View機制深入學習（四）View的事件分發機制

當發生點擊事件後，事件會最先傳遞給當前的Activity，Activity調用dispatchTouchEvent來進行事件的dispatch;

事件的分發方式可以簡明清晰地概括爲下圖所示：

通過dispatchTouchEvent進行分發，ViewGroup中會有onInterceptTouchEvent判斷是否進行攔截；

如果onInterceptTouchEvent返回fasle，則不進行攔截，繼續調用子View的dispatchTouchEvent進行分發；如果返回true,則直接調用其自身（因爲ViewGroup是繼承View的，故會調用View的）onTouchEvent來處理該Touch Event；

使用onTouchEvent處理事件時，如果返回false,則該層View並不消費該事件，而是會將該Event繼續往上傳遞；直到有一層View的onTouchEvent的返回值爲true時，該層View消耗該事件，該事件不再往上層View傳遞；使用View事件分發機制可以很好地處理滑動衝突等問題。

1、Activity#dispatchTouchEvent：

/** \frameworks\base\core\java\android\app\Activity.java **/
public boolean dispatchTouchEvent(MotionEvent ev) {
    if (ev.getAction() == MotionEvent.ACTION_DOWN) {
        onUserInteraction();
    }
    if (getWindow().superDispatchTouchEvent(ev)) {
        return true;
    }
    return onTouchEvent(ev);
}

代碼很簡單，當是ACTION_DOWN事件時，會先調用onUserInteraction方法，該方法其實就是個Activity的空函數，可以在定義Activity繼承時進行Override，完成一些ACTION_DOWN事件分發前的處理工作；

/** \frameworks\base\core\java\android\app\Activity.java **/
public void onUserInteraction() {
}

可以看到重寫onUserInteraction方法並不會對MotionEvent的派發產生影響，但是每一個對ACTION_DOWN事件的派發都會調用onUserInteraction方法。

接下來進而調用getWindow().superDispatchTouchEvent(ev)來派發事件，可以看到如果該方法返回true，系統將不會調用Activity中的onTouchEvent函數；

由 Android View機制深入學習（一）知getWindow()實質上返回的是PhoneWindow類，則繼續調用的是：

2、PhoneWindow#superDispatchTouchEvent:

/** \frameworks\base\policy\src\com\android\internal\policy\impl\PhoneWindow.java**/
private DecorView mDecor;
@Override
public boolean superDispatchTouchEvent(MotionEvent event) {
    return mDecor.superDispatchTouchEvent(event);
}

PhoneWindow繼續將事件傳遞給內部的DecorView;

/** \frameworks\base\policy\src\com\android\internal\policy\impl\PhoneWindow.java**/
private final class DecorView extends FrameLayout implements RootViewSurfaceTaker {
    public boolean superDispatchTouchEvent(MotionEvent event) {
        return super.dispatchTouchEvent(event);
    }
}

DecorView是PhoneWindow的子類，其會進一步調用super.dispatchTouchEvent(event),DecorView繼承FrameLayout,FrameLayout中並未實現dispatchTouchEvent方法；FameLayout繼承ViewGroup，則繼續調用ViewGroup的dispatchTouchEvent方法；即事件從Activity傳到Window進而傳遞到ViewGroup中；DecorView是頂層ViewGroup，可想而知，接下來的dispatch會根據View樹進行逐級派發事件。

3、ViewGroup#dispatchTouchEvent:(代碼較長，分段閱讀如下)：

1）處理ACTION_DOWN事件：

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

// Handle an initial down.
if (actionMasked == MotionEvent.ACTION_DOWN) {
    // Throw away all previous state when starting a new touch gesture.
    // The framework may have dropped the up or cancel event for the previous gesture
    // due to an app switch, ANR, or some other state change.
    cancelAndClearTouchTargets(ev);
    resetTouchState();
}

ACTION_DOWN操作可以看做一個完整事件流程的起點，故在該系列動作開始時，會清理之前設置過狀態，其中cancelAndClearTouchTargets會將下面將會看到的mFirstTouchTarget變量置爲null；

2）判斷是否對事件進行攔截：

// Check for interception.
final boolean intercepted;
if (actionMasked == MotionEvent.ACTION_DOWN
        || mFirstTouchTarget != null) {
    final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
    if (!disallowIntercept) {
        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.
    intercepted = true;
}

可以看到不攔截情況包括有ACTION_DOWN事件，或者mFirstTouchTarget不爲null;

// First touch target in the linked list of touch targets.
private TouchTarget mFirstTouchTarget;

private static final class TouchTarget {
    ......
    // The next target in the target list.
    public TouchTarget next;

    private TouchTarget() {
    }
    ......
}

mFirstTouchTarget是TouchTarget對象，可以看到其其實最終形式一個鏈表。每一個ViewGroup中都包含一個 mFirstTouchTarget對象，其指向處理TouchEvent事件的下一個View，即該ViewGroup的子元素A如果成功處理了該TouchEvent事件，就會將mFirstTouchTarget指向A；

其實容易理解，這些都是針對於一個完整系列的操作事件而設計的；該事件以ACTION_DOWN事件爲開端，噹噹前事件爲ACTION_DOWN時，表示又是一個新的操作，所以將所有配置全部重置，尤其是將mFirstTouchTarget置爲null；此時不用管mFirstTouchTarget，因爲是ACTION_DOWN事件會就直接跳入到判斷是否攔截的代碼中。

而在接下來會看到，mFirstTouchTarget將會賦值，如果發生了攔截，mFirstTouchTarget將會置爲null，否則將指向下一個將要傳遞事件的子View；當系列操作中ACTION_MOVE或者ACTION_UP事件派發時，如果已經之前事件分發時已經發生了攔截，此時mFirstTouchTarget==null也就是mFirstTouchTarget！=null條件不成立，則會直接建立攔截，無需再次調用onInterceptTouchEvent；

所以有結論：若某個View一旦發生攔截，那麼這一個事件序列都只能由它來處理，並且它的onInterceptTouchEvent方法將不再會調用。

同時注意這裏有一個標記位FLAG_DISALLOW_INTERCEPT,由字面意思就可以看出，設置它就可以使得攔截無效（從代碼中可以看出，因爲會直接跳到intercepted爲false，即不攔截的情況。但注意，由於ACTION_DOWN的特殊性，其表示一個序列事件的起點，會對所有狀態，包括FLAG_DISALLOW_INTERCEPT標誌位進行重置無效化，所以設置FLAG_DISALLOW_INTERCEPT並不能攔截ACTION_DOWN事件，ACTION_DOWN事件的攔截只能發生在onInterceptTouchEvent的處理邏輯中。

假設在該層ViewGroup並不發生攔截，即intercepted爲false，ViewGroup會將事件分發給它的子View進行處理：

3）當未發生攔截，分發事件給子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 float x = ev.getX(actionIndex);
        final float y = ev.getY(actionIndex);
        .....
        final View[] children = mChildren;
        // 遍歷子View
        for (int i = childrenCount - 1; i >= 0; i--) {
            final int childIndex = customOrder
                    ? getChildDrawingOrder(childrenCount, i) : i;
            final View child = (preorderedList == null)
                    ? children[childIndex] : preorderedList.get(childIndex);

            .....

            /** 這裏是重要的處理函數 ***/
            if (!canViewReceivePointerEvents(child)
                    || !isTransformedTouchPointInView(x, y, child, null)) {
                ev.setTargetAccessibilityFocus(false);
                continue;
            }

            newTouchTarget = getTouchTarget(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();
                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();
    }
}

上面主要是對事件向子View轉發的處理；系統如果採用將事件全部轉發，也就是廣播給所有子View，然後在子View中去判斷自己是否應當處理該event，這樣效率顯然是相當低的。因此係統採取的做法是先進行判斷，遍歷所有子View，判斷適合接收該event的子View，然後將該事件傳遞給它。上面的代碼中完成就是這樣的問題。

主要涉及到的函數爲canViewReceivePointerEvents和isTransformedTouchPointInView，可以看到如果兩個判斷均通過的話，該child即是所要尋找的結果，會調用dispatchTransformedTouchEvent方法將事件傳遞給它；

I) canViewReceivePointerEvents方法是判斷該View是否能夠該收該event,源碼如下：

private static boolean canViewReceivePointerEvents(View child) {
    return (child.mViewFlags & VISIBILITY_MASK) == VISIBLE
            || child.getAnimation() != null;
}

可以看到當child的狀態爲VISIBLE狀態，或者child當前在播放動畫時，此時該View是可以接受該event的；

II)isTransformedTouchPointInView方法是判斷點擊事件的座標是否在child的區域範圍內：

protected boolean isTransformedTouchPointInView(float x, float y, View child,
        PointF outLocalPoint) {
    final float[] point = getTempPoint();
    point[0] = x;
    point[1] = y;
    transformPointToViewLocal(point, child);
    final boolean isInView = child.pointInView(point[0], point[1]);
    if (isInView && outLocalPoint != null) {
        outLocalPoint.set(point[0], point[1]);
    }
    return isInView;
}

III)當兩個條件都滿足，即調用dispatchTransformedTouchEvent方法將事件傳遞給child:

private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
                                              View child, int desiredPointerIdBits) {
    final boolean handled;
    ....
    // Perform any necessary transformations and dispatch.
    if (child == null) {
        handled = super.dispatchTouchEvent(transformedEvent);
    } else {
        ......
        handled = child.dispatchTouchEvent(transformedEvent);
    }
    return handled;
}

如果child爲null，表示無子View或者改事件點擊範圍內沒有滿足條件的子View，則調用ViewGroup的父類View中的dispatchTouchEvent函數來處理event；否則，調用child的方法繼續下一輪事件派發；

IV)在dispatchTransformedTouchEvent函數結果值爲true的情況下，會繼續往下執行，執行的主要代碼如下：

    newTouchTarget = addTouchTarget(child, idBitsToAssign);
    alreadyDispatchedToNewTouchTarget = true;

即如果child子元素的dispatchTouchEvent返回結果爲true時，會執行addTouchTarget,

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

這裏完成對mFirstTouchTarget的初始化。

4、View對事件的處理過程：

由前面可以看到，當發生攔截或者事件分發到最底層的View時，事件會交給View的dispatchTouchEvent方法進行處理；

View#dispatchTouchEvent:

public boolean dispatchTouchEvent(MotionEvent event) {
    ....
    final int actionMasked = event.getActionMasked();
    if (actionMasked == MotionEvent.ACTION_DOWN) {
        // Defensive cleanup for new gesture
        stopNestedScroll();
    }

    if (onFilterTouchEventForSecurity(event)) {
        //noinspection SimplifiableIfStatement
        ListenerInfo li = mListenerInfo;
        if (li != null && li.mOnTouchListener != null
                && (mViewFlags & ENABLED_MASK) == ENABLED
                && li.mOnTouchListener.onTouch(this, event)) {
            result = true;
        }

        if (!result && onTouchEvent(event)) {
            result = true;
        }
    }
    ......
}

這裏是對Touch事件處理的主要邏輯，由View機制深入學習（三） View中的消息傳遞及InputManagerService 知ListenerInfo是對View註冊的一系列Listener的管理者，比如OnClickListener;這裏和上文中的邏輯相同，若是View註冊了onTouchListener,則先調用onTouchListener的onTouch方法處理事件，若onTouch方法返回true，則攔截事件，不再繼續向下處理；若onTouch返回false，則會繼續調用View中的onTouchEvent方法處理事件。

View#onTouchEvent：

I、狀態爲DISABLED的View相應點擊事件

if ((viewFlags & ENABLED_MASK) == DISABLED) {
    if (action == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
        setPressed(false);
    }
    // A disabled view that is clickable still consumes the touch
    // events, it just doesn't respond to them.
    return (((viewFlags & CLICKABLE) == CLICKABLE
            || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
            || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE);
}

可以看到當View爲DISABLED狀態時，依然會消耗點擊事件，只不過是不做處理而已。View的enable屬性是不影響View中onTouchEvent默認的返回值的，即使是DIABLED狀態，只要其clickable或者long_clickable爲true，就會返回true,消耗該點擊事件。

II、主要的事務處理邏輯：

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) {
                // take focus if we don't have it already and we should in
                // touch mode.
                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();
                        }
                        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;

View會針對TouchEvent事件類型的不同進行分別處理，這裏以ACTION_UP爲例，可以看到最核心的響應就是觸發performClick()方法:

III、View#performClick:

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;
    }

    sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
    return result;
}

可以看到OnClickListener的處理邏輯就在這裏，如果View註冊了 OnClickListener，在ACTION_UP事件到達該View時，會最終觸發performClick方法，該方法中進而調用OnClickListener的onClick函數，故而在日常使用中則是重寫onClick方法來實現點擊的響應，並且onClick(View view)這裏將this作參數傳遞進來，因此onClick中的view即代表被click的組件View。

5、總體而言，View的事件傳遞過程很簡單，總共涉及到三個主要的函數dispatchTouchEvent,onInterceptTouchEvent,onTouchEvent;

dispatchTouchEvent完成對事件的派發，一般很少重載該函數；

onInterceptTouchEvent判斷是否對事件進行攔截，若爲true，則攔截事件繼續向下分派給子View；若返回false，則繼續將事件向下分派。

onTouchEvent實際上是View中的方法，因爲ViewGroup是View的子類，當該層ViewGroup攔截事件，則需要調用其父類super即View中的onTouchEvent進行處理；onTouchEvent返回true的話，則事件在本層View中消耗，否則返回false的話，會把事件繼續向上層傳遞進行處理。

View機制深入學習（四）View的事件分發機制

SQL優化-20231016

Activity組件啓動過程（三）

leetcode-56 Merge Intervals 合併區間

Service組件的啓動機制深入學習

Java多線程——死鎖

leetcode-53 Maximum Subarray 連續子數組的最大和

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結