3.NestedScrollView简介
public class NestedScrollView
extends FrameLayout implements NestedScrollingParent3, NestedScrollingChild3, ScrollingView
NestedScrollView is just like ScrollView, but it supports acting as both a nested scrolling parent and child on both new and old versions of Android. Nested scrolling is enabled by default.
NestedScrollView即支持嵌套滑动的ScrollView，因此我们可以简单的把NestedScrollView类比为ScrollView，其作用就是作为控件父布局，从而具备(嵌套)滑动的功能。
它与ScrollView的区别就在于NestedScrollView支持嵌套滑动，无论是作为父控件还是子控件，嵌套滑动都支持，且默认开启。 因此，在一些需要支持嵌套滑动的情景中，比如一个ScrollView内部内部包裹一个RecyclerView，那么就会产生滑动冲突，这个问题就需要你自己去解决。而如果使用 NestedScrollView包裹RecyclerView，嵌套滑动天然支持，你无需做什么就可以实现前面想要实现的功能了。
我们通常为RecyclerView增加一个Header和Footer的方法是通过定义不同的viewType来区分的，而如果使用NestedScrollView，我们完全可以把RecyclerView当成一个单独的控件，然后在其上面增加一个控件作为Header，在其下面增加一个控件作为Footer。
虽然NestedScrollView内嵌RecyclerView和其他控件可以实现Header和Footer，但还是不推荐上面这种做法（建议还是直接使用RecyclerView自己添加Header和Footer），因为虽然NestedScrollView支持嵌套滑动，但是在实际应用中，嵌套滑动可能会带来其他的一些奇奇怪怪的副作用，Google也推荐我们能不使用嵌套滑动就尽量不要使用。
我们知道，在Android系统对于Touch事件有一套自己的分发机制，其中主要涉及到以下三个方法：
- dispatchTouchEvent()：主要是在View和ViewGroup中进行事件分发
- onInterceptTouchEvent()：进行Touch事件的拦截
- onTouchEvent()：Touch事件的处理
但是这里分发过程会有个问题，如果子View消费本次事件，父View就没法再对触摸事件进行处理，同理，如果父View将事件拦截了，本次触摸手势内就无法再讲事件分发给子View。这种情况如果如果想要处理父View和子View的嵌套滑动就比较困难了。因此，当有嵌套滑动场景时，我们都需要自己手动解决事件冲突。而在Android 5.0 Lollipop之后，Google官方通过嵌套滑动(NestedScrolling)机制解决了传统Android事件分发无法共享事件这个问题。
NestedScrolling机制
嵌套滑动机制的基本原理可以认为是事件共享，即当子控件(内部NestedScrollingChild)接收到滑动事件，准备要滑动时，会先通知父控件(startNestedScroll）；然后在滑动之前，会先询问父控件(NestedScrollingParent)是否要滑动（dispatchNestedPreScroll)；如果父控件响应该事件进行了滑动，那么就会通知子控件它具体消耗了多少滑动距离；然后交由子控件处理剩余的滑动距离；最后子控件滑动结束后，如果滑动距离还有剩余，就会再问一下父控件是否需要在继续滑动剩下的距离（dispatchNestedScroll)...
那么如果想让我们自定义的View或者ViewGroup实现嵌套滑动功能，应该怎样做呢？
其实，在Android 5.0之后，系统自带的View和ViewGroup都增加了嵌套滑动机制相关的方法了（但是默认不会被调用，因此默认不具备嵌套滑动功能），所以如果在Android 5.0及之后的平台上，自定义View只要覆写相应的嵌套滑动机制相关方法即可；但是为了提供低版本兼容性，Google 官方还提供了两个接口，分别作为嵌套滑动机制父控件接口和子控件接口:
- NestedScrollingParent：作为父控件，支持嵌套滑动功能。
- NestedScrollingChild：作为子控件，支持嵌套滑动功能。
前面我们说过NestedScrollView无论是作为父控件还是子控件都支持嵌套滑动，就是因为它同时实现了 NestedScrollingParent和NestedScrollingChild。
下面我们就先说下NestedScrollingParent和NestedScrollingChild这两个类。
嵌套滑动机制兼容处理
LOLLIPOP(SDK21)之后嵌套滑动的相关逻辑作为普通方法直接写进了最新的(SDK21之后)View和ViewGroup类.普通方法是指这个方法不是继承自接口或者其他类, 例如View#dispatchNestedScroll), 可以看到官方标注了Added in API level21标示,也就是说这是在SDK21版本之后添加进去的一个普通方法.
向前兼容而SDK21之前的版本
官方在android.support.v4兼容包中提供了两个接口NestedScrollingChild和NestedScrollingParent, 还有两个辅助类NestedScrollingChildHelper和NestedScrollingParentHelper来帮助控件实现嵌套滑动.这个兼容的原理很简单：两个接口NestedScrollingChild和NestedScrollingParent分别定义上面提到的View和ViewParent新增的普通方法。 在嵌套滑动中会要求控件要么是继承于SDK21之后的View或ViewGroup,要么实现了这两个接口,这是控件能够进行嵌套滑动的前提条件.那么怎么知道调用的方法是控件自有的方法, 还是接口的方法? 在代码中是通过ViewCompat和ViewParentCompat类来实现.ViewCompat和ViewParentCompat通过当前的Build.VERSION.SDK_INT来判断当前版本, 然后选择不同的实现类, 这样就可以根据版本选择调用的方法. 例如如果版本是SDK21之前, 那么就会判断控件是否实现了接口,然后调用接口的方法,如果是SDK21之后, 那么就可以直接调用对应的方法.
辅助类
除了接口兼容包还提供了NestedScrollingChildHelper和NestedScrollingParentHelper两个辅助类, 这两个辅助类实际上就是对应View和ViewParent中新增的普通方法, 代码就不贴了, 简单对比下就可以发现, 对应方法实现的逻辑基本一样, 所以只要在接口方法内对应调用辅助类的方法就可以兼容嵌套滑动了.
例如在NestedScrollingChild#startNestedScroll方法中调用NestedScrollingChildHelper#startNestedScroll，这里实际用了代理模式来让SDK21之前的控件具有了新增的方法。
默认处理逻辑
虽然View和ViewGroup(SDK21之后)本身就具有嵌套滑动的相关方法, 但是默认情况是是不会被调用, 因为View和ViewGroup本身不支持滑动。 NestedScrolling提供了一套父View和子View滑动交互机制。要完成这样的交互，父View需要实现 NestedScrollingParent接口，而子View需要实现NestedScrollingChild接口。
NestedScrollingChild
如果你有一个可以滑动的View，需要被用来作为嵌入滑动的子View，就必须实现本接口。在此View中，包含一个NestedScrollingChildHelper辅助类。
NestedScrollingChild接口的实现，基本上就是调用该Helper类的对应的方法，因为Helper类中已经实现好了Child和Parent交互的逻辑。原来的View处理的Touch事件，并实现滑动的逻辑大体上不需要改变。 需要做的就是，如果要准备开始滑动了，需要告诉Parent，你要准备进入滑动状态了，调用startNestedScroll()。你在滑动之前，先问一下Parent是否需要滑动，也就是调用dispatchNestedPreScroll()。如果父类滑动了一定距离，你需要重新计算一下父类滑动后剩下给你的滑动距离剩余量。然后，你自己进行余下的滑动。最后，如果滑动距离还有剩余，你就再问一下，Parent是否需要继续滑动你剩下的距离，也就是调用dispatchNestedScroll()。
startNestedScroll
起始方法, 主要作用是找到接收滑动距离信息的外控件，表示view开始滚动了,一般是在ACTION_DOWN中调用，如果返回true则表示父布局支持嵌套滚动。一般也是直接代理给NestedScrollingChildHelper的同名方法即可。这个时候正常情况会触发Parent的onStartNestedScroll()方法.
dispatchNestedPreScroll
在当前View消费滚动距离之前把滑动距离传给父布局。相当于把优先处理权交给Parent。返回true代表Parent消费了滚动距离
dispatchNestedScroll
在当前View消费滚动距离之后。通过调用该方法，把剩下的滚动距离传给父布局。如果当前没有发送嵌套滚动，或者不支持嵌套滚动，调用该方法也没啥用。
stopNestedScroll
结束方法, 主要作用就是清空嵌套滑动的相关状态。一般是在事件结束比如ACTION_UP或者ACTION_CANCLE中调用,告诉父布局滚动结束。
setNestedScrollingEnabled和isNestedScrollingEnabled
一对get&set方法, 用来判断控件是否支持嵌套滑动.
dispatchNestedPreFling
在当前View自己处理惯性滑动前，先将滑动事件分发给Parent。返回true表示Parent已经处理了滑动事件。一般来说如果想自己处理惯性的滑动事件，就不应该调用该方法给Parent处理。如果给了Parent并且返回true，那表示Parent已经处理了，自己就不应该再做处理。返回false则表示Parent没有处理，但是不代表Parent后面就不用处理了。
dispatchNestedFling
将惯性滑动的速度分发给Parent。返回true表示Parent处理了滑动事件。
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()表示本次处理结束。因为内控件是发起者,所以外控件的大部分方法都是被内控件的对应方法回调的.
onStartNestedScroll
对应startNestedScroll,当NestedScrollingChild调用方法startNestedScroll()时,会调用该方法。主要就是通过返回值告诉系统是否需要对后续的滚动进行处理。返回true表示我需要进行处理，后续的滚动会触发相应的回到，返回false表示我不需要处理，后面也就不会进行相应的回调了。
onNestedScrollAccepted
如果onStartNestedScroll()方法返回的是true的话,那么紧接着就会调用该方法.它是让嵌套滚动在开始滚动之前,让布局容器(viewGroup)或者它的父类执行一些配置的初始化的。
onNestedPreScroll
关键方法,接收内控件处理滑动前的滑动距离信息,在这里外控件可以优先响应滑动操作, 消耗部分或者全部滑动距离.
onNestedScroll(View target, int dx, int dy, int[] consumed)
当子view调用dispatchNestedPreScroll()方法时会调用该方法。也就是在NestedScrollingChild在处理滑动之前，会先将机会给Parent处理。如果Parent想先消费部分滚动距离，将消费的距离放入consumed。consumed表示Parent要消费的滚动距离,consumed[0]和consumed[1]分别表示父布局在x和y方向上消费的距离.
onStopNestedScroll
停止滚动了,当子view调用stopNestedScroll()时会调用该方法,用来做一些收尾工作.
onNestedFling
你可以捕获对内部NestedScrollingChild的fling事件，如果return true则表示消费了滑动事件
onNestedPreFling
在惯性滑动距离处理之前，会调用该方法，同onNestedPreScroll()一样，也是给Parent优先处理的权利。返回true则表示Parent要处理本次滑动事件，Child就不要处理了。
NestedScrollingParentHelper
这个类比较简单，方法也很简单，基本上就是一些赋值操作。所以就不多介绍了。这里就说下它的两个成员变量:
- mViewGroup：用于记录所关联的ViewGroup。起始也就是我们需要进程滑动处理的NestedScrollingParent
- mNestedScrollAxes：这个就是滑动的方向了。 然后另外需要注意的就是记得在NestedScrollingParent的实现类中，将相同签名的方法代理给我们的Helper类就可以了。
/**
* Helper class for implementing nested scrolling parent views compatible with Android platform
* versions earlier than Android 5.0 Lollipop (API 21).
*
* <p>{@link android.view.ViewGroup ViewGroup} subclasses should instantiate a final instance
* of this class as a field at construction. For each <code>ViewGroup</code> method that has
* a matching method signature in this class, delegate the operation to the helper instance
* in an overridden method implementation. This implements the standard framework policy
* for nested scrolling.</p>
*
* <p>Views invoking nested scrolling functionality should always do so from the relevant
* {@link androidx.core.view.ViewCompat}, {@link androidx.core.view.ViewGroupCompat} or
* {@link androidx.core.view.ViewParentCompat} compatibility
* shim static methods. This ensures interoperability with nested scrolling views on Android
* 5.0 Lollipop and newer.</p>
*/
public class NestedScrollingParentHelper {
private int mNestedScrollAxesTouch;
private int mNestedScrollAxesNonTouch;
/**
* Construct a new helper for a given ViewGroup
*/
public NestedScrollingParentHelper(@NonNull ViewGroup viewGroup) {
}
/**
* Called when a nested scrolling operation initiated by a descendant view is accepted
* by this ViewGroup.
*
* <p>This is a delegate method. Call it from your {@link android.view.ViewGroup ViewGroup}
* subclass method/{@link androidx.core.view.NestedScrollingParent} interface method with
* the same signature to implement the standard policy.</p>
*/
public void onNestedScrollAccepted(@NonNull View child, @NonNull View target,
@ScrollAxis int axes) {
onNestedScrollAccepted(child, target, axes, ViewCompat.TYPE_TOUCH);
}
/**
* Called when a nested scrolling operation initiated by a descendant view is accepted
* by this ViewGroup.
*
* <p>This is a delegate method. Call it from your {@link android.view.ViewGroup ViewGroup}
* subclass method/{@link androidx.core.view.NestedScrollingParent2} interface method with
* the same signature to implement the standard policy.</p>
*/
public void onNestedScrollAccepted(@NonNull View child, @NonNull View target,
@ScrollAxis int axes, @NestedScrollType int type) {
if (type == ViewCompat.TYPE_NON_TOUCH) {
mNestedScrollAxesNonTouch = axes;
} else {
mNestedScrollAxesTouch = axes;
}
}
/**
* Return the current axes of nested scrolling for this ViewGroup.
*
* <p>This is a delegate method. Call it from your {@link android.view.ViewGroup ViewGroup}
* subclass method/{@link androidx.core.view.NestedScrollingParent} interface method with
* the same signature to implement the standard policy.</p>
*/
@ScrollAxis
public int getNestedScrollAxes() {
return mNestedScrollAxesTouch | mNestedScrollAxesNonTouch;
}
/**
* React to a nested scroll operation ending.
*
* <p>This is a delegate method. Call it from your {@link android.view.ViewGroup ViewGroup}
* subclass method/{@link androidx.core.view.NestedScrollingParent} interface method with
* the same signature to implement the standard policy.</p>
*/
public void onStopNestedScroll(@NonNull View target) {
onStopNestedScroll(target, ViewCompat.TYPE_TOUCH);
}
/**
* React to a nested scroll operation ending.
*
* <p>This is a delegate method. Call it from your {@link android.view.ViewGroup ViewGroup}
* subclass method/{@link androidx.core.view.NestedScrollingParent2} interface method with
* the same signature to implement the standard policy.</p>
*/
public void onStopNestedScroll(@NonNull View target, @NestedScrollType int type) {
if (type == ViewCompat.TYPE_NON_TOUCH) {
mNestedScrollAxesNonTouch = ViewGroup.SCROLL_AXIS_NONE;
} else {
mNestedScrollAxesTouch = ViewGroup.SCROLL_AXIS_NONE;
}
}
}
NestedScrollingChildHelper
这个类其实就是NestedScrollingChild的标准实现。只是Java没有多继承，我们自定义View的时候只能通过实现NestedScrollingChild接口，然后在重写需要方法中，交个这个标准实现来处理就行了，相当于一种代理模式吧。
import static androidx.core.view.ViewCompat.TYPE_NON_TOUCH;
import static androidx.core.view.ViewCompat.TYPE_TOUCH;
import android.view.View;
import android.view.ViewParent;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.core.view.ViewCompat.NestedScrollType;
import androidx.core.view.ViewCompat.ScrollAxis;
/**
* Helper class for implementing nested scrolling child views compatible with Android platform
* versions earlier than Android 5.0 Lollipop (API 21).
*
* <p>{@link android.view.View View} subclasses should instantiate a final instance of this
* class as a field at construction. For each <code>View</code> method that has a matching
* method signature in this class, delegate the operation to the helper instance in an overridden
* method implementation. This implements the standard framework policy for nested scrolling.</p>
*
* <p>Views invoking nested scrolling functionality should always do so from the relevant
* {@link androidx.core.view.ViewCompat}, {@link androidx.core.view.ViewGroupCompat} or
* {@link androidx.core.view.ViewParentCompat} compatibility
* shim static methods. This ensures interoperability with nested scrolling views on Android
* 5.0 Lollipop and newer.</p>
*/
public class NestedScrollingChildHelper {
private ViewParent mNestedScrollingParentTouch;
private ViewParent mNestedScrollingParentNonTouch;
private final View mView;
private boolean mIsNestedScrollingEnabled;
private int[] mTempNestedScrollConsumed;
/**
* Construct a new helper for a given view.
*/
public NestedScrollingChildHelper(@NonNull View view) {
mView = view;
}
/**
* Enable nested scrolling.
*
* <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
* method/{@link androidx.core.view.NestedScrollingChild} interface method with the same
* signature to implement the standard policy.</p>
*
* @param enabled true to enable nested scrolling dispatch from this view, false otherwise
*/
public void setNestedScrollingEnabled(boolean enabled) {
if (mIsNestedScrollingEnabled) {
ViewCompat.stopNestedScroll(mView);
}
mIsNestedScrollingEnabled = enabled;
}
/**
* Check if nested scrolling is enabled for this view.
*
* <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
* method/{@link androidx.core.view.NestedScrollingChild} interface method with the same
* signature to implement the standard policy.</p>
*
* @return true if nested scrolling is enabled for this view
*/
public boolean isNestedScrollingEnabled() {
return mIsNestedScrollingEnabled;
}
/**
* Check if this view has a nested scrolling parent view currently receiving events for
* a nested scroll in progress with the type of touch.
*
* <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
* method/{@link androidx.core.view.NestedScrollingChild} interface method with the same
* signature to implement the standard policy.</p>
*
* @return true if this view has a nested scrolling parent, false otherwise
*/
public boolean hasNestedScrollingParent() {
return hasNestedScrollingParent(TYPE_TOUCH);
}
/**
* Check if this view has a nested scrolling parent view currently receiving events for
* a nested scroll in progress with the given type.
*
* <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
* method/{@link androidx.core.view.NestedScrollingChild} interface method with the same
* signature to implement the standard policy.</p>
*
* @return true if this view has a nested scrolling parent, false otherwise
*/
public boolean hasNestedScrollingParent(@NestedScrollType int type) {
return getNestedScrollingParentForType(type) != null;
}
/**
* Start a new nested scroll for this view.
*
* <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
* method/{@link androidx.core.view.NestedScrollingChild} interface method with the same
* signature to implement the standard policy.</p>
*
* @param axes Supported nested scroll axes.
* See {@link androidx.core.view.NestedScrollingChild#startNestedScroll(int)}.
* @return true if a cooperating parent view was found and nested scrolling started successfully
*/
public boolean startNestedScroll(@ScrollAxis int axes) {
return startNestedScroll(axes, TYPE_TOUCH);
}
/**
* Start a new nested scroll for this view.
*
* <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
* method/{@link androidx.core.view.NestedScrollingChild2} interface method with the same
* signature to implement the standard policy.</p>
*
* @param axes Supported nested scroll axes.
* See {@link androidx.core.view.NestedScrollingChild2#startNestedScroll(int,
* int)}.
* @return true if a cooperating parent view was found and nested scrolling started successfully
*/
public boolean startNestedScroll(@ScrollAxis int axes, @NestedScrollType int type) {
if (hasNestedScrollingParent(type)) {
// Already in progress
return true;
}
if (isNestedScrollingEnabled()) {
ViewParent p = mView.getParent();
View child = mView;
while (p != null) {
if (ViewParentCompat.onStartNestedScroll(p, child, mView, axes, type)) {
setNestedScrollingParentForType(type, p);
ViewParentCompat.onNestedScrollAccepted(p, child, mView, axes, type);
return true;
}
if (p instanceof View) {
child = (View) p;
}
p = p.getParent();
}
}
return false;
}
/**
* Stop a nested scroll in progress.
*
* <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
* method/{@link androidx.core.view.NestedScrollingChild} interface method with the same
* signature to implement the standard policy.</p>
*/
public void stopNestedScroll() {
stopNestedScroll(TYPE_TOUCH);
}
/**
* Stop a nested scroll in progress.
*
* <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
* method/{@link androidx.core.view.NestedScrollingChild2} interface method with the same
* signature to implement the standard policy.</p>
*/
public void stopNestedScroll(@NestedScrollType int type) {
ViewParent parent = getNestedScrollingParentForType(type);
if (parent != null) {
ViewParentCompat.onStopNestedScroll(parent, mView, type);
setNestedScrollingParentForType(type, null);
}
}
/**
* Dispatch one step of a nested scrolling operation to the current nested scrolling parent.
*
* <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
* method/{@link androidx.core.view.NestedScrollingChild} interface method with the same
* signature to implement the standard policy.</p>
*
* @return <code>true</code> if the parent consumed any of the nested scroll distance
*/
public boolean dispatchNestedScroll(int dxConsumed, int dyConsumed,
int dxUnconsumed, int dyUnconsumed, @Nullable int[] offsetInWindow) {
return dispatchNestedScrollInternal(dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed,
offsetInWindow, TYPE_TOUCH, null);
}
/**
* Dispatch one step of a nested scrolling operation to the current nested scrolling parent.
*
* <p>This is a delegate method. Call it from your {@link NestedScrollingChild2} interface
* method with the same signature to implement the standard policy.
*
* @return <code>true</code> if the parent consumed any of the nested scroll distance
*/
public boolean dispatchNestedScroll(int dxConsumed, int dyConsumed, int dxUnconsumed,
int dyUnconsumed, @Nullable int[] offsetInWindow, @NestedScrollType int type) {
return dispatchNestedScrollInternal(dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed,
offsetInWindow, type, null);
}
/**
* Dispatch one step of a nested scrolling operation to the current nested scrolling parent.
*
* <p>This is a delegate method. Call it from your {@link NestedScrollingChild3} interface
* method with the same signature to implement the standard policy.
*/
public void dispatchNestedScroll(int dxConsumed, int dyConsumed, int dxUnconsumed,
int dyUnconsumed, @Nullable int[] offsetInWindow, @NestedScrollType int type,
@Nullable int[] consumed) {
dispatchNestedScrollInternal(dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed,
offsetInWindow, type, consumed);
}
private boolean dispatchNestedScrollInternal(int dxConsumed, int dyConsumed,
int dxUnconsumed, int dyUnconsumed, @Nullable int[] offsetInWindow,
@NestedScrollType int type, @Nullable int[] consumed) {
if (isNestedScrollingEnabled()) {
final ViewParent parent = getNestedScrollingParentForType(type);
if (parent == null) {
return false;
}
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];
}
if (consumed == null) {
consumed = getTempNestedScrollConsumed();
consumed[0] = 0;
consumed[1] = 0;
}
ViewParentCompat.onNestedScroll(parent, mView,
dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed, type, consumed);
if (offsetInWindow != null) {
mView.getLocationInWindow(offsetInWindow);
offsetInWindow[0] -= startX;
offsetInWindow[1] -= startY;
}
return true;
} else if (offsetInWindow != null) {
// No motion, no dispatch. Keep offsetInWindow up to date.
offsetInWindow[0] = 0;
offsetInWindow[1] = 0;
}
}
return false;
}
/**
* Dispatch one step of a nested pre-scrolling operation to the current nested scrolling parent.
*
* <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
* method/{@link androidx.core.view.NestedScrollingChild} interface method with the same
* signature to implement the standard policy.</p>
*
* @return true if the parent consumed any of the nested scroll
*/
public boolean dispatchNestedPreScroll(int dx, int dy, @Nullable int[] consumed,
@Nullable int[] offsetInWindow) {
return dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow, TYPE_TOUCH);
}
/**
* Dispatch one step of a nested pre-scrolling operation to the current nested scrolling parent.
*
* <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
* method/{@link androidx.core.view.NestedScrollingChild2} interface method with the same
* signature to implement the standard policy.</p>
*
* @return true if the parent consumed any of the nested scroll
*/
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) {
int startX = 0;
int startY = 0;
if (offsetInWindow != null) {
mView.getLocationInWindow(offsetInWindow);
startX = offsetInWindow[0];
startY = offsetInWindow[1];
}
if (consumed == null) {
consumed = getTempNestedScrollConsumed();
}
consumed[0] = 0;
consumed[1] = 0;
ViewParentCompat.onNestedPreScroll(parent, mView, dx, dy, consumed, type);
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;
}
/**
* Dispatch a nested fling operation to the current nested scrolling parent.
*
* <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
* method/{@link androidx.core.view.NestedScrollingChild} interface method with the same
* signature to implement the standard policy.</p>
*
* @return true if the parent consumed the nested fling
*/
public boolean dispatchNestedFling(float velocityX, float velocityY, boolean consumed) {
if (isNestedScrollingEnabled()) {
ViewParent parent = getNestedScrollingParentForType(TYPE_TOUCH);
if (parent != null) {
return ViewParentCompat.onNestedFling(parent, mView, velocityX,
velocityY, consumed);
}
}
return false;
}
/**
* Dispatch a nested pre-fling operation to the current nested scrolling parent.
*
* <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
* method/{@link androidx.core.view.NestedScrollingChild} interface method with the same
* signature to implement the standard policy.</p>
*
* @return true if the parent consumed the nested fling
*/
public boolean dispatchNestedPreFling(float velocityX, float velocityY) {
if (isNestedScrollingEnabled()) {
ViewParent parent = getNestedScrollingParentForType(TYPE_TOUCH);
if (parent != null) {
return ViewParentCompat.onNestedPreFling(parent, mView, velocityX,
velocityY);
}
}
return false;
}
/**
* View subclasses should always call this method on their
* <code>NestedScrollingChildHelper</code> when detached from a window.
*
* <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
* method/{@link androidx.core.view.NestedScrollingChild} interface method with the same
* signature to implement the standard policy.</p>
*/
public void onDetachedFromWindow() {
ViewCompat.stopNestedScroll(mView);
}
/**
* Called when a nested scrolling child stops its current nested scroll operation.
*
* <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
* method/{@link androidx.core.view.NestedScrollingChild} interface method with the same
* signature to implement the standard policy.</p>
*
* @param child Child view stopping its nested scroll. This may not be a direct child view.
*/
public void onStopNestedScroll(@NonNull View child) {
ViewCompat.stopNestedScroll(mView);
}
private ViewParent getNestedScrollingParentForType(@NestedScrollType int type) {
switch (type) {
case TYPE_TOUCH:
return mNestedScrollingParentTouch;
case TYPE_NON_TOUCH:
return mNestedScrollingParentNonTouch;
}
return null;
}
private void setNestedScrollingParentForType(@NestedScrollType int type, ViewParent p) {
switch (type) {
case TYPE_TOUCH:
mNestedScrollingParentTouch = p;
break;
case TYPE_NON_TOUCH:
mNestedScrollingParentNonTouch = p;
break;
}
}
private int[] getTempNestedScrollConsumed() {
if (mTempNestedScrollConsumed == null) {
mTempNestedScrollConsumed = new int[2];
}
return mTempNestedScrollConsumed;
}
}
从NestedScrollView看嵌套机制
说完上面一大通, 终于可以开始分析源码来了解嵌套滑动机制起作用的具体逻辑了，首先是NestedScrollView.onTouchEvent方法:
@Override
public boolean onTouchEvent(MotionEvent ev) {
initVelocityTrackerIfNotExists();
final int actionMasked = ev.getActionMasked();
if (actionMasked == MotionEvent.ACTION_DOWN) {
mNestedYOffset = 0;
}
MotionEvent vtev = MotionEvent.obtain(ev);
vtev.offsetLocation(0, mNestedYOffset);
switch (actionMasked) {
case MotionEvent.ACTION_DOWN: {
if (getChildCount() == 0) {
return false;
}
if ((mIsBeingDragged = !mScroller.isFinished())) {
final ViewParent parent = getParent();
if (parent != null) {
parent.requestDisallowInterceptTouchEvent(true);
}
}
/*
* If being flinged and user touches, stop the fling. isFinished
* will be false if being flinged.
*/
if (!mScroller.isFinished()) {
abortAnimatedScroll();
}
// Remember where the motion event started
mLastMotionY = (int) ev.getY();
mActivePointerId = ev.getPointerId(0);
// 内部会调用mChildHelper.startNestedScroll(axes, type);
startNestedScroll(ViewCompat.SCROLL_AXIS_VERTICAL, ViewCompat.TYPE_TOUCH);
break;
}
case MotionEvent.ACTION_MOVE:
break;
....
继续看mChildHelper.startNestedScroll(axes, type):
public boolean startNestedScroll(@ScrollAxis int axes, @NestedScrollType int type) {
if (hasNestedScrollingParent(type)) {
// Already in progress
return true;
}
// 首先子view要先使用嵌套滑动机制
if (isNestedScrollingEnabled()) {
ViewParent p = mView.getParent();
View child = mView;
while (p != null) {
// 遍历视图层级，找到父控件为NestedScrollingParent2或NestedScrollingParent，并且onStartNestedScroll返回true，表示接受该嵌套滑动事件
if (ViewParentCompat.onStartNestedScroll(p, child, mView, axes, type)) {
setNestedScrollingParentForType(type, p);
// 找到父控件后，立即调用父控件的onNestedScrollAccepted
ViewParentCompat.onNestedScrollAccepted(p, child, mView, axes, type);
return true;
}
if (p instanceof View) {
child = (View) p;
}
p = p.getParent();
}
}
return false;
}
至此，ACTION_DOWN事件的处理就结束了。
接下来看下NestedScrollView对于ACTION_MOVE事件的处理：
case MotionEvent.ACTION_MOVE:
final int activePointerIndex = ev.findPointerIndex(mActivePointerId);
if (activePointerIndex == -1) {
Log.e(TAG, "Invalid pointerId=" + mActivePointerId + " in onTouchEvent");
break;
}
final int y = (int) ev.getY(activePointerIndex);
int deltaY = mLastMotionY - y;
//子view准备滑动，通知父控件
// 内部调用mChildHelper.dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow, type);
if (dispatchNestedPreScroll(0, deltaY, mScrollConsumed, mScrollOffset,
ViewCompat.TYPE_TOUCH)) {
// 父控件消费了mScrollConsumed[1]，子 view 还剩下 deltaY 距离可以消费
deltaY -= mScrollConsumed[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) {
// Scroll to follow the motion event
mLastMotionY = y - mScrollOffset[1];
final int oldY = getScrollY();
final int range = getScrollRange();
final int overscrollMode = getOverScrollMode();
boolean canOverscroll = overscrollMode == View.OVER_SCROLL_ALWAYS
|| (overscrollMode == View.OVER_SCROLL_IF_CONTENT_SCROLLS && range > 0);
// Calling overScrollByCompat will call onOverScrolled, which
// calls onScrollChanged if applicable.
if (overScrollByCompat(0, deltaY, 0, getScrollY(), 0, range, 0,
0, true) && !hasNestedScrollingParent(ViewCompat.TYPE_TOUCH)) {
// Break our velocity if we hit a scroll barrier.
mVelocityTracker.clear();
}
final int scrolledDeltaY = getScrollY() - oldY;
final int unconsumedY = deltaY - scrolledDeltaY;
mScrollConsumed[1] = 0;
// 子view消费滑动事件后，将消费距离详情通知父控件，内部调用ChildHelper.dispatchNestedScroll
dispatchNestedScroll(0, scrolledDeltaY, 0, unconsumedY, mScrollOffset,
ViewCompat.TYPE_TOUCH, mScrollConsumed);
mLastMotionY -= mScrollOffset[1];
mNestedYOffset += mScrollOffset[1];
if (canOverscroll) {
deltaY -= mScrollConsumed[1];
ensureGlows();
final int pulledToY = oldY + deltaY;
if (pulledToY < 0) {
EdgeEffectCompat.onPull(mEdgeGlowTop, (float) deltaY / getHeight(),
ev.getX(activePointerIndex) / getWidth());
if (!mEdgeGlowBottom.isFinished()) {
mEdgeGlowBottom.onRelease();
}
} else if (pulledToY > range) {
EdgeEffectCompat.onPull(mEdgeGlowBottom, (float) deltaY / getHeight(),
1.f - ev.getX(activePointerIndex)
/ getWidth());
if (!mEdgeGlowTop.isFinished()) {
mEdgeGlowTop.onRelease();
}
}
if (mEdgeGlowTop != null
&& (!mEdgeGlowTop.isFinished() || !mEdgeGlowBottom.isFinished())) {
ViewCompat.postInvalidateOnAnimation(this);
}
}
}
break;
所以，NestedScrollView 在 ACTION_MOVE 事件里，主要做了两件事:在每次滑动前调用dispatchNestedPreScroll和在拖动状态下分发dispatchNestedScroll。dispatchNestedScroll会调用mChildHelper.dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow, type);
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) {
int startX = 0;
int startY = 0;
if (offsetInWindow != null) {
mView.getLocationInWindow(offsetInWindow);
startX = offsetInWindow[0];
startY = offsetInWindow[1];
}
if (consumed == null) {
consumed = getTempNestedScrollConsumed();
}
consumed[0] = 0;
consumed[1] = 0;
// 回调父控件方法：onNestedPreScroll
ViewParentCompat.onNestedPreScroll(parent, mView, dx, dy, consumed, type);
if (offsetInWindow != null) {
mView.getLocationInWindow(offsetInWindow);
offsetInWindow[0] -= startX;
offsetInWindow[1] -= startY;
}
// true为父控件消费了滑动距离
return consumed[0] != 0 || consumed[1] != 0;
} else if (offsetInWindow != null) {
offsetInWindow[0] = 0;
offsetInWindow[1] = 0;
}
}
return false;
}
接着在来看下dispatchNestedScroll，内部调用了ChildHelper.dispatchNestedScroll:
// dispatchNestedPreScroll是让父控件优先消费滑动距离（在子 view 消费之前）；而dispatchNestedScroll是让父控件延后消费剩余滑动距离（在子 view 消费之后）。
public boolean dispatchNestedScroll(int dxConsumed, int dyConsumed,
int dxUnconsumed, int dyUnconsumed, @Nullable int[] offsetInWindow) {
return dispatchNestedScrollInternal(dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed,
offsetInWindow, TYPE_TOUCH, null);
}
private boolean dispatchNestedScrollInternal(int dxConsumed, int dyConsumed,
int dxUnconsumed, int dyUnconsumed, @Nullable int[] offsetInWindow,
@NestedScrollType int type, @Nullable int[] consumed) {
if (isNestedScrollingEnabled()) {
final ViewParent parent = getNestedScrollingParentForType(type);
if (parent == null) {
return false;
}
// 如果子 view 消费了滑动距离，或者是滑动距离还有剩余
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];
}
if (consumed == null) {
consumed = getTempNestedScrollConsumed();
consumed[0] = 0;
consumed[1] = 0;
}
// 通知父控件滑动距离详情
ViewParentCompat.onNestedScroll(parent, mView,
dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed, type, consumed);
if (offsetInWindow != null) {
mView.getLocationInWindow(offsetInWindow);
offsetInWindow[0] -= startX;
offsetInWindow[1] -= startY;
}
return true;
} else if (offsetInWindow != null) {
// No motion, no dispatch. Keep offsetInWindow up to date.
offsetInWindow[0] = 0;
offsetInWindow[1] = 0;
}
}
return false;
}
最后再来看下 NestedScrollView 对于 ACTION_UP 和 ACTION_CANCEL 事件的处理：
case MotionEvent.ACTION_UP:
final VelocityTracker velocityTracker = mVelocityTracker;
velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
int initialVelocity = (int) velocityTracker.getYVelocity(mActivePointerId);
if ((Math.abs(initialVelocity) > mMinimumVelocity)) {
// 子view在消费fling事件前，需要先询问父控件是否消费该事件
if (!dispatchNestedPreFling(0, -initialVelocity)) {
// 父控件不消费，则自己消费并回调fling事件给父控件
dispatchNestedFling(0, -initialVelocity, true);
// 开启新一轮滑动事件
fling(-initialVelocity);
}
} else if (mScroller.springBack(getScrollX(), getScrollY(), 0, 0, 0,
getScrollRange())) {
ViewCompat.postInvalidateOnAnimation(this);
}
mActivePointerId = INVALID_POINTER;
// 回收工作以及调用stopNestedScroll通知父控件滑动结束
endDrag();
break;
case MotionEvent.ACTION_CANCEL:
if (mIsBeingDragged && getChildCount() > 0) {
if (mScroller.springBack(getScrollX(), getScrollY(), 0, 0, 0,
getScrollRange())) {
ViewCompat.postInvalidateOnAnimation(this);
}
}
mActivePointerId = INVALID_POINTER;
endDrag();
break;
而在 ACTION_UP 事件中，会先判断下当前子 view 是否还存在惯性滑动速度，如果存在，则调用dispatchNestedPreFling询问父控件是否要消费该 fling 事件，如果父控件不消费，则调用dispatchNestedFling自己消费这个事件，并将结果通知到父控件。然后还有一个关键步骤，它开启了新的一轮嵌套滑动事件，开启方法如下：
public void fling(int velocityY) {
if (getChildCount() > 0) {
// scroller 驱动 fling 滑动
mScroller.fling(getScrollX(), getScrollY(), // start
0, velocityY, // velocities
0, 0, // x
Integer.MIN_VALUE, Integer.MAX_VALUE, // y
0, 0); // overscroll
runAnimatedScroll(true);
}
}
private void runAnimatedScroll(boolean participateInNestedScrolling) {
if (participateInNestedScrolling) {
// 参数为NON_TOUCH通知父控件开启新一轮嵌套滑动时间
startNestedScroll(ViewCompat.SCROLL_AXIS_VERTICAL, ViewCompat.TYPE_NON_TOUCH);
} else {
stopNestedScroll(ViewCompat.TYPE_NON_TOUCH);
}
mLastScrollerY = getScrollY();
// Scroller不会真正的起到滑动功能，只是负责一个计算功能，然后调用View.invalidate让View重新绘制
ViewCompat.postInvalidateOnAnimation(this);
}
在Android Design Support库中非常总要的CoordinatorLayout组件就是使用了这套机制，实现了Toolbar的收起和展开功能。