Android View事件分发机制

快来打我* 2022-05-10 12:52 236阅读 0赞

> 作为程序猿，最不想 看的但是也不得不去看的就是源码！所谓知其然也要知其所以然，神秘的大佬曾经说过进阶的方法就是**READ THE FUCKING CODE**！

### 认识MotionEvent ###

> 负责集中处理所有类型设备的输入事件.我们对屏幕的点击，滑动，抬起等一系的动作都是由一个一个MotionEvent对象组成的。

主要事件类型

*  ACTION\_DOWN 手机初次触摸到屏幕事件
 *  ACTION\_MOVE 手机在屏幕上滑动时触发,会回调多次
 *  ACTION\_UP 手指离开屏幕时触发

主要方法

*  getAction() 获取事件类型
 *  getX() 获取触摸点在当前View的X轴坐标
 *  getY() 获得触摸点在当前 View 的 Y 轴坐标
 *  getRawX() 获得触摸点在整个屏幕的 X 轴坐标
 *  getRawY() 获得触摸点在整个屏幕的 Y 轴坐标

上面这些是基本操作.下面我们来看一个小东西:

class MainActivity : AppCompatActivity() { 
    
        override fun onCreate(savedInstanceState: Bundle?) { 
            super.onCreate(savedInstanceState)
            setContentView(R.layout.activity_main)
    
            btn_test.setOnTouchListener {  v, event ->
                when (event.action) { 
                    MotionEvent.ACTION_DOWN -> { 
                        Log.e("xfhy", "ACTION_DOWN")
                    }
                    MotionEvent.ACTION_MOVE -> { 
                        Log.e("xfhy", "ACTION_MOVE")
                    }
                    MotionEvent.ACTION_UP -> { 
                        Log.e("xfhy", "ACTION_UP")
                    }
                    else -> { 
                    }
                }
    
                //返回false
                false
            }
    
            btn_test.setOnClickListener { 
                Log.e("xfhy", "点击事件")
            }
        }
    }

最后执行结果是

2018-10-15 17:51:19.766 9257-9257/com.xfhy.clickdemo E/xfhy: ACTION_DOWN
    2018-10-15 17:51:19.785 9257-9257/com.xfhy.clickdemo E/xfhy: ACTION_MOVE
    2018-10-15 17:51:19.844 9257-9257/com.xfhy.clickdemo E/xfhy: ACTION_MOVE
    2018-10-15 17:51:19.844 9257-9257/com.xfhy.clickdemo E/xfhy: ACTION_UP
    2018-10-15 17:51:19.848 9257-9257/com.xfhy.clickdemo E/xfhy: 点击事件

onClick()是在ACTION\_UP之后才调用的.  
至于为什么,稍后会给出解释(源码就是这样写的).

### MotionEvent事件分发 ###

当一个MotionEvent产生后,需要分发给一个具体的View,去消化处理.我们需要去了解这个分发的过程.

下面有几个重要的方法,简单介绍一下:

*  **public boolean dispatchTouchEvent(MotionEvent event)** 事件的分发.对于一个根ViewGroup来说,发生点击事件首先调用dispatchTouchEvent()
 *  **public boolean onInterceptTouchEvent(MotionEvent ev)**  
    事件拦截.如果这个ViewGroup的onIterceptTouchEvent返回true就表示它要拦截当前事件,接着这个ViewGroup的onTouchEvent就会被调用.如果onIterceptTouchEvent返回false,那么就会继续向下调用子View的dispatchTouchEvent方法.一旦一个元素拦截了某事件,那么一个事件序列里面后续的Move,Down事件都会交给它处理.并且它的onInterceptTouchEvent不会再调用.
 *  **public boolean onTouchEvent(MotionEvent ev)** 事件处理.View的默认实现会在onTouchEvent里面把touch事件解析成Click之类的事件.View的onTouchEvent默认都会消耗事件,除非它的clickable和longClickable都是false(不可点击),但是enable属性不会影响.

*  点击事件传递顺序 Activity -> ViewGroup -> View

下面是View事件分发流程图:

![View事件分发流程图][View]

现在,我们队View的事件分发有了一个大致的了解.

上面的三个方法可以用以下伪代码来表示其关系:

public boolean dispatchTouchEvent(MotionEvent ev) { 
            boolean consume = false;//事件是否被消费
            if (onInterceptTouchEvent(ev)){ //调用onInterceptTouchEvent判断是否拦截事件
                consume = onTouchEvent(ev);//如果拦截则调用自身的onTouchEvent方法
            }else{ 
                consume = child.dispatchTouchEvent(ev);//不拦截调用子View的dispatchTouchEvent方法
            }
            return consume;//返回值表示事件是否被消费，true事件终止，false调用父View的onTouchEvent方法
        }

通过上面的介绍,差不多简单了解了事件的传递机制.下面我们来看看源码:

### 源码分析 ###

事件从最先到达Activity,我们来看一下Activity的dispatchTouchEvent()

public boolean dispatchTouchEvent(MotionEvent ev) { 
        if (ev.getAction() == MotionEvent.ACTION_DOWN) { 
            //一个空方法,一般用于开发者想监听某个点击事件的开始
            onUserInteraction();
        }
        //交给Window去分发
        if (getWindow().superDispatchTouchEvent(ev)) { 
            return true;
        }
        
        //如果没人处理这个事件,那么当前Activity去处理
        return onTouchEvent(ev);
    }

上面是getWindow().superDispatchTouchEvent(ev).交给Window去分发事件.  
然后Window只有一个实现类PhoneWindow,其实最后就是调用的PhoneWindow中的superDispatchTouchEvent(ev).

### PhoneWindow部分代码
    private DecorView mDecor;
    
    @Override
    public boolean superDispatchTouchEvent(MotionEvent event) { 
        return mDecor.superDispatchTouchEvent(event);
    }

咦,看到没有,其实是通过顶级View–DecorView去分发事件,嗯,很合乎常理.从上往下分配任务.

下面是DecorView的代码

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

再跟进super.dispatchTouchEvent(event);,就来到了ViewGroup(显然,DecorView是ViewGroup).

public boolean dispatchTouchEvent(MotionEvent ev) { 
            boolean handled = false;
            // 判断当前View是否没被遮盖住 如果是遮盖住了,则不进行事件分发
            if (onFilterTouchEventForSecurity(ev)) { 
                final int action = ev.getAction();
                final int actionMasked = action & MotionEvent.ACTION_MASK;
    
                //处理初次的按下事件
                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.
                    //在开始新的触摸手势时丢弃所有先前的状态。
                    cancelAndClearTouchTargets(ev);
                    //重置所有触摸状态以准备新周期。
                    resetTouchState();
                }
    
                //检测拦截
                final boolean intercepted;
                //事件是按下
                if (actionMasked == MotionEvent.ACTION_DOWN || mFirstTouchTarget != null) { 
                    //判断是否禁止拦截 当子View调用requestDisallowInterceptTouchEvent(true)之后,这里的disallowIntercept就是true->禁止拦截 因为子类想接收这个事件并处理自己的逻辑
                    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 { 
                    // There are no touch targets and this action is not an initial down
                    // so this view group continues to intercept touches.
                    intercepted = true;
                }
    
                //检查是否已经被取消了
                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 (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;
    
                        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 = buildTouchDispatchChildList();
                            final boolean customOrder = preorderedList == null && isChildrenDrawingOrderEnabled();
                            final View[] children = mChildren;
                            for (int i = childrenCount - 1; i >= 0; i--) { 
                                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;
                                }
    
                                // a.如果View不可见并且没有播放动画
                                // b.点击事件的坐标落在View的范围内 
                                // 满足a或者b则不分发事件给这个view
                                if (!canViewReceivePointerEvents(child)
                                        || !isTransformedTouchPointInView(x, y, child, null)) { 
                                    ev.setTargetAccessibilityFocus(false);
                                    continue;
                                }
    
                                newTouchTarget = getTouchTarget(child);
                                if (newTouchTarget != null) { 
                                    //子View已经接收触摸事件在自己的范围内,则直接跳出循环,将事件给它自己处理.
                                    // 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);
                                //这里实际上是去调用child的dispatchTouchEvent(event);->子类去分发事件.
                                //ps: ViewGroup才能分发事件,View不能分发.
                                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();
                                    //将child赋值给mFirstTouchTarget
                                    newTouchTarget = addTouchTarget(child, idBitsToAssign);
                                    alreadyDispatchedToNewTouchTarget = true;
    
                                    //如果某个child处理了事件,那么就不用继续循环了,直接跳出循环.
                                    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;
                        }
                    }
                }
    
               // Dispatch to touch targets.
                if (mFirstTouchTarget == null) { 
                    //没有child接收该事件,则调用super.dispatchTouchEvent(event); 将该事件交给View去处理
                    // No touch targets so treat this as an ordinary view.
                    handled = dispatchTransformedTouchEvent(ev, canceled, null, TouchTarget.ALL_POINTER_IDS);
                }
            return handled;
        }
    
    
    
        //在ViewGroup中，比View多了一个方法—onInterceptTouchEvent()方法，这个是干嘛用的呢，是用来进行事件拦截的，如果被拦截，事件就不会往下传递了，不拦截则继续。
        //子类可以去实现这个方法,然后就可以轻松的拦截事件啦.
        public boolean onInterceptTouchEvent(MotionEvent ev) { 
            if (ev.isFromSource(InputDevice.SOURCE_MOUSE)
                    && ev.getAction() == MotionEvent.ACTION_DOWN
                    && ev.isButtonPressed(MotionEvent.BUTTON_PRIMARY)
                    && isOnScrollbarThumb(ev.getX(), ev.getY())) { 
                return true;
            }
            return false;
        }
    
        /* 是否能收到事件: 如果可见或者没有播放动画 */
        private static boolean canViewReceivePointerEvents(@NonNull View child) { 
            return (child.mViewFlags & VISIBILITY_MASK) == VISIBLE
                    || child.getAnimation() != null;
        }

上面是ViewGroup的分发事件源码,只抽取了源码的部分,关键部分加入了注释.

**结论**

ViewGroup会遍历所有子View去寻找能够处理点击事件的子View（可见，没有播放动画，点击事件坐标落在子View内部）最终调用子View的dispatchTouchEvent方法处理事件

当子View处理了事件则mFirstTouchTarget 被赋值，并终止子View的遍历。

如果ViewGroup并没有子View或者子View处理了事件，但是子View的dispatchTouchEvent返回了false（一般是子View的onTouchEvent方法返回false）那么ViewGroup会去处理这个事件（本质调用View的dispatchTouchEvent去处理）

--------------------

下面来看一下View的dispatchTouchEvent()

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;
                //这里的li.mOnTouchListener.onTouch(this, event)是有返回值的,如果是返回了true,那么result就是true了. 相当于处理了触摸事件
                if (li != null && li.mOnTouchListener != null
                        && (mViewFlags & ENABLED_MASK) == ENABLED
                        && li.mOnTouchListener.onTouch(this, event)) { 
                    result = true;
                }
                
                //result为false时调用自己的onTouchEvent()去处理该事件.
                if (!result && onTouchEvent(event)) { 
                    result = true;
                }
            }
            ...
    
            return result;
        }

从上面的代码中可以看出,如果设置了OnTouchListener并且onTouch方法返回了true，那么onTouchEvent不会被调用。

我们来看看onTouchEvent()方法

public boolean onTouchEvent(MotionEvent event) { 
            final float x = event.getX();
            final float y = event.getY();
            final int viewFlags = mViewFlags;
            final int action = event.getAction();
    
            //CLICKABLE和LONG_CLICKABLE任何一个都可以消费该事件
            //TextView默认是clickable是false,Button默认是true
            //设置setOnClickListener()时会将clickable置为true
            //设置setOnLongClickListener()时会将longClickable置为true
            final boolean clickable = ((viewFlags & CLICKABLE) == CLICKABLE
                    || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
                    || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE;
    
            //即使View被设置成了不可用(setEnable(false)->DISABLED),但它还是可以消费点击事件
            if ((viewFlags & ENABLED_MASK) == DISABLED) { 
                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;
            }
            if (mTouchDelegate != null) { 
                if (mTouchDelegate.onTouchEvent(event)) { 
                    return true;
                }
            }
    
            if (clickable || (viewFlags & TOOLTIP) == TOOLTIP) { 
                switch (action) { 
                    case MotionEvent.ACTION_UP:
                        mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
                        if ((viewFlags & TOOLTIP) == TOOLTIP) { 
                            handleTooltipUp();
                        }
                        if (!clickable) { 
                            removeTapCallback();
                            removeLongPressCallback();
                            mInContextButtonPress = false;
                            mHasPerformedLongPress = false;
                            mIgnoreNextUpEvent = false;
                            break;
                        }
                        boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
                        if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) { 
                            // take focus if we don't have it already and we should in
                            // touch mode.
                            boolean focusTaken = false;
                            if (isFocusable() && isFocusableInTouchMode() && !isFocused()) { 
                                focusTaken = requestFocus();
                            }
    
                            if (prepressed) { 
                                // The button is being released before we actually
                                // showed it as pressed. Make it show the pressed
                                // state now (before scheduling the click) to ensure
                                // the user sees it.
                                setPressed(true, x, y);
                            }
    
                            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)) { 
                                        //在ACTION_UP 方法发生时,会触发performClick()方法.
                                        performClick();
                                    }
                                }
                            }
                        ....
                        }
                        mIgnoreNextUpEvent = false;
                        break;
    
                    ....
                }
    
                return true;
            }
    
            return false;
        }

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

所以,回调点击事件是在事件的最后Action\_up中才去调用的.这也就解释了上面的demo中的最后才会调用回调点击事件的方法.

简单分析了一下View事件分发.希望能帮到大家.

[View]: http://olg7c0d2n.bkt.clouddn.com/18-10-16/38354441.jpg