Android事件分发原理

最新推荐文章于 2023-04-21 17:22:50 发布
最新推荐文章于 2023-04-21 17:22:50 发布
阅读量195 收藏 1
点赞数
分类专栏： android源码解读 android基础教程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qinwei1993/article/details/108977580
版权

文章目录

Android 事件分发

阅读完之后，你可以学到以下知识

  • 事件分发原理
  • 解决view之间交互冲突

1、事件组成以及传递顺序

1.1、触摸事件的组成
  • 1个down
  • n个move
  • 1个up
  • 0｜1 个cancel
1.2、传递顺序

Activity —> PhoneWindow —> DecorView —> ViewGroup —>… —> View

使用的是责任链设计模式，又上层往下层传递，如果有下层组建消费任务则结束，如果没有消费则交给上层自己处理

1.3、涉及的核心方法
  1. dispatchTouchEvent 分发事件
  2. onInterceptTouchEvent 拦截事件
  3. li.mOnTouchListener.onTouch 由开发者来处理事件
  4. onTouchEvent 处理用户产生的事件
  5. requestDisallowInterceptTouchEvent 控制父view拦截功能

其中1，2，3，4方法会返回一个值

true : 代表事件被处理，不会继续传递

false : 事件继续往下传递

2、View的事件分发

dispatchTouchEvent -> li.mOnTouchListener.onTouch -> onTouchEvent -> li.mOnClickListener.onClick

2.1、dispatchTouchEvent

分发触摸事件

public boolean dispatchTouchEvent(MotionEvent event) {
 		//...
  if (onFilterTouchEventForSecurity(event)) {
   	//...
    //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;
    }
  }
	//...
  return result;
}

第7行到第9行4个条件决定了result的值，result控制onTouchEvent方法调用

  1. li != null（mListenerInfo不为空）

    用户设置了事件(比如点击事件) - 条件为true

  2. li.mOnTouchListener != null （view设置了OnTouchListener）

    设置了触摸事件 - 条件为true

  3. (mViewFlags & ENABLED_MASK) == ENABLED

    控件不可用（默认可用）- 条件为true

  4. li.mOnTouchListener.onTouch(this, event)

    设置触摸事件onTouch方法返回true - 条件为true

2.2、mOnTouchListener.onTouch

触摸事件

public interface OnTouchListener {
  /**
         * Called when a touch event is dispatched to a view. This allows listeners to
         * get a chance to respond before the target view.
         *
         * @param v The view the touch event has been dispatched to.
         * @param event The MotionEvent object containing full information about
         *        the event.
         * @return True if the listener has consumed the event, false otherwise.
         */
  boolean onTouch(View v, MotionEvent event);
}
2.3、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();

  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 (mTouchDelegate != null) {
    if (mTouchDelegate.onTouchEvent(event)) {
      return true;
    }
  }
  if (clickable || (viewFlags & TOOLTIP) == TOOLTIP) {
    switch (action) {
      case MotionEvent.ACTION_UP:
        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)) {
                performClickInternal();
              }
            }
          }
          if (mUnsetPressedState == null) {
            mUnsetPressedState = new UnsetPressedState();
          }
          if (prepressed) {
            postDelayed(mUnsetPressedState,
                        ViewConfiguration.getPressedStateDuration());
          } else if (!post(mUnsetPressedState)) {
            // If the post failed, unpress right now
            mUnsetPressedState.run();
          }
          removeTapCallback();
        }
        mIgnoreNextUpEvent = false;
        break;
      case MotionEvent.ACTION_DOWN:
        break;
      case MotionEvent.ACTION_CANCEL:
        break;
      case MotionEvent.ACTION_MOVE:
        break;
    }
    return true;
  }
  return false;
}

54，55行 case MotionEvent.ACTION_UP 经过一些处理到达performClickInternal方法

private boolean performClickInternal() {
  // Must notify autofill manager before performing the click actions to avoid scenarios where
  // the app has a click listener that changes the state of views the autofill service might
  // be interested on.
  notifyAutofillManagerOnClick();
  return performClick();
}

在看performClick

public boolean performClick() {
  // We still need to call this method to handle the cases where performClick() was called
  // externally, instead of through performClickInternal()
  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;
}

第9行执行了li.mOnClickListener.onClick通知上层控件被点击了

补下OnClickListener源码

public interface OnClickListener {
  /**
         * Called when a view has been clicked.
         *
         * @param v The view that was clicked.
         */
  void onClick(View v);
}

场景1：button注册点击事件,触摸事件

action -> 点击按钮 ，代码执行流程如下

1、上层li.mOnTouchListener.onTouch返回为true：

​ dispatchTouchEvent -> li.mOnTouchListener.onTouch

2、上层li.mOnTouchListener.onTouch返回为false：

​ dispatchTouchEvent -> li.mOnTouchListener.onTouch -> li.mOnClickListener.onClick

总结

  1. 点击事件是在onTouchEvent中触发的
  2. onTouch触摸事件被消费，则不会产生li.mOnClickListener.onClick 事件
  3. 发现按钮点击事件不响应看dispatchTouchEvent 在看 onTouch

3、ViewGroup事件分发

dispatchTouchEvent->onInterceptTouchEvent-> li.mOnTouchListener.onTouch -> onTouchEvent

li.mOnTouchListener.onTouch，onTouchEvent跟View的事件传递是一直的

下面主要分析一下

  • dispatchTouchEvent
  • onInterceptTouchEvent
3.1、dispatchTouchEvent

ViewGroup重写了view的dispatchTouchEvent方法

主要做了一下几件事情

  1. 拦截事件分发
  2. 事件传递给子view
public boolean dispatchTouchEvent(MotionEvent ev) {
    final int action = ev.getAction();
    final float xf = ev.getX();
    final float yf = ev.getY();
    final float scrolledXFloat = xf + mScrollX;
    final float scrolledYFloat = yf + mScrollY;
    final Rect frame = mTempRect;
    boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
    if (action == MotionEvent.ACTION_DOWN) {
        if (mMotionTarget != null) {
            mMotionTarget = null;
        }
        if (disallowIntercept || !onInterceptTouchEvent(ev)) {
            ev.setAction(MotionEvent.ACTION_DOWN);
            final int scrolledXInt = (int) scrolledXFloat;
            final int scrolledYInt = (int) scrolledYFloat;
            final View[] children = mChildren;
            final int count = mChildrenCount;
            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);
                    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;
                        if (child.dispatchTouchEvent(ev))  {
                            mMotionTarget = child;
                            return true;
                        }
                    }
                }
            }
        }
    }
    boolean isUpOrCancel = (action == MotionEvent.ACTION_UP) ||
            (action == MotionEvent.ACTION_CANCEL);
    if (isUpOrCancel) {
        mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
    }
    final View target = mMotionTarget;
    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);
    }
    if (!disallowIntercept && onInterceptTouchEvent(ev)) {
        final float xc = scrolledXFloat - (float) target.mLeft;
        final float yc = scrolledYFloat - (float) target.mTop;
        mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;
        ev.setAction(MotionEvent.ACTION_CANCEL);
        ev.setLocation(xc, yc);
        if (!target.dispatchTouchEvent(ev)) {
        }
        mMotionTarget = null;
        return true;
    }
    if (isUpOrCancel) {
        mMotionTarget = null;
    }
    final float xc = scrolledXFloat - (float) target.mLeft;
    final float yc = scrolledYFloat - (float) target.mTop;
    ev.setLocation(xc, yc);
    if ((target.mPrivateFlags & CANCEL_NEXT_UP_EVENT) != 0) {
        ev.setAction(MotionEvent.ACTION_CANCEL);
        target.mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;
        mMotionTarget = null;
    }
    return target.dispatchTouchEvent(ev);
}

第13行 有两个条件disallowIntercept || !onInterceptTouchEvent(ev)

  • disallowIntercept

    是否禁用掉事件拦截的功能，默认是false。可通过requestDisallowInterceptTouchEvent修改

  • onInterceptTouchEvent

    拦截控件的触摸功能

源码执行流程

  1. disallowIntercept 为false 尝试事件拦截，进入onInterceptTouchEvent

  2. disallowIntercept 为true 不需要尝试事件拦截，不执行onInterceptTouchEvent

3.2、onInterceptTouchEvent

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

  • onInterceptTouchEvent返回true代表拦截触摸事件

    此后事件将交给当前控件来处理，调用super.dispatchTouchEvent() 也就是View.dispatchTouchEvent()

  • onInterceptTouchEvent返回false代表不拦截触摸事件

    匹配子view，匹配到之后传递给子view，调用child.dispatchTouchEvent(ev)

最后走的是View的事件传递:

dispatchTouchEvent -> li.mOnTouchListener.onTouch -> onTouchEvent -> li.mOnClickListener.onClick

4、事件冲突解决方法

一个布局中有多个可滑动的控件，就会存在滑动冲突的问题

举个栗子：

首页页面组成：Banner、功能菜单、列表item

  • 主view为ListView
  • Banner为ViewPager
  • ListView里面header是一个ViewPager

交互

  • ListView交互是上下滑动
  • ViewPager交互是左右滑动

用户想滑动ViewPager，ListView也滑动了 导致体验很不好

这个案例中ListView是父View，ViewPager是子View

事件传递顺序

ListView -> ViewPager

因为是滑动冲突，我们只要关注滑动事件move即可

下面说下两种解决方法

  1. 内部拦截法
  2. 外部拦截法
4.1、内部拦截法

左右滑动是触发ViewPager

内部指的是ViewPager

dispatchTouchEvent方法 中进行处理冲突

private float mInitialTouchX;
private float mInitialTouchY;

@Override
public boolean dispatchTouchEvent(MotionEvent event) {
  switch (event.getAction()) {
    case MotionEvent.ACTION_DOWN:
      mInitialTouchY = event.getY();
      mInitialTouchX = event.getX();
      break;
    case MotionEvent.ACTION_MOVE:
      float moveX = event.getX() - mInitialTouchX;
      float moveY = event.getY() - mInitialTouchY;
      if (Math.abs(moveX) - Math.abs(moveY) < 0) {
         //核心逻辑 
        getParent().requestDisallowInterceptTouchEvent(true);
      }
      mInitialTouchY = event.getY();
      mInitialTouchX = event.getX();
      break;
    case MotionEvent.ACTION_UP:
      getParent().requestDisallowInterceptTouchEvent(false);
      break;
    default:
      break;
  }
  return super.dispatchTouchEvent(event);
}

核心逻辑：x轴移动距离大于y轴则代表用户操作的是上下滑动。

第16行 getParent().requestDisallowInterceptTouchEvent(true); 禁用父view（ListView）拦截，将事件传递给ViewPager来处理

这样处理之后move事件，一旦符合view的滑动规则，子view告诉父view后续产生的的move事件都交给自己来处理，所以此时只有一个view（ViewPager）能拿到move事件

4.2、外部拦截法

上下滑动是触发ListView

这里外部指的就是ListView

也是在dispatchTouchEvent方法处理

private float mInitialTouchX;
private float mInitialTouchY;

@Override
public boolean dispatchTouchEvent(MotionEvent event) {
  switch (event.getAction()) {
    case MotionEvent.ACTION_DOWN:
      mInitialTouchY = event.getY();
      mInitialTouchX = event.getX();
      break;
    case MotionEvent.ACTION_MOVE:
      float moveX = event.getX() - mInitialTouchX;
      float moveY = event.getY() - mInitialTouchY;
      mInitialTouchY = event.getY();
      mInitialTouchX = event.getX();
      if (Math.abs(moveX) - Math.abs(moveY) > 0) {
         //核心逻辑 
        return true;
      }
      break;
    case MotionEvent.ACTION_UP:
      getParent().requestDisallowInterceptTouchEvent(false);
      break;
    default:
      break;
  }
  return super.dispatchTouchEvent(event);
}

核心逻辑： y轴移动距离大于x轴则代表用户操作的是上下滑动

第18行 return true; 事件拦截后，交给自己处理。事件将不会分发到ViewPager

使用哪种方案合适

  1. 看view冲突是子view还是父view
  2. 滑动意图是希望父view滑动，则采用外部拦截法
  3. 滑动意图是希望子view滑动，则采用内部拦截法

文章有什么不对的地方，请大家斧正

qinwei1993
关注
专栏目录
全面解析Android事件分发机制：一篇足矣！
2401_84132685的博客
04-19 663
当一个点击事件发生时，从Activity的事件分发开始（方法总结那么，ViewGroup的什么时候返回truefalse？请继续往下看ViewGroup事件的分发机制2.2 ViewGroup事件的分发机制从上面Activity事件分发机制可知，ViewGroup事件分发机制从开始Android事件分发总是先传递到ViewGroup、再传递到View过程：当点击了某个控件时核心方法总结每当控件被点击时：onTouch（）的执行 先于onClick（）核心方法总结。
Android事件分发机制
ucasyzj的博客
06-27 1710
最近在学习安卓的事件分发机制，实际上到目前为止还没有写过自定义View，在自定义View中如果需要能够响应手指的点击或者滑动事件就需要处理事件的分发，否则很容易出现冲突。写这篇博客是为了让自己能够更好的消化吸收，同时以后忘了能够很快的捡回来。此篇主要参考。
一张流体图带你完全搞懂Android的View事件分发机制并结合源码详解
SunshineBoy的博客
09-25 2091
首先咱们先看一下流程图： 首先Activity中点击事件其实就是触发触摸事件，会调dispatchTouchEvent(MotionEvent ev)，咱们先看一下Activity的源码： public boolean dispatchTouchEvent(MotionEvent ev) { if (ev.getAction() == MotionEvent.ACTION_DOWN) { onUserInteraction(); }
android事件分发流程图
kaibingwang的博客
04-23 1798
android手机基于用户的手指触摸来和用户进行交互，如你需要点击某个按钮进行跳转到另外一个页面；上下滑动列表看下一页的列表数据；或者横向水平滑动看下一个tab页面，这其中都涉及到事件分发机制，它们之间遵循着哪种规则呢？ 如下图所示，是android中常见的视图结构，当我点击view的时候，最先响应的是它的父容器viewGroup,执行事件分发dispatchTouchEvent(Motio...
Android---事件分发机制原理讲述
老王博客
01-12 594
事件分发机制讲解
Android 事件分发机制详解
Stackvoid小菜
10-08 1168
更多内容请参照我的个人站点： http://stackvoid.com/ 网上很多关于Android事件分发机制的解释，大多数描述的都不够清晰，没有吧来龙去脉搞清楚，本文将带你从Touch事件产生到Touch事件被消费这一全过程作全面的剖析。 产生Touch事件 这部分牵扯到硬件和Linux内核部分；我们简单讲述一下这部分内容，如果有兴趣的话可以参考这篇文章。 传递Touc
Android事件分发原理讲解文档
最新发布
05-27
Android事件分发原理讲解文档Android事件分发原理讲解文档Android事件分发原理讲解文档Android事件分发原理讲解文档Android事件分发原理讲解文档Android事件分发原理讲解文档Android事件分发原理讲解文档Android事件...
Android 事件分发机制视频讲解
11-07
### Android 事件分发机制详解 ...掌握了事件分发的基本原理后，开发者可以根据实际需求灵活地控制事件的流向，从而优化应用的交互体验。希望本文能够帮助广大Android开发者更好地应对实际开发中的各种挑战。
Android事件分发原理详解
佩琪的铁锤的博客
08-27 516
Android事件分发机制是android工程师必须掌握的基础知识，网上关于事件分发的文章有很多，这里我来阐述下自己对事件分发的看法。 MotionEvent 何为事件？事件就是用户手指触摸屏幕时，产生的的一系列触摸行为。Android中将事件定义为MotionEvent，其中事件的类型又分为四种： ACTION_DOWN：按下 ACTION_MOVE：滑动 ACTION_UP：抬起，对应ACT...
Android View 事件分发机制 源码解析 （上）
810364804
09-02 729
一直想写事件分发机制的文章，不管咋样，也得自己研究下事件分发的源码，写出心得~ 首先我们先写个简单的例子来测试View的事件转发的流程~ 1、案例 为了更好的研究View的事件转发，我们自定以一个MyButton继承Button，然后把跟事件传播有关的方法进行复写，然后添加上日志~ MyButton package com.example.zhy_event03; import android...
Android View的事件分发机制
s003603u的专栏
07-29 977
Android View的事件分发机制
Android View事件分发机制
weixin_33858485的博客
10-18 121
作为程序猿，最不想 看的但是也不得不去看的就是源码！所谓知其然也要知其所以然，神秘的大佬曾经说过进阶的方法就是READ THE FUCKING CODE！ 认识MotionEvent 负责集中处理所有类型设备的输入事件.我们对屏幕的点击，滑动，抬起等一系的动作都是由一个一个MotionEvent对象组成的。 主要事件类型 ACTION_DOWN 手机初次触摸到屏幕事件 ACTION_M...
Android 事件分发机制原理总结
愿你的微笑化成风的专栏
02-14 377
事件定义 当手指接触屏幕时，产生触摸行为（Touch事件），有4种事件类型： MotionEvent.ACTION_DOWN 手指刚接触屏幕 MotionEvent.ACTION_UP 手指从屏幕松开 MotionEvent.ACTION_MOVE 手指在屏幕上滑动 MotionEvent.ACTION_CANCEL 非人为因素取消 事件分发对象 Activity : 控制生命周期 & 处理事件 ViewGroup : 一组View的集合 View : 所有UI组件的基类
Android事件分发-基础原理和场景分析
m0_56255097的博客
04-21 133
（1）整个分发过程中没有任何拦截和消费，DOWN 事件会层层往下分发，并层层往上返回 false，MOVE 和 UP 事件则会交给 Activity 的 onTouchEvent 方法进行处理，不再往下分发（2）分发过程中没有任何拦截但有消费，DOWN 事件会层层往下分发，并层层往上返回false，直到有消费返回 true，MOVE 和 UP 事件则会层层往下分发，最后直接交给消费事件的 View 进行处理，然后层层返回 true。
Android的View事件分发机制原理
wodongx123的博客
03-12 647
L型链和U型链 WindowManagerService是一个独立的进程，拥有自己的main方法。它的内部有一个各种各样的集合用于存放各种各样状态的Activity WindowManagerService接收到屏幕的点击事件后，就会分发给其内部正在显示的activity，这个就是activity的点击事件被分发的基本原理。 总之Acitivity的dispatchTouchEvent就是这样被调用的，而MotionEvent也是WindowManagerService生成的。 dispatchTouch.
Android View 事件分发机制
qq_14931305的博客
08-08 1486
View事件分发机制
Android View事件的分发机制（图解）
Chance00的博客
08-13 439
学习了Android View事件的分发机制，绘制了一个流程图，用作复习总结：
一文读懂Android View事件分发机制
学无止尽，生命不息..
05-23 9612
Android View 虽然不是四大组件，但其并不比四大组件的地位低。而View的核心知识点事件分发机制则是不少刚入门同学的拦路虎。ScrollView嵌套RecyclerView(或者ListView)的滑动冲突这种老大难的问题的理论基础就是事件分发机制。 事件分发机制面试也会经常被提及，如果你能get到要领，并跟面试官深入的灵魂交流一下，那么一定会让面试官对你印象深刻，
深入解析Android事件分发机制
"本文将深入探讨Android事件分发机制，包括View和ViewGroup的事件...Android事件分发机制是Android开发中不可或缺的一部分，理解其工作原理有助于开发者更好地控制应用的用户交互，提供更加流畅、符合预期的用户体验。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值