Corner Passthrough 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 "base/time/default_tick_clock.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/events/event.h"
 #include "ui/events/event_processor.h"
 #include "ui/events/event_utils.h"
 #include "ui/gfx/geometry/rect.h"
 
 #define SET_STATE(state) SetState(state, __func__)
 #define VLOG_EVENT(event) if (VLOG_IS_ON(0)) VlogEvent(event, __func__)
 
 namespace ui {
 
 namespace {
 
 // Delay between adjustment sounds.
 const base::TimeDelta kSoundDelay = base::TimeDelta::FromMilliseconds(150);
 
+// Delay before corner passthrough activates.
+const base::TimeDelta kCornerPassthroughDelay =
+    base::TimeDelta::FromMilliseconds(700);
+
 // In ChromeOS, VKEY_LWIN is synonymous for the search key.
 const ui::KeyboardCode kChromeOSSearchKey = ui::VKEY_LWIN;
 }  // namespace
 
 TouchExplorationController::TouchExplorationController(
     aura::Window* root_window,
     TouchExplorationControllerDelegate* delegate)
     : root_window_(root_window),
       delegate_(delegate),
       state_(NO_FINGERS_DOWN),
@@ skipping 31 matching lines @@
   // the timer.
   if (tap_timer_.IsRunning() &&
       touch_event.time_stamp() - initial_press_->time_stamp() >
           gesture_detector_config_.double_tap_timeout) {
     tap_timer_.Stop();
     OnTapTimerFired();
     // Note: this may change the state. We should now continue and process
     // this event under this new state.
   }
 
+  if (passthrough_timer_.IsRunning() &&
+      event.time_stamp() - initial_press_->time_stamp() >
+          gesture_detector_config_.longpress_timeout) {
+    passthrough_timer_.Stop();
+    OnPassthroughTimerFired();
+  }
+
   const ui::EventType type = touch_event.type();
   const gfx::PointF& location = touch_event.location_f();
   const int touch_id = touch_event.touch_id();
 
   // Always update touch ids and touch locations, so we can use those
   // no matter what state we're in.
   if (type == ui::ET_TOUCH_PRESSED) {
     current_touch_ids_.push_back(touch_id);
     touch_locations_.insert(std::pair<int, gfx::PointF>(touch_id, location));
   } else if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
@@ skipping 19 matching lines @@
     NOTREACHED() << "Unexpected event type received: " << event.name();
     return ui::EVENT_REWRITE_CONTINUE;
   }
   VLOG_EVENT(touch_event);
 
   // In order to avoid accidentally double tapping when moving off the edge
   // of the screen, the state will be rewritten to NoFingersDown.
   if ((type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) &&
       FindEdgesWithinBounds(touch_event.location(), kLeavingScreenEdge) !=
           NO_EDGE) {
+    if (VLOG_on_)
+      VLOG(0) << "Leaving screen";
+
+    // Indicates to the user that they are leaving the screen.
+    delegate_->PlayExitScreenEarcon();
+
     if (current_touch_ids_.size() == 0) {
       SET_STATE(NO_FINGERS_DOWN);
       if (VLOG_on_) {
         VLOG(0) << "Reset to no fingers in Rewrite event because the touch  "
                    "release or cancel was on the edge of the screen.";
       }
       return ui::EVENT_REWRITE_DISCARD;
     }
   }
 
@@ skipping 20 matching lines @@
     case DOUBLE_TAP_PENDING:
       return InDoubleTapPending(touch_event, rewritten_event);
     case TOUCH_RELEASE_PENDING:
       return InTouchReleasePending(touch_event, rewritten_event);
     case TOUCH_EXPLORATION:
       return InTouchExploration(touch_event, rewritten_event);
     case GESTURE_IN_PROGRESS:
       return InGestureInProgress(touch_event, rewritten_event);
     case TOUCH_EXPLORE_SECOND_PRESS:
       return InTouchExploreSecondPress(touch_event, rewritten_event);
+    case CORNER_PASSTHROUGH:
+      return InCornerPassthrough(touch_event, rewritten_event);
     case SLIDE_GESTURE:
       return InSlideGesture(touch_event, rewritten_event);
     case ONE_FINGER_PASSTHROUGH:
       return InOneFingerPassthrough(touch_event, rewritten_event);
     case WAIT_FOR_NO_FINGERS:
       return InWaitForNoFingers(touch_event, rewritten_event);
     case TWO_FINGER_TAP:
       return InTwoFingerTap(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) {
-  ui::EventType type = event.type();
-  if (type == ui::ET_TOUCH_PRESSED) {
-    initial_press_.reset(new TouchEvent(event));
-    initial_presses_[event.touch_id()] = event.location();
-    last_unused_finger_event_.reset(new TouchEvent(event));
-    StartTapTimer();
-    SET_STATE(SINGLE_TAP_PRESSED);
-    return ui::EVENT_REWRITE_DISCARD;
+  const ui::EventType type = event.type();
+  if (type != ui::ET_TOUCH_PRESSED) {
+    NOTREACHED() << "Unexpected event type received: " << event.name();
+    return ui::EVENT_REWRITE_CONTINUE;
   }
-  NOTREACHED() << "Unexpected event type received: " << event.name();
-  return ui::EVENT_REWRITE_CONTINUE;
+
+  // If the user enters the screen from the edge then send an earcon.
+  int edge = FindEdgesWithinBounds(event.location(), kLeavingScreenEdge);
+  if (edge != NO_EDGE)
+    delegate_->PlayEnterScreenEarcon();
+
+  int location = FindEdgesWithinBounds(event.location(), kSlopDistanceFromEdge);
+  // If the press was at a corner, the user might go into corner passthrough
+  // instead.
+  bool in_a_bottom_corner =
+      (BOTTOM_LEFT_CORNER == location) || (BOTTOM_RIGHT_CORNER == location);
+  if (in_a_bottom_corner) {
+    passthrough_timer_.Start(
+        FROM_HERE,
+        gesture_detector_config_.longpress_timeout,
+        this,
+        &TouchExplorationController::OnPassthroughTimerFired);
+  }
+  initial_press_.reset(new TouchEvent(event));
+  initial_presses_[event.touch_id()] = event.location();
+  last_unused_finger_event_.reset(new TouchEvent(event));
+  StartTapTimer();
+  SET_STATE(SINGLE_TAP_PRESSED);
+  return ui::EVENT_REWRITE_DISCARD;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InSingleTapPressed(
     const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
 
+  int location = FindEdgesWithinBounds(event.location(), kMaxDistanceFromEdge);
+  bool in_a_bottom_corner =
+      (location == BOTTOM_LEFT_CORNER) || (location == BOTTOM_RIGHT_CORNER);
+  // If the event is from the initial press and the location is no longer in the
+  // corner, then we are not waiting for a corner passthrough anymore.
+  if (event.touch_id() == initial_press_->touch_id() && !in_a_bottom_corner) {
+    if (passthrough_timer_.IsRunning()) {
+      passthrough_timer_.Stop();
+      // Since the long press timer has been running, it is possible that the
+      // tap timer has timed out before the long press timer has. If the tap
+      // timer timeout has elapsed, then fire the tap timer.
+      if (event.time_stamp() - initial_press_->time_stamp() >
+          gesture_detector_config_.double_tap_timeout) {
+        OnTapTimerFired();
+      }
+    }
+  }
+
   if (type == ui::ET_TOUCH_PRESSED) {
     initial_presses_[event.touch_id()] = event.location();
     SET_STATE(TWO_FINGER_TAP);
     return EVENT_REWRITE_DISCARD;
   } else if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
+    if (passthrough_timer_.IsRunning())
+      passthrough_timer_.Stop();
     if (current_touch_ids_.size() == 0 &&
         event.touch_id() == initial_press_->touch_id()) {
       SET_STATE(SINGLE_TAP_RELEASED);
     } else if (current_touch_ids_.size() == 0) {
       SET_STATE(NO_FINGERS_DOWN);
     }
     return EVENT_REWRITE_DISCARD;
   } else if (type == ui::ET_TOUCH_MOVED) {
     float distance = (event.location() - initial_press_->location()).Length();
     // If the user does not move far enough from the original position, then the
     // resulting movement should not be considered to be a deliberate gesture or
     // touch exploration.
     if (distance <= gesture_detector_config_.touch_slop)
       return EVENT_REWRITE_DISCARD;
 
     float delta_time =
         (event.time_stamp() - initial_press_->time_stamp()).InSecondsF();
     float velocity = distance / delta_time;
     if (VLOG_on_) {
       VLOG(0) << "\n Delta time: " << delta_time << "\n Distance: " << distance
               << "\n Velocity of click: " << velocity
               << "\n Minimum swipe velocity: "
               << gesture_detector_config_.minimum_swipe_velocity;
     }
     // Change to slide gesture if the slide occurred at the right edge.
     int edge = FindEdgesWithinBounds(event.location(), kMaxDistanceFromEdge);
-    if (edge & RIGHT_EDGE) {
+    if (edge & RIGHT_EDGE && edge != BOTTOM_RIGHT_CORNER) {
       SET_STATE(SLIDE_GESTURE);
       return InSlideGesture(event, rewritten_event);
     }
 
     // If the user moves fast enough from the initial touch location, start
     // gesture detection. Otherwise, jump to the touch exploration mode early.
     if (velocity > gesture_detector_config_.minimum_swipe_velocity) {
       SET_STATE(GESTURE_IN_PROGRESS);
       return InGestureInProgress(event, rewritten_event);
     }
@@ skipping 148 matching lines @@
   // The events were sent to the gesture provider in RewriteEvent already.
   // If no gesture is registered before the tap timer times out, the state
   // will change to "wait for no fingers down" or "touch exploration" depending
   // on the number of fingers down, and this function will stop being called.
   if (current_touch_ids_.size() == 0) {
     SET_STATE(NO_FINGERS_DOWN);
   }
   return ui::EVENT_REWRITE_DISCARD;
 }
 
+ui::EventRewriteStatus TouchExplorationController::InCornerPassthrough(
+    const ui::TouchEvent& event,
+    scoped_ptr<ui::Event>* rewritten_event) {
+  ui::EventType type = event.type();
+
+  // If the first finger has left the corner, then exit passthrough.
+  if (event.touch_id() == initial_press_->touch_id()) {
+    int edges = FindEdgesWithinBounds(event.location(), kSlopDistanceFromEdge);
+    bool in_a_bottom_corner = (edges == BOTTOM_LEFT_CORNER) ||
+                              (edges == BOTTOM_RIGHT_CORNER);
+    if (type == ui::ET_TOUCH_MOVED && in_a_bottom_corner)
+      return ui::EVENT_REWRITE_DISCARD;
+
+    if (current_touch_ids_.size() == 0) {
+      SET_STATE(NO_FINGERS_DOWN);
+      return ui::EVENT_REWRITE_DISCARD;
+    }
+    SET_STATE(WAIT_FOR_NO_FINGERS);
+    return ui::EVENT_REWRITE_DISCARD;
+  }
+
+  rewritten_event->reset(new ui::TouchEvent(
+      type, event.location(), event.touch_id(), event.time_stamp()));
+  (*rewritten_event)->set_flags(event.flags());
+
+  if (current_touch_ids_.size() == 0)
+    SET_STATE(NO_FINGERS_DOWN);
+
+  return ui::EVENT_REWRITE_REWRITTEN;
+}
+
 ui::EventRewriteStatus TouchExplorationController::InOneFingerPassthrough(
     const ui::TouchEvent& event,
     scoped_ptr<ui::Event>* rewritten_event) {
   if (event.touch_id() != initial_press_->touch_id()) {
     if (current_touch_ids_.size() == 0) {
       SET_STATE(NO_FINGERS_DOWN);
     }
     return ui::EVENT_REWRITE_DISCARD;
   }
   rewritten_event->reset(
@@ skipping 51 matching lines @@
 
 ui::EventRewriteStatus TouchExplorationController::InWaitForNoFingers(
     const ui::TouchEvent& event,
     scoped_ptr<ui::Event>* rewritten_event) {
   if (current_touch_ids_.size() == 0)
     SET_STATE(NO_FINGERS_DOWN);
   return EVENT_REWRITE_DISCARD;
 }
 
 void TouchExplorationController::PlaySoundForTimer() {
-  delegate_->PlayVolumeAdjustSound();
+  delegate_->PlayVolumeAdjustEarcon();
 }
 
 ui::EventRewriteStatus TouchExplorationController::InSlideGesture(
     const ui::TouchEvent& event,
     scoped_ptr<ui::Event>* rewritten_event) {
   // The timer should not fire when sliding.
   tap_timer_.Stop();
 
   ui::EventType type = event.type();
   // If additional fingers are added before a swipe gesture has been registered,
@@ skipping 19 matching lines @@
     return EVENT_REWRITE_DISCARD;
   }
 
   // This can occur if the user leaves the screen edge and then returns to it to
   // continue adjusting the sound.
   if (!sound_timer_.IsRunning()) {
     sound_timer_.Start(FROM_HERE,
                        kSoundDelay,
                        this,
                        &ui::TouchExplorationController::PlaySoundForTimer);
-    delegate_->PlayVolumeAdjustSound();
+    delegate_->PlayVolumeAdjustEarcon();
   }
 
   if (current_touch_ids_.size() == 0) {
     SET_STATE(NO_FINGERS_DOWN);
   }
   return ui::EVENT_REWRITE_DISCARD;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InTwoFingerTap(
     const ui::TouchEvent& event,
@@ skipping 66 matching lines @@
                             last_touch_exploration_->location();
       scoped_ptr<ui::TouchEvent> passthrough_press(
           new ui::TouchEvent(ui::ET_TOUCH_PRESSED,
                              last_touch_exploration_->location(),
                              last_unused_finger_event_->touch_id(),
                              Now()));
       DispatchEvent(passthrough_press.get());
       return;
     }
     case SINGLE_TAP_PRESSED:
-      EnterTouchToMouseMode();
-      SET_STATE(TOUCH_EXPLORATION);
-      break;
+      if (passthrough_timer_.IsRunning())
+        return;
     case GESTURE_IN_PROGRESS:
       // If only one finger is down, go into touch exploration.
       if (current_touch_ids_.size() == 1) {
-        EnterTouchToMouseMode();
         SET_STATE(TOUCH_EXPLORATION);
         break;
       }
       // Otherwise wait for all fingers to be lifted.
       SET_STATE(WAIT_FOR_NO_FINGERS);
       return;
     case TWO_FINGER_TAP:
       SET_STATE(WAIT_FOR_NO_FINGERS);
       break;
     default:
       return;
   }
   EnterTouchToMouseMode();
   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::OnPassthroughTimerFired() {
+  // The passthrough timer will only fire if if the user has held a finger in
+  // one of the passthrough corners for the duration of the passthrough timeout.
+
+  // Check that initial press isn't null. Also a check that if the initial
+  // corner press was released, then it should not be in corner passthrough.
+  if (!initial_press_ ||
+      touch_locations_.find(initial_press_->touch_id()) !=
+          touch_locations_.end()) {
+    LOG(ERROR) << "No initial press or the initial press has been released.";
+  }
+
+  gfx::Point location =
+      ToRoundedPoint(touch_locations_[initial_press_->touch_id()]);
+  int corner = FindEdgesWithinBounds(location, kSlopDistanceFromEdge);
+  if (corner != BOTTOM_LEFT_CORNER && corner != BOTTOM_RIGHT_CORNER)
+    return;
+
+  if (sound_timer_.IsRunning())
+    sound_timer_.Stop();
+  delegate_->PlayPassthroughEarcon();
+  SET_STATE(CORNER_PASSTHROUGH);
+  return;
+}
+
 void TouchExplorationController::DispatchEvent(ui::Event* event) {
   ui::EventDispatchDetails result ALLOW_UNUSED =
       root_window_->GetHost()->dispatcher()->OnEventFromSource(event);
 }
 
 // This is an override for a function that is only called for timer-based events
 // like long press. Events that are created synchronously as a result of
 // certain touch events are added to the vector accessible via
 // GetAndResetPendingGestures(). We only care about swipes (which are created
 // synchronously), so we ignore this callback.
@@ skipping 20 matching lines @@
         SideSlideControl(*i);
       }
     }
   }
 }
 
 void TouchExplorationController::SideSlideControl(ui::GestureEvent* gesture) {
   ui::EventType type = gesture->type();
 
   if (type == ET_GESTURE_SCROLL_BEGIN) {
-    delegate_->PlayVolumeAdjustSound();
+    delegate_->PlayVolumeAdjustEarcon();
   }
 
   if (type == ET_GESTURE_SCROLL_END) {
     if (sound_timer_.IsRunning())
       sound_timer_.Stop();
-    delegate_->PlayVolumeAdjustSound();
+    delegate_->PlayVolumeAdjustEarcon();
   }
 
   // If the user is in the corner of the right side of the screen, the volume
   // will be automatically set to 100% or muted depending on which corner they
   // are in. Otherwise, the user will be able to adjust the volume by sliding
   // their finger along the right side of the screen. Volume is relative to
   // where they are on the right side of the screen.
   gfx::Point location = gesture->location();
   int edge = FindEdgesWithinBounds(location, kSlopDistanceFromEdge);
   if (!(edge & RIGHT_EDGE))
@@ skipping 178 matching lines @@
   // gesture provider still exists, it's reset to NULL until the user returns
   // to NO_FINGERS_DOWN.
   switch (new_state) {
     case SINGLE_TAP_RELEASED:
     case TOUCH_EXPLORE_RELEASED:
     case DOUBLE_TAP_PENDING:
     case TOUCH_RELEASE_PENDING:
     case TOUCH_EXPLORATION:
     case TOUCH_EXPLORE_SECOND_PRESS:
     case ONE_FINGER_PASSTHROUGH:
+    case CORNER_PASSTHROUGH:
     case WAIT_FOR_NO_FINGERS:
       if (gesture_provider_.get())
         gesture_provider_.reset(NULL);
       break;
     case NO_FINGERS_DOWN:
       gesture_provider_.reset(new GestureProviderAura(this));
       if (sound_timer_.IsRunning())
         sound_timer_.Stop();
       tap_timer_.Stop();
       break;
@@ skipping 59 matching lines @@
     case DOUBLE_TAP_PENDING:
       return "DOUBLE_TAP_PENDING";
     case TOUCH_RELEASE_PENDING:
       return "TOUCH_RELEASE_PENDING";
     case TOUCH_EXPLORATION:
       return "TOUCH_EXPLORATION";
     case GESTURE_IN_PROGRESS:
       return "GESTURE_IN_PROGRESS";
     case TOUCH_EXPLORE_SECOND_PRESS:
       return "TOUCH_EXPLORE_SECOND_PRESS";
+    case CORNER_PASSTHROUGH:
+      return "CORNER_PASSTHROUGH";
     case SLIDE_GESTURE:
       return "SLIDE_GESTURE";
     case ONE_FINGER_PASSTHROUGH:
       return "ONE_FINGER_PASSTHROUGH";
     case WAIT_FOR_NO_FINGERS:
       return "WAIT_FOR_NO_FINGERS";
     case TWO_FINGER_TAP:
       return "TWO_FINGER_TAP";
   }
   return "Not a state";
@@ skipping 36 matching lines @@
   left_swipe_gestures_[4] =
       BindKeyEventWithFlags(ui::VKEY_BRIGHTNESS_DOWN, ui::EF_NONE);
   right_swipe_gestures_[4] =
       BindKeyEventWithFlags(VKEY_BRIGHTNESS_UP, ui::EF_NONE);
   up_swipe_gestures_[4] = BindKeyEventWithFlags(VKEY_BROWSER_HOME, ui::EF_NONE);
   down_swipe_gestures_[4] =
       BindKeyEventWithFlags(VKEY_BROWSER_REFRESH, ui::EF_NONE);
 }
 
 }  // namespace ui