Android 事件分发

一,前言

事件分发的文章也看过很多,自己也写过笔记文章,但都没有从总体上真正理解过,最终也是一知半解。这次就从总体流程上归纳下,更方便记忆。

二,必须知道的方法

2.1 ViewGroup

//分发事件
public boolean dispatchTouchEvent(MotionEvent ev) 
//事件拦截,可以拦截本该子View处理的事件
public boolean onInterceptTouchEvent(MotionEvent ev) 
//将事件分发至子View或交给自己处理
private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
            View child, int desiredPointerIdBits)
  1. 与View中的dispatchTouchEvent不同,ViewGroup中的dispatchTouchEvent还要兼顾对子View的事件分发。而处理自身的事件是用super.dispatchTouchEvent(event),也就是View的,在dispatchTransformedTouchEvent中被调用。

  2. onInterceptTouchEvent是View中没有的方法,当子View处理了DOWN事件,获得了事件流的处理权,父ViewGroup可以用onInterceptTouchEvent返回true来拦截事件交予自己处理。

  3. dispatchTransformedTouchEvent中分情况调用用子View的dispatchTouchEvent来分发事件;或者调用super.dispatchTouchEvent(event)来自己处理事件。

2.2 View

与ViewGroup不同,View的主要实现事件的响应,不用管分发

//分发事件
public boolean dispatchTouchEvent(MotionEvent ev) 
//优先onTouchEvent的触摸响应,用户自定义添加监听
public interface OnTouchListener {
    boolean onTouch(View v, MotionEvent event);
}
//系统响应,长按和点击事件在里面被调用
public boolean onTouchEvent(MotionEvent event)
  1. 先调用mOnTouchListener.onTouch(this, event)来处理事件,如果onTouch没有处理,则再交给onTouchEvent处理。
  2. OnTouchListener是对事件分发的回调,在onTouchEvent前被调用。
  3. onTouchEvent主要用于响应长按事件和点击事件。

三,ViewGroup的dispatchTouchEvent

基于常用的几个方法来分析其功能的实现原理,也包括上面方法介绍时说的原理。==暂时只考虑单点触摸事件==。

  1. 父ViewGroup只要拦截了ACTION_DOWN,后续事件下层级的View无法抢夺了。
  2. 在子容器中调用getParent().requestDisallowInterceptTouchEvent(true)来抢夺上一层容器的事件处理权。前提ACTION_DOWN没有被拦截
  3. 在父容器中使onInterceptTouchEvent返回true来拦截本该交给它底下层级View的事件处理权。但父容器的requestDisallowInterceptTouchEvent(true)被调用,onInterceptTouchEvent无效。
  4. onInterceptTouchEvent只有在ACTION_DOWN事件或者事件被自己下面层级的View处理时才会被调用,也就是说ACTION_DOWN被自己处理了,这个ViewGroup的onInterceptTouchEvent在同一个事件序列中不会被调用。
  5. 一旦有View对down事件的触摸响应,也就是使其dispatchTouchEvent返回true,一般事件后续的move,up等都交予它处理了,除非抢夺处理权。
  6. 一旦子View抢夺权限成功,后续的一序列事件都交予子View处理了;父View抢夺成功,本改处理事件的View会收到ACTION_CANCE事件,被拦截的这次事件父View不会处理,但后续事件都会交给父View处理了,且因为事件被父View处理,它的onInterceptTouchEvent不会再被调用。

暂时根据ViewGroup的dispatchTouchEvent只想到这些了。其功能主要处理事件分发,所以相关点都是这些方法在事件分发中的作用。

又要贴代码了.....只贴重点代码,上面说的点都在代码中可以看出。

3.1

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    ......
    // 检查是否自身是否拦截事件
    final boolean intercepted;
    //只有ACTION_DOWN或事件交由底下View处理了才走进去
    if (actionMasked == MotionEvent.ACTION_DOWN
            || mFirstTouchTarget != null) {
        //FLAG_DISALLOW_INTERCEPT就是通过requestDisallowInterceptTouchEvent方法来设置的
        final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
        //如果requestDisallowInterceptTouchEvent(true),就走else了
        if (!disallowIntercept) {
            //调用onInterceptTouchEvent询问是否拦截
            intercepted = onInterceptTouchEvent(ev);
            ev.setAction(action); // restore action in case it was changed
        } else {
            intercepted = false;
        }
    } else {
        // 没有下层级的View处理事件,且不是Down事件,就直接拦截,不询问了。
        // 也就是说down被本ViewGroup拦截处理,后续不会询问而直接给本ViewGroup处理.
        intercepted = true;
    }
    ......
}

上面代码默认为intercepted = true就是拦截了事件。解释了第2,3,4点,注释说得很清楚了。

当然代码不能割裂来看,下面解释为什么intercepted = true就是拦截了事件和剩下几点。

3.2

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    ......
    //如果事件没有取消,且没有被拦截
    if (!canceled && !intercepted) {
        //下面跳过多点触控的代码了
        ......
        //ACTION_DOWN事件才会进入
        if (actionMasked == MotionEvent.ACTION_DOWN
                        || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
                        || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
            for (int i = childrenCount - 1; i >= 0; i--) {
                ......
                //判断子View是否在点击范围内
                if (!canViewReceivePointerEvents(child)
                        || !isTransformedTouchPointInView(x, y, child, null)) {
                    ev.setTargetAccessibilityFocus(false);
                    continue;
                }
                ......
                //dispatchTransformedTouchEvent分发给子View,如果有子View处理了,就进入if
                if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
                    ...... 
                    //addTouchTarget中会存储处理事件的子View,赋予mFirstTouchTarget
                    newTouchTarget = addTouchTarget(child, idBitsToAssign);
                    alreadyDispatchedToNewTouchTarget = true;
                    break;
                }
            }
        }
    }
}

上面这段主要实现Down事件如何分发给子View。

3.3

    // Dispatch to touch targets.
    if (mFirstTouchTarget == null) {
        // 1.没有子View处理事件,就交给自己处理
        handled = dispatchTransformedTouchEvent(ev, canceled, null,
                TouchTarget.ALL_POINTER_IDS);
    } else {
        // 2.如果前提事件已经有View处理了,走下面步骤
        TouchTarget predecessor = null;
        TouchTarget target = mFirstTouchTarget;
        //多点触摸多条事件时,循环分发
        while (target != null) {
            final TouchTarget next = target.next;
            //3.Down事件被子View处理了,这部就直接结束了这次分发
            if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
                handled = true;
            } else {
                final boolean cancelChild = resetCancelNextUpFlag(target.child)
                        || intercepted;
                //4.intercepted就决定了是否cancle事件,后续事件再交予自己处理,子View会收到ACTION_CANCEL。
                //否则正常分发
                if (dispatchTransformedTouchEvent(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;
        }
    }
    
    ......
    
    return handled;

上面解释了剩下几点。

  1. 注释第一点,mFirstTouchTarget为空,就说明Down事件中下层View没有处理这个事件,在这里交给自己处理。
  2. 注释第二点,mFirstTouchTarget不为空,则走这里,进行View的分发,因为mFirstTouchTarget保存了处理事件的子View,直接交予对应子View处理。
  3. 注释第三点,如果是Down事件,且找到处理事件的子View,handled = true;结束这个事件分发。
  4. 注释第四点,这个ViewGroup决定拦截本该交予子View处理的事件,这里cancelChild为true,在dispatchTransformedTouchEvent交予子View的是cancel事件而不是原本事件。mFirstTouchTarget中移除相应的TouchTarget,这样后续事件的mFirstTouchTarget就为空了,交予这个ViewGroup处理。

四,ViewGroup的dispatchTransformedTouchEvent

从上面的分析可以知道,这个方法在dispatchTouchEvent有三次调用,也可以说有三种作用。

  1. 在3.2中,在找到被触摸的子View后,交予其分发给子View处理,调用child.dispatchTouchEvent(transformedEvent)分发事件。
  2. 在3.3的注释第一点中,传递的child为空,会调用super.dispatchTouchEvent(transformedEvent)交予ViewGroup自身处理。
  3. 在3.3的第四点中,如果cancel参数为false,就和第一点一样的情况;如果cancel为true,会event.setAction(MotionEvent.ACTION_CANCEL),将事件统一变为cancel事件,再交予子View。
private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
            View child, int desiredPointerIdBits) {
    final int oldAction = event.getAction();
    //如果ViewGroup拦截这个事件,或cancel事件
    if (cancel || oldAction == MotionEvent.ACTION_CANCEL) {
        //设置传递的事件类型为cancel事件
        event.setAction(MotionEvent.ACTION_CANCEL);
        if (child == null) {
            //给自己的cancel事件
            handled = super.dispatchTouchEvent(event);
        } else {
            //给子View的cancel事件
            handled = child.dispatchTouchEvent(event);
        }
        event.setAction(oldAction);
        return handled;
    }
    
    //非传递cancel事件,正常分发
    if (child == null) {
        //叫给ViewGroup自己处理事件
        handled = super.dispatchTouchEvent(transformedEvent);
    } else {
        final float offsetX = mScrollX - child.mLeft;
        final float offsetY = mScrollY - child.mTop;
        transformedEvent.offsetLocation(offsetX, offsetY);
        if (! child.hasIdentityMatrix()) {
            transformedEvent.transform(child.getInverseMatrix());
        }

        //交给子View处理事件
        handled = child.dispatchTouchEvent(transformedEvent);
    }
    
    return handled;
}

五,View的dispatchTouchEvent

与ViewGroup作用为分发事件不同,View里它的作用为处理事件。

public boolean dispatchTouchEvent(MotionEvent event) {
    ......
    if (onFilterTouchEventForSecurity(event)) {
        ......
        //noinspection SimplifiableIfStatement
        ListenerInfo li = mListenerInfo;
        //调用onTouch
        if (li != null && li.mOnTouchListener != null
                && (mViewFlags & ENABLED_MASK) == ENABLED
                && li.mOnTouchListener.onTouch(this, event)) {
            result = true;
        }
        //如果onTouch返回true,则不会再调用onTouchEvent
        if (!result && onTouchEvent(event)) {
            result = true;
        }
    }
}

onTouch先于onTouchEvent调用,且onTouch处理事件,就不会交予onTouchEvent处理了,也就是点击事件和长按事件不会响应了。

六,View的onTouchEvent

  1. onTouchEvent中,主要调用了OnClick 和 OnLongClick。先调用
    OnLongClick再调用OnClick,如果OnLongClick返回true消耗了事件,onClick不会被调用。
  2. 只要View可点击的,就算没有注册点击事件和长按事件,也会消费这个事件。
public boolean onTouchEvent(MotionEvent event) {
    
    //DISABLED状态
    if ((viewFlags & ENABLED_MASK) == DISABLED) {
        if (action == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
            setPressed(false);
        }
        // 如果是DISABLED状态,但同时还是CLICKABLE可点击,虽然不会响应点击监听,但还是会消耗事件
        return (((viewFlags & CLICKABLE) == CLICKABLE
                || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
                || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE);
    }
    
    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) {
                    //mHasPerformedLongPress表示长按是否消费了事件 
                    //mIgnoreNextUpEvent是鼠标移动事件相关参数,可以不管
                     if (!mHasPerformedLongPress && !mIgnoreNextUpEvent) {
                        // 移除长按
                        removeLongPressCallback();

                        // 要有焦点,也就是在点击状态下,才响应点击事件
                        if (!focusTaken) {
                            // 使用Handler来实现回调,使视觉效果优先于点击响应。
                            if (mPerformClick == null) {
                                //创建的Runnable对象中,调用了performClick()来响应点击事件
                                mPerformClick = new PerformClick();
                            }
                            //发送消息执行点击监听
                            if (!post(mPerformClick)) {
                                performClick();
                            }
                        }
                    }
                    
                }
                
                break;
            case MotionEvent.ACTION_DOWN:
                // 所在容器是否可以滚动
                boolean isInScrollingContainer = isInScrollingContainer();

                //如果可以滚动,延迟ViewConfiguration.getTapTimeout()来进行长按判断,防止为滚动触摸事件。
                //但长按时间判断会减去ViewConfiguration.getTapTimeout(),所以最终长按监听被调用的时间不变
                if (isInScrollingContainer) {
                    mPrivateFlags |= PFLAG_PREPRESSED;
                    if (mPendingCheckForTap == null) {
                        //CheckForTap里会调用checkForLongClick方法进行长按判断
                        mPendingCheckForTap = new CheckForTap();
                    }
                    mPendingCheckForTap.x = event.getX();
                    mPendingCheckForTap.y = event.getY();
                    postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
                } else {
                    setPressed(true, x, y);
                    // 不是滚动,进行长按判断,使用Handler进行长按时间判断
                    checkForLongClick(0, x, y);
                }
                break;
            case MotionEvent.ACTION_CANCEL:
                setPressed(false);
                //移除长按消息
                removeTapCallback();
                removeLongPressCallback();
                mInContextButtonPress = false;
                mHasPerformedLongPress = false;
                mIgnoreNextUpEvent = false;
                break;
            case MotionEvent.ACTION_MOVE:
                //按钮之外的移动要容忍。
                if (!pointInView(x, y, mTouchSlop)) {
                    // 从Handler消息队列中移除Down里面添加的mPendingCheckForTap,也就是移除滚动容器里的长按判断
                    removeTapCallback();
                    if ((mPrivateFlags & PFLAG_PRESSED) != 0) {
                        // 从Handler消息队列中移除长按判断Runnable,
                        removeLongPressCallback();

                        setPressed(false);
                    }
                }
                break;
        }
        
        //只要设置了可点击或可长按状态,都会消耗事件,不管有没有设置监听
        return true;
    }
}
  1. 可以看出,长按监听调用是通过延迟消息实现的;如果进行了滑动,且是按压状态(满足down事件中长按消息发送),移除长按消息。所以在down事件后发送长按延迟消息,如果没有在move,cancel,up中移除消息,延迟时间过后就会执行长按回调了。
  2. ACTION_UP中的PFLAG_PREPRESSED参数,是在ACTION_DOWN的CheckForTap中被延迟赋值给mPrivateFlags的,在ACTION_CANCEL和ACTION_MOVE中会移除这个值。所以没有move而执行到ACTION_UP时,因为赋值了PFLAG_PREPRESSED一定会进入。
  3. ACTION_UP中的(mPrivateFlags & PFLAG_PRESSED) != 0判断,非处于滚动容器,会在ACTION_DOWN的setPressed(true, x, y)设置PFLAG_PRESSED值,在move中setPressed(false)移除。
  4. 上面2,3两点决定ACTION_DOWN的if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed)两个条件是否满足。满足的要求都是只有按下,而没有执行滑动就到抬起。
  5. 长按和点击回调都是通过发送消息来调用,在Runnable里调用对应的方法。长按为checkForLongClick(int delayOffset, float x, float y);点击为performClick()。方法里面调用了回调监听。

在ACTION_MOVE中,我们一般通过判断滑动距离有没有超过mTouchSlop来判断是否属于滑动事件。

参考

Android事件传递之子View和父View的那点事

安卓自定义View进阶-事件分发机制详解

你可能感兴趣的:(Android 事件分发)