obtener fragmento actualmente mostrado

Estoy jugando con Fragment 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 de 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 más tarde si quieres comprobar si el fragmento está 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 anterior, pero también estaba teniendo problemas con ella anteriormente. Encontré una solución que debía 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 funcionó para mí, ya que no quería recorrer cada fragmento 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 fragmentos pequeños

 public Fragment getVisibleFragment(){ FragmentManager fragmentManager = MainActivity.this.getSupportFragmentManager(); List 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 ponerlo en el 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); } 

Lo que estoy usando para encontrar el fragmento de visualización actual está en el código siguiente. Es simple y me funciona 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); 

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 como este:

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

Pero puede haber una mejor manera …

Bueno, esta pregunta recibió muchas vistas 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); 

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

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

Si es true visible 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 } 

Inspirado por la respuesta de Tainy , aquí está mi granito de arena. 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 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 tu Fragment actual. Si tiene Fragment personalizado y necesita verificar qué Fragment es, normalmente utilizo instanceof :

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

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

La respuesta de Sev funciona cuando pulsas el botón Atrás o si no cambias la stack trasera.

Aunque hice algo ligeramente diferente. Tengo una configuración de detector de cambio de backstack en un Fragmento base y sus fragmentos derivados y este código está en el oyente:

 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 pueda ayudar 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 Fragment de la actividad principal, puede simplemente

 findFragmentByID(R.id.container); 

Esto realmente es la instancia actual de fragmento que se llena 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. Simplemente obtiene 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() 
 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"); } 

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

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

Uso:

 Log.d(TAG, getCurrentFragment()); 

Productos:

 D/MainActivity: FragOne 

En la actividad principal, se llama al método onAttachFragment (Fragmento fragmentado) 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 saca un fragmento de la backstack, es decir, cuando se presiona el botón Atrás para obtener el fragmento superior en la parte superior de la stack. Todavía estoy buscando un método de callback que se activa en la actividad principal cuando un fragmento se vuelve visible dentro de la actividad.

Me encontré con un problema similar, donde quería saber qué fragmento se mostró por última vez cuando se presionó la tecla de retroceso. Usé una solución muy simple que funcionó para mí. Cada vez que abro un fragmento, en el método onCreate (), configuro una variable en mi singleton (reemplace “myFragment” con el nombre de su fragmento)

 MySingleton.currentFragment = myFragment.class; 

La variable se declara en singleton como

 public static Class currentFragment = null; 

Luego, en el onBackPressed () yo controlo

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

Asegúrese de llamar al super.onBackPressed (); después de la “devolución”, de lo contrario, la aplicación procesará la tecla de retroceso, que en mi caso provocó que la aplicación finalizara.

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

en MainLayout.xml

          

Quizás la forma más simple es:

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

Funcionó para mí

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

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

  1. asegúrese de respetar el ciclo de vida del fragmento y registrar / anular el registro del bus de eventos en el momento apropiado
  2. en el punto donde necesitas saber el fragmento visible actualmente y ejecutar un conjunto de acciones. dispara un evento con el bus de eventos.

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

Un poco extraño, pero miré FragmentManager $ FragmentManagerImpl y me funciona lo siguiente:

 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 use 0 como índice

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

Esto funciona para mí Debe realizar una comprobación nula antes de iterar a través de la lista de fragmentos. Puede haber un escenario en el que no se carguen fragmentos en la stack.

El fragmento que regresa se puede comparar con el fragmento que desea colocar en la stack.

Por favor prueba este método …..

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

Puedes obtener el fragmento actual usando el siguiente código

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

Puedes agregar una variable de clase selectedFragment y cada vez que cambies el fragmento actualizarás 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 selectedFragment donde quieras

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 de ayuda:

 public class MyHelperClass{ private static ArrayList 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 AttachFragment

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

y también, sobreescribo en el método BackPressed:

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

para que de esta forma, en cualquier momento, puedas obtener el fragmento activo con MyHelperClass.getCurrentFragment ()

Espero que esto sea útil para cualquiera

Saludos

Bueno, creo que quieres ver en qué fragmento estás, supongo que hay una solución. No creo que sea la mejor, pero funciona. Primero.


deberías crear tu fragmento padre que extiende Fragmento


 public class Fragment2 extends Fragment { private static position; public static int getPosition() { return position; } public static void setPosition(int position) { FragmentSecondParent.position = position; } } 

Segundo

deberías extenderlo en cada fragmento y en cada escribir en onCreateView

 setPosition(//your fragmentposition here) 

Tercero


donde quieras obtener el fragmento actual que deberías


escribe esto

 Fragment2 fragment= (Fragment2) getSupportFragmentManager() .findFragmentById(R.id.fragment_status); int position = fragment.getPosition(); if(//position condition) { //your code here }