GestureDetector.java

/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Modified for aFreeRDP by Martin Fleisz (martin.fleisz@thincast.com)
 */
 
package com.freerdp.freerdpcore.utils;
 
import android.content.Context;
import android.os.Handler;
import android.os.Message;
import android.util.DisplayMetrics;
import android.view.MotionEvent;
import android.view.ViewConfiguration;
 
public class GestureDetector
{
 
  private static final int TAP_TIMEOUT = 100;
  private static final int DOUBLE_TAP_TIMEOUT = 200;
  // Distance a touch can wander before we think the user is the first touch in a sequence of
  // double tap
  private static final int LARGE_TOUCH_SLOP = 18;
  // Distance between the first touch and second touch to still be considered a double tap
  private static final int DOUBLE_TAP_SLOP = 100;
  // constants for Message.what used by GestureHandler below
  private static final int SHOW_PRESS = 1;
  private static final int LONG_PRESS = 2;
  private static final int TAP = 3;
  private final Handler mHandler;
  private final OnGestureListener mListener;
  private int mTouchSlopSquare;
  private int mLargeTouchSlopSquare;
  private int mDoubleTapSlopSquare;
  private int mLongpressTimeout = 100;
  private OnDoubleTapListener mDoubleTapListener;
  private boolean mStillDown;
  private boolean mInLongPress;
  private boolean mAlwaysInTapRegion;
  private boolean mAlwaysInBiggerTapRegion;
  private MotionEvent mCurrentDownEvent;
  private MotionEvent mPreviousUpEvent;
  private boolean mIsDoubleTapping;
  private float mLastMotionY;
  private float mLastMotionX;
  private boolean mIsLongpressEnabled;
  private boolean mIgnoreMultitouch;
  public GestureDetector(Context context, OnGestureListener listener)
  {
    this(context, listener, null);
  }
 
  public GestureDetector(Context context, OnGestureListener listener, Handler handler)
  {
    this(context, listener, handler, context != null);
  }
 
  public GestureDetector(Context context, OnGestureListener listener, Handler handler,
                         boolean ignoreMultitouch)
  {
    if (handler != null)
    {
      mHandler = new GestureHandler(handler);
    }
    else
    {
      mHandler = new GestureHandler();
    }
    mListener = listener;
    if (listener instanceof OnDoubleTapListener)
    {
      setOnDoubleTapListener((OnDoubleTapListener)listener);
    }
    init(context, ignoreMultitouch);
  }
 
  private void init(Context context, boolean ignoreMultitouch)
  {
    if (mListener == null)
    {
      throw new NullPointerException("OnGestureListener must not be null");
    }
    mIsLongpressEnabled = true;
    mIgnoreMultitouch = ignoreMultitouch;
 
    // Fallback to support pre-donuts releases
    int touchSlop, largeTouchSlop, doubleTapSlop;
    if (context == null)
    {
      // noinspection deprecation
      touchSlop = ViewConfiguration.getTouchSlop();
      largeTouchSlop = touchSlop + 2;
      doubleTapSlop = DOUBLE_TAP_SLOP;
    }
    else
    {
      final DisplayMetrics metrics = context.getResources().getDisplayMetrics();
      final float density = metrics.density;
      final ViewConfiguration configuration = ViewConfiguration.get(context);
      touchSlop = configuration.getScaledTouchSlop();
      largeTouchSlop = (int)(density * LARGE_TOUCH_SLOP + 0.5f);
      doubleTapSlop = configuration.getScaledDoubleTapSlop();
    }
    mTouchSlopSquare = touchSlop * touchSlop;
    mLargeTouchSlopSquare = largeTouchSlop * largeTouchSlop;
    mDoubleTapSlopSquare = doubleTapSlop * doubleTapSlop;
  }
 
  public void setOnDoubleTapListener(OnDoubleTapListener onDoubleTapListener)
  {
    mDoubleTapListener = onDoubleTapListener;
  }
 
  public void setIsLongpressEnabled(boolean isLongpressEnabled)
  {
    mIsLongpressEnabled = isLongpressEnabled;
  }
 
  public boolean isLongpressEnabled()
  {
    return mIsLongpressEnabled;
  }
 
  public void setLongPressTimeout(int timeout)
  {
    mLongpressTimeout = timeout;
  }
 
  public boolean onTouchEvent(MotionEvent ev)
  {
    final int action = ev.getAction();
    final float y = ev.getY();
    final float x = ev.getX();
 
    boolean handled = false;
 
    switch (action & MotionEvent.ACTION_MASK)
    {
      case MotionEvent.ACTION_POINTER_DOWN:
        if (mIgnoreMultitouch)
        {
          // Multitouch event - abort.
          cancel();
        }
        break;
 
      case MotionEvent.ACTION_POINTER_UP:
        // Ending a multitouch gesture and going back to 1 finger
        if (mIgnoreMultitouch && ev.getPointerCount() == 2)
        {
          int index = (((action & MotionEvent.ACTION_POINTER_INDEX_MASK) >>
                        MotionEvent.ACTION_POINTER_INDEX_SHIFT) == 0)
                          ? 1
                          : 0;
          mLastMotionX = ev.getX(index);
          mLastMotionY = ev.getY(index);
        }
        break;
 
      case MotionEvent.ACTION_DOWN:
        if (mDoubleTapListener != null)
        {
          boolean hadTapMessage = mHandler.hasMessages(TAP);
          if (hadTapMessage)
            mHandler.removeMessages(TAP);
          if ((mCurrentDownEvent != null) && (mPreviousUpEvent != null) &&
              hadTapMessage &&
              isConsideredDoubleTap(mCurrentDownEvent, mPreviousUpEvent, ev))
          {
            // This is a second tap
            mIsDoubleTapping = true;
            // Give a callback with the first tap of the double-tap
            handled |= mDoubleTapListener.onDoubleTap(mCurrentDownEvent);
            // Give a callback with down event of the double-tap
            handled |= mDoubleTapListener.onDoubleTapEvent(ev);
          }
          else
          {
            // This is a first tap
            mHandler.sendEmptyMessageDelayed(TAP, DOUBLE_TAP_TIMEOUT);
          }
        }
 
        mLastMotionX = x;
        mLastMotionY = y;
        if (mCurrentDownEvent != null)
        {
          mCurrentDownEvent.recycle();
        }
        mCurrentDownEvent = MotionEvent.obtain(ev);
        mAlwaysInTapRegion = true;
        mAlwaysInBiggerTapRegion = true;
        mStillDown = true;
        mInLongPress = false;
 
        if (mIsLongpressEnabled)
        {
          mHandler.removeMessages(LONG_PRESS);
          mHandler.sendEmptyMessageAtTime(LONG_PRESS, mCurrentDownEvent.getDownTime() +
                                                          TAP_TIMEOUT +
                                                          mLongpressTimeout);
        }
        mHandler.sendEmptyMessageAtTime(SHOW_PRESS,
                                        mCurrentDownEvent.getDownTime() + TAP_TIMEOUT);
        handled |= mListener.onDown(ev);
        break;
 
      case MotionEvent.ACTION_MOVE:
        if (mIgnoreMultitouch && ev.getPointerCount() > 1)
        {
          break;
        }
        final float scrollX = mLastMotionX - x;
        final float scrollY = mLastMotionY - y;
        if (mIsDoubleTapping)
        {
          // Give the move events of the double-tap
          handled |= mDoubleTapListener.onDoubleTapEvent(ev);
        }
        else if (mAlwaysInTapRegion)
        {
          final int deltaX = (int)(x - mCurrentDownEvent.getX());
          final int deltaY = (int)(y - mCurrentDownEvent.getY());
          int distance = (deltaX * deltaX) + (deltaY * deltaY);
          if (distance > mTouchSlopSquare)
          {
            mLastMotionX = x;
            mLastMotionY = y;
            mAlwaysInTapRegion = false;
            mHandler.removeMessages(TAP);
            mHandler.removeMessages(SHOW_PRESS);
            mHandler.removeMessages(LONG_PRESS);
          }
          if (distance > mLargeTouchSlopSquare)
          {
            mAlwaysInBiggerTapRegion = false;
          }
          handled = mListener.onScroll(mCurrentDownEvent, ev, scrollX, scrollY);
        }
        else if ((Math.abs(scrollX) >= 1) || (Math.abs(scrollY) >= 1))
        {
          handled = mListener.onScroll(mCurrentDownEvent, ev, scrollX, scrollY);
          mLastMotionX = x;
          mLastMotionY = y;
        }
        break;
 
      case MotionEvent.ACTION_UP:
        mStillDown = false;
        MotionEvent currentUpEvent = MotionEvent.obtain(ev);
        if (mIsDoubleTapping)
        {
          // Finally, give the up event of the double-tap
          handled |= mDoubleTapListener.onDoubleTapEvent(ev);
        }
        else if (mInLongPress)
        {
          mHandler.removeMessages(TAP);
          mListener.onLongPressUp(ev);
          mInLongPress = false;
        }
        else if (mAlwaysInTapRegion)
        {
          handled = mListener.onSingleTapUp(mCurrentDownEvent);
        }
        else
        {
          // A fling must travel the minimum tap distance
        }
        if (mPreviousUpEvent != null)
        {
          mPreviousUpEvent.recycle();
        }
        // Hold the event we obtained above - listeners may have changed the original.
        mPreviousUpEvent = currentUpEvent;
        mIsDoubleTapping = false;
        mHandler.removeMessages(SHOW_PRESS);
        mHandler.removeMessages(LONG_PRESS);
        handled |= mListener.onUp(ev);
        break;
      case MotionEvent.ACTION_CANCEL:
        cancel();
        break;
    }
    return handled;
  }
 
  private void cancel()
  {
    mHandler.removeMessages(SHOW_PRESS);
    mHandler.removeMessages(LONG_PRESS);
    mHandler.removeMessages(TAP);
    mAlwaysInTapRegion = false; // ensures that we won't receive an OnSingleTap notification
                                // when a 2-Finger tap is performed
    mIsDoubleTapping = false;
    mStillDown = false;
    if (mInLongPress)
    {
      mInLongPress = false;
    }
  }
 
  private boolean isConsideredDoubleTap(MotionEvent firstDown, MotionEvent firstUp,
                                        MotionEvent secondDown)
  {
    if (!mAlwaysInBiggerTapRegion)
    {
      return false;
    }
 
    if (secondDown.getEventTime() - firstUp.getEventTime() > DOUBLE_TAP_TIMEOUT)
    {
      return false;
    }
 
    int deltaX = (int)firstDown.getX() - (int)secondDown.getX();
    int deltaY = (int)firstDown.getY() - (int)secondDown.getY();
    return (deltaX * deltaX + deltaY * deltaY < mDoubleTapSlopSquare);
  }
 
  private void dispatchLongPress()
  {
    mHandler.removeMessages(TAP);
    mInLongPress = true;
    mListener.onLongPress(mCurrentDownEvent);
  }
 
  public interface OnGestureListener {
 
    boolean onDown(MotionEvent e);
 
    boolean onUp(MotionEvent e);
 
    void onShowPress(MotionEvent e);
 
    boolean onSingleTapUp(MotionEvent e);
 
    boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY);
 
    void onLongPress(MotionEvent e);
 
    void onLongPressUp(MotionEvent e);
  }
 
  public interface OnDoubleTapListener {
    boolean onSingleTapConfirmed(MotionEvent e);
 
    boolean onDoubleTap(MotionEvent e);
 
    boolean onDoubleTapEvent(MotionEvent e);
  }
 
  public static class SimpleOnGestureListener implements OnGestureListener, OnDoubleTapListener
  {
    public boolean onSingleTapUp(MotionEvent e)
    {
      return false;
    }
 
    public void onLongPress(MotionEvent e)
    {
    }
 
    public void onLongPressUp(MotionEvent e)
    {
    }
 
    public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY)
    {
      return false;
    }
 
    public void onShowPress(MotionEvent e)
    {
    }
 
    public boolean onDown(MotionEvent e)
    {
      return false;
    }
 
    public boolean onUp(MotionEvent e)
    {
      return false;
    }
 
    public boolean onDoubleTap(MotionEvent e)
    {
      return false;
    }
 
    public boolean onDoubleTapEvent(MotionEvent e)
    {
      return false;
    }
 
    public boolean onSingleTapConfirmed(MotionEvent e)
    {
      return false;
    }
  }
 
  private class GestureHandler extends Handler
  {
    GestureHandler()
    {
      super();
    }
 
    GestureHandler(Handler handler)
    {
      super(handler.getLooper());
    }
 
    @Override public void handleMessage(Message msg)
    {
      switch (msg.what)
      {
        case SHOW_PRESS:
          mListener.onShowPress(mCurrentDownEvent);
          break;
 
        case LONG_PRESS:
          dispatchLongPress();
          break;
 
        case TAP:
          // If the user's finger is still down, do not count it as a tap
          if (mDoubleTapListener != null && !mStillDown)
          {
            mDoubleTapListener.onSingleTapConfirmed(mCurrentDownEvent);
          }
          break;
 
        default:
          throw new RuntimeException("Unknown message " + msg); // never
      }
    }
  }
}