android viewgroup事件分发机制

1、案例

首先我们接着上一篇的代码，在代码中添加一个自定义的LinearLayout：

[java] ​​ view plain​​ ​​copy​​

1. package
2.   
3. import
4. import
5. import
6. import
7. import
8.   
9. public class MyLinearLayout extends
10. {  
11. private static final String TAG = MyLinearLayout.class.getSimpleName();  
12.   
13. public
14.     {  
15. super(context, attrs);  
16.     }  
17.   
18. @Override
19. public boolean
20.     {  
21. int
22. switch
23.         {  
24. case
25. "dispatchTouchEvent ACTION_DOWN");  
26. break;  
27. case
28. "dispatchTouchEvent ACTION_MOVE");  
29. break;  
30. case
31. "dispatchTouchEvent ACTION_UP");  
32. break;  
33.   
34. default:  
35. break;  
36.         }  
37. return super.dispatchTouchEvent(ev);  
38.     }  
39.   
40. @Override
41. public boolean
42.     {  
43.   
44. int
45.   
46. switch
47.         {  
48. case
49. "onTouchEvent ACTION_DOWN");  
50. break;  
51. case
52. "onTouchEvent ACTION_MOVE");  
53. break;  
54. case
55. "onTouchEvent ACTION_UP");  
56. break;  
57.   
58. default:  
59. break;  
60.         }  
61.   
62. return super.onTouchEvent(event);  
63.     }  
64.   
65. @Override
66. public boolean
67.     {  
68.           
69. int
70. switch
71.         {  
72. case
73. "onInterceptTouchEvent ACTION_DOWN");  
74. break;  
75. case
76. "onInterceptTouchEvent ACTION_MOVE");  
77. break;  
78. case
79. "onInterceptTouchEvent ACTION_UP");  
80. break;  
81.   
82. default:  
83. break;  
84.         }  
85.           
86. return super.onInterceptTouchEvent(ev);  
87.     }  
88.   
89. @Override
90. public void requestDisallowInterceptTouchEvent(boolean
91.     {  
92. "requestDisallowInterceptTouchEvent ");  
93. super.requestDisallowInterceptTouchEvent(disallowIntercept);  
94.     }  
95.   
96. }  

继承LinearLayout，然后复写了与事件分发机制有关的代码，添加上了日志的打印~

然后看我们的布局文件：

[html] ​​ view plain​​ ​​copy​​

1. <com.example.zhy_event03.MyLinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
2. xmlns:tools="http://schemas.android.com/tools"
3. android:layout_width="match_parent"
4. android:layout_height="match_parent"
5. tools:context=".MainActivity" >
6.   
7. <com.example.zhy_event03.MyButton
8. android:id="@+id/id_btn"
9. android:layout_width="wrap_content"
10. android:layout_height="wrap_content"
11. android:text="click me" />
12.   
13. </com.example.zhy_event03.MyLinearLayout>

MyLinearLayout中包含一个MyButton，MyButton都上篇博客中已经出现过，这里就不再贴代码了，不清楚可以去查看~

然后MainActivity就是直接加载布局，没有任何代码~~~

直接运行我们的代码，然后点击我们的Button，依然是有意的MOVE一下，不然不会触发MOVE事件，看一下日志的输出：

[html] ​​ view plain​​ ​​copy​​

1. 09-06 09:57:27.287: E/MyLinearLayout(959): dispatchTouchEvent ACTION_DOWN  
2. 09-06 09:57:27.287: E/MyLinearLayout(959): onInterceptTouchEvent ACTION_DOWN  
3. 09-06 09:57:27.287: E/MyButton(959): dispatchTouchEvent ACTION_DOWN  
4. 09-06 09:57:27.297: E/MyButton(959): onTouchEvent ACTION_DOWN  
5. 09-06 09:57:27.297: E/MyButton(959): onTouchEvent ACTION_MOVE  
6. 09-06 09:57:27.327: E/MyLinearLayout(959): dispatchTouchEvent ACTION_MOVE  
7. 09-06 09:57:27.327: E/MyLinearLayout(959): onInterceptTouchEvent ACTION_MOVE  
8. 09-06 09:57:27.337: E/MyButton(959): dispatchTouchEvent ACTION_MOVE  
9. 09-06 09:57:27.337: E/MyButton(959): onTouchEvent ACTION_MOVE  
10. 09-06 09:57:27.457: E/MyLinearLayout(959): dispatchTouchEvent ACTION_UP  
11. 09-06 09:57:27.457: E/MyLinearLayout(959): onInterceptTouchEvent ACTION_UP  
12. 09-06 09:57:27.457: E/MyButton(959): dispatchTouchEvent ACTION_UP  
13. 09-06 09:57:27.457: E/MyButton(959): onTouchEvent ACTION_UP  

可以看到大体的事件流程为：

MyLinearLayout的dispatchTouchEvent -> MyLinearLayout的onInterceptTouchEvent -> MyButton的dispatchTouchEvent ->Mybutton的onTouchEvent 

可以看出，在View上触发事件，最先捕获到事件的为View所在的ViewGroup，然后才会到View自身~

下面我们按照日志的输出，进入源码~

2、源码分析

ViewGroup - dispatchTouchEvent

1、ViewGroup - dispatchTouchEvent - ACTION_DOWN

首先是ViewGroup的dispatchTouchEvent方法：

[java] ​​ view plain​​ ​​copy​​

1. @Override
2. public boolean
3. if
4. return false;  
5.        }  
6.   
7. final int
8. final float
9. final float
10. final float
11. final float
12. final
13.   
14. boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;  
15.   
16. if
17. if (mMotionTarget != null) {  
18. // this is weird, we got a pen down, but we thought it was
19. // already down!
20. // XXX: We should probably send an ACTION_UP to the current
21. // target.
22. null;  
23.            }  
24. // If we're disallowing intercept or if we're allowing and we didn't
25. // intercept
26. if
27. // reset this event's action (just to protect ourselves)
28.                ev.setAction(MotionEvent.ACTION_DOWN);  
29. // We know we want to dispatch the event down, find a child
30. // who can handle it, start with the front-most child.
31. final int scrolledXInt = (int) scrolledXFloat;  
32. final int scrolledYInt = (int) scrolledYFloat;  
33. final
34. final int
35.   
36. for (int i = count - 1; i >= 0; i--) {  
37. final
38. if
39. null) {  
40.                        child.getHitRect(frame);  
41. if
42. // offset the event to the view's coordinate system
43. final float
44. final float
45.                            ev.setLocation(xc, yc);  
46.                            child.mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;  
47. if
48. // Event handled, we have a target now.
49.                                mMotionTarget = child;  
50. return true;  
51.                            }  
52. // The event didn't get handled, try the next view.
53. // Don't reset the event's location, it's not
54. // necessary here.
55.                        }  
56.                    }  
57.                }  
58.            }  
59. //other code omitted

代码比较长，决定分段贴出，首先贴出的是ACTION_DOWN事件相关的代码。

16行：进入ACTION_DOWN的处理

17-23行：将mMotionTarget置为null

26行：进行判断：if(disallowIntercept || !onInterceptTouchEvent(ev))

两种可能会进入IF代码段

1、当前不允许拦截，即disallowIntercept =true，

2、当前允许拦截但是不拦截，即disallowIntercept =false,但是onInterceptTouchEvent(ev)返回false ;

注：disallowIntercept 可以通过viewGroup.requestDisallowInterceptTouchEvent(boolean);进行设置，后面会详细说；而onInterceptTouchEvent(ev)可以进行复写。

36-57行：开始遍历所有的子View

41行：进行判断当前的x,y坐标是否落在子View身上，如果在，47行，执行child.dispatchTouchEvent(ev)，就进入了View的dispatchTouchEvent代码中了，如果不了解请参考：​​Android View的事件分发机制​​，当child.dispatchTouchEvent(ev)返回true，则为mMotionTarget=child;然后return true;

ViewGroup的ACTION_DOWN分析结束，总结一下：

ViewGroup实现捕获到DOWN事件，如果代码中不做TOUCH事件拦截，则开始查找当前x,y是否在某个子View的区域内，如果在，则把事件分发下去。

按照日志，接下来到达ACTION_MOVE

2、ViewGroup - dispatchTouchEvent - ACTION_MOVE

首先我们源码进行删减，只留下MOVE相关的代码：

[java] ​​ view plain​​ ​​copy​​

1. @Override
2. public boolean
3. final int
4. final float
5. final float
6. final float
7. final float
8. final
9.   
10. boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;  
11.   
12. //...ACTION_DOWN
13.   
14. //...ACTIN_UP or ACTION_CANCEL
15.   
16. // The event wasn't an ACTION_DOWN, dispatch it to our target if
17. // we have one.
18. final
19.        
20.   
21. // if have a target, see if we're allowed to and want to intercept its
22. // events
23. if
24. //....
25.        }  
26. // finally offset the event to the target's coordinate system and
27. // dispatch the event.
28. final float xc = scrolledXFloat - (float) target.mLeft;  
29. final float yc = scrolledYFloat - (float) target.mTop;  
30.        ev.setLocation(xc, yc);  
31.   
32. return
33.    }  

18行：把ACTION_DOWN时赋值的mMotionTarget，付给target ; 

23行：if (!disallowIntercept && onInterceptTouchEvent(ev)) 当前允许拦截且拦截了，才进入IF体，当然了默认是不会拦截的~这里执行了onInterceptTouchEvent(ev)

28-30行：把坐标系统转化为子View的坐标系统

32行：直接return target.dispatchTouchEvent(ev); 

可以看到，正常流程下，ACTION_MOVE在检测完是否拦截以后，直接调用了子View.dispatchTouchEvent，事件分发下去；

最后就是ACTION_UP了

3、ViewGroup - dispatchTouchEvent - ACTION_UP

[java] ​​ view plain​​ ​​copy​​

1. public boolean
2. if
3. return false;  
4.        }  
5.   
6. final int
7. final float
8. final float
9. final float
10. final float
11. final
12.   
13. boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;  
14.   
15. if
16.   
17. boolean
18.                (action == MotionEvent.ACTION_CANCEL);  
19.   
20. if
21.            mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;  
22.        }  
23. final
24. if(target ==null
25. if
26.   
27. if
28. null;  
29.        }  
30.   
31. // finally offset the event to the target's coordinate system and
32. // dispatch the event.
33. final float xc = scrolledXFloat - (float) target.mLeft;  
34. final float yc = scrolledYFloat - (float) target.mTop;  
35.        ev.setLocation(xc, yc);  
36.   
37. return
38.    }  

17行：判断当前是否是ACTION_UP

21，28行：分别重置拦截标志位以及将DOWN赋值的mMotionTarget置为null，都UP了，当然置为null，下一次DOWN还会再赋值的~

最后，修改坐标系统，然后调用target.dispatchTouchEvent(ev);

正常情况下，即我们上例整个代码的流程我们已经走完了：

1、ACTION_DOWN中，ViewGroup捕获到事件，然后判断是否拦截，如果没有拦截，则找到包含当前x,y坐标的子View，赋值给mMotionTarget，然后调用 mMotionTarget.dispatchTouchEvent

2、ACTION_MOVE中，ViewGroup捕获到事件，然后判断是否拦截，如果没有拦截，则直接调用mMotionTarget.dispatchTouchEvent(ev)

3、ACTION_UP中，ViewGroup捕获到事件，然后判断是否拦截，如果没有拦截，则直接调用mMotionTarget.dispatchTouchEvent(ev)

当然了在分发之前都会修改下坐标系统，把当前的x，y分别减去child.left 和 child.top ，然后传给child;

3、关于拦截

1、如何拦截

上面的总结都是基于：如果没有拦截；那么如何拦截呢？

复写ViewGroup的onInterceptTouchEvent方法：

[java] ​​ view plain​​ ​​copy​​

1. @Override
2. public boolean
3.     {  
4. int
5. switch
6.         {  
7. case
8. //如果你觉得需要拦截
9. return true
10. case
11. //如果你觉得需要拦截
12. return true
13. case
14. //如果你觉得需要拦截
15. return true
16.         }  
17.           
18. return false;  
19.     }  

默认是不拦截的，即返回false；如果你需要拦截，只要return true就行了，这要该事件就不会往子View传递了，并且如果你在DOWN retrun true ，则DOWN,MOVE,UP子View都不会捕获事件；如果你在MOVE return true , 则子View在MOVE和UP都不会捕获事件。

原因很简单，当onInterceptTouchEvent(ev) return true的时候，会把mMotionTarget 置为null ; 

2、如何不被拦截

如果ViewGroup的onInterceptTouchEvent(ev) 当ACTION_MOVE时return true ，即拦截了子View的MOVE以及UP事件；

此时子View希望依然能够响应MOVE和UP时该咋办呢？

Android给我们提供了一个方法：requestDisallowInterceptTouchEvent(boolean) 用于设置是否允许拦截，我们在子View的dispatchTouchEvent中直接这么写：

[java] ​​ view plain​​ ​​copy​​

1. @Override
2. public boolean
3.     {  
4. true);    
5. int
6.   
7. switch
8.         {  
9. case
10. "dispatchTouchEvent ACTION_DOWN");  
11. break;  
12. case
13. "dispatchTouchEvent ACTION_MOVE");  
14. break;  
15. case
16. "dispatchTouchEvent ACTION_UP");  
17. break;  
18.   
19. default:  
20. break;  
21.         }  
22. return super.dispatchTouchEvent(event);  
23.     }  

getParent().requestDisallowInterceptTouchEvent(true);  这样即使ViewGroup在MOVE的时候return true，子View依然可以捕获到MOVE以及UP事件。

从源码也可以解释：

ViewGroup MOVE和UP拦截的源码是这样的：

[java] ​​ view plain​​ ​​copy​​

1. if
2. final float xc = scrolledXFloat - (float) target.mLeft;  
3. final float yc = scrolledYFloat - (float) target.mTop;  
4.             mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;  
5.             ev.setAction(MotionEvent.ACTION_CANCEL);  
6.             ev.setLocation(xc, yc);  
7. if
8. // target didn't handle ACTION_CANCEL. not much we can do
9. // but they should have.
10.             }  
11. // clear the target
12. null;  
13. // Don't dispatch this event to our own view, because we already
14. // saw it when intercepting; we just want to give the following
15. // event to the normal onTouchEvent().
16. return true;  
17.         }  

当我们把disallowIntercept设置为true时，!disallowIntercept直接为false，于是拦截的方法体就被跳过了~

注：如果ViewGroup在onInterceptTouchEvent(ev)  ACTION_DOWN里面直接return true了，那么子View是木有办法的捕获事件的~~~

4、如果没有找到合适的子View

我们的实例，直接点击ViewGroup内的按钮，当然直接很顺利的走完整个流程；

但是有两种特殊情况

1、ACTION_DOWN的时候，子View.dispatchTouchEvent(ev)返回的为false ; 

如果你仔细看了，你会注意到ViewGroup的dispatchTouchEvent(ev)的ACTION_DOWN代码是这样的

[java] ​​ view plain​​ ​​copy​​

1. if
2. // Event handled, we have a target now.
3.                               mMotionTarget = child;  
4. return true;  
5.                           }  

只有在child.dispatchTouchEvent(ev)返回true了，才会认为找到了能够处理当前事件的View，即mMotionTarget = child;

但是如果返回false,那么mMotionTarget 依然是null

mMotionTarget 为null会咋样呢？

其实ViewGroup也是View的子类，如果没有找到能够处理该事件的子View，或者干脆就没有子View；

那么，它作为一个View，就相当于View的事件转发了~~直接super.dispatchTouchEvent(ev);

源码是这样的：

[java] ​​ view plain​​ ​​copy​​

1. final
2. if (target == null) {  
3. // We don't have a target, this means we're handling the
4. // event as a regular view.
5.            ev.setLocation(xf, yf);  
6. if ((mPrivateFlags & CANCEL_NEXT_UP_EVENT) != 0) {  
7.                ev.setAction(MotionEvent.ACTION_CANCEL);  
8.                mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;  
9.            }  
10. return super.dispatchTouchEvent(ev);  
11.        }  

我们没有一个能够处理该事件的目标元素，意味着我们需要自己处理~~~就相当于传统的View~

2、那么什么时候子View.dispatchTouchEvent(ev)返回的为true

如果你仔细看了上篇博客，你会发现只要子View支持点击或者长按事件一定返回true~~

源码是这样的：

[java] ​​ view plain​​ ​​copy​​

1.    
2. if
3.                 (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {     
4. return true

5、总结

关于代码流程上面已经总结过了~

1、如果ViewGroup找到了能够处理该事件的View，则直接交给子View处理，自己的onTouchEvent不会被触发；

2、可以通过复写onInterceptTouchEvent(ev)方法，拦截子View的事件（即return true），把事件交给自己处理，则会执行自己对应的onTouchEvent方法

3、子View可以通过调用getParent().requestDisallowInterceptTouchEvent(true);  阻止ViewGroup对其MOVE或者UP事件进行拦截；

好了，那么实际应用中能解决哪些问题呢？

比如你需要写一个类似slidingmenu的左侧隐藏menu，主Activity上有个Button、ListView或者任何可以响应点击的View，你在当前View上死命的滑动，菜单栏也出不来；因为MOVE事件被子View处理了~ 你需要这么做：在ViewGroup的dispatchTouchEvent中判断用户是不是想显示菜单，如果是，则在onInterceptTouchEvent(ev)拦截子View的事件；自己进行处理，这样自己的onTouchEvent就可以顺利展现出菜单栏了~~