Bases de l'animation Flutter

Cette section présente la mise en œuvre des animations dans Flutter, y compris les animations implicites et les animations explicites.


Animation implicite

Les animations implicites sont des Widgets d'animation où Flutter gère automatiquement les effets de transition.

Exemple : AnimatedContainer

class AnimatedContainerExample extends StatefulWidget {
  const AnimatedContainerExample({super.key});

  @override
  State<AnimatedContainerExample> createState() =>
      _AnimatedContainerExampleState();
}

class _AnimatedContainerExampleState
    extends State<AnimatedContainerExample> {
  bool _isLarge = false;

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        // Cliquez pour basculer la taille
        GestureDetector(
          onTap: () => setState(() => _isLarge = !_isLarge),
          child: AnimatedContainer(
            duration: const Duration(milliseconds: 500),  // Durée de l'animation
            curve: Curves.easeInOut,  // Courbe d'animation
            width: _isLarge ? 200 : 100,
            height: _isLarge ? 200 : 100,
            color: _isLarge ? Colors.blue : Colors.red,
            child: Center(
              child: Text(
                _isLarge ? 'grand' : 'petit',
                style: const TextStyle(color: Colors.white, fontSize: 24),
              ),
            ),
          ),
        ),
        const SizedBox(height: 20),
        ElevatedButton(
          onPressed: () => setState(() => _isLarge = !_isLarge),
          child: const Text('Switch'),
        ),
      ],
    );
  }
}

Widgets d'animation implicite courants

WidgetDescription
AnimatedContainerAnimations lorsque des propriétés telles que la taille du conteneur, la couleur, etc., changent
AnimatedOpacityAnimation de transition d'opacité
AnimatedPaddingAnimation de transition de padding
AnimatedAlignAnimation de changement d'alignement
AnimatedSwitcherAnimation lors du changement de widgets enfants
AnimatedDefaultTextStyleAnimation de changement de style de texte

Animation explicite

Les animations explicites utilisent AnimationController pour contrôler entièrement l'animation.

Exemple : animation de rotation

class RotationAnimation extends StatefulWidget {
  const RotationAnimation({super.key});

  @override
  State<RotationAnimation> createState() => _RotationAnimationState();
}

class _RotationAnimationState extends State<RotationAnimation>
    with SingleTickerProviderStateMixin {
  late AnimationController _controller;
  late Animation<double> _animation;

  @override
  void initState() {
    super.initState();
    // Créer le contrôleur d'animation
    _controller = AnimationController(
      duration: const Duration(seconds: 2),
      vsync: this,
    );

    // Créer une animation de rotation (0 à 1 correspond à 0 à 2π)
    _animation = Tween<double>(begin: 0, end: 6.28).animer(
      CurvedAnimation(parent: _controller, curve: Curves.linear),
    );

    // Démarrer l'animation
    _controller.repeat();
  }

  @override
  void dispose() {
    _controller.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Center(
      child: AnimatedBuilder(
        animation: _animation,
        builder: (context, child) {
          return Transform.rotate(
            angle: _animation.value,  // Angle de rotation
            child: const Icon(Icons.refresh, size: 100),
          );
        },
      ),
    );
  }
}

Animation décalée

Exemple : Animation décalée

class StaggeredAnimation extends StatefulWidget {
  const StaggeredAnimation({super.key});

  @override
  State<StaggeredAnimation> createState() => _StaggeredAnimationState();
}

class _StaggeredAnimationState extends State<StaggeredAnimation>
    with TickerProviderStateMixin {
  late AnimationController _controller;

  // Animations individuelles
  late Animation<double> _fadeAnimation;
  late Animation<double> _scaleAnimation;
  late Animation<Offset> _slideAnimation;

  @override
  void initState() {
    super.initState();
    _controller = AnimationController(
      duration: const Duration(milliseconds: 1500),
      vsync: this,
    );

    // Animation d'apparition en fondu (0-0.5)
    _fadeAnimation = Tween<double>(begin: 0, end: 1).animer(
      CurvedAnimation(
        parent: _controller,
        curve: const Interval(0, 0.5, curve: Curves.easeOut),
      ),
    );

    // Animation de mise à l'échelle (0.3-0.7)
    _scaleAnimation = Tween<double>(begin: 0.5, end: 1).animer(
      CurvedAnimation(
        parent: _controller,
        curve: const Interval(0.3, 0.7, curve: Curves.elasticOut),
      ),
    );

    // Animation de glissement vers l'intérieur (0.5-1.0)
    _slideAnimation = Tween<Offset>(
      begin: const Offset(0, 0.5),
      end: Offset.zero,
    ).animer(
      CurvedAnimation(
        parent: _controller,
        curve: const Interval(0.5, 1, curve: Curves.easeOutCubic),
      ),
    );

    _controller.forward();
  }

  @override
  void dispose() {
    _controller.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return AnimatedBuilder(
      animation: _controller,
      builder: (context, child) {
        return FadeTransition(
          opacity: _fadeAnimation,
          child: ScaleTransition(
            scale: _scaleAnimation,
            child: SlideTransition(
              position: _slideAnimation,
              child: const Card(
                child: Padding(
                  padding: EdgeInsets.all(24),
                  child: Text('Bienvenue'),
                ),
              ),
            ),
          ),
        );
      },
    );
  }
}

Animation Hero

L'animation Hero est utilisée pour créer des effets de transition d'éléments partagés lors du passage d'une page à l'autre.

Exemple : animation Hero

// Accueil - image avec Hero
class HomePage extends StatelessWidget {
  const HomePage({super.key});

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('Bienvenue')),
      body: Center(
        child: GestureDetector(
          onTap: () => Navigator.push(
            context,
            MaterialPageRoute(builder: (_) => const DetailPage()),
          ),
          child: Hero(
            tag: 'myHero',  // Même tag
            child: Image.network(
              'https://picsum.photos/200',
              width: 200,
              height: 200,
            ),
          ),
        ),
      ),
    );
  }
}

// Page de détail - image avec Hero
class DetailPage extends StatelessWidget {
  const DetailPage({super.key});

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('Détails')),
      body: Center(
        child: Hero(
          tag: 'myHero',  // Même tag
          child: Image.network(
            'https://picsum.photos/200',
            width: 300,
            height: 300,
          ),
        ),
      ),
    );
  }
}

Les animations implicites conviennent aux scénarios simples, tandis que les animations explicites conviennent au contrôle complexe.

L'animation Hero est le meilleur choix pour les transitions de page.

autres extensions