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;
          }
      }
      

你可能感兴趣的:(Android 开发艺术探索之三 -- View 的事件体系)