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'état | Description | Exemples |
|---|---|---|
| État local | État dans un seul Widget | Texte de champ de saisie, progression d'animation |
| État partagé | État qui doit être partagé entre plusieurs Widgets | Informations de connexion utilisateur, thèmes |
| État appliqué | État auquel l'application entière doit accéder | Contenu du panier, configuration utilisateur |
État local - setState
Pour un état local simple, utiliser StatefulWidget et setState suffit.
Exemple : exemple de compteur
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
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
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
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'),
);
}
}
autres extensionsLe 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.