事件分發

1、View的事件分發

比如說你當前有一個非常簡單的項目，只有一個Activity，並且Activity中只有一個按鈕。你可能已經知道，如果想要給這個按鈕註冊一個點擊事件，只需要調用：

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

這樣在onClick方法裏面寫實現，就可以在按鈕被點擊的時候執行。你可能也已經知道，如果想給這個按鈕再添加一個touch事件，只需要調用：

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

onTouch方法裏能做的事情比onClick要多一些，比如判斷手指按下、擡起、移動等事件。那麼如果我兩個事件都註冊了，哪一個會先執行呢？我們來試一下就知道了，運行程序點擊按鈕，打印結果如下：

可以看到，onTouch是優先於onClick執行的，並且onTouch執行了兩次，一次是ACTION_DOWN，一次是ACTION_UP(你還可能會有多次ACTION_MOVE的執行，如果你手抖了一下)。因此事件傳遞的順序是先經過onTouch，再傳遞到onClick。

細心的朋友應該可以注意到，onTouch方法是有返回值的，這裏我們返回的是false，如果我們嘗試把onTouch方法裏的返回值改成true，再運行一次，結果如下：

我們發現，onClick方法不再執行了！爲什麼會這樣呢？你可以先理解成onTouch方法返回true就認爲這個事件被onTouch消費掉了，因而不會再繼續向下傳遞。

如果到現在爲止，以上的所有知識點你都是清楚的，那麼說明你對Android事件傳遞的基本用法應該是掌握了。不過別滿足於現狀，讓我們從源碼的角度分析一下，出現上述現象的原理是什麼。

首先你需要知道一點，只要你觸摸到了任何一個控件，就一定會調用該控件的dispatchTouchEvent方法。那當我們去點擊按鈕的時候，就會去調用Button類裏的dispatchTouchEvent方法，可是你會發現Button類裏並沒有這個方法，那麼就到它的父類TextView裏去找一找，你會發現TextView裏也沒有這個方法，那沒辦法了，只好繼續在TextView的父類View裏找一找，這個時候你終於在View裏找到了這個方法，示意圖如下：

            

然後我們來看一下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;
}

Bingo！找到了，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;
        }
    }
    if (((viewFlags & CLICKABLE) == CLICKABLE ||
            (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {
        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();
                            }
                            if (!post(mPerformClick)) {
                                performClick();
                            }
                        }
                    }
                    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;
        }
        return true;
    }
    return false;
}

相較於剛纔的dispatchTouchEvent方法，onTouchEvent方法複雜了很多，不過沒關係，我們只挑重點看就可以了。

首先在第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可以得到執行。

那我們可以換一個控件，將按鈕替換成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和按鈕不同，它是默認不可點擊的，因此在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滑動框架完全解析，教你如何一分鐘實現滑動菜單特效 這篇文章，你應該會知道滑動菜單的功能是通過給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也是可以得到執行的。

---------------------------------------------------------------------------------------------------------------

2、ViewGroup事件分發

首先我們來探討一下，什麼是ViewGroup？它和普通的View有什麼區別？

顧名思義，ViewGroup就是一組View的集合，它包含很多的子View和子VewGroup，是Android中所有佈局的父類或間接父類，像LinearLayout、RelativeLayout等都是繼承自ViewGroup的。但ViewGroup實際上也是一個View，只不過比起View，它多了可以包含子View和定義佈局參數的功能。ViewGroup繼承結構示意圖如下所示：

可以看到，我們平時項目裏經常用到的各種佈局，全都屬於ViewGroup的子類。

簡單介紹完了ViewGroup，我們現在通過一個Demo來演示一下Android中VewGroup的事件分發流程吧。

首先我們來自定義一個佈局，命名爲MyLayout，繼承自LinearLayout，如下所示：

public class MyLayout extends LinearLayout {

    public MyLayout(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

}

然後，打開主佈局文件activity_main.xml，在其中加入我們自定義的佈局：

<com.example.viewgrouptouchevent.MyLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/my_layout"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <Button
        android:id="@+id/button1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Button1" />

    <Button
        android:id="@+id/button2"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Button2" />

</com.example.viewgrouptouchevent.MyLayout>

可以看到，我們在MyLayout中添加了兩個按鈕，接着在MainActivity中爲這兩個按鈕和MyLayout都註冊了監聽事件：

myLayout.setOnTouchListener(new OnTouchListener() {
    @Override
    public boolean onTouch(View v, MotionEvent event) {
        Log.d("TAG", "myLayout on touch");
        return false;
    }
});
button1.setOnClickListener(new OnClickListener() {
    @Override
    public void onClick(View v) {
        Log.d("TAG", "You clicked button1");
    }
});
button2.setOnClickListener(new OnClickListener() {
    @Override
    public void onClick(View v) {
        Log.d("TAG", "You clicked button2");
    }
});

我們在MyLayout的onTouch方法，和Button1、Button2的onClick方法中都打印了一句話。現在運行一下項目，效果圖如下所示：

                                      

分別點擊一下Button1、Button2和空白區域，打印結果如下所示：

你會發現，當點擊按鈕的時候，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, AttributeSet attrs) {
        super(context, attrs);
    }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        return true;
    }

}

現在再次運行項目，然後分別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方法的源碼吧！代碼如下所示：

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;
        }
        if (disallowIntercept || !onInterceptTouchEvent(ev)) {
            ev.setAction(MotionEvent.ACTION_DOWN);
            final int scrolledXInt = (int) scrolledXFloat;
            final int scrolledYInt = (int) scrolledYFloat;
            final View[] children = mChildren;
            final int count = mChildrenCount;
            for (int i = count - 1; i >= 0; i--) {
                final View child = children[i];
                if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE
                        || child.getAnimation() != null) {
                    child.getHitRect(frame);
                    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;
                        if (child.dispatchTouchEvent(ev))  {
                            mMotionTarget = child;
                            return true;
                        }
                    }
                }
            }
        }
    }
    boolean isUpOrCancel = (action == MotionEvent.ACTION_UP) ||
            (action == MotionEvent.ACTION_CANCEL);
    if (isUpOrCancel) {
        mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
    }
    final View target = mMotionTarget;
    if (target == null) {
        ev.setLocation(xf, yf);
        if ((mPrivateFlags & CANCEL_NEXT_UP_EVENT) != 0) {
            ev.setAction(MotionEvent.ACTION_CANCEL);
            mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;
        }
        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方法對這個值進行修改。那麼當第一個值爲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中將無法接收到任何事件。

-----------------------------------------------------------------------------------------------------------------------------------------------------------------

另：MotionEvent

(1)首先是MotionEvent 中getAction()與getActionMasked()的區別:

 首先看代碼:

01

/**

02	* Bit mask of the parts of the action code that are the action itself.

03

*/

04	public static final int ACTION_MASK             = 0xff;

05

06

/**

07	* Return the kind of action being performed.

08	* Consider using {<a href="http://my.oschina.net/link1212" class="referer" target="_blank">@link</a>  #getActionMasked} and {<a href="http://my.oschina.net/link1212" class="referer" target="_blank">@link</a>  #getActionIndex} to retrieve

09	* the separate masked action and pointer index.

10	* @return The action, such as {<a href="http://my.oschina.net/link1212" class="referer" target="_blank">@link</a>  #ACTION_DOWN} or

11	* the combination of {<a href="http://my.oschina.net/link1212" class="referer" target="_blank">@link</a>  #ACTION_POINTER_DOWN} with a shifted pointer index.

12

*/

13	public final int getAction() {

14	return mAction;

15

}

16

17

/**

18	* Return the masked action being performed, without pointer index information.

19	* Use {<a href="http://my.oschina.net/link1212" class="referer" target="_blank">@link</a>  #getActionIndex} to return the index associated with pointer actions.

20	* @return The action, such as {<a href="http://my.oschina.net/link1212" class="referer" target="_blank">@link</a>  #ACTION_DOWN} or {<a href="http://my.oschina.net/link1212" class="referer" target="_blank">@link</a>  #ACTION_POINTER_DOWN}.

21

*/

22	public final int getActionMasked() {

23	return mAction & ACTION_MASK;

24

}

上面的代碼是基於android2.2的,註釋是android4.X中最新的.

初看一下從技術角度來說通過getActionMasked()和通過getAction()返回的結果應該是一樣的,

因爲ACTION_MASK 的值 是0xff, 

如果您對二進制位運算不太熟悉的話,請用下面的方法測試吧.看是不是這樣的.

1	private static void maskTest() {

2	for (int i = 0; i < 5; i++) {

3	System.out.println("" + i);

4	System.out.println("masked " + (i & 0xff));

5

}

6

}

那他們區別是什麼呢?先看關於這兩個方法註釋:

我簡單的翻譯如下:

 

01

/**

02	* action碼的位掩碼部分就是action本身

03

*/

04	public static final int ACTION_MASK             = 0xff;

05

06

/**

07	返回action的類型,考慮使用getActionMasked()和getActionIndex()來獲得單獨的經過掩碼的action和觸控點的索引.

08	@return action例如ACTION_DOWN或者ACTION_POINTER_DOWN與轉換的觸控點索引的合成值

09

*/

10	public final int getAction() {

11	return mAction;

12

}

13

14

/**

15	返回經過掩碼的action,沒有觸控點索引信息.

16	通過getActionIndex()來得到觸控操作點的索引.

17	@return action,例如ACTION_DOWN,ACTION_POINTER_DOWN

18

19

20

*/

21	public final int getActionMasked() {

22	return mAction & ACTION_MASK;

23

}

 

在上面的兩個方法中註釋出現差異的地方是對於ACTION_POINTER_DOWN的描述:

通過getAction()返回的ACTION_POINTER_DOWN的是與轉換觸控點索引的合成值.

而getActionMasked()則就是一個ACTION_POINTER_DOWN的值:

 

這麼來看我們知道一個action的代碼值還包含了action是那個觸控點的索引值:

現在我們對比來看看ACTION_MASK和ACTION_POINTER_INDEX_MASK

1	public static final int ACTION_MASK             = 0xff;

2	public static final int ACTION_POINTER_INDEX_MASK  = 0xff00;

還沒有看出來什麼嗎?

您把ACTION_MASK看成是0x00ff

就知道了吧.

也就是說,一個MotionEvent中的action代碼,

前8位是實實在在包含表示哪一個動作常量.

後八位呢就是包含了觸控點的索引信息.

因爲ACTION_MASK = 0x00ff所以,經過ACTION_MASK掩碼過後的action碼就沒有索引信息了.

如何得索引值呢?

原理:

先將action跟0xff00相與清除前8位用於存儲動作常量的信息,

然後將action右移8位就可以得到索引值了.

我們就可以自己想辦法得到索引信息了.

即先對action用ACTION_POINTER_INDEX_MASK進行掩碼處理,

即  maskedIndex = action&ACTION_POINTER_INDEX_MASK = action&0xff00

這各掩碼也就是將action這個數的前8位清零.

然後再將maskedIndex向右移8位就能夠得到索引值了.

再看看android真實是怎麼做的吧,

用於右移8位的常量.

1

/**

2	* Bit shift for the action bits holding the pointer index as

3	* defined by {<a href="http://my.oschina.net/link1212" class="referer" target="_blank">@link</a>  #ACTION_POINTER_INDEX_MASK}.

4

*/

5	public static final int ACTION_POINTER_INDEX_SHIFT = 8;

再年得到索引值方法源代碼,如下:

1	public final int getActionIndex() {

2	return (mAction & ACTION_POINTER_INDEX_MASK) >> ACTION_POINTER_INDEX_SHIFT;

3

}

 

爲什麼要有索引信息?

 因爲,這樣說吧,android中,當有觸摸事件發生時(假設已經註冊了事件監聽器),調用你註冊監聽器中的方法onTouch(,MotionEvent ev);傳遞了一個MotionEvent的對象過來.

但是,想想,上面只傳遞進來一個MotionEvent過來,如果只是單點觸控那是沒有問題.

問題就是當你多個手指觸控的時候也是隻傳遞這一個MotionEvent進來,

這個時候,你當然想知道每個手指的所對應的觸控點數據信息啦.

所以MotionEvent中有就要索引信息了.

事件是你可以很容易通過API看到,MotionEvent還包含了移動操作中其它歷史移動數據.

方便處理觸控的移動操作.

android sdk對於這個類的描述中就有這麼一句:

For efficiency, motion events with ACTION_MOVE may batch together multiple movement samples within a single object.

  我翻譯下:"出於效率的考慮,事件代碼爲ACTION_MOVE的Motion,會在一個MotionEvent對象中包含多個移動數據採樣."

 

現在我們對於MotionEvent有了初步的瞭解了.

PS:

我發現android4中MotionEvent中的代碼大多變成了原生代碼了:

例如如getX(int)在2.2中是這樣的:

1	public final float getX(int pointerIndex) {

2	return mDataSamples[(pointerIndex*NUM_SAMPLE_DATA) + SAMPLE_X];

3

}

但到了4.x是這樣的了:

view source

print?

1	public final float getX(int pointerIndex) {

2	return nativeGetAxisValue(mNativePtr, AXIS_X, pointerIndex, HISTORY_CURRENT);

3

}

一隻手指down後在down一隻

 public static final int ACTION_MASK             = 0xff;

public static final int ACTION_MOVE             = 2;

public static final int ACTION_POINTER_UP       = 6;

public static final int ACTION_POINTER_DOWN     = 5;