事件的分發機制(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的事件分發與消費機制