फ़्रैगमेंट ट्रांज़ैक्शन

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

हर लेन-देन को FragmentManager की ओर से मैनेज किए जाने वाले बैक स्टैक में सेव किया जा सकता है. इससे उपयोगकर्ता, फ़्रैगमेंट में हुए बदलावों के ज़रिए पीछे की ओर नेविगेट कर सकता है. यह सुविधा, गतिविधियों के ज़रिए पीछे की ओर नेविगेट करने की तरह ही है.

beginTransaction() को कॉल करके, FragmentManager से FragmentTransaction का एक इंस्टेंस पाया जा सकता है, जैसा कि इस उदाहरण में दिखाया गया है:

val fragmentManager = ...
val fragmentTransaction = fragmentManager.beginTransaction()

FragmentManager fragmentManager = ...
FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();

हर FragmentTransaction पर फ़ाइनल कॉल, लेन-देन को पक्का करना चाहिए. commit(), FragmentManager को कॉल सिग्नल भेजता है कि सभी ऑपरेशन, लेन-देन में जोड़ दिए गए हैं.

val fragmentManager = ...
// The fragment-ktx module provides a commit block that automatically
// calls beginTransaction and commit for you.
fragmentManager.commit {
    // Add operations here
}

FragmentManager fragmentManager = ...
FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();

// Add operations here

fragmentTransaction.commit();

फ़्रैगमेंट की स्थिति में हुए बदलावों को फिर से क्रम में लगाने की अनुमति दें

हर FragmentTransaction को setReorderingAllowed(true) का इस्तेमाल करना चाहिए:

supportFragmentManager.commit {
    ...
    setReorderingAllowed(true)
}

FragmentManager fragmentManager = ...
fragmentManager.beginTransaction()
    ...
    .setReorderingAllowed(true)
    .commit();

व्यवहार की कम्पैटिबिलिटी के लिए, रीऑर्डर करने का फ़्लैग डिफ़ॉल्ट रूप से चालू नहीं होता. हालांकि, FragmentManager को आपके FragmentTransaction को सही तरीके से लागू करने की अनुमति देना ज़रूरी है. खास तौर पर, जब यह बैक स्टैक पर काम करता है और एनिमेशन और ट्रांज़िशन चलाता है. फ़्लैग चालू करने से यह पक्का होता है कि अगर एक साथ कई लेन-देन किए जाते हैं, तो बीच में जोड़े गए और तुरंत बदले गए किसी भी फ़्रैगमेंट के लाइफ़साइकल में बदलाव नहीं होता या उनके ऐनिमेशन या ट्रांज़िशन लागू नहीं होते. ध्यान दें कि इस फ़्लैग का असर, लेन-देन के शुरू में होने वाले प्रोसेस और popBackStack() की मदद से लेन-देन को रिवर्स करने, दोनों पर पड़ता है.

फ़्रैगमेंट जोड़ना और हटाना

FragmentManager में कोई फ़्रैगमेंट जोड़ने के लिए, लेन-देन पर add() को कॉल करें. इस तरीके से, फ़्रैगमेंट के लिए कंटेनर का आईडी और उस फ़्रैगमेंट का क्लास नाम मिलता है जिसे जोड़ना है. जोड़ा गया फ़्रैगमेंट, RESUMED स्टेटस पर ले जाया जाता है. हमारा सुझाव है कि कंटेनर, व्यू हैरारकी का हिस्सा हो और वह FragmentContainerView हो.

होस्ट से किसी फ़्रैगमेंट को हटाने के लिए, remove() को कॉल करें. साथ ही, findFragmentById() या findFragmentByTag() की मदद से फ़्रैगमेंट मैनेजर से वापस पाया गया फ़्रैगमेंट इंस्टेंस पास करें. अगर फ़्रैगमेंट व्यू को पहले किसी कंटेनर में जोड़ा गया था, तो व्यू को कंटेनर से हटा दिया जाता है. हटाए गए फ़्रैगमेंट को DESTROYED स्थिति में ले जाया गया है.

किसी कंटेनर में मौजूद फ़्रैगमेंट को, आपके दिए गए किसी नए फ़्रैगमेंट क्लास के इंस्टेंस से बदलने के लिए, replace() का इस्तेमाल करें. replace() को कॉल करना, किसी कंटेनर में फ़्रैगमेंट के साथ remove() को कॉल करने और उसी कंटेनर में नया फ़्रैगमेंट जोड़ने जैसा है.

नीचे दिया गया कोड स्निपेट आपको एक फ़्रैगमेंट को दूसरे फ़्रैगमेंट से बदलने का तरीका बताता है:

// Create new fragment
val fragmentManager = // ...

// Create and commit a new transaction
fragmentManager.commit {
    setReorderingAllowed(true)
    // Replace whatever is in the fragment_container view with this fragment
    replace<ExampleFragment>(R.id.fragment_container)
}

// Create new fragment and transaction
FragmentManager fragmentManager = ...
FragmentTransaction transaction = fragmentManager.beginTransaction();
transaction.setReorderingAllowed(true);

// Replace whatever is in the fragment_container view with this fragment
transaction.replace(R.id.fragment_container, ExampleFragment.class, null);

// Commit the transaction
transaction.commit();

इस उदाहरण में, अगर कोई फ़्रैगमेंट फ़िलहाल R.id.fragment_container से पहचाने गए लेआउट कंटेनर में मौजूद है, तो ExampleFragment का एक नया इंस्टेंस इसे बदल देता है.

डिफ़ॉल्ट रूप से, FragmentTransaction में किए गए बदलाव, पिछली गतिविधियों में नहीं जोड़े जाते. इन बदलावों को सेव करने के लिए, FragmentTransaction पर addToBackStack() को कॉल करें. ज़्यादा जानकारी के लिए, फ़्रैगमेंट मैनेजर देखें.

कमिट करना एसिंक्रोनस है

commit() को कॉल करने पर, तुरंत लेन-देन नहीं होता. इसके बजाय, ट्रांज़ैक्शन को मुख्य यूज़र इंटरफ़ेस (यूआई) थ्रेड पर चलाने के लिए शेड्यूल किया जाता है. ऐसा करने के लिए ज़रूरी है. अगर ज़रूरी हो, तो अपने यूज़र इंटरफ़ेस (यूआई) थ्रेड पर फ़्रैगमेंट ट्रांज़ैक्शन को तुरंत चलाने के लिए, commitNow() को कॉल करें.

ध्यान दें कि commitNow को addToBackStack के साथ इस्तेमाल नहीं किया जा सकता. इसके अलावा, executePendingTransactions() को कॉल करके, commit() कॉल की मदद से सबमिट किए गए उन सभी FragmentTransactions को चलाया जा सकता है जो अब तक नहीं चले हैं. यह तरीका addToBackStack के साथ काम करता है.

इस्तेमाल के ज़्यादातर उदाहरणों के लिए, commit() का इस्तेमाल करना ही काफ़ी है.

ऑपरेशन का क्रम अहम है

FragmentTransaction में कार्रवाइयों का क्रम बहुत अहम होता है. खास तौर पर, setCustomAnimations() का इस्तेमाल करते समय. यह तरीका, दिए गए ऐनिमेशन को उसके बाद होने वाले सभी फ़्रैगमेंट ऑपरेशन पर लागू करता है.

supportFragmentManager.commit {
    setCustomAnimations(enter1, exit1, popEnter1, popExit1)
    add<ExampleFragment>(R.id.container) // gets the first animations
    setCustomAnimations(enter2, exit2, popEnter2, popExit2)
    add<ExampleFragment>(R.id.container) // gets the second animations
}

getSupportFragmentManager().beginTransaction()
        .setCustomAnimations(enter1, exit1, popEnter1, popExit1)
        .add(R.id.container, ExampleFragment.class, null) // gets the first animations
        .setCustomAnimations(enter2, exit2, popEnter2, popExit2)
        .add(R.id.container, ExampleFragment.class, null) // gets the second animations
        .commit()

फ़्रैगमेंट के लाइफ़साइकल को सीमित करना

FragmentTransactions, ट्रांज़ैक्शन के स्कोप में जोड़े गए अलग-अलग फ़्रैगमेंट की लाइफ़साइकल की स्थिति पर असर डाल सकता है. FragmentTransaction बनाते समय, setMaxLifecycle() दिए गए फ़्रैगमेंट के लिए ज़्यादा से ज़्यादा स्थिति सेट करता है. उदाहरण के लिए, ViewPager2, ऑफ़-स्क्रीन फ़्रैगमेंट को STARTED स्टेटस तक सीमित करने के लिए, setMaxLifecycle() का इस्तेमाल करता है.

फ़्रैगमेंट के व्यू दिखाना और छिपाना

कंटेनर में जोड़े गए फ़्रैगमेंट के व्यू को दिखाने और छिपाने के लिए, FragmentTransaction तरीकोंshow() और hide() का इस्तेमाल करें. ये तरीके, फ़्रैगमेंट के लाइफ़साइकल पर असर डाले बिना, फ़्रैगमेंट के व्यू की विज़िबिलिटी सेट करते हैं.

किसी फ़्रेगमेंट में व्यू की दिखने की स्थिति को टॉगल करने के लिए, फ़्रेगमेंट ट्रांज़ैक्शन का इस्तेमाल करना ज़रूरी नहीं है. हालांकि, ये तरीके उन मामलों में काम के होते हैं जहां आपको दिखने की स्थिति में किए गए बदलावों को बैक स्टैक पर मौजूद ट्रांज़ैक्शन से जोड़ना हो.

फ़्रैगमेंट को अटैच करना और अलग करना

FragmentTransaction तरीका detach(), यूज़र इंटरफ़ेस (यूआई) से फ़्रैगमेंट को अलग करता है और इसके व्यू हैरारकी को खत्म कर देता है. फ़्रैगमेंट उसी स्थिति (STOPPED) में बना रहता है जिसमें उसे पिछली स्टैक पर रखा गया था. इसका मतलब है कि फ़्रैगमेंट को यूज़र इंटरफ़ेस (यूआई) से हटा दिया गया है, लेकिन इसे अब भी फ़्रैगमेंट मैनेजर मैनेज करता है.

attach() वाला तरीका, उस फ़्रैगमेंट को फिर से जोड़ता है जिससे इसे पहले हटाया गया था. ऐसा करने पर, इसकी व्यू हैरारकी फिर से बनाई जाती है, यूज़र इंटरफ़ेस (यूआई) से अटैच की जाती है, और दिखाई जाती है.

FragmentTransaction को कार्रवाइयों का सिंगल ऐटॉमिक सेट माना जाता है. इसलिए, एक ही ट्रांज़ैक्शन में, एक फ़्रैगमेंट इंस्टेंस पर detach और attach, दोनों को कॉल करने पर, एक-दूसरे को असरदार तरीके से रद्द कर दिया जाता है. इस तरह, फ़्रैगमेंट का यूज़र इंटरफ़ेस (यूआई) खत्म होने और तुरंत फिर से बनाने से बचा जा सकता है. अगर commit() का इस्तेमाल करना है, तो executePendingOperations() से अलग किए गए अलग-अलग ट्रांज़ैक्शन का इस्तेमाल करें. अगर आपको फ़्रैगमेंट को अलग करना है और तुरंत फिर से अटैच करना है, तो ट्रांज़ैक्शन का इस्तेमाल करें.