插播一下背景 tips

FragmentActivity extends androidx.activity.ComponentActivity 
androidx.activity.ComponentActivity extends androidx.core.app.ComponentActivity
androidx.core.app.ComponentActivity
复制代码

一、LifecycleRegistry:Lifecycle

• 成员变量 mLifecycleOwner:WeakReference
  • 通过弱引用，来持有与其关联的所有者对象 LifecycleOwner。
• 成员变量 mState:State，用于表示当前状态。
  • State 是一个枚举类。用于表示生命周期的状态。
• 成员变量 mObserverMap:FastSafeIterableMap<LifecycleObserver, ObserverWithState>，持有所有的观察者对象 LifecycleObserver 以及 由该观察者对象而构造的封装对象 ObserverWithState。
  • 当调用 addObserver() 方法添加观察者对象 LifecycleOwner 时，将观察者对象进行封装，然后添加到 map 中。
  • 当调用 removeObserver() 方法移除观察者对象 LifecycleOwner 时，将观察者对象作为key键值，从 map 中查找并移除。
  • 当生命周期发生改变时外部通过调用 LifecycleRegistry.handleLifecycleEvent() 方法，该方法会更新修改当前对象所持有的用于表示当前状态的成员变量 mState:State ，并调用 sync() 方法通知所有观察者。sync() 方法中最终是通过遍历 map 获取到 ObserverWithState 对象，然后调用其 dispatchEvent() 方法来完成生命周期事件分发。

ObserverWithState

• 通过 Lifecycle 添加观察者对象时：LifecycleRegistry.addObserver()： ① 首先会构造一个 ObserverWithState 包装类对象，② 然后以方法参数 LifecycleOwner 对象作为key，以新建的 ObserverWithState 对象作为value，添加到 LifecycleRegistry 的成员变量 mObserverMap 中。
• ObserverWithState 的构造函数，需要接收两个参数。一个是生命周期观察者 observer:LifecycleObserver，一个是生命周期状态 initialState:State。
  • ① 首先根据 LifecycleRegistry.mState 是否处于 DESTROYED 状态，获取到默认的初始状态为 DESTROYED 或者 INITIALIZED。
  • ② 然后将调用该方法时所传进来的参数对象 – 即原始的观察者对象 LifecycleObserver 作为参数，一起传递给 ObserverWithState 的构造函数从而构造一个 ObserverWithState 对象。
• ObserverWithState ，是 LifecycleRegistry 中的一个静态内部类。
  • 该类有两个成员变量。
    • 一个是 mState:State；
    • 一个是 mLifecycleObserver:LifecycleEventObserver（不是原始的观察者对象，而是通过原始的观察者对象转换过后的观察者对象）。
  • 在 ObserverWithState 的构造函数中，会进行以下处理：
    • ① 将参数对象 initialState:State 赋值给 mState 成员变量。
    • ② 将参数对象 observer:LifecycleObserver – 即原始的观察者对象 LifecycleObserver 作为参数，调用 Lifecycling.lifecycleEventObserver(observer) 从而获取到一个 LifecycleEventObserver:LifecycleObserver 对象并赋值给 mLifecycleObserver 变量。

• dispatchEvent() 方法，顾名思义，用于分发生命周期事件，该方法会在生命周期状态更改时，由 LifecycleRegistry:Lifecycle 调用。
• 方法实现：首先会根据参数对象 event:Lifecycle.Event 转换为对应的 State 从而获取当前最新的生命周期状态，然后调用当前对象的成员变量 mLifecycleObserver.onStateChanged() 方法以分发生命周期事件，最后重置当前对象的成员变量 mState 设置为最新的生命周期状态值。

---

二、LifecycleObserver

生命周期观察者

• LifecycleObserver 是一个接口，用于标记当前类是一个生命周期观察者。
• 主要有两个实现类，FullLifecycleObserver、LifecycleEventObserver。
  • DefaultLifecycleObserver : FullLifecycleObserver
• 自定义一个生命周期观察者，可以有三种方式
  • ① 直接继承 DefaultLifecycleObserver 类：按需重写需要的生命周期回调方法 onXXX(LifecycleOwner)，包含有六个生命周期回调方法分别对应六个生命周期事件 Lifecycle.Event.ON_XXX。
  • ② 直接实现 LifecycleEventObserver 接口：实现唯一的回调方法 onStateChanged() ；当生命周期状态发生更改时会回调该方法，根据方法参数 Lifecycle.Event 可获取最新的生命周期事件。
  • ③ 直接实现 LifecycleObserver 接口，标记当前类为生命周期观察者；采用注解的方式，为类中的自定义方法添加注解 @OnLifecycleEvent() ，从而实现回调。
    • 2.4.0 版本之后废弃了@OnLifecycleEvent注解，废弃原因：使用代码生成或者反射的方式来实现，耗性能，应避免使用。
    • 建议：不要直接使用该接口，而是实现 DefaultLifecycleObserver 或 LifecycleEventObserver 以接收有关生命周期事件的通知。
    • 这两种方式的区别在于，apt可以减少反射的性能消耗，典型的空间换时间。
  • 
• 当一个类同时实现了这两个接口以及为方法添加了注解，那么 ① 会优先回调 DefaultLifecycleObserver.onXXX(LifecycleOwner) ，② 然后再回调 LifecycleEventObserver.onStateChanged(LifecycleOwner, Lifecycle.Event) 方法。③ 此时注解会被忽略。【详见 FullLifecycleObserverAdapter】

FullLifecycleObserver

• DefaultLifecycleObserver : FullLifecycleObserver

LifecycleEventObserver

• androidx.lifecycle 包下，主要的实现类有（不完全，还有很多）：
  • FullLifecycleObserverAdapter

① FullLifecycleObserverAdapter

• 持有两个成员变量，一个 FullLifecycleObserver，一个 LifecycleEventObserver。
• 在 onStateChanged() 方法中，当方法被回调，方法内会优先调用 mFullLifecycleObserver.onXXX() 方法，再调用 mLifecycleEventObserver.onStateChanged() 方法。
  • 这也是为什么【当一个类同时实现了这两个接口，会优先回调 DefaultLifecycleObserver.onXXX(LifecycleOwner) ，然后再回调 LifecycleEventObserver.onStateChanged(LifecycleOwner, Lifecycle.Event) 方法】的主要原因。
• 具体的”将原始的观察者对象转换为 FullLifecycleObserverAdapter 对象”的时机，是在注册观察者对象 LifecycleRegistry.addObserver() 时，将原始的观察者对象封装为一个 ObserverWithState 对象，ObserverWithState 的构造函数通过调用 Lifecycling.lifecycleEventObserver() 方法进行了转换。【下面讲解 Lifycycling 时继续描述】

---

三、LifecycleOwner

生命周期所有者。

• 以 androidx.core.app.ComponentActivity 为例，getLifecycle()方法直接返回了 mLifecycleRegistry:LifecycleRegistry。
  • 该成员变量的对象是在 Activity 初始化的时候就直接构造了。
• 以 FragmentActivity 为例，该类中有一个成员变量 mFragmentLifecycleRegistry:LifecycleRegistry。
  • 该成员变量的对象是在 Activity 初始化的时候就直接构造了。
• 在组件中，通过调用该对象mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event) 方法，通知 Lifecycle 去处理生命周期事件。
• 也就是说，生命周期所有者对象中，必定会持有一个 LifecycleRegistry:Lifecycle 对象，用于响应和分发生命周期事件。

---

四、Lifecycling

处理 lifecycle 生命周期转换等操作的一个内部类。

Lifecycling.lifecycleEventObserver()

• 主要关注其中的 Lifecycling.lifecycleEventObserver() 方法，该方法在 ObserverWithState 的构造函数中被调用。

• 接收原始的生命周期观察者对象为参数，转换并返回一个 LifecycleEventObserver 对象。该方法返回的对象只有以下四个类型
  • ① FullLifecycleObserverAdapter
  • ② LifecycleEventObserver
  • ③ SingleGeneratedAdapterObserver
  • ④ CompositeGeneratedAdaptersObserver
  • ⑤ ReflectiveGenericLifecycleObserver
• ① 首先会分别判断原始的生命周期观察者对象，是否实现了 LifecycleEventObserver 接口，是否实现了 FullLifecycleObserver 接口。
  • 如果同时实现了这两个接口，则封装为一个 FullLifecycleObserverAdapter 对象；
  • 如果只实现了 FullLifecycleObserver 接口，也会被封装为一个 FullLifecycleObserverAdapter 对象，此时第二个参数为 null。
• ② 如果只实现了 LifecycleEventObserver 接口，则会直接强转并返回一个 LifecycleEventObserver 对象（因为方法参数的接收类型为 Object）
• ③ 调用 getObserverConstructorType(klass) 方法，获取并得到观察者构造器类型。在此处区分是由注解处理器生成的，还是由反射生成的。
• 需要注意的事情是，由于2.4.0版本废弃了@OnLifecycleEvent这个注解，此时是不会走到第三步的。

---

小结

Activity 的生命周期回调监听

单个 Activity：androidx.lifecycle.ReportFragment

app进程中所有Activity：androidx.lifecycle.ProcessLifecycleOwner

ReportFragment

如何实现 Activity 的生命周期监听？

• 依赖于 ReportFragment 实现。为每个 Activity 注入添加一个ReportFragment，ReportFragment 相当于一个代理，通过 ReportFragment 来监听 Activity 的生命周期并分发生命周期事件。

ReportFragment 如何与 Activity 进行关联？

• 【问】也就是说什么时候为 Activity 添加 ReportFragment？什么时候为 Activity 注册 Application.ActivityLifecycleCallbacks 回调？即什么时候调用 ReportFragment.injectIfNeededIn() 方法？
• ① 在 androidx.core.app.ComponentActivity 的 onCreate() 方法中，会调用 ReportFragment.injectIfNeededIn(this) 方法进行注入。
• ② 在 androidx.activity.ComponentActivity 的 onCreate() 方法中，会调用 ReportFragment.injectIfNeededIn(this) 方法进行注入。
• ③ 除了上述的两处地方会调用该方法来尝试注入 ReportFragment 之外，另外还有一个地方进行了注入，LifecycleDispatcher.init()，该方法会在 ProcessLifecycleInitializer 执行时调用。
  • LifecycleDispatcher.init() 初始化时，为 application 注册一个自定义的 ActivityLifecycleCallbacks 对象，从而实现全局的监听 app 中所有 Activity 的创建并为其新建的 Activity 尝试注入 ReportFragment。【注意，这里是 Application.registerActivityLifecycleCallbacks()】
  • DispatcherActivityCallback：在 onActivityCreated() 回调方法中（即 Activity 创建时），调用 ReportFragment.injectIfNeededIn(this) 方法，尝试注入 ReportFragment。
• ReportFragment.injectIfNeededIn(this)
  • 处理1：无论 sdk 版本是多少，都会判断当前 Activity 中是否包含有一个 ReportFragment？如果无，则会为其添加一个 ReportFragment。
  • 处理2：当 sdk >= 29 时，还会主动为 Activity 注册 LifecycleCallbacks:Application.ActivityLifecycleCallbacks（针对不同 sdk 版本，对 Activity 生命周期的监听方式不同）。

不同 sdk 版本，如何实现对 Activity 生命周期的监听？

• 针对 sdk < 29（Android10） 的情况，通过重写 ReportFragment 的生命周期回调方法，在方法中去监听并响应生命周期事件。
  • 重写 onActivityCreated()、onStart()、onResume()、onPause()、onStop()、onDestroy() 方法
  • 根据对应的生命周期事件作为方法参数，调用 dispatch(Lifecycle.Event.ON_XXX) 方法；
• 针对 sdk >=29（Android10） 的情况，由于在 ReportFragment.injectIfNeededIn(this) 注入时为页面 Activity 注册了 Application.ActivityLifecycleCallbacks，通过在回调方法中对页面的生命周期进行监听和响应处理。【注意，这里是 activity.registerActivityLifecycleCallbacks()】
  • 在 ReportFragment 中，有一个实现了 Application.ActivityLifecycleCallbacks 接口的静态内部类 LifecycleCallbacks；LifecycleCallbacks 提供了一个静态方法 registerIn(Activity activity)，在 ReportFragment.injectIfNeededIn() 静态方法中被调用。
  • LifecycleCallbacks.registerIn(Activity activity) 方法，会方法参数 activity 注册生命周期回调 activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks()); 从而实现了对 Activity 的生命周期的监听（且该回调要求 sdk 必须大于等于 29）。注册的监听器为 LifecycleCallbacks 对象。
  • LifecycleCallbacks 通过重写接口的回调方法，根据对应的生命周期事件作为方法参数，调用静态方法 dispatch() 进行处理。其中重写的方法包括 onActivityPostCreated()、onActivityPostStarted()、onActivityPostResumed()、onActivityPrePaused()、onActivityPreStopped()、onActivityPreDestroyed() 方法。

ReportFragment 如何处理分发的生命周期事件？

• ReportFragment 中有一个静态方法 dispatch(Activity activity,Lifecycle.Event event)，用于对 参数activity 所指定的页面，去分发 参数event 所指定的生命周期事件。
• 内部实现：获取 参数activity 所关联的 lifecycle(LifecycleRegister) 对象，调用其 handleLifecycleEvent() 进行分发；LifecycleRegistry 通过遍历其所持有的 map 成员变量去通知所有已注册的观察者对象，获取并调用 ObserverWithState.dispatchEvent() 方法来通知观察者对象并完成生命周期事件的分发。

ProcessLifecycleInitializer

2.4.0 之前

• 2.4.0 之前：通过一个自定义的 ContentProvider 类，来初始化 ProcessLifecycleOwnerInitializer。
• ProcessLifecycleOwnerInitializer.onCreate() 回调中调用了两个方法：
  • LifecycleDispatcher.init(getContext())
  • ProcessLifecycleOwner.init(getContext())

2.4.0 版本-newest

• 2.4.0：使用 androidx.startup 来初始化 ProcessLifecycleInitializer。
• ProcessLifecycleInitializer.onCreate() 回调中调用了两个方法：
  • LifecycleDispatcher.init(getContext())
  • ProcessLifecycleOwner.init(getContext())

优点

• ① 使用 androidx.startup 来初始化 ProcessLifecycleInitializer，间接初始化 LifecycleDispatcher，为 application 注册一个自定义的 ActivityLifecycleCallbacks 对象，从而实现全局的监听 Activity 的创建并为其新建的 Activity 尝试注入 ReportFragment。从而避免了在基类中手动调用添加 Fragment 的操作。
• ② 利用 fragment 来分发生命周期，将分发生命周期的代码逻辑从 Activity 中剥离出来，减少耦合，方便复用。

Fragment 的生命周期回调监听

androidx.fragment.app.Fragment

androidx.fragment.app.FragmentViewLifecycleOwner

• 在 Fragment 当中，Fragment 实例 与 Fragment的View对象 ，这两者的生命周期是独立分离的，分别对应两个不同的 LifecycleOwner 生命周期所有者对象。
  • Fragment 实例对应的 LifecycleOwner：Fragment 实现了 LifecycleOwner 接口，通过 Fragment.getLifecycle() 即可获得 Fragment 实例对应的 Lifecycle 对象。
  • Fragment 的 View 对应的 LifecycleOwner：通过 Fragment.getViewLifecycleOwner() 方法即可获得 View 对应的 LifecycleOwner 对象；通过 Fragment.getViewLifecycleOwner().getLifecycle() 方法即可获得 View 对应的 Lifecycle 对象。

Fragment 实例对象

• mLifecycleRegirtry：在 Fragment 实例被构造时，初始化。
• 在 Fragment 中，Fragment 实例对象的生命周期事件分发，最终是通过调用 mLifecycleRegirtry.handleLifecycleEvent() 进行分发。

Fragment.View 对象

• mViewLifecycleOwner：在 onCreateView() 方法被回调时，构造了一个 FragmentViewLifecycleOwner:ViewModelStoreOwner 实例对象；该对象持有一个成员变量 mLifecycleRegistry:LifecycleRegistry。
• 在 Fragment 中，Fragment 的 View 对应的生命周期事件分发，最终是通过调用 mViewLifecycleOwner.handleLifecycleEvent() 进行分发，最终会回调 FragmentViewLifecycleOwner 的成员变量 mLifecycleRegistry.handleLifecycleEvent() 进行分发。

Service 的生命周期回调监听

需要依赖 implementation ‘androidx.lifecycle:lifecycle-service:${version}’

LifecycleService

• 当需要在 Service 中使用生命周期组件时，可直接继承 LifecycleService。

• LifecycleService 实现了 LifecycleOwner 接口。
• LifecycleService 持有一个 ServiceLifecycleDispatcher 类型的成员变量 mDispatcher，所有生命周期相关的操作和响应都是通过该对象来完成的。
  • getLifecycle() 方法返回了 mDispatcher.getLifecycle() 对象。
  • 重写了所有生命周期回调方法，并在生命周期回调方法中调用 mDispatcher 对应的分发方法 mDispatcher.onServicePreSuperOnXXX()，以分发生命周期事件 Lifecycle.Event。

ServiceLifecycleDispatcher

用于分发 Service 的生命周期事件的帮助类。
该类中有一个静态内部类 DispatchRunnable:Runnable。

ServiceLifecycleDispatcher

• 成员变量1，mRegistry：LifecycleRegistry，在构造函数中实例化。
  • LifecycleService.getLifecycle() 返回的就是该对象。
• 成员变量2，mHandler：Handler，在构造函数中实例化。
  • 分发生命周期事件时，就是通过该 Handler 对象 post 一个 Runnable 去执行处理。
  • 此时，该 Handler 关联的 Looper 对象，就是 Service 所在的线程所关联的 Looper。
• 成员变量3，mLastDispatchRunnable：DispatchRunnable，在分发生命周期事件调用 postDispatchRunnable(Lifecycle.Event) 方法时进行实例化。

核心方法 postDispatchRunnable()

• 如果当前的成员变量 runnable 不为空，先执行。
• 根据方法参数 Lifecycle.Event 构造一个新的 DispatchRunnable 对象，重置 runnable。
• 然后通过 mHandler.postAtFromtOfQueue() 出去执行，该方法会将当前的任务放到队列的队头优先被执行。
• 注意：这个Runnable就是在Handler所关联的线程中被执行；综上可知，会在Service所在的线程中被执行。

DispatchRunnable:Runnable

• 持有两个成员变量，mRegistry:LifecycleRegistry，mEvent:Lifecycle.Event。
• 持有一个标记 mWasExecuted，用于标记是否已经执行，默认为false。
• run()：执行时，如果mWasExecuted为false，则会调用 LifecycleRegistry 的 handlerLifecycleEvent() 方法处理并分发生命周期事件，并将mWasExecuted置为true。从而避免重复调用。

---