转载请以链接形式标明出处:
本文出自:103style的博客
《Android开发艺术探索》 学习记录
base on Android-29
文中相关的源码有删减
可以带着以下问题来看本文:
如果上面这些问题你都知道,那你很棒棒哦!
点击事件的分发主要由以下这三个很重要的方法来完成的:
public boolean dispatchTouchEvent(MotionEvent ev)
用来进行事件的分发。如果事件传到当前View, 这个方法一定被调用,返回结果受当前view的 onTouchEvent 和 下级view的 dispatchTouchEvent 影响,表示是否消耗事件。
public boolean onInterceptTouchEvent(MotionEvent ev)
ViewGroup才有的方法,用于判断是否拦截某个事件。 如果当前方法拦截了某个事件,同一个事件序列中,此方法不会再回调。 返回结果表示是否拦截当前事件。
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;
}
由于篇幅原因,实例验证过程记录到这里:Android事件分发机制验证示例 ,可以点击阅读原文查看。
大家主要关注里面打印的日志信息,看下事件分发的过程即可。
我们直接从入口 Avtivity 的 dispatchTouchEvent 开始看:
//Avtivity.java
public boolean dispatchTouchEvent(MotionEvent ev) {
if (ev.getAction() == MotionEvent.ACTION_DOWN) {
onUserInteraction();
}
if (getWindow().superDispatchTouchEvent(ev)) {
return true;
}
return onTouchEvent(ev);
}
public void onUserInteraction() {
}
可以看到 onUserInteraction 方法默认是一个空实现, 所以我们继续看 getWindow().superDispatchTouchEvent(ev),
public class Activity extends ContextThemeWrapper .... {
final void attach(...) {
...
mWindow = new PhoneWindow(this, window, activityConfigCallback);
...
}
public Window getWindow() {
return mWindow;
}
}
我们知道 getWindow 返回的是一个 PhoneWindow,
所有我们继续看 PhoneWindow:
//PhoneWindow.java
public boolean superDispatchTouchEvent(MotionEvent event) {
return mDecor.superDispatchTouchEvent(event);
}
private void installDecor() {
if (mDecor == null) {
mDecor = generateDecor(-1);
...
}
protected DecorView generateDecor(int featureId) {
...
return new DecorView(context, featureId, this, getAttributes());
}
而这里的 mDecor 我们可以在 generateDecor(int featureId) 中看到返回的是一个 DecorView,而且是继承自 FrameLayout 的, 而 superDispatchTouchEvent 方法调用的即为 ViewGroup 的 dispatchTouchEvent.
//DecorView.java
public class DecorView extends FrameLayout implements ...
public boolean superDispatchTouchEvent(MotionEvent event) {
return super.dispatchTouchEvent(event);
}
然后回到之前的 Activity 的 dispatchTouchEvent 方法,当 getWindow().superDispatchTouchEvent(ev) 返回 true
时,则不会再调用 Activity 中的 onTouchEvent 方法。
可以在上述示例中的 默认 和 仅 TestView 设置点击事件 的日志中 DOWN 事件的对比即可看出.
然后接下来就到 ViewGroup 的 dispatchTouchEvent 方法,暂时先隐藏满足 onFilterTouchEventForSecurity(ev) 条件的逻辑:
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)) {
....
}
if (!handled && mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onUnhandledEvent(ev, 1);
}
return handled;
}
首先我们看到 开头和结尾都有个 mInputEventConsistencyVerifier,而且在 AS 中是红色的,我们可以在 View 类里看到他的初始化:
//View.java
//Consistency verifier for debugging purposes.
protected final InputEventConsistencyVerifier mInputEventConsistencyVerifier =
InputEventConsistencyVerifier.isInstrumentationEnabled() ?
new InputEventConsistencyVerifier(this, 0) : null;
//InputEventConsistencyVerifier.java
private static final boolean IS_ENG_BUILD = Build.IS_ENG;
public static boolean isInstrumentationEnabled() {
return IS_ENG_BUILD;
}
//Build.java
public static final boolean IS_ENG = "eng".equals(TYPE);
/** The type of build, like "user" or "eng". */
public static final String TYPE = getString("ro.build.type");
TYPE 这个是区分是 开发者 还是 用户,我们的手机基本都是 user,所有 isInstrumentationEnabled() 返回 false
,所有我们得到 mInputEventConsistencyVerifier 为 null
。
而这里 setTargetAccessibilityFocus 在后面选择子元素的时,如果为 true
,则只会找子元素中获取焦点的 View 来处理事件。
然后 dispatchTouchEvent 方法代码可以缩减为:
public boolean dispatchTouchEvent(MotionEvent ev) {
boolean handled = false;
if (onFilterTouchEventForSecurity(ev)) {
....
}
return handled;
}
然后我们来看看满足 onFilterTouchEventForSecurity(ev) 里面的逻辑处理是什么的。
首先是在 ACTION_DOWN 重置状态,
final int action = ev.getAction();
final int actionMasked = action & MotionEvent.ACTION_MASK;
if (actionMasked == MotionEvent.ACTION_DOWN) {
cancelAndClearTouchTargets(ev);
resetTouchState();
}
在这里,ViewGroup 会重置到初始状态,而下面要说的 FLAG_DISALLOW_INTERCEPT 标记为也会被清掉,而且如果之前有子元素处理了事件,这里还会触发一个 ACTION_CANCEL 事件。
private void cancelAndClearTouchTargets(MotionEvent event) {
if (mFirstTouchTarget != null) {
for (TouchTarget target = mFirstTouchTarget; target != null; target = target.next) {
dispatchTransformedTouchEvent(event, true, target.child, target.pointerIdBits);
}
}
}
private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel, ...) {
final int oldAction = event.getAction();
if (cancel || oldAction == MotionEvent.ACTION_CANCEL) {
event.setAction(MotionEvent.ACTION_CANCEL);
if (child != null) {
//分发 ACTION_CANCEL 给子元素
handled = child.dispatchTouchEvent(event);
}
event.setAction(oldAction);
return handled;
}
...
}
然后我们来看 决定是否拦截事件 的逻辑:
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);
} else {
intercepted = false;
}
} else {
intercepted = true;
}
首先我们来看下条件,DOWN 事件就不用说了,那 mFirstTouchTarget 是什么呢?
从后面的逻辑代码可以看出来,当事件由 ViewGroup 的子元素成功处理时,它 即被赋值为子元素,
换种说话就是,ViewGroup不拦截并将事件交给子元素去处理时,则 mFirstTouchTarget != null。
反过来,只要 ViewGroup 拦截事件,mFirstTouchTarget != null 就不成立!那么当 MOVE、UP 事件来的时候 两个条件都不成立,则 intercepted = true,这些事件都不会交给子元素去处理了,都由 ViewGroup 自行处理。
我们看到其中还有一个 FLAG_DISALLOW_INTERCEPT 的标记位,这个是子元素中的 ViewGroup 通过调用 requestDisallowInterceptTouchEvent(boolean) 来设置的,一旦子元素有调用这个方法,那么此 ViewGroup 将无法拦截除 DOWN 以外的其他事件。
为什么说是除 DOWN 以外呢? 因为前面我们说了,FLAG_DISALLOW_INTERCEPT 在 DOWN事件的时候也会被重置,因此,对于 DOWN 事件,ViewGroup 总是通过 onInterceptTouchEvent 来判断是否拦截。
然后我们可以看到,当拦截 并且 不是 ACTION_CANCEL 时,如果之前没有事件交给子元素去处理的话,则直接调用 dispatchTransformedTouchEvent,而传的 第三个参数为 null,则该方法相当于直接调用 dispatchTouchEvent。
final boolean canceled = resetCancelNextUpFlag(this)
|| actionMasked == MotionEvent.ACTION_CANCEL;
if (!canceled && !intercepted) {
....
}
if (mFirstTouchTarget == null) {
handled = dispatchTransformedTouchEvent(ev, canceled, null, TouchTarget.ALL_POINTER_IDS);
} else {
...
}
private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel, View child, ...) {
//这里的条件相当于直接调用 ViewGroup的 dispatchTouchEvent
if (child == null) {
return super.dispatchTouchEvent(event);
}
}
接着我们来看 mFirstTouchTarget != null 时的逻辑:
boolean alreadyDispatchedToNewTouchTarget = false;
if (mFirstTouchTarget == null) {
...
} 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;
//传递 ACTION_CANCEL给处理了事件的子元素 和DOWN事件重置时执行的逻辑一致
if (dispatchTransformedTouchEvent(ev, cancelChild,target.child,...)) {
handled = true;
}
...
}
target = next;
}
}
即为传递 ACTION_CANCEL 给处理了事件的子元素,和DOWN事件重置时执行的逻辑一致
我们先来如果没有子元素时,可以看到下面的代码相当于没有。
if (!canceled && !intercepted) {
if (actionMasked == MotionEvent.ACTION_DOWN
|| (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
|| actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
final int childrenCount = mChildrenCount;
if (newTouchTarget == null && childrenCount != 0) {
...
}
}
}
然后当有子元素时:
View childWithAccessibilityFocus = ev.isTargetAccessibilityFocus()
? findChildWithAccessibilityFocus() : null;
if (newTouchTarget == null && childrenCount != 0) {
final float x = ev.getX(actionIndex);
final float y = ev.getY(actionIndex);
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 (!child.canReceivePointerEvents()
|| !isTransformedTouchPointInView(x, y, child, null)) {
ev.setTargetAccessibilityFocus(false);
continue;
}
resetCancelNextUpFlag(child);
//分发事件给子元素
if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
mLastTouchDownTime = ev.getDownTime();
if (preorderedList != null) {
for (int j = 0; j < childrenCount; j++) {
if (children[childIndex] == mChildren[j]) {
mLastTouchDownIndex = j;
break;
}
}
} else {
mLastTouchDownIndex = childIndex;
}
break;
}
newTouchTarget = addTouchTarget(child, idBitsToAssign);
ev.setTargetAccessibilityFocus(false);
}
if (preorderedList != null) preorderedList.clear();
}
private TouchTarget addTouchTarget(@NonNull View child, int pointerIdBits) {
final TouchTarget target = TouchTarget.obtain(child, pointerIdBits);
target.next = mFirstTouchTarget;
mFirstTouchTarget = target;
return target;
}
倒序遍历子元素,判断事件的坐标是否在子元素内,
然后调用 dispatchTransformedTouchEvent,里面的逻辑即为调用 child.dispatchTouchEvent(transformedEvent),把事件分发给子元素。
如果某个子元素处理了事件,则记录当前子元素的在子元素列表中的索引为 mLastTouchDownIndex。
然后在 addTouchTarget 中 赋值 mFirstTouchTarget 为此子元素。
dispatchTransformedTouchEvent 中的 transformedEvent 即为动画等做的位置变换。
private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel, View child, ...) {
if (child == null) {
} 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);
}
transformedEvent.recycle();
return handled;
}
通过上面的分析,我们可以看到最后的逻辑相当于:
if (XXX) {
handled = super.dispatchTouchEvent(event);
} else {
handled = child.dispatchTouchEvent(event);
}
可能继续调用 ViewGroup的 super.dispatchTouchEvent 或者 调用 View 的 dispatchTouchEvent 方法。而 super.dispatchTouchEvent 即为调用 View 的 dispatchTouchEvent。
接下来我们就来看看 View 的 dispatchTouchEvent 方法的处理逻辑。
public boolean dispatchTouchEvent(MotionEvent event) {
boolean result = false;
if (onFilterTouchEventForSecurity(event)) {
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;
}
这里我们可以看到,首先会判断当前是否设置了 OnTouchListener,设置了的话还得判断状态是否是 ENABLED,是的话就会调用 我们设置的 OnTouchListener 的 onTouch 方法,
如果我们返回 true
了,则 dispatchTouchEvent 返回 true
。
如果返回 false, 则调用 onTouchEvent 方法,dispatchTouchEvent 返回值即为 onTouchEvent 的返回值。
继续看 onTouchEvent 的处理逻辑。
final int viewFlags = mViewFlags;
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;
}
如果是 DISABLED 状态,则返回当前是否可以点击。
View 的 LONG_CLICKABLE 属性默认是 false,而 CLICKABLE 属性的值 和 View 是否可以点击有关,
比如Button是可以点击的,所以 CLICKABLE 为 true
;
而 TextView 默认是不可点击的,所以 CLICKABLE 为 false
。
通过 setOnClickListener 和 setOnLongClickListener 可以改变对应的属性,可以从它们的源码可以看出:
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是否设置了代理 mTouchDelegate,设置了则会调用其 onTouchEvent 方法,它和 OnTouchListener 的工作机制差不多,这里就不深入了。
if (mTouchDelegate != null) {
if (mTouchDelegate.onTouchEvent(event)) {
return true;
}
}
然后就是对应事件的处理了。
到这里了,就说明事件即被当前View消耗了,只是对不同的事件做不同的处理,我们主要关注 ACTION_UP事件,里面主要就是调用了 performClickInternal()。
public boolean onTouchEvent(MotionEvent event) {
if (clickable || (viewFlags & TOOLTIP) == TOOLTIP) {
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();
if (!focusTaken) {
if (mPerformClick == null) {
mPerformClick = new PerformClick();
}
if (!post(mPerformClick)) {
performClickInternal();
}
}
}
...
}
mIgnoreNextUpEvent = false;
break;
case MotionEvent.ACTION_DOWN:
...
break;
case MotionEvent.ACTION_CANCEL:
...
removeTapCallback();
removeLongPressCallback();
break;
case MotionEvent.ACTION_MOVE:
...
break;
}
return true;
}
return false;
}
这里就是看我们是否设置了 OnClickListener ,设置了及返回 true,否则返回 false.
private boolean performClickInternal() {
return 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;
}
return result;
}
所以我们如果自定义想设置点击事件的话,也可以直接重写 performClick。
到这里,相关的流程基本理清楚了,我们在回头看看开头的两张流程图,在自己理一下。
Q:事件分发的主要方法?
A: dispatchTouchEvent、onInterceptTouchEvent、onTouchEvent。
Q:事件从Activity 传到对应的点击的View上的过程是怎么样的?
A: 默认的流程是 Activity.dispatchTouchEvent → ViewGroup.dispatchTouchEvent → ViewGroup.onInterceptTouchEvent → View.dispatchTouchEvent → View.onTouchEvent → ViewGroup.onTouchEvent → Activity.onTouchEvent,然后会随着事件的消耗有所变化,可以看验证示例那块。
Q:ACTION_CANCEL 的调用时机?
A: 在ACTION_DOWN事件时,如果还有处理了事件的子元素,则会创建ACTION_CANCEL传递给他;在子元素消耗了DOWN事件之后,父元素拦截了后续的事件,后续事件到达的时候即会触发ACTION_CANCEL 传给你 消耗了DOWN事件的子元素。
Q:ViewGroup是怎么找到处理事件对应的子元素的?
A: 倒序遍历子元素,首先判断 isTargetAccessibilityFocus 的值, 如果为 true,则找到当前子元素中获取焦点的View;如果为 false, 则倒序遍历知道找到一个处理了事件的View位置。
Q:OnTouchListener 和 OnClickListener 的调用时机区别?在事件分发的三个主要方法的哪个方法中?
A: 如果都设置的话 OnTouchListener 比 OnClickListener 先调用,因为 OnTouchListener 在 View 的 dispatchTouchEvent 中调用,OnClickListener 在 onTouchEvent 中调用。
Q:OnClickListener 的触发条件以及在什么时候触发?
A: 当前View要能别点击,并且得设置OnClickListener。 在 ACTION_UP 时最终调用 performClick()。我们在自定义View时,如果重写了 onTouchEvent,IDE 就会警告你是要重写 performClick。
如果有描述错误的,请提醒我,感谢!
以上
如果觉得不错的话,请帮忙点个赞呗。
扫描下面的二维码,关注我的公众号 Android1024, 点关注,不迷路。