Android Jetpack | Lifecycle

一.前言

• 本篇主线包含三点，Lifecycle的作用、简单使用、核心原理（包含核心类与源码主线分析）；

二.作用

• 官方文档
• 生命周期感知型组件可执行操作来响应另一个组件（如 Activity 和 Fragment）的生命周期状态的变化。这些组件有助于您写出更有条理且往往更精简的代码，这样的代码更易于维护。

三.使用

3.1.依赖

• 仅针对 lifecycle-common-java8 依赖方式（另一种依赖其实现细节方面的区别在于使用了反射相关的逻辑，将一个方面梳理清楚，另一个方面只要具备了反射相关的知识，分析就比较容易）进行分析，适用于Java8及以上环境

    def lifecycle_version = "2.9.2"implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

3.2.代码

• 新建TestObserver类

public class TestObserver implements DefaultLifecycleObserver {private static final String TAG = "TestObserver ";@Overridepublic void onCreate(@NonNull LifecycleOwner owner) {Log.d(TAG, "onCreate: ");}@Overridepublic void onStart(@NonNull LifecycleOwner owner) {Log.d(TAG, "onStart: ");}@Overridepublic void onResume(@NonNull LifecycleOwner owner) {Log.d(TAG, "onResume: ");}@Overridepublic void onPause(@NonNull LifecycleOwner owner) {Log.d(TAG, "onPause: ");}@Overridepublic void onStop(@NonNull LifecycleOwner owner) {Log.d(TAG, "onStop: ");}@Overridepublic void onDestroy(@NonNull LifecycleOwner owner) {Log.d(TAG, "onDestroy: ");}
}

• MainActivity类中添加getLifecycle().addObserver(new TestObserver());

public class MainActivity extends AppCompatActivity {@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);getLifecycle().addObserver(new TestObserver());}
}

3.3.好处

• 当MainActivity生命周期函数，onCreate、onStart、onResume、onPause、onStop、onDestroy被调用时，会触发TestObserver类中对应的回调函数。如果不使用Lifecycle，则写出的代码明显没有这种方式简洁和便于管理。

四.实现原理

• 为什么按照上面的方式来写就能实现生命周期感知呢？接下来是我们需要探讨的内容。上方所依赖的版本是基于观察者模式实现的。我们先梳理出核心类以及被观察者、观察者、建立被观察者和观察者之间的联系。

4.1.核心类

• LifecycleOwner 接口

  • MainActivity间接继承的类-ComponentActivity中实现的接口；

• LifecycleObserver 接口

  • TestObserver间接实现的接口（DefaultLifecycleObserver实现的接口）；

• LifecycleRegistry 类

  • 聚合多个 LifecycleObserver ，生命周期改变时通知 LifecycleObserver 进行相应的方法调用；
  • 该类在ComponentActivity中有对应的成员变量

  private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
  

• ObserverWithState 类

  • LifecycleRegistry 中的内部类，对LifecycleObserver进行包装；

4.2.观察者模式的角色及联系方式

• 被观察者：直接或间接实现LifecycleOwner接口；
  • 即：MainActivity类；
• 观察者：直接或间接实现LifecycleObserver接口；
  • 即：TestObserver类；
• 被观察者和观察者建立关联：调用Lifecycle的addObserver函数，函数参数为观察者对象；

4.3.触发逻辑

• 被观察者的生命周期函数发生变化时通知观察者；

4.4.源码分析

• 目标：只分析主干，梳理Lifecycle的实现原理即可；
• 以addObserver函数作为分析的入口。

4.4.1.对应LifecycleRegistry类中的addObserver函数

@MainThread
actual override fun addObserver(observer: LifecycleObserver) {enforceMainThreadIfNeeded("addObserver")val initialState = if (state == State.DESTROYED) State.DESTROYED else State.INITIALIZEDval statefulObserver = ObserverWithState(observer, initialState)//注释1val previous = observerMap.putIfAbsent(observer, statefulObserver)//注释2//...
}

• 注释1，ObserverWithState 类是对observer的包装
• 注释2，observerMap：这个类是一个自定义列表，用于保存观察者并可在遍历期间处理删除/添加，对应LifecycleRegistry类中的成员变量

private var observerMap = FastSafeIterableMap<LifecycleObserver, ObserverWithState>()

4.4.2.以onCreate函数作为触发条件进行分析

• 在分析触发条件之前，先分析相关的初始化工作
• 在ComponentActivity类的onCreate函数

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {//...ReportFragment.injectIfNeededIn(this);//...
}

• ReportFragment.injectIfNeededIn(this)代码。
  • 这里做了一个区分，当大于等于API29时，通过注册回调的方式。低于则使用无页面的Fragment（ReportFragment）；

@JvmStatic
public fun injectIfNeededIn(activity: Activity) {if (Build.VERSION.SDK_INT >= 29) {// On API 29+, we can register for the correct Lifecycle callbacks directlyLifecycleCallbacks.registerIn(activity)}val manager = activity.fragmentManagerif (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {manager.beginTransaction().add(ReportFragment(), REPORT_FRAGMENT_TAG).commit()manager.executePendingTransactions()}
}

• 不论是哪一种API都会执行到下面的方法，参数1是ReportFragment 当前关联的 Activity，参数2是Lifecycle中定义的枚举事件，在4.4.3中单独分析；

@JvmStatic
internal fun dispatch(activity: Activity, event: Lifecycle.Event) {if (activity is LifecycleRegistryOwner) {activity.lifecycle.handleLifecycleEvent(event)return}if (activity is LifecycleOwner) {val lifecycle = (activity as LifecycleOwner).lifecycleif (lifecycle is LifecycleRegistry) {lifecycle.handleLifecycleEvent(event)}}
}

• 总结：

  • 无UI的ReportFragment使用了6个生命周期函数onActivityCreated、onStart、onResume、onPause、onStop、onDestroy，调用dispatch函数，分别传入不同的Event。因为Fragment生命周期函数与Activity生命周期函数调用时机的关系，无UI的ReportFragment的生命周期函数的调用约等于Activity几个函数的调用。
  • 而LifecycleCallbacks对Activity生命周期函数的触发做了监听。

• 综上：当Activity的onCreate函数调用时，则会发送Lifecycle.Event.ON_CREATE事件来调用internal fun dispatch(activity: Activity, event: Lifecycle.Event)函数。其它几个事件同理，到此，触发条件我们也就梳理清楚了。

4.4.3.状态机

• 学习Lifecycle的核心原理，对状态机部分的了解是必不可少的。4.4.2中所提到的Lifecycle.Event是Lifecycle中定义的枚举事件，Lifecycle中除了定义Event还定义了State，Event和State（对应矩形标记的内容）的对应关系，称为状态机（根据Event推算State，或根据State推算Event，从左往右是UI从不可见到可见的方向，反之，由可见到不可见的方向），如下图所示：
  

4.4.4.继续分析dispatch(activity: Activity, event: Lifecycle.Event)函数

• 根据上方代码可以知道，activity is LifecycleOwner & lifecycle is LifecycleRegistry 是成立的，执行LifecycleRegistry类的handleLifecycleEvent函数。

public actual open fun handleLifecycleEvent(event: Event) {enforceMainThreadIfNeeded("handleLifecycleEvent")//根据事件，先得到当前activity应该出现的下一个状态moveToState(event.targetState)
}private fun moveToState(next: State) {//...sync()//重点关注//...
}//作用：同步生命周期状态，当被观察生命周期发生改变时，通知所有的观察者进行同步
private fun sync() {val lifecycleOwner =lifecycleOwner.get()?: throw IllegalStateException("LifecycleOwner of this LifecycleRegistry is already " +"garbage collected. It is too late to change lifecycle state.")        while (!isSynced) {newEventOccurred = falseif (state < observerMap.eldest()!!.value.state) {backwardPass(lifecycleOwner)}val newest = observerMap.newest()if (!newEventOccurred && newest != null && state > newest.value.state) {forwardPass(lifecycleOwner)}}newEventOccurred = false_currentStateFlow.value = currentState
}

• 分析：isSynced

private val isSynced: Booleanget() {//没有观察者时返回trueif (observerMap.size() == 0) {return true}//获取最先添加进来的观察者生命周期状态val eldestObserverState = observerMap.eldest()!!.value.state//获取最后（最近）添加进来的观察者生命周期状态val newestObserverState = observerMap.newest()!!.value.state//如果最先的和最后的Observer的状态一致 && 当前Observer的状态和state保存的状态一致时，返回true，否则就返回falsereturn eldestObserverState == newestObserverState && state == newestObserverState}

• 观察者具体同步逻辑在backwardPass和forwardPass中，分析其中一个即可

private fun forwardPass(lifecycleOwner: LifecycleOwner) {@Suppress()//使用observerMap 返回一个按添加顺序遍历的迭代器val ascendingIterator: Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> =observerMap.iteratorWithAdditions()while (ascendingIterator.hasNext() && !newEventOccurred) {//从 Map.Entry 中提取，observer为ObserverWithState 对象，封装了观察者及其当前状态val (key, observer) = ascendingIterator.next()while (observer.state < state && !newEventOccurred && observerMap.contains(key)) {pushParentState(observer.state)val event =Event.upFrom(observer.state)?: throw IllegalStateException("no event up from ${observer.state}")//调用observer（即：ObserverWithState 对象）的dispatchEvent函数observer.dispatchEvent(lifecycleOwner, event)popParentState()}}
}

• 分析observer（ObserverWithState）.dispatchEvent(lifecycleOwner, event)

internal class ObserverWithState(observer: LifecycleObserver?, initialState: State) {var state: Statevar lifecycleObserver: LifecycleEventObserverinit {//下方分析lifecycleObserver = Lifecycling.lifecycleEventObserver(observer!!)state = initialState}fun dispatchEvent(owner: LifecycleOwner?, event: Event) {val newState = event.targetStatestate = min(state, newState)//调用lifecycleObserver的onStateChanged函数lifecycleObserver.onStateChanged(owner!!, event)state = newState}}

• 分析lifecycleObserver = Lifecycling.lifecycleEventObserver(observer!!) & lifecycleObserver的onStateChanged函数

//Lifecycling类中
public actual fun lifecycleEventObserver(`object`: Any): LifecycleEventObserver {val isLifecycleEventObserver = `object` is LifecycleEventObserverval isDefaultLifecycleObserver = `object` is DefaultLifecycleObserverif (isLifecycleEventObserver && isDefaultLifecycleObserver) {return DefaultLifecycleObserverAdapter(`object` as DefaultLifecycleObserver,`object` as LifecycleEventObserver)}if (isDefaultLifecycleObserver) {//分析DefaultLifecycleObserverAdapterreturn DefaultLifecycleObserverAdapter(`object` as DefaultLifecycleObserver, null)}if (isLifecycleEventObserver) {return `object` as LifecycleEventObserver}val klass: Class<*> = `object`.javaClassval type = getObserverConstructorType(klass)if (type == GENERATED_CALLBACK) {val constructors = classToAdapters[klass]!!if (constructors.size == 1) {val generatedAdapter = createGeneratedAdapter(constructors[0], `object`)return SingleGeneratedAdapterObserver(generatedAdapter)}val adapters: Array<GeneratedAdapter> =Array(constructors.size) { i -> createGeneratedAdapter(constructors[i], `object`) }return CompositeGeneratedAdaptersObserver(adapters)}return ReflectiveGenericLifecycleObserver(`object`)
}

• 在我们前面所使用的观察者TestObserver是实现了DefaultLifecycleObserver接口，则在lifecycleEventObserver函数中执行的是下方的代码

if (isDefaultLifecycleObserver) {return DefaultLifecycleObserverAdapter(`object` as DefaultLifecycleObserver, null)}

• 分析DefaultLifecycleObserverAdapter类

internal class DefaultLifecycleObserverAdapter(private val defaultLifecycleObserver: DefaultLifecycleObserver,private val lifecycleEventObserver: LifecycleEventObserver?
) : LifecycleEventObserver {override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {when (event) {Lifecycle.Event.ON_CREATE -> defaultLifecycleObserver.onCreate(source)Lifecycle.Event.ON_START -> defaultLifecycleObserver.onStart(source)Lifecycle.Event.ON_RESUME -> defaultLifecycleObserver.onResume(source)Lifecycle.Event.ON_PAUSE -> defaultLifecycleObserver.onPause(source)Lifecycle.Event.ON_STOP -> defaultLifecycleObserver.onStop(source)Lifecycle.Event.ON_DESTROY -> defaultLifecycleObserver.onDestroy(source)Lifecycle.Event.ON_ANY ->throw IllegalArgumentException("ON_ANY must not been send by anybody")}lifecycleEventObserver?.onStateChanged(source, event)}
}

• 到此，返回到ObserverWithState中，可以知晓：lifecycleObserver = Lifecycling.lifecycleEventObserver(observer!!) 等价于 lifecycleObserver = DefaultLifecycleObserverAdapter，调用lifecycleObserver.onStateChanged(owner!!, event)时会执行DefaultLifecycleObserverAdapter的onStateChanged函数，该函数中，每一个事件，都会触发一个不同的回调函数，即：对应DefaultLifecycleObserver实现类TestObserver中的，从Activity生命周期的执行到观察者TestObserver对应函数的执行，整个流程分析完毕。

4.5.执行流程

• 结合源码分析，代码执行流程大体如下
  

五.总结

• Activity里面lifecycle事件的分发会根据API的不同其实现有差异，大于等于29是采用注册的回调的方式，低于29是使用无UI的ReportFragment来实现lifecycle事件的分发；
• 宿主的每一个生命周期发生变化的时候会发送一个事件，根据事件推导宿主的状态，所有的观察者根据宿主的状态进行升级或降级以保持同步；