源码分析android的事件分发机制

最新推荐文章于 2022-10-23 22:00:03 发布

置顶刘裕育

最新推荐文章于 2022-10-23 22:00:03 发布

阅读量307

点赞数 1

分类专栏： android 文章标签： android-事件分发机制

本文链接：https://blog.csdn.net/s2311307/article/details/74780023

版权

android 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

在Android中，采用树的结构来储存View的。所以，事件（例如点击事件）每一次都是到达最上面的View（DecorView），然后通过事件分发机制，一层一层往下传递，直到被处理掉。

事件分发机制

事件分发机制：“从最顶层View往下传播，直到被某个View消费掉”

先来看一组代码。

myButton.setOnTouchListener(new View.OnTouchListener() {
   @Override
   public boolean onTouch(View v, MotionEvent event) {
      Log.e("TAG","myButton onTouch" + event.getAction());
          return false;
      }
 });

 myLinear.setOnTouchListener(new View.OnTouchListener() {
   @Override
   public boolean onTouch(View v, MotionEvent event) {
     Log.e("TAG","myLinear onTouch " + event.getAction() );
          return false;
     }
 });

做一个简单的输出
这里写图片描述

我们可以看到，上面的输出语句，只打印的Button的onTouch方法，而没有打印Linear的onTouch方法。

事件分发机制，不是从上而下的吗？而Button是在Linear里的，而Button输出了onTouch，Linear怎么会没有呢？

其实，ouTouch方法是事件的处理，并不是事件的分发。所以现在让我们一起来看事件的是怎么分发的吧。

首先，分别在MyButton和MyLinear中重写dispatchTouchEvent方法并且打印日志。然后运行程序之后点击MyButton按钮。可以看到。
这里写图片描述
这里就可以很清晰的看出来，事件是由MyLinear通过dispatchTouchEvent分发到MyButton的dispatchTouchEvent的，然后由于Mybutton就是那个被点击的View，所以就调用onTouch处理了这个事件。

所以，事件分发的机制就是：如果我是ViewGroup并且拥有子View，那么我就把事件分发下去。但是，如果当前ViewGroup在拥有子View的情况下，就是要拦截，该如何做呢？

我们在MyLinear中重写onInterceptTouchEvent方法，让他返回true。再来看看日志。
这里写图片描述
这里很明显可以看到，让onInterceptTouchEvent方法返回true，事件传递到这一层时，就会处理掉事件，所以，onInterceptTouchEvent方法其实是个拦截器。而看一看onInterceptTouchEvent方法，里面确实做了很少的事情，只是一个判断，然后就return了。

这里抛出个疑问，为什么在没有拦截之前，点击一次Button的输出有很多个action，而当MyLinear拦截掉事件后，就剩下一个。而触摸屏幕至少会产生两个事件（按下和离开），另外一个事件呢？

先抛出这个疑问，后面会有解答。

说了那么多，都是打印日志来说明问题，那么现在从源码的角度，来证明这个问题。

我们点击myLinear的dispatchTouchEvent方法，可以看到直接跳到viewGroup了，也就是说，所有可以容纳子view的view，事件分发都是viewGroup在处理。（除非我们重写dispatchTouchEvent）

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    boolean handled = false;
    if (onFilterTouchEventForSecurity(ev)) {
        final int action = ev.getAction();
        final int actionMasked 
             = action &MotionEvent.ACTION_MASK;

    //这是一个事件拦截器
    final boolean intercepted;
    if (actionMasked == MotionEvent.ACTION_DOWN 
        || mFirstTouchTarget != null) {
            final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
        if (!disallowIntercept) {
            intercepted = onInterceptTouchEvent(ev);
            ev.setAction(action);
        } else {
            intercepted = false;
        }
    } else {
        intercepted = true;
    }

    final boolean canceled = resetCancelNextUpFlag(this)
            || actionMasked == MotionEvent.ACTION_CANCEL;
    if (!canceled && !intercepted) {
        View childWithAccessibilityFocus 
            = ev.isTargetAccessibilityFocus()
            ? findChildWithAccessibilityFocus() : null;
        if (actionMasked == MotionEvent.ACTION_DOWN
                && actionMasked 
                   == MotionEvent.ACTION_POINTER_DOWN)
                || actionMasked 
                   == MotionEvent.ACTION_HOVER_MOVE) {
            final int actionIndex = ev.getActionIndex();        
            final int childrenCount = mChildrenCount;
            if (newTouchTarget == null && childrenCount != 0) {

                final ArrayList<View> preorderedList 
                     = buildTouchDispatchChildList();
                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 (childWithAccessibilityFocus != null) {
                      if (childWithAccessibilityFocus != child) {
                         continue;
                      }
                      childWithAccessibilityFocus = null;
                      i = childrenCount - 1;
                     }
                     if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
                      mLastTouchDownTime = ev.getDownTime();
                      if (preorderedList != null) {
                        for (int j = 0; j < childrenCount; j++) {
                          if (children[childIndex] 
                             == mChildren[j]) {
                               mLastTouchDownIndex = j;
                                break;
                          }
                      }
                 } else {
                            mLastTouchDownIndex = childIndex;
                        }
                        break;
                    }
                }
            }
        }
    }
}
return handled;
}

代码很长，被我删除掉一些。我们可以看到，在viewGroup的dispatchTouchEvent中，如果拦截器intercepted为false，就会通过一个for循环去遍历子view，onInterceptTouchEvent方法，所以上面只要我们重写onInterceptTouchEvent并且返回true，在viewGroup中就不会进入for循环，事件就这里被拦截了。

那么，for循环是怎么传递数据的呢？首先for循环会判断当前view是不是被点击的一个，如果是，就进入到了if语句，里面是一个方法判断，点进去看看这个方法做了什么。

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) {
            event.setAction(MotionEvent.ACTION_CANCEL);
            if (child == null) {
                handled = super.dispatchTouchEvent(event);
            } else {
                handled = child.dispatchTouchEvent(event);
            }
            event.setAction(oldAction);
            return handled;
        }
       .....
 }

在这个方法里面，终于看到，如果该事件不处于ACTION_CANCEL状态，且child不为null就会调用子View的dispatchTouchEvent方法。而子view如果也是viewGroup就会按照这个套路一直执行下去，知道执行到当前viewGroup拦截了事件或者当前点击的view。
如果是viewGroup拦截了事件，在上面if判断之后，还会去调用一次dispatchTransformedTouchEvent方法，只不过传入的参数不同，导致dispatchTouchEvent会调用super.dispatchTouchEvent(event)，而这就是viewGroup拦截后的处理。

好，再次看到dispatchTransformedTouchEvent方法，无论是调用super.dispatchTouchEvent(event)，还是把事件传递下去，总是要调用到View的dispatchTouchEvent方法。注：ViewGroup继承于View。

我们来看看，View对于dispatchTouchEvent的处理。

public boolean dispatchTouchEvent(MotionEvent event) {
    boolean result = false;
    final int actionMasked = event.getActionMasked();
    if (onFilterTouchEventForSecurity(event)) {
      if ((mViewFlags & ENABLED_MASK) == ENABLED 
          && handleScrollBarDragging(event)) {
          result = true;
      }
      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;
}

这里就是事件被处理时的代码，上面我说过，onTouch是事件的处理，果然，onTouch就在这里被调用了。而如果你细心的话，可以去试一试，在写监听的时候，onTouch的返回true，onClick就不会被调用了。
其实这里可以从源码看到，如果onTouch返回true，就不会调用onTouchEvent，而onClick就在onTouchEvent的Up事件被调用的。

上面有一个问题，问：为什么viewGroup在没有拦截之前，点击一次Button的输出有很多个action，而当MyLinear拦截掉事件后，就剩下一个。而触摸屏幕至少会产生两个事件（按下和离开），另外一个事件呢？

其实这里我也还没完完全全搞清楚，dispatchTouchEvent是被多次调用的，如果上一次dispatchTouchEvent返回false，则下一次dispatchTouchEvent就不会被调用了。而当事件被Linear拦截后，而如果你在onTouch返回false的话，是会调用onTouchEvent的，而在onTouchEvent中有一个判断。

 if (((viewFlags & CLICKABLE) == CLICKABLE
      ||(viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE) 
      ||(viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE) {