从源码的角度理解Fragment setUserVisibleHint与onHiddenChanged回调方法执行时机

Fragment一直是android开发者经常使用的控件，但是本人一直对这两个方法回调的时机弄得不是很清楚，今天就通过源码来看看，这两个api究竟怎么用。

setUserVisibleHint

    /**
     * Set a hint to the system about whether this fragment's UI is currently visible
     * to the user. This hint defaults to true and is persistent across fragment instance
     * state save and restore.
     *
     * <p>An app may set this to false to indicate that the fragment's UI is
     * scrolled out of visibility or is otherwise not directly visible to the user.
     * This may be used by the system to prioritize operations such as fragment lifecycle updates
     * or loader ordering behavior.</p>
     *
     * <p><strong>Note:</strong> This method may be called outside of the fragment lifecycle.
     * and thus has no ordering guarantees with regard to fragment lifecycle method calls.</p>
     *
     * @param isVisibleToUser true if this fragment's UI is currently visible to the user (default),
     *                        false if it is not.
     */
    public void setUserVisibleHint(boolean isVisibleToUser) {
        if (!mUserVisibleHint && isVisibleToUser && mState < STARTED
                && mFragmentManager != null && isAdded()) {
            mFragmentManager.performPendingDeferredStart(this);
        }
        mUserVisibleHint = isVisibleToUser;
        mDeferStart = mState < STARTED && !isVisibleToUser;
    }

* <p><strong>Note:</strong> This method may be called outside of the fragment lifecycle.
     * and thus has no ordering guarantees with regard to fragment lifecycle method calls.</p>

给系统设置一个提示当前fragment是否对用户可见，默认是可见的并且在fragment发生重启之后也会保存这个状态。注意看note，这个方法可能被调用在Fragment生命周期之外，并且不能保证这个方法与Fragment生命周期的排序。

查看源码，setUserVisibleHint被引用的状况，

image.png

发现在FragmentPageAdapter和FragmentStatePageAdapter中被调用了，看到这两个类是不是很熟悉，不就是我们常用的ViewPager+Fragment框架使用的适配器吗,下面我通过一个ViewPager+Fragment来查看
setUserVisibleHint的调用情况：

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="com.example.ziv.myapplication.MainActivity">

    <android.support.v4.view.ViewPager
        android:id="@+id/layout_content"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_below="@id/btn_next"
        android:orientation="horizontal" />
</RelativeLayout>

package com.example.ziv.myapplication;

import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentPagerAdapter;
import android.support.v4.app.FragmentTransaction;
import android.support.v4.view.ViewPager;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.EditText;

import java.util.List;

public class MainActivity extends AppCompatActivity {

    private final static String TAG = "BaseFragment";
    private ViewPager mViewPager;
    private EditText etPageNum;
    private Fragment[] mFragments;
    private FragmentManager mFragmentManager;
    private Frgament1 mFrgament1;
    private Frgament2 mFrgament2;
    private Frgament3 mFrgament3;
    private Frgament4 mFrgament4;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.e(TAG, "onCreate");
        setContentView(R.layout.activity_main);
        initViews();

        findViewById(R.id.btn_inflate_content).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                int num = Integer.valueOf(etPageNum.getText().toString());
                Fragment fragment = mFragmentManager.findFragmentByTag(String.format("%s%d", "Frgament", num));
                FragmentTransaction fragmentTransaction = mFragmentManager.beginTransaction();
                List<Fragment> fragmentList = mFragmentManager.getFragments();
                if (fragment == null) {
                    fragmentTransaction.add(R.id.layout_content, getFragmentByNum(num), String.format("%s%d", "Frgament", num));
                } else {
                    if (fragment.isAdded()) {
                        fragmentTransaction.show(fragment);
                    }
                }

                for (Fragment f : fragmentList) {
                    if (!f.equals(fragment)) {
                        fragmentTransaction.hide(f);
                    }
                }
                fragmentTransaction.addToBackStack(null);
                fragmentTransaction.commit();
            }
        });
    }

    private BaseFragment getFragmentByNum(int num) {

        BaseFragment fragment = null;

        switch (num) {
            case 1:
                fragment = mFrgament1;
                break;
            case 2:
                fragment = mFrgament2;
                break;
            case 3:
                fragment = mFrgament3;
                break;
            case 4:
                fragment = mFrgament4;
                break;
            default:
                fragment = mFrgament1;
                break;
        }
        return fragment;
    }

    private void initViews() {

        mViewPager = findViewById(R.id.layout_content);
//        etPageNum = findViewById(R.id.et_page_num);

        mFrgament1 = new Frgament1();
        mFrgament2 = new Frgament2();
        mFrgament3 = new Frgament3();
        mFrgament4 = new Frgament4();

        mFragments = new Fragment[]{mFrgament1, mFrgament2, mFrgament3, mFrgament4};
        mFragmentManager = getSupportFragmentManager();

        mViewPager.setOffscreenPageLimit(1);
        mViewPager.setAdapter(new MyAdapter(mFragmentManager));
    }

    @Override
    protected void onStart() {
        super.onStart();
        Log.e(TAG, "onStart");
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.e(TAG, "onResume");
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.e(TAG, "onStop");
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.e(TAG, "onPause");
    }

    @Override
    protected void onRestart() {
        super.onRestart();
        Log.e(TAG, "onRestart");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.e(TAG, "onDestroy");
    }

    private class MyAdapter extends FragmentPagerAdapter {

        public MyAdapter(FragmentManager fm) {
            super(fm);
        }

        @Override
        public Fragment getItem(int position) {
            return mFragments[position];
        }

        @Override
        public int getCount() {
            return mFragments.length;
        }
    }
}

package com.example.ziv.myapplication;

import android.os.Bundle;
import android.support.annotation.Nullable;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

/**
 * Created by ziv on 2017/12/20.
 */

public class Frgament1 extends BaseFragment {

    private final static String TAG = "BaseFragment";

    private View rootView;

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, Bundle savedInstanceState) {
        Log.e("", "onCreateView rootView is null ?"+(rootView==null));
        if (rootView == null) {
            rootView = inflater.inflate(R.layout.fragment_1, container, false);
        }
        return rootView;
    }
}

其他fragment类似，再来看看BaseFragment

package com.example.ziv.myapplication;

import android.content.Context;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v4.app.Fragment;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

/**
 * Created by ziv on 2017/12/20.
 */

public class BaseFragment extends Fragment {

    private final static String TAG = BaseFragment.class.getSimpleName();

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.e(TAG, this.getClass().getSimpleName() + "onCreate");
    }

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, Bundle savedInstanceState) {
        return super.onCreateView(inflater, container, savedInstanceState);
    }

    @Override
    public void onAttach(Context context) {
        super.onAttach(context);
        Log.e(TAG, this.getClass().getSimpleName() + "onAttach");
    }

    @Override
    public void onActivityCreated(@Nullable Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        Log.e(TAG, this.getClass().getSimpleName() + "onActivityCreated");
    }

    @Override
    public void onStart() {
        super.onStart();
        Log.e(TAG, this.getClass().getSimpleName() + "onStart");
    }

    @Override
    public void onResume() {
        super.onResume();
        Log.e(TAG, this.getClass().getSimpleName() + "onResume");
    }

    @Override
    public void onStop() {
        super.onStop();
        Log.e(TAG, this.getClass().getSimpleName() + "onStop");
    }

    @Override
    public void onPause() {
        super.onPause();
        Log.e(TAG, this.getClass().getSimpleName() + "onPause");
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.e(TAG, this.getClass().getSimpleName() + "onDestroy");
    }

    @Override
    public void onDestroyView() {
        super.onDestroyView();
        Log.e(TAG, this.getClass().getSimpleName() + "onDestroyView");
    }

    @Override
    public void onDetach() {
        super.onDetach();
        Log.e(TAG, this.getClass().getSimpleName() + "onDetach");
    }

    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        super.setUserVisibleHint(isVisibleToUser);
        Log.e(TAG, this.getClass().getSimpleName()+"setUserVisibleHint isVisibleToUser is: " + isVisibleToUser);
    }

    @Override
    public void onHiddenChanged(boolean hidden) {
        super.onHiddenChanged(hidden);
        Log.e(TAG, this.getClass().getSimpleName()+"onHiddenChanged hidden is: " + hidden);
    }
}

先来看看mViewPager.setOffscreenPageLimit(1);设置ViewPager预加载页数。看看看log：
首次加载时：

image.png

可以看到setUserVisibleHint是在onAttach之前调用的，因为设置了预加载，所以Fragment2的setUserVisibleHint也会被调用,然后就是正常的Fragment生命周期了。
滑动到Fragment2时：

image.png

由于预加载了一页，也就是当前Fragment的前后各自一页，所以这个时后Fragment3也会被加载，Fragment1这是后被缓存了。
滑动到Fragment3时：

image.png

由于只能预加载一页所以Fragment1被销毁了，setUserVisibleHint是在被加载或缓存的Fragment调用(Frgamen2/Fragment4),Fragment1已经被销毁了，如果是初次加载则在onAttach之前调用。
从Fragment3滑动到Fragment2：

image.png

综上所诉，setUserVisibleHint的调用与ViewPager预加载有关系，如果当前Fragment是属于预加载的页，setUserVisibleHint才会被调用。并且在onAttach之前调用，所以如果想要在setUserVisibleHint做懒加载，一定要判断当前Fragment的View是否已经初始化了。因为不去额定setUserVisibleHint的调用时机，所以做懒加载时最好在onResume和setUserVisibleHint都进行判断是否显示和是否Resumed的，示例代码如下：

    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        super.setUserVisibleHint(isVisibleToUser);
        mVisibleToUser = isVisibleToUser;
        Log.debug(TAG, "setUserVisibleHint isVisibleToUser=" + isVisibleToUser + ", [" + getClass().getSimpleName() + "]");
        if(isVisibleToUser && mResumed) {
            Log.debug(TAG, "onPageStart !! [" + getClass().getSimpleName() + "]");
            onPageStart();
        }
    }

    @Override
    public void onResume() {
        super.onResume();
        Log.debug(TAG, "onResume !! mVisibleToUser =" + mVisibleToUser + ", [" + getClass().getSimpleName() + "]");
        if(mVisibleToUser) {
            Log.debug(TAG, "onPageStart !! [" + getClass().getSimpleName() + "]");
            onPageStart();
        }
    }

onHiddenChanged

    /**
     * Called when the hidden state (as returned by {@link #isHidden()} of
     * the fragment has changed.  Fragments start out not hidden; this will
     * be called whenever the fragment changes state from that.
     * @param hidden True if the fragment is now hidden, false otherwise.
     */
    public void onHiddenChanged(boolean hidden) {
    }

大致意思就是Fragment的隐藏状态改变。隐藏状态，首先Fragment得隐藏。加载Fragment有两种方式，一种是replace，一种是add+show+hide；
这里先说结论：第一次add时是不会调用onHiddenChanged的，只有当一个Fragment之前的状态是hidden，然后show，这时候才会调用onHiddenChanged，或者之前的状态是show，然后置为hidden时，也会回调onHiddenChanged。现在从源码的角度来看，onHiddenChanged的调用时机：

    int num = Integer.valueOf(etPageNum.getText().toString());
                Fragment fragment = mFragmentManager.findFragmentByTag(String.format("%s%d", "Frgament", num));
                FragmentTransaction fragmentTransaction = mFragmentManager.beginTransaction();
                List<Fragment> fragmentList = mFragmentManager.getFragments();
                if (fragment == null) {
                    fragmentTransaction.add(R.id.layout_content, getFragmentByNum(num), String.format("%s%d", "Frgament", num));
                } else {
                    if (fragment.isAdded()) {
                        fragmentTransaction.show(fragment);
                    }
                }

                for (Fragment f : fragmentList) {
                    if (!f.equals(fragment)) {
                        fragmentTransaction.hide(f);
                    }
                }
                fragmentTransaction.addToBackStack(null);
                fragmentTransaction.commit();

来看fragmentTransaction.show

    @Override
    public FragmentTransaction show(Fragment fragment) {
        addOp(new Op(OP_SHOW, fragment));

        return this;
    }

    void addOp(Op op) {
        mOps.add(op);
        op.enterAnim = mEnterAnim;
        op.exitAnim = mExitAnim;
        op.popEnterAnim = mPopEnterAnim;
        op.popExitAnim = mPopExitAnim;
    }

    static final class Op {
        int cmd;
        Fragment fragment;
        int enterAnim;
        int exitAnim;
        int popEnterAnim;
        int popExitAnim;

        Op() {
        }

        Op(int cmd, Fragment fragment) {
            this.cmd = cmd;
            this.fragment = fragment;
        }
    }
// cmd指的是当前Fragment的要进行的动作
    static final int OP_NULL = 0;
    static final int OP_ADD = 1;
    static final int OP_REPLACE = 2;
    static final int OP_REMOVE = 3;
    static final int OP_HIDE = 4;
    static final int OP_SHOW = 5;
    static final int OP_DETACH = 6;
    static final int OP_ATTACH = 7;
    static final int OP_SET_PRIMARY_NAV = 8;
    static final int OP_UNSET_PRIMARY_NAV = 9;

把当前操作存在一个List里,再来看看commit方法：

    @Override
    public int commit() {
        return commitInternal(false);
    }

    int commitInternal(boolean allowStateLoss) {
        if (mCommitted) throw new IllegalStateException("commit already called");
        if (FragmentManagerImpl.DEBUG) {
            Log.v(TAG, "Commit: " + this);
            LogWriter logw = new LogWriter(TAG);
            PrintWriter pw = new PrintWriter(logw);
            dump("  ", null, pw, null);
            pw.close();
        }
        mCommitted = true;
        if (mAddToBackStack) {
            mIndex = mManager.allocBackStackIndex(this);
        } else {
            mIndex = -1;
        }
        mManager.enqueueAction(this, allowStateLoss);
        return mIndex;
    }

接着来看enqueueAction,

    public void enqueueAction(OpGenerator action, boolean allowStateLoss) {
        if (!allowStateLoss) {
            checkStateLoss();
        }
        synchronized (this) {
            if (mDestroyed || mHost == null) {
                if (allowStateLoss) {
                    // This FragmentManager isn't attached, so drop the entire transaction.
                    return;
                }
                throw new IllegalStateException("Activity has been destroyed");
            }
            if (mPendingActions == null) {
                mPendingActions = new ArrayList<>();
            }
            mPendingActions.add(action);
            scheduleCommit();
        }
    }

再来看 scheduleCommit(),

    /**
     * Schedules the execution when one hasn't been scheduled already. This should happen
     * the first time {@link #enqueueAction(OpGenerator, boolean)} is called or when
     * a postponed transaction has been started with
     * {@link Fragment#startPostponedEnterTransition()}
     */
    private void scheduleCommit() {
        synchronized (this) {
            boolean postponeReady =
                    mPostponedTransactions != null && !mPostponedTransactions.isEmpty();
            boolean pendingReady = mPendingActions != null && mPendingActions.size() == 1;
            if (postponeReady || pendingReady) {
                mHost.getHandler().removeCallbacks(mExecCommit);
                mHost.getHandler().post(mExecCommit);
            }
        }
    }

这里是执行一个排队的动作

    Runnable mExecCommit = new Runnable() {
        @Override
        public void run() {
            execPendingActions();
        }
    };

    /**
     * Only call from main thread!
     */
    public boolean execPendingActions() {
        ensureExecReady(true);

        boolean didSomething = false;
        while (generateOpsForPendingActions(mTmpRecords, mTmpIsPop)) {
            mExecutingActions = true;
            try {
                removeRedundantOperationsAndExecute(mTmpRecords, mTmpIsPop);
            } finally {
                cleanupExec();
            }
            didSomething = true;
        }

        doPendingDeferredStart();
        burpActive();

        return didSomething;
    }

接着就是removeRedundantOperationsAndExecute中执行executeOpsTogether，executeOpsTogether中执行executeOps
最后就来看下executeOps,已经找到真相了

    /**
     * Executes the operations contained within this transaction. The Fragment states will only
     * be modified if optimizations are not allowed.
     */
    void executeOps() {
        final int numOps = mOps.size();
        for (int opNum = 0; opNum < numOps; opNum++) {
            final Op op = mOps.get(opNum);
            final Fragment f = op.fragment;
            if (f != null) {
                f.setNextTransition(mTransition, mTransitionStyle);
            }
            switch (op.cmd) {
                case OP_ADD:
                    f.setNextAnim(op.enterAnim);
                    mManager.addFragment(f, false);
                    break;
                case OP_REMOVE:
                    f.setNextAnim(op.exitAnim);
                    mManager.removeFragment(f);
                    break;
                case OP_HIDE:
                    f.setNextAnim(op.exitAnim);
                    mManager.hideFragment(f);
                    break;
                case OP_SHOW:
                    f.setNextAnim(op.enterAnim);
                    mManager.showFragment(f);
                    break;
                case OP_DETACH:
                    f.setNextAnim(op.exitAnim);
                    mManager.detachFragment(f);
                    break;
                case OP_ATTACH:
                    f.setNextAnim(op.enterAnim);
                    mManager.attachFragment(f);
                    break;
                case OP_SET_PRIMARY_NAV:
                    mManager.setPrimaryNavigationFragment(f);
                    break;
                case OP_UNSET_PRIMARY_NAV:
                    mManager.setPrimaryNavigationFragment(null);
                    break;
                default:
                    throw new IllegalArgumentException("Unknown cmd: " + op.cmd);
            }
            if (!mReorderingAllowed && op.cmd != OP_ADD && f != null) {
                mManager.moveFragmentToExpectedState(f);
            }
        }
        if (!mReorderingAllowed) {
            // Added fragments are added at the end to comply with prior behavior.
            mManager.moveToState(mManager.mCurState, true);
        }
    }

再来看看showFragment和hideFragment

    /**
     * Marks a fragment as hidden to be later animated in with
     * {@link #completeShowHideFragment(Fragment)}.
     *
     * @param fragment The fragment to be shown.
     */
    public void hideFragment(Fragment fragment) {
        if (DEBUG) Log.v(TAG, "hide: " + fragment);
        if (!fragment.mHidden) {
            fragment.mHidden = true;
            // Toggle hidden changed so that if a fragment goes through show/hide/show
            // it doesn't go through the animation.
            fragment.mHiddenChanged = !fragment.mHiddenChanged;
        }
    }

    /**
     * Marks a fragment as shown to be later animated in with
     * {@link #completeShowHideFragment(Fragment)}.
     *
     * @param fragment The fragment to be shown.
     */
    public void showFragment(Fragment fragment) {
        if (DEBUG) Log.v(TAG, "show: " + fragment);
        if (fragment.mHidden) {
            fragment.mHidden = false;
            // Toggle hidden changed so that if a fragment goes through show/hide/show
            // it doesn't go through the animation.
            fragment.mHiddenChanged = !fragment.mHiddenChanged;
        }
    }

这两个方法都对mHiddenChanged进行重新赋值，就导致了onHiddenChanged的回调。