源码分析：View的事件分发机制

发表于 | 分类于 | 阅读次数：

前言

事件分发就是将MotionEvent事件分发给一个具体的View来处理的过程。本文将对Activity、ViewGroup和View的dispatchTouchEvent方法以及View的OnTouchEvent方法进行一些分析，以便更好理解事件分发的过程。下面的源码都是基于API26。

源码分析

Activity#dispatchTouchEvent

当一个点击操作产生时，事件最先传递给当前Activity，由Activity的dispatchTouchEvent方法进行事件派发。

1
2
3
4
5
6
7
8
9
10
11
public boolean dispatchTouchEvent(MotionEvent ev) {
    if (ev.getAction() == MotionEvent.ACTION_DOWN) {
        onUserInteraction();    
        //这是一个空方法，如果我们希望用户按下屏幕后执行什么操作，可以在活动中重写该方法
    }
    if (getWindow().superDispatchTouchEvent(ev)) {
        return true;
    }
    //没人处理的话就调用Activity的onTouchEvent
    return onTouchEvent(ev);
}

getWindow()获取到的是当前Activity的Window，其实现是PhoneWindow。PhoneWindow的superDispatchTouchEvent方法如下：

1
2
3
4
@Override
public boolean superDispatchTouchEvent(MotionEvent event) {
    return mDecor.superDispatchTouchEvent(event);
}

这里又调用了mDecor的superDispatchTouchEvent方法，mDecor是一个DecorView（setContentView所设置的View的父容器），所以现在来看看DecorView的superDispatchTouchEvent方法

1
2
3
public boolean superDispatchTouchEvent(MotionEvent event) {
    return super.dispatchTouchEvent(event);
}

这里调用的是父类的dispatchTouchEvent方法，DecorView继承于FrameLayout，但FrameLayout没有重写该方法，而FrameLayout又继承于ViewGroup，ViewGroup重写了该方法，所以这里调用的是ViewGroup的dispatchTouchEvent方法。

ViewGroup#dispatchTouchEvent

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    //...

    boolean handled = false;
    if (onFilterTouchEventForSecurity(ev)) {
        final int action = ev.getAction();
        final int actionMasked = action & MotionEvent.ACTION_MASK;

        if (actionMasked == MotionEvent.ACTION_DOWN) {
            //...
            
            //在该方法中会重置FLAG_DISALLOW_INTERCEPT标记位
            resetTouchState();
        }

        //（1）判断是否要拦截事件
        final boolean intercepted;	
        if (actionMasked == MotionEvent.ACTION_DOWN
                || mFirstTouchTarget != null) {
//如果设置了FLAG_DISALLOW_INTERCEPT标记位，则不拦截此事件
            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 {
//如果当前事件不是ACTION_DOWM，并且之前的事件是由自己拦截的，默认之后的事件都由自己处理
            intercepted = true;
        }

        //...
        
        //（2）不拦截事件时，查找可以分发事件的子View
        if (!canceled && !intercepted) {

            if (actionMasked == MotionEvent.ACTION_DOWN
                    || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
                    || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
                    
                //...

                if (newTouchTarget == null && childrenCount != 0) {
                    
                    //...
                    
                    
                    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);

                        //优先让有可访问焦点的子View处理
                        if (childWithAccessibilityFocus != null) {
                            if (childWithAccessibilityFocus != child) {
                                continue;
                            }
                            //置空，若该子View不处理，则重新遍历的时候跳过这个if
                            childWithAccessibilityFocus = null;
                            //重置i，以便该子View不处理时，重新遍历
                            i = childrenCount - 1;
                        }

                        //如果一个View不可见并且没有设置动画，或者不在点击范围内
                        //跳出本次循环，进行下一次循环
                        if (!canViewReceivePointerEvents(child)
                                || !isTransformedTouchPointInView(x, y, child, null)) {
                            ev.setTargetAccessibilityFocus(false);
                            continue;
                        }

                        //...
                        
                        //（3）找到可以分发事件的子View时，分发事件
                        if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
                            
                            //...
                            
                            //在addTouchTarget中给mFirstTouchTarget赋值
                            newTouchTarget = addTouchTarget(child, idBitsToAssign);
                            alreadyDispatchedToNewTouchTarget = true;
                            break;
                        }

                        //执行到这里说明具有可访问焦点的子View没有处理，重置后进行下一次循环
                        ev.setTargetAccessibilityFocus(false);
                    }
                }

                //...
            }
        }

        //（4）拦截了事件，或者没有找到可分发事件的子View时，自己处理事件
        if (mFirstTouchTarget == null) {
            handled = dispatchTransformedTouchEvent(ev, canceled, null,
                    TouchTarget.ALL_POINTER_IDS);
        } //...

        //...
    }

    return handled;
}

首先看（1）处代码，首先判断当前ViewGroup是否拦截此事件。这里分三种情况：

  1. 如果当前事件不是ACTION_DOWM，并且之前的事件是由自己处理的，那么默认之后的事件都由自己处理，拦截此事件。
  2. 如果设置了FLAG_DISALLOW_INTERCEPT标记位，那么ViewGroup将无法拦截除ACTION_DOWN以外的事件。
  3. 如果事件为ACTION_DOWM或自己之前没拦截过此事件，并且没有设置FLAG_DISALLOW_INTERCEPT标记位，那么将由onInterceptTouchEvent方法决定是否拦截。一般来说都是不拦截的，子类可以自己重写该方法来决定是否拦截事件。

接着看（2）处代码，当ViewGroup决定不拦截事件时，会查找可以分发事件的子View。直接看遍历子View的for循环。它的for循环是倒序遍历，所以是从最上层的View开始找起。

如果有带有可访问焦点的子View，那么优先将事件分发给它。如果没有这种View，或这种View不拦截事件，那么将会发事件分给可见或者设置了动画，并且符合点击范围的View。

看（3）处和（4）处代码，可以发现，无论是找到了可以分发的子View，还是没有可以处理事件的子View或者自己拦截了事件，都是调用dispatchTransformedTouchEvent方法。

dispatchTransformedTouchEvent方法简化后的逻辑如下：

1
2
3
4
5
6
7
8
9
10
11
12
private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
        View child, int desiredPointerIdBits) {
    final boolean handled;

    if (child == null) {
        handled = super.dispatchTouchEvent(transformedEvent);
    } else {
        handled = child.dispatchTouchEvent(transformedEvent);
    }

    return handled;
}

可以看到如果将事件分发给了子View，那么将调用子View的dispatchTouchEvent方法继续分发事件。如果是ViewGroup自己处理事件的话，它会调用父类，即View的dispatchTouchEvent方法来处理事件。

View#dispatchTouchEvent

从ViewGroup的dispatchTouchEvent方法可以看出，ViewGroup并没有对事件做出处理。只是起了一个分发作用。最终还是会调用View的dispatchTouchEvent方法。该方法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 public boolean dispatchTouchEvent(MotionEvent event) {
     
     //...
     
     boolean result = false;

     //...

     if (onFilterTouchEventForSecurity(event)) {
         //...
         
//如果用户设置了OnTouchListener，则先调用该接口的onTouch方法
//onTouch方法返回true的话，将不执行onTouchEvent
         ListenerInfo li = mListenerInfo;
         if (li != null && li.mOnTouchListener != null
                 && (mViewFlags & ENABLED_MASK) == ENABLED
                 && li.mOnTouchListener.onTouch(this, event)) {
             result = true;
         }

         //没有设置OnTouchListener，或者onTouch方法返回false，执行onTouchEvent
         if (!result && onTouchEvent(event)) {
             result = true;
         }
     }

     //...

     return result;
 }

dispatchTouchEvent方法的执行步骤如下：
先判断用户是否设置了OnTouchListener，如果用户设置了OnTouchListener，则先调用该接口的onTouch方法，如果onTouch方法返回true，则不执行onTouchEvent，否则执行onTouchEvent。如果用户没有设置OnTouchListener，执行onTouchEvent方法。

继续看View的onTouchEvent方法

View#onTouchEvent

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
public boolean onTouchEvent(MotionEvent event) {
    final float x = event.getX();
    final float y = event.getY();
    final int viewFlags = mViewFlags;
    final int action = event.getAction();

	//setOnClickListener会设置CLICKABLE属性
	//setOnLongClickListener会设置LONG_CLICKABLE属性
    final boolean clickable = ((viewFlags & CLICKABLE) == CLICKABLE
            || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
            || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE;

    //disable状态下的View照样会消耗点击事件
    if ((viewFlags & ENABLED_MASK) == DISABLED) {
        
        //...
        
        return clickable;
    }
    
    //...

    if (clickable || (viewFlags & TOOLTIP) == TOOLTIP) {
        switch (action) {
            case MotionEvent.ACTION_UP:
                //...
                
                if (mPerformClick == null) {
                    mPerformClick = new PerformClick();
                }
                if (!post(mPerformClick)) {
                    performClick();     //该方法会调用OnClickListener的onClick方法
                }

                //...
                break;

            //...
        }

        return true;
    }

    return false;
}

可以看到OnTouchEvent在处理ACTION_UP的时候会调用OnClickListener的onClick方法。

至此，View的事件分发源码分析完毕。

小结

  1. dispatchTouchEvent、onInterceptTouchEvent和onTouchEvent的关系

它们的关系可以用以下伪代码表示，首先是ViewGroup的dispatchTouchEvent方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public boolean dispatchTouchEvent(MotionEvent event) {
	boolean consume = false;	
	
	//判断该ViewGroup是否拦截当前事件
	if (onInterceptTouchEvent(event)) {
	    //调用父类，即View的dispatchTouchEvent方法
		consume = super.dispatchTouchEvent(event);	
	} else {
	    //子View继续调用dispatchTouchEvent方法进行分发
		consume = child.dispatchTouchEvent(event);
	}
	
	return consume;
}

最终都会调用View的dispatchTouchEvent方法：

1
2
3
4
5
6
7
public boolean dispatchTouchEvent(MotionEvent event) {
	boolean consume = false;	
	
    consume = onTouchEvent(event);
	
	return consume;
}

可以看到，dispatchTouchEvent方法主要是起分发作用，在ViewGroup中分发给子View，在View中交给onTouchEvent方法处理。onInterceptTouchEvent方法则是在ViewGroup中判断是否拦截此事件。onTouchEvent方法则是在View中最终处理事件。

  1. OnTouchListener、OnClickListener和onTouchEvent的优先级

OnTouchListener > onTouchEvent > OnClickListener

参考

-------------　　　　本文到此结束　　感谢您的阅读　　　　-------------
0%