Android L（5.0）源码之手势识别onTouchEvent

onTouchEvent同样也是在view中定义的一个方法。处理传递到view 的手势事件。通过MotionEvent的getAction()方法来获取Touch事件的类型，类型包括ACTION_DOWN,ACTION_MOVE,ACTION_UP,ACTION_CANCEL等事件。其中ACTION_DOWN是指按下触摸屏，ACTION_MOVE是指按下触摸屏后移动受力点，ACTION_UP则是指松 开触摸屏，ACTION_CANCEL不会由用户直接触发。

贴上View.onTouchEvent的android 5.0源代码

     public boolean onTouchEvent(MotionEvent event) {
         final float x = event.getX();
         final float y = event.getY();
         final int viewFlags = mViewFlags;

         if ((viewFlags & ENABLED_MASK) == DISABLED) {
             if (event.getAction() == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
                 setPressed(false);
             }
             // A disabled view that is clickable still consumes the touch
             // events, it just doesn't respond to them.
             return (((viewFlags & CLICKABLE) == CLICKABLE ||
                     (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE));
         }

         if (mTouchDelegate != null) {
             if (mTouchDelegate.onTouchEvent(event)) {
                 return true;
             }
         }

         if (((viewFlags & CLICKABLE) == CLICKABLE ||
                 (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {
             switch (event.getAction()) {
                 case MotionEvent.ACTION_UP:
                     boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
                     if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {
                         // take focus if we don't have it already and we should in
                         // touch mode.
                         boolean focusTaken = false;
                         if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {
                             focusTaken = requestFocus();
                         }

                         if (prepressed) {
                             // The button is being released before we actually
                             // showed it as pressed.  Make it show the pressed
                             // state now (before scheduling the click) to ensure
                             // the user sees it.
                             setPressed(true, x, y);
                        }

                         if (!mHasPerformedLongPress) {
                             // This is a tap, so remove the longpress check
                             removeLongPressCallback();

                             // Only perform take click actions if we were in the pressed state
                             if (!focusTaken) {
                                 // Use a Runnable and post this rather than calling
                                 // performClick directly. This lets other visual state
                                 // of the view update before click actions start.
                                 if (mPerformClick == null) {
                                     mPerformClick = new PerformClick();
                                 }
                                 if (!post(mPerformClick)) {
                                     performClick();
                                 }
                             }
                         }

                         if (mUnsetPressedState == null) {
                             mUnsetPressedState = new UnsetPressedState();
                         }

                         if (prepressed) {
                             postDelayed(mUnsetPressedState,
                                     ViewConfiguration.getPressedStateDuration());
                         } else if (!post(mUnsetPressedState)) {
                             // If the post failed, unpress right now
                             mUnsetPressedState.run();
                         }

                         removeTapCallback();
                     }
                     break;

                 case MotionEvent.ACTION_DOWN:
                     mHasPerformedLongPress = false;

                     if (performButtonActionOnTouchDown(event)) {
                         break;
                     }

                     // Walk up the hierarchy to determine if we're inside a scrolling container.
                     boolean isInScrollingContainer = isInScrollingContainer();

                     // For views inside a scrolling container, delay the pressed feedback for
                     // a short period in case this is a scroll.
                     if (isInScrollingContainer) {
                         mPrivateFlags |= PFLAG_PREPRESSED;
                         if (mPendingCheckForTap == null) {
                             mPendingCheckForTap = new CheckForTap();
                         }
                         mPendingCheckForTap.x = event.getX();
                         mPendingCheckForTap.y = event.getY();
                         postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
                     } else {
                         // Not inside a scrolling container, so show the feedback right away
                         setPressed(true, x, y);
                         checkForLongClick(0);
                     }
                     break;

                 case MotionEvent.ACTION_CANCEL:
                     setPressed(false);
                     removeTapCallback();
                     removeLongPressCallback();
                     break;

                 case MotionEvent.ACTION_MOVE:
                     drawableHotspotChanged(x, y);

                     // Be lenient about moving outside of buttons
                     if (!pointInView(x, y, mTouchSlop)) {
                         // Outside button
                         removeTapCallback();
                         if ((mPrivateFlags & PFLAG_PRESSED) != 0) {
                             // Remove any future long press/tap checks
                             removeLongPressCallback();

                             setPressed(false);
                         }
                     }
                     break;
             }

             return true;
         }

         return false;
     }

随后，在onTouch()方法中，我们调用GestureDetector的onTouchEvent()方法，将捕捉到的MotionEvent交给 GestureDetector 来分析是否有合适的callback函数来处理用户的手势。

贴上GestureDetector.onTouchEvent的android 5.0的源码：

     public boolean onTouchEvent(MotionEvent ev) {
         if (mInputEventConsistencyVerifier != null) {
             mInputEventConsistencyVerifier.onTouchEvent(ev, 0);
         }

         final int action = ev.getAction();

         if (mVelocityTracker == null) {
             mVelocityTracker = VelocityTracker.obtain();
         }
         mVelocityTracker.addMovement(ev);

         final boolean pointerUp =
                 (action & MotionEvent.ACTION_MASK) == MotionEvent.ACTION_POINTER_UP;
         final int skipIndex = pointerUp ? ev.getActionIndex() : -1;

         // Determine focal point
         float sumX = 0, sumY = 0;
         final int count = ev.getPointerCount();
         for (int i = 0; i < count; i++) {
             if (skipIndex == i) continue;
             sumX += ev.getX(i);
             sumY += ev.getY(i);
         }
         final int div = pointerUp ? count - 1 : count;
         final float focusX = sumX / div;
         final float focusY = sumY / div;

         boolean handled = false;

         switch (action & MotionEvent.ACTION_MASK) {
         case MotionEvent.ACTION_POINTER_DOWN:
             mDownFocusX = mLastFocusX = focusX;
             mDownFocusY = mLastFocusY = focusY;
             // Cancel long press and taps
             cancelTaps();
             break;

         case MotionEvent.ACTION_POINTER_UP:
             mDownFocusX = mLastFocusX = focusX;
             mDownFocusY = mLastFocusY = focusY;

             // Check the dot product of current velocities.
             // If the pointer that left was opposing another velocity vector, clear.
             mVelocityTracker.computeCurrentVelocity(1000, mMaximumFlingVelocity);
             final int upIndex = ev.getActionIndex();
             final int id1 = ev.getPointerId(upIndex);
             final float x1 = mVelocityTracker.getXVelocity(id1);
             final float y1 = mVelocityTracker.getYVelocity(id1);
             for (int i = 0; i < count; i++) {
                 if (i == upIndex) continue;

                 final int id2 = ev.getPointerId(i);
                 final float x = x1 * mVelocityTracker.getXVelocity(id2);
                 final float y = y1 * mVelocityTracker.getYVelocity(id2);

                 final float dot = x + y;
                 if (dot < 0) {
                     mVelocityTracker.clear();
                     break;
                 }
             }
             break;

         case MotionEvent.ACTION_DOWN:
             if (mDoubleTapListener != null) {
                 boolean hadTapMessage = mHandler.hasMessages(TAP);
                 if (hadTapMessage) mHandler.removeMessages(TAP);
                 if ((mCurrentDownEvent != null) && (mPreviousUpEvent != null) && hadTapMessage &&
                         isConsideredDoubleTap(mCurrentDownEvent, mPreviousUpEvent, ev)) {
                     // This is a second tap
                     mIsDoubleTapping = true;
                     // Give a callback with the first tap of the double-tap
                     handled |= mDoubleTapListener.onDoubleTap(mCurrentDownEvent);
                     // Give a callback with down event of the double-tap
                     handled |= mDoubleTapListener.onDoubleTapEvent(ev);
                 } else {
                     // This is a first tap
                     mHandler.sendEmptyMessageDelayed(TAP, DOUBLE_TAP_TIMEOUT);
                 }
             }

             mDownFocusX = mLastFocusX = focusX;
             mDownFocusY = mLastFocusY = focusY;
             if (mCurrentDownEvent != null) {
                 mCurrentDownEvent.recycle();
             }
             mCurrentDownEvent = MotionEvent.obtain(ev);
             mAlwaysInTapRegion = true;
             mAlwaysInBiggerTapRegion = true;
             mStillDown = true;
             mInLongPress = false;
             mDeferConfirmSingleTap = false;

             if (mIsLongpressEnabled) {
                 mHandler.removeMessages(LONG_PRESS);
                 mHandler.sendEmptyMessageAtTime(LONG_PRESS, mCurrentDownEvent.getDownTime()
                         + TAP_TIMEOUT + LONGPRESS_TIMEOUT);
             }
             mHandler.sendEmptyMessageAtTime(SHOW_PRESS, mCurrentDownEvent.getDownTime() + TAP_TIMEOUT);
             handled |= mListener.onDown(ev);
             break;

         case MotionEvent.ACTION_MOVE:
             if (mInLongPress) {
                 break;
             }
             final float scrollX = mLastFocusX - focusX;
             final float scrollY = mLastFocusY - focusY;
             if (mIsDoubleTapping) {
                 // Give the move events of the double-tap
                 handled |= mDoubleTapListener.onDoubleTapEvent(ev);
             } else if (mAlwaysInTapRegion) {
                 final int deltaX = (int) (focusX - mDownFocusX);
                 final int deltaY = (int) (focusY - mDownFocusY);
                 int distance = (deltaX * deltaX) + (deltaY * deltaY);
                 if (distance > mTouchSlopSquare) {
                     handled = mListener.onScroll(mCurrentDownEvent, ev, scrollX, scrollY);
                     mLastFocusX = focusX;
                     mLastFocusY = focusY;
                     mAlwaysInTapRegion = false;
                     mHandler.removeMessages(TAP);
                     mHandler.removeMessages(SHOW_PRESS);
                     mHandler.removeMessages(LONG_PRESS);
                 }
                 if (distance > mDoubleTapTouchSlopSquare) {
                     mAlwaysInBiggerTapRegion = false;
                 }
             } else if ((Math.abs(scrollX) >= 1) || (Math.abs(scrollY) >= 1)) {
                 handled = mListener.onScroll(mCurrentDownEvent, ev, scrollX, scrollY);
                 mLastFocusX = focusX;
                 mLastFocusY = focusY;
             }
             break;

         case MotionEvent.ACTION_UP:
             mStillDown = false;
             MotionEvent currentUpEvent = MotionEvent.obtain(ev);
             if (mIsDoubleTapping) {
                 // Finally, give the up event of the double-tap
                 handled |= mDoubleTapListener.onDoubleTapEvent(ev);
             } else if (mInLongPress) {
                 mHandler.removeMessages(TAP);
                 mInLongPress = false;
             } else if (mAlwaysInTapRegion) {
                 handled = mListener.onSingleTapUp(ev);
                 if (mDeferConfirmSingleTap && mDoubleTapListener != null) {
                     mDoubleTapListener.onSingleTapConfirmed(ev);
                 }
             } else {

                 // A fling must travel the minimum tap distance
                 final VelocityTracker velocityTracker = mVelocityTracker;
                 final int pointerId = ev.getPointerId(0);
                 velocityTracker.computeCurrentVelocity(1000, mMaximumFlingVelocity);
                 final float velocityY = velocityTracker.getYVelocity(pointerId);
                 final float velocityX = velocityTracker.getXVelocity(pointerId);

                 if ((Math.abs(velocityY) > mMinimumFlingVelocity)
                         || (Math.abs(velocityX) > mMinimumFlingVelocity)){
                     handled = mListener.onFling(mCurrentDownEvent, ev, velocityX, velocityY);
                 }
             }
             if (mPreviousUpEvent != null) {
                 mPreviousUpEvent.recycle();
             }
             // Hold the event we obtained above - listeners may have changed the original.
             mPreviousUpEvent = currentUpEvent;
             if (mVelocityTracker != null) {
                 // This may have been cleared when we called out to the
                 // application above.
                 mVelocityTracker.recycle();
                 mVelocityTracker = null;
             }
             mIsDoubleTapping = false;
             mDeferConfirmSingleTap = false;
             mHandler.removeMessages(SHOW_PRESS);
             mHandler.removeMessages(LONG_PRESS);
             break;

         case MotionEvent.ACTION_CANCEL:
             cancel();
             break;
         }

         if (!handled && mInputEventConsistencyVerifier != null) {
             mInputEventConsistencyVerifier.onUnhandledEvent(ev, 0);
         }
         return handled;
     }

原理还不太清楚，只能先贴上代码，望各位大神指教，谢谢！