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

FragmentManager है आपके ऐप्लिकेशन के फ़्रैगमेंट पर कार्रवाइयां करने के लिए ज़िम्मेदार क्लास, जैसे जैसे, उन्हें जोड़ना, हटाना या बदलना और पिछली स्टैक में जोड़ना.

अगर आप FragmentManager का इस्तेमाल कर रहे हैं, तो हो सकता है कि आप इसके साथ सीधे तौर पर इंटरैक्ट न करें Jetpack नेविगेशन लाइब्रेरी में मौजूद डेटा एक्सपोर्ट करता है. यह लाइब्रेरी, आपकी ओर से FragmentManager. हालांकि, फ़्रैगमेंट का इस्तेमाल करने वाला कोई भी ऐप्लिकेशन FragmentManager का इस्तेमाल कुछ स्तर पर किया है, इसलिए यह समझना ज़रूरी है कि क्या काम करती है और कैसे करना है.

इस पेज में इन चीज़ों के बारे में बताया गया है:

  • FragmentManager को ऐक्सेस करने का तरीका.
  • आपकी गतिविधियों और फ़्रैगमेंट में FragmentManager की भूमिका.
  • FragmentManager में पिछली गतिविधियों को मैनेज करने का तरीका.
  • अपने फ़्रैगमेंट के लिए डेटा और डिपेंडेंसी देने का तरीका.

फ़्रैगमेंट मैनेजर को ऐक्सेस करना

किसी गतिविधि या किसी फ़्रैगमेंट से FragmentManager को ऐक्सेस किया जा सकता है.

FragmentActivity और इसकी सब-क्लास, जैसे कि AppCompatActivity, के पास से FragmentManager का ऐक्सेस है: getSupportFragmentManager() तरीका.

फ़्रैगमेंट, एक या उससे ज़्यादा चाइल्ड फ़्रैगमेंट होस्ट कर सकते हैं. अंदर की फ़ोटो एक फ़्रैगमेंट है, तो आपको उस FragmentManager का रेफ़रंस मिल सकता है जो फ़्रैगमेंट में बच्चे का नाम getChildFragmentManager(). अगर आपक�� इसके होस्ट FragmentManager को ऐक्सेस करना है, तो getParentFragmentManager().

दोनों के बीच के संबंध को समझने के लिए यहां कुछ उदाहरण दिए गए हैं फ़्रैगमेंट, उनके होस्ट, और FragmentManager इंस्टेंस से जुड़े हर एक के साथ.

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

पहली इमेज में दो उदाहरण दिखाए गए हैं. हर उदाहरण में एक ऐक्टिविटी होस्ट है. कॉन्टेंट बनाने इन दोनों उदाहरणों में होस्ट गतिविधि, उपयोगकर्ता को BottomNavigationView जो होस्ट फ़्रैगमेंट को अलग स्क्रीन पर. हर स्क्रीन को एक अलग फ़्रैगमेंट के तौर पर लागू किया जाता है.

पहले उदाहरण में मौजूद होस्ट फ़्रैगमेंट, ऐसे दो चाइल्ड फ़्रैगमेंट होस्ट करता है जो स्प्लिट व्यू स्क्रीन हो सकती है. उदाहरण 2 में होस्ट फ़्रैगमेंट किसी सिंगल चाइल्ड फ़्रैगमेंट, जो किसी पेज का डिसप्ले फ़्रै��मेंट बनता है व्यू को स्वाइप करें पर टैप करें.

इस सेटअप को देखते हुए, आपको ऐसा लग सकता है कि हर होस्ट के पास FragmentManager इससे जुड़ा होता है, जो इसके चाइल्ड फ़्रैगमेंट को मैनेज करता है. इस इमेज में दिखाया गया है कि supportFragmentManager के बीच प्रॉपर्टी मैपिंग के साथ इमेज 2, parentFragmentManager और childFragmentManager.

हर होस्ट से उसका अपना फ़्रैगमेंट मैनेजर जुड़ा होता है जो अपने चाइल्ड फ़्रैगमेंट को मैनेज करता है
दूसरी इमेज. हर होस्ट का अपना होता है इससे जुड़ा FragmentManager, जो मैनेज करता है चाइल्ड फ़्रैगमेंट.

रेफ़रंस के लिए सही FragmentManager प्रॉपर्टी, इस बात पर निर्भर करती है कि कहां कॉलसाइट, फ़्रैगमेंट हैरारकी में है और इसमें किस फ़्रैगमेंट मैनेजर आप उसे ऐक्सेस करने की कोशिश कर रहे हैं.

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

चाइल्ड फ़्रैगमेंट

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

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

चाइल्ड फ़्रैगमेंट के लिए, इस्तेमाल के अन्य उदाहरण यहां दिए गए हैं:

  • स्क्रीन स्लाइड, चाइल्ड की सीरीज़ को मैनेज करने के लिए, पैरंट फ़्रैगमेंट में ViewPager2 का इस्तेमाल किया जा रहा है फ़्रैगमेंट व्यू.
  • मिलती-जुलती स्क्रीन के सेट में सब-नेविगेशन.
  • जेटपैक नेविगेशन, चाइल्ड फ़्रैगमेंट का इस्तेमाल अलग-अलग डेस्टिनेशन के तौर पर करता है. अगर आप ऐक्टिविटी, सिंगल पैरंट NavHostFragment को होस्ट करती है और पूरी जानकारी देती है जिसमें उपयोगकर्ता एक से दूसरी जगह जाने पर भी अलग-अलग चाइल्ड डेस्टिनेशन फ़्रैगमेंट का इस्तेमाल करते हैं आपका ऐप्लिकेशन.

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

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

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

आपके कॉल करने पर addToBackStack() लेन-देन में, लेन-देन में जैसे कि कई फ़्रैगमेंट जोड़ना या कई फ़्रैगमेंट को एक से ज़्यादा फ़्रैगमेंट में बदलना कंटेनर.

पिछली गतिविधियों के पॉप-अप होने पर, ये सभी संक्रियाएं, एक अणुओं से जुड़ी क्रिया की तरह उलटी हो जाती हैं. हालांकि, अगर आपने popBackStack() कॉल से पहले के अतिरिक्त लेन-देन. लेन-देन के लिए, इन कार्रवाइयों के लिए addToBackStack() का इस्तेमाल नहीं किया उलटा न करें. इसलिए, एक FragmentTransaction में, इससे बचें ऐसे ट्रांज़ैक्शन को हासिल करना जो पिछली गतिविधियों पर असर डालते हैं. साथ ही, जो लेन-देन नहीं करते हैं.

लेन-देन करें

लेआउट कंटेनर में फ़्रैगमेंट दिखाने के लिए, FragmentManager का इस्तेमाल करें FragmentTransaction बनाने के लिए. लेन-देन के दौरान, कोई कार्रवाई करो add() या replace() कंटेनर पर काम करते हैं.

उदाहरण के लिए, कोई सामान्य FragmentTransaction ऐसा दिख सकता है:

Kotlin

supportFragmentManager.commit {
   replace<ExampleFragment>(R.id.fragment_container)
   setReorderingAllowed(true)
   addToBackStack("name") // Name can be null
}

Java

FragmentManager fragmentManager = getSupportFragmentManager();
fragmentManager.beginTransaction()
    .replace(R.id.fragment_container, ExampleFragment.class, null)
    .setReorderingAllowed(true)
    .addToBackStack("name") // Name can be null
    .commit();

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

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

कॉल से जुड़ी सुविधा addToBackStack() ट्रांज़ैक्शन को बैक स्टैक में भेजता है. उपयोगकर्ता बाद में 'वापस जाएं' पर टैप करके पिछले फ़्रैगमेंट को वापस लाएं बटन. अगर आपने एक पेज में कई फ़्रैगमेंट जोड़े या हटाए हैं लेन-देन के बाद, बैक स्टैक होने पर वे सभी कार्रवाइयां पहले जैसी नहीं हो जाती हैं पॉप-अप होता है. addToBackStack() कॉल में दिया गया वैकल्पिक नाम आपको तो आपके पास इसका इस्तेमाल करके किसी खास लेन-देन पर वापस जाने की सुविधा होती है popBackStack().

अगर आप ऐसा पेमेंट करते समय addToBackStack() को कॉल नहीं करते एक फ़्रैगमेंट हटा देता है, तो हटाया गया फ़्रैगमेंट तब खत्म हो जाता है, जब लेन-देन तय होता है और उपयोगकर्ता वापस इस पर नहीं जा सकता. अगर आपको किसी फ़्रैगमेंट को हटाते समय, addToBackStack() को कॉल करें, फिर फ़्रैगमेंट यह होगा उपयोगकर्ता के वापस नेविगेट करने पर, यह सिर्फ़ STOPPED के लिए और बाद में RESUMED पर सेट होगा. इसका व्यू इस मामले में is नष्ट हो गया है. ज़्यादा जानकारी के लिए, यह देखें फ़्रैगमेंट का लाइफ़साइकल.

मौजूदा फ़्रैगमेंट ढूंढें

आपको लेआउट कंटेनर में मौजूदा फ़्रैगमेंट का रेफ़रंस मिल सकता है इसका इस्तेमाल करके findFragmentById(). दिए गए आईडी के हिसाब से फ़्रैगमेंट खोजने के लिए findFragmentById() का इस्तेमाल करें, जब एक्सएमएल से या कंटेनर आईडी के आधार पर, FragmentTransaction. यहां एक उदाहरण दिया गया है:

Kotlin

supportFragmentManager.commit {
   replace<ExampleFragment>(R.id.fragment_container)
   setReorderingAllowed(true)
   addToBackStack(null)
}
...
val fragment: ExampleFragment =
        supportFragmentManager.findFragmentById(R.id.fragment_container) as ExampleFragment

Java

FragmentManager fragmentManager = getSupportFragmentManager();
fragmentManager.beginTransaction()
    .replace(R.id.fragment_container, ExampleFragment.class, null)
    .setReorderingAllowed(true)
    .addToBackStack(null)
    .commit();
...
ExampleFragment fragment =
        (ExampleFragment) fragmentManager.findFragmentById(R.id.fragment_container);

इसके अलावा, आप किसी फ़्रैगमेंट के लिए यूनीक टैग असाइन कर सकते हैं और इसका इस्तेमाल करके रेफ़रंस findFragmentByTag(). ऐसे फ़्रैगमेंट के लिए, android:tag एक्सएमएल एट्रिब्यूट का इस्तेमाल करके टैग असाइन किया जा सकता है आपके लेआउट में या add() या replace() के दौरान तय किए गए हैं FragmentTransaction के अंदर हुई कार्रवाई.

Kotlin

supportFragmentManager.commit {
   replace<ExampleFragment>(R.id.fragment_container, "tag")
   setReorderingAllowed(true)
   addToBackStack(null)
}
...
val fragment: ExampleFragment =
        supportFragmentManager.findFragmentByTag("tag") as ExampleFragment

Java

FragmentManager fragmentManager = getSupportFragmentManager();
fragmentManager.beginTransaction()
    .replace(R.id.fragment_container, ExampleFragment.class, null, "tag")
    .setReorderingAllowed(true)
    .addToBackStack(null)
    .commit();
...
ExampleFragment fragment = (ExampleFragment) fragmentManager.findFragmentByTag("tag");

चाइल्ड और सिबलिंग फ़्रैगमेंट के लिए ध्यान देने वाली खास बातें

फ़्रैगमेंट बैक स्टैक को सिर्फ़ एक FragmentManager कंट्रोल कर सकता है किसी भी समय मिल सकता है. अगर आपका ऐप्लिकेशन या अगर आपका ऐप्लिकेशन चाइल्ड फ़्रैगमेंट का इस्तेमाल करता है, तो FragmentManager को आपके ऐप्लिकेशन के मुख्य नेविगेशन को मैनेज करने के लिए डिज़ाइन किया गया है.

फ़्रैगमेंट ट्रांज़ैक्शन में मुख्य नेविगेशन फ़्रैगमेंट तय करने के लिए, कॉल करो setPrimaryNavigationFragment() फ़्रैगमेंट के उस इंस्टेंस में पास हो रहा है जिसका childFragmentManager के पास मुख्य कंट्रोल होता है.

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

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

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

एक से ज़्यादा बैक स्टैक के साथ काम करें

कुछ मामलों में, आपके ऐप्लिकेशन को एक से ज़्यादा बैक स्टैक के साथ काम करने की ज़रूरत पड़ सकती है. एक कॉमन उदाहरण के लिए, अगर आपका ऐप्लिकेशन सबसे नीचे वाले नेविगेशन बार का इस्तेमाल करता है. FragmentManager ने तो saveBackStack() के साथ कई बैक स्टैक का इस्तेमाल किया जा सकता है और restoreBackStack() तरीके. इन तरीकों की मदद से, एक से दूसरे प्लैटफ़ॉर्म पर स्विच किया जा सकता है स्टैक को सेव किया जा सकता है.

saveBackStack(), popBackStack() को कॉल करने की तरह ही काम करता है. हालांकि, यह विकल्प विकल्प के तौर पर काम करता है name पैरामीटर: तय लेन-देन और उसके बाद के सभी लेन-देन स्टैक पॉप अप होते हैं. अंतर यह है कि saveBackStack() पॉप-अप में सभी फ़्रैगमेंट की स्थिति लेन-देन.

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

Kotlin

supportFragmentManager.commit {
  replace<ExampleFragment>(R.id.fragment_container)
  setReorderingAllowed(true)
  addToBackStack("replacement")
}

Java

supportFragmentManager.beginTransaction()
  .replace(R.id.fragment_container, ExampleFragment.class, null)
  // setReorderingAllowed(true) and the optional string argument for
  // addToBackStack() are both required if you want to use saveBackStack()
  .setReorderingAllowed(true)
  .addToBackStack("replacement")
  .commit();

इस स्थिति में, आप इस खंड लेन-देन और स्थिति saveBackStack() पर कॉल करके ExampleFragment:

Kotlin

supportFragmentManager.saveBackStack("replacement")

Java

supportFragmentManager.saveBackStack("replacement");

सभी को वापस लाने के लिए, आप इसी नाम पैरामीटर के साथ restoreBackStack() को कॉल कर सकते हैं ट्रांज़ैक्शन की जानकारी और सेव की गई सभी फ़्रैगमेंट स्थितियां:

Kotlin

supportFragmentManager.restoreBackStack("replacement")

Java

supportFragmentManager.restoreBackStack("replacement");

अपने फ़्रैगमेंट के लिए डिपेंडेंसी दें

कोई फ़्रैगमेंट जोड़ते समय, उसे मैन्युअल तरीके से इंस्टैंशिएट किया जा सकता है और उसे FragmentTransaction में जोड़ें.

Kotlin

fragmentManager.commit {
    // Instantiate a new instance before adding
    val myFragment = ExampleFragment()
    add(R.id.fragment_view_container, myFragment)
    setReorderingAllowed(true)
}

Java

// Instantiate a new instance before adding
ExampleFragment myFragment = new ExampleFragment();
fragmentManager.beginTransaction()
    .add(R.id.fragment_view_container, myFragment)
    .setReorderingAllowed(true)
    .commit();

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

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

अपने फ़्रैगमेंट को डिपेंडेंसी देने या कस्टम फ़्रैगमेंट कंस्ट्रक्टर के बजाय, को�� कस्टम FragmentFactory सब-क्लास बनाएं और फिर ओवरराइड करें FragmentFactory.instantiate. इसके बाद, इस ऐप्लिकेशन से FragmentManager की डिफ़ॉल्ट फ़ैक्ट्री को बदला जा सकता है को पसंद के मुताबिक बनाया जा सकता है, जिसे बाद में आपके फ़्रैगमेंट को इंस्टैंशिएट करने के लिए इस्तेमाल किया जाता है.

मान लें कि आपके पास एक DessertsFragment है, जिस पर आपके शहर की लोकप्रिय मिठाइयां और DessertsFragment की उस DessertsRepository क्लास पर निर्भर करती है जो इसे उपलब्ध कराती है आपके उपयोगकर्ता को सही यूज़र इंटरफ़ेस (यूआई) दिखाने के लिए इसकी ज़रूरत होती है.

DessertsRepository की ज़रूरत के लिए, DessertsFragment तय किया जा सकता है इंस्टेंस को अपने कंस्ट्रक्टर में शामिल कर देता है.

Kotlin

class DessertsFragment(val dessertsRepository: DessertsRepository) : Fragment() {
    ...
}

Java

public class DessertsFragment extends Fragment {
    private DessertsRepository dessertsRepository;

    public DessertsFragment(DessertsRepository dessertsRepository) {
        super();
        this.dessertsRepository = dessertsRepository;
    }

    // Getter omitted.

    ...
}

FragmentFactory को आसानी से लागू करने पर, यह कुछ ऐसा दिख सकता है हैं.

Kotlin

class MyFragmentFactory(val repository: DessertsRepository) : FragmentFactory() {
    override fun instantiate(classLoader: ClassLoader, className: String): Fragment =
            when (loadFragmentClass(classLoader, className)) {
                DessertsFragment::class.java -> DessertsFragment(repository)
                else -> super.instantiate(classLoader, className)
            }
}

Java

public class MyFragmentFactory extends FragmentFactory {
    private DessertsRepository repository;

    public MyFragmentFactory(DessertsRepository repository) {
        super();
        this.repository = repository;
    }

    @NonNull
    @Override
    public Fragment instantiate(@NonNull ClassLoader classLoader, @NonNull String className) {
        Class<? extends Fragment> fragmentClass = loadFragmentClass(classLoader, className);
        if (fragmentClass == DessertsFragment.class) {
            return new DessertsFragment(repository);
        } else {
            return super.instantiate(classLoader, className);
        }
    }
}

यह उदाहरण instantiate() को ओवरराइड करते हुए, FragmentFactory को सब-क्लास में बदल देता है तरीके का इस्तेमाल करके DessertsFragment के लिए कस्टम फ़्रैगमेंट बनाने वाला लॉजिक दिया जा सकता है. अन्य फ़्रैगमेंट क्लास को इनके डिफ़ॉल्ट व्यवहार से हैंडल किया जाता है FragmentFactory से super.instantiate().

इसके बाद, इस्तेमाल करने के लिए MyFragmentFactory को फ़ैक्ट्री के तौर पर सेट किया जा सकता है आपके ऐप्लिकेशन के फ़्रैगमेंट बनाने के लिए, FragmentManager. आपको अपनी गतिविधि के यह पक्का करने के लिए super.onCreate() कि MyFragmentFactory का इस्तेमाल तब किया जाए, जब अपने फ़्रैगमेंट को फिर से बनाना.

Kotlin

class MealActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        supportFragmentManager.fragmentFactory = MyFragmentFactory(DessertsRepository.getInstance())
        super.onCreate(savedInstanceState)
    }
}

Java

public class MealActivity extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        DessertsRepository repository = DessertsRepository.getInstance();
        getSupportFragmentManager().setFragmentFactory(new MyFragmentFactory(repository));
        super.onCreate(savedInstanceState);
    }
}

गतिविधि में FragmentFactory सेट करने से फ़्रैगमेंट बदल जाता है फ़्रैगमेंट की हैरारकी में इस्तेमाल किया जा सकता है. दूसरे शब्दों में, आपके जोड़े गए किसी भी चाइल्ड फ़्रैगमेंट में childFragmentManager कस्टम फ़्रैगमेंट फ़ैक्ट्री तब तक सेट रहती है, जब तक कि उसे निचले लेवल पर न बदला जाए.

फ़्रैगमेंट फ़ैक्ट्री की मदद से जांच करना

एक ही ऐक्टिविटी आर्किटेक्चर में, अपने फ़्रैगमेंट की जांच करें आइसोलेशन FragmentScenario क्लास. चूंकि आप अपने ब्राउज़र के कस्टम onCreate तर्क पर भरोसा नहीं कर सकते गतिविधि की पहचान करता है, तो आप इसके बजाय FragmentFactory को तर्क के रूप में पास कर सकते हैं को अपने फ़्रैगमेंट टेस्ट में बदलें, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है:

// Inside your test
val dessertRepository = mock(DessertsRepository::class.java)
launchFragment<DessertsFragment>(factory = MyFragmentFactory(dessertRepository)).onFragment {
    // Test Fragment logic
}

इस परीक्षण प्रक्रिया के बारे में विस्तृत जानकारी और पूरे उदाहरणों के लिए, अपने फ़्रैगमेंट की जांच करना देखें.