Android笔记:触摸事件的分析与总结----多点触控

   其他相关博文：

   Android笔记:触摸事件的分析与总结----MotionEvent对象

   Android笔记:触摸事件的分析与总结----TouchEvent处理机制

    Android笔记:触摸事件的分析与总结----多点触控

一、多点触控

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

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

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

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

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

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

简单测试范例

布局xml代码如下:

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 < count)
        {
            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.getBottom() && event.getX() > p_w_picpathView.getLeft()
                && event.getX() < p_w_picpathView.getRight())
        {
            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 < 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内的为处理消息
                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 < mDoubleTapSlopSquare);// 最后判断两次单击事件的距离
    }
    
    /**
     * 将事件信息放入双击判断队列，并返回序号
     * 
     * @param info
     * @return
     */
    private int addIntoTheMinIndex(EventInfo info)
    {
        for (int i = 0; i < sEventForDoubleTap.size(); 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 < 0)
        {
            // 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 < 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);
        }
        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 < ev.getPointerCount(); 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