Jetpack Compose组件生命周期事件检测不一致问题排查

我在Jetpack Compose中实现了监听生命周期事件的函数rememberLifecycleEvent，代码如下：

fun rememberLifecycleEvent(lifecycleOwner: LifecycleOwner = LocalLifecycleOwner.current): Lifecycle.Event {
var state by remember { mutableStateOf(Lifecycle.Event.ON_ANY) }
DisposableEffect(lifecycleOwner) {
    val observer = LifecycleEventObserver { _, event ->
        Log.v("log", "event  : $event")

        state = event
    }
    lifecycleOwner.lifecycle.addObserver(observer)
    onDispose {
        lifecycleOwner.lifecycle.removeObserver(observer)
    }
}
Log.v("log", "$state")

return state
}

在Composable中使用时，通过LaunchedEffect响应事件：

val lifecycleEvent = rememberLifecycleEvent()

LaunchedEffect(lifecycleEvent) {
    when (lifecycleEvent) {
        Lifecycle.Event.ON_START -> {
            // 处理逻辑
        }
        Lifecycle.Event.ON_RESUME -> {
            // 处理逻辑
        }
        else -> {}
    }
}

遇到的问题是：日志中能看到ON_START事件被触发，但LaunchedEffect有时无法捕获到该事件，怀疑和mutableState有关，但找不到具体原因。

问题原因 #

核心问题在于**mutableStateOf的状态覆盖特性**和Composable重组的异步性：

当页面从后台回到前台时，生命周期事件会按ON_START→ON_RESUME的顺序快速触发。mutableStateOf只会存储最新的状态值，当state刚被设置为ON_START，还没等Composable完成重组并让LaunchedEffect感知到这个状态，state就被紧接着的ON_RESUME事件覆盖了。最终LaunchedEffect只会接收到最后一次的状态更新，导致中间的ON_START被跳过。

修复方案 #

方案1：改用SharedFlow收集所有事件（推荐） #

利用SharedFlow的流式特性，确保每个生命周期事件都能被单独捕获和处理：

fun rememberLifecycleEvents(lifecycleOwner: LifecycleOwner = LocalLifecycleOwner.current): Flow<Lifecycle.Event> {
    return remember(lifecycleOwner) {
        callbackFlow {
            val observer = LifecycleEventObserver { _, event ->
                Log.v("log", "event  : $event")
                trySend(event) // 将事件发送到Flow中
            }
            lifecycleOwner.lifecycle.addObserver(observer)
            awaitClose {
                lifecycleOwner.lifecycle.removeObserver(observer) // 清理观察者
            }
        }.distinctUntilChanged() // 过滤重复事件
    }
}

使用方式：

val lifecycleEvents = rememberLifecycleEvents()

LaunchedEffect(Unit) {
    lifecycleEvents.collect { event ->
        when (event) {
            Lifecycle.Event.ON_START -> {
                // 处理ON_START逻辑
            }
            Lifecycle.Event.ON_RESUME -> {
                // 处理ON_RESUME逻辑
            }
            else -> {}
        }
    }
}

方案2：给状态添加版本号（兼容原有逻辑） #

如果希望保留mutableState的使用方式，可以给每个事件添加一个递增的版本号，强制每次事件都触发LaunchedEffect执行：

fun rememberLifecycleEvent(lifecycleOwner: LifecycleOwner = LocalLifecycleOwner.current): Pair<Lifecycle.Event, Int> {
    var state by remember { mutableStateOf(Lifecycle.Event.ON_ANY) }
    var version by remember { mutableStateOf(0) }
    
    DisposableEffect(lifecycleOwner) {
        val observer = LifecycleEventObserver { _, event ->
            Log.v("log", "event  : $event")
            state = event
            version++ // 每次事件更新版本号
        }
        lifecycleOwner.lifecycle.addObserver(observer)
        onDispose {
            lifecycleOwner.lifecycle.removeObserver(observer)
        }
    }
    return state to version
}

使用方式：

val (lifecycleEvent, eventVersion) = rememberLifecycleEvent()

LaunchedEffect(lifecycleEvent, eventVersion) {
    when (lifecycleEvent) {
        Lifecycle.Event.ON_START -> {
            // 处理ON_START逻辑
        }
        Lifecycle.Event.ON_RESUME -> {
            // 处理ON_RESUME逻辑
        }
        else -> {}
    }
}

内容的提问来源于stack exchange，提问作者joghm