Communitygithub.com

AnimationsFlutter

Guide complet pour implémenter des animations dans Flutter. À utiliser pour ajouter du mouvement et des effets visuels aux applications Flutter : animations implicites (AnimatedContainer, AnimatedOpacity, TweenAnimationBuilder), animations explicites (AnimationController, Tween, AnimatedWidget/AnimatedBuilder), animations héroïques (transitions d'éléments partagés), animations en escalier (séquentielles/chevauchantes) et animations basées sur la physique. Comprend un workflow pour choisir le bon type d'animation, des motifs d'implémentation et des bonnes pratiques pour les performances et l'expérience utilisateur.

Qu'est-ce que AnimationsFlutter ?

Cette compétence fournit un guide exhaustif pour créer des animations dans Flutter, en couvrant les approches implicites, explicites, héroïques, en escalier et basées sur la physique. Elle aide les développeurs à choisir le type d'animation approprié en fonction de leurs besoins (par exemple, animation d'une seule propriété, contrôle complet du cycle de vie, transitions d'éléments partagés entre écrans). Le guide inclut des exemples de code détaillés, des diagrammes de décision pour la sélection du type d'animation, et des bonnes pratiques pour les performances et l'accessibilité. Il est destiné aux développeurs travaillant avec Flutter sur tout IDE supportant le langage, et se base sur les widgets et API natifs de Flutter. Il explique comment utiliser des widgets comme AnimatedContainer, AnimationController, Hero, et des simulations physiques pour des animations naturelles.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ComeOnOliver/skillshub/tree/HEAD/skills/aiskillstore/marketplace/madteacher/flutter-animations

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

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 padding
  • AnimatedPositioned - Animation de position (dans Stack)
  • AnimatedAlign - Animation d'alignement
  • AnimatedContainer - Propriétés multiples
  • AnimatedSwitcher - Transition croisée entre widgets
  • AnimatedDefaultTextStyle - 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 curve et duration pour un comportement prévisible
  • Utilisez le callback onEnd si 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 fondu
  • ScaleTransition - Animation d'échelle
  • SlideTransition - Animation de glissement
  • SizeTransition - Animation de taille
  • RotationTransition - Animation de rotation
  • PositionedTransition - 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 AnimatedBuilder pour des reconstructions optimales
  • Évitez setState() dans les écouteurs d'animation (utilisez AnimatedWidget/AnimatedBuilder)
  • Utilisez timeDilation pour 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 Material avec une couleur transparente pour un effet "pop"
  • Utilisez timeDilation pour déboguer les transitions
  • Considérez HeroMode pour 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 Interval pour 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 timeDilation pour 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 ressort
  • BouncingScrollSimulation - Défilement avec rebond
  • ClampingScrollSimulation - Défilement sans rebond
  • GravitySimulation - Basée sur la gravité

Bonnes pratiques

À FAIRE

  • Disposez AnimationController lors de la suppression du widget
  • Utilisez AnimatedBuilder/AnimatedWidget au lieu de setState() dans les écouteurs
  • Choisissez des courbes appropriées pour un mouvement naturel
  • Utilisez timeDilation pour 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 quand AnimatedBuilder suffit
  • 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.

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

ComeOnOliver/skillshub

Create stunning, animation-rich HTML presentations from scratch or by converting PowerPoint files. Use when the user wants to build a presentation, convert a PPT/PPTX to web, or create slides for a talk/pitch. Helps non-designers discover their aesthetic through visual exploration rather than abstract choices.

ComeOnOliver/skillshub

Next.js 16+ 和 Turbopack — 增量打包、文件系统缓存、开发速度,以及何时使用 Turbopack 与 webpack。

ComeOnOliver/skillshub

SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

ComeOnOliver/skillshub

See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio, video), and create real time alerts for events from live streams or desktop capture.

ComeOnOliver/skillshub

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

ComeOnOliver/skillshub

Next.js 15 애플리케이션을 위한 프론트엔드 개발 가이드라인. React 19, TypeScript, Shadcn/ui, Tailwind CSS를 사용한 모던 패턴. Server Components, Client Components, App Router, 파일 구조, Shadcn/ui 컴포넌트, 성능 최적화, TypeScript 모범 사례 포함. 컴포넌트, 페이지, 기능 생성, 데이터 페칭, 스타일링, 라우팅, 프론트엔드 코드 작업 시 사용.

ComeOnOliver/skillshub

Provides Tamagui patterns for config v4, compiler optimization, styled context, and cross-platform styling. Must use when working with Tamagui projects (tamagui.config.ts, @tamagui imports).

ComeOnOliver/skillshub

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

ComeOnOliver/skillshub

Create high-converting, visually distinctive landing pages. Use when building marketing pages, product launches, SaaS homepages, or any single-page conversion-focused website. Guides section-by-section composition with anti-AI-slop principles.

ComeOnOliver/skillshub

Auto-loaded context for Portfolio Buddy 2 development. Use for ANY task involving: React 19 development, TypeScript, portfolio analysis features, metrics calculations, trading strategy comparison, or working with the Portfolio Buddy 2 codebase. Contains tech stack, known issues, and architectural constraints.

ComeOnOliver/skillshub

Next.js development tooling via MCP. Inspect routes, components, build info, and debug Next.js apps. Use when working on Next.js applications, debugging routing, or inspecting app structure. NOT for general React or non-Next.js projects.

ComeOnOliver/skillshub

Implement UI using Shadcn MCP (atoms/theme) and 21st.dev MCP (complex sections). Use when adding buttons, layouts, or generating landing pages.

ComeOnOliver/skillshub

A conceptual skill for building an API client in Next.js that handles JWT tokens

ComeOnOliver/skillshub

Best practices and patterns for Next.js App Router, Server Actions, and Routing in this project.

ComeOnOliver/skillshub

The Design System, Theme, and UX rules for the Physical AI Hub.

ComeOnOliver/skillshub

Comprehensive frontend development skill for building modern, performant web applications using ReactJS, NextJS, TypeScript, Tailwind CSS. Includes component scaffolding, performance optimization, bundle analysis, and UI best practices. Use when developing frontend features, optimizing performance, implementing UI/UX designs, managing state, or reviewing frontend code.

ComeOnOliver/skillshub

This document captures learnings from fixing keyboard navigation issues when floating components (Select, DropdownMenu, Popover) have CSS open/close animations.

ComeOnOliver/skillshub

Build Next.js 16 applications with correct patterns and distinctive design. Use when creating pages, layouts, dynamic routes, upgrading from Next.js 15, or implementing proxy.ts. Covers breaking changes (async params/searchParams, Turbopack, cacheComponents) and frontend aesthetics. NOT when building non-React or backend-only applications.

ComeOnOliver/skillshub

Comprehensive Framer Motion animation library for React. Covers motion components, variants, gestures, page transitions, and scroll animations. Use when adding animations to React/Next.js applications.

ComeOnOliver/skillshub

Build interfaces that resonate, not just render. This skill enforces bold, intentional

Skills associés