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")
}
}
正经文字的书面说法
在 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，以及分发宿主状态事件给它们。