Animações Flutter
Visão Geral
Crie animações suaves e performáticas em Flutter usando a abordagem certa para cada caso de uso. Este skill cobre o fluxo de trabalho completo de animação: desde a escolha entre abordagens implícitas/explícitas até a implementação de efeitos complexos como transições hero e animações escalonadas.
Árvore de Decisão do Tipo de Animação
Escolha o tipo de animação certo com base em seus requisitos:
Animações Implícitas - Use quando:
- Animando uma única propriedade (cor, tamanho, posição)
- Animações são disparadas por mudanças de estado
- Não há necessidade de controle refinado
Animações Explícitas - Use quando:
- Precisa de controle total sobre o ciclo de vida da animação
- Animando várias propriedades simultaneamente
- Precisa reagir a mudanças de estado da animação
- Criando animações ou transições personalizadas
Animações Hero - Use quando:
- Compartilhando um elemento entre duas telas
- Criando transições de elementos compartilhados
- O usuário espera que o elemento "voe" entre rotas
Animações Escalonadas - Use quando:
- Múltiplas animações devem ser executadas sequencialmente ou sobrepostas
- Criando efeitos de ondulação ou revelações sequenciais
- Animando itens de lista em sequência
Animações Baseadas em Física - Use quando:
- As animações devem parecer naturais/físicas
- Comportamento de mola, gestos de rolagem
- Interações arrastáveis
Animações Implícitas
Animações implícitas lidam automaticamente com a animação quando as propriedades mudam. Nenhum controlador necessário.
Widgets Implícitos Comuns
AnimatedContainer - Anima várias propriedades (tamanho, cor, decoração, padding):
AnimatedContainer(
duration: const Duration(milliseconds: 300),
curve: Curves.easeInOut,
width: _expanded ? 200 : 100,
height: _expanded ? 200 : 100,
color: _expanded ? Colors.blue : Colors.red,
child: const FlutterLogo(),
)
AnimatedOpacity - Animação simples de desvanecimento:
AnimatedOpacity(
opacity: _visible ? 1.0 : 0.0,
duration: const Duration(milliseconds: 300),
child: const Text('Olá'),
)
TweenAnimationBuilder - Animação de tween personalizada sem código boilerplate:
TweenAnimationBuilder<double>(
tween: Tween<double>(begin: 0, end: 1),
duration: const Duration(seconds: 1),
builder: (context, value, child) {
return Opacity(
opacity: value,
child: Transform.scale(
scale: value,
child: child,
),
);
},
child: const FlutterLogo(),
)
Outros widgets implícitos:
AnimatedPadding- Animação de paddingAnimatedPositioned- Animação de posição (em Stack)AnimatedAlign- Animação de alinhamentoAnimatedContainer- Múltiplas propriedadesAnimatedSwitcher- Transição cruzada entre widgetsAnimatedDefaultTextStyle- Animação de estilo de texto
Melhores Práticas
- Prefira animações implícitas para casos simples
- Use curvas apropriadas para movimento natural (veja a classe
Curves) - Defina
curveedurationpara comportamento previsível - Use o callback
onEndquando necessário - Evite animações implícitas aninhadas por desempenho
Animações Explícitas
Animações explícitas fornecem controle total com AnimationController.
Componentes Principais
AnimationController - Controla a animação:
late AnimationController _controller;
@override
void initState() {
super.initState();
_controller = AnimationController(
duration: const Duration(seconds: 2),
vsync: this,
);
}
@override
void dispose() {
_controller.dispose();
super.dispose();
}
Tween - Interpola entre valores inicial e final:
animation = Tween<double>(begin: 0, end: 300).animate(_controller);
CurvedAnimation - Aplica uma curva à animação:
animation = CurvedAnimation(
parent: _controller,
curve: Curves.easeInOut,
);
Padrão AnimatedWidget
Melhor para widgets animados reutilizáveis:
class AnimatedLogo extends AnimatedWidget {
const AnimatedLogo({super.key, required Animation<double> animation})
: super(listenable: animation);
@override
Widget build(BuildContext context) {
final animation = listenable as Animation<double>;
return Center(
child: Container(
height: animation.value,
width: animation.value,
child: const FlutterLogo(),
),
);
}
}
Padrão AnimatedBuilder
Melhor para widgets complexos com animações:
class GrowTransition extends StatelessWidget {
const GrowTransition({
required this.child,
required this.animation,
super.key,
});
final Widget child;
final Animation<double> animation;
@override
Widget build(BuildContext context) {
return Center(
child: AnimatedBuilder(
animation: animation,
builder: (context, child) {
return SizedBox(
height: animation.value,
width: animation.value,
child: child,
);
},
child: child,
),
);
}
}
Monitorando o Estado da Animação
animation.addStatusListener((status) {
switch (status) {
case AnimationStatus.completed:
_controller.reverse();
break;
case AnimationStatus.dismissed:
_controller.forward();
break;
default:
break;
}
});
Múltiplas Animações Simultâneas
class AnimatedLogo extends AnimatedWidget {
const AnimatedLogo({super.key, required Animation<double> animation})
: super(listenable: animation);
static final _opacityTween = Tween<double>(begin: 0.1, end: 1);
static final _sizeTween = Tween<double>(begin: 0, end: 300);
@override
Widget build(BuildContext context) {
final animation = listenable as Animation<double>;
return Center(
child: Opacity(
opacity: _opacityTween.evaluate(animation),
child: Container(
height: _sizeTween.evaluate(animation),
width: _sizeTween.evaluate(animation),
child: const FlutterLogo(),
),
),
);
}
}
Transições Explícitas Embutidas
Flutter fornece transições prontas para uso:
FadeTransition- Animação de desvanecimentoScaleTransition- Animação de escalaSlideTransition- Animação de deslizamentoSizeTransition- Animação de tamanhoRotationTransition- Animação de rotaçãoPositionedTransition- Animação de posição (em Stack)
Exemplo:
FadeTransition(
opacity: _animation,
child: const FlutterLogo(),
)
Dicas de Desempenho
- Descarte controladores quando o widget for removido
- Use
AnimatedBuilderpara reconstruções ideais - Evite
setState()em listeners de animação (useAnimatedWidget/AnimatedBuilder) - Use
timeDilationpara desacelerar animações durante a depuração
Animações Hero
Animações Hero criam transições de elementos compartilhados entre telas.
Animação Hero Básica
Tela de origem:
Hero(
tag: 'hero-image',
child: Image.asset('images/logo.png'),
)
Tela de destino:
Hero(
tag: 'hero-image', // Mesma tag!
child: Image.asset('images/logo.png'),
)
Exemplo Completo
class PhotoHero extends StatelessWidget {
const PhotoHero({
super.key,
required this.photo,
this.onTap,
required this.width,
});
final String photo;
final VoidCallback? onTap;
final double width;
@override
Widget build(BuildContext context) {
return SizedBox(
width: width,
child: Hero(
tag: photo,
child: Material(
color: Colors.transparent,
child: InkWell(
onTap: onTap,
child: Image.asset(photo, fit: BoxFit.contain),
),
),
),
);
}
}
Navegando entre telas:
Navigator.of(context).push(
MaterialPageRoute<void>(
builder: (context) {
return Scaffold(
appBar: AppBar(title: const Text('Detalhe')),
body: Center(
child: PhotoHero(
photo: 'images/logo.png',
width: 300.0,
onTap: () => Navigator.of(context).pop(),
),
),
);
},
),
);
Animação Hero Radial
Transforme de círculo para retângulo durante a transição:
class RadialExpansion extends StatelessWidget {
const RadialExpansion({
super.key,
required this.maxRadius,
this.child,
}) : clipRectSize = 2.0 * (maxRadius / math.sqrt2);
final double maxRadius;
final double clipRectSize;
final Widget? child;
@override
Widget build(BuildContext context) {
return ClipOval(
child: Center(
child: SizedBox(
width: clipRectSize,
height: clipRectSize,
child: ClipRect(child: child),
),
),
);
}
}
Use com MaterialRectCenterArcTween para interpolação baseada no centro:
static RectTween _createRectTween(Rect? begin, Rect? end) {
return MaterialRectCenterArcTween(begin: begin, end: end);
}
Melhores Práticas Hero
- Use tags únicas e consistentes (muitas vezes o próprio objeto de dados)
- Mantenha as árvores de widgets hero semelhantes entre as rotas
- Envolva imagens em
Materialcom cor transparente para efeito "pop" - Use
timeDilationpara depurar transições - Considere
HeroModepara desabilitar animações hero quando necessário
Animações Escalonadas
Execute múltiplas animações com tempos diferentes.
Animação Escalonada Básica
Todas as animações compartilham um controlador:
class StaggerAnimation extends StatelessWidget {
StaggerAnimation({super.key, required this.controller})
: opacity = Tween<double>(begin: 0.0, end: 1.0).animate(
CurvedAnimation(
parent: controller,
curve: const Interval(0.0, 0.100, curve: Curves.ease),
),
),
width = Tween<double>(begin: 50.0, end: 150.0).animate(
CurvedAnimation(
parent: controller,
curve: const Interval(0.125, 0.250, curve: Curves.ease),
),
);
final AnimationController controller;
final Animation<double> opacity;
final Animation<double> width;
Widget _buildAnimation(BuildContext context, Widget? child) {
return Container(
alignment: Alignment.bottomCenter,
child: Opacity(
opacity: opacity.value,
child: Container(
width: width.value,
height: 150,
color: Colors.blue,
),
),
);
}
@override
Widget build(BuildContext context) {
return AnimatedBuilder(
animation: controller,
builder: _buildAnimation,
);
}
}
Temporização Baseada em Intervalos
Cada animação tem um Intervalo entre 0.0 e 1.0:
animation = Tween<double>(begin: 0, end: 300).animate(
CurvedAnimation(
parent: controller,
curve: const Interval(
0.25, // Inicia em 25% da duração do controlador
0.50, // Termina em 50% da duração do controlador
curve: Curves.ease,
),
),
);
Tweens Comuns
borderRadius = BorderRadiusTween(
begin: BorderRadius.circular(4),
end: BorderRadius.circular(75),
).animate(
CurvedAnimation(
parent: controller,
curve: const Interval(0.375, 0.500, curve: Curves.ease),
),
);
Animação de Menu Escalonado
class _MenuState extends State<Menu> with SingleTickerProviderStateMixin {
static const _initialDelayTime = Duration(milliseconds: 50);
static const _itemSlideTime = Duration(milliseconds: 250);
static const _staggerTime = Duration(milliseconds: 50);
static const _buttonDelayTime = Duration(milliseconds: 150);
static const _buttonTime = Duration(milliseconds: 500);
final _animationDuration =
_initialDelayTime +
(_staggerTime * _menuTitles.length) +
_buttonDelayTime +
_buttonTime;
late AnimationController _controller;
@override
void initState() {
super.initState();
_controller = AnimationController(
duration: _animationDuration,
vsync: this,
);
_controller.forward();
}
@override
void dispose() {
_controller.dispose();
super.dispose();
}
}
Melhores Práticas Escalonadas
- Use
Intervalpara deslocar animações no tempo - Certifique-se de que a duração do controlador cubra todos os intervalos
- Use curvas para movimento natural dentro dos intervalos
- Considere
timeDilationpara depurar temporizações - Escalone itens de menu com atraso crescente para efeito de ondulação
Animações Baseadas em Física
Crie animações de sensação natural usando simulações físicas.
Animação Fling
_controller.fling(
velocity: 2.0, // Unidades por segundo
);
Simulação Física Personalizada
_controller.animateWith(
SpringSimulation(
spring: const SpringDescription(
mass: 1,
stiffness: 100,
damping: 10,
),
start: 0.0,
end: 1.0,
velocity: 0.0,
),
);
Simulações Físicas Comuns
SpringSimulation- Física de molaBouncingScrollSimulation- Rolagem com ressaltoClampingScrollSimulation- Rolagem sem ressaltoGravitySimulation- Baseada em gravidade
Melhores Práticas
FAÇA
- Descarte AnimationController na disposição do widget
- Use
AnimatedBuilder/AnimatedWidgetem vez desetState()em listeners - Escolha curvas apropriadas para movimento natural
- Use
timeDilationpara depurar animações - Considere o desempenho (evite widgets pesados em construções de animação)
- Teste animações em vários dispositivos
- Suporte animações reversas para sensação intuitiva
NÃO FAÇA
- Esqueça de descartar AnimationController (vazamento de memória)
- Use
setState()em listeners de animação quandoAnimatedBuilderé suficiente - Assuma que a animação completa instantaneamente (lide com
AnimationStatus) - Anime em excesso (animações podem distrair usuários)
- Crie animações que pareçam "instáveis" (use curvas suaves)
- Ignore acessibilidade (respeite a preferência
disableAnimations)
Recursos
referências/
implicit.md - Referência completa para widgets de animação implícita com exemplos e melhores práticas.
explicit.md - Aprofundamento em animações explícitas, AnimationController e padrões.
hero.md - Guia de animações Hero com transições padrão e radiais.
staggered.md - Padrões de animação escalonada e estratégias de temporização.
physics.md - Animações e simulações baseadas em física.
curves.md - Referência para a classe Curves e escolha de curvas apropriadas.