रनटाइम के दौरान,
FragmentManager
फ़्रैगमेंट जोड़ सकते हैं, हटा सकते हैं, बदल सकते हैं, और अन्य कार्रवाइयां कर सकते हैं
उपयोगकर्ता इंटरैक्शन की प्रतिक्रिया में. फ़्रैगमेंट का हर सेट बदलता है, जो
कमिट को ट्रांज़ैक्शन कहा जाता है और इसमें क्या-क्या किया जा सकता है, यह बताया जा सकता है
FragmentTransaction
क्लास. एक ही ट्रांज़ैक्शन में कई कार्रवाइयों को ग्रुप किया जा सकता है. उदाहरण के लिए,
ट्रांज़ैक्शन कई फ़्रैगमेंट जोड़ या बदल सकता है. इस ग्रुप को
तब उपयोगी होता है जब आपके पेज
एक जैसी स्क्रीन, जैसे कि स्प्लिट व्यू के साथ.
हर लेन-देन को ऐसी बैक स्टैक में सेव किया जा सकता है जिसे
FragmentManager
की मदद से, उपयोगकर्ता
फ़्रैगमेंट में होने वाले बदलाव—यही गतिविधियों के ज़रिए पीछे नेविगेट करने जैसा ही है.
आपको FragmentManager
से FragmentTransaction
का एक इंस्टेंस मिल सकता है
beginTransaction()
पर कॉल करके, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है:
Kotlin
val fragmentManager = ... val fragmentTransaction = fragmentManager.beginTransaction()
Java
FragmentManager fragmentManager = ... FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
हर FragmentTransaction
पर फ़ाइनल कॉल करने के लिए लेन-देन करना ज़रूरी है.
commit()
से, FragmentManager
को सभी कार्रवाइयां करने के सिग्नल मिलते हैं
लेन-देन में जोड़े गए हैं.
Kotlin
val fragmentManager = ... // The fragment-ktx module provides a commit block that automatically // calls beginTransaction and commit for you. fragmentManager.commit { // Add operations here }
Java
FragmentManager fragmentManager = ... FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction(); // Add operations here fragmentTransaction.commit();
फ़्रैगमेंट की स्थिति के बदलावों को फिर से क्रम में लगाने की अनुमति दें
हर FragmentTransaction
में setReorderingAllowed(true)
का इस्तेमाल करना चाहिए:
Kotlin
supportFragmentManager.commit { ... setReorderingAllowed(true) }
Java
FragmentManager fragmentManager = ... fragmentManager.beginTransaction() ... .setReorderingAllowed(true) .commit();
व्यवहार के साथ काम करने के लिए, फिर से ऑर्डर करने वाला फ़्लैग डिफ़ॉल्ट रूप से चालू नहीं होता.
हालांकि, FragmentManager
को सही तरीके से काम करने की अनुमति देना ज़रूरी है
आपका FragmentTransaction
. खास तौर पर, जब यह बैक स्टैक पर काम करता हो
और ऐनिमेशन और ट्रांज़िशन चलाता है. फ़्लैग को चालू करने से यह पक्का होता है कि अगर
कई ट्रांज़ैक्शन एक साथ किए जाते हैं, जैसे कि इंटरमीडिएट फ़्रैगमेंट
(यानी वे विज्ञापन जिन्हें जोड़ा जाता है और बाद में तुरंत बदल दिया जाता है)
लाइफ़साइकल बदलाव करना या उनके ऐनिमेशन या ट्रांज़िशन को लागू करना. ध्यान दें कि
यह फ़्लैग लेन-देन के शुरुआती निष्पादन और उसे वापस लेने, दोनों पर असर डालता है
popBackStack()
के साथ लेन-देन.
फ़्रैगमेंट जोड़ना और हटाना
FragmentManager
में फ़्रैगमेंट जोड़ने के लिए, कॉल करें
add()
लेन-देन पर लागू होता है. इस तरीके से ये फ़ाइलें मिलती हैं
फ़्रैगमेंट के लिए कंटेनर का आईडी और
फ़्रैगमेंट जिसे आपको जोड़ना है. जोड़े गए फ़्रैगमेंट को RESUMED
में ले जाया गया है
राज्य. हमारा सुझाव है कि कंटेनर
FragmentContainerView
जो कि व्यू हैरारकी का हिस्सा हो.
होस्ट से कोई फ़्रैगमेंट हटाने के लिए, कॉल करें
remove()
फ़्रैगमेंट से मिले फ़्रैगमेंट इंस्टेंस में पास करना
findFragmentById()
या findFragmentByTag()
से मैनेजर मिलेगा.
अगर फ़्रैगमेंट का व्यू पहले किसी कंटेनर में जोड़ा गया था, तो व्यू
इस बिंदु पर कंटेनर से हटा दिया जाता है. हटाए गए फ़्रैगमेंट को दूसरी जगह ले जाया गया है
DESTROYED
स्थिति के लिए.
इस्तेमाल की जाने वाली चीज़ें
replace()
कंटेनर में मौजूदा फ़्रैगमेंट को बदलने के लिए,
नई फ़्रैगमेंट क्लास का इस्तेमाल करें. replace()
को कॉल करने के बराबर है
कंटेनर में फ़्रैगमेंट के साथ remove()
को कॉल किया जा रहा है और नया
फ़्रैगमेंट को उस कंटेनर में ले जाना होगा.
नीचे दिया गया कोड स्निपेट आपको एक फ़्रैगमेंट को दूसरे फ़्रैगमेंट से बदलने का तरीका बताता है:
Kotlin
// 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) }
Java
// 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()
के इस्तेमाल के दौरान अहम है. यह
तरीका, दिए गए ऐनिमेशन को उन सभी फ़्रैगमेंट ऑपरेशन पर लागू करता है जिनमें
फ़ॉलो करें.
Kotlin
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 }
Java
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()
का इस्तेमाल किया जाता है, तो
अगर आपको अलग करना हो और फिर तुरंत फ़्रैगमेंट फिर से अटैच करना हो.