Android源码分析View的事件分发机制

最新推荐文章于 2023-05-26 11:09:09 发布

叫我Aso

最新推荐文章于 2023-05-26 11:09:09 发布

阅读量200

点赞数

分类专栏：详细信息文章标签： android

本文链接：https://blog.csdn.net/T_double/article/details/105831081

版权

详细信息专栏收录该内容

25 篇文章 0 订阅

订阅专栏

源码阅读，谨记：不要掉坑里，不要有强迫症，带着疑惑和问题去找它，阅读你关心的内容就好，别妄想一次就想搞定它！

事件使用与结论

1. 在Activity中对View事件的监听与结论

//点击事件
View.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        ALog.dTag("ViewEvent", "View的onClick事件");
    }
});
//触屏事件
View.setOnTouchListener(new View.OnTouchListener() {
    @Override
    public boolean onTouch(View v, MotionEvent event) {
        ALog.dTag("ViewEvent", "View的onTouch事件,event:%s", event.getAction());
        return false;//true-拦截此事件，false-透传此事件
    }
});

事件日志

onTouch 返回 false 时

D/ViewEvent: ╔════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ║ onTouch (ViewActivity.java:39) [ALog-Content] View的onTouch事件,event:0		//触屏事件中的按下（MotionEvent.ACTION_DOWN）事件
D/ViewEvent: ╚════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ╔════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ║ onTouch (ViewActivity.java:39) [ALog-Content] View的onTouch事件,event:2		//触屏事件中的滑动（MotionEvent.ACTION_MOVE）事件
D/ViewEvent: ╚════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ╔════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ║ onTouch (ViewActivity.java:39) [ALog-Content] View的onTouch事件,event:1		//触屏事件中的放开（MotionEvent.ACTION_UP）事件
D/ViewEvent: ╚════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ╔════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ║ onClick (ViewActivity.java:33) [ALog-Content] View的onClick事件
D/ViewEvent: ╚════════════════════════════════════════════════════════════════════════════════════════

2.onTouch 返回 true 时

D/ViewEvent: ╔════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ║ onTouch (ViewActivity.java:39) [ALog-Content] View的onTouch事件,event:0
D/ViewEvent: ╚════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ╔════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ║ onTouch (ViewActivity.java:39) [ALog-Content] View的onTouch事件,event:2
D/ViewEvent: ╚════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ╔════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ║ onTouch (ViewActivity.java:39) [ALog-Content] View的onTouch事件,event:1
D/ViewEvent: ╚════════════════════════════════════════════════════════════════════════════════════════

日志总结：
onClick与onTouch的注册，均可实现用户行为事件的监听，而区别在于若同时注册使用，即同时setOnClickListener和setOnTouchListener，那么事件中onTouch优先于onClick执行，onClick会在onTouch的MotionEvent.ACTION_UP之后执行，且onTouch的返回值，会影响到onClick是否被执行
onTouch返回false时，事件执行顺序为：setOnTouchListener的onTouch -> setOnClickListener的onClick
onTouch返回true时，事件执行顺序为：setOnTouchListener的onTouch

2. 在自定义View中事件的监听与结论

基于 1 的基础上，在自定义View重写dispatchTouchEvent、onTouchEvent内容

//Activity中监听触屏事件
View.setOnTouchListener(new View.OnTouchListener() {
    @Override
    public boolean onTouch(View v, MotionEvent event) {
        ALog.dTag("ViewEvent", "View的onTouch事件,event:%s", event.getAction());
        return false;//true-拦截此事件，false-透传此事件
    }
});

	//自定义View中重写部分
	
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        ALog.dTag("ViewEvent", "自定义View的 onTouchEvent 事件,event:%s", event.getAction());
        return super.onTouchEvent(event);
    }


    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        ALog.dTag("ViewEvent", "自定义View的 dispatchTouchEvent 事件,event:%s", ev.getAction());
        return super.dispatchTouchEvent(ev);
    }

事件日志
1.onTouch 返回 false 时

D/ViewEvent: ╔════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ║ dispatchTouchEvent (MyView.java:42) [ALog-Content] 自定义View的 dispatchTouchEvent 事件,event:0
D/ViewEvent: ╚════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ╔════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ║ onTouch (ViewActivity.java:41) [ALog-Content] View的onTouch事件,event:0
D/ViewEvent: ╚════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ╔════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ║ onTouchEvent (MyView.java:35) [ALog-Content] 自定义View的 onTouchEvent 事件,event:0
D/ViewEvent: ╚════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ╔════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ║ dispatchTouchEvent (MyView.java:42) [ALog-Content] 自定义View的 dispatchTouchEvent 事件,event:1
D/ViewEvent: ╚════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ╔════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ║ onTouch (ViewActivity.java:41) [ALog-Content] View的onTouch事件,event:1
D/ViewEvent: ╚════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ╔════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ║ onTouchEvent (MyView.java:35) [ALog-Content] 自定义View的 onTouchEvent 事件,event:1
D/ViewEvent: ╚════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ╔════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ║ onClick (ViewActivity.java:34) [ALog-Content] View的onClick事件
D/ViewEvent: ╚════════════════════════════════════════════════════════════════════════════════════════

onTouch 返回 true 时

D/ViewEvent: ╔════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ║ dispatchTouchEvent (MyView.java:42) [ALog-Content] 自定义View的 dispatchTouchEvent 事件,event:0
D/ViewEvent: ╚════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ╔════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ║ onTouch (ViewActivity.java:41) [ALog-Content] View的onTouch事件,event:0
D/ViewEvent: ╚════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ╔════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ║ dispatchTouchEvent (MyView.java:42) [ALog-Content] 自定义View的 dispatchTouchEvent 事件,event:1
D/ViewEvent: ╚════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ╔════════════════════════════════════════════════════════════════════════════════════════
D/ViewEvent: ║ onTouch (ViewActivity.java:41) [ALog-Content] View的onTouch事件,event:1
D/ViewEvent: ╚════════════════════════════════════════════════════════════════════════════════════════

日志总结
onTouch返回false时，事件执行顺序为：View的dispatchTouchEvent -> setOnTouchListener的onTouch -> View的onTouchEvent -> setOnClickListener的onClick
onTouch返回true时，事件执行顺序为：View的dispatchTouchEvent -> setOnTouchListener的onTouch -> setOnClickListener的onClick

事件源码分析

View中的dispatchTouchEvent()如何被调用

前提：熟知当视图UI发生点击事件后，最先响应的是Activity的dispatchTouchEvent()函数，那么接下来的源码就以dispatchTouchEvent()为源头开始分析

Activity中的dispatchTouchEvent()：

    /**
     * Called to process touch screen events.  You can override this to
     * intercept all touch screen events before they are dispatched to the
     * window.  Be sure to call this implementation for touch screen events
     * that should be handled normally.
     * 译文：被调用来处理触屏事件。你可以重写该方法来拦截所有触屏事件被分发到窗口之前。对于应该正常处理的触屏事件，需确保调用该实现
     * @param ev The touch screen event.//触屏事件
     *
     * @return boolean Return true if this event was consumed.//如果事件被消化则返回true
     */
    public boolean dispatchTouchEvent(MotionEvent ev) {
        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
            onUserInteraction();
        }
        if (getWindow().superDispatchTouchEvent(ev)) {
            return true;
        }
        return onTouchEvent(ev);
	}

当我们查看getWindow() 可知返回对象是Window，而Window又是一个抽象类，它只有一个唯一的实现类是PhoneWindow.java（从类说明验证）

/**
 * Abstract base class for a top-level window look and behavior policy.  An
 * instance of this class should be used as the top-level view added to the
 * window manager. It provides standard UI policies such as a background, title
 * area, default key processing, etc.
 *
 * <p>The only existing implementation of this abstract class is
 * android.view.PhoneWindow, which you should instantiate when needing a
 * Window.//该抽象类的唯一实现类是android.view.PhoneWindow，....
 */
public abstract class Window {
	...
}

根据getWindow().superDispatchTouchEvent(ev)我们应该到PhoneWindow.java类中查找superDispatchTouchEvent方法，这里，出现了DecorView对象mDecor，并且在这里是调用了mDecor.superDispatchTouchEvent(event);后直接返回

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

关键点来了，DecorView是个什么类？类中的superDispatchTouchEvent(event)里面执行了什么东西？
首先，DecorView是Activity窗口的根视图，不是很明白的可以查找下相关资料，
其次，代码如下

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

到这里，dispatchTouchEvent这个就不陌生了吧，就是在这里调用到View中具体实现的dispatchTouchEvent(MotionEvent ev)
在这里插入图片描述

为何onTouch返回true时onClick不被调用

从上面我们已经知道了dispatchTouchEvent是作为事件的源头，那么接下来就以View.java中的dispatchTouchEvent作为源头进行起点分析

    /**
     * Pass the touch screen motion event down to the target view, or this
     * view if it is the target.
     *
     * @param event The motion event to be dispatched.
     * @return True if the event was handled by the view, false otherwise.
     */
    public boolean dispatchTouchEvent(MotionEvent event) {
        // If the event should be handled by accessibility focus first.
        if (event.isTargetAccessibilityFocus()) {
            // We don't have focus or no virtual descendant has it, do not handle the event.
            if (!isAccessibilityFocusedViewOrHost()) {
                return false;
            }
            // We have focus and got the event, then use normal event dispatch.
            event.setTargetAccessibilityFocus(false);
        }
        //分析步骤 3
        //result 为该方法的返回值，同时也是控制是否调用onClick事件的标记位，
        //当为true表示消耗事件时，则将不会调用到onClick
        boolean result = false;

        if (mInputEventConsistencyVerifier != null) {
            mInputEventConsistencyVerifier.onTouchEvent(event, 0);
        }

        final int actionMasked = event.getActionMasked();
        if (actionMasked == MotionEvent.ACTION_DOWN) {
            // Defensive cleanup for new gesture
            stopNestedScroll();
        }

        if (onFilterTouchEventForSecurity(event)) {
            if ((mViewFlags & ENABLED_MASK) == ENABLED && handleScrollBarDragging(event)) {
                result = true;
            }
            //noinspection SimplifiableIfStatement
            ListenerInfo li = mListenerInfo;
            if (li != null && li.mOnTouchListener != null//判断是否setOnTouchListener，已setOnTouchListener的话，这个条件为true
                    && (mViewFlags & ENABLED_MASK) == ENABLED//判断当前操作的View是否为可点击(android:clickable="true")，因为默认是true(特殊的View除外，如ImageView)，所以该条件一般也是true
                    && li.mOnTouchListener.onTouch(this, event)) //关键的条件，在new出来的View.OnTouchListener()中onTouch的返回值直接决定了该if条件的成立，这将决定了result的值
                    {
                //分析步骤 2
                //在这里，我们姑且默认 setOnTouchListener了，enable也默认是true可用，
                //所以 li.mOnTouchListener.onTouch(this, event)的返回值决定是否result = true;
                result = true;
            }
			//分析步骤 1
			//纵观整个方法体内容，与事件有关的，猜测也只剩下这个if条件里的onTouchEvent函数了，并且在这个&&运算的条件中，result起着至关重要的前提，
			//result必须为false，onTouchEvent(event)事件才会被直接，所以到这里正是验证了onTouch的返回值必须是false，才会有下一步的事件分发
            if (!result && onTouchEvent(event)) {
                result = true;
            }
        }

        if (!result && mInputEventConsistencyVerifier != null) {
            mInputEventConsistencyVerifier.onUnhandledEvent(event, 0);
        }

        // Clean up after nested scrolls if this is the end of a gesture;
        // also cancel it if we tried an ACTION_DOWN but we didn't want the rest
        // of the gesture.
        if (actionMasked == MotionEvent.ACTION_UP ||
                actionMasked == MotionEvent.ACTION_CANCEL ||
                (actionMasked == MotionEvent.ACTION_DOWN && !result)) {
            stopNestedScroll();
        }

        return result;
    }

从上述源码的41行与51行也证明了为什么onTouch是在onClick之前执行.

分析步骤概括为以下几点

理清楚onClick是在哪里被调用

译文部分和注释部分为分析内容

    /**
     * Call this view's OnClickListener, if it is defined.  Performs all normal
     * actions associated with clicking: reporting accessibility event, playing
     * a sound, etc.
     *
     * @return True there was an assigned OnClickListener that was called, false
     *         otherwise is returned.
     * 译文：如果该视图的OnClickListener被定义了，则调用它。......
     * 意思就是如果这个自定义View被View.setOnClickListener，那么performClick()就会被调用（当然，前提是事件不被拦截）
     */
    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);

        notifyEnterOrExitForAutoFillIfNeeded(true);

        return result;
    }

分析onClick被调用的前提条件

根据上面的源码进行分析，我们所关心的onClick被调用的前提条件并不在performClick()中，那么就往上分析，是谁调用了performClick()？
如果进行搜索的话，我们会发现performClick()的调用者有不少，但是，以dispatchTouchEvent作为前提，谁与onTouchEvent有关，谁就是我们的目标，所以我们就在onTouchEvent中找到了performClick()的调用，也就是下面源码中的第 41 行

    /**
     * Implement this method to handle touch screen motion events.
     * <p>
     * If this method is used to detect click actions, it is recommended that
     * the actions be performed by implementing and calling
     * {@link #performClick()}. This will ensure consistent system behavior,
     * including:
     * <ul>
     * <li>obeying click sound preferences
     * <li>dispatching OnClickListener calls
     * <li>handling {@link AccessibilityNodeInfo#ACTION_CLICK ACTION_CLICK} when
     * accessibility features are enabled
     * </ul>
     *
     * @param event The motion event.
     * @return True if the event was handled, false otherwise.
     */
    public boolean onTouchEvent(MotionEvent event) {
        ......

        if (clickable || (viewFlags & TOOLTIP) == TOOLTIP) {
            switch (action) {
                case MotionEvent.ACTION_UP:
                    ......
                    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)) {
                                    performClick();
                                }
                            }
                        }

                        ......
                    }
                    ......
                    break;

                case MotionEvent.ACTION_DOWN:
                    ....
                    break;

                case MotionEvent.ACTION_CANCEL:
                    ....
                    break;

                case MotionEvent.ACTION_MOVE:
                    ....
                    break;
            }

            return true;
        }

        return false;
    }

到这里，已经实力验证了onTouchEvent是否执行触屏事件中的MotionEvent.ACTION_UP，就是决定是否调用onClick点击事件，这一点分析也同时验证了最上面提出来的结论：onClick会在onTouch的MotionEvent.ACTION_UP之后执行

分析onClick被调用的前提条件的生成

onTouchEvent是在dispatchTouchEvent中被调用，所以回归到dispatchTouchEvent函数内的注释说明进行阅读理解

概括整个目的流程

在整个事件的分发中，从Activity视图层接收到触屏事件开始，View在默认的enable前提下，onTouch的返回值决定了dispatchTouchEvent返回值result的值，result决定了是否执行onTouchEvent，所以onTouch返回值为false的时候，onTouchEvent才有机会被执行，onClick才有机会被调用

叫我Aso

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android源码分析View的事件分发机制

目录事件使用与结论事件源码分析View中的dispatchTouchEvent()如何被调用自定义控件事件冲突，如滑动事件，父容器的拦截，事件冲突解决事件使用与结论View.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { ALog...
复制链接

扫一扫