Home | History | Annotate | Download | only in chromoting 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 package org.chromium.chromoting;
      6 
      7 import android.content.Context;
      8 import android.view.MotionEvent;
      9 import android.view.ViewConfiguration;
     10 
     11 /**
     12  * Helper class for disambiguating whether to treat a two-finger gesture as a swipe or a pinch.
     13  * Initially, the status will be unknown, until the fingers have moved sufficiently far to
     14  * determine the intent.
     15  */
     16 public class SwipePinchDetector {
     17     /** Current state of the gesture. */
     18     private enum State {
     19         UNKNOWN,
     20         SWIPE,
     21         PINCH
     22     }
     23     private State mState = State.UNKNOWN;
     24 
     25     /** Initial coordinates of the two pointers in the current gesture. */
     26     private float mFirstX0;
     27     private float mFirstY0;
     28     private float mFirstX1;
     29     private float mFirstY1;
     30 
     31     /**
     32      * The initial coordinates above are valid when this flag is set. Used to determine whether a
     33      * MotionEvent's pointer coordinates are the first ones of the gesture.
     34      */
     35     private boolean mInGesture = false;
     36 
     37     /**
     38      * Threshold squared-distance, in pixels, to use for motion-detection.
     39      */
     40     private int mTouchSlopSquare;
     41 
     42     private void reset() {
     43         mState = State.UNKNOWN;
     44         mInGesture = false;
     45     }
     46 
     47     /** Construct a new detector, using the context to determine movement thresholds. */
     48     public SwipePinchDetector(Context context) {
     49         ViewConfiguration config = ViewConfiguration.get(context);
     50         int touchSlop = config.getScaledTouchSlop();
     51         mTouchSlopSquare = touchSlop * touchSlop;
     52     }
     53 
     54     /** Returns whether a swipe is in progress. */
     55     public boolean isSwiping() {
     56         return mState == State.SWIPE;
     57     }
     58 
     59     /** Returns whether a pinch is in progress. */
     60     public boolean isPinching() {
     61         return mState == State.PINCH;
     62     }
     63 
     64     /**
     65      * Analyzes the touch event to determine whether the user is swiping or pinching. Only
     66      * motion events with 2 pointers are considered here. Once the gesture is determined to be a
     67      * swipe or a pinch, further 2-finger motion-events will be ignored. When a different event is
     68      * passed in (motion event with != 2 pointers, or some other event type), this object will
     69      * revert back to the original UNKNOWN state.
     70      */
     71     public void onTouchEvent(MotionEvent event) {
     72         if (event.getPointerCount() != 2) {
     73             reset();
     74             return;
     75         }
     76 
     77         // Only MOVE or DOWN events are considered - all other events should finish any current
     78         // gesture and reset the detector. In addition, a DOWN event should reset the detector,
     79         // since it signals the start of the gesture. If the events are consistent, a DOWN event
     80         // will occur at the start of the gesture, but this implementation tries to cope in case
     81         // the first event is MOVE rather than DOWN.
     82         int action = event.getActionMasked();
     83         if (action != MotionEvent.ACTION_MOVE) {
     84             reset();
     85             if (action != MotionEvent.ACTION_POINTER_DOWN) {
     86                 return;
     87             }
     88         }
     89 
     90         // If the gesture is known, there is no need for further processing - the state should
     91         // remain the same until the gesture is complete, as tested above.
     92         if (mState != State.UNKNOWN) {
     93             return;
     94         }
     95 
     96         float currentX0 = event.getX(0);
     97         float currentY0 = event.getY(0);
     98         float currentX1 = event.getX(1);
     99         float currentY1 = event.getY(1);
    100         if (!mInGesture) {
    101             // This is the first event of the gesture, so store the pointer coordinates.
    102             mFirstX0 = currentX0;
    103             mFirstY0 = currentY0;
    104             mFirstX1 = currentX1;
    105             mFirstY1 = currentY1;
    106             mInGesture = true;
    107             return;
    108         }
    109 
    110         float deltaX0 = currentX0 - mFirstX0;
    111         float deltaY0 = currentY0 - mFirstY0;
    112         float deltaX1 = currentX1 - mFirstX1;
    113         float deltaY1 = currentY1 - mFirstY1;
    114 
    115         float squaredDistance0 = deltaX0 * deltaX0 + deltaY0 * deltaY0;
    116         float squaredDistance1 = deltaX1 * deltaX1 + deltaY1 * deltaY1;
    117 
    118 
    119         // If both fingers have moved beyond the touch-slop, it is safe to recognize the gesture.
    120         // However, one finger might be held stationary whilst the other finger is moved a long
    121         // distance. In this case, it is preferable to trigger a PINCH. This should be detected
    122         // soon enough to avoid triggering a sudden large change in the zoom level, but not so
    123         // soon that SWIPE never gets triggered.
    124 
    125         // Threshold level for triggering the PINCH gesture if one finger is stationary. This
    126         // cannot be equal to the touch-slop, because in that case, SWIPE would rarely be detected.
    127         // One finger would usually leave the touch-slop radius slightly before the other finger,
    128         // triggering a PINCH as described above. A larger radius gives an opportunity for
    129         // SWIPE to be detected. Doubling the radius is an arbitrary choice that works well.
    130         int pinchThresholdSquare = 4 * mTouchSlopSquare;
    131 
    132         boolean finger0Moved = squaredDistance0 > mTouchSlopSquare;
    133         boolean finger1Moved = squaredDistance1 > mTouchSlopSquare;
    134 
    135         if (!finger0Moved && !finger1Moved) {
    136             return;
    137         }
    138 
    139         if (finger0Moved && !finger1Moved) {
    140             if (squaredDistance0 > pinchThresholdSquare) {
    141                 mState = State.PINCH;
    142             }
    143             return;
    144         }
    145 
    146         if (!finger0Moved && finger1Moved) {
    147             if (squaredDistance1 > pinchThresholdSquare) {
    148                 mState = State.PINCH;
    149             }
    150             return;
    151         }
    152 
    153         // Both fingers have moved, so determine SWIPE/PINCH status. If the fingers have moved in
    154         // the same direction, this is a SWIPE, otherwise it's a PINCH. This can be measured by
    155         // taking the scalar product of the direction vectors. This product is positive if the
    156         // vectors are pointing in the same direction, and negative if they're in opposite
    157         // directions.
    158         float scalarProduct = deltaX0 * deltaX1 + deltaY0 * deltaY1;
    159         mState = (scalarProduct > 0) ? State.SWIPE : State.PINCH;
    160     }
    161 }
    162