Comment déterminer quand Fragment devient visible dans ViewPager

Problème: Fragment onResume()en ViewPagerest tiré avant que le fragment devient réellement visible.

Par exemple, j'ai 2 fragments avec ViewPageret FragmentPagerAdapter. Le deuxième fragment n'est disponible que pour les utilisateurs autorisés et je dois demander à l'utilisateur de se connecter lorsque le fragment devient visible (à l'aide d'une boîte de dialogue d'alerte).

MAIS le ViewPagercrée le deuxième fragment lorsque le premier est visible afin de mettre en cache le deuxième fragment et le rend visible lorsque l'utilisateur commence à glisser.

L' onResume()événement est donc déclenché dans le deuxième fragment bien avant qu'il ne devienne visible. C'est pourquoi j'essaie de trouver un événement qui se déclenche lorsque le deuxième fragment devient visible pour afficher une boîte de dialogue au moment approprié.

Comment cela peut-il être fait?

Comment déterminer quand Fragment devient visible dans ViewPager

Vous pouvez effectuer les opérations suivantes en remplaçant setUserVisibleHintvotre Fragment:

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

MISE À JOUR : Android Support Library (rev 11) a finalement corrigé le problème de l'indice visible de l'utilisateur , maintenant si vous utilisez la bibliothèque de support pour les fragments, vous pouvez utiliser getUserVisibleHint()ou remplacer en toute sécurité setUserVisibleHint()pour capturer les modifications comme décrit par la réponse de Gorn.

MISE À JOUR 1 Voici un petit problème avec getUserVisibleHint(). Cette valeur est par défaut true.

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

Il peut donc y avoir un problème lorsque vous essayez de l'utiliser avant qu'il setUserVisibleHint()soit invoqué. Pour contourner ce problème, vous pouvez définir une valeur dans une onCreateméthode comme celle-ci.

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

La réponse obsolète:

Dans la plupart des cas d'utilisation, ViewPageraffichez une seule page à la fois, mais les fragments pré-mis en cache sont également mis à l'état "visible" (en fait invisible) si vous utilisez FragmentStatePagerAdapterin Android Support Library pre-r11.

Je remplace:

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

Pour capturer l'état de mise au point du fragment, ce qui, à mon avis, est l'état le plus approprié de la "visibilité", car un seul fragment dans ViewPager peut réellement placer ses éléments de menu avec les éléments de l'activité parent.

Cela semble restaurer le onResume()comportement normal que vous attendez. Cela joue bien en appuyant sur la touche d'accueil pour quitter l'application, puis en entrant à nouveau dans l'application. onResume()n'est pas appelé deux fois de suite.

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

Voici une autre façon d'utiliser 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

  }
});

setUserVisibleHint()est appelé parfois avant onCreateView() et parfois après, ce qui cause des problèmes.

Pour surmonter cela, vous devez également vérifier la méthode isResumed()interne setUserVisibleHint(). Mais dans ce cas, j'ai réalisé que je ne suis setUserVisibleHint()appelé que si le fragment est repris et visible, PAS lors de sa création.

Donc, si vous souhaitez mettre à jour quelque chose lorsque Fragment est visible, mettez votre fonction de mise à jour à la fois dans onCreate()et setUserVisibleHint():

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

MISE À JOUR: Je me suis quand même rendu compte que je suis myUIUpdate()appelé parfois deux fois, la raison en est que si vous avez 3 onglets et que ce code est sur le 2e onglet, lorsque vous ouvrez le 1er onglet pour la première fois, le 2e onglet est également créé même s'il n'est pas visible et myUIUpdate()est appelé. Ensuite, lorsque vous glissez vers le 2e onglet, myUIUpdate()de if (visible && isResumed())est appelé et, par conséquent, myUIUpdate()peut être appelé deux fois en une seconde.

L'autre problème est !visibledans setUserVisibleHintobtient appelé à la fois 1) lorsque vous sortez de l'écran de fragment et 2) avant qu'il ne soit créé, lorsque vous passez à l'écran de fragment la première fois.

Solution:

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

Explication:

fragmentResume, fragmentVisible: S'assure que myUIUpdate()in onCreateView()n'est appelé que lorsque le fragment est créé et visible, et non à la reprise. Il résout également le problème lorsque vous êtes au 1er onglet, le deuxième onglet est créé même s'il n'est pas visible. Cela résout cela et vérifie si l'écran de fragment est visible quand onCreate.

fragmentOnCreated: S'assure que le fragment n'est pas visible et n'est pas appelé lorsque vous créez un fragment pour la première fois. Alors maintenant, cette clause if n'est appelée que lorsque vous glissez hors du fragment.

Mise à jour Vous pouvez mettre tout ce code dans du BaseFragmentcode comme celui-ci et remplacer la méthode.

Pour détecter Fragmenten ViewPagervisible, je suis bien sûr que seule l'utilisation setUserVisibleHint n'est pas suffisante.
Voici ma solution pour vérifier si un fragment est visible ou invisible. Tout d'abord lors du lancement de Viewpager, basculez entre les pages, accédez à une autre activité / fragment / arrière-plan / premier plan`

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

EXPLICATION Vous pouvez vérifier attentivement le logcat ci-dessous, puis je pense que vous savez peut-être pourquoi cette solution fonctionnera

Premier lancement

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

Aller à la page2

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

Aller à la page3

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

Aller à l'arrière-plan:

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

Aller au premier plan

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

Projet DEMO ici

J'espère que ça aide

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

Dans ViewPager2et à ViewPagerpartir de la version, androidx.fragment:fragment:1.1.0vous pouvez simplement utiliser onPauseet des onResumerappels pour déterminer quel fragment est actuellement visible pour l'utilisateur. onResumele rappel est appelé lorsque le fragment est devenu visible et onPauselorsqu'il cesse d'être visible.

Dans le cas de ViewPager2, il s'agit d'un comportement par défaut, mais le même comportement peut être activé ViewPagerfacilement pour l'ancien .

Pour activer ce comportement dans le premier ViewPager, vous devez passer le FragmentPagerAdapter.BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENTparamètre comme deuxième argument du FragmentPagerAdapterconstructeur.

FragmentPagerAdapter(fragmentManager, BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT)

Remarque: la setUserVisibleHint()méthode et le FragmentPagerAdapterconstructeur avec un paramètre sont désormais obsolètes dans la nouvelle version de Fragment d'Android Jetpack.

Remplacer setPrimaryItem()dans la FragmentPagerAdaptersous - classe. J'utilise cette méthode, et cela fonctionne bien.

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

Remplacez Fragment.onHiddenChanged()pour cela.

public void onHiddenChanged(boolean hidden)

Appelé lorsque l'état caché (tel que renvoyé par isHidden()) du fragment a changé. Les fragments commencent non cachés; cela sera appelé chaque fois que le fragment change d'état.

Paramètres
hidden- boolean: Vrai si le fragment est maintenant masqué, faux s'il n'est pas visible.

J'ai compris cela onCreateOptionsMenuet les onPrepareOptionsMenuméthodes appelées uniquement dans le cas du fragment vraiment visible. Je n'ai trouvé aucune méthode qui se comporte comme celles-ci, j'ai également essayé OnPageChangeListenermais cela n'a pas fonctionné pour les situations, par exemple, j'ai besoin d'une variable initialisée dans onCreatemethod.

Ces deux méthodes peuvent donc être utilisées pour ce problème comme solution de contournement, en particulier pour les petits et courts travaux.

Je pense que c'est la meilleure solution mais pas la meilleure. Je vais l'utiliser, mais attendre une meilleure solution en même temps.

Cordialement.

Une autre solution publiée ici remplaçant setPrimaryItem dans le pageradapter par kris larson a presque fonctionné pour moi. Mais cette méthode est appelée plusieurs fois pour chaque configuration. J'ai également obtenu NPE des vues, etc. dans le fragment car ce n'est pas prêt les premières fois que cette méthode est appelée. Avec les changements suivants, cela a fonctionné pour moi:

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

Ajouter le code suivant à l'intérieur du fragment

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

     }
}

J'ai rencontré le même problème en travaillant avec FragmentStatePagerAdapterset 3 onglets. Je devais montrer un Dilaog chaque fois que le premier onglet était cliqué et le cacher en cliquant sur d'autres onglets.

Le dépassement setUserVisibleHint()seul n'a pas aidé à trouver le fragment visible actuel.

En cliquant sur à partir du 3e onglet -----> 1er onglet. Il s'est déclenché deux fois pour le 2e fragment et pour le 1er fragment. Je l'ai combiné avec la méthode 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.
    }

}

Nous avons un cas particulier avec MVP où le fragment doit informer le présentateur que la vue est devenue visible, et le présentateur est injecté par Dagger dans fragment.onAttach().

setUserVisibleHint()ne suffit pas, nous avons détecté 3 cas différents qui devaient être traités ( onAttach()est mentionné pour que vous sachiez quand le présentateur est disponible):

1. Le fragment vient d'être créé. Le système effectue les appels suivants:

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

2. Fragment déjà créé et bouton d'accueil enfoncé. Lors de la restauration de l'application au premier plan, cela s'appelle:

   onResume()

3. Changement d'orientation:

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

Nous voulons que l'indicateur de visibilité ne parvienne au présentateur qu'une seule fois, alors voici comment procéder:

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

Détection par focused view!

Ça marche pour moi

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

J'ai rencontré ce problème lorsque j'essayais de déclencher une minuterie lorsque le fragment du viseur était à l'écran pour que l'utilisateur puisse le voir.

Le minuteur a toujours démarré juste avant que le fragment ne soit vu par l'utilisateur. C'est parce que la onResume()méthode dans le fragment est appelée avant que nous puissions voir le fragment.

Ma solution a été de vérifier la onResume()méthode. Je voulais appeler une certaine méthode 'foo ()' lorsque le fragment 8 était le fragment actuel des pagers de vue.

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

J'espère que cela t'aides. J'ai vu ce problème apparaître souvent. Cela semble être la solution la plus simple que j'ai vue. Beaucoup d'autres ne sont pas compatibles avec les API inférieures, etc.

J'ai eu le même problème. ViewPagerexécute d'autres événements de cycle de vie de fragment et je ne pouvais pas changer ce comportement. J'ai écrit un simple pager utilisant des fragments et des animations disponibles. SimplePager

Je l'ai utilisé et cela a fonctionné!

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

Je supporte SectionsPagerAdapter avec des fragments enfants, donc après beaucoup de maux de tête, j'ai finalement obtenu une version de travail basée sur des solutions de ce sujet:

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

Notez qu'il setUserVisibleHint(false)n'est pas appelé à l'arrêt de l'activité / du fragment. Vous aurez toujours besoin de vérifier démarrer / arrêter correctement register/unregistertous les écouteurs / etc.

En outre, vous obtiendrez setUserVisibleHint(false)si votre fragment commence dans un état non visible; vous ne voulez pas unregistery aller puisque vous ne vous êtes jamais inscrit auparavant dans ce cas.

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

Un moyen simple d'implémentation qui consiste à vérifier si l'utilisateur est connecté avant d' accéder au fragment.

Dans votre MainActivity, vous pouvez faire quelque chose comme ça dans la méthode 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;

Cependant, si vous utilisez le tiroir de navigation, la sélection dans le tiroir aura changé pour Profile bien que nous ne soyons pas passés au ProfileFragment.

Pour réinitialiser la sélection à la sélection actuelle, exécutez le code ci-dessous

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

setUserVisibleHint (booléen visible) est désormais obsolète. C'est donc la bonne solution

FragmentPagerAdapter(fragmentManager, BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT)

Dans ViewPager2 et ViewPager à partir de la version, androidx.fragment:fragment:1.1.0vous pouvez simplement utiliser onPause()et onResume()pour déterminer quel fragment est actuellement visible pour l'utilisateur. onResume()est appelé lorsque le fragment est devenu visible et onPauselorsqu'il cesse d'être visible.

Pour activer ce comportement dans le premier ViewPager, vous devez passer le FragmentPagerAdapter.BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENTparamètre comme deuxième argument du FragmentPagerAdapterconstructeur.

J'ai remplacé la méthode Count du FragmentStatePagerAdapter associé et lui ai fait retourner le nombre total moins le nombre de pages à cacher:

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

Donc, s'il y a 3 fragments initialement ajoutés au ViewPager et que seuls les 2 premiers doivent être affichés jusqu'à ce qu'une condition soit remplie, remplacez le nombre de pages en définissant TrimmedPages à 1 et il ne doit afficher que les deux premières pages.

Cela fonctionne bien pour les pages à la fin, mais n'aidera pas vraiment celles du début ou du milieu (bien qu'il existe de nombreuses façons de le faire).