Android事件分发详解

1.事件传递的流程是从外到内,即事件总是由父元素分发给子元素:Activity->ViewGroup-View，但是通过requestDisallowInterceptTouchEvent可以使子view要求父view不拦截事件

2.当一个事件发生时，首先由Activity接收，然后activity会交由他的window处理，window的处理方式即是调用顶级容器DecorView(即setContentView所设置的View的父容器，是一个FramLayout)的dispatchTouchEvent方法，事件就进入了一个ViewGroup，开始按照事件分发机制去分发事件，若DecorView不处理，则activity会调用自身的onTouchEvent()方法消费事件

3.三个最主要方法:

• public boolean dispatchTouchEvent(MotionEvent ev)

  此方法是事件进入某个view和ViewGroup的入口，返回true表示在此层或者下层已经消费了事件，返回false则表示此层即下层都没处理

• public boolean onTouchEvent(MotionEvent event)

此方法是view和ViewGroup自身事件的处理方法，返回true表示自己处理事件，返回false表示自己不处理

• public boolean onInterceptTouchEvent(MotionEvent ev)

此方法是ViewGroup拦截事件的方法，返回true表示拦截事件不再向下层传递事件，返回false表示不拦截

4.整个ViewGroup的事件分发机制大致可以用下面的伪代码来表示:

    public boolean dispatchTouchEvent(MotionEvent ev) {
        boolean handled = false;
        if(onInterceptTouchEvent(ev)){
            handled = super.dispatchTouchEvent(ev);
        }else{
            if(child.dispatchTouchEvent(ev)){
                handled = true;
            }else{
                handled = super.dispatchTouchEvent(ev);
            }
        }
        return handled;
    }

ViewGroup的dispatchTouchEvent方法的功能可分为两部分，即事件下发部分和自身事件处理部分,ViewGroup是继承于View,所以它的自身事件就是view的dispatchTouchEvent方法().
由两种情况来决定走什么功能:

1.是否拦截，拦截，则直接调用super.dispatchTouchEvent()方法处理身为一个view的特性处理自身事件。不拦截则调用child.dispatchTouchEvent()下发事件 2.所有被下发事件的子view的dispatchTouchEvent()在ACTION_DOWN就返回false，表示下面无view处理，则再调用super.dispatchTouchEvent()处理自身事件。这就完成了这一轮的事件分发，其他层同理，是一个递归的过程

3、一个事件从手指按下屏幕的那一刻到离开屏幕，中间还可能有多次滑动，这个过程以一个ACTION_DOWN开始，中间可能有0及以上个ACTION_MOVE，然后以一个ACTION_UP结束。这是一个事件序列。

4.事件的分发是一层一层分发下来的，一旦某个ViewGrou成功拦截了事件序列中的某个事件，那么此事件序列之后的所有事件都会默认被拦截(只要后续事件能传递到它这里)，不会再去调用onInterceptTouchEvent询问是否拦截，当然也不会再向下分发,

5.如果一个事件传递到某个View或ViewGroup，一旦在ACTION_DOWN返回了false，那么此事件序列后续的事件都不会传递到这里了，并且父View的onTouchEvent方法会被调用即事件会再次向上传递，若一旦开始消费某个事件，那么即便在后续事件选择不消费了(比如此View的onTouchEvent方法在ACTION_DOWN返回true，但是ACTION_MOVE返回false)，后续事件也会持续的传到这里,并且父View的onTouchEvent方法不会被调用即事件不会再次向上传递，这些后续被返回false的事件最终会直接传递给Activity处理

6.View.dispatchTouchEvent()关键代码,onTouchListener的优先级要高于onTouchEvent()，onClickListener在onTouchEvent()里面调用。:

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

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

onTouchEvent方法里如果clickable和longClickable有一个为真，就会调用
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);
    return result;
}

7.Enable属性不影响默认的系统控件的onTouchEvent的返回值，只要view的clickable或longClickAble有一个为true，默认的onTouchEvent方法便会返回true，否则返回false（例如，当TextView的onTouchEvent默认返回false，因为它默认就是不可点击的，在设置了clickable为true后，它的onTouchEvent就返回true了）

if ((viewFlags & ENABLED_MASK) == DISABLED) {
        if (action == 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)
                || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE);
    }

8.以ViewGroup为例，当事件传进来时，dispatchTouchEvent中的代码：

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

这里的条件判断的决定是否直接将拦截标志位设为true，不再调用onInterceptTouchEvent方法去判断。满足条件为这个事件是ACTION_DOWN事件，或者mFirstTouchTarget不为空。ACTION_DOWN是一个新事件序列的开始肯定不能直接将拦截标志位设为true，而是要经过onInterceptTouchEvent去决定，mFirstTouchTarget是只要下面有子view消耗了事件就会赋值，所以不为空就是下面有子view处理了事件，而如果是后续事件但是mFirstTouchTarget为空说明子view在ACTION_DOWN事件就返回了false不消耗事件，那么后续的事件也就无需再传递给下面了，直接将拦截标志为设为true，而不再通过onInterceptTouchEvent去决定，这里需结合4和5仔细体会。

若进入了条件为真的的代码块，这个disallowIntercept一般是在子view中被用parent.requestDisallowInterceptTouchEvent后结果为true，就不再走onInterceptTouchEvent判断了，直接使拦截标志位位true，使得本parentView不拦截事件。虽然事件的分发是从外到里，但是这是特殊的子view干预父view的事件分发的办法，另外在MotionEvent.ACTION_DOWN事件到来时，disallowIntercept标志会在时被重置，mFirstTouchTarget会被清除，因为这是新事件序列的开始，所以这也更好理解为什么在MotionEvent.ACTION_DOWN时不能直接拦截了

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

如果不拦截，就会遍历子view，通过是否在播放动画和事件是否落在它的范围内来获得合适的 View，如果存在就为mFirstTouchTarget赋值，注意这里能找到的合适子view可能不止一个，因此如果第一个合适的view不处理事件，那么会继续为下面合适的继续赋值，以此类推

        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 = buildOrderedChildList();
                    final boolean customOrder = preorderedList == null
                            && isChildrenDrawingOrderEnabled();
                    final View[] children = mChildren;
                    for (int i = childrenCount - 1; i >= 0; i--) {
                        final int childIndex = customOrder
                                ? getChildDrawingOrder(childrenCount, i) : i;
                        final View child = (preorderedList == null)
                                ? children[childIndex] : preorderedList.get(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;
                }
            }
        }

接着检验mFirstTouchTarget是否为空，为空的可能有两种，一是没有合适的view，二是view不处理事件：

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

可以看到，不管是否为空都调用了dispatchTransformedTouchEvent()这个方法，看看它的关键代码

        if (child == null) {
            handled = super.dispatchTouchEvent(event);
        } else {
            handled = child.dispatchTouchEvent(event);
        }
        return handled;

看到这里就能明白了，关键在于第三个参数，mFirstTouchTarget为空则将child赋值空，就会调用了父view的dispatchTouchEvent方法，事件再次向上传递，否则直接调用了子view的dispatchTouchEvent方法，事件进入下一轮

最后事件分发大致图: