android obtener el fragmento que se muestra actualmente





15 Answers

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.

android android-layout android-intent android-fragments

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?




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



La forma reactive :

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



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!




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
}



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
}



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
}



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



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



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.




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




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.




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.




Puedes obtener el fragmento actual usando el siguiente código

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



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




Related