事件分发机制

探讨Android事件传递机制前，务必明确android的两大基础控件类型:View和ViewGroup。

View即普通的控件，没有子布局的，如Button、TextView. ViewGroup继承自View；

ViewGroup控件，有子控件，如Linearlayout、Listview等。

而事件即MotionEvent，最重要的有3个:

(1)MotionEvent.ACTION_DOWN 按下View，是所有事件的开始

(2)MotionEvent.ACTION_MOVE 滑动事件

(3)MotionEvent.ACTION_UP   事件的结束与ACTION_DOWN 对应

（一）两类控件的主要事件函数

1.对应View类控件事件主要相关函数有两个：

public boolean dispatchTouchEvent(MotionEvent ev)  这个方法用来分发TouchEvent

public boolean onTouchEvent(MotionEvent ev) 这个方法用来处理TouchEvent

2.对应的groupView类控件主要相关函数有三个：

public boolean dispatchTouchEvent(MotionEvent ev)  这个方法用来分发TouchEvent

public boolean onInterceptTouchEvent(MotionEvent ev) 这个方法用来拦截TouchEvent

public boolean onTouchEvent(MotionEvent ev) 这个方法用来处理TouchEvent

因此，由此可知View控件比groupView类的控件少了一个onInterceptTouchEvent(MotionEvent ev)的拦截方法，这是因为View类没有子控件，没有拦截向子类传递的事件的说法，而groupView有子类，可判断是否拦截向子类传递的事件。

3.对MotionEvent说明一下：

参数MotionEvent为手机屏幕触摸事件封装类的对象，其中封装了该事件的所有信息，例如触摸的位置、触摸的类型以及触摸的时间等。该对象会在用户触摸手机屏幕时被创建。

4.下面对三个事件主要方法说明一下：

手机屏幕事件的处理方法onTouchEvent。该方法在View类中的定义，并且所有的View子类全部重写了该方法，应用程序可以通过该方法处理手机屏幕的触摸事件。该方法的签名如下所示。

public boolean onTouchEvent(MotionEvent event) {

return super.onTouchEvent(event);

}

返回值：该方法的返回值机理与键盘响应事件的相同，同样是当已经完整地处理了该事件且不希望其他回调方法再次处理时返回true，否则返回false

public boolean onInterceptTouchEvent(MotionEvent ev) {

return super.onInterceptTouchEvent(ev);

    }

onInterceptTouchEvent()用于处理事件并改变事件的传递方向，而决定传递方向的是返回值。

    返回为false时事件会传递给子控件的dispatchTouchEvent(),再由子类的dispatchTouchEvent()对事件进行分发

    返回为true时事件会传递给当前控件的onTouchEvent()，而不在传递给子控件，这就是所谓的Intercept(截断)。

    而且一旦拦截了事件，此方法不会被当前view（即viewgroup）再次调用。

public boolean dispatchTouchEvent(MotionEvent ev) {

        return super.dispatchTouchEvent(ev);

   }

 dispatchTouchEvent()主要负责对onTouchEvent事件进行分发，本身不处理onTouchEvent事件。而分发的方式由其返回值决定

    返回值为true时，则将事件交给当前view本身的onTouchEvent处理。

    返回值为false时，则将事件交给当前view本身的onInterceptTouchEvent()处理，再由其决定事件传递的方向

弄清楚这个三个方法后，我们再来初步分析一下事件的传递机制。

（二）初步了解触摸事件的传递顺序（如果对窗口的创建过程有了解就更好理解些）

一个触摸事件首先是在硬件层面触发，然后逐层传递到软件直至我们的app，前面的细节一般来说不用了解，我们讨论的事件入口从Activity开始。
触摸事件的传递顺序是：

而触摸事件的处理顺序则刚好相反（onTouchEvent）：

总体概况一下就是：

当TouchEvent发生时，首先Activity将TouchEvent通过getWindow().superDispatchTouchEvent(event)把事件分发到当前活动窗口(PhoneWindow)，之后是顶级窗口的DecorView，调用了DecorView的dispatchTouchEvent，DecorView继承自ViewGroup，所以这里实际上就进入了ViewGroup层面的dispatchTouchEvent，然后由dispatchTouchEvent 方法进行分发，如果dispatchTouchEvent返回true ，则交给当前这个view的onTouchEvent处理，如果dispatchTouchEvent返回 false 则交给当前这个 view 的 interceptTouchEvent 方法来决定是否要拦截这个事件，如果 interceptTouchEvent 返回 true ，也就是拦截掉了，则交给当前这个view的onTouchEvent来处理，如果 interceptTouchEvent 返回 false ，那么就继续传递给子view ，由子 view 的 dispatchTouchEvent 再来开始这个事件的分发。如果事件传递到某一层的子 view 的 onTouchEvent 上了，这个方法返回了 false ，那么这个事件会从这个 view 往上传递，而且都是 onTouchEvent 来接收。而如果传递到最上面的 onTouchEvent 也返回 false 的话，这个事件就会“消失”， 而且接收不到下一次事件。（这指的是 down 到 up 之间的一系列事件）。Touchevent 中，返回值是 true ，则说明消耗掉了这个事件。

这样说可能还有点抽象，这里我们来换种思路：

假如点击事件是一个难题，这个难题最终被上级领导分给了一个工程师主管去处理（事件分发），然而主管很忙不想处理（interceptTouchEvent返回false不拦截），主管把任务分给工程师，结果工程师没有搞定（onTouchEvent返回了false），那么只能交给工程师-主管处理（上级的onTouchEvent被调用），如果主管也没搞定，那么只能交给再往上的上级去解决，就这样一层层往上抛。所以事件传递处理大概也是这样的流程。

（三）初步了解触摸事件的传递顺序后，我们通过实例来进一步分析上面事件传递过程

首先创建一个EventButton类继承Button：

[java] view plain copy

 print?

1. package com.zejian.android_event;  
2.   
3. import android.content.Context;  
4. import android.util.AttributeSet;  
5. import android.util.Log;  
6. import android.view.MotionEvent;  
7. import android.widget.Button;  
8.   
9. /** 
10.  * @author : zejian 
11.  * @time : 2016年1月7日 下午10:10:34 
12.  * @email : [e-mail] 
13.  * @description : 
14.  */  
15. public class EventButton extends Button {  
16.     public EventButton(Context context) {  
17.         super(context);  
18.     }  
19.     public EventButton(Context context, AttributeSet attrs) {  
20.         super(context, attrs);  
21.     }  
22.     public EventButton(Context context, AttributeSet attrs, int defStyleAttr) {  
23.         super(context, attrs, defStyleAttr);  
24.     }  
25.     @Override  
26.     public boolean dispatchTouchEvent(MotionEvent ev) {  
27.         String str  = "ACTION_DOWN";  
28.         switch (ev.getAction()){  
29.             case MotionEvent.ACTION_DOWN:  
30.                 str = "ACTION_DOWN";  
31.                 break ;  
32.             case MotionEvent.ACTION_MOVE:  
33.                 str = "ACTION_MOVE";  
34.                 break;  
35.             case MotionEvent.ACTION_UP:  
36.                 str = "ACTION_UP";  
37.                 break;  
38.         }  
39.         Log.v("wzj", "=====View-----=====dispatchTouchEvent---========"+str) ;  
40.         return super.dispatchTouchEvent(ev);  
41.     }  
42.     @Override  
43.     public boolean onTouchEvent(MotionEvent event) {  
44.         String str  = "ACTION_DOWN";  
45.         switch (event.getAction()){  
46.             case MotionEvent.ACTION_DOWN:  
47.                 str = "ACTION_DOWN";  
48.                 break ;  
49.             case MotionEvent.ACTION_MOVE:  
50.                 str = "ACTION_MOVE";  
51.                 break;  
52.             case MotionEvent.ACTION_UP:  
53.                 str = "ACTION_UP";  
54.                 break;  
55.         }  
56.         Log.v("wzj","=====View-----=====onTouchEvent---------========"+str) ;  
57. //        return super.onTouchEvent(event);  
58.         return true;  
59.     }  
60. }  

在这个类中并没有复杂的逻辑，我们仅仅重写了dispatchTouchEvent（）方法和onTouchEvent（）方法。

接着我们再创建一个GroupViewEvent继承于LinearLayout：

[java] view plain copy

 print?

1. <span style="font-size:14px;">package com.zejian.android_event;  
2.   
3. import android.annotation.SuppressLint;  
4. import android.content.Context;  
5. import android.util.AttributeSet;  
6. import android.util.Log;  
7. import android.view.MotionEvent;  
8. import android.widget.LinearLayout;  
9.   
10. /** 
11.  * @author : zejian 
12.  * @time : 2016年1月7日 下午10:11:45 
13.  * @email : [e-mail] 
14.  * @description : 
15.  */  
16. public class GroupViewLayout extends LinearLayout {  
17.   
18.     public GroupViewLayout(Context context) {  
19.         super(context);  
20.     }  
21.   
22.     public GroupViewLayout(Context context, AttributeSet attrs) {  
23.         super(context, attrs);  
24.     }  
25.   
26.     @SuppressLint("NewApi")  
27.     public GroupViewLayout(Context context, AttributeSet attrs, int defStyleAttr) {  
28.         super(context, attrs, defStyleAttr);  
29.     }  
30.   
31.     @Override  
32.     public boolean onInterceptTouchEvent(MotionEvent ev) {  
33.         boolean handle = false;  
34.         String str = "ACTION_DOWN";  
35.         switch (ev.getAction()) {  
36.         case MotionEvent.ACTION_DOWN:  
37.             str = "ACTION_DOWN";  
38.             // handle = true ;  
39.             break;  
40.         case MotionEvent.ACTION_MOVE:  
41.             str = "ACTION_MOVE";  
42.             // handle = true ;  
43.             break;  
44.         case MotionEvent.ACTION_UP:  
45.             str = "ACTION_UP";  
46.             handle = true;  
47.             break;  
48.         }  
49.         Log.v("wzj", "=====ViewGroup=====onInterceptTouchEvent========" + str);  
50. //      if (handle) {  
51. //          return handle;  
52. //      }  
53.         return super.onInterceptTouchEvent(ev);  
54.     }  
55.   
56.     @Override  
57.     public boolean dispatchTouchEvent(MotionEvent ev) {  
58.         boolean handle = false;  
59.         String str = "ACTION_DOWN";  
60.         switch (ev.getAction()) {  
61.         case MotionEvent.ACTION_DOWN:  
62.             str = "ACTION_DOWN";  
63.             // handle = true ;  
64.             break;  
65.         case MotionEvent.ACTION_MOVE:  
66.             str = "ACTION_MOVE";  
67.             // handle = true ;  
68.             break;  
69.         case MotionEvent.ACTION_UP:  
70.             str = "ACTION_UP";  
71.             // handle = true ;  
72.             break;  
73.         }  
74.         Log.v("wzj", "=====ViewGroup=====dispatchTouchEvent---========" + str);  
75.         // if(handle){  
76.         // return handle ;  
77.         // }  
78.         return super.dispatchTouchEvent(ev);  
79.     }  
80.   
81.     @Override  
82.     public boolean onTouchEvent(MotionEvent event) {  
83.         String str = "ACTION_DOWN";  
84.         boolean handle = false;  
85.         switch (event.getAction()) {  
86.         case MotionEvent.ACTION_DOWN:  
87.             str = "ACTION_DOWN";  
88.             handle = true;  
89.             break;  
90.         case MotionEvent.ACTION_MOVE:  
91.             str = "ACTION_MOVE";  
92.             // handle = true ;  
93.             break;  
94.         case MotionEvent.ACTION_UP:  
95.             str = "ACTION_UP";  
96.             // handle = true ;  
97.             break;  
98.         }  
99.         Log.v("wzj", "=====ViewGroup=====onTouchEvent---------========" + str);  
100.         // if(handle){  
101.         // return handle ;  
102.         // }  
103.         return super.onTouchEvent(event);  
104.     }  
105. }</span>  

这是一个布局类，将存放上面两个自定义的EventButton和EventTextView的控件；

xml布局文件如下：

[java] view plain copy

 print?

1. <com.zejian.android_event.GroupViewLayout xmlns:android="http://schemas.android.com/apk/res/android"  
2.     android:layout_width="match_parent"  
3.     android:layout_height="match_parent"  
4.     android:orientation="vertical"  
5.     android:layout_gravity="center_horizontal"  
6. >  
7.     <com.zejian.android_event.EventButton  
8.         android:layout_width="120dp"  
9.         android:layout_height="60dp"  
10.         android:text="eventBut"/>  
11. </com.zejian.android_event.GroupViewLayout>  

最后就是MainActivity类了：

[java] view plain copy

 print?

1. package com.zejian.android_event;  
2.   
3. import android.app.Activity;  
4. import android.os.Bundle;  
5. import android.util.Log;  
6. import android.view.MotionEvent;  
7.   
8. public class MainActivity extends Activity {  
9.       
10.     @Override  
11.     protected void onCreate(Bundle savedInstanceState) {  
12.         super.onCreate(savedInstanceState);  
13.         setContentView(R.layout.activity_main);       
14.     }  
15.     /** 
16.      * 主要负责对ontouch事件进行分发，本身不处理ontouch事件。而分发的方式由其返回值决定 
17.      *  返回值： 
18.      *  返回值为true时，则将事件交给当前view本身的onTouchEvent处理。 
19.      *  返回值为false时，则将事件交给当前view本身的onInterceptTouchEvent()处理， 
20.      *  再由其决定事件传递的方向 
21.      */  
22.     @Override  
23.     public boolean dispatchTouchEvent(MotionEvent ev) {  
24.         String tag = "ACTION_DOWN";  
25.         switch (ev.getAction()) {  
26.         case MotionEvent.ACTION_DOWN:  
27.             tag = "ACTION_DOWN";  
28.             break;  
29.         case MotionEvent.ACTION_MOVE:  
30.             tag = "ACTION_MOVE";  
31.             break;  
32.         case MotionEvent.ACTION_UP:  
33.             tag = "ACTION_UP";  
34.             break;  
35.         }  
36.         Log.v("wzj","=====Activity =====dispatchTouchEvent---========"+tag) ;  
37.         return super.dispatchTouchEvent(ev);  
38.     }  
39.       
40.       
41.      @Override  
42.       public boolean onTouchEvent(MotionEvent event) {  
43.         String tag  = "ACTION_DOWN";  
44.         boolean handle = false ;  
45.         switch (event.getAction()){  
46.           case MotionEvent.ACTION_DOWN:  
47.               tag  = "ACTION_DOWN";  
48.             break ;  
49.           case MotionEvent.ACTION_MOVE:  
50.               tag = "ACTION_MOVE";  
51.             handle = true ;  
52.             break;  
53.           case MotionEvent.ACTION_UP:  
54.               tag  = "ACTION_UP";  
55.             break;  
56.         }  
57.         Log.v("wzj","=====Activity =====onTouchEvent---------========"+tag ) ;  
58.         return super.onTouchEvent(event);  
59.       }  
60.       
61. }  

然后我们运行一下，看看打印的Log日志（事件均未被消费掉）：

Activity 的 dispatchTouchEvent的事件分发给ViewGroup（暂时忽略窗口PhoneWindow和DecorView的传递），当dispatchTouchEvent返回false时，ViewGroup再通过事件拦截onInterceptTouchEvent（只有 ViewGroup 才有此方法）来判断，是否拦截事件，如果返回false也就是没有拦截，则将事件分发给 子View 的分发机制dispatchTouchEvent；子View 获取到事件后，就开始调用 onTouchEvent 方法，如果 View 的 onTouchEvent 返回false，即未把事件消费掉，则把事件有传递给 父类ViewGroup 的 onTouchEvent，同理，ViewGroup 未把事件消费掉，继续往下级传到了 Activity 的 onTouchEvent 事件处理中。(当然这里只是分析ACTION_DOWM事件，剩余ACTION_MOVE 和ACTION_UP也是类似的情况)，为了更好的理解下面我给出图解：

通过上图，我们可以得出以下几点结论：

1、Android 事件传递是层级传递的；

2、dispatchTouchEvent从底层向上层传递，而onTouchEvent刚好相反；

3、onInterceptTouchEvent返回为 true 时，将执行同层级的onTouchEvent，而dispatchTouchEvent和onTouchEvent返回 true 时，将终止事件的传递。

4.如果事件在view最终都未被消费（所谓的消费是指view未处理该事件）的话，那么将交给activity处理

好了说完了上面，我们再来提一个细节性的问题：上面最后两行的信息log，然后大家再来看一组调试信息：

事实上这是代码中ViewGroup 和 View的onTouchEvent事件在action 为ACTION_DOWN时返回false也就是未消费掉事件，因此最终都会返回给Activity,所以这里可以看到只有在 ACTION_DOWN 的时候是按照我们分析的流程图来执行，而 ACTION_MOVE、ACTION_UP 都只是执行了 Activity 的dispatchTouchEvent和onTouchEvent，但这又是为什么？事实上，上面那张图的流程是没有问题的，只是有些事件被拦截或消费掉。

ViewGroup 和 View的dispatchTouchEvent分发事件在 action 为ACTION_DOWN时没有被拦截且onTouchEvent的处理事件在 action 为ACTION_DOWN时未被消费，当 action 为ACTION_MOVE或ACTION_UP时，那么ViewGroup 和 View的dispatchTouchEvent和onTouchEvent将不会再次被调用，这就好比，上级把难题交给工程师处理，结果工程师没搞定，那么短期内这个问题就不会再次交给这个工程师处理，这样很好理解把，最终领导自己（activity）处理这一序列难题，因此dispatchTouchEvent和onTouchEvent只有在 activity 被调用。记住ACTION_DOWN，ACTION_MOVE，ACTION_UP一般都是一个序列操作。

下面来看一组log信息，(EventButton)View的onTouchEvent事件在action 为ACTION_DOWN时返回true也就是消费掉事件：

因此，现在我们可以看到无论是ACTION_DOWN或者ACTION_MOVE还是ACTION_UP都是按上面那么图的顺序走的，唯一不同的是在子类View的时候onTouchEvent就已经把事件消费了，所以无需再沿路返回给父类，因此Activity或者GroupView自然也不会调用onTouchEvent方法；相信现在对事件的传递都已经有比较清晰的了解了，好了，事件机制入门篇就到此完结了。下一篇我们将从源码的角度入手分析事件监听机制的整个流程。