LifeCycle of Fragment in FragmentStatePagerAdapter is unexpected

Question

I want to create a video list using ViewPager. I must know when pager item visible, and invisible. I use VideoListAdapter extending FragmentStatePagerAdapter for ViewPager. I use Fragment method setUserVisibleHint to trigger video start or pause. But there is a problem, the Fragment in the position 0 of ViewPager throw a NullPointerException. And then i print log for releated method of Fragment.
The log i come into VideoListActivity: 07-08 17:06:50.264 E/lemon: startUpdate 07-08 17:06:50.264 E/lemon: instantiateItem 0 07-08 17:06:50.264 E/lemon: getItem 0 07-08 17:06:50.264 E/lemon: setUserVisibleHint 0 isVisibleToUser false 07-08 17:06:50.264 E/lemon: instantiateItem 1 07-08 17:06:50.264 E/lemon: getItem 1 07-08 17:06:50.264 E/lemon: setUserVisibleHint 0 isVisibleToUser false 07-08 17:06:50.264 E/lemon: setPrimaryItem 0 07-08 17:06:50.264 E/lemon: setUserVisibleHint 0 isVisibleToUser true 07-08 17:06:50.264 E/lemon: finishUpdate 07-08 17:06:50.265 E/lemon: onAttach 0 07-08 17:06:50.265 E/lemon: onAttach 1 07-08 17:06:50.265 E/lemon: onCreateView 0 07-08 17:06:50.267 E/lemon: onstart 0 07-08 17:06:50.267 E/lemon: onCreateView 1 07-08 17:06:50.269 E/lemon: onstart 1 07-08 17:06:50.270 E/lemon: startUpdate 07-08 17:06:50.270 E/lemon: setPrimaryItem 0 07-08 17:06:50.270 E/lemon: finishUpdate 07-08 17:06:50.297 E/lemon: startUpdate 07-08 17:06:50.297 E/lemon: setPrimaryItem 0 07-08 17:06:50.297 E/lemon: finishUpdate 07-08 17:06:50.297 E/lemon: startUpdate 07-08 17:06:50.297 E/lemon: setPrimaryItem 0 07-08 17:06:50.297 E/lemon: finishUpdate 07-08 17:06:50.703 E/lemon: startUpdate 07-08 17:06:50.703 E/lemon: setPrimaryItem 0 07-08 17:06:50.703 E/lemon: finishUpdate 07-08 17:06:50.704 E/lemon: startUpdate 07-08 17:06:50.704 E/lemon: setPrimaryItem 0 07-08 17:06:50.704 E/lemon: finishUpdate

The log i scroll to position 1: 07-08 17:09:41.154 E/lemon: startUpdate 07-08 17:09:41.154 E/lemon: setPrimaryItem 0 07-08 17:09:41.154 E/lemon: finishUpdate 07-08 17:09:41.966 E/lemon: startUpdate 07-08 17:09:41.966 E/lemon: instantiateItem 2 07-08 17:09:41.967 E/lemon: getItem 2 07-08 17:09:41.967 E/lemon: setUserVisibleHint 0 isVisibleToUser false 07-08 17:09:41.967 E/lemon: setPrimaryItem 1 07-08 17:09:41.967 E/lemon: setUserVisibleHint 0 isVisibleToUser false 07-08 17:09:41.967 E/lemon: setUserVisibleHint 1 isVisibleToUser true 07-08 17:09:41.967 E/lemon: finishUpdate 07-08 17:09:41.968 E/lemon: onAttach 2 07-08 17:09:41.968 E/lemon: onCreateView 2 07-08 17:09:41.971 E/lemon: onstart 2 07-08 17:09:41.971 E/lemon: startUpdate 07-08 17:09:41.971 E/lemon: setPrimaryItem 1 07-08 17:09:41.971 E/lemon: finishUpdate 07-08 17:09:41.972 E/lemon: startUpdate 07-08 17:09:41.972 E/lemon: setPrimaryItem 1 07-08 17:09:41.972 E/lemon: finishUpdate
I analyse these logs, I find that fragment in positino 0 invokes setUserVisibleHint(true) first and then invokes onAttach(), but fragment in position 1 invokes onAttach() first and setUserVisibleHint(true) after.

So I write a method onTrigger() in Fragment called in both onAttach() and setUserVisibleHint(true), but fail. I then debug my code, it's show that isAdded() in onTrigger() returns false when invoke onTrigger in onAttach().

So any suggestions here to let me know when to trigger my video start. Thanks a lot.

public class FullScreenVideoFragment extends Fragment {

    private FragmentFullScreenVideoBinding binding;
    int colorRes;
    int position;

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        Log.e("lemon", "onCreateView " + position);
        binding = DataBindingUtil.inflate(inflater, R.layout.fragment_full_screen_video, container, false);
        setView();
        return binding.getRoot();
    }

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }

    public void setBgAndPosition(int position, int colorRes) {
        this.position = position;
        this.colorRes = colorRes;
    }

    @Override
    public void onAttach(Context context) {
        Log.e("lemon", "onAttach " + position);
        super.onAttach(context);
        onTriger();
    }

    @Override
    public void onDetach() {
        Log.e("lemon", "onDetach " + position);
        super.onDetach();
    }

    @Override
    public void onAttachFragment(Fragment childFragment) {
        Log.e("lemon", "onAttachFragment " + position);
        super.onAttachFragment(childFragment);
    }

    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        Log.e("lemon", "setUserVisibleHint " + position + " isVisibleToUser " + isVisibleToUser);
        super.setUserVisibleHint(isVisibleToUser);
        onTriger();
    }

    private void setView() {
        binding.getRoot().setBackgroundResource(colorRes);
        binding.position.setText(String.valueOf(position));
    }

    private void onTriger() {
        if (!isVisible()) return;
        binding.position.setText(position + " start");
    }
}

public class VideoListAdapter extends FragmentStatePagerAdapter {
    private LinkedList<FullScreenVideoFragment> fragmentCaches;
    private int[] colors = new int[]{android.graphics.Color.RED, android.graphics.Color.BLUE, android.graphics.Color.GREEN};

    public VideoListAdapter(FragmentManager fm) {
        super(fm);
        fragmentCaches = new LinkedList<>();
    }

    @Override
    public Fragment getItem(int position) {
        Log.e("lemon", "getItem " + position);
        FullScreenVideoFragment fragment = generateItem();
        return fragment;
    }

    @Override
    public int getCount() {
        return 10;
    }

    @Override
    public void destroyItem(ViewGroup container, int position, Object object) {
        Log.e("lemon", "destroyItem " + position);
        super.destroyItem(container, position, object);
    }

    @Override
    public void setPrimaryItem(ViewGroup container, int position, Object object) {
        Log.e("lemon", "setPrimaryItem " + position);
        super.setPrimaryItem(container, position, object);
    }

    @Override
    public Object instantiateItem(ViewGroup container, int position) {
        Log.e("lemon", "instantiateItem " + position);
        FullScreenVideoFragment fragment = (FullScreenVideoFragment) super.instantiateItem(container, position);
        fragment.setBgAndPosition(position, colors[position % 3]);
        return fragment;
    }

    @Override
    public void startUpdate(ViewGroup container) {
        Log.e("lemon", "startUpdate");
        super.startUpdate(container);
    }

    @Override
    public void finishUpdate(ViewGroup container) {
        Log.e("lemon", "finishUpdate");
        super.finishUpdate(container);
    }

    @Override
    public void restoreState(Parcelable state, ClassLoader loader) {
        Log.e("lemon", "restoreState");
        super.restoreState(state, loader);
    }

    @Override
    public Parcelable saveState() {
        Log.e("lemon", "saveState");
        return super.saveState();
    }

    private FullScreenVideoFragment generateItem() {
        FullScreenVideoFragment neededFragment = null;
        if (!fragmentCaches.isEmpty()) {
            neededFragment = fragmentCaches.get(0);
            fragmentCaches.remove(0);
            return neededFragment;
        }
        neededFragment = new FullScreenVideoFragment();
        return neededFragment;
    }
}

The fragment xml:

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android">

    <data></data>

    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent">
        <TextView
            android:id="@+id/position"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerInParent="true"
            android:textColor="@color/account_name_color"/>
    </RelativeLayout>
</layout>

Answer 1

I found that Fragments often use these three ways to switch:

• show/hide

• attach/detach(replace)

• ViewPager

These three ways lead to Fragment visible state there are some differences, so I defined the following classes to distinguish between these three ways. If a group of Fragments are using the same way to switch, I think it should be reliable, if the switch in a different way, then I do not know, no careful test.

import android.support.annotation.IntDef;
import android.support.v4.app.Fragment;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

/**
 * Created by Kilnn on 2017/7/12.
 * A smart fragment know itself's visible state.
 */
public abstract class SmartFragment extends Fragment {

    private boolean isFragmentVisible;

    @Override
    public void onResume() {
        super.onResume();
        int switchType = getSwitchType();
        if (switchType == ATTACH_DETACH) {
            notifyOnFragmentVisible();
        } else if (switchType == SHOW_HIDE) {
            if (!isHidden()) {
                notifyOnFragmentVisible();
            }
        } else if (switchType == VIEW_PAGER) {
            //If the parent fragment exist and hidden when activity destroy,
            //when the activity restore, The parent Fragment  will be restore to hidden state.
            //And the sub Fragment which in ViewPager is also be restored, and the onResumed() method will callback.
            //And The sub Fragment's getUserVisibleHint() method will return true  if it is in active position.
            //So we need to judge the parent Fragment visible state.
            if (getUserVisibleHint() && isParentFragmentVisible()) {
                notifyOnFragmentVisible();
            }
        }
    }

    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        super.setUserVisibleHint(isVisibleToUser);
        int switchType = getSwitchType();
        if (switchType == VIEW_PAGER) {
            if (isVisibleToUser) {
                notifyOnFragmentVisible();
            } else {
                notifyOnFragmentInvisible();
            }
        }
    }

    @Override
    public void onHiddenChanged(boolean hidden) {
        super.onHiddenChanged(hidden);
        int switchType = getSwitchType();
        if (switchType == SHOW_HIDE) {
            if (hidden) {
                notifyOnFragmentInvisible();
            } else {
                notifyOnFragmentVisible();
            }
        }
    }

    @Override
    public void onPause() {
        super.onPause();
        notifyOnFragmentInvisible();
    }

    private boolean isParentFragmentVisible() {
        Fragment parent = getParentFragment();
        if (parent == null) return true;
        if (parent instanceof SmartFragment) {
            return ((SmartFragment) parent).isFragmentVisible();
        } else {
            //TODO May be can't get the correct visible state if parent Fragment is not SmartFragment
            return parent.isVisible();
        }
    }

    public boolean isFragmentVisible() {
        // Don't judge the state of the parent fragment,
        // because if the parent fragment visible state changes,
        // you must take the initiative to change the state of the sub fragment
//        return isFragmentVisible && isParentFragmentVisible();
        return isFragmentVisible;
    }

    public void notifyOnFragmentVisible() {
        if (!isFragmentVisible) {
            onFragmentVisible();
            isFragmentVisible = true;
        }
    }

    public void notifyOnFragmentInvisible() {
        if (isFragmentVisible) {
            onFragmentInvisible();
            isFragmentVisible = false;
        }
    }

    /**
     * If this method callback, the Fragment must be resumed.
     */
    public void onFragmentVisible() {

    }

    /**
     * If this method callback, the Fragment maybe is resumed or in onPause().
     */
    public void onFragmentInvisible() {

    }

    /**
     * Fragments switch with attach/detach(replace)
     */
    public static final int ATTACH_DETACH = 0;

    /**
     * Fragments switch with show/hide
     */
    public static final int SHOW_HIDE = 1;

    /**
     * Fragments manage by view pager
     */
    public static final int VIEW_PAGER = 2;

    @Retention(RetentionPolicy.SOURCE)
    @IntDef({ATTACH_DETACH, SHOW_HIDE, VIEW_PAGER})
    @interface SwitchType {
    }

    @SwitchType
    public abstract int getSwitchType();

}

So you can do onTrigger() in onFragmentVisible().