第3章 View的事件體系

一、View基礎知識

1. View 的位置參數

left、right、top、bottom

View在平移的過程中，top和left表示的是原始左上角的位置信息，值不會發生改變，發生改變的是x、y、translationX和translationY這四個參數

2. MotionEvent 和 TouchSlop

1）MotionEvent：在手指觸摸後產生的一系列事件

• ACTION_DOWN
• ACTION_MOVE
• ACTION_UP

通過getX/getY 返回相對於當前VIew的左上角的x和y座標

通過getRawX/getRawY 返回相對於屏幕左上角的x和y座標

2）TouchSlop：是系統所能識別的被認爲是滑動的最小距離

獲取這個常量：ViewConfiguration.get(getContext()).getScaledTouchSlop()

3. VelocityTracker 、GestureDetector 和 Scroller

1）VelocityTracker：速度追蹤，追蹤手指在滑動過程中的速度

• 在View 的onTouchEvent中追蹤當前單擊事件的速度

VelocityTracker velocityTracker = VelocityTracker.obtain();
VelocityTracker.addMovement(event);

• 先計算速度再獲取速度

VelocityTracker.computeCurrentVelocity(1000); //1000像素
int xVelocity = (int)velocityTracker.getXVelocity();

• 速度指的是一段時間內手指所滑過的像素數
• 不需要是用clear重置並回收

VelocityTracker.clear();
VelocityTracker.recycle();

2）GestureDetector：手勢檢測，用於輔助用戶的單擊、滑動、長按、雙擊等行爲

• 創建一個GestureDetector對象並實現OnGestureListener接口，還可以實現OnDoubleTaoListener 從而監聽雙擊行爲

GestureDetector mGestureDetector = new GestureDetector(this);
mGestureDetector.setIsLongpressEnabled(false);//解決長按屏幕無法拖動現象

• 接管目標View的onTouchEvent方法

boolean consume = mGestureDetector.onTouchEvent(event);
return consume;

• 做完上面兩步，就可以有選擇地實現OnGestureListener 和 OnDoubleTaoListener中的方法：onSingleTapUp(單擊)、onFling(滑動)、onScroll(拖動)、onLongPress(長按)、onDoubleTap(雙擊)等

建議：監聽滑動相關，建議自己在onTouchEvent中實現，雙擊行爲，建議使用GestureDetector

3）Scroller：彈性滑動對象，用於實現View的彈性滑動

使用View的scrollTo/scrollBy 方法進行滑動時，其滑動效果是瞬間完成的，這時就可以用Scroller來實現有過渡效果的滑動

Scroller需要和View的computeScroll方法配合使用，典型代碼如下：

Scroller scroller = new Scroller(mContext);

// 緩慢滾動到指定位置
private void smoothScrollTo(int destX, int destY) {
  int scrollX = getScrollX();
  int delta = destX - scrollX;
  // 1000ms內滑向destX，效果是慢慢滑動
  scroller.starlScroll(scrollX, 0, delta, 0, 1000);
  invalidate();
}

@override
public void computeScroll() {
  if (scroller.computeScrollOffset) {
    scrollTo(scroller.getCurrX(), scroller.getCurrY());
    postInvalidate();
  }
}

二、View的滑動

3種方式

1. 使用scrollTo/scrollBy

• scrollBy 實際也是基於 scrollTo實現，前者基於當前位置相對滑動，後者基於所傳遞參數絕對滑動
• mScrollX 總是等於View左邊緣和View內容左邊緣在水平方向的距離，可通過getScrollX獲取
• mScrollY 總是等於View上邊緣和View內容上邊緣在豎直方向的距離，可通過getScrollY獲取
• scrollBy 和 scrollTo 只能改變View內容的位置而不能改變View在佈局中的位置
• mScrollX 和 mScrollY 的單位爲像素，右移上移爲正，反之爲負

2. 使用動畫

• View動畫的 translationX 和 translationY，注意View動畫是對View的影響做操作，並不能真正改變View的位置參數，包括寬/高，並且如果希望動畫結束後狀態保留還要設置 fillAfter爲true
• 屬性動畫，Android3.0以上才支持，真正改變屬性

ObjectAnimator.ofFloat(targetView, "translationX", 0, 100).setDuration(100).start();

注意：使用View動畫可能帶來問題，平移後的View將無法響應點擊事件，因爲點擊事件實在View的初始區域註冊的

3. 改變佈局參數

改變LayoutParams

MarginLayoutParams params = (MarginLaoutParams)mButton.getLayoutParams();
params.width += 100;
params.laftMargin += 100;
mButton.requestLayout();

4. 各種滑動方式比對

• scrollTo/scrollBy：操作簡單，適合對View內容的滑動
• 動畫：操作簡單，適用於沒有交互的View和實現複雜的動畫效果
• 改變佈局參數：操作稍微複雜，適用於有交互的View

三、彈性滑動

1. 使用Scroller

Scroller scroller = new Scroller(mContext);

// 緩慢滾動到指定位置
private void smoothScrollTo(int destX, int destY) {
  int scrollX = getScrollX();
  int delta = destX - scrollX;
  // 1000ms內滑向destX，效果是慢慢滑動
  scroller.starlScroll(scrollX, 0, delta, 0, 1000);
  invalidate();
}

@override
public void computeScroll() {
  if (scroller.computeScrollOffset) {
    scrollTo(scroller.getCurrX(), scroller.getCurrY());
    postInvalidate();
  }
}

再看一下computeScrollOffset方法的實現：

public boolean computeScrollOffset() {
  int timePassed = (int)(AnimationUtils.currentAnimationTImeMills() - mStartTime);
  if (timePassed < mDuration) {
    switch (MODE) {
      case SCROLL_MODE:
        final float x = mInterpolator.getInterpolation(timePassed * mDurationReciprocal);
        mCurrX = mStartX + Math.round(x * mDeltaX);
        mCurrY = mStartY + MAth.round(x * mDeltaX);
        break;
        ···
    }
}
  return true;
}

上面是Scroller的典型使用方法

工作原理：

• 構造一個Scroller對象並調用它的 startScroll 方法時，Scroller內部其實什麼也沒做，只是保存了我們傳遞的幾個參數；
• 然後調用invalidate方法會導致VIew重繪；
• 在VIew 的draw方法中又會去調用 computeScroll 方法，computeScroll方法在View中是一個空實現，因此需要我們自己去實現，computeScrollOffset 中，每一次重繪距滑動起始時間都會有一個時間間隔，通過這個時間間隔Scroller就可以得到當前VIew的滑動位置，computeScroll中我們去向Scroller獲取當前的scrollX 和 scrollY，然後通過scrollTo滑動；
• 接着調用postInvalidate 進行第二次重繪；
• 這一次重繪和第一次一樣，還是會導致computeScroll被調用，繼續向Scroller獲取當前的scrollX 和 scrollY並滑動，如此反覆，直至滑動結束。

以上，View的每一次重繪都會導致VIew進行小幅度的滑動，而多次的小幅度滑動就組成了彈性滑動，同時整個過程對View沒有絲毫引用，也沒有內部計時器

2. 使用動畫

基本實現：

ObjextAnimator.odFloat(targetView, "translationX", 0, 100).setDuration(100).start();

模仿Scroller實現：

final int StartX = 0;
final int deltaX = 100;
ValueAnimator animator = ValueAnimator.ofInt(0, 1).setDuration(1000);
animator.addUppdateListener(new AnimatorUpdateListener() {
  @override
  public void onAnimatorUpdate(ValueAnimator animator) {
    float duration = animator.getAnimatedFraction();
    mButton.scrollTo(startX + (int)(deltaX * fraction), 0);
  }
}) 

上述實現本質上沒有作用於任何對象，只是在1000ms內在動畫的每一幀獲取動畫完成比例，根據這個比例計算出VIew要滑動的距離，針對VIew內容而非VIew本身

3. 使用延時策略

1）Handler/postDelay

大約1000ms內將VIew向左移動100像素

private static final int MESSAGE_SCROLL_TO = 1;
private static final int FRAME_COUNT = 30;
private static final int DELAYED_TIME = 30;

private int mCount = 0;

@SuppressLint("HandlerLeak") 
private Handler mHandler = new Handler() {
  public void handleMaeeage(Messaeg msg) {
    switch(msg.what) {
      case Message_SCROLL_TO: {
        mCount ++;
        if (mCount <= FRAME_COUNT) {
          float fraction = mCount / (float) FRAME_COUNT;
          int scrollX = (int)(fraction * 100);
          mButton.scrollTo(scrollX, 0);
          mHandler.sendEmptyMessageDelayd(MESSAGE_SCROLL_TO, DELAYED_TIME);
        }
        break;
			}
      default:
        break;
    }
  };
};

2）Thread/sleep

四、View的事件分發機制

參考：https://www.gcssloop.com/customview/dispatch-touchevent-theory

http://wuxiaolong.me/2015/12/19/MotionEvent/

1. 傳遞規則

1）三個主要方法

類型	相關方法	Activity	VIewGroup	View
事件分發	dispatchTouchEvent	✔️	✔️	✔️
事件攔截	onInterceptTouchEvent	❌	✔️	❌
事件消費	onTouchEvent	✔️	✔️	✔️

• Activity 作爲原始的事件分發者，如果 Activity 攔截了事件會導致整個屏幕都無法響應事件，這肯定不是我們想要的效果。
• View最爲事件傳遞的最末端，要麼消費掉事件，要麼不處理進行回傳，根本沒必要進行事件攔截。

三個事件關係僞代碼：

public Boolean dispatchTouchEvent(MotionEvent ev) {
  boolean consume = false;
  if (onInterceptTouchEvent(ev)) {
    consume = onTouchEvent(ev);
  } else {
    consume = child.dispatchTouchEvent(ev);
  }
  return consume;
}

2）事件傳遞順序

事件收集之後最先傳遞給 Activity， 然後依次向下傳遞，大致如下：

Activity －> PhoneWindow －> DecorView －> ViewGroup －> ... －> View

如果最後分發到View，如果這個View也沒有處理事件怎麼辦，那麼這個事件會按照反方向回傳，最終傳回給Activity，如果最後 Activity 也沒有處理，本次事件纔會被拋棄:

Activity <－ PhoneWindow <－ DecorView <－ ViewGroup <－ ... <－ View

3）onTouchEvent中回調順序

• 單擊事件(onClickListener) 需要兩個兩個事件(ACTION_DOWN 和 ACTION_UP )才能觸發，如果先分配給onClick判斷，等它判斷完，用戶手指已經離開屏幕，黃花菜都涼了，定然造成 View 無法響應其他事件，應該最後調用。(最後)
• 長按事件(onLongClickListener) 同理，也是需要長時間等待才能出結果，肯定不能排到前面，但因爲不需要ACTION_UP，應該排在 onClick 前面。(onLongClickListener > onClickListener)
• 觸摸事件(onTouchListener) 如果用戶註冊了觸摸事件，說明用戶要自己處理觸摸事件了，這個應該排在最前面。(最前)
• View自身處理(onTouchEvent) 提供了一種默認的處理方式，如果用戶已經處理好了，也就不需要了，所以應該排在 onTouchListener 後面。(onTouchListener > onTouchEvent)

所以事件的調度順序應該是 onTouchListener > onTouchEvent > onLongClickListener > onClickListener

4）一些結論

• 同一個事件序列從手指接觸屏幕到離開屏幕，以down開始，中間含有數目不定的move，最終以up結束
• 正常情況下，一個事件序列只能被一個View攔截並消耗
• 某個View一旦開始處理事件，如果它不消耗ACTION_DOWN事件(onTouchEvent返回false)，那麼同一事件序列中的其他事件都不會再交給它處理，並將事件重新交給它的父元素去處理
• 如果View不消耗除ACTION_DOWN以外的其他事件，那麼這個點擊事件會消失，父元素的onTouchEvent不會調用，最終這些消失的點擊事件會傳遞給Activity處理
• ViewGroup默認不攔截任何事件
• View沒有onInterceptTouchEvent
• View的onTouchEvent默認會消耗事件，除非它是不可點擊的
• View的enable不影響onTouchEvent返回值

……

2. 事件分發機制源碼解析

參考：https://www.gcssloop.com/customview/dispatch-touchevent-source

1）Activity 對點擊事件的分發過程

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

事件開始交給Activity中的WIndow進行分發，返回flase意味着事件沒人處理，那麼Activity的 onTouchEvent會被調用

Window是一個抽象類，superDispatchTouchEvent也是抽象方法，其實現類是 PhoneWindow，PhoneWindow中處理：

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

PhoneWindow會將事件傳遞給DecorView，DecorView就說當前界面的底層容器（即setContentView所設置的View的父容器）

public class DecorView extends FrameLayout implements RootViewSurfaceTaker, WindowCallbacks

DecorView 繼承自FrameLayout且是Activity根View的父View，所以事件到這裏已經傳遞給頂級View了，即在Activity中通過setContentView所設置的VIew，頂級View也叫根View，一般是VIewGroup

2）頂級View（ViewGroup）對事件的分發過程

事件達到頂級View（一般是一個ViewGroup）後，會調用ViewGroup的dispatchTouchEvent，主要工作：

• 判斷自身是否需要(詢問 onInterceptTouchEvent 是否攔截)，如果需要，調用自己的 onTouchEvent
• 自身不需要或者不確定，則詢問 ChildView ，一般來說是調用手指觸摸位置的 ChildView
• 如果子 ChildView 不需要則調用自身的 onTouchEvent

源碼分析：

public boolean dispatchTouchEvent(MotionEvent ev) {
  	// 調試用
    if (mInputEventConsistencyVerifier != null) {
        mInputEventConsistencyVerifier.onTouchEvent(ev, 1);
    }

  	// 判斷事件是否是針對可訪問的焦點視圖(很晚才添加的內容，個人猜測和屏幕輔助相關，方便盲人等使用設備)
    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;

        // 處理第一次ACTION_DOWN.
        if (actionMasked == MotionEvent.ACTION_DOWN) {
            // 清除之前所有的狀態
            cancelAndClearTouchTargets(ev);
            resetTouchState();
        }

        // 檢查是否需要攔截.
        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); 						// 恢復操作，防止被更改
            } else {
                intercepted = false;
            }
        } else {
          	// 沒有目標來處理該事件，而且也不是一個新的事件事件(ACTION_DOWN), 進行攔截。
            intercepted = true;
        }

      	// 判斷事件是否是針對可訪問的焦點視圖
        if (intercepted || mFirstTouchTarget != null) {
            ev.setTargetAccessibilityFocus(false);
        }

        // 檢查事件是否被取消(ACTION_CANCEL).
        final boolean canceled = resetCancelNextUpFlag(this)
                || actionMasked == MotionEvent.ACTION_CANCEL;

        final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0;
        TouchTarget newTouchTarget = null;
        boolean alreadyDispatchedToNewTouchTarget = false;
      	
      	// 如果沒有取消也沒有被攔截	(進入事件分發)
        if (!canceled && !intercepted) {

            // 如果事件是針對可訪問性焦點視圖，我們將其提供給具有可訪問性焦點的視圖。
          	// 如果它不處理它，我們清除該標誌並像往常一樣將事件分派給所有的 ChildView。 
            // 我們檢測並避免保持這種狀態，因爲這些事非常罕見。
            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();
                final int idBitsToAssign = split ? 1 << ev.getPointerId(actionIndex)
                        : TouchTarget.ALL_POINTER_IDS;

                // 清除此指針ID的早期觸摸目標，防止不同步。
                removePointersFromTouchTargets(idBitsToAssign);

                final int childrenCount = mChildrenCount;
                if (newTouchTarget == null && childrenCount != 0) {
                    final float x = ev.getX(actionIndex);	// 獲取觸摸位置座標
                    final float y = ev.getY(actionIndex);
                    // 查找可以接受事件的 ChildView
                    final ArrayList<View> preorderedList = buildOrderedChildList();
                    final boolean customOrder = preorderedList == null
                            && isChildrenDrawingOrderEnabled();
                    final View[] children = mChildren;
                  	// ▼注意，從最後向前掃描
                    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 (childWithAccessibilityFocus != null) {
                            if (childWithAccessibilityFocus != child) {
                                continue;
                            }
                            childWithAccessibilityFocus = null;
                            i = childrenCount - 1;
                        }

                      	// 檢查View是否允許接受事件(即處於顯示狀態(VISIBLE)或者正在播放動畫)
                      	// 檢查觸摸位置是否在View區域內
                        if (!canViewReceivePointerEvents(child)
                                || !isTransformedTouchPointInView(x, y, child, null)) {
                            ev.setTargetAccessibilityFocus(false);
                            continue;
                        }

                      	// getTouchTarget 中判斷了 child 是否包含在 mFirstTouchTarget 中
                      	// 如果有返回 target，如果沒有返回 null 
                        newTouchTarget = getTouchTarget(child);
                        if (newTouchTarget != null) {
                            // ChildView 已經準備好接受在其區域內的事件。
                            newTouchTarget.pointerIdBits |= idBitsToAssign;
                            break;	// ◀︎已經找到目標View，跳出循環
                        }

                        resetCancelNextUpFlag(child);
                        if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
                            mLastTouchDownTime = ev.getDownTime();
                            if (preorderedList != null) {
                                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;
                        }
                      
                        ev.setTargetAccessibilityFocus(false);
                    }
                    if (preorderedList != null) preorderedList.clear();
                }

                if (newTouchTarget == null && mFirstTouchTarget != null) {
                    // 沒有找到 ChildView 接收事件
                    newTouchTarget = mFirstTouchTarget;
                    while (newTouchTarget.next != null) {
                        newTouchTarget = newTouchTarget.next;
                    }
                    newTouchTarget.pointerIdBits |= idBitsToAssign;
                }
            }
        }

        // 分發 TouchTarget
        if (mFirstTouchTarget == null) {
            // 沒有 TouchTarget，將當前 ViewGroup 當作普通的 View 處理。
            handled = dispatchTransformedTouchEvent(ev, canceled, null,
                    TouchTarget.ALL_POINTER_IDS);
        } else {
            // 分發TouchTarget，如果我們已經分發過，則避免分配給新的目標。 
          	// 如有必要，取消分發。
            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;
            }
        }

        // 如果需要，更新指針的觸摸目標列表或取消。
        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;
}

3）View對點擊事件的處理過程

事件調度：onTouchListener > onTouchEvent > onLongClickListener > onClickListene

public boolean dispatchTouchEvent(MotionEvent event) {
    ...
    boolean result = false;	// result 爲返回值，主要作用是告訴調用者事件是否已經被消費。
    if (onFilterTouchEventForSecurity(event)) {
        ListenerInfo li = mListenerInfo;
        /** 
         * 如果設置了OnTouchListener，並且當前 View 可點擊，就調用監聽器的 onTouch 方法，
         * 如果 onTouch 方法返回值爲 true，就設置 result 爲 true。
         */
        if (li != null && li.mOnTouchListener != null
                && (mViewFlags & ENABLED_MASK) == ENABLED
                && li.mOnTouchListener.onTouch(this, event)) {
            result = true;
        }
      
        /** 
         * 如果 result 爲 false，則調用自身的 onTouchEvent。
         * 如果 onTouchEvent 返回值爲 true，則設置 result 爲 true。
         */
        if (!result && onTouchEvent(event)) {
            result = true;
        }
    }
    ...
    return result;
}

onTouchEvent中

public boolean onTouchEvent(MotionEvent event) {
    ...
    final int action = event.getAction();
  	// 檢查各種 clickable
    if (((viewFlags & CLICKABLE) == CLICKABLE ||
            (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE) ||
            (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE) {
        switch (action) {
            case MotionEvent.ACTION_UP:
                ...
                removeLongPressCallback();  // 移除長按
                ...
                performClick();             // 檢查單擊
                ...
                break;
            case MotionEvent.ACTION_DOWN:
                ...
                checkForLongClick(0);       // 檢測長按
                ...
                break;
            ...
        }
        return true;                        // ◀︎表示事件被消費
    }
    return false;
}

注意：

• 不論 View 自身是否註冊點擊事件，只要 View 是可點擊的就會消費事件
• 事件是否被消費由返回值決定，true 表示消費，false 表示不消費，與是否使用了事件無關

五、View的滑動衝突

1. 常見的滑動衝突場景

• 場景1——外部滑動方向和內部滑動方向不一致
• 場景2——外部滑動方向和內部滑動方向一致
• 場景3——上面兩種情況的嵌套

2. 滑動衝突的處理規則

• 對於場景1，用戶左右滑動時，讓外部的View攔截事件（假設外部是左右滑動的），用戶上下滑動時，讓內部View攔截事件，判斷用戶是左右還是上下滑動可以依據滑動路徑的角度、速度、距離差等
• 對於場景2，一般在業務上找突破點，根據業務規定在某種狀態時需要哪一部分View響應用戶的滑動
• 場景3 同 場景2

3. 滑動衝突的解決方式（待深入學習）

1）外部攔截法

點擊事件都先經過父容器的攔截處理，如果父容器需要此事就攔截，不需要就不攔截，符合點擊事件的分發機制

重寫onInterceptTouchEvent 方法：

• ACTION_DOWN 這個事件父容器必須返回false
• ACTION_MOVE 這個事件根據需求來決定是否攔截
• ACTION_UP 事件，必須返回false

2）內部攔截法

指父容器不攔截任何事件，所有的事件都傳遞給子元素，如果子元素需要此事件就直接消耗掉，否則就交由父容器進行處理，和事件分發機制不一致，需要配合 requestDisallowInterceptTouchEvent 方法