मैं वर्तमान में प्रदर्शित टुकड़े कैसे प्राप्त करूं?

Question

मैं एंड्रॉइड में टुकड़ों के साथ खेल रहा हूं।

मुझे पता है कि मैं निम्नलिखित कोड का उपयोग करके एक अंश को बदल सकता हूं:

FragmentManager fragMgr = getSupportFragmentManager();
FragmentTransaction fragTrans = fragMgr.beginTransaction();

MyFragment myFragment = new MyFragment(); //my custom fragment

fragTrans.replace(android.R.id.content, myFragment);
fragTrans.addToBackStack(null);
fragTrans.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE);
fragTrans.commit();

मेरा सवाल है, एक जावा फ़ाइल में, मैं वर्तमान में प्रदर्शित फ्रैगमेंट उदाहरण कैसे प्राप्त कर सकता हूं?

Comments

सम्बंधित - stackoverflow.com/a/21104084/80428

— Jay Wick

वर्तमान खंड वस्तु प्राप्त करने के लिए

— S.S. A.Suk

Answer 1

जब आप अपने लेन-देन में टुकड़ा जोड़ते हैं तो आपको एक टैग का उपयोग करना चाहिए।

fragTrans.replace(android.R.id.content, myFragment, "MY_FRAGMENT");

... और बाद में अगर आप देखना चाहते हैं कि टुकड़ा दिखाई दे रहा है या नहीं:

MyFragment myFragment = (MyFragment)getFragmentManager().findFragmentByTag("MY_FRAGMENT");
if (myFragment != null && myFragment.isVisible()) {
   // add your code here
}

Http://developer.android.com/reference/android/app/Fragment.html भी देखें

Comments

ठीक है, लेकिन मुझे वर्तमान में प्रदर्शित फ्रैग्मेंट इंस्टेंस को तुरंत प्राप्त करने के लिए एक तरीका चाहिए, न कि सभी टुकड़ों के माध्यम से पुनरावृत्ति की जाँच करें और फिर तय करें कि अब स्क्रीन पर कौन सा टुकड़ा प्रदर्शित किया गया है। मुझे लगता है कि आपके उत्तर को मेरे प्रत्येक खंड को पुनरावृत्त रूप से जांचने के लिए मेरे कोड की आवश्यकता है, और दृश्यमान का पता लगाएं ...

— Leem.fin

हां, लेकिन एक समय में एक से अधिक टुकड़े दिखाई दे सकते हैं। तो "केवल सक्रिय टुकड़ा" जैसा कुछ भी नहीं है ....

— ramdroid

ठीक है, यहां तक ​​कि कई टुकड़े प्रदर्शित किए गए हैं, मुझे अभी भी उन्हें प्राप्त करने का एक तरीका चाहिए ... और एक ऐसा तरीका जो मेरे प्रत्येक टुकड़े की पुनरावृत्ति से बेहतर है। मुझे चिंता है "getDisplayedFragment () की तरह" उन्हें "एक तरीका है, लेकिन यकीन है कि Android में ऐसी कोई विधि नहीं है

— Leem.fin

मुझे नहीं पता कि यह आपके लिए एक समस्या क्यों है ... आपके पास आमतौर पर एक गतिविधि में केवल कुछ टुकड़े होते हैं और यह वास्तव में समस्या नहीं होनी चाहिए कि वे दिखाई दे रहे हैं या नहीं।

— ramdroid

हर कोई इस जवाब को क्यों बढ़ा रहा है? ज़रूर, यह कोड का एक अच्छा सा है, लेकिन टैग द्वारा एक विशिष्ट टुकड़ा प्राप्त करने के लिए सवाल का जवाब नहीं देता है .. लेकिन प्रश्नकर्ता वर्तमान में प्रदर्शित टुकड़ा चाहता है, जिसका अर्थ है कि वह नहीं जानता कि कौन सा टुकड़ा प्रदर्शित होता है। हां, एकाधिक टुकड़े हो सकते हैं, लेकिन प्रश्न को पढ़ने पर केवल 1 टुकड़ा UI पर प्रदर्शित होता है। क्षमा करें, क्योंकि यह प्रश्न के उत्तर का जवाब नहीं देता है।

— क्रोधितगीत

Answer 2

मुझे पता है कि यह एक पुरानी पोस्ट है, लेकिन इससे पहले भी परेशानी हो रही थी। एक समाधान मिला जो onBackStackChanged()सुनने के कार्य में ऐसा करना था

  @Override
    public void onBackPressed() {
        super.onBackPressed();

         Fragment f = getActivity().getFragmentManager().findFragmentById(R.id.fragment_container);
      if(f instanceof CustomFragmentClass) 
        // do something with f
        ((CustomFragmentClass) f).doSomething();

    }

यह मेरे लिए काम कर रहा था क्योंकि मैं हर टुकड़े के माध्यम से पुनरावृति नहीं करना चाहता था, जो मुझे दिखाई दे रहा है। आशा है कि यह किसी और को भी मदद करता है।

Comments

बिल्कुल एक नेविगेशन ड्रॉअर के साथ स्क्रीन रोटेशन के बाद onBackPressed () के साथ काम करते समय मैं क्या देख रहा था। इसे साझा करने के लिए वापस आने के लिए धन्यवाद।

— शॉर्टफ्यूज

आंतरिक रूप से सभी अंशों के माध्यम से खोज नहीं करता है? :)

— एंड्रयू सेननर

अगर .getFragmentManagerयह मेरे मामले में असंगत प्रकार की रिपोर्ट करता है, तो इसका कारण यह है कि मैं इसका उपयोग कर रहा था android.support.app.v4.Fragment, जिस स्थिति में उपयोग करने की सही विधि हैgetSupportFragmentManager

— रेज़वान बारू

या आप उपयोग कर सकते हैं findFragmentByTag()के स्थान पर findFragmentById, यदि आप जब में जोड़ने से टुकड़ा करने के लिए टैग प्रदान की हैfragmentManager.beginTransaction() .add(containerID, frag, fragmentTag) .addToBackStack(fragmentTag) .commit();

— DeltaCap019

@AndrewSenner, उनका मतलब है कि वह इसे स्पष्ट रूप से नहीं करना चाहते थे :)

— फरीद

Answer 3

यहाँ मेरा समाधान है जो मुझे कम टुकड़े वाले परिदृश्यों के लिए उपयोगी लगता है

public Fragment getVisibleFragment(){
    FragmentManager fragmentManager = MainActivity.this.getSupportFragmentManager();
    List<Fragment> fragments = fragmentManager.getFragments();
    if(fragments != null){
        for(Fragment fragment : fragments){
            if(fragment != null && fragment.isVisible())
                return fragment;
        }
    }
    return null;
}

Comments

fragmentकुछ परिदृश्यों में अशक्त हो सकता है, जैसे कि जब आप बैक स्टैक पॉप करते हैं। इसलिए बेहतर उपयोग करें if (fragment != null && fragment.isVisible())।

— cccrack

विधि अधूरा है क्योंकि न केवल एक टुकड़ा दिखाई दे रहे हैं यह संभव है

— letroll

यदि कोई टुकड़ा दिखाई नहीं देता है, तो fragmentManager.getFragments () NULL को लौटाएगा, जो NPE को यह कहते हुए "Nava ऑब्जेक्ट के संदर्भ में 'java.util.Iterator java.util.Listator .iterator ()' को लागू करने का प्रयास करेगा।" इसलिए, लूप के लिए एक साधारण चेक से घिरा होना चाहिए: अगर (टुकड़े! = Null)

— प्रणव महाजन

क्या होगा अगर एक से अधिक टुकड़े दिखाई दे रहे हैं?

— शिवराज पाटिल

तकनीकी रूप से इसे प्रश्न के आधार पर उत्तर के रूप में चिह्नित किया जाना चाहिए। आस्कर वर्तमान में टुकड़ा प्रदर्शित करना चाहता है, न जाने कौन सा टुकड़ा है। अन्य उत्तर टैग द्वारा टुकड़े होते रहते हैं

— नाराज़गी

Answer 4

हर बार जब आप टुकड़ा दिखाते हैं, तो आपको उसे टैग बैकस्टैक में डालना चाहिए:

FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
ft.setTransition(FragmentTransaction.TRANSIT_ENTER_MASK);       
ft.add(R.id.primaryLayout, fragment, tag);
ft.addToBackStack(tag);
ft.commit();        

और फिर जब आपको वर्तमान टुकड़ा प्राप्त करने की आवश्यकता हो तो आप इस विधि का उपयोग कर सकते हैं:

public BaseFragment getActiveFragment() {
    if (getSupportFragmentManager().getBackStackEntryCount() == 0) {
        return null;
    }
    String tag = getSupportFragmentManager().getBackStackEntryAt(getSupportFragmentManager().getBackStackEntryCount() - 1).getName();
    return (BaseFragment) getSupportFragmentManager().findFragmentByTag(tag);
}

Comments

मुझे पूरा यकीन है कि यह तकनीक किसी ViewPager के साथ उपयोग किए गए Fragments के लिए काम नहीं करेगी, क्योंकि वे टैग द्वारा नहीं जोड़े गए हैं। बस वहाँ से उछाला जा रहा है।

— लोशेग

यह केवल तभी काम करता है जब आप कॉल करते हैं addToBackStack(tag), लेकिन क्या होगा यदि आप टुकड़े को बैक स्टैक में जोड़ना नहीं चाहते हैं?

— cccrack

यह केवल तभी काम करता है जब आपका टैग बैक स्टैक नाम के समान हो, जो ऐसा लगता है कि यह असामान्य होगा।

यदि आप एक ही लेनदेन में 5 टुकड़े जोड़ते हैं तो क्या होगा?

— केविन लाम

यह कहना अच्छा है कि यदि आप कुछ फ्रैगमेंट के लिए addToBackStack (null) को कॉल करते हैं, जहाँ आपको नाम की आवश्यकता नहीं है, तो विधि getName () शून्य वापस आ सकती है और आपको एक NPE मिलता है। @ dpk, दण्ड कहता है: इस प्रविष्टि को बनाते समय उस नाम को प्राप्त करें जिसे FragmentTransaction.addToBackStack (स्ट्रिंग) को आपूर्ति की गई थी। यदि EntryCount 0 है, तो भी एक शून्य जाँच जोड़ें और आप शीर्ष प्रविष्टि प्राप्त करने का प्रयास करते हैं।

— जैकसनऑफ़ 1

Answer 5

वर्तमान प्रदर्शित टुकड़ा खोजने के लिए मैं जो प्रयोग कर रहा हूं वह नीचे दिए गए कोड में है। यह सरल है और यह अब तक मेरे लिए काम करता है। यह उस गतिविधि में चलता है जो टुकड़े रखती है

    FragmentManager fragManager = this.getSupportFragmentManager();
    int count = this.getSupportFragmentManager().getBackStackEntryCount();
    Fragment frag = fragManager.getFragments().get(count>0?count-1:count);

Comments

आपको यह सुनिश्चित करने के लिए जांच करनी चाहिए कि गिनती> 0 है ताकि (काउंट -1) एक IndexOutofBoundsException नहीं फेंके

— कीरर्स

यह नहीं है कि टुकड़ा बदल दिया गया था, लेकिन बैकस्ट में नहीं जोड़ा गया है? यदि हाँ, तो क्या मैं इसे टैग तर्क का उपयोग करके प्राप्त कर सकता हूं?

— कैफ़ेबेबे 1991

GetFragments कॉल आपको उस टुकड़े को नहीं देगा, जो आप उस आदेश को जोड़ रहे हैं, जब आप उस पर popBackStack (null, FragmentManager.POP_BACK_STACK_INCLUSIVE) कॉल करते हैं, और अधिक टुकड़े जोड़ते हैं।

— LEHO

यदि गतिविधि में एक से अधिक फ़्रैगमेंट दिखाई देते हैं, तो आपका तरीका गलत है। उदाहरण के लिए: ViewPager फ्रैगमेंट्स के साथ। जैसा कि मुझे पता है कि GetBackStackEntryCount () लेनदेन की वापसी संख्या, टुकड़े की संख्या नहीं

— HungNM2

आपको fragManager.getFragments().size()इसके बजाय जांच करनी चाहिए getBackStackEntryCount()क्योंकि वे जरूरी नहीं के बराबर हैं (जो मेरा मामला है)। अन्यथा आप IndexOutOfBoundsException

— RustamG

Answer 6

कोटलिन रास्ता;

val currentFragment = supportFragmentManager.fragments.last()

Comments

एपीआई 26 और केवल ऊपर

— ibit

@ibit का क्या मतलब है कि एपीआई 26 और केवल ऊपर काम करता है? मैंने एम्यूलेटर एपीआई 19 पर काम करने की कोशिश की।

— हेंड्रडब्ल्यूडब्ल्यू

@ केंद्र सरकार तुम सही हो! मैं फ्रेमवर्क getFragments()फ़ंक्शन में फ़ंक्शन का उल्लेख कर रहा था , जो कि एपीआई 26 और ऊपर है।

— ibit

ख्याल रखना। इससे पहले कि आप किसी भी टुकड़ा ढेर नहीं है, यह खाली अपवाद पैदा कर सकता है!

— जेटविज़

यह काम नहीं करता है? java.lang.ClassCastException: androidx.navigation.fragment.NavHostFragment फ्रैगमेंट में नहीं डाली जा सकती

— coolcool1994

Answer 7

प्रतिक्रियाशील रास्ता:

Observable.from(getSupportFragmentManager().getFragments())
    .filter(fragment -> fragment.isVisible())
    .subscribe(fragment1 -> {
        // Do something with it
    }, throwable1 -> {
        // 
    });

Comments

यह कैसे प्रतिक्रियाशील है? आप एक अवलोकनीय का उपयोग करते हैं लेकिन यह केवल एक बार ही निकलेगा

— टिम

और यह सिर्फ एक overkill है। एक साधारण वर्धित लूप केवल एक ही काम करेगा, शायद इससे भी तेज।

— पीटरस्टेव उमर्गाबा

सिर्फ स्ट्रीम एपीआई के लिए प्रतिक्रियाशील धारा का उपयोग करना इतना स्मार्ट नहीं है, वास्तव में जैसे उन्होंने कहा कि यह ओवरक्लिल का उपयोग भाप Java8 एपीआई है यदि आप सूची को एक धारा के रूप में मानना ​​चाहते हैं और फ़िल्टर एपी लागू करना चाहते हैं

— AndroidLover

Answer 8

मेरा तरीका इस तरह की कोशिश / पकड़ पर आधारित है:

MyFragment viewer = null;
    if(getFragmentManager().findFragmentByTag(MY_TAG_FRAGMENT) instanceOf MyFragment){
    viewer = (MyFragment) getFragmentManager().findFragmentByTag(MY_TAG_FRAGMENT);
}

लेकिन एक बेहतर तरीका हो सकता है ...

Comments

मेरा सवाल यह है कि वर्तमान में प्रदर्शित किए गए टुकड़े को कैसे प्राप्त किया जाए, जिसका अर्थ है कि बहुत सारे टुकड़े हो सकते हैं, मैं केवल वर्तमान में प्रदर्शित एक का उदाहरण प्राप्त करना चाहता हूं, क्यों (MyFragment) का उपयोग करें ?? मेरा मतलब है कि यह स्क्रीन पर किसी भी फ्रैग्मेंट डिस्प्ले हो सकता है ... और मैं वर्तमान में प्रदर्शित एक प्राप्त करना चाहता हूं।

— लेम.फिन

MY_TAG_FRAG एक स्थान का उपयोग करने से पहले मेरे द्वारा बनाए गए टुकड़े का टैग है, इस तरह: fragmentTransaction.replace (R.id.FL_MyFragment, MyFragment, MY_TAG_FRAGMENT);

— थोरैक्स

अगर मेरे पास कई टुकड़े हैं, तो क्या कॉल .replace (...) के लिए मैं सभी टुकड़ों के लिए एक टैग का उपयोग कर सकता हूं?

— Leem.fin

हां, कोई बात नहीं, इस कोड का उपयोग करें: fragmentTransaction.replace (R.id.FL_MyFragment, MyFragment, MY_TAG_FRAGMENT); और यह अच्छी तरह से हो सकता है।

— थोरैक्स

खैर, मुझे वास्तव में आपकी बात नहीं आती, मेरा मतलब है कि मुझे वर्तमान में प्रदर्शित किए गए फ्रैगमेंट उदाहरण को तुरंत प्राप्त करने के लिए एक तरीके की आवश्यकता है, न कि सभी टुकड़ों के माध्यम से पुनरावृत्ति की जाँच करें और फिर तय करें कि अब स्क्रीन पर कौन सा टुकड़ा प्रदर्शित किया गया है।

— Leem.fin

Answer 9

खैर, इस सवाल को बहुत सारे विचार और ध्यान मिले लेकिन फिर भी मेरे अंत से सबसे आसान समाधान नहीं मिला - getFragments () का उपयोग करने के लिए।

            List fragments = getSupportFragmentManager().getFragments();
            mCurrentFragment = fragments.get(fragments.size() - 1);

Comments

दुर्भाग्य से, यह हमेशा सच नहीं होता है, getSupportFragmentManager().getFragments() आपको एक सूची वापस दे देता है लेकिन यह अशक्त मूल्यों को पकड़ सकता है, यदि नवीनतम टुकड़ा सिर्फ बैकस्टैक से पॉप किया गया है। Eq: यदि आप onBackStackChanged()विधि के अंदर अपने तरीके से जांच करते हैं और आप popBackStack()कहीं कॉल करते हैं , तो mCurrentFragmentइच्छा होगी null।

— स्टुमि

@Stumi इस जानकारी के लिए धन्यवाद। हां, Android में कई अजीब जीवन चक्र समस्याओं में से एक की तरह लगता है।

— नटिव

Answer 10

आप क्वेरी कर सकते हैं कि कौन सा टुकड़ा आपके एक्टिविटी कंटेंट फ्रेम में लोड किया गया है, और टुकड़ा वर्ग, या टुकड़ा 'सरल नाम' (एक स्ट्रिंग के रूप में) को पुनः प्राप्त करें।

public String getCurrentFragment(){
     return activity.getSupportFragmentManager().findFragmentById(R.id.content_frame).getClass().getSimpleName();
}

उपयोग:

Log.d(TAG, getCurrentFragment());

आउटपुट:

D/MainActivity: FragOne

Answer 11

यह थोड़ी देर हो चुकी है, लेकिन दिलचस्पी रखने वाले किसी भी व्यक्ति के लिए: यदि आप FragmentManager में अपने वांछित टुकड़े के सूचकांक को जानते हैं, तो इसके लिए एक संदर्भ प्राप्त करें और isMenuV अदृश्य () फ़ंक्शन के लिए जांचें! यहाँ :

getSupportFragmentManager().getFragments().get(0).isMenuVisible()

अगर trueयह उपयोगकर्ता के लिए और इतने पर दिखाई देता है!

Comments

अजीब तरह से, यह यहां सूचीबद्ध एकमात्र समाधान था जो मेरे लिए काम करता था। इसी समय, कई टुकड़े हो सकता है isVisible() == true, getView() != null। इसके अलावा, मेरे कोड getBackStackEntryCountमें हमेशा शून्य होता है। भले ही मैं मेनू का उपयोग नहीं करता, isMenuVisible()लेकिन अभी तक एकमात्र ऐसा भेदभाव है जो वर्तमान में 'सक्रिय' टुकड़े के लिए मज़बूती से इंगित करता है। ty

— parvus

Answer 12

1)

ft.replace(R.id.content_frame, fragment, **tag**).commit();

2)

FragmentManager fragmentManager = getSupportFragmentManager();
Fragment currentFragment = fragmentManager.findFragmentById(R.id.content_frame);

3)

if (currentFragment.getTag().equals(**"Fragment_Main"**))
{
 //Do something
}
else
if (currentFragment.getTag().equals(**"Fragment_DM"**))
{
//Do something
}

Answer 13

अगर यहाँ मिलता है और आप कोटलिन का उपयोग कर रहे हैं :

var fragment = supportFragmentManager.findFragmentById(R.id.fragment_container)

R.id.fragment_containerवह जगह है idजहां fragmentपर प्रस्तुत कर रहा हैactivity

या यदि आप एक अच्छा समाधान चाहते हैं:

supportFragmentManager.findFragmentById(R.id.content_main)?.let {
    // the fragment exists

    if (it is FooFragment) {
        // The presented fragment is FooFragment type
    }
}

Answer 14

टेनी के जवाब से प्रेरित होकर , यहाँ मेरे दो सेंट हैं। अधिकांश अन्य कार्यान्वयन से थोड़ा संशोधित।

private Fragment getCurrentFragment() {
    FragmentManager fragmentManager = myActivity.getSupportFragmentManager();
    int stackCount = fragmentManager.getBackStackEntryCount();
    if( fragmentManager.getFragments() != null ) return fragmentManager.getFragments().get( stackCount > 0 ? stackCount-1 : stackCount );
    else return null;
}

"myActivity"यदि यह आपकी वर्तमान गतिविधि है तो "इसे" से बदलें या अपनी गतिविधि के संदर्भ का उपयोग करें।

Answer 15

findFragmentById()में नामक एक विधि है SupportFragmentManager। मैं गतिविधि कंटेनर में इसका उपयोग करता हूं जैसे:

public Fragment currentFragment(){
    return getSupportFragmentManager().findFragmentById(R.id.activity_newsfeed_frame);
}

कि कैसे अपने वर्तमान पाने के लिए Fragment। यदि आपके पास कस्टम है Fragmentऔर Fragmentयह जांचने की आवश्यकता है कि यह क्या है, तो मैं सामान्य रूप से उपयोग करता हूं instanceof:

if (currentFragment() instanceof MyFrag){
    // Do something here
}

Answer 16

यदि आप उपयोग कर रहे हैं AndroidX Navigation:

val currentFragment = findNavController(R.id.your_navhost).?currentDestination

इस नेविगेशन घटक के बारे में अधिक जानकारी के लिए: https://developer.android.com/guide/navigation/navigation-getting-sted

Comments

यह संकलन नहीं करता है

— इगोरगानपोलस्की

यह केवल तभी संकलित करेगा, जब आपके पास AndroidX नेविगेशन ठीक से सेटअप हो और किसी तरह आपका नेवीहोस्ट कहा जाए your_navhost।

— कोरी रॉय

Answer 17

यह वर्तमान टुकड़ा पाने का सरल तरीका है ।।

getFragmentManager().addOnBackStackChangedListener(new FragmentManager.OnBackStackChangedListener() {
  @Override public void onBackStackChanged() {
    currentFragment = fragmentManager.findFragmentById(R.id.content);
    if (currentFragment !=  null && (currentFragment instanceof LoginScreenFragment)) {
      logout.setVisibility(View.GONE);
    } else {
      logout.setVisibility(View.VISIBLE);
    }
  }
});

Answer 18

जब आप बैक बटन दबाते हैं या अन्यथा बैकस्ट को बदलते हैं तो सेव का जवाब काम करता है।

मैंने कुछ अलग किया, हालाँकि। मेरे पास आधार फ्रैगमेंट और उसके व्युत्पन्न अंशों पर एक बैकस्टैक चेंज श्रोता सेटअप है और यह कोड श्रोता में है:

Fragment f = getActivity().getSupportFragmentManager().findFragmentById(R.id.container);

if (f.getClass().equals(getClass())) {
    // On back button, or popBackStack(),
    // the fragment that's becoming visible executes here,
    // but not the one being popped, or others on the back stack

    // So, for my case, I can change action bar bg color per fragment
}

Answer 19

यह मेरे लिए काम है। मुझे उम्मीद है कि यह किसी को आकर्षित करेगा।

FragmentManager fragmentManager = this.getSupportFragmentManager();  
        String tag = fragmentManager
                    .getBackStackEntryAt(
                    fragmentManager
                    .getBackStackEntryCount() - 1)
                    .getName();
              Log.d("This is your Top Fragment name: ", ""+tag);

Answer 20

यदि आपको मूल गतिविधि से फ्रैगमेंट का वर्तमान उदाहरण मिल रहा है, तो आप बस कर सकते हैं

findFragmentByID(R.id.container);

यह वास्तव में उस टुकड़े का वर्तमान उदाहरण है जो दृश्य पर आबादी है। मेरी भी यही समस्या थी। मुझे बैकस्टैक पर एक ही खंड को दो बार लोड करना था।

निम्नलिखित विधि काम नहीं करती है। यह सिर्फ एक टुकड़ा है कि टैग है हो जाता है। इस विधि पर अपना समय बर्बाद मत करो। मुझे यकीन है कि यह इसका उपयोग करता है, लेकिन एक ही फ्रैगमेंट का सबसे हालिया संस्करण प्राप्त करने के लिए उनमें से एक नहीं है।

findFragmentByTag()

Answer 21

इस समाधान की जाँच करें। इसने मुझे वर्तमान फ्रैगमेंट प्राप्त करने के लिए काम किया।

if(getSupportFragmentManager().getBackStackEntryCount() > 0){
        android.support.v4.app.Fragment f = 
         getSupportFragmentManager().findFragmentById(R.id.fragment_container);
        if(f instanceof ProfileFragment){
            Log.d(TAG, "Profile Fragment");
        }else if(f instanceof SavedLocationsFragment){
            Log.d(TAG, "SavedLocations Fragment");
        }else if(f instanceof AddLocationFragment){
            Log.d(TAG, "Add Locations Fragment");
        }

Answer 22

final FragmentManager fm=this.getSupportFragmentManager();
final Fragment fragment=fm.findFragmentByTag("MY_FRAGMENT");

if(fragment != null && fragment.isVisible()){
      Log.i("TAG","my fragment is visible");
}
else{
      Log.i("TAG","my fragment is not visible");
}

Comments

यह Jetpack के साथ काम करता है?

— इगोरगानापोलस्की

Answer 23

getSupportFragmentManager().findFragmentById(R.id.content_frame).getClass().getSimpleName();

खैर, मुझे लगता है कि यह इस सवाल का सबसे सीधा जवाब है। आशा है कि ये आपकी मदद करेगा।

Answer 24

यहाँ एक कोटलिन समाधान है:

if ( this.getSupportFragmentManager().getBackStackEntryCount()>0 ) {
    var fgmt = this.getSupportFragmentManager().fragments[this.getSupportFragmentManager().getBackStackEntryCount()-1]
    if( fgmt is FgmtClassName ) {
        (fgmt as FgmtClassName).doSth()
    }
}

सरलीकृत तरीका:

with ( this.getSupportFragmentManager() ) {
    if ( getBackStackEntryCount()>0 ) {
        var fgmt = fragments[getBackStackEntryCount()-1]
        if ( fgmt is FgmtClassName ) {
            (fgmt as FgmtClassName).doSth()
        }
    }
}

Answer 25

ऐसा करने का आसान तरीका:

Fragment fr=getSupportFragmentManager().findFragmentById(R.id.fragment_container);
String fragmentName = fr.getClass().getSimpleName();

Answer 26

मुख्य गतिविधि में, onAttachFragment (Fragment fragment) विधि को तब कहा जाता है जब गतिविधि में एक नया टुकड़ा जुड़ा होता है। इस पद्धति में, आप वर्तमान टुकड़े का उदाहरण प्राप्त कर सकते हैं। हालाँकि, onAttachFragment मेथड को तब नहीं कहा जाता है जब बैकस्टैक के बाहर एक खंडित होता है, यानी, जब बैक बटन को स्टैक के शीर्ष पर शीर्ष टुकड़ा प्राप्त करने के लिए दबाया जाता है। मैं अभी भी एक कॉलबैक विधि की तलाश कर रहा हूं जो मुख्य गतिविधि में ट्रिगर होती है जब गतिविधि के अंदर एक टुकड़ा दिखाई देता है।

Comments

इतने पास! :-)

— ब्लंडेल

हम जेटपैक नेविगेशन लाइब्रेरी का उपयोग करते हैं

— इगोरगानपोलस्की

Answer 27

स्क्रॉल किए गए अंशों के मामले में, जब आपके व्यूपोर्ट क्लास का उपयोग उदाहरण, मान लीजिए mVeiwPager, आप वर्तमान टुकड़े इंटिमेट नंबर पाने के लिए mViewPager.getCurrentItem () कॉल कर सकते हैं।

MainLayout.xml में

<?xml version="1.0" encoding="utf-8"?>
<android.support.design.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:fitsSystemWindows="true"
    android:orientation="vertical"
    tools:context="unidesign.photo360.MainActivity">

    <android.support.design.widget.AppBarLayout
        android:id="@+id/appbar"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:fitsSystemWindows="false"
        android:theme="@style/AppTheme.AppBarOverlay"
        app:expanded="false">

        <android.support.v7.widget.Toolbar
            android:id="@+id/main_activity_toolbar"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            app:popupTheme="@style/AppTheme.PopupOverlay"
            app:title="@string/app_name">

        </android.support.v7.widget.Toolbar>

    </android.support.design.widget.AppBarLayout>


    <android.support.v4.view.ViewPager
        android:id="@+id/view_pager"
        android:layout_width="match_parent"
        android:layout_height="wrap_content">

    </android.support.v4.view.ViewPager>
    
</android.support.design.widget.CoordinatorLayout>

MainActivity.kt में

class MainActivity : AppCompatActivity() {
    
        lateinit var mViewPager: ViewPager
        lateinit var pageAdapter: PageAdapter
        
//      ...
    
        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            setContentView(R.layout.activity_main)
            
            pageAdapter = PageAdapter(supportFragmentManager)
            mViewPager = findViewById(R.id.view_pager)
//          ...
            }
            
        override fun onResume() {
          super.onResume()
          var currentFragment = pageAdapter.getItem(mViewPager.currentItem)
//         ...
          }

Answer 28

मैंने पाया findFragmentByTagकि सुविधाजनक नहीं है। यदि आपके पास String currentFragmentTagआपके Activityमाता-पिता हैं Fragment, तो आपको इसे सहेजने onSaveInstanceStateऔर इसे पुनर्स्थापित करने की आवश्यकता है onCreate। यहां तक कि अगर आप ऐसा करते हैं, जब Activityनिर्मित, onAttachFragmentपहले बुलाया जाएगा onCreate, तो आप उपयोग नहीं कर सकते currentFragmentTagमें onAttachFragment(जैसे। के आधार पर कुछ विचारों को अद्यतनcurrentFragmentTag क्योंकि यह का हो सकता है अभी तक बहाल नहीं),।

मैं निम्नलिखित कोड का उपयोग करता हूं:

Fragment getCurrentFragment() {
    List<Fragment> fragments = getSupportFragmentManager().getFragments();
    if(fragments.isEmpty()) {
        return null;
    }
    return fragments.get(fragments.size()-1);
}

FragmentManagerराज्य का दस्तावेज है कि

सूची में अंशों का क्रम वह क्रम है जिसमें उन्हें जोड़ा या संलग्न किया गया था।

जब आपको वर्तमान खंड प्रकार के आधार पर सामान करने की आवश्यकता होती है, तो getCurrentFragment() instance of MyFragmentइसके बजाय बस का उपयोग करें currentFragmentTag.equals("my_fragment_tag")।

ध्यान दें कि getCurrentFragment()में onAttachFragmentसंलग्न नहीं मिलेगा Fragment, लेकिन पिछले संलग्न एक।

Answer 29

मुझे यह हाल ही में करना पड़ा और यहाँ कोई भी उत्तर वास्तव में इस परिदृश्य के अनुकूल नहीं है।

यदि आप आश्वस्त हैं कि केवल एक टुकड़ा दिखाई देगा (फुल-स्क्रीन), तो वास्तव में बैकस्टैक के शीर्ष पर क्या खोजना चाहते हैं। उदाहरण के लिए, एक Kotlinके रूप में Fragment:

import androidx.fragment.app.Fragment

fun Fragment.setVisibilityChangeListener(clazz: Class<out Fragment>, listener: (Boolean) -> Unit) {
    fragmentManager?.run {
        addOnBackStackChangedListener {
            val topFragmentTag = getBackStackEntryAt(backStackEntryCount - 1).name
            val topFragment = findFragmentByTag(topFragmentTag)
            listener(topFragment != null && topFragment::class.java == clazz)
        }
    }
}

और इसका उपयोग करें:

class MyFragment: Fragment {
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        setVisibilityChangeListener(this::class.java) { visible -> 
            // Do stuff
        }
    }
}

Answer 30

आप इसे लॉगकोट में एक URL के साथ भी आसानी से कर सकते हैं जो आपको वर्तमान खंड स्रोत कोड के स्रोत कोड पर पुनर्निर्देशित करेगा। सबसे पहले, आपको होस्ट गतिविधि में एक OnBackStackChangedListener जोड़ने की आवश्यकता है जैसे -

activity.getChildFragmentManager().addOnBackStackChangedListener(backStackListener);

और OnBackStackChangedListener कार्यान्वयन है -

    public FragmentManager.OnBackStackChangedListener backStackListener = () -> {

    String simpleName = "";
    String stackName = getStackTopName().trim();

    if (Validator.isValid(stackName) && stackName.length() > 0) {

      simpleName = stackName.substring(Objects.requireNonNull(stackName).lastIndexOf('.') + 1).trim();

      List<Fragment >
       fragmentList = getChildFragmentManager().getFragments();
      Fragment myCurrentFragment;

      for (int i = 0; i < fragmentList.size(); i++) {
       myCurrentFragment= fragmentList.get(i);
       if (myCurrentFragment.getClass().getSimpleName().equals(simpleName)) {
        //Now you get the current displaying fragment assigned in myCurrentFragment.
        break;
       }
       myFragment = null;
      }
     }


     //The code below is for the source code redirectable logcat which would be optional for you.
     StackTraceElement stackTraceElement = new StackTraceElement(simpleName, "", simpleName + ".java", 50);
     String fileName = stackTraceElement.getFileName();
     if (fileName == null) fileName = "";
     final String info = "Current Fragment is:" + "(" + fileName + ":" +
     stackTraceElement.getLineNumber() + ")";
     Log.d("now", info + "\n\n");
    };

और getStackTopName () विधि है -

public String getStackTopName() {
    FragmentManager.BackStackEntry backEntry = null;
    FragmentManager fragmentManager = getChildFragmentManager();
    if (fragmentManager != null) {
        if (getChildFragmentManager().getBackStackEntryCount() > 0)
            backEntry = getChildFragmentManager().getBackStackEntryAt(
                    getChildFragmentManager().getBackStackEntryCount() - 1
            );
    }
    return backEntry != null ? backEntry.getName() : null;
}