多点手势识别的实现

  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平台上手势识别的兼容。
  开始贴代码:
[java]   view plain copy print ?
  1. package com.finger.utils;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5.   
  6. import android.content.Context;  
  7. import android.os.Handler;  
  8. import android.os.Message;  
  9. import android.view.MotionEvent;  
  10. import android.view.VelocityTracker;  
  11. import android.view.ViewConfiguration;  
  12.   
  13. public class MultiTouchGestureDetector {  
  14.   
  15.     @SuppressWarnings("unused")  
  16.     private static final String MYTAG = "Ray";  
  17.     public static final String CLASS_NAME = "MultiTouchGestureDetector";  
  18.   
  19.     /** 
  20.      * 事件信息类 <br/> 
  21.      * 用来记录一个手势 
  22.      */  
  23.     private class EventInfo {  
  24.         private MultiMotionEvent mCurrentDownEvent;    //当前的down事件  
  25.         private MultiMotionEvent mPreviousUpEvent;    //上一次up事件  
  26.         private boolean mStillDown;                    //当前手指是否还在屏幕上  
  27.         private boolean mInLongPress;                //当前事件是否属于长按手势  
  28.         private boolean mAlwaysInTapRegion;            //是否当前手指仅在小范围内移动,当手指仅在小范围内移动时,视为手指未曾移动过,不会触发onScroll手势  
  29.         private boolean mAlwaysInBiggerTapRegion;    //是否当前手指在较大范围内移动,仅当此值为true时,双击手势才能成立  
  30.         private boolean mIsDoubleTapping;            //当前手势,是否为双击手势  
  31.         private float mLastMotionY;                    //最后一次事件的X坐标  
  32.         private float mLastMotionX;                    //最后一次事件的Y坐标  
  33.   
  34.         private EventInfo(MotionEvent e) {  
  35.             this(new MultiMotionEvent(e));  
  36.         }  
  37.   
  38.         private EventInfo(MultiMotionEvent me) {  
  39.             mCurrentDownEvent = me;  
  40.             mStillDown = true;  
  41.             mInLongPress = false;  
  42.             mAlwaysInTapRegion = true;  
  43.             mAlwaysInBiggerTapRegion = true;  
  44.             mIsDoubleTapping = false;  
  45.         }  
  46.   
  47.         //释放MotionEven对象,使系统能够继续使用它们  
  48.         public void recycle() {  
  49.             if (mCurrentDownEvent != null) {  
  50.                 mCurrentDownEvent.recycle();  
  51.                 mCurrentDownEvent = null;  
  52.             }  
  53.   
  54.             if (mPreviousUpEvent != null) {  
  55.                 mPreviousUpEvent.recycle();  
  56.                 mPreviousUpEvent = null;  
  57.             }  
  58.         }  
  59.   
  60.         @Override  
  61.         public void finalize() {  
  62.             this.recycle();  
  63.         }  
  64.     }  
  65.   
  66.     /** 
  67.      * 多点事件类 <br/> 
  68.      * 将一个多点事件拆分为多个单点事件,并方便获得事件的绝对坐标 
  69.      * <br/> 绝对坐标用以在界面中找到触点所在的控件 
  70.      * @author ray-ni 
  71.      */  
  72.     public class MultiMotionEvent {  
  73.         private MotionEvent mEvent;  
  74.         private int mIndex;  
  75.   
  76.         private MultiMotionEvent(MotionEvent e) {  
  77.             mEvent = e;  
  78.             mIndex = (e.getAction() & MotionEvent.ACTION_POINTER_ID_MASK) >> MotionEvent.ACTION_POINTER_ID_SHIFT;  //等效于 mEvent.getActionIndex();  
  79.         }  
  80.   
  81.         private MultiMotionEvent(MotionEvent e, int idx) {  
  82.             mEvent = e;  
  83.             mIndex = idx;  
  84.         }  
  85.   
  86.         // 行为  
  87.         public int getAction() {  
  88.             int action = mEvent.getAction() & MotionEvent.ACTION_MASK;    //等效于 mEvent.getActionMasked();  
  89.             switch (action) {  
  90.             case MotionEvent.ACTION_POINTER_DOWN:  
  91.                 action = MotionEvent.ACTION_DOWN;  
  92.                 break;  
  93.             case MotionEvent.ACTION_POINTER_UP:  
  94.                 action = MotionEvent.ACTION_UP;  
  95.                 break;  
  96.             }  
  97.             return action;  
  98.         }  
  99.           
  100.         // 返回X的绝对坐标  
  101.         public float getX() {  
  102.             return mEvent.getX(mIndex) + mEvent.getRawX() - mEvent.getX();  
  103.         }  
  104.   
  105.         // 返回Y的绝对坐标  
  106.         public float getY() {  
  107.             return mEvent.getY(mIndex) + mEvent.getRawY() - mEvent.getY();  
  108.         }  
  109.   
  110.         // 事件发生的时间  
  111.         public long getEventTime() {  
  112.             return mEvent.getEventTime();  
  113.         }  
  114.           
  115.         // 事件序号  
  116.         public int getIndex() {  
  117.             return mIndex;  
  118.         }  
  119.           
  120.         // 事件ID  
  121.         public int getId() {  
  122.             return mEvent.getPointerId(mIndex);  
  123.         }  
  124.           
  125.         // 释放事件对象,使系统能够继续使用  
  126.         public void recycle() {  
  127.             if (mEvent != null) {  
  128.                 mEvent.recycle();  
  129.                 mEvent = null;  
  130.             }  
  131.         }  
  132.     }  
  133.   
  134.     // 多点手势监听器  
  135.     public interface MultiTouchGestureListener {  
  136.         // 手指触碰到屏幕,由一个 ACTION_DOWN触发  
  137.         boolean onDown(MultiMotionEvent e);  
  138.         // 确定一个press事件,强调手指按下的一段时间(TAP_TIMEOUT)内,手指未曾移动或抬起  
  139.         void onShowPress(MultiMotionEvent e);  
  140.         // 手指点击屏幕后离开,由 ACTION_UP引发,可以简单的理解为单击事件,即手指点击时间不长(未构成长按事件),也不曾移动过  
  141.         boolean onSingleTapUp(MultiMotionEvent e);  
  142.         // 长按,手指点下后一段时间(DOUBLE_TAP_TIMEOUT)内,不曾抬起或移动  
  143.         void onLongPress(MultiMotionEvent e);  
  144.         // 拖动,由ACTION_MOVE触发,手指地按下后,在屏幕上移动  
  145.         boolean onScroll(MultiMotionEvent e1, MultiMotionEvent e2, float distanceX, float distanceY);  
  146.         // 滑动,由ACTION_UP触发,手指按下并移动一段距离后,抬起时触发  
  147.         boolean onFling(MultiMotionEvent e1, MultiMotionEvent e2, float velocityX, float velocityY);  
  148.     }  
  149.     // 多点双击监听器  
  150.     public interface MultiTouchDoubleTapListener {  
  151.         // 单击事件确认,强调第一个单击事件发生后,一段时间内,未发生第二次单击事件,即确定不会触发双击事件  
  152.         boolean onSingleTapConfirmed(MultiMotionEvent e);  
  153.         // 双击事件, 由ACTION_DOWN触发,从第一次单击事件的DOWN事件开始的一段时间(DOUBLE_TAP_TIMEOUT)内结束(即手指),  
  154.         // 并且在第一次单击事件的UP时间开始后的一段时间内(DOUBLE_TAP_TIMEOUT)发生第二次单击事件,  
  155.         // 除此之外两者坐标间距小于定值(DOUBLE_TAP_SLAP)时,则触发双击事件  
  156.         boolean onDoubleTap(MultiMotionEvent e);  
  157.         // 双击事件,与onDoubleTap事件不同之处在于,构成双击的第二次点击的ACTION_DOWN,ACTION_MOVE和ACTION_UP都会触发该事件  
  158.         boolean onDoubleTapEvent(MultiMotionEvent e);  
  159.     }  
  160.   
  161.     // 事件信息队列,队列的下标与MotionEvent的pointId对应  
  162.     private static List<EventInfo> sEventInfos = new ArrayList<EventInfo>(10);  
  163.     // 双击判断队列,这个队列中的元素等待双击超时的判断结果  
  164.     private static List<EventInfo> sEventForDoubleTap = new ArrayList<EventInfo>(5);  
  165.     // 指定大点击区域的大小(这个比较拗口),这个值主要用于帮助判断双击是否成立  
  166.     private int mBiggerTouchSlopSquare = 20 * 20;  
  167.     // 判断是否构成onScroll手势,当手指在这个范围内移动时,不触发onScroll手势  
  168.     private int mTouchSlopSquare;  
  169.     // 判断是否构成双击,只有两次点击的距离小于该值,才能构成双击手势  
  170.     private int mDoubleTapSlopSquare;  
  171.     // 最小滑动速度  
  172.     private int mMinimumFlingVelocity;  
  173.     // 最大滑动速度  
  174.     private int mMaximumFlingVelocity;  
  175.   
  176.     // 长按阀值,当手指按下后,在该阀值的时间内,未移动超过mTouchSlopSquare的距离并未抬起,则长按手势触发  
  177.     private static final int LONGPRESS_TIMEOUT = ViewConfiguration.getLongPressTimeout();  
  178.     // showPress手势的触发阀值,当手指按下后,在该阀值的时间内,未移动超过mTouchSlopSquare的距离并未抬起,则showPress手势触发  
  179.     private static final int TAP_TIMEOUT = ViewConfiguration.getTapTimeout();  
  180.     // 双击超时阀值,仅在两次双击事件的间隔(第一次单击的UP事件和第二次单击的DOWN事件)小于此阀值,双击事件才能成立  
  181.     private static final int DOUBLE_TAP_TIMEOUT = ViewConfiguration.getDoubleTapTimeout();  
  182.     // 双击区域阀值,仅在两次双击事件的距离小于此阀值,双击事件才能成立  
  183.     private static final int DOUBLE_TAP_SLAP = 64;  
  184.   
  185.     // GestureHandler所处理的Message的what属性可能为以下 常量:  
  186.     // showPress手势  
  187.     private static final int SHOW_PRESS = 1;  
  188.     // 长按手势  
  189.     private static final int LONG_PRESS = 2;  
  190.     // SingleTapConfirmed手势  
  191.     private static final int TAP_SINGLE = 3;  
  192.     // 双击手势  
  193.     private static final int TAP_DOUBLE = 4;  
  194.       
  195.     // 手势处理器  
  196.     private final GestureHandler mHandler;  
  197.     // 手势监听器  
  198.     private final MultiTouchGestureListener mListener;  
  199.     // 双击监听器  
  200.     private MultiTouchDoubleTapListener mDoubleTapListener;  
  201.       
  202.     // 长按允许阀值  
  203.     private boolean mIsLongpressEnabled;  
  204.     // 速度追踪器  
  205.     private VelocityTracker mVelocityTracker;  
  206.   
  207.     private class GestureHandler extends Handler {  
  208.         GestureHandler() {  
  209.             super();  
  210.         }  
  211.   
  212.         GestureHandler(Handler handler) {  
  213.             super(handler.getLooper());  
  214.         }  
  215.   
  216.         @Override  
  217.         public void handleMessage(Message msg) {  
  218.             int idx = (Integer) msg.obj;  
  219.             switch (msg.what) {  
  220.             case SHOW_PRESS: {  
  221.                 if (idx >= sEventInfos.size()) {  
  222. //                    Log.w(MYTAG, CLASS_NAME + ":handleMessage, msg.what = SHOW_PRESS, idx=" + idx + ", while sEventInfos.size()="  
  223. //                            + sEventInfos.size());  
  224.                     break;  
  225.                 }  
  226.                 EventInfo info = sEventInfos.get(idx);  
  227.                 if (info == null) {  
  228. //                    Log.e(MYTAG, CLASS_NAME + ":handleMessage, msg.what = SHOW_PRESS, idx=" + idx + ", Info = null");  
  229.                     break;  
  230.                 }  
  231.                 // 触发手势监听器的onShowPress事件  
  232.                 mListener.onShowPress(info.mCurrentDownEvent);  
  233.                 break;  
  234.             }  
  235.             case LONG_PRESS: {  
  236.                 // Log.d(MYTAG, CLASS_NAME + ":trigger LONG_PRESS");  
  237.   
  238.                 if (idx >= sEventInfos.size()) {  
  239. //                    Log.w(MYTAG, CLASS_NAME + ":handleMessage, msg.what = LONG_PRESS, idx=" + idx + ", while sEventInfos.size()="  
  240. //                            + sEventInfos.size());  
  241.                     break;  
  242.                 }  
  243.                 EventInfo info = sEventInfos.get(idx);  
  244.                 if (info == null) {  
  245. //                    Log.e(MYTAG, CLASS_NAME + ":handleMessage, msg.what = LONG_PRESS, idx=" + idx + ", Info = null");  
  246.                     break;  
  247.                 }  
  248.                 dispatchLongPress(info, idx);  
  249.                 break;  
  250.             }  
  251.             case TAP_SINGLE: {  
  252.   
  253.                 // Log.d(MYTAG, CLASS_NAME + ":trriger TAP_SINGLE");  
  254.                 // If the user's finger is still down, do not count it as a tap  
  255.                 if (idx >= sEventInfos.size()) {  
  256. //                    Log.e(MYTAG, CLASS_NAME + ":handleMessage, msg.what = TAP_SINGLE, idx=" + idx + ", while sEventInfos.size()="  
  257. //                            + sEventInfos.size());  
  258.                     break;  
  259.                 }  
  260.                 EventInfo info = sEventInfos.get(idx);  
  261.                 if (info == null) {  
  262. //                    Log.e(MYTAG, CLASS_NAME + ":handleMessage, msg.what = TAP_SINGLE, idx=" + idx + ", Info = null");  
  263.                     break;  
  264.                 }  
  265.   
  266.                 if (mDoubleTapListener != null && !info.mStillDown) { //手指在双击超时的阀值内未离开屏幕进行第二次单击事件,则确定单击事件成立(不再触发双击事件)  
  267.                     mDoubleTapListener.onSingleTapConfirmed(info.mCurrentDownEvent);  
  268.                 }  
  269.                 break;  
  270.             }  
  271.             case TAP_DOUBLE: {  
  272.                 if (idx >= sEventForDoubleTap.size()) {  
  273. //                    Log.w(MYTAG, CLASS_NAME + ":handleMessage, msg.what = TAP_DOUBLE, idx=" + idx + ", while sEventForDoubleTap.size()="  
  274. //                            + sEventForDoubleTap.size());  
  275.                     break;  
  276.                 }  
  277.                 EventInfo info = sEventForDoubleTap.get(idx);  
  278.                 if (info == null) {  
  279. //                    Log.w(MYTAG, CLASS_NAME + ":handleMessage, msg.what = TAP_DOUBLE, idx=" + idx + ", Info = null");  
  280.                     break;  
  281.                 }  
  282.                 sEventForDoubleTap.set(idx, null);// 这个没什么好做的,就是把队列中对应的元素清除而已  
  283.                 break;  
  284.             }  
  285.             default:  
  286.                 throw new RuntimeException("Unknown message " + msg); // never  
  287.             }  
  288.         }  
  289.     }  
  290.   
  291.     /** 
  292.      * 触发长按事件 
  293.      * @param info 
  294.      * @param idx 
  295.      */  
  296.     private void dispatchLongPress(EventInfo info, int idx) {  
  297.         mHandler.removeMessages(TAP_SINGLE, idx);//移除单击事件确认  
  298.         info.mInLongPress = true;  
  299.         mListener.onLongPress(info.mCurrentDownEvent);  
  300.     }  

你可能感兴趣的:(android,null,Integer,Class,UP,action)