Android 事件分发详解
- 基于 android 29
要想自定义 View 玩的溜，事件分发肯定是必须要了解的，本文将带你看源码弄明白啥是事件，它又是咋分发的！
Activity 层
事件分发首先是先从 Activity 中的 dispatchTouchEvent 开始的。
在这个方法中会判断事件是否是 ACTION_DOWN 事件，如果是会回调 onUserInteraction 方法，开发时可以重写这个方法可以用来监听事件的开始，接下来会调用 getWindow().superDispatchTouchEvent() ，其中 getWindow 实际获取的是 PhoneWindow，而 PhoneWindow中的 superDispatchTouchEvent 实际调用的是 DecorView 中的 superDispatchTouchEvent，DecorView 中的 superDispatchTouchEvent 实际调用的是 ViewGroup 中的 dispatchTouchEvent。
public boolean dispatchTouchEvent(MotionEvent ev) {
if (ev.getAction() == MotionEvent.ACTION_DOWN) {
// 这是个空方法，可以在 Activity 中重写，用于监听用户的操作
onUserInteraction();
}
// 这里的 getWindow 获取到的是 PhoneWindow，
// 实际调用了 PhoneWindow 中的 superDispatchTouchEvent
// PhoneWindow 中的 superDispatchTouchEvent
// 实际调用的是 DecorView 中的 superDispatchTouchEvent
// DecorView 中的 superDispatchTouchEvent
// 实际调用的是 ViewGroup 中的 dispatchTouchEvent
if (getWindow().superDispatchTouchEvent(ev)) {
return true;
}
// 如果上面的事件没有被处理则会进这里
// 这里会判断当前点击区域是否应该关闭 Activity，若是则会关闭并返回 true
return onTouchEvent(ev);
}
ViewGroup 层
接下来就走到了 ViewGroup 中的 dispatchTouchEvent 方法了，我这里讲主要流程，因为实在是太多啦。
首先 ViewGroup 会 调用 onFilterTouchEventForSecurity 判断自己是否可以调度事件，接下来会获取 action 和 actionMasked，如果 actionMasked 就是 ACTION_DOWN 的话就说明是一个事件序列的开始，会将 mFirstTouchTarget 置位 null，并重置 mGroupFlags 标记。接下来会判断事件是否被拦截，首先会通过通过 mGroupFlags 标记判断是否允许拦截，若允许拦截就会调用 onInterceptTouchEvent 方法，开发时可以通过重写这个方法去定义 ViewGroup 的事件拦截规则。接下来就会判断若事件既没有取消也没有被拦截的情况下就会，再判断一次当前事件是否是 ACTION_DOWN ，若是的话，会先倒序遍历子 View 集合，并获取到可以接收事件的子 View，并且判断该子 View 是否可以处理该事件，如果可以，就会将该 View 添加到 mFirstTouchTarget 链表中。后续就会直接拿之前生成的链表去分发事件了，相当于节省了每次的遍历。在分发时调用的是 dispatchTransformedTouchEvent 方法，要注意这个方法会判断传入的子 View 是否为空，若为空时会调用自己父类的 dispatchTouchEvent，否则是调用子 View 的 dispatchTouchEvent。
public boolean dispatchTouchEvent(MotionEvent ev) {
if (mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onTouchEvent(ev, 1);
}
if (ev.isTargetAccessibilityFocus() && isAccessibilityFocusedViewOrHost()) {
ev.setTargetAccessibilityFocus(false);
}
boolean handled = false;
// 判断自己是否可以调度事件
if (onFilterTouchEventForSecurity(ev)) {
// 获取当前的行为
final int action = ev.getAction();
// 获取当前行为（如果在单触点下和 action 是一致的）
// 这句话作用相当于调了 MotionEvent 中的 getActionMasked，
// 但是由于之前调了 getAction 这里直接 & 可以减少一次 native 调用
final int actionMasked = action & MotionEvent.ACTION_MASK;
// 这一段作用是在事件开始前先清除所有的目标，并且重置状态，相当于先初始化
if (actionMasked == MotionEvent.ACTION_DOWN) {
// 这里会调用 clearTouchTargets 将 mFirstTouchTarget 设置为 null
cancelAndClearTouchTargets(ev);
// 这里会重置 mGroupFlags 的标记
resetTouchState();
}
// 接下来这一段是判断是否要拦截
final boolean intercepted;
// 这句话就说明了拦截判断是从 ACTION_DOWN 开始的
if (actionMasked == MotionEvent.ACTION_DOWN
|| mFirstTouchTarget != null) {
// 通过 mGroupFlags 标记判断是否允许拦截，若为 true 则不允许拦截
final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
if (!disallowIntercept) {
// 这里可以通过重写 onInterceptTouchEvent 对需要拦截的行为做处理
intercepted = onInterceptTouchEvent(ev);
ev.setAction(action); // restore action in case it was changed
} else {
intercepted = false;
}
} else {
intercepted = true;
}
if (intercepted || mFirstTouchTarget != null) {
ev.setTargetAccessibilityFocus(false);
}
// 检查事件是否被取消
final boolean canceled = resetCancelNextUpFlag(this)
|| actionMasked == MotionEvent.ACTION_CANCEL;
// 判断是否有多个触点
final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0;
TouchTarget newTouchTarget = null;
boolean alreadyDispatchedToNewTouchTarget = false;
if (!canceled && !intercepted) {
View childWithAccessibilityFocus = ev.isTargetAccessibilityFocus()
? findChildWithAccessibilityFocus() : null;
// 判断是否是 ACTION_DOWN：按下，
// 或 ACTION_POINTER_DOWN：有新的触点按下，
// 或 ACTION_HOVER_MOVE：指针移动到这个位置但没有按下（如用鼠标悬停在这里）
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;
removePointersFromTouchTargets(idBitsToAssign);
final int childrenCount = mChildrenCount;
// 这一段是处理 TouchTarget 的，如果 TouchTarget 没有且有子控件时
if (newTouchTarget == null && childrenCount != 0) {
final float x = ev.getX(actionIndex);
final float y = ev.getY(actionIndex);
// 获取到能够收到事件的子 View 集合
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);
// 获取可以接收事件的 View
final View child = getAndVerifyPreorderedView(
preorderedList, children, childIndex);
if (childWithAccessibilityFocus != null) {
if (childWithAccessibilityFocus != child) {
continue;
}
childWithAccessibilityFocus = null;
i = childrenCount - 1;
}
// 如果不能接收点击事件或者这个事件不再 View 里面跳过
// 若 View 是 VISIBLE 且没有关联动画
// canReceivePointerEvents 方法会返回 true
if (!child.canReceivePointerEvents()
|| !isTransformedTouchPointInView(x, y, child, null)) {
ev.setTargetAccessibilityFocus(false);
continue;
}
// 这里会获取该子 View 的 TouchTarget
newTouchTarget = getTouchTarget(child);
if (newTouchTarget != null) {
newTouchTarget.pointerIdBits |= idBitsToAssign;
break;
}
// 重置下一个取消标志。如果之前设置了该标志，则返回 true。
resetCancelNextUpFlag(child);
if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
// Child wants to receive touch within its bounds.
mLastTouchDownTime = ev.getDownTime();
if (preorderedList != null) {
for (int j = 0; j < childrenCount; j++) {
if (children[childIndex] == mChildren[j]) {
mLastTouchDownIndex = j;
break;
}
}
} else {
mLastTouchDownIndex = childIndex;
}
mLastTouchDownX = ev.getX();
mLastTouchDownY = ev.getY();
// 这句话会将改 TouchTarget 添加到 mFirstTouchTarget 的链表头部
newTouchTarget = addTouchTarget(child, idBitsToAssign);
alreadyDispatchedToNewTouchTarget = true;
break;
}
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;
}
}
}
// 这一段是判断是否有 TouchTarget 链表
if (mFirstTouchTarget == null) {
// No touch targets so treat this as an ordinary view.
handled = dispatchTransformedTouchEvent(ev, canceled, null,
TouchTarget.ALL_POINTER_IDS);
} else {
// 这里是遍历之前生成的触摸事件的链表，并且分发事件
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;
}
}
// Update list of touch targets for pointer up or cancel, if needed.
if (canceled
|| actionMasked == MotionEvent.ACTION_UP
|| actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
resetTouchState();
} else if (split && actionMasked == MotionEvent.ACTION_POINTER_UP) {
final int actionIndex = ev.getActionIndex();
final int idBitsToRemove = 1 << ev.getPointerId(actionIndex);
removePointersFromTouchTargets(idBitsToRemove);
}
}
if (!handled && mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onUnhandledEvent(ev, 1);
}
return handled;
}
View 层
接下来就到 View 层啦。
首先会判断若是 ACTION_DOWN 事件则会停止正在进行的滑动，接下来会判断自己是否可以调度事件，如果可以则会判断当前 View 是否是 ENABLED 并且响应了滚动条事件，如果是的话会将 result 先标记为 true。然后再判断如果当前 View 是 ENABLED 的，并且设置了 OnTouchListener 监听会直接回调到监听器内，并且 OnTouchListener 中的 onTouch 若返回了 true 的话则会将 result 标记为 true。接下来会再判断若之前的 result 仍然为 false 则说明之前并没有处理事件，这时候会调用自己的 onTouchEvent，若该该方法返回了 true，则 result 会被设为 true。
public boolean dispatchTouchEvent(MotionEvent event) {
if (event.isTargetAccessibilityFocus()) {
if (!isAccessibilityFocusedViewOrHost()) {
return false;
}
event.setTargetAccessibilityFocus(false);
}
// 是否处理事件，若为 true 则处理
boolean result = false;
if (mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onTouchEvent(event, 0);
}
final int actionMasked = event.getActionMasked();
if (actionMasked == MotionEvent.ACTION_DOWN) {
// 首先先停止正在进行的滑动
stopNestedScroll();
}
// 判断自己是否可以调度事件（未被其它窗口盖住且未隐藏）
if (onFilterTouchEventForSecurity(event)) {
// 如果当前 View 是 ENABLED 的，并且响应了滚动条事件
if ((mViewFlags & ENABLED_MASK) == ENABLED && handleScrollBarDragging(event)) {
result = true;
}
// 如果当前 View 是 ENABLED 的，并且设置了 OnTouchListener 监听会直接回调到监听器内
ListenerInfo li = mListenerInfo;
if (li != null && li.mOnTouchListener != null
&& (mViewFlags & ENABLED_MASK) == ENABLED
&& li.mOnTouchListener.onTouch(this, event)) {
result = true;
}
// 这里只有既没有响应滚动条，
// 又没有设置 OnTouchListener
// 又或者 OnTouchListener 中没有处理事件才会调用 onTouchEvent
if (!result && onTouchEvent(event)) {
result = true;
}
}
if (!result && mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onUnhandledEvent(event, 0);
}
// 若果当前事件为 ACTION_UP 或者为 ACTION_CANCEL 或者为 ACTION_DOWN 但是没有处理事件
if (actionMasked == MotionEvent.ACTION_UP ||
actionMasked == MotionEvent.ACTION_CANCEL ||
(actionMasked == MotionEvent.ACTION_DOWN && !result)) {
stopNestedScroll();
}
return result;
}
最后就是 View 的 onTouchEvent 啦。
该方法首先会判断 View 是否是可点击的，如果 View 可点击但是其状态是 DISABLED 的也可以消耗触摸事件，只是不会响应它。接下来会判断是否设置了 mTouchDelegate 触摸事件代理，如果有的话会优先处理代理中的 onTouchEvent。接下来就是处理具体是事件啦。
-
ACTION_UP
首先会先判断该 View 是否点击过，若可以则会判断该 View 是否被按压过会先设置按压效果并判断长按事件是否返回了 true，若返回的是 false 则会先移除长按事件的回调，并响应点击事件，这里会判断是否设置了 OnClickListener，若设置了则会回调其 onClick 方法
-
ACTION_DOWN
该事件会先将 mHasPerformedLongPress 也就是触发了长按事件的标记重置为 false，接下来会判断该 View 是否在可滑动的容器内，若不在则会设置按压效果并尝试触发长按事件，这里会延迟 500ms 的时间然后调用 performLongClick，最后调用到 performLongClickInternal 这里会判断是否设置了 OnLongClickListener 若设置了则会回调其中的 onLongClick，这个方法若返回 true 则表示处理了长按如果处理了长按事件会将 mHasPerformedLongPress 设置为 true
public boolean onTouchEvent(MotionEvent event) {
final float x = event.getX();
final float y = event.getY();
final int viewFlags = mViewFlags;
final int action = event.getAction();
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;
}
// 判断又没有设置处理代理，如果设置了则直接使用代理中的 onTouchEvent
if (mTouchDelegate != null) {
if (mTouchDelegate.onTouchEvent(event)) {
return true;
}
}
// 如果当前 View 是可点击的，或者设置了 TOOLTIP
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);
}
// 先判断了长按事件是否返回了 ture，若返回的 true 就不会触发点击事件了
if (!mHasPerformedLongPress && !mIgnoreNextUpEvent) {
// 先移除长按事件的回调
removeLongPressCallback();
if (!focusTaken) {
if (mPerformClick == null) {
mPerformClick = new PerformClick();
}
// 这里采用 post 是考虑到不会阻塞其他 UI 效果的更新
if (!post(mPerformClick)) {
performClickInternal();
}
}
}
if (mUnsetPressedState == null) {
mUnsetPressedState = new UnsetPressedState();
}
if (prepressed) {
postDelayed(mUnsetPressedState,
ViewConfiguration.getPressedStateDuration());
} else if (!post(mUnsetPressedState)) {
// If the post failed, unpress right now
mUnsetPressedState.run();
}
removeTapCallback();
}
mIgnoreNextUpEvent = false;
break;
case MotionEvent.ACTION_DOWN:
if (event.getSource() == InputDevice.SOURCE_TOUCHSCREEN) {
mPrivateFlags3 |= PFLAG3_FINGER_DOWN;
}
// 这个标记是判断长按事件是否触发，先重置为 false
mHasPerformedLongPress = false;
// 不可点击时也会尝试响应点击事件，因为有可能 mViewFlags 设置了 TOOLTIP
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);
// 检查长按事件，这里会延时
// ViewConfiguration.getLongPressTimeout() （500 ms）的时间
// 然后调用 performLongClick，最后调用到 performLongClickInternal
// performLongClickInternal 这里会判断是否设置了 OnLongClickListener
// 若设置了则会回调其中的 onLongClick，这个方法若返回 true 则表示处理了长按
// 如果处理了长按事件会将 mHasPerformedLongPress 设置为 true
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()) {
final float ambiguousMultiplier =
ViewConfiguration.getAmbiguousGestureMultiplier();
if (!pointInView(x, y, touchSlop)) {
removeLongPressCallback();
long delay = (long) (ViewConfiguration.getLongPressTimeout()
* ambiguousMultiplier);
delay -= event.getEventTime() - event.getDownTime();
checkForLongClick(
delay,
x,
y,
TOUCH_GESTURE_CLASSIFIED__CLASSIFICATION__LONG_PRESS);
}
touchSlop *= ambiguousMultiplier;
}
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()) {
// process the long click action immediately
removeLongPressCallback();
checkForLongClick(
0 /* send immediately */,
x,
y,
TOUCH_GESTURE_CLASSIFIED__CLASSIFICATION__DEEP_PRESS);
}
break;
}
return true;
}
return false;
}
948
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
