Flutter e Cloud Firestore testáveis
Usando injeção de dependência para testar apps que usam Flutter e Firebase
Por que Cloud Firestore?
A pilha tecnológica da FlutterFire, formada por Flutter e Firebase (especificamente o Cloud Firestore), libera uma velocidade de desenvolvimento sem precedentes enquanto você constrói e lança seu app. Neste artigo, você vai explorar uma integração robusta entre essas duas tecnologias, com foco em testes e em padrões de arquitetura limpa. No entanto, em vez de pular direto para a implementação final, você vai construir o caminho passo a passo, para que o raciocínio por trás de cada etapa fique claro.
O que você vai construir
Para demonstrar uma forma limpa de implementar o Cloud Firestore como backend do seu app, você vai construir uma versão modificada do clássico app contador do Flutter. A única diferença é que o timestamp de cada clique é armazenado no Cloud Firestore, e a contagem exibida é derivada do número de timestamps persistidos. Você vai usar
Provider e ChangeNotifier para manter as dependências e o código de gerenciamento de estado limpos, e vai atualizar o teste gerado para manter o código
correto!
Antes de começar
Este artigo supõe que você assistiu e seguiu os passos deste tutorial para integrar seu app ao Firebase. Para recapitular:
Crie um novo projeto Flutter e chame-o de
firebasecounter.-
Crie um app Firebase no console do Firebase.
-
Vincule seu app ao iOS e/ou Android, dependendo do seu ambiente de desenvolvimento e do público-alvo.
Observação: se você configurar seu app para funcionar em um cliente Android, certifique-se de criar um arquivo
debug.keystoreantes de gerar seu certificado SHA1.
Depois de gerar seus apps iOS ou Android no Firebase, você está pronto para prosseguir. O restante do vídeo tem conteúdo ótimo que você provavelmente vai precisar em projetos reais, mas ele não é necessário para este tutorial.
Se você ficar preso
Se algum dos passos deste tutorial não funcionar para você, consulte este repositório público, que divide as mudanças em commits distintos. Ao longo do tutorial, você encontrará links para cada commit quando for apropriado. Sinta-se à vontade para usá-lo para verificar se você acompanhou tudo corretamente!
Criar um gerenciador de estado simples
Para iniciar a integração do seu app com o Cloud Firestore, primeiro você precisa refatorar o código gerado para que o StatefulWidget inicial se comunique com uma classe separada, em vez de com seus próprios atributos. Isso permite que você, mais adiante, instrua essa classe separada a usar o Cloud Firestore.
Ao lado do arquivo main.dart gerado automaticamente no seu projeto, crie um novo arquivo chamado counter_manager.dart e copie o código a seguir nele:
class CounterManager {
/// Create a private integer to store the count. Make this private
/// so that Widgets can't modify it directly, but instead must
/// use official methods.
int _count = 0;
/// Publicly accessible reference to our state.
int get count => _count;
/// Publicly accessible state mutator.
void increment() => _count++;
}
Com esse código no lugar, adicione a seguinte linha no topo de firebasecounter/lib/main.dart:
import 'package:firebasecounter/counter_manager.dart';
Em seguida, altere o código de _MyHomePageState para este:
class _MyHomePageState extends State<MyHomePage> {
final manager = CounterManager();
void _incrementCounter() {
setState(() => manager.increment());
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: Text(widget.title),
),
body: Center(
child: Column(
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[
Text('You have pushed the button this many times:'),
Text(
'${manager.count}',
style: Theme.of(context).textTheme.headline4,
),
],
),
),
floatingActionButton: FloatingActionButton(
onPressed: _incrementCounter,
tooltip: 'Increment',
child: Icon(Icons.add),
),
);
}
}
Depois de salvar essa mudança de código, seu app pode parecer travar e mostrar uma tela vermelha de erro. Isso acontece porque você introduziu uma nova variável,
manager, cuja oportunidade de ser inicializada já passou. É uma experiência comum com o Flutter quando você muda a forma como o
estado é inicializado, e isso se resolve facilmente com um hot restart.
Depois de um hot restart, você deve voltar ao ponto de partida: com a contagem em 0 e podendo clicar no Floating Action Button quantas vezes quiser.
Este é um bom momento para rodar o único teste que o Flutter fornece em qualquer projeto novo. Você pode encontrar a definição dele em
test/widget_test.dart, e executá-lo rodando:
$ flutter test
Supondo que o teste passe, você deve estar pronto para continuar!
Observação: se você ficou preso nesta seção, compare suas mudanças com este commit no repositório do tutorial.
Persistir timestamps
A descrição inicial do app mencionava persistir o timestamp de cada clique. Até agora, você não adicionou nenhuma infraestrutura para atender a esse segundo requisito, então crie outro arquivo novo chamado
app_state.dart e adicione a seguinte classe:
/// Container for the entirety of the app's state. An instance of
/// this class should be able to inform what is rendered at any
/// point in time.
class AppState {
/// Full click history. For super important auditing purposes.
/// The count of clicks becomes this list's `length` attribute.
final List<DateTime> clicks;
/// Default generative constructor. Const-friendly, for optimal
/// performance.
const AppState([List<DateTime> clicks])
: clicks = clicks ?? const <DateTime>[];
/// Convenience helper.
int get count => clicks.length;
/// Copy method that returns a new instance of AppState instead
/// of mutating the existing copy.
AppState copyWith(DateTime latestClick) => AppState([
latestClick,
...clicks,
]);
}
A partir deste ponto, a função da classe AppState é representar o estado do que deve ser renderizado. A classe não contém nenhum método que possa alterar a si mesma, apenas um único método
copyWith que outras classes vão usar.
Pensando em testes, você pode começar a fazer mudanças no conceito de CounterManager. Ter uma única classe não vai funcionar a longo prazo, porque o app acaba interagindo com o Cloud Firestore. Mas você não quer criar registros reais toda vez que rodar os testes. Para isso, você precisa de uma interface abstrata que defina como o app deve se comportar.
Abra counter_manager.dart novamente e adicione o seguinte código no topo do arquivo:
import 'package:firebasecounter/app_state.dart';
/// Interface that defines the functions required to manipulate
/// the app state.
///
/// Defined as an abstract class so that tests can operate on a
/// version that does not communicate with Firebase.
abstract class ICounterManager {
/// Any `CounterManager` must have an instance of the state
/// object.
AppState state;
/// Handler for when a new click must be stored. Does not require
/// any parameters, because it only causes the timestamp to
/// persist.
void increment();
}
O próximo passo é atualizar CounterManager para herdar explicitamente de ICounterManager. Atualize a definição para esta:
class CounterManager implements ICounterManager {
AppState state = AppState();
void increment() => state = state.copyWith(DateTime.now());
}
Neste ponto, nosso código auxiliar está bem encaminhado, mas main.dart ficou para trás. Não há nenhuma referência a ICounterManager em main.dart, quando, na verdade, essa é a única classe Manager que ela deveria conhecer. No arquivo
main.dart, aplique as seguintes mudanças:
- Adicione o import que está faltando no topo de
main.dart:
import 'package:firebasecounter/app_state.dart';
- Atualize
_MyHomePageStateda seguinte forma:
class _MyHomePageState extends State<MyHomePage> {
final ICounterManager manager;
_MyHomePageState({@required this.manager});
void _incrementCounter() => setState(() => manager.increment());
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: Text(widget.title),
),
body: Center(
child: Column(
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[
Text('You have pushed the button this many times:'),
Text(
'${manager.state.count}',
style: Theme.of(context).textTheme.headline4,
),
],
),
),
floatingActionButton: FloatingActionButton(
onPressed: _incrementCounter,
tooltip: 'Increment',
child: Icon(Icons.add),
),
);
}
}
Essa mudança deve remover as linhas vermelhas onduladas do seu IDE em _MyHomePageState, mas agora MyHomePage reclama porque o método createState() não fornece todos os argumentos obrigatórios para _MyHomePageState. Você poderia fazer MyHomePage exigir essa variável e passar o objeto adiante para sua classe baseada em State, mas isso poderia levar a longas cadeias de widgets que exigem e repassam objetos que eles não usam de fato, só porque algum widget descendente precisa dele e algum widget ancestral o fornece. Claramente, isso exige uma estratégia melhor.
Entre: Provider
Usando Provider para acessar o estado do app
Provider é uma biblioteca que simplifica o uso do padrão InheritedWidget
do Flutter. Provider permite que um widget alto na sua árvore de widgets seja acessado diretamente por todos os seus descendentes. Isso pode parecer uma variável global, mas a alternativa é passar seus modelos de dados por todos os widgets intermediários, muitos dos quais não têm nenhum interesse intrínseco neles. Esse anti-padrão de “
brigada de baldes” (bucket brigade) borra a separação de responsabilidades do seu app e pode tornar a refatoração de layouts desnecessariamente tediosa. InheritedWidget e Provider resolvem esses problemas ao permitir que widgets em qualquer ponto da árvore de widgets obtenham diretamente os modelos de dados de que precisam.
Para adicionar Provider ao seu app, abra pubspec.yaml e inclua-o na seção de dependências:
dependencies:
flutter:
sdk: flutter
# Add this
provider: ^4.3.2+2
Depois de adicionar essa linha ao seu arquivo pubspec.yaml, execute o seguinte comando para baixar Provider
na sua máquina:
$ flutter pub get
Ao lado de main.dart, crie um novo arquivo chamado dependencies.dart e copie o código a seguir nele:
import 'package:firebasecounter/counter_manager.dart';
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
class DependenciesProvider extends StatelessWidget {
final Widget child;
DependenciesProvider({@required this.child});
@override
Widget build(BuildContext context) {
return MultiProvider(
providers: [
Provider<ICounterManager>(create: (context) => CounterManager()),
],
child: child,
);
}
}
Algumas observações sobre DependenciesProvider:
-
Ele usa
MultiProvider, apesar de ter apenas uma entrada na lista. Tecnicamente, isso poderia ser simplificado para um único widgetProvider, mas um app real provavelmente vai conter vários desses serviços, então geralmente é melhor começar logo comMultiProvider. -
Ele exige um widget
child, que segue a convenção do Flutter para composição de widgets e nos permite inserir esse auxiliar perto do topo da árvore de widgets, tornando a instância deICounterManagerdisponível para todo o app.
Em seguida, torne o novo DependenciesProvider disponível para todo o app. Uma forma simples de fazer isso é envolver todo o widget
MaterialApp com ele. Abra main.dart e atualize o método
main
para ficar assim:
void main() {
runApp(
DependenciesProvider(child: MyApp()),
);
}
Você também precisa importar dependencies.dart em main.dart:
import 'package:firebasecounter/dependencies.dart';
Usando um widget Consumer
Você já viu o widget MultiProvider em ação (que é, na prática, uma forma mais elegante de declarar uma série de widgets Provider individuais). O próximo passo é acessar o objeto ICounterManager usando o widget
Consumer.
Injeção de dependência
Se você escreveu um app Flutter usando o Cloud Firestore, provavelmente descobriu que o Firestore pode dificultar a escrita de bons testes unitários. Afinal, como evitar gerar registros reais no seu banco de dados quando uma integração com o Firestore está ligada diretamente à sua árvore de widgets?
Se você teve essa experiência, então encontrou as limitações de embutir suas dependências diretamente no código da UI, que, no caso do Flutter, são os widgets. Esse é o poder da injeção de dependência: se seus widgets aceitam classes auxiliares que facilitam a interação deles com as dependências (como o Firebase, o sistema de arquivos do dispositivo ou até requisições de rede), então você pode fornecer mocks ou fakes no lugar das classes reais durante os testes. Isso permite testar se seus widgets se comportam como esperado sem esperar por requisições de rede lentas, sem encher seu sistema de arquivos e sem gerar cobranças do Firebase.
Para conseguir isso, você precisa refatorar o app para que exista um ponto claro onde os testes possam injetar fakes que imitem o comportamento real do Cloud Firestore. Felizmente, o widget
Consumer é perfeito para essa tarefa.
Abra main.dart e substitua seu widget MyApp pelo seguinte código:
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
return MaterialApp(
title: 'Flutter Demo',
theme: ThemeData(
primarySwatch: Colors.blue,
visualDensity: VisualDensity.adaptivePlatformDensity,
),
home: Consumer<ICounterManager>(
builder: (context, manager, _child) => MyHomePage(
manager: manager,
title: 'Flutter Demo Home Page',
),
),
);
}
}
Também importe Provider no topo de main.dart:
import 'package:provider/provider.dart';
Envolver MyHomePage em um widget Consumer permite alcançar qualquer nível alto da árvore de widgets para acessar os recursos desejados e injetá-los nos widgets que precisam deles. Pode parecer trabalho desnecessário neste tutorial, porque você só volta uma camada até
MyApp(), mas isso pode se estender por dezenas de widgets em apps de produção reais.
Em seguida, no mesmo arquivo, faça esta edição em MyHomePage:
Observação: não se preocupe se aparecer uma tela vermelha depois de salvar essa mudança. Ainda são necessárias mais edições para concluir a refatoração!
class MyHomePage extends StatefulWidget {
final ICounterManager manager;
MyHomePage({@required this.manager, Key key, this.title}) : super(key: key);
final String title;
@override
_MyHomePageState createState() => _MyHomePageState();
}
Essa mudança simples no construtor permite que o código aceite a variável passada no trecho anterior.
Por fim, conclua a refatoração fazendo esta edição em _MyHomePageState:
class _MyHomePageState extends State<MyHomePage> {
// No longer expect to receive a `ICounterManager object`
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: Text(widget.title),
),
body: Center(
child: Column(
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[
Text('You have pushed the button this many times:'),
Text(
// Reference `widget.manager` instead of
// `manager` directly
'${widget.manager.state.count}',
style: Theme.of(context).textTheme.headline4,
),
],
),
),
floatingActionButton: FloatingActionButton(
// Reference `widget.manager` instead of `manager` directly
onPressed: () => setState(() => widget.manager.increment()),
tooltip: 'Increment',
child: Icon(Icons.add),
),
);
}
}
Observação: você provavelmente vai precisar fazer um hot restart para corrigir seu app.
Como você deve se lembrar, todos os objetos State contêm uma referência aos seus StatefulWidget envolventes nos atributos widget. Assim, o objeto _MyHomePageState pode acessar esse novo atributo
manager mudando seu código de manager para widget.manager.
E pronto! Você injetou dependências nos widgets que precisam delas, em vez de fixar implementações de produção no código.
Testar o app
Se você executar flutter test agora, verá que a suíte de testes não passa mais. Ao inspecionar
widget_test.dart, o motivo pode ficar claro: a função de teste instancia MyApp(), mas não a envolve com
DependenciesProvider como você fez no código real, então o widget Consumer adicionado dentro de
MyApp não consegue encontrar um Provider satisfatório entre seus widgets ancestrais.
É aqui que a injeção de dependência começa a dar retorno. Em vez de imitar o código de produção nos testes (envolvendo
MyApp com DependenciesProvider), altere o teste para inicializar MyHomePage. Atualize
widget_test.dart para ficar assim:
import 'package:firebasecounter/counter_manager.dart';
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:firebasecounter/main.dart';
void main() {
testWidgets('Counter increments smoke test', (WidgetTester tester) async {
// Build our app and trigger a frame.
await tester.pumpWidget(
MaterialApp(
home: MyHomePage(
manager: CounterManager(),
title: 'Test Widget',
),
),
);
// Verify that our counter starts at 0.
expect(find.text('0'), findsOneWidget);
expect(find.text('1'), findsNothing);
// Tap the '+' icon and trigger a frame.
await tester.tap(find.byIcon(Icons.add));
await tester.pump();
// Verify that our counter has incremented.
expect(find.text('0'), findsNothing);
expect(find.text('1'), findsOneWidget);
});
}
Ao usar uma instância de MyHomePage diretamente (junto com um MaterialApp envolvente para fornecer objetos
BuildContext válidos), você se preparou para ter uma integração testada por unidade com o Cloud Firestore!
Observação: se você ficou preso nesta seção, compare suas mudanças com este commit no repositório do tutorial.
Implementando o Cloud Firestore
Até agora, você moveu bastante código e introduziu várias classes auxiliares, mas não mudou nada no funcionamento do app. A boa notícia é que tudo está no lugar para começar a escrever código que conhece o Cloud Firestore. Para começar, abra
pubspec.yaml e adicione estas duas linhas:
dependencies:
# Add this
cloud_firestore: ^0.14.1
# Add this
firebase_core: ^0.5.0
flutter:
sdk: flutter
provider: ^4.3.2+2
Sempre que aplicar mudanças em pubspec.yaml (a menos que seu IDE faça isso por você), execute o seguinte comando para baixar e vincular suas novas bibliotecas:
$ flutter pub get
Observação: se você ainda não criou seu banco de dados, acesse o console do Firebase do seu projeto, clique na aba Cloud Firestore e clique no botão Criar banco de dados.
Aguardando o Firebase
O primeiro passo para usar o Cloud Firestore com sucesso é inicializar o Firebase e, o mais importante, não tentar usar nenhum recurso do Firebase até que essa tarefa seja concluída com sucesso. Felizmente, você pode isolar essa lógica com um único
StatefulWidget, em vez de espalhar essa tarefa por todo o código.
Crie um novo arquivo em firebasecounter/lib/firebase_waiter.dart e adicione o seguinte código:
import 'package:firebase_core/firebase_core.dart';
import 'package:flutter/material.dart';
class FirebaseWaiter extends StatefulWidget {
final Widget Function(BuildContext) builder;
final Widget waitingChild;
const FirebaseWaiter({
@required this.builder,
this.waitingChild,
Key key,
}) : super(key: key);
@override
_FirebaseWaiterState createState() => _FirebaseWaiterState();
}
class _FirebaseWaiterState extends State<FirebaseWaiter> {
Future<FirebaseApp> firebaseReady;
@override
void initState() {
super.initState();
firebaseReady = Firebase.initializeApp();
}
@override
Widget build(BuildContext context) => FutureBuilder<FirebaseApp>(
future: firebaseReady,
builder: (context, snapshot) => //
snapshot.connectionState == ConnectionState.done
? widget.builder(context)
: widget.waitingChild,
);
}
Esta classe usa o padrão do Flutter de aproveitar certos widgets para lidar completamente com uma dependência ou problema específico do app. Para usar este
FirebaseWaiter, volte para main.dart e aplique a seguinte mudança em
MyApp:
// Add this import at the top
import 'package:firebasecounter/firebase_waiter.dart';
// Replace `MyApp` with this
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
return MaterialApp(
title: 'Flutter Demo',
theme: ThemeData(
primarySwatch: Colors.blue,
visualDensity: VisualDensity.adaptivePlatformDensity,
),
home: FirebaseWaiter(
builder: (context) => Consumer<ICounterManager>(
builder: (context, manager, _child) => MyHomePage(
manager: manager,
title: 'Flutter Demo Home Page',
),
),
// This is a great place to put your splash page!
waitingChild: Scaffold(
body: const Center(child: CircularProgressIndicator()),
),
),
);
}
}
Agora, o app consegue aguardar a inicialização do Firebase, mas pode pular esse processo durante os testes simplesmente não usando
FirebaseWaiter.
Observação: as mudanças acima podem fazer o Flutter reclamar de plugins do Firebase ausentes. Se isso acontecer, encerre completamente seu app e comece a depurar de novo, o que permite ao Flutter instalar todas as dependências específicas de cada plataforma.
Obtendo dados do Cloud Firestore
Primeiro, importe o Cloud Firestore adicionando a seguinte linha no topo de counter_manager.dart:
import 'package:cloud_firestore/cloud_firestore.dart';
Em seguida, também em counter_manager.dart, adicione a seguinte classe:
class FirestoreCounterManager implements ICounterManager {
AppState state;
final FirebaseFirestore _firestore;
FirestoreCounterManager()
: _firestore = FirebaseFirestore.instance,
state = const AppState() {
_watchCollection();
}
void _watchCollection() {
// Part 1
_firestore
.collection('clicks')
.snapshots()
// Part 2
.listen((QuerySnapshot snapshot) {
// Part 3
if (snapshot.docs.isEmpty) return;
// Part 4
final _clicks = snapshot.docs
.map<DateTime>((doc) {
final timestamp = doc.data()['timestamp'];
return (timestamp != null)
? (timestamp as Timestamp).toDate()
: null;
})
// Part 5
.where((val) => val != null)
// Part 6
.toList();
// Part 7
state = AppState(_clicks);
});
}
@override
void increment() {
_firestore.collection('clicks').add({
'timestamp': FieldValue.serverTimestamp(),
});
}
}
Observação: esta classe está quase correta, mas cria um bug que é explorado mais adiante. Se você adicionar este código ao seu app e executá-lo agora, verá que o comportamento não é o que você quer. Continue lendo para uma explicação detalhada do que está acontecendo!
Há muita coisa acontecendo aqui, então vamos analisar passo a passo.
Primeiro, FirestoreCounterManager implementa a interface ICounterManager, então é um candidato elegível para uso em widgets de produção. (Mais adiante, ela será fornecida por
DependenciesProvider!) FirestoreCounterManager também mantém uma instância de
FirebaseFirestore, que é a conexão ativa com o banco de dados de produção. FirestoreCounterManager
também chama _watchCollection() durante sua inicialização para configurar uma conexão com os dados específicos que você quer, e é aqui que as coisas ficam interessantes.
O método _watchCollection() faz muita coisa e merece um exame próprio.
Na Parte 1, _watchCollection() chama _firestore.collection('clicks').snapshots(), que retorna um stream de atualizações sempre que os dados da coleção mudam.
Na Parte 2, _watchCollection() registra imediatamente um listener nesse stream usando .listen(). O callback passado para
listen() recebe um novo objeto QuerySnapshot a cada mudança nos dados. Esse objeto de atualização é chamado de snapshot porque reflete o estado correto do banco de dados em um momento, mas, a qualquer momento, pode ser substituído por um novo snapshot.
Na Parte 3, o callback faz um curto-circuito se a coleção estiver vazia.
Na Parte 4, o callback percorre os documentos do snapshot e retorna uma lista de valores null
e DateTime misturados.
Na Parte 5, o callback descarta quaisquer valores null. Eles surgem do bug que será corrigido em breve, mas esse tipo de código defensivo é sempre uma boa ideia ao lidar com dados do Cloud Firestore.
Na Parte 6, o callback resolve o fato de que map() retorna um iterador, não uma lista. Chamar
.toList() em um iterador força o processamento de toda a coleção, que é o que você quer.
E por fim, na Parte 7, o callback atualiza o objeto state.
Para usar a nova classe, abra dependencies.dart e substitua o conteúdo dele por este:
import 'package:firebasecounter/counter_manager.dart';
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
class DependenciesProvider extends StatelessWidget {
final Widget child;
DependenciesProvider({@required this.child});
@override
Widget build(BuildContext context) {
return MultiProvider(
providers: [
Provider<ICounterManager>(
create: (context) => FirestoreCounterManager()),
],
child: child,
);
}
}
Diagnosticando o bug
Se você executar este código como está, verá quase o comportamento desejado. Tudo parece correto, exceto que a tela é sempre renderizada um clique atrás da realidade. O que está acontecendo?
O problema surge de uma incompatibilidade entre a implementação inicial do contador e a implementação atual, baseada em streams. O handler
onPressed de FloatingActionButton tem esta aparência:
floatingActionButton: FloatingActionButton(
onPressed: () => setState(() => widget.manager.increment()),
...
)
Esse handler chama increment() e imediatamente invoca setState(), que diz ao Flutter para renderizar novamente.
Isso funcionava muito bem ao atualizar de forma síncrona o estado mantido na memória do dispositivo. No entanto, a nova implementação baseada em stream inicia uma série de etapas assíncronas. Isso significa que, do jeito que está, o código chama
setState() imediatamente e então, apenas em algum momento futuro desconhecido, o objeto manager
atualiza seu atributo state. Resumindo, a chamada setState() no handler onPressed
está acontecendo cedo demais! Pior ainda, como toda essa atividade acontece dentro de um callback, no fundo de FirestoreCounterManager que nenhum widget conhece, não existe Future
que os widgets possam await para resolver o problema.
Parece até que o objeto manager precisa conseguir avisar os widgets quando redesenhar. 🤔
Entre: ChangeNotifier
Observação: se você travou nesta seção, compare suas mudanças com este commit no repositório público. Essas mudanças incluem alterações no Xcode e no build.gradle resultantes da adição do Firebase, mas você provavelmente pode focar nas mudanças nos arquivos Dart.
Usando ChangeNotifier para re-renderizar a árvore de widgets
ChangeNotifier é uma classe que faz exatamente o que o nome sugere: ela notifica os widgets quando ocorrem mudanças que exigem uma nova renderização.
O primeiro passo deste processo é atualizar a interface ICounterManager para estender ChangeNotifier. Para isso, abra
firebasecounter/lib/counter_manager.dart e faça as seguintes mudanças na
declaração de ICounterManager:
// Add `extends ChangeNotifier` to your declaration
abstract class ICounterManager extends ChangeNotifier {
// Everything inside the class is the same.
}
Se você ainda não importou flutter/material.dart, abra firebasecounter/lib/counter_manager.dart e adicione-o no topo:
import 'package:flutter/material.dart';
Agora você está pronto para atualizar as definições de CounterManager e FirestoreCounterManager. Para
CounterManager, substitua o código dela pela seguinte implementação:
class CounterManager extends ChangeNotifier implements ICounterManager {
AppState state = AppState();
/// Copies the state object with the timestamp of the most
/// recent click and tells the stream to update.
void increment() {
state = state.copyWith(DateTime.now());
// Adding this line is how `ChangeNotifier` tells widgets to
// re-render themselves.
notifyListeners();
}
}
E, para FirebaseCounterManager, aplique as seguintes mudanças:
- Edite a assinatura para ficar assim:
class FirestoreCounterManager extends ChangeNotifier
implements ICounterManager {
...
}
-
Adicione a mesma linha
notifyListeners();ao final de_watchCollection(), assim:
void _watchCollection() {
_firestore
.collection('clicks')
.snapshots()
.listen((QuerySnapshot snapshot) {
// Generation of `_clicks` omitted for clarity, but do not
// change that code.
state = AppState(_clicks);
// The only change necessary is to add this line!
notifyListeners();
});
}
Você agora configurou metade das mudanças necessárias para que as classes ICounterManager avisem os widgets para re-renderizar sempre que os dados mudarem. As classes
Manager estão avisando os widgets para re-renderizar, mas se você executar o app agora, verá que os widgets não estão escutando.
Para corrigir isso, abra dependencies.dart e substitua a implementação de DependenciesProvider
pelo seguinte:
class DependenciesProvider extends StatelessWidget {
final Widget child;
DependenciesProvider({@required this.child});
@override
Widget build(BuildContext context) {
return MultiProvider(
providers: [
// `Provider` has been replaced by ChangeNotifierProvider
ChangeNotifierProvider<ICounterManager>(
create: (context) => FirestoreCounterManager(),
),
],
child: child,
);
}
}
Como última mudança, remova setState de _MyHomePageState para evitar uma re-renderização desnecessária. Atualize a
FloatingActionButton para ficar assim:
floatingActionButton: FloatingActionButton(
// Remove setState()!
onPressed: widget.manager.increment,
tooltip: 'Increment',
child: Icon(Icons.add),
),
E pronto! ChangeNotifierProvider garante que os widgets sejam “ouvintes”, de modo que, quando
notifyListeners() é chamado por uma classe ICounterManager, os widgets recebem a mensagem para re-renderizar.
Neste ponto, você já deve conseguir fazer hot restart no app e ver tudo funcionando!
Observação: se você travou nesta seção, compare suas mudanças com este commit do repositório público.
Corrigindo os testes
Embora a última rodada de mudanças tenha implementado a funcionalidade desejada, infelizmente elas também quebraram os testes. Agora você vai aplicar mais alguns ajustes para deixar tudo funcionando de novo e, então, terminamos.
Em widget_test.dart, o código passa uma instância de CounterManager diretamente, sem uma
ChangeNotifierListener correspondente. A forma como isso era tratado na árvore de widgets era envolver tudo em
DependenciesProvider, mas essa classe conhece o Firestore, e o objetivo de tudo isso é manter o Firestore fora dos testes.
Uma solução é criar TestDependenciesProvider, que pode conter as versões de teste de todas as dependências. Abra
firebasecounter/lib/dependencies.dart e adicione a seguinte classe:
class TestDependenciesProvider extends StatelessWidget {
final Widget child;
TestDependenciesProvider({@required this.child});
@override
Widget build(BuildContext context) {
return MultiProvider(
providers: [
ChangeNotifierProvider<ICounterManager>(
create: (context) => CounterManager(),
),
],
child: child,
);
}
}
Essa classe é quase idêntica a DependenciesProvider, mas TestDependenciesProvider
fornece uma instância de CounterManager() em vez de FirestoreCounterManager().
Agora, em test/widget_test.dart, atualize a inicialização do widget de teste para isto:
await tester.pumpWidget(
TestDependenciesProvider(
child: MaterialApp(
home: Consumer<ICounterManager>(
builder: (context, manager, _child) => MyHomePage(
manager: manager,
title: 'Flutter Test Home Page',
),
),
),
),
);
Se ainda não fez isso, adicione estes dois imports perto do topo de test/widget_test.dart:
import 'package:firebasecounter/dependencies.dart';
import 'package:provider/provider.dart';
Rode seus testes de novo e, voilà!
Observação: se você travou nesta seção, compare suas mudanças com este commit do repositório público.
Encerrando
Neste artigo, você remodelou o clássico app de contador do Flutter para que ele persista toda a atividade no Cloud Firestore. Você também evitou misturar lógica de negócio em qualquer widget, o que torna o app fácil de testar.
As técnicas de gerenciamento de estado abordadas aqui são viáveis para muitos apps, mas não são as únicas nem as melhores. A comunidade Flutter é rica em excelentes soluções de gerenciamento de estado que valem a pena ser investigadas. Aqui estão algumas para considerar:
-
Flutter Bloc é especialmente útil para quem tem experiência com Redux.
-
Esta série de tutoriais em vídeo sobre Flutter Firebase e DDD de Reso Coder guia você por todo o processo de uso do Flutter Bloc, Cloud Firestore e várias outras bibliotecas excelentes.
-
Este port mais direto do Redux também é popular.
-
A novidade da lista: o criador de
Providerlançou um novo pacote, Riverpod, que é o sucessor deProvider.
Para mais informações sobre gerenciamento de estado, veja a documentação de State Management no flutter.dev.
Qualquer que seja a solução de gerenciamento de estado que você escolher, boa sorte e feliz programação!