Jak określić, kiedy Fragment staje się widoczny w ViewPager

Jak określić, kiedy Fragment staje się widoczny w ViewPager

Możesz wykonać następujące czynności poprzez nadpisanie setUserVisibleHint w twoim Fragment:

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

To wydaje się przywracać normalne onResume() zachowanie, którego można się spodziewać. Gra dobrze z naciśnięciem klawisza home, aby opuścić aplikację, a następnie ponownie wprowadzić aplikację. onResume() nie jest wywoływany dwa razy z rzędu.

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

Oto inny sposób użycia 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() nazywa się czasami przed onCreateView() i czasami po tym powoduje kłopoty.

Aby to przezwyciężyć, musisz sprawdzić isResumed(), jak również wewnątrz setUserVisibleHint() metody. Ale w tym przypadku zdałem sobie sprawę, że {[2] } zostanie wywołany tylko jeśli Fragment zostanie wznowiony i widoczny, a nie gdy zostanie utworzony.

Więc jeśli chcesz coś zaktualizować, gdy Fragment jest visible, Umieść funkcję aktualizacji zarówno w onCreate(), jak i setUserVisibleHint():

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

UPDATE: still I realized myUIUpdate() gets wywołany dwukrotnie czasami, powodem jest to, że jeśli masz 3 karty i ten kod jest na 2.karcie, po pierwszym otwarciu 1. Karty, 2. karta jest również tworzony, nawet nie jest widoczny i myUIUpdate() jest wywoływany. Następnie, gdy przesuniesz palcem do 2. zakładki, myUIUpdate() z if (visible && isResumed()) zostanie wywołana i w rezultacie myUIUpdate() może zostać wywołana dwa razy w ciągu sekundy.

Drugi problem to !visible W setUserVisibleHint zostanie wywołany zarówno 1) po wyjściu z ekranu fragment, jak i 2) przed jego utworzeniem, gdy najpierw przełączysz się na ekran fragment czas.

Rozwiązanie:

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

Explanation:

fragmentResume,fragmentVisible: upewnia się, że myUIUpdate() in {[3] } jest wywoływany tylko wtedy, gdy fragment jest tworzony i widoczny, a nie podczas wznawiania. Rozwiązuje również problem, gdy jesteś na 1. karcie, 2. karta jest tworzona, nawet jeśli nie jest widoczna. Rozwiązuje to problem i sprawdza, czy fragment screen jest widoczny, gdy onCreate.

fragmentOnCreated: upewnia się, że fragment nie jest widoczny i nie jest wywoływany podczas tworzenia fragmentu po raz pierwszy. Więc teraz to jeśli klauzula zostanie wywołana tylko po przesunięciu z fragmentu.

Aktualizacja Możesz umieścić cały ten kod w BaseFragment kod w ten sposób i nadpisać metodę.

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

Override setPrimaryItem() w podklasie FragmentPagerAdapter. Używam tej metody i działa dobrze.

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

Override Fragment.onHiddenChanged() za to.

public void onHiddenChanged(boolean hidden)

Wywołane, gdy stan ukryty (zwracany przez isHidden()) fragment uległ zmianie. Fragmenty zaczynają się nie Ukryte; będzie to wywoływane za każdym razem, gdy fragment zmieni stan.

Parametry
hidden - boolean: True, jeśli fragment jest teraz ukryty, false, jeśli nie jest widoczny.

Aby wykryć Fragment W ViewPager widocznym, jestem pewien, że tylko za pomocą setUserVisibleHint to za mało.
Oto moje rozwiązanie dla zaznacz fragment widoczny, niewidoczny przy pierwszym uruchomieniu viewpagera, przełączanie między stroną, przejście do innej aktywności/ fragmentu/tła / pierwszego planu "

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 call when viewpager create fragment and when we go to this fragment from
     * background or another activity, fragment
     * NOT call 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 call 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();
    }
}

Wyjaśnienie Możesz dokładnie sprawdzić poniższy logcat, a następnie myślę, że możesz wiedzieć, dlaczego to rozwiązanie będzie działać

Pierwsze uruchomienie

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

Przejdź do page2

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

Idź do page3

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

Przejdź do tła:

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

Idź na pierwszy plan

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

Projekt DEMO tutaj

Hope it help

Zorientowałem się, że onCreateOptionsMenu i onPrepareOptionsMenu Metody wywołane tylko w przypadku fragmentu naprawdę widoczne. Nie mogłem znaleźć żadnej metody, która zachowuje się tak, również próbowałem OnPageChangeListener, ale to nie działa w sytuacjach, na przykład, potrzebuję zmiennej zainicjalizowanej w metodzie onCreate.

Więc te dwie metody mogą być wykorzystane w tym problemie jako obejście, szczególnie dla małych i krótkich zadań.

Inne rozwiązanie opublikowane tutaj nadpisanie setPrimaryItem w pageradapterze przez Krisa Larsona prawie mi się udało. Ale ta metoda jest wywoływana wiele razy dla każdej konfiguracji. Też dostałem NPE z odsłon itp. we fragmencie, ponieważ ten nie jest gotowy, pierwsze kilka razy ta metoda jest wywoływana. Z następującymi zmianami to działało dla mnie:

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

Dodaj następujący kod wewnątrz fragmentu

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

     }
}

Napotkałem ten sam problem podczas pracy z FragmentStatePagerAdapters i 3 zakładkami. Musiałem pokazać Dilaog za każdym razem, gdy pierwsza karta została kliknięta i ukryć ją po kliknięciu innych kart.

Samo nadpisanie setUserVisibleHint() nie pomogło znaleźć obecnego widocznego fragmentu.

Po kliknięciu z 3. Zakładki - - - - - > 1. Zakładka. Uruchomił się dwukrotnie dla 2. fragmentu i dla 1. fragmentu. Połączyłem go z metodą 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.
    }

}

Mamy specjalny przypadek z MVP, gdzie fragment musi powiadomić prezentera, że widok stał się widoczny, a prezenter jest wstrzykiwany przez Dagger w fragment.onAttach().

setUserVisibleHint() to za mało, wykryliśmy 3 różne przypadki, które wymagały rozwiązania (onAttach() jest wspomniane, abyś wiedział, kiedy prezenter jest dostępny):

1. Fragment właśnie został utworzony. System wykonuje następujące wywołania:

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

2. Fragment już utworzony i Dom przycisk jest wciśnięty. Podczas przywracania aplikacji na pierwszy plan nazywa się to:

   onResume()
   

3. Zmiana orientacji:

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

Chcemy, aby wskazówka widoczności dotarła do prezentera tylko raz, więc tak to robimy:

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

Wykrywanie przez focused view!

To działa dla mnie

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

Zauważ, że setUserVisibleHint(false) nie jest wywoływany przy zatrzymaniu activity / fragment. Nadal będziesz musiał sprawdzić start/stop, aby poprawnie register/unregister wszystkie słuchacze / etc.

Otrzymasz również setUserVisibleHint(false), Jeśli twój fragment zaczyna się w stanie niewidocznym; nie chcesz tam unregister, ponieważ nigdy wcześniej nie zarejestrowałeś się w tym przypadku.

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

Napotkałem ten problem, gdy próbowałem uruchomić timer, gdy fragment w viewpagerze był na ekranie, aby użytkownik mógł go zobaczyć.

Timer zawsze uruchamiał się tuż przed wyświetlaniem fragmentu przez użytkownika. Dzieje się tak, ponieważ metoda onResume() we fragmencie jest wywołana, zanim będziemy mogli zobaczyć fragment.

Moim rozwiązaniem było sprawdzenie metodą onResume(). Chciałem wywołać pewną metodę ' foo ()', gdy fragment 8 był bieżącym fragmentem widoku pagerów.

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

Miałem ten sam problem. ViewPager wykonuje inne zdarzenia cyklu życia fragmentu i nie mogłem zmienić tego zachowania. Napisałem prosty pager z wykorzystaniem fragmentów i dostępnych animacji. SimplePager

Spróbuj tego, to dla mnie praca:

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

        if (hidden) {

        }else
        {}
    }

Użyłem tego i zadziałało !

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

Nadpisuję metodę Count z powiązanego FragmentStatePagerAdapter i każę zwrócić całkowitą liczbę pomniejszoną o liczbę stron do ukrycia:

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

Tak więc, jeśli do Viewpagera są początkowo dodane 3 fragmenty i tylko pierwsze 2 powinny być wyświetlane, dopóki nie zostanie spełniony jakiś warunek, Nadpisz liczbę stron, ustawiając TrimmedPages na 1 i powinien wyświetlać tylko dwie pierwsze strony.

To działa dobrze dla stron na końcu, ale naprawdę nie pomoże dla tych na początku lub środkowy (choć jest na to wiele sposobów).