true:攔截;false:不攔截.

> View的事件分析總結：

1.view的事件可以理解成一個責任鏈模式，其實我當時就是因為了解了責任鏈模式，才會快速的理解view的事件傳遞的。
2.View的事件的排程順序是 onTouchListener –> onTouchEvent –> onLongClickListener –> onClickListener 。
3.如果他的enable為false。那他將不執行任何事件，包括ontouch。
4.如果view的ontouch消耗了事件，他不再執行任何點選事件。
5.對於click的處理，如果想只執行longclick不執行的click的方法，只有選擇不去監聽click...

  Android的事件分發是指Touch事件分發。只有搞清楚事件觸發和傳遞的機制才有可能保證在介面佈局非常複雜的情況下，UI 控制元件仍然能正確響應使用者操作。

 Android中父View和子view的點選事件的執行過程-- http://blog.csdn.net/jiangwei0910410003/article/details/16986039
 View中onTouch，onTouchEvent，onClick的執行順序??--  http://blog.csdn.net/songzeyang99/article/details/13776399
  TextView的dispatchTouchEvent方法(這個方法是每次觸發onTouch方法都會執行的)，然後是執行了onTouch方法中的ACTION_UP中的程式碼，然後執行了MyTextView中的onTouchEvent方法，當使用者彈起手指的時候又一次執行了這樣的一個過程，最後就是執行了onClick方法。
  -- ListView中的Item中如果有Button，CheckBox等這樣的元件的話，ListView中的setOnItemClick方法就是失效了，原因是Item沒有獲取焦點，焦點被Button等控制元件預設獲取到了，這裡有兩種解決方法：
第一種就是讓Button控制元件失去焦點，可以在佈局檔案中設定程式碼:android:focusable="false"即可；

第二種就是把setOnItemClick方法中的邏輯程式碼方法getView中的contentView的onClick方法中。

> onTouchEvent, onClick 、onLongClick 與onTouchEvent

1.  onTouchEvent
     onTouchEvent 中要處理的最常用的3 個事件就是：ACTION_DOWN、ACTION_MOVE、ACTION_UP。
     這三個事件標識出了最基本的使用者觸控螢幕的操作，含義也很清楚。雖然大家天天都在用它們，但是有一點請留意，ACTION_DOWN事件作為起始事件，它的重要性是要超過ACTION_MOVE 和ACTION_UP 的，如果發生了ACTION_MOVE或者ACTION_UP，那麼一定曾經發生了ACTION_DOWN 。
     從Android 的原始碼中能看到基於這種不同重要性的理解而實現的一些互動機制，SDK 中也有明確的提及，例如在ViewGroup的onInterceptTouchEvent 方法中，如果在ACTION_DOWN事件中返回了true ，那麼後續的事件將直接發給onTouchEvent ，而不是繼續發給onInterceptTouchEvent 。
2.  onClick 、onLongClick 與onTouchEvent
     曾經看過一篇帖子提到，如果在View 中處理了onTouchEvent ，那麼就不用再處理onClick 了，因為Android 只會觸發其中一個方法。這個理解是不太正確的，針對某個view ，使用者完成了一次觸碰操作，顯然從感測器上得到的訊號是手指按下和抬起兩個操作，我們可以理解為一次Click ，也可以理解為發生了一次ACTION_DOWN和ACTION_UP，那麼Android 是如何理解和處理的呢？
     在Android 中，onClick 、onLongClick 的觸發是和ACTION_DOWN 及ACTION_UP 相關的，在時序上，如果我們在一個View 中同時覆寫了onClick 、onLongClick 及onTouchEvent 的話，onTouchEvent 是最先捕捉到ACTION_DOWN 和ACTION_UP 事件的，其次才可能觸發onClick 或者onLongClick 。

-- 1.dispatchTouchEvent()事件分發，當Touch事件發生時，dispatchTouchEvent()方法會以隧道方式（即從根元素依次向內層元素傳遞）將事件向下傳遞。一般來說我們不會去改寫這個方法       
 return true ：事件交由當前view進行消費，同時事件停止向下傳遞    
 return false：事件交由上層view或者Activity進行消費      
 return super.dispatchTouchEvent()：系統預設的事件分發處理邏輯

2.onInerceptTouchEvent()事件攔截，該方法只有ViewGroup擁有。       
 return true：表示攔截事件，把攔截的事件交由當前的view處理      
 return fasle：表示不攔截事件，事件會被傳遞到子view的dispatchTouchEvent()來進行事件分發onTouchEvent()事件響應       

3.onTouchEvent()方法會以冒泡方式（即從最內層的子元素依次向外傳遞）將事件向上傳遞      
 return true：表示消費了事件，事件停止向上傳遞     
 return false：表示沒有處理事件，事件繼續向上傳遞       
 return super.onTouchEvent()：預設處理事件的邏輯，和返回false差不多

要不要攔截事件進行處理，要不要分發事件不進行處理？？？

整個View的事件轉發流程是：View.dispatchEvent->View.setOnTouchListener->View.onTouchEvent...

首先我們先寫個簡單的例子來測試View的事件轉發的流程~

1、案例

為了更好的研究View的事件轉發，我們自定以一個MyButton繼承Button，然後把跟事件傳播有關的方法進行復寫，然後新增上日誌~

MyButton

 

[java] view plain copy

1. package com.example.zhy_event03;  
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.Button;  
8.   
9. public class MyButton extends Button  
10. {  
11.     private static final String TAG = MyButton.class.getSimpleName();  
12.   
13.     public MyButton(Context context, AttributeSet attrs)  
14.     {  
15.         super(context, attrs);  
16.     }  
17.   
18.     @Override  
19.     public boolean onTouchEvent(MotionEvent event)  
20.     {  
21.         int action = event.getAction();  
22.   
23.         switch (action)  
24.         {  
25.         case MotionEvent.ACTION_DOWN:  
26.             Log.e(TAG, "onTouchEvent ACTION_DOWN");  
27.             break;  
28.         case MotionEvent.ACTION_MOVE:  
29.             Log.e(TAG, "onTouchEvent ACTION_MOVE");  
30.             break;  
31.         case MotionEvent.ACTION_UP:  
32.             Log.e(TAG, "onTouchEvent ACTION_UP");  
33.             break;  
34.         default:  
35.             break;  
36.         }  
37.         return super.onTouchEvent(event);  
38.     }  
39.       
40.     @Override  
41.     public boolean dispatchTouchEvent(MotionEvent event)  
42.     {  
43.         int action = event.getAction();  
44.   
45.         switch (action)  
46.         {  
47.         case MotionEvent.ACTION_DOWN:  
48.             Log.e(TAG, "dispatchTouchEvent ACTION_DOWN");  
49.             break;  
50.         case MotionEvent.ACTION_MOVE:  
51.             Log.e(TAG, "dispatchTouchEvent ACTION_MOVE");  
52.             break;  
53.         case MotionEvent.ACTION_UP:  
54.             Log.e(TAG, "dispatchTouchEvent ACTION_UP");  
55.             break;  
56.   
57.         default:  
58.             break;  
59.         }  
60.         return super.dispatchTouchEvent(event);  
61.     }  
62.   
63.       
64. }  

在onTouchEvent和dispatchTouchEvent中列印了日誌~

 

然後把我們自定義的按鈕加到主佈局檔案中； 佈局檔案：

 

[html] view plain copy

1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
2.     xmlns:tools="http://schemas.android.com/tools"  
3.     android:layout_width="match_parent"  
4.     android:layout_height="match_parent"  
5.     tools:context=".MainActivity" >  
6.   
7.     <com.example.zhy_event03.MyButton  
8.         android:id="@+id/id_btn"  
9.         android:layout_width="wrap_content"  
10.         android:layout_height="wrap_content"  
11.         android:text="click me" />  
12.   
13. </LinearLayout>  

最後看一眼MainActivity的程式碼

 

 

[java] view plain copy

1. package com.example.zhy_event03;  
2.   
3. import android.app.Activity;  
4. import android.os.Bundle;  
5. import android.util.Log;  
6. import android.view.MotionEvent;  
7. import android.view.View;  
8. import android.view.View.OnTouchListener;  
9. import android.widget.Button;  
10.   
11. public class MainActivity extends Activity  
12. {  
13.     protected static final String TAG = "MyButton";  
14.     private Button mButton ;  
15.     @Override  
16.     protected void onCreate(Bundle savedInstanceState)  {  
17.         super.onCreate(savedInstanceState);  
18.         setContentView(R.layout.activity_main);  
19.           
20.         mButton = (Button) findViewById(R.id.id_btn);  
21.         mButton.setOnTouchListener(new OnTouchListener()  
22.         {  
23.             @Override  
24.             public boolean onTouch(View v, MotionEvent event)  
25.             {  
26.                 int action = event.getAction();  
27.   
28.                 switch (action)  
29.                 {  
30.                 case MotionEvent.ACTION_DOWN:  
31.                     Log.e(TAG, "onTouch ACTION_DOWN");  
32.                     break;  
33.                 case MotionEvent.ACTION_MOVE:  
34.                     Log.e(TAG, "onTouch ACTION_MOVE");  
35.                     break;  
36.                 case MotionEvent.ACTION_UP:  
37.                     Log.e(TAG, "onTouch ACTION_UP");  
38.                     break;  
39.                 default:  
40.                     break;  
41.                 }  
42.                   
43.                 return false;  
44.             }  
45.         });  
46.     }  
47.   
48.       
49. }  

在MainActivity中，我們還給MyButton設定了OnTouchListener這個監聽~

 

好了，跟View事件相關一般就這三個地方了，一個onTouchEvent，一個dispatchTouchEvent，一個setOnTouchListener;

下面我們執行，然後點選按鈕，檢視日誌輸出：

 

[html] view plain copy

1. 08-31 06:09:39.030: E/MyButton(879): dispatchTouchEvent ACTION_DOWN  
2. 08-31 06:09:39.030: E/MyButton(879): onTouch ACTION_DOWN  
3. 08-31 06:09:39.049: E/MyButton(879): onTouchEvent ACTION_DOWN
4.   
5. 08-31 06:09:39.138: E/MyButton(879): dispatchTouchEvent ACTION_MOVE  
6. 08-31 06:09:39.138: E/MyButton(879): onTouch ACTION_MOVE  
7. 08-31 06:09:39.147: E/MyButton(879): onTouchEvent ACTION_MOVE
8.   
9. 08-31 06:09:39.232: E/MyButton(879): dispatchTouchEvent ACTION_UP  
10. 08-31 06:09:39.248: E/MyButton(879): onTouch ACTION_UP  
11. 08-31 06:09:39.248: E/MyButton(879): onTouchEvent ACTION_UP  

我有意點選的時候蹭了一下，不然不會觸發MOVE，手抖可能會列印一堆MOVE的日誌~~~

 

好了，可以看到，不管是DOWN，MOVE，UP都會按照下面的順序執行：

1、dispatchTouchEvent()；2、 setOnTouchListener的onTouch()；3、onTouchEvent()

下面就跟隨日誌的腳步開始原始碼的探索~

2、dispatchTouchEvent

首先進入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 (!onFilterTouchEventForSecurity(event)) {  
10.             return false;  
11.         }  
12.   
13.         if (mOnTouchListener != null && (mViewFlags & ENABLED_MASK) == ENABLED &&  
14.                 mOnTouchListener.onTouch(this, event)) {  
15.             return true;  
16.         }  
17.         return onTouchEvent(event);  
18.     }  

直接看13行：首先判斷mOnTouchListener不為null，並且view是enable的狀態，然後 mOnTouchListener.onTouch(this, event)返回true，這三個條件如果都滿足，直接return true ; 也就是下面的onTouchEvent(event）不會被執行了；

 

那麼mOnTouchListener是和方神聖，我們來看看：

 

[java] view plain copy

1. /** 
2.   * Register a callback to be invoked when a touch event is sent to this view. 
3.   * @param l the touch listener to attach to this view 
4.   */  
5.  public void setOnTouchListener(OnTouchListener l) {  
6.      mOnTouchListener = l;  
7.  }  

其實就是我們在Activity中設定的setOnTouchListener。

 

也就是說：如果我們設定了setOnTouchListener，並且return true，那麼View自己的onTouchEvent就不會被執行了，當然了，本例我們return false，我們還得往下探索 ;

已經解決一個常見的問題：View的onTouchListener和onTouchEvent的呼叫關係，相信大家應該已經明白了~let's go；繼續往下。

 3、View的onTouchEvent:

接下來是View的onTouchEvent:

 

[java] view plain copy

1. /** 
2.      * Implement this method to handle touch screen motion events. 
3.      * 
4.      * @param event The motion event. 
5.      * @return True if the event was handled, false otherwise. 
6.      */  
7.     public boolean onTouchEvent(MotionEvent event) {  
8.         final int viewFlags = mViewFlags;  
9.   
10.         if ((viewFlags & ENABLED_MASK) == DISABLED) {  
11.             // A disabled view that is clickable still consumes the touch  
12.             // events, it just doesn't respond to them.  
13.             return (((viewFlags & CLICKABLE) == CLICKABLE ||  
14.                     (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE));  
15.         }  
16.         if (mTouchDelegate != null) {  
17.             if (mTouchDelegate.onTouchEvent(event)) {  
18.                 return true;  
19.             }  
20.         }  
21.         if (((viewFlags & CLICKABLE) == CLICKABLE ||  
22.                 (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {  
23.             switch (event.getAction()) {  
24.                 case MotionEvent.ACTION_UP:  
25.                     boolean prepressed = (mPrivateFlags & PREPRESSED) != 0;  
26.                     if ((mPrivateFlags & PRESSED) != 0 || prepressed) {  
27.                         // take focus if we don't have it already and we should in  
28.                         // touch mode.  
29.                         boolean focusTaken = false;  
30.                         if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {  
31.                             focusTaken = requestFocus();  
32.                         }  
33.   
34.                         if (!mHasPerformedLongPress) {  
35.                             // This is a tap, so remove the longpress check  
36.                             removeLongPressCallback();  
37.   
38.                             // Only perform take click actions if we were in the pressed state  
39.                             if (!focusTaken) {  
40.                                 // Use a Runnable and post this rather than calling  
41.                                 // performClick directly. This lets other visual state  
42.                                 // of the view update before click actions start.  
43.                                 if (mPerformClick == null) {  
44.                                     mPerformClick = new PerformClick();  
45.                                 }  
46.                                 if (!post(mPerformClick)) {  
47.                                     performClick();  
48.                                 }  
49.                             }  
50.                         }  
51.   
52.                         if (mUnsetPressedState == null) {  
53.                             mUnsetPressedState = new UnsetPressedState();  
54.                         }  
55.   
56.                         if (prepressed) {  
57.                             mPrivateFlags |= PRESSED;  
58.                             refreshDrawableState();  
59.                             postDelayed(mUnsetPressedState,  
60.                                     ViewConfiguration.getPressedStateDuration());  
61.                         } else if (!post(mUnsetPressedState)) {  
62.                             // If the post failed, unpress right now  
63.                             mUnsetPressedState.run();  
64.                         }  
65.                         removeTapCallback();  
66.                     }  
67.                     break;  
68.   
69.                 case MotionEvent.ACTION_DOWN:  
70.                     if (mPendingCheckForTap == null) {  
71.                         mPendingCheckForTap = new CheckForTap();  
72.                     }  
73.                     mPrivateFlags |= PREPRESSED;  
74.                     mHasPerformedLongPress = false;  
75.                     postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());  
76.                     break;  
77.   
78.                 case MotionEvent.ACTION_CANCEL:  
79.                     mPrivateFlags &= ~PRESSED;  
80.                     refreshDrawableState();  
81.                     removeTapCallback();  
82.                     break;  
83.   
84.                 case MotionEvent.ACTION_MOVE:  
85.                     final int x = (int) event.getX();  
86.                     final int y = (int) event.getY();  
87.   
88.                     // Be lenient about moving outside of buttons  
89.                     int slop = mTouchSlop;  
90.                     if ((x < 0 - slop) || (x >= getWidth() + slop) ||  
91.                             (y < 0 - slop) || (y >= getHeight() + slop)) {  
92.                         // Outside button  
93.                         removeTapCallback();  
94.                         if ((mPrivateFlags & PRESSED) != 0) {  
95.                             // Remove any future long press/tap checks  
96.                             removeLongPressCallback();  
97.   
98.                             // Need to switch from pressed to not pressed  
99.                             mPrivateFlags &= ~PRESSED;  
100.                             refreshDrawableState();  
101.                         }  
102.                     }  
103.                     break;  
104.             }  
105.             return true;  
106.         }  
107.   
108.         return false;  
109.     }  

程式碼還是比較長的，

10-15行，如果當前View是Disabled狀態且是可點選則會消費掉事件（return true);可以忽略，不是我們的重點；

 

17-21行，如果設定了mTouchDelegate，則會將事件交給代理者處理，直接return true，如果大家希望自己的View增加它的touch範圍，可以嘗試使用TouchDelegate，這裡也不是重點，可以忽略；

 

接下來到我們的重點了：

23行的判斷：如果我們的View可以點選或者可以長按，則，注意IF的範圍，最終一定return true ;

 if (((viewFlags & CLICKABLE) == CLICKABLE ||
                (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {
           //...
            return true;
        }

接下來就是   switch (event.getAction())了，判斷事件型別，DOWN,MOVE,UP等；

我們按照例子執行的順序，先看  case MotionEvent.ACTION_DOWN （71-78行）:

--------------------------------

1、MotionEvent.ACTION_DOWN

75行：給mPrivateFlags設定一個PREPRESSED的標識

76行：設定mHasPerformedLongPress=false；表示長按事件還未觸發；

77行：傳送一個延遲為ViewConfiguration.getTapTimeout()的延遲訊息，到達延時時間後會執行CheckForTap()裡面的run方法：

1、ViewConfiguration.getTapTimeout()為115毫秒；

2、CheckForTap

 

[java] view plain copy

1. private final class CheckForTap implements Runnable {  
2.       public void run() {  
3.           mPrivateFlags &= ~PREPRESSED;  
4.           mPrivateFlags |= PRESSED;  
5.           refreshDrawableState();  
6.           if ((mViewFlags & LONG_CLICKABLE) == LONG_CLICKABLE) {  
7.               postCheckForLongClick(ViewConfiguration.getTapTimeout());  
8.           }  
9.       }  
10.   }  

在run方法裡面取消mPrivateFlags的PREPRESSED，然後設定PRESSED標識，重新整理背景，如果View支援長按事件，則再發一個延時訊息，檢測長按；

 

[java] view plain copy

1. private void postCheckForLongClick(int delayOffset) {  
2.        mHasPerformedLongPress = false;  
3.        if (mPendingCheckForLongPress == null) {  
4.            mPendingCheckForLongPress = new CheckForLongPress();  
5.        }  
6.        mPendingCheckForLongPress.rememberWindowAttachCount();  
7.        postDelayed(mPendingCheckForLongPress,  
8.                ViewConfiguration.getLongPressTimeout() - delayOffset);  
9.    }  

[java] view plain copy

1. class CheckForLongPress implements Runnable {  
2.   
3.         private int mOriginalWindowAttachCount;  
4.         public void run() {  
5.             if (isPressed() && (mParent != null)  
6.                     && mOriginalWindowAttachCount == mWindowAttachCount) {  
7.                 if (performLongClick()) {  
8.                     mHasPerformedLongPress = true;  
9.                 }  
10.             }  
11.         }  

可以看到，當使用者按下，首先會設定標識為PREPRESSED

 

如果115後，沒有抬起，會將View的標識設定為PRESSED且去掉PREPRESSED標識，然後發出一個檢測長按的延遲任務，延時為：ViewConfiguration.getLongPressTimeout() - delayOffset（500ms -115ms），這個115ms剛好時檢測額PREPRESSED時間；也就是使用者從DOWN觸發開始算起，如果500ms內沒有抬起則認為觸發了長按事件：

1、如果此時設定了長按的回撥，則執行長按時的回撥，且如果長按的回撥返回true;才把mHasPerformedLongPress置為ture；

2、否則，如果沒有設定長按回撥或者長按回撥返回的是false；則mHasPerformedLongPress依然是false;

好了DOWN就分析完成了；大家回個神，下面回到VIEW的onTouchEvent中的ACTION_MOVE:

 

2、MotionEvent.ACTION_MOVE

 

86到105行：

87-88行：拿到當前觸控的x,y座標；

91行判斷當然觸控點有沒有移出我們的View，如果移出了：

1、執行removeTapCallback(); 

2、然後判斷是否包含PRESSED標識，如果包含，移除長按的檢查：removeLongPressCallback();

3、最後把mPrivateFlags中PRESSED標識去除，重新整理背景；

 

[java] view plain copy

1. private void removeTapCallback() {  
2.        if (mPendingCheckForTap != null) {  
3.            mPrivateFlags &= ~PREPRESSED;  
4.            removeCallbacks(mPendingCheckForTap);  
5.        }  
6.    }  

這個是移除，DOWN觸發時設定的PREPRESSED的檢測；即當前觸發時機在DOWN觸發不到115ms時，你就已經移出控制元件外了；

 

如果115ms後，你才移出控制元件外，則你的當前mPrivateFlags一定為PRESSED且傳送了長按的檢測；

就會走上面的2和3；首先移除removeLongPressCallback（）
 private void removeLongPressCallback() {
        if (mPendingCheckForLongPress != null) {
          removeCallbacks(mPendingCheckForLongPress);
        }
    }

然後把mPrivateFlags中PRESSED標識去除，重新整理背景；

好了，MOVE我們也分析完成了，總結一下：只要使用者移出了我們的控制元件：則將mPrivateFlags取出PRESSED標識，且移除所有在DOWN中設定的檢測，長按等；

下面再回個神，回到View的onTouchEvent的ACTION_UP：

 

3、MotionEvent.ACTION_UP

 

26到69行：

27行：判斷mPrivateFlags是否包含PREPRESSED

28行：如果包含PRESSED或者PREPRESSED則進入執行體，也就是無論是115ms內或者之後抬起都會進入執行體。

36行：如果mHasPerformedLongPress沒有被執行，進入IF

38行：removeLongPressCallback（）；移除長按的檢測

45-50行：如果mPerformClick如果mPerformClick為null，初始化一個例項，然後立即通過handler新增到訊息佇列尾部，如果新增失敗則直接執行 performClick();新增成功，在mPerformClick的run方法中就是執行performClick（）；

終於執行了我們的click事件了，下面看一下performClick()方法：

 

[java] view plain copy

1. public boolean performClick() {  
2.        sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);  
3.   
4.        if (mOnClickListener != null) {  
5.            playSoundEffect(SoundEffectConstants.CLICK);  
6.            mOnClickListener.onClick(this);  
7.            return true;  
8.        }  
9.   
10.        return false;  
11.    }  

if (mOnClickListener != null) {    
            mOnClickListener.onClick(this);
            return true;
        }

 

 

 

久違了~我們的mOnClickListener ；

別激動，還沒結束，回到ACTION_UP，

58行：如果prepressed為true，進入IF體：

為mPrivateFlags設定表示為PRESSED，重新整理背景，125毫秒後執行mUnsetPressedState

否則：mUnsetPressedState.run();立即執行；也就是不管咋樣，最後mUnsetPressedState.run()都會執行；

看看這個UnsetPressedState主要幹什麼:

  private final class UnsetPressedState implements Runnable {
        public void run() {
            setPressed(false);
        }
    }

 public void setPressed(boolean pressed) {
        if (pressed) {
            mPrivateFlags |= PRESSED;
        } else {
            mPrivateFlags &= ~PRESSED;
        }
        refreshDrawableState();
        dispatchSetPressed(pressed);
    }

把我們的mPrivateFlags中的PRESSED取消，然後重新整理背景，把setPress轉發下去。

ACTION_UP的最後一行：removeTapCallback()，如果mPendingCheckForTap不為null，移除;

4、總結

好了，程式碼跨度還是相當大的，下面需要總結下：

1、整個View的事件轉發流程是：

View.dispatchEvent->View.setOnTouchListener->View.onTouchEvent

在dispatchTouchEvent中會進行OnTouchListener的判斷，如果OnTouchListener不為null且返回true，則表示事件被消費，onTouchEvent不會被執行；否則執行onTouchEvent。

2、onTouchEvent中的DOWN,MOVE,UP

 DOWN時：

a、首先設定標誌為PREPRESSED，設定mHasPerformedLongPress=false ;然後發出一個115ms後的mPendingCheckForTap；

b、如果115ms內沒有觸發UP，則將標誌置為PRESSED，清除PREPRESSED標誌，同時發出一個延時為500-115ms的，檢測長按任務訊息；

c、如果500ms內（從DOWN觸發開始算），則會觸發LongClickListener:

此時如果LongClickListener不為null，則會執行回撥，同時如果LongClickListener.onClick返回true，才把mHasPerformedLongPress設定為true;否則mHasPerformedLongPress依然為false;

 

 MOVE時：

主要就是檢測使用者是否劃出控制元件，如果劃出了：

115ms內，直接移除mPendingCheckForTap；

115ms後，則將標誌中的PRESSED去除，同時移除長按的檢查：removeLongPressCallback();

 UP時：

a、如果115ms內，觸發UP，此時標誌為PREPRESSED，則執行UnsetPressedState，setPressed(false);會把setPress轉發下去，可以在View中複寫dispatchSetPressed方法接收；

b、如果是115ms-500ms間，即長按還未發生，則首先移除長按檢測，執行onClick回撥；

c、如果是500ms以後，那麼有兩種情況：

 

i.設定了onLongClickListener，且onLongClickListener.onClick返回true，則點選事件OnClick事件無法觸發；

ii.沒有設定onLongClickListener或者onLongClickListener.onClick返回false，則點選事件OnClick事件依然可以觸發；

d、最後執行mUnsetPressedState.run()，將setPressed傳遞下去，然後將PRESSED標識去除；

 

>最後問個問題，然後再執行個例子結束：

1、setOnLongClickListener和setOnClickListener是否只能執行一個

不是的，只要setOnLongClickListener中的onClick返回false，則兩個都會執行；返回true則會螢幕setOnClickListener

最後我們給MyButton同時設定setOnClickListener和setOnLongClickListener，執行看看：

 

[java] view plain copy

1. package com.example.zhy_event03;  
2.   
3. import android.app.Activity;  
4. import android.os.Bundle;  
5. import android.util.Log;  
6. import android.view.MotionEvent;  
7. import android.view.View;  
8. import android.view.View.OnClickListener;  
9. import android.view.View.OnLongClickListener;  
10. import android.view.View.OnTouchListener;  
11. import android.widget.Button;  
12. import android.widget.Toast;  
13.   
14. public class MainActivity extends Activity  
15. {  
16.     protected static final String TAG = "MyButton";  
17.     private Button mButton ;  
18.     @Override  
19.     protected void onCreate(Bundle savedInstanceState)  
20.     {  
21.         super.onCreate(savedInstanceState);  
22.         setContentView(R.layout.activity_main);  
23.           
24.         mButton = (Button) findViewById(R.id.id_btn);  
25.         mButton.setOnTouchListener(new OnTouchListener()  
26.         {  
27.             @Override  
28.             public boolean onTouch(View v, MotionEvent event)  
29.             {  
30.                 int action = event.getAction();  
31.   
32.                 switch (action)  
33.                 {  
34.                 case MotionEvent.ACTION_DOWN:  
35.                     Log.e(TAG, "onTouch ACTION_DOWN");  
36.                     break;  
37.                 case MotionEvent.ACTION_MOVE:  
38.                     Log.e(TAG, "onTouch ACTION_MOVE");  
39.                     break;  
40.                 case MotionEvent.ACTION_UP:  
41.                     Log.e(TAG, "onTouch ACTION_UP");  
42.                     break;  
43.                 default:  
44.                     break;  
45.                 }  
46.                   
47.                 return false;  
48.             }  
49.         });  
50.         mButton.setOnClickListener(new OnClickListener()  
51.         {  
52.             @Override  
53.             public void onClick(View v)  
54.             {  
55.                 Toast.makeText(getApplicationContext(), "onclick",Toast.LENGTH_SHORT).show();  
56.             }  
57.         });  
58.           
59.         mButton.setOnLongClickListener(new OnLongClickListener()  
60.         {  
61.             @Override  
62.             public boolean onLongClick(View v)  
63.             {  
64.                 Toast.makeText(getApplicationContext(), "setOnLongClickListener",Toast.LENGTH_SHORT).show();  
65.                 return false;  
66.             }  
67.         });  
68.     }  
69.   
70.       
71. }  

效果圖：

 

可以看到LongClickListener已經ClickListener都觸發了~

    最後，本篇博文完成了對View的事件分發機制的整個流程的說明，並且對原始碼進行了分析；