Android View 事件分发机制
Android View 事件分发机制
点击事件传递规则
在分析点击事件传递规则之前，首先要分析的对象是MotionEvent，点击事件的事件分发，其实就是对MotionEvent事件的分发过程，即当一个MotionEvent产生了以后，系统需要把这个事件传递给一个具体的View，而这个传递的过程就是分发过程。
点击事件的分发过程由三个很重要的方法来完成：
puhlic boolean dispatchTouchEvent(MotionEvent ev)
用来进行事件的分发。如果事件能够传递给当前View，那么此方法一定会被调用，返回结果受当前View的onTouchEvent和下级View的dispatchTouchEvent方法的影响，表示是否消耗当前事件。
public boolean onInterceptTouchEvent(MotionEvent event)
在上述方法内部调用，用来判断是否拦截某个事件，如果当前View拦截了某个事件，那么在同一个事件序列当中，此方法不会被再次调用，返回结果表示是否拦截当前事件
public boolean onTouchEvent(MotionEvent event)
在dispatchTouchEvent方法中调用，用来处理点击事件，返回结果表示是否消耗当前事件，如果不消耗，则在同一个事件序列中，当前View无法再次接收到事件。
public boolean dispatchTouchEvent(MotionEvent ev) {
boolean consume = false;
if(onInterceptTouchEvent(ev)){
consume = onTouchEvent(ev);
}else {
consume = child.dispatchTouchEvent(ev);
}
return consume;
}
通过上述伪代码可以大致了解点击事件的传递规则：点击事件产生以后，首先传递给根ViewGroup，调用它的dispatchTouchEvent，然后执行onIntereptTouchEvent方法，如果返回true就表示它要拦截当前事件，接着事件就会交给这个ViewGroup处理，则他的onTouchEvent方法就会被调用；如果返回false则表示不需要拦截当前事件，这时就会调用子元素的dispatchTouchEvent方法，接着子元素的onIntereptTouchEvent方法就会被调用，如此反复直到事件被最终处理。
当一个点击事件产生后，它的传递过程遵循如下顺序：Activity->Window->View，即事件总是先传递给Activity，Activity再传递给Window，最后Window再传递给顶级View，顶级View接收到事件后，就会按照事件分发机制去分发事件。考虑一种情况，如果一个view的onTouchEvent返回false，那么它的父容器的onTouchEvent将会被调用，依此类推,如果所有的元素都不处理这个事件，那么这个事件将会最终传递给Activity处理，即Activity的onTouchEvent方法会被调用。
当一个View设置了OnTouchListener，那么OnTouchListener中的onTouch方法会被回调。如果onTouch返回false，则View的OnTouchEvent会被调用；如果返回true，那么onTouchEvent方法将不会被调用。由此可见，给View设置的OnTouchListener，其优先级比onTouchEvent要高。在onTouchEvent方法中，如果当前设置的有OnClickListener，那么它的onClick方法会用。因此OnClickListener，其优先级最低，处于事件传递的尾端。
关于事件传递的机制，这里给出一些结论，根据这些结论可以更好地理解整个传递机制，如下所示：
-
一个事件序列是指down->move->move…->up这样一系列事件。
-
同一个事件序列不能被两个View同时处理，但是可以通过特殊手段，比如某个View通过onTouchEvent强行传递给其他View处理。
-
某个View一旦决定拦截，那么整个事件序列都会由它来处理，并且onInterceprTouchEvent不会再被调用。
-
某个View一旦开始处理事件，如果它不消耗ACTON_DOWN事件(onTouchEvent返回了false)，那么同一事件序列中的其他事件都不会再交给它来处理，并且事件将重新交由它的父元素去处理，即父元素的onTouchEvent会被调用。
-
如果View不消耗除ACTION_DOWN以外的其他事件，那么这个点击事件会消失，此时父元素的onTouchEvent并不会被调用，并且当前View可以持续收到后续的事件，最终这些消失的点击事件会传递给Activity处理。
-
ViewGroup默认不拦截任何事件。Android源码中ViewGroup的onInterceptTouchEvent方法默认返回false。
-
View没有onInterceptTouchEvent方法，一旦有点击事件传递给它，那么它的onTouchEvent方法就会被调用。
-
view的onTouchEvent默认都会消耗事件（返回true)，除非它是不可点击的(clickable和longClickable同时为false)，View的longClickable属性默认都为false,clickable属性要分情况，比如Button的clickable属性默认为true，而TextView的clickable属性默认为false。
-
view的enable属性不影响onTouchEvent的默认返回值。哪怕一个View是disable状态的，只要它的clickable或者longclickable有一个为true，那么它的onTouchEvent就返会true。
-
onClick会发生的前提是当前View是可点击的，并且他收到了down和up的事件。
-
事件传递过程是由外向内的，即事件总是先传递给父元素，然后再由父元素分发给子View，通过requestDisallowInterptTouchEvent方法可以在子元素中干预父元素的事件分发过程，但是ACTION_DOWN除外。
事件分发源码解析
Activity对点击事件的分发过程
MotionEvent对象表示点击事件，当一个点击操作发生时，事件最先由Activity的dispatchTouchEvent来进行事件分发，具体的工作是由Activity内部的window来完成的，window会将事件传递给decor view，decor view一般都是当前界面的底层容器（setContentView所设置的父容器），通过Activity.getWindow.getDecorView()获得，我们可用先从dispatchTouchEvent的源码看起：
public boolean dispatchTouchEvent(MotionEvent ev) {
if (ev.getAction() == MotionEvent.ACTION_DOWN) {
onUserInteraction();
}
if (getWindow().superDispatchTouchEvent(ev)) {
return true;
}
return onTouchEvent(ev);
}
首先事件分发给Activity所附属的Window进行分发，如果返回true，整个事件循环就结束了，返回false意味所有View的onTouchEvent都返回了false，那么Activity的onTouchEvent就会被调用。
window是一个抽象类，而window的super.dispatchTouchEvent(ev)也是抽象方法
public abstract boolean superDispatchTouchEvent(MotionEvent event);
Window的唯一实现类是PhoneWindow，phoneWindow将事件直接传递给了DecorView
public boolean superDispatchTouchEvent(MotionEvent ev){
return mDecor.superDispatchTouchEvent(ev);
}
通过((ViewGroup)getwindow().getDecorView().findViewByld(android.R.idcontent)).getChildAt(0))可以获取Activity所设置的View，这个mDecor显然就是getWindow().getDocorView()返回的View，而我们通过setContextView设置的View就是它的一个子View。
// This is the top-level view of the window, containing the window decor.
private DecorView mDecor;
@Override
public final View getDecorView(){
if(mDecor == null){
installDesor():
}
return mDecor;
}
目前事件传递到了DecorView这里，由于DecorView继承自FrameLayout且是父View，因此事件已经传递到顶级View(ViewGroup)了，所以最终事件会传递给View。
Activity事件分发流程图
顶级View对点击事件的分发过程
首先看ViewGroup对点击事件的分发过程，其主要实现在ViewGroup的dispatchTouchEvent方法中，这个方法比较长，这里分段说明。
先看下面一段，它描述的是当前View是否拦截点击事件这个逻辑
// 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;
}
这里有两个判断条件，一个是事件类型为ACTION_DOWN，另一个是mFirstTouchTarget!=null，ACTION_DOWN很好理解，mFirstTouchTarget!=null表示事件已经交给某个子元素来处理，当事件由ViewGroup的子元素成功处理时，mFirstTouchTarget会被赋值并指向子元素（在后面的代码逻辑可以看到）。
从上面代码可以看出，ViewGroup在当事件类型为ACTION_DOWN或者mFirstTouchTarget!=null时才会判断是否要拦截当前事件。反过来，一旦点击事件没有子元素处理则mFirstTouchTarget !=null就不成立，那么当ACTION_MOVE和ACTION_UP事件到来时，由于actionMasked == MotionEvent.ACTION_DOWN|| mFirstTouchTarget != null这个条件为false，将导致ViewGroup的onInterceptTouchEvent不会再被调用，因此后续同一序列事件都会默认交给它处理。
这里有一种特殊情况，那就是FLAG_DISALLOW_INTERCEPT标记位，这个标记位是通过requestDisallowInterceptTouchEvent方法来设置的，一般用于子View中。
FLAG_DISALLOW_INTERCEPT一旦设置后，ViewGroup将无法拦截除了ACTION_DOWN以外的其他点击事件。这是因为ViewGroup在分发事件时，如果是ACTION_DOWN就会重置 FLAG_DISALLOW_INTERCEPT这个标记位，将导致子View中设置的这个标记位无效。
// 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();
}
在上面的代码中，ViewGroup会在ACTION_DOWN事件到来时做重置的作用。而在resetTouchState方法中会对FLAG_DISALLOW_INTERCEPT进行重置，因此子View调用requestDisallowInterceptTouchEvent方法并不能影响ViewGroup对ACTION_DOWN事件的处理。
以上分析总结起来有两点：第一点，onInterceptTouchEvent不是每次事件都会被调用的，如果想提前处理所有点击事件，要选择dispatchTouchEvent方法，前提是事件能够传递到当前的ViewGroup；另外一点，在面对滑动冲突时可以考虑用FLAG_DISALLOW_INTERCEPT标记位来解决。
接着再看当ViewGroup不拦截事件的时候，事件会向下分发交由他的子View进行处理，源码如下：
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 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;
}
}
上面的代码逻辑也很清晰，首先遍历ViewGroup所有子元素，然后判断子元素是否能接受这个点击事件，并主要由两点来衡量，子元素是否在播动画和点击事件的坐标是否落在子元素的区域内，如果某个子元素满足这两个条件，那么事件就会传递给他处理（调用dispatchTransformedTouchEvent）。
private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,View child, int desiredPointerIdBits) {
final boolean handled;
...
if (child == null) {
handled = super.dispatchTouchEvent(event);
} else {
handled = child.dispatchTouchEvent(event);
}
...
}
可以看到，dispatchTransformedTouchEvent调用时，由于child传递的不是null，因此他会直接调用子元素的dispatchTouchEvent方法，这样事件就交由子元素处理处理，这就从而完成这一轮事件分发。
如果子元素的dispatchTouchEvent返回true，这时我们暂时不考虑事件在子元素的怎么分发的，那么mFirstTouchTarget就会被赋值同时跳出for循环：
newTouchTarget = addTouchTarget(child, idBitsToAssign);
alreadyDispatchedToNewTouchTarget = true;
break;
这几行代码就完成了mFirstTouchTarget的赋值并且并终止对子元素的遍历，如果子元素的dispatchTouchEvent返回false，ViewGroup就会把事件分给下一个子元素
private TouchTarget addTouchTarget(@NonNull View child, int pointerIdBits) {
final TouchTarget target = TouchTarget.obtain(child, pointerIdBits);
target.next = mFirstTouchTarget;
mFirstTouchTarget = target;
return target;
}
mFirstTouchTarget赋值过程是在addTouchTarget内部完成的，从addTouchTarget方法的内部结构可以看出，mFirstTouchTarget是一种单链表的结构，mFirstTouchTarget是否被赋值，将直接影响到ViewGroup对事件的拦截机制，如果mFirstTouchTarget为null，那么ViewGroup的默认拦截下来同一序列中所有的点击事件，这一点在前面已作分析。
如果遍历所有的子元素后事件都没有被合适的处理，这包含两种情况，第一是ViewGroup没有子元素，第二种是子元素处理了点击事件，但是在dispatchTouchEvent中返回false，这一般是因为子元素在onTouchEvent返回了false，这两种情况下，ViewGroup会自己处理点击事件，看代码：
// Dispatch to touch targets.
if (mFirstTouchTarget == null) {
// No touch targets so treat this as an ordinary view.
handled = dispatchTransformedTouchEvent(ev, canceled, null,
TouchTarget.ALL_POINTER_IDS);
}
dispatchTransformedTouchEvent调用时第三个参数child传递的是null，因此就会调用super.dispatchTouchEvent(event)，调用了它的基类View的dispatchTouchEvent方法，即点击事件开始交由View来处理。
ViewGroup事件分发流程图
View对点击事件的处理过程
View对点击事件的处理稍微简单一些，注意这里的View不包含ViewGroup，先看他的dispatchTouchEvent方法，如下所示：
public boolean dispatchTouchEvent(MotionEvent event) {
...
boolean result = false;
...
if (onFilterTouchEventForSecurity(event)) {
...
//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;
}
}
...
return result;
}
View(不包含ViewGroup)没有子元素无法向下传递事件只能自己处理，从上面可以看到，首先会判断有没有设置onTouchListener，如果onTouchListener中的onTouch返回true，那么onTouchEvent就不会被调用，可见onTouchListener的优先级高于onTouchEvent，这样做到好处就是方便在外界处理点击事件。
接着再分析onTouchEvent的实现，先看当View处于不可用的状态下点击事件的处理过程，很显然不可用状态下的View照样会消耗点击事件，尽管他看起来不可用。
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);
}
接着，如果View设置有代理，那么还会执行TouchDelegate的onTouchEvent方法，这个onTouchEvent的工作机制看起来和onTouchListener类似，这里就不深究了
if (mTouchDelegate != null) {
if (mTouchDelegate.onTouchEvent(event)) {
return true;
}
}
下面再看一下onTouchEvent中点击事件的具体处理，如下所示：
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) {
...
if (!mHasPerformedLongPress && !mIgnoreNextUpEvent) {
// This is a tap, so remove the longpress check
removeLongPressCallback();
// Only perform take click actions if we were in the pressed state
if (!focusTaken) {
// Use a Runnable and post this rather than calling
// performClick directly. This lets other visual state
// of the view update before click actions start.
if (mPerformClick == null) {
mPerformClick = new PerformClick();
}
if (!post(mPerformClick)) {
performClick();
}
}
}
break;
}
....
return true;
}
从上面的代码来看，只要View的CLICKABLE和LONG_CLICKABLE有一个为true（CONTEXT_CLICKABLE为鼠标或手写笔所用），那么它就会消耗这个事件，即onTouchEvent返回true，不管他是不是DISABLE状态，这就证实了上面的第8,9,10结论，然后就是当ACTION_UP事件发生之后，会触发performClick方法，如果View设置了onClickListener，那么performClick方法内部就会调用他的onClick方法，如下：
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;
}
View的LONG_CLICKABLE属性默认为false，而CLICKABLE属性是否为false和具体的View有关，确切的说是可点击的View其CLICKABLE为true，不可点击的为false，比如button是可点击的，textview是不可点击的。通过setClickable和setLongClick可以分别改变属性，setOnClickListener与setOnLongClickListener会自动enable属性，这点我们看源码：
public void setOnClickListener(@Nullable OnClickListener l) {
if (!isClickable()) {
setClickable(true);
}
getListenerInfo().mOnClickListener = l;
}
public void setOnLongClickListener(@Nullable OnLongClickListener l) {
if (!isLongClickable()) {
setLongClickable(true);
}
getListenerInfo().mOnLongClickListener = l;
}
View事件分发流程图
到这里，点击事件的分发机制源码就分析完了，结合理论分析和相关结论可以更好的理解事件分发机制
View的滑动冲突
常见的滑动冲突场景
常见的滑动冲突场景可以简单分为三种：
- 外部滑动方向和内部滑动方向不一致
- 外部滑动方向和内部滑动方向一致
- 上面两种情况的嵌套
从本质上来说，这三种滑动冲突场景的复杂度其实是相同的，因为它们的区别仅仅是滑动策略的不同，至于解决滑动冲突的方法，它们几个是通用的
滑动冲突的处理规则
一般来说，不管滑动冲突多么复杂，它都有既定的规则，根据这些规则我们就可以选择合适的方法去处理。
对于场景1，可以根据滑动是水平滑动还是竖直滑动来判断到底由谁来拦截事件，具体来说就是当用户左右滑动时，需要让外部的View拦截点击事件，当用户上下滑动时，需要让内部View拦截点击事件。如何区分左右滑动还是上下滑动，则可以根据滑动过程中两个点之间的坐标来计算距离差，比如竖直方向滑动的距离大就判断为竖直滑动，否则判断为水平滑动。
对于场景2，一般在业务需求上得出相应的处理规则：当处于某种状态时需要外部View响应用户的滑动，而处于另外一种状态时则需要内部View来响应View的滑动。
对于场景3，滑动规则更复杂，同样需要在业务需求上得出相应的处理规则
滑动冲突的解决方式
首先根据场景1的情况来得出通用的解决方案，然后场景2和场景3我们只需要修改有关滑动规则的逻辑即可。
1. 外部拦截法
外部拦截费是指点击事件都先经过父容器的拦截处理，如果父容器需要这个事件就拦截。外部拦截法需要重写onInterceptTouchEvent方法，伪代码如下：
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
boolean intercepted = false;
int x = (int) ev.getX();
int y = (int) ev.getY();
switch (ev.getAction()){
case MotionEvent.ACTION_DOWN:
intercepted = false;
break;
case MotionEvent.ACTION_MOVE:
if(${isParentNeedMotionEvent}){
intercepted = true;
}else {
intercepted = false;
}
break;
case MotionEvent.ACTION_UP:
intercepted = false;
break;
}
mLastXIntercept = x;
mLastYIntercept = x;
return intercepted;
}
上述代码是外部拦截法的典型逻辑，针对不同的滑动冲突，只需要修改父容器需要当前点击事件（isParentNeedMotionEvent）这个条件即可，其他均不需做修改并且也不能修改。
这里对上述代码再描述一下，首先是ACTION_DOWN这个事件，父容器必须返回false，即不拦截ACTION_DOWN事件，这是因为一旦父容器拦截了ACTION_DOWN，那么后续的ACTION_MOVE和ACTION_UP事件都会直接交由父容器处理，这个时候事件没法再传递给子元素了；其次是ACTION_MOVE事件，这个事件可以根据需要来决定是否拦截，如果父容器需要拦截就返回true，否则返回false；最后是ACTION_UP事件，这里必须要返回false，因为父容器在ACTION_UP时返回了true，会导致子元素无法接收到ACTION_UP事件，onClick事件无法触发，但是父容器比较特殊，一旦它开始拦截任何一个事件，那么后续的事件都会交给它处理，而ACTION_UP作为最后一个事件也必定可以传递给父容器，即便父容器的onInterceptTouchEvent方法在ACTION_UP时返回了false。
2. 内部拦截法
内部拦截法是指父容器不拦截任何事件，所有的事件都传递给子元素，如果子元素要消耗此事件就直接消耗掉，否则就交由父容器进行处理，这种方法和Android中的事件分发机制不一致，需要配合requestDisallowInterceptTouchEvent方法才能正常工作，使用起来较外部拦截法稍显复杂。它的伪代码如下，需要重写子元素的dispatchTouchEvent方法：
@Override
public boolean dispatchTouchEvent(MotionEvent event) {
int x = (int) event.getX();
int y = (int) event.getY();
switch (event.getAction()){
case MotionEvent.ACTION_DOWN:
parent.requestDisallowInterceptTouchEvent(true);
break;
case MotionEvent.ACTION_MOVE:
int deltaX = x - mLastX;
int deltaY = x - mLastY;
if(${isParentNeedMotionEvent}){
parent.requestDisallowInterceptTouchEvent(false);
}
break;
case MotionEvent.ACTION_UP:
break;
}
mLastX = x;
mLastY = y;
return super.dispatchTouchEvent(event);
}
上述代码就是内部拦截法的典型代码，当面对不同的滑动策略只需要修改里面的条件即可，其他不需要做改动，除了子元素需要处理之外，父元素默认也要拦截除ACTION_DOWN之外的其他事件，这样当子元素调用parent.requestDisallowInterceptTouchEvent(true)方法时，父元素才能继续拦截所需要的事件。
父容器不能拦截ACTION_DOWN事件，需要做如下修改：
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
int action = ev.getAction();
if(action == MotionEvent.ACTION_DOWN){
return false;
}else {
return true;
}
}
因为ACTION_DOWN事件并不受FLAG_DISALLOW_DOWN这个标记位的控制，所以一旦父容器拦截，那么所有的事件都无法传递到子元素中，这样额你不拦截就无法起作用了。