Animações direcionais com animações explícitas nativas
Aprenda a criar animações que rodam para frente e para trás com os widgets de animação explícita nativos do Flutter.
Para assistir a este post em vídeo, confira nosso vídeo no YouTube aqui.
Oi! Em nossos posts
anteriores, aprendemos a fazer algumas animações incríveis usando as animações implícitas do Flutter.
AnimatedFoo e TweenAnimationBuilder deram a você a capacidade de adicionar animações básicas ao seu app. Essas animações normalmente seguem uma direção, “interpolando” de um início até um fim, onde param. Nos bastidores, o Flutter assume o controle, decide as intenções e elimina a necessidade de você se preocupar com a transição de uma coisa para a próxima.
Isso funciona perfeitamente para muitos objetivos de animação, mas às vezes essa seta do tempo que só avança nos deixa presos temporalmente. Assim, enquanto paramos para contemplar as leis da termodinâmica e a inevitável morte térmica do universo, não seria legal se pudéssemos reverter o tempo e fazer tudo de novo?
Entre na nossa primeira incursão nas animações explícitas do Flutter! Não vamos construir nenhuma máquina do tempo hoje, mas vamos aprender a ter um pouco mais de controle sobre suas animações usando widgets de Transition.
Os widgets de Transition são um conjunto de widgets do Flutter cujos nomes terminam em — adivinhou — Transition.
ScaleTransition,
DecoratedBoxTransition,
SizeTransition, e outros. Eles se parecem e funcionam muito com os nossos widgets
AnimatedBlah. PositionedTransition, por exemplo, anima a transição de um widget entre diferentes posições. Isso é bem parecido com
AnimatedPositioned, mas há uma grande diferença: esses widgets de Transition são extensões de
AnimatedWidget. Isso os torna
animações explícitas.
Mas o que isso realmente significa para nós, desenvolvedores de apps? Vamos ver passo a passo o que faz essas animações funcionarem.
Aqui, vamos criar uma animação de proporções galácticas, usando esta imagem inicial. Mas, neste estado inicial sem animação, ela não parece muito galáctica. Nossa primeira missão: incluir uma rotação.
RotationTransition como exemplo
O widget RotationTransition
é útil, pois cuida de todos os cálculos trigonométricos e transformações para fazer as coisas girarem. Seu construtor recebe apenas três coisas:
// [Most of] RotationTransition's constructor
RotationTransition({
Widget child,
Alignment alignment,
Animation<double> turns,
})
Primeiro, um child — o widget que queremos girar. A galáxia serve, então vamos colocá-la ali:
RotationTransition(
child: GalaxyFitz(),
alignment: null, /*TODO*/
turns: null, /*TODO*/
)
Em seguida, precisamos informar à RotationTransition o ponto em torno do qual nossa galáxia gira. O buraco negro da nossa galáxia fica aproximadamente no centro da imagem, onde normalmente esperaríamos. Então, vamos definir um
alignment de center, deixando todos os nossos cálculos de rotação “alinhados” a esse ponto.
RotationTransition(
child: GalaxyFitz(),
alignment: Alignment.center,
turns: null, /*TODO*/
)
Por último, o que é essa propriedade misteriosamente chamada turns? A documentação da API nos diz que é um… Animation?!? Não estávamos criando uma animação?
RotationTransition
documentação diz que turns é do tipo Animation.
Não se preocupe! Isso faz parte do que torna RotationTransition, e todos os outros widgets de Transition, animações explícitas. Nós poderíamos alcançar o mesmo efeito de rotação com um AnimatedContainer e uma transformação, mas aí giraríamos uma vez e pararíamos. Com nossas animações explícitas, temos controle do tempo e podemos fazer com que nossa galáxia nunca pare de girar.
A propriedade turns espera algo que tenha um valor e notifique quando esse valor mudar. Um Animation<double> é exatamente isso. Para RotationTransition, o valor corresponde a quantas vezes giramos, ou, mais especificamente, à porcentagem de uma rotação completa.
Criando um AnimationController
Uma das maneiras mais fáceis de obter um Animation<double> é criar um AnimationController, que é um controlador de animação. Esse controlador cuida de escutar os ticks¹ e nos dá alguns controles úteis sobre o que a animação está fazendo.
Vamos precisar criar isso em um widget com estado, porque manter uma referência ao controlador será importante no nosso futuro não tão distante. Como o AnimationController também tem seu próprio estado para gerenciar, nós o inicializamos em initState e o descartamos em dispose.
class _TimeMachineState extends State<TimeMachine> {
AnimationController _animationController;
@override
void initState() {
super.initState();
_animationController = AnimationController(
// ...
);
}
@override
void dispose() {
_animationController.dispose();
super.dispose();
}
}
Há dois parâmetros que devemos passar para o construtor de AnimationController. O primeiro é uma duração, que é quanto tempo nossa ̶m̶á̶q̶u̶i̶n̶a̶ ̶d̶o̶ ̶t̶e̶m̶p̶o animação dura. O motivo de estarmos aqui é que precisamos de um objeto que nos diga o quão avançados estamos em uma única rotação. Por padrão, AnimationController “emite” valores de 0.0 até 1.0. Quantos valores e com que granularidade dependem de quanto tempo queremos que uma única rotação leve. Felizmente, o Dart nos oferece a classe Duration para usar. Para fins deste exemplo, a galáxia deve girar em algum ponto entre 5 segundos e 230 milhões de anos por rotação. Que tal 15 segundos por volta, então?
_animationController = AnimationController(
duration: Duration(seconds: 15),
// TODO: finish constructing me.
);
O próximo parâmetro obrigatório é vsync. Se você está aqui vindo do futuro, bem-vindo de volta! Esperamos que você já saiba tudo sobre vsync. Para quem veio do passado, basta dizer que isso é o que dá ao Flutter uma referência ao objeto para notificar sobre mudanças. this é esse objeto, e ele precisa incorporar algum código de ticker provider. Um post futuro vai se aprofundar em vsync e ticker providers.
class _TimeMachineState extends State<TimeMachine>
with SingleTickerProviderStateMixin {
AnimationController _animationController;
@override
void initState() {
super.initState();
_animationController = AnimationController(
duration: Duration(seconds: 15),
vsync: this,
);
}
@override
void dispose() {
_animationController.dispose();
super.dispose();
}
}
Se deixarmos as coisas assim, nada muito acontece. Isso porque recebemos um controlador, mas ainda não apertamos nenhum dos seus botões! Queremos que nossa galáxia gire para sempre, certo? Para isso, pediremos ao controlador que repita a animação continuamente.
_animationController = AnimationController(
duration: Duration(seconds: 15),
vsync: this,
)..repeat();
Por fim, podemos voltar e substituir aquele null que deixamos ali, passando o controlador de animação para o parâmetro turns do nosso RotationTransition.
RotationTransition(
child: GalaxyFitz(),
alignment: Alignment.center,
turns: _animationController,
)
E, embora agora tenhamos uma galáxia girando infinitamente, isso ainda não parece que temos controle do tempo. A galáxia simplesmente faz o que quer agora, certo? Lembre-se, porém, que temos uma referência a um controlador. Vamos usá-la.²
Usando um AnimationController
Permitir que qualquer pessoa controle a galáxia parece um pouco permissivo demais, então vou transformar isso em um easter egg. Vou adicionar um irmão à galáxia, um botão simples escondido no canto, e vou passar a ele uma referência ao nosso controlador, para que, dentro do seu listener onTap, possamos parar ou reiniciar a animação.
Stack(
children: <Widget>[
Align(
alignment: Alignment.bottomLeft,
child: TimeStopper(
controller: _animationController,
),
),
Align(
alignment: Alignment.center,
child: RotationTransition(
child: GalaxyFitz(),
alignment: Alignment.center,
turns: _animationController,
),
),
],
)
O controlador mantém — entre outras coisas — o status da animação, que podemos verificar e interromper se estiver em execução, ou reiniciar se não estiver. E pronto! Usando um animation controller, conseguimos controlar a animação sob demanda. Mas isso não é tudo o que você pode fazer com o controlador.
class TimeStopper extends StatelessWidget {
final AnimationController controller;
const TimeStopper({Key key, this.controller}) : super(key: key);
@override
Widget build(BuildContext context) {
return GestureDetector(
onTap: () {
if (controller.isAnimating) {
controller.stop();
} else {
controller.repeat();
}
},
child: InvisibleBox(size: 100),
);
}
}
Com ele, você também pode animar até (ou a partir de) um valor específico, lançar a animação para frente com uma velocidade dada ou controlar várias animações com o mesmo controlador.
Esta foi apenas a nossa primeira amostra de animações explícitas no Flutter. Vimos como um widget de Transition funciona com AnimationController, para oferecer direcionalidade e controle sobre como nossa animação funciona. Em posts futuros, vamos mergulhar mais fundo nas animações explícitas e em como personalizá-las ainda mais.
Os ticks galácticos são difíceis de ouvir, mas AnimationController e TickerProviders ajudam.
Como com todos os seus controladores de tempo: use com responsabilidade.
Artigos desta série: