Problem: Fragment onResume() in ViewPager is fired before the fragment becomes actually visible.

For example, I have 2 fragments with ViewPager and FragmentPagerAdapter. The second fragment is only available for authorized users and I need to ask the user to log in when the fragment becomes visible (using an alert dialog).

BUT the ViewPager creates the second fragment when the first is visible in order to cache the second fragment and makes it visible when the user starts swiping.

So the onResume() event is fired in the second fragment long before it becomes visible. That's why I'm trying to find an event which fires when the second fragment becomes visible to show a dialog at the appropriate moment.

How can this be done?

9 upvote
  flag
"i have 2 fragment with ViewPager and FragmentPagerAdapter. The second fragment can be available for authorized users only and i should ask use to login when the fragment becomes visible (alert dialog)." -- IMHO, that is awful UX. Popping up a dialog because the user swiped horizontally would cause me to give you a one-star rating on the Play Store. – CommonsWare
upvote
  flag
is it better to just display information at TextView with "Login" button? What is your solution for that case? – 4ntoine
upvote
  flag
Either log them in before they get to the ViewPager, or integrate the login into the to-be-secured fragment. – CommonsWare
upvote
  flag
In general that does not make sense. Ok, imagine the next case: data loading takes a lot of time and you have to display ProgressDialog while loading. You have to display it at moment the fragment becomes visible. The problem is to determine when the fragment becomes visible. – 4ntoine
upvote
  flag
You would not use a ProgressDialog with a Fragment in a ViewPager. You would use a ProgressBar widget as a placeholder for the fragment's content. – CommonsWare
upvote
  flag
The point is that i don't know the time when i should start animation in ProgressBar or show ProgressDialog as onResume is fired long before . – 4ntoine
upvote
  flag
You would start animation on the ProgressBar as soon as it is created. You would hide or remove the ProgressBar when it is no longer needed. – CommonsWare
upvote
  flag
No need to load data if it will not be displayed. This loads CPU, increases traffic and drains battery and i will set one-star rating for such app. – 4ntoine
75 upvote
  flag
How to determine when Fragment becomes visible in ViewPager. Anyone? – 4ntoine
5 upvote
  flag
"No need to load data if it will not be displayed." -- then you should not be putting it in a ViewPager. In a two-page pager, both pages will be loaded immediately, whether you like it or not. The user experience of ViewPager is supposed to be that the content is there immediately upon swiping, not some time later. That is why ViewPager initializes a page ahead of what is visible, to help ensure that user experience. – CommonsWare
2 upvote
  flag
It seems that ViewPager is not flexible enough and it does not allow to turn off caching since minimum setOffscreenPageLimit is 1: //allinonescript.com/questions/10073214/…. Don't see any reason for this and the expected behaviour (in case of compulsory caching) is to create fragment BUT fire fragment's onResume() when the fragment becomes visible. – 4ntoine
upvote
  flag
I too am looking for a way to handle this "view is visible" event. I do not want to do this from the FragmentActivity using setOnPageChangeListener - so please tell me if there is another way. – slott
upvote
  flag
@CommonsWare Thank you for your exploration, so what is the solution for such cases? – Chris.Zou
1 upvote
  flag
A bit late, but for anyone facing the same issue, you could try FragmentViewPager library (I am the author), which deals with this issue and provides a few extra features. For a sample, check project's GitHub page or this stackoverflow answer. – S. Brukhanda
upvote
  flag

22 Answers 11

How to determine when Fragment becomes visible in ViewPager

You can do the following by overriding setUserVisibleHint in your Fragment:

public class MyFragment extends Fragment {
    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        super.setUserVisibleHint(isVisibleToUser);
        if (isVisibleToUser) {
        }
        else {
        }
    }
}
3 upvote
  flag
I have 3 fragments in viewstatepager and found getUserVisibleHint() always returns true. – scottyab
upvote
  flag
getUserVisibleHint()? My example with setsetUserVisibleHint should work fine by using the boolean paramater. – gorn
upvote
  flag
you should override setMenuVisibility as descibed by Oasis Feng. His answer should be voted up! – Rodja
upvote
  flag
Actually I have tried this way before, but I found that not only the currently centered page, but also the pages before and after it got "user visible hint". So it may be suitable if your ViewPager shows more than one page at the same time (usually the case on tablet UI), but not for that shows only on page at a time. – Oasis Feng
6 upvote
  flag
Thanks to today's Android Support Library update (rev 11), the user visible hint issue is finally fixed. It's now safe to use user visible hint for ViewPager. – Oasis Feng
2 upvote
  flag
I haven't seen setUserVisibleHint() documented anywhere as a lifecycle event of the Fragment. – Igor Ganapolsky
1 upvote
  flag
Looks like setUserVisibleHint is only for SupportLibrary, couldn't find it in latest SDK – AAverin
upvote
  flag
when should i call this method? – keybee
2 upvote
  flag
You know, in Java a method is identified, in part, with a name (as you used), and a CLASS. So, please, when you suggest to override a method, please, please give the class. Especially as there are two objects that may be manipulated (Fragment and ViewPager). – Vince
39 upvote
  flag
I have found that the setUserVisibleHint method gets called BEFORE the onCreateView gets called and this makes it difficult to track any initialization. – AndroidDev
8 upvote
  flag
@AndroidDev If you want to run some code when the hint's coming in as true, but which needs the view tree already initialized, just wrap that block of code in isResumed() to avoid an NPE. Been working fine for me. – Ravi Thapliyal
upvote
  flag
A bit late, but for anyone facing the same issue, you could try FragmentViewPager library (I am the author), which deals with this issue and provides a few extra features. For a sample, check project's GitHub page or this stackoverflow answer. – S. Brukhanda
2 upvote
  flag
Doesn't get called at all. – Violet Giraffe
upvote
  flag
setUserVisibleHint() is not called when your App is paused on the fragment you want and you restart it from onNewIntent() – Pierre
upvote
  flag
upvote
  flag
Its just ridiculous that there are so many different hacks for something the SDK should provide by default. – Mike6679

Here is another way using 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

  }
});
upvote
  flag
This solution works well, thanks. This should be the recommended solution for those building for older platforms using the (v4) fragment support packages – Frank Yin
5 upvote
  flag
It's worth noting that this could not give you the expected result if you're using a FragmentStatePagerAdapter and instantiating a new Fragment instance on getItem(), because you would only be setting the state on the new fragment and not the one that the viewpager got – Ben Pearson
upvote
  flag
This solution is good if you want to perform something when the fragment becomes visible. It doesn't keep a fragment's visible state (meaning, it doesn't know when the fragment is invisible). – AsafK
upvote
  flag
I am same type of problem. please help me to solve the problem. My Post : //allinonescript.com/questions/23115283/… – Jeeten Parmar
upvote
  flag
this is giving null pointer exception for adapter which i am using in the iamVisible method of the fragment. I am trying to set data received from network only when the fragment is visible. – zaphod100.10
upvote
  flag
The correct is isVisible instead of imVisible. No? – androidevil
upvote
  flag
This call seems to be deprecated. – Zapnologica
upvote
  flag

Override Fragment.onHiddenChanged() for that.

public void onHiddenChanged(boolean hidden)

Called when the hidden state (as returned by isHidden()) of the fragment has changed. Fragments start out not hidden; this will be called whenever the fragment changes state from that.

Parameters
hidden - boolean: True if the fragment is now hidden, false if it is not visible.

2 upvote
  flag
this method is deprecated by now and can not be used anymore – bluewhile
4 upvote
  flag
@bluewhile where do you see it is deprecated? developer.android.com/reference/android/app/… – Cel
1 upvote
  flag
I've just used this with success, and the documentation don't seem to indicate it's deprecated. – Trevor
1 upvote
  flag
@bluewhile, in 4.1 (api 16) it is not deprecated yet. – dan
6 upvote
  flag
I'm using API level 19 and can confirm that while this is not deprecated, it does not work as advertised. onHiddenChanged is not called when the fragment is hidden by another fragment, for example. – user153275
upvote
  flag
This method is not called. – AndroidGuy
up vote 427 down vote accepted

UPDATE: Android Support Library (rev 11) finally fixed the user visible hint issue, now if you use support library for fragments, then you can safely use getUserVisibleHint() or override setUserVisibleHint() to capture the changes as described by gorn's answer.

UPDATE 1 Here is one small problem with getUserVisibleHint(). This value is by default true.

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

So there might be a problem when you try to use it before setUserVisibleHint() was invoked. As a workaround you might set value in onCreate method like this.

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

The outdated answer:

In most use cases, ViewPager only show one page at a time, but the pre-cached fragments are also put to "visible" state (actually invisible) if you are using FragmentStatePagerAdapter in Android Support Library pre-r11.

I override :

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

To capture the focus state of fragment, which I think is the most suitable state of the "visibility" you mean, since only one fragment in ViewPager can actually place its menu items together with parent activity's items.

63 upvote
  flag
Be carefull to use getActivity(), on first start it will be null. – vovkab
6 upvote
  flag
Note that setUserVisibleHint() has always worked properly in FragmentPagerAdapter. – louielouie
upvote
  flag
Gr8! But is this work perfectly in old support v4? – thecr0w
5 upvote
  flag
This solution (and also gorn's) is lagging a little bit. In cases where the viewpager is swiped quickly and mutliple times, this method will be called with a delay (when the fragment is no longer visible/invisible). – AsafK
upvote
  flag
all above solution work once fragment visible completely..is there any way to know when it just get started to visible. – CoDe
2 upvote
  flag
I am getting true for getUserVisibleHint() when onCreateOptionsMenu is called, and when setUserVisibleHint is called, the menu has not yet been been created it seems. Ultimately I get two options Menu's added when I only want the menu from the fragment that is visible. Any suggestions in this regard? – cYrixmorten
upvote
  flag
This is just to let anyone who's thinking of using this approach know that there's a delay of almost a second before your updates show up. My app is almost done and I'm not happy with the results on the phone. For some reason, this isn't very noticeable on the emulator but on the phone is very disconcerting. To give you an example, if you have a ListView setup with a TextView that shows up when the List is empty, when you swipe to that Fragment (with the backing data list now cleared) you'll see all the previous list items first and then they'll vanish with "no data/empty text" a second later! – Ravi Thapliyal
upvote
  flag
A bit late, but for anyone facing the same issue, you could try FragmentViewPager library (I am the author), which deals with this issue and provides a few extra features. For a sample, check project's GitHub page or this stackoverflow answer. – S. Brukhanda
upvote
  flag
Above new answer works fine but it must be noted that above answer would not work if you're working with transactions. It means the fragment which is created by a transaction, always is visible by default and that callback would be called. – Alireza
upvote
  flag
The updated answer made my day... :D :D thanks a lot @Piyush – Jimit Patel

I overrode the Count method of the associated FragmentStatePagerAdapter and have it return the total count minus the number of pages to hide:

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

So, if there are 3 fragments initially added to the ViewPager, and only the first 2 should be shown until some condition is met, override the page count by setting TrimmedPages to 1 and it should only show the first two pages.

This works good for pages on the end, but wont really help for ones on the beginning or middle (though there are plenty of ways of doing this).

I had the same issue. ViewPager executes other fragment life cycle events and I could not change that behavior. I wrote a simple pager using fragments and available animations. SimplePager

I figured out that onCreateOptionsMenu and onPrepareOptionsMenu methods called only in the case of the fragment really visible. I could not found any method which behaves like these, also I tried OnPageChangeListener but it did not work for the situations, for example, I need a variable initialized in onCreate method.

So these two methods can be used for this problem as a workaround, specifically for little and short jobs.

I think, this is the better solution but not the best. I will use this but wait for better solution at the same time.

Regards.

upvote
  flag
sounds logical. – Jemshit Iskenderov

This seems to restore the normal onResume() behavior that you would expect. It plays well with pressing the home key to leave the app and then re-entering the app. onResume() is not called twice in a row.

@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
}
upvote
  flag
isResumed() was really helpful to get the desired result. – kamal_prd
1 upvote
  flag
Exactly what I was looking for. Solves the problem with setUserVisibleHint being called before onCreateView and that setUserVisibleHint doesn't get called if app goes background and then foreground. Awesome! Thank you! – Alex
3 upvote
  flag
I think calling onResume yourself is a pretty bad idea, but otherwise, everything you need to answer the question of this post is in the setUserVisibleHint function ! – Quentin G.
upvote
  flag
Yea, I'd probably tend to agree; for this example I implemented like that only for the sake of simplicity. You can create your own method onVisible or whatever you'd like to name it and call that method instead of onResume. – craigrs84
upvote
  flag
Thanks a lot, this together with some checks in addOnTabSelectedListener worked great for me. – Waqas Khalid Obeidy

setUserVisibleHint() gets called sometimes before onCreateView() and sometimes after which causes trouble.

To overcome this you need to check isResumed() as well inside setUserVisibleHint() method. But in this case i realized setUserVisibleHint() gets called only if Fragment is resumed and visible, NOT when Created.

So if you want to update something when Fragment is visible, put your update function both in onCreate() and 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 called twice sometimes, the reason is, if you have 3 tabs and this code is on 2nd tab, when you first open 1st tab, the 2nd tab is also created even it is not visible and myUIUpdate() is called. Then when you swipe to 2nd tab, myUIUpdate() from if (visible && isResumed()) is called and as a result,myUIUpdate() may get called twice in a second.

The other problem is !visible in setUserVisibleHint gets called both 1) when you go out of fragment screen and 2) before it is created, when you switch to fragment screen first time.

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

Explanation:

fragmentResume,fragmentVisible: Makes sure myUIUpdate() in onCreateView() is called only when fragment is created and visible, not on resume. It also solves problem when you are at 1st tab, 2nd tab is created even if it is not visible. This solves that and checks if fragment screen is visible when onCreate.

fragmentOnCreated: Makes sure fragment is not visible, and not called when you create fragment first time. So now this if clause only gets called when you swipe out of fragment.

Update You can put all this code in BaseFragment code like this and override method.

Override setPrimaryItem() in the FragmentPagerAdapter subclass. I use this method, and it works well.

@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();
    }
}
1 upvote
  flag
This almost worked but had issues with NPE and being called multiple times. Posted an alternative below! – Gober
upvote
  flag

I encountered this problem when I was trying to get a timer to fire when the fragment in the viewpager was on-screen for the user to see.

The timer always started just before the fragment was seen by the user. This is because the onResume() method in the fragment is called before we can see the fragment.

My solution was to do a check in the onResume() method. I wanted to call a certain method 'foo()' when fragment 8 was the view pagers current fragment.

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

Hope this helps. I've seen this problem pop up a lot. This seems to be the simplest solution I've seen. A lot of others are not compatible with lower APIs etc.

Note that setUserVisibleHint(false) is not called on activity / fragment stop. You'll still need to check start/stop to properly register/unregister any listeners/etc.

Also, you'll get setUserVisibleHint(false) if your fragment starts in a non-visible state; you don't want to unregister there since you've never registered before in that case.

@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
    }
}
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);
    }
}
upvote
  flag
This works for me. – w3hacker
upvote
  flag
This is excellent solution, Thanks. – Arjun
upvote
  flag
This should be the accepted answer. Works with android.app.Fragment also, which is a huge bonus. – RajV

Another solution posted here overriding setPrimaryItem in the pageradapter by kris larson almost worked for me. But this method is called multiple times for each setup. Also I got NPE from views, etc. in the fragment as this is not ready the first few times this method is called. With the following changes this worked for me:

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

I encountered the same problem while working with FragmentStatePagerAdapters and 3 tabs. I had to show a Dilaog whenever the 1st tab was clicked and hide it on clicking other tabs.

Overriding setUserVisibleHint() alone didn't help to find the current visible fragment.

When clicking from 3rd tab -----> 1st tab. It triggered twice for 2nd fragment and for 1st fragment. I combined it with isResumed() method.

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

}

Add following Code inside fragment

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

     }
}
upvote
  flag
This only works for ViewPagerFragments. Not for fragments in normal activity. – AndroidGuy

To detect Fragment in ViewPager visible, I quite sure that only using setUserVisibleHint is not enough.
Here is my solution for check fragment visible, invisible when first launch viewpager, switch between page, go to another activity/fragment/ background/foreground`

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

    /**
     * This method will 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();
    }
}

EXPLANATION You can check the logcat below carefully then I think you may know why this solution will work

First launch

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

Go to page2

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

Go to page3

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

Go to background:

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

Go to foreground

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

DEMO project here

Hope it help

1 upvote
  flag
Thanks for solution. It works perfect for my case. :) – Beena

In the Fragment use the GestureDetector.OnGestureListenerand and when that fires you will know that "this" Fragment is visible

In the Fragment use the GestureDetector

upvote
  flag
Is this just repeating this other answer? – Pang

We have a special case with MVP where the fragment needs to notify the presenter that the view has become visible, and the presenter is injected by Dagger in fragment.onAttach().

setUserVisibleHint() is not enough, we've detected 3 different cases that needed to be addressed (onAttach() is mentioned so that you know when the presenter is available):

  1. Fragment has just been created. The system makes the following calls:

    setUserVisibleHint() // before fragment's lifecycle calls, so presenter is null
    onAttach()
    ...
    onResume()
    
  2. Fragment already created and home button is pressed. When restoring the app to foreground, this is called:

    onResume()
    
  3. Orientation change:

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

We only want the visibility hint to get to the presenter once, so this is how we do it:

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

I handle the visible state at here: Check fragment is currently visible or not in android?. I split the Fragment's switch type into three ways, and if nested use, handle the sub Fragment's visible state in it's parent Fragment. It work for me.

Detecting by focused view!

This works for me

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

Not the answer you're looking for? Browse other questions tagged or ask your own question.