Android事件分發機制是Android開發者必須瞭解的基礎，也是面試的常客，今天來就這源碼走一下事件分發流程。
事件的基礎
MotionEvent 有三個關鍵的事件，其他事件用的較少：
MotionEvent.ACTION_DOWN：手指按下事件
MotionEvent.ACTION_UP：手指彈起事件
MotionEvent.ACTION_MOVE：手指移動事件
二進制位運算(後面標誌位運算)
按位與（&）
位運算實質是將參與運算的數字轉換爲二進制，而後逐位對應進行運算。
按位與運算爲：兩位全爲1，結果爲1，即1&1=1，1&0=0，0&1=0，0&0=0。
例如51 & 5 -> 00110011 & 00000101 = 00000001 -> 51 & 5 = 1
特殊用法：
（1）與0相與可清零。
（2）與1相與可保留原值，可從一個數中取某些位。例如需要取10101110中的低四位，10101110 & 00001111 = 00001110，即得到所需結果。
按位或（|）
兩位只要有一位爲1，結果則爲1，即1|1=1，1|0=1，0|1=1，0|0=0。
特殊用法：
（1）與0相或可保留原值。
（2）與1相或可將對應位置1。例如，將X=10100000的低四位置1，使X | 00001111 = 10101111即可。
異或運算（^）
兩位爲“異”，即一位爲1一位爲0，則結果爲1，否則爲0。即1^1=1，1^0=0，0^1=0，0^0=1。
特殊用法：
使指定位翻轉：找一個數，對應X要翻轉的各位爲1，其餘爲0，使其與X進行異或運算即可。例如，X=10101110，使低四位翻轉，X ^ 00001111 = 10100001。
與0相異或保留原值。例如X ^ 00000000 = 10101110。
交換兩變量的值。（比藉助容器法、加減法效率高）原理：一個數對同一個數連續兩次進行異或運算，結果與這個數相等。
因此，交換方法爲：A = A ^ B，B = A ^ B，A = A ^ B。
取反（~）
將一個數按位取反，即~ 0 = 1，~ 1 = 0。
ViewGroup的相關事件有三個：onInterceptTouchEvent、dispatchTouchEvent、onTouchEvent。View的相關事件只有兩個：dispatchTouchEvent、onTouchEvent。
onInterceptTouchEvent 事件攔截，如果返回true，攔截事件，事件將不會在向下傳遞
dispatchTouchEvent 事件分發，向上或者下子控件分發
onTouchEvent 處理事件
Android事件傳遞流程：
事件都是從Activity.dispatchTouchEvent()開始傳遞
事件由父View傳遞給子View，ViewGroup可以通過onInterceptTouchEvent()方法對事件攔截，停止其向子view傳遞
如果事件從上往下傳遞過程中一直沒有被停止，且最底層子View沒有消費事件，事件會反向往上傳遞，這時父View(ViewGroup)可以進行消費，如果還是沒有被消費的話，最後會到Activity的onTouchEvent()函數。
如果View沒有對ACTION_DOWN進行消費，之後的其他事件不會傳遞過來，也就是說ACTION_DOWN必須返回true，之後的事件纔會傳遞進來,因爲mFirstTouchTarget這個是在ACTION_DOWN返回true的時候，纔會被賦值，也就是找到消費事件的view，具體流程，下面將會揭曉。
看看這個網上借的流程圖
事件分發的大致僞代碼：
public boolean dispatchTouchEvent(MotionEvent ev) {
boolean result = false; // 默認狀態爲沒有消費過
if (!onInterceptTouchEvent(ev)) { // 如果沒有攔截交給子View
result = child.dispatchTouchEvent(ev);
}
if (!result) { // 如果事件沒有被消費,詢問自身onTouchEvent
result = onTouchEvent(ev);
}
return result;
}來一段系統的源碼ViewGroup中的dispatchTouchEvent：
public boolean dispatchTouchEvent(MotionEvent ev) {
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);
}
boolean handled = false;
if (onFilterTouchEventForSecurity(ev)) {
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();
}
// 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;
}
// If intercepted, start normal event dispatch. Also if there is already
// a view that is handling the gesture, do normal event dispatch.
if (intercepted || mFirstTouchTarget != null) {
ev.setTargetAccessibilityFocus(false);
}
// Check for cancelation.
final boolean canceled = resetCancelNextUpFlag(this)
|| actionMasked == MotionEvent.ACTION_CANCEL;
// Update list of touch targets for pointer down, if needed.
final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0;
TouchTarget newTouchTarget = null;
boolean alreadyDispatchedToNewTouchTarget = false;
if (!canceled && !intercepted) {
// If the event is targeting accessiiblity focus we give it to the
// view that has accessibility focus and if it does not handle it
// we clear the flag and dispatch the event to all children as usual.
// We are looking up the accessibility focused host to avoid keeping
// state since these events are very rare.
View childWithAccessibilityFocus = ev.isTargetAccessibilityFocus()
? findChildWithAccessibilityFocus() : null;
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;
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)) {
// 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();
}
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;
}
}
}
// Dispatch to touch targets.
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 predecessor = null;
TouchTarget target = mFirstTouchTarget;
while (target != null) {
final TouchTarget next = target.next;
if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
handled = true;
} else {
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;
}說到這裏我們還需要了解一下另一個方法
@Override
public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {
if (disallowIntercept == ((mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0)) {
// We're already in this state, assume our ancestors are too
return;
}
if (disallowIntercept) {
mGroupFlags |= FLAG_DISALLOW_INTERCEPT;
} else {
mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
}
// Pass it up to our parent
if (mParent != null) {
mParent.requestDisallowInterceptTouchEvent(disallowIntercept);
}
}有過經驗的開發者肯定見過這個方法，這個方法就是子控件申請父控件是否攔截，以應對後續業務的處理。這個方法就是改變一個標誌位mGroupFlags，這個在父控件中可以控制是否對事件進行攔截，具體怎麼攔截，馬上揭曉。
好，回到源碼
if (actionMasked == MotionEvent.ACTION_DOWN) {
cancelAndClearTouchTargets(ev);
resetTouchState();
}
private void resetTouchState() {
clearTouchTargets();
resetCancelNextUpFlag(this);
mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
mNestedScrollAxes = SCROLL_AXIS_NONE;
}
看這裏，事件一開始就對mGroupFlags 標誌位進行了處理，剛剛已經說了，它可以直接控制是否攔截。
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;
}
} 這裏就可以看到如何控制的事件攔截，在用戶沒有調用requestDisallowInterceptTouchEvent（），對mGroupFlags這個標誌位進行改變的時候， (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0是不成立的，爲false，這個時候就會去調用onInterceptTouchEvent（），是否攔截，默認是不攔截的。如果攔截了，那麼事件就不會向子控件傳遞，而是自己的TouchEvent消費。
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 (childWithAccessibilityFocus != null) {
if (childWithAccessibilityFocus != child) {
continue;
}
｝這裏開始遍歷所有的子控件，canViewReceivePointerEvents(child) 和 !isTransformedTouchPointInView就是判斷依據，可以接受事件，還有當前事件必須在該控件上。dispatchTransformedTouchEvent 這個就是將事件交給子控件進行處理，如果事件被處理返回true，並在addTouchTarget()方法裏面對mFirstTouchTarget進行賦值，這個就是保存處理事件的子視圖。
if (mFirstTouchTarget == null) {
//沒有觸摸target,則由當前ViewGroup來處理
handled = dispatchTransformedTouchEvent(ev, canceled, null,
TouchTarget.ALL_POINTER_IDS);
}如果mFirstTouchTarget沒有值，沒有消耗事件，那麼事件就交給自己處理。
// 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;
if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
handled = true;
} else {
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;
}如果View消費ACTION_DOWN事件，那麼MOVE,UP等事件相繼開始執行。
來一個小小的總結
1)Android事件分發是先傳遞到ViewGroup，再由ViewGroup傳遞到View的。
2 )在ViewGroup中可以通過onInterceptTouchEvent方法對事件傳遞進行攔截，onInterceptTouchEvent方法返回true代表不允許事件繼續向子View傳遞，返回false代表不對事件進行攔截，默認返回false。
3 )子View中如果將傳遞的事件消費掉，ViewGroup中將無法接收到任何事件。
參考文章
http://blog.csdn.net/guolin_blog/article/details/9097463
瞭解更多，可以添加公衆號
