Swipe Gestures for Accessibility

ui/chromeos/touch_exploration_controller.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/chromeos/touch_exploration_controller.h"
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/window.h"
@@ skipping 21 matching lines @@
 // until all fingers are released.
 const int kTouchIdNone = -1;
 }  // namespace
 
 TouchExplorationController::TouchExplorationController(
     aura::Window* root_window)
     : root_window_(root_window),
       initial_touch_id_passthrough_mapping_(kTouchIdUnassigned),
       state_(NO_FINGERS_DOWN),
       event_handler_for_testing_(NULL),
+      gesture_provider_(this),
       prev_state_(NO_FINGERS_DOWN) {
   CHECK(root_window);
   root_window->GetHost()->GetEventSource()->AddEventRewriter(this);
 }
 
 TouchExplorationController::~TouchExplorationController() {
   root_window_->GetHost()->GetEventSource()->RemoveEventRewriter(this);
 }
 
 void TouchExplorationController::CallTapTimerNowForTesting() {
@@ skipping 68 matching lines @@
     case NO_FINGERS_DOWN:
       return InNoFingersDown(touch_event, rewritten_event);
     case SINGLE_TAP_PRESSED:
       return InSingleTapPressed(touch_event, rewritten_event);
     case SINGLE_TAP_RELEASED:
       return InSingleTapReleased(touch_event, rewritten_event);
     case DOUBLE_TAP_PRESSED:
       return InDoubleTapPressed(touch_event, rewritten_event);
     case TOUCH_EXPLORATION:
       return InTouchExploration(touch_event, rewritten_event);
+    case GESTURE_IN_PROGRESS:
+      return InGestureInProgress(touch_event, rewritten_event);
     case PASSTHROUGH_MINUS_ONE:
       return InPassthroughMinusOne(touch_event, rewritten_event);
     case TOUCH_EXPLORE_SECOND_PRESS:
       return InTouchExploreSecondPress(touch_event, rewritten_event);
   }
 
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::NextDispatchEvent(
     const ui::Event& last_event, scoped_ptr<ui::Event>* new_event) {
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InNoFingersDown(
     const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
   if (type == ui::ET_TOUCH_PRESSED) {
     initial_press_.reset(new TouchEvent(event));
     tap_timer_.Start(FROM_HERE,
                      gesture_detector_config_.double_tap_timeout,
                      this,
                      &TouchExplorationController::OnTapTimerFired);
+    gesture_provider_.OnTouchEvent(event);
+    gesture_provider_.OnTouchEventAck(false);
     state_ = SINGLE_TAP_PRESSED;
     VLOG_STATE();
     return ui::EVENT_REWRITE_DISCARD;
   }
 
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InSingleTapPressed(
     const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
 
   if (type == ui::ET_TOUCH_PRESSED) {
     // Adding a second finger within the timeout period switches to
     // passthrough.
     state_ = PASSTHROUGH_MINUS_ONE;
     return InPassthroughMinusOne(event, rewritten_event);
   } else if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
     DCHECK_EQ(0U, current_touch_ids_.size());
     state_ = SINGLE_TAP_RELEASED;
     VLOG_STATE();
     return EVENT_REWRITE_DISCARD;
   } else if (type == ui::ET_TOUCH_MOVED) {
-    // If the user moves far enough from the initial touch location (outside
-    // the "slop" region, jump to the touch exploration mode early.
-    // TODO(evy, lisayin): Add gesture recognition here instead -
-    // we should probably jump to gesture mode here if the velocity is
-    // high enough, and touch exploration if the velocity is lower.
-    float delta = (event.location() - initial_press_->location()).Length();
-    if (delta > gesture_detector_config_.touch_slop) {
-      EnterTouchToMouseMode();
-      state_ = TOUCH_EXPLORATION;
-      VLOG_STATE();
-      return InTouchExploration(event, rewritten_event);
+    float delta_time =
+        (event.time_stamp() - initial_press_->time_stamp()).InSecondsF();
+    float delta_distance =
+        (event.location() - initial_press_->location()).Length();
+    float velocity = delta_distance / delta_time;
+    VLOG(0) << "\n Delta time: " << delta_time
+            << "\n Delta distance: " << delta_distance
+            << "\n Velocity of click: " << velocity
+            << "\n Minimum swipe velocity: "
+            << gesture_detector_config_.minimum_swipe_velocity;
+    if (delta_distance > gesture_detector_config_.touch_slop) {
+    // If the user moves fast enough and far enough

[dmazzoni, 2014/06/23 15:50:44]

Nit: indent the comment to match inside the block.

+    // from the initial touch location, start gesture detection
+      if (velocity > gesture_detector_config_.minimum_swipe_velocity) {
+        state_ = GESTURE_IN_PROGRESS;
+        VLOG_STATE();
+        return InGestureInProgress(event, rewritten_event);
+      }
+      // Otherwise, if the user moves far enough from the initial touch location

[dmazzoni, 2014/06/23 15:50:44]

Nit: don't put comments in-between the final } of the last block and the else,
to avoid any possible confusion. I suggest you put both comments inside the
blocks rather than outside.

+      // outside the "slop" region, jump to the touch exploration mode early.
+      else {
+        EnterTouchToMouseMode();
+        state_ = TOUCH_EXPLORATION;
+        VLOG_STATE();
+        return InTouchExploration(event, rewritten_event);
+      }
     }
-
     return EVENT_REWRITE_DISCARD;
   }
   NOTREACHED() << "Unexpected event type received.";
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InSingleTapReleased(
     const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
   if (type == ui::ET_TOUCH_PRESSED) {
@@ skipping 74 matching lines @@
     NOTREACHED() << "Unexpected event type received.";
     return ui::EVENT_REWRITE_CONTINUE;
   }
 
   // Rewrite as a mouse-move event.
   *rewritten_event = CreateMouseMoveEvent(event.location(), event.flags());
   last_touch_exploration_.reset(new TouchEvent(event));
   return ui::EVENT_REWRITE_REWRITTEN;
 }
 
+ui::EventRewriteStatus TouchExplorationController::InGestureInProgress(
+    const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event) {
+  ui::EventType type = event.type();
+  gfx::PointF location = event.location_f();
+  if (type == ui::ET_TOUCH_PRESSED) {
+    return EVENT_REWRITE_DISCARD;
+  }
+  if (type == ui::ET_TOUCH_MOVED) {
+    gesture_provider_.OnTouchEvent(event);

[dmazzoni, 2014/06/23 15:50:44]

If you're throwing away "pressed" events for any fingers other than the first, i
don't think you should pass those events to the gesture provider from other
fingers.

[lisayin, 2014/06/23 16:48:43]

Just to clarify, I should check the id of the event and only process the events
that match the id of the initial press.

+    gesture_provider_.OnTouchEventAck(false);
+   }
+  if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
+    gesture_provider_.OnTouchEvent(event);
+    gesture_provider_.OnTouchEventAck(true);
+    if (current_touch_ids_.size() == 0)
+      ResetToNoFingersDown();
+  }
+  return ui::EVENT_REWRITE_DISCARD;
+}
+
 ui::EventRewriteStatus TouchExplorationController::InPassthroughMinusOne(
     const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event) {
   ui::EventType type = event.type();
   gfx::PointF location = event.location_f();
 
   if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
     if (current_touch_ids_.size() == 0)
       ResetToNoFingersDown();
 
     if (initial_touch_id_passthrough_mapping_ == kTouchIdUnassigned) {
@@ skipping 72 matching lines @@
     (*rewritten_event)->set_flags(event.flags());
     state_ = TOUCH_EXPLORATION;
     VLOG_STATE();
     return ui::EVENT_REWRITE_REWRITTEN;
   }
   NOTREACHED() << "Unexpected event type received.";
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 void TouchExplorationController::OnTapTimerFired() {
-  if (state_ != SINGLE_TAP_RELEASED && state_ != SINGLE_TAP_PRESSED)
+  if (state_ != SINGLE_TAP_RELEASED && state_ != SINGLE_TAP_PRESSED &&

[dmazzoni, 2014/06/23 15:50:44]

Nit: for readability, when there are multiple lines of a conditional, put one
condition on each line, like this - and use braces around the "return" (whenever
either the conditional or the block is multi-line).

if (state_ != SINGLE_TAP_RELEASED &&
    state_ != SINGLE_TAP_PRESSED &&
    state_ != GESTURE_IN_PROGRESS) {
  return;
}

+      state_ != GESTURE_IN_PROGRESS)
     return;
 
   if (state_ == SINGLE_TAP_RELEASED) {
     ResetToNoFingersDown();
   } else {
     EnterTouchToMouseMode();
+    // Discard any pending gestures
+    delete gesture_provider_.GetAndResetPendingGestures();
     state_ = TOUCH_EXPLORATION;
     VLOG_STATE();
   }
 
   scoped_ptr<ui::Event> mouse_move = CreateMouseMoveEvent(
       initial_press_->location(), initial_press_->flags());
   DispatchEvent(mouse_move.get());
   last_touch_exploration_.reset(new TouchEvent(*initial_press_));
 }
 
 void TouchExplorationController::DispatchEvent(ui::Event* event) {
   if (event_handler_for_testing_) {
     event_handler_for_testing_->OnEvent(event);
     return;
   }
 
   ui::EventDispatchDetails result ALLOW_UNUSED =
       root_window_->GetHost()->dispatcher()->OnEventFromSource(event);
 }
 
+void TouchExplorationController::OnGestureEvent(ui::GestureEvent* gesture) {
+  CHECK(gesture->IsGestureEvent());
+  VLOG(0) << " \n Gesture Triggered: " << gesture->name();
+}
+
 scoped_ptr<ui::Event> TouchExplorationController::CreateMouseMoveEvent(
     const gfx::PointF& location,
     int flags) {
   return scoped_ptr<ui::Event>(
       new ui::MouseEvent(
           ui::ET_MOUSE_MOVED,
           location,
           location,
           flags | ui::EF_IS_SYNTHESIZED | ui::EF_TOUCH_ACCESSIBILITY,
           0));
 }
 
 void TouchExplorationController::EnterTouchToMouseMode() {
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(root_window_);
   if (cursor_client && !cursor_client->IsMouseEventsEnabled())
     cursor_client->EnableMouseEvents();
   if (cursor_client && cursor_client->IsCursorVisible())
     cursor_client->HideCursor();
 }
 
 void TouchExplorationController::ResetToNoFingersDown() {
+  scoped_ptr<ScopedVector<ui::GestureEvent> > gestures;
+  gestures.reset(gesture_provider_.GetAndResetPendingGestures());
+  if (gestures != NULL) {
+    for (ScopedVector<GestureEvent>::iterator i = gestures->begin();
+         i != gestures->end();
+         ++i) {
+      OnGestureEvent(*i);
+    }
+  }
   state_ = NO_FINGERS_DOWN;
   initial_touch_id_passthrough_mapping_ = kTouchIdUnassigned;
   VLOG_STATE();
   if (tap_timer_.IsRunning())
     tap_timer_.Stop();
 }
 
 void TouchExplorationController::VlogState(const char* function_name) {
   if (prev_state_ == state_)
     return;
@@ skipping 26 matching lines @@
     case NO_FINGERS_DOWN:
       return "NO_FINGERS_DOWN";
     case SINGLE_TAP_PRESSED:
       return "SINGLE_TAP_PRESSED";
     case SINGLE_TAP_RELEASED:
       return "SINGLE_TAP_RELEASED";
     case DOUBLE_TAP_PRESSED:
       return "DOUBLE_TAP_PRESSED";
     case TOUCH_EXPLORATION:
       return "TOUCH_EXPLORATION";
+    case GESTURE_IN_PROGRESS:
+      return "GESTURE_IN_PROGRESS";
     case PASSTHROUGH_MINUS_ONE:
       return "PASSTHROUGH_MINUS_ONE";
     case TOUCH_EXPLORE_SECOND_PRESS:
       return "TOUCH_EXPLORE_SECOND_PRESS";
   }
   return "Not a state";
 }
 
 std::string TouchExplorationController::EnumEventTypeToString(
     ui::EventType type) {
   // Add more cases later. For now, these are the most frequently seen
   // event types.
   switch (type) {
     case ET_TOUCH_RELEASED:
       return "ET_TOUCH_RELEASED";
     case ET_TOUCH_PRESSED:
       return "ET_TOUCH_PRESSED";
     case ET_TOUCH_MOVED:
       return "ET_TOUCH_MOVED";
     case ET_TOUCH_CANCELLED:
       return "ET_TOUCH_CANCELLED";
     default:
       return base::IntToString(type);
   }
 }
 
 }  // namespace ui