Animations Flutter
Vue d'ensemble
Créez des animations fluides et performantes dans Flutter en utilisant la bonne approche pour chaque cas d'usage. Cette compétence couvre le workflow complet d'animation : du choix entre approches implicites/explicites à l'implémentation d'effets complexes comme les transitions héroïques et les animations en escalier.
Arbre de décision du type d'animation
Choisissez le bon type d'animation selon vos besoins :
Animations implicites - À utiliser quand :
- Vous animez une seule propriété (couleur, taille, position)
- L'animation est déclenchée par un changement d'état
- Aucun contrôle fin n'est nécessaire
Animations explicites - À utiliser quand :
- Vous avez besoin d'un contrôle total sur le cycle de vie de l'animation
- Vous animez plusieurs propriétés simultanément
- Vous devez réagir aux changements d'état de l'animation
- Vous créez des animations ou transitions personnalisées
Animations héroïques - À utiliser quand :
- Vous partagez un élément entre deux écrans
- Vous créez des transitions d'éléments partagés
- L'utilisateur s'attend à ce que l'élément "vole" entre les routes
Animations en escalier - À utiliser quand :
- Plusieurs animations doivent s'exécuter séquentiellement ou se chevaucher
- Vous créez des effets d'ondulation ou de révélations séquentielles
- Vous animez des éléments de liste en séquence
Animations basées sur la physique - À utiliser quand :
- Les animations doivent sembler naturelles/physiques
- Comportement de ressort, gestes de défilement
- Interactions déplaçables
Animations implicites
Les animations implicites gèrent automatiquement l'animation lorsque les propriétés changent. Aucun contrôleur n'est nécessaire.
Widgets implicites courants
AnimatedContainer - Anime plusieurs propriétés (taille, couleur, décoration, padding) :
AnimatedContainer(
duration: const Duration(milliseconds: 300),
curve: Curves.easeInOut,
width: _expanded ? 200 : 100,
height: _expanded ? 200 : 100,
color: _expanded ? Colors.blue : Colors.red,
child: const FlutterLogo(),
)
AnimatedOpacity - Animation de fondu simple :
AnimatedOpacity(
opacity: _visible ? 1.0 : 0.0,
duration: const Duration(milliseconds: 300),
child: const Text('Hello'),
)
TweenAnimationBuilder - Animation Tween personnalisée sans code superflu :
TweenAnimationBuilder<double>(
tween: Tween<double>(begin: 0, end: 1),
duration: const Duration(seconds: 1),
builder: (context, value, child) {
return Opacity(
opacity: value,
child: Transform.scale(
scale: value,
child: child,
),
);
},
child: const FlutterLogo(),
)
Autres widgets implicites :
AnimatedPadding- Animation de paddingAnimatedPositioned- Animation de position (dans Stack)AnimatedAlign- Animation d'alignementAnimatedContainer- Propriétés multiplesAnimatedSwitcher- Transition croisée entre widgetsAnimatedDefaultTextStyle- Animation de style de texte
Bonnes pratiques
- Préférez les animations implicites pour les cas simples
- Utilisez des courbes appropriées pour un mouvement naturel (voir la classe
Curves) - Définissez
curveetdurationpour un comportement prévisible - Utilisez le callback
onEndsi nécessaire - Évitez les animations implicites imbriquées pour les performances
Animations explicites
Les animations explicites offrent un contrôle total avec AnimationController.
Composants principaux
AnimationController - Pilote l'animation :
late AnimationController _controller;
@override
void initState() {
super.initState();
_controller = AnimationController(
duration: const Duration(seconds: 2),
vsync: this,
);
}
@override
void dispose() {
_controller.dispose();
super.dispose();
}
Tween - Interpole entre les valeurs de début et de fin :
animation = Tween<double>(begin: 0, end: 300).animate(_controller);
CurvedAnimation - Applique une courbe à l'animation :
animation = CurvedAnimation(
parent: _controller,
curve: Curves.easeInOut,
);
Motif AnimatedWidget
Idéal pour les widgets animés réutilisables :
class AnimatedLogo extends AnimatedWidget {
const AnimatedLogo({super.key, required Animation<double> animation})
: super(listenable: animation);
@override
Widget build(BuildContext context) {
final animation = listenable as Animation<double>;
return Center(
child: Container(
height: animation.value,
width: animation.value,
child: const FlutterLogo(),
),
);
}
}
Motif AnimatedBuilder
Idéal pour les widgets complexes avec animations :
class GrowTransition extends StatelessWidget {
const GrowTransition({
required this.child,
required this.animation,
super.key,
});
final Widget child;
final Animation<double> animation;
@override
Widget build(BuildContext context) {
return Center(
child: AnimatedBuilder(
animation: animation,
builder: (context, child) {
return SizedBox(
height: animation.value,
width: animation.value,
child: child,
);
},
child: child,
),
);
}
}
Surveillance de l'état de l'animation
animation.addStatusListener((status) {
switch (status) {
case AnimationStatus.completed:
_controller.reverse();
break;
case AnimationStatus.dismissed:
_controller.forward();
break;
default:
break;
}
});
Animations simultanées multiples
class AnimatedLogo extends AnimatedWidget {
const AnimatedLogo({super.key, required Animation<double> animation})
: super(listenable: animation);
static final _opacityTween = Tween<double>(begin: 0.1, end: 1);
static final _sizeTween = Tween<double>(begin: 0, end: 300);
@override
Widget build(BuildContext context) {
final animation = listenable as Animation<double>;
return Center(
child: Opacity(
opacity: _opacityTween.evaluate(animation),
child: Container(
height: _sizeTween.evaluate(animation),
width: _sizeTween.evaluate(animation),
child: const FlutterLogo(),
),
),
);
}
}
Transitions explicites intégrées
Flutter fournit des transitions prêtes à l'emploi :
FadeTransition- Animation de fonduScaleTransition- Animation d'échelleSlideTransition- Animation de glissementSizeTransition- Animation de tailleRotationTransition- Animation de rotationPositionedTransition- Animation de position (dans Stack)
Exemple :
FadeTransition(
opacity: _animation,
child: const FlutterLogo(),
)
Conseils de performance
- Disposez les contrôleurs lorsque le widget est retiré
- Utilisez
AnimatedBuilderpour des reconstructions optimales - Évitez
setState()dans les écouteurs d'animation (utilisezAnimatedWidget/AnimatedBuilder) - Utilisez
timeDilationpour ralentir les animations pendant le débogage
Animations héroïques
Les animations héroïques créent des transitions d'éléments partagés entre les écrans.
Animation héroïque de base
Écran source :
Hero(
tag: 'hero-image',
child: Image.asset('images/logo.png'),
)
Écran de destination :
Hero(
tag: 'hero-image', // Même tag !
child: Image.asset('images/logo.png'),
)
Exemple complet
class PhotoHero extends StatelessWidget {
const PhotoHero({
super.key,
required this.photo,
this.onTap,
required this.width,
});
final String photo;
final VoidCallback? onTap;
final double width;
@override
Widget build(BuildContext context) {
return SizedBox(
width: width,
child: Hero(
tag: photo,
child: Material(
color: Colors.transparent,
child: InkWell(
onTap: onTap,
child: Image.asset(photo, fit: BoxFit.contain),
),
),
),
);
}
}
Navigation entre les écrans :
Navigator.of(context).push(
MaterialPageRoute<void>(
builder: (context) {
return Scaffold(
appBar: AppBar(title: const Text('Détail')),
body: Center(
child: PhotoHero(
photo: 'images/logo.png',
width: 300.0,
onTap: () => Navigator.of(context).pop(),
),
),
);
},
),
);
Animation héroïque radiale
Transformez un cercle en rectangle pendant la transition :
class RadialExpansion extends StatelessWidget {
const RadialExpansion({
super.key,
required this.maxRadius,
this.child,
}) : clipRectSize = 2.0 * (maxRadius / math.sqrt2);
final double maxRadius;
final double clipRectSize;
final Widget? child;
@override
Widget build(BuildContext context) {
return ClipOval(
child: Center(
child: SizedBox(
width: clipRectSize,
height: clipRectSize,
child: ClipRect(child: child),
),
),
);
}
}
Utilisation avec MaterialRectCenterArcTween pour une interpolation centrée :
static RectTween _createRectTween(Rect? begin, Rect? end) {
return MaterialRectCenterArcTween(begin: begin, end: end);
}
Bonnes pratiques pour les héros
- Utilisez des tags uniques et cohérents (souvent l'objet de données lui-même)
- Gardez les arbres de widgets héros similaires entre les routes
- Enveloppez les images dans
Materialavec une couleur transparente pour un effet "pop" - Utilisez
timeDilationpour déboguer les transitions - Considérez
HeroModepour désactiver les animations héroïques si nécessaire
Animations en escalier
Exécutez plusieurs animations avec un timing différent.
Animation en escalier de base
Toutes les animations partagent un contrôleur :
class StaggerAnimation extends StatelessWidget {
StaggerAnimation({super.key, required this.controller})
: opacity = Tween<double>(begin: 0.0, end: 1.0).animate(
CurvedAnimation(
parent: controller,
curve: const Interval(0.0, 0.100, curve: Curves.ease),
),
),
width = Tween<double>(begin: 50.0, end: 150.0).animate(
CurvedAnimation(
parent: controller,
curve: const Interval(0.125, 0.250, curve: Curves.ease),
),
);
final AnimationController controller;
final Animation<double> opacity;
final Animation<double> width;
Widget _buildAnimation(BuildContext context, Widget? child) {
return Container(
alignment: Alignment.bottomCenter,
child: Opacity(
opacity: opacity.value,
child: Container(
width: width.value,
height: 150,
color: Colors.blue,
),
),
);
}
@override
Widget build(BuildContext context) {
return AnimatedBuilder(
animation: controller,
builder: _buildAnimation,
);
}
}
Timing basé sur les intervalles
Chaque animation a un Intervalle entre 0.0 et 1.0 :
animation = Tween<double>(begin: 0, end: 300).animate(
CurvedAnimation(
parent: controller,
curve: const Interval(
0.25, // Démarre à 25% de la durée du contrôleur
0.50, // Se termine à 50% de la durée du contrôleur
curve: Curves.ease,
),
),
);
Tweens courants
borderRadius = BorderRadiusTween(
begin: BorderRadius.circular(4),
end: BorderRadius.circular(75),
).animate(
CurvedAnimation(
parent: controller,
curve: const Interval(0.375, 0.500, curve: Curves.ease),
),
);
Animation de menu en escalier
class _MenuState extends State<Menu> with SingleTickerProviderStateMixin {
static const _initialDelayTime = Duration(milliseconds: 50);
static const _itemSlideTime = Duration(milliseconds: 250);
static const _staggerTime = Duration(milliseconds: 50);
static const _buttonDelayTime = Duration(milliseconds: 150);
static const _buttonTime = Duration(milliseconds: 500);
final _animationDuration =
_initialDelayTime +
(_staggerTime * _menuTitles.length) +
_buttonDelayTime +
_buttonTime;
late AnimationController _controller;
@override
void initState() {
super.initState();
_controller = AnimationController(
duration: _animationDuration,
vsync: this,
);
_controller.forward();
}
@override
void dispose() {
_controller.dispose();
super.dispose();
}
}
Bonnes pratiques pour les escaliers
- Utilisez
Intervalpour décaler les animations dans le temps - Assurez-vous que la durée du contrôleur couvre tous les intervalles
- Utilisez des courbes pour un mouvement naturel dans les intervalles
- Considérez
timeDilationpour déboguer le timing - Décalez les éléments de menu avec un délai croissant pour un effet d'ondulation
Animations basées sur la physique
Créez des animations naturelles en utilisant des simulations physiques.
Animation de lancer
_controller.fling(
velocity: 2.0, // Unités par seconde
);
Simulation physique personnalisée
_controller.animateWith(
SpringSimulation(
spring: const SpringDescription(
mass: 1,
stiffness: 100,
damping: 10,
),
start: 0.0,
end: 1.0,
velocity: 0.0,
),
);
Simulations physiques courantes
SpringSimulation- Physique de ressortBouncingScrollSimulation- Défilement avec rebondClampingScrollSimulation- Défilement sans rebondGravitySimulation- Basée sur la gravité
Bonnes pratiques
À FAIRE
- Disposez AnimationController lors de la suppression du widget
- Utilisez
AnimatedBuilder/AnimatedWidgetau lieu desetState()dans les écouteurs - Choisissez des courbes appropriées pour un mouvement naturel
- Utilisez
timeDilationpour déboguer les animations - Tenez compte des performances (évitez les widgets lourds dans les builds d'animation)
- Testez les animations sur différents appareils
- Prenez en charge les animations inverses pour un rendu intuitif
À NE PAS FAIRE
- N'oubliez pas de disposer AnimationController (fuite mémoire)
- N'utilisez pas
setState()dans les écouteurs d'animation quandAnimatedBuildersuffit - Ne supposez pas que l'animation se termine instantanément (gérez
AnimationStatus) - N'animez pas trop (les animations peuvent distraire les utilisateurs)
- Ne créez pas d'animations saccadées (utilisez des courbes lisses)
- N'ignorez pas l'accessibilité (respectez la préférence
disableAnimations)
Ressources
references/
implicit.md - Référence complète pour les widgets d'animation implicite avec exemples et bonnes pratiques.
explicit.md - Plongée approfondie dans les animations explicites, AnimationController et motifs.
hero.md - Guide des animations héroïques avec transitions standard et radiales.
staggered.md - Motifs d'animations en escalier et stratégies de timing.
physics.md - Animations basées sur la physique et simulations.
curves.md - Référence pour la classe Curves et choix de courbes appropriées.