Jak uzyskać aktualnie wyświetlany fragment?

Gram z fragmentami w Androidzie.

Wiem, że mogę zmienić fragment, używając następującego kodu:

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

Moje pytanie brzmi: w pliku Java, jak mogę uzyskać aktualnie wyświetlaną instancję Fragment?

Po dodaniu fragmentu do transakcji należy użyć znacznika.

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

... a później, jeśli chcesz sprawdzić, czy fragment jest widoczny:

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

Zobacz także http://developer.android.com/reference/android/app/Fragment.html

Wiem, że to stary post, ale wcześniej miałem z tym problem. Znaleziono rozwiązanie, które miało to zrobić w onBackStackChanged()funkcji odsłuchu

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

    }

To działało dla mnie, ponieważ nie chciałem powtarzać każdego fragmentu, który muszę znaleźć, który jest widoczny. Mam nadzieję, że pomoże to również komuś innemu.

Oto moje rozwiązanie, które uważam za przydatne w scenariuszach z niskim fragmentem

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;
}

Za każdym razem, gdy pokazujesz fragment, musisz umieścić go w plecaku:

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

A kiedy potrzebujesz uzyskać aktualny fragment, możesz użyć tej metody:

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

To, czego używam do znalezienia bieżącego fragmentu wyświetlania, znajduje się poniżej kodu. To jest proste i do tej pory działa dla mnie. Działa w aktywności, która zawiera fragmenty

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

Sposób Kotlina;

val currentFragment = supportFragmentManager.fragments.last()

Reaktywne sposób:

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

Moja metoda oparta jest na try / catch:

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

Ale może być lepszy sposób ...

Cóż, to pytanie zyskało wiele poglądów i uwagi, ale wciąż nie zawierało najłatwiejszego rozwiązania z mojej strony - użycia getFragments ().

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

Możesz zapytać, który fragment jest załadowany do ramki treści Działania, i pobrać klasę fragmentu lub fragment „prostej nazwy” (jako ciąg).

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

Stosowanie:

Log.d(TAG, getCurrentFragment());

Wyjścia:

D/MainActivity: FragOne

Jest trochę późno, ale dla każdego, kto jest zainteresowany: jeśli znasz indeks żądanego fragmentu w FragmentManager, po prostu uzyskaj odwołanie do niego i sprawdź, czy jest funkcja isMenuVisible ()! tutaj:

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

Jeśli jest truewidoczny dla użytkownika i tak dalej!

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
}

Jeśli się tu dostaniesz i korzystasz z Kotlin:

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

R.id.fragment_containerto miejsce, w idktórym fragmentprezentuje się na nichactivity

Lub jeśli chcesz ładniejszego rozwiązania:

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

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

Zainspirowany odpowiedzią Tainy , oto moje dwa centy. Trochę zmodyfikowany w stosunku do większości innych implementacji.

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;
}

Zamień na "myActivity"„to”, jeśli jest to Twoja bieżąca aktywność, lub użyj odniesienia do swojej aktywności.

Jest to metoda nazywa findFragmentById()się SupportFragmentManager. Używam go w kontenerze aktywności, takim jak:

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

Tak zdobędziesz swój prąd Fragment. Jeśli masz niestandardowy Fragmenti chcesz sprawdzić, co Fragmentto jest, zwykle używam instanceof:

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

Jeśli używasz AndroidX Navigation:

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

Aby uzyskać więcej informacji na temat tego elementu nawigacyjnego: https://developer.android.com/guide/navigation/navigation-getting-started

Jest to prosty sposób na uzyskanie bieżącego fragmentu.

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

Odpowiedź Seva działa, gdy naciśniesz przycisk Wstecz lub w inny sposób zmienisz plecak.

Zrobiłem jednak coś nieco innego. Mam konfigurację detektora zmian cofnięcia na podstawowym fragmencie i jego pochodnych fragmentach, a ten kod znajduje się w detektorze:

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
}

To dla mnie praca. Mam nadzieję, że to komuś pomoże.

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

Jeśli pobierasz bieżącą instancję Fragmentu z działania nadrzędnego, możesz to zrobić

findFragmentByID(R.id.container);

To faktycznie jest bieżącą instancją fragmentu, który jest zapełniany w widoku. Miałem ten sam problem. Musiałem załadować ten sam fragment dwa razy, trzymając jeden z powrotem na stos.

Następująca metoda nie działa. Po prostu dostaje fragment, który ma tag. Nie trać czasu na tę metodę. Jestem pewien, że ma on swoje zastosowania, ale uzyskanie najnowszej wersji tego samego fragmentu nie jest jednym z nich.

findFragmentByTag()

Sprawdź to rozwiązanie. Udało mi się zdobyć obecny Fragment.

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");
        }

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");
}

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

Sądzę, że jest to najprostsza odpowiedź na to pytanie. Mam nadzieję, że to pomoże.

Oto rozwiązanie Kotlin:

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

Uproszczony sposób:

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

Łatwy sposób to zrobić:

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

W głównym działaniu metoda onAttachFragment (fragment fragmentu) jest wywoływana, gdy do działania dołączany jest nowy fragment. W tej metodzie można uzyskać instancję bieżącego fragmentu. Jednak metoda onAttachFragment nie jest wywoływana, gdy fragment jest usuwany ze stosu, tj. Gdy naciśnięty jest przycisk Wstecz, aby uzyskać górny fragment na szczycie stosu. Nadal szukam metody wywołania zwrotnego, która jest uruchamiana w głównej aktywności, gdy fragment staje się widoczny w tej aktywności.

W przypadku przewijanych fragmentów, gdy używasz instancji klasy ViewPager, załóżmy, że mVeiwPager, możesz wywołać mViewPager.getCurrentItem () w celu uzyskania bieżącego numeru int.

w 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>

w 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)
//         ...
          }

Odkryłem, że findFragmentByTagto nie jest wygodne. Jeśli masz String currentFragmentTagu swojego Activitylub rodzica Fragment, musisz go zapisać onSaveInstanceStatei przywrócić onCreate. Nawet jeśli to zrobisz, po Activityodtworzeniu onAttachFragmentzostanie wywołany wcześniej onCreate, więc nie możesz użyć currentFragmentTagw onAttachFragment(np. Zaktualizować niektórych widoków na podstawiecurrentFragmentTag ), ponieważ może nie zostać jeszcze przywrócone.

Używam następującego kodu:

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

Dokument FragmentManagerstwierdzający, że

Kolejność fragmentów na liście to kolejność, w której zostały dodane lub dołączone.

Jeśli musisz robić rzeczy na podstawie bieżącego typu fragmentu, po prostu użyj getCurrentFragment() instance of MyFragmentzamiast currentFragmentTag.equals("my_fragment_tag").

Zauważ, że getCurrentFragment()w onAttachFragmentnie otrzyma załączania Fragment, ale poprzedni załączony.

Musiałem to zrobić bardzo niedawno i żadna z odpowiedzi tutaj nie pasowała do tego scenariusza.

Jeśli masz pewność, że widoczny będzie tylko jeden fragment (pełny ekran), więc naprawdę chcesz znaleźć to, co znajduje się na górze plecaka. Na przykład, jak Kotlinna 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)
        }
    }
}

I używaj go w następujący sposób:

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

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

Możesz to zrobić bardzo łatwo również za pomocą adresu URL w logcat, który przekieruje cię do kodu źródłowego bieżącego kodu źródłowego fragmentu. Najpierw musisz dodać OnBackStackChangedListener do działania hosta, takiego jak -

activity.getChildFragmentManager().addOnBackStackChangedListener(backStackListener);

A implementacja OnBackStackChangedListener to -

    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");
    };

A metoda getStackTopName () to -

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;
}