分发流程
ViewGroup.dispatchTouchEvent -> ViewGroup.onInterceptTouchEvent -> View.dispatchTouchEvent -> View.onTouchEvent -> ViewGroup.onTouchEvent
源码解析事件分发机制
ViewGroup#dispatchTouchEvent
public boolean dispatchTouchEvent(MotionEvent ev) {
...
boolean handled = false;
if (onFilterTouchEventForSecurity(ev)) {
final int action = ev.getAction();
final int actionMasked = action & MotionEvent.ACTION_MASK;
// 清除重置状态,完整的事件序列，从down开始，从up结束
if (actionMasked == MotionEvent.ACTION_DOWN) {
cancelAndClearTouchTargets(ev);
resetTouchState();
}
final boolean intercepted;
// mFirstTouchTarget当前ViewGroup是否拦截了事件，拦截了mFirstTouchTarget == null
// 如果ViewGroup拦截，并且是MOVE，UP事件，viewGroup会直接拦截。DOWN事件，如果没有请求父控件不拦截，ViewGroup会执行onInterceptTouchEvent方法
if (actionMasked == MotionEvent.ACTION_DOWN
|| mFirstTouchTarget != null) {
final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
// 子View是否调用requestDisallowInterceptTouchEvent方法
if (!disallowIntercept) {
// 父View的onInterceptTouchEvent是否拦截事件
intercepted = onInterceptTouchEvent(ev);
ev.setAction(action); // restore action in case it was changed
} else {
intercepted = false;
}
} else {
intercepted = true;
}
...
// 没有取消，没有拦截
if (!canceled && !intercepted) {
View childWithAccessibilityFocus = ev.isTargetAccessibilityFocus()
? findChildWithAccessibilityFocus() : null;
if (actionMasked == MotionEvent.ACTION_DOWN
|| (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
|| actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
...
if (newTouchTarget == null && childrenCount != 0) {
...
final View[] children = mChildren;
// 从最上层的子View开始往内层遍历
for (int i = childrenCount - 1; i >= 0; i--) {
final int childIndex = getAndVerifyPreorderedIndex(
childrenCount, i, customOrder);
final View child = getAndVerifyPreorderedView(
preorderedList, children, childIndex);
...
// 判断触摸点位置是否在子View的范围内或者View是否在播放动画
if (!canViewReceivePointerEvents(child)
|| !isTransformedTouchPointInView(x, y, child, null)) {
ev.setTargetAccessibilityFocus(false);
continue;
}
// 检查该子view是否在touchTarget链表中
newTouchTarget = getTouchTarget(child);
if (newTouchTarget != null) {
// 把接触到的点并入，一个View可以被多个手指触摸
// 当有新的down事件被消费时，viewGroup会把该view和对应的触控点id绑定起来存储到touchTarget中
newTouchTarget.pointerIdBits |= idBitsToAssign;
break;
}
resetCancelNextUpFlag(child);
// 重点代码
//找到合适的子view，把事件分发给他，看该子view是否消费了down事件
// 如果消费了，需要生成新的TouchTarget
// 如果没有消费，说明子view不接受该down事件，继续循环寻找合适的子控件
if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
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;
}
// The accessibility focus didn't handle the event, so clear
// the flag and do a normal dispatch to all children.
ev.setTargetAccessibilityFocus(false);
}
if (preorderedList != null) preorderedList.clear();
}
if (newTouchTarget == null && mFirstTouchTarget != null) {
newTouchTarget = mFirstTouchTarget;
while (newTouchTarget.next != null) {
newTouchTarget = newTouchTarget.next;
}
newTouchTarget.pointerIdBits |= idBitsToAssign;
}
}
}
// 任何子view都不接受事件
if (mFirstTouchTarget == null) {
// 调用自己的ouTouchEvent
handled = dispatchTransformedTouchEvent(ev, canceled, null,
TouchTarget.ALL_POINTER_IDS);
} else {
// Dispatch to touch targets, excluding the new touch target if we already
// dispatched to it. Cancel touch targets if necessary.
TouchTarget predecessor = null;
TouchTarget target = mFirstTouchTarget;
while (target != null) {
final TouchTarget next = target.next;
if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
handled = true;
} else {
final boolean cancelChild = resetCancelNextUpFlag(target.child)
|| intercepted;
if (dispatchTransformedTouchEvent(ev, cancelChild,
target.child, target.pointerIdBits)) {
handled = true;
}
...
}
predecessor = target;
target = next;
}
}
...
}
...
return handled;
}
ViewGroup#dispatchTransformedTouchEvent
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);
// 如果有子View，调用子View的dispatchTouchEvent方法。
// 如果没有子View，调用super的dispatchTouchEvent方法。
if (child == null) {
handled = super.dispatchTouchEvent(event);
} else {
handled = child.dispatchTouchEvent(event);
}
event.setAction(oldAction);
return handled;
}
// Calculate the number of pointers to deliver.
final int oldPointerIdBits = event.getPointerIdBits();
final int newPointerIdBits = oldPointerIdBits & desiredPointerIdBits;
// If for some reason we ended up in an inconsistent state where it looks like we
// might produce a motion event with no pointers in it, then drop the event.
if (newPointerIdBits == 0) {
return false;
}
final MotionEvent transformedEvent;
if (newPointerIdBits == oldPointerIdBits) {
if (child == null || child.hasIdentityMatrix()) {
if (child == null) {
handled = super.dispatchTouchEvent(event);
} else {
final float offsetX = mScrollX - child.mLeft;
final float offsetY = mScrollY - child.mTop;
event.offsetLocation(offsetX, offsetY);
handled = child.dispatchTouchEvent(event);
event.offsetLocation(-offsetX, -offsetY);
}
return handled;
}
transformedEvent = MotionEvent.obtain(event);
} else {
transformedEvent = event.split(newPointerIdBits);
}
// Perform any necessary transformations and dispatch.
if (child == null) {
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());
}
handled = child.dispatchTouchEvent(transformedEvent);
}
// Done.
transformedEvent.recycle();
return handled;
}
View#dispatchTouchEvent
public boolean dispatchTouchEvent(MotionEvent event) {
...
boolean result = false;
...
if (onFilterTouchEventForSecurity(event)) {
if ((mViewFlags & ENABLED_MASK) == ENABLED && handleScrollBarDragging(event)) {
result = true;
}
//noinspection SimplifiableIfStatement
ListenerInfo li = mListenerInfo;
// 如果OnTouchListener不为null并且onTouch返回true，表示事件消费，不会执行onTouchEvent方法。
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;
}
View#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();
// 判断这个view是否是可点击的,如果CLICKABLE，LONG_CLICKABLE和CONTEXT_CLICKABLE有一个返回true，onTouchEvent就会返回true，消耗这个事件
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;
return clickable;
}
// mTouchDelegate触摸代理，增加点击区域，防止按钮过小
if (mTouchDelegate != null) {
if (mTouchDelegate.onTouchEvent(event)) {
return true;
}
}
// TOOLTIP，解释工具，解释摸的view是干什么用的，对应android:tooltipText属性
if (clickable || (viewFlags & TOOLTIP) == TOOLTIP) {
switch (action) {
case MotionEvent.ACTION_UP:
mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
// 1.5s后取消TOOLTIP提示
if ((viewFlags & TOOLTIP) == TOOLTIP) {
handleTooltipUp();
}
if (!clickable) {
removeTapCallback();
removeLongPressCallback();
mInContextButtonPress = false;
mHasPerformedLongPress = false;
mIgnoreNextUpEvent = false;
break;
}
boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
// 如果是按下状态或者预按下
if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {
boolean focusTaken = false;
if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {
focusTaken = requestFocus();
}
if (prepressed) {
// 滑动控件里的按下触发点击，让你的预点击有个按下弹起的效果
setPressed(true, x, y);
}
if (!mHasPerformedLongPress && !mIgnoreNextUpEvent) {
removeLongPressCallback();
if (!focusTaken) {
if (mPerformClick == null) {
mPerformClick = new PerformClick();
}
// 触发点击，内部调用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:
// 是否触摸到屏幕
if (event.getSource() == InputDevice.SOURCE_TOUCHSCREEN) {
mPrivateFlags3 |= PFLAG3_FINGER_DOWN;
}
mHasPerformedLongPress = false;
// 不可点击说明是解释工具，只需要检查是否长按显示出来
if (!clickable) {
checkForLongClick(
ViewConfiguration.getLongPressTimeout(),
x,
y,
TOUCH_GESTURE_CLASSIFIED__CLASSIFICATION__LONG_PRESS);
break;
}
if (performButtonActionOnTouchDown(event)) {
break;
}
// 是否在滑动控件里面
boolean isInScrollingContainer = isInScrollingContainer();
// For views inside a scrolling container, delay the pressed feedback for
// a short period in case this is a scroll.
if (isInScrollingContainer) {
// 设置成预点击
mPrivateFlags |= PFLAG_PREPRESSED;
// 延迟100ms判断当前是点击还是滑动
if (mPendingCheckForTap == null) {
mPendingCheckForTap = new CheckForTap();
}
mPendingCheckForTap.x = event.getX();
mPendingCheckForTap.y = event.getY();
postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
} else {
// 状态设置成按下
setPressed(true, x, y);
// 设置长按等待器，进行长按操作
checkForLongClick(
ViewConfiguration.getLongPressTimeout(),
x,
y,
TOUCH_GESTURE_CLASSIFIED__CLASSIFICATION__LONG_PRESS);
}
break;
case MotionEvent.ACTION_CANCEL:
if (clickable) {
setPressed(false);
}
removeTapCallback();
removeLongPressCallback();
mInContextButtonPress = false;
mHasPerformedLongPress = false;
mIgnoreNextUpEvent = false;
mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
break;
case MotionEvent.ACTION_MOVE:
// 安卓5.0以后点击触发水波纹效果
if (clickable) {
drawableHotspotChanged(x, y);
}
final int motionClassification = event.getClassification();
final boolean ambiguousGesture =
motionClassification == MotionEvent.CLASSIFICATION_AMBIGUOUS_GESTURE;
int touchSlop = mTouchSlop;
if (ambiguousGesture && hasPendingLongPressCallback()) {
if (!pointInView(x, y, touchSlop)) {
// The default action here is to cancel long press. But instead, we
// just extend the timeout here, in case the classification
// stays ambiguous.
removeLongPressCallback();
long delay = (long) (ViewConfiguration.getLongPressTimeout()
* mAmbiguousGestureMultiplier);
// Subtract the time already spent
delay -= event.getEventTime() - event.getDownTime();
checkForLongClick(
delay,
x,
y,
TOUCH_GESTURE_CLASSIFIED__CLASSIFICATION__LONG_PRESS);
}
touchSlop *= mAmbiguousGestureMultiplier;
}
// 手指在view外，滑出屏幕
// touchSlop会在view的区域外加一层额外区域，用来响应点击
if (!pointInView(x, y, touchSlop)) {
// 取消所有状态
removeTapCallback();
removeLongPressCallback();
if ((mPrivateFlags & PFLAG_PRESSED) != 0) {
setPressed(false);
}
mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
}
// 大力按直接触发长按
final boolean deepPress =
motionClassification == MotionEvent.CLASSIFICATION_DEEP_PRESS;
if (deepPress && hasPendingLongPressCallback()) {
// process the long click action immediately
removeLongPressCallback();
checkForLongClick(
0 /* send immediately */,
x,
y,
TOUCH_GESTURE_CLASSIFIED__CLASSIFICATION__DEEP_PRESS);
}
break;
}
return true;
}
return false;
}
View#performClick
public boolean performClick() {
notifyAutofillManagerOnClick();
final boolean result;
final ListenerInfo li = mListenerInfo;
// 如果View设置点击事件OnClickListener，那么onClick方法就会被执行
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;
}
自定义ViewGroup需要重写，不然每次点击View都要延迟100ms，默认ViewGroup是滑动布局。具体源码看Action_down的isInScrollingContainer。
override fun shouldDelayChildPressedState(): Boolean {
return false
}
onInterceptTouchEvent方法
只有ViewGroup有这个方法，拦截子View的事件进行处理。如果不拦截就会将事件从最上面的子View一层层向下传，如果没有View处理这个事件就会回到ViewGroup的onTouchEvent方法。
如果down返回true进行事件拦截，直接调用ViewGroup的onTouchEvent，后续事件全部拦截不会再向子View发。开始不要拦截，需要的时候拦截返回true，做好拦截准备工作，记录坐标之类的。
requestDisallowInterceptTouchEvent
在一次事件序列过程中，down事件之后，up，cancel之前，这之间调用。
源码总结
viewGroup的事件分发
- 每一个触控点的事件序列，只能给一个view消费；如果一个view消费了一个触控点的down事件，那么该触控点的后续事件都会给他处理。
- 每一个事件到达viewGroup，如果需要分发到子view，那么viewGroup会新判断是否要拦截。
- 当viewGroup的touchTarget!=null || 事件的类型为down需要进行判断是否拦截；
- 判断是否拦截受两个因素影响：onInterceptTouchEvent和FLAG_DISALLOW_INTERCEPT标志
- 如果该事件没有取消没有拦截是down类型，那么需要遍历所有的子控件在每个触控点都找到消费自己事件序列的控件并绑定在了TouchTarget中。
- 根据前面的处理情况，将事件派发到viewGroup自身或touchTarget中
- 如果touchTarget==null，说明没有子控件消费了down事件，那么viewGroup自己处理事件。
- 否则将事件分离成多个MotionEvent，每个MotionEvent只包含对应view感兴趣的触控点的信息，并派发给对应的子view。
View事件分发
- 检查之后先检查是否有onTouchListener监听器，如果有则调用它。
- 调用onTouchEvent方法来处理事件
View的onTouchEvent方法
根据按下情况选择触发onClickListener或者onLongClickListener。
如何辨别：
当一个down事件来临时，会添加一个延时任务到消息队列中。如果时间到还没有接收到up事件，说明这是个长按事件，那么就会调用onLongClickListener监听器，而如果在延时时间（400ms）内收到了up事件，那么说明这是个单击事件，取消这个延时的任务，并调用onClickListener。
如果在滑动控件里面，在给定时间（100ms）用户的触摸没有移动,就当作用户是想点击,而不是滑动。
结论
- 事件序列以down事件开始，中间含有数量不定的move事件，最终以up事件结束。
- 正常情况下，一个事件序列只能被一个View拦截且消耗。当然可以特殊处理，一个View调用onTouchEvent方法，再强制调用其他View的onTouchEvent方法。
- 某个View一旦决定拦截，那么这一个事件序列都只能由它来处理（如果事件序列能够传递给它的话），并且它的onInterceptTouchEvent不会再被调用。
- 某个View一旦开始处理事件，如果它不消耗ACTION_DOWN事件（onTouchEvent返回了false），那么同一事件序列中的其他事件都不会再交给它来处理，并且事件将重新交由它的父元素去处理，即父元素的onTouchEvent会被调用。
- View的onTouchEvent默认都会消耗事件（返回true），除非它是不可点击的（clickable和longClickable同时为false），并且没有设置android:tooltipText属性。
- 如果ViewGroup的mOnTouchListener被设置，则onTouch会被调用，onTouchEvent不会被调用。否则onTouchEvent会被调用。
事件传递
事件传递流程
事件会传递给当前的Activity，调用Activity的dispatchTouchEvent方法，具体事件处理交给Activity的PhoneWindow完成，然后PhoneWindow再把事件处理工作交给DecorView，之后再由DecorView将事件处理工作交给根ViewGroup。
根ViewGroup会将点击事件传递给它的dispatchTouchEvent方法，如果该ViewGroup的onInterceptTouchEvent方法返回true，就会调用到自己的onTouchEvent方法。onInterceptTouchEvent方法返回false，则表示不会拦截，事件会交给它的子元素的dispatchTouchEvent来处理。如果传递给最底层View，会调用该View的dispatchTouchEvent方法，一般还会调用到该View的onTouchEvent方法。
如果最底层View的onTouchEvent方法返回true，代表该View消耗和处理事件。如果返回false，则表示该View不做处理。则传递给父View的onTouchEvent处理，如果依然返回false，一层层往上处理。
伪代码
public boolean dispatchTouchEvent(MotionEvent ev){
boolean result = false;
if(onInterceptTouchEvent(ev)){
result = onTouchEvent(ev);
}else{
result = child.dispatchTouchEvent(ev);
}
return result;
}
ViewGroup事件拦截
重写onInterceptTouchEvent方法，拦截View事件，请求父控件不要拦截。
常见问题
什么是事件分发
事件分发是将屏幕触控信息分发给控件树的一整套机制。 DecorView，他会先把事件交给Activity，再通过下面这个流程进行事件传递。
Activity（dispatchTouchEvent） - PhoneWindow（superDispatchTouchEvent） - DecorView（superDispatchTouchEvent方法） - ViewGroup（dispatchTouchEvent） - View
事件怎么到Activity的
触摸信息由屏幕这个硬件产生，被系统底层驱动获取，交给Android的输入系统服务：InputManagerService，也就是IMS。
IMS会对这个触摸信息进行处理，通过WMS找到要分发的window，随后发送给对应的viewRootImpl。viewRootImpl接收到触摸信息之后，经过处理之后，封装成MotionEvent对象发送给他所管理的view，由view自己进行分发。
DecorView#dispatchTouchEvent
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
final Window.Callback cb = mWindow.getCallback();
return cb != null && !mWindow.isDestroyed() && mFeatureId < 0
? cb.dispatchTouchEvent(ev) : super.dispatchTouchEvent(ev);
}
Activity实现了Window.CallBack接口,因此在Activity的布局界面中，DecorView会把事件分发给Activity进行处理。同理，在Dialog的布局界面中，会分发给实现了callBack接口的Dialog。
触摸事件是先发送到viewRootImpl，然后由viewRootImpl调用其所管理的view的方法进行事件分发。按照正常的流程，view会按照控件树向下去分发。而事件却到了activity、dialog，就是因为DecorView这个“叛徒”的存在。
事件一定从Activity开始吗？
不是,Activity只是其中的一种情况，只有Activity自己负责的那一棵view树，才一定会到达activity，而其他的window，则不会经过Activity，比如dialog事件流是不会经过Activity的,PopupWindow其它ViewGroup。触摸事件是从viewRootImpl开始，而不是Activity。
Activity
public boolean dispatchTouchEvent(MotionEvent ev) {
if (ev.getAction() == MotionEvent.ACTION_DOWN) {
onUserInteraction();
}
if (getWindow().superDispatchTouchEvent(ev)) {
return true;
}
return onTouchEvent(ev);
}
Dialog
public boolean dispatchTouchEvent(@NonNull MotionEvent ev) {
// PhoneWindow实例，和Activity相同
if (mWindow.superDispatchTouchEvent(ev)) {
return true;
}
return onTouchEvent(ev);
}
PopupWindow
PopupWindow他的根View是PopupDecorView,直接继承于FrameLayout。
public boolean dispatchTouchEvent(MotionEvent ev) {
// mTouchInterceptor是一个拦截器，我们可以手动给PopupWindow设置拦截器。
// 事件会优先交给拦截器处理，如果没有拦截器或拦截器没有消费事件，那么才会交给viewGroup去进行分发。
if (mTouchInterceptor != null && mTouchInterceptor.onTouch(this, ev)) {
return true;
}
return super.dispatchTouchEvent(ev);
}
viewGroup是如何分发事件的
viewGroup处理事件信息分为三个步骤：拦截、寻找子控件、派发事件。
事件分发中有一个重要的规则：
一个触控点的一个事件序列只能给一个view处理，除非异常情况。所以如果viewGroup消费了down事件，那么子view将无法收到任何事件。
viewGroup第一步会判断这个事件是否需要分发给子view，如果是则调用onInterceptTouchEvent方法判断是否要进行拦截。
第二步是如果这个事件是down事件，那么需要为他寻找一个消费此事件的子控件，如果找到则为他创建一个TouchTarget。
第三步是派发事件，如果存在TouchTarget，说明找到了消费事件序列的子view，直接分发给他。如果没有则交给自己处理。
// mFirstTouchTarget当前ViewGroup是否拦截了事件，拦截了mFirstTouchTarget == null
if (actionMasked == MotionEvent.ACTION_DOWN
|| mFirstTouchTarget != null) {
final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
// 子View是否调用requestDisallowInterceptTouchEvent方法
if (!disallowIntercept) {
// 父View的onInterceptTouchEvent是否拦截事件
intercepted = onInterceptTouchEvent(ev);
ev.setAction(action); // restore action in case it was changed
} else {
intercepted = false;
}
} else {
intercepted = true;
}
ViewGroup的多点
在ViewGroup的事件派发流程中，只有在事件序列开始或子序列开始时（ACTION_DOWN或ACTION_POINTER_DOWN），会遍历子view，进行派发目标查找，并将目标封装成TouchTarget保存在mFirstTouchTarget链表中，TouchTarget里面可以有多个pointerId，也就是说多个手指触摸一个View。完成派发目标查找后，再遍历TouchTarget链表，会根据TouchTarget中的ID集合从MotionEvent中拆分出仅包含TouchTarget期望处理的触摸点的事件的副本，将事件副本派发给该child。
View多点
View默认是不支持的。他在获取触控点信息的时候并没有传入触控点索引，也就是获取的是MotionEvent内部数组中的第一个触控点的信息。多指需要我们自己去重写方法支持他。
多点触控获取事件类型请使用getActionMasked()。
追踪事件流请使用pointId。
pointId和index区别：
pointId和index都是从0开始，自动增长。
如果之前落下的手指抬起，后面手指的Index会随之减小。pointId是不变的，始终为第一次落下时生成的数值，不会受到其他手指抬起和落下的影响。
判断当前手指是否是第一根手指
event.getPointerId(event.getActionIndex()) == 0
获取第一根手指x位移
int index = event.findPointerIndex(0);
event.getX(index)
@Override
public boolean onTouchEvent(MotionEvent event) {
switch (event.getActionMasked()) {
case MotionEvent.ACTION_DOWN:
// 按下之前已经有手指在屏幕上
case MotionEvent.ACTION_POINTER_DOWN:
// ▼ 判断是否是第一个手指 && 是否包含在图片区域内
if (event.getPointerId(event.getActionIndex()) == 0 && mBitmapRectF.contains((int)event.getX(), (int)event.getY())){
canDrag = true;
lastPoint.set(event.getX(), event.getY());
}
break;
case MotionEvent.ACTION_UP:
// 抬起之前已经有手指在屏幕上
case MotionEvent.ACTION_POINTER_UP:
// ▼ 判断是否是第一个手指
if (event.getPointerId(event.getActionIndex()) == 0){
canDrag = false;
}
break;
case MotionEvent.ACTION_MOVE:
// 如果存在第一个手指，且这个手指的落点在图片区域内
if (canDrag) {
// ▼ 注意 getX 和 getY
int index = event.findPointerIndex(0);
// Log.i(TAG, "index="+index);
mBitmapMatrix.postTranslate(event.getX(index)-lastPoint.x, event.getY(index)-lastPoint.y);
lastPoint.set(event.getX(index), event.getY(index));
mBitmapRectF = new RectF(0,0,mBitmap.getWidth(), mBitmap.getHeight());
mBitmapMatrix.mapRect(mBitmapRectF);
invalidate();
}
break;
}
return true;
}
View是如何处理触摸事件的
会判断是否存在onTouchListener，存在则会调用他的onTouch方法来处理事件。如果该方法返回true那么就分发结束直接返回。而如果该监听器为null或者onTouch方法返回了false，则会调用onTouchEvent方法来处理事件。
onTouchEvent方法中支持了两种监听器：onClickListener和onLongClickListener。View会根据不同的触摸情况来调用这两个监听器。同时进入到onTouchEvent方法中，无论该view是否是enable，只要是clickable，他的分发方法都是返回true。
分发有什么方法，之间的联系
dispatchTouchEvent消息分发，onInterceptTouchEvent在viewGroup负责判断是否拦截，onTouchEvent消费事件。
ViewGroup：
viewGroup的dispatchTouchEvent方法接收到事件消息，首先会去调用onInterceptTouchEvent判断是否拦截事件。
- 如果拦截，则调用自身的onTouchEvent方法
- 如果不拦截则调用子view的dispatchTouchEvent方法
子view没有消费事件，那么会调用viewGroup本身的onTouchEvent。
上面1、2步的处理结果为viewGroup的dispatchTouchEvent方法的处理结果，没有消费则返回false并返回给上一层的onTouchEvent处理，如果消费则分发结束并返回true。
View：
view的dispatchTouchEvent默认情况下会调用onTouchEvent来处理事件，如果设置onTouchListener，需要看onTouch方法结果，ouTouchEvent返回true表示消费事件，返回false表示没有消费事件。成功消费则返回true，没有消费则返回false并交给上一层的onTouchEvent处理。
外部和内部拦截法
外部拦截：事件先经过父容器处理，父容器需要此事件就拦截，不需要此事件就不拦截。
一般down事件是不拦截的，一旦拦截后续move和up事件都会交给父容器处理就没办法传给子容器了。
内部拦截：父容器不拦截事件，所有事件传递给子元素，如果子元素需要此事件就消耗掉，否则交给父容器处理。需要父容器重写onInterceptTouchEvent，down不拦截，其余拦截。子View需要重写dispatchTouchEvent，down事件请求父控件不要拦截，其余需要的请求父控件不要拦截。
从实现的复杂度来看，外部拦截法会更加优秀，不需要里外view去配合，只需要viewGroup自身做好事件拦截处理即可。两者的区别就在于主动权在谁的手上。如果view需要做更多的判断可以采用内部拦截法，而一般情况下采用外部拦截法会更加简单。