为了表述方便，本书约定，将在Widget属性发生变化时会执行过渡动画的组件统称为动画过渡组件，而动画过渡组件最明显的一个特征就是它会在内部自管理AnimationController

  • 我们知道，为了方便使用者可以自定义
    • 动画的曲线
    • 执行时长
    • 方向等，
  • 在前面介绍过的动画封装方法中，通常都需要使用者自己提供一个AnimationController对象来自定义这些属性值。
  • 但是，如此一来，使用者就必须得手动管理AnimationController，这又会增加使用的复杂性
  • 因此，如果也能将AnimationController进行封装，则会大大提高动画组件的易用性。

自定义动画过渡组件

我们要实现一个AnimatedDecoratedBox，它可以在decoration属性发生变化时，从旧状态变成新状态的过程可以执行一个过渡动画。根据前面所学的知识，我们实现了一个AnimatedDecoratedBox组件：

  1. import 'package:flutter/material.dart';
  3. void main() => runApp(new MyApp());
  5. class MyApp extends StatelessWidget {
  6.   @override
  7.   Widget build(BuildContext context) {
  8.     return MaterialApp(
  9.         debugShowCheckedModeBanner: true,
  10.         title: 'AnimatedSwitcher',
  11.         theme: ThemeData(
  12.           primarySwatch: Colors.blue,
  13.         ),
  14.         home: Scaffold(
  15.           appBar: AppBar(title: Text("AnimatedSwitcher")),
  16.           body: AnimatedSwitcherCounterRoute(),
  17.         ));
  18.   }
  19. }
  21. class AnimatedSwitcherCounterRoute extends StatefulWidget {
  22.   const AnimatedSwitcherCounterRoute({Key key}) : super(key: key);
  23.   @override
  24.   _AnimatedSwitcherCounterRouteState createState() =>
  25.       _AnimatedSwitcherCounterRouteState();
  26. }
  28. class _AnimatedSwitcherCounterRouteState
  29.     extends State<AnimatedSwitcherCounterRoute> {
  30.   Color _decorationColor = Colors.blue;
  31.   var duration = Duration(seconds: 5);
  33.   @override
  34.   Widget build(BuildContext context) {
  35.     return Center(
  36.       child: Column(
  37.         mainAxisAlignment: MainAxisAlignment.center,
  38.         children: <Widget>[
  39.           AnimatedDecoratedBox(
  40.             duration: duration,
  41.             decoration: BoxDecoration(color: _decorationColor),
  42.             child: FlatButton(
  43.               onPressed: () {
  44.                 setState(() {
  45.                   _decorationColor = Colors.red;
  46.                 });
  47.               },
  48.               child: Text(
  49.                 "AnimatedDecoratedBox",
  50.                 style: TextStyle(color: Colors.white),
  51.               ),
  52.             ),
  53.           )
  54.         ],
  55.       ),
  56.     );
  57.   }
  58. }
  60. class AnimatedDecoratedBox extends StatefulWidget {
  61.   AnimatedDecoratedBox({
  62.     Key key,
  63.     @required this.decoration,
  64.     @required this.duration,
  65.     @required this.child,
  66.     this.curve = Curves.linear,
  67.     this.reverseDuration,
  68.   });
  70.   final BoxDecoration decoration;
  71.   final Widget child;
  72.   final Duration duration;
  73.   final Curve curve;
  74.   final Duration reverseDuration;
  76.   @override
  77.   _AnimatedDecoratedBox1State createState() => _AnimatedDecoratedBox1State();
  78. }
  82. class _AnimatedDecoratedBox1State extends State<AnimatedDecoratedBox>
  83.     with SingleTickerProviderStateMixin {
  84.   @protected
  85.   AnimationController get controller => _controller;
  86.   AnimationController _controller;
  87.   Animation<double> get animation => _animation;
  88.   Animation<double> _animation;
  89.   DecorationTween _tween;
  91.   @override
  92.   void initState() {
  93.     super.initState();
  94.     _controller = AnimationController(
  95.       duration: widget.duration,
  96.       reverseDuration: widget.reverseDuration,
  97.       vsync: this,
  98.     );
  99.     _tween = DecorationTween(begin: widget.decoration);
  100.     _updateCurve();
  101.   }
  103.   void _updateCurve() {
  104.     if (widget.curve != null)
  105.       _animation = CurvedAnimation(parent: _controller, curve: widget.curve);
  106.     else
  107.       _animation = _controller;
  108.   }
  111.   @override
  112.   void didUpdateWidget(AnimatedDecoratedBox oldWidget) {
  113.     super.didUpdateWidget(oldWidget);
  114.     if (widget.curve != oldWidget.curve) _updateCurve();
  115.     _controller.duration = widget.duration;
  116.     _controller.reverseDuration = widget.reverseDuration;
  117.     if (widget.decoration != (_tween.end ?? _tween.begin)) {
  118.       _tween
  119.         ..begin = _tween.evaluate(_animation)
  120.         ..end = widget.decoration;
  121.       _controller
  122.         ..value = 0.0
  123.         ..forward();
  124.     }
  125.   }
  127.   @override
  128.   void dispose() {
  129.     _controller.dispose();
  130.     super.dispose();
  131.   }
  133.   @override
  134.   Widget build(BuildContext context) {
  135.     return AnimatedBuilder(
  136.       animation: _animation,
  137.       builder: (context, child) {
  138.         return DecoratedBox(
  139.           decoration: _tween.evaluate(_animation),
  140.           child: child,
  141.         );
  142.       },
  143.       child: widget.child,
  144.     );
  145.   }
  146. }

点击前效果如图所示，点击后截取了过渡过程的一帧如图所示： 动画过渡组件 - 图1动画过渡组件 - 图2

点击后，按钮背景色会从蓝色向红色过渡，图是过渡过程中的一帧，有点偏紫色，整个过渡动画结束后背景会变为红色

if判断语句可以简写

  1. if (widget.curve != null)
  2.   _animation = CurvedAnimation(parent: _controller, curve: widget.curve);
  3. else
  4.   _animation = _controller;

ImplicitlyAnimatedWidget

上面的代码虽然实现了我们期望的功能，但是代码却比较复杂。稍加思考后，我们就可以发现，AnimationController的管理以及Tween更新部分的代码都是可以抽象出来的，如果我们这些通用逻辑封装成基类，那么要实现动画过渡组件只需要继承这些基类，然后定制自身不同的代码（比如动画每一帧的构建方法）即可，这样将会简化代码。
为了方便开发者来实现动画过渡组件的封装，Flutter提供了一个ImplicitlyAnimatedWidget抽象类，它继承自StatefulWidget，同时提供了一个对应的ImplicitlyAnimatedWidgetState类，AnimationController的管理就在ImplicitlyAnimatedWidgetState类中。
开发者如果要封装动画，只需要分别继承ImplicitlyAnimatedWidget和ImplicitlyAnimatedWidgetState类即可，下面我们演示一下具体如何实现。

我们需要分两步实现：

  1. 继承ImplicitlyAnimatedWidget类。

    1. class AnimatedDecoratedBox extends ImplicitlyAnimatedWidget {
    2. AnimatedDecoratedBox({
    3.  Key key,
    4.  @required this.decoration,
    5.  this.child,
    6.  Curve curve = Curves.linear, //动画曲线
    7.  @required Duration duration, // 正向动画执行时长
    8.  Duration reverseDuration, // 反向动画执行时长
    9. }) : super(
    10.        key: key,
    11.        curve: curve,
    12.        duration: duration,
    13.        reverseDuration: reverseDuration,
    14.      );
    15. final BoxDecoration decoration;
    16. final Widget child;
    17. @override
    18. _AnimatedDecoratedBoxState createState() {
    19.  return _AnimatedDecoratedBoxState();
    20. }
    21. }

    其中curve、duration、reverseDuration三个属性在ImplicitlyAnimatedWidget中已定义。 可以看到AnimatedDecoratedBox类和普通继承自StatefulWidget的类没有什么不同

  2. State类继承自AnimatedWidgetBaseState（该类继承自ImplicitlyAnimatedWidgetState类）。

    1. class _AnimatedDecoratedBoxState
    2.  extends AnimatedWidgetBaseState<AnimatedDecoratedBox> {
    3. DecorationTween _decoration; //定义一个Tween
    4. @override
    5. Widget build(BuildContext context) {
    6.  return DecoratedBox(
    7.    decoration: _decoration.evaluate(animation),
    8.    child: widget.child,
    9.  );
    10. }
    11. @override
    12. void forEachTween(visitor) {
    13.  // 在需要更新Tween时，基类会调用此方法
    14.  _decoration = visitor(_decoration, widget.decoration,
    15.      (value) => DecorationTween(begin: value));
    16. }
    17. }

    可以看到我们实现了build和forEachTween两个方法
    在动画执行过程中，每一帧都会调用build方法（调用逻辑在ImplicitlyAnimatedWidgetState中）
    所以在build方法中我们需要构建每一帧的DecoratedBox状态，因此得算出每一帧的decoration状态，这个我们可以通过_decoration.evaluate(animation)来算出，

  • 其中animation是ImplicitlyAnimatedWidgetState基类中定义的对象
  • _decoration是我们自定义的一个DecorationTween类型的对象

那么现在的问题就是它是在什么时候被赋值的呢？要回答这个问题，我们就得搞清楚什么时候需要对_decoration赋值。我们知道_decoration是一个Tween，而Tween的主要职责就是定义动画的起始状态（begin）和终止状态(end)。对于AnimatedDecoratedBox来说，decoration的终止状态就是用户传给它的值，而起始状态是不确定的，有以下两种情况：

  1. AnimatedDecoratedBox首次build，此时直接将其decoration值置为起始状态，即_decoration值为DecorationTween(begin: decoration) 。
  2. AnimatedDecoratedBox的decoration更新时，则起始状态为_decoration.animate(animation)，即_decoration值为DecorationTween(begin: _decoration.animate(animation)，end:decoration)。

现在forEachTween的作用就很明显了，它正是用于来更新Tween的初始值的，在上述两种情况下会被调用，而开发者只需重写此方法，并在此方法中更新Tween的起始状态值即可。而一些更新的逻辑被屏蔽在了visitor回调，我们只需要调用它并给它传递正确的参数即可，visitor方法签名如下：

  1. Tween visitor(
  2.      Tween<dynamic> tween, //当前的tween，第一次调用为null
  3.      dynamic targetValue, // 终止状态
  4.      TweenConstructor<dynamic> constructor，//Tween构造器，在上述三种情况下会被调用以更新tween
  5.    );

可以看到，通过继承ImplicitlyAnimatedWidget和ImplicitlyAnimatedWidgetState类可以快速的实现动画过渡组件的封装，这和我们纯手工实现相比，代码简化了很多。

如果读者还有疑惑，建议查看ImplicitlyAnimatedWidgetState的源码并结合本示例代码对比理解。

完整代码

  1. import 'package:flutter/material.dart';
  3. void main() => runApp(new MyApp());
  5. class MyApp extends StatelessWidget {
  6.   @override
  7.   Widget build(BuildContext context) {
  8.     return MaterialApp(
  9.         debugShowCheckedModeBanner: true,
  10.         title: 'AnimatedSwitcher',
  11.         theme: ThemeData(
  12.           primarySwatch: Colors.blue,
  13.         ),
  14.         home: Scaffold(
  15.           appBar: AppBar(title: Text("AnimatedSwitcher")),
  16.           body: AnimatedSwitcherCounterRoute(),
  17.         ));
  18.   }
  19. }
  21. class AnimatedSwitcherCounterRoute extends StatefulWidget {
  22.   const AnimatedSwitcherCounterRoute({Key key}) : super(key: key);
  23.   @override
  24.   _AnimatedSwitcherCounterRouteState createState() =>
  25.       _AnimatedSwitcherCounterRouteState();
  26. }
  28. class _AnimatedSwitcherCounterRouteState
  29.     extends State<AnimatedSwitcherCounterRoute> {
  30.   Color _decorationColor = Colors.blue;
  31.   var duration = Duration(seconds: 5);
  33.   @override
  34.   Widget build(BuildContext context) {
  35.     return Center(
  36.       child: Column(
  37.         mainAxisAlignment: MainAxisAlignment.center,
  38.         children: <Widget>[
  39.           AnimatedDecoratedBox(
  40.             duration: duration,
  41.             decoration: BoxDecoration(color: _decorationColor),
  42.             child: FlatButton(
  43.               onPressed: () {
  44.                 setState(() {
  45.                   _decorationColor = Colors.red;
  46.                 });
  47.               },
  48.               child: Text(
  49.                 "AnimatedDecoratedBox",
  50.                 style: TextStyle(color: Colors.white),
  51.               ),
  52.             ),
  53.           )
  54.         ],
  55.       ),
  56.     );
  57.   }
  58. }
  60. class AnimatedDecoratedBox extends ImplicitlyAnimatedWidget {
  61.   AnimatedDecoratedBox({
  62.     Key key,
  63.     @required this.decoration,
  64.     this.child,
  65.     Curve curve = Curves.linear, //动画曲线
  66.     @required Duration duration, // 正向动画执行时长
  67.     Duration reverseDuration, // 反向动画执行时长
  68.   }) : super(
  69.           key: key,
  70.           curve: curve,
  71.           duration: duration,
  72.           // reverseDuration: reverseDuration,
  73.         );
  74.   final BoxDecoration decoration;
  75.   final Widget child;
  76.   @override
  77.   _AnimatedDecoratedBoxState createState() {
  78.     return _AnimatedDecoratedBoxState();
  79.   }
  80. }
  82. class _AnimatedDecoratedBoxState
  83.     extends AnimatedWidgetBaseState<AnimatedDecoratedBox> {
  84.   DecorationTween _decoration; //定义一个Tween
  85.   @override
  86.   Widget build(BuildContext context) {
  87.     return DecoratedBox(
  88.       decoration: _decoration.evaluate(animation),
  89.       child: widget.child,
  90.     );
  91.   }
  93.   @override
  94.   void forEachTween(visitor) {
  95.     // 在需要更新Tween时，基类会调用此方法
  96.     _decoration = visitor(_decoration, widget.decoration,
  97.         (value) => DecorationTween(begin: value));
  98.   }
  99. }

动画过渡组件的反向动画

在使用动画过渡组件，我们只需要在改变一些属性值后重新build组件即可，所以要实现状态反向过渡，只需要将前后状态值互换即可实现，这本来是不需要再浪费笔墨的。
但是ImplicitlyAnimatedWidget构造函数中却有一个reverseDuration属性用于设置反向动画的执行时长，这貌似在告诉读者ImplicitlyAnimatedWidget本身也提供了执行反向动画的接口
于是笔者查看了ImplicitlyAnimatedWidgetState源码并未发现有执行反向动画的接口，唯一有用的是它暴露了控制动画的controller。
所以如果要让reverseDuration生效，我们只能先获取controller，然后再通过controller.reverse()来启动反向动画，比如我们在上面示例的基础上实现一个循环的点击背景颜色变换效果，要求从蓝色变为红色时动画执行时间为400ms，从红变蓝为2s，如果要使reverseDuration生效，我们需要这么做：

  1. import 'package:flutter/material.dart';
  3. void main() => runApp(new MyApp());
  5. class MyApp extends StatelessWidget {
  6.   @override
  7.   Widget build(BuildContext context) {
  8.     return MaterialApp(
  9.         debugShowCheckedModeBanner: true,
  10.         title: 'AnimatedSwitcher',
  11.         theme: ThemeData(
  12.           primarySwatch: Colors.blue,
  13.         ),
  14.         home: Scaffold(
  15.           appBar: AppBar(title: Text("AnimatedSwitcher")),
  16.           body: AnimatedSwitcherCounterRoute(),
  17.         ));
  18.   }
  19. }
  21. class AnimatedSwitcherCounterRoute extends StatefulWidget {
  22.   const AnimatedSwitcherCounterRoute({Key key}) : super(key: key);
  23.   @override
  24.   _AnimatedSwitcherCounterRouteState createState() =>
  25.       _AnimatedSwitcherCounterRouteState();
  26. }
  28. class _AnimatedSwitcherCounterRouteState
  29.     extends State<AnimatedSwitcherCounterRoute> {
  30.   Color _decorationColor = Colors.blue;
  31.   var duration = Duration(seconds: 5);
  33.   @override
  34.   Widget build(BuildContext context) {
  35.     return Center(
  36.       child: Column(
  37.         mainAxisAlignment: MainAxisAlignment.center,
  38.         children: <Widget>[
  39.           AnimatedDecoratedBox(
  40.             duration: Duration(milliseconds: 400),
  41.             decoration: BoxDecoration(color: _decorationColor),
  42.             reverseDuration: Duration(seconds: 2),
  43.             child: Builder(builder: (context) {
  44.               return FlatButton(
  45.                 onPressed: () {
  46.                   if (_decorationColor == Colors.red) {
  47.                     ImplicitlyAnimatedWidgetState _state =
  48.                         context.ancestorStateOfType(
  49.                             TypeMatcher<ImplicitlyAnimatedWidgetState>());
  50.                     // 通过controller来启动反向动画
  51.                     _state.controller.reverse().then((e) {
  52.                       // 经验证必须调用setState来触发rebuild，否则状态同步会有问题
  53.                       setState(() {
  54.                         _decorationColor = Colors.blue;
  55.                       });
  56.                     });
  57.                   } else {
  58.                     setState(() {
  59.                       _decorationColor = Colors.red;
  60.                     });
  61.                   }
  62.                 },
  63.                 child: Text(
  64.                   "AnimatedDecoratedBox toggle",
  65.                   style: TextStyle(color: Colors.white),
  66.                 ),
  67.               );
  68.             }),
  69.           )
  70.         ],
  71.       ),
  72.     );
  73.   }
  74. }
  76. class AnimatedDecoratedBox extends ImplicitlyAnimatedWidget {
  77.   AnimatedDecoratedBox({
  78.     Key key,
  79.     @required this.decoration,
  80.     this.child,
  81.     Curve curve = Curves.linear, //动画曲线
  82.     @required Duration duration, // 正向动画执行时长
  83.     Duration reverseDuration, // 反向动画执行时长
  84.   }) : super(
  85.           key: key,
  86.           curve: curve,
  87.           duration: duration,
  88.           // reverseDuration: reverseDuration,
  89.         );
  90.   final BoxDecoration decoration;
  91.   final Widget child;
  92.   @override
  93.   _AnimatedDecoratedBoxState createState() {
  94.     return _AnimatedDecoratedBoxState();
  95.   }
  96. }
  98. class _AnimatedDecoratedBoxState
  99.     extends AnimatedWidgetBaseState<AnimatedDecoratedBox> {
  100.   DecorationTween _decoration; //定义一个Tween
  101.   @override
  102.   Widget build(BuildContext context) {
  103.     return DecoratedBox(
  104.       decoration: _decoration.evaluate(animation),
  105.       child: widget.child,
  106.     );
  107.   }
  109.   @override
  110.   void forEachTween(visitor) {
  111.     // 在需要更新Tween时，基类会调用此方法
  112.     _decoration = visitor(_decoration, widget.decoration,
  113.         (value) => DecorationTween(begin: value));
  114.   }
  115. }

上面的代码实际上是非常糟糕且没必要的，它需要我们了解ImplicitlyAnimatedWidgetState内部实现，并且要手动去启动反向动画。我们完全可以通过如下代码实现相同的效果：

  1. AnimatedDecoratedBox(
  2.   duration: Duration(
  3.       milliseconds: _decorationColor == Colors.red ? 400 : 2000),
  4.   decoration: BoxDecoration(color: _decorationColor),
  5.   child: Builder(builder: (context) {
  6.     return FlatButton(
  7.       onPressed: () {
  8.         setState(() {
  9.           _decorationColor = _decorationColor == Colors.blue
  10.               ? Colors.red
  11.               : Colors.blue;
  12.         });
  13.       },
  14.       child: Text(
  15.         "AnimatedDecoratedBox toggle",
  16.         style: TextStyle(color: Colors.white),
  17.       ),
  18.     );
  19.   }),
  20. )

这样的代码是不是优雅的多！那么现在问题来了，为什么ImplicitlyAnimatedWidgetState要提供一个reverseDuration参数呢？笔者仔细研究了ImplicitlyAnimatedWidgetState的实现，发现唯一的解释就是该参数并非是给ImplicitlyAnimatedWidgetState用的，而是给子类用的！原因正如我们前面说的，要使reverseDuration 有用就必须得获取controller 属性来手动启动反向动画，ImplicitlyAnimatedWidgetState中的controller 属性是一个保护属性，定义如下：

  1. @protected
  2.   AnimationController get controller => _controller;

而保护属性原则上只应该在子类中使用，而不应该像上面示例代码一样在外部使用。综上，我们可以得出两条结论：

  1. 使用动画过渡组件时如果需要执行反向动画的场景，应尽量使用状态互换的方法，而不应该通过获取ImplicitlyAnimatedWidgetState中controller的方式。
  2. 如果我们自定义的动画过渡组件用不到reverseDuration ，那么最好就不要暴露此参数，比如我们上面自定义的AnimatedDecoratedBox定义中就可以去除reverseDuration 可选参数，如：
    1. class AnimatedDecoratedBox extends ImplicitlyAnimatedWidget {
    2. AnimatedDecoratedBox({
    3.  Key key,
    4.  @required this.decoration,
    5.  this.child,
    6.  Curve curve = Curves.linear,
    7.  @required Duration duration,
    8. }) : super(
    9.        key: key,
    10.        curve: curve,
    11.        duration: duration,
    12.      );
    13.      }

    Flutter预置的动画过渡组件

    Flutter SDK中也预置了很多动画过渡组件，实现方式和大都和AnimatedDecoratedBox差不多，如表9-1所示：
组件名 功能
AnimatedPadding 在padding发生变化时会执行过渡动画到新状态
AnimatedPositioned 配合Stack一起使用，当定位状态发生变化时会执行过渡动画到新的状态。
AnimatedOpacity 在透明度opacity发生变化时执行过渡动画到新状态
AnimatedAlign 当alignment发生变化时会执行过渡动画到新的状态。
AnimatedContainer 当Container属性发生变化时会执行过渡动画到新的状态。
AnimatedDefaultTextStyle 当字体样式发生变化时，子组件中继承了该样式的文本组件会动态过渡到新样式。

表9-1：Flutter预置的动画过渡组件下面我们通过一个示例来感受一下这些预置的动画过渡组件效果：

  1. import 'package:flutter/material.dart';
  3. void main() => runApp(new MyApp());
  5. class MyApp extends StatelessWidget {
  6.   @override
  7.   Widget build(BuildContext context) {
  8.     return MaterialApp(
  9.         debugShowCheckedModeBanner: true,
  10.         title: 'AnimatedSwitcher',
  11.         theme: ThemeData(
  12.           primarySwatch: Colors.blue,
  13.         ),
  14.         home: Scaffold(
  15.           appBar: AppBar(title: Text("AnimatedSwitcher")),
  16.           body: AnimatedWidgetsTest(),
  17.         ));
  18.   }
  19. }
  21. class AnimatedWidgetsTest extends StatefulWidget {
  22.   @override
  23.   _AnimatedWidgetsTestState createState() => _AnimatedWidgetsTestState();
  24. }
  26. class _AnimatedWidgetsTestState extends State<AnimatedWidgetsTest> {
  27.   double _padding = 10;
  28.   var _align = Alignment.topRight;
  29.   double _height = 100;
  30.   double _left = 0;
  31.   Color _color = Colors.red;
  32.   TextStyle _style = TextStyle(color: Colors.black);
  33.   Color _decorationColor = Colors.blue;
  35.   @override
  36.   Widget build(BuildContext context) {
  37.     var duration = Duration(seconds: 5);
  38.     return SingleChildScrollView(
  39.       child: Column(
  40.         children: <Widget>[
  41.           RaisedButton(
  42.             onPressed: () {
  43.               setState(() {
  44.                 _padding = 20;
  45.               });
  46.             },
  47.             child: AnimatedPadding(
  48.               duration: duration,
  49.               padding: EdgeInsets.all(_padding),
  50.               child: Text("AnimatedPadding"),
  51.             ),
  52.           ),
  53.           SizedBox(
  54.             height: 50,
  55.             child: Stack(
  56.               children: <Widget>[
  57.                 AnimatedPositioned(
  58.                   duration: duration,
  59.                   left: _left,
  60.                   child: RaisedButton(
  61.                     onPressed: () {
  62.                       setState(() {
  63.                         _left = 100;
  64.                       });
  65.                     },
  66.                     child: Text("AnimatedPositioned"),
  67.                   ),
  68.                 )
  69.               ],
  70.             ),
  71.           ),
  72.           Container(
  73.             height: 100,
  74.             color: Colors.grey,
  75.             child: AnimatedAlign(
  76.               duration: duration,
  77.               alignment: _align,
  78.               child: RaisedButton(
  79.                 onPressed: () {
  80.                   setState(() {
  81.                     _align = Alignment.center;
  82.                   });
  83.                 },
  84.                 child: Text("AnimatedAlign"),
  85.               ),
  86.             ),
  87.           ),
  88.           AnimatedContainer(
  89.             duration: duration,
  90.             height: _height,
  91.             color: _color,
  92.             child: FlatButton(
  93.               onPressed: () {
  94.                 setState(() {
  95.                   _height = 150;
  96.                   _color = Colors.blue;
  97.                 });
  98.               },
  99.               child: Text(
  100.                 "AnimatedContainer",
  101.                 style: TextStyle(color: Colors.white),
  102.               ),
  103.             ),
  104.           ),
  105.           AnimatedDefaultTextStyle(
  106.             child: GestureDetector(
  107.               child: Text("hello world"),
  108.               onTap: () {
  109.                 setState(() {
  110.                   _style = TextStyle(
  111.                     color: Colors.blue,
  112.                     decorationStyle: TextDecorationStyle.solid,
  113.                     decorationColor: Colors.blue,
  114.                   );
  115.                 });
  116.               },
  117.             ),
  118.             style: _style,
  119.             duration: duration,
  120.           ),
  121.           AnimatedDecoratedBox(
  122.             duration: duration,
  123.             decoration: BoxDecoration(color: _decorationColor),
  124.             child: FlatButton(
  125.               onPressed: () {
  126.                 setState(() {
  127.                   _decorationColor = Colors.red;
  128.                 });
  129.               },
  130.               child: Text(
  131.                 "AnimatedDecoratedBox",
  132.                 style: TextStyle(color: Colors.white),
  133.               ),
  134.             ),
  135.           )
  136.         ].map((e) {
  137.           return Padding(
  138.             padding: EdgeInsets.symmetric(vertical: 16),
  139.             child: e,
  140.           );
  141.         }).toList(),
  142.       ),
  143.     );
  144.   }
  145. }
  147. class AnimatedDecoratedBox extends ImplicitlyAnimatedWidget {
  148.   AnimatedDecoratedBox({
  149.     Key key,
  150.     @required this.decoration,
  151.     this.child,
  152.     Curve curve = Curves.linear, //动画曲线
  153.     @required Duration duration, // 正向动画执行时长
  154.     Duration reverseDuration, // 反向动画执行时长
  155.   }) : super(
  156.           key: key,
  157.           curve: curve,
  158.           duration: duration,
  159.         );
  160.   final BoxDecoration decoration;
  161.   final Widget child;
  162.   @override
  163.   _AnimatedDecoratedBoxState createState() {
  164.     return _AnimatedDecoratedBoxState();
  165.   }
  166. }
  169. class _AnimatedDecoratedBoxState
  170.     extends AnimatedWidgetBaseState<AnimatedDecoratedBox> {
  171.   DecorationTween _decoration; //定义一个Tween
  172.   @override
  173.   Widget build(BuildContext context) {
  174.     return DecoratedBox(
  175.       decoration: _decoration.evaluate(animation),
  176.       child: widget.child,
  177.     );
  178.   }
  179.   @override
  180.   void forEachTween(visitor) {
  181.     // 在需要更新Tween时，基类会调用此方法
  182.     _decoration = visitor(_decoration, widget.decoration,
  183.         (value) => DecorationTween(begin: value));
  184.   }
  185. }

运行后效果如图所示：
动画过渡组件 - 图3
读者可以点击一下相应组件来查看一下实际的运行效果。

知识小技巧：遍历增加padding

  1. [].map((e) {
  2.           return Padding(
  3.             padding: EdgeInsets.symmetric(vertical: 16),
  4.             child: e,
  5.           );
  6.         }).toList()