关于Android事件派发流程的理解

以前看了很多人介绍的Android事件派发流程,但最近使用那些来写代码的时候出现了不少错误。所以回顾一下整个流程,简单介绍从手触摸屏幕开始到事件在View树派发。从源码上分析ViewGroup.dispatchTouchEvent。

事件从触摸到View简述

Android的事件产生是从我们触摸屏幕开始,在经过Input子系统,最后达到我们的应用程序(或者经过WindowManagerService到达应用程序)。

而其中Input子系统在Java层对应着InputManagerService,其主要在native层,由InputReader读取EventHub的元数据,将这些数据加工成InputEvent,最后发到InputDispatcher,而InputDispatcher则负责将时间发到应用程序,Input子系统流程可以参见这篇文章Android Framework——之Input子系统

对于应用层的时间流程,主要是下面的流程图所示:

其中最后一步就是我们经常说的View事件派发流程。另外上面DecorView是经过了两次,第一次是调用DecorView的dispatchTouchEvent,它的源码是:

    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        final Callback cb = getCallback();
        return cb != null && !isDestroyed() && mFeatureId < 0 ? cb.dispatchTouchEvent(ev)
                : super.dispatchTouchEvent(ev);
    }

Callback就是Window.Callback,Activity实现了这个接口。在Activity的attach函数中,会调用window的setCallback,将Activity设置给Window。所以这里getCallback返回的就是Activity,最终会调用Activity的dispatchTouchEvent。下面看一下Activity的dispatchTouchEvent函数:

    public boolean dispatchTouchEvent(MotionEvent ev) {
        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
            onUserInteraction();
        }
        if (getWindow().superDispatchTouchEvent(ev)) {
            return true;
        }
        return onTouchEvent(ev);
    }

在ACTION_DOWN的时候会调用onUserInteraction方法,然后调用Window(实际上是PhoneWindow)的superDispatchTouchEvent,如果Window的superDispatchTouchEvent消耗了事件,则直接返回,不会调用Activity的onTouchEvent方法。

@Override
public boolean superDispatchTouchEvent(MotionEvent event) {
    return mDecor.superDispatchTouchEvent(event);
}

而DecorView的superDispatchTouchEvent为:

public boolean superDispatchTouchEvent(MotionEvent event) {
    return super.dispatchTouchEvent(event);
}

最终还是调用DecorView的父类的dispatchTouchEvent,DecorView的父类是FrameLayout,它没实现该方法,最终会调用ViewGroup的dispatchTouchEvent方法。从这里开始就进入了view树的时间派发流程了。

View树的事件派发流程

这里从源码上分析事件派发的一些特性。事件派发最开始会进入到ViewGroup的dispatchTouchEvent(DecorVIew父类),下面是ViewGroup的dispatchTouchEvent伪代码的分析,直接在对应的代码部分加了注释:

“`

@Override

public boolean dispatchTouchEvent(MotionEvent ev) {

//一开始做一些调试验证,另外如果事件的目标是focused view,并且当前view就是一个focused view,

//有可能view的子View就会处理这次事件,所以将targetAccessibilityFocus设置为false。

    boolean handled = false;
    if (onFilterTouchEventForSecurity(ev)) { //检查event是否是安全的
        final int action = ev.getAction();
        final int actionMasked = action & MotionEvent.ACTION_MASK;

        // Handle an initial down.
        if (actionMasked == MotionEvent.ACTION_DOWN) {
            // Throw away all previous state when starting a new touch gesture.
            // The framework may have dropped the up or cancel event for the previous gesture
            // due to an app switch, ANR, or some other state change.
            //清除之前的事件状态。比如说在app切换,ANR或其他状态改变时,系统框架将会去掉up或cancel事件。在这里会将mFirstTouchTarget清空,mFirstTouchTarget是保存了会接受事件的View处理对象。
            cancelAndClearTouchTargets(ev);
            resetTouchState(); //这里会将mGroupFlags的FLAG_DISALLOW_INTERCEPT标识清除,
            //1. 每次事件流开始的时候都会先清除FLAG_DISALLOW_INTERCEPT,所以子view的requestDisallowInterceptTouchEvent只有当次事件流有效。
        }

        // 判断是否需要拦截事件,去判断是否拦截事件的条件是此次事件是DOWN事件,或者有子类会处理这次事件(mFirstTouchTarget不为null),并且FLAG_DISALLOW_INTERCEPT没被设置。
        final boolean intercepted;
        if (actionMasked == MotionEvent.ACTION_DOWN
                || mFirstTouchTarget != null) {
            final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
            if (!disallowIntercept) {
                //2. 只有有TouchTarget并且没有被disallow,或者是ACTION_DOWN时才会调用onInterceptTouchEvent。
                intercepted = onInterceptTouchEvent(ev);
                ev.setAction(action); // restore action in case it was changed
            } else {
                intercepted = false;
            }
        } else {
            // There are no touch targets and this action is not an initial down
            // so this view group continues to intercept touches.
            intercepted = true;
        }

        // If intercepted, start normal event dispatch. Also if there is already
        // a view that is handling the gesture, do normal event dispatch.
        if (intercepted || mFirstTouchTarget != null) {
            ev.setTargetAccessibilityFocus(false);
        }

        // Check for cancelation.判断是否取消
        final boolean canceled = resetCancelNextUpFlag(this)
                || actionMasked == MotionEvent.ACTION_CANCEL;

        // Update list of touch targets for pointer down, if needed.
        final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0;
        TouchTarget newTouchTarget = null;
        boolean alreadyDispatchedToNewTouchTarget = false;
        if (!canceled && !intercepted) {

            // If the event is targeting accessiiblity focus we give it to the
            // view that has accessibility focus and if it does not handle it
            // we clear the flag and dispatch the event to all children as usual.
            // We are looking up the accessibility focused host to avoid keeping
            // state since these events are very rare.
            View childWithAccessibilityFocus = ev.isTargetAccessibilityFocus()
                    ? findChildWithAccessibilityFocus() : null;

            if (actionMasked == MotionEvent.ACTION_DOWN
                    || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
                    || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
                final int actionIndex = ev.getActionIndex(); // always 0 for down
                final int idBitsToAssign = split ? 1 << ev.getPointerId(actionIndex)
                        : TouchTarget.ALL_POINTER_IDS;

                // Clean up earlier touch targets for this pointer id in case they
                // have become out of sync.
                removePointersFromTouchTargets(idBitsToAssign);

                final int childrenCount = mChildrenCount;
                if (newTouchTarget == null && childrenCount != 0) {
                    final float x = ev.getX(actionIndex);
                    final float y = ev.getY(actionIndex);
                    // Find a child that can receive the event.
                    // Scan children from front to back.
                    final ArrayList<View> preorderedList = buildOrderedChildList();
                    final boolean customOrder = preorderedList == null
                            && isChildrenDrawingOrderEnabled();
                    final View[] children = mChildren;
                    for (int i = childrenCount - 1; i >= 0; i--) {
                        final int childIndex = customOrder
                                ? getChildDrawingOrder(childrenCount, i) : i;
                        final View child = (preorderedList == null)
                                ? children[childIndex] : preorderedList.get(childIndex);

                        // If there is a view that has accessibility focus we want it
                        // to get the event first and if not handled we will perform a
                        // normal dispatch. We may do a double iteration but this is
                        // safer given the timeframe.
                        if (childWithAccessibilityFocus != null) {
                            if (childWithAccessibilityFocus != child) {
                                continue;
                            }
                            childWithAccessibilityFocus = null;
                            i = childrenCount - 1;
                        }
                        //判断当前的child是否可以接收事件,并且事件是否在当前的view范围
                        if (!canViewReceivePointerEvents(child)
                                || !isTransformedTouchPointInView(x, y, child, null)) {
                            ev.setTargetAccessibilityFocus(false);
                            continue;
                        }

                        newTouchTarget = getTouchTarget(child);
                        if (newTouchTarget != null) {
                            // Child is already receiving touch within its bounds.
                            // Give it the new pointer in addition to the ones it is handling.
                            newTouchTarget.pointerIdBits |= idBitsToAssign;
                            break;
                        }

                        resetCancelNextUpFlag(child);
                                    //3.dispatchTransformedTouchEvent会将Event转化为child坐标空间(getX的变化),然后去除无关的points id,如果有必要更改事件,最后调用child.dispatchTouchEvent。 dispatchTransformedTouchEvent把事件派发给child,如果child成功处理了,则会将child添加到mFirstTouchTarget
                        if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
                            // Child wants to receive touch within its bounds.
                            mLastTouchDownTime = ev.getDownTime();
                            if (preorderedList != null) {
                                // childIndex points into presorted list, find original index
                                for (int j = 0; j < childrenCount; j++) {
                                    if (children[childIndex] == mChildren[j]) {
                                        mLastTouchDownIndex = j;
                                        break;
                                    }
                                }
                            } else {
                                mLastTouchDownIndex = childIndex;
                            }
                            mLastTouchDownX = ev.getX();
                            mLastTouchDownY = ev.getY();
                            //addTouchTarget会创建新的TouchTarget,并将其加入到mFirstTouchTarget
                            newTouchTarget = addTouchTarget(child, idBitsToAssign);
                            alreadyDispatchedToNewTouchTarget = true;
                            break;
                        }

                        // The accessibility focus didn‘t handle the event, so clear
                        // the flag and do a normal dispatch to all children.
                        ev.setTargetAccessibilityFocus(false);
                    }
                    if (preorderedList != null) preorderedList.clear();
                }

                if (newTouchTarget == null && mFirstTouchTarget != null) {
                    // Did not find a child to receive the event.
                    // Assign the pointer to the least recently added target.
                    newTouchTarget = mFirstTouchTarget;
                    while (newTouchTarget.next != null) {
                        newTouchTarget = newTouchTarget.next;
                    }
                    newTouchTarget.pointerIdBits |= idBitsToAssign;
                }
            }
        }

        //4. 派发事件
        // Dispatch to touch targets.
        if (mFirstTouchTarget == null) { //mFirstTouchTarget为空表示没有子View会处理这次事件,则交给当前的ViewGroup处理。
            // No touch targets so treat this as an ordinary view.
            handled = dispatchTransformedTouchEvent(ev, canceled, null,
                    TouchTarget.ALL_POINTER_IDS);
        } else {
            // Dispatch to touch targets, excluding the new touch target if we already
            // dispatched to it.  Cancel touch targets if necessary.
            TouchTarget predecessor = null;
            TouchTarget target = mFirstTouchTarget; 
            while (target != null) {//遍历mFirstTouchTarget链表,一个一个地处理TouchTarget。
                final TouchTarget next = target.next;
                if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {//新添加的不会立刻处理,ACTION_DOWN已经在前面派发了
                    handled = true;
                } else {
                    final boolean cancelChild = resetCancelNextUpFlag(target.child)
                            || intercepted;
                    //dispatchTransformedTouchEvent会将Event转化为child坐标空间(getX的变化),然后去除无关的points id,如果有必要更改事件,最后调用child.dispatchTouchEvent
                    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.
        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);
        }
    }

    ...
    //用于测试的代码

    return handled;
}
```

事件派发流程主要集中在这几个方法的调用:
- dispatchTouchEvent 这是事件派发每个View的时候,第一个被调用的方法,如果是ViewGroup,dispatchTouchEvent会先去调用onInterceptTouchEvent是否应该拦截事件,不拦截的话会先从子View中判断是否有处理该次事件的(在ACTION_DOWN中采用mFirstTouchTarget链接保存会处理事件的TouchTarget),如果没有的话则调用当前View的onTouchEvent。
- onInterceptTouchEvent 判断是否应该拦截事件,ViewGroup默认实现是返回false,子View可以调用getParent.requestDisallowInterceptTouchEvent()来阻止父View拦截。否则只要有子View可能消费事件,该方法都会被调用。
- onTouchEvent这个方法是在没有子View将会消耗事件时才会被调用,onClickListener,onTouchListener,onLongClickListener都是在这个方法中处理的。如果返回true表示消费这次事件。

对于事件派发流程,我觉得有几个地方需要注意的:
1. 应该把ViewGroup以及它所包含的子View都看作是这个ViewGroup的一部分,对于一个ViewGroup是否会处理一次事件,应该是包含了它的子View是否也处理。
2. 如果整个ViewGroup以及它的子类没有一个View处理ACTION_DOWN事件,那么下一次就不会调用这个ViewGroup的dispatchTouchEvent。***但是如果ACTION_DOWN返回了true,那么下一次事件还是会继续派发到ViewGroup,即使中间某个ACTION_MOVE返回了false***。
3. onInterceptTouchEvent是在子View可能会处理该次事件,并且没有被设置FLAG_DISALLOW_INTERCEPT才会被调用。正常情况下,它在ACTION_DOWN的时候一定会被调用的,因为在ACTION_DOWN的时候会先调用resetTouchState()。

这个是最近略微改了一下很久之前写的一个模仿QQ邮箱滑动退出写的一个东西:https://github.com/xxxzhi/SlideListener,改的过程发现之前看的东西理解地不够好…

源码是解释很多现象的最根本的原因,阅读源码能够更好地理解事件派发流程,理解地更加深刻。

时间: 2024-11-06 07:08:24

关于Android事件派发流程的理解的相关文章

android事件分发流程

1.描述 说到android事件的分发机制,真的是感觉既熟悉又陌生,因为每次需要用到的时候查看相关的源码,总能找到一些所以然来,但是要根据自己理解从头到尾说一遍,却一点都说不上.总结原因吧,感觉是自己不善于总结,过目就忘,并没有把心思放在上面,自然也就没有一点概念咯~~所以在这里主要是把自己理解的一些东西记录下来,不涉及源代码. 好吧,接下来简单说说android事件分发流程吧,说到事件分发,首先应该想到的是两个类,View和ViewGroup,ViewGroup是继承自View实现的,View

Touch事件派发流程分析

分native侧事件派发到java侧和Framework派发事件到UI,流程看源码即可,此处不赘叙, Native侧上报事件的干活类图如下: Framework侧派发事件给UI的类图如下:

Android touch事件的派发流程

http://blog.csdn.net/xyz_lmn/article/details/12517911 通过流程图了解touch事件派发过程. http://blog.csdn.net/stonecao/article/details/6759189 从代码的层面分析,尽管目前代码已经变化了,但是作者的分析对Android touch事件派发流程的理解还是很有帮助的. http://www.2cto.com/kf/201504/388625.html 通过实例了解Button的touch事件

Android View触摸屏事件派发机制详解与源码分析

PS一句:最终还是选择CSDN来整理发表这几年的知识点,该文章平行迁移到CSDN.因为CSDN也支持MarkDown语法了,牛逼啊! [工匠若水 http://blog.csdn.net/yanbober] 1.背景 最近在简书和微博还有Q群看见很多人说Android自定义控件(View/ViewGroup)如何学习?为啥那么难?其实答案很简单:"基础不牢,地动山摇." 不扯蛋了,进入正题.就算你不自定义控件,你也必须要了解Android控件的触摸屏事件传递机制(之所以说触摸屏是因为该

Android触摸屏事件派发机制详解与源码分析二(ViewGroup篇)

1 背景 还记得前一篇<Android触摸屏事件派发机制详解与源码分析一(View篇)>中关于透过源码继续进阶实例验证模块中存在的点击Button却触发了LinearLayout的事件疑惑吗?当时说了,在那一篇咱们只讨论View的触摸事件派发机制,这个疑惑留在了这一篇解释,也就是ViewGroup的事件派发机制. PS:阅读本篇前建议先查看前一篇<Android触摸屏事件派发机制详解与源码分析一(View篇)>,这一篇承接上一篇. 关于View与ViewGroup的区别在前一篇的A

Android ViewGroup触摸屏事件派发机制详解与源码分析

PS一句:最终还是选择CSDN来整理发表这几年的知识点,该文章平行迁移到CSDN.因为CSDN也支持MarkDown语法了,牛逼啊! [工匠若水 http://blog.csdn.net/yanbober] 该篇承接上一篇<Android View触摸屏事件派发机制详解与源码分析>,阅读本篇之前建议先阅读. 1 背景 还记得前一篇<Android View触摸屏事件派发机制详解与源码分析>中关于透过源码继续进阶实例验证模块中存在的点击Button却触发了LinearLayout的事

【朝花夕拾】Android自定义View篇之(五)Android事件分发及传递机制

前言 在自定义View中,经常需要处理Android事件分发的问题,尤其在有多个输入设备(如遥控.鼠标.游戏手柄等)时,事件处理问题尤为突出.Android事件分发机制,一直以来都是一个让众多开发者困扰的难点,至少笔者在工作的前几年中,没有特意研究它之前,就经常云里雾里.实际上,该问题的“七寸”就是dispatchTouchEvent(MotionEvent ev).onInterceptTouchEvent(MotionEvent ev).onTouchEvent(MotionEvent ev

Android事件分发机制详解:史上最全面、最易懂

前言 Android事件分发机制是每个Android开发者必须了解的基础知识 网上有大量关于Android事件分发机制的文章,但存在一些问题:内容不全.思路不清晰.无源码分析.简单问题复杂化等等 今天,我将全面总结Android的事件分发机制,我能保证这是市面上的最全面.最清晰.最易懂的 本文秉着"结论先行.详细分析在后"的原则,即先让大家感性认识,再通过理性分析从而理解问题: 所以,请各位读者先记住结论,再往下继续看分析: 文章较长,阅读需要较长时间,建议收藏等充足时间再进行阅读 目

Android 事件传递与焦点处理(tv)

1.概述 上节介绍了android tv app 与android mobile app 的一些表现形式的不同.在实际编程中需要很多的焦点处理,而焦点处理有经常是在事件传递函数内处理的.所以本节做个android 事件传递与焦点处理的小结.另既然描述到android事件传递不可避免就涉及到了android手势拦截.这也是对原有知识认识的一个补充,因为之前涉及到安卓事件传递就是为了做手势拦截,以至于当看到代码在手势分发函数里处理tv的焦点,与界面移动填充时.一时有点迷糊,为什么是写在dispath