/*
2 finger gesture detector
Copyright 2013 Thincast Technologies GmbH, Author: Martin Fleisz
This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
If a copy of the MPL was not distributed with this file, You can obtain one at
http://mozilla.org/MPL/2.0/.
*/
package com.freerdp.freerdpcore.utils;
import android.content.Context;
import android.os.Handler;
import android.view.MotionEvent;
import android.view.ScaleGestureDetector;
import com.freerdp.freerdpcore.utils.GestureDetector.OnGestureListener;
public class DoubleGestureDetector
{
// timeout during that the second finger has to touch the screen before the double finger
// detection is cancelled
private static final long DOUBLE_TOUCH_TIMEOUT = 100;
// timeout during that an UP event will trigger a single double touch event
private static final long SINGLE_DOUBLE_TOUCH_TIMEOUT = 1000;
// constants for Message.what used by GestureHandler below
private static final int TAP = 1;
// different detection modes
private static final int MODE_UNKNOWN = 0;
private static final int MODE_PINCH_ZOOM = 1;
private static final int MODE_SCROLL = 2;
private static final int SCROLL_SCORE_TO_REACH = 20;
private final OnDoubleGestureListener mListener;
private int mPointerDistanceSquare;
private int mCurrentMode;
private int mScrollDetectionScore;
private ScaleGestureDetector scaleGestureDetector;
private boolean mCancelDetection;
private boolean mDoubleInProgress;
private GestureHandler mHandler;
private MotionEvent mCurrentDownEvent;
private MotionEvent mCurrentDoubleDownEvent;
private MotionEvent mPreviousUpEvent;
private MotionEvent mPreviousPointerUpEvent;
/**
* Creates a GestureDetector with the supplied listener.
* You may only use this constructor from a UI thread (this is the usual situation).
*
* @param context the application's context
* @param listener the listener invoked for all the callbacks, this must
* not be null.
* @throws NullPointerException if {@code listener} is null.
* @see android.os.Handler#Handler()
*/
public DoubleGestureDetector(Context context, Handler handler, OnDoubleGestureListener listener)
{
mListener = listener;
init(context, handler);
}
private void init(Context context, Handler handler)
{
if (mListener == null)
{
throw new NullPointerException("OnGestureListener must not be null");
}
if (handler != null)
mHandler = new GestureHandler(handler);
else
mHandler = new GestureHandler();
// we use 1cm distance to decide between scroll and pinch zoom
// - first convert cm to inches
// - then multiply inches by dots per inch
float distInches = 0.5f / 2.54f;
float distPixelsX = distInches * context.getResources().getDisplayMetrics().xdpi;
float distPixelsY = distInches * context.getResources().getDisplayMetrics().ydpi;
mPointerDistanceSquare = (int)(distPixelsX * distPixelsX + distPixelsY * distPixelsY);
}
/**
* Set scale gesture detector
*
* @param scaleGestureDetector
*/
public void setScaleGestureDetector(ScaleGestureDetector scaleGestureDetector)
{
this.scaleGestureDetector = scaleGestureDetector;
}
/**
* Analyzes the given motion event and if applicable triggers the
* appropriate callbacks on the {@link OnGestureListener} supplied.
*
* @param ev The current motion event.
* @return true if the {@link OnGestureListener} consumed the event,
* else false.
*/
public boolean onTouchEvent(MotionEvent ev)
{
boolean handled = false;
final int action = ev.getAction();
// dumpEvent(ev);
switch (action & MotionEvent.ACTION_MASK)
{
case MotionEvent.ACTION_DOWN:
if (mCurrentDownEvent != null)
mCurrentDownEvent.recycle();
mCurrentMode = MODE_UNKNOWN;
mCurrentDownEvent = MotionEvent.obtain(ev);
mCancelDetection = false;
mDoubleInProgress = false;
mScrollDetectionScore = 0;
handled = true;
break;
case MotionEvent.ACTION_POINTER_UP:
if (mPreviousPointerUpEvent != null)
mPreviousPointerUpEvent.recycle();
mPreviousPointerUpEvent = MotionEvent.obtain(ev);
break;
case MotionEvent.ACTION_POINTER_DOWN:
// more than 2 fingers down? cancel
// 2nd finger touched too late? cancel
if (ev.getPointerCount() > 2 ||
(ev.getEventTime() - mCurrentDownEvent.getEventTime()) > DOUBLE_TOUCH_TIMEOUT)
{
cancel();
break;
}
// detection cancelled?
if (mCancelDetection)
break;
// double touch gesture in progress
mDoubleInProgress = true;
if (mCurrentDoubleDownEvent != null)
mCurrentDoubleDownEvent.recycle();
mCurrentDoubleDownEvent = MotionEvent.obtain(ev);
// set detection mode to unkown and send a TOUCH timeout event to detect single taps
mCurrentMode = MODE_UNKNOWN;
mHandler.sendEmptyMessageDelayed(TAP, SINGLE_DOUBLE_TOUCH_TIMEOUT);
handled |= mListener.onDoubleTouchDown(ev);
break;
case MotionEvent.ACTION_MOVE:
// detection cancelled or not active?
if (mCancelDetection || !mDoubleInProgress || ev.getPointerCount() != 2)
break;
// determine mode
if (mCurrentMode == MODE_UNKNOWN)
{
// did the pointer distance change?
if (pointerDistanceChanged(mCurrentDoubleDownEvent, ev))
{
handled |= scaleGestureDetector.onTouchEvent(mCurrentDownEvent);
MotionEvent e = MotionEvent.obtain(ev);
e.setAction(mCurrentDoubleDownEvent.getAction());
handled |= scaleGestureDetector.onTouchEvent(e);
mCurrentMode = MODE_PINCH_ZOOM;
break;
}
else
{
mScrollDetectionScore++;
if (mScrollDetectionScore >= SCROLL_SCORE_TO_REACH)
mCurrentMode = MODE_SCROLL;
}
}
switch (mCurrentMode)
{
case MODE_PINCH_ZOOM:
if (scaleGestureDetector != null)
handled |= scaleGestureDetector.onTouchEvent(ev);
break;
case MODE_SCROLL:
handled = mListener.onDoubleTouchScroll(mCurrentDownEvent, ev);
break;
default:
handled = true;
break;
}
break;
case MotionEvent.ACTION_UP:
// fingers were not removed equally? cancel
if (mPreviousPointerUpEvent != null &&
(ev.getEventTime() - mPreviousPointerUpEvent.getEventTime()) >
DOUBLE_TOUCH_TIMEOUT)
{
mPreviousPointerUpEvent.recycle();
mPreviousPointerUpEvent = null;
cancel();
break;
}
// detection cancelled or not active?
if (mCancelDetection || !mDoubleInProgress)
break;
boolean hasTapEvent = mHandler.hasMessages(TAP);
MotionEvent currentUpEvent = MotionEvent.obtain(ev);
if (mCurrentMode == MODE_UNKNOWN && hasTapEvent)
handled = mListener.onDoubleTouchSingleTap(mCurrentDoubleDownEvent);
else if (mCurrentMode == MODE_PINCH_ZOOM)
handled = scaleGestureDetector.onTouchEvent(ev);
if (mPreviousUpEvent != null)
mPreviousUpEvent.recycle();
// Hold the event we obtained above - listeners may have changed the original.
mPreviousUpEvent = currentUpEvent;
handled |= mListener.onDoubleTouchUp(ev);
break;
case MotionEvent.ACTION_CANCEL:
cancel();
break;
}
if ((action == MotionEvent.ACTION_MOVE) && handled == false)
handled = true;
return handled;
}
private void cancel()
{
mHandler.removeMessages(TAP);
mCurrentMode = MODE_UNKNOWN;
mCancelDetection = true;
mDoubleInProgress = false;
}
// returns true of the distance between the two pointers changed
private boolean pointerDistanceChanged(MotionEvent oldEvent, MotionEvent newEvent)
{
int deltaX1 = Math.abs((int)oldEvent.getX(0) - (int)oldEvent.getX(1));
int deltaX2 = Math.abs((int)newEvent.getX(0) - (int)newEvent.getX(1));
int distXSquare = (deltaX2 - deltaX1) * (deltaX2 - deltaX1);
int deltaY1 = Math.abs((int)oldEvent.getY(0) - (int)oldEvent.getY(1));
int deltaY2 = Math.abs((int)newEvent.getY(0) - (int)newEvent.getY(1));
int distYSquare = (deltaY2 - deltaY1) * (deltaY2 - deltaY1);
return (distXSquare + distYSquare) > mPointerDistanceSquare;
}
/**
* The listener that is used to notify when gestures occur.
* If you want to listen for all the different gestures then implement
* this interface. If you only want to listen for a subset it might
* be easier to extend {@link SimpleOnGestureListener}.
*/
public interface OnDoubleGestureListener {
/**
* Notified when a multi tap event starts
*/
boolean onDoubleTouchDown(MotionEvent e);
/**
* Notified when a multi tap event ends
*/
boolean onDoubleTouchUp(MotionEvent e);
/**
* Notified when a tap occurs with the up {@link MotionEvent}
* that triggered it.
*
* @param e The up motion event that completed the first tap
* @return true if the event is consumed, else false
*/
boolean onDoubleTouchSingleTap(MotionEvent e);
/**
* Notified when a scroll occurs with the initial on down {@link MotionEvent} and the
* current move {@link MotionEvent}. The distance in x and y is also supplied for
* convenience.
*
* @param e1 The first down motion event that started the scrolling.
* @param e2 The move motion event that triggered the current onScroll.
* @param distanceX The distance along the X axis that has been scrolled since the last
* call to onScroll. This is NOT the distance between {@code e1}
* and {@code e2}.
* @param distanceY The distance along the Y axis that has been scrolled since the last
* call to onScroll. This is NOT the distance between {@code e1}
* and {@code e2}.
* @return true if the event is consumed, else false
*/
boolean onDoubleTouchScroll(MotionEvent e1, MotionEvent e2);
}
/*
private void dumpEvent(MotionEvent event) {
String names[] = { "DOWN" , "UP" , "MOVE" , "CANCEL" , "OUTSIDE" ,
"POINTER_DOWN" , "POINTER_UP" , "7?" , "8?" , "9?" };
StringBuilder sb = new StringBuilder();
int action = event.getAction();
int actionCode = action & MotionEvent.ACTION_MASK;
sb.append("event ACTION_" ).append(names[actionCode]);
if (actionCode == MotionEvent.ACTION_POINTER_DOWN
|| actionCode == MotionEvent.ACTION_POINTER_UP) {
sb.append("(pid " ).append(
action >> MotionEvent.ACTION_POINTER_ID_SHIFT);
sb.append(")" );
}
sb.append("[" );
for (int i = 0; i < event.getPointerCount(); i++) {
sb.append("#" ).append(i);
sb.append("(pid " ).append(event.getPointerId(i));
sb.append(")=" ).append((int) event.getX(i));
sb.append("," ).append((int) event.getY(i));
if (i + 1 < event.getPointerCount())
sb.append(";" );
}
sb.append("]" );
Log.d("DoubleDetector", sb.toString());
}
*/
private class GestureHandler extends Handler
{
GestureHandler()
{
super();
}
GestureHandler(Handler handler)
{
super(handler.getLooper());
}
}
}