从源码角度分析事件分发流程

事件分发流程分为View的事件分发和ViewGroup的事件分发, 首先来看看View的事件分发流程，也就是View#dispatchTouchEvent到底做了什么。

View的事件分发

public boolean dispatchTouchEvent(MotionEvent event) {
   ...
    //默认不消费
    boolean result = false;

    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)) {
             //这里是关键,如果OnTouchListener消费了事件,直接设置result = true
            result = true;
        }

        if (!result && onTouchEvent(event)) {
            //如果result=false, 且onTouchEvent消费了事件,那么将设置result = true
            result = true;
        }
    }
    //返回是否消费了事件,true表示消费了,false表示没有消费
    return result;
}

由此可见View的dispatchTouchEvent主要处理事件的消费,首先会判断OnTouchListener#onTouch的返回值, 如果是true则会拦截onTouchEvent方法,否则就会传递到onTouchEvent进行消费.
下面是View的onTouchEvent源码

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 (mTouchDelegate != null) {
        //这里如果有设置监听,则交个监听去处理，比较少用到
        if (mTouchDelegate.onTouchEvent(event)) {
            return true;
        }
    }

    if (clickable || (viewFlags & TOOLTIP) == TOOLTIP) {
        //注意:这里只要clickable=true就可以进来
        switch (action) {
            case MotionEvent.ACTION_UP:
                ...
                if (!post(mPerformClick)) {
                         //处理点击事件,最后会调用performClick方法
                      performClickInternal();
                 }
                 ...
                break;
                ...
        }
        //clickable=true 直接返回true,到这就表示事件消费了.
        return true;
    }
    //否则表示不消费事件
    return false;
}

onTouchEvent方法也很简单，直接判断View是否是可点击的，如果是则返回true消费事件，否则返回false不消费。另外ACTION_UP事件会处理我们的点击事件，上面的performClickInternal代码如下:

private boolean performClickInternal() {
        // Must notify autofill manager before performing the click actions to avoid scenarios where
        // the app has a click listener that changes the state of views the autofill service might
        // be interested on.
        notifyAutofillManagerOnClick();
		//这里处理点击事件
        return performClick();
}

performClick就是处理点击事件的

public boolean performClick() {
        // We still need to call this method to handle the cases where performClick() was called
        // externally, instead of through performClickInternal()
        notifyAutofillManagerOnClick();

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

ok ,View的事件分发原理就看完, 比较简单, 主要是处理事件的消费, 是否消费由onTouchEvent的返回值决定, true表示消费,false表示不消费.

Activity的事件分发

在介绍ViewGroup的事件分发前, 我们先来看看事件是怎么到达ViewGroup的, 大致流程是这样的
硬件-> Activity-> PhoneWindow -> DecorView ->ViewGroup

我们看看Activity#dispatchTouchEvent分发

 public boolean dispatchTouchEvent(MotionEvent ev) {
        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
            onUserInteraction();
        }
        //这里会先走里
        if (getWindow().superDispatchTouchEvent(ev)) {
            return true;
        }
        //上面没有消费,就会走Activity的onTouchEvent方法去消费
        return onTouchEvent(ev);
    }

getWindow()得到的是Widow抽象类, 它的唯一实现是PhoneWindow, 来看看它的superDispatchTouchEvent方法

  @Override
   public boolean superDispatchTouchEvent(MotionEvent event) {
   		//这里mDecor是DecorView,它是顶级View
       return mDecor.superDispatchTouchEvent(event);
   }

可以看到PhoneWindow#superDispatchTouchEvent就一句代码, 调用的是DecorView的superDispatchTouchEvent, 继续走

public boolean superDispatchTouchEvent(MotionEvent event) {
		//终于在这里看到了dispatchTouchEvent的身影了.
       return super.dispatchTouchEvent(event);
}

走到DecorView的superDispatchTouchEvent方法后,可以看到它调用了父类的dispatchTouchEvent方法, 我们知道DecorView是继承FrameLayout的

public class DecorView extends FrameLayout implements RootViewSurfaceTaker, WindowCallbacks {...}

而FrameLayout是继承ViewGroup的, 由于FrameLayout没有重写ViewGroup的dispatchTouchEvent方法,所以DecorView的superDispatchTouchEvent方法最终会调用ViewGroup的dispatchTouchEvent方法.

终于经过层层传递,事件来到了ViewGroup#dispatchTouchEvent方法了. 下面开始正式分析ViewGroup的事件分发流程.

ViewGroup的事件分发

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    //默认没有消费
    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) {
            //重置各种标记
            cancelAndClearTouchTargets(ev);
            resetTouchState();
        }

        // 标记是否拦截
        final boolean intercepted;
        if (actionMasked == MotionEvent.ACTION_DOWN
                || mFirstTouchTarget != null) {
            //down事件或者目标View存在,一开始是不存在目标View的
            
             //判断子View是否禁止拦截的标记,默认是false,这里可知down事件没法禁止拦截,
             //因为这里会优先于子View的down事件执行     
            final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
            if (!disallowIntercept) {
                //如果子View没有设置禁止拦截,则调用ViewGroup#onInterceptTouchEvent判断是否拦截
                intercepted = onInterceptTouchEvent(ev);
                ev.setAction(action); // restore action in case it was changed
            } else {
                //如果子View设置了请求拦截,那么将拦截标记至为false,表示不会拦截
                intercepted = false;
            }
        } else {
            //如果是move/up事件,且不存在mFirstTouchTarget (目标View)的时候直接标记为拦截
            intercepted = true;
        }
        ...

        // 是否取消子View事件的标记
        final boolean canceled = resetCancelNextUpFlag(this)
                || actionMasked == MotionEvent.ACTION_CANCEL;
     ...
       
        TouchTarget newTouchTarget = null;
        
        //这个变量每次进来都会重置为false,这个标记下面的逻辑会用到
        boolean alreadyDispatchedToNewTouchTarget = false;
        
        if (!canceled && !intercepted) {
           ...
            //如果不是取消事件且没有拦截会进来 继续处理down事件去查找目标View
            if (actionMasked == MotionEvent.ACTION_DOWN) {
              ...
                final int childrenCount = mChildrenCount;
                if (newTouchTarget == null && childrenCount != 0) {
                    // Scan children from front to back.
                    //排序
                    final ArrayList<View> preorderedList = buildTouchDispatchChildList();
                    final View[] children = mChildren;
                    for (int i = childrenCount - 1; i >= 0; i--) {
                        //遍历所有子View,注意这里是倒序遍历的,也就是说最末尾的子View可以优先得到判断
                        final View child = getAndVerifyPreorderedView(
                                preorderedList, children, childIndex);
                        //这里处理子View的分发
                        if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
                             //这里标记目标view,里面的操作是child.next=mFirstTouchTarget 
                             //mFirstTouchTarget = child
                            newTouchTarget = addTouchTarget(child, idBitsToAssign);
                           //这个标记设置true
                             alreadyDispatchedToNewTouchTarget = true;
                             //退出循环,结束down事件
                            break;
                        }
                    }
                }
            }
        }
        
        // Dispatch to touch targets.
        if (mFirstTouchTarget == null) {
            //走到这说明没有找到目标View或者事件被ViewGroup拦截了, 那么调用dispatchTransformedTouchEvent时,传的第三个child参数是null
            //canceled默认也是false
            handled = dispatchTransformedTouchEvent(ev, canceled, null,
                    TouchTarget.ALL_POINTER_IDS);
        } else {
            //说明有目标View消费了down事件
            TouchTarget target = mFirstTouchTarget;
            while (target != null) {
                //目标View关联的View
                final TouchTarget next = target.next;
                
                if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
                    //如果有目标View且是down事件 这里会进来
                    //因为alreadyDispatchedToNewTouchTarget =true  target也等于newTouchTarget
                     handled = true;
                } else {
                    //如果是move up 事件 会走这里,因为alreadyDispatchedToNewTouchTarget会每次都换重置为false
                    //是否取消子View的事件分发
                    final boolean cancelChild = resetCancelNextUpFlag(target.child)
                            || intercepted; //注意这里:intercepted=true的话会取消子View的事件
                     
                    //继续调这个方法,如果时ViewGroup设置了拦截,那么cancelChild=true    
                    if (dispatchTransformedTouchEvent(ev, cancelChild,
                            target.child, target.pointerIdBits)) {
                         //如果取消了,这里也设置 handled = true
                        handled = true;
                    }
                    
                    if (cancelChild) {
                        //取消事件后将会重置 mFirstTouchTarget  
                        mFirstTouchTarget = next; //这里next是null ,
                       //回收目标View
                        target.recycle();
                        target = next;
                        continue;
                    }
                }
                //这个循环一般只会执行一次,mFirstTouchTarget 的next是null
                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();
        }
    }
    //返回是否消费,true则消费了,false则由父View去判断了
    return handled;
}

上面多个地方都用到了dispatchTransformedTouchEvent方法,这里继续往里看

private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
        View child, int desiredPointerIdBits) {
  //默认不消费
      final boolean handled;

    //保存当前的事件
    final int oldAction = event.getAction();

    if (cancel || oldAction == MotionEvent.ACTION_CANCEL) {
        //这里是处理cancle事件的操作,如果有目标View且ViewGroup拦截了事件,那么cancel永远为true
        //给当前event设置一个ACTION_CANCEL
        event.setAction(MotionEvent.ACTION_CANCEL);
        if (child == null) {
            //child=null表示没有目标View,那么直接调用super去处理
            //ViewGroup的父类就是View,那么就会走View的分发流程了,也就是走事件的消费流程
            handled = super.dispatchTouchEvent(event);
        } else {
            //这里说明有目标View,那么将设置了ACTION_CANCEL的事件传递给子目标View
            handled = child.dispatchTouchEvent(event);
        }
        //重新设置回原来的事件
        event.setAction(oldAction);
        //返回消费结果
        return handled;
    }

    ...

    // Perform any necessary transformations and dispatch.
    if (child == null) {
        //没有目标View, 这里分析和上面一样
        handled = super.dispatchTouchEvent(transformedEvent);
    } else {
        //有目标View,让目标View继续分发事件
        handled = child.dispatchTouchEvent(transformedEvent);
    }

    // Done.
    return handled;
}

分析完源码后，得出的总结如下:
首先down事件由Activity的dispatchTouchEvent处开始分发，该方法如果被重写返回true或者false则直接消费事件，默认是返回super的，那么down事件将先传递给ViewGroup的dispatchTouchEvent方法。

ViewGroup的dispatchTouchEvent方法内首先会通过onInterceptTouchEvent方法判断down事件是否拦截，拦截则ViewGroup自己处理，也就是调用自己的onTouchEvent方法，onTouchEvent方法返回true则完成down事件的消费，返回false则会回到Activity处，交给Activity的onTouchEvent方法处理。

如果down事件ViewGroup不拦截，则会走查找目标View的流程，如果有目标View消费了down事件，那么记录该目标View，同时ViewGroup返回true，结束down事件分发。

接着move事件从Activity的dispatchTouchEvent开始分发，走super的流程，此时会判断上一次down事件有没有被ViewGroup消费，如果没有，那么move事件会直接交个Activity的onTouchEvent方法处理，不会分发给ViewGroup了。

如果上次down事件ViewGroup有做处理，那么会继续调用ViewGroup的dispatchTouchEvent方法。该方法内首先会判断是否有目标View存在，如果目标View不存在，那么会直接交给ViewGroup的onTouchEvent处理。

如果目标View存在，则再判断目标View有没有请求禁止拦截，如果请求了禁止拦截则不会走ViewGroup的onInterceptTouchEvent方法，否则还是会走一次判断是否要拦截，如果ViewGroup拦截则会传递一个ACTION_CANCEL的事件给目标View，最后会将目标View清空， 当下次move事件到达的时候会直接交给ViewGroup的onTouchEvent处理，ViewGroup的onTouchEvent如果不处理，也就是返回false给Activity，那么之后ViewGroup将无法收到move事件了，如果ViewGroup处理则完成此次move事件的消费。

后续的move事件
如果前一次move事件ViewGroup有处理， 那么事件还会继续到达ViewGroup， 且不会走onInterceptTouchEvent方法了，直接走ViewGroup#onTouchEvent方法。 因为ViewGroup#onInterceptTouchEvent方法仅当down事件或者存在目标View的时候且目标View没有禁止拦截时才会触发的。
如果前一次move事件ViewGroup拦截后没有做处理，也就是onTouchEvent返回false， 那么事件将不会到达ViewGroup了，直接被Activity处理了。