Android基础知识View篇：View的事件分发机制源码解析

最新推荐文章于 2024-04-19 16:58:31 发布

AI老猴子

最新推荐文章于 2024-04-19 16:58:31 发布

阅读量290

点赞数 1

文章标签： android java 开发语言

本文链接：https://blog.csdn.net/star_nwe/article/details/130622837

版权

文章详细介绍了Android中MotionEvent的类型，如ACTION_DOWN,ACTION_MOVE,ACTION_UP，以及事件分发过程中的三个关键方法：dispatchTouchEvent,onInterceptTouchEvent,onTouchEvent。还深入探讨了Activity、Window、DecorView和ViewGroup在事件分发中的角色和处理方式，以及View对事件的处理流程，包括OnTouchListener和OnTouchEvent的优先级。最后提到了成为架构师所需的能力和学习方向。

摘要由CSDN通过智能技术生成

1.介绍

1.MotionEvent

当我们点击屏幕时，就产生了点击事件，这个点击事件被封装成了一个类：MotionEvent。当手机接触屏幕后会产生一系列的事件，其中典型的事件类型有如下几种：

ACTION_DOWN：手指刚接触屏幕；
ACTION_MOVE：手指在屏幕上移动；
ACTION_UP：手指从屏幕上松开的一瞬间。

2.事件分发的3个重要方法

当一个MotionEvent产生后，系统需要把这个事件传递给一个具体的View，这个传递过程就是事件分发过程。事件的分发的过程由3个重要的方法来共同完成：

public boolean dispatchTouchEvent(MotionEvent ev)
用来进行事件的分发。如果事件能够传递给当前View，那么此方法一定会被调用，返回结果受当前View的TouchEvent和下级View的dispatchTouchEvent方法影响，表示是否消耗当前事件。
public boolean onInterceptTouchEvent(MotionEvent ev)
在dispatchTouchEvent方法中调用，用来判断是否拦截某个事件。如果当前View拦截了某个事件，那么在同一个事件序列当中，此方法不会被再次调用，返回结果表示是否拦截当前事件。需要注意的是View没有提供该方法。
public boolean onTouchEvent(MotionEvent event)
在dispatchTouchEvent方法中调用，用来处理点击事件。返回结果表示是否消耗当前事件，如果不消耗，则在同一个事件序列中，当前View无法再次接收到事件。

2.Activity对事件的分发

当一个事件产生时，事件会最先传递给当前Activity，即Activity的dispatchTouchEvent方法会被调用。在Activity的dispatchTouchEvent方法中会将事件交给PhoneWindow处理，PhoneWindow又会将事件传递给DecorView，即事件传递顺序为：Activity->Window->DecorView。我们先来看下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);
}

上面Activity的dispatchTouchEvent方法中，先调用了window的superDispatchTouchEvent方法，交给window来处理。如果window的superDispatchTouchEvent返回true，表示事件被处理，整个事件循环就结束了；如果返回false，表示事件没有被处理，那么Activity的onTouchEvent方法会被调用，事件由Activity来处理。

接下来看Window的superDispatchTouchEvent方法。通过源码可以发现Window是个抽象类，它的superDispatchTouchEvent方法也是个抽象方法。所以我们需要看Window的唯一实现类PhoneWindow的处理，源码如下：

//PhoneWindow的superDispatchTouchEvent
public boolean superDispatchTouchEvent(MotionEvent event){
    return mDecor.superDispatchTouchEvent(event);
}

在PhoneWindow的superDispatchTouchEvent方法中，我们可以知道事件传递给了DecorView。再看下DecorView的superDispatchTouchEvent方法，源码如下：

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

DecorView继承自FrameLayout，它的super.dispatchTouchEvent方法调用的就是ViewGroup的dispatchTouchEvent方法。并且Activity中通过setContentView所设置的根View，是getWindow.getDecorView().findViewById(Android.R.id.content).getChildAt(0)返回的View，那么可以确定根View是DecorView的一个子元素。所以事件传递到DecorView之后，其实就是ViewGroup的事件分发过程。

3.ViewGrou对事件的分发

ViewGroup对事件的分发过程，主要实现是在它的dispatchTouchEvent方法中。这个方法大概逻辑是先判断是否拦截事件，如果不拦截事件，则将事件交给子元素处理，如果拦截了事件或者子元素没有处理事件则由自己处理事件。

1.判断是否拦截

先来看下如何判断是否拦截事件的，源码如下：

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    //...省略无关代码
    
    final boolean intercepted;
    //1. 判断是否有子元素处理了该事件
    if (actionMasked == MotionEvent.ACTION_DOWN
            || mFirstTouchTarget != null) {
        final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
        //2. 判断子元素是否设置了禁止拦截的标记位
        if (!disallowIntercept) {
            //3. 调用自己的onInterceptTouchEvent方法，询问自己是否要拦截事件
            intercepted = onInterceptTouchEvent(ev);
            ev.setAction(action); // restore action in case it was changed
        } else {
            intercepted = false;
        }
    } else {
        intercepted = true;
    }  
    //...省略无关代码
}

上面源码可以看到，有两个判断，如果都为true，则会调用自己的onInterceptTouchEvent方法，来询问自己是否拦截事件。那么什么情况下不调用自己的onInterceptTouchEvent方法呢？

首先第一个判断mFirstTouchTarget != null，从后面的逻辑可以看出来，当事件由子元素成功处理时，mFirstTouchTarget会被赋值并指向子元素。

那么 (actionMasked == MotionEvent.ACTION_DOWN || mFirstTouchTarget != null) 这个判断的主要目的就是，当没有子元素去处理事件时，则该事件序列中的其它事件（move、up等事件）到来时，ViewGroup会默认拦截事件，并且不再调用onInterceptTouchEvent方法。

第二个判断boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0，这里的FLAG_DISALLOW_INTERCEPT标记位是通过requestDisallowInterceptTouchEvent方法设置的，一般用于子View中。一旦FLAG_DISALLOW_INTERCEPT设置后，ViewGroup将无法拦截除了down事件以外的其它事件。为什么说是down以外的其它事件呢？这是因为，ViewGroup在分发事件时，如果是down事件机会重置这个标记位。源码如下：

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    //...省略无关代码
    
    // 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.
    if (actionMasked == MotionEvent.ACTION_DOWN) {
        cancelAndClearTouchTargets(ev);
        resetTouchState();
    }
}

3.具体分发过程

如果ViewGroup不拦截事件，会将事件交由它的子元素处理，这段源码如下：

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    //...省略无关代码
    //如果不拦截事件，遍历所有子元素，判断子元素是否能够接收事件
    if (!canceled && !intercepted) {

        final View[] children = mChildren;
        for (int i = childrenCount - 1; i >= 0; i--) {//1. 倒序遍历子元素
            final int childIndex = getAndVerifyPreorderedIndex(
                    childrenCount, i, customOrder);
            final View child = getAndVerifyPreorderedView(
                    preorderedList, children, 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;
            }

            //2. 判断子元素是否可以接收点击事件
            if (!child.canReceivePointerEvents()
                    || !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. 事件分发
            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();
                newTouchTarget = addTouchTarget(child, idBitsToAssign);
                alreadyDispatchedToNewTouchTarget = true;
                break;
            }
        }
    }
}

从上面源码可以看到，首先ViewGroup会遍历所有子元素，然后判断子元素是否能够接收点击事件。是否能够接收点击事件主要由两点来衡量：子元素是否在播放动画和点击事件的坐标是否落在子元素的区域内。如果某个子元素满足这两个条件，就会调用dispatchTransformedTouchEvent方法将事件交给这个子元素处理。

接下来我们看下View的dispatchTransformedTouchEvent方法，在该方法内部有如下一段内容：

private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
        View child, int desiredPointerIdBits) {
    final boolean handled;
    
    //...省略无关代码
    if (child == null) {
        handled = super.dispatchTouchEvent(event);
    } else {
        //省略无关代码
        handled = child.dispatchTouchEvent(event);
    }
    
    return handled;
}

因为在向子元素分发事件时，child不为null，所以它会直接调用child的dispatchTouchEvent方法，将事件交给子元素处理。并且可以看到dispatchTransformedTouchEvent的返回值就是child.dispatchTouchEvent(event)的返回值。

再回到ViewGroup的dispatchTouchEvent方法中，可以看如果dispatchTransformedTouchEvent返回true，那么mFirstTouchTarget就会被赋值，同时break（跳出循环）。当然，如果返回false，ViewGroup会继续向下一个子元素分发。如下所示：

//事件分发
if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
    //...省略无关代码
    newTouchTarget = addTouchTarget(child, idBitsToAssign);
    alreadyDispatchedToNewTouchTarget = true;
    break;
}

mFirstTouchTarget的赋值是在过程是在addTouchTarget方法内部完成的，addTouchTarget方法内部可以看出，mFirstTouchTarget是一种单链表结构。前面提到过mFirstTouchTarget，mFirstTouchTarget是否赋值，将影响VIewGroup对事件的拦截策略。如果mFirstTouchTarget为null，那么ViewGroup就会默认拦截同一序列中down事件以外的其它所有事件。mFirstTouchTarget赋值源码如下：

private TouchTarget addTouchTarget(@NonNull View child, int pointerIdBits) {
    final TouchTarget target = TouchTarget.obtain(child, pointerIdBits);
    target.next = mFirstTouchTarget;
    mFirstTouchTarget = target;
    return target;
}

3.ViewGroup自己处理事件

如果ViewGroup拦截了事件或者它的所有子元素都没有处理事件，mFirstTouchTarget为null，那么ViewGroup会自己处理事件，这段代码如下：


@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    //...省略无关代码
    
    if (mFirstTouchTarget == null) {
    // No touch targets so treat this as an ordinary view.
        handled = dispatchTransformedTouchEvent(ev, canceled, null,
                TouchTarget.ALL_POINTER_IDS);
    }
    //...省略无关代码
}

在这里的dispatchTransformedTouchEvent方法第三个参数child为null。前面有介绍这个方法，如果child为null，会调用super.dispatchTouchEvent方法，而ViewGroup的父类是View，所以实际调用的是View的dispatchTouchEvent方法。那么可以知道，无论事件是分发给子View还是ViewGroup自己处理，都会转到View的dispatchTouchEvent方法，接下来继续分析View的dispatchTouchEvent方法。

4.View对事件的处理

1.View的dispatchTouchEvent方法

因为View（这里不包含ViewGroup）是一个单独的元素，它没有子元素无法向下传递事件，因此它只能自己处理事件。源码如下：

public boolean dispatchTouchEvent(MotionEvent event) {
    boolean result = false;
    //...省略无关代码
    if (onFilterTouchEventForSecurity(event)) {
        if ((mViewFlags & ENABLED_MASK) == ENABLED && handleScrollBarDragging(event)) {
            result = true;
        }
        //noinspection SimplifiableIfStatement
        ListenerInfo li = mListenerInfo;
        if (li != null && li.mOnTouchListener != null
                && (mViewFlags & ENABLED_MASK) == ENABLED
                && li.mOnTouchListener.onTouch(this, event)) {
            result = true;
        }
    
        if (!result && onTouchEvent(event)) {
            result = true;
        }
    }
    
    //...省略无关代码
    return result;
}

从上面的源码可以看出View对点击事件的处理过程，首先会判断有没有设置OnTouchListener。如果OnTouchListener中的onTouch方法返回true，那么onTouchEvent就不会被调用，可见OnTouchListener的优先级高于OnTouchEvent，这样做的好处是方便在外界处理点击事件。

2.View的OnTouchEvent方法

下面看下OnTouchEvent的实现，首先当View处于不可用状态下照样会消耗点击事件，尽管它看起来不可用。这段源码如下：

    final int action = event.getAction();
    
    final boolean clickable = ((viewFlags & CLICKABLE) == CLICKABLE
            || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
            || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE;
    
    if ((viewFlags & ENABLED_MASK) == DISABLED
            && (mPrivateFlags4 & PFLAG4_ALLOW_CLICK_WHEN_DISABLED) == 0) {
        if (action == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
            setPressed(false);
        }
        mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
        // A disabled view that is clickable still consumes the touch
        // events, it just doesn't respond to them.
        return clickable;
    }

接着，如果View设置有代理，那么还会执行TouchDelegate的onTouchEvent方法，这个onTouchEvent的工作机制看起来和OnTouchListener类似。

    if (mTouchDelegate != null) {
        if (mTouchDelegate.onTouchEvent(event)) {
            return true;
        }
    }

接下来看下onTouchEvent中对点击事件的具体处理，如下所示：

public boolean onTouchEvent(MotionEvent event) {
    final boolean clickable = ((viewFlags & CLICKABLE) == CLICKABLE
            || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
            || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE;

    if (clickable) {
        switch (event.getAction()) {
            case MotionEvent.ACTION_UP:
                boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
                if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {
                    //...省略无关代码
                    if (!mHasPerformedLongPress && !mIgnoreNextUpEvent) {
                        // This is a tap, so remove the longpress check
                        removeLongPressCallback();
                        // Only perform take click actions if we were in the pressed state
                        if (!focusTaken) {
                            // Use a Runnable and post this rather than calling
                            // performClick directly. This lets other visual state
                            // of the view update before click actions start.
                            if (mPerformClick == null) {
                                mPerformClick = new PerformClick();
                            }
                            if (!post(mPerformClick)) {
                                performClickInternal();
                            }
                        }
                    }
                    //...省略无关代码
                }
                break;
            case MotionEvent.ACTION_DOWN:
                //...省略无关代码
                break;
            case MotionEvent.ACTION_CANCEL:
                //...省略无关代码
                break;
            case MotionEvent.ACTION_MOVE:
                //...省略无关代码
                break;
        }
        return true;
    }

    return false;
}

从上面的代码来看，只要View的CLICKABLE和LONG_CLICKABLE有一个为true，那么它就会消耗这个事件，即onTouchEvent方法返回true，不管它是不是DISABLE状态。然后就是当ACTION_UP事件发生时，会触发performClick方法，如果View设置了onClickListener，那么performClick方法内部会调用它的onClick方法，如下所示：

public boolean performClick() {
    final boolean result;
    final ListenerInfo li = mListenerInfo;
    if (li != null && li.mOnClickListener != null) {
        playSoundEffect(SoundEffectConstants.CLICK);
        li.mOnClickListener.onClick(this);
        result = true;
    } else {
        result = false;
    }
    sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
    return result;
}

View的LONG_CLICKABLE属性默认为false，而CLICKABLE属性是否为false和具体的View有关。确切的来说是可点击的View其CLICKABLE为true，不可点击的View其CLICKABLE为false，比如Button是可点击的，TextView是不可点击的。通过setClickable和setLongClickable可以分别改变View的CLICKABLE和LONG_CLICKABLE属性。另外，setOnClickListener会自动将View的CLICKABLE设为true，setLongClickListener则会自动将View的LONG_CLICKABLE设为true，这一点从源码中可以看出来，如下所示：

public void setOnClickListener(@Nullable OnClickListener l) {
    if (!isClickable()) {
        setClickable(true);
    }
    getListenerInfo().mOnClickListener = l;
}

public void setOnLongClickListener(@Nullable OnLongClickListener l) {
    if (!isLongClickable()) {
        setLongClickable(true);
    }
    getListenerInfo().mOnLongClickListener = l;
}

到这里，事件分发机制的源码也就分析完了。

最后

如果想要成为架构师或想突破20~30K薪资范畴，那就不要局限在编码，业务，要会选型、扩展，提升编程思维。此外，良好的职业规划也很重要，学习的习惯很重要，但是最重要的还是要能持之以恒，任何不能坚持落实的计划都是空谈。

如果你没有方向，这里给大家分享一套由阿里高级架构师编写的《Android八大模块进阶笔记》，帮大家将杂乱、零散、碎片化的知识进行体系化的整理，让大家系统而高效地掌握Android开发的各个知识点。
在这里插入图片描述
相对于我们平时看的碎片化内容，这份笔记的知识点更系统化，更容易理解和记忆，是严格按照知识体系编排的。