<TextView

android:layout_width=“match_parent”

android:layout_height=“64dp”

android:layout_gravity=“bottom”

android:text=“Top”

android:textSize=“32sp”

android:textColor="@color/white"

android:gravity=“center”

android:textStyle=“bold”/>

</com.google.android.material.appbar.AppBarLayout>

<androidx.recyclerview.widget.RecyclerView

android:id="@+id/rv"

android:layout_width=“match_parent”

android:layout_height=“wrap_content”

app:layout_behavior="@string/appbar_scrolling_view_behavior"/>

</androidx.coordinatorlayout.widget.CoordinatorLayout>

将 AppBarLayout 中需要上滑隐藏的部分的 scrollFlag 指定为 scroll ，在RecyclerView 中指定 behavior 为 appbar_scrolling_view_behavior 就可以实现最简单的吸顶嵌套滑动，如下：

看起来像带有 header 的 RecyclerView 在滑动，但其实是嵌套滑动。

layout_scrollFlags 和 layout_behavior 有很多可选值，配合起来可以实现多种效果，不只限于嵌套滑动。具体可以参考 API 文档。

使用 CoordinatorLayout 实现嵌套滑动比手动实现要好得多，既可以实现连贯的吸顶嵌套滑动，又支持 fling。而且是官方提供的布局，可以放心使用，出 bug 的几率很小，性能也不会有问题。不过也正是因为官方将其封装得很好，使用 CoordinatorLayout 很难实现比较复杂的嵌套滑动布局，比如多级嵌套滑动。

3、嵌套滑动组件 NestedScrollingParent 和 NestedScrollingChild

NestedScrollingParent 和 NestedScrollingChild 是 google 官方提供地一套专门用来解决嵌套滑动地组件。它们是两个接口，代码如下：

public interface NestedScrollingParent2 extends NestedScrollingParent {

boolean onStartNestedScroll(@NonNull View child, @NonNull View target, @ScrollAxis int axes,

@NestedScrollType int type);

void onNestedScrollAccepted(@NonNull View child, @NonNull View target, @ScrollAxis int axes,

@NestedScrollType int type);

void onStopNestedScroll(@NonNull View target, @NestedScrollType int type);

void onNestedScroll(@NonNull View target, int dxConsumed, int dyConsumed,

int dxUnconsumed, int dyUnconsumed, @NestedScrollType int type);

void onNestedPreScroll(@NonNull View target, int dx, int dy, @NonNull int[] consumed,

@NestedScrollType int type);

}

public interface NestedScrollingChild2 extends NestedScrollingChild {

boolean startNestedScroll(@ScrollAxis int axes, @NestedScrollType int type);

void stopNestedScroll(@NestedScrollType int type);

boolean hasNestedScrollingParent(@NestedScrollType int type);

boolean dispatchNestedScroll(int dxConsumed, int dyConsumed,

int dxUnconsumed, int dyUnconsumed, @Nullable int[] offsetInWindow,

@NestedScrollType int type);

boolean dispatchNestedPreScroll(int dx, int dy, @Nullable int[] consumed,

@Nullable int[] offsetInWindow, @NestedScrollType int type);

}

需要嵌套滑动的 View 可以实现这两个接口，复写其中的方法。这套组件实现嵌套滑动的核心原理很简单，主要是以下三步：

• NestedScrollingChild 在 onTouchEvent 方法中先将 ACITON_MOVE 事件产生的位移 dx 和 dy 通过 dispatchNestedPreScroll 传递给 NestedScrollingParent

• NestedScrollingParent 在 onNestedPreScroll 中接受到 dx 和 dy 并进行消费。并将消费掉的位移放入 int[] consumed 中，consumed 数组是一个长度为 2 的 int 类型数组，consumed[0] 代表 x 轴的消耗，consumed[1] 代表 y 轴的消耗

• NestedScrollingChild 之后从 int[] consumed 数组中拿到 NestedScrollingParent 已经消费掉的位移，减去之后得到剩余的位移，再由自己消费

滑动位移传递方向由 child -> parent -> child，如下图。如果 child 是 Recyclerview ，它会先把位移给父布局消费，这时父布局滑动。当父布局滑动顶到不能滑动时，Recyclerview 这时会消费全部位移，这时它自己开始滑动，这样就形成了嵌套滑动，效果正如之前的例子中所看到的。

dispatchNestedScroll 和 onNestedScroll 的作用原理上述 preScroll 的方法类似，只不过这两个方法构造的嵌套滑动顺序和 preScroll 的相反，是子 View 先消费，子 View 消费不了的时候，再由父 View 再消费。

这套机制还支持 fling，在手指离开 view 的时候，即产生 ACITON_UP 事件时，child 将此时的 Velocity 转化为位移 dx 或 dy，并重复之前的流程。通过 @NestedScrollType int type 的值来判断是 TYPE_TOUCH 还是 TYPE_NON_TOUCH， TYPE_TOUCH 就是滑动， TYPE_NON_TOUCH 就是 fling。

Android 中哪些 View 使用了这套滑动机制？

• 实现 NestedScrollingParent 接口的 View 有：NestedScrollView、CoordinatorLayout、MotionLayout 等

• 实现 NestedScrollingChild 接口的 View 有：NestedScrollView、RecyclerView 等

• NestedScrollView 是唯一同时实现两个接口的 View，这意味着它可以用作中介来实现多级嵌套滑动，后面会说到。

从上面可以看到，实际上，之前提到的 CoordinatorLayout 实现的嵌套滑动，本质上也是通过这套 NestedScrolling 接口来实现的。但是由于它封装得太好，我们没办法做过多定制。而直接使用这套接口，就可以根据自己的需求做定制。

大部分的场景中，我们不需要去实现 NestedScrollingChild 接口，因为 RecyclerView 已经做了这个实现，而涉及到嵌套滑动场景的子 View 基本也都是 RecyclerView。我们看看 RecyclerView 的相关源码：

public boolean onTouchEvent(MotionEvent e) {

…

case MotionEvent.ACTION_MOVE: {

…

// 计算 dx，dy

int dx = mLastTouchX - x;

int dy = mLastTouchY - y;

…

mReusableIntPair[0] = 0;

mReusableIntPair[1] = 0;

…

// 分发 preScroll

if (dispatchNestedPreScroll(

canScrollHorizontally ? dx : 0,

canScrollVertically ? dy : 0,

mReusableIntPair, mScrollOffset, TYPE_TOUCH

)) {

// 减去父 view 消费掉的位移

dx -= mReusableIntPair[0];

dy -= mReusableIntPair[1];

mNestedOffsets[0] += mScrollOffset[0];

mNestedOffsets[1] += mScrollOffset[1];

getParent().requestDisallowInterceptTouchEvent(true);

}

…

} break;

…

}

boolean scrollByInternal(int x, int y, MotionEvent ev) {

int unconsumedX = 0;

int unconsumedY = 0;

int consumedX = 0;

int consumedY = 0;

if (mAdapter != null) {

mReusableIntPair[0] = 0;

mReusableIntPair[1] = 0;

// 先消耗掉自己的 scroll

scrollStep(x, y, mReusableIntPair);

consumedX = mReusableIntPair[0];

consumedY = mReusableIntPair[1];

// 计算剩余的量

unconsumedX = x - consumedX;

unconsumedY = y - consumedY;

}

mReusableIntPair[0] = 0;

mReusableIntPair[1] = 0;

// 分发 nestedScroll 给父 View，顺序和 preScroll 刚好相反

dispatchNestedScroll(consumedX, consumedY, unconsumedX, unconsumedY, mScrollOffset,

TYPE_TOUCH, mReusableIntPair);

unconsumedX -= mReusableIntPair[0];

unconsumedY -= mReusableIntPair[1];

…

}

RecyclerView 是怎么调到父 View 的 onNestedPreSroll 和 onNestedScroll 的呢？分析一下 dispatchNestedPreScroll 的代码，如下，dispatchNestedScroll 的代码原理和此类似，不再贴出：

public boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow,

int type) {

return getScrollingChildHelper().dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow,type);

}

// NestedScrollingChildHelper.java

public boolean dispatchNestedPreScroll(int dx, int dy, @Nullable int[] consumed,

@Nullable int[] offsetInWindow, @NestedScrollType int type) {

if (isNestedScrollingEnabled()) {

final ViewParent parent = getNestedScrollingParentForType(type);

if (parent == null) {

return false;

}

if (dx != 0 || dy != 0) {

…

consumed[0] = 0;

consumed[1] = 0;

ViewParentCompat.onNestedPreScroll(parent, mView, dx, dy, consumed, type);

…

}

…

}

return false;

}

// ViewCompat.java

public static void onNestedPreScroll(ViewParent parent, View target, int dx, int dy,

int[] consumed, int type) {

if (parent instanceof NestedScrollingParent2) {

// First try the NestedScrollingParent2 API

((NestedScrollingParent2) parent).onNestedPreScroll(target, dx, dy, consumed, type);

} else if (type == ViewCompat.TYPE_TOUCH) {

// Else if the type is the default (touch), try the NestedScrollingParent API

if (Build.VERSION.SDK_INT >= 21) {

try {

parent.onNestedPreScroll(target, dx, dy, consumed);

} catch (AbstractMethodError e) {

Log.e(TAG, "ViewParent " + parent + " does not implement interface "

• “method onNestedPreScroll”, e);

}

} else if (parent instanceof NestedScrollingParent) {

((NestedScrollingParent) parent).onNestedPreScroll(target, dx, dy, consumed);

}

}

}

可以看到，RecyclerView 通过一个代理类 NestedScrollingChildHelper 完成滑动分发，最后交给 ViewCompat 的静态方法来让父 View 处理 onNestedPreScroll。ViewCompat 的主要作用是用来兼容不同版本的滑动接口。

实现 onNestedPreScroll 方法

从上面的代码可以清楚地看到 RecyclerView 对于 NestedScrollingChild 的实现，以及触发嵌套滑动的时机。如果我们要实现嵌套滑动，并且内部的滑动子 View 是 RecyclerView，那么只需要让外层的父 View 实现 NestedScrollingParent 的方法就行了，比如在 onNestedPreScroll 方法中，

@Override

public void onNestedPreScroll(@NonNull View target, int dx, int dy, @NonNull int[] consumed, int type) {

// 滑动 dy 距离

scrollBy(0, dy);

// 将消耗掉的 dy 放入 consumed 数组通知子 view

consumed[1] = dy;

}

这样就实现了最简单的嵌套滑动。当然，实际情况中，还要对滑动距离进行判断，不能让父 View 一直消费子 View 的位移。

关于 Nested

《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》

【docs.qq.com/doc/DSkNLaERkbnFoS0ZF】 完整内容开源分享

ScrollView

像 NestedScrollView 这样的类，由于它内部实现了 onNestedScroll，所以在下滑时，它能在内部的 RecyclerView 下滑直到列表顶端时，外层继续下滑而不用抬起手指。另外也实现了 onNestedPreScroll方法，只不过它在该方法中把滑动继续向上传递，自己没有消费，如下代码：

// NestedScrollView.java

public void onNestedPreScroll(@NonNull View target, int dx, int dy, @NonNull int[] consumed,

int type) {

// 只分发了 preScroll 自己并没有消费。之所以能分发是因为 NestedScrollView 同时实现了 NestedScrollingChild 接口

dispatchNestedPreScroll(dx, dy, consumed, null, type);

}

@Override

public boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow,

int type) {

return mChildHelper.dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow, type);

}

// NestedScrollingChildHelper.java

public boolean dispatchNestedPreScroll(int dx, int dy, @Nullable int[] consumed,

@Nullable int[] offsetInWindow, @NestedScrollType int type) {

if (isNestedScrollingEnabled()) {

final ViewParent parent = getNestedScrollingParentForType(type);

if (parent == null) {

return false;

}

if (dx != 0 || dy != 0) {

…

consumed[0] = 0;

consumed[1] = 0;

ViewParentCompat.onNestedPreScroll(parent, mView, dx, dy, consumed, type);

…

}

…

}

return false;

}

所以如果直接在 RecyclerView 的外层套 NestedScrollView 是没有办法实现完整的嵌套滑动的，你会发现在上滑的时候，没有嵌套滑动的效果，而下滑的时候有嵌套滑动的效果。

没有考虑到的问题

其实，在之前所说的内容中，默认了手指从子 Viw 开始滑动。假如手指从外层的父 View 开始滑动，当父 View fling 到顶后，子 View 是无法继续 fling，会立马停住，无法实现连贯的嵌套滑动。

这是因为嵌套滑动组件中，位移的消费只能从 NestedScrollingChild 到 NestedScrollingParent，而不能从 NestedScrollingParent 到 NestedScrollingChild ，因为只有 NestedScrollingChild 才能 dispatch，NestedScrollingParent 不能 dispatch。

如果想要实现从 NestedScrollingParent 到 NestedScrollingChild 连贯的滑动，暂时没有特别好的办法，只能重写父 View 的事件分发，将父 View 滑动到顶后剩余的位移手动分发给它的子 View。(先挖个坑，看看有没有更好的办法，可以通过扩展嵌套滑动组件达到目的）

Tips

NestedScrollingParent 和 NestedScrollingChild 一共有 3 个版本。

最早的是 NestedScrollingParent 和 NestedScrollingChild，这一套接口把 scroll 和 fling 分别进行处理，造成了不必要的复杂性。

后来有了 NestedScrollingParent2 和 NestedScrollingChild2 继承自一代，不过它将 fling 转化为 scroll 的距离统一进行处理。上述的嵌套滑动组件均指二代。

再后来又有了 NestedScrollingParent3 和 NestedScrollingChild 继承自二代，它们相比于 2 代增加了 dispatchNestedScroll 和 onNestedScroll 消耗部分滑动位移的功能，即在父 View 消耗位移之后，将消耗值放入 consumed 数组通知子 View。而二代是不会让子 View 知道父 View 的消耗值的。一般来说，要自己实现嵌套滑动，只需要实现 2 代及以上接口即可。一代基本不再使用。

注意：使用 NestedScrollView 有一个地方需要注意，当它的子 View 是 RecyclerView 这种 content 可以无限长的布局时，要注意限制这些子 View 的高度，不要使用 wrap_content 设置 RecyclerView 的高度。因为 NestedScrollView 在测量时给子 View 的限制是 UNSPECIFIED ，即不做限制，RecyclerView 想要多高就有多高。像 RecyclerView 如果内部 item 数量太多，RecyclerView 在 wrap_content 的情况下会把所有 item 都显示出来，相当于没有回收。这样会对内存造成很大消耗。如果调用 setVisibility 改变可见性的话，当从不可见到可见，更是会瞬间调用所有 item 的测量布局流程，造成卡顿。这是我在项目中实际遇到的问题。

三、多级嵌套滑动

我们知道了 NestedScrollingParent 和 NestedScrollingChild可以用来定制化地实现自己地嵌套滑动。很容易想到，如果一个 View 同时实现了两个接口，那么它既可以接受 child 的滑动，又可以分发滑动给 parent，这样就形成了一个链条。而多级嵌套滑动的核心原理就来自于此，如图：

原理其实并不复杂，下面用伪代码表示一下：

• 对于 NestedScrollingParent

@Override

public void onNestedPreScroll(@NonNull View target, int dx, int dy, @NonNull int[] consumed, int type) {

scrollByMe(dx, dy);

…

consumed[0] = dxConsumed;

consumed[1] = dyConsumed;

}

• 对于中介者，即同时实现了 NestedScrollingParent 和 NestedScrollingChild 的中间 View 来说

@Override

public void onNestedPreScroll(@NonNull View target, int dx, int dy, @NonNull int[] consumed, int type) {

// 先分发，再消费。当然也可以先以先消费，再分发，这取决于业务

dispatchNestedPreScroll(dispatchNestedPreScroll(dx, dy, consumed, null, type);

int dx -= consumed[0];

int dy -= consumed[1];