我如何获得当前显示的片段?

小开

我的方法是基于try / catch，如下所示:

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

但也许有更好的办法……

小开

当您在事务中添加片段时，您应该使用标记。

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

小开

每次当你显示fragment时，你必须把它标签放入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);
}

小开

在主活动中，当一个新的片段附加到活动时，将调用onAttachFragment(Fragment fragment)方法。在此方法中，您可以获得当前片段的实例。然而，当一个片段从后面的堆栈弹出时，onAttachFragment(Fragment 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;
}

小开

如果您使用支持库v13，则此问题已修复，您应该简单地覆盖:

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

问题是，你不能将两者混合，因为fragment与版本4的fragment类不兼容。

如果不是，并且您正在使用V4支持库，则将setPrimaryItem方法覆盖到FragmentStatePagerAdapter。

我用这个在大列表中更新Actionbat标题。

小开

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

小开

也许最简单的方法是:

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

这对我很有效

小开

我用什么来寻找当前显示片段是在下面的代码。这很简单，现在对我来说很有用。它运行在持有片段的活动中

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

小开

现在有点晚了，但是对于任何感兴趣的人来说: 如果你知道你想要的片段在FragmentManager中的索引，只需获得它的引用并检查isMenuVisible()函数!: < / p >

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

如果true对用户可见，等等!

小开

我知道这是一个老帖子，但之前也遇到了麻烦。找到了一个解决方案，这是在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();


}

这对我来说很有效，因为我不想遍历每个片段，我必须找到一个可见的片段。

小开

这是我的工作。我希望这能帮助到某人。

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

小开

塞夫的回答适用于当你按下返回按钮或以其他方式更改backstack时。

不过，我做了一些略有不同的事情。我有一个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
}

小开

使用事件总线(如奥托， EventBus或RxJava总线)在这些情况下特别方便。

虽然这种方法不一定会将当前可见的片段作为对象传递给您(尽管也可以这样做，但这会导致更长的调用链)，但它允许您在当前可见的片段上执行操作(这通常是您想要知道当前可见的片段所做的事情)。

确保您尊重片段生命周期，并在适当的时间注册/取消注册事件总线
此时，您需要知道当前可见的片段并执行一组操作。使用事件总线输出事件。

所有已注册到总线的可见片段都将执行必要的操作。

小开

我遇到了一个类似的问题，我想知道当返回键被按下时最后显示的片段是什么。我用了一个非常简单的方法。每次我打开一个片段，在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;
}

小开

如果你从父活动中获得Fragment的当前实例，你可以

findFragmentByID(R.id.container);

这实际上是视图中填充的fragment的当前实例。我也有同样的问题。我不得不加载相同的片段两次，保持一个备份。

下面的方法不起作用。它只是得到一个带有标签的片段。不要在这个方法上浪费时间。我相信它有它的用途，但获得同一片段的最新版本不是其中之一。

findFragmentByTag()

小开

您可以使用以下代码获取当前片段

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

小开

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
}

小开

您可以添加一个类变量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

小开

你好，我知道这是一个非常老的问题，但我想分享我自己的解决方案。

为了获得用户浏览的片段列表，我创建了一个helper类:

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

进入主活动，我重写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()获得活动片段

我希望这对任何人都有帮助

问候

小开

无功方式:

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

小开

这个问题得到了很多观点和关注，但仍然没有得到控制从我的端最简单的解决方案-使用getFragments().

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

小开

受Tainy的答案启发，以下是我的观点。与大多数其他实现相比几乎没有修改。

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"是你当前的活动，用"this"替换它，或者使用你的活动的引用。

小开

在SupportFragmentManager中有一个名为findFragmentById()的方法。我在活动容器中使用它，就像:

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

这就是获取当前Fragment的方法。如果你有自定义Fragment并且需要检查它是什么，我通常使用instanceof:

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

小开

我想你想知道你在哪个片段中我想有一个解决办法，但我认为它不是最好的但这是可行的 首先，

你应该创建你的父片段，它扩展fragment

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


}

不要忘记在header中定义这个:

private Fragment fragment;
FragmentTransaction tx;

小开

这是获得当前片段的简单方法。

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

小开

在滚动片段的情况下，当你使用ViewPager类的实例时，假设mVeiwPager，你可以调用mviewpage . 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)
//         ...
}

小开

您可以查询哪个片段被加载到您的Activities内容框架中，并检索片段类，或片段“简单名称”(作为字符串)。

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

用法:

Log.d(TAG, getCurrentFragment());

输出:

D/MainActivity: FragOne

小开

我也坚持这一点。我最后做的，只是声明了一个Fragments数组:

private static PlaceholderFragment[] arrFrg;

(在我的情况下，它是PlaceholderFragment)和包装所有这些片段到这个数组没有标记:)

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

我知道，这可能不是最好的解决方案，但它对我来说非常适合:)

小开

我发现findFragmentByTag不是那么方便。如果你的Activity或父Fragment中有String currentFragmentTag，你需要将它保存在onSaveInstanceState中，并在onCreate中恢复它。即使你这样做了，当Activity重新创建时，onAttachFragment将在onCreate之前被调用，所以你不能在onAttachFragment中使用currentFragmentTag(例如。更新一些基于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")。

注意，onAttachFragment中的getCurrentFragment()将不会获得附加的Fragment，而是之前附加的Fragment。

小开

签出此解决方案。我成功拿到了现在的碎片。

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

小开

如果到达这里并且你正在使用芬兰湾的科特林:

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

小开

芬兰湾的科特林;

val currentFragment = supportFragmentManager.fragments.last()

小开

我最近不得不这样做，这里没有一个答案真正适合这种情况。

如果你确信只有一个片段可见(全屏)，那么真的想要找到backstack顶部的内容。例如，作为Fragment的Kotlin:

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

小开

如果你有嵌套片段，如viewpagers内部viewpagers等你想要得到所有嵌套的片段

感谢并感谢马特·蒙布雷回答的一个小调整版本。

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

小开

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

好吧，我想这是对这个问题最直接的回答。

.

小开

如果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
}


}

小开

下面是一个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()
}
}
}

小开

它很简单，你不需要写那么多代码 yourFragment.isAdded() 或 yourFragment.isVisible(); < / p >

我更喜欢isAdded()，它们都返回布尔值使用它在if条件，必须在onCreate()初始化你的片段，否则你会得到空点异常。

小开

你也可以很容易地在logcat中使用URL，它将重定向到当前片段源代码的源代码。首先，你需要在主机活动中添加一个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;
}

小开

简单的方法:

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

小开

如果你正在使用AndroidX Navigation:

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

关于这个导航组件的更多信息: https://developer.android.com/guide/navigation/navigation-getting-started < / p >

小开

如果您正在使用Jetpack导航库:

val currentFragment = defaultNavigator.currentDestination

小开

以上30个答案都不适合我。但这是一个有效的答案:

使用Kotlin，当使用导航组件时:

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

小开

  SupportFragmentManager.BeginTransaction().Replace(Resource.Id.patientFrameHome, test, "Test").CommitAllowingStateLoss();


var fragment = SupportFragmentManager.FindFragmentByTag("Test") as V4Fragment;


if (fragment == null && fragment.IsVisiable is true)
{
}

小开

这样比暴露在这里更安全

supportFragmentManager.fragments.lastOrNull()?.let { currentFragment ->
               

//Do something here
}

小开

我最近不得不这么做

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

我终于找到了容器上的最后一个碎片。

小开

〇应该可以

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

小开

在你的活动中，在创建之前初始化你的片段

    MyFragment myFragment = new MyFragment(); // add this
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
........

然后调用该方法来查看您的片段

openFragment(this.myFragment);

这是方法

(R.id.frame_container)是xml文件中的片段容器id (框架布局)< / p >

 private void openFragment(final Fragment fragment)   {
FragmentManager fragmentManager = getSupportFragmentManager();
FragmentTransaction transaction = fragmentManager.beginTransaction();
transaction.replace(R.id.frame_container, fragment);
transaction.commit();


}

那么在你的活动中，Override方法应该是这样的

    public void onBackPressed() {
if (myFragment.isVisible()) {
myFragment.onBackPressed(this);
return;
}
super.onBackPressed();
}

然后在你的片段中放入这个方法

public  void onBackPressed(Activity activity) {
Toast.makeText(activity, "Back Pressed inside Fragment", Toast.LENGTH_SHORT).show();
}

小开

为这个FragmentManager返回当前活动的主导航片段。

public @Nullable Fragment getPrimaryNavigationFragment()
Fragment fragment = fragmentManager.getPrimaryNavigationFragment();

小开

我只需要这样做，如果你有访问导航控制器，你可以从后面的堆栈很容易地获得当前片段:

// current fragments label/title:
navController.backStack.last.destination.label


// current fragments name:
navController.backStack.last.destination.displayName

要访问导航控制器(替换为正确的名称):

val navController = findNavController(R.id.nav_host_fragment_activity_main)

小开

在androidx.fragment: fragment-ktx: 1.4中，有一种新方法可以获取最近添加到容器中的片段。如果你使用FragmentContainerView作为你的片段的容器，这将很容易:

val fragmentContainer: FragmentContainerView = ...
val currentFragment: Fragment = fragmentContainer.getFragment()