public boolean onTouchEvent(MotionEvent event) {
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                break;
            case MotionEvent.ACTION_MOVE:
                break;
            case MotionEvent.ACTION_UP:
                break;
            case MotionEvent.ACTION_CANCEL:
                break;
        }
        return true;
    }

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

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

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

public class ViewGroup {
    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        boolean handled = false;
        final int action = ev.getAction();
        final int actionMasked = action & MotionEvent.ACTION_MASK;
        // Check for interception.
        //按下后，第一次調用時actionMasked=down，mFirstTouchTarget=null
        //一直按著 actionMasked=move, 如果mFirstTouchTarget！=null說明有子view處理了touch事件
        final boolean intercepted;
        if (actionMasked == MotionEvent.ACTION_DOWN
                || mFirstTouchTarget != null) {
            final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
            if (!disallowIntercept) {
                //調用子類復寫的方法 如果為true表示攔截，false表示不攔截
                intercepted = onInterceptTouchEvent(ev);
                ev.setAction(action); // restore action in case it was changed
            } else {
                intercepted = false;
            }
        } else {
            // There are no touch targets and this action is not an initial down
            // so this view group continues to intercept touches.
            //如果沒有子view處理touch事件，并且不是第一次按下的down事件，group會對touch事件進行攔截
            intercepted = true;
        }
        TouchTarget newTouchTarget = null;
        //第一次按下時，判斷view是否處理事件的標志
        boolean alreadyDispatchedToNewTouchTarget = false;
        //如果不攔截，則進入事件分發
        if (!canceled && !intercepted) {
            //注意，只有ACTION_DOWN時才會遍歷子View
            if (actionMasked == MotionEvent.ACTION_DOWN
                    || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
                    || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
                final int childrenCount = mChildrenCount;
                if (newTouchTarget == null && childrenCount != 0) {
                    final ArrayList<View> preorderedList = buildTouchDispatchChildList();
                    final View[] children = mChildren;
                    //開始遍歷子view
                    for (int i = childrenCount - 1; i >= 0; i--) {
                        final View child = getAndVerifyPreorderedView(
                                preorderedList, children, childIndex);
                        //isTransformedTouchPointInView 通過比對坐標，來判斷事件是否落在了child上，
                        // true是，false不是
                        if (!canViewReceivePointerEvents(child)
                                || !isTransformedTouchPointInView(x, y, child, null)) {
                            ev.setTargetAccessibilityFocus(false);
                            // 如果事件沒有落在child上，則跳過此次循環，執行下一次循環
                            continue;
                        }
                        //通過遍歷TouchTarget鏈表查找TouchTarget，如果找到了，則break跳出循環
                        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;
                        }
                        //第一次進來newTouchTarget==null，進入下面的邏輯
                        //如果dispatchTransformedTouchEvent 返回true，表示子view對事件進行了處理，則跳出此循環，
                        // 不會再向子view進行分發
                        if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
                            // Child wants to receive touch within its bounds.
                            //將child緩存到TouchTarget的鏈表中
                            newTouchTarget = addTouchTarget(child, idBitsToAssign);
                            //注意這個標志位，true，下面的邏輯會用到
                            alreadyDispatchedToNewTouchTarget = true;
                            break;
                        }
 
                    }
                    if (preorderedList != null) preorderedList.clear();
                }
            }
        }
        // Dispatch to touch targets.
        //ACTION_DOWN和ACTION_MOVE 的時都會執行下面邏輯
        //mFirstTouchTarget==null 說明沒有子View處理touch事件，dispatchTransformedTouchEvent的第三個參數為null。
        if (mFirstTouchTarget == null) {
            // No touch targets so treat this as an ordinary view.
            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 鏈表進行遍歷，TouchTarget里緩存了處理事件的view，
            //一次完整事件，move會調用多次，所以在ACTION_DOWN時找到的對應的view，緩存起來，
            // 而不是每次都遍歷ViewGroup的子View，這樣太損壞性能
            TouchTarget target = mFirstTouchTarget;
            //開始對鏈表進行遍歷，為啥是一個鏈表呢，這是為了進行多點觸摸，會有多個view響應觸摸事件。
            while (target != null) {
                final TouchTarget next = target.next;
                //alreadyDispatchedToNewTouchTarget ==true ，并且緩存的target和newTouchTarget是同一個
                //直接將handled置為true，防止ACTION_DOWN時dispatchTransformedTouchEvent方法重復調用
                if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
                    handled = true;
                } else {
                    if (dispatchTransformedTouchEvent(ev, cancelChild,
                            target.child, target.pointerIdBits)) {
                        handled = true;
                    }
                }
                target = next;
            }
        }
        //將handled 返回dispatchTouchEvent的調用者。
        return handled;
    }
    /**
     * Gets the touch target for specified child view.
     * Returns null if not found.
     * 通過遍歷TouchTarget 鏈表，找到touch target
     */
    private TouchTarget getTouchTarget(@NonNull View child) {
        for (TouchTarget target = mFirstTouchTarget; target != null; target = target.next) {
            if (target.child == child) {
                return target;
            }
        }
        return null;
    }
    /**
     * Adds a touch target for specified child to the beginning of the list.
     * Assumes the target child is not already present.
     * 將TouchTarget和view進行關聯，并且把這個TouchTarget放在鏈表的頭部
     */
    private TouchTarget addTouchTarget(@NonNull View child, int pointerIdBits) {
        final TouchTarget target = TouchTarget.obtain(child, pointerIdBits);
        target.next = mFirstTouchTarget;
        mFirstTouchTarget = target;
        return target;
    }
    private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
                                                  View child, int desiredPointerIdBits) {
        final boolean handled;
        // 只看最關鍵的兩行代碼
        if (child == null) {
            //如果child為null，沒有子view處理touch事件，則調用父類View的dispatchTouchEvent。
            handled = super.dispatchTouchEvent(transformedEvent);
        } else {
            //如果child不為空，則調用child view 的dispatchTouchEvent
            //這行代碼很關鍵，如果child是ViewGroup則繼續在ViewGoup的進行事件分發，這會是一個遞歸調用
            //如果child 是一個View，則調用View的dispatchTouchEvent，進行事件的分發。
            handled = child.dispatchTouchEvent(transformedEvent);
        }
        //以上兩行代碼最終會調用到View的dispatchTouchEvent方法。
        return handled;
    }
}

public class View {
    public boolean dispatchTouchEvent(MotionEvent ev) {
        boolean result = false;
        ListenerInfo li = mListenerInfo;
        //如果view設置了mOnTouchListener，先調用mOnTouchListener.onTouch，
        //如果返回true，則表示消費了此事件，不在向下傳遞，為啥這樣說？那是因為，通過他的返回值，進行了邏輯判斷
        if (li != null && li.mOnTouchListener != null
                && (mViewFlags & ENABLED_MASK) == ENABLED
                && li.mOnTouchListener.onTouch(this, event)) {
            result = true;
        }
        //如果result為false，則調用View.onTouchEvent方法
        if (!result && onTouchEvent(event)) {
            result = true;
        }
        return result;
    }
    public boolean onTouchEvent(MotionEvent event) {
        switch (action) {
            case MotionEvent.ACTION_UP:
                if (mPerformClick == null) {
                    mPerformClick = new PerformClick();
                }
                if (!post(mPerformClick)) {
                    //調用performClick mOnClickListener.onClick()方法
                    performClickInternal();
                }
                break;
            case MotionEvent.ACTION_DOWN:
                break;
            case MotionEvent.ACTION_CANCEL:
                break;
            case MotionEvent.ACTION_MOVE:
                break;
        }
        return false;
    }
    public boolean performClick() {
        final boolean result;
        final ListenerInfo li = mListenerInfo;
        if (li != null && li.mOnClickListener != null) {
            playSoundEffect(SoundEffectConstants.CLICK);
            li.mOnClickListener.onClick(this);
            result = true;
        } else {
            result = false;
        }
        return result;
    }
}