1、概述

Lifecycle是一个抽象类，内部定义了两个枚举类型Event和State，前者表示生命周期事件，后者表示生命周期状态。
LifecycleRegistry是Lifecycle的唯一实现类，负责添加和移除observer、生命周期状态事件的分发处理等具体逻辑的实现
LifecycleObserver是一个标志接口，它有两个子类接口(即两种接收生命周期的方式)：LifecycleEventObserver和DefaultLifecycleObserver，前者只有一个onStateChanged方法，所有生命周期都会回调该方法，传入Lifecycle.Event来表示处于哪个生命周期；后者有六个生命周期方法，对应activity的生命周期，在各个生命周期中会回调对应方法
LifecycleOwner是一个接口，里面仅有一个getLifecycle方法，负责返回Lifecycle对象
ComponentActivity实现了LifecycleOwner接口，在ComponentActivity中创建并持有一个LifecycleRegistry对象，getLifecycle方法在这里的实现就是返回LifecycleRegistry对象
LifecycleObserver不是直接监听activity的生命周期，在ComponentActivity的onCreate方法中会注入一个ReportFragment，该类继承于Fragment，是一个没有视图的空fragment，专门负责将生命周期事件发送给LifecycleRegistry，所以LifecycleObserver实际上监听的是这个fragment的生命周期
lifecycle的生命周期事件通知具有粘性特性，即addObserver后会接收到当前生命周期及之前的生命周期事件。比如在activity的onResume中给lifecycle添加LifecycleEventObserver，则onStateChanged会被回调三次，接收到的Event分别为ON_CREATE,ON_START,ON_RESUME；如果添加的是DefaultLifecycleObserver，则onCreate、onStart、onResume三个方法会被回调
lifecycle基本工作流程：1、监听生命周期：activity走到一个生命周期，其注入的ReportFragment也会走到对应的生命周期，在fragment的生命周期方法中会调用dispatch方法，在该方法中会调用activity的lifecycle的handleLifecycleEvent方法。2、分发生命周期：lifecycle通过handleLifecycleEvent方法收到新生命周期事件后，会处理从当前生命周期行进到新生命周期的逻辑，处理完毕后就遍历observerMap，将生命周期事件通知给所有注册的观察者。

2、问题

1. Lifecycle.State应该是与Event对应的，那为什么没有PAUSED和STOPED这两种状态，是如何表示onPause和onStop生命周期的

附一张图：

没有PAUSED和STOPED是因为不需要这两种状态即可表示onPause和onStop。LifecycleRegistry中会记录当前所处的生命周期状态，当收到一个新的状态时，会结合当前状态来判断新状态表示哪个生命周期。比如收到一个新状态CREATED，那么如果当前状态是INITIALIZED（该状态表示activity刚创建并且还未走到onCreate），则表示新到来的生命周期是onCreate；如果当前状态是STARTED，则表示新到来的生命周期是onStop。因此不需要PAUSED和STOPED即可表示onPause和onStop

2. 为什么不直接监听Activity的生命周期，而是要监听ReportFragment的生命周期

为了不增加Activity的负担，或者说不侵入activity。Fragment的生命周期是依附Activity的，可以用Fragment的生命周期来表示Activity的生命周期，所以可以将分发生命周期的代码和逻辑抽离出来放在ReportFragment，由ReportFragment专门负责。这也是在一定程度上遵循单一职责原则。

3. 如果给Lifecycle添加的观察者同时实现了LifecycleEventObserver和DefaultLifecycleObserver方法，会有什么结果，是如何实现的

会先回调DefaultLifecycleObserver中的生命周期方法，后回调LifecycleEventObserver中的onStateChanged方法。

LifecycleRegistry中使用一个map来保存所有添加的“观察者”，但不是直接将我们通过addObserver方法传入的observer（以下称MyObserver）存入map，而是保存的ObserverWithState对象，我们传入的MyObserver会再被传入ObserverWithState中：

override fun addObserver(observer: LifecycleObserver) {
    enforceMainThreadIfNeeded("addObserver")
    val initialState = if (state == State.DESTROYED) State.DESTROYED else State.INITIALIZED
    val statefulObserver = ObserverWithState(observer, initialState)
    val previous = observerMap.putIfAbsent(observer, statefulObserver)
    ...
}

这个ObserverWithState并没有实现任何接口，所以它不是观察者，可以理解为观察者的容器。看下这个类：

internal class ObserverWithState(observer: LifecycleObserver?, initialState: State) {
    var state: State
    var lifecycleObserver: LifecycleEventObserver

    init {
        lifecycleObserver = Lifecycling.lifecycleEventObserver(observer!!)
        state = initialState
    }

    fun dispatchEvent(owner: LifecycleOwner?, event: Event) {
        val newState = event.targetState
        state = min(state, newState)
        lifecycleObserver.onStateChanged(owner!!, event)
        state = newState
    }
}

里面有一个lifecycleObserver变量，是通过Lifecycling.lifecycleEventObserver方法赋值的，将MyObserver传入该方法。看下这个方法：

public fun lifecycleEventObserver(`object`: Any): LifecycleEventObserver {
    val isLifecycleEventObserver = `object` is LifecycleEventObserver
    val isDefaultLifecycleObserver = `object` is DefaultLifecycleObserver
    if (isLifecycleEventObserver && isDefaultLifecycleObserver) {
        return DefaultLifecycleObserverAdapter(
            `object` as DefaultLifecycleObserver,
            `object` as LifecycleEventObserver
        )
    }
    if (isDefaultLifecycleObserver) {
        return DefaultLifecycleObserverAdapter(`object` as DefaultLifecycleObserver, null)
    }
    if (isLifecycleEventObserver) {
        return `object` as LifecycleEventObserver
    }
    ...
}

可以看到这个方法会根据MyObserver的接口实现情况返回不同的类型对象。如果我们的MyObserver把LifecycleEventObserver和DefaultLifecycleObserver两个接口都实现了，则返回DefaultLifecycleObserverAdapter对象；如果只实现了后者，也是返回DefaultLifecycleObserverAdapter对象，但与上者的区别是第二个参数传入的null；如果只实现了前者，则将MyObserver原路返回。看下DefaultLifecycleObserverAdapter类：

internal class DefaultLifecycleObserverAdapter(
    private val defaultLifecycleObserver: DefaultLifecycleObserver,
    private val lifecycleEventObserver: LifecycleEventObserver?
) : LifecycleEventObserver {
    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        when (event) {
            Lifecycle.Event.ON_CREATE -> defaultLifecycleObserver.onCreate(source)
            Lifecycle.Event.ON_START -> defaultLifecycleObserver.onStart(source)
            Lifecycle.Event.ON_RESUME -> defaultLifecycleObserver.onResume(source)
            Lifecycle.Event.ON_PAUSE -> defaultLifecycleObserver.onPause(source)
            Lifecycle.Event.ON_STOP -> defaultLifecycleObserver.onStop(source)
            Lifecycle.Event.ON_DESTROY -> defaultLifecycleObserver.onDestroy(source)
            Lifecycle.Event.ON_ANY ->
                throw IllegalArgumentException("ON_ANY must not been send by anybody")
        }
        lifecycleEventObserver?.onStateChanged(source, event)
    }
}

这个类就相当于一个中转站，它也实现了LifecycleEventObserver接口，Lifecycle收到生命周期事件后实际是调用它的onStateChanged方法，在这里才会再调用我们MyObserver的相应方法。可以看到是先调用的DefaultLifecycleObserver，后调用LifecycleEventObserver。

这个中转站的意义就在于统一观察者的接口，Lifecycle在收到生命周期事件时只需要调用ObserverWithState的dispatchEvent方法即可，否则就要把判断MyObserver的接口实现情况的逻辑放入Lifecycle中了。这里使用的设计模式是代理模式。

对于State事件的处理很复杂，参考Android架构组件（2）LifecycleRegistry 源码分析-CSDN博客