我们这次来个有些难度的，这个例子涉及到数据计算啦，把本次的例子学好，自定义 Behavior 就学会一般了。

本次的例子，仿开眼：

我实现的效果：

ezgif.com-video-to-gif.gif

如何消费滚动数值和判断滑动方向

在学习本次的例子之前有个很重要的事情要搞清楚，那就是如何判断滑动的方向呢，这里我们就要重点看看这2个方法了：

 /**
     * 进行嵌套滚动时被调用
     * @param coordinatorLayout
     * @param child
     * @param target
     * @param dxConsumed target 已经消费的x方向的距离
     * @param dyConsumed target 已经消费的y方向的距离
     * @param dxUnconsumed x 方向剩下的滚动距离
     * @param dyUnconsumed y 方向剩下的滚动距离
     */
    @Override
    public void onNestedScroll(CoordinatorLayout coordinatorLayout, View child, View target, int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed) {
        super.onNestedScroll(coordinatorLayout, child, target, dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed);
    }

/**
     * 嵌套滚动发生之前被调用
     * 在nested scroll child 消费掉自己的滚动距离之前，嵌套滚动每次被nested scroll child
     * 更新都会调用onNestedPreScroll。注意有个重要的参数consumed，可以修改这个数组表示你消费
     * 了多少距离。假设用户滑动了100px,child 做了90px 的位移，你需要把 consumed［1］的值改成90，
     * 这样coordinatorLayout就能知道只处理剩下的10px的滚动。
     * @param coordinatorLayout
     * @param child
     * @param target
     * @param dx  用户水平方向的滚动距离
     * @param dy  用户竖直方向的滚动距离
     * @param consumed
     */
    @Override
    public void onNestedPreScroll(CoordinatorLayout coordinatorLayout, View child, View target, int dx, int dy, int[] consumed) {
        super.onNestedPreScroll(coordinatorLayout, child, target, dx, dy, consumed);
    }

不知道大家对 onNestedPreScroll 和 onNestedScroll 还有多少印象，这2个方法可是核心方法啊，在这2个方法中我们可以消费滚动事件的啊。

在这2个方法中有4个重要的参数：

• dx / dy
  onNestedPreScroll 中的参数，这个方法是在滚动控件消费滚动数据之前询问其他参与嵌套滚动的控件要不要先于滚动控件消费滚动事件。dx / dy 就表示 x / y 轴的滚动量
• consumed
  也是onNestedPreScroll 中的参数，这是一个数组，表示参与嵌套滚动的控件先于滚动控件消费的滚动数值是多少， [0] 表示 x 轴的，[1] 表示 y 轴的。举个例子，若这里 dx = 100， consumed[0] = 80，那么表示嵌套控件已经消费了80个像素，滚动控件比如列表就只能消费生息的20个像素了，也就是只能滚动20个像素。这点很重要的，一会要用的。
• dxConsumed / dyConsumed
  onNestedScroll 的参数，这个方法是滚动控件比如列表在消费完滚动数值后，询问嵌套控件还要不要消费同等的滚动数值，注意滚动控件消费完滚动数值后，相同的滚动数值会传递给嵌套控件，而不是同上个方法一样，会直接消失掉。这点也是很好理解的，就是给跟随滚动控件滚动的 view 设计的。dxConsumed / dyConsumed 表示滚动控件在 x / y 轴上实际消费了多少。
• dxUnconsumed / dyUnconsumed
  也是onNestedScroll 的参数，表示滚动控件在 x / y 轴上没有消费的数值有多少，和上面的数据值是相反的意思。一个滚动事件下来，滚动控件比如滚动到头了，就不能继续再滚动消费滚动数值了，那么就产生了这组参数，表示有多少滚动值没有呗消费。使用这2组参数我们可以判断滚动控件的滚动状态

看这里：

if (dyConsumed > 0 && dyUnconsumed == 0) {
    System.out.println("上滑中。。。");
}
if (dyConsumed == 0 && dyUnconsumed > 0) {
    System.out.println("到边界了还在上滑。。。");
}
if (dyConsumed < 0 && dyUnconsumed == 0) {
    System.out.println("下滑中。。。");
}
if (dyConsumed == 0 && dyUnconsumed < 0) {
    System.out.println("到边界了，还在下滑。。。");
}

这样我们就能判断滚动方向，还有滚动控件是不是滚动到头了。控件在滚动到头时，手指可以还在继续滑动的，这时，滚动事件还是在产生的，只不过没有再被滚动控件消费了。

分析开眼思路

看过上面的方法使用，参数意义，我们就可以来完成本次例子啦。

按照逻辑分成2个思考段落：

• 上滑时遮挡 head，并且 head 会从不透明 -> 半透明
• 下滑时露出 head，并且 head 会从半透明 -> 不透明

但是呢，在这之前，我们要知道一点，CoordinatorLayout 是一个 FrameLayout 帧布局，不能设置谁在谁的那部分，幸好 google 想到了，Behavior 里面有布局相关的生命周期，onLayoutChild ，我们可以在这个方法里对列表进行重新布局，让他在 head 的下方，这里给列表加上一个 headHeight 高度的 translationY 即可。

@Override
    public boolean onLayoutChild(CoordinatorLayout parent, View child, int layoutDirection) {

        mViewHead = parent.findViewById(R.id.kaiyan_appbar);

        CoordinatorLayout.LayoutParams layoutParams = (CoordinatorLayout.LayoutParams) child.getLayoutParams();
        if (layoutParams != null && layoutParams.height == CoordinatorLayout.LayoutParams.MATCH_PARENT) {
            child.layout(0, 0, layoutParams.width, layoutParams.height);
            child.setTranslationY(getAppBarHeight());
        }

        return super.onLayoutChild(parent, child, layoutDirection);
    }

上滑时

上滑时我们需要列表不滚动，而是向上位移，遮挡 head，所以我们要在滚动控件之前消费滚动数据，所以选择在 onNestedPreScroll 这个方法中操作，代码如下：

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

        // 在嵌套滚动开始之前，我们在这里进行上滑处理，先于滚动消费掉滚动数据，这里就是指我们上移列表，这样我们上移列表了，列表就不会再滚动了
        float translationY = child.getTranslationY();
        float offsetaAlphe = 0;

        if (dy > 0 && translationY > 0) {

            // 进行列表的位移
            float offestY = translationY - dy;
            Log.d("AAA", "translationY:" + translationY + " / dy:" + dy);

            if (offestY < 0) {
                // 说明此时Y轴线的偏移量不足本次一帧时间内的滑动量，所以需要特别处理一下
                Log.d("AAA", "AAA");
                offestY = 0;
                consumed[1] = (int) translationY;
            } else {
                Log.d("AAA", "BBB:");
                offestY = translationY - dy;
                consumed[1] = dy;
            }
            Log.d("AAA", "translationY:" + offestY);
            child.setTranslationY(offestY);

            // 进行头部的透明度变化
            if (mViewHead != null) {
                offsetaAlphe = 0.5f + 0.5f * (translationY / getAppBarHeight());
                mViewHead.setAlpha(offsetaAlphe);
            }

        }
        super.onNestedPreScroll(coordinatorLayout, child, target, dx, dy, consumed);
    }

思路：

• 当 dy > 0 时，说明列表向上滚动
• 这时我们获取列表的在 Y 轴的偏移量 float translationY = child.getTranslationY()
• translationY = headHeight 在起始时是等于 head 的高度的，这是我们在 onLayoutChild 时对列表的位置的调整，在 head 的底下
• 手指上移，translationY 的变化是从 headHeight -> 0 的变化过程，在 translationY = 0时 ，说明 head 已经被全部遮挡了
• translationY 从 headHeight -> 0 的过程中，我们一直让 translationY = translationY - dy，并且 consumed[1] = dy (拦截滚动数据)，这样我们这样就会让列表上移，先消费掉滚动数据并且通过 consumed[1] = dy 生命滚动已经被消费了，就能使滚动控件接受到的滚动数据 = 0，从而不进行滚动。
• 当 translationY = 0，我们不再拦截滚动数值，不再位移列表，让列表自己滚动就行
• 注意一点，网上其他的例子都有这个问题，在向上位移列表的最后一次，有可能剩下的偏移量比手指滚动的数据小，从而使我们忽略这次拦截这次滚动，使translationY 一直会有一点数值，不能 = 0，让列表的顶上一直有一小段 head 露出来，这里我们需要做下处理下
• 注意代码里有一些边界值处理，我的经验，别管用得上，用不上的，直接写上，会减少那些莫名其妙的滑动，减少bug，节省我们的精力。

下滑时

下滑时我们需要列表不滚动，而是向下位移，露出 head来，这个就不能写在上面哪个函数里了，大家想，只有列表滚动会头部，不能再往上滚动了，才应该把 head 露出来不是，所以选择在 onNestedScroll 这个方法中操作，代码如下：

@Override
    public void onNestedScroll(CoordinatorLayout coordinatorLayout, View child, View target, int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed) {
        super.onNestedScroll(coordinatorLayout, child, target, dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed);

        int appBarHeight = getAppBarHeight();
        float offestY = 0;
        float translationY = child.getTranslationY();
        float offsetaAlphe = 0;

        if (dyUnconsumed < 0 && translationY < appBarHeight) {

            // 进行列表的位移
            offestY = translationY + Math.abs(dyUnconsumed);
            if (offestY < 0) {
                offestY = 0;
            }
            if (offestY >= appBarHeight) {
                offestY = appBarHeight;
            }
            child.setTranslationY(offestY);

            // 进行头部的透明度变化
            if (mViewHead != null) {
                if (translationY > appBarHeight) {
                    translationY = appBarHeight;
                }
                offsetaAlphe = 0.5f + 0.5f * (translationY / getAppBarHeight());
                mViewHead.setAlpha(offsetaAlphe);
            }
        }
    }

思路，和上面的差不多，就不说太详细了：

• 当 dyUnconsumed < 0 ，说明啥，说米给你手指下滑，并且列表下滑到头了，这时候我们就要让 head 露出来啦。
• 注意透明度值的计算，透明度不能大于1啊
• 同理还是要注意边界值处理。

全部代码：

<?xml version="1.0" encoding="utf-8"?>
<android.support.design.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">

    <ImageView
        android:id="@+id/kaiyan_appbar"
        android:layout_width="match_parent"
        android:layout_height="@dimen/app_bar_height"
        android:scaleType="centerCrop"
        android:src="@mipmap/x001"/>

    <android.support.v4.widget.NestedScrollView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="@color/colorAccent"
        app:layout_behavior="@string/kaiyan_nestlist_behavior">

        <TextView
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:layout_margin="@dimen/text_margin"
            android:text="@string/large_text"
            android:textColor="@android:color/white"/>

    </android.support.v4.widget.NestedScrollView>

</android.support.design.widget.CoordinatorLayout>

public class KaiYanAppBarBehavior extends CoordinatorLayout.Behavior {

    private Context mContext;
    private View mViewHead;
    private int appbarHeight = 0;

    public KaiYanAppBarBehavior(Context context, AttributeSet attrs) {
        super(context, attrs);
        mContext = context;
    }

    @Override
    public boolean onLayoutChild(CoordinatorLayout parent, View child, int layoutDirection) {

        mViewHead = parent.findViewById(R.id.kaiyan_appbar);

        CoordinatorLayout.LayoutParams layoutParams = (CoordinatorLayout.LayoutParams) child.getLayoutParams();
        if (layoutParams != null && layoutParams.height == CoordinatorLayout.LayoutParams.MATCH_PARENT) {
            child.layout(0, 0, layoutParams.width, layoutParams.height);
            child.setTranslationY(getAppBarHeight());
        }

        return super.onLayoutChild(parent, child, layoutDirection);
    }

    @Override
    public boolean onStartNestedScroll(CoordinatorLayout coordinatorLayout, View child, View directTargetChild, View target, int nestedScrollAxes) {
        return nestedScrollAxes == ViewCompat.SCROLL_AXIS_VERTICAL;
    }

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

        // 在嵌套滚动开始之前，我们在这里进行上滑处理，先于滚动消费掉滚动数据，这里就是指我们上移列表，这样我们上移列表了，列表就不会再滚动了
        float translationY = child.getTranslationY();
        float offsetaAlphe = 0;

        if (dy > 0 && translationY > 0) {

            // 进行列表的位移
            float offestY = translationY - dy;
            Log.d("AAA", "translationY:" + translationY + " / dy:" + dy);

            if (offestY < 0) {
                // 说明此时Y轴线的偏移量不足本次一帧时间内的滑动量，所以需要特别处理一下
                Log.d("AAA", "AAA");
                offestY = 0;
                consumed[1] = (int) translationY;
            } else {
                Log.d("AAA", "BBB:");
                offestY = translationY - dy;
                consumed[1] = dy;
            }
            Log.d("AAA", "translationY:" + offestY);
            child.setTranslationY(offestY);

            // 进行头部的透明度变化
            if (mViewHead != null) {
                offsetaAlphe = 0.5f + 0.5f * (translationY / getAppBarHeight());
                mViewHead.setAlpha(offsetaAlphe);
            }

        }
        super.onNestedPreScroll(coordinatorLayout, child, target, dx, dy, consumed);
    }

    @Override
    public void onNestedScroll(CoordinatorLayout coordinatorLayout, View child, View target, int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed) {
        super.onNestedScroll(coordinatorLayout, child, target, dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed);

        int appBarHeight = getAppBarHeight();
        float offestY = 0;
        float translationY = child.getTranslationY();
        float offsetaAlphe = 0;

        if (dyUnconsumed < 0 && translationY < appBarHeight) {

            // 进行列表的位移
            offestY = translationY + Math.abs(dyUnconsumed);
            if (offestY < 0) {
                offestY = 0;
            }
            if (offestY >= appBarHeight) {
                offestY = appBarHeight;
            }
            child.setTranslationY(offestY);

            // 进行头部的透明度变化
            if (mViewHead != null) {
                if (translationY > appBarHeight) {
                    translationY = appBarHeight;
                }
                offsetaAlphe = 0.5f + 0.5f * (translationY / getAppBarHeight());
                mViewHead.setAlpha(offsetaAlphe);
            }
        }
    }

    @Override
    public boolean onNestedPreFling(CoordinatorLayout coordinatorLayout, View child, View target, float velocityX, float velocityY) {
        Log.d("AAA", "onNestedPreFling:" + velocityY);
        return super.onNestedPreFling(coordinatorLayout, child, target, velocityX, velocityY);
    }

    private int getAppBarHeight() {

        if (appbarHeight == 0) {
            if (mViewHead == null) {
                return appbarHeight;
            }
            appbarHeight = mViewHead.getMeasuredHeight();
            if (appbarHeight == 0) {
                mViewHead.measure(0, 0);
                appbarHeight = mViewHead.getMeasuredHeight();
            }
        }
        return appbarHeight;
//        return mContext.getResources().getDimensionPixelOffset(R.dimen.app_bar_height);
    }
}

说在最后

这里我们要明白几点啊，很重要：

1. 我们是给设置的 Behavior ？NestedScrollView 啊，他既然可以产生滚动，为啥还可以加 Behavior 啊？不知道大家还记 android ui 学习系列 -自定义Behavior (1) - 相关原理 的那张图，NestedScrollView 可是即实现了 NestedScrollingChild 接口发送滚动事件，也同样实现了 NestedScrollingParent 接口拦截消费滚动事件的。哈哈，有点绕哈，但是 google 的 nestedscroll 嵌套滚动，核心就是拦截滚动，优先滚动控件去消费滚动数据，走别人的路让别人无路可走的思路，要不泽呢嘛实现嵌套的效果啊。大家想滚动发生了肯定有一个人要去消费，这里我们决定的是谁，是优先消费，还是跟随消费。
2. 这里参与嵌套滚动的只有2个 view，所以写法很粗暴，虽然是用 Behavior 写的，看似解耦，但是对于 head 来说并没有解耦啊。思路类似于传统的监听控件的滚动事件，在滚动经停对象里面去操作数据，控制其他的 view，本质和 Behavior 是冲突的。Behavior 的思路是解耦，相关的每个 view 都把自己的滚动逻辑抽象到 Behavior 里面，可以做到动态的替换 view，而不用更改代码。这个例子没有达到这样的高度，主要是为了让大家学习有个循序渐进的过程，至于如何 实现每个 view 都有自己的 Behavior 这样的解耦效果，那就要看下一个例子啦。下一篇我们学习 Behavior 的这2个方法： layoutDependsOn / onDependentViewChanged

demo 地址: github

参考资料：

• Material Design 之 Behavior的使用和自定义Behavior
• 使用 CoordinatorLayout 实现复杂联动效果