Android事件分发机制源码解析

前言

在网上查找了无数的事件分发机制详解，但是基本上都忘光了，所以自己就写上一篇，以备日后查找。

View点击事件

直接进入主题，一些比较基础的东西这里就不提了，点击Button的时候，会先触发View的dispatchTouchEvent(MotionEvent event)

public boolean dispatchTouchEvent(MotionEvent event) {

        ...

        boolean result = false;

        ...

            ListenerInfo li = mListenerInfo;
        ...    
        //对result进行赋值
            if (li != null && li.mOnTouchListener != null
                    && (mViewFlags & ENABLED_MASK) == ENABLED
                    //mOnTouchListener是一个全局变量，是在设置监听时赋值的
                    //**重点** 如果mOnTouchListener不为空（即设置了监听），此处就会进行回调
                    && li.mOnTouchListener.onTouch(this, event)) {
                result = true;
            }

            //**重点** 根据&&的特性，如果result为true，onTouchEvent就不会执行
            if (!result && onTouchEvent(event)) {
                result = true;
            }

        ...

        return result;
    }

接着看onTouchEvent方法

    public boolean onTouchEvent(MotionEvent event) {
        ...
         switch (action) {
                case MotionEvent.ACTION_UP:
        ...
        //手指抬起的时候触发performClick()
              if (!post(mPerformClick)) {
                 performClick();
             }
        ...
                    break;
        ...

        return false;
    }

    public boolean performClick() {
        final boolean result;
        final ListenerInfo li = mListenerInfo;
        if (li != null && li.mOnClickListener != null) {
            playSoundEffect(SoundEffectConstants.CLICK);
            //**重点** 如果设置了点击事件则会触发onClick
            li.mOnClickListener.onClick(this);
            result = true;
        } else {
            result = false;
        }

        sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
        return result;
    }

通过上面一系列的源码分析，我们可以知道为什么OnTouchListener中返回true之后，OnClickListener不会触发。

onTouchEvent、dispatchTouchEvent和onInterceptTouchEvent

首先让我们自定义一个ViewGroup重写上述三个方法

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        Log.d(TAG, "ViewGroup onTouchEvent: " + event.getAction());
        return super.onTouchEvent(event);
    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        Log.d(TAG, "ViewGroup dispatchTouchEvent: " + ev.getAction());
        return super.dispatchTouchEvent(ev);
    }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        Log.d(TAG, "ViewGroup onInterceptTouchEvent: " + ev.getAction());
        return super.onInterceptTouchEvent(ev);
    }

然后在Activity中重写

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        Log.d(TAG, "MainActivity onTouchEvent: " + event.getAction());
        return super.onTouchEvent(event);
    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        Log.d(TAG, "MainActivity dispatchTouchEvent: " + ev.getAction());
        return super.dispatchTouchEvent(ev);
    }

点击ViewGroup之后，日志如下

D/Chauncey: MainActivity dispatchTouchEvent: 0
D/Chauncey: ViewGroup dispatchTouchEvent: 0
D/Chauncey: ViewGroup onInterceptTouchEvent: 0
D/Chauncey: ViewGroup onTouchEvent: 0
D/Chauncey: MainActivity onTouchEvent: 0
D/Chauncey: MainActivity dispatchTouchEvent: 2
D/Chauncey: MainActivity onTouchEvent: 2
D/Chauncey: MainActivity dispatchTouchEvent: 1
D/Chauncey: MainActivity onTouchEvent: 1

为什么是这样的一个顺序，先来看看Activity下的dispatchTouchEvent

    public boolean dispatchTouchEvent(MotionEvent ev) {
        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
        //用户与屏幕互动时调用的方法，是一个空的方法，根据需要重写
            onUserInteraction();
        }
        //superDispatchTouchEvent返回true的情况下，onTouchEvent将不会被执行
        //superDispatchTouchEvent是一个抽象方法，实现类在Window的唯一子类PhoneWindow中
        if (getWindow().superDispatchTouchEvent(ev)) {
            return true;
        }
        return onTouchEvent(ev);
    }

查看PhoneWindow.java

    @Override
    public boolean superDispatchTouchEvent(MotionEvent event) {
        //mDecor是DecorView：Activity最顶层的View，继承自FrameLayout，也就是说DecorView是一个ViewGroup
        return mDecor.superDispatchTouchEvent(event);
    }

查看DecorView.superDispatchTouchEvent(event)

    public boolean superDispatchTouchEvent(MotionEvent event) {
    //直接调用父类(ViewGroup)的dispatchTouchEvent
        return super.dispatchTouchEvent(event);
    }

ViewGroup.superDispatchTouchEvent(event)

@Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
            if (mInputEventConsistencyVerifier != null) {
                mInputEventConsistencyVerifier.onTouchEvent(ev, 1);
            }

            //辅助类，此处不深入讨论
            if (ev.isTargetAccessibilityFocus() && isAccessibilityFocusedViewOrHost()) {
                ev.setTargetAccessibilityFocus(false);
            }

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

            if (actionMasked == MotionEvent.ACTION_DOWN) {
                //清除标志，这个方法后面会详细说明
                cancelAndClearTouchTargets(ev);
                resetTouchState();
            }

            //检查父控件是否拦截
            final boolean intercepted;
            if (actionMasked == MotionEvent.ACTION_DOWN
                    || mFirstTouchTarget != null) {
            //mGroupFlags 是一个标志位，通过调用requestDisallowInterceptTouchEvent方法可对其进行修改
                final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;

                if (!disallowIntercept) {
            //**重点** 不允许拦截的情况下，会调用onInterceptTouchEvent方法
                    intercepted = onInterceptTouchEvent(ev);
                    ev.setAction(action); // restore action in case it was changed
                } else {
                    intercepted = false;
                }
            } else {
                intercepted = true;
            }
        if (intercepted || mFirstTouchTarget != null) {
                ev.setTargetAccessibilityFocus(false);
            }

            final boolean canceled = resetCancelNextUpFlag(this)
                    || actionMasked == MotionEvent.ACTION_CANCEL;
            ...

            if (!canceled && !intercepted) {
            ...
            //如果不拦截，则对mFirstTouchTarget 进行一些操作
            }

            if (mFirstTouchTarget == null) {

                //**重点** 当被拦截时会调用，这个是真正做事件分发的方法
                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;
                }
            }


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

    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) {
            event.setAction(MotionEvent.ACTION_CANCEL);
            //**重点** 当子控件为空则调用父控件的dispatchTouchEvent
            if (child == null) {
                handled = super.dispatchTouchEvent(event);
            } else {
                handled = child.dispatchTouchEvent(event);
            }
            event.setAction(oldAction);
            return handled;
        }
        ...
        // Otherwise we need to make a copy.
        final MotionEvent transformedEvent;
        if (newPointerIdBits == oldPointerIdBits) {
            if (child == null || child.hasIdentityMatrix()) {
                if (child == null) {
                    handled = super.dispatchTouchEvent(event);
                } else {
                ...

                    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 {
        ...

            handled = child.dispatchTouchEvent(transformedEvent);
        }

        // Done.
        transformedEvent.recycle();
        return handled;
    }

重新来看cancelAndClearTouchTargets(ev)方法

private void cancelAndClearTouchTargets(MotionEvent event) {
        //mFirstTouchTarget是一个TouchTarget对象，手指点击在屏幕上（最多可支持32个手指），第一次触发Down事件时，mFirstTouchTarget为空，第二个手指点击到屏幕上时，mFirstTouchTarget 不为空
        if (mFirstTouchTarget != null) {
            boolean syntheticEvent = false;
            if (event == null) {
                final long now = SystemClock.uptimeMillis();
                event = MotionEvent.obtain(now, now,
                        MotionEvent.ACTION_CANCEL, 0.0f, 0.0f, 0);
                event.setSource(InputDevice.SOURCE_TOUCHSCREEN);
                syntheticEvent = true;
            }

            for (TouchTarget target = mFirstTouchTarget; target != null; target = target.next) {
                resetCancelNextUpFlag(target.child);
                dispatchTransformedTouchEvent(event, true, target.child, target.pointerIdBits);
            }
            //全部初始化
            clearTouchTargets();

            if (syntheticEvent) {
                event.recycle();
            }
        }
    }

    private void clearTouchTargets() {
        TouchTarget target = mFirstTouchTarget;
        if (target != null) {
            do {
            //TouchTarget 是一个单向链表结构，此处遍历所有的TouchTarget对象进行重置
                TouchTarget next = target.next;
                target.recycle();
                target = next;
            } while (target != null);
            mFirstTouchTarget = null;
        }
    }

    @Override
    public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {

        if (disallowIntercept == ((mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0)) {
            // We're already in this state, assume our ancestors are too
            return;
        }

        if (disallowIntercept) {
            mGroupFlags |= FLAG_DISALLOW_INTERCEPT;
        } else {
            mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
        }

        // Pass it up to our parent
        if (mParent != null) {
            mParent.requestDisallowInterceptTouchEvent(disallowIntercept);
        }
    }