Corner Passthrough for Accessibility

ui/chromeos/touch_exploration_controller.h

 // 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.
 
 #ifndef UI_CHROMEOS_TOUCH_EXPLORATION_CONTROLLER_H_
 #define UI_CHROMEOS_TOUCH_EXPLORATION_CONTROLLER_H_
 
 #include "base/timer/timer.h"
 #include "base/values.h"
 #include "ui/chromeos/ui_chromeos_export.h"
@@ skipping 14 matching lines @@
 class GestureEvent;
 class GestureProviderAura;
 class TouchEvent;
 
 // A delegate to handle commands in response to detected accessibility gesture
 // events.
 class TouchExplorationControllerDelegate {
  public:
   virtual ~TouchExplorationControllerDelegate() {}
 
-  // This function should be called whenever the delegate wants to play a sound
-  // when the volume adjusts.
-  virtual void PlayVolumeAdjustSound() = 0;
-
   // Takes an int from 0.0 to 100.0 that indicates the percent the volume
   // should be set to.
   virtual void SetOutputLevel(int volume) = 0;
+
+  // This function should be called when the volume adjust earcon should be
+  // played
+  virtual void PlayVolumeAdjustEarcon() = 0;
+
+  // This function should be called when the passthrough earcon should be
+  // played.
+  virtual void PlayPassthroughEarcon() = 0;
+
+  // This function should be called when the exit screen earcon should be
+  // played.
+  virtual void PlayExitScreenEarcon() = 0;
+
+  // This function should be called when the enter screen earcon should be
+  // played.
+  virtual void PlayEnterScreenEarcon() = 0;
 };
 
 // TouchExplorationController is used in tandem with "Spoken Feedback" to
 // make the touch UI accessible. Gestures performed in the middle of the screen
 // are mapped to accessiblity key shortcuts while gestures performed on the edge
 // of the screen can change settings.
 //
 // ** Short version **
 //
 // At a high-level, single-finger events are used for accessibility -
 // exploring the screen gets turned into mouse moves (which can then be
 // spoken by an accessibility service running), a single tap while the user
 // is in touch exploration or a double-tap simulates a click, and gestures
 // can be used to send high-level accessibility commands. For example, a swipe
 // right would correspond to the keyboard short cut shift+search+right.
 // When two or more fingers are pressed initially, from then on the events
 // are passed through, but with the initial finger removed - so if you swipe
-// down with two fingers, the running app will see a one-finger swipe. Slide
+// down with two fingers, the running app will see a one-finger swipe. If the
+// user holds down the corner of the screen until an earcon sounds, all
+// subsequent fingers will also be passed through in a similar manner. Slide
 // gestures performed on the edge of the screen can change settings
 // continuously. For example, sliding a finger along the right side of the
 // screen will change the volume.
 //
 // ** Long version **
 //
 // Here are the details of the implementation:
 //
 // When the first touch is pressed, a 300 ms grace period timer starts.
 //
@@ skipping 88 matching lines @@
   ui::EventRewriteStatus InSingleTapPressed(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InSingleTapOrTouchExploreReleased(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InDoubleTapPressed(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InTouchExploration(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InTwoToOneFinger(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
+  ui::EventRewriteStatus InCornerPassthrough(
+      const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InPassthrough(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InGestureInProgress(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InTouchExploreSecondPress(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InWaitForRelease(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InSlideGesture(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
 
-  // This timer is started every time we get the first press event, and
-  // it fires after the double-click timeout elapses (300 ms by default).
+  // This timer is started every time we get the first press event and the
+  // finger is not in the corner of the screen.
+  // It fires after the double-click timeout elapses (300 ms by default).
   // If the user taps and releases within 300 ms and doesn't press again,
-  // we treat that as a single mouse move (touch exploration) event.
+  // we treat that as a single mouse move (touch exploration) event. If the user
+  // completes a swipe gesture within 300 ms, then the gesture is processed.
   void OnTapTimerFired();
 
+  // This timer is started every timer we get the first press event and the
+  // finger is in the corner of the screen.
+  // It fires after the long_press timeout elapses (500 ms by default). If the
+  // user is still in the corner by the time this timre fires, all subsequent
+  // fingers added on the screen will be passed through.
+  void OnLongPressTimerFired();
+
   // Dispatch a new event outside of the event rewriting flow.
   void DispatchEvent(ui::Event* event);
 
   // Overridden from GestureProviderAuraClient.
   //
   // The gesture provider keeps track of all the touch events after
   // the user moves fast enough to trigger a gesture. After the user
   // completes their gesture, this method will decide what keyboard
   // input their gesture corresponded to.
   virtual void OnGestureEvent(ui::GestureEvent* gesture) OVERRIDE;
@@ skipping 83 matching lines @@
     // touch explore. Any fingers pressed past the first two are ignored.
     TOUCH_EXPLORE_SECOND_PRESS,
 
     // The user placed two fingers down within the grace period.
     // We're now in two to one finger mode until one of the fingers is
     // lifted. The first finger is ignored and the events for the second
     // finger are passed throuugh. If either finger is released, nothing
     // happens until all fingers are up.
     TWO_TO_ONE_FINGER,
 
+    // If the user has pressed and held down the left corner past long press,
+    // then as long as they are holding the corner, all subsequent fingers
+    // registered will be in passthrough.
+    CORNER_PASSTHROUGH,
+
     // If the user is in TWO_TO_ONE_FINGER with two fingers down and presses
     // a third finger, every finger and touch event is passed through until
     // all fingers are released.
     PASSTHROUGH,
 
     // If the user lifted a finger in TWO_TO_ONE_FINGER, they must release
     // all fingers before completing any more actions. This state is
     // generally useful for developing new features, because it creates a
     // simple way to handle a dead end in user flow.
     WAIT_FOR_RELEASE,
 
     // If the user is within the given bounds from an edge of the screen, not
     // including corners, then the resulting movements will be interpreted as
     // slide gestures.
     SLIDE_GESTURE,
   };
 
   enum ScreenLocation {
     // Hot "edges" of the screen are each represented by a respective bit.
     NO_EDGE = 0,
     RIGHT_EDGE = 1 << 0,
     TOP_EDGE = 1 << 1,
     LEFT_EDGE = 1 << 2,
     BOTTOM_EDGE = 1 << 3,
+    BOTTOM_LEFT_CORNER = LEFT_EDGE | BOTTOM_EDGE,
+    BOTTOM_RIGHT_CORNER = RIGHT_EDGE | BOTTOM_EDGE,
   };
 
   // Given a point, if it is within the given bounds of an edge, returns the
   // edge. If it is within the given bounds of two edges, returns an int with
   // both bits that represent the respective edges turned on. Otherwise returns
   // SCREEN_CENTER.
   int FindEdgesWithinBounds(gfx::Point point, float bounds);
 
   void VlogState(const char* function_name);
 
@@ skipping 26 matching lines @@
 
   // The last synthesized mouse move event. When the user double-taps,
   // we send the passed-through tap to the location of this event.
   scoped_ptr<ui::TouchEvent> last_touch_exploration_;
 
   // The last event from the finger that is being passed through in
   // TWO_TO_ONE_FINGER. When the user lifts a finger during two to one,
   // the location and id of the touch release is from here.
   scoped_ptr<ui::TouchEvent> last_two_to_one_;
 
-  // A timer to fire the mouse move event after the double-tap delay.
+  // A timer that fires after a long press delay.
+  base::OneShotTimer<TouchExplorationController> long_press_timer_;
+
+  // A timer that fires after a double tap delay.
   base::OneShotTimer<TouchExplorationController> tap_timer_;
 
   // A timer to fire an indicating sound when sliding to change volume.
   base::RepeatingTimer<TouchExplorationController> sound_timer_;
 
   // For testing only, an event handler to use for generated events
   // outside of the normal event rewriting flow.
   ui::EventHandler* event_handler_for_testing_;
 
   // A default gesture detector config, so we can share the same
   // timeout and pixel slop constants.
   ui::GestureDetector::Config gesture_detector_config_;
 
   // Gesture Handler to interpret the touch events.
   ui::GestureProviderAura gesture_provider_;
 
   // The previous state entered.
   State prev_state_;
 
   // A copy of the previous event passed.
   scoped_ptr<ui::TouchEvent> prev_event_;
 
   // This toggles whether VLOGS are turned on or not.
   bool VLOG_on_;
 
+  // Indicates if a finger is in the lower left corner waiting for the timer to
+  // run out.
+  bool waiting_for_corner_passthrough_;
+
   DISALLOW_COPY_AND_ASSIGN(TouchExplorationController);
 };
 
 }  // namespace ui
 
 #endif  // UI_CHROMEOS_TOUCH_EXPLORATION_CONTROLLER_H_