Android知識點<8>View 的事件體系

時間  2020-12-26
欄目 Android 简体版
原文   原文鏈接

轉載  ：

http://blog.csdn.net/zizidemenghanxiao/article/details/50184295

結論Tips

（1）同一個事件序列：是指從手指接觸屏幕的那一刻起，到手指離開屏幕的那一刻結束。

其中會有一個down，多個move，一個up事件。

（2）正常情況下，一個事件序列只能被一個VIew攔截且消耗，因爲一旦攔截，剩下的就都交給攔截的那個View了。不過可以採取特殊手段，比如說一個View將本該自己處理的事件通過onTouchEvent 強行傳遞給其他View處理。

（3）一個View一旦決定攔截，那剩下的事件序列都會給它，而且它的 onInterceptTouchEvent 就不會再被調用了。

（4）某個VIew一旦開始處理事件，也就是到了onTouchEvent的地步，如果它不消耗 ACTION_DOWN事件，也就是說onTouchEvent返回了false，那麼同一事件序列中的其他事件都不會再交給它來處理，並且事件將重新交給它的父元素去處理。就是說事件一旦交給一個VIew處理，他就必須消耗掉，不然同一事件序列中剩下的事件就不再交給它來處理了。

（5）（沒看懂這條）如果VIew不消耗除 ACTION_DOWN 以外的其他事件（就是說消耗了ACTION_DOWN，卻沒消耗其他的），那麼這個點擊事件會消失，此時父元素的 onTouchEvent 並不會被調用，並且當前View可以持續接到後續的事件，最終這些消失的點擊事件會傳遞給Activity處理。

（6）ViewGroup默認不攔截任何事件。Android源碼中ViewGroup的onInterceptTouchEvent 方法默認返回 false。

（7）View沒有 onInterceptTouchEvent 方法，一旦有點擊事件傳遞給它，那麼它的 onTouchEvent 方法就會被調用。

（8）View 的onTouchEvent 默認都會消耗事件（返回true），除非它是不可點擊的（clickable 和 longClickable 同時爲 false）。

View的longClickable 屬性默認都爲false，clickable 屬性要看具體的控件，比如Button爲true，TextView爲false。

（9）View的enable 屬性不影響 onTouchEvent 的默認返回值。哪怕一個View是disable狀態的，只要它的clickable 或者 longClickable 有一個爲true，那麼它的onTouchEvent 就返回ture。

（10）onClick會發生的前提是當前的View 是可點擊的，並且它收到了 down 和 up的事件。

（11）事件傳遞過程是由外向內的，通過 requestDisallowInterceptTouchEvent 方法可以在子元素中干預父元素的事件分發過程，就是下面的那個FLAG_DISALLOW_INTERCEPT標誌位，但是ACTION_DOWN事件除外。


點擊事件的分發過程由三個很重要的方法共同完成：


public boolean dispatchTouchEvent(MotionEvent ev)

用來進行事件的分發，dispatch派分。如果事件能夠傳遞給當前View，這個方法就一定會被調用，

返回結果受當前View的 onTouchEvent 和下級 View 的 dispatchTouchEvent 方法的影響，表示是否消耗當前事件。


public boolean onInterceptTouchEvent(MotionEvent event)

在 dispatchTouchEvent 方法的內部調用，用來判斷是否攔截某個事件，如果當前View 攔截了某個事件，那麼在同一個事件序列當中，此方法不會被再次調用，

返回結果表示是否攔截當前事件。true表示攔截。


public boolean onTouchEvent(MotionEvent event)

在 dispatchTouchEvent 方法中調用，用來處理點擊事件，

返回結果表示是否消耗當前事件，如果不消耗，則在同一個事件序列中，當前View再也無法接收到該事件的後續事件。

就是說如果消耗了down，還可以消耗move，up等，如果不消耗，後續的就都沒有了。

但如果不消耗，該事件序列就要交由上一層來處理。


一、View基礎知識


1、什麼是View：


View是一種界面層的控件的一種抽象，它代表了一個控件。
ViewGroup爲控件組。
View中也可以包含多個控件，形成控件樹。

ImageButton是一個View，LinearLayout是一個View，也是一個ViewGroup。


2、View的位置參數：


（1）視圖座標系：（子視圖在父視圖中的位置關係）

以父視圖的左上角爲原點。
在觸控事件MotionEvent中，通過getX（）、getY（）所獲得的座標就是視圖座標系中的座標。

View的位置對應View的四個屬性：top、left、right、button。
所以說View的寬高分別可以這樣表示：
width = right - left
height = bottom - top

獲取方式：getLeft（），getRight（），getTop（），getBottom（）。



從Android3.0開始，另外還有幾個參數：x、y、translationX 和 translationY。
x、y是VIew左上角的座標，translationX 和 translationY 是View左上角相對於父容器的偏移量。默認爲0。
且 x = left + translationX，y = top + translationY

是不是還是不清楚，就是說在View平移的過程中，top、left、right、button這四個值是不會變化的，是原始位置，變化的是x、y、translationX 和 translationY這四個參數。

（2）Android座標系（以屏幕的左上角爲原點）

系統提供了 getLocationOnScreen（intlocation[]）這樣的方法來獲取Android座標系中點的位置，即該視圖左上角在Android座標系中的座標。
另外在觸控事件MotionEvent中使用getRawX（）、getRawY（）方法所獲得的座標同樣是An座標系中的座標。

（3）總結獲取各種座標值的辦法：



屬於MotionEvent的：
getX（），getY（），（相對父容器的）
getRawX（），getRawY（）；（相對屏幕的）

屬於View自身的：
getTop（），getRight（），getTop（），getBottom（）。（相對父容器的）




3、MotionEvent 手指觸摸事件類型


ACTION_DOWN、ACTION_MOVE、ACTION_UP 就是這三個啦。

在這裏我們將常會獲取座標：
getX/getY：返回相對於當前View左上角的 x 和 y 座標。（視圖座標系）
getRawX/getRawY：返回相對於手機屏幕左上角的 x 和 y 座標。（Android座標系）

[java]  view plain  copy
  1. /** 
  2.  * 按下 
  3.  */  
  4. public static final int ACTION_DOWN             = 0;  
  5.   
  6. /** 
  7.  * 擡起 
  8.  */  
  9. public static final int ACTION_UP               = 1;  
  10.   
  11. /** 
  12.  * 移動 
  13.  */  
  14. public static final int ACTION_MOVE             = 2;  
  15.   
  16. /** 
  17.  * 觸摸動作取消 
  18.  */  
  19. public static final int ACTION_CANCEL           = 3;  
  20.   
  21. /** 
  22.  * 觸摸動作超出邊界 
  23.  */  
  24. public static final int ACTION_OUTSIDE          = 4;  
  25.   
  26. /** 
  27.  * 多點觸摸按下動作 
  28.  */  
  29. public static final int ACTION_POINTER_DOWN     = 5;  
  30.   
  31. /** 
  32.  * 多點離開動作 
  33.  */  
  34. public static final int ACTION_POINTER_UP       = 6;  


4、TouchSlop 系統能識別的最小滑動距離


獲取方式：ViewConfiguration.get(getContext()).getScaledTouchSlop() 。

我在程序中用的時候發現需要這樣寫才行：要用this才行：
[java]  view plain  copy
  1. private int m = ViewConfiguration.get(DemoActivity_1.this).getScaledTouchSlop();   
其中的get是爲了獲取一個ViewConfiguration類型的對象，然後這個對象再調用getScaledTouchSlop方法。


而它的默認值是定義在這裏的：

裏面的config.xml中：
[java]  view plain  copy
  1. <!-- Base "touch slop" value used by ViewConfiguration as a  
  2.      movement threshold where scrolling should begin. -->  
  3. <dimen name="config_viewConfigurationTouchSlop">8dp</dimen>  


5、VelocityTracker速度追蹤


用於追蹤手指在滑動過程中的速度，包括水平和豎直。
它所謂的滑動速度指的是一段時間內手指劃過的像素數，比如假設時間間隔爲1s，速度就指的是手指在水平方向從左向右滑過100像素時，速度就是100，那如果向左滑動，速度就是負值啦。

[java]  view plain  copy
  1.     // 首先在View的onTouchEvent方法中獲取追蹤速度的對象  
  2.     VelocityTracker velocityTracker = VelocityTracker.obtain();  
  3.     // 將追蹤速度對象與事件綁定起來：  
  4.     velocityTracker.addMovement(event);  
  5.     // 獲取速度之前先計算速度，這一句不可缺：  
  6.     velocityTracker.computeCurrentVelocity(1000);  
  7.     // 分別計算水平和豎直速度：  
  8.     int xVelocity = (int) velocityTracker.getXVelocity();  
  9.     int yVelocity = (int) velocityTracker.getYVelocity();  
  10.       
  11.     // 不需要使用它的時候，來重置和回收：  
  12.     velocityTracker.clear();  
  13.     velocityTracker.recycle();  


6、GestureDetector手勢檢測


用於輔助檢測用戶的單擊、滑動、長按、雙擊等行爲。

一般情況下，我們知道View類有個View.OnTouchListener內部接口，通過重寫他的onTouch(View v, MotionEvent event)方法，我們可以處理一些touch事件，但是這個方法太過簡單，如果需要處理一些複雜的手勢，用這個接口就會很麻煩（因爲我們要自己根據用戶觸摸的軌跡去判斷是什麼手勢）。

Android sdk給我們提供了GestureDetector（Gesture：手勢Detector：識別）類，通過這個類我們可以識別很多的手勢，主要是通過他的onTouchEvent(event)方法完成了不同手勢的識別。雖然他能識別手勢，但是不同的手勢要怎麼處理，應該是提供給程序員實現的。


GestureDetector這個類對外提供了兩個接口：OnGestureListener，OnDoubleTapListener，還有一個內部類SimpleOnGestureListener。


GestureDetector.OnDoubleTapListener接口：用來通知DoubleTap事件，類似於鼠標的雙擊事件。

1、onDoubleTap(MotionEvent e)：

在雙擊的第二下，按下時觸發 。它不能和 onSingleTapConfirmed 共存。


2、onDoubleTapEvent(MotionEvent e)：

通知雙擊手勢中的事件，包含down、up和move事件。

（這裏指的是在雙擊之間發生的事件，例如在同一個地方雙擊會產生雙擊手勢，而在雙擊手勢裏面還會發生down和up事件，這兩個事件由該函數通知）；

雙擊的第二下按下時，down和up都會觸發，可用e.getAction()區分。 


3，onSingleTapConfirmed(MotionEvent e)：

用來判定該次點擊是單擊而不是雙擊，如果連續點擊兩次就是雙擊手勢，如果只點擊一次，系統等待一段時間後沒有收到第二次點擊則判定該次點擊爲單擊而不是雙擊，然後觸發SingleTapConfirmed事件。這個方法不同於onSingleTapUp，他是在GestureDetector確信用戶在第一次觸摸屏幕後，沒有緊跟着第二次觸摸屏幕，也就是不是「雙擊」的時候觸發  


GestureDetector.OnGestureListener接口：用來通知普通的手勢事件，該接口有如下六個回調函數：
1、onDown(MotionEvent e)：

down事件；


2、onSingleTapUp(MotionEvente)：

一次點擊up事件；在touch down後又沒有滑動（onScroll），又沒有長按（onLongPress），然後Touch up時觸發。

點擊一下非常快的（不滑動）Touchup：

          onDown->onSingleTapUp->onSingleTapConfirmed 
點擊一下稍微慢點的（不滑動）Touchup：

          onDown->onShowPress->onSingleTapUp->onSingleTapConfirmed


3、onShowPress(MotionEvent e)：

down事件發生而move或則up還沒發生前觸發該事件；按下了還沒有滑動時觸發（與onDown，onLongPress）。

比較：onDown只要按下後一定立刻觸發。而按下後停留一會兒且沒有滑動，則先觸發onShowPress再是onLongPress。

所以按下後一直不滑動按照：onDown->onShowPress->onLongPress這個順序觸發。 


4、onLongPress(MotionEvent e)：

長按事件；按下了不移動一直按着的時候觸發。 


5、onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY)：

滑動手勢事件；按下了滑動一點距離後，在ACTION_UP時纔會觸發參數：

e1 第1個ACTION_DOWN 事件並且只有一個；

e2 最後一個ACTION_MOVE 事件 ；

velocityX X軸上的移動速度，像素/秒 ；

velocityY Y軸上的移動速度，像素/秒.

觸發條件：X軸的座標位移大於FLING_MIN_DISTANCE，且移動速度大於FLING_MIN_VELOCITY個像素/秒


6、onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY)：

在屏幕上拖動事件。無論是用手拖動view，或者是以拋的動作滾動，都會多次觸發,這個方法在ACTION_MOVE動作發生時就會觸發拋：

手指觸動屏幕後，稍微滑動後立即鬆開：

          onDown-----》onScroll----》onScroll----》onScroll----》………----->onFling

拖動：

          onDown------》onScroll----》onScroll------》onFiling


[java]  view plain  copy
  1. // 首先需要創建GestureDetector對象，實現OnGestureListener接口：下面這個語句寫的有點問題  
  2. GestureDetector mGestureDetector = new GestureDetector(this);  
  3. // 解決長按屏幕後無法拖動的現象：  
  4. mGestureDetector.setIsLongpressEnabled(false);  
  5. // 接管目標View 的 onTouchEvent 方法，在待監聽View的onTouchEvent方法中添加如下實現：  
  6. boolean consume = mGestureDetector.onTouchEvent(event);  
  7. return consume;  

三、View的滑動


要實現View的滑動，就必須監聽用戶的觸摸事件，並根據事件傳入的座標，動態且不斷地改變View的座標，從而實現View跟隨用戶觸摸的滑動而滑動。

不管採用哪一種方式，其實現的思想基本是一致的：
當觸摸View時，系統記下當前觸摸點的座標，
當手指移動時，系統記下移動後的觸摸點座標，從而獲取到相對前一次座標點的偏移量，並通過偏移量來修改View的座標。
這樣不斷重複，從而實現滑動過程。

三種方法實現View的滑動：
（1）View本身提供的scrollTo/scrollBy。
（2）通過動畫給View施加平移效果來實現滑動。
（3）通過改變View的LayoutParams使得View重新佈局從而實現滑動。
（4）layout（）方法。
（5）offsetLeftAndRight（）與offsetTopAndBottom（）。
（6）Scroller彈性滑動

1、使用scrollTo/scrollBy：（操作簡單，適合對View內容的滑動）


scrollTo、scrollBy方法移動的是View的content內容，即讓View的內容移動，
如果在ViewGroup中使用scrollBy、scrollTo方法，那麼移動的將是所有的子View，
但如果在View中使用，那麼移動的將是View的內容，
例如對TextView這個View而言，文本就是它的內容，對於ImageView而言，drawable就是它的內容，但TextView和ImageView本身的View卻沒有移動。

所以寫的時候應該這樣寫：在View所在的ViewGroup中來使用：
[java]  view plain  copy
  1. ((View)getParent()).scrollBy(offsetX, offsetY);  

（1）源碼位置在：sources\android\view\View.java
[java]  view plain  copy
  1. /** 
  2.  * Set the scrolled position of your view. This will cause a call to 
  3.  * {@link #onScrollChanged(int, int, int, int)} and the view will be 
  4.  * invalidated. 
  5.  * @param x the x position to scroll to 
  6.  * @param y the y position to scroll to 
  7.  */  
  8. /* 
  9.  * 實現的是基於所傳遞參數的絕對滑動，到x和y的地方 
  10.  * */  
  11. public void scrollTo(int x, int y) {  
  12.     if (mScrollX != x || mScrollY != y) {  
  13.         int oldX = mScrollX;  
  14.         int oldY = mScrollY;  
  15.         mScrollX = x;  
  16.         mScrollY = y;  
  17.         invalidateParentCaches();  
  18.         onScrollChanged(mScrollX, mScrollY, oldX, oldY);  
  19.         if (!awakenScrollBars()) {  
  20.             postInvalidateOnAnimation();  
  21.         }  
  22.     }  
  23. }  
  24.   
  25. /** 
  26.  * Move the scrolled position of your view. This will cause a call to 
  27.  * {@link #onScrollChanged(int, int, int, int)} and the view will be 
  28.  * invalidated. 
  29.  * @param x the amount of pixels to scroll by horizontally 
  30.  * @param y the amount of pixels to scroll by vertically 
  31.  */  
  32. /* 
  33.  * 實現的是基於所傳遞參數的相對滑動 
  34.  * */  
  35. public void scrollBy(int x, int y) {  
  36.     scrollTo(mScrollX + x, mScrollY + y);  
  37. }  


（2）其中的mScrollX和mScrollY，可以通過getScrollX和getScrollY來獲得。

[java]  view plain  copy
  1. /** 
  2.  * Return the scrolled top position of this view. This is the top edge of 
  3.  * the displayed part of your view. You do not need to draw any pixels above 
  4.  * it, since those are outside of the frame of your view on screen. 
  5.  * 
  6.  * @return The top edge of the displayed part of your view, in pixels. 
  7.  */  
  8. public final int getScrollY() {  
  9.     return mScrollY;  
  10. }  
在滑動的過程中，mScrollX的值總是等於View的左邊緣和View內容左邊緣在水平方向的距離，

而mScrollY的值總是等於View上邊緣和View內容上邊緣在豎直方向的距離。

View邊緣指的是View的位置，由四個頂點組成，

而View內容邊緣指的是View中內容的邊緣。

scrollTo和scrollBy只能改變View內容的位置而不能改變View在佈局中的位置。假位移啦！！！！！！

這個圖裏面主要注意它們的那個正負值吶。




2、使用動畫：（操作簡單，適用於沒有交互的View和複雜動畫效果的View）


（1）使用動畫來移動View，主要是操作View的translationX和translationY屬性。
（2）動畫包括傳統的View動畫和屬性動畫。
（3）注意點：同上面的scrollBy 和scrollTo一樣，View動畫是對View的影像做操作，它並不能真正改變View的位置參數，包括寬高。
並且如果希望動畫後的狀態得以保留還必須將 fillAfter屬性設置爲true，否則動畫完成後其動畫結果會消失。
（4）屬性動畫並不存在（3）這樣的情況。
（5）情況（3）會導致一個嚴重的後果，就是移動後不能帶着它的點擊事件一起移動。那怎麼辦呢？有兩種方法：
第一種：使用屬性動畫。
第二種：我們可以在新的位置上預先創建一個和目標Button一模一樣的Button，它們連onClick事件也一樣。所以移動後，設置顯示和隱藏，來間接達到移動的目的。
（6）複雜效果用動畫。

3、改變佈局參數LayoutParams：（操作稍微複雜，適用於有交互的View）


（1）改變Button的參數：主要改變的是margin屬性。
[java]  view plain  copy
  1. MarginLayoutParams params = (MarginLayoutParams)mButton.getLayoutParams();  
  2. params.width += 100;  
  3. params.leftMargin += 100;  
  4. mButton.requestLayout();  
  5. // 或者mButton.setLayoutParams(params);  
[java]  view plain  copy
  1. params.leftMargin = getLeft() + offsetX;  
  2. params.topMargin = getTop() + offsetY;  
[java]  view plain  copy
  1. LinearLayout.LayoutParams params = (LinearLayout.LayoutParams)getLayoutParams();  
用這個params的時候需要考慮父佈局的類型，當然還可以使用ViewGroup.MarginLayoutParams來實現這個功能，效果是一樣的，並且更加方便，不需要考慮父佈局的類型：
[java]  view plain  copy
  1. ViewGroup.MarginLayoutParams params = (ViewGroup.MarginLayoutParams)getLayoutParams();  

（2）在Button的左邊放置一個空的View，這個空View的默認寬度爲0。當我們需要向右移動Button時，只需要重新設置空View的寬度即可。

4、layout方法：


通過調用View的layout方法，給layout設置新的值：（使用相對父容器的座標）
[java]  view plain  copy
  1. @Override  
  2. public boolean onTouchEvent(MotionEvent event) {  
  3.   
  4.     // 每次進來獲取以下現在的座標值：  
  5.     int x = (int) event.getX();  
  6.     int y = (int) event.getY();  
  7.       
  8.     switch (event.getAction()) {  
  9.     case MotionEvent.ACTION_DOWN: {  
  10.         // 記錄觸摸點座標：  
  11.         lastX = x;  
  12.         lastY = y;  
  13.         break;  
  14.     }  
  15.     case MotionEvent.ACTION_MOVE: {  
  16.         int offsetX = x - lastX;  
  17.         int offsetY = y - lastY;  
  18.         // 在當前left、top、right、bottom的基礎上加上偏移量（注意這個左上右下的順序）  
  19.         layout(getLeft() + offsetX,  
  20.                 getTop() + offsetY,  
  21.                 getRight() + offsetX,  
  22.                 getBottom() + offsetY,  
  23.                 );  
  24.         break;  
  25.     }  
  26.     case MotionEvent.ACTION_UP: {  
  27.         break;  
  28.     }  
  29.     default:  
  30.         break;  
  31.     }  
  32.   
  33.     return true;  
  34. }  

下面使用（絕對座標，相對屏幕的座標）：
[java]  view plain  copy
  1. @Override  
  2. public boolean onTouchEvent(MotionEvent event) {  
  3.   
  4.     // 每次進來獲取以下現在的座標值：  
  5.     int rawX = (int) event.getRawX();  
  6.     int rawY = (int) event.getRawY();  
  7.       
  8.     switch (event.getAction()) {  
  9.     case MotionEvent.ACTION_DOWN: {  
  10.         // 記錄觸摸點座標：  
  11.         lastX = rawX;  
  12.         lastY = rawY;  
  13.         break;  
  14.     }  
  15.     case MotionEvent.ACTION_MOVE: {  
  16.         int offsetX = rawX - lastX;  
  17.         int offsetY = rawY - lastY;  
  18.         // 在當前left、top、right、bottom的基礎上加上偏移量（注意這個左上右下的順序）  
  19.         layout(getLeft() + offsetX,  
  20.                 getTop() + offsetY,  
  21.                 getRight() + offsetX,  
  22.                 getBottom() + offsetY,  
  23.                 );  
  24.         /* 
  25.          * 這裏是必須要注意的一點 
  26.          * 使用絕對座標系，在每次執行完ACTION_DOWN的邏輯後， 
  27.          * 一定要重新設置初始座標，這樣才能準確的獲取偏移量。 
  28.          * */  
  29.         lastX = rawX;  
  30.         lastY = rawY;  
  31.         break;  
  32.     }  
  33.     case MotionEvent.ACTION_UP: {  
  34.         break;  
  35.     }  
  36.     default:  
  37.         break;  
  38.     }  
  39.   
  40.     return true;  
  41. }  

5、offsetLeftAndRight（）與offsetTopAndBottom（）


這個方法相當於系統提供了一個對左右、上下移動的API的封裝。
當計算出偏移量後，只需要使用如下代碼就可以完成View的重新佈局，
效果與使用Layout方法一樣，
代碼如下所示：
[java]  view plain  copy
  1. // 同時對left和right進行偏移：  
  2. offsetLeftAndRight(offsetX);  
  3. // 同時對top和bottom進行偏移：  
  4. offsetTopAndBottom(offsetY);  


6、Scroller彈性滑動


Scroller的工作機制：Scroller本身並不能實現View的滑動，它需要配合View的computeScroll方法才能完成彈性滑動的效果，它不斷地讓View重繪，而每一次重繪距滑動起始時間會有一個時間間隔，通過這個時間間隔Scroller就可以得出View當前的滑動位置，知道了滑動位置就可以通過scrollTp方法來完成View的滑動。就這樣，View的每一次重繪都會導致View進行小幅度的滑動，而多次的小幅度滑動就組成了彈性滑動。
使用Scroller類通常需要三個步驟：
（1）初始化Scroller：
[java]  view plain  copy
  1. Scroller scroller = new Scroller(mContext);  
（2）重寫computeScroll（）方法，實現模擬滑動：
它是scroller的核心，系統在繪製View的時候會在draw（）方法中調用該方法。
這個方法實際上就是使用的scrollTo方法，再結合Scroller對象，幫助獲取到當前的滾動值。
我們可以通過不斷地瞬間移動一個小的距離來實現整體上的平滑移動效果：
[java]  view plain  copy
  1. @Override  
  2. public void computeScroll(){  
  3.     super.computeScroll();  
  4.     // 判斷Scroller是否執行完畢  
  5.     if(mScroller.computeScrollOffest()){  
  6.         ((View)getParent()).scrollTo(  
  7.                 mScroller.getCurrX(),   
  8.                 mScroller.getCurrY()  
  9.                 );  
  10.         // 通過重繪來不斷調用computeScroll：  
  11.         invalidate();  
  12.     }  
  13. }  

Scroller類提供了computeScrollOffset（）方法來判斷是否完成了整個滑動，同時也提供了 getCurrX（）、getCurrY（）方法來獲得當前的滑動座標。

還有一個注意點就是invalidate()方法，因爲只能在computeScroll（）方法中獲取模擬過程中的scrollX和scrollY座標。
但computeScroll（）方法是不會自動調用的，只能通過invalidate（）-> draw()    -> computeScroll（）來間接調用computeScroll（）方法，
所以需要在上面的代碼中調用invalidate（）方法，實現循環獲取scrollX和scrollY的目的。
而當模擬過程結束以後，scroller.computeScrollOffset()方法會返回false，從而中斷循環，完成整個平滑移動過程。

（3）startScroll開啓模擬過程：
有兩個重載方法：
[java]  view plain  copy
  1. public void startScroll(int startX, int startY, int dx, int dy, int duration)  
  2.   
  3. public void startScroll(int startX, int startY, int dx, int dy)  
在獲取座標時，通常可以使用 getScrollX（）和getScrollY（）方法來獲取父視圖中content所滑動到的點的座標，不過還是要注意正負值，和scrollTo、scrollBy一樣正負值相反。

（4）具體的使用：
就是在ACTION_UP的時候，寫上面的（1）（2）就可以啦，但是要記得再次調用invalidate()來通知View進行重繪。

（5）注意點：
因爲scrollTo/scrollBy的滑動過程是瞬間完成的，所以爲了用戶體驗，需要設置彈性滑動。
Scroller本身無法讓View彈性滑動，它需要和View的computeScroll方法配合使用才能共同完成這個功能。
[java]  view plain  copy
  1. Scroller scroller = new Scroller(mContext);  
  2.   
  3. // 緩慢滾動到指定位置：  
  4. private void smoothScrollTo(int destX, int destY){  
  5.     int scrollX = getScrollX();  
  6.     int delta = destX - scrollX;  
  7.     // 1000ms內滑向destX，效果就是慢慢滑動  
  8.     mScroller.startScroll(scrollX, 0, delta, 0, 1000);  
  9.     invalidate();  
  10. }  
  11.   
  12. @Override  
  13. public void computeScroll(){  
  14.     if(mScroller.computeScrollOffest()){  
  15.         scrollTo(mScroller.getCurrX(), mScroller.getCurrY();  
  16.         postInvalidate();  
  17.     }  
  18. }  
所以呢，結合上面的（1）（2）（3）（4），我們規整爲（5），就是說第一行scroller是必須創建的，下面的computeScroll方法是需要重寫的，中間的smoothScrollTo方法是我們自己寫的，裏面主要是要調用startScroll方法，隨後又調用了invalidate方法，這樣就可以循環往復的一直調用了：computeScroll（）方法是不會自動調用的，只能通過invalidate（）-> draw()    -> computeScroll（）來間接調用computeScroll（）方法。


四、彈性滑動


三種方法：

（1）使用Scoller。

（2）通過動畫。

（3）使用延時策略


1、使用Scoller：


（1）剛剛已經寫過了下面的這兩個函數：這兩個方法寫在活動中：

[java]  view plain  copy
  1. Scroller scroller = new Scroller(mContext);  
  2.   
  3. //緩慢滾動到指定位置：  
  4. private void smoothScrollTo(int destX, int destY){  
  5.     int scrollX = getScrollX();  
  6.     int delta = destX - scrollX;  
  7.     // 1000ms內滑向destX，效果就是慢慢滑動  
  8.     mScroller.startScroll(scrollX, 0, delta, 0, 1000);  
  9.     invalidate();//通知View進行重繪  
  10. }  
  11.   
  12. @Override  
  13. public void computeScroll(){  
  14.     if(mScroller.computeScrollOffest()){  
  15.         scrollTo(mScroller.getCurrX(), mScroller.getCurrY());  
  16.         postInvalidate();  
  17.     }  
  18. }  
但其實現的重點在於startCroll方法和computeScrollOffest方法的實現。

（2）源碼地址：sources\android\widget\Scoller.java

（3）其實在startScroll中什麼都沒有做，它只是保存了我們傳遞的幾個參數：

[java]  view plain  copy
  1. /** 
  2.  * Start scrolling by providing a starting point, the distance to travel, 
  3.  * and the duration of the scroll. 
  4.  *  
  5.  * @param startX Starting horizontal scroll offset in pixels. Positive 
  6.  *        numbers will scroll the content to the left. 
  7.  * @param startY Starting vertical scroll offset in pixels. Positive numbers 
  8.  *        will scroll the content up. 
  9.  * @param dx Horizontal distance to travel. Positive numbers will scroll the 
  10.  *        content to the left. 
  11.  * @param dy Vertical distance to travel. Positive numbers will scroll the 
  12.  *        content up. 
  13.  * @param duration Duration of the scroll in milliseconds. 
  14.  */  
  15. public void startScroll(int startX, int startY, int dx, int dy, int duration) {  
  16.     mMode = SCROLL_MODE;  
  17.     mFinished = false;  
  18.     mDuration = duration;  
  19.     mStartTime = AnimationUtils.currentAnimationTimeMillis();  
  20.     // 滑動起點  
  21.     mStartX = startX;  
  22.     mStartY = startY;  
  23.     // 滑動終點  
  24.     mFinalX = startX + dx;  
  25.     mFinalY = startY + dy;  
  26.     mDeltaX = dx;  
  27.     mDeltaY = dy;  
  28.     // 滑動時間，內容的滑動而不是位置的滑動  
  29.     mDurationReciprocal = 1.0f / (float) mDuration;  
  30. }  
（4）真正的滑動實現是在startScroll下面的 invalidate（）方法中。

 invalidate方法會導致View重繪，View重繪會調用draw方法，在View的draw方法中又會去調用computeScroll方法，computeScroll方法在View中是一個空實現（它在View.java中），因此需要我們自己去重寫實現。

具體過程：當View重繪後會在draw方法中調用computeScroll方法，而computeScroll方法又會去向Scroller獲取當前的scrollX 和scrollY；然後通過scrollTo方法實現滑動；接着又調用postInvalidate方法來進行第二次重繪，這一次重繪和上一次重繪過程一樣的，還是會導致computeScroll方法被調用；然後繼續向Scroller獲取當前的scrollX和scrollY，並通過scrollTo方法滑動到新的位置，如此反覆，直到整個滑動過程結束。

[java]  view plain  copy
  1. /** 
  2.  * Call this when you want to know the new location.  If it returns true, 
  3.  * the animation is not yet finished. 
  4.  */   
  5. /* 
  6.  * 這個方法會根據事件的流逝來計算出當前scrollX和scrollY的值。 
  7.  * 根據時間流逝的百分比來算出scrollX和scrollY改變的百分比並計算出當前的值 
  8.  * 它返回true表示滑動還沒有結束，false表示滑動已經結束。 
  9.  * */  
  10. public boolean computeScrollOffset() {  
  11.     if (mFinished) {  
  12.         return false;  
  13.     }  
  14.   
  15.     int timePassed = (int)(AnimationUtils.currentAnimationTimeMillis() - mStartTime);  
  16.   
  17.     if (timePassed < mDuration) {  
  18.         switch (mMode) {  
  19.         case SCROLL_MODE:  
  20.             float x = timePassed * mDurationReciprocal;  
  21.   
  22.             if (mInterpolator == null)  
  23.                 x = viscousFluid(x);   
  24.             else  
  25.                 x = mInterpolator.getInterpolation(x);  
  26.   
  27.             mCurrX = mStartX + Math.round(x * mDeltaX);  
  28.             mCurrY = mStartY + Math.round(x * mDeltaY);  
  29.             break;  
  30.         case FLING_MODE:  
  31.             final float t = (float) timePassed / mDuration;  
  32.             final int index = (int) (NB_SAMPLES * t);  
  33.             float distanceCoef = 1.f;  
  34.             float velocityCoef = 0.f;  
  35.             if (index < NB_SAMPLES) {  
  36.                 final float t_inf = (float) index / NB_SAMPLES;  
  37.                 final float t_sup = (float) (index + 1) / NB_SAMPLES;  
  38.                 final float d_inf = SPLINE_POSITION[index];  
  39.                 final float d_sup = SPLINE_POSITION[index + 1];  
  40.                 velocityCoef = (d_sup - d_inf) / (t_sup - t_inf);  
  41.                 distanceCoef = d_inf + (t - t_inf) * velocityCoef;  
  42.             }  
  43.   
  44.             mCurrVelocity = velocityCoef * mDistance / mDuration * 1000.0f;  
  45.               
  46.             mCurrX = mStartX + Math.round(distanceCoef * (mFinalX - mStartX));  
  47.             // Pin to mMinX <= mCurrX <= mMaxX  
  48.             mCurrX = Math.min(mCurrX, mMaxX);  
  49.             mCurrX = Math.max(mCurrX, mMinX);  
  50.               
  51.             mCurrY = mStartY + Math.round(distanceCoef * (mFinalY - mStartY));  
  52.             // Pin to mMinY <= mCurrY <= mMaxY  
  53.             mCurrY = Math.min(mCurrY, mMaxY);  
  54.             mCurrY = Math.max(mCurrY, mMinY);  
  55.   
  56.             if (mCurrX == mFinalX && mCurrY == mFinalY) {  
  57.                 mFinished = true;  
  58.             }  
  59.   
  60.             break;  
  61.         }  
  62.     }  
  63.     else {  
  64.         mCurrX = mFinalX;  
  65.         mCurrY = mFinalY;  
  66.         mFinished = true;  
  67.     }  
  68.     return true;  
  69. }  

是不是很神奇？切


2、通過動畫：


動畫本身就是一種漸近的過程，因此通過它來實現的滑動天然就具有彈性效果。

（1）下面的代碼可以讓一個View的內容在100ms內向左移動100像素：

[java]  view plain  copy
  1. ObjectAnimator.ofFloat(targetView, "translationX", 0, 100).setDuration(100).satrt();  

（2）我們可以利用動畫的特性來實現一些動畫不能實現的效果。我們可以在動畫的每一幀到來時獲取動畫完成的比例，然後再根據這個比例計算出當前View所要滑動的距離。

[java]  view plain  copy
  1. final int startX = 0;  
  2. final int deltaX = 100;  
  3. ValueAnimator animator = ValueAnimator.ofInt(0, 1).setDuration(1000);  
  4. animator.addUpdateListener(new AnimatorUpdateListener(){  
  5.     @Override  
  6.     public void onAnimationUpdate(ValueAnimator animator){  
  7.         float fraction = animator.getAnimatedFraction();  
  8.         mButton1.scrollTo(startX + (int)(deltaX * fraction), 0);  
  9.     }  
  10. });  
  11. animator.start();  
在這裏例子中，我們並沒有在ofInt方法中直接對目標對象進行移動，而是在下面的scrollTo中進行實際的移動，這個思想和上面的Scroller滑動思想是相同的。


3、使用延時策略：


延時策略的工作機制：通過發送一系列延時消息從而達到一種漸近式的效果。

（1）兩種方式：Handler或View的postDelayed方法，或使用線程的sleep方法。
（2）其實還是要計算滑動過程中的百分比的。這裏有一個小例子：

[java]  view plain  copy
  1. private static final int MESSAGE_SCROLL_TO = 1;  
  2. private static final int FRAME_COUNT = 30;  
  3. private static final int DELAYED_TIME = 33;  
  4.   
  5. private int mCount = 0;  
  6.   
  7. private Handler mHandler = new Handler(){  
  8.     public void handleMessage(Message msg){  
  9.         switch(msg.what){  
  10.         case MESSAGE_SCROLL_TO:  
  11.             mCount++;  
  12.             if(mCount <= FRAME_COUNT){  
  13.                 float fraction = mCount / (float) FRAME_COUNT;  
  14.                 int scrollX = (int) (fraction * 100);  
  15.                 mButton.scrollTo(scrollX, 0);  
  16.                 mHandler.sendEmptyMessageDelayed(MESSAGE_SCROLL_TO, DELAYED_TIME);  
  17.             }  
  18.             break;  
  19.           
  20.         }  
  21.           
  22.         default:  
  23.             break;  
  24.         }  
  25.     };  
  26. };  


五、View的事件分發機制


點擊事件的事件分發，就是對MotionEvent事件的分發過程，即當一個MotionEvent產生了以後，系統需要把這個事件傳遞給一個具體的View。


1、點擊事件的分發過程由三個很重要的方法共同完成：


public boolean dispatchTouchEvent(MotionEvent ev)

用來進行事件的分發，dispatch派分。如果事件能夠傳遞給當前View，這個方法就一定會被調用，

返回結果受當前View的 onTouchEvent 和下級 View 的 dispatchTouchEvent 方法的影響，表示是否消耗當前事件。


public boolean onInterceptTouchEvent(MotionEvent event)

在 dispatchTouchEvent 方法的內部調用，用來判斷是否攔截某個事件，如果當前View 攔截了某個事件，那麼在同一個事件序列當中，此方法不會被再次調用，

返回結果表示是否攔截當前事件。true表示攔截。


public boolean onTouchEvent(MotionEvent event)

在 dispatchTouchEvent 方法中調用，用來處理點擊事件，

返回結果表示是否消耗當前事件，如果不消耗，則在同一個事件序列中，當前View再也無法接收到該事件的後續事件。

就是說如果消耗了down，還可以消耗move，up等，如果不消耗，後續的就都沒有了。

但如果不消耗，該事件序列就要交由上一層來處理。


它們三者的關係用僞代碼表示的話就是這樣的：是不是很簡單的樣子？

[java]  view plain  copy
  1. public boolean dispatchTouchEvent(MotionEvent ev) {  
  2.       
  3.     boolean consume = false;  
  4.       
  5.     if (onInterceptTouchEvent(ev)) {  
  6.         consume = onTouchEvent(ev);  
  7.     } else {  
  8.         consume = child.dispatchTouchEvent(ev);  
  9.     }  
  10.       
  11.     return consume;  
  12. }  


2、OnTouchListener 和 OnTouchEvent 的關係


如果一個View並沒有給它設置OnTouchListener，也就不存在什麼問題了，就按上面的程序走。

但如果有設置了OnTouchListener，那麼它裏面的 onTouch 方法就會被調用。

這時候問題就來了，如果 onTouch 方法返回的是 false，則當前View的onTouchEvent 方法會被調用；

但如果onTouch 方法返回的是true，那麼當前View的 onTouchEvent 方法就不會被調用了！

所以說呢，給View設置的 OnTouchListener 的優先級要比 onTouchEvent 要高，

兩者只會有一個返回true，先詢問 OnTouchListener，不行再去看看 OnTouchEvent。


在onTouchEvent方法中，還可能設置有 OnClickListener，那麼它的 onClick 方法會被調用，

也就是說，只有 onTouchEvent被調用了，onClick 纔有調用的機會，所以說onClick的優先級是最低的。


3、事件傳遞順序


Activity -> Window -> View


雖然是從上往下的傳遞，但是當一個View 的 onTouchEvent 返回false（參考下面Tips中的（4）），那麼它的父容器的 onTouchEvent 將會被調用，如果還返回false就以此類推的往上推，直到Activity。


4、


5、事件分發的源碼解析


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


（1）源碼位置在：sources\android\app\Activity.java

（2）這裏是一個事件發生時最先到達的地方。

（3）Activity調用它的dispatchTouchEvent來進行事件派發。

（4）看第二個if語句，首先Activity將事件交給Windows，然後Windows會調用它的superDispatchTouchEvent，如果成功了，說明Activity下面的子處理了該事件，返回true，否則就會由下級傳回來來調用Activity最下面的那個onTouchEvent來處理事件。

[java]  view plain  copy
  1. /** 
  2.  * Called to process touch screen events.  You can override this to 
  3.  * intercept all touch screen events before they are dispatched to the 
  4.  * window.  Be sure to call this implementation for touch screen events 
  5.  * that should be handled normally. 
  6.  *  
  7.  * @param ev The touch screen event. 
  8.  *  
  9.  * @return boolean Return true if this event was consumed. 
  10.  */  
  11. public boolean dispatchTouchEvent(MotionEvent ev) {  
  12.     if (ev.getAction() == MotionEvent.ACTION_DOWN) {  
  13.         onUserInteraction();  
  14.     }  
  15.     // 交給下級Window去處理  
  16.     if (getWindow().superDispatchTouchEvent(ev)) {  
  17.         // 下級處理成功，返回false。  
  18.         return true;  
  19.     }  
  20.     // 下級處理失敗，退回來自己在onTouchEvent中處理。  
  21.     return onTouchEvent(ev);  
  22. }  


2、Window對點擊事件的分發過程：


（1）源碼位置在：sources\android\view\Window.java
（2）由Activity傳遞到Window，然後Window要將事件傳遞給ViewGroup。
（3）Window是一個抽象類，其中的方法都是抽象方法，所以superDispatchTouchEvent 也是一個抽象方法。
[java]  view plain  copy
  1. /** 
  2.  * Used by custom windows, such as Dialog, to pass the touch screen event 
  3.  * further down the view hierarchy. Application developers should 
  4.  * not need to implement or call this. 
  5.  * 
  6.  */  
  7. public abstract boolean superDispatchTouchEvent(MotionEvent event);  
（4）Window的唯一實現類是 PhoneWindow。唯一的！！！
[java]  view plain  copy
  1. /** 
  2.  * Abstract base class for a top-level window look and behavior policy.  An 
  3.  * instance of this class should be used as the top-level view added to the 
  4.  * window manager. It provides standard UI policies such as a background, title 
  5.  * area, default key processing, etc. 
  6.  * 
  7.  * <p>The only existing implementation of this abstract class is 
  8.  * android.policy.PhoneWindow, which you should instantiate when needing a 
  9.  * Window.  Eventually that class will be refactored and a factory method 
  10.  * added for creating Window instances without knowing about a particular 
  11.  * implementation. 
  12.  */  

（5）關於PhoneWindow，我並沒有找到它的源碼，呵呵。位置應該在：sources\android\policy\PhoneWindow.java 。看吧，PhoneWindow 又把事件分發的任務給了DecorView。
[java]  view plain  copy
  1. public boolean superDispatchTouchEvent(MotionEvent event){  
  2.     return mDecor.superDispatchTouchEvent(event);  
  3. }  


3、DecorView對點擊事件的分發過程：


反正最後是從DecorView傳給了View了，過程先略。


4、頂級View對點擊事件的分發過程：


我這裏需要加一下我一直沒搞懂的陳述：

（1）就是在ViewGroup中的 dispatchTouchEvent 方法，其實所有的事件序列中的事件包括ACTION_DOWN、ACTION_MOVE和ACTION_UP都會進入到這裏來進行事件的分配。

（2）對於ACTION_DOWN，如果ViewGroup攔截了ACTION_DOWN，就會導致 mFirstTouchTarget == null，interception ==  true；這樣的話當其他的後續的事件到來時，if (actionMasked == MotionEvent.ACTION_DOWN || mFirstTouchTarget != null) 語句無法進入，所以ViewGroup攔截了ACTION_DOWN以後，這個事件的後續只能由ViewGroup來處理。

（3）如果ACTION_DOWN是由子元素攔截的，那麼 mFirstTouchTarget ！= null，interception ==  false，這樣呢當其他後續的事件到來時，if (actionMasked == MotionEvent.ACTION_DOWN || mFirstTouchTarget != null) 語句還是可以進入的。然後可以執行到onInterceptTouchEvent 方法，默認的ViewGroup的這個方法是都返回false的，也就是ViewGroup不攔截任何的事件，並且這也意味着，一旦某個子元素攔截了ACTION_DOWN，那後續的事件序列也都交給這個子元素來處理了。但是我們在寫自己的ViewGroup例如LinearLayout時，就可以重寫onInterceptTouchEvent方法，然後讓它可以在例如ACTION_MOVE的時候返回ture，這樣ViewGroup就可以實現沒有攔截ACTION_DOWN並交給了子元素，但是卻攔截了後面的ACTION_MOVE，這也就是下面在滑動衝突中講到的外部攔截法。

是不是很神奇呀！


頂級View一般是一個ViewGroup，所以我們去看ViewGroup。

（1）源碼位置在：sources\android\view\ViewGroup.java

（2）下面我們將一直在ViewGroup的超長dispatchTouchEvent函數中講解！

[java]  view plain  copy
  1. /** 
  2.  * {@inheritDoc} 
  3.  */  
  4. @Override  
  5. public boolean dispatchTouchEvent(MotionEvent ev) {  
  6.     if (mInputEventConsistencyVerifier != null) {  
  7.         mInputEventConsistencyVerifier.onTouchEvent(ev, 1);  
  8.     }  
  9.   
  10.     boolean handled = false;  
  11.     if (onFilterTouchEventForSecurity(ev)) {  
  12.         final int action = ev.getAction();  
  13.         final int actionMasked = action & MotionEvent.ACTION_MASK;  
  14.   
  15.   
  16.         /* 
  17.          * 當新的一輪點擊到來的時候，從ACTION_DOWN開始的，做一些初始化的工作： 
  18.          * */  
  19.         // Handle an initial down.  
  20.         if (actionMasked == MotionEvent.ACTION_DOWN) {  
  21.             // Throw away all previous state when starting a new touch gesture.  
  22.             // The framework may have dropped the up or cancel event for the previous gesture  
  23.             // due to an app switch, ANR, or some other state change.  
  24.         /* 
  25.          * 至少我知道在這個函數中最終將mFirstTouchTarget設爲null。 
  26.          * mFirstTouchTarget代表的就是一個事件序列中第一個攔截的對象， 
  27.          * 所以這裏需要重置。 
  28.          * */  
  29.             cancelAndClearTouchTargets(ev);  
  30.             /* 
  31.              * 如果事件是ACTION_DOWN， 
  32.              * ViewGroup就會在resetTouchState中重置下面的FLAG_DISALLOW_INTERCEPT標誌位。 
  33.              * 重置的方式是這樣的：mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT; 
  34.              * */  
  35.             resetTouchState();  
  36.         }  
  37.   
  38.   
  39.         // Check for interception.  
  40.         /* 
  41.          * 這個標識很重要，因爲它一旦被標誌位true，意味着下面的各種if語句都進不去了， 
  42.          * 意味着本ViewGroup攔截了該事件，並且後續的事件序列直接由該ViewGroup處理， 
  43.          * 而不是進入各種if中判斷是否需要攔截。 
  44.          * */  
  45.         final boolean intercepted;// 攔截標識  
  46.         /* 
  47.          * 這個if中需要滿足兩個條件： 
  48.          * （1）actionMasked == MotionEvent.ACTION_DOWN： 
  49.          * 該事件是否爲點擊下按事件時成立，就是說新的一輪事件到來 
  50.          * （2）mFirstTouchTarget != null： 
  51.          * 當ViewGroup不攔截事件並將事件交給子元素處理時，成立，mFirstTouchTarget指向這個子元素。 
  52.          * 而且在ViewGroup中，默認onInterceptTouchEvent返回false，它是不攔截任何事件的， 
  53.          * 但是在LinearLayout中可能就會攔截啊，可以改寫啊。 
  54.          * 而且，當第二個條件成立時，此時發生的事件序列就是ACTION_MOVE或者ACTION_UP，都會進入到這個if語句中。 
  55.          * */  
  56.         /* 
  57.          * 所以說呢，當子元素成功攔截了事件或者下按事件發生的時候就會進入if語句。 
  58.          * 所以說呢，如果子元素沒有處理，並且是move和up發生的時候就無法進入該if語句。 
  59.          * 但爲什麼這樣設定呢，因爲如果子元素沒有處理的話，事件序列中的其他事件就會直接由ViewGroup來處理了， 
  60.          * 不需要來這裏來判斷一下到底要不要攔截事件了。那如果是move和up也是同樣的，不需要來這裏來判斷要不要攔截事件。 
  61.          * */  
  62.         /* 
  63.          * 也就相當於說，一個事件，第一次因爲ACTION_DOWN進入這裏，然後ViewGroup判斷是否來攔截。 
  64.          * 之後在子元素成功處理後，因爲子元素是可以通過FLAG_DISALLOW_INTERCEPT標誌位來干預父元素的事件分發過程，所以又來這裏來要看是否攔截。 
  65.          * */  
  66.         /* 
  67.          * 爲什麼總說一旦父元素攔截ACTION_DOWN以後其他的事件序列就只能由父元素來處理呢？ 
  68.          * 是因爲如果父元素攔截了ACTION_DOWN，那麼mFirstTouchTarget == null 
  69.          * 當ACTION_MOVE和ACTION_UP到來的時候，這條if語句就不會進入了， 
  70.          * 然後intercepted = true;表示事件序列由父元素全攔截了。 
  71.          * */  
  72.         if (actionMasked == MotionEvent.ACTION_DOWN  
  73.                 || mFirstTouchTarget != null) {  
  74.         /* 
  75.          * 通常事件傳遞過程是由外向內的， 
  76.          * 但是通過 requestDisallowInterceptTouchEvent方法可以在子元素中干預父元素的事件分發過程， 
  77.          * 不過ACTION_DOWN事件除外。 
  78.          * 干預表現在子元素已經攔截了事件， 
  79.          * 但是可以通過requestDisallowInterceptTouchEvent來控制 
  80.          * ACTION_MOVE和ACTION_UP能不能夠進入到這裏來。 
  81.          * */  
  82.         /* 
  83.          * FLAG_DISALLOW_INTERCEPT一旦設置後，ViewGroup將無法攔截處理ACTION_DOWN以外的其他點擊事件了。 
  84.          * 因爲在事件分發時，ACTION_DOWN會重置FLAG_DISALLOW_INTERCEPT標誌位，表示另一次事件開始。 
  85.          * */  
  86.         /* 
  87.          * 子View干涉ViewGroup的過程： 
  88.          * 初始化：mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT; 
  89.          * 在子View中FLAG_DISALLOW_INTERCEPT被重置，也就是要去幹擾， 
  90.          * 然後mGroupFlags & FLAG_DISALLOW_INTERCEPT爲1 
  91.          * 然後(mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0 爲true 
  92.          * 然後disallowIntercept爲true 
  93.          * 然後導致if (!disallowIntercept)無法進入。 
  94.          * */  
  95.         /* 
  96.          * FLAG_DISALLOW_INTERCEPT標誌位有什麼用呢？ 
  97.          * 當面對滑動衝突時，我們可以考慮用這種方法去解決問題。 
  98.          * */  
  99.             final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;  
  100.             if (!disallowIntercept) {  
  101.             /* 
  102.              * 所以說onInterceptTouchEvent並不是每次事件都會被調用的。 
  103.              * 而dispatchTouchEvent卻會在每次都調用。 
  104.              * 對於原始的ViewGroup，onInterceptTouchEvent會返回false， 
  105.              * 但是對於你自己寫的LinearLayout，則可以修改這個函數， 
  106.              * 讓它對ACTION_DOWN、ACTION_MOVE、ACTION_UP做出不同的選擇。 
  107.              * */  
  108.                 intercepted = onInterceptTouchEvent(ev);  
  109.                 ev.setAction(action); // restore action in case it was changed  
  110.             } else {  
  111.                 intercepted = false;  
  112.             }  
  113.         } else {  
  114.             // There are no touch targets and this action is not an initial down  
  115.             // so this view group continues to intercept touches.  
  116.         /* 
  117.          * 就是說沒有子元素mFirstTouchTarget，而且事件也不是ACTION_DOWN， 
  118.          * 沒人管那就只能自己攔截了。 
  119.          * */  
  120.             intercepted = true;  
  121.         }  
  122.   
  123.   
  124.         // Check for cancelation.  
  125.         final boolean canceled = resetCancelNextUpFlag(this)  
  126.                 || actionMasked == MotionEvent.ACTION_CANCEL;  
  127.   
  128.   
  129.         // Update list of touch targets for pointer down, if needed.  
  130.         final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0;  
  131.         TouchTarget newTouchTarget = null;  
  132.         boolean alreadyDispatchedToNewTouchTarget = false;  
  133.           
  134.         /* 
  135.          * 當ViewGroup不攔截事件的時候，intercepted=false，事件會向下分發由它的子View進行處理 
  136.          * 所以說一旦ViewGroup攔截了事件，intercepted=true， 
  137.          * 意味着事件序列中的任何事件都不再會傳給子元素了，由父元素全權處理。 
  138.          * 所以intercepted=true一定要謹慎設置。 
  139.          * */  
  140.         if (!canceled && !intercepted) {  
  141.             if (actionMasked == MotionEvent.ACTION_DOWN  
  142.                     || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)  
  143.                     || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {  
  144.                 final int actionIndex = ev.getActionIndex(); // always 0 for down  
  145.                 final int idBitsToAssign = split ? 1 << ev.getPointerId(actionIndex)  
  146.                         : TouchTarget.ALL_POINTER_IDS;  
  147.   
  148.   
  149.                 // Clean up earlier touch targets for this pointer id in case they  
  150.                 // have become out of sync.  
  151.                 removePointersFromTouchTargets(idBitsToAssign);  
  152.                 final int childrenCount = mChildrenCount;  
  153.                 if (newTouchTarget == null && childrenCount != 0) {  
  154.                     final float x = ev.getX(actionIndex);  
  155.                     final float y = ev.getY(actionIndex);  
  156.                     // Find a child that can receive the event.  
  157.                     // Scan children from front to back.  
  158.                     final View[] children = mChildren;  
  159.   
  160.   
  161.                     final boolean customOrder = isChildrenDrawingOrderEnabled();  
  162.                       
  163.                     /* 
  164.                      * 遍歷ViewGroup的所有子元素，判斷子元素是否能夠接收到點擊事件。 
  165.                      * */  
  166.                     for (int i = childrenCount - 1; i >= 0; i--) {  
  167.                         final int childIndex = customOrder ?  
  168.                                 getChildDrawingOrder(childrenCount, i) : i;  
  169.                         final View child = children[childIndex];  
  170.                         /* 
  171.                          * 判斷子元素是否能夠接收到點擊事件: 
  172.                          * （1）canViewReceivePointerEvents：子元素是否在播動畫。 
  173.                          * （2）isTransformedTouchPointInView：點擊事件的座標是否落在子元素的區域內。 
  174.                          * */  
  175.                         if (!canViewReceivePointerEvents(child)  
  176.                                 || !isTransformedTouchPointInView(x, y, child, null)) {  
  177.                             continue;  
  178.                         }  
  179.   
  180.   
  181.                         /* 
  182.                          * 如果上面那個if語句沒有成立，說明這個子元素是可以攔截事件的， 
  183.                          * 所以新的TouchTarget出現了，就是這個子元素。 
  184.                          * */  
  185.                         newTouchTarget = getTouchTarget(child);  
  186.                         if (newTouchTarget != null) {  
  187.                             // Child is already receiving touch within its bounds.  
  188.                             // Give it the new pointer in addition to the ones it is handling.  
  189.                             newTouchTarget.pointerIdBits |= idBitsToAssign;  
  190.                             break;  
  191.                         }  
  192.   
  193.   
  194.                         resetCancelNextUpFlag(child);  
  195.                         /* 
  196.                          * 這個子元素已經攔截該事件了，現在要子元素傳遞給它自己的子元素去分派這個事件了： 
  197.                          * dispatchTransformedTouchEvent實際上調用的就是子元素的dispatchTouchEvent方法。 
  198.                          * 下面的第三個參數中child一定不爲null，所以child的dispatchTouchEvent一定會被調用。 
  199.                          * 子元素的dispatchTouchEvent返回true， 
  200.                          * 意味着dispatchTransformedTouchEvent也返回ture， 
  201.                          * 表示事件被子元素分發成功，並break跳出循環。 
  202.                          * */  
  203.                         if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {  
  204.                             // Child wants to receive touch within its bounds.  
  205.                             mLastTouchDownTime = ev.getDownTime();  
  206.                             mLastTouchDownIndex = childIndex;  
  207.                             mLastTouchDownX = ev.getX();  
  208.                             mLastTouchDownY = ev.getY();  
  209.                             /* 
  210.                              * 分發成功後，在addTouchTarget會對mFirstTouchTarget進行賦值 
  211.                              * */  
  212.                             newTouchTarget = addTouchTarget(child, idBitsToAssign);  
  213.                             alreadyDispatchedToNewTouchTarget = true;  
  214.                             /* 
  215.                              * 分發成功，跳出循環 
  216.                              * */  
  217.                             break;  
  218.                         }  
  219.                     }  
  220.                 }  
  221.   
  222.   
  223.                 if (newTouchTarget == null && mFirstTouchTarget != null) {  
  224.                     // Did not find a child to receive the event.  
  225.                     // Assign the pointer to the least recently added target.  
  226.                     newTouchTarget = mFirstTouchTarget;  
  227.                     while (newTouchTarget.next != null) {  
  228.                         newTouchTarget = newTouchTarget.next;  
  229.                     }  
  230.                     newTouchTarget.pointerIdBits |= idBitsToAssign;  
  231.                 }  
  232.             }  
  233.         }  
  234.   
  235.   
  236.         /* 
  237.          * 有兩種情況遍歷所有的子元素後事件也沒有處理： 
  238.          * （1）ViewGroup根本沒有子元素 
  239.          * （2）子元素的dispatchTouchEvent都返回了false。 
  240.          * 這種情況下只能ViewGroup自己來處理事件了。 
  241.          * */  
  242.         // Dispatch to touch targets.  
  243.         if (mFirstTouchTarget == null) {  
  244.             // No touch targets so treat this as an ordinary view.  
  245.        /* 
  246.         * 注意第三個參數：null，在上面變量子元素的時候這裏放的是child。 
  247.         * 如果是null，dispatchTransformedTouchEvent內部就會調用： 
  248.          * super.dispatchTouchEvent(event); 
  249.          * 很顯然，這裏就轉到了View的dispatchTouchEvent(event)方法，即點擊事件開始交由View來處理。在View中有onTouchEvent。 
  250.          * 其實父元素ViewGroup的onTouchEvent就是指的是View中的onTouchEvent方法，它自己這裏是沒有的。因爲ViewGroup是繼承View的！！！！ 
  251.          * */  
  252.             handled = dispatchTransformedTouchEvent(ev, canceled, null,  
  253.                     TouchTarget.ALL_POINTER_IDS);  
  254.         } else {  
  255.             // Dispatch to touch targets, excluding the new touch target if we already  
  256.             // dispatched to it.  Cancel touch targets if necessary.  
  257.             TouchTarget predecessor = null;  
  258.             TouchTarget target = mFirstTouchTarget;  
  259.             while (target != null) {  
  260.                 final TouchTarget next = target.next;  
  261.                 if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {  
  262.                     handled = true;  
  263.                 } else {  
  264.                     final boolean cancelChild = resetCancelNextUpFlag(target.child)  
  265.                             || intercepted;  
  266.                     if (dispatchTransformedTouchEvent(ev, cancelChild,  
  267.                             target.child, target.pointerIdBits)) {  
  268.                         handled = true;  
  269.                     }  
  270.                     if (cancelChild) {  
  271.                         if (predecessor == null) {  
  272.                             mFirstTouchTarget = next;  
  273.                         } else {  
  274.                             predecessor.next = next;  
  275.                         }  
  276.                         target.recycle();  
  277.                         target = next;  
  278.                         continue;  
  279.                     }  
  280.                 }  
  281.                 predecessor = target;  
  282.                 target = next;  
  283.             }  
  284.         }  
  285.   
  286.   
  287.         // Update list of touch targets for pointer up or cancel, if needed.  
  288.         if (canceled  
  289.                 || actionMasked == MotionEvent.ACTION_UP  
  290.                 || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {  
  291.             resetTouchState();  
  292.         } else if (split && actionMasked == MotionEvent.ACTION_POINTER_UP) {  
  293.             final int actionIndex = ev.getActionIndex();  
  294.             final int idBitsToRemove = 1 << ev.getPointerId(actionIndex);  
  295.             removePointersFromTouchTargets(idBitsToRemove);  
  296.         }  
  297.     }  
  298.   
  299.   
  300.     if (!handled && mInputEventConsistencyVerifier != null) {  
  301.         mInputEventConsistencyVerifier.onUnhandledEvent(ev, 1);  
  302.     }  
  303.     return handled;  
  304. }  


5、View對點擊事件的處理過程


（1）源碼位置在：sources\android\view\View.java

（2）在上面的頂級View中，如果頂級View沒有處理事件，而頂級View的子元素也沒有人處理這個事件，那就會到這裏來由View來處理事件。

（3）View對點擊事件的處理過程稍微簡單一些。

（4）注意，這裏的View不包含ViewGroup。只是簡單的單個View的處理，因爲他沒有子元素因此不能向下傳遞事件，所以它只能自己處理事件。

（5）下面對View源碼中的dispatchTouchEvent進行分析：


[java]  view plain  copy
  1. /** 
  2.  * Pass the touch screen motion event down to the target view, or this 
  3.  * view if it is the target. 
  4.  * 
  5.  * @param event The motion event to be dispatched. 
  6.  * @return True if the event was handled by the view, false otherwise. 
  7.  */  
  8. public boolean dispatchTouchEvent(MotionEvent event) {  
  9.     if (mInputEventConsistencyVerifier != null) {  
  10.         mInputEventConsistencyVerifier.onTouchEvent(event, 0);  
  11.     }  
  12.   
  13.     if (onFilterTouchEventForSecurity(event)) {  
  14.         //noinspection SimplifiableIfStatement  
  15.         /* 
  16.          * 首先會判斷有沒有設置OnTouchListener。 
  17.          * 如果OnTouchListener中的onTouch方法返回true，那麼onTouchEvent方法就不會調用， 
  18.          * 這樣做的好處是方便外界處理點擊事件。 
  19.          * */  
  20.         ListenerInfo li = mListenerInfo;  
  21.         if (li != null   
  22.                 && li.mOnTouchListener != null   
  23.                 && (mViewFlags & ENABLED_MASK) == ENABLED  
  24.                 && li.mOnTouchListener.onTouch(this, event)) {  
  25.             return true;  
  26.         }  
  27.   
  28.         /* 
  29.          * 優先級低於OnTouchListener 
  30.          * */  
  31.         if (onTouchEvent(event)) {  
  32.             return true;  
  33.         }  
  34.     }  
  35.   
  36.     if (mInputEventConsistencyVerifier != null) {  
  37.         mInputEventConsistencyVerifier.onUnhandledEvent(event, 0);  
  38.     }  
  39.     return false;  
  40. }  

（6）下面對View源碼中的onTouchEvent方法進行分析：

[java]  view plain  copy
  1. /** 
  2.  * Implement this method to handle touch screen motion events. 
  3.  * <p> 
  4.  * If this method is used to detect click actions, it is recommended that 
  5.  * the actions be performed by implementing and calling 
  6.  * {@link #performClick()}. This will ensure consistent system behavior, 
  7.  * including: 
  8.  * <ul> 
  9.  * <li>obeying click sound preferences 
  10.  * <li>dispatching OnClickListener calls 
  11.  * <li>handling {@link AccessibilityNodeInfo#ACTION_CLICK ACTION_CLICK} when 
  12.  * accessibility features are enabled 
  13.  * </ul> 
  14.  * 
  15.  * @param event The motion event. 
  16.  * @return True if the event was handled, false otherwise. 
  17.  */  
  18. public boolean onTouchEvent(MotionEvent event) {  
  19.     final int viewFlags = mViewFlags;  
  20.   
  21.     /* 
  22.      * 當View處於不可用狀態下時，View照樣會消耗點擊事， 
  23.      * 但它並不對事件做出任何的反映 
  24.      * */  
  25.     if ((viewFlags & ENABLED_MASK) == DISABLED) {  
  26.         if (event.getAction() == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {  
  27.             setPressed(false);  
  28.         }  
  29.           
  30.         // A disabled view that is clickable still consumes the touch  
  31.         // events, it just doesn't respond to them.  
  32.         return (((viewFlags & CLICKABLE) == CLICKABLE ||  
  33.                 (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE));  
  34.     }  
  35.   
  36.     /* 
  37.      * 如果View設置有代理，那麼還會執行mTouchDelegate的onTouchEvent方法， 
  38.      * 這個onTouchEvent的工作機制看起來和OnTouchListener類似，這裏我們不做研究 
  39.      * */  
  40.     if (mTouchDelegate != null) {  
  41.         if (mTouchDelegate.onTouchEvent(event)) {  
  42.             return true;  
  43.         }  
  44.     }  
  45.   
  46.     /* 
  47.      * 這裏是對點擊事件的具體處理。 
  48.      * 可以發現的是View的CLICKABLE和LONG_CLICKABLE只要有一個爲true， 
  49.      * 那麼這個View就消耗這個事件，即onTouchEvent返回ture，不管他是不是DISABLE狀態。 
  50.      * 這個證明了前面（8）（9）（10）的結論。 
  51.      * */  
  52.     if (((viewFlags & CLICKABLE) == CLICKABLE ||  
  53.             (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {  
  54.         switch (event.getAction()) {  
  55.         /* 
  56.          * 當up事件發生時，就會觸發performClick()方法。 
  57.          * */  
  58.             case MotionEvent.ACTION_UP:  
  59.                 boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;  
  60.                 if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {  
  61.                     // take focus if we don't have it already and we should in  
  62.                     // touch mode.  
  63.                     boolean focusTaken = false;  
  64.                     if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {  
  65.                         focusTaken = requestFocus();  
  66.                     }  
  67.   
  68.                     if (prepressed) {  
  69.                         // The button is being released before we actually  
  70.                         // showed it as pressed.  Make it show the pressed  
  71.                         // state now (before scheduling the click) to ensure  
  72.                         // the user sees it.  
  73.                         setPressed(true);  
  74.                    }  
  75.   
  76.                     if (!mHasPerformedLongPress) {  
  77.                         // This is a tap, so remove the longpress check  
  78.                         removeLongPressCallback();  
  79.   
  80.                         // Only perform take click actions if we were in the pressed state  
  81.                         if (!focusTaken) {  
  82.                             // Use a Runnable and post this rather than calling  
  83.                             // performClick directly. This lets other visual state  
  84.                             // of the view update before click actions start.  
  85.                             if (mPerformClick == null) {  
  86.                                 mPerformClick = new PerformClick();  
  87.                             }  
  88.                             if (!post(mPerformClick)) {  
  89.                                 /* 
  90.                                  * 如果View設置了OnClickListener， 
  91.                                  * 那麼performClick()方法內部會調用它的onClick方法 
  92.                                  * */  
  93.                                 performClick();  
  94.                             }  
  95.                         }  
  96.                     }  
  97.   
  98.                     if (mUnsetPressedState == null) {  
  99.                         mUnsetPressedState = new UnsetPressedState();  
  100.                     }  
  101.   
  102.                     if (prepressed) {  
  103.                         postDelayed(mUnsetPressedState,  
  104.                                 ViewConfiguration.getPressedStateDuration());  
  105.                     } else if (!post(mUnsetPressedState)) {  
  106.                         // If the post failed, unpress right now  
  107.                         mUnsetPressedState.run();  
  108.                     }  
  109.                     removeTapCallback();  
  110.                 }  
  111.                 break;  
  112.   
  113.             case MotionEvent.ACTION_DOWN:  
  114.                 mHasPerformedLongPress = false;  
  115.   
  116.                 if (performButtonActionOnTouchDown(event)) {  
  117.                     break;  
  118.                 }  
  119.   
  120.                 // Walk up the hierarchy to determine if we're inside a scrolling container.  
  121.                 boolean isInScrollingContainer = isInScrollingContainer();  
  122.   
  123.                 // For views inside a scrolling container, delay the pressed feedback for  
  124.                 // a short period in case this is a scroll.  
  125.                 if (isInScrollingContainer) {  
  126.                     mPrivateFlags |= PFLAG_PREPRESSED;  
  127.                     if (mPendingCheckForTap == null) {  
  128.                         mPendingCheckForTap = new CheckForTap();  
  129.                     }  
  130.                     postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());  
  131.                 } else {  
  132.                     // Not inside a scrolling container, so show the feedback right away  
  133.                     setPressed(true);  
  134.                     checkForLongClick(0);  
  135.                 }  
  136.                 break;  
  137.   
  138.             case MotionEvent.ACTION_CANCEL:  
  139.                 setPressed(false);  
  140.                 removeTapCallback();  
  141.                 removeLongPressCallback();  
  142.                 break;  
  143.   
  144.             case MotionEvent.ACTION_MOVE:  
  145.                 final int x = (int) event.getX();  
  146.                 final int y = (int) event.getY();  
  147.   
  148.                 // Be lenient about moving outside of buttons  
  149.                 if (!pointInView(x, y, mTouchSlop)) {  
  150.                     // Outside button  
  151.                     removeTapCallback();  
  152.                     if ((mPrivateFlags & PFLAG_PRESSED) != 0) {  
  153.                         // Remove any future long press/tap checks  
  154.                         removeLongPressCallback();  
  155.   
  156.                         setPressed(false);  
  157.                     }  
  158.                 }  
  159.                 break;  
  160.         }  
  161.         return true;  
  162.     }  
  163.   
  164.     return false;  
  165. }  


六、View的滑動衝突


1、常見的滑動衝突場景：


（1）外部滑動方向和內部滑動方向不一致。

（2）外部滑動方向和內部滑動方向一致。

（3）上面兩種情況的嵌套。


2、滑動衝突的處理規則：


具體來說：就是根據滑動是水平滑動還是豎直滑動來判斷到底由誰來攔截事件。

也就是說可以根據滑動過程中兩個點之間的座標就可以得出到底是水平滑動還是豎直滑動。


對於場景（1）如下解決辦法：（一左一右，或者一上一下）

（1）可以根據滑動路徑和水平方向的夾角。

（2）可以根據水平方向和豎直方向的距離差。

（3）可以根據水平方向和豎直方向的速度差。


對於場景（2）如下解決辦法：（同上同下，或者同左同右）

一般需要在業務上尋找突破點。

比如業務上有規定：當初與某種狀態時需要外部View相應用戶的滑動，而處於另一種狀態時需要內部View來響應View的滑動。


對於場景（3）也只能從業務上尋找突破點。



3、滑動衝突的解決方式：


（1）外部攔截法：


所謂外部攔截法就是指點擊事件都先經過父容器的攔截處理，如果父容器需要此事件就攔截，如果不需要此事件就不攔截，這樣就可以解決滑動衝突的問題，這種方法比較符合點擊事件的分發機制。

外部攔截法需要重寫父容器的 onInterceptTouchEvent 方法，在內部做出相應的攔截即可。

下面給出僞代碼：

[java]  view plain  copy
  1. @Override  
  2. public boolean onInterceptTouchEvent(MotionEvent event) {  
  3.       
  4.     boolean intercepted = false;  
  5.       
  6.     int x = (int) event.getX();  
  7.     int y = (int) event.getY();  
  8.       
  9.     int action = event.getAction();  
  10.     switch (action) {  
  11.       
  12.     case MotionEvent.ACTION_DOWN:  
  13.         // 必須爲fasle,不然父類容器攔截ACTION_DOWN以後，  
  14.         // 後續的事件序列就都由父容器處理了。  
  15.         intercepted = false;  
  16.         break;  
  17.           
  18.     case MotionEvent.ACTION_MOVE:  
  19.         if(父類容器需要當前點擊事件){  
  20.             intercepted = true;  
  21.         }             
  22.         else{  
  23.             intercepted = false;  
  24.         }  
  25.         break;  
  26.           
  27.     case MotionEvent.ACTION_UP:  
  28.         intercepted = false;//這裏也是必須的。  
  29.         break;  
  30.           
  31.     default:  
  32.         break;  
  33.     }  
  34.       
  35.     mLastXIntercept = x;  
  36.     mLastYIntercept = y;  
  37.       
  38.     return intercepted  
  39. }  


（2）內部攔截法：


內部攔截法是指父容器不攔截任何事件，所有的事件都傳遞給子元素。
如果子元素需要此事件就消耗，否則就交給父容器進行處理。
這種方法和Android中的事件分發機制不一致，需要配合 requestDisallowInterceptTouchEvent 方法才能正常工作，使用起來比外部攔截法要稍微複雜。
下面提供僞代碼，主要是重寫了子元素的 dispatchTouchEvent 方法：
[java]  view plain  copy
  1. @Override  
  2. public boolean dispatchTouchEvent(MotionEvent event) {  
  3.   
  4.     int x = (int) event.getX();  
  5.     int y = (int) event.getY();  
  6.       
  7.     switch (event.getAction()) {  
  8.       
  9.     case MotionEvent.ACTION_DOWN: {  
  10.         // 這裏的意思是設置讓父容器無法攔截ACTION_DOWN事件：  
  11.         parent.requestDisallowInterceptTouchEvent(true);  
  12.         break;  
  13.     }  
  14.       
  15.     case MotionEvent.ACTION_MOVE: {  
  16.         int deltaX = x - mLastX;  
  17.         int deltaY = y - mLastY;  
  18.         if(父容器需要此類點擊事件){  
  19.             // 如果需要的話就讓父類容器可以接收ACTION_MOVE事件。  
  20.             parent.requestDisallowInterceptTouchEvent(false);  
  21.         }  
  22.         break;  
  23.     }  
  24.     case MotionEvent.ACTION_UP: {  
  25.   
  26.         break;  
  27.     }  
  28.     default:  
  29.         break;  
  30.     }  
  31.   
  32.     mLastX = x;  
  33.     mLastY = y;  
  34.     return true;  
  35. }  
當面對不同的滑動策略時只需要修改裏面的條件即可，其他不需要做改動而且也不同有改動。
除了子元素需要做處理以外，父元素也要默認攔截除了ACTION_DOWN以外的其他事件，
（這裏ACTION_DOWN不能讓父元素默認攔截，因爲一旦父元素攔截，剩下的指令序列就都由父元素來處理了）
這樣當子元素調用 parent.requestDisallowInterceptTouchEvent(false); 方法時，父元素才能繼續攔截所需的事件。
父元素去哪裏改呢，當然是 onInterceptTouchEvent 方法啦。
[java]  view plain  copy
  1. public boolean onInterceptTouchEvent(MotionEvent event) {  
  2.     int action = event.getAction();  
  3.     if(action == MotionEvent.ACTION_DOWN) {  
  4.         return false;  
  5.     } else {  
  6.         return true;  
  7.     }  
  8. }  


我們去源碼中看一下ViewGroup中的 requestDisallowInterceptTouchEvent 這個方法吧：是通過操控disallowIntercept 來達到目的的。
[java]  view plain  copy
  1. /** 
  2.  * {@inheritDoc} 
  3.  */  
  4. public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {  
  5.   
  6.     if (disallowIntercept == ((mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0)) {  
  7.         // We're already in this state, assume our ancestors are too  
  8.         return;  
  9.     }  
  10.   
  11.     if (disallowIntercept) {  
  12.         mGroupFlags |= FLAG_DISALLOW_INTERCEPT;  
  13.     } else {  
  14.         mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;  
  15.     }  
  16.   
  17.     // Pass it up to our parent  
  18.     if (mParent != null) {  
  19.         mParent.requestDisallowInterceptTouchEvent(disallowIntercept);  
  20.     }  
  21. }  

（3）舉例：在一個水平佈局的LinearLayout中添加三個並列的ListView，所以父容器左右移動，子容器上下移動，造成衝突。

首先看一下Activity中的初始化代碼：

[java]  view plain  copy
  1. package com.ryg.chapter_3;  
  2.   
  3. import java.util.ArrayList;  
  4. import com.ryg.chapter_3.R;  
  5. import com.ryg.chapter_3.ui.HorizontalScrollViewEx;  
  6. import com.ryg.chapter_3.utils.MyUtils;  
  7.   
  8. import android.app.Activity;  
  9. import android.graphics.Color;  
  10. import android.os.Bundle;  
  11. import android.util.Log;  
  12. import android.view.GestureDetector;  
  13. import android.view.LayoutInflater;  
  14. import android.view.VelocityTracker;  
  15. import android.view.View;  
  16. import android.view.ViewConfiguration;  
  17. import android.view.ViewGroup;  
  18. import android.widget.AdapterView;  
  19. import android.widget.ArrayAdapter;  
  20. import android.widget.LinearLayout;  
  21. import android.widget.ListView;  
  22. import android.widget.TextView;  
  23. import android.widget.Toast;  
  24. import android.widget.AdapterView.OnItemClickListener;  
  25.   
  26. public class DemoActivity_1 extends Activity {  
  27.     private static final String TAG = "DemoActivity_1";  
  28.   
  29.     /* 
  30.      * HorizontalScrollViewEx mListContainer是父容器，是自定義View。 
  31.      * 下面的代碼中向父容器中添加了三個ListView。 
  32.      * */  
  33.     private HorizontalScrollViewEx mListContainer;  
  34.   
  35.     @Override  
  36.     protected void onCreate(Bundle savedInstanceState) {  
  37.         super.onCreate(savedInstanceState);  
  38.         setContentView(R.layout.demo_1);  
  39.         Log.d(TAG, "onCreate");  
  40.         initView();  
  41.     }  
  42.   
  43.     private void initView() {  
  44.         LayoutInflater inflater = getLayoutInflater();  
  45.         mListContainer = (HorizontalScrollViewEx) findViewById(R.id.container);  
  46.         final int screenWidth = MyUtils.getScreenMetrics(this).widthPixels;  
  47.         final int screenHeight = MyUtils.getScreenMetrics(this).heightPixels;  
  48.         for (int i = 0; i < 3; i++) {  
  49.             /* 
  50.              * 這個layout就是一個TextView和ListView的組合佈局，它的父容器是mListContainer 
  51.              * */  
  52.             ViewGroup layout = (ViewGroup) inflater.inflate(  
  53.                     R.layout.content_layout, mListContainer, false);  
  54.             layout.getLayoutParams().width = screenWidth;  
  55.             TextView textView = (TextView) layout.findViewById(R.id.title);  
  56.             textView.setText("page " + (i + 1));  
  57.             layout.setBackgroundColor(Color  
  58.                     .rgb(255 / (i + 1), 255 / (i + 1), 0));  
  59.             /* 
  60.              * 爲layout中的TextView和ListView添加內容： 
  61.              * */  
  62.             createList(layout);  
  63.             mListContainer.addView(layout);  
  64.         }  
  65.     }  
  66.   
  67.     /* 
  68.      * 爲layout中的TextView和ListView添加內容， 
  69.      * ListView中的每個Item又是一個TextView文本。 
  70.      * */  
  71.     private void createList(ViewGroup layout) {  
  72.         ListView listView = (ListView) layout.findViewById(R.id.list);  
  73.         ArrayList<String> datas = new ArrayList<String>();  
  74.         for (int i = 0; i < 50; i++) {  
  75.             datas.add("name " + i);  
  76.         }  
  77.   
  78.         ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,  
  79.                 R.layout.content_list_item, R.id.name, datas);  
  80.         listView.setAdapter(adapter);  
  81.         listView.setOnItemClickListener(new OnItemClickListener() {  
  82.             @Override  
  83.             public void onItemClick(AdapterView<?> parent, View view,  
  84.                     int position, long id) {  
  85.                 Toast.makeText(DemoActivity_1.this, "click item",  
  86.                         Toast.LENGTH_SHORT).show();  
  87.   
  88.             }  
  89.         });  
  90.     }  
  91.   
  92. }  


下面採用外部攔截法來解決滑動衝突問題：

我們只需要修改父容器需要攔截事件的條件即可。對於本例來說，父容器的攔截條件就是滑動過程中水平距離差比豎直距離差大，在這種情況下，父容器就攔截當前點擊事件，根據這一條件進行相應修改（正常情況下父容器的onInterceptTouchEvent都是默認返回false不攔截的），修改後的HorizontalScrollViewEx父容器的onInterceptTouchEvent方法如下所示：

[java]  view plain  copy
  1. @Override  
  2. public boolean onInterceptTouchEvent(MotionEvent event) {  
  3.     boolean intercepted = false;  
  4.     int x = (int) event.getX();  
  5.     int y = (int) event.getY();  
  6.   
  7.     switch (event.getAction()) {  
  8.     case MotionEvent.ACTION_DOWN: {  
  9.         /* 
  10.          * 這裏必須是false，不然父容器攔截了ACTION_DOWN以後，子容器再也接收不到任何事件了 
  11.          * */  
  12.         intercepted = false;  
  13.         if (!mScroller.isFinished()) {  
  14.             mScroller.abortAnimation();  
  15.             intercepted = true;  
  16.         }  
  17.         break;  
  18.     }  
  19.     case MotionEvent.ACTION_MOVE: {  
  20.         int deltaX = x - mLastXIntercept;  
  21.         int deltaY = y - mLastYIntercept;  
  22.         /* 
  23.          * 主要的邏輯就這麼點啦，呵呵 
  24.          * */  
  25.         if (Math.abs(deltaX) > Math.abs(deltaY)) {  
  26.             intercepted = true;  
  27.         } else {  
  28.             intercepted = false;  
  29.         }  
  30.         break;  
  31.     }  
  32.     case MotionEvent.ACTION_UP: {  
  33.         /* 
  34.          * 這裏也必須是false，不然如果是子容器攔截了上面的事件，子容器將接收不到up事件，就無法結束了 
  35.          * */  
  36.         intercepted = false;  
  37.         break;  
  38.     }  
  39.     default:  
  40.         break;  
  41.     }  
  42.   
  43.     Log.d(TAG, "intercepted=" + intercepted);  
  44.     mLastX = x;  
  45.     mLastY = y;  
  46.     mLastXIntercept = x;  
  47.     mLastYIntercept = y;  
  48.   
  49.     return intercepted;  
  50. }  
下面給出HorizontalScrollViewEx的完整代碼：

[java]  view plain  copy
  1. package com.ryg.chapter_3.ui;  
  2.   
  3.   
  4. import android.content.Context;  
  5. import android.util.AttributeSet;  
  6. import android.util.Log;  
  7. import android.view.MotionEvent;  
  8. import android.view.VelocityTracker;  
  9. import android.view.View;  
  10. import android.view.ViewGroup;  
  11. import android.widget.Scroller;  
  12.   
  13.   
  14. public class HorizontalScrollViewEx extends ViewGroup {  
  15.     private static final String TAG = "HorizontalScrollViewEx";  
  16.   
  17.   
  18.     private int mChildrenSize;  
  19.     private int mChildWidth;  
  20.     private int mChildIndex;  
  21.   
  22.   
  23.     // 分別記錄上次滑動的座標  
  24.     private int mLastX = 0;  
  25.     private int mLastY = 0;  
  26.     // 分別記錄上次滑動的座標(onInterceptTouchEvent)  
  27.     private int mLastXIntercept = 0;  
  28.     private int mLastYIntercept = 0;  
  29.   
  30.   
  31.     private Scroller mScroller;  
  32.     private VelocityTracker mVelocityTracker;  
  33.   
  34.   
  35.     public HorizontalScrollViewEx(Context context) {  
  36.         super(context);  
  37.         init();  
  38.     }  
  39.   
  40.   
  41.     public HorizontalScrollViewEx(Context context, AttributeSet attrs) {  
  42.         super(context, attrs);  
  43.         init();  
  44.     }  
  45.   
  46.   
  47.     public HorizontalScrollViewEx(Context context, AttributeSet attrs,  
  48.             int defStyle) {  
  49.         super(context, attrs, defStyle);  
  50.         init();  
  51.     }  
  52.   
  53.   
  54.     private void init() {  
  55.         mScroller = new Scroller(getContext());  
  56.         mVelocityTracker = VelocityTracker.obtain();  
  57.     }  
  58.   
  59.   
  60.     @Override  
  61.     public boolean onInterceptTouchEvent(MotionEvent event) {  
  62.         boolean intercepted = false;  
  63.         int x = (int) event.getX();  
  64.         int y = (int) event.getY();  
  65.   
  66.   
  67.         switch (event.getAction()) {  
  68.         case MotionEvent.ACTION_DOWN: {  
  69.         <span style="white-space:pre">    </span>/* 
  70.         <span style="white-space:pre">    </span> * 這裏必須是false，不然父容器攔截了ACTION_DOWN以後，子容器再也接收不到任何事件了 
  71.         <span style="white-space:pre">    </span> * */  
  72.             intercepted = false;  
  73.             if (!mScroller.isFinished()) {  
  74.                 mScroller.abortAnimation();  
  75.                 intercepted = true;  
  76.             }  
  77.             break;  
  78.         }  
  79.         case MotionEvent.ACTION_MOVE: {  
  80.             int deltaX = x - mLastXIntercept;  
  81.             int deltaY = y - mLastYIntercept;  
  82.             /* 
  83.              * 主要的邏輯就這麼點啦，呵呵 
  84.              * */  
  85.             if (Math.abs(deltaX) > Math.abs(deltaY)) {  
  86.                 intercepted = true;  
  87.             } else {  
  88.                 intercepted = false;  
  89.             }  
  90.             break;  
  91.         }  
  92.         case MotionEvent.ACTION_UP: {  
  93.         <span style="white-space:pre">    </span>/* 
  94.         <span style="white-space:pre">    </span> * 這裏也必須是false，不然如果是子容器攔截了上面的事件，子容器將接收不到up事件，就無法結束了 
  95.         <span style="white-space:pre">    </span> * */  
  96.             intercepted = false;  
  97.             break;  
  98.         }  
  99.         default:  
  100.             break;  
  101.         }  
  102.   
  103.   
  104.         Log.d(TAG, "intercepted=" + intercepted);  
  105.         mLastX = x;  
  106.         mLastY = y;  
  107.         mLastXIntercept = x;  
  108.         mLastYIntercept = y;  
  109.   
  110.   
  111.         return intercepted;  
  112.     }  
  113.   
  114.   
  115.     @Override  
  116.     public boolean onTouchEvent(MotionEvent event) {  
  117.         mVelocityTracker.addMovement(event);  
  118.         int x = (int) event.getX();  
  119.         int y = (int) event.getY();  
  120.         switch (event.getAction()) {  
  121.         case MotionEvent.ACTION_DOWN: {  
  122.             if (!mScroller.isFinished()) {  
  123.                 mScroller.abortAnimation();  
  124.             }  
  125.             break;  
  126.         }  
  127.         case MotionEvent.ACTION_MOVE: {  
  128.             int deltaX = x - mLastX;  
  129.             int deltaY = y - mLastY;  
  130.             scrollBy(-deltaX, 0);  
  131.             break;  
  132.         }  
  133.         /* 
  134.          * 要根據移動的距離來判斷當前顯示哪個ListView。 
  135.          * */  
  136.         case MotionEvent.ACTION_UP: {  
  137.             int scrollX = getScrollX();  
  138.             int scrollToChildIndex = scrollX / mChildWidth;  
  139.             mVelocityTracker.computeCurrentVelocity(1000);  
  140.             float xVelocity = mVelocityTracker.getXVelocity();  
  141.             if (Math.abs(xVelocity) >= 50) {  
  142.                 mChildIndex = xVelocity > 0 ? mChildIndex - 1 : mChildIndex + 1;  
  143.             } else {  
  144.                 mChildIndex = (scrollX + mChildWidth / 2) / mChildWidth;  
  145.             }  
  146.             mChildIndex = Math.max(0, Math.min(mChildIndex, mChildrenSize - 1));  
  147.             int dx = mChildIndex * mChildWidth - scrollX;  
  148.             smoothScrollBy(dx, 0);  
  149.             mVelocityTracker.clear();  
  150.             break;  
  151.         }  
  152.         default:  
  153.             break;  
  154.         }  
  155.   
  156.   
  157.         mLastX = x;  
  158.         mLastY = y;  
  159.         return true;  
  160.     }  
  161.   
  162.   
  163.     @Override  
  164.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
  165.         super.onMeasure(widthMeasureSpec, heightMeasureSpec);  
  166.         int measuredWidth = 0;  
  167.         int measuredHeight = 0;  
  168.         final int childCount = getChildCount();  
  169.         measureChildren(widthMeasureSpec, heightMeasureSpec);  
  170.   
  171.   
  172.         int widthSpaceSize = MeasureSpec.getSize(widthMeasureSpec);  
  173.         int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);  
  174.         int heightSpaceSize = MeasureSpec.getSize(heightMeasureSpec);  
  175.         int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);  
  176.         if (childCount == 0) {  
  177.             setMeasuredDimension(0, 0);  
  178.         } else if (heightSpecMode == MeasureSpec.AT_MOST) {  
  179.             final View childView = getChildAt(0);  
  180.             measuredHeight = childView.getMeasuredHeight();  
  181.             setMeasuredDimension(widthSpaceSize, childView.getMeasuredHeight());  
  182.         } else if (widthSpecMode == MeasureSpec.AT_MOST) {  
  183.             final View childView = getChildAt(0);  
  184.             measuredWidth = childView.getMeasuredWidth() * childCount;  
  185.             setMeasuredDimension(measuredWidth, heightSpaceSize);  
  186.         } else {  
  187.             final View childView = getChildAt(0);  
  188.             measuredWidth = childView.getMeasuredWidth() * childCount;  
  189.             measuredHeight = childView.getMeasuredHeight();  
  190.             setMeasuredDimension(measuredWidth, measuredHeight);  
  191.         }  
  192.     }  
  193.   
  194.   
  195.     @Override  
  196.     protected void onLayout(boolean changed, int l, int t, int r, int b) {  
  197.         int childLeft = 0;  
  198.         final int childCount = getChildCount();  
  199.         mChildrenSize = childCount;  
  200.   
  201.   
  202.         for (int i = 0; i < childCount; i++) {  
  203.             final View childView = getChildAt(i);  
  204.             if (childView.getVisibility() != View.GONE) {  
  205.                 final int childWidth = childView.getMeasuredWidth();  
  206.                 mChildWidth = childWidth;  
  207.                 childView.layout(childLeft, 0, childLeft + childWidth,  
  208.                         childView.getMeasuredHeight());  
  209.                 childLeft += childWidth;  
  210.             }  
  211.         }  
  212.     }  
  213.   
  214.   
  215.     /* 
  216.      * 彈性滑動 
  217.      * */  
  218.     private void smoothScrollBy(int dx, int dy) {  
  219.         mScroller.startScroll(getScrollX(), 0, dx, 0, 500);  
  220.         invalidate();  
  221.     }  
  222.   
  223.   
  224.     /* 
  225.      * 彈性滑動 
  226.      * */  
  227.     @Override  
  228.     public void computeScroll() {  
  229.         if (mScroller.computeScrollOffset()) {  
  230.             scrollTo(mScroller.getCurrX(), mScroller.getCurrY());  
  231.             postInvalidate();  
  232.         }  
  233.     }  
  234.   
  235.   
  236.     @Override  
  237.     protected void onDetachedFromWindow() {  
  238.         mVelocityTracker.recycle();  
  239.         super.onDetachedFromWindow();  
  240.     }  
  241. }  


下面採用內部攔截法來解決滑動衝突問題：

我們只需要修改ListView的dispatchTouchEvent方法中的父容器的攔截邏輯，同時讓父容器攔截ACTION_MOVE和ACTION_UP事件即可。爲了重寫ListView的dispatchTouchEvent方法，我們必須自定義一個ListView，稱爲ListViewEx，然後對內部攔截法的模板代碼進行修改：

[java]  view plain  copy
  1. package com.ryg.chapter_3.ui;  
  2.   
  3. import android.content.Context;  
  4. import android.util.AttributeSet;  
  5. import android.util.Log;  
  6. import android.view.MotionEvent;  
  7. import android.widget.ListView;  
  8.   
  9. public class ListViewEx extends ListView {  
  10.     private static final String TAG = "ListViewEx";  
  11.   
  12.     private HorizontalScrollViewEx2 mHorizontalScrollViewEx2;  
  13.   
  14.     // 分別記錄上次滑動的座標：  
  15.     private int mLastX = 0;  
  16.     private int mLastY = 0;  
  17.   
  18.     public ListViewEx(Context context) {  
  19.         super(context);  
  20.     }  
  21.   
  22.     public ListViewEx(Context context, AttributeSet attrs) {  
  23.         super(context, attrs);  
  24.     }  
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程