1. 使用

官方文档

使用生命周期感知型组件处理生命周期
简单使用


class LifeCycleActivity : AppCompatActivity() {
    private var lifecyclePresenter: LifecyclePresenter? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_life_cycle)

        lifecyclePresenter = LifecyclePresenter()
                .apply {
                    lifecycle.addObserver(this)
                }
    }
}

// 自定义Presenter 实现 LifecycleObserver 接口
public class LifecyclePresenter implements LifecycleObserver {

    public LifecyclePresenter() {}

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreate(LifecycleOwner owner) {
        log("ON_CREATE");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onStart(LifecycleOwner owner) {
        log("ON_START");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResume(LifecycleOwner owner) {
        log("ON_RESUME");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void onPause(LifecycleOwner owner) {
        log("ON_PAUSE");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStop(LifecycleOwner owner) {
        log("ON_STOP");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy(LifecycleOwner owner) {
        log("ON_DESTROY");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    public void onAny(LifecycleOwner owner) {
        log("ON_ANY");
    }

    private void log(String s) {
        String tag = "LifecycleTest";
        Log.d(tag, s);
    }
}

使用步骤

实现 LifecycleObserver 接口, 这里对应 LifecyclePresenter, 因为通常业务上来讲 Presenter 会需要监听 Activity 生命周期的变化，以进行资源的加载或释放
LifecyclePresenter 内编写方法，方法名称任意，用@OnLifecycleEvent注解标注
在需要监听的 Activity 内通过 getLifecycle.addObserver(Lifecycle lifcycle) 实现关系绑定

2. 原理

实现原理这块主要分为两个部分分析

订阅

事件的分发

2.1 订阅部分

上述代码之所以可以实现监听 acitivity 生命周期的功能，主要基于观察者模式构建，这里的观察者和被观察者的关系如下

被观察者 - Lifecycle （对应 activity）
观察者 - LifecycleObserver（对应 presenter）

简单粗暴地理解的话，上述使用过程可以简化为：

Lifecycle.addObserver(LifecycleObserver) 
就是
activity.addObserver(presenter)

2.1.1 设计原型

ComponentActivity 部分

实现了 LifecycleOwner 接口满足生命周期所有者这个角色，通过getLifecycle() 返回对应接口引用，隐藏实现细节。

通过 LifecycleRegistry 管理所有订阅者，降低耦合度

LifecycleRegistry部分

扩展 Lifecycle，担任生命周期管理者的角色

实现了订阅/取消订阅的细节

使用 mObserverMap 保存订阅事件的观察者，对订阅者集合进行统一管理

一句话总结: lifecycle.addObserver(new LifecyclePresenter()) 就是：先拿到 ComponentActivity 的成员 mLifecycleRegistry 的，进而往 mLifecycleRegistry 的成员 map 中添加/移除观察者，从而将观察者添加至被观察者内部维护的序列中，当被观察者发生相应事件时，遍历该序列，轮流进行通知就可以了

PS: 所以只有继承自 AppCompatActivity 的 activity 才可以直接以上述的方式使用，否则需要自行实现相应订阅与事件分发逻辑。

2.1.2 源码跟读

基于 LifecyclePresenter 中生命周期回调的方法需要结合注解，不难想到是通过反射实现的，既然如此，那么一定根据对应注解对被注解方法进行了解析并缓存，时机只有一个：那就是 addObserver() 发生订阅关系时，因为只有这时，将 LifecyclePresenter 的实例传给了 Lifecycle 的实现对象，也就是我们的 activity

第一步：回到事件订阅的源码处，发现对传入的 observer 进行了二次包装，构造成了一个 ObserverWithState 对象

public class LifecycleRegistry extends Lifecycle {

    /* ...省略无关代码 */

    @Override
    public void addObserver(@NonNull LifecycleObserver observer ) {
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        
        // 这里对传入的 observer 进行了二次包装
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

        // ... 省略代码
        
        // 同步状态，举个栗子：
        // 假如在 onResmue 后订阅，初始化状态是INITIALIZED ，在订阅时，需要将当前状态同步至 onResume 对应的状态，这里无需关心
        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);
        }
    }     
    
}

第二步：继续追进去，发现 ObserverWithState 是 LifecycleRegistry 的一个内部类，结构如下

static class ObserverWithState {
    State mState;
    LifecycleEventObserver mLifecycleObserver;

    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;
    }
}

第三步：发现构造过程中，又将传入的 observer 包装成了一个 LifecycleEventObserver 对象，再看下 Lifecycling.lifecycleEventObserver(observer) 做了什么。


@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP_PREFIX)
public class Lifecycling {

    // type 可能的值
    private static final int REFLECTIVE_CALLBACK = 1;
    private static final int GENERATED_CALLBACK = 2;

    private static Map<Class<?>, Integer> sCallbackCache = new HashMap<>();
    private static Map<Class<?>, List<Constructor<? extends GeneratedAdapter>>> sClassToAdapters =
            new HashMap<>();
            
    @NonNull
    static LifecycleEventObserver lifecycleEventObserver(Object object) {
        
        // ... 省略代码
        final Class<?> klass = object.getClass();
        int type = getObserverConstructorType(klass);
        if (type == GENERATED_CALLBACK) {
            List<Constructor<? extends GeneratedAdapter>> constructors =
                    sClassToAdapters.get(klass);
            if (constructors.size() == 1) {
                // 通过反射，创建生成的适配器实例
                GeneratedAdapter generatedAdapter = createGeneratedAdapter(
                        constructors.get(0), object);
                return new SingleGeneratedAdapterObserver(generatedAdapter);
            }
            GeneratedAdapter[] adapters = new GeneratedAdapter[constructors.size()];
            for (int i = 0; i < constructors.size(); i++) {
                adapters[i] = createGeneratedAdapter(constructors.get(i), object);
            }
            return new CompositeGeneratedAdaptersObserver(adapters);
        }
        return new ReflectiveGenericLifecycleObserver(object);
    }
}

这里重点在于，根据 type 分为两个分支分别构造实例并返回，所以重点一定在 getObserverConstructorType(klass) 处对 type 的获取。

这里直接上结论：

Lifecycling 类有几个重要成员
- REFLECTIVE_CALLBACK = 1
- GENERATED_CALLBACK = 2
- sCallbackCache // Map 类型
- sClassToAdapters // Map 类型
源码会对不同的实现方式，进行区别处理，对于上述 LifecyclePresenter 直接实现 LifecycleObserver 接口这种方式，getObserverConstructorType(klass) 会返回 type = GENERATED_CALLBACK == 2
对于 type = GENERATED_CALLBACK == 2 的情况，会通过APT在编译阶段，在 build 目录下同（包名）路径下生成一个实现了 GeneratedAdapter 接口的适配器类，如上述 LifecyclePresenter 的包名为：com.view.jetpack.lifecycle，则生成的适配器类：
同时， getObserverConstructorType(klass) 方法会在获取到正确type的同时，将生成的这个适配器类的相关信息（如在build目录下的全路径，以及类名）缓存在 sClassToAdapters 成员中
通过反射构造出生成的适配器类
实例化一个 SingleGeneratedAdapterObserver 包装这个 适配器类，这样SingleGeneratedAdapterObserver 就可以代理适配器类的功能了

看一下 SingleGeneratedAdapterObserver 的具体实现

class SingleGeneratedAdapterObserver implements LifecycleEventObserver {

    private final GeneratedAdapter mGeneratedAdapter;

    SingleGeneratedAdapterObserver(GeneratedAdapter generatedAdapter) {
        mGeneratedAdapter = generatedAdapter;
    }

    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
        mGeneratedAdapter.callMethods(source, event, false, null);
        mGeneratedAdapter.callMethods(source, event, true, null);
    }
}

onStateChanged() 方法会在生命周期变化时被回调，具体下边再分析。这里可以清楚看到，最终还是调用的生成的适配器类的相关方法。

2.2 事件的分发

生命周期变化事件分发过程主要是基于一个状态机模型实现的，官方文档给出的原理图如下：

图中一共有三个关键元素：

States：当前（activity）的状态
Events: 被分发的事件
方向：状态机事件的流动方向

总结来说：主要基于当前 State 和新到来的 Event 驱动，又因为 activity 生命周期回调函数的对称性，这里只声明了 CRETED,STARTED,RESMUED 几个变量进行了优化，具体回调函数，可以通过状态变化的方向得到，如：CRETED->STARTED 则回调 onStart， STARTED->CRETED则回调onStop 具体栗子如下：

当前观察者处于 State.INITIALIZED 状态
状态机收到 Event.ON_CREATE 事件
回调观察者上 @OnLifecycleEvent(Lifecycle.Event.ON_CREATE) 的方法
将观察者当前状态调整为：State.CREATED

State 和 Event 代码上体现为 Lifecycle 的内部枚举类，如下：

public abstract class Lifecycle {
    public enum Event {
        ON_CREATE,
        ON_START,
        ON_RESUME,
        ON_PAUSE,
        ON_STOP,
        ON_DESTROY,
        ON_ANY
    }
    public enum State {
        DESTROYED,
        INITIALIZED,
        CREATED,
        STARTED,
        RESUMED;
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }
}

运作关系上体现为（onCreate为例）：

2.2.1 代码原理

第一部分： Activity 将生命周期变化通知到订阅者，那么一定是在生命周期回调函数处做了一些事情，对相关父类生命周期函数依次查看后，发现 ComponentActivity 的 onCreate()，效仿 Glide 创建了一个无界面的 Fragment，用于感知 activity 生命周期的变化

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    // ... 省略其他代码
    // 这里效仿 Glide 创建了一个无界面的 Fragment， 用于感知 activity 生命周期的变化
    ReportFragment.injectIfNeededIn(this);
}

第二部分： 来到 ReportFragment 以 onActivityCreated() 为例进行分析：当 activity 的 onCreate() 方法执行后，首先会回调到 ReportFragment 的 onActivityCreated() 方法上，进而会调用到 LifecycleRegistry.handleLifecycleEvent(event) 如下

@Override
public void onActivityCreated(Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);
    // 管理整个应用进程的生命周期相关，这里先不用管
    dispatchCreate(mProcessListener);
    // 分发事件 Event.ON_CREATE
    dispatch(Lifecycle.Event.ON_CREATE);
}

static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
    if (activity instanceof LifecycleRegistryOwner) {
        ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
        return;
    }

    // 因为 ComponentActivity 实现的是 LifecycleOwner 接口
    if (activity instanceof LifecycleOwner) {
        // 最终走的这里
        Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
        if (lifecycle instanceof LifecycleRegistry) {
            // 分发具体事件
            ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
        }
    }
}

第三部分： 从订阅部分的分析，可得知这里的 getLifecycle 得到的就是 ComponentActivity 中的 LifecycleRegistry对象，所以一定可以转型成功，再来到 LifecycleRegistry 的 handleLifecycleEvent()

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

第四步： 这里有两个重点

获取状态getStateAfter(event),也就是通过事件（Event），获取状态(State)
切换到对应状态 moveToState(next) 先看 getStateAfter(event), 这里传入的是 Event.ON_CREATE 所以会得到 State.CREATED :

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;
    }
    throw new IllegalArgumentException("Unexpected event value " + event);
}

然后继续看状态的切换 -> moveToState(next)，一共完成了两件事

LifecycleRegistry 状态的切换

生命周期改变事件的分发

private void moveToState(State next) {
    if (mState == next) {
        return;
    }
    
    // 这里先完成了状态的同步/更新, 下边 sync() 会用到
    // mState 是 LifecycleRegistry 内的一个成员变 
    mState = next;
    if (mHandlingEvent || mAddingObserverCounter != 0) {
        mNewEventOccurred = true;
        // we will figure out what to do on upper level.
        return;
    }
    mHandlingEvent = true;
    
    // 这里完成了生命周期事件的分发
    sync();
    mHandlingEvent = false;
}


private void sync() {
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    if (lifecycleOwner == null) {
        throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
                + "garbage collected. It is too late to change lifecycle state.");
    }
    
    // 遍历所有订阅者，进行事件分发
    while (!isSynced()) {
        mNewEventOccurred = false;
        
        // 逆向推进状态机状态，进而分发生命周期改变事件
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            backwardPass(lifecycleOwner);
        }
        
        Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        // 正向推进状态机状态，进而分发生命周期改变事件
        if (!mNewEventOccurred && newest != null
                && mState.compareTo(newest.getValue().mState) > 0) {
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}

// 事件是否分发完毕， 可以这么理解：
// mObserverMap.eldest() 返回 Map 中的第一个加入的对象
// mObserverMap.newest() 返回 Map 中的最后一个被加入的对象
// 所以 eldestObserverState == newestObserverState 代表当前事件已经分发给所有订阅者了
private boolean isSynced() {
    if (mObserverMap.size() == 0) {
        return true;
    }
    State eldestObserverState = mObserverMap.eldest().getValue().mState;
    State newestObserverState = mObserverMap.newest().getValue().mState;
    return eldestObserverState == newestObserverState && mState == newestObserverState;
}

这里的核心主要体现在 backwardPass() 和 forwardPass 两个方法上

PS:

mState 为 LifecycleRegistry 内 Lifecycle.State 类型的成员变量，所以为枚举类型

枚举类型默认情况下 compareTo() 返回结果由声明顺序决定，假设有两个变量 A 和 B，先声明A，后声明B的情况下：A.compareTo(B) 时返回 -1。反之返回1, 即：返回声明时的前后顺序

mObserverMap 中存放了所有订阅者，这些订阅者上都保存了收到上一次事件时的状态

所以，假设在当前轮遍历过程中，当前订阅者状态为 Lifecycle.State.INITIALIZED，那么运作过程为：

因为moveToState() 中，mState 已经被同步为了 Lifecycle.State.CREATED
(compareTo() == 1) > 0
执行 forwardPass 进行事件分发,在状态机上体现为：
继续下一轮遍历

PS: backwardPass() 和 forwardPass 原理相似，不再分析

第五步： 事件具体是如何分发的呢？再看 forwardPass

private void forwardPass(LifecycleOwner lifecycleOwner) {
    Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
            mObserverMap.iteratorWithAdditions();
    while (ascendingIterator.hasNext() && !mNewEventOccurred) {
        Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
        // 最终接受事件的对象
        ObserverWithState observer = entry.getValue();
        while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                && mObserverMap.contains(entry.getKey()))) {
            // 同步状态
            pushParentState(observer.mState);
            // 分发事件
            observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
            popParentState();
        }
    }
}

到这里就一切明晰了，ObserverWithState 就是前边分析订阅部分时构造的包装者，为了方便看，直接在拷一份，贴下边：


static class ObserverWithState {
    State mState;
    LifecycleEventObserver mLifecycleObserver;

    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;
    }
}

这里又嵌套一层，也就是之前反射构建的 SingleGeneratedAdapterObserver, 所以最终会调用到 SingleGeneratedAdapterObserver 的 onStateChanged(owner, event) 方法上，再贴一份看一下

class SingleGeneratedAdapterObserver implements LifecycleEventObserver {
 
    private final GeneratedAdapter mGeneratedAdapter;

    // 传入了APT生成的适配器类实例
    SingleGeneratedAdapterObserver(GeneratedAdapter generatedAdapter) {
        mGeneratedAdapter = generatedAdapter;
    }

    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
        mGeneratedAdapter.callMethods(source, event, false, null);
        mGeneratedAdapter.callMethods(source, event, true, null);
    }
}

还记得 SingleGeneratedAdapterObserver 构造函数的实参吗？其实就是通过反射创建的APT生成的适配器类实例，所以最终看一下这个适配器类的 callMethods() 即可。对应之前的使用例子，生成的适配器类代码如下：

public class LifecyclePresenter_LifecycleAdapter implements GeneratedAdapter {
  final LifecyclePresenter mReceiver;
  
  LifecyclePresenter_LifecycleAdapter(LifecyclePresenter receiver) {
    this.mReceiver = receiver;
  }

  @Override
  public void callMethods(LifecycleOwner owner, Lifecycle.Event event, boolean onAny, MethodCallsLogger logger) {
    boolean hasLogger = logger != null;
    if (onAny) {
      if (!hasLogger || logger.approveCall("onAny", 2)) {
        mReceiver.onAny(owner);
      }
      return;
    }
    if (event == Lifecycle.Event.ON_CREATE) {
      if (!hasLogger || logger.approveCall("onCreate", 2)) {
        mReceiver.onCreate(owner);
      }
      return;
    }
    if (event == Lifecycle.Event.ON_START) {
      if (!hasLogger || logger.approveCall("onStart", 2)) {
        mReceiver.onStart(owner);
      }
      return;
    }
    // ... 省略类似代码
  }
}

其实重点就在于构造函数实例化的 receiver, 结合订阅部分的逻辑，这里的 receiver 其实就是最初在 LifeCycleActivity 内 addObsever 时传入的 LifecyclePresenter 实例。所以最终根据到来的 Lifecycle.Event 回调到 LifecyclePresenter 内被相应注解所标注的方法上即可，至此，Lifecycle 关于生命周期事件的分发就分析完毕了。

关于其中涉及的数据结构，推荐这篇：

Android架构组件（2）LifecycleRegistry 源码分析

Android Lifecycle源码阅读