View的工作原理和事件体系

View的基础知识

View是所有控件的基类，ViewGroup继承了View, ViewGroup表示一个控件组，内部可以包含多个控件, 例如LineraLayout就是继承的ViewGroup，它里面可以包含多个子控件。即View可以是单个控件也可以是多个控件组成的控件组。

View的位置参数
View在平移过程中，left、top、right、bottom这几个值是不会改变的，改变的是x、y、translationX、
translationY这几个值

参数名	解释
left	View的左边界距父容器左边界的距离
top	View的上边界距父容器上边界的距离
right	View的右边界距父容器左边界的距离
bottom	View的底边界距父容器上边界的距离
x	left+translationX
y	top+translationY
translationX	View的左上角X方向相对于父容器的偏移量
translationY	View的左上角Y方向相对于父容器的偏移量

MotionEvent和TouchSlop

典型的MotionEvent事件

名称	解释
ACTION_DOWN	手指刚接触屏幕
ACTION_MOVE	手指在屏幕上滑动
ACTION_UP	手指从屏幕上松开的一瞬间

获取点击位置的坐标
getX()/getY() 获取的是相对于当前View左上角的坐标
getRawX()/getRawY() 获取的是相对于手机屏幕左上角的坐标

TouchSlop
系统识别认为是滑动的最小距离

   /**
    * Distance a touch can wander before we think the user is scrolling in dips.
    * Note that this value defined here is only used as a fallback by legacy/misbehaving
    * applications that do not provide a Context for determining densit   configuration-dependent
    * values.
    *
    * To alter this value, see the configuration resourc config_viewConfigurationTouchSlop
    * in frameworks/base/core/res/res/values/config.xml or the appropriate devic resource   overlay.
    * It may be appropriate to tweak this on a device-specific basis in an overla based on
    * the characteristics of the touch panel and firmware.
    */
   private static final int TOUCH_SLOP = 8;

VelocityTracker、 GestureDetector、 Scroller

VelocityTracket

   //获取实例
   private var velocityTracker: VelocityTracker = VelocityTracker.obtain()
  
    //添加事件
    /**
     * Add a user's movement to the tracker.  You should call this for the
     * initial {@link MotionEvent#ACTION_DOWN}, the following
     * {@link MotionEvent#ACTION_MOVE} events that you receive, and the
     * final {@link MotionEvent#ACTION_UP}.  You can, however, call this
     * for whichever events you desire.
     * 
     * @param event The MotionEvent you received and would like to track.
     */
   velocityTracker.addMovement(event)

   //在MotionEvent#ACTION_UP的时候计算速率
   /**
    *@param units 单位为毫秒(millisecond),表示速率的单位时间
    *       如值是1000,则在1000毫秒内滑过100像素(px)，速率就是100
    *       如值是100，如果在100毫秒内同样滑过100像素，速率也是100
    *       速率 = 终点位置(ACTION_DOWN)- 初始位置(ACTION_DOWN)/(经过的时间/units)
    */
   velocityTracker.computeCurrentVelocity(1000)
   // 获取x、y方向上的速率
   val xVelocity = velocityTracker.xVelocity
   val yVelocity = velocityTracker.yVelocity  

   //将实例重置为初始状态
   velocityTracker.clear()
   //回收内存
   velocityTracker.recycle()

GestureDetector
Android手势介绍
Scroller
实现View的弹性滑动，详情见下文

View的滑动

实现滑动的方式及弹性滑动

Android动画介绍

滑动

实现滑动的方式
scrollTo()/scrollBy()
View动画
属性动画
LayoutParams

scrollTo()/scrollBy()

     // 只是移动View里面的内容，对于像ImageView之类的单个控件来说，内容就是里面的图片
     // 对于ViewGroup这种控件组，内容就是其中的子View.
     // scrollBy()是相对目前的scrollX, scrollY进行移动
     // scrollTo()则是覆盖之前的scrollX, scrollY进行移动
     // scrollX == View的左边坐标 - View内容的左边坐标，即scrollX为负值时，View内容向右移
     // scrollY == View的顶部坐标 - View内容的顶部坐标， scrollY为负值时，View内容向下移动
     SLIDE_MODE_SCROLL -> {
         scrollTo(-event.x.toInt(), 0)
     }

View动画

    //移动后，点击响应的位置还在原来的区域
    // left,top,right,bottom属性不变
    // x, y属性不变
    SLIDE_MODE_ANIMATION -> {
        val translateTime = (Math.abs(event.x - x) / 100 * 1000).toLong()
        val translateAnimation = TranslateAnimation(x, event.x, y, y).apply {
            duration = translateTime
            fillAfter = true
        }
        this.startAnimation(translateAnimation)
    }

属性动画

    //移动后，点击响应的位置在移动后的区域
    // left,top,right,bottom属性不变
    // translationX,translationY改变 导致x, y属性改变
    SLIDE_MODE_ANIMATOR -> {
        val translateTime = (Math.abs(event.x - x) / 100 * 100).toLong()
        ObjectAnimator.ofFloat(this, "translationX", x, event.x).setDuratio(translateTime).start()
    }

LayoutParams

    //移动后，点击响应的位置在移动后的区域
    // left,top,right,bottom属性根据情况改变
    // left,top改变 导致x, y属性改变
    SLIDE_MODE_LAYOUT_PARAMS -> {
                  (this.layoutParams    ViewGroup.MarginLayoutParams)?.apply {
                      leftMargin = event.x.toInt()
                      [email protected]()
                  }
              }

弹性滑动

弹性滑动实际上是将一次滑动“微分”成一次次小滑动，并在一个合理的时间段内完成，而不像普通的滑动一次滑动就完成所有工作
实现弹性滑动一般结合scrollTo()来实现

实现弹性滑动的方式
使用Scroller
使用属性动画
延时策略(Handler#sendMessageDelay())

Scroller

   //初始化时创建实例
   private var mScroller: Scroller = Scroller(context)

   //重写computeScroll实现
   SLIDE_MODE_SMOOTH_SCROLL -> smoothScrollTo(-event.x.toInt())

   private fun smoothScrollTo(destX: Int) {
       val deltaX = destX - scrollX
       val time = Math.abs(deltaX) / 100 * 1000
       mScroller.startScroll(scrollX, y.toInt(), deltaX, y.toInt(), time)
       //重绘
       invalidate()
  }

   //会在draw的时候调用computeScroll()
   override fun computeScroll() {
      //计算当前的滑动偏移
      //滑动未结束则返回true
       if (mScroller.computeScrollOffset()) {
           scrollTo(mScroller.currX, mScroller.currY)
           //scrollTo()之后重绘，达成弹性滑动的效果
           postInvalidate()
       }
   }

属性动画

   //动画实现弹性滑动
   SLIDE_MODE_ANIMATOR_SCROLL -> {
       lastScrollX = scrollX
       mScrollX = -event.x.toInt() - scrollX
       ValueAnimator.ofInt(0, 1).apply {
           duration = Math.abs(mScrollX) / 100 * 1000.toLong()
           addUpdateListener {
               it.animatedFraction
               [email protected]((it.animatedFraction * mScrollX).toInt() + lastScrollX, 0)
           }
           start()
       }
   }

延时策略(Handler#sendMessageDelay())


    //通过Handler#sendMessageDelay实现弹性滑动
     SLIDE_MODE_HANDLER_SMOOTH -> {
         lastScrollX = scrollX
         mScrollX = -event.x.toInt() - scrollX
         intervalX = if (mScrollX < 0) -10 else 10
         mHandler.sendMessage(Message.obtain(nul SLIDE_MODE_HANDLER_SMOOTH, intervalX, 0 ))
     }


     //Handler
     private class SlideHandler(private val weakReference: WeakReference) : Handler() {
         private var scrollerX = 0
         override fun handleMessage(msg: Message?) {
             if (msg?.what == SLIDE_MODE_HANDLER_SMOOTH) {
                 weakReference.get()?.run {
                     scrollerX += msg.arg1
                     scrollTo(scrollerX + lastScrollX, 0)
                     mScrollX -= intervalX
                     if (Math.abs(mScrollX) >= Math.abs(intervalX)) {
                         mHandler.sendMessageDelayed(Message.obtain(null,     SLIDE_MODE_HANDLER_SMOOTH, intervalX, 0), 100)
                     } else {
                         scrollerX = 0
                     }
                 }
             }
         }
     }

滑动冲突

滑动冲突场景	处理原则
外部滑动方向和内部滑动方向不一致	根据x方向滑动距离和y方向的滑动距里的差值或根据二者的夹角来判断滑动方向，如ViewPager的解决方式
外部滑动方向和内部滑动方向一致	根据具体需求，如可以根据滑动的距离，滑动起始位置来判断具体是哪个部分滑动
以上两者的嵌套

滑动冲突处理方式

滑动冲突处理方式
外部拦截法，父容器需要就拦截，不需要就不拦截。重写父容器的onInterceptTouchEvent
内部拦截法，父容器也需要配合修改，子元素需要就直接消耗，重写dispatchTouchEvent且要配合requestDisallowTouchEvent,参考ViewPager

外部拦截法-简单示例

   override fun onInterceptTouchEvent(ev: MotionEvent?): Boolean {
       var intercepted = false
       when(ev?.action){
           //如果拦截了ACTION_DOWN,后续的事件都会在当前View中处理
           //子View中的onClick(在ACTION_UP的时候)之类的事件也不会触发
           MotionEvent.ACTION_DOWN ->{
               intercepted =false
           }
           MotionEvent.ACTION_MOVE ->{
               //是否需要事件
               intercepted = needMotionEvent()
           }
           // 如果在这之前已经拦截了，返回true和false 相差不大
           // 如果之前没有拦截，此处返回了true，那么子View中设置的onClick(ACTION_UP的时候)就会无效
           MotionEvent.ACTION_UP ->{
               intercepted = false
           }
       }
       return intercepted
    }

内部拦截法(可参考ViewPager)-简单示例

   //子元素
    override fun dispatchTouchEvent(event: MotionEvent?): Boolean {
       when(event?.action){
           //ACTION_DOWN在父元素中默认不拦截，如果拦截了ACTION_DOWN的话之后的事件都不会传递
           MotionEvent.ACTION_DOWN ->{
               //父元素不拦截事件
               parent.requestDisallowInterceptTouchEvent(true)
           }
           MotionEvent.ACTION_MOVE ->{
               if (parentNeedEvent()){
                   parent.requestDisallowInterceptTouchEvent(false)
               }
           }
       }
       return super.dispatchTouchEvent(event)
   }
   //父元素
   override fun onInterceptTouchEvent(ev: MotionEvent?): Boolean {
       return ev?.action != MotionEvent.ACTION_DOWN
   }

View的事件分发

Note:
1. 事件的传递从Activity开始到View结束，如果被消费了就不再继续传递，ACTION_DOWN是事件开始的标识，不会被拦截。例如重写了Activity的onTouchEvent方法并返回true,则ACTION_DOWN之后的事件都不会向下一级分发。
2. 事件的消费从View开始到Activity结束，只能消费一次例如一个自定义View,重写了onTouchEvent方法并返回true,则表示要消费此次事件，这个自定义View会接收ACTION_DOWN之后的事件,而在它的消费链下一级(ViewGroup、 Activity)一些用来消费事件的方法不会被调用(onTouchEvent、一些点击事件)
3. onTouchListener的执行顺序在onTouchEvent之前，如果onTouchListener返回true消费了事件则onTouchEvent不会调用,一些点击事件是在onTouchEvent中处理的。
4. 像onClick(ACTION_UP后执行),onLongClick(ACTION_DOWN一般延时500ms后还是press后执行)都是在onTouchEvent中执行的，设置了这些点击事件则onTouchEvent返回的是true.
5. onLongClick中返回的bool值，true表示消费结束了，其它点击事件不再响应，false则其他点击事件还可以响应.