6. Processamento assíncrono e estado compartilhado
6.1. Exemplo 19: Future, Stream e timers
Muitas coisas acontecem “mais tarde”: ticks de timer, teclas digitadas, a resposta de um servidor. O [Dart] tem dois tipos para isso, no núcleo da linguagem:
- [Future<T>]: UM valor, mais tarde (a resposta de um servidor, uma escolha feita em uma janela);
- [Stream<T>]: uma SEQUÊNCIA de valores ao longo do tempo (ticks, mensagens, posições de GPS...).
O [Flutter] tem um widget para exibir cada um deles, reconstruindo-o quando um valor chega: [FutureBuilder] e [StreamBuilder]. E para o que deve acontecer após um atraso: [Timer].
| // =========================================================================
// lib/ex19_asynchronous/main.dart - Future, Stream, timers
// -------------------------------------------------------------------------
// Muitas coisas acontecem "depois": os ticks de um timer, as
// teclas digitadas, a resposta de um servidor. O Dart tem dois tipos para
// isso, no coração da linguagem:
// - Future<T>: UM valor, depois (a resposta de um servidor);
// - Stream<T>: uma SEQUÊNCIA de valores, ao longo do tempo (ticks,
// mensagens...).
// O Flutter tem um widget para exibir cada um, reconstruindo-o quando um
// valor chega: FutureBuilder e StreamBuilder.
// E para o que deve acontecer após um atraso: 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();
// um "servidor" simulado: a resposta (um Future) chega após um atraso aleatório
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. um Stream produzido por uma função "async*": cada yield ENVIA um
// valor a quem escuta o 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 = [];
// o Stream e o Future são criados UMA vez (e não a cada build:
// cada chamada de build reiniciaria a contagem regressiva!)
final Stream<int> _countdown = countdown(20);
// 3. um Future que termina após um segundo
final Future<String> _message = Future.delayed(const Duration(seconds: 1), () => 'three (one second later)');
// 2. a pesquisa enquanto se digita
Timer? _debounce;
int _requestNumber = 0; // o número da ÚLTIMA pesquisa iniciada
List<String> _results = [];
void _trace(String message) => setState(() => _log.add('${currentTime()} $message'));
// chamado a cada tecla digitada
void _onInput(String text) {
// o DEBOUNCE: cada tecla cancela o timer da tecla anterior;
// a pesquisa só começa após 400 ms sem nenhuma tecla
_debounce?.cancel();
_debounce = Timer(const Duration(milliseconds: 400), () => _launch(text.trim().toLowerCase()));
}
Future<void> _launch(String text) async {
// menos de duas letras: nenhuma pesquisa, nenhum resultado
if (text.length < 2) {
_requestNumber++; // uma resposta ainda esperada será ignorada
setState(() => _results = []);
return;
}
// "obsoleta" (stale): uma resposta que chega DEPOIS que outra pesquisa foi
// iniciada deve ser ignorada (senão a resposta lenta de uma pesquisa
// antiga sobrescreveria a da nova)
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: reconstrói seu conteúdo a cada valor do Stream;
// snapshot.data: o último valor recebido (null antes do primeiro)
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),
// enquanto o Future não terminar: o conteúdo 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)),
],
),
);
}
}
|
- linhas 24–26: um “servidor” simulado: uma função [async], cuja resposta (um [Future]) chega após um atraso aleatório. [await Future<void>.delayed(...)] espera por esse atraso sem bloquear o aplicativo;
- linhas 31–34: um [Stream] gerado por uma função [async*] (com asterisco): um gerador assíncrono. Cada [yield] envia um valor a quem está ouvindo o [Stream]; entre os valores, a função espera um segundo;
- linhas 61–63: o [Stream] e o [Future] são criados UMA ÚNICA vez, em campos do objeto [State], e não em [build]: cada reconstrução reiniciaria a contagem regressiva! Este é o erro mais comum com [FutureBuilder] e [StreamBuilder];
- linhas 66–68: o estado da pesquisa enquanto o usuário digita: um timer, o número da última pesquisa iniciada e os resultados;
- linhas 73–77: debouncing: o programa espera o usuário fazer uma pausa antes de consultar o servidor, em vez de enviar uma requisição a cada tecla digitada. Cada tecla digitada zera o timer da tecla anterior ([cancel()]) e inicia um novo: a pesquisa só é disparada após 400 milissegundos sem nenhuma tecla;
- Linhas 80–98: a pesquisa. Uma resposta “desatualizada” (que chega DEPOIS de outra pesquisa ter sido lançada) deve ser ignorada: caso contrário, a resposta lenta de uma pesquisa antiga sobrescreveria a da nova. Cada pesquisa recebe um número ([++_requestNumber]); quando sua resposta chega, se esse não for mais o número da pesquisa mais recente, ela é ignorada. [if (!mounted) return;]: a tela pode ter desaparecido durante a espera;
- linhas 102–104: o timer é interrompido se a tela desaparecer;
- linhas 124–127: [StreamBuilder] escuta o [Stream] e reconstrói seu conteúdo a cada novo valor. [builder] recebe um snapshot ([snapshot], um [AsyncSnapshot]): [snapshot.hasData], [snapshot.data] (o último valor recebido), [snapshot.hasError], [snapshot.connectionState]. Quando o widget desaparece, [StreamBuilder] cancela a inscrição por conta própria;
- linhas 158–162: [FutureBuilder] espera o [Future]: até que ele termine, o conteúdo provisório; depois, seu valor. [switch] sobre [snapshot.connectionState] escolhe um ou outro.
Digitamos rapidamente “p”, “pe”, “pel”: apenas uma pesquisa é enviada. Depois “du”, seguido de “dup” antes da resposta: a resposta a “du” chega tarde demais e é ignorada se “dup” já tiver recebido sua resposta:
Em [JavaScript], a mesma coisa é escrita com promises e timers; o [Angular] acrescenta os "observables" do [RxJS]. No [Dart], [Future] e [Stream] estão na biblioteca básica, e [async], [await], [async*], [yield] e [await for] estão na linguagem: é por isso que o [Flutter] não exige uma biblioteca para operações assíncronas.
6.2. Exemplo 20: um estado compartilhado
A mesma pergunta das lições anteriores: quais são os “escopos” dos dados de um aplicativo?
- O estado local de um widget desaparece quando o widget é removido;
- o estado de um “store” é compartilhado por todos os widgets e sobrevive à sua remoção… mas não ao encerramento do aplicativo;
- o estado guardado no dispositivo sobrevive ao encerramento do aplicativo.
6.2.1. O carrinho de compras
| // =========================================================================
// lib/ex20_shared_state/stores/cart.dart - um ESTADO COMPARTILHADO, com provider
// -------------------------------------------------------------------------
// Um "store" é um estado que vive FORA das telas, em uma ÚNICA
// instância, compartilhada por todos os que o leem. O exemplo 14 fez isso
// à mão (InheritedNotifier); o pacote provider, o mais usado
// com o Flutter (e recomendado pela sua documentação), faz a mesma coisa
// em uma linha:
//
// ChangeNotifierProvider(create: (_) => Cart(), child: ...)
//
// O store é um ChangeNotifier comum. Organização usual:
// - o ESTADO: dados PRIVADOS (_items);
// - as AÇÕES: métodos, os únicos a modificar o estado, que terminam
// com notifyListeners();
// - os valores calculados: getters.
// Um widget o acessa por meio do seu context:
// - context.watch<Cart>() : ler E se inscrever (reconstruído a cada alteração);
// - context.read<Cart>() : ler sem se inscrever (para chamar uma ação);
// - context.select<Cart, int>((p) => p.count) : inscrever-se em UM valor:
// reconstruído somente se ESTE valor mudar.
// O store vive enquanto seu provider viver: ele sobrevive à remoção de uma
// tela... mas não à parada do aplicativo.
// =========================================================================
import 'package:flutter/foundation.dart';
typedef Item = ({String label, double price});
class Cart extends ChangeNotifier {
final List<Item> _items = [];
// uma visão NÃO MODIFICÁVEL da lista: somente as ações a alteram
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();
}
}
|
Um store é um estado que abrange várias telas, existindo como uma única instância compartilhada por todos que o acessam. O exemplo 14 implementou isso manualmente. O pacote [provider], o mais usado junto com o [Flutter] (e o recomendado em sua documentação), faz o mesmo em uma única linha: [ChangeNotifierProvider(create: (_) => Cart(), child: ...)].
- Linha 31: o estado: dados privados;
- linhas 34–36: valores calculados: getters. [List.unmodifiable]: uma visão somente leitura da lista; apenas as ações podem modificá-la;
- linhas 38–45: as ações: métodos — os únicos que modificam o estado — que terminam com [notifyListeners()].
6.2.2. Preferências
| // =========================================================================
// lib/ex20_shared_state/stores/preferences.dart - um estado que sobrevive à parada
// -------------------------------------------------------------------------
// Para que um dado sobreviva à parada do aplicativo, ele deve ser guardado
// NO DISPOSITIVO. O pacote shared_preferences oferece um pequeno dicionário
// chave -> valor (bool, int, double, String), específico do aplicativo e
// mantido no dispositivo (na web: no localStorage do navegador).
// - na inicialização, os valores guardados são lidos (main.dart);
// - a cada alteração, eles são escritos de novo.
// NUNCA guarde dados sensíveis ali (senha, token): eles são
// escritos em texto puro.
// =========================================================================
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; // tamanho do texto
// o estado inicial: o que o dispositivo guardou, senão os valores padrão
Preferences(this._storage)
: _dark = _storage.getBool(_darkKey) ?? false,
_size = _storage.getDouble(_sizeKey) ?? 16;
bool get dark => _dark;
double get size => _size;
// um parâmetro nomeado opcional por preferência: só o que é fornecido muda
void update({bool? dark, double? size}) {
if (dark != null) {
_dark = dark;
_storage.setBool(_darkKey, dark); // escrita no dispositivo
}
if (size != null) {
_size = size;
_storage.setDouble(_sizeKey, size);
}
notifyListeners();
}
}
|
Para que os dados sobrevivam ao encerramento do aplicativo, eles devem ser guardados no dispositivo. O pacote [shared_preferences] oferece um pequeno dicionário chave->valor ([bool], [int], [double], [String]), específico do aplicativo e armazenado no dispositivo (na web: no [localStorage] do navegador).
- Linha 21: os dados de armazenamento, recebidos na criação;
- linhas 26–28: o estado inicial: o que o dispositivo armazenou ou, caso contrário, valores padrão. Os campos são inicializados pela “lista de inicialização” do construtor (depois dos dois-pontos), antes do corpo;
- Linhas 34–43: uma única ação, com parâmetros nomeados opcionais: apenas os valores fornecidos são alterados, e eles são imediatamente gravados no dispositivo ([setBool], [setDouble]).
NUNCA guarde dados sensíveis (senhas, tokens) ali: esses dados são gravados em texto simples. Para essa finalidade, existe o pacote [flutter_secure_storage], que usa o cofre do sistema ([Keystore] do [Android], [Keychain] do [iOS]).
| // lib/ex20_shared_state/components/shop.dart - ACRESCENTA ao carrinho compartilhado
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: apenas CHAMAMOS uma ação; Shop não é
// reconstruído quando o carrinho muda
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),
),
],
),
),
);
}
}
|
- Linha 16: [context.read<Cart>()] lê o carrinho de compras fornecido acima, SEM se inscrever: o store simplesmente chama uma ação; ele não precisa ser reconstruído quando o carrinho muda.
| // lib/ex20_shared_state/components/cart_summary.dart - LÊ o mesmo carrinho
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: reconstrói SOMENTE se a quantidade ou o total mudar
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'),
),
],
),
),
);
}
}
|
- Linhas 13–14: [context.select] lê UM valor do carrinho de compras e inscreve o widget NESSE valor: ele só é reconstruído se esse valor mudar. [context.watch<Cart>()] leria e se inscreveria em todo o carrinho de compras.
| // lib/ex20_shared_state/components/local_counter.dart - um estado LOCAL, que desaparece com o 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)')),
),
);
}
}
|
Um estado local que desaparece junto com o widget.
6.2.4. O aplicativo
| // =========================================================================
// lib/ex20_shared_state/main.dart - três "escopos" de dados
// -------------------------------------------------------------------------
// - o estado LOCAL de um widget (LocalCounter) desaparece com ele;
// - o estado de um STORE (o carrinho) é compartilhado por todos os widgets
// e sobrevive à sua remoção - mas não à parada do aplicativo;
// - o estado guardado no dispositivo (as preferências) sobrevive à parada.
// E Visibility(maintainState: true): o conteúdo fica OCULTO, mas não
// removido; seu estado local é mantido.
// Desmarque e marque de novo "mostrar a área", depois pare e reinicie
// o aplicativo: 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 {
// indispensável antes de usar um "plugin" (código específico do Android, iOS,
// web...) como shared_preferences, ANTES de runApp
WidgetsFlutterBinding.ensureInitialized();
final storage = await SharedPreferences.getInstance();
runApp(
// MultiProvider: vários providers, aninhados uns nos outros,
// acima de todo o aplicativo
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: o aplicativo é reconstruído quando as preferências mudam
final preferences = context.watch<Preferences>();
return MaterialApp(
debugShowCheckedModeBanner: false,
theme: ThemeData(colorSchemeSeed: Colors.indigo),
// o tema escuro e a escolha entre os dois
darkTheme: ThemeData(colorSchemeSeed: Colors.indigo, brightness: Brightness.dark),
themeMode: preferences.dark ? ThemeMode.dark : ThemeMode.light,
// builder: envolve TODAS as telas; aqui, o tamanho do 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!),
),
// removidos: estes widgets desaparecem, com seu estado local
if (_areaVisible) ...[const Shop(), const CartSummary(), const LocalCounter(title: 'Local state')],
// ocultos: o widget permanece na memória, seu estado é mantido
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(),
],
),
);
}
}
|
- Linhas 27–28: [shared_preferences] é um "plugin": ele usa código específico de cada plataforma ([Android], web...). Para usá-lo ANTES de [runApp], é preciso primeiro inicializar o [Flutter] ([ensureInitialized]). A leitura do armazenamento é assíncrona: [main] espera que ela termine;
- linhas 32–35: [MultiProvider] coloca vários providers, um dentro do outro, no topo de todo o aplicativo. [ChangeNotifierProvider] cria o [ChangeNotifier] ([create]), fornece-o aos seus descendentes, reconstrói os que se inscrevem nele quando ele muda e o libera quando desaparece;
- linha 48: o aplicativo lê as preferências e se inscreve nelas; ele é reconstruído quando elas mudam;
- linhas 53–54: dois temas, claro e escuro, e a opção de escolher entre eles ([themeMode]);
- linhas 56–58: o [builder] do [MaterialApp] envolve TODAS as telas. Aqui, o tamanho do texto de todo o aplicativo é alterado: [MediaQuery] descreve a tela e os ajustes do usuário (inclusive [textScaler], o fator de ampliação do texto, que também pode ser ajustado nas configurações de acessibilidade do celular);
- linha 104: removida; a área desaparece, junto com o estado local de seus widgets;
- Linhas 106–109: [Visibility] com [maintainState: true] OCULTA seu filho sem removê-lo: seu estado é preservado. (É o que [<Activity mode="hidden">] faz no curso de [React].)
Adicionamos dois itens e clicamos uma vez em cada contador local (à esquerda); removemos a área e passamos para o modo escuro (no meio); restauramos a área (à direita):
O carrinho de compras sobreviveu à remoção da seção (como mostra o segundo resumo); o contador removido voltou a zero; o contador oculto manteve seu valor. Pare o aplicativo e reinicie-o: o tema escuro e o tamanho do texto são preservados, e o carrinho de compras está vazio.
Por que [provider]? Há muitas bibliotecas de gerenciamento de estado para o [Flutter] ([Riverpod], [Bloc], [GetX], [MobX]...). [provider] é o mais simples: é apenas uma forma conveniente de escrever o [InheritedWidget] do exemplo 14, com base em o [ChangeNotifier] do [Flutter]. É o usado no guia de arquitetura da documentação do [Flutter] e o que será usado no estudo de caso.