Android-Lifecycle原理

Lifecycle的用途

MVP中，Presenter经常需要感知V(Activity/Fragment)的生命周期，在相应的生命周期回调中做一些操作，比如在onDestory取消网络请求等。一般的套路是，在Activity的基类中持有Presenter的基类，重写Activity的生命周期回调方法，并在这些回调中调用Presenter的相应生命周期方法。但有些组件可能传入的参数是Activity，无法传入一个预定义的类在Activity相应的生命周期中调用。因此，support(或者说AndroidX)提供了Lifecycle组件，用于在向一个Activity/Fragment注册生命周期回调监听。这种基于观察者模式的组件无需重写Activity的生命周期回调方法(其实也是Activity基类中重写的)，而且Lifecycle没有持有Activity的引用，不会导致内存泄露。

Lifecycle框架关键类

• LifecycleOwner：生命周期的拥有者，一般是Activity和Fragment实现这个接口，只有一个方法getLifecycle():Lifecycle
• Lifecycle:表示一个生命周期过程对象，可以添加生命周期观察者
• Lifecycle.State:生命周期枚举，有DESTROYED、INITIALIZED、CREATED、STARTED、RESUMED
• LifecycleRegistry:Lifecycle的子类，对Lifecycle中的抽象方法进行了实现
• LifecycleObserver:生命周期观察者，虽是个空接口，但可以通过Lifecycle的注解定义所有的生命周期方法
• Lifecycle.Event:生命周期事件，和Activity/Fragment的相应生命周期回调一一对应，有ON_CREATE、ON_START、ON_RESUME、ON_PAUSE、ON_STOP、ON_DESTROY、ON_ANY七种取值，一般和OnLifecycleEvent注解一起使用，用来在LifecycleObserver中标注方法属于哪个生命周期

Lifecycle最简Demo

一个普通类实现LifecycleObserver接口，并添加相应的生命周期回调方法

class DemoLifecycleObserver: LifecycleObserver {
            @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
            fun onCreate(owner: LifecycleOwner) {
                Log.d(TAG, "owner-$owner onCreate")
            }

            @OnLifecycleEvent(Lifecycle.Event.ON_START)
            fun onStart(owner: LifecycleOwner) {
                Log.d(TAG, "owner-$owner onStart")
            }

            @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
            fun onResume(owner: LifecycleOwner) {
                Log.d(TAG, "owner-$owner onResume")
            }

            @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
            fun onPause(owner: LifecycleOwner) {
                Log.d(TAG, "owner-$owner onPause")
            }

            @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
            fun onStop(owner: LifecycleOwner) {
                Log.d(TAG, "owner-$owner onStop")
            }

            @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
            fun onDestroy(owner: LifecycleOwner) {
                Log.d(TAG, "owner-$owner onDestroy")
            }

            @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
            fun onAny(owner: LifecycleOwner) {
                Log.d(TAG, "owner-$owner onAny")
            }
        }

在Activity/Fragment的onCreate中注册生命周期

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        ......
        lifecycle.addObserver(DemoLifecycleObserver())
    }

打印输出为

2020-07-25 17:11:03.948 3558-3558/com.benson.android.study D/MainActivity: owner-com.benson.android.study.MainActivity@223b4c0 onCreate
2020-07-25 17:11:03.948 3558-3558/com.benson.android.study D/MainActivity: owner-com.benson.android.study.MainActivity@223b4c0 onAny
2020-07-25 17:11:03.949 3558-3558/com.benson.android.study D/MainActivity: owner-com.benson.android.study.MainActivity@223b4c0 onStart
2020-07-25 17:11:03.949 3558-3558/com.benson.android.study D/MainActivity: owner-com.benson.android.study.MainActivity@223b4c0 onAny
2020-07-25 17:11:03.950 3558-3558/com.benson.android.study D/MainActivity: owner-com.benson.android.study.MainActivity@223b4c0 onResume
2020-07-25 17:11:03.950 3558-3558/com.benson.android.study D/MainActivity: owner-com.benson.android.study.MainActivity@223b4c0 onAny
2020-07-25 17:12:52.703 3558-3558/com.benson.android.study D/MainActivity: owner-com.benson.android.study.MainActivity@223b4c0 onPause
2020-07-25 17:12:52.703 3558-3558/com.benson.android.study D/MainActivity: owner-com.benson.android.study.MainActivity@223b4c0 onAny
2020-07-25 17:12:52.939 3558-3558/com.benson.android.study D/MainActivity: owner-com.benson.android.study.MainActivity@223b4c0 onStop
2020-07-25 17:12:52.939 3558-3558/com.benson.android.study D/MainActivity: owner-com.benson.android.study.MainActivity@223b4c0 onAny
2020-07-25 17:12:52.940 3558-3558/com.benson.android.study D/MainActivity: owner-com.benson.android.study.MainActivity@223b4c0 onDestroy
2020-07-25 17:12:52.940 3558-3558/com.benson.android.study D/MainActivity: owner-com.benson.android.study.MainActivity@223b4c0 onAny

源码分析

LifecycleRegistry的addObserver的实现

@Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

        if (previous != null) {
            return;
        }
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            // it is null we should be destroyed. Fallback quickly
            return;
        }

        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
        State targetState = calculateTargetState(observer);
        mAddingObserverCounter++;
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
            pushParentState(statefulObserver.mState);
            statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
            popParentState();
            // mState / subling may have been changed recalculate
            targetState = calculateTargetState(observer);
        }

        if (!isReentrance) {
            // we do sync only on the top level.
            sync();
        }
        mAddingObserverCounter--;
    }

如果当前状态不是DESTROY的话，就将observer的状态标记为INITIALIZED，如果被添加的observer已经被add过了，就直接return了。LifecycleRegistry中使用mLifecycleOwner来持有LifecycleOwner对象，可前面的分析可知LifecycleOwner其实就是Activity/Fragment，而mLifecycleOwner是一个WeakReference，这就避免了内存泄漏。这里用ObserverWithState封装了一下LifecycleObserver，让LifecycleObserver也有维护着自己的生命周期状态，这是因为，如果Oberser是在Activiyt/Fragment的onStart中被add，那么Observer应该要执行onCreate再执行onStart，这被有些人称之为倒灌，当时在做代码迁移的时候，就被这人坑了一道。calculateTargetState是计算LifecycleRegistry、ParentStates和前一个LifecycleObserver的生命周期状态的最小值，其实也就是上一次生命周期同步所达到的位置，将刚被add的LifecycleObserver的生命周期State同步到这个值来。这里涉及到一个parentState的概念，这是为了防止在LifecycleObserver的生命周期中将自己给remove了，并且add一个新的LifecycleObserver，这个执行生命周期的LifecycleObserver达到的状态就是parentState。在while中一起调用statefulObserver的dispatchEvent方法，就是将刚add的LifecycleObserver的生命周期状态进行同步。

看一下ObserverWithState的dispatchEvent的实现

void dispatchEvent(LifecycleOwner owner, Event event) {
            State newState = getStateAfter(event);
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }

比较简单，就是获取当前状态的下一个状态，比较当前状态和下一个状态，取较小值，将当前状态设置成这个较小值，然后执行LifecycleEventObserver的onStateChanged方法，这里是再把LifecycleObserver封装了一层，用onStateChange去执行LifecycleObserver的生命周期方法。

一般实现LifecycleObserver接口的监听器，都是用的反射来生成LifeccyleObserver的封装对象，但也可以用lifecycle的compiler注解处理器，会为每个LifecycleObserver类生成一个LifecycleAdapter，包名与我们实现的LifecycleObserver一样，类名为XXX_LifecycleAdapter，其中XXX前缀就是我们LifecycleObserver实现类的名字。反射的LifecycleEventObserver是ReflectiveGenericLifecycleObserver，在构造器中对mInfo进行了初始化，也是用反射去收集LifecycleObserver实现类中被OnLifecycleEvent注解标记的方法。ReflectiveGenericLifecycleObserver的onStateChanged方法中调用了mInfo.invokeCallbacks方法，ClassesInfoCache方法的invokeCallbacks的实现就是反射调用相应生命周期事件的，同时调用ON_ANY的的方法，使用注解处理器生成的用的是SingleGeneratedAdapterObserver，在其onStateChanged方法中，同样是调用了相应生命周期的方法，同时也调用ON_ANY的方法。

Activity对Lifecycle的生命周期分发是使用了一个桩Fragment，而每个Fragment中持有了一个mChildFragmentManager，FragmentManagerImpl会调用Fragment的perform生命周期方法，这样会分发子Fragment的生命周期，而Activity的Fragment会由Activity中持有的FragmentManagerImpl来调用Fragment的perform生命周期方法。这些Fragment的perform生命周期方法中，就调用了LifecycleRegistry#handleLifecycleEvent，通过这个FragmentManagerImpl来分发生命周期。在CompponentActivity的onCreate方法中，调用了ReportFragment折静态方法injectIfNeededIn，判断当前Activity如果没有一个tag为androidx.lifecycle.LifecycleDispatcher.report_fragment_tag的Fragment就add进去，这样这个ReportFragment就可以获取到Activity的生命周期了。可以看到ReportFragment的第个生命周期回调方法中都调用了dispatch方法，传入的是Lifecycle.Event的值。dispatch的实现如下

private void dispatch(Lifecycle.Event event) {
        Activity activity = getActivity();
        if (activity instanceof LifecycleRegistryOwner) {
            ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
            return;
        }

        if (activity instanceof LifecycleOwner) {
            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
            if (lifecycle instanceof LifecycleRegistry) {
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }

比较简单，就是获取ReportFragent的activity，强转成LifecycleOwner，再获取其LifecycleRegistry对象，调用其handleLifecycleEvent。LifecycleRegistry#handleLifecycleEvent的实现也比较简单，获取下一个状态对象，然后调用moveToState将当前状态转化为下一个状态。这里的moveToState过程跟LifecycleObserver初始化的moveToState的过程也比较类似，都是比较最新状态和Observer列表中的最后一个Observer的状态，如果大于了，就遍历所有的Observer，将其状态同步到LifecycycleRegistry的当前状态，否则回退状态。状态前进和状态回退都遵循着CREATE-DESTROY、START-STOP、RESUME-PAUSE的对应规则。

总结

Lifecycle的原理比较简单，调用过程也比较简单。但使用时需要注意以下几点

• Lifecycle有状态倒灌过程，也就是在任意生命周期中注册LifecycleObserver，这个LifecycleObserver会把前面的生命周期回调都执行一遍，直到和注册时的生命周期状态同步。
• 在Activity/Fragment重写生命周期方法时，必须调用父类的相应方法，因为Lifecycle的生命周期分发在父类的相应生命周期方法中
• LifecycleObserver是使用的一个Map来存的，虽然LifecycleObserver是Map的Key，但其实也是当成一个List<Pair<LifecycleObserver,xxx>>来存在的，也就是说从根本上来说还是一个List，但同一个Observer只能存一份，如果一个LifecycleObserver被add了两次，那么生命周期方法也只会回调一次。