View事件分发机制

点击事件的传递规则

点击事件产生后，传递过程：Activity->Window->顶层View->分发到具体的View。前两个传递比较简单，不用说。顶层View一般为ViewGroup，ViewGroup会首先根据onInterceptTouchEvent判断是否拦截，如果拦截，那么就会调用自己的onTouchEvent方法进行处理，如果不拦截，就会分发给子View，子View再调用自己的dispatchTouchEvent做进一步分发。如果所有的View都不消费掉这个事件，那么会调用Activity的onTouchEvent方法来处理。

对于一个View而言，OnTouchListener的优先级高于自己的onTouchEvent方法，在onTouchEvent方法中，TouchDelegate的优先级最高，其次是OnLongClickListener（如果是长按的话），最后才是OnClickListener。

源码解析

当触摸事件发生时，Activity的dispatchTouchEvent首先被调用。

// Activity$dispatchTouchEvent
public boolean dispatchTouchEvent(MotionEvent ev) {
if (ev.getAction() == MotionEvent.ACTION_DOWN) {
onUserInteraction();
}
// 首先分发给Window去处理，如果该事件没有被消费掉，那么
// 会调用Activity的ouTouchEvent方法
if (getWindow().superDispatchTouchEvent(ev)) {
return true;
}
return onTouchEvent(ev);
}

// PhoneWindow$superDispatchTouchEvent
@Override
public boolean superDispatchTouchEvent(MotionEvent event) {
return mDecor.superDispatchTouchEvent(event);
}

// DecorView$superDispatchTouchEvent
public boolean superDispatchTouchEvent(MotionEvent event) {
return super.dispatchTouchEvent(event);
}

// ViewGroup$dispatchTouchEvent
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
...
// 出于安全考虑，如果设置了窗口被遮挡后丢弃事件的属性，那么窗口被
// 遮挡时，事件直接被丢弃，而不会分发出去。也就是说，当出现了Toast、
// 对话框等的时候，触摸事件就不会被响应了。该属性一般不会被设置。
if (onFilterTouchEventForSecurity(ev)) {
...
// 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);
// 这个方法中会重置FLAG_DISALLOW_INTERCEPT标识，该标识表示当前
// ViewGroup不能拦截触摸事件，也就是说，无论如何该标识都不能控制
// ACTION_DOWN事件的拦截
resetTouchState();
}

// 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.
// 也就是说如果ViewGorup拦截了某触摸手势的ACTION_DOWN事件后，
// 该触摸手势的后续事件都交给这个ViewGroup进行处理，不再需要用
// onInterceptTouchEvent判断是否拦截
intercepted = true;
}
...
}
}
...

// 还是ViewGroup$dispatchTouchEvent
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
...
// ViewGroup不拦截时的事件分发
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);

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

// The accessibility focus didn't handle the event, so clear
// the flag and do a normal dispatch to all children.
ev.setTargetAccessibilityFocus(false);
}
...
if (mFirstTouchTarget == null) {
// ViewGroup进行拦截或者在子View中没有处理事件时，ViewGroup
// 调用父类View的dispatchTouchEvent进行处理。
// No touch targets so treat this as an ordinary view.
handled = dispatchTransformedTouchEvent(ev, canceled, null,
TouchTarget.ALL_POINTER_IDS);
}
...
}

明显，在正常的事件（通常是ACTION_DOWN）分发时，ViewGroup会依次查询每个子View，如果子View能够接收到触摸事件，就会把事件交给该子View去处理。判断是否能接收到触摸事件有两点：view没有在播放动画，也没有准备播放动画；触摸事件的坐标处于view的范围内。子View收到事件后，会调用自己的dispatchTouchEvent来进一步分发。如果子View处理了该事件，那么mFirstTouchTarget就会在addTouchTarget方法中被赋值，并且终止事件的分发。在之前的代码中，可以看到，如果mFirstTouchTarget为null，也就是没有任何子View处理该事件（通常是ACTION_DOWN），那么接下来的所有事件都会被当前的ViewGroup拦截。

// ViewGroup$dispatchTransformedTouchEvent
private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
View child, int desiredPointerIdBits) {
...
// Perform any necessary transformations and dispatch.
if (child == null) {
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());
}
handled = child.dispatchTouchEvent(transformedEvent);
}
...
}

// View$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在处理触摸事件时，会先判断是否设置了OnTouchListener，如果设置了而且onTouch方法处理了该事件，就不再调用onTouchEvent进行处理；否则才会调用onTouchEvent。明显，onTouch优先级高于onTouchEvent。

// View$onTouchEvent
public boolean onTouchEvent(MotionEvent event) {
...
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);
}

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

if (((viewFlags & CLICKABLE) == CLICKABLE ||
(viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE) ||
(viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE) {
switch (action) {
case MotionEvent.ACTION_UP:
// 如果在ListView等可以滚动的容器中ACTION_DOWN时，
// 会有一个延迟之后，才会置位PFLAF_PRESSED，此前都是
// PFLAG_PREPRESSED被置位。
boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {
// take focus if we don't have it already and we should in
// touch mode.
boolean focusTaken = false;
if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {
focusTaken = requestFocus();
}

if (prepressed) {
// The button is being released before we actually
// showed it as pressed.  Make it show the pressed
// state now (before scheduling the click) to ensure
// the user sees it.
setPressed(true, x, y);
}

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

return false;
}

明显，只要是CLICKABLE或者LONG_CLICKABLE或者CONTEXT_CLICKABLE的，不管View是否是enabled状态，都会消费点击事件。如果View是enabled的，那么会看是否设置了代理，如果有代理，那么先调用代理的onTouchEvent方法看是否被消费掉，如果没有消费，那么才会真正由View来做处理。在ACTION_UP时如果点击事件没有被OnLongClickListener.onLongClick方法消费掉，那么就会调用OnClickListener的onClick方法。

// View$performLongClick
public boolean performLongClick() {
sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_LONG_CLICKED);

boolean handled = false;
ListenerInfo li = mListenerInfo;
if (li != null && li.mOnLongClickListener != null) {
handled = li.mOnLongClickListener.onLongClick(View.this);
}
if (!handled) {
handled = showContextMenu();
}
if (handled) {
performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
}
return handled;
}

// View$performClick
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;
}