android - know - obtener el fragmento que se muestra actualmente

how to know current fragment

Question

Estoy jugando con Fragmento en Android.

Sé que puedo cambiar el 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?

Answer 1

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 2

Aquí está mi solución que me parece útil para escenarios de fragmentos bajos

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

Answer 3

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

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

Answer 4

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

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

Answer 5

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

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

... y más tarde si desea comprobar si el fragmento es visible:

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

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

Answer 6

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

MySingleton.currentFragment = myFragment.class;

Answer 7

El uso de un bus de eventos (como Otto , EventBus o un RxJava Bus ) es especialmente útil en estas situaciones.

Si bien este enfoque no necesariamente le entrega el fragmento actualmente visible como un objeto (aunque eso también se puede hacer, pero conduce a una cadena de llamadas más larga), le permite ejecutar acciones en el fragmento actualmente visible (que generalmente es lo que usted desea). Quiero hacer saber el fragmento actualmente visible).

1. asegúrese de respetar el ciclo de vida del fragmento y registre / cancele el registro del bus de eventos en los momentos adecuados
2. en el punto en el que necesita conocer el fragmento actualmente visible y ejecutar un conjunto de acciones. dispara un evento con el bus del evento.

Todos los fragmentos visibles que se hayan registrado en el bus ejecutarán la acción necesaria.

Answer 8

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

en MainLayout.xml

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

en MainActivity.kt

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 9

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

Answer 10

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

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

Si es true visible para el usuario y así sucesivamente!

Answer 11

Esta es una manera simple 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);
    }
  }
});

Answer 12

Esto es trabajo para mí. 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);

Answer 13

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 conseguir tu Fragment actual. Si tiene un Fragment personalizado y necesita verificar qué Fragment es, normalmente uso instanceof :

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

Answer 14

Hola, sé que este es un problema muy antiguo, pero me gustaría compartir mi propia solución ...

Para obtener la lista de fragmentos examinados por el usuario, creé una clase auxiliar:

public class MyHelperClass{

    private static ArrayList<Fragment> listFragment = new ArrayList<>();

    public static void addFragment(Fragment f){
        if(!existFragment(f)) {
            listFragment.add(f);
        }
    }
    public static void removeFragment(){
        if(listFragment.size()>0)
            listFragment.remove(listFragment.size()-1);
    }
    public static Fragment getCurrentFragment(){
        return listFragment.get(listFragment.size()-1);
    }
    public static int sizeFragments(){
        return listFragment.size();
    }
    private static Boolean existFragment(Fragment f){
        Boolean ret = false;
        for(Fragment fragment : listFragment){
            if (fragment.getClass() == f.getClass()){
                ret = true;
            }
        }
        return ret;
    }

Y en la actividad principal, anulo el método onAttachFragment

@Override
public void onAttachFragment(Fragment f) {
    super.onAttachFragment(f);

    MyHelperClass.addFragment(f);
}

Y también, anulo el método onBackPressed:

@Override
public void onBackPressed() {
        General.removeFragment();
        if(General.sizeFragments()>0){
            Fragment fragment = null;
            Class fragmentClass = General.getCurrentFragment().getClass();

            try {
                fragment = (Fragment) fragmentClass.newInstance();
                fragment.setArguments(General.getCurrentFragment().getArguments());
            } catch (Exception e) {
                e.printStackTrace();
            }

            fragmentManager.beginTransaction().replace(R.id.flContent, fragment).commit();
        }else{
            super.onBackPressed();
        }
}

de esta manera, en cualquier momento puede obtener el fragmento activo con MyHelperClass.getCurrentFragment ()

Espero que esto sea de ayuda para cualquiera.

Saludos

Answer 15

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 "this" si es su actividad actual o use la referencia a su actividad.

Answer 16

La forma reactive :

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

Answer 17

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

Answer 18

Me encontré con un problema similar, en el que quería saber qué fragmento se mostraba por última vez cuando se presionaba la tecla Atrás. Usé una solución muy simple que funcionó para mí. Cada vez que abro un fragmento, en el método onCreate (), establezco una variable en mi singleton (reemplace "myFragment" con el nombre de su fragmento)

public static Class currentFragment = null; 

La variable se declara en el singleton como

    if (MySingleton.currentFragment == myFragment.class){
        // do something
        return;
    }
    super.onBackPressed();

Luego en el onBackPressed () compruebo

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

Asegúrese de llamar a super.onBackPressed (); después de la "devolución", de lo contrario la aplicación procesará la tecla de retroceso, lo que en mi caso hizo que la aplicación terminara.

Answer 19

Mi método se basa en probar / atrapar así:

MyFragment viewer = null;
try {
    viewer = (MyFragment) getFragmentManager().findFragmentByTag(MY_TAG_FRAGMENT);
} catch (ClassCastException e) {
    // not that fragment
}

Pero puede haber una mejor manera ...

Answer 20

Por favor, intente este método .....

private Fragment getCurrentFragment(){
    FragmentManager fragmentManager = getSupportFragmentManager();
    String fragmentTag = fragmentManager.getBackStackEntryAt(fragmentManager.getBackStackEntryCount() - 1).getName();
    Fragment currentFragment = getSupportFragmentManager()
.findFragmentByTag(fragmentTag);
    return currentFragment;
}

Answer 21

Puede agregar una variable de clase selectedFragment, y cada vez que cambie el fragmento, actualice la variable.

public Fragment selectedFragment;
public void changeFragment(Fragment newFragment){
    FragmentManager fragMgr = getSupportFragmentManager();
    FragmentTransaction fragTrans = fragMgr.beginTransaction();
    fragTrans.replace(android.R.id.content, newFragment);
    fragTrans.addToBackStack(null);
    fragTrans.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE);
    fragTrans.commit();
    //here you update the variable
    selectedFragment = newFragment;
}

Entonces puedes usar Frigment seleccionado donde quieras

Answer 22

Puede consultar qué fragmento se carga en el marco de contenido de Actividades y recuperar la clase de fragmento o el ''nombre simple'' del fragmento (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

Answer 23

Puedes obtener el fragmento actual usando el siguiente código

FragmentClass f = (FragmentClass)viewPager.getAdapter().instantiateItem(viewPager, viewPager.getCurrentItem());

Answer 24

Quizás la forma más sencilla es:

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

Funciono para mi

Answer 25

Sé que es una publicación antigua, pero también tenía problemas con ella anteriormente. Encontró una solución que era hacer esto en la función de escucha 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();

    }

Esto me funcionó 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.

Answer 26

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

findFragmentByID(R.id.container);

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

El siguiente método no funciona. Solo recibe un Fragmento que tiene la etiqueta. No pierdas tu tiempo en 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()

Answer 27

Un poco extraño, pero miré FragmentManager $ FragmentManagerImpl y los siguientes trabajos para mí:

public static Fragment getActiveFragment(Activity activity, int index)
{
    Bundle bundle = new Bundle();
    String key = "i";
    bundle.putInt(key,index);
    Fragment fragment=null;
    try
    {
        fragment = activity.getFragmentManager().getFragment(bundle, key);
    } catch(Exception e){}
    return fragment;
}

para obtener el primer fragmento activo usa 0 como el índice

Answer 28

share funciona para cuando presionas el botón de retroceso o cambias el backstack.

Aunque hice algo ligeramente diferente. Tengo una configuración de escucha de cambio en 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
}

Answer 29

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

Answer 30

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

Esto funciona para mi Debe realizar una comprobación nula antes de recorrer la lista de fragmentos. Puede haber un escenario en el que no se carguen fragmentos en la pila.

El fragmento devuelto puede compararse con el fragmento que desea colocar en la pila.