@Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        final Window.Callback cb = mWindow.getCallback();
        return cb != null && !mWindow.isDestroyed() && mFeatureId < 0
                ? cb.dispatchTouchEvent(ev) : super.dispatchTouchEvent(ev);
    }

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

public void onUserInteraction() {
}

final void attach(Context context, ActivityThread aThread,
            Instrumentation instr, IBinder token, int ident,
            Application application, Intent intent, ActivityInfo info,
            CharSequence title, Activity parent, String id,
            NonConfigurationInstances lastNonConfigurationInstances,
            Configuration config, String referrer, IVoiceInteractor voiceInteractor,
            Window window) {
            ......
            mWindow = new PhoneWindow(this, window);
            mWindow.setCallback(this);
            ......
}

//這是窗口的頂層視圖
private DecorView mDecor
@Override
    public boolean superDispatchTouchEvent(MotionEvent event) {
        return mDecor.superDispatchTouchEvent(event);
    }

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

        @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        //用于調(diào)試目的的一致性驗(yàn)證程序
        if (mInputEventConsistencyVerifier != null) {
            mInputEventConsistencyVerifier.onTouchEvent(ev, 1);
        }
        // If the event targets the accessibility focused view and this is it, start
        // normal event dispatch. Maybe a descendant is what will handle the click.
        if (ev.isTargetAccessibilityFocus() && isAccessibilityFocusedViewOrHost()) {
            ev.setTargetAccessibilityFocus(false);
        }
        //這個(gè)變量用于標(biāo)記事件是否被消費(fèi)
        boolean handled = false;
        //根據(jù)應(yīng)用安全策略過(guò)濾觸摸事件
        if (onFilterTouchEventForSecurity(ev)) {
            final int action = ev.getAction();
            final int actionMasked = action & MotionEvent.ACTION_MASK;
            // 處理 initial down 發(fā)生后的初始化操作
            if (actionMasked == MotionEvent.ACTION_DOWN) {
                // 新的 ACTION_DOWN 事件來(lái)了，需要取消并清除之前的 touch Targets
                //清空掉 mFirstTouchTarget
                cancelAndClearTouchTargets(ev);
                //重置觸摸狀態(tài)
                resetTouchState();
            }
            //標(biāo)記是否攔截事件
            final boolean intercepted;
            // 當(dāng) ACTION_DOWN 來(lái)了或者已經(jīng)發(fā)生過(guò) ACTION_DOWN,并且將 mFirstTouchTarget 賦值 就檢測(cè) ViewGroup 是否需要攔截事件.
            //只有發(fā)生過(guò) ACTION_DOWN 事件，mFirstTouchTarget != null
            if (actionMasked == MotionEvent.ACTION_DOWN
                    || mFirstTouchTarget != null) {
                //子 View 可以通過(guò)調(diào)用父 View 的 requestDisallowInterceptTouchEvent 方法設(shè)置 mGroupFlags 值
                //以此告訴父 View 是否攔截事件
                final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
                //如果子 view 沒(méi)有告訴父 View 別攔截事件，那父 View 就判斷自己是否需要攔截事件
                if (!disallowIntercept) {
                    intercepted = onInterceptTouchEvent(ev);
                    ev.setAction(action); // 重新恢復(fù) action  以防被改變了
                } else {
                        //這里表明子 View 告訴父 View 不要攔截事件
                    intercepted = false;
                }
            } else {
                //當(dāng) mFirstTouchTarget=null（沒(méi)有子 View 被分配處理），且不是 initial down 事件時(shí)（事件已經(jīng)初始化過(guò)了），ViewGroup 繼續(xù)攔截觸摸
                //繼續(xù)設(shè)置為 true
                intercepted = true;
            }
            // 如果當(dāng)前事件是 ACTION_CANCEL，或者 view.mPrivateFlags 被設(shè)置了 PFLAG_CANCEL_NEXT_UP_EVENT
            //那么當(dāng)前事件就取消了
            final boolean canceled = resetCancelNextUpFlag(this)
                    || actionMasked == MotionEvent.ACTION_CANCEL;
            //split 表示當(dāng)前的 ViewGroup 是不是支持分割 MotionEvent 到不同的 View 當(dāng)中
            final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0;
            //新的 TouchTarget
            TouchTarget newTouchTarget = null;
            //是否把事件分發(fā)給了新的 TouchTarget
            boolean alreadyDispatchedToNewTouchTarget = false;
            //不取消事件，同時(shí)不攔截事件才進(jìn)入該區(qū)域
            if (!canceled && !intercepted) {
                //把事件分發(fā)給所有的子視圖，尋找可以獲取焦點(diǎn)的視圖
                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;
                    // 對(duì)于這個(gè) PointerId 清空更早的 touch targets 
                    removePointersFromTouchTargets(idBitsToAssign);
                    final int childrenCount = mChildrenCount;
                    //如果當(dāng)前 ViewGroup 有子 View 且 newTouchTarget=null
                    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;
                        //遍歷所有子 View，找到一個(gè)來(lái)接收事件
                        for (int i = childrenCount - 1; i >= 0; i--) {
                            final int childIndex = getAndVerifyPreorderedIndex(
                                    childrenCount, i, customOrder);
                            final View child = getAndVerifyPreorderedView(
                                    preorderedList, children, childIndex);
                            //如果當(dāng)前子 View 沒(méi)有獲取焦點(diǎn)，則跳過(guò)這個(gè)子 View
                            if (childWithAccessibilityFocus != null) {
                                if (childWithAccessibilityFocus != child) {
                                    continue;
                                }
                                childWithAccessibilityFocus = null;
                                i = childrenCount - 1;
                            }
                            //如果當(dāng)前子 View 不可見(jiàn)且沒(méi)有播放動(dòng)畫 或者 不在觸摸點(diǎn)范圍內(nèi)，跳過(guò)這個(gè)子 View
                            if (!canViewReceivePointerEvents(child)
                                    || !isTransformedTouchPointInView(x, y, child, null)) {
                                ev.setTargetAccessibilityFocus(false);
                                continue;
                            }
                            //如果在觸摸目標(biāo)列表找到了與該子 View 對(duì)應(yīng)的 TouchTarget，說(shuō)明這個(gè) view 正在接收事件，不需要再遍歷，直接退出
                            newTouchTarget = getTouchTarget(child);
                            if (newTouchTarget != null) {
                                newTouchTarget.pointerIdBits |= idBitsToAssign;
                                break;
                            }
                            resetCancelNextUpFlag(child);
                            //子 view 處于觸摸位置，就將事件分發(fā)給子 View，如果該子 View 返回 true，說(shuō)明消費(fèi)了這個(gè)事件，就跳出遍歷
                            if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
                                // 獲取 TouchDown 的時(shí)間點(diǎn)
                                mLastTouchDownTime = ev.getDownTime();
                                // 獲取 TouchDown 的 Index
                                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;
                                }
                                //獲取 TouchDown 的 x,y 坐標(biāo)
                                mLastTouchDownX = ev.getX();
                                mLastTouchDownY = ev.getY();
                                //添加到觸摸目標(biāo)列表 同時(shí)給 mFirstTouchTarget 賦值
                                newTouchTarget = addTouchTarget(child, idBitsToAssign);
                                alreadyDispatchedToNewTouchTarget = true;
                                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();
                    }
                    if (newTouchTarget == null && mFirstTouchTarget != null) {
                        // 到這里說(shuō)明沒(méi)有子 View 接收事件，那就把最近一次的觸摸目標(biāo)賦值給 newTouchTarget
                        newTouchTarget = mFirstTouchTarget;
                        while (newTouchTarget.next != null) {
                            newTouchTarget = newTouchTarget.next;
                        }
                        newTouchTarget.pointerIdBits |= idBitsToAssign;
                    }
                }
            }
            // mFirstTouchTarget 賦值是在通過(guò) addTouchTarget 方法獲取的；
            // 只有處理 ACTION_DOWN 事件，才會(huì)進(jìn)入 addTouchTarget 方法。
            // 這也正是當(dāng) View 沒(méi)有消費(fèi) ACTION_DOWN 事件，則不會(huì)接收其他 MOVE,UP 等事件的原因
            if (mFirstTouchTarget == null) {
                // 那就只能 ViewGroup 自己處理事件了
                handled = dispatchTransformedTouchEvent(ev, canceled, null,
                        TouchTarget.ALL_POINTER_IDS);
            } else {
                // 到這里就說(shuō)明有子 View 接收了 ACTION_DOWN 事件，那后續(xù)的 move up 等事件就繼續(xù)分發(fā)給這個(gè)觸摸目標(biāo)
                TouchTarget predecessor = null;
                TouchTarget target = mFirstTouchTarget;
                while (target != null) {
                    final TouchTarget next = target.next;
                    if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
                        handled = true;
                    } else {
                        //如果 view.mPrivateFlags 被設(shè)置了 PFLAG_CANCEL_NEXT_UP_EVENT 或者事件被 ViewGroup 攔截了
                        //那子 View 需要取消事件
                        final boolean cancelChild = resetCancelNextUpFlag(target.child)
                                || intercepted;
                        //繼續(xù)分發(fā)事件給子 View
                        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;
                }
            }
            //當(dāng)發(fā)生抬起或取消事件，更新觸摸目標(biāo)列表
            if (canceled
                    || actionMasked == MotionEvent.ACTION_UP
                    || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
                resetTouchState();
            } else if (split && actionMasked == MotionEvent.ACTION_POINTER_UP) {
                //如果是多點(diǎn)觸摸下的手指抬起事件，就要根據(jù) idBit 從 TouchTarget 中移除掉對(duì)應(yīng)的 Pointer(觸摸點(diǎn))
                final int actionIndex = ev.getActionIndex();
                final int idBitsToRemove = 1 << ev.getPointerId(actionIndex);
                removePointersFromTouchTargets(idBitsToRemove);
            }
        }
        if (!handled && mInputEventConsistencyVerifier != null) {
            mInputEventConsistencyVerifier.onUnhandledEvent(ev, 1);
        }
        return handled;
    }

/**
      * 取消和清空所有的 touch targets.
      */
    private void cancelAndClearTouchTargets(MotionEvent event) {
        if (mFirstTouchTarget != null) {
            boolean syntheticEvent = false;
            if (event == null) {
                final long now = SystemClock.uptimeMillis();
                event = MotionEvent.obtain(now, now,
                        MotionEvent.ACTION_CANCEL, 0.0f, 0.0f, 0);
                event.setSource(InputDevice.SOURCE_TOUCHSCREEN);
                syntheticEvent = true;
            }
            for (TouchTarget target = mFirstTouchTarget; target != null; target = target.next) {
                resetCancelNextUpFlag(target.child);
                dispatchTransformedTouchEvent(event, true, target.child, target.pointerIdBits);
            }
            clearTouchTargets();
            if (syntheticEvent) {
                event.recycle();
            }
        }
    }
    /**
     * 清空所有的 touch targets.
     */
    private void clearTouchTargets() {
        TouchTarget target = mFirstTouchTarget;
        if (target != null) {
            do {
                TouchTarget next = target.next;
                target.recycle();
                target = next;
            } while (target != null);
            mFirstTouchTarget = null;
        }
    }
    /**
     * 重置所有觸摸狀態(tài)以準(zhǔn)備新周期.
     */
    private void resetTouchState() {
        clearTouchTargets();
        resetCancelNextUpFlag(this);
        mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
        mNestedScrollAxes = SCROLL_AXIS_NONE;
    }

            //標(biāo)記是否攔截事件
            final boolean intercepted;
            // 當(dāng) ACTION_DOWN 來(lái)了或者已經(jīng)發(fā)生過(guò) ACTION_DOWN,并且將 mFirstTouchTarget 賦值 就檢測(cè) ViewGroup 是否需要攔截事件.
            if (actionMasked == MotionEvent.ACTION_DOWN
                    || mFirstTouchTarget != null) {
                //子 View 可以通過(guò)調(diào)用父 View 的 requestDisallowInterceptTouchEvent 方法設(shè)置 mGroupFlags 值
                //以此告訴父 View 是否攔截事件
                final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
                //如果子 view 沒(méi)有告訴父 View 別攔截事件，那父 View 就判斷自己是否需要攔截事件
                if (!disallowIntercept) {
                    intercepted = onInterceptTouchEvent(ev);
                    ev.setAction(action); // 重新恢復(fù) action  以防被改變了
                } else {
                    //這里表明子 View 告訴父 View 不要攔截事件
                    intercepted = false;
                }
            } else {
                //當(dāng) mFirstTouchTarget=null（沒(méi)有子 View 被分配處理），且不是 initial down 事件時(shí)（事件已經(jīng)初始化過(guò)了），ViewGroup 繼續(xù)攔截觸摸
                //繼續(xù)設(shè)置為 true
                intercepted = true;
            }

@Override
    public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {
        if (disallowIntercept == ((mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0)) {
            // 如果已經(jīng)設(shè)置過(guò)了，就返回
            return;
        }
        if (disallowIntercept) {
            mGroupFlags |= FLAG_DISALLOW_INTERCEPT;
        } else {
            mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
        }
        // 依次告訴父 view
        if (mParent != null) {
            mParent.requestDisallowInterceptTouchEvent(disallowIntercept);
        }
    }

 /**
     * ViewGroup 可在這個(gè)方法里攔截所有觸摸事件，默認(rèn)是不攔截事件，開(kāi)發(fā)者可以重寫這個(gè)方法決定是否要攔截
     * 如下四個(gè)條件都成立，返回 true，攔截事件
     * 第一個(gè)：觸摸事件是否來(lái)自鼠標(biāo)指針設(shè)備
     * 第二個(gè)：觸摸事件是否是 ACTION_DOWN
     * 第三個(gè)：檢查是否按下了鼠標(biāo)或手寫筆按鈕（或按鈕組合），也就是說(shuō)用戶必須實(shí)際按下
     * 第四個(gè)：觸摸點(diǎn)是否在滾動(dòng)條上
     */
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        if (ev.isFromSource(InputDevice.SOURCE_MOUSE)
                && ev.getAction() == MotionEvent.ACTION_DOWN
                && ev.isButtonPressed(MotionEvent.BUTTON_PRIMARY)
                && isOnScrollbarThumb(ev.getX(), ev.getY())) {
            return true;
        }
        return false;
    }

private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
        View child, int desiredPointerIdBits) {
    final boolean handled;
    // 發(fā)生取消操作時(shí)，不再執(zhí)行后續(xù)的任何操作
    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;
    }
    final int oldPointerIdBits = event.getPointerIdBits();
    final int newPointerIdBits = oldPointerIdBits & desiredPointerIdBits;
    //由于某些原因，發(fā)生不一致的操作，那么將拋棄該事件
    if (newPointerIdBits == 0) {
        return false;
    }
    //分發(fā)的主要區(qū)域
    final MotionEvent transformedEvent;
    //判斷預(yù)期的 pointer id 與事件的 pointer id 是否相等
    if (newPointerIdBits == oldPointerIdBits) {
        if (child == null || child.hasIdentityMatrix()) {
            if (child == null) {
                //不存在子視圖時(shí)，ViewGroup 調(diào)用 View.dispatchTouchEvent 分發(fā)事件，再調(diào)用 ViewGroup.onTouchEvent 來(lái)處理事件
                handled = super.dispatchTouchEvent(event); 
            } else {
                final float offsetX = mScrollX - child.mLeft;
                final float offsetY = mScrollY - child.mTop;
                event.offsetLocation(offsetX, offsetY);
                //將觸摸事件分發(fā)給子 ViewGroup 或 View;
                handled = child.dispatchTouchEvent(event);
                event.offsetLocation(-offsetX, -offsetY); //調(diào)整該事件的位置
            }
            return handled;
        }
        transformedEvent = MotionEvent.obtain(event); //拷貝該事件，來(lái)創(chuàng)建一個(gè)新的 MotionEvent
    } else {
        //分離事件，獲取包含 newPointerIdBits 的 MotionEvent
        transformedEvent = event.split(newPointerIdBits);
    }
    if (child == null) {
        //不存在子視圖時(shí)，ViewGroup 調(diào)用 View.dispatchTouchEvent 分發(fā)事件，再調(diào)用 ViewGroup.onTouchEvent 來(lái)處理事件
        handled = super.dispatchTouchEvent(transformedEvent); 
    } else {
        final float offsetX = mScrollX - child.mLeft;
        final float offsetY = mScrollY - child.mTop;
        transformedEvent.offsetLocation(offsetX, offsetY);
        if (! child.hasIdentityMatrix()) {
            //將該視圖的矩陣進(jìn)行轉(zhuǎn)換
            transformedEvent.transform(child.getInverseMatrix());
        }
        //將觸摸事件分發(fā)給子 ViewGroup 或 View;
        handled = child.dispatchTouchEvent(transformedEvent);
    }
    //回收 transformedEvent
    transformedEvent.recycle();
    return handled;
}

private TouchTarget addTouchTarget(View child, int pointerIdBits) {
    TouchTarget target = TouchTarget.obtain(child, pointerIdBits);
    target.next = mFirstTouchTarget;
    mFirstTouchTarget = target;
    return target;
}

/**
     * 將觸摸事件向下傳遞到目標(biāo)視圖，或者這個(gè) View 是目標(biāo)視圖。
     *
     * @return 返回 true 表示消費(fèi)了事件，反之返回 false 
     */
    public boolean dispatchTouchEvent(MotionEvent event) {
                ......
        boolean result = false;
        final int actionMasked = event.getActionMasked();
        if (actionMasked == MotionEvent.ACTION_DOWN) {
            //在 Down 事件之前，如果存在滾動(dòng)操作則停止。不存在則不進(jìn)行操作
            stopNestedScroll();
        }
        //過(guò)濾觸摸事件以應(yīng)用安全策略
        if (onFilterTouchEventForSecurity(event)) {
            if ((mViewFlags & ENABLED_MASK) == ENABLED && handleScrollBarDragging(event)) {
                result = true;
            }
            ListenerInfo li = mListenerInfo;
            // 如果給 View 設(shè)置了 OnTouchListener
            //且該 view 沒(méi)有禁用的
            //且 OnTouchListener.onTouch 返回 true
            //那說(shuō)明該 View 消費(fèi)了該事件，返回 true
            if (li != null && li.mOnTouchListener != null
                    && (mViewFlags & ENABLED_MASK) == ENABLED
                    && li.mOnTouchListener.onTouch(this, event)) {
                result = true;
            }
           //如果 OnTouchListener.onTouch 沒(méi)有消費(fèi)事件且 View 的 onTouchEvent 方法返回 true，那返回 true
            if (!result && onTouchEvent(event)) {
                result = true;
            }
        }
        // 如果這是手勢(shì)的結(jié)束，則在嵌套滾動(dòng)后清理;
        //如果我們嘗試了 ACTION_DOWN 但是我們不想要其余的手勢(shì)，也要取消它。
        if (actionMasked == MotionEvent.ACTION_UP ||
                actionMasked == MotionEvent.ACTION_CANCEL ||
                (actionMasked == MotionEvent.ACTION_DOWN && !result)) {
            stopNestedScroll();
        }
        return result;
    }

public boolean onTouchEvent(MotionEvent event) {
        final float x = event.getX();
        final float y = event.getY();
        final int viewFlags = mViewFlags;
        final int action = event.getAction();
        //如果這個(gè) view 是禁用的，可以通過(guò) setEnabled()設(shè)置是否禁用
        if ((viewFlags & ENABLED_MASK) == DISABLED) {
            if (action == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
                setPressed(false);
            }
            // 即使設(shè)置了禁用，但是只要這個(gè) view 滿足 CLICKABLE ，LONG_CLICKABLE ，CONTEXT_CLICKABLE 其中一種
            //任然算消費(fèi)該事件，只是沒(méi)有響應(yīng)而已
            return (((viewFlags & CLICKABLE) == CLICKABLE
                    || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
                    || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE);
        }
         //當(dāng) View 狀態(tài)為 ENABLED
        //且這個(gè) view 滿足 CLICKABLE LONG_CLICKABLE CONTEXT_CLICKABLE 其中一種，就消費(fèi)這個(gè)事件
        if (((viewFlags & CLICKABLE) == CLICKABLE ||
                (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE) ||
                (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE) {
            switch (action) {
                case MotionEvent.ACTION_UP:
                    boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
                    if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {
                        // 獲取焦點(diǎn)處于可觸摸模式
                        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) {
                            //這是 Tap 操作，移除長(zhǎng)按回調(diào)方法
                            removeLongPressCallback();
                            // 如果處于按下?tīng)顟B(tài)盡執(zhí)行點(diǎn)擊操作
                            if (!focusTaken) {
                                // 使用 Runnable 并發(fā)布而不是直接調(diào)用 performClick 
                                //這樣可以在單擊操作開(kāi)始之前更新視圖的其他可視狀態(tài)
                                if (mPerformClick == null) {
                                    mPerformClick = new PerformClick();
                                }
                                //調(diào)用 View.OnClickListener
                                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:
                    mHasPerformedLongPress = false;
                    if (performButtonActionOnTouchDown(event)) {
                        break;
                    }
                    // 確定是否處于可滾動(dòng)的視圖內(nèi)
                    boolean isInScrollingContainer = isInScrollingContainer();
                    if (isInScrollingContainer) {
                        mPrivateFlags |= PFLAG_PREPRESSED;
                        if (mPendingCheckForTap == null) {
                            mPendingCheckForTap = new CheckForTap();
                        }
                        mPendingCheckForTap.x = event.getX();
                        mPendingCheckForTap.y = event.getY();
                        //當(dāng)處于可滾動(dòng)視圖內(nèi)，則延遲 TAP_TIMEOUT，再反饋按壓狀態(tài)，用來(lái)判斷用戶是否想要滾動(dòng)。默認(rèn)延時(shí)為 100ms
                            postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
                    } else {
                        //當(dāng)不再滾動(dòng)視圖內(nèi)，則立刻反饋按壓狀態(tài)
                        setPressed(true, x, y);
                        //檢測(cè)是否是長(zhǎng)按，如果長(zhǎng)按，回調(diào) OnLongClickListener.onLongClick
                        checkForLongClick(0, x, y);
                    }
                    break;
                case MotionEvent.ACTION_CANCEL:
                    setPressed(false);
                    removeTapCallback();
                    removeLongPressCallback();
                    mInContextButtonPress = false;
                    mHasPerformedLongPress = false;
                    mIgnoreNextUpEvent = false;
                    break;
                case MotionEvent.ACTION_MOVE:
                    drawableHotspotChanged(x, y);
                    // Be lenient about moving outside of buttons
                    if (!pointInView(x, y, mTouchSlop)) {
                        // Outside button
                        removeTapCallback();
                        if ((mPrivateFlags & PFLAG_PRESSED) != 0) {
                            // Remove any future long press/tap checks
                            removeLongPressCallback();
                            setPressed(false);
                        }
                    }
                    break;
            }
            return true;
        }
        return false;
    }

public boolean dispatchTouchEvent(MotionEvent ev) {
        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
            onUserInteraction();
        }
        //循環(huán)判斷是否有 ViewGroup 或者 View 消費(fèi)事件，如果沒(méi)有，事件回到 activity
        if (getWindow().superDispatchTouchEvent(ev)) {
            return true;
        }
        return onTouchEvent(ev);
    }
public boolean onTouchEvent(MotionEvent event) {
        if (mWindow.shouldCloseOnTouch(this, event)) {
            finish();
            return true;
        }
        return false;
    }