做名片用哪个网站/最新域名ip地址

做名片用哪个网站,最新域名ip地址,级a做爰片免费视网站看看,服务类网站建设服务公司Android Compose 框架隐式动画之过渡动画深入剖析 一、引言 在移动应用开发领域，用户体验始终是至关重要的。动画效果作为提升用户体验的关键元素，能够为应用增添生动性和交互性。Android Compose 作为现代 Android UI 工具包，为开发者提供…

Android Compose 框架隐式动画之过渡动画深入剖析

一、引言

在移动应用开发领域，用户体验始终是至关重要的。动画效果作为提升用户体验的关键元素，能够为应用增添生动性和交互性。Android Compose 作为现代 Android UI 工具包，为开发者提供了丰富且强大的动画支持，其中隐式动画里的过渡动画（Transition、Crossfade）尤为引人注目。

过渡动画能够在界面元素的状态发生变化时，自动创建平滑的动画过渡效果，让界面的变化更加自然和流畅。Transition 可以让开发者精确控制多个属性在不同状态之间的过渡，而 Crossfade 则专注于实现内容之间的淡入淡出过渡。深入理解这两种过渡动画的原理和使用方法，有助于开发者在 Android Compose 应用中创建出更加出色的用户界面。

本文将从源码级别深入分析 Transition 和 Crossfade，详细介绍它们的工作原理、核心方法和使用场景，并通过丰富的示例代码和详细的注释，帮助开发者更好地掌握这两种过渡动画的使用。

二、Android Compose 隐式动画概述

2.1 隐式动画的概念

隐式动画是 Android Compose 中一种非常便捷的动画实现方式。它允许开发者在定义界面元素的属性时，只需指定属性的目标值，Compose 框架会自动根据属性的变化创建动画过渡效果。与显式动画不同，显式动画需要开发者手动控制动画的启动、停止和每一个关键帧，而隐式动画则由框架自动处理这些细节，大大简化了动画的实现过程。

例如，当一个按钮的颜色从红色变为蓝色时，使用隐式动画，开发者只需要更新按钮颜色的属性值，Compose 框架会自动创建一个颜色渐变的动画过渡，让按钮颜色的变化更加平滑。

2.2 过渡动画在隐式动画中的地位

过渡动画是隐式动画的重要组成部分，它主要用于处理界面元素在不同状态之间的过渡效果。在 Android Compose 中，状态的变化是非常常见的，比如按钮的点击、列表项的展开和收缩等。过渡动画可以让这些状态变化更加自然和流畅，增强用户体验。

Transition 和 Crossfade 是过渡动画中两个非常重要的组件。Transition 可以用于管理多个属性在不同状态之间的过渡，开发者可以为每个属性定义不同的动画效果和过渡时间。而 Crossfade 则专注于实现内容之间的淡入淡出过渡，非常适合用于在不同内容片段之间进行切换的场景。

2.3 隐式动画与传统动画的对比

与传统的 Android 动画实现方式相比，Android Compose 的隐式动画具有以下几个显著的优点：

  • 声明式编程风格：传统的 Android 动画通常使用命令式编程方式，需要开发者手动控制动画的各个环节，如动画的开始、停止、持续时间等。而 Android Compose 的隐式动画采用声明式编程风格，开发者只需要描述属性的目标值和动画的一些基本参数，框架会自动处理动画的执行过程，代码更加简洁和易于维护。
  • 与 Compose UI 系统深度集成：隐式动画与 Compose 的 UI 系统紧密结合，能够充分利用 Compose 的状态管理和布局系统。当界面元素的状态发生变化时，隐式动画可以自动触发，并且能够根据界面的布局和状态变化进行自适应调整。
  • 性能优化：Compose 框架对隐式动画进行了优化，能够高效地处理动画的计算和渲染。它采用智能的重组机制，只有当与动画相关的状态发生变化时，才会重新计算和执行动画，避免了不必要的性能开销。

三、Transition 源码分析

3.1 Transition 的基本定义与结构

在 Android Compose 中，Transition 是一个用于管理状态过渡动画的核心类。下面是 Transition 类的基本定义和结构：

kotlin

// 引入必要的包
import androidx.compose.animation.core.*
import androidx.compose.runtime.*// 定义 Transition 类，T 为状态的类型
@Stable
class Transition<T>(// 可变的过渡状态对象，用于存储当前状态和目标状态private val transitionState: MutableTransitionState<T>,// 过渡的标签，用于调试和标识label: String = "Transition"
) {// 获取当前状态internal val currentState: Tget() = transitionState.currentState// 获取目标状态internal val targetState: Tget() = transitionState.targetState// 用于存储过渡动画的映射，键为动画的标识，值为过渡定义private val transitions = mutableMapOf<Any, TransitionDefinition<T, *>>()// 用于存储动画完成回调的映射，键为动画的标识，值为回调函数private val onEndCallbacks = mutableMapOf<Any, () -> Unit>()// 用于生成动画规范的工厂类private val animationSpecFactory: AnimationSpecFactory = AnimationSpecFactory()// 用于控制过渡动画的暂停状态private var isPaused = false// 过渡的标签，用于调试目的val label: String = labelinternal set// 内部的 State 对象，用于跟踪过渡状态的变化internal val transitionStateState: State<MutableTransitionState<T>> = remember {derivedStateOf { transitionState }}// 用于存储当前运行的动画状态private var currentAnimation: AnimationState<T>? = null// 用于存储上一次运行的动画状态private var previousAnimation: AnimationState<T>? = null// 用于调度动画帧的回调函数private var frameCallback: (() -> Unit)? = null// 用于管理动画的时钟，提供时间信息private val clock = AnimationClockAmbient.current// 判断是否正在进行过渡动画internal val isInTransition: Booleanget() = currentAnimation != null// 获取指定键对应的过渡动画的值@Suppress("UNCHECKED_CAST")internal fun <V> getTransitionValue(key: Any): V? {return transitions[key]?.let {it.getValue(transitionState.currentState, transitionState.targetState)} as? V}// 设置过渡动画的定义internal fun <V> setTransition(key: Any,transition: TransitionDefinition<T, V>,onEnd: (() -> Unit)? = null) {transitions[key] = transitionif (onEnd != null) {onEndCallbacks[key] = onEnd}}// 启动过渡动画internal fun startTransition() {if (isPaused) {return}if (currentAnimation != null) {// 如果已经有正在运行的动画，停止它currentAnimation?.stop()previousAnimation = currentAnimation}val newAnimation = createAnimation()if (newAnimation != null) {currentAnimation = newAnimationnewAnimation.start()}}// 创建动画状态对象private fun createAnimation(): AnimationState<T>? {val transitionDefinitions = transitions.values.toList()if (transitionDefinitions.isEmpty()) {return null}val animationSpecs = transitionDefinitions.map { it.animationSpec }val initialValues = transitionDefinitions.map { it.getValue(transitionState.currentState, transitionState.targetState) }val targetValues = transitionDefinitions.map { it.getValue(transitionState.targetState, transitionState.currentState) }val animationSpec = animationSpecFactory.merge(animationSpecs)return AnimationState(initialValue = initialValues,targetValue = targetValues,animationSpec = animationSpec,onEnd = {currentAnimation = nullonEndCallbacks.forEach { (_, callback) -> callback() }onEndCallbacks.clear()},clock = clock)}// 暂停过渡动画internal fun pauseTransition() {isPaused = truecurrentAnimation?.pause()}// 恢复过渡动画internal fun resumeTransition() {isPaused = falsecurrentAnimation?.resume()}// 停止过渡动画internal fun stopTransition() {isPaused = truecurrentAnimation?.stop()currentAnimation = nullpreviousAnimation = nullonEndCallbacks.clear()}// 跳转到目标状态internal fun jumpTo(target: T) {stopTransition()transitionState.currentState = targettransitions.forEach { (_, transition) ->transition.jumpTo(target)}}// 更新目标状态internal fun updateTargetState(target: T) {if (transitionState.targetState == target) {return}transitionState.targetState = targetif (isInTransition) {stopTransition()}startTransition()}
}

从上述代码可以看出，Transition 类主要负责管理状态的过渡动画。它通过 MutableTransitionState 来存储当前状态和目标状态，并提供了一系列方法来控制动画的启动、暂停、恢复和停止。transitions 用于存储不同动画的定义，onEndCallbacks 用于存储动画完成后的回调函数。createAnimation 方法根据存储的动画定义创建实际的动画对象并启动。

3.2 Transition 的核心方法解析

3.2.1 setTransition 方法

kotlin

// 设置过渡动画的定义
internal fun <V> setTransition(key: Any, // 动画的标识，用于唯一区分不同的动画transition: TransitionDefinition<T, V>, // 过渡动画的定义对象onEnd: (() -> Unit)? = null // 动画结束时的回调函数，可选
) {transitions[key] = transition // 将过渡动画定义存储到 transitions 映射中if (onEnd != null) {onEndCallbacks[key] = onEnd // 如果提供了回调函数，将其存储到 onEndCallbacks 映射中}
}

setTransition 方法用于添加一个过渡动画定义。通过这个方法，开发者可以将不同的动画定义添加到 Transition 对象中，以便在状态变化时执行相应的动画。key 用于唯一标识这个动画定义，transition 是具体的动画定义对象，onEnd 是动画结束时的回调函数（可选）。

3.2.2 startTransition 方法

kotlin

// 启动过渡动画
internal fun startTransition() {if (isPaused) { // 如果过渡动画处于暂停状态，直接返回return}if (currentAnimation != null) { // 如果已经有正在运行的动画// 停止当前正在运行的动画currentAnimation?.stop()// 将当前动画状态保存到 previousAnimation 中previousAnimation = currentAnimation}val newAnimation = createAnimation() // 创建新的动画状态对象if (newAnimation != null) { // 如果新的动画状态对象创建成功currentAnimation = newAnimation // 将新的动画状态对象设置为当前动画newAnimation.start() // 启动新的动画}
}

startTransition 方法用于启动过渡动画。首先检查当前是否处于暂停状态，如果是则直接返回。然后，如果有正在运行的动画，先停止它并保存到 previousAnimation 中。接着调用 createAnimation 方法创建新的动画对象，如果创建成功，则将其设置为当前运行的动画并启动。

3.2.3 createAnimation 方法

kotlin

// 创建动画状态对象
private fun createAnimation(): AnimationState<T>? {val transitionDefinitions = transitions.values.toList() // 获取所有的过渡动画定义if (transitionDefinitions.isEmpty()) { // 如果没有过渡动画定义，返回 nullreturn null}val animationSpecs = transitionDefinitions.map { it.animationSpec } // 获取所有过渡动画的动画规范val initialValues = transitionDefinitions.map { it.getValue(transitionState.currentState, transitionState.targetState) } // 获取所有过渡动画的初始值val targetValues = transitionDefinitions.map { it.getValue(transitionState.targetState, transitionState.currentState) } // 获取所有过渡动画的目标值val animationSpec = animationSpecFactory.merge(animationSpecs) // 合并所有的动画规范return AnimationState(initialValue = initialValues, // 设置动画的初始值targetValue = targetValues, // 设置动画的目标值animationSpec = animationSpec, // 设置动画的规范onEnd = {currentAnimation = null // 动画结束后，将当前动画状态设置为 nullonEndCallbacks.forEach { (_, callback) -> callback() } // 执行所有的动画结束回调函数onEndCallbacks.clear() // 清空动画结束回调函数映射},clock = clock // 设置动画的时钟)
}

createAnimation 方法负责创建实际的动画对象。它首先获取所有已添加的动画定义列表 transitionDefinitions，如果列表为空则返回 null。然后分别从动画定义中提取动画规范 animationSpecs、初始值 initialValues 和目标值 targetValues。通过 animationSpecFactory.merge 方法合并动画规范，最后创建并返回一个 AnimationState 对象。AnimationState 对象包含了动画的初始值、目标值、动画规范以及动画结束时的回调函数等信息。

3.2.4 updateTargetState 方法

kotlin

// 更新目标状态
internal fun updateTargetState(target: T) {if (transitionState.targetState == target) { // 如果新的目标状态与当前目标状态相同，直接返回return}transitionState.targetState = target // 更新过渡状态的目标状态if (isInTransition) { // 如果当前正在进行过渡动画stopTransition() // 停止当前的过渡动画}startTransition() // 启动新的过渡动画
}

updateTargetState 方法用于更新目标状态。首先检查新的目标状态是否与当前目标状态相同，如果相同则直接返回。否则更新 transitionState 的目标状态。如果当前正在进行过渡动画，则先停止动画，然后启动新的过渡动画，以确保根据新的目标状态执行正确的动画过渡。

3.3 Transition 的使用示例与代码解析

下面是一个使用 Transition 实现按钮颜色过渡动画的示例：

kotlin

import androidx.compose.animation.ExperimentalAnimationApi
import androidx.compose.animation.core.Animatable
import androidx.compose.animation.core.AnimationSpec
import androidx.compose.animation.core.tween
import androidx.compose.material.Button
import androidx.compose.material.Text
import androidx.compose.runtime.*@OptIn(ExperimentalAnimationApi::class)
@Composable
fun TransitionExample() {// 定义一个可变状态，用于控制按钮的颜色var isButtonClicked by remember { mutableStateOf(false) }// 创建一个 Transition 对象，用于管理按钮颜色的过渡val transition = updateTransition(targetState = isButtonClicked, label = "ButtonColorTransition")// 定义按钮颜色的过渡动画val buttonColor by transition.animateColor(transitionSpec = { tween(durationMillis = 300) }, // 动画规范，持续时间为 300 毫秒label = "ButtonColor" // 动画的标签) { if (it) androidx.compose.ui.graphics.Color.Green else androidx.compose.ui.graphics.Color.Red } // 根据状态返回不同的颜色// 创建按钮Button(onClick = { isButtonClicked = !isButtonClicked }, // 点击按钮时切换状态modifier = Modifier,colors = ButtonDefaults.buttonColors(backgroundColor = buttonColor) // 设置按钮的背景颜色) {Text(text = if (isButtonClicked) "Clicked" else "Not Clicked") // 根据状态显示不同的文本}
}

代码解析：

  • 首先，使用 remember 创建一个可变状态 isButtonClicked，用于控制按钮的点击状态。
  • 然后，通过 updateTransition 创建一个 Transition 对象 transition，其目标状态为 isButtonClicked，并设置了过渡标签 ButtonColorTransition。
  • 接着，使用 transition.animateColor 定义按钮颜色的过渡动画。transitionSpec 指定了动画的规范，这里使用了一个持续时间为 300 毫秒的线性过渡动画。label 用于标识这个动画，{ if (it) androidx.compose.ui.graphics.Color.Green else androidx.compose.ui.graphics.Color.Red } 根据 isButtonClicked 的值决定按钮的起始和结束颜色。
  • 最后，创建一个按钮，其背景颜色根据 buttonColor 动态变化，点击按钮时会切换 isButtonClicked 的状态，从而触发 Transition 对象执行颜色过渡动画。

3.4 Transition 中的状态管理机制

在 Transition 中，状态管理是通过 MutableTransitionState 来实现的。MutableTransitionState 是一个可变的状态对象，它存储了当前状态和目标状态。当目标状态发生变化时，Transition 会根据状态的变化启动相应的过渡动画。

kotlin

// 定义 MutableTransitionState 类，T 为状态的类型
class MutableTransitionState<T>(initialState: T // 初始状态
) {// 当前状态var currentState: T = initialStateinternal set// 目标状态var targetState: T = initialStateinternal set// 判断是否正在过渡中val isInTransition: Booleanget() = currentState != targetState// 跳转到目标状态fun jumpTo(target: T) {currentState = targettargetState = target}// 更新目标状态fun updateState(target: T) {targetState = target}
}

MutableTransitionState 提供了 currentState 和 targetState 两个属性来存储当前状态和目标状态。isInTransition 属性用于判断是否正在进行过渡。jumpTo 方法用于直接跳转到目标状态，而 updateState 方法用于更新目标状态。

在 Transition 中，当调用 updateTargetState 方法更新目标状态时，会触发 MutableTransitionState 的 targetState 属性的更新，然后 Transition 会根据状态的变化启动相应的过渡动画。

3.5 Transition 与动画规范的结合

在 Transition 中，动画规范（AnimationSpec）起着重要的作用，它定义了动画的行为，如动画的持续时间、插值器等。Transition 通过 AnimationSpec 来控制过渡动画的具体效果。

kotlin

// 定义一个简单的动画规范，使用线性插值器，持续时间为 300 毫秒
val linearAnimationSpec = tween<Float>(durationMillis = 300)@OptIn(ExperimentalAnimationApi::class)
@Composable
fun TransitionWithAnimationSpecExample() {var isExpanded by remember { mutableStateOf(false) }val transition = updateTransition(targetState = isExpanded, label = "SizeTransition")val size by transition.animateDp(transitionSpec = { linearAnimationSpec }, // 使用定义好的动画规范label = "Size") { if (it) 200.dp else 100.dp }Box(modifier = Modifier.size(size).background(Color.Blue).clickable { isExpanded = !isExpanded })
}

在这个示例中，我们定义了一个简单的线性动画规范 linearAnimationSpec，并将其应用到 Transition 的 animateDp 方法中。当 isExpanded 状态发生变化时，Box 的大小会根据 linearAnimationSpec 定义的动画规范进行过渡。

除了 tween 动画规范，Android Compose 还提供了其他类型的动画规范，如 spring、keyframes 等，开发者可以根据需要选择合适的动画规范来实现不同的动画效果。

3.6 Transition 中的回调机制

Transition 提供了回调机制，允许开发者在动画结束时执行特定的操作。通过 setTransition 方法的 onEnd 参数，可以传入一个回调函数，当动画结束时，该回调函数会被调用。

kotlin

@OptIn(ExperimentalAnimationApi::class)
@Composable
fun TransitionWithCallbackExample() {var isAnimated by remember { mutableStateOf(false) }val transition = updateTransition(targetState = isAnimated, label = "CallbackTransition")val alpha by transition.animateFloat(transitionSpec = { tween(durationMillis = 500) },label = "Alpha") { if (it) 1f else 0f }transition.setTransition(key = "AlphaTransition",transition = FloatTransitionDefinition(animationSpec = tween(durationMillis = 500)) { if (it) 1f else 0f },onEnd = {// 动画结束时的回调函数println("Animation ended!")})Box(modifier = Modifier.size(100.dp).background(Color.Red).alpha(alpha).clickable { isAnimated = !isAnimated })
}

在这个示例中，我们通过 setTransition 方法的 onEnd 参数传入了一个回调函数，当 alpha 动画结束时，会打印出 “Animation ended!”。

3.7 Transition 的性能优化考虑

在使用 Transition 时，为了提高性能，需要考虑以下几点：

  • 减少不必要的动画：避免在界面中添加过多不必要的过渡动画，过多的动画会增加系统的计算负担，导致性能下降。只在必要的地方添加动画，例如在用户操作的关键节点，如按钮点击、页面切换等，以提供及时的反馈和良好的用户体验。
  • 合理设置动画持续时间：动画持续时间过长会导致用户等待时间过长，影响用户体验；而过短则可能使动画效果不明显。因此，需要根据具体的应用场景和用户交互需求，合理设置动画的持续时间。
  • 使用合适的动画规范：选择合适的动画规范可以提高动画的性能。例如，spring 动画规范在一些情况下可以提供更自然的动画效果，并且性能相对较好。
  • 避免频繁的状态变化：频繁的状态变化会导致动画频繁触发，增加系统的开销。尽量减少不必要的状态变化，例如在用户连续点击按钮时，可以设置一个时间间隔，避免在短时间内多次触发动画。

四、Crossfade 源码分析

4.1 Crossfade 的基本定义与结构

Crossfade 是 Android Compose 中用于实现内容之间淡入淡出过渡的 Composable 函数。下面是 Crossfade 的基本定义和结构：

kotlin

import androidx.compose.animation.ExperimentalAnimationApi
import androidx.compose.animation.core.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.drawscope.DrawScope
import androidx.compose.ui.layout.Layout
import androidx.compose.ui.layout.layoutId@OptIn(ExperimentalAnimationApi::class)
@Composable
fun Crossfade(targetState: Any, // 目标状态modifier: Modifier = Modifier, // 修饰符animationSpec: AnimationSpec<Float> = crossfadeSpec(), // 动画规范content: @Composable (targetState: Any) -> Unit // 内容函数
) {// 创建一个 Transition 对象，用于管理目标状态的过渡val transition = updateTransition(targetState = targetState, label = "Crossfade")// 定义透明度的过渡动画val alpha by transition.animateFloat(transitionSpec = { animationSpec }, // 使用传入的动画规范label = "CrossfadeAlpha" // 动画的标签) { 1f } // 透明度的目标值为 1f// 获取上一个状态val previousContent = transition.previousState// 获取当前状态val currentContent = transition.currentState// 使用 Layout 组件进行布局Layout(modifier = modifier,content = {if (previousContent != null) {// 绘制上一个状态的内容Box(modifier = Modifier.layoutId("previousContent").alpha(1f - alpha) // 设置上一个状态内容的透明度) {content(previousContent)}}// 绘制当前状态的内容Box(modifier = Modifier.layoutId("currentContent").alpha(alpha) // 设置当前状态内容的透明度) {content(currentContent)}}) { measurables, constraints ->// 测量所有的子组件val placeables = measurables.map { it.measure(constraints) }// 获取最大的宽度和高度val maxWidth = placeables.maxOfOrNull { it.width } ?: 0val maxHeight = placeables.maxOfOrNull { it.height } ?: 0// 创建布局结果layout(maxWidth, maxHeight) {placeables.forEach { placeable ->// 将子组件放置在布局中placeable.placeRelative(0, 0)}}}
}

从上述代码可以看出，Crossfade 首先通过 updateTransition 创建一个 Transition 对象，用于管理目标状态的变化。然后，使用 transition.animateFloat 为内容的透明度创建一个动画过渡。接着，通过 transition.previousState 和 transition.currentState 获取上一个状态和当前状态。在 Layout 组件中，分别绘制上一个状态和当前状态的内容，并根据透明度的动画过渡设置它们的透明度，从而实现淡入淡出的效果。

4.2 Crossfade 的核心方法与逻辑解析

4.2.1 updateTransition 的作用

kotlin

val transition = updateTransition(targetState = targetState, label = "Crossfade")

updateTransition 是一个非常重要的函数，它用于创建一个 Transition 对象，该对象会跟踪 targetState 的变化。当 targetState 发生改变时，Transition 对象会根据定义的动画规则来执行过渡动画。在 Crossfade 中，updateTransition 为淡入淡出过渡提供了状态管理和动画触发的基础。

4.2.2 animateFloat 的实现

kotlin

val alpha by transition.animateFloat(transitionSpec = { animationSpec },label = "CrossfadeAlpha"
) { 1f }

animateFloat 是 Transition 对象的一个扩展函数，用于创建一个 Float 类型的动画过渡。transitionSpec 指定了动画的规范，这里使用了传入的 animationSpec，它决定了动画的持续时间、插值器等属性。label 用于标识这个动画，方便调试和管理。{ 1f } 是一个状态映射函数，它指定了每个状态对应的 Float 值，这里初始值和目标值都为 1f，但在过渡过程中 alpha 会根据动画规范进行变化。

4.2.3 Layout 组件的使用

kotlin

Layout(modifier = modifier,content = {if (previousContent != null) {Box(modifier = Modifier.layoutId("previousContent").alpha(1f - alpha)) {content(previousContent)}}Box(modifier = Modifier.layoutId("currentContent").alpha(alpha)) {content(currentContent)}}
) { measurables, constraints ->val placeables = measurables.map { it.measure(constraints) }val maxWidth = placeables.maxOfOrNull { it.width } ?: 0val maxHeight = placeables.maxOfOrNull { it.height } ?: 0layout(maxWidth, maxHeight) {placeables.forEach { placeable ->placeable.placeRelative(0, 0)}}
}

Layout 组件用于自定义布局。在 Crossfade 中，Layout 组件用于将上一个状态和当前状态的内容进行布局。通过 layoutId 为每个内容分配一个唯一的标识，方便管理。根据透明度的动画过渡，分别设置上一个状态和当前状态内容的透明度，实现淡入淡出的效果。

4.3 Crossfade 的使用示例与代码解析

下面是一个使用 Crossfade 实现文本切换淡入淡出效果的示例：

kotlin

import androidx.compose.animation.Crossfade
import androidx.compose.animation.ExperimentalAnimationApi
import androidx.compose.material.Button
import androidx.compose.material.Text
import androidx.compose.runtime.*@OptIn(ExperimentalAnimationApi::class)
@Composable
fun CrossfadeTextExample() {// 定义一个可变状态，用于控制显示的文本var showFirstText by remember { mutableStateOf(true) }// 创建一个按钮，点击时切换显示的文本Button(onClick = { showFirstText = !showFirstText }) {Text(text = "Toggle Text")}// 使用 Crossfade 组件，根据 showFirstText 的值切换显示不同的文本Crossfade(targetState = showFirstText,animationSpec = androidx.compose.animation.core.tween(durationMillis = 500) // 动画持续时间为 500 毫秒) { isFirst ->if (isFirst) {Text(text = "This is the first text.")} else {Text(text = "This is the second text.")}}
}

代码解析：

  • 首先，使用 remember 创建一个可变状态 showFirstText，用于控制显示的文本。
  • 然后，创建一个按钮，点击按钮时会切换 showFirstText 的状态。
  • 接着，使用 Crossfade 组件，targetState 为 showFirstText，animationSpec 指定了动画的持续时间为 500 毫秒。在 content 函数中，根据 isFirst 的值显示不同的文本。当 showFirstText 状态发生变化时，Crossfade 会自动执行淡入淡出过渡动画，使文本切换更加平滑。

4.4 Crossfade 中的动画规范定制

在 Crossfade 中，可以通过传入不同的动画规范来定制淡入淡出的效果。除了使用 tween 动画规范，还可以使用 spring、keyframes 等其他类型的动画规范。

kotlin

import androidx.compose.animation.Crossfade
import androidx.compose.animation.ExperimentalAnimationApi
import androidx.compose.animation.core.*
import androidx.compose.material.Button
import androidx.compose.material.Text
import androidx.compose.runtime.*@OptIn(ExperimentalAnimationApi::class)
@Composable
fun CrossfadeWithCustomSpecExample() {var showFirstImage by remember { mutableStateOf(true) }// 自定义弹簧动画规范val springSpec = spring<Float>(dampingRatio = Spring.DampingRatioLowBouncy,stiffness = Spring.StiffnessLow)Button(onClick = { showFirstImage = !showFirstImage }) {Text(text = "Toggle Image")}Crossfade(targetState = showFirstImage,animationSpec = springSpec // 使用自定义的弹簧动画规范) { isFirst ->if (isFirst) {// 显示第一张图片Image(painter = painterResource(id = R.drawable.image1),contentDescription = null)} else {// 显示第二张图片Image(painter = painterResource(id = R.drawable.image2),contentDescription = null)}}
}

在这个示例中，我们自定义了一个弹簧动画规范 springSpec，并将其应用到 Crossfade 组件中。当点击按钮切换图片时，图片会以弹簧动画的效果进行淡入淡出过渡。

4.5 Crossfade 的性能优化技巧

为了提高 Crossfade 的性能，可以考虑以下几点：

  • 减少不必要的内容重绘：Crossfade 在过渡过程中会同时绘制上一个状态和当前状态的内容，因此要尽量减少不必要的内容重绘。可以通过合理管理状态和内容，避免在过渡过程中频繁更新内容。
  • 优化动画规范：选择合适的动画规范可以提高动画的性能。例如，使用简单的 tween 动画规范通常比复杂的 keyframes 动画规范性能更好。
  • 避免在过渡过程中进行复杂计算：在 Crossfade 的过渡过程中，尽量避免进行复杂的计算，以免影响动画的流畅度。可以将复杂的计算提前进行，或者在过渡结束后再进行。

五、Transition 与 Crossfade 的对比与应用场景分析

5.1 功能对比

5.1.1 动画控制粒度
  • Transition：提供了更细粒度的动画控制。它允许开发者为不同的属性（如颜色、大小、位置等）定义独立的动画过渡。例如，在一个按钮状态切换的场景中，可以同时为按钮的背景颜色、文字颜色和大小定义不同的过渡动画，并且可以精确控制每个动画的起始和结束状态、持续时间、插值器等。

kotlin

@OptIn(ExperimentalAnimationApi::class)
@Composable
fun TransitionFineGrainedControlExample() {var isButtonActive by remember { mutableStateOf(false) }val transition = updateTransition(targetState = isButtonActive, label = "ButtonTransition")val backgroundColor by transition.animateColor(transitionSpec = { tween(durationMillis = 300) },label = "BackgroundColor") { if (it) Color.Green else Color.Red }val textColor by transition.animateColor(transitionSpec = { tween(durationMillis = 300) },label = "TextColor") { if (it) Color.White else Color.Black }val buttonSize by transition.animateDp(transitionSpec = { tween(durationMillis = 300) },label = "ButtonSize") { if (it) 200.dp else 100.dp }Button(onClick = { isButtonActive = !isButtonActive },modifier = Modifier.size(buttonSize),colors = ButtonDefaults.buttonColors(backgroundColor = backgroundColor)) {Text(text = "Button", color = textColor)}
}
  • Crossfade：主要专注于内容之间的淡入淡出过渡，动画控制相对单一。它通过改变内容的透明度来实现过渡效果，适用于简单的内容切换场景，如文本、图像的切换。

kotlin

@OptIn(ExperimentalAnimationApi::class)
@Composable
fun CrossfadeSimpleTransitionExample() {var showFirstText by remember { mutableStateOf(true)
5.1.2 状态管理
  • Transition：通过 MutableTransitionState 来管理状态的变化，能够跟踪当前状态和目标状态，并根据状态的变化触发相应的动画。可以在状态变化时动态调整动画的参数，实现复杂的状态过渡逻辑。例如，在一个多级菜单展开和收缩的场景中，可以根据不同的层级状态设置不同的动画效果和持续时间。

kotlin

@OptIn(ExperimentalAnimationApi::class)
@Composable
fun TransitionComplexStateManagementExample() {// 定义多级菜单的状态，这里简化为一个 Int 类型表示层级var menuLevel by remember { mutableStateOf(1) }val transition = updateTransition(targetState = menuLevel, label = "MenuTransition")// 不同层级的动画持续时间不同val duration = when (menuLevel) {1 -> 2002 -> 300else -> 400}val menuHeight by transition.animateDp(transitionSpec = { tween(durationMillis = duration) },label = "MenuHeight") {when (it) {1 -> 50.dp2 -> 150.dpelse -> 250.dp}}Box(modifier = Modifier.height(menuHeight).background(Color.Gray).clickable {menuLevel = if (menuLevel < 3) menuLevel + 1 else 1}) {Text(text = "Menu Level: $menuLevel")}
}
  • Crossfade：依赖于 updateTransition 创建的 Transition 对象来管理状态，但它的状态管理主要用于控制内容的显示和隐藏，以及触发淡入淡出动画。状态变化相对简单，主要围绕内容的切换。

kotlin

@OptIn(ExperimentalAnimationApi::class)
@Composable
fun CrossfadeSimpleStateManagementExample() {var showContent by remember { mutableStateOf(true) }Crossfade(targetState = showContent,animationSpec = tween(durationMillis = 300)) { isVisible ->if (isVisible) {Text(text = "Visible Content")} else {Text(text = "Hidden Content")}}Button(onClick = { showContent = !showContent }) {Text(text = "Toggle Content")}
}
5.1.3 动画类型支持
  • Transition：支持多种类型的动画过渡，包括颜色、大小、位置、透明度等。可以使用不同的动画规范（如 tween、spring、keyframes 等）来实现丰富的动画效果。例如，在一个卡片翻转的动画中，可以同时对卡片的旋转角度和透明度进行过渡动画。

kotlin

@OptIn(ExperimentalAnimationApi::class)
@Composable
fun TransitionMultipleAnimationTypesExample() {var isCardFlipped by remember { mutableStateOf(false) }val transition = updateTransition(targetState = isCardFlipped, label = "CardFlipTransition")val rotation by transition.animateFloat(transitionSpec = { tween(durationMillis = 500) },label = "Rotation") { if (it) 180f else 0f }val alpha by transition.animateFloat(transitionSpec = { tween(durationMillis = 500) },label = "Alpha") { if (it) 0.5f else 1f }Box(modifier = Modifier.size(200.dp).background(Color.Blue).rotate(rotation).alpha(alpha).clickable { isCardFlipped = !isCardFlipped }) {Text(text = if (isCardFlipped) "Back" else "Front")}
}
  • Crossfade：主要专注于透明度的过渡动画，通过淡入淡出的效果实现内容的切换。虽然也可以结合其他动画效果，但相对来说动画类型较为单一。

5.2 性能对比

5.2.1 资源消耗
  • Transition：由于可以同时管理多个属性的动画过渡，可能会消耗更多的系统资源。特别是在动画复杂度较高、涉及多个动画同时执行时，需要更多的计算资源来处理动画的计算和渲染。例如，在一个包含多个元素同时进行动画的场景中，每个元素的多个属性都有动画过渡，会增加 CPU 和 GPU 的负担。

kotlin

@OptIn(ExperimentalAnimationApi::class)
@Composable
fun TransitionHighResourceConsumptionExample() {var isAnimated by remember { mutableStateOf(false) }val transition = updateTransition(targetState = isAnimated, label = "MultipleElementsTransition")// 多个元素的动画repeat(10) { index ->val size by transition.animateDp(transitionSpec = { tween(durationMillis = 500) },label = "Size$index") { if (isAnimated) 100.dp + index * 10.dp else 50.dp }val color by transition.animateColor(transitionSpec = { tween(durationMillis = 500) },label = "Color$index") { if (isAnimated) Color.Green else Color.Red }Box(modifier = Modifier.size(size).background(color).offset(x = index * 20.dp, y = 0.dp))}Button(onClick = { isAnimated = !isAnimated }) {Text(text = "Animate")}
}
  • Crossfade：主要通过改变内容的透明度来实现过渡，动画逻辑相对简单，资源消耗较少。在处理简单的内容切换时，能够提供较好的性能表现。

kotlin

@OptIn(ExperimentalAnimationApi::class)
@Composable
fun CrossfadeLowResourceConsumptionExample() {var showFirstImage by remember { mutableStateOf(true) }Crossfade(targetState = showFirstImage,animationSpec = tween(durationMillis = 300)) { isFirst ->if (isFirst) {Image(painter = painterResource(id = R.drawable.image1),contentDescription = null)} else {Image(painter = painterResource(id = R.drawable.image2),contentDescription = null)}}Button(onClick = { showFirstImage = !showFirstImage }) {Text(text = "Toggle Image")}
}
5.2.2 动画流畅度
  • Transition：如果动画参数设置合理，并且系统资源充足，Transition 可以实现非常流畅的动画效果。但在复杂动画场景下，可能会因为资源竞争等问题导致动画出现卡顿。例如，当同时有多个复杂的动画在运行时，可能会出现帧率下降的情况。
  • Crossfade：由于其动画逻辑简单，在大多数情况下能够提供较为流畅的淡入淡出过渡效果，尤其是在性能较低的设备上也能保持较好的流畅度。

5.3 应用场景分析

5.3.1 Transition 的应用场景
  • 复杂状态切换：当界面元素需要在多个状态之间进行复杂的过渡时，如开关的打开和关闭、卡片的展开和收缩等，Transition 可以为每个状态变化定义详细的动画过渡，使界面交互更加生动和自然。

kotlin

@OptIn(ExperimentalAnimationApi::class)
@Composable
fun TransitionComplexStateSwitchExample() {var isSwitchOn by remember { mutableStateOf(false) }val transition = updateTransition(targetState = isSwitchOn, label = "SwitchTransition")val switchWidth by transition.animateDp(transitionSpec = { tween(durationMillis = 300) },label = "SwitchWidth") { if (isSwitchOn) 150.dp else 50.dp }val switchColor by transition.animateColor(transitionSpec = { tween(durationMillis = 300) },label = "SwitchColor") { if (isSwitchOn) Color.Green else Color.Red }Box(modifier = Modifier.width(switchWidth).height(50.dp).background(switchColor).clickable { isSwitchOn = !isSwitchOn }) {Text(text = if (isSwitchOn) "On" else "Off")}
}
  • 多属性动画：需要同时对多个属性进行动画过渡的场景，如按钮的颜色、大小和位置同时发生变化，Transition 可以方便地实现这些属性的协同动画。

kotlin

@OptIn(ExperimentalAnimationApi::class)
@Composable
fun TransitionMultiplePropertyAnimationExample() {var isButtonAnimated by remember { mutableStateOf(false) }val transition = updateTransition(targetState = isButtonAnimated, label = "ButtonMultiplePropertyTransition")val buttonSize by transition.animateDp(transitionSpec = { tween(durationMillis = 300) },label = "ButtonSize") { if (isButtonAnimated) 200.dp else 100.dp }val buttonColor by transition.animateColor(transitionSpec = { tween(durationMillis = 300) },label = "ButtonColor") { if (isButtonAnimated) Color.Green else Color.Red }val buttonOffset by transition.animateDp(transitionSpec = { tween(durationMillis = 300) },label = "ButtonOffset") { if (isButtonAnimated) 50.dp else 0.dp }Button(onClick = { isButtonAnimated = !isButtonAnimated },modifier = Modifier.size(buttonSize).offset(x = buttonOffset, y = 0.dp),colors = ButtonDefaults.buttonColors(backgroundColor = buttonColor)) {Text(text = "Animate Button")}
}
5.3.2 Crossfade 的应用场景
  • 内容切换：在不同内容片段之间进行切换的场景，如文本、图像、页面的切换，Crossfade 可以提供平滑的淡入淡出过渡效果，增强用户体验。

kotlin

@OptIn(ExperimentalAnimationApi::class)
@Composable
fun CrossfadeContentSwitchExample() {var showPage by remember { mutableStateOf(1) }Crossfade(targetState = showPage,animationSpec = tween(durationMillis = 300)) { page ->when (page) {1 -> Text(text = "Page 1 Content")2 -> Text(text = "Page 2 Content")3 -> Text(text = "Page 3 Content")}}Row {Button(onClick = { showPage = 1 }) {Text(text = "Page 1")}Button(onClick = { showPage = 2 }) {Text(text = "Page 2")}Button(onClick = { showPage = 3 }) {Text(text = "Page 3")}}
}
  • 简单过渡效果：对于只需要简单的淡入淡出效果的场景，Crossfade 是一个简洁而高效的选择，能够快速实现过渡动画，减少开发成本。

kotlin

@OptIn(ExperimentalAnimationApi::class)
@Composable
fun CrossfadeSimpleTransitionEffectExample() {var showText by remember { mutableStateOf(true) }Crossfade(targetState = showText,animationSpec = tween(durationMillis = 300)) { isVisible ->if (isVisible) {Text(text = "Hello, World!")}}Button(onClick = { showText = !showText }) {Text(text = "Toggle Text")}
}

六、高级用法与实战案例

6.1 Transition 的高级用法

6.1.1 组合多个过渡动画

可以将多个 Transition 组合在一起，实现更复杂的动画效果。例如，在一个卡片展开的场景中，可以同时为卡片的高度、宽度和透明度定义不同的 Transition，并在卡片展开时同时触发这些动画。

kotlin

import androidx.compose.animation.ExperimentalAnimationApi
import androidx.compose.animation.core.*
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.material.Card
import androidx.compose.material.Text
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp@OptIn(ExperimentalAnimationApi::class)
@Composable
fun CombinedTransitionExample() {// 定义一个可变状态，用于控制卡片的展开和收缩var isExpanded by remember { mutableStateOf(false) }// 创建一个用于控制卡片高度的 Transition 对象val heightTransition = updateTransition(targetState = isExpanded, label = "HeightTransition")val cardHeight by heightTransition.animateDp(transitionSpec = { tween(durationMillis = 300) },label = "CardHeight") { if (it) 200.dp else 100.dp }// 创建一个用于控制卡片宽度的 Transition 对象val widthTransition = updateTransition(targetState = isExpanded, label = "WidthTransition")val cardWidth by widthTransition.animateDp(transitionSpec = { tween(durationMillis = 300) },label = "CardWidth") { if (it) 300.dp else 200.dp }// 创建一个用于控制卡片透明度的 Transition 对象val alphaTransition = updateTransition(targetState = isExpanded, label = "AlphaTransition")val cardAlpha by alphaTransition.animateFloat(transitionSpec = { tween(durationMillis = 300) },label = "CardAlpha") { if (it) 1f else 0.5f }// 创建卡片Card(modifier = Modifier.width(cardWidth).height(cardHeight).alpha(cardAlpha).padding(16.dp).clickable { isExpanded = !isExpanded },elevation = 8.dp) {Column(modifier = Modifier.fillMaxSize().background(Color.LightGray).padding(16.dp),verticalArrangement = Arrangement.Center,horizontalAlignment = Alignment.CenterHorizontally) {Text(text = if (isExpanded) "Expanded" else "Collapsed")}}
}

在这个示例中，分别为卡片的高度、宽度和透明度创建了不同的 Transition 对象，并在卡片点击时同时触发这些动画，实现了卡片展开和收缩的复杂动画效果。

6.1.2 自定义过渡动画规范

可以通过自定义 AnimationSpec 来实现独特的过渡动画效果。例如，使用 SpringSpec 可以创建弹性动画效果。

kotlin

import androidx.compose.animation.ExperimentalAnimationApi
import androidx.compose.animation.core.*
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.material.Button
import androidx.compose.material.Text
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp@OptIn(ExperimentalAnimationApi::class)
@Composable
fun CustomTransitionSpecExample() {// 定义一个可变状态，用于控制按钮的大小var isBig by remember { mutableStateOf(false) }// 自定义一个 SpringSpec 动画规范val springSpec = SpringSpec(dampingRatio = Spring.DampingRatioLowBouncy,stiffness = Spring.StiffnessLow)// 创建一个 Transition 对象，用于控制按钮的大小过渡val transition = updateTransition(targetState = isBig, label = "ButtonSizeTransition")val buttonSize by transition.animateDp(transitionSpec = { springSpec },label = "ButtonSize") { if (it) 200.dp else 100.dp }// 创建按钮Button(onClick = { isBig = !isBig },modifier = Modifier.width(buttonSize).height(buttonSize).padding(16.dp)) {Text(text = if (isBig) "Big" else "Small")}
}

在这个示例中，使用 SpringSpec 自定义了一个弹性动画规范，并将其应用到按钮大小的过渡动画中，使按钮在大小变化时具有弹性效果。

6.1.3 动态更新过渡动画

在某些情况下，可能需要根据不同的条件动态更新过渡动画的参数。例如，根据用户的操作次数来改变动画的持续时间。

kotlin

import androidx.compose.animation.ExperimentalAnimationApi
import androidx.compose.animation.core.*
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.material.Button
import androidx.compose.material.Text
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp@OptIn(ExperimentalAnimationApi::class)
@Composable
fun DynamicTransitionUpdateExample() {// 定义一个可变状态，用于控制方块的大小var isExpanded by remember { mutableStateOf(false) }// 定义一个可变状态，用于记录点击次数var clickCount by remember { mutableStateOf(0) }// 根据点击次数动态计算动画持续时间val duration = clickCount * 100 + 200// 创建一个 Transition 对象，用于控制方块的大小过渡val transition = updateTransition(targetState = isExpanded, label = "BoxSizeTransition")val boxSize by transition.animateDp(transitionSpec = { tween(durationMillis = duration) },label = "BoxSize") { if (it) 200.dp else 100.dp }// 创建方块Box(modifier = Modifier.size(boxSize).background(Color.Blue).clickable {isExpanded = !isExpandedclickCount++}) {Text(text = "Click Count: $clickCount",modifier = Modifier.align(Alignment.Center))}
}

在这个示例中，每次点击方块时，clickCount 会增加，动画的持续时间会根据 clickCount 动态更新，从而实现动态更新过渡动画的效果。

6.2 Crossfade 的高级用法

6.2.1 嵌套 Crossfade

可以在 Crossfade 中嵌套另一个 Crossfade，实现更复杂的内容过渡效果。例如，在一个页面中，先进行大内容块的切换，然后在每个大内容块中再进行小内容的切换。

kotlin

import androidx.compose.animation.Crossfade
import androidx.compose.animation.ExperimentalAnimationApi
import androidx.compose.material.Button
import androidx.compose.material.Text
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.unit.dp
import androidx.compose.foundation.Image
import androidx.compose.foundation.layout.*@OptIn(ExperimentalAnimationApi::class)
@Composable
fun NestedCrossfadeExample() {// 定义一个可变状态，用于控制大内容块的切换var showFirstContent by remember { mutableStateOf(true) }// 定义一个可变状态，用于控制小内容块的切换var showFirstSubContent by remember { mutableStateOf(true) }// 创建一个按钮，点击时切换大内容块Button(onClick = { showFirstContent = !showFirstContent }) {Text(text = "Toggle Main Content")}// 使用 Crossfade 组件，根据 showFirstContent 的值切换大内容块Crossfade(targetState = showFirstContent,animationSpec = androidx.compose.animation.core.tween(durationMillis = 500)) { isFirst ->if (isFirst) {Column(modifier = Modifier.fillMaxSize().padding(16.dp),verticalArrangement = Arrangement.Center,horizontalAlignment = Alignment.CenterHorizontally) {Text(text = "This is the first main content.")// 创建一个按钮，点击时切换小内容块Button(onClick = { showFirstSubContent = !showFirstSubContent }) {Text(text = "Toggle Sub Content")}// 在大内容块中嵌套另一个 Crossfade，根据 showFirstSubContent 的值切换小内容块Crossfade(targetState = showFirstSubContent,animationSpec = androidx.compose.animation.core.tween(durationMillis = 300)) { isFirstSub ->if (isFirstSub) {Text(text = "This is the first sub content.")} else {Image(painter = painterResource(id = R.drawable.sample_image),contentDescription = null,modifier = Modifier.width(200.dp).height(200.dp),contentScale = ContentScale.Crop)}}}} else {Text(text = "This is the second main content.")}}
}

在这个示例中，外层的 Crossfade 用于切换大内容块，内层的 Crossfade 用于在大内容块中切换小内容块，实现了多层次的内容过渡效果。

6.2.2 自定义淡入淡出效果

可以通过自定义 AnimationSpec 来改变 Crossfade 的淡入淡出效果。例如，使用 KeyframesSpec 可以创建具有不同阶段的淡入淡出动画。

kotlin

import androidx.compose.animation.Crossfade
import androidx.compose.animation.ExperimentalAnimationApi
import androidx.compose.animation.core.*
import androidx.compose.material.Button
import androidx.compose.material.Text
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.unit.dp
import androidx.compose.foundation.Image
import androidx.compose.foundation.layout.*@OptIn(ExperimentalAnimationApi::class)
@Composable
fun CustomCrossfadeEffectExample() {// 定义一个可变状态，用于控制显示的内容var showFirstContent by remember { mutableStateOf(true) }// 自定义一个 KeyframesSpec 动画规范val keyframesSpec = keyframes {durationMillis = 10000f at 0 with LinearEasing0.5f at 500 with FastOutSlowInEasing1f at 1000 with LinearEasing}// 创建一个按钮，点击时切换显示的内容Button(onClick = { showFirstContent = !showFirstContent }) {Text(text = "Toggle Content")}// 使用 Crossfade 组件，根据 showFirstContent 的值切换显示不同的内容，并应用自定义的动画规范Crossfade(targetState = showFirstContent,animationSpec = keyframesSpec) { isFirst ->if (isFirst) {Text(text = "This is the first content.")} else {Image(painter = painterResource(id = R.drawable.sample_image),contentDescription = null,modifier = Modifier.width(200.dp).height(200.dp),contentScale = ContentScale.Crop)}}
}

在这个示例中，使用 KeyframesSpec 自定义了一个淡入淡出动画规范，使内容在淡入淡出过程中具有不同的阶段和插值效果。

6.2.3 与其他动画效果结合

可以将 Crossfade 与其他动画效果结合使用，创造出更丰富的动画体验。例如，结合 AnimatedVisibility 实现内容的淡入淡出和显示隐藏的组合效果。

kotlin

import androidx.compose.animation.*
import androidx.compose.animation.core.*
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.material.Button
import androidx.compose.material.Text
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp@OptIn(ExperimentalAnimationApi::class)
@Composable
fun CrossfadeWithOtherAnimationExample() {// 定义一个可变状态，用于控制内容的显示和隐藏var isVisible by remember { mutableStateOf(false) }// 定义一个可变状态，用于控制内容的切换var showFirstText by remember { mutableStateOf(true) }// 创建一个按钮，点击时切换内容的显示和隐藏状态Button(onClick = { isVisible = !isVisible }) {Text(text = "Toggle Visibility")}// 创建一个按钮，点击时切换显示的文本Button(onClick = { showFirstText = !showFirstText }) {Text(text = "Toggle Text")}// 使用 AnimatedVisibility 组件，根据 isVisible 的值显示或隐藏内容AnimatedVisibility(visible = isVisible,enter = fadeIn() + expandIn(),exit = fadeOut() + shrinkOut()) {// 使用 Crossfade 组件，根据 showFirstText 的值切换显示不同的文本Crossfade(targetState = showFirstText,animationSpec = tween(durationMillis = 300)) { isFirst ->Box(modifier = Modifier.size(200.dp).background(Color.LightGray).padding(16.dp),contentAlignment = Alignment.Center) {Text(text = if (isFirst) "First Text" else "Second Text")}}}
}

在这个示例中，AnimatedVisibility 控制内容的显示和隐藏，并带有淡入淡出和缩放动画，Crossfade 用于在内容显示时进行文本的切换，实现了两种动画效果的结合。

6.3 实战案例：打造一个动画卡片列表

以下是一个使用 Transition 和 Crossfade 打造动画卡片列表的实战案例：

kotlin

import androidx.compose.animation.*
import androidx.compose.animation.core.*
import androidx.compose.foundation.*
import androidx.compose.foundation.layout.*
import androidx.compose.material.*
import androidx.compose.runtime.*
import androidx.compose.ui.*
import androidx.compose.ui.draw.alpha
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp@OptIn(ExperimentalAnimationApi::class)
@Composable
fun AnimatedCardList() {// 定义一个列表，存储卡片的数据val cardList = remember {mutableListOf(CardData("Card 1", R.drawable.sample_image_1),CardData("Card 2", R.drawable.sample_image_2),CardData("Card 3", R.drawable.sample_image_3))}// 定义一个可变状态，用于控制当前选中的卡片var selectedCardIndex by remember { mutableStateOf(-1) }// 创建一个垂直滚动的列表Column(modifier = Modifier.fillMaxSize().verticalScroll(rememberScrollState())) {// 遍历卡片列表cardList.forEachIndexed { index, cardData ->// 创建一个 Transition 对象，用于控制卡片的展开和收缩val transition = updateTransition(targetState = index == selectedCardIndex, label = "CardTransition")val cardHeight by transition.animateDp(transitionSpec = { tween(durationMillis = 300) },label = "CardHeight") { if (it) 300.dp else 150.dp }val cardAlpha by transition.animateFloat(transitionSpec = { tween(durationMillis = 300) },label = "CardAlpha") { if (it) 1f else 0.8f }// 创建卡片Card(modifier = Modifier.fillMaxWidth().height(cardHeight).alpha(cardAlpha).padding(16.dp).clickable {if (selectedCardIndex == index) {selectedCardIndex = -1} else {selectedCardIndex = index}},elevation = 8.dp) {Column(modifier = Modifier.fillMaxSize().background(Color.LightGray)) {// 显示卡片的标题Text(text = cardData.title,modifier = Modifier.fillMaxWidth().padding(16.dp),fontSize = 20.sp,textAlign = TextAlign.Center)// 使用 Crossfade 组件，根据卡片是否展开显示不同的内容Crossfade(targetState = index == selectedCardIndex,animationSpec = tween(durationMillis = 300)) { isExpanded ->if (isExpanded) {// 展开时显示图片Image(painter = painterResource(id = cardData.imageResId),contentDescription = null,modifier = Modifier.fillMaxSize().clip(shape = MaterialTheme.shapes.medium),contentScale = ContentScale.Crop)} else {// 收缩时显示空白Spacer(modifier = Modifier.fillMaxSize())}}}}}}
}// 定义卡片数据类
data class CardData(val title: String, val imageResId: Int)

代码解析：

  • 首先，定义了一个 CardData 数据类，用于存储卡片的标题和图片资源 ID。

  • 然后，创建了一个 cardList 列表，存储多个卡片的数据。

  • 接着，使用 selectedCardIndex 来控制当前选中的卡片。

  • 在遍历卡片列表时，为每个卡片创建一个 Transition 对象，用于控制卡片的高度和透明度的过渡动画。

  • 对于每个卡片，使用 Crossfade 组件根据卡片是否展开显示不同的内容。当卡片展开时，显示图片；当卡片收缩时，显示空白。

通过这种方式，实现了一个具有动画效果的卡片列表，用户点击卡片时，卡片会展开并显示图片，再次点击则收缩。

七、性能优化与注意事项

7.1 性能优化策略

7.1.1 合理设置动画持续时间

动画持续时间过长会导致用户等待时间过长，影响用户体验；而过短则可能使动画效果不明显。因此，需要根据具体的应用场景和用户交互需求，合理设置动画的持续时间。例如，对于简单的按钮点击反馈动画，可以将持续时间设置为 200 - 300 毫秒；对于复杂的页面切换动画，可以设置为 500 - 1000 毫秒。

kotlin

// 简单按钮点击动画，持续时间 200 毫秒
val simpleClickAnimation = tween<Float>(durationMillis = 200)// 复杂页面切换动画，持续时间 800 毫秒
val complexPageTransitionAnimation = tween<Float>(durationMillis = 800)
7.1.2 减少不必要的动画

避免在界面中添加过多不必要的动画，过多的动画会增加系统的计算负担，导致性能下降。只在必要的地方添加动画，例如在用户操作的关键节点，如按钮点击、页面切换等，以提供及时的反馈和良好的用户体验。

kotlin

// 避免在不需要动画的地方添加动画
// 例如，静态文本不需要动画效果
Text(text = "This is a static text", modifier = Modifier.padding(16.dp))// 只在需要的地方添加动画，如按钮点击
var isButtonClicked by remember { mutableStateOf(false) }
val transition = updateTransition(targetState = isButtonClicked, label = "ButtonClickTransition")
val buttonColor by transition.animateColor(transitionSpec = { tween(durationMillis = 200) },label = "ButtonColor"
) { if (it) Color.Green else Color.Red }
Button(onClick = { isButtonClicked = !isButtonClicked },colors = ButtonDefaults.buttonColors(backgroundColor = buttonColor)
) {Text(text = "Click me")
}
7.1.3 使用合适的插值器

插值器决定了动画的变化速率，不同的插值器可以产生不同的动画效果。选择合适的插值器可以使动画更加自然和流畅。例如，FastOutSlowInEasing 可以使动画开始时快速变化，结束时缓慢变化，符合人眼的视觉习惯。

kotlin

// 使用 FastOutSlowInEasing 插值器
val fastOutSlowInAnimation = tween<Float>(durationMillis = 300,easing = FastOutSlowInEasing
)@OptIn(ExperimentalAnimationApi::class)
@Composable
fun InterpolatorExample() {var isAnimated by remember { mutableStateOf(false) }val transition = updateTransition(targetState = isAnimated, label = "InterpolatorTransition")val offset by transition.animateDp(transitionSpec = { fastOutSlowInAnimation },label = "Offset") { if (isAnimated) 100.dp else 0.dp }Box(modifier = Modifier.size(50.dp).background(Color.Blue).offset(x = offset).clickable { isAnimated = !isAnimated })
}
7.1.4 避免频繁的状态变化

频繁的状态变化会导致动画频繁触发，增加系统的开销。尽量减少不必要的状态变化，例如在用户连续点击按钮时，可以设置一个时间间隔，避免在短时间内多次触发动画。

kotlin

import androidx.compose.animation.ExperimentalAnimationApi
import androidx.compose.animation.core.*
import androidx.compose.material.Button
import androidx.compose.material.Text
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import kotlinx.coroutines.delay@OptIn(ExperimentalAnimationApi::class)
@Composable
fun AvoidFrequentStateChangesExample() {var isButtonClicked by remember { mutableStateOf(false) }// 用于记录上次点击的时间var lastClickTime by remember { mutableStateOf(0L) }// 定义点击间隔时间，单位为毫秒val clickInterval = 500Lval transition = updateTransition(targetState = isButtonClicked, label = "ButtonClickTransition")val buttonColor by transition.animateColor(transitionSpec = { tween(durationMillis = 300) },label = "ButtonColor") { if (it) androidx.compose.ui.graphics.Color.Green else androidx.compose.ui.graphics.Color.Red }Button(onClick = {val currentTime = System.currentTimeMillis()if (currentTime - lastClickTime > clickInterval) {isButtonClicked = !isButtonClickedlastClickTime = currentTime}},modifier = Modifier,colors = androidx.compose.material.ButtonDefaults.buttonColors(backgroundColor = buttonColor)) {Text(text = if (isButtonClicked) "Clicked" else "Not Clicked")}
}

在这个示例中，通过记录上次点击的时间 lastClickTime，并与当前时间进行比较，只有当时间间隔超过 clickInterval 时，才会更新按钮的状态并触发动画，从而避免了频繁的状态变化。

7.1.5 优化布局结构

复杂的布局结构会增加动画的计算和渲染时间。尽量简化布局结构，避免嵌套过深的布局。例如，使用 Box 或 Row、Column 等简单布局组件来替代复杂的布局嵌套。

kotlin

import androidx.compose.animation.ExperimentalAnimationApi
import androidx.compose.animation.core.*
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.material.Text
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp@OptIn(ExperimentalAnimationApi::class)
@Composable
fun OptimizeLayoutStructureExample() {var isExpanded by remember { mutableStateOf(false) }val transition = updateTransition(targetState = isExpanded, label = "BoxSizeTransition")val boxHeight by transition.animateDp(transitionSpec = { tween(durationMillis = 300) },label = "BoxHeight") { if (isExpanded) 200.dp else 100.dp }// 简化布局结构，使用 Box 作为根布局Box(modifier = Modifier.fillMaxWidth().height(boxHeight).background(Color.LightGray).clickable { isExpanded = !isExpanded },contentAlignment = Alignment.Center) {Text(text = if (isExpanded) "Expanded" else "Collapsed")}
}

在这个示例中，使用 Box 作为根布局，避免了复杂的布局嵌套，从而提高了动画的性能。

7.2 常见问题及解决方法

7.2.1 动画卡顿问题

  • 原因：动画卡顿通常是由于系统资源不足，如 CPU 或 GPU 负载过高，或者动画计算过于复杂导致的。

  • 解决方法：

    • 优化动画的复杂度，减少不必要的动画效果。例如，避免同时进行多个复杂的动画过渡。
    • 合理设置动画的帧率，避免过高的帧率导致系统负担过重。在 Android Compose 中，动画的帧率默认是根据系统的刷新率进行自适应调整的，但可以通过自定义 AnimationSpec 来限制帧率。
    • 检查布局结构，避免嵌套过深的布局，减少布局计算的开销。
7.2.2 动画闪烁问题

  • 原因：动画闪烁可能是由于动画的起始和结束状态设置不当，或者动画的更新频率过高导致的。

  • 解决方法：

    • 确保动画的起始和结束状态正确设置，避免出现状态跳跃的情况。例如，在设置透明度动画时，确保起始透明度和结束透明度的值合理。
    • 减少动画的更新频率，避免在短时间内多次更新动画状态。可以通过设置合适的动画持续时间和插值器来实现。
7.2.3 动画不执行问题

  • 原因：动画不执行可能是由于状态管理出现问题，或者动画的依赖项没有正确更新导致的。

  • 解决方法：

    • 检查状态管理逻辑，确保状态的更新能够正确触发动画。例如，在使用 Transition 时，确保 updateTargetState 方法被正确调用。
    • 检查动画的依赖项，确保依赖项的变化能够正确触发动画的更新。例如，在使用 animateDp 等方法时，确保状态的变化能够正确影响到动画的目标值。

7.3 兼容性与版本注意事项

7.3.1 Android 版本兼容性

Android Compose 的动画功能在不同的 Android 版本上可能会有一些差异。在使用 Transition 和 Crossfade 时，需要确保应用的最低支持版本能够兼容 Android Compose 的要求。目前，Android Compose 要求 Android 5.0（API 级别 21）及以上版本。

groovy

// 在 build.gradle 文件中设置最低 SDK 版本
android {compileSdkVersion 33defaultConfig {applicationId "com.example.myapp"minSdkVersion 21targetSdkVersion 33versionCode 1versionName "1.0"}
}
7.3.2 Compose 版本更新

随着 Android Compose 的不断发展，其动画 API 可能会有一些更新和改进。在使用 Transition 和 Crossfade 时，建议使用最新的 Compose 版本，以获得更好的性能和功能。同时，需要注意 Compose 版本更新可能会带来的 API 变化，及时更新代码以确保兼容性。

groovy

// 在 build.gradle 文件中设置 Compose 版本
dependencies {implementation "androidx.compose.ui:ui:$compose_version"implementation "androidx.compose.material:material:$compose_version"implementation "androidx.compose.animation:animation:$compose_version"
}
7.3.3 第三方库兼容性

如果在项目中使用了第三方库，需要确保这些库与 Android Compose 的动画功能兼容。一些第三方库可能会对布局和绘制过程进行修改，从而影响动画的效果。在集成第三方库时，需要进行充分的测试，确保动画功能正常工作。

八、总结与展望

8.1 总结

在 Android 应用开发中，动画效果是提升用户体验的关键因素之一。Android Compose 提供的 Transition 和 Crossfade 这两种隐式过渡动画机制，为开发者带来了极大的便利和丰富的创意空间。

Transition 是一个强大的状态过渡管理工具，它能够精确控制多个属性在不同状态之间的过渡。通过 MutableTransitionState 管理状态变化，结合各种动画规范（如 tween、spring 等），可以实现复杂而精细的动画效果。例如，在按钮状态切换、卡片展开收缩等场景中，Transition 可以同时对颜色、大小、位置等多个属性进行动画过渡，使界面交互更加生动自然。同时，Transition 还提供了回调机制，方便开发者在动画结束时执行特定的操作。

Crossfade 则专注于内容之间的淡入淡出过渡，通过改变内容的透明度实现平滑的切换效果。它的实现逻辑相对简单，资源消耗较少，在性能较低的设备上也能保持较好的流畅度。适用于文本、图像、页面等不同内容片段的切换场景，能够为用户提供清晰、舒适的视觉体验。

通过对 Transition 和 Crossfade 的源码分析，我们深入了解了它们的工作原理和核心机制。在实际应用中，开发者可以根据具体的需求和场景，灵活选择和使用这两种动画机制，还可以将它们组合使用，创造出更加丰富多样的动画效果。同时，在使用过程中，需要注意性能优化和兼容性问题，合理设置动画参数、简化布局结构，确保应用在不同设备和 Android 版本上都能稳定运行。

8.2 展望

随着 Android 技术的不断发展和用户对应用体验要求的日益提高，Android Compose 的动画功能也将不断完善和扩展。

8.2.1 更丰富的动画效果

未来，Transition 和 Crossfade 可能会支持更多种类的动画效果和过渡方式。例如，引入更多复杂的插值器，如弹性插值器、贝塞尔曲线插值器等，让动画的变化更加自然和富有创意。同时，可能会增加对 3D 动画效果的支持，为用户带来更加沉浸式的体验。

8.2.2 智能化的动画管理

随着人工智能和机器学习技术的发展，Android Compose 的动画管理可能会变得更加智能化。例如，根据用户的操作习惯和行为模式，自动调整动画的速度、持续时间和效果，提供更加个性化的动画体验。同时，智能算法可以对动画性能进行实时监测和优化，自动识别和解决动画卡顿、闪烁等问题。

8.2.3 与其他技术的融合

Android Compose 的动画功能可能会与其他技术进行更深入的融合。例如，与增强现实（AR）和虚拟现实（VR）技术结合，为用户创造更加逼真的动画场景。与手势识别技术结合，实现更加自然和直观的交互动画。此外，还可能与后端数据和网络服务结合，根据实时数据的变化动态生成动画效果。

8.2.4 简化开发流程

为了降低开发者的学习成本和开发难度，未来的 Android Compose 动画 API 可能会进一步简化和优化。提供更多的预设动画模板和便捷的工具，让开发者可以快速创建出高质量的动画效果。同时，文档和示例代码也会更加完善，帮助开发者更好地理解和使用动画功能。

总之，Transition 和 Crossfade 作为 Android Compose 中重要的过渡动画机制，在当前的应用开发中已经发挥了重要作用。随着技术的不断进步，它们将在未来的 Android 应用开发中展现出更大的潜力，为用户带来更加出色的动画体验。开发者可以持续关注 Android Compose 的发展动态，不断探索和应用新的动画技术，提升自己的开发能力和应用的竞争力。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/899025.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

2024年3月全国计算机等级考试真题（二级C语言）

2024年3月全国计算机等级考试真题（二级C语言）

&#x1f600; 第1题 下列叙述中正确的是 A. 矩阵是非线性结构 B. 数组是长度固定的线性表 C. 对线性表只能作插入与删除运算 D. 线性表中各元素的数据类型可以不同 题目解析&#xff1a; A. 矩阵是非线性结构 错误。矩阵通常是二维数组&#xff0c;属…
阅读更多...
基于Ebay拍卖网站成交价格的影响因素分析

基于Ebay拍卖网站成交价格的影响因素分析

摘要:近些年来网上拍卖的不断地发展&#xff0c;网上购物慢慢变成了大家普遍接受的购物方式。因此关于网上拍卖的研究日益成为很多人研究的重点。 影响拍卖网站价格的因素很多&#xff0c;但很少有人分得清楚哪些因素才是比较重要的因素&#xff0c;因此对价格因素分析&#x…
阅读更多...
Langchain中的表格解析:RAG 和表格的爱恨情仇

Langchain中的表格解析:RAG 和表格的爱恨情仇

实现 RAG（Retrieval-Augmented Generation）是一个挑战，尤其是在有效解析和理解非结构化文档中的表格时。这在处理扫描文档或图像格式的文档时尤为困难。这些挑战至少包括以下三个方面： 1.表格的“叛逆期”：不准确的解析可能会破坏表格结构： 表格在文档里就像个叛逆的青少…
阅读更多...
Solr-搜索引擎-入门到精通

Solr-搜索引擎-入门到精通

以下是对 Apache Solr 的简介及其常用语法的快速入门指南&#xff1a; 一、Solr 是什么&#xff1f; • 核心定位&#xff1a;Apache Solr 是一个基于 Lucene 的高性能、开源的搜索平台&#xff0c;支持全文检索、分词、高亮、聚合统计等功能。 • 核心功能&#xff1a; • 全…
阅读更多...
原生后台GPS位置限制，降低功耗

原生后台GPS位置限制，降低功耗

1.后台 GPS 位置限制的背景 为了控制功耗&#xff0c;Android 平台对后台应用获取位置信息的频率进行了限制。后台的定义与后台执行限制一致&#xff0c;即应用不在前台运行时被视为后台应用。 2.更新间隔限制&#xff1a; 后台应用获取位置信息的更新间隔不能超过一定阈值。…
阅读更多...
Docker 搭建 PlantUML 服务：高效生成 UML 图的最佳实践

Docker 搭建 PlantUML 服务：高效生成 UML 图的最佳实践

PlantUML 是一款开源的 UML 图形生成工具&#xff0c;它支持生成类图、时序图、用例图、活动图等多种类型的 UML 图&#xff0c;广泛应用于软件设计、文档编写以及团队沟通中。通过 Docker 安装 PlantUML&#xff0c;开发者可以快速搭建环境&#xff0c;轻松生成 UML 图&#x…
阅读更多...
简鹿办公汇总快速打开 Windows 资源管理器的几种方式

简鹿办公汇总快速打开 Windows 资源管理器的几种方式

无论你是刚开始使用电脑的新手&#xff0c;还是已经有一定经验的用户&#xff0c;了解如何在 Windows 系统中打开资源管理器都是一个非常基本且重要的技能。Windows 资源管理器&#xff08;现在称为“文件资源管理器”&#xff09;是帮助你浏览、查找和管理计算机上所有文件的主…
阅读更多...
DNA-PAINT

DNA-PAINT

参考: 【科研教程】NUPACK网页版使用教程 https://www.bilibili.com/video/BV1G94y1W7mN/NUPACK新版网页版教程-模拟部分 https://zhuanlan.zhihu.com/p/678730568NUPACK 4.0 User Guide https://docs.nupack.org/NUPACK网页版使用指南 https://zhuanlan.zhihu.com/p/55024017…
阅读更多...
小程序内表格合并功能实现—行合并

小程序内表格合并功能实现—行合并

功能介绍&#xff1a;支付宝小程序手写表格实现行内合并&#xff0c;依据动态数据自动计算每次需求合并的值&#xff0c;本次记录行内合并&#xff0c;如果列内合并&#xff0c;同理即可实现 前端技术&#xff1a;grid布局 display&#xff1a;grid 先看实现效果: axml&…
阅读更多...
计算机视觉cv2入门之角点检测

计算机视觉cv2入门之角点检测

角点是指图像中两条边缘线的交点&#xff0c;这些交点通常代表了图像中的重要特征。在计算机视觉中&#xff0c;角点检测是一种关键的技术&#xff0c;它可以帮助我们从图像中提取出这些重要的特征点&#xff0c;进而用于图像匹配、物体识别、图像拼接等多种应用。 角点检测示例…
阅读更多...
抽奖的诱惑系统注册与登录功能测试报告

抽奖的诱惑系统注册与登录功能测试报告

目录 一&#xff1a;项目背景 二&#xff1a;项目功能 &#xff08;1&#xff09; 注册功能 &#xff08;2&#xff09; 登录功能 电话 密码登录 电话 短信登录 三&#xff1a;设计测试用例 四&#xff1a;功能测试 五&#xff1a;自动化测试代码 七&#xff1a;遗留风…
阅读更多...
【蓝桥杯】每日练习 Day12 贡献法

【蓝桥杯】每日练习 Day12 贡献法

前言 今天给大家带来两道贡献法的问题&#xff0c;先来讲一下什么是贡献法。 贡献法&#xff0c;与其说是一种算法&#xff0c;不如说是一种数学方法&#xff0c;是一种思维方式。 先来给大家举个例子&#xff0c;假设现在有个问题&#xff0c;需要你在一个只有小写字母的字…
阅读更多...
文字也能生成视频？【蓝耘实践】：通义万相2.1文生视频

文字也能生成视频？【蓝耘实践】：通义万相2.1文生视频

文字也能生成视频&#xff1f;【蓝耘实践】&#xff1a;通义万相2.1文生视频 上次我们已经介绍了关于在蓝耘云平台实践通义万相的基本玩法&#xff0c;这次将介绍进阶玩法&#xff0c;也就是使用文字来生成视频。 首先我们还是先注册或者登录蓝耘云平台。 通过蓝耘平台进入流…
阅读更多...
ASP.NET Web的 Razor Pages应用，配置热重载，解决.NET Core MVC 页面在更改后不刷新

ASP.NET Web的 Razor Pages应用，配置热重载，解决.NET Core MVC 页面在更改后不刷新

Razor Pages应用&#xff0c;修改页面查看修改效果&#xff0c;如果没有热重载&#xff0c;改一句话跑一次&#xff0c;这个活就没法干了。 1、VS2022中的NuGet中安装RuntimeCompilation Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation 需要配套你的.net sdk版本&#x…
阅读更多...
PhotoShop学习02

PhotoShop学习02

1.添加文本 这个工具栏是文字工具栏&#xff0c;快捷键是T。选择之后鼠标会变成一个竖杠外貌&#xff0c;我们可以借此在图片中写入文字。 选择后&#xff0c;上方的工具栏会变为专门调整文字工具 这个框点击旁边的小箭头可以选择我们我们电脑系统自带的字体&#xff0c;同时可…
阅读更多...
BFS解决FloodFill算法

BFS解决FloodFill算法

1.图像渲染 733. 图像渲染 - 力扣&#xff08;LeetCode&#xff09; 1.题目解析 有一幅以 m x n 的二维整数数组表示的图画 image &#xff0c;其中 image[i][j] 表示该图画的像素值大小。你也被给予三个整数 sr , sc 和 color 。你应该从像素 image[sr][sc] 开始对图像进行…
阅读更多...
OpenAI的“噩梦”，DeepSeek V3-0324效率革命展现中国AI雄心

OpenAI的“噩梦”，DeepSeek V3-0324效率革命展现中国AI雄心

3月24日晚&#xff0c;DeepSeek低调发布其V3模型的小版本更新——DeepSeek V3-0324&#xff0c;这一操作立即在社区引发热议。据悉&#xff0c;该版本已集成至DeepSeek官网、应用程序和小程序&#xff0c;用户只需关闭“Deep Thinking”功能即可体验。另该模型已在Hugging Face…
阅读更多...
mysql创建库表插入数据演示

mysql创建库表插入数据演示

show databases; use zzj; create table stu (sid int primary key,name varchar(10) not null,sex varchar(2) );desc stu;insert into stu (sid, name, sex) values (1, zzj, 男);select * from stu; desc stu: select * from stu:
阅读更多...
用SVG绕过浏览器XSS审计

用SVG绕过浏览器XSS审计

[Translated From]&#xff1a;http://insert-script.blogspot.com/2014/02/svg-fun-time-firefox-svg-vector.html SVG - <use> element SVG中的<use>元素用于重用其他元素&#xff0c;主要用于联接<defs>和alike&#xff0c;而我们却用它来引用外部SVG文件…
阅读更多...
简记_单片机硬件最小系统设计

简记_单片机硬件最小系统设计

以STM32为例&#xff1a; 一、电源 1.1、数字电源 IO电源&#xff1a;VDD、VSS&#xff1a;1.8~3.6V&#xff0c;常用3.3V&#xff0c;去耦电容1 x 10u N x 100n &#xff1b; 内核电源&#xff1a;内嵌的稳压器输出&#xff1a;1.2V&#xff0c;给内核、存储器、数字外设…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023