目錄
2）頂級View（ViewGroup）的分發過程：分發規則的僞代碼來源的詳細說明
3)view的處理過程：主要是onTouchListener、OnTouchEvent、onClick的關係
View的事件分發，指的是 在多層級ViewGroup/View中對觸摸事件的分發。觸摸事件即MotionEvent，系統要把它傳遞給具體的view取處理。
事件序列，從Down開始，到多個Move，再到Up結束，就是一個事件序列。
一、事件分發
1、事件傳遞規則
事件分發主要3個方法：
public boolean dispatchTouchEvent(MotionEvent ev)，負責事件的傳遞分發，事件到達view時一定回調此方法。返回值表示是否消費此事件，受onTouchEvent和子view的dispatchTouchEvent返回值影響。
public boolean onInterceptTouchEvent(MotionEvent ev)，用於判斷是否攔截事件，也是返回值的含義。在dispatchTouchEvent內部調用。view攔截了某個事件，那後續這一事件序列都會默認攔截，不再調用此方法。
public boolean onTouchEvent(MotionEvent event)，用於處理事件，返回值表示是否消費此事件。
在dispatchTouchEvent內部調用。如果不消耗某一事件，那當前view不再接受同一事件序列的事件。 注意，如果設置了onTouchListener且onTouch返回值是true，那麼不會調用onTouchEvent(會給父view處理)。onTouchEvent中發現設置了onClickListener那onCLick會被調用。
三者關係：事件到達view時，會調用dispatchTouchEvent，然後內部調用onInterceptTouchEvent判斷是否攔截，如果不攔截就調用子view的dispatchTouchEvent。用僞代碼表示：
public boolean dispatchTouchEvent(MotionEvent event){
boolean consumed;
if (onIntercepterTouchEvent(event)){
consumed = onTouchEvent(event);
}else {
consumed = child.dispatchTouchEvent(event);
}
return consumed;
}
事件發生時，傳遞順序是：Activity-Window-View。如果所有activity的所有子View都不處理，那麼最終Activity的onTouchEvent會被調用。
另外幾點規則：
1）ViewGroup默認不攔截任何事件。即onInterceptTouchEvent方法返回false
2) View沒有onInterceptTouchEvent（）
3）View的onTouchEvent默認會消耗事件（返回True）,除非它是不可點擊的——-clickable 和 longClickable同時爲false.注意：View的longClickable默認都爲false,clickable要根據控件屬性判斷。
4）View的enable屬性不影響onTouchEvent的默認返回值。（哪怕是disable）
5) 事件總是先傳遞給父元素，然後由父元素分發給子View.通過requestDisallowIntercept()分發可以在子元素中干預父元素的事件分發過程，但是ACTION_DOWN事件除外。
2、源碼分析
1）Activity的分發過程：
public boolean dispatchTouchEvent(MotionEvent ev) {
if (ev.getAction() == MotionEvent.ACTION_DOWN) {
onUserInteraction();
}
//調用window的superDispatchTouchEvent來分發。（實際window只有一個實現PhoneWindow）
if (getWindow().superDispatchTouchEvent(ev)) {
return true;
}
//如果window內所有view沒有消費，就會走acticity的onTouchEvent
return onTouchEvent(ev);
}
看PhoneWindow：
// This is the top-level view of the window, containing the window decor.
private DecorView mDecor;
@Override
public boolean superDispatchTouchEvent(MotionEvent event) {
//mDecor是DecorView
return mDecor.superDispatchTouchEvent(event);
}
看DecorView：
public boolean superDispatchTouchEvent(MotionEvent event) {
return super.dispatchTouchEvent(event);
}
繼續跟就到了ViewGroup的dispatchTouchEvent。DecorView內部的子View實際就是StatusBar、ActionBar、ContentView這些。
2）頂級View（ViewGroup）的分發過程：分發規則的僞代碼來源的詳細說明
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
...
boolean handled = false;
if (onFilterTouchEventForSecurity(ev)) {
final int action = ev.getAction();
final int actionMasked = action & MotionEvent.ACTION_MASK;
// Handle an initial down.
// 事件DOWN時會清除 子view的 "不允許父view攔截"的flag。因爲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;
//是Down 或者 MOVE、UP但沒有攔截DOWN讓子View處理了（mFirstTouchTarget != null）
if (actionMasked == MotionEvent.ACTION_DOWN
|| mFirstTouchTarget != null) {
final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
if (!disallowIntercept) {
//如果子View沒有不允許攔截，就正常詢問自己是否攔截
intercepted = onInterceptTouchEvent(ev);
ev.setAction(action); // restore action in case it was changed
} else {
//如果子View設置了不允許攔截，就不攔截
intercepted = false;
}
} else {
// There are no touch targets and this action is not an initial down
// so this view group continues to intercept touches.
//不是Down且子view沒有處理，就是說本身攔截了DOWN，那後續的MOVE、UP就不再調用onInterceptTouchEvent詢問，直接攔截。
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 (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;
//就遍歷子view
for (int i = childrenCount - 1; i >= 0; i--) {
final int childIndex = getAndVerifyPreorderedIndex(
childrenCount, i, customOrder);
final View child = getAndVerifyPreorderedView(
preorderedList, children, childIndex);
...
//判斷子view能否接受事件：是否在播動畫、是否點擊在區域內
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);
//child不爲空就會調child.dispatchTouchEvent(event)
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();
//mFirstTouchTarget賦值，就是說child處理了事件
newTouchTarget = addTouchTarget(child, idBitsToAssign);
alreadyDispatchedToNewTouchTarget = true;
break;
}
...
}
if (preorderedList != null) preorderedList.clear();
}
if (newTouchTarget == null && mFirstTouchTarget != null) {
...
}
}
}
// Dispatch to touch targets.
//所有子View都沒處理事件
if (mFirstTouchTarget == null) {
// No touch targets so treat this as an ordinary view.
//那麼這裏穿的child是null，就是調用super.dispatchTouchEvent(event)，就是View.dispatchTouchEvent(event)
handled = dispatchTransformedTouchEvent(ev, canceled, null,
TouchTarget.ALL_POINTER_IDS);
} else {
...
}
...
}
...
return handled;
}
private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
View child, int desiredPointerIdBits) {
final boolean handled;
// Canceling motions is a special case. We don't 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) {
//如果所有子view都沒有處理，就調用View本身的分發
handled = super.dispatchTouchEvent(event);
} else {
//分發到子view，同樣開始遍歷
handled = child.dispatchTouchEvent(event);
}
event.setAction(oldAction);
return handled;
}
...
3)view的處理過程：主要是onTouchListener、OnTouchEvent、onClick的關係
public boolean dispatchTouchEvent(MotionEvent event) {
...
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)) {
//設置了OnTouchListener且onTouch返回 true，則看下面一行
result = true;
}
//設置了OnTouchListener且onTouch返回 true就不會走onTouchEvent了
if (!result && onTouchEvent(event)) {
result = true;
}
}
...
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();
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 doesn't respond to them.
//即使disabled，也是可點擊也會消費事件
return clickable;
}
if (mTouchDelegate != null) {
if (mTouchDelegate.onTouchEvent(event)) {
return true;
}
}
if (clickable || (viewFlags & TOOLTIP) == TOOLTIP) {
switch (action) {
case MotionEvent.ACTION_UP:
...
// 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)) {
//走onClick了
performClickInternal();
}
}
}
...
break;
case MotionEvent.ACTION_DOWN:
...
break;
case MotionEvent.ACTION_MOVE:
...
break;
}
return true;
}
return false;
}
二、滑動衝突
1、衝突場景
ViewGroup的滑動和子view的滑動有衝突。
外部橫向，裏面豎向，那就是看外部啥時候攔截。
外部裏面都是相同方向，那就要看具體的業務規則了。
2、解決原理
因爲ViewGroup的onInterceptTouchEvent默認是不攔截的，所以：
解決滑動衝突的要點：重寫onInterceptTouchEvent，根據衝突場景的規則來 判斷是否攔截，即isIntercept的賦值規則。其他代碼不動即可。
（還有個內部攔截法，用子view調用parent.requestDisallowInterceptTouchEvent(true)，就不讓parent攔截）
@Override
public boolean onInterceptTouchEvent(MotionEvent motionEvent) {
//解決滑動衝突
boolean isIntercept = false;
int x = (int) motionEvent.getX();
int y = (int) motionEvent.getY();
switch (motionEvent.getAction()) {
case MotionEvent.ACTION_DOWN:
//down不能攔截，因爲一攔截就都給你了。
mLastXIntercept = x;
mLastYIntercept = y;
break;
case MotionEvent.ACTION_MOVE:
//是橫向的滑動
boolean isHorizontal = Math.abs(x - mLastXIntercept) > Math.abs(y - mLastYIntercept);
//解決滑動衝突的要點：根據衝突場景的規則來 判斷是否攔截，即isHorizontal如果取值
if (isHorizontal) {
//此處一旦攔截，後面的ACTION就不會在調用onInterceptTouchEvent
isIntercept = true;
}
break;
case MotionEvent.ACTION_UP:
//up不能攔截，因爲攔截了沒啥意義。因爲如果前面攔截了Down，那自然Up也會給到。
//另外，如果只攔截了UP，那子view即使處理了其他事件，那也不會走onClick。
break;
}
Log.i(TAG, "onInterceptTouchEvent: isIntercept：" + isIntercept);
//此處要記錄下 攔截時的 開始的 觸摸點（僅用於下面onTouchEvent處理滑動使用）
mLastX = mLastXIntercept;
mLastY = mLastYIntercept;
mLastXIntercept = x;
mLastYIntercept = y;
return isIntercept;
}
3、舉個例子
之前寫的橫向滑動View：《Android進階之光》自定義ViewGroup實例：橫向滑動HorizontalView