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.

Watch on YouTube in a new tab: "Animation deep dive - Flutter in Focus"

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:

Um vídeo do Filip acenando com a mão.
Um vídeo do Filip acenando com a mão.

É 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().

Este screencast confuso só mostra que estou dizendo a verdade no parágrafo anterior. O AnimatedBuilder realmente chama `setState()` a cada quadro.
Este screencast confuso só mostra que estou dizendo a verdade no parágrafo anterior. O Animated Builder realmente chama 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.

dart
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.

dart
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.

dart
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.

dart
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.

dart
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.

dart
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.

dart
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.

dart
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:

Mais do Flutter