如何确定 Fragment 何时在 ViewPager 中可见

Question

问题： ViewPager中的片段onResume()在片段实际可见之前被触发。

例如，我有 2 个带有ViewPager和FragmentPagerAdapter的片段。 第二个片段仅对授权用户可用，我需要要求用户在片段变得可见时登录（使用警告对话框）。

但是ViewPager在第一个片段可见时创建第二个片段，以便缓存第二个片段并在用户开始滑动时使其可见。

因此onResume()事件在第二个片段变得可见之前很久就被触发了。 这就是为什么我试图找到一个事件，该事件在第二个片段变得可见时触发，以便在适当的时候显示对话框。

如何才能做到这一点？

Answer 1

如何确定 Fragment 何时在 ViewPager 中可见

您可以通过覆盖Fragment中的setUserVisibleHint来执行以下操作：

public class MyFragment extends Fragment {
    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        super.setUserVisibleHint(isVisibleToUser);
        if (isVisibleToUser) {
        }
        else {
        }
    }
}

Answer 2

更新：Android 支持库（修订版 11）最终解决了用户可见提示问题，现在如果您对片段使用支持库，那么您可以安全地使用getUserVisibleHint()或覆盖setUserVisibleHint()来捕获 gorn 的回答中描述的更改。

更新 1这是getUserVisibleHint()的一个小问题。 该值默认为true 。

// Hint provided by the app that this fragment is currently visible to the user.
boolean mUserVisibleHint = true;

因此，当您在调用setUserVisibleHint()之前尝试使用它时可能会出现问题。 作为解决方法，您可以像这样在onCreate方法中设置值。

public void onCreate(@Nullable Bundle savedInstanceState) {
    setUserVisibleHint(false);

---

过时的答案：

在大多数用例中， ViewPager只显示一页，但如果您使用Android Support Library pre-r11中的FragmentStatePagerAdapter ，预缓存的片段也会被放入“可见”state（实际上不可见）。

我覆盖：

public class MyFragment extends Fragment {
    @Override
    public void setMenuVisibility(final boolean visible) {
        super.setMenuVisibility(visible);
        if (visible) {
            // ...
        }
    }
   // ...
}

要捕获片段的焦点 state，我认为这是您所说的“可见性”最合适的 state，因为 ViewPager 中只有一个片段实际上可以将其菜单项与父活动的项目放在一起。

Answer 3

这似乎恢复了您期望的正常onResume()行为。 按主页键离开应用程序然后重新进入应用程序时效果很好。 onResume()不会连续调用两次。

@Override
public void setUserVisibleHint(boolean visible)
{
    super.setUserVisibleHint(visible);
    if (visible && isResumed())
    {
        //Only manually call onResume if fragment is already visible
        //Otherwise allow natural fragment lifecycle to call onResume
        onResume();
    }
}

@Override
public void onResume()
{
    super.onResume();
    if (!getUserVisibleHint())
    {
        return;
    }

    //INSERT CUSTOM CODE HERE
}

Answer 4

这是使用onPageChangeListener的另一种方式：

  ViewPager pager = (ViewPager) findByViewId(R.id.viewpager);
  FragmentPagerAdapter adapter = new FragmentPageAdapter(getFragmentManager);
  pager.setAdapter(adapter);
  pager.setOnPageChangeListener(new OnPageChangeListener() {

  public void onPageSelected(int pageNumber) {
    // Just define a callback method in your fragment and call it like this! 
    adapter.getItem(pageNumber).imVisible();

  }

  public void onPageScrolled(int arg0, float arg1, int arg2) {
    // TODO Auto-generated method stub

  }

  public void onPageScrollStateChanged(int arg0) {
    // TODO Auto-generated method stub

  }
});

Answer 5

setUserVisibleHint()有时会在onCreateView()之前被调用，有时会在之后引起麻烦。

为了克服这个问题，您还需要在setUserVisibleHint()方法中检查isResumed() 。 但在这种情况下，我意识到setUserVisibleHint()只有在 Fragment 恢复并可见时才会被调用，而不是在创建时被调用。

因此，如果您想在 Fragment visible时更新某些内容，请将更新 function 都放在onCreate()和setUserVisibleHint()中：

@Override
public View onCreateView(...){
    ...
    myUIUpdate();
    ...        
}
  ....
@Override
public void setUserVisibleHint(boolean visible){
    super.setUserVisibleHint(visible);
    if (visible && isResumed()){
        myUIUpdate();
    }
}

更新：我仍然意识到myUIUpdate()有时会被调用两次，原因是，如果您有 3 个选项卡并且此代码位于第二个选项卡上，当您第一次打开第一个选项卡时，即使第二个选项卡不可见，也会创建第二个选项卡和myUIUpdate()被调用。 然后，当您滑动到第二个选项卡时， myUIUpdate() if (visible && isResumed())中的 myUIUpdate()，因此， myUIUpdate()可能会在一秒钟内被调用两次。

另一个问题是setUserVisibleHint中的!visible被调用 1) 当您 go 离开片段屏幕时和 2) 在创建它之前，当您第一次切换到片段屏幕时。

解决方案：

private boolean fragmentResume=false;
private boolean fragmentVisible=false;
private boolean fragmentOnCreated=false;
...

@Override
public View onCreateView(...){
    ...
    //Initialize variables
    if (!fragmentResume && fragmentVisible){   //only when first time fragment is created
        myUIUpdate();
    }
    ...        
}

@Override
public void setUserVisibleHint(boolean visible){
    super.setUserVisibleHint(visible);
    if (visible && isResumed()){   // only at fragment screen is resumed
        fragmentResume=true;
        fragmentVisible=false;
        fragmentOnCreated=true;
        myUIUpdate();
    }else  if (visible){        // only at fragment onCreated
        fragmentResume=false;
        fragmentVisible=true;
        fragmentOnCreated=true;
    }
    else if(!visible && fragmentOnCreated){// only when you go out of fragment screen
        fragmentVisible=false;
        fragmentResume=false;
    }
}

解释：

fragmentResume , fragmentVisible : 确保onCreateView()中的myUIUpdate()仅在 fragment 创建且可见时调用，而不是在恢复时调用。 当您在第一个选项卡时，它也解决了问题，即使第二个选项卡不可见，也会创建它。 这解决了这个问题并检查片段屏幕在onCreate时是否可见。

fragmentOnCreated ：确保片段不可见，并且在您第一次创建片段时不被调用。 所以现在这个 if 子句只会在你滑出片段时被调用。

更新您可以像这样将所有这些代码放在BaseFragment代码中并覆盖方法。

Answer 6

在ViewPager2 androidx.fragment:fragment:1.1.0版本的 ViewPager2 和ViewPager中，您可以只使用onPause和onResume回调来确定哪个片段当前对用户可见。 当片段变得可见时调用onResume回调，当它停止可见时调用onPause 。

在 ViewPager2 的情况下，它是默认行为，但可以轻松地为旧的好ViewPager启用相同的行为。

要在第一个 ViewPager 中启用此行为，您必须将FragmentPagerAdapter.BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT参数作为FragmentPagerAdapter构造函数的第二个参数传递。

FragmentPagerAdapter(fragmentManager, BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT)

注意： setUserVisibleHint()方法和带一个参数的FragmentPagerAdapter构造函数现已在 android jetpack 的新版本 Fragment 中弃用。

Answer 7

新的

ViewPager2 + FragmentStateAdapter + onResume() （在Fragment中）解决问题

旧答案（已弃用）

要检测ViewPager中的Fragment是否可见，我很确定仅使用setUserVisibleHint是不够的。
这是我检查片段是可见还是不可见的解决方案。 首先启动viewpager时，切换页面，go到另一个activity/fragment/background/foreground`

public class BaseFragmentHelpLoadDataWhenVisible extends Fragment {
    protected boolean mIsVisibleToUser; // you can see this variable may absolutely <=> getUserVisibleHint() but it not. Currently, after many test I find that

    /**
     * This method will be called when viewpager creates fragment and when we go to this fragment background or another activity or fragment
     * NOT called when we switch between each page in ViewPager
     */
    @Override
    public void onStart() {
        super.onStart();
        if (mIsVisibleToUser) {
            onVisible();
        }
    }

    @Override
    public void onStop() {
        super.onStop();
        if (mIsVisibleToUser) {
            onInVisible();
        }
    }

    /**
     * This method will called at first time viewpager created and when we switch between each page
     * NOT called when we go to background or another activity (fragment) when we go back
     */
    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        super.setUserVisibleHint(isVisibleToUser);
        mIsVisibleToUser = isVisibleToUser;
        if (isResumed()) { // fragment have created
            if (mIsVisibleToUser) {
                onVisible();
            } else {
                onInVisible();
            }
        }
    }

    public void onVisible() {
        Toast.makeText(getActivity(), TAG + "visible", Toast.LENGTH_SHORT).show();
    }

    public void onInVisible() {
        Toast.makeText(getActivity(), TAG + "invisible", Toast.LENGTH_SHORT).show();
    }
}

EXPLANATION你可以仔细检查下面的 logcat 然后我想你可能知道为什么这个解决方案会起作用

首次发射

Fragment1: setUserVisibleHint: isVisibleToUser=false isResumed=false
Fragment2: setUserVisibleHint: isVisibleToUser=false isResumed=false
Fragment3: setUserVisibleHint: isVisibleToUser=false isResumed=false
Fragment1: setUserVisibleHint: isVisibleToUser=true isResumed=false // AT THIS TIME isVisibleToUser=true but fragment still not created. If you do something with View here, you will receive exception
Fragment1: onCreateView
Fragment1: onStart mIsVisibleToUser=true
Fragment2: onCreateView
Fragment3: onCreateView
Fragment2: onStart mIsVisibleToUser=false
Fragment3: onStart mIsVisibleToUser=false

Go 到第2页

Fragment1: setUserVisibleHint: isVisibleToUser=false isResumed=true
Fragment2: setUserVisibleHint: isVisibleToUser=true isResumed=true

Go到第3页

Fragment2: setUserVisibleHint: isVisibleToUser=false isResumed=true
Fragment3: setUserVisibleHint: isVisibleToUser=true isResumed=true

Go 到后台：

Fragment1: onStop mIsVisibleToUser=false
Fragment2: onStop mIsVisibleToUser=false
Fragment3: onStop mIsVisibleToUser=true

Go 到前台

Fragment1: onStart mIsVisibleToUser=false
Fragment2: onStart mIsVisibleToUser=false
Fragment3: onStart mIsVisibleToUser=true

演示项目在这里

希望有帮助

Answer 8

package com.example.com.ui.fragment;


import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

import com.example.com.R;

public class SubscribeFragment extends Fragment {

    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_subscribe, container, false);
        return view;
    }

    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        super.setUserVisibleHint(isVisibleToUser);

        if (isVisibleToUser) {
            // called here
        }
    }

    @Override
    public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
    }
}

Answer 9

覆盖FragmentPagerAdapter子类中的setPrimaryItem() 。 我用这个方法，效果很好。

@Override
public void setPrimaryItem(ViewGroup container, int position, Object object) {
    // This is what calls setMenuVisibility() on the fragments
    super.setPrimaryItem(container, position, object);

    if (object instanceof MyWhizBangFragment) {
        MyWhizBangFragment fragment = (MyWhizBangFragment) object;
        fragment.doTheThingYouNeedToDoOnBecomingVisible();
    }
}

Answer 10

为此覆盖Fragment.onHiddenChanged() 。

public void onHiddenChanged(boolean hidden)

当片段的隐藏 state（由isHidden()返回）发生变化时调用。 碎片开始时没有隐藏； 每当片段从那个改变 state 时，就会调用它。

参数
hidden - boolean ：如果片段现在隐藏则为真，如果不可见则为假。

Answer 11

只有这个对我有用！！ 并且setUserVisibleHint(...)现在已弃用（我在末尾附加了文档），这意味着大多数其他答案已弃用；-)

public class FragmentFirewall extends Fragment {
    /**
     * Required cause "setMenuVisibility(...)" is not guaranteed to be
     * called after "onResume()" and/or "onCreateView(...)" method.
     */
    protected void didVisibilityChange() {
        Activity activity = getActivity();
        if (isResumed() && isMenuVisible()) {
            // Once resumed and menu is visible, at last
            // our Fragment is really visible to user.
        }
    }

    @Override
    public void onResume() {
        super.onResume();
        didVisibilityChange();
    }

    @Override
    public void setMenuVisibility(boolean visible) {
        super.setMenuVisibility(visible);
        didVisibilityChange();
    }
}

经过测试并与NaviagationDrawer一起工作， isMenuVisible()将始终返回true （并且onResume()似乎足够了，但我们也想支持ViewPager ）。

setUserVisibleHint已弃用。 如果重写此方法，则传入true时实现的行为应移至Fragment.onResume() ，传入false时实现的行为应移至Fragment.onPause() 。

Answer 12

setUserVisibleHint(boolean visible)现已弃用所以这是正确的解决方案

FragmentPagerAdapter(fragmentManager, BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT)

在Androidx.fragment androidx.fragment:fragment:1.1.0版本的 ViewPager2 和ViewPager中，您可以只使用onPause()和onResume()来确定哪个片段当前对用户可见。 当片段变得可见时调用onResume() ，当片段停止可见时调用onPause 。

要在第一个 ViewPager 中启用此行为，您必须将FragmentPagerAdapter.BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT参数作为FragmentPagerAdapter构造函数的第二个参数传递。

Answer 13

我发现只有在片段真正可见的情况下才会调用onCreateOptionsMenu和onPrepareOptionsMenu方法。 我找不到任何类似这些行为的方法，我也尝试过OnPageChangeListener但它不适用于这种情况，例如，我需要在onCreate方法中初始化一个变量。

所以这两种方法可以作为解决这个问题的方法，特别是针对小而短的工作。

我认为，这是更好的解决方案，但不是最好的。 我会使用它，但同时等待更好的解决方案。

问候。

Answer 14

此处发布的另一个解决方案覆盖了 kris larson 的 pageradapter 中的 setPrimaryItem几乎对我有用。 但是每次设置都会多次调用此方法。 我还从片段中的视图等中获得了NPE ，因为在调用此方法的前几次还没有准备好。 通过以下更改，这对我有用：

private int mCurrentPosition = -1;

@Override
public void setPrimaryItem(ViewGroup container, int position, Object object) {
    super.setPrimaryItem(container, position, object);

    if (position == mCurrentPosition) {
        return;
    }

    if (object instanceof MyWhizBangFragment) {
        MyWhizBangFragment fragment = (MyWhizBangFragment) object;

        if (fragment.isResumed()) {
            mCurrentPosition = position;
            fragment.doTheThingYouNeedToDoOnBecomingVisible();
        }
    }
}

Answer 15

我在使用FragmentStatePagerAdapters和 3 个选项卡时遇到了同样的问题。 每当单击第一个选项卡时，我都必须显示一个 Dilaog，并在单击其他选项卡时将其隐藏。

单独覆盖setUserVisibleHint()无助于找到当前可见片段。

从第三个选项卡单击时 -----> 第一个选项卡。 它为第二个片段和第一个片段触发了两次。 我将它与 isResumed() 方法结合起来。

    @Override
public void setUserVisibleHint(boolean isVisibleToUser) {
    super.setUserVisibleHint(isVisibleToUser);
    isVisible = isVisibleToUser;

    // Make sure that fragment is currently visible
    if (!isVisible && isResumed()) {
        // Call code when Fragment not visible
    } else if (isVisible && isResumed()) {
       // Call code when Fragment becomes visible.
    }

}

Answer 16

在片段中添加以下代码

@Override
public void setMenuVisibility(final boolean visible) 
 {
    super.setMenuVisibility(visible);
    if (visible && isResumed()) 
     {

     }
}

Answer 17

我们有一个 MVP 的特殊情况，其中片段需要通知演示者视图已经可见，并且演示者由 Dagger 在fragment.onAttach()中注入。

setUserVisibleHint()是不够的，我们已经检测到 3 种不同的情况需要解决（提到了onAttach()以便您知道演示者何时可用）：

1. 片段刚刚创建。 系统进行以下调用：

    setUserVisibleHint() // before fragment's lifecycle calls, so presenter is null onAttach()... onResume()

2. 片段已经创建并且主页按钮被按下。 将应用程序恢复到前台时，这称为：

    onResume()

3. 方向变化：

    onAttach() // presenter available onResume() setUserVisibleHint()

我们只希望可见性提示到达演示者一次，所以我们是这样做的：

@Nullable
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    View root = inflater.inflate(R.layout.fragment_list, container, false);
    setHasOptionsMenu(true);

    if (savedInstanceState != null) {
        lastOrientation = savedInstanceState.getInt(STATE_LAST_ORIENTATION,
              getResources().getConfiguration().orientation);
    } else {
        lastOrientation = getResources().getConfiguration().orientation;
    }

    return root;
}

@Override
public void onResume() {
    super.onResume();
    presenter.onResume();

    int orientation = getResources().getConfiguration().orientation;
    if (orientation == lastOrientation) {
        if (getUserVisibleHint()) {
            presenter.onViewBecomesVisible();
        }
    }
    lastOrientation = orientation;
}

@Override
public void setUserVisibleHint(boolean isVisibleToUser) {
    super.setUserVisibleHint(isVisibleToUser);
    if (presenter != null && isResumed() && isVisibleToUser) {
        presenter.onViewBecomesVisible();
    }
}

@Override public void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    outState.putInt(STATE_LAST_ORIENTATION, lastOrientation);
}

Answer 18

通过focused view检测！

这对我有用

public static boolean isFragmentVisible(Fragment fragment) {
    Activity activity = fragment.getActivity();
    View focusedView = fragment.getView().findFocus();
    return activity != null
            && focusedView != null
            && focusedView == activity.getWindow().getDecorView().findFocus();
}

Answer 19

我遇到过同样的问题。 ViewPager执行其他片段生命周期事件，我无法更改该行为。 我使用片段和可用动画编写了一个简单的寻呼机。 简单寻呼机

Answer 20

我用过这个并且有效！

mContext.getWindow().getDecorView().isShown() //boolean

Answer 21

我支持带有子片段的 SectionsPagerAdapter 所以在经历了很多头痛之后我终于得到了基于这个主题的解决方案的工作版本：

public abstract class BaseFragment extends Fragment {

    private boolean visible;
    private boolean visibilityHintChanged;

    /**
     * Called when the visibility of the fragment changed
     */
    protected void onVisibilityChanged(View view, boolean visible) {

    }

    private void triggerVisibilityChangedIfNeeded(boolean visible) {
        if (this.visible == visible || getActivity() == null || getView() == null) {
            return;
        }
        this.visible = visible;
        onVisibilityChanged(getView(), visible);
    }

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (!visibilityHintChanged) {
            setUserVisibleHint(false);
        }
    }

    @Override
    public void onResume() {
        super.onResume();
        if (getUserVisibleHint() && !isHidden()) {
            triggerVisibilityChangedIfNeeded(true);
        }
    }

    @Override
    public void onHiddenChanged(boolean hidden) {
        super.onHiddenChanged(hidden);
        triggerVisibilityChangedIfNeeded(!hidden);
    }

    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        super.setUserVisibleHint(isVisibleToUser);
        visibilityHintChanged = true;
        if (isVisibleToUser && isResumed() && !isHidden()) {
            triggerVisibilityChangedIfNeeded(true);
        } else if (!isVisibleToUser) {
            triggerVisibilityChangedIfNeeded(false);
        }
    }

    @Override
    public void onPause() {
        super.onPause();
        triggerVisibilityChangedIfNeeded(false);
    }

    @Override
    public void onStop() {
        super.onStop();
        triggerVisibilityChangedIfNeeded(false);
    }

    protected boolean isReallyVisible() {
        return visible;
    }
}

Answer 22

当 viewpager 中的片段在屏幕上供用户查看时，我试图让计时器触发时遇到了这个问题。

计时器总是在用户看到片段之前启动。 这是因为片段中的onResume()方法在我们看到片段之前被调用了。

我的解决方案是检查onResume()方法。 当片段 8 是视图寻呼机当前片段时，我想调用某个方法“foo()”。

@Override
public void onResume() {
    super.onResume();
    if(viewPager.getCurrentItem() == 8){
        foo();
        //Your code here. Executed when fragment is seen by user.
    }
}

希望这可以帮助。 我已经看到这个问题经常出现。 这似乎是我见过的最简单的解决方案。 许多其他的与较低的 API 等不兼容。

Answer 23

请注意，不会在活动/片段停止时调用setUserVisibleHint(false) 。 您仍然需要检查开始/停止以正确register/unregister任何听众/等。

此外，如果您的片段以不可见的 state 开头，您将获得setUserVisibleHint(false) ； 您不想在那里unregister ，因为在这种情况下您之前从未注册过。

@Override
public void onStart() {
    super.onStart();

    if (getUserVisibleHint()) {
        // register
    }
}

@Override
public void onStop() {
    if (getUserVisibleHint()) {
        // unregister
    }

    super.onStop();
}

@Override
public void setUserVisibleHint(boolean isVisibleToUser) {
    super.setUserVisibleHint(isVisibleToUser);

    if (isVisibleToUser && isResumed()) {
        // register

        if (!mHasBeenVisible) {
            mHasBeenVisible = true;
        }
    } else if (mHasBeenVisible){
        // unregister
    }
}

Answer 24

一种简单的实现方法是在转到片段之前检查用户是否已登录。

在您的 MainActivity 中，您可以在onNavigationItemSelected方法中执行类似的操作。

 case R.id.nav_profile_side:


                if (User_is_logged_in) {

                    fragmentManager.beginTransaction()
                            .replace(R.id.content_frame
                                    , new FragmentProfile())
                            .commit();
                }else {

                    ShowLoginOrRegisterDialog(fragmentManager);

                }

                break;

但是，如果您使用的是导航抽屉，抽屉中的选择将更改为配置文件，尽管我们还没有转到 ProfileFragment。

要将选择重置为当前选择，请运行以下代码

        navigationView.getMenu().getItem(0).setChecked(true);

Answer 25

可能会很晚。 这对我有用。 我稍微更新了@Gobar 和@kris Solutions 的代码。 我们必须更新PagerAdapter中的代码。

每次可见标签并返回其setPrimaryItem 。 如果 position 改变了并且当前 position 不是我们点击的选项卡设置为 -1。

private int mCurrentPosition = -1;

@Override
public void setPrimaryItem(@NotNull ViewGroup container, int position, @NotNull Object object) {
    // This is what calls setMenuVisibility() on the fragments
    super.setPrimaryItem(container, position, object);
    if (position == mCurrentPosition) {
        return;
    }
    if (object instanceof YourFragment) {
        YourFragment fragment = (YourFragment) object;
        if (fragment.isResumed()) {
            mCurrentPosition = position;
            fragment.doYourWork();//Update your function
        }
    } else {
        mCurrentPosition = -1;
    }
}

Answer 26

问题：在片段实际可见之前，已触发ViewPager片段onResume() 。

例如，我有2个带有ViewPager和FragmentPagerAdapter 。 第二个片段仅适用于授权用户，我需要让用户在该片段可见时登录（使用警报对话框）。

但是，当第一个片段可见时， ViewPager会创建第二个片段，以便缓存第二个片段，并在用户开始滑动时使其可见。

因此， onResume()事件在它可见之前就在第二个片段中触发了。 这就是为什么我试图找到一个事件，该事件在第二个片段变得可见时触发，并在适当的时候显示一个对话框。

如何才能做到这一点？

Answer 27

在Kotlin

override fun onHiddenChanged(hidden: Boolean) {
    super.onHiddenChanged(hidden)

    // Your code goes here..
}

Answer 28

我覆盖了关联的 FragmentStatePagerAdapter 的 Count 方法，并让它返回总计数减去要隐藏的页数：

 public class MyAdapter : Android.Support.V13.App.FragmentStatePagerAdapter
 {   
     private List<Fragment> _fragments;

     public int TrimmedPages { get; set; }

     public MyAdapter(Android.App.FragmentManager fm) : base(fm) { }

     public MyAdapter(Android.App.FragmentManager fm, List<Android.App.Fragment> fragments) : base(fm)
     {
         _fragments = fragments;

         TrimmedPages = 0;
     }

     public override int Count
     {
         //get { return _fragments.Count; }
         get { return _fragments.Count - TrimmedPages; }
     }
 }

因此，如果最初有 3 个片段添加到 ViewPager，并且只有前 2 个应该显示直到满足某些条件，通过将 TrimmedPages 设置为 1 来覆盖页面计数，它应该只显示前两个页面。

这对最后的页面很有用，但对开头或中间的页面没有真正帮助（尽管有很多方法可以做到这一点）。