ViewGroup事件分發和處理原始碼分析

大胃粥發表於2019-08-25
View事件原始碼

上篇文章事件分發之View事件處理講述了事件分發處理中最基礎的一環，那麼本篇文章就繼續來分析ViewGroup的事件分發以及處理。

ViewGroup事件分發以及處理極其的複雜，體現在以下幾個方面

  1. ViewGroup不僅要分發事件，而且也可能截斷並處理事件。
  2. 對於ACTION_DOWN，ACTION_MOVE, ACTION_UP，甚至還有ACTION_CANCEL事件，有不同的處理情況。
  3. ViewGroup的程式碼中還雜合了對多手指的處理情況。

鑑於程式碼的複雜性，本篇文章會對不同的情況分段講解，並在講解完畢用一副圖來表示程式碼的處理過程。

由於篇幅的原因，本文並不打算把多點觸控的程式碼拿出來講解，因為多點觸控也是比較難以講解的一塊。如果後續有時間，而且如果感覺有必要，我會用另外一篇文章來講解ViewGroup對多手指事件的處理。

處理ACTION_DOWN事件

檢測是否截斷事件

當ViewGroup檢測到ACTION_DOWN事件後，它做的第一件事是檢測是否截斷ACTION_DOWN事件。

    public boolean dispatchTouchEvent(MotionEvent ev) {
        if (onFilterTouchEventForSecurity(ev)) {
            
            // 做一些重置動作，包括清除FLAG_DISALLOW_INTERCEPT
            if (actionMasked == MotionEvent.ACTION_DOWN) {
                cancelAndClearTouchTargets(ev);
                resetTouchState();
            }
            
            // 1. 檢測是否截斷事件
            final boolean intercepted;
            if (actionMasked == MotionEvent.ACTION_DOWN
                    || mFirstTouchTarget != null) {
                // 由於之前清除過FLAG_DISALLOW_INTERCEPT，因此這裡的值為false
                final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
                if (!disallowIntercept) {
                    // 判斷自己是否截斷
                    intercepted = onInterceptTouchEvent(ev);
                    ev.setAction(action); // restore action in case it was changed
                } else {

                }
            } else {
                
            }
        }
複製程式碼

對於ACTION_DOWN事件，ViewGroup只通過onInterceptTouchEvent()方法來判斷是否截斷。

我們首先來分析下ViewGroup.onInterceptTouchEvent()返回false的情況，也就是不截斷ACTION_DOWN的情況，之後再來分析截斷的情況。

不截斷ACTION_DOWN事件

尋找處理事件的子View

如果ViewGroup不截斷ACTION_DOWN事件，那麼intercepted值為false。這意思就是說ViewGroup不截斷處理這個事件了，那就得找個子View來處理事件

    public boolean dispatchTouchEvent(MotionEvent ev) {

        if (onFilterTouchEventForSecurity(ev)) {
            final int action = ev.getAction();
            final int actionMasked = action & MotionEvent.ACTION_MASK;

            // 1. 檢測是否截斷事件
            // ...
            
            TouchTarget newTouchTarget = null;
            boolean alreadyDispatchedToNewTouchTarget = false;
            // 不截斷
            if (!canceled && !intercepted) {
                if (actionMasked == MotionEvent.ACTION_DOWN
                        || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
                        || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
                    final int actionIndex = ev.getActionIndex(); // always 0 for down
                    final int idBitsToAssign = split ? 1 << ev.getPointerId(actionIndex)
                            : TouchTarget.ALL_POINTER_IDS;

                    final int childrenCount = mChildrenCount;
                    if (newTouchTarget == null && childrenCount != 0) {
                        final float x = ev.getX(actionIndex);
                        final float y = ev.getY(actionIndex);
                        
                        // 獲取有序的子View集合
                        final ArrayList<View> preorderedList = buildTouchDispatchChildList();
                        
                        final boolean customOrder = preorderedList == null
                                && isChildrenDrawingOrderEnabled();
                                
                        final View[] children = mChildren;
                        for (int i = childrenCount - 1; i >= 0; i--) {
                            // 2.通過迴圈來尋找一個能處理ACTION_DOWN事件的子View
                            // 2.1 獲取一個子View
                            final int childIndex = getAndVerifyPreorderedIndex(
                                    childrenCount, i, customOrder);
                            final View child = getAndVerifyPreorderedView(
                                    preorderedList, children, childIndex);

                            // 2.2 判斷子View是否能夠處理事件
                            if (!canViewReceivePointerEvents(child)
                                    || !isTransformedTouchPointInView(x, y, child, null)) {
                                ev.setTargetAccessibilityFocus(false);
                                // 如果不能處理，就進行下一輪迴圈繼續尋找子View
                                continue;
                            }

                            // 3. 把事件分發給子View
                            // ...
                        }
                    }
                }
            }
        }
        return handled;
    }
複製程式碼

首先2.1步，獲取一個子View。至於以怎麼樣一個方式獲取一個子View，我們這裡不需要深究，如果大家以後遇到繪製順序，以及子View接收事件的順序問題時，可以再回頭分析這裡獲取子View的順序。

獲取到一個子View後，2.2步，判斷這個子View是否滿足處理事件的標準，標準有兩個

  1. 通過canViewReceivePointerEvents()判斷子View是否能夠接收事件。它的原理非常簡單，只要View可見，或者View有動畫，那麼View就可以接收事件。
  2. 通過isTransformedTouchPointInView()判斷事件的座標是否在子View內。它的原理可以簡單描述下，首先要把事件座標轉換為View空間的座標，然後判斷轉換後的座標是否在View內。這個說起來簡單，但是如果要解釋，需要大家瞭解View滾動以及Matrix相關知識，因此我這裡不打算詳細解釋。

2.2步呢，如果找到的子View沒有這個能力處理事件，那麼就會直接進行下一輪迴圈，去找下一個能夠處理事件的子View。這一步基本上都是能找到子View的，因為如果我們想使用某個控制元件，手指肯定要在上面按下吧。

事件分發給子View

有了能處理事件的子View，現在就把ACTION_DOWN事件分發給它處理，並且通過結果看看它是否處理了ACTION_DOWN事件，我們來看下程式碼

    public boolean dispatchTouchEvent(MotionEvent ev) {

        if (onFilterTouchEventForSecurity(ev)) {
            final int action = ev.getAction();
            final int actionMasked = action & MotionEvent.ACTION_MASK;

            // 1. 檢測是否截斷事件
            // ...
            
            // 不取消，不截斷
            if (!canceled && !intercepted) {
                if (actionMasked == MotionEvent.ACTION_DOWN
                        || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
                        || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
                    
                    if (newTouchTarget == null && childrenCount != 0) {

                        // 遍歷尋找一個能處理事件的View
                        for (int i = childrenCount - 1; i >= 0; i--) {
                            // 2. 找一個能處理事件的子View
                            // ...

                            // 3. 把事件分發給子View
                            if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
                                // 3.1 子View處理了事件，獲取一個TouchTarget物件
                                newTouchTarget = addTouchTarget(child, idBitsToAssign);
                                alreadyDispatchedToNewTouchTarget = true;
                                break;
                            }
                        }
                    }
                }
            }

            if (mFirstTouchTarget == null) {

            } else {
                TouchTarget predecessor = null;
                TouchTarget target = mFirstTouchTarget;
                while (target != null) {
                    final TouchTarget next = target.next;
                    if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
                        // 3.2 找到了處理ACTION_DOWN事件的子View，設定結果
                        handled = true;
                    } else {

                    }
                }
            }            
        }
        // 3.3 返回結果
        return handled;
    }
複製程式碼

第3步，通過dispatchTransformedTouchEvent()方法把事件發給這個子View，並通過返回值確定子View的處理結果

    private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
            View child, int desiredPointerIdBits) {
        final boolean handled;

        final int oldPointerIdBits = event.getPointerIdBits();
        final int newPointerIdBits = oldPointerIdBits & desiredPointerIdBits;

        final MotionEvent transformedEvent;
        // 手指數沒有變
        if (newPointerIdBits == oldPointerIdBits) {
            // 1. child有單位矩陣情況
            if (child == null || child.hasIdentityMatrix()) {
                if (child == null) {

                } else {
                    // 先把事件座標轉換為child座標空間的座標
                    final float offsetX = mScrollX - child.mLeft;
                    final float offsetY = mScrollY - child.mTop;
                    event.offsetLocation(offsetX, offsetY);

                    // 把事件發給child處理
                    handled = child.dispatchTouchEvent(event);

                    event.offsetLocation(-offsetX, -offsetY);
                }
                // 返回處理結果
                return handled;
            }
            transformedEvent = MotionEvent.obtain(event);
        } else {
            transformedEvent = event.split(newPointerIdBits);
        }

        if (child == null) {

        } else {
            // 2. 處理child沒有單位矩陣的情況
            // 先把事件座標轉換為child座標空間的座標
            final float offsetX = mScrollX - child.mLeft;
            final float offsetY = mScrollY - child.mTop;
            transformedEvent.offsetLocation(offsetX, offsetY);
            // 再根據轉換矩陣，把轉換後的座標經過逆矩陣再次轉換
            if (! child.hasIdentityMatrix()) {
                transformedEvent.transform(child.getInverseMatrix());
            }
            // 最後交給child處理轉換座標後的事件
            handled = child.dispatchTouchEvent(transformedEvent);
        }
        // 返回處理結果
        return handled;
    }
複製程式碼

雖然根據子View是否有單位矩陣的情況，這裡的處理流程分為了兩步，但是這裡的處理方式大致都是相同的，都是首先把事件座標做轉換，然後交給子View的dispatchTouchEvent()處理。

從dispatchTransformedTouchEvent()實現可以看出，它的返回結果是由子View的dispatchTouchEvent()決定的。假如返回了true, 就代表子View處理了ACTION_DOWN，那麼就走到了3.1步，通過addTouchTarget()獲取一個TouchTarget物件

    private TouchTarget addTouchTarget(@NonNull View child, int pointerIdBits) {
        // 從物件池中獲取一個TouchTarget
        final TouchTarget target = TouchTarget.obtain(child, pointerIdBits);
        // 插入到鏈單表的頭部
        target.next = mFirstTouchTarget;
        // mFirstTouchTarget指向單連結串列的開頭
        mFirstTouchTarget = target;
        return target;
    }
複製程式碼

這裡是一個物件池配合連結串列的常規操作，這裡要注意一點就是，mFirstTarget指向單連結串列的頭部，mFirstTouchTarget.child就是指向了處理了ACTION_DOWN事件的子View。

走到這裡就代表找到並處理了ACTION_DOWN事件的子View，之後就走到3.2和3.3直接返回結果true。

我們用一幅圖來表示下ACTION_DOWN事件不被截斷的處理過程

不截斷ACTION_DOWN

ViewGroup自己處理ACTION_DOWN事件

其實ViewGroup是可以自己處理ACTION_DOWN事件的，有兩種情況會讓這成為可能

  1. ViewGroup自己截斷ACTION_DOWN事件
  2. ViewGroup找不到能處理ACTION_DOWN事件的子View

由於這兩種情況的程式碼處理方式是一樣的，所以我把這兩種情況放到一起講，程式碼如下

    public boolean dispatchTouchEvent(MotionEvent ev) {

        if (onFilterTouchEventForSecurity(ev)) {
            final int action = ev.getAction();
            final int actionMasked = action & MotionEvent.ACTION_MASK;

            // 檢測是否截斷事件
            final boolean intercepted;
            if (actionMasked == MotionEvent.ACTION_DOWN
                    || mFirstTouchTarget != null) {
                // ACTION_DOWN時，disallowIntercept值永遠為false
                final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
                if (!disallowIntercept) {
                    // 返回true，截斷事件
                    intercepted = onInterceptTouchEvent(ev);
                } else {
                    
                }
            } else {

            }
            
            // 1. 如果ViewGroup截斷事件，直接走第3步
            if (!canceled && !intercepted) {
                if (actionMasked == MotionEvent.ACTION_DOWN
                        || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
                        || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
                    
                    if (newTouchTarget == null && childrenCount != 0) {

                        // 2. 如果所有的子View都不處理ACTION_DOWN事件，直接走第3步
                        for (int i = childrenCount - 1; i >= 0; i--) {
                            // 找一個能處理事件的子View
                            // ...

                            // View處理事件
                            if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {

                            }
                        }
                    }
                }
            }

            if (mFirstTouchTarget == null) {
                // 3. ViewGroup自己處理ACTION_DOWN事件
                handled = dispatchTransformedTouchEvent(ev, canceled, null,
                        TouchTarget.ALL_POINTER_IDS);
            } else {

            }            
        }
        // 4. 返回處理結果
        return handled;
    }
複製程式碼

從程式碼中可以看到，如果ViewGroup截斷ACTION_DOWN事件或者找不到一個能處理ACTION_DOWN事件的子View，最終都會走到第3步，通過dispatchTransformedTouchEvent()方法把ACTION_DOWN事件交給自己處理，注意傳入的第三個引數為null，表示沒有處理事件的子View

    private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
            View child, int desiredPointerIdBits) {

        final int oldPointerIdBits = event.getPointerIdBits();
        final int newPointerIdBits = oldPointerIdBits & desiredPointerIdBits;
        
        // 手指數不變
        if (newPointerIdBits == oldPointerIdBits) {
            if (child == null || child.hasIdentityMatrix()) {
                if (child == null) {
                    // 呼叫View.dispatchTouchEvent()
                    handled = super.dispatchTouchEvent(event);
                } else {
                
                }
                // 返回處理的結果
                return handled;
            }
        } else {

        }
        return handled;
    }
複製程式碼

很簡單，呼叫父類View的diaptchTouchEvent()方法，由事件分發之View事件處理可知，會交給onTouchEvent()方法。

View事件處理其實還有OnTouchListener一環，但是一般不會給ViewGroup設定這個監聽器，因此這裡忽略了。

從整個分析過程可以看出，如果ViewGroup自己處理ACTION_DOWN事件，那麼ViewGroup.dispatchTouchEvent()的返回值是與ViewGroup.onTouchEvent()返回值相同的。

我們現在也用一幅圖來表示ViewGroup自己處理ACTION_DOWN事件的情況，其中包括兩套處理流程，我這裡還是再強調一遍ViewGroup自己處理ACTION_DOWN事件的情況

  1. ViewGroup截斷ACTION_DOWN事件
  2. ViewGroup找不到能處理ACTION_DOWN事件的子View

截斷ACTION_DOWN

處理ACTION_DOWN總結

ViewGroup對ACTION_DOWN的處理很關鍵，我們永遠要記住一點，它是為了找到mFirstTouchTarget，因為mFirstTouchTarget.child指向處理了ACTION_DOWN事件的子View。

為何mFirstTouchTarget如此關鍵，因為後續所有事件都是圍繞mFirstTouchTarget來處理的，例如把後續事件交給mFirstTouchTarget.child來處理。

處理ACTION_MOVE事件

檢測是否截斷ACTION_MOVE事件

對於ACTION_MOVE事件，ViewGroup也會去判斷是否進行截斷，程式碼片段如下

    public boolean dispatchTouchEvent(MotionEvent ev) {

        boolean handled = false;
        if (onFilterTouchEventForSecurity(ev)) {
            final int action = ev.getAction();
            final int actionMasked = action & MotionEvent.ACTION_MASK;

            // 1. 檢測是否截斷
            final boolean intercepted;
            // 1.2 如果有處理ACTION_DOWN事件的子View
            if (actionMasked == MotionEvent.ACTION_DOWN
                    || mFirstTouchTarget != null) {
                // 判斷子View是否請求不允許父View截斷事件
                final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
                if (!disallowIntercept) { // 子View允許截斷事件
                    // 判斷自己是否截斷
                    intercepted = onInterceptTouchEvent(ev);
                    ev.setAction(action); // restore action in case it was changed
                } else { // 子View不允許截斷事件
                    intercepted = false;
                }
            } else {
                // 1.3 沒有處理ACTION_DOWN的子View，就截斷ACTION_MOVE事件
                intercepted = true;
            }

        }
    }
複製程式碼

從程式碼中可以看到，mFirstTouchTarget成為了是否截斷ACTION_MOVE事件的判斷條件。現在知道ACTION_DOWN事件處理有多重要了吧，它直接影響了ACTION_MOVE事件的處理，當然還有ACTION_UP和ACTION_CANCEL事件的處理。

1.3步的意思是，既然沒有處理了ACTION_DOWN事件的子View，也就是mFirstTouchTarget == null，那麼只能由老夫ViewGroup截斷，然後自己處理了。

1.2步呢，如果有處理了ACTION_DOWN事件的子View，也就是mFirstTouchTarget != null，在把事件分發給mFirstTouchTarget.child之前呢，ViewGroup要看看自己是否要截斷，這就要分兩種情況了

  1. 如果子View允許父View截斷事件，那麼就通過onInterceptTouchEvent()來判斷ViewGroup自己是否截斷
  2. 如果子View不允許父View截斷事件，那麼ViewGroup肯定就不截斷了。

現在，有兩種情況會導致ViewGroup不截斷ACTION_MOVE事件

  1. mFirstTouchTarget != null，子View允許父ViewGroup截斷事件，並且ViewGroup的onInterceptTouchEvent()返回false
  2. mFirstTouchTarget != null，子View不允許父ViewGroup截斷事件

那麼接下來，我們還是先分析ViewGroup不截斷ACTION_MOVE事件的情況

不截斷ACTION_MOVE

事件分發給mFirstTouchTarget.child

如果ViewGroup不截斷事件，其實也說明mFirstTouchTarget不為null，那麼ACTION_MOVE事件會分發給mFirstTouchTarget.child，我們來看下程式碼

    public boolean dispatchTouchEvent(MotionEvent ev) {

        boolean handled = false;
        if (onFilterTouchEventForSecurity(ev)) {

            // 1. 檢測是否截斷ACTION_MOVE
            final boolean intercepted;
            if (actionMasked == MotionEvent.ACTION_DOWN
                    || mFirstTouchTarget != null) {
                final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
                if (!disallowIntercept) {
                    // 1.1 兒子允許截斷，老子自己決定也不截斷
                    intercepted = onInterceptTouchEvent(ev);
                } else {
                    // 1.2 兒子不允許截斷，老子就不截斷
                    intercepted = false;
                }
            } else {
            }
            
            if (!canceled && !intercepted) {

                if (actionMasked == MotionEvent.ACTION_DOWN
                        || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
                        || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
                    
                }
            }

            if (mFirstTouchTarget == null) {
                // 截斷事件的情況
            } else {
                while (target != null) {
                    final TouchTarget next = target.next;
                    if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
                        
                    } else {
                        // 不截斷事件，cancelChild為false
                        final boolean cancelChild = resetCancelNextUpFlag(target.child)
                                || intercepted;
                        // 3. 把事件交給mFirstTouchTarget指向的子View處理
                        if (dispatchTransformedTouchEvent(ev, cancelChild,
                                target.child, target.pointerIdBits)) {
                            handled = true;
                        }
                    // ...
                    }
                    // ...
                }
            }
        }
        return handled;
    }
複製程式碼

ViewGroup不截斷ACTION_MOVE事件時，就呼叫dispatchTransformedTouchEvent()把事件交給mFirstTouchTarget.chid處理

    private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
            View child, int desiredPointerIdBits) {
        final boolean handled;

        final int oldPointerIdBits = event.getPointerIdBits();
        final int newPointerIdBits = oldPointerIdBits & desiredPointerIdBits;

        final MotionEvent transformedEvent;
        // 1. child有單位矩陣的情況
        if (newPointerIdBits == oldPointerIdBits) { // 手指數沒有變
            if (child == null || child.hasIdentityMatrix()) {
                if (child == null) {
                    
                } else {
                    // 事件座標進行轉換
                    final float offsetX = mScrollX - child.mLeft;
                    final float offsetY = mScrollY - child.mTop;
                    event.offsetLocation(offsetX, offsetY);
                    
                    // 把事件傳遞給child
                    handled = child.dispatchTouchEvent(event);

                    event.offsetLocation(-offsetX, -offsetY);
                }
                return handled;
            }
            transformedEvent = MotionEvent.obtain(event);
        } else {
            transformedEvent = event.split(newPointerIdBits);
        }
        
        if (child == null) {
            
        }
        // 2. child沒單位矩陣的情況
        else {
            // 事件座標進行轉換
            final float offsetX = mScrollX - child.mLeft;
            final float offsetY = mScrollY - child.mTop;
            transformedEvent.offsetLocation(offsetX, offsetY);
            if (! child.hasIdentityMatrix()) {
                transformedEvent.transform(child.getInverseMatrix());
            }
            // 把事件傳遞給child
            handled = child.dispatchTouchEvent(transformedEvent);
        }

        return handled;
    }
複製程式碼

我們可以看到無論是哪種情況，最終都會呼叫child.dispatchTouchEvent()方法把ACTION_MOVE事件傳遞給child。 也就是說處理了ACTION_DOWN事件的子View最終會收到ACTION_MOVE事件。

我們用一張圖來總結下ViewGroup不截斷ACTION_MOVE事件的處理流程

ViewGroup事件分發和處理原始碼分析

截斷ACTION_MOVE

從前面的分析的可知，如果ViewGroup截斷ACTION_MOVE事件，是有兩種情況

  1. mFirstTouchTarget == null，那麼ViewGroup就要截斷事件自己來處理。
  2. mFirstTouchTarget != null，並且子View允許截斷事件，ViewGroup的onInterceptTouchEvent()返回true。

然而這兩種情況的程式碼處理流程是不同的，這無疑又給程式碼分析增加了難度，我們先來看第一種情況，沒有mFirstTouchTarget的情況

    public boolean dispatchTouchEvent(MotionEvent ev) {

        boolean handled = false;
        if (onFilterTouchEventForSecurity(ev)) {

            final boolean intercepted;
            if (actionMasked == MotionEvent.ACTION_DOWN
                    || mFirstTouchTarget != null) {

            } else {
                // 1. mFirstTouchTarget為null, 截斷事件
                intercepted = true;
            }
            
            if (!canceled && !intercepted) {

                if (actionMasked == MotionEvent.ACTION_DOWN
                        || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
                        || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
                    
                }
            }

            if (mFirstTouchTarget == null) {
                // 2. 截斷了，把事件交給ViewGroup自己處理
                handled = dispatchTransformedTouchEvent(ev, canceled, null,
                        TouchTarget.ALL_POINTER_IDS);
            } else {
                // ...
            }
        }
        return handled;
    }
複製程式碼

從程式碼可以看到，當mFirstTouchTarget == null的時候，ViewGroup截斷事件，就呼叫dispatchTransformedTouchEvent()方法交給自己處理，這個方法之前分析過，不過注意這裡的第三個引數為null，代表沒有處理這個事件的子View

    private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
            View child, int desiredPointerIdBits) {
        final boolean handled;
        
        // 手指數沒變
        if (newPointerIdBits == oldPointerIdBits) {
            if (child == null || child.hasIdentityMatrix()) {
                if (child == null) {
                    // 呼叫父類View的dispatchTouchEvent()方法
                    handled = super.dispatchTouchEvent(event);
                } else {

                }
                return handled;
            }
            
        }
複製程式碼

很簡單，就是呼叫父類View的dispatchTouchEvent()方法，也就是呼叫了ViewGroup.onTouchEvent()方法，並且ViewGroup.dispatchTouchEvent()的返回值與ViewGroup.onTouchEvent()相同。

現在來看看第二種截斷的情況，也就是mFirstTouchTarget != null，並且ViewGroup.onInterceptTouchEvent()返回true。

    public boolean dispatchTouchEvent(MotionEvent ev) {

        boolean handled = false;
        if (onFilterTouchEventForSecurity(ev)) {

            // 檢測是否截斷
            final boolean intercepted;
            if (actionMasked == MotionEvent.ACTION_DOWN
                    || mFirstTouchTarget != null) {
                final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
                if (!disallowIntercept) {
                    // 1. 子View允許截斷，並且ViewGroup也截斷了，intercepted為true
                    intercepted = onInterceptTouchEvent(ev);
                } else {
                    intercepted = false;
                }
            } else {

            }

            if (!canceled && !intercepted) {
                // ...
            }

            if (mFirstTouchTarget == null) {
                // ...
            } else {
                TouchTarget predecessor = null;
                TouchTarget target = mFirstTouchTarget;
                while (target != null) {
                    final TouchTarget next = target.next;
                    if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
                        // ...
                    } else {
                        // intercepted為true, cancelChild為true，代表取消child處理事件
                        final boolean cancelChild = resetCancelNextUpFlag(target.child)
                                || intercepted;
                        // 2. 向child傳送ACTION_CANCEL事件
                        if (dispatchTransformedTouchEvent(ev, cancelChild,
                                target.child, target.pointerIdBits)) {
                            handled = true;
                        }
                        
                        // 取消child處理事件
                        if (cancelChild) {
                            if (predecessor == null) {
                                // 3. 把mFirstTouchTarget值設為null
                                mFirstTouchTarget = next;
                            } else {
                                predecessor.next = next;
                            }
                            target.recycle();
                            target = next;
                            continue;
                        }
                    }
                    predecessor = target;
                    target = next;
                }
            }
        }
        return handled;
    }
複製程式碼

第1步，當mFirstTouchTarget != null，子View允許父ViewGroup截斷ACTION_MOVE事件，並且ViewGroup.onInterceptTouchEvent()返回true，也就是父ViewGroup截斷事件。

第2步，ViewGroup仍然會呼叫dispatchTransformedTouchEvent()方法把事件傳送給mFirstTouchTarget，只是這次mFisrtTouchTarget接收到的是ACTION_CANCEL事件，而不是ACTION_MOVE事件。注意，第二個引數cancelChild的值為true，我們來看下具體的方法實現

    private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
            View child, int desiredPointerIdBits) {
        final boolean handled;

        final int oldAction = event.getAction();
        // cancel值為true
        if (cancel || oldAction == MotionEvent.ACTION_CANCEL) {
            // 設定事件的型別為ACTION_CANCEL
            event.setAction(MotionEvent.ACTION_CANCEL);
            if (child == null) {
                handled = super.dispatchTouchEvent(event);
            } else {
                // 把ACTION_CANCEL的事件傳送給child
                handled = child.dispatchTouchEvent(event);
            }
            event.setAction(oldAction);
            // 返回child處理結果
            return handled;
        }

    }
複製程式碼

我們可以驚訝的發現，當ViewGroup截斷了ACTION_MOVE事件，mFirstTouchTarget.child居然收到的是ACTION_CANCEL事件。現在大家知道了一個View在怎樣的情況下收到ACTION_CANCEL事件吧！！！

把ACTION_CANCEL事件傳送給mFirstTouchTarget後還沒完，還進行了第3步，把mFirstTouchTarget設定為null。 這就很過分了，ViewGroup截斷了本來屬於mFirstTouchTarget的ACTION_MOVE事件，把ACTION_MOVE變為ACTION_CANCEL事件傳送了mFirstTouchTarget，最後還要取消mFirstTouchTarget.child接收後續事件的資格。

由於滑動的時候，會產生大量的ACTION_MOVE事件，既然ViewGroup截斷ACTION_MOVE之後，後續的ACTION_MOVE事件怎麼處理呢？當然是按照mFirstTouchTarget == null的情況，呼叫ViewGroup.onTouchEvent()處理。

現在，我們再用一幅圖來表示ViewGroup截斷ACTION_MOVE事件的過程

截斷ACTION_MOVE

這幅圖沒有列出傳送ACTION_CANCEL結果，似乎平時也沒有在意ACTION_CANCEL的處理結果。

處理 ACTION_UP 和 ACTION_CANCEL 事件

View/ViewGroup每一次都是處理一個事件序列，一個事件序列由ACTON_DOWN開始，由ACTION_UP/ACTION_CANCEL結束，中間有零個或者多個ACTION_MOVE事件。

ACTION_UP和ACTION_CANCEL理論上講只能取其一。

ViewGroup處理ACTION_UP和ACTION_CANCEL事件與處理ACTION_MOVE事件的流程是一樣的，大家可以從原始碼中自行再分析一遍。

正確地使用requestDisallowInterceptTouchEvent()

前面我們一直在提子View能夠請求父View不允許截斷事件，那麼子View如何做到呢

        final ViewParent parent = getParent();
        if (parent != null) {
            parent.requestDisallowInterceptTouchEvent(true);
        }
複製程式碼

獲取父View，並呼叫其requestDisallowInterceptTouchEvent(true)方法，從而不允許父View截斷事件。

父View一般為ViewGroup，我們就來看看ViewGroup.requestDisallowInterceptTouchEvent()方法的實現吧

    // ViewGroup.java

    public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {
        // 已經設定FLAG_DISALLOW_INTERCEPT標記，就直接返回
        if (disallowIntercept == ((mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0)) {
            // We're already in this state, assume our ancestors are too
            return;
        }

        // 根據引數值來決定是否設定FLAG_DISALLOW_INTERCEPT標記
        if (disallowIntercept) {
            mGroupFlags |= FLAG_DISALLOW_INTERCEPT;
        } else {
            mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
        }

        // 把這個請求繼續往上傳給父View
        if (mParent != null) {
            mParent.requestDisallowInterceptTouchEvent(disallowIntercept);
        }
    }
複製程式碼

requestDisallowInterceptTouchEvent(boolean disallowIntercept)會根據引數disallowIntercept的值來決定是否設定FLAG_DISALLOW_INTERCEPT標記，再去請求父View做相同的事情。

現在，我們可以想象一個事情，假如某個子View呼叫了getParent.requestDisallowInterceptTouchEvent(true)，那麼這個子View的上層的所有父View都會設定一個FLAG_DISALLOW_INTERCEPT標記。這個標記一旦設定，那麼所有的父View不再截斷後續任何事件。這個方法實在是霸道，要慎用，否則可能影響某個父View的功能。

然而requestDisallowInterceptTouchEvent()方法的呼叫並不是在任何時候都有效的，請看如下程式碼

    private void resetTouchState() {
        // 清除FLAG_DISALLOW_INTERCEPT標記
        mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
    }
    
    
    public boolean dispatchTouchEvent(MotionEvent ev) {

        if (onFilterTouchEventForSecurity(ev)) {
            
            // ACTION_DOWN清除FLAG_DISALLOW_INTERCEPT標記
            if (actionMasked == MotionEvent.ACTION_DOWN) {
                resetTouchState();
            }


            final boolean canceled = resetCancelNextUpFlag(this)
                    || actionMasked == MotionEvent.ACTION_CANCEL;

            // 省略處理ACTION_DOWM, ACTION_MOVE, ACTIOON_UP的程式碼

            
            // ACTION_CANCEL或者ACTION_UP也會清除FLAG_DISALLOW_INTERCEPT標記
            if (canceled
                    || actionMasked == MotionEvent.ACTION_UP
                    || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
                resetTouchState();
            } else if (split && actionMasked == MotionEvent.ACTION_POINTER_UP) {

            }
        }
        
        return handled;
    }

複製程式碼

我們可以發現，在處理ACTION_DOWN事件的時候，會首先清除這個FLAG_DISALLOW_INTERCEPT標記，那意思就是說，子View如果在父View處理ACTION_DOWN之前呼叫了getParent().requestDisallowInterceptTouchEvent(true)方法，其實是無效的。

ACTION_UP或ACTION_CANCEL事件，都表示事件序列的終止，我們可以看到，在處理完ACTION_UP或ACTION_CANCEL事件，都會取消FLAG_DISALLOW_INTERCEPT標記。很顯然這是可以理解的，因為一個事件序列完了，就要恢復狀態，等待處理下一個事件序列。

現在，我們現在可以得出一個推論，getParent().requestDisallowInterceptTouchEvent(true)是要在接收ACTION_DOWN之後，並在接收ACTION_UP或ACTION_CANCEL事件之前呼叫才有效。很明顯這個方法只是在針對ACTION_MOVE事件。

那麼，什麼情況下子View會去請求不允許父View截斷ACTION_MOVE事件呢？我用ViewPager舉例讓大家體會下。

第一種情況就是ViewPager在onInterceptTouchEvent()接收到ACTION_MOVE事件，準備截斷ACTION_MOVE事件，在執行滑動程式碼之前，呼叫getParent().requestDisallowInterceptTouchEvent(true)， 請求父View不允許截斷後續ACTION_MOVE事件。為何要向父View做這個請求？因為既然ViewPager已經利用ACTION_MOVE開始滑動了，父View再截斷ViewPager的ACTION_MOVE就說不過去了吧。

第二種情況就是ViewPager在手指快速滑動並抬起後，ViewPager仍然還處於滑動狀態，此時如果手指再按下，ViewPager認為這是一個終止當前滑動，並重新進行滑動的動作，因此ViewPager會向父View請求不允許截斷ACTION_MOVE事件，因為它要馬上利用ACTION_MOVE開始再進行滑動。

如果大家能看懂這前後兩篇文章，分析ViewPager沒有太大的問題的。

從這兩種情況可以得出一個結論，那就是如果當前控制元件即將利用ACTION_MOVE來執行某種持續的動作前，例如滑動，那麼它可以請求父View不允許截斷後續的ACTION_MOVE事件。

總結

文章非常長，但是已經把每個過程都分析清楚了。然而在實戰中，無論是自定義View事件處理，還是事件衝突解決，我們往往會感覺畏首畏尾，有點摸不著頭腦。現在我對本文的關鍵點進行總結，希望大家在實際應用中牢記這些關鍵點

  1. 一定要要知道ViewGroup.dispatchTouchEvent()何時返回true，何時返回false。因為處理了事件才返回true，因為沒有處理事件才返回false。
  2. 處理ACTION_DOWN時，出現一個關鍵變數，就是mFirstTouchTarget，一定要記住，只有在消費了ACTION_DOWN事件才有值。
  3. ACTION_MOVE正常的情況下會傳給mFirstTouchTarget.child，而如果被ViewGroup截斷，就會把接收到ACTION_MOVE變為ACTION_CANCEL事件傳送給mFirstTouchTarget.child，並且把mFirstTouchTarget置空，後續的ACTION_MOVE事件就會傳給ViewGroup的onTouchEvent()。
  4. ACTION_UP, ACTION_CANCEL事件處理流程與ACTION_MOVE一樣。
  5. 注意子View請求不允許父View截斷的呼叫時機。

相關文章