A controller for an animation.

This class lets you perform tasks such as:

By default, an AnimationController linearly produces values that range from 0.0 to 1.0, during a given duration. The animation controller generates a new value whenever the device running your app is ready to display a new frame (typically, this rate is around 60 values per second).

An AnimationController needs a TickerProvider, which is configured using the vsync argument on the constructor. If you are creating an AnimationController from a State, then you can use the TickerProviderStateMixin and SingleTickerProviderStateMixin classes to obtain a suitable TickerProvider. The widget test framework WidgetTester object can be used as a ticker provider in the context of tests. In other contexts, you will have to either pass a TickerProvider from a higher level (e.g. indirectly from a State that mixes in TickerProviderStateMixin), or create a custom TickerProvider subclass.

The methods that start animations return a TickerFuture object which completes when the animation completes successfully, and never throws an error; if the animation is canceled, the future never completes. This object also has a TickerFuture.orCancel property which returns a future that completes when the animation completes successfully, and completes with an error when the animation is aborted.

This can be used to write code such as:

Future<Null> fadeOutAndUpdateState() async {
  try {
    await fadeAnimationController.forward().orCancel;
    await sizeAnimationController.forward().orCancel;
    setState(() {
      dismissed = true;
  } on TickerCanceled {
    // the animation got canceled, probably because we were disposed

...which asynchronously runs one animation, then runs another, then changes the state of the widget, without having to verify State.mounted is still true at each step, and without having to chain futures together explicitly. (This assumes that the controllers are created in State.initState and disposed in State.dispose.)



AnimationController({double value, Duration duration, String debugLabel, double lowerBound: 0.0, double upperBound: 1.0, @required TickerProvider vsync })
Creates an animation controller. [...]
AnimationController.unbounded({double value: 0.0, Duration duration, String debugLabel, @required TickerProvider vsync })
Creates an animation controller with no upper or lower bound for its value. [...]


debugLabel String
A label that is used in the toString output. Intended to aid with identifying animation controller instances in debug output.
duration Duration
The length of time this animation should last.
read / write
isAnimating bool
Whether this animation is currently animating in either the forward or reverse direction. [...]
lastElapsedDuration Duration
The amount of time that has passed between the time the animation started and the most recent tick of the animation. [...]
lowerBound double
The value at which this animation is deemed to be dismissed.
status AnimationStatus
The current status of this animation.
upperBound double
The value at which this animation is deemed to be completed.
value double
The current value of the animation. [...]
read / write
velocity double
The rate of change of value per second. [...]
view Animation<double>
Returns an Animation for this animation controller, so that a pointer to this object can be passed around without allowing users of that pointer to mutate the AnimationController state.
hashCode int
The hash code for this object. [...]
read-only, inherited
isCompleted bool
Whether this animation is stopped at the end.
read-only, inherited
isDismissed bool
Whether this animation is stopped at the beginning.
read-only, inherited
runtimeType Type
A representation of the runtime type of the object.
read-only, inherited


animateTo(double target, { Duration duration, Curve curve: Curves.linear }) TickerFuture
Drives the animation from its current value to target. [...]
animateWith(Simulation simulation) TickerFuture
Drives the animation according to the given simulation. [...]
dispose() → void
Release the resources used by this object. The object is no longer usable after this method is called. [...]
fling({double velocity: 1.0 }) TickerFuture
Drives the animation with a critically damped spring (within lowerBound and upperBound) and initial velocity. [...]
forward({double from }) TickerFuture
Starts running this animation forwards (towards the end). [...]
repeat({double min, double max, Duration period }) TickerFuture
Starts running this animation in the forward direction, and restarts the animation when it completes. [...]
reset() → void
Sets the controller's value to lowerBound, stopping the animation (if in progress), and resetting to its beginning point, or dismissed state.
resync(TickerProvider vsync) → void
Recreates the Ticker with the new TickerProvider.
reverse({double from }) TickerFuture
Starts running this animation in reverse (towards the beginning). [...]
stop({bool canceled: true }) → void
Stops running this animation. [...]
toStringDetails() String
Provides a string describing the status of this object, but not including information about the object itself. [...]
addListener(VoidCallback listener) → void
Calls the listener every time the value of the animation changes. [...]
addStatusListener(AnimationStatusListener listener) → void
Calls listener every time the status of the animation changes. [...]
didRegisterListener() → void
didUnregisterListener() → void
noSuchMethod(Invocation invocation) → dynamic
Invoked when a non-existent method or property is accessed. [...]
notifyListeners() → void
Calls all the listeners. [...]
notifyStatusListeners(AnimationStatus status) → void
Calls all the status listeners. [...]
removeListener(VoidCallback listener) → void
Stop calling the listener every time the value of the animation changes. [...]
removeStatusListener(AnimationStatusListener listener) → void
Stops calling the listener every time the status of the animation changes. [...]
toString() String
Returns a string representation of this object.


operator ==(other) bool
The equality operator. [...]