View 的事件分发机制

2018-07-26 本文已影响442人 Eren丶耶格尔

目的

安卓上面的 View 是树形结构的，View 可能会重叠在一起，当我们点击的地方有多个 View 都可以响应的时候，这个点击事件应该给谁呢？为了解决这一个问题，就有了事件分发机制。

（一）View的事件分发机制

MontionEvent 点击事件的分发过程由三个很重要的方法来共同完成：
dispatchTouchEvent、onInterceptTouchEvent 和 onTouchEvent

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

1. View 的事件分发机制

当点击事件产生后，事件首先会传递给当前 Activity，这会调用 Activity 的 dispatchTouchEvent 方法，具体的事件处理工作都交由 Activity 中的 PhoneWindow 来完成，然后 PhoneWindow 再把事件处理工作交给 DecorView，之后再由 DecorView 将事件处理工作交给最顶级的 ViewGroup，依次传递给子 View

分发拦截方法

2. 点击事件的传递规则

上述的三种方法的关系，如下 伪代码：

public boolean diapatchTouchEvent(MotionEvent event){
   boolean consume = false;
   //判断是否拦截
   if(onIntercetTouchEvent(ev)){ //拦截
      consume = onTouchEvent(ev);//消费事件
   }else{
      consume = child.dispatchTouchEvent(ev);//chileView开始事件分发
   }
   return consume;  //返回事件拦截结果 默认为false
}

通过上述代码，我们大致了解点击事件的传递规则：

对于一个根 ViewGroup 来说，点击事件产生后，首先会传递给它，这时它的 dispatchTouchEvent 就会被调用，如果这个 ViewGroup 的 onInterceptTouchEvent 方法返回 true 就表示它要拦截当前事件，接着事件就交给这个 ViewGroup 处理，即它的 onTouchEvent 方法就会被调用；如果这个 ViewGroup 的 onInterceptTouchEvent 方法返回的 false 就表示它不拦截当前事件，这时当前事件就会继续传递给它的子元素，接着子元素的 disptchTouchEvent 方法就会被调用，如此反复直到事件被最终处理

（二）事件分发的源码解析

1. Activity 对点击事件的分发过程

当一个点击事件发生时，事件最先传到当前 Activity 的 dispatchTouchEvent 进行事件分发，之后事件传递给 Window，Window 是个抽象类，它的唯一实现类是 PhoneWindow，PhoneWindow 又将事件直接传递给了 DecorView，这个 DecorView 类是 PhoneWindow 类的一个内部类 DecorView 继承自 FrameLayout，是所有界面的父类，FrameLayout 是 ViewGroup 的子类，故 DecorView 的间接父类 = ViewGroup（顶级 View）

源码如下：

public boolean dispatchTouchEvent(MotionEvent ev) {
    if (ev.getAction() == MotionEvent.ACTION_DOWN) {
        onUserInteraction();
    }
    if (getWindow().superDispatchTouchEvent(ev)) {
        return true;
    }
    return onTouchEvent(ev);
}

首先，事件开始交给 Activity 所附属的 Window 进行分发，如果返回 true，整个事件循环就结束了，返回 false 意味着事件没人处理，所有 View 的 onTouchEvent 都返回了 false，那么 Activity 的 onTouchEvent 就会被调用

示意图

2. ViewGroup 事件的分发过程

点击事件传递到 ViewGroup（顶级 View），ViewGroup 的事件分发机制也是从 dispatchTouchEvent 开始

源码如下：

public boolean dispatchTouchEvent(MotionEvent ev) { 

    ... // 仅贴出关键代码

        // 重点分析1：ViewGroup每次事件分发时，都需调用onInterceptTouchEvent()询问是否拦截事件
            if (disallowIntercept || !onInterceptTouchEvent(ev)) {  

            // 判断值1：disallowIntercept = 是否禁用事件拦截的功能(默认是false)，可通过调用requestDisallowInterceptTouchEvent（）修改
            // 判断值2： !onInterceptTouchEvent(ev) = 对onInterceptTouchEvent()返回值取反
                    // a. 若在onInterceptTouchEvent()中返回false（即不拦截事件），就会让第二个值为true，从而进入到条件判断的内部
                    // b. 若在onInterceptTouchEvent()中返回true（即拦截事件），就会让第二个值为false，从而跳出了这个条件判断
                    // c. 关于onInterceptTouchEvent() ->>分析1

                ev.setAction(MotionEvent.ACTION_DOWN);  
                final int scrolledXInt = (int) scrolledXFloat;  
                final int scrolledYInt = (int) scrolledYFloat;  
                final View[] children = mChildren;  
                final int count = mChildrenCount;  

        // 重点分析2
            // 通过for循环，遍历了当前ViewGroup下的所有子View
            for (int i = count - 1; i >= 0; i--) {  
                final View child = children[i];  
                if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE  
                        || child.getAnimation() != null) {  
                    child.getHitRect(frame);  

                    // 判断当前遍历的View是不是正在点击的View，从而找到当前被点击的View
                    // 若是，则进入条件判断内部
                    if (frame.contains(scrolledXInt, scrolledYInt)) {  
                        final float xc = scrolledXFloat - child.mLeft;  
                        final float yc = scrolledYFloat - child.mTop;  
                        ev.setLocation(xc, yc);  
                        child.mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;  

                        // 条件判断的内部调用了该View的dispatchTouchEvent()
                        // 即 实现了点击事件从ViewGroup到子View的传递（具体请看下面的View事件分发机制）
                        if (child.dispatchTouchEvent(ev))  { 

                        mMotionTarget = child;  
                        return true; 
                        // 调用子View的dispatchTouchEvent后是有返回值的
                        // 若该控件可点击，那么点击时，dispatchTouchEvent的返回值必定是true，因此会导致条件判断成立
                        // 于是给ViewGroup的dispatchTouchEvent（）直接返回了true，即直接跳出
                        // 即把ViewGroup的点击事件拦截掉

                                }  
                            }  
                        }  
                    }  
                }  
            }  
            boolean isUpOrCancel = (action == MotionEvent.ACTION_UP) ||  
                    (action == MotionEvent.ACTION_CANCEL);  
            if (isUpOrCancel) {  
                mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;  
            }  
            final View target = mMotionTarget;  

        // 重点分析3
        // 若点击的是空白处（即无任何View接收事件） / 拦截事件（手动复写onInterceptTouchEvent（），从而让其返回true）
        if (target == null) {  
            ev.setLocation(xf, yf);  
            if ((mPrivateFlags & CANCEL_NEXT_UP_EVENT) != 0) {  
                ev.setAction(MotionEvent.ACTION_CANCEL);  
                mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;  
            }  
            
            return super.dispatchTouchEvent(ev);
            // 调用ViewGroup父类的dispatchTouchEvent()，即View.dispatchTouchEvent()
            // 因此会执行ViewGroup的onTouch() ->> onTouchEvent() ->> performClick（） ->> onClick()，即自己处理该事件，事件不会往下传递（具体请参考View事件的分发机制中的View.dispatchTouchEvent（））
            // 此处需与上面区别：子View的dispatchTouchEvent（）
        } 

        ... 

}
/**
  * 分析1：ViewGroup.onInterceptTouchEvent()
  * 作用：是否拦截事件
  * 说明：
  *     a. 返回true = 拦截，即事件停止往下传递（需手动设置，即复写onInterceptTouchEvent（），从而让其返回true）
  *     b. 返回false = 不拦截（默认）
  */
  public boolean onInterceptTouchEvent(MotionEvent ev) {  
    
    return false;

  }

总是先传递到 ViewGroup、再传递到子 View

示意图

2. View 事件的分发机制

源码：

public boolean dispatchTouchEvent(MotionEvent event) {  

        if (mOnTouchListener != null && (mViewFlags & ENABLED_MASK) == ENABLED &&  
                mOnTouchListener.onTouch(this, event)) {  
            return true;  
        } 
        return onTouchEvent(event);  
  }
  // 说明：只有以下3个条件都为真，dispatchTouchEvent()才返回true；否则执行onTouchEvent()
  //     1. mOnTouchListener != null
  //     2. (mViewFlags & ENABLED_MASK) == ENABLED
  //     3. mOnTouchListener.onTouch(this, event)
  // 下面对这3个条件逐个分析


/**
  * 条件1：mOnTouchListener != null
  * 说明：mOnTouchListener变量在View.setOnTouchListener（）方法里赋值
  */
  public void setOnTouchListener(OnTouchListener l) { 

    mOnTouchListener = l;  
    // 即只要我们给控件注册了Touch事件，mOnTouchListener就一定被赋值（不为空）
        
} 

/**
  * 条件2：(mViewFlags & ENABLED_MASK) == ENABLED
  * 说明：
  *     a. 该条件是判断当前点击的控件是否enable
  *     b. 由于很多View默认enable，故该条件恒定为true
  */

/**
  * 条件3：mOnTouchListener.onTouch(this, event)
  * 说明：即 回调控件注册Touch事件时的onTouch（）；需手动复写设置，具体如下（以按钮Button为例）
  */
    button.setOnTouchListener(new OnTouchListener() {  
        @Override  
        public boolean onTouch(View v, MotionEvent event) {  
     
            return false;  
        }  
    });
    // 若在onTouch（）返回true，就会让上述三个条件全部成立，从而使得View.dispatchTouchEvent（）直接返回true，事件分发结束
    // 若在onTouch（）返回false，就会使得上述三个条件不全部成立，从而使得View.dispatchTouchEvent（）中跳出If，执行onTouchEvent(event)

onTouchEvent(event)的源码：

public boolean onTouchEvent(MotionEvent event) {  
    final int viewFlags = mViewFlags;  

    if ((viewFlags & ENABLED_MASK) == DISABLED) {  
         
        return (((viewFlags & CLICKABLE) == CLICKABLE ||  
                (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE));  
    }  
    if (mTouchDelegate != null) {  
        if (mTouchDelegate.onTouchEvent(event)) {  
            return true;  
        }  
    }  

    // 若该控件可点击，则进入switch判断中
    if (((viewFlags & CLICKABLE) == CLICKABLE ||  
            (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {  

                switch (event.getAction()) { 

                    // a. 若当前的事件 = 抬起View（主要分析）
                    case MotionEvent.ACTION_UP:  
                        boolean prepressed = (mPrivateFlags & PREPRESSED) != 0;  

                            ...// 经过种种判断，此处省略

                            // 执行performClick() ->>分析1
                            performClick();  
                            break;  

                    // b. 若当前的事件 = 按下View
                    case MotionEvent.ACTION_DOWN:  
                        if (mPendingCheckForTap == null) {  
                            mPendingCheckForTap = new CheckForTap();  
                        }  
                        mPrivateFlags |= PREPRESSED;  
                        mHasPerformedLongPress = false;  
                        postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());  
                        break;  

                    // c. 若当前的事件 = 结束事件（非人为原因）
                    case MotionEvent.ACTION_CANCEL:  
                        mPrivateFlags &= ~PRESSED;  
                        refreshDrawableState();  
                        removeTapCallback();  
                        break;

                    // d. 若当前的事件 = 滑动View
                    case MotionEvent.ACTION_MOVE:  
                        final int x = (int) event.getX();  
                        final int y = (int) event.getY();  
        
                        int slop = mTouchSlop;  
                        if ((x < 0 - slop) || (x >= getWidth() + slop) ||  
                                (y < 0 - slop) || (y >= getHeight() + slop)) {  
                            // Outside button  
                            removeTapCallback();  
                            if ((mPrivateFlags & PRESSED) != 0) {  
                                // Remove any future long press/tap checks  
                                removeLongPressCallback();  
                                // Need to switch from pressed to not pressed  
                                mPrivateFlags &= ~PRESSED;  
                                refreshDrawableState();  
                            }  
                        }  
                        break;  
                }  
                // 若该控件可点击，就一定返回true
                return true;  
            }  
             // 若该控件不可点击，就一定返回false
            return false;  
        }

/**
  * 分析1：performClick（）
  */  
    public boolean performClick() {  

        if (mOnClickListener != null) {  
            playSoundEffect(SoundEffectConstants.CLICK);  
            mOnClickListener.onClick(this);  
            return true;  
            // 只要我们通过setOnClickListener（）为控件View注册1个点击事件
            // 那么就会给mOnClickListener变量赋值（即不为空）
            // 则会往下回调onClick（） & performClick（）返回true
        }  
        return false;  
    }

onTouch 的执行先于 onClick

示意图

（三）代码举例分析

（1）工作日常演示

老板派发工作，给经理提出需求，经理给组长分发任务，组长再给程序员安排任务
Activity：老板
ManagerViewGroup：经理
LoaderViewGroup：组长
ProgrammerView：程序员

经理代码：

public class ManagerViewGroup extends LinearLayout {
    private final String TAG = "Eren";
    private Paint mPaint;

    public ManagerViewGroup(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    private void init() {
        mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mPaint.setColor(Color.WHITE);
        mPaint.setTextSize(70f);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        canvas.drawText("经理", 30f, getHeight() - 80f, mPaint);
    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        Log.e(TAG, "dispatchTouchEvent ---> 经理接到老板发的任务通知");
        return super.dispatchTouchEvent(ev);
    }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        Log.e(TAG, "onInterceptTouchEvent ---> 经理拦截任务，查看任务通知");
        return super.onInterceptTouchEvent(ev);
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        Log.e(TAG, "onTouchEvent --->经理把自己的任务做了");
        return super.onTouchEvent(event);
    }
}

组长代码：

public class LoaderViewGroup extends LinearLayout {
    private final String TAG = "Eren";
    private Paint mPaint;

    public LoaderViewGroup(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    private void init() {
        mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mPaint.setColor(Color.WHITE);
        mPaint.setTextSize(70f);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        canvas.drawText("组长", 30f, getHeight() - 80f, mPaint);
    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        Log.e(TAG, "dispatchTouchEvent ---> 组长接到经理发的任务通知");
        return true;
    }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        Log.e(TAG, "onInterceptTouchEvent ---> 组长拦截任务，查看任务通知");
        return super.onInterceptTouchEvent(ev);
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        Log.e(TAG, "onTouchEvent --->组长把自己的任务做了");
        return super.onTouchEvent(event);
    }
}

程序员代码：

public class ProgrammerView extends View {
    private final String TAG = "Eren";
    private Paint mPaint;

    public ProgrammerView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    private void init() {
        mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mPaint.setColor(Color.WHITE);
        mPaint.setTextSize(70f);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        canvas.drawText("程序员", 30f, getHeight() - 50f, mPaint);
    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent event) {
        Log.e(TAG, "dispatchTouchEvent ---> 程序员接到组长发的任务通知");
        return super.dispatchTouchEvent(event);
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        Log.e(TAG, "onTouchEvent ---> 程序员把自己的任务做完");
        return super.onTouchEvent(event);
    }
}

布局文件

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.example.eren.toucheventtest.MainActivity">

    <com.example.eren.toucheventtest.ManagerViewGroup
        android:layout_width="270dp"
        android:layout_height="480dp"
        android:background="@color/colorPrimary">

        <com.example.eren.toucheventtest.LoaderViewGroup
            android:layout_width="180dp"
            android:layout_height="320dp"
            android:background="@color/colorAccent">

            <com.example.eren.toucheventtest.ProgrammerView
                android:layout_width="90dp"
                android:layout_height="160dp"
                android:background="@android:color/holo_orange_dark" />
        </com.example.eren.toucheventtest.LoaderViewGroup>

    </com.example.eren.toucheventtest.ManagerViewGroup>

</RelativeLayout>

运行效果

点击程序员，查看Log信息：

Log信息

这个任务所有人都没有进行拦截，最终任务又回到了BOSS那里（愤怒！）

由此可见

事件由上而下传递
传递顺序：

Activity -> Window -> ViewGroup -> View

由下而上消费
消费顺序：

Activity <- Window <- ViewGroup <- View

（2）更改需求
如果这个问题组长就能解决，并且程序员请假没有来，将组长代码中的 onInterceptTouchEvent 返回值改成 true，对事件进行拦截：

    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        Log.e(TAG, "onInterceptTouchEvent ---> 组长拦截任务，查看任务通知");
        return true;
    }

再次点击程序员，查看Log信息：

Log信息

组长对任务进行了拦截，所以不会继续传递，任务完全由组长完成

（3）再次更改需求
程序员没有请假，并且要完成这个任务，将程序员代码中的 onTouchEvent 返回值改成 true，对事件进行消耗

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        Log.e(TAG, "onTouchEvent ---> 程序员把自己的任务做完");
        return true;
    }

再再次点击程序员，查看Log信息：

Log信息

程序员把工作做了，不会再交给上级处理

（4）突发情况
程序员的女朋友约程序员吃饭看电影，程序员接到上级通知，但是依然放弃手头工作陪女朋友（通常情况下是不可能的，因为，程序员根本没有女朋友￣へ￣）

public class MainActivity extends AppCompatActivity {

    private ProgrammerView mProgrammer;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mProgrammer = findViewById(R.id.programmer);
        //女朋友 onTouch 进行事件消费为 true
        mProgrammer.setOnTouchListener(new View.OnTouchListener() {
            @Override
            public boolean onTouch(View view, MotionEvent motionEvent) {
                return true;
            }
        });
    }

点击程序员，查看Log信息：

Log信息

onTouch 方式是 View 的 OnTouchListener 接口中定义的方法，其优先级大于 onTouchEvent（女朋友最重要），手动复写在onTouch 中返回 true（事件消费掉），将不会再执行 onTouchEvent

总结

文章借鉴于：Android事件分发机制详解：史上最全面、最易懂

下一章，将解决 View 的滑动冲突

View 的事件分发机制

目的

（一）View的事件分发机制

1. View 的事件分发机制

2. 点击事件的传递规则

（二）事件分发的源码解析

1. Activity 对点击事件的分发过程

2. ViewGroup 事件的分发过程

2. View 事件的分发机制

（三）代码举例分析

总结

猜你喜欢

热点阅读