DynamicAnimation

const val ALPHA: DynamicAnimation.ViewProperty!

View's alpha property.

const val MIN_VISIBLE_CHANGE_ALPHA = 0.00390625f: Float

The minimum visible change in alpha that can be visible to users.

const val MIN_VISIBLE_CHANGE_PIXELS = 1.0f: Float

The minimum visible change in pixels that can be visible to users.

const val MIN_VISIBLE_CHANGE_ROTATION_DEGREES = 0.1f: Float

The minimum visible change in degrees that can be visible to users.

const val MIN_VISIBLE_CHANGE_SCALE = 0.002f: Float

The minimum visible change in scale that can be visible to users.

const val ROTATION: DynamicAnimation.ViewProperty!

View's rotation property.

const val ROTATION_X: DynamicAnimation.ViewProperty!

View's rotationX property.

const val ROTATION_Y: DynamicAnimation.ViewProperty!

View's rotationY property.

const val SCALE_X: DynamicAnimation.ViewProperty!

View's scaleX property.

const val SCALE_Y: DynamicAnimation.ViewProperty!

View's scaleY property.

const val SCROLL_X: DynamicAnimation.ViewProperty!

View's scrollX property.

const val SCROLL_Y: DynamicAnimation.ViewProperty!

View's scrollY property.

const val TRANSLATION_X: DynamicAnimation.ViewProperty!

View's translationX property.

const val TRANSLATION_Y: DynamicAnimation.ViewProperty!

View's translationY property.

const val TRANSLATION_Z: DynamicAnimation.ViewProperty!

View's translationZ property.

const val X: DynamicAnimation.ViewProperty!

View's x property.

const val Y: DynamicAnimation.ViewProperty!

View's y property.

const val Z: DynamicAnimation.ViewProperty!

View's z property.

fun addEndListener(listener: DynamicAnimation.OnAnimationEndListener!): T!

Adds an end listener to the animation for receiving onAnimationEnd callbacks. If the listener is null or has already been added to the list of listeners for the animation, no op.

fun addUpdateListener(listener: DynamicAnimation.OnAnimationUpdateListener!): T!

Adds an update listener to the animation for receiving per-frame animation update callbacks. If the listener is null or has already been added to the list of listeners for the animation, no op.

Note that update listener should only be added before the start of the animation.

@MainThread
fun cancel(): Unit

Cancels the on-going animation. If the animation hasn't started, no op. Unless a AnimationHandler is provided via setAnimationHandler, a default AnimationHandler is created on the same thread as the first call to start/cancel an animation. All the subsequent animation lifecycle manipulations need to be on that same thread, until the AnimationHandler is reset (using [setAnimationHandler]).

@VisibleForTesting
fun getAnimationHandler(): AnimationHandler

Returns the AnimationHandler used to schedule updates for this animator.

fun getMinimumVisibleChange(): Float

Returns the minimum change in the animation property that could be visibly different to users.

fun getScheduler(): FrameCallbackScheduler

Returns the FrameCallbackScheduler used to schedule updates for this animator. If not already set using setScheduler, this is initialized to an FrameCallbackScheduler that uses the caller thread's Choreographer. Otherwise, return the scheduler set via the previous setScheduler call.

fun isRunning(): Boolean

Returns whether the animation is currently running.

fun removeEndListener(listener: DynamicAnimation.OnAnimationEndListener!): Unit

Removes the end listener from the animation, so as to stop receiving animation end callbacks.

fun removeUpdateListener(
    listener: DynamicAnimation.OnAnimationUpdateListener!
): Unit

Removes the update listener from the animation, so as to stop receiving animation update callbacks.

fun setMaxValue(max: Float): T!

Sets the max value of the animation. Animations will not animate beyond their max value. Whether or not animation will come to an end when max value is reached is dependent on the child animation's implementation.

fun setMinValue(min: Float): T!

Sets the min value of the animation. Animations will not animate beyond their min value. Whether or not animation will come to an end when min value is reached is dependent on the child animation's implementation.

fun setMinimumVisibleChange(
    minimumVisibleChange: @FloatRange(from = 0.0, fromInclusive = false) Float
): T!

This method sets the minimal change of animation value that is visible to users, which helps determine a reasonable threshold for the animation's termination condition. It is critical to set the minimal visible change for custom properties (i.e. non-ViewPropertys) unless the custom property is in pixels.

For custom properties, this minimum visible change defaults to change in pixel (i.e. MIN_VISIBLE_CHANGE_PIXELS. It is recommended to adjust this value that is reasonable for the property to be animated. A general rule of thumb to calculate such a value is: minimum visible change = range of custom property value / corresponding pixel range. For example, if the property to be animated is a progress (from 0 to 100) that corresponds to a 200-pixel change. Then the min visible change should be 100 / 200. (i.e. 0.5).

It's not necessary to call this method when animating ViewPropertys, as the minimum visible change will be derived from the property. For example, if the property to be animated is in pixels (i.e. TRANSLATION_X, TRANSLATION_Y, TRANSLATION_Z, @SCROLL_X or SCROLL_Y), the default minimum visible change is 1 (pixel). For ROTATION, ROTATION_X or ROTATION_Y, the animation will use MIN_VISIBLE_CHANGE_ROTATION_DEGREES as the min visible change, which is 1/10. Similarly, the minimum visible change for alpha ( i.e. MIN_VISIBLE_CHANGE_ALPHA is defined as 1 / 256.

fun setScheduler(scheduler: FrameCallbackScheduler): Unit

Sets the frame scheduler used to schedule updates for this animator. Note this should be called before animation running, as it would lead to discontinuity in animations.

fun setStartValue(startValue: Float): T!

Sets the start value of the animation. If start value is not set, the animation will get the current value for the view's property, and use that as the start value.

fun setStartVelocity(startVelocity: Float): T!

Start velocity of the animation. Default velocity is 0. Unit: change in property per second (e.g. pixels per second, scale/alpha value change per second).

Note when using a fixed value as the start velocity (as opposed to getting the velocity through touch events), it is recommended to define such a value in dp/second and convert it to pixel/second based on the density of the screen to achieve a consistent look across different screens.

To convert from dp/second to pixel/second:

float pixelPerSecond = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dpPerSecond,
        getResources().getDisplayMetrics());

@MainThread
fun start(): Unit

Starts an animation. If the animation has already been started, no op. Note that calling start will not immediately set the property value to start value of the animation. The property values will be changed at each animation pulse, which happens before the draw pass. As a result, the changes will be reflected in the next frame, the same as if the values were set immediately. This method should only be called on main thread. Unless a AnimationHandler is provided via setAnimationHandler, a default AnimationHandler is created on the same thread as the first call to start/cancel an animation. All the subsequent animation lifecycle manipulations need to be on that same thread, until the AnimationHandler is reset (using [setAnimationHandler]).