Kotlin UI (五) 动画

0 阅读7分钟
  • 基础动画

基础动画

  1. animate*AsState 系列(单值动画)

支持:animateDpAsState / animateColorAsState / animateFloatAsState / animateSizeAsState

示例1:animateDpAsState 尺寸动画

@Composable
fun AnimateDpDemo() {
        var expand by remember { mutableStateOf(false) }
        // targetValue:目标值,expand=true → 180.dp,false→80.dp
        val size by animateDpAsState(targetValue = if (expand) 180.dp else 80.dp)

        Column {
            Box(
                Modifier
                    .size(size)
                    .background(Color.Blue)
            )
            Button({ expand = !expand }) {
                Text("切换大小")
            }
        }

}

示例2:animateColorAsState 颜色过渡

var isRed by remember { mutableStateOf(false) }
val bgColor by animateColorAsState(
    targetValue = if (isRed) Color.Red else Color.Green
)

Box(Modifier.size(100.dp).background(bgColor))

Button(onClick = {
    isRed = !isRed
}) {
    Text("改变颜色")
}

示例3:自定义时长、插值器

val size by animateDpAsState(
    targetValue = if (expand) 200.dp else 60.dp,
    animationSpec = tween(
        durationMillis = 600,   // 时长
        delayMillis = 100,       // 延迟
        easing = FastOutSlowInEasing
    )
)

常用 easing(插值曲线)

  • FastOutSlowInEasing:默认,先快后慢,最通用
  • LinearEasing:匀速
  • EaseIn:先慢后快
  • EaseOut:先快后慢
  • tween():插值动画(最常用)
  • spring():弹簧动画,带阻尼,回弹效果,手感很好
animationSpec = spring(
    dampingRatio = Spring.DampingRatioMediumBouncy
)

  1. AnimatedVisibility(显示/隐藏动画,高频!)

控制组件入场、退场,自带默认淡入淡出 + 缩放,也可以自定义进出动画。 ✅ 前提:布尔状态控制可见性

最简:

@Composable
fun VisDemo() {
    var show by remember { mutableStateOf(false) }
    Column {
        Button({ show = !show }) { Text("显示/隐藏") }

        AnimatedVisibility(visible = show) {
            Box(
                Modifier
                    .size(100.dp)
                    .background(Color.Magenta)
            )
        }
    }
}

自定义 enter / exit 动画

AnimatedVisibility(
    visible = show,
    enter = slideInVertically() + fadeIn() + scaleIn(),
    exit = slideOutVertically() + fadeOut() + scaleOut()
) {
    Text("带组合动画的文字", Modifier.padding(16.dp))
}

+ 可以叠加多个动画,同时执行

内置入场/退场:

  • fadeIn / fadeOut 透明度
  • slideInHorizontally / slideInVertically 滑动
  • scaleIn / scaleOut 缩放
  • expandVertically / shrinkVertically 高度展开收起(适合下拉面板)

  1. 补充:animateValueAsState(泛型,自定义类型)

上面 animateDp/Color 是封装好的快捷版;任意类型用 animateValueAsState<T>

适合自定义数据结构插值,日常写业务用的偏少。


Animatable

Animatable:命令式,手动调用 animateTo,精细控制:启动、暂停、取消、速度、获取当前值、中途切换目标,底层也是用 TwoWayConverter,和 animateValueAsState 同源。
包:androidx.compose.animation.core.Animatable

var ani = remember { Animatable(0f) }
var coroutineScope = rememberCoroutineScope()
Box(modifier = Modifier.size(ani.value.dp).background(color=Color.Green))
Button(onClick = {
    coroutineScope.launch {
        ani.animateTo(
            targetValue = 200f,
            animationSpec = tween<Float>(durationMillis = 800, easing = FastOutSlowInEasing)
        )
    }

}) {
    Text("变大")
}

animate*AsState 本质底层就是 Animatable 的封装,更简单。

✅ 关键点:animateTo 是 suspend 函数,只能在协程作用域(LaunchedEffect /viewModel 协程)执行


6. 避坑小结

  1. 动画状态必须是 Compose State(remember+mutableStateOf),普通var动画不会跑
  2. 不要在动画回调里做重业务逻辑,动画每一帧都会执行
  3. 弹簧动画 spring 没有 duration,靠阻尼和刚度控制,不能写duration
  4. AnimatedVisibility 如果只是改透明度,没必要用,直接 animateFloatAsState 修改alpha就行

Jetpack Compose — Transition 多状态复合动画

前面 animate*AsState 一般只处理 布尔二态(A ↔ B)  Transition 适合3种及以上状态切换,一个Transition统一管理一组关联动画,同步执行。 核心:Transition<T> 绑定一个状态源,然后在transition上声明多个动画。

基础模板

@Composable
fun TransitionDemo() {
    // 定义状态枚举(推荐枚举,清晰稳定)
    enum class BoxState { Small, Medium, Big }

    var currentState by remember { mutableStateOf(BoxState.Small) }

    // 1. 创建Transition,绑定状态
    val transition = updateTransition(targetState = currentState, label = "boxTransition")

    // 2. 在transition上声明多个动画:尺寸、颜色
    val boxSize by transition.animateDp(label = "size") { state ->
        when (state) {
            BoxState.Small -> 60.dp
            BoxState.Medium -> 120.dp
            BoxState.Big -> 200.dp
        }
    }
    val boxColor by transition.animateColor(label = "color") { state ->
        when (state) {
            BoxState.Small -> Color.Green
            BoxState.Medium -> Color.Yellow
            BoxState.Big -> Color.Red
        }
    }

    Column {
        Box(
            Modifier
                .size(boxSize)
                .background(boxColor)
        )
        Row {
            Button({ currentState = BoxState.Small }) { Text("小") }
            Button({ currentState = BoxState.Medium }) { Text("中") }
            Button({ currentState = BoxState.Big }) { Text("大") }
        }
    }
}

✅ 特点:

  • 切换 currentState,size、color两套动画自动同步一起跑
  • label 调试用,Android Studio动画预览面板可以区分各个动画

修改动画曲线(单独给每个转场配置spec)

animateDp 可以加 transitionSpec,控制【从X→Y】用什么动画

val boxSize by transition.animateDp(
    label = "size",
    transitionSpec = {
        // Small → Big:弹簧动画
        if (initialState == BoxState.Small && targetState == BoxState.Big) {
            spring(DampingRatioHighBouncy)
        } else {
            tween(400)
        }
    }
) { state ->
    when (state) {
        BoxState.Small -> 60.dp
        BoxState.Medium -> 120.dp
        BoxState.Big -> 200.dp
    }
}

transitionSpec 里面 initialState 是出发前状态,targetState 目标状态,可以为不同跳转路径定制不同动画。

Transition + AnimatedVisibility(非常经典组合)

一个状态同时控制:组件显隐 + 大小 + 颜色

enum class PanelState { Hide, Show }

var panelState by remember { mutableStateOf(PanelState.Hide) }
val transition = updateTransition(panelState, label = "panel")

val alpha by transition.animateFloat(label = "alpha") {
    when(it){
        PanelState.Hide -> 0f
        PanelState.Show -> 1f
    }
}

Column {
    Button({ panelState = if(panelState == PanelState.Hide) PanelState.Show else PanelState.Hide }){
        Text("开关面板")
    }
    transition.AnimatedVisibility(
        visible = { it == PanelState.Show },
        enter = fadeIn() + expandVertically(),
        exit = fadeOut() + shrinkVertically()
    ) {
        Box(Modifier.size(150.dp).background(Color.Cyan))
    }
}

注意:是 transition.AnimatedVisibility,不是独立的 AnimatedVisibility,这样入场退场动画归这个Transition统一管理。

和 animate*AsState 对比(面试高频)

  1. animateXxxAsState

    • 只能跟一个targetValue,适合二选一 true/false
    • 多个动画要分开写多个animate,不好同步管理
  2. Transition

    • 一个状态源,同时驱动多个属性动画
    • 支持≥3种状态(枚举优先)
    • 支持给不同跳转路径单独设置动画曲线 transitionSpec
    • 可以挂载 AnimatedVisibility,把显隐动画也纳入统一调度

底层一句话理解

updateTransition 监听 targetState 的变化; 状态一变,Transition收集所有注册在它身上的动画,统一启动、同步时间线。

坑点总结

  1. transition 的 targetState 必须是稳定类型:枚举、基础类型、不可变data class;不要传经常变的可变对象
  2. transitionSpec 判断的是跳转方向,不是单纯看目标值
  3. 不要在animate代码块里面写副作用(网络请求、日志),每一帧插值都会反复执行这个lambda
  4. label 推荐写上,在 Layout Inspector 的动画调试器里可以直观看到每一条动画

延伸:SealedClass 密封类做状态(更适合复杂页面)

状态带附加数据的时候,不用枚举,用密封类

sealed interface UiState {
    object Loading : UiState
    data class Success(val count:Int) : UiState
    object Error : UiState
}

Transition 同样可以绑定密封类。


动画主线到此: animate*AsState(单值二态) → AnimatedVisibility(挂载卸载) → Transition(多状态复合) 再往上还有:Animatable(手动驱动)、animateAsState + 手势、AnimatedContent(内容切换动画,比如Tab切换、文本切换)

下一节:

  1. AnimatedContent(内容切换动画,Tab/页面内容替换)
  2. 切回业务主线 NavHost 导航

选哪个?

Jetpack Compose — AnimatedContent 内容切换动画

前面 Transition 是同一个组件属性变化动画; AnimatedContent 是:状态变了 → 渲染不同子组件,新旧组件之间做切换动画 典型场景:Tab切换、分页、加载/成功/错误UI切换、计数器数字翻转动画、多视图轮换。

核心一句话:状态决定显示哪一块内容,自动给「旧内容退场 + 新内容入场」加上过渡动画

最简基础示例

@Composable
fun AnimatedContentDemo() {
    var tabIndex by remember { mutableStateOf(0) }

    Column {
        Row {
            Button(onClick = { tabIndex = 0 }) { Text("页面A") }
            Button(onClick = { tabIndex = 1 }) { Text("页面B") }
            Button(onClick = { tabIndex = 2 }) { Text("页面C") }
        }

        AnimatedContent(
            targetState = tabIndex,
            label = "tabContent"
        ) { index ->
            when (index) {
                0 -> Box(Modifier.fillMaxSize().height(120.dp).background(Color.Red))
                1 -> Box(Modifier.fillMaxSize().height(120.dp).background(Color.Green))
                2 -> Box(Modifier.fillMaxSize().height(120.dp).background(Color.Blue))
            }
        }
    }
}

默认自带:fadeIn + fadeOut 淡入淡出。

自定义切换动画:transitionSpec

通过 transitionSpec 定义进场、退场动画,还可以区分方向(往左切、往右切不同动画)

AnimatedContent(
    targetState = tabIndex,
    label = "tab",
    transitionSpec = {
        // 判断跳转方向
        if (targetState > initialState) {
            // 下标变大:向右滑动进入
            slideInHorizontally { width -> width } + fadeIn() togetherWith
                    slideOutHorizontally { width -> -width } + fadeOut()
        } else {
            // 下标变小:向左滑动进入
            slideInHorizontally { width -> -width } + fadeIn() togetherWith
                    slideOutHorizontally { width -> width } + fadeOut()
        }.using(
            SizeTransform(clip = false) // 尺寸变化时平滑过渡
        )
    }
) { index ->
    // 根据状态渲染内容
    Text("Tab $index", Modifier.padding(20.dp))
}

重点语法

  • togetherWith:入场动画 和 退场动画同时执行(绝大多数Tab切换用这个)
  • using(SizeTransform):当前后两个内容宽高不一样时,容器大小平滑过渡;clip=true会裁剪内容

对比:AnimatedVisibility 只能控制单个组件显隐;AnimatedContent 是两个不同组件交替替换

实战:UiState 加载态切换(Loading / Success / Error)

业务最常用!

sealed interface PageUiState {
    object Loading : PageUiState
    data class Success(val text: String) : PageUiState
    object Error : PageUiState
}

@Composable
fun StateSwitchDemo(uiState: PageUiState) {
    AnimatedContent(
        targetState = uiState,
        label = "uiStateSwitch",
        transitionSpec = {
            fadeIn() togetherWith fadeOut()
        }
    ) { state ->
        when (state) {
            is PageUiState.Loading -> {
                CircularProgressIndicator()
            }
            is PageUiState.Success -> {
                Text(state.text)
            }
            is PageUiState.Error -> {
                Text("加载失败,请重试", color = Color.Red)
            }
        }
    }
}

数字翻转动画小案例

var count by remember { mutableStateOf(0) }
Column {
    Button({ count++ }) { Text("+1") }
    AnimatedContent(targetState = count, label = "numAnim") {
        Text("$it", fontSize = 36.sp)
    }
}

关键区分(面试高频三连)

  1. animate*AsState:同一个组件,属性(颜色/大小)插值变化,组件不变
  2. Transition:同一个组件,一套状态驱动多组属性动画
  3. AnimatedContent:状态切换,渲染完全不同的Composable,新旧两个组件交替出场退场

重要坑点

  1. targetState 必须是稳定可比较的类型(Int、Enum、密封类),Compose靠对比新旧值判断要不要切换动画
  2. transitionSpec 里 initialState = 旧状态,targetState = 新状态,可以定向定制动画
  3. 动画运行期间,新旧内容同时存在在树上一小段时间,两个Composable同时存活; 如果内部有LaunchedEffect,两个Effect会同时跑,注意资源冲突!
  4. 不要放非常重的布局在AnimatedContent内部,切换容易掉帧
  5. SizeTransform:如果前后内容高度差别很大,加上它才会有容器平滑伸缩效果,不然容器瞬间跳变

动画全家桶小结(串一遍)

  1. animateXxxAsState:简单二态属性动画
  2. Animatable:手动控制动画、手势联动
  3. AnimatedVisibility:单个组件挂载/卸载
  4. Transition:单一状态驱动多个属性同步动画(≥3状态)
  5. AnimatedContent:不同内容组件互相替换的切换动画(Tab/状态页)