Jetpack Compose对话框正确用法：如何传递操作Lambda并保存状态

核心问题很明确：rememberSaveable只能序列化保存纯数据，Lambda这类函数类型没法被序列化，所以不能把() -> Unit放进你的OptionsDialogState里。下面给你几个接地气的解决方案：

方案一：用标识符映射回调（最推荐） #

把选项的操作和纯数据彻底分开，只在状态里存可序列化的标识符，回调在调用对话框时临时传递：

1. 先修改你的OptionsDialogState，让选项只包含纯数据+唯一标识符：

data class OptionsDialogState(
    val isVisible: Boolean = false,
    val title: String = "",
    val options: List<DialogOption> = emptyList()
)

// 只存纯数据，用id做唯一标识（用枚举更安全）
data class DialogOption(
    val id: String,
    val text: String,
    val iconResId: Int? = null
)

2. 封装对话框控制器，分离可保存状态和临时回调：

class OptionsDialogController {
    // 仅存可序列化的纯数据，用rememberSaveable保证状态恢复
    val state = rememberSaveable { mutableStateOf(OptionsDialogState()) }
    // 临时存储回调，不用saveable（对话框关闭后自动清空）
    var onOptionSelected: ((String) -> Unit)? by mutableStateOf(null)
}

// 用CompositionLocal全局提供控制器
val LocalOptionsDialogController = compositionLocalOf<OptionsDialogController> {
    error("No OptionsDialogController provided")
}

3. 根节点的通用对话框实现：

@Composable
fun OptionsDialog() {
    val controller = LocalOptionsDialogController.current
    val currentState = controller.state.value

    if (currentState.isVisible) {
        BottomSheetDialog(
            onDismissRequest = {
                controller.state.value = currentState.copy(isVisible = false)
                controller.onOptionSelected = null // 清空回调
            }
        ) {
            Column(modifier = Modifier.padding(16.dp)) {
                Text(
                    text = currentState.title,
                    style = MaterialTheme.typography.headlineSmall
                )
                Spacer(modifier = Modifier.height(16.dp))
                currentState.options.forEach { option ->
                    ListItem(
                        onClick = {
                            // 根据标识符触发对应回调
                            controller.onOptionSelected?.invoke(option.id)
                            controller.state.value = currentState.copy(isVisible = false)
                            controller.onOptionSelected = null
                        },
                        leadingContent = {
                            option.iconResId?.let {
                                Icon(
                                    painter = painterResource(it),
                                    contentDescription = null
                                )
                            }
                        },
                        headlineContent = { Text(option.text) }
                    )
                }
            }
        }
    }
}

4. 任意子组件中调用对话框：

val dialogController = LocalOptionsDialogController.current

Button(onClick = {
    // 更新可保存的对话框状态
    dialogController.state.value = OptionsDialogState(
        isVisible = true,
        title = "请选择操作",
        options = listOf(
            DialogOption(id = "delete", text = "删除", iconResId = R.drawable.ic_delete),
            DialogOption(id = "share", text = "分享", iconResId = R.drawable.ic_share)
        )
    )
    // 绑定当前场景的回调逻辑
    dialogController.onOptionSelected = { id ->
        when(id) {
            "delete" -> { /* 执行删除逻辑 */ }
            "share" -> { /* 执行分享逻辑 */ }
        }
    }
}) {
    Text("打开对话框")
}

方案二：直接在显示处绑定回调（适合非全局场景） #

如果你的对话框不需要全局复用，也可以放弃CompositionLocal，直接在需要的地方控制显示并绑定回调：

@Composable
fun SomeScreen() {
    val showDialog = rememberSaveable { mutableStateOf(false) }

    Button(onClick = { showDialog.value = true }) {
        Text("打开对话框")
    }

    if (showDialog.value) {
        BottomSheetDialog(onDismissRequest = { showDialog.value = false }) {
            Column(modifier = Modifier.padding(16.dp)) {
                Text("请选择操作")
                Spacer(modifier = Modifier.height(16.dp))
                ListItem(
                    onClick = {
                        // 直接执行删除逻辑
                        showDialog.value = false
                    }
                ) { Text("删除") }
                ListItem(
                    onClick = {
                        // 直接执行分享逻辑
                        showDialog.value = false
                    }
                ) { Text("分享") }
            }
        }
    }
}

关键提醒 #

• 永远不要尝试把Lambda放进rememberSaveable，函数类型无法序列化，强行存储会导致状态恢复异常。
• 可保存状态只放纯数据（字符串、数字、枚举、可序列化数据类），回调这类临时逻辑要么用标识符映射，要么用临时变量持有，对话框关闭后及时清空。

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