Android 多点手势识别详解

google 提供的API中，有个类，大家都很熟悉，GestureDetector。使用它，我们可以识别用户通常会用的手势。但是，这个类不支持多点触摸（可能 google认为没有人会在几个手指都在屏幕上的时候，使用手势吧~），不过，最近和朋友们一起做的一个App，的确用到了多点手势（主要是 onScroll和onFling两个手势），所以，我就把这个类拓展了一下，来实现让多个控件各自跟着一跟手指实现拖动和滑动的效果。

顺便说一下，大家应该都知道，在Android3.0以后，Android的触摸事件的分配机制和以前的版本是有区别的。从3.0开始，用户在不同控件
上操作产生的touch消息不会相互干扰，touch消息会被分派到不同控件上的touchListener中处理。而

在以前的版本中，所有的touch消息，都会被分排到第一个碰到屏幕的手指所操作的控件的touchListener中处理，也就是说，会出现这样一个矛盾的现象：

在界面上有A,B,C三个控件，然后，当你先用食指按住A，跟着又用中指和无名指（嘛，别的手指也行，不用在意中指还是无名指）按住B,C。当中指和无
名指移动的时候，B和C都无法接收到这个ACTION_MOVE消息，而接收到消息的却是A。而在3.0以上版本中，并不存在这个问题。

使用以下的这个类，可以实现从2.2到3.2平台上手势识别的兼容。

代码区：

packagecom.finger.utils;

importjava.util.ArrayList;

importjava.util.List;

importandroid.content.Context;

importandroid.os.Handler;

importandroid.os.Message;

importandroid.view.MotionEvent;

importandroid.view.VelocityTracker;

importandroid.view.ViewConfiguration;

publicclassMultiTouchGestureDetector {

@SuppressWarnings("unused")

privatestaticfinalString MYTAG ="Ray";

publicstaticfinalString CLASS_NAME ="MultiTouchGestureDetector";

/**

* 事件信息类 <br/>

* 用来记录一个手势

*/

privateclassEventInfo {

privateMultiMotionEvent mCurrentDownEvent; //当前的down事件

privateMultiMotionEvent mPreviousUpEvent; //上一次up事件

privatebooleanmStillDown; //当前手指是否还在屏幕上

privatebooleanmInLongPress; //当前事件是否属于长按手势

privatebooleanmAlwaysInTapRegion; //是否当前手指仅在小范围内移动，当手指仅在小范围内移动时，视为手指未曾移动过，不会触发onScroll手势

privatebooleanmAlwaysInBiggerTapRegion; //是否当前手指在较大范围内移动，仅当此值为true时，双击手势才能成立

privatebooleanmIsDoubleTapping; //当前手势，是否为双击手势

privatefloatmLastMotionY; //最后一次事件的X坐标

privatefloatmLastMotionX; //最后一次事件的Y坐标

privateEventInfo(MotionEvent e) {

this(newMultiMotionEvent(e));

}

privateEventInfo(MultiMotionEvent me) {

mCurrentDownEvent = me;

mStillDown =true;

mInLongPress =false;

mAlwaysInTapRegion =true;

mAlwaysInBiggerTapRegion =true;

mIsDoubleTapping =false;

}

//释放MotionEven对象，使系统能够继续使用它们

publicvoidrecycle() {

if(mCurrentDownEvent !=null) {

mCurrentDownEvent.recycle();

mCurrentDownEvent =null;

}

if(mPreviousUpEvent !=null) {

mPreviousUpEvent.recycle();

mPreviousUpEvent =null;

}

}

@Override

publicvoidfinalize() {

this.recycle();

}

}

/**

* 多点事件类 <br/>

* 将一个多点事件拆分为多个单点事件，并方便获得事件的绝对坐标

* <br/> 绝对坐标用以在界面中找到触点所在的控件

* @author ray-ni

*/

publicclassMultiMotionEvent {

privateMotionEvent mEvent;

privateintmIndex;

privateMultiMotionEvent(MotionEvent e) {

mEvent = e;

mIndex = (e.getAction() &
MotionEvent.ACTION_POINTER_ID_MASK) >>
MotionEvent.ACTION_POINTER_ID_SHIFT; //等效于 mEvent.getActionIndex();

}

privateMultiMotionEvent(MotionEvent e,intidx) {

mEvent = e;

mIndex = idx;

}

// 行为

publicintgetAction() {

intaction = mEvent.getAction() & MotionEvent.ACTION_MASK; //等效于 mEvent.getActionMasked();

switch(action) {

caseMotionEvent.ACTION_POINTER_DOWN:

action = MotionEvent.ACTION_DOWN;

break;

caseMotionEvent.ACTION_POINTER_UP:

action = MotionEvent.ACTION_UP;

break;

}

returnaction;

}

// 返回X的绝对坐标

publicfloatgetX() {

returnmEvent.getX(mIndex) + mEvent.getRawX() - mEvent.getX();

}

// 返回Y的绝对坐标

publicfloatgetY() {

returnmEvent.getY(mIndex) + mEvent.getRawY() - mEvent.getY();

}

// 事件发生的时间

publiclonggetEventTime() {

returnmEvent.getEventTime();

}

// 事件序号

publicintgetIndex() {

returnmIndex;

}

// 事件ID

publicintgetId() {

returnmEvent.getPointerId(mIndex);

}

// 释放事件对象，使系统能够继续使用

publicvoidrecycle() {

if(mEvent !=null) {

mEvent.recycle();

mEvent =null;

}

}

}

// 多点手势监听器

publicinterfaceMultiTouchGestureListener {

// 手指触碰到屏幕，由一个 ACTION_DOWN触发

booleanonDown(MultiMotionEvent e);

// 确定一个press事件，强调手指按下的一段时间（TAP_TIMEOUT）内，手指未曾移动或抬起

voidonShowPress(MultiMotionEvent e);

// 手指点击屏幕后离开，由 ACTION_UP引发，可以简单的理解为单击事件，即手指点击时间不长（未构成长按事件），也不曾移动过

booleanonSingleTapUp(MultiMotionEvent e);

// 长按，手指点下后一段时间（DOUBLE_TAP_TIMEOUT）内，不曾抬起或移动

voidonLongPress(MultiMotionEvent e);

// 拖动，由ACTION_MOVE触发，手指地按下后，在屏幕上移动

booleanonScroll(MultiMotionEvent e1, MultiMotionEvent e2,floatdistanceX,floatdistanceY);

// 滑动，由ACTION_UP触发，手指按下并移动一段距离后，抬起时触发

booleanonFling(MultiMotionEvent e1, MultiMotionEvent e2,floatvelocityX,floatvelocityY);

}

// 多点双击监听器

publicinterfaceMultiTouchDoubleTapListener {

// 单击事件确认，强调第一个单击事件发生后，一段时间内，未发生第二次单击事件，即确定不会触发双击事件

booleanonSingleTapConfirmed(MultiMotionEvent e);

// 双击事件， 由ACTION_DOWN触发，从第一次单击事件的DOWN事件开始的一段时间(DOUBLE_TAP_TIMEOUT)内结束（即手指），

// 并且在第一次单击事件的UP时间开始后的一段时间内（DOUBLE_TAP_TIMEOUT）发生第二次单击事件，

// 除此之外两者坐标间距小于定值（DOUBLE_TAP_SLAP）时，则触发双击事件

booleanonDoubleTap(MultiMotionEvent e);

// 双击事件，与onDoubleTap事件不同之处在于，构成双击的第二次点击的ACTION_DOWN,ACTION_MOVE和ACTION_UP都会触发该事件

booleanonDoubleTapEvent(MultiMotionEvent e);

}

// 事件信息队列，队列的下标与MotionEvent的pointId对应

privatestaticList<EventInfo> sEventInfos =newArrayList<EventInfo>(10);

// 双击判断队列，这个队列中的元素等待双击超时的判断结果

privatestaticList<EventInfo> sEventForDoubleTap =newArrayList<EventInfo>(5);

// 指定大点击区域的大小（这个比较拗口），这个值主要用于帮助判断双击是否成立

privateintmBiggerTouchSlopSquare =20*20;

// 判断是否构成onScroll手势，当手指在这个范围内移动时，不触发onScroll手势

privateintmTouchSlopSquare;

// 判断是否构成双击，只有两次点击的距离小于该值，才能构成双击手势

privateintmDoubleTapSlopSquare;

// 最小滑动速度

privateintmMinimumFlingVelocity;

// 最大滑动速度

privateintmMaximumFlingVelocity;

// 长按阀值，当手指按下后，在该阀值的时间内，未移动超过mTouchSlopSquare的距离并未抬起，则长按手势触发

privatestaticfinalintLONGPRESS_TIMEOUT = ViewConfiguration.getLongPressTimeout();

// showPress手势的触发阀值，当手指按下后，在该阀值的时间内，未移动超过mTouchSlopSquare的距离并未抬起，则showPress手势触发

privatestaticfinalintTAP_TIMEOUT = ViewConfiguration.getTapTimeout();

// 双击超时阀值，仅在两次双击事件的间隔（第一次单击的UP事件和第二次单击的DOWN事件）小于此阀值，双击事件才能成立

privatestaticfinalintDOUBLE_TAP_TIMEOUT = ViewConfiguration.getDoubleTapTimeout();

// 双击区域阀值，仅在两次双击事件的距离小于此阀值，双击事件才能成立

privatestaticfinalintDOUBLE_TAP_SLAP =64;

// GestureHandler所处理的Message的what属性可能为以下 常量：

// showPress手势

privatestaticfinalintSHOW_PRESS =1;

// 长按手势

privatestaticfinalintLONG_PRESS =2;

// SingleTapConfirmed手势

privatestaticfinalintTAP_SINGLE =3;

// 双击手势

privatestaticfinalintTAP_DOUBLE =4;

// 手势处理器

privatefinalGestureHandler mHandler;

// 手势监听器

privatefinalMultiTouchGestureListener mListener;

// 双击监听器

privateMultiTouchDoubleTapListener mDoubleTapListener;

// 长按允许阀值

privatebooleanmIsLongpressEnabled;

// 速度追踪器

privateVelocityTracker mVelocityTracker;

privateclassGestureHandlerextendsHandler {

GestureHandler() {

super();

}

GestureHandler(Handler handler) {

super(handler.getLooper());

}

@Override

publicvoidhandleMessage(Message msg) {

intidx = (Integer) msg.obj;

switch(msg.what) {

caseSHOW_PRESS: {

if(idx >= sEventInfos.size()) {

// Log.w(MYTAG, CLASS_NAME + ":handleMessage,
msg.what = SHOW_PRESS, idx=" + idx + ", while sEventInfos.size()="

// + sEventInfos.size());

break;

}

EventInfo info = sEventInfos.get(idx);

if(info ==null) {

// Log.e(MYTAG, CLASS_NAME + ":handleMessage, msg.what = SHOW_PRESS, idx=" + idx + ", Info = null");

break;

}

// 触发手势监听器的onShowPress事件

mListener.onShowPress(info.mCurrentDownEvent);

break;

}

caseLONG_PRESS: {

// Log.d(MYTAG, CLASS_NAME + ":trigger LONG_PRESS");

if(idx >= sEventInfos.size()) {

// Log.w(MYTAG, CLASS_NAME + ":handleMessage,
msg.what = LONG_PRESS, idx=" + idx + ", while sEventInfos.size()="

// + sEventInfos.size());

break;

}

EventInfo info = sEventInfos.get(idx);

if(info ==null) {

// Log.e(MYTAG, CLASS_NAME + ":handleMessage, msg.what = LONG_PRESS, idx=" + idx + ", Info = null");

break;

}

dispatchLongPress(info, idx);

break;

}

caseTAP_SINGLE: {

// Log.d(MYTAG, CLASS_NAME + ":trriger TAP_SINGLE");

// If the user's finger is still down, do not count it as a tap

if(idx >= sEventInfos.size()) {

// Log.e(MYTAG, CLASS_NAME + ":handleMessage,
msg.what = TAP_SINGLE, idx=" + idx + ", while sEventInfos.size()="

// + sEventInfos.size());

break;

}

EventInfo info = sEventInfos.get(idx);

if(info ==null) {

// Log.e(MYTAG, CLASS_NAME + ":handleMessage, msg.what = TAP_SINGLE, idx=" + idx + ", Info = null");

break;

}

if(mDoubleTapListener !=null&& !info.mStillDown) {//手指在双击超时的阀值内未离开屏幕进行第二次单击事件，则确定单击事件成立（不再触发双击事件）

mDoubleTapListener.onSingleTapConfirmed(info.mCurrentDownEvent);

}

break;

}

caseTAP_DOUBLE: {

if(idx >= sEventForDoubleTap.size()) {

// Log.w(MYTAG, CLASS_NAME + ":handleMessage,
msg.what = TAP_DOUBLE, idx=" + idx + ", while
sEventForDoubleTap.size()="

// + sEventForDoubleTap.size());

break;

}

EventInfo info = sEventForDoubleTap.get(idx);

if(info ==null) {

// Log.w(MYTAG, CLASS_NAME + ":handleMessage, msg.what = TAP_DOUBLE, idx=" + idx + ", Info = null");

break;

}

sEventForDoubleTap.set(idx,null);// 这个没什么好做的，就是把队列中对应的元素清除而已

break;

}

default:

thrownewRuntimeException("Unknown message "+ msg);// never

}

}

}

/**

* 触发长按事件

* @param info

* @param idx

*/

privatevoiddispatchLongPress(EventInfo info,intidx) {

mHandler.removeMessages(TAP_SINGLE, idx);//移除单击事件确认

info.mInLongPress =true;

mListener.onLongPress(info.mCurrentDownEvent);

}

/**

* 构造器1

* @param context

* @param listener

*/

publicMultiTouchGestureDetector(Context context, MultiTouchGestureListener listener) {

this(context, listener,null);

}

/**

* 构造器2

* @param context

* @param listener

* @param handler

*/

publicMultiTouchGestureDetector(Context context, MultiTouchGestureListener listener, Handler handler) {

if(handler !=null) {

mHandler =newGestureHandler(handler);

}else{

mHandler =newGestureHandler();

}

mListener = listener;

if(listenerinstanceofMultiTouchDoubleTapListener) {

setOnDoubleTapListener((MultiTouchDoubleTapListener) listener);

}

init(context);

}

/**

* 初始化识别器

* @param context

*/

privatevoidinit(Context context) {

if(mListener ==null) {

thrownewNullPointerException("OnGestureListener must not be null");

}

mIsLongpressEnabled =true;

inttouchSlop, doubleTapSlop;

if(context ==null) {

touchSlop = ViewConfiguration.getTouchSlop();

doubleTapSlop = DOUBLE_TAP_SLAP;

mMinimumFlingVelocity = ViewConfiguration.getMinimumFlingVelocity();

mMaximumFlingVelocity = ViewConfiguration.getMaximumFlingVelocity();

}else{//允许识别器在App中，使用偏好的设定

finalViewConfiguration configuration = ViewConfiguration.get(context);

touchSlop = configuration.getScaledTouchSlop();

doubleTapSlop = configuration.getScaledDoubleTapSlop();

mMinimumFlingVelocity = configuration.getScaledMinimumFlingVelocity();

mMaximumFlingVelocity = configuration.getScaledMaximumFlingVelocity();

}

mTouchSlopSquare = touchSlop * touchSlop /16;

mDoubleTapSlopSquare = doubleTapSlop * doubleTapSlop;

}

/**

* 设置双击监听器

* @param onDoubleTapListener

*/

publicvoidsetOnDoubleTapListener(MultiTouchDoubleTapListener onDoubleTapListener) {

mDoubleTapListener = onDoubleTapListener;

}

/**

* 设置是否允许长按

* @param isLongpressEnabled

*/

publicvoidsetIsLongpressEnabled(booleanisLongpressEnabled) {

mIsLongpressEnabled = isLongpressEnabled;

}

/**

* 判断是否允许长按

* @return

*/

publicbooleanisLongpressEnabled() {

returnmIsLongpressEnabled;

}

/**

* 判断当前事件是否为双击事件

* <br/> 通过遍历sEventForDoubleTap来匹配是否存在能够构成双击事件的单击事件

* @param e

* @return

*/

privateEventInfo checkForDoubleTap(MultiMotionEvent e) {

if(sEventForDoubleTap.isEmpty()) {

// Log.e(MYTAG, CLASS_NAME + ":checkForDoubleTap(), sEventForDoubleTap is empty !");

returnnull;

}

for(inti =0; i < sEventForDoubleTap.size(); i++) {

EventInfo info = sEventForDoubleTap.get(i);

if(info !=null&& isConsideredDoubleTap(info, e)) {

sEventForDoubleTap.set(i,null);// 这个单击事件已经被消耗了，所以置为null

mHandler.removeMessages(TAP_DOUBLE, i);// 移除Handler内的为处理消息

returninfo;

}

}

returnnull;

}

/**

* 判断当前按下事件是否能和指定的单击事件构成双击事件

*

* @param info

* @param secondDown

* @return

*/

privatebooleanisConsideredDoubleTap(EventInfo info, MultiMotionEvent secondDown) {

if(!info.mAlwaysInBiggerTapRegion) {//如多第一次单击事件有过较大距离的移动，则无法构成双击事件

returnfalse;

}

if(secondDown.getEventTime() - info.mPreviousUpEvent.getEventTime() > DOUBLE_TAP_TIMEOUT) {

//如果第一次单击的UP时间和第二次单击的down时间时间间隔大于DOUBLE_TAP_TIMEOUT，也无法构成双击事件

returnfalse;

}

intdeltaX = (int) info.mCurrentDownEvent.getX() - (int) secondDown.getX();

intdeltaY = (int) info.mCurrentDownEvent.getY() - (int) secondDown.getY();

return(deltaX * deltaX + deltaY * deltaY < mDoubleTapSlopSquare);//最后判断两次单击事件的距离

}

/**

* 将事件信息放入双击判断队列，并返回序号

*

* @param info

* @return

*/

privateintaddIntoTheMinIndex(EventInfo info) {

for(inti =0; i < sEventForDoubleTap.size(); i++) {

if(sEventForDoubleTap.get(i) ==null) {

sEventForDoubleTap.set(i, info);

returni;

}

}

sEventForDoubleTap.add(info);

returnsEventForDoubleTap.size() -1;

}

/**

* 从事件信息队列中移除指定序号的事件

*

* @param idx

*/

privatevoidremoveEventFromList(intid) {

if(id > sEventInfos.size() || id <0) {

// Log.e(MYTAG, CLASS_NAME + ".removeEventFromList(), id=" +
id + ", while sEventInfos.size() =" + sEventInfos.size());

return;

}

sEventInfos.set(id,null);

}

/**

* 向事件队列中添加新信息

*

* @param e

*/

privatevoidaddEventIntoList(EventInfo info) {

intid = info.mCurrentDownEvent.getId();

if(id < sEventInfos.size()) {

// if (sEventInfos.get(id) != null)

// Log.e(MYTAG, CLASS_NAME + ".addEventIntoList, info(" + id + ") has not set to null !");

sEventInfos.set(info.mCurrentDownEvent.getId(), info);

}elseif(id == sEventInfos.size()) {

sEventInfos.add(info);

}else{

// Log.e(MYTAG, CLASS_NAME + ".addEventIntoList, invalidata id !");

}

}

publicbooleanonTouchEvent(MotionEvent ev) {

if(mVelocityTracker ==null) {

mVelocityTracker = VelocityTracker.obtain();

}

mVelocityTracker.addMovement(ev);//把所有事件都添加到速度追踪器，为计算速度做准备

booleanhandled =false;

finalintaction = ev.getAction();//获取Action

// int idx = (action & MotionEvent.ACTION_POINTER_INDEX_MASK)
>> MotionEvent.ACTION_POINTER_INDEX_SHIFT;//获取触摸事件的序号

intidx = ev.getPointerId(ev.getActionIndex());//获取触摸事件的id

switch(action & MotionEvent.ACTION_MASK) {

caseMotionEvent.ACTION_DOWN:

caseMotionEvent.ACTION_POINTER_DOWN: {

EventInfo info =newEventInfo(MotionEvent.obtain(ev));

this.addEventIntoList(info);//将手势信息保存到队列中

if(mDoubleTapListener !=null) {//如果双击监听器不为null

if(mHandler.hasMessages(TAP_DOUBLE)) {

MultiMotionEvent e =newMultiMotionEvent(ev);

EventInfo origInfo = checkForDoubleTap(e);//检查是否构成双击事件

if(origInfo !=null) {

info.mIsDoubleTapping =true;

handled |= mDoubleTapListener.onDoubleTap(origInfo.mCurrentDownEvent);

handled |= mDoubleTapListener.onDoubleTapEvent(e);

}

}

if(!info.mIsDoubleTapping) {//当前事件不构成双击事件，那么发送延迟消息以判断onSingleTapConfirmed事件

mHandler.sendMessageDelayed(mHandler.obtainMessage(TAP_SINGLE, idx), DOUBLE_TAP_TIMEOUT);

// Log.d(MYTAG, CLASS_NAME + ": add TAP_SINGLE");

}

}

// 记录X坐标和Y坐标

info.mLastMotionX = info.mCurrentDownEvent.getX();

info.mLastMotionY = info.mCurrentDownEvent.getY();

if(mIsLongpressEnabled) {//允许长按

mHandler.removeMessages(LONG_PRESS, idx);

mHandler.sendMessageAtTime(mHandler.obtainMessage(LONG_PRESS, idx),
info.mCurrentDownEvent.getEventTime() + TAP_TIMEOUT

+ LONGPRESS_TIMEOUT);//延时消息以触发长按手势

// Log.d(MYTAG, CLASS_NAME +

// ":add LONG_PRESS to handler for idx " + idx);

}

mHandler.sendMessageAtTime(mHandler.obtainMessage(SHOW_PRESS, idx),
info.mCurrentDownEvent.getEventTime() + TAP_TIMEOUT);//
延时消息，触发showPress手势

handled |= mListener.onDown(info.mCurrentDownEvent);//触发onDown（）

break;

}

caseMotionEvent.ACTION_UP:

caseMotionEvent.ACTION_POINTER_UP: {

MultiMotionEvent currentUpEvent =newMultiMotionEvent(ev);

if(idx >= sEventInfos.size()) {

// Log.e(MYTAG, CLASS_NAME + ":ACTION_POINTER_UP, idx=" +
idx + ", while sEventInfos.size()=" + sEventInfos.size());

break;

}

EventInfo info = sEventInfos.get(currentUpEvent.getId());

if(info ==null) {

// Log.e(MYTAG, CLASS_NAME + ":ACTION_POINTER_UP, idx=" + idx + ", Info = null");

break;

}

info.mStillDown =false;

if(info.mIsDoubleTapping) {//处于双击状态，则触发onDoubleTapEvent事件

handled |= mDoubleTapListener.onDoubleTapEvent(currentUpEvent);

}elseif(info.mInLongPress) {//处于长按状态

mHandler.removeMessages(TAP_SINGLE, idx);//可以无视这行代码

info.mInLongPress =false;

}elseif(info.mAlwaysInTapRegion) {//尚未移动过

if(mHandler.hasMessages(TAP_SINGLE, idx)) {//还在双击的时间阀值内，所以要为双击判断做额外处理

mHandler.removeMessages(TAP_SINGLE, idx);

info.mPreviousUpEvent =newMultiMotionEvent(MotionEvent.obtain(ev));

intindex =this.addIntoTheMinIndex(info);// 把当前事件放入队列，等待双击的判断

mHandler.sendMessageAtTime(mHandler.obtainMessage(TAP_DOUBLE, index), info.mCurrentDownEvent.getEventTime()

+ DOUBLE_TAP_TIMEOUT);// 将双击超时判断添加到Handler

// Log.d(MYTAG, CLASS_NAME + ": add TAP_DOUBLE");

}

handled = mListener.onSingleTapUp(currentUpEvent);//触发onSingleTapUp事件

}else{

// A fling must travel the minimum tap distance

finalVelocityTracker velocityTracker = mVelocityTracker;

velocityTracker.computeCurrentVelocity(1000, mMaximumFlingVelocity);//计算1秒钟内的滑动速度

//获取X和Y方向的速度

finalfloatvelocityX = velocityTracker.getXVelocity(idx);

finalfloatvelocityY = velocityTracker.getYVelocity(idx);

// Log.i(MYTAG, CLASS_NAME + ":ACTION_POINTER_UP, idx=" + idx +

// ", vx=" + velocityX + ", vy=" + velocityY);

// 触发滑动事件

if((Math.abs(velocityY) > mMinimumFlingVelocity) || (Math.abs(velocityX) > mMinimumFlingVelocity)) {

handled = mListener.onFling(info.mCurrentDownEvent, currentUpEvent, velocityX, velocityY);

}

}

// Hold the event we obtained above - listeners may have changed the

// original.

if(action == MotionEvent.ACTION_UP) { //释放速度追踪器

mVelocityTracker.recycle();

mVelocityTracker =null;

// Log.w(MYTAG, CLASS_NAME +

// ":ACTION_POINTER_UP, mVelocityTracker.recycle()");

}

info.mIsDoubleTapping =false;

// Log.d(MYTAG, CLASS_NAME + "remove LONG_PRESS");

// 移除showPress和长按消息

mHandler.removeMessages(SHOW_PRESS, idx);

mHandler.removeMessages(LONG_PRESS, idx);

removeEventFromList(currentUpEvent.getId());//手指离开，则从队列中删除手势信息

break;

}

caseMotionEvent.ACTION_MOVE:

for(intrIdx =0; rIdx < ev.getPointerCount(); rIdx++) {//因为无法确定当前发生移动的是哪个手指，所以遍历处理所有手指

MultiMotionEvent e =newMultiMotionEvent(ev, rIdx);

if(e.getId() >= sEventInfos.size()) {

// Log.e(MYTAG, CLASS_NAME + ":ACTION_MOVE, idx=" +
rIdx + ", while sEventInfos.size()=" + sEventInfos.size());

break;

}

EventInfo info = sEventInfos.get(e.getId());

if(info ==null) {

// Log.e(MYTAG, CLASS_NAME + ":ACTION_MOVE, idx=" + rIdx + ", Info = null");

break;

}

if(info.mInLongPress) { //长按，则不处理move事件

break;

}

//当前坐标

floatx = e.getX();

floaty = e.getY();

//距离上次事件移动的位置

finalfloatscrollX = x - info.mLastMotionX;

finalfloatscrollY = y - info.mLastMotionY;

if(info.mIsDoubleTapping) {//双击事件

handled |= mDoubleTapListener.onDoubleTapEvent(e);

}elseif(info.mAlwaysInTapRegion) {//该手势尚未移动过（移动的距离小于mTouchSlopSquare,视为未移动过）

// 计算从落下到当前事件，移动的距离

finalintdeltaX = (int) (x - info.mCurrentDownEvent.getX());

finalintdeltaY = (int) (y - info.mCurrentDownEvent.getY());

// Log.d(MYTAG, CLASS_NAME + "deltaX="+deltaX+";deltaY=" +

// deltaX +"mTouchSlopSquare=" + mTouchSlopSquare);

intdistance = (deltaX * deltaX) + (deltaY * deltaY);

if(distance > mTouchSlopSquare) { // 移动距离超过mTouchSlopSquare

handled = mListener.onScroll(info.mCurrentDownEvent, e, scrollX, scrollY);

info.mLastMotionX = e.getX();

info.mLastMotionY = e.getY();

info.mAlwaysInTapRegion =false;

// Log.d(MYTAG, CLASS_NAME +

// ":remove LONG_PRESS for idx" + rIdx +

// ",mTouchSlopSquare("+mTouchSlopSquare+"), distance("+distance+")");

// 清除onSingleTapConform，showPress,longPress三种消息

intid = e.getId();

mHandler.removeMessages(TAP_SINGLE, id);

mHandler.removeMessages(SHOW_PRESS, id);

mHandler.removeMessages(LONG_PRESS, id);

}

if(distance > mBiggerTouchSlopSquare) {//移动距离大于mBiggerTouchSlopSquare，则无法构成双击事件

info.mAlwaysInBiggerTapRegion =false;

}

}elseif((Math.abs(scrollX) >=1) || (Math.abs(scrollY) >=1)) {//之前已经移动过了

handled = mListener.onScroll(info.mCurrentDownEvent, e, scrollX, scrollY);

info.mLastMotionX = x;

info.mLastMotionY = y;

}

}

break;

caseMotionEvent.ACTION_CANCEL:

cancel();//清理

}

returnhandled;

}

// 清理所有队列

privatevoidcancel() {

mHandler.removeMessages(SHOW_PRESS);

mHandler.removeMessages(LONG_PRESS);

mHandler.removeMessages(TAP_SINGLE);

mVelocityTracker.recycle();

mVelocityTracker =null;

sEventInfos.clear();

sEventForDoubleTap.clear();

}

}