Jetpack学习笔录-LifecycleObserver

lifecycle本身是一个抽象类，位于androidx.lifecycle包，该包下有一些列生命周期感知型的组件。

lifecycle主要用于存储有关组件的生命周期状态信息，比如activity,fragment,或者是整个应用的生命周期。

跟踪生命周期主要由：状态和事件 这两个表示。

来张官网的图感受一下

新建项目，创建一个新的empty Aactivity ，默认都是继承自AppCompatActivity的，查找其父类，发现ComponentActivity实现了LifecycleOwner接口。

结合LifeCycleObserver来说明.

LifecycleObserver

LifecycleOwner 是单一方法接口，表示类具有 Lifecycle。它具有一种方法（即 getLifecycle()），该方法必须由类实现。如果您尝试管理整个应用进程的生命周期，请参阅 ProcessLifecycleOwner。

 代码示例

1、我们先创建一个观察者类，继承LifecycleObserver接口。在该类中，创建方法，并使用相应注解标注该方法监听的生命周期事件

class MyObserver : LifecycleObserver {


    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun create() {
        showLog("观察者调用了create方法")
    }


    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun start() {
        showLog("观察者调用了Start方法")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun resume() {
        showLog("观察者调用了resume方法")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun pause() {
        showLog("观察者调用了pause方法")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun stop() {
        showLog("观察者调用了stop方法")
    }


    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun destry() {
        showLog("观察者调用了destry方法")
    }
//
//    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
//    fun anyMethod() {
//        showLog("观察者调用了anyMethod方法")
//    }
}

有一个Lifecycle.Event.ON_ANY方法，该方法会在其他监听方法执行完后再执行。

2、在activity或者fragment中拿到lifecycle对象，并注册我们创建的观察者类

class MainActivity : AppCompatActivity() {

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

        showLog("activity的onCreate执行")

        //注册观察者类
        lifecycle.addObserver(MyObserver())

    }

    override fun onStart() {
        super.onStart()
        showLog("activity的onStart执行")
    }

    override fun onResume() {
        super.onResume()
        showLog("activity的onResume执行")
    }

    override fun onPause() {
        super.onPause()
        showLog("activity的onPause执行")
    }

    override fun onStop() {
        super.onStop()
        showLog("activity的onStop执行")
    }

    override fun onDestroy() {
        super.onDestroy()
        showLog("activity的onDestroy执行")
    }

    fun second(view: View) {
        startActivity(Intent(MainActivity@this, SecondActivity::class.java))
    }
}

这里我把activity的生命周期都重写打印下，看下谁先执行。

可以发现，在创建activity的过程中，生命周期方法到onResume前，都是activity的生命周期方法先走，然后才回调我们创建的观察者的对应方法。

现在跳转到第二页看看

发现是我们创建的观察者方法先走，然后才走activity的相应生命周期方法。

从第二页返回第一页同理，先走activity生命周期方法，然后回调我们创建的类的方法

相比于在activity中的每个生命周期方法加代码，lifecycleObserver可以说是减少了不少activity的代码。在一定程度上做到了代码解耦~

状态查询

fun doSomething() {

        //如果当前是在onResume状态下
        if (lifecycle.currentState.isAtLeast(Lifecycle.State.RESUMED)) {

            //todo...
        }
    }

通过getLifecycle()方法获取到lifecycle就可以调用getCurrentState()方法获取大当前状态了

自定义LifecycleOwner 

activity和fragment都是实现了LifecycleOwner接口的，当然我们也可以自定义。

public interface LifecycleOwner {
    /**
     * Returns the Lifecycle of the provider.
     *
     * @return The lifecycle of the provider.
     */
    @NonNull
    Lifecycle getLifecycle();
}

 可以看到LifecycleOwner接口只有一个获得Lifecycle的方法，所以自定义类实现LifecycleOwner接口的核心就是返回一个创建好的Lifecycle对象了。如果我们创建的自定义类是fragment或者是activity,可以直接使用已经自带的LifecycleRegistry类啦~。下面用这个LifecycleRegistry类举个小栗子~

class MyView : LifecycleOwner {

    private val lifecycleRegistry: LifecycleRegistry = LifecycleRegistry(this)

    override fun getLifecycle(): Lifecycle {
        return lifecycleRegistry
    }

    init {
        lifecycleRegistry.markState(Lifecycle.State.CREATED)
    }

    fun onResume(){
        lifecycleRegistry.markState(Lifecycle.State.RESUMED)
    }

}

这里我创建一个MyView的类，实现LifecycleOwner接口。内部创建好一个LifecycleRegistry对象。并让getLifecycle()方法返回该对象。然后就是可以随心所欲的设置方法了，在需要的方法中标记该方法对应的状态即可。

下面是在acttivity中创建出MyView的类，然后MyView去添加一个观察者，使用前面用过的MyObserver。

class MainActivity : AppCompatActivity() {

    private lateinit var myView: MyView

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


        myView = MyView()
        myView.lifecycle.addObserver(MyObserver())

        myView.onResume()

    }
    
}

我调用了MyView的onResume方法，这个方法标注了是RESUME状态~log日志可以看到，观察者回调了相应方法

这个组件也很简单，主要就是可以观察activity和fragment的生命周期，在自己的类中写相关方法，不用在activity或者frament的生命周期方法中额外调用xxx方法这样~。减少一些生命周期中调用其他类方法的逻辑。

版本2.4之后

 具体链接：https://developer.android.google.cn/jetpack/androidx/releases/lifecycle#kotlin

这里是放弃了使用注解的方式了

为啥放弃呢？

This annotation required the usage of code generation or reflection, which should be avoided.

从官方文档的注释可以看到，注解要么依赖反射降低运行时性能，要么依靠 APT 降低编译速度，不是完美的方案。

我们之所引入注解，无非是不想多实现几个空方法。早期 Android 工程不支持 Java8 编译，接口没有 default 方法， 现如今 Java8 已经是默认配置，可以为接口添加 default 方法，此时注解已经失去了存在的意义。
 

官方给出了2个替代方案：LifecycleEventObserver和DefaultLifecycleObserver。

DefaultLifecycleObserver在2.4以前也能用。

下面看具体使用：

 

 

 

 

 同样使用起来很方便哈~

参考：

@OnLifecycleEvent 遭废弃，推荐使用 DefaultLifecycleObserver 替代