本节先介绍一些Flutter中用于处理手势的

  • GestureDetector
  • GestureRecognizer

然后再仔细讨论一下手势竞争与冲突问题。

GestureDetector

GestureDetector 是一个用于手势识别的功能性组件（手势检测器），我们通过它可以来识别各种手势。实际上是指针事件的语义化封装，接下来我们详细介绍一下各种手势识别。
参数属性

  1. (new) GestureDetector GestureDetector({Key key,
  2.  Widget child,
  3.  void Function(TapDownDetails) onTapDown,
  4.  void Function(TapUpDetails) onTapUp,
  5.  void Function() onTap,
  6.  void Function() onTapCancel,
  7.  void Function(TapDownDetails) onSecondaryTapDown,
  8.  void Function(TapUpDetails) onSecondaryTapUp,
  9.  void Function() onSecondaryTapCancel,
  10.  void Function() onDoubleTap,
  11.  void Function() onLongPress,
  12.  void Function(LongPressStartDetails) onLongPressStart,
  13.  void Function(LongPressMoveUpdateDetails) onLongPressMoveUpdate,
  14.  void Function() onLongPressUp,
  15.  void Function(LongPressEndDetails) onLongPressEnd,
  16.  void Function(DragDownDetails) onVerticalDragDown,
  17.  void Function(DragStartDetails) onVerticalDragStart,
  18.  void Function(DragUpdateDetails) onVerticalDragUpdate,
  19.  void Function(DragEndDetails) onVerticalDragEnd,
  20.  void Function() onVerticalDragCancel,
  21.  void Function(DragDownDetails) onHorizontalDragDown,
  22.  void Function(DragStartDetails) onHorizontalDragStart,
  23.  void Function(DragUpdateDetails) onHorizontalDragUpdate,
  24.  void Function(DragEndDetails) onHorizontalDragEnd,
  25.  void Function() onHorizontalDragCancel,
  26.  void Function(ForcePressDetails) onForcePressStart,
  27.  void Function(ForcePressDetails) onForcePressPeak,
  28.  void Function(ForcePressDetails) onForcePressUpdate,
  29.  void Function(ForcePressDetails) onForcePressEnd,
  30.  void Function(DragDownDetails) onPanDown,
  31.  void Function(DragStartDetails) onPanStart,
  32.  void Function(DragUpdateDetails) onPanUpdate,
  33.  void Function(DragEndDetails) onPanEnd,
  34.  void Function() onPanCancel,
  35.  void Function(ScaleStartDetails) onScaleStart,
  36.  void Function(ScaleUpdateDetails) onScaleUpdate,
  37.  void Function(ScaleEndDetails) onScaleEnd,
  38.  HitTestBehavior behavior,
  39.  bool excludeFromSemantics = false,
  40.  DragStartBehavior dragStartBehavior = DragStartBehavior.start})
属性名 描述
onTapDown:(TapDownDetails e){} 一个可能导致点击主按钮的指针已在特定位置与屏幕联系

HitTestBehavior

  1. // 自己处理事件 
  2. HitTestBehavior.opaque 
  4. // child处理事件 
  5. HitTestBehavior.deferToChild 
  7. //  自己和child都可以接收事件  
  8. HitTestBehavior.translucent

onVerticalDragUpdate

  1. onVerticalDragUpdate GestureDragUpdateCallback(DragUpdateDetails details)
  3. DragUpdateDetails 存储所有的drag信息
  4. primaryDelta 最新的drag 导致的位移

onVerticalDragEnd

  1. onVerticalDragEnd  GestureDragEndCallback(DragEndDetails details)
  3. DragEndDetails 存储drag结束信息
  4. details.velocity.pixelsPerSecond.dy 获取滑动结束后垂直的位移 x轴同理

点击、双击、长按

我们通过GestureDetector对Container进行手势识别，触发相应事件后，在Container上显示事件名，为了增大点击区域，将Container设置为200×100，代码如下：

  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: '原始指针事件处理',
  11.         theme: ThemeData(
  12.           primarySwatch: Colors.blue,
  13.         ),
  14.         home: Scaffold(
  15.           appBar: AppBar(title: Text("原始指针事件处理")),
  16.           body: GestureDetectorTestRoute(),
  17.         ));
  18.   }
  19. }
  22. class GestureDetectorTestRoute extends StatefulWidget {
  23.   @override
  24.   _GestureDetectorTestRouteState createState() =>
  25.       new _GestureDetectorTestRouteState();
  26. }
  27. class _GestureDetectorTestRouteState extends State<GestureDetectorTestRoute> {
  28.   String _operation = "No Gesture detected!"; //保存事件名
  29.   @override
  30.   Widget build(BuildContext context) {
  31.     return Center(
  32.       child: GestureDetector(
  33.         child: Container(
  34.           alignment: Alignment.center,
  35.           color: Colors.blue,
  36.           width: 200.0,
  37.           height: 100.0,
  38.           child: Text(_operation,
  39.             style: TextStyle(color: Colors.white),
  40.           ),
  41.         ),
  42.         onTap: () => updateText("Tap点击"),             //点击
  43.         onDoubleTap: () => updateText("DoubleTap双击"), //双击
  44.         onLongPress: () => updateText("LongPress长按"), //长按
  45.       ),
  46.     );
  47.   }
  48.   void updateText(String text) {
  49.     //更新显示的事件名
  50.     setState(() {
  51.       _operation = text;
  52.     });
  53.   }
  54. }

运行效果如图所示：
手势识别 GestureDetector - 图1

⚠️ 注意：当同时监听onTap和onDoubleTap事件时，当用户触发tap事件时，会有200毫秒左右的延时！ 这是因为当用户点击完之后很可能会再次点击以触发双击事件，所以GestureDetector会等一段时间来确定是否为双击事件。如果用户只监听了onTap（没有监听onDoubleTap）事件时，则没有延时。

拖动、滑动

一次完整的手势过程是指用户手指按下到抬起的整个过程，期间，用户按下手指后可能会移动，也可能不会移动。GestureDetector对于拖动和滑动事件是没有区分的，他们本质上是一样的。GestureDetector会将要监听的组件的原点（左上角）作为本次手势的原点，当用户在监听的组件上按下手指时，手势识别就会开始。下面我们看一个拖动圆形字母A的示例：

  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: 'GestureDetectorTestRoute',
  11.         theme: ThemeData(
  12.           primarySwatch: Colors.blue,
  13.         ),
  14.         home: Scaffold(
  15.           appBar: AppBar(title: Text("GestureDetectorTestRoute")),
  16.           body: Drag(),
  17.         ));
  18.   }
  19. }
  21. class Drag extends StatefulWidget {
  22.   @override
  23.   _DragState createState() => new _DragState();
  24. }
  26. class _DragState extends State<Drag> with SingleTickerProviderStateMixin {
  27.   double _top = 20.0; //距顶部的偏移
  28.   double _left = 20.0; //距左边的偏移
  29.   String _text_output = "初始情况";
  30.   @override
  31.   Widget build(BuildContext context) {
  32.     return Stack(
  33.       alignment: Alignment.center, //指定未定位或部分定位widget的对齐方式
  34.       children: <Widget>[
  35.         Positioned(
  36.           top: 18.0,
  37.           child: Container(
  38.             width: 300,
  39.             height: 300,
  40.             child: Text(_text_output,
  41.                 style: TextStyle(
  42.                     color: Colors.white,
  43.                     decorationStyle: TextDecorationStyle.solid)),
  44.             color: Colors.red,
  45.             padding: EdgeInsets.all(5),
  46.           ),
  47.         ),
  48.         Positioned(
  49.           top: _top,
  50.           left: _left,
  51.           child: GestureDetector(
  52.             child: CircleAvatar(child: Text("A")),
  53.             //手指按下时会触发此回调
  54.             onPanDown: (DragDownDetails e) {
  55.               //打印手指按下的位置(相对于屏幕)
  56.               setState(() {
  57.                 _text_output = "DragDownDetails.globalPosition：${e.globalPosition}";
  58.               });
  59.             },
  60.             //手指滑动时会触发此回调
  61.             onPanUpdate: (DragUpdateDetails e) {
  62.               //用户手指滑动时，更新偏移，重新构建
  63.               setState(() {
  64.                 _left += e.delta.dx;
  65.                 _top += e.delta.dy;
  66.                 _text_output = "DragUpdateDetails.delta.[dx|dy]:【_left：$_left】【_top：$_top】";
  67.               });
  68.             },
  69.             onPanEnd: (DragEndDetails e) {
  70.               //打印滑动结束时在x、y轴上的速度
  71.               setState(() {
  72.                 _text_output = "DragEndDetails.velocity:${e.velocity}";
  73.               });
  74.             },
  75.           ),
  76.         ),
  77.       ],
  78.     );
  79.   }
  80. }

运行后，就可以在任意方向拖动了，运行效果如图所示：
手势识别 GestureDetector - 图2
日志：

  1. I/flutter ( 8513): 用户手指按下：Offset(26.3, 101.8)
  2. I/flutter ( 8513): Velocity(235.5, 125.8)

代码解释：

  • DragDownDetails.globalPosition：当用户按下时，此属性为用户按下的位置相对于屏幕（而非父组件）原点(左上角)的偏移。
  • DragUpdateDetails.delta：当用户在屏幕上滑动时，会触发多次Update事件，delta指一次Update事件的滑动的偏移量。
  • DragEndDetails.velocity：该属性代表用户抬起手指时的滑动速度(包含x、y两个轴的），示例中并没有处理手指抬起时的速度，常见的效果是根据用户抬起手指时的速度做一个减速动画。

    单一方向拖动

    在本示例中，是可以朝任意方向拖动的，但是在很多场景，我们只需要沿一个方向来拖动，如一个垂直方向的列表，GestureDetector 可以只识别特定方向的手势事件，我们将上面的例子改为只能沿垂直方向拖动： ```dart import ‘package:flutter/material.dart’;

void main() => runApp(new MyApp());

class MyApp extends StatelessWidget { @override Widget build(BuildContext context) { return MaterialApp( debugShowCheckedModeBanner: true, title: ‘GestureDetectorTestRoute’, theme: ThemeData( primarySwatch: Colors.blue, ), home: Scaffold( appBar: AppBar(title: Text(“GestureDetectorTestRoute”)), body: DragVertical(), )); } }

class DragVertical extends StatefulWidget { @override _DragVerticalState createState() => new _DragVerticalState(); } class _DragVerticalState extends State { double _top = 0.0; @override Widget build(BuildContext context) { return Stack( children: [ Positioned( top: _top, child: GestureDetector( child: CircleAvatar(child: Text(“A”)), //垂直方向拖动事件 onVerticalDragUpdate: (DragUpdateDetails details) { setState(() { // _left += e.delta.dx; _top += details.delta.dy; }); } ), ) ], ); } }

  1. 这样就只能在垂直方向拖动了，如果只想在水平方向滑动同理。
  4. <a name="9qbTT"></a>
  5. ### 缩放
  6. GestureDetector 可以监听缩放事件 onScaleUpdate，下面示例演示了一个简单的图片缩放效果：
  7. ```dart
  8. import 'package:flutter/material.dart';
  10. void main() => runApp(new MyApp());
  12. class MyApp extends StatelessWidget {
  13.   @override
  14.   Widget build(BuildContext context) {
  15.     return MaterialApp(
  16.         debugShowCheckedModeBanner: true,
  17.         title: '缩放',
  18.         theme: ThemeData(
  19.           primarySwatch: Colors.blue,
  20.         ),
  21.         home: Scaffold(
  22.           appBar: AppBar(title: Text("缩放")),
  23.           body: _ScaleTestRoute(),
  24.         ));
  25.   }
  26. }
  28. class _ScaleTestRoute extends StatefulWidget {
  29.   _ScaleTestRoute({Key key}) : super(key: key);
  31.   @override
  32.   __ScaleTestRouteState createState() => __ScaleTestRouteState();
  33. }
  35. class __ScaleTestRouteState extends State<_ScaleTestRoute> {
  36.   double _width = 200.0; //通过修改图片宽度来达到缩放效果
  37.   @override
  38.   Widget build(BuildContext context) {
  39.     return Center(
  40.       child: GestureDetector(
  41.         //指定宽度，高度自适应
  42.         child: Image.asset("images/avatar.jpg", width: _width),
  43.         onScaleUpdate: (ScaleUpdateDetails details) {
  44.           setState(() {
  45.             //缩放倍数在0.8到10倍之间
  46.             _width = 200.0 * details.scale.clamp(.8, 10.0);
  47.           });
  48.         },
  49.       ),
  50.     );
  51.   }
  52. }

运行效果如图所示：
手势识别 GestureDetector - 图3
现在在图片上双指张开、收缩就可以放大、缩小图片。本示例比较简单，实际中我们通常还需要一些其它功能，如双击放大或缩小一定倍数、双指张开离开屏幕时执行一个减速放大动画等，读者可以在学习完后面“动画”一章中的内容后自己来尝试实现一下。

GestureRecognizer

  • GestureDetector 内部是使用一个或多个 GestureRecognizer 来识别各种手势的
  • 而 GestureRecognizer 的作用就是通过 Listener 来将原始指针事件转换为语义手势，GestureDetector 直接可以接收一个子widget。
  • GestureRecognizer 是一个抽象类，一种手势的识别器对应一个 GestureRecognizer 的子类,Flutter实现了丰富的手势识别器，我们可以直接使用。

示例
假设我们要给一段富文本（RichText）的不同部分分别添加点击事件处理器，但是 TextSpan 并不是一个widget，这时我们不能用 GestureDetector，但TextSpan有一个 recognizer 属性，它可以接收一个GestureRecognizer。
假设我们需要在点击时给文本变色:

  1. import 'package:flutter/gestures.dart';
  2. import 'package:flutter/material.dart';
  4. void main() => runApp(new MyApp());
  6. class MyApp extends StatelessWidget {
  7.   @override
  8.   Widget build(BuildContext context) {
  9.     return MaterialApp(
  10.         debugShowCheckedModeBanner: true,
  11.         title: 'GestureRecognizer',
  12.         theme: ThemeData(
  13.           primarySwatch: Colors.blue,
  14.         ),
  15.         home: Scaffold(
  16.           appBar: AppBar(title: Text("GestureRecognizer")),
  17.           body: _GestureRecognizerTestRoute(),
  18.         ));
  19.   }
  20. }
  22. class _GestureRecognizerTestRoute extends StatefulWidget {
  23.   _GestureRecognizerTestRoute({Key key}) : super(key: key);
  25.   @override
  26.   __GestureRecognizerTestRouteState createState() =>
  27.       __GestureRecognizerTestRouteState();
  28. }
  30. class __GestureRecognizerTestRouteState
  31.     extends State<_GestureRecognizerTestRoute> {
  32.   TapGestureRecognizer _tapGestureRecognizer = new TapGestureRecognizer();
  33.   bool _toggle = false; //变色开关
  34.   @override
  35.   void dispose() {
  36.     //用到GestureRecognizer的话一定要调用其dispose方法释放资源
  37.     _tapGestureRecognizer.dispose();
  38.     super.dispose();
  39.   }
  41.   @override
  42.   Widget build(BuildContext context) {
  43.     return Center(
  44.       child: Text.rich(TextSpan(children: [
  45.         TextSpan(text: "你好世界"),
  46.         TextSpan(
  47.           text: "点我变色",
  48.           style: TextStyle(
  49.               fontSize: 30.0, color: _toggle ? Colors.blue : Colors.red),
  50.           recognizer: _tapGestureRecognizer
  51.             ..onTap = () {
  52.               setState(() {
  53.                 _toggle = !_toggle;
  54.               });
  55.             },
  56.         ),
  57.         TextSpan(text: "你好世界"),
  58.       ])),
  59.     );
  60.   }
  61. }

运行效果：
手势识别 GestureDetector - 图4

注意：使用GestureRecognizer后一定要调用其dispose()方法来释放资源（主要是取消内部的计时器）。

手势竞争与冲突

手势竞争

如果在上例中我们同时监听水平和垂直方向的拖动事件，那么我们斜着拖动时哪个方向会生效？

  • 实际上取决于第一次移动时两个轴上的位移分量，哪个轴的大，哪个轴在本次滑动事件竞争中就胜出。
  • 实际上Flutter中的手势识别引入了一个Arena的概念，Arena直译为“竞技场”的意思，每一个手势识别器（GestureRecognizer）都是一个“竞争者”（GestureArenaMember），当发生滑动事件时，他们都要在“竞技场”去竞争本次事件的处理权，而最终只有一个“竞争者”会胜出(win)。
    • 例如，假设有一个ListView，它的第一个子组件也是ListView，如果现在滑动这个子ListView，父ListView会动吗？答案是否定的，这时只有子ListView会动，因为这时子ListView会胜出而获得滑动事件的处理权。

示例:我们以拖动手势为例，同时识别水平和垂直方向的拖动手势，当用户按下手指时就会触发竞争（水平方向和垂直方向），一旦某个方向“获胜”，则直到当次拖动手势结束都会沿着该方向移动。代码如下：

  1. import 'package:flutter/gestures.dart';
  2. import 'package:flutter/material.dart';
  4. void main() => runApp(new MyApp());
  6. class MyApp extends StatelessWidget {
  7.   @override
  8.   Widget build(BuildContext context) {
  9.     return MaterialApp(
  10.         debugShowCheckedModeBanner: true,
  11.         title: '手势竞争',
  12.         theme: ThemeData(
  13.           primarySwatch: Colors.blue,
  14.         ),
  15.         home: Scaffold(
  16.           appBar: AppBar(title: Text("手势竞争")),
  17.           body: BothDirectionTestRoute(),
  18.         ));
  19.   }
  20. }
  22. class BothDirectionTestRoute extends StatefulWidget {
  23.   @override
  24.   BothDirectionTestRouteState createState() =>
  25.       new BothDirectionTestRouteState();
  26. }
  28. class BothDirectionTestRouteState extends State<BothDirectionTestRoute> {
  29.   double _top = 0.0;
  30.   double _left = 0.0;
  31.   @override
  32.   Widget build(BuildContext context) {
  33.     return Stack(
  34.       children: <Widget>[
  35.         Positioned(
  36.           top: _top,
  37.           left: _left,
  38.           child: GestureDetector(
  39.             child: CircleAvatar(child: Text("A")),
  40.             //垂直方向拖动事件
  41.             onVerticalDragUpdate: (DragUpdateDetails details) {
  42.               setState(() {
  43.                 _top += details.delta.dy;
  44.               });
  45.             },
  46.             //水平方向拖动事件
  47.             onHorizontalDragUpdate: (DragUpdateDetails details) {
  48.               setState(() {
  49.                 _left += details.delta.dx;
  50.               });
  51.             },
  52.           ),
  53.         )
  54.       ],
  55.     );
  56.   }
  57. }

此示例运行后，每次拖动只会沿一个方向移动（水平或垂直），而竞争发生在手指按下后首次移动（move）时，此例中具体的“获胜”条件是：首次移动时的位移在水平和垂直方向上的分量大的一个获胜。

手势冲突

由于手势竞争最终只有一个胜出者，所以，当有多个手势识别器时，可能会产生冲突。假设有一个widget，它可以左右拖动，现在我们也想检测在它上面手指按下和抬起的事件，代码如下：

  1. import 'package:flutter/gestures.dart';
  2. import 'package:flutter/material.dart';
  4. void main() => runApp(new MyApp());
  6. class MyApp extends StatelessWidget {
  7.   @override
  8.   Widget build(BuildContext context) {
  9.     return MaterialApp(
  10.         debugShowCheckedModeBanner: true,
  11.         title: '手势冲突',
  12.         theme: ThemeData(
  13.           primarySwatch: Colors.blue,
  14.         ),
  15.         home: Scaffold(
  16.           appBar: AppBar(title: Text("手势冲突")),
  17.           body: GestureConflictTestRoute(),
  18.         ));
  19.   }
  20. }
  22. class GestureConflictTestRoute extends StatefulWidget {
  23.   @override
  24.   GestureConflictTestRouteState createState() =>
  25.       new GestureConflictTestRouteState();
  26. }
  28. class GestureConflictTestRouteState extends State<GestureConflictTestRoute> {
  29.   double _left = 0.0;
  30.   @override
  31.   Widget build(BuildContext context) {
  32.     return Stack(
  33.       children: <Widget>[
  34.         Positioned(
  35.           left: _left,
  36.           child: GestureDetector(
  37.             child: CircleAvatar(child: Text("A")), //要拖动和点击的widget
  38.             onTapDown: (details) {
  39.               //一个可能导致点击主按钮的指针已在特定位置与屏幕联系。
  40.               print("down");
  41.             },
  42.             onHorizontalDragUpdate: (DragUpdateDetails details) { //用主按钮与屏幕接触并水平移动的指针已在水平方向上移动。
  43.               setState(() {
  44.                 _left += details.delta.dx;
  45.               });
  46.             },
  47.             onHorizontalDragEnd: (details) {
  48.               //以前用主按钮接触屏幕并水平移动的指针不再与屏幕接触，并且在停止接触屏幕时以特定速度移动
  49.               print("onHorizontalDragEnd");
  50.             },
  51.             onTapUp: (details) {
  52.               //用主按钮触发点击的指针已停止在特定位置与屏幕接触
  53.               print("up");
  54.             },
  55.           ),
  56.         )
  57.       ],
  58.     );
  59.   }
  60. }

现在我们按住圆形“A”拖动然后抬起手指，控制台日志如下:

  1. I/flutter (17539): down
  2. I/flutter (17539): onHorizontalDragEnd

我们发现没有打印”up”，这是为什么呢？

  • 这是因为在拖动时，刚开始按下手指时在没有移动时，拖动手势还没有完整的语义，此时onTapDown手势胜出(win)，此时打印”down”
  • 而拖动时，拖动手势会胜出，当手指抬起时，onHorizontalDragEnd和 onTapUp发生了冲突，但是因为是在拖动的语义中，所以onHorizontalDragEnd胜出，所以就会打印 “onHorizontalDragEnd”。

处理手势冲突

如果我们的代码逻辑中，对于手指按下和抬起是强依赖的，比如在一个轮播图组件中，我们希望

  • 手指按下时，暂停轮播，
  • 而抬起时恢复轮播

但是由于轮播图组件中本身可能已经处理了拖动手势（支持手动滑动切换），甚至可能也支持了缩放手势，这时我们如果在外部再用onTapDown、onTapUp来监听的话是不行的。这时我们应该怎么做？其实很简单，通过Listener监听原始指针事件就行：

  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: '处理手势冲突',
  11.         theme: ThemeData(
  12.           primarySwatch: Colors.blue,
  13.         ),
  14.         home: Scaffold(
  15.           appBar: AppBar(title: Text("处理手势冲突")),
  16.           body: GestureConflictTestRoute(),
  17.         ));
  18.   }
  19. }
  21. class GestureConflictTestRoute extends StatefulWidget {
  22.   @override
  23.   GestureConflictTestRouteState createState() =>
  24.       new GestureConflictTestRouteState();
  25. }
  27. class GestureConflictTestRouteState extends State<GestureConflictTestRoute> {
  28.   double _leftB = 0.0;
  29.   @override
  30.   Widget build(BuildContext context) {
  31.     return Stack(
  32.       children: <Widget>[
  33.         Positioned(
  34.           top: 80.0,
  35.           left: _leftB,
  36.           child: Listener(
  37.             onPointerDown: (details) {
  38.               print("down");
  39.             },
  40.             onPointerUp: (details) {
  41.               //会触发
  42.               print("up");
  43.             },
  44.             child: GestureDetector(
  45.               child: CircleAvatar(child: Text("B")),
  46.               onHorizontalDragStart: (DragStartDetails e){
  47.                   print("onHorizontalDragStart");
  48.               },
  49.               onHorizontalDragUpdate: (DragUpdateDetails details) {
  50.                 setState(() {
  51.                   _leftB += details.delta.dx;
  52.                 });
  53.               },
  54.               onHorizontalDragEnd: (details) {
  55.                 print("onHorizontalDragEnd");
  56.               },
  57.             ),
  58.           ),
  59.         )
  60.       ],
  61.     );
  62.   }
  63. }

手势冲突只是手势级别的，而手势是对原始指针的语义化的识别，所以在遇到复杂的冲突场景时，都可以通过Listener直接识别原始指针事件来解决冲突。