Jetpack之LifeCycle

一、前言

Jetpack中有一个LifeCycle，主要用于对Activity和Fragment的生命周期做一个解耦分离。虽然用法简单，但却是JetPack不可缺少的一环。这里不在对为什么使用LifeCycle和使用LifeCycle的优点进行解释(这里官方文档有详细解释)，仅记录LifeCycle的使用方式。

二、添加依赖

关于lifecycle的依赖可以根据情况进行添加，不必全部添加

    dependencies {
        val lifecycle_version = "2.4.0"
        val 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")
        // 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中，核心部分是LifecycleObserver接口、LifecycleOwner接口、Lifecycle抽象类。这三者的关系如下:

1. LifecycleObserver是一个用来监听生命周期状态的接口，不过该接口是空接口，具体接口由其它子类实现，如FullLifecycleObserver、DefaultLifecycleObserver、LifecycleEventObserver。

2. Lifecycle是一个存储生命生命周期状态信息的抽象类，并允许其它类对其进行观察，比如LifecycleObserver

3. LifecycleOwner是一个单一方法接口，用于获取LifeCycle。该类可以抽离出所有类的LifeCycle。但该类并不是必然需要的，但是有的话可以使代码更加简单。

支持库 26.1.0 及更高版本中的 Fragment 和 Activity 已实现 LifecycleOwner 接口。所以可以很方便的获取到LifeCycle类

四、简单示例

class MyObserver : DefaultLifecycleObserver {
    override fun onResume(owner: LifecycleOwner) {
        connect()
    }

    override fun onPause(owner: LifecycleOwner) {
        disconnect()
    }
}

myLifecycleOwner.getLifecycle().addObserver(MyObserver())

在26.1.0 及更高版本的Activity中，可以使用以下简单的方式进行处理:

class MainActivity : AppCompatActivity(){
    val observer = MyObserver()
    override fun onCreate(savedInstanceState: Bundle?) {
        lifecycle.addObserver(observer)
    }
    override fun onDestroy() {
        lifecycle.removeObserver(observer) //需要注意的是这个不需要显示调用，写这里只是让知道有这么个函数
    }
}
class MyObserver : DefaultLifecycleObserver {
    override fun onResume(owner: LifecycleOwner) {
        Log.e("YM--->Observer","---->onResume()")
    }

    override fun onPause(owner: LifecycleOwner) {
    }
}

五、自定义 LifecycleOwner

假如我们想要监听的类没有实现LifecycleOwner，那么就没有办法直接获取LifeCycle。所以就需要进行自定义。方式如下：

class MyActivity : Activity(), LifecycleOwner {

    private lateinit var lifecycleRegistry: LifecycleRegistry

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        lifecycleRegistry = LifecycleRegistry(this)
        lifecycleRegistry.markState(Lifecycle.State.CREATED)
    }

    public override fun onStart() {
        super.onStart()
        lifecycleRegistry.markState(Lifecycle.State.STARTED)
    }

    override fun getLifecycle(): Lifecycle {
        return lifecycleRegistry
    }
}

六、LifecycleEventObserver

其实到上述部分就结束了，这里是对其进行的拓展。上面知道了对生命周期的监听，除了该方式外还可以对生命周期的事件进行监听，如下:

      this.getLifecycle().addObserver(new LifecycleEventObserver() {
                public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {
                    if (event == Event.ON_DESTROY) {
                          // 页面销毁
                    }

                }
            });

七、Lifecycle的部分方法

1. getCurrentState()获取当前生命周期状态

2. isAtLeast(@NonNull State state)大于等于既定的状态

比如如果某段代码需要在页面存在期间更新，倘若页面销毁了再更新ui会崩溃，可以使用以下写法

 val isCreated = lifecycle.currentState.isAtLeast(Lifecycle.State.CREATED)
        if (!isCreated) return

当然这个范围也可以限制到START的范围中。这个还有一个类似的函数

 lifecycleScope.launchWhenCreated {
 	//相关代码
 }

八、参考链接

1. 使用生命周期感知型组件处理生命周期

2. Lifecycle Dependencies

3. Lifecycle Observer is not removed in step_4 #5