说一说android的嵌套滚动机制

欣赏一下

年轻时候的贝鲁奇

1.　系统接口

NestedScrollingParent, NestedScrollingChild，android5.0之后新增的特性

在传统的事件分发机制中，如果一次手势想让多个view来联动，只能让里面的view先滚动起来然后等到适当的条件拦截事件让外面的view滚动，若想交换滚动顺序即先让外面的view动再让里面的view动，这是做不到的，因为事件机制是由里向外抛出，没法再回到里面了！但是在5.0左右的时候，提供了NestedScrollingParent，NestedScrollingChild接口，支持了嵌套手势操作，可以弥补这个缺陷哦。
什么是嵌套滚动呢？
- 当页面里面的控件在接受到手势行为去滚动的时候，能够让外面的view去滚动，然后外面滚到到符合你的要求了，你再让里面的控件滚动，也可以让外面的view和里面的控件一起滚动, 这个过程都是在一次手势中哦，所以正好弥补了传统事件机制中的不足。

NestedScrollingParent: 作为嵌套滑动的parent

public interface NestedScrollingParent {
    
    /**
    *当嵌套的child调用startNestedScroll，会触发这个方法，检测我们的parent是否支持嵌套的去滚动操作;
    return true即支持parent来滚动，return false即不支持嵌套滚动。
    * target是我们的发起嵌套滚动操作的ｖｉew哦。
     */
    public boolean onStartNestedScroll(View child, View target, int nestedScrollAxes);

    /**
    *当上面的onStartNestedScroll返回true的时候，会触发这个方法来做你想要的初始化操作;
     */
    public void onNestedScrollAccepted(View child, View target, int nestedScrollAxes);

    /**
     */
    public void onStopNestedScroll(View target);

    /**
    * 接收到滚动请求，此时可以主动滑动来消费掉发起方提供的未消费完剩下的距离
     */
    public void onNestedScroll(View target, int dxConsumed, int dyConsumed,
            int dxUnconsumed, int dyUnconsumed);

    /**
    * 在嵌套的层级中，当嵌套的子ｖｉew滑动时候，我们想在他之前先让parent来滑动，就执行这个操作。
     */
    public void onNestedPreScroll(View target, int dx, int dy, int[] consumed);

    /**
    *parent实现一定的滑翔处理
     */
    public boolean onNestedFling(View target, float velocityX, float velocityY, boolean consumed);

    /**
    *　一般没什么用，在子child滑翔之前开始滑翔，一般不会有这个操作。retur false即可。
     */
    public boolean onNestedPreFling(View target, float velocityX, float velocityY);

    /**
    * 返回当前滚动的坐标轴线，横轴线/纵轴
     */
    public int getNestedScrollAxes();

NestedScrollingChild：作为嵌套滑动的child

public interface NestedScrollingChild {
    
    /**
     * 设置child支持嵌套滑动,表示是否支持滚动的时候是否将发给parent.
     */
    public void setNestedScrollingEnabled(boolean enabled);

    /**
     * 判断是否支持嵌套滑动
     */
    public boolean isNestedScrollingEnabled();

    /**
     *child 开始着手触发嵌套活动了
     */
    public boolean startNestedScroll(int axes);

    /**
     * child开始想要停止嵌套滑动了，与startNestedScroll对应，由他发起自然要由他结束了。
     */
    public void stopNestedScroll();

    /**
     * 在child自身滚动之后分发剩余的未消费滑动距离
     */
    public boolean dispatchNestedScroll(int dxConsumed, int dyConsumed,
            int dxUnconsumed, int dyUnconsumed, int[] offsetInWindow);

    /**
     * 在子child决定滑动前先让他的parent来尝试下要不要先滑动下.
     */
    public boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow);

    /**
     *当child滑翔的过程中时候，问问parent要不要也滑一下。
     */
    public boolean dispatchNestedFling(float velocityX, float velocityY, boolean consumed);

    /**
     * 略
     */
    public boolean dispatchNestedPreFling(float velocityX, float velocityY);

NestedScrollingParent和NestedScrollingChild的关系图

图片来自https://www.jianshu.com/p/490659fae773

NestedScrollingParentHelper：嵌套滚动的parent辅助类, 只是设计的方便，里面并没有做什么实际的动作。

NestedScrollingChildHelper：嵌套滚动的发起方child, 下面列出几个关键的方法


//当child滚动的时候，会调用该方法，找到可以接受嵌套去滚动的父容器， true表示找到了，false表示没有找到
public boolean startNestedScroll(int axes) {
    //如果已经有了，直接返回
    if (hasNestedScrollingParent()) {
        return true;
    }
    //需要当前的child能支持嵌套滚动哦
    if (isNestedScrollingEnabled()) {
        ViewParent p = mView.getParent();
        View child = mView;
        //递归地上巡找到能够接收嵌套滚动的parent
        while (p != null) {
            //这个if检测当前的container是否支持嵌套滚动哦，
            if (ViewParentCompat.onStartNestedScroll(p, child, mView, axes)) {
                //如果支持赋值给mNestedScrollingParent，后面就直接用它就好了
                mNestedScrollingParent = p;
                ViewParentCompat.onNestedScrollAccepted(p, child, mView, axes);
                return true;
            }
            //没找到继续向上遍历。
            if (p instanceof View) {
                child = (View) p;
            }
            p = p.getParent();
        }
    }
    return false;
}

//在嵌套滚动的时候，child在自己滚动前会先问问他的parent要不要先滚动下，是通过该方法来实现的。
//
public boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow) {
    //如果child支持嵌套滚动,并且存在嵌套的父容器，
    if (isNestedScrollingEnabled() && mNestedScrollingParent != null) {
        if (dx != 0 || dy != 0) {
            int startX = 0;
            int startY = 0;
            if (offsetInWindow != null) {
                mView.getLocationInWindow(offsetInWindow);
                startX = offsetInWindow[0];
                startY = offsetInWindow[1];
            }

            if (consumed == null) {
                if (mTempNestedScrollConsumed == null) {
                    mTempNestedScrollConsumed = new int[2];
                }
                consumed = mTempNestedScrollConsumed;
            }
            consumed[0] = 0;
            consumed[1] = 0;
            //滚动父容器
            ViewParentCompat.onNestedPreScroll(mNestedScrollingParent, mView, dx, dy, consumed);

            if (offsetInWindow != null) {
                mView.getLocationInWindow(offsetInWindow);
                offsetInWindow[0] -= startX;
                offsetInWindow[1] -= startY;
            }
            //consumed记录了父容器消耗的距离，有就会返回true.
            return consumed[0] != 0 || consumed[1] != 0;
        } else if (offsetInWindow != null) {
            offsetInWindow[0] = 0;
            offsetInWindow[1] = 0;
        }
    }
    return false;
}



//在嵌套滚动的时候，如果child滚动了一段距离，还剩下一段手势距离，就交给他的父容器问问他要不要划一划,基本逻辑和前面的方法是一样的呢，return true表明有这样的parent并且划了。
public boolean dispatchNestedScroll(int dxConsumed, int dyConsumed,
            int dxUnconsumed, int dyUnconsumed, int[] offsetInWindow) {
    //如果child支持嵌套滚动，并且有嵌套的parent.
    if (isNestedScrollingEnabled() && mNestedScrollingParent != null) {
        if (dxConsumed != 0 || dyConsumed != 0 || dxUnconsumed != 0 || dyUnconsumed != 0) {
            int startX = 0;
            int startY = 0;
            if (offsetInWindow != null) {
                mView.getLocationInWindow(offsetInWindow);
                startX = offsetInWindow[0];
                startY = offsetInWindow[1];
            }
         //那么就让嵌套的parent来滑动一下
            ViewParentCompat.onNestedScroll(mNestedScrollingParent, mView, dxConsumed,
                                            dyConsumed, dxUnconsumed, dyUnconsumed);

            if (offsetInWindow != null) {
                mView.getLocationInWindow(offsetInWindow);
                offsetInWindow[0] -= startX;
                offsetInWindow[1] -= startY;
            }
            //表明parent滚动了一段距离
            return true;
        } else if (offsetInWindow != null) {
            // No motion, no dispatch. Keep offsetInWindow up to date.
            offsetInWindow[0] = 0;
            offsetInWindow[1] = 0;
        }
    }
    //表明没有滚动距离
    return false;
}

2.　嵌套在系统中的应用：NestedScrollView作为嵌套的parent, RecyclerView作为嵌套滚动的child的场景

NestedScrollView：他既充当着嵌套滚动的父view,(其实也可同时充当着嵌套滚动的子child) 这里就看看作为parent实现了的NestedScrollingParent的相关接口吧, 接受嵌套child发起的滚动的操作都会在下面的接口中进行动作啦：

 @Override
    public boolean onStartNestedScroll(View child, View target, int nestedScrollAxes) {
        //如果是纵向的滚动，NestedScrollView支持嵌套地滚动;
        return (nestedScrollAxes & ViewCompat.SCROLL_AXIS_VERTICAL) != 0;
    }

    @Override
    public void onNestedScrollAccepted(View child, View target, int nestedScrollAxes) {         
        //如果onStartNestedScroll返回true,走到这里。
        mParentHelper.onNestedScrollAccepted(child, target, nestedScrollAxes);
        //NestedScrollView同时也作为child, 将嵌套事件发给他的parent中去;是一种递归嵌套
        startNestedScroll(ViewCompat.SCROLL_AXIS_VERTICAL);
    }

    @Override
    public void onStopNestedScroll(View target) {
        mParentHelper.onStopNestedScroll(target);
          //NestedScrollView同时也作为child,将嵌套滚动发给他的parent中去;
        stopNestedScroll();
    }

    @Override
    public void onNestedScroll(View target, int dxConsumed, int dyConsumed, int dxUnconsumed,
            int dyUnconsumed) {
        final int oldScrollY = getScrollY();
        //消耗child没有滚动完的距离，
        scrollBy(0, dyUnconsumed);
        final int myConsumed = getScrollY() - oldScrollY;
        final int myUnconsumed = dyUnconsumed - myConsumed;
        //将自己未消耗完的距离继续递归地给到他的parent去消耗。NestedScrollView这时候又冲到嵌套的child
        dispatchNestedScroll(0, myConsumed, 0, myUnconsumed, null);
    }

    @Override
    public void onNestedPreScroll(View target, int dx, int dy, int[] consumed) {
        // Do nothing
        //不会在child滑行前做什么
    }

    @Override
    public boolean onNestedFling(View target, float velocityX, float velocityY, boolean consumed) {
        //如果child没有消耗，NestedScrollView将消耗掉这些。
        if (!consumed) {
            flingWithNestedDispatch((int) velocityY);
            return true;
        }
        return false;
    }

    @Override
    public boolean onNestedPreFling(View target, float velocityX, float velocityY) {
        // Do nothing
        return false;
    }

    @Override
    public int getNestedScrollAxes() {
        //获取滚动的轴，横向的或是纵向的。
        return mParentHelper.getNestedScrollAxes();
    }

NestedScrollView中的拦截和消耗事件对嵌套滚动原则的相关处理，看看onInterceptTouchEvent和onTouchEvent.

onInterceptTouchEvent, 如何拦截的呢，看源码注释解读

//返回true就是拦截下来, false就是不拦截
public boolean onInterceptTouchEvent(MotionEvent ev) {
  
  final int action = ev.getAction();
    //如果当前是move,并且当前NestedScrollView处于了滚动状态，就返回true.滚动事件不会下去，所以他的子ｖｉew没法发起嵌套滚动的操作。
     if ((action == MotionEvent.ACTION_MOVE) && (mIsBeingDragged)) {
         return true;
     }

     switch (action & MotionEventCompat.ACTION_MASK) {
         case MotionEvent.ACTION_MOVE: {
            
             final int activePointerId = mActivePointerId;
             //无效的判断......
             if (activePointerId == INVALID_POINTER) {
                 // If we don't have a valid id, the touch down wasn't on content.
                 break;
             }

             final int pointerIndex = MotionEventCompat.findPointerIndex(ev, activePointerId);
                //无效的判断......
             if (pointerIndex == -1) {
                 Log.e(TAG, "Invalid pointerId=" + activePointerId
                       + " in onInterceptTouchEvent");
                 break;
             }

             final int y = (int) MotionEventCompat.getY(ev, pointerIndex);
             final int yDiff = Math.abs(y - mLastMotionY);
             //如果当前move是滚动操作，并且当前View压根就不支持嵌套滚动，那么就表示自己要来实现滚动啦。这时候后面的move都会被该NestedScrollView拦截下来的。
             if (yDiff > mTouchSlop
                 && (getNestedScrollAxes() & ViewCompat.SCROLL_AXIS_VERTICAL) == 0) {
                 mIsBeingDragged = true;
                 mLastMotionY = y;
                 initVelocityTrackerIfNotExists();
                 mVelocityTracker.addMovement(ev);
                 mNestedYOffset = 0;
                 final ViewParent parent = getParent();
                 if (parent != null) {
                     parent.requestDisallowInterceptTouchEvent(true);
                 }
             }
             break;
         }

         case MotionEvent.ACTION_DOWN: {
             final int y = (int) ev.getY();
             //如果down位置落点不在他的child内部，啥都不做，没法滚动
             if (!inChild((int) ev.getX(), (int) y)) {
                 mIsBeingDragged = false;
                 recycleVelocityTracker();
                 break;
             }

        
             mLastMotionY = y;
             mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
         
             //建立速度跟踪，然后跟踪手势
             initOrResetVelocityTracker();
             mVelocityTracker.addMovement(ev);
             //计算滚动
             mScroller.computeScrollOffset();
             //滚动没结束，mIsBeingDragged为true.
             mIsBeingDragged = !mScroller.isFinished();
             //作为嵌套的child, 发起滚动请求
             startNestedScroll(ViewCompat.SCROLL_AXIS_VERTICAL);
             break;
         }

         case MotionEvent.ACTION_CANCEL:
         case MotionEvent.ACTION_UP:
             //mIsBeingDragged清除掉状态, 
             mIsBeingDragged = false;
             mActivePointerId = INVALID_POINTER;
             //清除掉速度跟踪
             recycleVelocityTracker();
             //检查是否要滚动回弹一下
             if (mScroller.springBack(getScrollX(), getScrollY(), 0, 0, 0, getScrollRange())) {
                 ViewCompat.postInvalidateOnAnimation(this);
             }
             //停下嵌套滚动，如果有嵌套滚动的操作。
             stopNestedScroll();
             break;
        
     }
 //mIsBeingDragged其实表示的就是档次拖动是不是给这个ScrollView用;
     return mIsBeingDragged;
 }

onTouchEvent：如何响应的呢，看源码注释解读

 public boolean onTouchEvent(MotionEvent ev) {
     initVelocityTrackerIfNotExists();

     MotionEvent vtev = MotionEvent.obtain(ev);

     final int actionMasked = MotionEventCompat.getActionMasked(ev);

     if (actionMasked == MotionEvent.ACTION_DOWN) {
         mNestedYOffset = 0;
     }
     vtev.offsetLocation(0, mNestedYOffset);

     switch (actionMasked) {
         case MotionEvent.ACTION_DOWN: {
             if (getChildCount() == 0) {
                 return false;
             }
             //down的时候，请求父容器不要拦截;
             if ((mIsBeingDragged = !mScroller.isFinished())) {
                 final ViewParent parent = getParent();
                 if (parent != null) {
                     parent.requestDisallowInterceptTouchEvent(true);
                 }
             }

           //当我们滚动scrollView的时候，如果还在滑行，我们突然按下手指，滚动就会停下来，就是因为这里的处理哦！
             if (!mScroller.isFinished()) {
                 mScroller.abortAnimation();
             }

             // Remember where the motion event started
             mLastMotionY = (int) ev.getY();
             mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
             //这里是和嵌套滚动相关的地方，作为嵌套的child, 发起纵向的滚动请求
             startNestedScroll(ViewCompat.SCROLL_AXIS_VERTICAL);
             break;
         }
         case MotionEvent.ACTION_MOVE:
             final int activePointerIndex = MotionEventCompat.findPointerIndex(ev,                                                                          mActivePointerId);
             if (activePointerIndex == -1) {
                 Log.e(TAG, "Invalid pointerId=" + mActivePointerId + " in onTouchEvent");
                 break;
             }

             final int y = (int) MotionEventCompat.getY(ev, activePointerIndex);
             //计算滚动的距离
             int deltaY = mLastMotionY - y;
             //这时候其实作为一个child,滚动前先问问parent要不要滚动一下
             if (dispatchNestedPreScroll(0, deltaY, mScrollConsumed, mScrollOffset)) {
                 //除去parent滚动过的距离
                 deltaY -= mScrollConsumed[1];
                 vtev.offsetLocation(0, mScrollOffset[1]);
                 mNestedYOffset += mScrollOffset[1];
             }
             if (!mIsBeingDragged && Math.abs(deltaY) > mTouchSlop) {
                 final ViewParent parent = getParent();
                 if (parent != null) {
                     parent.requestDisallowInterceptTouchEvent(true);
                 }
                 mIsBeingDragged = true;
                 if (deltaY > 0) {
                     deltaY -= mTouchSlop;
                 } else {
                     deltaY += mTouchSlop;
                 }
             }
             if (mIsBeingDragged) {//表示NestedScrollView自己要滚动了
                 // Scroll to follow the motion event
                 mLastMotionY = y - mScrollOffset[1];

                 final int oldY = getScrollY();
                 final int range = getScrollRange();
                 final int overscrollMode = ViewCompat.getOverScrollMode(this);
                 boolean canOverscroll = overscrollMode == ViewCompat.OVER_SCROLL_ALWAYS ||
                     (overscrollMode == ViewCompat.OVER_SCROLL_IF_CONTENT_SCROLLS &&
                      range > 0);

                 //overScrollByCompat表示要自己来滚动对应的距离啦，并不一定会滚动完所有的剩余距离
                 if (overScrollByCompat(0, deltaY, 0, getScrollY(), 0, range, 0,
                                        0, true) && !hasNestedScrollingParent()) {
                     // Break our velocity if we hit a scroll barrier.
                     mVelocityTracker.clear();
                 }

                 final int scrolledDeltaY = getScrollY() - oldY;
                 final int unconsumedY = deltaY - scrolledDeltaY;
                 //这里还是作为child, 把还没滚完的手势给到父parent.让他去滚动
                 if (dispatchNestedScroll(0, scrolledDeltaY, 0, unconsumedY, mScrollOffset)) {
                     mLastMotionY -= mScrollOffset[1];
                     vtev.offsetLocation(0, mScrollOffset[1]);
                     mNestedYOffset += mScrollOffset[1];
                 } else if (canOverscroll) {//如果支持, 当滑动了上下边界的，要绘制边界阴影了
                     ensureGlows();
                     final int pulledToY = oldY + deltaY;
                     if (pulledToY < 0) {//绘制上面的边界阴影
                         mEdgeGlowTop.onPull((float) deltaY / getHeight(),
                                             MotionEventCompat.getX(ev, activePointerIndex) / getWidth());
                         if (!mEdgeGlowBottom.isFinished()) {
                             mEdgeGlowBottom.onRelease();
                         }
                     } else if (pulledToY > range) {//绘制下面的边界阴影
                         mEdgeGlowBottom.onPull((float) deltaY / getHeight(),
                                                1.f - MotionEventCompat.getX(ev, activePointerIndex)
                                                / getWidth());
                         if (!mEdgeGlowTop.isFinished()) {
                             mEdgeGlowTop.onRelease();
                         }
                     }
                     if (mEdgeGlowTop != null
                         && (!mEdgeGlowTop.isFinished() || !mEdgeGlowBottom.isFinished())) {//刷新绘制，从而让边界阴影显示出来;
                         ViewCompat.postInvalidateOnAnimation(this);
                     }
                 }
             }
             break;
         case MotionEvent.ACTION_UP:
             if (mIsBeingDragged) {
                 final VelocityTracker velocityTracker = mVelocityTracker;
                 velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
                 int initialVelocity = (int) VelocityTrackerCompat.getYVelocity(velocityTracker,
                                                                                mActivePointerId);
               //如果大于最小速度限制，会滑行
                 if ((Math.abs(initialVelocity) > mMinimumVelocity)) {
                     //该方法会做嵌套滑行分发，也就是当钱view支持滑行的时候也会给parent-view去滑行一下，不过他们没有做距离和速度分减少，也不好做因为他们都是根据最后的初始速度去减速滑行的。只是对应的parent可以根据child是否到边界了选择滑还是不滑。
                     flingWithNestedDispatch(-initialVelocity);
                 } else if (mScroller.springBack(getScrollX(), getScrollY(), 0, 0, 0,
                                                 getScrollRange())) {
                     ViewCompat.postInvalidateOnAnimation(this);
                 }
             }
             mActivePointerId = INVALID_POINTER;
             endDrag();
             break;
      
        .......
            
     vtev.recycle();
     return true;
 }

本来是想分析NestedScrollView作为嵌套的parent行为，但从前面的onTouchEvent中源码可以看到，NestedScrollView这里其实基本充当着嵌套的child角色的，想想也是对的，嵌套滚动操作是由child来发起的然后parent响应，onTouchEvent自然是动作发起的地方，所以这里基本就是child的动作行为。我们在认识传统事件分发的时候，知道滚动这些move操作当前只能给某个view去消耗，没法给多个人使用的，而嵌套滚动却可以，在这里总结下他的实现，他在move的时候先将滚动距离通过dispatchNestedPreScroll传递给实现了NestedScrollingParent的接口的parent, 让他先滚动滚动，然后扣除parent滚动过的距离，接着自己再调用overScrollByCompat，NestedScrollView自己来滚动，如果还有剩余又调用dispatchNestedScroll, 继续让parent去滚动。在手指抬起的时候如果有滑行操作，也会把滑行速度传递父parent，父parent可以自行决定要不要进行滑行。大概就是这么个逻辑，实现了多个view来消耗一次手势操作呢。

RecyclerView, 他只能作为嵌套的子child, 即实现NestedScrollingChild，而没能做parent. 就来看看他的onInterceptTouchEvent和onTouchEvent，是如何处理嵌套相关的行为吧。感觉应该和NestedScrollView应该是很相似的逻辑的哦

RecyclerView.onInterceptTouchEvent，看源码注释解读

 public boolean onInterceptTouchEvent(MotionEvent e) {
     if (mLayoutFrozen) {
         return false;
     }
     if (dispatchOnItemTouchIntercept(e)) {
         cancelTouch();
         return true;
     }

     if (mLayout == null) {
         return false;
     }

     final boolean canScrollHorizontally = mLayout.canScrollHorizontally();
     final boolean canScrollVertically = mLayout.canScrollVertically();

     if (mVelocityTracker == null) {
         mVelocityTracker = VelocityTracker.obtain();
     }
     mVelocityTracker.addMovement(e);

     final int action = MotionEventCompat.getActionMasked(e);
     final int actionIndex = MotionEventCompat.getActionIndex(e);

     switch (action) {
         case MotionEvent.ACTION_DOWN:
             if (mIgnoreMotionEventTillDown) {
                 mIgnoreMotionEventTillDown = false;
             }
             mScrollPointerId = MotionEventCompat.getPointerId(e, 0);
             mInitialTouchX = mLastTouchX = (int) (e.getX() + 0.5f);
             mInitialTouchY = mLastTouchY = (int) (e.getY() + 0.5f);

             if (mScrollState == SCROLL_STATE_SETTLING) {
                 getParent().requestDisallowInterceptTouchEvent(true);
                 setScrollState(SCROLL_STATE_DRAGGING);
             }

             // Clear the nested offsets
             mNestedOffsets[0] = mNestedOffsets[1] = 0;

             int nestedScrollAxis = ViewCompat.SCROLL_AXIS_NONE;
             if (canScrollHorizontally) {
                 nestedScrollAxis |= ViewCompat.SCROLL_AXIS_HORIZONTAL;
             }
             if (canScrollVertically) {
                 nestedScrollAxis |= ViewCompat.SCROLL_AXIS_VERTICAL;
             }
             //down的时候发起嵌套滚动请求
             startNestedScroll(nestedScrollAxis);
             break;

         case MotionEventCompat.ACTION_POINTER_DOWN:
             mScrollPointerId = MotionEventCompat.getPointerId(e, actionIndex);
             mInitialTouchX = mLastTouchX = (int) (MotionEventCompat.getX(e, actionIndex) + 0.5f);
             mInitialTouchY = mLastTouchY = (int) (MotionEventCompat.getY(e, actionIndex) + 0.5f);
             break;

         case MotionEvent.ACTION_MOVE: {
             final int index = MotionEventCompat.findPointerIndex(e, mScrollPointerId);
             if (index < 0) {
                 Log.e(TAG, "Error processing scroll; pointer index for id " +
                       mScrollPointerId + " not found. Did any MotionEvents get skipped?");
                 return false;
             }

             final int x = (int) (MotionEventCompat.getX(e, index) + 0.5f);
             final int y = (int) (MotionEventCompat.getY(e, index) + 0.5f);
             if (mScrollState != SCROLL_STATE_DRAGGING) {
                 final int dx = x - mInitialTouchX;
                 final int dy = y - mInitialTouchY;
                 boolean startScroll = false;
                 if (canScrollHorizontally && Math.abs(dx) > mTouchSlop) {
                     mLastTouchX = mInitialTouchX + mTouchSlop * (dx < 0 ? -1 : 1);
                     startScroll = true;
                 }
                 if (canScrollVertically && Math.abs(dy) > mTouchSlop) {
                     mLastTouchY = mInitialTouchY + mTouchSlop * (dy < 0 ? -1 : 1);
                     startScroll = true;
                 }
                 if (startScroll) {
                     setScrollState(SCROLL_STATE_DRAGGING);
                 }
             }
         } break;
             
     .......

         case MotionEvent.ACTION_UP: {
             mVelocityTracker.clear();
             //停止嵌套滚动
             stopNestedScroll();
         } break;

         case MotionEvent.ACTION_CANCEL: {
             cancelTouch();
         }
     }
     return mScrollState == SCROLL_STATE_DRAGGING;
 }

总结一下，从recyclerView的拦截方法中可以看出，其实和嵌套滚动操作的内容是很少的，只有在down的时候发起一下嵌套操作startNestedScroll，在up的时候停止嵌套滚动，告知到他的父容器，比如NestedScrollView。那么就看看他的其他关于拦截的逻辑吧，只要在拖拽的过程中，就会拦截下来，那么他的子view一般在这里就没法响应触摸事件啦。

RecyclerView.onTouchEvent，看源码注释解读

public boolean onTouchEvent(MotionEvent e) {
  
   ......
        
    if (action == MotionEvent.ACTION_DOWN) {
        mNestedOffsets[0] = mNestedOffsets[1] = 0;
    }
    vtev.offsetLocation(mNestedOffsets[0], mNestedOffsets[1]);

    switch (action) {
        case MotionEvent.ACTION_DOWN: {
            mScrollPointerId = MotionEventCompat.getPointerId(e, 0);
            mInitialTouchX = mLastTouchX = (int) (e.getX() + 0.5f);
            mInitialTouchY = mLastTouchY = (int) (e.getY() + 0.5f);
           
            if (mScrollState == SCROLL_STATE_SETTLING) {
                //请求recyclerView的父容器不要拦截啊，看样子android系统也是这么做的哦，也担心上面被拦了
                    getParent().requestDisallowInterceptTouchEvent(true);
                    setScrollState(SCROLL_STATE_DRAGGING);
            }
            
            int nestedScrollAxis = ViewCompat.SCROLL_AXIS_NONE;
            if (canScrollHorizontally) {
                nestedScrollAxis |= ViewCompat.SCROLL_AXIS_HORIZONTAL;
            }
            if (canScrollVertically) {
                nestedScrollAxis |= ViewCompat.SCROLL_AXIS_VERTICAL;
            }
            //根据是横向的还是竖向的启动嵌套滚动
            startNestedScroll(nestedScrollAxis);
        } break;

     ......
        
        case MotionEvent.ACTION_MOVE: {
            final int index = MotionEventCompat.findPointerIndex(e, mScrollPointerId);
            //检查操作
            if (index < 0) {
                Log.e(TAG, "Error processing scroll; pointer index for id " +
                      mScrollPointerId + " not found. Did any MotionEvents get skipped?");
                return false;
            }

            final int x = (int) (MotionEventCompat.getX(e, index) + 0.5f);
            final int y = (int) (MotionEventCompat.getY(e, index) + 0.5f);
            int dx = mLastTouchX - x;
            int dy = mLastTouchY - y;
           // 传递给parent去预先滚动一段距离
            if (dispatchNestedPreScroll(dx, dy, mScrollConsumed, mScrollOffset)) {
                dx -= mScrollConsumed[0];
                dy -= mScrollConsumed[1];
                vtev.offsetLocation(mScrollOffset[0], mScrollOffset[1]);
                // Updated the nested offsets
                mNestedOffsets[0] += mScrollOffset[0];
                mNestedOffsets[1] += mScrollOffset[1];
            }

            //这里应该是一个设定，只要我们的move达到了一段的距离，我们就要让recyclerView滚动起来！
            if (mScrollState != SCROLL_STATE_DRAGGING) {
                boolean startScroll = false;
                if (canScrollHorizontally && Math.abs(dx) > mTouchSlop) {
                    if (dx > 0) {
                        dx -= mTouchSlop;
                    } else {
                        dx += mTouchSlop;
                    }
                    startScroll = true;
                }
                if (canScrollVertically && Math.abs(dy) > mTouchSlop) {
                    if (dy > 0) {
                        dy -= mTouchSlop;
                    } else {
                        dy += mTouchSlop;
                    }
                    startScroll = true;
                }
                //设置滚动态
                if (startScroll) {
                    setScrollState(SCROLL_STATE_DRAGGING);
                }
            }

            if (mScrollState == SCROLL_STATE_DRAGGING) {
                mLastTouchX = x - mScrollOffset[0];
                mLastTouchY = y - mScrollOffset[1];

                //scrollByInternal自己滚动一段距离，并且内部还会将剩下的距离又传递给parent.
                //以后可以去查看该方法的实现。
                if (scrollByInternal(
                    canScrollHorizontally ? dx : 0,
                    canScrollVertically ? dy : 0,
                    vtev)) {
                    //请求父容器不要拦截
                    getParent().requestDisallowInterceptTouchEvent(true);
                }
            }
        } break;

       ......

        case MotionEvent.ACTION_UP: {
            mVelocityTracker.addMovement(vtev);
            eventAddedToVelocityTracker = true;
            mVelocityTracker.computeCurrentVelocity(1000, mMaxFlingVelocity);
            final float xvel = canScrollHorizontally ?
                -VelocityTrackerCompat.getXVelocity(mVelocityTracker, mScrollPointerId) : 0;
            final float yvel = canScrollVertically ?
                -VelocityTrackerCompat.getYVelocity(mVelocityTracker, mScrollPointerId) : 0;
            //fling操作，在这里处理嵌套滑行的行为，可以查看里面的方法细节
            if (!((xvel != 0 || yvel != 0) && fling((int) xvel, (int) yvel))) {
                setScrollState(SCROLL_STATE_IDLE);
            }
            resetTouch();
        } break;

        case MotionEvent.ACTION_CANCEL: {
            cancelTouch();
        } break;
    }

    if (!eventAddedToVelocityTracker) {
        mVelocityTracker.addMovement(vtev);
    }
    vtev.recycle();

    return true;
}

总结一下，RecyclerView的onTouchEvent和NestedScrollView的逻辑很相似，二者在这个区间里表现的都是一个嵌套child的行为，在down的时候发起，在move先传递给parent, 然后自己消耗。大概就这样子吧。

3. 　嵌套存在着的问题，以及造成的原因

NestedScrollView/ScrollView嵌套ListView显示不全，经常显示一行问题!

原因在哪里呢，如下：

---NestedScrollView方法:

protected void measureChildWithMargins(View child, int parentWidthMeasureSpec, int widthUsed,
            int parentHeightMeasureSpec, int heightUsed) {
        final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();

        final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
                getPaddingLeft() + getPaddingRight() + lp.leftMargin + lp.rightMargin
                        + widthUsed, lp.width);
    //在测量子View的高度的时候传递进去的是UNSPECIFIED，也就是不限制子ｖｉew的高度。
        final int childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(
                lp.topMargin + lp.bottomMargin, MeasureSpec.UNSPECIFIED);

        child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
    }

---ListView方法:
  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        // Sets up mListPadding
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);

       .......
           
        if (widthMode == MeasureSpec.UNSPECIFIED) {
            widthSize = mListPadding.left + mListPadding.right + childWidth +
                    getVerticalScrollbarWidth();
        } else {
            widthSize |= (childState & MEASURED_STATE_MASK);
        }
    .......
        
        //重点在这里呢，如果是MeasureSpec.UNSPECIFIED模式，他设置的高度就是单个条目加上padding距离啊！所以就显示了一行......但是如果我们用其他的布局嵌套listView的时候，一般是不会传递UNSPECIFIED的规格的，所以没问题。
        if (heightMode == MeasureSpec.UNSPECIFIED) {
            heightSize = mListPadding.top + mListPadding.bottom + childHeight +
                    getVerticalFadingEdgeLength() * 2;
        }

        setMeasuredDimension(widthSize, heightSize);

        mWidthMeasureSpec = widthMeasureSpec;
    }

解决，　重写LinearLayout的onMeasure方法，改写ScrollView传进来的测量规格哦，虽然解决了显示不全的问题，但是复用规则被打破！这不是好的办法。

  @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        //改写规格，将高度设置成无限。因此也就造成了一开始就全部展开，无法复用listView的单元控件。重要弊端！
        int heightSpec = MeasureSpec.makeMeasureSpec(Integer.MAX_VALUE >> 2, MeasureSpec.AT_MOST);
        super.onMeasure(widthMeasureSpec, heightSpec);
    }

NestedScrollView与RecyclerView嵌套，RecyclerView不能被重复利用

原因，还是看代码吧:

--- LineaLayoutManager
//当layoutState.mInfinite为true的时候，会一直调用layoutChunk，从而让所有的itemView一次性全部创建了。ayoutState.mInfinite的计算就是mLayoutState.mInfinite = mOrientationHelper.getMode() == View.MeasureSpec.UNSPECIFIED;而这个mode也是ScrollView传递进来的！
while ((layoutState.mInfinite || remainingSpace > 0) && layoutState.hasMore(state)) {
            layoutChunkResult.resetInternal();
                layoutChunk(recycler, state, layoutState, layoutChunkResult);
            if (layoutChunkResult.mFinished) {
                break;
            }
            layoutState.mOffset += layoutChunkResult.mConsumed * layoutState.mLayoutDirection;
            /**
             * Consume the available space if:
             * * layoutChunk did not request to be ignored
             * * OR we are laying out scrap children
             * * OR we are not doing pre-layout
             */
            if (!layoutChunkResult.mIgnoreConsumed || mLayoutState.mScrapList != null
                    || !state.isPreLayout()) {
                layoutState.mAvailable -= layoutChunkResult.mConsumed;
                // we keep a separate remaining space because mAvailable is important for recycling
                remainingSpace -= layoutChunkResult.mConsumed;
            }

            if (layoutState.mScrollingOffset != LayoutState.SCOLLING_OFFSET_NaN) {
                layoutState.mScrollingOffset += layoutChunkResult.mConsumed;
                if (layoutState.mAvailable < 0) {
                    layoutState.mScrollingOffset += layoutState.mAvailable;
                }
                recycleByLayoutState(recycler, layoutState);
            }
            if (stopOnFocusable && layoutChunkResult.mFocusable) {
                break;
            }
        }



 void layoutChunk(RecyclerView.Recycler recycler, RecyclerView.State state,
            LayoutState layoutState, LayoutChunkResult result) {
        View view = layoutState.next(recycler);
     ........
         if (layoutState.mScrapList == null) {
             if (mShouldReverseLayout == (layoutState.mLayoutDirection
                                          == LayoutState.LAYOUT_START)) {
                 addView(view);
             } else {
                 addView(view, 0);
             }

总结，上面两个都有复用规则打破的问题，这是个大问题，在少量数据还好，数据多了就会出现crash的，所以利用NestedScrollView＋RecyclerView的去实现复杂界面并没有好的实现策略。虽然系统对二者都实现了嵌套滚动的策略，看上去处理的很好，然而却是存在着巨大的bug, google也推荐我们不要这么搞，但是实际有这样的需求啊, 感觉google这里好坑啊!

说一说android的嵌套滚动机制

欣赏一下

1. 系统接口

2. 嵌套在系统中的应用：NestedScrollView作为嵌套的parent, RecyclerView作为嵌套滚动的child的场景

3. 嵌套存在着的问题，以及造成的原因

1.　系统接口

2.　嵌套在系统中的应用：NestedScrollView作为嵌套的parent, RecyclerView作为嵌套滚动的child的场景

3. 　嵌套存在着的问题，以及造成的原因