Android 從源碼的角度分析View的事件分發（上）

問題：Android中的onClick()和onTouch()誰先執行？
下面通過一個具體的實例來解析：
代碼如下，布局文件：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center">
    
    <Button
        android:id="@+id/bt_onclick"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="點我吆！"
        android:padding="10dp"
        android:background="@color/colorPrimary"
        android:gravity="center"
        android:layout_gravity="center"
        android:textColor="@color/white"
        android:textSize="15sp"/>

</LinearLayout>```

onClick()事件和onTouch()事件代碼：

bt_onclick.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Log.d("TAG", "onClick execute");
}
});

bt_onclick.setOnTouchListener(new View.OnTouchListener() {
@Override
public boolean onTouch(View v, MotionEvent event) {
Log.d("TAG", "onTouch execute, action " + event.getAction());
return false;
}
});```
按鈕被點擊時執行的結果：

onClick和onTouch事件

onTouch()方法執行多次.png

修改onTouch方法的返回值為true后的結果

尋找：View中的dispatchTouchEvent()方法

public boolean dispatchTouchEvent(MotionEvent event) {  
    if (mOnTouchListener != null && (mViewFlags & ENABLED_MASK) == ENABLED &&  
            mOnTouchListener.onTouch(this, event)) {  
        return true;  
    }  
    return onTouchEvent(event);  
}```
**這個方法非常簡單，只有短短幾行代碼，我們可以看出，在這個方法內，首先是進行一個判斷，如果```mOnTouchListener != null```,```
(mViewFlags & ENABLED_MASK) == ENABLED```和```
mOnTouchListener.onTouch(this, event)```這三個條件都為真時，就返回true，否者就去執行onTouchEvent(event)方法，并返回。**
* 先看一下第一個條件，```mOnTouchListener```這個變量實在哪里賦值的呢？我們通過尋找之后在View里發現了如下方法：

public void setOnTouchListener(OnTouchListener l) {
mOnTouchListener = l;
} 通過看源碼，我們找到了，mOnTouchListener正是在setOnTouchListener方法里賦值的，也就是說只要我們給控件注冊了touch事件，mOnTouchListener```就一定會被賦值。

• 第二個條件(mViewFlags & ENABLED_MASK) == ENABLED是判斷當前點擊的控件是否是enable（可用的），按鈕默認都是enable（可用的），因此這個條件恒為true。
• 第三個條件就比較關鍵了。mOnTouchListener.onTouch(this, event),其實也就是去回調控件注冊touch事件時的onTouch()方法。也就是說如果我們在onTouch()方法里返回true，就會讓這三個條件全部成立，從而整個方法直接返回true。如果我們在onTouch()方法里返回false，就會去執行onTouchEvent(event)方法。

現在我們可以結合前面的例子來分析一下，首先在dispatchTouchEvent()方法中最先執行的就是onTouch()方法，因此onTouch()肯定是要優先于onClick()執行的，也是印證了剛剛的打印結果。而如果在onTouch()方法里返回了true，就會讓dispatchTouchEvent()方法直接返回true，不會再繼續往下執行。而打印結果也證實了如果onTouch()方法返回true，onClick()方法就不會被執行了。
根據以上源碼分析，從原理上解釋我們前面例子運行的結果。而上面的分析還透漏出一個重要的信息，那就是onClick的調用肯定是在onTouchEvent(event)方法中的，那我們馬上來看onTouchEvent的源碼，代碼如下：

public boolean onTouchEvent(MotionEvent event) {  
    final int viewFlags = mViewFlags;  
    if ((viewFlags & ENABLED_MASK) == DISABLED) {  
        // A disabled view that is clickable still consumes the touch  
        // events, it just doesn't respond to them.  
        return (((viewFlags & CLICKABLE) == CLICKABLE ||  
                (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE));  
    }  
    if (mTouchDelegate != null) {  
        if (mTouchDelegate.onTouchEvent(event)) {  
            return true;  
        }  
    }  
14  if (((viewFlags & CLICKABLE) == CLICKABLE ||  
15        (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {  
16      switch (event.getAction()) {  
            case MotionEvent.ACTION_UP:  
                boolean prepressed = (mPrivateFlags & PREPRESSED) != 0;  
                if ((mPrivateFlags & PRESSED) != 0 || prepressed) {  
                    // take focus if we don't have it already and we should in  
                    // touch mode.  
                    boolean focusTaken = false;  
                    if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {  
                        focusTaken = requestFocus();  
                    }  
                    if (!mHasPerformedLongPress) {  
                        // This is a tap, so remove the longpress check  
                        removeLongPressCallback();  
                        // Only perform take click actions if we were in the pressed state  
                        if (!focusTaken) {  
                            // Use a Runnable and post this rather than calling  
                            // performClick directly. This lets other visual state  
                            // of the view update before click actions start.  
                            if (mPerformClick == null) {  
                                mPerformClick = new PerformClick();  
                            }  
37                          if (!post(mPerformClick)) {  
38                                performClick();  
39                          }  
                        }  
                    }  
                    if (mUnsetPressedState == null) {  
                        mUnsetPressedState = new UnsetPressedState();  
                    }  
                    if (prepressed) {  
                        mPrivateFlags |= PRESSED;  
                        refreshDrawableState();  
                        postDelayed(mUnsetPressedState,  
                                ViewConfiguration.getPressedStateDuration());  
                    } else if (!post(mUnsetPressedState)) {  
                        // If the post failed, unpress right now  
                        mUnsetPressedState.run();  
                    }  
                    removeTapCallback();  
                }  
                break;  
            case MotionEvent.ACTION_DOWN:  
                if (mPendingCheckForTap == null) {  
                    mPendingCheckForTap = new CheckForTap();  
                }  
                mPrivateFlags |= PREPRESSED;  
                mHasPerformedLongPress = false;  
                postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());  
                break;  
            case MotionEvent.ACTION_CANCEL:  
                mPrivateFlags &= ~PRESSED;  
                refreshDrawableState();  
                removeTapCallback();  
                break;  
            case MotionEvent.ACTION_MOVE:  
                final int x = (int) event.getX();  
                final int y = (int) event.getY();  
                // Be lenient about moving outside of buttons  
                int slop = mTouchSlop;  
                if ((x < 0 - slop) || (x >= getWidth() + slop) ||  
                        (y < 0 - slop) || (y >= getHeight() + slop)) {  
                    // Outside button  
                    removeTapCallback();  
                    if ((mPrivateFlags & PRESSED) != 0) {  
                        // Remove any future long press/tap checks  
                        removeLongPressCallback();  
                        // Need to switch from pressed to not pressed  
                        mPrivateFlags &= ~PRESSED;  
                        refreshDrawableState();  
                    }  
                }  
                break;  
88        }  
89      return true;  
90    }  
91    return false;  
}  ```
首先在第14行我們可以看出，如果該控件是可以點擊的就會進入到第16行的switch判斷中去，而如果當前的事件是抬起手指，則會進入到MotionEvent.ACTION_UP這個case當中。在經過種種的判斷之后，會執行到第38行的performClick()方法，那我們進入到這個方法可以看看：

public boolean performClick() {
sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
if (mOnClickListener != null) {
playSoundEffect(SoundEffectConstants.CLICK);
mOnClickListener.onClick(this);
return true;
}
return false;
} ```
可以看到，只要mOnClickListener不是null，就會去調用它的onClick()方法，那mOnClickListener又在哪進行賦值呢？我們接著看，下面的代碼：

public void setOnClickListener(OnClickListener l) {  
    if (!isClickable()) {  
        setClickable(true);  
    }  
    mOnClickListener = l;  
}  ```
好了，一切都是那么清楚了！**當我們通過setOnclickListener()方法來給控件注冊一個點擊事件時，就會給mOnClickListener進行賦值，然后每當控件被點擊時，都會在performClick()方法里回調被點擊控件的onClick()方法。**

這樣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```可以得到執行。

那我們可以換一個控件，將Button控件替換成ImageView，然后給它注冊一個touch事件，并返回false。如下所示：

imageView.setOnTouchListener(new OnTouchListener() {
@Override
public boolean onTouch(View v, MotionEvent event) {
Log.d("TAG", "onTouch execute, action " + event.getAction());
return false;
}
});```
運行一下程序，點擊ImageView，你會發現結果如下：

在ACTION_DOWN執行完后，后面的一系列action都不會得到執行了。這又是為什么呢？因為ImageView和Button按鈕不同，它是默認不可點擊的，因此在onTouchEvent的第14行判斷時無法進入到if的內部，直接跳到第91行返回了false，也就導致后面其它的action都無法執行了。

好了，關于View的事件分發，我想講的東西全都在這里了。現在我們再來回顧一下開篇時提到的那三個問題，相信每個人都會有更深一層的理解。

總結：
1.onTouch和onTouchEvent有什么區別，又該如何使用？
從源碼中可以看出，這兩個方法都是在View的dispatchTouchEvent中調用的，onTouch優先于onTouchEvent執行。如果onTouch方法中通過返回true將事件消費掉，onTouchEvent將不會再執行。
另外需要注意的是，onTouch能夠得到執行需要兩個前提條件，第一mOnTouchListener的值不能為空，第二是當前點擊的控件必須是enable（可用的）。因此如果你有一個控件是非enable的話，那么給它注冊onTouch事件將永遠得不到執行。對于這一類控件，如果我們想要監聽它的touch事件，就必須通過在該控件中重寫onTouchEvent方法來實現。

2. 為什么給ListView引入了一個滑動菜單的功能，ListView就不能滾動了？
如果你閱讀了Android實現圖片滾動控件，含頁簽功能，讓你的應用像淘寶一樣炫起來 這篇文章。當時我在圖片輪播器里使用Button，主要就是因為Button是可點擊的，而ImageView是不可點擊的。如果想要使用ImageView，可以有兩種改法。第一，在ImageView的onTouch方法里返回true，這樣可以保證ACTION_DOWN之后的其它action都能得到執行，才能實現圖片滾動的效果。第二，在布局文件里面給ImageView增加一個android:clickable="true"的屬性，這樣ImageView變成可點擊的之后，即使在onTouch里返回了false，ACTION_DOWN之后的其它action也是可以得到執行的。

Android 從源碼的角度分析ViewGroup的事件分發（下）

問題：什么是ViewGroup?它與普通的View有什么區別？
顧名思義，ViewGroup就是一組View的集合，它包含很多的子View和子ViewGroup，是Android中所有布局的父類或者間接父類，像LinerLayout、RelativeLayout等都是繼承自ViewGroup的。但ViewGroup實際上也是一個View，只不過比起View，它多了可以包含子View和定義布局參數的功能。ViewGroup繼承結構示意圖如下所示：

public class MyLayout extends LinearLayout{
    public MyLayout(Context context) {
        super(context);
    }
    public MyLayout(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
    }
    public MyLayout(Context context, @Nullable AttributeSet attrs
                                         , int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }
}

布局文件：

<?xml version="1.0" encoding="utf-8"?>
<app.wangling.com.myapplication.MyLayout
    xmlns:tools="http://schemas.android.com/tools"
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/my_layout"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <Button
        android:id="@+id/bt_button1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:padding="10dp"
        android:text="點擊按鈕1"/>

    <Button
        android:id="@+id/bt_button2"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:padding="10dp"
        android:text="點擊按鈕2"/>

</app.wangling.com.myapplication.MyLayout>

點擊事件：

 my_layout.setOnTouchListener(new View.OnTouchListener() {
       @Override
       public boolean onTouch(View v, MotionEvent event) {
             Log.d("TAG", "myLayout on touch");
             return false;
       }
  });

  bt_button1.setOnClickListener(new View.OnClickListener() {
       @Override
       public void onClick(View v) {
            Log.d("TAG", "You clicked button1");
       }
   });

   bt_button2.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
             Log.d("TAG", "You clicked button2");
        }
   });```
我們在MyLayout的onTouch方法，和Button1、Button2的onClick方法中都打印了一句話。現在運行一下項目，效果圖如下所示：
![](http://upload-images.jianshu.io/upload_images/3416944-7194c64f56289bbb?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
分別點擊一下Button1、Button2和空白區域，打印結果如下所示：
![](http://upload-images.jianshu.io/upload_images/3416944-380625281a4f4e98?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
你會發現，當點擊按鈕的時候，MyLayout注冊的onTouch()方法并不會執行，只有點擊空白區域的時候該方法才會被執行。你可以先理解為Button的onClick()方法將事件消費掉了，因此事件不會再繼續向下傳遞。
疑問：那么，我們可以看出Android中的touch事件是先傳遞到View，再傳遞到ViewGroup？現在下結論還未免過早，讓我們再做一次實驗。
查閱文檔可以看出，ViewGroup中有一個onInterceptTouchEvent()方法，我們來看一下方法中的源碼：

/**
 * Implement this method to intercept all touch screen motion events.  This
 * allows you to watch events as they are dispatched to your children, and
 * take ownership of the current gesture at any point.
 *
 * <p>Using this function takes some care, as it has a fairly complicated
 * interaction with {@link View#onTouchEvent(MotionEvent)
 * View.onTouchEvent(MotionEvent)}, and using it requires implementing
 * that method as well as this one in the correct way.  Events will be
 * received in the following order:
 *
 * <ol>
 * <li> You will receive the down event here.
 * <li> The down event will be handled either by a child of this view
 * group, or given to your own onTouchEvent() method to handle; this means
 * you should implement onTouchEvent() to return true, so you will
 * continue to see the rest of the gesture (instead of looking for
 * a parent view to handle it).  Also, by returning true from
 * onTouchEvent(), you will not receive any following
 * events in onInterceptTouchEvent() and all touch processing must
 * happen in onTouchEvent() like normal.
 * <li> For as long as you return false from this function, each following
 * event (up to and including the final up) will be delivered first here
 * and then to the target's onTouchEvent().
 * <li> If you return true from here, you will not receive any
 * following events: the target view will receive the same event but
 * with the action {@link MotionEvent#ACTION_CANCEL}, and all further
 * events will be delivered to your onTouchEvent() method and no longer
 * appear here.
 * </ol>
 *
 * @param ev The motion event being dispatched down the hierarchy.
 * @return Return true to steal motion events from the children and have
 * them dispatched to this ViewGroup through onTouchEvent().
 * The current target will receive an ACTION_CANCEL event, and no further
 * messages will be delivered here.
 */
public boolean onInterceptTouchEvent(MotionEvent ev) {
    return false;
}

如果不看源碼，你還真的被注釋嚇到，這么多引文注釋呀，可是看了源碼如此簡單！只有一行代碼，返回一個false。
既然是布爾型的返回，那么只有兩種可能，我們在MyLayout中重寫這個方法，然后返回一個true試試看，代碼如下：

public class MyLayout extends LinearLayout{
public MyLayout(Context context) {
super(context);
}
public MyLayout(Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
}
public MyLayout(Context context, @Nullable AttributeSet attrs
, int defStyleAttr) {
super(context, attrs, defStyleAttr);
}
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
return true;
}
}```
再次運行項目，然后分別點擊Button1，Button2和空白區域，打印結果如下所示：

你會發現，不管你點擊哪里，永遠都只會觸發MyLayout的touch事件了，按鈕的點擊事件完全被屏蔽了！這是為什么呢？如果Android中的touch事件是先傳遞到View，再傳遞到ViewGroup的，那么MyLayout又怎么可能屏蔽Button的點擊事件呢？
哈哈！看來只能通過閱讀源碼，搞清楚Android中的ViewGroup的事件分發機制了，才能解決我們心中的疑惑了，不過這里我想先給大家透漏一句，Android中touch事件的傳遞，絕對是先傳遞到ViewGroup，再傳遞到View。記住我前面所講到的。只要你觸摸了任何控件，就一定調用該控件的dispatchTouchEvent()方法，這個說法是沒有錯的，只不過還不夠完整。實際情況是，當你點擊了某一個控件，首先會去調用該控件所在布局的dispatchTouchEvent()方法，然后在布局的dispatchTouchEvent()方法中找到被點擊的相應的控件，再去調用該控件的dispatchTouchEvent()方法。如果我們點擊了MyLayout中的按鈕，會先去調用MyLayout的dispatchTouchEvent()方法，可是你會發現MyLayout中并沒有這個方法。那就在到它的父類LinearLayout中找一找，發現也沒有這個方法。那只好繼續再找LinearLayout的父類ViewGroup，你終于在ViewGroup中看到了這個方法，按鈕的dispatchTouchEvent()方法就是這里調用的。修改后的示意圖如下所示：

public boolean dispatchTouchEvent(MotionEvent ev) {  
    final int action = ev.getAction();  
    final float xf = ev.getX();  
    final float yf = ev.getY();  
    final float scrolledXFloat = xf + mScrollX;  
    final float scrolledYFloat = yf + mScrollY;  
    final Rect frame = mTempRect;  
    boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;  
    if (action == MotionEvent.ACTION_DOWN) {  
        if (mMotionTarget != null) {  
            mMotionTarget = null;  
        }  
13    if (disallowIntercept || !onInterceptTouchEvent(ev)) {  
14          ev.setAction(MotionEvent.ACTION_DOWN);  
            final int scrolledXInt = (int) scrolledXFloat;  
            final int scrolledYInt = (int) scrolledYFloat;  
            final View[] children = mChildren;  
            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)) {  
                        final float xc = scrolledXFloat - child.mLeft;  
                        final float yc = scrolledYFloat - child.mTop;  
                        ev.setLocation(xc, yc);  
                        child.mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;  
29                      if (child.dispatchTouchEvent(ev))  {  
30                          mMotionTarget = child;  
31                          return true;  
                        }  
                    }  
                }  
            }  
        }  
    }  
    boolean isUpOrCancel = (action == MotionEvent.ACTION_UP) ||  
            (action == MotionEvent.ACTION_CANCEL);  
    if (isUpOrCancel) {  
        mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;  
    }  
    final View target = mMotionTarget;  
44  if (target == null) {  
45      ev.setLocation(xf, yf);  
        if ((mPrivateFlags & CANCEL_NEXT_UP_EVENT) != 0) {  
            ev.setAction(MotionEvent.ACTION_CANCEL);  
            mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;  
        }  
50      return super.dispatchTouchEvent(ev);  
    }  
    if (!disallowIntercept && onInterceptTouchEvent(ev)) {  
        final float xc = scrolledXFloat - (float) target.mLeft;  
        final float yc = scrolledYFloat - (float) target.mTop;  
        mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;  
        ev.setAction(MotionEvent.ACTION_CANCEL);  
        ev.setLocation(xc, yc);  
        if (!target.dispatchTouchEvent(ev)) {  
        }  
        mMotionTarget = null;  
        return true;  
    }  
    if (isUpOrCancel) {  
        mMotionTarget = null;  
    }  
    final float xc = scrolledXFloat - (float) target.mLeft;  
    final float yc = scrolledYFloat - (float) target.mTop;  
    ev.setLocation(xc, yc);  
    if ((target.mPrivateFlags & CANCEL_NEXT_UP_EVENT) != 0) {  
        ev.setAction(MotionEvent.ACTION_CANCEL);  
        target.mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;  
        mMotionTarget = null;  
    }  
    return target.dispatchTouchEvent(ev);  
}  

這個方法代碼比較長，我們只能挑重點看，首先在第13行可以看到一個條件判斷，如果disallowIntercept和!onInterceptTouchEvent(ev)兩者有一個為true，就會進入到這個條件判斷中。disallowIntercept是指是否禁用掉事件攔截的功能，默認是false，也可以通過調用requestDisallowInterceptTouchEvent()方法對這個值進行修改。那么dang第一個值為false的時候就會完全依賴第二個值來決定是否可以進入到條件判斷的內部，第二個值是什么呢？竟然就是對onInterceptTouchEvent()方法的返回值取反 ！ 也就是說：如果我們在onInterceptTouchEvent()方法中返回false，就會讓第二個值為true，從而進入到條件判斷的內部，如果我們在onInterceptTouchEvent()方法中返回true，就會讓第二個值為false，從而跳出了這個條件判斷。
那我們重點來看下條件判斷的內部是怎么實現的。在第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中將無法接收到任何事件。
**