NestedScrollingParent 和 NestedScrollingChild 嵌套滑动原理介绍

---

View的事件分发机制

在介绍NestedScrollingParent 和 NestedScrollingChild 嵌套滑动之前，先介绍下View的事件分发机制，因为NestedScrollingParent 和 NestedScrollingChild 主要是很好地解决了View滑动冲突问题。

一次点击事件由三个重要的方法来共同完成：dispatchTouchEvent、onInterceptTouchEvent、onTouchEvent。

dispatchTouchEvent：进行事件分发。如果事件能够传递到当前View，那么此方法一定会被调用，返回结果受当前View的onTouchEvent和下级View的dispatchTouchEvent方法的影响。方法返回结果表示是否消耗当前事件，true表示消耗，false表示不消耗。

onInterceptTouchEvent：进行事件拦截，在方法内部调用，在ViewGroup中的dispatchTouchEvent方法内部中调用，View并没有onInterceptTouchEvent方法。如果View拦截了某个事件，在同一个事件序列中，此方法不会被再次调用。方法返回结果表示是否拦截当前事件，true表示拦截，false表示不拦截。

onTouchEvent：进行事件处理，在dispatchTouchEvent方法中调用。如果View不消耗这个事件，在同一事件序列中，当前View无法再次接受到事件。方法返回结果表示是否消耗当前事件，true表示消耗，false表示不消耗。

这三个方法的关系：

public boolean dispatchTouchEvent(MotionEvent ev){
    boolean consume = false;
    if (onInterceptTouchEvent(ev)){
        consume =  onTouchEvnet(ev);
    } else{
        consume = child.dispatchTouchEvent(ev);
    }
    return consume;
}

上面表现出了事件的传递规则：一次点击事件产生后，传递的顺序是：Activity → Window → View，首先会传递给Activity，Activity再传递给Window，最后Window传递给顶级View，顶级View接受事件后，就会进行事件分发。顶级View是一个ViewGroup，首先调用它的dispatchTouchEvent，如果这个ViewGroup的onInterceptTouchEvent方法返回true，就会交给这个ViewGroup的onTouchEvent方法处理；如果这个ViewGroup的onInterceptTouchEvent方法返回false，就会交给这个ViewGroup的子View的dispatchTouchEvent方法处理，如此反复直到事件被最终处理。

---

View滑动冲突

常见的滑动冲突场景：

• 场景1：外部滑动方向与内部滑动方向不一致；
• 场景2：外部滑动方向与内部滑动方向一致；
• 场景3：上面两种情况的嵌套。

场景1解决办法：外部拦截法，当事件传递到父View时，父View需要处理此事件，就拦截，不处理此事件就不拦截。

场景2解决办法：内部拦截法，当事件传递到父View时，父View都传递给子View，如果子View需要处理此事件就消耗掉，否则就交给父View处理。但是这种方法和Android事件分发不一致，需要配合 requestDisallowInterceptTouchEvent 方法才能正常工作。

---

View的事件分发机制无法解决的滑动冲突场景

下面是一种常见的滑动场景：

在下滑动的时候，首先RecyclerView的父级View开始接收View触摸事件，事件不被拦截，全部交给RecyclerView接收和处理滑动View事件，当滑动到一定位置后，事件被拦截，全部交给RecyclerView的父级View接收和处理滑动View事件。

在上滑动的时候，首先RecyclerView的父级View接收和处理滑动View事件，事件被拦截，当滑动到一定位置后，全部交给RecyclerView接收和处理滑动View事件，事件不被拦截。

上面这种滑动效果，利用View的事件分发机制原理是无法解决问题的。

因为：某个View一旦决定拦截，那么这一个事件序列都只能由它来处理，并且它的onInterceptTouchEvent不会再被调用。

所以：在RecyclerView的父级View接收和处理滑动View事件，事件被拦截后，只能交给RecyclerView的父级View，不能再交给RecyclerView。

解决这种滑动冲突，可以用NestedScrollingParent 和 NestedScrollingChild 来解决。

---

NestedScrollingParent 和 NestedScrollingChild 解决滑动冲突

NestedScrollingParent 和 NestedScrollingChild 接口

NestedScrollingParent 和 NestedScrollingChild 都是接口，NestedScrollingParent 接口用于外部View实现， NestedScrollingChild 用于内部View实现。

NestedScrollingParent 和 NestedScrollingChild 解决滑动冲突的机制：实现了NestedScrollingChild接口的内部View在滑动的时候，首先将滑动距离dx和dy交给实现了NestedScrollingParent接口的外部View（可以不是直接父View），外部View可对其进行部分消耗，剩余的部分还给内部View。

NestedScrollingParent接口

public interface NestedScrollingParent {

    //准备开始滑动。参数nestedScrollAxes为getNestedScrollAxes方法返回的值。返回值表示是否接收内部View（可以是非直接子View）滑动时的参数。
    boolean onStartNestedScroll(View child, View target, int nestedScrollAxes);

    //接收内部View（可以是非直接子View）滑动
    void onNestedScrollAccepted(View child, View target, int nestedScrollAxes);

   //停止接收内部View（可以是非直接子View）滑动
    void onStopNestedScroll(View target);
    
    //内部View滑动时调用
    void onNestedScroll(View target, int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed);

   //内部View开始滑动之前调用。参数dx和dy表示滑动的横向和纵向距离，consumed参数表示消耗的横向和纵向距离，如纵向滑动，需要消耗了dy/2，表示外部View和内部View分别处理这次滑动距离的 1/2
    void onNestedPreScroll(View target, int dx, int dy, int[] consumed);

    //内部View开始Fling时调用
    boolean onNestedFling(View target, float velocityX, float velocityY, boolean consumed);

   //内部View开始Fling之前调用。参数velocityX 和velocityY 表示水平方向和垂直方向的速度。返回值表示是否处理了这次Fling操作，返回true表示拦截掉这次操作，false表示不拦截。
    boolean onNestedPreFling(View target, float velocityX, float velocityY);

    //是纵向滑动还是横向滑动
    int getNestedScrollAxes();
}

NestedScrollingChild 接口：

public interface NestedScrollingChild {

    //开始滑动的时候会调用这个方法。参数axes 代表是横向滑动还是纵向滑动。返回值表示是否找到支持嵌套滑动的外部View（可以是非直接父View）。
    void setNestedScrollingEnabled(boolean enabled);
    
    boolean isNestedScrollingEnabled();

    //准备开始滑动
    boolean startNestedScroll(int axes);
    
    //停止滑动
    void stopNestedScroll();

   //是否有嵌套滑动的外部View
    boolean hasNestedScrollingParent();
   
    //在内部View滑动的时候，通知外部View。
    boolean dispatchNestedScroll(int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed, int[] offsetInWindow);
    
    //在内部View滑动之前，先让外部View处理这次滑动。参数dx 和 dy表示这次滑动的横向和纵向距离，参数consumed表示外部View消耗这次滑动的横向和纵向距离。返回值表示外部View是否有消耗这次滑动。
    boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow);
   
   //在内部View Fling操作的时候，通知外部View。
    boolean dispatchNestedFling(float velocityX, float velocityY, boolean consumed);
    
   //与dispatchNestedPreScroll 方法相似，在内部View Fling操作之前，先让外部View处理这次Fling操作。参数velocityX 和velocityY 表示水平方向和垂直方向的速度。表示外部View是否有消耗这次Fling。
    boolean dispatchNestedPreFling(float velocityX, float velocityY);

NestedScrollingParent 和 NestedScrollingChild 接口方法的对应关系：

NestedScrollingChild	NestedScrollingParent	关系描述	内部View中的调用时机
startNestedScroll	onStartNestedScroll、onNestedScrollAccepted	内部View通知外部View准备开始滑动	ACTION_DOWN事件
dispatchNestedPreScroll	onNestedPreScroll	内部View在滑动之前通知外部View是否要处理这次滑动的横向和纵向距离，外部View处理之后，剩下的才交给内部View处理。	ACTION_MOVE事件
dispatchNestedScroll	onNestedScroll	内部View在滑动的时候，通知外部View是否也要跟随处理这次滑动。各自处各自的。	ACTION_MOVE事件后已经开始scroll
dispatchNestedPreFling	onNestedPreFling	内部View在Fling操作之前通知外部View是否要处理这次Fling操作，如果外部View处理了则内部View不再处理，如果外部View没有处理则内部View处理。	fling时
dispatchNestedFling	onNestedFling	内部View在Fling操作时通知外部View是否要处理这次Fling操作，如果外部View处理了则内部View不再处理，如果外部View没有处理则内部View处理。	fling时
stopNestedScroll	onStopNestedScroll	内部View通知外部View停止滑动	ACTION_UP事件

NestedScrollingChildHelper 和 NestedScrollingParentHelper 类

NestedScrollingChildHelper 和 NestedScrollingParentHelper 类的作用：主要是帮助内部View和外部View实现交互逻辑。

关于NestedScrollingChildHelper 和 NestedScrollingParentHelper 类是如何帮助内部View和外部View实现交互逻辑的，这里以RecyclerView为例子，介绍 startNestedScroll方法 的交互逻辑。

RecyclerView实现了NestedScrollingChild接口，首先看它的onTouchEvent方法：

public boolean onTouchEvent(MotionEvent e) {
......

   //ACTION_DOWN
   case 0:
                    this.mScrollPointerId = e.getPointerId(0);
                    this.mInitialTouchX = this.mLastTouchX = (int)(e.getX() + 0.5F);
                    this.mInitialTouchY = this.mLastTouchY = (int)(e.getY() + 0.5F);
                    nestedScrollAxis = 0;
                    if (canScrollHorizontally) {
                        nestedScrollAxis |= 1;
                    }

                    if (canScrollVertically) {
                        nestedScrollAxis |= 2;
                    }

                    this.startNestedScroll(nestedScrollAxis, 0);
                    break;

......
}

在ACTION_DOWN事件中，调用startNestedScroll方法，第一个参数为横向还是纵向，第二个参数为类型：

1. TYPE_TOUCH：值为0，用户触摸操作类型
2. TYPE_NON_TOUCH：值为1，非用户触摸操作类型，而且主要用于代码中的惯性操作，比如View滑动时的惯性滑动.

RecyclerView中实现的startNestedScroll方法：

    public boolean startNestedScroll(int axes) {
        return this.getScrollingChildHelper().startNestedScroll(axes);
    }

    public boolean startNestedScroll(int axes, int type) {
        return this.getScrollingChildHelper().startNestedScroll(axes, type);
    }
    
    private NestedScrollingChildHelper getScrollingChildHelper() {
        if (this.mScrollingChildHelper == null) {
            this.mScrollingChildHelper = new NestedScrollingChildHelper(this);
        }

        return this.mScrollingChildHelper;
    }

这个方法主要是委托给NestedScrollingChildHelper 类的startNestedScroll方法处理。

NestedScrollingChildHelper中的startNestedScroll方法：

    public boolean startNestedScroll(int axes) {
        return this.startNestedScroll(axes, 0);
    }

    public boolean startNestedScroll(int axes, int type) {
        if (this.hasNestedScrollingParent(type)) {
            return true;
        } else {
            if (this.isNestedScrollingEnabled()) {
                ViewParent p = this.mView.getParent();

                for(View child = this.mView; p != null; p = p.getParent()) {
                    if (ViewParentCompat.onStartNestedScroll(p, child, this.mView, axes, type)) {
                        this.setNestedScrollingParentForType(type, p);
                        ViewParentCompat.onNestedScrollAccepted(p, child, this.mView, axes, type);
                        return true;
                    }

                    if (p instanceof View) {
                        child = (View)p;
                    }
                }
            }

            return false;
        }
    }

isNestedScrollingEnabled方法判断是否允许嵌套滑动，如果是则找实现了NestedScrollingParent接口的外部View，如果外部View的onStartNestedScroll方法返回true，也就是外部View准备接收内部View的滑动，然后再接着调用外部View的onNestedScrollAccepted方法，确认接收内部View的滑动。

ViewParentCompat中的onStartNestedScroll 和 onNestedScrollAccepted方法：

    public static boolean onStartNestedScroll(ViewParent parent, View child, View target, int nestedScrollAxes, int type) {
        if (parent instanceof NestedScrollingParent2) {
            return ((NestedScrollingParent2)parent).onStartNestedScroll(child, target, nestedScrollAxes, type);
        } else {
            if (type == 0) {
                if (VERSION.SDK_INT >= 21) {
                    try {
                        return parent.onStartNestedScroll(child, target, nestedScrollAxes);
                    } catch (AbstractMethodError var6) {
                        Log.e("ViewParentCompat", "ViewParent " + parent + " does not implement interface " + "method onStartNestedScroll", var6);
                    }
                } else if (parent instanceof NestedScrollingParent) {
                    return ((NestedScrollingParent)parent).onStartNestedScroll(child, target, nestedScrollAxes);
                }
            }

            return false;
        }
    }

    public static void onNestedScrollAccepted(ViewParent parent, View child, View target, int nestedScrollAxes, int type) {
        if (parent instanceof NestedScrollingParent2) {
            ((NestedScrollingParent2)parent).onNestedScrollAccepted(child, target, nestedScrollAxes, type);
        } else if (type == 0) {
            if (VERSION.SDK_INT >= 21) {
                try {
                    parent.onNestedScrollAccepted(child, target, nestedScrollAxes);
                } catch (AbstractMethodError var6) {
                    Log.e("ViewParentCompat", "ViewParent " + parent + " does not implement interface " + "method onNestedScrollAccepted", var6);
                }
            } else if (parent instanceof NestedScrollingParent) {
                ((NestedScrollingParent)parent).onNestedScrollAccepted(child, target, nestedScrollAxes);
            }
        }

    }

方法里面做了版本兼容，主要是调用外部View的onStartNestedScroll 和 onNestedScrollAccepted方法。

这就是一次完整的从内部View 的 startNestedScroll方法到外部View的onStartNestedScroll 和 onNestedScrollAccepted 方法的交互过程。

其它方法类似，这里不再介绍，可以查看相关源码了解。

---

例子：微信运动排行榜页面的滑动效果

外部View实现NestedScrollingParent接口：

public class NestedScrollingLayout extends FrameLayout implements NestedScrollingParent {

    private static final String TAG = "StickyNavLayout";

    /**
     * 是否是往下拉
     */
    private boolean mShowTop = false;
    /**
     * 是否是往上滑
     */
    private boolean mHideTop = false;

    /**
     * 外部View滑动的最大距离
     */
    private int mTopViewHeight;

    @Override
    public boolean onStartNestedScroll(@NonNull View child, @NonNull View target, int nestedScrollAxes) {
        return (nestedScrollAxes & ViewCompat.SCROLL_AXIS_VERTICAL) != 0;
    }

    @Override
    public void onNestedScrollAccepted(@NonNull View child, @NonNull View target, int nestedScrollAxes) {
    }

    @Override
    public void onStopNestedScroll(@NonNull View target) {
    }

    @Override
    public void onNestedScroll(@NonNull View target, int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed) {
    }

    /**
     * dx和dy参数表示滑动的横向和纵向距离，consumed参数表示消耗的横向和纵向距离，如纵向滚动，只需要消耗了dy/2，表示父View和内部View分别处理这次滚动距离的 1/2
     *
     * @param target   内部View
     * @param dx       滑动的横向距离
     * @param dy       滑动的纵向距离
     * @param consumed 外部View消耗的横向和纵向距离
     */
    @Override
    public void onNestedPreScroll(@NonNull View target, int dx, int dy, @NonNull int[] consumed) {
        mShowTop = dy < 0 && Math.abs(getScrollY()) < mTopViewHeight && !target.canScrollVertically(-1);//往下拉
        if (mShowTop) {
            if (Math.abs(getScrollY() + dy) > mTopViewHeight) {//如果超过了指定位置
                dy = -(mTopViewHeight - Math.abs(getScrollY()));//滑动到指定位置
            }
        }
        mHideTop = dy > 0 && getScrollY() < 0;//往上滑
        if (mHideTop) {
            if (dy + getScrollY() > 0) {//如果超过了初始位置
                dy = -getScrollY();//滑动到初始位置
            }
        }
        if (mShowTop || mHideTop) {
            consumed[1] = dy;//消耗纵向距离
            scrollBy(0, dy);//外部View滚动
        }
    }


    @Override
    public boolean onNestedFling(@NonNull View target, float velocityX, float velocityY, boolean consumed) {
        return getScrollY() != 0;
    }

    @Override
    public boolean onNestedPreFling(@NonNull View target, float velocityX, float velocityY) {
        return getScrollY() != 0;
    }

    @Override
    public int getNestedScrollAxes() {
        return ViewCompat.SCROLL_AXIS_VERTICAL;
    }


    public NestedScrollingLayout(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public NestedScrollingLayout(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    @Override
    protected void onFinishInflate() {
        super.onFinishInflate();
        mTopViewHeight = getResources().getDimensionPixelSize(R.dimen.size_256dp);
    }
}

内部RecyclerView实现了NestedScrollingChild 接口。

布局文件：

最终实现的滑动效果：