Android進階之View事件分發機制和源碼詳解

作者： Android開發編程 2021-08-17 13:41:11

移動開發 Android

View的位置主要由它的四個頂點來決定，即它的四個屬性：top、left、right、bottom，分別表示View左上角的坐標點( top，left) 以及右下角的坐標點( right，bottom)。

[[418059]]

本文轉載自微信公眾號「Android開發編程」，作者Android開發編程。轉載本文請聯系Android開發編程公眾號。

前言

在Android 開發中事件分發是比較重要的，也是比較難理解的;

開發中會經常遇到滑動沖突(比如ScrollView或是SliddingMenu與ListView的嵌套)的問題，

需要我們深入的了解android事件響應機制才能解決，

事件響應機制已經是android開發者必不可少的知識。

那么今天我們就來詳細講解下事件分發，各位老鐵們一起學習

一、view事件相關知識了解

1、View的位置參數

同時，我們可以得到View的大小：

width = right - left 
height = bottom - top

而這四個參數可以由以下方式獲取：

Left = getLeft(); 
Right = getRight(); 
Top = getTop(); 
Bottom = getBottom();

Android3.0后，View增加了x、y、translationX和translationY這幾個參數。其中x和y是View左上角的坐標，而translationX和translationY是View左上角相對于容器的偏移量。他們之間的換算關系如下：

x = left + translationX; 
y = top + translationY;

2、MotionEvent

我們對屏幕的點擊，滑動，抬起等一系的動作都是由一個一個MotionEvent對象組成的。根據不同動作，主要有以下三種事件類型：

ACTION_DOWN：手指剛接觸屏幕，按下去的那一瞬間產生該事件
ACTION_MOVE：手指在屏幕上移動時候產生該事件
ACTION_UP：手指從屏幕上松開的瞬間產生該事件

從ACTION_DOWN開始到ACTION_UP結束我們稱為一個事件序列

正常情況下，無論你手指在屏幕上有多么騷的操作，最終呈現在MotionEvent上來講無外乎下面兩種;

點擊后抬起，也就是單擊操作：ACTION_DOWN -> ACTION_UP
點擊后再風騷的滑動一段距離，再抬起：ACTION_DOWN -> ACTION_MOVE -> ... -> ACTION_MOVE -> ACTION_UP;

public class MotionEventActivity extends BaseActivity { 
    private Button mButton; 
    @Override 
    protected void onCreate(Bundle savedInstanceState) { 
        super.onCreate(savedInstanceState); 
        setContentView(R.layout.activity_motion_event); 
        mButton = (Button) findViewById(R.id.button); 
        mButton.setOnTouchListener(new View.OnTouchListener() { 
            @Override 
            public boolean onTouch(View v, MotionEvent event) { 
                switch (event.getAction()) { 
                    case MotionEvent.ACTION_DOWN: 
                        e("MotionEvent: ACTION_DOWN"); 
                        break; 
                    case MotionEvent.ACTION_MOVE: 
                        e("MotionEvent: ACTION_MOVE"); 
                        break; 
                    case MotionEvent.ACTION_UP: 
                        e("MotionEvent: ACTION_UP"); 
                        break; 
                } 
                return false; 
            } 
        }); 
    } 
    public void click(View v) { 
        e("點擊了按鈕"); 
    } 
}

3、Scroller

彈性滑動對象，用于實現View的彈性滑動。其本身無法讓View彈性滑動，需要和View的computeScroll方法配合使用才能完成這個功能。使用方法：

Scroller scroller = new Scroller(mContext); 
//緩慢移動到指定位置 
private void smoothScrollTo(int destX,int destY){ 
    int scrollX = getScrollX(); 
    int delta = destX - scrollX; 
    //1000ms內滑向destX,效果就是慢慢滑動 
    mScroller.startScroll(scrollX,0,delta,0,1000); 
    invalidata(); 
}  
@Override 
public void computeScroll(){ 
    if(mScroller.computeScrollOffset()){ 
    scrollTo(mScroller.getCurrX,mScroller.getCurrY()); 
    postInvalidate(); 
    } 
}

4、事件分發涉及方法了解

dispatchTouchEvent(MotionEvent ev)：用來進行事件分發。如果事件能傳遞給當前的View，那么此方法一定會被調用。
onInterceptTouchEvent(MotionEvent ev)：用來判斷是否攔截某個事件，如果當前View攔截了某個事件，那么在同一個事件序列中，此方法不會再被調用。
onTouchEvent(MotionEvent ev)：用來處理觸摸事件，返回結果表示是否消耗當前事件，如果不消耗，則在同一個事件序列中，當前View無法再次接受事件。
onTouch(View view, MotionEvent motionEvent)：用于處理觸摸事件，通過setOnTouchListener設置，很常見的方法。
onClick(View view)：用于處理點擊事件，通過setOnClickListener設置，很常見的方法。
requestDisallowInterceptTouchEvent(boolean b)：請求不攔截觸摸事件。一般用于處理滑動沖突中，子控件請求父控件不攔截;
ACTION_DOWN以外的其他事件，ACTION_DOWN事件不受影響。

二、事件分發

當一個MotionEvent產生了以后，就是你的手指在屏幕上做一系列動作的時候，系統需要把這一系列的MotionEvent分發給一個具體的View。我們重點需要了解這個分發的過程，那么系統是如何去判斷這個事件要給哪個View，也就是說是如何進行分發的呢?

事件分發需要View的三個重要方法來共同完成：

1、public boolean dispatchTouchEvent(MotionEvent event)

通過方法名我們不難猜測，它就是事件分發的重要方法。那么很明顯，如果一個MotionEvent傳遞給了View，那么dispatchTouchEvent方法一定會被調用!

返回值：表示是否消費了當前事件。可能是View本身的onTouchEvent方法消費，也可能是子View的dispatchTouchEvent方法中消費。返回true表示事件被消費，本次的事件終止。返回false表示View以及子View均沒有消費事件，將調用父View的onTouchEvent方法;

2、public boolean onInterceptTouchEvent(MotionEvent ev)

事件攔截，當一個ViewGroup在接到MotionEvent事件序列時候，首先會調用此方法判斷是否需要攔截。特別注意，這是ViewGroup特有的方法，View并沒有攔截方法;

返回值：是否攔截事件傳遞，返回true表示攔截了事件，那么事件將不再向下分發而是調用View本身的onTouchEvent方法。返回false表示不做攔截，事件將向下分發到子View的dispatchTouchEvent方法。

3、public boolean onTouchEvent(MotionEvent ev)

真正對MotionEvent進行處理或者說消費的方法。在dispatchTouchEvent進行調用;

返回值：返回true表示事件被消費，本次的事件終止。返回false表示事件沒有被消費，將調用父View的onTouchEvent方法

上面的三個方法可以用以下的偽代碼來表示其之間的關系。

public boolean dispatchTouchEvent(MotionEvent ev) { 
        boolean consume = false;//事件是否被消費 
        if (onInterceptTouchEvent(ev)){//調用onInterceptTouchEvent判斷是否攔截事件 
            consume = onTouchEvent(ev);//如果攔截則調用自身的onTouchEvent方法 
        }else{ 
            consume = child.dispatchTouchEvent(ev);//不攔截調用子View的dispatchTouchEvent方法 
        } 
        return consume;//返回值表示事件是否被消費，true事件終止，false調用父View的onTouchEvent方法 
    }

接下來我們來看一下View 和ViewGroup 在事件分發的時候有什么不一樣的地方

ViewGroup是View的子類，也就是說ViewGroup本身就是一個View，但是它可以包含子View(當然子View也可能是一個ViewGroup)，所以不難理解，上面所展示的偽代碼表示的是ViewGroup 處理事件分發的流程。而View本身是不存在分發，所以也沒有攔截方法(onInterceptTouchEvent)，它只能在onTouchEvent方法中進行處理消費或者不消費。

通過下面的流程圖，會更加清晰的幫助我們梳理事件分發機制

可以看出事件的傳遞過程都是從父View到子View。

子View可以通過requestDisallowInterceptTouchEvent方法干預父View的事件分發過程(ACTION_DOWN事件除外)，而這就是我們處理滑動沖突常用的關鍵方法;

對于View(注意!ViewGroup也是View)而言，如果設置了onTouchListener，那么OnTouchListener方法中的onTouch方法會被回調。onTouch方法返回true，則onTouchEvent方法不會被調用(onClick事件是在onTouchEvent中調用)所以三者優先級是onTouch->onTouchEvent->onClick;

View 的onTouchEvent 方法默認都會消費掉事件(返回true)，除非它是不可點擊的(clickable和longClickable同時為false)，View的longClickable默認為false，clickable需要區分情況，如Button的clickable默認為true，而TextView的clickable默認為false;

事件傳遞的機制，這里給出一些總結：

一個事件系列以down事件開始，中間包含數量不定的move事件，最終以up事件結束;
正常情況下，一個事件序列只能由一個View攔截并消耗;
某個View攔截了事件后，該事件序列只能由它去處理，并且它的onInterceptTouchEvent不會再被調用;
某個View一旦開始處理事件，如果它不消耗ACTION_DOWN事件( onTouchEvnet返回false) ，那么同一事件序列中的其他事件都不會交給他處理，并且事件將重新交由他的父元素去處理，即父元素的onTouchEvent被調用;。
如果View不消耗ACTION_DOWN以外的其他事件，那么這個事件將會消失，此時父元素的onTouchEvent并不會被調用，并且當前View可以持續收到后續的事件，最終消失的點擊事件會傳遞給Activity去處理。
ViewGroup默認不攔截任何事件;
View沒有onInterceptTouchEvent方法，一旦事件傳遞給它，它的onTouchEvent方法會被調用;
View的onTouchEvent默認消耗事件，除非他是不可點擊的( clickable和longClickable同時為false) 。View的longClickable屬性默認false，clickable默認屬性分情況(如TextView為false，button為true);
View的enable屬性不影響onTouchEvent的默認返回值;
onClick會發生的前提是當前View是可點擊的，并且收到了down和up事件;
事件傳遞過程總是由外向內的，即事件總是先傳遞給父元素，然后由父元素分發給子View，通過requestDisallowInterceptTouchEvent方法可以在子元素中干預父元素的分發過程，但是ACTION_DOWN事件除外;

三、滑動沖突的解決方式

1、外部攔截法

所謂外部攔截法是指點擊事件都先經過父容器的攔截處理，如果父容器需要此事件就攔截，否則就不攔截。下面是偽代碼：

public boolean onInterceptTouchEvent (MotionEvent event){ 
boolean intercepted = false; 
int x = (int) event.getX(); 
int y = (int) event.getY(); 
switch (event.getAction()) { 
case MotionEvent.ACTION_DOWN: 
    intercepted = false; 
    break; 
case MotionEvent.ACTION_MOVE: 
    if (父容器需要當前事件） { 
    intercepted = true; 
    } else { 
    intercepted = false; 
    }  
    break; 
case MotionEvent.ACTION_UP: 
    intercepted = false; 
    break; 
default :  
    break; 
}  
mLastXIntercept = x; 
mLastYIntercept = y; 
return intercepted;

針對不同沖突，只需修改父容器需要當前事件的條件即可。其他不需修改也不能修改。

ACTION_DOWN:必須返回false。因為如果返回true，后續事件都會被攔截，無法傳遞給子View;

ACTION_MOVE：根據需要決定是否攔截;

ACTION_UP：必須返回false。如果攔截，那么子View無法接受up事件，無法完成click操作。而如果是父容器需要該事件，那么在ACTION_MOVE時已經進行了攔截，根據上一節的結論3，ACTION_UP不會經過onInterceptTouchEvent方法，直接交給父容器處理;

2、內部攔截法

內部攔截法是指父容器不攔截任何事件，所有的事件都傳遞給子元素，如果子元素需要此事件就直接消耗，否則就交由父容器進行處理。這種方法與Android事件分發機制不一致，需要配合requestDisallowInterceptTouchEvent方法才能正常工作。下面是偽代碼：

public boolean dispatchTouchEvent ( MotionEvent event ) { 
int x = (int) event.getX(); 
int y = (int) event.getY(); 
switch (event.getAction) { 
case MotionEvent.ACTION_DOWN: 
    parent.requestDisallowInterceptTouchEvent(true); 
    break; 
case MotionEvent.ACTION_MOVE: 
    int deltaX = x - mLastX; 
    int deltaY = y - mLastY; 
    if (父容器需要此類點擊事件) { 
        parent.requestDisallowInterceptTouchEvent(false); 
    }  
    break; 
case MotionEvent.ACTION_UP: 
    break; 
default :  
    break; 
}  
mLastX = x; 
mLastY = y; 
return super.dispatchTouchEvent(event); 
}

除了子元素需要做處理外，父元素也要默認攔截除了ACTION_DOWN以外的其他事件，這樣當子元素調用parent.requestDisallowInterceptTouchEvent(false)方法時，父元素才能繼續攔截所需的事件。因此，父元素要做以下修改：

public boolean onInterceptTouchEvent (MotionEvent event) { 
    int action = event.getAction(); 
    if(action == MotionEvent.ACTION_DOWN) { 
        return false; 
    } else { 
        return true; 
    } 
}

四、事件分發機制-源碼分析

從源碼的角度來了解一下Android下的事件分發機制

1、首先看到Activity中的dispatchTouchEvent()方法源碼：

public boolean dispatchTouchEvent(MotionEvent ev) { 
    // 如果是ACTION_DOWN事件會走這個語句，onUserInteraction()這個方法在系統中是空實現 
    if (ev.getAction() == MotionEvent.ACTION_DOWN) { 
        onUserInteraction(); 
    } 
    /** 
     * 主要看一下這行代碼 
     * getWindow()表示獲取Window的子類PhoneWindow對象 
     * 也就是說調用PhoneWindow中的superDispatchTouchEvent(ev)方法，判斷是否有控件處理事件 
     */ 
    if (getWindow().superDispatchTouchEvent(ev)) { 
        return true; 
    } 
    // 如果沒有控件能處理事件，就走這一行代碼，調用Activity的onTouchEvent()方法處理事件 
    return onTouchEvent(ev); 
}

2、接著進入到PhoneWindow中的，查看superDispatchTouchEvent(ev)這個方法：

@Override 
public boolean superDispatchTouchEvent(MotionEvent event) { 
    return mDecor.superDispatchTouchEvent(event); 
}

在PhoneWindow類的superDispatchTouchEvent(ev)方法中，直接調用了mDecor對象的superDispatchTouchEvent(ev)方法，mDecore其實就是繼承至FrameLayout的DecorView的對象。在《Activity的組成》這篇博客中貼出了DecorView類的定義源碼。

接著查看類中的superDispatchTouchEvent(ev)這個方法：

public boolean superDispatchTouchEvent(MotionEvent event) { 
    return super.dispatchTouchEvent(event); 
}

只有一句代碼，super.dispatchTouchEvent(event)，調用父類的dispatchTouchEvent(event)方法，也就是FrameLayout的dispatchTouchEvent(event)方法，查看FrameLayout類會發現FrameLayout并沒有重寫dispatchTouchEvent(event)方法，那么就是使用的ViewGroup中的dispatchTouchEvent(event)方法。

到這里也就完全說明了Activity在做事件分發時調用的是ViewGroup中的dispatchTouchEvent()方法。

3、查看ViewGroup中的dispatchTouchEvent()方法：

@Override 
public boolean dispatchTouchEvent(MotionEvent ev) { 
    ... 
    boolean handled = false; 
    // 過濾觸摸安全策略，如果是false(窗口或控件被遮住了時)，直接跳出觸摸事件 
    // 如果應該分發事件(調用onTouch()或onTouchEvdent()方法)，則返回True;如果應該刪除事件，則返回false 
    if (onFilterTouchEventForSecurity(ev)) { 
        ... 
        /** 
         * 如果是DOWN事件就先將mFirstTouchTarget設置為null， 
         * 然后在resetTouchState()方法中重置狀態 
         */ 
        if (actionMasked == MotionEvent.ACTION_DOWN) { 
            cancelAndClearTouchTargets(ev); 
            resetTouchState(); 
        } 
        // 定義變量intercepted標記ViewGroup是否攔截Touch事件的傳遞. 
        final boolean intercepted; 
        // 事件為ACTION_DOWN或者mFirstTouchTarget不為null(有控件消費touch事件) 
        if (actionMasked == MotionEvent.ACTION_DOWN || mFirstTouchTarget != null) { 
            //判斷disallowIntercept(禁止攔截)標志位 
            final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0; 
            //當沒有禁止攔截時 
            if (!disallowIntercept) { 
                // 調用onInterceptTouchEvent(ev)方法，并將返回值賦給intercepted 
                intercepted = onInterceptTouchEvent(ev); 
                ev.setAction(action); 
            } else { 
                 //當禁止攔截時，指定intercepted = false，表示不攔截事件 
                intercepted = false; 
            } 
        } else { 
            //當事件不是ACTION_DOWN并且mFirstTouchTarget為null(沒有控件消費touch事件)時 
            //設置 intercepted = true，表示ViewGroup執行Touch事件攔截的操作。 
            intercepted = true; 
        } 
        ... 
        // 事件分發 
        final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0; 
        TouchTarget newTouchTarget = null; 
        boolean alreadyDispatchedToNewTouchTarget = false; 
        //不是ACTION_CANCEL事件并且intercepted為false(ViewGroup不攔截事件onInterceptTouchEvent()方法返回false) 
        if (!canceled && !intercepted) { 
            //處理ACTION_DOWN事件 
            if (actionMasked == MotionEvent.ACTION_DOWN 
                || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN) 
                || actionMasked == MotionEvent.ACTION_HOVER_MOVE) { 
                final int actionIndex = ev.getActionIndex();  
                final int idBitsToAssign = split ? 1 << ev.getPointerId(actionIndex):TouchTarget.ALL_POINTER_IDS; 
                removePointersFromTouchTargets(idBitsToAssign); 
                final int childrenCount = mChildrenCount; 
                if (childrenCount != 0) { 
                    // 依據Touch坐標尋找孩子控件來消費Touch事件 
                    final View[] children = mChildren; 
                    final float x = ev.getX(actionIndex); 
                    final float y = ev.getY(actionIndex); 
                    final boolean customOrder = isChildrenDrawingOrderEnabled(); 
                    // 遍歷所有孩子控件，判斷哪個消費Touch事件 
                    for (int i = childrenCount - 1; i >= 0; i--) { 
                        final int childIndex = customOrder ? getChildDrawingOrder(childrenCount, i) : i; 
                        final View child = children[childIndex]; 
                        if (!canViewReceivePointerEvents(child) || !isTransformedTouchPointInView(x, y, child, null)) { 
                            continue; 
                        } 
                        newTouchTarget = getTouchTarget(child); 
                        if (newTouchTarget != null) { 
                            // 找到消費Touch事件的孩子控件，跳出循環，并用newTouchTarget表示孩子控件 
                            newTouchTarget.pointerIdBits |= idBitsToAssign; 
                            break; 
                        } 
                        resetCancelNextUpFlag(child); 
                        // 沒有跳出循環，走到這一步，就會調用dispatchTransformedTouchEvent()方法，將事件傳給孩子控件做遞歸處理，第三個參數不為null 
                        if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) { 
                           ... 
                        } 
                    } 
                } 
                /** 
                 * 如果在循環中沒有孩子控件消費事件并且之前的mFirstTouchTarget不為空 
                 */ 
                if (newTouchTarget == null && mFirstTouchTarget != null) { 
                    // 將mFirstTouchTarget的賦給newTouchTarget 
                    newTouchTarget = mFirstTouchTarget; 
                    while (newTouchTarget.next != null) { 
                        newTouchTarget = newTouchTarget.next; 
                    } 
                    // newTouchTarget指向了最初的TouchTarget 
                    newTouchTarget.pointerIdBits |= idBitsToAssign; 
                } 
            } 
        } 
        /** 
         * 分發Touch事件至目標控件(target)，以上過程主要針對ACTION_DOWN， 
         * 如果不是（上一步中判斷intercepted變量），比如ACTION_MOVE和ACTION_UP，就是從此處開始執行 
         */ 
        if (mFirstTouchTarget == null) { 
            /** 
             * mFirstTouchTarget為null表示Touch事件未被消費或Touch事件被攔截了， 
             * 則調用ViewGroup的dispatchTransformedTouchEvent()方法，遞歸處理，第三個參數為null 
             */ 
            handled = dispatchTransformedTouchEvent(ev, canceled, null,TouchTarget.ALL_POINTER_IDS); 
        } else { 
            /** 
             * mFirstTouchTarget不為null表示找到了可以消費Touch事件的子View 
             * 并且MOVE或UP事件可以傳遞到該子View 
             */ 
            TouchTarget predecessor = null; 
            // 將找到的可以消費事件的mFirstTouchTarget賦給目標控件(target) 
            TouchTarget target = mFirstTouchTarget; 
            while (target != null) { 
                final TouchTarget next = target.next; 
                // 如果已經分發到新的控件并且消費事件的目標控件就是新的控件 
                if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) { 
                    handled = true; 
                } else { 
                    final boolean cancelChild = resetCancelNextUpFlag(target.child) || intercepted; 
                    // 否則調用dispatchTransformedTouchEvent()方法進行遞歸處理，第三個參數不為null 
                    if (dispatchTransformedTouchEvent(ev, cancelChild, target.child, target.pointerIdBits)) { 
                        handled = true; 
                    } 
                   ... 
                } 
                predecessor = target; 
                target = next; 
            } 
        } 
        /** 
         * 如果是ACTION_UP和ACTION_CANCEL事件，還原狀態 
         */ 
        if (canceled|| actionMasked == MotionEvent.ACTION_UP 
                    || actionMasked == MotionEvent.ACTION_HOVER_MOVE) { 
            resetTouchState(); 
        } else if (split && actionMasked == MotionEvent.ACTION_POINTER_UP) { 
            ... 
        } 
    } 
    ... 
    return handled; 
}

我們可以看到在上面的方法中，調用的onInterceptTouchEvent()判斷是否需要攔截事件。

查看ViewGroup中的dispatchTransformedTouchEvent()方法:

private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel, 
            View child, int desiredPointerIdBits) { 
    final boolean handled; 
    ... 
        if (child == null) { 
            // 如果孩子控件為空，就調用View的dispatchTouchEvent()方法，在View的dispatchTouchEvent()方法中會調用onTouchEvent()方法 
            handled = super.dispatchTouchEvent(event); 
        } else { 
            // 如果孩子控件不為空，就調用孩子控件的dispatchTouchEvent()方法 
            // 在此處孩子控件也還有可能是ViewGroup，所以就是繼續調用ViewGroup的dispatchTouchEvent()方法 
            handled = child.dispatchTouchEvent(event); 
        } 
        event.setAction(oldAction); 
        return handled; 
    } 
   ... 
    transformedEvent.recycle(); 
    return handled; 
} 
查看ViewGroup中onInterceptTouchEvent()方法： 
public boolean onInterceptTouchEvent(MotionEvent ev) { 
    return false; 
}

在ViewGroup中，沒有重寫onTouchEvent()方法，所以調用的是View中的onTouchEvent()方法。

4、在View類中，首先看一下View中的dispatchTouchEvent()方法：

public boolean dispatchTouchEvent(MotionEvent event) { 
    // If the event should be handled by accessibility focus first. 
    if (event.isTargetAccessibilityFocus()) { 
        // We don't have focus or no virtual descendant has it, do not handle the event. 
        if (!isAccessibilityFocusedViewOrHost()) { 
            return false; 
        } 
        // We have focus and got the event, then use normal event dispatch. 
        event.setTargetAccessibilityFocus(false); 
    } 
    boolean result = false; 
    if (mInputEventConsistencyVerifier != null) { 
        mInputEventConsistencyVerifier.onTouchEvent(event, 0); 
    } 
    // 如果是DOWN事件，重置狀態 
    final int actionMasked = event.getActionMasked(); 
    if (actionMasked == MotionEvent.ACTION_DOWN) { 
        stopNestedScroll(); 
    } 
    // 過濾觸摸安全策略，如果是false(窗口或控件被遮住了時)，直接跳出觸摸事件 
    // 如果應該分發事件(調用onTouch()或onTouchEvdent()方法)，則返回True;如果應該刪除事件，則返回false 
    if (onFilterTouchEventForSecurity(event)) { 
        ListenerInfo li = mListenerInfo; 
        if (li != null && li.mOnTouchListener != null 
                && (mViewFlags & ENABLED_MASK) == ENABLED 
                && li.mOnTouchListener.onTouch(this, event)) { 
            // 當前控件是可用(enabled)的并且View調用了setOnTouchListener()方法且返回了true，那么就設置result為true 
            result = true; 
        } 
        // result為false，表示沒有調用setOnTouchListener()方法或該方法返回false，那么就調用 
        // View的onTouchEvent()方法 
        if (!result && onTouchEvent(event)) { 
            result = true; 
        } 
    } 
    if (!result && mInputEventConsistencyVerifier != null) { 
        mInputEventConsistencyVerifier.onUnhandledEvent(event, 0); 
    } 
    // 如果是UP事件或CANCEL事件或者是DOWN事件但是該控件不能消費事件時，重置狀態 
    if (actionMasked == MotionEvent.ACTION_UP || 
            actionMasked == MotionEvent.ACTION_CANCEL || 
            (actionMasked == MotionEvent.ACTION_DOWN && !result)) { 
        stopNestedScroll(); 
    } 
    return result; 
}

最后查看View的onTouchEvent()方法：

public boolean onTouchEvent(MotionEvent event) { 
    final float x = event.getX(); 
    final float y = event.getY(); 
    final int viewFlags = mViewFlags; 
    final int action = event.getAction(); 
    // 判斷是否有單擊或長按事件 
    final boolean clickable = ((viewFlags & CLICKABLE) == CLICKABLE 
            || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE) 
            || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE; 
    if ((viewFlags & ENABLED_MASK) == DISABLED) { 
        if (action == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) { 
            setPressed(false); 
        } 
        mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN; 
        // 控件disabled 了，他還能消耗觸摸事件，只是不相應她了 
        return clickable; 
    } 
    // 如果有代理，調用代理的方法 
    if (mTouchDelegate != null) { 
        if (mTouchDelegate.onTouchEvent(event)) { 
            return true; 
        } 
    } 
    // 對點擊事件的具體處理，只要有點擊事件，那么onTouchEvent()方法就返回了 true 
    if (clickable || (viewFlags & TOOLTIP) == TOOLTIP) { 
        switch (action) { 
            case MotionEvent.ACTION_UP: 
                // ... 
                    // mHasPerformedLongPress 表示長按事件的返回值，如果長按事件的的回調方法返回了true，那么在同一事件序列中，點擊事件就不會調用了（否則會同時相應長按事件和點擊事件） 
                    if (!mHasPerformedLongPress && !mIgnoreNextUpEvent) { 
                        // 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)) { 
                                performClickInternal(); // 會調用 performClick()方法處理單擊事件 
                            } 
                        } 
                    } 
                    if (mUnsetPressedState == null) { 
                        mUnsetPressedState = new UnsetPressedState(); 
                    } 
                    if (prepressed) { 
                        postDelayed(mUnsetPressedState, 
                                ViewConfiguration.getPressedStateDuration()); 
                    } else if (!post(mUnsetPressedState)) { 
                        // If the post failed, unpress right now 
                        mUnsetPressedState.run(); 
                    } 
                    removeTapCallback(); 
                } 
                mIgnoreNextUpEvent = false; 
                break; 
            case MotionEvent.ACTION_DOWN: 
                if (event.getSource() == InputDevice.SOURCE_TOUCHSCREEN) { 
                    mPrivateFlags3 |= PFLAG3_FINGER_DOWN; 
                } 
                mHasPerformedLongPress = false; 
                if (!clickable) { 
                    checkForLongClick(0, x, y); 
                    break; 
                } 
                if (performButtonActionOnTouchDown(event)) { 
                    break; 
                } 
                // Walk up the hierarchy to determine if we're inside a scrolling container. 
                boolean isInScrollingContainer = isInScrollingContainer(); 
                // 根據是否在滾動容器中，使用不同方式調用長按事件的回調 
                if (isInScrollingContainer) { 
                    mPrivateFlags |= PFLAG_PREPRESSED; 
                    if (mPendingCheckForTap == null) { 
                        mPendingCheckForTap = new CheckForTap(); // 最終調用長按事件回調 
                    } 
                    mPendingCheckForTap.x = event.getX(); 
                    mPendingCheckForTap.y = event.getY(); 
                    postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout()); 
                } else { 
                    // Not inside a scrolling container, so show the feedback right away 
                    setPressed(true, x, y); 
                    checkForLongClick(0, x, y); // 最終調用長按事件回調 
                } 
                break; 
            case MotionEvent.ACTION_CANCEL: 
                // ... 
                break; 
        } 
        // 只要有點擊事件，那么onTouchEvent()方法就返回了 true 
        return true; 
    } 
    return false; 
}

從上面的代碼來看，只要View的 CLICLABLE和LONG_CLICKABLE有一個為true，那么onTouchEvent()方法就會返回true，而且不管該View是否為DISABLE狀態，其他情況返回false。true表示該控件可以消費事件，false表示該控件不能消費事件。現在，在回過頭來看一下第一張圖，是不是更加的清晰了呢。

5、最后，對于View 的 CLICKABLE 和 LONG_CLICKABLE默認值，LONG_CLICKABLE默認值為false，但是對于CLICKABLE就要根據具體的View來看了，確切的說是可點擊的View的CLICKABLE值為true，如Button，不可點擊的View的CLICKABLE值為false，比如TextView，但是當我們調用了View的 setOnClickListener(@Nullable OnClickListener l) 方法或者 setOnLongClickListener(@Nullable OnLongClickListener l) 方法就會將對應的值改為true。

public void setOnClickListener(@Nullable OnClickListener l) { 
    if (!isClickable()) { 
        setClickable(true); 
    } 
    getListenerInfo().mOnClickListener = l; 
} 
public void setOnLongClickListener(@Nullable OnLongClickListener l) { 
    if (!isLongClickable()) { 
        setLongClickable(true); 
    } 
    getListenerInfo().mOnLongClickListener = l; 
}

總結

對于ViewGroup和View的disatchTouchEvent()和onTouchEvent()方法，return true表示處理事件，事件終結;return false表示不處理事件，讓事件回傳到上一層的onTouchEvent()方法中，也就是父控件中的onTouchEvent()方法中;
對于Activity的disatchTouchEvent()方法，如果沒有重寫，就會通過調用ViewGroup的disatchTouchEvent()方法開始分發事件，如果重寫了，那么不管返回true還是false都會消費事件，不在將事件往下分發;
對于dispatchTouchEvent()方法，如果開發者不重寫，就會走系統中的默認實現，在ViewGroup中會調用ViewGroup的onInterceptTouchEvent()方法，而在View中會直接把事件分發給View的onTouchEvent()方法處理;
對于ViewGroup而言，如果ViewGroup要自己處理事件，需要重寫onInterceptTouchEvent()方法并且返回true，這樣才會終止事件的傳遞，并調用ViewGroup的onTouchEvent()方法處理事件，否則調用系統onInterceptTouchEvent()方法，系統默認的返回值是false，不處理事件將事件傳遞下去;
對于View而言，在View中是沒有onInterceptTouchEvent()方法的，因為他沒有孩子控件，不需要攔截，系統在dispatchTouchEvent()方法中默認會把事件分發給View的onTouchEvent()方法處理;
在Android中，最開始獲取到事件的是Activity，然后由Activity的dispatchTouchEvent()方法開始分發事件;
如果一個事件由Activity開始下發，但是所有的控件都不處理事件，最終就會回到Activity的onTouchEvent()方法，如果Activity也不消費事件，那么這個事件就丟失了。

責任編輯：武曉燕來源： Android開發編程

成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看