Как мне получить отображаемый в данный момент фрагмент?

Когда вы добавляете фрагмент в свою транзакцию, вы должны использовать тег.

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

... и позже, если вы хотите проверить, виден ли фрагмент:

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

См. Также http://developer.android.com/reference/android/app/Fragment.html

Я знаю, что это старый пост, но и раньше с ним были проблемы. Нашел решение, которое должно было сделать это в функции прослушивания 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();

    }

Это сработало для меня, поскольку я не хотел перебирать каждый фрагмент, который мне нужно было найти, чтобы найти тот, который виден. Надеюсь, это поможет и кому-то другому.

Вот мое решение, которое я считаю удобным для сценариев с низким фрагментом

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

Каждый раз, когда вы показываете фрагмент, вы должны поместить его тег в backstack:

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

А затем, когда вам нужно получить текущий фрагмент, вы можете использовать этот метод:

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

Котлинский путь;

val currentFragment = supportFragmentManager.fragments.last()

То, что я использую, чтобы найти текущий отображаемый фрагмент, находится в приведенном ниже коде. Это просто и сейчас у меня работает. Он работает в действии, которое содержит фрагменты

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

реактивный способ:

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

Мой метод основан на следующем:

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

Но может быть способ получше ...

Что ж, этот вопрос получил много просмотров и внимания, но все же не содержал самого простого решения с моей стороны - использовать getFragments ().

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

Если вы используете AndroidX Navigation:

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

Для получения дополнительной информации об этом компоненте навигации: https://developer.android.com/guide/navigation/navigation-getting-started

Вы можете запросить, какой фрагмент загружен во фрейм содержимого Activity, и получить класс фрагмента или «простое имя» фрагмента (в виде строки).

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

Использование:

Log.d(TAG, getCurrentFragment());

Выходы:

D/MainActivity: FragOne

Немного поздно, но для всех, кому интересно: если вы знаете индекс нужного фрагмента в FragmentManager, просто получите ссылку на него и проверьте функцию isMenuVisible ()! здесь :

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

Если true Это видно пользователю и так далее!

Если вы попали сюда и используете Kotlin:

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

R.id.fragment_container - это id, где fragment представлены на своих activity

Или, если вам нужно более приятное решение:

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

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

В SupportFragmentManager есть метод под названием findFragmentById(). Я использую его в контейнере активности, например:

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

Вот как получить свой текущий Fragment. Если у вас есть пользовательский Fragment и вам нужно проверить, что это Fragment, я обычно использую instanceof:

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

Вдохновленный ответом Тайни, вот мои два цента. Немного изменен по сравнению с большинством других реализаций.

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

Замените "myActivity" на «это», если это ваша текущая деятельность, или используйте ссылку на вашу деятельность.

Это простой способ получить текущий фрагмент ..

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

Ознакомьтесь с этим решением. Мне удалось получить текущий фрагмент.

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

это так просто, не так уж много кода нужно писать yourFragment.isAdded() или yourFragment.isVisible();

Я предпочитаю isAdded (), оба из них возвращают логическое значение, используйте его в условии if и должны инициализировать свой фрагмент в onCreate (), иначе вы получите исключение с нулевой точкой.

Ответ Сева работает, когда вы нажимаете кнопку "Назад" или иным образом меняете стек назад.

Но я сделал что-то немного другое. У меня есть настройка прослушивателя изменений backstack на базовом фрагменте и его производных фрагментах, и этот код находится в прослушивателе:

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
}

Простой способ сделать это:

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

Это работа для меня. Надеюсь, это кому-то поможет.

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

Если вы получаете текущий экземпляр фрагмента из родительского действия, вы можете просто

findFragmentByID(R.id.container);

Это фактически получает текущий экземпляр фрагмента, который заполняется в представлении. Я была такая же проблема. Мне пришлось дважды загрузить один и тот же фрагмент, оставив один на заднем стеке.

Следующий метод не работает. Он просто получает фрагмент с тегом. Не тратьте время на этот метод. Я уверен, что он его использует, но получить самую последнюю версию того же фрагмента - не один из них.

findFragmentByTag()

getSupportFragmentManager().findFragmentById(R.id.content_frame).getClass().getSimpleName();

Что ж, я думаю, это наиболее прямой ответ на этот вопрос. Надеюсь, это поможет.

Вы можете сделать это очень легко также с помощью URL-адреса в logcat, который перенаправит вас на исходный код текущего исходного кода фрагмента. Во-первых, вам нужно добавить OnBackStackChangedListener в активность хоста, например:

activity.getChildFragmentManager().addOnBackStackChangedListener(backStackListener);

И реализация 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");
    };

А метод 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;
}

Ни один из 30 приведенных выше ответов не помог мне полностью. Но вот ответ, который сработал:

Используя Kotlin, при использовании компонента навигации:

fun currentVisibleFragment(): Fragment? {
    return supportFragmentManager.fragments.first()?.getChildFragmentManager()?.getFragments()?.get(0)
}

В случае прокрученных фрагментов, когда вы используете экземпляр класса ViewPager, предположим, что mVeiwPager, вы можете вызвать mViewPager.getCurrentItem () для получения текущего номера int фрагмента.

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

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

Я обнаружил, что findFragmentByTag не так уж и удобен. Если у вас есть String currentFragmentTag в вашем Activity или родительском Fragment, вам нужно сохранить его в onSaveInstanceState и восстановить в onCreate. Даже если вы это сделаете, когда Activity воссоздается, onAttachFragment будет вызываться перед onCreate, поэтому вы не можете использовать currentFragmentTag в onAttachFragment (например, обновить некоторые представления на основе currentFragmentTag), потому что он может еще не восстановлен.

Я использую следующий код:

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

В документе FragmentManager говорится, что

Порядок фрагментов в списке - это порядок, в котором они были добавлены или прикреплены.

Когда вам нужно сделать что-то на основе текущего типа фрагмента, просто используйте getCurrentFragment() instance of MyFragment вместо currentFragmentTag.equals("my_fragment_tag").

Обратите внимание, что getCurrentFragment() в onAttachFragment получит не прикрепленный Fragment, а предыдущий прикрепленный.

Мне пришлось сделать это совсем недавно, и ни один из ответов здесь не подходил для этого сценария.

Если вы уверены, что будет виден только один фрагмент (в полноэкранном режиме), вы действительно хотите найти то, что находится наверху backstack. Например, как Kotlin для 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)
        }
    }
}

И используйте это так:

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

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

Вот решение Kotlin:

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

Упрощенный способ:

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

Если вы используете библиотеку Jetpack Navigation:

val currentFragment = defaultNavigator.currentDestination

Котлин безопаснее, чем здесь

supportFragmentManager.fragments.lastOrNull()?.let { currentFragment ->
               
      //Do something here
 }

В основном действии метод onAttachFragment(Fragment fragment) вызывается, когда к действию присоединяется новый фрагмент. В этом методе вы можете получить экземпляр текущего фрагмента. Однако метод onAttachFragment(Fragment fragment) не вызывается, когда фрагмент извлекается из заднего стека, то есть когда нажимается кнопка возврата, чтобы поместить верхний фрагмент на вершину стека. Я все еще ищу метод обратного вызова, который запускается в основном действии, когда фрагмент становится видимым внутри действия.

Я должен был сделать это совсем недавно

public Fragment getCurrentFragment() {
     return fragmentManager.findFragmentById(R.id.container);
}

и, наконец, я получил последний фрагмент на этом контейнере.

Это должно сработать -

val visibleFragment = supportFragmentManager.fragments.findLast { fgm -> fgm.isVisible }
Timber.d("backStackIterator: visibleFragment: $visibleFragment")

Возможно, самый простой способ:

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

Это сработало для меня

Использование шины событий (например, Otto, EventBus или RxJava Bus) особенно удобен в таких ситуациях.

Хотя этот подход не обязательно передает вам видимый в данный момент фрагмент как объект (хотя это тоже можно сделать, но это приводит к более длинной цепочке вызовов), он позволяет выполнять действия с видимым в данный момент фрагментом (обычно это то, что вы хотите знать текущий видимый фрагмент).

1. убедитесь, что вы соблюдаете жизненный цикл фрагмента и зарегистрируете / отмените регистрацию шины событий в подходящее время
2. в момент, когда вам нужно узнать видимый в данный момент фрагмент и выполнить набор действий. снимать событие с автобусом событий.

все видимые фрагменты, зарегистрированные на шине, выполнят необходимое действие.

Я столкнулся с аналогичной проблемой, когда хотел узнать, какой фрагмент отображался последним при нажатии клавиши возврата. Я использовал очень простое решение, которое мне помогло. Каждый раз, когда я открываю фрагмент, в методе onCreate () я устанавливаю переменную в своем синглтоне (замените myFragment на имя вашего фрагмента)

MySingleton.currentFragment = myFragment.class;

Переменная объявлена ​​в синглтоне как

public static Class currentFragment = null; 

Затем в onBackPressed () я проверяю

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

Обязательно вызовите super.onBackPressed (); после «возврата», иначе приложение обработает клавишу возврата, что в моем случае привело к завершению работы приложения.

Немного странно, но я посмотрел на FragmentManager $ FragmentManagerImpl, и у меня работает следующее:

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

чтобы получить первый активный фрагмент, используйте 0 в качестве индекса

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

У меня это работает. Перед перебором списка фрагментов необходимо выполнить нулевую проверку. Возможен сценарий, при котором в стек не загружаются фрагменты.

Возвращаемый фрагмент можно сравнить с фрагментом, который вы хотите поместить в стек.

Пожалуйста, попробуйте этот метод .....

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

Вы можете получить текущий фрагмент, используя следующий код

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

Вы можете добавить переменную класса selectedFragment, и каждый раз, когда вы меняете фрагмент, вы обновляете переменную.

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

тогда вы можете использовать selectedFragment где угодно

Здравствуйте, я знаю, что это очень старая проблема, но я хотел бы поделиться своим собственным решением ..

Чтобы получить список просматриваемых фрагментов пользователем, я создал вспомогательный класс:

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

И в основном Activity я переопределяю метод onAttachFragment

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

    MyHelperClass.addFragment(f);
}

а также я переопределяю метод 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();
        }
}

таким образом вы в любое время можете получить активный фрагмент с помощью MyHelperClass.getCurrentFragment ()

Я надеюсь, что это будет полезно для всех

С уважением

ну, я думаю, вы хотите увидеть, в каком фрагменте вы находитесь, я думаю, есть решение, которое я не думаю, что оно лучшее, но оно работает Во-первых, вообще

вы должны создать свой родительский фрагмент, который расширяет фрагмент

public class Fragment2 extends Fragment {
    private static position;
    public static int getPosition() {
        return position;
    }

    public static void setPosition(int position) {
        FragmentSecondParent.position = position;
    }
}

Второй

вы должны расширять его в каждом фрагменте и при каждой записи в onCreateView

setPosition(//your fragmentposition here)

Третий

где вы хотите получить текущий фрагмент, вы должны

напиши это

Fragment2 fragment= (Fragment2) getSupportFragmentManager()
    .findFragmentById(R.id.fragment_status);

int position = fragment.getPosition();
if(//position condition)
{
    //your code here
}

это лучший способ:

       android.app.Fragment currentFragment=getFragmentManager().findFragmentById(R.id.main_container);
            if(currentFragment!=null)
            {
                String[] currentFragmentName = currentFragment.toString().split("\\{");
                if (currentFragmentName[0].toString().equalsIgnoreCase("HomeSubjectFragment"))
                {
                    fragment = new HomeStagesFragment();
                    tx = getSupportFragmentManager().beginTransaction();
                    tx.replace(R.id.main_container, fragment);
                    tx.addToBackStack(null);
                    tx.commit();
                }
                else if(currentFragmentName[0].toString().equalsIgnoreCase("HomeStagesFragment"))
                {
                    new AlertDialog.Builder(this)
                            .setMessage("Are you sure you want to exit?")
                            .setCancelable(false)
                            .setPositiveButton("Yes", new DialogInterface.OnClickListener() {
                                public void onClick(DialogInterface dialog, int id) {
                                    finish();
                                }
                            })
                            .setNegativeButton("No", null)
                            .show();
                }

            }

не забудьте указать это в заголовке:

private Fragment fragment;
FragmentTransaction tx;

Если вы используете библиотеку поддержки v13, эта проблема устранена, и вам следует просто переопределить:

@Override
public void setUserVisibleHint(boolean isVisibleToUser)
{
    // TODO Auto-generated method stub
    super.setUserVisibleHint(isVisibleToUser);
}

Дело в том, что вы не можете смешивать их, потому что фрагмент несовместим с классом фрагментов версии 4.

Если это не так и вы используете библиотеку поддержки V4, переопределите метод setPrimaryItem для своего FragmentStatePagerAdapter.

Я использовал это для обновления названия Actionbat в больших списках.

Я тоже придерживался этой точки зрения. В конце концов я просто объявил массив фрагментов:

private static PlaceholderFragment[] arrFrg;

(в моем случае это PlaceholderFragment) и упаковал все эти Fragemnts в этот массив без тегов :)

        public static PlaceholderFragment newInstance(int sectionNumber) {
            final PlaceholderFragment fragment = new PlaceholderFragment();
            Bundle args = new Bundle();
            args.putInt(ARG_SECTION_NUMBER, sectionNumber);
            fragment.setArguments(args);
            arrFrg[sectionNumber] = fragment;

            return fragment;
}

Затем вы можете легко получить доступ к текущему отображаемому фрагменту:

arrFrg[mViewPager.getCurrentItem()];

Я понимаю, это, наверное, не лучшее решение, но у меня оно отлично работает :)

Если у вас есть вложенные фрагменты, например страницы просмотра внутри страниц просмотра и т. Д., И вы хотите получить все вложенные фрагменты.

Спасибо и любезно предоставил ответ Мэтта Момбреа, немного измененную версию.

private List<Fragment> getVisibleFragments(List<Fragment> searchFragments, List<Fragment> visibleFragments) {
    if (searchFragments != null && searchFragments.size() > 0) {
        for (Fragment fragment : searchFragments) {
            List<Fragment> nestedFragments = new ArrayList<>();
            List<Fragment> childFMFragments = fragment.getChildFragmentManager().getFragments();
            List<Fragment> fmFragments = fragment.getFragmentManager().getFragments();
            fmFragments.retainAll(childFMFragments);
            nestedFragments.addAll(childFMFragments);
            nestedFragments.addAll(fmFragments);
            getVisibleFragments(nestedFragments, visibleFragments);
            if (fragment != null && fragment.isVisible()) {
                visibleFragments.add(fragment);
            }
        }
    }
    return visibleFragments;
}

А вот и использование:

List<Fragment> allVisibleFragments = getVisibleFragments(searchFragments, visibleFragments);

Например:

List<Fragment> visibleFragments = new ArrayList<>();
List<Fragment> searchFragments = MainActivity.this.getSupportFragmentManager().getFragments();
Toast.makeText(this, ""+getVisibleFragments(searchFragments, visibleFragments), Toast.LENGTH_LONG).show();

если getFragmentManager () не работает, попробуйте использовать getSupportFragmentManager () и добавить тег во время загрузки фрагмента.

public void onBackPressed(){

    Fragment fragment=getSupportFragmentManager().findFragmentByTag(/*enter your tag*/);


    if(fragment!=null && fragment.isVisible())
    {
        //do your code here
    }
    else
    {
       //do your code here
    }

}

для тех, кто ищет его в 2021 году, просто сделайте это: (R.id.fragment - это идентификатор вашего контейнера)

    val activeFragment  = this.supportFragmentManager.findFragmentById(R.id.fragment)?.childFragmentManager?.primaryNavigationFragment

    if (activeFragment is DetailFragment){
        (activeFragment as DetailFragment).onPermissionResult(permissionGranted)
    }