如何自己实现Android View Touch事件分发流程

目录

• MotionEvent

• View

• ViewGroup

• 事件拦截

• 寻找目标视图，分发ACTION_DOWN

• 分发除ACTION_DOWN外的其他事件

• 使用

• 总结

Android Touch事件分发是Android UI中的重要内容，Touch事件从驱动层向上，经过InputManagerService，WindowManagerService，ViewRootImpl，Window，到达DecorView，经View树分发，最终被消费。

本文尝试通过对其中View部分的事件分发，也是与日常开发联系最紧密的部分，进行重写。说是重写，其实是对Android该部分源码进行大幅精简而不失要点，且能够独立运行，以一窥其全貌，而不陷入到源码繁杂的细节中。

以下类均为自定义类，而非Android同名原生类。

MotionEvent

class MotionEvent {
companion object {
 const val ACTION_DOWN = 0
 const val ACTION_MOVE = 1
 const val ACTION_UP = 2
 const val ACTION_CANCEL = 3
}
var x = 0
var y = 0
var action = 0
override fun toString(): String {
 return "MotionEvent(x=$x, y=$y, action=$action)"
}
}

首先定义MotionEvent，这里将触摸事件action减少为最常用的4种，同时只支持单指操作，因此action取值仅支持4个常量。并且为了简化后续的位置计算，x和y表示的是绝对坐标（相当于getRawX()与getRawY()），而非相对坐标。

View

open class View {
var left = 0
var right = 0
var top = 0
var bottom = 0//1

var enable = true
var clickable = false
var onTouch: ((View, MotionEvent) -> Boolean)? = null
var onClick: ((View) -> Unit)? = null//3
 set(value) {
  field = value
  clickable = true
 }

private var downed = false

open fun layout(l: Int, t: Int, r: Int, b: Int) {
 left = l
 top = t
 right = r
 bottom = b
}//2

open fun onTouchEvent(ev: MotionEvent): Boolean {
 var handled: Boolean
 if (enable && clickable) {
  when (ev.action) {
   MotionEvent.ACTION_DOWN -> {
    downed = true
   }
   MotionEvent.ACTION_UP -> {
    if (downed && ev.inView(this)) {//7
     downed = false
     onClick?.invoke(this)
    }
   }
   MotionEvent.ACTION_MOVE -> {
    if (!ev.inView(this)) {//7
     downed = false
    }
   }
   MotionEvent.ACTION_CANCEL -> {
    downed = false
   }
  }
  handled = true
 } else {
  handled = false
 }
 return handled
}//5

open fun dispatchTouchEvent(ev: MotionEvent): Boolean {
 var result = false
 if (onTouch != null && enable) {
  result = onTouch!!.invoke(this, ev)
 }
 if (!result && onTouchEvent(ev)) {
  result = true
 }
 return result
}//4
}
fun MotionEvent.inView(v: View) = v.left <= x && x <= v.right && v.top <= y && y <= v.bottom//6

接下来定义View。（1）定义了View的位置，这里同样表示绝对坐标，而不是相对于父View的位置。（2）同时使用layout方法传递位置，因为我们的重点是View的事件分发而不是其布局与绘制，因此只定义了layout。（3）触摸回调这里直接使用函数类型定义，（4）dispatchTouchEvent先处理了onTouch回调，如果未回调，则调用onTouchEvent，可见二者的优先级。（5）onTouchEvent则主要处理了onClick回调，虽然真实源码中对点击的判断更为复杂，但实际效果与此处是一致的，（6）使用扩展函数来确定事件是否发生在View内部，（7）两处调用配合downed标记确保ACTION_MOVE与ACTION_UP发生在View内才被识别为点击。至于长按等其他手势的监听，因为较为繁琐，这里就不再实现。

ViewGroup

open class ViewGroup(private vararg val children: View) : View() {//1
private var mFirstTouchTarget: View? = null

open fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
 return false
}//2

override fun dispatchTouchEvent(ev: MotionEvent): Boolean {//3
 val intercepted: Boolean
 var handled = false

if (ev.action == MotionEvent.ACTION_DOWN) {
  mFirstTouchTarget = null
 }//4
 if (ev.action == MotionEvent.ACTION_DOWN || mFirstTouchTarget != null) {
  intercepted = onInterceptTouchEvent(ev)//5
 } else {
  intercepted = true//6
 }

val canceled = ev.action == MotionEvent.ACTION_CANCEL
 var alreadyDispatchedToNewTouchTarget = false
 if (!intercepted) {
  if (ev.action == MotionEvent.ACTION_DOWN) {//7
   for (child in children.reversed()) {//8
    if (ev.inView(child)) {//9
     if (dispatchTransformedTouchEvent(ev, false, child)) {//10
      mFirstTouchTarget = child
      alreadyDispatchedToNewTouchTarget = true//12
     }
     break
    }
   }
  }
 }

if (mFirstTouchTarget == null) {
  handled = dispatchTransformedTouchEvent(ev, canceled, null)//17
 } else {
  if (alreadyDispatchedToNewTouchTarget) {//13
   handled = true
  } else {
   val cancelChild = canceled || intercepted//14
   if (dispatchTransformedTouchEvent(ev, cancelChild, mFirstTouchTarget)) {
    handled = true
   }
   if (cancelChild) {
    mFirstTouchTarget = null//16
   }
  }
 }

if (canceled || ev.action == MotionEvent.ACTION_UP) {
  mFirstTouchTarget = null
 }//4
 return handled
}

private fun dispatchTransformedTouchEvent(ev: MotionEvent, cancel: Boolean, child: View?): Boolean {
 if (cancel) {
  ev.action = MotionEvent.ACTION_CANCEL//15
 }
 val oldAction = ev.action
 val handled = if (child == null) {
  super.dispatchTouchEvent(ev)//18
 } else {
  child.dispatchTouchEvent(ev)//11
 }
 ev.action = oldAction
 return handled
}
}

最后来实现ViewGroup：（1）子View这里通过构造函数传入， 而不再提供addView等方法，（2）onInterceptTouchEvent简单返回false，主要通过子类继承来修改返回，（3）dispatchTouchEvent是整个实现中最主要的逻辑，来详细解释，这里的实现只包含对单指Touch事件的处理，并且不包含requestDisallowInterceptTouchEvent的情况。

（4）源码中开头和结尾处有清理字段与标记的方法，用于在一个事件序列（由ACTION_DOWN开始，经过若干ACTION_MOVE等，最终以ACTION_UP结束，即整个触摸过程）开头和结束时清理旧数据，这里简化为了将我们类中的唯一字段mFirstTouchTarget（表示整个事件序列的目标视图，在源码中，此变量类型为TouchTarget，实现为一个View的链表节点，以此来支持多指触摸，这里简化为View）置空。

接下来将该方法分为几部分来介绍：

事件拦截

（5）表示在一个事件序列的开始或者已经找到了目标视图的情况下，才需要调用onInterceptTouchEvent判断本ViewGroup是否拦截事件。（6）表示如果ACTION_DOWN没有视图消费，则之后的事件将被拦截，且拦截的View是View树中的顶层View，即Android中的DecorView。

寻找目标视图，分发ACTION_DOWN

（7）当ACTION_DOWN事件未被拦截，（8）则反向遍历子View数组，（9）寻找ACTION_DOWN事件落在其中的View，（10）并将ACTION_DOWN事件传递给该子View，这一步调用了dispatchTransformedTouchEvent，该方法将源码中的方法简化为了三参数，方法名中的Transformed表示，会将Touch事件进行坐标系的变换，而这里为了简化使用的坐标是绝对的，因此不需要变换。此时会调用dispatchTransformedTouchEvent中（11）处向子View分发ACTION_DOWN，child即mFirstTouchTarget。

分发除ACTION_DOWN外的其他事件

（12）对于ACTION_DOWN事件，会将alreadyDispatchedToNewTouchTarget置位，（13）此时会会进入if块，而非ACTION_DOWN事件会进入else块。（14）当该事件是ACTION_CANCEL或者事件被拦截，则在调用dispatchTransformedTouchEvent的（15）处后，将事件修改为ACTION_CANCEL，然后调用（11），将ACTION_CANCEL分发给子View，（16）同时将mFirstTouchTarget置空。当事件序列中的下个事件到来时，会进入（17）处，即最终调用（18），调用上节中View的事件处理，即ViewGroup消费该事件，消费该事件的ViewGroup即拦截了非ACTION_DOWN事件并向子View分发ACTION_CANCEL的ViewGroup。

使用

至此，实现了MotionEvent，View，与ViewGroup，来进行一下验证。

定义三个子类：

class VG1(vararg children: View) : ViewGroup(*children)
class VG2(vararg children: View) : ViewGroup(*children)
class V : View() {
override fun onTouchEvent(ev: MotionEvent): Boolean {
 println("V onTouchEvent $ev")
 return super.onTouchEvent(ev)
}

override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
 println("V dispatchTouchEvent $ev")
 return super.dispatchTouchEvent(ev)
}
}

定义一个事件发生方法，由该方法来模拟Touch事件的轨迹与action:

fun produceEvents(startX: Int, startY: Int, endX: Int, endY: Int, stepNum: Int): List<MotionEvent> {
val list = arrayListOf<MotionEvent>()
val stepX = (endX - startX) / stepNum
val stepY = (endY - startY) / stepNum
for (i in 0..stepNum) {
 when (i) {
  0 -> {
   list.add(MotionEvent().apply {
    action = MotionEvent.ACTION_DOWN
    x = startX
    y = startY
   })
  }
  stepNum -> {
   list.add(MotionEvent().apply {
    action = MotionEvent.ACTION_UP
    x = endX
    y = endY
   })
  }
  else -> {
   list.add(MotionEvent().apply {
    action = MotionEvent.ACTION_MOVE
    x = stepX * i + startX
    y = stepY * i + startY
   })
  }
 }
}
return list
}

接下来就可以验证了，在Android中事件由驱动层一步步传递至View树的顶端，这里我们定义一个三层的布局page，（1）直接将事件序列遍历调用顶层ViewGroup的dispatchTouchEvent来开启事件分发。

fun main() {
val page = VG1(
 VG2(
  V().apply { layout(0, 0, 100, 100); onClick = { println("Click in V") } }//2
 ).apply { layout(0, 0, 200, 200) }
).apply { layout(0, 0, 300, 300) }//3

val events = produceEvents(50, 50, 90, 90, 5)
events.forEach {
 page.dispatchTouchEvent(it)//1
}
}

程序可以正常执行，打印如下：

V dispatchTouchEvent MotionEvent(x=50, y=50, action=0)
V onTouchEvent MotionEvent(x=50, y=50, action=0)
V dispatchTouchEvent MotionEvent(x=58, y=58, action=1)
V onTouchEvent MotionEvent(x=58, y=58, action=1)
V dispatchTouchEvent MotionEvent(x=66, y=66, action=1)
V onTouchEvent MotionEvent(x=66, y=66, action=1)
V dispatchTouchEvent MotionEvent(x=74, y=74, action=1)
V onTouchEvent MotionEvent(x=74, y=74, action=1)
V dispatchTouchEvent MotionEvent(x=82, y=82, action=1)
V onTouchEvent MotionEvent(x=82, y=82, action=1)
V dispatchTouchEvent MotionEvent(x=90, y=90, action=2)
V onTouchEvent MotionEvent(x=90, y=90, action=2)
Click in V

因为我们在（2）增加了点击事件，以上表示了一次点击的事件分发。也可以重写修改page布局（3）来查看其它情景下的事件分发流程，或者重写VG1，VG2的方法，增加打印并查看。

总结

通过对Android 源码的整理，用约150行代码就能实现了一个简化版的Android Touch View事件分发，虽然为了代码结构的简洁舍弃了部分功能，但整个流程与Android Touch View事件分发是一致的，能够更方便理解这套机制。

来源：https://juejin.cn/post/6904069282657730573