Análise aprofundada de animações
Conheça mais a fundo os conceitos e técnicas de animação do Flutter na série Flutter Animations.
No ano passado, tive a oportunidade de gravar um dos episódios da série Flutter Animations, e achei que deveria publicar o mesmo conteúdo para quem prefere texto a vídeo.
Nos outros episódios da série, meus colegas falam sobre todas as formas práticas de criar animações no Flutter. Não é o caso do meu episódio. Aqui, você vai aprender a implementar animações da forma menos pragmática que se possa imaginar. (Mas também vai aprender algumas coisas pelo caminho.)
Vamos começar com algo simples e leve:
O que é movimento, de verdade?
Veja bem, movimento é uma ilusão. Olhe para isto:
É mentira. O que você está vendo são várias imagens paradas exibidas em rápida sucessão. É assim que os filmes funcionam. As imagens individuais são chamadas de frames no cinema — e, como as telas digitais funcionam de forma parecida, elas também são chamadas de frames aqui. O cinema normalmente exibe 24 frames por segundo. Os dispositivos digitais modernos exibem de 60 a 120 frames por segundo.
Então, se movimento é mentira, o que todos esses AnimationFoo e FooTransition widgets realmente fazem? Certamente, como os frames precisam ser construídos até 120 vezes por segundo, a UI não pode ser
reconstruída a cada vez.
Ou será que pode?
Na verdade, animações no Flutter são apenas uma forma de reconstruir partes da sua árvore de widgets a cada frame. Não há nenhum caso especial. O Flutter é rápido o suficiente para fazer isso.
Vamos olhar um dos blocos básicos das animações do Flutter: AnimatedBuilder. Este widget é um
AnimatedWidget, que é sustentado por _AnimatedState. No método initState()
do State, estamos escutando o Animation (ou Listenable, como é chamado aqui), e quando ele muda de valor, nós… chamamos setState().
setState()
a cada frame.
Pronto. Animações no Flutter são apenas uma sucessão rápida de mudanças no estado de algum widget, de 60 a 120 vezes por segundo.
Posso provar. Aqui está uma animação que “anima” de zero até a velocidade da luz. Embora ela mude o texto a cada frame, do ponto de vista do Flutter, é apenas mais uma animação.

Vamos usar o framework de animação do Flutter para construir essa animação a partir dos primeiros princípios.
Normalmente, usaríamos o widget TweenAnimationBuilder ou algo parecido, mas neste artigo vamos ignorar tudo isso e usar um ticker, um controller e
setState.
Ticker
Vamos falar primeiro sobre o Ticker. Em 99% das vezes, você não vai usar um ticker diretamente. Mas acho que ainda vale falar sobre ele — nem que seja para desmistificá-lo.
Um ticker é um objeto que chama uma função a cada frame.
var ticker = Ticker((elapsed) => print('hello'));
ticker.start();
Neste caso, estamos imprimindo ‘hello’ a cada frame. Admito que isso não é muito útil.
Além disso, esquecemos de chamar ticker.dispose(), então nosso ticker vai rodar para sempre, até matarmos o app.
Por isso o Flutter oferece o SingleTickerProviderStateMixin, o mixin com nome bem apropriado que você já viu em alguns dos vídeos anteriores.
Esse mixin cuida da complicação de gerenciar um ticker. Basta acoplá-lo ao state do seu widget e ele se torna secretamente um
TickerProvider.
class _MyWidgetState extends State<MyWidget>
with SingleTickerProviderStateMixin<MyWidget> {
@override
Widget build(BuildContext context) {
return Container();
}
}
Isso significa que o framework do Flutter pode pedir ao seu state um ticker. Mais importante, AnimationController
pode pedir ao state um ticker.
class _MyWidgetState extends State<MyWidget>
with SingleTickerProviderStateMixin<MyWidget> {
AnimationController _controller;
@override
void initState() {
super.initState();
_controller = AnimationController(vsync: this);
}
@override
Widget build(BuildContext context) {
return Container();
}
}
AnimationController precisa de um ticker para funcionar. Se você usar SingleTickerProviderStateMixin
ou seu primo TickerProviderStateMixin, basta passar this para o AnimationController, e pronto.
AnimationController
AnimationController é o que você normalmente usa para tocar, pausar, reverter e parar animações. Em vez de eventos puros de “tick”, AnimationController nos diz em que ponto da animação estamos, a qualquer momento. Por exemplo: já estamos na metade? Estamos 99% lá? A animação foi concluída?

Normalmente, você pegaria o AnimationController, talvez o transformaria com um Curve, o passaria por um
Tween e o usaria em um dos widgets práticos, como FadeTransition ou TweenAnimationBuilder. Mas, para fins educacionais, não vamos fazer isso. Em vez disso, vamos chamar diretamente
setState.
setState
Depois de inicializar o AnimationController, podemos adicionar um listener a ele. E, nesse listener, chamamos
setState.
class _MyWidgetState extends State<MyWidget>
with SingleTickerProviderStateMixin<MyWidget> {
AnimationController _controller;
@override
void initState() {
super.initState();
_controller = AnimationController(vsync: this);
_controller.addListener(_update);
}
void _update() {
setState(() {
// TODO
});
}
@override
Widget build(BuildContext context) {
return Container();
}
}
Agora, provavelmente devemos ter um state para definir. Vamos manter simples com um inteiro. E não vamos esquecer de realmente usar o state no nosso método build, e de alterar o state no nosso listener de acordo com o valor atual do controller.
class _MyWidgetState extends State<MyWidget>
with SingleTickerProviderStateMixin<MyWidget> {
AnimationController _controller;
int i = 0;
@override
void initState() {
super.initState();
_controller = AnimationController(vsync: this);
_controller.addListener(_update);
}
void _update() {
setState(() {
i = (_controller.value * 299792458).round();
});
}
@override
Widget build(BuildContext context) {
return Text('$i m/s');
}
}
Este código atribui um valor de zero até a velocidade da luz, dependendo do progresso da animação.
Executando a animação
Agora, só precisamos dizer à animação quanto tempo ela deve levar para ser concluída e iniciá-la.
class _MyWidgetState extends State<MyWidget>
with SingleTickerProviderStateMixin<MyWidget> {
AnimationController _controller;
int i = 0;
@override
void initState() {
super.initState();
_controller = AnimationController(
vsync: this,
duration: const Duration(seconds: 1),
);
_controller.addListener(_update);
_controller.forward();
}
void _update() {
setState(() {
i = (_controller.value * 299792458).round();
});
}
@override
Widget build(BuildContext context) {
return Text('$i m/s');
}
}
O widget anima assim que é adicionado à tela. E ele “anima” de zero até a velocidade da luz em um segundo.

Descartando o controller
Ah, e não se esqueça de descartar o AnimationController. Caso contrário, você terá um vazamento de memória no seu app.
class _MyWidgetState extends State<MyWidget>
with SingleTickerProviderStateMixin<MyWidget> {
AnimationController _controller;
int i = 0;
@override
void initState() {
super.initState();
_controller = AnimationController(
vsync: this,
duration: const Duration(seconds: 1),
);
_controller.addListener(_update);
_controller.forward();
}
@override
void dispose() {
_controller.dispose();
super.dispose();
}
void _update() {
setState(() {
i = (_controller.value * 299792458).round();
});
}
@override
Widget build(BuildContext context) {
return Text('$i m/s');
}
}
Que tal usar um widget embutido, talvez?
Como você pode ver, fazer tudo sozinho não é ideal. A mesma funcionalidade pode ser obtida com o TweenAnimationBuilder em muito menos linhas de código, sem precisar manipular um AnimationController
e chamar setState.
class MyPragmaticWidget extends StatelessWidget {
@override
Widget build(BuildContext context) {
return TweenAnimationBuilder(
tween: IntTween(begin: 0, end: 299792458),
duration: const Duration(seconds: 1),
builder: (BuildContext context, int i, Widget child) {
return Text('$i m/s');
},
);
}
}
Resumo
Vimos o que Ticker realmente é. Vimos como escutar manualmente um AnimationController. E vimos que, no nível básico, animações são apenas reconstruções rápidas e consecutivas de um widget. Você pode fazer o que quiser em qualquer frame.
Artigos desta série: