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

Вы можете использовать метод getName() для FragmentManager.BackStackEntry, который был представлен на уровне API 14. Этот метод вернет тег, который вы использовали, когда добавляли фрагмент в стопку с помощью addTobackStack(tag).

int index = getActivity().getFragmentManager().getBackStackEntryCount() - 1
FragmentManager.BackStackEntry backEntry = getFragmentManager().getBackStackEntryAt(index);
String tag = backEntry.getName();
Fragment fragment = getFragmentManager().findFragmentByTag(tag);

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

fragmentTransaction.addToBackStack(tag);

FragmentManager.findFragmentById(fragmentsContainerId) 

функция возвращает ссылку на начало Fragment в стопке. Пример использования:

    fragmentManager.addOnBackStackChangedListener(new OnBackStackChangedListener() {
        @Override
        public void onBackStackChanged() {
            Fragment fr = fragmentManager.findFragmentById(R.id.fragmentsContainer);
            if(fr!=null){
                Log.e("fragment=", fr.getClass().getSimpleName());
            }
        }
    });

Я лично пробовал многие из этих решений и в итоге получил это рабочее решение:

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

protected int getFragmentCount() {
    return getSupportFragmentManager().getBackStackEntryCount();
}

Затем, когда вы добавляете/заменяете свой фрагмент с помощью метода FragmentTransaction, сгенерируйте уникальный тег для вашего фрагмента (например, используя количество фрагментов в вашем стеке):

getSupportFragmentManager().beginTransaction().add(yourContainerId, yourFragment, Integer.toString(getFragmentCount()));

Наконец, вы можете найти любой из ваших фрагментов в вашем бэкстеке с помощью этого метода:

private Fragment getFragmentAt(int index) {
    return getFragmentCount() > 0 ? getSupportFragmentManager().findFragmentByTag(Integer.toString(index)) : null;
}

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

protected Fragment getCurrentFragment() {
    return getFragmentAt(getFragmentCount() - 1);
}

Надеюсь это поможет!

Котлин

// In activities
activity.supportFragmentManager.fragments.lastOrNull()

// In fragments
fragment.childFragmentManager.fragments.lastOrNull()

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

public Fragment getTopFragment() {
    if (getSupportFragmentManager().getBackStackEntryCount() == 0) {
        return null;
    }
    String fragmentTag = getSupportFragmentManager().getBackStackEntryAt(getSupportFragmentManager().getBackStackEntryCount() - 1).getName();
    return getSupportFragmentManager().findFragmentByTag(fragmentTag);
}

В менеджере фрагментов есть список фрагментов. Имейте в виду, что удаление фрагмента не приводит к уменьшению размера списка (запись фрагмента просто становится нулевой). Поэтому правильным решением будет:

public Fragment getTopFragment() {
 List<Fragment> fragentList = fragmentManager.getFragments();
 Fragment top = null;
  for (int i = fragentList.size() -1; i>=0 ; i--) {
   top = (Fragment) fragentList.get(i);
     if (top != null) {
       return top;
     }
   }
 return top;
}

Ответ, данный Deepak Goel, не работает для меня, потому что я всегда получаю null от entry.getName();

Что я делаю, так это устанавливаю тег для фрагмента следующим образом:

ft.add(R.id.fragment_container, fragmentIn, FRAGMENT_TAG);

Где ft — моя фрагментная транзакция, а FRAGMENT_TAG — тег. Затем я использую этот код для получения фрагмента:

Fragment prev_fragment = fragmentManager.findFragmentByTag(FRAGMENT_TAG);

Просто взял ответ @roghayeh hosseini (правильный) и сделал его в Котлине для тех, кто здесь в 2017 году :)

fun getTopFragment(): Fragment? {
    supportFragmentManager.run {
        return when (backStackEntryCount) {
            0 -> null
            else -> findFragmentByTag(getBackStackEntryAt(backStackEntryCount - 1).name)
        }
    }
}

* Это следует вызывать из действия.

Наслаждаться :)

вы можете использовать getBackStackEntryAt(). Чтобы узнать, сколько записей активность содержит в бэкстеке, вы можете использовать getBackStackEntryCount()

int lastFragmentCount = getBackStackEntryCount() - 1;

Похоже, что-то изменилось к лучшему, потому что код ниже у меня отлично работает, но я не нашел его в уже предоставленных ответах.

Котлин:

supportFragmentManager.fragments[supportFragmentManager.fragments.size - 1]

Ява:

getSupportFragmentManager().getFragments()
.get(getSupportFragmentManager().getFragments().size() - 1)

Я добавлю кое-что к Deepak Goel answer, так как многие люди, включая меня, получали нуль, используя его метод. По-видимому, чтобы заставить тег работать, когда вы добавляете фрагмент в стопку, вы должны делать это следующим образом:

getSupportFragmentManager.beginTransaction().replace(R.id.container_id,FragmentName,TAG_NAME).addToBackStack(TAG_NAME).commit();

Вам нужно добавить один и тот же тег дважды.

Я бы прокомментировал, но у меня нет репутации 50.

Держите свой собственный задний стек: myBackStack. Поскольку вы Add добавляете фрагмент к FragmentManager, добавьте его и к myBackStack. В onBackStackChanged() извлекается из myBackStack, когда его длина превышает getBackStackEntryCount.

Если вы используете addToBackStack(), вы можете использовать следующий код.

List<Fragment> fragments = fragmentManager.getFragments(); activeFragment = fragments.get(fragments.size() - 1);

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

Если вы действительно хотите иметь стек фрагментов и иметь доступ к фрагменту по его индексу в стеке, вам лучше иметь слой абстракции над FragmentManager и его задним стеком. Вот как это сделать:

public class FragmentStackManager {
  private final FragmentManager fragmentManager;
  private final int containerId;

  private final List<Fragment> fragments = new ArrayList<>();

  public FragmentStackManager(final FragmentManager fragmentManager,
      final int containerId) {
    this.fragmentManager = fragmentManager;
    this.containerId = containerId;
  }

  public Parcelable saveState() {
    final Bundle state = new Bundle(fragments.size());
    for (int i = 0, count = fragments.size(); i < count; ++i) {
      fragmentManager.putFragment(state, Integer.toString(i), fragments.get(i));
    }
    return state;
  }

  public void restoreState(final Parcelable state) {
    if (state instanceof Bundle) {
      final Bundle bundle = (Bundle) state;
      int index = 0;
      while (true) {
        final Fragment fragment =
            fragmentManager.getFragment(bundle, Integer.toString(index));
        if (fragment == null) {
          break;
        }

        fragments.add(fragment);
        index += 1;
      }
    }
  }

  public void replace(final Fragment fragment) {
    fragmentManager.popBackStackImmediate(
        null, FragmentManager.POP_BACK_STACK_INCLUSIVE);
    fragmentManager.beginTransaction()
        .replace(containerId, fragment)
        .addToBackStack(null)
        .commit();
    fragmentManager.executePendingTransactions();

    fragments.clear();
    fragments.add(fragment);
  }

  public void push(final Fragment fragment) {
    fragmentManager
        .beginTransaction()
        .replace(containerId, fragment)
        .addToBackStack(null)
        .commit();
    fragmentManager.executePendingTransactions();

    fragments.add(fragment);
  }

  public boolean pop() {
    if (isEmpty()) {
      return false;
    }

    fragmentManager.popBackStackImmediate();

    fragments.remove(fragments.size() - 1);
    return true;
  }

  public boolean isEmpty() {
    return fragments.isEmpty();
  }

  public int size() {
    return fragments.size();
  }

  public Fragment getFragment(final int index) {
    return fragments.get(index);
  }
}

Теперь вместо того, чтобы добавлять и удалять фрагменты, вызывая FragmentManager напрямую, вы должны использовать методы push(), replace() и pop() из FragmentStackManager. И вы сможете получить доступ к самому верхнему фрагменту, просто вызвав stack.get(stack.size() - 1).

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

Первый способ — просто добавить все активные фрагменты в диспетчер фрагментов. Если вы просто замените фрагменты один за другим и извлечете их из стека, этот метод вернет самый верхний фрагмент:

public class BackStackHelper {
  public static List<Fragment> getTopFragments(
      final FragmentManager fragmentManager) {
    final List<Fragment> fragments = fragmentManager.getFragments();
    final List<Fragment> topFragments = new ArrayList<>();

    for (final Fragment fragment : fragments) {
      if (fragment != null && fragment.isResumed()) {
        topFragments.add(fragment);
      }
    }

    return topFragments;
  }
}

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

package android.support.v4.app;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class BackStackHelper {
  public static List<Fragment> getTopFragments(
      final FragmentManager fragmentManager) {
    if (fragmentManager.getBackStackEntryCount() == 0) {
      return Collections.emptyList();
    }

    final List<Fragment> fragments = new ArrayList<>();

    final int count = fragmentManager.getBackStackEntryCount();
    final BackStackRecord record =
        (BackStackRecord) fragmentManager.getBackStackEntryAt(count - 1);
    BackStackRecord.Op op = record.mHead;
    while (op != null) {
      switch (op.cmd) {
        case BackStackRecord.OP_ADD:
        case BackStackRecord.OP_REPLACE:
        case BackStackRecord.OP_SHOW:
        case BackStackRecord.OP_ATTACH:
          fragments.add(op.fragment);
      }
      op = op.next;
    }

    return fragments;
  }
}

Обратите внимание, что в этом случае вы должны поместить этот класс в пакет android.support.v4.app.

Или вы можете просто добавить тег при добавлении фрагментов, соответствующих их содержимому, и использовать простое статическое поле String (также вы можете сохранить его в пакете экземпляра активности в методе onSaveInstanceState(Bundle)) для хранения последнего добавленного тега фрагмента и получить этот фрагмент поTag() в любое время вам нужно...

Самый высокий (Deepak Goel) ответ не сработал для меня. Почему-то тег не был добавлен должным образом.

В итоге я просто отправил идентификатор фрагмента через поток (используя намерения) и получил его непосредственно из диспетчера фрагментов.

Разработчики Kotlin могут использовать это для получения текущего фрагмента:

        supportFragmentManager.addOnBackStackChangedListener {
        val myFragment = supportFragmentManager.fragments.last()

        if (null != myFragment && myFragment is HomeFragment) {
            //HomeFragment is visible or currently loaded
        } else {
            //your code
        }
    }