Comment obtenir le fragment actuellement affiché?

Je joue avec des fragments dans Android.

Je sais que je peux modifier un fragment en utilisant le code suivant:

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

Ma question est, dans un fichier Java, comment puis-je obtenir l'instance de fragment actuellement affichée?

Lorsque vous ajoutez le fragment dans votre transaction, vous devez utiliser une balise.

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

... et plus tard si vous souhaitez vérifier si le fragment est visible:

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

Voir également http://developer.android.com/reference/android/app/Fragment.html

Je sais que c'est un ancien poste, mais j'avais déjà eu des problèmes avec lui auparavant. Trouvé une solution qui était de le faire dans la onBackStackChanged()fonction d'écoute

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

    }

Cela a fonctionné pour moi car je ne voulais pas parcourir chaque fragment que je dois trouver un qui est visible. J'espère que ça aide quelqu'un d'autre aussi.

Voici ma solution que je trouve pratique pour les scénarios à faible fragment

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

Chaque fois que vous montrez un fragment, vous devez le mettre en backstack:

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

Et puis, lorsque vous devez obtenir le fragment actuel, vous pouvez utiliser cette méthode:

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

Ce que j'utilise pour trouver le fragment d'affichage actuel est dans le code ci-dessous. C'est simple et ça marche pour moi maintenant. Il s'exécute dans l'activité qui détient les fragments

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

Façon Kotlin;

val currentFragment = supportFragmentManager.fragments.last()

La manière réactive :

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

Ma méthode est basée sur try / catch comme ceci:

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

Mais il peut y avoir une meilleure façon ...

Eh bien, cette question a suscité beaucoup de vues et d'attention, mais ne contenait toujours pas la solution la plus simple de mon côté - utiliser getFragments ().

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

Vous pouvez interroger quel fragment est chargé dans votre cadre de contenu Activités et récupérer la classe de fragment ou le fragment «nom simple» (sous forme de chaîne).

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

Usage:

Log.d(TAG, getCurrentFragment());

Les sorties:

D/MainActivity: FragOne

C'est un peu tard, mais pour tous ceux qui sont intéressés: si vous connaissez l'index du fragment souhaité dans FragmentManager, obtenez simplement une référence et vérifiez la fonction isMenuVisible ()! ici :

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

Si c'est truevisible pour l'utilisateur et ainsi de suite!

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 vous arrivez ici et que vous utilisez Kotlin:

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

R.id.fragment_containerest l' idendroit où le fragmentprésente sur leuractivity

Ou si vous voulez une meilleure solution:

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

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

Inspiré par la réponse de Tainy , voici mes deux cents. Peu modifié de la plupart des autres implémentations.

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

Remplacez-le "myActivity"par «ceci» s'il s'agit de votre activité actuelle ou utilisez une référence à votre activité.

Il y a une méthode appelée findFragmentById()dans SupportFragmentManager. Je l'utilise dans le conteneur d'activités comme:

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

Voilà comment obtenir votre courant Fragment. Si vous avez des coutumes Fragmentet devez vérifier de quoi Fragmentil s'agit, j'utilise normalement instanceof:

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

Si vous utilisez AndroidX Navigation:

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

Pour plus d'informations sur ce composant de navigation: https://developer.android.com/guide/navigation/navigation-getting-started

C'est un moyen simple d'obtenir le fragment actuel.

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 réponse de Sev fonctionne lorsque vous appuyez sur le bouton de retour ou que vous modifiez le backstack.

J'ai cependant fait quelque chose de légèrement différent. J'ai une configuration d'écouteur de changement de backstack sur un fragment de base et ses fragments dérivés et ce code est dans l'écouteur:

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
}

C'est du travail pour moi. J'espère que cela va aider quelqu'un.

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

Si vous obtenez l'instance actuelle de Fragment de l'activité parent, vous pouvez simplement

findFragmentByID(R.id.container);

Il s'agit en fait de l'instance actuelle de fragment qui est remplie sur la vue. J'ai eu le même problème. J'ai dû charger le même fragment deux fois en en gardant un sur le backstack.

La méthode suivante ne fonctionne pas. Il obtient juste un fragment qui a la balise. Ne perdez pas votre temps avec cette méthode. Je suis sûr qu'il a ses utilisations, mais pour obtenir la version la plus récente du même fragment n'en fait pas partie.

findFragmentByTag()

Découvrez cette solution. Cela a fonctionné pour moi d'obtenir le fragment actuel.

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

Eh bien, je suppose que c'est la réponse la plus simple à cette question. J'espère que ça aide.

Voici une solution Kotlin:

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

Manière simplifiée:

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

Un moyen simple de le faire:

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

Dans l'activité principale, la méthode onAttachFragment (Fragment fragment) est appelée lorsqu'un nouveau fragment est attaché à l'activité. Dans cette méthode, vous pouvez obtenir l'instance du fragment actuel. Cependant, la méthode onAttachFragment n'est pas appelée lorsqu'un fragment est extrait de la backstack, c'est-à-dire lorsque le bouton de retour est enfoncé pour placer le fragment supérieur au sommet de la pile. Je recherche toujours une méthode de rappel qui est déclenchée dans l'activité principale lorsqu'un fragment devient visible à l'intérieur de l'activité.

Dans le cas de fragments déroulants, lorsque votre instance d'utilisation de la classe ViewPager suppose mVeiwPager, vous pouvez appeler mViewPager.getCurrentItem () pour obtenir le numéro actuel du fragment int.

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

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

J'ai trouvé findFragmentByTagque ce n'était pas pratique. Si vous en avez String currentFragmentTagdans votre Activityou parent Fragment, vous devez l'enregistrer onSaveInstanceStateet le restaurer onCreate. Même si vous le faites, lors de la Activityrecréation, onAttachFragmentsera appelé avant onCreate, vous ne pouvez donc pas l'utiliser currentFragmentTagdans onAttachFragment(par exemple, mettre à jour certaines vues en fonction decurrentFragmentTag ), car il n'est peut-être pas encore restauré.

J'utilise le code suivant:

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

Le document FragmentManagerindiquant que

L'ordre des fragments dans la liste est l'ordre dans lequel ils ont été ajoutés ou attachés.

Lorsque vous devez faire des choses en fonction du type de fragment actuel, utilisez simplement getCurrentFragment() instance of MyFragmentau lieu de currentFragmentTag.equals("my_fragment_tag").

Notez que getCurrentFragment()in onAttachFragmentn'obtiendra pas la pièce Fragmentjointe, mais la précédente attachée.

J'ai dû le faire très récemment et aucune des réponses ici ne convenait vraiment à ce scénario.

Si vous êtes sûr qu'un seul fragment sera visible (plein écran), alors voulez vraiment trouver ce qui se trouve en haut du backstack. Par exemple, comme Kotlinpour 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)
        }
    }
}

Et utilisez-le comme:

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

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

Vous pouvez le faire très facilement également avec une URL dans logcat qui vous redirigera vers le code source du code source du fragment actuel. Tout d'abord, vous devez ajouter un OnBackStackChangedListener dans l'activité hôte comme -

activity.getChildFragmentManager().addOnBackStackChangedListener(backStackListener);

Et l' implémentation OnBackStackChangedListener est -

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

Et la méthode getStackTopName () est -

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