Animações implícitas personalizadas no Flutter…com TweenAnimationBuilder

Para criar animações no Flutter, existem muitas opções diferentes. Como escolher o widget de animação certo?

Para criar animações no Flutter, há muitas opções diferentes. Como escolher o widget de animação certo? Este artigo, parte da nossa série sobre animações, explora os melhores casos de uso de TweenAnimationBuilder em comparação com os momentos em que outro widget é mais indicado para a tarefa. O artigo anterior desta série explica o quão poderosos são todos os widgets de animação implícita embutidos e o quanto você consegue fazer com eles.

Um fluxograma para entender qual animação usar em qualquer cenário. Este artigo foca no “estado final” penúltimo à direita: TweenAnimationBuilder.
Um fluxograma para entender qual animação usar em qualquer cenário. Este artigo foca no “estado final” penúltimo à direita: TweenAnimationBuilder.

Por que usar TweenAnimationBuilder? Suponha que você queira criar uma animação básica: uma animação que não se repete para sempre e é apenas um widget ou uma árvore de widgets. O Flutter tem a convenção de nomear seus widgets de animação implícita AnimatedFoo, onde Foo é o nome da propriedade que é animada. Não acredita? Aqui está uma amostra de widgets embutidos com animação implícita: AnimatedContainer, AnimatedCrossFade, AnimatedDefaultTextStyle, AnimatedModalBarrier, AnimatedOpacity, AnimatedPadding, AnimatedPhysicalModel, AnimatedPositioned, AnimatedPositionedDirectional, AnimatedSwitcher. Esse conjunto de widgets é impressionantemente poderoso, e você consegue resolver muitas necessidades usando apenas esses. AnimatedContainer consegue até animar gradientes e girar widgets, sem precisar se preocupar com um AnimationController!

No entanto, se você precisar criar uma animação básica e nenhuma das animações implícitas embutidas for o que procura, ainda assim é possível criar essa animação com TweenAnimationBuilder!

O básico

Para usar TweenAnimationBuilder, defino a duração da animação com o parâmetro duration e o intervalo de valores que quero animar com o…Tween parâmetro. Como o nome sugere, um objeto Tween permite especificar um intervalo de valores que você quer animar entre eles.

O último parâmetro que preciso especificar é o builder, que retorna como será o meu widget animado em um dado momento. Essa função builder recebe um parâmetro do mesmo tipo dos seus valores Tween, o que basicamente informa ao Flutter qual é o valor atual da animação em um dado momento.

dart
/// This is an EXTREMELY bare-bones illustration of using TweenAnimationBuilder.
/// See the rest of the article for optimizations.
/// Also note that this example is for illustration use only -- an implicit rotation
/// animation can be accomplished with AnimatedContainer.
class SuperBasic extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Stack(
      children: <Widget>[
        starsBackground,
        Center(
          child: TweenAnimationBuilder<double>(
            tween: Tween<double>(begin: 0, end: 2 * math.pi),
            duration: Duration(seconds: 2),
            builder: (BuildContext context, double angle, Widget child) {
              return Transform.rotate(
                angle: angle,
                child: Image.asset('assets/Earth.png'),
              );
            },
          ),
        ),
      ],
    );
  }
}

TweenAnimationBuilder em detalhes

O exemplo de código acima mostrou o conjunto mínimo de argumentos necessários para usar TweenAnimationBuilder, mas esse widget tem muito mais a oferecer! Para fins ilustrativos, criei um app para um caso de uso extremamente comum: a ilustração do efeito Doppler no espaço. Tudo bem, é um caso de uso meio bobo, mas você pode querer aplicar um filtro de cor a uma imagem e animar as cores mudando… e é exatamente isso que faremos neste cenário.

No efeito Doppler, quando uma estrela se afasta de você no espaço, as ondas de luz se alongam, fazendo a luz se deslocar para a extremidade vermelha do espectro. Esse efeito é muito sutil e não é visível a olho nu, mas astrônomos o usam para determinar a velocidade de estrelas e galáxias em relação a nós.

Consulte um astrofísico da sua região para mais detalhes.
Consulte um astrofísico da sua região para mais detalhes.

No nosso app, vamos deixar isso um pouco menos sutil. Tenho uma bela imagem de uma estrela e, para mudar a cor dela, vou usar o widget ColorFiltered. Aplico um modo de mesclagem e digo para mesclar laranja na imagem, para deixá-la um pouco mais avermelhada.

dart
ColorFiltered(
  child: Image.asset('assets/sun.png'),
  colorFilter: ColorFilter.mode(color, BlendMode.modulate),
)

Próximo passo… animação! Não existe um widget embutido que aplique um filtro de cor arbitrário a um widget, mas podemos criar um nós mesmos com TweenAnimationBuilder. Para mudar a cor ao longo do tempo, queremos modificar a cor que estamos aplicando ao filtro. Então, esse é o valor que vamos animar. Vamos colocar o widget ColorFiltered dentro da função builder do TweenAnimationBuilder. Como mencionei antes, um Tween é apenas o intervalo de valores entre os quais estamos animando. Neste caso, vamos usar um ColorTween para animar entre branco, que é como se não tivéssemos nenhum filtro, e laranja. E pronto! Um filtro de cor animado em 10 linhas de código.

dart
TweenAnimationBuilder(
  tween: ColorTween(begin: Colors.white, end: Colors.red),
  duration: Duration(seconds: 2),
  builder: (_, Color color, __) {
    return ColorFiltered(
      child: Image.asset('assets/sun.png'),
      colorFilter: ColorFilter.mode(color, BlendMode.modulate),
    );
  },
)

Dependendo de o que você quer animar, seu Tween pode especificar intervalos entre coisas que não são cores ou números. Você pode ter um Tween com objetos Offset para animar a mudança de posição de um widget, ou até animar como a borda de um widget muda! O ponto é que você tem uma enorme variedade de opções.

Tweens são mutáveis, então, se você sabe que sempre vai animar entre o mesmo conjunto de valores, é melhor declarar seu Tween como uma variável static final na sua classe. Assim, você não cria um novo objeto a cada rebuild.

dart
class ColorAnimationWithStaticFinal extends StatelessWidget {
  static final colorTween = ColorTween(begin: Colors.white, end: Colors.red);
​
  @override
  Widget build(BuildContext context) {
    return Stack(
      children: <Widget>[
        starsBackground,
        Center(
          child: TweenAnimationBuilder<Color>(
            tween: colorTween,
            duration: Duration(seconds: 2),
            builder: (_, Color color, __) {
              return ColorFiltered(
                child: Image.asset('assets/sun.png'),
                colorFilter: ColorFilter.mode(color, BlendMode.modulate),
              );
            },
          ),
        ),
      ],
    );
  }
}

Modificando valores de Tween dinamicamente

O exemplo anterior mostrou uma forma bem simples de animar de um valor para outro sem usar setState ou qualquer outra coisa. Mas você pode fazer mais com TweenAnimationBuilder modificando dinamicamente o valor do seu Tween.

dart
class OngoingAnimationByModifyingEndTweenValue extends StatefulWidget {
  @override
  _OngoingAnimationState createState() => _OngoingAnimationState();
}
​
class _OngoingAnimationState extends State<OngoingAnimationByModifyingEndTweenValue> {
  double _newValue = .4;
  Color _newColor = Colors.white;
​
  @override
  Widget build(BuildContext context) {
    return Stack(
      children: <Widget>[
        starsBackground,
        Column(
          children: <Widget>[
            Center(
              child: TweenAnimationBuilder(
                tween: ColorTween(begin: Colors.white, end: _newColor),
                duration: Duration(seconds: 2),
                builder: (_, Color color, __) {
                  return ColorFiltered(
                    child: Image.asset('assets/sun.png'),
                    colorFilter: ColorFilter.mode(color, BlendMode.modulate),
                  );
                },
              ),
            ),
            Slider.adaptive(
              value: _newValue,
              onChanged: (double value) {
                setState(() {
                  _newValue = value;
                  _newColor = Color.lerp(Colors.white, Colors.red, value);
                });
              },
            ),
          ],
        ),
      ],
    );
  }
}

Alterei o código para incluir também um widget Slider. Depois declarei uma variável local chamada _newColor que recebe o valor do slider e o converte em uma cor. _newColor também é usado como valor final no meu Tween. Agora a animação é atualizada toda vez que eu arrasto o slider.

Uma coisa a ter em mente é que TweenAnimationBuilder sempre vai do valor atual até o novo valor final. Isso significa que, conforme arrasto o slider, vejo a cor mudar em relação à cor anterior, em vez de sempre animar a partir do branco no início. Basta definir um novo valor final no meu Tween para inverter a animação ou ir para qualquer ponto intermediário. TweenAnimationBuilder sempre anima suavemente do seu valor atual até o novo ponto final. Como você pode perceber, isso significa que mudar dinamicamente o início do seu Tween não tem efeito algum.

dart
// DON'T DO THIS! YOU WON'T SEE AN ANIMATION IF YOU JUST UPDATE THE START VALUE!
class NopeNopeNope extends StatefulWidget {
  @override
  _NopeNopeNopeState createState() => _NopeNopeNopeState();
}
​
class _NopeNopeNopeState extends State<NopeNopeNope> {
  double _newValue = .4;
  Color _newColor = Colors.white;
​
  @override
  Widget build(BuildContext context) {
    return Stack(
      children: <Widget>[
        starsBackground,
        Column(
          children: <Widget>[
            Center(
              child: TweenAnimationBuilder(
                tween: ColorTween(begin: _newColor, end: Colors.red),
                duration: Duration(seconds: 2),
                builder: (_, Color color, __) {
                  return ColorFiltered(
                    child: Image.asset('assets/sun.png'),
                    colorFilter: ColorFilter.mode(color, BlendMode.modulate),
                  );
                },
              ),
            ),
            Slider.adaptive(
              value: _newValue,
              onChanged: (double value) {
                setState(() {
                  _newValue = value;
                  _newColor = Color.lerp(Colors.white, Colors.red, value);
                });
              },
            ),
          ],
        ),
      ],
    );
  }
}

onEnd e child

Há alguns outros parâmetros que ainda não mencionei. O primeiro é a curve, que descreve como devemos fazer a transição entre os valores inicial e final no intervalo de Tween. No artigo anterior falamos sobre como você pode até criar uma curve personalizada, mas há muitas ótimas opções predefinidas também.

O segundo é um callback que você pode especificar para fazer algo quando a animação terminar. Talvez você queira fazer outro widget aparecer depois que essa animação acabar. Você também pode usar esse callback como uma forma de inverter sua animação de um lado para o outro. Recomendo que pense bem antes de fazer isso, porém. O callback deixa o tipo de animação que você está tentando fazer menos claro, porque a definição dos valores fica espalhada pelo seu código. Como os valores são descontínuos (voltando ao início de novo), se você quiser uma animação repetida, vai precisar de algum tipo de animação explícita: ou um widget de animação explícita embutido ou estendendo AnimatedWidget.

dart
class BackAndForth extends StatefulWidget {
  @override
  _BackAndForthState createState() => _BackAndForthState();
}
​
class _BackAndForthState extends State<MyHomePage> {
  Color _newColor = Colors.red;
​
  @override
  Widget build(BuildContext context) {
    return Stack(
      children: <Widget>[
        starsBackground,
        Center(
          child: TweenAnimationBuilder(
            tween: ColorTween(begin: Colors.white, end: _newColor),
            duration: Duration(seconds: 2),
            onEnd: () {
              setState(() {
                _newColor = _newColor == Colors.red ? Colors.white : Colors.red;
              });
            },
            builder: (_, Color color, __) {
              return ColorFiltered(
                child: Image.asset('assets/sun.png'),
                colorFilter: ColorFilter.mode(color, BlendMode.modulate),
              );
            },
          ),
        )
      ],
    );
  }
}

Há ainda um último parâmetro que não discutimos: o parâmetro child. Definir o parâmetro child é uma possível otimização de desempenho. Mesmo que a cor mude, o widget da imagem da estrela em si continua o mesmo. Do jeito que está escrito, porém, o widget de imagem é reconstruído toda vez que o método builder é chamado. Podemos construir a imagem da estrela antecipadamente e passá-la como parâmetro child. Assim, o Flutter sabe que o único widget que precisa reconstruir de quadro em quadro é o novo filtro de cor, não a imagem da estrela. Este exemplo é simples, então não há uma diferença realmente perceptível. Mas, se estivéssemos animando um componente muito mais complexo, você pode imaginar que a otimização de desempenho ficaria mais importante.

dart
class ChildParameter extends StatelessWidget {
  static final colorTween = ColorTween(begin: Colors.white, end: Colors.red);
​
  @override
  Widget build(BuildContext context) {
    return Stack(
      children: <Widget>[
        starsBackground,
        Center(
          child: TweenAnimationBuilder<Color>(
            tween: colorTween,
            child: Image.asset('assets/sun.png'),
            duration: Duration(seconds: 2),
            builder: (_, Color color, Widget myChild) {
              return ColorFiltered(
                child: myChild,
                colorFilter: ColorFilter.mode(color, BlendMode.modulate),
              );
            },
          ),
        ),
      ],
    );
  }
}

Resumo

É isso que você precisa saber para escrever suas próprias animações implícitas personalizadas com TweenAnimationBuilder! Resumindo, TweenAnimationBuilder é uma ótima forma de criar animações implícitas do tipo “configure e esqueça” se você não encontrar um widget embutido do tipo AnimatedFoo. Você pode fazer animações simples usando TweenAnimationBuilder sem precisar usar um StatefulWidget. Você pode mudar esse valor final no Tween para animar suavemente até um novo valor. Também há possíveis otimizações de desempenho ao passar um child antecipadamente ou definir um Tween static final quando for apropriado. Para saber mais sobre qual widget de animação usar em cada situação, confira os outros artigos desta série.

Este é o artigo equivalente ao seguinte conteúdo em vídeo. Se preferir vídeos, assista:

Watch on YouTube in a new tab: "Creating your own Custom Implicit Animations with TweenAnimationBuilder"

Artigos desta série:

Mais do Flutter