AnimationResult

public class AnimationResult<T, V : AnimationVector>(
    /**
     * The state of the animation in its last frame before it's canceled or reset. This captures the
     * animation value/velocity/frame time, etc at the point of interruption, or before the velocity
     * is reset when the animation finishes successfully.
     */
    public val endState: AnimationState<T, V>,
    /**
     * The reason why the animation has ended. Could be either of the following:
     * - [Finished], when the animation finishes successfully without any interruption
     * - [BoundReached] If the animation reaches the either [lowerBound][Animatable.lowerBound] or
     *   [upperBound][Animatable.upperBound] in any dimension, the animation will end with
     *   [BoundReached] being the end reason.
     */
    public val endReason: AnimationEndReason,
)

AnimationResult contains information about an animation at the end of the animation. endState captures the value/velocity/frame time, etc of the animation at its last frame. It can be useful for starting another animation to continue the velocity from the previously interrupted animation. endReason describes why the animation ended, it could be either of the following:

• Finished, when the animation finishes successfully without any interruption
• BoundReached If the animation reaches the either lowerBound or upperBound in any dimension, the animation will end with BoundReached being the end reason.

Code Examples

AnimatableAnimationResultSample

fun AnimatableAnimationResultSample() {
    suspend fun CoroutineScope.animateBouncingOffBounds(
        animatable: Animatable<Offset, *>,
        flingVelocity: Offset,
        parentSize: Size,
    ) {
        launch {
            var startVelocity = flingVelocity
            // Set bounds for the animation, so that when it reaches bounds it will stop
            // immediately. We can then inspect the returned `AnimationResult` and decide whether
            // we should start another animation.
            animatable.updateBounds(Offset(0f, 0f), Offset(parentSize.width, parentSize.height))
            do {
                val result = animatable.animateDecay(startVelocity, exponentialDecay())
                // Copy out the end velocity of the previous animation.
                startVelocity = result.endState.velocity
                // Negate the velocity for the dimension that hits the bounds, to create a
                // bouncing off the bounds effect.
                with(animatable) {
                    if (value.x == upperBound?.x || value.x == lowerBound?.x) {
                        // x dimension hits bounds
                        startVelocity = startVelocity.copy(x = -startVelocity.x)
                    }
                    if (value.y == upperBound?.y || value.y == lowerBound?.y) {
                        // y dimension hits bounds
                        startVelocity = startVelocity.copy(y = -startVelocity.y)
                    }
                }
                // Repeat the animation until the animation ends for reasons other than hitting
                // bounds, e.g. if `stop()` is called, or preempted by another animation.
            } while (result.endReason == AnimationEndReason.BoundReached)
        }
    }
}