animation_controller.dart 35.5 KB
Newer Older
Ian Hickson's avatar
Ian Hickson committed
1
// Copyright 2014 The Flutter Authors. All rights reserved.
2 3 4
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

5

6
import 'dart:ui' as ui show lerpDouble;
7

8
import 'package:flutter/foundation.dart';
9
import 'package:flutter/physics.dart';
10
import 'package:flutter/scheduler.dart';
11
import 'package:flutter/semantics.dart';
12 13

import 'animation.dart';
14
import 'curves.dart';
15 16
import 'listener_helpers.dart';

17 18
export 'package:flutter/scheduler.dart' show TickerFuture, TickerCanceled;

19
// Examples can assume:
20 21
// late AnimationController _controller, fadeAnimationController, sizeAnimationController;
// late bool dismissed;
22
// void setState(VoidCallback fn) { }
23

Adam Barth's avatar
Adam Barth committed
24 25 26 27 28 29
/// The direction in which an animation is running.
enum _AnimationDirection {
  /// The animation is running from beginning to end.
  forward,

  /// The animation is running backwards, from end to beginning.
30
  reverse,
Adam Barth's avatar
Adam Barth committed
31 32
}

33
final SpringDescription _kFlingSpringDescription = SpringDescription.withDampingRatio(
34
  mass: 1.0,
35
  stiffness: 500.0,
36 37 38
  ratio: 1.0,
);

39
const Tolerance _kFlingTolerance = Tolerance(
40
  velocity: double.infinity,
41 42 43
  distance: 0.01,
);

44 45
/// Configures how an [AnimationController] behaves when animations are
/// disabled.
46 47
///
/// When [AccessibilityFeatures.disableAnimations] is true, the device is asking
48
/// Flutter to reduce or disable animations as much as possible. To honor this,
49 50 51
/// we reduce the duration and the corresponding number of frames for
/// animations. This enum is used to allow certain [AnimationController]s to opt
/// out of this behavior.
52 53
///
/// For example, the [AnimationController] which controls the physics simulation
54
/// for a scrollable list will have [AnimationBehavior.preserve], so that when
55 56 57 58 59 60 61 62 63 64 65 66 67 68
/// a user attempts to scroll it does not jump to the end/beginning too quickly.
enum AnimationBehavior {
  /// The [AnimationController] will reduce its duration when
  /// [AccessibilityFeatures.disableAnimations] is true.
  normal,

  /// The [AnimationController] will preserve its behavior.
  ///
  /// This is the default for repeating animations in order to prevent them from
  /// flashing rapidly on the screen if the widget does not take the
  /// [AccessibilityFeatures.disableAnimations] flag into account.
  preserve,
}

69 70
/// A controller for an animation.
///
71 72 73 74 75 76 77
/// This class lets you perform tasks such as:
///
/// * Play an animation [forward] or in [reverse], or [stop] an animation.
/// * Set the animation to a specific [value].
/// * Define the [upperBound] and [lowerBound] values of an animation.
/// * Create a [fling] animation effect using a physics simulation.
///
78 79 80 81
/// 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).
82
///
83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
/// ## Ticker providers
///
/// An [AnimationController] needs a [TickerProvider], which is configured using
/// the `vsync` argument on the constructor.
///
/// The [TickerProvider] interface describes a factory for [Ticker] objects. A
/// [Ticker] is an object that knows how to register itself with the
/// [SchedulerBinding] and fires a callback every frame. The
/// [AnimationController] class uses a [Ticker] to step through the animation
/// that it controls.
///
/// If an [AnimationController] is being created from a [State], then the State
/// can use the [TickerProviderStateMixin] and [SingleTickerProviderStateMixin]
/// classes to implement the [TickerProvider] interface. The
/// [TickerProviderStateMixin] class always works for this purpose; the
/// [SingleTickerProviderStateMixin] is slightly more efficient in the case of
/// the class only ever needing one [Ticker] (e.g. if the class creates only a
/// single [AnimationController] during its entire lifetime).
///
/// 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.
///
/// ## Life cycle
///
/// An [AnimationController] should be [dispose]d when it is no longer needed.
/// This reduces the likelihood of leaks. When used with a [StatefulWidget], it
/// is common for an [AnimationController] to be created in the
/// [State.initState] method and then disposed in the [State.dispose] method.
///
/// ## Using [Future]s with [AnimationController]
116 117 118 119 120 121 122 123
///
/// 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.
///
124 125 126
/// This can be used to write code such as the `fadeOutAndUpdateState` method
/// below.
///
127
/// {@tool snippet}
128
///
Dan Field's avatar
Dan Field committed
129
/// Here is a stateful `Foo` widget. Its [State] uses the
130
/// [SingleTickerProviderStateMixin] to implement the necessary
Dan Field's avatar
Dan Field committed
131 132 133 134 135
/// [TickerProvider], creating its controller in the [State.initState] method
/// and disposing of it in the [State.dispose] method. The duration of the
/// controller is configured from a property in the `Foo` widget; as that
/// changes, the [State.didUpdateWidget] method is used to update the
/// controller.
136 137 138
///
/// ```dart
/// class Foo extends StatefulWidget {
139
///   Foo({ Key? key, required this.duration }) : super(key: key);
140 141 142 143 144 145 146 147
///
///   final Duration duration;
///
///   @override
///   _FooState createState() => _FooState();
/// }
///
/// class _FooState extends State<Foo> with SingleTickerProviderStateMixin {
148
///   late AnimationController _controller;
149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
///
///   @override
///   void initState() {
///     super.initState();
///     _controller = AnimationController(
///       vsync: this, // the SingleTickerProviderStateMixin
///       duration: widget.duration,
///     );
///   }
///
///   @override
///   void didUpdateWidget(Foo oldWidget) {
///     super.didUpdateWidget(oldWidget);
///     _controller.duration = widget.duration;
///   }
///
///   @override
///   void dispose() {
///     _controller.dispose();
///     super.dispose();
///   }
///
///   @override
///   Widget build(BuildContext context) {
///     return Container(); // ...
///   }
/// }
/// ```
177
/// {@end-tool}
178
/// {@tool snippet}
179 180 181
///
/// The following method (for a [State] subclass) drives two animation
/// controllers using Dart's asynchronous syntax for awaiting [Future] objects:
182 183
///
/// ```dart
184
/// Future<void> fadeOutAndUpdateState() async {
185 186 187 188 189 190 191 192 193 194 195
///   try {
///     await fadeAnimationController.forward().orCancel;
///     await sizeAnimationController.forward().orCancel;
///     setState(() {
///       dismissed = true;
///     });
///   } on TickerCanceled {
///     // the animation got canceled, probably because we were disposed
///   }
/// }
/// ```
196
/// {@end-tool}
197
///
198 199 200 201 202 203 204 205 206 207 208 209
/// The assumption in the code above is that the animation controllers are being
/// disposed in the [State] subclass' override of the [State.dispose] method.
/// Since disposing the controller cancels the animation (raising a
/// [TickerCanceled] exception), the code here can skip verifying whether
/// [State.mounted] is still true at each step. (Again, this assumes that the
/// controllers are created in [State.initState] and disposed in
/// [State.dispose], as described in the previous section.)
///
/// See also:
///
///  * [Tween], the base class for converting an [AnimationController] to a
///    range of values of other types.
210
class AnimationController extends Animation<double>
211
  with AnimationEagerListenerMixin, AnimationLocalListenersMixin, AnimationLocalStatusListenersMixin {
212 213
  /// Creates an animation controller.
  ///
214
  /// * `value` is the initial value of the animation. If defaults to the lower
215 216
  ///   bound.
  ///
217
  /// * [duration] is the length of time this animation should last.
218 219 220 221 222 223 224 225 226 227 228 229 230
  ///
  /// * [debugLabel] is a string to help identify this animation during
  ///   debugging (used by [toString]).
  ///
  /// * [lowerBound] is the smallest value this animation can obtain and the
  ///   value at which this animation is deemed to be dismissed. It cannot be
  ///   null.
  ///
  /// * [upperBound] is the largest value this animation can obtain and the
  ///   value at which this animation is deemed to be completed. It cannot be
  ///   null.
  ///
  /// * `vsync` is the [TickerProvider] for the current context. It can be
231
  ///   changed by calling [resync]. It is required and must not be null. See
232
  ///   [TickerProvider] for advice on obtaining a ticker provider.
233
  AnimationController({
234
    double? value,
235
    this.duration,
236
    this.reverseDuration,
237
    this.debugLabel,
238 239
    this.lowerBound = 0.0,
    this.upperBound = 1.0,
240
    this.animationBehavior = AnimationBehavior.normal,
241
    required TickerProvider vsync,
242 243 244 245 246
  }) : assert(lowerBound != null),
       assert(upperBound != null),
       assert(upperBound >= lowerBound),
       assert(vsync != null),
       _direction = _AnimationDirection.forward {
247
    _ticker = vsync.createTicker(_tick);
248
    _internalSetValue(value ?? lowerBound);
249 250
  }

251 252
  /// Creates an animation controller with no upper or lower bound for its
  /// value.
253
  ///
254
  /// * [value] is the initial value of the animation.
255
  ///
256
  /// * [duration] is the length of time this animation should last.
257 258 259 260 261
  ///
  /// * [debugLabel] is a string to help identify this animation during
  ///   debugging (used by [toString]).
  ///
  /// * `vsync` is the [TickerProvider] for the current context. It can be
262
  ///   changed by calling [resync]. It is required and must not be null. See
263
  ///   [TickerProvider] for advice on obtaining a ticker provider.
264 265
  ///
  /// This constructor is most useful for animations that will be driven using a
266
  /// physics simulation, especially when the physics simulation has no
267
  /// pre-determined bounds.
268
  AnimationController.unbounded({
269
    double value = 0.0,
270
    this.duration,
271
    this.reverseDuration,
272
    this.debugLabel,
273
    required TickerProvider vsync,
274
    this.animationBehavior = AnimationBehavior.preserve,
275 276
  }) : assert(value != null),
       assert(vsync != null),
277 278
       lowerBound = double.negativeInfinity,
       upperBound = double.infinity,
279
       _direction = _AnimationDirection.forward {
280
    _ticker = vsync.createTicker(_tick);
281
    _internalSetValue(value);
282 283 284 285 286 287 288 289
  }

  /// The value at which this animation is deemed to be dismissed.
  final double lowerBound;

  /// The value at which this animation is deemed to be completed.
  final double upperBound;

290 291
  /// A label that is used in the [toString] output. Intended to aid with
  /// identifying animation controller instances in debug output.
292
  final String? debugLabel;
293

294 295 296
  /// The behavior of the controller when [AccessibilityFeatures.disableAnimations]
  /// is true.
  ///
297
  /// Defaults to [AnimationBehavior.normal] for the [new AnimationController]
298
  /// constructor, and [AnimationBehavior.preserve] for the
299
  /// [new AnimationController.unbounded] constructor.
300 301
  final AnimationBehavior animationBehavior;

302 303 304
  /// Returns an [Animation<double>] 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.
305 306 307
  Animation<double> get view => this;

  /// The length of time this animation should last.
308 309 310
  ///
  /// If [reverseDuration] is specified, then [duration] is only used when going
  /// [forward]. Otherwise, it specifies the duration going in both directions.
311
  Duration? duration;
312

313 314
  /// The length of time this animation should last when going in [reverse].
  ///
315
  /// The value of [duration] is used if [reverseDuration] is not specified or
316
  /// set to null.
317
  Duration? reverseDuration;
318

319
  Ticker? _ticker;
320 321 322

  /// Recreates the [Ticker] with the new [TickerProvider].
  void resync(TickerProvider vsync) {
323
    final Ticker oldTicker = _ticker!;
324
    _ticker = vsync.createTicker(_tick);
325
    _ticker!.absorbTicker(oldTicker);
326 327
  }

328
  Simulation? _simulation;
329

330
  /// The current value of the animation.
331
  ///
332 333 334 335 336 337
  /// Setting this value notifies all the listeners that the value
  /// changed.
  ///
  /// Setting this value also stops the controller if it is currently
  /// running; if this happens, it also notifies all the status
  /// listeners.
338
  @override
339
  double get value => _value;
340
  late double _value;
341 342 343
  /// Stops the animation controller and sets the current value of the
  /// animation.
  ///
344 345
  /// The new value is clamped to the range set by [lowerBound] and
  /// [upperBound].
346 347 348
  ///
  /// Value listeners are notified even if this does not change the value.
  /// Status listeners are notified if the animation was previously playing.
349 350 351 352
  ///
  /// The most recently returned [TickerFuture], if any, is marked as having been
  /// canceled, meaning the future never completes and its [TickerFuture.orCancel]
  /// derivative future completes with a [TickerCanceled] error.
353 354 355 356 357 358 359 360 361
  ///
  /// See also:
  ///
  ///  * [reset], which is equivalent to setting [value] to [lowerBound].
  ///  * [stop], which aborts the animation without changing its value or status
  ///    and without dispatching any notifications other than completing or
  ///    canceling the [TickerFuture].
  ///  * [forward], [reverse], [animateTo], [animateWith], [fling], and [repeat],
  ///    which start the animation controller.
362
  set value(double newValue) {
363
    assert(newValue != null);
364
    stop();
365
    _internalSetValue(newValue);
366
    notifyListeners();
367 368
    _checkStatusChanged();
  }
369

370 371
  /// Sets the controller's value to [lowerBound], stopping the animation (if
  /// in progress), and resetting to its beginning point, or dismissed state.
372 373 374 375 376 377 378 379 380 381 382 383
  ///
  /// The most recently returned [TickerFuture], if any, is marked as having been
  /// canceled, meaning the future never completes and its [TickerFuture.orCancel]
  /// derivative future completes with a [TickerCanceled] error.
  ///
  /// See also:
  ///
  ///  * [value], which can be explicitly set to a specific value as desired.
  ///  * [forward], which starts the animation in the forward direction.
  ///  * [stop], which aborts the animation without changing its value or status
  ///    and without dispatching any notifications other than completing or
  ///    canceling the [TickerFuture].
384 385 386
  void reset() {
    value = lowerBound;
  }
387

388 389 390 391
  /// The rate of change of [value] per second.
  ///
  /// If [isAnimating] is false, then [value] is not changing and the rate of
  /// change is zero.
392 393 394
  double get velocity {
    if (!isAnimating)
      return 0.0;
395
    return _simulation!.dx(lastElapsedDuration!.inMicroseconds.toDouble() / Duration.microsecondsPerSecond);
396 397
  }

398
  void _internalSetValue(double newValue) {
399
    _value = newValue.clamp(lowerBound, upperBound);
400 401 402 403
    if (_value == lowerBound) {
      _status = AnimationStatus.dismissed;
    } else if (_value == upperBound) {
      _status = AnimationStatus.completed;
404
    } else {
405 406 407
      _status = (_direction == _AnimationDirection.forward) ?
        AnimationStatus.forward :
        AnimationStatus.reverse;
408
    }
409 410
  }

411 412
  /// The amount of time that has passed between the time the animation started
  /// and the most recent tick of the animation.
413
  ///
414
  /// If the controller is not animating, the last elapsed duration is null.
415 416
  Duration? get lastElapsedDuration => _lastElapsedDuration;
  Duration? _lastElapsedDuration;
417

418
  /// Whether this animation is currently animating in either the forward or reverse direction.
419 420 421 422 423
  ///
  /// This is separate from whether it is actively ticking. An animation
  /// controller's ticker might get muted, in which case the animation
  /// controller's callbacks will no longer fire even though time is continuing
  /// to pass. See [Ticker.muted] and [TickerMode].
424
  bool get isAnimating => _ticker != null && _ticker!.isActive;
425

Adam Barth's avatar
Adam Barth committed
426 427
  _AnimationDirection _direction;

428
  @override
429
  AnimationStatus get status => _status;
430
  late AnimationStatus _status;
431 432

  /// Starts running this animation forwards (towards the end).
433
  ///
434 435 436 437 438
  /// Returns a [TickerFuture] that completes when the animation is complete.
  ///
  /// The most recently returned [TickerFuture], if any, is marked as having been
  /// canceled, meaning the future never completes and its [TickerFuture.orCancel]
  /// derivative future completes with a [TickerCanceled] error.
439 440 441 442
  ///
  /// During the animation, [status] is reported as [AnimationStatus.forward],
  /// which switches to [AnimationStatus.completed] when [upperBound] is
  /// reached at the end of the animation.
443
  TickerFuture forward({ double? from }) {
444 445
    assert(() {
      if (duration == null) {
446
        throw FlutterError(
447
          'AnimationController.forward() called with no default duration.\n'
448 449 450 451 452
          'The "duration" property should be set, either in the constructor or later, before '
          'calling the forward() function.'
        );
      }
      return true;
453
    }());
454 455 456 457 458
    assert(
      _ticker != null,
      'AnimationController.forward() called after AnimationController.dispose()\n'
      'AnimationController methods should not be used after calling dispose.'
    );
459
    _direction = _AnimationDirection.forward;
460 461
    if (from != null)
      value = from;
462
    return _animateToInternal(upperBound);
463 464
  }

Adam Barth's avatar
Adam Barth committed
465
  /// Starts running this animation in reverse (towards the beginning).
466
  ///
467 468 469 470 471
  /// Returns a [TickerFuture] that completes when the animation is dismissed.
  ///
  /// The most recently returned [TickerFuture], if any, is marked as having been
  /// canceled, meaning the future never completes and its [TickerFuture.orCancel]
  /// derivative future completes with a [TickerCanceled] error.
472 473 474 475
  ///
  /// During the animation, [status] is reported as [AnimationStatus.reverse],
  /// which switches to [AnimationStatus.dismissed] when [lowerBound] is
  /// reached at the end of the animation.
476
  TickerFuture reverse({ double? from }) {
477
    assert(() {
478
      if (duration == null && reverseDuration == null) {
479
        throw FlutterError(
480 481
          'AnimationController.reverse() called with no default duration or reverseDuration.\n'
          'The "duration" or "reverseDuration" property should be set, either in the constructor or later, before '
482 483 484 485
          'calling the reverse() function.'
        );
      }
      return true;
486
    }());
487 488 489 490 491
    assert(
      _ticker != null,
      'AnimationController.reverse() called after AnimationController.dispose()\n'
      'AnimationController methods should not be used after calling dispose.'
    );
492
    _direction = _AnimationDirection.reverse;
493 494
    if (from != null)
      value = from;
495
    return _animateToInternal(lowerBound);
496 497
  }

498
  /// Drives the animation from its current value to target.
499
  ///
500 501 502 503 504
  /// Returns a [TickerFuture] that completes when the animation is complete.
  ///
  /// The most recently returned [TickerFuture], if any, is marked as having been
  /// canceled, meaning the future never completes and its [TickerFuture.orCancel]
  /// derivative future completes with a [TickerCanceled] error.
505 506 507 508 509
  ///
  /// During the animation, [status] is reported as [AnimationStatus.forward]
  /// regardless of whether `target` > [value] or not. At the end of the
  /// animation, when `target` is reached, [status] is reported as
  /// [AnimationStatus.completed].
510 511 512 513
  ///
  /// If the `target` argument is the same as the current [value] of the
  /// animation, then this won't animate, and the returned [TickerFuture] will
  /// be already complete.
514
  TickerFuture animateTo(double target, { Duration? duration, Curve curve = Curves.linear }) {
515 516 517 518 519 520 521 522 523 524 525
    assert(() {
      if (this.duration == null && duration == null) {
        throw FlutterError(
          'AnimationController.animateTo() called with no explicit duration and no default duration.\n'
          'Either the "duration" argument to the animateTo() method should be provided, or the '
          '"duration" property should be set, either in the constructor or later, before '
          'calling the animateTo() function.'
        );
      }
      return true;
    }());
526 527 528 529 530
    assert(
      _ticker != null,
      'AnimationController.animateTo() called after AnimationController.dispose()\n'
      'AnimationController methods should not be used after calling dispose.'
    );
531 532 533 534
    _direction = _AnimationDirection.forward;
    return _animateToInternal(target, duration: duration, curve: curve);
  }

535 536 537 538 539 540 541 542 543 544 545 546
  /// Drives the animation from its current value to target.
  ///
  /// Returns a [TickerFuture] that completes when the animation is complete.
  ///
  /// The most recently returned [TickerFuture], if any, is marked as having been
  /// canceled, meaning the future never completes and its [TickerFuture.orCancel]
  /// derivative future completes with a [TickerCanceled] error.
  ///
  /// During the animation, [status] is reported as [AnimationStatus.reverse]
  /// regardless of whether `target` < [value] or not. At the end of the
  /// animation, when `target` is reached, [status] is reported as
  /// [AnimationStatus.dismissed].
547
  TickerFuture animateBack(double target, { Duration? duration, Curve curve = Curves.linear }) {
548 549 550 551 552 553 554 555 556 557 558
    assert(() {
      if (this.duration == null && reverseDuration == null && duration == null) {
        throw FlutterError(
          'AnimationController.animateBack() called with no explicit duration and no default duration or reverseDuration.\n'
          'Either the "duration" argument to the animateBack() method should be provided, or the '
          '"duration" or "reverseDuration" property should be set, either in the constructor or later, before '
          'calling the animateBack() function.'
        );
      }
      return true;
    }());
559 560 561 562 563
    assert(
      _ticker != null,
      'AnimationController.animateBack() called after AnimationController.dispose()\n'
      'AnimationController methods should not be used after calling dispose.'
    );
564 565 566 567
    _direction = _AnimationDirection.reverse;
    return _animateToInternal(target, duration: duration, curve: curve);
  }

568
  TickerFuture _animateToInternal(double target, { Duration? duration, Curve curve = Curves.linear }) {
569
    double scale = 1.0;
570
    if (SemanticsBinding.instance!.disableAnimations) {
571
      switch (animationBehavior) {
572
        case AnimationBehavior.normal:
573 574 575
          // Since the framework cannot handle zero duration animations, we run it at 5% of the normal
          // duration to limit most animations to a single frame.
          // TODO(jonahwilliams): determine a better process for setting duration.
576 577 578 579 580 581
          scale = 0.05;
          break;
        case AnimationBehavior.preserve:
          break;
      }
    }
582
    Duration? simulationDuration = duration;
583
    if (simulationDuration == null) {
584 585
      assert(!(this.duration == null && _direction == _AnimationDirection.forward));
      assert(!(this.duration == null && _direction == _AnimationDirection.reverse && reverseDuration == null));
586 587
      final double range = upperBound - lowerBound;
      final double remainingFraction = range.isFinite ? (target - _value).abs() / range : 1.0;
588 589
      final Duration directionDuration =
        (_direction == _AnimationDirection.reverse && reverseDuration != null)
590 591
        ? reverseDuration!
        : this.duration!;
592
      simulationDuration = directionDuration * remainingFraction;
593 594
    } else if (target == value) {
      // Already at target, don't animate.
595
      simulationDuration = Duration.zero;
596
    }
597
    stop();
598
    if (simulationDuration == Duration.zero) {
599
      if (value != target) {
600
        _value = target.clamp(lowerBound, upperBound);
601 602
        notifyListeners();
      }
603 604 605
      _status = (_direction == _AnimationDirection.forward) ?
        AnimationStatus.completed :
        AnimationStatus.dismissed;
606
      _checkStatusChanged();
607
      return TickerFuture.complete();
608
    }
609
    assert(simulationDuration > Duration.zero);
610
    assert(!isAnimating);
611
    return _startSimulation(_InterpolationSimulation(_value, target, simulationDuration, curve, scale));
612 613
  }

614 615
  /// Starts running this animation in the forward direction, and
  /// restarts the animation when it completes.
616
  ///
617 618 619 620
  /// Defaults to repeating between the [lowerBound] and [upperBound] of the
  /// [AnimationController] when no explicit value is set for [min] and [max].
  ///
  /// With [reverse] set to true, instead of always starting over at [min]
621 622 623
  /// the starting value will alternate between [min] and [max] values on each
  /// repeat. The [status] will be reported as [AnimationStatus.reverse] when
  /// the animation runs from [max] to [min].
624
  ///
625 626 627 628
  /// Each run of the animation will have a duration of `period`. If `period` is not
  /// provided, [duration] will be used instead, which has to be set before [repeat] is
  /// called either in the constructor or later by using the [duration] setter.
  ///
629
  /// Returns a [TickerFuture] that never completes. The [TickerFuture.orCancel] future
630 631 632 633 634
  /// completes with an error when the animation is stopped (e.g. with [stop]).
  ///
  /// The most recently returned [TickerFuture], if any, is marked as having been
  /// canceled, meaning the future never completes and its [TickerFuture.orCancel]
  /// derivative future completes with a [TickerCanceled] error.
635
  TickerFuture repeat({ double? min, double? max, bool reverse = false, Duration? period }) {
636 637
    min ??= lowerBound;
    max ??= upperBound;
638
    period ??= duration;
639
    assert(() {
640
      if (period == null) {
641
        throw FlutterError(
642 643
          'AnimationController.repeat() called without an explicit period and with no default Duration.\n'
          'Either the "period" argument to the repeat() method should be provided, or the '
644 645 646 647 648
          '"duration" property should be set, either in the constructor or later, before '
          'calling the repeat() function.'
        );
      }
      return true;
649
    }());
650 651 652
    assert(max >= min);
    assert(max <= upperBound && min >= lowerBound);
    assert(reverse != null);
653
    stop();
654
    return _startSimulation(_RepeatingSimulation(_value, min, max, reverse, period!, _directionSetter));
655 656 657 658 659 660 661 662
  }

  void _directionSetter(_AnimationDirection direction) {
    _direction = direction;
    _status = (_direction == _AnimationDirection.forward) ?
      AnimationStatus.forward :
      AnimationStatus.reverse;
    _checkStatusChanged();
663 664
  }

665 666
  /// Drives the animation with a spring (within [lowerBound] and [upperBound])
  /// and initial velocity.
667 668 669 670
  ///
  /// If velocity is positive, the animation will complete, otherwise it will
  /// dismiss.
  ///
671 672 673 674 675 676 677 678
  /// The [springDescription] parameter can be used to specify a custom [SpringType.criticallyDamped]
  /// or [SpringType.overDamped] spring to drive the animation with. Defaults to null, which uses a
  /// [SpringType.criticallyDamped] spring. See [SpringDescription.withDampingRatio] for how
  /// to create a suitable [SpringDescription].
  ///
  /// The resulting spring simulation cannot be of type [SpringType.underDamped],
  /// as this can lead to unexpected look of the produced animation.
  ///
679
  /// Returns a [TickerFuture] that completes when the animation is complete.
680
  ///
681 682 683
  /// The most recently returned [TickerFuture], if any, is marked as having been
  /// canceled, meaning the future never completes and its [TickerFuture.orCancel]
  /// derivative future completes with a [TickerCanceled] error.
684 685
  TickerFuture fling({ double velocity = 1.0, SpringDescription? springDescription, AnimationBehavior? animationBehavior }) {
    springDescription ??= _kFlingSpringDescription;
Adam Barth's avatar
Adam Barth committed
686
    _direction = velocity < 0.0 ? _AnimationDirection.reverse : _AnimationDirection.forward;
687 688
    final double target = velocity < 0.0 ? lowerBound - _kFlingTolerance.distance
                                         : upperBound + _kFlingTolerance.distance;
689 690
    double scale = 1.0;
    final AnimationBehavior behavior = animationBehavior ?? this.animationBehavior;
691
    if (SemanticsBinding.instance!.disableAnimations) {
692 693
      switch (behavior) {
        case AnimationBehavior.normal:
694 695
          // TODO(jonahwilliams): determine a better process for setting velocity.
          // the value below was arbitrarily chosen because it worked for the drawer widget.
696 697 698 699 700 701
          scale = 200.0;
          break;
        case AnimationBehavior.preserve:
          break;
      }
    }
702
    final SpringSimulation simulation = SpringSimulation(springDescription, value, target, velocity * scale)
703
      ..tolerance = _kFlingTolerance;
704 705 706 707 708
    assert(
      simulation.type != SpringType.underDamped,
      'The resulting spring simulation is of type SpringType.underDamped.\n'
      'This can lead to unexpected look of the animation, please adjust the springDescription parameter'
    );
709 710
    stop();
    return _startSimulation(simulation);
711 712 713
  }

  /// Drives the animation according to the given simulation.
714
  ///
715 716 717 718
  /// The values from the simulation are clamped to the [lowerBound] and
  /// [upperBound]. To avoid this, consider creating the [AnimationController]
  /// using the [new AnimationController.unbounded] constructor.
  ///
719 720 721 722 723
  /// Returns a [TickerFuture] that completes when the animation is complete.
  ///
  /// The most recently returned [TickerFuture], if any, is marked as having been
  /// canceled, meaning the future never completes and its [TickerFuture.orCancel]
  /// derivative future completes with a [TickerCanceled] error.
724 725 726
  ///
  /// The [status] is always [AnimationStatus.forward] for the entire duration
  /// of the simulation.
727
  TickerFuture animateWith(Simulation simulation) {
728 729 730 731 732
    assert(
      _ticker != null,
      'AnimationController.animateWith() called after AnimationController.dispose()\n'
      'AnimationController methods should not be used after calling dispose.'
    );
733
    stop();
734
    _direction = _AnimationDirection.forward;
735 736 737
    return _startSimulation(simulation);
  }

738
  TickerFuture _startSimulation(Simulation simulation) {
739 740 741
    assert(simulation != null);
    assert(!isAnimating);
    _simulation = simulation;
742
    _lastElapsedDuration = Duration.zero;
743
    _value = simulation.x(0.0).clamp(lowerBound, upperBound);
744
    final TickerFuture result = _ticker!.start();
745 746 747
    _status = (_direction == _AnimationDirection.forward) ?
      AnimationStatus.forward :
      AnimationStatus.reverse;
748 749
    _checkStatusChanged();
    return result;
750 751
  }

752
  /// Stops running this animation.
753 754 755
  ///
  /// This does not trigger any notifications. The animation stops in its
  /// current state.
756 757 758 759
  ///
  /// By default, the most recently returned [TickerFuture] is marked as having
  /// been canceled, meaning the future never completes and its
  /// [TickerFuture.orCancel] derivative future completes with a [TickerCanceled]
760
  /// error. By passing the `canceled` argument with the value false, this is
761
  /// reversed, and the futures complete successfully.
762 763 764 765 766 767 768
  ///
  /// See also:
  ///
  ///  * [reset], which stops the animation and resets it to the [lowerBound],
  ///    and which does send notifications.
  ///  * [forward], [reverse], [animateTo], [animateWith], [fling], and [repeat],
  ///    which restart the animation controller.
769
  void stop({ bool canceled = true }) {
770 771 772 773 774
    assert(
      _ticker != null,
      'AnimationController.stop() called after AnimationController.dispose()\n'
      'AnimationController methods should not be used after calling dispose.'
    );
775
    _simulation = null;
776
    _lastElapsedDuration = null;
777
    _ticker!.stop(canceled: canceled);
778 779
  }

780 781
  /// Release the resources used by this object. The object is no longer usable
  /// after this method is called.
782 783 784 785
  ///
  /// The most recently returned [TickerFuture], if any, is marked as having been
  /// canceled, meaning the future never completes and its [TickerFuture.orCancel]
  /// derivative future completes with a [TickerCanceled] error.
786
  @override
787
  void dispose() {
788 789
    assert(() {
      if (_ticker == null) {
790 791 792 793 794 795 796 797 798
        throw FlutterError.fromParts(<DiagnosticsNode>[
          ErrorSummary('AnimationController.dispose() called more than once.'),
          ErrorDescription('A given $runtimeType cannot be disposed more than once.\n'),
          DiagnosticsProperty<AnimationController>(
            'The following $runtimeType object was disposed multiple times',
            this,
            style: DiagnosticsTreeStyle.errorProperty,
          ),
        ]);
799 800
      }
      return true;
801
    }());
802
    _ticker!.dispose();
803
    _ticker = null;
804
    super.dispose();
805 806
  }

807
  AnimationStatus _lastReportedStatus = AnimationStatus.dismissed;
808
  void _checkStatusChanged() {
809
    final AnimationStatus newStatus = status;
810 811
    if (_lastReportedStatus != newStatus) {
      _lastReportedStatus = newStatus;
812
      notifyStatusListeners(newStatus);
813
    }
814 815
  }

816
  void _tick(Duration elapsed) {
817
    _lastElapsedDuration = elapsed;
818
    final double elapsedInSeconds = elapsed.inMicroseconds.toDouble() / Duration.microsecondsPerSecond;
819
    assert(elapsedInSeconds >= 0.0);
820
    _value = _simulation!.x(elapsedInSeconds).clamp(lowerBound, upperBound);
821
    if (_simulation!.isDone(elapsedInSeconds)) {
822 823 824
      _status = (_direction == _AnimationDirection.forward) ?
        AnimationStatus.completed :
        AnimationStatus.dismissed;
825
      stop(canceled: false);
826
    }
827 828 829 830
    notifyListeners();
    _checkStatusChanged();
  }

831
  @override
832
  String toStringDetails() {
833
    final String paused = isAnimating ? '' : '; paused';
834
    final String ticker = _ticker == null ? '; DISPOSED' : (_ticker!.muted ? '; silenced' : '');
835 836
    final String label = debugLabel == null ? '' : '; for $debugLabel';
    final String more = '${super.toStringDetails()} ${value.toStringAsFixed(3)}';
837
    return '$more$paused$ticker$label';
838 839 840
  }
}

841
class _InterpolationSimulation extends Simulation {
842
  _InterpolationSimulation(this._begin, this._end, Duration duration, this._curve, double scale)
843 844 845
    : assert(_begin != null),
      assert(_end != null),
      assert(duration != null && duration.inMicroseconds > 0),
846
      _durationInSeconds = (duration.inMicroseconds * scale) / Duration.microsecondsPerSecond;
847 848 849 850 851 852

  final double _durationInSeconds;
  final double _begin;
  final double _end;
  final Curve _curve;

853
  @override
854
  double x(double timeInSeconds) {
855
    final double t = (timeInSeconds / _durationInSeconds).clamp(0.0, 1.0);
856 857 858 859 860 861 862 863
    if (t == 0.0)
      return _begin;
    else if (t == 1.0)
      return _end;
    else
      return _begin + (_end - _begin) * _curve.transform(t);
  }

864
  @override
865
  double dx(double timeInSeconds) {
866
    final double epsilon = tolerance.time;
867 868
    return (x(timeInSeconds + epsilon) - x(timeInSeconds - epsilon)) / (2 * epsilon);
  }
869

870
  @override
871 872 873
  bool isDone(double timeInSeconds) => timeInSeconds > _durationInSeconds;
}

874 875
typedef _DirectionSetter = void Function(_AnimationDirection direction);

876
class _RepeatingSimulation extends Simulation {
877
  _RepeatingSimulation(double initialValue, this.min, this.max, this.reverse, Duration period, this.directionSetter)
878 879
      : _periodInSeconds = period.inMicroseconds / Duration.microsecondsPerSecond,
        _initialT = (max == min) ? 0.0 : (initialValue / (max - min)) * (period.inMicroseconds / Duration.microsecondsPerSecond) {
880
    assert(_periodInSeconds > 0.0);
881
    assert(_initialT >= 0.0);
882 883 884 885
  }

  final double min;
  final double max;
886
  final bool reverse;
887
  final _DirectionSetter directionSetter;
888 889

  final double _periodInSeconds;
890
  final double _initialT;
891

892
  @override
893 894
  double x(double timeInSeconds) {
    assert(timeInSeconds >= 0.0);
895 896 897

    final double totalTimeInSeconds = timeInSeconds + _initialT;
    final double t = (totalTimeInSeconds / _periodInSeconds) % 1.0;
898
    final bool _isPlayingReverse = (totalTimeInSeconds ~/ _periodInSeconds).isOdd;
899 900

    if (reverse && _isPlayingReverse) {
901
      directionSetter(_AnimationDirection.reverse);
902
      return ui.lerpDouble(max, min, t)!;
903
    } else {
904
      directionSetter(_AnimationDirection.forward);
905
      return ui.lerpDouble(min, max, t)!;
906
    }
907 908
  }

909
  @override
910
  double dx(double timeInSeconds) => (max - min) / _periodInSeconds;
911

912
  @override
913 914
  bool isDone(double timeInSeconds) => false;
}