Gerenciando o estado de apps Flutter com InheritedWidgets

Todo mundo já ouviu que aplicações interativas podem ser decompostas em três partes: modelo, view e controller. Qualquer pessoa que já tenha dado…

Todo mundo já ouviu que aplicações interativas podem ser decompostas em três partes: modelo, visão e controlador. Quem já experimentou o Flutter vai reconhecer seu suporte ao estilo React para construir view/controllers com widgets e callbacks. Nem todo mundo, porém, entende bem como o Flutter dá suporte à parte “modelo” do MVC.

O modelo de uma aplicação Flutter representa o estado persistente dela. Os widgets fornecem visualizações desse estado e permitem que o usuário o modifique. Um widget depende do modelo quando seu método build recupera valores do modelo ou quando seus callbacks modificam valores do modelo. Se um widget depende do modelo, ele deve ser reconstruído quando o modelo mudar. Como fazer isso acontecer é o tema deste artigo.

Este artigo analisa como as classes StatefulWidget e InheritedWidget do Flutter podem ser usadas para vincular os elementos visuais de uma aplicação ao seu modelo. Ele termina com uma classe ModelBinding pequena, mas espero que útil, que deve ser fácil de incluir em uma aplicação. Se você está ansioso para começar, pode baixar a classe ModelBinding junto com uma pequena demo agora mesmo.

Veja o exemplo completo de ModelBinding<T> em https://gist.github.com/HansMuller/a3a6d520c6a24238bf1b1b9e3d473bf5.
Veja o exemplo completo de ModelBinding<T> .

Ressalvas e expectativas do leitor

A abordagem para construir apps MVC descrita neste artigo não é a única. Há muitas formas de vincular o Flutter a modelos e, se você estiver planejando algo grande, talvez queira avaliar suas opções, algumas das quais listo no final deste artigo. Por outro lado, mesmo que você não decida adotar a pequena classe ModelBinding apresentada na última seção, pode aprender algo novo sobre o Flutter lendo este artigo.

Este não é um artigo introdutório sobre Flutter; espero que os leitores já tenham alguma experiência com a API do Flutter. Por exemplo, presume-se que:

  • Você está confortável escrevendo classes em Dart e entende a sobrecarga de operator == e hashcode, bem como métodos genéricos.

  • Você está familiarizado com as classes básicas de widgets do Flutter e sabe como escrever novos.

O modelo da aplicação

Para os exemplos a seguir, precisamos de um modelo de aplicação de exemplo. Para poupar nossa atenção já curta, mantive esse modelo o mais simples possível. Há apenas um campo de valor aqui e a classe real inclui as sobrescritas de operator == e hashCode.

dart
class Model {
  const Model({ this.value = 0 });
  final int value;
  // .. operator ==, hashCode
}

É fácil imaginar como se poderia estender os valores que o modelo representa.

Este é um modelo imutável, então alterá-lo significa substituí-lo. As abordagens MVC mostradas abaixo podem ser usadas com um modelo mutável; só que fica um pouco mais complicado nesse caso.

Vinculando ao modelo com StatefulWidget

Esta é a abordagem mais simples para integrar um modelo, perfeita para um app de uma tarde.

Um StatefulWidget está associado a um objeto State persistente. O método build do objeto State cria a subárvore contribuída pelo widget, assim como o método build de um StatelessWidget. O método setState do objeto State faz com que o widget seja construído novamente na próxima vez em que o intervalo de frames do display for atingido. Se o objeto de estado do widget stateful é dono do modelo, seu método build configura os widgets que ele cria usando valores do modelo, e ele chama setState quando o modelo muda.

Definir o widget stateful ViewController de exemplo exige um pouco de boilerplate:

dart
class ViewController extends StatefulWidget {
  _ViewControllerState createState() => _ViewControllerState();
}
​
class _ViewControllerState extends State<ViewController> {
  // the widget's persistent state goes here
  @override
  Widget build(BuildContext context) {
    // return a widget based on the persistent state
  }
}

Neste caso, o estado persistente do widget é uma instância de Model. O método build cria um botão que mostra o valor atual do modelo e substitui o modelo quando pressionado. O método updateModel redefine o currentModel e chama setState para disparar uma reconstrução. Em outras palavras, pressionar o botão atualiza o modelo e depois reconstrói o widget ViewController.

dart
Model currentModel = Model();
​
void updateModel(Model newModel) {
  if (newModel != currentModel) {
    setState(() {
      currentModel = newModel;
    });
  }
}
​
@override
Widget build(BuildContext context) {
  return RaisedButton(
    onPressed: () {
      updateModel(Model(value: currentModel.value + 1));
    },
    child: Text('Hello World ${currentModel.value}'),
  );
}

Limitações da vinculação com StatefulWidget

A abordagem descrita acima é um esboço inicial. Não é ideal para uma aplicação de porte relativamente grande:

  • Quando o modelo muda, o ViewController e toda a árvore de widgets que ele cria são reconstruídos. Não só os widgets que dependem do modelo, mas todos eles.

  • Se um widget filho precisa consultar o valor do modelo, o modelo precisa ser passado a ele por um parâmetro do construtor ou por um closure, como no exemplo trivial acima.

  • Se um widget descendente precisa consultar o valor do modelo, o modelo precisa ser passado a ele por uma cadeia de parâmetros de construtor.

  • Se um widget filho quer modificar o valor do modelo, ele precisa receber um callback fornecido pelo ViewController. No exemplo, seria o parâmetro onPressed do RaisedButton.

Fica claro que StatefulWidgets, embora adequados para criar widgets com algum estado interno persistente, não são ideais para compartilhar um modelo em uma aplicação complexa. E, como engenheiros de software, complexidade é o nosso pão com manteiga.

Vinculando ao modelo com InheritedWidget, versão 0

A classe InheritedWidget tem algumas propriedades especiais que a tornam adequada para compartilhar um modelo com uma árvore de widgets:

  • Dado um BuildContext, encontrar o ancestral InheritedWidget mais próximo de um tipo específico é barato: é apenas uma consulta em tabela.

  • Os InheritedWidgets mantêm o registro de seus dependentes, ou seja, os BuildContexts a partir dos quais o InheritedWidget foi acessado. Quando um InheritedWidget é reconstruído, todos os seus dependentes também são reconstruídos.

Você provavelmente já encontrou o widget herdado Theme. O método estático Theme.of(context) retorna o ThemeData do Theme e registra o context como dependente do Theme. Se o Theme for reconstruído com um ThemeData novo e diferente, todos os widgets que se referiram a ele com Theme.of() são reconstruídos automaticamente.

É fácil usar uma subclasse personalizada de InheritedWidget da mesma forma, como hospedeira do modelo da aplicação. Esta subclasse de InheritedWidget se chama ModelBinding porque conecta os widgets da aplicação ao modelo.

dart
class ModelBinding extends InheritedWidget {
  ModelBinding({
    Key key,
    this.model = const Model(),
    Widget child,
  }) : assert(model != null), super(key: key, child: child);
​
  final Model model;
​
  @override
  bool updateShouldNotify(ModelBinding oldWidget) => model != oldWidget.model;
}

O método updateShouldNotify é chamado quando o ModelBinding é reconstruído. Se ele retornar true, todos os widgets dependentes são reconstruídos.

O método BuildContext inheritFromWidgetOfExactType() é usado para buscar um widget herdado. Como ele é um tanto feio e por outros motivos que ficarão claros mais adiante, normalmente ele é encapsulado em um método estático. Adicionar o método de busca à classe Model torna possível recuperar o modelo a partir de qualquer descendente do ModelBinding com: Model.of(context):

Agora o ViewController pode ser stateless, e sua referência ao modelo fica assim:

dart
// Model.of(context) works from any ModelBinding descendant
Text('Hello World ${Model.of(context).value}')

Qualquer descendente do ModelBinding pode fazer a mesma coisa; não há necessidade de passar o Model para baixo. Se o modelo mudar, os widgets dependentes, como o ViewController, são reconstruídos automaticamente.

O próprio ModelBinding precisa ser construído por um widget stateful. Para alterar o modelo, esse widget stateful precisa ser reconstruído chamando seu método setState. Agora o widget App de nível superior se torna stateful, e um callback que atualiza o modelo precisa ser passado ao ViewController.

dart
class App extends StatefulWidget {
  @override
  _AppState createState() => _AppState();
}
​
class _AppState extends State<App> {
  Model currentModel = Model();
​
  void updateModel(Model newModel) {
    if (newModel != currentModel) {
      setState(() {
        currentModel = newModel;
      });
    }
  }
​
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: ModelBinding(
        model: currentModel,
        child: Scaffold(
          body: Center(
            child: ViewController(updateModel: updateModel),
          ),
        ),
      ),
    );
  }
}

Neste caso, Model é apenas um valor simples e imutável, então substituí-lo é tão simples quanto atribuir um novo currentModel. A substituição poderia ser mais complicada, por exemplo, se o modelo contivesse objetos que exigem gerenciamento de ciclo de vida; nesse caso, substituir o modelo poderia exigir o descarte de partes do modelo antigo.

Limitações da versão 0 do InheritedWidget

Por um lado, a versão do nosso vínculo de modelo com InheritedWidget facilita que os widgets acessem o modelo e automatiza a reconstrução dos widgets “dependentes” quando o modelo muda.

Por outro lado, ainda é necessário passar um callback updateModel pela árvore de widgets, até os widgets que precisam alterar o modelo.

Vinculando ao modelo com InheritedWidget, versão 1

Esta versão da abordagem InheritedWidget para vincular widgets a um modelo simplifica as atualizações do modelo. Agora qualquer descendente do ModelBinding pode obter o modelo e também atualizá-lo, e não há necessidade de passar um callback específico do modelo.

Assim, como antes, qualquer descendente do ModelBinding pode obter um valor do modelo com Model.of(context) e, ao fazer isso, se torna um dependente do modelo que é reconstruído automaticamente. Agora qualquer descendente do ModelBinding pode atualizar o modelo com Model.update(context, newModel). O que é ótimo.

Para permitir a reconstrução do modelo com o método estático Model.update(), é necessário introduzir um widget stateful extra. Isso fica um pouco complicado, então, se você estiver de chapéu, segure-o firme.

ModelBinding agora é um widget stateful que acompanha o valor atual do Model. O ModelBinding constrói um filho InheritedWidget privado, _ModelBindingScope, que tem uma referência ao State<ModelBinding> — um _ModelBindingState; essencialmente ao seu widget stateful pai. Para alterar o valor atual do modelo do ModelBinding, reconstrua o ModelBinding com setState(), o que por sua vez reconstrói o widget herdado _ModelBindingScope. Os métodos estáticos de Model para obter ou atualizar o modelo buscam o _ModelBindingScope:

dart
static Model of(BuildContext context) {
  _ModelBindingScope scope = context.inheritFromWidgetOfExactType(_ModelBindingScope);
  return scope.modelBindingState.currentModel;
}
​
static void update(BuildContext context, Model newModel) {
  _ModelBindingScope scope = context.inheritFromWidgetOfExactType(_ModelBindingScope);
  scope.modelBindingState.updateModel(newModel);
}

Qualquer descendente do ModelBinding pode agora atualizar ou alterar o modelo usando esses métodos. O botão do exemplo faz as duas coisas:

dart
RaisedButton(
  onPressed: () {
    Model model = Model.of(context);
    Model.update(context, Model(value: model.value + 1));
  },
  child: Text('Hello World ${Model.of(context).value}'),
);

Limitações da versão 1 do InheritedWidget

Esta versão é geralmente útil e tem menos de 100 linhas de código. Pode ser usada como está ou como ponto de partida para um sistema de vinculação de modelo mais complexo.

Há uma limitação que realmente precisa ser eliminada: o tipo de dado Model tem uma conexão privada com a implementação do ModelBinding. Os apps deveriam poder definir seus tipos de modelo do jeito que quiserem; eles não deveriam precisar estender a classe Model definida aqui. Para resolver isso, vamos adicionar um parâmetro de tipo.

Vinculando ao modelo com InheritedWidget, final

Esta versão isola o tipo Model. Agora o tipo do modelo da aplicação é o parâmetro de tipo do ModelBinding, e o ModelBinding fornece as funções estáticas genéricas of<T>(context) e update<T>(context).

A implementação fica um pouco mais complicada (de novo) por causa do parâmetro de tipo, e é por isso que ficou para o final. Por outro lado, a implementação continua bem pequena, com cerca de 64 linhas de código, e usar o widget ModelBinding e seus dois métodos estáticos deve ser bem direto.

A aplicação cria um ModelBinding do tipo MyModel assim:

dart
ModelBinding<MyModel>(
  initialState: MyModel(),
  child: child,
)

O modelo da aplicação, MyModel, é recuperado e atualizado com as versões genéricas dos métodos of e update assim:

dart
RaisedButton(
  onPressed: () {
    MyModel model = ModelBinding.of<MyModel>(context);
    ModelBinding.update<MyModel>(context, MyModel(value: model.value + 1));
  },
  child: Text('Hello World ${ModelBinding.of<MyModel>(context).value}'),
)

Resumindo, o ModelBinding e companhia podem ser facilmente fatorados em uma pequena biblioteca, em vez de ficarem acoplados à aplicação. Só a classe ModelBinding<T> precisa ser exportada.

Resumo

Este artigo teve como objetivo explicar os fundamentos das classes StatefulWidget e InheritedWidget do Flutter e mostrar como a segunda pode ser usada para vincular o modelo de uma aplicação aos seus widgets. Há muito mais a compartilhar sobre as duas classes e sobre classes relacionadas, como InheritedModel e InheritedNotifier. Tudo isso fica para outra ocasião.

ModelBinding<T> é uma classe simples baseada em InheritedWidget que pode ser usada para vincular um tipo de modelo arbitrário T aos widgets de uma aplicação. Para usá-la, baixe o exemplo e copie sua página de código para o seu app. E, se não funcionar para você, mude-a.

O código por trás do exemplo completo de ModelBinding. Abra para ler.
Veja o exemplo completo de ModelBinding<T>.

Esta é apenas uma breve amostra de artigos recentes sobre esse tema popular. O projeto Flutter mantém uma lista mais abrangente na página State Management do flutter.io.

  • Redux, Flutter ReduxThunk, finalmente um exemplo Uma arquitetura que fatora a aplicação em um modelo chamado “Store”, que é atualizado por um “Reducer” que processa “Actions” geradas pela interface do usuário.

  • Bloc, Arquitete seu projeto Flutter usando o padrão BLoC Uma arquitetura em que o modelo é um “Business Logic Component” (BLoC), que expõe seu estado com streams e permite mudanças por meio de sinks. Funciona bem com o widget StreamBuilder do Flutter.

  • ScopedModel, O pacote ScopedModel O ScopedModel possui um modelo, e os dependentes são envolvidos por um widget ScopedModelDescendant que se reconstrói quando o modelo muda. A reconstrução é tratada por um callback com um parâmetro model.

Mais do Flutter