Property Animation: What It Is, ObjectAnimator and ValueAnimator

What Is Property Animation?

Property Animation is a framework in Android SDK (android.animation package) that animates any properties of any object (View, Drawable, custom class) over a specified time. Unlike View Animation, which only works with View and changes only the visual representation (matrix transform), Property Animation modifies the real fields of an object. This means that after translationX animation, the object is actually at the new position, and clicks are processed at the new location.

The Property Animation architecture is built on three key classes: ValueAnimator — the base value generator, ObjectAnimator — a subclass for binding to an object property, AnimatorSet — an orchestrator for group animation. All three support Interpolator (speed curve) and TypeEvaluator (interpolation rule between values).

According to Android Performance Patterns (Google, 2025), Property Animation runs at up to 60 FPS with a properly configured Interpolator and no heavy computations in onAnimationUpdate(). For complex animations (3D, physics), RenderThread (RenderNode Animations) is recommended in Android 12+. Property Animation remains the primary choice for animating View properties — translationX, rotationY, scaleX, alpha, and others.

ObjectAnimator: Animating Object Properties

ObjectAnimator is the most popular Property Animation class. It extends ValueAnimator and automatically calls the setter of the specified object property with animated values. For ObjectAnimator to work, the object must have a public setter for the property being animated (e.g., setTranslationX(float) for the "translationX" property).

import android.animation.ObjectAnimator
import android.view.View

// ObjectAnimator for translationX
val animator = ObjectAnimator.ofFloat(
    myView,
    "translationX",
    0f,
    300f
).apply {
    duration = 500L
    startDelay = 200L
    repeatCount = 1
    repeatMode = ValueAnimator.REVERSE
    interpolator = FastOutSlowInInterpolator()
    start()
}

Supported View properties: translationX, translationY, translationZ, rotation, rotationX, rotationY, scaleX, scaleY, alpha, x, y, elevation. ObjectAnimator.ofFloat() is used for float properties, ofInt() for int, ofObject() for custom types (color, point). For color animation, use ofObject() with ArgbEvaluator or HsvEvaluator.

// ObjectAnimator with custom TypeEvaluator (color)
import android.animation.ObjectAnimator
import android.animation.ArgbEvaluator
import android.graphics.Color

val colorAnim = ObjectAnimator.ofObject(
    myView,
    "backgroundColor",
    ArgbEvaluator(),
    Color.BLUE,
    Color.RED
).apply {
    duration = 1000L
    repeatCount = ValueAnimator.INFINITE
    repeatMode = ValueAnimator.REVERSE
    start()
}

// Animating multiple properties simultaneously
val scaleXAnim = ObjectAnimator.ofFloat(myView, "scaleX", 1f, 1.5f)
val scaleYAnim = ObjectAnimator.ofFloat(myView, "scaleY", 1f, 1.5f)
val alphaAnim = ObjectAnimator.ofFloat(myView, "alpha", 1f, 0.5f)

AnimatorListener — an interface for tracking animation events: onAnimationStart, onAnimationEnd, onAnimationCancel, onAnimationRepeat. Use AnimatorListenerAdapter to override only the methods you need. Starting from Android 12, Animator.AnimationCallback with coroutine support via suspendAnimationFrame has been added.

ValueAnimator: Generating Animated Values

ValueAnimator is the base class of Property Animation that generates animated values from start to end over a given time. Unlike ObjectAnimator, ValueAnimator is not bound to an object — it simply computes intermediate values and notifies via a listener. The developer decides what to do with the obtained values: set a View property, change a Drawable parameter, update custom drawing in onDraw().

import android.animation.ValueAnimator
import android.view.animation.LinearInterpolator

"> ValueAnimator: loading progress animation
val valueAnimator = ValueAnimator.ofFloat(0f, 100f).apply {
    duration = 2000L
    interpolator = LinearInterpolator()
    repeatCount = ValueAnimator.INFINITE

    addUpdateListener { animator ->
        val progress = animator.animatedValue as Float
        progressBar.progress = progress.toInt()
        progressText.text = "${progress.toInt()}%"
    }

    addListener(object : AnimatorListenerAdapter() {
        override fun onAnimationRepeat(animation: Animator) {
            Log.d("Anim", "Progress animation restarted")
        }
    })
    start()
}

ValueAnimator.ofInt() — used for integer properties (width, height, number of steps). ValueAnimator.ofObject() — for custom types with TypeEvaluator. ValueAnimator.ofPropertyValuesHolder() — for parallel animation of multiple properties with a single timer, saving resources compared to separate Animators for each property.

// ValueAnimator.ofObject with PointEvaluator
import android.animation.ValueAnimator
import android.graphics.PointF
import android.animation.PointFEvaluator

val pointAnim = ValueAnimator.ofObject(
    PointFEvaluator(),
    PointF(0f, 0f),
    PointF(300f, 500f)
).apply {
    duration = 1000L
    addUpdateListener { animator ->
        val point = animator.animatedValue as PointF
        movingView.x = point.x
        movingView.y = point.y
    }
    start()
}

ValueAnimator performance: at 60 FPS, onAnimationUpdate is called every ~16.7 ms. Avoid inside the listener: object allocations (create PointF/RectF once), calling findViewById(), heavy computations (file I/O, network). For animating 20+ simultaneous elements, use PropertyValuesHolder in one Animator instead of 20 separate Animators. For size-changing animation, use View.setLayoutParams() only at the end of animation (via AnimatorListenerAdapter.onAnimationEnd).

AnimatorSet: Animation Composition

AnimatorSet is an orchestrator that allows running multiple Animator (ObjectAnimator, ValueAnimator) instances in a specific order: sequentially (playSequentially), in parallel (playTogether), with delays (after, before, with). AnimatorSet supports nesting — an AnimatorSet can contain other AnimatorSets for complex scenarios.

import android.animation.AnimatorSet
import android.animation.ObjectAnimator

// AnimatorSet: sequential and parallel animation
val fadeIn = ObjectAnimator.ofFloat(myView, "alpha", 0f, 1f)
val slideUp = ObjectAnimator.ofFloat(myView, "translationY", 100f, 0f)
val bounce = ObjectAnimator.ofFloat(myView, "scaleX", 1f, 1.1f, 1f)

val animatorSet = AnimatorSet().apply {
    // In parallel: fadeIn + slideUp
    play(fadeIn).with(slideUp)
        "> After: bounce with a 200ms delay
    play(bounce).after(200L)

    duration = 400L
    interpolator = FastOutSlowInInterpolator()
    addListener(object : AnimatorListenerAdapter() {
        override fun onAnimationEnd(animation: Animator) {
            Log.d("Anim", "Set completed")
        }
    })
    start()
}

AnimatorSet.Builder provides a fluent API for building chains: with() — in parallel, before() — before, after() — after. AnimatorSet supports cancel() to stop all animations in the set. For complex scenarios (25+ animators), use PropertyValuesHolder — it is more performant because it uses a single shared timer instead of separate ones for each Animator.

Interpolator and TypeEvaluator: Speed and Type Control

Interpolator defines the speed curve of the animation from 0 to 1. Android provides built-in Interpolators: LinearInterpolator (uniform), AccelerateDecelerateInterpolator (slow-fast-slow), FastOutSlowInInterpolator (Material Design), OvershootInterpolator (with overshooting), BounceInterpolator (with bouncing), AnticipateOvershootInterpolator (with pull back before start and overshooting the target). Custom Interpolator is implemented via TimeInterpolator.

import android.animation.ObjectAnimator
import android.view.animation.BounceInterpolator
import android.view.animation.OvershootInterpolator
import android.view.animation.AnticipateOvershootInterpolator

// BounceInterpolator — bounce effect at the end
val bounceAnim = ObjectAnimator.ofFloat(myView, "translationY", 0f, -50f).apply {
    duration = 600L
    interpolator = BounceInterpolator()
    start()
}

// AnticipateOvershoot — pull back, then overshoot
val anticipateAnim = ObjectAnimator.ofFloat(myView, "scaleX", 1f, 1.3f).apply {
    duration = 500L
    interpolator = AnticipateOvershootInterpolator(2.0f)
    start()
}

TypeEvaluator — an interface with the evaluate(fraction, startValue, endValue) method that computes the intermediate value between start and end. Built-in: ArgbEvaluator (int color), FloatEvaluator, IntEvaluator, PointFEvaluator, RectEvaluator. For custom data types (e.g., animating a custom class with three fields), implement your own TypeEvaluator. For animating multiple Views with the same settings, use PropertyValuesHolder — it accepts an array of property names and corresponding values.

// Custom TypeEvaluator for ProgressState class
data class ProgressState(val progress: Float, val color: Int)

class ProgressEvaluator : TypeEvaluator<ProgressState> {
    override fun evaluate(
        fraction: Float,
        startValue: ProgressState,
        endValue: ProgressState
    ): ProgressState {
        val progress = startValue.progress + fraction * (endValue.progress - startValue.progress)
        val color = ArgbEvaluator().evaluate(
            fraction, startValue.color, endValue.color
        ) as Int
        return ProgressState(progress, color)
    }
}

"> PropertyValuesHolder — maximum performance
val pvh1 = PropertyValuesHolder.ofFloat("scaleX", 1f, 1.5f)
val pvh2 = PropertyValuesHolder.ofFloat("scaleY", 1f, 1.5f)
val pvhAnim = ObjectAnimator.ofPropertyValuesHolder(myView, pvh1, pvh2).apply {
    duration = 300L
    start()
}