问题[android-jetpack-compose](coding)

我正在制作一个 Kotlin Multiplatform / Compose Multiplatform 应用程序。我想要这种图表：

• 启动画面
• 验证屏幕
• 主图
  • 主屏幕
  • ...
  • 设置屏幕

我想要一个导航栏来浏览我的主图，但显然，当我在 SplashScreen 或 AuthScreen 上时，我不想有这个导航栏。我以为这很容易，但奇怪的是，我找不到任何帖子询问这个问题，也找不到任何关于这个问题的文档。而且 ChatGPT 一直给我根本不起作用的代码。

我尝试在可组合块中使用另一个 NavHost，但是不起作用。就像这样：

val navController = rememberNavController()
NavHost(
    navController = navController,
    startDestination = Destination.Splash
) {
    composable<Destination.Splash> {
        SplashScreenRoot()
    }
    composable<Destination.Auth> {
        AuthScreenRoot()
    }
    composable<Destination.Main> {
        // Add navigation here
        NavHost(
            navController = navController,
            startDestination = Destination.Main.Home
        ) {
            composable<Destination.Main.Home> {
                HomeScreenRoot()
            }
            composable<Destination.Main.Settings> {
                SettingsScreenRoot()
            }
        }
    }
}

我已经看到了一种方法来做到这一点，即使用导航栏并根据当前路线显示它，但似乎很奇怪，因为这是一个非常基本的情况，所以没有更简洁的方法来做到这一点。

我知道我可以利用Modifier.fillMaxHeight(0.8f)80％的可用高度。

但是，我希望有一个修饰符可以包裹内容高度，但不超过可用高度的 80%。因此，如果内容仅覆盖可用高度的 40%，那就没问题。如果它覆盖 90%，我只想要 80%。有什么方法可以编写这样的修饰符吗？

我正在尝试绘制带有各个部分的饼图并显示每个部分的标签。标签应显示在每个部分的开头，并与饼图保持 10dp 的间距。

这是我的代码：

@Composable
fun PieChartLocal(
    modifier: Modifier = Modifier,
    width: Float,
    thickness: Float,
    duration: Int,
    sections: List<Section>,
) {
    val sweepAngles = remember(sections) { findSweepAngles(sections) }
    val animateFloat = remember { Animatable(0f) }

    val density = LocalDensity.current
    val paddingDp = 18.dp
    val textSizeDp = 10.sp
    val paddingPx = with(density) { paddingDp.toPx() }

    val textSizePx = with(density) { textSizeDp.toPx() }

    LaunchedEffect(animateFloat) {
        animateFloat.animateTo(
            targetValue = 1f,
            animationSpec = tween(durationMillis = duration, easing = LinearEasing)
        )
    }

    Canvas(
        modifier = modifier
            .size((width + 2 * (paddingDp.value + textSizeDp.value)).dp)
    ) {
        var startAngle = 0f
        val radius =
            (size.minDimension - 2 * (paddingPx + textSizePx)) / 2
        val center = size.center

        for (i in sweepAngles.indices) {
            val sweepAngle = sweepAngles[i] * animateFloat.value
            val color = sections[i].color

            drawArc(
                color = color,
                startAngle = startAngle,
                sweepAngle = sweepAngle,
                useCenter = false,
                style = Stroke(width = thickness),
                topLeft = Offset(center.x - radius, center.y - radius),
                size = Size(radius * 2, radius * 2),
            )

            val angleInRadians = Math.toRadians(startAngle.toDouble())
            val textRadius = radius + paddingPx
            val x = center.x + textRadius * cos(angleInRadians).toFloat()
            val y = center.y + textRadius * sin(angleInRadians).toFloat()

            val percentage = (sweepAngles[i] / ROUND_ANGLE * 100).toInt()
            
            drawContext.canvas.nativeCanvas.apply {
                drawText(
                    "$percentage%",
                    x,
                    y,
                    TextPaint().apply {
                        textAlign = Paint.Align.CENTER
                        textSize = textSizePx
                    }
                )
            }

            startAngle += sweepAngle
        }
    }
}

private fun findSweepAngles(sections: List<Section>): List<Float> {
    val values = sections.map(Section::value)
    val sumValues = values.sum()
    return values.map { value -> ROUND_ANGLE * value / sumValues }
}

问题是，对于某些标签，我的饼图偏移量不正确。对于许多标签，它等于预期的 10dp，而对于其余标签，它完全不存在。可能是什么问题？

请帮我..

我有一个光标图标，我想让它在用户拖动它时保持在用户手指的中心，但是由于触摸误差和其他各种原因，它不能通过 onDrag 中的拖动量简单地更新视图的偏移量来保持中心位置。

我以为我可以计算触摸点的全局 XY 并将其设置为该值，但如果不执行诸如使用 pointerInterop 修饰符之类的令人沮丧的操作，则很难在 Compose 中获取该值。

     onDrag = { change, dragAmount ->
                    change.consume()

                    params.x += dragAmount.x.toInt()
                    params.y += dragAmount.y.toInt()
                    wm.updateViewLayout(composeView, params)
                   
                }

更新 1

肯定有一些明显的数学知识我没注意到。我能够通过将视图按偏移量移动，将视图的中心点与用户在 DragStart 上的手指同步，如下所示：

onDragStart = {
    params.x = params.x + it.x.toInt() - (composeView.width / 2)
    params.y = params.y + it.y.toInt() - (composeView.height / 2)
    wm.updateViewLayout(composeView, params)
},
onDrag = { change, dragAmount ->
    change.consume()
    //cant do that here though so doing the normal way below
    // params.x = params.x + change.position.x.toInt() - (composeView.width / 2)
    // params.y = params.y + change.position.y.toInt() - (composeView.height / 2)
    params.x += dragAmount.x.toInt()
    params.y += dragAmount.y.toInt()
   
    wm.updateViewLayout(composeView, params)
}

如果我注释掉 dragamount 增量方式并使用调整后的方式，拖动它时它会变得不稳定，疯狂地跳来跳去。

我尝试了一些其他技术，例如使用awaitEachGesture（如下所示）drag来摆脱触摸倾斜检测，但这并没有让我更接近目标。
真正的问题似乎发生在用户拖动速度非常慢的时候。如果你拖动得非常慢，出于某种原因，你的手指就会从视图中移开。这就像视图对非常微小的移动没有​​反应一样。
我想要做的就是让视图保持在触摸点的中心。这似乎应该只是一些具有现有可用参数的公式。

 .pointerInput(Unit) {
                awaitEachGesture {
                    val down = awaitFirstDown()

                    drag(down.id) { change ->
                        val posChange = change.positionChange()
                        val pos = change.position
                        Log.i("await gesture drag", "change: ${pos}")
                        Log.i("await gesture drag", "poschange: ${posChange}")
                        change.consume()
                        params.x += posChange.x.toInt()
                        params.y += posChange.y.toInt()
                       // params.x = params.x + pos.x.toInt() - (composeView.width / 2)
                       // params.y = params.y + pos.y.toInt() - (composeView.height / 2)
                        wm.updateViewLayout(composeView, params)
                    }

                }
            }

我还制作了此 GIF 来展示问题。首先，您可以看到，即使我移动得很快，触摸点也会有一些漂移。它会移到圆圈的边缘。更糟糕的是，如果我移动得非常慢，它会漂移很多。

更新 2

我刚刚意识到这可能是因为布局参数 x 和 y 的拖动量必须四舍五入为整数。我明天会调查一下。

imgur 问题的 GIF

更新 3

我关于舍入的理论是正确的。当您非常缓慢地拖动时，更改位置/拖动量浮点.toInt()会向下舍入为零，并且不会造成任何移动。将其更改为roundToInt也不起作用，因为缓慢的移动会在向上舍入时慢慢爬过您的手指。对我来说，解决方案是使用浮点累加器，这样小的拖动量就不会被吞没。我猜这是因为我围绕父 ComposeView 移动，而不是从触摸元素自己的.offset修饰符移动？我不太确定有什么区别，因为我知道您不需要通常的拖动技术累加器，也许引擎盖下有一个隐藏的累加器？

            .pointerInput(Unit) {

                val center = size.center

                awaitEachGesture {
                    val down = awaitFirstDown()

                    params.x += (down.position.x - center.x).roundToInt()
                    params.y += (down.position.y - center.y).roundToInt() 
                    wm.updateViewLayout(composeView, params)

                    drag(down.id) { change ->
                        val posChange = change.positionChange()

                        change.consume()

                        accumulatedX += posChange.x
                        accumulatedY += posChange.y

                        val deltaX = accumulatedX.toInt()
                        val deltaY = accumulatedY.toInt()

                        accumulatedX -= deltaX
                        accumulatedY -= deltaY

                        params.x += deltaX
                        params.y += deltaY
                        wm.updateViewLayout(composeView, params)
                    }

                }
            }

我正在批量读取一个大文件（从第一行开始向下读取）。当用户到达一批文件的末尾时，我希望他们能够向上滑动（将手指从列表底部拖到顶部）以加载更多内容。

Material3pullToRefresh工作正常，但前提是要从上往下拉。有没有办法反转方向？我想不通。我可以检测到我何时位于列表底部，但我希望拉动...所以这个动作是故意的。

val pullToRefreshState = rememberPullToRefreshState()

LazyColumnScrollbar(
    state = listState,
    modifier = Modifier.pullToRefresh(
        isRefreshing = isLoading.value,
        state = pullToRefreshState,
        enabled = true,
        onRefresh = { refresh() },
        *** direction = BottomTop *** // something like that 
    )
) {
    LazyColumn(){}
}

或者有其他替代方案吗？

为什么每次点击按钮都会重组两次？

代码片段：

var counter by remember { mutableIntStateOf(0) }
Button(onClick = { counter++ }) {
  Text(text = "I've been clicked $counter times")
}

观察：

当按钮被点击 x 次时，根据布局检查器，按钮会被重组 2 次。

我有一行，其中有一个文本模块，后面跟着一个图像模块。如果文本很长，它会挤掉图像。但如果我给文本加权，这个问题就解决了，但文本块会占用可用空间，而不是换行，而这正是我想要的。

使用以下代码，包括文本上的 Weight Modifier，它解决了图像被推开的问题。但如果标题很短，则文本不会换行，如下所示： 带权重，长标题 带权重，短标题

但是，如果不使用 Weight，我会得到我想要的文本换行，但如果标题很长，我会丢失此处显示的图像： 无权重，长标题 无权重，短标题

我如何保护图像并保持文本换行？

@Composable
fun TitleAndChevron() {
    Row(
        verticalAlignment = Alignment.CenterVertically,
        modifier = Modifier
            .padding(8.dp)
            .background(color = Color.Black)
            .wrapContentWidth(align = Alignment.Start),
    ) {
        Text(
            text = "The Englishman Who Went Up a Hill But Came Down a Mountain",
            color = Color.White,
            maxLines = 1,
            overflow = TextOverflow.Ellipsis,
            style = MaterialTheme.typography.titleLarge,
            modifier = Modifier
                .padding(8.dp)
                .weight(1f)
        )
        Image(
            painter = painterResource(id = R.drawable.ic_chevron),
            contentDescription = null,
            modifier = Modifier
                .padding(start = 8.dp, end = 8.dp)
                .size(12.dp),
        )
    }
}

我有以下聊天视图，但是行中的最后一个元素（KeyboardArrowRight 图标）没有显示。我无论如何也想不出为什么。任何对此有新见解的人都将不胜感激！

如果我对中间元素（包含个人资料名称、发送时间、最后一条消息和未读消息圆圈指示器的中间列）应用固定宽度修饰符，则会显示 KeyboardArrowRight 图标，但显然不想这样做，因为它在不同宽度的屏幕上看起来不太好

@Composable
fun ChatView() {

    val configuration = LocalConfiguration.current
    val screenWidth = configuration.screenWidthDp.dp
    val chatIsNew = true

    val chats = 4
    
    LazyVerticalGrid(
        columns = GridCells.Fixed(1),
        contentPadding = PaddingValues(30.dp),
        verticalArrangement = Arrangement.spacedBy(10.dp),
    ) {

        items(chats) { chat ->

            Row(
                horizontalArrangement = Arrangement.spacedBy(10.dp),
                verticalAlignment = Alignment.CenterVertically,
                modifier = Modifier
                    .fillMaxWidth()
                    .border(
                        width = 1.dp,
                        color = Color.Black,
                        shape = RoundedCornerShape(5.dp)
                    )
                    .padding(10.dp)
            ) {

                //Profile image
                Box(
                    contentAlignment = Alignment.Center,
                    modifier = Modifier
                        .size(
                            screenWidth / 4.25F,
                            screenWidth / 4.25F
                        )
                        .background(
                            color = Color.Black.copy(alpha = 0.1F),
                            shape = CircleShape
                        )
                ) {
                }



                Column(
                    verticalArrangement = Arrangement.spacedBy(5.dp),
                    horizontalAlignment = Alignment.Start,
                ) {

                    Row(
                        verticalAlignment = Alignment.CenterVertically
                    ) {

                        //Profile Name
                        Text(
                            text = "Profile Name",
                            style = TextStyle(
                                fontSize = 18.sp,
                                fontWeight = FontWeight.Bold,
                                textAlign = TextAlign.Center,
                                color = if (isSystemInDarkTheme()) {
                                    Color.White
                                } else {
                                    Color.Black
                                },
                            ),
                            maxLines = 1
                        )


                        Spacer(modifier = Modifier.weight(1F))


                        //Sent time
                        Text(
                            text = "10:00",
                            style = TextStyle(
                                fontSize = 14.sp,
                                textAlign = TextAlign.Center,
                                color = Color.Gray,
                            )
                        )
                    }


                    Row(
                        verticalAlignment = Alignment.CenterVertically
                    ) {
                        //Last message
                        Text(
                            text = "Last message to go here",
                            style = TextStyle(
                                fontSize = 14.sp,
                                textAlign = TextAlign.Start,
                                color = Color.Gray,
                            ),
                            maxLines = 2,
                            overflow = TextOverflow.Ellipsis,
                        )


                        Spacer(modifier = Modifier.weight(1F))


                        //New chat and unread message circle indicator
                        if (chatIsNew == true) {

                            Box(
                                contentAlignment = Alignment.Center,
                                modifier = Modifier
                                    .size(12.dp)
                                    .background(
                                        color = Color.Blue.copy(alpha = 0.75F),
                                        shape = CircleShape
                                    )
                            ) {
                            }

                        }
                    }
                }



                Icon(
                    imageVector = Icons.Rounded.KeyboardArrowRight,
                    contentDescription = "null",
                    tint = Color.Gray,
                    modifier = Modifier.size(25.dp)
                )


            }

        }
    }

}

假设有一家餐厅，里面有以下桌子 -

@Entity(tablename = "pizza-sales")
data class Pizza(  
  val id,
  val name,
  val price,
  val quantitySold,
  val date,
) //Pizza sales of a day

@Entity(tablename = "burger-sales")
data class Burger(
  val id,
  val name,
  val price,
  val quantitySold,
  val date,
) //Burger sales of a day

现在，我想要第三个表（总销售额），其中的行是根据上面的表格计算出来的

@Entity(tablename= "total-sales")
data class TotalSales(
  val id,
  val date,
  val totalQuantity = Sum(Pizza[quantitySold]) + Sum(Burger[quantitySold]),
  val totalPrice = Sum(Pizza[quantitySold * price]) + Sum(Burger[quantitySold * price])
) //Total sales of a day

请注意，我对 Pizza、Burger 进行了求和，其中 TotalSales.date = (Burger/Pizza).date。

另外，是否可以在查询中进行这样的算术运算-

@Dao
interface ToatalSalesDao {
    @Query(
        "ADD pizza-sales.quantitySold WHERE pizza-sales.date = :date"+
        "ADD"+
        "ADD burger-sales.quantitySold WHERE burger-sales.date = :date"
        )
    fun loadTotalSalesQuantityOfTheDay(date: String): Int
}

在这个Google Codelab (Mars Photos) 中，当 Coil 加载图像时，应用程序会显示一个进度轮。代码使用此 XML 文件作为可绘制对象：

并使用此代码来显示它：

@Composable
fun LoadingScreen(modifier: Modifier = Modifier) {
    Box(
        contentAlignment = Alignment.Center,
        modifier = modifier.fillMaxSize()
    ) {
        Image(
            modifier = Modifier.size(200.dp),
            painter = painterResource(R.drawable.loading_img),
            contentDescription = stringResource(R.string.loading)
        )
    }
}

但是，这只能显示静态图像。我希望它旋转（这是我当然期望的行为）。我想到了一些方法，但我都不太喜欢：

• 定义 12 个类似的 XML 文件，每个旋转度一个，并按顺序连续显示每个文件
• 动态生成 XML 并以某种方式将其动态转换为画家
• 使用 Coil 加载 GIF

有没有更简单的方法来完成这项任务？ 有没有办法以编程方式旋转图像本身，例如应用某种预定义的动画模式（可能类似于 basicMarquee）？