Android中的Touch事件

gearss 2016-05-31

展开全文

http://www.cnblogs.com/mengdd/p/3394345.html

Android中的Touch事件处理

主要内容

　　Activity或View类的onTouchEvent()回调函数会接收到touch事件。

　　一个完整的手势是从ACTION_DOWN开始，到ACTION_UP结束。

　　简单的情况下，我们只需要在onTouchEvent()中写个switch case语句，处理各种事件（Touch Down、 Touch Move、 Touch Up等），但是比较复杂的动作就需要更多的处理了。

　　ViewGroup作为一个parent是可以截获传向它的child的touch事件的。

　　如果一个ViewGroup的onInterceptTouchEvent()方法返回true，说明Touch事件被截获，子View不再接收到Touch事件，而是转向本ViewGroup的 onTouchEvent()方法处理。从Down开始，之后的Move，Up都会直接在onTouchEvent()方法中处理。

　　先前还在处理touch event的child view将会接收到一个 ACTION_CANCEL。

　　如果onInterceptTouchEvent()返回false，则事件会交给child view处理。

　　Android中提供了ViewGroup、View、Activity三个层次的Touch事件处理。

　　处理过程是按照Touch事件从上到下传递，再按照是否消费的返回值，从下到上返回，即如果View的onTouchEvent返回false，将会向上传给它的parent的ViewGroup，如果ViewGroup不处理，将会一直向上返回到Activity。

　　即隧道式向下分发，然后冒泡式向上处理。

Activity的Touch事件分发

　　Activity的dispatchTouchEvent (MotionEvent ev)：

    /**
     * Called to process touch screen events.  You can override this to
     * intercept all touch screen events before they are dispatched to the
     * window.  Be sure to call this implementation for touch screen events
     * that should be handled normally.
     *
     * @param ev The touch screen event.
     *
     * @return boolean Return true if this event was consumed.
     */
    public boolean dispatchTouchEvent(MotionEvent ev) {
        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
            onUserInteraction();
        }
        if (getWindow().superDispatchTouchEvent(ev)) {
            return true;
        }
        return onTouchEvent(ev);
    }

　　处理屏幕触摸事件，你可以覆写这个方法来截获所有的触摸屏幕事件，是在它们分发到窗口之前截获。

　　对于要正常处理的触摸屏幕事件，要确认调用这个实现。

　　返回值为true的时候，表明这个事件被消费。

　　Activity的onTouchEvent (MotionEvent event)：

    /**
     * Called when a touch screen event was not handled by any of the views
     * under it.  This is most useful to process touch events that happen
     * outside of your window bounds, where there is no view to receive it.
     *
     * @param event The touch screen event being processed.
     *
     * @return Return true if you have consumed the event, false if you haven't.
     * The default implementation always returns false.
     */
    public boolean onTouchEvent(MotionEvent event) {
        if (mWindow.shouldCloseOnTouch(this, event)) {
            finish();
            return true;
        }

        return false;
    }

　　如果一个屏幕触摸事件没有被这个Activity下的任何View所处理，Activity的onTouchEvent将会调用。

　　这对于处理window边界之外的Touch事件非常有用，因为通常是没有View会接收到它们的。

　　返回值为true表明你已经消费了这个事件，false则表示没有消费，默认实现中返回false。

View的Touch事件

　　View的dispatchTouchEvent (MotionEvent event)：

View --> dispatchTouchEvent

　　将touch屏幕的事件向下传递到目标View，或者传递到本View，如果它就是目标View。

　　如果事件被这个View处理，则返回true，否则返回false。

　　onTouchEvent (MotionEvent event)：

View --> onTouchEvent

　　实现这个方法来处理touch屏幕的事件。

　　返回true如果这个事件被处理了。

ViewGroup的Touch事件

　　因为ViewGroup是View的子类，所以它覆写方法时会加上Override注解，如果没有覆写，则沿用父类实现，如onTouchEvent()。

　　dispatchTouchEvent (MotionEvent ev)：　

ViewGroup --> dispatchTouchEvent

　　将Touch事件向下传递到目标View，因为自身也是View，所以目标View如果是自己，则传递给自己。

　　返回true，如果这个事件是被本View所处理。

　　onInterceptTouchEvent (MotionEvent ev)

　　ViewGroup中比较特殊的一个方法。默认实现如下：

    public boolean onInterceptTouchEvent(MotionEvent ev) {
        return false;
    }

　　这个方法注释很长：

ViewGroup onInterceptTouchEvent

　　实现这个方法可以截获所有的Touch事件。这样你就可以控制向child分发的Touch事件。

　　一般实现这个方法，需要同时实现View.onTouchEvent(MotionEvent)方法。

　　事件是按照如下的顺序被接收的：

　　1.首先在onInterceptTouchEvent()中接收到Down事件。

　　2.Down事件将会：要么给这个ViewGroup的一个child view处理，要么是这个ViewGroup自己的onTouchEvent()处理。

　　处理意味着你应该在onTouchEvent()的实现中返回true，这样你就可以继续看到这个gesture的其他部分，如果返回false，将会返回寻找一个parent view去处理它。

　　如果在onTouchEvent()中返回true，你将不会再在onInterceptTouchEvent()再收到接下来的事件，所有的Touch处理必须放在onTouchEvent()中正常处理。

　　3.如果你在onInterceptTouchEvent()中返回false，接下来的每一个事件都会先传到onInterceptTouchEvent()，之后传递到目标view的onTouchEvent()中。

　　4.如果你在onInterceptTouchEvent()中返回true，将不会再接收到手势中的其他事件，当前的目标view将会接收到同一个事件，但是动作是 ACTION_CANCEL。其他所有的事件将会被直接传递到onTouchEvent()中，并且不再在onInterceptTouchEvent()中出现。

　　onInterceptTouchEvent()的返回值：true将会从子view中偷取运动事件，把它们分配到这个ViewGroup的onTouchEvent()中，当前目标view将会接收到取消动作，并且接下来的动作都不会再经过onInterceptTouchEvent()。

　　ViewGroup的onTouchEvent()是采用父类View的默认实现，有需要的话可以覆写。

代码示例

　　写了一个Demo观察输出和调用关系，代码如下：

package com.mengdd.hellotouch;

import android.util.Log;
import android.view.MotionEvent;

public class Utils {

    public static void showMotionEventType(MotionEvent event, String logTag,
            String methodName) {

        final int action = event.getActionMasked();
        switch (action) {
            case MotionEvent.ACTION_DOWN:
                Log.i(logTag, methodName + ": " + action + ": ACTION_DOWN");
                break;
            case MotionEvent.ACTION_MOVE:
                Log.i(logTag, methodName + ": " + action + ": ACTION_MOVE");
                break;
            case MotionEvent.ACTION_UP:
                Log.i(logTag, methodName + ": " + action + ": ACTION_UP");
                break;
            case MotionEvent.ACTION_CANCEL:
                Log.i(logTag, methodName + ": " + action + ": ACTION_CANCEL");
                break;

            default:
                break;
        }

    }

    public static void showReturnValue(boolean returnValue, String logTag,
            String methodName) {
        Log.w(logTag, methodName + " return: " + returnValue);
    }

    public static void showInfo(String info, String logTag, String methodName) {
        Log.e(logTag, methodName + " info: " + info);
    }
}

package com.mengdd.hellotouch;

import com.example.helloscroller.R;

import android.app.Activity;
import android.os.Bundle;
import android.view.MotionEvent;

public class HelloTouchActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_hello_scroller);
    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        Utils.showMotionEventType(ev, "Activity", "dispatchTouchEvent");
        boolean result = super.dispatchTouchEvent(ev);

        Utils.showReturnValue(result, "Activity", "dispatchTouchEvent");
        return result;
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {

        Utils.showMotionEventType(event, "Activity", "onTouchEvent");
        boolean result = super.onTouchEvent(event);
        Utils.showReturnValue(result, "Activity", "onTouchEvent");
        return result;
    }

}

package com.mengdd.hellotouch;

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

public class MyViewGroup extends LinearLayout {

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

    public MyViewGroup(Context context) {
        super(context);
        init();
    }

    private void init() {

        setOnClickListener(mOnClickListener);
        setOnLongClickListener(mOnLongClickListener);
    }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent event) {
        Utils.showMotionEventType(event, "ViewGroup", "onInterceptTouchEvent");
        boolean returnValue = super.onInterceptTouchEvent(event);

        // This method JUST determines whether we want to intercept the motion.
        // If we return true, onTouchEvent will be called

        Utils.showReturnValue(returnValue, "ViewGroup", "onInterceptTouchEvent");
        return returnValue;

    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent event) {
        Utils.showMotionEventType(event, "ViewGroup", "dispatchTouchEvent");
        boolean returnValue = super.dispatchTouchEvent(event);
        Utils.showReturnValue(returnValue, "ViewGroup", "dispatchTouchEvent");
        return returnValue;
    }

    // ViewGroup自己的Touch事件处理，如果在onInterceptTouchEvent返回true，则会到这里处理，不传入child
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        Utils.showMotionEventType(event, "ViewGroup", "onTouchEvent");

        boolean returnValue = super.onTouchEvent(event);
        Utils.showReturnValue(returnValue, "ViewGroup", "onTouchEvent");
        return returnValue;
    }

    private OnClickListener mOnClickListener = new OnClickListener() {

        @Override
        public void onClick(View v) {
            Utils.showInfo("onClick", "ViewGroup", "mOnClickListener");
            // onClick是ACTION_UP后调用的

        }
    };

    private OnLongClickListener mOnLongClickListener = new OnLongClickListener() {

        @Override
        public boolean onLongClick(View v) {
            // onLongClick按下到一定的时间就调用了
            Utils.showInfo("onLongClick", "ViewGroup", "mOnLongClickListener");
            // 如果返回false，则长按结束的ACTION_UP调用onClick
            // 如果返回true，onLongClick后不再调用onClick
            return true;
        }
    };

}

package com.mengdd.hellotouch;

import android.content.Context;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import android.widget.TextView;

public class MyView extends TextView {

    public MyView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init();
    }

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

    public MyView(Context context) {
        super(context);
    }

    private void init() {

        setOnClickListener(mOnClickListener);
        setOnLongClickListener(mOnLongClickListener);
    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent event) {
        Utils.showMotionEventType(event, "View", "dispatchTouchEvent");
        boolean returnValue = super.dispatchTouchEvent(event);
        Utils.showReturnValue(returnValue, "View", "dispatchTouchEvent");
        return returnValue;
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        Utils.showMotionEventType(event, "View", "onTouchEvent");
        boolean returnValue = super.onTouchEvent(event);
        Utils.showReturnValue(returnValue, "View", "onTouchEvent");

        return returnValue;
    }

    private OnClickListener mOnClickListener = new OnClickListener() {

        @Override
        public void onClick(View v) {
            Utils.showInfo("onClick", "View", "mOnClickListener");

        }
    };

    private OnLongClickListener mOnLongClickListener = new OnLongClickListener() {

        @Override
        public boolean onLongClick(View v) {
            Utils.showInfo("onLongClick", "View", "mOnLongClickListener");

            // 如果返回false，则长按结束的ACTION_UP调用onClick
            return false;
        }
    };

}

<RelativeLayout xmlns:android="http://schemas./apk/res/android"
    xmlns:tools="http://schemas./tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context=".HelloTouchActivity" >

    <com.mengdd.hellotouch.MyViewGroup
        android:layout_width="match_parent"
        android:layout_height="match_parent" 
        android:orientation="vertical">

        <com.mengdd.hellotouch.MyView
            android:layout_width="100dp"
            android:layout_height="100dp"
            android:layout_gravity="center"
            android:text="Hello"
            android:background="#FFBBFFBB" />
    </com.mengdd.hellotouch.MyViewGroup>

</RelativeLayout>