我有一个类似的用例，我需要显示2-3个堆叠的底页。我最终复制了大部分的Compose BottomSheet，并添加了所需的行为：

enum class BottomSheetValue { SHOWING, HIDDEN }
@Composable
fun BottomSheet(
        parentHeight: Int,
        topOffset: Dp = 0.dp,
        fillMaxHeight: Boolean = false,
        sheetState: SwipeableState<BottomSheetValue>,
        shape: Shape = bottomSheetShape,
        backgroundColor: Color = MaterialTheme.colors.background,
        contentColor: Color = contentColorFor(backgroundColor),
        elevation: Dp = 0.dp,
        content: @Composable () -> Unit
) {
    val topOffsetPx = with(LocalDensity.current) { topOffset.roundToPx() }
    var bottomSheetHeight by remember { mutableStateOf(parentHeight.toFloat())}
    val scrollConnection = sheetState.PreUpPostDownNestedScrollConnection
    BottomSheetLayout(
        maxHeight = parentHeight - topOffsetPx,
        fillMaxHeight = fillMaxHeight
    ) {
        val swipeable = Modifier.swipeable(
            state = sheetState,
            anchors = mapOf(
                parentHeight.toFloat() to BottomSheetValue.HIDDEN,
                parentHeight - bottomSheetHeight to BottomSheetValue.SHOWING
            ),
            orientation = Orientation.Vertical,
            resistance = null
        )
        Surface(
            shape = shape,
            color = backgroundColor,
            contentColor = contentColor,
            elevation = elevation,
            modifier = Modifier
                .nestedScroll(scrollConnection)
                .offset { IntOffset(0, sheetState.offset.value.roundToInt()) }
                .then(swipeable)
                .onGloballyPositioned {
                    bottomSheetHeight = it.size.height.toFloat()
                },
        ) {
            content()
        }
    }
}
@Composable
private fun BottomSheetLayout(
        maxHeight: Int,
        fillMaxHeight: Boolean,
        content: @Composable () -> Unit
) {
    Layout(content = content) { measurables, constraints ->
        val sheetConstraints =
            if (fillMaxHeight) {
                constraints.copy(minHeight = maxHeight, maxHeight = maxHeight)
            } else {
                constraints.copy(maxHeight = maxHeight)
            }
        val placeable = measurables.first().measure(sheetConstraints)
        layout(placeable.width, placeable.height) {
            placeable.placeRelative(0, 0)
        }
    }
}

顶部偏移，例如允许将bottomSheet放置在AppBar下面：

BoxWithConstraints {
 BottomSheet(
                parentHeight = constraints.maxHeight,
                topOffset = with(LocalDensity.current) {56.toDp()}
                fillMaxHeight = true,
                sheetState = yourSheetState,
            ) {
                content()
            }
}

我是这样实现的。它看起来很简单，但我仍然不知道如何将参数直接传递给“mutableStateOf（）”，我必须创建一个变量“content”

fun Screen() {
    val bottomSheetState = rememberModalBottomSheetState(ModalBottomSheetValue.Hidden)
    val scope = rememberCoroutineScope()
    val content: @Composable (() -> Unit) = { Text("NULL") }
    var customSheetContent by remember { mutableStateOf(content) }
    ModalBottomSheetLayout(
        sheetState = bottomSheetState,
        sheetContent = {
            customSheetContent()
        }
    ) {
        Column {
        Button(
            onClick = {
                customSheetContent = { SomeComposable1() }
                scope.launch { bottomSheetState.show() }
        }) {
         Text("First Button")
        }
        Button(
            onClick = {
                customSheetContent = { SomeComposable2() }
                scope.launch { bottomSheetState.show() }
        }) {
         Text("Second Button")
        }
    }
    }

我想实现同样的事情，因为大的解决方案，我写了一篇文章在dev.to解决这个问题，这里是link

这个解决方案适用于 N 数量的底部片材，甚至如果你想堆叠它们也可以工作，下面是实现：

typealias BottomSheetControl = Pair<ModalBottomSheetState, @Composable ColumnScope.() -> Unit> 
@Composable
fun HeaderContentMultipleBottomSheetsTemplate(
    finalContent: @Composable () -> Unit,
    sheetsShape: Shape = ServyUIShapesDefaults.RoundedRectangle,
    vararg sheets: BottomSheetControl
) {
    HeaderContentBottomSheetsTemplateImpl(
        finalContent = finalContent,
        sheetsShape = sheetsShape,
        sheets = sheets,
    )
}
@Composable
private fun HeaderContentBottomSheetsTemplateImpl(
    modifier: Modifier = Modifier,
    finalContent: @Composable () -> Unit,
    scrimColor: Color = ModalBottomSheetDefaults.scrimColor,
    sheetsShape: Shape = ServyUIShapesDefaults.RoundedRectangle,
    vararg sheets: BottomSheetControl
) {
    if (sheets.isNotEmpty()) {
        ModalBottomSheetLayout(
            modifier = modifier,
            sheetState = sheets[0].first,
            sheetContent = sheets[0].second,
            sheetShape = sheetsShape,
            scrimColor = scrimColor
        ) {
            HeaderContentBottomSheetsTemplateImpl(
                finalContent = finalContent,
                sheets = sheets.sliceArray(1 until sheets.size)
            )
        }
    } else {
        finalContent() // Here is your Screen Content
    }
}

对于实现，您需要具有以下内容：

// The sheet state, you can manipulate it whatever you want.
val testSheetState= rememberModalBottomSheetState(
        initialValue = ModalBottomSheetValue.Hidden,
        animationSpec = tween(durationMillis = 100),
        confirmValueChange = { it != ModalBottomSheetValue.HalfExpanded },
        skipHalfExpanded = true,
    )
// The sheet content.
@Composable
fun TestSheet(): @Composable ColumnScope.() -> Unit = {
    Text(text = "LOLLL")
}
// The Pair of state and content 
val test: BottomSheetControl = Pair(testSheetState, TestSheet())

最后，你可以：

HeaderContentMultipleBottomSheetsTemplate(
    finalContent = {
        // Here the content of your screen (in ColumnScope)
    },
    sheets = arrayOf(test)
)

Pd：vararg参数“sheets”中的项目顺序定义了每个项目的级别，如果你想堆叠它们，请按嵌套顺序编写。