1.GestureDetecor
用户触摸屏幕时会产生许多手势，一般通过重写View类的onTouch()方法可以处理一些触摸事件，但是这个方法太过简单，如果需要处理一些复杂的手势，用这个接口就会很麻烦，需要自己根据用户触摸的轨迹去判断是什么手势。
因此，Android sdk提供了GestureDetector类来监听手势发生，通过它的onTouchEvent(event)方法完成不同手势的识别。识别出手势后，不同的手势要怎么处理，再由开发者自己来实现。
GestureDetector类内部定义了三个接口和一个类，重写这些方法，就能实现传入触摸事件之后做出相应的回调：
①OnGestureListener接口
监听一些手势，如单击、滑动、长按等操作。
②OnDoubleTapListener接口
监听双击和单击事件。
③OnContextClickListener接口
当鼠标/触摸板，右键点击时候的回调。
④SimpleOnGestureListener 类
实现了上面三个接口的类，拥有上面三个的所有回调方法。
这些回调方法的返回值都是boolean类型，和View的事件传递机制一样，返回true表示消耗了事件，flase表示没有消耗。
其中，SimpleOnGestureListener是一个静态内部类，它实现了OnGestureListener、OnDoubleTapListener、OnContextClickListener三个接口。SimpleOnGestureListener类内重写了接口中的所有方法，但都是空实现，返回的布尔值都是false。这个类的主要作用就是方便继承这个类有选择的复写回调方法，而不是实现接口去重写所有的方法。
下面具体说说这几个接口：
①GesturetDetector.OnGestureListener 接口
public interface OnGestureListener {
boolean onDown(MotionEvent e); // 由1个down触发，每按一下屏幕立即触发
void onShowPress(MotionEvent e); //按下屏幕并且没有移动或松开，由1个down触发。注意和onDown()的区别，强调的是没有松开或者拖动的状态，而onDown()没有任何限制。主要是提供给用户一个可视化的反馈，告诉用户按下操作已经被捕捉到了。如果按下的速度很快只会调用onDown()，按下的速度稍慢一点会先调用onDown()再调用onShowPress()
boolean onSingleTapUp(MotionEvent e); //一次单纯的轻击抬手动作时触发，由一个up触发。如果除了Down以外还有其他操作，比如触发了长按，这时候手抬起时，这个方法不执行
boolean onScroll(MotionEvent e1, MotionEvent e2,float distanceX,float distanceY); // 屏幕拖动事件。手指按下并在屏幕上滑动时触发。这个事件由1个down，多个move触发。手指在屏幕上滑动时，会不断触发该方法。如果按下的时间过长，调用了onLongPress，再拖动屏幕不会触发onScroll。e1：开始拖动的第一次按下down操作,也就是第一个ACTION_DOWN；e2：触发当前onScroll方法的ACTION_MOVE，即当前滑动位置点；distanceX：当前x坐标与最后一次触发scroll方法的x坐标的差值，不是e1点到e2点的x轴距离；diastancY：当前y坐标与最后一次触发scroll方法的y坐标的差值，不是e1点到e2点的y轴距离
void onLongPress(MotionEvent e); //长按。在down操作之后，过一个特定的时间触发
boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY); //按下屏幕，在屏幕上快速滑动后松开，由一个down、多个move、一个up触发。当滑动较慢时，只会触发onScroll，而不会触发onFling。e1：开始快速滑动的第一次按下down操作，也就是第一个ACTION_DOWN，即拖动事件的起点；e2：触发当前onFling方法的move操作，也就是最后一个ACTION_MOVE，即onFling()调用时手指的位置；velocityX：X轴上的移动速度，像素/秒；velocityY：Y轴上的移动速度，像素/秒
}快按屏幕抬起：onDown —> onSingleTapUp —> onSingleTapConfirmed
慢按屏幕抬起：onDown –> onShowPress —> onSingleTapUp —> onSingleTapConfirmed
按下屏幕等待一段时间：onDown –> onShowPress –> onLongPress
拖动屏幕：onDown –> onShowPress –> onScroll(多个) –> onFling
快速滑动：onDown–>onScroll(多个)–>onFling
注意：当拖动速率velocityX或velocityY超过ViewConfiguration.getMinimumFlingVelocity()最小拖动速率时，才会调用onFling()，也就是说如果只拖动一点，或者慢慢的拖动，是不会触发该方法的。
②GesttureDetector.OnDoubleTapListener 接口
public interface OnDoubleTapListener {
boolean onSingleTapConfirmed(MotionEvent e); //单击事件。用来判定该次点击是单纯的SingleTap而不是DoubleTap。如果连续点击两次就是DoubleTap手势，如果只点击一次，系统等待一段时间后没有收到第二次点击则判定该次点击为SingleTap而不是DoubleTap，然后触发SingleTapConfirmed事件。触发顺序是：OnDown->OnSingleTapUp->OnSingleTapConfirmed。关于onSingleTapConfirmed和onSingleTapUp的区别：onSingleTapUp只要手抬起就会执行，而对于onSingleTapConfirmed来说，如果双击的话，则onSingleTapConfirmed不会执行。
boolean onDoubleTap(MotionEvent e); //双击事件。在第二次点击的down时触发。参数表示双击发生时，第一次按下时的down事件
boolean onDoubleTapEvent( MotionEvent e); //双击间隔中发生的动作。指触发onDoubleTap以后，在双击之间发生的其它动作，包含down、up和move事件
}
下图是双击一下的Log输出：
从图中可以看出，在第二下点击时，先触发OnDoubleTap，然后再触发OnDown（第二次点击）。在触发OnDoubleTap以后，就开始触发onDoubleTapEvent了，onDoubleTapEvent后面的数字代表了当前的事件，0指ACTION_DOWN，1指ACTION_UP，2 指ACTION_MOVE。
双击顺序：onDown –> onSingleTapUp –> onDoubleTap –> onDoubleTapEvent –> onDown–> onDoubleTapEvent
③GesttureDetector.OnContextClickListener接口
public interface On context click Listener {
boolean onContextClick(MotionEvent e);
}④GestureDetector.SimpleOnGestureListener类
它与前面三个不同，这是一个类，并且实现了前三个接口，在它基础上新建类的话，要用extends派生而不是用implements继承。OnGestureListener和OnDoubleTapListener接口里的函数都是必须重写的，即使用不到也要重写一个空函数，但SimpleOnGestureListener类的实例或派生类中可以根据情况，用到哪个函数就重写哪个函数，因为SimpleOnGestureListener类本身已经实现了这两个接口的所有函数，只是里面全是空的而已。
2.GestureDetector使用方法
①第一步：根据需求创建onGestureListener、onDoubleTapListener或simpleOnGestureListener这三个类中的一个对象。比如只需要监听单击的话，那只需要得到实现了onGestureListener接口的对象；如果是双击，就只需要得到实现了onDoubleTapListener接口的对象；如果两种情况都需要考虑，就可以用SimpleOnGestureListener对象或者一个实现了上面两个接口的对象。
②第二步：创建一个GestureDetector对象，参数传入第一步的对象。
GestureDetector的构造函数如下：
public GestureDetector(Context context, OnGestureListener listener) {
this(context, listener, null);
}
public GestureDetector(Context context, OnGestureListener listener, Handler handler) {
}
public GestureDetector(Context context, OnGestureListener listener, Handler handler,
boolean unused) {
this(context, listener, handler);
}
mGestureDetector = new GestureDetector( mContext, new MyGestureListener());③第三步： 给view设置OnTouchListener监听，重写onTouch()方法，在return语句中写上mGestureDetector.onTouchEvent(event)，将控制权交给GestureDector。
④第四步：绑定控件，给view设置setClickable(true)、setFocusable(true)、setLongClickable(true)。这一步非常重要，不然出不来效果。
注意：GestureDetector的构造方法中，有的构造函数需要多传递一个Handler作为参数，这个Handler主要是为了给GestureDetector提供一个Looper。带有handler参数，表示要在与该handler相关联的线程上，监听手势并处理延时事件。
通常情况下不需要这个Handler，因为它会在内部自动创建一个Handler用于处理数据。如果在主线程中创建GestureDetector，那么它内部创建的Handler会自动获得主线程的Looper；但是如果在一个没有创建Looper的子线程中创建 GestureDetector ，则需要传递一个带有Looper的Handler给它，否则就会因为无法获取到Looper导致创建失败。
下面是两种在子线程中创建GestureDetector的方法：
// 方式一：在主线程创建Handler
final Handler handler = new Handler();
new Thread(new Runnable() {
@Override
public void run() {
final GestureDetector detector = new GestureDetector(this, new GestureDetector.SimpleOnGestureListener() , handler);
// ......
}
}).start();
// 方式二：在子线程创建Handler，并指定Looper
new Thread(new Runnable() {
@Override
public void run() {
final Handler handler = new Handler(Looper.getMainLooper());
final GestureDetector detector = new GestureDetector(this, new GestureDetector.SimpleOnGestureListener() , handler);
// ......
}
}).start();使用其它创建Handler的方式也可以，重点是传递的Handler一定要有Looper。强调一下：重点是Handler中的Looper。假如子线程准备了Looper，则可以直接使用第 1 种构造函数进行创建：
new Thread(new Runnable() {
@Override public void run() {
Looper.prepare(); // <- 重点在这里
final GestureDetector detector = new GestureDetector(this, new GestureDetector.SimpleOnGestureListener());
// ... 省略其它代码 ...
}
}).start();
GestureDetector使用 完整代码：
public class MyActivity extends Activity implements View.OnTouchListener, GestureDetector.OnGestureListener,GestureDetector.OnDoubleTapListener{
private GestureDetector mGestureDetector;
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mGestureDetector = new GestureDetector(this);
Text view textview = findViewById(R.id.tv);
textview.setOnTouchListener(this);
textview.setClickable(true);
textview.setLongClickable(true);
textview.setFocusable(true); mGestureDetector.setIsLongpressEnabled(true);
}
@Override
public boolean onTouch(View v, MotionEvent event) {
return mGestureDetector. onTouchEvent(event);
}
@Override
public boolean onDown(MotionEvent e) {
return true;//注意要返回true，否则后续事件无法处理
}
@Override
public void onShowPress(MotionEvent e) {
Log.e(TAG, "onShowPress");
}
@Override
public boolean onSingleTapUp(MotionEvent e) {
Log.e(TAG, "onSingleTapUp");
return true;
}
@Override
public void onLongPress(MotionEvent e) {
Log.e(TAG, "onLongPress");
}
@Override
public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX,float distanceY){
Log.e(TAG, "onScroll");
return true;
}
@Override
public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
Log.e(TAG, "onFling");
final int FLING_MIN_DISTANCE = 100, FLING_MIN_VELOCHTE = 200;
if(e1.getX() - e2.getX() > FLING_MIN_DISTANCE && Math.abs(velocityX) > FLING_MIN_VELOCITY) {
Log.i(TAG, "Fling left");
} else if(e2.getX() - e1.getX() > FLING_MIN_DISTANCE && Math.abs(velocityX) > FLING_MIN_VELOCITY) {
Log.i(TAG, "Fling right");
} else if(e1.getY() - e2.getY() > FLING_MIN_DISTANCE && Math.abs(velocityY) > FLING_MIN_VELOCITY) {
Log.i(TAG, "Fling up");
} else if(e2.getY() - e1.getY() > FLING_MIN_DISTANCE && Math.abs(velocityY) > FLING_MIN_VELOCITY) {
Log.i(TAG, "Fling down");
}
return false;
}
@Override
public boolean onDoubleTap(MotionEvent e) {
Log.e(TAG, "onDoubleTap");
return true;
}
@Override
public boolean onDoubleTapEvent( MotionEvent e) {
Log.e(TAG, "onDoubleTapEvent");
return true;
}
@Override
public boolean onSingleTapConfirmed( MotionEvent e) {
Log.e(TAG, "onSingleTapConfirmed");
return true;
}
@Override
public boolean onContextClick(MotionEvent e) {
Log.e(TAG, "onContextClick");
return true;
}
@override
public boolean dispatchTouchEvent( MotionEvent event){
if(mGestureDetector.onTouchEvent(event)){ //返回true说明手势处理了这个事件
event.setAction(MotionEvent. ACTION_CANCEL);
}
return super.dispatchTouchEvent(event);
}
}注意：最后这个dispatchTouchEvent方法必须要写，否则onScroll、onFling方法不执行。原因还在研究中。而且，要想触发onScroll、onFling方法，必须让监听器的onDown返回值是true。
3.GestureDetector源码
①初始化处理
从构造方法开始，目前在用的有三个：
public GestureDetector(Context context, OnGestureListener listener) {
this(context, listener, null);
}
public GestureDetector(Context context, OnGestureListener listener, Handler handler, boolean unused) {
this(context, listener, handler);
}
public GestureDetector(Context context, OnGestureListener listener, Handler handler) {
if (handler != null) {
mHandler = new GestureHandler(handler);//初始化Handler，用于处理延时消息
} else {
mHandler = new GestureHandler();
}
mListener = listener;//设置回调监听器
if (listener instanceof OnDoubleTapListener) {
setOnDoubleTapListener( (OnDoubleTapListener) listener);
}
if (listener instanceof OnContextClickListener){
setContextClickListener( (OnContextClickListener) listener);
}
init(context);
}
private void init(Context context) {
if (mListener == null) {
throw new NullPointerException( "OnGestureListener must not be null");
}
mIsLongpressEnabled = true;
int touchSlop, doubleTapSlop, doubleTapTouchSlop;
if (context == null) {
touchSlop = ViewConfiguration. getTouchSlop(); //滑动的时候，滑动数值大于这个值才认为滑动开始
doubleTapTouchSlop = touchSlop; //点击的时候，手指移动大于这个距离，就被认为不可能是双击
doubleTapSlop = ViewConfiguration. getDoubleTapSlop();//双击位置之间的最大距离，大于这个值就不认为是双击
mMinimumFlingVelocity = ViewConfiguration.getMinimumFlingVelocity();//手指抛的最小速度
mMaximumFlingVelocity = ViewConfiguration.getMaximumFlingVelocity();//手指抛的最大速度
} else {
final ViewConfiguration configuration = ViewConfiguration.get(context);
touchSlop = configuration. getScaledTouchSlop();
doubleTapTouchSlop = configuration.getScaledDoubleTapTouchSlop();
doubleTapSlop = configuration. getScaledDoubleTapSlop();
mMinimumFlingVelocity = configuration. getScaledMinimumFlingVelocity();
mMaximumFlingVelocity = configuration. getScaledMaximumFlingVelocity();
}
mTouchSlopSquare = touchSlop * touchSlop;//做平方好计算距离，后面的距离对比也是用平方
mDoubleTapTouchSlopSquare = doubleTapTouchSlop * doubleTapTouchSlop;
mDoubleTapSlopSquare = doubleTapSlop * doubleTapSlop;
}GestureDetector的创建就是初始化一些属性，获取一些数值作为阈值，然后把对应的Listener设置好。此外，注意到初始化了mHandler。mHandler是GestureHandler的一个实例，它是控制onShowPress()、onLongPress()、onSingleTapConfirmed()回调的关键：
private class GestureHandler extends Handler {
//两个构造方法，一个带参数handler，一个不带
GestureHandler() {
super();
}
GestureHandler(Handler handler) {
super(handler.getLooper());
}
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case SHOW_PRESS:
mListener.onShowPress( mCurrentDownEvent); //回调onShowPress方法
break;
case LONG_PRESS:
dispatchLongPress();//处理长按消息
break;
case TAP:
// 控制SingleTapConfirmed的回调
if (mDoubleTapListener != null) {
if (!mStillDown) { //此时手指已抬起，回调确认单击的方法
mDoubleTapListener. onSingleTapConfirmed(mCurrentDownEvent);
} else { //手指未抬起，那么就在手指抬起的时候回调确认单击的方法。也就是说如果处理Message时手指还没松开，就设置mDeferConfirmSingleTap为true，在UP事件的时候调用SingleTapConfirme
mDeferConfirmSingleTap = true;
}
}
break;
default:
throw new RuntimeException("Unknown message " + msg);
}
}
}在handler中调用了dispatchLongPress方法：
private void dispatchLongPress() { //长按处理
mHandler.removeMessages(TAP);
mDeferConfirmSingleTap = false;
mInLongPress = true;
mListener.onLongPress(mCurrentDownEvent);
}②onTouchEvent
这是GestureDetector的核心逻辑，也就是如何处理手势信息，并判断是具体的哪种手势：
public boolean onTouchEvent(MotionEvent ev) {
if (mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier. onTouchEvent(ev, 0); //检查事件输入的一致性，log出来一致性的信息，如：有事件只有up没有down
}
final int action = ev.getAction();
if(mCurrentMotionEvent != null) {
mCurrentMotionEvent.recycle();
}
mCurrentMotionEvent=MotionEvent.obtain(ev);
if (mVelocityTracker == null) {
mVelocityTracker = VelocityTracker.obtain();
}
mVelocityTracker.addMovement(ev); //初始化速度追踪器，并计算速度
//检测action是否有非主要手指抬起来了，如果是的话，记录它的index，下面计算的时候忽略这个触点
final boolean pointerUp = (action & MotionEvent.ACTION_MASK) == MotionEvent.ACTION_POINTER_UP;
final int skipIndex = pointerUp ? ev.getActionIndex() : -1;
final boolean isGeneratedGesture = (ev.get flag & MotionEvent.FLAG_IS_GENERATED_GESTURE) != 0;
float sumX = 0, sumY = 0;
final int count = ev.getPointerCount();
//下面需要得出x、y方向上的中心焦点。如果是多点触碰，则把所有还在触摸的手指的位置x、y加起来，后面求平均数，算出中心焦点
for (int i = 0; i < count; i++) {
if (skipIndex == i) continue; // 非主要手指抬起的话会跳过
sumX += ev.getX(i);
sumY += ev.getY(i);
}
final int div = pointerUp ? count - 1 : count; //pointerUp为true，需要排除掉
final float focusX = sumX / div; //中心焦点x
final float focusY = sumY / div;//中心焦点y
boolean handled = false;
switch (action & MotionEvent.ACTION_MASK){
case MotionEvent.ACTION_POINTER_DOWN:
//...
break;
case MotionEvent.ACTION_POINTER_UP:
//...
break;
case MotionEvent.ACTION_DOWN:
//...
break;
case MotionEvent.ACTION_MOVE:
//...
break;
case MotionEvent.ACTION_UP:
//...
break;
case MotionEvent.ACTION_CANCEL:
cancel();
break;
}
//对未被处理的事件进行一次一致性检测
if (!handled && mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier. onUnhandledEvent(ev, 0);
}
return handled;
}onTouchEvent()的主要思路就是先对输入事件做出统一处理，提取一些共有的信息，如多个点同时触摸时候的中心焦点和滑动速度等，然后根据事件的分类做出相应的处理。
注意：InputEventConsistencyVerifier对输入事件进行的一致性检测的结果并不影响GestureDetector的运行，如果检测到一致性不符合的事件（只有UP事件而前面没有DOWN事件），就只会输出log告诉开发者。
接下来看具体每个event是如何处理的。
③DOWN事件处理
case MotionEvent.ACTION_DOWN:
if (mDoubleTapListener != null) { //设置了双击监听器
//第一次点击的时候发送了TAP类型的消息，取消掉，防止出错
boolean hadTapMessage = mHandler.hasMessages(TAP);
if (hadTapMessage)
mHandler.removeMessages(TAP);
if ((mCurrentDownEvent != null) && (mPreviousUpEvent != null) && hadTapMessage && isConsideredDoubleTap( mCurrentDownEvent, mPreviousUpEvent, ev)) { //判断到这是第二次点击
mIsDoubleTapping = true;
handled |= mDoubleTapListener.onDou bleTap(mCurrentDownEvent); //回调双击方法，参数用的是双击里的第一次tap的down事件
handled |= mDoubleTapListener.onDou bleTapEvent(ev); //回调双击方法，参数用的是双击里第二次tap的down事件
} else {
//延时发出单击事件，如果到了时间还没有取消的话就确认是TAP事件了
mHandler.sendEmptyMessageDelayed( TAP, DOUBLE_TAP_TIMEOUT); //这是第一次的点击，先发送延时消息，如果时间到了(300ms)还没有取消的话(也就是没有再次点击)，GestureDetector就会处理这个TAP类型的消息
}
}
mDownFocusX = mLastFocusX = focusX;
mDownFocusY = mLastFocusY = focusY;
//重置mCurrentDownEvent
if (mCurrentDownEvent != null) {
mCurrentDownEvent.recycle();
}
mCurrentDownEvent = MotionEvent.obtain(ev);
mAlwaysInTapRegion = true;
mAlwaysInBiggerTapRegion = true;
mStillDown = true;
mInLongPress = false;
mDeferConfirmSingleTap = false;
if (mIsLongpressEnabled) { //允许长按
mHandler.removeMessages(LONG_PRESS);
mHandler.sendEmptyMessageAtTime( LONG_PRESS,mCurrentDownEvent.getDownTime() + TAP_TIMEOUT + LONGPRESS_TIMEOUT); //发送延时的长按消息，在TAP_TIMEOUT+ LONGPRESS_TIMEOUT这段时间内，如果没有其他手势操作(移动手指、抬起手指)，就会认为是长按手势，并且回调LongPress方法
} mHandler.sendEmptyMessageAtTime( SHOW_PRESS,mCurrentDownEvent.getDownTime() + TAP_TIMEOUT); //一小段时间后，延时发送showPress事件，反馈给用户
handled |= mListener.onDown(ev);
break;
down事件处理完了，里面有一个判断是不是双击的方法isConsideredDoubleTap，该方法用于判断第二次点击是否有效双击：
private boolean isConsideredDoubleTap( MotionEvent firstDown, MotionEvent firstUp, MotionEvent secondDown) {
if (!mAlwaysInBiggerTapRegion) { //第一次点击后，超出了限定范围，认为无效
return false;
}
final long deltaTime = secondDown. getEventTime() - firstUp.getEventTime();
if (deltaTime > DOUBLE_TAP_TIMEOUT || deltaTime < DOUBLE_TAP_MIN_TIME) { //第一次点击的手指抬起和第二次点击的手指落下，中间时间间隔不符合要求，无效
return false;
}
int deltaX = (int) firstDown.getX() - (int) secondDown.getX();
int deltaY = (int) firstDown.getY() - (int) secondDown.getY();
//判断第二次点击是否在附近，在附近才被认为是双击
return (deltaX * deltaX + deltaY * deltaY < mDoubleTapSlopSquare);
}对DOWN事件的处理逻辑：
1)单击判断：如果收到一次DOWN事件，而且前段时间没有DOWN事件的话，会发送一个延时的TAP信息，一段时间（300ms）之后没有被取消的话，就执行GestureHandler里面的TAP单击确认操作。
2)双击判断：如果前面也有一次DOWN事件，而且符合isConsideredDoubleTap()的条件（第一次点击后没有移动超出范围，第二次点击也在附近），就可以确认双击，执行onDoubleTap()和onDoubleTapEvent()的回调。
3)长按判断：先看用户是否允许检测长按，如果允许长按，在点击的时候就发送一个延时的长按消息，如果时间到了还没被取消的话就回调长按方法。
4)showPress判断：这个和长按差不多，就是时间（100ms）短了一点而已。
注意：handled是boolean变量，|=符号是用符号右边的值跟左边的值进行或运算再赋值给左边。a |= b等价于a = a | b，这里handled变量初始值为false，进行了多次|=操作，一旦有结果是true的话，handled最后的值就是true，所有结果都是false最后才会false，onTouchEvent()方法最后返回这个handled，就可以表示事件有没有被处理，实现了对事件处理的封装。
④MOVE事件处理
case MotionEvent.ACTION_MOVE:
if (mInLongPress || mInContextClick) {
break; //已经触发长按操作，一系列事件可以认为是长按，接下来不做其他处理
}
final float scrollX = mLastFocusX - focusX;
final float scrollY = mLastFocusY - focusY;
if (mIsDoubleTapping) { //双击过程中，会回调onDoubleTapEvent方法
handled |= mDoubleTapListener. onDoubleTapEvent(ev);
} else if (mAlwaysInTapRegion) { //在down事件里才会使mAlwaysInTapRegion为true
final int deltaX=(int) (focusX-mDownFocusX);
final int deltaY=(int) (focusY-mDownFocusY);
int distance=(deltaX*deltaX)+(deltaY*deltaY);
if (distance > mTouchSlopSquare) { //距离超过一个数值，可以认为是滑动，进入Scroll事件
handled = mListener.onScroll( mCurrentDownEvent, ev, scrollX, scrollY);
mLastFocusX = focusX;
mLastFocusY = focusY;
mAlwaysInTapRegion = false;
mHandler.removeMessages(TAP);
mHandler.removeMessages( SHOW_PRESS);
mHandler.removeMessages( LONG_PRESS);
}
if(distance > mDoubleTapTouchSlopSquare){
//如果移动距离超过允许范围，则不再可能认为移动事件是双击
mAlwaysInBiggerTapRegion = false;
}
} else if ((Math.abs(scrollX) >= 1) || (Math.abs(scrollY) >= 1)) {
//后续的Scroll移动，前面的是进入Scroll移动
handled = mListener.onScroll( mCurrentDownEvent, ev, scrollX, scrollY);
mLastFocusX = focusX;
mLastFocusY = focusY;
}
break;
//...对MOVE事件涉及：
1)onDoubleTapEvent()回调：只要确认是双击之后，mIsDoubleTapping为true，除了长按，后面的MOVE事件都会只回调onDoubleTapEvent()。
2)onScroll()回调：当MOVE不是长按，不是DoubleTapEvent之后，当移动距离大于一定距离之后，就会进入Scroll模式，然后两个MOVE事件的位移距离scrollX或者scrollY大于1px，都会调用onScroll()。
⑤UP事件的处理
case MotionEvent.ACTION_UP:
mStillDown = false;
MotionEvent currentUpEvent = MotionEvent.obtain(ev);
if (mIsDoubleTapping) {
//双击事件
handled |= mDoubleTapListener. onDoubleTapEvent(ev);
} else if (mInLongPress) {
//长按结束
mHandler.removeMessages(TAP);
mInLongPress = false;
} else if (mAlwaysInTapRegion && !mIgnoreNextUpEvent) {
handled = mListener.onSingleTapUp(ev);
//处理单击确认，具体逻辑看GestureHandler如何处理TAP事件
if (mDeferConfirmSingleTap && mDoubleTapListener != null) {
mDoubleTapListener.onSingleTapConf irmed(ev);
}
} else if (!mIgnoreNextUpEvent) {
//处理Fling，如果速度大于定义的最小速度（50），就回调Fling
// A fling must travel the minimum tap distance
final VelocityTracker velocityTracker = mVelocityTracker;
final int pointerId = ev.getPointerId(0);
velocityTracker.computeCurrentVelocity( 1000, mMaximumFlingVelocity);
final float velocityY = velocityTracker.getYVelocity(pointerId);
final float velocityX = velocityTracker.getXVelocity(pointerId);
if ((Math.abs(velocityY) > mMinimumFlingVelocity) || (Math.abs(velocityX) > mMinimumFlingVelocity)){
handled = mListener.onFling( mCurrentDownEvent, ev, velocityX, velocityY);
}
}
//重置mPreviousUpEvent
if (mPreviousUpEvent != null) {
mPreviousUpEvent.recycle();
}
// Hold the event we obtained above - listeners may have changed the original.
mPreviousUpEvent = currentUpEvent;
//回收mVelocityTracker
if (mVelocityTracker != null) {
// This may have been cleared when we called out to the
// application above.
mVelocityTracker.recycle();
mVelocityTracker = null;
}
mIsDoubleTapping = false;
mDeferConfirmSingleTap = false;
mIgnoreNextUpEvent = false;
mHandler.removeMessages(SHOW_PRESS);
mHandler.removeMessages(LONG_PRESS);
break;
//...UP事件涉及：
1)onSingleTapUp()回调：DOWN事件之后没有MOVE，或者MOVE的距离没有超出范围，mAlwaysInTapRegion才不会变成false，回调onSingleTapUp()。
2)onSingleTapConfirmed()回调：从前面GestureHandler里面的TAP消息的实现可以看到：
case TAP:
//这里控制SingleTapConfirmed的回调
if (mDoubleTapListener != null) {
if (!mStillDown) {
//如果已经松开，就立刻调用SingleTapConfirmed
mDoubleTapListener.onSingleTapConfi rmed( mCurrentDownEvent);
} else {
//如果处理Message的时候还没松开，就设置mDeferConfirmSingleTap为true，在UP事件的时候调用SingleTapConfirme
mDeferConfirmSingleTap = true;
}
}
break;之前看过，TAP消息是延时（300ms）发送的，然而实际逻辑中，是抬起手指才算是点击，所以这里处理TAP的时候就不一定立刻调用onSingleTapConfirmed()，而是判断手指是否松开了，是松开的话就立刻回调。如果还未松开那就把标志位mDeferConfirmSingleTap设置为true，等到收到UP事件的时候再回调。
3)onFling()回调：当UP事件的速度大于一定速度时，就会回调onFling()，至于mIgnoreNextUpEvent参数，是只有鼠标右键点击的时候才会为true。
⑥多点触摸的处理
对于多个手指落下，前面的统一处理已经是把所有手指的坐标值加起来然后算平均值了，所以多手指触摸的时候，其实滑动的实际点是这些手指的中心焦点。回看上面的MOVE事件处理，中心焦点的位置值FocusX和FocusY决定onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY)的后两个参数值，所以处理多点触控的话就使用它们比较方便。因为MotionEvent是使用数组装着当前屏幕上所有指针的动作的，使用前两个参数的话还要循环用getX(int pointerIndex)和getY(int pointerIndex)方法取出各个指针的值再自己处理。
case MotionEvent.ACTION_POINTER_DOWN:
mDownFocusX = mLastFocusX = focusX;
mDownFocusY = mLastFocusY = focusY;
//如果有多根手指按下，取消长按和点击计时
cancelTaps();
break;
case MotionEvent.ACTION_POINTER_UP:
mDownFocusX = mLastFocusX = focusX;
mDownFocusY = mLastFocusY = focusY;
//计算每一秒钟的滑动像素
mVelocityTracker.computeCurrentVelocity( 1000, mMaximumFlingVelocity);
final int upIndex = ev.getActionIndex();
final int id1 = ev.getPointerId(upIndex);
final float x1 = mVelocityTracker. getXVelocity(id1);
final float y1 = mVelocityTracker. getYVelocity(id1);
//如果剩下的手指速度方向是和抬起那根手指的速度相反方向的，就说明不是fling，清空速度监听
for (int i = 0; i < count; i++) {
if (i == upIndex) continue;
final int id2 = ev.getPointerId(i);
final float x = x1 * mVelocityTracker. getXVelocity(id2);
final float y = y1 * mVelocityTracker. getYVelocity(id2);
final float dot = x + y;
if (dot < 0) {
mVelocityTracker.clear();
break;
}
}
break;
//...
private void cancelTaps() {
mHandler.removeMessages(SHOW_PRESS);
mHandler.removeMessages(LONG_PRESS);
mHandler.removeMessages(TAP);
mIsDoubleTapping = false;
mAlwaysInTapRegion = false;
mAlwaysInBiggerTapRegion = false;
mDeferConfirmSingleTap = false;
mInLongPress = false;
mInContextClick = false;
mIgnoreNextUpEvent = false;
}这是对多个手指的UP和DOWN事件处理，其实就是做一些取消操作而让多点触摸不影响单点触摸的应用，例如在多个手指落下的时候取消点击信息等。
⑦ContextClick的处理
ContextClick的事件是由onGenericMotionEvent()传入：
public boolean onGenericMotionEvent( MotionEvent ev) {
if (mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier. onGenericMotionEvent(ev, 0);
}
final int actionButton = ev.getActionButton();
switch (ev.getActionMasked()) {
case MotionEvent.ACTION_BUTTON_PRESS:
//按下触控笔首选按钮或者鼠标右键
if (mContextClickListener != null && !mInContextClick && !mInLongPress && (actionButton == MotionEvent.BUTTON_STYLUS_PRIMARY || actionButton == MotionEvent.BUTTON_SECONDARY)) {
if (mContextClickListener. onContextClick(ev)) {
mInContextClick = true;
mHandler.removeMessages( LONG_PRESS);
mHandler.removeMessages(TAP);
return true;
}
}
break;
case MotionEvent.ACTION_BUTTON_RELEASE:
if (mInContextClick && (actionButton == MotionEvent.BUTTON_STYLUS_PRIMARY || actionButton == MotionEvent.BUTTON_SECONDARY)) {
mInContextClick = false;
//无视下一个UP事件，因为它是由鼠标右键或者触控笔键带起的
mIgnoreNextUpEvent = true;
}
break;
}
return false;
}由此可以，当按键按下（ACTION_BUTTON_PRESS）的时候已经回调onContextClick()。
4.ScaleGestureDetector
ScaleGestureDetector是用于处理缩放的工具类，用法与GestureDetector类似，都是通过onTouchEvent()关联相应的MotionEvent事件。
ScaleGestureDetector类提供了OnScaleGestureListener接口，处理缩放过程中的一些回调。
public interface OnScaleGestureListener {
//缩放进行中，返回值表示是否下次缩放需要重置，如果返回ture，那么detector就会重置缩放事件，如果返回false，detector会在之前的缩放上继续进行计算
public boolean onScale( ScaleGestureDetector detector);
//缩放开始，返回值表示是否受理后续的缩放事件
public boolean onScaleBegin( ScaleGestureDetector detector);
//缩放结束
public void onScaleEnd(ScaleGestureDetector detector);
}①onScaleBegin
当一个缩放手势开始时触发该事件，即双指按下屏幕时。该方法的返回值为boolean，主要用来判断探测器是否应该继续识别处理这个手势。例如，如果在屏幕上的某个区域内不需要识别缩放手势，当手势的焦点在该区域内时，onScaleBegin()可以返回false忽略不处理该手势的接下来的一系列事件。
②onScale
当一个缩放手势正在进行中时持续触发该事件，即双指正在屏幕上滑动。该方法的返回值为boolean，主要用来判断是否结束当前缩放手势事件，即本次缩放事件是否已被处理。如果已被处理，那么detector就会重置缩放事件；如果未被处理，detector会继续进行计算，修改getScaleFactor()的返回值，直到被处理为止。当返回true时，则结束当前缩放手势的一系列事件，缩放因子将会初始化为1.0，当返回false时，当前缩放手势的一系列事件继续进行，缩放因子不会被初始化，而是根据手势不断的持续变化。返回值可以用来限制缩放值的最大比例上限和最小比例下限。
③onScaleEnd
当一个缩放手势结束后触发该事件，即双指抬起离开屏幕时。
在缩放过程中，要通过ScaleGestureDetector来获取一些缩放信息。ScaleGestureDetector类提供了常用函数：
public boolean isInProgress(); //缩放是否正处在进行中
public float getFocusX(); //返回组成缩放手势(两个手指)中点x的位置
public float getFocusY(); //返回组成缩放手势(两个手指)中点y的位置
public float getCurrentSpan();组成缩放手势的两个触点的跨度(两个触点间的距离)
public float getCurrentSpanX(); //同上，x的距离
public float getCurrentSpanY(); //同上，y的距离
public float getPreviousSpan();组成缩放手势的两个触点的前一次缩放的跨度(两个触点间的距离)
public float getPreviousSpanX(); //同上，x的距离
public float getPreviousSpanY(); //同上，y的距离public float getScaleFactor(); //获取本次缩放事件的缩放因子，缩放事件以onScale()返回值为基准，一旦该方法返回true，代表本次事件结束，重新开启下次缩放事件。
getScaleFactor返回从之前的缩放手势和当前的缩放手势两者的比例因子，即缩放值，默认1.0。当手指做缩小操作时，该值小于1.0，当手指做放大操作时，该值大于1.0。在每一个缩放事件中都会从1.0开始变化，如果需要做持续性操作，则需要保存上一次的伸缩值，然后当前的伸缩值*上一次的伸缩值，得到连续变化的伸缩值，例如有3次事件发生，没连续性则是缩小0.9->缩小0.9->缩小0.9，如果做了连续性处理即保存上一次的伸缩值，则是缩小0.9->缩小0.9*0.9=0.81->缩小0.81*0.9=0.72，有了逐渐变小的连续性。
public long getTimeDelta(); //返回上次缩放事件结束时到当前的时间间隔
public long getEventTime(); //获取当前motion事件的时间5.ScaleGestureDetector使用
ScaleGestureDetector的使用很简单：
①定义ScaleGestureDetector类。
②将touch事件交给Scale GestureDetector，即在onTouchEvent函数里面调用ScaleGestureDetector的onTouchEvent函数。
③处理OnScaleGestureListener的各个回调。
注意：
①重写的三个回调方法里，如果在onScaleBegin里返回false，则永远不会回调onScale方法。
②如果onScaleBegin返回true，onScale返回false，则一次缩放手势里会回调一次onScaleBegin，回调多次onScale。
6.ScaleGestureDetector源码分析
ScaleGestureDetector的源码比GestureDetector的源码要稍微复杂点，因为ScaleGestureDetector的事件涉及到多个手指。
想要缩放的值，所有的MotionEvent事件都要交给ScaleGestureDetector的onTouchEvent()函数，所以直接来看onTouchEvent()函数大概的逻辑。
public boolean onTouchEvent(MotionEvent event) {
...
// 缩放的手势需要多个手指来完成，count表示 手指的个数
final int count = event.getPointerCount();
...
// streamComplete表示当前事件流是否完成
final boolean streamComplete = action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL || anchoredScaleCancelled;
if (action == MotionEvent.ACTION_DOWN || streamComplete) {
// mInProgress表示是否进行缩放，这里是停掉上一次的缩放调用onScaleEnd()
if (mInProgress) {
mListener.onScaleEnd(this);
mInProgress = false;
mInitialSpan = 0;
mAnchoredScaleMode = ANCHORED_SCALE_MODE_NONE;
} else if (inAnchoredScaleMode() && streamComplete) {
mInProgress = false;
mInitialSpan = 0;
mAnchoredScaleMode = ANCHORED_SCALE_MODE_NONE;
}
if (streamComplete) {
return true;
}
}
...
if (inAnchoredScaleMode()) {
...
} else {
// 所有手指的距离相加
for (int i = 0; i < count; i++) {
if (skipIndex == i) continue;
sumX += event.getX(i);
sumY += event.getY(i);
}
// 所有手指的中心点
focusX = sumX / div;
focusY = sumY / div;
}
// Determine average deviation from focal point
float devSumX = 0, devSumY = 0;
for (int i = 0; i < count; i++) {
if (skipIndex == i) continue;
// 所有手指相对于中心点(所有手指的中心点)的距离之和
devSumX += Math.abs(event.getX(i) - focusX);
devSumY += Math.abs(event.getY(i) - focusY);
}
// 所有手指相对于中心点的平均值
final float devX = devSumX / div;
final float devY = devSumY / div;
// *2 相当于是两个手指之间的距离跨度
final float spanX = devX * 2;
final float spanY = devY * 2;
final float span;
if (inAnchoredScaleMode()) {
span = spanY;
} else {
span = (float) Math.hypot(spanX, spanY);
}
...
final int minSpan = inAnchoredScaleMode() ? mSpanSlop : mMinSpan;
// 回调onScaleBegin()，返回值表示是否开始缩放
if (!mInProgress && span >= minSpan &&(wasInProgress || Math.abs(span - mInitialSpan) > mSpanSlop)) {
mPrevSpanX = mCurrSpanX = spanX;
mPrevSpanY = mCurrSpanY = spanY;
mPrevSpan = mCurrSpan = span;
mPrevTime = mCurrTime;
mInProgress = mListener.onScaleBegin(this);
}
// 回调onScale(),如果onScale()返回true,则重新保存mPrevSpanX，mPrevSpanY，mPrevSpan，mPrevTime
if (action == MotionEvent.ACTION_MOVE) {
mCurrSpanX = spanX;
mCurrSpanY = spanY;
mCurrSpan = span;
boolean updatePrev = true;
if (mInProgress) {
updatePrev = mListener.onScale(this);
}
if (updatePrev) {
mPrevSpanX = mCurrSpanX;
mPrevSpanY = mCurrSpanY;
mPrevSpan = mCurrSpan;
mPrevTime = mCurrTime;
}
}
return true;
}onTouchEvent()函数里面，要注意onScale()的返回值为true的时候mPrevSpanX，mPrevSpanY，mPrevSpan，mPrevTime这些才会改变。
再看下缩放过程中的缩放因子是怎么计算到的。getScaleFactor()函数：
public float getScaleFactor() {
...
return mPrevSpan > 0 ? mCurrSpan / mPrevSpan : 1;
}用当前两个手指之间的跨度除以上一次记录的两个手指之间的跨度。同时也注意到上面讲到的onTouchEvent()函数里面onScale()返回true的时候mPrevSpan才会重新赋值。比如两个手指放在屏幕上，手指慢慢的拉开。假设回调过程中onScale()函数每次返回的是true，每次onScale()之后getScaleFactor()会重新去计算缩放因子，但是如果onScale()函数返回的是false，getScaleFactor()的返回值是一直增大的。
7.同时使用ScaleGestureDetector.SimpleOnScaleGestureListener和GestureDetector.SimpleOnGestureListener
@Override
public boolean onTouchEvent(MotionEvent event) {
boolean res = mScaleGestureDetector.onTouchEvent(event);
if (!mScaleGestureDetector.isInProgress()) {
res = mGestureDetector.onTouchEvent(event);
}
return res;
}思路就是首先判断是不是在缩放过程中，如果不是缩放，才去执行mGestureDetector.onTouchEvent(event);
