Android lifecycle的使用

引言

lifecycle 是属于Android Jetpack（官方开发工具包）—— Architecture（架构组件）中的一员。

【官方介绍】构建生命周期感知型组件，这些组件可以根据 Activity 或 Fragment 的当前生命周期状态调整行为。

其实就是实现生命周期监听，做些逻辑。

1. 应用场景

• 控制视频缓冲的开始与停止：启动App的时候可以更快的开始缓冲视频，App销毁时停止缓冲。
• 开始和停止网络连接：应用位于前台时可能需要实时传输数据，并在应用进入后台时自动暂停。
• 控制页面动画的启动与停止：动画在页面可见时进行播放，不可见时停止。

2. 示例

class MainActivity: AppCompatActivity{
	/**网络监听器*/
	val mNet = NetListener()
	/**视频播放器*/
	val mPlayer = VideoPlayer()
	
	override fun onStart(){
		mNet.connect()// 网络开始连接
		mPlayer.startCache()// 视频开始缓冲
		耗时任务（）
		// 其他业务逻辑...
	}
	
	override fun onStop(){
		mNet.cancel()// 网络断开
		mPlayer.releaseCache()// 视频释放缓存
		// 其他业务逻辑...
	}
}

思考一下：

1、我们在生命周期的回调方法中做了很多事情，一旦代码多了后，是很难维护的。

2、另外,在页面停止时，其他生命周期（如onStart）有耗时任务，这时有可能onStop先结束，而耗时的组件，还存在。

3、随着业务复杂，也容易出bug。这就需要本文的主角Lifecycle来感知生命周期的变化，解耦出去这些逻辑，并自动在适当的生命周期内执行。

Lifecycle使用

先说使用的

除了Activity和Fragment外，还可以绑定Service和Application的生命周期。

只要引入支持相关的可选库即可；官方提到最多的是Activity和Fragment，是因为平时主要用于这两个组件；其实只要有生命周期的组件都可以跟它绑定。而在Android中大多数的组件都是有生命周期的。

这里有三个名词  Lifecycle     LifecycleOwner     lifecycleOberver

Lifecycle

Lifecycle是一个抽象类，用来存储生命周期状态的；

源码：

在lifecycle抽象类中，定义了抽象方法，addOberrver和removeObserver,这是经典的被观察者

LifecycleOwner（被观察者）

LifecycleOwner: 我的理解这是一个被观察者接口，他持有一个lifecycle，这个lifecycle就是被观察者中的事件，观察者想观察的事件，就是lifecycle的状态

其实就是一个接口，一个获取lifecycle对象的方法

那么到这里，就知道了，只要实现了lifecycleOwner接口的对象，都会持有一个lifecycle的对象，那么实际上，lifecycleOwner本没有添加观察者的能力，添加观察者实际是在lifecycle对象中实现的

lifecycleOberver（观察者）

lifecycleOberver:前面被观察者找到了，那么观察者也应该现身了，就是他，也是一个接口，实现该接口的对象，通过注解的方式，被lifecycleOwner代理被观察者注册为观察者，此后就能观察到lifecycle的状态改变

从上面lifecycle的源码中可以看到，addOberver(LifecycleOberver oberver)，添加的观察者就是LifecycleOberver

就是一个接口，也就是说实现了这个接口的类，就可以是lifecycle的观察者

项目中使用

baseViewModel

package com.XXXX.testgradle

import androidx.lifecycle.DefaultLifecycleObserver
import androidx.lifecycle.LifecycleOwner
import androidx.lifecycle.ViewModel

//viewModel  的基类  实现了  DefaultLifecycleObserver 等于实现了lifeCycleObserver 从此继承BaseViewModel就是lifeCycle的观察者
class BaseViewModel :ViewModel() ,DefaultLifecycleObserver  {

    protected lateinit var owner :LifecycleOwner //观察者应持有一个被观察者对象

    override fun onCreate(owner: LifecycleOwner) {
       this.owner = owner
    }

    override fun onDestroy(owner: LifecycleOwner) {
        super.onDestroy(owner)
        onCleared()
    }

    override fun onCleared() {
        super.onCleared()
    }



}

继承了ViewModel抽象类，并实现了DefaultLifecycleObserver

BaseViewModel变成了一个实现了LifecycleObserver的观察者，并且我们可以重写onCreate获得被观察者，这个onCreate()来自哪里呢

看DefaultLifecycleObserver  源码：

写的很明白了，当lifecycle的生命周期发生变换的时候，这些方法就会执行。

那么此时我们是不是就变成了有生命周期感知了，那么我们继续追踪lifecycleOwner的来源。

MineViewModel代码：

package com.XXXXXX.testgradle

import androidx.lifecycle.LifecycleOwner

//MineViewModel 是实现了 LifecycleObserver接口的观察者
class MineViewModel : BaseViewModel() {

   private var myOwner : LifecycleOwner?  = null  // 被观察者

   private var repository :RequestRepository?= null

    fun start(){
        repository = RequestRepository()
    }

    /**
     * 我们这个onCreate是回调方法
     * 通知ON_CREATE 事件发生。
     * 这个方法将在lifecycleOwner的onCreate 方法返回后被调用。
     * 参数：
     * 所有者  ---- 状态被更改的组件（activity，Fragment,自定义组件等实现了LifecycleOwner接口的组件）
     * 也就是说，当我们的被观察者指向onCreate时，我们作为观察者，就会收到这个方法的回调
     * @param owner
     * 这个时候，我们就要去到 MineViewModel和 MineActivity绑定的地方了。那就是BaseActivity中，在baseActivity 中我们实现了viewModel的绑定
     */
    override fun onCreate(owner: LifecycleOwner) {
        super.onCreate(owner)
        repository?.onCreate(owner)

    }


}

怎么让仓库层也能感应生命周期的变化呢？

我们需要做一些操作赋予它生命周期的感应功能

新建一个接口

package com.XXXXX.testgradle

import androidx.lifecycle.LifecycleOwner

interface MyLifecycle {
    //定义两个函数 ，形参都是lifecycleOwner接口， 也就是被观察者
    fun onCreate( owner: LifecycleOwner)

    fun onDestory( owner: LifecycleOwner)
    
}

这个接口就定义两个函数，onCreate()和onDestory(),

参数就是被观察者，参数肯定是被观察者，因为我们要感知生命周期，那生命周期肯定就是被观察者。

写一个基类仓库层，实现接口

package com.XXXXX.testgradle

import androidx.lifecycle.LifecycleOwner


class BaseRepository : MyLifecycle{
    override fun onCreate(owner: LifecycleOwner) {
        //做一些初始化
    }

    override fun onDestory(owner: LifecycleOwner) {
        //可以做一些资源释放
        
    }
}

这样写的好处是可以在基类做一些其他的事情

来到我们实际的仓库层

package com.XXXXX.testgradle

import androidx.lifecycle.LifecycleOwner

class RequestRepository : BaseRepository() {

    private var owner:LifecycleOwner? = null

    //这里模拟请求到数据
    fun getMineInfoData(): Int {
        return 100
    }

    override fun onCreate(owner: LifecycleOwner) {
        super.onCreate(owner)
        this.owner = owner
    }

    override fun onDestory(owner: LifecycleOwner) {
        super.onDestory(owner)
        
    }

}

在实际的仓库层中，我们就能获得生命周期被观察者LifecycleOwner，那么这里是获取到，获取的是谁呢？

回到刚刚的MineViewModel中，

repository?.onCreate(owner)

在MainViewModel的onCrate中调用仓库层的onCreate()，

因为viewModel的onCreate是 被观察者即(封装的BaseActivity)

 lifecycle的ON_START事件的回调

那么此时我们的仓库层，也就是  拥有了生命周期的被观察者   且

我们仓库层和被观察者的ON_START事件和ON_DESTORY事件  同步   上了。

到现在我们还没找到LifecycleOwner从哪里传来的呢？继续追踪

我们的MineViewModel是和自己的Activity绑定的，绑定在哪里执行呢，在我们封装的BaseActivity中，我们在这创建了viewModel，然后呢，直接给它注册到被观察者里面去啊！！

 我们追踪Activity的继承关系，发现在ComponetActivity类中实现了LifecycleOwner和ViewModelStoreOwner接口。（被观察者实现对象）

那么Activity就是    被观察者。