Android Lifecycle使用

一：Lifecycle的定义

Lifecycle是具有生命周期感知能力的组件。也就是说，我们能在Activity或Fragment的生命周期发生变化的时候得到通知。

二：为什么使用lifecycle

比如，我们往往会在Activity的各种生命周期方法中执行特定的方法，比如广播的注册和解绑，EventBus的注册和解绑等。

如果我们把很多这种需要跟生命周期相关的逻辑代码都放在Activity的生命周期方法中，Activity代码会很臃肿，Activity也会变得越来越难以维护。so，通过Lifecycle，我们就能避免这些问题。把在Activity对应生命周期执行的办法，搬运到跟Lifecycle相关的类中去（LifecycleObserver）。

三：如何使用Lifecycle

1：导入 Lifecycle 依赖

如果项目已经迁移到了 AndroidX或者支持库版本在 26.1.0及以上，那么不需要额外导入 Lifecycle 库。

如果支持库版本小于 26.1.0 ，就需要单独导入 Lifecycle 库 ：

    implementation "android.arch.lifecycle:runtime:1.1.1"

本文以AndroidX为例：

实现Lifecycle有两种方式，一种是继承AppCompatActivity，第二种是继承自普通的 Activity。

方式一：继承自 AppCompatActivity的实现方式

（1）首先，我们创建一个 MyObserver.java 类，让它实现 LifecycleObserver 接口( LifecycleObserver 接口是一个空接口，主要是给注解处理器使用)，代码如下：

/**
 * author : Naruto
 * desc   : 管理Activity 和 Fragment 生命周期
 *  LifecycleObserver 接口是一个空接口，主要是给注解处理器使用
 *  我们通过在方法上使用@OnLifecycleEvent 注解使得该方法具有了生命周期感知能力。
 *  括号里面的参数，表明需要监听的是什么生命周期事件
 */
class MyLifecycleObserver : LifecycleObserver {
    private val TAG = "MyLifecycleObserver"

    //为了缩减文章长度，只保留两种生命周期。
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public fun onResume() {
        Log.e(TAG, "onResume")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public fun onDestroy() {
        Log.e(TAG, "onDestroy")
    }

}

（2）让我们的 Activity 继承自 AppCompatActivity，然后在 onCreate(…) 方法中通过getLifecycle().addObserver(new MyObserver())完成 Lifecycle 和LifecycleObserver 的绑定。

class LifecycleActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_lifecycle)
        //添加observer
        lifecycle.addObserver(MyLifecycleObserver())
    }
}

（3）运行程序，改变Activity的生命周期，就能看到MyObserver打印的日志了。

解析：AppCompatActivity 的父类类 ComponentActivity默认实现了 LifecycleOwner 接口，通过其 getLifecycle() 方法可以直接返回一个 Lifecycle 实例对象mLifecycleRegistry。之后我们就可以通过该对象的 addObserver(…) 方法将 Lifecycle 跟指定的 LifecycleObserver 进行绑定。

 

方式二：继承自普通的 Activity的实现方式，这是另一种实现方式

步骤1：同2.1创建MyObserver.java

步骤2:让我们的 Activity 继承自 普通的 Activity，现在我们需要自己实现LifecycleOwner接口。

现在这个Activity无法直接使用 getLifecycle() 方法来获取 Lifecycle 。现在，我们就需要自己实现LifecycleOwner接口，并在具体的生命周期下通过 LifecycleRegistry 的 setCurrentState()方法来主动进行生命周期事件的分发。

具体步骤

1）实现LifecycleOwner接口，实现该接口的对象，就是Lifecycle的持有者。

2）同时实现getLifecycle()方法，返回LifecycleRegistry对象。LifecycleRegistry是Lifecycle的子类。

3）通过addObserver将 Lifecycle 跟指定的 LifecycleObserver 进行绑定

4）在Activity的具体生命周期下，通过LifecycleRegistry 的 setCurrentState

()方法来主动进行生命周期事件的分发。

具体代码如下：

class LifecycleActivity_V2 : Activity(), LifecycleOwner {

    private val mLifecycleRegistry = LifecycleRegistry(this)
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_lifecycle__v2)
        lifecycle.addObserver(MyLifecycleObserver())
    }


    override fun onResume() {
        super.onResume()
        mLifecycleRegistry.currentState = Lifecycle.State.RESUMED
    }

    override fun onDestroy() {
        super.onDestroy()
        mLifecycleRegistry.currentState = Lifecycle.State.DESTROYED
    }

    override fun getLifecycle(): Lifecycle {
        return mLifecycleRegistry
    }

}

四：总结

Lifecycle 的实现机制是观察者模式。

1：观察者

创建一个类实现接口LifecycleObserver。实现该接口的类，通过在方法上添加注解的方式，可以对实现LifecycleOwner的类的生命周期进行感知。

2：被观察者

被观察者也就是实现LifecycleOwner接口的类，我们称之为Lifecycle对象。在类中，通过getLifecycle()这个方法，返回Lifecycle实例对象。如Activity。我们就需要在Acitivity的生命周期中，把生命周期的变化通知给观察者。

3.注册：

通过将 Lifecycle 对象的 addObserver() 方法，将 Lifecycle 对象和 LifecycleObserver 对象进行绑定。LifecycleObserver便可以观察到LifecycleOwner的生命周期事件。