Android Kotlin Jetpack之Lifecycles

前言

因为公司要用到Jetpack，所以这边也就聊聊下Jetpack之一的Lifecycles，顺便做下笔记来加深自己对这一块的理解

Jetpack

Jetpack是什么呢？Jetpack就一个开发集合包(就是我们平时用到的库那些)，用官方的话说就是

Android Jetpack 组件是库的集合，这些库是为协同工作而构建的，不过也可以单独采用，同时利用 Kotlin 语言功能帮助您提高工作效率。可全部使用，也可混合搭配！

Lifecycles

Lifecycles是Jetpack当中的一个来解决生命周期管理问题的组件通过监听生命周期的方式(Handling Lifecycles with Lifecycle-Aware Components)

常规来说，如果我们的类不是Activity的话(广播\碎片另说)，那么它是没有生命周期的。但在开发过程中，如我们的MVP模式，我们需要在Presenter里回调View的接口来更新UI，如果不对Presenter进行生命周期做处理的话，是很容易发生内存泄漏问题的，所以为了让Presenter感知Activity的生命周期，通常会写出如下代码

public interface IPresenter {
    void onCreate();
    void onStart();
    void onResume();
    void onPause();
    void onStop();
    void onDestroy();
}

Presenter实现这些接口，然后在对应的Activity里回调这些接口，完成生命周期管理。这个方法通俗易懂，好不好用另说，但代码量肯定多了，每个Presenter都要实现IPresenter 。
而Lifecycles就是实现这一功能而推出的，它是一个可以被其他对象观察其生命周期的类，Lifecycles是基于观察者模式实现的来对外响应生命周期的变化的，这里面有2个枚举变量Event和Evenet来一一对应(到时候看用法就知道了)。

导入

正常情况下使用Android studio 3.2 以上的版本新建项目都是可以直接用的(这段可以直接跳过)
首先我们要依赖Google仓库，在project -> build.gradle里

  repositories {
        //一般来说自动生成的项目都会默认依赖Google和Jcenter仓库的
        google()
        jcenter()
    }

然后是Module -> build.gradle

dependencies {
    def lifecycle_version = "2.0.0"

    // ViewModel and LiveData
    implementation "androidx.lifecycle:lifecycle-extensions:$lifecycle_version"
    // alternatively - just ViewModel
    implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version" // For Kotlin use lifecycle-viewmodel-ktx
    // alternatively - just LiveData
    implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
    // alternatively - Lifecycles only (no ViewModel or LiveData). Some UI
    //     AndroidX libraries use this lightweight import for Lifecycle
    implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"

    annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version" // For Kotlin use kapt instead of annotationProcessor
    // alternately - if using Java8, use the following instead of lifecycle-compiler
    implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

    // optional - ReactiveStreams support for LiveData
    implementation "androidx.lifecycle:lifecycle-reactivestreams:$lifecycle_version" // For Kotlin use lifecycle-reactivestreams-ktx

    // optional - Test helpers for LiveData
    testImplementation "androidx.arch.core:core-testing:$lifecycle_version"
}

这个是Google官方文档的导入说明，因为一般来说LiveData、ViewModel，Lifecycles都是会一起用到的，你可以看注释按需导入。

使用

我们可以让一个类实现LifecycleObserver接口后通过注解的方式来监听对应的生命周期

class MyObserver : LifecycleObserver{

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun lifecycleOnCreate(){
        Log.e(TAG,"lifecycleOnCreate")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun lifecycleOnStart(){
        Log.e(TAG,"lifecycleOnStart")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun lifecycleOnResume(){
        Log.e(TAG,"lifecycleOnResume")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun lifecycleOnPause(){
        Log.e(TAG,"lifecycleOnPause")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun lifecycleOnStop(){
        Log.e(TAG,"lifecycleOnStop")
    }

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

    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    fun lifecycleOnAny(){
        Log.e(TAG,"lifecycleOnAny")
    }
}

然后通过在相应的Activity里addObserver()即可完成监听(在onResume之前)，方便观察我们再在对应的生命周期打印log

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        lifecycle.addObserver(MyObserver())
        Log.e(TAG,"onCreate")
    }

    override fun onStart() {
        super.onStart()
        Log.e(TAG,"onStart")
    }

    override fun onResume() {
        super.onResume()
        Log.e(TAG,"onResume")
    }

    override fun onPause() {
        super.onPause()
        Log.e(TAG,"onPause")
    }

    override fun onStop() {
        super.onStop()
        Log.e(TAG,"onStop")
    }

    override fun onDestroy() {
        super.onDestroy()
        Log.e(TAG,"onDestroy")
    }
}

可以看到：

• onAny是在任何一个生命周期都会被调用
• Lifecycles的监听在onCreate()、onStart()、onResume()之后调用的，而onPause()、onStop()、onDestroy()则是之前调用

其实很容易理解Lifecycles如果在onPause()、onStop()、onDestroy()如果在之后调用的话，那我还有用他来干嘛，我就是要在那个时间段进行某些操作的，之后再调不就晚了？

LifecycleOwner

简单得说就是Activity需要实现LifecycleOwner才有刚刚上图说展示的Lifecycles效果，但是，如果你的Android Support 版本是v26.1.0以上，或者使用的是AndroidX，那么你可以不用理这个，因为谷歌已经帮我们弄好了

LifecycleOwner是一个有生命周期的接口，与LifecycleObserver里面的生命周期相对应，因为Lifecycles是基于观察者模式实现的，LifecycleObserver是观察者，那么被观察者就是LifecycleOwner。
而LifecycleOwner里面有一个getLifecycle()方法且必须被实现，是用来获取到观察者的。
在Activity里面使用Lifecycles时，关键是这一句代码

lifecycle.addObserver(MyObserver())

事实上lifecycle里调用的就是这个方法

  /**
     * Returns the Lifecycle of the provider.
     *
     * @return The lifecycle of the provider.
     */
    @Override
    public Lifecycle getLifecycle() {
        return super.getLifecycle();
    }

那么老版本的Activity要怎么实现LifecycleOwner呢？
实现LifecycleOwner接口，并在对应的生命周期进行操作(和IPresenter一模一样)

class MainActivity : AppCompatActivity(),LifecycleOwner {

    private lateinit var mLifecycleRegistry: LifecycleRegistry

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        mLifecycleRegistry = LifecycleRegistry(this)
        mLifecycleRegistry.markState(Lifecycle.State.CREATED)
        mLifecycleRegistry.addObserver(MyObserver())
    }

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

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

    override fun onPause() {
        super.onPause()
        mLifecycleRegistry.markState(Lifecycle.State.STARTED)
    }

    override fun onStop() {
        super.onStop()
        mLifecycleRegistry.markState(Lifecycle.State.CREATED)
    }

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

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

眼尖的小伙伴肯定看到了，onCreat()和onStop()共用了CREATED，onStart()和onPause()公用了STARTED这个状态，因为在Activity的生命周期里，这4个生命周期也是互相对应了，为了节省内存，谷歌干脆就共用了。

结语

到这里，Lifecycles的用法也已经说完了，如何用Lifecycles封装基类相信不用说大家也有个思路了，其实Lifecycles的用法不止这些，而之后的LiveData和ViewModel才是更厉害的，但这3个是相辅相成的，所以就先来讲下Lifecycles。