[关闭]
@xujun94 2017-05-11T22:32:34.000000Z 字数 22667 阅读 1380

一步步带你读懂 CoordinatorLayout 源码

使用CoordinatorLayout打造各种炫酷的效果

自定义Behavior —— 仿知乎，FloatActionButton隐藏与展示

NestedScrolling 机制深入解析

一步步带你读懂 CoordinatorLayout 源码

前言

记得在去年的时候，就写过一篇博客使用CoordinatorLayout打造各种炫酷的效果，里面介绍了 CoordinatorLayout 的常用用法，今天，这篇博客将带大家一步步来分析源码。

CoordinatorLayout 实现了 NestedScrollingParent 接口，是一个容器，我们可以通过指定 behavior 来实现各种各样炫酷的效果。需要注意的是本篇博客分析的版本是 25.2.0 的。

分析之前，先放一下效果图，给大家看一看，增加一下博客访问量，下一篇博客会教大家如何实现。

仿新浪微博效果图

Behavior 的初始化

Behavior 是 CoordinatorLayout 里面的一个静态类。重写里面的若干方法，我们可以实现各种炫酷的效果，比如仿 UC 主页，仿新浪微博，仿 QQ 浏览器主页，仿知乎首页等效果。

Behavior 的主要几个方法

  1. public static abstract class Behavior<V extends View> {
  3.     // 中间省略了若干方法
  4.     public Behavior() {
  5.     }
  8.     public Behavior(Context context, AttributeSet attrs) {
  9.     }
  12.     public void onAttachedToLayoutParams(@NonNull CoordinatorLayout.LayoutParams params) {
  13.     }
  16.     public void onDetachedFromLayoutParams() {
  17.     }
  20.     public boolean onInterceptTouchEvent(CoordinatorLayout parent, V child, MotionEvent ev) {
  21.         return false;
  22.     }
  25.     public boolean onTouchEvent(CoordinatorLayout parent, V child, MotionEvent ev) {
  26.         return false;
  27.     }
  31.     public boolean layoutDependsOn(CoordinatorLayout parent, V child, View dependency) {
  32.         return false;
  33.     }
  36.     public boolean onDependentViewChanged(CoordinatorLayout parent, V child, View dependency) {
  37.         return false;
  38.     }
  40.     public void onDependentViewRemoved(CoordinatorLayout parent, V child, View dependency) {
  41.     }
  45.     public boolean onStartNestedScroll(CoordinatorLayout coordinatorLayout,
  46.             V child, View directTargetChild, View target, int nestedScrollAxes) {
  47.         return false;
  48.     }
  51.     public void onNestedScrollAccepted(CoordinatorLayout coordinatorLayout, V child,
  52.             View directTargetChild, View target, int nestedScrollAxes) {
  53.         // Do nothing
  54.     }
  57.     public void onStopNestedScroll(CoordinatorLayout coordinatorLayout, V child, View target) {
  58.         // Do nothing
  59.     }
  62.     public void onNestedScroll(CoordinatorLayout coordinatorLayout, V child, View target,
  63.             int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed) {
  64.         // Do nothing
  65.     }
  68.     public void onNestedPreScroll(CoordinatorLayout coordinatorLayout, V child, View target,
  69.             int dx, int dy, int[] consumed) {
  70.         // Do nothing
  71.     }
  74.     public boolean onNestedFling(CoordinatorLayout coordinatorLayout, V child, View target,
  75.             float velocityX, float velocityY, boolean consumed) {
  76.         return false;
  77.     }
  80.     public boolean onNestedPreFling(CoordinatorLayout coordinatorLayout, V child, View target,
  81.             float velocityX, float velocityY) {
  82.         return false;
  83.     }
  86. }

Behavior 的初始化时机

这种方式指定的 Behavior 是在生成 layoutParams 里面进行转化的。

  1. LayoutParams(Context context, AttributeSet attrs) {
  2.     super(context, attrs);
  3.     if (mBehaviorResolved) {
  4.         mBehavior = parseBehavior(context, attrs, a.getString(
  5.                 R.styleable.CoordinatorLayout_Layout_layout_behavior));
  6.     }
  7.     a.recycle();
  9.     if (mBehavior != null) {
  10.         // If we have a Behavior, dispatch that it has been attached
  11.         mBehavior.onAttachedToLayoutParams(this);
  12.     }
  13. }
  1. protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  2.     prepareChildren();
  4. }
  6. private void prepareChildren() {
  7.     mDependencySortedChildren.clear();
  8.     mChildDag.clear();
  10.     for (int i = 0, count = getChildCount(); i < count; i++) {
  11.         final View view = getChildAt(i);
  12.         final LayoutParams lp = getResolvedLayoutParams(view);
  13.         lp.findAnchorView(this, view);
  14.         mChildDag.addNode(view);
  16.         // Now iterate again over the other children, adding any dependencies to the graph
  17.         for (int j = 0; j < count; j++) {
  18.             if (j == i) {
  19.                 continue;
  20.             }
  21.             final View other = getChildAt(j);
  22.             final LayoutParams otherLp = getResolvedLayoutParams(other);
  23.             if (otherLp.dependsOn(this, other, view)) {
  24.                 if (!mChildDag.contains(other)) {
  25.                     // Make sure that the other node is added
  26.                     mChildDag.addNode(other);
  27.                 }
  28.                 // Now add the dependency to the graph
  29.                 mChildDag.addEdge(view, other);
  30.             }
  31.         }
  32.     }
  34.     // Finally add the sorted graph list to our list
  35.     mDependencySortedChildren.addAll(mChildDag.getSortedList());
  36.     // We also need to reverse the result since we want the start of the list to contain
  37.     // Views which have no dependencies, then dependent views after that
  38.     Collections.reverse(mDependencySortedChildren);
  39. }
  41. LayoutParams getResolvedLayoutParams(View child) {
  42.     final LayoutParams result = (LayoutParams) child.getLayoutParams();
  43.     if (!result.mBehaviorResolved) {
  44.         Class<?> childClass = child.getClass();
  45.         DefaultBehavior defaultBehavior = null;
  46.         while (childClass != null &&
  47.                 (defaultBehavior = childClass.getAnnotation(DefaultBehavior.class)) == null) {
  48.             childClass = childClass.getSuperclass();
  49.         }
  50.         if (defaultBehavior != null) {
  51.             try {
  52.                 result.setBehavior(defaultBehavior.value().newInstance());
  53.             } catch (Exception e) {
  54.                 Log.e(TAG, "Default behavior class " + defaultBehavior.value().getName() +
  55.                         " could not be instantiated. Did you forget a default constructor?", e);
  56.             }
  57.         }
  58.         result.mBehaviorResolved = true;
  59.     }
  60.     return result;
  61. }

NestedScrollingParent 与 NestedScrollingChild 接口方法是怎样回调的

执行流程

  1. 在 Action_Down 的时候，Scrolling child 会调用 startNestedScroll 方法，通过 childHelper 回调 Scrolling Parent 的 startNestedScroll 方法
  2. 在 Action_move 的时候，Scrolling Child 要开始滑动的时候，会调用dispatchNestedPreScroll 方法，通过 ChildHelper 询问 Scrolling Parent 是否要先于 Child 进行 滑动，若需要的话，会调用 Parent 的 onNestedPreScroll 方法，协同 Child 一起进行滑动
  3. 当 ScrollingChild 滑动完成的时候，会调用 dispatchNestedScroll 方法，通过 ChildHelper 询问 Scrolling Parent 是否需要进行滑动，需要的话，会 调用 Parent 的 onNestedScroll 方法
  4. 在 Action_down,Action_move 的时候，会调用 Scrolling Child 的stopNestedScroll ，通过 ChildHelper 询问 Scrolling parent 的 stopNestedScroll 方法。
  5. 如果需要处理 Fling 动作，我们可以通过 VelocityTrackerCompat 获得相应的速度，并在 Action_up 的时候，调用 dispatchNestedPreFling 方法，通过 ChildHelper 询问 Parent 是否需要先于 child 进行 Fling 动作
  6. 在 Child 处理完 Fling 动作时候，如果 Scrolling Parent 还需要处理 Fling 动作，我们可以调用 dispatchNestedFling 方法，通过 ChildHelper ，调用 Parent 的 onNestedFling 方法

在上一篇博客NestedScrolling 机制深入解析 的 时候其实已经说到：是通过 NestedScrollingChildHelper 来完成的，具体 的请看里面分分析，这里就不再一一阐述。

Behavior 方法与 NestedScrollingParent 方法之间的关系

我们知道 NestedScrollingParent 主要有这些方法，

在 Behavior 方法里面也有这些方法，与 NestedScrollingParent 方法 几乎也是一一对应的。在 CoordinatorLayout 里面。NestedScrollingParent 接口的方法的具体 实现逻辑 都会交给 Behavior 对应的方法去处理。下面我们一起来看一下是怎样处理的。

onStartNestedScroll 方法

思想大概是这样的：

遍历所有的孩子 ，如果可见性是 GONE，跳过。如果可见性不是 GONE，通过 layoutParams 拿到 Behavior，判断 behavior 是否为空，不为空，调用 behavior 的对应方法 onStartNestedScroll 和 acceptNestedScroll 方法。

  1. // 开始滑动的时候
  2. @Override
  3. public boolean onStartNestedScroll(View child, View target, int nestedScrollAxes) {
  4.     boolean handled = false;
  6.     final int childCount = getChildCount();
  7.     for (int i = 0; i < childCount; i++) {
  8.         final View view = getChildAt(i);
  9.         if (view.getVisibility() == View.GONE) {
  10.             // If it's GONE, don't dispatch
  11.             continue;
  12.         }
  13.         // 通过  LayoutParams 拿到对应的  Behavior 
  14.         final LayoutParams lp = (LayoutParams) view.getLayoutParams();
  15.         final Behavior viewBehavior = lp.getBehavior();
  16.         if (viewBehavior != null) {
  17.              // 交给 Behavior  去处理
  18.             final boolean accepted = viewBehavior.onStartNestedScroll(this, view, child, target,
  19.                     nestedScrollAxes);
  20.             handled |= accepted;
  22.             lp.acceptNestedScroll(accepted);
  23.         } else {
  24.             lp.acceptNestedScroll(false);
  25.         }
  26.     }
  27.     return handled;
  28. }

onNestedScrollAccepted 方法

思想大概是这样的

  1. @Override
  2. public void onNestedScrollAccepted(View child, View target, int nestedScrollAxes) {
  3.     mNestedScrollingParentHelper.onNestedScrollAccepted(child, target, nestedScrollAxes);
  4.     mNestedScrollingDirectChild = child;
  5.     mNestedScrollingTarget = target;
  7.     final int childCount = getChildCount();
  8.     for (int i = 0; i < childCount; i++) {
  9.         final View view = getChildAt(i);
  10.         final LayoutParams lp = (LayoutParams) view.getLayoutParams();
  11.         if (!lp.isNestedScrollAccepted()) {
  12.             continue;
  13.         }
  15.         final Behavior viewBehavior = lp.getBehavior();
  16.         if (viewBehavior != null) {
  17.             // 调用 behavior 的相应方法
  18.             viewBehavior.onNestedScrollAccepted(this, view, child, target, nestedScrollAxes);
  19.         }
  20.     }
  21. }

onNestedPreScroll 方法

我们知道 onNestedPreScroll 是在 Scrolling child 滑动之前回调的，提供机会给 Scrooling Parent 先于 child 进行滑动的。

在 CoordinatorLayout 里面，它的处理流程是这样的。 遍历所有的孩子，判断可见性是否为 GONE，如果是 ，跳过当前 子 View,通过 LayoutParams 判断是否处理滑动事件，不处理滑动 事件，跳过，拿到 Behavior，判断 Behavior 是否为空，不过空，回调 Behavior 的 onNestedPreScroll 方法。

  1. @Override
  2. public void onNestedPreScroll(View target, int dx, int dy, int[] consumed) {
  3.     int xConsumed = 0;
  4.     int yConsumed = 0;
  5.     boolean accepted = false;
  7.     final int childCount = getChildCount();
  8.     for (int i = 0; i < childCount; i++) {
  9.         final View view = getChildAt(i);
  10.         if (view.getVisibility() == GONE) {
  11.             // If the child is GONE, skip...
  12.             continue;
  13.         }
  15.         final LayoutParams lp = (LayoutParams) view.getLayoutParams();
  16.         if (!lp.isNestedScrollAccepted()) {
  17.             continue;
  18.         }
  20.         final Behavior viewBehavior = lp.getBehavior();
  21.         if (viewBehavior != null) {
  22.             mTempIntPair[0] = mTempIntPair[1] = 0;
  23.             viewBehavior.onNestedPreScroll(this, view, target, dx, dy, mTempIntPair);
  25.             xConsumed = dx > 0 ? Math.max(xConsumed, mTempIntPair[0])
  26.                     : Math.min(xConsumed, mTempIntPair[0]);
  27.             yConsumed = dy > 0 ? Math.max(yConsumed, mTempIntPair[1])
  28.                     : Math.min(yConsumed, mTempIntPair[1]);
  30.             accepted = true;
  31.         }
  32.     }
  34.     consumed[0] = xConsumed;
  35.     consumed[1] = yConsumed;
  37.     if (accepted) {
  38.         onChildViewsChanged(EVENT_NESTED_SCROLL);
  39.     }
  40. }

onNestedScroll 方法

在 Scrolling Child 滑动之后，提供机会给 Scrolling Parent 滑动，事件的处理 逻辑就不一一阐述了 ，跟前面的差不多

  1. @Override
  2. public void onNestedScroll(View target, int dxConsumed, int dyConsumed,
  3.         int dxUnconsumed, int dyUnconsumed) {
  4.     final int childCount = getChildCount();
  5.     boolean accepted = false;
  7.     for (int i = 0; i < childCount; i++) {
  8.         final View view = getChildAt(i);
  9.         if (view.getVisibility() == GONE) {
  10.             // If the child is GONE, skip...
  11.             continue;
  12.         }
  14.         final LayoutParams lp = (LayoutParams) view.getLayoutParams();
  15.           // 如果之前没有处理滑动事件，直接返回，不调用 onStopNestedScroll 方法
  16.         if (!lp.isNestedScrollAccepted()) {
  17.             continue;
  18.         }
  20.         final Behavior viewBehavior = lp.getBehavior();
  21.         if (viewBehavior != null) {
  22.              // 调用 behavior 的相应方法
  23.             viewBehavior.onNestedScroll(this, view, target, dxConsumed, dyConsumed,
  24.                     dxUnconsumed, dyUnconsumed);
  25.             accepted = true;
  26.         }
  27.     }
  29.     if (accepted) {
  30.         onChildViewsChanged(EVENT_NESTED_SCROLL);
  31.     }
  32. }

onNestedPreFling 和 onNestedFling 方法

  2. @Override
  3. public boolean onNestedPreFling(View target, float velocityX, float velocityY) {
  4.     boolean handled = false;
  6.     final int childCount = getChildCount();
  7.     for (int i = 0; i < childCount; i++) {
  8.         final View view = getChildAt(i);
  9.         if (view.getVisibility() == GONE) {
  10.             // If the child is GONE, skip...
  11.             continue;
  12.         }
  14.         final LayoutParams lp = (LayoutParams) view.getLayoutParams();
  15.         if (!lp.isNestedScrollAccepted()) {
  16.             continue;
  17.         }
  19.         final Behavior viewBehavior = lp.getBehavior();
  20.         if (viewBehavior != null) {
  21.             handled |= viewBehavior.onNestedPreFling(this, view, target, velocityX, velocityY);
  22.         }
  23.     }
  24.     return handled;
  25. }
  26. @Override
  27. public boolean onNestedFling(View target, float velocityX, float velocityY, boolean consumed) {
  28.     boolean handled = false;
  30.     final int childCount = getChildCount();
  31.     for (int i = 0; i < childCount; i++) {
  32.         final View view = getChildAt(i);
  33.         if (view.getVisibility() == GONE) {
  34.             // If the child is GONE, skip...
  35.             continue;
  36.         }
  38.         final LayoutParams lp = (LayoutParams) view.getLayoutParams();
  39.         if (!lp.isNestedScrollAccepted()) {
  40.             continue;
  41.         }
  43.         final Behavior viewBehavior = lp.getBehavior();
  44.         if (viewBehavior != null) {
  45.             handled |= viewBehavior.onNestedFling(this, view, target, velocityX, velocityY,
  46.                     consumed);
  47.         }
  48.     }
  49.     if (handled) {
  50.         onChildViewsChanged(EVENT_NESTED_SCROLL);
  51.     }
  52.     return handled;
  53. }

onStopNestedScroll 方法

  1. @Override
  2. public void onStopNestedScroll(View target) {
  3.     mNestedScrollingParentHelper.onStopNestedScroll(target);
  5.     final int childCount = getChildCount();
  6.     for (int i = 0; i < childCount; i++) {
  7.         final View view = getChildAt(i);
  8.         final LayoutParams lp = (LayoutParams) view.getLayoutParams();
  9.          // 如果之前没有处理滑动事件，直接返回，不调用 onStopNestedScroll 方法
  10.         if (!lp.isNestedScrollAccepted()) {
  11.             continue;
  12.         }
  14.         final Behavior viewBehavior = lp.getBehavior();
  15.         if (viewBehavior != null) {
  16.             viewBehavior.onStopNestedScroll(this, view, target);
  17.         }
  18.         lp.resetNestedScroll();
  19.         lp.resetChangedAfterNestedScroll();
  20.     }
  22.     mNestedScrollingDirectChild = null;
  23.     mNestedScrollingTarget = null;
  24. }

Behavior 相比 NestedScrollingParent 独有的方法

返回 true，当 dependency 改变的 时候，将会回调 onDependentViewChanged 方法.比如，当我们依赖于 AppBarLayout 的时候，我们可以这样写 。

  1. @Override
  2. public boolean layoutDependsOn(CoordinatorLayout parent, View child, View dependency) {
  3.     // We depend on any AppBarLayouts
  4.     return dependency instanceof AppBarLayout;
  5. }

与 layoutDependsOn 息息相关，当 layoutDependsOn 返回TRUE的时候，才会回调这个方法。

CoordinatorLayout 是如何监听 View 的状态的？

那 onDependentViewChanged 和 onDependentViewRemove 这两个方法是如何监听得到 View 变化和移除的？其实是在 onAttachedToWindow 方法里面，他会为 ViewTreeObserver 视图树添加 OnPreDrawListener 监听。

  1. @Override
  2. public void onAttachedToWindow() {
  3.     super.onAttachedToWindow();
  4.     resetTouchBehaviors();
  5.     if (mNeedsPreDrawListener) {
  6.         if (mOnPreDrawListener == null) {
  7.             mOnPreDrawListener = new OnPreDrawListener();
  8.         }
  9.         final ViewTreeObserver vto = getViewTreeObserver();
  10.         vto.addOnPreDrawListener(mOnPreDrawListener);
  11.     }
  12.     if (mLastInsets == null && ViewCompat.getFitsSystemWindows(this)) {
  13.         // We're set to fitSystemWindows but we haven't had any insets yet...
  14.         // We should request a new dispatch of window insets
  15.         ViewCompat.requestApplyInsets(this);
  16.     }
  17.     mIsAttachedToWindow = true;
  18. }
  20. class OnPreDrawListener implements ViewTreeObserver.OnPreDrawListener {
  21.         @Override
  22.         public boolean onPreDraw() {
  23.             onChildViewsChanged(EVENT_PRE_DRAW);
  24.             return true;
  25.         }
  26.     }

在 OnPreDrawListener 监听里面会调用 onChildViewsChanged 方法，在该方法里面会根据 View的状态回调 onDependentViewRemoved 或者 onDependentViewChanged 方法。

  1. final void onChildViewsChanged(@DispatchChangeEvent final int type) {
  2.        ---
  3.        / / 省略若干方法
  5.     for (int i = 0; i < childCount; i++) {
  6.         final View child = mDependencySortedChildren.get(i);
  7.         final LayoutParams lp = (LayoutParams) child.getLayoutParams();
  8.         if (type == EVENT_PRE_DRAW && child.getVisibility() == View.GONE) {
  9.             // Do not try to update GONE child views in pre draw updates.
  10.             continue;
  11.         }
  13.      ---
  15.         // Get the current draw rect of the view
  16.      ----
  17.        / / 省略若干方法
  19.         if (type == EVENT_PRE_DRAW) {
  20.             // Did it change? if not continue
  21.             getLastChildRect(child, lastDrawRect);
  22.             if (lastDrawRect.equals(drawRect)) {
  23.                 continue;
  24.             }
  25.             recordLastChildRect(child, drawRect);
  26.         }
  28.         // Update any behavior-dependent views for the change
  29.         for (int j = i + 1; j < childCount; j++) {
  30.             final View checkChild = mDependencySortedChildren.get(j);
  31.             final LayoutParams checkLp = (LayoutParams) checkChild.getLayoutParams();
  32.             final Behavior b = checkLp.getBehavior();
  34.             if (b != null && b.layoutDependsOn(this, checkChild, child)) {
  35.                 if (type == EVENT_PRE_DRAW && checkLp.getChangedAfterNestedScroll()) {
  36.                     // If this is from a pre-draw and we have already been changed
  37.                     // from a nested scroll, skip the dispatch and reset the flag
  38.                     checkLp.resetChangedAfterNestedScroll();
  39.                     continue;
  40.                 }
  42.                 final boolean handled;
  43.                 switch (type) {
  44.                     case EVENT_VIEW_REMOVED:
  45.                         // EVENT_VIEW_REMOVED means that we need to dispatch
  46.                         // onDependentViewRemoved() instead
  47.                         // 回调 Behavior 的 onDependentViewRemoved 方法
  48.                         b.onDependentViewRemoved(this, checkChild, child);
  49.                         handled = true;
  50.                         break;
  51.                     default:
  52.                         // Otherwise we dispatch onDependentViewChanged() 
  53.                             // 回调 Behavior 的 onDependentViewChanged 方法
  54.                         handled = b.onDependentViewChanged(this, checkChild, child);
  55.                         break;
  56.                 }
  58.                 if (type == EVENT_NESTED_SCROLL) {
  59.                     // If this is from a nested scroll, set the flag so that we may skip
  60.                     // any resulting onPreDraw dispatch (if needed)
  61.                     checkLp.setChangedAfterNestedScroll(handled);
  62.                 }
  63.             }
  64.         }
  65.     }
  67.   ---
  68. }

CoordinatorLayout 如何移除 View 的监听状态的

我们知道当 View 被销毁的时候，会回调 onDetachedFromWindow 这个方法，因此适合在这个方法里面移除 View 视图树的 PreDrawListener 监听。

  1. @Override
  2. public void onDetachedFromWindow() {
  3.     super.onDetachedFromWindow();
  4.     resetTouchBehaviors();
  5.     if (mNeedsPreDrawListener && mOnPreDrawListener != null) {
  6.         final ViewTreeObserver vto = getViewTreeObserver();
  7.         vto.removeOnPreDrawListener(mOnPreDrawListener);
  8.     }
  9.     if (mNestedScrollingTarget != null) {
  10.         onStopNestedScroll(mNestedScrollingTarget);
  11.     }
  12.     mIsAttachedToWindow = false;
  13. }

CoordinatorLayout 的 measure 和 layout

measure

  1. protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  2.     // 处理 child 的一些 相关属性 ，比如 Behavior等
  3.     prepareChildren();
  4.     // 如果有依赖的话，添加 OnPreDrawListener 监听，没有的话，移除 OnPreDrawListener 监听
  5.     ensurePreDrawListener();
  7.     ---
  8.     // 省略了 染过逻辑，主要是处理  padding的 
  9.     for (int i = 0; i < childCount; i++) {
  10.         final View child = mDependencySortedChildren.get(i);
  11.         if (child.getVisibility() == GONE) {
  12.             // If the child is GONE, skip...
  13.             continue;
  14.         }
  16.         final LayoutParams lp = (LayoutParams) child.getLayoutParams();
  18.           ----
  21.         final Behavior b = lp.getBehavior();
  22.           // 回调 Behavior 的 onMeasureChild 方法
  23.         if (b == null || !b.onMeasureChild(this, child, childWidthMeasureSpec, keylineWidthUsed,
  24.                 childHeightMeasureSpec, 0)) {
  25.             onMeasureChild(child, childWidthMeasureSpec, keylineWidthUsed,
  26.                     childHeightMeasureSpec, 0);
  27.         }
  29.         widthUsed = Math.max(widthUsed, widthPadding + child.getMeasuredWidth() +
  30.                 lp.leftMargin + lp.rightMargin);
  32.         heightUsed = Math.max(heightUsed, heightPadding + child.getMeasuredHeight() +
  33.                 lp.topMargin + lp.bottomMargin);
  34.         childState = ViewCompat.combineMeasuredStates(childState,
  35.                 ViewCompat.getMeasuredState(child));
  36.     }
  38.     final int width = ViewCompat.resolveSizeAndState(widthUsed, widthMeasureSpec,
  39.             childState & ViewCompat.MEASURED_STATE_MASK);
  40.     final int height = ViewCompat.resolveSizeAndState(heightUsed, heightMeasureSpec,
  41.             childState << ViewCompat.MEASURED_HEIGHT_STATE_SHIFT);
  42.     setMeasuredDimension(width, height);
  43. }

我们进入 prepareChildren 方法里面，可以发现它对 CoordinatorLayout 里面的子 View 进行了排序，排序的结果是 最后被依赖的 View 会排在最前面。举个例子 A 依赖于 B，那么 B会排在前面，A 会排在 B 的 后面。这样的排序结果是合理的，因为 A 既然依赖于 B，那么 B 肯定要有限 measure。

  1. private void prepareChildren() {
  2.     mDependencySortedChildren.clear();
  3.     mChildDag.clear();
  5.     for (int i = 0, count = getChildCount(); i < count; i++) {
  6.         final View view = getChildAt(i);
  8.         final LayoutParams lp = getResolvedLayoutParams(view);
  9.         lp.findAnchorView(this, view);
  11.         mChildDag.addNode(view);
  13.         // Now iterate again over the other children, adding any dependencies to the graph
  14.         for (int j = 0; j < count; j++) {
  15.             if (j == i) {
  16.                 continue;
  17.             }
  18.             final View other = getChildAt(j);
  19.             final LayoutParams otherLp = getResolvedLayoutParams(other);
  20.             if (otherLp.dependsOn(this, other, view)) {
  21.                 if (!mChildDag.contains(other)) {
  22.                     // Make sure that the other node is added
  23.                     mChildDag.addNode(other);
  24.                 }
  25.                 // Now add the dependency to the graph
  26.                 mChildDag.addEdge(view, other);
  27.             }
  28.         }
  29.     }
  31.     // Finally add the sorted graph list to our list
  32.     mDependencySortedChildren.addAll(mChildDag.getSortedList());
  33.     // We also need to reverse the result since we want the start of the list to contain
  34.     // Views which have no dependencies, then dependent views after that
  35.     Collections.reverse(mDependencySortedChildren);
  36. }

接下来 我们进入 ensurePreDrawListener 方法里面，看看里面到底做了什么？

  1. void ensurePreDrawListener() {
  2.     boolean hasDependencies = false;
  3.     final int childCount = getChildCount();
  4.     for (int i = 0; i < childCount; i++) {
  5.         final View child = getChildAt(i);
  6.         if (hasDependencies(child)) {
  7.             hasDependencies = true;
  8.             break;
  9.         }
  10.     }
  12.     if (hasDependencies != mNeedsPreDrawListener) {
  13.         if (hasDependencies) {
  14.             addPreDrawListener();
  15.         } else {
  16.             removePreDrawListener();
  17.         }
  18.     }
  19. }

其实它所做的工作就是 判断 子View ，如果有依赖的话，添加 OnPreDrawListener 监听，没有的话，移除 OnPreDrawListener 监听。

那这个 OnPreDrawListener 监听是干什么用的呢?

  1. void addPreDrawListener() {
  2.     if (mIsAttachedToWindow) {
  3.         // Add the listener
  4.         if (mOnPreDrawListener == null) {
  5.             mOnPreDrawListener = new OnPreDrawListener();
  6.         }
  7.         final ViewTreeObserver vto = getViewTreeObserver();
  8.         vto.addOnPreDrawListener(mOnPreDrawListener);
  9.     }
  11.     // Record that we need the listener regardless of whether or not we're attached.
  12.     // We'll add the real listener when we become attached.
  13.     mNeedsPreDrawListener = true;
  14. }
  16.     class OnPreDrawListener implements ViewTreeObserver.OnPreDrawListener {
  17.         @Override
  18.         public boolean onPreDraw() {
  19.             onChildViewsChanged(EVENT_PRE_DRAW);
  20.             return true;
  21.         }
  22.     }

其实就是当 Child 改变的 时候，回调依赖它的 Behavior 的 onDependentViewChanged 或者 onDependentViewRemoved 方法，从而来调整 View 在界面的显示位置 。

  1. final void onChildViewsChanged(@DispatchChangeEvent final int type) {
  2.     ---
  4.     for (int i = 0; i < childCount; i++) {
  5.         final View child = mDependencySortedChildren.get(i);
  6.         final LayoutParams lp = (LayoutParams) child.getLayoutParams();
  7.         if (type == EVENT_PRE_DRAW && child.getVisibility() == View.GONE) {
  8.             // Do not try to update GONE child views in pre draw updates.
  9.             continue;
  10.         }
  12.          ---
  13.          // 省略若干方法
  14.         // Dodge inset edges if necessary
  15.         if (lp.dodgeInsetEdges != Gravity.NO_GRAVITY && child.getVisibility() == View.VISIBLE) {
  16.             offsetChildByInset(child, inset, layoutDirection);
  17.         }
  19.         if (type == EVENT_PRE_DRAW) {
  20.             // Did it change? if not continue
  21.             getLastChildRect(child, lastDrawRect);
  22.             if (lastDrawRect.equals(drawRect)) {
  23.                 continue;
  24.             }
  25.             recordLastChildRect(child, drawRect);
  26.         }
  28.         // Update any behavior-dependent views for the change
  29.         for (int j = i + 1; j < childCount; j++) {
  30.             final View checkChild = mDependencySortedChildren.get(j);
  31.             final LayoutParams checkLp = (LayoutParams) checkChild.getLayoutParams();
  32.             final Behavior b = checkLp.getBehavior();
  34.             if (b != null && b.layoutDependsOn(this, checkChild, child)) {
  35.                 if (type == EVENT_PRE_DRAW && checkLp.getChangedAfterNestedScroll()) {
  36.                     // If this is from a pre-draw and we have already been changed
  37.                     // from a nested scroll, skip the dispatch and reset the flag
  38.                     checkLp.resetChangedAfterNestedScroll();
  39.                     continue;
  40.                 }
  42.                 final boolean handled;
  43.                 switch (type) {
  44.                     case EVENT_VIEW_REMOVED:
  45.                         // EVENT_VIEW_REMOVED means that we need to dispatch
  46.                         // onDependentViewRemoved() instead
  47.                         b.onDependentViewRemoved(this, checkChild, child);
  48.                         handled = true;
  49.                         break;
  50.                     default:
  51.                         // Otherwise we dispatch onDependentViewChanged()
  52.                         handled = b.onDependentViewChanged(this, checkChild, child);
  53.                         break;
  54.                 }
  56.                 if (type == EVENT_NESTED_SCROLL) {
  57.                     // If this is from a nested scroll, set the flag so that we may skip
  58.                     // any resulting onPreDraw dispatch (if needed)
  59.                     checkLp.setChangedAfterNestedScroll(handled);
  60.                 }
  61.             }
  62.         }
  63.     }
  65.     releaseTempRect(inset);
  66.     releaseTempRect(drawRect);
  67.     releaseTempRect(lastDrawRect);
  68. }

layout 过程

  1. @Override
  2. protected void onLayout(boolean changed, int l, int t, int r, int b) {
  3.     final int layoutDirection = ViewCompat.getLayoutDirection(this);
  4.     final int childCount = mDependencySortedChildren.size();
  5.     for (int i = 0; i < childCount; i++) {
  6.         final View child = mDependencySortedChildren.get(i);
  7.         if (child.getVisibility() == GONE) {
  8.             // If the child is GONE, skip...
  9.             continue;
  10.         }
  12.         final LayoutParams lp = (LayoutParams) child.getLayoutParams();
  13.         final Behavior behavior = lp.getBehavior();
  15.         if (behavior == null || !behavior.onLayoutChild(this, child, layoutDirection)) {
  16.             onLayoutChild(child, layoutDirection);
  17.         }
  18.     }
  19. }

CoordinatorLayout 的事件传递

CoordinatorLayout 并不会直接处理事件，而是会尽可能地交给子 View 的Behavior 进行处理。onInterceptTouchEvent 和 onToucheEvent 这两个方法都会调用 performIntercept 来处理事件。

  1. private boolean performIntercept(MotionEvent ev, final int type) {
  2.     boolean intercepted = false;
  3.     boolean newBlock = false;
  5.     MotionEvent cancelEvent = null;
  7.     final int action = MotionEventCompat.getActionMasked(ev);
  9.     final List<View> topmostChildList = mTempList1;
  10.     //在5.0以上，按照z属性来排序，以下，则是按照添加顺序或者自定义的绘制顺序来排列
  11.     getTopSortedChildren(topmostChildList);
  13.     // Let topmost child views inspect first
  14.     final int childCount = topmostChildList.size();
  15.     for (int i = 0; i < childCount; i++) {
  16.         final View child = topmostChildList.get(i);
  17.         final LayoutParams lp = (LayoutParams) child.getLayoutParams();
  18.         final Behavior b = lp.getBehavior();
  20.         if ((intercepted || newBlock) && action != MotionEvent.ACTION_DOWN) {
  21.             // Cancel all behaviors beneath the one that intercepted.
  22.             // If the event is "down" then we don't have anything to cancel yet.
  23.                  // 如果有一个behavior对事件进行了拦截，就发送Cancel事件给后续的所有Behavior。
  24.                  //假设之前还没有Intercept发生，那么所有的事件都平等地对所有含有behavior的view进行分发，
  25.                  //现在intercept忽然出现，那么相应的我们就要对除了Intercept的view发出Cancel
  26.             if (b != null) {
  27.                 if (cancelEvent == null) {
  28.                     final long now = SystemClock.uptimeMillis();
  29.                     cancelEvent = MotionEvent.obtain(now, now,
  30.                             MotionEvent.ACTION_CANCEL, 0.0f, 0.0f, 0);
  31.                 }
  32.                 switch (type) {
  33.                     case TYPE_ON_INTERCEPT:
  34.                         b.onInterceptTouchEvent(this, child, cancelEvent);
  35.                         break;
  36.                     case TYPE_ON_TOUCH:
  37.                         b.onTouchEvent(this, child, cancelEvent);
  38.                         break;
  39.                 }
  40.             }
  41.             continue;
  42.         }
  44.         if (!intercepted && b != null) {
  45.             switch (type) {
  46.                 case TYPE_ON_INTERCEPT:
  47.                     intercepted = b.onInterceptTouchEvent(this, child, ev);
  48.                     break;
  49.                 case TYPE_ON_TOUCH:
  50.                     intercepted = b.onTouchEvent(this, child, ev);
  51.                     break;
  52.             }
  53.             // 记录拦截事件 的child
  54.             if (intercepted) {
  55.                 mBehaviorTouchView = child;
  56.             }
  57.         }
  59.         // Don't keep going if we're not allowing interaction below this.
  60.         // Setting newBlock will make sure we cancel the rest of the behaviors.
  61.         final boolean wasBlocking = lp.didBlockInteraction();
  62.         final boolean isBlocking = lp.isBlockingInteractionBelow(this, child);
  63.         newBlock = isBlocking && !wasBlocking;
  64.         if (isBlocking && !newBlock) {
  65.             // Stop here since we don't have anything more to cancel - we already did
  66.             // when the behavior first started blocking things below this point.
  67.             break;
  68.         }
  69.     }
  71.     topmostChildList.clear();
  73.     return intercepted;
  74. }

处理流程大概是这样的

总结

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