Quando devo usar AnimatedBuilder ou AnimatedWidget?

Sabemos que você tem muitas opções na hora de voar, quer dizer, de animar, no Flutter, então obrigado por escolher AnimatedBuilder e AnimatedWidget.

Sabemos que você tem muitas opções ao voar, quer dizer, animar, no Flutter, então obrigado por escolher AnimatedBuilder e AnimatedWidget. Espera, o quê? Não! O Flutter tem muitos widgets de animação diferentes, mas, ao contrário das companhias aéreas comerciais, cada tipo de widget é adequado para um tipo diferente de trabalho. Claro, você pode fazer a mesma animação de algumas maneiras diferentes, mas usar o widget de animação certo para o trabalho vai facilitar muito a sua vida.

Este artigo explica por que você pode querer usar AnimatedBuilder ou AnimatedWidget em vez de outros widgets de animação, e como usá-los. Suponha que você queira adicionar uma animação ao seu app. Este artigo é parte de uma série que percorre por que você pode querer usar cada tipo de widget de animação. A animação que você quer fazer se repete algumas vezes ou precisa poder pausar e retomar em resposta a algo, como um toque com o dedo. Como sua animação precisa se repetir, ou parar e começar, você vai precisar usar uma animação explícita.

Como lembrete, temos duas grandes categorias de animações no Flutter: explícitas e implícitas. Para as animações explícitas, você precisa de um controlador de animação. Para as implícitas, não. Apresentamos os controladores de animação no artigo anterior sobre animações explícitas integradas. Se quiser saber mais sobre elas, confira esse artigo antes.

Então, se você determinou que precisa de uma animação explícita, há uma série de classes de animação explícita para escolher. Essas são as classes geralmente chamadas FooTransition, onde Foo é o nome da propriedade que você quer animar. Recomendo verificar se você consegue usar um desses widgets para atender às suas necessidades primeiro, antes de mergulhar no mundo profundo de AnimatedWidget e AnimatedBuilder. Há uma seleção incrível de widgets para praticamente qualquer coisa que você possa imaginar — rotação, posição, alinhamento, fade, estilo de texto e muito mais. Além disso, você pode compor esses widgets, para girar e fazer fade ao mesmo tempo. Mas, se nenhum dos widgets integrados conseguir fazer o que você procura, é hora de criar o seu próprio usando AnimatedWidget ou AnimatedBuilder.

Um fluxograma para entender qual animação usar em cada cenário. Este artigo foca nos dois estados finais azuis na parte inferior: AnimatedBuilder e AnimatedWidget.
Um fluxograma para entender qual animação usar em cada cenário. Este artigo foca nos dois estados finais azuis na parte inferior: AnimatedBuilder e AnimatedWidget.

Exemplo específico

Para deixar isso mais concreto, vamos percorrer um cenário específico: quero escrever um app com uma nave espacial alienígena e ter uma animação de feixe de luz da nave.

Algo exatamente assim, talvez.
Algo exatamente assim, talvez.

Desenhei um feixe de nave com um gradiente que desaparece do amarelo para o transparente, começando o fade bem no centro do gradiente. Depois, criei o formato do “feixe” a partir desse gradiente com um path clipper.

dart
import 'package:flutter/material.dart';
​
void main() => runApp(MyApp());
​
class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
        home: Scaffold(
      body: MyHomePage(),
    ));
  }
}
​
class MyHomePage extends StatelessWidget {
  final Image starsBackground = Image.asset(
    'assets/milky-way.jpg',
  );
  final Image ufo = Image.asset('assets/ufo.png');
  @override
  Widget build(BuildContext context) {
    return Stack(
      alignment: AlignmentDirectional.center,
      children: <Widget>[
        starsBackground,
        ClipPath(
          clipper: const BeamClipper(),
          child: Container(
            height: 1000,
            decoration: BoxDecoration(
              gradient: RadialGradient(
                radius: 1.5,
                colors: [
                  Colors.yellow,
                  Colors.transparent,
                ],
              ),
            ),
          ),
        ),
        ufo,
      ],
    );
  }
}
​
class BeamClipper extends CustomClipper<Path> {
  const BeamClipper();
​
  @override
  getClip(Size size) {
    return Path()
      ..lineTo(size.width / 2, size.height / 2)
      ..lineTo(size.width, size.height)
      ..lineTo(0, size.height)
      ..lineTo(size.width / 2, size.height / 2)
      ..close();
  }
​
  /// Return false always because we always clip the same area.
  @override
  bool shouldReclip(CustomClipper oldClipper) => false;
}

Quero criar uma animação de “feixe descendo”, começando do centro desse gradiente, e quero que ela se repita. Isso significa que vou precisar criar uma animação explícita. Infelizmente não há nenhuma animação explícita integrada para animar gradientes em formato de funil, mas, sabe o que temos… AnimatedWidget e AnimatedBuilder para resolver o problema!

AnimatedBuilder

Para animar o feixe, vou envolver esse código de gradiente em um widget AnimatedBuilder. O código do gradiente vai na função builder, que é chamada sempre que o AnimatedBuilder é construído.

Em seguida, preciso adicionar um controlador para dirigir essa animação. O controlador fornece os valores que AnimatedBuilder usa para desenhar novas versões do quadro da animação, quadro a quadro. Como você viu no artigo anterior, eu incorporo a classe SingleTickerProviderStateMixin e instancio o controlador na função initState, para que ele seja criado apenas uma vez. Crio o controlador em initState, em vez do método build, porque não quero criar esse controlador várias vezes — quero que ele forneça novos valores para animar a cada quadro! Como criei um novo objeto em initState, adiciono um método dispose e informo ao Flutter que ele pode descartar esse controlador quando o widget pai não estiver mais na tela.

Depois, passo esse controlador para o AnimatedBuilder, e minha animação roda como esperado!

dart
class MyHomePage extends StatefulWidget {
  @override
  _MyHomePageState createState() => _MyHomePageState();
}
​
class _MyHomePageState extends State<MyHomePage>
    with SingleTickerProviderStateMixin {
  final Image starsBackground = Image.asset(
    'assets/milky-way.jpg',
  );
  final Image ufo = Image.asset('assets/ufo.png');
  AnimationController _animation;
​
  @override
  void initState() {
    super.initState();
    _animation = AnimationController(
      duration: const Duration(seconds: 5),
      vsync: this,
    )..repeat();
  }
​
  @override
  Widget build(BuildContext context) {
    return Stack(
      alignment: AlignmentDirectional.center,
      children: <Widget>[
        starsBackground,
        AnimatedBuilder(
          animation: _animation,
          builder: (_, __) {
            return ClipPath(
              clipper: const BeamClipper(),
              child: Container(
                height: 1000,
                decoration: BoxDecoration(
                  gradient: RadialGradient(
                    radius: 1.5,
                    colors: [
                      Colors.yellow,
                      Colors.transparent,
                    ],
                    stops: [0, _animation.value],
                  ),
                ),
              ),
            );
          },
        ),
        ufo,
      ],
    );
  }
​
  @override
  void dispose() {
    _animation.dispose();
    super.dispose();
  }
}
​
class BeamClipper extends CustomClipper<Path> {
  const BeamClipper();
​
  @override
  getClip(Size size) {
    return Path()
      ..lineTo(size.width / 2, size.height / 2)
      ..lineTo(size.width, size.height)
      ..lineTo(0, size.height)
      ..lineTo(size.width / 2, size.height / 2)
      ..close();
  }
​
  /// Return false always because we always clip the same area.
  @override
  bool shouldReclip(CustomClipper oldClipper) => false;
}

Você deve se lembrar do artigo TweenAnimationBuilder em que usamos o parâmetro child como otimização de desempenho, e podemos fazer o mesmo com AnimatedBuilder também. Basicamente, se temos um objeto que nunca muda durante a animação, podemos construí-lo antecipadamente e apenas passá-lo para AnimatedBuilder.

Neste caso específico, uma forma melhor de obter o mesmo resultado é dar a BeamClipper um construtor const e simplesmente torná-lo const. É menos código, e o objeto é criado em tempo de compilação, deixando as coisas ainda mais rápidas. Às vezes, porém, você vai programar algo que não tem um construtor const, e esse é um bom caso para usar o parâmetro child opcional.

AnimatedWidget

Então, temos nossa animação, mas o método build que contém o código AnimatedBuilder é um pouco grande. Se o seu método build está começando a ficar difícil de ler, é hora de refatorar o seu código!

Você poderia extrair o código AnimatedBuilder para um widget separado, mas aí teria apenas um método build dentro de outro método build, o que é meio bobo. Em vez disso, você pode fazer a mesma animação criando um novo widget que estende AnimatedWidget. Vou chamar meu widget de BeamTransition para seguir a convenção de nomes FooTransition usada para animações explícitas. Passo o controlador de animação para BeamTransition e reutilizo o corpo da função builder de AnimatedBuilder's.

dart
class MyHomePage extends StatefulWidget {
  @override
  _MyHomePageState createState() => _MyHomePageState();
}
​
class _MyHomePageState extends State<MyHomePage>
    with SingleTickerProviderStateMixin {
  final Image starsBackground = Image.asset(
    'assets/milky-way.jpg',
  );
  final Image ufo = Image.asset('assets/ufo.png');
  AnimationController _animation;
​
  @override
  void initState() {
    super.initState();
    _animation = AnimationController(
      duration: const Duration(seconds: 5),
      vsync: this,
    )..repeat();
  }
​
  @override
  Widget build(BuildContext context) {
    return Stack(
      alignment: AlignmentDirectional.center,
      children: <Widget>[
        starsBackground,
        BeamTransition(animation: _animation),
        ufo,
      ],
    );
  }
​
  @override
  void dispose() {
    _animation.dispose();
    super.dispose();
  }
}
​
class BeamTransition extends AnimatedWidget {
  BeamTransition({Key key, Animation<double> animation})
      : super(key: key, listenable: animation);
  @override
  Widget build(BuildContext context) {
    final Animation<double> animation = listenable;
    return ClipPath(
      clipper: const BeamClipper(),
      child: Container(
        height: 1000,
        decoration: BoxDecoration(
          gradient: RadialGradient(
            radius: 1.5,
            colors: [
              Colors.yellow,
              Colors.transparent,
            ],
            stops: [0, animation.value],
          ),
        ),
      ),
    );
  }
}

Assim como AnimatedBuilder, se for apropriado, posso adicionar um parâmetro child ao meu widget como otimização de desempenho, para que ele seja construído antecipadamente, em vez de a cada animação. Só lembrando que, neste exemplo, fazer o meu BeamClipper receber um construtor const é o melhor caminho.

Então, qual devo usar mesmo?

Acabamos de ver como AnimatedBuilder e AnimatedWidget podem ser usados para fazer o mesmo tipo de animação explícita quando você não encontra uma animação explícita integrada que faça o que você quer. Então, qual deles usar? É realmente uma questão de gosto. De modo geral, recomendo criar widgets individuais, cada um com um trabalho separado, que neste caso é a animação.

Isso é um voto a favor de usar AnimatedWidget sempre que possível. No entanto, se o widget pai que cria o controlador de animação for bem simples, talvez criar um widget independente só para a sua animação seja código extra demais. Nesse caso, AnimatedBuilder é tudo o que você precisa.

Esta é a versão em artigo do vídeo abaixo. Se você prefere vídeos, clique abaixo:

Watch on YouTube in a new tab: "Creating custom explicit animations with AnimatedBuilder & AnimatedWidget - Flutter in Focus"

Artigos desta série:

Mais do Flutter