View的事件分发机制
首先分析的对象是MotionEvent，点击事件。最关键的三个方法：dispatchTouchEvent，onInterceptTouchEvent,onTouchEvent
翻译成中文就是，分发事件、拦截事件、处理事件，先看三者的关系，然后我们在细分讲解
public boolean dispatchTouchEvent(MotionEvent ev) {
boolean consume=false;
if (onInterceptTouchEvent(ev)){
consume=onTouchEvent(ev);
}else {
consume=child.dispatchTouchEvent(ev);
}
return consume;
}
public boolean dispatchTouchEvent(MotionEvent ev)
用于进行事件分发，如果当前事件能够传递到当前View，这个方法一定会被调用，返回值收当前View的onTouchEvent和下级View的dispatchTouchEvent方法影响，表示是否消耗当前事件
public boolean onInterceptTouchEvent(MotionEvent ev)
内部调用，用来判断当前View拦截事件，如果当前view拦截了事件，那么同个事件序列中，此方法不会再次被调用
public boolean onTouchEvent(MotionEvent ev)
用来处理点击事件，返回结果表示是否消耗当前事情，如果不消耗，在同一个事件序列中，当前View无法再次接收到事件。
当一个View需要处理事件时，View如果设置onTouchListenter，那么onTouchListenter的onTouch方法会被回调，这时候如果返回FALSE，那么当前View的onTouchEvent会被调用。由此可见，onTouch优先级高于onTouchEvent，在onTouchEvent中，如果设置了onClickListener，那么onClick方法会被调用，因此
onClickListener优先级最低，处于事件传递的尾端。
点击事件传递过程：Activity -> WIndow -> View
责任链模式，如果最顶级的View都没处理这个事件，那么父容器的onTouchEvent将会被调用，一直到Activity的onTouchEvent处理。
总结：
1.事件从down事件开始，不定数move事件，up事件结束，很好理解，手指从触摸-移动-抬起完成事件流程。
2.一个事件只能由一个view处理，除非通过其他强制手段将事件在转给其他View.
3.某个View一旦决定拦截，那么同个事件序列中，onInterceptTouchEvent此方法不会再次被调用。
4.某个view一旦开始处理事件，不消耗ACTION_DOWN事件（onTouchEvent返回了false）,那么同一序列的其他事件都不会再交给它处理，而是交个它的父元素onTouchEvent。
5.某个view消耗ACTION_DOWN事件，没消耗其他事件,这个点击事件会消失，父元素onTouchEvent也不会调用，而是传递给Activity处理。
6.ViewGroup默认不拦截任何事件。
7.View没有onInterceptTouchEvent方法，默认直接调用onTouchEvent。（因为它没有子布局）
8.View默认消耗事件，onTouchEvent返回true,除非它不可以点击（clickable和longClicable同时为false）。
9.View的enable属性不影响onTouchEvent返回true。
10.onClick会发生的前提是View可以点击的。
11.事件传递由外向内，总是先传递给父元素，再由父元素分发给子View，子View可以通过requestDisallowInterceptTouchEvent方法可以干预父元素分发过程，ACTION_DOWN事件除外。
源码分析
1.Activity对点击事件的分发过程
public boolean dispatchTouchEvent(MotionEvent ev) {
if (ev.getAction() == MotionEvent.ACTION_DOWN) {
onUserInteraction();
}
if (getWindow().superDispatchTouchEvent(ev)) {
return true;
}
return onTouchEvent(ev);
}
首先事件开始交给
这里的逻辑十分简单，先判断down事件并触发onUserInteraction()，之后就是把事件传递给所依附的window进行分发，根据处理结果决定是否再交给activity的onTouchEvent()处理。
onUserInteraction是一个空方法，对事件分发无影响。
然后看一下window中的事件分发源码，
window是如何分发给
ViewGroup的，
这里看到是一个抽象方法，所以我们需要找到实现window的子类
public abstract class Window {
public abstract boolean superDispatchTouchEvent(MotionEvent event);}
而PhoneWindow就是window的唯一实现子类，那继续到phoneWindow中找：
public class PhoneWindow extends Window implements MenuBuilder.Callback {
@Override
public boolean superDispatchTouchEvent(MotionEvent event) {
return mDecor.superDispatchTouchEvent(event);
}}
PhoneWindow将事件直接传递给了
DecorView，
DecorView就是我们布局里面的父布局。
DecorView继承FrameLayout而且是父View，最终事件传递给View.
2.顶级View对事件的分发过程
事件到了ViewGroup 后，调用dispatchTouchEvent方法，进入之前我们说的父到子View的一个分发流程。
public abstract class ViewGroup extends View implements ViewParent, ViewManager {
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
/**省略部分代码**/
// Handle an initial down.
if (actionMasked == MotionEvent.ACTION_DOWN) {
//开始新的触摸手势时，放弃所有以前的状态。
//framework可能已放弃上一个手势的up或cancel事件
//由于应用程序切换、ANR或某些其他状态更改。
cancelAndClearTouchTargets(ev);
resetTouchState();
}
// Check for interception.
final boolean intercepted;
if (actionMasked == MotionEvent.ACTION_DOWN
|| mFirstTouchTarget != null) {//按下去的时候mFirstTouchTarget如果没有赋值，则后面事件就被拦截
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 {
//没有接触目标，此动作不是初始下降
//因此，该视图组继续拦截触摸。
intercepted = true;
}
/**省略部分代码**/
}}
从上面代码看，ViewGroup两种情况是否需要拦截：ACTION_DOWN或者mFirstTouchTarget != null，ACTION_DOWN代表事件开始，mFirstTouchTarget != null代表
ViewGroup的子元素处理成功，mFirstTouchTarget会被赋值并指向子元素。反之，如果
ViewGroup拦截时，mFirstTouchTarget将会为空，同一序列将都会交给它处理。
在往下看，可以看到FLAG_DISALLOW_INTERCEPT标记位，这个子View可以通过requestDisallowInterceptTouchEvent方法设置，为何ACTION_DOWN改变不了，看代码开始的时候就已经处理了actionMasked == MotionEvent.ACTION_DOWN事件，重置了FLAG_DISALLOW_INTERCEPT标记位，导致设置无效。所以当ACTION_DOWN事件来临时候，
ViewGroup总是会调用自己的onInterceptTouchEvent来询问自己是否需要拦截事件。
代码接着往下走，接下来是子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 = buildTouchDispatchChildList();
final boolean customOrder = preorderedList == null
&& isChildrenDrawingOrderEnabled();
final View[] children = mChildren;
//遍历子View
for (int i = childrenCount - 1; i >= 0; i--) {
final int childIndex = getAndVerifyPreorderedIndex(
childrenCount, i, customOrder);
final View child = getAndVerifyPreorderedView(
preorderedList, children, childIndex);
//如果有一个视图具有可访问性焦点，我们需要它要先获取事件，
//如果未处理，我们将执行正常调度。
//我们可以进行双重迭代，但这是考虑到时间框架，更安全。
if (childWithAccessibilityFocus != null) {
if (childWithAccessibilityFocus != child) {
continue;
}
childWithAccessibilityFocus = null;
i = childrenCount - 1;
}
//判断view是否能接受点击事件
//判断点击区域是不是在view的范围内
//其中有一项不符合，就标记不合适并继续找下一个
if (!child.canReceivePointerEvents()
|| !isTransformedTouchPointInView(x, y, child, null)) {
ev.setTargetAccessibilityFocus(false);
continue;
}
newTouchTarget = getTouchTarget(child);
if (newTouchTarget != null) {
//孩子已经在自己的范围内受到了触碰。
//除了它正在处理的指针之外，还要给它一个新指针。
newTouchTarget.pointerIdBits |= idBitsToAssign;
break;
}
resetCancelNextUpFlag(child);
if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
//子view希望在自己的范围内得到触摸。
mLastTouchDownTime = ev.getDownTime();
if (preorderedList != null) {
//childIndex指向预排序列表，查找原始索引
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);
//设置已经处理了Down事件
alreadyDispatchedToNewTouchTarget = true;
break;
}
// 可访问性焦点没有处理事件，非常清楚
//标记并对所有子项执行正常调度。
ev.setTargetAccessibilityFocus(false);
}
if (preorderedList != null) preorderedList.clear();
}
首先遍历ViewGroup的所有子元素，然后判断子元素是否能够接收到点击事件：子元素是否在播动画和点击事件的坐标是否落在子元素的区域内。
dispatchTransformedTouchEvent其实就是调用了子元素的dispatchTouchEvent方法，如果子元素返回了ture，那么会跳出for循环
if (child == null) {
handled = super.dispatchTouchEvent(event);
} else {
handled = child.dispatchTouchEvent(event);
}
如果子元素返回了true，那么mFirstTouchTarget会被赋值同时跳出循环
newTouchTarget = addTouchTarget(child, idBitsToAssign);
alreadyDispatchedToNewTouchTarget = true;
break;
mFirstTouchTarget真正赋值在addTouchTarget内部完成的，其实是一种单链表结构，mFirstTouchTarget是否为null，直接影响到ViewGroup对事件的拦截策略，为空时ViewGroup就默认拦截接下来同一序列的所有点击事件。意味分发过程，只有点击下去的时候会判断一遍，后面同一序列的移动和抬起，一起处理
/**
*将指定子对象的触摸目标添加到列表的开头。
*假设目标子项尚未存在。
*/
private TouchTarget addTouchTarget(@NonNull View child, int pointerIdBits) {
final TouchTarget target = TouchTarget.obtain(child, pointerIdBits);
target.next = mFirstTouchTarget;
mFirstTouchTarget = target;
return target;
}
最后事件没有被处理，两种情况：1.ViewGroup没有子元素；2.子元素处理了点击事件，但是在dispatchTouchEvent中返回了false，这是因为子元素onTouchEvent返回了false。这两种情况下，ViewGroup自己处理点击事件：
if (mFirstTouchTarget == null) {
// 无接触目标，因此将其视为普通视图。
handled = dispatchTransformedTouchEvent(ev, canceled, null,
TouchTarget.ALL_POINTER_IDS);
}
第三个元素child为空，这就导致调用了super.dispatchTouchEvent(event)方法，也就是ViewGroup的父类View的dispatchTouchEvent方法处理，接下来我们看view的处理。
3.
view
对事件的处理过程
这里的View不包括ViewGroup，首先看dispatchTouchEvent分发过程
public boolean dispatchTouchEvent(MotionEvent event) {
// 事件应首先由辅助功能焦点处理。
if (event.isTargetAccessibilityFocus()) {
// 我们没有焦点或者虚拟后代没有焦点，请不要处理事件。
if (!isAccessibilityFocusedViewOrHost()) {
return false;
}
//我们聚焦并获取事件，然后使用正常事件调度。
event.setTargetAccessibilityFocus(false);
}
boolean result = false;
if (mInputEventConsistencyVerifier != null) {//输入事件一致性验证器
mInputEventConsistencyVerifier.onTouchEvent(event, 0);
}
final int actionMasked = event.getActionMasked();
if (actionMasked == MotionEvent.ACTION_DOWN) {
// 新姿态的防御性清理,停止滚动
stopNestedScroll();
}
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监听，返回true才会消耗事件
result = true;
}
if (!result && onTouchEvent(event)) {//没有OnTouchListener监听才会调用onTouchEvent事件，返回true才会消耗事件
result = true;
}
}
if (!result && mInputEventConsistencyVerifier != null) {//通知验证器给定的事件未处理，其余的应忽略事件的跟踪。
mInputEventConsistencyVerifier.onUnhandledEvent(event, 0);
}
//如果这是一个手势的结束，在嵌套的滚动之后清理；
//如果我们尝试了一个动作，但我们不想要其他动作，也可以取消它手势
if (actionMasked == MotionEvent.ACTION_UP ||
actionMasked == MotionEvent.ACTION_CANCEL ||
(actionMasked == MotionEvent.ACTION_DOWN && !result)) {
stopNestedScroll();
}
return result;
}
View是一个单独的元素，因此只能自己处理事件，上面看出处理过程，首先判断有没有设置mOnTouchListener，如果mOnTouchListener里面的onTouch方法返回了true，那么onTouchEvent将不被调用，这样的好处是方便在外界处理点击事件。
接下来在分析
onTouchEvent的实现，首先看View处于不可用的情况下依然会消耗掉点击事件，还有就是是CLICKABLE和LONG_CLICKABLE有一个为true,就会消耗事件，
onTouchEvent返回true；
final boolean clickable = ((viewFlags & CLICKABLE) == CLICKABLE
|| (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
|| (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE;
if ((viewFlags & ENABLED_MASK) == DISABLED) {
if (action == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
setPressed(false);
}
mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
//可单击的禁用视图仍然会使用触摸事件，它只是不响应这些事件
return clickable;
}
如果view设置有代理，还会执行mTouchDelegate的onTouchEvent方法，类似OnTouchListener
if (mTouchDelegate != null) {
if (mTouchDelegate.onTouchEvent(event)) {
return true;
}
}
接下来是
onTouchEvent中对点击事件的具体处理，比较多代码。
if (clickable || (viewFlags & TOOLTIP) == TOOLTIP) {
switch (action) {
case MotionEvent.ACTION_UP:
mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
if ((viewFlags & TOOLTIP) == TOOLTIP) {
handleTooltipUp();
}
if (!clickable) {//没有被点击，就跳出并重置
removeTapCallback();
removeLongPressCallback();
mInContextButtonPress = false;
mHasPerformedLongPress = false;
mIgnoreNextUpEvent = false;
break;
}
boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {
//检查焦点，没有获取需要获取焦点
boolean focusTaken = false;
if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {
focusTaken = requestFocus();
}
if (prepressed) {
//按钮在我们实际显示为按下之前就被释放了。现在（在安排单击之前）使其显示按下的状态，以确保用户看到它
setPressed(true, x, y);
}
if (!mHasPerformedLongPress && !mIgnoreNextUpEvent) {
// 移除长按回调
removeLongPressCallback();
//仅当我们处于按下状态时才执行“采取单击”操作
if (!focusTaken) {
// 使用Runnable并发布此消息，而不是直接调用performClick。这使视图的其他可视状态可以在单击操作开始之前更新。
if (mPerformClick == null) {
mPerformClick = new PerformClick();
}
if (!post(mPerformClick)) {//通过POST将runnable将在用户界面线程上运行
performClickInternal();//失败通常是因为正在退出处理消息队列的循环器，在当前线程执行
}
}
}
if (mUnsetPressedState == null) {
mUnsetPressedState = new UnsetPressedState();
}
if (prepressed) {//延迟取消前面按下的状态
postDelayed(mUnsetPressedState,
ViewConfiguration.getPressedStateDuration());
} else if (!post(mUnsetPressedState)) {
// 如果post失败，请立即取消
mUnsetPressedState.run();
}
removeTapCallback();
}
mIgnoreNextUpEvent = false;
break;
case MotionEvent.ACTION_DOWN:
if (event.getSource() == InputDevice.SOURCE_TOUCHSCREEN) {
mPrivateFlags3 |= PFLAG3_FINGER_DOWN;
}
mHasPerformedLongPress = false;
if (!clickable) {//如果已经点击，那么将长按事件放入延迟线程，结束流程
checkForLongClick(ViewConfiguration.getLongPressTimeout(),x, y,TOUCH_GESTURE_CLASSIFIED__CLASSIFICATION__LONG_PRESS);
break;
}
if (performButtonActionOnTouchDown(event)) {//（事件来源鼠标）在事件期间执行与按钮相关的操作。
break;
}
//沿着层次结构向上走，确定我们是否在滚动容器中。
boolean isInScrollingContainer = isInScrollingContainer();
//对于滚动容器内的视图，如果这是滚动，则将按下的反馈延迟一小段时间。
if (isInScrollingContainer) {
mPrivateFlags |= PFLAG_PREPRESSED;
if (mPendingCheckForTap == null) {
mPendingCheckForTap = new CheckForTap();
}
mPendingCheckForTap.x = event.getX();
mPendingCheckForTap.y = event.getY();
postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
} else {
// 不在滚动容器中，因此立即显示反馈
setPressed(true, x, y);
checkForLongClick(ViewConfiguration.getLongPressTimeout(),x,y,TOUCH_GESTURE_CLASSIFIED__CLASSIFICATION__LONG_PRESS);
}
break;
case MotionEvent.ACTION_CANCEL://触摸取消时处理
if (clickable) {
setPressed(false);
}
removeTapCallback();
removeLongPressCallback();
mInContextButtonPress = false;
mHasPerformedLongPress = false;
mIgnoreNextUpEvent = false;
mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
break;
case MotionEvent.ACTION_MOVE:
if (clickable) {
drawableHotspotChanged(x, y);//每当视图热点发生更改并且需要传播到由视图管理的可绘制视图或子视图时，都会调用此函数。
}
final int motionClassification = event.getClassification();
final boolean ambiguousGesture = motionClassification == MotionEvent.CLASSIFICATION_AMBIGUOUS_GESTURE;
int touchSlop = mTouchSlop;
if (ambiguousGesture && hasPendingLongPressCallback()) {
if (!pointInView(x, y, touchSlop)) {
//这里的默认操作是取消长按。但是，我们只是在这里延长超时时间，以防分类不明确。
removeLongPressCallback();
long delay = (long) (ViewConfiguration.getLongPressTimeout()
* mAmbiguousGestureMultiplier);
//减去已经花费的时间
delay -= event.getEventTime() - event.getDownTime();
checkForLongClick(delay,x,y,TOUCH_GESTURE_CLASSIFIED__CLASSIFICATION__LONG_PRESS);
}
touchSlop *= mAmbiguousGestureMultiplier;
}
// 在按钮外移动时要小心
if (!pointInView(x, y, touchSlop)) {
// 外部按钮,删除任何未来长按/点击检查
removeTapCallback();
removeLongPressCallback();
if ((mPrivateFlags & PFLAG_PRESSED) != 0) {
setPressed(false);
}
mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
}
final boolean deepPress = motionClassification == MotionEvent.CLASSIFICATION_DEEP_PRESS;
if (deepPress && hasPendingLongPressCallback()) {
// 立即处理长单击操作
removeLongPressCallback();
checkForLongClick(0 /* send immediately */,x,y,TOUCH_GESTURE_CLASSIFIED__CLASSIFICATION__DEEP_PRESS);
}
break;
}
return true;
可以看到ACTION_UP事件发生时，会触发performClickInternal里面的performClick()方法，如果View设置了OnClickListener，那么onClick方法会被调用。
//注意：视图上的其他方法不应直接调用此方法，而应调用performClickInternal（），以确保在必要时通知自动填充管理器（因为子类可以在不调用super.performClick（）的情况下扩展此方法）。
public boolean performClick() {
//我们仍然需要调用此方法来处理外部调用performClick（）而不是通过performClickInternal（）调用performClick（）的情况
notifyAutofillManagerOnClick();
final boolean result;
final ListenerInfo li = mListenerInfo;
if (li != null && li.mOnClickListener != null) {
playSoundEffect(SoundEffectConstants.CLICK);
li.mOnClickListener.onClick(this);//调用onClick事件
result = true;
} else {
result = false;
}
sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
notifyEnterOrExitForAutoFillIfNeeded(true);
return result;
}
长按事件流程，延迟执行CheckForLongPress对象run，在CheckForLongPress对象里面run方法执行performLongClick方法，performLongClick最终检查ListenerInfo里面是否有OnLongClickListener监听，有监听就调用onLongClick方法。
private void checkForLongClick(long delay, float x, float y, int classification) {
...
if (mPendingCheckForLongPress == null) {
mPendingCheckForLongPress = new CheckForLongPress();//初始化长按事件对象
}
...
postDelayed(mPendingCheckForLongPress, delay);
}
}
private final class CheckForLongPress implements Runnable {
...
@Override
public void run() {
..
if (performLongClick(mX, mY)) {//长按事件
mHasPerformedLongPress = true;
}
..
}
...
}
public boolean performLongClick(float x, float y) {
..
final boolean handled = performLongClick();
..
return handled;
}
private boolean performLongClickInternal(float x, float y) {
...
final ListenerInfo li = mListenerInfo;
if (li != null && li.mOnLongClickListener != null) {//长按事件监听回调
handled = li.mOnLongClickListener.onLongClick(View.this);
}
...
return handled;
}
长按事件LongClickable默认是False，而点击事件Clickable默认和具体View有关系，例如Button和TextView，这两个属性都可以通过设置监听而改变。
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;
}
到这里流程基本分析结束。
扫一扫
640
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
