android事件分发

1). android对事件分发的顺序为：Activity--->PhoneWindow--->DecorView--->yourView;

2). android控件对事件处理的优先级：onTouch--->onTouchEvent--->onClick

　　Android既然可以对事件进行拦截，肯定有某个方法对事件进行的传递或者分发，完成事件分发功能是由Activity的dispatchTouchEvent(MotionEvent ev)l来负责：

 public boolean dispatchTouchEvent(MotionEvent ev) {
         if (ev.getAction() == MotionEvent.ACTION_DOWN) {
 　　　　　　　//该方法为空方法，有用户交互的时候的回调，注意只在ACTION_DOWN中回调
             onUserInteraction();
         }

 　　　　　　//交由phoneWindow来处理
         if (getWindow().superDispatchTouchEvent(ev)) {
             return true;
         }

12　　　　　　//否则，调用Activity的onTouchEvent方法
         return onTouchEvent(ev);
     }

上述分发事件的方法dispatchTouchEvent, 先把事件分发给Window, 通过之前写的博客知道这个Window其实就是PhoneWindow，那就看看PhoneWindow方法都做了些什么：

    @Override
     public boolean superDispatchTouchEvent(MotionEvent event) {
         return mDecor.superDispatchTouchEvent(event);
     } 

很简单把此次事件直接很光棍的传给DecorView，这个View是所有视图的根视图，Activity界面中你能见到的各个View都是DecorView的子View。到此为止事件已经分发到View上面，View获取到事件后有两个选择：处理和不处理该事件，如果处理该事件那事件就不会继续向其子View分发下去；否则就继续分发下去交给子View对该事件做同样的判断，其实就是个递归的过程。下面是DecorView里面的调用方法

 public boolean superDispatchTouchEvent(MotionEvent event) {
         return super.dispatchTouchEvent(event);
 }

1）ViewGroup永远不会对拦截，因为他的onInterceptTouchEvent(MotionEvent ev)始终返回的是false！这样DecorView对到来的事件MotionEvent就只有分发到子View并由子View进行拦截和处理此事件了.

2)View包括直接继承于View的子类因为其父类View没有onInterceptTouchEvent方法，所以没法对事件进行拦截，如果这种View获取到了事件，那么就会执行onTouchEvent方法（当然这也是有条件的，这个前提条件在对下面onTouch方法作用的时候会有说明）。

A) View类对事件的处理：

比如Button的直接父类TextVew的父类为View，那么当Button获取事件的时候其执行分发和处理的时候调用dispatchTouchEvent,就先分析一下View的这个方法都做了什么以供博客后面的篇幅用：

 public boolean dispatchTouchEvent(MotionEvent event) {
         // If the event should be handled by accessibility focus first.
         if (event.isTargetAccessibilityFocus()) {
             // We don't have focus or no virtual descendant has it, do not handle the event.
             if (!isAccessibilityFocusedViewOrHost()) {
                 return false;
             }
             // We have focus and got the event, then use normal event dispatch.
             event.setTargetAccessibilityFocus(false);
         }

         boolean result = false;

         if (mInputEventConsistencyVerifier != null) {
             mInputEventConsistencyVerifier.onTouchEvent(event, 0);
         }

         final int actionMasked = event.getActionMasked();
         if (actionMasked == MotionEvent.ACTION_DOWN) {
             // Defensive cleanup for new gesture
             stopNestedScroll();
         }

         if (onFilterTouchEventForSecurity(event)) {
             if ((mViewFlags & ENABLED_MASK) == ENABLED && handleScrollBarDragging(event)) {
                 result = true;
             }
             //noinspection SimplifiableIfStatement
             ListenerInfo li = mListenerInfo;
             if (li != null && li.mOnTouchListener != null
                     && (mViewFlags & ENABLED_MASK) == ENABLED
                     && li.mOnTouchListener.onTouch(this, event)) {
　　　　　　　　　　　　//如果这里返回true的话，那么也表明此次事件被处理了
                 result = true;
             }

             if (!result && onTouchEvent(event)) {
                 result = true;
             }
         }

         if (!result && mInputEventConsistencyVerifier != null) {
             mInputEventConsistencyVerifier.onUnhandledEvent(event, 0);
         }

         // Clean up after nested scrolls if this is the end of a gesture;
         // also cancel it if we tried an ACTION_DOWN but we didn't want the rest
         // of the gesture.
         if (actionMasked == MotionEvent.ACTION_UP ||
                 actionMasked == MotionEvent.ACTION_CANCEL ||
                 (actionMasked == MotionEvent.ACTION_DOWN && !result)) {
             stopNestedScroll();
         }

         return result;
     }

通过上面可以知道onTouchListener的onTouch方法优先于onTouchEvent执行，这个onTouch是否能实行取决于你的View有没有调用setOnTouchListener方法设置OnTouchListener。如果onTouch方法返回的true，那么View的dispatchTouchEvent方法就返回true而结束执行，onTouchEvent方法就不会得到执行；因为onClick方法通过下面的分析也知道是在onTouchEvent方法中执行的，所以此时onClick方法也不会执行了。

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

         final boolean clickable = ((viewFlags & CLICKABLE) == CLICKABLE
                 || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
                 || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE;

         if ((viewFlags & ENABLED_MASK) == DISABLED) {
             if (action == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
                 setPressed(false);
             }
             mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
             // A disabled view that is clickable still consumes the touch
             // events, it just doesn't respond to them.
             return clickable;
         }
         if (mTouchDelegate != null) {
             if (mTouchDelegate.onTouchEvent(event)) {
                 return true;
             }
         }

         if (clickable || (viewFlags & TOOLTIP) == TOOLTIP) {
             switch (action) {
                 case MotionEvent.ACTION_UP:
                     mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
                     if ((viewFlags & TOOLTIP) == TOOLTIP) {
                         handleTooltipUp();
                     }
                     if (!clickable) {
                         removeTapCallback();
                         removeLongPressCallback();
                         mInContextButtonPress = false;
                         mHasPerformedLongPress = false;
                         mIgnoreNextUpEvent = false;
                         break;
                     }
                     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 && !mIgnoreNextUpEvent) {
                             // 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();
 72                                 }
                             }
                         }

                         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();
                     }
                     mIgnoreNextUpEvent = false;
                     break;

                 case MotionEvent.ACTION_DOWN:
                     if (event.getSource() == InputDevice.SOURCE_TOUCHSCREEN) {
                         mPrivateFlags3 |= PFLAG3_FINGER_DOWN;
                     }
                     mHasPerformedLongPress = false;

                     if (!clickable) {
                         checkForLongClick(0, x, y);
                         break;
                     }

                     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, x, y);
                     }
                     break;

                 case MotionEvent.ACTION_CANCEL:
                     if (clickable) {
                         setPressed(false);
                     }
                     removeTapCallback();
                     removeLongPressCallback();
                     mInContextButtonPress = false;
                     mHasPerformedLongPress = false;
                     mIgnoreNextUpEvent = false;
                     mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
                     break;

                 case MotionEvent.ACTION_MOVE:
                     if (clickable) {
                         drawableHotspotChanged(x, y);
                     }

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

             return true;
         }

         return false;
     }

 public boolean performClick() {
         final boolean result;
         final ListenerInfo li = mListenerInfo;
         if (li != null && li.mOnClickListener != null) {
             playSoundEffect(SoundEffectConstants.CLICK);
             li.mOnClickListener.onClick(this);
             result = true;
         } else {
             result = false;
         }

         sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);

         notifyEnterOrExitForAutoFillIfNeeded(true);

         return result;
     }

以上简单的说下onTouch和onTouchEvent和onClick的执行顺序以及onTouch的返回值对onTouchEvent和onClick的影响。

到此为止，关于View对事件的分发和处理算是简单的分析完毕，也可以得到一个结论：如果View类的的dispatchTouchEvent返回true的话，就表明有某个View对该起事件负责（进行处理）。

通过View类的onTouchEvent方法我们也很容易得到如下两个结论，该结论主要有上方代码的如下语句得来的

　　if (((viewFlags & CLICKABLE) == CLICKABLE ||  (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE))

这句代码是说如果这个view是可点击的（clickable=true或者longClickable=true)，那么这样的View最终都会消耗当前事件而让View的dispatchTouchEvent返回true，这样的View就是下面将要说到的消耗事件的target对象！否则，即如果一个View既不是clickable也不是longClickable的话，那么这个View不会消耗该事件。

B)ViewGroup类对事件分发的处理：

下面继续分析在ViewGroup的dispatchTouchEvent方法，该方法中开始有这么一段：

 @Override
     public boolean dispatchTouchEvent(MotionEvent ev) {
         if (mInputEventConsistencyVerifier != null) {
             mInputEventConsistencyVerifier.onTouchEvent(ev, 1);
         }

         // If the event targets the accessibility focused view and this is it, start
         // normal event dispatch. Maybe a descendant is what will handle the click.
         if (ev.isTargetAccessibilityFocus() && isAccessibilityFocusedViewOrHost()) {
             ev.setTargetAccessibilityFocus(false);
         }

         boolean handled = false;
         if (onFilterTouchEventForSecurity(ev)) {
             final int action = ev.getAction();
             final int actionMasked = action & MotionEvent.ACTION_MASK;

             // Handle an initial down.
             if (actionMasked == MotionEvent.ACTION_DOWN) {
                 // Throw away all previous state when starting a new touch gesture.
                 // The framework may have dropped the up or cancel event for the previous gesture
                 // due to an app switch, ANR, or some other state change.
                 cancelAndClearTouchTargets(ev);
                 resetTouchState();
             }

             // Check for interception.
             final boolean intercepted;
             if (actionMasked == MotionEvent.ACTION_DOWN
                     || mFirstTouchTarget != null) {
                 final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
                 if (!disallowIntercept) {
                     intercepted = onInterceptTouchEvent(ev);
                     ev.setAction(action); // restore action in case it was changed
                 } else {
                     intercepted = false;
                 }
             } else {
                 // There are no touch targets and this action is not an initial down
                 // so this view group continues to intercept touches.
                 intercepted = true;
             }
 43 

               //如果不允许当前View拦截该事件或者没有拦截该事件，就让当前View的子类去分发和拦截，递归过程

             // If intercepted, start normal event dispatch. Also if there is already
             // a view that is handling the gesture, do normal event dispatch.
             if (intercepted || mFirstTouchTarget != null) {
                 ev.setTargetAccessibilityFocus(false);
             }

             // Check for cancelation.
             final boolean canceled = resetCancelNextUpFlag(this)
                     || actionMasked == MotionEvent.ACTION_CANCEL;

             // Update list of touch targets for pointer down, if needed.
             final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0;
             TouchTarget newTouchTarget = null;
             boolean alreadyDispatchedToNewTouchTarget = false;
             if (!canceled && !intercepted) {

                 // If the event is targeting accessiiblity focus we give it to the
                 // view that has accessibility focus and if it does not handle it
                 // we clear the flag and dispatch the event to all children as usual.
                 // We are looking up the accessibility focused host to avoid keeping
                 // state since these events are very rare.
                 View childWithAccessibilityFocus = ev.isTargetAccessibilityFocus()
                         ? findChildWithAccessibilityFocus() : null;

                 if (actionMasked == MotionEvent.ACTION_DOWN
                         || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
                         || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
                     final int actionIndex = ev.getActionIndex(); // always 0 for down
                     final int idBitsToAssign = split ? 1 << ev.getPointerId(actionIndex)
                             : TouchTarget.ALL_POINTER_IDS;

                     // Clean up earlier touch targets for this pointer id in case they
                     // have become out of sync.
                     removePointersFromTouchTargets(idBitsToAssign);

                     final int childrenCount = mChildrenCount;
                     if (newTouchTarget == null && childrenCount != 0) {
                         final float x = ev.getX(actionIndex);
                         final float y = ev.getY(actionIndex);
                         // Find a child that can receive the event.
                         // Scan children from front to back.
                         final ArrayList<View> preorderedList = buildTouchDispatchChildList();
                         final boolean customOrder = preorderedList == null
                                 && isChildrenDrawingOrderEnabled();
                         final View[] children = mChildren;
                         for (int i = childrenCount - 1; i >= 0; i--) {
                             final int childIndex = getAndVerifyPreorderedIndex(
                                     childrenCount, i, customOrder);
                             final View child = getAndVerifyPreorderedView(
                                     preorderedList, children, childIndex);

                             // If there is a view that has accessibility focus we want it
                             // to get the event first and if not handled we will perform a
                             // normal dispatch. We may do a double iteration but this is
                             // safer given the timeframe.
                             if (childWithAccessibilityFocus != null) {
                                 if (childWithAccessibilityFocus != child) {
                                     continue;
                                 }
                                 childWithAccessibilityFocus = null;
                                 i = childrenCount - 1;
                             }

                             if (!canViewReceivePointerEvents(child)
                                     || !isTransformedTouchPointInView(x, y, child, null)) {
                                 ev.setTargetAccessibilityFocus(false);
                                 continue;
                             }

                             newTouchTarget = getTouchTarget(child);
                             if (newTouchTarget != null) {
                                 // Child is already receiving touch within its bounds.
                                 // Give it the new pointer in addition to the ones it is handling.
                                 newTouchTarget.pointerIdBits |= idBitsToAssign;
                                 break;
                             }

                             resetCancelNextUpFlag(child);
                             if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
                                 // Child wants to receive touch within its bounds.
                                 mLastTouchDownTime = ev.getDownTime();
                                 if (preorderedList != null) {
                                     // childIndex points into presorted list, find original index
                                     for (int j = 0; j < childrenCount; j++) {
                                         if (children[childIndex] == mChildren[j]) {
                                             mLastTouchDownIndex = j;
                                             break;
                                         }
                                     }
                                 } else {
                                     mLastTouchDownIndex = childIndex;
                                 }
                                 mLastTouchDownX = ev.getX();
                                 mLastTouchDownY = ev.getY();
                                 newTouchTarget = addTouchTarget(child, idBitsToAssign);
                                 alreadyDispatchedToNewTouchTarget = true;
                                 break;
                             }

                             // The accessibility focus didn't handle the event, so clear
                             // the flag and do a normal dispatch to all children.
                             ev.setTargetAccessibilityFocus(false);
                         }
                         if (preorderedList != null) preorderedList.clear();
                     }

                     if (newTouchTarget == null && mFirstTouchTarget != null) {
                         // Did not find a child to receive the event.
                         // Assign the pointer to the least recently added target.
                         newTouchTarget = mFirstTouchTarget;
                         while (newTouchTarget.next != null) {
                             newTouchTarget = newTouchTarget.next;
                         }
                         newTouchTarget.pointerIdBits |= idBitsToAssign;
                     }
                 }
             }

             // Dispatch to touch targets.
             if (mFirstTouchTarget == null) {
                 // No touch targets so treat this as an ordinary view.
                 handled = dispatchTransformedTouchEvent(ev, canceled, null,
                         TouchTarget.ALL_POINTER_IDS);
             } else {
                 // Dispatch to touch targets, excluding the new touch target if we already
                 // dispatched to it.  Cancel touch targets if necessary.
                 TouchTarget predecessor = null;
                 TouchTarget target = mFirstTouchTarget;
                 while (target != null) {
                     final TouchTarget next = target.next;
                     if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
                         handled = true;
                     } else {
                         final boolean cancelChild = resetCancelNextUpFlag(target.child)
                                 || intercepted;
                         if (dispatchTransformedTouchEvent(ev, cancelChild,
180                                 target.child, target.pointerIdBits)) {
                             handled = true;
                         }
                         if (cancelChild) {
                             if (predecessor == null) {
                                 mFirstTouchTarget = next;
                             } else {
                                 predecessor.next = next;
                             }
                             target.recycle();
                             target = next;
                             continue;
                         }
                     }
                     predecessor = target;
                     target = next;
                 }
             }

             // Update list of touch targets for pointer up or cancel, if needed.
             if (canceled
                     || actionMasked == MotionEvent.ACTION_UP
                     || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
                 resetTouchState();
             } else if (split && actionMasked == MotionEvent.ACTION_POINTER_UP) {
                 final int actionIndex = ev.getActionIndex();
                 final int idBitsToRemove = 1 << ev.getPointerId(actionIndex);
                 removePointersFromTouchTargets(idBitsToRemove);
             }
         }

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

1. //如果不允许当前View拦截该事件或者没有拦截该事件
2. //就让当前View的子类去分发和拦截，递归过程
3. if (disallowIntercept || !onInterceptTouchEvent(ev)) {
4. // reset this event's action (just to protect ourselves)
5. ev.setAction(MotionEvent.ACTION_DOWN);
6. // We know we want to dispatch the event down, find a child
7. // who can handle it, start with the front-most child.
8. final int scrolledXInt = (int) scrolledXFloat;
9. final int scrolledYInt = (int) scrolledYFloat;
10. final View[] children = mChildren;
11. final int count = mChildrenCount;
12. //遍历ViewGroup的子View，在此为遍历DecorView的子View
13. for (int i = count - 1; i >= 0; i--) {
14. final View child = children[i];
15. if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE
16. || child.getAnimation() != null) {
17. child.getHitRect(frame);
18. if (frame.contains(scrolledXInt, scrolledYInt)) {
19. .........
20. //交给子View的dispatchTouchEvent进行对此事件的分发拦截。
21. //如果返回true说明child处理了此事件，递归调用
22. if (child.dispatchTouchEvent(ev))  {
23. // Event handled, we have a target now.
24. //说明已经找到处理此次事件的子View，用mMotionTarget记录
25. mMotionTarget = child;
26. //找到目标，此次down事件结束。
27. return true;
28. }
29. // The event didn't get handled, try the next view.
30. // Don't reset the event's location, it's not
31. // necessary here.
32. }
33. }
34. }
35. }
36. }

上诉代码的for循环很详细的说明了View对事件进行分发的过程，当然for循环之所以能得以执行使用两个前提条件的：

1）事件为ACTION_DOWN事件，在Down事件中才去进行分拦截发事件并寻找消耗事件的target View，！

2）disallowIntercept   ，这个属性可通过requestDisallowInterceptTouchEvent(boolean disallowIntercept  )来设置，通过观察期具体实现可以知道该方法的作用就是子View干预父View的事件分发过程，当然对于ACTION_DOWN事件子类是不能干预父类的，因为if条件为(disallowIntercept ||!onInterceptTouchEvent(ev))为或操作；或者当前的View没有拦截成功该事件。如果disallowIntercept 为true，那么就说明当前ViewGroup的某个子View不允许其父View对当前事件进行拦截，反之就是某个子View允许其父View对当前事件进行拦截，当然这并不等于父View一定能拦截成功当前事件，如果父View此时拦截不成功（即父View的onInterceptTouchEvent返回false）,那么仍然交给子view进行分发拦截逻辑

:

1. @Override
2. public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {
3. //省略部分代码
4. // Pass it up to our parent
5. if (mParent != null) {

1. //当前View干预其父View对后续事件的分发
2. mParent.requestDisallowInterceptTouchEvent(disallowIntercept);
3. }

如果当前的ViewGroup（为了方便再次称之为ParentView)允许对此次事件进行拦截或者ParentView没有对此事件拦截成功(ParentView的onInterceptTouchEvent返回false）简而言之就是如果ParentView不拦截这处理该事件，就把该事件分发到ParentView的若干子类中去，循环遍历它的子类，来寻找是否有某个子类对处理该事件。可以参照上面的伪代码和流程图来理解之。

如果找到了这样的View，就对该View用一个变量mMotionTarget进行标识。如果在当前的ParentView的子View中没有找到处理该事件的子View会怎么办呢？在ViewGroup里面的dispatchTouchEvent在上面的for循环之后有如下代码：

1. //如果没有找到处理事件的View
2. if (target == null) {
3. // We don't have a target, this means we're handling the
4. // event as a regular view.
5. ev.setLocation(xf, yf);
6. if ((mPrivateFlags & CANCEL_NEXT_UP_EVENT) != 0) {
7. ev.setAction(MotionEvent.ACTION_CANCEL);
8. mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;
9. }
10. //ViewGroup调用View的事件分发方法，之所以能进入当前的View是因为当前的View的父View没有拦截成功此事件。
11. return super.dispatchTouchEvent(ev);
12. }

从上面的代码可以看出：如果在ParentView的子类中没有找到能处理问题的那个view,就调用parentView的父View的dispatchTouchEvent方法。我们应该知道之所以parentView能分发和拦截事件，前提是它的父类本来没有拦截事件的能力或如本身拦截事件的方法返回了false，所以沿着view树最终会调用的View类的dispatchTouchEvent,那么又回归到本篇博客的A）View类对事件的处理那一部分了。

注意前面讲的for循环查找的重大前提是：在down事件中，且我们要明白在手指接触屏幕到手指离开屏幕会产生一系列事件，一个down(ACTION_DOWN)事件，数个move(ACTION_MOVE)事件,和一个 UP事件。寻找到目标事件之后，之后的一些列事件都交给这个target消耗，比如move事件等。当然我们是可以通过让target调用requestDisallowInterceptTouchEvent方法来干预父类关于事件分发过程。或者在在适当的情况下让target父View的onInterceptEvent返回true或者false，来解决滑动问题事件的冲突问题：

1. if (!disallowIntercept && onInterceptTouchEvent(ev)) {
2. final float xc = scrolledXFloat - (float) target.mLeft;
3. final float yc = scrolledYFloat - (float) target.mTop;
4. mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;
5. ev.setAction(MotionEvent.ACTION_CANCEL);
6. ev.setLocation(xc, yc);
7. if (!target.dispatchTouchEvent(ev)) {
8. // target didn't handle ACTION_CANCEL. not much we can do
9. // but they should have.
10. }
11. // clear the target
12. mMotionTarget = null;
13. // Don't dispatch this event to our own view, because we already
14. // saw it when intercepting; we just want to give the following
15. // event to the normal onTouchEvent().
16. return true;
17. }

最后某个View（target）如果开始处理事件，在手指离开屏幕之前的什么move事件啦，up事件啦都会交给这个View(target)来处理，因为在ViewGroup的diapatchTouchEvent代码的最后会执行:

1. //把事件交给目标视图来处理
2. return target.dispatchTouchEvent(ev);

并且本View的onInterceptTouchEvent是不会调用了。也就是说如果有一个view处理该事件，那么down之后的一系列move事件和up事件都自动交给该view处理，因为该view已经是targetView 了，所以不会对后续事件序列或者事件集合进行拦截操作，只会调用dispatchTouchEvent和onTunchEvent来处理该事件！而onInterceptTouchEvent事件不会调用。简单的举个例子，如图：

假设上图中由D进行事件的处理，也就是说D的onInterceptTouchEvent和onTouchEvent均返回true,D的父View A ,B ,C的这两个方法都返回false，那么在这个布局中D就是上面所说的 target.在首次的Down事件中会执行查找target的操作：(注：下图中分发事件指的是执行了dispatchTouchEvent,拦截事件指的是onInterceptTouchEvent,消耗事件为onTouchEvent方法）

1. @Override
2. public boolean dispatchTouchEvent(MotionEvent ev) {
3. Log.e(null, "B--分发事件");
4. return super.dispatchTouchEvent(ev);
5. }
6. @Override
7. public boolean onInterceptTouchEvent(MotionEvent ev) {
8. Log.e(null, "B--拦截事件");
9. return super.onInterceptTouchEvent(ev);
10. }
11. @Override
12. public boolean onTouchEvent(MotionEvent event) {
13. Log.e(null, "B--处理事件");
14. return super.onTouchEvent(event);
15. }

注意D此时的打印，D为此事件的target View,拦截和处理了该次down事件，那么如果此时手指继续移动的话将会打印如下的Log：

注意上图是手指滑动后打印的log，可以发现D只负责分发和处理该事件，而没有像down事件那样进行拦截，所以上面的log打印可以清晰的说明上面的结论：

1）targetView只会对一个事件序列拦截一次，即只拦截down事件或者说由down事件负责查找targetView

2)一旦targetView被找到，down事件之后的一些列事件都由target View负责消耗，而target并不对后续事件进行再次拦截

3)当然在down事件之后的后续事件还是会先由父View进行分发拦截，也即是说文章开头所说的事件序列中把每一个事件单独来看的话，都会由父View来进行拦截和分发的，只不过到后续事件到传到target的时候直接进行处理而少了拦截的过程而已，因为在父类查找target的时候已经拦截过一次，这点很重要，也是解决滑动冲突的关键点，比如滑动的时候根据合适的时机来判断是否让父View进行事件拦截和处理。只不过省下了对targetView的寻找，因为在down事件中已经寻找到了target并有mMotionTarget变量进行了标识，（通过上面的对ViewGroup的dispatchTouchEvent源码的解析就可以表明出来）