Gestion d'état Flutter

La gestion d'état est un concept fondamental dans le développement Flutter.

Cette section présentera les approches de gestion d'état intégrées de Flutter, notamment setState, Provider et ChangeNotifier.


Qu'est-ce que la gestion d'état

La gestion d'état fait référence au mécanisme de gestion des modifications de données et des mises à jour de l'interface utilisateur dans une application. Lorsque les données changent, l'interface utilisateur doit se mettre à jour en conséquence ; c'est le problème que la gestion d'état résout.

Types d'étatDescriptionExemples
État localÉtat dans un seul WidgetTexte de champ de saisie, progression d'animation
État partagéÉtat qui doit être partagé entre plusieurs WidgetsInformations de connexion utilisateur, thèmes
État appliquéÉtat auquel l'application entière doit accéderContenu du panier, configuration utilisateur

État local - setState

Pour un état local simple, utiliser StatefulWidget et setState suffit.

Exemple : exemple de compteur

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

  @override
  State<CounterWidget> createState() => _CounterWidgetState();
}

class _CounterWidgetState extends State<CounterWidget> {
  // État local
  int _count = 0;

  // Incrémenter le compteur
  void _increment() {
    setState(() {
      _count++;
    });
  }

  // Décrémenter le compteur
  void _decrement() {
    setState(() {
      _count--;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      mainAxisAlignment: MainAxisAlignment.center,
      children: [
        Text(Compteur : $_count, style: const TextStyle(fontSize: 32)),
        const SizedBox(height: 20),
        Row(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            ElevatedButton(onPressed: _decrement, child: const Text('-')),
            const SizedBox(width: 20),
            ElevatedButton(onPressed: _increment, child: const Text('+')),
          ],
        ),
      ],
    );
  }
}

Gestion d'état avec Provider

Provider est l'une des solutions de gestion d'état officiellement recommandées par Flutter, adaptée à la gestion d'état partagé entre les composants.

Installer Provider

Ajoutez la dépendance dans pubspec.yaml :

dependencies:
  provider: ^6.0.0

Modèle ChangeNotifier

Exemple : Provider + ChangeNotifier

// 1. Définir le modèle de données (hériter de ChangeNotifier)
class CounterModel extends ChangeNotifier {
  int _count = 0;

  int get count => _count;

  void increment() {
    _count++;
    // Notifier les écouteurs que l'état a changé
    notifyListeners();
  }

  void decrement() {
    _count--;
    notifyListeners();
  }
}

// 2. Fournir les données en haut de l'application
void main() {
  runApp(
    // Fournir CounterModel aux widgets enfants
    ChangeNotifierProvider(
      create: (context) => CounterModel(),
      child: const MyApp(),
    ),
  );
}

// 3. Utiliser les données dans le widget
class CounterDisplay extends StatelessWidget {
  const CounterDisplay({super.key});

  @override
  Widget build(BuildContext context) {
    // Lire CounterModel
    final counter = context.watch<CounterModel>();

    return Column(
      children: [
        Text('Count: ${counter.count}', style: const TextStyle(fontSize: 32)),
        ElevatedButton(
          onPressed: () => counter.increment(),
          child: const Text('Increase'),
        ),
      ],
    );
  }
}

Composition multi-Provider

Exemple : Utilisation de plusieurs Providers

void main() {
  runApp(
    MultiProvider(
      providers: [
        // Provider d'informations utilisateur
        ChangeNotifierProvider(create: (_) => UserModel()),
        // Provider de thème
        ChangeNotifierProvider(create: (_) => ThemeModel()),
        // Provider de panier d'achat
        ChangeNotifierProvider(create: (_) => CartModel()),
      ],
      child: const MyApp(),
    ),
  );
}

// Utilisez context.read lorsque vous n'avez pas besoin d'écouter les changements.
class SomeWidget extends StatelessWidget {
  const SomeWidget({super.key});

  @override
  Widget build(BuildContext context) {
    // Lire mais ne pas écouter
    final user = context.read<UserModel>();

    return ElevatedButton(
      onPressed: () => user.logout(),
      child: const Text('Déconnexion'),
    );
  }
}

Faire remonter l'état

Lorsque plusieurs composants enfants doivent partager un état, l'état peut être remonté vers le composant parent commun le plus proche.

Exemple : remontée de l'état

// Le composant parent gère l'état
class ParentWidget extends StatefulWidget {
  const ParentWidget({super.key});

  @override
  State<ParentWidget> createState() => _ParentWidgetState();
}

class _ParentWidgetState extends State<ParentWidget> {
  // État partagé
  bool _isEnabled = false;

  // Méthode de rappel
  void _toggleEnabled() {
    setState(() {
      _isEnabled = !_isEnabled;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        // Composant enfant A
        ChildWidgetA(
          isEnabled: _isEnabled,
        ),
        // Composant enfant B
        ChildWidgetB(
          isEnabled: _isEnabled,
          onToggle: _toggleEnabled,
        ),
      ],
    );
  }
}

// Composant enfant A (affiche uniquement l'état)
class ChildWidgetA extends StatelessWidget {
  final bool isEnabled;

  const ChildWidgetA({super.key, required this.isEnabled});

  @override
  Widget build(BuildContext context) {
    return Text('Statut : ${isEnabled ? "Activé" : "Désactivé"}');
  }
}

// Composant enfant B (contrôle l'état)
class ChildWidgetB extends StatelessWidget {
  final bool isEnabled;
  final VoidCallback onToggle;

  const ChildWidgetB({
    super.key,
    required this.isEnabled,
    required this.onToggle,
  });

  @override
  Widget build(BuildContext context) {
    return ElevatedButton(
      onPressed: onToggle,
      child: Text(isEnabled ? 'Fermer' : 'Activer'),
    );
  }
}

Le choix de la gestion d'état dépend de l'échelle de l'application : les applications simples utilisent setState, les applications de taille moyenne utilisent Provider, et les applications complexes peuvent envisager des solutions telles que Riverpod, BLoC ou GetX.

autres extensions