Android事件分發：從原始碼角度分析View事件分發機制

莫比烏斯環發表於2018-10-29
Android事件原始碼View

本文由 愛學園平臺 進行聯合編輯整理輸出

原作者：愛學園——莫比烏斯環

       在開始描述問題之前先說點題外話，寫這篇文章的初衷一方面為了構建Android知識體系，另一方面是真心覺得這個是Android面試必問的知識點。網上這方面的部落格和書籍講解這方面的知識也不少，講的也很到位。正所謂只有自己理解了才是自己的，所以在閱讀了他們的文章後，加上自己的理解特此記錄一篇～，以便加深理解和記憶！如理解有誤的地方請留言說明，我們一起探討，謝謝！

聯絡方式：郵箱（ixiyan.li@gmail.com）

1.必備知識點

       事件的分發說白了，就是使用者與應用的互動過程（手指與螢幕接觸）中，發生的一系列事件傳遞與處理過程。

1.1 事件分發涉及的物件--MotionEvent

典型事件型別：

ACTION_DOWN——手指剛觸碰螢幕那一刻（按下）
ACTION_MOVE——手指在螢幕上移動（移動）
ACTION_UP——手指抬起那一刻（抬起）
複製程式碼

一個事件序列：就是從手指按下 View 開始直到手指離開 View 產生的一系列事件。

ACTION_DOWN-> ACTION_UP
ACTION_DOWN->...ACTION_MOVE...->ACTION_UP
複製程式碼

1.2 事件分發涉及的方法

1. dispatchTouchEvent(MotionEvent ev)

用來進行事件分發。返回結果受當前 View 的 onTouchEvent 和子 View 的 dispatchTouchEvent 方法的影響，表示是否消耗當前事件。

2. onInterceptTouchEvent(MotionEvent ev)

在上述dispatchTouchEvent方法內部呼叫，用來進行當前事件是否攔截校驗。這裡有一點要注意的地方就是如果當前View攔截了某個事件（一般指ACTION_DOWN），那麼在同一個事件序列（上面講過這個概念）當中,此方法不會被再次呼叫——即不會做二次攔截校驗。 注：Activity和View內部沒有此方法

3. onTouchEvent(MotionEvent ev)

在上述dispatchTouchEvent方法內部呼叫，返回結果表示是否消耗當前事件。這裡同上也有一點要注意，如果當前方法返回false（不消耗）,那麼同一個事件序列中，當前View無法再次接收到事件。

上述方法的關係可用下面的一段虛擬碼表示：

public boolean dispatchTouchEvent(MotionEvetn e){ 
	if(onInterceptTouchEvent(ev)){//是否攔截
		return onTouchEvent(e);//攔截事件處理：是否消耗
	}
	return child.dispatchTouchEvent(e);//不攔截：子類View分發
}
複製程式碼

通過上面的虛擬碼可以大致瞭解到事件的傳遞規則：對於一個根ViewGroup來說，點選事件產生後，首先會傳遞給它，這時它的dispatchTouchEvent就會被呼叫，如果這個ViewGroup的onInterceptTouchEvent方法返回true,就說明攔截當前事件，接著事件就會交給這個ViewGroup的onTouchEvent方法處理。反之onInterceptTouchEvent方法返回false，就不攔截當前事件，這時當前事件就會傳遞給它的子View，接著View的dispatchTouchEvent方法就會呼叫，如此反覆直到事件最終被處理。

1.3 事件傳遞過程遵循如下過程

Activity -> Windown(PhoneWindow) -> DecorView(FrameLayout) -> contentView(setContentView) ->..ViewGroup..->View
複製程式碼

2. 事件分發原始碼解析

根據上面瞭解到的事件傳遞的過程分析，下面我們就一步一步撕開它神祕的面紗，從內部瞭解它的呼叫關係。

2.1 Activity對點選事件的分發過程

點選事件用MontionEvent表示，當一個點選操作發生時，最先傳遞給當前Activity,由Activity的dispatchTouchEvent方法進行事件分發，具體的工作由Window來完成。Window會將事件傳遞給DecorView，DecorView一般就是當前介面的底層容器（即setContentView所設定的 View 的父容器），通過Activity.getWindow().getDecorView()可以獲得。因此我們先從Activity的dispatchTouchEvent開始分析。

原始碼-1：Activity#dispatchTouchEvent

/**
* Called to process touch screen events.  You can override this to
* intercept all touch screen events before they are dispatched to the
* window.  Be sure to call this implementation for touch screen events
* that should be handled normally.
*
* @param ev The touch screen event.
*
* @return boolean Return true if this event was consumed.
*/
public boolean dispatchTouchEvent(MotionEvent ev) {
    if (ev.getAction() == MotionEvent.ACTION_DOWN) {
            onUserInteraction();
        }
        if (getWindow().superDispatchTouchEvent(ev)) {
            return true;
        }
        return onTouchEvent(ev);
    }
    
public boolean onTouchEvent(MotionEvent event) {
    if (mWindow.shouldCloseOnTouch(this, event)) {
        finish();
        return true;
    }

    return false;
}    
複製程式碼

現在分析上述程式碼，通過原始碼瞭解到事件交給Activity所附屬的Window進行分發，如果getWindow().superDispatchTouchEvent(ev)返回true，事件到此結束，返回false，說明下級所有View的onTouchEvent都返回了false,則Activity的onTouchEvent將會被呼叫（如上）

通過上面瞭解到getWindow().superDispatchTouchEvent(ev)這個才是分發的關鍵，看原始碼：

原始碼-2：Window#superDispatchTouchEvent


/**
 * Abstract base class for a top-level window look and behavior policy.  An
 * instance of this class should be used as the top-level view added to the
 * window manager. It provides standard UI policies such as a background, title
 * area, default key processing, etc.
 *
 * <p>The only existing implementation of this abstract class is
 * android.view.PhoneWindow, which you should instantiate when needing a
 * Window.
 */
public abstract class Window {
	/**
	 * Used by custom windows, such as Dialog, to pass the touch screen event
	 * further down the view hierarchy. Application developers should
	 * not need to implement or call this.
	 *
	 */
	public abstract boolean superDispatchTouchEvent(MotionEvent event);
	...
}
複製程式碼

看上面貼的原始碼發現貼了好多註釋說明，因為這裡Window是個抽象類，那麼它的實現類是什麼呢，是PhoneWindow，為什麼呢？到這裡您可以詳細閱讀下上面Window類的說明，發現此處已經指明瞭Window的唯一實現就是android.view.PhoneWindow，好傢伙，隱藏的夠深的，那麼請移駕，謝謝～

原始碼-3：PhoneWindow#superDispatchTouchEvent相關程式碼

// This is the top-level view of the window, containing the window decor.
private DecorView mDecor;
@Override
public boolean superDispatchTouchEvent(MotionEvent event) {
    return mDecor.superDispatchTouchEvent(event);
}
複製程式碼

到這裡邏輯就清晰了吧！雖然程式碼只有一行，但已經足以說明問題了，此處具體邏輯移交給DecorView(這就是我們前面說的視窗的頂級View-->ViewGroup)，即Activity#setContentView設定的View就是DecorView的子View。目前事件傳遞到了DecorView這裡，由於DecorVieW即成自FrameLayout且是父View，那麼得出結論--最終事件會傳遞給View，到這一步並不是我們的重點，事件如何通過頂級View進行傳遞消費才是我們的重頭戲，請繼續，謝謝～

2.2 頂級View對點選事件的分發過程

關於點選事件如何在View中進行分發，上面已經做了描述，這裡就直接上ViewGroup原始碼，原始碼如下：

dispatchTouchEvent方法內容較多分如下幾個片段說明：

原始碼-4：ViewGroup#dispatchTouchEvent——攔截邏輯處理

// 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();
}
// 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;
}
複製程式碼
  1. 是否攔截條件：事件型別為ACTION_DOWN || mFirstTouchTarget != null;
  2. mFirstTouchTarget：每次開始(ACTION_DOWN)都會被初始化為null,當事件由ViewGroup的子元素成功處理時，它指向子元素；
  3. 當事件由ViewGroup攔截時，條件mFirstTouchTarget != null不成立，即當ACTION_MOVE和 ACTION_UP事件到來時，由於第一條攔截條件不滿足，則onInterceptTouchEvent不再呼叫：應證了一旦當前View攔截事件，那麼同一事件序列的其它事件都不再進行攔截校驗，直接交給它處理。
  4. FLAG_DISALLOW_INTERCEPT標記位：這個標記位一旦設定後(requestDisallowInterceptTouchEvent)，ViewGroup將無法攔截除了ACTION_DOWN以外的其它點選事件（ACTION_DOWN事件會重置此標記位,將導致子View中設定的這個標記位無效）。
  5. 面對ACTION_DOWN事件時，ViewGroup總是會呼叫自己的onInterceptTouchEvent方法來詢問自己是否要攔截事件，這一點從上面的原始碼中可以看出來。

原始碼-5：ViewGroup#dispatchTouchEvent——初始化

// 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);//重置 mFirstTouchTarget = null
    resetTouchState();//重置FLAG_DISALLOW_INTERCEPT標記位
}
複製程式碼

從上面的程式碼可以看出，ViewGroup會在ACTION_DOWN事件到來時會做重置狀態的操作，因此子View呼叫requestDisallowInterceptTouchEvent並不能影響ViewGroup對ACTION_DOWN事件的處理。

總結：

  1. ViewGroup決定攔截事件（ACTION_DOWN）後，那麼後續的點選事件將會預設交給它處理且不再呼叫它的onInterceptTouchEvent方法。
  2. FLAG_DISALLOW_INTERCEPT這個標誌的作用是讓ViewGroup不再攔截事件，當然前提是ViewGroup不攔截ACTION_DOWN事件。
  3. FLAG_DISALLOW_INTERCEPT為解決滑動衝突解決提供了新的思路。

原始碼-6：ViewGroup#dispatchTouchEvent——不攔截，遍歷子View

final int childrenCount = mChildrenCount;
if (newTouchTarget == null && childrenCount != 0) {
    final float x = ev.getX(actionIndex);
    final float y = ev.getY(actionIndex);
    // Find a child that can receive the event.
    // Scan children from front to back.
    final ArrayList<View> preorderedList = buildTouchDispatchChildList();
    final boolean customOrder = preorderedList == null
            && isChildrenDrawingOrderEnabled();
    final View[] children = mChildren;
    for (int i = childrenCount - 1; i >= 0; i--) {
        final int childIndex = getAndVerifyPreorderedIndex(
                childrenCount, i, customOrder);
        final View child = getAndVerifyPreorderedView(
                preorderedList, children, childIndex);

        // If there is a view that has accessibility focus we want it
        // to get the event first and if not handled we will perform a
        // normal dispatch. We may do a double iteration but this is
        // safer given the timeframe.
        if (childWithAccessibilityFocus != null) {
            if (childWithAccessibilityFocus != child) {
                continue;
            }
            childWithAccessibilityFocus = null;
            i = childrenCount - 1;
        }

        if (!canViewReceivePointerEvents(child)
                || !isTransformedTouchPointInView(x, y, child, null)) {
            ev.setTargetAccessibilityFocus(false);
            continue;
        }

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

        resetCancelNextUpFlag(child);
        if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {//*子元素呼叫dispatchTouchEvent方法*
            // 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:mFirstTouchTarget
            newTouchTarget = addTouchTarget(child, idBitsToAssign);
            alreadyDispatchedToNewTouchTarget = true;
            break;
        }

        // The accessibility focus did not handle the event, so clear
        // the flag and do a normal dispatch to all children.
        ev.setTargetAccessibilityFocus(false);
    }
    if (preorderedList != null) preorderedList.clear();
    //...
}
複製程式碼

原始碼-7：ViewGroup#dispatchTouchEvent——子View下發主要邏輯呼叫

/**
 * Transforms a motion event into the coordinate space of a particular child view,
 * filters out irrelevant pointer ids, and overrides its action if necessary.
 * If child is null, assumes the MotionEvent will be sent to this ViewGroup instead.
 */
private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
        View child, int desiredPointerIdBits) {
    final boolean handled;

    // Canceling motions is a special case.  We do not 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是否能夠接收點選事件有以下兩點衡量：

  • 子元素是否在播放動畫
  • 點選事件的座標是否落在子元素的區域內

上面這部分程式碼說明的是ViewGroup不攔截情況下，事件向子View下發的過程.即主要呼叫方法為dispatchTransformedTouchEvent，它的內部實際上呼叫的就是子元素的dispatchTouchEvent方法(可通過上面的原始碼-7看得出來).通過具體分析可看出，如果child.dispatchTouchEvent(event)返回true，那麼mFirstTouchTarget(addTouchTarget方法內部操作)就會被賦值同時跳出for迴圈,這裡是否對mFirstTouchTarget賦值，將會影響ViewGroup的攔截策略，如下所示：

原始碼-8：ViewGroup#dispatchTouchEvent——賦值mFirstTouchTarget

/**
 * Adds a touch target for specified child to the beginning of the list.
 * Assumes the target child is not already present.
 */
private TouchTarget addTouchTarget(@NonNull View child, int pointerIdBits) {
    final TouchTarget target = TouchTarget.obtain(child, pointerIdBits);
    target.next = mFirstTouchTarget;
    mFirstTouchTarget = target;
    return target;
}
複製程式碼

mFirstTouchTarget如果為null,將會預設攔截接下來同一序列的所有事件。（不做二次攔截校驗）

遍歷所有子元素，都沒有處理包含兩種情況：

  1. ViewGroup沒有子元素;
  2. 子元素處理了點選事件，但是所有的子元素都沒有消耗事件。

此時ViewGroup將會呼叫super.dispatchTouchEvent(evet),這一點可以從上述原始碼-8可以看出，很顯然這裡ViewGroup繼承自View,所以這裡就轉到View的dispatchTouchEvent方法，即點選事件交由View處理，那麼請繼續看下面的分析。

2.3 View對點選事件的處理過程

View（不包含ViewGroup）對點選事件的處理稍微簡單，它沒有onInterceptTouchEvent方法且無法向下傳遞事件，只能自己處理，請看它的dispatchTouchEvent方法，如下：

原始碼-9：View#dispatchTouchEvent——View點選事件處理

/**
* Pass the touch screen motion event down to the target view, or this
* view if it is the target.
*
* @param event The motion event to be dispatched.
* @return True if the event was handled by the view, false otherwise.
*/
public boolean dispatchTouchEvent(MotionEvent event) {
// If the event should be handled by accessibility focus first.
//...
boolean result = false;
//...
if (onFilterTouchEventForSecurity(event)) {
    if ((mViewFlags & ENABLED_MASK) == ENABLED && handleScrollBarDragging(event)) {
        result = true;
    }
    //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;
    }
}
//...
return result;
}
複製程式碼

從上面的程式碼可以看出：OnTouchListener的onTouch比onTouchEvent(event)優先順序高，如果設定了OnTouchListener且mOnTouchListener.onTouch返回true那麼onTouchEvent(event)將不會呼叫,反之將會呼叫onTouchEvent(event),見下文：

原始碼-10：View#onTouchEvent——點選事件具體處理

public boolean onTouchEvent(MotionEvent event) {
final float x = event.getX();
final float y = event.getY();
final int viewFlags = mViewFlags;
final int action = event.getAction();
	
final boolean clickable = ((viewFlags & CLICKABLE) == CLICKABLE
    || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
    || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE;
	
if ((viewFlags & ENABLED_MASK) == DISABLED) {
	if (action == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
	    setPressed(false);
	}
mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
	// A disabled view that is clickable still consumes the touch
	// events, it just does not respond to them.
	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) {
	            // take focus if we do not 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;
	
	//...
	   	}
	
	return true;
	}
	
	return false;
}
複製程式碼

從上面的程式碼看出:影響事件的消耗因素有兩個：CLICKABLE和LONG_CLICKABLE只要有一個為true,那麼它就會消耗這個事件，即onTouchEvent方法返回true，實際呼叫方法為performClick();,在其內部呼叫OnClickListener#onClick方法。

到此點選事件的分發機制的原始碼分析就完了，但是Android 的學習才剛開始，還有很長的路要走，下面附上從別處盜來的圖，覺得不錯可以看下

2.4 View事件分發流程圖示例圖

事件分發流程圖

參考相關文章與相關書籍

Android 事件分發

Android事件分發機制解析

書籍：任玉剛的《Android開發藝術探索》

若果您覺得寫得還不錯的話，請抬手點個贊吧?。

相關文章