从 Android 5.0 Lollipop 开始提供一套 API 来支持嵌入的滑动效果。同样在最新的 Support V4 包中也提供了前向的兼容。有了嵌入滑动机制，就能实现很多很复杂的滑动效果。在 Android Design Support 库中非常总要的 CoordinatorLayout 组件就是使用了这套机制，实现了 Toolbar 的收起和展开功能，如下图所示：

Android NestedScrolling 实例

       NestedScrolling提供了一套父 View 和子 View 滑动交互机制。要完成这样的交互，父 View 需要实现 NestedScrollingParent 接口，而子 View 需要实现 NestedScrollingChild 接口。

       实现 NestedScrollingChild

       首先来说NestedScrollingChild。如果你有一个可以滑动的 View，需要被用来作为嵌入滑动的子 View，就必须实现本接口。在此 View 中，包含一个 NestedScrollingChildHelper 辅助类。NestedScrollingChild接口的实现，基本上就是调用本 Helper 类的对应的函数即可，因为 Helper 类中已经实现好了 Child 和 Parent 交互的逻辑。原来的 View 的处理 Touch 事件，并实现滑动的逻辑大体上不需要改变。

       需要做的就是，如果要准备开始滑动了，需要告诉 Parent，你要准备进入滑动状态了，调用startNestedScroll()。你在滑动之前，先问一下你的 Parent 是否需要滑动，也就是调用dispatchNestedPreScroll()。如果父类滑动了一定距离，你需要重新计算一下父类滑动后剩下给你的滑动距离余量。然后，你自己进行余下的滑动。最后，如果滑动距离还有剩余，你就再问一下，Parent 是否需要在继续滑动你剩下的距离，也就是调用dispatchNestedScroll()。

       以上是一些基本原理，有了上面的基本思路，可以参考这篇 文章 ，这里面有原理的详细解析。如果还是不清楚， 这里 有对应的代码可以参考。

       实现 NestedScrollingParent

       作为一个可以嵌入 NestedScrollingChild 的父 View，需要实现NestedScrollingParent，这个接口方法和NestedScrollingChild大致有一一对应的关系。同样，也有一个 NestedScrollingParentHelper 辅助类来默默的帮助你实现和 Child 交互的逻辑。滑动动作是 Child 主动发起，Parent 就收滑动回调并作出响应。

       从上面的 Child 分析可知，滑动开始的调用startNestedScroll()，Parent 收到onStartNestedScroll()回调，决定是否需要配合 Child 一起进行处理滑动，如果需要配合，还会回调onNestedScrollAccepted()。

       每次滑动前，Child 先询问 Parent 是否需要滑动，即dispatchNestedPreScroll()，这就回调到 Parent 的onNestedPreScroll()，Parent 可以在这个回调中“劫持”掉 Child 的滑动，也就是先于 Child 滑动。

       Child 滑动以后，会调用onNestedScroll()，回调到 Parent 的onNestedScroll()，这里就是 Child 滑动后，剩下的给 Parent 处理，也就是 后于 Child 滑动。

       最后，滑动结束，调用onStopNestedScroll()表示本次处理结束。

       其实，除了上面的 Scroll 相关的调用和回调，还有 Fling 相关的调用和回调，处理逻辑基本一致。

       实战

       有了这一套官方的嵌套滑动的解决方案，打算把我的 FlyRefresh 的滑动和下来部分用 NestedScrolling 来实现。我在这篇博客中讲了，之前是通过在PullHeaderLayout的dispatchTouchEvent()中小心处理 Touch 事件来实现的。现在回想起来，这种方法相对复杂，需要清楚知道 Parent 和 Child 的滑动状态，这就导致了，只能支持有限的 Child 类型，例如当时只支持 ListView 和 RecyclerView，为了支持更多的类型，还定义了一个IScrollHandler接口来支持。

       让 FlyRefresh 实现NestedScrollingParent，就可以支持所有的NestedScrollingChild作为FlyRefreshLayout的子 View。另外，因为CoordinatorLayout是如此的重要，大部分的 App 都需要使用它作为顶层的 Layout，为了让FlyRefreshLayout能够在 CoordinatorLayout 也能使用，所以我还打算同时实现NestedScrollingChild接口。关键实现代码如下：

Java代码
  1. public class PullHeaderLayout extends ViewGroup implements NestedScrollingParent, NestedScrollingChild {  
  2.   
  3.     private final int[] mScrollOffset = new int[2];  
  4.     private final int[] mScrollConsumed = new int[2];  
  5.     private final NestedScrollingParentHelper mParentHelper;  
  6.     private final NestedScrollingChildHelper mChildHelper;  
  7.     ...  
  8.   
  9.     // NestedScrollingChild  
  10.   
  11.     @Override  
  12.     public void setNestedScrollingEnabled(boolean enabled) {  
  13.         mChildHelper.setNestedScrollingEnabled(enabled);  
  14.     }  
  15.   
  16.     @Override  
  17.     public boolean isNestedScrollingEnabled() {  
  18.         return mChildHelper.isNestedScrollingEnabled();  
  19.     }  
  20.   
  21.     @Override  
  22.     public boolean startNestedScroll(int axes) {  
  23.         return mChildHelper.startNestedScroll(axes);  
  24.     }  
  25.   
  26.     @Override  
  27.     public void stopNestedScroll() {  
  28.         mChildHelper.stopNestedScroll();  
  29.     }  
  30.   
  31.     @Override  
  32.     public boolean hasNestedScrollingParent() {  
  33.         return mChildHelper.hasNestedScrollingParent();  
  34.     }  
  35.   
  36.     @Override  
  37.     public boolean dispatchNestedScroll(int dxConsumed, int dyConsumed, int dxUnconsumed,  
  38.                                         int dyUnconsumed, int[] offsetInWindow) {  
  39.         return mChildHelper.dispatchNestedScroll(dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed,  
  40.                 offsetInWindow);  
  41.     }  
  42.   
  43.     @Override  
  44.     public boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow) {  
  45.         return mChildHelper.dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow);  
  46.     }  
  47.   
  48.     @Override  
  49.     public boolean dispatchNestedFling(float velocityX, float velocityY, boolean consumed) {  
  50.         return mChildHelper.dispatchNestedFling(velocityX, velocityY, consumed);  
  51.     }  
  52.   
  53.     @Override  
  54.     public boolean dispatchNestedPreFling(float velocityX, float velocityY) {  
  55.         return mChildHelper.dispatchNestedPreFling(velocityX, velocityY);  
  56.     }  
  57.   
  58.     // NestedScrollingParent  
  59.     @Override  
  60.     public boolean onStartNestedScroll(View child, View target, int nestedScrollAxes) {  
  61.         return (nestedScrollAxes & ViewCompat.SCROLL_AXIS_VERTICAL) != 0;  
  62.     }  
  63.   
  64.     @Override  
  65.     public void onNestedScrollAccepted(View child, View target, int nestedScrollAxes) {  
  66.         mParentHelper.onNestedScrollAccepted(child, target, nestedScrollAxes);  
  67.         startNestedScroll(ViewCompat.SCROLL_AXIS_VERTICAL);  
  68.     }  
  69.   
  70.     @Override  
  71.     public void onStopNestedScroll(View target) {  
  72.         stopNestedScroll();  
  73.     }  
  74.   
  75.     @Override  
  76.     public void onNestedScroll(View target, int dxConsumed, int dyConsumed, int dxUnconsumed,  
  77.                                int dyUnconsumed) {  
  78.         final int myConsumed = moveBy(dyUnconsumed);  
  79.         final int myUnconsumed = dyUnconsumed - myConsumed;  
  80.         dispatchNestedScroll(0, myConsumed, 0, myUnconsumed, null);  
  81.     }  
  82.   
  83.     @Override  
  84.     public void onNestedPreScroll(View target, int dx, int dy, int[] consumed) {  
  85.         if (dy > 0 && mHeaderController.canScrollUp()) {  
  86.             final int delta = moveBy(dy);  
  87.             consumed[0] = 0;  
  88.             consumed[1] = delta;  
  89.             //dispatchNestedScroll(0, myConsumed, 0, consumed[1], null);  
  90.         }  
  91.     }  
  92.   
  93.     @Override  
  94.     public boolean onNestedFling(View target, float velocityX, float velocityY, boolean consumed) {  
  95.         if (!consumed) {  
  96.             flingWithNestedDispatch((int) velocityY);  
  97.             return true;  
  98.         }  
  99.         return false;  
  100.     }  
  101.   
  102.     private boolean flingWithNestedDispatch(int velocityY) {  
  103.         final boolean canFling = (mHeaderController.canScrollUp() && velocityY > 0) ||  
  104.                 (mHeaderController.canScrollDown() && velocityY < 0);  
  105.         if (!dispatchNestedPreFling(0, velocityY)) {  
  106.             dispatchNestedFling(0, velocityY, canFling);  
  107.             if (canFling) {  
  108.                 fling(velocityY);  
  109.             }  
  110.         }  
  111.         return canFling;  
  112.     }  
  113.   
  114.     @Override  
  115.     public boolean onNestedPreFling(View target, float velocityX, float velocityY) {  
  116.         return flingWithNestedDispatch((int) velocityY);  
  117.     }  
  118.   
  119.     @Override  
  120.     public int getNestedScrollAxes() {  
  121.         return mParentHelper.getNestedScrollAxes();  
  122.     }  
  123.   
  124.     // Touch event hanlder  
  125.   
  126.     @Override  
  127.     public boolean onTouchEvent(MotionEvent ev) {  
  128.         MotionEvent vtev = MotionEvent.obtain(ev);  
  129.         final int actionMasked = MotionEventCompat.getActionMasked(ev);  
  130.         if (actionMasked == MotionEvent.ACTION_DOWN) {  
  131.             mNestedYOffset = 0;  
  132.         }  
  133.         vtev.offsetLocation(0, mNestedYOffset);  
  134.   
  135.         switch (actionMasked) {  
  136.             ...  
  137.             case MotionEvent.ACTION_MOVE:  
  138.                 ...  
  139.                 final int y = (int) MotionEventCompat.getY(ev, activePointerIndex);  
  140.                 int deltaY = mLastMotionY - y;  
  141.                 if (dispatchNestedPreScroll(0, deltaY, mScrollConsumed, mScrollOffset)) {  
  142.                     deltaY -= mScrollConsumed[1];  
  143.                     vtev.offsetLocation(0, mScrollOffset[1]);  
  144.                     mNestedYOffset += mScrollOffset[1];  
  145.                 }  
  146.                 if (!mIsBeingDragged && Math.abs(deltaY) > mTouchSlop) {  
  147.                     final ViewParent parent = getParent();  
  148.                     if (parent != null) {  
  149.                         parent.requestDisallowInterceptTouchEvent(true);  
  150.                     }  
  151.                     mIsBeingDragged = true;  
  152.                     if (deltaY > 0) {  
  153.                         deltaY -= mTouchSlop;  
  154.                     } else {  
  155.                         deltaY += mTouchSlop;  
  156.                     }  
  157.                 }  
  158.                 if (mIsBeingDragged) {  
  159.                     // Scroll to follow the motion event  
  160.                     mLastMotionY = y - mScrollOffset[1];  
  161.   
  162.                     final int scrolledDeltaY = moveBy(deltaY);  
  163.                     final int unconsumedY = deltaY - scrolledDeltaY;  
  164.                     if (dispatchNestedScroll(0, scrolledDeltaY, 0, unconsumedY, mScrollOffset)) {  
  165.                         mLastMotionY -= mScrollOffset[1];  
  166.                         vtev.offsetLocation(0, mScrollOffset[1]);  
  167.                         mNestedYOffset += mScrollOffset[1];  
  168.                     }  
  169.                 }  
  170.                 break;  
  171.             ...  
  172.         }  
  173.         ...  
  174.         return true;  
  175.     }  
  176.   
  177.     ...  
  178. }  

       完整的修改，可以看这个 commit 。整个修改下来，代码减少了不少，而且更加整洁了。

       总结

       总体来说， NestedScroll 初看起来有些让人费解，但是真的理解以后，就发现这种设计的优秀之处。把滑动整体封装起来，通过 Helper 来实现 Child 和 Parent 之间的连接和交互。通过接口来回调，实现了 Child 和 Parent 的逻辑独立。

       Android 5.0的大部分可以滑动的控件都支持了 NestScrolling 接口，最新的 Support V4 中也一样，相信以后越来越多的第三方库都会支持，到时候各种控件的嵌套滑动就能无缝集成了。

本文发布：Android开发网
本文地址：http://www.jizhuomi.com/android/example/483.html
2015年10月29日
发布:鸡啄米 分类:Android开发实例 浏览: 评论:0