Como determinar quando o fragmento se torna visível no ViewPager

Problema: Fragmento onResume() em ViewPageré acionado antes do fragmento se torna realmente visível.

Por exemplo, eu tenho 2 fragmentos com ViewPagereFragmentPagerAdapter . O segundo fragmento está disponível apenas para usuários autorizados e preciso solicitar que o usuário efetue login quando o fragmento se tornar visível (usando uma caixa de diálogo de alerta).

Mas o ViewPager cria o segundo fragmento quando o primeiro estiver visível para armazenar em cache o segundo fragmento e o torna visível quando o usuário começa a passar o dedo.

Então o onResume() evento é disparado no segundo fragmento muito antes de se tornar visível. É por isso que estou tentando encontrar um evento que é acionado quando o segundo fragmento se torna visível para mostrar um diálogo no momento apropriado.

Como isso pode ser feito?

Como determinar quando o fragmento se torna visível no ViewPager

Você pode fazer o seguinte substituindo o setUserVisibleHintseu Fragment:

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

ATUALIZAÇÃO : a Biblioteca de suporte do Android (rev 11) finalmente corrigiu o problema de dica visível do usuário . Agora, se você usar a biblioteca de suporte para fragmentos, poderá usar getUserVisibleHint()ou substituir setUserVisibleHint()com segurança para capturar as alterações, conforme descrito pela resposta de gorn.

ATUALIZAÇÃO 1 Aqui está um pequeno problema com getUserVisibleHint(). Este valor é por padrão true.

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

Portanto, pode haver um problema ao tentar usá-lo antes de setUserVisibleHint()ser chamado. Como solução alternativa, você pode definir um valor no onCreatemétodo como este.

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

A resposta desatualizada:

Na maioria dos casos de uso, ViewPagermostram apenas uma página de cada vez, mas os fragmentos pré-armazenados em cache também são colocados para o estado "visível" (na verdade invisível) se você estiver usando FragmentStatePagerAdapterno Android Support Library pre-r11.

Eu substituo:

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

Para capturar o estado de foco do fragmento, que eu acho que é o estado mais adequado para a "visibilidade" que você quer dizer, uma vez que apenas um fragmento no ViewPager pode realmente colocar seus itens de menu junto com os itens da atividade pai.

Isso parece restaurar o onResume()comportamento normal que você esperaria. Ele funciona bem ao pressionar a tecla home para sair do aplicativo e depois entrar novamente no aplicativo. onResume()não é chamado duas vezes seguidas.

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

Aqui está outra maneira de usar 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()é chamado algumas vezes antes onCreateView() e outras depois, o que causa problemas.

Para superar isso, você precisa verificar isResumed()também o setUserVisibleHint()método interno . Mas, nesse caso, percebi que sósetUserVisibleHint() é chamado se o Fragmento for retomado e visível, NÃO quando criado.

Portanto, se você deseja atualizar algo quando o Fragment estiver visible, coloque sua função de atualização em onCreate()e setUserVisibleHint():

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

ATUALIZAÇÃO: Ainda assim, eu percebi que myUIUpdate()é chamado duas vezes às vezes, o motivo é que, se você tiver 3 guias e esse código estiver na 2ª guia, quando você abrir a 1ª guia, a 2ª guia também será criada, mesmo que não seja visível e myUIUpdate()seja chamada. Então, quando você desliza para a 2ª guia, myUIUpdate()from if (visible && isResumed())é chamado e, como resultado, myUIUpdate()pode ser chamado duas vezes em um segundo.

O outro problema é !visibleem setUserVisibleHinté chamado tanto 1) quando você sai da tela fragmento e 2) antes de ser criado, quando você alternar para a tela fragmento primeira vez.

Solução:

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

Explicação:

fragmentResume, fragmentVisible: Garante myUIUpdate()em onCreateView()é chamado somente quando fragmento é criado e visível, não no currículo. Também resolve o problema quando você está na 1ª guia, a segunda guia é criada mesmo que não esteja visível. Isso resolve e verifica se a tela do fragmento está visível quando onCreate.

fragmentOnCreated: Garante que o fragmento não esteja visível e não seja chamado quando você criar um fragmento pela primeira vez. Então agora essa cláusula if só é chamada quando você desliza para fora do fragmento.

Atualização Você pode colocar todo esse código em um BaseFragmentcódigo como este e substituir o método.

Para detectar Fragmentno ViewPagervisível, tenho certeza de que apenas o uso setUserVisibleHint não é suficiente.
Aqui está minha solução para verificar se um fragmento é visível ou invisível. Primeiro, ao iniciar o viewpager, alterne entre as páginas, vá para outra atividade / fragmento / fundo / primeiro plano`

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

EXPLICAÇÃO Você pode verificar o logcat abaixo com cuidado, então acho que você pode saber por que essa solução funcionará

Primeiro lançamento

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

Ir para a página2

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

Ir para a página3

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

Vá para segundo plano:

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

Ir para o primeiro plano

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

Projeto DEMO aqui

Espero que ajude

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

Na versão ViewPager2e ViewPagerda versão, androidx.fragment:fragment:1.1.0você pode apenas usar onPausee onResumeretornos de chamada para determinar qual fragmento está atualmente visível para o usuário. onResumeo retorno de chamada é chamado quando o fragmento se onPausetorna visível e quando para de ficar visível.

No caso do ViewPager2, é um comportamento padrão, mas o mesmo comportamento pode ser ativado para o bem antigo ViewPagerfacilmente.

Para habilitar esse comportamento no primeiro ViewPager, você deve passar o FragmentPagerAdapter.BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENTparâmetro como segundo argumento do FragmentPagerAdapterconstrutor.

FragmentPagerAdapter(fragmentManager, BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT)

Nota: o setUserVisibleHint()método e o FragmentPagerAdapterconstrutor com um parâmetro agora estão obsoletos na nova versão do Fragment do android jetpack.

Substituir setPrimaryItem()na FragmentPagerAdaptersubclasse. Eu uso esse método e funciona bem.

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

Substituir Fragment.onHiddenChanged()por isso.

public void onHiddenChanged(boolean hidden)

Chamado quando o estado oculto (retornado por isHidden() ) do fragmento foi alterado. Fragmentos começam não ocultos; isso será chamado sempre que o fragmento mudar de estado a partir disso.

Parâmetros
hidden- boolean: True se o fragmento está agora oculto, false se não estiver visível.

Eu descobri isso onCreateOptionsMenue onPrepareOptionsMenumétodos chamados apenas no caso do fragmento realmente visível. Não encontrei nenhum método que se comporte assim, tentei, OnPageChangeListenermas não funcionou para as situações, por exemplo, preciso de uma variável inicializada no onCreatemétodo.

Portanto, esses dois métodos podem ser usados ​​para esse problema como uma solução alternativa, especificamente para trabalhos pequenos e curtos.

Penso que esta é a melhor solução, mas não a melhor. Vou usar isso, mas aguardo uma solução melhor ao mesmo tempo.

Saudações.

Outra solução postada aqui, substituindo setPrimaryItem no pageradapter por kris larson, quase funcionou para mim. Mas esse método é chamado várias vezes para cada instalação. Também recebi o NPE de visualizações, etc. no fragmento, pois isso não está pronto nas primeiras vezes em que esse método é chamado. Com as seguintes alterações, isso funcionou para mim:

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

Adicione o seguinte código dentro do fragmento

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

     }
}

Encontrei o mesmo problema ao trabalhar com FragmentStatePagerAdapterse 3 guias. Eu tive que mostrar um Dilaog sempre que a 1ª guia foi clicada e ocultá-la clicando em outras guias.

A substituição setUserVisibleHint()sozinha não ajudou a encontrar o fragmento visível atual.

Ao clicar na 3ª guia -----> 1ª guia. Foi acionado duas vezes para o 2º fragmento e para o 1º fragmento. Eu combinei com o método 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.
    }

}

Temos um caso especial com o MVP, em que o fragmento precisa notificar o apresentador de que a exibição se tornou visível, e o apresentador é injetado por Dagger fragment.onAttach().

setUserVisibleHint()não é suficiente, detectamos três casos diferentes que precisavam ser abordados ( onAttach()é mencionado para que você saiba quando o apresentador está disponível):

1. Fragmento acaba de ser criado. O sistema faz as seguintes chamadas:

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

2. Fragmento já criado e o botão home é pressionado. Ao restaurar o aplicativo em primeiro plano, isso é chamado:

   onResume()

3. Mudança de orientação:

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

Queremos que a dica de visibilidade chegue ao apresentador apenas uma vez, e é assim que fazemos:

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

Detectando por focused view!

Isso funciona para mim

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

Encontrei esse problema quando estava tentando acionar um timer quando o fragmento no visor estava na tela para o usuário ver.

O cronômetro sempre iniciava antes do fragmento ser visto pelo usuário. Isso ocorre porque o onResume()método no fragmento é chamado antes que possamos ver o fragmento.

Minha solução foi fazer uma verificação no onResume()método. Eu queria chamar um determinado método de 'foo ()' quando o fragmento 8 era o fragmento atual dos pagers de exibição.

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

Espero que isto ajude. Eu já vi esse problema aparecer muito. Esta parece ser a solução mais simples que já vi. Muitos outros não são compatíveis com APIs mais baixas etc.

Eu tive o mesmo problema. ViewPagerexecuta outros eventos do ciclo de vida do fragmento e não pude mudar esse comportamento. Escrevi um pager simples usando fragmentos e animações disponíveis. SimplePager

Eu usei isso e funcionou!

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

Eu apóio o SectionsPagerAdapter com fragmentos filhos. Depois de muita dor de cabeça, finalmente consegui a versão de trabalho com base nas soluções deste tópico:

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

Observe que setUserVisibleHint(false)não é chamado na parada de atividade / fragmento. Você ainda precisará verificar iniciar / parar adequadamente register/unregisterqualquer ouvinte / etc.

Além disso, você verá setUserVisibleHint(false)se o seu fragmento inicia em um estado não visível; você não quer ir para unregisterlá, porque nunca se registrou antes nesse caso.

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

Uma maneira simples de implementar é verificar se o usuário está conectado antes de ir para o fragmento.

Em seu MainActivity, você pode fazer algo assim dentro do método 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;

No entanto, se você estiver usando a gaveta de navegação, a seleção na gaveta será alterada para Perfil, embora não tenhamos ido para o ProfileFragment.

Para redefinir a seleção para a seleção atual, execute o código abaixo

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

setUserVisibleHint (boolean visible) agora está obsoleto. Portanto, esta é a solução correta

FragmentPagerAdapter(fragmentManager, BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT)

No ViewPager2 e no ViewPager da versão, androidx.fragment:fragment:1.1.0você pode apenas usar onPause()e onResume()determinar qual fragmento está atualmente visível para o usuário. onResume()é chamado quando o fragmento se tornou visível e onPausequando para de ficar visível.

Para habilitar esse comportamento no primeiro ViewPager, você deve passar o FragmentPagerAdapter.BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENTparâmetro como o segundo argumento do FragmentPagerAdapterconstrutor.

Substituí o método Count do FragmentStatePagerAdapter associado e ele retornou a contagem total menos o número de páginas a serem ocultadas:

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

Portanto, se houver 3 fragmentos adicionados inicialmente ao ViewPager e apenas os 2 primeiros devem ser mostrados até que alguma condição seja atendida, substitua a contagem de páginas configurando TrimmedPages como 1 e ele deve mostrar apenas as duas primeiras páginas.

Isso funciona bem para as páginas no final, mas realmente não ajuda no começo ou no meio (embora haja várias maneiras de fazer isso).