Android Touch事件分發超詳細解析（附源碼）

時間 2019-11-30

標籤 android touch 事件分發詳細解析源碼欄目 Android 简体版

原文原文鏈接

1.基礎概念

1.1 touch事件定義

什麼是Touch事件？java

一個Touch事件在用戶點擊屏幕（ACTION_DOWN）時產生，擡起手指（ACTION_UP）時結束，而Touch事件又被封裝到MotionEvent當中。安全

1.2 事件分類

Touch事件整體能夠分爲如下幾類。bash

事件類型	說明
ACTION_DOWN	手指按下
ACTION_UP	手指擡起
ACTION_MOVE	手勢移動
ACTION_POINTER_DOWN	多個手指按下
ACTION_POINTER_UP	多個手指擡起
ACTION_CANCEL	取消事件

獲取Action最多見的方式就是使用MotionEvent的getAction()方法，getAction()方法能夠獲ACTION_DONW、ACTION_UP、ACTION_MOVE、以及ACTION_CANCEL等事件，咱們分析事件傳遞時基本也是分析這些事件。app

ACTION_POINTER_DOWN和ACTION_POINTER_UP，則得和ACTION_MASK相與才能獲得。ide

1.3 事件順序

從事件定義也能夠知道，一個事件老是以ACTION_DOWN做爲開始，在手勢移動過程當中會重複產生多個ACTION_MOVE事件，用戶操做結束事件的標誌爲ACTION_UP，而意外終止事件則會觸發ACTION_CANCEL。函數

1.4 事件傳遞層級

事件傳遞時，老是會從最下層開始向上層傳遞，也就是說出發點爲Activity,逐層向上傳遞。當上層View響應事件後，下層的View將再也不會再響應。在後面的代碼中咱們會分析爲何會是這種現象。源碼分析

作完準備工做後開始正式對事件傳遞流程進行分析，先分析最上層的View如何處理事件。佈局

2. View的事件分發

2.1 實例分析

咱們先看一下在咱們的代碼中事件會如何執行。自定義一個TestViewpost

public class TestView extends View {

    public TestView(Context context) {
        super(context);
    }

    public TestView(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
    }

    public TestView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        Log.d("test", "View onTouchEvent"+ event.getAction());
        return super.onTouchEvent(event);
    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent event) {
        Log.d("test", "View dispatchTouchEvent"+ event.getAction() );
        return super.dispatchTouchEvent(event);
    }
    
}
複製代碼

在自定義View當中存在兩個事件分發相關方法onTouchEvent以及dispatchTouchEvent,咱們先關注一下現象，後文經過源碼分析他們兩個的關係。測試

在XML代碼中對TestView進行引用，這一步很簡單，只是簡單地引用就不貼代碼了。在Activity當中爲TestView定義事件。

public class MainActivity extends AppCompatActivity implements View.OnTouchListener {

    private TestView testView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        testView2 = (TestView2) findViewById(R.id.testView2);
        View rootview = button.getRootView();
        testView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.d("test", "onClick" + "------" + v);
            }
        });
        testView.setOnTouchListener(this);
    }

    @Override
    public boolean onTouch(View v, MotionEvent event) {
        Log.d("test", "-----onTouch------" + event.getAction() + "------" + v);
        return false;
    }
}

複製代碼

在Activity當中給TestView定義OnClickListener以及TochLintener。運行程序，輕輕點擊TestView看一下結果：

D/test: View dispatchTouchEvent0

D/test: -----onTouch------0------com.example.liubohua.viewtestapplication.TestView{40f09bf V.ED..C.. ........ 0,0-1080,90 #7f070071 app:id/testView}

D/test: View onTouchEvent0

D/test: View dispatchTouchEvent1

D/test: -----onTouch------1------com.example.liubohua.viewtestapplication.TestView{40f09bf V.ED..C.. ...P.... 0,0-1080,90 #7f070071 app:id/testView}

D/test: View onTouchEvent1

D/test: onClick------com.example.liubohua.viewtestapplication.TestView{40f09bf V.ED..C.. ...P.... 0,0-1080,90 #7f070071 app:id/testView}

咱們在代碼中是直接把Action打印的，在輸出日誌中變成了0，1，這也對應咱們的ACTION_DOWN和ACTION_UP兩個事件.咱們以一種Action爲一組分析整個事件調用流程。

第一組Action=0：ACTION_DOWN事件，從輸出結果能夠看出，執行順序爲了dispatchTouchEvent->onTouch->onTouchEvent。
第二組Action=1：ACTION_UP事件，執行順序與以前相同，可是在末尾多了一個onClick方法，這是爲何呢？接下來稍微修改一下咱們測試代碼。修改OnToUch方法返回值爲true.

@Override
    public boolean onTouch(View v, MotionEvent event) {
        Log.d("test", "-----onTouch------" + event.getAction() + "------" + v);
        return false;  ------>return true;
    }                       
    
複製代碼

在看輸出的結果：

D/test: View dispatchTouchEvent0

D/test: -----onTouch------0------com.example.liubohua.viewtestapplication.TestView{40f09bf V.ED..C.. ........ 0,0-1080,90 #7f070071 app:id/testView}

D/test: View dispatchTouchEvent2

D/test: -----onTouch------2------com.example.liubohua.viewtestapplication.TestView{40f09bf V.ED..C.. ........ 0,0-1080,90 #7f070071 app:id/testView}

D/test: View dispatchTouchEvent1

D/test: -----onTouch------1------com.example.liubohua.viewtestapplication.TestView{40f09bf V.ED..C.. ........ 0,0-1080,90 #7f070071 app:id/testView}

ON_DOWN和ACTION_UP兩個事件.咱們以一種Action`爲一組分析整個事件調用流程。

第一組Action=0：ACTION_DOWN事件，從輸出結果能夠看出，執行順序爲了dispatchTouchEvent->onTouch接結束了，後面的onTouchEvent沒有再執行。
第二組Action=2：ACTION_MOVE事件，與ACTION_DOWN事件事件的執行順序相同。
第二組Action=1：ACTION_UP事件，與ACTION_DOWN事件事件的執行順序相同。再改一改，撤回以前對OnTouch的操做，仍是讓onTouch返回false,而後修改onTouchEvent的返回值爲false。

@Override
    public boolean onTouchEvent(MotionEvent event) {
        " "     ------->super.onTouchEvent(event);
        Log.d("test", "View onTouchEvent"+ event.getAction());
        return super.onTouchEvent(event);------->return fasle;
    }
複製代碼

再來看一下輸出結果：

D/test: View dispatchTouchEvent0

D/test: -----onTouch------0------com.example.liubohua.viewtestapplication.TestView{40f09bf V.ED..C.. ........ 0,0-1080,90 #7f070071 app:id/testView}

D/test: View onTouchEvent0

執行順序變成dispatchTouchEvent->onTouch->onTouchEvent，可是整個事件分發過程當中，只剩下了ACTION_DOWN這一種事件，只輸出了Action=0的狀況，也就是ACTION_DOWN以後的事件都再也不響應，怎麼回事呢。

2.2 View源碼分析

2.2.1 dispatchTouchEvent

從上面的實例來看，dispatchTouchEvent毫無疑問就是我整個事件分發的入口了，咱們從這裏入手。話很少說上源碼。

//返回結果定義在方法內部變量result當中，當result返回true時，表示事件被消費，再也不繼續向下分發，爲false時繼續向下分發
 public boolean dispatchTouchEvent(MotionEvent event) {
    if (event.isTargetAccessibilityFocus()) {
        if (!isAccessibilityFocusedViewOrHost()) {
            return false;
        }
        // 事件能夠被關注並正常分發
        event.setTargetAccessibilityFocus(false);
    }
    //result用來存儲函數最後的返回結果。
    boolean result = false;

    if (mInputEventConsistencyVerifier != null) {
        mInputEventConsistencyVerifier.onTouchEvent(event, 0);
    }

    //當actionMasked == MotionEvent.ACTION_DOWN中止滑動事件
    final int actionMasked = event.getActionMasked();
    if (actionMasked == MotionEvent.ACTION_DOWN) {
        // Defensive cleanup for new gesture
        stopNestedScroll();
    }

    //判斷窗口window是否被遮擋，方法返回爲true，事件能夠被繼續分發，false再也不繼續分發
    if (onFilterTouchEventForSecurity(event)) {
        //View當前是否被激活，而且有滾動事件發生
        if ((mViewFlags & ENABLED_MASK) == ENABLED && handleScrollBarDragging(event)) {
            result = true;
        }
        //ListenerInfo是一個內部類，定義了一些監聽事件
        ListenerInfo li = mListenerInfo;
        //這裏的判斷條件分別爲li != nul
        //li.mOnTouchListener != null，這個li.mOnTouchListener變量就是經過setOnTouchEvent賦值的。
        //當前View是被激活的狀態
        //li.mOnTouchListener.onTouch(this, event)在咱們setOnTouchEvent內部有操做，當在這裏咱們設置View的TouchEvent事件，當返回爲true時，reslult=true表示消耗這個事件，將再也不繼續往下傳遞。
        if (li != null && li.mOnTouchListener != null
                && (mViewFlags & ENABLED_MASK) == ENABLED
                && li.mOnTouchListener.onTouch(this, event)) {
            result = true;
        }

        //當result=false纔會執行onTouchEvent(event)，這也就解釋了爲何當onTouch返回true時onTouchEvent(event)再也不執行。
        //onTouchEvent(event)也返回true時，result=true
        if (!result && onTouchEvent(event)) {
            result = true;
        }
    }

    if (!result && mInputEventConsistencyVerifier != null) {
        mInputEventConsistencyVerifier.onUnhandledEvent(event, 0);
    }

    // Clean up after nested scrolls if this is the end of a gesture;
    // also cancel it if we tried an ACTION_DOWN but we didn't want the rest // of the gesture. if (actionMasked == MotionEvent.ACTION_UP || actionMasked == MotionEvent.ACTION_CANCEL || (actionMasked == MotionEvent.ACTION_DOWN && !result)) { stopNestedScroll(); } return result; } 複製代碼

dispatchTouchEvent這個類代碼很少，結合註釋，方法內的處理主要有：

定義了result對象來記錄事件是否被消費。
拿到了View的mOnTouchListener，判斷是否爲Null，當不爲空而且onTouch事件返回true時，表明事件被消費掉。

if (li != null && li.mOnTouchListener != null
                && (mViewFlags & ENABLED_MASK) == ENABLED
                && li.mOnTouchListener.onTouch(this, event)) {
            result = true;
    }
複製代碼

在下面的代碼中，當result=false纔會執行onTouchEvent，這也就解釋了我把OnTouch返回值置爲true時，onTouchEvent(event)將再也不執行，由於這個時候result=true，而if(A&&B)當中，只有在A成立的狀況下才會執行B，在這裏!result顯然不成立，因此onTouchEvent(event)也就不會執行。

if (!result && onTouchEvent(event)) {
                result = true;
    }
複製代碼

當 onTouchEvent(event)返回false時，result也就返回false了，這個時候就表明dispatchEvent沒有消費事件，後續的Action也就不會再執行了。

分析到這裏，dispatchTouchEvent、OnTouch和OnTouchEevent的調用關係應該是清楚了，咱們來總結一下：

dispatchTouchEvent做爲事件分發的入口，在任什麼時候候都會優先執行，在dispatchTouchEvent函數內部調用了onTouch和OnTouchEvent方法。

當onTouch返回True時，dispatchTouchEvent返回值也爲True，OnTouchEvent方法將再也不執行。

當onTouch返回False時，會執行OnTouchEvent方法，而OnTouchEvent方法的返回值也就決定了dispatchTouchEvent的返回值

當dispatchTouchEvent返回true時表示消費事件，後續的事件將繼續響應；當dispatchTouchEvent返回Fasle是表示不消費事件，不會再響應後續事件。

2.2.2 onTouchEvent

分析了半天，咱們最經常使用的setOnCLickListener怎麼沒有出現呢，何時會執行onClick方法。咱們接着看OnTouchEvent的代碼：

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();

    //當前視圖是否可被執行點擊、長按等操做
    //可經過java代碼或者xml代碼設置enable狀態或者clickable狀態。
    //當這些狀態爲false時，則clickable = false，不然爲true。
    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;
    //一個已經銷燬的視圖，被點擊時依舊消費事件，只是不能響應事件
        return clickable;
    }
    if (mTouchDelegate != null) {
        if (mTouchDelegate.onTouchEvent(event)) {
            return true;
        }
    }

    if (clickable || (viewFlags & TOOLTIP) == TOOLTIP) {
        switch (action) {
            case MotionEvent.ACTION_UP:
                mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
                if ((viewFlags & TOOLTIP) == TOOLTIP) {
                    handleTooltipUp();
                }
                 //判斷是否可點擊
                if (!clickable) {
                    removeTapCallback();
                    removeLongPressCallback();
                    mInContextButtonPress = false;
                    mHasPerformedLongPress = false;
                    mIgnoreNextUpEvent = false;
                    break;
                }
                boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
                if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {
                    // 判斷是否能夠獲取焦點，若是能夠，則獲取焦點
                    boolean focusTaken = false;
                    if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {
                        focusTaken = requestFocus();
                    }

                    if (prepressed) {
                        // The button is being released before we actually
                        // showed it as pressed.  Make it show the pressed
                        // state now (before scheduling the click) to ensure
                        // the user sees it.
                        setPressed(true, x, y);
                    }


                    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();
                            }
                            //最終ACTION_UP要執行的方法，post到UI Thread的中的一個Runnable，若是不存在message queue，則直接執行performClick();
                            if (!post(mPerformClick)) {
                                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;
                }

                // 判斷當前view是不是在滾動器當中
                boolean isInScrollingContainer = isInScrollingContainer();

               //若是是在滾動器當中，在滾動器當中的話延遲返回事件，延遲時間爲 ViewConfiguration.getTapTimeout()=100毫秒
                if (isInScrollingContainer) {
                    mPrivateFlags |= PFLAG_PREPRESSED;
                    if (mPendingCheckForTap == null) {
                        mPendingCheckForTap = new CheckForTap();
                    }
                    mPendingCheckForTap.x = event.getX();
                    mPendingCheckForTap.y = event.getY();
                    postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
                } else {
                    // 不在滾動器當中則當即作出響應
                    setPressed(true, x, y);
                    checkForLongClick(0, x, y);
                }
                break;

            case MotionEvent.ACTION_CANCEL:
                if (clickable) {
                    setPressed(false);
                }
                removeTapCallback();
                removeLongPressCallback();
                mInContextButtonPress = false;
                mHasPerformedLongPress = false;
                mIgnoreNextUpEvent = false;
                mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
                break;

            case MotionEvent.ACTION_MOVE:
                if (clickable) {
                    drawableHotspotChanged(x, y);
                }

                // 判斷當前滑動事件是否還在當前view當中
                if (!pointInView(x, y, mTouchSlop)) {
                    // 若是超出view，則取消所事件
                    removeTapCallback();
                    removeLongPressCallback();
                    if ((mPrivateFlags & PFLAG_PRESSED) != 0) {
                        setPressed(false);
                    }
                    mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
                }
                break;
        }

        return true;
    }

    return false;
}
複製代碼

onTouchEvent裏面作的事情也很少，主要是分類處理各個不一樣的Action事件，仍是結合註釋，咱們分析一下大概流程：

在程序的入口處咱們初始化了一個clickable的變量，這個變量在View包括繼承自View的自定義View當中默認是fasle的，可是在Button、TextView當中默認就是true。當咱們設置了setOnClickListener時會也會執行clickable=true。以後即是對不一樣Action的處理。

final boolean clickable = ((viewFlags & CLICKABLE) == CLICKABLE
                || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
                || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE;
複製代碼

從上面事件的觸發流程能夠知道，第一個事件必定會是ACTION_DOWN。這一部分主要是判斷是否在滾動器中，當在滾動器中會有100毫秒的延遲響應，用來判斷是否要響應事件。再也不滾動器則直接響應事件。
ACTION_MOVE只是作了處理響應事件的操做。
最終action = MotionEvent.ACTION_UP執行的是performClick()方法，再來看一下這個方法

public boolean performClick() {
    final boolean result;
    final ListenerInfo li = mListenerInfo;
    if (li != null && li.mOnClickListener != null) {
        playSoundEffect(SoundEffectConstants.CLICK);
        //這裏實際上就是調用了咱們的setOnClickListerner.onClick()方法
        li.mOnClickListener.onClick(this);
        result = true;
    } else {
        result = false;
    }
    sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);

    notifyEnterOrExitForAutoFillIfNeeded(true);

    return result;
}

複製代碼

看到這裏咱們知道setOnClickListener方法在調用到action = MotionEvent.ACTION_UP方法以後纔會執行。這也就解釋了爲何在上面的實例當中onClick方法老是在最後執行，而當TouchEvent返回false以後setOnClickListener方法則不會再執行。由於這時候TouchEvent只會響應MotionEvent.ACTION_DOWN事件，而setOnClickListener是在View響應MotionEvent.ACTION_UP事件以後才執行。

2.3 View 事件分發流程圖

3 ViewGroup事件分發

3.1 實例分析

與測試View時的基本流程同樣，咱們自定義一個TestLayout用來輸出事件的調用順序，具體代碼以下：

public class TestLayout extends LinearLayout {
    public TestLayout(Context context) {
        super(context);
    }

    public TestLayout(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
    }

    public TestLayout(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }


    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        Log.d("test", "TestLayout onInterceptTouchEvent-- action=" + ev.getAction());
        return super.onInterceptTouchEvent(ev);
    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent event) {
        Log.d("test","TestLayout dispatchTouchEvent-- action=" + event.getAction());
        return super.dispatchTouchEvent(event);
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        Log.d("test","TestLayout onTouchEvent-- action=" + event.getAction());
        return super.onTouchEvent(event);
    }
}
複製代碼

由於LinearLayout是直接繼承自ViewGroup的，因此爲了佈局方便這裏咱們的自定義TestView選擇繼承LinearLayout。

在ViewGroup當中涉及到事件分發的方法,相比View來講除了dispatchTouchEvent和onTouchEvent外還有onInterceptTouchEvent。爲了測試方便，咱們把TestView的代碼改成最開始的樣子：

TestView

public class TestView extends View {

    public TestView(Context context) {
        super(context);
    }

    public TestView(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
    }

    public TestView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        Log.d("test", "View onTouchEvent"+ event.getAction());
        return super.onTouchEvent(event);
    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent event) {
        Log.d("test", "View dispatchTouchEvent"+ event.getAction() );
        return super.dispatchTouchEvent(event);
    }

}
複製代碼

XML依然只是引入最簡單的佈局，這裏省略掉，看一下Activity當中的設置：

public class MainActivity extends AppCompatActivity implements View.OnTouchListener {

    private TestView testView;
    private TestLayout testLayout;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        testView = (TestView) findViewById(R.id.testView);
        testLayout = (TestLayout) findViewById(R.id.test_layout);
        testLayout.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.d("test", "TestLayout onClick" + "------" + v);
            }
        });
        testView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.d("test", "onClick" + "------" + v);
            }
        });
        testLayout.setOnTouchListener(this);
        testView.setOnTouchListener(this);

    }

    @Override
    public boolean onTouch(View v, MotionEvent event) {
        Log.d("test", "-----onTouch------" + event.getAction() + "------" + v);
        return false;
    }
}
複製代碼

運行程序，點擊TestView所在區域，看一下輸出的結果：

D/test: TestLayout dispatchTouchEvent-- action=0

D/test: TestLayout onInterceptTouchEvent-- action=0

D/test: View dispatchTouchEvent0

D/test: -----onTouch------0------com.example.liubohua.viewtestapplication.TestView{40f09bf V.ED..C.. ........ 0,0-1080,90 #7f070071 app:id/testView}

D/test: View onTouchEvent0

D/test: TestLayout dispatchTouchEvent-- action=2

D/test: TestLayout onInterceptTouchEvent-- action=2

D/test: View dispatchTouchEvent2

D/test: -----onTouch------2------com.example.liubohua.viewtestapplication.TestView{40f09bf V.ED..C.. ...P.... 0,0-1080,90 #7f070071 app:id/testView}

D/test: View onTouchEvent2

D/test: TestLayout dispatchTouchEvent-- action=1

D/test: TestLayout onInterceptTouchEvent-- action=1

D/test: View dispatchTouchEvent1

D/test: -----onTouch------1------com.example.liubohua.viewtestapplication.TestView{40f09bf V.ED..C.. ...P.... 0,0-1080,90 #7f070071 app:id/testView}

D/test: View onTouchEvent1

D/test: onClick------com.example.liubohua.viewtestapplication.TestView{40f09bf V.ED..C.. ...P.... 0,0-1080,90 #7f070071 app:id/testView}

輸出的日誌有點多，咱們以一個Action爲一組進行分析，以前咱們也說過，一個Action表明一類的Touch事件。

第一租Action=0：ACTION_DOIWN事件，先執行了dispatchTouchEvent，而後是onInterceptTouchEvent，這兩個都是TestLayout的方法,以後的事件被傳遞到了TestView當中，按照咱們以前說的順序dispatchTouchEvent->onTouch->onTouchEvent進行事件分發。
第二組Action=2：ACTION_MOVE事件，與第一組的時間順序相同。
第三組Action=1：ACTION_UP事件，與上述步驟基本相同，可是在輸出末尾執行了View的onClick事件，這就與咱們以前分析的View當中的事件分發機制不謀而合。

咱們以前說ViewGroup的事件分發與dispatchTouchEvent、onTouchEvent、onInterceptTouchEvent三個方法有關，可是從這個例子當中咱們發現所執行的方法只有dispatchTouchEvent和onInterceptTouchEvent，那麼onTouchEvent在何時執行呢？咱們設置的OnTouch方法以及OnClick方法在何時調用呢？

帶着疑問咱們點擊一下TestView之外的區域,再查看輸出日誌:

D/test: TestLayout dispatchTouchEvent-- action=0

D/test: TestLayout onInterceptTouchEvent-- action=0

D/test: -----onTouch------0------com.example.liubohua.viewtestapplication.TestLayout{15fd3de V.E...C.. ........ 0,0-1080,1680 #7f070074 app:id/test_layout}

D/test: TestLayout onTouchEvent-- action=0

D/test: TestLayout dispatchTouchEvent-- action=2

D/test: -----onTouch------2------com.example.liubohua.viewtestapplication.TestLayout{15fd3de V.E...C.. ...P.... 0,0-1080,1680 #7f070074 app:id/test_layout}

D/test: TestLayout onTouchEvent-- action=2

D/test: TestLayout dispatchTouchEvent-- action=1

D/test: -----onTouch------1------com.example.liubohua.viewtestapplication.TestLayout{15fd3de V.E...C.. ...P.... 0,0-1080,1680 #7f070074 app:id/test_layout}

D/test: TestLayout onTouchEvent-- action=1

D/test: TestLayout onClick------com.example.liubohua.viewtestapplication.TestLayout{15fd3de V.E...C.. ...P.... 0,0-1080,1680 #7f070074 app:id/test_layout}

一樣的仍是以不一樣的Action來分組分析：

第一租Action=0：ACTION_DOIWN事件，執行順序爲dispatchTouchEvent->onInterceptTouchEvent->onTouch->onTouchEvent，並且四個方法所有都是TestLayout內的方法輸出，沒有了View的參與瞬間清爽了不少。
第二組Action=2：ACTION_MOVE事件，執行順序爲dispatchTouchEvent->onTouch->onTouchEvent，到了這裏onInterceptTouchEvent方法又不見了。
第三組Action=1：ACTION_UP事件，這裏就更過度了，執行的流程當中不只沒有了onInterceptTouchEvent方法，在輸出末尾還讀了TestLayOut的onClick事件，這麼任性究竟是要鬧哪樣。

我再看到這裏的時候也是一頭霧水，這事件執行的還真是隨意，一會一個樣子。沒辦法仍是去源碼裏面找答案吧。

3.2 ViewGroup源碼分析

與View同樣，整個事件分發的入口依然是dispatchTouchEvent，咱們從這裏入手。

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    if (mInputEventConsistencyVerifier != null) {
        mInputEventConsistencyVerifier.onTouchEvent(ev, 1);
    }

    // 若是事件指向了一個可達的視圖，則事件正常調度分發。
    if (ev.isTargetAccessibilityFocus() && isAccessibilityFocusedViewOrHost()) {
        ev.setTargetAccessibilityFocus(false);
    }

    boolean handled = false;
    //進行安全策略檢查，返回true正常進行下一步操做
    if (onFilterTouchEventForSecurity(ev)) {
        final int action = ev.getAction();
        final int actionMasked = action & MotionEvent.ACTION_MASK;

        //當action爲MotionEvent.ACTION_DOWN時作一些初始化操做
        if (actionMasked == MotionEvent.ACTION_DOWN) {
           //在這裏把全部的TouchTarget置空。這裏須要說明一下，當TouchTarget不爲null時，表示已經找到可以處理touch事件的目標。
            //touchTarget是一個鏈表，用來存儲能夠用來響應事件的view
            cancelAndClearTouchTargets(ev);
            //重置了全部的TouchState
            resetTouchState();
        }

        // intercepted變量用來記錄是否須要攔截事件
        final boolean intercepted;
        //當actionMasked == MotionEvent.ACTION_DOWN或者已經找到能夠處理事件的view時知足判斷條件
        if (actionMasked == MotionEvent.ACTION_DOWN
                || mFirstTouchTarget != null) {
            //disallowIntercept爲是否開啓禁止攔截的標誌，當disallowIntercept=true時禁止攔截，不然開啓
            //調用requestDisallowInterceptTouchEvent(boolean disallowIntercept)方法能夠設置是否關閉攔截
            final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
            //判斷disallowIntercept=false，開啓攔截
            if (!disallowIntercept) {
                //執行onInterceptTouchEvent方法，也就是咱們本身定義的回調
                //默認onInterceptTouchEvent(ev)方法返回false，不攔截事件，當返回true時表示事件攔截
                intercepted = onInterceptTouchEvent(ev);
                ev.setAction(action); // restore action in case it was changed
            } else {
                //判斷disallowIntercept=true，賦值intercepted = false，表示不攔截事件
                intercepted = false;
            }
        } else {
            // 當沒有View處理事件，而且不是ACTION_DOWN時，繼續攔截。
            intercepted = true;
        }

        //如何事件被攔截，或者有View處理該事件，則正常處理。
        if (intercepted || mFirstTouchTarget != null) {
            ev.setTargetAccessibilityFocus(false);
        }

        // canceled變量初始化，
        final boolean canceled = resetCancelNextUpFlag(this)
                || actionMasked == MotionEvent.ACTION_CANCEL;

        // split變量決定是否吧事件分發給多個子View，能夠經過setMotionEventSplittingEnabled(boolean split)方法進行設置
        final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0;
        TouchTarget newTouchTarget = null;
        boolean alreadyDispatchedToNewTouchTarget = false;
        //沒有取消而且沒有攔截事件時進入判斷
        if (!canceled && !intercepted) {
        //查找優先處理action的view，
        //在View當中能夠經過getRootView().getParent().requestSendAccessibilityEvent(View child, AccessibilityEvent event));方法進行設置
            View childWithAccessibilityFocus = ev.isTargetAccessibilityFocus()
                    ? findChildWithAccessibilityFocus() : null;
            //不知足條件時表示不須要再從新尋找響應事件的View
            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;

                // Clean up earlier touch targets for this pointer id in case they
                // have become out of sync.
                removePointersFromTouchTargets(idBitsToAssign);

                final int childrenCount = mChildrenCount;
                //判斷childrenCount是否等於0而且newTouchTarget == null
                if (newTouchTarget == null && childrenCount != 0) {
                    //獲取事件的座標值，沒有在座標內的View不須要再響應事件
                    final float x = ev.getX(actionIndex);
                    final float y = ev.getY(actionIndex);
                
                    final ArrayList<View> preorderedList = buildTouchDispatchChildList();
                    final boolean customOrder = preorderedList == null
                            && isChildrenDrawingOrderEnabled();
                    final View[] children = mChildren;
                    //倒序遍歷全部的子View，這裏採用一種倒序的方式，在java代碼中後addView或者在xml當中後添加的佈局會先被響應事件。
                    for (int i = childrenCount - 1; i >= 0; i--) {
                        final int childIndex = getAndVerifyPreorderedIndex(
                                childrenCount, i, customOrder);
                        final View child = getAndVerifyPreorderedView(
                                preorderedList, children, childIndex);
                         //若是存在優先要處理Action的View，則進行下次循環直到找到View
                        //當childWithAccessibilityFocus=null時正常分發事件到每個View
                        if (childWithAccessibilityFocus != null) {
                            if (childWithAccessibilityFocus != child) {
                                continue;
                            }
                            childWithAccessibilityFocus = null;
                            i = childrenCount - 1;
                        }
                        //若是當前點擊的位置沒有被子View佔據，則直接進入下一次循環
                        if (!canViewReceivePointerEvents(child)
                                || !isTransformedTouchPointInView(x, y, child, null)) {
                            ev.setTargetAccessibilityFocus(false);
                            continue;
                        }
                        //在TouchTarget當中在此尋找該View，若是找到了直接退出循環，沒有找到則繼續向下執行
                        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.
                            newTouchTarget.pointerIdBits |= idBitsToAssign;
                            break;
                        }

                        //遞歸的方式在子View的dispatchTouchEvent方法，尋找能夠響應action的View，當返回爲True時，進入循環，表示找到能夠響應的View。
                        resetCancelNextUpFlag(child);
                        if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
                            // Child wants to receive touch within its bounds.
                            mLastTouchDownTime = ev.getDownTime();
                            if (preorderedList != null) {
                                // childIndex points into presorted list, find original index
                                for (int j = 0; j < childrenCount; j++) {
                                    if (children[childIndex] == mChildren[j]) {
                                        mLastTouchDownIndex = j;
                                        break;
                                    }
                                }
                            } else {
                                mLastTouchDownIndex = childIndex;
                            }
                            mLastTouchDownX = ev.getX();
                            mLastTouchDownY = ev.getY();
                            //將找到的View加入到TouchTarget當中
                            newTouchTarget = addTouchTarget(child, idBitsToAssign);
                            alreadyDispatchedToNewTouchTarget = true;
                            //找到View 跳出循環
                            break;
                        }

                        // The accessibility focus didn't handle the event, so clear // the flag and do a normal dispatch to all children. ev.setTargetAccessibilityFocus(false); } if (preorderedList != null) preorderedList.clear(); } //當不能再找到能夠響應action的子View時，將TouchTarget鏈表指到最初找到的View 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; } } } //當沒有View消費事件時，mFirstTouchTarget == null if (mFirstTouchTarget == null) { // 這裏調用dispatchTransformedTouchEvent，其實也就是調用ViewGroup自身TouchEvent事件 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; while (target != null) { final TouchTarget next = target.next; //alreadyDispatchedToNewTouchTarget=true表示在上面遍歷View的過程當中已經消費了事件 if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) { handled = true; } else { //調用子View的dispatchOnTouchEvent進行事件處理 final boolean cancelChild = resetCancelNextUpFlag(target.child) || intercepted; if (dispatchTransformedTouchEvent(ev, cancelChild, target.child, target.pointerIdBits)) { handled = true; } if (cancelChild) { if (predecessor == null) { mFirstTouchTarget = next; } else { predecessor.next = next; } target.recycle(); target = next; 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) { final int actionIndex = ev.getActionIndex(); final int idBitsToRemove = 1 << ev.getPointerId(actionIndex); removePointersFromTouchTargets(idBitsToRemove); } } if (!handled && mInputEventConsistencyVerifier != null) { mInputEventConsistencyVerifier.onUnhandledEvent(ev, 1); } return handled; } 複製代碼

整個代碼有點多，有興趣的能夠逐行分析。這裏咱們挑出重點步驟分析一下。

首先是初始化的部分，初始化是在ACTION_DOWN產生時發生的。這裏有一個很是重要的操做就是把touchTarget是鏈表置空。

touchTarget鏈表自己是用來存儲在一次分發過程當中可響應事件的View的鏈表，每一次ACTION_DOWN產生事件產生，都表明一個新的事件開始，這個時候清空touchTarget從新尋找能夠響應的View，一旦找到能夠相應的View，就存儲進來，在後續的ACTION_MOVE等事件發生時，直接在touchTarget鏈表中尋找事件的消費者。

//當action爲MotionEvent.ACTION_DOWN時作一些初始化操做
        if (actionMasked == MotionEvent.ACTION_DOWN) {
           //在這裏把全部的TouchTarget置空。這裏須要說明一下，當TouchTarget不爲null時，表示已經找到可以處理touch事件的目標。
            //touchTarget是一個鏈表，用來存儲能夠用來響應事件的view
            cancelAndClearTouchTargets(ev);
            //重置了全部的TouchState
            resetTouchState();
        }
複製代碼

初始化以後是對攔截器的判斷，onInterceptTouchEvent的執行與否就和這裏密切相關。

首先初始化了一個標誌位disallowIntercept，這個標誌位用來標記時候禁用攔截器，在咱們的代碼中能夠經過requestDisallowInterceptTouchEvent(boolean disallowIntercept)方法來對disallowIntercept的值進行設置。

當disallowIntercept=false時表示不由用攔截器，正常執行onInterceptTouchEvent(ev);方法，而且將該方法的返回值返回給intercepted變量用來標誌是否攔截事件。

當disallowIntercept=true時表示禁用攔截器，執行intercepted = false;也就是對事件不進行攔截。

這裏也就解釋了爲何點擊ViewGroup空白處時onInterceptTouchEvent(ev)只調用一次了

//intercepted變量用來記錄是否須要攔截事件
        final boolean intercepted;
        //當actionMasked == MotionEvent.ACTION_DOWN或者已經找到能夠處理事件的view時知足判斷條件
        if (actionMasked == MotionEvent.ACTION_DOWN
                || mFirstTouchTarget != null) {
            //disallowIntercept爲是否開啓禁止攔截的標誌，當disallowIntercept=true時禁止攔截，不然開啓
            //調用requestDisallowInterceptTouchEvent(boolean disallowIntercept)方法能夠設置是否關閉攔截
            final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
            //判斷disallowIntercept=false，開啓攔截
            if (!disallowIntercept) {
                //執行onInterceptTouchEvent方法，也就是咱們本身定義的回調
                //默認onInterceptTouchEvent(ev)方法返回false，不攔截事件，當返回true時表示事件攔截
                intercepted = onInterceptTouchEvent(ev);
                ev.setAction(action); // restore action in case it was changed
            } else {
                //判斷disallowIntercept=true，賦值intercepted = false，表示不攔截事件
                intercepted = false;
            }
        } else {
            // 當沒有View處理事件，而且不是ACTION_DOWN時，繼續攔截。
            intercepted = true;
        }
複製代碼

接下來會對子View進行遍歷，這裏採用一個倒序遍歷的方式，在java代碼中後addView或者在xml當中後添加的佈局會先被響應事件，這也符合咱們的視圖邏輯，在最上層的View應該最優先響應事件。

for (int i = childrenCount - 1; i >= 0; i--) {
        final int childIndex = getAndVerifyPreorderedIndex(
                                    childrenCount, i, customOrder);
        final View child = getAndVerifyPreorderedView(
                                    preorderedList, children, childIndex);
複製代碼

再往下執行，有一個判斷語句if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign))當它返回true時表明找到了能夠響應事件的View，返回Fasle表示沒有找到。

dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)方法中有個重要的參數child，當child！=null時，調用了子View的dispatchTouchEvent方法判斷是否對事件進行響應。若是child==null，則調用super.dispatchTouchEvent(event);也就是View的dispatchTouchEvent(event);方法進行處理。

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

        // Canceling motions is a special case.  We don't need to perform any transformations // or filtering. The important part is the action, not the contents. final int oldAction = event.getAction(); if (cancel || oldAction == MotionEvent.ACTION_CANCEL) { event.setAction(MotionEvent.ACTION_CANCEL); if (child == null) { handled = super.dispatchTouchEvent(event); } else { handled = child.dispatchTouchEvent(event); } event.setAction(oldAction); return handled; } } 複製代碼

當找到能夠響應事件的View時進入判斷，最終經過newTouchTarget = addTouchTarget(child, idBitsToAssign);方法將子View添加到鏈表TouchTarget當中。

在最後一部分的代碼裏決定了具體後續將如何響應事件。

前面咱們分析過複合條件的View都會被存儲到mFirstTouchTarget所對應的鏈表當中，當mFirstTouchTarget == null時就須要ViewGroup本身處理事件，這個時候一樣調用dispatchTransformedTouchEvent方法，可是chlid參數傳參爲null，上面咱們也分析過，會調用View的dispatchTouchEvent(event)方法。

當mFirstTouchTarget != null表示存在能夠響應事件的子View，一樣也是調用dispatchTransformedTouchEvent方法，可是chlid參數傳參爲則傳入可實際響應事件的View。

//當沒有View消費事件時，mFirstTouchTarget == null
        if (mFirstTouchTarget == null) {
            // 這裏調用dispatchTransformedTouchEvent，其實也就是調用ViewGroup自身TouchEvent事件
            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;
            while (target != null) {
                final TouchTarget next = target.next;
                //alreadyDispatchedToNewTouchTarget=true表示在上面遍歷View的過程當中已經消費了事件
                if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
                    handled = true;
                } else {
                    //調用子View的dispatchOnTouchEvent進行事件處理
                    final boolean cancelChild = resetCancelNextUpFlag(target.child)
                            || intercepted;
                    if (dispatchTransformedTouchEvent(ev, cancelChild,
                            target.child, target.pointerIdBits)) {
                        handled = true;
                    }
                    if (cancelChild) {
                        if (predecessor == null) {
                            mFirstTouchTarget = next;
                        } else {
                            predecessor.next = next;
                        }
                        target.recycle();
                        target = next;
                        continue;
                    }
                }
                predecessor = target;
                target = next;
            }
        }
複製代碼

分析到這裏ViewGroup的事件分發也基本完成了。這裏沒有再分析onTouchEevent和onTouch方法，這兩個方法和View當中的處理並無區別。

3.3 ViewGroup事件分發流程圖

事件分發到這裏就結束了?在咱們的本身的佈局當中看是這樣的，可是除了在咱們XML中定義的佈局以外，Android視圖還有默認的Activity層級。

4. Activity事件分發

4.1 實例分析

以前的佈局都不變,再Activity當中作出修改：

@Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        Log.i("test", "MainActivity--dispatchTouchEvent--action=" + ev.getAction());
        return super.dispatchTouchEvent(ev);
    }

    @Override
    public void onUserInteraction() {
        Log.d("test", "MainActivity--onUserInteraction");
        super.onUserInteraction();
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        Log.d("test", "MainActivity--onTouchEvent--action=" + event.getAction());
        return super.onTouchEvent(event);
    }
複製代碼

這三個都是Activity提供的可重寫的方法，再點擊一下看看如何輸出日誌：

I/test: MainActivity--dispatchTouchEvent--action=0

D/test: MainActivity--onUserInteraction

D/test: TestLayout dispatchTouchEvent-- action=0

D/test: TestLayout onInterceptTouchEvent-- action=0false

D/test: -----onTouch------0------com.example.liubohua.viewtestapplication.TestLayout{6de08b5 V.E...C.. ........ 0,0-1920,864 #7f070074 app:id/test_layout}

D/test: TestLayout onTouchEvent-- action=0

I/test: MainActivity--dispatchTouchEvent--action=1

D/test: TestLayout dispatchTouchEvent-- action=1

D/test: -----onTouch------1------com.example.liubohua.viewtestapplication.TestLayout{6de08b5 V.E...C.. ...P.... 0,0-1920,864 #7f070074 app:id/test_layout}

D/test: TestLayout onTouchEvent-- action=1

依然是分組分析。

第一租Action=0：ACTION_DOIWN事件，先執行了Activity的dispatchTouchEvent->onUserInteraction,接着執行TestLayout的dispatchTouchEvent->onInterceptTouchEvent->onTouch->onTouchEvent。
第二組Action=1：ACTION_UP事件，先執行了Activity的dispatchTouchEvent,接着執行TestLayout的dispatchTouchEvent->onTouch->onTouchEvent。

話很少說，我們直接看源碼。

4.2 源碼分析

dispatchTouchEvent一樣仍是整個事件的入口

public boolean dispatchTouchEvent(MotionEvent ev) {
        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
            onUserInteraction();
        }
        if (getWindow().superDispatchTouchEvent(ev)) {
            return true;
        }
        return onTouchEvent(ev);
    }
複製代碼

這裏代碼不多，咱們逐行分析。

當MotionEvent.ACTION_DOWN事件產生時，就執行了onUserInteraction()，沒有任何前置條件，在一次事件流程中必定會執行且只執行一次。

public void onUserInteraction() {
    }
複製代碼

onUserInteraction()裏面沒有任何實現，這個方法提供出來就是爲用戶提供的。

接下執行getWindow，獲取到一個PhoneWindow實例，去PhoneWindow當中在看一下superDispatchTouchEvent(ev)方法都作了些什麼。

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

複製代碼

又調用了mDecor的方法，咱們再跟進去看看。

public class DecorView extends FrameLayout{
    public boolean superDispatchTouchEvent(MotionEvent event) {
        return super.dispatchTouchEvent(event);
    }
}
複製代碼

好了到這裏咱們就應明瞭了，DecorView裏面直接調用了super.dispatchTouchEvent(event)，而這個super是誰呢？就是FrameLayout，FrameLayout的dispatchTouchEvent(event)就是ViewGoup的dispatchTouchEvent(event)。