zoukankan      html  css  js  c++  java

  • 用户手势检测-GestureDetector使用详解

    一、概述

    当用户触摸屏幕的时候，会产生许多手势，例如down，up，scroll，filing等等。
    一 般情况下，我们知道View类有个View.OnTouchListener内部接口，通过重写他的onTouch(View v, MotionEvent event)方法，我们可以处理一些touch事件，但是这个方法太过简单，如果需要处理一些复杂的手势，用这个接口就会很麻烦（因为我们要自己根据用户 触摸的轨迹去判断是什么手势）。
    Android sdk给我们提供了GestureDetector（Gesture：手势Detector：识别）类，通过这个类我们可以识别很多的手势，主要是通过他 的onTouchEvent(event)方法完成了不同手势的识别。虽然他能识别手势，但是不同的手势要怎么处理，应该是提供给程序员实现的。

    GestureDetector这个类对外提供了两个接口和一个外部类
    接口：OnGestureListener，OnDoubleTapListener
    内部类:SimpleOnGestureListener

    这个外部类，其实是两个接口中所有函数的集成，它包含了这两个接口里所有必须要实现的函数而且都已经重写，但所有方法体都是空的；不同点在于：该类是static class，程序员可以在外部继承这个类，重写里面的手势处理方法。

    下面我们先看OnGestureListener接口；

    二、GestureDetector.OnGestureListener---接口

    1、基本讲解

    如果我们写一个类并implements OnGestureListener，会提示有几个必须重写的函数，加上之后是这个样子的：

    [java] view plain copy 在CODE上查看代码片派生到我的代码片
    1. private class gesturelistener implements GestureDetector.OnGestureListener{  
    2.   
    3.     public boolean onDown(MotionEvent e) {  
    4.         // TODO Auto-generated method stub  
    5.         return false;  
    6.     }  
    7.   
    8.     public void onShowPress(MotionEvent e) {  
    9.         // TODO Auto-generated method stub  
    10.           
    11.     }  
    12.   
    13.     public boolean onSingleTapUp(MotionEvent e) {  
    14.         // TODO Auto-generated method stub  
    15.         return false;  
    16.     }  
    17.   
    18.     public boolean onScroll(MotionEvent e1, MotionEvent e2,  
    19.             float distanceX, float distanceY) {  
    20.         // TODO Auto-generated method stub  
    21.         return false;  
    22.     }  
    23.   
    24.     public void onLongPress(MotionEvent e) {  
    25.         // TODO Auto-generated method stub  
    26.           
    27.     }  
    28.   
    29.     public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,  
    30.             float velocityY) {  
    31.         // TODO Auto-generated method stub  
    32.         return false;  
    33.     }  
    34.       
    35. }  

    可见，这里总共重写了六个函数，这些函数都在什么情况下才会触发呢，下面讲一下：

    OnDown(MotionEvent e)：用户按下屏幕就会触发；
    onShowPress(MotionEvent e)：如果是按下的时间超过瞬间，而且在按下的时候没有松开或者是拖动的，那么onShowPress就会执行，具体这个瞬间是多久，我也不清楚呃……
    onLongPress(MotionEvent e)：长按触摸屏，超过一定时长，就会触发这个事件
        触发顺序：
        onDown->onShowPress->onLongPress
    onSingleTapUp(MotionEvent e)：从名子也可以看出,一次单独的轻击抬起操作,也就是轻击一下屏幕，立刻抬起来，才会有这个触发，当然,如果除了Down以外还有其它操作,那就不再算是Single操作了,所以也就不会触发这个事件
        触发顺序：
        点击一下非常快的（不滑动）Touchup：
        onDown->onSingleTapUp->onSingleTapConfirmed 
        点击一下稍微慢点的（不滑动）Touchup：
        onDown->onShowPress->onSingleTapUp->onSingleTapConfirmed
    onFling(MotionEvent e1, MotionEvent e2, float velocityX,float velocityY) ：滑屏，用户按下触摸屏、快速移动后松开，由1个MotionEvent ACTION_DOWN, 多个ACTION_MOVE, 1个ACTION_UP触发   
         参数解释：
        e1：第1个ACTION_DOWN MotionEvent
        e2：最后一个ACTION_MOVE MotionEvent
        velocityX：X轴上的移动速度，像素/秒
        velocityY：Y轴上的移动速度，像素/秒   
    onScroll(MotionEvent e1, MotionEvent e2,float distanceX, float distanceY)：在屏幕上拖动事件。无论是用手拖动view，或者是以抛的动作滚动，都会多次触发,这个方法       在ACTION_MOVE动作发生时就会触发
        滑屏：手指触动屏幕后，稍微滑动后立即松开
        onDown-----》onScroll----》onScroll----》onScroll----》………----->onFling
        拖动
        onDown------》onScroll----》onScroll------》onFiling

        可见，无论是滑屏，还是拖动，影响的只是中间OnScroll触发的数量多少而已，最终都会触发onFling事件！

    2、实例

    要使用GestureDetector，有三步要走：

    1、创建OnGestureListener监听函数：
    可以使用构造实例：

    [java] view plain copy 在CODE上查看代码片派生到我的代码片
    1. GestureDetector.OnGestureListener listener = new GestureDetector.OnGestureListener(){  
    2.           
    3.     };  

    也可以构造类：

    [java] view plain copy 在CODE上查看代码片派生到我的代码片
    1. private class gestureListener implements GestureDetector.OnGestureListener{  
    2.   
    3. }  

    2、创建GestureDetector实例mGestureDetector：

    构造函数有下面三个，根据需要选择：

    [java] view plain copy 在CODE上查看代码片派生到我的代码片
    1. GestureDetector gestureDetector=new GestureDetector(GestureDetector.OnGestureListener listener);  
    2. GestureDetector gestureDetector=new GestureDetector(Context context,GestureDetector.OnGestureListener listener);  
    3. GestureDetector gestureDetector=new GestureDetector(Context context,GestureDetector.SimpleOnGestureListener listener);  

    3、onTouch(View v, MotionEvent event)中拦截：

    [java] view plain copy 在CODE上查看代码片派生到我的代码片
    1. public boolean onTouch(View v, MotionEvent event) {  
    2.     return mGestureDetector.onTouchEvent(event);     
    3. }  

    4、控件绑定

    [java] view plain copy 在CODE上查看代码片派生到我的代码片
    1. TextView tv = (TextView)findViewById(R.id.tv);  
    2. tv.setOnTouchListener(this);  

    现在进入实例阶段：

    首先，在主布局页面添加一个textView，并将其放大到整屏，方便在其上的手势识别，代码为：

    [java] view plain copy 在CODE上查看代码片派生到我的代码片
    1. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    2.     xmlns:tools="http://schemas.android.com/tools"  
    3.     android:layout_width="match_parent"  
    4.     android:layout_height="match_parent"  
    5.     tools:context="com.example.gesturedetectorinterface.MainActivity" >  
    6.   
    7.     <TextView  
    8.         android:id="@+id/tv"  
    9.         android:layout_width="fill_parent"  
    10.         android:layout_height="fill_parent"  
    11.         android:layout_margin="50dip"  
    12.         android:background="#ff00ff"  
    13.         android:text="@string/hello_world" />  
    14.   
    15. </RelativeLayout>  

    然后在JAVA代码中，依据上面的三步走原则，写出代码，并在所有的手势下添加上Toast提示并写上Log

    [java] view plain copy 在CODE上查看代码片派生到我的代码片
    1. public class MainActivity extends Activity implements OnTouchListener{  
    2.   
    3.     private GestureDetector mGestureDetector;     
    4.       
    5.   
    6.     @Override  
    7.     protected void onCreate(Bundle savedInstanceState) {  
    8.         super.onCreate(savedInstanceState);  
    9.         setContentView(R.layout.activity_main);  
    10.           
    11.       mGestureDetector = new GestureDetector(new gestureListener()); //使用派生自OnGestureListener  
    12.           
    13.       TextView tv = (TextView)findViewById(R.id.tv);  
    14.       tv.setOnTouchListener(this);  
    15.       tv.setFocusable(true);     
    16.       tv.setClickable(true);     
    17.       tv.setLongClickable(true);   
    18.     }  
    19.       
    20.       
    21.     /*  
    22.      * 在onTouch()方法中，我们调用GestureDetector的onTouchEvent()方法，将捕捉到的MotionEvent交给GestureDetector  
    23.      * 来分析是否有合适的callback函数来处理用户的手势  
    24.      */    
    25.     public boolean onTouch(View v, MotionEvent event) {  
    26.         return mGestureDetector.onTouchEvent(event);     
    27.     }  
    28.       
    29.     private class gestureListener implements GestureDetector.OnGestureListener{  
    30.   
    31.         // 用户轻触触摸屏，由1个MotionEvent ACTION_DOWN触发     
    32.         public boolean onDown(MotionEvent e) {  
    33.             Log.i("MyGesture", "onDown");     
    34.             Toast.makeText(MainActivity.this, "onDown", Toast.LENGTH_SHORT).show();     
    35.             return false;  
    36.         }  
    37.   
    38.         /*   
    39.          * 用户轻触触摸屏，尚未松开或拖动，由一个1个MotionEvent ACTION_DOWN触发   
    40.          * 注意和onDown()的区别，强调的是没有松开或者拖动的状态   
    41.          *  
    42.          * 而onDown也是由一个MotionEventACTION_DOWN触发的，但是他没有任何限制， 
    43.          * 也就是说当用户点击的时候，首先MotionEventACTION_DOWN，onDown就会执行， 
    44.          * 如果在按下的瞬间没有松开或者是拖动的时候onShowPress就会执行，如果是按下的时间超过瞬间 
    45.          * （这块我也不太清楚瞬间的时间差是多少，一般情况下都会执行onShowPress），拖动了，就不执行onShowPress。 
    46.          */  
    47.         public void onShowPress(MotionEvent e) {  
    48.             Log.i("MyGesture", "onShowPress");     
    49.             Toast.makeText(MainActivity.this, "onShowPress", Toast.LENGTH_SHORT).show();     
    50.         }  
    51.   
    52.         // 用户（轻触触摸屏后）松开，由一个1个MotionEvent ACTION_UP触发     
    53.         ///轻击一下屏幕，立刻抬起来，才会有这个触发  
    54.         //从名子也可以看出,一次单独的轻击抬起操作,当然,如果除了Down以外还有其它操作,那就不再算是Single操作了,所以这个事件 就不再响应  
    55.         public boolean onSingleTapUp(MotionEvent e) {  
    56.             Log.i("MyGesture", "onSingleTapUp");     
    57.             Toast.makeText(MainActivity.this, "onSingleTapUp", Toast.LENGTH_SHORT).show();     
    58.             return true;     
    59.         }  
    60.   
    61.         // 用户按下触摸屏，并拖动，由1个MotionEvent ACTION_DOWN, 多个ACTION_MOVE触发     
    62.         public boolean onScroll(MotionEvent e1, MotionEvent e2,  
    63.                 float distanceX, float distanceY) {  
    64.             Log.i("MyGesture22", "onScroll:"+(e2.getX()-e1.getX()) +"   "+distanceX);     
    65.             Toast.makeText(MainActivity.this, "onScroll", Toast.LENGTH_LONG).show();     
    66.               
    67.             return true;     
    68.         }  
    69.   
    70.         // 用户长按触摸屏，由多个MotionEvent ACTION_DOWN触发     
    71.         public void onLongPress(MotionEvent e) {  
    72.              Log.i("MyGesture", "onLongPress");     
    73.              Toast.makeText(MainActivity.this, "onLongPress", Toast.LENGTH_LONG).show();     
    74.         }  
    75.   
    76.         // 用户按下触摸屏、快速移动后松开，由1个MotionEvent ACTION_DOWN, 多个ACTION_MOVE, 1个ACTION_UP触发     
    77.         public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,  
    78.                 float velocityY) {  
    79.             Log.i("MyGesture", "onFling");     
    80.             Toast.makeText(MainActivity.this, "onFling", Toast.LENGTH_LONG).show();     
    81.             return true;  
    82.         }  
    83.     };  
    84.       
    85.   
    86. }  

    源码在博客底部给出。

    三、GestureDetector.OnDoubleTapListener---接口

    1、构建

    有两种方式设置双击监听：

    方法一：新建一个类同时派生自OnGestureListener和OnDoubleTapListener：

    [java] view plain copy 在CODE上查看代码片派生到我的代码片
    1. private class gestureListener implements GestureDetector.OnGestureListener,GestureDetector.OnDoubleTapListener{  
    2.     }  

    方法二：使用GestureDetector::setOnDoubleTapListener();函数设置监听：

    [java] view plain copy 在CODE上查看代码片派生到我的代码片
    1. //构建GestureDetector实例     
    2. mGestureDetector = new GestureDetector(new gestureListener()); //使用派生自OnGestureListener  
    3. private class gestureListener implements GestureDetector.OnGestureListener{  
    4.       
    5. }  
    6.   
    7. //设置双击监听器  
    8. mGestureDetector.setOnDoubleTapListener(new doubleTapListener());  
    9. private class doubleTapListener implements GestureDetector.OnDoubleTapListener{  
    10.       
    11. }  

    注意：大家可以看到无论在方法一还是在方法二中，都需要派生自GestureDetector.OnGestureListener，前面我们说过GestureDetector 的构造函数，如下：

    [java] view plain copy 在CODE上查看代码片派生到我的代码片
    1. GestureDetector gestureDetector=new GestureDetector(GestureDetector.OnGestureListener listener);  
    2. GestureDetector gestureDetector=new GestureDetector(Context context,GestureDetector.OnGestureListener listener);  
    3. GestureDetector gestureDetector=new GestureDetector(Context context,GestureDetector.SimpleOnGestureListener listener);  

    可 以看到，在构造函数中，除了后面要讲的SimpleOnGestureListener 以外的其它两个构造函数都必须是OnGestureListener的实例。所以要想使用OnDoubleTapListener的几个函数，就必须先实 现OnGestureListener。

    2、函数讲解：

    首先看一下OnDoubleTapListener接口必须重写的三个函数：

    [java] view plain copy 在CODE上查看代码片派生到我的代码片
    1. private class doubleTapListener implements GestureDetector.OnDoubleTapListener{  
    2.   
    3.     public boolean onSingleTapConfirmed(MotionEvent e) {  
    4.         // TODO Auto-generated method stub  
    5.         return false;  
    6.     }  
    7.   
    8.     public boolean onDoubleTap(MotionEvent e) {  
    9.         // TODO Auto-generated method stub  
    10.         return false;  
    11.     }  
    12.   
    13.     public boolean onDoubleTapEvent(MotionEvent e) {  
    14.         // TODO Auto-generated method stub  
    15.         return false;  
    16.     }  
    17. }  

    onSingleTapConfirmed(MotionEvent e)：单 击事件。用来判定该次点击是SingleTap而不是DoubleTap，如果连续点击两次就是DoubleTap手势，如果只点击一次，系统等待一段时 间后没有收到第二次点击则判定该次点击为SingleTap而不是DoubleTap，然后触发SingleTapConfirmed事件。触发顺序 是：OnDown->OnsingleTapUp->OnsingleTapConfirmed
    关于 onSingleTapConfirmed和onSingleTapUp的一点区别： OnGestureListener有这样的一个方法onSingleTapUp，和onSingleTapConfirmed容易混淆。二者的区别 是：onSingleTapUp，只要手抬起就会执行，而对于onSingleTapConfirmed来说，如果双击的话，则 onSingleTapConfirmed不会执行。

    onDoubleTap(MotionEvent e)：双击事件

    onDoubleTapEvent(MotionEvent e)：双击间隔中发生的动作。指触发onDoubleTap以后，在双击之间发生的其它动作，包含down、up和move事件；下图是双击一下的Log输出：

    两点总结：

    1、从上图可以看出，在第二下点击时，先触发OnDoubleTap，然后再触发OnDown（第二次点击）

    2、其次在触发OnDoubleTap以后，就开始触发onDoubleTapEvent了，onDoubleTapEvent后面的数字代表了当前的事件，0指ACTION_DOWN，1指ACTION_UP，2 指ACTION_MOVE
    在上一个例子的基础上，我们再添加一个双击监听类，实现如下：

    [java] view plain copy 在CODE上查看代码片派生到我的代码片
    1. public class MainActivity extends Activity implements OnTouchListener{  
    2.   
    3.     private GestureDetector mGestureDetector;     
    4.       
    5.   
    6.     @Override  
    7.     protected void onCreate(Bundle savedInstanceState) {  
    8.         super.onCreate(savedInstanceState);  
    9.         setContentView(R.layout.activity_main);  
    10.           
    11.   
    12.       mGestureDetector = new GestureDetector(new gestureListener()); //使用派生自OnGestureListener  
    13.       mGestureDetector.setOnDoubleTapListener(new doubleTapListener());  
    14.           
    15.       TextView tv = (TextView)findViewById(R.id.tv);  
    16.       tv.setOnTouchListener(this);  
    17.       tv.setFocusable(true);     
    18.       tv.setClickable(true);     
    19.       tv.setLongClickable(true);   
    20.     }  
    21.       
    22.       
    23.     /*  
    24.      * 在onTouch()方法中，我们调用GestureDetector的onTouchEvent()方法，将捕捉到的MotionEvent交给GestureDetector  
    25.      * 来分析是否有合适的callback函数来处理用户的手势  
    26.      */    
    27.     public boolean onTouch(View v, MotionEvent event) {  
    28.         return mGestureDetector.onTouchEvent(event);     
    29.     }  
    30.       
    31.     //OnGestureListener监听  
    32.     private class gestureListener implements GestureDetector.OnGestureListener{  
    33.   
    34.         public boolean onDown(MotionEvent e) {  
    35.             Log.i("MyGesture", "onDown");     
    36.             Toast.makeText(MainActivity.this, "onDown", Toast.LENGTH_SHORT).show();     
    37.             return false;  
    38.         }  
    39.   
    40.         public void onShowPress(MotionEvent e) {  
    41.             Log.i("MyGesture", "onShowPress");     
    42.             Toast.makeText(MainActivity.this, "onShowPress", Toast.LENGTH_SHORT).show();     
    43.         }  
    44.   
    45.         public boolean onSingleTapUp(MotionEvent e) {  
    46.             Log.i("MyGesture", "onSingleTapUp");     
    47.             Toast.makeText(MainActivity.this, "onSingleTapUp", Toast.LENGTH_SHORT).show();     
    48.             return true;     
    49.         }  
    50.   
    51.         public boolean onScroll(MotionEvent e1, MotionEvent e2,  
    52.                 float distanceX, float distanceY) {  
    53.             Log.i("MyGesture22", "onScroll:"+(e2.getX()-e1.getX()) +"   "+distanceX);     
    54.             Toast.makeText(MainActivity.this, "onScroll", Toast.LENGTH_LONG).show();     
    55.               
    56.             return true;     
    57.         }  
    58.   
    59.         public void onLongPress(MotionEvent e) {  
    60.              Log.i("MyGesture", "onLongPress");     
    61.              Toast.makeText(MainActivity.this, "onLongPress", Toast.LENGTH_LONG).show();     
    62.         }  
    63.   
    64.         public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,  
    65.                 float velocityY) {  
    66.             Log.i("MyGesture", "onFling");     
    67.             Toast.makeText(MainActivity.this, "onFling", Toast.LENGTH_LONG).show();     
    68.             return true;  
    69.         }  
    70.     };  
    71.       
    72.     //OnDoubleTapListener监听  
    73.     private class doubleTapListener implements GestureDetector.OnDoubleTapListener{  
    74.   
    75.         public boolean onSingleTapConfirmed(MotionEvent e) {  
    76.             Log.i("MyGesture", "onSingleTapConfirmed");     
    77.             Toast.makeText(MainActivity.this, "onSingleTapConfirmed", Toast.LENGTH_LONG).show();    
    78.             return true;  
    79.         }  
    80.   
    81.         public boolean onDoubleTap(MotionEvent e) {  
    82.             Log.i("MyGesture", "onDoubleTap");     
    83.             Toast.makeText(MainActivity.this, "onDoubleTap", Toast.LENGTH_LONG).show();    
    84.             return true;  
    85.         }  
    86.   
    87.         public boolean onDoubleTapEvent(MotionEvent e) {  
    88.             Log.i("MyGesture", "onDoubleTapEvent");     
    89.             Toast.makeText(MainActivity.this, "onDoubleTapEvent", Toast.LENGTH_LONG).show();    
    90.             return true;  
    91.         }  
    92.     };  
    93. }  

    双击一下，部分截图如下：

    双击所对应的触发事件顺序：

    轻轻单击一下，对应的事件触发顺序为：

    源码在博客底部给出。

    四、GestureDetector.SimpleOnGestureListener---类

    它与前两个不同的是：
    1、这是一个类，在它基础上新建类的话，要用extends派生而不是用implements继承！
    2、 OnGestureListener和OnDoubleTapListener接口里的函数都是强制必须重写的，即使用不到也要重写出来一个空函数但在 SimpleOnGestureListener类的实例或派生类中不必如此，可以根据情况，用到哪个函数就重写哪个函数，因为 SimpleOnGestureListener类本身已经实现了这两个接口的所有函数，只是里面全是空的而已。

    下面利用SimpleOnGestureListener类来重新实现上面的几个效果，代码如下：

    [java] view plain copy 在CODE上查看代码片派生到我的代码片
    1. public class MainActivity extends Activity implements OnTouchListener {  
    2.   
    3.     private GestureDetector mGestureDetector;     
    4.       
    5.     @Override  
    6.     protected void onCreate(Bundle savedInstanceState) {  
    7.         super.onCreate(savedInstanceState);  
    8.         setContentView(R.layout.activity_main);  
    9.           
    10.         mGestureDetector = new GestureDetector(new simpleGestureListener());  
    11.           
    12.         TextView tv = (TextView)findViewById(R.id.tv);  
    13.         tv.setOnTouchListener(this);  
    14.         tv.setFocusable(true);     
    15.         tv.setClickable(true);     
    16.         tv.setLongClickable(true);   
    17.     }  
    18.       
    19.     public boolean onTouch(View v, MotionEvent event) {  
    20.         // TODO Auto-generated method stub  
    21.         return mGestureDetector.onTouchEvent(event);     
    22.     }  
    23.   
    24.     private class simpleGestureListener extends  
    25.             GestureDetector.SimpleOnGestureListener {  
    26.           
    27.         /*****OnGestureListener的函数*****/  
    28.         public boolean onDown(MotionEvent e) {  
    29.             Log.i("MyGesture", "onDown");  
    30.             Toast.makeText(MainActivity.this, "onDown", Toast.LENGTH_SHORT)  
    31.                     .show();  
    32.             return false;  
    33.         }  
    34.   
    35.         public void onShowPress(MotionEvent e) {  
    36.             Log.i("MyGesture", "onShowPress");  
    37.             Toast.makeText(MainActivity.this, "onShowPress", Toast.LENGTH_SHORT)  
    38.                     .show();  
    39.         }  
    40.   
    41.         public boolean onSingleTapUp(MotionEvent e) {  
    42.             Log.i("MyGesture", "onSingleTapUp");  
    43.             Toast.makeText(MainActivity.this, "onSingleTapUp",  
    44.                     Toast.LENGTH_SHORT).show();  
    45.             return true;  
    46.         }  
    47.   
    48.         public boolean onScroll(MotionEvent e1, MotionEvent e2,  
    49.                 float distanceX, float distanceY) {  
    50.             Log.i("MyGesture", "onScroll:" + (e2.getX() - e1.getX()) + "   "  
    51.                     + distanceX);  
    52.             Toast.makeText(MainActivity.this, "onScroll", Toast.LENGTH_LONG)  
    53.                     .show();  
    54.   
    55.             return true;  
    56.         }  
    57.   
    58.         public void onLongPress(MotionEvent e) {  
    59.             Log.i("MyGesture", "onLongPress");  
    60.             Toast.makeText(MainActivity.this, "onLongPress", Toast.LENGTH_LONG)  
    61.                     .show();  
    62.         }  
    63.   
    64.         public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,  
    65.                 float velocityY) {  
    66.             Log.i("MyGesture", "onFling");  
    67.             Toast.makeText(MainActivity.this, "onFling", Toast.LENGTH_LONG)  
    68.                     .show();  
    69.             return true;  
    70.         }  
    71.           
    72.         /*****OnDoubleTapListener的函数*****/  
    73.         public boolean onSingleTapConfirmed(MotionEvent e) {  
    74.             Log.i("MyGesture", "onSingleTapConfirmed");  
    75.             Toast.makeText(MainActivity.this, "onSingleTapConfirmed",  
    76.                     Toast.LENGTH_LONG).show();  
    77.             return true;  
    78.         }  
    79.   
    80.         public boolean onDoubleTap(MotionEvent e) {  
    81.             Log.i("MyGesture", "onDoubleTap");  
    82.             Toast.makeText(MainActivity.this, "onDoubleTap", Toast.LENGTH_LONG)  
    83.                     .show();  
    84.             return true;  
    85.         }  
    86.   
    87.         public boolean onDoubleTapEvent(MotionEvent e) {  
    88.             Log.i("MyGesture", "onDoubleTapEvent");  
    89.             Toast.makeText(MainActivity.this, "onDoubleTapEvent",  
    90.                     Toast.LENGTH_LONG).show();  
    91.             return true;  
    92.         }  
    93.   
    94.     }  
    95. }  


    到此，有关GestureDetector的所有基础知识都讲解完了，下面给出一个小应用——识别用户是向左滑还是向右滑！

    源码在博客底部给出。

    五、OnFling应用——识别向左滑还是向右滑

    这部分就有点意思了，可以说是上面知识的一个小应用，我们利用OnFling函数来识别当前用户是在向左滑还是向右滑，从而打出日志。先看下OnFling的参数：

    [java] view plain copy 在CODE上查看代码片派生到我的代码片
    1. boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,float velocityY)  
    2. 参数解释：     
    3. e1：第1个ACTION_DOWN MotionEvent     
    4. e2：最后一个ACTION_MOVE MotionEvent     
    5. velocityX：X轴上的移动速度，像素/秒     
    6. velocityY：Y轴上的移动速度，像素/秒     

    首先，先说一下实现的功能：当用户向左滑动距离超过100px，且滑动速度超过100 px/s时,即判断为向左滑动;向右同理.代码如下:

    [java] view plain copy 在CODE上查看代码片派生到我的代码片
    1. public class MainActivity extends Activity implements OnTouchListener {  
    2.   
    3.     private GestureDetector mGestureDetector;     
    4.       
    5.     @Override  
    6.     protected void onCreate(Bundle savedInstanceState) {  
    7.         super.onCreate(savedInstanceState);  
    8.         setContentView(R.layout.activity_main);  
    9.           
    10.         mGestureDetector = new GestureDetector(new simpleGestureListener());  
    11.           
    12.         TextView tv = (TextView)findViewById(R.id.tv);  
    13.         tv.setOnTouchListener(this);  
    14.         tv.setFocusable(true);     
    15.         tv.setClickable(true);     
    16.         tv.setLongClickable(true);   
    17.     }  
    18.       
    19.     public boolean onTouch(View v, MotionEvent event) {  
    20.         // TODO Auto-generated method stub  
    21.         return mGestureDetector.onTouchEvent(event);     
    22.     }  
    23.   
    24.     private class simpleGestureListener extends  
    25.             GestureDetector.SimpleOnGestureListener {  
    26.           
    27.         /*****OnGestureListener的函数*****/  
    28.   
    29.         final int FLING_MIN_DISTANCE = 100, FLING_MIN_VELOCITY = 200;    
    30.           
    31.         // 触发条件 ：     
    32.         // X轴的坐标位移大于FLING_MIN_DISTANCE，且移动速度大于FLING_MIN_VELOCITY个像素/秒     
    33.          
    34.         // 参数解释：     
    35.         // e1：第1个ACTION_DOWN MotionEvent     
    36.         // e2：最后一个ACTION_MOVE MotionEvent     
    37.         // velocityX：X轴上的移动速度，像素/秒     
    38.         // velocityY：Y轴上的移动速度，像素/秒     
    39.         public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,  
    40.                 float velocityY) {  
    41.               
    42.               
    43.             if (e1.getX() - e2.getX() > FLING_MIN_DISTANCE    
    44.                     && Math.abs(velocityX) > FLING_MIN_VELOCITY) {    
    45.                 // Fling left     
    46.                 Log.i("MyGesture", "Fling left");    
    47.                 Toast.makeText(MainActivity.this, "Fling Left", Toast.LENGTH_SHORT).show();    
    48.             } else if (e2.getX() - e1.getX() > FLING_MIN_DISTANCE    
    49.                     && Math.abs(velocityX) > FLING_MIN_VELOCITY) {    
    50.                 // Fling right     
    51.                 Log.i("MyGesture", "Fling right");    
    52.                 Toast.makeText(MainActivity.this, "Fling Right", Toast.LENGTH_SHORT).show();    
    53.             }    
    54.             return true;  
    55.         }  
    56.   
    57.     }  
    58. }  

    这段代码难度不大,就不再细讲,看下效果:

    源码地址：http://download.csdn.net/detail/harvic880925/7978943

    转载：http://blog.csdn.net/harvic880925/article/details/39520901
  • 相关阅读:
    Html禁止粘贴 复制 剪切
    表单标签
    自构BeanHandler(用BeansUtils)
    spring配置中引入properties
    How Subcontracting Cockpit ME2ON creates SD delivery?
    cascadia code一款很好看的微软字体
    How condition value calculated in sap
    Code in SAP query
    SO Pricing not updated for partial billing items
    Javascript learning
  • 原文地址：https://www.cnblogs.com/mgstone/p/5802936.html
Copyright © 2011-2022 走看看