Android Jetpack LifeCycle 实现原理分析
Posted 麦田里的守望者-Jiang
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Android Jetpack LifeCycle 实现原理分析相关的知识,希望对你有一定的参考价值。
LifeCycle
LifeCycle 是 Jetpack 提供的一个可感知 Activity 或 Fragment 的生命周期 变化的组件。这个组件方便业务针对生命周期的变化做出相应管理和改变,也可以防止业务内存泄漏。
首先了解下与 LifeCycle 相关的概念:
LifeCycle
:抽象类,定义了添加和删除观察者(LifecycleObserver
)的抽象方法,也定义了生命周期事件Lifecycle.Event
,以及生命周期状态Lifecycle.State
;Lifecycle.Event
:LifeCycle
的内部枚举类,定义了LifecycleOwner
(也就是Activity 或 Fragment )的生命周期事件,从ON_CREATE
到ON_DESTROY
;Lifecycle.State
:LifeCycle
的内部枚举类,定义了生命周期状态。LifecycleRegistry
:LifeCycle
的实现类,管理LifecycleObserver
,维护生命周期状态Lifecycle.State
,并负责分发 Activity 或 Fragment 的生命周期事件Lifecycle.Event
;LifecycleObserver
:接口,生命周期观察者,它没有任何方法,依赖注解OnLifecycleEvent
;FullLifecycleObserver
:接口,继承自LifecycleObserver
接口,以生命周期方法(onCreate…onDestroy)的形式观察 Activity 或 Fragment 的生命周期;LifecycleEventObserver
:接口,继承自LifecycleObserver
接口,以生命周期事件(ON_CREATE…ON_DESTROY)的形式观察 Activity 或 Fragment 的生命周期;LifecycleOwner
:接口,关联 Activity 或 Fragment 相关生命周期事件;OnLifecycleEvent
:注解,主要是声明方法监听Lifecycle.Event
事件;Lifecycling
:辅助类,将LifecycleObserver
转换为适配器LifecycleEventObserver
(FullLifecycleObserverAdapter
、SingleGeneratedAdapterObserver
、CompositeGeneratedAdaptersObserver
、ReflectiveGenericLifecycleObserver
),其中ReflectiveGenericLifecycleObserver
处理 以注解OnLifecycleEvent
声明的LifecycleObserver
。
了解了 与 LifeCycle 的相关概念后,再了解下它的简要类关系图:
通常情况下,业务定义的 LifecycleObserver
,一般是通过注解 OnLifecycleEvent
来观察 Activity 或 Fragment 相关生命周期,当 ReportFragment 或 Fragment 的生命周期发生变化时候,ReflectiveGenericLifecycleObserver
通过反射的方式调用 LifecycleObserver
的相关含有OnLifecycleEvent
注解的方法。
这里 Activity 的生命周期的监听是通过 ReportFragment
实现的,Fragment 的生命周期的监听是通过 它自身生命周期回调实现的。另外,定义在 LifecycleObserver
中声明的生命周期事件,都是在 Activity 或 Fragment 的自身生命周期方法调用之后再调用的。由于 LifecycleRegistry
在 addObserver
的时候,会以一个链表结构的 Map 来存储 LifecycleObserver
,所以注册的相关 LifecycleObserver
,最后接受处理生命周期事件时,也是按照添加顺序依次触发的。
流程图:
Activity 中的 LifeCycle 的流程是:
- 在 Activity 中实现
LifecycleOwner
接口,并创建LifecycleRegistry
对象; - 在
ReportFragment
中,当前版本SDK 大于等于 29(也就是安卓10)时,会创建 Activity 的生命周期监听器,否则就使用 ReportFragment 的生命周期作为监听; - 当
ReportFragment
的生命周期发生变化时,通过ReportFragment
中的 activity 对象,获取LifecycleOwner
对象 ,然后获取Lifecycle
的实现类LifecycleRegistry
对象,然后调用它的handleLifecycleEvent
方法; - 添加生命周期观察者
LifecycleObserver
,通过 Activity 获取Lifecycle
的实现类LifecycleRegistry
对象,调用addObserver
方法,移除生命周期观察者LifecycleObserver
,调用removeObserver
; addObserver
方法会创建一个ObserverWithState
对象,并将LifecycleObserver
对象传递给ObserverWithState
的构造函数,在这个方法中,通过Lifecycling
创建一个 实现了LifecycleEventObserver
的适配器对象,LifecycleObserver
对象被包装在LifecycleEventObserver
的适配器对象中;LifecycleRegistry
会用一个 链表的 Map 去维护LifecycleObserver
对象 和ObserverWithState
对象,也会维护 生命周期状态Lifecycle.State
;LifecycleRegistry
对象 接受handleLifecycleEvent
时,就会触发添加的LifecycleEventObserver
的onStateChanged
方法;然后适配者(FullLifecycleObserverAdapter
、SingleGeneratedAdapterObserver
、CompositeGeneratedAdaptersObserver
、ReflectiveGenericLifecycleObserver
)通知LifecycleObserver
观察者。
Fragment 中的 LifeCycle 的流程,除了 生命周期的监听方式不一样以外,其它的和 Activity 一样。Fragment 是在自身的生命周期方法回调中做的处理。
例子
定义生命周期观察者,使用注解 OnLifecycleEvent
定义生命周期事件:
open class BizXXX : LifecycleObserver {
@OnLifecycleEvent(value = Lifecycle.Event.ON_CREATE)
fun onCreate() {
}
@OnLifecycleEvent(value = Lifecycle.Event.ON_START)
fun onStart() {
}
@OnLifecycleEvent(value = Lifecycle.Event.ON_RESUME)
fun onResume() {
}
@OnLifecycleEvent(value = Lifecycle.Event.ON_PAUSE)
fun onPause() {
}
@OnLifecycleEvent(value = Lifecycle.Event.ON_STOP)
fun onStop() {
}
@OnLifecycleEvent(value = Lifecycle.Event.ON_DESTROY)
fun onDestroy() {
}
}
或者 使用 DefaultLifecycleObserver
观察生命周期:
open class BizXXX : DefaultLifecycleObserver {
override fun onCreate(owner: LifecycleOwner) {
}
override fun onStart(owner: LifecycleOwner) {
}
override fun onResume(owner: LifecycleOwner) {
}
override fun onPause(owner: LifecycleOwner) {
}
override fun onStop(owner: LifecycleOwner) {
}
override fun onDestroy(owner: LifecycleOwner) {
}
}
在 Activity 中添加:
class YourActivity : BaseAppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
this.lifecycle.addObserver(BizXXX())
}
}
在 Fragment 中添加:
class YourFragment : Fragment() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
this.lifecycle.addObserver(BizXXX())
}
}
当不能直接使用 LifeCycle 的时候,也可以间接使用 LifeCycle,比如 数据层也要监听生命周期的变化,那么可以将 Presenter 层定义 为一个 LifeOwner:
open class BizPresenter : LifecycleObserver, LifecycleOwner {
private val lifecycleRegistry: LifecycleRegistry = LifecycleRegistry(this)
override fun getLifecycle(): Lifecycle {
return lifecycleRegistry
}
@OnLifecycleEvent(value = Lifecycle.Event.ON_CREATE)
fun onCreate() {
lifecycle.addObserver(BizModel())
lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
}
@OnLifecycleEvent(value = Lifecycle.Event.ON_START)
fun onStart() {
lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
}
@OnLifecycleEvent(value = Lifecycle.Event.ON_RESUME)
fun onResume() {
lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME)
}
@OnLifecycleEvent(value = Lifecycle.Event.ON_PAUSE)
fun onPause() {
lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE)
}
@OnLifecycleEvent(value = Lifecycle.Event.ON_STOP)
fun onStop() {
lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
}
@OnLifecycleEvent(value = Lifecycle.Event.ON_DESTROY)
fun onDestroy() {
lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
}
}
class BizModel : LifecycleObserver {
@OnLifecycleEvent(value = Lifecycle.Event.ON_CREATE)
fun onCreate() {
}
@OnLifecycleEvent(value = Lifecycle.Event.ON_DESTROY)
fun onDestroy() {
}
}
这种嵌套也是很实用的。
以上是关于Android Jetpack LifeCycle 实现原理分析的主要内容,如果未能解决你的问题,请参考以下文章
Android Jetpack 之 Lifecycle - 2
Android Jetpack LifeCycle 实现原理分析
Android Jetpack LifeCycle 实现原理分析