UIView.animate: qué es, animación de propiedades de UIView en iOS

¿Qué es UIView.animate?

UIView.animate es un método estático de la clase UIView, introducido en iOS 4 (2010). Proporciona una API declarativa para animar propiedades animables de UIView: frame, bounds, center, alpha, transform, backgroundColor. El método acepta un bloque (cierre) con cambios de propiedades — el sistema crea automáticamente CABasicAnimation para cada propiedad modificada.

La sintaxis de bloques reemplazó al antiguo beginAnimations/commitAnimations (iOS 2-3) y se convirtió en el estándar de animación en UIKit. Las animaciones de UIView.animate se ejecutan en el hilo principal y no bloquean la interfaz de usuario. Por defecto, la duración de la animación es de 0.25 segundos con una curva easeInOut.

Según Apple WWDC 2023, el enfoque de animación recomendado en nuevos proyectos es SwiftUI con los modificadores .animation() y .transition(), pero UIView.animate sigue siendo la herramienta principal para soporte de iOS 16 y versiones anteriores, así como para transiciones personalizadas complejas.

Parámetros y opciones de animación

UIView.animate proporciona tres parámetros clave: duration (duración en segundos), delay (retardo antes del inicio) y options (conjunto de máscaras de bits UIView.AnimationOptions). Options incluyen curve (easeInOut, easeIn, easeOut, linear), repeat, autoreverse, allowUserInteraction, beginFromCurrentState y overrideInheritedDuration.

El parámetro options se combina mediante un array: [.curveEaseOut, .repeat, .autoreverse]. La animación con repeat y autoreverse devuelve suavemente la vista a su estado inicial y se repite indefinidamente. Para un número finito de repeticiones, usa animateKeyframes.

Animación Spring mediante UIView.animate

La animación Spring añade un efecto físico de muelle: el objeto no solo se mueve del punto A al B, sino que sobrepasa el objetivo con oscilaciones amortiguadas. Parámetros: usingSpringWithDamping (amortiguación 0-1, donde 0 es la oscilación máxima) e initialSpringVelocity (velocidad inicial del muelle).

Apple recomienda usingSpringWithDamping en el rango de 0.4-0.8 para animaciones de UI naturales. Un valor de 0.5 crea un rebote notable sin sensación de "goma". initialSpringVelocity = 1.0 corresponde a una velocidad de 1 pt/seg. En 0, la animación comienza desde el reposo.

// Ejemplo de animación spring y keyframe
import UIKit

class AnimatedView: UIView {

    func springBounce() {
        // Animación spring con amortiguación
        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
        }
    }
}

Animación Keyframe

UIView.animateKeyframes permite dividir una animación en varios pasos (keyframes), cada uno con su propio tiempo y duración relativos. El método addKeyframe(withRelativeStartTime:relativeDuration:) acepta valores de tiempo de 0 a 1 relativos a la duración total de la animación.

Las animaciones keyframe son útiles para efectos de múltiples etapas: pulso de botón (aumento → pausa → retorno), aparición secuencial de elementos, deformaciones complejas con estados intermedios. Cada keyframe puede tener su propia curva de animación mediante options.

// Animación keyframe con secuencia compleja
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
        }
    }
}

// Animación con cierres anidados
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
        }
    }
}

Estructura interna: Core Animation bajo el capó

Bajo el capó, UIView.animate delega la animación al CALayer de cada UIView a través de Core Animation (CAAnimation). Cuando cambias el frame dentro del bloque de animación, el sistema crea CABasicAnimation para las propiedades position y bounds de la capa correspondiente. Si se cambia alpha — CABasicAnimation para la propiedad opacity de la capa.

Core Animation utiliza un proceso de render server separado (backboardd en iOS) que procesa las animaciones a 120 Hz (ProMotion). UIView.animate no bloquea el hilo principal — los cambios de propiedades se envían al render server, que interpola los fotogramas sin intervención de la aplicación.

Según Apple, las animaciones mediante UIView.animate tienen una sobrecarga de ~2-3% de CPU por capa modificada a 60 FPS. Para animaciones masivas (20+ objetos simultáneamente), se recomienda usar CATransaction y gestión manual de capas.

Para depurar y visualizar animaciones de UIKit, usa Xcode Debug View Hierarchy — muestra las CAAnimations activas en cada capa, su duración, curva y estado actual. Comprender la estructura interna de Core Animation ayuda a evitar problemas de rendimiento con animaciones complejas y elegir el enfoque óptimo entre UIView.animate y el uso directo de CABasicAnimation.