【转】android 手势识别和VelocityTracker

参考地址：

http://jcodecraeer.com/a/anzhuokaifa/androidkaifa/2012/1020/448.html

http://www.jcodecraeer.com/a/anzhuokaifa/androidkaifa/2012/1117/574.html

一.Android的手势操作识别

1.在android应用当中每一次手势的交互都都会依照如下顺序去执行的

• 刚接触到手机屏幕的时候，要触发MotionEvent事件
• 该事件被OnTouchListener监听，在要复写的onTouch()方法里获得该MotionEvent对象
• 通过GestureDetector（手势识别器）转发次MotionEvent对象至OnGestureListener。
• OnGestureListener获取到对象之后，根据对应的手势做出回应

2.这个顺序可以说就是手势交互的原理，下面一同来了解一下MotionEvent、GestureDetector和OnGestureListener。

MotionEvent: 这个类用于封装手势、触摸笔、轨迹球等等的动作事件。其内部封装了两个重要的属性X和Y，这两个属性分别用于记录横轴和纵轴的坐标。

GestureDetector: 识别各种手势。

OnGestureListener: 这是一个手势交互的监听接口，其中提供了多个抽象方法，并根据GestureDetector的手势识别结果调用相对应的方法。

下面我再通过一个切换图片的代码示例，演示一下手势交互的实现，让大伙对上面的执行顺序，以及各手势动作的区分有一个更加深刻的了解和记忆。

首先，提供一个只有ImageView的布局文件——main.xml。

 <?xml version="1.0" encoding="utf-8"?>
 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 android:orientation="vertical"
 android:layout_width="fill_parent"
 android:layout_height="fill_parent">

  <ImageView android:id="@+id/image"
 android:layout_width="fill_parent"
 android:layout_height="fill_parent"
 android:layout_gravity="center"/>
 </LinearLayout>

然后，完成我们的Activity，因为要监听触摸屏的触摸事件和手势事件，所以该Activity必须实现OnTouchListener和OnGestureListener两个接口，并重写其中的方法。具体代码如下：

 public class MainActivity extends Activity implements OnTouchListener, OnGestureListener { 

 //创建一个用于识别收拾的GestureDetector对象waiyuwu.blogcn.com
 private GestureDetector detector = new GestureDetector(this);
 //定义一个数组，用于放漂亮的女孩
 int[] girls = new int[]{R.drawable.girl1, R.drawable.girl2, R.drawable.girl3};
 //定义数组下标，以方便观看各个女孩
 private int index;
 private ImageView image;

 @Override
 public void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.main);
 image = (ImageView)findViewById(R.id.image);
 //设置一个初始显示的girl吧
 image.setImageResource(girls[index]);
 //监听这个ImageView组件上的触摸屏时间
 image.setOnTouchListener(this);
 //下面两个要记得设哦，不然就没法处理轻触以外的事件了，例如抛掷动作。
 image.setLongClickable(true);
 detector.setIsLongpressEnabled(true);
 }//用于呼喊下一个女孩的方法
 public void goNext(){
 index++;
 index = Math.abs(index % girls.length);
 image.setImageResource(girls[index]);
 }

 //重写OnTouchListener的onTouch方法
 //此方法在触摸屏被触摸，即发生触摸事件（接触和抚摸两个事件，挺形象）的时候被调用。
 @Override
 public boolean onTouch(View v, MotionEvent event) {
 detector.onTouchEvent(event);
 return true;
 }

 //在按下动作时被调用
 @Override
 public boolean onDown(MotionEvent e) {
 return false;
 }

 //在抛掷动作时被调用
 @Override
 public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
 float velocityY) {
 //velocityX表示横向的移动，根据手指移动的方向切换女孩
 if(velocityX < 0){
 goNext();
 }else if(velocityX > 0){
 goPrevious();
 }
 return false;
 }

 //用户呼唤上一个女孩的方法
 public void goPrevious(){
 index--;
 index = Math.abs(index % girls.length);
 image.setImageResource(girls[index]);
 }

 //在长按时被调用
 @Override
 public void onLongPress(MotionEvent e) {
 }

 //在滚动时调用
 @Override
 public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX,
 float distanceY) {
 return false;
 }

 //在按住时被调用
 @Override
 public void onShowPress(MotionEvent e) {
 }

 //在抬起时被调用
 @Override
 public boolean onSingleTapUp(MotionEvent e) {
 return false;
 }
 }

GestureDetector.OnGestureListener监听手势的方法有如下这些：

aaarticlea/png;base64,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" alt="" width="812" height="300" />

对这些方法做一下解释：

• 按下（onDown）： 刚刚手指接触到触摸屏的那一刹那，就是触的那一下。

• 抛掷（onFling）： 手指在触摸屏上迅速移动，并松开的动作。

• 长按（onLongPress）： 手指按在持续一段时间，并且没有松开。

• 滚动（onScroll）： 手指在触摸屏上滑动。

• 按住（onShowPress）： 手指按在触摸屏上，它的时间范围在按下起效，在长按之前。

• 抬起（onSingleTapUp）：手指离开触摸屏的那一刹那。

除了这些定义之外，鄙人也总结了一点算是经验的经验吧，在这里和大家分享一下。

• 任何手势动作都会先执行一次按下（onDown）动作。

• 长按（onLongPress）动作前一定会执行一次按住（onShowPress）动作。

• 按住（onShowPress）动作和按下（onDown）动作之后都会执行一次抬起（onSingleTapUp）动作。

• 长按（onLongPress）、滚动（onScroll）和抛掷（onFling）动作之后都不会执行抬起（onSingleTapUp）动作。

二.手势事件：滑动动速度跟踪类VelocityTracker介绍

VelocityTracker顾名思义即速度跟踪，在android中主要应用于touchEvent， VelocityTracker通过跟踪一连串事件实时计算出当前的速度，这样的用法在android系统空间中随处可见，比如Gestures中的 Fling, Scrolling等。

android.view.VelocityTracker主要用跟踪触摸屏事件 （flinging事件和其他gestures手势事件）的速率。用addMovement(MotionEvent)函数将Motion event加入到VelocityTracker类实例中.你可以使用getXVelocity() 或getXVelocity()获得横向和竖向的速率到速率时，但是使用它们之前请先调用computeCurrentVelocity(int)来初始 化速率的单位 。

主要函数

 

Public Methods
void	addMovement(MotionEventevent) Add a user's movement to the tracker.
void	clear() Reset the velocity tracker back to its initial state.
void	computeCurrentVelocity(int units, float maxVelocity) Compute the current velocity based on the points that have been collected. intunitis表示速率的基本时间单位。unitis值为1的表示是，一毫秒时间单位内运动了多少个像素， unitis值为1000表示一秒（1000毫秒）时间单位内运动了多少个像素 floatVelocity表示速率的最大值
void	computeCurrentVelocity(int units) Equivalent to invoking computeCurrentVelocity(int, float)with a maximum velocity of Float.MAX_VALUE.
abstract T	getNextPoolable()
float	getXVelocity() Retrieve the last computed X velocity.
float	getXVelocity(int id) Retrieve the last computed X velocity.
float	getYVelocity(int id) Retrieve the last computed Y velocity.
float	getYVelocity() Retrieve the last computed Y velocity.
abstract boolean	isPooled()
static VelocityTracker	obtain() Retrieve a new VelocityTracker object to watch the velocity of a motion.
void	recycle() Return a VelocityTracker object back to be re-used by others.
abstract void	setNextPoolable(T element)
abstract void	setPooled(boolean isPooled)

 

示例：

 

 private VelocityTracker mVelocityTracker;//生命变量
 //在onTouchEvent(MotionEvent ev)中
 if (mVelocityTracker == null) {
     mVelocityTracker = VelocityTracker.obtain();//获得VelocityTracker类实例
 }
 mVelocityTracker.addMovement(ev);//将事件加入到VelocityTracker类实例中
 //判断当ev事件是MotionEvent.ACTION_UP时：计算速率
 final VelocityTracker velocityTracker = mVelocityTracker;
 // 1000 provides pixels per second
 velocityTracker.computeCurrentVelocity(1, (float)0.01);//设置maxVelocity值为0.1时，速率大于0.01时，显示的速率都是0.01,速率小于0.01时，显示正常
 Log.i("test","velocityTraker"+velocityTracker.getXVelocity());
 velocityTracker.computeCurrentVelocity(1000); //设置units的值为1000，意思为一秒时间内运动了多少个像素
 Log.i("test","velocityTraker"+velocityTracker.getXVelocity());

大体的使用是这样的：

 

当你需要跟踪触摸屏事件的速度的时候,使用obtain()方法来获得VelocityTracker类的一个实例对象

 

在onTouchEvent回调函数中，使用addMovement(MotionEvent)函数将当前的移动事件传递给VelocityTracker对象

 

使用computeCurrentVelocity (int units)函数来计算当前的速度，使用getXVelocity ()、 getYVelocity ()函数来获得当前的速度

下面是我写的一个简单Demo:

 package com.bxwu.demo.component.activity;
 import android.app.Activity;
 import android.graphics.Color;
 import android.os.Bundle;
 import android.view.MotionEvent;
 import android.view.VelocityTracker;
 import android.view.ViewConfiguration;
 import android.view.ViewGroup.LayoutParams;
 import android.widget.TextView;

 public class VelocityTrackerTest extends Activity {
     private TextView mInfo;

     private VelocityTracker mVelocityTracker;
     private int mMaxVelocity;

     private int mPointerId;

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);

         mInfo = new TextView(this);
         mInfo.setLines(4);
         mInfo.setLayoutParams(new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT));
         mInfo.setTextColor(Color.WHITE);

         setContentView(mInfo);

         mMaxVelocity = ViewConfiguration.get(this).getMaximumFlingVelocity();
     }

     @Override
     public boolean onTouchEvent(MotionEvent event) {
         final int action = event.getAction();
         acquireVelocityTracker(event);
         final VelocityTracker verTracker = mVelocityTracker;
         switch (action) {
             case MotionEvent.ACTION_DOWN:
                 //求第一个触点的id， 此时可能有多个触点，但至少一个
                 mPointerId = event.getPointerId(0);
                 break;

             case MotionEvent.ACTION_MOVE:
                 //求伪瞬时速度
                 verTracker.computeCurrentVelocity(1000, mMaxVelocity);
                 final float velocityX = verTracker.getXVelocity(mPointerId);
                 final float velocityY = verTracker.getYVelocity(mPointerId);
                 recodeInfo(velocityX, velocityY);
                 break;

             case MotionEvent.ACTION_UP:
                 releaseVelocityTracker();
                 break;

             case MotionEvent.ACTION_CANCEL:
                 releaseVelocityTracker();
                 break;

             default:
                 break;
         }
         return super.onTouchEvent(event);
     }

     /**
      *
      * @param event 向VelocityTracker添加MotionEvent
      *
      * @see android.view.VelocityTracker#obtain()
      * @see android.view.VelocityTracker#addMovement(MotionEvent)
      */
     private void acquireVelocityTracker(final MotionEvent event) {
         if(null == mVelocityTracker) {
             mVelocityTracker = VelocityTracker.obtain();
         }
         mVelocityTracker.addMovement(event);
     }

     /**
      * 释放VelocityTracker
      *
      * @see android.view.VelocityTracker#clear()
      * @see android.view.VelocityTracker#recycle()
      */
     private void releaseVelocityTracker() {
         if(null != mVelocityTracker) {
             mVelocityTracker.clear();
             mVelocityTracker.recycle();
             mVelocityTracker = null;
         }
     }

     private static final String sFormatStr = "velocityX=%f\nvelocityY=%f";

     /**
      * 记录当前速度
      *
      * @param velocityX x轴速度
      * @param velocityY y轴速度
      */
     private void recodeInfo(final float velocityX, final float velocityY) {
         final String info = String.format(sFormatStr, velocityX, velocityY);
         mInfo.setText(info);
     }
 }

 

代码很简单，我们可以求出move过程中的伪瞬时速度， 这样在做很多控件的时候都是可以用到的，比如系统Launcher的分页，

ScrollView滑动等， 可根据此时的速度来计算ACTION_UP后的减速运动等。实现一些非常棒的效果。

来源： <http://www.jcodecraeer.com/a/anzhuokaifa/androidkaifa/2012/1117/574.html>

来源： <http://jcodecraeer.com/a/anzhuokaifa/androidkaifa/2012/1020/448.html>

android手势处理揭秘