JetPack系列之Lifecycle

目录

• LifeCycle是什么？
• 为什么要使用LifeCycle?
• 如何使用LifeCycle?
• LifeCycleOwner和LifecycleObserver

LifeCycle是什么？

官方文档地址:https://developer.android.google.cn/topic/libraries/architecture/lifecycle

先来看一下官方的解释:

生命周期感知型组件可执行操作来响应另一个组件（如 Activity 和 Fragment）的生命周期状态的变化。这些组件有助于您写出更有条理且往往更精简的代码，这样的代码更易于维护。
Lifecycle 是一个类，用于存储有关组件（如 Activity 或 Fragment）的生命周期状态的信息，并允许其他对象观察此状态

为什么要使用LifeCycle?

Activity和Fragment都是由生命周期方法的，比如onCreate、onStart、onResume等。在日常的开发过程中我们可能会将一些比较复杂的逻辑写在这些生命周期方法中。这种做法在项目规模比较小的的时候不会显现什么弊端，但是随着需求越来越多，逻辑越来越复杂，这个时候如果继续将相关逻辑放在生命周期方法中执行会使页面变得非常臃肿，逻辑越来越复杂并且界面不容易维护。
LifeCycle的目的就是为了统一生命周期相关的代码规范，使开发者在处理生命周期相关问题时代码更加简洁规范，易于维护。

如何使用LifeCycle?

如果使用Java8,需要在gradle文件中显式声明如下

def lifecycle_version = "2.2.0"
implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

两种实现方式

1. 实现LifecycleObserver接口，使用注解监听生命周期
2. 直接实现DefaultLifecycleObserver接口，重写其中的生命周期方法

实现LifecycleObserver
新建一个类MyObserver，实现LifecycleObserver接口,这种写法需要为想要监听的生命周期方法添加对应的注解

class MyObserver(var context: Context):LifecycleObserver {
    val tag:String = "myObserver"
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun create(owner: LifecycleOwner){
        Log.d(tag,"当前生命周期onCreate")

    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun start(owner: LifecycleOwner){
        Log.d(tag,"当前生命周期onStart")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun resume(owner: LifecycleOwner){
        Log.d(tag,"当前生命周期onResume")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun pause(owner: LifecycleOwner){
        Log.d(tag,"当前生命周期onPause")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun stop(owner: LifecycleOwner){
        Log.d(tag,"当前生命周期onStop")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun destory(owner: LifecycleOwner){
        Log.d(tag,"当前生命周期onDestory")
    }

直接实现DefaultLifecycleObserver
新建一个类MyObserver2，实现DefaultLifecycleObserver接口，重写其中的生命周期方法，不需要添加注解

class MyObserver2(var context:Context):DefaultLifecycleObserver {
    private val tag : String = "myObserver"
    override fun onCreate(owner: LifecycleOwner) {
        Log.d(tag,context::class.java.toString()+"当前生命周期onCreate")
    }

    override fun onResume(owner: LifecycleOwner) {
//        super.onResume(owner)
        Log.d(tag,context::class.java.toString()+"当前生命周期onResume")

    }
    override fun onPause(owner: LifecycleOwner) {
//        super.onPause(owner)
        Log.d(tag,context::class.java.toString()+"当前生命周期onPause")
    }


    override fun onStart(owner: LifecycleOwner) {
//        super.onStart(owner)
        Log.d(tag,context::class.java.toString()+"当前生命周期onStart")
    }


    override fun onStop(owner: LifecycleOwner) {
//        super.onStop(owner)
        Log.d(tag,context::class.java.toString()+"当前生命周期onStop")
    }


    override fun onDestroy(owner: LifecycleOwner) {
//        super.onDestroy(owner)
        Log.d(tag,context::class.java.toString()+"当前生命周期onPause")
    }

Activity中注册使用
API26以后的Activty已经默认实现了LifecycleOwner接口，所以可以在Activity中直接获取到LifeCycle

lifecycle.addObserver(MyObserver(this))

如果我们有一些操作是需要在activity或者fragment的生命周期内进行的，就需要保证执行操作时生命周期的状态至少是onCreate。可以在自定义观察者类的构造方法中接收一个LifeCycle对象，通过这个LifeCycle的状态来判断当前生命周期是不是在onCreate或者其他状态。

class MyObserver(var context: Context,var lifecycle: Lifecycle):LifecycleObserver {
    val tag:String = "myObserver"
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun create(owner: LifecycleOwner){
        if (lifecycle.currentState.isAtLeast(Lifecycle.State.CREATED)){
            Log.d(tag,"当前生命周期onCreate")
        }
    }
}

LifeCycleOwner和LifecycleObserver

LifeCycleOwner 生命周期持有者

官方的解释是

官网介绍：LifecycleOwner是一个单一的方法接口，表示该类有一个 Lifecycle。它有一个getLifecycle()方法 必须由这个类来实现。如果您试图管理整个应用程序进程的生命周期，请参阅 ProcessLifecycleOwner。该接口从各个类（如Fragment和AppCompatActivity）抽象生命周期的所有权，并允许编写与它们一起工作的组件。
任何自定义应用程序类都可以实现LifecycleOwner接口
实现LifecycleObserver的组件与实现LifecycleOwner的组件无缝协作，因为所有者可以提供生命周期，观察者可以注册以观看

就是说，LifecycleOwner是一个生命周期持有者接口，谁实现了这个接口谁就持有LifeCycle对象，并且可以通过getLifeCycle()方法获取LifeCycle，获取到LifeCycle之后就可以调用addObserver注册监听了

LifecycleObserver 生命周期观察者接口

LifecycleObserver 是一个观察者接口，实现了它，可以通过注解或者继承的方式，来管理声明周期的监听。只要在持有lifecycle的类中注册了它，当声明周期发生变化时，它就能收到，进行我们自定义的操作