**注意：因为是解析源码，所以本文要求对Android的事件传递机制有一定的的了解。**当然我也会简单的对事件传递的知识进行提要：
一、 简单提要
- 同一个事件序列：指的是从手指接触屏幕的那一刻起，到手指离开屏幕的那一刻结束，在这个过程中所产生的一系列事件，这个事件以down事件开始，中间含有数量不定的move事件，最终以up事件结束。
- 点击事件的事件分发，就是对同一事件序列的分发，这个过程由三个很重要的方法来完成：dispatchTouchEvent，onInterceptTouchEvent，onTouchEvent。
- 当一个点击事件产生后，传递过程遵循如下顺序：Activity-ViewGroup-View，顶级view收到事件后就会按照事件分发机制分发。
- dispatchTouchEvent()：表示本层或下层是否有能力处理事件，view和ViewGroup都有该方法。 ，注意，该方法表示的是是否有能力。事件的分发受本层的onInterceptTouchEvent方法、onTouchEvent返回值和下级view的dispatchTouchEvent结果影响。
该方法返回true，表示该事件可能被本层或被下层处理了，事件不再分发
有以下几种情况：
1.）onInterceptTouchEvent拦截了事件(返回true)，且本层onTouchEvent处理了事件(返回true)；
2.）下层元素的dispatchTouchEvent返回值为true，事件被下层处理掉了。
该方法返回false，表示事件本层或下层没处理。事件上抛给父层
有以下几种情况：
1.）onInterceptTouchEvent拦截了事件，但本层的onTouchEvent没处理该事件(返回false)，表示本层没有能力处理该事件，该事件上抛给父容器处理。
2.）onInterceptTouchEvent没拦截该事件(返回false)，但下层的dispatchTouchEvent因该层的onTouchEvent返回false，表示下层没有能力处理该事件。
注意：如果某个组件的dispatchTouchEvent()方法返回了true,那么该事件序列后续的事件都会给该组件处理，除非我们重写dispatchTouchEvent()返回false或者通过onInterceptTouchEvent()拦截事件。
- onInterceptTouchEvent()：ViewGroup对事件是否进行拦截（默认false即不做拦截处理，直接传递到子view的dispatchTouchEvent），只有ViewGroup都有该方法。
返回true，将事件进行拦截，并将拦截到的事件交由本层控件的 onTouchEvent 进行处理；
返回false，不对事件进行拦截，该事件被分发到子View，并由子View的dispatchTouchEvent分发。
默认返回super.onInterceptTouchEvent(ev)，事件默认不会被拦截，交由子View的dispatchTouchEvent进行处理。
如果当前view拦截了该事件，则在同事件序列中后续事件都会直接交给该view处理，不再调用onInterceptTouchEvent方法了。
二、dispatchTouchEvent方法源码解析
在解析过程中有一个很重要的变量 mFirstTouchTarget 需要额外注意。
mFirstTouchTarget表示一个事件系列中可以处理触摸事件的子组件，如果mFirstTouchTarget不为null,表示我们已经找到了该子组件
dispatchTouchEvent方法源码如下：源码很长，我分成了四个步骤，都加上了一些注释帮助理解，如果不想看源码，可以略过源码直接看后面的四步骤解析：
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
if (mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onTouchEvent(ev, 1);
}
if (ev.isTargetAccessibilityFocus() && isAccessibilityFocusedViewOrHost()) {
ev.setTargetAccessibilityFocus(false);
}
boolean handled = false;
if (onFilterTouchEventForSecurity(ev)) {
final int action = ev.getAction();
final int actionMasked = action & MotionEvent.ACTION_MASK;
//第一步：
//ACTION_DOWN是事件序列的开端,所以触摸事件ACTION_DOWN时进行初始化操作。
//cancelAndClearTouchTargets和resetTouchState方法都用于清空上一次触摸事件的缓存数据。会把 mFirstTouchTarget 清空为null
if (actionMasked == MotionEvent.ACTION_DOWN) {
cancelAndClearTouchTargets(ev);
resetTouchState();
}
//第二步：检查触摸事件是否需要拦截
final boolean intercepted; //定义一个变量intercepted来标志是否需要拦截触摸事件。
if (actionMasked == MotionEvent.ACTION_DOWN
|| mFirstTouchTarget != null) {
//事件为ACTION_DOWN或者mFirstTouchTarget不为null,
final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
//判断disallowIntercept禁止拦截
//因为在其他地方可能调用了requestDisallowInterceptTouchEvent(boolean disallowIntercept)
//从而禁止执行是否需要拦截的判断。字面意思，禁止调用owInterceptTouchEvent（）方法进行触摸事件的拦截。
if (!disallowIntercept) {
//如果可以调用owInterceptTouchEvent（），则调用onInterceptTouchEvent（）方法判断是否拦截这个触摸事件
intercepted = onInterceptTouchEvent(ev);
ev.setAction(action);
} else {
//不允许调用owInterceptTouchEvent（）方法，不拦截事件
intercepted = false;
}
} else {
//当不是ACTION_DOWN事件并且mFirstTouchTarget为null(即没有可以处理触摸事件的子组件)时
//设置 intercepted = true表示ViewGroup拦截触摸事件。
intercepted = true;
}
if (intercepted || mFirstTouchTarget != null) {
ev.setTargetAccessibilityFocus(false);
}
// 判断是不是ACTION_CANCEL事件
final boolean canceled = resetCancelNextUpFlag(this)
|| actionMasked == MotionEvent.ACTION_CANCEL;
// 第三步：进行事件分发：
final boolean isMouseEvent = ev.getSource() == InputDevice.SOURCE_MOUSE;
final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0
&& !isMouseEvent;
TouchTarget newTouchTarget = null;
boolean alreadyDispatchedToNewTouchTarget = false;
if (!canceled && !intercepted) {
//不是ACTION_CANCEL事件 并且ViewGroup不拦截，那我们可以去找一个子组件处理触摸事件。
View childWithAccessibilityFocus = ev.isTargetAccessibilityFocus()
? findChildWithAccessibilityFocus() : null;
if (actionMasked == MotionEvent.ACTION_DOWN
|| (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
|| actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
//如果是ACTION_DOWN事件
//下面代码概述：
// 开启了一个循环，循环所有的子View判断哪个子View可以处理触摸事件。
子view是否可以处理触摸事件肯定也是调用子view 的dispatchTouchEvent()方法判断，该循环中的dispatchTransformedTouchEvent（）里面就是调用的子view 的dispatchTouchEvent()方法，如果返回true,我们就找到了可以触摸事件的子view ，并将该子view 赋值给mFirstTouchTarget。
final int actionIndex = ev.getActionIndex();
final int idBitsToAssign = split ? 1 << ev.getPointerId(actionIndex)
: TouchTarget.ALL_POINTER_IDS;
removePointersFromTouchTargets(idBitsToAssign);
final int childrenCount = mChildrenCount;
if (newTouchTarget == null && childrenCount != 0) {
final float x =
isMouseEvent ? ev.getXCursorPosition() : ev.getX(actionIndex);
final float y =
isMouseEvent ? ev.getYCursorPosition() : ev.getY(actionIndex);
final ArrayList<View> preorderedList = buildTouchDispatchChildList();
final boolean customOrder = preorderedList == null
&& isChildrenDrawingOrderEnabled();
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 (childWithAccessibilityFocus != null) {
if (childWithAccessibilityFocus != child) {
continue;
}
childWithAccessibilityFocus = null;
i = childrenCount - 1;
}
if (!child.canReceivePointerEvents()
|| !isTransformedTouchPointInView(x, y, child, null)) {
ev.setTargetAccessibilityFocus(false);
continue;
}
newTouchTarget = getTouchTarget(child);
if (newTouchTarget != null) {
newTouchTarget.pointerIdBits |= idBitsToAssign;
break;
}
resetCancelNextUpFlag(child);
if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
mLastTouchDownTime = ev.getDownTime();
if (preorderedList != null) {
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;
}
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) {
如果没有找到，则调用dispatchTransformedTouchEvent（）方法，不过这里传的参数是null,该方法内部如果是null,就会判断ViewGroup自身是否可以处理触摸事件。
handled = dispatchTransformedTouchEvent(ev, canceled, null,
TouchTarget.ALL_POINTER_IDS);
} else {
// 如果找到了，则调用 dispatchTransformedTouchEvent（）方法，
//并传值是mFirstTouchTarget，dispatchTransformedTouchEvent内部会调用子View的dispatchTouchEvent()方法，完成事件的分发，
//因为我们在第三步为了找到一个可以出发触摸事件的子View，可能已经调用过dispatchTransformedTouchEvent（）方法分发过一次了，所以在第三步和第四步都加了一个boolean值 alreadyDispatchedToNewTouchTarget，避免进行重复分发。
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;
}
if (cancelChild) {
if (predecessor == null) {
mFirstTouchTarget = next;
} else {
predecessor.next = next;
}
target.recycle();
target = next;
continue;
}
}
predecessor = target;
target = next;
}
}
// Update list of touch targets for pointer up or cancel, if needed.
if (canceled
|| actionMasked == MotionEvent.ACTION_UP
|| actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
resetTouchState();
} else if (split && actionMasked == MotionEvent.ACTION_POINTER_UP) {
final int actionIndex = ev.getActionIndex();
final int idBitsToRemove = 1 << ev.getPointerId(actionIndex);
removePointersFromTouchTargets(idBitsToRemove);
}
}
if (!handled && mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onUnhandledEvent(ev, 1);
}
return handled;
}
//另一个重要的方法：
//该方法很简单，如果传入的child不是null,调用child的dispatchTouchEvent（）方法，如果传入的child是null,则调用ViewGroup基类也就是View类的dispatchTouchEvent（）方法，判断当前ViewGroup自身可以不可以处理触摸事件。
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);
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 (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;
}
我们来梳理一下上面代码过程
dispatchTouchEvent源码步骤：
第一步： ACTION_DOWN 事件来了，表示一个新的触摸系列开始了，ViewGroup清空上一次触摸事件系列的缓存，主要是上次一触摸事件中处理触摸事件的View ：mFirstTouchTarget。
第二步：如果是 ACTION_DOWN事件 或者 mFirstTouchTarget 不是空的（即经过下面第3步已经找到了处理触摸事件的View）,需要调用onInterceptTouchEvent（）方法判断是拦截 该触摸事件。
第三步：如果不拦截，并且是 ACTION_DOWN事件（触摸事件的开始），我们需要寻找一个可以处理该事件的子View,办法肯定是循环所有子View，对其调用dispatchTouchEvent()方法。这时候触摸事件已经分发到了子view。
该步骤只会在ACTION_DOWN事件的时候调用一次，也就是一个触摸事件系列只会找到一个可以处理的子View。
这也是为什么dispatchTouchEvent()方法返回了true,那么事件序列后续的事件都会交给一个组件处理，因为dispatchTouchEvent()方法只会在ACTION_DOWN事件的时候去寻找一个可以处理触摸事件的子View，其他事件不会去寻找。
第四步：这是一个if判断，判断mFirstTouchTarget（就是我们经过第三步，找到了可以处理触摸事件的子View）是不是null, ，那么后续的触摸事件ACTION_MOVE、ACTION_UP都会再次调用 这个子View的dispatchTouchEvent()方法，这就完成了 后续触摸事件分发给子view。
如果我们经过第三步，没有找到可以处理触摸事件的子View ，我们肯定是判断ViewGroup自身可不可以处理触摸事件，因为ViewGroup继承自View，所以调用了View基类的dispatchTouchEvent()方法判断ViewGroup自身可不可以处理触摸事件。
第三步和第四步的核心方法就是：dispatchTransformedTouchEvent（）方法。
该方法的核心代码就是：
if (child == null) {
handled = super.dispatchTouchEvent(event);
//mFirstTouchTarget是null,我们没有找到可以处理触摸事件的子View，交给ViewGroup处理，判断ViewGroup可以不可以处理触摸事件
} else {
handled = child.dispatchTouchEvent(event);
//mFirstTouchTarget不是null,我们找到了一个可以处理触摸事件的子View,那就分发事件给他
}
上面我们讲到的都是不拦截的情况，如果存在拦截会怎么样？拦截分为两种情况，
-
）第一种就是直接从ACTION_DOWN事件开始拦截，通过第三步我们知道，当ACTION_DOWN来临时，只有满足 if (!canceled && !intercepted) 才会去寻找一个可以处理触摸事件的子ViewmFirstTouchTarget，如果我们从ACTION_DOWN就拦截，那么就不会去找这个子view ,那么mFirstTouchTarget也就是null,
所以会执行第四步的if判断
if (mFirstTouchTarget == null) {
handled = dispatchTransformedTouchEvent(ev, canceled, null,
TouchTarget.ALL_POINTER_IDS);
}
通过dispatchTransformedTouchEvent的核心代码我们知道，传入了一个null,会调用当前ViewGroup的基类View类的dispatchTouchEvent进行自身的触摸事件处理。 -
）第二种就是不在ACTION_DOWN事件拦截，而是在 ACTION_MOVE进行拦截，这个时候mFirstTouchTarget可能不是null，所以进入了第一种情况的else分支：
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;
}
if (cancelChild) {
if (predecessor == null) {
mFirstTouchTarget = next;
} else {
predecessor.next = next;
}
target.recycle();
target = next;
continue;
}
}
predecessor = target;
target = next;
}
上面代码的核心代码如下：
final boolean cancelChild = resetCancelNextUpFlag(target.child)
|| intercepted;
if (dispatchTransformedTouchEvent(ev, cancelChild,
target.child, target.pointerIdBits)) {
handled = true;
}
可以看到还是通过dispatchTransformedTouchEvent（）方法把事件分发。
上面代码的后面代码是如果我们拦截了触摸事件会把mFirstTouchTarget设置为null。就是下面的代码：(这也就是为什么如果当前view拦截了该事件，则在同事件序列中后续事件都会直接交给该view处理，因为mFirstTouchTarget已经被重制为null了)
if (cancelChild) {
if (predecessor == null) {
mFirstTouchTarget = next;
} else {
predecessor.next = next;
}
target.recycle();
target = next;
continue;
}
是的，如果要拦截触摸事件，就会给dispatchTransformedTouchEvent传入一个false，在dispatchTransformedTouchEvent方法中，如果传入false，会分发一个ACTION_CANCEL事件而不会分发原始事件。
dispatchTransformedTouchEvent（）方法的处理代码如下：
final int oldAction = event.getAction();
if (cancel || oldAction == MotionEvent.ACTION_CANCEL) {
event.setAction(MotionEvent.ACTION_CANCEL);
if (child == null) {
handled = super.dispatchTouchEvent(event);
} else {
handled = child.dispatchTouchEvent(event);
}
event.setAction(oldAction);
return handled;
}
实例演示：
class MyLinearLayout(
context : Context , @Nullable attrs : AttributeSet? ,
defStyleAttr : Int ,
) : LinearLayout(context , attrs , defStyleAttr) {
constructor(context : Context) : this(context , null , -1)
constructor(context : Context , @Nullable attrs : AttributeSet?) : this(context , attrs , -1)
init {
orientation = VERTICAL
setBackgroundColor(Color.parseColor("#00FF00"))
}
override fun dispatchTouchEvent(ev : MotionEvent?) : Boolean {
if (ev!!.action == MotionEvent.ACTION_DOWN) {
Log.e("父组件分发了DOWN事件" , "--------")
// return true
} else if (ev.action == MotionEvent.ACTION_MOVE) {
Log.e("父组件分发了MOVE事件" , "--------")
// return false
} else if (ev.action == MotionEvent.ACTION_UP) {
Log.e("父组件分发了UP事件" , "--------")
}
return super.dispatchTouchEvent(ev)
}
override fun onInterceptTouchEvent(ev : MotionEvent?) : Boolean {
if (ev!!.action == MotionEvent.ACTION_DOWN) {
Log.e("父组件拦截了DOWN事件" , "--------")
// return true
} else if (ev.action == MotionEvent.ACTION_MOVE) {
Log.e("父组件拦截了MOVE事件" , "--------")
// return true
} else if (ev.action == MotionEvent.ACTION_UP) {
Log.e("父组件拦截了UP事件" , "--------")
// return true
}
return super.onInterceptTouchEvent(ev)
}
}
class MyView(
context : Context , @Nullable attrs : AttributeSet? ,
defStyleAttr : Int ,
) : View(context , attrs , defStyleAttr) {
constructor(context : Context) : this(context , null , -1)
constructor(context : Context , @Nullable attrs : AttributeSet?) : this(context , attrs , -1)
init {
setBackgroundColor(Color.parseColor("#FF0000"))
}
override fun onMeasure(widthMeasureSpec : Int , heightMeasureSpec : Int) {
setMeasuredDimension(500 , 500)
}
override fun dispatchTouchEvent(event : MotionEvent?) : Boolean {
if (event!!.action == MotionEvent.ACTION_DOWN) {
Log.e("子组件分发了DOWN事件" , "--------")
} else if (event.action == MotionEvent.ACTION_MOVE) {
Log.e("子组件分发了MOVE事件" , "--------")
} else if (event.action == MotionEvent.ACTION_UP) {
Log.e("子组件分发了UP事件" , "--------")
}else if (event.action == MotionEvent.ACTION_CANCEL) {
Log.e("子组件分发了Cancel事件" , "--------")
}
return super.dispatchTouchEvent(event)
}
}
<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=".MainActivity">
<com.cxkj.myapplication.MyLinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content">
<com.cxkj.myapplication.MyView
android:id="@+id/myView"
android:layout_width="wrap_content"
android:layout_height="wrap_content">
</com.cxkj.myapplication.MyView>
</com.cxkj.myapplication.MyLinearLayout>
</LinearLayout>
val myView = findViewById<MyView>(R.id.myView)
myView.setOnClickListener {
Log.e("子view被点击了" , "--------")
}
上面代码：
我们定义了一个绿色的LinaearLayout,重写dispatchTouchEvent和onInterceptTouchEvent事件，加上打印好观察
一个红色的的View并放在了，重写了dispatchTouchEvent，加上打印好观察。
1.）我们在父组件拦截 Action_Move，我们把MyLinearLayout的下面代码中的 // return true注释放开，然后我们触摸MyView，会是一种什么情况呢？
else if (ev.action == MotionEvent.ACTION_MOVE) {
Log.e("父组件拦截了MOVE事件" , "--------")
return true
}
打印结果：
父组件分发了DOWN事件: --------
父组件拦截了DOWN事件: --------
子组件分发了DOWN事件: --------
父组件分发了MOVE事件: --------
父组件拦截了MOVE事件: --------
子组件分发了Cancel事件: --------
父组件分发了MOVE事件: --------
父组件分发了MOVE事件: --------
父组件分发了UP事件: --------
可以看到 DOWN事件完成了正常的分发，而第一次MOVE事件只被ViewGroup分发了，然后多出了一个Cancel事件分发给了子View，然后后面的MOVE事件就不再到达子View了，这就验证了上面的源码逻辑（拦截后会分发一个Cancel事件并把mFirstTouchTarget重制为null）。
那如果我们只是轻轻的点一下呢？没有任何的MOVE操作，打印又会是怎么样的呢？打印结果如下：
父组件分发了DOWN事件: --------
父组件拦截了DOWN事件: --------
子组件分发了DOWN事件: --------
父组件分发了UP事件: --------
父组件拦截了UP事件: --------
子组件分发了UP事件: --------
子view被点击了: --------
是的，因为没有MOVE事件，所有没有被拦截过，所以mFirstTouchTarget没有被重置为null,这就使得UP事件正常的分发到达了子组件。
2.）如果我们直接从DOWN事件拦截呢？我们把MyLinearLayout的下面代码中的 // return true注释放开，然后我们触摸MyView，会是一种什么情况呢？
if (ev!!.action == MotionEvent.ACTION_DOWN) {
Log.e("父组件分发了DOWN事件" , "--------")
// return true
}
打印结果：
父组件分发了DOWN事件: --------
父组件拦截了DOWN事件: --------
很神奇，MyLinearLayout只能分发DOWN事件，这是为什么呢？因为我们从一开始就拦截了事件，所以mFirstTouchTarget =null, 所有的事件都会MyLinearLayout自身处理，但我们并没有给MyLinearLayout添加点击事件，也就是MyLinearLayout的 onTouchEvent返回的是false,表示他不能处理触摸事件，要记得MyLinearLayout也是有父布局的，对于MyLinearLayout的父布局，他也会进行上述的流程，当MyLinearLayout的父布局知道MyLinearLayout不能处理触摸事件后，也就不会再分发后续事件给MyLinearLayout了，所以就出现了上面的情况。