Android 开发艺术探索之三 -- View 的事件体系

学习内容

• View 基础
• 滑动
• 事件分发机制
• 滑动冲突

1. View 基础知识

1. View 定义

   1. View 是 Android 种所有控件的基类，是一种界面层的控件的一种抽象，代表了一个控件
   2. ViewGroup 继承 View，其内部包含了许多个控件，即一组 View
   3. ViewGroup 内部是可以有子 View 的，而这个子 View 同样还可以是 ViewGroup

2. View 位置参数

   1. Android 种，坐标系的 x 轴和 y 轴的正方向分别是右和下。
   2. View 的位置由其四个顶点决定，分别对应四个属性：top（左上角纵坐标）、left（左上角横坐标）、right（右下角横坐标）、bottom（右下角纵坐标），这些坐标相对于父容器来说的。
   3. Android 3.0 以后，加入 x、y、translationX、translationY，其中 x、y是 View 左上角的坐标，而 translationX、translationY 是 View 左上角相对于父容器的偏移量

3. MotionEvent 和 TouchSlop

   1. MotionEvent 是手指接触屏幕后所产生的一系列事件。
   2. 一般通过 MotionEvent 对象可以得到点击事件发生的 x 和 y 坐标
      1. getX / getY：相对坐标
      2. getRawX / getRawY：绝对坐标
   3. TouchSlop 指系统能识别出的被认为是滑动的最小距离，通过 ViewConfiguration.get(getContext()).getScaledTouchSlop() 方法来获取。

4. VelocityTracker、GestureDetector 和 Scroller

   1. VelocityTracker

      1. 速度追踪，用于追踪手指在滑动过程中的速度
      2. 使用

         VelocityTracker velocityTracker = VelociityTracker.obtain();
         velocityTracker.addMovement(event);
         
         //获取速度之前按必须先计算速度，速度指一段时间内手指滑过的像素数
         //速度 = （终点位置 - 起点位置）/ 时间段
         velocityTracker.computeCurrentVelocity(1000);
         int xVelocity = (int)velocityTracker.getXVelocity();
         int yVelocity = (int)velocityTracker.getYVelocity();
         
         
         //不再需要使用的时候，重置并回收内存
         velocityTracker.clear();
         velocityTracker.recycler();
         

   2. GestureDetector

      1. 手势检测，用于辅助检测用户的单击、滑动、长按、双击等行为。

      2. 使用

         //创建 GestureDetector 对象并实现 指定接口如 OnGestureListener 、 OnDoubleTapListener
         GestureDetector mGestureDetector = new GestureDetector(this);
         mGestureDetector.setIsLongpressEnabled(flase);
         
         //接着接管目标 View 的 onTouchEvent 方法
         boolean consume = mGestureDetector.onTouchEvent(event);
         return consume;
         

      3. 建议：如果只是监听滑动相关，建议自己在 onTouchEvent 中实现，如果要监听双击这种行为的话，那么就使用 GestureDetector

   3. Scroller

      1. 弹性滑动对象，用于实现 View 的弹性滑动

      2. 使用

         Scroller mScroller = new Scroller(mContext);
         
         //缓慢滚动到指定位置
         private void smoothScrollTo(int destX,int destY){
             int scrollX = getScrollX();
             int delta = destX - scrollX;
             //1000ms 内滑向 destX，效果就是缓慢滑动
             mScroller.startScroll(scrollX,0,delta,0,1000);
             invalidate();
         }
         
         @Override
         public void computeScroll(){
             if(mScroll.computeScrollOffset()){
                 scrollTo(mScroller.getCurrX(),mScroller.getCurrY());
                 postInvalidate();
             }
         }
         

View 的滑动

1. 使用 ScrollTo / ScrollBy

   1. 只能改变 View 内容的位置而不能改变 View 在布局中的位置
   2. mScrolllX 的值总是等于 View 左边缘和 View 内容左边缘在水平方向的距离；mScrollY 的值总是等于 View 上边缘和 View 内容上边缘在竖直方向的距离，二者单位均为像素。
   3. 当 View 左边缘在 View 内容左边缘的右边时，mScrollX 为正值
   4. 当 View 上边缘在 View 内容上边缘的下边时，mScrollY 为正值

2. 使用动画

   1. translationX / translationY 属性
   2. View 动画
      1. 以上两种，只是移动 View 的影像，不能改变真正的位置
   3. 属性动画
      1. 可以改变 View 的参数

3. 改变布局参数

   1. 改变 LayoutParams

   2. 举例：

      //将一个 Button 右平移100px
      ViewGroup.MarginLayoutParams params = (ViewGroup.MarginLayoutParams)mTbn.getLayoutParams();
      params.leftMargin += 100;
      mBtn.requestLayout();
      //或者  mBtn.setLayoutParams(params);
      

4. 小结

   1. ScrollTo / ScrollBy：操作简单，适合对 View 内容的滑动
   2. 动画（View 动画）：操作简单，主要适用于没有交互的 View 和实现复杂的动画效果
   3. 改变布局参数：操作稍微复杂，适用于有交互的 View

3. 弹性滑动

1. 具体思想：将一次大的滑动分成若干次小的滑动，并在一个时间段内完成。

2. 实现方式

   1. 使用 Scrolller

      当 View 重绘后会在 draw 方法中调用 computeScroll，而 compiteScroll 又会去向 Scroller 获取当前的 scrollX 和 scrollY；然后通过 scrollTo 方法实现滑动；接着又调用 postInvalidate 方法来进行第二次重绘，这一次重绘的过程和第一次重绘一样，还是会导致 computeScroll 方法被调用；后续同上，如此反复，直到整个滑动过程结束。

   2. 通过动画

   3. 使用延时策略

      1. 核心思想：通过发送一系列延时消息从而达到一种渐进式的效果

      2. 方法：

         使用 Handler或 View 的 postDelayed 方法，也可以使用线程的 sleep 方法，对于 postDelayed 方法来说，通过其延时发送消息，然后在消息中进行 View 的滑动。接连不断地发送这种延时消息，以此大导弹性滑动的效果

4. View 的事件分发机制

1. 核心的三个方法

   1. dispatchTouchEvent(MotionEvent ev)

      用来进行事件的分发。返回结果受当前 View 的 onTouchEvent 和 下级 View 的 dispatchTouchEvent 方法的影响，表示是否消耗该事件。

   2. onInterceptTouchEvent(MotionEvent ev)

      在上述方法中调用，用来判断是否拦截某个事件，如果当前View 拦截了某个事件，那么在同一个时间序列中，此方法不会再次调用，返回结果表示是否拦截当前事件

   3. onTouchEvent(MotionEvent ev)

      在 dispatchTouchEvent 方法中调用，用来处理点击事件，返回结果表示是否消耗事件，如果不消耗，则同一个事件序列中，当前 View 无法再次接收到事件

   4. 三者关系伪代码表示

      public boolean dispatchTouchEvent(MotionEvent ev){
          boolean consume = false;
          if(onInterceptTouchEvent（ev){
              consume = onTouchEvent(ev);
          }else {
              consume = child.dispatchTouchEvent(ev);
          }
          return consume;
      }
      
      

2. 事件的传递规则

   1. 对于一个根 ViewGroup 来说，点击事件产生后，首先传递给它，此时它的 dispatchTouchEvent 会被调用，如果这个 ViewGroup 的 onInterceptTouchEvent 方法返回 true 就表示它要拦截当前事件，接着事件就会交给这个 ViewGroup 处理，即调用它的 onTouchEvent 方法。如果 onInterceptTouchEvent 方法 返回 false，表示不拦截当前事件，这时该事件传递给它的子元素，接着子元素的 dispatchTouchEvent 方法被调用，如此反复。

   2. 传递过程遵循如下顺序：

      Activity -> Window ( PhoneWindow )-> View (DecorView)

      当一个 View 的 onTouchEvent 返回 false，那么会调用其父容器的 onTouchEvent ，依此类推。如果所有的元素都不处理这个事件，那么这个事件将会最终传递给 Activity 处理。

3. 一些结论

   1. 同一个时间序列指 从手指接触屏幕的那一刻起，到手指离开屏幕的那一刻结束。（down -> [move]* -> up ）
   2. 正常情况下，一个事件序列只能被一个 View 拦截并消耗
   3. 某个 View 一旦决定拦截，那么这一个事件序列都只能由它来处理，并且 onInterceptTouchEvent 不会再被调用
   4. 某个 View 一旦开始处理事件，如果它不消耗 ACTION_DOWN（ onTouchEvent 返回了 false），那么同一事件序列中其他事件都不会再交给它来处理，事件将重新交给他的父元素处理，即父元素的 onTouchEvent 会被调用。
   5. 如果某个 View 不消耗除 ACTION_DOWN 以外的其他事件，那么这个点击事件会消失，此时父元素的 onTouchEvent 并不会被调用，并且当前 View 可以收到后续事件，最终这些消失的点击事件会传递给 Activity 处理
   6. ViewGroup 默认不拦截任何事件，ViewGroup 的 onInterceptTouchEvent 方法默认返回 false
   7. View 没有 onInterceptTouchEvent 方法，一旦有事件传递给它，那么它的 onTouchEvent 方法会被调用
   8. View 的 onTouchEvent 方法默认消耗事件（返回 true ），除非他是不可点击的（clickable 和 longClickable 同时为 false）。View 的 longClickable 属性默认都为 false，clickable 属性分情况，Button 默认为 true，TextView 默认为false。
   9. View 的 enable 属性不影响 o'nTouchEvent 的默认返回值
   10. onClick 会发生的前提是当前 View 是可点击的，并且它收到了 down 和 up 的事件
   11. 时间传递过程是由外向内的，即事件总是先传递给父元素，然后再由父元素分发给子 View，通过 requestDisallowInterceptTouchEvent 方法可以在子元素中干预父元素的事件分发过程，但是 ACTION_DOWN 事件除外。

5. View 的滑动冲突

1. 常见的滑动冲突场景

   1. 外部滑动方向和内部滑动方向不一致
   2. 外部滑动方向和内部滑动方向一致
   3. 上面两种情况的嵌套

2. 滑动冲突处理规则

   1. 滑动方向有明显差异时：根据特征（水平滑动还是竖直滑动）来决定让谁来拦截事件
   2. 滑动方向无法辨别：根据业务需求来决定让谁来拦截事件

3. 滑动冲突的解决方式

4. 外部拦截法（推荐）

   1. 指点击事件都先经过父容器的拦截处理，如果父容器需要此事件就拦截，否则不拦截。

   2. 需要重写父容器的 onInterceptTouchEvent 方法，在内部做相应的拦截

   3. 典型伪代码

      @Override
      public boolean onInterceptTouchEvent(MotionEvent ev) {
          boolean intercepted = false;
          int x = (int) ev.getX();
          int y = (int) ev.getY();
          switch (ev.getAction()){
              //对于 ACTION_DOWN 事件，父容器必须返回false，即不拦截，一旦拦截，那么后续的 MOVE、UP 事件都会直接交由父容器处理。没法传递给子元素
              case MotionEvent.ACTION_DOWN:
                  intercepted = false;
                  break;
              //MOVE 事件根据需求来决定是否拦截，父容器需要则返回true，否则返回false
              case MotionEvent.ACTION_MOVE:
                  if (/*父容器需要当前点击事件*/){
                      intercepted = true;
                  }else {
                      intercepted = false;
                  }
                  break;
              //必须返回 false，因为 UP 事件没太多意义        
              case MotionEvent.ACTION_UP:
                  intercepted = false;
                  break;
              default:
                  break;
          }
          mLastXIntercept = x;
          mLastYIntercept = y;
          return intercepted;
      }
      

5. 内部拦截法

   1. 指 父容器不拦截任何事件，所有的事件都传递给子元素，如果子元素需要此事件就直接消耗掉，否则交由父容器进行处理。

   2. 需要 requestDisallowInterceptTouchEvent 方法配合工作。

   3. 典型伪代码

      //子元素
      @Override
      public boolean dispatchTouchEvent(MotionEvent ev) {
          int x = (int) ev.getX();
          int y = (int) ev.getY();
      
          switch (ev.getAction()) {
              case MotionEvent.ACTION_DOWN:
                  getParent().requestDisallowInterceptTouchEvent(true);
                  break;
              case MotionEvent.ACTION_MOVE:
                  int deltaX = x - mLastX;
                  int deltaY = y - mLastY;
                  if (/*父容器需要此类点击事件*/){
                      getParent().requestDisallowInterceptTouchEvent(false);
                  }
                  break;
              case MotionEvent.ACTION_UP:
                  break;
              default:
                  break;
          }
          mLastX = x;
          mLastY = y;
      
          return super.dispatchTouchEvent(ev);
      }
      
      
      //父元素
      //父元素默认拦截除了 ACTION_DOWN 外的事件，原因是 ACTION_DOWN 不受 requestDisallowInterceptTouchEvent() 方法的控制
      @Override
      public boolean onInterceptTouchEvent(MotionEvent ev) {
          int action = ev.getAction();
          if (action == MotionEvent.ACTION_DOWN){
              return false;
          }else {
              return true;
          }
      }