Android事件分发机制详解

时间  2019-11-07
标签 android 事件 分发 机制 详解 栏目 Android 繁體版
原文   原文链接

距离上篇文章有半个月，感受有些荒度，不过这篇文章写下来确实是用了半个月，确实是小白，因此看了好多文章才算是搞懂了事件分发。这篇文章更像是总结，把别人的东西比较清晰易懂的点本身记录下来，再经过本身的实践来了解事件分发的过程，废话很少说，带你看看小白是怎么一步步了解事件分发的。java

1. 什么是事件

要了解事件分发，那咱们先说说什么是事件，其实这里的事件指的就是点击事件，当用户触摸屏幕的时候，将会产生点击事件（Touch事件）android

Touch事件的相关细节（发生触摸的位置、时间等）被封装成MotionEvent对象bash

MotionEvent事件类型app

事件类型 具体动做
MotionEvent.ACTION_DOWN 按下View（全部事件的开始）
MotionEvent.ACTION_UP 抬起View（与DOWN对应）
MotionEvent.ACTION_MOVE 滑动View
MotionEvent.ACTION_CANCEL 结束事件（非人为缘由）

事件序列：其实就是从手指触摸屏幕到离开屏幕所发生的一系列事件ide

2. 什么是事件分发

咱们要讲的事件分发其实就是将点击事件传递到某个具体的View，这个传递的过程就叫作事件分发函数

3. 事件在哪些对象间进行传递、顺序是什么

Activity的UI界面由Activity、ViewGroup、View及其派生类组成布局

事件分发在这三个对象之间进行传递。post

当点击事件发生后，事件先传到Activity，再传到ViewGroup，最终传到View动画

4. 事件分发有啥用？

默认状况下事件分发会按照由Activity到ViewGroup再到View的顺序进行分发，当咱们不想View进行处理，让ViewGroup处理，那就能够进行拦截，这些知识能够用于解决滑动冲突。this

例如：外部滑动和内部滑动方向不一致，当ScrollView嵌套Fragment，且Fragemnt内部有个竖向的ListView，当用户左右滑动时，要让外部的View拦截单击事件，当用户上下滑动时，要让内部的View拦截点击事件。怎么拦截，在哪里拦截，就用到了咱们这篇文章所讲的内容了。

5. 事件分发涉及到的函数及相应的做用

方法 做用
dispatchTouchEvent 进行事件分发
onInterceptTouchEvent 事件拦截
onTouchEvent 事件消耗（就是交给当前View处理）
  • dispatchTouchEvent： 用来进行事件分发，若事件可以传递到当前View，则此方法必定会被调用。
  • onInterceptTouchEvent： 在dispatchTouchEvent方法内被调用，用来判断是否拦截某个事件。若当前View拦截了某个事件，则该方法不会再被调用，返回结果表示是否拦截当前事件，该方法只在ViewGroup中存在。
  • onTouchEvent： 用来处理点击事件，返回结果表示是否消耗当前事件，若不消耗，则在同一事件序列中，当前View没法再次接收到事件。

这三个方法可用如下伪代码表示

public boolean dispatchTouchEvent(MotionEvent ev){
    boolean consume = false;
    if(onInterceptTouchEvent(ev)){
        consume = onTouchEvent(ev);
    }else{
        consume = child.dispatchTouchEvent(ev);
    }
    return consume;
}
复制代码

对应的根ViewGroup，当一个点击事件产生时，Activity会传递给它，这时它的dispatchTouchEvent就会被调用，若该ViewGroup的onInterceptTouchEvent返回true，表明拦截该事件，可是否消耗该事件，还要看它的onTouchEvent的返回值，若是不拦截，则表明将事件分发下去给子View，接着子View的dispatchTouchEvent方法会被调用，如此反复直到事件被最终处理。

6. Activity的事件分发

当一个点击事件发生时，事件最早传到Activity的dispatchTouchEvent()进行事件分发。这里主要要弄明白Activity是怎么将事件分发到ViewGroup中的

6.1 Demo演示

咱们先看一个案例

（1） 自定义一个MyViewGroup，继承自ViewGroup，重写dispatchTouchEvent()方法

public class MyViewGroup extends ViewGroup{
    
    public boolean dispatchTouchEvent(MotionEvent ev) {
		Log.i(TAG, "dispatchTouchEvent: ");        
		//这里咱们暂时先返回false 
		return false;
    }
}
复制代码

（2） 在Activity的布局中，使用该布局做为最外层布局

<com.ld.eventdispatchdemo.activitydispatch.MyViewGroup xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:id="@+id/myViewGroup"
    android:orientation="vertical"
    tools:context=".activitydispatch.ActivityDispatchActivity">

</com.ld.eventdispatchdemo.activitydispatch.MyViewGroup>
复制代码

（3） 重写该Activity的dispatchTouchEvent()和onTouchEvent()方法，打印log日志

public class Activity extends AppCompatActivity{
    ...
	private static final String TAG = "Activit_activitydispatch";
    
    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {

        if(ev.getAction()==MotionEvent.ACTION_DOWN){
            Log.i(TAG, "dispatchTouchEvent: ");
        }
     	//这里是仿照源码的格式写的
        if(getWindow().superDispatchTouchEvent(ev)){
            Log.i(TAG, "dispatchTouchEvent: 这里被调用");
            return true;
        }        
        return onTouchEvent(ev);
    }       
    
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        Log.i(TAG, "onTouchEvent: ");
        return super.onTouchEvent(event);
    }
}
复制代码

当MyViewGroup的dispatchTouchEvent返回false时，打印的log日志为：

Activit_activitydispatch: dispatchTouchEvent: 
MyViewGroup_activitydispatch: dispatchTouchEvent: 
Activit_activitydispatch: onTouchEvent: 
Activit_activitydispatch: onTouchEvent: 
Activit_activitydispatch: onTouchEvent: 
Activit_activitydispatch: onTouchEvent: 
Activit_activitydispatch: onTouchEvent: 
复制代码

当MyViewGroup的dispatchTouchEvent返回true时，打印的log日志为：

Activit_activitydispatch: dispatchTouchEvent: 
MyViewGroup_activitydispatch: dispatchTouchEvent: 
Activit_activitydispatch: dispatchTouchEvent: 这里被调用
MyViewGroup_activitydispatch: dispatchTouchEvent: 
Activit_activitydispatch: dispatchTouchEvent: 这里被调用
MyViewGroup_activitydispatch: dispatchTouchEvent: 
Activit_activitydispatch: dispatchTouchEvent: 这里被调用
MyViewGroup_activitydispatch: dispatchTouchEvent: 
Activit_activitydispatch: dispatchTouchEvent: 这里被调用
复制代码

仔细观察能够看到，当MyViewGroup的dispatchTouchEvent返回false时，Activity的onTouchEvent会被调用，返回true时，不会被调用，这是什么缘由呢？

你可能会有疑问，个人Activity的dispatchTouchEvent()方法内为什么要这样写呢？别急，看完下面的源码你就知道了。

6.2 源码解析

目的：

一、研究MyViewGroup的dispatchTouchEvent返回false时，Activity的onTouchEvent会被调用，返回true时，不会被调用的缘由

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方法，但内容和源码基本一致。

能够从源码看到，当getWindow().superDispatchTouchEvent(ev)==true时，那么此时return ture，天然就不会调用底下的onTouchEvent()方法，即Activity的onTouchEvent()。

getWindow()返回Window对象，Window是抽象类，而PhoneWindow是Window的惟一实现类，因此getWindow().superDispatchTouchEvent(ev)其实就是调用的PhoneWindow内的superDispatchTouchEvent(ev)方法。

看看PhoneWindow类源码：

@Override
public boolean superDispatchTouchEvent(MotionEvent event) {
    return mDecor.superDispatchTouchEvent(event);
}
复制代码

PhoneWindow将事件直接传递给了DecorView，接下来看看DecorView是什么

public class DecorView extends FrameLayout implements RootViewSurfaceTaker, WindowCallbacks {
                     
}
复制代码

mDecor是getWindow().getDecorView()返回的View，经过setContentView设置的View是该View的子View。

DecorView继承自FrameLayout(ViewGroup)，因此mDecor.superDispatchTouchEvent(event)其实调用的就是ViewGroup的dispatchTouchEvent()方法，因此到这里你就懂了吧，

if (getWindow().superDispatchTouchEvent(ev)) {
    return true;
}
复制代码

其实就至关于下面这个

if(viewgroup.DispatchTouchEvent(ev)){
    return true;
}
复制代码

因此说当咱们的MyLayout的DispatchTouchEvent()返回true时，Activity的onTouchEvent就不会被调用。

6.3 事件时怎么从Activity分发到ViewGroup中的

从上面Activity的dispatchTouchEvent源码可知道，默认状态下，它内部必定会调用该方法，而if()条件中的内容其实就是调用ViewGroup的dispatchTouchEvent()方法，也就是在这里完成了Activity到ViewGroup的事件分发。

if (getWindow().superDispatchTouchEvent(ev)) {
    return true;
}
复制代码

6.4 小结：Activity分发的流程图

7. ViewGroup的事件分发

上面讲了Activity在dispatchTouchEvent内将事件传递到了ViewGroup的dispatchTouchEvent()方法中，那么ViewGroup又是如何将事件进一步向下分发的呢？

7.1 Demo演示

（1） 自定义MyLayout，继承自LinearLayout，重写onInterceptTouchEvent()方法，并返回true，重写dispatchTouchEvent()、onTouchEvent()方法，打印log日志

public class MyLayout extends LinearLayout {
    
    private static final String TAG = "MyLayout_ViewGroupDispatch";
    
    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        Log.i(TAG, "dispatchTouchEvent: ");
        return super.dispatchTouchEvent(ev);
    }
    
    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        Log.i(TAG, "onInterceptTouchEvent: ");
        //此处暂时返回true观察现象
        return true;
    }
    
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        Log.i(TAG, "onTouchEvent: ");
        return super.onTouchEvent(event);
    }   
}
复制代码

（2） 在Activity的布局中，使用该布局做为最外层布局，并在该布局内添加一个按钮

<com.ld.eventdispatchdemo.viewgroupdispatch.MyLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:id="@+id/myLayout"
    tools:context=".viewgroupdispatch.ViewGroupActivity">
    <Button
        android:id="@+id/btn1"
        android:text="Button1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />  
</com.ld.eventdispatchdemo.viewgroupdispatch.MyLayout>
复制代码

（3） 在Activity内为按钮添加点击事件

public class ViewGroupActivity extends AppCompatActivity {
    
    private Button btn1;
    private static final String TAG = "Activity_ViewGroupDispatch";
	@Override
    protected void onCreate(Bundle savedInstanceState) {
        
        btn1 = findViewById(R.id.btn1);
        btn1.setOnClickListener(new View.OnClickListener() {
            @SuppressLint("LongLogTag")
            @Override
            public void onClick(View v) {
                Log.i(TAG, "onClick: 点击了按钮1");
            }
        });
    }           
}
复制代码

当MyLayout的onInterceptTouchEvent()返回true时，分别点击空白处、点击按钮，log日志以下：

//点击空白处
MyLayout_ViewGroupDispatch: dispatchTouchEvent: 
MyLayout_ViewGroupDispatch: onInterceptTouchEvent: 
MyLayout_ViewGroupDispatch: onTouchEvent: 
//点击按钮
MyLayout_ViewGroupDispatch: dispatchTouchEvent: 
MyLayout_ViewGroupDispatch: onInterceptTouchEvent: 
MyLayout_ViewGroupDispatch: onTouchEvent: 
复制代码

当MyLayout的onInterceptTouchEvent()返回false时，分别点击空白处、点击按钮，log日志以下：

//点击空白处
MyLayout_ViewGroupDispatch: dispatchTouchEvent: 
MyLayout_ViewGroupDispatch: onInterceptTouchEvent: 
MyLayout_ViewGroupDispatch: onTouchEvent: 
//点击按钮
MyLayout_ViewGroupDispatch: onInterceptTouchEvent: 
MyLayout_ViewGroupDispatch: dispatchTouchEvent: 
MyLayout_ViewGroupDispatch: onInterceptTouchEvent: 
MyLayout_ViewGroupDispatch: dispatchTouchEvent: 
MyLayout_ViewGroupDispatch: onInterceptTouchEvent: 
MyLayout_ViewGroupDispatch: dispatchTouchEvent: 
MyLayout_ViewGroupDispatch: onInterceptTouchEvent: 
MyLayout_ViewGroupDispatch: dispatchTouchEvent: 
MyLayout_ViewGroupDispatch: onInterceptTouchEvent: 
Activity_ViewGroupDispatch: onClick: 点击了按钮1
复制代码

能够看到当ViewGroup(MyLayout)的onInterceptTouchEvent()返回true时，并无触发按钮的点击事件，而且自身的onTouchEvent()方法被调用，当返回false时，按钮的点击事件触发，但自身的onTouchEvent()方法未被调用。

并且在默认状态下，onInterceptTouchEvent()必定会被调用。

以上现象是什么缘由呢？接下来咱们看看ViewGroup的dispatchTouchEvent()方法的源码

7.2 源码解析

目的：

一、研究当ViewGroup(MyLayout)的onInterceptTouchEvent()返回true时，并无触发按钮的点击事件，而且自身的onTouchEvent()方法被调用，当返回false时，按钮的点击事件触发，但自身的onTouchEvent()方法未被调用的缘由

二、分发事件是怎么从ViewGroup分发到View中的

ViewGroup的dispatchTouchEvent()源码：

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
	...
        
    boolean handled = false;
    if (onFilterTouchEventForSecurity(ev)) {
  		......
         //一大堆代码 
    }
    
    if (!handled && mInputEventConsistencyVerifier != null) {
        mInputEventConsistencyVerifier.onUnhandledEvent(ev, 1);
    }
    return handled;
}
复制代码

咱们想要了解事件是如何分发，实际上是主要看ViewGroup的dispatchTouchEvent()方法何时返回true，何时返回false。看源码能够知道，ViewGroup的dispatchTouchEvent()方法返回的是handle的值，因此咱们只须要观察该方法内改变handle值的语句。

首先初始化了handle的值，默认为false

而后你能够看到dispatchTouchEvent()的大部份内容都在if (onFilterTouchEventForSecurity(ev)) {}这个条件判断内，也就是说若是onFilterTouchEventForSecurity(ev)方法返回true的话，那么就进入该if判断内。若返回false，则dispatchTouchEvent()返回初始值为false的handled，表示不分发事件。

查看下onFilterTouchEventForSecurity(ev)方法

public boolean onFilterTouchEventForSecurity(MotionEvent event) {
    //noinspection RedundantIfStatement
    if ((mViewFlags & FILTER_TOUCHES_WHEN_OBSCURED) != 0
        && (event.getFlags() & MotionEvent.FLAG_WINDOW_IS_OBSCURED) != 0) {
        // Window is obscured, drop this touch.
        return false;
    }
    return true;
}
复制代码
  • FILTER_TOUCHES_WHEN_OBSCURED是android:filterTouchesWhenObscured属性所对应的。android:filterTouchesWhenObscured是true的话，则表示其余视图在该视图之上，致使该视图被隐藏时，该视图就再也不响应触摸事件。
  • MotionEvent.FLAG_WINDOW_IS_OBSCURED为true的话，则表示该视图的窗口是被隐藏的

而咱们并无在XML中为控件设置android:filterTouchesWhenObscured属性，因此它==0，没有进入if()方法，因此onFilterTouchEventForSecurity()方法返回true，那么if (onFilterTouchEventForSecurity(ev))判断一定会进入以下的判断中。

接下来咱们看看if(onFilterTouchEventForSecurity(ev))判断下的内容

if (onFilterTouchEventForSecurity(ev)) {
    final int action = ev.getAction();
    final int actionMasked = action & MotionEvent.ACTION_MASK;
    
    if (actionMasked == MotionEvent.ACTION_DOWN) {        
        cancelAndClearTouchTargets(ev);
        
        resetTouchState();       
    }   
    
 	......   
}
复制代码
private void resetTouchState() {
    
    clearTouchTargets();
    
    resetCancelNextUpFlag(this);
    mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
    mNestedScrollAxes = SCROLL_AXIS_NONE;
}
复制代码
private void clearTouchTargets() {
    TouchTarget target = mFirstTouchTarget;
    if (target != null) {
        do {
            TouchTarget next = target.next;
            target.recycle();
            target = next;
        } while (target != null);
        mFirstTouchTarget = null;
    }
}
复制代码

能够看到，若为ACTION_DOWN事件，就会触发 cancelAndClearTouchTargets(ev)和resetTouchState()方法，在resetTouchState()方法中，有一个clearTouchTargets()方法，而在 clearTouchTargets()方法内会将mFirstTouchTarget设置为null。咱们暂时先记住这个mFristTouchTarget已经置为null了。

咱们再看if (onFilterTouchEventForSecurity(ev)){}该判断内的其余代码

if (onFilterTouchEventForSecurity(ev)) {
    ......
    //记录是否拦截 
    final boolean intercepted;
    
    if (actionMasked == MotionEvent.ACTION_DOWN
        || mFirstTouchTarget != null) {
        
        //判断是否设置了FLAG_DISALLOW_INTERCEPT这个标记位,默认为false
        //disallowIntercept表明禁止拦截判断
        final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
        
        if (!disallowIntercept) {
            //关键看这里
            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;
    }     
    ......
}
复制代码

前面咱们知道了mFirstTouchTarget为null，因此说只要是ACTION_DOWN事件，就会进入到if (actionMasked == MotionEvent.ACTION_DOWN|| mFirstTouchTarget != null) {}该方法块内，由于咱们没有设置FLAG_DISALLOW_INTERCEPT属性，因此它为默认为false，因此进入到了if (!disallowIntercept) {}方法块内，调用了onInterceptTouchEvent()方法。这里就解释了为什么默认状况下dispatchTouchEvent()后会调用onInterceptTouchEvent()方法。

接下来咱们看下if (onFilterTouchEventForSecurity(ev)) {}方法块其他部分源码

if (onFilterTouchEventForSecurity(ev)) {
    ......
        if (!canceled && !intercepted) {
        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 (!canViewReceivePointerEvents(child)
                || !isTransformedTouchPointInView(x, y, child, null)) {
                ev.setTargetAccessibilityFocus(false);
                continue;
            }
            
            newTouchTarget = getTouchTarget(child);
            if (newTouchTarget != null) {                      
                newTouchTarget.pointerIdBits |= idBitsToAssign;
                break;
            }
            
            resetCancelNextUpFlag(child);
            //调用子元素的dispatchTouchEvent方法
            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;
            }                           
    }            
}
复制代码

在上一个方法块中，intercepted=onInterceptTouchEvent()的返回值，当不拦截的时候，intercepted==false，进入到if (!canceled && !intercepted) {}方法块内。能够看到咱们经过for循环遍历了全部的子元素，而后判断子元素是否可以接收到点击事件。判断子元素是否可以接收点击事件由两点决定：一、canViewReceivePointerEvents(child)判断点击事件坐标是否落在子元素的区域内，二、isTransformedTouchPointInView(x, y, child, null)判断子元素是否在播放动画。

因此说当onInterceptTouchEvent()返回false时，触发了点击事件，返回true时没有触发。

若知足这两个条件，则事件传递给它处理。有一个为ture则不会进入到该if (!canceled && !intercepted) {}方法块内，而是执行下面的代码。

if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {}这个方法块，dispatchTransformedTouchEvent()实际上是调用子元素的dispatchTouchEvent()方法，dispatchTransformedTouchEvent()源码以下：

private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,View child, int desiredPointerIdBits) {
    
    ......
    if (child == null) {
        //child为null,调用父类的dispatchTouchEvent方法，ViewGroup父类为View，因此是调用View的dispatchTouchEvent方法。
        handled = super.dispatchTouchEvent(transformedEvent);
    } else {
        final float offsetX = mScrollX - child.mLeft;
        final float offsetY = mScrollY - child.mTop;
        transformedEvent.offsetLocation(offsetX, offsetY);
        if (! child.hasIdentityMatrix()) {
            transformedEvent.transform(child.getInverseMatrix());
        }
        
       	//child不为null 
        handled = child.dispatchTouchEvent(transformedEvent);
    }
    ......

}
复制代码

能够看到当child不为null时，调用child.dispatchTouchEvent(transformedEvent)，完成了从ViewGroup到View的事件分发。

7.3 事件怎么从ViewGroup分发到View中的

在上面的源码中，ViewGroup的dispatchTouchEvent方法内，当onInterceptTouchEvent返回false时，会调用dispatchTransformedTouchEvent()方法，而该方法内会调用View的dispatchTouchEvent，在这里实现了事件从ViewGroup到View的事件分发。

7.4 小结：ViewGroup分发的流程图

8. View的事件分发

8.1 Demo演示

（1） 自定义一个MyButton，继承自Button，重写dispatchTouchEvent()和onTouchEvent()方法并打印日志

public class MyButton extends AppCompatButton {
    
    @Override
    public boolean dispatchTouchEvent(MotionEvent event) {        
        Log.i(TAG, "dispatchTouchEvent: ");        
        return super.dispatchTouchEvent(event);
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {

        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                Log.i(TAG, "onTouchEvent: ACTION_DOWN");
                break;
            default:
                break;
        }
        return super.onTouchEvent(event);
    }       
}
复制代码

（2） 在Activity布局中，放入该控件

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".viewdiapatch.ViewDispatchActivity">

    <com.ld.eventdispatchdemo.viewdiapatch.MyButton   
        android:id="@+id/btn_click"
        android:text="view的点击事件分发"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:clickable="true"/>
</LinearLayout>
复制代码

（3） 在Activity内为按钮添加点击事件和touch事件

public class ViewDispatchActivity extends AppCompatActivity {
    
    private static final String TAG = "Activity_viewDispatch";
    private Button btnClick;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        btnClick = findViewById(R.id.btn_click);
        btnClick.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.i(TAG, "onClick: ");                
            }
        });
        
        btnClick.setOnTouchListener(new View.OnTouchListener() {
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                switch (event.getAction()) {
                    case MotionEvent.ACTION_DOWN:
                        Log.i(TAG, "onTouch: ");
                        break;
                }
                //这里暂时先返回false查看日志
                return false; // 返回false，onTouchEvent会被调用
            }
        });
    }    
}
复制代码

当按钮的onTouch()方法的返回值为false时，打印的log日志为：

MyButton_viewDispatch: dispatchTouchEvent: 
Activity_viewDispatch: onTouch: 
MyButton_viewDispatch: onTouchEvent: ACTION_DOWN
MyButton_viewDispatch: dispatchTouchEvent: 
MyButton_viewDispatch: dispatchTouchEvent: 
MyButton_viewDispatch: dispatchTouchEvent: 
MyButton_viewDispatch: dispatchTouchEvent: 
MyButton_viewDispatch: dispatchTouchEvent: 
Activity_viewDispatch: onClick: 
复制代码

当按钮的onTouch()方法的返回值为true时，打印的log日志为：

MyButton_viewDispatch: dispatchTouchEvent: 
Activity_viewDispatch: onTouch: 
MyButton_viewDispatch: dispatchTouchEvent: 
MyButton_viewDispatch: dispatchTouchEvent: 
MyButton_viewDispatch: dispatchTouchEvent: 
MyButton_viewDispatch: dispatchTouchEvent: 
MyButton_viewDispatch: dispatchTouchEvent: 
复制代码

能够看到当View的onTouch()方法返回false时，View的onTouchEvent()方法和onClick()方法会被调用，当返回true时，这两个方法都不会被调用。这是什么缘由呢？

8.2 源码解析

目的：

一、想得知为什么View的onTouch()返回false时，它的onTouchEvent()和onClick()方法会被调用，而返回false时都不会被调用。

咱们看View的dispatchTouchEvent()方法源码

public boolean dispatchTouchEvent(MotionEvent event) {
	......
    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;
        }
    }
    ......
}
复制代码

(mViewFlags & ENABLED_MASK) == ENABLED表明控件enable，li.mOnTouchListener表明其设置的OnTouchListener，当咱们为View经过setOnTouchListener()方法设置touch监听事件时，li.mOnTouchListener就不为空。li.mOnTouchListener.onTouch(this, event)表明onTouch()方法的返回值。

因此说当咱们设置了onTouch监听事件并返回false时，源码这里的result=false，因此if(!result&&onTouchEvent(event))内的onTouchEvent方法会被调用。

当onTouch()返回true时，if(!result&&onTouchEvent(event))内!result==false，因此后面的onTouchEvent()方法不会被调用。

onTouchEvent()不被调用的时候，onClick()也不会被调用，他俩可能有关系，咱们看下onTouchEvent()的源码

public boolean onTouchEvent(MotionEvent event) {
    
    final boolean clickable = ((viewFlags & CLICKABLE) == CLICKABLE
		|| (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
		|| (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE;
    
    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 (clickable || (viewFlags & TOOLTIP) == TOOLTIP) {
        switch (action) {
            case MotionEvent.ACTION_UP:
                ......
                if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {  
                    ......
                    if (!mHasPerformedLongPress && !mIgnoreNextUpEvent) {
                        removeLongPressCallback();
                        if (!focusTaken) {
                            if (mPerformClick == null) {
                                mPerformClick = new PerformClick();
                            }
                            if (!post(mPerformClick)) {
                                performClickInternal();
                            }
                        }                    
                    }                               
			break;        
		return true;
	}        
    return false;            
}
复制代码

由其中的

final boolean clickable = ((viewFlags & CLICKABLE) == CLICKABLE
	|| (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
	|| (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE;
复制代码

能够看到，只要View的clickable和longclickable有一个为true，那么clickable就会为true。而后会进入到switch语句中，在通过各类判断后会执行到performClickInternal()方法，而该方法源码为如下内容

private boolean performClickInternal() {    
    notifyAutofillManagerOnClick();
    return performClick();
}
复制代码

能够看到调用了performClick()方法，接下来看它的源码

public boolean performClick() {
       
    notifyAutofillManagerOnClick();    
    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);   
    notifyEnterOrExitForAutoFillIfNeeded(true);    
    return result;
}
复制代码

能够看到li.mOnClickListener.onClick(this);，调用了click方法，因此说onCLick()方法在onTouchEvent()方法内被调用，onTouchEvent不被执行，那么onCLick必定不会执行。

8.3 小结：View分发的流程图

9. 一个U形图解释

10. 总结

其实若是只是想逻辑的话也很好理解。

dispatchTouchEvent表明分发事件，onInterceptTouchEvent()表明拦截事件，onTouchEvent()表明消耗事件，由本身处理。

默认状态下事件是按照从Activity到ViewGroup再到View的顺序进行分发的，分发下去处不处理是另外一回事，分发完成后，不处理则向上一层回调，调用上一层的onTouchEvent进行处理事件，若onTouchEvent返回true，则表示在该层消耗了事件，若返回false，表示事件还没被处理，须要再向上回调一层，调用上一层的onTouchEvent方法。

以上就是所有内容，第一次分析源码，有错误的地方还望指出，参考文章大神写得也很详细，必定要看看。

多说一句，看源码确实很头大，尤为在看不懂却还要看到这么多文字就更耐不下心来了，可是当我看到一篇文章下的一个评论时，确实是激励了我，不懂就多读，没有解决不了的问题！

11. 参考文章

Android事件分发——ViewGroup篇

Android事件分发机制彻底解析，带你从源码的角度完全理解(下)

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

图解 Android 事件分发机制

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程