「这是我参与2022首次更文挑战的第14天，活动详情查看： 2022首次更文挑战 」。

Android日常开发中除了四个组件之外，还有一种使用频率很高的组件——Fragment。在使用时我们通常需要在Fragment的各种生命周期方法中处理数据加载、页面刷新和资源释放等逻辑操作。

但是当Fragment遇上了ViewPager，事情就变得有点不一样了。Fragment的生命周期变得不再那么可控，当显示Fragment A时，相邻的Fragment B的一些生命周期方法也会触发。这是因为ViewPager为了优化切换效果，使切换更流畅、顺滑，引入了预加载和缓存机制。通常会预加载前一个和后一个Fragment，让前一个和后一个Fragment提前初始化。

当页面布局过于复杂或者数据量比较大，甚至当Fragment中有播放器时，预加载会耗费资源，造成页面卡顿甚至页面播放器出现异常报错。

使用懒加载的意义就在于只有当Fragment被显示时，才会去加载耗费资源的素材和数据，可以节省资源、提升页面流畅度，而且让流程变得更可控。

Fragment中提供了一对可见性相关的方法 setUserVisibleHint(boolean isVisibleToUser) 和 getUserVisibleHint() 可以通过重写 setUserVisibleHint() 来监听页面可见性变化，当页面从不可见变为可见时触发加载数据方法，反之也可以实现页面从可见到不可见时部分资源的释放操作。

懒加载实现

先实现一个Fragment + ViewPager的结构（实现很简单省略了），依次有三个Fragment为：AFragment、BFragment和CFragemtn，三个Fragment分别继承基类BaseLazyLoadFragment。

生命周期变化

在基类中添加生命周期方法的打印，如下图：

从Fragment的生命周期变化可以看出，需要注意的有几点：

基于以上几点问题，我们通过来通过代码实现BaseLazyLoadFragment。

public abstract class BaseLazyLoadFragment extends BaseFragment {
    protected String TAG = BaseLazyLoadFragment.class.getSimpleName() + this.toString();
    //布局是否初始化完成
    private boolean isLayoutInitialized = false;
    //懒加载完成
    private boolean isLazyLoadFinished = false;
    //记录页面可见性
    private boolean isVisibleToUser = false;
    //不可见时释放部分资源
    private boolean isInVisibleRelease = false;
    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d(TAG, getClass().getSimpleName() + "  onCreate");
    @Nullable
    @Override
    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        super.onCreateView(inflater, container,savedInstanceState);
        Log.d(TAG, getClass().getSimpleName() + "  onCreateView");
        initView();
        return rootView;
    @Override
    public void onDestroyView() {
        super.onDestroyView();
        Log.d(TAG, getClass().getSimpleName() + "  onDestroyView");
        //页面释放后，重置布局初始化状态变量
        isLayoutInitialized = false;
        this.rootView = null;
    @Override
    public void onActivityCreated(@Nullable Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        Log.d(TAG, getClass().getSimpleName() + "  onActivityCreated");
        //此方法是在第一次初始化时onCreateView之后触发的
        //onCreateView和onActivityCreated中分别应该初始化哪些数据可以参考：
        //https://stackoverflow.com/questions/8041206/android-fragment-oncreateview-vs-onactivitycreated
        isLayoutInitialized = true;
        //第一次初始化后需要处理一次可见性事件
        //因为第一次初始化时setUserVisibleHint方法的触发要先于onCreateView
        dispatchVisibleEvent();
    @Override
    public void onStart() {
        super.onStart();
        Log.d(TAG, getClass().getSimpleName() + "  onStart");
    @Override
    public void onResume() {
        super.onResume();
        Log.d(TAG, getClass().getSimpleName() + "  onResume");
        //页面从其他Activity返回时，重新加载被释放的资源
        if(isLazyLoadFinished && isLayoutInitialized && isInVisibleRelease && isVisibleToUser){
//            visibleReLoad();
            resume();
            isInVisibleRelease = false;
    @Override
    public void onPause() {
        super.onPause();
        Log.d(TAG, getClass().getSimpleName() + "  onPause");
        //当从Fragment切换到其他Activity释放部分资源
        if(isLazyLoadFinished && isVisibleToUser){
            //页面从可见切换到不可见时触发，可以释放部分资源，配合reload方法再次进入页面时加载
//            inVisibleRelease();
            pause();
            isInVisibleRelease = true;
    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d(TAG, getClass().getSimpleName() + "  onDestroy");
        //重置所有数据
        this.rootView = null;
        isLayoutInitialized = false;
        isLazyLoadFinished = false;
        isVisibleToUser = false;
        isInVisibleRelease = false;
    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        super.setUserVisibleHint(isVisibleToUser);
        Log.d(TAG, getClass().getSimpleName() + "  setUserVisibleHint isVisibleToUser = " + isVisibleToUser);
        dispatchVisibleEvent();
     * 处理可见性事件
    private void dispatchVisibleEvent(){
        Log.d(TAG, getClass().getSimpleName() + "  dispatchVisibleEvent isVisibleToUser = " + getUserVisibleHint()
                + " --- isLayoutInitialized = " + isLayoutInitialized + " --- isLazyLoadFinished = " + isLazyLoadFinished);
        if(getUserVisibleHint() && isLayoutInitialized){
            if(!isLazyLoadFinished){
                //第一次可见，懒加载
                lazyLoad();
                isLazyLoadFinished = true;
            } else{
                //非第一次可见，刷新数据
                visibleReLoad();
        } else{
            if(isLazyLoadFinished && isVisibleToUser){
                //页面从可见切换到不可见时触发，可以释放部分资源，配合reload方法再次进入页面时加载
                inVisibleRelease();
        //处理完可见性事件之后修改isVisibleToUser状态
        this.isVisibleToUser = getUserVisibleHint();
     * 初始化View
    protected abstract void initView();
     * 绑定布局
     * @return 布局ID
    protected abstract int initLayout();
     * 懒加载<br/>
     * 只会在初始化后第一次可见时调用一次。
    protected abstract void lazyLoad();
     * 刷新数据加载<br/>
     * 配合{@link #lazyLoad()}，在页面非第一次可见时刷新数据
     * 左右切换Fragment时触发
    protected abstract void visibleReLoad();
     * 当页面从可见变为不可见时，释放部分数据和资源。<br/>
     * 比如页面播放器的释放或者一些特别占资源的数据的释放
     * 左右切换Fragment时触发
    protected abstract void inVisibleRelease();
     * 当从其他页面返回，重新可见
    protected abstract void resume();
     * 进入其他页面触发
    protected abstract void pause();
代码注释比较详细了，简单说一下。BaseLazyLoadFragment中提供了
lazyLoad()方法当页面被显示时做懒加载；
visibleReLoad()方法当页面没有被释放且从不可见状态切换到可见时刷新数据用；
inVisibleRelease()方法当页面从可见状态切换到不可见时，做部分资源释放（如播放器等）。
同样支持当切换到其他Activity时，触发inVisibleRelease()方法做资源释放，从Activity返回页面时触发visibleReLoad()刷新加载数据。
androidx的实现方式
以下部分涉及Fragment的生命周期相关内容，不熟悉的建议自行补习，借用一张官方说明图。官方说明
我们将项目迁移到androidx之后会发现setUserVisibleHint和getUserVisibleHint方法被标记为@Deprecated废弃了。方法注释中写明了通过FragmentTransaction中的setMaxLifecycle()方法来替换。
setMaxLifecycle
setMaxLifecycle是在androidx之后，FragmentTransaction中添加的方法，用于控制Fragment的最大生命周期。
fragmentTransaction = fragmentManager.beginTransaction();
//replace或add
fragmentTransaction.replace(R.id.fragment_frm, movieFragmentX);
//设置最大生命周期：Resume
fragmentTransaction.setMaxLifecycle(movieFragmentX, Lifecycle.State.RESUMED);
fragmentTransaction.commit();
注意：setMaxLifecycle方法必须在replace或add之后使用，要不然会抛出异常。
设置之后Fragment的生命周期只会执行到onResume()。
State的取值类型有以下几种，对应的生命周期执行到哪步方法注释中有具体说明。
 * Lifecycle states. You can consider the states as the nodes in a graph and
 * {@link Event}s as the edges between these nodes.
@SuppressWarnings("WeakerAccess")
public enum State {
     * Destroyed state for a LifecycleOwner. After this event, this Lifecycle will not dispatch
     * any more events. For instance, for an {@link android.app.Activity}, this state is reached
     * <b>right before</b> Activity's {@link android.app.Activity#onDestroy() onDestroy} call.
    DESTROYED,
     * Initialized state for a LifecycleOwner. For an {@link android.app.Activity}, this is
     * the state when it is constructed but has not received
     * {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} yet.
    INITIALIZED,
     * Created state for a LifecycleOwner. For an {@link android.app.Activity}, this state
     * is reached in two cases:
     *     <li>after {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} call;
     *     <li><b>right before</b> {@link android.app.Activity#onStop() onStop} call.
     * </ul>
    CREATED,
     * Started state for a LifecycleOwner. For an {@link android.app.Activity}, this state
     * is reached in two cases:
     *     <li>after {@link android.app.Activity#onStart() onStart} call;
     *     <li><b>right before</b> {@link android.app.Activity#onPause() onPause} call.
     * </ul>
    STARTED,
     * Resumed state for a LifecycleOwner. For an {@link android.app.Activity}, this state
     * is reached after {@link android.app.Activity#onResume() onResume} is called.
    RESUMED;
     * Compares if this State is greater or equal to the given {@code state}.
     * @param state State to compare with
     * @return true if this State is greater or equal to the given {@code state}
    public boolean isAtLeast(@NonNull State state) {
        return compareTo(state) >= 0;
阅读上面源码中的注释会发现CREATED和STARTED这两个类型相比其他类型注释中多了一句right before{@link android.app.Activity#onPause() onPause} call.怎么理解这句话呢？
如果Fragment已经正常显示，生命周期执行到onResume()，再设置setMaxLifecycle到CREATED或STARTED，那么Fragment的生命周期会相应的回退到onStop()或onPause()，也就是对应方法注释中的解释。
单独使用setMaxLifecycle():
fragmentTransaction = fragmentManager.beginTransaction();
fragmentTransaction.setMaxLifecycle(movieFragmentX, Lifecycle.State.CREATED);
fragmentTransaction.commit();
log如下图：
懒加载实现
既然androidx已经提供了setMaxLifecycle()来精确控制Fragment的生命周期，我们只需要通过setMaxLifecycle()来控制显示的Fragment的生命周期就可以实现懒加载功能，实际上android已经为我们提供了现成的实现方式。
当我们把项目迁移到androidx之后，会发现FragmentAdapter和FragmentStatePagerAdapter都添加了一个构造方法。
//FragmentStatePagerAdapter构造方法
public FragmentStatePagerAdapter(@NonNull FragmentManager fm,
        @Behavior int behavior) {
    mFragmentManager = fm;
    mBehavior = behavior;
//FragmentPagerAdapter构造方法
public FragmentPagerAdapter(@NonNull FragmentManager fm,
        @Behavior int behavior) {
    mFragmentManager = fm;
    mBehavior = behavior;
添加了一个behavior参数，behavior的取值如下：
@IntDef({BEHAVIOR_SET_USER_VISIBLE_HINT, BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT})
private @interface Behavior { }
//.....
 * Indicates that {@link Fragment#setUserVisibleHint(boolean)} will be called when the current
 * fragment changes.
 * @deprecated This behavior relies on the deprecated
 * {@link Fragment#setUserVisibleHint(boolean)} API. Use
 * {@link #BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT} to switch to its replacement,
 * {@link FragmentTransaction#setMaxLifecycle}.
 * @see #FragmentPagerAdapter(FragmentManager, int)
@Deprecated
public static final int BEHAVIOR_SET_USER_VISIBLE_HINT = 0;
 * Indicates that only the current fragment will be in the {@link Lifecycle.State#RESUMED}
 * state. All other Fragments are capped at {@link Lifecycle.State#STARTED}.
 * @see #FragmentPagerAdapter(FragmentManager, int)
public static final int BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT = 1;
以FragmentPagerAdapter为例，通过查看源码的setPrimaryItem()方法。
@SuppressWarnings({"ReferenceEquality", "deprecation"})
@Override
public void setPrimaryItem(@NonNull ViewGroup container, int position, @NonNull Object object) {
    Fragment fragment = (Fragment)object;
    if (fragment != mCurrentPrimaryItem) {
        if (mCurrentPrimaryItem != null) {
		    //当前显示Fragment
            mCurrentPrimaryItem.setMenuVisibility(false);
            if (mBehavior == BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT) {
                if (mCurTransaction == null) {
                    mCurTransaction = mFragmentManager.beginTransaction();
				//最大生命周期设置为STARTED,生命周期回退到onPause
                mCurTransaction.setMaxLifecycle(mCurrentPrimaryItem, Lifecycle.State.STARTED);
            } else {
				//可见性设置为false
                mCurrentPrimaryItem.setUserVisibleHint(false);
		//将要显示的Fragment
        fragment.setMenuVisibility(true);
        if (mBehavior == BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT) {
            if (mCurTransaction == null) {
                mCurTransaction = mFragmentManager.beginTransaction();
			//最大生命周期设置为RESUMED
            mCurTransaction.setMaxLifecycle(fragment, Lifecycle.State.RESUMED);
        } else {
			//可见性设置为true
            fragment.setUserVisibleHint(true);
        mCurrentPrimaryItem = fragment;
代码比较简单很好理解
当mBehavior设置为BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT会通过setMaxLifecycle来修改当前Fragment和将要显示的Fragment的状态，使得只有正在显示的Fragment执行到onResume()方法，其他Fragment只会执行到onStart()方法，并且当Fragment切换到不显示状态时触发onpause()方法。
当mBehavior设置为BEHAVIOR_SET_USER_VISIBLE_HINT时，会当frament可见性发生变化时调用setUserVisibleHint()，也就是跟我们上面提到的第一种懒加载实现方式一样。
到这里懒加载的实现基本就清晰了，我们只需要在onResume()中处理需要延时加载的逻辑，并在onPause()中做相应的释放就可以了。