Jetpack之Lifecycle源码

Android Jetpack 组件是库的集合，这些库是为协同工作而构建的，不过也可以单独采用，同时利用 Kotlin语言功能帮助您提高工作效率。可全部使用，也可混合搭配！

JetPack组件.png

1.什么是 Lifecycle？：它是可以感知 Activity、 Fragment 的生命周期，并将变化通知到已注册的观察者。让代码符合生命周期规范，有效的避免了内存泄漏等问题。

2.基本使用：被动的通知 View层生命周期变化让逻辑层拥有 LifecycleOwner对象，因为view层实现了 LifecycleOwner接口，所以可以在view层初始化的时候，直接赋值，有了 LifecycleOwner对象，就可以通过 getLifecycle方法获取到 Lifecycle对象了（附图片）。

image.png

3. Lifecycle有4个比较重要的类： LifecycleOwner， LifecycleObserver、 Lifecycle 和 LifecycleRegistry。

3.1 LifecycleOwner，它是一个接口，我们现在用的 Androidx包下的 AppcompatActivty和 Fragment都默认实现了 LifecycleOwner这个接口，这个接口提供了 getLifecycle() 方法来获取其 Lifecycle 对象。
也就是上面说的直接在 Activity添加 addObserver(new CustomObserver())就能感知 Activity生命周期了。

可以看到LifecycleOwner源码.png

3.2 LifecycleObserver，它是一个空的接口，这个接口只是来标志这个是对Lifecycle的观察者，内部没有任何方法，全部都依赖于OnLifecycleEvent注解

四个类之间的关系 .png

3.3 Lifecycle，它是一个抽象的类，定义了2个枚举类Event和State，addObserver和removeObserver方法。

image.png

3.4 LifecycleRegistry：它是 Lifecycle 的唯一实现类。主要用来注册观察者（ LifecycleObserver），以及分发宿主状态给它们（可以处理多个观察者）

上面简单看了下四个类的源码。真正的源码如下所示
在看源码之前，，我们可能产生几个疑问

• Lifecycle是怎样感知生命周期的？
• Lifecycle是如何处理生命周期的？
• LifecycleObserver的方法是怎么回调的呢？
• 为什么LifecycleObserver可以感知到Activity的生命周期？

源码解析（以LifeCycleActivity.class为例)：

image.png
上图中1标注的我们拆分成2步：getLifecycle()和addObserver()
①先看getLifecycle():它是ComponentActivity里面的
image.png
mLifecycleRegistry 是 LifecycleRegistry 对象，LifecycleRegistry 是 LifeCycle 的子类；

②addObserver()

image.png
上面代码可看出，addObserver()干了以下几件事：
1、可以添加多个观察者，这时候需要维护他们的状态，每次添加新的观察者的初始状态是INITIALIZED；
2、然后把LifecycleObserver包装成ObserverWithState；
3、把Observer添加到map集合中。
观察者已经添加完成了，那么如何将生命周期的变化通知观察者呢？
再会到ComponentActivity中，仔细看下ComponentActivity的onCreate()方法有一个
ReportFragment.injectIfNeededIn(this);
它初始化了一个ReportFragment，仔细看下ReportFragment源码可知，它是向Activity添加了一个没有页面的Fragment，并且ReportFragment中的各个生命周期都调用了dispatch(Lifecycle.Event event) 方法，
它里面的参数就是传递了不同的Event值，再仔细看dispatch里面干了2件事：
（1）如果Activity实现了LifecycleRegistryOwner接口的话，就调用LifecycleRegistryOwner的handleLifecycleEvent的方法；
（2）如果Activity实现了LifecycleOwner接口的话，就调用LifecycleRegistry的handleLifecycleEvent的方法；
经过我们上面的介绍，Activity是实现了LifecycleOwner的接口，所以会执行LifecycleRegistry的handleLifecycleEvent的方法。

看到这里我们可以回答第4中的前2个问题了。

接下来看下handleLifecycleEvent方法

 public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    State next = getStateAfter(event);
    moveToState(next);
}

1.首先根据需要分发的事件，获取宿主当前处于什么状态

假设分发的是 ON_START 事件，那么根据 getStateAfter() 方法我们可以知道，宿主当前是处于STARTED 状态。

 static State getStateAfter(Event event) {
    switch (event) {
        case ON_CREATE:
        case ON_STOP:
            return CREATED;
        case ON_START:
        case ON_PAUSE:
            return STARTED;
        case ON_RESUME:
            return RESUMED;
        case ON_DESTROY:
            return DESTROYED;
        case ON_ANY:
            break;
    }

2.根据第一步获取的宿主状态设置当前的状态并通知观察者

private void moveToState(State next) {
    if (mState == next) {
        return;
    }
    //设置当前状态
    mState = next;

    ...

    //通知观察者
    sync();
}

下面来看一下 sync方法：

 private void sync() {

    while (!isSynced()) {

    //如果宿主当前的状态 小于 mObserverMap 集合中最先添加的那个观察者的状态
    //则说明宿主可能发生了状态回退，比如当前是 RESUMED 状态，执行了onPause 则回退到STARTED 状态
    //此时调用 backwardPass 给集合中的每个一观察者分发一个 on_pause 事件，并同步它的状态。
    if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
        backwardPass(lifecycleOwner);
    }

    //如果宿主当前状态 大于 mObserverMap 集合中最先添加的那个观察者的状态
    //则说明宿主可能发生了状态前进，比如当前是 STARTED 状态，执行了onResume 则前进到RESUMED 状态
    //此时调用 forwardPass 给集合中的每个一观察者分发一个 on_resume 事件，并同步它的状态。
    Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
    if (!mNewEventOccurred && newest != null
            && mState.compareTo(newest.getValue().mState) > 0) {
        forwardPass(lifecycleOwner);
    }
}
mNewEventOccurred = false;

}

ObserverWithState源码分析
ObserverWithState 是LifecycleRegistry中持有观察者及其状态的内部类。

static class ObserverWithState {
     State mState;
     LifecycleEventObserver mLifecycleObserver;

     //把传入的 LifecycleObserver 适配成 LifecycleEventObserver，目的是为了统一事件的分发形式。
    //在之前的文章里介绍过实现观察者有三种形式，每一种接收的事件类型都不一样，如果在分发的时候不统一事件分发的形式，将会变得很麻烦
   ObserverWithState(LifecycleObserver observer, State initialState) {
       mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
       mState = initialState;
}

void dispatchEvent(LifecycleOwner owner, Event event) {
    State newState = getStateAfter(event);
    mState = min(mState, newState);
    //执行事件分发
    mLifecycleObserver.onStateChanged(owner, event);
    mState = newState;
}

至此LifeCycle源码讲解完成，希望能大家有帮助，谢谢