[Android] Support double-tap selection

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.
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
 #include "ui/events/gesture_detection/gesture_detector.h"
 
 #include <cmath>
@@ skipping 37 matching lines @@
       touch_slop(8),
       double_tap_slop(100),
       minimum_fling_velocity(50),
       maximum_fling_velocity(8000),
       swipe_enabled(false),
       minimum_swipe_velocity(20),
       maximum_swipe_deviation_angle(20.f),
       two_finger_tap_enabled(false),
       two_finger_tap_max_separation(300),
       two_finger_tap_timeout(base::TimeDelta::FromMilliseconds(700)),
-      velocity_tracker_strategy(VelocityTracker::Strategy::STRATEGY_DEFAULT) {
-}
+      single_tap_repeat_interval(1),
+      velocity_tracker_strategy(VelocityTracker::Strategy::STRATEGY_DEFAULT) {}
 
 GestureDetector::Config::~Config() {}
 
 class GestureDetector::TimeoutGestureHandler {
  public:
   TimeoutGestureHandler(const Config& config, GestureDetector* gesture_detector)
       : gesture_detector_(gesture_detector) {
     DCHECK(config.showpress_timeout <= config.longpress_timeout);
 
     timeout_callbacks_[SHOW_PRESS] = &GestureDetector::OnShowPressTimeout;
@@ skipping 52 matching lines @@
       min_fling_velocity_(1),
       max_fling_velocity_(1),
       min_swipe_velocity_(0),
       min_swipe_direction_component_ratio_(0),
       still_down_(false),
       defer_confirm_single_tap_(false),
       always_in_tap_region_(false),
       always_in_bigger_tap_region_(false),
       two_finger_tap_allowed_for_gesture_(false),
       is_double_tapping_(false),
+      is_down_candidate_for_repeated_single_tap_(false),
+      current_single_tap_repeat_count_(0),
+      single_tap_repeat_interval_(1),
       last_focus_x_(0),
       last_focus_y_(0),
       down_focus_x_(0),
       down_focus_y_(0),
       longpress_enabled_(true),
       showpress_enabled_(true),
       swipe_enabled_(false),
       two_finger_tap_enabled_(false),
       velocity_tracker_(config.velocity_tracker_strategy) {
   DCHECK(listener_);
@@ skipping 85 matching lines @@
       handled = HandleSwipeIfNeeded(ev, vx_total / count, vy_total / count);
 
       if (two_finger_tap_allowed_for_gesture_ && ev.GetPointerCount() == 2 &&
           (ev.GetEventTime() - secondary_pointer_down_event_->GetEventTime() <=
            two_finger_tap_timeout_)) {
         handled = listener_->OnTwoFingerTap(*current_down_event_, ev);
       }
       two_finger_tap_allowed_for_gesture_ = false;
     } break;
 
-    case MotionEvent::ACTION_DOWN:
+    case MotionEvent::ACTION_DOWN: {
+      bool is_repeated_tap =
+          current_down_event_ && previous_up_event_ &&
+          IsRepeatedTap(*current_down_event_, *previous_up_event_, ev);
       if (double_tap_listener_) {
+        is_down_candidate_for_repeated_single_tap_ = false;
         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 &&
-            IsConsideredDoubleTap(
-                *current_down_event_, *previous_up_event_, ev)) {
+        if (is_repeated_tap && had_tap_message) {
           // This is a second tap.
           is_double_tapping_ = true;
           // Give a callback with the first tap of the double-tap.
           handled |= double_tap_listener_->OnDoubleTap(*current_down_event_);
           // Give a callback with down event of the double-tap.
           handled |= double_tap_listener_->OnDoubleTapEvent(ev);
         } else {
           // This is a first tap.
           DCHECK(double_tap_timeout_ > base::TimeDelta());
           timeout_handler_->StartTimeout(TAP);
         }
+      } else {
+        is_down_candidate_for_repeated_single_tap_ = is_repeated_tap;
       }
 
       down_focus_x_ = last_focus_x_ = focus_x;
       down_focus_y_ = last_focus_y_ = focus_y;
       current_down_event_ = ev.Clone();
 
       secondary_pointer_down_event_.reset();
       always_in_tap_region_ = true;
       always_in_bigger_tap_region_ = true;
       still_down_ = true;
       defer_confirm_single_tap_ = false;
       two_finger_tap_allowed_for_gesture_ = two_finger_tap_enabled_;
 
       // Always start the SHOW_PRESS timer before the LONG_PRESS timer to ensure
       // proper timeout ordering.
       if (showpress_enabled_)
         timeout_handler_->StartTimeout(SHOW_PRESS);
       if (longpress_enabled_)
         timeout_handler_->StartTimeout(LONG_PRESS);
       handled |= listener_->OnDown(ev);
-      break;
+    } break;
 
     case MotionEvent::ACTION_MOVE:
       {
         const float scroll_x = last_focus_x_ - focus_x;
         const float scroll_y = last_focus_y_ - focus_y;
         if (is_double_tapping_) {
           // Give the move events of the double-tap.
           DCHECK(double_tap_listener_);
           handled |= double_tap_listener_->OnDoubleTapEvent(ev);
         } else if (always_in_tap_region_) {
@@ skipping 49 matching lines @@
       break;
 
     case MotionEvent::ACTION_UP:
       still_down_ = false;
       {
         if (is_double_tapping_) {
           // Finally, give the up event of the double-tap.
           DCHECK(double_tap_listener_);
           handled |= double_tap_listener_->OnDoubleTapEvent(ev);
         } else if (always_in_tap_region_) {
-          handled = listener_->OnSingleTapUp(ev);
+          if (is_down_candidate_for_repeated_single_tap_) {
+            current_single_tap_repeat_count_ =
+                (1 + current_single_tap_repeat_count_) %
+                single_tap_repeat_interval_;
+          } else {
+            current_single_tap_repeat_count_ = 0;
+          }
+          handled = listener_->OnSingleTapUp(
+              ev, 1 + current_single_tap_repeat_count_);
           if (defer_confirm_single_tap_ && double_tap_listener_ != NULL) {
             double_tap_listener_->OnSingleTapConfirmed(ev);
           }
         } else {
-
+          current_single_tap_repeat_count_ = 0;
           // A fling must travel the minimum tap distance.
           const int pointer_id = ev.GetPointerId(0);
           velocity_tracker_.ComputeCurrentVelocity(1000, max_fling_velocity_);
           const float velocity_y = velocity_tracker_.GetYVelocity(pointer_id);
           const float velocity_x = velocity_tracker_.GetXVelocity(pointer_id);
 
           if ((std::abs(velocity_y) > min_fling_velocity_) ||
               (std::abs(velocity_x) > min_fling_velocity_)) {
             handled = listener_->OnFling(
                 *current_down_event_, ev, velocity_x, velocity_y);
@@ skipping 59 matching lines @@
   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);
 
   two_finger_tap_enabled_ = config.two_finger_tap_enabled;
   two_finger_tap_distance_square_ = config.two_finger_tap_max_separation *
                                     config.two_finger_tap_max_separation;
   two_finger_tap_timeout_ = config.two_finger_tap_timeout;
+
+  DCHECK_GE(config.single_tap_repeat_interval, 1);
+  single_tap_repeat_interval_ = config.single_tap_repeat_interval;
 }
 
 void GestureDetector::OnShowPressTimeout() {
   listener_->OnShowPress(*current_down_event_);
 }
 
 void GestureDetector::OnLongPressTimeout() {
   timeout_handler_->StopTimeout(TAP);
   defer_confirm_single_tap_ = false;
   listener_->OnLongPress(*current_down_event_);
@@ skipping 15 matching lines @@
   velocity_tracker_.Clear();
   still_down_ = false;
 }
 
 void GestureDetector::CancelTaps() {
   timeout_handler_->Stop();
   is_double_tapping_ = false;
   always_in_tap_region_ = false;
   always_in_bigger_tap_region_ = false;
   defer_confirm_single_tap_ = false;
+  is_down_candidate_for_repeated_single_tap_ = false;
+  current_single_tap_repeat_count_ = 0;
 }
 
-bool GestureDetector::IsConsideredDoubleTap(
-    const MotionEvent& first_down,
-    const MotionEvent& first_up,
-    const MotionEvent& second_down) const {
+bool GestureDetector::IsRepeatedTap(const MotionEvent& first_down,
+                                    const MotionEvent& first_up,
+                                    const MotionEvent& second_down) const {
   if (!always_in_bigger_tap_region_)
     return false;
 
   const base::TimeDelta delta_time =
       second_down.GetEventTime() - first_up.GetEventTime();
-  if (delta_time < double_tap_min_time_ || delta_time > double_tap_timeout_)
+  if (delta_time > double_tap_timeout_)
+    return false;
+
+  // Only use the min time when in double-tap detection mode. For repeated
+  // single taps the risk of accidental repeat detection (e.g., from fingernail
+  // interference) is minimal.
+  if (double_tap_listener_ && delta_time < double_tap_min_time_)
     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_);
 }
 
 bool GestureDetector::HandleSwipeIfNeeded(const MotionEvent& up,
                                           float vx,
                                           float vy) {
@@ skipping 15 matching lines @@
     return false;
 
   if (vx_abs > vy_abs)
     vy = 0;
   else
     vx = 0;
   return listener_->OnSwipe(*current_down_event_, up, vx, vy);
 }
 
 }  // namespace ui