Android VelocityTracker使用总结

VelocityTracker是一个什么东西呢，查看VelocityTracker源代码发现有如下注释：

[html]  view plain copy print ?

1. /**  
2.     * Helper for tracking the velocity of touch events, for implementing  
3.     * flinging and other such gestures.  
4.     *  
5.     * Use {@link #obtain} to retrieve a new instance of the class when you are going  
6.     * to begin tracking.  Put the motion events you receive into it with  
7.     * {@link #addMovement(android.view.MotionEvent)}.  When you want to determine the velocity call  
8.     * {@link #computeCurrentVelocity(int)} and then call {@link #getXVelocity(int)}  
9.     * and {@link #getYVelocity(int)} to retrieve the velocity for each pointer id.  
10.     *  
11.     * 追踪触摸事件速率，实现flinging和其他手势的帮助类  
12.     *  
13.     * 1、当开始追踪的时候，使用obtain来获取VelocityTracker类的实例  
14.     * 2、把接收到的MotionEvent放入到addMovement(android.view.MotionEvent)中  
15.     * 3、当要确定速度时调用computeCurrentVelocity(int)，  
16.     *   使用getXVelocity(int)和getYVelocity(int)来检测每个触摸点id的速率  
17.     */  

VelocityTracker是一个帮助追踪触摸事件速率的追踪器，可以追踪fliinging和其他触摸手势。

如何使用VelocityTracker呢，注释中提到如下步骤：

[html]  view plain copy print ?

1. 1、当开始追踪的时候，使用obtain来获取VelocityTracker类的实例  
2. 2、把接受到的MotionEvent放入到addMovement(android.view.MotionEvent)中  
3. 3、当要确定速度时调用computeCurrentVelocity(int)，  
4.       使用getXVelocity(int)和getYVelocity(int)来检测每个触摸点id的速率  

既然VelocityTracker是追踪触摸事件的速度追踪器，当然需要与触摸事件结合使用。

第一步：当你想要追踪触摸事件的速度时，使用private VelocityTracker mVelocityTracker = VelocityTracker.obtain();来获取一个实例，

obtain()方法的源代码：

[java]  view plain copy print ?

1. /** 
2.   * Retrieve a new VelocityTracker object to watch the velocity of a 
3.   * motion.  Be sure to call {@link #recycle} when done.  You should 
4.   * generally only maintain an active object while tracking a movement, 
5.   * so that the VelocityTracker can be re-used elsewhere. 
6.   * 
7.   * @return Returns a new VelocityTracker. 
8.   * 
9.   * 获取一个新的VelocityTracker对象，用于检测一个动作的速率 
10.   * 检测结束时确保调用了recycle()方法来回收VelocityTracker对象 
11.   * 追踪一个移动事件时通常只需要维护一个活动对象，这样VelocityTracker可以被重用 
12.   */  
13.  static public VelocityTracker obtain() {  
14.      VelocityTracker instance = sPool.acquire();  
15.      return (instance != null) ? instance : new VelocityTracker(null);  
16.  }  

第二步：把接收到的MotionEvent放入到addMovement(MotionEvent event)方法中，

在初始化MotionEvent的ACTION_DOWN时调用addMovement(MotionEvent event)

然后在ACTION_MOVE和ACTION_UP动作中就可以检测到速度了。

[java]  view plain copy print ?

1. /** 
2.     * Add a user's movement to the tracker.  You should call this for the 
3.     * initial {@link MotionEvent#ACTION_DOWN}, the following 
4.     * {@link MotionEvent#ACTION_MOVE} events that you receive, and the 
5.     * final {@link MotionEvent#ACTION_UP}.  You can, however, call this 
6.     * for whichever events you desire. 
7.     * 
8.     * @param event The MotionEvent you received and would like to track. 
9.     * 
10.     * 添加一个移动事件到追踪器 
11.     * 1.为初始化MotionEvent的ACTION_DOWN动作调用addMovement() 
12.     * 2.接下来，在MotionEvent的ACTION_MOVE和ACTION_UP动作中接收。 
13.     *    不管是哪一个events都可以调用本方法 
14.     */  
15.    public void addMovement(MotionEvent event) {  
16.        if (event == null) {  
17.            throw new IllegalArgumentException("event must not be null");  
18.        }  
19.        nativeAddMovement(mPtr, event);  
20.    }  

第三步：想要确定速度的时候调用computeCurrentVelocity(int units)方法。有两个同样的方法，一个带有最大值参数，默认为Float.MAX_VALUE

[java]  view plain copy print ?

1. /** 
2.  * Compute the current velocity based on the points that have been 
3.  * collected.  Only call this when you actually want to retrieve velocity 
4.  * information, as it is relatively expensive.  You can then retrieve 
5.  * the velocity with {@link #getXVelocity()} and 
6.  * {@link #getYVelocity()}. 
7.  * 根据收集到的触摸点计算当前速率 
8.  * 因为此方法相当消耗性能，所以只有当真的确实想要检测速度信息的时候才调用这个方法 
9.  * 然后可以通过getXVelocity()和getYVelocity()方法获取到追踪的速度 
10.  * 
11.  * @param units The units you would like the velocity in.  A value of 1 
12.  * provides pixels per millisecond, 1000 provides pixels per second, etc. 
13.  *        units ：代表速度的单位， 
14.  *              值为1时：代表每毫秒运动一个像素，px/ms 
15.  *              值为1000时：代表每秒运动1000个像素，1000px/s 
16.  * @param maxVelocity The maximum velocity that can be computed by this method. 
17.  * This value must be declared in the same unit as the units parameter. This value 
18.  * must be positive. 
19.  *        maxVelocity :代表可以被本方法计算的最大速度， 
20.  *                    这个值必须用同一个作为速度参数的单位声明，而且值必须为正数 
21.  */  
22. public void computeCurrentVelocity(int units, float maxVelocity) {  
23.     nativeComputeCurrentVelocity(mPtr, units, maxVelocity);  
24. }  

[java]  view plain copy print ?

1. /** 
2.     * Equivalent to invoking {@link #computeCurrentVelocity(int, float)} with a maximum 
3.     * velocity of Float.MAX_VALUE. 
4.     * 
5.     * @see #computeCurrentVelocity(int, float) 
6.     *  
7.     * 等价调用带有最大值为Float.MAX_VALUE的computeCurrentVelocity(int, float)方法， 
8.     */  
9.    public void computeCurrentVelocity(int units) {  
10.        nativeComputeCurrentVelocity(mPtr, units, Float.MAX_VALUE);  
11.    }  

第四步：使用getXVelocity()和getYVelocity()方法获取检测到的速度

获取X轴方向的速度：

[java]  view plain copy print ?

1. /** 
2.     * Retrieve the last computed X velocity.  You must first call 
3.     * {@link #computeCurrentVelocity(int)} before calling this function. 
4.     *  
5.     * 检测最后计算的X轴方向的速度，在调用getXVelocity()之前必须先调用computeCurrentVelocity(int) 
6.     * @return The previously computed X velocity. 
7.     */  
8.    public float getXVelocity() {  
9.        return nativeGetXVelocity(mPtr, ACTIVE_POINTER_ID);  
10.    }  

获取Y轴方向上的速度：

[java]  view plain copy print ?

1. /** 
2.      * Retrieve the last computed Y velocity.  You must first call 
3.      * {@link #computeCurrentVelocity(int)} before calling this function. 
4.      * 
5.      * 检测最后计算的X轴方向的速度，在调用getXVelocity()之前必须先调用computeCurrentVelocity(int) 
6.      * @return The previously computed Y velocity. 
7.      */  
8.     public float getYVelocity() {  
9.         return nativeGetYVelocity(mPtr, ACTIVE_POINTER_ID);  
10.     }  

第五步：回收VelocityTracker实例

[java]  view plain copy print ?

1. /** 
2.    * Return a VelocityTracker object back to be re-used by others.  You must 
3.    * not touch the object after calling this function. 
4.    * 
5.    * 回收一个VelocityTracker对象给其他动作事件使用 
6.    * 在调用recycle()这个函数之后，你不能访问VelocityTracker对象 
7.    */  
8.   public void recycle() {  
9.       if (mStrategy == null) {  
10.           clear();  
11.           sPool.release(this);  
12.       }  
13.   }  

小实例：

[java]  view plain copy print ?

1. package com.zwc.admin.scrollerdemo;  
2.   
3. import android.support.v7.app.ActionBarActivity;  
4. import android.os.Bundle;  
5. import android.util.Log;  
6. import android.view.MotionEvent;  
7. import android.view.VelocityTracker;  
8.   
9.   
10. public class VelocityTrackerTestActivity extends ActionBarActivity {  
11.   
12.     private static final String TAG = "VelocityTrackerTestActivity";  
13.   
14.     private VelocityTracker mVelocityTracker;  
15.     private int mPointerId;  
16.   
17.     @Override  
18.     protected void onCreate(Bundle savedInstanceState) {  
19.         super.onCreate(savedInstanceState);  
20.         setContentView(R.layout.activity_velocity_tracker_test);  
21.     }  
22.   
23.     @Override  
24.     public boolean onTouchEvent(MotionEvent event) {  
25.         int action = event.getAction();  
26.         if (null == mVelocityTracker) {  
27.             mVelocityTracker = VelocityTracker.obtain();  
28.         }  
29.         mVelocityTracker.addMovement(event);  
30.           
31.         switch (action) {  
32.             case MotionEvent.ACTION_DOWN:  
33.                 //获取第一个触摸点的id  
34.                 mPointerId = event.getPointerId(0);  
35.                 break;  
36.   
37.             case MotionEvent.ACTION_MOVE:  
38.                 mVelocityTracker.computeCurrentVelocity(1000);  
39.                 float xVelocity = mVelocityTracker.getXVelocity(event.getPointerId(mPointerId));  
40.                 float yVelocity = mVelocityTracker.getYVelocity(event.getPointerId(mPointerId));  
41.                 Log.e(TAG, "xVelocity = " + xVelocity + ",yVelocity = " + yVelocity);  
42.                 break;  
43.   
44.             case MotionEvent.ACTION_UP:  
45.             case MotionEvent.ACTION_CANCEL:  
46.                 if (null != mVelocityTracker) {  
47.                     mVelocityTracker.recycle();  
48.                 }  
49.                 break;  
50.         }  
51.   
52.         return super.onTouchEvent(event);  
53.     }  
54.   
55. }