Animaciones en Flutter
Descripción general
Crea animaciones suaves y eficientes en Flutter utilizando el enfoque adecuado para cada caso de uso. Esta habilidad cubre el flujo de trabajo completo de animación: desde elegir entre enfoques implícitos y explícitos hasta implementar efectos complejos como transiciones héroe y animaciones escalonadas.
Árbol de decisión del tipo de animación
Elige el tipo de animación adecuado según tus requisitos:
Animaciones Implícitas - Úsalas cuando:
- Animes una sola propiedad (color, tamaño, posición)
- La animación se active por un cambio de estado
- No necesites control detallado
Animaciones Explícitas - Úsalas cuando:
- Necesites control total sobre el ciclo de vida de la animación
- Animes múltiples propiedades simultáneamente
- Necesites reaccionar a cambios de estado de la animación
- Crees animaciones o transiciones personalizadas
Animaciones Héroe - Úsalas cuando:
- Compartas un elemento entre dos pantallas
- Crees transiciones de elementos compartidos
- El usuario espere que un elemento "vuele" entre rutas
Animaciones Escalonadas - Úsalas cuando:
- Múltiples animaciones deban ejecutarse secuencialmente o superponerse
- Creases efectos de onda o revelaciones secuenciales
- Animes elementos de una lista en secuencia
Animaciones Basadas en Física - Úsalas cuando:
- Las animaciones deban sentirse naturales/físicas
- Se requiera comportamiento de resorte, gestos de desplazamiento
- Interacciones arrastrables
Animaciones Implícitas
Las animaciones implícitas manejan automáticamente la animación cuando las propiedades cambian. No necesitan controlador.
Widgets implícitos comunes
AnimatedContainer - Anima múltiples propiedades (tamaño, color, decoración, relleno):
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 - Animación de fundido simple:
AnimatedOpacity(
opacity: _visible ? 1.0 : 0.0,
duration: const Duration(milliseconds: 300),
child: const Text('Hola'),
)
TweenAnimationBuilder - Animación Tween personalizada sin código repetitivo:
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(),
)
Otros widgets implícitos:
AnimatedPadding- Animación de rellenoAnimatedPositioned- Animación de posición (en Stack)AnimatedAlign- Animación de alineaciónAnimatedContainer- Múltiples propiedadesAnimatedSwitcher- Transición entre widgetsAnimatedDefaultTextStyle- Animación de estilo de texto
Mejores prácticas
- Prefiere animaciones implícitas para casos simples
- Usa curvas apropiadas para movimiento natural (ver clase
Curves) - Establece
curveydurationpara un comportamiento predecible - Usa el callback
onEndcuando sea necesario - Evita animaciones implícitas anidadas por rendimiento
Animaciones Explícitas
Las animaciones explícitas proporcionan control total con AnimationController.
Componentes principales
AnimationController - Impulsa la animación:
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 y final:
animation = Tween<double>(begin: 0, end: 300).animate(_controller);
CurvedAnimation - Aplica una curva a la animación:
animation = CurvedAnimation(
parent: _controller,
curve: Curves.easeInOut,
);
Patrón AnimatedWidget
Ideal para widgets animados reutilizables:
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(),
),
);
}
}
Patrón AnimatedBuilder
Ideal para widgets complejos con animaciones:
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,
),
);
}
}
Monitoreo del estado de la animación
animation.addStatusListener((status) {
switch (status) {
case AnimationStatus.completed:
_controller.reverse();
break;
case AnimationStatus.dismissed:
_controller.forward();
break;
default:
break;
}
});
Múltiples animaciones 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(),
),
),
);
}
}
Transiciones explícitas incorporadas
Flutter proporciona transiciones listas para usar:
FadeTransition- Animación de fundidoScaleTransition- Animación de escalaSlideTransition- Animación de desplazamientoSizeTransition- Animación de tamañoRotationTransition- Animación de rotaciónPositionedTransition- Animación de posición (en Stack)
Ejemplo:
FadeTransition(
opacity: _animation,
child: const FlutterLogo(),
)
Consejos de rendimiento
- Libera los controladores cuando se elimine el widget
- Usa
AnimatedBuilderpara reconstrucciones óptimas - Evita
setState()en los listeners de animación (usaAnimatedWidget/AnimatedBuilder) - Usa
timeDilationpara ralentizar animaciones durante la depuración
Animaciones Héroe
Las animaciones héroe crean transiciones de elementos compartidos entre pantallas.
Animación Héroe básica
Pantalla de origen:
Hero(
tag: 'hero-image',
child: Image.asset('images/logo.png'),
)
Pantalla de destino:
Hero(
tag: 'hero-image', // ¡Misma etiqueta!
child: Image.asset('images/logo.png'),
)
Ejemplo 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 pantallas:
Navigator.of(context).push(
MaterialPageRoute<void>(
builder: (context) {
return Scaffold(
appBar: AppBar(title: const Text('Detalle')),
body: Center(
child: PhotoHero(
photo: 'images/logo.png',
width: 300.0,
onTap: () => Navigator.of(context).pop(),
),
),
);
},
),
);
Animación Héroe radial
Transforma de círculo a rectángulo durante la transición:
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),
),
),
);
}
}
Úsalo con MaterialRectCenterArcTween para interpolación basada en el centro:
static RectTween _createRectTween(Rect? begin, Rect? end) {
return MaterialRectCenterArcTween(begin: begin, end: end);
}
Mejores prácticas para Héroe
- Usa etiquetas únicas y consistentes (a menudo el propio objeto de datos)
- Mantén los árboles de widgets héroe similares entre rutas
- Envuelve las imágenes en
Materialcon color transparente para un efecto "pop" - Usa
timeDilationpara depurar transiciones - Considera
HeroModepara deshabilitar animaciones héroe cuando sea necesario
Animaciones Escalonadas
Ejecuta múltiples animaciones con diferentes tiempos.
Animación escalonada básica
Todas las animaciones comparten un 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,
);
}
}
Temporización basada en intervalos
Cada animación tiene un Interval entre 0.0 y 1.0:
animation = Tween<double>(begin: 0, end: 300).animate(
CurvedAnimation(
parent: controller,
curve: const Interval(
0.25, // Comienza al 25% de la duración del controlador
0.50, // Termina al 50% de la duración del controlador
curve: Curves.ease,
),
),
);
Tweens comunes
borderRadius = BorderRadiusTween(
begin: BorderRadius.circular(4),
end: BorderRadius.circular(75),
).animate(
CurvedAnimation(
parent: controller,
curve: const Interval(0.375, 0.500, curve: Curves.ease),
),
);
Animación de menú 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();
}
}
Mejores prácticas para escalonadas
- Usa
Intervalpara desplazar las animaciones en el tiempo - Asegúrate de que la duración del controlador cubra todos los intervalos
- Usa curvas para un movimiento natural dentro de los intervalos
- Considera
timeDilationpara depurar la temporización - Escalona los elementos del menú con retraso creciente para un efecto de onda
Animaciones Basadas en Física
Crea animaciones con sensación natural usando simulaciones físicas.
Animación Fling
_controller.fling(
velocity: 2.0, // Unidades por segundo
);
Simulación física personalizada
_controller.animateWith(
SpringSimulation(
spring: const SpringDescription(
mass: 1,
stiffness: 100,
damping: 10,
),
start: 0.0,
end: 1.0,
velocity: 0.0,
),
);
Simulaciones físicas comunes
SpringSimulation- Física de resorteBouncingScrollSimulation- Desplazamiento con reboteClampingScrollSimulation- Desplazamiento sin reboteGravitySimulation- Basada en gravedad
Mejores prácticas
HACER
- Libera AnimationController al eliminar el widget
- Usa
AnimatedBuilder/AnimatedWidgeten lugar desetState()en los listeners - Elige curvas apropiadas para un movimiento natural
- Usa
timeDilationpara depurar animaciones - Considera el rendimiento (evita widgets pesados en las reconstrucciones de animación)
- Prueba las animaciones en varios dispositivos
- Soporta animaciones inversas para una sensación intuitiva
NO HACER
- Olvides liberar AnimationController (fuga de memoria)
- Uses
setState()en los listeners de animación cuandoAnimatedBuildersea suficiente - Asumas que la animación se completa instantáneamente (maneja
AnimationStatus) - Sobreamimes (las animaciones pueden distraer a los usuarios)
- Creases animaciones que se sientan "entrecortadas" (usa curvas suaves)
- Ignorar la accesibilidad (respeta la preferencia
disableAnimations)
Recursos
references/
implicit.md - Referencia completa para widgets de animación implícita con ejemplos y mejores prácticas.
explicit.md - Inmersión profunda en animaciones explícitas, AnimationController y patrones.
hero.md - Guía de animaciones héroe con transiciones estándar y radiales.
staggered.md - Patrones de animación escalonada y estrategias de temporización.
physics.md - Animaciones y simulaciones basadas en física.
curves.md - Referencia para la clase Curves y cómo elegir curvas apropiadas
...
[truncado para traducción]