UIView.animate: o que é, animação de propriedades de UIView no iOS

O que é UIView.animate?

UIView.animate é um método estático da classe UIView, introduzido no iOS 4 (2010). Ele fornece uma API declarativa para animar propriedades animáveis de UIView: frame, bounds, center, alpha, transform, backgroundColor. O método aceita um bloco (encerramento) com alterações de propriedades — o sistema cria automaticamente CABasicAnimation para cada propriedade alterada.

A sintaxe de blocos substituiu o antigo beginAnimations/commitAnimations (iOS 2-3) e tornou-se o padrão de animação no UIKit. As animações UIView.animate são executadas na thread principal e não bloqueiam a interface do utilizador. Por defeito, a duração da animação é de 0.25 segundos com uma curva easeInOut.

De acordo com a Apple WWDC 2023, a abordagem de animação recomendada em novos projetos é SwiftUI com os modificadores .animation() e .transition(), mas UIView.animate continua a ser a ferramenta principal para suporte iOS 16 e inferior, bem como para transições personalizadas complexas.

Parâmetros e opções de animação

UIView.animate fornece três parâmetros chave: duration (duração em segundos), delay (atraso antes do início) e options (conjunto de máscaras de bits UIView.AnimationOptions). Options incluem curve (easeInOut, easeIn, easeOut, linear), repeat, autoreverse, allowUserInteraction, beginFromCurrentState e overrideInheritedDuration.

O parâmetro options é combinado através de uma matriz: [.curveEaseOut, .repeat, .autoreverse]. A animação com repeat e autoreverse retorna suavemente a View ao seu estado inicial e repete-se indefinidamente. Para um número finito de repetições, use animateKeyframes.

Animação Spring via UIView.animate

A animação Spring adiciona um efeito físico de mola: o objeto não apenas se move do ponto A para B, mas ultrapassa o alvo com oscilações amortecidas. Parâmetros: usingSpringWithDamping (amortecimento 0-1, onde 0 é oscilação máxima) e initialSpringVelocity (velocidade inicial da mola).

A Apple recomenda usingSpringWithDamping no intervalo de 0.4-0.8 para animações de UI naturais. Um valor de 0.5 cria um ressalto notável sem sensação de "borracha". initialSpringVelocity = 1.0 corresponde a uma velocidade de 1 pt/seg. Em 0, a animação começa a partir do repouso.

// Exemplo de animação spring e keyframe
import UIKit

class AnimatedView: UIView {

    func springBounce() {
        // Animação spring com amortecimento
        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ção Keyframe

UIView.animateKeyframes permite dividir uma animação em vários passos (keyframes), cada um com o seu próprio tempo e duração relativos. O método addKeyframe(withRelativeStartTime:relativeDuration:) aceita valores de tempo de 0 a 1 relativos à duração total da animação.

As animações keyframe são úteis para efeitos de múltiplas etapas: pulso de botão (aumento → pausa → retorno), aparecimento sequencial de elementos, deformações complexas com estados intermédios. Cada keyframe pode ter a sua própria curva de animação através de options.

// Animação keyframe com sequência complexa
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ção com encerramentos aninhados
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
        }
    }
}

Estrutura interna: Core Animation internamente

Internamente, UIView.animate delega a animação ao CALayer de cada UIView através de Core Animation (CAAnimation). Quando altera o frame dentro do bloco de animação, o sistema cria CABasicAnimation para as propriedades position e bounds da camada correspondente. Se alpha é alterado — CABasicAnimation para a propriedade opacity da camada.

Core Animation utiliza um processo de servidor de renderização separado (backboardd no iOS) que processa animações a 120 Hz (ProMotion). UIView.animate não bloqueia a thread principal — as alterações de propriedades são enviadas para o servidor de renderização, que interpola os quadros sem envolvimento da aplicação.

De acordo com a Apple, as animações através de UIView.animate têm uma sobrecarga de ~2-3% de CPU por camada alterada a 60 FPS. Para animações em massa (20+ objetos simultaneamente), recomenda-se usar CATransaction e gestão manual de camadas.

Para depurar e visualizar animações UIKit, use Xcode Debug View Hierarchy — mostra as CAAnimations ativas em cada camada, a sua duração, curva e estado atual. Compreender a estrutura interna da Core Animation ajuda a evitar problemas de desempenho com animações complexas e escolher a abordagem ideal entre UIView.animate e o uso direto de CABasicAnimation.