什么是嵌套滚动？(如下图):
嵌套滚动(知乎效果).gif
- 一般情况下,如果我们界面有多个布局: 包括可滚动布局(ScrollView、ListView、RecyclerView等)和不可滚动布局(普通的View). 当我们滚动该滚动布局时,该布局内会做相应的滚动,其他的不可滚动布局并不会有相关的变动。这是因为：滚动View在处理Touch事件时，拦截了该Touch事件进行处理，那么布局内后续的Touch事件都不会交给其他布局（父布局/同级View），会一直下发到这个滚动View。
- 但是,我们从
嵌套滚动可以看出: 当滚动ListView时,Toolbar、Bottombar、FloatingActionBar会先隐藏后，再执行ListView的滚动（或者是ListView滚动过程中隐藏其他不可滚动View）。显然这是因为： 滚动View布局内发生Touch事件时，滚动View先不处理这个Touch事件，先把它交给本身的父布局，父布局再把这个Touch事件交给与滚动View同级的非滚动View去处理（隐藏/改变颜色等等），等到其他View处理完成后，父布局不再需要滚动View内的Touch事件时，滚动View就自己去处理剩下的Touch事件。
如何实现嵌套滚动
实现嵌套滚动机制主要依赖四个类：
1. NestedScrollingChild //滚动列表需要实现NestedScrollingChild接口，以支持将滚动事件分发给父ViewGroup
2. NestedScrollingParent //相应的，父ViewGroup需要实现NestedScrollingParent接口，以支持将滚动事件进一步的分发给各个子View
3. NestedScrollingChildHelper //进行嵌套滚动的辅助类
4. NestedScrollingParentHelper //进行嵌套滚动的辅助类
一般实现NestedScrollingChild接口的滚动列表会把滚动事件委托给NestedScrollingChildHelper辅助类来处理。例如：RecyclerView实现了NestedScrollingChild接口，它内部就会把滚动相关事件委托给NestedScrollingChildHelper对象来处理，如下所示：
@Override
public boolean startNestedScroll(int axes) {
return getScrollingChildHelper().startNestedScroll(axes);
}
@Override
public void stopNestedScroll() {
getScrollingChildHelper().stopNestedScroll();
}
@Override
public boolean dispatchNestedScroll(int dxConsumed, int dyConsumed, int dxUnconsumed,int dyUnconsumed, int[] offsetInWindow) {
return getScrollingChildHelper().dispatchNestedScroll(dxConsumed, dyConsumed,dxUnconsumed, dyUnconsumed, offsetInWindow);
}
@Override
public boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow) {
return getScrollingChildHelper().dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow);
}
//NestedScrollingChild的方法有很多，更多的可参见源码
//...
当我们滚动RecyclerView时，RecyclerView首先会通过startNestedScroll方法通知父ViewGroup（“我马上要滚动了，是否有兄弟节点要一起滚动？”），父ViewGroup会进一步把滚动事件分发给所有子View（实际是分发给和子View绑定的Behavior），感兴趣的子View会特别关注，即Behavior.onStartNestedScroll方法返回true。
1. RecyclerView会在Down事件时调用startNestedScroll方法
我们看下NestedScrollingChildHelper.startNestedScroll方法的实现：
public boolean startNestedScroll(int axes) {
if (hasNestedScrollingParent()) {
// Already in progress
return true;
}
if (isNestedScrollingEnabled()) {
ViewParent p = mView.getParent();
View child = mView;
//该循环主要是寻找到能够协调处理滚动事件的父View，即实现NestedScrollingParent接口的父ViewGroup
while (p != null) {
if (ViewParentCompat.onStartNestedScroll(p, child, mView, axes)) {
//记录协调处理滚动事件的父View
mNestedScrollingParent = p;
//ViewParentCompat是一个和父ViewGroup交互的兼容类，如果在Android5.0以上，就用View自带的方法，否则若实现了NestedScrollingParent接口，则调用接口方法。
ViewParentCompat.onNestedScrollAccepted(p, child, mView, axes);
return true;
}
if (p instanceof View) {
child = (View) p;
}
p = p.getParent();
}
}
return false;
}
上述方法会找到能够协调处理滚动事件的父ViewGroup，然后调用它的onStartNestedScroll方法
2. 调用父ViewGroup的onStartNestedScroll方法
因为CoordinatorLayout实现了NestedScrollingParent接口，所以我们看下CoordinatorLayout.onStartNestedScroll方法：
public boolean onStartNestedScroll(View child, View target, int nestedScrollAxes) {
boolean handled = false;
final int childCount = getChildCount();
//询问每一个子View是否对滚动列表的滚动事件感兴趣？
for (int i = 0; i < childCount; i++) {
final View view = getChildAt(i);
final LayoutParams lp = (LayoutParams) view.getLayoutParams();
//获取和子View绑定的Behavior
final Behavior viewBehavior = lp.getBehavior();
if (viewBehavior != null) {
final boolean accepted = viewBehavior.onStartNestedScroll(this, view, child, target,nestedScrollAxes);
handled |= accepted;
//做一下标注，作为判断后续是否接收滚动事件的标记
lp.acceptNestedScroll(accepted);
} else {
lp.acceptNestedScroll(false);
}
}
return handled;
}
上述方法会遍历每一个子View，询问它们是否对滚动列表的滚动事件感兴趣，若Behavior.onStartNestedScroll方法返回true，则表示感兴趣，那么滚动列表后续的滚动事件都会分发到该子View的Behavior。
因此，我们可以在自定义的Behavior.onStartNestedScroll方法中根据实际情况决定是否对滚动事件感兴趣。
假设CoordinatorLayout的某个子View对RecyclerView的滚动事件感兴趣(Behavior.onStartNestedScroll方法返回true)
-> CoordinatorLayout.onStartNestedScroll返回true
-> RecyclerView.startNestedScroll返回true
-> RecyclerView就会把用户的滚动事件源源不断的分发给之前找到的父ViewGroup
-> 父ViewGroup则进一步分发给感兴趣的子View
-> 感兴趣的子View处理完滚动事件后，若用户的滚动距离没有被消费完
-> RecyclerView才有机会处理滚动事件(例如：用户一次性滚动了10px，其中某个View消费了8px，那么RecyclerView就只能滚动2px了)
3.RecyclerView会在Move事件时进行事件分发（先交给父布局，再自己处理）
@Override
public boolean onTouchEvent(MotionEvent e) {
final int action = e.getActionMasked();
...
switch (action) {
//other case...
case MotionEvent.ACTION_MOVE: {
//1.先算出滚动距离...
//2.事件分发给父ViewGroup处理
// dispatchNestedPreScroll返回true，说明 父ViewGroup消耗了一定距离，消耗掉的距离存储在mScrollConsumed，滚动的距离要减去父ViewGroup消耗的距离
if (dispatchNestedPreScroll(dx, dy, mScrollConsumed, mScrollOffset, TYPE_TOUCH)) {
dx -= mScrollConsumed[0];
dy -= mScrollConsumed[1];
vtev.offsetLocation(mScrollOffset[0], mScrollOffset[1]);
// Updated the nested offsets
mNestedOffsets[0] += mScrollOffset[0];
mNestedOffsets[1] += mScrollOffset[1];
}
//3.计算出本身处理的距离...
//4.RecyclerView本身处理这些滚动事件（scrollByInternal）
if (mScrollState == SCROLL_STATE_DRAGGING) {
mLastTouchX = x - mScrollOffset[0];
mLastTouchY = y - mScrollOffset[1];
if (scrollByInternal(
canScrollHorizontally ? dx : 0,
canScrollVertically ? dy : 0,
vtev)) {
getParent().requestDisallowInterceptTouchEvent(true);
}
if (mGapWorker != null && (dx != 0 || dy != 0)) {
mGapWorker.postFromTraversal(this, dx, dy);
}
}
}break;
//other case...
}
}
3.1 调用RecyclerView的dispatchNestedPreScroll把事件分发给父ViewGroup处理：ViewParentCompat.onNestedPreScroll(mNestedScrollingParent, mView, dx, dy, consumed)
@Override
public boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow) {
return getScrollingChildHelper().dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow);
}
//NestedScrollingChildHelper.dispatchNestedPreScroll方法的实现
public boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow) {
//判断之前是否找到协同处理的父ViewGroup
if (isNestedScrollingEnabled() && mNestedScrollingParent != null) {
//dx和dy分别表示X和Y轴上的滚动距离
if (dx != 0 || dy != 0) {
int startX = 0;
int startY = 0;
//offsetInWindow用于计算滚动前后，滚动列表本身的偏移量
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;
//分发给父ViewGroup
ViewParentCompat.onNestedPreScroll(mNestedScrollingParent, mView, dx, dy, consumed);
if (offsetInWindow != null) {
//计算出滚动列表本身的偏移量
mView.getLocationInWindow(offsetInWindow);
offsetInWindow[0] -= startX;
offsetInWindow[1] -= startY;
}
return consumed[0] != 0 || consumed[1] != 0;
} else if (offsetInWindow != null) {
offsetInWindow[0] = 0;
offsetInWindow[1] = 0;
}
}
return false;
}
方法的第3个参数是一个长度为2的一维数组，用于记录父ViewGroup（其实是父ViewGroup的子View）消费的滚动长度，若滚动距离没有用完，则滚动列表处理剩下的滚动距离；第4个参数也是一个长度为2的一维数组，用于记录滚动列表本身的偏移量，该参数用于修复用户Touch事件的坐标，以保证下一次滚动距离的正确性。
3.2 父ViewGroup就会把滚动事件分发给感兴趣的子View
//ViewParentCompat.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
IMPL.onNestedPreScroll(parent, target, dx, dy, consumed);
}
}
CoordinatorLayout实现了NestedScrollingParent接口，所以我们看下CoordinatorLayout.onNestedPreScroll方法：
public void onNestedPreScroll(View target, int dx, int dy, int[] consumed) {
int xConsumed = 0;
int yConsumed = 0;
boolean accepted = false;
final int childCount = getChildCount();
for (int i = 0; i < childCount; i++) {
final View view = getChildAt(i);
final LayoutParams lp = (LayoutParams)view.getLayoutParams();
//若子View对滚动事件不感兴趣，则直接跳过
if (!lp.isNestedScrollAccepted()) {
continue;
}
final Behavior viewBehavior = lp.getBehavior();
if (viewBehavior != null) {
mTempIntPair[0] = mTempIntPair[1] = 0;
//分发给每个子View的Behavior处理
viewBehavior.onNestedPreScroll(this, view,target, dx, dy, mTempIntPair);
//找出每个子View消费的最大滚动距离就是父ViewGroup消费的滚动距离
xConsumed = dx > 0 ? Math.max(xConsumed, mTempIntPair[0]): Math.min(xConsumed, mTempIntPair[0]);
yConsumed = dy > 0 ? Math.max(yConsumed, mTempIntPair[1]): Math.min(yConsumed, mTempIntPair[1]);
accepted = true;
}
}
//记录父ViewGroup消费的滚动距离
consumed[0] = xConsumed;
consumed[1] = yConsumed;
if (accepted) {
//处理子View之间的依赖关系
dispatchOnDependentViewChanged(true);
}
}
CoordinatorLayout的处理很简单，把滚动事件分发给各个子View的Behavior.onNestedPreScroll方法处理，并计算出最终消费的滚动距离。
因此，我们可以在RecyclerView滚动之前，重写
Behavior.onNestedPreScroll方法中处理CoordinatorLayout的子View的滚动事件，然后根据实际情况填写消费的滚动距离。
3.3 RecyclerView调用scrollByInternal事件分发给自己处理
假设RecyclerView的滚动距离没有被CoordinatorLayout消费完，那么接下来RecyclerView应该处理这些滚动事件了。在RecyclerView的onTouchEvent方法中会调用scrollByInternal处理内容滚动，关键代码如下所示：
//x表示X轴上剩余的滚动距离
if (x != 0) {
//交给具体的LayoutManager处理滚动事件，并且记录下消费的和剩余的滚动量
consumedX = mLayout.scrollHorizontallyBy(x, mRecycler,mState);
unconsumedX = x - consumedX;
}
//y表示Y轴上剩余的滚动距离
if (y != 0) {
//交给具体的LayoutManager处理滚动事件，并且记录下消费的和剩余的滚动量
consumedY = mLayout.scrollVerticallyBy(y, mRecycler, mState);
unconsumedY = y - consumedY;
}
//...
//分发滚动列表本身对剩余滚动量的消费情况
dispatchNestedScroll(consumedX, consumedY, unconsumedX, unconsumedY, mScrollOffset);
如上所示，RecyclerView通过LayoutManager处理了剩余的滚动距离，如果onNestedPreScroll之后的剩余滚动量没有被RecyclerView消耗完，又可以分发给父ViewGroup，父ViewGroup再分发给感兴趣的子View的Behavior处理。这部分的代码逻辑和onNestedPreScroll类似，就不贴出了，感兴趣的可以直接看源码。
因此，我们可以在RecyclerView滚动时或滚动后，重写
Behavior.onNestedScroll方法处理CoordinatorLayout的子View的滚动事件，去消耗RecyclerView的滚动量
4. RecyclerView会在UP事件时stopNestedScroll
假设用户结束滚动操作了，即应该结束一系列的滚动事件了，RecyclerView会在UP事件中调用stopNestedScroll方法，该方法和上面介绍的三个方法类似，都会先把事件分发给父ViewGroup，然后父ViewGroup再把事件分到各个子View，最终触发子View的Behavior.onStopNestedScroll方法，感兴趣可以可接看源码，此处不再贴出。
因此，我们可以在自定义的Behavior.onStopNestedScroll方法中检测到滚动事件的结束。
总结：
整个嵌套滚动机制就介绍完了，可见跟我们直接打交道的就是
CoordinatorLayout.Behavior类了，通过重写该类中的方法，我们不仅可以监听滚动列表的滚动事件，还可以做很多其他的事情。
下一篇会重点介绍：CoordinatorLayout.Behavior
网友评论