Android 触摸事件分发源码

作为以触摸作为主要交互的系统，触摸事件是我们在写代码时无可避免的。不论是对触摸事件进行响应，还是拦截一些不需要关心的事件，都需要我们对View中触摸事件的分发机制进行了解。

ViewGroup事件的分发拦截和处理

触摸事件一般是从Activity开始分发，但是这里我们就跳过Activity，直接从根布局也就是ViewGroup开始了。

事件分发(dispatchTouchEvent)

源码

public boolean dispatchTouchEvent(MotionEvent ev) {

    /*...省略...*/
    boolean handled = false;
    if (onFilterTouchEventForSecurity(ev)) {
        final int action = ev.getAction();
        final int actionMasked = action & MotionEvent.ACTION_MASK;

        /*...省略...*/
        // 1. 将ACTION_DOWN事件作为一系列触摸事件的起始，对事件进行初始化.
        if (actionMasked == MotionEvent.ACTION_DOWN) {
            // 在开始一系列新的手势时清除之前的所有状态（可能由于app切换、ANR所遗留下来）
            // 将mFirstTouchTarget重置为null(在clearTouchTargets()中)，并且回收事件
            cancelAndClearTouchTargets(ev);
            resetTouchState();// 重置所有的触摸状态
        }

        // 2. 检测是否需要拦截.
        final boolean intercepted;
        if (actionMasked == MotionEvent.ACTION_DOWN || mFirstTouchTarget != null) {
            // 当触摸事件为ACTION_DOWN或者mFirstTouchTarget不为null时（也就是已经找到接受事件并可以接受后续事件的子View）
            final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
            // 通过requestDisallowInterceptTouchEvent(boolean disallowIntercept)可以设置ViewGroup是否禁用拦截
            if (!disallowIntercept) {
                // 如果没有禁用拦截，那么就调用当前ViewGroup的onInterceptTouchEvent()方法。对是否拦截进行判断
                intercepted = onInterceptTouchEvent(ev);
                ev.setAction(action);
            } else {
                // 如果禁用拦截，那么直接返回false
                intercepted = false;
            }
        } else {
            // 触摸事件不是初始的ACTION_DOWN事件，并且没有接收后续事件的View控件。ViewGroup会继续拦截触摸事件
            intercepted = true;
        }

        // 如果对事件进行了拦截，或者已经有一个控件对手势进行处理。那么进行normal的事件分发（这里不太明白）
        if (intercepted || mFirstTouchTarget != null) {
            ev.setTargetAccessibilityFocus(false);
        }

        final boolean canceled = resetCancelNextUpFlag(this) || actionMasked == MotionEvent.ACTION_CANCEL;
        // 判断事件是否是ACTION_CANCEL或者之前的手势遗留的
        final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0;// 判断VIewGroup是否可以分发事件

        TouchTarget newTouchTarget = null;
        boolean alreadyDispatchedToNewTouchTarget = false;
        if (!canceled && !intercepted) {
            // 如果事件不是ACTION_CANCEL并且没有进行拦截

            View childWithAccessibilityFocus = ev.isTargetAccessibilityFocus() ? findChildWithAccessibilityFocus(): null;
            // 3. 当事件为ACTION_DOWN时进入该方法（另两个条件不太明白）
            if (actionMasked == MotionEvent.ACTION_DOWN || (split && actionMasked == MotionEvent
                    .ACTION_POINTER_DOWN)
                    || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {

                /*...省略...*/
                final int childrenCount = mChildrenCount;
                if (newTouchTarget == null && childrenCount != 0) {
                    // 获取触摸的位置
                    final float x = ev.getX(actionIndex);
                    final float y = ev.getY(actionIndex);

                    /*...省略...*/
                    // 按照从前到后的顺序遍历子View，找到可以接收事件的子View
                    final View[] children = mChildren;
                    for (int i = childrenCount - 1; i >= 0; i--) {
                        // 后添加的View覆盖在最上层，从集合的最后向前遍历
                        final int childIndex = customOrder ? getChildDrawingOrder(childrenCount, i) : i;
                        final View child = (preorderedList == null) ? children[childIndex] : preorderedList.get
                                (childIndex);

                        /*...省略...*/
                        // 如果子View不能接收事件，或者Transformed(不太明白)后的触摸点不在子View中，continue。加速查找
                        if (!canViewReceivePointerEvents(child) || !isTransformedTouchPointInView(x, y, child,
                                null)) {
                            ev.setTargetAccessibilityFocus(false);
                            continue;
                        }

                        // 如果没有可以接收事件的子View就返回null，否则返回子View
                        newTouchTarget = getTouchTarget(child);
                        if (newTouchTarget != null) {
                            // 如果已经找到了接收事件的子View，就跳出循环
                            newTouchTarget.pointerIdBits |= idBitsToAssign;
                            break;
                        }

                        resetCancelNextUpFlag(child);

                        // 通过dispatchTransformedTouchEvent()方法，递归遍历所有子View。
                        // 如果返回true，说明事件被子View消费了
                        if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
                            mLastTouchDownTime = ev.getDownTime();
                            if (preorderedList != null) {
                                for (int j = 0; j < childrenCount; j++) {
                                    if (children[childIndex] == mChildren[j]) {
                                        mLastTouchDownIndex = j;
                                        break;
                                    }
                                }
                            } else {
                                mLastTouchDownIndex = childIndex;
                            }
                            mLastTouchDownX = ev.getX();
                            mLastTouchDownY = ev.getY();
                            //将接收并消费ACTION_DOWN事件的子View其赋值给newTouchTarget，作为后续事件的接受者。跳出循环
                            newTouchTarget = addTouchTarget(child, idBitsToAssign);
                            alreadyDispatchedToNewTouchTarget = true;
                            break;
                        }

                        ev.setTargetAccessibilityFocus(false);
                    }
                    if (preorderedList != null) preorderedList.clear();
                }

                    if (newTouchTarget == null && mFirstTouchTarget != null) {
                        // 没有找到可以接收事件的子View，但是之前某个子View消费过触摸事件。那么将该子View赋值给newTouchTarget
                        newTouchTarget = mFirstTouchTarget;
                        while (newTouchTarget.next != null) {
                            newTouchTarget = newTouchTarget.next;
                        }
                    newTouchTarget.pointerIdBits |= idBitsToAssign;
                }
            }
        }

        // 4. 如果触摸事件不是ACTION_DOWN时，处理事件.
        if (mFirstTouchTarget == null) {
            // a. 没有哪个子View能够消费ACTION_DOWN事件，或者后续的事件被拦截了
            // 将ViewGroup作为一般的View，调用dispatchTransformedTouchEvent()对事件进行处理(参数传入null)
            handled = dispatchTransformedTouchEvent(ev, canceled, null, TouchTarget.ALL_POINTER_IDS);
        } else {
            // b. 存在某个子View能够消费ACTION_DOWN事件
            TouchTarget predecessor = null;
            TouchTarget target = mFirstTouchTarget;
            while (target != null) {
                final TouchTarget next = target.next;
                if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
                    // 如果能消费ACTION_DOWN的子View，同时也在这次触摸事件中消费ACTION_DOWN事件，也就是第一次消费事件。(瞎猜的:P)
                    handled = true;中
                } else {
                    // 对于ACTION_DOWN后续的事件，根据onInterceptTouchEvent()的返回值决定是否想子View发送ACTION_CANCEL
                    final boolean cancelChild = resetCancelNextUpFlag(target.child) || intercepted;
                    // 再将事件通过dispatchTransformedTouchEvent()交由子View处理
                    if (dispatchTransformedTouchEvent(ev, cancelChild, target.child, target.pointerIdBits)) {
                        handled = true;
                    }
                    /*...省略...*/
                }
            }
            /*...省略...*/
        }

        if (canceled || actionMasked == MotionEvent.ACTION_UP || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
            // 如果对后续的事件设置了CANCEL或者事件是ACTION_UP.重置事件状态
            resetTouchState();
        } else if (split && actionMasked == MotionEvent.ACTION_POINTER_UP) {
            final int actionIndex = ev.getActionIndex();
            final int idBitsToRemove = 1 << ev.getPointerId(actionIndex);
            removePointersFromTouchTargets(idBitsToRemove);
        }
    }

    /*...省略...*/
    return handled;
}

源码分析

将ACTION_DOWN事件作为一系列触摸事件的起始，对事件进行初始化. 这个步骤最重要的一点就是将mFirstTouchTarget置为null

检测是否需要拦截先判断当前ViewGroup是否禁用了拦截。如果禁用了，直接返回false 如果没有禁用，当触摸事件为ACTION_DOWN或着是接收后续事件时会调用**onInterceptTouchEvent()**进行判断

如果不进行拦截，当触摸事件为ACTION_DOWN时(触摸事件的起始)进行特殊的判断递归遍历子View，找到能够消费事件的子View。在这个过程中多次调用dispatchTransformedTouchEvent()方法以递归的形式将事件依次发送给子View 这个步骤最重要的一点就是是否给mFirstTouchTarget赋值

处理完ACTION_DOWN后，对事件是否消费做判断(根据mFirstTouchTarget是否为null) 如果没有子View可以消费事件或者事件被拦截，事件通过dispatchTransformedTouchEvent()由父ViewGroup处理，返回结果如果当前事件为ACTION_DOWN并且被消费，返回true 如果当前事件为ACTION_DOWN的后续事件，根据onInterceptTouchEvent()的返回值决定向下分发的时ACTION_CANCEL还是当前事件。通过dispatchTransformedTouchEvent()由子View处理，返回结果

ViewGroup中事件的拦截

源码

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

源码分析

ViewGroup中对事件是不进行拦截的，将其向下传送

ViewGroup中事件的处理

源码


private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
        View child, int desiredPointerIdBits) {
    final boolean handled;

    final int oldAction = event.getAction();
    if (cancel || oldAction == MotionEvent.ACTION_CANCEL) {
        // 1. 根据传入的参数cancel或者事件决定发送的事件是否时ACTION_CANCEL
        event.setAction(MotionEvent.ACTION_CANCEL);
        // 2. 根据传入的参数child决定是将事件交由父ViewGroup还是交由子View处理
        if (child == null) {
            handled = super.dispatchTouchEvent(event);
        } else {
            handled = child.dispatchTouchEvent(event);
        }
        event.setAction(oldAction);
        return handled;
    }

    final int oldPointerIdBits = event.getPointerIdBits();
    final int newPointerIdBits = oldPointerIdBits & dcancelesiredPointerIdBits;

    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);
    }

    transformedEvent.recycle();
    return handled;
}

源码分析

虽然这个方法很长，但是其实我们只需要关注两个参数：boolean cancel和View child

boolean cancel控制了发送的事件是否是ACTION_CANCEL

View child控制了事件是发送给子View还是交由父ViewGroup处理

事件是否被消费决定了最后的返回值。

ViewGroup是View的子类，他并没有重写View的onTouchEvent()方法。所以如果事件交由父ViewGroup处理，实际调用的是super.dispatchTouchEvent()

将触摸事件从ACTION_DOWN -> ACTION_MOVE -> ACTION_UP看做一系列触摸事件的整体。当ViewGroup处理这一系列事件的过程中，我们需要特别注意一个变量：mFirstTouchTarget。在ACTION_DOWN事件中mFirstTouchTarget被置为了null。那么mFirstTouchTarget的最终值就意味着是否找到了能够消费触摸事件的子View。来看一下mFirstTouchTarget在那些情况下可以被赋值：

在ACTION_DOWN事件中：a).父ViewGroup不对事件进行拦截；2).点击点位于某个子View上；3). 被点击的子View消费了ACTION_DOWN事件
在ACTION_DOWN的后续事件中：a). 首先必须存在可以消费ACTION_DOWN事件的子View，否则后续事件都无法向下分发；b). 在分发后续事件时，父ViewGroup不对事件进行拦截

View中事件的分发和处理

上面我们说到了当ViewGroup中所有的子View都无法消费触摸事件时，会把事件返回给ViewGroup，再调用View的dispatchTouchEvent()方法，那么就来看看具体的实现吧

事件分发

源码

public boolean dispatchTouchEvent(MotionEvent event) {

    /*...省略...*/
    boolean result = false;

    /*...省略...*/
    final int actionMasked = event.getActionMasked();
    if (actionMasked == MotionEvent.ACTION_DOWN) {
        // NestedScroll是Lolipop之后添加的嵌套滚动机制，用于解决子View不处理滑动事件时，父View也无法处理的该事件的问题
        // 这里我们只要看作是触摸事件时清除掉之前的触摸事件的状态就可以了
        stopNestedScroll();
    }

    if (onFilterTouchEventForSecurity(event)) {
        // ListenerInfo是封装了一系列监听器的类
        ListenerInfo li = mListenerInfo;
        if (li != null && li.mOnTouchListener != null && (mViewFlags & ENABLED_MASK) == ENABLED && li.mOnTouchListener.onTouch(this, event)) {
            // 1. 首先判断是否给View添加了onTouchListener监听器；mViewFlags是在View构造时传入的一系列状态值，这里用来判断View是否是enabled的。
            // 如果前面都为true，最后执行监听器的onTouch()方法，并根据其返回值决定result的值
            result = true;
        }

        if (!result && onTouchEvent(event)) {
            // 2. 当未设置onTouchListener或者onTouch()方法返回false（表示事件未被消费），则会调用onTouchEvent()方法并决定result的值
            result = true;
        }
    }

    /*...省略...*/
    return result;
}

源码分析

相比起ViewGroup，View的dispatchTouchEvent()方法就简单多了。重点主要有两点：

判断View是否设置了onTouchListener，相信设置监听器的方法大家应该都知道了——setOnTouchListener()。如果设置了监听器，就调用监听器的onTouch()方法

如果没有设置监听器或者onTouch()返回false时，会调用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) {
            // 当触摸事件为ACTION_UP并且View未设定pressed属性时，设置pressed状态未false
            setPressed(false);
        }
        // 1. 如果当前View同时具有clickable和disabled两个属性，返回true(消费事件但不作出响应)
        return (((viewFlags & CLICKABLE) == CLICKABLE
                || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
                || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE);
    }

    // 2. 将事件委托给一个代理进行处理，如果代理的onTouchEvent()返回true，表示事件被消费（不懂）
    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) {

                    /*...省略...*/
                    //做了一系列判断，设置按下状态并迅速弹起
                    if (!mHasPerformedLongPress && !mIgnoreNextUpEvent) {
                        // 判断未tap（轻触）状态，移除长按的回调
                        removeLongPressCallback();

                        // 如果View没有夺取焦点
                        if (!focusTaken) {
                            // 调用一个处理Click事件的Runnable对象进行异步的处理
                            // 最终调用了onClickListener的onClick()方法
                            if (mPerformClick == null) {
                                mPerformClick = new PerformClick();
                            }
                            if (!post(mPerformClick)) {
                                performClick();
                            }
                        }
                    }

                    if (mUnsetPressedState == null) {
                        mUnsetPressedState = new UnsetPressedState();
                    }
                    /*...省略...*/
                }
                break;

            case MotionEvent.ACTION_DOWN:

                /*...省略...*/
                // 处理长按事件等
                break;

            case MotionEvent.ACTION_CANCEL:
                /*...省略...*/
                //移除回调、清除状态
                break;

            case MotionEvent.ACTION_MOVE:
                /*...省略...*/
                break;
        }
        // 3. 只要View是clickable、longclickable或者contextclickable的，不论触摸事件是什么都消费事件
        return true;
    }

    return false;
}

//PerformClick类中执行的还是performClick()方法
private final class PerformClick implements Runnable {
    @Override
    public void run() {
        performClick();
    }
}

//处理Click事件的方法
public boolean performClick() {
    final boolean result;
    final ListenerInfo li = mListenerInfo;
    if (li != null && li.mOnClickListener != null) {
        playSoundEffect(SoundEffectConstants.CLICK);
        // 调用onClickListener的onClick()方法
        li.mOnClickListener.onClick(this);
        result = true;
    } else {
        result = false;
    }

   sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
    return result;
}

源码分析

对onTouchEvent()的分析，我们主要关注其返回值

View同时具有clickable和disabled两个属性，返回true(消费事件但不作出响应)

只要View是clickable、longclickable或者contextclickable的，不论触摸事件是什么都消费事件

如果不是上面的情况，返回false

要注意的是，在第二种情况下，当触摸事件是ACTION_DOWN时，创建了一个处理Click事件的Runnable对象并将其加入消息队列这个Runnable对象内部执行的是performClick()方法。而我们可以看到，如果Runnable对象添加到消息队列失败的话时会直接调用这个方法的在performClick()中，判断了是否设置了onClickListener，最终调用了onClickListener的onClick()方法

文章目录

ViewGroup事件的分发拦截和处理

事件分发(dispatchTouchEvent)

源码

源码分析

ViewGroup中事件的拦截

源码

源码分析

ViewGroup中事件的处理

源码

源码分析

View中事件的分发和处理

事件分发

源码

源码分析

事件处理

源码

源码分析