Jetpack组件之Lifecycle

Lifecycle 管理activity和fragment的生命周期
刚开始看的时候云里雾里，不知道讲的什么东东，一脑门啥啥啥？
后来懂了一点点，就用口语大概总结下，再放一些官方的文字。
总体就是利用观察者模式，订阅宿主(activity或者fragment)的生命周期函数，然后分发给观察者，自动调用观察者绑定的函数方法。
比如，想在activity的onStart()方法中调用开始，在onDestory()方法中调用停止，创建一个观察者类（实现lifecycleObserve），绑定相应的事件，然后把这个观察者添加到Lifecycle中即可
因此在生命周期组件的生命周期发生变化时告诉观察者，内部组件即可感知外部的生命周期
下面是写的一个demo 测试

创建观察者

package com.shadow.jetpackdemo.lifecycle;

import android.util.Log;

import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleObserver;
import androidx.lifecycle.LifecycleOwner;
import androidx.lifecycle.OnLifecycleEvent;

/**
 * @author 付影影
 * @desc 在对应方法上用注解声明想要观察的宿主的生命周期事件即可
 * @date 2020/7/27
 */
public class LocationObserver implements LifecycleObserver {
    private LifecycleOwner mLifecycleOwn;

    public LocationObserver(LifecycleOwner mLifecycleOwn) {
        this.mLifecycleOwn = mLifecycleOwn;
        //注册观察者 观察宿主(即调用该类的fragment或者activity)生命周期的状态变化
        mLifecycleOwn.getLifecycle().addObserver(this);
    }

    /**
     * 绑定宿主的生命周期
     * 就不用必须在宿主的相关生命周期方法中 调用相应的注册或者取消注册方法
     */

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    void onStart(){
        Log.d("hh","LocationObserver 我当前所在宿主的生命周期是onStart");
    }

    /**
     * 宿主 执行onStop时候，会分发该事件，执行此类的onStop方法，类似观察者订阅
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    void onStop(){
        Log.d("hh","LocationObserver 我当前所在宿主的生命周期是onStop");
    }

}

创建被观察者宿主

package com.shadow.jetpackdemo

import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
import com.shadow.jetpackdemo.lifecycle.LocationObserver

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        Log.d("hh","MainActivity -- onCreate")
        setContentView(R.layout.activity_main)
        val localObserve = LocationObserver(this)
    }

    override fun onStart() {
        super.onStart()
        Log.d("hh","MainActivity -- onStart")
    }

    override fun onResume() {
        super.onResume()
        Log.d("hh","MainActivity -- onResume")
    }

    override fun onPause() {
        super.onPause()
        Log.d("hh","MainActivity -- onPause")
    }

    override fun onStop() {
        super.onStop()
        Log.d("hh","MainActivity -- onStop")
    }

    override fun onDestroy() {
        super.onDestroy()
        Log.d("hh","MainActivity -- onDestroy")
    }


}

1111.png

正经文字的书面说法

在 Android 框架中定义的大多数应用组件都存在生命周期。
生命周期由操作系统或进程中运行的框架代码管理。它们是 Android 运作方式的核心，应用必须遵循它们。如果不这样做，可能会引发内存泄露甚至应用崩溃。
在android开发中，很多功能的实现都需要在不同的生命周期中进行相应操作的调用，
比如说地图，定位需要在onStart中执行start操作，在onStop中执行stop操作；
还有播放器需要在onStart中的进行连接，在onStop中进行中断连接的操作。
如果我们忘记了在onStop或者onDestory中释放资源，那么就会导致内存泄漏的问题。
如果有所有的组件，都能感知外部的生命周期，能在相应的时机释放资源，并且在错过生命周期时能及时叫停异步的任务就好了

Lifecycle 是具备宿主声明后期感知能力的组件。它能持有组件（如 Activity 或 Fragment）生命周期状态的信息，并且允许其他观察者监听宿主的状态

假设我们有一个在屏幕上显示设备位置的 Activity。常见的实现可能如下所示：

    internal class MyLocationListener(
            private val context: Context,
            private val callback: (Location) -> Unit
    ) {

        fun start() {
            // connect to system location service
        }

        fun stop() {
            // disconnect from system location service
        }
    }

    class MyActivity : AppCompatActivity() {
        private lateinit var myLocationListener: MyLocationListener

        override fun onCreate(...) {
            myLocationListener = MyLocationListener(this) { location ->
                // update UI
            }
        }

        public override fun onStart() {
            super.onStart()
            myLocationListener.start()
            // manage other components that need to respond
            // to the activity lifecycle
        }

        public override fun onStop() {
            super.onStop()
            myLocationListener.stop()
            // manage other components that need to respond
            // to the activity lifecycle
        }
    }

虽然此示例看起来没问题，但在真实的应用中，最终会有太多管理界面和其他组件的调用，以响应生命周期的当前状态。管理多个组件会在生命周期方法（如 [onStart()] 和 [onStop()]中放置大量的代码，这使得它们难以维护。

此外，无法保证组件会在 Activity 或 Fragment 停止之前启动。在我们需要执行长时间运行的操作（如 [onStart()] 中的某种配置检查）时尤其如此。这可能会导致出现一种竞争条件，在这种条件下，[onStop()] 方法会在 [onStart()] 之前结束，这使得组件留存的时间比所需的时间要长。

Lifecycle 的三种写法

Lifecycle 有三种实现方法，下面我们一一来介绍一下：

使用 Lifecycle 前需要先添加依赖：

 //通常情况下，只需要添加appcompat就可以了
api 'androidx.appcompat:appcompat:1.1.0'
 //如果想单独使用，可引入下面这个依赖
api 'androidx.lifecycler:lifecycle-common:2.1.0'

LifecycleObserver 配合注解：

//1\. 自定义的LifecycleObserver观察者，在对应方法上用注解声明想要观  察的宿主的生命周期事件即可
class LocationObserver extends LifecycleObserver{
    //宿主执行了onstart时，会分发该事件
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    void onStart(@NotNull LifecycleOwner owner){
      //开启定位
    }

  //宿主执行了onstop时 会分发该事件
  @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
  void onStop(@NotNull LifecycleOwner owner){
     //停止定位
  }
 }

//2\. 注册观察者,观察宿主生命周期状态变化
class MyFragment extends Fragment{
  public void onCreate(Bundle bundle){
    LocationObserver observer =new LocationObserver()
    getLifecycle().addObserver(observer);
  }
 }

FullLifecyclerObserver 拥有宿主所有生命周期事件：

//1.源码
interface FullLifecycleObserver extends LifecycleObserver {
    void onCreate(LifecycleOwner owner);
    void onStart(LifecycleOwner owner);
    void onResume(LifecycleOwner owner);
    void onPause(LifecycleOwner owner);
    void onStop(LifecycleOwner owner);
    void onDestroy(LifecycleOwner owner);
}
//2.用法,需要监听那个事件，复写那个方法即可
class LocationObserver extends FullLifecycleObserver{
    void onStart(LifecycleOwner owner){}
    void onStop(LifecycleOwner owner){}
}

LifecycleEventObserver宿主生命周期事件封装成 Lifecycle.Event

//1.源码
public interface LifecycleEventObserver extends LifecycleObserver {
    void onStateChanged(LifecycleOwner source, Lifecycle.Event event);
}
//2.用法 
class LocationObserver extends LifecycleEventObserver{
    @override
    void onStateChanged(LifecycleOwner source, Lifecycle.Event event){
      //需要自行判断life-event是onstart, 还是onstop
    }
}

上面的这三种 Lifecycle 写法比较推荐第二、第三种，因为第一种你虽然用注解很爽，但是如果没有添加 lifecycle-compiler 这个注解处理器的话，运行时会使用反射的形式回调到对应的方法上。

LifecycleOwner、Lifecycle、LifecycleRegistry 的关系

事件在分发宿主生命周期事件的流程中涉及到三个类，我们分别来捋一捋：

LifecycleOwner：我们的 Activity/Fragment 都实现了该接口，用以声明它是一个能够提供生命周期事件的宿主。同时必须复写getLifecycle()方法提供一个Lifecycle对象；
Lifecycle：是一个抽象类，里面定义了两个枚举State宿主的状态，Event 需要分发的事件的类型；
LifecycleRegistry: 是 Lifecycle 的唯一实现类，主要用来负责注册 Observer，以及分发宿主状态事件给它们。