Property Animation: Was ist das, ObjectAnimator und ValueAnimator

Was ist Property Animation?

Property Animation ist ein Framework im Android SDK (Paket android.animation), das beliebige Eigenschaften jedes Objekts (View, Drawable, benutzerdefinierte Klasse) über eine bestimmte Zeit animiert. Im Gegensatz zu View Animation, die nur mit View funktioniert und nur die visuelle Darstellung (Matrix-Transformation) ändert, modifiziert Property Animation die tatsächlichen Felder des Objekts. Das bedeutet, dass sich das Objekt nach einer translationX-Animation tatsächlich an der neuen Position befindet und Klicks an der neuen Stelle verarbeitet werden.

Die Architektur von Property Animation basiert auf drei Schlüsselklassen: ValueAnimator — der Basiswertgenerator, ObjectAnimator — eine Unterklasse zum Binden an eine Objekteigenschaft, AnimatorSet — ein Orchestrator für Gruppenanimationen. Alle drei unterstützen Interpolator (Geschwindigkeitskurve) und TypeEvaluator (Interpolationsregel zwischen Werten).

Laut Android Performance Patterns (Google, 2025) läuft Property Animation mit bis zu 60 FPS bei korrekt konfiguriertem Interpolator und ohne aufwändige Berechnungen in onAnimationUpdate(). Für komplexe Animationen (3D, Physik) wird RenderThread (RenderNode Animations) in Android 12+ empfohlen. Property Animation bleibt die erste Wahl für die Animation von View-Eigenschaften — translationX, rotationY, scaleX, alpha und andere.

ObjectAnimator: Animieren von Objekteigenschaften

ObjectAnimator ist die beliebteste Klasse der Property Animation. Sie erweitert ValueAnimator und ruft automatisch den Setter der angegebenen Objekteigenschaft mit animierten Werten auf. Damit ObjectAnimator funktioniert, muss das Objekt einen öffentlichen Setter für die zu animierende Eigenschaft haben (z.B. setTranslationX(float) für die Eigenschaft „translationX”).

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()
}

Unterstützte View-Eigenschaften: translationX, translationY, translationZ, rotation, rotationX, rotationY, scaleX, scaleY, alpha, x, y, elevation. ObjectAnimator.ofFloat() wird für Float-Eigenschaften verwendet, ofInt() für int, ofObject() für benutzerdefinierte Typen (Farbe, Punkt). Verwenden Sie für Farbanimationen ofObject() mit ArgbEvaluator oder HsvEvaluator.

// ObjectAnimator mit benutzerdefiniertem TypeEvaluator (Farbe)
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()
}

// Mehrere Eigenschaften gleichzeitig animieren
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 — ein Interface zum Verfolgen von Animationsereignissen: onAnimationStart, onAnimationEnd, onAnimationCancel, onAnimationRepeat. Verwenden Sie AnimatorListenerAdapter, um nur die benötigten Methoden zu überschreiben. Ab Android 12 wurde Animator.AnimationCallback mit Coroutine-Unterstützung über suspendAnimationFrame hinzugefügt.

ValueAnimator: Generieren animierter Werte

ValueAnimator ist die Basisklasse von Property Animation, die animierte Werte von Anfang bis Ende über eine bestimmte Zeit generiert. Im Gegensatz zu ObjectAnimator ist ValueAnimator nicht an ein Objekt gebunden — er berechnet einfach Zwischenwerte und benachrichtigt über einen Listener. Der Entwickler entscheidet, was mit den erhaltenen Werten geschehen soll: eine View-Eigenschaft setzen, einen Drawable-Parameter ändern, benutzerdefiniertes Zeichnen in onDraw() aktualisieren.

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

"> ValueAnimator: Animation des Ladefortschritts
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() — wird für ganzzahlige Eigenschaften (Breite, Höhe, Anzahl der Schritte) verwendet. ValueAnimator.ofObject() — für benutzerdefinierte Typen mit TypeEvaluator. ValueAnimator.ofPropertyValuesHolder() — für die parallele Animation mehrerer Eigenschaften mit einem einzigen Timer, was im Vergleich zu separaten Animators für jede Eigenschaft Ressourcen spart.

// ValueAnimator.ofObject mit 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-Leistung: Bei 60 FPS wird onAnimationUpdate alle ~16,7 ms aufgerufen. Vermeiden Sie innerhalb des Listeners: Objektzuweisungen (PointF/RectF einmal erstellen), Aufruf von findViewById(), aufwändige Berechnungen (Datei-E/A, Netzwerk). Verwenden Sie für die gleichzeitige Animation von 20+ Elementen PropertyValuesHolder in einem Animator anstelle von 20 separaten Animators. Verwenden Sie für größenverändernde Animationen View.setLayoutParams() nur am Ende der Animation (über AnimatorListenerAdapter.onAnimationEnd).

AnimatorSet: Animationskomposition

AnimatorSet ist ein Orchestrator, der das Ausführen mehrerer Animator-Instanzen (ObjectAnimator, ValueAnimator) in einer bestimmten Reihenfolge ermöglicht: sequenziell (playSequentially), parallel (playTogether), mit Verzögerungen (after, before, with). AnimatorSet unterstützt Verschachtelung — ein AnimatorSet kann andere AnimatorSets für komplexe Szenarien enthalten.

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

// AnimatorSet: sequenzielle und parallele 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 {
    // Parallel: fadeIn + slideUp
    play(fadeIn).with(slideUp)
        "> Nachher: bounce mit 200ms Verzögerung
    play(bounce).after(200L)

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

AnimatorSet.Builder bietet eine fließende API zum Erstellen von Ketten: with() — parallel, before() — vor, after() — nach. AnimatorSet unterstützt cancel() zum Stoppen aller Animationen im Set. Verwenden Sie für komplexe Szenarien (25+ Animator-Objekte) PropertyValuesHolder — es ist leistungsfähiger, da es einen einzigen gemeinsamen Timer anstelle eines separaten für jeden Animator verwendet.

Interpolator und TypeEvaluator: Geschwindigkeits- und Typsteuerung

Interpolator definiert die Geschwindigkeitskurve der Animation von 0 bis 1. Android bietet integrierte Interpolators: LinearInterpolator (gleichmäßig), AccelerateDecelerateInterpolator (langsam-schnell-langsam), FastOutSlowInInterpolator (Material Design), OvershootInterpolator (mit Überschwingen), BounceInterpolator (mit Hüpfen), AnticipateOvershootInterpolator (mit Zurückziehen vor Beginn und Überschwingen des Ziels). Benutzerdefinierte Interpolators werden über TimeInterpolator implementiert.

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

// BounceInterpolator — Hüpfeffekt am Ende
val bounceAnim = ObjectAnimator.ofFloat(myView, "translationY", 0f, -50f).apply {
    duration = 600L
    interpolator = BounceInterpolator()
    start()
}

// AnticipateOvershoot — Zurückziehen, dann Überschwingen
val anticipateAnim = ObjectAnimator.ofFloat(myView, "scaleX", 1f, 1.3f).apply {
    duration = 500L
    interpolator = AnticipateOvershootInterpolator(2.0f)
    start()
}

TypeEvaluator — ein Interface mit der Methode evaluate(fraction, startValue, endValue), das den Zwischenwert zwischen Start und Ende berechnet. Integriert: ArgbEvaluator (int Farbe), FloatEvaluator, IntEvaluator, PointFEvaluator, RectEvaluator. Für benutzerdefinierte Datentypen (z.B. Animieren einer benutzerdefinierten Klasse mit drei Feldern) implementieren Sie Ihren eigenen TypeEvaluator. Verwenden Sie zum Animieren mehrerer Views mit denselben Einstellungen PropertyValuesHolder — es akzeptiert ein Array von Eigenschaftsnamen und entsprechenden Werten.

// Benutzerdefinierter TypeEvaluator für die Klasse ProgressState
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 — maximale Leistung
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()
}