UIView.animate: co to jest, animacja właściwości UIView w iOS

Co to jest UIView.animate?

UIView.animate — statyczna metoda klasy UIView, wprowadzona w iOS 4 (2010). Zapewnia deklaratywne API do animacji animowalnych właściwości UIView: frame, bounds, center, alpha, transform, backgroundColor. Metoda przyjmuje blok (domknięcie) ze zmianami właściwości — system automatycznie tworzy CABasicAnimation dla każdej zmienionej właściwości.

Składnia blokowa zastąpiła starą beginAnimations/commitAnimations (iOS 2-3) i stała się standardem animacji w UIKit. Animacje UIView.animate są wykonywane na głównym wątku i nie blokują UI. Domyślnie czas trwania animacji wynosi 0.25 sekundy z krzywą easeInOut.

Według danych Apple WWDC 2023, zalecanym sposobem animacji w nowych projektach jest SwiftUI z modyfikatorami .animation() i .transition(), ale UIKit.animate pozostaje głównym narzędziem do obsługi iOS 16 i starszych, a także do złożonych niestandardowych przejść.

Parametry i opcje animacji

UIView.animate udostępnia trzy kluczowe parametry: duration (czas trwania w sekundach), delay (opóźnienie przed rozpoczęciem) i options (zestaw masek bitowych UIView.AnimationOptions). Options obejmują curve (easeInOut, easeIn, easeOut, linear), repeat (powtórzenie), autoreverse (automatyczny odwrót), allowUserInteraction, beginFromCurrentState i overrideInheritedDuration.

Parametr options jest łączony przez tablicę: [.curveEaseOut, .repeat, .autoreverse]. Animacja z repeat i autoreverse płynnie przywraca View do stanu początkowego i powtarza się w nieskończoność. Dla skończonej liczby powtórzeń użyj animateKeyframes.

Animacja sprężyny przez UIView.animate

Animacja sprężyny dodaje fizyczny efekt sprężyny: obiekt nie tylko przechodzi z punktu A do B, ale „przelatuje" cel z tłumionymi oscylacjami. Parametry: usingSpringWithDamping (tłumienie 0-1, gdzie 0 — maksymalne oscylacje) i initialSpringVelocity (prędkość początkowa sprężyny).

Apple zaleca usingSpringWithDamping w zakresie 0.4-0.8 dla naturalnych animacji UI. Wartość 0.5 tworzy zauważalne odbicie bez uczucia „gumowatości". initialSpringVelocity = 1.0 odpowiada prędkości 1 pt/sek. Przy 0 animacja startuje ze stanu spoczynku.

// Przykład animacji sprężyny i keyframe
import UIKit

class AnimatedView: UIView {

    func springBounce() {
        // Animacja sprężyny z tłumieniem
        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
        }
    }
}

Animacja keyframe

UIView.animateKeyframes pozwala podzielić animację na kilka kroków (keyframes), każdy z własnym względnym czasem i czasem trwania. Metoda addKeyframe(withRelativeStartTime:relativeDuration:) przyjmuje wartości czasowe od 0 do 1 względem całkowitego czasu trwania animacji.

Animacje keyframe są przydatne do wieloetapowych efektów: pulsowanie przycisku (powiększenie → pauza → powrót), sekwencyjne pojawianie się elementów, złożone deformacje z pośrednimi stanami. Każdy keyframe może mieć własną krzywą animacji przez options.

// Animacja keyframe ze złożoną sekwencją
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
        }
    }
}

// Animacja z zagnieżdżonymi domknięciami
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
        }
    }
}

Wewnętrzna struktura: Core Animation pod maską

Pod maską UIView.animate deleguje animację do CALayer każdego UIView przez Core Animation (CAAnimation). Kiedy zmieniasz frame wewnątrz bloku animacji, system tworzy CABasicAnimation dla właściwości position i bounds odpowiedniej warstwy. Jeśli zmieniasz alpha — CABasicAnimation dla właściwości opacity warstwy.

Core Animation używa osobnego procesu render server (backboardd na iOS), który przetwarza animacje z częstotliwością 120 Hz (ProMotion). UIView.animate nie blokuje głównego wątku — zmiany właściwości są wysyłane do render server, który interpoluje klatki bez udziału aplikacji.

Według Apple, animacje przez UIView.animate mają narzut ~2-3% CPU na każdą zmienioną warstwę przy 60 FPS. Dla masowych animacji (20+ obiektów jednocześnie) zaleca się użycie CATransaction i ręczne zarządzanie warstwami.

Do debugowania i wizualizacji animacji UIKit używaj Xcode Debug View Hierarchy — pokazuje aktywne CAAnimations na każdej warstwie, ich czas trwania, krzywą i bieżący stan. Zrozumienie wewnętrznej struktury Core Animation pomaga uniknąć problemów z wydajnością przy złożonych animacjach i wybrać optymalne podejście między UIView.animate a bezpośrednim użyciem CABasicAnimation.