फ़्रैगमेंट बनाना

फ़्रैगमेंट, उपयोगकर्ता के मॉड्यूलर हिस्से को दिखाता है का इस्तेमाल किया जा सकता है. फ़्रैगमेंट का अपना लाइफ़साइकल होता है और यह खुद के इनपुट इवेंट होते हैं और आपके पास फ़्रैगमेंट को जोड़ने या हटाने के लिए, गतिविधि चल रही है.

इस दस्तावेज़ में फ़्रैगमेंट बनाने और उसे किसी गतिविधि में शामिल करने का तरीका बताया गया है.

अपना एनवायरमेंट सेट अप करें

फ़्रैगमेंट को इस पर निर्भरता की ज़रूरत होती है: AndroidX फ़्रैगमेंट लाइब्रेरी. आपको ये काम करने होंगे Google Maven रिपॉज़िटरी जोड़ना आपके प्रोजेक्ट की settings.gradle फ़ाइल में जोड़ा जा सकता है, ताकि इस डिपेंडेंसी को शामिल किया जा सके.

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        ...
    }
}

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        ...
    }
}

अपने प्रोजेक्ट में AndroidX फ़्रैगमेंट लाइब्रेरी शामिल करने के लिए, ये जोड़ें आपके ऐप्लिकेशन की build.gradle फ़ाइल पर डिपेंडेंसी:

dependencies {
    def fragment_version = "1.8.9"

    // Java language implementation
    implementation "androidx.fragment:fragment:$fragment_version"
    // Kotlin
    implementation "androidx.fragment:fragment-ktx:$fragment_version"
}

dependencies {
    val fragment_version = "1.8.9"

    // Java language implementation
    implementation("androidx.fragment:fragment:$fragment_version")
    // Kotlin
    implementation("androidx.fragment:fragment-ktx:$fragment_version")
}

फ़्रैगमेंट क्लास बनाना

फ़्रैगमेंट बनाने के लिए, AndroidX बढ़ाएं Fragment क्लास, और बदलें आपके ऐप्लिकेशन के लॉजिक को इंसर्ट करने के तरीके, वैसे ही जैसे Activity क्लास. मिनिमम वह फ़्रैगमेंट जो अपने लेआउट को तय करता है, अपने फ़्रैगमेंट का लेआउट रिसॉर्स दें को बेस कंस्ट्रक्टर से बदल दें, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है:

class ExampleFragment : Fragment(R.layout.example_fragment)

class ExampleFragment extends Fragment {
    public ExampleFragment() {
        super(R.layout.example_fragment);
    }
}

फ़्रैगमेंट लाइब्रेरी में, खास तरह के फ़्रैगमेंट बेस क्लास भी उपलब्ध होती हैं:

DialogFragment

फ़्लोटिंग डायलॉग बॉक्स दिखाता है. डायलॉग बनाने के लिए इस क्लास का इस्तेमाल करना अच्छा है यह डायलॉग बॉक्स में डायलॉग हेल्पर के तरीके का इस्तेमाल करने के बजाय फ़्रैगमेंट के तौर पर Activity क्लास Dialog की बनाने और क्लीनअप की प्रोसेस अपने-आप मैनेज करती है. DialogFragment के साथ डायलॉग दिखाना देखें ज़्यादा जानकारी के लिए.

PreferenceFragmentCompat

इनका क्रम दिखाता है Preference ऑब्जेक्ट सूची. PreferenceFragmentCompat का इस्तेमाल इन कामों के लिए किया जा सकता है अपने ऐप्लिकेशन के लिए, सेटिंग की स्क्रीन बनाएं.

किसी गतिविधि में कोई फ़्रैगमेंट जोड़ें

आम तौर पर, आपका फ़्रैगमेंट किसी AndroidX में एम्बेड होना चाहिए FragmentActivity से यूज़र इंटरफ़ेस (यूआई) का कोई हिस्सा उस गतिविधि के लेआउट में जोड़ सकता है. FragmentActivity अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है यह इसकी बेस क्लास है: AppCompatActivity, इसलिए, अगर आपने पुराना डेटा डालने के लिए पहले से ही AppCompatActivity को सब-क्लास किया हुआ है साथ काम करता है, तो आपको अपनी गतिविधि में बदलाव करने की ज़रूरत नहीं है बेस क्लास.

आप चाहें, तो अपने फ़्रैगमेंट को ऐक्टिविटी के व्यू हैरारकी (व्यू और व्यू ग्रुप के लेआउट का क्रम) में या तो जोड़ दें फ़्रैगमेंट की परिभाषा तय करके फ़्रैगमेंट कंटेनर में और फिर प्रोग्राम बनाकर अपनी गतिविधि में फ़्रैगमेंट जोड़ना. दोनों ही मामलों में, आपको जोड़ें FragmentContainerView वह जगह तय करता है जहां फ़्रैगमेंट को गतिविधि के व्यू हैरारकी (व्यू और व्यू ग्रुप के लेआउट का क्रम) के हिसाब से. हमारा सुझाव है कि आप हमेशा फ़्रैगमेंट के कंटेनर के तौर पर FragmentContainerView, जैसा FragmentContainerView में ऐसे फ़्रैगमेंट के सुधार शामिल हैं जिन्हें अन्य FrameLayout जैसे व्यू ग्रुप उपलब्ध नहीं कराते.

एक्सएमएल के ज़रिए फ़्रैगमेंट जोड़ें

अपनी गतिविधि के लेआउट के एक्सएमएल में, साफ़ तौर पर कोई फ़्रैगमेंट जोड़ने के लिए, FragmentContainerView एलिमेंट.

यहां ऐक्टिविटी लेआउट का एक उदाहरण दिया गया है, जिसमें एक FragmentContainerView:

<!-- res/layout/example_activity.xml -->
<androidx.fragment.app.FragmentContainerView
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/fragment_container_view"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    andr>oid:name="com.example.ExampleFragment" /

android:name एट्रिब्यूट, Fragment की क्लास का नाम इंस्टैंशिएट करें. जब गतिविधि का लेआउट इनफ़्लेट होता है, तो बताया गया फ़्रैगमेंट इंस्टैंशिएट किया जाता है, onInflate() को नए इंस्टैंशिएट किए गए फ़्रैगमेंट पर कॉल किया जाता है और FragmentTransaction FragmentManager में फ़्रैगमेंट जोड़ने के लिए बनाया गया है.

प्रोग्राम के हिसाब से फ़्रैगमेंट जोड़ना

प्रोग्राम के हिसाब से अपनी गतिविधि के लेआउट में कोई फ़्रैगमेंट जोड़ने के लिए, लेआउट फ़्रैगमेंट कंटेनर के तौर पर काम करने के लिए, इसमें FragmentContainerView शामिल होना चाहिए, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है:

<!-- res/layout/example_activity.xml -->
<androidx.fragment.app.FragmentContainerView
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/fragment_container_view"
    android:layout_width="match_parent"
    android:>layout_height="match_parent" /

एक्सएमएल वाले तरीके के उलट, android:name एट्रिब्यूट का इस्तेमाल FragmentContainerView यहां है, इसलिए कोई भी खास फ़्रैगमेंट अपने-आप नहीं बदलता है इंस्टैंशिएट किया हुआ. इसके बजाय, FragmentTransaction का इस्तेमाल किसी फ़्रैगमेंट को इंस्टैंशिएट करने और उसे गतिविधि के लेआउट में जोड़ने के लिए किया जाता है.

अपनी गतिविधि के दौरान, फ़्रैगमेंट ट्रांज़ैक्शन किए जा सकते हैं, जैसे कि कोई फ़्रैगमेंट जोड़ना, हटाना या बदलना. अपने FragmentActivity में, ये काम किए जा सकते हैं उदाहरण के तौर पर, FragmentManager, जो FragmentTransaction बनाने के लिए इस्तेमाल किया जा सकता है. इसके बाद, इंस्टैंशिएट किया जा सकता है फ़्रैगमेंट, इसका इस्तेमाल करके आपकी गतिविधि के onCreate() तरीके में FragmentTransaction.add(), आपके लेआउट और फ़्रैगमेंट में कंटेनर का ViewGroup आईडी पास कर रहे हैं क्लास को जोड़ना चाहते हैं और फिर लेन-देन करना चाहते हैं, जैसा कि नीचे दिया गया उदाहरण:

class ExampleActivity : AppCompatActivity(R.layout.example_activity) {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        if (savedInstanceState == null) {
            supportFragmentManager.commit {
                setReorderingAllowed(true)
                add<ExampleFragment>(R.id.fragment_container_view)
            }
        }
    }
}

public class ExampleActivity extends AppCompatActivity {
    public ExampleActivity() {
        super(R.layout.example_activity);
    }
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (savedInstanceState == null) {
            getSupportFragmentManager().beginTransaction()
                .setReorderingAllowed(true)
                .add(R.id.fragment_container_view, ExampleFragment.class, null)
                .commit();
        }
    }
}

पिछले उदाहरण में, ध्यान दें कि फ़्रैगमेंट ट्रांज़ैक्शन सिर्फ़ बनाया गया है जब savedInstanceState, null हो. इससे यह पक्का होता है कि फ़्रैगमेंट गतिविधि पहली बार बनाने पर, इसे सिर्फ़ एक बार जोड़ा जाता है. जब कॉन्फ़िगरेशन में बदलाव होता है और गतिविधि को फिर से बनाया जाता है, savedInstanceState अब null नहीं है, और फ़्रैगमेंट को इसकी ज़रूरत नहीं है दूसरी बार जोड़ा जाना चाहिए, क्योंकि फ़्रैगमेंट अपने-आप पहले जैसा हो जाता है savedInstanceState से मिला डेटा.

अगर आपके फ़्रैगमेंट को कुछ शुरुआती डेटा की ज़रूरत है, तो FragmentTransaction.add() को कॉल करते समय Bundle देकर, आपके फ़्रैगमेंट में आर्ग्युमेंट पास किए जा सकते हैं, जैसा कि यहां दिखाया गया है:

class ExampleActivity : AppCompatActivity(R.layout.example_activity) {
      override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        if (savedInstanceState == null) {
            val bundle = bundleOf("some_int" to 0)
            supportFragmentManager.commit {
                setReorderingAllowed(true)
         <       addExampleFragment>(R.id.fragment_container_view, args = bundle)
            }
        }
    }
}

public class ExampleActivity extends AppCompatActivity {
    public ExampleActivity() {
        super(R.layout.example_activity);
    }
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (savedInstanceState == null) {
            Bundle bundle = new Bundle();
            bundle.putInt("some_int", 0);

            getSupportFragmentManager().beginTransaction()
                .setReorderingAllowed(true)
                .add(R.id.fragment_container_view, ExampleFragment.class, bundle)
                .commit();
        }
    }
}

इसके बाद तर्क Bundle आपके फ़्रैगमेंट में से इसके ज़रिए वापस लाए जा सकते हैं कॉल किया जा रहा है requireArguments(), साथ ही, डेटा वापस पाने के लिए सही Bundle गेटर तरीकों का इस्तेमाल किया जा सकता है का इस्तेमाल करें.

class ExampleFragment : Fragment(R.layout.example_fragment) {
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        val someInt = requireArguments().getInt("some_int")
        ...
    }
}

class ExampleFragment extends Fragment {
    public ExampleFragment() {
        super(R.layout.example_fragment);
    }

    @Override
    public void onViewCreated(@NonNull View view, Bundle savedInstanceState) {
        int someInt = requireArguments().getInt("some_int");
        ...
    }
}

यह भी देखें:

फ़्रैगमेंट ट्रांज़ैक्शन और FragmentManager के बारे में ज़्यादा जानकारी दी गई है फ़्रैगमेंट मैनेजर गाइड में जाएं.