一、事件分发简介
android核心机制，用户点击屏幕控件的时候，指尖触碰到控件，会有按下（down）、移动（move）、抬起（up）操作，这一系列操作简称为事件，看上去简单，实际上包含了复杂的事件分发逻辑。我们知道一个activity里面有viewgroup、还有view，viewgroup里面有各种view，view与view甚至还会重叠，那么系统是如何判断用户点击的是哪个控件呢？
二、事件分发原理
这里涉及到三个核心的方法：
事件分发函数：override fun dispatchTouchEvent(ev: MotionEvent?): Boolean
事件执行函数：override fun onTouchEvent(event: MotionEvent?): Boolean
事件拦截函数：override fun onInterceptTouchEvent(ev: MotionEvent?): Boolean
其中在activity中，没有事件拦截函数，因为默认根布局的事件肯定要往下分发，不需要拦截，下面会讲到，activity的分发会分发到window，然后到viewgroup；
在view中，没有事件拦截函数，因为没有子view，不需要往下传递事件；
viewgroup没有事件执行函数。
用户点击屏幕整个流程
1.调用activity的dispatchTouchEvent()，查看源码，调用到了window.dispatchTouchEvent()
public boolean dispatchTouchEvent(MotionEvent ev) {
if (ev.getAction() == MotionEvent.ACTION_DOWN) {
onUserInteraction();
}
if (getWindow().superDispatchTouchEvent(ev)) {
return true;
}
return onTouchEvent(ev);
}
这个简单易理解的吧，window层或者更下的viewgroup或者view消费了，那么返回true，表明整体消费了，如果最终发现子view没有一个愿意消费的，那么直接自己来，自己做touchEvent。为什么我说了"window层或者更下的viewgroup或者view消费了"，因为后面讲解源码的时候会发现，其实dispatchTouchEvent这个函数包含了ontouchevent和onintercepttouchevent，且在里面还会有对子view的各种遍历，只要子view消费了，就最终返回给自己所有父布局dispatchTouchEvent=true 表明消费。
window这里实际上就是PhoneWindow，查看源码，调用了mDecor，熟悉源码的知道实际上mDecor就是activtiy 的跟布局，是一个不能设置大小（默认全屏）的FrameLayout
fun superDispatchTouchEvent(event: MotionEvent?): Boolean {
return mDecor.superDispatchTouchEvent(event)
}
ok，实际上mDecor.superDispatchTouchEvent(event)这个代码调用到了viewgroup.dispatchTouchEvent了。
2.调用viewgroup.dispatchTouchEvent，二话不说，我们直接看源码，这里省略部分代码，主要看主要的逻辑，重点逻辑标记了“核心”tag的注释，其实逻辑很简单，先判断一下需不需要拦截onInterceptTouchEvent，如果不需要拦截，就对子view遍历循环，继续调用dispatchTouchEvent，如果递归下去发现子view没有了，那么走最终调用view.dispatchTouchEvent
public boolean dispatchTouchEvent(MotionEvent ev) {
//...
boolean handled = false; //核心：是否消费的标记位
if (onFilterTouchEventForSecurity(ev)) { //校验一下事件是否合理安全，可以忽略
//...
final boolean intercepted;
if (actionMasked == MotionEvent.ACTION_DOWN
|| mFirstTouchTarget != null) {
final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
if (!disallowIntercept) {
//核心：判断事件是不是需要分发给子view，注意，只有down事件时候判断一次，后面不会二次判断，所以事件down的时候被拦截了，后续所有事件都不会分发给子view了
intercepted = onInterceptTouchEvent(ev);
ev.setAction(action);
} else {
intercepted = false;
}
} else {
intercepted = true;
}
final boolean canceled = resetCancelNextUpFlag(this)
|| actionMasked == MotionEvent.ACTION_CANCEL;
final boolean isMouseEvent = ev.getSource() == InputDevice.SOURCE_MOUSE;
final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0
&& !isMouseEvent;
TouchTarget newTouchTarget = null;
boolean alreadyDispatchedToNewTouchTarget = false;
if (!canceled && !intercepted) {
//核心：如果事件没拦截也没有取消，开始对子view开始分发
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;
//....
final int childrenCount = mChildrenCount;
if (newTouchTarget == null && childrenCount != 0) {
//根据x、y的点按坐标，获取到子view
final float x = ev.getXDispatchLocation(actionIndex);
final float y = ev.getYDispatchLocation(actionIndex);
final ArrayList<View> preorderedList = buildTouchDispatchChildList();
final boolean customOrder = preorderedList == null
&& isChildrenDrawingOrderEnabled();
final View[] children = mChildren;
for (int i = childrenCount - 1; i >= 0; i--) {
final int childIndex = getAndVerifyPreorderedIndex(
childrenCount, i, customOrder);
//获取子view
final View child = getAndVerifyPreorderedView(
preorderedList, children, childIndex);
//....
if (!child.canReceivePointerEvents()
|| !isTransformedTouchPointInView(x, y, child, null)) {
ev.setTargetAccessibilityFocus(false);
continue;
}
newTouchTarget = getTouchTarget(child);
//...
//核心！！：这里开始对子view进行分发，我们接下来看一下dispatchTransformedTouchEvent源码
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 = x;
mLastTouchDownY = y;
newTouchTarget = addTouchTarget(child, idBitsToAssign);
alreadyDispatchedToNewTouchTarget = true;
break; //核心：当循环到需要消费的子view的时候，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;
}
}
}
// 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);
} 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;
}
}
//....
}
if (!handled && mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onUnhandledEvent(ev, 1);
}
return handled;
}
看一下分发子view的api dispatchTransformedTouchEvent源码
private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
View child, int desiredPointerIdBits) {
final boolean handled;
// Canceling motions is a special case. We don't need to perform any transformations
// or filtering. The important part is the action, not the contents.
final int oldAction = event.getAction();
if (cancel || oldAction == MotionEvent.ACTION_CANCEL) {
event.setAction(MotionEvent.ACTION_CANCEL);
if (child == null) {
//如果child为空，那么直接调用view.dispatchTouchEvent，由于viewgroup是继承view的，所以viewgroup这种情况下就调用自己的ontouchevent
handled = super.dispatchTouchEvent(event);
} else {
//否则继续调用viewgroup.dispatchTouchEvent或者view.dispatchTouchEvent，取决于进来的参数view是不是viewgroup，viewgroup和view的分发逻辑不太一样，注意区分
handled = child.dispatchTouchEvent(event);
}
event.setAction(oldAction);
return handled;
}
//......
return handled;
}
3.调用View.dispatchTouchEvent
那么最终就调用到了View.dispatchTouchEvent，不多说，show me code！其实代码比较简单，因为是view了，所以没有判断事件分发逻辑，直接判断如果设置了ontouchListener且onTouch返回了true就消费，且不调用ontouchevent（如果if(A&&B)，A为false，B是不会再执行判断结果，这是短路求值（short-circuit evaluation）的特性），如果ontouch返回了false，走onTouchEvent再次判断是否消费。
最终的result结果回溯给父布局dispatchTouchEvent
public boolean dispatchTouchEvent(MotionEvent event) {
//...
boolean result = false;
if (mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onTouchEvent(event, 0);
}
//...
if (onFilterTouchEventForSecurity(event)) { //判断是否是安全触摸事件
if ((mViewFlags & ENABLED_MASK) == ENABLED && handleScrollBarDragging(event)) {
result = true;
}
//核心！！：如果ontouch事件不为空，且ontouch事件返回了true，那么ontouchevent不执行
ListenerInfo li = mListenerInfo;
if (li != null && li.mOnTouchListener != null
&& (mViewFlags & ENABLED_MASK) == ENABLED
&& li.mOnTouchListener.onTouch(this, event)) {
result = true;
}
//核心！！：上述条件不成立，开始执行ontouchevent，如果ontouchevent=true，表明消费，最终result=true，最终回溯给父布局，最终dispatchTouchEvent=true
if (!result && onTouchEvent(event)) {
result = true;
}
}
//....
return result;
}
4.调用到View.onTouchEvent()，这里贴一下关键源码即可，实际上就是判断一下这个view是否可点击，一般view可点击返回true表示消费，回调给view.dispatchTouchEvent，再回调给viewGroup.dispatchTouchEvent，最终回调给activity.dispatchTouchEvent
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的clickable事件
final boolean clickable = ((viewFlags & CLICKABLE) == CLICKABLE
|| (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
|| (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE;
if ((viewFlags & ENABLED_MASK) == DISABLED
&& (mPrivateFlags4 & PFLAG4_ALLOW_CLICK_WHEN_DISABLED) == 0) {
if (action == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
setPressed(false);
}
mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
return clickable;
}
if (mTouchDelegate != null) {
//代理事件
if (mTouchDelegate.onTouchEvent(event)) {
return true;
}
}
//可点击的条件下，up、move等事件才会被调用
if (clickable || (viewFlags & TOOLTIP) == TOOLTIP) {
switch (action) {
case MotionEvent.ACTION_UP:
//...
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) {
if (mPerformClick == null) {
mPerformClick = new PerformClick();
}
if (!post(mPerformClick)) {
performClickInternal(); //这里可以看到click事件，所以就明白为什么点击事件都是等松开手的时候才执行（up）
}
}
}
//...
mIgnoreNextUpEvent = false;
break;
case MotionEvent.ACTION_DOWN:
//....
break;
case MotionEvent.ACTION_CANCEL:
//..
break;
case MotionEvent.ACTION_MOVE:
//...
break;
}
return true;
}
return false;
}
还有一个问题，目前很多博客都单纯写了一句话略过：
“ViewGroup的dispatchTouchEvent方法接收到事件消息，首先会去调用onInterceptTouchEvent判断是否拦截事件，如果拦截，则调用自身的onTouchEvent方法”
这句话理解起来很容易，但是代码呢？我找了很长时间代码，都没找到这一块逻辑！！！！！！！太坑了，后来看了一下源码大概知道了。贴下一下源码，所以可以看到拦截的情况下，mFirstTouchTarget一直没有赋值，所以最终调用super.dispatchTouchEvent(event);即调用到了view的方法， 然后view的方法里有onTouchEvent，所以上述那个疑问迎刃而解了
//被拦截的情况下，mFirstTouchTarget一直为空，mFirstTouchTarget赋值只有在不被拦截的代码逻辑里，具体可以看源码
if (mFirstTouchTarget == null) {
// No touch targets so treat this as an ordinary view.
handled = dispatchTransformedTouchEvent(ev, canceled, null, TouchTarget.ALL_POINTER_IDS);
}
事件分发流程图
这个流程图直接挪用网上的好了，实际上个人觉得是有一点问题的，调用顺序是没问题，但是缺少了很多细节，这边做一个具体的补充吧
逻辑1.viewgroup的dispatchtouchevnt中判断是否拦截onInterceptTouchEven，返回false后，由于mFirstTouchTarget==null，所以dispatchtouchEvent中会调用到dispatchTransformedTouchEvent(ev, canceled, null,TouchTarget.ALL_POINTER_IDS)，最终执行了viewgroup自己的onTouchEvent
逻辑2.dispatchtouchevent返回false表示自己的所有子view都没有消费，虽然没有拦截，但是最后代码中mFirstTouchTarget一直没有赋值到，因为所有的子view调用的dispatchTransformedTouchEvent->dispatchtouchevent都为false，走不了赋值的逻辑，最终和逻辑1一样，执行了自己的viewgroup.onTouchEvent
逻辑3.和逻辑2同理，ontouchEvent实际上就是在view.dispatchtouchevent中的，自己的子view调用了一遍发现没消费，那么自己最后又调用dispatchTransformedTouchEvent->dispatchtouchevent->onTouchEvent，走了自己的onTouchEvent，尝试一下自己能不能消费
问题总结
1.为什么当前的viewgroup被消费了，事件不会往下分发了呢？
查看下面源码，这是对所有子view事件分发的逻辑，如果一个viewgroup被消费了，那么父布局的事件分发逻辑里，调用getTouchTarget方法获取不为null，然后break，停止向下分发
for (int i = childrenCount - 1; i >= 0; i--) {
//...
//重点逻辑，如果当前view已经被消费了，那么newTouchTarget不为null，直接break，不需要走下面的逻辑分发事件了
//参考文献：https://zhuanlan.zhihu.com/p/76655500
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)) {
//开始分发
break;
}
}
案例：以下图布局为例，假设在MySubRootLayout消费了事件，那么用户点击ImageView后，产生产生的逻辑如下：
按下：MyRootLayout.dispatchTouchEvent——>MySubRootLayout.dispatchTouchEvent——>ImageView.dispatchTouchchEvent——>ImageView.onTouchEvent；走的是Action.down——>MySubRootLayout.onTouchEvent；走的是Action.down，判断到要消费了，这时候条件满足，mFirstTouchTarget != null，不会继续走父布局的onTouchEvent——>所有布局的dispatchTouchEvent返回true；
抬起：MyRootLayout.dispatchTouchEvent——>MySubRootLayout.dispatchTouchEvent；因为消费了，所以不再往下分发了—>MySubRootLayout.onTouchEvent；走的是Action.up，所有布局的dispatchTouchEvent返回true
2.为什么我的view只走了action.down，没有走up
因为view没有消费，不消费了，mFirstTarget == null，默认ontouchEvent给父布局调用尝试消费，解决方法是设置可点击、或者ontouchEvent返回true、或者ontouch返回true
3.当viewgroup下所有view都没有消费的时候，自己的ontouchEvent是怎么回调到的
看如下代码，只有消费了，mFirstTouchTarget才会赋值，如果遍历一遍发现都没有消费，即dispatchTransformedTouchEvent都是false，那么自然这个if条件走不进入，所以mFirstTouchTargert必然为空
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 = x;
mLastTouchDownY = y;
newTouchTarget = addTouchTarget(child, idBitsToAssign); //核心重点，这里会给mFirstTouchTargert赋值
alreadyDispatchedToNewTouchTarget = true;
break;
}
if (mFirstTouchTarget == null) {
//这里就调用viewgroup的ontouchEvent了
handled = dispatchTransformedTouchEvent(ev, canceled, null,TouchTarget.ALL_POINTER_IDS);
}
结论：
ViewGroup会遍历所有子View去寻找能够处理点击事件的子View（可见，没有播放动画，点击事件坐标落在子View内部）最终调用子View的dispatchTouchEvent方法处理事件
当子View处理了事件则mFirstTouchTarget 被赋值，并终止子View的遍历，同时父view也不会执行onTouchEvent尝试消费（因为mFirstTouchTarget != null）
如果ViewGroup并没有子View或者子View处理了事件，但是子View的dispatchTouchEvent返回了false（一般是子View的onTouchEvent方法返回false）那么ViewGroup会去处理这个事件（本质调用View的dispatchTouchEvent去处理）
参考：https://blog.csdn.net/u010302764/article/details/72636459
扫一扫
640
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
