Android 事件传递机制

时间 2020-02-02

标签 android 事件传递机制栏目 Android 繁體版

原文原文链接

有不少博客写过Android 事件传递机制,可是我看了一大圈,没有让我满意的,或版本老旧,或过于复杂,或直接是有内在逻辑错误java

参考内容: 《Android 开发艺术探索》网络

Android事件分发机制详解攻略，您值得拥有ide

本博客只分析单指状况下,ACTION_DOWN,ACTION_MOVE,ACTION_UP,ACTION_CANCEL事件相关源码分析

在这里分析的源代码,部分在官方源码的基础上,进行了简化改写,以便于分析post

关于 MotionEvent 基础,请参考:Android MotionEvent详解动画

事件在哪些对象之间进行传递？

答：Activity、ViewGroup、Viewthis

当一个点击事件发生时，事件最早传到Activity的dispatchTouchEvent()进行事件分发spa

// 源码分析：Activity.dispatchTouchEvent()
public boolean dispatchTouchEvent(MotionEvent ev) {
    if (ev.getAction() == MotionEvent.ACTION_DOWN) {
        onUserInteraction();// 一个空的hook方法,不用管
    }
    if (getWindow().superDispatchTouchEvent(ev)) {
        // 若getWindow().superDispatchTouchEvent(ev)的返回true,事件已经被处理了
        // getWindow()返回的为PhoneWindow对象(Activity#attach方法中建立)
        return true;
    }
    // 若getWindow().superDispatchTouchEvent(ev)的返回false,调用Activity.onTouchEvent
    return onTouchEvent(ev);
}

// PhoneWindow#superDispatchTouchEvent()
@Override
public boolean superDispatchTouchEvent(MotionEvent event) {
    // mDecor是window中的顶层View,类型为DecorView,继承自FrameLayout
    return mDecor.superDispatchTouchEvent(event);
}

// DecorView#superDispatchTouchEvent()
public boolean superDispatchTouchEvent(MotionEvent event) {
    // 也即调用了ViewGroup#dispatchTouchEvent()
    return super.dispatchTouchEvent(event);
}

// 回到最初的调用原处
// Activity#onTouchEvent() 
public boolean onTouchEvent(MotionEvent event) {
    if (mWindow.shouldCloseOnTouch(this, event)) {
        finish();
        return true;
    }
    // 默认返回false
    return false;
}

// Window#shouldCloseOnTouch
public boolean shouldCloseOnTouch(Context context, MotionEvent event) {
    if (mCloseOnTouchOutside && event.getAction() == MotionEvent.ACTION_DOWN && isOutOfBounds(context, event)
            && peekDecorView() != null) {
        return true;
    }
    return false;
}

总结: activity 将时间分发给 window,window 将事件给到本身的 DecorView,DecorView 事件分发的的流程为 ViewGroup 的事件分发流程.net

对 activity 来讲,若是交给 window 的事件分发没有消费掉事件(返回 false),将调用本身的 onTouchEvent 方法.code

ViewGroup的事件分发

// ViewGroup#dispatchTouchEvent()
// 这里只分析 MOTION_DOWN,MOTION_MOVE,MOTION_UP,MOTION_CANCEL事件相关,其余的都被过滤掉了
// 只分析单指状况,多指触控状况也被过滤掉
// 这里对官方源代码作了改写,便于理解
// mFirstTouchTarget,实际上为一个链表,可是这里分析单指状况,一个事件只能给一个 View 处理,因此这里能够认为就是一个对象
public boolean dispatchTouchEvent(MotionEvent ev) {
    boolean handled = false;// 方法最终返回的值
    final int action = ev.getAction();
    final int actionMasked = action & MotionEvent.ACTION_MASK;
    // Handle an initial down.
    // 收到 ACTION_DOWN,清除掉 mFirstTouchTarget 和 disallowIntercept 标识
    if (actionMasked == MotionEvent.ACTION_DOWN) {
        cancelAndClearTouchTargets(ev);// 分析 1
        resetTouchState();// 分析 2
    }
    // Check for interception.  处理拦截
    // 这里根据为了便于理解,对源代码进行了必定的改写,简化代码,便于理解
    boolean intercepted = true;// There are no touch targets and this action is not an initial down so this view group continues to intercept touches.
    if (actionMasked == MotionEvent.ACTION_DOWN) {
        // ACTION_DOWN 时,必定会调用 onInterceptTouchEvent
        intercepted = onInterceptTouchEvent(ev);
    } else if (mFirstTouchTarget != null) {
        // 不是 ACTION_DOWN 时,若是 mFirstTouchTarget 链表不为空(这个事件序列以前被子 view 处理过),
        // 就须要经过 onInterceptTouchEvent 判断是否须要拦截了
        final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
        intercepted = disallowIntercept ? false : onInterceptTouchEvent(ev);
    }
    // Check for cancelation. 处理取消事件
    final boolean canceled = resetCancelNextUpFlag(this) || actionMasked == MotionEvent.ACTION_CANCEL;
    // Update list of touch targets for pointer down, if needed.
    TouchTarget newTouchTarget = null;
    boolean alreadyDispatchedToNewTouchTarget = false;
    if (actionMasked == MotionEvent.ACTION_DOWN && !canceled && !intercepted) {
    // 这里既然指定了 ACTION_DOWN,那么 mFirstTouchTarget 确定是空的(以前进行过清除)
    // 不拦截 ACTION_DOWN 的话,那么事件须要分发给子 view,若是子view 消费掉 ACTION_DOWN,那么该子view 将会被用来构建 mFirstTouchTarget
        final int actionIndex = ev.getActionIndex(); // always 0 for down
        final int childrenCount = mChildrenCount;
        if (childrenCount != 0) {
            final float x = ev.getX(actionIndex);
            final float y = ev.getY(actionIndex);
            final View[] children = mChildren;
            // 倒序遍历子 view(后添加的 view 位置在上面)
            for (int i = childrenCount - 1; i >= 0; i--) {
                final View child = getAndVerifyPreorderedView(preorderedList, children, childIndex);
                // 不可见的|| 触摸点不在子view 范围内 的,直接过滤掉
                if (!canViewReceivePointerEvents(child)/*分析 3*/ || !isTransformedTouchPointInView(x, y, child, null)/*分析 4*/) {
                    continue;
                }
                // 将该事件分发给子view
                if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign) /*分析 6*/) {
                    // 子view 将该事件消费掉,跳出循环,再也不分发,给mFirstTouchTarget 赋值
                    newTouchTarget = addTouchTarget(child, idBitsToAssign);// 分析 5
                    alreadyDispatchedToNewTouchTarget = true;
                    break;
                }
            }
        }
    }
    
    // 没有子 view 要这个事件,这里多是 ACTION_DOWN 事件分发给子 view 不要,或者 ACTION_MOVE 事件被拦截,给那个子view 发送过 CANCEL 事件,将 mFirstTouchTarget 复制为 null 了
    if (mFirstTouchTarget == null) {
        // 分发给本身(这里传入的 child 为 null) 分析 6
        handled = dispatchTransformedTouchEvent(ev, canceled, null, TouchTarget.ALL_POINTER_IDS);
    } else {
        TouchTarget target = mFirstTouchTarget;
        // 已经分发了,返回结果为 true,这里对应于 ACTION_DOWN 事件
        if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
            handled = true;
        } else {
            final boolean cancelChild = resetCancelNextUpFlag(target.child) || intercepted;
            // 发送事件给 子view,若是被拦截,向子view 发送 CANCEL 事件(这里传入的 cancel 参数为 true)
      handled = dispatchTransformedTouchEvent(ev, cancelChild, target.child, target.pointerIdBits);
            if (cancelChild) {
                // 若是是向子view 发送 CANCEL 事件,这个事件序列之后不须要发送给子view 了
                mFirstTouchTarget = null;
            }
        }
    }
    return handled;
}

// ->分析1  ViewGroup#cancelAndClearTouchTargets()
private void cancelAndClearTouchTargets(MotionEvent event) {
    // 以前 mFirstTouchTarget 链表不为空
    if (mFirstTouchTarget != null) {
        // 给 mFirstTouchTarget 链表中的 view 发送 CANCEL事件
        for (TouchTarget target = mFirstTouchTarget; target != null; target = target.next) {
            resetCancelNextUpFlag(target.child);
            dispatchTransformedTouchEvent(event, true, target.child, target.pointerIdBits);
        }
        // 清空 mFirstTouchTarget 链表
        clearTouchTargets();
    }
}

// ->分析2  ViewGroup#resetTouchState()
private void resetTouchState() {
    clearTouchTargets();
    resetCancelNextUpFlag(this);
    // 清除 disallowIntercept 标志,这个标志能够经过viewGroup#requestDisallowInterceptTouchEvent(boolean)来进行设置
    mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
    mNestedScrollAxes = SCROLL_AXIS_NONE;
}

// ->分析 3  子view 是可见的或者正在执行动画
private static boolean canViewReceivePointerEvents(@NonNull View child) {
    return (child.mViewFlags & VISIBILITY_MASK) == VISIBLE
            || child.getAnimation() != null;
}

// ->分析 4 触摸点是否子view 范围内
protected boolean isTransformedTouchPointInView(float x, float y, View child,
                                                PointF outLocalPoint) {
    final float[] point = getTempPoint();
    point[0] = x;
    point[1] = y;
    transformPointToViewLocal(point, child);
    final boolean isInView = child.pointInView(point[0], point[1]);
    if (isInView && outLocalPoint != null) {
        outLocalPoint.set(point[0], point[1]);
    }
    return isInView;
}

// -> 分析 5  构建 mFirstTouchTarget 链表
private TouchTarget addTouchTarget(@NonNull View child, int pointerIdBits) {
    final TouchTarget target = TouchTarget.obtain(child, pointerIdBits);
    target.next = mFirstTouchTarget;
    mFirstTouchTarget = target;
    return target;
}

// ->分析 6,重要,事假分发的核心
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) {
        // 分发 ACTION_CANCEL
        event.setAction(MotionEvent.ACTION_CANCEL);
        if (child == null) {
      // 把 ViewGroup 当作一个普通的 View,本身处理
            handled = super.dispatchTouchEvent(event);
        } else {
            handled = child.dispatchTouchEvent(event);
        }
        // 事件类型还的还原回去
        event.setAction(oldAction);
        return handled;
    }
    if (child == null) {
        // 把 ViewGroup 当作一个普通的 View,本身处理
        handled = super.dispatchTouchEvent(event);
    } else {
        // 给子view 处理
        final float offsetX = mScrollX - child.mLeft;
        final float offsetY = mScrollY - child.mTop;
        // 把触摸点的X,Y坐标改成在子view中的 X,Y 坐标
        event.offsetLocation(offsetX, offsetY);
        // 交给子view 处理
        handled = child.dispatchTouchEvent(event);
        // 把触摸点的 X,Y坐标改回来
        event.offsetLocation(-offsetX, -offsetY);
    }
    return handled;
}

上述的分析很是复杂,须要花不少时间才能彻底看懂,这里直接提供一些结论,在上面的额代码和注释中都能找到相应的依据:

一个 View 若是不消耗 ACTION_DOWN 事件,那么同一个事件序列的其余事件都不会交给他来处理;从上面源码能够看出,ACTION_DOWN 事件时,只有返回 true 时,才会使用该子view 构造 mFirstTouchTarget;
若是非 ACTION_DOWN 事件被拦截,且该事件序列以前被子view 处理过,那么向该子 view 发送 CANCEL 事件,且会重置mFirstTouchTarget;
一个 View 一旦决定拦截,那么这个事件序列都由他来处理(若是事件序列能传递到的话,dispatchTransformedTouchEvent传入的 child 参数为 null),而且其 onInterceptTouchEvent 方法不会再被调用(mFirstTouchTarget != null 不成立).
使用 ViewGroup 的 requestDisallowInterceptTouchEvent 方法能够请求父view 不拦截事件,可是 MOTION_DOWN 事件除外(MOTION_DOWN时会清除FLAG_DISALLOW_INTERCEPT)
若是View 树事件分发返回了 false,最终Acitivity的onTouchEvent 方法会被调用;

从上面能够看出,view 的事件分发最终都会调用View 的 dispatchTouchEvent 方法:

View的事件分发

// View#dispatchTouchEvent()
public boolean dispatchTouchEvent(MotionEvent event) {
    boolean result = false;
    ListenerInfo li = mListenerInfo;
    if (li != null && li.mOnTouchListener != null// 设置了mOnTouchListener(经过 setOnTouchListener())
            && (mViewFlags & ENABLED_MASK) == ENABLED// 处于 enalbed 状态
            && li.mOnTouchListener.onTouch(this, event)) {// 优先触发mOnTouchListener.onTouch
        result = true;
    }
    // mOnTouchListener.onTouch返回 false,调用自身的 onTouchEvent
    if (!result && onTouchEvent(event)) {
        result = true;
    }
    return result;
}

// 这里忽略了 longClick,tap等状况
public boolean onTouchEvent(MotionEvent event) {
    final float x = event.getX();
    final float y = event.getY();
    final int viewFlags = mViewFlags;
    final int action = event.getAction();
    final boolean clickable = ((viewFlags & CLICKABLE) == CLICKABLE  // CLICKABLE
            || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE) // LONG_CLICKABLE
            || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE;
    // view 的 enabled 状态为 DISABLED
    if ((viewFlags & ENABLED_MASK) == DISABLED) {
        // disabled 状态的 view,仍然会消费事件,只是不会响应而已
        return clickable;
    }
    if (!clickable) {
        return false;
    }
    switch (action) {
        case MotionEvent.ACTION_UP:
            mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
            boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
            if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {
                boolean focusTaken = false;
                if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {
                    // 拿到焦点,若是这里返回 true,那么后面不会调用 onClick 方法,可是咱们如今已经有了焦点了
                    focusTaken = requestFocus();
                }
                // Only perform take click actions if we were in the pressed state
                if (!focusTaken) {
                    if (mPerformClick == null) {
                        mPerformClick = new PerformClick();
                    }
                    if (!post(mPerformClick)) {
                        // 点击事件触发
                        performClick();
                    }
                }
            }
            break;
    }
    // 只要cliclable,就返回 true
    return true;
}

public boolean performClick() {
    final ListenerInfo li = mListenerInfo;
  final boolean result = li != null && li.mOnClickListener != null;
    if (result) {
        li.mOnClickListener.onClick(this);// 触发 onClick 方法
    } 
    return result;
}

根据上述代码,有如下结论:

View 的 dispatchTouchEvent 优先触发mOnTouchListener.onTouch 方法(在enabled 时),在其返回 false 时,触发onTouchEvent 方法;
onTouchEent 默认返回可点击状态值, clickable || longClickable,view的 enabled 状态与返回值无关,只是 disabled 状况下,不会响应(mOnTouchListener.onTouch也不会调用);

事件分发机制大概源码分析就是这样,其实简化一些,也不是很复杂,就是一些细节容易遗忘,并且目前也没有比较好的方式可以讲好这个源码(网络上的那些图形,其实都忽略了一些细节,有些细节甚至很重要),若是开发过程当中有什么不清楚的再来查看一下吧,比直接从新分析官方源码和看别人博客方便些;