Add multi-finger swipe detection to GestureDetector

ui/events/gesture_detection/gesture_detector.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/events/gesture_detection/gesture_detector.h"
 
 #include <cmath>
 
 #include "base/timer/timer.h"
 #include "ui/events/gesture_detection/motion_event.h"
 
 namespace ui {
 namespace {
 
 // Using a small epsilon when comparing slop distances allows pixel perfect
 // slop determination when using fractional DIP coordinates (assuming the slop
 // region and DPI scale are reasonably proportioned).
 const float kSlopEpsilon = .05f;
 
 // Minimum distance a scroll must have traveled from the last scroll/focal point
 // to trigger an |OnScroll| callback.
 const float kScrollEpsilon = .1f;
 
+const float kDegreesToRadians = 3.14159265f / 180.0f;

[tdresser, 2014/04/24 12:42:40]

Might as well use M_PI here.

Note that you need a 
#ifdef _WIN32
#define _USE_MATH_DEFINES
#endif
for windows.

[jdduke (slow), 2014/04/24 15:13:55]

Done.

+
 // Constants used by TimeoutGestureHandler.
 enum TimeoutEvent {
   SHOW_PRESS = 0,
   LONG_PRESS,
   TAP,
   TIMEOUT_EVENT_COUNT
 };
 
 }  // namespace
 
 // Note: These constants were taken directly from the default (unscaled)
 // versions found in Android's ViewConfiguration.
 GestureDetector::Config::Config()
     : longpress_timeout(base::TimeDelta::FromMilliseconds(500)),
       showpress_timeout(base::TimeDelta::FromMilliseconds(180)),
       double_tap_timeout(base::TimeDelta::FromMilliseconds(300)),
       touch_slop(8),
       double_tap_slop(100),
       minimum_fling_velocity(50),
-      maximum_fling_velocity(8000) {}
+      maximum_fling_velocity(8000),
+      swipe_enabled(false),
+      minimum_swipe_velocity(20),
+      maximum_swipe_deviation_angle(20.f) {
+}
 
 GestureDetector::Config::~Config() {}
 
 bool GestureDetector::SimpleGestureListener::OnDown(const MotionEvent& e) {
   return false;
 }
 
 void GestureDetector::SimpleGestureListener::OnShowPress(const MotionEvent& e) {
 }
 
@@ skipping 13 matching lines @@
   return false;
 }
 
 bool GestureDetector::SimpleGestureListener::OnFling(const MotionEvent& e1,
                                                      const MotionEvent& e2,
                                                      float velocity_x,
                                                      float velocity_y) {
   return false;
 }
 
+bool GestureDetector::SimpleGestureListener::OnSwipe(const MotionEvent& e1,
+                                                     const MotionEvent& e2,
+                                                     float velocity_x,
+                                                     float velocity_y) {
+  return false;
+}
+
 bool GestureDetector::SimpleGestureListener::OnSingleTapConfirmed(
     const MotionEvent& e) {
   return false;
 }
 
 bool GestureDetector::SimpleGestureListener::OnDoubleTap(const MotionEvent& e) {
   return false;
 }
 
 bool GestureDetector::SimpleGestureListener::OnDoubleTapEvent(
@@ skipping 64 matching lines @@
       still_down_(false),
       defer_confirm_single_tap_(false),
       in_longpress_(false),
       always_in_tap_region_(false),
       always_in_bigger_tap_region_(false),
       is_double_tapping_(false),
       last_focus_x_(0),
       last_focus_y_(0),
       down_focus_x_(0),
       down_focus_y_(0),
-      is_longpress_enabled_(true) {
+      longpress_enabled_(true) {
   DCHECK(listener_);
   Init(config);
 }
 
 GestureDetector::~GestureDetector() {}
 
 bool GestureDetector::OnTouchEvent(const MotionEvent& ev) {
   const MotionEvent::Action action = ev.GetAction();
 
   velocity_tracker_.AddMovement(ev);
@@ skipping 27 matching lines @@
     case MotionEvent::ACTION_POINTER_UP:
       down_focus_x_ = last_focus_x_ = focus_x;
       down_focus_y_ = last_focus_y_ = focus_y;
 
       // Check the dot product of current velocities.
       // If the pointer that left was opposing another velocity vector, clear.
       velocity_tracker_.ComputeCurrentVelocity(1000, max_fling_velocity_);
       {
         const int up_index = ev.GetActionIndex();
         const int id1 = ev.GetPointerId(up_index);
-        const float x1 = velocity_tracker_.GetXVelocity(id1);
-        const float y1 = velocity_tracker_.GetYVelocity(id1);
+        const float vx1 = velocity_tracker_.GetXVelocity(id1);
+        const float vy1 = velocity_tracker_.GetYVelocity(id1);
+        float vx_total = vx1;
+        float vy_total = vy1;
         for (int i = 0; i < count; i++) {
           if (i == up_index)
             continue;
 
           const int id2 = ev.GetPointerId(i);
-          const float x = x1 * velocity_tracker_.GetXVelocity(id2);
-          const float y = y1 * velocity_tracker_.GetYVelocity(id2);
-
-          const float dot = x + y;
+          const float vx2 = velocity_tracker_.GetXVelocity(id2);
+          const float vy2 = velocity_tracker_.GetYVelocity(id2);
+          const float dot = vx1 * vx2 + vy1 * vy2;
           if (dot < 0) {
+            vx_total = 0;
+            vy_total = 0;
             velocity_tracker_.Clear();
             break;
           }
+          vx_total += vx2;
+          vy_total += vy2;
+        }
+
+        if (swipe_enabled_ && (vx_total || vy_total)) {
+          float vx = vx_total / count;
+          float vy = vy_total / count;
+          float vx_abs = std::abs(vx);
+          float vy_abs = std::abs(vy);
+
+          if (vx_abs < min_swipe_velocity_)
+            vx_abs = vx = 0;
+          if (vy_abs < min_swipe_velocity_)
+            vy_abs = vy = 0;
+
+          // Note that the ratio will be 0 if both velocites are below the min.
+          float ratio = vx_abs > vy_abs ? vx_abs / std::max(vy_abs, 0.001f)
+                                        : vy_abs / std::max(vx_abs, 0.001f);
+          if (ratio > min_swipe_direction_component_ratio_) {
+            if (vx_abs > vy_abs)
+              vy = 0;
+            else
+              vx = 0;
+
+            handled = listener_->OnSwipe(*current_down_event_, ev, vx, vy);
+          }
         }
       }
       break;
 
     case MotionEvent::ACTION_DOWN:
       if (double_tap_listener_) {
         bool had_tap_message = timeout_handler_->HasTimeout(TAP);
         if (had_tap_message)
           timeout_handler_->StopTimeout(TAP);
         if (current_down_event_ && previous_up_event_ && had_tap_message &&
@@ skipping 18 matching lines @@
 
       always_in_tap_region_ = true;
       always_in_bigger_tap_region_ = true;
       still_down_ = true;
       in_longpress_ = false;
       defer_confirm_single_tap_ = false;
 
       // Always start the SHOW_PRESS timer before the LONG_PRESS timer to ensure
       // proper timeout ordering.
       timeout_handler_->StartTimeout(SHOW_PRESS);
-      if (is_longpress_enabled_)
+      if (longpress_enabled_)
         timeout_handler_->StartTimeout(LONG_PRESS);
       handled |= listener_->OnDown(ev);
       break;
 
     case MotionEvent::ACTION_MOVE:
       if (in_longpress_)
         break;
 
       {
         const float scroll_x = last_focus_x_ - focus_x;
@@ skipping 97 matching lines @@
 
   const float touch_slop = config.touch_slop + kSlopEpsilon;
   const float double_tap_touch_slop = touch_slop;
   const float double_tap_slop = config.double_tap_slop + kSlopEpsilon;
   touch_slop_square_ = touch_slop * touch_slop;
   double_tap_touch_slop_square_ = double_tap_touch_slop * double_tap_touch_slop;
   double_tap_slop_square_ = double_tap_slop * double_tap_slop;
   double_tap_timeout_ = config.double_tap_timeout;
   min_fling_velocity_ = config.minimum_fling_velocity;
   max_fling_velocity_ = config.maximum_fling_velocity;
+
+  swipe_enabled_ = config.swipe_enabled;
+  min_swipe_velocity_ = config.minimum_swipe_velocity;
+  DCHECK_GT(config.maximum_swipe_deviation_angle, 0);
+  DCHECK_LE(config.maximum_swipe_deviation_angle, 45);
+  const float maximum_swipe_deviation_angle =
+      std::min(45.f, std::max(0.001f, config.maximum_swipe_deviation_angle));
+  min_swipe_direction_component_ratio_ =
+      1.f / tan(maximum_swipe_deviation_angle * kDegreesToRadians);
 }
 
 void GestureDetector::OnShowPressTimeout() {
   listener_->OnShowPress(*current_down_event_);
 }
 
 void GestureDetector::OnLongPressTimeout() {
   timeout_handler_->StopTimeout(TAP);
   defer_confirm_single_tap_ = false;
   in_longpress_ = listener_->OnLongPress(*current_down_event_);
@@ skipping 38 matching lines @@
   if (second_down.GetEventTime() - first_up.GetEventTime() >
       double_tap_timeout_)
     return false;
 
   const float delta_x = first_down.GetX() - second_down.GetX();
   const float delta_y = first_down.GetY() - second_down.GetY();
   return (delta_x * delta_x + delta_y * delta_y < double_tap_slop_square_);
 }
 
 }  // namespace ui