Android事件分发机制

谁借莪１个温暖的怀抱￠ 2022-06-04 08:21 385阅读 0赞

文章来自：http://gityuan.com/2015/09/19/android-touch/

一.概述

事件分发有多种类型, 本文主要介绍Touch相关的事件分发.

  • 整个事件分发流程中，会有大量MotionEvent对象，该对象用于记录所有与移动相关的事件，比如手指触摸屏幕事件。
  • 一次完整的MotionEvent事件，是从用户触摸屏幕到离开屏幕。整个过程的动作序列：ACTION_DOWN(1次) -> ACTION_MOVE(N次) ->ACTION_UP(1次),
  • 多点触摸，每一个触摸点Pointer会有一个id和index。对于多指操作，通过pointerindex来获取指定Pointer的触屏位置。比如，对于单点操作时获取x坐标通过getX()，而多点操作获取x坐标通过getX(pointerindex)

对于View,ViewGroup,Activity都能处理Touch事件, 它们之间处理的先后顺序和方法有所不同.

1.1 View

  • View是所有视图对象的父类，实现了动画相关的接口Drawable.Callback， 按键相关的接口KeyEvent.Callback， 交互相关的接口AccessibilityEventSource。比如Button继承自View。
  • TouchEvent事件处理相关的方法： 
  1.  *  dispatchTouchEvent(MotionEvent event)
  2.  *  onTouchEvent(MotionEvent event)

1.2 ViewGroup

  • ViewGroup，是一个abstract类，一组View的集合，可以包含View和ViewGroup,是所有布局的父类或间接父类。继承了View，实现了ViewParent（用于与父视图交互的接口）， ViewManager（用于添加、删除、更新子视图到Activity的接口）。比如常用的LinearLayout，RelativeLayout都是继承自ViewGroup。
  • TouchEvent事件处理相关的方法： 
  1.  *  dispatchTouchEvent(MotionEvent event)
  2.  *  onInterceptTouchEvent(MotionEvent ev)
  3.  *  onTouchEvent(MotionEvent event)

1.3 Activity

  • Activity是Android四大基本组件之一，当手指触摸到屏幕时，屏幕硬件一行行不断地扫描每个像素点，获取到触摸事件后，从底层产生中断上报。再通过native层调用Java层InputEventReceiver中的dispatchInputEvent方法。经过层层调用，交由Activity的dispatchTouchEvent方法来处理。
  • TouchEvent事件处理相关的方法： 
  1.  *  dispatchTouchEvent(MotionEvent event)
  2.  *  onTouchEvent(MotionEvent event)

二. 分发原理

Input系统—进程交互文章的小节[3.3]已介绍事件分发过程的前期工作. 当UI主线程收到底层上报的input事件,便会调用InputEventReceiver.dispachInputEvent方法.
这里写图片描述

2.1 DecorView.dispatchTouchEvent

[-> PhoneWindow.java ::DecorView]

  1. public boolean dispatchTouchEvent(MotionEvent ev) {
  2.     final Callback cb = getCallback();
  3.     // [见小节2.2]
  4.     return cb != null && !isDestroyed() && mFeatureId < 0 ? cb.dispatchTouchEvent(ev)
  5.             : super.dispatchTouchEvent(ev);
  6. }

此处cb是指Window的内部接口Callback. 对于Activity实现了Window.Callback接口. 故接下来调用Activity类.

2.2 Activity.dispatchTouchEvent

[-> Activity.java]

  1. public boolean dispatchTouchEvent(MotionEvent ev) {
  2.     if (ev.getAction() == MotionEvent.ACTION_DOWN) {
  3.         //第一次按下操作时，用户希望能与设备进行交互，可通过实现该方法
  4.         onUserInteraction();
  5.     }
  7.     //获取当前Activity的顶层窗口是PhoneWindow [见小节2.3]
  8.     if (getWindow().superDispatchTouchEvent(ev)) {
  9.         return true;
  10.     }
  11.     //当没有任何view处理时，交由activity的onTouchEvent处理
  12.     return onTouchEvent(ev); // [见小节2.2.1]
  13. }

如果重写Activity的该方法，则会在分发事件之前拦截所有的触摸事件. 另外此处getWindow()返回的是Activity的mWindow成员变量, 该变量赋值过程是在Activity.attach()方法, 可知其类型为PhoneWindow.

2.2.1 Activity.onTouchEvent

[-> Activity.java]

  1. public boolean onTouchEvent(MotionEvent event) {
  2.     //当窗口需要关闭时，消费掉当前event
  3.     if (mWindow.shouldCloseOnTouch(this, event)) {
  4.         finish();
  5.         return true;
  6.     }
  8.     return false;
  9. }

2.3 superDispatchTouchEvent

[-> PhoneWindow.java]

  1. public boolean superDispatchTouchEvent(KeyEvent event) {
  2.     return mDecor.superDispatcTouchEvent(event); // [见小节2.4]
  3. }

PhoneWindow的最顶View是DecorView，再交由DecorView处理。而DecorView的父类的父类是ViewGroup,接着调用 ViewGroup.dispatchTouchEvent()方法。为了精简篇幅，有些中间函数调用不涉及关键逻辑，可能会直接跳过。

2.4 ViewGroup.dispatchTouchEvent

  1. public boolean dispatchTouchEvent(MotionEvent ev) {
  2.     ...
  3.     boolean handled = false;
  4.     //根据隐私策略而来决定是否过滤本次触摸事件,
  5.     if (onFilterTouchEventForSecurity(ev)) {  // [见小节2.4.1]
  6.         final int action = ev.getAction();
  7.         final int actionMasked = action & MotionEvent.ACTION_MASK;
  9.         if (actionMasked == MotionEvent.ACTION_DOWN) {
  10.             // 发生ACTION_DOWN事件, 则取消并清除之前所有的触摸targets
  11.             cancelAndClearTouchTargets(ev);
  12.             resetTouchState(); // 重置触摸状态
  13.         }
  15.         // 发生ACTION_DOWN事件或者已经发生过ACTION_DOWN;才进入此区域，主要功能是拦截器
  16.         //只有发生过ACTION_DOWN事件，则mFirstTouchTarget != null;
  17.         final boolean intercepted;
  18.         if (actionMasked == MotionEvent.ACTION_DOWN
  19.                 || mFirstTouchTarget != null) {
  20.             //可通过调用requestDisallowInterceptTouchEvent，不让父View拦截事件
  21.             final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
  22.             //判断是否允许调用拦截器
  23.             if (!disallowIntercept) {
  24.                 //调用拦截方法
  25.                 intercepted = onInterceptTouchEvent(ev);  // [见小节2.4.2]
  26.                 ev.setAction(action);
  27.             } else {
  28.                 intercepted = false;
  29.             }
  30.         } else {
  31.             // 当没有触摸targets，且不是down事件时，开始持续拦截触摸。
  32.             intercepted = true;
  33.         }
  34.         ...
  37.         //不取消事件，同时不拦截事件, 并且是Down事件才进入该区域
  38.         if (!canceled && !intercepted) {
  39.             //把事件分发给所有的子视图，寻找可以获取焦点的视图。
  40.             View childWithAccessibilityFocus = ev.isTargetAccessibilityFocus()
  41.                     ? findChildWithAccessibilityFocus() : null;
  43.             if (actionMasked == MotionEvent.ACTION_DOWN
  44.                     || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
  45.                     || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
  46.                 final int actionIndex = ev.getActionIndex(); // down事件等于0
  47.                 final int idBitsToAssign = split ? 1 << ev.getPointerId(actionIndex)
  48.                         : TouchTarget.ALL_POINTER_IDS;
  50.                 removePointersFromTouchTargets(idBitsToAssign); //清空早先的触摸对象
  52.                 final int childrenCount = mChildrenCount;
  53.                 //第一次down事件，同时子视图不会空时
  54.                 if (newTouchTarget == null && childrenCount != 0) {
  55.                     final float x = ev.getX(actionIndex);
  56.                     final float y = ev.getY(actionIndex);
  57.                     // 从视图最上层到下层，获取所有能接收该事件的子视图
  58.                     final ArrayList<View> preorderedList = buildOrderedChildList(); // [见小节2.4.3]
  59.                     final boolean customOrder = preorderedList == null
  60.                             && isChildrenDrawingOrderEnabled();
  61.                     final View[] children = mChildren;
  63.                     /* 从最底层的父视图开始遍历， ** 找寻newTouchTarget，并赋予view与 pointerIdBits； ** 如果已经存在找寻newTouchTarget，说明正在接收触摸事件，则跳出循环。 */
  64.                     for (int i = childrenCount - 1; i >= 0; i--) {
  65.                         final int childIndex = customOrder
  66.                                 ? getChildDrawingOrder(childrenCount, i) : i;
  67.                         final View child = (preorderedList == null)
  68.                                 ? children[childIndex] : preorderedList.get(childIndex);
  70.                         // 如果当前视图无法获取用户焦点，则跳过本次循环
  71.                         if (childWithAccessibilityFocus != null) {
  72.                             if (childWithAccessibilityFocus != child) {
  73.                                 continue;
  74.                             }
  75.                             childWithAccessibilityFocus = null;
  76.                             i = childrenCount - 1;
  77.                         }
  78.                         //如果view不可见，或者触摸的坐标点不在view的范围内，则跳过本次循环
  79.                         if (!canViewReceivePointerEvents(child)
  80.                                 || !isTransformedTouchPointInView(x, y, child, null)) {
  81.                             ev.setTargetAccessibilityFocus(false);
  82.                             continue;
  83.                         }
  85.                         newTouchTarget = getTouchTarget(child);
  86.                         // 已经开始接收触摸事件,并退出整个循环。
  87.                         if (newTouchTarget != null) {
  88.                             newTouchTarget.pointerIdBits |= idBitsToAssign;
  89.                             break;
  90.                         }
  92.                         //重置取消或抬起标志位
  93.                         //如果触摸位置在child的区域内，则把事件分发给子View或ViewGroup
  94.                         if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) { // [见小节2.4.4]
  95.                             // 获取TouchDown的时间点
  96.                             mLastTouchDownTime = ev.getDownTime();
  97.                             // 获取TouchDown的Index
  98.                             if (preorderedList != null) {
  99.                                 for (int j = 0; j < childrenCount; j++) {
  100.                                     if (children[childIndex] == mChildren[j]) {
  101.                                         mLastTouchDownIndex = j;
  102.                                         break;
  103.                                     }
  104.                                 }
  105.                             } else {
  106.                                 mLastTouchDownIndex = childIndex;
  107.                             }
  109.                             //获取TouchDown的x,y坐标
  110.                             mLastTouchDownX = ev.getX();
  111.                             mLastTouchDownY = ev.getY();
  112.                             //添加TouchTarget,则mFirstTouchTarget != null。 [见小节2.4.5]
  113.                             newTouchTarget = addTouchTarget(child, idBitsToAssign);
  114.                             //表示以及分发给NewTouchTarget
  115.                             alreadyDispatchedToNewTouchTarget = true;
  116.                             break;
  117.                         }
  118.                         ev.setTargetAccessibilityFocus(false);
  119.                     }
  120.                     // 清除视图列表
  121.                     if (preorderedList != null) preorderedList.clear();
  122.                 }
  124.                 if (newTouchTarget == null && mFirstTouchTarget != null) {
  125.                     //将mFirstTouchTarget的链表最后的touchTarget赋给newTouchTarget
  126.                     newTouchTarget = mFirstTouchTarget;
  127.                     while (newTouchTarget.next != null) {
  128.                         newTouchTarget = newTouchTarget.next;
  129.                     }
  130.                     newTouchTarget.pointerIdBits |= idBitsToAssign;
  131.                 }
  132.             }
  133.         }
  135.         // mFirstTouchTarget赋值是在通过addTouchTarget方法获取的；
  136.         // 只有处理ACTION_DOWN事件，才会进入addTouchTarget方法。
  137.         // 这也正是当View没有消费ACTION_DOWN事件，则不会接收其他MOVE,UP等事件的原因
  138.         if (mFirstTouchTarget == null) {
  139.             //没有触摸target,则由当前ViewGroup来处理
  140.             handled = dispatchTransformedTouchEvent(ev, canceled, null,
  141.                     TouchTarget.ALL_POINTER_IDS);
  142.         } else {
  143.             //如果View消费ACTION_DOWN事件，那么MOVE,UP等事件相继开始执行
  144.             TouchTarget predecessor = null;
  145.             TouchTarget target = mFirstTouchTarget;
  146.             while (target != null) {
  147.                 final TouchTarget next = target.next;
  148.                 if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
  149.                     handled = true;
  150.                 } else {
  151.                     final boolean cancelChild = resetCancelNextUpFlag(target.child)
  152.                             || intercepted;
  153.                     if (dispatchTransformedTouchEvent(ev, cancelChild,
  154.                             target.child, target.pointerIdBits)) {
  155.                         handled = true;
  156.                     }
  157.                     if (cancelChild) {
  158.                         if (predecessor == null) {
  159.                             mFirstTouchTarget = next;
  160.                         } else {
  161.                             predecessor.next = next;
  162.                         }
  163.                         target.recycle();
  164.                         target = next;
  165.                         continue;
  166.                     }
  167.                 }
  168.                 predecessor = target;
  169.                 target = next;
  170.             }
  171.         }
  173.         //当发生抬起或取消事件，更新触摸targets
  174.         if (canceled
  175.                 || actionMasked == MotionEvent.ACTION_UP
  176.                 || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
  177.             resetTouchState();
  178.         } else if (split && actionMasked == MotionEvent.ACTION_POINTER_UP) {
  179.             final int actionIndex = ev.getActionIndex();
  180.             final int idBitsToRemove = 1 << ev.getPointerId(actionIndex);
  181.             removePointersFromTouchTargets(idBitsToRemove);
  182.         }
  183.     } //此处大括号，是if (onFilterTouchEventForSecurity(ev))的结尾
  185.     //通知verifier由于当前时间未处理，那么该事件其余的都将被忽略
  186.     if (!handled && mInputEventConsistencyVerifier != null) {
  187.         mInputEventConsistencyVerifier.onUnhandledEvent(ev, 1);
  188.     }
  189.     return handled;
  190. }

2.4.1 onFilterTouchEventForSecurity

  1. public boolean onFilterTouchEventForSecurity(MotionEvent event) {
  2.     if ((mViewFlags & FILTER_TOUCHES_WHEN_OBSCURED) != 0
  3.             && (event.getFlags() & MotionEvent.FLAG_WINDOW_IS_OBSCURED) != 0) {
  4.         //隐私包含,则丢弃该事件
  5.         return false;
  6.     }
  7.     return true;
  8. }

根据隐私策略来过滤触摸事件。当返回true，表示继续分发事件；当返回flase,表示该事件应该被过滤掉，不再进行任何分发。

2.4.2 onInterceptTouchEvent

  1. public boolean onInterceptTouchEvent(MotionEvent ev) {
  2.     return false;
  3. }
  • 当返回true，表示该事件被当前视图拦截；
  • 当返回false，继续执行事件分发。

2.4.3 buildOrderedChildList

  1. ArrayList<View> buildOrderedChildList() {
  2.     final int count = mChildrenCount;
  3.     if (count <= 1 || !hasChildWithZ()) return null;
  5.     if (mPreSortedChildren == null) {
  6.         mPreSortedChildren = new ArrayList<View>(count);
  7.     } else {
  8.         mPreSortedChildren.ensureCapacity(count);
  9.     }
  11.     final boolean useCustomOrder = isChildrenDrawingOrderEnabled();
  12.     for (int i = 0; i < mChildrenCount; i++) {
  13.         // 添加下一个子视图到列表
  14.         int childIndex = useCustomOrder ? getChildDrawingOrder(mChildrenCount, i) : i;
  15.         View nextChild = mChildren[childIndex];
  16.         float currentZ = nextChild.getZ(); //获取Z轴
  18.         int insertIndex = i;
  19.         //按Z轴，从小到大排序所有的子视图
  20.         while (insertIndex > 0 && mPreSortedChildren.get(insertIndex - 1).getZ() > currentZ) {
  21.             insertIndex--;
  22.         }
  23.         mPreSortedChildren.add(insertIndex, nextChild);
  24.     }
  25.     return mPreSortedChildren;
  26. }

获取一个视图组的先序列表，通过虚拟的Z轴来排序。

  1. public float getZ() {
  2.     return getElevation() + getTranslationZ();
  3. }

getZ()用于获取Z轴坐标。屏幕只有x,y坐标，而Z是虚拟的，可通过setElevation(),setTranslationZ()或者setZ()方法来修改Z轴的坐标值。

2.4.4 dispatchTransformedTouchEvent

  1. private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
  2.         View child, int desiredPointerIdBits) {
  3.     final boolean handled;
  5.     // 发生取消操作时，不再执行后续的任何操作
  6.     final int oldAction = event.getAction();
  7.     if (cancel || oldAction == MotionEvent.ACTION_CANCEL) {
  8.         event.setAction(MotionEvent.ACTION_CANCEL);
  9.         if (child == null) {
  10.             handled = super.dispatchTouchEvent(event);
  11.         } else {
  12.             handled = child.dispatchTouchEvent(event);
  13.         }
  14.         event.setAction(oldAction);
  15.         return handled;
  16.     }
  18.     final int oldPointerIdBits = event.getPointerIdBits();
  19.     final int newPointerIdBits = oldPointerIdBits & desiredPointerIdBits;
  21.     //由于某些原因，发生不一致的操作，那么将抛弃该事件
  22.     if (newPointerIdBits == 0) {
  23.         return false;
  24.     }
  26.     //分发的主要区域
  27.     final MotionEvent transformedEvent;
  28.     //判断预期的pointer id与事件的pointer id是否相等
  29.     if (newPointerIdBits == oldPointerIdBits) {
  30.         if (child == null || child.hasIdentityMatrix()) {
  31.             if (child == null) {
  32.                 //不存在子视图时，ViewGroup调用View.dispatchTouchEvent分发事件，再调用ViewGroup.onTouchEvent来处理事件
  33.                 handled = super.dispatchTouchEvent(event);  // [见小节2.4]
  34.             } else {
  35.                 final float offsetX = mScrollX - child.mLeft;
  36.                 final float offsetY = mScrollY - child.mTop;
  37.                 event.offsetLocation(offsetX, offsetY);
  38.                 //将触摸事件分发给子ViewGroup或View;
  39.                 //如果是ViewGroup，则调用代码(2.1)；
  40.                 //如果是View，则调用代码(3.1)；
  41.                 handled = child.dispatchTouchEvent(event);
  43.                 event.offsetLocation(-offsetX, -offsetY); //调整该事件的位置
  44.             }
  45.             return handled;
  46.         }
  47.         transformedEvent = MotionEvent.obtain(event); //拷贝该事件，来创建一个新的MotionEvent
  48.     } else {
  49.         //分离事件，获取包含newPointerIdBits的MotionEvent
  50.         transformedEvent = event.split(newPointerIdBits);
  51.     }
  53.     if (child == null) {
  54.         //不存在子视图时，ViewGroup调用View.dispatchTouchEvent分发事件，再调用ViewGroup.onTouchEvent来处理事件
  55.         handled = super.dispatchTouchEvent(transformedEvent);  // [见小节2.4]
  56.     } else {
  57.         final float offsetX = mScrollX - child.mLeft;
  58.         final float offsetY = mScrollY - child.mTop;
  59.         transformedEvent.offsetLocation(offsetX, offsetY);
  60.         if (! child.hasIdentityMatrix()) {
  61.             //将该视图的矩阵进行转换
  62.             transformedEvent.transform(child.getInverseMatrix());
  63.         }
  64.         //将触摸事件分发给子ViewGroup或View;
  65.         /如果是ViewGroup，则 [见小节2.4]; 如果是View，则[见小节2.5];
  66.         handled = child.dispatchTouchEvent(transformedEvent);
  67.     }
  69.     //回收transformedEvent
  70.     transformedEvent.recycle();
  71.     return handled;
  72. }

该方法是ViewGroup真正处理事件的地方，分发子View来处理事件，过滤掉不相干的pointer ids。当子视图为null时，MotionEvent将会发送给该ViewGroup。最终调用View.dispatchTouchEvent方法来分发事件。

2.4.5 addTouchTarget

  1. private TouchTarget addTouchTarget(View child, int pointerIdBits) {
  2.     TouchTarget target = TouchTarget.obtain(child, pointerIdBits);
  3.     target.next = mFirstTouchTarget;
  4.     mFirstTouchTarget = target;
  5.     return target;
  6. }

调用该方法，获取了TouchTarget，同时mFirstTouchTarget不再为null。

2.5 View.dispatchTouchEvent

[-> View.java]

  1. public boolean dispatchTouchEvent(MotionEvent event) {
  2.     ...
  4.     final int actionMasked = event.getActionMasked();
  5.     if (actionMasked == MotionEvent.ACTION_DOWN) {
  6.         //在Down事件之前，如果存在滚动操作则停止。不存在则不进行操作
  7.         stopNestedScroll();
  8.     }
  10.     // mOnTouchListener.onTouch优先于onTouchEvent。
  11.     if (onFilterTouchEventForSecurity(event)) {
  12.         //当存在OnTouchListener，且视图状态为ENABLED时，调用onTouch()方法
  13.         ListenerInfo li = mListenerInfo;
  14.         if (li != null && li.mOnTouchListener != null
  15.                 && (mViewFlags & ENABLED_MASK) == ENABLED
  16.                 && li.mOnTouchListener.onTouch(this, event)) {
  17.             result = true; //如果已经消费事件，则返回True
  18.         }
  19.         //如果OnTouch（)没有消费Touch事件则调用OnTouchEvent()
  20.         if (!result && onTouchEvent(event)) { // [见小节2.5.1]
  21.             result = true; //如果已经消费事件，则返回True
  22.         }
  23.     }
  25.     if (!result && mInputEventConsistencyVerifier != null) {
  26.         mInputEventConsistencyVerifier.onUnhandledEvent(event, 0);
  27.     }
  29.     // 处理取消或抬起操作
  30.     if (actionMasked == MotionEvent.ACTION_UP ||
  31.             actionMasked == MotionEvent.ACTION_CANCEL ||
  32.             (actionMasked == MotionEvent.ACTION_DOWN && !result)) {
  33.         stopNestedScroll();
  34.     }
  36.     return result;
  37. }
  1. 先由OnTouchListener的OnTouch()来处理事件，当返回True，则消费该事件，否则进入2。
  2. onTouchEvent处理事件，的那个返回True时，消费该事件。否则不会处理

2.5.1 View.onTouchEvent

  1. public boolean onTouchEvent(MotionEvent event) {
  2.     final float x = event.getX();
  3.     final float y = event.getY();
  4.     final int viewFlags = mViewFlags;
  6.     // 当View状态为DISABLED，如果可点击或可长按，则返回True，即消费事件
  7.     if ((viewFlags & ENABLED_MASK) == DISABLED) {
  8.         if (event.getAction() == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
  9.             setPressed(false);
  10.         }
  11.         return (((viewFlags & CLICKABLE) == CLICKABLE ||
  12.                 (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE));
  13.     }
  15.     if (mTouchDelegate != null) {
  16.         if (mTouchDelegate.onTouchEvent(event)) {
  17.             return true;
  18.         }
  19.     }
  21.     //当View状态为ENABLED，如果可点击或可长按，则返回True，即消费事件;
  22.     //与前面的的结合，可得出结论:只要view是可点击或可长按，则消费该事件.
  23.     if (((viewFlags & CLICKABLE) == CLICKABLE ||
  24.             (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {
  25.         switch (event.getAction()) {
  26.             case MotionEvent.ACTION_UP:
  27.                 boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
  28.                 if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {
  29.                     boolean focusTaken = false;
  30.                     if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {
  31.                         focusTaken = requestFocus();
  32.                     }
  34.                     if (prepressed) {
  35.                         setPressed(true, x, y);
  36.                    }
  38.                     if (!mHasPerformedLongPress) {
  39.                         //这是Tap操作，移除长按回调方法
  40.                         removeLongPressCallback();
  42.                         if (!focusTaken) {
  43.                             if (mPerformClick == null) {
  44.                                 mPerformClick = new PerformClick();
  45.                             }
  46.                             //调用View.OnClickListener
  47.                             if (!post(mPerformClick)) {
  48.                                 performClick();
  49.                             }
  50.                         }
  51.                     }
  53.                     if (mUnsetPressedState == null) {
  54.                         mUnsetPressedState = new UnsetPressedState();
  55.                     }
  57.                     if (prepressed) {
  58.                         postDelayed(mUnsetPressedState,
  59.                                 ViewConfiguration.getPressedStateDuration());
  60.                     } else if (!post(mUnsetPressedState)) {
  61.                         mUnsetPressedState.run();
  62.                     }
  64.                     removeTapCallback();
  65.                 }
  66.                 break;
  68.             case MotionEvent.ACTION_DOWN:
  69.                 mHasPerformedLongPress = false;
  71.                 if (performButtonActionOnTouchDown(event)) {
  72.                     break;
  73.                 }
  75.                 //获取是否处于可滚动的视图内
  76.                 boolean isInScrollingContainer = isInScrollingContainer();
  78.                 if (isInScrollingContainer) {
  79.                     mPrivateFlags |= PFLAG_PREPRESSED;
  80.                     if (mPendingCheckForTap == null) {
  81.                         mPendingCheckForTap = new CheckForTap();
  82.                     }
  83.                     mPendingCheckForTap.x = event.getX();
  84.                     mPendingCheckForTap.y = event.getY();
  85.                     //当处于可滚动视图内，则延迟TAP_TIMEOUT，再反馈按压状态，用来判断用户是否想要滚动。默认延时为100ms
  86.                     postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
  87.                 } else {
  88.                     //当不再滚动视图内，则立刻反馈按压状态
  89.                     setPressed(true, x, y);
  90.                     checkForLongClick(0); //检测是否是长按
  91.                 }
  92.                 break;
  94.             case MotionEvent.ACTION_CANCEL:
  95.                 setPressed(false);
  96.                 removeTapCallback();
  97.                 removeLongPressCallback();
  98.                 break;
  100.             case MotionEvent.ACTION_MOVE:
  101.                 drawableHotspotChanged(x, y);
  103.                 if (!pointInView(x, y, mTouchSlop)) {
  104.                     removeTapCallback();
  105.                     if ((mPrivateFlags & PFLAG_PRESSED) != 0) {
  106.                         removeLongPressCallback();
  107.                         setPressed(false);
  108.                     }
  109.                 }
  110.                 break;
  111.         }
  113.         return true;
  114.     }
  115.     return false;
  116. }

三. 总结

事件分发流程图:
这里写图片描述

  1. onInterceptTouchEvent返回值true表示事件拦截， onTouch/onTouchEvent 返回值true表示事件消费。
  2. 触摸事件先交由Activity.dispatchTouchEvent。再一层层往下分发，当中间的ViewGroup都不拦截时，进入最底层的View后，开始由最底层的OnTouchEvent来处理，如果一直不消费，则最后返回到Activity.OnTouchEvent。
  3. ViewGroup才有onInterceptTouchEvent拦截方法。在分发过程中，中间任何一层ViewGroup都可以直接拦截，则不再往下分发，而是交由发生拦截操作的ViewGroup的OnTouchEvent来处理。
  4. 子View可调用requestDisallowInterceptTouchEvent方法，来设置disallowIntercept=true，从而阻止父ViewGroup的onInterceptTouchEvent拦截操作。
  5. OnTouchEvent由下往上冒泡时，当中间任何一层的OnTouchEvent消费该事件，则不再往上传递，表示事件已处理。
  6. 如果View没有消费ACTION_DOWN事件，则之后的ACTION_MOVE等事件都不会再接收。
  7. 只要View.onTouchEvent是可点击或可长按，则消费该事件.
  8. onTouch优先于onTouchEvent执行，上面流程图中省略，onTouch的位置在onTouchEvent前面。当onTouch返回true,则不执行onTouchEvent,否则会执行onTouchEvent。onTouch只有View设置了OnTouchListener，且是enable的才执行该方法。

发表评论

表情：
评论列表 （有 0 条评论，385人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Android事件分发机制

    在触摸屏幕的过程中，要涉及到和控件的交互，如何处理多个控件之间的事件处理，保证正常的交互效果。我们今天来看事件分发机制。 零、事件分发的一些基础知识 什么是事件？

    偏执的太偏执、偏执的太偏执、/ 0 赞/ 122 阅读

    相关 Android事件分发机制

    在触摸屏幕的过程中，要涉及到和控件的交互，如何处理多个控件之间的事件处理，保证正常的交互效果。我们今天来看事件分发机制。 零、事件分发的一些基础知识 什么是事件？

    ￡神魔★判官ぃ￡神魔★判官ぃ/ 0 赞/ 218 阅读

    相关 Android事件分发机制

    Android事件分发机制    就是一个触摸事件发生了，从一个窗口传递到下一个视图，在传递到另一个视图，最后被消费的过程，在android中还是比较复杂的传递流程：   

    柔光的暖阳◎柔光的暖阳◎/ 0 赞/ 327 阅读

    相关 Android 事件分发机制

    前言 说到这个事件分发机制呢，我觉得一直以来都是我的弱项，可能它太抽象了，也与我在实际项目中没怎么使用到过，也没自定义过view有着很大的关系。虽然在面试过程中事件分发是必不

    快来打我*快来打我*/ 0 赞/ 378 阅读

    相关 Android事件分发机制

    事件分发机制 在我们要详细了解这个东西的时候，首先要对它有一个最基础的认知，事件分发是干嘛的？分发的对象又是什么？接下来以一段伪代码来给大家解释什么是事件分发和它分发的对

    左手的ㄟ右手左手的ㄟ右手/ 0 赞/ 378 阅读