UIView.animate: cos'è, animazione delle proprietà UIView in iOS

Cos'è UIView.animate?

UIView.animate è un metodo statico della classe UIView, introdotto in iOS 4 (2010). Fornisce un'API dichiarativa per animare le proprietà animabili di UIView: frame, bounds, center, alpha, transform, backgroundColor. Il metodo accetta un blocco (chiusura) con modifiche delle proprietà — il sistema crea automaticamente CABasicAnimation per ogni proprietà modificata.

La sintassi a blocchi ha sostituito il vecchio beginAnimations/commitAnimations (iOS 2-3) ed è diventata lo standard di animazione in UIKit. Le animazioni UIView.animate vengono eseguite sul thread principale e non bloccano l'interfaccia utente. Per impostazione predefinita, la durata dell'animazione è di 0,25 secondi con una curva easeInOut.

Secondo Apple WWDC 2023, l'approccio di animazione consigliato nei nuovi progetti è SwiftUI con i modificatori .animation() e .transition(), ma UIView.animate rimane lo strumento principale per il supporto di iOS 16 e versioni precedenti, nonché per transizioni personalizzate complesse.

Parametri e opzioni di animazione

UIView.animate fornisce tre parametri chiave: duration (durata in secondi), delay (ritardo prima dell'inizio) e options (insieme di maschere di bit UIView.AnimationOptions). Le options includono curve (easeInOut, easeIn, easeOut, linear), repeat, autoreverse, allowUserInteraction, beginFromCurrentState e overrideInheritedDuration.

Il parametro options viene combinato tramite un array: [.curveEaseOut, .repeat, .autoreverse]. L'animazione con repeat e autoreverse riporta dolcemente la View allo stato iniziale e si ripete indefinitamente. Per un numero finito di ripetizioni, utilizza animateKeyframes.

Animazione Spring tramite UIView.animate

L'animazione Spring aggiunge un effetto fisico a molla: l'oggetto non si limita a spostarsi dal punto A al B, ma supera l'obiettivo con oscillazioni smorzate. Parametri: usingSpringWithDamping (smorzamento 0-1, dove 0 è oscillazione massima) e initialSpringVelocity (velocità iniziale della molla).

Apple consiglia usingSpringWithDamping nell'intervallo 0,4-0,8 per animazioni UI naturali. Un valore di 0,5 crea un rimbalzo evidente senza sensazione di "gomma". initialSpringVelocity = 1,0 corrisponde a una velocità di 1 pt/s. A 0, l'animazione parte da fermo.

// Esempio di animazione spring e keyframe
import UIKit

class AnimatedView: UIView {

    func springBounce() {
        // Animazione spring con smorzamento
        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
        }
    }
}

Animazione Keyframe

UIView.animateKeyframes consente di suddividere un'animazione in più passaggi (keyframe), ciascuno con il proprio tempo e durata relativi. Il metodo addKeyframe(withRelativeStartTime:relativeDuration:) accetta valori temporali da 0 a 1 relativi alla durata totale dell'animazione.

Le animazioni keyframe sono utili per effetti multi-fase: pulsazione del pulsante (aumento → pausa → ritorno), comparsa sequenziale di elementi, deformazioni complesse con stati intermedi. Ogni keyframe può avere la propria curva di animazione tramite options.

// Animazione keyframe con sequenza complessa
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
        }
    }
}

// Animazione con chiusure annidate
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
        }
    }
}

Struttura interna: Core Animation sotto il cofano

Sotto il cofano, UIView.animate delega l'animazione al CALayer di ogni UIView tramite Core Animation (CAAnimation). Quando si modifica il frame all'interno del blocco di animazione, il sistema crea CABasicAnimation per le proprietà position e bounds del livello corrispondente. Se viene modificato alpha — CABasicAnimation per la proprietà opacity del livello.

Core Animation utilizza un processo di server di rendering separato (backboardd su iOS) che elabora le animazioni a 120 Hz (ProMotion). UIView.animate non blocca il thread principale — le modifiche delle proprietà vengono inviate al server di rendering, che interpola i fotogrammi senza il coinvolgimento dell'applicazione.

Secondo Apple, le animazioni tramite UIView.animate hanno un overhead di circa il 2-3% di CPU per livello modificato a 60 FPS. Per animazioni di massa (20+ oggetti contemporaneamente), si consiglia di utilizzare CATransaction e la gestione manuale dei livelli.

Per eseguire il debug e visualizzare le animazioni UIKit, utilizzare Xcode Debug View Hierarchy — mostra le CAAnimations attive su ogni livello, la loro durata, curva e stato corrente. Comprendere la struttura interna di Core Animation aiuta a evitare problemi di prestazioni con animazioni complesse e a scegliere l'approccio ottimale tra UIView.animate e l'uso diretto di CABasicAnimation.