事件的分发机制(View篇和ViewGroup篇)

本文转载自查看原文 2015-06-06 20:41 3294 Android

参考声明：感谢郭霖http://blog.csdn.net/guolin_blog/article/details/9097463和张鸿洋http://blog.csdn.net/lmj623565791/article/details/38960443

http://blog.csdn.net/yanbober/article/details/45932123

以一个简单的activity为例，该activity中只有一个button，如果我们为该按钮添加监听，只需要这样：

1 button.setOnClickListener(new OnClickListener() {
2     @Override
3     public void onClick(View v) {
4         Log.d("TAG", "onClick execute");
5     }
6 });

onClick里面就可以写执行内容，如果我们还想给button添加一个touch事件，可以这样：

1 button.setOnTouchListener(new OnTouchListener() {
2     @Override
3     public boolean onTouch(View v, MotionEvent event) {
4         Log.d("TAG", "onTouch execute, action " + event.getAction());
5         return false;
6     }
7 });

那么当我们点击按钮时具体是哪个监听先执行呢？运行结果显示如下：

onTouch execute, action 0

onTouch execute, action 1

onClick execute

如此我们可以看到是touch事件先执行，分别执行了action down，action up，实际执行过程中由于抖动的情况，action move会前面两个action之间执行多次，而button的OnClick则是后执行的，因此因此事件传递的顺序是先经过onTouch，再传递到onClick
由上面onTouch方法中的代码可知，最后是返回的false，那如果改为返回true会是什么结果呢？结果显示onClick execute是不执行的，为什么呢？
简单理解就是此次事件被onTouch给消费掉了，不会继续向下传递了
那本质原因是什么呢？接下来将从源码的角度来分析：
其实在View中跟事件分发机制有关的就是两个方法：dispatchTouchEvent和onTouchEvent
其实当你触摸到控件时，就会调用dispatchTouchEvent方法，以前面点击Button为例，当我们点击该按钮时，应用会去Button的类中寻找该方法，发现没有，就会继续往上找，找到容纳该button的TextView时，发现该类中仍没有该方法，最后继续往上寻找，找到View这时发现了该方法：
首先看一下该方法的源码：

 1 /**
 2      * Pass the touch screen motion event down to the target view, or this
 3      * view if it is the target.
 4      *
 5      * @param event The motion event to be dispatched.
 6      * @return True if the event was handled by the view, false otherwise.
 7      */
 8     public boolean dispatchTouchEvent(MotionEvent event) {
 9         if (!onFilterTouchEventForSecurity(event)) {
10             return false;
11         }
12 
13         if (mOnTouchListener != null && (mViewFlags & ENABLED_MASK) == ENABLED &&
14                 mOnTouchListener.onTouch(this, event)) {
15             return true;
16         }
17         return onTouchEvent(event);
18     }

从13行看起，判断了三个条件：1、判断mOnTouchListener不为空 2、(mViewFlags & ENABLED_MASK) == ENABLED即触摸的控件使能 3、mOnTouchListener.onTouch(this, event)的onTouch方法返回值为true，当3个条件全部满足时返回true，否则返回onTouchEvent(event)该方法执行后的返回值

接下来，我们一一来分析：

1.mOnTouchListener是什么东东？上源码：

1    /**
2      * Register a callback to be invoked when a touch event is sent to this view.
3      * @param l the touch listener to attach to this view
4      */
5     public void setOnTouchListener(OnTouchListener l) {
6         mOnTouchListener = l;
7     }

该方法是在View里找到的，mOnTouchListener是在setOnTouchListener方法中设置的，事实上就是我们刚才在Activity中设置的setOnTouchListener，也就是说只要我们给控件注册了touch事件，mOnTouchListener就一定被赋值了

2.第二个条件是判断控件是否是使能的，按钮默认即使Enabled，所以为true

3.第三个条件是关键，该条件会回调控件注册touch事件时的onTouch方法，到这里关键就是看onTouch方法执行的返回值喽：

至此可以结合前面的例子来分析一下，首先在dispatchTouchEvent中最先执行的就是onTouch方法，因此onTouch肯定是要优先于onClick执行的，也是印证了刚刚的打印结果。而如果在onTouch方法里返回了true，就会让dispatchTouchEvent方法直接返回true，不会再继续往下执行。而打印结果也证实了如果onTouch返回true，onClick就不会再执行了。

由这个分析也可以知道OnClick方法必然是在onTouchEvent方法中执行的，那是不是这样的？上源码：

  1 /**
  2      * Implement this method to handle touch screen motion events.
  3      *
  4      * @param event The motion event.
  5      * @return True if the event was handled, false otherwise.
  6      */
  7     public boolean onTouchEvent(MotionEvent event) {
  8         final int viewFlags = mViewFlags;
  9 
 10         if ((viewFlags & ENABLED_MASK) == DISABLED) {
 11             // A disabled view that is clickable still consumes the touch
 12             // events, it just doesn't respond to them.
 13             return (((viewFlags & CLICKABLE) == CLICKABLE ||
 14                     (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE));
 15         }
 16 
 17         if (mTouchDelegate != null) {
 18             if (mTouchDelegate.onTouchEvent(event)) {
 19                 return true;
 20             }
 21         }
 22 
 23         if (((viewFlags & CLICKABLE) == CLICKABLE ||
 24                 (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {
 25             switch (event.getAction()) {
 26                 case MotionEvent.ACTION_UP:
 27                     boolean prepressed = (mPrivateFlags & PREPRESSED) != 0;
 28                     if ((mPrivateFlags & PRESSED) != 0 || prepressed) {
 29                         // take focus if we don't have it already and we should in
 30                         // touch mode.
 31                         boolean focusTaken = false;
 32                         if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {
 33                             focusTaken = requestFocus();
 34                         }
 35 
 36                         if (!mHasPerformedLongPress) {
 37                             // This is a tap, so remove the longpress check
 38                             removeLongPressCallback();
 39 
 40                             // Only perform take click actions if we were in the pressed state
 41                             if (!focusTaken) {
 42                                 // Use a Runnable and post this rather than calling
 43                                 // performClick directly. This lets other visual state
 44                                 // of the view update before click actions start.
 45                                 if (mPerformClick == null) {
 46                                     mPerformClick = new PerformClick();
 47                                 }
 48                                 if (!post(mPerformClick)) {
 49                                     performClick();
 50                                 }
 51                             }
 52                         }
 53 
 54                         if (mUnsetPressedState == null) {
 55                             mUnsetPressedState = new UnsetPressedState();
 56                         }
 57 
 58                         if (prepressed) {
 59                             mPrivateFlags |= PRESSED;
 60                             refreshDrawableState();
 61                             postDelayed(mUnsetPressedState,
 62                                     ViewConfiguration.getPressedStateDuration());
 63                         } else if (!post(mUnsetPressedState)) {
 64                             // If the post failed, unpress right now
 65                             mUnsetPressedState.run();
 66                         }
 67                         removeTapCallback();
 68                     }
 69                     break;
 70 
 71                 case MotionEvent.ACTION_DOWN:
 72                     if (mPendingCheckForTap == null) {
 73                         mPendingCheckForTap = new CheckForTap();
 74                     }
 75                     mPrivateFlags |= PREPRESSED;
 76                     mHasPerformedLongPress = false;
 77                     postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
 78                     break;
 79 
 80                 case MotionEvent.ACTION_CANCEL:
 81                     mPrivateFlags &= ~PRESSED;
 82                     refreshDrawableState();
 83                     removeTapCallback();
 84                     break;
 85 
 86                 case MotionEvent.ACTION_MOVE:
 87                     final int x = (int) event.getX();
 88                     final int y = (int) event.getY();
 89 
 90                     // Be lenient about moving outside of buttons
 91                     int slop = mTouchSlop;
 92                     if ((x < 0 - slop) || (x >= getWidth() + slop) ||
 93                             (y < 0 - slop) || (y >= getHeight() + slop)) {
 94                         // Outside button
 95                         removeTapCallback();
 96                         if ((mPrivateFlags & PRESSED) != 0) {
 97                             // Remove any future long press/tap checks
 98                             removeLongPressCallback();
 99 
100                             // Need to switch from pressed to not pressed
101                             mPrivateFlags &= ~PRESSED;
102                             refreshDrawableState();
103                         }
104                     }
105                     break;
106             }
107             return true;
108         }
109 
110         return false;
111     }

由23~24行的if判断可知只要点击了控件，就会进入事件类型的switch判断中，(注意最后返回值一定为true)，为了充分理解源码，我们就从action的执行顺序将源码一一分析一遍：

a、首先分析MotionEvent.ACTION_DOWN

72~74行：先判断mPendingCheckForTap是否为空，为空的话新建CheckForTap()

75行：给mPrivateFlags设置一个PREPRESSED的标识

76行：设置 mHasPerformedLongPress为 false说明长按还没有触发

77行：执行postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout()); 发送一个大小为ViewConfiguration.getTapTimeout()(115毫秒)的延迟

到达延迟时间后会执行CheckForTap()方法中的run方法：

 1   private final class CheckForTap implements Runnable {
 2         public void run() {
 3             mPrivateFlags &= ~PREPRESSED;
 4             mPrivateFlags |= PRESSED;
 5             refreshDrawableState();
 6             if ((mViewFlags & LONG_CLICKABLE) == LONG_CLICKABLE) {
 7                 postCheckForLongClick(ViewConfiguration.getTapTimeout());
 8             }
 9         }
10     }

在run方法里面取消mPrivateFlags的PREPRESSED，然后设置PRESSED标识，刷新背景，如果View支持长按事件，则再发一个延时消息，检测长按；

 1  private void postCheckForLongClick(int delayOffset) {
 2         mHasPerformedLongPress = false;
 3 
 4         if (mPendingCheckForLongPress == null) {
 5             mPendingCheckForLongPress = new CheckForLongPress();
 6         }
 7         mPendingCheckForLongPress.rememberWindowAttachCount();
 8         postDelayed(mPendingCheckForLongPress,
 9                 ViewConfiguration.getLongPressTimeout() - delayOffset);
10     }

 1 class CheckForLongPress implements Runnable {
 2 
 3         private int mOriginalWindowAttachCount;
 4 
 5         public void run() {
 6             if (isPressed() && (mParent != null)
 7                     && mOriginalWindowAttachCount == mWindowAttachCount) {
 8                 if (performLongClick()) {
 9                     mHasPerformedLongPress = true;
10                 }
11             }
12         }

可以看到，当用户按下，首先会设置标识为PREPRESSED

如果115后，没有抬起，会将View的标识设置为PRESSED且去掉PREPRESSED标识，然后发出一个检测长按的延迟任务，延时为：ViewConfiguration.getLongPressTimeout() - delayOffset（500ms -115ms），这个115ms刚好时检测额PREPRESSED时间；也就是用户从DOWN触发开始算起，如果500ms内没有抬起则认为触发了长按事件：

1、如果此时设置了长按的回调，则执行长按时的回调，且如果长按的回调返回true;才把mHasPerformedLongPress置为ture；

2、否则，如果没有设置长按回调或者长按回调返回的是false；则mHasPerformedLongPress依然是false;

b、MotionEvent.ACTION_MOVE

86~105行：86~87两行获取到当前触摸的x和y的坐标

91行判断当前的触摸点是否超出我们的view，如果移出了

1、执行removeTapCallback();

2、然后判断是否包含PRESSED标识，如果包含，移除长按的检查：removeLongPressCallback();

3、最后把mPrivateFlags中PRESSED标识去除，刷新背景；

1  private void removeTapCallback() {
2         if (mPendingCheckForTap != null) {
3             mPrivateFlags &= ~PREPRESSED;
4             removeCallbacks(mPendingCheckForTap);
5         }
6     }

这个是移除，DOWN触发时设置的PREPRESSED的检测；即当前触发时机在DOWN触发不到115ms时，你就已经移出控件外了；

如果115ms后，你才移出控件外，则你的当前mPrivateFlags一定为PRESSED且发送了长按的检测；

就会走上面的2和3；首先移除removeLongPressCallback（）
private void removeLongPressCallback() {
if (mPendingCheckForLongPress != null) {
removeCallbacks(mPendingCheckForLongPress);
}
}

然后把mPrivateFlags中PRESSED标识去除，刷新背景；

至此move分析完毕，只要用户移出了我们的控件：则将mPrivateFlags取出PRESSED标识，且移除所有在DOWN中设置的检测，长按等；

c、MotionEvent.ACTION_UP

26到69行：

27行：判断mPrivateFlags是否包含PREPRESSED

28行：如果包含PRESSED或者PREPRESSED则进入执行体，也就是无论是115ms内或者之后抬起都会进入执行体。

36行：如果mHasPerformedLongPress没有被执行，进入IF

38行：removeLongPressCallback（）；移除长按的检测

45-50行：如果mPerformClick如果mPerformClick为null，初始化一个实例，然后立即通过handler添加到消息队列尾部，如果添加失败则直接执行 performClick();添加成功，在mPerformClick的run方法中就是执行performClick（）；

终于执行了我们的click事件了，下面看一下performClick()方法：

 1  public boolean performClick() {
 2         sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
 3 
 4         if (mOnClickListener != null) {
 5             playSoundEffect(SoundEffectConstants.CLICK);
 6             mOnClickListener.onClick(this);
 7             return true;
 8         }
 9 
10         return false;
11     }

从代码可以看到如果mOnClickListener不为null，就会执行mOnClickListener.onClick(this);这里mOnClickListener是在哪里赋值的呢？

1 public void setOnClickListener(OnClickListener l) {
2     if (!isClickable()) {
3         setClickable(true);
4     }
5     mOnClickListener = l;
6 }

当我们通过调用setOnClickListener方法来给控件注册一个点击事件时，就会给mOnClickListener赋值。然后每当控件被点击时，都会在performClick()方法里回调被点击控件的onClick方法。

这里也就表明了，如果对于一个可点击控件如button既设置OnClickListener又设置OnTouch监听事件，OnClickListener会被屏蔽掉，只会在MotionEvent.ACTION_UP中执行click事件

这样View的整个事件分发的流程就让我们搞清楚了！不过别高兴的太早，现在还没结束，还有一个很重要的知识点需要说明，就是touch事件的层级传递。我们都知道如果给一个控件注册了touch事件，每次点击它的时候都会触发一系列的ACTION_DOWN，ACTION_MOVE，ACTION_UP等事件。这里需要注意，如果你在执行ACTION_DOWN的时候返回了false，后面一系列其它的action就不会再得到执行了。简单的说，就是当dispatchTouchEvent在进行事件分发的时候，只有前一个action返回true，才会触发后一个action。

说到这里，很多的朋友肯定要有巨大的疑问了。这不是在自相矛盾吗？前面的例子中，明明在onTouch事件里面返回了false，ACTION_DOWN和ACTION_UP不是都得到执行了吗？其实你只是被假象所迷惑了，让我们仔细分析一下，在前面的例子当中，我们到底返回的是什么。

参考着我们前面分析的源码，首先在onTouch事件里返回了false，就一定会进入到onTouchEvent方法中，然后我们来看一下onTouchEvent方法的细节。由于我们点击了按钮，就会进入到第14行这个if判断的内部，然后你会发现，不管当前的action是什么，最终都一定会走到第89行，返回一个true。

是不是有一种被欺骗的感觉？明明在onTouch事件里返回了false，系统还是在onTouchEvent方法中帮你返回了true。就因为这个原因，才使得前面的例子中ACTION_UP可以得到执行。

那我们可以换一个控件，将按钮替换成ImageView，然后给它也注册一个touch事件，并返回false。如下所示：

1 imageView.setOnTouchListener(new OnTouchListener() {
2     @Override
3     public boolean onTouch(View v, MotionEvent event) {
4         Log.d("TAG", "onTouch execute, action " + event.getAction());
5         return false;
6     }
7 });

运行一下程序，点击ImageView，你会发现结果如下：

在ACTION_DOWN执行完后，后面的一系列action都不会得到执行了。这又是为什么呢？因为ImageView和按钮不同，它是默认不可点击的，因此在onTouchEvent的第23行判断时无法进入到if的内部，直接跳到第91行返回了false，也就导致后面其它的action都无法执行了。

1. onTouch和onTouchEvent有什么区别，又该如何使用？

从源码中可以看出，这两个方法都是在View的dispatchTouchEvent中调用的，onTouch优先于onTouchEvent执行。如果在onTouch方法中通过返回true将事件消费掉，onTouchEvent将不会再执行。

另外需要注意的是，onTouch能够得到执行需要两个前提条件，第一mOnTouchListener的值不能为空，第二当前点击的控件必须是enable的。因此如果你有一个控件是非enable的，那么给它注册onTouch事件将永远得不到执行。对于这一类控件，如果我们想要监听它的touch事件，就必须通过在该控件中重写onTouchEvent方法来实现。

2. 为什么给ListView引入了一个滑动菜单的功能，ListView就不能滚动了？

如果你阅读了Android滑动框架完全解析，教你如何一分钟实现滑动菜单特效这篇文章，你应该会知道滑动菜单的功能是通过给ListView注册了一个touch事件来实现的。如果你在onTouch方法里处理完了滑动逻辑后返回true，那么ListView本身的滚动事件就被屏蔽了，自然也就无法滑动(原理同前面例子中按钮不能点击)，因此解决办法就是在onTouch方法里返回false。

3. 为什么图片轮播器里的图片使用Button而不用ImageView？

提这个问题的朋友是看过了Android实现图片滚动控件，含页签功能，让你的应用像淘宝一样炫起来这篇文章。当时我在图片轮播器里使用Button，主要就是因为Button是可点击的，而ImageView是不可点击的。如果想要使用ImageView，可以有两种改法。第一，在ImageView的onTouch方法里返回true，这样可以保证ACTION_DOWN之后的其它action都能得到执行，才能实现图片滚动的效果。第二，在布局文件里面给ImageView增加一个android:clickable="true"的属性，这样ImageView变成可点击的之后，即使在onTouch里返回了false，ACTION_DOWN之后的其它action也是可以得到执行的。

注：此处说的是onTouch中事件处理，和onTouchEvent无关，根据前面的onTouchEvent代码可知只有在ACTION_DOWN执行后，后面返回true，才会触发后面的其他触摸事件(ACTION_UP等)，也即上面的第一种改法，在ImageView的onTouch方法里返回true，当然也可以采用法2，使其和button一样

==================================================================================================================
最后引用一下鸿洋的总结：

1、整个View的事件转发流程是：

View.dispatchEvent->View.setOnTouchListener->View.onTouchEvent

在dispatchTouchEvent中会进行OnTouchListener的判断，如果OnTouchListener不为null且返回true，则表示事件被消费，onTouchEvent不会被执行；否则执行onTouchEvent。

2、onTouchEvent中的DOWN,MOVE,UP

DOWN时：

a、首先设置标志为PREPRESSED，设置mHasPerformedLongPress=false ;然后发出一个115ms后的mPendingCheckForTap；

b、如果115ms内没有触发UP，则将标志置为PRESSED，清除PREPRESSED标志，同时发出一个延时为500-115ms的，检测长按任务消息；

c、如果500ms内（从DOWN触发开始算），则会触发LongClickListener:

此时如果LongClickListener不为null，则会执行回调，同时如果LongClickListener.onClick返回true，才把mHasPerformedLongPress设置为true;否则mHasPerformedLongPress依然为false;

MOVE时：

主要就是检测用户是否划出控件，如果划出了：

115ms内，直接移除mPendingCheckForTap；

115ms后，则将标志中的PRESSED去除，同时移除长按的检查：removeLongPressCallback();

UP时：

a、如果115ms内，触发UP，此时标志为PREPRESSED，则执行UnsetPressedState，setPressed(false);会把setPress转发下去，可以在View中复写dispatchSetPressed方法接收；

b、如果是115ms-500ms间，即长按还未发生，则首先移除长按检测，执行onClick回调；

c、如果是500ms以后，那么有两种情况：

i.设置了onLongClickListener，且onLongClickListener.onClick返回true，则点击事件OnClick事件无法触发；

ii.没有设置onLongClickListener或者onLongClickListener.onClick返回false，则点击事件OnClick事件依然可以触发；

d、最后执行mUnsetPressedState.run()，将setPressed传递下去，然后将PRESSED标识去除；

关于长按和点击控件的疑问，这里鸿洋也给出了一个demo：参考一下

1、当同时设置setOnLongClickListener和setOnClickListener，只要setOnLongClickListener中的onClick返回false，则两个都会执行；返回true则会屏蔽setOnClickListener

这里给MyButton同时设置setOnClickListener和setOnLongClickListener，运行看看：

 1 package com.example.zhy_event03;
 2 
 3 import android.app.Activity;
 4 import android.os.Bundle;
 5 import android.util.Log;
 6 import android.view.MotionEvent;
 7 import android.view.View;
 8 import android.view.View.OnClickListener;
 9 import android.view.View.OnLongClickListener;
10 import android.view.View.OnTouchListener;
11 import android.widget.Button;
12 import android.widget.Toast;
13 
14 public class MainActivity extends Activity
15 {
16     protected static final String TAG = "MyButton";
17     private Button mButton ;
18     @Override
19     protected void onCreate(Bundle savedInstanceState)
20     {
21         super.onCreate(savedInstanceState);
22         setContentView(R.layout.activity_main);
23         
24         mButton = (Button) findViewById(R.id.id_btn);
25         mButton.setOnTouchListener(new OnTouchListener()
26         {
27             @Override
28             public boolean onTouch(View v, MotionEvent event)
29             {
30                 int action = event.getAction();
31 
32                 switch (action)
33                 {
34                 case MotionEvent.ACTION_DOWN:
35                     Log.e(TAG, "onTouch ACTION_DOWN");
36                     break;
37                 case MotionEvent.ACTION_MOVE:
38                     Log.e(TAG, "onTouch ACTION_MOVE");
39                     break;
40                 case MotionEvent.ACTION_UP:
41                     Log.e(TAG, "onTouch ACTION_UP");
42                     break;
43                 default:
44                     break;
45                 }
46                 
47                 return false;
48             }
49         });
50         mButton.setOnClickListener(new OnClickListener()
51         {
52             @Override
53             public void onClick(View v)
54             {
55                 Toast.makeText(getApplicationContext(), "onclick",Toast.LENGTH_SHORT).show();
56             }
57         });
58         
59         mButton.setOnLongClickListener(new OnLongClickListener()
60         {
61             @Override
62             public boolean onLongClick(View v)
63             {
64                 Toast.makeText(getApplicationContext(), "setOnLongClickListener",Toast.LENGTH_SHORT).show();
65                 return false;
66             }
67         });
68     }
69 
70     
71 }

可以看到LongClickListener已经ClickListener都触发了

首先我们来探讨一下，什么是ViewGroup？它和普通的View有什么区别？

顾名思义，ViewGroup就是一组View的集合，它包含很多的子View和子VewGroup，是Android中所有布局的父类或间接父类，像LinearLayout、RelativeLayout等都是继承自ViewGroup的。但ViewGroup实际上也是一个View，只不过比起View，它多了可以包含子View和定义布局参数的功能。ViewGroup继承结构示意图如下所示：

可以看到，我们平时项目里经常用到的各种布局，全都属于ViewGroup的子类。

简单介绍完了ViewGroup，我们现在通过一个Demo来演示一下Android中VewGroup的事件分发流程吧。

首先我们来自定义一个布局，命名为MyLayout，继承自LinearLayout，如下所示：

1 public class MyLayout extends LinearLayout {
2 
3     public MyLayout(Context context, AttributeSet attrs) {
4         super(context, attrs);
5     }
6 
7 }

然后，打开主布局文件activity_main.xml，在其中加入我们自定义的布局：

 1 <com.example.viewgrouptouchevent.MyLayout xmlns:android="http://schemas.android.com/apk/res/android"
 2     xmlns:tools="http://schemas.android.com/tools"
 3     android:id="@+id/my_layout"
 4     android:layout_width="match_parent"
 5     android:layout_height="match_parent"
 6     android:orientation="vertical" >
 7 
 8     <Button
 9         android:id="@+id/button1"
10         android:layout_width="match_parent"
11         android:layout_height="wrap_content"
12         android:text="Button1" />
13 
14     <Button
15         android:id="@+id/button2"
16         android:layout_width="match_parent"
17         android:layout_height="wrap_content"
18         android:text="Button2" />
19 
20 </com.example.viewgrouptouchevent.MyLayout>

可以看到，我们在MyLayout中添加了两个按钮，接着在MainActivity中为这两个按钮和MyLayout都注册了监听事件：

 1 myLayout.setOnTouchListener(new OnTouchListener() {
 2     @Override
 3     public boolean onTouch(View v, MotionEvent event) {
 4         Log.d("TAG", "myLayout on touch");
 5         return false;
 6     }
 7 });
 8 button1.setOnClickListener(new OnClickListener() {
 9     @Override
10     public void onClick(View v) {
11         Log.d("TAG", "You clicked button1");
12     }
13 });
14 button2.setOnClickListener(new OnClickListener() {
15     @Override
16     public void onClick(View v) {
17         Log.d("TAG", "You clicked button2");
18     }
19 });

我们在MyLayout的onTouch方法，和Button1、Button2的onClick方法中都打印了一句话。现在运行一下项目，效果图如下所示：

分别点击一下Button1、Button2和空白区域，打印结果如下所示：

你会发现，当点击按钮的时候，MyLayout注册的onTouch方法并不会执行，只有点击空白区域的时候才会执行该方法。你可以先理解成Button的onClick方法将事件消费掉了，因此事件不会再继续向下传递。

那就说明Android中的touch事件是先传递到View，再传递到ViewGroup的？现在下结论还未免过早了，让我们再来做一个实验。

查阅文档可以看到，ViewGroup中有一个onInterceptTouchEvent方法，我们来看一下这个方法的源码：

 1 /**
 2  * Implement this method to intercept all touch screen motion events.  This
 3  * allows you to watch events as they are dispatched to your children, and
 4  * take ownership of the current gesture at any point.
 5  *
 6  * <p>Using this function takes some care, as it has a fairly complicated
 7  * interaction with {@link View#onTouchEvent(MotionEvent)
 8  * View.onTouchEvent(MotionEvent)}, and using it requires implementing
 9  * that method as well as this one in the correct way.  Events will be
10  * received in the following order:
11  *
12  * <ol>
13  * <li> You will receive the down event here.
14  * <li> The down event will be handled either by a child of this view
15  * group, or given to your own onTouchEvent() method to handle; this means
16  * you should implement onTouchEvent() to return true, so you will
17  * continue to see the rest of the gesture (instead of looking for
18  * a parent view to handle it).  Also, by returning true from
19  * onTouchEvent(), you will not receive any following
20  * events in onInterceptTouchEvent() and all touch processing must
21  * happen in onTouchEvent() like normal.
22  * <li> For as long as you return false from this function, each following
23  * event (up to and including the final up) will be delivered first here
24  * and then to the target's onTouchEvent().
25  * <li> If you return true from here, you will not receive any
26  * following events: the target view will receive the same event but
27  * with the action {@link MotionEvent#ACTION_CANCEL}, and all further
28  * events will be delivered to your onTouchEvent() method and no longer
29  * appear here.
30  * </ol>
31  *
32  * @param ev The motion event being dispatched down the hierarchy.
33  * @return Return true to steal motion events from the children and have
34  * them dispatched to this ViewGroup through onTouchEvent().
35  * The current target will receive an ACTION_CANCEL event, and no further
36  * messages will be delivered here.
37  */
38 public boolean onInterceptTouchEvent(MotionEvent ev) {
39     return false;
40 }

如果不看源码你还真可能被这注释吓到了，这么长的英文注释看得头都大了。可是源码竟然如此简单！只有一行代码，返回了一个false！

好吧，既然是布尔型的返回，那么只有两种可能，我们在MyLayout中重写这个方法，然后返回一个true试试，代码如下所示：

 1 public class MyLayout extends LinearLayout {
 2 
 3     public MyLayout(Context context, AttributeSet attrs) {
 4         super(context, attrs);
 5     }
 6     
 7     @Override
 8     public boolean onInterceptTouchEvent(MotionEvent ev) {
 9         return true;
10     }
11     
12 }

现在再次运行项目，然后分别Button1、Button2和空白区域，打印结果如下所示：

你会发现，不管你点击哪里，永远都只会触发MyLayout的touch事件了，按钮的点击事件完全被屏蔽掉了！这是为什么呢？如果Android中的touch事件是先传递到View，再传递到ViewGroup的，那么MyLayout又怎么可能屏蔽掉Button的点击事件呢？

看来只有通过阅读源码，搞清楚Android中ViewGroup的事件分发机制，才能解决我们心中的疑惑了，不过这里我想先跟你透露一句，Android中touch事件的传递，绝对是先传递到ViewGroup，再传递到View的。记得在Android事件分发机制完全解析，带你从源码的角度彻底理解(上) 中我有说明过，只要你触摸了任何控件，就一定会调用该控件的dispatchTouchEvent方法。这个说法没错，只不过还不完整而已。实际情况是，当你点击了某个控件，首先会去调用该控件所在布局的dispatchTouchEvent方法，然后在布局的dispatchTouchEvent方法中找到被点击的相应控件，再去调用该控件的dispatchTouchEvent方法。如果我们点击了MyLayout中的按钮，会先去调用MyLayout的dispatchTouchEvent方法，可是你会发现MyLayout中并没有这个方法。那就再到它的父类LinearLayout中找一找，发现也没有这个方法。那只好继续再找LinearLayout的父类ViewGroup，你终于在ViewGroup中看到了这个方法，按钮的dispatchTouchEvent方法就是在这里调用的。修改后的示意图如下所示：

那还等什么？快去看一看ViewGroup中的dispatchTouchEvent方法的源码吧！代码如下所示：

 1 public boolean dispatchTouchEvent(MotionEvent ev) {
 2     final int action = ev.getAction();
 3     final float xf = ev.getX();
 4     final float yf = ev.getY();
 5     final float scrolledXFloat = xf + mScrollX;
 6     final float scrolledYFloat = yf + mScrollY;
 7     final Rect frame = mTempRect;
 8     boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
 9     if (action == MotionEvent.ACTION_DOWN) {
10         if (mMotionTarget != null) {
11             mMotionTarget = null;
12         }
13         if (disallowIntercept || !onInterceptTouchEvent(ev)) {
14             ev.setAction(MotionEvent.ACTION_DOWN);
15             final int scrolledXInt = (int) scrolledXFloat;
16             final int scrolledYInt = (int) scrolledYFloat;
17             final View[] children = mChildren;
18             final int count = mChildrenCount;
19             for (int i = count - 1; i >= 0; i--) {
20                 final View child = children[i];
21                 if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE
22                         || child.getAnimation() != null) {
23                     child.getHitRect(frame);
24                     if (frame.contains(scrolledXInt, scrolledYInt)) {
25                         final float xc = scrolledXFloat - child.mLeft;
26                         final float yc = scrolledYFloat - child.mTop;
27                         ev.setLocation(xc, yc);
28                         child.mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;
29                         if (child.dispatchTouchEvent(ev))  {
30                             mMotionTarget = child;
31                             return true;
32                         }
33                     }
34                 }
35             }
36         }
37     }
38     boolean isUpOrCancel = (action == MotionEvent.ACTION_UP) ||
39             (action == MotionEvent.ACTION_CANCEL);
40     if (isUpOrCancel) {
41         mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
42     }
43     final View target = mMotionTarget;
44     if (target == null) {
45         ev.setLocation(xf, yf);
46         if ((mPrivateFlags & CANCEL_NEXT_UP_EVENT) != 0) {
47             ev.setAction(MotionEvent.ACTION_CANCEL);
48             mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;
49         }
50         return super.dispatchTouchEvent(ev);
51     }
52     if (!disallowIntercept && onInterceptTouchEvent(ev)) {
53         final float xc = scrolledXFloat - (float) target.mLeft;
54         final float yc = scrolledYFloat - (float) target.mTop;
55         mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;
56         ev.setAction(MotionEvent.ACTION_CANCEL);
57         ev.setLocation(xc, yc);
58         if (!target.dispatchTouchEvent(ev)) {
59         }
60         mMotionTarget = null;
61         return true;
62     }
63     if (isUpOrCancel) {
64         mMotionTarget = null;
65     }
66     final float xc = scrolledXFloat - (float) target.mLeft;
67     final float yc = scrolledYFloat - (float) target.mTop;
68     ev.setLocation(xc, yc);
69     if ((target.mPrivateFlags & CANCEL_NEXT_UP_EVENT) != 0) {
70         ev.setAction(MotionEvent.ACTION_CANCEL);
71         target.mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;
72         mMotionTarget = null;
73     }
74     return target.dispatchTouchEvent(ev);
75 }

我们只挑重点看。首先在第13行可以看到一个条件判断，如果disallowIntercept和!onInterceptTouchEvent(ev)两者有一个为true，就会进入到这个条件判断中。disallowIntercept是指是否禁用掉事件拦截的功能，默认是false，也可以通过调用requestDisallowInterceptTouchEvent方法对这个值进行修改。那么当第一个值为false的时候就会完全依赖第二个值来决定是否可以进入到条件判断的内部，第二个值是什么呢？竟然就是对onInterceptTouchEvent方法的返回值取反！也就是说如果我们在onInterceptTouchEvent方法中返回false，就会让第二个值为true，从而进入到条件判断的内部，如果我们在onInterceptTouchEvent方法中返回true，就会让第二个值为false，从而跳出了这个条件判断。

这个时候你就可以思考一下了，由于我们刚刚在MyLayout中重写了onInterceptTouchEvent方法，让这个方法返回true，导致所有按钮的点击事件都被屏蔽了，那我们就完全有理由相信，按钮点击事件的处理就是在第13行条件判断的内部进行的！

那我们重点来看下条件判断的内部是怎么实现的。在第19行通过一个for循环，遍历了当前ViewGroup下的所有子View，然后在第24行判断当前遍历的View是不是正在点击的View，如果是的话就会进入到该条件判断的内部，然后在第29行调用了该View的dispatchTouchEvent，之后的流程就和 Android事件分发机制完全解析，带你从源码的角度彻底理解(上) 中讲解的是一样的了。我们也因此证实了，按钮点击事件的处理确实就是在这里进行的。

然后需要注意一下，调用子View的dispatchTouchEvent后是有返回值的。我们已经知道，如果一个控件是可点击的，那么点击该控件时，dispatchTouchEvent的返回值必定是true。因此会导致第29行的条件判断成立，于是在第31行给ViewGroup的dispatchTouchEvent方法直接返回了true。这样就导致后面的代码无法执行到了，也是印证了我们前面的Demo打印的结果，如果按钮的点击事件得到执行，就会把MyLayout的touch事件拦截掉。

那如果我们点击的不是按钮，而是空白区域呢？这种情况就一定不会在第31行返回true了，而是会继续执行后面的代码。那我们继续往后看，在第44行，如果target等于null，就会进入到该条件判断内部，这里一般情况下target都会是null，因此会在第50行调用super.dispatchTouchEvent(ev)。这句代码会调用到哪里呢？当然是View中的dispatchTouchEvent方法了，因为ViewGroup的父类就是View。之后的处理逻辑又和前面所说的是一样的了，也因此MyLayout中注册的onTouch方法会得到执行。之后的代码在一般情况下是走不到的了，我们也就不再继续往下分析。

再看一下整个ViewGroup事件分发过程的流程图吧，相信可以帮助大家更好地去理解：

现在整个ViewGroup的事件分发流程的分析也就到此结束了，我们最后再来简单梳理一下吧。

1. Android事件分发是先传递到ViewGroup，再由ViewGroup传递到View的。

2. 在ViewGroup中可以通过onInterceptTouchEvent方法对事件传递进行拦截，onInterceptTouchEvent方法返回true代表不允许事件继续向子View传递，返回false代表不对事件进行拦截，默认返回false。

3. 子View中如果将传递的事件消费掉，ViewGroup中将无法接收到任何事件。

参考：http://blog.csdn.net/lmj623565791/article/details/39102591

http://www.cnblogs.com/xiaoQLu/archive/2012/04/28/2474443.html

http://ryantang.me/blog/2014/01/02/android-event-dispatch/

免责声明！

本站转载的文章为个人学习借鉴使用，本站对版权不负任何法律责任。如果侵犯了您的隐私权益，请联系本站邮箱yoyou2525@163.com删除。

猜您在找 Android事件分发机制二：viewGroup与view对事件的处理【朝花夕拾】Android自定义View篇之（六）Android事件分发机制（中）从源码分析事件分发机制 Android面试必问！View 事件分发机制，看这一篇就够了！ View 点击事件的分发机制【朝花夕拾】Android自定义View篇之（五）Android事件分发机制（上）Touch三个重要方法的处理逻辑【朝花夕拾】Android自定义View篇之（七）Android事件分发机制（下）滑动冲突解决方案总结 Android事件分发机制：基础篇：最全面、最易懂 Android View的事件分发机制探索 Android View 事件分发机制详解 Android：View的事件分发与消费机制