Flutter Gestión de Estado

La gestión de estado es un concepto central en el desarrollo de Flutter.

Esta sección presentará los métodos de gestión de estado integrados en Flutter, incluyendo setState, Provider y ChangeNotifier.


¿Qué es la gestión de estado?

La gestión de estado se refiere al mecanismo que gestiona los cambios de datos y las actualizaciones de la interfaz de usuario (UI) en una aplicación. Cuando los datos cambian, la UI necesita actualizarse en consecuencia; este es el problema que resuelve la gestión de estado.

Tipos de estadoDescripciónEjemplo
Estado localEstado interno de un solo WidgetTexto del campo de entrada, progreso de animación
Estado compartidoEstado que necesitan compartir múltiples WidgetsInformación de inicio de sesión del usuario, tema
Estado de la aplicaciónEstado al que toda la aplicación necesita accederContenido del carrito de compras, configuración del usuario

Estado local - setState

Para estados locales simples, es suficiente usar StatefulWidget y setState.

Ejemplo: Contador

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

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

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

  // Incrementar contador
  void _increment() {
    setState(() {
      _count++;
    });
  }

  // Decrementar contador
  void _decrement() {
    setState(() {
      _count--;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      mainAxisAlignment: MainAxisAlignment.center,
      children: [
        Text('Contador: $_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('+')),
          ],
        ),
      ],
    );
  }
}

Gestión de estado con Provider

Provider es una de las soluciones de gestión de estado recomendadas oficialmente por Flutter, adecuada para gestionar estados compartidos entre componentes.

Instalar Provider

Agregue la dependencia en pubspec.yaml:

dependencies:
  provider: ^6.0.0

Patrón ChangeNotifier

Ejemplo: Provider + ChangeNotifier

// 1. Definir el modelo de datos (heredar de ChangeNotifier)
class CounterModel extends ChangeNotifier {
  int _count = 0;

  int get count => _count;

  void increment() {
    _count++;
    // Notificar a los listeners que el estado ha cambiado
    notifyListeners();
  }

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

// 2. Proporcionar los datos en el nivel superior de la aplicación
void main() {
  runApp(
    // Proporcionar CounterModel a los componentes hijos
    ChangeNotifierProvider(
      create: (context) => CounterModel(),
      child: const MyApp(),
    ),
  );
}

// 3. Usar los datos en los componentes
class CounterDisplay extends StatelessWidget {
  const CounterDisplay({super.key});

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

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

Combinación de múltiples Providers

Ejemplo: Uso de múltiples Providers

void main() {
  runApp(
    MultiProvider(
      providers: [
        // Provider de información de usuario
        ChangeNotifierProvider(create: (_) => UserModel()),
        // Provider de tema
        ChangeNotifierProvider(create: (_) => ThemeModel()),
        // Provider del carrito de compras
        ChangeNotifierProvider(create: (_) => CartModel()),
      ],
      child: const MyApp(),
    ),
  );
}

// Usar context.read cuando no se necesita escuchar cambios
class SomeWidget extends StatelessWidget {
  const SomeWidget({super.key});

  @override
  Widget build(BuildContext context) {
    // Leer pero no escuchar
    final user = context.read<UserModel>();

    return ElevatedButton(
      onPressed: () => user.logout(),
      child: const Text('Cerrar sesión'),
    );
  }
}

Elevación de estado - Lifting State Up

Cuando varios componentes hijos necesitan compartir estado, se puede elevar el estado al componente padre común más cercano.

Ejemplo: Elevación de estado

// El componente padre gestiona el estado
class ParentWidget extends StatefulWidget {
  const ParentWidget({super.key});

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

class _ParentWidgetState extends State<ParentWidget> {
  // Estado compartido
  bool _isEnabled = false;

  // Método de callback
  void _toggleEnabled() {
    setState(() {
      _isEnabled = !_isEnabled;
    });
  }

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

// Componente hijo A (solo muestra el estado)
class ChildWidgetA extends StatelessWidget {
  final bool isEnabled;

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

  @override
  Widget build(BuildContext context) {
    return Text('Estado: ${isEnabled ? "Activado" : "Desactivado"}');
  }
}

// Componente hijo B (controla el estado)
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 ? 'Desactivar' : 'Activar'),
    );
  }
}

La elección de la gestión de estado depende del tamaño de la aplicación: las aplicaciones simples usan setState, las aplicaciones medianas usan Provider, y para aplicaciones complejas se pueden considerar soluciones como Riverpod, BLoC o GetX.

Otras extensiones