Was macht Flutter-Animationen?
Überblick
Erstelle flüssige, leistungsstarke Animationen in Flutter mit dem richtigen Ansatz für jeden Anwendungsfall. Dieses Skill deckt den gesamten Animations-Workflow ab: von der Wahl zwischen impliziten und expliziten Ansätzen bis hin zur Implementierung komplexer Effekte wie Hero-Übergänge und gestaffelte Animationen.
Entscheidungsbaum für Animationstypen
Wähle den richtigen Animationstyp basierend auf deinen Anforderungen:
Implizite Animationen – Verwende sie, wenn:
- Eine einzelne Eigenschaft animiert wird (Farbe, Größe, Position)
- Die Animation durch eine Statusänderung ausgelöst wird
- Keine feingranulare Kontrolle erforderlich ist
Explizite Animationen – Verwende sie, wenn:
- Volle Kontrolle über den Animationslebenszyklus benötigt wird
- Mehrere Eigenschaften gleichzeitig animiert werden
- Auf Statusänderungen der Animation reagiert werden muss
- Benutzerdefinierte Animationen oder Übergänge erstellt werden
Hero-Animationen – Verwende sie, wenn:
- Ein Element zwischen zwei Bildschirmen geteilt wird
- Shared-Element-Übergänge erstellt werden
- Der Benutzer erwartet, dass ein Element zwischen Routen „fliegt“
Gestaffelte Animationen – Verwende sie, wenn:
- Mehrere Animationen sequentiell oder überlappend ablaufen sollen
- Ripple-Effekte oder sequentielle Enthüllungen erstellt werden
- Listenelemente nacheinander animiert werden
Physikbasierte Animationen – Verwende sie, wenn:
- Animationen natürlich/physikalisch wirken sollen
- Federähnliches Verhalten, Scroll-Gesten
- Ziehbare Interaktionen
Implizite Animationen
Implizite Animationen verwalten die Animation automatisch, wenn sich Eigenschaften ändern. Es wird kein Controller benötigt.
Häufige implizite Widgets
AnimatedContainer – Animiert mehrere Eigenschaften (Größe, Farbe, Dekoration, 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 – Einfache Einblend-Animation:
AnimatedOpacity(
opacity: _visible ? 1.0 : 0.0,
duration: const Duration(milliseconds: 300),
child: const Text('Hello'),
)
TweenAnimationBuilder – Benutzerdefinierte Tween-Animation ohne 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(),
)
Weitere implizite Widgets:
AnimatedPadding– Padding-AnimationAnimatedPositioned– Positionsanimation (im Stack)AnimatedAlign– AusrichtungsanimationAnimatedContainer– Mehrere EigenschaftenAnimatedSwitcher– Überblenden zwischen WidgetsAnimatedDefaultTextStyle– Textstil-Animation
Best Practices
- Bevorzuge implizite Animationen für einfache Fälle
- Verwende passende Kurven für natürliche Bewegung (siehe
Curves-Klasse) - Setze
curveunddurationfür vorhersagbares Verhalten - Verwende den
onEnd-Callback bei Bedarf - Vermeide verschachtelte implizite Animationen aus Leistungsgründen
Explizite Animationen
Explizite Animationen bieten volle Kontrolle mit AnimationController.
Kernkomponenten
AnimationController – Treibt die Animation an:
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 – Interpoliert zwischen Start- und Endwerten:
animation = Tween<double>(begin: 0, end: 300).animate(_controller);
CurvedAnimation – Wendet eine Kurve auf die Animation an:
animation = CurvedAnimation(
parent: _controller,
curve: Curves.easeInOut,
);
AnimatedWidget-Muster
Am besten geeignet für wiederverwendbare animierte Widgets:
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(),
),
);
}
}
AnimatedBuilder-Muster
Am besten geeignet für komplexe Widgets mit Animationen:
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,
),
);
}
}
Überwachung des Animationsstatus
animation.addStatusListener((status) {
switch (status) {
case AnimationStatus.completed:
_controller.reverse();
break;
case AnimationStatus.dismissed:
_controller.forward();
break;
default:
break;
}
});
Mehrere gleichzeitige Animationen
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(),
),
),
);
}
}
Integrierte explizite Übergänge
Flutter bietet vorgefertigte Übergänge:
FadeTransition– Einblend-AnimationScaleTransition– SkalierungsanimationSlideTransition– SchiebeanimationSizeTransition– GrößenanimationRotationTransition– RotationsanimationPositionedTransition– Positionsanimation (im Stack)
Beispiel:
FadeTransition(
opacity: _animation,
child: const FlutterLogo(),
)
Leistungstipps
- Entsorge Controller, wenn das Widget entfernt wird
- Verwende
AnimatedBuilderfür optimale Neuerstellungen - Vermeide
setState()in Animations-Listenern (verwendeAnimatedWidget/AnimatedBuilder) - Verwende
timeDilation, um Animationen während des Debuggens zu verlangsamen
Hero-Animationen
Hero-Animationen erstellen Shared-Element-Übergänge zwischen Bildschirmen.
Einfache Hero-Animation
Quellbildschirm:
Hero(
tag: 'hero-image',
child: Image.asset('images/logo.png'),
)
Zielbildschirm:
Hero(
tag: 'hero-image', // Gleicher Tag!
child: Image.asset('images/logo.png'),
)
Vollständiges Beispiel
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),
),
),
),
);
}
}
Navigation zwischen Bildschirmen:
Navigator.of(context).push(
MaterialPageRoute<void>(
builder: (context) {
return Scaffold(
appBar: AppBar(title: const Text('Detail')),
body: Center(
child: PhotoHero(
photo: 'images/logo.png',
width: 300.0,
onTap: () => Navigator.of(context).pop(),
),
),
);
},
),
);
Radiale Hero-Animation
Wandle während des Übergangs von einem Kreis in ein Rechteck um:
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),
),
),
);
}
}
Verwende mit MaterialRectCenterArcTween für zentrierte Interpolation:
static RectTween _createRectTween(Rect? begin, Rect? end) {
return MaterialRectCenterArcTween(begin: begin, end: end);
}
Best Practices für Hero-Animationen
- Verwende eindeutige, konsistente Tags (oft das Datenobjekt selbst)
- Halte die Widget-Bäume des Hero-Widgets zwischen Routen ähnlich
- Wickle Bilder in
Materialmit transparenter Farbe ein, um einen „Pop“-Effekt zu erzielen - Verwende
timeDilation, um Übergänge zu debuggen - Erwäge
HeroMode, um Hero-Animationen bei Bedarf zu deaktivieren
Gestaffelte Animationen
Führe mehrere Animationen mit unterschiedlichem Timing aus.
Einfache gestaffelte Animation
Alle Animationen teilen sich einen Controller:
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,
);
}
}
Intervallbasiertes Timing
Jede Animation hat ein Intervall zwischen 0.0 und 1.0:
animation = Tween<double>(begin: 0, end: 300).animate(
CurvedAnimation(
parent: controller,
curve: const Interval(
0.25, // Start bei 25% der Controller-Dauer
0.50, // Ende bei 50% der Controller-Dauer
curve: Curves.ease,
),
),
);
Häufige Tweens
borderRadius = BorderRadiusTween(
begin: BorderRadius.circular(4),
end: BorderRadius.circular(75),
).animate(
CurvedAnimation(
parent: controller,
curve: const Interval(0.375, 0.500, curve: Curves.ease),
),
);
Gestaffelte Menü-Animation
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();
}
}
Best Practices für gestaffelte Animationen
- Verwende
Interval, um Animationen zeitlich zu versetzen - Stelle sicher, dass die Controller-Dauer alle Intervalle abdeckt
- Verwende Kurven für natürliche Bewegung innerhalb der Intervalle
- Erwäge
timeDilation, um das Timing zu debuggen - Staffele Menüpunkte mit zunehmender Verzögerung für einen Ripple-Effekt
Physikbasierte Animationen
Erstelle natürlich wirkende Animationen mit Physiksimulationen.
Fling-Animation
_controller.fling(
velocity: 2.0, // Einheiten pro Sekunde
);
Benutzerdefinierte Physiksimulation
_controller.animateWith(
SpringSimulation(
spring: const SpringDescription(
mass: 1,
stiffness: 100,
damping: 10,
),
start: 0.0,
end: 1.0,
velocity: 0.0,
),
);
Häufige Physiksimulationen
SpringSimulation– FederphysikBouncingScrollSimulation– Scrollen mit SpringenClampingScrollSimulation– Scrollen ohne SpringenGravitySimulation– Schwerkraftbasiert
Best Practices
MACHEN
- Entsorge AnimationController, wenn das Widget entsorgt wird
- Verwende
AnimatedBuilder/AnimatedWidgetstattsetState()in Listenern - Wähle passende Kurven für natürliche Bewegung
- Verwende
timeDilationzum Debuggen von Animationen - Berücksichtige die Leistung (vermeide schwere Widgets in Animations-Builds)
- Teste Animationen auf verschiedenen Geräten
- Unterstütze Rückwärtsanimationen für ein intuitives Gefühl
NICHT MACHEN
- Vergiss nicht, AnimationController zu entsorgen (Speicherleck)
- Verwende
setState()in Animations-Listenern, wennAnimatedBuilderausreicht - Gehe nicht davon aus, dass die Animation sofort abgeschlossen ist (behandle
AnimationStatus) - Überanimieren (Animationen können Benutzer ablenken)
- Erstelle keine Animationen, die „ruckelig“ wirken (verwende glatte Kurven)
- Ignoriere die Barrierefreiheit (respektiere die Einstellung
disableAnimations)
Ressourcen
references/
implicit.md – Vollständige Referenz für implizite Animations-Widgets mit Beispielen und Best Practices.
explicit.md – Tiefergehende Erklärung von expliziten Animationen, AnimationController und Mustern.
hero.md – Leitfaden für Hero-Animationen mit Standard- und Radialübergängen.
staggered.md – Muster und Timingsstrategien für gestaffelte Animationen.
physics.md – Physikbasierte Animationen und Simulationen.
curves.md – Referenz für die Curves-Klasse und die Auswahl geeigneter Kurven.