Android touch事件

touch event

首先，接收touch事件的是ViewGroup，然后才是其child，某个具体的view

首先触发的是ViewGroup的onInterceptTouchEvent方法

onInterceptTouchEvent (MotionEvent ev)

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

    public boolean onInterceptTouchEvent(MotionEvent ev) {

        return false;

    }

 

　　这个方法注释很长：

    /**

     * Implement this method to intercept all touch screen motion events.  This

     * allows you to watch events as they are dispatched to your children, and

     * take ownership of the current gesture at any point.

     *

     * <p>Using this function takes some care, as it has a fairly complicated

     * interaction with {@link View#onTouchEvent(MotionEvent)

     * View.onTouchEvent(MotionEvent)}, and using it requires implementing

     * that method as well as this one in the correct way.  Events will be

     * received in the following order:

     *

     * <ol>

     * <li> You will receive the down event here.

     * <li> The down event will be handled either by a child of this view

     * group, or given to your own onTouchEvent() method to handle; this means

     * you should implement onTouchEvent() to return true, so you will

     * continue to see the rest of the gesture (instead of looking for

     * a parent view to handle it).  Also, by returning true from

     * onTouchEvent(), you will not receive any following

     * events in onInterceptTouchEvent() and all touch processing must

     * happen in onTouchEvent() like normal.

     * <li> For as long as you return false from this function, each following

     * event (up to and including the final up) will be delivered first here

     * and then to the target's onTouchEvent().

     * <li> If you return true from here, you will not receive any

     * following events: the target view will receive the same event but

     * with the action {@link MotionEvent#ACTION_CANCEL}, and all further

     * events will be delivered to your onTouchEvent() method and no longer

     * appear here.

     * </ol>

     *

     * @param ev The motion event being dispatched down the hierarchy.

     * @return Return true to steal motion events from the children and have

     * them dispatched to this ViewGroup through onTouchEvent().

     * The current target will receive an ACTION_CANCEL event, and no further

     * messages will be delivered here.

     */

 

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

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

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

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

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

　　ViewGroup自己处理意味着你应该在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()中出现。

看一下ViewGroup的dispatchTouchEvent方法的源码，这个是4.0.3的源码

@Override    public boolean <strong>dispatchTouchEvent</strong>(MotionEvent ev) {        if (mInputEventConsistencyVerifier != null) {            mInputEventConsistencyVerifier.onTouchEvent(ev, 1);        }        boolean handled = false;        if (onFilterTouchEventForSecurity(ev)) {            final int action = ev.getAction();            final int actionMasked = action & MotionEvent.ACTION_MASK;            // Handle an initial down.            if (actionMasked == MotionEvent.ACTION_DOWN) {                // Throw away all previous state when starting a new touch gesture.                // The framework may have dropped the up or cancel event for the previous gesture                // due to an app switch, ANR, or some other state change.                cancelAndClearTouchTargets(ev);                resetTouchState();            }            // Check for interception.            final boolean intercepted;            if (actionMasked == MotionEvent.ACTION_DOWN                    || mFirstTouchTarget != null) {                final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;                <strong>if (!disallowIntercept) </strong>{                    intercepted = <strong><span style="color:#ff0000;">onInterceptTouchEvent</span></strong>(ev);                    ev.setAction(action); // restore action in case it was changed                } else {                    intercepted = false;                }            } else {                // There are no touch targets and this action is not an initial down                // so this view group continues to intercept touches.                intercepted = true;            }            // Check for cancelation.            final boolean canceled = resetCancelNextUpFlag(this)                    || actionMasked == MotionEvent.ACTION_CANCEL;            // Update list of touch targets for pointer down, if needed.            final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0;            TouchTarget newTouchTarget = null;            boolean alreadyDispatchedToNewTouchTarget = false;            <span style="color:#ff0000;">if (!canceled && !intercepted)</span> {//<span style="color:#cc9933;background-color: rgb(255, 255, 255);">如果没有拦截，且没有取消，交给子View</span>                if (actionMasked == MotionEvent.ACTION_DOWN                        || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)                        || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {                    final int actionIndex = ev.getActionIndex(); // always 0 for down                    final int idBitsToAssign = split ? 1 << ev.getPointerId(actionIndex)                            : TouchTarget.ALL_POINTER_IDS;                    // Clean up earlier touch targets for this pointer id in case they                    // have become out of sync.                    removePointersFromTouchTargets(idBitsToAssign);                    final int childrenCount = mChildrenCount;                    if (childrenCount != 0) {                        // Find a child that can receive the event.                        // Scan children from front to back.                        final View[] children = mChildren;                        final float x = ev.getX(actionIndex);                        final float y = ev.getY(actionIndex);                        for (int i = childrenCount - 1; i >= 0; i--) {<span style="color:#ff6600;">//遍历所有的子view，找出当前点击的子view</span>                            final View child = children[i];                            if (!canViewReceivePointerEvents(child)                                    || !<strong>isTransformedTouchPointInView</strong>(x, y, child, null)) {<span style="color:#3366ff;">//该方法计算点击点所在的子view</span>                                continue;                            }                           <span style="color:#ff0000;"> newTouchTarget = getTouchTarget(child);</span>                            if (newTouchTarget != null) {                                // Child is already receiving touch within its bounds.                                // Give it the new pointer in addition to the ones it is handling.                                newTouchTarget.pointerIdBits |= idBitsToAssign;                                break;                            }                            resetCancelNextUpFlag(child);                            if (<strong>dispatchTransformedTouchEvent</strong>(ev, false, child, idBitsToAssign)) {

<span style="white-space:pre"></span>//如果child不为空，child处理，否则super.dispatch                                // Child wants to receive touch within its bounds.                                mLastTouchDownTime = ev.getDownTime();                                mLastTouchDownIndex = i;                                mLastTouchDownX = ev.getX();                                mLastTouchDownY = ev.getY();                                newTouchTarget = addTouchTarget(child, idBitsToAssign);                                alreadyDispatchedToNewTouchTarget = true;                                break;                            }                        }                    }                    if (newTouchTarget == null && mFirstTouchTarget != null) {                        // Did not find a child to receive the event.                        // Assign the pointer to the least recently added target.                        newTouchTarget = mFirstTouchTarget;                        while (newTouchTarget.next != null) {                            newTouchTarget = newTouchTarget.next;                        }                        newTouchTarget.pointerIdBits |= idBitsToAssign;                    }                }            }            // Dispatch to touch targets.            if (mFirstTouchTarget == null) {                // No touch targets so treat this as an ordinary view.                handled = <strong>dispatchTransformedTouchEvent</strong>(ev, canceled, null,                        TouchTarget.ALL_POINTER_IDS);            } else {                // Dispatch to touch targets, excluding the new touch target if we already                // dispatched to it.  Cancel touch targets if necessary.                TouchTarget predecessor = null;                TouchTarget target = mFirstTouchTarget;                while (target != null) {                    final TouchTarget next = target.next;                    if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {                        handled = true;                    } else {                        final boolean cancelChild = resetCancelNextUpFlag(target.child)                        || intercepted;                        if (<strong>dispatchTransformedTouchEvent</strong>(ev, cancelChild,                                target.child, target.pointerIdBits)) {                            handled = true;                        }                        if (cancelChild) {                            if (predecessor == null) {                                mFirstTouchTarget = next;                            } else {                                predecessor.next = next;                            }                            target.recycle();                            target = next;                            continue;                        }                    }                    predecessor = target;                    target = next;                }            }            // Update list of touch targets for pointer up or cancel, if needed.            if (canceled                    || actionMasked == MotionEvent.ACTION_UP                    || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {                resetTouchState();            } else if (split && actionMasked == MotionEvent.ACTION_POINTER_UP) {                final int actionIndex = ev.getActionIndex();                final int idBitsToRemove = 1 << ev.getPointerId(actionIndex);                removePointersFromTouchTargets(idBitsToRemove);            }        }        if (!handled && mInputEventConsistencyVerifier != null) {            mInputEventConsistencyVerifier.onUnhandledEvent(ev, 1);        }        return handled;    }

这段代码略复杂，主要就是看由child，还是parent处理touch事件。

如果你在执行ACTION_DOWN的时候返回了false，后面一系列其它的action就不会再得到执行了。简单的说，就是当dispatchTouchEvent在进行事件分发的时候，只有前一个action返回true，才会触发后一个action。

因为ImageView和按钮不同，它是默认不可点击的

a. onTouch和onTouchEvent有什么区别，又该如何使用？

从源码中可以看出，这两个方法都是在View的dispatchTouchEvent中调用的，onTouch优先于onTouchEvent执行。如果在onTouch方法中通过返回true将事件消费掉，onTouchEvent将不会再执行。

另外需要注意的是，onTouch能够得到执行需要两个前提条件，第一mOnTouchListener的值不能为空，第二当前点击的控件必须是enable的。因此如果你有一个控件是非enable的，那么给它注册onTouch事件将永远得不到执行。对于这一类控件，如果我们想要监听它的touch事件，就必须通过在该控件中重写onTouchEvent方法来实现。

1 Android中touch事件的传递，绝对是先传递到ViewGroup，再传递到View的。

2 在ViewGroup中可以通过onInterceptTouchEvent方法对事件传递进行拦截，onInterceptTouchEvent方法返回true代表不允许事件继续向子View传递，返回false代表不对事件进行拦截，默认返回false。

3. 子View中如果将传递的事件消费掉，ViewGroup中将无法接收到任何事件。

———————————————

@Override

//处理点击事件，如果是手势的事件则不作点击事件 普通View   

//注：必须是        setClickable(true);    setLongClickable(true);
    public boolean performClick() {
        if(isGesture){
            return true;
        }else{
            return super.performClick();
        }
    }

———————

参考view的源码

if (mPerformClick == null) {
                                    mPerformClick = new PerformClick();
                                }
                                if (!post(mPerformClick)) {
                                    performClick();
                                }

performClick()方法，那我们进入到这个方法里瞧一瞧：

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

可以看到，只要mOnClickListener不是null，就会去调用它的onClick方法，那mOnClickListener又是在哪里赋值的呢？经过寻找后找到如下方法：

1. public void setOnClickListener(OnClickListener l) {  
2.     if (!isClickable()) {  
3.         setClickable(true);  
4.     }  
5.     mOnClickListener = l;  
6. }  

每当控件被点击时，都会在performClick()方法里回调被点击控件的onClick方法。

———————————

touch与click的关系

1. button.setOnClickListener(new OnClickListener() {  
2.     @Override  
3.     public void onClick(View v) {  
4.         Log.d("TAG", "onClick execute");  
5.     }  
6. });  

1. button.setOnTouchListener(new OnTouchListener() {  
2.     @Override  
3.     public boolean onTouch(View v, MotionEvent event) {  
4.         Log.d("TAG", "onTouch execute, action " + event.getAction());  
5.         return false;  
6.     }  
7. });  

onTouch是优先于onClick执行的

onTouch方法是有返回值的，这里我们返回的是false，如果我们尝试把onTouch方法里的返回值改成true，那么click事件不会发生。只要你触摸到了任何一个控件，就一定会调用该控件的dispatchTouchEvent方法。那当我们去点击按钮的时候，就会去调用Button类里的dispatchTouchEvent方法，可是你会发现Button类里并没有这个方法，那么就到它的父类TextView里去找一找，你会发现TextView里也没有这个方法，那没办法了，只好继续在TextView的父类View里找一找，这个时候你终于在View里找到了这个方法，

1. public boolean dispatchTouchEvent(MotionEvent event) {  
2.     if (mOnTouchListener != null && (mViewFlags & ENABLED_MASK) == ENABLED &&  
3.             mOnTouchListener.onTouch(this, event)) {  
4.         return true;  
5.     }  
6.     return onTouchEvent(event);  
7. }  

mOnTouchListener这个变量是在哪里赋值的呢？我们寻找之后在View里发现了如下方法：

1. public void setOnTouchListener(OnTouchListener l) {  
2.     mOnTouchListener = l;  
3. }  

找到了，mOnTouchListener正是在setOnTouchListener方法里赋值的，也就是说只要我们给控件注册了touch事件，mOnTouchListener就一定被赋值了。第三个条件就比较关键了，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)方法中的

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

如果一个控件是可点击的，那么点击该控件时，dispatchTouchEvent的返回值必定是true。

  ViewGroup的父类是View。

  一般是parent的onInterceptTouchEvent返回false，这样子控件才能接收到touch事件，否则，touch被parent的dispatchTouchEvent方法捕获并处理。

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