UIView.animate: Was es ist, Animation von UIView-Eigenschaften in iOS

Was ist UIView.animate?

UIView.animate ist eine statische Methode der UIView-Klasse, eingeführt in iOS 4 (2010). Sie bietet eine deklarative API zum Animieren animierbarer Eigenschaften von UIView: frame, bounds, center, alpha, transform, backgroundColor. Die Methode akzeptiert einen Block (Closure) mit Eigenschaftsänderungen — das System erstellt automatisch CABasicAnimation für jede geänderte Eigenschaft.

Die Blocksyntax ersetzte die alten beginAnimations/commitAnimations (iOS 2-3) und wurde zum Animationsstandard in UIKit. UIView.animate-Animationen werden im Hauptthread ausgeführt und blockieren die Benutzeroberfläche nicht. Standardmäßig beträgt die Animationsdauer 0,25 Sekunden mit einer easeInOut-Kurve.

Laut Apple WWDC 2023 ist der empfohlene Animationsansatz in neuen Projekten SwiftUI mit .animation()- und .transition()-Modifikatoren, aber UIView.animate bleibt das wichtigste Werkzeug für die Unterstützung von iOS 16 und älter sowie für komplexe benutzerdefinierte Übergänge.

Animationsparameter und Optionen

UIView.animate bietet drei Schlüsselparameter: duration (Dauer in Sekunden), delay (Verzögerung vor dem Start) und options (Satz von UIView.AnimationOptions-Bitmasken). Options umfassen curve (easeInOut, easeIn, easeOut, linear), repeat, autoreverse, allowUserInteraction, beginFromCurrentState und overrideInheritedDuration.

Der Parameter options wird über ein Array kombiniert: [.curveEaseOut, .repeat, .autoreverse]. Animation mit repeat und autoreverse kehrt die View sanft in ihren Ausgangszustand zurück und wiederholt sich unbegrenzt. Für eine endliche Anzahl von Wiederholungen verwenden Sie animateKeyframes.

Spring-Animation über UIView.animate

Spring-Animation fügt einen physikalischen Federeffekt hinzu: Das Objekt bewegt sich nicht nur von Punkt A nach B, sondern überschießt das Ziel mit gedämpften Schwingungen. Parameter: usingSpringWithDamping (Dämpfung 0-1, wobei 0 maximale Schwingung ist) und initialSpringVelocity (anfängliche Federgeschwindigkeit).

Apple empfiehlt usingSpringWithDamping im Bereich von 0,4-0,8 für natürliche UI-Animationen. Ein Wert von 0,5 erzeugt ein merkliches Zurückfedern ohne sich „gummiartig" anzufühlen. initialSpringVelocity = 1,0 entspricht einer Geschwindigkeit von 1 pt/s. Bei 0 beginnt die Animation aus dem Ruhezustand.

// Beispiel für Spring- und Keyframe-Animation
import UIKit

class AnimatedView: UIView {

    func springBounce() {
        // Spring-Animation mit Dämpfung
        UIView.animate(
            withDuration: 0.8,
            delay: 0,
            usingSpringWithDamping: 0.5,
            initialSpringVelocity: 1.0,
            options: [.allowUserInteraction],
            animations: {
                self.transform = CGAffineTransform(scaleX: 1.2, y: 1.2)
                self.alpha = 0.7
            },
            completion: { _ in
                UIView.animate(withDuration: 0.3) {
                    self.transform = .identity
                    self.alpha = 1.0
                }
            }
        )
    }

    func slideIn(from offset: CGFloat) {
        self.transform = CGAffineTransform(translationX: offset, y: 0)
        self.alpha = 0.0

        UIView.animate(
            withDuration: 0.6,
            delay: 0.1,
            options: [.curveEaseOut]
        ) {
            self.transform = .identity
            self.alpha = 1.0
        }
    }
}

Keyframe-Animation

UIView.animateKeyframes ermöglicht es, eine Animation in mehrere Schritte (Keyframes) zu unterteilen, jeder mit seiner eigenen relativen Zeit und Dauer. Die Methode addKeyframe(withRelativeStartTime:relativeDuration:) akzeptiert Zeitwerte von 0 bis 1 relativ zur gesamten Animationsdauer.

Keyframe-Animationen sind nützlich für mehrstufige Effekte: Button-Puls (Vergrößerung → Pause → Rückkehr), sequenzielles Erscheinen von Elementen, komplexe Verformungen mit Zwischenzuständen. Jeder Keyframe kann über options seine eigene Animationskurve haben.

// Keyframe-Animation mit komplexer Sequenz
func complexPulse() {
    UIView.animateKeyframes(withDuration: 2.0, delay: 0, options: [.repeat]) {
        UIView.addKeyframe(withRelativeStartTime: 0.0, relativeDuration: 0.25) {
            self.transform = CGAffineTransform(scaleX: 1.5, y: 1.5)
            self.alpha = 0.5
        }
        UIView.addKeyframe(withRelativeStartTime: 0.25, relativeDuration: 0.25) {
            self.transform = CGAffineTransform(scaleX: 0.8, y: 0.8)
            self.alpha = 0.8
        }
        UIView.addKeyframe(withRelativeStartTime: 0.5, relativeDuration: 0.5) {
            self.transform = .identity
            self.alpha = 1.0
        }
    }
}

// Animation mit verschachtelten Closures
func animateCardTransition() {
    UIView.animate(withDuration: 0.4, delay: 0, options: [.curveEaseOut]) {
        self.transform = CGAffineTransform(scaleX: 0.95, y: 0.95)
    } completion: { _ in
        UIView.animate(withDuration: 0.3, delay: 0, options: [.curveEaseIn]) {
            self.transform = .identity
        }
    }
}

Interne Struktur: Core Animation unter der Haube

Unter der Haube delegiert UIView.animate die Animation an das CALayer jedes UIView über Core Animation (CAAnimation). Wenn Sie den frame innerhalb des Animationsblocks ändern, erstellt das System CABasicAnimation für die Eigenschaften position und bounds der entsprechenden Ebene. Wenn alpha geändert wird — CABasicAnimation für die Eigenschaft opacity der Ebene.

Core Animation verwendet einen separaten Render-Server-Prozess (backboardd auf iOS), der Animationen mit 120 Hz (ProMotion) verarbeitet. UIView.animate blockiert den Hauptthread nicht — Eigenschaftsänderungen werden an den Render-Server gesendet, der Frames ohne Beteiligung der Anwendung interpoliert.

Laut Apple haben Animationen über UIView.animate einen Overhead von ~2-3% CPU pro geänderter Ebene bei 60 FPS. Für Massenanimationen (20+ Objekte gleichzeitig) wird die Verwendung von CATransaction und manuellem Ebenenmanagement empfohlen.

Zum Debuggen und Visualisieren von UIKit-Animationen verwenden Sie Xcode Debug View Hierarchy — es zeigt aktive CAAnimations auf jeder Ebene, ihre Dauer, Kurve und den aktuellen Zustand. Das Verständnis der internen Struktur von Core Animation hilft, Leistungsprobleme bei komplexen Animationen zu vermeiden und den optimalen Ansatz zwischen UIView.animate und der direkten Verwendung von CABasicAnimation zu wählen.