当前位置：首页 > article >正文

Android Compose 切换按钮深度剖析：从源码到实践(六)

article 2025/3/22 19:37:36

Android Compose 切换按钮深度剖析：从源码到实践

一、引言

在现代 Android 应用开发中，用户交互体验至关重要。切换按钮（Toggle Button）作为一种常见的交互组件，允许用户在两种状态之间进行切换，例如开 / 关、选中 / 未选中等。Android Compose 作为 Google 推出的声明式 UI 工具包，为开发者提供了便捷的方式来创建和定制切换按钮。本文将深入 Android Compose 框架的切换按钮模块，从源码级别进行详细分析，帮助开发者更好地理解和运用切换按钮，提升应用的交互体验。

二、Android Compose 基础回顾

2.1 Compose 简介

Android Compose 是用于构建 Android UI 的现代工具包，它采用声明式编程范式，与传统的基于视图的 UI 系统相比，代码更加简洁、易于维护。通过使用可组合函数（Composable Functions），开发者可以描述 UI 的外观和行为，Compose 会自动处理布局和状态管理。

2.2 核心概念

2.2.1 可组合函数（@Composable）

可组合函数是 Compose 的核心概念，使用 @Composable 注解标记的函数可以用来构建 UI。这些函数可以调用其他可组合函数，从而构建出复杂的 UI 界面。

kotlin

import androidx.compose.runtime.Composable
import androidx.compose.material.Text

// 简单的可组合函数，显示文本
@Composable
fun SimpleText() {
    Text(text = "Hello, Compose!")
}

2.2.2 状态管理

Compose 提供了强大的状态管理机制，通过 mutableStateOf 函数可以创建可变状态。当状态发生变化时，Compose 会自动重新组合受影响的 UI 部分。

kotlin

import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.material.Text

@Composable
fun StatefulText() {
    // 创建可变状态，初始值为 "Hello"
    var text by mutableStateOf("Hello")
    // 显示文本
    Text(text = text)
    // 模拟状态变化
    text = "World"
}

三、切换按钮概述

3.1 切换按钮的作用

切换按钮在 Android 应用中广泛应用，用于让用户在两种状态之间进行快速切换。常见的使用场景包括开关功能、选择模式等。

3.2 Android Compose 中的切换按钮组件

在 Android Compose 中，主要有以下几种切换按钮组件：

Switch：经典的开关样式切换按钮。
Checkbox：复选框样式的切换按钮。
RadioButton：单选框样式的切换按钮。

3.3 简单示例

以下是一个简单的 Switch 组件示例：

kotlin

import androidx.compose.material.Switch
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.runtime.Composable

@Composable
fun SimpleSwitch() {
    // 创建可变状态，用于记录开关状态
    var isChecked by mutableStateOf(false)
    Switch(
        checked = isChecked,
        onCheckedChange = { isChecked = it }
    )
}

四、Switch 组件源码分析

4.1 Switch 组件定义

Switch 组件的定义位于 androidx.compose.material 包中，以下是简化后的源码：

kotlin

@Composable
fun Switch(
    checked: Boolean, // 当前开关状态
    onCheckedChange: (Boolean) -> Unit, // 状态改变时的回调函数
    modifier: Modifier = Modifier, // 修饰符，用于修改组件的外观和行为
    enabled: Boolean = true, // 组件是否可用
    colors: SwitchColors = SwitchDefaults.colors() // 开关的颜色设置
) {
    // 使用 Clickable 修饰符处理点击事件
    val interactionSource = remember { MutableInteractionSource() }
    val semanticsProperties = {
        SemanticsProperties.CheckableState provides CheckableState(checked)
        SemanticsProperties.ToggleableState provides ToggleableState(checked)
        SemanticsProperties.OnClickLabel provides if (checked) "Turn off" else "Turn on"
    }
    Box(
        modifier = modifier
           .clickable(
                interactionSource = interactionSource,
                indication = rememberRipple(bounded = false),
                enabled = enabled,
                onClick = { onCheckedChange(!checked) }
            )
           .semantics(mergeDescendants = true, properties = semanticsProperties)
           .then(Modifier.size(SwitchDefaults.SwitchWidth, SwitchDefaults.SwitchHeight))
    ) {
        // 绘制开关轨道
        val trackColor = colors.trackColor(enabled = enabled, checked = checked).value
        Canvas(
            modifier = Modifier
               .fillMaxSize()
               .padding(SwitchDefaults.TrackPadding)
        ) {
            drawRoundRect(
                color = trackColor,
                cornerRadius = SwitchDefaults.TrackCornerRadius
            )
        }
        // 绘制开关拇指
        val thumbColor = colors.thumbColor(enabled = enabled, checked = checked).value
        val thumbOffset = animateFloatAsState(
            targetValue = if (checked) SwitchDefaults.ThumbCheckedOffset else SwitchDefaults.ThumbUncheckedOffset,
            animationSpec = tween(durationMillis = SwitchDefaults.AnimationDuration)
        )
        Canvas(
            modifier = Modifier
               .size(SwitchDefaults.ThumbSize)
               .offset(x = thumbOffset.value)
               .align(Alignment.CenterStart)
        ) {
            drawCircle(
                color = thumbColor,
                radius = SwitchDefaults.ThumbRadius
            )
        }
    }
}

4.2 点击事件处理

Switch 组件使用 Clickable 修饰符处理点击事件。当用户点击开关时，会调用 onCheckedChange 回调函数，将新的开关状态传递给该函数。

kotlin

modifier.clickable(
    interactionSource = interactionSource,
    indication = rememberRipple(bounded = false),
    enabled = enabled,
    onClick = { onCheckedChange(!checked) }
)

4.3 状态动画

在开关状态切换时，使用 animateFloatAsState 函数实现拇指的动画效果。通过设置不同的目标值（SwitchDefaults.ThumbCheckedOffset 和 SwitchDefaults.ThumbUncheckedOffset），并指定动画规格（tween），实现平滑的动画过渡。

kotlin

val thumbOffset = animateFloatAsState(
    targetValue = if (checked) SwitchDefaults.ThumbCheckedOffset else SwitchDefaults.ThumbUncheckedOffset,
    animationSpec = tween(durationMillis = SwitchDefaults.AnimationDuration)
)

4.4 颜色设置

Switch 组件使用 SwitchColors 来设置开关的颜色，包括轨道颜色和拇指颜色。可以通过 SwitchDefaults.colors() 方法获取默认的颜色设置，也可以自定义颜色。

kotlin

val trackColor = colors.trackColor(enabled = enabled, checked = checked).value
val thumbColor = colors.thumbColor(enabled = enabled, checked = checked).value

五、Checkbox 组件源码分析

5.1 Checkbox 组件定义

Checkbox 组件的定义如下：

kotlin

@Composable
fun Checkbox(
    checked: Boolean, // 当前复选框状态
    onCheckedChange: ((Boolean) -> Unit)?, // 状态改变时的回调函数
    modifier: Modifier = Modifier, // 修饰符
    enabled: Boolean = true, // 组件是否可用
    colors: CheckboxColors = CheckboxDefaults.colors() // 复选框的颜色设置
) {
    val interactionSource = remember { MutableInteractionSource() }
    val semanticsProperties = {
        SemanticsProperties.CheckableState provides CheckableState(checked)
        SemanticsProperties.ToggleableState provides ToggleableState(checked)
        SemanticsProperties.OnClickLabel provides if (checked) "Uncheck" else "Check"
    }
    Box(
        modifier = modifier
           .clickable(
                interactionSource = interactionSource,
                indication = rememberRipple(bounded = false),
                enabled = enabled && onCheckedChange != null,
                onClick = { onCheckedChange?.invoke(!checked) }
            )
           .semantics(mergeDescendants = true, properties = semanticsProperties)
           .then(Modifier.size(CheckboxDefaults.Size))
    ) {
        // 绘制复选框背景
        val boxColor = colors.boxColor(enabled = enabled, checked = checked).value
        Canvas(
            modifier = Modifier
               .fillMaxSize()
               .padding(CheckboxDefaults.InnerPadding)
        ) {
            drawRoundRect(
                color = boxColor,
                cornerRadius = CheckboxDefaults.CornerRadius
            )
        }
        // 绘制复选框选中标记
        if (checked) {
            val checkmarkColor = colors.checkmarkColor(enabled = enabled, checked = checked).value
            Canvas(
                modifier = Modifier
                   .fillMaxSize()
                   .padding(CheckboxDefaults.InnerPadding)
            ) {
                drawPath(
                    path = Path().apply {
                        moveTo(size.width * 0.2f, size.height * 0.5f)
                        lineTo(size.width * 0.4f, size.height * 0.7f)
                        lineTo(size.width * 0.8f, size.height * 0.3f)
                    },
                    color = checkmarkColor,
                    strokeWidth = CheckboxDefaults.CheckmarkStrokeWidth
                )
            }
        }
    }
}

5.2 点击事件处理

与 Switch 类似，Checkbox 也使用 Clickable 修饰符处理点击事件。当用户点击复选框时，会调用 onCheckedChange 回调函数。

kotlin

modifier.clickable(
    interactionSource = interactionSource,
    indication = rememberRipple(bounded = false),
    enabled = enabled && onCheckedChange != null,
    onClick = { onCheckedChange?.invoke(!checked) }
)

5.3 绘制逻辑

Checkbox 组件的绘制分为两部分：背景和选中标记。当复选框被选中时，会绘制选中标记；未选中时，只绘制背景。

kotlin

// 绘制背景
val boxColor = colors.boxColor(enabled = enabled, checked = checked).value
drawRoundRect(
    color = boxColor,
    cornerRadius = CheckboxDefaults.CornerRadius
)

// 绘制选中标记
if (checked) {
    val checkmarkColor = colors.checkmarkColor(enabled = enabled, checked = checked).value
    drawPath(
        path = Path().apply {
            moveTo(size.width * 0.2f, size.height * 0.5f)
            lineTo(size.width * 0.4f, size.height * 0.7f)
            lineTo(size.width * 0.8f, size.height * 0.3f)
        },
        color = checkmarkColor,
        strokeWidth = CheckboxDefaults.CheckmarkStrokeWidth
    )
}

5.4 颜色设置

Checkbox 组件使用 CheckboxColors 来设置背景颜色和选中标记颜色。可以通过 CheckboxDefaults.colors() 方法获取默认的颜色设置，也可以自定义颜色。

kotlin

val boxColor = colors.boxColor(enabled = enabled, checked = checked).value
val checkmarkColor = colors.checkmarkColor(enabled = enabled, checked = checked).value

六、RadioButton 组件源码分析

6.1 RadioButton 组件定义

kotlin

@Composable
fun RadioButton(
    selected: Boolean, // 当前单选框是否选中
    onClick: (() -> Unit)?, // 点击事件回调函数
    modifier: Modifier = Modifier, // 修饰符
    enabled: Boolean = true, // 组件是否可用
    colors: RadioButtonColors = RadioButtonDefaults.colors() // 单选框的颜色设置
) {
    val interactionSource = remember { MutableInteractionSource() }
    val semanticsProperties = {
        SemanticsProperties.SelectableState provides SelectableState(selected)
        SemanticsProperties.OnClickLabel provides if (selected) "Unselect" else "Select"
    }
    Box(
        modifier = modifier
           .clickable(
                interactionSource = interactionSource,
                indication = rememberRipple(bounded = false),
                enabled = enabled && onClick != null,
                onClick = onClick
            )
           .semantics(mergeDescendants = true, properties = semanticsProperties)
           .then(Modifier.size(RadioButtonDefaults.Size))
    ) {
        // 绘制单选框外圈
        val outerColor = colors.unselectedColor(enabled = enabled).value
        Canvas(
            modifier = Modifier
               .fillMaxSize()
               .padding(RadioButtonDefaults.OuterPadding)
        ) {
            drawCircle(
                color = outerColor,
                radius = RadioButtonDefaults.OuterRadius
            )
        }
        // 绘制单选框内圈
        if (selected) {
            val innerColor = colors.selectedColor(enabled = enabled).value
            Canvas(
                modifier = Modifier
                   .fillMaxSize()
                   .padding(RadioButtonDefaults.InnerPadding)
            ) {
                drawCircle(
                    color = innerColor,
                    radius = RadioButtonDefaults.InnerRadius
                )
            }
        }
    }
}

6.2 点击事件处理

RadioButton 同样使用 Clickable 修饰符处理点击事件。当用户点击单选框时，会调用 onClick 回调函数。

kotlin

modifier.clickable(
    interactionSource = interactionSource,
    indication = rememberRipple(bounded = false),
    enabled = enabled && onClick != null,
    onClick = onClick
)

6.3 绘制逻辑

RadioButton 组件的绘制分为外圈和内圈。当单选框被选中时，会绘制内圈；未选中时，只绘制外圈。

kotlin

// 绘制外圈
val outerColor = colors.unselectedColor(enabled = enabled).value
drawCircle(
    color = outerColor,
    radius = RadioButtonDefaults.OuterRadius
)

// 绘制内圈
if (selected) {
    val innerColor = colors.selectedColor(enabled = enabled).value
    drawCircle(
        color = innerColor,
        radius = RadioButtonDefaults.InnerRadius
    )
}

6.4 颜色设置

RadioButton 组件使用 RadioButtonColors 来设置外圈和内圈的颜色。可以通过 RadioButtonDefaults.colors() 方法获取默认的颜色设置，也可以自定义颜色。

kotlin

val outerColor = colors.unselectedColor(enabled = enabled).value
val innerColor = colors.selectedColor(enabled = enabled).value

七、切换按钮的样式定制

7.1 自定义颜色

可以通过自定义 SwitchColors、CheckboxColors 和 RadioButtonColors 来改变切换按钮的颜色。

7.1.1 自定义 Switch 颜色

kotlin

import androidx.compose.material.Switch
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.runtime.Composable
import androidx.compose.ui.graphics.Color
import androidx.compose.material.SwitchDefaults

@Composable
fun CustomColorSwitch() {
    var isChecked by mutableStateOf(false)
    Switch(
        checked = isChecked,
        onCheckedChange = { isChecked = it },
        colors = SwitchDefaults.colors(
            checkedThumbColor = Color.Red,
            checkedTrackColor = Color.Blue,
            uncheckedThumbColor = Color.Green,
            uncheckedTrackColor = Color.Yellow
        )
    )
}

7.1.2 自定义 Checkbox 颜色

kotlin

import androidx.compose.material.Checkbox
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.runtime.Composable
import androidx.compose.ui.graphics.Color
import androidx.compose.material.CheckboxDefaults

@Composable
fun CustomColorCheckbox() {
    var isChecked by mutableStateOf(false)
    Checkbox(
        checked = isChecked,
        onCheckedChange = { isChecked = it },
        colors = CheckboxDefaults.colors(
            checkedColor = Color.Red,
            uncheckedColor = Color.Blue,
            checkmarkColor = Color.Green
        )
    )
}

7.1.3 自定义 RadioButton 颜色

kotlin

import androidx.compose.material.RadioButton
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.runtime.Composable
import androidx.compose.ui.graphics.Color
import androidx.compose.material.RadioButtonDefaults

@Composable
fun CustomColorRadioButton() {
    var isSelected by mutableStateOf(false)
    RadioButton(
        selected = isSelected,
        onClick = { isSelected = !isSelected },
        colors = RadioButtonDefaults.colors(
            selectedColor = Color.Red,
            unselectedColor = Color.Blue
        )
    )
}

7.2 自定义大小

可以使用 Modifier.size 修饰符来改变切换按钮的大小。

7.2.1 自定义 Switch 大小

kotlin

import androidx.compose.material.Switch
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp

@Composable
fun CustomSizeSwitch() {
    var isChecked by mutableStateOf(false)
    Switch(
        checked = isChecked,
        onCheckedChange = { isChecked = it },
        modifier = Modifier.size(50.dp, 25.dp)
    )
}

7.2.2 自定义 Checkbox 大小

kotlin

import androidx.compose.material.Checkbox
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp

@Composable
fun CustomSizeCheckbox() {
    var isChecked by mutableStateOf(false)
    Checkbox(
        checked = isChecked,
        onCheckedChange = { isChecked = it },
        modifier = Modifier.size(30.dp)
    )
}

7.2.3 自定义 RadioButton 大小

kotlin

import androidx.compose.material.RadioButton
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp

@Composable
fun CustomSizeRadioButton() {
    var isSelected by mutableStateOf(false)
    RadioButton(
        selected = isSelected,
        onClick = { isSelected = !isSelected },
        modifier = Modifier.size(30.dp)
    )
}

7.3 自定义形状

虽然切换按钮默认是圆形或矩形，但可以通过自定义绘制逻辑来改变其形状。以下是一个自定义形状的 Switch 示例：

kotlin

import androidx.compose.material.Switch
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.geometry.Size
import androidx.compose.ui.graphics.Outline
import androidx.compose.ui.graphics.Shape
import androidx.compose.ui.unit.Density
import androidx.compose.ui.unit.LayoutDirection

class CustomSwitchShape : Shape {
    override fun createOutline(
        size: Size,
        layoutDirection: LayoutDirection,
        density: Density
    ): Outline {
        // 自定义形状逻辑，这里简单返回一个矩形
        return Outline.Rectangle(androidx.compose.ui.geometry.Rect(0f, 0f, size.width, size.height))
    }
}

@Composable
fun CustomShapeSwitch() {
    var isChecked by mutableStateOf(false)
    Switch(
        checked = isChecked,
        onCheckedChange = { isChecked = it },
        modifier = Modifier.clip(CustomSwitchShape())
    )
}

八、切换按钮的交互处理

8.1 点击事件处理

如前面源码分析所述，切换按钮通过 Clickable 修饰符处理点击事件。可以在 onCheckedChange 或 onClick 回调函数中处理点击逻辑。

kotlin

import androidx.compose.material.Switch
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.runtime.Composable
import android.widget.Toast
import androidx.compose.ui.platform.LocalContext

@Composable
fun ClickableSwitch() {
    val context = LocalContext.current
    var isChecked by mutableStateOf(false)
    Switch(
        checked = isChecked,
        onCheckedChange = {
            isChecked = it
            Toast.makeText(context, "Switch state changed: $it", Toast.LENGTH_SHORT).show()
        }
    )
}

8.2 状态管理

切换按钮的状态通常使用 mutableStateOf 来管理。当状态发生变化时，Compose 会自动重新组合 UI。

kotlin

import androidx.compose.material.Checkbox
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.runtime.Composable

@Composable
fun StateManagedCheckbox() {
    var isChecked by mutableStateOf(false)
    Checkbox(
        checked = isChecked,
        onCheckedChange = { isChecked = it }
    )
}

8.3 分组管理（RadioButton）

RadioButton 通常用于分组选择，同一组的 RadioButton 只能有一个被选中。可以通过状态管理来实现分组功能。

kotlin

import androidx.compose.material.RadioButton
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.runtime.Composable
import androidx.compose.foundation.layout.Column

@Composable
fun RadioButtonGroup() {
    val options = listOf("Option 1", "Option 2", "Option 3")
    var selectedOption by mutableStateOf(options[0])
    Column {
        options.forEach { option ->
            RadioButton(
                selected = option == selectedOption,
                onClick = { selectedOption = option }
            )
        }
    }
}

九、切换按钮的性能优化

9.1 避免不必要的重新组合

可以使用 remember 函数缓存计算结果，避免每次重新组合时都进行重复计算。

kotlin

import androidx.compose.material.Switch
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember

@Composable
fun OptimizedSwitch() {
    var isChecked by mutableStateOf(false)
    val colors = remember {
        SwitchDefaults.colors(
            checkedThumbColor = Color.Red,
            checkedTrackColor = Color.Blue,
            uncheckedThumbColor = Color.Green,
            uncheckedTrackColor = Color.Yellow
        )
    }
    Switch(
        checked = isChecked,
        onCheckedChange = { isChecked = it },
        colors = colors
    )
}

9.2 减少组件嵌套

过多的组件嵌套会增加布局的复杂度，影响性能。可以尽量减少不必要的组件嵌套。

kotlin

// 不推荐的写法，嵌套过多
@Composable
fun NestedSwitch() {
    Box {
        Switch(
            checked = false,
            onCheckedChange = {}
        )
    }
}

// 推荐的写法，减少嵌套
@Composable
fun OptimizedNestedSwitch() {
    Switch(
        checked = false,
        onCheckedChange = {}
    )
}

十、切换按钮的异常处理

10.1 空指针异常

在使用切换按钮时，要确保 onCheckedChange 或 onClick 回调函数不为空。

kotlin

// 错误示例，传入 null 作为 onCheckedChange 参数
// Switch(
//     checked = false,
//     onCheckedChange = null
// )

// 正确示例，传入有效的 onCheckedChange 回调函数
Switch(
    checked = false,
    onCheckedChange = { /* 处理状态变化 */ }
)

10.2 状态不一致问题

在多线程或复杂状态管理场景下，可能会出现状态不一致的问题。可以使用 mutableStateOf 结合 LaunchedEffect 来确保状态更新的一致性。

kotlin

import androidx.compose.material.Switch
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import kotlinx.coroutines.delay

@Composable
fun ConsistentStateSwitch() {
    var isChecked by mutableStateOf(false)
    LaunchedEffect(isChecked) {
        // 模拟异步操作
        delay(1000)
        // 更新状态
        isChecked = !isChecked
    }
    Switch(
        checked = isChecked,
        onCheckedChange = { isChecked = it }
    )
}

十一、切换按钮的扩展和定制

11.1 自定义切换按钮组件

可以通过组合现有的组件来创建自定义的切换按钮组件。以下是一个带有文本标签的 Switch 组件示例：

kotlin

import androidx.compose.material.Switch
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.runtime.Composable
import androidx.compose.foundation.layout.Row
import androidx.compose.material.Text

@Composable
fun LabeledSwitch(label: String) {
    var isChecked by mutableStateOf(false)
    Row {
        Switch(
            checked = isChecked,
            onCheckedChange = { isChecked = it }
        )
        Text(text = label)
    }
}

11.2 自定义交互效果

可以通过自定义 Indication 来实现自定义的交互效果。以下是一个带有自定义涟漪效果的 Checkbox 示例：

kotlin

import androidx.compose.material.Checkbox
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.layout.LayoutCoordinates
import androidx.compose.ui.layout.onGloballyPositioned
import androidx.compose.ui.unit.IntSize
import kotlinx.coroutines.launch

@Composable
fun CustomIndicationCheckbox() {
    var isChecked by mutableStateOf(false)
    var layoutCoordinates: LayoutCoordinates? = null
    Checkbox(
        checked = isChecked,
        onCheckedChange = { isChecked = it },
        modifier = Modifier
           .onGloballyPositioned { layoutCoordinates = it }
           .pointerInput(Unit) {
                detectTapGestures(
                    onPress = { offset ->
                        val size = layoutCoordinates?.size ?: IntSize.Zero
                        launch {
                            // 模拟自定义涟漪效果
                            for (i in 0..100) {
                                val alpha = 1f - i / 100f
                                // 绘制自定义涟漪
                                drawCustomRipple(alpha, offset, size)
                                kotlinx.coroutines.delay(10)
                            }
                        }
                    }
                )
            }
    )
}

fun DrawScope.drawCustomRipple(alpha: Float, center: Offset, size: IntSize) {
    drawCircle(
        color = Color.Red.copy(alpha = alpha),
        radius = size.maxDimension.toFloat(),
        center = center
    )
}

十二、总结与展望

12.1 总结

通过对 Android Compose 框架中切换按钮（Switch、Checkbox、RadioButton）的源码分析，我们深入了解了它们的实现原理、交互处理、样式定制和性能优化等方面的知识。切换按钮作为常见的交互组件，在 Android 应用中起着重要的作用。借助 Compose 的声明式编程范式和强大的状态管理机制，开发者可以轻松创建和定制切换按钮，提升应用的交互体验。

查看全文

http://www.kler.cn/a/595768.html