Android Touch事件相关源码【Android SourceCode 2.3.6】

2018-05-31 17:23:46

Note: 这里的源码来自Android 2.3.6，这个版本的代码比较简单，适合理解Touch事件的传递原理。后续版本源码复杂了很多，但是原理都是类似的。

2个方法源码较多，在这里记录下。

View.java

  /**
      * Implement this method to handle touch screen motion events.
      *
      * @param event The motion event.
      * @return True if the event was handled, false otherwise.
      */
     public boolean onTouchEvent(MotionEvent event) {
         final int viewFlags = mViewFlags;

         if ((viewFlags & ENABLED_MASK) == DISABLED) {
             // 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 & PREPRESSED) != 0;
                     if ((mPrivateFlags & 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 (!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) {
                             mPrivateFlags |= PRESSED;
                             refreshDrawableState();
                             postDelayed(mUnsetPressedState,
                                     ViewConfiguration.getPressedStateDuration());
                         } else if (!post(mUnsetPressedState)) {
                             // If the post failed, unpress right now
                             mUnsetPressedState.run();
                         }
                         removeTapCallback();
                     }
                     break;

                 case MotionEvent.ACTION_DOWN:
                     if (mPendingCheckForTap == null) {
                         mPendingCheckForTap = new CheckForTap();
                     }
                     mPrivateFlags |= PREPRESSED;
                     mHasPerformedLongPress = false;
                     postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
                     break;

                 case MotionEvent.ACTION_CANCEL:
                     mPrivateFlags &= ~PRESSED;
                     refreshDrawableState();
                     removeTapCallback();
                     break;

                 case MotionEvent.ACTION_MOVE:
                     final int x = (int) event.getX();
                     final int y = (int) event.getY();

                     // Be lenient about moving outside of buttons
                     int slop = mTouchSlop;
                     if ((x < 0 - slop) || (x >= getWidth() + slop) ||
                             (y < 0 - slop) || (y >= getHeight() + slop)) {
                         // Outside button
                         removeTapCallback();
                         if ((mPrivateFlags & PRESSED) != 0) {
                             // Remove any future long press/tap checks
                             removeLongPressCallback();

                             // Need to switch from pressed to not pressed
                             mPrivateFlags &= ~PRESSED;
                             refreshDrawableState();
                         }
                     }
                     break;
             }
             return true;
         }

         return false;
     }

ViewGroup.java

     /**
      * {@inheritDoc}
      */
     @Override
     public boolean dispatchTouchEvent(MotionEvent ev) {
         if (!onFilterTouchEventForSecurity(ev)) {
             return false;
         }

         final int action = ev.getAction();
         final float xf = ev.getX();
         final float yf = ev.getY();
         final float scrolledXFloat = xf + mScrollX;
         final float scrolledYFloat = yf + mScrollY;
         final Rect frame = mTempRect;

         boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;

         if (action == MotionEvent.ACTION_DOWN) {
             if (mMotionTarget != null) {
                 // this is weird, we got a pen down, but we thought it was
                 // already down!
                 // XXX: We should probably send an ACTION_UP to the current
                 // target.
                 mMotionTarget = null;
             }
             // If we're disallowing intercept or if we're allowing and we didn't
             // intercept
             if (disallowIntercept || !onInterceptTouchEvent(ev)) {
                 // reset this event's action (just to protect ourselves)
                 ev.setAction(MotionEvent.ACTION_DOWN);
                 // We know we want to dispatch the event down, find a child
                 // who can handle it, start with the front-most child.
                 final int scrolledXInt = (int) scrolledXFloat;
                 final int scrolledYInt = (int) scrolledYFloat;
                 final View[] children = mChildren;
                 final int count = mChildrenCount;

                 for (int i = count - 1; i >= 0; i--) {
                     final View child = children[i];
                     if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE
                             || child.getAnimation() != null) {
                         child.getHitRect(frame);
                         if (frame.contains(scrolledXInt, scrolledYInt)) {
                             // offset the event to the view's coordinate system
                             final float xc = scrolledXFloat - child.mLeft;
                             final float yc = scrolledYFloat - child.mTop;
                             ev.setLocation(xc, yc);
                             child.mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;
                             if (child.dispatchTouchEvent(ev))  {
                                 // Event handled, we have a target now.
                                 mMotionTarget = child;
                                 return true;
                             }
                             // The event didn't get handled, try the next view.
                             // Don't reset the event's location, it's not
                             // necessary here.
                         }
                     }
                 }
             }
         }

         boolean isUpOrCancel = (action == MotionEvent.ACTION_UP) ||
                 (action == MotionEvent.ACTION_CANCEL);

         if (isUpOrCancel) {
             // Note, we've already copied the previous state to our local
             // variable, so this takes effect on the next event
             mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
         }

         // The event wasn't an ACTION_DOWN, dispatch it to our target if
         // we have one.
         final View target = mMotionTarget;
         if (target == null) {
             // We don't have a target, this means we're handling the
             // event as a regular view.
             ev.setLocation(xf, yf);
             if ((mPrivateFlags & CANCEL_NEXT_UP_EVENT) != 0) {
                 ev.setAction(MotionEvent.ACTION_CANCEL);
                 mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;
             }
             return super.dispatchTouchEvent(ev);
         }

         // if have a target, see if we're allowed to and want to intercept its
         // events
         if (!disallowIntercept && onInterceptTouchEvent(ev)) {
             final float xc = scrolledXFloat - (float) target.mLeft;
             final float yc = scrolledYFloat - (float) target.mTop;
             mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;
             ev.setAction(MotionEvent.ACTION_CANCEL);
             ev.setLocation(xc, yc);
             if (!target.dispatchTouchEvent(ev)) {
                 // target didn't handle ACTION_CANCEL. not much we can do
                 // but they should have.
             }
             // clear the target
             mMotionTarget = null;
             // Don't dispatch this event to our own view, because we already
             // saw it when intercepting; we just want to give the following
             // event to the normal onTouchEvent().
             return true;
         }

         if (isUpOrCancel) {
             mMotionTarget = null;
         }

         // finally offset the event to the target's coordinate system and
         // dispatch the event.
         final float xc = scrolledXFloat - (float) target.mLeft;
         final float yc = scrolledYFloat - (float) target.mTop;
         ev.setLocation(xc, yc);

         if ((target.mPrivateFlags & CANCEL_NEXT_UP_EVENT) != 0) {
             ev.setAction(MotionEvent.ACTION_CANCEL);
             target.mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;
             mMotionTarget = null;
         }

         return target.dispatchTouchEvent(ev);
     }