Property Animation: vad är det, ObjectAnimator och ValueAnimator

Vad är Property Animation?

Property Animation — är ett ramverk i Android SDK (paket android.animation) som animerar alla egenskaper hos alla objekt (View, Drawable, anpassad klass) under en angiven tid. Till skillnad från View Animation, som bara fungerar med View och endast ändrar den visuella representationen (matrix transform), ändrar Property Animation objektets faktiska fält. Detta innebär att efter animering av translationX befinner sig objektet verkligen på den nya positionen och klickningar bearbetas på den nya platsen.

Arkitekturen för Property Animation bygger på tre nyckelklasser: ValueAnimator — basgenerator av värden, ObjectAnimator — underklass för bindning till objektegenskap, AnimatorSet — orkestrator för gruppanimering. Alla tre stöder Interpolator (hastighetskurva) och TypeEvaluator (interpolationsregel mellan värden).

Enligt Android Performance Patterns (Google, 2025) fungerar Property Animation med frekvens upp till 60 FPS med korrekt konfigurerad Interpolator och utan tunga beräkningar i onAnimationUpdate(). För komplexa animeringar (3D, fysik) rekommenderas RenderThread (RenderNode Animations) i Android 12+. Property Animation förblir det främsta valet för animering av View-egenskaper — translationX, rotationY, scaleX, alpha och andra.

ObjectAnimator: animering av objektegenskaper

ObjectAnimator — den populäraste klassen i Property Animation. Den ärver från ValueAnimator och anropar automatiskt setter för den angivna egenskapen hos objektet med animerade värden. För att fungera kräver ObjectAnimator att objektet har en publik setter för den egenskap som animeras (t.ex. setTranslationX(float) för egenskapen «translationX»).

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

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

Stödda View-egenskaper: translationX, translationY, translationZ, rotation, rotationX, rotationY, scaleX, scaleY, alpha, x, y, elevation. ObjectAnimator.ofFloat() används för float-egenskaper, ofInt() — för int, ofObject() — för anpassade typer (färg, punkt). För färganimering använd ofObject() med ArgbEvaluator eller HsvEvaluator.

// ObjectAnimator med anpassad TypeEvaluator (färg)
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()
}

// Animering av flera egenskaper samtidigt
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 — gränssnitt för att spåra animationshändelser: onAnimationStart, onAnimationEnd, onAnimationCancel, onAnimationRepeat. Använd AnimatorListenerAdapter för att bara åsidosätta nödvändiga metoder. Från och med Android 12 har Animator.AnimationCallback lagts till med stöd för korutiner via suspendAnimationFrame.

ValueAnimator: generering av animerade värden

ValueAnimator — basklassen i Property Animation som genererar animerade värden från start till end under en angiven tid. Till skillnad från ObjectAnimator är ValueAnimator inte bundet till ett objekt — det beräknar bara mellanliggande värden och meddelar via en lyssnare. Utvecklaren bestämmer själv vad som ska göras med de mottagna värdena: ställa in en View-egenskap, ändra en Drawable-parameter, uppdatera anpassad ritning i onDraw().

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

"> ValueAnimator: animering av laddningsförloppet
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() — används för heltalsegenskaper (bredd, höjd, antal steg). ValueAnimator.ofObject() — för anpassade typer med TypeEvaluator. ValueAnimator.ofPropertyValuesHolder() — för parallell animering av flera egenskaper med en timer, vilket sparar resurser jämfört med separata Animator för varje egenskap.

// ValueAnimator.ofObject med 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()
}

Prestanda för ValueAnimator: vid frekvensen 60 FPS anropas onAnimationUpdate varje ~16.7 ms. Undvik inuti lyssnaren: objektallokering (skapa PointF/RectF en gång), anropa findViewById(), tunga beräkningar (fil-I/O, nätverk). För animering av 20+ samtidiga element, använd PropertyValuesHolder i en Animator istället för 20 separata Animator. För animering med storleksändring, använd View.setLayoutParams() endast i slutet av animeringen (via AnimatorListenerAdapter.onAnimationEnd).

AnimatorSet: komposition av animeringar

AnimatorSet — orkestrator som gör det möjligt att köra flera Animator (ObjectAnimator, ValueAnimator) i en viss ordning: sekventiellt (playSequentially), parallellt (playTogether), med fördröjningar (after, before, with). AnimatorSet stöder nästling — AnimatorSet kan innehålla andra AnimatorSet för komplexa scenarier.

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

// AnimatorSet: sekventiell och parallell animering
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 {
    // Parallellt: fadeIn + slideUp
    play(fadeIn).with(slideUp)
        "> Efter: bounce med 200ms fördröjning
    play(bounce).after(200L)

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

AnimatorSet.Builder tillhandahåller ett flytande API för att bygga kedjor: with() — parallellt, before() — före, after() — efter. AnimatorSet stöder cancel() för att stoppa alla animeringar i uppsättningen. För komplexa scenarier (25+ animatorer), använd PropertyValuesHolder — det är effektivare eftersom det använder en gemensam timer istället för separata timers för varje Animator.

Interpolator och TypeEvaluator: hantera hastighet och typ

Interpolator bestämmer kurvan för hastighetsändringen av animeringen från 0 till 1. Android tillhandahåller inbyggda Interpolator: LinearInterpolator (jämnt), AccelerateDecelerateInterpolator (långsamt-snabbt-långsamt), FastOutSlowInInterpolator (Material Design), OvershootInterpolator (med överskridande av målet), BounceInterpolator (med studs), AnticipateOvershootInterpolator (med tillbakadragande före starten och överskridande av målet). Anpassad Interpolator implementeras via TimeInterpolator.

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

// BounceInterpolator — studseffekt i slutet
val bounceAnim = ObjectAnimator.ofFloat(myView, "translationY", 0f, -50f).apply {
    duration = 600L
    interpolator = BounceInterpolator()
    start()
}

// AnticipateOvershoot — dra tillbaka, sedan överskrida
val anticipateAnim = ObjectAnimator.ofFloat(myView, "scaleX", 1f, 1.3f).apply {
    duration = 500L
    interpolator = AnticipateOvershootInterpolator(2.0f)
    start()
}

TypeEvaluator — gränssnitt med metoden evaluate(fraction, startValue, endValue) som beräknar mellanliggande värde mellan start och end. Inbyggda: ArgbEvaluator (färg int), FloatEvaluator, IntEvaluator, PointFEvaluator, RectEvaluator. För anpassade datatyper (t.ex. animering av en anpassad klass med tre fält) implementera din egen TypeEvaluator. För animering av flera View med samma inställningar, använd PropertyValuesHolder — den accepterar en array med egenskapsnamn och motsvarande värden.

// Anpassad TypeEvaluator för klassen 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 — maximal prestanda
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()
}