diff --git a/compose/animation/animation-benchmark/build.gradle b/compose/animation/animation-benchmark/build.gradle
index cf2c99440d973..227900f7325f3 100644
--- a/compose/animation/animation-benchmark/build.gradle
+++ b/compose/animation/animation-benchmark/build.gradle
@@ -39,6 +39,9 @@ dependencies {
android {
compileSdk { version = release(37) }
+ defaultConfig {
+ minSdk { version = release(24) }
+ }
namespace = "androidx.compose.animation.benchmark"
}
diff --git a/compose/animation/animation-benchmark/integration-tests/macrobenchmark-target/build.gradle b/compose/animation/animation-benchmark/integration-tests/macrobenchmark-target/build.gradle
index 476158d235c2a..0c0af609cc888 100644
--- a/compose/animation/animation-benchmark/integration-tests/macrobenchmark-target/build.gradle
+++ b/compose/animation/animation-benchmark/integration-tests/macrobenchmark-target/build.gradle
@@ -25,14 +25,14 @@ android {
compileSdk { version = release(37) }
buildTypes {
release {
- minifyEnabled true
+ minifyEnabled = true
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt')
}
benchmark {
initWith release
signingConfig = signingConfigs.debug
matchingFallbacks = ['release']
- debuggable false
+ debuggable = false
}
}
}
@@ -44,8 +44,8 @@ dependencies {
implementation(project(":compose:foundation:foundation"))
implementation(project(":compose:material:material"))
implementation(project(":compose:material3:material3"))
- implementation(project(":lifecycle:lifecycle-runtime"))
- implementation(project(":lifecycle:lifecycle-common"))
- implementation(project(":lifecycle:lifecycle-viewmodel"))
+ implementation("androidx.lifecycle:lifecycle-runtime:2.10.0")
+ implementation("androidx.lifecycle:lifecycle-common:2.10.0")
+ implementation("androidx.lifecycle:lifecycle-viewmodel:2.10.0")
implementation(project(":compose:runtime:runtime"))
}
diff --git a/compose/animation/animation-benchmark/integration-tests/macrobenchmark-target/lint-baseline.xml b/compose/animation/animation-benchmark/integration-tests/macrobenchmark-target/lint-baseline.xml
deleted file mode 100644
index e33c4657f6b87..0000000000000
--- a/compose/animation/animation-benchmark/integration-tests/macrobenchmark-target/lint-baseline.xml
+++ /dev/null
@@ -1,13 +0,0 @@
-
-
-
-
-
-
-
-
diff --git a/compose/animation/animation-benchmark/macrobenchmark/build.gradle b/compose/animation/animation-benchmark/macrobenchmark/build.gradle
index bc01189edb423..4594701637cbc 100644
--- a/compose/animation/animation-benchmark/macrobenchmark/build.gradle
+++ b/compose/animation/animation-benchmark/macrobenchmark/build.gradle
@@ -24,6 +24,9 @@ android {
compileSdk {
version = release(37)
}
+ defaultConfig {
+ minSdk { version = release(24) }
+ }
buildTypes {
// This benchmark buildType is used for benchmarking, and should function like your
diff --git a/compose/animation/animation-benchmark/src/androidTest/java/androidx/compose/animation/benchmark/AnimateXAsStateBenchmark.kt b/compose/animation/animation-benchmark/src/androidTest/java/androidx/compose/animation/benchmark/AnimateXAsStateBenchmark.kt
new file mode 100644
index 0000000000000..ac1fd18aef3b7
--- /dev/null
+++ b/compose/animation/animation-benchmark/src/androidTest/java/androidx/compose/animation/benchmark/AnimateXAsStateBenchmark.kt
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2026 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.animation.benchmark
+
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.runtime.Composable
+import androidx.compose.testutils.LayeredComposeTestCase
+import androidx.compose.testutils.benchmark.ComposeBenchmarkRule
+import androidx.compose.testutils.benchmark.benchmarkFirstCompose
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.filters.LargeTest
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@LargeTest
+@RunWith(AndroidJUnit4::class)
+class AnimateXAsStateBenchmark {
+ @get:Rule val rule = ComposeBenchmarkRule()
+
+ @Test fun animateFloat_compose() = rule.benchmarkFirstCompose(::AnimateFloatAsStateTestCase)
+}
+
+private class AnimateFloatAsStateTestCase : LayeredComposeTestCase() {
+ @Composable
+ override fun MeasuredContent() {
+ animateFloatAsState(targetValue = 0f)
+ }
+}
diff --git a/compose/animation/animation-benchmark/src/androidTest/java/androidx/compose/animation/benchmark/AnimatedContentBenchmark.kt b/compose/animation/animation-benchmark/src/androidTest/java/androidx/compose/animation/benchmark/AnimatedContentBenchmark.kt
new file mode 100644
index 0000000000000..cb586710202a3
--- /dev/null
+++ b/compose/animation/animation-benchmark/src/androidTest/java/androidx/compose/animation/benchmark/AnimatedContentBenchmark.kt
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2026 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.animation.benchmark
+
+import androidx.compose.animation.AnimatedContent
+import androidx.compose.animation.core.updateTransition
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.compose.testutils.LayeredComposeTestCase
+import androidx.compose.testutils.ToggleableTestCase
+import androidx.compose.testutils.benchmark.ComposeBenchmarkRule
+import androidx.compose.testutils.benchmark.benchmarkFirstCompose
+import androidx.compose.testutils.benchmark.benchmarkToFirstPixel
+import androidx.compose.testutils.benchmark.toggleStateBenchmarkCompose
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.filters.LargeTest
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@LargeTest
+@RunWith(AndroidJUnit4::class)
+class AnimatedContentBenchmark {
+ @get:Rule val rule = ComposeBenchmarkRule()
+
+ @Test fun compose() = rule.benchmarkFirstCompose(::AnimatedContentTestCase)
+
+ @Test fun firstPixel() = rule.benchmarkToFirstPixel(::AnimatedContentTestCase)
+
+ @Test
+ fun toggleState_compose() =
+ rule.toggleStateBenchmarkCompose(::AnimatedContentTestCase, assertOneRecomposition = false)
+}
+
+private class AnimatedContentTestCase : LayeredComposeTestCase(), ToggleableTestCase {
+ var state by mutableStateOf(true)
+
+ @Composable
+ override fun MeasuredContent() {
+ val transition = updateTransition(state)
+ transition.AnimatedContent { targetState ->
+ Box(Modifier.fillMaxSize().background(if (targetState) Color.Red else Color.Green))
+ }
+ }
+
+ override fun toggleState() {
+ state = !state
+ }
+}
diff --git a/compose/animation/animation-benchmark/src/androidTest/java/androidx/compose/animation/benchmark/AnimatedVisibilityBenchmark.kt b/compose/animation/animation-benchmark/src/androidTest/java/androidx/compose/animation/benchmark/AnimatedVisibilityBenchmark.kt
new file mode 100644
index 0000000000000..71ef00a0a1bbd
--- /dev/null
+++ b/compose/animation/animation-benchmark/src/androidTest/java/androidx/compose/animation/benchmark/AnimatedVisibilityBenchmark.kt
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2026 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.animation.benchmark
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.core.updateTransition
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.compose.testutils.LayeredComposeTestCase
+import androidx.compose.testutils.ToggleableTestCase
+import androidx.compose.testutils.benchmark.ComposeBenchmarkRule
+import androidx.compose.testutils.benchmark.benchmarkFirstCompose
+import androidx.compose.testutils.benchmark.benchmarkToFirstPixel
+import androidx.compose.testutils.benchmark.toggleStateBenchmarkCompose
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.filters.LargeTest
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@LargeTest
+@RunWith(AndroidJUnit4::class)
+class AnimatedVisibilityBenchmark {
+ @get:Rule val rule = ComposeBenchmarkRule()
+
+ @Test fun compose() = rule.benchmarkFirstCompose(::AnimatedVisibilityTestCase)
+
+ @Test fun firstPixel() = rule.benchmarkToFirstPixel(::AnimatedVisibilityTestCase)
+
+ @Test
+ fun toggleState_compose() =
+ rule.toggleStateBenchmarkCompose(
+ ::AnimatedVisibilityTestCase,
+ assertOneRecomposition = false,
+ )
+}
+
+private class AnimatedVisibilityTestCase : LayeredComposeTestCase(), ToggleableTestCase {
+ var state by mutableStateOf(true)
+
+ @Composable
+ override fun MeasuredContent() {
+ val transition = updateTransition(state)
+ transition.AnimatedVisibility(visible = { it }) {
+ Box(Modifier.fillMaxSize().background(Color.Red))
+ }
+ }
+
+ override fun toggleState() {
+ state = !state
+ }
+}
diff --git a/compose/animation/animation-benchmark/src/androidTest/java/androidx/compose/animation/benchmark/CapturedAnimatedVisibilityBenchmark.kt b/compose/animation/animation-benchmark/src/androidTest/java/androidx/compose/animation/benchmark/CapturedAnimatedVisibilityBenchmark.kt
new file mode 100644
index 0000000000000..3d8c81af56cf0
--- /dev/null
+++ b/compose/animation/animation-benchmark/src/androidTest/java/androidx/compose/animation/benchmark/CapturedAnimatedVisibilityBenchmark.kt
@@ -0,0 +1,241 @@
+/*
+ * Copyright 2026 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.animation.benchmark
+
+import androidx.benchmark.ExperimentalBenchmarkConfigApi
+import androidx.benchmark.MicrobenchmarkConfig
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.CapturedAnimatedVisibility
+import androidx.compose.animation.EnterTransition
+import androidx.compose.animation.core.MutableTransitionState
+import androidx.compose.animation.core.tween
+import androidx.compose.animation.fadeOut
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.text.BasicText
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.setValue
+import androidx.compose.testutils.LayeredComposeTestCase
+import androidx.compose.testutils.ToggleableTestCase
+import androidx.compose.testutils.benchmark.ComposeBenchmarkRule
+import androidx.compose.testutils.doFramesUntilNoChangesPending
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.unit.dp
+import androidx.test.filters.LargeTest
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.Parameterized
+import org.junit.runners.Parameterized.Parameters
+
+@LargeTest
+@RunWith(Parameterized::class)
+class CapturedAnimatedVisibilityBenchmark(
+ private val useCaptured: Boolean,
+ private val isComplexContent: Boolean,
+) {
+ companion object {
+ @JvmStatic
+ @Parameters(name = "captured={0}_complex={1}")
+ fun data() =
+ listOf(
+ arrayOf(false, false), // AV Simple
+ arrayOf(true, false), // CAV Simple
+ arrayOf(false, true), // AV Elaborate
+ arrayOf(true, true), // CAV Elaborate
+ )
+ }
+
+ // Run the whole animation sequence ~18 frames per animation 10 times.
+ @OptIn(ExperimentalBenchmarkConfigApi::class)
+ @get:Rule
+ val rule = ComposeBenchmarkRule(MicrobenchmarkConfig(warmupCount = 3, measurementCount = 10))
+
+ /** Measures total combined CPU duration across the full exit animation sequence. */
+ @Test
+ fun exitFullSequence() {
+ rule.runBenchmarkFor({ VisibilityBenchmarkTestCase(useCaptured, isComplexContent) }) {
+ rule.runOnUiThread { doFramesUntilNoChangesPending(60) }
+ rule.measureRepeatedOnUiThread {
+ runWithMeasurementDisabled {
+ getTestCase().setToVisible()
+ doFramesUntilNoChangesPending(10)
+ // Once all the changes are settled, change the visibility to start exit
+ // animation, and subsequent measurements.
+ getTestCase().setToInvisible()
+ }
+ doFramesUntilNoChangesPending(maxAmountOfFrames = 60)
+ }
+ }
+ }
+
+ /** Measures isolated Recomposition pass duration across the full exit animation sequence. */
+ @Test
+ fun exitFullSequenceRecompose() {
+ rule.runBenchmarkFor({ VisibilityBenchmarkTestCase(useCaptured, isComplexContent) }) {
+ rule.runOnUiThread { doFramesUntilNoChangesPending(60) }
+ rule.measureRepeatedOnUiThread {
+ runWithMeasurementDisabled {
+ getTestCase().setToVisible()
+ doFramesUntilNoChangesPending(10)
+ getTestCase().setToInvisible()
+ }
+ while (hasPendingChanges()) {
+ recompose()
+ runWithMeasurementDisabled {
+ measure()
+ layout()
+ drawToBitmap()
+ }
+ }
+ }
+ }
+ }
+
+ /** Measures isolated Measure & Layout pass duration across the full exit animation sequence. */
+ @Test
+ fun exitFullSequenceMeasureLayout() {
+ rule.runBenchmarkFor({ VisibilityBenchmarkTestCase(useCaptured, isComplexContent) }) {
+ rule.runOnUiThread { doFramesUntilNoChangesPending(60) }
+ rule.measureRepeatedOnUiThread {
+ runWithMeasurementDisabled {
+ getTestCase().setToVisible()
+ doFramesUntilNoChangesPending(10)
+ getTestCase().setToInvisible()
+ }
+ while (hasPendingChanges()) {
+ runWithMeasurementDisabled { recompose() }
+ measure()
+ layout()
+ runWithMeasurementDisabled { drawToBitmap() }
+ }
+ }
+ }
+ }
+
+ /** Measures isolated Draw pass duration across the full exit animation sequence. */
+ @Test
+ fun exitFullSequenceDraw() {
+ rule.runBenchmarkFor({ VisibilityBenchmarkTestCase(useCaptured, isComplexContent) }) {
+ rule.runOnUiThread { doFramesUntilNoChangesPending(60) }
+ rule.measureRepeatedOnUiThread {
+ runWithMeasurementDisabled {
+ getTestCase().setToVisible()
+ doFramesUntilNoChangesPending(10)
+ getTestCase().setToInvisible()
+ }
+ while (hasPendingChanges()) {
+ runWithMeasurementDisabled {
+ recompose()
+ measure()
+ layout()
+ drawPrepare()
+ }
+ draw()
+ runWithMeasurementDisabled { drawFinish() }
+ }
+ }
+ }
+ }
+}
+
+private class VisibilityBenchmarkTestCase(
+ private val useCaptured: Boolean,
+ private val isComplexContent: Boolean,
+) : LayeredComposeTestCase(), ToggleableTestCase {
+ val visibleState = MutableTransitionState(true)
+ var visible: Boolean = true
+
+ fun setToVisible() {
+ visibleState.targetState = true
+ }
+
+ fun setToInvisible() {
+ visibleState.targetState = false
+ }
+
+ @Composable
+ override fun MeasuredContent() {
+ visible = visibleState.currentState
+ if (useCaptured) {
+ CapturedAnimatedVisibility(
+ visibleState = visibleState,
+ enter = EnterTransition.None,
+ exit = fadeOut(tween(300)),
+ ) {
+ if (isComplexContent) ElaborateContent() else SimpleContent()
+ }
+ } else {
+ AnimatedVisibility(
+ visibleState = visibleState,
+ enter = EnterTransition.None,
+ exit = fadeOut(tween(300)),
+ ) {
+ if (isComplexContent) ElaborateContent() else SimpleContent()
+ }
+ }
+ }
+
+ override fun toggleState() {
+ visibleState.targetState = !visibleState.targetState
+ }
+}
+
+@Composable
+private fun SimpleContent() {
+ Box(
+ modifier = Modifier.size(100.dp).background(Color.Red),
+ contentAlignment = Alignment.Center,
+ ) {
+ BasicText("Simple Content", style = TextStyle(color = Color.White))
+ }
+}
+
+@Composable
+private fun ElaborateContent() {
+ Column(Modifier.fillMaxWidth().padding(8.dp)) {
+ repeat(15) { rowIndex ->
+ Row(Modifier.fillMaxWidth().padding(vertical = 2.dp)) {
+ repeat(4) { colIndex ->
+ Box(
+ modifier =
+ Modifier.weight(1f)
+ .height(40.dp)
+ .padding(2.dp)
+ .background(Color(0xFFE0F7FA)),
+ contentAlignment = Alignment.Center,
+ ) {
+ BasicText(
+ text = "Item $rowIndex-$colIndex",
+ modifier = Modifier.padding(4.dp),
+ )
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/compose/animation/animation-benchmark/src/androidTest/java/androidx/compose/animation/benchmark/CrossfadeBenchmark.kt b/compose/animation/animation-benchmark/src/androidTest/java/androidx/compose/animation/benchmark/CrossfadeBenchmark.kt
new file mode 100644
index 0000000000000..3fd872e02e019
--- /dev/null
+++ b/compose/animation/animation-benchmark/src/androidTest/java/androidx/compose/animation/benchmark/CrossfadeBenchmark.kt
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2026 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.animation.benchmark
+
+import androidx.compose.animation.Crossfade
+import androidx.compose.animation.core.updateTransition
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.compose.testutils.LayeredComposeTestCase
+import androidx.compose.testutils.ToggleableTestCase
+import androidx.compose.testutils.benchmark.ComposeBenchmarkRule
+import androidx.compose.testutils.benchmark.benchmarkFirstCompose
+import androidx.compose.testutils.benchmark.benchmarkToFirstPixel
+import androidx.compose.testutils.benchmark.toggleStateBenchmarkCompose
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.filters.LargeTest
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@LargeTest
+@RunWith(AndroidJUnit4::class)
+class CrossfadeBenchmark {
+ @get:Rule val rule = ComposeBenchmarkRule()
+
+ @Test fun compose() = rule.benchmarkFirstCompose(::CrossfadeTestCase)
+
+ @Test fun firstPixel() = rule.benchmarkToFirstPixel(::CrossfadeTestCase)
+
+ @Test
+ fun toggleState_compose() =
+ rule.toggleStateBenchmarkCompose(::CrossfadeTestCase, assertOneRecomposition = false)
+}
+
+private class CrossfadeTestCase : LayeredComposeTestCase(), ToggleableTestCase {
+ var state by mutableStateOf(true)
+
+ @Composable
+ override fun MeasuredContent() {
+ val transition = updateTransition(state)
+ transition.Crossfade { targetState ->
+ Box(Modifier.fillMaxSize().background(if (targetState) Color.Red else Color.Green))
+ }
+ }
+
+ override fun toggleState() {
+ state = !state
+ }
+}
diff --git a/compose/animation/animation-benchmark/src/androidTest/java/androidx/compose/animation/benchmark/TransitionBenchmark.kt b/compose/animation/animation-benchmark/src/androidTest/java/androidx/compose/animation/benchmark/TransitionBenchmark.kt
index 74cde5578cb93..8b6e8e3048674 100644
--- a/compose/animation/animation-benchmark/src/androidTest/java/androidx/compose/animation/benchmark/TransitionBenchmark.kt
+++ b/compose/animation/animation-benchmark/src/androidTest/java/androidx/compose/animation/benchmark/TransitionBenchmark.kt
@@ -16,13 +16,16 @@
package androidx.compose.animation.benchmark
+import androidx.compose.animation.core.MutableTransitionState
import androidx.compose.animation.core.animateDp
import androidx.compose.animation.core.animateFloat
+import androidx.compose.animation.core.rememberTransition
import androidx.compose.animation.core.updateTransition
import androidx.compose.foundation.layout.Box
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.testutils.LayeredComposeTestCase
import androidx.compose.testutils.ToggleableTestCase
@@ -44,12 +47,22 @@ class TransitionBenchmark {
@get:Rule val rule = ComposeBenchmarkRule()
- /**
- * Measures the cost of creating a new [androidx.compose.animation.core.Transition] instance.
- */
+ /** Measures the cost of calling [updateTransition]. */
@Test
fun createTransitionThroughUpdateTransition() {
- rule.benchmarkFirstCompose(::TransitionInstantiationTestCase)
+ rule.benchmarkFirstCompose(::UpdateTransitionTestCase)
+ }
+
+ /** Measures the cost of calling [rememberTransition]. */
+ @Test
+ fun createTransitionThroughRememberTransition() {
+ rule.benchmarkFirstCompose { RememberTransitionTestCase(sameState = true) }
+ }
+
+ /** Measures the cost of calling [rememberTransition] with different initial state. */
+ @Test
+ fun createTransitionThroughRememberTransition_differentState() {
+ rule.benchmarkFirstCompose { RememberTransitionTestCase(sameState = false) }
}
/** Measures the cost of running a [androidx.compose.animation.core.Transition]. */
@@ -59,13 +72,25 @@ class TransitionBenchmark {
}
}
-private class TransitionInstantiationTestCase : LayeredComposeTestCase() {
+private class UpdateTransitionTestCase : LayeredComposeTestCase() {
@Composable
override fun MeasuredContent() {
updateTransition(targetState = Unit, label = null)
}
}
+private class RememberTransitionTestCase(private val sameState: Boolean) :
+ LayeredComposeTestCase() {
+ @Composable
+ override fun MeasuredContent() {
+ val state = remember { MutableTransitionState(true) }
+ if (!sameState) {
+ state.targetState = false
+ }
+ rememberTransition(state, label = null)
+ }
+}
+
private class TransitionTestCase : LayeredComposeTestCase(), ToggleableTestCase {
private var state by mutableStateOf(false)
diff --git a/compose/animation/animation-core/api/1.10.0-beta01.txt b/compose/animation/animation-core/api/1.10.0-beta01.txt
new file mode 100644
index 0000000000000..f05548c256a78
--- /dev/null
+++ b/compose/animation/animation-core/api/1.10.0-beta01.txt
@@ -0,0 +1,986 @@
+// Signature format: 4.0
+package androidx.compose.animation.core {
+
+ public final class Animatable {
+ ctor @BytecodeOnly @Deprecated public Animatable(Object!, androidx.compose.animation.core.TwoWayConverter!, Object!);
+ ctor @BytecodeOnly @Deprecated public Animatable(Object!, androidx.compose.animation.core.TwoWayConverter!, Object!, int, kotlin.jvm.internal.DefaultConstructorMarker!);
+ ctor @BytecodeOnly @androidx.compose.runtime.annotation.RememberInComposition public Animatable(Object!, androidx.compose.animation.core.TwoWayConverter!, Object!, String!, int, kotlin.jvm.internal.DefaultConstructorMarker!);
+ ctor @androidx.compose.runtime.annotation.RememberInComposition public Animatable(T initialValue, androidx.compose.animation.core.TwoWayConverter typeConverter, optional T? visibilityThreshold, optional String label);
+ method public suspend Object? animateDecay(T initialVelocity, androidx.compose.animation.core.DecayAnimationSpec animationSpec, optional kotlin.jvm.functions.Function1,kotlin.Unit>? block, kotlin.coroutines.Continuation>);
+ method @BytecodeOnly public static Object! animateDecay$default(androidx.compose.animation.core.Animatable!, Object!, androidx.compose.animation.core.DecayAnimationSpec!, kotlin.jvm.functions.Function1!, kotlin.coroutines.Continuation!, int, Object!);
+ method public suspend Object? animateTo(T targetValue, optional androidx.compose.animation.core.AnimationSpec animationSpec, optional T initialVelocity, optional kotlin.jvm.functions.Function1,kotlin.Unit>? block, kotlin.coroutines.Continuation>);
+ method @BytecodeOnly public static Object! animateTo$default(androidx.compose.animation.core.Animatable!, Object!, androidx.compose.animation.core.AnimationSpec!, Object!, kotlin.jvm.functions.Function1!, kotlin.coroutines.Continuation!, int, Object!);
+ method public androidx.compose.runtime.State asState();
+ method @InaccessibleFromKotlin public String getLabel();
+ method @InaccessibleFromKotlin public T? getLowerBound();
+ method @InaccessibleFromKotlin public T getTargetValue();
+ method @InaccessibleFromKotlin public androidx.compose.animation.core.TwoWayConverter getTypeConverter();
+ method @InaccessibleFromKotlin public T? getUpperBound();
+ method @InaccessibleFromKotlin public T getValue();
+ method @InaccessibleFromKotlin public T getVelocity();
+ method @InaccessibleFromKotlin public V getVelocityVector();
+ method @InaccessibleFromKotlin public boolean isRunning();
+ method public suspend Object? snapTo(T targetValue, kotlin.coroutines.Continuation);
+ method public suspend Object? stop(kotlin.coroutines.Continuation);
+ method public void updateBounds(optional T? lowerBound, optional T? upperBound);
+ method @BytecodeOnly public static void updateBounds$default(androidx.compose.animation.core.Animatable!, Object!, Object!, int, Object!);
+ property public boolean isRunning;
+ property public String label;
+ property public T? lowerBound;
+ property public T targetValue;
+ property public androidx.compose.animation.core.TwoWayConverter typeConverter;
+ property public T? upperBound;
+ property public T value;
+ property public T velocity;
+ property public V velocityVector;
+ }
+
+ public final class AnimatableKt {
+ method @androidx.compose.runtime.annotation.RememberInComposition public static androidx.compose.animation.core.Animatable Animatable(float initialValue, optional float visibilityThreshold);
+ method @BytecodeOnly @androidx.compose.runtime.annotation.RememberInComposition public static androidx.compose.animation.core.Animatable! Animatable$default(float, float, int, Object!);
+ }
+
+ public final class AnimateAsStateKt {
+ method @KotlinOnly @androidx.compose.runtime.Composable public static androidx.compose.runtime.State animateDpAsState(androidx.compose.ui.unit.Dp targetValue, optional androidx.compose.animation.core.AnimationSpec animationSpec, optional String label, optional kotlin.jvm.functions.Function1? finishedListener);
+ method @BytecodeOnly @androidx.compose.runtime.Composable public static androidx.compose.runtime.State animateDpAsState-AjpBEmI(float, androidx.compose.animation.core.AnimationSpec?, String?, kotlin.jvm.functions.Function1?, androidx.compose.runtime.Composer?, int, int);
+ method @BytecodeOnly @Deprecated @androidx.compose.runtime.Composable public static androidx.compose.runtime.State! animateDpAsState-Kz89ssw(float, androidx.compose.animation.core.AnimationSpec!, kotlin.jvm.functions.Function1!, androidx.compose.runtime.Composer!, int, int);
+ method @BytecodeOnly @Deprecated @androidx.compose.runtime.Composable public static androidx.compose.runtime.State! animateFloatAsState(float, androidx.compose.animation.core.AnimationSpec!, float, kotlin.jvm.functions.Function1!, androidx.compose.runtime.Composer!, int, int);
+ method @BytecodeOnly @androidx.compose.runtime.Composable public static androidx.compose.runtime.State animateFloatAsState(float, androidx.compose.animation.core.AnimationSpec?, float, String?, kotlin.jvm.functions.Function1?, androidx.compose.runtime.Composer?, int, int);
+ method @KotlinOnly @androidx.compose.runtime.Composable public static androidx.compose.runtime.State animateFloatAsState(float targetValue, optional androidx.compose.animation.core.AnimationSpec animationSpec, optional float visibilityThreshold, optional String label, optional kotlin.jvm.functions.Function1? finishedListener);
+ method @BytecodeOnly @Deprecated @androidx.compose.runtime.Composable public static androidx.compose.runtime.State! animateIntAsState(int, androidx.compose.animation.core.AnimationSpec!, kotlin.jvm.functions.Function1!, androidx.compose.runtime.Composer!, int, int);
+ method @BytecodeOnly @androidx.compose.runtime.Composable public static androidx.compose.runtime.State animateIntAsState(int, androidx.compose.animation.core.AnimationSpec?, String?, kotlin.jvm.functions.Function1?, androidx.compose.runtime.Composer?, int, int);
+ method @KotlinOnly @androidx.compose.runtime.Composable public static androidx.compose.runtime.State animateIntAsState(int targetValue, optional androidx.compose.animation.core.AnimationSpec animationSpec, optional String label, optional kotlin.jvm.functions.Function1? finishedListener);
+ method @KotlinOnly @androidx.compose.runtime.Composable public static androidx.compose.runtime.State animateIntOffsetAsState(androidx.compose.ui.unit.IntOffset targetValue, optional androidx.compose.animation.core.AnimationSpec animationSpec, optional String label, optional kotlin.jvm.functions.Function1? finishedListener);
+ method @BytecodeOnly @Deprecated @androidx.compose.runtime.Composable public static androidx.compose.runtime.State! animateIntOffsetAsState-8f6pmRE(long, androidx.compose.animation.core.AnimationSpec!, kotlin.jvm.functions.Function1!, androidx.compose.runtime.Composer!, int, int);
+ method @BytecodeOnly @androidx.compose.runtime.Composable public static androidx.compose.runtime.State animateIntOffsetAsState-HyPO7BM(long, androidx.compose.animation.core.AnimationSpec?, String?, kotlin.jvm.functions.Function1?, androidx.compose.runtime.Composer?, int, int);
+ method @KotlinOnly @androidx.compose.runtime.Composable public static androidx.compose.runtime.State animateIntSizeAsState(androidx.compose.ui.unit.IntSize targetValue, optional androidx.compose.animation.core.AnimationSpec animationSpec, optional String label, optional kotlin.jvm.functions.Function1? finishedListener);
+ method @BytecodeOnly @androidx.compose.runtime.Composable public static androidx.compose.runtime.State animateIntSizeAsState-4goxYXU(long, androidx.compose.animation.core.AnimationSpec?, String?, kotlin.jvm.functions.Function1?, androidx.compose.runtime.Composer?, int, int);
+ method @BytecodeOnly @Deprecated @androidx.compose.runtime.Composable public static androidx.compose.runtime.State! animateIntSizeAsState-zTRF_AQ(long, androidx.compose.animation.core.AnimationSpec!, kotlin.jvm.functions.Function1!, androidx.compose.runtime.Composer!, int, int);
+ method @KotlinOnly @androidx.compose.runtime.Composable public static androidx.compose.runtime.State animateOffsetAsState(androidx.compose.ui.geometry.Offset targetValue, optional androidx.compose.animation.core.AnimationSpec animationSpec, optional String label, optional kotlin.jvm.functions.Function1? finishedListener);
+ method @BytecodeOnly @androidx.compose.runtime.Composable public static androidx.compose.runtime.State animateOffsetAsState-7362WCg(long, androidx.compose.animation.core.AnimationSpec?, String?, kotlin.jvm.functions.Function1?, androidx.compose.runtime.Composer?, int, int);
+ method @BytecodeOnly @Deprecated @androidx.compose.runtime.Composable public static androidx.compose.runtime.State! animateOffsetAsState-N6fFfp4(long, androidx.compose.animation.core.AnimationSpec!, kotlin.jvm.functions.Function1!, androidx.compose.runtime.Composer!, int, int);
+ method @BytecodeOnly @Deprecated @androidx.compose.runtime.Composable public static androidx.compose.runtime.State! animateRectAsState(androidx.compose.ui.geometry.Rect!, androidx.compose.animation.core.AnimationSpec!, kotlin.jvm.functions.Function1!, androidx.compose.runtime.Composer!, int, int);
+ method @BytecodeOnly @androidx.compose.runtime.Composable public static androidx.compose.runtime.State animateRectAsState(androidx.compose.ui.geometry.Rect, androidx.compose.animation.core.AnimationSpec?, String?, kotlin.jvm.functions.Function1?, androidx.compose.runtime.Composer?, int, int);
+ method @KotlinOnly @androidx.compose.runtime.Composable public static androidx.compose.runtime.State animateRectAsState(androidx.compose.ui.geometry.Rect targetValue, optional androidx.compose.animation.core.AnimationSpec animationSpec, optional String label, optional kotlin.jvm.functions.Function1? finishedListener);
+ method @KotlinOnly @androidx.compose.runtime.Composable public static androidx.compose.runtime.State animateSizeAsState(androidx.compose.ui.geometry.Size targetValue, optional androidx.compose.animation.core.AnimationSpec animationSpec, optional String label, optional kotlin.jvm.functions.Function1? finishedListener);
+ method @BytecodeOnly @Deprecated @androidx.compose.runtime.Composable public static androidx.compose.runtime.State! animateSizeAsState-LjSzlW0(long, androidx.compose.animation.core.AnimationSpec!, kotlin.jvm.functions.Function1!, androidx.compose.runtime.Composer!, int, int);
+ method @BytecodeOnly @androidx.compose.runtime.Composable public static androidx.compose.runtime.State animateSizeAsState-YLp_XPw(long, androidx.compose.animation.core.AnimationSpec?, String?, kotlin.jvm.functions.Function1?, androidx.compose.runtime.Composer?, int, int);
+ method @BytecodeOnly @Deprecated @androidx.compose.runtime.Composable public static androidx.compose.runtime.State! animateValueAsState(Object!, androidx.compose.animation.core.TwoWayConverter!, androidx.compose.animation.core.AnimationSpec!, Object!, kotlin.jvm.functions.Function1!, androidx.compose.runtime.Composer!, int, int);
+ method @BytecodeOnly @androidx.compose.runtime.Composable public static androidx.compose.runtime.State animateValueAsState(T!, androidx.compose.animation.core.TwoWayConverter, androidx.compose.animation.core.AnimationSpec?, T?, String?, kotlin.jvm.functions.Function1?, androidx.compose.runtime.Composer?, int, int);
+ method @KotlinOnly @androidx.compose.runtime.Composable public static androidx.compose.runtime.State animateValueAsState(T targetValue, androidx.compose.animation.core.TwoWayConverter typeConverter, optional androidx.compose.animation.core.AnimationSpec animationSpec, optional T? visibilityThreshold, optional String label, optional kotlin.jvm.functions.Function1? finishedListener);
+ }
+
+ @kotlin.jvm.JvmDefaultWithCompatibility public interface Animation {
+ method @InaccessibleFromKotlin public long getDurationNanos();
+ method @InaccessibleFromKotlin public T getTargetValue();
+ method @InaccessibleFromKotlin public androidx.compose.animation.core.TwoWayConverter getTypeConverter();
+ method public T getValueFromNanos(long playTimeNanos);
+ method public V getVelocityVectorFromNanos(long playTimeNanos);
+ method public default boolean isFinishedFromNanos(long playTimeNanos);
+ method @InaccessibleFromKotlin public boolean isInfinite();
+ property public abstract long durationNanos;
+ property public abstract boolean isInfinite;
+ property public abstract T targetValue;
+ property public abstract androidx.compose.animation.core.TwoWayConverter typeConverter;
+ }
+
+ public final class AnimationConstants {
+ property public static int DefaultDurationMillis;
+ property public static long UnspecifiedTime;
+ field public static final int DefaultDurationMillis = 300; // 0x12c
+ field public static final androidx.compose.animation.core.AnimationConstants INSTANCE;
+ field public static final long UnspecifiedTime = -9223372036854775808L; // 0x8000000000000000L
+ }
+
+ public enum AnimationEndReason {
+ enum_constant public static final androidx.compose.animation.core.AnimationEndReason BoundReached;
+ enum_constant public static final androidx.compose.animation.core.AnimationEndReason Finished;
+ }
+
+ public final class AnimationKt {
+ method public static androidx.compose.animation.core.DecayAnimation DecayAnimation(androidx.compose.animation.core.FloatDecayAnimationSpec animationSpec, float initialValue, optional float initialVelocity);
+ method @BytecodeOnly public static androidx.compose.animation.core.DecayAnimation! DecayAnimation$default(androidx.compose.animation.core.FloatDecayAnimationSpec!, float, float, int, Object!);
+ method public static androidx.compose.animation.core.TargetBasedAnimation TargetBasedAnimation(androidx.compose.animation.core.AnimationSpec animationSpec, androidx.compose.animation.core.TwoWayConverter typeConverter, T initialValue, T targetValue, T initialVelocity);
+ method public static T getVelocityFromNanos(androidx.compose.animation.core.Animation, long playTimeNanos);
+ }
+
+ public final class AnimationResult {
+ ctor public AnimationResult(androidx.compose.animation.core.AnimationState endState, androidx.compose.animation.core.AnimationEndReason endReason);
+ method @InaccessibleFromKotlin public androidx.compose.animation.core.AnimationEndReason getEndReason();
+ method @InaccessibleFromKotlin public androidx.compose.animation.core.AnimationState getEndState();
+ property public androidx.compose.animation.core.AnimationEndReason endReason;
+ property public androidx.compose.animation.core.AnimationState endState;
+ }
+
+ public final class AnimationScope {
+ method public void cancelAnimation();
+ method @InaccessibleFromKotlin public long getFinishedTimeNanos();
+ method @InaccessibleFromKotlin public long getLastFrameTimeNanos();
+ method @InaccessibleFromKotlin public long getStartTimeNanos();
+ method @InaccessibleFromKotlin public T getTargetValue();
+ method @InaccessibleFromKotlin public androidx.compose.animation.core.TwoWayConverter getTypeConverter();
+ method @InaccessibleFromKotlin public T getValue();
+ method @InaccessibleFromKotlin public T getVelocity();
+ method @InaccessibleFromKotlin public V getVelocityVector();
+ method @InaccessibleFromKotlin public boolean isRunning();
+ method public androidx.compose.animation.core.AnimationState toAnimationState();
+ property public long finishedTimeNanos;
+ property public boolean isRunning;
+ property public long lastFrameTimeNanos;
+ property public long startTimeNanos;
+ property public T targetValue;
+ property public androidx.compose.animation.core.TwoWayConverter typeConverter;
+ property public T value;
+ property public T velocity;
+ property public V velocityVector;
+ }
+
+ public interface AnimationSpec {
+ method public androidx.compose.animation.core.VectorizedAnimationSpec vectorize(androidx.compose.animation.core.TwoWayConverter converter);
+ }
+
+ public final class AnimationSpecKt {
+ method @BytecodeOnly @Deprecated @androidx.compose.runtime.Stable public static androidx.compose.animation.core.InfiniteRepeatableSpec! infiniteRepeatable(androidx.compose.animation.core.DurationBasedAnimationSpec!, androidx.compose.animation.core.RepeatMode!);
+ method @KotlinOnly @androidx.compose.runtime.Stable public static androidx.compose.animation.core.InfiniteRepeatableSpec infiniteRepeatable(androidx.compose.animation.core.DurationBasedAnimationSpec animation, optional androidx.compose.animation.core.RepeatMode repeatMode, optional androidx.compose.animation.core.StartOffset initialStartOffset);
+ method @BytecodeOnly @Deprecated @androidx.compose.runtime.Stable public static androidx.compose.animation.core.InfiniteRepeatableSpec! infiniteRepeatable$default(androidx.compose.animation.core.DurationBasedAnimationSpec!, androidx.compose.animation.core.RepeatMode!, int, Object!);
+ method @BytecodeOnly @androidx.compose.runtime.Stable public static androidx.compose.animation.core.InfiniteRepeatableSpec infiniteRepeatable-9IiC70o(androidx.compose.animation.core.DurationBasedAnimationSpec, androidx.compose.animation.core.RepeatMode, long);
+ method @BytecodeOnly @androidx.compose.runtime.Stable public static androidx.compose.animation.core.InfiniteRepeatableSpec! infiniteRepeatable-9IiC70o$default(androidx.compose.animation.core.DurationBasedAnimationSpec!, androidx.compose.animation.core.RepeatMode!, long, int, Object!);
+ method @androidx.compose.runtime.Stable public static androidx.compose.animation.core.KeyframesSpec keyframes(kotlin.jvm.functions.Function1,kotlin.Unit> init);
+ method public static androidx.compose.animation.core.KeyframesWithSplineSpec keyframesWithSpline(@FloatRange(from=0.0, to=1.0) float periodicBias, kotlin.jvm.functions.Function1,kotlin.Unit> init);
+ method public static androidx.compose.animation.core.KeyframesWithSplineSpec keyframesWithSpline(kotlin.jvm.functions.Function1,kotlin.Unit> init);
+ method @BytecodeOnly @Deprecated @androidx.compose.runtime.Stable public static androidx.compose.animation.core.RepeatableSpec! repeatable(int, androidx.compose.animation.core.DurationBasedAnimationSpec!, androidx.compose.animation.core.RepeatMode!);
+ method @KotlinOnly @androidx.compose.runtime.Stable public static androidx.compose.animation.core.RepeatableSpec repeatable(int iterations, androidx.compose.animation.core.DurationBasedAnimationSpec animation, optional androidx.compose.animation.core.RepeatMode repeatMode, optional androidx.compose.animation.core.StartOffset initialStartOffset);
+ method @BytecodeOnly @Deprecated @androidx.compose.runtime.Stable public static androidx.compose.animation.core.RepeatableSpec! repeatable$default(int, androidx.compose.animation.core.DurationBasedAnimationSpec!, androidx.compose.animation.core.RepeatMode!, int, Object!);
+ method @BytecodeOnly @androidx.compose.runtime.Stable public static androidx.compose.animation.core.RepeatableSpec repeatable-91I0pcU(int, androidx.compose.animation.core.DurationBasedAnimationSpec, androidx.compose.animation.core.RepeatMode, long);
+ method @BytecodeOnly @androidx.compose.runtime.Stable public static androidx.compose.animation.core.RepeatableSpec! repeatable-91I0pcU$default(int, androidx.compose.animation.core.DurationBasedAnimationSpec!, androidx.compose.animation.core.RepeatMode!, long, int, Object!);
+ method @androidx.compose.runtime.Stable public static androidx.compose.animation.core.SnapSpec snap(optional int delayMillis);
+ method @BytecodeOnly @androidx.compose.runtime.Stable public static androidx.compose.animation.core.SnapSpec! snap$default(int, int, Object!);
+ method @androidx.compose.runtime.Stable public static androidx.compose.animation.core.SpringSpec spring(optional float dampingRatio, optional float stiffness, optional T? visibilityThreshold);
+ method @BytecodeOnly @androidx.compose.runtime.Stable public static androidx.compose.animation.core.SpringSpec! spring$default(float, float, Object!, int, Object!);
+ method @androidx.compose.runtime.Stable public static androidx.compose.animation.core.TweenSpec tween(optional int durationMillis, optional int delayMillis, optional androidx.compose.animation.core.Easing easing);
+ method @BytecodeOnly @androidx.compose.runtime.Stable public static androidx.compose.animation.core.TweenSpec! tween$default(int, int, androidx.compose.animation.core.Easing!, int, Object!);
+ }
+
+ public final class AnimationState implements androidx.compose.runtime.State {
+ ctor @BytecodeOnly public AnimationState(androidx.compose.animation.core.TwoWayConverter!, Object!, androidx.compose.animation.core.AnimationVector!, long, long, boolean, int, kotlin.jvm.internal.DefaultConstructorMarker!);
+ ctor public AnimationState(androidx.compose.animation.core.TwoWayConverter typeConverter, T initialValue, optional V? initialVelocityVector, optional long lastFrameTimeNanos, optional long finishedTimeNanos, optional boolean isRunning);
+ method @InaccessibleFromKotlin public long getFinishedTimeNanos();
+ method @InaccessibleFromKotlin public long getLastFrameTimeNanos();
+ method @InaccessibleFromKotlin public androidx.compose.animation.core.TwoWayConverter getTypeConverter();
+ method @InaccessibleFromKotlin public T getValue();
+ method @InaccessibleFromKotlin public T getVelocity();
+ method @InaccessibleFromKotlin public V getVelocityVector();
+ method @InaccessibleFromKotlin public boolean isRunning();
+ property public long finishedTimeNanos;
+ property public boolean isRunning;
+ property public long lastFrameTimeNanos;
+ property public androidx.compose.animation.core.TwoWayConverter typeConverter;
+ property public T value;
+ property public T velocity;
+ property public V velocityVector;
+ }
+
+ public final class AnimationStateKt {
+ method public static androidx.compose.animation.core.AnimationState AnimationState(androidx.compose.animation.core.TwoWayConverter typeConverter, T initialValue, T initialVelocity, optional long lastFrameTimeNanos, optional long finishedTimeNanos, optional boolean isRunning);
+ method public static androidx.compose.animation.core.AnimationState AnimationState(float initialValue, optional float initialVelocity, optional long lastFrameTimeNanos, optional long finishedTimeNanos, optional boolean isRunning);
+ method @BytecodeOnly public static androidx.compose.animation.core.AnimationState! AnimationState$default(androidx.compose.animation.core.TwoWayConverter!, Object!, Object!, long, long, boolean, int, Object!);
+ method @BytecodeOnly public static androidx.compose.animation.core.AnimationState! AnimationState$default(float, float, long, long, boolean, int, Object!);
+ method public static androidx.compose.animation.core.AnimationState copy(androidx.compose.animation.core.AnimationState, optional float value, optional float velocity, optional long lastFrameTimeNanos, optional long finishedTimeNanos, optional boolean isRunning);
+ method public static androidx.compose.animation.core.AnimationState copy(androidx.compose.animation.core.AnimationState, optional T value, optional V? velocityVector, optional long lastFrameTimeNanos, optional long finishedTimeNanos, optional boolean isRunning);
+ method @BytecodeOnly public static androidx.compose.animation.core.AnimationState! copy$default(androidx.compose.animation.core.AnimationState!, float, float, long, long, boolean, int, Object!);
+ method @BytecodeOnly public static androidx.compose.animation.core.AnimationState! copy$default(androidx.compose.animation.core.AnimationState!, Object!, androidx.compose.animation.core.AnimationVector!, long, long, boolean, int, Object!);
+ method public static V createZeroVectorFrom(androidx.compose.animation.core.TwoWayConverter, T value);
+ method @InaccessibleFromKotlin public static boolean isFinished(androidx.compose.animation.core.AnimationState);
+ property public static boolean androidx.compose.animation.core.AnimationState.isFinished;
+ }
+
+ public abstract sealed class AnimationVector {
+ }
+
+ public final class AnimationVector1D extends androidx.compose.animation.core.AnimationVector {
+ ctor public AnimationVector1D(float initVal);
+ method @InaccessibleFromKotlin public float getValue();
+ property public float value;
+ }
+
+ public final class AnimationVector2D extends androidx.compose.animation.core.AnimationVector {
+ ctor public AnimationVector2D(float v1, float v2);
+ method @InaccessibleFromKotlin public float getV1();
+ method @InaccessibleFromKotlin public float getV2();
+ property public float v1;
+ property public float v2;
+ }
+
+ public final class AnimationVector3D extends androidx.compose.animation.core.AnimationVector {
+ ctor public AnimationVector3D(float v1, float v2, float v3);
+ method @InaccessibleFromKotlin public float getV1();
+ method @InaccessibleFromKotlin public float getV2();
+ method @InaccessibleFromKotlin public float getV3();
+ property public float v1;
+ property public float v2;
+ property public float v3;
+ }
+
+ public final class AnimationVector4D extends androidx.compose.animation.core.AnimationVector {
+ ctor public AnimationVector4D(float v1, float v2, float v3, float v4);
+ method @InaccessibleFromKotlin public float getV1();
+ method @InaccessibleFromKotlin public float getV2();
+ method @InaccessibleFromKotlin public float getV3();
+ method @InaccessibleFromKotlin public float getV4();
+ property public float v1;
+ property public float v2;
+ property public float v3;
+ property public float v4;
+ }
+
+ public final class AnimationVectorsKt {
+ method public static androidx.compose.animation.core.AnimationVector1D AnimationVector(float v1);
+ method public static androidx.compose.animation.core.AnimationVector2D AnimationVector(float v1, float v2);
+ method public static androidx.compose.animation.core.AnimationVector3D AnimationVector(float v1, float v2, float v3);
+ method public static androidx.compose.animation.core.AnimationVector4D AnimationVector(float v1, float v2, float v3, float v4);
+ }
+
+ @SuppressCompatibility @androidx.compose.animation.core.ExperimentalAnimationSpecApi @androidx.compose.runtime.Immutable public final class ArcAnimationSpec implements androidx.compose.animation.core.DurationBasedAnimationSpec {
+ ctor public ArcAnimationSpec();
+ ctor @KotlinOnly public ArcAnimationSpec(optional androidx.compose.animation.core.ArcMode mode, optional int durationMillis, optional int delayMillis, optional androidx.compose.animation.core.Easing easing);
+ ctor @BytecodeOnly public ArcAnimationSpec(int, int, int, androidx.compose.animation.core.Easing!, int, kotlin.jvm.internal.DefaultConstructorMarker!);
+ ctor @BytecodeOnly public ArcAnimationSpec(int, int, int, androidx.compose.animation.core.Easing!, kotlin.jvm.internal.DefaultConstructorMarker!);
+ method @InaccessibleFromKotlin public int getDelayMillis();
+ method @InaccessibleFromKotlin public int getDurationMillis();
+ method @InaccessibleFromKotlin public androidx.compose.animation.core.Easing getEasing();
+ method @BytecodeOnly public int getMode--9T-Mq4();
+ method public androidx.compose.animation.core.VectorizedDurationBasedAnimationSpec vectorize(androidx.compose.animation.core.TwoWayConverter converter);
+ property public int delayMillis;
+ property public int durationMillis;
+ property public androidx.compose.animation.core.Easing easing;
+ property public androidx.compose.animation.core.ArcMode mode;
+ }
+
+ @kotlin.jvm.JvmInline public final value class ArcMode {
+ method @BytecodeOnly public static androidx.compose.animation.core.ArcMode! box-impl(int);
+ method @BytecodeOnly public int unbox-impl();
+ field public static final androidx.compose.animation.core.ArcMode.Companion Companion;
+ }
+
+ public static final class ArcMode.Companion {
+ method @BytecodeOnly public int getArcAbove--9T-Mq4();
+ method @BytecodeOnly public int getArcBelow--9T-Mq4();
+ method @BytecodeOnly public int getArcLinear--9T-Mq4();
+ property public androidx.compose.animation.core.ArcMode ArcAbove;
+ property public androidx.compose.animation.core.ArcMode ArcBelow;
+ property public androidx.compose.animation.core.ArcMode ArcLinear;
+ }
+
+ @androidx.compose.runtime.Immutable public final class CubicBezierEasing implements androidx.compose.animation.core.Easing {
+ ctor public CubicBezierEasing(float a, float b, float c, float d);
+ method public float transform(float fraction);
+ }
+
+ public final class DecayAnimation implements androidx.compose.animation.core.Animation {
+ ctor public DecayAnimation(androidx.compose.animation.core.DecayAnimationSpec animationSpec, androidx.compose.animation.core.TwoWayConverter typeConverter, T initialValue, T initialVelocity);
+ ctor public DecayAnimation(androidx.compose.animation.core.DecayAnimationSpec animationSpec, androidx.compose.animation.core.TwoWayConverter typeConverter, T initialValue, V initialVelocityVector);
+ ctor public DecayAnimation(androidx.compose.animation.core.VectorizedDecayAnimationSpec animationSpec, androidx.compose.animation.core.TwoWayConverter typeConverter, T initialValue, V initialVelocityVector);
+ method @InaccessibleFromKotlin public long getDurationNanos();
+ method @InaccessibleFromKotlin public T getInitialValue();
+ method @InaccessibleFromKotlin public V getInitialVelocityVector();
+ method @InaccessibleFromKotlin public T getTargetValue();
+ method @InaccessibleFromKotlin public androidx.compose.animation.core.TwoWayConverter getTypeConverter();
+ method public T getValueFromNanos(long playTimeNanos);
+ method public V getVelocityVectorFromNanos(long playTimeNanos);
+ method @InaccessibleFromKotlin public boolean isInfinite();
+ property public long durationNanos;
+ property public T initialValue;
+ property public V initialVelocityVector;
+ property public boolean isInfinite;
+ property public T targetValue;
+ property public androidx.compose.animation.core.TwoWayConverter typeConverter;
+ }
+
+ public interface DecayAnimationSpec {
+ method public androidx.compose.animation.core.VectorizedDecayAnimationSpec vectorize(androidx.compose.animation.core.TwoWayConverter typeConverter);
+ }
+
+ public final class DecayAnimationSpecKt {
+ method public static float calculateTargetValue(androidx.compose.animation.core.DecayAnimationSpec, float initialValue, float initialVelocity);
+ method public static T calculateTargetValue(androidx.compose.animation.core.DecayAnimationSpec, androidx.compose.animation.core.TwoWayConverter typeConverter, T initialValue, T initialVelocity);
+ method public static androidx.compose.animation.core.DecayAnimationSpec exponentialDecay(optional @FloatRange(from=0.0, fromInclusive=false) float frictionMultiplier, optional @FloatRange(from=0.0, fromInclusive=false) float absVelocityThreshold);
+ method @BytecodeOnly public static androidx.compose.animation.core.DecayAnimationSpec! exponentialDecay$default(float, float, int, Object!);
+ method public static androidx.compose.animation.core.DecayAnimationSpec generateDecayAnimationSpec(androidx.compose.animation.core.FloatDecayAnimationSpec);
+ }
+
+ @SuppressCompatibility @androidx.compose.animation.core.ExperimentalAnimatableApi public final class DeferredTargetAnimation {
+ ctor public DeferredTargetAnimation(androidx.compose.animation.core.TwoWayConverter vectorConverter);
+ method @InaccessibleFromKotlin public T? getPendingTarget();
+ method @InaccessibleFromKotlin public boolean isIdle();
+ method public T updateTarget(T target, kotlinx.coroutines.CoroutineScope coroutineScope, optional androidx.compose.animation.core.FiniteAnimationSpec animationSpec);
+ method @BytecodeOnly public static Object! updateTarget$default(androidx.compose.animation.core.DeferredTargetAnimation!, Object!, kotlinx.coroutines.CoroutineScope!, androidx.compose.animation.core.FiniteAnimationSpec!, int, Object!);
+ property public boolean isIdle;
+ property public T? pendingTarget;
+ }
+
+ public interface DurationBasedAnimationSpec extends androidx.compose.animation.core.FiniteAnimationSpec {
+ method public androidx.compose.animation.core.VectorizedDurationBasedAnimationSpec vectorize(androidx.compose.animation.core.TwoWayConverter converter);
+ }
+
+ @androidx.compose.runtime.Stable public fun interface Easing {
+ method public float transform(float fraction);
+ }
+
+ public final class EasingFunctionsKt {
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEase();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseIn();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseInBack();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseInBounce();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseInCirc();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseInCubic();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseInElastic();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseInExpo();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseInOut();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseInOutBack();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseInOutBounce();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseInOutCirc();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseInOutCubic();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseInOutElastic();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseInOutExpo();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseInOutQuad();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseInOutQuart();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseInOutQuint();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseInOutSine();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseInQuad();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseInQuart();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseInQuint();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseInSine();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseOut();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseOutBack();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseOutBounce();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseOutCirc();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseOutCubic();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseOutElastic();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseOutExpo();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseOutQuad();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseOutQuart();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseOutQuint();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getEaseOutSine();
+ property public static androidx.compose.animation.core.Easing Ease;
+ property public static androidx.compose.animation.core.Easing EaseIn;
+ property public static androidx.compose.animation.core.Easing EaseInBack;
+ property public static androidx.compose.animation.core.Easing EaseInBounce;
+ property public static androidx.compose.animation.core.Easing EaseInCirc;
+ property public static androidx.compose.animation.core.Easing EaseInCubic;
+ property public static androidx.compose.animation.core.Easing EaseInElastic;
+ property public static androidx.compose.animation.core.Easing EaseInExpo;
+ property public static androidx.compose.animation.core.Easing EaseInOut;
+ property public static androidx.compose.animation.core.Easing EaseInOutBack;
+ property public static androidx.compose.animation.core.Easing EaseInOutBounce;
+ property public static androidx.compose.animation.core.Easing EaseInOutCirc;
+ property public static androidx.compose.animation.core.Easing EaseInOutCubic;
+ property public static androidx.compose.animation.core.Easing EaseInOutElastic;
+ property public static androidx.compose.animation.core.Easing EaseInOutExpo;
+ property public static androidx.compose.animation.core.Easing EaseInOutQuad;
+ property public static androidx.compose.animation.core.Easing EaseInOutQuart;
+ property public static androidx.compose.animation.core.Easing EaseInOutQuint;
+ property public static androidx.compose.animation.core.Easing EaseInOutSine;
+ property public static androidx.compose.animation.core.Easing EaseInQuad;
+ property public static androidx.compose.animation.core.Easing EaseInQuart;
+ property public static androidx.compose.animation.core.Easing EaseInQuint;
+ property public static androidx.compose.animation.core.Easing EaseInSine;
+ property public static androidx.compose.animation.core.Easing EaseOut;
+ property public static androidx.compose.animation.core.Easing EaseOutBack;
+ property public static androidx.compose.animation.core.Easing EaseOutBounce;
+ property public static androidx.compose.animation.core.Easing EaseOutCirc;
+ property public static androidx.compose.animation.core.Easing EaseOutCubic;
+ property public static androidx.compose.animation.core.Easing EaseOutElastic;
+ property public static androidx.compose.animation.core.Easing EaseOutExpo;
+ property public static androidx.compose.animation.core.Easing EaseOutQuad;
+ property public static androidx.compose.animation.core.Easing EaseOutQuart;
+ property public static androidx.compose.animation.core.Easing EaseOutQuint;
+ property public static androidx.compose.animation.core.Easing EaseOutSine;
+ }
+
+ public final class EasingKt {
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getFastOutLinearInEasing();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getFastOutSlowInEasing();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getLinearEasing();
+ method @InaccessibleFromKotlin public static androidx.compose.animation.core.Easing getLinearOutSlowInEasing();
+ property public static androidx.compose.animation.core.Easing FastOutLinearInEasing;
+ property public static androidx.compose.animation.core.Easing FastOutSlowInEasing;
+ property public static androidx.compose.animation.core.Easing LinearEasing;
+ property public static androidx.compose.animation.core.Easing LinearOutSlowInEasing;
+ }
+
+ @SuppressCompatibility @kotlin.RequiresOptIn(message="This is an experimental animation API for Transition. It may change in the future.") @kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) public @interface ExperimentalAnimatableApi {
+ }
+
+ @SuppressCompatibility @kotlin.RequiresOptIn(message="This is an experimental animation API for AnimationSpec. It may change in the future.") @kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) public @interface ExperimentalAnimationSpecApi {
+ }
+
+ @SuppressCompatibility @kotlin.RequiresOptIn(message="This is an experimental animation API for Transition. It may change in the future.") @kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) public @interface ExperimentalTransitionApi {
+ }
+
+ public interface FiniteAnimationSpec extends androidx.compose.animation.core.AnimationSpec {
+ method public androidx.compose.animation.core.VectorizedFiniteAnimationSpec vectorize(androidx.compose.animation.core.TwoWayConverter converter);
+ }
+
+ @kotlin.jvm.JvmDefaultWithCompatibility public interface FloatAnimationSpec extends androidx.compose.animation.core.AnimationSpec {
+ method public long getDurationNanos(float initialValue, float targetValue, float initialVelocity);
+ method public default float getEndVelocity(float initialValue, float targetValue, float initialVelocity);
+ method public float getValueFromNanos(long playTimeNanos, float initialValue, float targetValue, float initialVelocity);
+ method public float getVelocityFromNanos(long playTimeNanos, float initialValue, float targetValue, float initialVelocity);
+ method public default androidx.compose.animation.core.VectorizedFloatAnimationSpec vectorize(androidx.compose.animation.core.TwoWayConverter converter);
+ }
+
+ public interface FloatDecayAnimationSpec {
+ method @InaccessibleFromKotlin public float getAbsVelocityThreshold();
+ method public long getDurationNanos(float initialValue, float initialVelocity);
+ method public float getTargetValue(float initialValue, float initialVelocity);
+ method public float getValueFromNanos(long playTimeNanos, float initialValue, float initialVelocity);
+ method public float getVelocityFromNanos(long playTimeNanos, float initialValue, float initialVelocity);
+ property public abstract float absVelocityThreshold;
+ }
+
+ public final class FloatExponentialDecaySpec implements androidx.compose.animation.core.FloatDecayAnimationSpec {
+ ctor public FloatExponentialDecaySpec();
+ ctor public FloatExponentialDecaySpec(optional @FloatRange(from=0.0, fromInclusive=false) float frictionMultiplier, optional @FloatRange(from=0.0, fromInclusive=false) float absVelocityThreshold);
+ ctor @BytecodeOnly public FloatExponentialDecaySpec(float, float, int, kotlin.jvm.internal.DefaultConstructorMarker!);
+ method @InaccessibleFromKotlin public float getAbsVelocityThreshold();
+ method public long getDurationNanos(float initialValue, float initialVelocity);
+ method public float getTargetValue(float initialValue, float initialVelocity);
+ method public float getValueFromNanos(long playTimeNanos, float initialValue, float initialVelocity);
+ method public float getVelocityFromNanos(long playTimeNanos, float initialValue, float initialVelocity);
+ property public float absVelocityThreshold;
+ }
+
+ public final class FloatSpringSpec implements androidx.compose.animation.core.FloatAnimationSpec {
+ ctor public FloatSpringSpec();
+ ctor public FloatSpringSpec(optional float dampingRatio, optional float stiffness, optional float visibilityThreshold);
+ ctor @BytecodeOnly public FloatSpringSpec(float, float, float, int, kotlin.jvm.internal.DefaultConstructorMarker!);
+ method @InaccessibleFromKotlin public float getDampingRatio();
+ method public long getDurationNanos(float initialValue, float targetValue, float initialVelocity);
+ method @InaccessibleFromKotlin public float getStiffness();
+ method public float getValueFromNanos(long playTimeNanos, float initialValue, float targetValue, float initialVelocity);
+ method public float getVelocityFromNanos(long playTimeNanos, float initialValue, float targetValue, float initialVelocity);
+ property public float dampingRatio;
+ property public float stiffness;
+ }
+
+ public final class FloatTweenSpec implements androidx.compose.animation.core.FloatAnimationSpec {
+ ctor public FloatTweenSpec();
+ ctor public FloatTweenSpec(optional int duration, optional int delay, optional androidx.compose.animation.core.Easing easing);
+ ctor @BytecodeOnly public FloatTweenSpec(int, int, androidx.compose.animation.core.Easing!, int, kotlin.jvm.internal.DefaultConstructorMarker!);
+ method @InaccessibleFromKotlin public int getDelay();
+ method @InaccessibleFromKotlin public int getDuration();
+ method public long getDurationNanos(float initialValue, float targetValue, float initialVelocity);
+ method public float getValueFromNanos(long playTimeNanos, float initialValue, float targetValue, float initialVelocity);
+ method public float getVelocityFromNanos(long playTimeNanos, float initialValue, float targetValue, float initialVelocity);
+ property public int delay;
+ property public int duration;
+ }
+
+ public final class InfiniteAnimationPolicyKt {
+ method public static suspend inline Object? withInfiniteAnimationFrameMillis(kotlin.jvm.functions.Function1 onFrame, kotlin.coroutines.Continuation);
+ method public static suspend Object? withInfiniteAnimationFrameNanos(kotlin.jvm.functions.Function1 onFrame, kotlin.coroutines.Continuation);
+ }
+
+ public final class InfiniteRepeatableSpec implements androidx.compose.animation.core.AnimationSpec {
+ ctor @BytecodeOnly @Deprecated public InfiniteRepeatableSpec(androidx.compose.animation.core.DurationBasedAnimationSpec!, androidx.compose.animation.core.RepeatMode!);
+ ctor @BytecodeOnly @Deprecated public InfiniteRepeatableSpec(androidx.compose.animation.core.DurationBasedAnimationSpec!, androidx.compose.animation.core.RepeatMode!, int, kotlin.jvm.internal.DefaultConstructorMarker!);
+ ctor @BytecodeOnly public InfiniteRepeatableSpec(androidx.compose.animation.core.DurationBasedAnimationSpec!, androidx.compose.animation.core.RepeatMode!, long, int, kotlin.jvm.internal.DefaultConstructorMarker!);
+ ctor @BytecodeOnly public InfiniteRepeatableSpec(androidx.compose.animation.core.DurationBasedAnimationSpec!, androidx.compose.animation.core.RepeatMode!, long, kotlin.jvm.internal.DefaultConstructorMarker!);
+ ctor @KotlinOnly public InfiniteRepeatableSpec(androidx.compose.animation.core.DurationBasedAnimationSpec animation, optional androidx.compose.animation.core.RepeatMode repeatMode, optional androidx.compose.animation.core.StartOffset initialStartOffset);
+ method @InaccessibleFromKotlin public androidx.compose.animation.core.DurationBasedAnimationSpec getAnimation();
+ method @BytecodeOnly public long getInitialStartOffset-Rmkjzm4();
+ method @InaccessibleFromKotlin public androidx.compose.animation.core.RepeatMode getRepeatMode();
+ method public androidx.compose.animation.core.VectorizedAnimationSpec vectorize(androidx.compose.animation.core.TwoWayConverter converter);
+ property public androidx.compose.animation.core.DurationBasedAnimationSpec animation;
+ property public androidx.compose.animation.core.StartOffset initialStartOffset;
+ property public androidx.compose.animation.core.RepeatMode repeatMode;
+ }
+
+ public final class InfiniteTransition {
+ method @InaccessibleFromKotlin public java.util.List> getAnimations();
+ method @InaccessibleFromKotlin public String getLabel();
+ property public java.util.List> animations;
+ property public String label;
+ }
+
+ public final class InfiniteTransition.TransitionAnimationState implements androidx.compose.runtime.State {
+ method @InaccessibleFromKotlin public androidx.compose.animation.core.TargetBasedAnimation getAnimation();
+ method @InaccessibleFromKotlin public androidx.compose.animation.core.AnimationSpec getAnimationSpec();
+ method @InaccessibleFromKotlin public String getLabel();
+ method @InaccessibleFromKotlin public androidx.compose.animation.core.TwoWayConverter getTypeConverter();
+ method @InaccessibleFromKotlin public T getValue();
+ property public androidx.compose.animation.core.TargetBasedAnimation animation;
+ property public androidx.compose.animation.core.AnimationSpec animationSpec;
+ property public String label;
+ property public androidx.compose.animation.core.TwoWayConverter typeConverter;
+ property public T value;
+ }
+
+ public final class InfiniteTransitionKt {
+ method @BytecodeOnly @Deprecated @androidx.compose.runtime.Composable public static androidx.compose.runtime.State! animateFloat(androidx.compose.animation.core.InfiniteTransition!, float, float, androidx.compose.animation.core.InfiniteRepeatableSpec!, androidx.compose.runtime.Composer!, int);
+ method @KotlinOnly @androidx.compose.runtime.Composable public static androidx.compose.runtime.State animateFloat(androidx.compose.animation.core.InfiniteTransition, float initialValue, float targetValue, androidx.compose.animation.core.InfiniteRepeatableSpec animationSpec, optional String label);
+ method @BytecodeOnly @androidx.compose.runtime.Composable public static androidx.compose.runtime.State animateFloat(androidx.compose.animation.core.InfiniteTransition, float, float, androidx.compose.animation.core.InfiniteRepeatableSpec, String?, androidx.compose.runtime.Composer?, int, int);
+ method @BytecodeOnly @Deprecated @androidx.compose.runtime.Composable public static androidx.compose.runtime.State! animateValue(androidx.compose.animation.core.InfiniteTransition!, Object!, Object!, androidx.compose.animation.core.TwoWayConverter!, androidx.compose.animation.core.InfiniteRepeatableSpec!, androidx.compose.runtime.Composer!, int);
+ method @KotlinOnly @androidx.compose.runtime.Composable public static androidx.compose.runtime.State animateValue(androidx.compose.animation.core.InfiniteTransition, T initialValue, T targetValue, androidx.compose.animation.core.TwoWayConverter typeConverter, androidx.compose.animation.core.InfiniteRepeatableSpec animationSpec, optional String label);
+ method @BytecodeOnly @androidx.compose.runtime.Composable public static androidx.compose.runtime.State animateValue(androidx.compose.animation.core.InfiniteTransition, T!, T!, androidx.compose.animation.core.TwoWayConverter, androidx.compose.animation.core.InfiniteRepeatableSpec, String?, androidx.compose.runtime.Composer?, int, int);
+ method @BytecodeOnly @Deprecated @androidx.compose.runtime.Composable public static androidx.compose.animation.core.InfiniteTransition! rememberInfiniteTransition(androidx.compose.runtime.Composer!, int);
+ method @KotlinOnly @androidx.compose.runtime.Composable public static androidx.compose.animation.core.InfiniteTransition rememberInfiniteTransition(optional String label);
+ method @BytecodeOnly @androidx.compose.runtime.Composable public static androidx.compose.animation.core.InfiniteTransition rememberInfiniteTransition(String?, androidx.compose.runtime.Composer?, int, int);
+ }
+
+ @SuppressCompatibility @kotlin.RequiresOptIn(message="This API is internal to library.") @kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets={kotlin.annotation.AnnotationTarget.CLASS, kotlin.annotation.AnnotationTarget.FUNCTION, kotlin.annotation.AnnotationTarget.PROPERTY, kotlin.annotation.AnnotationTarget.FIELD, kotlin.annotation.AnnotationTarget.PROPERTY_GETTER}) public @interface InternalAnimationApi {
+ }
+
+ public abstract sealed class KeyframeBaseEntity {
+ }
+
+ @androidx.compose.runtime.Immutable public final class KeyframesSpec implements androidx.compose.animation.core.DurationBasedAnimationSpec {
+ ctor public KeyframesSpec(androidx.compose.animation.core.KeyframesSpec.KeyframesSpecConfig config);
+ method @InaccessibleFromKotlin public androidx.compose.animation.core.KeyframesSpec.KeyframesSpecConfig getConfig();
+ method public androidx.compose.animation.core.VectorizedKeyframesSpec vectorize(androidx.compose.animation.core.TwoWayConverter converter);
+ property public androidx.compose.animation.core.KeyframesSpec.KeyframesSpecConfig config;
+ }
+
+ public static final class KeyframesSpec.KeyframeEntity extends androidx.compose.animation.core.KeyframeBaseEntity {
+ ctor @BytecodeOnly public KeyframesSpec.KeyframeEntity(Object!, androidx.compose.animation.core.Easing!, int, int, kotlin.jvm.internal.DefaultConstructorMarker!);
+ }
+
+ public static final class KeyframesSpec.KeyframesSpecConfig extends androidx.compose.animation.core.KeyframesSpecBaseConfig> {
+ ctor public KeyframesSpec.KeyframesSpecConfig();
+ method public infix androidx.compose.animation.core.KeyframesSpec.KeyframeEntity at(T, @IntRange(from=0L) int timeStamp);
+ method public infix androidx.compose.animation.core.KeyframesSpec.KeyframeEntity atFraction(T, @FloatRange(from=0.0, to=1.0) float fraction);
+ method @KotlinOnly public infix androidx.compose.animation.core.KeyframesSpec.KeyframeEntity using(androidx.compose.animation.core.KeyframesSpec.KeyframeEntity, androidx.compose.animation.core.ArcMode arcMode);
+ method @BytecodeOnly public androidx.compose.animation.core.KeyframesSpec.KeyframeEntity using-ngzHuyU(androidx.compose.animation.core.KeyframesSpec.KeyframeEntity, int);
+ method @Deprecated public infix void with(androidx.compose.animation.core.KeyframesSpec.KeyframeEntity, androidx.compose.animation.core.Easing easing);
+ }
+
+ public abstract sealed class KeyframesSpecBaseConfig> {
+ method public infix E at(T, @IntRange(from=0L) int timeStamp);
+ method public infix E atFraction(T, @FloatRange(from=0.0, to=1.0) float fraction);
+ method @InaccessibleFromKotlin @IntRange(from=0L) public final int getDelayMillis();
+ method @InaccessibleFromKotlin @IntRange(from=0L) public final int getDurationMillis();
+ method @InaccessibleFromKotlin public final void setDelayMillis(@IntRange(from=0L) int);
+ method @InaccessibleFromKotlin public final void setDurationMillis(@IntRange(from=0L) int);
+ method public final infix E using(E, androidx.compose.animation.core.Easing easing);
+ property @IntRange(from=0L) public final int delayMillis;
+ property @IntRange(from=0L) public final int durationMillis;
+ }
+
+ @androidx.compose.runtime.Immutable public final class KeyframesWithSplineSpec implements androidx.compose.animation.core.DurationBasedAnimationSpec {
+ ctor public KeyframesWithSplineSpec(androidx.compose.animation.core.KeyframesWithSplineSpec.KeyframesWithSplineSpecConfig config);
+ ctor public KeyframesWithSplineSpec(androidx.compose.animation.core.KeyframesWithSplineSpec.KeyframesWithSplineSpecConfig config, @FloatRange(from=0.0, to=1.0) float periodicBias);
+ method @InaccessibleFromKotlin public androidx.compose.animation.core.KeyframesWithSplineSpec.KeyframesWithSplineSpecConfig getConfig();
+ method public androidx.compose.animation.core.VectorizedDurationBasedAnimationSpec vectorize(androidx.compose.animation.core.TwoWayConverter converter);
+ property public androidx.compose.animation.core.KeyframesWithSplineSpec.KeyframesWithSplineSpecConfig config;
+ }
+
+ public static final class KeyframesWithSplineSpec.KeyframesWithSplineSpecConfig extends androidx.compose.animation.core.KeyframesSpecBaseConfig> {
+ ctor public KeyframesWithSplineSpec.KeyframesWithSplineSpecConfig();
+ }
+
+ public final class MutableTransitionState extends androidx.compose.animation.core.TransitionState {
+ ctor public MutableTransitionState(S initialState);
+ method @InaccessibleFromKotlin public S getCurrentState();
+ method @InaccessibleFromKotlin public S getTargetState();
+ method @InaccessibleFromKotlin public boolean isIdle();
+ method @InaccessibleFromKotlin public void setTargetState(S);
+ property public S currentState;
+ property public boolean isIdle;
+ property public S targetState;
+ }
+
+ @androidx.compose.runtime.Immutable public final class PathEasing implements androidx.compose.animation.core.Easing {
+ ctor public PathEasing(androidx.compose.ui.graphics.Path path);
+ method public float transform(float fraction);
+ }
+
+ public enum RepeatMode {
+ enum_constant public static final androidx.compose.animation.core.RepeatMode Restart;
+ enum_constant public static final androidx.compose.animation.core.RepeatMode Reverse;
+ }
+
+ @androidx.compose.runtime.Immutable public final class RepeatableSpec implements androidx.compose.animation.core.FiniteAnimationSpec {
+ ctor @BytecodeOnly @Deprecated public RepeatableSpec(int, androidx.compose.animation.core.DurationBasedAnimationSpec!, androidx.compose.animation.core.RepeatMode!);
+ ctor @BytecodeOnly @Deprecated public RepeatableSpec(int, androidx.compose.animation.core.DurationBasedAnimationSpec!, androidx.compose.animation.core.RepeatMode!, int, kotlin.jvm.internal.DefaultConstructorMarker!);
+ ctor @BytecodeOnly public RepeatableSpec(int, androidx.compose.animation.core.DurationBasedAnimationSpec!, androidx.compose.animation.core.RepeatMode!, long, int, kotlin.jvm.internal.DefaultConstructorMarker!);
+ ctor @BytecodeOnly public RepeatableSpec(int, androidx.compose.animation.core.DurationBasedAnimationSpec!, androidx.compose.animation.core.RepeatMode!, long, kotlin.jvm.internal.DefaultConstructorMarker!);
+ ctor @KotlinOnly public RepeatableSpec(int iterations, androidx.compose.animation.core.DurationBasedAnimationSpec animation, optional androidx.compose.animation.core.RepeatMode repeatMode, optional androidx.compose.animation.core.StartOffset initialStartOffset);
+ method @InaccessibleFromKotlin public androidx.compose.animation.core.DurationBasedAnimationSpec getAnimation();
+ method @BytecodeOnly public long getInitialStartOffset-Rmkjzm4();
+ method @InaccessibleFromKotlin public int getIterations();
+ method @InaccessibleFromKotlin public androidx.compose.animation.core.RepeatMode getRepeatMode();
+ method public androidx.compose.animation.core.VectorizedFiniteAnimationSpec vectorize(androidx.compose.animation.core.TwoWayConverter converter);
+ property public androidx.compose.animation.core.DurationBasedAnimationSpec animation;
+ property public androidx.compose.animation.core.StartOffset initialStartOffset;
+ property public int iterations;
+ property public androidx.compose.animation.core.RepeatMode repeatMode;
+ }
+
+ public final class SeekableTransitionState extends androidx.compose.animation.core.TransitionState {
+ ctor public SeekableTransitionState(S initialState);
+ method public suspend Object? animateTo(optional S targetState, optional androidx.compose.animation.core.FiniteAnimationSpec? animationSpec, kotlin.coroutines.Continuation);
+ method @BytecodeOnly public static Object! animateTo$default(androidx.compose.animation.core.SeekableTransitionState!, Object!, androidx.compose.animation.core.FiniteAnimationSpec!, kotlin.coroutines.Continuation!, int, Object!);
+ method @InaccessibleFromKotlin public S getCurrentState();
+ method @InaccessibleFromKotlin @FloatRange(from=0.0, to=1.0) public float getFraction();
+ method @InaccessibleFromKotlin public S getTargetState();
+ method public suspend Object? seekTo(@FloatRange(from=0.0, to=1.0) float fraction, optional S targetState, kotlin.coroutines.Continuation);
+ method @BytecodeOnly public static Object! seekTo$default(androidx.compose.animation.core.SeekableTransitionState!, float, Object!, kotlin.coroutines.Continuation!, int, Object!);
+ method public suspend Object? snapTo(S targetState, kotlin.coroutines.Continuation);
+ property public S currentState;
+ property @FloatRange(from=0.0, to=1.0) public float fraction;
+ property public S targetState;
+ }
+
+ @androidx.compose.runtime.Immutable public final class SnapSpec implements androidx.compose.animation.core.DurationBasedAnimationSpec {
+ ctor public SnapSpec();
+ ctor public SnapSpec(optional int delay);
+ ctor @BytecodeOnly public SnapSpec(int, int, kotlin.jvm.internal.DefaultConstructorMarker!);
+ method @InaccessibleFromKotlin public int getDelay();
+ method public androidx.compose.animation.core.VectorizedDurationBasedAnimationSpec vectorize(androidx.compose.animation.core.TwoWayConverter converter);
+ property public int delay;
+ }
+
+ public final class Spring {
+ property public static float DampingRatioHighBouncy;
+ property public static float DampingRatioLowBouncy;
+ property public static float DampingRatioMediumBouncy;
+ property public static float DampingRatioNoBouncy;
+ property public static float DefaultDisplacementThreshold;
+ property public static float StiffnessHigh;
+ property public static float StiffnessLow;
+ property public static float StiffnessMedium;
+ property public static float StiffnessMediumLow;
+ property public static float StiffnessVeryLow;
+ field public static final float DampingRatioHighBouncy = 0.2f;
+ field public static final float DampingRatioLowBouncy = 0.75f;
+ field public static final float DampingRatioMediumBouncy = 0.5f;
+ field public static final float DampingRatioNoBouncy = 1.0f;
+ field public static final float DefaultDisplacementThreshold = 0.01f;
+ field public static final androidx.compose.animation.core.Spring INSTANCE;
+ field public static final float StiffnessHigh = 10000.0f;
+ field public static final float StiffnessLow = 200.0f;
+ field public static final float StiffnessMedium = 1500.0f;
+ field public static final float StiffnessMediumLow = 400.0f;
+ field public static final float StiffnessVeryLow = 50.0f;
+ }
+
+ @androidx.compose.runtime.Immutable public final class SpringSpec implements androidx.compose.animation.core.FiniteAnimationSpec {
+ ctor public SpringSpec();
+ ctor @BytecodeOnly public SpringSpec(float, float, Object!, int, kotlin.jvm.internal.DefaultConstructorMarker!);
+ ctor public SpringSpec(optional float dampingRatio, optional float stiffness, optional T? visibilityThreshold);
+ method @InaccessibleFromKotlin public float getDampingRatio();
+ method @InaccessibleFromKotlin public float getStiffness();
+ method @InaccessibleFromKotlin public T? getVisibilityThreshold();
+ method public androidx.compose.animation.core.VectorizedSpringSpec vectorize(androidx.compose.animation.core.TwoWayConverter converter);
+ property public float dampingRatio;
+ property public float stiffness;
+ property public T? visibilityThreshold;
+ }
+
+ @kotlin.jvm.JvmInline public final value class StartOffset {
+ ctor @KotlinOnly public StartOffset(int offsetMillis, optional androidx.compose.animation.core.StartOffsetType offsetType);
+ method @BytecodeOnly public static androidx.compose.animation.core.StartOffset! box-impl(long);
+ method @BytecodeOnly public static long constructor-impl(int, int);
+ method @BytecodeOnly public static long constructor-impl$default(int, int, int, kotlin.jvm.internal.DefaultConstructorMarker!);
+ method @BytecodeOnly public static int getOffsetMillis-impl(long);
+ method @BytecodeOnly public static int getOffsetType-Eo1U57Q(long);
+ method @BytecodeOnly public long unbox-impl();
+ property public int offsetMillis;
+ property public androidx.compose.animation.core.StartOffsetType offsetType;
+ }
+
+ @kotlin.jvm.JvmInline public final value class StartOffsetType {
+ method @BytecodeOnly public static androidx.compose.animation.core.StartOffsetType! box-impl(int);
+ method @BytecodeOnly public int unbox-impl();
+ field public static final androidx.compose.animation.core.StartOffsetType.Companion Companion;
+ }
+
+ public static final class StartOffsetType.Companion {
+ method @BytecodeOnly public int getDelay-Eo1U57Q();
+ method @BytecodeOnly public int getFastForward-Eo1U57Q();
+ property public androidx.compose.animation.core.StartOffsetType Delay;
+ property public androidx.compose.animation.core.StartOffsetType FastForward;
+ }
+
+ public final class SuspendAnimationKt {
+ method public static suspend