Revert "MM: MotionValueCollection in MotionDriver, read from gra..." (7d470f2e) · Commits · e / os / android_frameworks_libs_systemui

mechanics/compose/src/com/android/mechanics/compose/modifier/MotionDriver.kt

+163 −29

Original line number	Diff line number	Diff line
		@@ -16,10 +16,12 @@

		package com.android.mechanics.compose.modifier

		import androidx.compose.runtime.derivedStateOf
		import androidx.compose.runtime.getValue
		import androidx.compose.runtime.mutableFloatStateOf
		import androidx.compose.runtime.mutableStateOf
		import androidx.compose.runtime.setValue
		import androidx.compose.runtime.withFrameNanos
		import androidx.compose.ui.Modifier
		import androidx.compose.ui.geometry.Offset
		import androidx.compose.ui.layout.LayoutCoordinates
		@@ -32,15 +34,19 @@ import androidx.compose.ui.node.DelegatableNode
		import androidx.compose.ui.node.LayoutModifierNode
		import androidx.compose.ui.node.ModifierNodeElement
		import androidx.compose.ui.node.TraversableNode
		import androidx.compose.ui.node.currentValueOf
		import androidx.compose.ui.node.findNearestAncestor
		import androidx.compose.ui.platform.InspectorInfo
		import androidx.compose.ui.unit.Constraints
		import androidx.compose.ui.unit.IntOffset
		import androidx.compose.ui.util.fastForEach
		import com.android.mechanics.GestureContext
		import com.android.mechanics.ManagedMotionValue
		import com.android.mechanics.MotionValueCollection
		import com.android.mechanics.MotionValue
		import com.android.mechanics.MotionValue.Companion.StableThresholdEffect
		import com.android.mechanics.compose.modifier.MotionDriver.RequestConstraints
		import com.android.mechanics.debug.LocalMotionValueDebugController
		import com.android.mechanics.spec.MotionSpec
		import kotlinx.coroutines.Dispatchers
		import kotlinx.coroutines.DisposableHandle
		import kotlinx.coroutines.launch

		private const val TRAVERSAL_NODE_KEY = "MotionDriverNode"
		@@ -60,10 +66,13 @@ internal fun DelegatableNode.findMotionDriver(): MotionDriver {
		/**
		* A central interface for driving animations based on layout constraints.
		*
		* A `MotionDriver` is attached to a layout node using the [motionDriver] modifier. Descendant nodes
		* can then find this driver to create animations whose target values are derived from the driver's
		* layout `Constraints`. This allows for coordinated animations within a component tree that react
		* to a parent's size changes, such as expanding or collapsing.
		* A `MotionDriver` is attached to a specific layout node using the [motionDriver] modifier.
		* Descendant nodes can find this driver to create animations whose target values are derived from
		* the driver's layout `Constraints`. It also provides access to the layout's geometry and a shared
		* [GestureContext].
		*
		* This allows for coordinated animations within a component tree that react to changes in a
		* parent's size, such as expanding or collapsing.
		*/
		internal interface MotionDriver {
		/** The [GestureContext] associated with this motion. */
		@@ -94,16 +103,62 @@ internal interface MotionDriver {
		fun Placeable.PlacementScope.driverOffset(): Offset

		/**
		* Creates and registers a [ManagedMotionValue] that animates based on layout constraints.
		* Creates and registers a [AnimatedApproachMeasurement] that animates based on layout
		* constraints.
		*
		* The value will automatically update its output whenever the `MotionDriver`'s `maxHeight`
		* constraint changes.
		* The returned value will automatically update its output whenever the `MotionDriver`'s layout
		* constraints change.
		*
		* @param request Defines how to extract a `Float` input value from the incoming `Constraints`.
		* @param spec A factory for the [MotionSpec] that governs the animation.
		* @param label A string identifier for debugging purposes.
		* @return A [ManagedMotionValue] that provides the animated output.
		* @param stableThreshold The threshold (in pixels) at which the value is considered stable.
		* @return An [AnimatedApproachMeasurement] that provides the animated output.
		*/
		fun animatedApproachMeasurement(
		request: RequestConstraints,
		spec: () -> MotionSpec,
		label: String? = null,
		stableThreshold: Float = StableThresholdEffect,
		debug: Boolean = false,
		): AnimatedApproachMeasurement

		/**
		* A functional interface that defines how to convert layout [Constraints] into a single `Float`
		* value, which serves as the input for a [AnimatedApproachMeasurement].
		*/
		fun interface RequestConstraints {

		/**
		* Extracts a `Float` input from the given [constraints].
		*
		* @param constraints The layout constraints provided during the measurement pass.
		* @return The `Float` value to be used as the animation input.
		*/
		fun constraintsToInput(constraints: Constraints): Float

		/**
		* A predefined [RequestConstraints] implementation that uses the `maxHeight` of the
		* constraints as the input value.
		*/
		object MaxHeight : RequestConstraints {
		override fun constraintsToInput(constraints: Constraints): Float {
		return constraints.maxHeight.toFloat()
		}
		}
		}

		/**
		* Represents a value that is derived from layout constraints and animated by a [MotionSpec].
		*
		* This value is state-backed and can be read in composition or snapshot-aware contexts to
		* trigger recomposition or other effects when it changes.
		*/
		fun maxHeightDriven(spec: () -> MotionSpec, label: String? = null): ManagedMotionValue
		interface AnimatedApproachMeasurement : DisposableHandle {
		val inProgress: Boolean

		val value: Float
		}
		}

		/**
		@@ -121,11 +176,10 @@ fun Modifier.motionDriver(gestureContext: GestureContext, label: String? = null)

		private data class MotionDriverElement(val gestureContext: GestureContext, val label: String?) :
		ModifierNodeElement<MotionDriverNode>() {
		override fun create(): MotionDriverNode =
		MotionDriverNode(gestureContext = gestureContext, label = label)
		override fun create(): MotionDriverNode = MotionDriverNode(gestureContext = gestureContext)

		override fun update(node: MotionDriverNode) {
		check(node.gestureContext == gestureContext) { "Cannot change the gestureContext" }
		node.update(gestureContext = gestureContext)
		}

		override fun InspectorInfo.inspectableProperties() {
		@@ -134,31 +188,26 @@ private data class MotionDriverElement(val gestureContext: GestureContext, val l
		}
		}

		private class MotionDriverNode(override val gestureContext: GestureContext, label: String?) :
		private class MotionDriverNode(override var gestureContext: GestureContext) :
		Modifier.Node(),
		TraversableNode,
		LayoutModifierNode,
		MotionDriver,
		CompositionLocalConsumerModifierNode {
		override val traverseKey: Any = TRAVERSAL_NODE_KEY
		override var verticalState: MotionDriver.State by mutableStateOf(MotionDriver.State.MinValue)

		private val animatedValues = mutableListOf<AnimatedApproachMeasurementImpl>()
		private var driverCoordinates: LayoutCoordinates? = null
		private var lookAheadHeight: Int = 0
		private var input by mutableFloatStateOf(0f)
		private val motionValues = MotionValueCollection(::input, gestureContext, label = label)

		override fun onAttach() {
		coroutineScope.launch(Dispatchers.Main.immediate) { motionValues.keepRunning() }
		}
		override val traverseKey: Any = TRAVERSAL_NODE_KEY
		override var verticalState: MotionDriver.State by mutableStateOf(MotionDriver.State.MinValue)

		override fun maxHeightDriven(spec: () -> MotionSpec, label: String?): ManagedMotionValue {
		return motionValues.create(spec, label)
		fun update(gestureContext: GestureContext) {
		this.gestureContext = gestureContext
		}

		override fun Placeable.PlacementScope.driverOffset(): Offset {
		val driverCoordinates = requireNotNull(driverCoordinates) { "No driver coordinates" }
		val childCoordinates = requireNotNull(coordinates) { "No child coordinates" }
		val driverCoordinates = requireNotNull(driverCoordinates) { "" }
		val childCoordinates = requireNotNull(coordinates) { "" }
		return driverCoordinates.localPositionOf(childCoordinates)
		}

		@@ -180,7 +229,7 @@ private class MotionDriverNode(override val gestureContext: GestureContext, labe
		else -> MotionDriver.State.Transition
		}

		input = constraints.maxHeight.toFloat()
		animatedValues.fastForEach { it.updateInput(constraints) }
		}

		return layout(width = placeable.width, height = placeable.height) {
		@@ -188,4 +237,89 @@ private class MotionDriverNode(override val gestureContext: GestureContext, labe
		placeable.place(IntOffset.Zero)
		}
		}

		override fun animatedApproachMeasurement(
		request: RequestConstraints,
		spec: () -> MotionSpec,
		label: String?,
		stableThreshold: Float,
		debug: Boolean,
		): MotionDriver.AnimatedApproachMeasurement {
		val animatedApproachMeasurement =
		AnimatedApproachMeasurementImpl(
		request = request,
		gestureContext = gestureContext,
		spec = spec,
		label = label,
		stableThreshold = stableThreshold,
		onDispose = { animatedValues -= this },
		)
		animatedValues += animatedApproachMeasurement

		val debugController = if (debug) currentValueOf(LocalMotionValueDebugController) else null
		coroutineScope.launch {
		val disposableHandle =
		debugController?.register(animatedApproachMeasurement.motionValue)
		try {
		animatedApproachMeasurement.keepRunningWhileObserved()
		} finally {
		disposableHandle?.dispose()
		}
		}

		coroutineScope.launch {
		while (animatedApproachMeasurement.isObserved) {
		withFrameNanos { animatedApproachMeasurement.computeOutput() }
		}
		}

		return animatedApproachMeasurement
		}

		private class AnimatedApproachMeasurementImpl(
		private val request: RequestConstraints,
		gestureContext: GestureContext,
		spec: () -> MotionSpec,
		label: String?,
		stableThreshold: Float,
		private val onDispose: AnimatedApproachMeasurementImpl.() -> Unit,
		) : MotionDriver.AnimatedApproachMeasurement {
		var isObserved = true
		private var lastInput: Float? = null

		val motionValue: MotionValue =
		MotionValue(
		input = { lastInput ?: 0f },
		gestureContext = gestureContext,
		spec = derivedStateOf(spec)::value,
		label = label,
		stableThreshold = stableThreshold,
		)

		override var inProgress: Boolean by mutableStateOf(false)

		override var value: Float by mutableFloatStateOf(motionValue.output)

		fun updateInput(input: Constraints): Boolean {
		val newInput = request.constraintsToInput(input)
		val isNew = lastInput != newInput
		if (isNew) lastInput = newInput
		return isNew
		}

		fun computeOutput() {
		val currentOutput = motionValue.output
		if (currentOutput.isFinite()) {
		inProgress = value != currentOutput
		value = currentOutput
		}
		}

		override fun dispose() {
		isObserved = false
		onDispose()
		}

		suspend fun keepRunningWhileObserved() = motionValue.keepRunningWhile { isObserved }
		}
		}

mechanics/compose/src/com/android/mechanics/compose/modifier/VerticalFadeContentRevealModifier.kt

+32 −34

Original line number	Diff line number	Diff line
		@@ -34,8 +34,6 @@ import androidx.compose.ui.unit.Constraints
		import androidx.compose.ui.unit.IntOffset
		import androidx.compose.ui.unit.IntSize
		import androidx.compose.ui.util.fastCoerceAtLeast
		import com.android.mechanics.ManagedMotionValue
		import com.android.mechanics.debug.DebugMotionValueNode
		import com.android.mechanics.effects.FixedValue
		import com.android.mechanics.spec.Mapping
		import com.android.mechanics.spec.MotionSpec
		@@ -53,24 +51,28 @@ fun Modifier.verticalFadeContentReveal(
		motionBuilderContext: MotionBuilderContext,
		deltaY: Float = 0f,
		label: String? = null,
		debug: Boolean = false,
		): Modifier =
		this then
		FadeContentRevealElement(
		motionBuilderContext = motionBuilderContext,
		deltaY = deltaY,
		label = label,
		debug = debug,
		)

		private data class FadeContentRevealElement(
		val motionBuilderContext: MotionBuilderContext,
		val deltaY: Float,
		val label: String?,
		val debug: Boolean,
		) : ModifierNodeElement<FadeContentRevealNode>() {
		override fun create(): FadeContentRevealNode =
		FadeContentRevealNode(
		motionBuilderContext = motionBuilderContext,
		deltaY = deltaY,
		label = label,
		debug = debug,
		)

		override fun update(node: FadeContentRevealNode) {
		@@ -81,6 +83,7 @@ private data class FadeContentRevealElement(
		name = "fadeContentReveal"
		properties["deltaY"] = deltaY
		properties["label"] = label
		properties["debug"] = debug
		}
		}

		@@ -88,14 +91,14 @@ private class FadeContentRevealNode(
		private var motionBuilderContext: MotionBuilderContext,
		deltaY: Float,
		private val label: String?,
		private val debug: Boolean,
		) : DelegatingNode(), ApproachLayoutModifierNode {
		private var lookAheadHeight by mutableFloatStateOf(Float.NaN)
		private var lookAheadHeight by mutableFloatStateOf(0f)
		private var layoutOffsetY by mutableFloatStateOf(0f)
		private var deltaY: Float by mutableFloatStateOf(deltaY)

		private lateinit var animatedApproachMeasurement: MotionDriver.AnimatedApproachMeasurement
		private lateinit var motionDriver: MotionDriver
		// Created after the first lookahead measure, guaranteed to be created before first measure
		private var revealAlpha: ManagedMotionValue? = null

		fun update(motionBuilderContext: MotionBuilderContext, deltaY: Float) {
		this.motionBuilderContext = motionBuilderContext
		@@ -104,13 +107,25 @@ private class FadeContentRevealNode(

		override fun onAttach() {
		motionDriver = findMotionDriver()
		animatedApproachMeasurement =
		motionDriver.animatedApproachMeasurement(
		request = MotionDriver.RequestConstraints.MaxHeight,
		spec = derivedStateOf(::spec)::value,
		label = "FadeContentReveal(${label.orEmpty()})",
		debug = debug,
		)
		}

		override fun onDetach() {
		revealAlpha?.dispose()
		animatedApproachMeasurement.dispose()
		}

		private fun spec(): MotionSpec {
		if (lookAheadHeight == 0f) {
		// We cannot compute specs for height 0.
		return motionBuilderContext.fixedEffectsValueSpec(0f)
		}

		return when (motionDriver.verticalState) {
		MotionDriver.State.MinValue -> {
		motionBuilderContext.fixedEffectsValueSpec(0f)
		@@ -129,40 +144,21 @@ private class FadeContentRevealNode(
		override fun MeasureScope.measure(
		measurable: Measurable,
		constraints: Constraints,
		): MeasureResult {
		return if (isLookingAhead) {
		lookAheadMeasure(measurable, constraints)
		} else {
		measurable.measure(constraints).run { layout(width, height) { place(IntOffset.Zero) } }
		}
		}

		private fun MeasureScope.lookAheadMeasure(
		measurable: Measurable,
		constraints: Constraints,
		): MeasureResult {
		val placeable = measurable.measure(constraints)
		val targetHeight = placeable.height.toFloat()
		lookAheadHeight = targetHeight
		if (revealAlpha == null) {
		val maxHeightDriven =
		motionDriver.maxHeightDriven(
		spec = derivedStateOf(::spec)::value,
		label = "FadeContentReveal(${label.orEmpty()})",
		)
		revealAlpha = maxHeightDriven
		delegate(DebugMotionValueNode(maxHeightDriven))
		if (isLookingAhead) {
		lookAheadHeight = placeable.height.toFloat()
		}
		return layout(placeable.width, placeable.height) {
		if (isLookingAhead) {
		layoutOffsetY = with(motionDriver) { driverOffset() }.y
		}
		placeable.place(IntOffset.Zero)
		}
		}

		override fun isMeasurementApproachInProgress(lookaheadSize: IntSize): Boolean {
		val revealAlpha = revealAlpha
		return revealAlpha != null &&
		(motionDriver.verticalState == MotionDriver.State.Transition \|\| !revealAlpha.isStable)
		return animatedApproachMeasurement.inProgress
		}

		override fun ApproachMeasureScope.approachMeasure(
		@@ -171,12 +167,14 @@ private class FadeContentRevealNode(
		): MeasureResult {
		return measurable.measure(constraints).run {
		layout(width, height) {
		placeWithLayer(IntOffset.Zero) {
		val revealAlpha = checkNotNull(revealAlpha).output.fastCoerceAtLeast(0f)
		val revealAlpha = animatedApproachMeasurement.value.fastCoerceAtLeast(0f)
		if (revealAlpha < 1f) {
		placeWithLayer(IntOffset.Zero) {
		alpha = revealAlpha
		compositingStrategy = CompositingStrategy.ModulateAlpha
		}
		} else {
		place(IntOffset.Zero)
		}
		}
		}

mechanics/compose/src/com/android/mechanics/compose/modifier/VerticalTactileSurfaceRevealModifier.kt

+38 −71

Original line number	Diff line number	Diff line
		@@ -16,19 +16,12 @@

		package com.android.mechanics.compose.modifier

		import androidx.compose.foundation.shape.GenericShape
		import androidx.compose.runtime.derivedStateOf
		import androidx.compose.runtime.getValue
		import androidx.compose.runtime.mutableFloatStateOf
		import androidx.compose.runtime.setValue
		import androidx.compose.ui.Modifier
		import androidx.compose.ui.geometry.CornerRadius
		import androidx.compose.ui.geometry.Offset
		import androidx.compose.ui.geometry.Rect
		import androidx.compose.ui.geometry.RoundRect
		import androidx.compose.ui.geometry.Size
		import androidx.compose.ui.graphics.CompositingStrategy
		import androidx.compose.ui.graphics.GraphicsLayerScope
		import androidx.compose.ui.layout.ApproachLayoutModifierNode
		import androidx.compose.ui.layout.ApproachMeasureScope
		import androidx.compose.ui.layout.Measurable
		@@ -42,9 +35,6 @@ import androidx.compose.ui.unit.IntOffset
		import androidx.compose.ui.unit.IntSize
		import androidx.compose.ui.unit.constrainHeight
		import androidx.compose.ui.util.fastCoerceAtLeast
		import androidx.compose.ui.util.fastCoerceAtMost
		import com.android.mechanics.ManagedMotionValue
		import com.android.mechanics.debug.DebugMotionValueNode
		import com.android.mechanics.effects.RevealOnThreshold
		import com.android.mechanics.spec.Mapping
		import com.android.mechanics.spec.MotionSpec
		@@ -65,6 +55,7 @@ fun Modifier.verticalTactileSurfaceReveal(
		deltaY: Float = 0f,
		revealOnThreshold: RevealOnThreshold = DefaultRevealOnThreshold,
		label: String? = null,
		debug: Boolean = false,
		): Modifier =
		this then
		VerticalTactileSurfaceRevealElement(
		@@ -72,6 +63,7 @@ fun Modifier.verticalTactileSurfaceReveal(
		deltaY = deltaY,
		revealOnThreshold = revealOnThreshold,
		label = label,
		debug = debug,
		)

		private val DefaultRevealOnThreshold = RevealOnThreshold()
		@@ -81,6 +73,7 @@ private data class VerticalTactileSurfaceRevealElement(
		val deltaY: Float,
		val revealOnThreshold: RevealOnThreshold,
		val label: String?,
		val debug: Boolean,
		) : ModifierNodeElement<VerticalTactileSurfaceRevealNode>() {
		override fun create(): VerticalTactileSurfaceRevealNode =
		VerticalTactileSurfaceRevealNode(
		@@ -88,6 +81,7 @@ private data class VerticalTactileSurfaceRevealElement(
		deltaY = deltaY,
		revealOnThreshold = revealOnThreshold,
		label = label,
		debug = debug,
		)

		override fun update(node: VerticalTactileSurfaceRevealNode) {
		@@ -103,6 +97,7 @@ private data class VerticalTactileSurfaceRevealElement(
		properties["deltaY"] = deltaY
		properties["revealOnThreshold"] = revealOnThreshold
		properties["label"] = label
		properties["debug"] = debug
		}
		}

		@@ -111,14 +106,14 @@ private class VerticalTactileSurfaceRevealNode(
		deltaY: Float,
		private var revealOnThreshold: RevealOnThreshold,
		private val label: String?,
		private val debug: Boolean,
		) : DelegatingNode(), ApproachLayoutModifierNode {
		private var lookAheadHeight by mutableFloatStateOf(Float.NaN)
		private var lookAheadHeight by mutableFloatStateOf(0f)
		private var layoutOffsetY by mutableFloatStateOf(0f)
		private var deltaY: Float by mutableFloatStateOf(deltaY)

		private lateinit var animatedApproachMeasurement: MotionDriver.AnimatedApproachMeasurement
		private lateinit var motionDriver: MotionDriver
		// Created after the first lookahead measure, guaranteed to be created before first measure
		private var revealHeight: ManagedMotionValue? = null

		fun update(
		motionBuilderContext: MotionBuilderContext,
		@@ -132,13 +127,25 @@ private class VerticalTactileSurfaceRevealNode(

		override fun onAttach() {
		motionDriver = findMotionDriver()
		animatedApproachMeasurement =
		motionDriver.animatedApproachMeasurement(
		request = MotionDriver.RequestConstraints.MaxHeight,
		spec = derivedStateOf(::spec)::value,
		label = "TactileSurfaceReveal(${label.orEmpty()})",
		debug = debug,
		)
		}

		override fun onDetach() {
		revealHeight?.dispose()
		animatedApproachMeasurement.dispose()
		}

		private fun spec(): MotionSpec {
		if (lookAheadHeight == 0f) {
		// We cannot compute specs for height 0.
		return motionBuilderContext.fixedSpatialValueSpec(0f)
		}

		return when (motionDriver.verticalState) {
		MotionDriver.State.MinValue -> {
		motionBuilderContext.fixedSpatialValueSpec(0f)
		@@ -161,81 +168,41 @@ private class VerticalTactileSurfaceRevealNode(
		override fun MeasureScope.measure(
		measurable: Measurable,
		constraints: Constraints,
		): MeasureResult {
		return if (isLookingAhead) {
		lookAheadMeasure(measurable, constraints)
		} else {
		measurable.measure(constraints).run { layout(width, height) { place(IntOffset.Zero) } }
		}
		}

		private fun MeasureScope.lookAheadMeasure(
		measurable: Measurable,
		constraints: Constraints,
		): MeasureResult {
		val placeable = measurable.measure(constraints)
		val targetHeight = placeable.height.toFloat()
		lookAheadHeight = targetHeight
		if (revealHeight == null) {
		val maxHeightDriven =
		motionDriver.maxHeightDriven(
		spec = derivedStateOf(::spec)::value,
		label = "TactileSurfaceReveal(${label.orEmpty()})",
		)
		revealHeight = maxHeightDriven
		delegate(DebugMotionValueNode(maxHeightDriven))
		if (isLookingAhead) {
		lookAheadHeight = placeable.height.toFloat()
		}
		return layout(placeable.width, placeable.height) {
		if (isLookingAhead) {
		layoutOffsetY = with(motionDriver) { driverOffset() }.y
		}
		placeable.place(IntOffset.Zero)
		}
		}

		override fun isMeasurementApproachInProgress(lookaheadSize: IntSize): Boolean {
		val revealHeight = revealHeight
		return revealHeight != null &&
		(motionDriver.verticalState == MotionDriver.State.Transition \|\| !revealHeight.isStable)
		return animatedApproachMeasurement.inProgress
		}

		override fun ApproachMeasureScope.approachMeasure(
		measurable: Measurable,
		constraints: Constraints,
		): MeasureResult {
		return measurable.measure(constraints).run {
		val height = constraints.constrainHeight(animatedApproachMeasurement.value.roundToInt())
		val animatedConstraints = constraints.copy(maxHeight = height)

		return measurable.measure(animatedConstraints).run {
		layout(width, height) {
		val revealAlpha = (height / revealOnThreshold.minSize.toPx()).fastCoerceAtLeast(0f)
		if (revealAlpha < 1f) {
		placeWithLayer(IntOffset.Zero) {
		val revealHeight =
		constraints
		.constrainHeight(checkNotNull(revealHeight).output.roundToInt())
		.toFloat()

		if (revealHeight != lookAheadHeight) {
		approachGraphicsLayer(revealHeight)
		}
		}
		}
		}
		alpha = revealAlpha
		compositingStrategy = CompositingStrategy.ModulateAlpha
		}

		private fun GraphicsLayerScope.approachGraphicsLayer(revealHeight: Float) {
		translationY = (revealHeight - lookAheadHeight) / 2f
		clip = true
		shape = GenericShape { placeableSize, _ ->
		val rect = Rect(Offset(0f, -translationY), Size(placeableSize.width, revealHeight))
		val cornerMaxSize = revealOnThreshold.cornerMaxSize.toPx()
		if (cornerMaxSize != 0f) {
		val radius = (revealHeight / 2f).fastCoerceAtMost(cornerMaxSize)
		addRoundRect(RoundRect(rect, CornerRadius(radius)))
		} else {
		addRect(rect)
		}
		place(IntOffset.Zero)
		}
		val fullyVisibleMinHeight = revealOnThreshold.minSize.toPx()
		if (fullyVisibleMinHeight != 0f) {
		val revealAlpha = (revealHeight / fullyVisibleMinHeight).fastCoerceAtLeast(0f)
		if (revealAlpha < 1f) {
		alpha = revealAlpha
		compositingStrategy = CompositingStrategy.ModulateAlpha
		}
		}
		}

mechanics/src/com/android/mechanics/MotionValueCollection.kt

+10 −65

File changed.

Preview size limit exceeded, changes collapsed.

mechanics/src/com/android/mechanics/effects/RevealOnThreshold.kt

+1 −6

Original line number	Diff line number	Diff line
		@@ -26,13 +26,9 @@ import com.android.mechanics.spec.builder.EffectApplyScope
		import com.android.mechanics.spec.builder.EffectPlacement

		/** An effect that reveals a component when the available space reaches a certain threshold. */
		data class RevealOnThreshold(
		val minSize: Dp = Defaults.MinSize,
		val cornerMaxSize: Dp = Defaults.CornerMaxSize,
		) : Effect.PlaceableBetween {
		data class RevealOnThreshold(val minSize: Dp = Defaults.MinSize) : Effect.PlaceableBetween {
		init {
		require(minSize >= 0.dp)
		require(cornerMaxSize >= 0.dp)
		}

		override fun EffectApplyScope.createSpec(
		@@ -56,6 +52,5 @@ data class RevealOnThreshold(

		object Defaults {
		val MinSize: Dp = 8.dp
		val CornerMaxSize: Dp = 32.dp
		}
		}