Provider en Flutter permite poner un objeto a disposición de una parte de la interfaz sin pasarlo manualmente por cada constructor intermedio. Se usa, por ejemplo, para compartir el estado de una sesión, un carrito o una lista de tareas entre varias pantallas. No sustituye al sistema de widgets de Flutter: organiza cómo se proporcionan y se observan esos datos.
La idea clave es separar tres responsabilidades: crear o localizar el objeto, modificarlo y reconstruir los widgets que dependen de sus cambios. Provider ofrece widgets y extensiones de BuildContext para conectar esas piezas. Entender esa relación evita errores habituales, como escuchar cambios en un lugar que no debe reconstruirse o intentar leer un proveedor fuera de su ámbito.
Qué resuelve Provider y qué no
Cuando una aplicación crece, un dato puede necesitarse en distintos puntos del árbol de widgets. Pasarlo de padre a hijo mediante parámetros funciona, pero obliga a atravesar widgets que quizá no utilizan ese dato. Provider permite exponerlo desde un ancestro y acceder a él desde sus descendientes.
El paquete no decide por sí solo cómo debe modelarse el estado. Se puede proporcionar una instancia de una clase sencilla, un objeto de configuración o una clase que notifique cambios. Tampoco es una base de datos, un sistema de navegación ni una garantía automática de que la arquitectura sea correcta. Si una clase concentra demasiadas responsabilidades, usar Provider no la convierte en una clase mejor organizada.
Provider suele aparecer junto a ChangeNotifier, una clase de Flutter que permite avisar a sus oyentes cuando cambian los datos. Una combinación típica es un modelo que mantiene el estado y un widget que lo proporciona al resto de la pantalla. Para profundizar en otros temas de esta tecnología, puedes consultar la sección de Flutter.
El recorrido de un dato: proveedor, modelo y widget
Supongamos, como ejemplo hipotético, una pantalla con un contador de elementos guardados. El modelo guarda el número y ofrece una operación para incrementarlo. Al llamar a notifyListeners(), comunica que su estado ha cambiado. Un widget que esté escuchando ese modelo se reconstruye y muestra el valor actualizado.
class GuardadosModel extends ChangeNotifier {
int _cantidad = 0;
int get cantidad => _cantidad;
void anadir() {
_cantidad++;
notifyListeners();
}
}
El modelo no dibuja botones ni conoce la estructura visual de la pantalla. Esa separación facilita que la interfaz presente el estado y que las acciones lo modifiquen mediante métodos explícitos. En una aplicación real, el objeto podría coordinarse además con un repositorio o una API, pero esa lógica no es necesaria para entender el mecanismo básico.
Crear el ámbito con ChangeNotifierProvider
El proveedor debe colocarse por encima de los widgets que necesiten acceder al objeto. Por ejemplo, se puede envolver una pantalla o un conjunto de rutas con ChangeNotifierProvider. Los descendientes de ese punto pueden encontrar el modelo; los widgets que estén fuera de su subárbol, no.
ChangeNotifierProvider(
create: (_) => GuardadosModel(),
child: const PantallaGuardados(),
)
La función create es adecuada cuando el proveedor debe crear y gestionar una instancia nueva. Si ya existe una instancia que se quiere exponer, se utiliza ChangeNotifierProvider.value. Esta distinción importa porque entregar una instancia existente mediante create puede hacer que el proveedor la gestione como si fuera de su propiedad y la elimine al cerrar su ámbito. A la inversa, usar .value para crear un objeto nuevo no es el patrón indicado.
Leer el estado y ejecutar una acción
Un widget puede observar el contador y solicitar una actualización al pulsar un botón:
class PantallaGuardados extends StatelessWidget {
const PantallaGuardados({super.key});
@override
Widget build(BuildContext context) {
final cantidad = context.watch<GuardadosModel>().cantidad;
return Column(
children: [
Text('Elementos guardados: $cantidad'),
ElevatedButton(
onPressed: () => context.read<GuardadosModel>().anadir(),
child: const Text('Añadir'),
),
],
);
}
}
context.watch establece una suscripción: si el modelo notifica un cambio, el widget que lo usa vuelve a construirse. context.read obtiene el objeto sin suscribirse. Por eso resulta apropiado para invocar una acción desde un callback, pero no para mostrar un valor que debe mantenerse actualizado. Leer el dato una sola vez durante la construcción y esperar que cambie en pantalla es un error frecuente.
watch, read y select no son intercambiables
Elegir el tipo de acceso determina qué cambios provocan reconstrucciones. La decisión no es solo de estilo: afecta a la relación entre el estado y la interfaz.
watch: observa el objeto durante la construcción del widget. Úsalo cuando el resultado visual dependa de sus cambios.read: obtiene el objeto sin escuchar cambios. Es útil en acciones comoonPressedo al ejecutar un comando.select: observa una parte concreta del objeto. Puede evitar reconstrucciones cuando cambian otros campos que ese widget no utiliza.
Por ejemplo, si un modelo contiene el nombre de usuario y una lista de notificaciones, un indicador que solo muestra el nombre puede seleccionar ese campo. Si cambia la lista, ese indicador no necesita reconstruirse por ese motivo. La selección funciona mejor cuando el valor seleccionado tiene una igualdad estable; seleccionar una estructura nueva en cada ocasión puede reducir la ventaja esperada.
Ámbitos, varios proveedores y errores de contexto
Un error como “Provider not found” suele indicar que el widget intenta leer un tipo que no está disponible por encima de él. Hay que comprobar tres cosas: que el proveedor envuelve realmente al widget consumidor, que el tipo solicitado coincide con el proporcionado y que el acceso ocurre desde el contexto de un descendiente.
Este último punto puede aparecer al insertar un proveedor y, en la misma construcción, intentar leerlo usando un contexto que pertenece a un widget situado por encima. Una solución habitual es introducir un widget hijo o usar Builder para obtener un contexto dentro del ámbito. No basta con que ambas instrucciones estén escritas en el mismo método: importa la posición real de cada widget en el árbol.
Para ofrecer varios objetos, se puede usar MultiProvider, que agrupa proveedores y hace más legible la composición. Cada proveedor sigue teniendo su propio alcance y su propio ciclo de vida. Si un modelo necesita otro objeto para construirse, el orden y la forma de inyectar esa dependencia deben reflejarlo; no conviene ocultar esas relaciones en búsquedas globales difíciles de seguir.
Estado asíncrono y tamaño de las reconstrucciones
Una operación que consulta una API introduce estados adicionales: carga, resultado y error. Provider no define por sí mismo cómo representarlos. El modelo puede mantener, por ejemplo, una bandera de carga, los datos recibidos y un mensaje de error, y notificar los cambios en cada transición. La interfaz debe contemplar esos estados en lugar de mostrar siempre una lista vacía, que podría confundirse con una respuesta válida sin resultados.
También es importante limitar el área que escucha. Si un widget grande utiliza watch para un único valor, cualquier notificación del modelo puede reconstruir todo ese subárbol. Separar la parte dinámica en un widget pequeño o utilizar select ayuda a expresar qué dato necesita cada zona. No es necesario optimizar cada pantalla por anticipado: primero hay que mantener claras las dependencias y reducir reconstrucciones cuando el tamaño o la frecuencia de los cambios lo justifiquen.
Cuándo elegir Provider y cuándo considerar otra opción
Provider encaja bien cuando se necesita compartir dependencias o estado entre widgets, especialmente si el modelo puede expresarse con objetos sencillos y notificaciones claras. Para un estado estrictamente local —por ejemplo, si un desplegable está abierto— puede bastar con el estado propio del widget. Introducir un proveedor para un dato que solo usa un componente añade una capa sin aportar necesariamente una ventaja.
En proyectos con flujos de estado más complejos, muchas reglas de negocio o requisitos de pruebas específicos, el equipo puede valorar otras soluciones de gestión de estado. La comparación debe centrarse en cómo se representan las transiciones, cómo se inyectan las dependencias, qué parte de la interfaz se actualiza y cuánto código necesita mantener el equipo. No hay una elección universal: el tamaño de la aplicación y la claridad del diseño importan más que adoptar una herramienta por popularidad.
Antes de añadir Provider a una pantalla, comprueba que el dato de verdad se comparte, que el proveedor está situado en el ámbito adecuado y que cada widget usa el tipo de lectura correcto. Si el modelo notifica cambios solo cuando sus datos relevantes han cambiado, la interfaz tendrá una relación comprensible con el estado y será más sencillo localizar fallos.
