[关闭]
@xujun94 2017-05-12T07:12:08.000000Z 字数 20358 阅读 1984

自定义 Behavior -仿 新浪微博发现页的实现

效果图

我们先来看一下新浪微博发现页的效果：

接下来我们在来看一下我们仿照新浪微博实现的效果

仿新浪微博效果图

实现思路分析

我们这里先定义两种状态，open 和 close 状态。

从效果图，我们可以看到 在 open 状态下，我们向上滑动 ViewPager 里面的 RecyclerView 的 时候，RecyclerView 并不会向上移动（RecyclerView 的滑动事件交给 外部的容器处理，被被全部消费掉了），而是整个布局（指 Header + Tab +ViewPager）会向上偏移 。当 Tab 滑动到顶部的时候，我们向上滑动 ViewPager 里面的 RecyclerView 的时候，RecyclerView 可以正常向上滑动，即此时外部容器没有拦截滑动事件。

同时我们可以看到在 open 状态的时候，我们是不支持下拉刷新的，这个比较容易实现，监听页面的状态，如果是 open 状态，我们设置 SwipeRefreshLayout setEnabled 为 false，这样不会 拦截事件，在页面 close 的时候，设置 SwipeRefreshLayout setEnabled 为 TRUE，这样就可以支持下拉刷新了。

基于上面的分析，我们这里可以把整个效果划分为两个部分，第一部分为 Header，第二部分为 Tab+ViewPager。下文统一把第一部分称为 Header，第二部分称为 Content 。

需要实现的效果为：在页面状态为 open 的时候，向上滑动 Header 的时候，整体向上偏移，ViewPager 里面的 RecyclerView 向上滑动的时候，消费其滑动事件，并整体向上移动。在页面状态为 close 的时候，不消耗 RecyclerView 的 滑动事件。

在上一篇博客 一步步带你读懂 CoordinatorLayout 源码 中，我们有提到在 CoordinatorLayout中，我们可以通过 给子 View 自定义 Behavior 来处理事件。它是一个容器，实现了 NestedScrollingParent 接口。它并不会直接处理事件，而是会尽可能地交给子 View 的 Behavior 进行处理。因此，为了减少依赖，我们把这两部分的关系定义为 Content 依赖于 Header。Header 移动的时候，Content 跟着 移动。所以，我们在处理滑动事件的时候，只需要处理好 Header 部分的 Behavior 就oK了，Content 部分的 Behavior 不需要处理滑动事件，只需依赖于 Header ，跟着做相应的移动即可。

Header 部分的实现

Header 部分实现的两个关键点在于

  1. 在页面状态为 open 的时候，ViewPager 里面的 RecyclerView 向上滑动的时候，消费其滑动事件，并整体向上移动。在页面状态为 close 的时候，不消耗 RecyclerView 的 滑动事件
  2. 在页面状态为 open 的时候，向上滑动 Header 的时候，整体向上偏移。

第一个关键点的实现

这里区分页面状态是 open 还是 close 状态是通过 Header 是否移除屏幕来区分的，即 child.getTranslationY() == getHeaderOffsetRange() 。

  1. private boolean isClosed(View child) {
  2.     boolean isClosed = child.getTranslationY() == getHeaderOffsetRange();
  3.     return isClosed;
  4. }

在NestedScrolling 机制深入解析博客中，我们对 NestedScrolling 机制做了如下的总结。

而 RecyclerView 也是 Scrolling Child （实现了 NestedScrollingChild 接口），RecyclerView 在开始滑动的 时候会先调用 CoordinatorLayout 的 startNestedScroll 方法，而 CoordinatorLayout 会 调用子 View 的 Behavior 的 startNestedScroll 方法。并且只有 boolean startNestedScroll 返回 TRUE 的 时候，才会调用接下里 Behavior 中的 onNestedPreScroll 和 onNestedScroll 方法。

所以，我们在 WeiboHeaderPagerBehavior 的 onStartNestedScroll 方法可以这样写，可以确保 只拦截垂直方向上的滚动事件，且当前状态是打开的并且还可以继续向上收缩的时候还会拦截

  1. @Override
  2. public boolean onStartNestedScroll(CoordinatorLayout coordinatorLayout, View child, View
  3.         directTargetChild, View target, int nestedScrollAxes) {
  4.     if (BuildConfig.DEBUG) {
  5.         Log.d(TAG, "onStartNestedScroll: nestedScrollAxes=" + nestedScrollAxes);
  6.     }
  8.     boolean canScroll = canScroll(child, 0);
  9.     //拦截垂直方向上的滚动事件且当前状态是打开的并且还可以继续向上收缩
  10.     return (nestedScrollAxes & ViewCompat.SCROLL_AXIS_VERTICAL) != 0 && canScroll &&
  11.             !isClosed(child);
  13. }

拦截事件之后，我们需要在 RecyclerView 滑动之前消耗事件，并且移动 Header，让其向上偏移。

  1. @Override
  2. public void onNestedPreScroll(CoordinatorLayout coordinatorLayout, View child, View target,
  3.                               int dx, int dy, int[] consumed) {
  4.     super.onNestedPreScroll(coordinatorLayout, child, target, dx, dy, consumed);
  5.     //dy>0 scroll up;dy<0,scroll down
  6.     Log.i(TAG, "onNestedPreScroll: dy=" + dy);
  7.     float halfOfDis = dy;
  8.     //    不能滑动了，直接给 Header 设置 终值，防止出错
  9.     if (!canScroll(child, halfOfDis)) {
  10.         child.setTranslationY(halfOfDis > 0 ? getHeaderOffsetRange() : 0);
  11.     } else {
  12.         child.setTranslationY(child.getTranslationY() - halfOfDis);
  13.     }
  14.     //consumed all scroll behavior after we started Nested Scrolling
  15.     consumed[1] = dy;
  16. }

当然，我们也需要处理 Fling 事件，在页面没有完全关闭的 时候，消费所有 fling 事件。

  1. @Override
  2. public boolean onNestedPreFling(CoordinatorLayout coordinatorLayout, View child, View target,
  3.                                 float velocityX, float velocityY) {
  4.     // consumed the flinging behavior until Closed
  5.     return !isClosed(child);
  6. }

至于滑动到顶部的动画，我是通过 mOverScroller + FlingRunnable 来实现的 。

  1. public class WeiboHeaderPagerBehavior extends ViewOffsetBehavior {
  2.     private static final String TAG = "UcNewsHeaderPager";
  3.     public static final int STATE_OPENED = 0;
  4.     public static final int STATE_CLOSED = 1;
  5.     public static final int DURATION_SHORT = 300;
  6.     public static final int DURATION_LONG = 600;
  8.     private int mCurState = STATE_OPENED;
  9.     private OnPagerStateListener mPagerStateListener;
  11.     private OverScroller mOverScroller;
  13.     private WeakReference<CoordinatorLayout> mParent;
  14.     private WeakReference<View> mChild;
  16.     public void setPagerStateListener(OnPagerStateListener pagerStateListener) {
  17.         mPagerStateListener = pagerStateListener;
  18.     }
  20.     public WeiboHeaderPagerBehavior() {
  21.         init();
  22.     }
  24.     public WeiboHeaderPagerBehavior(Context context, AttributeSet attrs) {
  25.         super(context, attrs);
  26.         init();
  27.     }
  29.     private void init() {
  30.         mOverScroller = new OverScroller(BaseAPP.getAppContext());
  31.     }
  33.     @Override
  34.     protected void layoutChild(CoordinatorLayout parent, View child, int layoutDirection) {
  35.         super.layoutChild(parent, child, layoutDirection);
  36.         mParent = new WeakReference<CoordinatorLayout>(parent);
  37.         mChild = new WeakReference<View>(child);
  38.     }
  40.     @Override
  41.     public boolean onStartNestedScroll(CoordinatorLayout coordinatorLayout, View child, View
  42.             directTargetChild, View target, int nestedScrollAxes) {
  43.         if (BuildConfig.DEBUG) {
  44.             Log.d(TAG, "onStartNestedScroll: nestedScrollAxes=" + nestedScrollAxes);
  45.         }
  47.         boolean canScroll = canScroll(child, 0);
  48.         //拦截垂直方向上的滚动事件且当前状态是打开的并且还可以继续向上收缩
  49.         return (nestedScrollAxes & ViewCompat.SCROLL_AXIS_VERTICAL) != 0 && canScroll &&
  50.                 !isClosed(child);
  52.     }
  54.     @Override
  55.     public boolean onNestedPreFling(CoordinatorLayout coordinatorLayout, View child, View target,
  56.                                     float velocityX, float velocityY) {
  57.         // consumed the flinging behavior until Closed
  59.         boolean coumsed = !isClosed(child);
  60.         Log.i(TAG, "onNestedPreFling: coumsed=" +coumsed);
  61.         return coumsed;
  62.     }
  64.     @Override
  65.     public boolean onNestedFling(CoordinatorLayout coordinatorLayout, View child, View target,
  66.                                  float velocityX, float velocityY, boolean consumed) {
  67.         Log.i(TAG, "onNestedFling: velocityY=" +velocityY);
  68.         return super.onNestedFling(coordinatorLayout, child, target, velocityX, velocityY,
  69.                 consumed);
  71.     }
  73.     private boolean isClosed(View child) {
  74.         boolean isClosed = child.getTranslationY() == getHeaderOffsetRange();
  75.         return isClosed;
  76.     }
  78.     public boolean isClosed() {
  79.         return mCurState == STATE_CLOSED;
  80.     }
  82.     private void changeState(int newState) {
  83.         if (mCurState != newState) {
  84.             mCurState = newState;
  85.             if (mCurState == STATE_OPENED) {
  86.                 if (mPagerStateListener != null) {
  87.                     mPagerStateListener.onPagerOpened();
  88.                 }
  90.             } else {
  91.                 if (mPagerStateListener != null) {
  92.                     mPagerStateListener.onPagerClosed();
  93.                 }
  95.             }
  96.         }
  98.     }
  100.     // 表示 Header TransLationY 的值是否达到我们指定的阀值， headerOffsetRange，到达了，返回 false，
  101.     // 否则，返回 true。注意 TransLationY 是负数。
  102.     private boolean canScroll(View child, float pendingDy) {
  103.         int pendingTranslationY = (int) (child.getTranslationY() - pendingDy);
  104.         int headerOffsetRange = getHeaderOffsetRange();
  105.         if (pendingTranslationY >= headerOffsetRange && pendingTranslationY <= 0) {
  106.             return true;
  107.         }
  108.         return false;
  109.     }
  113.     @Override
  114.     public boolean onInterceptTouchEvent(CoordinatorLayout parent, final View child, MotionEvent
  115.             ev) {
  117.         boolean closed = isClosed();
  118.         Log.i(TAG, "onInterceptTouchEvent: closed=" + closed);
  119.         if (ev.getAction() == MotionEvent.ACTION_UP && !closed) {
  120.             handleActionUp(parent,child);
  121.         }
  123.         return super.onInterceptTouchEvent(parent, child, ev);
  124.     }
  126.     @Override
  127.     public void onNestedPreScroll(CoordinatorLayout coordinatorLayout, View child, View target,
  128.                                   int dx, int dy, int[] consumed) {
  129.         super.onNestedPreScroll(coordinatorLayout, child, target, dx, dy, consumed);
  130.         //dy>0 scroll up;dy<0,scroll down
  131.         Log.i(TAG, "onNestedPreScroll: dy=" + dy);
  132.         float halfOfDis = dy;
  133.         //    不能滑动了，直接给 Header 设置 终值，防止出错
  134.         if (!canScroll(child, halfOfDis)) {
  135.             child.setTranslationY(halfOfDis > 0 ? getHeaderOffsetRange() : 0);
  136.         } else {
  137.             child.setTranslationY(child.getTranslationY() - halfOfDis);
  138.         }
  139.         //consumed all scroll behavior after we started Nested Scrolling
  140.         consumed[1] = dy;
  141.     }
  143.     //    需要注意的是  Header 我们是通过 setTranslationY 来移出屏幕的，所以这个值是负数
  144.     private int getHeaderOffsetRange() {
  145.         return BaseAPP.getInstance().getResources().getDimensionPixelOffset(R.dimen
  146.                 .weibo_header_offset);
  147.     }
  149.     private void handleActionUp(CoordinatorLayout parent, final View child) {
  150.         if (BuildConfig.DEBUG) {
  151.             Log.d(TAG, "handleActionUp: ");
  152.         }
  153.         if (mFlingRunnable != null) {
  154.             child.removeCallbacks(mFlingRunnable);
  155.             mFlingRunnable = null;
  156.         }
  157.         mFlingRunnable = new FlingRunnable(parent, child);
  158.         if (child.getTranslationY() < getHeaderOffsetRange() / 6.0f) {
  159.             mFlingRunnable.scrollToClosed(DURATION_SHORT);
  160.         } else {
  161.             mFlingRunnable.scrollToOpen(DURATION_SHORT);
  162.         }
  164.     }
  166.     private void onFlingFinished(CoordinatorLayout coordinatorLayout, View layout) {
  167.         changeState(isClosed(layout) ? STATE_CLOSED : STATE_OPENED);
  168.     }
  170.     public void openPager() {
  171.         openPager(DURATION_LONG);
  172.     }
  174.     /**
  175.      * @param duration open animation duration
  176.      */
  177.     public void openPager(int duration) {
  178.         View child = mChild.get();
  179.         CoordinatorLayout parent = mParent.get();
  180.         if (isClosed() && child != null) {
  181.             if (mFlingRunnable != null) {
  182.                 child.removeCallbacks(mFlingRunnable);
  183.                 mFlingRunnable = null;
  184.             }
  185.             mFlingRunnable = new FlingRunnable(parent, child);
  186.             mFlingRunnable.scrollToOpen(duration);
  187.         }
  188.     }
  190.     public void closePager() {
  191.         closePager(DURATION_LONG);
  192.     }
  194.     /**
  195.      * @param duration close animation duration
  196.      */
  197.     public void closePager(int duration) {
  198.         View child = mChild.get();
  199.         CoordinatorLayout parent = mParent.get();
  200.         if (!isClosed()) {
  201.             if (mFlingRunnable != null) {
  202.                 child.removeCallbacks(mFlingRunnable);
  203.                 mFlingRunnable = null;
  204.             }
  205.             mFlingRunnable = new FlingRunnable(parent, child);
  206.             mFlingRunnable.scrollToClosed(duration);
  207.         }
  208.     }
  210.     private FlingRunnable mFlingRunnable;
  212.     /**
  213.      * For animation , Why not use {@link android.view.ViewPropertyAnimator } to play animation
  214.      * is of the
  215.      * other {@link CoordinatorLayout.Behavior} that depend on this could not receiving the
  216.      * correct result of
  217.      * {@link View#getTranslationY()} after animation finished for whatever reason that i don't know
  218.      */
  219.     private class FlingRunnable implements Runnable {
  220.         private final CoordinatorLayout mParent;
  221.         private final View mLayout;
  223.         FlingRunnable(CoordinatorLayout parent, View layout) {
  224.             mParent = parent;
  225.             mLayout = layout;
  226.         }
  228.         public void scrollToClosed(int duration) {
  229.             float curTranslationY = ViewCompat.getTranslationY(mLayout);
  230.             float dy = getHeaderOffsetRange() - curTranslationY;
  231.             if (BuildConfig.DEBUG) {
  232.                 Log.d(TAG, "scrollToClosed:offest:" + getHeaderOffsetRange());
  233.                 Log.d(TAG, "scrollToClosed: cur0:" + curTranslationY + ",end0:" + dy);
  234.                 Log.d(TAG, "scrollToClosed: cur:" + Math.round(curTranslationY) + ",end:" + Math
  235.                         .round(dy));
  236.                 Log.d(TAG, "scrollToClosed: cur1:" + (int) (curTranslationY) + ",end:" + (int) dy);
  237.             }
  238.             mOverScroller.startScroll(0, Math.round(curTranslationY - 0.1f), 0, Math.round(dy +
  239.                     0.1f), duration);
  240.             start();
  241.         }
  243.         public void scrollToOpen(int duration) {
  244.             float curTranslationY = ViewCompat.getTranslationY(mLayout);
  245.             mOverScroller.startScroll(0, (int) curTranslationY, 0, (int) -curTranslationY,
  246.                     duration);
  247.             start();
  248.         }
  250.         private void start() {
  251.             if (mOverScroller.computeScrollOffset()) {
  252.                 mFlingRunnable = new FlingRunnable(mParent, mLayout);
  253.                 ViewCompat.postOnAnimation(mLayout, mFlingRunnable);
  254.             } else {
  255.                 onFlingFinished(mParent, mLayout);
  256.             }
  257.         }
  259.         @Override
  260.         public void run() {
  261.             if (mLayout != null && mOverScroller != null) {
  262.                 if (mOverScroller.computeScrollOffset()) {
  263.                     if (BuildConfig.DEBUG) {
  264.                         Log.d(TAG, "run: " + mOverScroller.getCurrY());
  265.                     }
  266.                     ViewCompat.setTranslationY(mLayout, mOverScroller.getCurrY());
  267.                     ViewCompat.postOnAnimation(mLayout, this);
  268.                 } else {
  269.                     onFlingFinished(mParent, mLayout);
  270.                 }
  271.             }
  272.         }
  273.     }
  275.     /**
  276.      * callback for HeaderPager 's state
  277.      */
  278.     public interface OnPagerStateListener {
  279.         /**
  280.          * do callback when pager closed
  281.          */
  282.         void onPagerClosed();
  284.         /**
  285.          * do callback when pager opened
  286.          */
  287.         void onPagerOpened();
  288.     }
  290. }

第二个关键点的实现

在页面状态为 open 的时候，向上滑动 Header 的时候，整体向上偏移。

在第一个关键点的实现上，我们是通过自定义 Behavior 来处理 ViewPager 里面 RecyclerView 的移动的，那我们要怎样监听整个 Header 的滑动了。

那就是重写 LinearLayout，将滑动事件交给 ScrollingParent（这里是CoordinatorLayout） 去处理，CoordinatorLayout 再交给子 View 的 behavior 去处理。

  1. public class NestedLinearLayout extends LinearLayout implements NestedScrollingChild {
  3.     private static final String TAG = "NestedLinearLayout";
  5.     private final int[] offset = new int[2];
  6.     private final int[] consumed = new int[2];
  8.     private NestedScrollingChildHelper mScrollingChildHelper;
  9.     private int lastY;
  11.     public NestedLinearLayout(Context context) {
  12.         this(context, null);
  13.     }
  15.     public NestedLinearLayout(Context context, @Nullable AttributeSet attrs) {
  16.         this(context, attrs, 0);
  17.     }
  19.     public NestedLinearLayout(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
  20.         super(context, attrs, defStyleAttr);
  21.         initData();
  22.     }
  24.     private void initData() {
  25.         if (mScrollingChildHelper == null) {
  26.             mScrollingChildHelper = new NestedScrollingChildHelper(this);
  27.             mScrollingChildHelper.setNestedScrollingEnabled(true);
  28.         }
  29.     }
  31.   @Override
  32.     public boolean onInterceptTouchEvent(MotionEvent event) {
  33.         switch (event.getAction()){
  34.             case MotionEvent.ACTION_DOWN:
  35.                 lastY = (int) event.getRawY();
  36.                 // 当开始滑动的时候，告诉父view
  37.                 startNestedScroll(ViewCompat.SCROLL_AXIS_HORIZONTAL
  38.                         | ViewCompat.SCROLL_AXIS_VERTICAL);
  39.                 break;
  40.             case MotionEvent.ACTION_MOVE:
  42.                 return true;
  43.         }
  44.         return super.onInterceptTouchEvent(event);
  45.     }
  47.     @Override
  48.     public boolean onTouchEvent(MotionEvent event) {
  49.         switch (event.getAction()){
  50.             case MotionEvent.ACTION_MOVE:
  51.                 Log.i(TAG, "onTouchEvent: ACTION_MOVE=");
  52.                 int y = (int) (event.getRawY());
  53.                 int dy =lastY- y;
  54.                 lastY = y;
  55.                 Log.i(TAG, "onTouchEvent: lastY=" + lastY);
  56.                 Log.i(TAG, "onTouchEvent: dy=" + dy);
  57.                 //  dy < 0 下拉， dy>0 赏花
  58.                 if (dy >0) { // 上滑的时候才交给父类去处理
  59.                     if (startNestedScroll(ViewCompat.SCROLL_AXIS_VERTICAL) // 如果找到了支持嵌套滚动的父类
  60.                             && dispatchNestedPreScroll(0, dy, consumed, offset)) {//
  61.                         // 父类进行了一部分滚动
  62.                     }
  63.                 }else{
  64.                     if (startNestedScroll(ViewCompat.SCROLL_AXIS_VERTICAL) // 如果找到了支持嵌套滚动的父类
  65.                             && dispatchNestedScroll(0, 0, 0,dy, offset)) {//
  66.                         // 父类进行了一部分滚动
  67.                     }
  68.                 }
  69.                 break;
  70.         }
  71.         return true;
  72.     }
  76.     private NestedScrollingChildHelper getScrollingChildHelper() {
  77.         return mScrollingChildHelper;
  78.     }
  80.     // 接口实现--------------------------------------------------
  82.     @Override
  83.     public void setNestedScrollingEnabled(boolean enabled) {
  84.         getScrollingChildHelper().setNestedScrollingEnabled(enabled);
  85.     }
  87.     @Override
  88.     public boolean isNestedScrollingEnabled() {
  89.         return getScrollingChildHelper().isNestedScrollingEnabled();
  90.     }
  92.     @Override
  93.     public boolean startNestedScroll(int axes) {
  94.         return getScrollingChildHelper().startNestedScroll(axes);
  95.     }
  97.     @Override
  98.     public void stopNestedScroll() {
  99.         getScrollingChildHelper().stopNestedScroll();
  100.     }
  102.     @Override
  103.     public boolean hasNestedScrollingParent() {
  104.         return getScrollingChildHelper().hasNestedScrollingParent();
  105.     }
  107.     @Override
  108.     public boolean dispatchNestedScroll(int dxConsumed, int dyConsumed,
  109.                                         int dxUnconsumed, int dyUnconsumed, int[] offsetInWindow) {
  110.         return getScrollingChildHelper().dispatchNestedScroll(dxConsumed,
  111.                 dyConsumed, dxUnconsumed, dyUnconsumed, offsetInWindow);
  112.     }
  114.     @Override
  115.     public boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed,
  116.                                            int[] offsetInWindow) {
  117.         return getScrollingChildHelper().dispatchNestedPreScroll(dx, dy,
  118.                 consumed, offsetInWindow);
  119.     }
  121.     @Override
  122.     public boolean dispatchNestedFling(float velocityX, float velocityY,
  123.                                        boolean consumed) {
  124.         return getScrollingChildHelper().dispatchNestedFling(velocityX,
  125.                 velocityY, consumed);
  126.     }
  128.     @Override
  129.     public boolean dispatchNestedPreFling(float velocityX, float velocityY) {
  130.         return getScrollingChildHelper().dispatchNestedPreFling(velocityX,
  131.                 velocityY);
  132.     }
  133. }

Content 部分的实现

Content 部分的实现也主要有两个关键点

第一个关键点的实现

整体置于 Header 之下。这个我们可以参考 APPBarLayout 的 behavior，它是这样处理的。

  1. /**
  2.  * Copy from Android design library
  3.  * <p/>
  4.  * Created by xujun
  5.  */
  6. public abstract class HeaderScrollingViewBehavior extends ViewOffsetBehavior<View> {
  7.     private final Rect mTempRect1 = new Rect();
  8.     private final Rect mTempRect2 = new Rect();
  10.     private int mVerticalLayoutGap = 0;
  11.     private int mOverlayTop;
  13.     public HeaderScrollingViewBehavior() {
  14.     }
  16.     public HeaderScrollingViewBehavior(Context context, AttributeSet attrs) {
  17.         super(context, attrs);
  18.     }
  20.     @Override
  21.     public boolean onMeasureChild(CoordinatorLayout parent, View child, int parentWidthMeasureSpec, int widthUsed, int parentHeightMeasureSpec, int heightUsed) {
  22.         final int childLpHeight = child.getLayoutParams().height;
  23.         if (childLpHeight == ViewGroup.LayoutParams.MATCH_PARENT || childLpHeight == ViewGroup.LayoutParams.WRAP_CONTENT) {
  24.             // If the menu's height is set to match_parent/wrap_content then measure it
  25.             // with the maximum visible height
  27.             final List<View> dependencies = parent.getDependencies(child);
  28.             final View header = findFirstDependency(dependencies);
  29.             if (header != null) {
  30.                 if (ViewCompat.getFitsSystemWindows(header) && !ViewCompat.getFitsSystemWindows(child)) {
  31.                     // If the header is fitting system windows then we need to also,
  32.                     // otherwise we'll get CoL's compatible measuring
  33.                     ViewCompat.setFitsSystemWindows(child, true);
  35.                     if (ViewCompat.getFitsSystemWindows(child)) {
  36.                         // If the set succeeded, trigger a new layout and return true
  37.                         child.requestLayout();
  38.                         return true;
  39.                     }
  40.                 }
  42.                 if (ViewCompat.isLaidOut(header)) {
  43.                     int availableHeight = View.MeasureSpec.getSize(parentHeightMeasureSpec);
  44.                     if (availableHeight == 0) {
  45.                         // If the measure spec doesn't specify a size, use the current height
  46.                         availableHeight = parent.getHeight();
  47.                     }
  49.                     final int height = availableHeight - header.getMeasuredHeight() + getScrollRange(header);
  50.                     final int heightMeasureSpec = View.MeasureSpec.makeMeasureSpec(height,
  51.                             childLpHeight == ViewGroup.LayoutParams.MATCH_PARENT ? View.MeasureSpec.EXACTLY : View.MeasureSpec.AT_MOST);
  53.                     // Now measure the scrolling view with the correct height
  54.                     parent.onMeasureChild(child, parentWidthMeasureSpec, widthUsed, heightMeasureSpec, heightUsed);
  56.                     return true;
  57.                 }
  58.             }
  59.         }
  60.         return false;
  61.     }
  63.     @Override
  64.     protected void layoutChild(final CoordinatorLayout parent, final View child, final int layoutDirection) {
  65.         final List<View> dependencies = parent.getDependencies(child);
  66.         final View header = findFirstDependency(dependencies);
  68.         if (header != null) {
  69.             final CoordinatorLayout.LayoutParams lp = (CoordinatorLayout.LayoutParams) child.getLayoutParams();
  70.             final Rect available = mTempRect1;
  71.             available.set(parent.getPaddingLeft() + lp.leftMargin, header.getBottom() + lp.topMargin,
  72.                     parent.getWidth() - parent.getPaddingRight() - lp.rightMargin,
  73.                     parent.getHeight() + header.getBottom() - parent.getPaddingBottom() - lp.bottomMargin);
  75.             final Rect out = mTempRect2;
  76.             GravityCompat.apply(resolveGravity(lp.gravity), child.getMeasuredWidth(), child.getMeasuredHeight(), available, out, layoutDirection);
  78.             final int overlap = getOverlapPixelsForOffset(header);
  80.             child.layout(out.left, out.top - overlap, out.right, out.bottom - overlap);
  81.             mVerticalLayoutGap = out.top - header.getBottom();
  82.         } else {
  83.             // If we don't have a dependency, let super handle it
  84.             super.layoutChild(parent, child, layoutDirection);
  85.             mVerticalLayoutGap = 0;
  86.         }
  87.     }
  89.     float getOverlapRatioForOffset(final View header) {
  90.         return 1f;
  91.     }
  93.     final int getOverlapPixelsForOffset(final View header) {
  94.         return mOverlayTop == 0
  95.                 ? 0
  96.                 : MathUtils.constrain(Math.round(getOverlapRatioForOffset(header) * mOverlayTop),
  97.                 0, mOverlayTop);
  99.     }
  101.     private static int resolveGravity(int gravity) {
  102.         return gravity == Gravity.NO_GRAVITY ? GravityCompat.START | Gravity.TOP : gravity;
  103.     }
  105.     protected abstract View findFirstDependency(List<View> views);
  107.     protected int getScrollRange(View v) {
  108.         return v.getMeasuredHeight();
  109.     }
  111.     /**
  112.      * The gap between the top of the scrolling view and the bottom of the header layout in pixels.
  113.      */
  114.     final int getVerticalLayoutGap() {
  115.         return mVerticalLayoutGap;
  116.     }
  118.     /**
  119.      * Set the distance that this view should overlap any {@link AppBarLayout}.
  120.      *
  121.      * @param overlayTop the distance in px
  122.      */
  123.     public final void setOverlayTop(int overlayTop) {
  124.         mOverlayTop = overlayTop;
  125.     }
  127.     /**
  128.      * Returns the distance that this view should overlap any {@link AppBarLayout}.
  129.      */
  130.     public final int getOverlayTop() {
  131.         return mOverlayTop;
  132.     }
  134. }

这个基类的代码还是很好理解的，因为之前就说过了，正常来说被依赖的 View 会优先于依赖它的 View 处理，所以需要依赖的 View 可以在 measure/layout 的时候，找到依赖的 View 并获取到它的测量/布局的信息，这里的处理就是依靠着这种关系来实现的.

我们的实现类，需要重写的除了抽象方法 findFirstDependency 外，还需要重写 getScrollRange，我们把 Header
的 Id id_weibo_header 定义在 ids.xml 资源文件内，方便依赖的判断.

至于缩放的高度，根据 结果图 得知是 0，得出如下代码

  1. public class WeiboContentBehavior extends HeaderScrollingViewBehavior {
  2.     private static final String TAG = "WeiboContentBehavior";
  4.     public WeiboContentBehavior() {
  5.     }
  7.     public WeiboContentBehavior(Context context, AttributeSet attrs) {
  8.         super(context, attrs);
  9.     }
  11.     @Override
  12.     public boolean layoutDependsOn(CoordinatorLayout parent, View child, View dependency) {
  13.         return isDependOn(dependency);
  14.     }
  16.     @Override
  17.     public boolean onDependentViewChanged(CoordinatorLayout parent, View child, View dependency) {
  18.         if (BuildConfig.DEBUG) {
  19.             Log.d(TAG, "onDependentViewChanged");
  20.         }
  21.         offsetChildAsNeeded(parent, child, dependency);
  22.         return false;
  23.     }
  25.     private void offsetChildAsNeeded(CoordinatorLayout parent, View child, View dependency) {
  26.         float dependencyTranslationY = dependency.getTranslationY();
  27.         int translationY = (int) (-dependencyTranslationY / (getHeaderOffsetRange() * 1.0f) * 
  28.                 getScrollRange(dependency));
  29.         Log.i(TAG, "offsetChildAsNeeded: translationY=" + translationY);
  30.         child.setTranslationY(translationY);
  32.     }
  34.     @Override
  35.     protected View findFirstDependency(List<View> views) {
  36.         for (int i = 0, z = views.size(); i < z; i++) {
  37.             View view = views.get(i);
  38.             if (isDependOn(view)) return view;
  39.         }
  40.         return null;
  41.     }
  43.     @Override
  44.     protected int getScrollRange(View v) {
  45.         if (isDependOn(v)) {
  46.             return Math.max(0, v.getMeasuredHeight() - getFinalHeight());
  47.         } else {
  48.             return super.getScrollRange(v);
  49.         }
  50.     }
  52.     private int getHeaderOffsetRange() {
  53.         return BaseAPP.getInstance().getResources().getDimensionPixelOffset(R.dimen
  54.                 .weibo_header_offset);
  55.     }
  57.     private int getFinalHeight() {
  58.         Resources resources = BaseAPP.getInstance().getResources();
  60.         return 0;
  61.     }
  63.     private boolean isDependOn(View dependency) {
  64.         return dependency != null && dependency.getId() == R.id.id_weibo_header;
  65.     }
  66. }

里面主要的逻辑就是 在 Header 位置发生变化的时候，会回调 onDependentViewChanged 方法，在该方法里面，做相应的偏移。TranslationY 是根据比例算出来的 translationY = (int) (-dependencyTranslationY / (getHeaderOffsetRange() * 1.0f) * getScrollRange(dependency));

题外话

最后，特别感谢写这篇博客 自定义Behavior的艺术探索-仿UC浏览器主页 的开发者，没有这篇博客作为参考，这种效果我很大几率是 实现 不了的。大家觉得效果还不错的话，顺手到 github 上面给我 star，谢谢。github 地址

参考文章：

自定义Behavior的艺术探索-仿UC浏览器主页

github 地址

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注