Animações e Transições SwiftUI
Guia abrangente sobre animações SwiftUI, a nova macro @Animatable (iOS 26), transições e melhores práticas de design de movimento para desenvolvimento iOS moderno.
Pré-requisitos
- iOS 17+ para PhaseAnimator/KeyframeAnimator
- iOS 26+ para a macro @Animatable
- Xcode 26+
Macro @Animatable (iOS 26 - NOVO!)
A Revolução nas Animações Personalizadas
iOS 26 introduz a macro @Animatable, eliminando o tedioso boilerplate anteriormente necessário para animar formas e visualizações personalizadas.
Antes do iOS 26 (Abordagem Manual)
// FORMA ANTIGA - Muito boilerplate
struct FatiaDeTorta: Shape {
var anguloInicial: Angle
var anguloFinal: Angle
// Implementação manual de animatableData necessária
var animatableData: AnimatablePair<Double, Double> {
get {
AnimatablePair(anguloInicial.radians, anguloFinal.radians)
}
set {
anguloInicial = Angle(radians: newValue.first)
anguloFinal = Angle(radians: newValue.second)
}
}
func path(in rect: CGRect) -> Path {
var path = Path()
let center = CGPoint(x: rect.midX, y: rect.midY)
let radius = min(rect.width, rect.height) / 2
path.move(to: center)
path.addArc(center: center, radius: radius,
startAngle: anguloInicial, endAngle: anguloFinal,
clockwise: false)
path.closeSubpath()
return path
}
}
Depois do iOS 26 (Com @Animatable)
// NOVA FORMA - Apenas adicione @Animatable
@Animatable
struct FatiaDeTorta: Shape {
var anguloInicial: Angle
var anguloFinal: Angle
func path(in rect: CGRect) -> Path {
var path = Path()
let center = CGPoint(x: rect.midX, y: rect.midY)
let radius = min(rect.width, rect.height) / 2
path.move(to: center)
path.addArc(center: center, radius: radius,
startAngle: anguloInicial, endAngle: anguloFinal,
clockwise: false)
path.closeSubpath()
return path
}
}
@AnimatableIgnored
Exclua propriedades da animação:
@Animatable
struct FormaPersonalizada: Shape {
var valorAnimado: CGFloat
@AnimatableIgnored var configuracaoEstatica: Bool // Não é animado
func path(in rect: CGRect) -> Path {
// Use ambos os valores, mas apenas valorAnimado será animado
}
}
Tipos Suportados para Animação
A macro @Animatable lida automaticamente com:
CGFloat,Double,FloatAngleCGSize,CGPoint,CGRectUnitPointColor(interpolação de componentes)- Tipos personalizados que estejam em conformidade com
VectorArithmetic
Exemplo Complexo com Múltiplas Propriedades
@Animatable
struct FormaMorfavel: Shape {
var raioCanto: CGFloat
var quantidadeInsercao: CGFloat
var rotacao: Angle
@AnimatableIgnored var corPreenchimento: Color
func path(in rect: CGRect) -> Path {
let rectInserido = rect.insetBy(dx: quantidadeInsercao, dy: quantidadeInsercao)
var path = Path(roundedRect: rectInserido, cornerRadius: raioCanto)
let transform = CGAffineTransform(rotationAngle: rotacao.radians)
return path.applying(transform)
}
}
// Uso
struct VisaoMorfavel: View {
@State private var estaExpandido = false
var body: some View {
FormaMorfavel(
raioCanto: estaExpandido ? 50 : 10,
quantidadeInsercao: estaExpandido ? 20 : 50,
rotacao: estaExpandido ? .degrees(45) : .zero,
corPreenchimento: .blue
)
.fill(.blue)
.frame(width: 200, height: 200)
.onTapGesture {
withAnimation(.spring(duration: 0.6, bounce: 0.3)) {
estaExpandido.toggle()
}
}
}
}
withAnimation
Uso Básico
struct ContentView: View {
@State private var estaExpandido = false
var body: some View {
VStack {
Rectangle()
.frame(width: estaExpandido ? 200 : 100,
height: estaExpandido ? 200 : 100)
Button("Alternar") {
withAnimation {
estaExpandido.toggle()
}
}
}
}
}
Com Tipo de Animação
withAnimation(.spring(duration: 0.5, bounce: 0.3)) {
estaExpandido.toggle()
}
withAnimation(.easeInOut(duration: 0.3)) {
opacidade = 1.0
}
withAnimation(.linear(duration: 1.0)) {
progresso = 1.0
}
Manipulador de Conclusão (iOS 17+)
withAnimation(.easeInOut(duration: 0.5)) {
mostrarDetalhes = true
} completion: {
// Chamado quando a animação termina
print("Animação finalizada")
buscarMaisDados()
}
Animações Aninhadas com Tempos Diferentes
Button("Animar") {
withAnimation(.spring(duration: 0.4)) {
estaExpandido = true
}
withAnimation(.easeOut(duration: 0.6).delay(0.2)) {
opacidade = 1.0
}
}
Tipos de Animação
Animações Embutidas
// Linear - velocidade constante
.linear(duration: 0.3)
// Variantes de Ease - aceleração/desaceleração
.easeIn(duration: 0.3) // Início lento
.easeOut(duration: 0.3) // Final lento
.easeInOut(duration: 0.3) // Ambos lentos
// Padrão (ease in/out)
.default
Animações Spring (Modernas)
// Spring moderna com duração e bounce
.spring(duration: 0.5, bounce: 0.3)
// Valores de bounce:
// 0.0 = sem bounce (criticamente amortecido)
// 0.5 = bounce médio
// 1.0 = bounce máximo (nunca estabiliza)
// Parâmetro extra de bounce para ultrapassagem
.spring(duration: 0.5, bounce: 0.4, blendDuration: 0.2)
Presets Spring
// Bouncy - brincalhão, energético
.bouncy
.bouncy(duration: 0.4, extraBounce: 0.1)
// Snappy - rápido, responsivo
.snappy
.snappy(duration: 0.3, extraBounce: 0.05)
// Smooth - suave, elegante
.smooth
.smooth(duration: 0.5, extraBounce: 0.0)
Spring Interativo
// Para animações orientadas a gestos
.interactiveSpring()
.interactiveSpring(response: 0.3, dampingFraction: 0.7)
// Melhor para gestos de arrastar
.interactiveSpring(response: 0.15, dampingFraction: 0.86, blendDuration: 0.25)
Curvas de Tempo Personalizadas
// Curva Bezier de tempo
.timingCurve(0.2, 0.8, 0.2, 1.0, duration: 0.5)
// Parâmetros: (x1, y1, x2, y2)
// Início: (0, 0), Fim: (1, 1)
// Os pontos de controle definem a forma da curva
Modificadores de Animação
// Atraso antes de iniciar
.spring().delay(0.2)
// Multiplicador de velocidade
.spring().speed(2.0) // 2x mais rápido
// Repetir
.linear(duration: 1.0).repeatCount(3)
.linear(duration: 1.0).repeatForever()
// Reversão automática
.easeInOut(duration: 0.5).repeatForever(autoreverses: true)
Modificador de Animação Explícita
Abordagem Preferida
struct ContentView: View {
@State private var escala = 1.0
var body: some View {
Circle()
.scaleEffect(escala)
// Explícita: anima apenas quando a escala muda
.animation(.spring, value: escala)
.onTapGesture {
escala = escala == 1.0 ? 1.5 : 1.0
}
}
}
Por que Explícita é Melhor
// EVITAR: Animação implícita (anima tudo)
Circle()
.animation(.spring) // Aviso de obsoleto em iOS mais recentes
// PREFERIR: Animação explícita (controle preciso)
Circle()
.animation(.spring, value: valorEspecifico)
Múltiplas Animações Explícitas
struct VisaoMultiAnimada: View {
@State private var escala = 1.0
@State private var opacidade = 1.0
@State private var rotacao = 0.0
var body: some View {
Rectangle()
.scaleEffect(escala)
.opacity(opacidade)
.rotationEffect(.degrees(rotacao))
// Animações diferentes para propriedades diferentes
.animation(.bouncy, value: escala)
.animation(.easeOut(duration: 0.2), value: opacidade)
.animation(.spring(duration: 1.0), value: rotacao)
}
}
Transições
Transições Básicas
struct ContentView: View {
@State private var mostrarDetalhe = false
var body: some View {
VStack {
if mostrarDetalhe {
DetalheView()
.transition(.slide)
}
Button("Alternar") {
withAnimation {
mostrarDetalhe.toggle()
}
}
}
}
}
Transições Embutidas
.transition(.opacity) // Aparecer/desaparecer
.transition(.scale) // Escalar do centro
.transition(.scale(scale: 0.5)) // Escalar de 50%
.transition(.slide) // Deslizar da borda inicial
.transition(.move(edge: .top)) // Mover de uma borda específica
.transition(.push(from: .bottom)) // Empurrar com substituição
.transition(.offset(x: 100, y: 0)) // Deslocamento personalizado
Transições Combinadas
// Combinar múltiplas transições
.transition(.scale.combined(with: .opacity))
// Encadear combinações
.transition(
.scale(scale: 0.8)
.combined(with: .opacity)
.combined(with: .offset(y: 20))
)
Transições Assimétricas
// Transições diferentes para inserção vs remoção
.transition(.asymmetric(
insertion: .scale.combined(with: .opacity),
removal: .slide
))
// Padrão comum: deslizar de um lado, sair pelo outro
.transition(.asymmetric(
insertion: .push(from: .trailing),
removal: .push(from: .leading)
))
Transições Personalizadas
extension AnyTransition {
static var virarDeBaixo: AnyTransition {
.modifier(
active: ModificadorVirar(angulo: -90),
identity: ModificadorVirar(angulo: 0)
)
}
}
struct ModificadorVirar: ViewModifier {
let angulo: Double
func body(content: Content) -> some View {
content
.rotation3DEffect(
.degrees(angulo),
axis: (x: 1, y: 0, z: 0)
)
.opacity(angulo == 0 ? 1 : 0)
}
}
// Uso
DetalheView()
.transition(.virarDeBaixo)
PhaseAnimator (iOS 17+)
Uso Básico
enum FaseAnimacao: CaseIterable {
case inicial
case medio
case final
var escala: CGFloat {
switch self {
case .inicial: return 1.0
case .medio: return 1.2
case .final: return 1.0
}
}
var opacidade: Double {
switch self {
case .inicial: return 1.0
case .medio: return 0.5
case .final: return 1.0
}
}
}
struct VisaoPulsante: View {
var body: some View {
PhaseAnimator(FaseAnimacao.allCases) { fase in
Circle()
.fill(.blue)
.scaleEffect(fase.escala)
.opacity(fase.opacidade)
}
}
}
Animação Acionada
struct AnimacaoAcionavel: View {
@State private var acionador = false
var body: some View {
VStack {
PhaseAnimator(
FaseAnimacao.allCases,
trigger: acionador
) { fase in
Star()
.scaleEffect(fase.escala)
.rotationEffect(.degrees(fase.rotacao))
}
Button("Animar") {
acionador.toggle()
}
}
}
}
Animação Personalizada Por Fase
PhaseAnimator(FaseAnimacao.allCases) { fase in
ContentView(fase: fase)
} animation: { fase in
switch fase {
case .inicial: .spring(duration: 0.3)
case .medio: .easeOut(duration: 0.2)
case .final: .bouncy
}
}
KeyframeAnimator (iOS 17+)
Animação Básica com Keyframes
struct ValoresAnimacao {
var escala = 1.0
var rotacao = 0.0
var deslocamentoY = 0.0
}
struct VisaoQuicando: View {
@State private var acionador = false
var body: some View {
Circle()
.fill(.blue)
.frame(width: 100, height: 100)
.keyframeAnimator(
initialValue: ValoresAnimacao(),
trigger: acionador
) { content, valor in
content
.scaleEffect(valor.escala)
.rotationEffect(.degrees(valor.rotacao))
.offset(y: valor.deslocamentoY)
} keyframes: { _ in
KeyframeTrack(\.escala) {
SpringKeyframe(1.2, duration: 0.2)
SpringKeyframe(0.9, duration: 0.15)
SpringKeyframe(1.0, duration: 0.15)
}
KeyframeTrack(\.rotacao) {
LinearKeyframe(0, duration: 0.1)
SpringKeyframe(10, duration: 0.15)
SpringKeyframe(-10, duration: 0.15)
SpringKeyframe(0, duration: 0.1)
}
KeyframeTrack(\.deslocamentoY) {
SpringKeyframe(-30, duration: 0.2)
SpringKeyframe(0, duration: 0.3)
}
}
.onTapGesture {
acionador.toggle()
}
}
}
Tipos de Keyframe
KeyframeTrack(\.valor) {
// Interpolação linear
LinearKeyframe(valorAlvo, duration: 0.3)
// Interpolação baseada em spring
SpringKeyframe(valorAlvo, duration: 0.3)
SpringKeyframe(valorAlvo, duration: 0.3, spring: .bouncy)
// Interpolação cúbica Bezier
CubicKeyframe(valorAlvo, duration: 0.3)
// Mover sem animação
MoveKeyframe(valorAlvo)
}
Animação Complexa com Múltiplos Tracks
struct ValoresAnimacaoComplexa {
var deslocamentoX = 0.0
var deslocamentoY = 0.0
var escala = 1.0
var opacidade = 1.0
var borrao = 0.0
}
struct AnimacaoComplexa: View {
@State private var animando = false
var body: some View {
Image(systemName: "star.fill")
.font(.system(size: 50))
.keyframeAnimator(
initialValue: ValoresAnimacaoComplexa(),
repeating: animando
) { content, valor in
content
.offset(x: valor.deslocamentoX, y: valor.deslocamentoY)
.scaleEffect(valor.escala)
.opacity(valor.opacidade)
.blur(radius: valor.borrao)
} keyframes: { _ in
KeyframeTrack(\.deslocamentoX) {
CubicKeyframe(50, duration: 0.4)
CubicKeyframe(-50, duration: 0.4)
CubicKeyframe(0, duration: 0.4)
}
KeyframeTrack(\.deslocamentoY) {
SpringKeyframe(30, duration: 0.3)
SpringKeyframe(-30, duration: 0.3)
SpringKeyframe(0, duration: 0.3)
}
KeyframeTrack(\.escala) {
LinearKeyframe(1.2, duration: 0.2)
LinearKeyframe(0.8, duration: 0.2)
LinearKeyframe(1.0, duration: 0.2)
}
KeyframeTrack(\.opacidade) {
LinearKeyframe(0.5, duration: 0.3)
LinearKeyframe(1.0, duration: 0.3)
}
KeyframeTrack(\.borrao) {
MoveKeyframe(0)
CubicKeyframe(10, duration: 0.5)
CubicKeyframe(0, duration: 0.5)
}
}
.onTapGesture {
animando.toggle()
}
}
}
Design de Movimento e Melhores Práticas
Princípios de Animação
- Propósito: Animações devem ter um propósito, não apenas serem decorativas.
- Feedback visual: Use animações para confirmar ações do usuário (toques, gestos, mudanças de estado).
- Continuidade: Animações guiam o olhar do usuário e explicam mudanças na interface.
- Desempenho: Prefira animações baseadas em hardware (opacidade, escala, posição, rotação). Evite animar
frameouoffsetem layouts complexos.
Durações Recomendadas
- Micro-interações (toques, feedback): 100-200ms
- Transições de elemento: 200-400ms
- Mudanças de tela: 300-500ms
- Animações expressivas: 500-800ms
Diretrizes de Spring
- Use
.snappypara elementos interativos (botões, gestos). - Use
.smoothpara transições de layout. - Use
.bouncypara animações lúdicas. - Evite bounce excessivo em elementos sérios (alertas e formulários).
Considerações de Acessibilidade
struct ContentView: View {
@Environment(\.accessibilityReduceMotion) var reduzirMovimento
var body: some View {
if reduzirMovimento {
// Transições instantâneas sem animação
} else {
comAnimation { ... }
}
}
}
Marcos de Performance
| Animação | Impacto na GPU | Notas |
|---|---|---|
| Opacidade | Baixo | Mais eficiente, prefira sempre |
| Escala | Baixo | Eficiente, evite escala >3x |
| Rotação 3D | Médio | Pode causar rasterização em dispositivos mais antigos |
| Borrão | Alto | Evite movimentar blur; use apenas para efeitos de foco |
| Sombra | Médio | Prefira sombras pré-renderizadas |
Guia de Referência Rápida
| Recurso | SDK Mínimo | Uso Principal |
|---|---|---|
withAnimation | iOS 13 | Animações de estado declarativas |
Modificador .animation | iOS 13 | Controle de animação explícito |
| Transições | iOS 13 | Animação de entrada/saída de visualizações |
| Spring moderno | iOS 17 | Animações spring físicas com bounce |
PhaseAnimator | iOS 17 | Animações em múltiplas fases |
KeyframeAnimator | iOS 17 | Animações complexas baseadas em keyframes |
@Animatable | iOS 26 | Formas animáveis automáticas sem boilerplate |
Armadilhas Comuns
- Usar animação implícita em vez de explícita: Sempre prefira
.animation(_:value:). - Animar muitas visualizações de uma vez: Mantenha o número de visualizações animadas simultâneas baixo.
- Ignorar redução de movimento: Sempre respeite as preferências de acessibilidade.
- Durações de animação inconsistentes: Use tempos consistentes para interações similares.
- Animar propriedades caras: Evite animar
frame,offsetoushadowem loops de alta frequência.