80. Lifecycle 组件

Activity 有生命周期，但它不只是自己过生命周期，还能把生命周期事件广播给关心的类。Lifecycle 组件就是这套机制的封装。

为什么需要 Lifecycle 组件

打个比方，定位管理器这种系统服务，应用在前台时要持续定位，进后台就得停，省电省隐私。但定位管理器自己不知道应用在前台还是后台，得有人告诉它。

最笨的办法是在 Activity 的 onStart/onStop 里写 manager.start()/manager.stop()。问题：

• Activity 代码膨胀。
• 多个需要生命周期感知的类都塞进 Activity。
• 难复用，换个 Activity 又得写一遍。

Lifecycle 组件把这套逻辑抽出来：需要感知生命周期的类实现 LifecycleObserver，自己注册到 LifecycleOwner，事件自动回调。

三个核心角色

• Lifecycle：抽象的生命周期状态对象，持有 Event 和 State。
• LifecycleOwner：生命周期拥有者，比如 Activity、Fragment。提供 Lifecycle 实例。
• LifecycleObserver：观察者，订阅 LifecycleOwner 的生命周期事件。

ComponentActivity 和 Fragment 都实现了 LifecycleOwner，所以你直接能用。

Lifecycle.Event 和 State

事件（Event）按顺序：

ON_CREATE -> ON_START -> ON_RESUME -> ON_PAUSE -> ON_STOP -> ON_DESTROY

状态（State）是事件之间的稳定阶段：

INITIALIZED -> CREATED -> STARTED -> RESUMED
                                       (反向回到 DESTROYED)

状态比事件少，因为事件是「转换瞬间」，状态是「持续阶段」。

用 LifecycleObserver

让一个类感知生命周期，实现 DefaultLifecycleObserver（Java 8 风格，推荐）：

class LocationObserver(
    private val manager: LocationManager
) : DefaultLifecycleObserver {

    override fun onStart(owner: LifecycleOwner) {
        manager.requestLocationUpdates()
    }

    override fun onStop(owner: LifecycleOwner) {
        manager.removeUpdates()
    }
}

在 Activity 里注册：

class MainActivity : AppCompatActivity() {
    private val locationObserver = LocationObserver(locationManager)

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycle.addObserver(locationObserver)
    }
}

之后 onStart/onStop 自动回调到 observer，不用在 Activity 里手写。

自定义 LifecycleOwner

自己写的类也能实现 LifecycleOwner：

class MyComponent : LifecycleOwner {
    private val lifecycleRegistry = LifecycleRegistry(this)

    override val lifecycle: Lifecycle = lifecycleRegistry

    fun start() {
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
    }

    fun stop() {
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
    }
}

LifecycleRegistry 是 Lifecycle 的实现类，用 handleLifecycleEvent 派发事件。

Compose 里的 Lifecycle

Compose 的可组合函数没有传统意义的方法回调，但能通过 LocalLifecycleOwner 拿到当前 LifecycleOwner。

观察生命周期状态：

@Composable
fun CurrentLifecycleState() {
    val lifecycleOwner = LocalLifecycleOwner.current
    val state by lifecycleOwner.lifecycle.currentStateFlow.collectAsState()
    Text("当前状态：$state")
}

或者一行：

val state = LocalLifecycleOwner.current.lifecycle.currentStateAsState()

LifecycleEffect 系列

Compose 里有几个生命周期副作用，专门用来在生命周期事件时跑代码：

LifecycleEventEffect

特定事件时跑一次：

@Composable
fun AnalyticsTracker(screenName: String) {
    LifecycleEventEffect(Lifecycle.Event.ON_RESUME) {
        Analytics.logView(screenName)
    }
}

LifecycleStartEffect

ON_START 启动，ON_STOP 清理：

@Composable
fun LocationMonitor(manager: LocationManager) {
    LifecycleStartEffect(manager) {
        val listener = LocationListener { /* update UI */ }
        manager.requestLocationUpdates(listener)

        onStopOrDispose {
            manager.removeUpdates(listener)
        }
    }
}

LifecycleResumeEffect

ON_RESUME 启动，ON_PAUSE 清理：

@Composable
fun CameraPreview(controller: CameraController) {
    LifecycleResumeEffect(controller) {
        controller.startPreview()

        onPauseOrDispose {
            controller.stopPreview()
        }
    }
}

collectAsStateWithLifecycle

收集 Flow 时用 collectAsStateWithLifecycle，应用进后台自动停止收集：

val state by viewModel.uiState.collectAsStateWithLifecycle()

来自 lifecycle-runtime-compose 库。比 collectAsState 省电，因为后台时不浪费 CPU 收集数据。

repeatOnLifecycle

View 体系下，在协程里收集 Flow 时手动控制生命周期：

lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        viewModel.uiState.collect { state ->
            // 只在 STARTED 以上才收集
        }
    }
}

应用进后台时取消收集，回到前台自动恢复。

LifecycleService

普通 Service 没有 LifecycleOwner。要给 Service 加生命周期感知，继承 LifecycleService：

class MyService : LifecycleService() {
    override fun onCreate() {
        super.onCreate()
        lifecycle.addObserver(myObserver)
    }
}

来自 lifecycle-service 库。适合 Service 里要管理生命周期感知组件的场景。

ProcessLifecycleOwner

想知道整个应用是前台还是后台，用 ProcessLifecycleOwner：

class App : Application() {
    override fun onCreate() {
        super.onCreate()
        ProcessLifecycleOwner.get().lifecycle.addObserver(object : DefaultLifecycleObserver {
            override fun onStart(owner: LifecycleOwner) {
                Log.d("App", "进入前台")
            }
            override fun onStop(owner: LifecycleOwner) {
                Log.d("App", "进入后台")
            }
        })
    }
}

来自 lifecycle-process 库。适合做「应用进后台时暂停某些操作」「回到前台时刷新」这种全局逻辑。

常见用例

• 位置监听：前台时细粒度更新，后台时停。
• 视频缓冲：onResume 开始，onPause 暂停。
• 相机预览：onResume 启动，onPause 释放。
• 网络套接字：前台收消息，后台断开。
• 埋点：onResume 记录页面曝光，onStop 记录离开。
• 动画：onPause 暂停，onResume 恢复。

常见坑

1. Fragment 用 this 而不是 viewLifecycleOwner：Fragment 视图销毁后 observer 还在，崩或者泄漏。
2. LifecycleObserver 用注解方式：已废弃，编译警告。用 DefaultLifecycleObserver。
3. collectAsState 不带 WithLifecycle：后台还在收集，浪费电。
4. 在 Lifecycle 销毁后调操作：比如 onDestroy 后还更新 LiveData，崩。
5. ProcessLifecycleOwner 当成 Activity 生命周期用：它是应用级的，不区分哪个 Activity。

小结

Lifecycle 组件让普通类感知 Activity/Fragment 生命周期，自动启停资源。DefaultLifecycleObserver 实现观察者，lifecycle.addObserver() 注册。Compose 里用 LifecycleStartEffect/LifecycleResumeEffect/LifecycleEventEffect 挂副作用，collectAsStateWithLifecycle 收集 Flow 省电。ProcessLifecycleOwner 监听应用前后台切换。

下一章讲 MVVM 架构，把前面学的 ViewModel、LiveData/Flow、Repository 串成完整架构。