Animation SwiftUI
Aperçu
Guide complet du système d'animation de SwiftUI, des concepts fondamentaux aux techniques avancées. Ce skill couvre le protocole Animatable, la macro @Animatable (iOS 26), les types d'animations et le système de Transaction.
Principe fondamental : L'animation dans SwiftUI est une interpolation mathématique dans le temps, alimentée par le protocole VectorArithmetic. Comprendre cette fondation déverrouille toute la puissance du système d'animation déclaratif de SwiftUI.
Configuration système requise
- iOS 13+ : Protocole Animatable, animations temporelles/ressort
- iOS 17+ : Animations ressort par défaut, animations scopées, PhaseAnimator, KeyframeAnimator
- iOS 18+ : Transitions de zoom, pont d'animation UIKit/AppKit
- iOS 26+ : Macro @Animatable
Partie 1 : Comprendre l'Animation
Qu'est-ce que l'Interpolation
L'animation est le processus de génération de valeurs intermédiaires entre un état de départ et un état d'arrivée.
Exemple : Animation d'opacité
.opacity(0) → .opacity(1)
Pendant que cette animation s'exécute, SwiftUI calcule des valeurs intermédiaires :
0.0 → 0.02 → 0.05 → 0.1 → 0.25 → 0.4 → 0.6 → 0.8 → 1.0
Comment les valeurs sont distribuées
- Déterminé par la courbe temporelle ou la fonction de vélocité de l'animation
- Les animations ressort utilisent une simulation physique
- Les courbes temporelles utilisent des courbes de Bézier
- Chaque type d'animation calcule les valeurs différemment
Protocole VectorArithmetic
SwiftUI exige que les données animées soient conformes à VectorArithmetic — fournissant la soustraction, la mise à l'échelle, l'addition et une valeur nulle. Cela permet à SwiftUI d'interpoler entre deux valeurs quelconques.
Types conformes intégrés : CGFloat, Double, Float, Angle (1D), CGPoint, CGSize (2D), CGRect (4D).
Point clé : L'arithmétique vectorielle fait abstraction de la dimensionnalité. SwiftUI anime tous ces types avec une seule implémentation générique.
Pourquoi Int ne peut pas être animé
Int n'est pas conforme à VectorArithmetic — il n'existe pas d'intermédiaires fractionnaires entre 3 et 4. SwiftUI change simplement la valeur brusquement.
Solution : Utilisez Float/Double et affichez comme Int :
@State private var count: Float = 0
// ...
Text("\(Int(count))")
.animation(.spring, value: count)
Valeurs de Modèle vs de Présentation
Les attributs animables ont conceptuellement deux valeurs :
Valeur de Modèle
- La valeur cible définie par votre code
- Mise à jour immédiatement lorsque l'état change
- Ce que vous écrivez dans le corps de votre vue
Valeur de Présentation
- La valeur interpolée actuelle en cours de rendu
- Mise à jour image par image pendant l'animation
- Ce que l'utilisateur voit réellement
Exemple
.scaleEffect(selected ? 1.5 : 1.0)
Lorsque selected devient true :
- Valeur de modèle : devient immédiatement
1.5 - Valeur de présentation : interpole
1.0 → 1.1 → 1.2 → 1.3 → 1.4 → 1.5au fil du temps
Partie 2 : Protocole Animatable
Aperçu
Le protocole Animatable permet aux vues d'animer leurs propriétés en définissant quelles données doivent être interpolées.
protocol Animatable {
associatedtype AnimatableData: VectorArithmetic
var animatableData: AnimatableData { get set }
}
SwiftUI crée un attribut animable pour toute vue conforme à ce protocole.
Vues Animables Intégrées
De nombreux modificateurs SwiftUI sont conformes à Animatable :
Effets visuels
.scaleEffect()— Anime la transformation d'échelle.rotationEffect()— Anime la rotation.offset()— Anime le décalage de position.opacity()— Anime la transparence.blur()— Anime le rayon de flou.shadow()— Anime les propriétés d'ombre
Tous les types Shape
Circle,Rectangle,RoundedRectangleCapsule,Ellipse,Path- Implémentations personnalisées de
Shape
AnimatablePair pour les Données Multidimensionnelles
Lors de l'animation de plusieurs propriétés, utilisez AnimatablePair pour combiner des vecteurs. Par exemple, scaleEffect combine CGSize (2D) et UnitPoint (2D) en un vecteur 4D via AnimatablePair<CGSize.AnimatableData, UnitPoint.AnimatableData>. Accédez aux composants via .first et .second. La macro @Animatable (iOS 26+) élimine complètement ce code répétitif.
Conformité Animatable Personnalisée
Quand l'utiliser
- Animer une mise en page personnalisée (comme RadialLayout)
- Animer du code de dessin personnalisé
- Animer des propriétés qui affectent les chemins de forme
Exemple : Vue de nombre animée
struct AnimatableNumberView: View, Animatable {
var number: Double
var animatableData: Double {
get { number }
set { number = newValue }
}
var body: some View {
Text("\(Int(number))")
.font(.largeTitle)
}
}
// Utilisation
AnimatableNumberView(number: value)
.animation(.spring, value: value)
Comment ça fonctionne
numberpasse de 0 à 100- SwiftUI appelle
bodypour chaque image de l'animation - Chaque image reçoit une nouvelle valeur
number: 0 → 5 → 15 → 30 → 55 → 80 → 100 - Le texte se met à jour pour afficher l'entier interpolé
Avertissement sur les Performances
La conformité Animatable personnalisée est coûteuse — SwiftUI appelle body pour chaque image sur le thread principal. Les effets intégrés (.scaleEffect(), .opacity()) s'exécutent hors du thread principal et n'appellent pas body. Utilisez la conformité personnalisée uniquement lorsque les modificateurs intégrés ne peuvent pas réaliser l'effet (par exemple, animer une Layout personnalisée qui repositionne les sous-vues image par image).
Partie 3 : Macro @Animatable (iOS 26+)
Aperçu
La macro @Animatable élimine le code répétitif lié à la conformité manuelle au protocole Animatable.
Avant iOS 26, vous deviez :
- Être manuellement conforme à
Animatable - Écrire le getter et le setter de
animatableData - Utiliser
AnimatablePairpour plusieurs propriétés - Exclure manuellement les propriétés non animables
iOS 26+, il suffit d'ajouter @Animatable :
@MainActor
@Animatable
struct MyView: View {
var scale: CGFloat
var opacity: Double
var body: some View {
// ...
}
}
La macro automatiquement :
- Génère la conformité
Animatable - Inspecte toutes les propriétés stockées
- Crée
animatableDataà partir des propriétés conformes à VectorArithmetic - Gère les données multidimensionnelles avec
AnimatablePair
Comparaison Avant/Après
Avant la macro @Animatable
struct HikingRouteShape: Shape {
var startPoint: CGPoint
var endPoint: CGPoint
var elevation: Double
var drawingDirection: Bool // On ne veut pas animer ceci
// Déclaration manuelle fastidieuse de animatableData
var animatableData: AnimatablePair<AnimatablePair<CGFloat, CGFloat>,
AnimatablePair<Double, AnimatablePair<CGFloat, CGFloat>>> {
get {
AnimatablePair(
AnimatablePair(startPoint.x, startPoint.y),
AnimatablePair(elevation, AnimatablePair(endPoint.x, endPoint.y))
)
}
set {
startPoint = CGPoint(x: newValue.first.first, y: newValue.first.second)
elevation = newValue.second.first
endPoint = CGPoint(x: newValue.second.second.first, y: newValue.second.second.second)
}
}
func path(in rect: CGRect) -> Path {
// Code de dessin
}
}
Après la macro @Animatable
@Animatable
struct HikingRouteShape: Shape {
var startPoint: CGPoint
var endPoint: CGPoint
var elevation: Double
@AnimatableIgnored
var drawingDirection: Bool // Exclu de l'animation
func path(in rect: CGRect) -> Path {
// Code de dessin
}
}
Lignes de code : 20 → 12 (réduction de 40%)
@AnimatableIgnored
Utilisez @AnimatableIgnored pour exclure des propriétés de l'animation.
Quand l'utiliser
- Valeurs de débogage — Indicateurs réservés au développement
- Identifiants — Identifiants qui ne doivent pas être animés
- Horodatages — Quand la vue a été créée/mise à jour
- État interne — Comptabilité non visuelle
- Types non VectorArithmetic — Couleurs, chaînes, booléens
Exemple
@MainActor
@Animatable
struct ProgressView: View {
var progress: Double // Animé
var totalItems: Int // Animé (si Float, pas si Int)
@AnimatableIgnored
var title: String // Non animé
@AnimatableIgnored
var startTime: Date // Non animé
@AnimatableIgnored
var debugEnabled: Bool // Non animé
var body: some View {
VStack {
Text(title)
ProgressBar(value: progress)
if debugEnabled {
Text("Démarré : \(startTime.formatted())")
}
}
}
}
Cas d'Utilisation Réel
@Animatable fonctionne pour tout affichage numérique — prix d'actions, fréquence cardiaque, scores, minuteurs, barres de progression :
@MainActor
@Animatable
struct AnimatedValueView: View {
var value: Double
var changePercent: Double
@AnimatableIgnored
var label: String
var body: some View {
VStack(alignment: .trailing) {
Text("\(value, format: .number.precision(.fractionLength(2)))")
.font(.title)
Text("\(changePercent > 0 ? "+" : "")\(changePercent, format: .percent)")
.foregroundStyle(changePercent > 0 ? .green : .red)
}
}
}
// Utilisation
AnimatedValueView(value: currentPrice, changePercent: 0.025, label: "Price")
.animation(.spring(duration: 0.8), value: currentPrice)
Partie 4 : Types d'Animation
Animations par Courbes Temporelles
Les animations par courbes temporelles utilisent des courbes de Bézier pour contrôler la vitesse de l'animation dans le temps.
Préréglages intégrés
.animation(.linear) // Vitesse constante
.animation(.easeIn) // Commence lentement, finit vite
.animation(.easeOut) // Commence vite, finit lentement
.animation(.easeInOut) // Début et fin lents, milieu rapide
Courbes temporelles personnalisées
let customCurve = UnitCurve(
startControlPoint: CGPoint(x: 0.2, y: 0),
endControlPoint: CGPoint(x: 0.8, y: 1)
)
.animation(.timingCurve(customCurve, duration: 0.5))
Durée
Toutes les animations par courbes temporelles acceptent une durée optionnelle :
.animation(.easeInOut(duration: 0.3))
.animation(.linear(duration: 1.0))
Par défaut : 0,35 seconde
Animations Ressort
Les animations ressort utilisent une simulation physique pour créer un mouvement naturel et organique.
Préréglages intégrés
.animation(.smooth) // Pas de rebond (par défaut depuis iOS 17)
.animation(.snappy) // Petite quantité de rebond
.animation(.bouncy) // Plus grande quantité de rebond
Ressorts personnalisés
.animation(.spring(duration: 0.6, bounce: 0.3))
Paramètres
duration— Durée perçue de l'animationbounce— Quantité de rebond (0 = pas de rebond, 1 = très rebondissant)
Beaucoup plus intuitif que les paramètres de ressort traditionnels (masse, rigidité, amortissement).
Animations d'Ordre Supérieur
Modifiez les animations de base pour créer des effets complexes.
Délai
.animation(.spring.delay(0.5))
Attend 0,5 seconde avant de démarrer l'animation.
Répétition
.animation(.easeInOut.repeatCount(3, autoreverses: true))
.animation(.linear.repeatForever(autoreverses: false))
Répète l'animation plusieurs fois ou indéfiniment.
Vitesse
.animation(.spring.speed(2.0)) // 2x plus rapide
.animation(.spring.speed(0.5)) // 2x plus lent
Multiplie la vitesse de l'animation.
Changements d'Animation par Défaut (iOS 17+)
Avant iOS 17
withAnimation {
// Utilisait une courbe temporelle par défaut
}
iOS 17+
withAnimation {
// Utilise le ressort .smooth par défaut
}
Pourquoi ce changement : Les animations ressort semblent plus naturelles et préservent la vélocité lorsqu'elles sont interrompues.
Recommandation : Adoptez les ressorts. Ils rendent votre interface plus réactive et soignée.
Partie 5 : Système de Transaction
withAnimation
La façon la plus courante de déclencher une animation.
Button("Agrandir") {
withAnimation(.spring) {
scale = 1.5
}
}
Comment ça fonctionne
withAnimationouvre une transaction- Définit l'animation dans le dictionnaire de la transaction
- Exécute la fermeture (changements d'état)
- La transaction se propage dans la hiérarchie des vues
- Les attributs animables vérifient l'animation et interpole
Animation explicite
withAnimation(.spring(duration: 0.6, bounce: 0.4)) {
isExpanded.toggle()
}
Pas d'animation
withAnimation(nil) {
// Les changements se produisent immédiatement, pas d'animation
resetState()
}
Modificateur animation() de Vue
Appliquez des animations à des valeurs spécifiques dans une vue.
Utilisation de base
Circle()
.fill(isActive ? .blue : .gray)
.animation(.spring, value: isActive)
Comment ça fonctionne : L'animation ne s'applique que lorsque isActive change. Les autres changements d'état ne déclencheront pas cette animation.
Plusieurs animations sur la même vue
Circle()
.scaleEffect(scale)
.animation(.bouncy, value: scale)
.opacity(opacity)
.animation(.easeInOut, value: opacity)
Différentes animations pour différentes propriétés.
Animations Scopées (iOS 17+)
Limitez étroitement les animations à des attributs animables spécifiques.
Problème avec l'ancienne approche
struct AvatarView: View {
var selected: Bool
var body: some View {
Image("avatar")
.scaleEffect(selected ? 1.5 : 1.0)
.animation(.spring, value: selected)
// ⚠️ Si l'image change aussi lorsque selected change,
// la transition d'image est également animée (accidentellement)
}
}
Solution : Animation scopée
struct AvatarView: View {
var selected: Bool
var body: some View {
Image("avatar")
.animation(.spring, value: selected) {
$0.scaleEffect(selected ? 1.5 : 1.0)
}
// ✅ Seul scaleEffect est animé, la transition d'image ne l'est pas
}
}
Comment ça fonctionne
- L'animation ne s'applique qu'aux attributs dans la fermeture
- Les autres attributs ne sont pas affectés
- Empêche les animations accidentelles
Clés de Transaction Personnalisées
Définissez des types TransactionKey personnalisés pour propager le contexte à travers le système de transaction. Utilisez withTransaction pour définir des valeurs et le modificateur .transaction pour les lire. Cela permet d'appliquer différentes animations selon la façon dont un changement d'état a été déclenché (tap vs programmatique).
Partie 6 : Sujets Avancés
Protocole CustomAnimation
Impl
... (le texte original a été tronqué, merci de fournir le contenu complet si vous souhaitez que je continue la traduction)