手势识别官方教程(3)识别移动手势(识别速度用VelocityTracker)

moving手势在onTouchEvent()或onTouch()中就可识别，编程时主要是识别积云的速度用VelocityTracker等，

Tracking Movement

　　This lesson describes how to track movement in touch events.

　　A new onTouchEvent() is triggered with an ACTION_MOVE event whenever the current touch contact position, pressure, or size changes. As described in Detecting Common Gestures, all of these events are recorded in the MotionEvent parameter of onTouchEvent().

　　Because finger-based touch isn't always the most precise form of interaction, detecting touch events is often based more on movement than on simple contact. To help apps distinguish between movement-based gestures (such as a swipe) and non-movement gestures (such as a single tap), Android includes the notion of "touch slop." Touch slop refers to the distance in pixels a user's touch can wander before the gesture is interpreted as a movement-based gesture. For more discussion of this topic, see Managing Touch Events in a ViewGroup.

　　There are several different ways to track movement in a gesture, depending on the needs of your application. For example:

Android为了区分swipe(按住一点挑动)和tap(轻按一点)定义了“touch slop”这个新概念，它是在手势被识别成移动手势之前像素的距离。
常见的识别移动手势的方法如下：

• The starting and ending position of a pointer (for example, move an on-screen object from point A to point B).

  看起始点

• The direction the pointer is traveling in, as determined by the x and y coordinates.

  在x或y轴上是否在移动

• History. You can find the size of a gesture's history by calling the MotionEvent method getHistorySize(). You can then obtain the positions, sizes, time, and pressures of each of the historical events by using the motion event's getHistorical<Value> methods. History is useful when rendering a trail of the user's finger, such as for touch drawing. See the MotionEvent reference for details.

  从历史点的位置，大小，时间，压力等来判断

• The velocity of the pointer as it moves across the touch screen.

  在屏幕上沿某个方向划动的速度

Track Velocity

　　You could have a movement-based gesture that is simply based on the distance and/or direction the pointer traveled. But velocity often is a determining factor in tracking a gesture's characteristics or even deciding whether the gesture occurred. To make velocity calculation easier, Android provides the VelocityTracker class and the VelocityTrackerCompat class in the Support Library. VelocityTracker helps you track the velocity of touch events. This is useful for gestures in which velocity is part of the criteria for the gesture, such as a fling.

识别速度主要用到 VelocityTracker 或 VelocityTrackerCompat ，下面是示例：

　　Here is a simple example that illustrates the purpose of the methods in the VelocityTracker API:

 public class MainActivity extends Activity {
     private static final String DEBUG_TAG = "Velocity";
         ...
     private VelocityTracker mVelocityTracker = null;
     @Override
     public boolean onTouchEvent(MotionEvent event) {
         int index = event.getActionIndex();
         int action = event.getActionMasked();
         int pointerId = event.getPointerId(index);

         switch(action) {
             case MotionEvent.ACTION_DOWN:
                 if(mVelocityTracker == null) {
                     // Retrieve a new VelocityTracker object to watch the velocity of a motion.
                     mVelocityTracker = VelocityTracker.obtain();
                 }
                 else {
                     // Reset the velocity tracker back to its initial state.
                     mVelocityTracker.clear();
                 }
                 // Add a user's movement to the tracker.
                 mVelocityTracker.addMovement(event);
                 break;
             case MotionEvent.ACTION_MOVE:
                 mVelocityTracker.addMovement(event);
                 // When you want to determine the velocity, call
                 // computeCurrentVelocity(). Then call getXVelocity()
                 // and getYVelocity() to retrieve the velocity for each pointer ID.
                 mVelocityTracker.computeCurrentVelocity(1000);
                 // Log velocity of pixels per second
                 // Best practice to use VelocityTrackerCompat where possible.
                 Log.d("", "X velocity: " +
                         VelocityTrackerCompat.getXVelocity(mVelocityTracker,
                         pointerId));
                 Log.d("", "Y velocity: " +
                         VelocityTrackerCompat.getYVelocity(mVelocityTracker,
                         pointerId));
                 break;
             case MotionEvent.ACTION_UP:
             case MotionEvent.ACTION_CANCEL:
                 // Return a VelocityTracker object back to be re-used by others.
                 mVelocityTracker.recycle();
                 break;
         }
         return true;
     }
 }

　　Note: Note that you should calculate velocity after an ACTION_MOVE event, not after ACTION_UP. After anACTION_UP, the X and Y velocities will be 0.