Do zero ao um com Flutter
Era o fim do verão de 2016, e minha primeira tarefa como novo contratado no escritório do Google em Aarhus, Dinamarca, era implementar gráficos animados
Era o final do verão de 2016, e minha primeira tarefa como novo contratado no escritório do Google em Aarhus, Dinamarca, era implementar gráficos animados em um app Android/iOS usando Flutter e Dart. Além de ser um “Noogler”, eu era novo em Flutter, novo em Dart e novo em animações. Na verdade, eu nunca tinha feito um app mobile antes. Meu primeiro smartphone tinha apenas alguns meses — comprado num acesso de pânico de que eu pudesse falhar na entrevista por telefone ao atender a ligação com meu velho Nokia...
Eu tinha alguma experiência com gráficos do Java para desktop, mas não eram animados. Eu me senti… estranho. Meio dinossauro, meio renascido.

TL;DR Descobrindo a força dos conceitos de widget e tween do Flutter ao escrever animações de gráficos em Dart para um app Android/iOS.
Atualizado em 7 de agosto de 2018 para usar a sintaxe do Dart 2. Repositório no GitHub adicionado em 17 de outubro de 2018. Cada passo descrito abaixo é um commit separado.
Mudar para uma nova stack de desenvolvimento faz você perceber suas prioridades. No topo da minha lista estão estas três:
-
Conceitos sólidos lidam de forma eficaz com a complexidade, oferecendo maneiras simples e relevantes de estruturar pensamentos, lógica ou dados.
-
Código limpo nos permite expressar esses conceitos com clareza, sem nos distrair com armadilhas da linguagem, boilerplate excessivo ou detalhes auxiliares.
-
Iteração rápida é fundamental para experimentação e aprendizado — e equipes de desenvolvimento de software aprendem por profissão: quais são os requisitos reais e como melhor atendê-los com conceitos expressos em código.
Flutter é uma nova plataforma para desenvolver apps Android e iOS a partir de uma única base de código, escrita em Dart. Como nossos requisitos falavam de uma UI bastante complexa, incluindo gráficos animados, a ideia de construí-la apenas uma vez parecia muito atraente. Minhas tarefas envolviam usar as ferramentas de CLI do Flutter, alguns widgets pré-construídos e seu engine de renderização 2D — além de escrever bastante código Dart puro para modelar e animar gráficos. Vou compartilhar abaixo alguns destaques conceituais da minha experiência de aprendizado e fornecer um ponto de partida para sua própria avaliação da stack Flutter/Dart.
Esta é a parte um de uma introdução em duas partes ao Flutter e aos seus conceitos de ‘widget’ e ‘tween’. Vou ilustrar a força desses conceitos usando-os para exibir e animar gráficos como o mostrado acima. Os exemplos de código completos devem dar uma impressão do nível de clareza que se consegue com Dart. E vou incluir detalhes suficientes para que você consiga acompanhar no seu próprio laptop (e emulador ou dispositivo) e vivenciar a duração do ciclo de desenvolvimento do Flutter.
O ponto de partida é uma instalação nova do Flutter. Execute
$ flutter doctor
para verificar a configuração:
$ flutter doctor
Doctor summary (to see all details, run flutter doctor -v):
[✓] Flutter
(Channel beta, v0.5.1, on Mac OS X 10.13.6 17G65, locale en-US)
[✓] Android toolchain - develop for Android devices
(Android SDK 28.0.0)
[✓] iOS toolchain - develop for iOS devices (Xcode 9.4)
[✓] Android Studio (version 3.1)
[✓] IntelliJ IDEA Community Edition (version 2018.2.1)
[✓] Connected devices (1 available)
• No issues found!
Com marcas de verificação suficientes, você pode criar um app Flutter. Vamos chamá-lo de charts:
$ flutter create charts
Isso deve gerar um diretório com o mesmo nome:
charts
android
ios
lib
main.dart
Cerca de sessenta arquivos foram gerados, formando um app de exemplo completo que pode ser instalado tanto no Android quanto no iOS. Faremos toda a programação em
main.dart e nos arquivos irmãos, sem necessidade de mexer nos outros arquivos ou diretórios.
Você deve verificar se consegue iniciar o app de exemplo. Inicie um emulador ou conecte um dispositivo e depois execute
$ flutter run
no diretório charts. Você deverá ver um app simples de contagem no seu emulador ou dispositivo. Ele usa widgets do Material Design, o que é bom, mas opcional. Como a camada mais alta da arquitetura do Flutter, esses widgets são completamente substituíveis.
Vamos começar substituindo o conteúdo de main.dart pelo código abaixo, um ponto de partida simples para brincar com animações de gráficos.
import 'dart:math';
import 'package:flutter/material.dart';
void main() {
runApp(MaterialApp(home: ChartPage()));
}
class ChartPage extends StatefulWidget {
@override
ChartPageState createState() => ChartPageState();
}
class ChartPageState extends State<ChartPage> {
final random = Random();
int dataSet;
void changeData() {
setState(() {
dataSet = random.nextInt(100);
});
}
@override
Widget build(BuildContext context) {
return Scaffold(
body: Center(
child: Text('Data set: $dataSet'),
),
floatingActionButton: FloatingActionButton(
child: Icon(Icons.refresh),
onPressed: changeData,
),
);
}
}
Salve as alterações e reinicie o app. Você pode fazer isso pelo terminal, pressionando R. Essa operação de ‘reinício completo’ descarta o estado da aplicação e depois reconstrói a UI. Para situações em que o estado existente da aplicação ainda faz sentido após a mudança no código, pode-se pressionar
r para fazer um ‘hot reload’, que apenas reconstrói a UI. Também existe um plugin do Flutter para o IntelliJ IDEA que oferece a mesma funcionalidade, integrada a um editor Dart:
Depois de reiniciar, o app mostra um rótulo de texto centralizado dizendo Data set: null e um floating action button para atualizar os dados. Sim, começo humilde.
Para sentir a diferença entre hot reload e reinício completo, tente o seguinte: depois de pressionar o floating action button algumas vezes, anote o número atual do conjunto de dados e depois substitua
Icons.refresh por Icons.add no código, salve e faça um hot reload. Observe que o botão muda, mas o estado da aplicação é mantido; ainda estamos no mesmo ponto do fluxo aleatório de números. Agora desfaça a troca de ícone, salve e faça um reinício completo. O estado da aplicação foi redefinido, e voltamos para
Data set: null.
Nosso app simples mostra dois aspectos centrais do conceito de widget do Flutter em ação:
-
A interface do usuário é definida por uma árvore de widgets imutáveis, construída por meio de uma mistura de chamadas de construtor (onde você configura os widgets) e métodos
build(onde as implementações dos widgets decidem como suas subárvores ficam). A estrutura de árvore resultante do nosso app é mostrada abaixo, com o papel principal de cada widget entre parênteses. Como você pode ver, embora o conceito de widget seja bastante amplo, cada tipo concreto de widget normalmente tem uma responsabilidade bem focada.
MaterialApp (navigation)
ChartPage (state management)
Scaffold (layout)
Center (layout)
Text (text)
FloatingActionButton (user interaction)
Icon (graphics)
-
Com uma árvore imutável de widgets imutáveis definindo a interface, a única forma de mudar essa interface é reconstruir a árvore. O Flutter cuida disso quando o próximo frame estiver previsto. Tudo o que precisamos fazer é dizer ao Flutter que algum estado do qual uma subárvore depende mudou. A raiz de tal
subárvore dependente de estado deve ser um
StatefulWidget. Como qualquer widget bem projetado, umStatefulWidgetnão é mutável, mas sua subárvore é construída por um objetoStateque é. O Flutter mantém os objetosStateentre as reconstruções da árvore e os anexa a cada widget correspondente na nova árvore durante a construção. Eles então determinam como a subárvore desse widget é construída. Em nosso app,ChartPageé umStatefulWidgetcomChartPageStatecomo seuState. Sempre que o usuário pressiona o botão, executamos algum código para mudarChartPageState.. Marcamos a mudança comsetStatepara que o Flutter possa fazer sua manutenção e agendar a árvore de widgets para reconstrução. Quando isso acontece,ChartPageStatevai construir uma subárvore ligeiramente diferente, com raiz na nova instância deChartPage.
Widgets imutáveis e subárvores dependentes de estado são as principais ferramentas que o Flutter coloca à nossa disposição para lidar com a complexidade do gerenciamento de estado em UIs elaboradas que respondem a eventos assíncronos, como toques em botões, ticks de timer ou dados recebidos. Pela minha experiência com desktop, diria que essa complexidade é muito real. Avaliar a força da abordagem do Flutter é — e deve ser — um exercício para o leitor: experimente em algo não trivial.
Nosso app de gráficos vai continuar simples em termos de estrutura de widgets, mas faremos um pouco de gráficos personalizados animados. O primeiro passo é substituir a representação textual de cada conjunto de dados por um gráfico bem simples. Como um conjunto de dados atualmente envolve apenas um único número no intervalo
0..100, o gráfico será um gráfico de barras com uma única barra, cuja altura é determinada por esse número. Vamos usar um valor inicial de
50 para evitar uma altura null:
import 'dart:math';
import 'package:flutter/material.dart';
void main() {
runApp(MaterialApp(home: ChartPage()));
}
class ChartPage extends StatefulWidget {
@override
ChartPageState createState() => ChartPageState();
}
class ChartPageState extends State<ChartPage> {
final random = Random();
int dataSet = 50;
void changeData() {
setState(() {
dataSet = random.nextInt(100);
});
}
@override
Widget build(BuildContext context) {
return Scaffold(
body: Center(
child: CustomPaint(
size: Size(200.0, 100.0),
painter: BarChartPainter(dataSet.toDouble()),
),
),
floatingActionButton: FloatingActionButton(
child: Icon(Icons.refresh),
onPressed: changeData,
),
);
}
}
class BarChartPainter extends CustomPainter {
static const barWidth = 10.0;
BarChartPainter(this.barHeight);
final double barHeight;
@override
void paint(Canvas canvas, Size size) {
final paint = Paint()
..color = Colors.blue[400]
..style = PaintingStyle.fill;
canvas.drawRect(
Rect.fromLTWH(
(size.width - barWidth) / 2.0,
size.height - barHeight,
barWidth,
barHeight,
),
paint,
);
}
@override
bool shouldRepaint(BarChartPainter old) => barHeight != old.barHeight;
}
CustomPaint é um widget que delega a pintura a uma estratégia CustomPainter. Nossa implementação dessa estratégia desenha uma única barra.
O próximo passo é adicionar animação. Sempre que o conjunto de dados mudar, queremos que a barra mude de altura suavemente, em vez de abruptamente. O Flutter tem um conceito de
AnimationController para orquestrar animações e, ao registrar um listener, somos avisados quando o valor da animação — um double que vai de zero a um — muda. Sempre que isso acontece, podemos chamar
setState como antes e atualizar ChartPageState.
Por razões didáticas, nossa primeira tentativa será feia:
import 'dart:math';
import 'dart:ui' show lerpDouble;
import 'package:flutter/animation.dart';
import 'package:flutter/material.dart';
void main() {
runApp(MaterialApp(home: ChartPage()));
}
class ChartPage extends StatefulWidget {
@override
ChartPageState createState() => ChartPageState();
}
class ChartPageState extends State<ChartPage> with TickerProviderStateMixin {
final random = Random();
int dataSet = 50;
AnimationController animation;
double startHeight; // Strike one.
double currentHeight; // Strike two.
double endHeight; // Strike three. Refactor.
@override
void initState() {
super.initState();
animation = AnimationController(
duration: const Duration(milliseconds: 300),
vsync: this,
)..addListener(() {
setState(() {
currentHeight = lerpDouble( // Strike one.
startHeight,
endHeight,
animation.value,
);
});
});
startHeight = 0.0; // Strike two.
currentHeight = 0.0;
endHeight = dataSet.toDouble();
animation.forward();
}
@override
void dispose() {
animation.dispose();
super.dispose();
}
void changeData() {
setState(() {
startHeight = currentHeight; // Strike three. Refactor.
dataSet = random.nextInt(100);
endHeight = dataSet.toDouble();
animation.forward(from: 0.0);
});
}
@override
Widget build(BuildContext context) {
return Scaffold(
body: Center(
child: CustomPaint(
size: Size(200.0, 100.0),
painter: BarChartPainter(currentHeight),
),
),
floatingActionButton: FloatingActionButton(
child: Icon(Icons.refresh),
onPressed: changeData,
),
);
}
}
class BarChartPainter extends CustomPainter {
static const barWidth = 10.0;
BarChartPainter(this.barHeight);
final double barHeight;
@override
void paint(Canvas canvas, Size size) {
final paint = Paint()
..color = Colors.blue[400]
..style = PaintingStyle.fill;
canvas.drawRect(
Rect.fromLTWH(
(size.width - barWidth) / 2.0,
size.height - barHeight,
barWidth,
barHeight,
),
paint,
);
}
@override
bool shouldRepaint(BarChartPainter old) => barHeight != old.barHeight;
}
Ai. A complexidade já mostra sua face feia, e nosso conjunto de dados ainda é apenas um único número! O código necessário para configurar o controle de animação é uma preocupação menor, pois não se ramifica quando temos mais dados no gráfico. O problema real são as variáveis
startHeight, currentHeight e endHeight, que refletem as mudanças feitas no conjunto de dados e no valor da animação, e são atualizadas em três lugares diferentes.
Precisamos de um conceito para lidar com essa bagunça.
Entram os tweens. Embora de forma alguma exclusivos do Flutter, eles são um conceito deliciosamente simples para estruturar código de animação. Sua principal contribuição é substituir a abordagem imperativa acima por uma funcional. Um tween é um valor. Ele descreve o caminho percorrido entre dois pontos em um espaço de outros valores, como gráficos de barras, conforme o valor da animação vai de zero a um.

Tweens são genéricos quanto ao tipo desses outros valores e podem ser expressos em Dart como objetos do tipo
Tween<T>:
abstract class Tween<T> {
final T begin;
final T end;
Tween(this.begin, this.end);
T lerp(double t);
}
O termo lerp vem do campo da computação gráfica e é uma abreviação de interpolação linear (como substantivo) e interpolar linearmente (como verbo). O parâmetro t é o valor da animação, e um tween deve, portanto, fazer lerp de
begin (quando t é zero) até end (quando t é um).
A classe Tween<T>
do SDK do Flutter é muito parecida com a acima, mas é uma classe concreta que permite mutar begin
e end. Não tenho certeza do motivo dessa escolha, mas provavelmente há boas razões nas áreas de suporte a animações do SDK que ainda não explorei. A seguir, vou usar a
Tween<T> do Flutter, mas fingir que ela é imutável.
Podemos limpar nosso código usando um único Tween<double> para a altura da barra:
import 'dart:math';
import 'package:flutter/animation.dart';
import 'package:flutter/material.dart';
void main() {
runApp(MaterialApp(home: ChartPage()));
}
class ChartPage extends StatefulWidget {
@override
ChartPageState createState() => ChartPageState();
}
class ChartPageState extends State<ChartPage> with TickerProviderStateMixin {
final random = Random();
int dataSet = 50;
AnimationController animation;
Tween<double> tween;
@override
void initState() {
super.initState();
animation = AnimationController(
duration: const Duration(milliseconds: 300),
vsync: this,
);
tween = Tween<double>(begin: 0.0, end: dataSet.toDouble());
animation.forward();
}
@override
void dispose() {
animation.dispose();
super.dispose();
}
void changeData() {
setState(() {
dataSet = random.nextInt(100);
tween = Tween<double>(
begin: tween.evaluate(animation),
end: dataSet.toDouble(),
);
animation.forward(from: 0.0);
});
}
@override
Widget build(BuildContext context) {
return Scaffold(
body: Center(
child: CustomPaint(
size: Size(200.0, 100.0),
painter: BarChartPainter(tween.animate(animation)),
),
),
floatingActionButton: FloatingActionButton(
child: Icon(Icons.refresh),
onPressed: changeData,
),
);
}
}
class BarChartPainter extends CustomPainter {
static const barWidth = 10.0;
BarChartPainter(Animation<double> animation)
: animation = animation,
super(repaint: animation);
final Animation<double> animation;
@override
void paint(Canvas canvas, Size size) {
final barHeight = animation.value;
final paint = Paint()
..color = Colors.blue[400]
..style = PaintingStyle.fill;
canvas.drawRect(
Rect.fromLTWH(
(size.width - barWidth) / 2.0,
size.height - barHeight,
barWidth,
barHeight,
),
paint,
);
}
@override
bool shouldRepaint(BarChartPainter old) => false;
}
Estamos usando Tween para empacotar os pontos finais da animação da altura da barra em um único valor. Ele se integra bem com o
AnimationController e CustomPainter, evitando reconstruções da árvore de widgets durante a animação, pois a infraestrutura do Flutter agora marca apenas
CustomPaint para repintura a cada tick da animação, em vez de marcar toda a subárvore ChartPage para reconstrução, relayout e repintura. Essas são melhorias claras. Mas há mais no conceito de tween: ele oferece estrutura para organizar nossos pensamentos e código, e ainda não levamos isso realmente a sério. O conceito de tween diz:
Anime T traçando um caminho no espaço de todos os T possíveis conforme o valor da animação vai de zero a um. Modele o caminho com um Tween<T>.
No código acima, T é um double, mas não queremos animar doubles, queremos animar gráficos de barras! Bem, tudo bem, barras únicas por enquanto, mas o conceito é forte e escala, se o deixarmos.
(Você pode estar se perguntando por que não levamos esse argumento um passo além e insistimos em animar conjuntos de dados em vez de suas representações como gráficos de barras. Isso acontece porque conjuntos de dados — em contraste com gráficos de barras, que são objetos gráficos — geralmente não habitam espaços onde existem caminhos suaves. Conjuntos de dados para gráficos de barras normalmente envolvem dados numéricos mapeados contra categorias discretas. Mas, sem a representação espacial como gráficos de barras, não há uma noção razoável de caminho suave entre dois conjuntos de dados com categorias diferentes.)
Voltando ao nosso código, vamos precisar de um tipo Bar e de um BarTween para animá-lo. Vamos extrair as classes relacionadas a barras para seu próprio
arquivo bar.dart, ao lado de main.dart:
import 'dart:ui' show lerpDouble;
import 'package:flutter/animation.dart';
import 'package:flutter/material.dart';
class Bar {
Bar(this.height);
final double height;
static Bar lerp(Bar begin, Bar end, double t) {
return Bar(lerpDouble(begin.height, end.height, t));
}
}
class BarTween extends Tween<Bar> {
BarTween(Bar begin, Bar end) : super(begin: begin, end: end);
@override
Bar lerp(double t) => Bar.lerp(begin, end, t);
}
class BarChartPainter extends CustomPainter {
static const barWidth = 10.0;
BarChartPainter(Animation<Bar> animation)
: animation = animation,
super(repaint: animation);
final Animation<Bar> animation;
@override
void paint(Canvas canvas, Size size) {
final bar = animation.value;
final paint = Paint()
..color = Colors.blue[400]
..style = PaintingStyle.fill;
canvas.drawRect(
Rect.fromLTWH(
(size.width - barWidth) / 2.0,
size.height - bar.height,
barWidth,
bar.height,
),
paint,
);
}
@override
bool shouldRepaint(BarChartPainter old) => false;
}
Estou seguindo uma convenção do SDK do Flutter ao definir BarTween.lerp em termos de um método estático da classe
Bar. Isso funciona bem para tipos simples como Bar, Color, Rect
e muitos outros, mas vamos precisar reconsiderar a abordagem para tipos de gráfico mais elaborados. Não existe
double.lerp no SDK do Dart, então estamos usando a função lerpDouble do pacote
dart:ui com o mesmo efeito.
Nosso app agora pode ser reexpresso em termos de barras, como mostrado no código abaixo; aproveitei para dispensar o campo
dataSet.
import 'dart:math';
import 'package:flutter/animation.dart';
import 'package:flutter/material.dart';
import 'bar.dart';
void main() {
runApp(MaterialApp(home: ChartPage()));
}
class ChartPage extends StatefulWidget {
@override
ChartPageState createState() => ChartPageState();
}
class ChartPageState extends State<ChartPage> with TickerProviderStateMixin {
final random = Random();
AnimationController animation;
BarTween tween;
@override
void initState() {
super.initState();
animation = AnimationController(
duration: const Duration(milliseconds: 300),
vsync: this,
);
tween = BarTween(Bar(0.0), Bar(50.0));
animation.forward();
}
@override
void dispose() {
animation.dispose();
super.dispose();
}
void changeData() {
setState(() {
tween = BarTween(
tween.evaluate(animation),
Bar(random.nextDouble() * 100.0),
);
animation.forward(from: 0.0);
});
}
@override
Widget build(BuildContext context) {
return Scaffold(
body: Center(
child: CustomPaint(
size: Size(200.0, 100.0),
painter: BarChartPainter(tween.animate(animation)),
),
),
floatingActionButton: FloatingActionButton(
child: Icon(Icons.refresh),
onPressed: changeData,
),
);
}
}
A nova versão é mais longa, e o código extra deve compensar. Vai compensar, à medida que enfrentarmos a crescente complexidade dos gráficos na parte dois. Nossos requisitos falam de barras coloridas, múltiplas barras, dados parciais, barras empilhadas, barras agrupadas, barras empilhadas e agrupadas, … tudo animado. Fique ligado.