导包

[versions]
lifecycle_version = "2.3.1"[libraries]
androidx-viewmodel = { group = "androidx.lifecycle", name = "lifecycle-viewmodel-ktx", version.ref = "lifecycle_version" }
androidx-livedata = { group = "androidx.lifecycle", name = "lifecycle-livedata-ktx", version.ref = "lifecycle_version" }
androidx-runtime = { group = "androidx.lifecycle", name = "lifecycle-runtime-ktx", version.ref = "lifecycle_version" }
androidx-viewmodel-savestate = { group = "androidx.lifecycle", name = "lifecycle-viewmodel-savedstate", version.ref = "lifecycle_version" }
androidx-lifecycle-compiler = { group = "androidx.lifecycle", name = "lifecycle-compiler", version.ref = "lifecycle_version" }
androidx-lifecycle-service = { group = "androidx.lifecycle", name = "lifecycle-service", version.ref = "lifecycle_version" }  #service 中使用lifecycle
androidx-lifecycle-process = { group = "androidx.lifecycle", name = "lifecycle-process", version.ref = "lifecycle_version" }  #application 中使用lifecycle

核心组件协作

‌LifecycleOwner‌：生命周期拥有者(如Activity/Fragment)，通过getLifecycle()提供Lifecycle对象
‌LifecycleRegistry‌：Lifecycle的具体实现，负责状态管理和事件分发
LifecycleObserver‌：观察者接口，业务组件通过实现它来接收生命周期事件

LifecycleObserver

LifecycleObserver是Android Jetpack架构组件中的关键接口，用于构建能够感知Activity/Fragment生命周期的观察者组件。它通过解耦生命周期管理逻辑与UI组件，帮助开发者编写更有条理且易于维护的代码

package androidx.lifecycle/*** Marks a class as a LifecycleObserver. Don't use this interface directly. Instead implement either* [DefaultLifecycleObserver] or [LifecycleEventObserver] to be notified about* lifecycle events.
翻译如下
将一个类标记为生命周期观察者。不要直接使用此接口。相反，实现DefaultLifecycleObserver或LifecycleEventObserver，以接收生命周期事件的通知。** @see Lifecycle Lifecycle - for samples and usage patterns.*/
public interface LifecycleObserver

so 我们

class MyLifecycleObserver:LifecycleEventObserver {override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {Log.i("zq_demo","event>>${event.name}  ${event.targetState}")}
}

然后我们activity中添加如下代码

 lifecycle.addObserver(MyLifecycleObserver())

结果
在这里插入图片描述
app退到后台

app回前台

app 退出

发现木有

event>>ON_PAUSE STARTED ON_PAUSE时是STARTED
event>>ON_STOP CREATED ON_STOP时是CREATED

why？？？

public abstract class Lifecycle {
//省略public enum class Event {/*** Constant for onCreate event of the [LifecycleOwner].*/ON_CREATE,/*** Constant for onStart event of the [LifecycleOwner].*/ON_START,/*** Constant for onResume event of the [LifecycleOwner].*/ON_RESUME,/*** Constant for onPause event of the [LifecycleOwner].*/ON_PAUSE,/*** Constant for onStop event of the [LifecycleOwner].*/ON_STOP,/*** Constant for onDestroy event of the [LifecycleOwner].*/ON_DESTROY,/*** An [Event] constant that can be used to match all events.*/ON_ANY;public val targetState: Stateget() {when (this) {ON_CREATE, ON_STOP -> return State.CREATED  //看这里看这里ON_START, ON_PAUSE -> return State.STARTED  //看这里看这里ON_RESUME -> return State.RESUMEDON_DESTROY -> return State.DESTROYEDON_ANY -> {}}throw IllegalArgumentException("$this has no target state")}
}
}

为什么要这么搞呢？

下面是deepseek的回答

Android生命周期中ON_PAUSE事件对应STARTED状态的原因

Android生命周期设计中，Lifecycle.Event.ON_PAUSE对应Lifecycle.State.STARTED状态，这种设计基于Activity生命周期的状态转换逻辑和实际应用场景考虑。

生命周期状态与事件的基本关系

Android生命周期定义了5种状态和7种事件：

5种状态‌：INITIALIZED、CREATED、STARTED、RESUMED、DESTROYED
7种事件‌：ON_CREATE、ON_START、ON_RESUME、ON_PAUSE、ON_STOP、ON_DESTROY、ON_ANY
其中STARTED状态表示Activity已可见但未获得焦点，而ON_PAUSE事件表示Activity正在停止但仍可见‌

ON_PAUSE与STARTED对应的技术原因

1‌ 状态定义一致性‌：当Activity触发ON_PAUSE时，它仍然可见（如被透明Activity或对话框部分遮挡），这符合STARTED状态"已可见但未获得焦点"的定义‌34。

‌2 状态转换顺序‌：Android使用状态机模型管理生命周期，确保状态转换有序。从RESUMED状态出发，触发ON_PAUSE后应进入STARTED状态，而非直接跳转到CREATED或STOPPED‌15。

3‌ 用户体验考虑‌：这种设计允许Activity在被部分遮挡时仍能保持可见状态，同时释放焦点资源给新Activity，实现平滑过渡‌26。

‌4 资源管理优化‌：ON_PAUSE对应STARTED状态的设计确保了系统可以在Activity失去焦点但仍可见时进行合理的资源分配，而不是立即停止所有功能‌

实际场景示例

当用户打开一个对话框或透明Activity时：

原Activity触发ON_PAUSE事件
状态变为STARTED（可见但无焦点）
如果用户返回，会触发ON_RESUME回到RESUMED状态
如果被完全覆盖，才会触发ON_STOP进入CREATED状态‌。
这种设计使Android能够精细控制Activity的可见性和交互状态，为开发者提供明确的生命周期回调时机进行资源管理‌。

LifecycleOwner

看继承或实现关系

MainActivity : AppCompatActivity()
AppCompatActivity extends FragmentActivity
FragmentActivity extends ComponentActivity
public class ComponentActivity extends androidx.core.app.ComponentActivity implements LifecycleOwner
不光activity 实现了 LifecycleOwner ； Fragment 也实现了

LifecycleOwner是Android Jetpack架构组件中的核心接口，用于表示具有Android生命周期的组件。根据官方文档，LifecycleOwner的主要作用是‌抽象生命周期所有权‌，使自定义组件能够感知宿主(如Activity/Fragment)的生命周期变化，而无需在宿主中直接实现相关代码‌

‌生命周期提供者‌：通过getLifecycle()方法提供Lifecycle对象，作为生命周期状态和事件的桥梁‌
观察者模式实现‌：与LifecycleObserver配合使用，形成观察者模式架构‌
状态管理‌：维护5种生命周期状态(INITIALIZED、CREATED、STARTED、RESUMED、DESTROYED)和7种事件(ON_CREATE等)‌

上边我们添加lifecycyleObserver时使用

  lifecycle.addObserver(MyLifecycleObserver())

看这个lifecycle

public class ComponentActivity ...{
....private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
....@NonNull@Overridepublic Lifecycle getLifecycle() {return mLifecycleRegistry;}
....
}

open class LifecycleRegistry private constructor(provider: LifecycleOwner,private val enforceMainThread: Boolean
) : Lifecycle() {

LifecycleOwner的实现类可多 ProcessLifecycleOwner 用于监听应用进程生命周期的变化
我们比猫画虎
于是乎：


class MyLifecyclerOwner:LifecycleOwner {private val registry = LifecycleRegistry(this)fun onCreate(){registry.currentState = Lifecycle.State.CREATED}fun onStart(){registry.currentState = Lifecycle.State.STARTED}fun onResume(){registry.currentState = Lifecycle.State.RESUMED}fun onPause(){registry.currentState = Lifecycle.State.STARTED}fun onStop(){registry.currentState = Lifecycle.State.CREATED}fun onDestroy(){registry.currentState = Lifecycle.State.DESTROYED}override val lifecycle: Lifecycleget() = registry
}

使用

class MainActivity : AppCompatActivity() {val owner = MyLifecyclerOwner()override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)enableEdgeToEdge()setContentView(R.layout.activity_main)//        lifecycle.addObserver(MyLifecycleObserver())owner.onCreate()owner.lifecycle.addObserver(MyLifecycleObserver())Log.i("zq_demo","onCreate")}override fun onStart() {super.onStart()owner.onStart()Log.i("zq_demo","onStart")}override fun onResume() {super.onResume()owner.onResume()Log.i("zq_demo","onResume")}override fun onPause() {super.onPause()owner.onPause()Log.i("zq_demo","onPause")}override fun onStop() {super.onStop()owner.onStop()Log.i("zq_demo","onStop")}override fun onDestroy() {super.onDestroy()owner.onDestroy()Log.i("zq_demo","onDestroy")}}

运行结果
在这里插入图片描述
与上边一样一样滴；

LifecycleRegistry 以下为deepseek 说明

LifecycleRegistry是Android Jetpack架构组件中Lifecycle接口的核心实现类，负责管理Android组件(Activity/Fragment)的生命周期状态并分发给观察者。作为生命周期管理的中枢系统，它实现了以下核心功能：

1 状态管理‌：维护5种生命周期状态(INITIALIZED→CREATED→STARTED→RESUMED→DESTROYED)和7种事件(ON_CREATE等)‌
2 观察者模式实现‌：通过addObserver()/removeObserver()管理观察者列表，实现生命周期事件的订阅-发布机制‌
3 事件分发‌：当宿主状态变化时，同步状态并通知所有注册的观察者‌
4 线程安全保证‌：确保生命周期事件在主线程分发，状态变更操作线程安全‌

内部实现与状态机模型

状态机设计原理

LifecycleRegistry采用‌有限状态机(FSM)‌模型管理生命周期，状态转换规则严格遵循Android生命周期逻辑：

// 状态转换规则示例
static State getStateAfter(Event event) {switch(event) {case ON_CREATE: case ON_STOP: return CREATED;case ON_START: case ON_PAUSE: return STARTED;case ON_RESUME: return RESUMED;case ON_DESTROY: return DESTROYED;}throw new IllegalArgumentException("Unexpected event");
}

状态转换路径：

DESTROYED ← ON_DESTROY ← CREATED ← ON_STOP ← STARTED ← ON_PAUSE ← RESUMED
ON_CREATE → ON_START → ON_RESUME →

关键实现机制

1 双向同步算法‌：通过sync()方法确保观察者状态与宿主状态一致：

private void sync() {while (!isSynced()) {// 向后回退状态 (RESUMED → STARTED → CREATED)if (mState < eldestObserverState) backwardPass();// 向前推进状态 (CREATED → STARTED → RESUMED)if (mState > newestObserverState) forwardPass();}
}

2 观察者包装机制‌：通过Lifecycling类将观察者统一包装为LifecycleEventObserver，支持接口回调和注解两种方式‌
3 状态验证‌：提供currentState.isAtLeast()方法验证状态条件‌

与LifecycleOwner的协作关系

协作流程

1 宿主绑定‌：Activity/Fragment实现LifecycleOwner接口，通过getLifecycle()返回LifecycleRegistry实例‌
2 事件捕获‌：
- Fragment：直接通过生命周期回调触发handleLifecycleEvent()
- Activity：通过ReportFragment代理捕获事件‌
3 观察者注册‌：业务组件调用getLifecycle().addObserver()注册监听

自定义LifecycleOwner实现

非Activity/Fragment类可通过实现LifecycleOwner接口创建自定义生命周期宿主：

class CustomOwner : LifecycleOwner {private val registry = LifecycleRegistry(this)override fun getLifecycle(): Lifecycle = registryfun updateState(newState: Lifecycle.State) {registry.currentState = newState}
}

事件分发机制详解

分发流程

1 事件触发‌：Activity/Fragment生命周期变化时，ReportFragment调用dispatch(Lifecycle.Event)‌
2 事件处理‌：LifecycleRegistry.handleLifecycleEvent()根据事件类型计算新状态‌
3 状态同步‌：通过sync()方法同步所有观察者状态‌
4 观察者通知‌：调用观察者的onStateChanged()方法或对应注解方法‌

线程模型特性

主线程限制‌：所有生命周期回调强制在主线程执行‌
线程安全保证‌：状态变更操作通过同步块保证原子性‌
异步处理建议‌：耗时操作应切换到工作线程执行‌

实际应用场景与最佳实践

典型使用场景

1 资源生命周期管理‌：
- 在ON_START时连接服务，ON_STOP时自动释放‌
- 网络请求在页面不可见时自动取消‌
2 组件解耦‌：

class LocationObserver : DefaultLifecycleObserver {override fun onStart(owner: LifecycleOwner) {startLocationUpdates()}override fun onStop(owner: LifecycleOwner) {stopLocationUpdates()}
}

3 自定义生命周期宿主‌：为非UI组件(如Service、自定义View)添加生命周期感知能力‌

最佳实践指南

1 观察者注册方式选择‌：
- 推荐使用DefaultLifecycleObserver接口(优于已废弃的注解方式)‌
- 避免在DESTROYED状态后注册观察者‌
2 资源管理规范‌：
- 在配对回调中执行相反操作(如start/stop)‌
- 使用isAtLeast()验证状态条件‌
3 性能优化‌：
- 及时移除不再需要的观察者‌
- 避免在回调中执行耗时操作‌
Lifecycle

Lifecycle是Android Jetpack架构组件中的基础接口，定义了Android组件生命周期管理的标准化模型。作为生命周期感知组件的核心，它通过状态和事件的抽象，实现了对Activity/Fragment等组件生命周期的统一管理‌

关键方法说明

‌- addObserver()‌：注册生命周期观察者，开始接收生命周期事件‌
‌- removeObserver()‌：移除已注册的观察者，停止事件接收‌
‌- getCurrentState()‌：获取当前生命周期状态‌
‌- handleLifecycleEvent()‌：处理生命周期事件并触发状态转换(由LifecycleRegistry实现)‌

public class ComponentActivity@Overrideprotected void onCreate(@Nullable Bundle savedInstanceState) {// Restore the Saved State first so that it is available to// OnContextAvailableListener instancesmSavedStateRegistryController.performRestore(savedInstanceState);mContextAwareHelper.dispatchOnContextAvailable(this);super.onCreate(savedInstanceState);ReportFragment.injectIfNeededIn(this);  //注意这一句if (mContentLayoutId != 0) {setContentView(mContentLayoutId);}}}

查看ReportFragment

open class ReportFragment() : android.app.Fragment() {
...override fun onActivityCreated(savedInstanceState: Bundle?) {super.onActivityCreated(savedInstanceState)dispatchCreate(processListener)dispatch(Lifecycle.Event.ON_CREATE)}override fun onStart() {super.onStart()dispatchStart(processListener)dispatch(Lifecycle.Event.ON_START)}override fun onResume() {super.onResume()dispatchResume(processListener)dispatch(Lifecycle.Event.ON_RESUME)}override fun onPause() {super.onPause()dispatch(Lifecycle.Event.ON_PAUSE)}override fun onStop() {super.onStop()dispatch(Lifecycle.Event.ON_STOP)}override fun onDestroy() {super.onDestroy()dispatch(Lifecycle.Event.ON_DESTROY)// just want to be sure that we won't leak reference to an activityprocessListener = null}private fun dispatch(event: Lifecycle.Event) {if (Build.VERSION.SDK_INT < 29) {// Only dispatch events from ReportFragment on API levels prior// to API 29. On API 29+, this is handled by the ActivityLifecycleCallbacks// added in ReportFragment.injectIfNeededIndispatch(activity, event)}}
...companion object {private const val REPORT_FRAGMENT_TAG ="androidx.lifecycle.LifecycleDispatcher.report_fragment_tag"@JvmStaticfun injectIfNeededIn(activity: Activity) {if (Build.VERSION.SDK_INT >= 29) {// On API 29+, we can register for the correct Lifecycle callbacks directlyLifecycleCallbacks.registerIn(activity)}// Prior to API 29 and to maintain compatibility with older versions of// ProcessLifecycleOwner (which may not be updated when lifecycle-runtime is updated and// need to support activities that don't extend from FragmentActivity from support lib),// use a framework fragment to get the correct timing of Lifecycle eventsval manager = activity.fragmentManagerif (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {manager.beginTransaction().add(ReportFragment(), REPORT_FRAGMENT_TAG).commit()// Hopefully, we are the first to make a transaction.manager.executePendingTransactions()}}@JvmStaticinternal 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)}}}@JvmStatic@get:JvmName("get")val Activity.reportFragment: ReportFragmentget() {return this.fragmentManager.findFragmentByTag(REPORT_FRAGMENT_TAG) as ReportFragment}}
}

代码的逻辑很清晰，主要通过一个透明的Fragment来分发生命周期事件，这样对于Activity来说是无侵入的

最终调用到了

 @JvmStaticinternal 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)}}}

也就是上面 lifecycle(LifecycleRegistry).handleLifecycleEvent(event)

 open fun handleLifecycleEvent(event: Event) {enforceMainThreadIfNeeded("handleLifecycleEvent")moveToState(event.targetState)}private fun moveToState(next: State) {if (state == next) {return}check(!(state == State.INITIALIZED && next == State.DESTROYED)) {"no event down from $state in component ${lifecycleOwner.get()}"}state = nextif (handlingEvent || addingObserverCounter != 0) {newEventOccurred = true// we will figure out what to do on upper level.return}handlingEvent = truesync()handlingEvent = falseif (state == State.DESTROYED) {observerMap = FastSafeIterableMap()}}

后边代码就不沾了可以自己点点点也可以参考点这里点这里