¿Cómo obtengo el fragmento que se muestra actualmente?

Estoy jugando con fragmentos en Android.

Sé que puedo cambiar un fragmento usando el siguiente código:

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

Mi pregunta es, en un archivo Java, ¿cómo puedo obtener la instancia de Fragment que se muestra actualmente?

Cuando agrega el fragmento en su transacción, debe usar una etiqueta.

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

... y luego si quieres comprobar si el fragmento es visible:

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

Ver también http://developer.android.com/reference/android/app/Fragment.html

Sé que es una publicación antigua, pero también tuve problemas con ella anteriormente. Encontré una solución que era hacer esto en la onBackStackChanged()función de escucha

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

    }

Esto funcionó para mí, ya que no quería recorrer cada fragmento que tengo para encontrar uno que sea visible. Espero que ayude a alguien más también.

Aquí está mi solución, que encuentro útil para escenarios de bajo fragmento

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

Cada vez que muestres un fragmento debes poner la etiqueta en la pila:

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

Y luego, cuando necesite obtener un fragmento actual, puede usar este método:

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

Lo que estoy usando para encontrar el fragmento de visualización actual se encuentra en el siguiente código. Es simple y funciona para mí por ahora. Se ejecuta en la actividad que contiene los fragmentos.

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

Camino de Kotlin;

val currentFragment = supportFragmentManager.fragments.last()

La forma reactiva :

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

Mi método se basa en try / catch de esta manera:

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

Pero puede haber una mejor manera ...

Bueno, esta pregunta obtuvo muchas opiniones y atención, pero aún no contenía la solución más fácil de mi parte: usar getFragments ().

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

Puede consultar qué fragmento se carga en su marco de contenido de Actividades y recuperar la clase de fragmento o el fragmento 'nombre simple' (como una cadena).

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

Uso:

Log.d(TAG, getCurrentFragment());

Salidas:

D/MainActivity: FragOne

Es un poco tarde, pero para cualquiera que esté interesado: si conoce el índice del fragmento que desea en FragmentManager, solo obtenga una referencia y verifique la función isMenuVisible (). aquí :

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

Si es truevisible para el usuario, etc.

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
}

Si llegas aquí y estás usando Kotlin:

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

R.id.fragment_containeres el lugar iddonde fragmentse presenta en suactivity

O si quieres una mejor solución:

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

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

Inspirado por la respuesta de Tainy , aquí están mis dos centavos. Poco modificado de la mayoría de las otras implementaciones.

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

Reemplace "myActivity"con "esto" si es su actividad actual o use una referencia a su actividad.

Hay un método llamado findFragmentById()en SupportFragmentManager. Lo uso en el contenedor de actividades como:

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

Así es como obtener su actual Fragment. Si tiene una costumbre Fragmenty necesita verificar qué Fragmentes, normalmente uso instanceof:

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

Si está utilizando el AndroidX Navigation:

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

Para obtener más información sobre este componente de navegación: https://developer.android.com/guide/navigation/navigation-getting-started

Esta es una forma sencilla de obtener el fragmento actual.

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 respuesta de Sev funciona cuando presionas el botón Atrás o cambias la pila.

Sin embargo, hice algo un poco diferente. Tengo una configuración de escucha de cambio de backstack en un Fragmento base y sus fragmentos derivados y este código está en la escucha:

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
}

Esto es trabajo para mi. Espero que esto ayude a alguien.

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

Si obtiene la instancia actual de Fragmento de la actividad principal, puede simplemente

findFragmentByID(R.id.container);

Esto realmente es la instancia actual de fragmento que se rellena en la vista. Tuve el mismo problema. Tuve que cargar el mismo fragmento dos veces manteniendo uno en el backstack.

El siguiente método no funciona. Simplemente obtiene un Fragment que tiene la etiqueta. No pierdas tu tiempo con este método. Estoy seguro de que tiene sus usos, pero obtener la versión más reciente del mismo Fragmento no es uno de ellos.

findFragmentByTag()

Echa un vistazo a esta solución. Me funcionó para obtener el Fragmento actual.

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

Bueno, supongo que esta es la respuesta más directa a esta pregunta. Espero que esto ayude.

Aquí hay una solución de Kotlin:

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

Forma simplificada:

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

Manera fácil de hacer eso:

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

En la actividad principal, se llama al método onAttachFragment (Fragment fragment) cuando se adjunta un nuevo fragmento a la actividad. En este método, puede obtener la instancia del fragmento actual. Sin embargo, no se llama al método onAttachFragment cuando se saca un fragmento de la pila, es decir, cuando se presiona el botón Atrás para colocar el fragmento superior en la parte superior de la pila. Todavía estoy buscando un método de devolución de llamada que se active en la actividad principal cuando un fragmento se hace visible dentro de la actividad.

En el caso de fragmentos desplazados, cuando use la instancia de la clase ViewPager, suponga que mVeiwPager, puede llamar a mViewPager.getCurrentItem () para obtener el número int del fragmento actual.

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

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

Descubrí findFragmentByTagque no es tan conveniente. Si tiene String currentFragmentTagen su Activityo padre Fragment, necesita guardarlo onSaveInstanceStatey restaurarlo onCreate. Incluso si lo hace, cuando el Activityrecreada, onAttachFragmentserá llamado antes onCreate, por lo que no se puede utilizar currentFragmentTagen onAttachFragment(por ejemplo. Actualizar algunos puntos de vista basados en currentFragmentTag), ya que de fuerza aún no restaurado.

Yo uso el siguiente código:

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

El documento de FragmentManagerestado que

El orden de los fragmentos en la lista es el orden en que se agregaron o adjuntaron.

Cuando necesite hacer cosas basadas en el tipo de fragmento actual, simplemente use en getCurrentFragment() instance of MyFragmentlugar de currentFragmentTag.equals("my_fragment_tag").

Tenga getCurrentFragment()en cuenta que onAttachFragmentno obtendrá el Fragmentadjunto, sino el adjunto anterior.

Tuve que hacer esto muy recientemente y ninguna de las respuestas aquí realmente se ajustaba a este escenario.

Si está seguro de que solo un fragmento estará visible (pantalla completa), entonces realmente desea encontrar lo que está en la parte superior de la pila. Por ejemplo, como Kotlinpara 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)
        }
    }
}

Y úsalo como:

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

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

Puede hacerlo muy fácilmente también con una URL en logcat que lo redirigirá al código fuente del código fuente del fragmento actual. Primero, debe agregar un OnBackStackChangedListener en la actividad del host como -

activity.getChildFragmentManager().addOnBackStackChangedListener(backStackListener);

Y la implementación de OnBackStackChangedListener es:

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

Y el método getStackTopName () es -

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