其他相关博文：

一、多点触控

当多点同时触摸屏幕时，系统将会产生如下的触摸事件：

1.ACTION_DOWN：触摸屏幕的第一个点。此时手势开始。该点的数据通常在MotionEvent事件队列索引位置0处。

2.ACTION_POINTER_DOWN：除了第一个点的其他触摸点数据。该点的数据的索引位置由getActionIndex()方法返回。

3.ACTION_MOVE：在手势过程中发生的一次变化。

4.ACTION_POINTER_UP：当不是第一个点的其他点UP后触发。

5.ACTION_UP：当手势中的最后一个点离开屏幕。

简单测试范例

布局xml代码如下:

xmlns:tools="http://schemas.android.com/tools"

android:id="@+id/layout1"

android:layout_width="match_parent"

android:layout_height="match_parent"

android:tag="true布局"

tools:context=".MainActivity" >

android:id="@+id/message"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:tag="true控件"

android:text="@string/hello_world" />

java代码如下:package com.lonshine.d_touchduodian;

import android.os.Bundle;

import android.app.Activity;

import android.util.Log;

import android.view.MotionEvent;

import android.view.View;

import android.view.View.OnTouchListener;

import android.widget.RelativeLayout;

public class MainActivity extends Activity implements OnTouchListener

{

@Override

protected void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

RelativeLayout layout = (RelativeLayout) findViewById(R.id.layout1);

layout.setOnTouchListener(this);

}

@Override

public boolean onTouch(View v, MotionEvent event)

{

String tag = v.getTag().toString();

Log.e(tag, "**********************************************");

Log.e(tag, "**********************************************");

Log.e(tag, "触摸的是:" + tag);

Log.e(tag, describeEvent(event));

logAction(event);

Log.e(tag, "**********************************************");

Log.e(tag, "**********************************************");

Log.e("", "                        ");

Log.e("", "                        ");

if("true".equals(tag.substring(0, 4)))

{

return true;

}

else

{

return false;

}

}

protected static String describeEvent(MotionEvent event)

{

StringBuilder sb = new StringBuilder(500);

sb.append("Action: ").append(event.getAction()).append("\n");// 获取触控动作比如ACTION_DOWN

int count = event.getPointerCount();

sb.append("触点个数: ").append(count).append("\n");

int i = 0;

while (i

{

sb.append("-------------------------").append("\n");

int pointerId = event.getPointerId(i);

sb.append("触点序号: ").append(i).append("\n");

sb.append("触点ID : ").append(pointerId).append("\n");

sb.append("相对坐标: ").append(event.getX(i)).append("  *  ").append(event.getY(i)).append("\n");

sb.append("压力       : ").append(event.getPressure(i)).append("\n");// 压力值,0-1之间,看情况,很可能始终返回1

sb.append("范围大小: ").append(event.getSize(i)).append("\n");// 指压范围

i++;

sb.append("-------------------------").append("\n");

}

sb.append("按下时间: ").append(event.getDownTime()).append("ms   ");

sb.append("结束时间: ").append(event.getEventTime()).append("ms   ");

sb.append("运行时间: ").append(event.getEventTime() - event.getDownTime()).append("ms\n");

return sb.toString();

}

private void logAction(MotionEvent event)

{

int masked = event.getActionMasked();

int index = event.getActionIndex();

int pointerId = event.getPointerId(index);

if(masked == 5 || masked == 6)

{

masked = masked - 5;

}

Log.e("Action", "触点序号: " + index);

Log.e("Action", "触点ID ：  " + pointerId);

Log.e("Action", "ActionMasked :" + masked);

}

}

多点触控的日志打印出来太多，此处仅针对日志输出作简单分析：

A.按下第一根手指时，获得一个索引为0且指针ID为0的指针(ACTION_DOWN = 0);

B.接下去action输出为2(ACTION_MOVE)，此时仍然仅有一个指针，并且索引和ID都为0;

C.然后按下第二根手指，action值输出为261。此值由两部分组成：一个是指针索引，一个是指针正在执行何种操作;

D.将十进制261转换为十六进制数为0x00000105。其中01代表指针索引，05代表操作值(即ACTION_POINTER_DOWN的值，用于多点触摸场景);

E.依此类推，当按下第三根手指时action输出值为0x00000205(十进制517)，第四根则为0x000305(十进制773);

F.当第一根手指离开屏幕时，action值为0x00000006(十进制6)，即索引为0，操作值为6(即ACTION_POINTER_UP);

G.如果此时第二根手指离开时,action值应该为0x00000106(十进制262)，因为此时仍然拥有两根手指的信息;

H.而实际结果并没有得到262的action值，这是因为当第一根手指离开屏幕后，第二根手指的索引从1更改成了0，但是指针ID仍然为1.

I.对于每一次移动，action值将始终为2，因为ACTION_MOVE事件并没有包含哪根手指在移动的信息。

附：依次按下四根手指的日志

其他小结:

(1)getPointerCount() 获得触屏的点数，

getActionIndex()获得触点的指针索引，

getPointerId(index)获得指针索引对应的触点ID；

(2)getActionMasked()表示用于多点触控检测点。而在1.6和2.1中并没有event.getActionMasked()这个方法，其实他就是把event.getAction()& MotionEvent.ACTION_MASK封装了一下。

二、其他参考范例：

(一)单点触摸拖动图片与多点触摸缩放图片package com.lonshine.touchdemo;

import android.app.Activity;

import android.content.Context;

import android.graphics.*;

import android.graphics.drawable.BitmapDrawable;

import android.os.Bundle;

import android.view.MotionEvent;

import android.widget.ImageView;

import android.widget.ImageView.ScaleType;

/**

* 多点触控来控制ImageView中图像的放大与缩小, 单点触控则用来拖动图片

*

* @author zeng

*

*/

public class MainActivity extends Activity

{

private MyImageView p_w_picpathView;

private Bitmap bitmap;

// 两点触屏后之间的长度

private float beforeLenght;

private float afterLenght;

// 单点移动的前后坐标值

private float afterX, afterY;

private float beforeX, beforeY;

/** Called when the activity is first created. */

@Override

public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

findView();

setContentView(p_w_picpathView);

config();

}

private void findView()

{

p_w_picpathView = new MyImageView(this);

// 获得图片

bitmap = ((BitmapDrawable) getResources().getDrawable(R.drawable.xing)).getBitmap();

}

private void config()

{

// 设置p_w_picpathView的显示图片

p_w_picpathView.setImageBitmap(bitmap);

// 设置图片填充ImageView

p_w_picpathView.setScaleType(ScaleType.FIT_XY);

}

// 创建一个自己的ImageView类

class MyImageView extends ImageView

{

private float scale = 0.1f;

public MyImageView(Context context)

{

super(context);

}

// 用来设置ImageView的位置

private void setLocation(int x, int y)

{

this.setFrame(this.getLeft() + x, this.getTop() + y, this.getRight() + x, this.getBottom() + y);

}

/**

* 用来放大缩小ImageView 因为图片是填充ImageView的，所以也就有放大缩小图片的效果 flag为0是放大图片，为1是缩小图片

*/

private void setScale(float temp, int flag)

{

if (flag == 0)

{

this.setFrame(this.getLeft() - (int) (temp * this.getWidth()), this.getTop() - (int) (temp * this.getHeight()), this.getRight()

+ (int) (temp * this.getWidth()), this.getBottom() + (int) (temp * this.getHeight()));

}

else

{

this.setFrame(this.getLeft() + (int) (temp * this.getWidth()), this.getTop() + (int) (temp * this.getHeight()), this.getRight()

- (int) (temp * this.getWidth()), this.getBottom() - (int) (temp * this.getHeight()));

}

}

// 绘制边框

@Override

protected void onDraw(Canvas canvas)

{

super.onDraw(canvas);

Rect rec = canvas.getClipBounds();

rec.bottom--;

rec.right--;

Paint paint = new Paint();

paint.setColor(Color.RED);

paint.setStyle(Paint.Style.STROKE);

canvas.drawRect(rec, paint);

}

/**

* 让图片跟随手指触屏的位置移动 beforeX、Y是用来保存前一位置的坐标 afterX、Y是用来保存当前位置的坐标

* 它们的差值就是ImageView各坐标的增加或减少值

*/

public void moveWithFinger(MotionEvent event)

{

switch (event.getAction())

{

case MotionEvent.ACTION_DOWN:

beforeX = event.getX();

beforeY = event.getY();

break;

case MotionEvent.ACTION_MOVE:

afterX = event.getX();

afterY = event.getY();

this.setLocation((int) (afterX - beforeX), (int) (afterY - beforeY));

beforeX = afterX;

beforeY = afterY;

break;

case MotionEvent.ACTION_UP:

break;

}

}

/**

* 通过多点触屏放大或缩小图像 beforeLenght用来保存前一时间两点之间的距离 afterLenght用来保存当前时间两点之间的距离

*/

public void scaleWithFinger(MotionEvent event)

{

float moveX = event.getX(1) - event.getX(0);

float moveY = event.getY(1) - event.getY(0);

switch (event.getAction())

{

case MotionEvent.ACTION_DOWN:

beforeLenght = (float) Math.sqrt((moveX * moveX) + (moveY * moveY));

break;

case MotionEvent.ACTION_MOVE:

// 得到两个点之间的长度

afterLenght = (float) Math.sqrt((moveX * moveX) + (moveY * moveY));

float gapLenght = afterLenght - beforeLenght;

if (gapLenght == 0)

{

break;

}

// 如果当前时间两点距离大于前一时间两点距离，则传0，否则传1

if (gapLenght > 0)

{

this.setScale(scale, 0);

}

else

{

this.setScale(scale, 1);

}

beforeLenght = afterLenght;

break;

}

}

}

// 这里来监听屏幕触控时间

@Override

public boolean onTouchEvent(MotionEvent event)

{

/**

* 判定用户是否触摸到了图片 如果是单点触摸则调用控制图片移动的方法 如果是2点触控则调用控制图片大小的方法

*/

if (event.getY() > p_w_picpathView.getTop() && event.getY()  p_w_picpathView.getLeft()

&& event.getX()

{

if (event.getPointerCount() == 2)

{

p_w_picpathView.scaleWithFinger(event);

}

else if (event.getPointerCount() == 1)

{

p_w_picpathView.moveWithFinger(event);

}

}

return true;

}

}

范例参考自：http://blog.csdn.net/ldj299/article/details/6422547

(二)实现多点消息拦截，用于多个物体拖动等效果package com.lonshine.d_touchdemo;

import java.util.ArrayList;

import java.util.List;

import android.content.Context;

import android.os.Handler;

import android.os.Message;

import android.view.MotionEvent;

import android.view.VelocityTracker;

import android.view.ViewConfiguration;

/**

* 实现多点消息拦截，用于多个物体拖动等效果

* @author zeng

*/

public class MultiTouchGestureDetector

{

@SuppressWarnings("unused")

private static final String MYTAG = "Alan";

public static final String CLASS_NAME = "MultiTouchGestureDetector";

/**

* 事件信息类

* 用来记录一个手势

*/

private class EventInfo

{

private MultiMotionEvent mCurrentDownEvent; // 当前的down事件

private MultiMotionEvent mPreviousUpEvent; // 上一次up事件

private boolean mStillDown; // 当前手指是否还在屏幕上

private boolean mInLongPress; // 当前事件是否属于长按手势

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

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

private boolean mIsDoubleTapping; // 当前手势，是否为双击手势

private float mLastMotionY; // 最后一次事件的X坐标

private float mLastMotionX; // 最后一次事件的Y坐标

private EventInfo(MotionEvent e)

{

this(new MultiMotionEvent(e));

}

private EventInfo(MultiMotionEvent me)

{

mCurrentDownEvent = me;

mStillDown = true;

mInLongPress = false;

mAlwaysInTapRegion = true;

mAlwaysInBiggerTapRegion = true;

mIsDoubleTapping = false;

}

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

public void recycle()

{

if (mCurrentDownEvent != null)

{

mCurrentDownEvent.recycle();

mCurrentDownEvent = null;

}

if (mPreviousUpEvent != null)

{

mPreviousUpEvent.recycle();

mPreviousUpEvent = null;

}

}

@Override

public void finalize()

{

this.recycle();

}

}

/**

* 多点事件类

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

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

*

* @author ray-ni

*/

public class MultiMotionEvent

{

private MotionEvent mEvent;

private int mIndex;

private MultiMotionEvent(MotionEvent e)

{

mEvent = e;

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

// mEvent.getActionIndex();

}

private MultiMotionEvent(MotionEvent e, int idx)

{

mEvent = e;

mIndex = idx;

}

// 行为

public int getAction()

{

int action = mEvent.getAction() & MotionEvent.ACTION_MASK; // 等效于

// mEvent.getActionMasked();

switch (action)

{

case MotionEvent.ACTION_POINTER_DOWN:

action = MotionEvent.ACTION_DOWN;

break;

case MotionEvent.ACTION_POINTER_UP:

action = MotionEvent.ACTION_UP;

break;

}

return action;

}

// 返回X的绝对坐标

public float getX()

{

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

}

// 返回Y的绝对坐标

public float getY()

{

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

}

// 事件发生的时间

public long getEventTime()

{

return mEvent.getEventTime();

}

// 事件序号

public int getIndex()

{

return mIndex;

}

// 事件ID

public int getId()

{

return mEvent.getPointerId(mIndex);

}

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

public void recycle()

{

if (mEvent != null)

{

mEvent.recycle();

mEvent = null;

}

}

}

// 多点手势监听器

public interface MultiTouchGestureListener

{

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

boolean onDown(MultiMotionEvent e);

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

void onShowPress(MultiMotionEvent e);

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

boolean onSingleTapUp(MultiMotionEvent e);

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

void onLongPress(MultiMotionEvent e);

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

boolean onScroll(MultiMotionEvent e1, MultiMotionEvent e2, float distanceX, float distanceY);

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

boolean onFling(MultiMotionEvent e1, MultiMotionEvent e2, float velocityX, float velocityY);

}

// 多点双击监听器

public interface MultiTouchDoubleTapListener

{

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

boolean onSingleTapConfirmed(MultiMotionEvent e);

// 双击事件，

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

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

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

boolean onDoubleTap(MultiMotionEvent e);

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

boolean onDoubleTapEvent(MultiMotionEvent e);

}

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

private static List sEventInfos = new ArrayList(10);

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

private static List sEventForDoubleTap = new ArrayList(5);

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

private int mBiggerTouchSlopSquare = 20 * 20;

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

private int mTouchSlopSquare;

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

private int mDoubleTapSlopSquare;

// 最小滑动速度

private int mMinimumFlingVelocity;

// 最大滑动速度

private int mMaximumFlingVelocity;

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

private static final int LONGPRESS_TIMEOUT = ViewConfiguration.getLongPressTimeout();

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

private static final int TAP_TIMEOUT = ViewConfiguration.getTapTimeout();

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

private static final int DOUBLE_TAP_TIMEOUT = ViewConfiguration.getDoubleTapTimeout();

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

private static final int DOUBLE_TAP_SLAP = 64;

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

// showPress手势

private static final int SHOW_PRESS = 1;

// 长按手势

private static final int LONG_PRESS = 2;

// SingleTapConfirmed手势

private static final int TAP_SINGLE = 3;

// 双击手势

private static final int TAP_DOUBLE = 4;

// 手势处理器

private final GestureHandler mHandler;

// 手势监听器

private final MultiTouchGestureListener mListener;

// 双击监听器

private MultiTouchDoubleTapListener mDoubleTapListener;

// 长按允许阀值

private boolean mIsLongpressEnabled;

// 速度追踪器

private VelocityTracker mVelocityTracker;

private class GestureHandler extends Handler

{

GestureHandler()

{

super();

}

GestureHandler(Handler handler)

{

super(handler.getLooper());

}

@Override

public void handleMessage(Message msg)

{

int idx = (Integer) msg.obj;

switch (msg.what)

{

case SHOW_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;

}

case LONG_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;

}

case TAP_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;

}

case TAP_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:

throw new RuntimeException("Unknown message " + msg); // never

}

}

}

/**

* 触发长按事件

*

* @param info

* @param idx

*/

private void dispatchLongPress(EventInfo info, int idx)

{

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

info.mInLongPress = true;

mListener.onLongPress(info.mCurrentDownEvent);

}

/**

* 构造器1

*

* @param context

* @param listener

*/

public MultiTouchGestureDetector(Context context, MultiTouchGestureListener listener)

{

this(context, listener, null);

}

/**

* 构造器2

*

* @param context

* @param listener

* @param handler

*/

public MultiTouchGestureDetector(Context context, MultiTouchGestureListener listener, Handler handler)

{

if (handler != null)

{

mHandler = new GestureHandler(handler);

}

else

{

mHandler = new GestureHandler();

}

mListener = listener;

if (listener instanceof MultiTouchDoubleTapListener)

{

setOnDoubleTapListener((MultiTouchDoubleTapListener) listener);

}

init(context);

}

/**

* 初始化识别器

*

* @param context

*/

private void init(Context context)

{

if (mListener == null)

{

throw new NullPointerException("OnGestureListener must not be null");

}

mIsLongpressEnabled = true;

int touchSlop, doubleTapSlop;

if (context == null)

{

touchSlop = ViewConfiguration.getTouchSlop();

doubleTapSlop = DOUBLE_TAP_SLAP;

mMinimumFlingVelocity = ViewConfiguration.getMinimumFlingVelocity();

mMaximumFlingVelocity = ViewConfiguration.getMaximumFlingVelocity();

}

else

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

final ViewConfiguration 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

*/

public void setOnDoubleTapListener(MultiTouchDoubleTapListener onDoubleTapListener)

{

mDoubleTapListener = onDoubleTapListener;

}

/**

* 设置是否允许长按

*

* @param isLongpressEnabled

*/

public void setIsLongpressEnabled(boolean isLongpressEnabled)

{

mIsLongpressEnabled = isLongpressEnabled;

}

/**

* 判断是否允许长按

*

* @return

*/

public boolean isLongpressEnabled()

{

return mIsLongpressEnabled;

}

/**

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

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

*

* @param e

* @return

*/

private EventInfo checkForDoubleTap(MultiMotionEvent e)

{

if (sEventForDoubleTap.isEmpty())

{

// Log.e(MYTAG, CLASS_NAME +

// ":checkForDoubleTap(), sEventForDoubleTap is empty !");

return null;

}

for (int i = 0; i

{

EventInfo info = sEventForDoubleTap.get(i);

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

{

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

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

return info;

}

}

return null;

}

/**

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

*

* @param info

* @param secondDown

* @return

*/

private boolean isConsideredDoubleTap(EventInfo info, MultiMotionEvent secondDown)

{

if (!info.mAlwaysInBiggerTapRegion)

{ // 如多第一次单击事件有过较大距离的移动，则无法构成双击事件

return false;

}

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

{

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

return false;

}

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

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

return (deltaX * deltaX + deltaY * deltaY

}

/**

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

*

* @param info

* @return

*/

private int addIntoTheMinIndex(EventInfo info)

{

for (int i = 0; i

{

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

{

sEventForDoubleTap.set(i, info);

return i;

}

}

sEventForDoubleTap.add(info);

return sEventForDoubleTap.size() - 1;

}

/**

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

*

* @param idx

*/

private void removeEventFromList(int id)

{

if (id > sEventInfos.size() || id

{

// Log.e(MYTAG, CLASS_NAME + ".removeEventFromList(), id=" + id +

// ", while sEventInfos.size() =" +

// sEventInfos.size());

return;

}

sEventInfos.set(id, null);

}

/**

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

*

* @param e

*/

private void addEventIntoList(EventInfo info)

{

int id = info.mCurrentDownEvent.getId();

if (id

{

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

// Log.e(MYTAG, CLASS_NAME + ".addEventIntoList, info(" + id +

// ") has not set to null !");

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

}

else if (id == sEventInfos.size())

{

sEventInfos.add(info);

}

else

{

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

}

}

public boolean onTouchEvent(MotionEvent ev)

{

if (mVelocityTracker == null)

{

mVelocityTracker = VelocityTracker.obtain();

}

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

boolean handled = false;

final int action = ev.getAction(); // 获取Action

// int idx = (action & MotionEvent.ACTION_POINTER_INDEX_MASK) >>

// MotionEvent.ACTION_POINTER_INDEX_SHIFT;//获取触摸事件的序号

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

switch (action & MotionEvent.ACTION_MASK)

{

case MotionEvent.ACTION_DOWN:

case MotionEvent.ACTION_POINTER_DOWN:

{

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

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

if (mDoubleTapListener != null)

{// 如果双击监听器不为null

if (mHandler.hasMessages(TAP_DOUBLE))

{

MultiMotionEvent e = new MultiMotionEvent(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;

}

case MotionEvent.ACTION_UP:

case MotionEvent.ACTION_POINTER_UP:

{

MultiMotionEvent currentUpEvent = new MultiMotionEvent(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);

}

else if (info.mInLongPress)

{// 处于长按状态

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

info.mInLongPress = false;

}

else if (info.mAlwaysInTapRegion)

{// 尚未移动过

if (mHandler.hasMessages(TAP_SINGLE, idx))

{// 还在双击的时间阀值内，所以要为双击判断做额外处理

mHandler.removeMessages(TAP_SINGLE, idx);

info.mPreviousUpEvent = new MultiMotionEvent(MotionEvent.obtain(ev));

int index = 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

final VelocityTracker velocityTracker = mVelocityTracker;

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

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

final float velocityX = velocityTracker.getXVelocity(idx);

final float velocityY = 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;

}

case MotionEvent.ACTION_MOVE:

for (int rIdx = 0; rIdx

{// 因为无法确定当前发生移动的是哪个手指，所以遍历处理所有手指

MultiMotionEvent e = new MultiMotionEvent(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;

}

// 当前坐标

float x = e.getX();

float y = e.getY();

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

final float scrollX = x - info.mLastMotionX;

final float scrollY = y - info.mLastMotionY;

if (info.mIsDoubleTapping)

{// 双击事件

handled |= mDoubleTapListener.onDoubleTapEvent(e);

}

else if (info.mAlwaysInTapRegion)

{// 该手势尚未移动过(移动的距离小于mTouchSlopSquare,视为未移动过)

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

final int deltaX = (int) (x - info.mCurrentDownEvent.getX());

final int deltaY = (int) (y - info.mCurrentDownEvent.getY());

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

// +

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

int distance = (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三种消息

int id = e.getId();

mHandler.removeMessages(TAP_SINGLE, id);

mHandler.removeMessages(SHOW_PRESS, id);

mHandler.removeMessages(LONG_PRESS, id);

}

if (distance > mBiggerTouchSlopSquare)

{// 移动距离大于mBiggerTouchSlopSquare，则无法构成双击事件

info.mAlwaysInBiggerTapRegion = false;

}

}

else if ((Math.abs(scrollX) >= 1) || (Math.abs(scrollY) >= 1))

{// 之前已经移动过了

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

info.mLastMotionX = x;

info.mLastMotionY = y;

}

}

break;

case MotionEvent.ACTION_CANCEL:

cancel();// 清理

}

return handled;

}

// 清理所有队列

private void cancel()

{

mHandler.removeMessages(SHOW_PRESS);

mHandler.removeMessages(LONG_PRESS);

mHandler.removeMessages(TAP_SINGLE);

mVelocityTracker.recycle();

mVelocityTracker = null;

sEventInfos.clear();

sEventForDoubleTap.clear();

}

}

参考资料：http://xiaxingwork.iteye.com/blog/1771714