不知道大家平时在开发 Android 项目时有没有好奇我们经常使用的控件如 Button、TextView 等是怎么响应我们手指点击的？或者滑动控件如 RecyclerView、ViewPager 等是怎么随着我们手指滑动的？当然，诸如此类场景很多很多，比如下拉刷新啊、拖动排序啊等等，可以说，只要是手机屏幕上产生的效果是通过用户手指触发的，都要涉及到 Android 的事件机制，今天，我们就来理理 Android 的事件机制到底是怎么回事，走起！

首先我们通过一张流程图来大体了解下 Android 的一个事件是怎样分发下去的：

android_event_dispatch.png

事件序列

接下来我们说下什么叫事件序列，通过上面一张图，我们不难看出一个事件由开始到结束经历了很多的成员及方法，那么一个事件序列就是指从手指接触屏幕的那一刻起，到手指离开屏幕的那一刻结束时这个过程中产生的一系列动作。一个事件序列中包含多个动作（按下、滑动等），如果一个动作不被一个 View 所消耗，那么这个事件序列后续的动作也不会再交由这个 View 处理，例如一个 View 不消耗按下动作时，那么后续的滑动等动作也不会收到了

示例代码

事件监听器及事件处理器

class EventActivity : AppCompatActivity() {

    private val DEBUG_TAG = "EventActivity"

    private lateinit var mView:View

    private lateinit var mViewGroup:ViewGroup

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        mViewGroup = object : ViewGroup(this){
            override fun onLayout(changed: Boolean, 
                                  l: Int, 
                                  t: Int, 
                                  r: Int, 
                                  b: Int) {}
        }
        /**
         * View 事件监听器         
         */
        mView = View(this)
        mView.setOnClickListener{view ->}
        mView.setOnLongClickListener{view -> false}
        mView.setOnTouchListener{view,motionevent-> false}
        mView.setOnFocusChangeListener { view, hasFocus -> }
        mView.setOnContextClickListener { view -> false }
        mView.setOnCreateContextMenuListener{menu, view, menuInfo ->  }
    }

    /**
     * View 中也有此方法
     */
    override fun dispatchTouchEvent(ev: MotionEvent?): Boolean {
        // ViewParent 接口方法，子 View 要求父容器不要拦截我的事件
        // 注意自定义 ViewGroup 时一定不要拦截 ACTION_DOWN 事件
        // 不然后续事件永远无法传递到子 View
        mView.parent.requestDisallowInterceptTouchEvent(true)
        return super.dispatchTouchEvent(ev)
    }

    /**
     * 返回 true 表示拦截事件，ViewGroup 及其子类才有此方法
     */
    /*override fun onInterceptTouchEvent(ev: MotionEvent?): Boolean {
        return super.onInterceptTouchEvent(ev)
    }*/

    /**
     * View 中也有此方法
     * 注意下 MotionEventCompat 类不是 MotionEvent 的替代，
     * 而是操作 MotionEvent 的辅助类
     */
    override fun onTouchEvent(event: MotionEvent): Boolean {
        // 以下的 3 种方法均可获取事件动作类型
        val action = event.actionMasked
        // val action = event.action
        // val action = MotionEventCompat.getActionMasked(event)
        return when (action) {
            MotionEvent.ACTION_DOWN -> {
                Log.d(DEBUG_TAG, "Action was DOWN")
                true
            }
            MotionEvent.ACTION_MOVE -> {
                Log.d(DEBUG_TAG, "Action was MOVE")
                true
            }
            MotionEvent.ACTION_UP -> {
                Log.d(DEBUG_TAG, "Action was UP")
                true
            }
            MotionEvent.ACTION_CANCEL -> {
                Log.d(DEBUG_TAG, "Action was CANCEL")
                true
            }
            MotionEvent.ACTION_OUTSIDE -> {
                Log.d(DEBUG_TAG, "Movement occurred outside bounds of current screen element")
                true
            }
            else -> super.onTouchEvent(event)
        }
    }

    /**
     * View 中也有此方法
     */
    override fun onKeyDown(keyCode: Int, event: KeyEvent?): Boolean {
        return super.onKeyDown(keyCode, event)
    }

    /**
     * View 中也有此方法
     */
    override fun onKeyUp(keyCode: Int, event: KeyEvent?): Boolean {
        return super.onKeyUp(keyCode, event)
    }

    /**
     * View 中也有此方法
     */
    override fun onKeyLongPress(keyCode: Int, event: KeyEvent?): Boolean {
        return super.onKeyLongPress(keyCode, event)
    }

    /**
     * View 中也有此方法
     */
    override fun onKeyMultiple(keyCode: Int, 
                               repeatCount: Int, 
                               event: KeyEvent?): Boolean {
        return super.onKeyMultiple(keyCode, repeatCount, event)
    }

    /**
     * OnCreateContextMenuListener 也有此方法
     */
    override fun onCreateContextMenu(menu: ContextMenu?, 
                                     v: View?, 
                                     menuInfo: ContextMenu.ContextMenuInfo?) {
        super.onCreateContextMenu(menu, v, menuInfo)
    }

    /**
     * View 有一 onFocusChanged 方法
     */
    override fun onWindowFocusChanged(hasFocus: Boolean) {
        super.onWindowFocusChanged(hasFocus)
    }

}

我们一般将以 XxxListener 结尾的类中的方法称作事件监听方法，其它与事件处理相关的方法叫做事件处理方法

GestureDetectorCompat 使用

private const val DEBUG_TAG = "Gestures"

/**
 * 如果只想覆写 GestureDetector.OnGestureListener 部分方法，
 * 可实现 GestureDetector.SimpleOnGestureListener 接口
 */
class MainActivity :
        Activity(),
        GestureDetector.OnGestureListener,
        GestureDetector.OnDoubleTapListener,
        GestureDetector.OnContextClickListener{

    private lateinit var mDetector: GestureDetectorCompat
          
    public override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        mDetector = GestureDetectorCompat(this, this)
        mDetector.setOnDoubleTapListener(this)
        mDetector.setContextClickListener(this)
    }

    override fun onTouchEvent(event: MotionEvent): Boolean {
        return if (mDetector.onTouchEvent(event)) {
            true
        } else {
            super.onTouchEvent(event)
        }
    }

    /**
     * 注意此方法需返回 true，不然不会有后续方法的回调
     */
    override fun onDown(event: MotionEvent): Boolean {
        Log.d(DEBUG_TAG, "onDown: $event")
        return true
    }

    override fun onFling(
            event1: MotionEvent,
            event2: MotionEvent,
            velocityX: Float,
            velocityY: Float
    ): Boolean {
        Log.d(DEBUG_TAG, "onFling: $event1 $event2")
        return true
    }

    override fun onLongPress(event: MotionEvent) {
        Log.d(DEBUG_TAG, "onLongPress: $event")
    }

    override fun onScroll(
            event1: MotionEvent,
            event2: MotionEvent,
            distanceX: Float,
            distanceY: Float
    ): Boolean {
        Log.d(DEBUG_TAG, "onScroll: $event1 $event2")
        return true
    }

    override fun onShowPress(event: MotionEvent) {
        Log.d(DEBUG_TAG, "onShowPress: $event")
    }

    override fun onSingleTapUp(event: MotionEvent): Boolean {
        Log.d(DEBUG_TAG, "onSingleTapUp: $event")
        return true
    }

    override fun onDoubleTap(event: MotionEvent): Boolean {
        Log.d(DEBUG_TAG, "onDoubleTap: $event")
        return true
    }

    override fun onDoubleTapEvent(event: MotionEvent): Boolean {
        Log.d(DEBUG_TAG, "onDoubleTapEvent: $event")
        return true
    }

    override fun onSingleTapConfirmed(event: MotionEvent): Boolean {
        Log.d(DEBUG_TAG, "onSingleTapConfirmed: $event")
        return true
    }
    
    override fun onContextClick(e: MotionEvent?): Boolean {
        Log.d(DEBUG_TAG, "onContextClick: $event")
        return true
    }

}

手指移动速度监测

private const val TAG_VELOCITY = "velocity"

class VelocityActivity: AppCompatActivity(){

    private var mVelocityTracker:VelocityTracker? = null

    override fun onTouchEvent(event: MotionEvent): Boolean {

        when (event.actionMasked) {
            MotionEvent.ACTION_DOWN -> {
                mVelocityTracker?.clear()
                mVelocityTracker = mVelocityTracker ?: VelocityTracker.obtain()
                mVelocityTracker?.addMovement(event)
            }
            MotionEvent.ACTION_MOVE -> {
                mVelocityTracker?.apply {
                    val pointerId: Int = event.getPointerId(event.actionIndex)
                    addMovement(event)
                    // 计算速度，参数单位为毫秒，即每多少秒的速度
                    // 调用了这个方法后才能分别拿到 x、y 的速度
                    computeCurrentVelocity(1000)
                    val xV = VelocityTrackerCompat.getXVelocity(mVelocityTracker,pointerId)
                    val yV = VelocityTrackerCompat.getYVelocity(mVelocityTracker,pointerId)
                    Log.d(TAG_VELOCITY, "X velocity: $xV")
                    Log.d(TAG_VELOCITY, "Y velocity: $yV")
                }
            }
            MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
                mVelocityTracker?.recycle()
                mVelocityTracker = null
            }
        }
        return true
    }

}

相关方法

总结

本篇文章在编写时参考了官方文档的 触摸事件 介绍及一些自己的总结，希望能对大家理解 Android 事件机制有所帮助