feat: add drag event listen

@@ -19,7 +19,8 @@ class AutoTrackConfig {
     this.enablePageView = true,
     this.enablePageLeave = false,
     this.enableClick = true,
-    this.enableUpload = false
+    this.enableUpload = false,
+    this.enableDrag = false
   }) {
     trackId ??= const Uuid().v4().replaceAll('-', '');
     signature ??= (t) => sha256.convert(utf8.encode('$appKey$t$appSecret')).toString();
@@ -55,6 +56,8 @@ class AutoTrackConfig {
   bool enableClick;
 
   bool enableUpload;
+
+  bool enableDrag;
 }
 
 typedef PageWidgetFunc = bool Function(Widget);

@@ -64,6 +64,10 @@ class AutoTrackConfigManager {
     _config.enableClick = enable;
   }
 
+  void enableDrag(bool enable) {
+    _config.enableDrag = enable;
+  }
+
   void enableAutoTrack(bool enable) {
     _autoTrackEnable = enable;
   }
@@ -102,6 +106,11 @@ class AutoTrackConfigManager {
     if (getIgnoreElementStringKeySet().contains(key.toString())) {
       return true;
     }
+
+    if (key is ValueKey) {
+      return getIgnoreElementStringKeySet().contains(key.value);
+    }
+
     return false;
   }
 
@@ -110,4 +119,6 @@ class AutoTrackConfigManager {
   bool get pageLeaveEnable => _config.enablePageLeave;
 
   bool get clickEnable => _config.enableClick;
+
+  bool get dragEnable => _config.enableDrag;
 }

+import 'package:flutter/widgets.dart';
+
+import '../config/manager.dart';
+import '../page_view/page_info.dart';
+
+class DragInfo {
+  DragInfo._(this.pageInfo);
+
+  factory DragInfo.from(
+      {required Offset begin,
+      required Offset end,
+      required Element pageElement,
+      required PageInfo pageInfo,
+      required int duration}) {
+    DragInfo dragInfo = DragInfo._(pageInfo);
+    dragInfo._beginOffset = begin;
+    dragInfo._endOffset = end;
+    dragInfo._duration = duration;
+    dragInfo._ignore = AutoTrackConfigManager.instance.isIgnoreElement(
+        pageElement.widget.key ?? ValueKey(pageInfo.pageManualKey));
+
+    double dx = dragInfo.endOffset.dx - dragInfo.beginOffset.dx;
+    double dy = dragInfo.endOffset.dy - dragInfo.beginOffset.dy;
+
+    var direction = 'down';
+    if (dx.abs() > dy.abs()) {
+      if (dx > 0) {
+        direction = 'right';
+      } else {
+        direction = 'left';
+      }
+    } else if (dy.abs() > dx.abs()) {
+      if (dy > 0) {
+        direction = 'down';
+      } else {
+        direction = 'up';
+      }
+    } else {
+      direction = 'none';
+    }
+    dragInfo._direction = direction;
+
+    return dragInfo;
+  }
+
+  Offset _beginOffset = Offset.zero;
+  Offset get beginOffset => _beginOffset;
+
+  Offset _endOffset = Offset.zero;
+  Offset get endOffset => _endOffset;
+
+  bool _ignore = false;
+  bool get ignore => _ignore;
+
+  String _direction = 'none';
+  String get direction => _direction;
+
+  int _duration = 0;
+  int get duration => _duration;
+
+  final PageInfo pageInfo;
+
+  @override
+  String toString() {
+    return [
+      'beginOffset: $beginOffset',
+      'endOffset: $endOffset',
+      'pageInfo: $pageInfo',
+    ].join(', ');
+  }
+}

+import 'package:auto_track/auto_track/drag/drag_info.dart';
+import 'package:auto_track/auto_track/track/track.dart';
+import 'package:flutter/gestures.dart';
+
+import '../page_view/page_stack.dart';
+
+class DragPointerEventListener {
+  static final DragPointerEventListener instance = DragPointerEventListener._();
+  DragPointerEventListener._();
+  bool _started = false;
+  late _AutoTrackPanGestureRecognizer _panGestureRecognizer;
+
+  void start() {
+    if (!_started) {
+      _panGestureRecognizer = _AutoTrackPanGestureRecognizer();
+      GestureBinding.instance?.pointerRouter
+          .addGlobalRoute(_panGestureRecognizer.addPointer);
+      _started = true;
+    }
+  }
+
+  void stop() {
+    if (_started) {
+      GestureBinding.instance?.pointerRouter
+          .removeGlobalRoute(_panGestureRecognizer.addPointer);
+      _panGestureRecognizer.dispose();
+      _started = false;
+    }
+  }
+}
+
+class _AutoTrackPanGestureRecognizer extends PanGestureRecognizer {
+  _AutoTrackPanGestureRecognizer({Object? debugOwner})
+      : super(debugOwner: debugOwner);
+
+  PointerAddedEvent? beginEvent;
+  int startTime = 0;
+
+  @override
+  void addPointer(PointerEvent event) {
+    resolve(GestureDisposition.accepted);
+
+    final page = PageStack.instance.getCurrentPage();
+    if (page == null) {
+      return;
+    }
+    if (event is PointerAddedEvent) {
+      beginEvent = event;
+      startTime = DateTime.now().millisecondsSinceEpoch;
+    } else if (event is PointerRemovedEvent) {
+      if (beginEvent != null) {
+        final distance = (beginEvent!.position.dx - event.position.dx).abs() +
+            (beginEvent!.position.dy - event.position.dy).abs();
+        if (distance > 30) {
+          final info = DragInfo.from(
+              begin: beginEvent!.position,
+              end: event.position,
+              pageElement: page!.element,
+              pageInfo: page!.pageInfo,
+              duration: DateTime.now().millisecondsSinceEpoch - startTime);
+          if (!info.ignore) {
+            Track.instance.drag(info);
+          }
+        }
+      }
+      beginEvent = null;
+    }
+  }
+}

+import 'package:auto_track/auto_track/drag/drag_pointer_event_listener.dart';
 import 'package:flutter/foundation.dart';
 
 import 'click/pointer_event_listener.dart';
@@ -81,6 +82,16 @@ class AutoTrack {
     return _instance;
   }
 
+  AutoTrack enableDrag() {
+    AutoTrackConfigManager.instance.enableDrag(true);
+    return _instance;
+  }
+
+  AutoTrack disableDrag() {
+    AutoTrackConfigManager.instance.enableDrag(true);
+    return _instance;
+  }
+
   AutoTrack disableClick() {
     AutoTrackConfigManager.instance.enableClick(false);
     return _instance;
@@ -89,12 +100,14 @@ class AutoTrack {
   AutoTrack enable() {
     AutoTrackConfigManager.instance.enableAutoTrack(true);
     PointerEventListener.instance.start();
+    DragPointerEventListener.instance.start();
     return _instance;
   }
 
   AutoTrack disable() {
     AutoTrackConfigManager.instance.enableAutoTrack(false);
     PointerEventListener.instance.stop();
+    DragPointerEventListener.instance.stop();
     return _instance;
   }
 

 import 'package:auto_track/auto_track/config/queue.dart';
+import 'package:auto_track/auto_track/drag/drag_info.dart';
 import 'package:auto_track/auto_track/utils/track_model.dart';
 
 import '../click/click_info.dart';
@@ -68,6 +69,32 @@ class Track {
     AutoTrackLogger.getInstance().debug('track click => $params');
   }
 
+  void drag(DragInfo dragInfo) {
+    if (!AutoTrackConfigManager.instance.autoTrackEnable) {
+      return;
+    }
+    if (!AutoTrackConfigManager.instance.dragEnable) {
+      return;
+    }
+    Map<String, dynamic> params = {};
+    params['manual_key'] = 'drag';
+    params['begin'] = {
+      'x': dragInfo.beginOffset.dx,
+      'y': dragInfo.beginOffset.dy,
+    };
+    params['end'] = {
+      'x': dragInfo.endOffset.dx,
+      'y': dragInfo.endOffset.dy,
+    };
+    params['drag_duration'] = dragInfo.duration;
+    params['drag_direction'] = dragInfo.direction;
+
+    _appendPageInfo(params, dragInfo.pageInfo);
+    _TrackPlugin.drag(params);
+    AutoTrackLogger.getInstance().debug('track drag => $params');
+
+  }
+
   void customEvent(String type, Map<String, dynamic> params) {
     _TrackPlugin.customEvent(type, params);
     AutoTrackLogger.getInstance().debug('track custom_event => $params');
@@ -92,7 +119,7 @@ class _TrackPlugin {
     AutoTrackQueue.instance.appendQueue(TrackModel(type, DateTime.now().millisecondsSinceEpoch, params, params['key'] ?? type));
   }
 
-  static void scroll(Map<String, dynamic> params) {
-    // AutoTrackQueue.instance.appendQueue(TrackModel('scroll', DateTime.now().millisecondsSinceEpoch, params));
+  static void drag(Map<String, dynamic> params) {
+    AutoTrackQueue.instance.appendQueue(TrackModel('drag', DateTime.now().millisecondsSinceEpoch, params, params['manual_key']));
   }
 }