理解RecyclerView（七）—RecyclerView配合使用CoordinatorLayout及Behavior的嵌套滑动机制

前言： 并不是热泪盈眶才叫青春，也不是莽撞热血才叫年轻。不忘初心，便始终都是年轻。多少人把放纵当热血，并把早熟和自律当做陈腐来嬉笑。岁月还未过多流逝之前，他们的身体和精神就已经被掏空，提早告别了青春。

一、概述

  上一篇文章分析了RecyclerView的滑动原理，依然是由onTouchEvent()触控事件响应的，最终通过遍历所有子View，每个子View调用了底层View的offsetTopAndBottom()或者offsetLeftAndRight()方法来实现滑动的。不同的是RecyclerView采用嵌套滑动机制，会把滑动事件通知给支持嵌套滑动的父View先做决定。那么什么是嵌套滑动呢？RecyclerView是怎么处理嵌套滑动的呢？

什么是嵌套滑动？

我们来看看一个RecyclerView的滑动效果图：

这就是嵌套滑动的效果，当一个View产生嵌套滑动事件时，会先通知他的父View，询问父View是否处理这个事件，如果处理那么子View不处理，如果不处理那么子View处理，实际上父View只处理部分滑动距离的情况。可以看到由下往上滑动RecyclerView的时候，先处理头部的滑动事件，然后才处理RecyclerView自身的滑动事件，由上往下滑时，也是先询问父View是否处理滑动事件，如果不处理则交给RecyclerView自身的处理滑动事件。

<?xml version="1.0" encoding="utf-8"?>
<androidx.coordinatorlayout.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:fitsSystemWindows="true">

    <com.google.android.material.appbar.AppBarLayout
        android:id="@+id/app_bar"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:fitsSystemWindows="true">

        <com.google.android.material.appbar.CollapsingToolbarLayout
            android:id="@+id/toolbar_layout"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            app:contentScrim="#FF5722"
            app:layout_scrollFlags="scroll|exitUntilCollapsed|snap">

            <ImageView
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:src="@mipmap/flower"
                android:scaleType="centerCrop"
                app:layout_scrollFlags="scroll|enterAlwaysCollapsed" />

            <androidx.appcompat.widget.Toolbar
                android:id="@+id/toolbar"
                android:layout_width="match_parent"
                android:layout_height="40dp"
                app:layout_collapseMode="pin"
                app:title="二级标题" />

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

    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/recyclerView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:layout_behavior="@string/appbar_scrolling_view_behavior" />

</androidx.coordinatorlayout.widget.CoordinatorLayout>

这种高大上的视觉交互效果叫做“协调者布局”，实现这种效果的核心类就是一个CoordinatorLayout，它遵循Material Design风格，结合AppbarLayout，CollapsingToolbarLayout等可以产生各种炫酷的折叠悬浮效果。

二、CoordinatorLayout与Behavior

照着上面的xml布局，效果是完成了，但是你是否有很多问号，CoordinatorLayout是啥，干什么的？AppBarLayout有什么用？CollapsingToolbarLayout又是啥？上面的布局控件除了ImageView，Toolbar，RecyclerView这几个控件外，其他的我基本不认识。

这是官网CoordinatorLayout的解析截图，它是一个超级的FrameLayout，注意它继承自ViewGroup，并没有继承FrameLayout，然后实现了NestedScrollingParent接口。

CoordinatorLayout可以作为一个容器与一个或多个子View进行特定的交互。通过指定Behaviors为子视图，可以在单个父视图中提供许多不同的交互，这些视图可以彼此交互。

Behavior是CoordinatorLayout的子视图的交互行为插件，一个行为实现了一个或多个用户可以在子视图上进行的交互。这些交互可能包括拖动，滑动，甩动或任何其他手势。

插件也就代表如果一个子View需要某种交互，它就需要加载对应的Behavior，否则它就是不具备交互能力的。而Behavior是一个抽象类，它的实现类都是为了让用户作用在一个View上面进行拖拽、滑动、快速滑动等手势操作。如果你需要其他的交互动作，则需要自定义Behavior。

但是，我们有了解到Behavior的真正含义吗？它到底是具体干什么的？

前面内容有讲过，CoordinatorLayout可以定义与它子View的交互或某些子View之间的交互。先来看看Behavior的源码：

public static abstract class Behavior<V extends View> {

    public Behavior() {}

    public Behavior(Context context, AttributeSet attrs) {}
	
    public boolean layoutDependsOn(CoordinatorLayout parent, V child, View dependency) { 
    	return false;
    }
	
    public boolean onDependentViewChanged(CoordinatorLayout parent, V child, View dependency) {  
    	return false;
    }

    public void onDependentViewRemoved(CoordinatorLayout parent, V child, View dependency) {
    }

    public boolean onStartNestedScroll(CoordinatorLayout coordinatorLayout, View child, View directTargetChild,
                                       View target, int axes, int type) {
        return false;
    }

    public void onNestedScrollAccepted(CoordinatorLayout coordinatorLayout, View child, View directTargetChild,
                                       View target, int axes, int type) {
    	// Do nothing
    }

    public void onStopNestedScroll(CoordinatorLayout coordinatorLayout, V child, View target, int type) {
        // Do nothing
    }

    public void onNestedScroll(CoordinatorLayout coordinatorLayout, View child, View target, int dxConsumed,
                               int dyConsumed, int dxUnconsumed, int dyUnconsumed, int type) {
        // Do nothing                           
    }

    public void onNestedPreScroll(CoordinatorLayout coordinatorLayout, View child, View target, int dx,
                                  int dy, int[] consumed, int type) {
        // Do nothing                              
    }

    public boolean onNestedFling(CoordinatorLayout coordinatorLayout, View child, View target,
                                 float velocityX, float velocityY, boolean consumed) {
        return false;
    }

    public boolean onNestedPreFling(CoordinatorLayout coordinatorLayout, View child, View target,
                                    float velocityX, float velocityY) {
        return false;
    }
}

我们自定义Behavior的一般目的只有两个，一是根据某些依赖的View的位置改变进行相应的操作；二是响应CoordinatorLayout中某些组件的滑动事件。先来看第一种情况：

2.1 两个View之间的依赖关系

如果一个View需要依赖另一个View，可能需要操作下面的API：

//确定提供的子视图是否有另一个特定的同级视图作为布局依赖项
public boolean layoutDependsOn(CoordinatorLayout parent, V child, View dependency) { return false; }

//子View依赖的View的改变做出响应，当依赖视图在标准布局流之外的大小或者位置发生变化，此方法被调用。
//Behavior可以使用此方法更新子视图，如果子视图大小或者位置发生变化则返回true。
public boolean onDependentViewChanged(CoordinatorLayout parent, V child, View dependency) {  return false; }

//响应子View在依赖的视图中移除
public void onDependentViewRemoved(CoordinatorLayout parent, V child, View dependency) {}

通过layoutDependsOn()确定一个View是否对另一个View进行依赖，注意：child是测试的子View，dependency该依赖的子View，如果child的布局依赖于dependency的布局则返回true，即依赖成立；反之不成立。当然你可以复写该方法对dependency进行类型判断然后再决定是否依赖，只有在layoutDependsOn()返回true的时候后面的onDependentViewChanged()和onDependentViewRemoved()才会执行。

注释上面有说，无论子View 的顺序如何，总是在依赖的子View被布局后再布局这个子View，当依赖视图的布局发生改变时回调Behavior的onDependentViewChanged()方法，可以适当更新响应的子视图。如果Behavior改变了child的位置和尺寸时，则返回true，默认返回false。

onDependentViewRemoved()响应child从属性视图中被删除，从parent中移除dependency后调用此方法，
Behavior也可以使用此方法适当更新子视图来作为响应。

但是这样说有点抽象，到底是谁依赖谁？何为依赖？

下面举个例子加深理解：首先定义一个可以响应屏幕拖拽的View，DependencyView效果如下：

它的代码很简单，继承自TextView，在触摸事件onTouchEvent()根据触摸点移动对自身位置进行位移。

public class DependencyView extends AppCompatTextView {

    private int mTouchSlop;
    private float mLastY;
    private float mLastX;

    public DependencyView(Context context) {
        this(context, null);
    }

    public DependencyView(Context context, @Nullable AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public DependencyView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        setClickable(true);
        //在用户发生滚动之前，以像素为单位的触摸距离可能会发生飘移
        mTouchSlop = ViewConfiguration.get(context).getScaledTouchSlop();
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN://按下
                mLastX = event.getX();
                mLastY = event.getY();
                break;
            case MotionEvent.ACTION_MOVE://移动
                float moveX = event.getX() - mLastX;
                float moveY = event.getY() - mLastY;
                if (Math.abs(moveX) > mTouchSlop || Math.abs(moveY) > mTouchSlop) {
                    ViewCompat.offsetLeftAndRight(this, (int) moveX);
                    ViewCompat.offsetTopAndBottom(this, (int) moveY);
                    mLastX = event.getX();
                    mLastY = event.getY();
                }
                break;
            case MotionEvent.ACTION_UP://抬起
                mLastX = event.getX();
                mLastY = event.getY();
                break;
        }
        return true;
    }
}

然后实现一个Behavior，让它支配一个View，去紧紧依赖所支配的View。这里我们让依赖的View显示在被依赖的View的下面，不论被依赖的View位置如何变化，依赖的View都跟着变化：

public class MyBehavior extends CoordinatorLayout.Behavior<View> {
    private static final String TAG = "MyBehavior";

    public MyBehavior() {
    }

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

    //确定提供的子视图是否有另一个特定的同级视图作为布局依赖项
    @Override
    public boolean layoutDependsOn(@NonNull CoordinatorLayout parent, @NonNull View child, @NonNull View dependency) {
        return dependency instanceof DependencyView;
    }

    //子View依赖的View的改变做出响应，当依赖视图在标准布局流之外的大小或者位置发生变化，此方法被调用。
    //Behavior可以使用此方法更新子视图，如果子视图大小或者位置发生变化则返回true。
    @Override
    public boolean onDependentViewChanged(@NonNull CoordinatorLayout parent, @NonNull View child, @NonNull View dependency) {
        int bottom = dependency.getBottom();
        child.setY(bottom );
        child.setX(dependency.getLeft());
        
        Log.d(TAG, "onDependentViewChanged: " + dependency);
        return true;
    }
}

在layoutDependsOn()中通过判断dependency是否为DependencyView类型决定是否对其进行依赖，然后再onDependentViewChanged()获取dependency的位置参数来设置child的位置参数，从而实现了child跟随dependency的位置改变而发生位置改变。

下面来验证MyBehavior，我们在布局文件中对ImageView设置了MyBehavior，然后观察它的现象：

<?xml version="1.0" encoding="utf-8"?>
<androidx.coordinatorlayout.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:fitsSystemWindows="true">

    <ImageView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:src="@mipmap/ic_head"
        app:layout_behavior="com.antiphon.recyclerviewdemo.weight.MyBehavior" />

    <com.antiphon.recyclerviewdemo.weight.DependencyView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:background="@color/colorAccent"
        android:padding="4dp"
        android:text="DependencyView"
        android:textColor="#fff"
        android:textSize="18sp" />
</androidx.coordinatorlayout.widget.CoordinatorLayout>

注意：布局最外层需要是CoordinatorLayout作为父布局，效果如下：

可以看到，我们在拖动DependencyView的时候，ImageView也跟随着DependencyView移动。当然这种依赖并非只有一对一的关系，也可能是一对多或者多对多。

我们再修改一下MyBehavior中的代码，如果child是一个TextView则显示在 dependency的上方，否则显示在下方：

   	@Override
    public boolean onDependentViewChanged(@NonNull CoordinatorLayout parent, @NonNull View child, @NonNull View dependency) {
        //child坐标
        float childX = child.getX();
        float childY = child.getY();

        //dependency顶部底部坐标
        int dependencyTop = dependency.getTop();
        int dependencyBottom = dependency.getBottom();

        childX = dependency.getX();

        if (child instanceof TextView) {//如果是TextView则显示在dependency上面，否则显示在下面
            childY = dependencyTop + child.getHeight();
        } else {
            childY = dependencyBottom;
        }

        child.setX(childX);
        child.setY(childY);

        return true;

我们在xml布局文件再添加一个TextView，设置MyBehavior：

   <ImageView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:src="@mipmap/ic_head"
        app:layout_behavior="com.antiphon.recyclerviewdemo.weight.MyBehavior" />
    
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="helloWord"
        android:textColor="#000"
        android:textSize="14sp"
        app:layout_behavior="com.antiphon.recyclerviewdemo.weight.MyBehavior" />

效果如下：

到这里我们知道，在Behavior中针对被依赖对象尺寸及位置变化时，依赖方该如何处理的流程，接下来就是处理滑动相关操作了。

2.2 Behavior对滑动事件的响应

我们一般接触到的滑动控件一般是 ScrollView和 RecyclerView，而CoordinatorLayout本身能滑动吗？如果能是怎么滑动的，到底是谁响应谁的滑动。

Behavior的相关滑动代码如下：

Behavior.java

	public boolean onStartNestedScroll(CoordinatorLayout coordinatorLayout, View child, View directTargetChild,
                                       View target, int axes, int type) {
        return false;
    }

    public void onNestedScrollAccepted(CoordinatorLayout coordinatorLayout, View child, View directTargetChild,
                                       View target, int axes, int type) {
    	// Do nothing
    }

    public void onStopNestedScroll(CoordinatorLayout coordinatorLayout, V child, View target, int type) {
        // Do nothing
    }

    public void onNestedScroll(CoordinatorLayout coordinatorLayout, View child, View target, int dxConsumed,
                               int dyConsumed, int dxUnconsumed, int dyUnconsumed, int type) {
        // Do nothing                           
    }

    public void onNestedPreScroll(CoordinatorLayout coordinatorLayout, View child, View target, int dx,
                                  int dy, int[] consumed, int type) {
        // Do nothing                              
    }

    public boolean onNestedFling(CoordinatorLayout coordinatorLayout, View child, View target,
                                 float velocityX, float velocityY, boolean consumed) {
        return false;
    }

    public boolean onNestedPreFling(CoordinatorLayout coordinatorLayout, View child, View target,
                                    float velocityX, float velocityY) {
        return false;
    }

为了观察Behavior行为，我在相关滑动方法添加了log：

Behavior.java

    @Override
    public boolean onStartNestedScroll(CoordinatorLayout coordinatorLayout, View child, View directTargetChild,
                                       View target, int axes, int type) {
        Log.e(TAG, "onStartNestedScroll：axes == " + axes);
        return super.onStartNestedScroll(coordinatorLayout, child, directTargetChild, target, axes, type);
    }

    @Override
    public void onNestedScrollAccepted(CoordinatorLayout coordinatorLayout, View child, View directTargetChild,
                                       View target, int axes, int type) {
        Log.e(TAG, "onNestedScrollAccepted：axes == " + axes + " | type == " + type);
        super.onNestedScrollAccepted(coordinatorLayout, child, directTargetChild, target, axes, type);
    }

    @Override
    public void onNestedScroll(CoordinatorLayout coordinatorLayout, View child, View target, int dxConsumed,
                               int dyConsumed, int dxUnconsumed, int dyUnconsumed, int type) {
        Log.e(TAG, "onNestedScrollAccepted：dxConsumed == " + dxConsumed + " | dyConsumed == "
                + dyConsumed + " | dxUnconsumed == " + dxUnconsumed + " | dyUnconsumed == " + dyUnconsumed);
        super.onNestedScroll(coordinatorLayout, child, target, dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed, type);
    }

    @Override
    public void onNestedPreScroll(CoordinatorLayout coordinatorLayout, View child, View target, int dx,
                                  int dy, int[] consumed, int type) {
        Log.e(TAG, "onNestedScrollAccepted：dx == " + dx + " | dy == " + dy + " | type == " + type);
        super.onNestedPreScroll(coordinatorLayout, child, target, dx, dy, consumed, type);
    }

    @Override
    public void onStopNestedScroll(CoordinatorLayout coordinatorLayout, View child, View target, int type) {
        Log.e(TAG, "onNestedScrollAccepted：type == " + type);
        super.onStopNestedScroll(coordinatorLayout, child, target, type);
    }

    @Override
    public boolean onNestedFling(CoordinatorLayout coordinatorLayout, View child, View target,
                                 float velocityX, float velocityY, boolean consumed) {
        Log.e(TAG, "onNestedScrollAccepted：velocityX == " + velocityX + " | velocityY == "
                + velocityY + " | consumed == " + consumed);
        return super.onNestedFling(coordinatorLayout, child, target, velocityX, velocityY, consumed);
    }

    @Override
    public boolean onNestedPreFling(CoordinatorLayout coordinatorLayout, View child, View target,
                                    float velocityX, float velocityY) {
        Log.e(TAG, "onNestedScrollAccepted：velocityX == " + velocityX + " | velocityY == " + velocityY);
        return super.onNestedPreFling(coordinatorLayout, child, target, velocityX, velocityY);
    }

然后我在模拟器上面用鼠标滑动CoordinatorLayout制造一些滑动事件，观看MyBehavior相关的滑动函数API是否能触发，然后观察log：

可以看到，并没有触发任何的函数。那么先来了解嵌套滑动事件的API：

Behavior.java

   /**
     * 如果CoordinatorLayout后代的View尝试发起嵌套滑动时调用
     * 任何与CoordinatorLayout的任何直接子元素相关联的Behavior都可以响应这个事件并返回true，
     * 以指示CoordinatorLayout应该作为这个滑动嵌套滑动的父View，只有返回true才能接收后续的嵌套滑动事件。
     */
	public boolean onStartNestedScroll(CoordinatorLayout coordinatorLayout, View child, View directTargetChild,
                                       View target, int axes, int type) {
        return false;
    }

注释中说明，当一个CoordinatorLayout的后代想要触发嵌套滑动事件时，这个方法被调用，只有onStartNestedScroll()返回true，后续的嵌套滑动事件才会响应。后续响应的函数指的是这几个函数：

Behavior.java

    public void onNestedScrollAccepted(CoordinatorLayout coordinatorLayout, View child, View directTargetChild,
                                       View target, int axes, int type) {}

    public void onStopNestedScroll(CoordinatorLayout coordinatorLayout, V child, View target, int type) {}

    public void onNestedScroll(CoordinatorLayout coordinatorLayout, View child, View target, int dxConsumed,
                               int dyConsumed, int dxUnconsumed, int dyUnconsumed, int type) {}

    public void onNestedPreScroll(CoordinatorLayout coordinatorLayout, View child, View target, int dx,
                                  int dy, int[] consumed, int type) {}

    public boolean onNestedFling(CoordinatorLayout coordinatorLayout, View child, View target,
                                 float velocityX, float velocityY, boolean consumed) {}

    public boolean onNestedPreFling(CoordinatorLayout coordinatorLayout, View child, View target,
                                    float velocityX, float velocityY) {}

那么，我们先从onStartNestedScroll()开始分析，查找在哪里调用到这个方法：

可以看到MyBehavior的onStartNestedScroll()被调用了，原来它是在CoordinatorLayout中被调用：

CoordinatorLayout.java

    @Override
    public boolean onStartNestedScroll(View child, View target, int axes, int type) {
        boolean handled = false;

        final int childCount = getChildCount();
        for (int i = 0; i < childCount; i++) {
            final View view = getChildAt(i);
            if (view.getVisibility() == View.GONE) {
                // If it's GONE, don't dispatch
                continue;
            }
            final LayoutParams lp = (LayoutParams) view.getLayoutParams();
            final Behavior viewBehavior = lp.getBehavior();
            if (viewBehavior != null) {
                final boolean accepted = viewBehavior.onStartNestedScroll(this, view, child,
                        target, axes, type);
                handled |= accepted;
                lp.setNestedScrollAccepted(type, accepted);
            } else {
                lp.setNestedScrollAccepted(type, false);
            }
        }
        return handled;
    }

这是CoordinatorLayout中的一个方法，先获取CoordinatorLayout下的子View，再获取子View中的Behavior，然后调用Behavior的onStartNestedScroll()方法。

继续深入，那么谁调用了CoordinatorLayout的onStartNestedScroll()呢？

继续追踪下去：

可以看到有多个地方调用它，其实归根到底最终都是View或者ViewParentCompat，这里以View为例：

   public boolean startNestedScroll(int axes) {
        if (hasNestedScrollingParent()) {
            // Already in progress
            return true;
        }
        if (isNestedScrollingEnabled()) {//是否启用嵌套滑动
            ViewParent p = getParent();
            View child = this;
            while (p != null) {
                try {
                    if (p.onStartNestedScroll(child, this, axes)) {
                        mNestedScrollingParent = p;
                        p.onNestedScrollAccepted(child, this, axes);
                        return true;
                    }
                }
                if (p instanceof View) {
                    child = (View) p;
                }
                p = p.getParent();
            }
        }
        return false;
    }

当一个View触发onStartNestedScroll() 的时候，如果符合嵌套滑动，则获取Parent通过while循环调用Parent的onStartNestedScroll()方法。因为CoordinatorLayout就是一个ViewGroup，所以它就是一个ViewParent对象，如果一个CoordinatorLayout的后代View触发了onStartNestedScroll() 方法，如果符合条件，那么CoordinatorLayout 的onStartNestedScroll()方法就会被调用，再进一步调用Behavior的onStartNestedScroll()方法。

当isNestedScrollingEnabled() = true时，它的ViewParent的onStartNestedScroll()才能被触发，它是被判断自身是否能嵌套滑动，如果为true则在使用时作为嵌套滑动的子视图，可以通过setNestedScrollingEnabled(boolean enabled)来设置View是否拥有嵌套滑动的能力。

2.3 使用TextView产生嵌套滑动事件

如果一个View符合嵌套滑动的事件，也就是通过setNestedScrollingEnabled(true)，然后调用它的onStartNestedScroll() 方法，理论上是可以产生嵌套滑动事件的。我们来尝试一下，在布局里面添加一个普通的TextView，然后设置点击事件。

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        mTv_nested_scroll.setNestedScrollingEnabled(true);
        mTv_nested_scroll.startNestedScroll(View.SCROLL_AXIS_HORIZONTAL);
    }

之前在MyBehavior中对应的嵌套滑动方法打印了log，所以如果CoordinatorLayout中发生嵌套滑动的事件，log就有输出：
可以看到在一个View符合嵌套滑动的事件，则调用它的onStartNestedScroll() 方法。不过在安卓版本21(LOLLIPOP，5.0)及以上时才能调用View的嵌套滑动相关的API，那么在低于5.0版本呢？其实系统做了兼容：

    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP){
    	ViewCompat.setNestedScrollingEnabled(mTv_nested_scroll, true);
        ViewCompat.startNestedScroll(mTv_nested_scroll, ViewCompat.SCROLL_AXIS_HORIZONTAL);
    }

我们知道5.0以上版本View已经自带嵌套滑动功能和相关属性，可以根据ViewCompat这个类完成低版本的兼容操作，继续跟踪ViewCompat.startNestedScroll()：

   public static void setNestedScrollingEnabled(@NonNull View view, boolean enabled) {
        if (Build.VERSION.SDK_INT >= 21) {
            view.setNestedScrollingEnabled(enabled);
        } else {
            if (view instanceof NestedScrollingChild) {
                ((NestedScrollingChild) view).setNestedScrollingEnabled(enabled);
            }
        }
    }
    
  public static boolean startNestedScroll(@NonNull View view, @ScrollAxis int axes) {
        if (Build.VERSION.SDK_INT >= 21) {
            return view.startNestedScroll(axes);
        }
        if (view instanceof NestedScrollingChild) {
            return ((NestedScrollingChild) view).startNestedScroll(axes);
        }
        return false;
    }

可以看到ViewCompat的源码里面也做了版本兼容，在API>=21则会直接调用view.startNestedScroll()相关嵌套滑动方法，否则会判断view是否为NestedScrollingChild的实例，如果是则调用NestedScrollingChild的startNestedScroll()方法，NestedScrollingChild是一个接口。

所以如果在5.0以上版本我们可以view.startNestedScroll()，如果在5.0以下版本，如果一个View想发起嵌套滑动事件，你得保证这个View实现NestedScrollingChild接口。

2.4 想触发事件吗？你是NestedScrollingChild吗？

我们来看看NestedScrollingChild：

public interface NestedScrollingChild {
  	/**
     * 启用或者禁用此View的嵌套滑动。
     * 注意：如果此属性设置为true，则允许该View使用当前层结构中兼容的父View启动嵌套滑动操作。
     * 		如果这个View没有任务嵌套滑动，则这个方法没有任何作用。
     */ 	
    void setNestedScrollingEnabled(boolean enabled);
	/**
     * 如果此View启用了嵌套滑动，则返回true。
     * 如果启动了嵌套滑动，并且这个View类实现支持嵌套滑动，那么这个View将在适用时充当嵌套滑动子View，
     * 将有关正在进行的滚动操作的数据转发到兼容且协作嵌套滑动的父View。
     */ 	
    boolean isNestedScrollingEnabled();
	/**
     * 沿着给定的方向(垂直或水平方向)开始一个可嵌套滚动的滑动操作。
     * 返回true表示能处理父View传递上去的嵌套滑动事件，实际这个方法里面调用了NestedScrollingParent的onStartNestedScroll()
     *@param axes axes表示方向
     */ 	
    boolean startNestedScroll(int axes);
	/**
     * 停止正在进行的嵌套滑动，嵌套滑动结束
     */ 
    void stopNestedScroll();
	/**
     * 如果该View有一个嵌套的滑动父View，则返回true
     */ 
    boolean hasNestedScrollingParent();

	/**
     * 调度一个正在执行的滑动步骤
     * 在产生嵌套滑动的View已经滑动完成之后调用，该方法的作用是将剩余没有消耗的距离继续分发到View里面去
     * @param dxConsumed 表示该View在x轴上消耗的距离
     * @param dyConsumed 表示该View在y轴上消耗的距离
     * @param dxUnconsumed 表示该View在x轴上未消耗的距离
     * @param dyUnconsumed 表示该View在y轴未消耗的距离
     * @param offsetInWindow 表示该该View在屏幕上滑动的距离，包括x轴上的距离和y轴上的距离
     * 返回true表示父线程消耗了部分或者全部滑动的量，false表示不消耗
     */ 
    boolean dispatchNestedScroll(int dxConsumed, int dyConsumed,int dxUnconsumed, 
    							 int dyUnconsumed, int[] offsetInWindow);
	/**
     * 在View消耗滑动的任何部分之前调度嵌套滑动的一个步骤。为嵌套滑动中的父View提供一个机会，在子View使用滑动操作之前，使用部分或者全部滑动操作。
     * 在dispatchNestedScroll之前调用，也就是距离产生了，但是改View还没滑动。将滑动的距离报给父View，看父View是否优先消耗这部分距离
     * @param dx x轴上产生的距离
     * @param dy y轴上产生的距离
     * @param consumed index为0的值表示父View在x轴消耗的的距离，index为1的值表示父View在y轴上消耗的距离
     * @param offsetInWindow 该View在屏幕滑动的距离
     * 返回true表示父线程消耗了部分或者全部滑动的距离，false表示父View不消耗
     */ 
    boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow);
	/**
     * 如果父View不对惯性滑动做任何处理，那么子View会调用这个方法，作用是报告父View，子View此时正在fling
     * @param velocityX x轴上的速度
     * @param velocityY y轴的速度
     * @param consumed true表示子View对这个fling事件有所行动，false表示没有行动
     * 返回true表示嵌套滑动的父View消耗了或者以其他方式对惯性滑动做出反应,false则没有
     */ 
    boolean dispatchNestedFling(float velocityX, float velocityY, boolean consumed);

	/**
     * 在视图处理之前，将一个抛投运动发送给嵌套滑动的父View
     * 在子View对fling有所行动之前，回调用这个方法，用于询问父View是否对fling有所行动
     */ 
    boolean dispatchNestedPreFling(float velocityX, float velocityY);
}

这个接口应该由View的子类实现并且希望支持将嵌套滑动操作分派到协作的父View(ViewGroup)。实现这个接口的类应该创建NestedScrollingChildHelper并将任何View方法委托给它。调用嵌套滑动功能的View应该始终从ViewCompat，ViewGroupCompat，ViewParentCompat兼容性垫板静态方法执行，确保Android 5.0及以上版本的嵌套滑动视图的相护操作性。

通过AndroidStudio快捷键Ctrl+H，可以看到NestedScrollingChild目前的实现者：

NestedScrollingChild的实现者有两个SwipleRefreshLayout和NestedScrollingChild2，而NestedScrollingChild2也有两个实现者RecyclerView和NestedScrollingChild3，那么RecyclerView也是NestedScrollingChild间接实现者。而NestedScrollingChild3的实现者是RecyclerView和NestedScrollView。

那么来到这里，NestedScrollingChild可以说有三个实现类，RecyclerView，NestedScrollView，SwipleRefreshLayout，上面三个控件我们都认识，都是自带滑动的控件。

2.5 Behavior是如何响应滑动事件的？

我们在上面验证了child之间的依赖互动关系，那么Behavior是如果响应滑动事件的？我们需要找到挑起嵌套滑动的View，我们往CoordinatorLayout布局中添加RecyclerView，滑动RecyclerView的内容，能产生嵌套滑动事件：

<?xml version="1.0" encoding="utf-8"?>
<androidx.coordinatorlayout.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:fitsSystemWindows="true">

    <ImageView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginLeft="5dp"
        android:layout_marginTop="10dp"
        android:src="@mipmap/ic_gesture_down"
        app:layout_behavior="com.antiphon.recyclerviewdemo.weight.MyBehavior" />

    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/recyclerView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_marginLeft="50dp" />

</androidx.coordinatorlayout.widget.CoordinatorLayout>

Behavior需要针对自身的业务逻辑进行处理，当我们滑动RecyclerView内容的时候，MyBehavior规定关联的ImageView进行相应的位移，主要是在垂直方向上。在MyBehavior的onStartNestedScroll()做一些特别的处理：

    @Override
    public boolean onStartNestedScroll(CoordinatorLayout coordinatorLayout, View child, View directTargetChild,
                                       View target, int axes, int type) {
        Log.e(TAG, "onStartNestedScroll：axes == " + axes);
        return child instanceof ImageView && axes == ViewCompat.SCROLL_AXIS_VERTICAL;
    }

只要child是ImageView并且滑动方向是垂直方向，返回true响应后续的嵌套滑动事件，针对滑动事件返回的位移对child进行操作：

    @Override
    public void onNestedPreScroll(CoordinatorLayout coordinatorLayout, View child, View target, int dx,
                                  int dy, int[] consumed, int type) {
        Log.e(TAG, "onNestedScrollAccepted：dx == " + dx + " | dy == " + dy + " | type == " + type);
        super.onNestedPreScroll(coordinatorLayout, child, target, dx, dy, consumed, type);
        ViewCompat.offsetTopAndBottom(child, dy);//让child进行垂直方向移动
    }

复写onNestedPreScroll()方法，通过读取dy值，让child进行垂直方向移动。dx是滑动水平方向的位移，dy是滑动垂直方向的位移，它是在滑动事件滑动onNestedScroll()之前调用，然后把消耗的距离传递给consumed数组中。而onNestedScroll()是滑动事件时调用，它的参数包括位移信息，以及已经在onNestedPreScroll()消耗过的位移数。实现onNestedPreScroll()方法就可以了。

    @Override
    public boolean layoutDependsOn(@NonNull CoordinatorLayout parent, @NonNull View child, @NonNull View dependency) {
        return false;
//        return dependency instanceof DependencyView;
    }

将MyBehavior之前做的一些处理，将它与DependencyView接触依赖。效果如下：

这里还有两个和惯性滑动相关的API：

    public boolean onNestedFling(CoordinatorLayout coordinatorLayout, View child, View target,
                                 float velocityX, float velocityY, boolean consumed) {
        return false;
    }

    public boolean onNestedPreFling(CoordinatorLayout coordinatorLayout, View child, View target,
                                    float velocityX, float velocityY) {
        return false;
    }

Fling惯性滑动，RecyclerView和NestedScrollView快速滑动的时候，手指停下来的时候，滑动操作并没有停止，还会滑动一段距离。同样我们在Fling动作即将发生的时候，通过onNestedPreFling()如果返回true则会拦截这次Fling动作，表明响应中的child自己处理这里fling事件，那么RecyclerView反而操作不了这个动作，因为child消耗了这个fling事件。

我们验证一下，将MyBehavior响应fling事件的时候，如果滑动向下，则ImageView放大，滑动向上，则ImageView缩小。

    @Override
    public boolean onNestedPreFling(CoordinatorLayout coordinatorLayout, View child, View target,
                                    float velocityX, float velocityY) {
        Log.e(TAG, "onNestedScrollAccepted：velocityX == " + velocityX + " | velocityY == " + velocityY);
        if (velocityY > 0) {//向下惯性滑动
            child.animate().scaleX(2f).scaleY(2f).setDuration(2000).start();
        } else {//向上惯性滑动
            child.animate().scaleX(1f).scaleY(1f).setDuration(2000).start();
        }
        return false;
//        return super.onNestedPreFling(coordinatorLayout, child, target, velocityX, velocityY);
    }

效果如下：

2.6 Behavior的总结

1.确定CoordinatorLayout中View与View之间的关系，通过layoutDependsOn()方法返回true则表示依赖，否则不依赖；
2.当一个被依赖项dependency尺寸或者位置发生变化时，依赖方会通过Behavior获取到，然后在onDependentViewChanged()中处理，如果方法中child的尺寸或者位置发生了变化，则需要返回true；
3.当Behavior中的View准备响应嵌套滑动时，它不需要通过layoutDependsOn()来进行依赖绑定，只需要在onStartNestedScroll()通过返回值告诉ViewParent，是否开启嵌套滑动功能，返回true后续的嵌套滑动事件才能响应。
4.嵌套滑动包括普通滑动（scroll）和惯性滑动（fling）两种。

前面我有尝试找出谁能产生嵌套滑动事件，结果发现他需要是NestedScrollChild对象，但是NestedScrollChild在调用startNestedScroll()方法时，它需要借助它父View的力量，只有父View的startNestedScroll()返回true的时候，它的后续事件才能延续下去。

View.java

   public boolean startNestedScroll(int axes) {
        if (hasNestedScrollingParent()) {
            // Already in progress
            return true;
        }
        if (isNestedScrollingEnabled()) {
            ViewParent p = getParent();
            View child = this;
            while (p != null) {
                try {
                    if (p.onStartNestedScroll(child, this, axes)) {
                        mNestedScrollingParent = p;
                        p.onNestedScrollAccepted(child, this, axes);
                        return true;
                    }
                }
                if (p instanceof View) {
                    child = (View) p;
                }
                p = p.getParent();
            }
        }
        return false;
    }

可以看到ViewParent充当了非常重要的角色，回调了父View的onStartNestedScroll()方法：

public interface ViewParent {
  
    public void requestLayout();

    public ViewParent getParent();

    public boolean onStartNestedScroll(View child, View target, int nestedScrollAxes);

    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);

    public void onNestedPreScroll(View target, int dx, int dy, int[] consumed);

    public boolean onNestedFling(View target, float velocityX, float velocityY, boolean consumed);

    public boolean onNestedPreFling(View target, float velocityX, float velocityY);
}

ViewParent是一个接口，常见的实现类是ViewGroup，它提供了嵌套滑动的相关API，是在Android5.0才加进去的，如果要兼容的话需要分析ViewParentCompat这个类，它为View以及它的父类提供了执行嵌套滑动的初始配置的机会，如果有这个方法的实现则应该调用父类来实现这个方法：

ViewParentCompat.java

    public static boolean onStartNestedScroll(ViewParent parent, View child, View target,
            int nestedScrollAxes, int type) {
        if (parent instanceof NestedScrollingParent2) {
            // First try the NestedScrollingParent2 API
            return ((NestedScrollingParent2) parent).onStartNestedScroll(child, target,
                    nestedScrollAxes, 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) {//5.0及以上
                return parent.onStartNestedScroll(child, target, nestedScrollAxes);
            } else if (parent instanceof NestedScrollingParent) {//5.0以下
                return ((NestedScrollingParent) parent).onStartNestedScroll(child, target,
                        nestedScrollAxes);
            }
        }
        return false;
    }

可以看到在安卓5.0版本以下，如果ViewParent需要响应嵌套滑动事件，则需要保证自己是一个NestedScrollingParent对象：

public interface NestedScrollingParent {
    
    boolean onStartNestedScroll(View child, View target, int axes);

    void onNestedScrollAccepted(View child, View target, int axes);

    void onStopNestedScroll(View target);

    void onNestedScroll(View target, int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed);

    void onNestedPreScroll(View target, int dx, int dy, int[] consumed);

    boolean onNestedFling(View target, float velocityX, float velocityY, boolean consumed);

    boolean onNestedPreFling(View target, float velocityX, float velocityY);

    int getNestedScrollAxes();
}

NestedScrollingParent的实现类有以下几个：

因为NestedScrollingParent2也是NestedScrollingParent的一个实现类，CoordinatorLayout间接实现了NestedScrollingParent，所以有四个实现了类：CoordinatorLayout、NestedScrollView、SwipeRefreshLayout、ActionBarOverlayLayout。所以CoordinatorLayout之所以能处理嵌套滑动事件，是因为它本身就是一个NestedScrollingParent。

嵌套滑动的流程：
总的来说一个嵌套滑动事件的起始，它是由一个NestedScrollingChild发起，通过向上遍历parent，借助parent的嵌套滑动相关方法来完成交互。注意安卓5.0以下版本，parent必须NestedScrollingParent接口。

三、RecyclerView的嵌套滑动事件

  如果要支持嵌套滑动，子View必须实现NestedScrollingChild接口，父View必须实现NestedScrollingParent接口。而RecyclerView实现了NestedScrollingChild接口，CoordinatorLayout实现了NestedScrollingParent接口。

温馨提示：本文源码基于androidx.recyclerview:recyclerview:1.2.0-alpha01

嵌套滑动机制主要用到的接口和类：NestedScrollingChild，NestedScrollingParent，NestedScrollingParentHelper，NestedScrollingChildHelper。这里做个简单总结：

类名	含义
NestedScrollingChild	如果一个View想要产生滑动事件，这个View必须实现NestedScrollingChild接口， 从Android5.0开始View实现了这个接口，不需要手动实现了
NestedScrollingParent	这个接口通常被ViewGroup来实现，表示能接收从子View发送过来的嵌套滑动事件
NestedScrollingChildHelper	这个类通常在实现NestedScrollingChild接口的View里面辅助使用，它通常用来负责子View产生的嵌套滑动事件报告给父View。也就是说，一个子View想要把产生的嵌套滑动事件交给父View，那么NestedScrollingChildHelper会帮我们来处理。
NestedScrollingParentHelper	与上述类似，都是传递事件的辅助类。通常用在实现了NestedScrollingParent接口的父View，如果父View不想处理这个事件，就通过NestedScrollingParentHelper传递

3.1 ACTION_DOWN事件

结合RecyclerView的源码来分析嵌套事件传递原理，先来看看RecyclerView的ACTION_DOWN事件的处理：

RecyclerView.java

   case MotionEvent.ACTION_DOWN: {
        int nestedScrollAxis = ViewCompat.SCROLL_AXIS_NONE;
        if (canScrollHorizontally) {
            nestedScrollAxis |= ViewCompat.SCROLL_AXIS_HORIZONTAL;
        }
        if (canScrollVertically) {
            nestedScrollAxis |= ViewCompat.SCROLL_AXIS_VERTICAL;
        }
        //开始嵌套滑动
        startNestedScroll(nestedScrollAxis, TYPE_TOUCH);
    } break;

初始化nestedScrollAxis(线性方向)变量后，就会调用startNestedScroll()告诉父View滑动事件已经开始，你是否需要有所行动，可以看到嵌套滑动事件是从下往上传递的。它是怎么将一个事件传递到父View的呢？

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

事件是通过NestedScrollingChildHelper帮助类传递的，通过NestedScrollingChildHelper实例调用startNestedScroll()：

NestedScrollingChildHelper.java

    public boolean startNestedScroll(@ScrollAxis int axes, @NestedScrollType int type) {
        if (hasNestedScrollingParent(type)) {//嵌套滑动进行中，直接返回true
            // Already in progress
            return true;
        }
        if (isNestedScrollingEnabled()) {//父View是否支持嵌套滑动
            ViewParent p = mView.getParent();
            View child = mView;
            //while循环获取上级的view，看是否支持嵌套滑动，如果支持则返回true，结束循环；不支持则继续访问上层View。
            while (p != null) {
            	//这里调用父View的方法，如果父View运行嵌套滑动则返回true,之后会消耗掉部分子View传上来的滑动距离。
                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;
    }

这里首先经过hasNestedScrollingParent()来判断父View是否正在进行嵌套滑动，父View必须实现NestedScrollingParent接口，onStartNestedScroll()方法返回true，如果父View不能够处理嵌套滑动事件时，就会while()递归往上找。NestedScrollingChildHelper有依靠ViewParentCompat类帮助传递事件，实际上ViewParentCompat也帮我们调用父View的onStartNestedScroll()方法，这样做的目的是为了兼容不同的版本。前面说过，在Android5.0开始View实现了NestScrollingChild接口，但是5.0以下版本需要自己手动实现。

3.2 ViewParentCompat

事件是如何传递到父View的呢？ViewParentCompat作为系统兼容扮演着重要的角色，它是如何保证系统兼容的呢？

ViewParentCompat.java

   public static void onNestedScroll(ViewParent parent, View target, int dxConsumed,
            int dyConsumed, int dxUnconsumed, int dyUnconsumed, int type,
            @NonNull int[] consumed) {
		//如果我们调用的是小于NestedScrollingParent3的函数，那么将未使用的距离添加到已使用的参数中，这样调用NestedScrollingChild3实现就会被告知整个滚动距离已被使用(用于向后比较)。
        if (parent instanceof NestedScrollingParent3) {
            ((NestedScrollingParent3) parent).onNestedScroll(target, dxConsumed, dyConsumed,
                    dxUnconsumed, dyUnconsumed, type, consumed);
        } else {
            if (parent instanceof NestedScrollingParent2) {
                ((NestedScrollingParent2) parent).onNestedScroll(target, dxConsumed, dyConsumed,
                        dxUnconsumed, dyUnconsumed, type);
            } else if (type == ViewCompat.TYPE_TOUCH) {
                //如果类型是默认的(触摸)，尝试NestedScrollingParent API
                if (Build.VERSION.SDK_INT >= 21) {
                    parent.onNestedScroll(target, dxConsumed, dyConsumed, dxUnconsumed,
                                dyUnconsumed);
                } else if (parent instanceof NestedScrollingParent) {
                    ((NestedScrollingParent) parent).onNestedScroll(target, dxConsumed, dyConsumed,
                            dxUnconsumed, dyUnconsumed);
                }
            }
        }
    }

其中NestedScrollingParent3继承自NestedScrollingParent2，NestedScrollingParent2继承自NestedScrollingParent，如果parent实现了NestedScrollingParent3的接口则调用NestedScrollingParent3中的onNestedScroll()；如果parent实现了NestedScrollingParent2的接口则调用NestedScrollingParent2中的onNestedScroll()；如果parent实现了NestedScrollingParent的接口则调用NestedScrollingParent中的onNestedScroll()；如果版本在Android5.0以上则直接调用parent的onNestedScroll()。

该方法是对正在进行的嵌套滑动做出响应，将滚动距离的已使用部分和未使用部分报告给ViewParent。所以一个父View想要接收子View传递过来的事件，就的实现NestedScrollingParent等相关接口。

3.3 ACTION_MOVE事件

在ACTION_DOWN中涉及的嵌套滑动流程就是NestedScrollingChildHelper初始化，寻找支持嵌套滑动的父级View，接下来在ACTION_MOVE中将滑动的距离首先交给这个找到的父View，父View会将消耗的滑动距离写入到传入的参数中，之后RecycleView会知道滑动的距离是否被父View消耗掉，来决定RecycleView的滑动是否更新。

RecyclerView.java

    case MotionEvent.ACTION_MOVE:{
        if (dispatchNestedPreScroll(
                canScrollHorizontally ? dx : 0,
                canScrollVertically ? dy : 0,
                mReusableIntPair, mScrollOffset, TYPE_TOUCH
        )) 
    } break;
    
    @Override
    public boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow,
            int type) {
        return getScrollingChildHelper().dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow,
                type);
    }

主要是通过ScrollingChildHelper类调用dispatchNestedPreScroll()方法：

ScrollingChildHelper.java

   public boolean dispatchNestedPreScroll(int dx, int dy, @Nullable int[] consumed,
            @Nullable int[] offsetInWindow, @NestedScrollType int type) {
        if (isNestedScrollingEnabled()) {
        	//之前嵌套滑动的父View不匹配就直接返回
            final ViewParent parent = getNestedScrollingParentForType(type);
            if (parent == null) {
                return false;
            }

            if (dx != 0 || dy != 0) {
                int startX = 0;
                int startY = 0;
                //offsetInWindow为非空就将view的坐标写入数组中
                if (offsetInWindow != null) {
                    mView.getLocationInWindow(offsetInWindow);
                    startX = offsetInWindow[0];
                    startY = offsetInWindow[1];
                }

                if (consumed == null) {
                    consumed = getTempNestedScrollConsumed();
                }
                consumed[0] = 0;
                consumed[1] = 0;
                //回调父View相关方法，将消耗的数据写入consumed数组中
                ViewParentCompat.onNestedPreScroll(parent, mView, dx, dy, consumed, type);

                if (offsetInWindow != null) {
                    mView.getLocationInWindow(offsetInWindow);
                    offsetInWindow[0] -= startX;
                    offsetInWindow[1] -= startY;
                }
                //父View消耗了dy或者dx就返回true
                return consumed[0] != 0 || consumed[1] != 0;
            } else if (offsetInWindow != null) {
                offsetInWindow[0] = 0;
                offsetInWindow[1] = 0;
            }
        }
        return false;
    }

3.4 ACTION_UP事件

ACTION_UP根据手指抬起的X，Y抬起的速度来判断是否需要执行惯性滑动fling()：

RecyclerView.java

    case MotionEvent.ACTION_UP: {
        final float yvel = canScrollVertically
                ? -mVelocityTracker.getYVelocity(mScrollPointerId) : 0;
        if (!((xvel != 0 || yvel != 0) && fling((int) xvel, (int) yvel))) {
            setScrollState(SCROLL_STATE_IDLE);
        }
        resetScroll();
    } break;

主要方法是在fling()中：

    public boolean fling(int velocityX, int velocityY) {
		······
		//如果父View未消耗本次的fling
        if (!dispatchNestedPreFling(velocityX, velocityY)) {
            final boolean canScroll = canScrollHorizontal || canScrollVertical;
            //嵌套的惯性滑动
            dispatchNestedFling(velocityX, velocityY, canScroll);

            if (mOnFlingListener != null && mOnFlingListener.onFling(velocityX, velocityY)) {
                return true;
            }
			//如果还可以滚动，就使用recyclerview自己的机制来实现一段惯性滑动
            if (canScroll) {
                int nestedScrollAxis = ViewCompat.SCROLL_AXIS_NONE;
                if (canScrollHorizontal) {
                    nestedScrollAxis |= ViewCompat.SCROLL_AXIS_HORIZONTAL;
                }
                if (canScrollVertical) {
                    nestedScrollAxis |= ViewCompat.SCROLL_AXIS_VERTICAL;
                }
                startNestedScroll(nestedScrollAxis, TYPE_NON_TOUCH);

                velocityX = Math.max(-mMaxFlingVelocity, Math.min(velocityX, mMaxFlingVelocity));
                velocityY = Math.max(-mMaxFlingVelocity, Math.min(velocityY, mMaxFlingVelocity));
                //根据计算速度实现惯性滑动
                mViewFlinger.fling(velocityX, velocityY);
                return true;
            }
        }
        return false;
    }

这里如果父View的惯性滑动尚未分发的话就dispatchNestedFling()就将嵌套的fling操作分发给父View。

NestedScrollingChildHelper.java

    public boolean dispatchNestedFling(float velocityX, float velocityY, boolean consumed) {
        if (isNestedScrollingEnabled()) {
        	//根据类型获取parent
            ViewParent parent = getNestedScrollingParentForType(TYPE_TOUCH);
            if (parent != null) {
                return ViewParentCompat.onNestedFling(parent, mView, velocityX,
                        velocityY, consumed);
            }
        }
        return false;
    }

最后调用ViewParentCompat的onNestedFling()方法：

ViewParentCompat.java

    public static boolean onNestedFling(ViewParent parent, View target, float velocityX,
            float velocityY, boolean consumed) {
        if (Build.VERSION.SDK_INT >= 21) {
            return parent.onNestedFling(target, velocityX, velocityY, consumed);
        } else if (parent instanceof NestedScrollingParent) {
            return ((NestedScrollingParent) parent).onNestedFling(target, velocityX, velocityY,
                    consumed);
        }
        return false;
    }

如果在Android5.0以上则直接调用父view的onNestedFling()方法，如果在在Android5.0以下则调用父View实现的NestedScrollingParent接口中的onNestedFling()方法。(有关RecyclerView的惯性滑动相关原理可以参考理解RecyclerView(六))

画图总结RecyclerViewonTouchEvent()的嵌套滑动流程：

简单总结RecyclerView嵌套滑动：
1.嵌套滑动事件由子View传递给父View，从下到上分发；
2.如果一个view想要传递嵌套滑动事件，实现NestedScrollingChild接口，并且支持嵌套滑动；如果父View想要支持嵌套滑动事件，必须实现NestedScrollingParent接口。

四、总结

1.CoordinatorLayout是一个普通的ViewGroup，也是一个超级FrameLayout，能通过Behavior与child交互；

2.在Behavior中的layoutDepentOn()返回true或者通过xml指定目标控件来确定两个View的依赖关系，当依赖方的尺寸和位置发生变化时，Behavior中onDependentViewChanged()就会被调用，如果改变了主动依赖的View的尺寸和位置，方法返回true；

3.Behavior是一种插件机制，可以决定CoordinatorLayout对应childview的测量尺寸，布局位置，触摸响应；如果没有Behavior的存在CoordinatorLayout与普通的FrameLayout没有区别；

4.嵌套滑动分为nested scroll和 fling 两种，childView是否接受响应由onStartNestedScroll()返回值决定，一般在startNestedScroll()处理相应的nested scroll事件，在onNestedFling()处理fling事件；

5.RecyclerView能够产生嵌套滑动事件是因为实现了NestedScrollingChild接口，CoordinatorLayout能够响应嵌套滑动事件是因为实现了NestedScrollingParent接口；由childView发起，通过由下向上循环遍历parent，借助parent的嵌套滑动相关方法来完成交互。

  到这里一个嵌套滑动的起始才彻底水落石出，RecyclerView实现NestedScrollingChild接口，发起嵌套滑动时(Android5.0以下需要setNestedScrollEnable(true))，由下向上循环遍历自己的parent，parent实现NestedScrollingParent接口，parent调用onStartNestedScroll()，进而调用CoordinatorLayout 的onStartNestedScroll()方法，CoordinatorLayout里面其实调用了Behavior中的onStartNestedScroll()，告知ViewParent是否对嵌套滑动事件感兴趣，如果返回true，CoordinatorLayout 中的嵌套滑动事件才会被响应。(Android5.0以下parent必须实现NestedScrollingParent接口 )

用一张图来概念更加清晰：

源码地址

点关注，不迷路

---

好了各位，以上就是这篇文章的全部内容了，能看到这里的人呀，都是人才。

我是suming，感谢各位的支持和认可，您的点赞、评论、收藏【一键三连】就是我创作的最大动力，我们下篇文章见！

如果本篇博客有任何错误，请批评指教，不胜感激 ！

要想成为一个优秀的安卓开发者，这里有必须要掌握的知识架构，一步一步朝着自己的梦想前进！Keep Moving!

相关文章：

理解RecyclerView(五)

 ● RecyclerView的绘制流程

理解RecyclerView(六)

 ● RecyclerView的滑动原理

理解RecyclerView(七)

 ● RecyclerView的嵌套滑动机制

理解RecyclerView(八)

 ● RecyclerView的回收复用缓存机制详解

理解RecyclerView(九)

 ● RecyclerView的自定义LayoutManager