Android事件分发机制——Touch事件

对着背影说爱祢 提交于 2019-12-24 04:05:27

1. 简介

    先来看一个表:

Touch事件相关方法

功能

Activity

ViewGroup

View

public boolean dispatchTouchEvent(MotionEvent ev)

事件分发

Yes

Yes

Yes

public boolean onInterceptTouchEvent(MotionEvent ev)

事件拦截

No

Yes

No

public boolean onTouchEvent(MotionEvent ev)

事件响应

Yes

Yes

Yes

     从表中可以看出,Activity、ViewGroup、View都关心Touch事件,其中ViewGroup的关心的事件有三个:onInterceptTouchEvent、dispatchTouchEvent、onTouchEvent。Activity和View关心的事件只有两个:dispatchTouchEvent、onTouchEvent。也就是说只有ViewGroup可以对事件进行拦截。

    Android的UI结构是一个树形结构,树的最顶层(根节点)是Activity内包含的一个ViewGroup,下面有若干个ViewGroup节点,每个节点下面又有若干个ViewGroup节点或者View节点,以此类推。Touch事件的传递和处理与这种结构密切相关。一次完整的触摸事件由一个ACTION_DOWN、零个或一个或多个ACTION_MOVE、一个ACTION_UP组成。

在分析源码之前,先简单了解下这三个函数。

(1) 事件分发: public boolean dispatchTouchEvent(MotionEvent ev)

    当Touch事件发生时,Activity的dispatchTouchEvent()方法会以隧道方式(从根节点依次往下传递直到最内层子节点,或在中间某一节点中由于某一条件停止传递)将事件传递给最外层View的dispatchTouchEvent()方法,并由该View的dispatchTouchEvent()方法对事件进行分发。

dispatchTouchEvent 的事件分发逻辑如下:

  • return true :事件会分发给当前View并由dispatchTouchEvent()方法进行消费,同时事件会停止向下传递。
  • return false :将事件返还给当前View的上一级的onTouchEvent()进行消费。(这个上一级可能是Activity,也可能是父View)
  • return super.dispatchTouchEvent(ev) :事件会自动的分发给当前View的onInterceptTouchEvent方法。

    注意,View响应dispatchTouchEvent()和onInterceptTouchEvent()的前提是可以向该View中添加子View,也就是说该View有子节点才谈得上能分发和拦截。

(2) 事件拦截public boolean onInterceptTouchEvent(MotionEvent ev) 

    在外层View的dispatchTouchEvent()方法返回super.dispatchTouchEvent(ev)时,事件会自动的分发给当前View的onInterceptTouchEvent()方法。

onInterceptTouchEvent 的事件拦截逻辑如下:

  • return true :将对事件进行拦截,并将拦截到的事件交由当前View的onTouchEvent()进行处理。
  • return false :将对事件进行放行,当前View上的事件会被传递到子View 上,再由子View的dispatchTouchEvent()来继续对这个事件进行分发。
  • return super.onInterceptTouchEvent(ev) :事件默认会被拦截,并将拦截到的事件交由当前View的onTouchEvent()进行处理。

(3) 事件响应public boolean onTouchEvent(MotionEvent ev)

    由(1)和(2)可以知道onTouchEvent()被调用的条件。

onTouchEvent 的事件响应逻辑如下:

  • return false :事件将会从当前View向上传递,并且都是由上层View的onTouchEvent()来接收,如果传递到上层的onTouchEvent()也返回false,那么这                       个事件就会"消失",而且接收不到下一次事件。
  • return true :接收并消费掉该事件。
  • return super.onTouchEvent(ev) :默认处理事件的逻辑和return false相同。

下面看下源码。

1.1 Activity对Touch事件的处理

      当Touch事件发生生,最先被触发的是Activity的dispatchTouchEvent()函数,再由这个函数触发根节点的dispatchTouchEvent()。如果想让Activity不响应触摸事件,可以直接重写这个函数。

dispatchTouchEvent()@Activity.java

// 处理触摸屏事件。可以重写这个函数来拦截所有的触摸屏事件,不让它们分发到window。为了应该被正常处理的触摸屏幕事件,一定要确保调用这个实现。
public boolean dispatchTouchEvent(MotionEvent ev) {
    if (ev.getAction() == MotionEvent.ACTION_DOWN) {  // 从ACTION_DOWN事件开始本次触摸事件
        onUserInteraction();
    }
    if (getWindow().superDispatchTouchEvent(ev)) {  // 会调用window中的根ViewGroup进行事件分发
        return true;   // 如果子View消费了这个事件,返回true.
    }
    return onTouchEvent(ev);    // 没有View处理本次事件,调用Activity的onTouchEvent。
}

 onTouchEvent()@Activity.java

// 当一个触摸屏事件没有被它下面的任意view处理的时候,调用这个函数。这个处理对于触摸事件超出window范围的时候很有用,这个时候没有view接收到事件。
public boolean onTouchEvent(MotionEvent event) {
    if (mWindow.shouldCloseOnTouch(this, event)) {
        finish();
        return true;
    }
    return false;
}

1.2 View对Touch事件的处理

dispatchTouchEvent()@View.java

// 将屏幕触摸事件向下传递给目标view.
public boolean dispatchTouchEvent(MotionEvent event) {
    ......
    if (onFilterTouchEventForSecurity(event)) {
        // ListenerInfo类保存了设给这个view的各种listener,如OnClickListener,OnTouchListener等。
        ListenerInfo li = mListenerInfo;
        if (li != null && li.mOnTouchListener != null && (mViewFlags & ENABLED_MASK) == ENABLED
                       && li.mOnTouchListener.onTouch(this, event)) {
            // 当mOnTouchListener不为null,当前控件是enable的,且mOnTouchListener.onTouch返回true, 那么dispatchTouchEvent返回true.
            // 从这里可以看到onTouch执行要先于onTouchEvent及onClick
            return true;
        }
        // 上面的条件都不成立,才会执行onTouchEvent()
        if (onTouchEvent(event)) {       // 如果一个控件是可点击的,那么onTouchEvent必定返回true, 因此dispatchTouchEvent也返回true.
            return true;
        }
    }
    ......
    return false;
} 

    从View的dispatchTouchEvent()的实现知道,如果给一个view设置了OnTouchListener,那么onTouch函数就在dispatchTouchEvent()函数中被回调,只有onTouch()返回false时,才会继续执行onTouchEvent()。

onTouchEvent()@View.java

// 实现这个方法处理屏幕触摸手势事件
// 如果这个方法被用于检测点击动作,那么推荐通过调用performClick来实现。这样做可以确保系统行为一致,包括服从点击声音喜好,调度OnClickListener调用,当辅助 // 功能启用的时候处理ACTION_CLICK ACTION_CLICK。
public boolean onTouchEvent(MotionEvent event) {
    final int viewFlags = mViewFlags;
    if ((viewFlags & ENABLED_MASK) == DISABLED) {
        if (event.getAction() == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
            setPressed(false);    // 设置按下UI状态
        }
        // 一个可点击的但是disabled的view仍然消费touch事件,只是不作出回应。
        return (((viewFlags & CLICKABLE) == CLICKABLE || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE));
    }
    ......    
    if (((viewFlags & CLICKABLE) == CLICKABLE || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {
        switch (event.getAction()) {
            case MotionEvent.ACTION_UP:
                boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
                if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {
                    // 如果我们没有拥有它,我们应该获取焦点,而且应该在Touch模式下。
                    boolean focusTaken = false;
                    if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {
                        focusTaken = requestFocus();
                    }
    
                    if (prepressed) {
                        // 按钮在我们实际显示它按下之前被释放。现在使它显示按下状态(在调度click之前),以确保用户看到它。
                        setPressed(true);
                    }

                    if (!mHasPerformedLongPress) {
                        // 这是一个阀门,所以移除长按的检查
                        removeLongPressCallback();
                        // 只有在按下状态中时才执行click动作。
                        if (!focusTaken) {
                            // 使用Runnable和post执行performClick,而不是直接执行。这样可以让这个view的其它可见状态在click操作开始前更新。
                            if (mPerformClick == null) {
                                mPerformClick = new PerformClick();
                            }
                            if (!post(mPerformClick)) {
                                performClick();              // 注意,在MotionEvent.ACTION_UP时执行click。
                            }
                        }
                    }
                    if (mUnsetPressedState == null) {
                        mUnsetPressedState = new UnsetPressedState();
                    }
                    if (prepressed) {
                        postDelayed(mUnsetPressedState, ViewConfiguration.getPressedStateDuration());
                    } else if (!post(mUnsetPressedState)) {
                        mUnsetPressedState.run();
                    }
                    removeTapCallback();
                }
                break;
    
            case MotionEvent.ACTION_DOWN:
                mHasPerformedLongPress = false;
                if (performButtonActionOnTouchDown(event)) {
                    break;
                }
    
                // 沿层次结构走,以确定我们是否在一个滚动的容器内。
                boolean isInScrollingContainer = isInScrollingContainer();
                // 对于在一个滚动容器内的views,延迟一会按下的反馈,以防这是一个滚动。
                if (isInScrollingContainer) {
                    mPrivateFlags |= PFLAG_PREPRESSED;
                    if (mPendingCheckForTap == null) {
                        mPendingCheckForTap = new CheckForTap();
                    }
                    postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
                } else {
                    // 如果不是在一个正在滚动的容器内,那么马上显示反馈。
                    setPressed(true);
                    checkForLongClick(0);
                }
                break;
    
            case MotionEvent.ACTION_CANCEL:
                setPressed(false);
                removeTapCallback();
                removeLongPressCallback();
                break;

            case MotionEvent.ACTION_MOVE:
                final int x = (int) event.getX();
                final int y = (int) event.getY();
                // 按钮之外的移动要容忍。
                if (!pointInView(x, y, mTouchSlop)) {
                    // Outside button
                    removeTapCallback();
                    if ((mPrivateFlags & PFLAG_PRESSED) != 0) {
                        // 移除后面长按/阀门的检查
                        removeLongPressCallback();
                        setPressed(false);
                    }
                }
            break;
        }
        return true; // 如果一个控件是可点击的,那么点击该控件时,onTouchEvent的返回值必定是true
    } 
    return false;
} 

performClick()@View.java

// 如果定义了OnClickListener,则调用。执行所有与click关联的动作:报告可访问性事件,播放按键声音。
public boolean performClick() {
    sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
    
    ListenerInfo li = mListenerInfo;
    if (li != null && li.mOnClickListener != null) {
        playSoundEffect(SoundEffectConstants.CLICK);
        li.mOnClickListener.onClick(this);
        return true;
    }
    return false;
}

 setOnClickListener()@View.java

public void setOnClickListener(OnClickListener l) {
    if (!isClickable()) {
        setClickable(true);  // 如果这个view不是clickable,将它设置为clickable。
    }
    getListenerInfo().mOnClickListener = l;
}

     如果给一个View设置了OnClickListener,那么onClick()事件是在onTouchEvent()函数中被调用的。

1.3 ViewGroup对Touch事件的处理

onInterceptTouchEvent()@ViewGroup.java

// 实现这个方法来拦截所有触摸屏移动事件。这可以让你在事件被分配给孩子的时候看到事件,并在任意时刻获取当前手势的所有权。
// 使用这个功能需要特别注意,因为它与View.onTouchEvent有着相当复杂的相互作用,并且使用它还需要以正确的方式实现这个方法。
// 事件将会以下面顺序被接收:
// (1) ViewGroup会在这里接收到DOWN事件,这个DOWN事件会被这个ViewGroup的一个子View处理掉,或者给这个ViewGroup自己的onTouchEvent函数进行处理。那就意味着ViewGroup应该实现onTouchEvent()函数并且返回true, 这样你就会继续看到手势的后续事件(而不是寻找父View来处理)。
// (2) 通过从ViewGroup自己的onTouchEvent()返回true, ViewGroup的onInterceptTouchEvent()中将不会再收到任何后续事件,即后续事件不用再经过onInterceptTouchEvent()了,所有触摸的处理都像正常情况一样发生在onTouchEvent里了。
// (3) 只要ViewGroup从这个函数返回false,接下来的每个事件(包括最后的UP)都会首先传递到这里,然后再传递给目标View的onTouchEvent()。
// (4) 如果ViewGroup从这个函数返回true,说明从子view拦截了事件,并将它们通过onTouchEvent()传递给这个ViewGroup。当前目标View将接收到相同事件,但是Action为ACTION_CANCEL,并且没有进一步消息在这里传递。

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

dispatchTouchEvent()@ViewGroup.java

public boolean dispatchTouchEvent(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;

        // 处理最初的down事件
        if (actionMasked == MotionEvent.ACTION_DOWN) {
            // 开始一个新的触摸手势时,丢掉所有之前的状态。framework可能由于app切换,ANR或者其它状态变化而放弃前一个手势的up或者cancel事件。
            cancelAndClearTouchTargets(ev);
            resetTouchState();
        }

        // 检查拦截
        final boolean intercepted;
        if (actionMasked == MotionEvent.ACTION_DOWN || mFirstTouchTarget != null) {
            final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;       // 是否禁用事件拦截功能,默认为false.
            if (!disallowIntercept) {
                intercepted = onInterceptTouchEvent(ev);// 根据onInterceptTouchEvent返回值决定是否拦截,返回false表示不拦截,返回true表示拦截。
                ev.setAction(action); // 重新保存action,以防它发生变化。
            } else {
                intercepted = false;
            }
        } else {
            // 没有触摸目标且action不是最初的DOWN事件,那么这个ViewGroup继续拦截触摸事件。
            intercepted = true;
        }

        // 检查取消
        final boolean canceled = resetCancelNextUpFlag(this) || actionMasked == MotionEvent.ACTION_CANCEL;

        // 如果需要,更新触摸目标列表给向下的指针。
        final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0;
        TouchTarget newTouchTarget = null;
        boolean alreadyDispatchedToNewTouchTarget = false;
        if (!canceled && !intercepted) { // 如果不是CANCEL,而且不拦截事件,则往下走。intercepted的值在前面被赋值。intercepted为true,则事件不再往下传。
            if (actionMasked == MotionEvent.ACTION_DOWN || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
                            || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
                final int actionIndex = ev.getActionIndex();  // DOWN事件这个值通常为0
                final int idBitsToAssign = split ? 1 << ev.getPointerId(actionIndex) : TouchTarget.ALL_POINTER_IDS;
    
                // 为该指针id除早期的触摸目标,以防它们已经不同步了。
                removePointersFromTouchTargets(idBitsToAssign);
                final int childrenCount = mChildrenCount;
                if (newTouchTarget == null && childrenCount != 0) {
                    final float x = ev.getX(actionIndex);
                    final float y = ev.getY(actionIndex);
                    // 从前往后扫描,找一个可以接收事件的子view。
                    final View[] children = mChildren;
                    final boolean customOrder = isChildrenDrawingOrderEnabled();
                    for (int i = childrenCount - 1; i >= 0; i--) {
                        final int childIndex = customOrder ? getChildDrawingOrder(childrenCount, i) : i;
                        final View child = children[childIndex];
                        if (!canViewReceivePointerEvents(child) || !isTransformedTouchPointInView(x, y, child, null)) {
                            continue;
                        }
    
                        newTouchTarget = getTouchTarget(child);
                        if (newTouchTarget != null) {
                            // 子view已经在它的范围内接收触摸事件了。
                            // 给它新指针,除了它正在处理的指针。
                            newTouchTarget.pointerIdBits |= idBitsToAssign;
                            break;      // 找到了接收事件的target,跳出循环。
                        }
    
                        resetCancelNextUpFlag(child);
                        if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {   // dispatchTransformedTouchEvent函数中调用子view的dispatchTouchEvent。
                            // 子view在它的范围内接收触摸事件。
                            mLastTouchDownTime = ev.getDownTime();
                            mLastTouchDownIndex = childIndex;
                            mLastTouchDownX = ev.getX();
                            mLastTouchDownY = ev.getY();
                            newTouchTarget = addTouchTarget(child, idBitsToAssign);
                            alreadyDispatchedToNewTouchTarget = true;
                            break;
                        }
                    }
                }
    
                if (newTouchTarget == null && mFirstTouchTarget != null) {
                    // 没有找到一个子view来接收事件,将指针指向最近添加的目标。
                    newTouchTarget = mFirstTouchTarget;
                    while (newTouchTarget.next != null) {
                        newTouchTarget = newTouchTarget.next;
                    }
                    newTouchTarget.pointerIdBits |= idBitsToAssign;
                }
            }
        }
        // 分发给触摸目标
        if (mFirstTouchTarget == null) {
            // 没有触摸目标,那么把它当作一个普通的view。
            handled = dispatchTransformedTouchEvent(ev, canceled, null, TouchTarget.ALL_POINTER_IDS);
        } else {
            // 分发给触摸目标,如果我们已经分发给它那么就排除新的触摸目标。如有必要取消触摸目标。
            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 (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;
            }
        }
    
        // Update list of touch targets for pointer up or cancel, if needed.
        // 如果需要,为指针UP或者CANCEL更新触摸目标列表。
        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;
}

 dispatchTransformedTouchEvent()@ViewGroup.java

// 将手势事件转换成特定子view的坐标空间,过滤无关的指针ID,如有必要覆盖它的action。如果child为null,则取而代之的是假定手势事件会发送给该ViewGroup。
private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel, View child, int desiredPointerIdBits) {
    final boolean handled;
 
    // 取消手势动作是一种特殊情况。不需要执行任何转换或者过滤操作。重点关注的是action,而不是内容。
    final int oldAction = event.getAction();
    if (cancel || oldAction == MotionEvent.ACTION_CANCEL) {
        event.setAction(MotionEvent.ACTION_CANCEL);
        if (child == null) {
            handled = super.dispatchTouchEvent(event);
        } else {
            handled = child.dispatchTouchEvent(event);     // 调用child的dispatchTouchEvent。
        }
        event.setAction(oldAction);
        return handled;
    }

    // 结算要传递的指针数量。
    final int oldPointerIdBits = event.getPointerIdBits();
    final int newPointerIdBits = oldPointerIdBits & desiredPointerIdBits;

    // 如果因为某种原因,我们在一个不符的状态中结束了,在这个状态中看起来我们可能会产生一个不带指针的手势事件,那么就放弃这个事件。
    if (newPointerIdBits == 0) {
        return false;
    }

    // 如果指针的数量是相等的,那么我们就不需要执行任何代价高的不可逆转的转换,那么只要我们小心恢复我们做的任何修改,我们就可以在这次分发中重用手势事件。
    // 否则,我们就需要复制一个手势事件。
    final MotionEvent transformedEvent;
    if (newPointerIdBits == oldPointerIdBits) {
        if (child == null || child.hasIdentityMatrix()) {
            if (child == null) {
                handled = super.dispatchTouchEvent(event);
            } else {
                final float offsetX = mScrollX - child.mLeft;
                final float offsetY = mScrollY - child.mTop;
                event.offsetLocation(offsetX, offsetY);
    
                handled = child.dispatchTouchEvent(event);

                event.offsetLocation(-offsetX, -offsetY);
            }
            return handled;
        }
        transformedEvent = MotionEvent.obtain(event);
    } else {
        transformedEvent = event.split(newPointerIdBits);
    }

    // 执行任何需要的转换和分发。
    if (child == null) {
        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());
        }
        handled = child.dispatchTouchEvent(transformedEvent); //若一个控件是可点击的,则点击该控件时,dispatchTouchEvent的返回值必定是true
    }
    // 完成
    transformedEvent.recycle();
    return handled;
}

 



易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!