remoting/android/java/src/org/chromium/chromoting/SwipePinchDetector.java

// Copyright 2013 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.

package org.chromium.chromoting;

import android.content.Context;
import android.view.MotionEvent;
import android.view.ViewConfiguration;

/**
 * Helper class for disambiguating whether to treat a two-finger gesture as a swipe or a pinch.
 * Initially, the status will be unknown, until the fingers have moved sufficiently far to
 * determine the intent.
 */
public class SwipePinchDetector {
    /** Current state of the gesture. */
    private enum State {
        UNKNOWN,
        SWIPE,
        PINCH
    }
    private State mState = State.UNKNOWN;

    /** Initial coordinates of the two pointers in the current gesture. */
    private float mFirstX0;
    private float mFirstY0;
    private float mFirstX1;
    private float mFirstY1;

    /**
     * The initial coordinates above are valid when this flag is set. Used to determine whether a
     * MotionEvent's pointer coordinates are the first ones of the gesture.
     */
    private boolean mInGesture = false;

    /**
     * Threshold squared-distance, in pixels, to use for motion-detection.
     */
    private int mTouchSlopSquare;

    private void reset() {
        mState = State.UNKNOWN;
        mInGesture = false;
    }

    /** Construct a new detector, using the context to determine movement thresholds. */
    public SwipePinchDetector(Context context) {
        ViewConfiguration config = ViewConfiguration.get(context);
        int touchSlop = config.getScaledTouchSlop();
        mTouchSlopSquare = touchSlop * touchSlop;
    }

    /** Returns whether a swipe is in progress. */
    public boolean isSwiping() {
        return mState == State.SWIPE;
    }

    /** Returns whether a pinch is in progress. */
    public boolean isPinching() {
        return mState == State.PINCH;
    }

    /**
     * Analyzes the touch event to determine whether the user is swiping or pinching. Only
     * motion events with 2 pointers are considered here. Once the gesture is determined to be a
     * swipe or a pinch, further 2-finger motion-events will be ignored. When a different event is
     * passed in (motion event with != 2 pointers, or some other event type), this object will
     * revert back to the original UNKNOWN state.
     */
    public void onTouchEvent(MotionEvent event) {
        if (event.getPointerCount() != 2) {
            reset();
            return;
        }

        // Only MOVE or DOWN events are considered - all other events should finish any current
        // gesture and reset the detector. In addition, a DOWN event should reset the detector,
        // since it signals the start of the gesture. If the events are consistent, a DOWN event
        // will occur at the start of the gesture, but this implementation tries to cope in case
        // the first event is MOVE rather than DOWN.
        int action = event.getActionMasked();
        if (action != MotionEvent.ACTION_MOVE) {
            reset();
            if (action != MotionEvent.ACTION_POINTER_DOWN) {
                return;
            }
        }

        // If the gesture is known, there is no need for further processing - the state should
        // remain the same until the gesture is complete, as tested above.
        if (mState != State.UNKNOWN) {
            return;
        }

        float currentX0 = event.getX(0);
        float currentY0 = event.getY(0);
        float currentX1 = event.getX(1);
        float currentY1 = event.getY(1);
        if (!mInGesture) {
            // This is the first event of the gesture, so store the pointer coordinates.
            mFirstX0 = currentX0;
            mFirstY0 = currentY0;
            mFirstX1 = currentX1;
            mFirstY1 = currentY1;
            mInGesture = true;
            return;
        }

        float deltaX0 = currentX0 - mFirstX0;
        float deltaY0 = currentY0 - mFirstY0;
        float deltaX1 = currentX1 - mFirstX1;
        float deltaY1 = currentY1 - mFirstY1;

        float squaredDistance0 = deltaX0 * deltaX0 + deltaY0 * deltaY0;
        float squaredDistance1 = deltaX1 * deltaX1 + deltaY1 * deltaY1;


        // If both fingers have moved beyond the touch-slop, it is safe to recognize the gesture.
        // However, one finger might be held stationary whilst the other finger is moved a long
        // distance. In this case, it is preferable to trigger a PINCH. This should be detected
        // soon enough to avoid triggering a sudden large change in the zoom level, but not so
        // soon that SWIPE never gets triggered.

        // Threshold level for triggering the PINCH gesture if one finger is stationary. This
        // cannot be equal to the touch-slop, because in that case, SWIPE would rarely be detected.
        // One finger would usually leave the touch-slop radius slightly before the other finger,
        // triggering a PINCH as described above. A larger radius gives an opportunity for
        // SWIPE to be detected. Doubling the radius is an arbitrary choice that works well.
        int pinchThresholdSquare = 4 * mTouchSlopSquare;

        boolean finger0Moved = squaredDistance0 > mTouchSlopSquare;
        boolean finger1Moved = squaredDistance1 > mTouchSlopSquare;

        if (!finger0Moved && !finger1Moved) {
            return;
        }

        if (finger0Moved && !finger1Moved) {
            if (squaredDistance0 > pinchThresholdSquare) {
                mState = State.PINCH;
            }
            return;
        }

        if (!finger0Moved && finger1Moved) {
            if (squaredDistance1 > pinchThresholdSquare) {
                mState = State.PINCH;
            }
            return;
        }

        // Both fingers have moved, so determine SWIPE/PINCH status. If the fingers have moved in
        // the same direction, this is a SWIPE, otherwise it's a PINCH. This can be measured by
        // taking the scalar product of the direction vectors. This product is positive if the
        // vectors are pointing in the same direction, and negative if they're in opposite
        // directions.
        float scalarProduct = deltaX0 * deltaX1 + deltaY0 * deltaY1;
        mState = (scalarProduct > 0) ? State.SWIPE : State.PINCH;
    }
}