Touch事件分发源码解析

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

以下源码基于Gingerbread 2.3.7

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

1、先看ViewGroup的dispatchOnTouchEvent(MotionEvent e)的源码

1.1 主要是获取一些坐标值，留备后用

     @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;

1.2 先处理DOWN事件

         //TODO 1、判断是不是子View不允许老子拦截Touch事件
         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
             //TODO 2、如果子View不允许，或者老子自己不想拦截，则进入这里
             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;
                 //TODO 3、根据用户落指的坐标，找到应该响应该Touch事件的子View或者子ViewGroup
                 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);
                         //TODO 4、很明显，根据范围来判断的
                         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;
                             //TODO 5、找到子View，将事件交给它，如果它愿意消费DOWN事件，则记录下来这个龟儿子，并返回
                             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.
                         }
                     }
                 }
             }
         }

看见上面5条注释了吧，够用了

1.3 没找到子View、子View不愿消费(注释5)、或者不是DOWN事件，如下

         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.
12         // TODO 1、如果是没有子View，不管是DOWN还是其他事件，都交给自己来处理，包括后续的MOVE、UP事件。
13         //      因为这个方法有点类似递归调用，所以如果自己也不想处理，那么父类会分发给自己
         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;
             }
             // TODO 2、调用View的dispatchTouchEvent，会调用到自己的onTouchEvent()方法
             return super.dispatchTouchEvent(ev);
         }

这段代码就一个意思，不管啥事件，没有子View，老子亲自处理~

1.4 找到子View，继续往下走

 1         // TODO 1、找到子View，子View让老子拦截，或者老子自己想拦截，给龟孙一个CANCEL，
 2         //      并告诉父ViewGroup，老子要了，而且将mMotionTarget置为null，这样后续事件直接走上面的判断，直接找老子处理
         // 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;
         }

         // TODO 2、如果是UP、CANCEL事件，则清空
         if (isUpOrCancel) {
             mMotionTarget = null;
         }

这段代码，龟孙之前说的好好的， 要自己消费事件，突然又不想了。或者老子突然想拦截了，那么老子自己拦截，自己处理

1.5 没有幺蛾子了，交给龟孙自己处理

         // 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;
         }

         // TODO 1、不管前面这几行了，交给龟孙去处理
         return target.dispatchTouchEvent(ev);

ViewGroup没有重写View的onTouchEvent()方法，onInterceptTouchEvent()返回false，默认不拦截

2、 View的相关方法

2.1 dispatchTouchEvent()方法

就一点点，调用自己的onTouchEvent()方法，并以onTouchEvent的返回值为返回值

     /**
      * Pass the touch screen motion event down to the target view, or this
      * view if it is the target.
      *
      * @param event The motion event to be dispatched.
      * @return True if the event was handled by the view, false otherwise.
      */
     public boolean dispatchTouchEvent(MotionEvent event) {
         if (!onFilterTouchEventForSecurity(event)) {
             return false;
         }

         if (mOnTouchListener != null && (mViewFlags & ENABLED_MASK) == ENABLED &&
                 mOnTouchListener.onTouch(this, event)) {
             return true;
         }
         return onTouchEvent(event);
     }

2.2 onTouchEvent()方法

这个方法比较复杂，不可点击的时候返回false，说明自己不处理。可点击的时候，根据不同的事件类型进行处理

     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;
     }