6. Procesamiento asíncrono y estado compartido
6.1. Ejemplo 19: Future, Stream y temporizadores
Muchas cosas ocurren “más tarde”: los pulsos de un temporizador, las pulsaciones de teclas, la respuesta de un servidor. [Dart] tiene dos tipos para esto, en el núcleo del lenguaje:
- [Future<T>]: UN valor, más tarde (la respuesta de un servidor, una elección hecha en una ventana);
- [Stream<T>]: una SECUENCIA de valores a lo largo del tiempo (pulsos, mensajes, posiciones GPS...).
[Flutter] tiene un widget para mostrar cada uno, que se reconstruye cuando llega un valor: [FutureBuilder] y [StreamBuilder]. Y para lo que debe ocurrir después de un retraso: [Timer].
| // =========================================================================
// lib/ex19_asynchronous/main.dart - Future, Stream, temporizadores
// -------------------------------------------------------------------------
// Muchas cosas ocurren "más tarde": los ticks de un temporizador, las
// pulsaciones de teclas, la respuesta de un servidor. Dart tiene dos tipos para
// esto, en el corazón del lenguaje:
// - Future<T>: UN valor, más tarde (la respuesta de un servidor);
// - Stream<T>: una SECUENCIA de valores, a lo largo del tiempo (ticks,
// mensajes...).
// Flutter tiene un widget para mostrar cada uno, reconstruyéndolo cuando llega un
// valor: FutureBuilder y StreamBuilder.
// Y para lo que debe ocurrir tras una espera: Timer (dart:async).
// =========================================================================
import 'dart:async';
import 'dart:math';
import 'package:flutter/material.dart';
const doctors = ['Marie PELISSIER', 'Paul TATOU', 'Sophie DUPONT', 'Jacques DURAND', 'Martine PELLETIER'];
final _random = Random();
// un "servidor" simulado: la respuesta (un Future) llega tras una demora aleatoria
Future<List<String>> search(String text) async {
await Future<void>.delayed(Duration(milliseconds: 200 + _random.nextInt(600)));
return doctors.where((m) => m.toLowerCase().contains(text)).toList();
}
// 1. un Stream producido por una función "async*": cada yield ENVÍA un
// valor a quienes escuchan el Stream
Stream<int> countdown(int start) async* {
for (var remaining = start; remaining >= 0; remaining--) {
yield remaining;
if (remaining > 0) await Future<void>.delayed(const Duration(seconds: 1));
}
}
String currentTime() => DateTime.now().toString().substring(11, 19);
void main() {
runApp(
MaterialApp(
debugShowCheckedModeBanner: false,
theme: ThemeData(colorSchemeSeed: Colors.indigo),
home: const AsynchronousPage(),
),
);
}
class AsynchronousPage extends StatefulWidget {
const AsynchronousPage({super.key});
@override
State<AsynchronousPage> createState() => _AsynchronousPageState();
}
class _AsynchronousPageState extends State<AsynchronousPage> {
final List<String> _log = [];
// el Stream y el Future se crean UNA SOLA VEZ (y no en cada build:
// ¡cada llamada a build reiniciaría la cuenta regresiva!)
final Stream<int> _countdown = countdown(20);
// 3. un Future que se completa tras un segundo
final Future<String> _message = Future.delayed(const Duration(seconds: 1), () => 'three (one second later)');
// 2. la búsqueda mientras se escribe
Timer? _debounce;
int _requestNumber = 0; // el número de la ÚLTIMA búsqueda lanzada
List<String> _results = [];
void _trace(String message) => setState(() => _log.add('${currentTime()} $message'));
// se llama en cada pulsación de tecla
void _onInput(String text) {
// el DEBOUNCE: cada pulsación cancela el temporizador de la pulsación
// anterior; la búsqueda solo comienza tras 400 ms sin pulsaciones
_debounce?.cancel();
_debounce = Timer(const Duration(milliseconds: 400), () => _launch(text.trim().toLowerCase()));
}
Future<void> _launch(String text) async {
// menos de dos letras: sin búsqueda, sin resultado
if (text.length < 2) {
_requestNumber++; // se ignorará una respuesta que aún se espera
setState(() => _results = []);
return;
}
// "obsoleta" (stale): una respuesta que llega DESPUÉS de que se haya lanzado otra búsqueda
// debe ignorarse (de lo contrario, la respuesta lenta de una búsqueda
// antigua sobrescribiría la de la nueva)
final number = ++_requestNumber;
_trace('search sent: "$text"');
final found = await search(text);
if (!mounted) return;
if (number != _requestNumber) {
_trace('response ignored (stale): "$text"');
return;
}
setState(() => _results = found);
}
@override
void dispose() {
_debounce?.cancel();
super.dispose();
}
@override
Widget build(BuildContext context) {
final titleStyle = Theme.of(context).textTheme.titleSmall;
return Scaffold(
appBar: AppBar(title: const Text('Example 19 - asynchrony')),
body: ListView(
padding: const EdgeInsets.all(16),
children: [
Card(
child: Padding(
padding: const EdgeInsets.all(12),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text('A countdown (a Stream and StreamBuilder)', style: titleStyle),
// StreamBuilder: reconstruye su contenido con cada valor del Stream;
// snapshot.data: el último valor recibido (null antes del primero)
StreamBuilder<int>(
stream: _countdown,
builder: (context, snapshot) =>
Text(snapshot.hasData ? '${snapshot.data}' : '...', style: Theme.of(context).textTheme.displaySmall),
),
],
),
),
),
Card(
child: Padding(
padding: const EdgeInsets.all(12),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text('A search as you type (debounce, stale responses)', style: titleStyle),
TextField(
decoration: const InputDecoration(hintText: 'at least two letters: pel, dur...'),
onChanged: _onInput,
),
for (final r in _results) Text('• $r'),
if (_results.isEmpty) const Text('no result', style: TextStyle(color: Colors.grey)),
],
),
),
),
Card(
child: Padding(
padding: const EdgeInsets.all(12),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text('Waiting for a Future (FutureBuilder)', style: titleStyle),
// mientras el Future no se haya completado: el contenido de espera
FutureBuilder<String>(
future: _message,
builder: (context, snapshot) => switch (snapshot.connectionState) {
ConnectionState.done => Text('received: ${snapshot.data}'),
_ => const Text('waiting...', style: TextStyle(color: Colors.grey)),
},
),
],
),
),
),
Text('Log', style: titleStyle),
for (final (i, line) in _log.indexed) Text('${i + 1}. $line', style: const TextStyle(fontSize: 12)),
],
),
);
}
}
|
- líneas 24–26: un “servidor” simulado: una función [async], cuya respuesta (un [Future]) llega tras un retraso aleatorio. [await Future<void>.delayed(...)] espera este retraso sin bloquear la aplicación;
- líneas 31–34: un [Stream] generado por una función [async*] (con asterisco): un generador asíncrono. Cada [yield] envía un valor a quienes escuchan el [Stream]; entre valores, la función espera un segundo;
- líneas 61–63: el [Stream] y el [Future] se crean UNA sola vez, en campos del objeto [State], y no en [build]: ¡cada reconstrucción reiniciaría la cuenta regresiva! Este es el error más común con [FutureBuilder] y [StreamBuilder];
- líneas 66–68: el estado de la búsqueda mientras el usuario escribe: un temporizador, el número de la última búsqueda iniciada y los resultados;
- líneas 73–77: debouncing: el programa espera a que el usuario haga una pausa antes de consultar al servidor, en lugar de enviar una solicitud con cada pulsación de tecla. Cada pulsación reinicia el temporizador de la pulsación anterior ([cancel()]) e inicia uno nuevo: la búsqueda solo se desencadena después de 400 milisegundos sin pulsaciones;
- líneas 80–98: la búsqueda. Una respuesta “obsoleta” (la que llega DESPUÉS de que se haya lanzado otra búsqueda) debe ignorarse: de lo contrario, la respuesta lenta de una búsqueda antigua sobrescribiría la de la nueva. A cada búsqueda se le asigna un número ([++_requestNumber]); cuando llega su respuesta, si ya no es el número de la búsqueda más reciente, se ignora. [if (!mounted) return;]: la pantalla puede haber desaparecido durante la espera;
- líneas 102–104: el temporizador se detiene si la pantalla desaparece;
- líneas 124–127: [StreamBuilder] escucha el [Stream] y reconstruye su contenido con cada nuevo valor. [builder] recibe una instantánea ([snapshot], un [AsyncSnapshot]): [snapshot.hasData], [snapshot.data] (el último valor recibido), [snapshot.hasError], [snapshot.connectionState]. Cuando el widget desaparece, [StreamBuilder] cancela su suscripción por sí mismo;
- líneas 158–162: [FutureBuilder] espera el [Future]: hasta que termina, muestra el contenido provisional; luego, su valor. [switch] sobre [snapshot.connectionState] elige uno u otro.
Escribimos rápidamente “p”, “pe”, “pel”: solo se envía una búsqueda. Luego “du”, seguido de “dup” antes de la respuesta: la respuesta a “du” llega demasiado tarde y se ignora si “dup” ya ha recibido su respuesta:
En [JavaScript], lo mismo se escribe con promesas y temporizadores; [Angular] agrega los "observables" de [RxJS]. En [Dart], [Future] y [Stream] están en la biblioteca base, y [async], [await], [async*], [yield] y [await for] están en el lenguaje: por eso [Flutter] no requiere una biblioteca para las operaciones asíncronas.
6.2. Ejemplo 20: un estado compartido
La misma pregunta que en las lecciones anteriores: ¿cuáles son los “ámbitos” de los datos de una aplicación?
- El estado local de un widget desaparece cuando el widget se elimina;
- el estado de un “store” lo comparten todos los widgets y sobrevive a su eliminación… pero no al cierre de la aplicación;
- El estado almacenado en el dispositivo sobrevive al cierre de la aplicación.
6.2.1. El carrito de compras
| // =========================================================================
// lib/ex20_shared_state/stores/cart.dart - un ESTADO COMPARTIDO, con provider
// -------------------------------------------------------------------------
// Un "store" es un estado que vive FUERA de las pantallas, en una ÚNICA
// instancia, compartida por todos los que lo leen. El ejemplo 14 lo hizo
// a mano (InheritedNotifier); el paquete provider, el más usado
// con Flutter (y recomendado por su documentación), hace lo mismo
// en una línea:
//
// ChangeNotifierProvider(create: (_) => Cart(), child: ...)
//
// El store es un ChangeNotifier ordinario. Organización habitual:
// - el ESTADO: datos PRIVADOS (_items);
// - las ACCIONES: métodos, los únicos que modifican el estado, y que terminan
// con notifyListeners();
// - los valores calculados: getters.
// Un widget accede a él mediante su contexto:
// - context.watch<Cart>() : leer Y suscribirse (se reconstruye en cada cambio);
// - context.read<Cart>() : leer sin suscribirse (para llamar a una acción);
// - context.select<Cart, int>((p) => p.count) : suscribirse a UN valor:
// se reconstruye solo si ESTE valor cambia.
// El store vive mientras viva su proveedor: sobrevive a la eliminación de una
// pantalla... pero no a la detención de la aplicación.
// =========================================================================
import 'package:flutter/foundation.dart';
typedef Item = ({String label, double price});
class Cart extends ChangeNotifier {
final List<Item> _items = [];
// una vista NO MODIFICABLE de la lista: solo las acciones la cambian
List<Item> get items => List.unmodifiable(_items);
int get count => _items.length;
double get total => _items.fold(0, (s, a) => s + a.price);
void add(Item item) {
_items.add(item);
notifyListeners();
}
void clear() {
_items.clear();
notifyListeners();
}
}
|
Un store es un estado que abarca varias pantallas y existe como una única instancia compartida por todos los que acceden a él. El ejemplo 14 lo implementó manualmente. El paquete [provider], el más utilizado junto con [Flutter] (y el recomendado en su documentación), hace lo mismo en una sola línea: [ChangeNotifierProvider(create: (_) => Cart(), child: ...)].
- Línea 31: el estado: datos privados;
- líneas 34–36: valores calculados: getters. [List.unmodifiable]: una vista de solo lectura de la lista; solo las acciones pueden modificarla;
- líneas 38–45: las acciones: métodos (los únicos que modifican el estado) que terminan con [notifyListeners()].
6.2.2. Preferencias
| // =========================================================================
// lib/ex20_shared_state/stores/preferences.dart - un estado que sobrevive a la detención
// -------------------------------------------------------------------------
// Para que un dato sobreviva a la detención de la aplicación, debe guardarse
// EN EL DISPOSITIVO. El paquete shared_preferences ofrece un pequeño diccionario
// clave -> valor (bool, int, double, String), propio de la aplicación y
// guardado en el dispositivo (en la web: en el localStorage del navegador).
// - al iniciar, se leen los valores guardados (main.dart);
// - en cada cambio, se vuelven a escribir.
// NUNCA guarde datos sensibles allí (contraseña, token): se
// escriben en texto plano.
// =========================================================================
import 'package:flutter/foundation.dart';
import 'package:shared_preferences/shared_preferences.dart';
class Preferences extends ChangeNotifier {
static const _darkKey = 'example20.dark';
static const _sizeKey = 'example20.size';
final SharedPreferences _storage;
bool _dark;
double _size; // tamaño del texto
// el estado inicial: lo que el dispositivo ha guardado, o si no los valores por defecto
Preferences(this._storage)
: _dark = _storage.getBool(_darkKey) ?? false,
_size = _storage.getDouble(_sizeKey) ?? 16;
bool get dark => _dark;
double get size => _size;
// un parámetro con nombre opcional por cada preferencia: solo cambia lo que se proporciona
void update({bool? dark, double? size}) {
if (dark != null) {
_dark = dark;
_storage.setBool(_darkKey, dark); // escritura en el dispositivo
}
if (size != null) {
_size = size;
_storage.setDouble(_sizeKey, size);
}
notifyListeners();
}
}
|
Para que los datos sobrevivan después de cerrar la aplicación, deben almacenarse en el dispositivo. El paquete [shared_preferences] proporciona un pequeño diccionario clave->valor ([bool], [int], [double], [String]), específico de la aplicación y almacenado en el dispositivo (en la web: en el [localStorage] del navegador).
- Línea 21: los datos de almacenamiento, recibidos al crearse;
- líneas 26–28: el estado inicial: lo que el dispositivo ha almacenado, o valores predeterminados en caso contrario. Los campos se inicializan mediante la “lista de inicialización” del constructor (después de los dos puntos), antes del cuerpo;
- Líneas 34–43: una única acción, con parámetros con nombre opcionales: solo se cambian los valores proporcionados, y se escriben de inmediato en el dispositivo ([setBool], [setDouble]).
NUNCA almacene aquí datos sensibles (contraseñas, tokens): se escriben en texto plano. Para ello existe el paquete [flutter_secure_storage], que utiliza la bóveda del sistema ([Keystore] de [Android], [Keychain] de [iOS]).
| // lib/ex20_shared_state/components/shop.dart - AGREGA al carrito compartido
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import '../stores/cart.dart';
const products = <Item>[(label: 'Consultation', price: 30), (label: 'Vaccine', price: 12.5)];
class Shop extends StatelessWidget {
const Shop({super.key});
@override
Widget build(BuildContext context) {
// read: solo LLAMAMOS a una acción; Shop no se
// reconstruye cuando cambia el carrito
final cart = context.read<Cart>();
return Card(
child: Padding(
padding: const EdgeInsets.all(12),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text('Shop', style: Theme.of(context).textTheme.titleSmall),
for (final p in products)
TextButton.icon(
icon: const Icon(Icons.add),
label: Text('${p.label} (${p.price} €)'),
onPressed: () => cart.add(p),
),
],
),
),
);
}
}
|
- Línea 16: [context.read<Cart>()] lee el carrito de compras proporcionado por encima; SIN suscribirse: la tienda simplemente llama a una acción; no necesita reconstruirse cuando el carrito cambia.
| // lib/ex20_shared_state/components/cart_summary.dart - LEE el mismo carrito
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import '../stores/cart.dart';
class CartSummary extends StatelessWidget {
const CartSummary({super.key});
@override
Widget build(BuildContext context) {
// select: se reconstruye SOLO si cambia la cantidad o el total
final count = context.select<Cart, int>((p) => p.count);
final total = context.select<Cart, double>((p) => p.total);
return Card(
child: Padding(
padding: const EdgeInsets.all(12),
child: Row(
children: [
const Icon(Icons.shopping_cart),
const SizedBox(width: 8),
Expanded(child: Text('$count item(s), $total €')),
TextButton(
onPressed: count == 0 ? null : () => context.read<Cart>().clear(),
child: const Text('Clear'),
),
],
),
),
);
}
}
|
- Líneas 13–14: [context.select] lee UN valor del carrito de compras y suscribe el widget a ESE valor: solo se reconstruye si ese valor cambia. [context.watch<Cart>()] leería y se suscribiría a todo el carrito.
| // lib/ex20_shared_state/components/local_counter.dart - un estado LOCAL, que desaparece con el widget
import 'package:flutter/material.dart';
class LocalCounter extends StatefulWidget {
final String title;
const LocalCounter({super.key, required this.title});
@override
State<LocalCounter> createState() => _LocalCounterState();
}
class _LocalCounterState extends State<LocalCounter> {
int _clicks = 0;
@override
Widget build(BuildContext context) {
return Card(
child: ListTile(
title: Text(widget.title),
trailing: OutlinedButton(onPressed: () => setState(() => _clicks++), child: Text('$_clicks click(s)')),
),
);
}
}
|
Un estado local que desaparece con el widget.
6.2.4. La aplicación
| // =========================================================================
// lib/ex20_shared_state/main.dart - tres "ámbitos" de datos
// -------------------------------------------------------------------------
// - el estado LOCAL de un widget (LocalCounter) desaparece con él;
// - el estado de un STORE (el carrito) es compartido por todos los widgets
// y sobrevive a su eliminación, pero no a la detención de la aplicación;
// - el estado guardado en el dispositivo (las preferencias) sobrevive a la detención.
// Y Visibility(maintainState: true): el contenido está OCULTO, pero no
// eliminado; su estado local se conserva.
// Desmarque y vuelva a marcar "mostrar el área", luego detenga y reinicie
// la aplicación: compare.
// =========================================================================
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'components/shop.dart';
import 'components/local_counter.dart';
import 'components/cart_summary.dart';
import 'stores/cart.dart';
import 'stores/preferences.dart';
Future<void> main() async {
// indispensable antes de usar un "plugin" (código específico de Android, iOS,
// web...) como shared_preferences, ANTES de runApp
WidgetsFlutterBinding.ensureInitialized();
final storage = await SharedPreferences.getInstance();
runApp(
// MultiProvider: varios proveedores, anidados unos en otros,
// por encima de toda la aplicación
MultiProvider(
providers: [
ChangeNotifierProvider(create: (_) => Cart()),
ChangeNotifierProvider(create: (_) => Preferences(storage)),
],
child: const Application(),
),
);
}
class Application extends StatelessWidget {
const Application({super.key});
@override
Widget build(BuildContext context) {
// watch: la aplicación se reconstruye cuando cambian las preferencias
final preferences = context.watch<Preferences>();
return MaterialApp(
debugShowCheckedModeBanner: false,
theme: ThemeData(colorSchemeSeed: Colors.indigo),
// el tema oscuro, y la elección entre los dos
darkTheme: ThemeData(colorSchemeSeed: Colors.indigo, brightness: Brightness.dark),
themeMode: preferences.dark ? ThemeMode.dark : ThemeMode.light,
// builder: envuelve TODAS las pantallas; aquí, el tamaño del texto
builder: (context, child) => MediaQuery(
data: MediaQuery.of(context).copyWith(textScaler: TextScaler.linear(preferences.size / 16)),
child: child!,
),
home: const SharedStatePage(),
);
}
}
class SharedStatePage extends StatefulWidget {
const SharedStatePage({super.key});
@override
State<SharedStatePage> createState() => _SharedStatePageState();
}
class _SharedStatePageState extends State<SharedStatePage> {
bool _areaVisible = true;
@override
Widget build(BuildContext context) {
final preferences = context.watch<Preferences>();
return Scaffold(
appBar: AppBar(title: const Text('Example 20 - a shared state')),
body: ListView(
padding: const EdgeInsets.all(12),
children: [
SwitchListTile(
title: const Text('dark theme'),
value: preferences.dark,
onChanged: (v) => preferences.update(dark: v),
),
ListTile(
title: Text('text size: ${preferences.size.round()}'),
subtitle: Slider(
value: preferences.size,
min: 12,
max: 22,
divisions: 10,
onChanged: (v) => preferences.update(size: v),
),
),
CheckboxListTile(
title: const Text('show the area'),
value: _areaVisible,
onChanged: (v) => setState(() => _areaVisible = v!),
),
// eliminados: estos widgets desaparecen, con su estado local
if (_areaVisible) ...[const Shop(), const CartSummary(), const LocalCounter(title: 'Local state')],
// ocultos: el widget permanece en memoria, su estado se conserva
Visibility(
visible: _areaVisible,
maintainState: true,
child: const LocalCounter(title: 'Local state, in a Visibility'),
),
const Padding(
padding: EdgeInsets.symmetric(vertical: 8),
child: Text('Outside the area, a second summary of the SAME cart (it stays there when the area disappears):'),
),
const CartSummary(),
],
),
);
}
}
|
- Líneas 27–28: [shared_preferences] es un "plugin": utiliza código específico de cada plataforma ([Android], web...). Para usarlo ANTES de [runApp], primero hay que inicializar [Flutter] ([ensureInitialized]). La lectura del almacenamiento es asíncrona: [main] espera a que termine;
- líneas 32–35: [MultiProvider] coloca varios proveedores, uno dentro de otro, en lo alto de toda la aplicación. [ChangeNotifierProvider] crea el [ChangeNotifier] ([create]), lo proporciona a sus descendientes, reconstruye a los que se suscriben a él cuando cambia y lo libera cuando desaparece;
- línea 48: la aplicación lee las preferencias y se suscribe a ellas; se reconstruye cuando cambian;
- líneas 53–54: dos temas, claro y oscuro, y la opción de elegir entre ellos ([themeMode]);
- líneas 56–58: el [builder] de [MaterialApp] envuelve TODAS las pantallas. Aquí se cambia el tamaño del texto de toda la aplicación: [MediaQuery] describe la pantalla y la configuración del usuario (incluido [textScaler], el factor de ampliación del texto, que también puede ajustarse en la configuración de accesibilidad del teléfono);
- línea 104: eliminada; el área desaparece, junto con el estado local de sus widgets;
- Líneas 106–109: [Visibility] con [maintainState: true] OCULTA a su hijo sin eliminarlo: su estado se conserva. (Esto es lo que hace [<Activity mode="hidden">] en el curso de [React].)
Agregamos dos artículos, hacemos clic una vez en cada contador local (a la izquierda); quitamos el área y cambiamos al modo oscuro (en el centro); restauramos el área (a la derecha):
El carrito de compras sobrevivió a la eliminación de la sección (como lo muestra el segundo resumen); el contador eliminado volvió a cero; el contador oculto conservó su valor. Detenga la aplicación y vuelva a iniciarla: el tema oscuro y el tamaño del texto se conservan, y el carrito de compras está vacío.
¿Por qué [provider]? Hay muchas bibliotecas de gestión de estado para [Flutter] ([Riverpod], [Bloc], [GetX], [MobX]...). [provider] es la más sencilla: es simplemente una forma cómoda de escribir el [InheritedWidget] del ejemplo 14, basada en el [ChangeNotifier] de [Flutter]. Es la que se usa en la guía de arquitectura de la documentación de [Flutter], y la que se usará en el caso de estudio.