【轉】Android onTouch()和onTouchEvent()區別

1、onTouch()方法：

　　onTouch方式是View的OnTouchListener接口中定義的方法。

　　當一個View綁定了OnTouchListener后，當有Touch事件觸發時，就會調用onTouch方法。

　　（當把手放到View上后，onTouch方法被一遍一遍的調用）

 

2、onTouchEvent()方法：

　　onTouchEvent方法時重載的Activity的方法

　　重寫了Acitivity的onTouchEvent方法后，當屏幕有Touch事件時，此方法就會被調用。

　　（當把手放到Activity上時，onTouchEvent方法會一遍一遍的被調用）

 

3、Touch事件的傳遞：

　　在一個Activity里面放一個TextView的實例tv，並且這個tv的屬性設定為march_parent

　　在這種情況下，當手放到屏幕上的時候，首先會是tv響應Touch事件，執行onTouch方法。

　

　　如果onTouch返回值為true,表示這個Touch事件被onTouch方法處理完畢，不會把Touch事件再傳遞給Activity

　　也就是說onTouchEvent方法不會被調用

　　（手放到屏幕上后，onTouch方法會被一遍一遍的調用）

 

 

　　如果onTouch返回值為false,表示這個Touch事件沒有被tv完全處理，onTouch返回以后，Touch事件被傳遞給Activity,

　　onTouchEvent方法調用

　　（當把手放到屏幕上后，onTouch方法調用一次后，onTouchEvent方法被一遍一遍的調用）

 

測試：

1、MyLinearLayout繼承LinearLayout,並重寫onTouchEvent方法

 

import android.content.Context;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.widget.LinearLayout;

public class MyLinearLayout extends LinearLayout{

    public MyLinearLayout(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        switch (event.getAction()) {
        case MotionEvent.ACTION_DOWN://0
            Log.e("TAG", "LinearLayout onTouchEvent 按住");
            break;
        case MotionEvent.ACTION_UP://1
            Log.e("TAG", "LinearLayout onTouchEvent onTouch抬起");
            break;
        case MotionEvent.ACTION_MOVE://2
            Log.e("TAG", "LinearLayout onTouchEvent 移動");
            break;    
        }
        return super.onTouchEvent(event);
    }
    
    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        return super.dispatchTouchEvent(ev);
    }
    
    @Override
    public void setOnTouchListener(OnTouchListener l) {
        super.setOnTouchListener(l);
    }
    
}

 

 

2、在MainActivity中聲明MyLinearLayout，並設置觸摸監聽和點擊監聽，同時MainActivity自己也有onTouchEvent方法，重寫看結果

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.View.OnTouchListener;

public class MainActivity extends Activity {

    MyLinearLayout ll;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        ll = (MyLinearLayout) findViewById(R.id.ll);
        //觸摸監聽
        ll.setOnTouchListener(new OnTouchListener() {
            
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                //Log.e("TAG", event.getX()+" "+event.getY());
                
                switch (event.getAction()) {
                case MotionEvent.ACTION_DOWN://0
                    Log.e("TAG", "LinearLayout onTouch按住");
                    break;
                case MotionEvent.ACTION_UP://1
                    Log.e("TAG", "LinearLayout onTouch抬起");
                    break;
                case MotionEvent.ACTION_MOVE://2
                    Log.e("TAG", "LinearLayout onTouch移動");
                    break;    
                }
                //事件分發
                //1、setOnTouchListener單獨使用的時候返回值需要true,這樣才能保證移動的時候獲取相應的監聽，而非一次監聽（即只有按下事件）
                    //返回false,表示沒有被處理，將向父View傳遞。只能監聽到view的"按下"事件，"移動"和"抬起"都不能監聽到。因為down事件未結束
                    //返回true,消耗此事件，表示正確接收並處理,不在分發。"按下""抬起""移動"都能監聽到了
                
                //2、setOnTouchListener和setOnClickListener同時使用時，
                    //返回true,事件被onTouch消耗掉了，因而不會在繼續向下傳遞。只能監聽"按下""抬起""移動",不能監聽到"點擊"；
                    //返回false,"按下""抬起""移動""點擊"都能監聽
                 
                return false;
                /**
                 * onTouch是優先於onClick的，並且執行了兩次，一次是ACTION_DOWN,一次是ACTION_UP(可能還會有多次ACTION_MOVE)，
                 * 因此事件傳遞的順序是先經過OnTouch,再傳遞給onClick
                 *
                 */
            }
        });
        
        ll.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.e("TAG", "onClick點擊事件");
            }
        });
    }
    
    //事件分發：public boolean dispatchTouchEvent(MotionEvent ev)
    //當監聽到事件時，首先由Activity的捕獲到，進入事件分發處理流程，無論是Activity還是View,事件分發自身也具有消費能力
    //如果事件分發返回true,表示該事件在本層不再進行分發且已經已經在事件分發自身中被消費了。
    //如果你不想Activity中的任何控件具有任何的事件消費能力，可以直接重寫Activity的dispatchTouchEvent方法，返回true就可以了
    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        // TODO Auto-generated method stub
        return super.dispatchTouchEvent(ev);
    }
    
    
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        switch (event.getAction()) {
        case MotionEvent.ACTION_DOWN://0
            Log.e("TAG", "Activity onTouchEvent按住");
            break;
        case MotionEvent.ACTION_UP://1
            Log.e("TAG", "Activity onTouchEvent抬起");
            break;
        case MotionEvent.ACTION_MOVE://2
            Log.e("TAG", "Activity onTouchEvent移動");
            break;    
        }
        return super.onTouchEvent(event);
    }

    
}

 

3、由於MyLinearLayout繼承了LinearLayou，但是XML並不認識他，所以在xml中搭建布局的時候，一定要包名帶類名

<com.example.lesson6_ontouch.MyLinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
       android:id="@+id/ll"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

       <TextView
           android:id="@+id/tv"
           android:layout_width="match_parent"
           android:layout_height="match_parent"
           android:text="hsss"/>

</com.example.lesson6_ontouch.MyLinearLayout>

 

測試結果：

4、下面貼一位博主的分析 Android事件分發機制完全解析，帶你從源碼的角度徹底理解(上) 

首先你需要知道一點，只要你觸摸到了任何一個控件，就一定會調用該控件的dispatchTouchEvent方法。那當我們去點擊按鈕的時候，就會去調用Button類里的dispatchTouchEvent方法，可是你會發現Button類里並沒有這個方法，那么就到它的父類TextView里去找一找，你會發現TextView里也沒有這個方法，那沒辦法了，只好繼續在TextView的父類View里找一找，這個時候你終於在View里找到了這個方法，示意圖如下：

            

然后我們來看一下View中dispatchTouchEvent方法的源碼：

public boolean dispatchTouchEvent(MotionEvent event) {  
    if (mOnTouchListener != null && (mViewFlags & ENABLED_MASK) == ENABLED &&  
            mOnTouchListener.onTouch(this, event)) {  
        return true;  
    }  
    return onTouchEvent(event);  
}  

我們可以看到，在這個方法內，首先是進行了一個判斷，如果mOnTouchListener != null，(mViewFlags & ENABLED_MASK) == ENABLED和mOnTouchListener.onTouch(this, event)這三個條件都為真，就返回true，否則就去執行onTouchEvent(event)方法並返回。

先看一下第一個條件，mOnTouchListener這個變量是在哪里賦值的呢？我們尋找之后在View里發現了如下方法：

 

public void setOnTouchListener(OnTouchListener l) {  
    mOnTouchListener = l;  
}  

mOnTouchListener正是在setOnTouchListener方法里賦值的，也就是說只要我們給控件注冊了touch事件，mOnTouchListener就一定被賦值了。

 

第二個條件(mViewFlags & ENABLED_MASK) == ENABLED是判斷當前點擊的控件是否是enable的，按鈕默認都是enable的，因此這個條件恆定為true。

第三個條件就比較關鍵了，mOnTouchListener.onTouch(this, event)，其實也就是去回調控件注冊touch事件時的onTouch方法。也就是說如果我們在onTouch方法里返回true，就會讓這三個條件全部成立，從而整個方法直接返回true。如果我們在onTouch方法里返回false，就會再去執行onTouchEvent(event)方法。

 

現在我們可以結合前面的例子來分析一下了，首先在dispatchTouchEvent中最先執行的就是onTouch方法，因此onTouch肯定是要優先於onClick執行的，也是印證了剛剛的打印結果。而如果在onTouch方法里返回了true，就會讓dispatchTouchEvent方法直接返回true，不會再繼續往下執行。而打印結果也證實了如果onTouch返回true，onClick就不會再執行了。

 

 根據以上源碼的分析，從原理上解釋了我們前面例子的運行結果。而上面的分析還透漏出了一個重要的信息，那就是onClick的調用肯定是在onTouchEvent(event)方法中的！那我們馬上來看下onTouchEvent的源碼，如下所示：

 

public boolean onTouchEvent(MotionEvent event) {
        final float x = event.getX();
        final float y = event.getY();
        final int viewFlags = mViewFlags;
        final int action = event.getAction();

        if ((viewFlags & ENABLED_MASK) == DISABLED) {
            if (action == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
                setPressed(false);
            }
            // A disabled view that is clickable still consumes the touch
            // events, it just doesn't respond to them.
            return (((viewFlags & CLICKABLE) == CLICKABLE
                    || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
                    || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE);
        }
        if (mTouchDelegate != null) {
            if (mTouchDelegate.onTouchEvent(event)) {
                return true;
            }
        }

        if (((viewFlags & CLICKABLE) == CLICKABLE ||
                (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE) ||
                (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE) {
            switch (action) {
                case MotionEvent.ACTION_UP:
                    boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
                    if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {
                        // take focus if we don't have it already and we should in
                        // touch mode.
                        boolean focusTaken = false;
                        if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {
                            focusTaken = requestFocus();
                        }

                        if (prepressed) {
                            // The button is being released before we actually
                            // showed it as pressed.  Make it show the pressed
                            // state now (before scheduling the click) to ensure
                            // the user sees it.
                            setPressed(true, x, y);
                       }

                        if (!mHasPerformedLongPress && !mIgnoreNextUpEvent) {
                            // This is a tap, so remove the longpress check
                            removeLongPressCallback();

                            // Only perform take click actions if we were in the pressed state
                            if (!focusTaken) {
                                // Use a Runnable and post this rather than calling
                                // performClick directly. This lets other visual state
                                // of the view update before click actions start.
                                if (mPerformClick == null) {
                                    mPerformClick = new PerformClick();
                                }
                                if (!post(mPerformClick)) {
                                    performClick();
                                }
                            }
                        }

                        if (mUnsetPressedState == null) {
                            mUnsetPressedState = new UnsetPressedState();
                        }

                        if (prepressed) {
                            postDelayed(mUnsetPressedState,
                                    ViewConfiguration.getPressedStateDuration());
                        } else if (!post(mUnsetPressedState)) {
                            // If the post failed, unpress right now
                            mUnsetPressedState.run();
                        }

                        removeTapCallback();
                    }
                    mIgnoreNextUpEvent = false;
                    break;

                case MotionEvent.ACTION_DOWN:
                    mHasPerformedLongPress = false;

                    if (performButtonActionOnTouchDown(event)) {
                        break;
                    }

                    // Walk up the hierarchy to determine if we're inside a scrolling container.
                    boolean isInScrollingContainer = isInScrollingContainer();

                    // For views inside a scrolling container, delay the pressed feedback for
                    // a short period in case this is a scroll.
                    if (isInScrollingContainer) {
                        mPrivateFlags |= PFLAG_PREPRESSED;
                        if (mPendingCheckForTap == null) {
                            mPendingCheckForTap = new CheckForTap();
                        }
                        mPendingCheckForTap.x = event.getX();
                        mPendingCheckForTap.y = event.getY();
                        postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
                    } else {
                        // Not inside a scrolling container, so show the feedback right away
                        setPressed(true, x, y);
                        checkForLongClick(0, x, y);
                    }
                    break;

                case MotionEvent.ACTION_CANCEL:
                    setPressed(false);
                    removeTapCallback();
                    removeLongPressCallback();
                    mInContextButtonPress = false;
                    mHasPerformedLongPress = false;
                    mIgnoreNextUpEvent = false;
                    break;

                case MotionEvent.ACTION_MOVE:
                    drawableHotspotChanged(x, y);

                    // Be lenient about moving outside of buttons
                    if (!pointInView(x, y, mTouchSlop)) {
                        // Outside button
                        removeTapCallback();
                        if ((mPrivateFlags & PFLAG_PRESSED) != 0) {
                            // Remove any future long press/tap checks
                            removeLongPressCallback();

                            setPressed(false);
                        }
                    }
                    break;
            }

            return true;
        }

        return false;
    }

 

相較於剛才的dispatchTouchEvent方法，onTouchEvent方法復雜了很多，不過沒關系，我們只挑重點看就可以了。

 

首先在第23行我們可以看出，如果該控件是可以點擊的就會進入到第26行的switch判斷中去，而如果當前的事件是抬起手指，則會進入到MotionEvent.ACTION_UP這個case當中。在經過種種判斷之后，會執行到第58行的performClick()方法，那我們進入到這個方法里瞧一瞧：

public boolean performClick() {  
    sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);  
    if (mOnClickListener != null) {  
        playSoundEffect(SoundEffectConstants.CLICK);  
        mOnClickListener.onClick(this);  
        return true;  
    }  
    return false;  
}  

可以看到，只要mOnClickListener不是null，就會去調用它的onClick方法，那mOnClickListener又是在哪里賦值的呢？經過尋找后找到如下方法：

 

public void setOnClickListener(OnClickListener l) {  
    if (!isClickable()) {  
        setClickable(true);  
    }  
    mOnClickListener = l;  
} 

 

 一切都是那么清楚了！當我們通過調用setOnClickListener方法來給控件注冊一個點擊事件時，就會給mOnClickListener賦值。然后每當控件被點擊時，都會在performClick()方法里回調被點擊控件的onClick方法。

 

這樣View的整個事件分發的流程就讓我們搞清楚了！不過別高興的太早，現在還沒結束，還有一個很重要的知識點需要說明，就是touch事件的層級傳遞。我們都知道如果給一個控件注冊了touch事件，每次點擊它的時候都會觸發一系列的ACTION_DOWN，ACTION_MOVE，ACTION_UP等事件。這里需要注意，如果你在執行ACTION_DOWN的時候返回了false，后面一系列其它的action就不會再得到執行了。簡單的說，就是當dispatchTouchEvent在進行事件分發的時候，只有前一個action返回true，才會觸發后一個action。

說到這里，很多的朋友肯定要有巨大的疑問了。這不是在自相矛盾嗎？前面的例子中，明明在onTouch事件里面返回了false，ACTION_DOWN和ACTION_UP不是都得到執行了嗎？其實你只是被假象所迷惑了，讓我們仔細分析一下，在前面的例子當中，我們到底返回的是什么。

參考着我們前面分析的源碼，首先在onTouch事件里返回了false，就一定會進入到onTouchEvent方法中，然后我們來看一下onTouchEvent方法的細節。由於我們點擊了按鈕，就會進入到第23行這個if判斷的內部，然后你會發現，不管當前的action是什么，最終都一定會走到第133行，返回一個true。

是不是有一種被欺騙的感覺？明明在onTouch事件里返回了false，系統還是在onTouchEvent方法中幫你返回了true。就因為這個原因，才使得前面的例子中ACTION_UP可以得到執行。

 

那我們可以換一個控件，將按鈕替換成ImageView，然后給它也注冊一個touch事件，並返回false。如下所示：

imageView.setOnTouchListener(new OnTouchListener() {  
    @Override  
    public boolean onTouch(View v, MotionEvent event) {  
        Log.d("TAG", "onTouch execute, action " + event.getAction());  
        return false;  
    }  
}); 

運行一下程序，點擊ImageView，你會發現結果如下：

 

 

在ACTION_DOWN執行完后，后面的一系列action都不會得到執行了。這又是為什么呢？因為ImageView和按鈕不同，它是默認不可點擊的，因此在onTouchEvent的第14行判斷時無法進入到if的內部，直接跳到第91行返回了false，也就導致后面其它的action都無法執行了。

好了，關於View的事件分發，我想講的東西全都在這里了。現在我們再來回顧一下開篇時提到的那三個問題，相信每個人都會有更深一層的理解。

1. onTouch和onTouchEvent有什么區別，又該如何使用？

從源碼中可以看出，這兩個方法都是在View的dispatchTouchEvent中調用的，onTouch優先於onTouchEvent執行。如果在onTouch方法中通過返回true將事件消費掉，onTouchEvent將不會再執行。

另外需要注意的是，onTouch能夠得到執行需要兩個前提條件，第一mOnTouchListener的值不能為空，第二當前點擊的控件必須是enable的。因此如果你有一個控件是非enable的，那么給它注冊onTouch事件將永遠得不到執行。對於這一類控件，如果我們想要監聽它的touch事件，就必須通過在該控件中重寫onTouchEvent方法來實現。

2. 為什么給ListView引入了一個滑動菜單的功能，ListView就不能滾動了？

如果你閱讀了Android滑動框架完全解析，教你如何一分鍾實現滑動菜單特效 這篇文章，你應該會知道滑動菜單的功能是通過給ListView注冊了一個touch事件來實現的。如果你在onTouch方法里處理完了滑動邏輯后返回true，那么ListView本身的滾動事件就被屏蔽了，自然也就無法滑動(原理同前面例子中按鈕不能點擊)，因此解決辦法就是在onTouch方法里返回false。

3. 為什么圖片輪播器里的圖片使用Button而不用ImageView？

提這個問題的朋友是看過了Android實現圖片滾動控件，含頁簽功能，讓你的應用像淘寶一樣炫起來 這篇文章。當時我在圖片輪播器里使用Button，主要就是因為Button是可點擊的，而ImageView是不可點擊的。如果想要使用ImageView，可以有兩種改法。第一，在ImageView的onTouch方法里返回true，這樣可以保證ACTION_DOWN之后的其它action都能得到執行，才能實現圖片滾動的效果。第二，在布局文件里面給ImageView增加一個android:clickable="true"的屬性，這樣ImageView變成可點擊的之后，即使在onTouch里返回了false，ACTION_DOWN之后的其它action也是可以得到執行的。

今天的講解就到這里了，相信大家現在對Android事件分發機制又有了進一步的認識，在后面的文章中我會再帶大家一起探究Android中ViewGroup的事件分發機制，感興趣的朋友請繼續閱讀 Android事件分發機制完全解析，帶你從源碼的角度徹底理解(下) 。