View 的滑动冲突处理

96
zhaoyubetter
2017.02.21 23:36* 字数 659

参考资料:
1.《Android开发艺术探索》

  1. http://www.jianshu.com/p/057832528bdd

常见的滑动冲突创景##

  1. 外部滑动方向与内部滑动方向不一致;
  2. 外部滑动方向与内部滑动方法一致时;
  3. 上面2种情况的嵌套;
内外滑动方向不一致
内外滑动方向一致
结合2种情况.png

滑动冲突的处理规则##

不管多么复杂的滑动冲突,他们之间的区别仅仅是滑动规则不同而已;

处理规则:根据滑动的方向,进行相应的拦截,如果想外部View接受事件,就外部View拦截,想内部View接受,就内部View拦截;

** 外部拦截法:**
指的是点击事情是先经过父容器的拦截处理,如父容器需要此事件,则拦截,如不需要就不拦截;

伪代码如下:

public boolean onInterceptTouchEvent(MotionEvent ev) {
   boolean result = false;
   switch (ev.getAction()) {
      // 不能消耗down,如果消耗了down,后续分发事件,onInterceptTouch就不再执行,即 子view将收不到任何事件
      case MotionEvent.ACTION_DOWN:   
         lastX = ev.getX();
         lastY = ev.getY();
         result = false;
         // 让Detector收到DOWN事件,如果不设置,则表示ViewGroup将没有down这个事件 这个时,候,滑动的时候,会发生错乱;
// 根据事件分发原则,只有在 onInterceptTouchEvent返回true时,onTouchEvent才执行;
    // 返回false的时候,down被子view消耗了,这个时候,当前 容器 onTouchEvent没有收到down事件;
         // mDetector.onTouchEvent(ev);       
         break;
      case MotionEvent.ACTION_MOVE:
         if(父容器需要当前点击事件) {
            result = true;
         } else {
            result = false;
         }
         break;
      case MotionEvent.ACTION_UP:
         result = false;
   }
   return result;
}

示例代码:
https://github.com/zhaoyubetter/TestCode/blob/master/improve/src/main/java/test/better/com/leak/ui/CustomHorizontalView.java

内部拦截法
是父容器不拦截任何事件,所有的事件都传递给子元素,如果子元素要事件就直接消耗掉,否则交给父容器进行处理;
这种方式与Android的事件分发不一致,需要配合 requestDisallowInterceptTouchEvent方法才能工作;

// 父: onInterceptTouchEvent
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
   boolean result = false;
   switch (ev.getAction()) {
      case MotionEvent.ACTION_DOWN:
         result = false;
         mDetector.onTouchEvent(ev);
         break;
      default:
         result = true;
         break;
   }
   return result;
}

// 子 view : 
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
   int action = ev.getAction();
   switch (action) {
      case MotionEvent.ACTION_DOWN:
         // 要求父不要阻止拦截事件
         getParent().requestDisallowInterceptTouchEvent(true);
         lastX = (int) ev.getX();
         lastY = (int) ev.getY();
         break;
      case MotionEvent.ACTION_MOVE:
         int distanceX = (int) Math.abs(ev.getX() - lastX);
         int distanceY = (int) Math.abs(ev.getY() - lastY);
         int slop = ViewConfiguration.get(getContext()).getScaledTouchSlop();
         // 父要事件了
         if (distanceX > distanceY && distanceX > slop) {
            getParent().requestDisallowInterceptTouchEvent(false);
         }
         break;
   }

   lastX = (int) ev.getX();
   lastY = (int) ev.getY();

   return super.dispatchTouchEvent(ev);
}

示例代码:
https://github.com/zhaoyubetter/TestCode/blob/master/improve/src/main/java/test/better/com/leak/ui/CustomHorizontalView2.java

滑动方向一致的冲突处理

上面的例子是内外滑动的方向相反时的处理,如果滑动方向一致呢?采用 scrollView 包裹ListView就是这种情况,
采用外部拦截法来处理,这里重新 scrollView 的 onInterceptTouchEvent:

public boolean onInterceptTouchEvent(MotionEvent ev) {
    boolean intercept = false;
    float y = ev.getY();

    switch (ev.getAction()) {
        case MotionEvent.ACTION_DOWN:
        mDownY = ev.getY();
        intercept = super.onInterceptTouchEvent(ev);
        case MotionEvent.ACTION_MOVE:
        // 第一个条目完全可见时,并且向下滑动时,才拦截事件
        if (mListView.getFirstVisiblePosition() == 0 &&
            mListView.getChildAt(0).getTop() >= mListView.getPaddingTop() &&
            y > mDownY) {
            intercept = true;
            break;
        }

        // 最后一个条目完全可见时,并且向上滑动,拦截事件
        if (mListView.getLastVisiblePosition() >= mListView.getCount() - 1) {
            final int childIndex = mListView.getLastVisiblePosition() - mListView.getFirstVisiblePosition();
            final int index = Math.min(childIndex, mListView.getCount() - 1);
            final View lastVisibleChild = mListView.getChildAt(index);
            if (lastVisibleChild != null && y < mDownY) {
            Log.e("better", "last bottom: " + lastVisibleChild.getBottom());
            intercept = lastVisibleChild.getBottom() + mListView.getBottom() >= mListView.getHeight();
            Log.e("better", intercept + "");
            }
        }
        break;
    }

    Log.e("better", intercept + "" + " , top: " + mListView.getChildAt(0).getTop() + ", listView Height: " + mListView.getHeight());

    return intercept;
}

代码路径:
https://github.com/zhaoyubetter/TestCode/blob/master/improve/src/main/java/test/better/com/leak/ui/ConflictScrollView.java

8.14 修正
上面的代码,效果是实现了,但是他们之间的联动有中断,我们需要解决这个问题,解决的入口,就是 dispatchTouchEvent
修正如下:

@Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        float y = ev.getY();
        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                mLastY = y;
                break;
            case MotionEvent.ACTION_MOVE:
                float dy = y - mLastY;
                if (Math.abs(dy) > ViewConfiguration.getTouchSlop()) {
                    // 内层下拉到头了 并且 外层还能下拉时,重发事件
                    if (!isReDispatch && !ViewCompat.canScrollVertically(mListView, -1) && dy > 0 && ViewCompat.canScrollVertically(this, -1)) {
                        isReDispatch = true;
                        Log.e("better", "下拉到头了,外层还可以下拉,重发事件");
                        ev.setAction(MotionEvent.ACTION_CANCEL);
                        MotionEvent ev2 = MotionEvent.obtain(ev);
                        ev2.setAction(MotionEvent.ACTION_DOWN);
                        dispatchTouchEvent(ev);
                        return dispatchTouchEvent(ev2);
                    }

                    if (!isReDispatch && !ViewCompat.canScrollVertically(mListView, 1) && dy < 0 && ViewCompat.canScrollVertically(this, 1)) {
                        isReDispatch = true;
                        Log.e("better", "上拉  到头了,外层还可以上拉,重发事件");
                        ev.setAction(MotionEvent.ACTION_CANCEL);
                        MotionEvent ev2 = MotionEvent.obtain(ev);
                        ev2.setAction(MotionEvent.ACTION_DOWN);
                        dispatchTouchEvent(ev);
                        return dispatchTouchEvent(ev2);
                    }
                }

                break;

            case MotionEvent.ACTION_UP:
                isReDispatch = false;
        }
        return super.dispatchTouchEvent(ev);
    }

@Override
    public boolean onTouchEvent(MotionEvent ev) {
        float y = ev.getY();
        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                mLastY = y;
                break;
            case MotionEvent.ACTION_MOVE:
                float dy = y - mLastY;
                Log.e("better", "onTouchEvent: " + dy);
                if(!isDrag && Math.abs(dy) > ViewConfiguration.getTouchSlop()) {
                    isDrag = true;
                }
                if (isDrag) {
                    if (dy > 0 && !ViewCompat.canScrollVertically(this, -1) && ViewCompat.canScrollVertically(mListView, -1)) {
                        ev.setAction(MotionEvent.ACTION_DOWN);
                        dispatchTouchEvent(ev);
                        isReDispatch = false;
                        Log.e("better", "redispatch --》 onTouchEvent");
                    }
                    if (dy < 0 && !ViewCompat.canScrollVertically(this, 1) && ViewCompat.canScrollVertically(mListView, 1)) {
                        ev.setAction(MotionEvent.ACTION_DOWN);
                        dispatchTouchEvent(ev);
                        isReDispatch = false;
                        Log.e("better", "redispatch --》 onTouchEvent");
                    }
                }

                mLastY = y;
                break;
            case MotionEvent.ACTION_CANCEL:
            case MotionEvent.ACTION_UP:
                isDrag = false;
        }
        return super.onTouchEvent(ev);
    }
@Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        boolean intercept = false;
        float y = ev.getY();

        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                mLastY = y;
                intercept = super.onInterceptTouchEvent(ev);
                break;
            case MotionEvent.ACTION_MOVE:
                // 第一个条目完成可见时,并且向下滑动时,才拦截事件
                float dy = y - mLastY;
                if (Math.abs(dy) > ViewConfiguration.getTouchSlop()) {
                    isDrag = true;
                    if (!ViewCompat.canScrollVertically(mListView, -1) && dy > 0) {
                        intercept = true;
                    }
                    if (!ViewCompat.canScrollVertically(mListView, 1) && dy < 0) {
                        intercept = true;
                    }
                }
                break;
            case MotionEvent.ACTION_CANCEL:
            case MotionEvent.ACTION_UP:
                isDrag = false;
        }

        return intercept;
    }

内部拦截法来处理,只修改ListView 的 dispatchTouchEvent,不修改 scrollView 代码:

 @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        float y = ev.getY();

        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                mDownY = ev.getY();
                mScrollView.requestDisallowInterceptTouchEvent(true);
                break;
            case MotionEvent.ACTION_MOVE:
                // 向下滑动
                if (getFirstVisiblePosition() == 0 && getChildAt(0).getTop() >= getPaddingTop() &&
                        y > mDownY) {
                    mScrollView.requestDisallowInterceptTouchEvent(false);
                    break;
                }

                if (getLastVisiblePosition() == getCount() - 1) {
                    final View lastVisibleChild = getChildAt(getLastVisiblePosition() - getFirstVisiblePosition());
                    if (lastVisibleChild != null && y < mDownY) {
                        if (lastVisibleChild.getBottom() + getPaddingBottom() <= getHeight()) {
                            mScrollView.requestDisallowInterceptTouchEvent(false);
                        }
                    }
                }
                break;
        }

        return super.dispatchTouchEvent(ev);
    }

通过这种方式,可以发现当内部 listview 滚动到 头 or 尾,时继续滚动时,由于事件又给了 scrollView了。所以,外部scrollView 收到了事件,开始了外部滚动;

![内部拦截法——滑动方向一致].gif](http://upload-images.jianshu.io/upload_images/2003670-b617ea2c4dc29893.gif?imageMogr2/auto-orient/strip)

如果要使用 外部拦截法,来实现 上图动画中的 效果,那就复杂多了。尝试了一下,没有实现好;

Android 晋级
Web note ad 1