Android事件分發

Android事件分發

Android 中與 Touch 事件相關的方法包括：dispatchTouchEvent(MotionEvent ev)、onInterceptTouchEvent(MotionEvent ev)、onTouchEvent(MotionEvent ev)

從這張表中我們可以看到 ViewGroup 及其子類對與 Touch 事件相關的三個方法均能響應，而 Activity 對 onInterceptTouchEvent(MotionEvent ev) 也就是事件攔截不進行響應。另外需要注意的是 View 對 dispatchTouchEvent(MotionEvent ev) 和 onInterceptTouchEvent(MotionEvent ev) 的響應的前提是可以向該 View 中添加子 View，如果當前的 View 已經是一個最小的單元 View（比如 TextView），那麼就無法向這個最小 View 中添加子 View，也就無法向子 View 進行事件的分發和攔截，所以它沒有 dispatchTouchEvent(MotionEvent ev) 和 onInterceptTouchEvent(MotionEvent ev)，只有 onTouchEvent(MotionEvent ev)。

Touch 事件分析
事件分發：public boolean dispatchTouchEvent(MotionEvent ev)
Touch 事件發生時 Activity 的 dispatchTouchEvent(MotionEvent ev) 方法會以隧道方式（從根元素依次往下傳遞直到最內層子元素或在中間某一元素中由於某一條件停止傳遞）將事件傳遞給最外層 View 的 dispatchTouchEvent(MotionEvent ev) 方法，並由該 View 的 dispatchTouchEvent(MotionEvent ev) 方法對事件進行分發。dispatchTouchEvent 的事件分發邏輯如下：

如果 return true，事件會分發給當前 View 並由 dispatchTouchEvent 方法進行消費，同時事件會停止向下傳遞；
如果 return false，事件分發分為兩種情況：
如果當前 View 獲取的事件直接來自 Activity，則會將事件返回給 Activity 的 onTouchEvent 進行消費；
如果當前 View 獲取的事件來自外層父控件，則會將事件返回給父 View 的 onTouchEvent 進行消費。
如果返回系統默認的 super.dispatchTouchEvent(ev)，事件會自動的分發給當前 View 的 onInterceptTouchEvent 方法。

事件攔截：public boolean onInterceptTouchEvent(MotionEvent ev)
在外層 View 的 dispatchTouchEvent(MotionEvent ev) 方法返回系統默認的 super.dispatchTouchEvent(ev) 情況下，事件會自動的分發給當前 View 的 onInterceptTouchEvent 方法。onInterceptTouchEvent 的事件攔截邏輯如下：

如果 onInterceptTouchEvent 返回 true，則表示將事件進行攔截，並將攔截到的事件交由當前 View 的 onTouchEvent 進行處理；
如果 onInterceptTouchEvent 返回 false，則表示將事件放行，當前 View 上的事件會被傳遞到子 View 上，再由子 View 的 dispatchTouchEvent 來開始這個事件的分發；
如果 onInterceptTouchEvent 返回 super.onInterceptTouchEvent(ev)，事件默認會被攔截，並將攔截到的事件交由當前 View 的 onTouchEvent 進行處理。

事件響應：public boolean onTouchEvent(MotionEvent ev)
在 dispatchTouchEvent 返回 super.dispatchTouchEvent(ev) 並且 onInterceptTouchEvent 返回 true 或返回 super.onInterceptTouchEvent(ev) 的情況下 onTouchEvent 會被調用。onTouchEvent 的事件響應邏輯如下：

如果事件傳遞到當前 View 的 onTouchEvent 方法，而該方法返回了 false，那麼這個事件會從當前 View 向上傳遞，並且都是由上層 View 的 onTouchEvent 來接收，如果傳遞到上面的 onTouchEvent 也返回 false，這個事件就會“消失”，而且接收不到下一次事件。
如果返回了 true 則會接收並消費該事件。
如果返回 super.onTouchEvent(ev) 默認處理事件的邏輯和返回 false 時相同。

接下來從源碼的角度來分析事件分發：
比如說你當前有一個非常簡單的項目，只有一個Activity，並且Activity中只有一個按鈕。你可能已經知道，如果想要給這個按鈕注冊一個點擊事件和一個Touch事件：

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

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執行了兩次，一次是ACTION_DOWN，一次是ACTION_UP(你還可能會有多次ACTION_MOVE的執行，如果你手抖了一下)。因此事件傳遞的順序是先經過onTouch，再傳遞到onClick。
細心的朋友應該可以注意到，onTouch方法是有返回值的，這裡我們返回的是false，如果我們嘗試把onTouch方法裡的返回值改成true，再運行一次，結果如下：

我們發現，onClick方法不再執行了！為什麼會這樣呢？你可以先理解成onTouch方法返回true就認為這個事件被onTouch消費掉了，因而不會再繼續向下傳遞。
首先你需要知道一點，只要你觸摸到了任何一個控件，就一定會調用該控件的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;  
} 

第二個條件(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方法。
一切都是那麼清楚了！當我們通過調用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，你會發現結果如下：

在ACTION_DOWN執行完後，後面的一系列action都不會得到執行了。這又是為什麼呢？因為ImageView和按鈕不同，它是默認不可點擊的，因此在onTouchEvent的第14行判斷時無法進入到if的內部，直接跳到第91行返回了false，也就導致後面其它的action都無法執行了。
好了，關於View的事件分發，我想講的東西全都在這裡了。現在我們再來回顧一下開篇時提到的那三個問題，相信每個人都會有更深一層的理解。

我們現在通過一個Demo來演示一下Android中VewGroup的事件分發流程吧。
首先我們來自定義一個布局，命名為MyLayout，繼承自LinearLayout，如下所示：<喎?http://www.Bkjia.com/kf/ware/vc/" target="_blank" class="keylink">vcD4KCgoKPHByZSBjbGFzcz0="brush:java;">public class MyLayout extends LinearLayout { public MyLayout(Context context, AttributeSet attrs) { super(context, attrs); } }

我們在MyLayout中添加了兩個按鈕，接著在MainActivity中為這兩個按鈕和MyLayout都注冊了監聽事件：

myLayout.setOnTouchListener(new View.OnTouchListener() {
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                Log.i("========","myLayout onTouch");
                return false;
            }
        });

        bt1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.i("========", "Button1 onClick");
            }
        });
        bt2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.i("========","Button2 onClick");
            }
        });

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

你會發現，當點擊按鈕的時候，MyLayout注冊的onTouch方法並不會執行，只有點擊空白區域的時候才會執行該方法。你可以先理解成Button的onClick方法將事件消費掉了，因此事件不會再繼續向下傳遞。

查閱文檔可以看到，ViewGroup中有一個onInterceptTouchEvent方法，我們來看一下這個方法的源碼：

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的。只要你觸摸了任何控件，就一定會調用該控件的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;  
        }  
        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，我們也因此證實了，按鈕點擊事件的處理確實就是在這裡進行的。
然後需要注意一下，調用子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的事件分發流程的分析也就到此結束了，我們最後再來簡單梳理一下吧。
1. Android事件分發是先傳遞到ViewGroup，再由ViewGroup傳遞到View的。
2. 在ViewGroup中可以通過onInterceptTouchEvent方法對事件傳遞進行攔截，onInterceptTouchEvent方法返回true代表不允許事件繼續向子View傳遞，返回false代表不對事件進行攔截，默認返回false。
3. 子View中如果將傳遞的事件消費掉，ViewGroup中將無法接收到任何事件。