网站导航
> 技术文档 > 小玩 Lifecycle

小玩 Lifecycle

网友: 技术文档 2025-07-26 20:01:55

导包

[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 中使用lifecycleandroidx-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())

结果
小玩 Lifecycle
app退到后台
小玩 Lifecycle
app回前台
小玩 Lifecycle
app 退出
小玩 Lifecycle

发现木有

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: 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\") }}}
为什么要这么搞呢？

下面是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 @Override public 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: Lifecycle get() = 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\") }}

运行结果
小玩 Lifecycle
与上边一样一样滴；

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 ← RESUMEDON_CREATE → ON_START → ON_RESUME →
关键实现机制
  • 1 双向同步算法‌：通过sync()方法确保观察者状态与宿主状态一致：
private void sync() { while (!isSynced()) { // 向后回退状态 (RESUMED → STARTED → CREATED) 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 = registry fun 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@Override protected void onCreate(@Nullable Bundle savedInstanceState) { // Restore the Saved State first so that it is available to // OnContextAvailableListener instances mSavedStateRegistryController.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 activity processListener = null } private fun dispatch(event: Lifecycle.Event) { if (Build.VERSION.SDK_INT = 29) { // On API 29+, we can register for the correct Lifecycle callbacks directly LifecycleCallbacks.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 events val manager = activity.fragmentManager if (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() } } @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) } } } @JvmStatic @get:JvmName(\"get\") val Activity.reportFragment: ReportFragment get() { return this.fragmentManager.findFragmentByTag(  REPORT_FRAGMENT_TAG ) as ReportFragment } }}

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

最终调用到了

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

也就是上面 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 = next if (handlingEvent || addingObserverCounter != 0) { newEventOccurred = true // we will figure out what to do on upper level. return } handlingEvent = true sync() handlingEvent = false if (state == State.DESTROYED) { observerMap = FastSafeIterableMap() } }

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

网络标签：

相关问题