重学Android Jetpack(六)之—Lifecycle生命周期感知

简介

官方文档的介绍是这样说的：

生命周期感知型组件Lifecycle可执行操作来响应另一个组件（如Activity和Fragment）的生命周期状态的变化。这些组件有助于您编写出更有条理且往往更精简的代码，此类代码更易于维护。

简单来说，Lifecycle就是一个可以感知Activity/Fragment等组件生命周期的组件。使用Lifecycle可以避免在Activity/Fragment生命周期方法内写太多的业务逻辑处理代码，这样可以使我们的业务逻辑更加解耦。在以往，当我们需要在Activity/Fragment外部进行事件监听和状态查询时，只能自定义一套提供侦测功能的Activity/Fragment基类及回调接口，而Lifecycle的引入，就是对Activity/Fragment生命周期监听实现的官方支持。

Lifecycle相关类

库依赖：

implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.5.0-beta01"
implementation "androidx.lifecycle:lifecycle-common:2.4.1"

如果需要其他支持，可以参考以下依赖：

  dependencies {
    def lifecycle_version = "2.5.0-beta01"
    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"
   
    // Saved state module for ViewModel
    implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version"
    // Annotation processor
    kapt "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
    // 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"
  }
  

Lifecycle类

Lifecycle是一个核心抽象类，也是结构的核心，用于存储有关组件（如Activity或Fragment）的生命周期状态的信息，并允许其他对象观察此状态。继承该类的子类，表示本身是一个具有Android生命周期特性的对象，并能对外提供如下能力：

• Android生命周期事件的监听：从框架和Lifecycle类分派的生命周期事件。这些事件映射到Activity和 Fragment中的回调事件；
• Android生命周期状态的获取：由Lifecycle对象跟踪组件的当前状态。

来自官方关于Activity生命周期状态和事件的示意构图：

State是节点，Event是连接每个节点的线。Event的值是完全按Activity的生命周期来理解，都是一一对应的，State看起来是缺失了PAUSED、STOPED，其实它的PAUSED就是STARTED，STOPED是CREATED。总的来说，Event就是改变生命周期的事件，State是目前Activity/Fragment所处生命周期的状态。

Lifecycle的几个状态对应：

• onCreate() > CREATED
• onStart() > STARTED
• onResume() > RESUMED
• onPause() > STARTED
• onStop() > CREATED
• onDestroy() > DESTROYED

Lifecycle抽象类内部，还定义了2个用于生命周期相关的枚举类：

• enum Event：生命周期事件
• enum State：生命周期状态

LifecycleOwner

LifecycleOwner是单一方法的核心接口，所有该接口的实现类都能够为外部提供Lifecycle实例，它具有一种方法（即getLifecycle()）。如果要管理整个应用进程的生命周期，可以参阅ProcessLifecycleOwner。

在系统框架中，LifecycleOwner接口的实现类为ComponentActivity和Fragment(这也是为什么我们新建项目不依赖库都可以直接拿到lifecycle)，两者提供的Lifecycle对象，是系统框架实现中Lifecycle的唯一子类LifecycleRegistry。

LifecycleRegistry

LifecycleRegistry是Lifecycle的子类，也是系统框架实现中Lifecycle的唯一子类,相关的逻辑调用都是通过LifecycleRegistry来实现的。实现Lifecycle定义生命周期观察订阅，生命周期查询的方法。还实现了架构中，生命周期变化时触发的自身状态处理和相关对观察者的订阅回调的逻辑。

LifecycleObserver

LifecycleObserver也是一个接口，所有实现该接口的实现类都是关注生命周期事件的观察者。LifecycleObserver接口只是标记其实现类为观察者，内部不存在任何方法定义，实际的工作一般根据需求使用其子类接口或者使用注解实现，这些接口主要是包括如下：

• LifecycleObserver

是LifecycleObserver本身，采用注解方式，@OnLifecycleEvent标记自定义的方法以实现回调。注解的工作方式有两种：反射，预编译适配类，默认的工作方式为反射。 反射方式： 很好理解，就是通过包装和处理后，最终通过invoke调用被注解的方法。 预编译方式： 需要引入注解编译器：androidx.lifecycle:lifecycle-compiler:<*>。

目前这一种方式在使用Java8特性建议使用DefaultLifecycleObserver和LifecycleEventObserver：

Annotation that can be used to mark methods on LifecycleObserver implementations that should be invoked to handle lifecycle events. Deprecated This annotation required the usage of code generation or reflection, which should be avoided. Use DefaultLifecycleObserver or LifecycleEventObserver instead.

• FullLifecycleObserver

LifecycleObserver子接口。为所有的生命周期事件都定义了对应的回调方法。实现该接口，就需要把不需要观察的方法回调都做一个空实现。在没有java8的default关键字时，如果仅需要1-2个回调方法，那么最终实现类中的空方法会相当碍眼，这种情况下推选使用 @OnLifecycleEvent注解方式替代。(当然也可以自己弄一个空实现的BaseLifecycleObserver)

• DefaultLifecycleObserver FullLifecycleObserver子接口。使用java8的default关键字空实现了FullLifecycleObserver的所有方法。 需要引入：androidx.lifecycle:lifecycle-compiler:<*>。

如果项目中使用了java8或者开启java8特性，那么官方强烈推选DefaultLifecycleObserver替代的@OnLifecycleEvent注解实现 (注解后续可能被弃用)，包括预编译。引入DefaultLifecycleObserver后，就需要把注解实现相关逻辑移除。即使保留注解，由于Lifecycling的处理逻辑（系统架构逻辑中所有传入的观察者都会经过Lifecycling处理），任何FullLifecycleObserver的实现类 (即包括DefaultLifecycleObserver) 内部所有的@OnLifecycleEvent注解都会失效。

• LifecycleEventObserver

LifecycleObserver子接口。只有一个onStateChanged方法，以Lifecycle.Event入参提供事件区分的形式，进行统一方法回调。与FullLifecycleObserver不冲突，但是也会无效化@OnLifecycleEvent注解。同时实现LifecycleEventObserver和FullLifecycleObserver，可以得到2次相同的生命周期回调，后者的具体方法回调优先于前者的统一方法回调。

Lifecycle基本使用

使用Lifecycle的只要方法有三个：

getLifecycle().addObserver(LifecycleObserver);
getLifecycle().removeObserver(LifecycleObserver);
getLifecycle().getCurrentState();

然后根据两个接口实现定义观察者和被观察者：

• 被观察者：LifecycleOwner连接有生命周期的组件，如activity/fragment;
• 观察者：LifecycleObserver用于观察LifecycleOwner。

一般我们创建一个Activity继承AppCompatActivity就自动实现LifecycleOwner接口了，即已经具备了LifecycleOwner，只需自己实现LifecycleObserver，然后addObserver就可以建立生命周期监听了。这里延伸说一下最后是AppCompatActivity的父类ComponentActivity实现了LifecycleOwner接口并持有LifecycleRegistry实例，但是操作LifecycleRegistry生命周期变化的逻辑却是在ReportFragment中。ComponentActivity会在初始化阶段添加一个ReportFragment实例，以此对自身维护的LifecycleRegistry进行生命周期变化管理。

实现LifecycleObserver

class CustomLifeObserver: DefaultLifecycleObserver {
    private val TAG = CustomLifeObserver::class.simpleName
    override fun onCreate(owner: LifecycleOwner) {
        super.onCreate(owner)
        Log.e(TAG, "onCreate" )
    }
    override fun onStart(owner: LifecycleOwner) {
        super.onStart(owner)
        Log.e(TAG, "onStart" )
    }
    override fun onResume(owner: LifecycleOwner) {
        super.onResume(owner)
        Log.e(TAG, "onResume" )
    }
    override fun onPause(owner: LifecycleOwner) {
        super.onPause(owner)
        Log.e(TAG, "onPause" )
    }
    override fun onStop(owner: LifecycleOwner) {
        super.onStop(owner)
        Log.e(TAG, "onStop" )
    }
    override fun onDestroy(owner: LifecycleOwner) {
        super.onDestroy(owner)
        Log.e(TAG, "onDestroy")
    }
}

在Activity中的处理：

class MainActivity : AppCompatActivity() {
    private lateinit var customLifeObserver: CustomLifeObserver
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        customLifeObserver = CustomLifeObserver()
        lifecycle.addObserver(customLifeObserver)
    }
    override fun onDestroy() {
        super.onDestroy()
        lifecycle.removeObserver(customLifeObserver)
    }
}

基本的使用流程即使这样。

业务使用场景案例

音视频播放业务的解耦

一般来说，我们的音视频播放依赖于Activity或Fragment，如果仅在Activity中处理，代码肯定会非常繁多，我们也可以通过实现LifecycleObserver接口来处理音视频一部分的逻辑：

class MediaPlayerListener: DefaultLifecycleObserver {
    private val TAG = MediaPlayerListener::class.simpleName
    override fun onCreate(owner: LifecycleOwner) {
        super.onCreate(owner)
        initMedia()
    }
    //可以是从后台回到前台继续播放
    override fun onResume(owner: LifecycleOwner) {
        super.onResume(owner)
        startPlayMedia()
    }
    //停止播放 
    override fun onPause(owner: LifecycleOwner) {
        super.onPause(owner)
        pausePaly()
    }
    //退出播放销毁播放器防止内存泄露
    override fun onDestroy(owner: LifecycleOwner) {
        super.onDestroy(owner)
        destroyPlay()
    }
    private fun initMedia(){}
    private fun startPlayMedia(){}
    private fun pausePaly(){}
    private fun destroyPlay(){}
}

LifecycleService

LifecycleService是用来监听和解耦Service组件的相关业务逻辑的。下面一起看看它的使用流程：

添加依赖：

implementation "androidx.lifecycle:lifecycle-service:2.3.1"

自定义一个LifecycleServiceObserver类：

class LifecycleServiceObserver: DefaultLifecycleObserver {
    private val TAG = LifecycleServiceObserver::class.simpleName
    override fun onCreate(owner: LifecycleOwner) {
        super.onCreate(owner)
        Log.e(TAG,"init")
    }
    override fun onDestroy(owner: LifecycleOwner) {
        super.onDestroy(owner)
        Log.e(TAG,"destroy")
    }
}

创建一个CustomService并继承LifecycleService，因为LifecycleService是Service的直接子类，所以CustomService与普通的Service在使用并没有什么差别的。

class CustomService: LifecycleService() {
    private var lifecycleServiceObserver: LifecycleServiceObserver = LifecycleServiceObserver()
    override fun onCreate() {
        super.onCreate()
        lifecycle.addObserver(lifecycleServiceObserver)
    }
    override fun onDestroy() {
        super.onDestroy()
        lifecycle.removeObserver(lifecycleServiceObserver)
    }
}

ProcessLifecycleOwner监听应用程序的生命周期

ProcessLifecycleOwner是监听整个应用程序的生命周期的组件，很明显它应该在Application中处理。

要使用ProcessLifecycleOwner首先要添加相应的依赖：

implementation "androidx.lifecycle:lifecycle-process:2.4.0"

定义一个AppObserver

class AppObserver: DefaultLifecycleObserver {
    private val TAG = AppObserver::class.simpleName
    override fun onCreate(owner: LifecycleOwner) {
        super.onCreate(owner)
        Log.e(TAG, "onCreate" )
    }
    override fun onStart(owner: LifecycleOwner) {
        super.onStart(owner)
        Log.e(TAG, "onStart" )
    }
    override fun onResume(owner: LifecycleOwner) {
        super.onResume(owner)
        Log.e(TAG, "onResume" )
    }
    override fun onPause(owner: LifecycleOwner) {
        super.onPause(owner)
        Log.e(TAG, "onPause" )
    }
    override fun onStop(owner: LifecycleOwner) {
        super.onStop(owner)
        Log.e(TAG, "onStop" )
    }
    override fun onDestroy(owner: LifecycleOwner) {
        super.onDestroy(owner)
        Log.e(TAG, "onDestroy")
    }
}

在Application中关联ApplicationObserver：

class MyApp: Application() {
    override fun onCreate() {
        super.onCreate()
        ProcessLifecycleOwner.get().lifecycle.addObserver(AppObserver())
    }
}

这里要注意的是AppObserver的onCreate方法只会被调用一次，而onDestroy方法不会被调用。

总结

LifeCycle组件最主要意义就是帮助我们解耦和处理避免内存泄露。如果我们用mvvm架构开发，那LifeCycle可能会用得不太多，因为mvvm背后的核心就包含LifeCycle，我们之所以说Livedata可以保证内存泄漏的发生，靠的就是LifeCycle组件。另外官方的文档里说到，LifeCycle的最佳实践做法也是配合ViewModel和LiveData使用。

参考文章：developer.android.com/topic/libra…