Come ottengo il frammento attualmente visualizzato?

Sto giocando con frammenti in Android.

So che posso cambiare un frammento usando il seguente codice:

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

La mia domanda è, in un file Java, come posso ottenere l'istanza Fragment attualmente visualizzata?

Quando aggiungi il frammento nella tua transazione, dovresti usare un tag.

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

... e successivamente se si desidera verificare se il frammento è visibile:

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

Vedi anche http://developer.android.com/reference/android/app/Fragment.html

So che è un vecchio post, ma in precedenza ho avuto problemi con esso. Ho trovato una soluzione per farlo nella onBackStackChanged()funzione di ascolto

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

    }

Questo ha funzionato per me poiché non volevo scorrere tutti i frammenti che devo trovare uno visibile. Spero che aiuti anche qualcun altro.

Ecco la mia soluzione che trovo utile per scenari con frammenti bassi

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

Ogni volta che mostri un frammento devi metterlo nel backstack:

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

E quindi quando è necessario ottenere il frammento corrente è possibile utilizzare questo metodo:

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

Quello che sto usando per trovare il frammento di visualizzazione corrente è nel codice seguente. È semplice e funziona per me ormai. Funziona nell'attività che contiene i frammenti

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

Via di Kotlin;

val currentFragment = supportFragmentManager.fragments.last()

Il modo reattivo :

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

Il mio metodo si basa su try / catch in questo modo:

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

Ma potrebbe esserci un modo migliore ...

Bene, questa domanda ha avuto molti punti di vista e attenzione ma non conteneva ancora la soluzione più semplice da parte mia: usare getFragments ().

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

È possibile eseguire una query su quale frammento viene caricato nel riquadro del contenuto delle attività e recuperare la classe del frammento o il frammento "nome semplice" (come stringa).

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

Uso:

Log.d(TAG, getCurrentFragment());

Uscite:

D/MainActivity: FragOne

È un po 'tardi, ma per chiunque sia interessato: se si conosce l'indice del frammento desiderato in FragmentManager, basta ottenere un riferimento ad esso e verificare la funzione isMenuVisible ()! Qui :

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

Se è truevisibile all'utente e così via!

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
}

Se arriva qui e stai usando Kotlin:

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

R.id.fragment_containerè il luogo in idcui si fragmentsta presentandoactivity

O se vuoi una soluzione migliore:

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

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

Ispirato dalla risposta di Tainy , ecco i miei due centesimi. Poco modificato dalla maggior parte delle altre implementazioni.

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

Sostituisci "myActivity"con "questo" se è la tua attività corrente o usa il riferimento alla tua attività.

C'è un metodo chiamato findFragmentById()in SupportFragmentManager. Lo uso nel contenitore delle attività come:

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

Ecco come ottenere la tua corrente Fragment. Se hai personalizzato Fragmente devi controllare di cosa Fragmentsi tratta, normalmente utilizzo instanceof:

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

Se stai usando AndroidX Navigation:

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

Per maggiori informazioni su questo componente di navigazione: https://developer.android.com/guide/navigation/navigation-getting-started

Questo è un modo semplice per ottenere il frammento corrente.

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

La risposta di Sev funziona quando si preme il pulsante Indietro o in caso contrario si cambia lo zaino.

Ho fatto qualcosa di leggermente diverso, però. Ho una configurazione dell'ascoltatore di modifiche di backstack su un frammento di base e sui suoi frammenti derivati ​​e questo codice è nell'ascoltatore:

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
}

Questo è lavoro per me. Spero che questo possa aiutare qualcuno.

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

Se stai ricevendo l'istanza corrente di Frammento dall'attività principale puoi semplicemente

findFragmentByID(R.id.container);

Questo effettivamente ottiene l'attuale istanza di frammento popolata nella vista. Ho avuto lo stesso problema. Ho dovuto caricare due volte lo stesso frammento tenendone uno nello zaino.

Il seguente metodo non funziona. Ottiene solo un frammento che ha il tag. Non perdere tempo con questo metodo. Sono sicuro che ha i suoi usi, ma per ottenere la versione più recente dello stesso frammento non è uno di questi.

findFragmentByTag()

Dai un'occhiata a questa soluzione. Ha funzionato per me ottenere l'attuale frammento.

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

Bene, immagino che questa sia la risposta più diretta a questa domanda. Spero che questo possa essere d'aiuto.

Ecco una soluzione Kotlin:

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

Modo semplificato:

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

Un modo semplice per farlo:

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

Nell'attività principale, il metodo onAttachFragment (Fragment fragment) viene chiamato quando un nuovo frammento è collegato all'attività. In questo metodo, è possibile ottenere l'istanza del frammento corrente. Tuttavia, il metodo onAttachFragment non viene chiamato quando un frammento viene estratto dallo backstack, ovvero quando viene premuto il pulsante Indietro per ottenere il frammento superiore in cima allo stack. Sto ancora cercando un metodo di callback che viene attivato nell'attività principale quando un frammento diventa visibile all'interno dell'attività.

In caso di frammenti di scorrimento, quando l'istanza di utilizzo della classe ViewPager, supponiamo mVeiwPager, puoi chiamare mViewPager.getCurrentItem () per ottenere il numero int del frammento corrente.

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

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

Ho scoperto findFragmentByTagche non è conveniente. Se hai String currentFragmentTagnel tuo Activityo genitore Fragment, è necessario salvarlo onSaveInstanceStatee ripristinarlo onCreate. Anche se si fa così, quando la Activityricreato, onAttachFragmentsarà chiamato prima onCreate, quindi non è possibile utilizzare currentFragmentTagin onAttachFragment(ad es. Aggiornare alcune opinioni sulla base dicurrentFragmentTag ), perché di forze non ancora ripristinata.

Io uso il seguente codice:

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

Il documento FragmentManagerafferma che

L'ordine dei frammenti nell'elenco è l'ordine in cui sono stati aggiunti o allegati.

Quando devi fare cose in base al tipo di frammento corrente, usa getCurrentFragment() instance of MyFragmentinvece dicurrentFragmentTag.equals("my_fragment_tag") .

Si noti che getCurrentFragment()in onAttachFragmentnon verrà allegato Fragment, ma il precedente allegato.

Ho dovuto farlo molto di recente e nessuna delle risposte qui si adattava davvero a questo scenario.

Se sei sicuro che sarà visibile solo un frammento (schermo intero), quindi vuoi davvero trovare ciò che si trova nella parte superiore dello zaino. Ad esempio, come Kotlinper 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)
        }
    }
}

E usalo come:

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

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

Puoi farlo molto facilmente anche con un URL in logcat che ti reindirizzerà al codice sorgente del codice sorgente del frammento corrente. Innanzitutto, devi aggiungere un OnBackStackChangedListener nell'attività dell'host come -

activity.getChildFragmentManager().addOnBackStackChangedListener(backStackListener);

E l' implementazione di 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");
    };

E il metodo 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;
}