概述

本文主要分享Android常见的事件冲突处理，处理方式有两种：

• 外部拦截：父容器处理冲突
• 内部拦截：子控件处理冲突

在介绍这两种处理方法之前，我们必须先了解两件事情：

• 事件在控件中是如何传递的
• 事件冲突产生的根本原因

事件在控件中是如何传递的

先来看一张事件分发的大致流程图：

通过流程图可知，事件的分发是从Activity的dispatchTouchEvent开始传递的，然后调用PhoneWindow的superDispatchTouchEvent，再调用DecorView的superDispatchTouchEvent，再调用到ViewGroup的dispatchTouchEvent方法，ViewGroup要先走分发流程，再走处理流程，而View只能走处理流程。下面便从ViewGroup的dispatchTouchEvent方法分析事件的传递流程。

DOWN事件

事件的分发是从Down事件开始的，Down事件只有一个，ViewGroup的dispatchTouchEvent方法对Down事件的处理方式有以下两种：

• 拦截事件
• 不拦截事件

接下来结合源码分析这两种处理方式有什么区别。

拦截事件

跟踪ViewGroup中dispatchTouchEvent方法针对ACTION_DOWN处理的关键代码：

    if (actionMasked == MotionEvent.ACTION_DOWN) {
        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;
    }
    ...
    if (mFirstTouchTarget == null) {
        // No touch targets so treat this as an ordinary view.
        handled = dispatchTransformedTouchEvent(ev, canceled, null,
                TouchTarget.ALL_POINTER_IDS);
    }

上述中有一句关键代码：
final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
disallowIntercept表示是否不允许父控件拦截，由于在MotionEvent.ACTION_DOWN中调用了resetTouchState方法：

private void resetTouchState() {
    clearTouchTargets();
    resetCancelNextUpFlag(this);
    mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
    mNestedScrollAxes = SCROLL_AXIS_NONE;
}

所以在MotionEvent.ACTION_DOWN时disallowIntercept的值为fasle,此时会调用ViewGroup的onInterceptTouchEvent，因为拦截了Down事件，所以onInterceptTouchEvent返回true,此时事件停止向子控件分发，交给自身处理即mFirstTouchTarget==null,然后会调用到以下的关键代码：
handled = dispatchTransformedTouchEvent(ev, canceled, null, TouchTarget.ALL_POINTER_IDS)

跟踪dispatchTransformedTouchEvent方法的关键代码：

if (child == null) {
      handled = super.dispatchTouchEvent(transformedEvent);
  } else {
      final float offsetX = mScrollX - child.mLeft;
      final float offsetY = mScrollY - child.mTop;
      transformedEvent.offsetLocation(offsetX, offsetY);
      if (! child.hasIdentityMatrix()) {
          transformedEvent.transform(child.getInverseMatrix());
      }
  
      handled = child.dispatchTouchEvent(transformedEvent);
  }

由源码可知，由于child==null会调用到 super.dispatchTouchEvent方法，即调用到View的dispatchTouchEvent方法，关键代码如下：

 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)) {
            result = true;
        }

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

由源码可知，View的dispatchTouchEvent中会根据mOnTouchListener.onTouch或onTouchEvent是否返回true，来判断是否消费该事件。到这里拦截事件的基本流程就结束了。
这里补充一个小知识点，由于mOnTouchListener.onTouch是优先与onTouchEvent，所以当mOnTouchListener.onTouch返回true时，以下代码不会执行：

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

那如果此时控件同时设置了onClick事件便会失效，因为在onTouchEvent的ACTION_UP事件中调用了 performClick() 方法：

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

不拦截事件

ViewGroup的onInterceptTouchEvent返回false(默认返回false)时，此时会将事件分发给子控件处理，如果子控件都不处理则自己处理该事件，关键代码如下：

    boolean alreadyDispatchedToNewTouchTarget = false;
    if (!canceled && !intercepted) {
               
        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;
    
            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 (childWithAccessibilityFocus != null) {
                        if (childWithAccessibilityFocus != child) {
                            continue;
                        }
                        childWithAccessibilityFocus = null;
                        i = childrenCount - 1;
                    }
    
                    if (!child.canReceivePointerEvents()
                            || !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;
            }
        }
    }

遍历子控件集合时，会根据子控件的dispatchTransformedTouchEvent方法判断是否有子控件处理了事件，若有子控件处理，会执行如关键代码：

    newTouchTarget = addTouchTarget(child, idBitsToAssign);
    private TouchTarget addTouchTarget(@NonNull View child, int pointerIdBits) {
        final TouchTarget target = TouchTarget.obtain(child, pointerIdBits);
        target.next = mFirstTouchTarget;
        mFirstTouchTarget = target;
        return target;
    }

这里采用了链表来存储目标控件，此时mFirstTouchTarget不为空，那如果子控件都没有处理，是如何将事件再交给父控件处理呢？继续跟踪源码：

if (mFirstTouchTarget == null) {
        // No touch targets so treat this as an ordinary view.
        handled = dispatchTransformedTouchEvent(ev, canceled, null,
                TouchTarget.ALL_POINTER_IDS);
    } else {
        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,
                        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;
        }
    }

当没有子控件都没有处理事件时，mFirstTouchTarget=null,此时会调用ViewGroup的dispatchTransformedTouchEvent方法自己处理该事件，如果有子控件处理，会执行以下判断：

     if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
        handled = true;
    }

因为有子控件处理，此时alreadyDispatchedToNewTouchTarget = true、mFirstTouchTarget=newTouchTarget、 target.next=null即满足上述条件，while循环只会执行一次，到这里不拦截事件的基本流程就结束了。

MOVE事件

Move事件的传递也是通过以下两种方式进行分析：

• 不拦截Move事件传递
• 拦截Move事件传递

Move事件正常传递

父控件不拦截事件时，Move事件的传递也是通过dispatchTouchEvent方法传递给目标控件的，关键代码如下：

    boolean alreadyDispatchedToNewTouchTarget = false;
    View childWithAccessibilityFocus = ev.isTargetAccessibilityFocus()
                        ? findChildWithAccessibilityFocus() : null;

                if (actionMasked == MotionEvent.ACTION_DOWN
                        || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
                        || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
                        .....
                }//此时是Move事件，不会执行这段代码
    }
    .....
    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,
                    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;
    }

这里需要注意由于此时alreadyDispatchedToNewTouchTarget=false,所以会走else分支，会执行以下关键代码：

 if (dispatchTransformedTouchEvent(ev, cancelChild,
        target.child, target.pointerIdBits)) {
    handled = true;
}

将Move事件交给对应的目标控件(Down事件保存的Target)，到这里正常的Move事件就执行完了。

拦截Move事件传递

分析拦截事件时，先来看一段代码：

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

通过上面Down事件分析可知，由于Down事件做了重置操作，所以disallowIntercept的值为false,即if分支的代码一定会执行，此时拦截子控件的Move事件，会执行以下关键代码：

    final boolean cancelChild = resetCancelNextUpFlag(target.child)
                                    || intercepted;
    if (dispatchTransformedTouchEvent(ev, cancelChild,
            target.child, target.pointerIdBits)) {
        handled = true;
    }

    private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
            View child, int desiredPointerIdBits) {
        final boolean handled;

        // Canceling motions is a special case.  We don't need to perform any transformations
        // or filtering.  The important part is the action, not the contents.
        final int oldAction = event.getAction();
        if (cancel || oldAction == MotionEvent.ACTION_CANCEL) {
            event.setAction(MotionEvent.ACTION_CANCEL);
            if (child == null) {
                handled = super.dispatchTouchEvent(event);
            } else {
                handled = child.dispatchTouchEvent(event);
            }
            event.setAction(oldAction);
            return handled;
        }
}

因为拦截了move事件，此时intercepted=true, cancelChild=true,此时会设置子控件的Action为MotionEvent.ACTION_CANCEL，取消子控件的事件，并且注意以下代码：

 final boolean cancelChild = resetCancelNextUpFlag(target.child)
                                    || intercepted;
    if (dispatchTransformedTouchEvent(ev, cancelChild,
            target.child, target.pointerIdBits)) {
        handled = true;
    }
    if (cancelChild) {
        if (predecessor == null) {
            mFirstTouchTarget = next;
        } else {
            predecessor.next = next;
        }
        target.recycle();
        target = next;
        continue;
    }

由于此时cancelChild=true, mFirstTouchTarget被设置成null,本次Move事件就结束了，注意ViewGroup是在下一Move事件才能够接收到事件，因为下一次Move事件会重新走dispatchTouchEvent方法，关注以下代码：

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

由于此时是Move事件并mFirstTouchTarget=null，所以此时走else分支intercepted = true，Move事件会交给自身处理，关联代码：

if (mFirstTouchTarget == null) {
    // No touch targets so treat this as an ordinary view.
    handled = dispatchTransformedTouchEvent(ev, canceled, null,
            TouchTarget.ALL_POINTER_IDS);
}

小结一下，当父控件拦截Move事件时，第一次会将子控件的事件类型设置为MotionEvent.ACTION_CANCEL并将mFirstTouchTarget赋值为null,此时第一次Move事件结束（由于子控件的dispatchTransformedTouchEvent返回true),第二次以后的Move事件才会传递到父控件。

UP与Cancel事件

一次完整的事件，首先有Down事件开始，中间有多个Move事件，最后由Up/Cancel事件结束，Up事件是正常结束，而Cancel事件是被父控件拦截后产生的

事件分发完整流程图

为了进一步理解上述的源码分析流程，下面提供一张完整的事件分发流程图：

896629-20171007002836974-997068426.png

事件冲突处理

通过前面的铺垫，可以知道事件冲突只能在Move事件中处理，可以通过外部拦截和内部拦截处理事件冲突，这里以SwipeRefreshLayout嵌套ViewPager为例：

外部拦截

根据父控件的滑动逻辑在onInterceptTouchEvent方法中返回true/false,核心代码：

public class CustomSRL2 extends SwipeRefreshLayout {

    //外部拦截成员变量
    private float startX;
    private float startY;
    //ViewPager是否滚动
    boolean mIsVpMove = false;
    //触发移动事件的最小距离,如果小于这个距离就不触发移动控件，如Viewpager就是用这个距离来判断用户是否翻页
    private int mTouchSlop;

    public CustomSRL2(Context context) {
        this(context, null);
    }

    public CustomSRL2(Context context, AttributeSet attrs) {
        super(context, attrs);
        mTouchSlop = ViewConfiguration.get(context).getScaledTouchSlop();
    }

    //外部拦截
    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                startX = ev.getX();
                startY = ev.getY();
                mIsVpMove = false;
                break;
            case MotionEvent.ACTION_MOVE:
                //若此时ViewPager还在滑动，则返回false,不拦截
                if (mIsVpMove) {
                    return false;
                }
                float x = ev.getX();
                float y = ev.getY();
                float deltaX = Math.abs(x - startX);
                float deltaY = Math.abs(y - startY);
                if (deltaX > mTouchSlop && deltaX > deltaY) {
                    mIsVpMove = true;
                    return false;
                }
                break;
            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_CANCEL:
                mIsVpMove = false;
                break;
        }
        return super.onInterceptTouchEvent(ev);
    }
}

内部拦截

根据子控件的滑动逻辑调用父控的requestDisallowInterceptTouchEvent(true/false)方法通知父控件是否不拦截事件,核心代码：

public class CustomSRL2 extends SwipeRefreshLayout {

    public CustomSRL2(Context context) {
        super(context);
    }

    public CustomSRL2(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    //以下代码为内部拦截代码
    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        //在ACTION_DOWN事件返回false,不拦截事件，将事件交给子控件处理
        if(ev.getAction() == MotionEvent.ACTION_DOWN){
            super.onInterceptTouchEvent(ev);
            return false;
        }
        return true;//拦截事件
    }
}

public class CustomVPInner extends ViewPager {

    private float startX;
    private float startY;

    public CustomVPInner(Context context) {
        super(context);
    }

    public CustomVPInner(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    //内部拦截:使用ViewCompat.setNestedScrollingEnabled(this,true)，参考以下代码
    /**
     * public void requestDisallowInterceptTouchEvent(boolean b) {
     *         // if this is a List < L or another view that doesn't support nested
     *         // scrolling, ignore this request so that the vertical scroll event
     *         // isn't stolen
     *         if ((android.os.Build.VERSION.SDK_INT < 21 && mTarget instanceof AbsListView)
     *                 || (mTarget != null && !ViewCompat.isNestedScrollingEnabled(mTarget))) {
     *             // Nope.
     *         } else {
     *             super.requestDisallowInterceptTouchEvent(b);
     *         }
     *     }
     */
    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                startX = ev.getX();
                startY = ev.getY();
                ViewCompat.setNestedScrollingEnabled(this,true);
                getParent().requestDisallowInterceptTouchEvent(true);
                break;
            case MotionEvent.ACTION_MOVE:
                float x = ev.getX();
                float y = ev.getY();
                float deltaX = Math.abs(x - startX);
                float deltaY = Math.abs(y - startY);
                if (deltaX < deltaY) {
                    getParent().requestDisallowInterceptTouchEvent(false);
                }
                break;
        }

        //打印ViewPager是否消费了该事件，如果没有，事件还是会交给SwipeRefreshLayout处理
        boolean consume = super.dispatchTouchEvent(ev);
        Log.e("fmt","consume=" + consume);

        return super.dispatchTouchEvent(ev);
    }
}

完整代码实现

百度链接
密码:1cq9