Como obtenho o fragmento exibido no momento?

Estou brincando com fragmentos no Android.

Eu sei que posso alterar um fragmento usando o seguinte 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();

Minha pergunta é, em um arquivo Java, como posso obter a instância do Fragment exibida no momento?

Ao adicionar o fragmento em sua transação, você deve usar uma tag.

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

... e mais tarde, se você quiser verificar se o fragmento está visível:

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

Consulte também http://developer.android.com/reference/android/app/Fragment.html

Eu sei que é um post antigo, mas também estava tendo problemas com ele anteriormente. Encontrei uma solução para fazer isso na onBackStackChanged()função de escuta

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

    }

Isso funcionou para mim, pois não queria percorrer todos os fragmentos que tenho para encontrar um que seja visível. Espero que ajude outra pessoa também.

Aqui está minha solução que eu acho útil para cenários de baixo 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;
}

Toda vez que você mostra um fragmento, deve colocá-lo no backstack:

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

E então, quando você precisar obter o fragmento atual, poderá 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);
}

O que estou usando para encontrar o fragmento de exibição atual está no código abaixo. É simples e funciona para mim agora. É executado na atividade que contém os fragmentos

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

Maneira Kotlin;

val currentFragment = supportFragmentManager.fragments.last()

A maneira reativa :

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

Meu método é baseado em try / catch assim:

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

Mas pode haver uma maneira melhor ...

Bem, essa pergunta teve muitas visualizações e atenção, mas ainda não continha a solução mais fácil do meu lado - usar getFragments ().

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

Você pode consultar qual fragmento é carregado no seu quadro de conteúdo de Atividades e recuperar a classe de fragmento ou o 'nome simples' do fragmento (como uma sequência).

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

Uso:

Log.d(TAG, getCurrentFragment());

Saídas:

D/MainActivity: FragOne

É um pouco tarde, mas para quem estiver interessado: Se você conhece o índice do fragmento desejado no FragmentManager, obtenha uma referência a ele e verifique a função isMenuVisible ()! aqui :

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

Se trueé visível para o usuário e assim por diante!

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
}

Se chegar aqui e você estiver usando o Kotlin:

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

R.id.fragment_containeré o local idonde fragmentestá apresentando em seuactivity

Ou se você deseja uma solução melhor:

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

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

Inspirado pela resposta de Tainy , aqui estão meus dois centavos. Pouco modificado da maioria das outras implementações.

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

Substitua "myActivity"por "this" se for sua atividade atual ou use referência a sua atividade.

Há um método chamado findFragmentById()no SupportFragmentManager. Eu o uso no contêiner de atividades como:

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

É assim que você se atualiza Fragment. Se você tem um costume Fragmente precisa verificar o Fragmentque é, normalmente uso instanceof:

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

Se você estiver usando o AndroidX Navigation:

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

Para mais informações sobre este componente de navegação: https://developer.android.com/guide/navigation/navigation-getting-started

Esta é uma maneira simples de obter o fragmento atual.

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

A resposta de Sev funciona quando você pressiona o botão Voltar ou altera o backstack.

Eu fiz algo um pouco diferente, no entanto. Eu tenho uma configuração de ouvinte de alteração de backstack em um fragmento base e seus fragmentos derivados e esse código está no ouvinte:

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
}

Isso é trabalho para mim. Espero que isso ajude alguém.

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

Se você estiver obtendo a instância atual do Fragment da atividade pai, poderá apenas

findFragmentByID(R.id.container);

Na verdade, essa é a instância atual do fragmento que é preenchida na exibição. Eu tive o mesmo problema. Eu tive que carregar o mesmo fragmento duas vezes, mantendo um no backstack.

O método a seguir não funciona. Apenas obtém um fragmento com a etiqueta. Não perca seu tempo com esse método. Estou certo de que tem seus usos, mas obter a versão mais recente do mesmo fragmento não é um deles.

findFragmentByTag()

Finalize esta solução. Funcionou para mim obter o fragmento atual.

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

Bem, acho que essa é a resposta mais direta a essa pergunta. Eu espero que isso ajude.

Aqui está uma solução Kotlin:

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

Maneira simplificada:

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

Maneira fácil de fazer isso:

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

Na atividade principal, o método onAttachFragment (fragmento de fragmento) é chamado quando um novo fragmento é anexado à atividade. Nesse método, você pode obter a instância do fragmento atual. No entanto, o método onAttachFragment não é chamado quando um fragmento é retirado do backstack, ou seja, quando o botão Voltar é pressionado para colocar o fragmento superior no topo da pilha. Ainda estou procurando um método de retorno de chamada que é acionado na atividade principal quando um fragmento se torna visível dentro da atividade.

No caso de fragmentos rolados, quando sua instância de uso da classe ViewPager, suponha mVeiwPager, você pode chamar mViewPager.getCurrentItem () para obter o número int do fragmento atual.

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

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

Eu achei findFragmentByTagque não é tão conveniente. Se você possui um dos String currentFragmentTagseus Activitypais Fragment, é necessário salvá-lo onSaveInstanceStatee restaurá-lo onCreate. Mesmo se você fizer isso, quando o Activityrecriado onAttachFragmentfor chamado antes onCreate, você não poderá usá currentFragmentTag-lo onAttachFragment(por exemplo, atualizar algumas visualizações com base em currentFragmentTag), porque talvez ainda não seja restaurado.

Eu uso o seguinte código:

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

O documento de FragmentManagerestado que

A ordem dos fragmentos na lista é a ordem em que foram adicionados ou anexados.

Quando você precisar fazer coisas com base no tipo de fragmento atual, use em getCurrentFragment() instance of MyFragmentvez de currentFragmentTag.equals("my_fragment_tag").

Observe que getCurrentFragment()in onAttachFragmentnão receberá o anexo Fragment, mas o anterior anexado.

Eu tive que fazer isso muito recentemente e nenhuma das respostas aqui realmente se adequava a esse cenário.

Se você tem certeza de que apenas um fragmento será visível (tela cheia), realmente deseja encontrar o que está no topo do backstack. Por exemplo, como umKotlin para 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)
        }
    }
}

E use-o como:

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

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

Você pode fazer isso com muita facilidade também com uma URL no logcat que o redirecionará para o código-fonte do código-fonte atual do fragmento. Primeiro, você precisa adicionar um OnBackStackChangedListener na atividade do host, como -

activity.getChildFragmentManager().addOnBackStackChangedListener(backStackListener);

E a implementação OnBackStackChangedListener é -

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

E o método getStackTopName () é -

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