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

学习内容

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

1. View 基础知识

View 定义
1. View 是 Android 种所有控件的基类，是一种界面层的控件的一种抽象，代表了一个控件
2. ViewGroup 继承 View，其内部包含了许多个控件，即一组 View
3. ViewGroup 内部是可以有子 View 的，而这个子 View 同样还可以是 ViewGroup
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 左上角相对于父容器的偏移量
MotionEvent 和 TouchSlop
1. MotionEvent 是手指接触屏幕后所产生的一系列事件。
2. 一般通过 MotionEvent 对象可以得到点击事件发生的 x 和 y 坐标
  1. getX / getY：相对坐标
  2. getRawX / getRawY：绝对坐标
3. TouchSlop 指系统能识别出的被认为是滑动的最小距离，通过 ViewConfiguration.get(getContext()).getScaledTouchSlop() 方法来获取。

VelocityTracker、GestureDetector 和 Scroller

VelocityTracker

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

使用

VelocityTracker velocityTracker = VelociityTracker.obtain();
velocityTracker.addMovement(event);

//获取速度之前按必须先计算速度，速度指一段时间内手指滑过的像素数
//速度 = （终点位置 - 起点位置）/ 时间段
velocityTracker.computeCurrentVelocity(1000);
int xVelocity = (int)velocityTracker.getXVelocity();
int yVelocity = (int)velocityTracker.getYVelocity();


//不再需要使用的时候，重置并回收内存
velocityTracker.clear();
velocityTracker.recycler();

GestureDetector

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

使用

//创建 GestureDetector 对象并实现 指定接口如 OnGestureListener 、 OnDoubleTapListener
GestureDetector mGestureDetector = new GestureDetector(this);
mGestureDetector.setIsLongpressEnabled(flase);

//接着接管目标 View 的 onTouchEvent 方法
boolean consume = mGestureDetector.onTouchEvent(event);
return consume;

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

Scroller

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

使用

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

2. View 的滑动

使用 ScrollTo / ScrollBy
1. 只能改变 View 内容的位置而不能改变 View 在布局中的位置
2. mScrolllX 的值总是等于 View 左边缘和 View 内容左边缘在水平方向的距离；mScrollY 的值总是等于 View 上边缘和 View 内容上边缘在竖直方向的距离，二者单位均为像素。
3. 当 View 左边缘在 View 内容左边缘的右边时，mScrollX 为正值
4. 当 View 上边缘在 View 内容上边缘的下边时，mScrollY 为正值
使用动画
1. translationX / translationY 属性
2. View 动画
  1. 以上两种，只是移动 View 的影像，不能改变真正的位置
3. 属性动画
  1. 可以改变 View 的参数

改变布局参数

改变 LayoutParams

举例：

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

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

3. 弹性滑动

具体思想：将一次大的滑动分成若干次小的滑动，并在一个时间段内完成。
实现方式
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. 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;
}
```
事件的传递规则
1. 对于一个根 ViewGroup 来说，点击事件产生后，首先传递给它，此时它的 dispatchTouchEvent 会被调用，如果这个 ViewGroup 的 onInterceptTouchEvent 方法返回 true 就表示它要拦截当前事件，接着事件就会交给这个 ViewGroup 处理，即调用它的 onTouchEvent 方法。如果 onInterceptTouchEvent 方法返回 false，表示不拦截当前事件，这时该事件传递给它的子元素，接着子元素的 dispatchTouchEvent 方法被调用，如此反复。
2. 传递过程遵循如下顺序：
  
  Activity -> Window ( PhoneWindow )-> View (DecorView)
  
  当一个 View 的 onTouchEvent 返回 false，那么会调用其父容器的 onTouchEvent ，依此类推。如果所有的元素都不处理这个事件，那么这个事件将会最终传递给 Activity 处理。
一些结论
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. 外部滑动方向和内部滑动方向不一致
2. 外部滑动方向和内部滑动方向一致
3. 上面两种情况的嵌套
滑动冲突处理规则
1. 滑动方向有明显差异时：根据特征（水平滑动还是竖直滑动）来决定让谁来拦截事件
2. 滑动方向无法辨别：根据业务需求来决定让谁来拦截事件

滑动冲突的解决方式

外部拦截法（推荐）

指点击事件都先经过父容器的拦截处理，如果父容器需要此事件就拦截，否则不拦截。
需要重写父容器的 onInterceptTouchEvent 方法，在内部做相应的拦截

典型伪代码

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

内部拦截法

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

典型伪代码

//子元素
@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 的事件体系

1. View 基础知识

2. View 的滑动

3. 弹性滑动

4. View 的事件分发机制

5. View 的滑动冲突

猜你喜欢