在前面的第二篇文章中，我們提過，View的事件分發是一種委託思想：上層委託下層，父容器委託子元素來處理這個流程。接下來，我們就將深入去學習View的事件分發機制。
1.事件的傳遞流程
    事件，在Android中對應的類是MotionEvent，因此，我們要分析的就是MotionEvent這個類。對點選事件的分發，其實就是對MotionEvent的物件進行處分發。所以，當一個MotionEvent產生以後（從驅動讀取），系統需要把這個事件傳遞給一個具體的View，這個傳遞的過程就是分發過程，點選事件由三個很重要的方法完成：

• public boolean dispatchTouchEvent( MotionEvent event)

            用於進行事件的分發，如果事件能夠傳遞給當前的View，那麼此方法一定會被呼叫。返回結構受當前View的onTouchEvent和下級View的dispatchTouchEvent方法的影響，表示是否消耗當前事件。

• public boolean onIntercptTouchEvent( MotionEvent event )

            在上述方法內部呼叫，用來判斷是否攔截某個事件，如果當前View攔截了某個事件，那麼在同一個事件序列中，此方法不會被再次呼叫，返回結果是表示是否攔截當前事件。本方法不在View內部，在ViewGroup中的dispatchEvent被呼叫。

• public boolean onTouchEvent( MotionEvent event )

            在dispatchTouchEvent方法中呼叫，用來處理點選事件，返回結果表示是否消耗當前事件，如果不消耗，則在同一個事件序列中，當前View無法再次接收到事件，事件全部往下傳遞給子View去了。         例如自定義了一個MyTestView，重寫了onTouchEvent方法如下：         @Override

       public boolean onTouchEvent(MotionEvent event) {
        switch (event.getAction()) {         case MotionEvent.ACTION_DOWN:             Log.d( "MyTestView",  "================ Action down ==============");             return true;          case MotionEvent.ACTION_MOVE:             Log.d( "MyTestView",  "================ Action move ==============");             return true;
         case MotionEvent.ACTION_UP:             Log.d( "MyTestView",  "================ Action up ==============");             return true;
         default:             break;         }
    觸控，打印出來截圖為：     
    然後，修改方法為如下：     @Override     public boolean onTouchEvent(MotionEvent event) {
        switch (event.getAction()) {         case MotionEvent.ACTION_DOWN:             Log.d( "MyTestView",  "================ Action down ==============");             return false;          case MotionEvent.ACTION_MOVE:             Log.d( "MyTestView",  "================ Action move ==============");             return true;
         case MotionEvent.ACTION_UP:             Log.d( "MyTestView",  "================ Action up ==============");             return true;
         default:             break;         }     列印的結果為：

    可以看到，我們在down事件reture false了，那麼之後的up事件和move事件都不執行本方法了。      對於一個根ViewGroup來說，點選事件產生了以後，首先會傳遞給它，此時，它的dispatchTouchEvent會被呼叫，在dispatcTouchEvent中，onintereptTouchEvent會被呼叫，如果onInterceptTouchEvent返回了true,表示在這邊攔截事件，這時候，就會呼叫ViewGroup的onTouchEvent ，否則的話，就根據事件發生的位置，選擇一組子元素（需要可見），處理事件，直到遍歷了全部的子元素，然後子元素再呼叫dispatchTouchEvent。
    當一個View需要處理事件的時候，如果它設定了OnTouchListener ，那麼OnTouchListener中onTouch方法會被回撥，這時候，如果onTouchListner的onTouch返回了true,那麼就代表，已經消費了這個事件，則事件不會傳遞到onTouchEvent，如果返回為false.則會繼續呼叫onTouchEvent，所以onTouchListener的優先順序最高，並且，onTouchEvent中會呼叫onClickListener，所以OnClickListener的優先順序是最低的。     當onTouchEvent或者是onToucListsner#onTouch方法返回為true的時候，dispatchOnTouchEvent就不會再繼續被呼叫了。     下面是點選事件產生過程相關元素的關係圖(底層實現:http://www.cnblogs.com/samchen2009/p/3368158.html):

         當事件產生了以後，會按照下面的流程傳遞：          頂級View接收到事件後，就會按照事件分發機制去分發事件，這邊的頂級View的物件是一個ViewGroup。之後會詳細討論這個頂級View.     一個事件序列，只能被一個ViewGroup攔截且消耗。      2.dispatchTouchEvent方法詳解
    在詳細解釋這個方法之前，我們要先了解幾個東西：     1.位運算。在這個方法裡面，大量使用了位運算，這樣對於一些很少使用位運算的人來說，這個程式碼是有點晦澀難懂的，下面我們先簡單地說下位運算的好處。         首先是與（&）運算     比如，我們有一個對一個16bit的int的數值進行劃分，其中最後個bit，表示的當前View的可見性，不為0則是可見，第8個bit，不為0代表可以獲取焦點，比如現在有個值為：0x0101 意思就是可見，並且可以獲取焦點     那麼我們要判斷view是不是可見，那麼我們就可以直接進行下面的操作      0x0101 & 0xff  ,結果是0x01 那麼，我們就可以拿這個值直接去判斷了，     使用位運算，我們可以讓每個bit都有一可以表示一個Boolean值，也可以把一個數值的值，分成幾個部分，將不同狀態集合在一個變數當中。     或運算可以讓我們把狀態賦予進去，比如我們現在為view可見0x0001希望這個變數承載一個可以獲取焦點的flag(值為0x0100)，那麼我們就只需要進行下面的操作：     0x0001 | 0x0100 得到的值為0x0101 這樣，我們就放入了一個數據進去了。     非運算和與運算一起用可以讓我們清空儲存的變數，比如如下：     我們現在改變了View的可見性了，設定為不可見，我們就要做下面的操作     if( (flag & 0x01)!=0)//不為0那麼就是說可見啊。     {         flag &=~0x01 ；//等價於flg&0xfe ，讓最後一位為0     }     通過上面的程式碼，我們就把最後一位設定為0.這樣子，我們就把view設為了不可見了。     2.pointer 表示的應該就是點，經常表示的就是我們手指的觸控點 2個手指觸控，就有2個pointer     3.TouchTarget         TouchTarget是表示pointer（觸控點）和子View的關係
下面是dispatchTouchEvent的程式碼註釋

public boolean dispatchTouchEvent(MotionEvent ev) {
        //驗證事件是否連續
        if (mInputEventConsistencyVerifier != null) {
            mInputEventConsistencyVerifier.onTouchEvent(ev, 1);
        }
        //這個變數用於記錄事件是否被處理完
        boolean handled = false;
        //過濾掉一些不合法的事件：當前的View的視窗被遮擋了。
        if (onFilterTouchEventForSecurity(ev)) {
            //如果事件發生的View在的視窗，沒有被遮擋
            final int action = ev.getAction();
            //重置前面為0 ，只留下後八位，用於判斷相等時候，可以提高效能。
            final int actionMasked = action & MotionEvent.ACTION_MASK;
            //判斷是不是Down事件，如果是的話，就要做初始化操作
            if (actionMasked == MotionEvent.ACTION_DOWN) {
                //如果是down事件，就要清空掉之前的狀態，比如,重置手勢判斷什麼的。
                //比如，之前正在判斷是不是一個單點的滑動，但是第二個down來了，就表示，不可能是單點的滑動，要重新開始判斷觸控的手勢
                //清空掉mFirstTouchTarget
                // Throw away all previous state when starting a new touch gesture.
                // The framework may have dropped the up or cancel event for the previous gesture
                // due to an app switch, ANR, or some other state change.
                cancelAndClearTouchTargets(ev);
                resetTouchState();
            }

 
            //檢查是否攔截事件
            final boolean intercepted;
            //如果當前是Down事件，或者已經有處理Touch事件的目標了
            if (actionMasked == MotionEvent.ACTION_DOWN
                    || mFirstTouchTarget != null) {
                //判斷允不允許這個View攔截
                //使用與運算作為判斷，可以讓我們在flag中，儲存好幾個標誌
                final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
                //如果說允許攔截事件
                if (!disallowIntercept) {
                    //確定是不是攔截了
                    intercepted = onInterceptTouchEvent(ev);
                    //重新恢復Action，以免action在上面的步驟被人為地改變了
                    ev.setAction(action); // restore action in case it was changed
                } else {
                    intercepted = false;
                }
            } else {
                // There are no touch targets and this action is not an initial down
                // so this view group continues to intercept touches.
                //如果說，事件已經初始化過了，並且沒有子View被分配處理，那麼就說明，這個ViewGroup已經攔截了這個事件
                intercepted = true;
            }

            // Check for cancelation.
            //如果viewFlag被設定了PFLAG_CANCEL_NEXT_UP_EVENT ,那麼就表示，下一步應該是Cancel事件
            //或者如果當前的Action為取消，那麼當前事件應該就是取消了。
            final boolean canceled = resetCancelNextUpFlag(this)
                    || actionMasked == MotionEvent.ACTION_CANCEL;

            // Update list of touch targets for pointer down, if needed.
            //如果需要（不是取消，也沒有被攔截）的話，那麼在觸控down事件的時候更新觸控目標列表
            //split代表，當前的ViewGroup是不是支援分割MotionEvent到不同的View當中
            final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0;
            //新的觸控物件，
            TouchTarget newTouchTarget = null;
            //是否把事件分配給了新的觸控
            boolean alreadyDispatchedToNewTouchTarget = false;
            //事件不是取消事件，也沒有攔截那麼就要判斷
            if (!canceled && !intercepted) {
                //如果是個全新的Down事件
                //或者是有新的觸控點
                //或者是游標來回移動事件（不太明白什麼時候發生）
                if (actionMasked == MotionEvent.ACTION_DOWN
                        || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
                        || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
                    //這個事件的索引，也就是第幾個事件，如果是down事件就是0
                    final int actionIndex = ev.getActionIndex(); // always 0 for down
                    //獲取分配的ID的bit數量
                    final int idBitsToAssign = split ? 1 << ev.getPointerId(actionIndex)
                            : TouchTarget.ALL_POINTER_IDS;

                    // Clean up earlier touch targets for this pointer id in case they
                    // have become out of sync.
                    //清理之前觸控這個指標標識,以防他們的目標變得不同步。
                    removePointersFromTouchTargets(idBitsToAssign);

                    final int childrenCount = mChildrenCount;
                    //如果新的觸控物件為null（這個不是鐵定的嗎）並且當前ViewGroup有子元素
                    if (newTouchTarget == null && childrenCount != 0) {
                        final float x = ev.getX(actionIndex);
                        final float y = ev.getY(actionIndex);
                        // Find a child that can receive the event.
                        // Scan children from front to back.
                        //下面所做的工作，就是找到可以接收這個事件的子元素
                        final View[] children = mChildren;
                        //是否使用自定義的順序來新增控制元件
                        final boolean customOrder = isChildrenDrawingOrderEnabled();
                        for (int i = childrenCount - 1; i >= 0; i--) {
                            //如果是用了自定義的順序來新增控制元件，那麼繪製的View的順序和mChildren的順序是不一樣的
                            //所以要根據getChildDrawingOrder取出真正的繪製的View
                            //自定義的繪製，可能第一個會畫到第三個，和第四個，第二個畫到第一個，這樣裡面的內容和Children是不一樣的
                            final int childIndex = customOrder ?
                                    getChildDrawingOrder(childrenCount, i) : i;
                            final View child = children[childIndex];
                            //如果child不可以接收這個觸控的事件，或者觸控事件發生的位置不在這個View的範圍內
                            if (!canViewReceivePointerEvents(child)
                                    || !isTransformedTouchPointInView(x, y, child, null)) {
                                continue;
                            }
                            //獲取新的觸控物件，如果當前的子View在之前的觸控目標的列表當中就返回touchTarget
                            //子View不在之前的觸控目標列表那麼就返回null
                            newTouchTarget = getTouchTarget(child);
                            if (newTouchTarget != null) {
                                // Child is already receiving touch within its bounds.
                                // Give it the new pointer in addition to the ones it is handling.
                                //如果新的觸控目標物件不為空，那麼就把這個觸控的ID賦予它，這樣子，
                                //這個觸控的目標物件的id就含有了好幾個pointer的ID了

                                newTouchTarget.pointerIdBits |= idBitsToAssign;
                                break;
                            }
                            //如果子View不在之前的觸控目標列表中，先重置childView的標誌，去除掉CACEL的標誌
                            resetCancelNextUpFlag(child);
                            //呼叫子View的dispatchTouchEvent,並且把pointer的id 賦予進去
                            //如果說，子View接收並且處理了這個事件，那麼就更新上一次觸控事件的資訊，
                            //並且為建立一個新的觸控目標物件，並且繫結這個子View和Pointer的ID
                            if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
                                // Child wants to receive touch within its bounds.
                                mLastTouchDownTime = ev.getDownTime();
                                mLastTouchDownIndex = childIndex;
                                mLastTouchDownX = ev.getX();
                                mLastTouchDownY = ev.getY();
                                newTouchTarget = addTouchTarget(child, idBitsToAssign);
                                alreadyDispatchedToNewTouchTarget = true;
                                break;
                            }
                        }
                    }
                    //如果newTouchTarget為null，就代表，這個事件沒有找到子View去處理它，
                    //那麼，如果之前已經有了觸控物件（比如，我點了一張圖，另一個手指在外面圖的外面點下去）
                    //那麼就把這個之前那個觸控目標定為第一個觸控物件，並且把這個觸控（pointer）分配給最近新增的觸控目標
                    if (newTouchTarget == null && mFirstTouchTarget != null) {
                        // Did not find a child to receive the event.
                        // Assign the pointer to the least recently added target.
                        newTouchTarget = mFirstTouchTarget;
                        while (newTouchTarget.next != null) {
                            newTouchTarget = newTouchTarget.next;
                        }
                        newTouchTarget.pointerIdBits |= idBitsToAssign;
                    }
                }
            }

            // Dispatch to touch targets.
            //如果沒有觸控目標
            if (mFirstTouchTarget == null) {
                // No touch targets so treat this as an ordinary view.
                //那麼就表示我們要自己在這個ViewGroup處理這個觸控事件了
                handled = dispatchTransformedTouchEvent(ev, canceled, null,
                        TouchTarget.ALL_POINTER_IDS);
            } else {
                // Dispatch to touch targets, excluding the new touch target if we already
                // dispatched to it.  Cancel touch targets if necessary.
                TouchTarget predecessor = null;
                TouchTarget target = mFirstTouchTarget;
                //遍歷TouchTargt樹.分發事件，如果我們已經分發給了新的TouchTarget那麼我們就不再分發給newTouchTarget
                while (target != null) {
                    final TouchTarget next = target.next;
                    if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
                        handled = true;
                    } else {
                        //是否讓child取消處理事件，如果為true，就會分發給child一個ACTION_CANCEL事件
                        final boolean cancelChild = resetCancelNextUpFlag(target.child)
                                || intercepted;
                        //派發事件
                        if (dispatchTransformedTouchEvent(ev, cancelChild,
                                target.child, target.pointerIdBits)) {
                            handled = true;
                        }
                        //cancelChild也就是說，派發給了當前child一個ACTION_CANCEL事件，
                        //那麼就移除這個child
                        if (cancelChild) {
                            //沒有父節點，也就是當前是第一個TouchTarget
                            //那麼就把頭去掉
                            if (predecessor == null) {
                                mFirstTouchTarget = next;
                            } else {
                                //把下一個賦予父節點的上一個，這樣當前節點就被丟棄了
                                predecessor.next = next;
                            }
                            //回收記憶體
                            target.recycle();
                            //把下一個賦予現在
                            target = next;
                            //下面的兩行不執行了，因為我們已經做了連結串列的操作了。
                            //主要是我們不能執行predecessor=target，因為刪除本節點的話，父節點還是父節點
                            continue;
                        }
                    }
                    //如果沒有刪除本節點，那麼下一輪父節點就是當前節點，下一個節點也是下一輪的當前節點
                    predecessor = target;
                    target = next;
                }
            }

            // Update list of touch targets for pointer up or cancel, if needed.
            //遇到了取消事件、或者是單點觸控下情況下手指離開，我們就要更新觸控的狀態
            if (canceled
                    || actionMasked == MotionEvent.ACTION_UP
                    || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
                resetTouchState();
            } else if (split && actionMasked == MotionEvent.ACTION_POINTER_UP) {
                //如果是多點觸控下的手指擡起事件，就要根據idBit從TouchTarget中移除掉對應的Pointer(觸控點)
                final int actionIndex = ev.getActionIndex();
                final int idBitsToRemove = 1 << ev.getPointerId(actionIndex);
                removePointersFromTouchTargets(idBitsToRemove);
            }
        }

        if (!handled && mInputEventConsistencyVerifier != null) {
            mInputEventConsistencyVerifier.onUnhandledEvent(ev, 1);
        }
        return handled;
    }