Jetpack——Lifecycle源码解析

一、Lifecycle是什么？

官网文档是学习最好的资料，传送门：

• Lifecycle
• 使用生命周期感知型组件处理生命周期

Lifecycle 属于Jetpack的一个组件，是构建生命周期感知型组件，这些组件可以根据 Activity 或 Fragment 的当前生命周期状态调整行为。生命周期感知型组件可执行操作来响应另一个组件的生命周期状态的变化。这些组件有助于我们写出更有条理且往往更精简的代码，这样的代码更易于维护。

Jetpack是一个庞大且强大的工具集，这是第一篇分析Jetpack 的文章，在此列出部分组件供参考，后续可能会出一个系列分析其中稳定、成熟的组件。

1.1 Lifecycle的作用

Lifecycle 的出现是为了解耦系统组件的生命周期与自定义组件之间耦合。以前如果自定义的组件需要在 Activity 对应的生命周期做相应的处理的话，就要重写 Activity 的生命周期，然后在生命周期方法里做相应的处理，而现在可以通过 Lifecycle 去省略掉重写生命周期方法这个步骤。可以有效避免内存泄漏，解决 Android 生命周期常见难题。

1.2 Lifecycle的原理

Lifecycle 架构设计使用了观察者模式，通过 Owner 和 Observer 的配合，使用观察者模式监听被观察者的生命周期的变化，来实现生命周期的解耦。Activity 虽然实现了 LifecycleOwner 接口，但是并没有实现相关处理，而是通过添加一个 Fragment 来代理 Lifecycle 的分发。这种通过 Fragment 代理 Activity 行为的设计在其他一些库也经常出现，相对来说更加无侵和优雅。

1.3 Lifecycle 框架涉及到几个关键类

• Lifecycle 是一个持有组件生命周期状态信息的核心抽象类，能够监听Activity / Fragment生命周期行为的各种变化。包含一个全局变量、三个抽象方法和两个枚举内部类，三个方法分别用于添加 LifecycleObserver 、移除 LifecycleObserver、获取当前 Lifecycle 所处的状态值和表示状态和事件的两个枚举。一个常量mInternalScopeRef 用于在引入了 lifecycle-common-ktx 包的情况，即只有在使用 Kotlin 协程库的时候才有用。
• LifecycleOwner 是一个核心接口，生命周期的事件分发者，接口通常用来声明具备某种能力，该接口的实现类表示能够为外部提供 Lifecycle 实例用于连接生命周期对象，如Activity / Fragment ，当然，也可以自定义生命周期组件。LifecycleOwner 提供了 getLifecycle() 方法来获取其 Lifecycle 对象，大部分情况下真正具有使用意义的是它的子接口 ，可以说仅是用于类型标记，系统框架实现中 Lifecycle 的唯一子类LifecycleRegistry，在 Activity/Fragment 他们的生命周期发生变化的时发出相应的 Event 给 LifecycleRegistry。
• LifecycleObserver 该接口的实现类表示为关注生命周期事件的观察者，用于观察 LifecycleOwner，它是没有任何方法是一个空接口，实际的工作一般根据需求使用其子类接口或者使用注解实现，一般包括：
  • LifecycleObserver 该接口本身采用注解方式，@OnLifecycleEvent标记自定义的方法以实现回调。
    注解的工作方式有两种：反射和预编译适配类，默认的工作方式为反射。
    反射方式：通过包装和处理后，最终通过invoke调用被注解的方法。
    预编译方式：需要引入注解编译器：androidx.lifecycle:lifecycle-compiler:$lifecycle_version。
    对被注解标记 且 继承/实现 LifecycleObserver 接口的 类/接口，自动编译生成对应的继承 GeneratedAdapter 的 _LifecycleAdapter.class 适配类，以减少反射消耗，典型的空间换时间，通过注解将处理函数与希望监听的 Event 绑定,当相应的 Event 发生时，LifecycleRegistry 会通知相应的函数进行处理。
  • FullLifecycleObserver 为所有的生命周期事件都定义了对应的回调方法。实现该接口就需要把不需要观察的方法回调都做一个空实现。在没有 Java 8 的 default 关键字时，如果仅需要1-2个回调方法，那么最终实现类中的空方法会相当碍眼，这种情况下推选使用 @OnLifecycleEvent注解方式替代。(当然也可以自己实现一个空实现的BaseLifecycleObserver)。
  • DefaultLifecycleObserver 使用 Java 8 的 default 关键字空实现了 FullLifecycleObserver 的所有方法。如果项目中使用了 Java8 或者开启 Java 8 特性，那么官方强烈推选DefaultLifecycleObserver替代的 @OnLifecycleEvent 注解实现 (注解后续可能被弃用)，包括预编译。引入 DefaultLifecycleObserver 后，就需要把注解实现相关逻辑移除。即使保留注解，由于 Lifecycling 的处理逻辑（系统架构逻辑中所有传入的观察者都会经过 Lifecycling 处理），任何 FullLifecycleObserver 的实现类 (即包括 DefaultLifecycleObserver) 内部所有的 @OnLifecycleEvent 注解都会失效。
  • LifecycleEventObserver 只有一个 onStateChanged() 方法，以 Lifecycle.Event 入参提供事件区分的形式，进行统一方法回调。与 FullLifecycleObserver 不冲突，但是也会无效化@OnLifecycleEvent注解。同时实现 LifecycleEventObserver 和 FullLifecycleObserver，可以得到2次相同的生命周期回调，后者的具体方法回调优先于前者的统一方法回调。
  • ReflectiveGenericLifecycleObserver 是 LifecycleEventObserver 子类。适应于注解方式的反射工作方式。通过该类对观察者进行包装，处理观察者关注的回调的反射调用，由Lifecycling处理包装过程。
  • SingleGeneratedAdapterObserver 是 LifecycleEventObserver 子类。适应于注解方式的预编译工作方式。通过该类对观察者的 GeneratedAdapter 进行包装，处理 GeneratedAdapter 的方法调用，由 Lifecycling 处理包装过程。
  • CompositeGeneratedAdaptersObserver 是 SingleGeneratedAdapterObserver 的复数版，内部逻辑基本与其一致，只是提供"复数" GeneratedAdapter 的支持。
• LifecycleRegistry 控制中心，它负责控制 state 的转换、接受分发 event 事件。
• Lifecycling 核心工具类。系统框架实现中，对所有 LifecycleObserver 的包装适配器选择和相关处理都由本类完成。

怎么理解“复数”呢？
首先要知道，在程序运行过程，Lifecycling 会查找传入观察者自身的对应的 GeneratedAdapter，假如不存在，则会查找其所有父类/接口对应的 GeneratedAdapter。
假如存在自身的对应的 GeneratedAdapter，那么此时 GeneratedAdapter 数量等于1，则会实例化这个 GeneratedAdapter 并使用 SingleGeneratedAdapterObserver 保存（所以叫做 Single）。
假如目标观察者类自身不包含注解方法，而是继承或实现包含注解方法的 LifecycleObserver 类/接口。根据前面的预编译规则，由于目标类不包含注解方法，注解编译器不会为其生成 GeneratedAdapter。
根据查找逻辑，自身对应的 GeneratedAdapter 不存在，Lifecycling将会查找其所有父类/接口对应的 GeneratedAdapter。
如果结果 GeneratedAdapter 数量等于1，则走 SingleGeneratedAdapterObserver 流程。
如果结果 GeneratedAdapter 数量大于1 （继承+实现，或多实现等等，都可能发生），Lifecycling 将会结果 GeneratedAdapter 实例化并打包成数组，并使用 CompositeGeneratedAdaptersObserver 保存（所以叫做 Composite）。
——深入理解AAC架构 - Lifecycle整体机制源码

Lifecycle组件原理——图源：ShymanZhu

二、Lifecycle的使用

2.1 声明依赖

（1）完整引入

// lifecycle-extensions 中的 API 已弃用。您可以为特定 Lifecycle 工件添加所需的依赖项。
dependencies {
   
   
    def lifecycle_version = "2.4.0"// 文档用的是val lifecycle_version = "2.4.0"
    def arch_version = "2.1.0"

    // ViewModel
    implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version")
    // ViewModel utilities for Compose
    implementation("androidx.lifecycle:lifecycle-viewmodel-compose:$lifecycle_version")
    // LiveData
    implementation("androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version")
    // Lifecycles only (without ViewModel or LiveData)
    implementation("androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version")

    // Saved state module for ViewModel
    implementation("androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version")

    // Annotation processor
    kapt("androidx.lifecycle:lifecycle-compiler:$lifecycle_version")
    // 替换 - 如果使用Java8,就用这个替换上面的lifecycle-compiler
    // alternately - if using Java8, use the following instead of lifecycle-compiler
    implementation("androidx.lifecycle:lifecycle-common-java8:$lifecycle_version")

	//以下按需引入
    // optional - helpers for implementing LifecycleOwner in a Service
    implementation("androidx.lifecycle:lifecycle-service:$lifecycle_version")
    // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process
    implementation("androidx.lifecycle:lifecycle-process:$lifecycle_version")
    // optional - ReactiveStreams support for LiveData
    implementation("androidx.lifecycle:lifecycle-reactivestreams-ktx:$lifecycle_version")
    // optional - Test helpers for LiveData
    testImplementation("androidx.arch.core:core-testing:$arch_version")
}

（2）精简版本

dependencies {
   
   
    implementation "androidx.lifecycle:lifecycle-runtime:2.0.0"
    implementation "androidx.lifecycle:lifecycle-extensions:2.0.0"
    implementation "androidx.lifecycle:lifecycle-common-java8:2.0.0"
    annotationProcessor "androidx.lifecycle:lifecycle-runtime:2.0.0"
}

如果只使用Lifecycle，只需要引入lifecycle-runtime即可。

2.2 使用

（1）自定义监听器

如果不使用 Lifecycle 的话实现一个观察者，需要自定义监听器

/**
 * 自定义监听器
 */
class MyListener {
   
   
    private val TAG = "MyListener"

    // 能监听到所有需要的方法
    fun start():Int = Log.d(TAG, "start run ...")
    fun stop():Int = Log.d(TAG, "stop run ...")
}

在界面初始化的位置实例化，并在被观察者需要监听的位置调用监听器对应的方法实现效果

class MainActivity : AppCompatActivity() {
   
   
    private var myListener: MyListener? = null

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

        myListener = MyListener()// 初始化订阅关系
    }

    override fun onStart() {
   
   
        super.onStart()
        myListener?.start()// 调用监听器对应方法
    }

    override fun onStop() {
   
   
        super.onStop()
        myListener?.stop()
    }
}

（2）MVP中使用

一般这种编程思路通常在P层监听 Activity 生命周期，忽略已消亡的页面逻辑、数据处理

/**
 * 一般用于MVP中P层监听Activity生命周期
 */
class MyPresenter {
   
   
    private val TAG = "MyPresenter"

    // 能监听到所有需要的方法
    fun resume():Int = Log.d(TAG, "resume run ...")
    fun pause():Int = Log.d(TAG, "pause run ...")
}

Activity中使用，和上面相同的方式

class MainActivity : AppCompatActivity() {
   
   
    private var mPresenter: MyPresenter? = null

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

        mPresenter = MyPresenter()
    }

    override fun onResume() {
   
   
        super.onResume()
        mPresenter?.resume()
    }

    override fun onPause() {
   
   
        super.onPause()
        mPresenter?.pause()
    }
}

（3）使用 Lifecycle 方式

只要项目支持 Androidx，系统已经实现了 Lifecycle 接口，不需要自己写监听器。

我们看一下系统是如何帮我们实现 Lifecycle 接口的？

一般我们页面都是 AppCompatActivity 的实现类：

class MainActivity : AppCompatActivity() {
   
   

AppCompatActivity 继承自 FragmentActivity：

public class AppCompatActivity extends FragmentActivity implements AppCompatCallback,
        TaskStackBuilder.SupportParentable, ActionBarDrawerToggle.DelegateProvider {
   
   

FragmentActivity 继承自 ComponentActivity ：

public class FragmentActivity extends ComponentActivity implements
        ActivityCompat.OnRequestPermissionsResultCallback,
        ActivityCompat.RequestPermissionsRequestCodeValidator {
   
   

ComponentActivity 中实现了 LifecycleOwner 接口，这就是关键所在：

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        LifecycleOwner, // Lifecycle持有者
        ViewModelStoreOwner,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner {
   
   

只需要写一个观察者实现类，并实现 LifecycleObserver 接口，为方法添加注解即可。
缺点：这种方式拿不到页面环境。

/**
 * 观察者
 * 开发环境是 Java 1.7 ，可以使用注解的方式来监听生命周期变化
 * 但在以后会被逐步废弃，Google 官方也建议开发者尽量使用接口回调的形式
 */
class MyObserver : LifecycleObserver {
   
   
    private val TAG = "MyObsever"

    // 画面可见，连接
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun connectListener(): Int = Log.d(TAG, "connectListener run ...")

    // 画面不可见，断开连接
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun disConnectListener(): Int = Log.d(TAG, "disConnectListener run ...")
}

在页面初始化添加监听，不需要手动调用方法（如果大量页面中出现人为失误，会造成处理不一致性功能问题）

/**
 * 宿主（Activity/Fragment）
 * 依靠LifecycleOwner来维护
 */
class MainActivity : AppCompatActivity() {
   
   

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

        // 一般放在BaseActivity中关联注册
        // 观察者与被观察者关联的环节
        lifecycle.addObserver(MyObserver())
        lifecycle.addObserver(MyObserver2())
    }
}

可以增加多个观察者，多次观察，一般放在 BaseActivity 中关联注册。

另一种写法，不需要注解：

/**
 * 推荐写法
 * 开发环境是 Java 8 ，推荐使用以实现 DefaultLifecycleObserver 接口的方式来监听生命周期的变化
 * DefaultLifecycleObserver是对LifecycleObserver的二次封装，需要引入支持：
 * implementation "android.arch.lifecycle:common-java8:1.1.1"
 */
class MyObserver2 : DefaultLifecycleObserver {
   
   
    private val TAG = "MyObserver2"

    override fun onCreate(owner: LifecycleOwner) {
   
   
        super.onCreate(owner)
        Log.d(TAG, "onCreate run ...")