【自定义View系列】04--谈谈事件分发

引言：这部分会分三个模块来讲，先讲View对Touch的处理，再讲ViewGroup的事件分发，最后讲如何解决滑动冲突。

我习惯通过在源码中添加注释来理解源码，以下是我提取出来几个重要方法，将不重要的部分删掉，并且添加了中文注释。

一、先从View讲起

如果一个View(比如Button)接收到Touch，那么该Touch事件首先会传入到它的dispatchTouchEvent( )方法，所以我们从这里开始学习View对Touch事件的处理。

// 返回值表示Touch事件是否被该View消费
public boolean dispatchTouchEvent(MotionEvent event) {
//result的值决定最后该方法的返回值，也就是决定Touch事件是否被消费
boolean result = false;

/***/

if (onFilterTouchEventForSecurity(event)) {
ListenerInfo li = mListenerInfo;
//该if判断中一共包含了4个条件，必须同时满足时才表示Touch事件被消费
//在这四个条件中，我们通常最关心的就是最后一个:TouchListener的onTouch()方法。假如这四个条件中的任意一个不满足，那么result仍为false；则进入下一步调用自身的onTouchEvent()
if (li != null && li.mOnTouchListener != null &&
(mViewFlags&ENABLED_MASK)==ENABLED && li.mOnTouchListener.onTouch(this,event)) {
result = true;
}

//调用View自身的onTouchEvent()处理Touch事件，由onTouchEvent的返回值决定result的值（当然，如果在上一步中，如果已经将result设为true，就不会去判断onTouchEvent()了）
if (!result && onTouchEvent(event)) {
result = true;
}
}

/***/

return result;
}

onTouchEvent()是决定事件是否被消耗的最后一道门，如果返回false，则它的父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();

//如果一个View是disable的，CLICKABLE，LONG_CLICKABLE，CONTEXT_CLICKABLE消耗掉，且不会触发onClick事件回调
if ((viewFlags & ENABLED_MASK) == DISABLED) {
return (((viewFlags & CLICKABLE) == CLICKABLE
|| (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
|| (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE);
}

if (mTouchDelegate != null) {
if (mTouchDelegate.onTouchEvent(event)) {
return true;
}
}

//如果View不是disable的，会继续执行，对CLICK,LONG_CLICK,CONTEXT_CLICKABLE进行处理
if (((viewFlags & CLICKABLE) == CLICKABLE ||
(viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE) ||
(viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE) {
switch (action) {
case MotionEvent.ACTION_DOWN:
/***/
break;

case MotionEvent.ACTION_MOVE:
/***/
break;

case MotionEvent.ACTION_CANCEL:
/***/
break;

case MotionEvent.ACTION_UP:
boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {
/***/
if (!mHasPerformedLongPress && !mIgnoreNextUpEvent) {
/***/
if (!focusTaken) {
/***/
if (!post(mPerformClick)) {
//performClick()中会回调onClick，所以我们平时常见的onClick回调都是在ACTION_UP的时候触发的
performClick();
}
}
}
}
/***/
}

//这里表示，只要View是enable的，Touch事件都会被消耗掉
return true;
}

return false;
}

引用一张谷歌的小弟画的流程图：



需要注意的点：

onTouch()与onTouchEvent()以及click三者的区别和联系 ：

onTouch()与onTouchEvent()都是处理触摸事件的API

onTouch()属于TouchListener接口中的方法，是View暴露给用户的接口便于处理触摸事件，而onTouchEvent()是Android系统自身对于Touch处理的实现

先调用onTouch()后调用onTouchEvent()。而且只有当onTouch()未消费Touch事件才有可能调用到onTouchEvent()。即onTouch()的优先级比onTouchEvent()的优先级更高。

在onTouchEvent()中处理ACTION_UP时会利用ClickListener执行Click事件。所以Touch的处理是优先于Click的

简单地说三者执行顺序为：onTouch()–>onTouchEvent()–>onClick()

View没有事件的拦截(onInterceptTouchEvent( ))，ViewGroup才有，请勿混淆

二、ViewGroup的事件分发

Touch事件会从PhoneWindow开始一直传递到最顶层的ViewGroup，然后调用到最顶层的dispatchTouchEvent()

事件分发体系最重要的几个方法：

dispatchTouchEvent(event)

主要完成事件分发的逻辑，只要事件到达该View，一定会调用这个方法，返回值表示是否消耗当前事件。

onInterceptTouchEvent(Event)

判断是否拦截某个事件，返回值表示是否拦截

onTouchEvent(Event)

用来处理Touch事件，返回值表示是否消耗该事件。

他们的关系可以这样表示：

public boolean dispatchTouchEvent(MotionEvent e) {
if(onInterceptTouchEvent(ev)) {
//如果拦截，就自己处理，调用自己的onTouchEvent,如果onTouchEvent返回true就消费掉，如果返回false就传给上层处理
return onTouchEvent(ev);
} else {
//如果不拦截，就走子view的分发流程
return child.dispatchTouchEvent(ev);
}
}

来看看源码：

public boolean dispatchTouchEvent(MotionEvent ev) {

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

if (actionMasked == MotionEvent.ACTION_DOWN) {
//如果是DOWN事件，进行初始化和还原操作
cancelAndClearTouchTargets(ev);
resetTouchState();
}

// 判断是否需要拦截事件，根据intercepted的值确定
// mFirstTouchTarget用于多点触控
// mFirstTouchTarget不为空，表示有子View消费了Touch事件
final boolean intercepted;
if (actionMasked == MotionEvent.ACTION_DOWN
|| mFirstTouchTarget != null) {
final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
if (!disallowIntercept) {
// 如果是DOWN或者有子View消费，则根据onInterceptTouchEvent判断是否拦截
// ViewGroup的onInterceptTouchEvent默认返回false，也就是不拦截
// 所以我们往往可以在自定义控件中重写这个方法，来决定什么情况下拦截事件
intercepted = onInterceptTouchEvent(ev);
ev.setAction(action);
} else {
// 如果disallowIntercept == false，就是不允许拦截，可以在子View设置不允许父View拦截
intercepted = false;
}
} else {
// 执行到这里，说明mFirstTouchTarget为null或者不是DOWN事件，需要ViewGroup自己处理此次Touch事件
// 也就是拦截本次Touch事件
intercepted = true;
}

// 如果Touch事件没有被取消也没有被拦截，那么ViewGroup将类型为ACTION_DOWN的Touch事件分发给子View。
if (!canceled && !intercepted) {

if (actionMasked == MotionEvent.ACTION_DOWN
|| (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
|| actionMasked == MotionEvent.ACTION_HOVER_MOVE) {

// 根据Touch事件的坐标，找到触摸到了哪个子View
final int childrenCount = mChildrenCount;
if (newTouchTarget == null && childrenCount != 0) {
final float x = ev.getX(actionIndex);
final float y = ev.getY(actionIndex);
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);

newTouchTarget = getTouchTarget(child);
if (newTouchTarget != null) {
newTouchTarget.pointerIdBits |= idBitsToAssign;
break;
}

/***/

// 找到之后，调用dispatchTransformedTouchEvent，传入子view
// 子View没有消费Touch事件则该方法的返回值为false，此时mFirstTouchTarget仍为null
// 如果子View消费掉了Touch事件那么该方法的返回值为true，然后执行newTouchTarget = addTouchTarget(child, idBitsToAssign);
if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
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();
// 如果子View消费掉了Touch事件那么该方法的返回值为true，然后执行
newTouchTarget = addTouchTarget(child, idBitsToAssign);
alreadyDispatchedToNewTouchTarget = true;
break;
}
}
}
}
}

// mFirstTouchTarget为空，表示没有子View消耗Touch事件，需要ViewGroup自己处理
if (mFirstTouchTarget == null) {
// 同样也会调用dispatchTransformedTouchEvent，但是传入Null，标明由父View自己处理这次Touch事件
handled = dispatchTransformedTouchEvent(ev, canceled, null,
TouchTarget.ALL_POINTER_IDS);
} else {
/***/
}

/***/
}
}

最后会调用dispatchTransformedTouchEvent

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

/***/

// 如果child == null，表明没有子View消费这次Touch事件
if (child == null) {
// 所以会调用super.dispatchTouchEvent，此时，ViewGroup就化身为了普通的View，它会在自己的onTouch()，onTouchEvent()中处理Touch
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());
}

// 如果child不为空，表示有子View处理这次Touch事件，直接调用child的dispatchTouchEvent
// 当然该view可能是一个View也可能是一个ViewGroup
handled = child.dispatchTouchEvent(transformedEvent);
}

// Done.
transformedEvent.recycle();
return handled;
}

最后会递归的执行子View的这套流程，或者被ViewGroup自身拦截掉，亲自用onTouchEvent处理这次事件

onInterceptTouchEvent()表示是否拦截此次事件，ViewGroup的默认实现是不拦截，return false；所以我们往往可以在自定义控件中重写这个方法，来决定什么情况下拦截事件

总结下来就是：

Touch事件的传递顺序为 ：

Activity–>外层ViewGroup–>内层ViewGroup–>View

如果Touch事件在中间某一层被拦截了，DOWN事件将不会再传递给更底层的View

Touch事件的消费顺序为 ：

View–>内层ViewGroup–>外层ViewGroup–>Activity

如果Touch事件在中间某一层被消费了，将不会再通知更上层的View，只有当所有子View都不消费Touch事件，顶层ViewGroup才会自己处理这次Touch事件。

三、滑动冲突处理

引发原因：两个可以滑动的View互相嵌套，且滑动方向相同，则会产生滑动冲突。

有两个比较常见的解决方案：

1、在父View中准确地进行事件分发和拦截

比如重写onInterceptTouchEvent()和onTouchEvent()，对事件进行正确的分配，保证在合适的时候Touch时间可以传递给子View

2、使用Google在support.v4包提供的两个支持嵌套滚动的接口：onNestedScrollChild、onNestedScrollParent。（有一个例子，在我的Github上一个快速开发框架里的下拉刷新SwipeLayout中有用到，贴上地址：https://github.com/miomin/Shareward）

四、需要注意的地方

一个事件序列指的是从手指按下的一刻起直到手指放开，通常情况下，一个事件序列只能被一个View拦截或消耗，拦截和消耗通常都是在DOWN事件进行，如果不对DOWN时间进行消费，则不会有机会消耗后续的MOVE事件，如果消耗了DOWN事件，后续的MOVE和UP事件同样由这个View消费。（support.v4包中的NestedScrolling接口可以打破这个原则，允许多个View同时处理同一个事件序列）

ViewGroup的onInterceptTouchEvent默认返回false，也就是默认不会拦截事件，交给下层的View来处理。

View没有onInterceptTouchEvent方法，一旦有事件到达，就会调用onTouchEvent。

可点击的View的onTouchEvent默认返回true，也就是消耗事件。