Android 事件分发

一，前言

事件分发的文章也看过很多，自己也写过笔记文章，但都没有从总体上真正理解过，最终也是一知半解。这次就从总体流程上归纳下，更方便记忆。

二，必须知道的方法

2.1 ViewGroup

//分发事件
public boolean dispatchTouchEvent(MotionEvent ev) 
//事件拦截，可以拦截本该子View处理的事件
public boolean onInterceptTouchEvent(MotionEvent ev) 
//将事件分发至子View或交给自己处理
private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
            View child, int desiredPointerIdBits)

与View中的dispatchTouchEvent不同，ViewGroup中的dispatchTouchEvent还要兼顾对子View的事件分发。而处理自身的事件是用super.dispatchTouchEvent(event)，也就是View的，在dispatchTransformedTouchEvent中被调用。
onInterceptTouchEvent是View中没有的方法，当子View处理了DOWN事件，获得了事件流的处理权，父ViewGroup可以用onInterceptTouchEvent返回true来拦截事件交予自己处理。
dispatchTransformedTouchEvent中分情况调用用子View的dispatchTouchEvent来分发事件；或者调用super.dispatchTouchEvent(event)来自己处理事件。

2.2 View

与ViewGroup不同，View的主要实现事件的响应，不用管分发

//分发事件
public boolean dispatchTouchEvent(MotionEvent ev) 
//优先onTouchEvent的触摸响应，用户自定义添加监听
public interface OnTouchListener {
    boolean onTouch(View v, MotionEvent event);
}
//系统响应，长按和点击事件在里面被调用
public boolean onTouchEvent(MotionEvent event)

先调用mOnTouchListener.onTouch(this, event)来处理事件，如果onTouch没有处理，则再交给onTouchEvent处理。
OnTouchListener是对事件分发的回调，在onTouchEvent前被调用。
onTouchEvent主要用于响应长按事件和点击事件。

三，ViewGroup的dispatchTouchEvent

基于常用的几个方法来分析其功能的实现原理，也包括上面方法介绍时说的原理。==暂时只考虑单点触摸事件==。

父ViewGroup只要拦截了ACTION_DOWN,后续事件下层级的View无法抢夺了。
在子容器中调用getParent().requestDisallowInterceptTouchEvent(true)来抢夺上一层容器的事件处理权。前提ACTION_DOWN没有被拦截。
在父容器中使onInterceptTouchEvent返回true来拦截本该交给它底下层级View的事件处理权。但父容器的requestDisallowInterceptTouchEvent(true)被调用，onInterceptTouchEvent无效。
onInterceptTouchEvent只有在ACTION_DOWN事件或者事件被自己下面层级的View处理时才会被调用，也就是说ACTION_DOWN被自己处理了，这个ViewGroup的onInterceptTouchEvent在同一个事件序列中不会被调用。
一旦有View对down事件的触摸响应，也就是使其dispatchTouchEvent返回true，一般事件后续的move，up等都交予它处理了，除非抢夺处理权。
一旦子View抢夺权限成功，后续的一序列事件都交予子View处理了；父View抢夺成功，本改处理事件的View会收到ACTION_CANCE事件，被拦截的这次事件父View不会处理，但后续事件都会交给父View处理了，且因为事件被父View处理，它的onInterceptTouchEvent不会再被调用。

暂时根据ViewGroup的dispatchTouchEvent只想到这些了。其功能主要处理事件分发，所以相关点都是这些方法在事件分发中的作用。

又要贴代码了.....只贴重点代码，上面说的点都在代码中可以看出。

3.1

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    ......
    // 检查是否自身是否拦截事件
    final boolean intercepted;
    //只有ACTION_DOWN或事件交由底下View处理了才走进去
    if (actionMasked == MotionEvent.ACTION_DOWN
            || mFirstTouchTarget != null) {
        //FLAG_DISALLOW_INTERCEPT就是通过requestDisallowInterceptTouchEvent方法来设置的
        final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
        //如果requestDisallowInterceptTouchEvent(true)，就走else了
        if (!disallowIntercept) {
            //调用onInterceptTouchEvent询问是否拦截
            intercepted = onInterceptTouchEvent(ev);
            ev.setAction(action); // restore action in case it was changed
        } else {
            intercepted = false;
        }
    } else {
        // 没有下层级的View处理事件，且不是Down事件，就直接拦截，不询问了。
        // 也就是说down被本ViewGroup拦截处理，后续不会询问而直接给本ViewGroup处理.
        intercepted = true;
    }
    ......
}

上面代码默认为intercepted = true就是拦截了事件。解释了第2，3，4点，注释说得很清楚了。

当然代码不能割裂来看，下面解释为什么intercepted = true就是拦截了事件和剩下几点。

3.2

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    ......
    //如果事件没有取消，且没有被拦截
    if (!canceled && !intercepted) {
        //下面跳过多点触控的代码了
        ......
        //ACTION_DOWN事件才会进入
        if (actionMasked == MotionEvent.ACTION_DOWN
                        || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
                        || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
            for (int i = childrenCount - 1; i >= 0; i--) {
                ......
                //判断子View是否在点击范围内
                if (!canViewReceivePointerEvents(child)
                        || !isTransformedTouchPointInView(x, y, child, null)) {
                    ev.setTargetAccessibilityFocus(false);
                    continue;
                }
                ......
                //dispatchTransformedTouchEvent分发给子View，如果有子View处理了，就进入if
                if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
                    ...... 
                    //addTouchTarget中会存储处理事件的子View，赋予mFirstTouchTarget
                    newTouchTarget = addTouchTarget(child, idBitsToAssign);
                    alreadyDispatchedToNewTouchTarget = true;
                    break;
                }
            }
        }
    }
}

上面这段主要实现Down事件如何分发给子View。

3.3

    // Dispatch to touch targets.
    if (mFirstTouchTarget == null) {
        // 1.没有子View处理事件，就交给自己处理
        handled = dispatchTransformedTouchEvent(ev, canceled, null,
                TouchTarget.ALL_POINTER_IDS);
    } else {
        // 2.如果前提事件已经有View处理了，走下面步骤
        TouchTarget predecessor = null;
        TouchTarget target = mFirstTouchTarget;
        //多点触摸多条事件时，循环分发
        while (target != null) {
            final TouchTarget next = target.next;
            //3.Down事件被子View处理了，这部就直接结束了这次分发
            if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
                handled = true;
            } else {
                final boolean cancelChild = resetCancelNextUpFlag(target.child)
                        || intercepted;
                //4.intercepted就决定了是否cancle事件，后续事件再交予自己处理，子View会收到ACTION_CANCEL。
                //否则正常分发
                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;
        }
    }
    
    ......
    
    return handled;

上面解释了剩下几点。

注释第一点，mFirstTouchTarget为空，就说明Down事件中下层View没有处理这个事件，在这里交给自己处理。
注释第二点，mFirstTouchTarget不为空，则走这里，进行View的分发，因为mFirstTouchTarget保存了处理事件的子View，直接交予对应子View处理。
注释第三点，如果是Down事件，且找到处理事件的子View，handled = true;结束这个事件分发。
注释第四点，这个ViewGroup决定拦截本该交予子View处理的事件，这里cancelChild为true，在dispatchTransformedTouchEvent交予子View的是cancel事件而不是原本事件。mFirstTouchTarget中移除相应的TouchTarget，这样后续事件的mFirstTouchTarget就为空了，交予这个ViewGroup处理。

四，ViewGroup的dispatchTransformedTouchEvent

从上面的分析可以知道，这个方法在dispatchTouchEvent有三次调用，也可以说有三种作用。

在3.2中，在找到被触摸的子View后，交予其分发给子View处理，调用child.dispatchTouchEvent(transformedEvent)分发事件。
在3.3的注释第一点中，传递的child为空，会调用super.dispatchTouchEvent(transformedEvent)交予ViewGroup自身处理。
在3.3的第四点中，如果cancel参数为false，就和第一点一样的情况；如果cancel为true，会event.setAction(MotionEvent.ACTION_CANCEL)，将事件统一变为cancel事件，再交予子View。

private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
            View child, int desiredPointerIdBits) {
    final int oldAction = event.getAction();
    //如果ViewGroup拦截这个事件，或cancel事件
    if (cancel || oldAction == MotionEvent.ACTION_CANCEL) {
        //设置传递的事件类型为cancel事件
        event.setAction(MotionEvent.ACTION_CANCEL);
        if (child == null) {
            //给自己的cancel事件
            handled = super.dispatchTouchEvent(event);
        } else {
            //给子View的cancel事件
            handled = child.dispatchTouchEvent(event);
        }
        event.setAction(oldAction);
        return handled;
    }
    
    //非传递cancel事件，正常分发
    if (child == null) {
        //叫给ViewGroup自己处理事件
        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());
        }

        //交给子View处理事件
        handled = child.dispatchTouchEvent(transformedEvent);
    }
    
    return handled;
}

五，View的dispatchTouchEvent

与ViewGroup作用为分发事件不同，View里它的作用为处理事件。

public boolean dispatchTouchEvent(MotionEvent event) {
    ......
    if (onFilterTouchEventForSecurity(event)) {
        ......
        //noinspection SimplifiableIfStatement
        ListenerInfo li = mListenerInfo;
        //调用onTouch
        if (li != null && li.mOnTouchListener != null
                && (mViewFlags & ENABLED_MASK) == ENABLED
                && li.mOnTouchListener.onTouch(this, event)) {
            result = true;
        }
        //如果onTouch返回true，则不会再调用onTouchEvent
        if (!result && onTouchEvent(event)) {
            result = true;
        }
    }
}

onTouch先于onTouchEvent调用，且onTouch处理事件，就不会交予onTouchEvent处理了，也就是点击事件和长按事件不会响应了。

六，View的onTouchEvent

onTouchEvent中，主要调用了OnClick 和 OnLongClick。先调用
OnLongClick再调用OnClick，如果OnLongClick返回true消耗了事件，onClick不会被调用。
只要View可点击的，就算没有注册点击事件和长按事件，也会消费这个事件。

public boolean onTouchEvent(MotionEvent event) {
    
    //DISABLED状态
    if ((viewFlags & ENABLED_MASK) == DISABLED) {
        if (action == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
            setPressed(false);
        }
        // 如果是DISABLED状态，但同时还是CLICKABLE可点击，虽然不会响应点击监听，但还是会消耗事件
        return (((viewFlags & CLICKABLE) == CLICKABLE
                || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
                || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE);
    }
    
    if (((viewFlags & CLICKABLE) == CLICKABLE ||
            (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE) ||
            (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE) {
        switch (action) {
            case MotionEvent.ACTION_UP:
                boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
                if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {
                    //mHasPerformedLongPress表示长按是否消费了事件 
                    //mIgnoreNextUpEvent是鼠标移动事件相关参数，可以不管
                     if (!mHasPerformedLongPress && !mIgnoreNextUpEvent) {
                        // 移除长按
                        removeLongPressCallback();

                        // 要有焦点，也就是在点击状态下，才响应点击事件
                        if (!focusTaken) {
                            // 使用Handler来实现回调，使视觉效果优先于点击响应。
                            if (mPerformClick == null) {
                                //创建的Runnable对象中，调用了performClick()来响应点击事件
                                mPerformClick = new PerformClick();
                            }
                            //发送消息执行点击监听
                            if (!post(mPerformClick)) {
                                performClick();
                            }
                        }
                    }
                    
                }
                
                break;
            case MotionEvent.ACTION_DOWN:
                // 所在容器是否可以滚动
                boolean isInScrollingContainer = isInScrollingContainer();

                //如果可以滚动，延迟ViewConfiguration.getTapTimeout()来进行长按判断，防止为滚动触摸事件。
                //但长按时间判断会减去ViewConfiguration.getTapTimeout()，所以最终长按监听被调用的时间不变
                if (isInScrollingContainer) {
                    mPrivateFlags |= PFLAG_PREPRESSED;
                    if (mPendingCheckForTap == null) {
                        //CheckForTap里会调用checkForLongClick方法进行长按判断
                        mPendingCheckForTap = new CheckForTap();
                    }
                    mPendingCheckForTap.x = event.getX();
                    mPendingCheckForTap.y = event.getY();
                    postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
                } else {
                    setPressed(true, x, y);
                    // 不是滚动，进行长按判断，使用Handler进行长按时间判断
                    checkForLongClick(0, x, y);
                }
                break;
            case MotionEvent.ACTION_CANCEL:
                setPressed(false);
                //移除长按消息
                removeTapCallback();
                removeLongPressCallback();
                mInContextButtonPress = false;
                mHasPerformedLongPress = false;
                mIgnoreNextUpEvent = false;
                break;
            case MotionEvent.ACTION_MOVE:
                //按钮之外的移动要容忍。
                if (!pointInView(x, y, mTouchSlop)) {
                    // 从Handler消息队列中移除Down里面添加的mPendingCheckForTap,也就是移除滚动容器里的长按判断
                    removeTapCallback();
                    if ((mPrivateFlags & PFLAG_PRESSED) != 0) {
                        // 从Handler消息队列中移除长按判断Runnable，
                        removeLongPressCallback();

                        setPressed(false);
                    }
                }
                break;
        }
        
        //只要设置了可点击或可长按状态，都会消耗事件，不管有没有设置监听
        return true;
    }
}

可以看出，长按监听调用是通过延迟消息实现的；如果进行了滑动，且是按压状态（满足down事件中长按消息发送），移除长按消息。所以在down事件后发送长按延迟消息，如果没有在move，cancel，up中移除消息，延迟时间过后就会执行长按回调了。
ACTION_UP中的PFLAG_PREPRESSED参数，是在ACTION_DOWN的CheckForTap中被延迟赋值给mPrivateFlags的，在ACTION_CANCEL和ACTION_MOVE中会移除这个值。所以没有move而执行到ACTION_UP时，因为赋值了PFLAG_PREPRESSED一定会进入。
ACTION_UP中的(mPrivateFlags & PFLAG_PRESSED) != 0判断，非处于滚动容器，会在ACTION_DOWN的setPressed(true, x, y)设置PFLAG_PRESSED值，在move中setPressed(false)移除。
上面2，3两点决定ACTION_DOWN的if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed)两个条件是否满足。满足的要求都是只有按下，而没有执行滑动就到抬起。
长按和点击回调都是通过发送消息来调用，在Runnable里调用对应的方法。长按为checkForLongClick(int delayOffset, float x, float y)；点击为performClick()。方法里面调用了回调监听。

在ACTION_MOVE中，我们一般通过判断滑动距离有没有超过mTouchSlop来判断是否属于滑动事件。

参考

Android事件传递之子View和父View的那点事

安卓自定义View进阶-事件分发机制详解