Как определить, когда фрагмент становится видимым в ViewPager

Проблема: Фрагмент onResume() в ViewPager запускается до того, как фрагмент станет фактически видимым.

Например, у меня есть 2 фрагмента с ViewPager и FragmentPagerAdapter. Второй фрагмент доступен только для авторизованных пользователей, и мне нужно попросить пользователя войти в систему, когда фрагмент станет видимым (используя диалоговое окно предупреждения).

НО ViewPager создает второй фрагмент, когда первый видится для кэширования второго фрагмента и делает его видимым, когда пользователь начинает прокручивать.

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

Как это можно сделать?

ОТВЕТЫ

Ответ 1

UPDATE: Android Support Library (rev 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 показывает только одну страницу за раз, но предварительно кэшированные фрагменты также попадают в "видимое" состояние (фактически невидимое), если вы используете FragmentStatePagerAdapter в Android Support Library pre-r11.

Я переопределяю:

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

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

Ответ 2

Как определить, когда фрагмент становится видимым в ViewPager

Вы можете сделать следующее, переопределив setUserVisibleHint в Fragment:

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

Ответ 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
}

Ответ 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

  }
});

Ответ 5

setUserVisibleHint() иногда вызывается до onCreateView(), а иногда и после этого вызывает проблемы.

Чтобы преодолеть это, вам нужно проверить isResumed(), а также внутри метода setUserVisibleHint(). Но в этом случае я понял, что setUserVisibleHint() получает вызов только, если Fragment возобновляется и видится, NOT when Created.

Итак, если вы хотите что-то обновить, когда Fragment visible, поместите свою функцию обновления как в onCreate(), так и setUserVisibleHint():

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

ОБНОВЛЕНИЕ:. Тем не менее, я понял, что myUIUpdate() иногда вызывается дважды, причина в том, что если у вас есть 3 вкладки, и этот код находится на 2-й вкладке, когда вы открываете первую вкладку, вторая вкладка также создается даже не видно и myUIUpdate() вызывается. Затем, когда вы прокручиваете вторую вкладку, вызывается myUIUpdate() из if (visible && isResumed()), и в результате myUIUpdate() может вызываться дважды за секунду.

Другая проблема: !visible в setUserVisibleHint вызывается как 1), когда вы выходите из экрана фрагмента, и 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: Уверен, что myUIUpdate() в onCreateView() вызывается только тогда, когда фрагмент создан и видим, а не при возобновлении. Он также решает проблему, когда вы на первой вкладке, вторая вкладка создается, даже если она не видна. Это разрешает это и проверяет, отображается ли экран фрагмента, когда onCreate.

fragmentOnCreated: Делает правильный фрагмент невидимым и не вызывается при первом создании фрагмента. Итак, теперь это предложение if вызывается только тогда, когда вы удаляете фрагмент.

Обновление Вы можете поместить весь этот код в BaseFragment код как этот и переопределить метод.

Ответ 6

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

Ответ 7

Чтобы обнаружить видимый Fragment в ViewPager, я совершенно уверен, что недостаточно только использование setUserVisibleHint.
Вот мое решение, чтобы проверить, является ли фрагмент видимым или невидимым. Сначала при запуске viewpager переключайтесь между страницами, переходите к другой активности/фрагменту/фону/переднему плану '

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

ОБЪЯСНЕНИЕ Вы можете внимательно проверить 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

Перейти на страницу 2

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

Перейти на страницу 3

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

Перейти к фону:

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

Перейти на передний план

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

ДЕМО проект здесь

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

Ответ 8

Заменить setPrimaryItem() в подклассе FragmentPagerAdapter. Я использую этот метод, и он работает хорошо.

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

Ответ 9

Переопределите Fragment.onHiddenChanged() для этого.

public void onHiddenChanged(boolean hidden)

Вызывается, когда скрытое состояние (как было возвращено isHidden()). Фрагменты начинают не скрываться; это будет вызываться всякий раз, когда фрагмент меняет свое состояние.

Параметры
hidden - boolean: Истинно, если фрагмент теперь скрыт, false, если он не отображается.

Ответ 10

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

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

Я думаю, это лучшее решение, но не лучшее. Я буду использовать это, но ждать лучшего решения в одно и то же время.

С уважением.

Ответ 11

Другое решение размещенное здесь, переопределение setPrimaryItem в pageradapter от kris larson почти сработало для меня. Но этот метод вызывается несколько раз для каждой установки. Кроме того, я получил 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();
        }
    }
}

Ответ 12

Я столкнулся с такой же проблемой при работе с FragmentStatePagerAdapters и 3 вкладками. Я должен был показать Dilaog всякий раз, когда была нажата 1-я вкладка, и спрятать ее, нажав другие вкладки.

Переопределение только setUserVisibleHint() не помогло найти текущий видимый фрагмент.

При нажатии с третьей вкладки ----- > 1-я вкладка. Он запускается дважды для второго фрагмента и для первого фрагмента. Я объединил его с методом 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.
    }

}

Ответ 13

Добавьте следующий код внутри фрагмента

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

     }
}

Ответ 14

У нас есть специальный случай с MVP, где фрагмент должен уведомить ведущего о том, что представление стало видимым, а ведущий вводится кинжалом в fragment.onAttach().

setUserVisibleHint() недостаточно, мы обнаружили 3 разных случая, которые необходимо было решить (onAttach() упоминается так, что вы знаете, когда доступен ведущий):

  • Фрагмент только что был создан. Система выполняет следующие вызовы:

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

  • Фрагмент уже создан и нажата кнопка home. При восстановлении приложения на передний план это называется:

    onResume()

  • Изменение ориентации:

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

Ответ 15

Обнаружение 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();
}

Ответ 16

Попробуйте это, это работает для меня:

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

        if (hidden) {

        }else
        {}
    }

Ответ 17

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

Ответ 18

Я столкнулся с этой проблемой, когда пытался запустить таймер, когда фрагмент в viewpager был на экране для просмотра пользователем.

Таймер всегда запускается непосредственно перед тем, как фрагмент просматривается пользователем. Это связано с тем, что метод onResume() в фрагменте вызывается до того, как мы увидим фрагмент.

Мое решение состояло в том, чтобы проверить метод onResume(). Я хотел вызвать определенный метод "foo()", когда фрагмент 8 был текущим фрагментом пейджера представления.

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

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

Ответ 19

Обратите внимание, что setUserVisibleHint(false) не вызывается при остановке активности/фрагмента. Вам все равно нужно правильно проверить запуск/остановку register/unregister любых слушателей и т.д.

Кроме того, вы получите 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
    }
}

Ответ 20

Во Фрагменте используйте GestureDetector.OnGestureListenerand, и когда это срабатывает, вы узнаете, что "this" Фрагмент виден

Ответ 21

В Фрагменте используйте GestureDetector

Ответ 22

Я обрабатываю видимое состояние здесь: Проверить, что фрагмент в настоящее время отображается или нет в android?. Я разделяю тип переключателя фрагмента на три способа, и если вложенное использование, обрабатывайте видимое состояние субфрагмента в его родительском фрагменте. Это работает для меня.

Ответ 23

Я использовал это, и это сработало!

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

Ответ 24

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

@Override
public void setUserVisibleHint(boolean isVisibleToUser)
{

   if (isVisibleToUser&&rootView!=null)
   //code to run
}

Ответ 25

Я поддерживаю 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;
    }
}

Ответ 26

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

В вашей 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);

Ответ 27

Поскольку setUserVisibleHint (boolean aBoolean) теперь устарела, для тех, кто все еще хочет знать, когда фрагмент виден, вы все равно можете использовать

 public FragmentTransaction setMaxLifecycle(Fragment fragment, Lifecycle.State state)

либо косвенно с FragmentPagerAdapter (или FragmentStatePagerAdapter) просто с помощью нового конструктора

MyFPagerAdapter(FragmentManager fm) {
        super(fm ,FragmentStatePagerAdapter.BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT);
       //...
}

обратите внимание, что FragmentStatePagerAdapter.BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT позволяет адаптеру использовать setMaxLifecycle внутренне (через setPrimaryItem) вместо setUserVisibleHint. Следовательно, в реализации вашего фрагмента вам больше не нужно будет использовать

setUserVisibleHint(boolean aBoolean)

но вместо этого onResume() вызывают теперь onResume() будет вызываться только для видимого фрагмента. остальные все равно смогут связаться с onCreateView().

Прямой путь заключается в использовании setMaxLifeCycle с FragmentTransaction при добавлении или переключении фрагмента, где затем

setMaxLifecycle(fragment, Lifecycle.State.STARTED);

эквивалентно

setUserVisibleHint(false);

а также

setMaxLifecycle(fragment, Lifecycle.State.RESUMED);

эквивалентно

setUserVisibleHint(true);

затем снова прослушайте с обратным вызовом Fragment onResume()

Ответ 28

Я перепробовал метод Count связанного FragmentStatePagerAdapter и возвратил его общее количество минус количество страниц, которые нужно скрыть:

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

Итак, если в ViewPager добавлено 3 фрагмента, и только первые 2 должны отображаться до тех пор, пока не будет выполнено какое-либо условие, переопределите количество страниц, установив TrimmedPages в 1, и он должен отображать только первые две страницы.

Это хорошо работает для страниц в конце, но обычно не помогает для них в начале или в середине (хотя есть много способов сделать это).