一.前言
- 本篇主线包含三点，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 ";
@Override
public void onCreate(@NonNull LifecycleOwner owner) {
Log.d(TAG, "onCreate: ");
}
@Override
public void onStart(@NonNull LifecycleOwner owner) {
Log.d(TAG, "onStart: ");
}
@Override
public void onResume(@NonNull LifecycleOwner owner) {
Log.d(TAG, "onResume: ");
}
@Override
public void onPause(@NonNull LifecycleOwner owner) {
Log.d(TAG, "onPause: ");
}
@Override
public void onStop(@NonNull LifecycleOwner owner) {
Log.d(TAG, "onStop: ");
}
@Override
public void onDestroy(@NonNull LifecycleOwner owner) {
Log.d(TAG, "onDestroy: ");
}
}
- MainActivity类中添加getLifecycle().addObserver(new TestObserver());
public class MainActivity extends AppCompatActivity {
@Override
protected 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.INITIALIZED
val statefulObserver = ObserverWithState(observer, initialState)//注释1
val 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 directly
LifecycleCallbacks.registerIn(activity)
}
val manager = activity.fragmentManager
if (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).lifecycle
if (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 = false
if (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: Boolean
get() {
//没有观察者时返回true
if (observerMap.size() == 0) {
return true
}
//获取最先添加进来的观察者生命周期状态
val eldestObserverState = observerMap.eldest()!!.value.state
//获取最后（最近）添加进来的观察者生命周期状态
val newestObserverState = observerMap.newest()!!.value.state
//如果最先的和最后的Observer的状态一致 && 当前Observer的状态和state保存的状态一致时，返回true，否则就返回false
return 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: State
var lifecycleObserver: LifecycleEventObserver
init {
//下方分析
lifecycleObserver = Lifecycling.lifecycleEventObserver(observer!!)
state = initialState
}
fun dispatchEvent(owner: LifecycleOwner?, event: Event) {
val newState = event.targetState
state = 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 LifecycleEventObserver
val isDefaultLifecycleObserver = `object` is DefaultLifecycleObserver
if (isLifecycleEventObserver && isDefaultLifecycleObserver) {
return DefaultLifecycleObserverAdapter(
`object` as DefaultLifecycleObserver,
`object` as LifecycleEventObserver
)
}
if (isDefaultLifecycleObserver) {
//分析DefaultLifecycleObserverAdapter
return DefaultLifecycleObserverAdapter(`object` as DefaultLifecycleObserver, null)
}
if (isLifecycleEventObserver) {
return `object` as LifecycleEventObserver
}
val klass: Class<*> = `object`.javaClass
val 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事件的分发；
- 宿主的每一个生命周期发生变化的时候会发送一个事件，根据事件推导宿主的状态，所有的观察者根据宿主的状态进行升级或降级以保持同步；
评论区