Fora de profundidade com o Flutter
Como a programação reativa, a composição de widgets e a UI como código podem enterrar a lógica da sua view em aninhamentos profundos, e o que fazer a respeito.
Flutter é um novo framework para criar apps nativos de alta qualidade para iOS e Android em tempo recorde. Na minha experiência usando o Flutter (como membro da equipe do Flutter), a velocidade de desenvolvimento vem principalmente do seguinte:
-
Hot reload com estado. A experiência de desenvolvimento do Flutter é alimentada pela tecnologia do compilador e da VM do Dart, permitindo carregar alterações de código em um app em execução enquanto mantém o estado do app (incluindo a tela para a qual você navegou). Ao salvar, você verá o efeito da mudança no dispositivo em menos de um segundo.
-
Programação reativa. O Flutter segue outros frameworks modernos na forma de definir e atualizar a interface do usuário: ambas as coisas acontecem com base em uma única descrição de como a interface depende do estado atual.
-
Composição. No Flutter, tudo é um widget, e você alcança qualquer resultado desejado compondo livremente widgets focados, no estilo de peças de Lego.
-
UI como código. O Flutter não vem com uma linguagem de marcação de layout separada. Cada widget é escrito somente em Dart, em um único lugar, eliminando a troca de sintaxe e a troca de arquivo.
Curiosamente, as últimas três listas acima se juntam para formar um desafio à velocidade de desenvolvimento: perder-se no caminho e na lógica de view dentro de árvores de widgets profundamente aninhadas.
Abaixo vou discutir por que esse problema surge e o que você pode fazer a respeito. Ao longo do caminho, vou tentar lançar luz sobre como o Flutter funciona.
Programação reativa
O modelo de programação reativa do Flutter convida você a usar programação declarativa para definir sua interface de usuário, como uma função do estado atual:
@override
Widget build(BuildContext context) {
return // some widget based on current state
}
Widgets são descrições imutáveis da interface de usuário. Somos solicitados a retornar um único widget definido por uma única expressão. Não existe uma sequência de comandos mutadores para configurar ou atualizar uma view mutável. Em vez disso, apenas chamamos algum construtor de widget.
Composição
Widgets costumam ser simples, cada um fazendo uma coisa bem: Text, Icon, Padding,
Center, Column, Row, … Para alcançar qualquer resultado não trivial, muitos widgets precisam ser compostos. Assim, nossa expressão única facilmente se torna uma árvore profundamente aninhada de chamadas de construtores de widgets:

Widgets têm propriedades além de child/children, mas você entendeu a ideia.
UI como código
Escrever e editar árvores profundamente aninhadas exige um editor decente e um pouco de prática para ficar eficiente. Desenvolvedores parecem tolerar aninhamento profundo melhor em marcação de layout (XML, HTML) do que em código, mas a abordagem de UI como código do Flutter significa que o aninhamento profundo de código. Qualquer lógica de view que você tenha dentro da sua árvore de widgets — condicionais, transformações, iterações usadas para ler o estado atual, manipuladores de eventos usados para alterá-lo — também fica profundamente aninhada.
E esse é, então, o desafio.
O desafio
O tutorial de layout do flutter.io oferece um exemplo ilustrativo usando — ao que parece — um app explorador de lagos.

Aqui está uma árvore de widgets bruta implementando esta view:
import 'package:flutter/material.dart';
void main() {
runApp(MyApp());
}
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
return MaterialApp(
title: 'Flutter Demo',
home: Scaffold(
appBar: AppBar(title: Text('Top Lakes')),
body: ListView(
children: <Widget>[
Image.asset(
'images/lake.jpg',
width: 600.0,
height: 240.0,
fit: BoxFit.cover,
),
Container(
padding: const EdgeInsets.all(32.0),
child: Row(
children: <Widget>[
Expanded(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
Container(
padding: const EdgeInsets.only(bottom: 8.0),
child: Text(
'Oeschinen Lake Campground',
style: TextStyle(fontWeight: FontWeight.bold),
),
),
Text(
'Kandersteg, Switzerland',
style: TextStyle(color: Colors.grey[500]),
),
],
),
),
Row(
children: <Widget>[
Icon(Icons.star, color: Colors.red[500]),
Text('41'),
],
),
],
),
),
Container(
child: Row(
mainAxisAlignment: MainAxisAlignment.spaceEvenly,
children: <Widget>[
Column(
mainAxisSize: MainAxisSize.min,
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[
Icon(Icons.call, color: Theme.of(context).primaryColor),
Container(
margin: const EdgeInsets.only(top: 8.0),
child: Text(
'CALL',
style: TextStyle(
fontSize: 12.0,
fontWeight: FontWeight.w400,
color: Theme.of(context).primaryColor,
),
),
),
],
),
Column(
mainAxisSize: MainAxisSize.min,
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[
Icon(Icons.near_me,
color: Theme.of(context).primaryColor),
Container(
margin: const EdgeInsets.only(top: 8.0),
child: Text(
'ROUTE',
style: TextStyle(
fontSize: 12.0,
fontWeight: FontWeight.w400,
color: Theme.of(context).primaryColor,
),
),
),
],
),
Column(
mainAxisSize: MainAxisSize.min,
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[
Icon(Icons.share, color: Theme.of(context).primaryColor),
Container(
margin: const EdgeInsets.only(top: 8.0),
child: Text(
'SHARE',
style: TextStyle(
fontSize: 12.0,
fontWeight: FontWeight.w400,
color: Theme.of(context).primaryColor,
),
),
),
],
),
],
),
),
Container(
padding: const EdgeInsets.all(32.0),
child: Text(
'Lake Oeschinen lies at the foot of the Blüemlisalp in the '
'Bernese Alps. Situated 1,578 meters above sea level, it '
'is one of the larger Alpine Lakes. A gondola ride from '
'Kandersteg, followed by a half-hour walk through pastures '
'and pine forest, leads you to the lake, which warms to '
'20 degrees Celsius in the summer. Activities enjoyed here '
'include rowing, and riding the summer toboggan run.',
softWrap: true,
),
),
],
),
),
);
}
}
Esta é apenas uma árvore de widgets estática, sem implementar nenhum comportamento. Mas incorporar sua lógica de view diretamente nessa árvore pode não ser uma experiência agradável.
Desafio aceito.
UI como código, revisitado
Com a abordagem de UI como código do Flutter, a árvore de widgets é, bem, apenas código. Então podemos usar todas as nossas ferramentas habituais de organização de código para melhorar a situação. Uma das ferramentas mais simples da caixa é dar nome às subexpressões. Isso vira a árvore de widgets do avesso, sintaticamente. Em vez de
return A(B(C(D(), E())), F());
podemos dar nome a cada subexpressão e obter
final Widget d = D();
final Widget e = E();
final Widget c = C(d, e);
final Widget b = B(c);
final Widget f = F();
return A(b, f);
Nosso app de lagos pode ser reescrito da seguinte forma:
import 'package:flutter/material.dart';
void main() {
runApp(MyApp());
}
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
final Widget imageSection = Image.asset(
'images/lake.jpg',
width: 600.0,
height: 240.0,
fit: BoxFit.cover,
);
final Widget titles = Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
Container(
padding: const EdgeInsets.only(bottom: 8.0),
child: Text(
'Oeschinen Lake Campground',
style: TextStyle(fontWeight: FontWeight.bold),
),
),
Text(
'Kandersteg, Switzerland',
style: TextStyle(color: Colors.grey[500]),
),
],
);
final Widget stars = Row(
children: <Widget>[
Icon(Icons.star, color: Colors.red[500]),
Text('41'),
],
);
final Widget titleSection = Container(
padding: const EdgeInsets.all(32.0),
child: Row(
children: <Widget>[
Expanded(child: titles),
stars,
],
),
);
final Widget callAction = Column(
mainAxisSize: MainAxisSize.min,
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[
Icon(Icons.call, color: Theme.of(context).primaryColor),
Container(
margin: const EdgeInsets.only(top: 8.0),
child: Text(
'CALL',
style: TextStyle(
fontSize: 12.0,
fontWeight: FontWeight.w400,
color: Theme.of(context).primaryColor,
),
),
),
],
);
final Widget routeAction = Column(
mainAxisSize: MainAxisSize.min,
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[
Icon(Icons.near_me, color: Theme.of(context).primaryColor),
Container(
margin: const EdgeInsets.only(top: 8.0),
child: Text(
'ROUTE',
style: TextStyle(
fontSize: 12.0,
fontWeight: FontWeight.w400,
color: Theme.of(context).primaryColor,
),
),
),
],
);
final Widget shareAction = Column(
mainAxisSize: MainAxisSize.min,
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[
Icon(Icons.share, color: Theme.of(context).primaryColor),
Container(
margin: const EdgeInsets.only(top: 8.0),
child: Text(
'SHARE',
style: TextStyle(
fontSize: 12.0,
fontWeight: FontWeight.w400,
color: Theme.of(context).primaryColor,
),
),
),
],
);
final Widget actionSection = Container(
child: Row(
mainAxisAlignment: MainAxisAlignment.spaceEvenly,
children: <Widget>[
callAction,
routeAction,
shareAction,
],
),
);
final Widget textSection = Container(
padding: const EdgeInsets.all(32.0),
child: Text(
'Lake Oeschinen lies at the foot of the Blüemlisalp in the '
'Bernese Alps. Situated 1,578 meters above sea level, it '
'is one of the larger Alpine Lakes. A gondola ride from '
'Kandersteg, followed by a half-hour walk through pastures '
'and pine forest, leads you to the lake, which warms to '
'20 degrees Celsius in the summer. Activities enjoyed here '
'include rowing, and riding the summer toboggan run.',
softWrap: true,
),
);
final Widget scaffold = Scaffold(
appBar: AppBar(title: Text('Top Lakes')),
body: ListView(
children: <Widget>[
imageSection,
titleSection,
actionSection,
textSection,
],
),
);
return MaterialApp(
title: 'Flutter Demo',
home: scaffold,
);
}
}
Os níveis de indentação agora são mais razoáveis, e podemos deixar as subárvores tão rasas quanto quisermos introduzindo mais nomes. Melhor ainda: ao dar nomes significativos a subárvores individuais, comunicamos o papel de cada uma. Assim, agora podemos falar sobre as subárvores
xxxAction… e observar que temos muita duplicação de código entre elas! Outra ferramenta básica de organização de código — abstração funcional — resolve isso:
import 'package:flutter/material.dart';
void main() {
runApp(MyApp());
}
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
final Widget imageSection = ...
final Widget titles = ...
final Widget stars = ...
final Widget titleSection = ...
Widget action(String label, IconData icon) {
final Color color = Theme.of(context).primaryColor;
return Column(
mainAxisSize: MainAxisSize.min,
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[
Icon(icon, color: color),
Container(
margin: const EdgeInsets.only(top: 8.0),
child: Text(
label,
style: TextStyle(
fontSize: 12.0,
fontWeight: FontWeight.w400,
color: color,
),
),
),
],
);
}
final Widget actionSection = Container(
child: Row(
mainAxisAlignment: MainAxisAlignment.spaceEvenly,
children: <Widget>[
action('CALL', Icons.call),
action('ROUTE', Icons.near_me),
action('SHARE', Icons.share),
],
),
);
final Widget textSection = ...
final Widget scaffold = ...
return MaterialApp(
title: 'Flutter Demo',
home: scaffold,
);
}
}
Veremos uma alternativa mais “Flutter” do que a abstração funcional simples daqui a pouco.
Composição, revisitada
E agora? Bem, o método build ainda é bem longo. Talvez possamos extrair algumas partes significativas… Partes? Widgets! Widgets do Flutter são todos sobre composição e reuso. Compusemos um widget complexo a partir de widgets simples fornecidos pelo framework. Mas, achando o resultado complexo demais, podemos optar por decompô-lo em widgets personalizados menos complexos. Widgets personalizados são cidadãos de primeira classe no mundo Flutter, e widgets bem definidos têm grande potencial de reuso. Vamos transformar a função
action em um tipo de widget Action e colocá-lo em um arquivo próprio:
import 'package:flutter/material.dart';
import 'src/widgets.dart';
void main() {
runApp(MyApp());
}
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
final Widget imageSection = ...
final Widget titles = ...
final Widget titleSection = ...
final Widget actionSection = Container(
child: Row(
mainAxisAlignment: MainAxisAlignment.spaceEvenly,
children: <Widget>[
Action(label: 'CALL', icon: Icons.call),
Action(label: 'ROUTE', icon: Icons.near_me),
Action(label: 'SHARE', icon: Icons.share),
],
),
);
final Widget textSection = ...
final Widget scaffold = ...
return MaterialApp(
title: 'Flutter Demo',
home: scaffold,
);
}
}
import 'package:flutter/material.dart';
class Action extends StatelessWidget {
Action({Key key, this.label, this.icon}) : super(key: key);
final String label;
final IconData icon;
@override
Widget build(BuildContext context) {
final Color color = Theme.of(context).primaryColor;
return Column(
mainAxisSize: MainAxisSize.min,
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[
Icon(icon, color: color),
Container(
margin: const EdgeInsets.only(top: 8.0),
child: Text(
label,
style: TextStyle(
fontSize: 12.0,
fontWeight: FontWeight.w400,
color: color,
),
),
),
],
);
}
}
Agora podemos reutilizar o widget Action em qualquer lugar do nosso app, exatamente como se fosse definido pelo próprio framework do Flutter.
Mas, ei, uma função action de nível superior não atenderia à mesma necessidade?
Em geral, não.
-
Muitos widgets são construídos a partir de outros widgets; seus construtores têm parâmetros
childechildrentipados comoWidgeteList<Widget>. Assim, a funçãoactionnão pode ser passada para nenhum deles. É claro que o resultado de invocaractionpode ser. Mas aí você passaria uma árvore de widgets pré-construída no contexto de build atual, em vez de umStatelessWidgetque constrói sua subárvore somente se necessário e no contexto definido por onde ela acabar na árvore geral. Reparou na expressãoTheme.of(context).primaryColorno início deAction.build? Ela recupera a cor primária do widgetThememais próximo na cadeia de pais — que pode muito bem ser diferente doThememais próximo no ponto em queactionseria invocado. -
Actioné definido como umStatelessWidgetque é pouco mais que uma função build transformada em método de instância. Mas existem outros tipos de widget com comportamentos mais elaborados. Clientes deActionnão devem se importar com o tipo de widget queActioné. Por exemplo, se quiséssemos dar aActionuma animação intrínseca, talvez tivéssemos que transformá-lo em umStatefulWidgetpara gerenciar o estado da animação. O restante do app não deveria ser afetado por essa mudança.
Programação reativa, revisitada
O gerenciamento de estado é o sinal para começar a aproveitar o modelo de programação reativa do Flutter e dar vida à nossa view estática. Vamos definir o estado do app. Vamos manter simples e assumir uma classe de lógica de negócio
Lake cujo único estado mutável é se o usuário marcou o app com estrela:
abstract class Lake {
String get imageAsset;
String get name;
String get locationName;
String get description;
int get starCount;
bool get isStarred;
void toggleStarring();
void call();
void route();
void share();
}
Podemos então construir nossa árvore de widgets dinamicamente a partir de uma instância de Lake e, como parte disso, configurar manipuladores de eventos para chamar seus métodos. A beleza do modelo de programação reativa é que só precisamos fazer isso uma vez na base de código. O framework do Flutter reconstruirá nossa árvore de widgets sempre que a instância
Lake mudar — desde que informemos o framework sobre isso. Isso exige tornar MyApp
um StatefulWidget, o que por sua vez envolve delegar a construção de widgets a um objeto State
associado e então chamar o método State.setState sempre que alternarmos a marcação com estrela em nosso Lake.
import 'package:flutter/material.dart';
import 'src/lake.dart';
import 'src/widgets.dart';
void main() {
// Pretend we get a Lake instance from business logic.
final Lake lake = Lake();
runApp(MyApp(lake));
}
class MyApp extends StatefulWidget {
final Lake lake;
MyApp(this.lake);
@override
MyAppState createState() => new MyAppState();
}
class MyAppState extends State<MyApp> {
@override
Widget build(BuildContext context) {
final Lake lake = widget.lake;
final Widget imageSection = Image.asset(
lake.imageAsset,
width: 600.0,
height: 240.0,
fit: BoxFit.cover,
);
final Widget titles = Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
Container(
padding: const EdgeInsets.only(bottom: 8.0),
child: Text(
lake.name,
style: TextStyle(fontWeight: FontWeight.bold),
),
),
Text(
lake.locationName,
style: TextStyle(color: Colors.grey[500]),
),
],
);
final Widget stars = GestureDetector(
child: Row(
children: <Widget>[
Icon(
lake.isStarred ? Icons.star : Icons.star_border,
color: Colors.red[500],
),
Text('${lake.starCount}'),
],
),
onTap: () {
setState(() {
lake.toggleStarring();
});
},
);
final Widget titleSection = Container(
padding: const EdgeInsets.all(32.0),
child: Row(
children: <Widget>[
Expanded(child: titles),
stars,
],
),
);
final Widget actionSection = Container(
child: Row(
mainAxisAlignment: MainAxisAlignment.spaceEvenly,
children: <Widget>[
Action(label: 'CALL', icon: Icons.call, handler: lake.call),
Action(label: 'ROUTE', icon: Icons.near_me, handler: lake.route),
Action(label: 'SHARE', icon: Icons.share, handler: lake.share),
],
),
);
final Widget textSection = Container(
padding: const EdgeInsets.all(32.0),
child: Text(
lake.description,
softWrap: true,
),
);
final Widget scaffold = Scaffold(
appBar: AppBar(title: Text('Top Lakes')),
body: ListView(
children: <Widget>[
imageSection,
titleSection,
actionSection,
textSection,
],
),
);
return MaterialApp(
title: 'Flutter Demo',
home: scaffold,
);
}
}
import 'package:flutter/material.dart';
class Action extends StatelessWidget {
Action({Key key, this.label, this.icon, this.handler}) : super(key: key);
final String label;
final IconData icon;
final VoidCallback handler;
@override
Widget build(BuildContext context) {
final Color color = Theme.of(context).primaryColor;
return Column(
mainAxisSize: MainAxisSize.min,
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[
IconButton(
icon: Icon(icon, color: color),
onPressed: handler,
),
Text(
label,
style: TextStyle(
fontSize: 12.0,
fontWeight: FontWeight.w400,
color: color,
),
),
],
);
}
}
Isso funciona, mas não é particularmente eficiente. O desafio original era uma árvore de widgets profundamente aninhada. Essa árvore ainda está lá, se não no nosso código, então em tempo de execução. Reconstruir tudo isso só para alternar a marcação com estrela é desperdício. Concedido, o Dart é implementado para lidar com objetos de vida curta com bastante eficiência, mas até o Dart vai drenar sua bateria se você reconstruir o mundo repetidamente — especialmente quando há animações envolvidas. Em geral, devemos restringir a reconstrução às subárvores que realmente mudam.
Você percebeu a contradição? A árvore de widgets é uma descrição imutável da interface de usuário. Como podemos reconstruir parte disso sem reconstruí-la desde a raiz? Bem, na verdade, a árvore de widgets não é uma estrutura de árvore materializada com referências do widget pai para o widget filho, da raiz para as folhas. Em particular,
StatelessWidget e StatefulWidget não têm referências a filhos. O que eles fornecem são métodos
build (no caso com estado, por meio das instâncias State associadas). O framework do Flutter chama esses métodos
build, recursivamente, enquanto gera ou atualiza uma estrutura de árvore de tempo de execução real, não de widgets, mas de instâncias Element que referenciam widgets. A árvore de elementos é mutável e gerenciada pelo framework do Flutter.
Então, o que realmente acontece quando você chama setState em uma instância de State s? O framework do Flutter marca a subárvore enraizada no elemento correspondente a
s para reconstrução. Quando o próximo frame estiver para ser gerado, essa subárvore é atualizada com base na árvore de widgets retornada pelo método
build de s, que por sua vez depende do estado atual do app.
Nossa última tentativa no código extrai um widget LakeStars com estado para restringir as reconstruções a uma subárvore bem pequena. E MyApp volta a ser sem estado:
import 'package:flutter/material.dart';
import 'src/lake.dart';
import 'src/widgets.dart';
void main() {
// Pretend we get a Lake instance from business logic.
final Lake lake = Lake();
runApp(MyApp(lake));
}
class MyApp extends StatelessWidget {
const MyApp(this.lake);
final Lake lake;
@override
Widget build(BuildContext context) {
final Widget imageSection = ...
final Widget titles = ...
final Widget titleSection = Container(
padding: const EdgeInsets.all(32.0),
child: Row(
children: <Widget>[
Expanded(child: titles),
LakeStars(lake: lake),
],
),
);
final Widget actionSection = ...
final Widget textSection = ...
final Widget scaffold = ...
return MaterialApp(
title: 'Flutter Demo',
home: scaffold,
);
}
}
import 'package:flutter/material.dart';
import 'lake.dart';
class LakeStars extends StatefulWidget {
LakeStars({Key key, this.lake}) : super(key: key);
final Lake lake;
@override
State createState() => LakeStarsState();
}
class LakeStarsState extends State<LakeStars> {
@override
Widget build(BuildContext context) {
final Lake lake = widget.lake;
return GestureDetector(
child: Row(
children: <Widget>[
Icon(
lake.isStarred ? Icons.star : Icons.star_border,
color: Colors.red[500],
),
Text('${lake.starCount}'),
],
),
onTap: () {
setState(() {
lake.toggleStarring();
});
},
);
}
}
class Action extends StatelessWidget { ... }
Parece sensato desacoplar um widget Stars de uso geral do conceito Lake,
mas deixarei isso como exercício para o leitor.
Tendo adicionado com sucesso lógica de view ao código, em uma profundidade de aninhamento administrável, acho que chegamos a uma resposta razoável ao desafio do aninhamento profundo.
É possível imaginar várias soluções técnicas interessantes para o problema de perder o controle da lógica de view do Flutter dentro de árvores de widgets profundamente aninhadas. Algumas delas podem exigir mudanças no framework do Flutter, nas IDEs e em outras ferramentas, ou talvez até na sintaxe da linguagem Dart.
Mas há coisas poderosas que você já pode fazer hoje, simplesmente transformando as causas do problema — UI como código, composição de widgets e programação reativa — em vantagem sua. Eliminar a sintaxe profundamente aninhada é só o começo de uma jornada rumo a um código de app mobile legível, sustentável e eficiente.
Boa programação com Flutter!