Jetpack是Google为Android开发提供的组件库.旨在帮助开发者更快更好的开发App程序. 它提供了一系列工具,库和架构组件涵盖了UI展示数据管理,和后台服务到设备兼容的各个方面.
LifeCycle 用于管理组件的生命周期，使开发者能够更方便地编写与组件生命周期相关的代码，实现代码解耦和资源的合理管理。
核心类
- Lifecycle(生命周期)
- LifecycleRegistry(生命周期注册表)
- LifecycleOwner(生命周期拥有者)
下面让我们从源码的角度分析下 具体实现
1.Lifecycle(生命周期)
1.1 Lifecycle类做了什么
Lifecycle是生命周期管理的核心类,他是一个抽象类具体功能在 LifecycleRegistry 这个实现类中实现
核心功能以及属性
1.1.1 生命周期状态和事件的定义
状态枚举（State）
Lifecycle 类中定义了 State 枚举，用于表示 Android 组件的不同生命周期状态，这些状态形成了一个有序的生命周期状态图。主要的状态包括：
INITIALIZED：组件初始化状态，例如Activity被构造但还未调用onCreate方法时处于此状态。CREATED：组件已创建，对应Activity的onCreate方法调用之后，或者在onStop方法调用之前的状态。STARTED：组件已启动，对应Activity的onStart方法调用之后，或者在onPause方法调用之前的状态。RESUMED：组件已恢复，对应Activity的onResume方法调用之后的状态。DESTROYED：组件已销毁，对应Activity的onDestroy方法调用之前的最后状态。
事件枚举（Event）
Event 枚举定义了与生命周期状态变化相关的事件，这些事件标志着状态之间的转换：
ON_CREATE：对应组件的onCreate事件。ON_START：对应组件的onStart事件。ON_RESUME：对应组件的onResume事件。ON_PAUSE：对应组件的onPause事件。ON_STOP：对应组件的onStop事件。ON_DESTROY：对应组件的onDestroy事件。ON_ANY：一个特殊的事件，可用于匹配所有事件。
1.1.2 观察者机制
Lifecycle 类提供了 addObserver 和 removeObserver 方法，允许开发者注册和移除 LifecycleObserver。当组件的生命周期状态发生变化时，注册的观察者会收到相应的通知。
@MainThread
public abstract fun addObserver(observer: LifecycleObserver)
@MainThread
public abstract fun removeObserver(observer: LifecycleObserver)
1.1.3状态获取和状态流
//当前状态
public abstract val currentState: State
//状态流
public open val currentStateFlow: StateFlow<Lifecycle.State>
get() {
val mutableStateFlow = MutableStateFlow(currentState)
LifecycleEventObserver { _, event ->
mutableStateFlow.value = event.targetState
}.also { addObserver(it) }
return mutableStateFlow.asStateFlow()
}
通过 currentState 属性，开发者可以获取 Lifecycle 的当前状态，从而根据状态进行相应的逻辑处理。
Lifecycle 提供了 currentStateFlow 属性，它返回一个 StateFlow，开发者可以使用这个 StateFlow 来观察 Lifecycle 状态的变化。
1.1.4 集成协程
Lifecycle 与协程集成，提供了 coroutineScope 属性，它返回一个与 Lifecycle 绑定的 LifecycleCoroutineScope。当 Lifecycle 进入 DESTROYED 状态时，这个协程作用域会自动取消其中的所有协程，避免内存泄漏。
//协程对象
public val Lifecycle.coroutineScope: LifecycleCoroutineScope
get() {
while (true) {
val existing = internalScopeRef.get() as LifecycleCoroutineScopeImpl?
if (existing != null) {
return existing
}
//运行到主线程 并且与实现类的生命周期做关联 销毁的时候做销毁操作
val newScope = LifecycleCoroutineScopeImpl(
this,
SupervisorJob() + Dispatchers.Main.immediate
)
if (internalScopeRef.compareAndSet(null, newScope)) {
newScope.register()
return newScope
}
}
}
1.1.5 事件流
Lifecycle 还提供了 eventFlow 属性，它返回一个 Flow，用于观察 Lifecycle 分发的事件。开发者可以通过订阅这个 Flow 来响应生命周期事件。
public val Lifecycle.eventFlow: Flow<Lifecycle.Event>
get() = callbackFlow {
val observer = LifecycleEventObserver { _, event ->
trySend(event)
}.also { addObserver(it) }
awaitClose { removeObserver(observer) }
}.flowOn(Dispatchers.Main.immediate)
1.2 Lifecycle.class 源码分析
package androidx.lifecycle
import androidx.annotation.MainThread
import androidx.annotation.RestrictTo
import kotlin.coroutines.CoroutineContext
import kotlin.jvm.JvmStatic
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.cancel
import kotlinx.coroutines.channels.awaitClose
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.callbackFlow
import kotlinx.coroutines.flow.flowOn
import kotlinx.coroutines.launch
/**
* 定义一个具有 Android 生命周期的对象。
* [Fragment][androidx.fragment.app.Fragment] 和 [FragmentActivity][androidx.fragment.app.FragmentActivity] 类实现了
* [LifecycleOwner] 接口，该接口提供了 [getLifecycle][LifecycleOwner.getLifecycle] 方法来访问生命周期。
* 你也可以在自己的类中实现 [LifecycleOwner] 接口。
*
* 此类中的 [Event.ON_CREATE]、[Event.ON_START]、[Event.ON_RESUME] 事件在 [LifecycleOwner] 的相关方法返回 **之后** 分发。
* 此类中的 [Event.ON_PAUSE]、[Event.ON_STOP]、[Event.ON_DESTROY] 事件在 [LifecycleOwner] 的相关方法被调用 **之前** 分发。
* 例如，[Event.ON_START] 将在 [onStart][android.app.Activity.onStart] 返回后分发，[Event.ON_STOP] 将在 [onStop][android.app.Activity.onStop] 被调用前分发。
* 这为你提供了关于所有者所处状态的一定保证。
*
* 若要观察生命周期事件，请调用 [.addObserver] 方法，并传入一个实现了 [DefaultLifecycleObserver] 或 [LifecycleEventObserver] 的对象。
*/
public abstract class Lifecycle {
/**
* Lifecycle 的协程扩展将 CoroutineScope 存储在此字段中。
* 此属性受限制，仅供 lifecycle-common-ktx 库使用。
*/
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
@get:RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
@set:RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
public var internalScopeRef: AtomicReference<Any?> = AtomicReference(null)
/**
* 添加一个 LifecycleObserver，当 LifecycleOwner 的状态改变时，该观察者将收到通知。
*
* 给定的观察者将被更新到 LifecycleOwner 的当前状态。例如，如果 LifecycleOwner 处于 [State.STARTED] 状态，
* 给定的观察者将收到 [Event.ON_CREATE]、[Event.ON_START] 事件。
*
* @param observer 要通知的观察者
*/
@MainThread
public abstract fun addObserver(observer: LifecycleObserver)
/**
* 从观察者列表中移除给定的观察者。
*
* 如果在状态更改分发过程中调用此方法：
* - 如果给定的观察者尚未收到该事件，则不会收到。
* - 如果给定的观察者有多个方法观察当前正在分发的事件，且至少有一个方法已收到该事件，
* 则所有方法都会收到该事件，移除操作将在之后进行。
*
* @param observer 要移除的观察者
*/
@MainThread
public abstract fun removeObserver(observer: LifecycleObserver)
/**
* 返回 Lifecycle 的当前状态。
*
* @return Lifecycle 的当前状态
*/
@get:MainThread
public abstract val currentState: State
/**
* 返回一个 [StateFlow]，其中 [StateFlow.value] 表示此 Lifecycle 的当前 [State]。
*
* @return 一个 [StateFlow]，其值表示此 Lifecycle 的当前状态
*/
public open val currentStateFlow: StateFlow<Lifecycle.State>
get() {
// 创建一个可变状态流，初始值为当前生命周期状态
val mutableStateFlow = MutableStateFlow(currentState)
// 创建一个 LifecycleEventObserver，用于监听生命周期事件并更新状态流的值
LifecycleEventObserver { _, event ->
mutableStateFlow.value = event.targetState
}.also { addObserver(it) }
// 将可变状态流转换为只读状态流并返回
return mutableStateFlow.asStateFlow()
}
/**
* 生命周期事件的枚举类。
*/
public enum class Event {
/**
* [LifecycleOwner] 的 onCreate 事件常量。
*/
ON_CREATE,
/**
* [LifecycleOwner] 的 onStart 事件常量。
*/
ON_START,
/**
* [LifecycleOwner] 的 onResume 事件常量。
*/
ON_RESUME,
/**
* [LifecycleOwner] 的 onPause 事件常量。
*/
ON_PAUSE,
/**
* [LifecycleOwner] 的 onStop 事件常量。
*/
ON_STOP,
/**
* [LifecycleOwner] 的 onDestroy 事件常量。
*/
ON_DESTROY,
/**
* 可用于匹配所有事件的 [Event] 常量。
*/
ON_ANY;
/**
* 返回刚刚报告此 [Lifecycle.Event] 的 [Lifecycle] 的新 [Lifecycle.State]。
*
* 如果在 [.ON_ANY] 上调用此方法，将抛出 [IllegalArgumentException]，因为它是 [OnLifecycleEvent] 使用的特殊值，不是真正的生命周期事件。
*
* @return 此事件将导致的状态
*/
public val targetState: State
get() {
when (this) {
ON_CREATE, ON_STOP -> return State.CREATED
ON_START, ON_PAUSE -> return State.STARTED
ON_RESUME -> return State.RESUMED
ON_DESTROY -> return State.DESTROYED
ON_ANY -> {}
}
throw IllegalArgumentException("$this has no target state")
}
public companion object {
/**
* 返回 [Lifecycle] 从指定的 [Lifecycle.State] 过渡到较低状态时将报告的 [Lifecycle.Event]，
* 如果没有有效的事件可以从给定状态过渡到较低状态，则返回 `null`。
*
* @param state 要过渡下来的较高状态
* @return 从该状态向下过渡生命周期阶段的事件
*/
@JvmStatic
public fun downFrom(state: State): Event? {
return when (state) {
State.CREATED -> ON_DESTROY
State.STARTED -> ON_STOP
State.RESUMED -> ON_PAUSE
else -> null
}
}
/**
* 返回 [Lifecycle] 从较高状态进入指定的 [Lifecycle.State] 时将报告的 [Lifecycle.Event]，
* 如果没有有效的事件可以过渡到给定状态，则返回 `null`。
*
* @param state 要过渡到的较低状态
* @return 向下过渡生命周期阶段到该状态的事件
*/
@JvmStatic
public fun downTo(state: State): Event? {
return when (state) {
State.DESTROYED -> ON_DESTROY
State.CREATED -> ON_STOP
State.STARTED -> ON_PAUSE
else -> null
}
}
/**
* 返回 [Lifecycle] 从指定的 [Lifecycle.State] 过渡到较高状态时将报告的 [Lifecycle.Event]，
* 如果没有有效的事件可以从给定状态过渡到较高状态，则返回 `null`。
*
* @param state 要过渡上去的较低状态
* @return 从该状态向上过渡生命周期阶段的事件
*/
@JvmStatic
public fun upFrom(state: State): Event? {
return when (state) {
State.INITIALIZED -> ON_CREATE
State.CREATED -> ON_START
State.STARTED -> ON_RESUME
else -> null
}
}
/**
* 返回 [Lifecycle] 从较低状态进入指定的 [Lifecycle.State] 时将报告的 [Lifecycle.Event]，
* 如果没有有效的事件可以过渡到给定状态，则返回 `null`。
*
* @param state 要过渡到的较高状态
* @return 向上过渡生命周期阶段到该状态的事件
*/
@JvmStatic
public fun upTo(state: State): Event? {
return when (state) {
State.CREATED -> ON_CREATE
State.STARTED -> ON_START
State.RESUMED -> ON_RESUME
else -> null
}
}
}
}
/**
* 生命周期状态的枚举类。可以将状态视为图中的节点，[Event] 视为这些节点之间的边。
*/
public enum class State {
/**
* LifecycleOwner 的已销毁状态。在此事件之后，此 Lifecycle 将不再分发任何事件。
* 例如，对于 [android.app.Activity]，在 Activity 的 [onDestroy][android.app.Activity.onDestroy] 调用 **之前** 达到此状态。
*/
DESTROYED,
/**
* LifecycleOwner 的已初始化状态。对于 [android.app.Activity]，在其构造完成但尚未收到
* [onCreate][android.app.Activity.onCreate] 调用时处于此状态。
*/
INITIALIZED,
/**
* LifecycleOwner 的已创建状态。对于 [android.app.Activity]，在以下两种情况下达到此状态：
* - 在 [onCreate][android.app.Activity.onCreate] 调用之后；
* - 在 [onStop][android.app.Activity.onStop] 调用 **之前**。
*/
CREATED,
/**
* LifecycleOwner 的已启动状态。对于 [android.app.Activity]，在以下两种情况下达到此状态：
* - 在 [onStart][android.app.Activity.onStart] 调用之后；
* - 在 [onPause][android.app.Activity.onPause] 调用 **之前**。
*/
STARTED,
/**
* LifecycleOwner 的已恢复状态。对于 [android.app.Activity]，在 [onResume][android.app.Activity.onResume] 调用之后达到此状态。
*/
RESUMED;
/**
* 比较此状态是否大于或等于给定的 `state`。
*
* @param state 要比较的状态
* @return 如果此状态大于或等于给定的 `state`，则返回 true
*/
public fun isAtLeast(state: State): Boolean {
return compareTo(state) >= 0
}
}
}
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
public expect class AtomicReference<V>(value: V) {
public fun get(): V
public fun compareAndSet(expect: V, newValue: V): Boolean
}
/**
* 与该 [Lifecycle] 绑定的 [CoroutineScope]。
*
* 当 [Lifecycle] 被销毁时，此作用域将被取消。
*
* 此作用域绑定到 [Dispatchers.Main.immediate][kotlinx.coroutines.MainCoroutineDispatcher.immediate]
*/
public val Lifecycle.coroutineScope: LifecycleCoroutineScope
get() {
while (true) {
// 尝试从 internalScopeRef 中获取已存在的 LifecycleCoroutineScopeImpl 实例
val existing = internalScopeRef.get() as LifecycleCoroutineScopeImpl?
if (existing != null) {
return existing
}
// 如果不存在，则创建一个新的 LifecycleCoroutineScopeImpl 实例
val newScope = LifecycleCoroutineScopeImpl(
this,
SupervisorJob() + Dispatchers.Main.immediate
)
// 使用 CAS 操作尝试将新实例设置到 internalScopeRef 中
if (internalScopeRef.compareAndSet(null, newScope)) {
newScope.register()
return newScope
}
}
}
/**
* 与 [Lifecycle] 和 [Dispatchers.Main.immediate][kotlinx.coroutines.MainCoroutineDispatcher.immediate] 绑定的 [CoroutineScope]。
*
* 当 [Lifecycle] 被销毁时，此作用域将被取消。
*/
public expect abstract class LifecycleCoroutineScope internal constructor() : CoroutineScope {
internal abstract val lifecycle: Lifecycle
}
internal class LifecycleCoroutineScopeImpl(
override val lifecycle: Lifecycle,
override val coroutineContext: CoroutineContext
) : LifecycleCoroutineScope(), LifecycleEventObserver {
init {
// 如果在非主线程初始化，在返回作用域之前进行最佳努力的检查。
// 这不是同步检查，但如果开发者在非主线程调度器上启动协程，他们无论如何也不能 100% 确定。
if (lifecycle.currentState == Lifecycle.State.DESTROYED) {
coroutineContext.cancel()
}
}
fun register() {
// 在主线程立即调度器上启动协程
launch(Dispatchers.Main.immediate) {
if (lifecycle.currentState >= Lifecycle.State.INITIALIZED) {
// 如果生命周期状态大于等于 INITIALIZED，则添加当前实例作为生命周期观察者
lifecycle.addObserver(this@LifecycleCoroutineScopeImpl)
} else {
// 否则取消协程上下文
coroutineContext.cancel()
}
}
}
override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
if (lifecycle.currentState <= Lifecycle.State.DESTROYED) {
// 如果生命周期状态小于等于 DESTROYED，则移除当前实例作为观察者并取消协程上下文
lifecycle.removeObserver(this)
coroutineContext.cancel()
}
}
}
/**
* 创建一个 [Flow]，其中包含此 [Lifecycle] 分发的 [Lifecycle.Event]。
*/
public val Lifecycle.eventFlow: Flow<Lifecycle.Event>
get() = callbackFlow {
// 创建一个 LifecycleEventObserver，用于将生命周期事件发送到流中
val observer = LifecycleEventObserver { _, event ->
trySend(event)
}.also { addObserver(it) }
// 当流关闭时，移除观察者
awaitClose { removeObserver(observer) }
}.flowOn(Dispatchers.Main.immediate)
1.3 核心方法和属性总结
addObserver(observer: LifecycleObserver)：添加一个生命周期观察者，当生命周期状态改变时通知该观察者。removeObserver(observer: LifecycleObserver)：移除指定的生命周期观察者。currentState: State：获取当前的生命周期状态。currentStateFlow: StateFlow<Lifecycle.State>：返回一个StateFlow，用于观察生命周期状态的变化。coroutineScope: LifecycleCoroutineScope：获取与该生命周期绑定的协程作用域，生命周期销毁时协程作用域会被取消。eventFlow: Flow<Lifecycle.Event>：返回一个Flow，用于观察生命周期事件的分发。Event枚举：定义了生命周期事件的常量，如ON_CREATE、ON_START等。State枚举：定义了生命周期的状态，如DESTROYED、INITIALIZED等。
注意
LifecycleCoroutineScopeImpl 是协程的实现类 关联了生命周期状态 Lifecycle.State.INITIALIZED 状态的时候添加了关注 Lifecycle.State.DESTROYED状态的时候取消了协程
internal class LifecycleCoroutineScopeImpl(
override val lifecycle: Lifecycle,
override val coroutineContext: CoroutineContext
) : LifecycleCoroutineScope(), LifecycleEventObserver {
init {
// 如果在非主线程初始化，在返回作用域之前进行最佳努力的检查。
// 这不是同步检查，但如果开发者在非主线程调度器上启动协程，他们无论如何也不能 100% 确定。
if (lifecycle.currentState == Lifecycle.State.DESTROYED) {
coroutineContext.cancel()
}
}
fun register() {
// 在主线程立即调度器上启动协程
launch(Dispatchers.Main.immediate) {
if (lifecycle.currentState >= Lifecycle.State.INITIALIZED) {
// 如果生命周期状态大于等于 INITIALIZED，则添加当前实例作为生命周期观察者
lifecycle.addObserver(this@LifecycleCoroutineScopeImpl)
} else {
// 否则取消协程上下文
coroutineContext.cancel()
}
}
}
override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
if (lifecycle.currentState <= Lifecycle.State.DESTROYED) {
// 如果生命周期状态小于等于 DESTROYED，则移除当前实例作为观察者并取消协程上下文
lifecycle.removeObserver(this)
coroutineContext.cancel()
}
}
}
2.LifecycleRegistry(生命周期注册表)
2.1 LifecycleRegistry做了什么
LifecycleRegistry 是 androidx.lifecycle 包中 Lifecycle 接口的具体实现类，主要负责管理 LifecycleOwner（如 Activity、Fragment）的生命周期状态，并将这些状态变化通知给注册的 LifecycleObserver
LifecycleRegistry 是Lifecycle 的具体实现.实现了Lifecycle的具体功能
2.2 核心功能
2.2.1 生命周期状态管理
moveToState(next: State)
- 功能：该方法用于将
Lifecycle的状态移动到指定的next状态。在移动状态之前，会检查状态转换的合法性，避免从INITIALIZED直接到DESTROYED这种无效转换。如果在处理事件或添加观察者的过程中调用此方法，会标记有新事件发生，等待上层处理。状态移动完成后，会调用sync方法同步观察者的状态。当状态变为DESTROYED时，会清空观察者列表。 - 代码示例：
private fun moveToState(next: State) {
if (state == next) {
return
}
check(!(state == State.INITIALIZED && next == State.DESTROYED)) {
"State must be at least CREATED to move to $next, but was $state in component " +
"${lifecycleOwner.get()}"
}
state = next
if (handlingEvent || addingObserverCounter != 0) {
newEventOccurred = true
return
}
handlingEvent = true
sync()
handlingEvent = false
if (state == State.DESTROYED) {
observerMap = FastSafeIterableMap()
}
}
currentState 属性
- 功能：这是一个可读写的属性，用于获取和设置
Lifecycle的当前状态。获取时直接返回内部存储的state变量，设置时会调用moveToState方法来更新状态，并确保操作在主线程执行（如果需要）。 - 代码示例：
actual override var currentState: State
get() = state
set(state) {
enforceMainThreadIfNeeded("setCurrentState")
moveToState(state)
}
2.2.2 观察者管理
addObserver(observer: LifecycleObserver)
- 功能：向
LifecycleRegistry中添加一个LifecycleObserver。添加前会检查是否在主线程执行（如果需要），然后根据当前Lifecycle的状态为观察者设置初始状态。接着计算观察者的目标状态，并将其状态逐步更新到目标状态，期间会向观察者分发相应的生命周期事件。最后，如果不是重入状态，会调用sync方法同步所有观察者的状态。 - 代码示例：
override fun addObserver(observer: LifecycleObserver) {
enforceMainThreadIfNeeded("addObserver")
val initialState = if (state == State.DESTROYED) State.DESTROYED else State.INITIALIZED
val statefulObserver = ObserverWithState(observer, initialState)
val previous = observerMap.putIfAbsent(observer, statefulObserver)
if (previous != null) {
return
}
val lifecycleOwner = lifecycleOwner.get()
?: return
val isReentrance = addingObserverCounter != 0 || handlingEvent
var targetState = calculateTargetState(observer)
addingObserverCounter++
while (statefulObserver.state < targetState && observerMap.contains(observer)) {
pushParentState(statefulObserver.state)
val event = Event.upFrom(statefulObserver.state)
?: throw IllegalStateException("no event up from ${statefulObserver.state}")
statefulObserver.dispatchEvent(lifecycleOwner, event)
popParentState()
targetState = calculateTargetState(observer)
}
if (!isReentrance) {
sync()
}
addingObserverCounter--
}
removeObserver(observer: LifecycleObserver)
- 功能：从
LifecycleRegistry中移除指定的LifecycleObserver。移除操作会检查是否在主线程执行（如果需要），并且不会发送销毁事件给被移除的观察者，以避免一些复杂的清理逻辑。 - 代码示例：
override fun removeObserver(observer: LifecycleObserver) {
enforceMainThreadIfNeeded("removeObserver")
observerMap.remove(observer
2.2.3 LifecycleRegistry.class 源码分析
package androidx.lifecycle
import androidx.annotation.MainThread
import androidx.annotation.VisibleForTesting
import androidx.arch.core.internal.FastSafeIterableMap
import java.lang.ref.WeakReference
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
/**
* [Lifecycle] 的一个实现类，它可以处理多个观察者。
*
* Fragments 和支持库中的 Activities 会使用这个类。如果你有自定义的 LifecycleOwner，也可以直接使用它。
*/
public actual open class LifecycleRegistry private constructor(
//维护了一个 LifecycleOwner
provider: LifecycleOwner,
// 是否强制要求方法在主线程调用
private val enforceMainThread: Boolean
) : Lifecycle() {
/**
* 自定义的列表，用于保存观察者，并且能够在遍历过程中处理添加和移除操作。
*
* 不变性规则：在任意时刻，对于观察者 observer1 和 observer2：
* 如果 observer1 的添加顺序早于 observer2，那么 observer1 的状态不低于 observer2 的状态。
*/
private var observerMap = FastSafeIterableMap<LifecycleObserver, ObserverWithState>()
/**
* 当前的生命周期状态
*/
private var state: State = State.INITIALIZED
/**
* 持有此 Lifecycle 的 LifecycleOwner。
* 只保留对 LifecycleOwner 的弱引用，这样即使有人泄漏了 Lifecycle，也不会导致整个 Fragment 或 Activity 泄漏。
* 不过，泄漏 Lifecycle 对象也不是个好主意，因为它持有所有其他监听器的强引用，会导致这些监听器也被泄漏。
*/
private val lifecycleOwner: WeakReference<LifecycleOwner>
// 构造函数，默认强制要求方法在主线程调用
public actual constructor(provider: LifecycleOwner) : this(provider, true)
init {
// 初始化时保存对 LifecycleOwner 的弱引用
lifecycleOwner = WeakReference(provider)
}
/**
* 将 Lifecycle 的状态移动到指定状态，并向观察者分发必要的事件。
*
* @param state 新的状态
*/
@MainThread
@Deprecated("Override [currentState].") // 已弃用，建议重写 [currentState]
public open fun markState(state: State) {
// 若需要，强制执行主线程检查
enforceMainThreadIfNeeded("markState")
// 更新当前状态
currentState = state
}
// 重写 Lifecycle 中的 currentState 属性
actual override var currentState: State
get() = state // 获取当前状态
/**
* 将 Lifecycle 的状态移动到指定状态，并向观察者分发必要的事件。
*
* @param state 新的状态
*/
set(state) {
// 若需要，强制执行主线程检查
enforceMainThreadIfNeeded("setCurrentState")
// 移动到新状态
moveToState(state)
}
// 用于存储当前生命周期状态的可变状态流
private val _currentStateFlow: MutableStateFlow<State> = MutableStateFlow(State.INITIALIZED)
// 将可变状态流转换为只读状态流暴露出去
override val currentStateFlow: StateFlow<State>
get() = _currentStateFlow.asStateFlow()
/**
* 设置当前状态并通知观察者。
*
* 注意，如果 `currentState` 与上次调用此方法时的状态相同，调用此方法将没有效果。
*
* @param event 接收到的生命周期事件
*/
public actual open fun handleLifecycleEvent(event: Event) {
// 若需要，强制执行主线程检查
enforceMainThreadIfNeeded("handleLifecycleEvent")
// 移动到事件对应的目标状态
moveToState(event.targetState)
}
/**
* 移动到新的生命周期状态
* @param next 目标状态
*/
private fun moveToState(next: State) {
// 如果当前状态和目标状态相同，直接返回
if (state == next) {
return
}
// 检查是否是无效的状态转换（从 INITIALIZED 直接到 DESTROYED）
check(!(state == State.INITIALIZED && next == State.DESTROYED)) {
"State must be at least CREATED to move to $next, but was $state in component " +
"${lifecycleOwner.get()}"
}
// 更新当前状态
state = next
// 如果正在处理事件或者正在添加观察者，标记有新事件发生，等待上层处理
if (handlingEvent || addingObserverCounter != 0) {
newEventOccurred = true
return
}
// 标记开始处理事件
handlingEvent = true
// 同步观察者状态
sync()
// 标记事件处理结束
handlingEvent = false
// 如果状态变为 DESTROYED，清空观察者列表
if (state == State.DESTROYED) {
observerMap = FastSafeIterableMap()
}
}
/**
* 判断是否所有观察者的状态都与 Lifecycle 的当前状态同步
*/
private val isSynced: Boolean
get() {
// 如果没有观察者，认为是同步的
if (observerMap.size() == 0) {
return true
}
// 获取最早添加的观察者的状态
val eldestObserverState = observerMap.eldest()!!.value.state
// 获取最晚添加的观察者的状态
val newestObserverState = observerMap.newest()!!.value.state
// 当最早和最晚添加的观察者状态相同，且都与当前 Lifecycle 状态相同时，认为是同步的
return eldestObserverState == newestObserverState && state == newestObserverState
}
/**
* 计算某个观察者应该达到的目标状态
* @param observer 要计算目标状态的观察者
* @return 目标状态
*/
private fun calculateTargetState(observer: LifecycleObserver): State {
// 获取该观察者在列表中之后的第一个元素
val map = observerMap.ceil(observer)
// 获取该元素对应的观察者状态
val siblingState = map?.value?.state
// 获取父状态，如果有记录的话
val parentState =
if (parentStates.isNotEmpty()) parentStates[parentStates.size - 1] else null
// 返回当前状态、兄弟状态和父状态中的最小状态
return min(min(state, siblingState), parentState)
}
/**
* 添加一个 LifecycleObserver，当 LifecycleOwner 的状态改变时，该观察者将被通知。
*
* 给定的观察者将被更新到 LifecycleOwner 的当前状态。例如，如果 LifecycleOwner 处于 [Lifecycle.State.STARTED] 状态，
* 给定的观察者将收到 [Lifecycle.Event.ON_CREATE]、[Lifecycle.Event.ON_START] 事件。
*
* @param observer 要添加的观察者
* @throws IllegalStateException 如果从观察者的初始状态无法向上找到对应的事件
*/
override fun addObserver(observer: LifecycleObserver) {
// 若需要，强制执行主线程检查
enforceMainThreadIfNeeded("addObserver")
// 根据当前 Lifecycle 的状态确定观察者的初始状态
val initialState = if (state == State.DESTROYED) State.DESTROYED else State.INITIALIZED
// 创建一个带有状态的观察者实例
val statefulObserver = ObserverWithState(observer, initialState)
// 将观察者添加到列表中，如果已经存在则返回之前的实例
val previous = observerMap.putIfAbsent(observer, statefulObserver)
if (previous != null) {
return
}
// 获取 LifecycleOwner 实例
val lifecycleOwner = lifecycleOwner.get()
?: // 如果 LifecycleOwner 已经被垃圾回收，快速返回
return
// 判断是否处于重入状态（正在添加观察者或处理事件）
val isReentrance = addingObserverCounter != 0 || handlingEvent
// 计算观察者的目标状态
var targetState = calculateTargetState(observer)
// 增加添加观察者计数器
addingObserverCounter++
// 当观察者的当前状态小于目标状态，且观察者仍在列表中时
while (statefulObserver.state < targetState && observerMap.contains(observer)) {
// 记录当前状态作为父状态
pushParentState(statefulObserver.state)
// 获取从当前状态向上的事件
val event = Event.upFrom(statefulObserver.state)
?: throw IllegalStateException("no event up from ${statefulObserver.state}")
// 向观察者分发事件
statefulObserver.dispatchEvent(lifecycleOwner, event)
// 移除记录的父状态
popParentState()
// 重新计算目标状态，因为状态可能在分发事件过程中改变
targetState = calculateTargetState(observer)
}
// 如果不是重入状态，调用 sync 方法同步状态
if (!isReentrance) {
sync()
}
// 减少添加观察者计数器
addingObserverCounter--
}
/**
* 移除记录的父状态
*/
private fun popParentState() {
parentStates.removeAt(parentStates.size - 1)
}
/**
* 记录当前状态作为父状态
* @param state 要记录的状态
*/
private fun pushParentState(state: State) {
parentStates.add(state)
}
/**
* 移除一个 LifecycleObserver。
*
* 这里有意识地决定不发送销毁事件，与 addObserver 方法不同。原因如下：
* 1. 这些销毁事件实际上还没有发生。与 addObserver 中的事件不同，那些事件是实际发生过但较早的。
* 2. 有些情况下，removeObserver 是由于某种致命事件而调用的。如果 removeObserver 方法发送销毁事件，
* 那么清理例程会变得更加繁琐。例如，你的 LifecycleObserver 监听网络连接，
* 在通常的 OnStop 方法中，你会向服务器报告会话已结束并关闭连接。
* 现在假设你失去了网络连接，因此移除了这个观察者。如果在 removeObserver 中收到销毁事件，
* 你需要在 onStop 方法中添加一个特殊情况，检查网络连接是否已断开，并且不应该尝试向服务器报告任何内容。
*
* @param observer 要移除的观察者
*/
override fun removeObserver(observer: LifecycleObserver) {
// 若需要，强制执行主线程检查
enforceMainThreadIfNeeded("removeObserver")
// 从观察者列表中移除该观察者
observerMap.remove(observer)
}
/**
* 获取观察者的数量
* @return 观察者的数量
*/
public actual open val observerCount: Int
get() {
// 若需要，强制执行主线程检查
enforceMainThreadIfNeeded("getObserverCount")
// 返回观察者列表的大小
return observerMap.size()
}
/**
* 正向遍历观察者列表，将状态小于 Lifecycle 当前状态的观察者状态更新
* @param lifecycleOwner 当前的 LifecycleOwner
*/
private fun forwardPass(lifecycleOwner: LifecycleOwner) {
@Suppress()
// 获取支持添加操作的迭代器
val ascendingIterator: Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> =
observerMap.iteratorWithAdditions()
while (ascendingIterator.hasNext() && !newEventOccurred) {
val (key, observer) = ascendingIterator.next()
// 当观察者状态小于 Lifecycle 当前状态，且没有新事件发生，且观察者仍在列表中时
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.dispatchEvent(lifecycleOwner, event)
// 移除记录的父状态
popParentState()
}
}
}
/**
* 反向遍历观察者列表，将状态大于 Lifecycle 当前状态的观察者状态更新
* @param lifecycleOwner 当前的 LifecycleOwner
*/
private fun backwardPass(lifecycleOwner: LifecycleOwner) {
// 获取反向迭代器
val descendingIterator = observerMap.descendingIterator()
while (descendingIterator.hasNext() && !newEventOccurred) {
val (key, observer) = descendingIterator.next()
// 当观察者状态大于 Lifecycle 当前状态，且没有新事件发生，且观察者仍在列表中时
while (observer.state > state && !newEventOccurred && observerMap.contains(key)) {
// 获取从当前状态向下的事件
val event = Event.downFrom(observer.state)
?: throw IllegalStateException("no event down from ${observer.state}")
// 记录事件目标状态作为父状态
pushParentState(event.targetState)
// 向观察者分发事件
observer.dispatchEvent(lifecycleOwner, event)
// 移除记录的父状态
popParentState()
}
}
}
/**
* 同步观察者的状态，确保所有观察者的状态与 Lifecycle 的当前状态一致
* 该方法只在栈顶调用（非重入情况），因此不需要考虑父状态
*/
private fun sync() {
// 获取 LifecycleOwner 实例
val lifecycleOwner = lifecycleOwner.get()
?: throw IllegalStateException(
"LifecycleOwner of this LifecycleRegistry is already " +
"garbage collected. It is too late to change lifecycle state."
)
// 当观察者状态与 Lifecycle 状态不同步时
while (!isSynced) {
// 标记没有新事件发生
newEventOccurred = false
// 如果 Lifecycle 当前状态小于最早添加的观察者的状态
if (state < observerMap.eldest()!!.value.state) {
// 调用 backwardPass 方法反向更新观察者状态
backwardPass(lifecycleOwner)
}
// 获取最晚添加的观察者
val newest = observerMap.newest()
if (!newEventOccurred && newest != null && state > newest.value.state) {
// 如果没有新事件发生，且 Lifecycle 当前状态大于最晚添加的观察者的状态
// 调用 forwardPass 方法正向更新观察者状态
forwardPass(lifecycleOwner)
}
}
// 标记没有新事件发生
newEventOccurred = false
// 更新状态流的值
_currentStateFlow.value = currentState
}
/**
* 若需要，强制执行主线程检查
* @param methodName 方法名，用于异常提示
*/
private fun enforceMainThreadIfNeeded(methodName: String) {
if (enforceMainThread) {
check(isMainThread()) {
("Method $methodName must be called on the main thread")
}
}
}
/**
* 内部类，用于存储观察者及其对应的状态，并处理事件分发
*/
internal class ObserverWithState(observer: LifecycleObserver?, initialState: State) {
// 观察者的当前状态
var state: State
// 包装后的 LifecycleEventObserver 实例
var lifecycleObserver: LifecycleEventObserver
init {
// 将传入的 LifecycleObserver 转换为 LifecycleEventObserver
lifecycleObserver = Lifecycling.lifecycleEventObserver(observer!!)
// 初始化观察者状态
state = initialState
}
/**
* 向观察者分发生命周期事件
* @param owner 当前的 LifecycleOwner
* @param event 要分发的事件
*/
fun dispatchEvent(owner: LifecycleOwner?, event: Event) {
// 获取事件对应的目标状态
val newState = event.targetState
// 更新观察者状态为当前状态和目标状态中的较小值
state = min(state, newState)
// 调用观察者的 onStateChanged 方法处理状态变更
lifecycleObserver.onStateChanged(owner!!, event)
// 更新观察者状态为目标状态
state = newState
}
}
public actual companion object {
/**
* 为给定的 LifecycleOwner 创建一个新的 LifecycleRegistry 实例，该实例不会检查其方法是否在主线程调用。
*
* LifecycleRegistry 不是线程安全的：如果多个线程访问这个 `LifecycleRegistry`，必须在外部进行同步。
*
* 此方法的另一个可能用例是 JVM 测试，当没有主线程时可以使用。
*
* @param owner 所属的 LifecycleOwner
* @return 新的 LifecycleRegistry 实例
*/
@JvmStatic
@VisibleForTesting
public actual fun createUnsafe(owner: LifecycleOwner): LifecycleRegistry {
return LifecycleRegistry(owner, false)
}
/**
* 返回两个状态中的较小状态
* @param state1 状态 1
* @param state2 状态 2
* @return 较小的状态
*/
@JvmStatic
3.LifecycleOwner(生命周期拥有者)
LifecycleOwner 接口用于表示一个具有生命周期的对象。实现该接口的类可以提供一个 Lifecycle 对象，这个 Lifecycle 对象能够跟踪该对象的生命周期状态变化，并允许其他组件（如 LifecycleObserver）监听这些变化。简单来说，LifecycleOwner 就是一个生命周期的持有者，它将自身的生命周期暴露给外部，使得其他组件可以与之交互。
3.1源码分析
package androidx.lifecycle
import kotlinx.coroutines.CoroutineScope
public interface LifecycleOwner {
public val lifecycle: Lifecycle
}
public val LifecycleOwner.lifecycleScope: LifecycleCoroutineScope
get() = lifecycle.coroutineScope
3.2 实现了LifecycleOwner 的组件
总结
Lifecycle 是一个抽象类 提供了抽象方法和属性
- 声明了添加和移除观察的方法
- 声明了事件以及事件状态
- 提供了一个生命周期的协程作用域
- 声明了一个事件流
- 声明了一个状态流
LifecycleRegistry继承了Lifecycle 实现了具体的功能
LifecycleOwner是一个接口,维护了一个Lifecycle的对象 Activity/Fragment 等控件通过实现LifecycleOwner 持有了Lifecycle 并创建了一个LifecycleRegistry 对象来分发其生命周期的状态
