androidx.animation

AnimatedFloat

fun AnimatedFloat(
    initVal: Float, 
    clock: AnimationClockObservable, 
    visibilityThreshold: Float = Spring.DefaultDisplacementThreshold
): AnimatedFloat

Factory method for creating an AnimatedFloat object, and initialize the value field to initVal.

AnimatedValue

fun <T, V : AnimationVector> AnimatedValue(
    initVal: T, 
    typeConverter: TwoWayConverter<T, V>, 
    clock: AnimationClockObservable, 
    visibilityThreshold: T? = null
): AnimatedValue<T, V>

Factory method for creating an AnimatedValue object, and initialize the value field to initVal.

AnimatedVector

fun <V : AnimationVector> AnimatedVector(
    initVal: V, 
    clock: AnimationClockObservable, 
    visibilityThreshold: V = initVal.newInstanceOfValue(Spring.DefaultDisplacementThreshold)
): AnimatedValue<V, V>

Factory method for creating an AnimatedVector object, and initialize the value field to initVal.

AnimationVector

fun AnimationVector(v1: Float): AnimationVector1D

Factory method to create an AnimationVector1D

AnimationVector

fun AnimationVector(
    v1: Float, 
    v2: Float
): AnimationVector2D

Factory method to create an AnimationVector2D

AnimationVector

fun AnimationVector(
    v1: Float, 
    v2: Float, 
    v3: Float
): AnimationVector3D

Factory method to create an AnimationVector3D

AnimationVector

fun AnimationVector(
    v1: Float, 
    v2: Float, 
    v3: Float, 
    v4: Float
): AnimationVector4D

Factory method to create an AnimationVector4D

TwoWayConverter

fun <T, V : AnimationVector> TwoWayConverter(
    convertToVector: (T) -> V, 
    convertFromVector: (V) -> T
): TwoWayConverter<T, V>

Factory method to create a TwoWayConverter that converts a type T from and to an AnimationVector type.

keyframes

fun <T> keyframes(init: KeyframesSpec.KeyframesSpecConfig<T>.() -> Unit): KeyframesSpec<T>

Creates a KeyframesSpec animation, initialized with init. For example:

import androidx.animation.keyframes
import androidx.ui.unit.Position

// Use FastOutSlowInEasing for the interval from 0 to 50 ms, and LinearOutSlowInEasing for the
// time between 50 and 100ms
keyframes<Position> {
    durationMillis = 200
    Position(0.dp, 0.dp) at 0 with LinearEasing
    Position(500.dp, 100.dp) at 100 with LinearOutSlowInEasing
    Position(400.dp, 50.dp) at 150
}

repeatable

fun <T> repeatable(
    iterations: Int, 
    animation: DurationBasedAnimationSpec<T>, 
    repeatMode: RepeatMode = RepeatMode.Restart
): AnimationSpec<T>

Creates a RepeatableSpec that plays a DurationBasedAnimationSpec (e.g. TweenSpec, KeyframesSpec) the amount of iterations specified by iterations.

The iteration count describes the amount of times the animation will run. 1 means no repeat. Use Infinite to create an infinity repeating animation.

Note: When repeating in the RepeatMode.Reverse mode, it's highly recommended to have an odd number of iterations, or AnimationConstants.Infinite iterations. Otherwise, the animation may jump to the end value when it finishes the last iteration.

snap

fun <T> snap(delayMillis: Int = 0): AnimationSpec<T>

Creates a Snap animation for immediately switching the animating value to the end value.

spring

fun <T> spring(
    dampingRatio: Float = Spring.DampingRatioNoBouncy, 
    stiffness: Float = Spring.StiffnessMedium, 
    visibilityThreshold: T? = null
): SpringSpec<T>

Creates a SpringSpec that uses the given spring constants (i.e. dampingRatio and stiffness. The optional visibilityThreshold defines when the animation should be considered to be visually close enough to round off to its target.

transitionDefinition

fun <T> transitionDefinition(init: TransitionDefinition<T>.() -> Unit): TransitionDefinition<T>

Creates a TransitionDefinition using the init function to initialize it.

tween

fun <T> tween(
    durationMillis: Int = DefaultDurationMillis, 
    delayMillis: Int = 0, 
    easing: Easing = FastOutSlowInEasing
): TweenSpec<T>

Creates a TweenSpec configured with the given duration, delay and easing curve.

FastOutLinearInEasing

val FastOutLinearInEasing: CubicBezierEasing

Elements exiting a screen use acceleration easing, where they start at rest and end at peak velocity.

This is equivalent to the Android FastOutLinearInInterpolator

FastOutSlowInEasing

val FastOutSlowInEasing: CubicBezierEasing

Elements that begin and end at rest use this standard easing. They speed up quickly and slow down gradually, in order to emphasize the end of the transition.

Standard easing puts subtle attention at the end of an animation, by giving more time to deceleration than acceleration. It is the most common form of easing.

This is equivalent to the Android FastOutSlowInInterpolator

FloatToVectorConverter

val FloatToVectorConverter: TwoWayConverter<Float, AnimationVector1D>

A TwoWayConverter that converts Float from and to AnimationVector1D

IntToVectorConverter

val IntToVectorConverter: TwoWayConverter<Int, AnimationVector1D>

A TwoWayConverter that converts Int from and to AnimationVector1D

LinearEasing

val LinearEasing: Easing

It returns fraction unmodified. This is useful as a default value for cases where a Easing is required but no actual easing is desired.

LinearOutSlowInEasing

val LinearOutSlowInEasing: CubicBezierEasing

Incoming elements are animated using deceleration easing, which starts a transition at peak velocity (the fastest point of an element’s movement) and ends at rest.

This is equivalent to the Android LinearOutSlowInInterpolator

createAnimation

fun <T> TransitionDefinition<T>.createAnimation(
    clock: AnimationClockObservable, 
    initState: T? = null
): TransitionAnimation<T>

Creates a transition animation using the transition definition and the given clock.

fling

fun AnimatedFloat.fling(
    startVelocity: Float, 
    decay: FloatDecayAnimationSpec = ExponentialDecay(), 
    onEnd: OnAnimationEnd? = null
): Unit

Starts a fling animation with the specified starting velocity.

fling

fun AnimatedFloat.fling(
    startVelocity: Float, 
    decay: FloatDecayAnimationSpec = ExponentialDecay(), 
    adjustTarget: (Float) -> TargetAnimation?, 
    onEnd: OnAnimationEnd? = null
): Unit

Starts a fling animation with the specified starting velocity.