UIView.animate: ce este, animația proprietăților UIView în iOS

Ce este UIView.animate?

UIView.animate — o metodă statică a clasei UIView, introdusă în iOS 4 (2010). Oferă o API declarativă pentru animarea proprietăților animabile ale UIView: frame, bounds, center, alpha, transform, backgroundColor. Metoda primește un bloc (închidere) cu modificări ale proprietăților — sistemul creează automat CABasicAnimation pentru fiecare proprietate modificată.

Sintaxa bloc a înlocuit vechiul beginAnimations/commitAnimations (iOS 2-3) și a devenit standardul de animație în UIKit. Animațiile UIView.animate sunt executate pe firul principal și nu blochează UI. În mod implicit, durata animației este de 0.25 secunde cu curba easeInOut.

Conform datelor Apple WWDC 2023, modul recomandat de animație în proiecte noi este SwiftUI cu modificatorii .animation() și .transition(), dar UIKit.animate rămâne instrumentul principal pentru suportul iOS 16 și mai jos, precum și pentru tranziții personalizate complexe.

Parametri și opțiuni de animație

UIView.animate oferă trei parametri cheie: duration (durata în secunde), delay (întârzierea înainte de start) și options (set de măști binare UIView.AnimationOptions). Options includ curve (easeInOut, easeIn, easeOut, linear), repeat (repetare), autoreverse (întoarcere automată), allowUserInteraction, beginFromCurrentState și overrideInheritedDuration.

Parametrul options se combină prin tablou: [.curveEaseOut, .repeat, .autoreverse]. Animația cu repeat și autoreverse readuce lin View-ul la starea inițială și se repetă la nesfârșit. Pentru un număr finit de repetări, folosiți animateKeyframes.

Animația spring prin UIView.animate

Animația spring adaugă un efect fizic de arc: obiectul nu doar trece din punctul A în B, ci „zboară" dincolo de țintă cu oscilații amortizate. Parametri: usingSpringWithDamping (amortizare 0-1, unde 0 — oscilații maxime) și initialSpringVelocity (viteza inițială a arcului).

Apple recomandă usingSpringWithDamping în intervalul 0.4-0.8 pentru animații UI naturale. Valoarea 0.5 creează o revenire vizibilă fără senzația de „cauciuc". initialSpringVelocity = 1.0 corespunde vitezei de 1 pt/sec. La 0, animația pornește din stare de repaus.

// Exemplu de animație spring și keyframe
import UIKit

class AnimatedView: UIView {

    func springBounce() {
        // Animație spring cu amortizare
        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
        }
    }
}

Animația keyframe

UIView.animateKeyframes permite împărțirea animației în mai mulți pași (keyframes), fiecare cu timpul și durata sa relativă. Metoda addKeyframe(withRelativeStartTime:relativeDuration:) acceptă valori de timp de la 0 la 1 în raport cu durata totală a animației.

Animațiile keyframe sunt utile pentru efecte în mai mulți pași: pulsarea butonului (mărire → pauză → revenire), apariția secvențială a elementelor, deformări complexe cu stări intermediare. Fiecare keyframe poate avea propria curbă de animație prin options.

// Animație keyframe cu secvență complexă
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
        }
    }
}

// Animație cu închideri imbricate
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
        }
    }
}

Structura internă: Core Animation în spatele scenei

În spatele scenei, UIView.animate delegă animația către CALayer-ul fiecărui UIView prin Core Animation (CAAnimation). Când modificați frame în interiorul blocului de animație, sistemul creează CABasicAnimation pentru proprietățile position și bounds ale stratului corespunzător. Dacă modificați alpha — CABasicAnimation pentru proprietatea opacity a stratului.

Core Animation folosește un proces separat render server (backboardd pe iOS) care procesează animațiile la frecvența de 120 Hz (ProMotion). UIView.animate nu blochează firul principal — modificările proprietăților sunt trimise către render server, care interpolează cadrele fără participarea aplicației.

Conform Apple, animațiile prin UIView.animate au un consum de ~2-3% CPU pentru fiecare strat modificat la 60 FPS. Pentru animații masive (20+ obiecte simultan) se recomandă utilizarea CATransaction și gestionarea manuală a straturilor.

Pentru depanarea și vizualizarea animațiilor UIKit, folosiți Xcode Debug View Hierarchy — arată CAAnimations active pe fiecare strat, durata, curba și starea curentă. Înțelegerea structurii interne a Core Animation ajută la evitarea problemelor de performanță la animații complexe și la alegerea abordării optime între UIView.animate și utilizarea directă a CABasicAnimation.