小玩 Lifecycle

导包

[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: 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")
    }

}

运行结果

与上边一样一样滴；

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 = 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) {
            // Only dispatch events from ReportFragment on API levels prior
            // to API 29. On API 29+, this is handled by the ActivityLifecycleCallbacks
            // added in ReportFragment.injectIfNeededIn
            dispatch(activity, event)
        }
    }
...

 companion object {
        private const val REPORT_FRAGMENT_TAG =
            "androidx.lifecycle.LifecycleDispatcher.report_fragment_tag"

        @JvmStatic
        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)
            }
            // 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()
        }
    }

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