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

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

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

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

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();

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

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

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

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

ध्यान दें कि commitNow, addToBackStack के साथ काम नहीं करता. इसके अलावा, आपके पास उन सभी FragmentTransactions को एक्ज़ीक्यूट करने का विकल्प है जिन्हें सबमिट किया जाना बाकी है commit() वे कॉल जो अभी तक executePendingTransactions() पर कॉल करने से नहीं की गई हैं. यह तरीका, 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 बार इस्तेमाल करता है setMaxLifecycle() ऑफ़-स्क्रीन फ़्रैगमेंट को STARTED स्थिति तक सीमित करने के लिए.

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

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

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

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

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

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

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