[关闭]
@RitcheeQinG 2020-04-26T02:55:34.000000Z 字数 9318 阅读 264

RelativeLayout源码分析（1）（发布版）

Android

过去自己记录的内容归档，内容较老，仅供参考

onMeasure

问题：

  1. RelativeLayout的child是不是无论如何都不可能超出parent？即使固定高度，再设置clipChildren和clipPadding？
  2. RelativeLayout的child是不是要绘制两遍？两次的区别在哪
  3. RelativeLayout因为什么导致了child超不出范围？
  4. 为什么wrap_content的情况下设置align会直接让其范围跑到屏幕边上？
  1. /**
  2.  * Measure specification mode: The parent has not imposed any constraint
  3.  * on the child. It can be whatever size it wants.
  4.  */
  5. public static final int UNSPECIFIED = 0 << MODE_SHIFT;
  7. /**
  8.  * Measure specification mode: The parent has determined an exact size
  9.  * for the child. The child is going to be given those bounds regardless
  10.  * of how big it wants to be.
  11.  */
  12. public static final int EXACTLY     = 1 << MODE_SHIFT;
  14. /**
  15.  * Measure specification mode: The child can be as large as it wants up
  16.  * to the specified size.
  17.  */
  18. public static final int AT_MOST     = 2 << MODE_SHIFT;
  1. UNSPECIFIED: parent没给child加任何限制，按照child申请的大小来
  2. EXACTLY: parent给child定好了大小，就按这么大，一般代表写死值或者match
  3. AT_MOST: 最大能大到一个精确数值，一般代表wrap_content
  1. @Override
  2. protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  3.     // ...
  4.     int myWidth = -1;
  5.     int myHeight = -1;
  7.     int width = 0;
  8.     int height = 0;
  10.     final int widthMode = MeasureSpec.getMode(widthMeasureSpec);
  11.     final int heightMode = MeasureSpec.getMode(heightMeasureSpec);
  12.     final int widthSize = MeasureSpec.getSize(widthMeasureSpec);
  13.     final int heightSize = MeasureSpec.getSize(heightMeasureSpec);
  15.     // Record our dimensions if they are known;
  16.     // 如果是unspecified，那就是-1了，而这个-1会让其子view都是unspecified
  17.     if (widthMode != MeasureSpec.UNSPECIFIED) {
  18.         myWidth = widthSize;
  19.     }
  21.     if (heightMode != MeasureSpec.UNSPECIFIED) {
  22.         myHeight = heightSize;
  23.     }
  25.     if (widthMode == MeasureSpec.EXACTLY) {
  26.         width = myWidth;
  27.     }
  29.     if (heightMode == MeasureSpec.EXACTLY) {
  30.         height = myHeight;
  31.     }
  32.     // ...
  33. }
  1. @Override
  2. protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  3.     // ...
  4.     for (int i = 0; i < count; i++) {
  5.             View child = views[i];
  6.             if (child.getVisibility() != GONE) {
  7.                 LayoutParams params = (LayoutParams) child.getLayoutParams();
  8.                 int[] rules = params.getRules(layoutDirection);
  9.                 // 基本上是在处理child和其周围相关child的关系，重新计算其layoutParams
  10.                 applyHorizontalSizeRules(params, myWidth, rules);
  11.                 measureChildHorizontal(child, params, myWidth, myHeight);
  13.                 if (positionChildHorizontal(child, params, myWidth, isWrapContentWidth)) {
  14.                     offsetHorizontalAxis = true;
  15.                 }
  16.             }
  17.         }
  18.     // ...
  19. }
  1. private void measureChildHorizontal(
  2.         View child, LayoutParams params, int myWidth, int myHeight) {
  3.     // myWidth和myHeight是RelativeLayout的，如果是unspecific，那就是-1
  4.     // params是child自己的
  5.     // widthMeasureSpec在这个下面这个方法里就算是计算完成了，但heightMeasureSpec还要在下面算
  6.     final int childWidthMeasureSpec = getChildMeasureSpec(params.mLeft, params.mRight, params.width, params.leftMargin, params.rightMargin, mPaddingLeft, mPaddingRight, myWidth);
  8.     final int childHeightMeasureSpec;
  9.     if (myHeight < 0 && !mAllowBrokenMeasureSpecs) {
  10.     // relativeLayout is unspecified, and version > 17
  11.         if (params.height >= 0) {
  12.             // 众所周知wrap_content和match_parent分别是-2和-1
  13.             // 代表child有写死值的高度了
  14.             childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(
  15.                     params.height, MeasureSpec.EXACTLY);
  16.         } else {
  17.             // parent都不确定，child如果是wrap或者match肯定也确定不了
  18.             childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
  19.         }
  20.     } else {
  21.         // at most or exactly
  22.         final int maxHeight;
  23.         if (mMeasureVerticalWithPaddingMargin) {
  24.                 // version >= 18
  25.             // 0 或者 RL高度 - (topPadding, topMargin, bottomPadding, bottomMargin)里面的最大值
  26.             maxHeight = Math.max(0, myHeight - mPaddingTop - mPaddingBottom - params.topMargin - params.bottomMargin);
  27.         } else {
  28.             // 似乎不到18这里的maxHeight就不把padding margin算进去了
  29.             maxHeight = Math.max(0, myHeight);
  30.         }
  32.         final int heightMode;
  33.         // 意思是如果此RelativeLayout的值确定了，child就只有match_parent时能确认值就和parent一样，其他情况都要按at most判断（因为即使写死值也可能比parent大）
  34.         if (params.height == LayoutParams.MATCH_PARENT) {
  35.             heightMode = MeasureSpec.EXACTLY;
  36.         } else {
  37.             heightMode = MeasureSpec.AT_MOST;
  38.         }
  39.         childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(maxHeight, heightMode);
  40.     }
  42.     child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
  43. }

总结一下这里的第一次绘制

width = getChildMeasureSpec, height = myHeight - padding - margin

  1. /**
  2.  * @param childStart The left or top field of the child's layout params
  3.  * @param childEnd The right or bottom field of the child's layout params
  4.  * @param childSize The child's desired size (the width or height field of the child's layout params)
  5.  * @param startMargin The left or top margin
  6.  * @param endMargin The right or bottom margin
  7.  * @param startPadding mPaddingLeft or mPaddingTop
  8.  * @param endPadding mPaddingRight or mPaddingBottom
  9.  * @param mySize The width or height of this view (the RelativeLayout)
  10.  * @return MeasureSpec for the child
  11.  */
  12. private int getChildMeasureSpec(int childStart, int childEnd, int childSize, int startMargin, int endMargin, int startPadding, int endPadding, int mySize) {
  14.   int childSpecMode = 0;
  15.   int childSpecSize = 0;
  17.   final boolean isUnspecified = mySize < 0;
  18.   if (isUnspecified && !mAllowBrokenMeasureSpecs) {
  19.     // 先忽略unSpecified，总之child宽高只要有值就会是exactly
  20.   }
  22.   // Figure out start and end bounds.
  23.   // 这个方法里并不会再给childStart和childEnd赋值，如果没有任何约束，那默认自然是在左上角
  24.   int tempStart = childStart;
  25.   int tempEnd = childEnd;
  27.   // 从上面给params赋值的过程可以看到，这里的值如果是default value，存在几种情况
  28.   // 1.约束自己的对象gone掉了或者不存在，而且没设置alignParentIfMissing
  29.   // 2.压根就没有约束
  30.   // If the view did not express a layout constraint for an edge, use
  31.   // view's margins and our padding
  32.   if (tempStart == VALUE_NOT_SET) {
  33.     // 没有约束的情况下（在左上角），左边最大可以是padding + margin
  34.     tempStart = startPadding + startMargin;
  35.   }
  36.   if (tempEnd == VALUE_NOT_SET) {
  37.     // 没有约束的情况下，右边最大是RL的右边 - padding - margin
  38.     tempEnd = mySize - endPadding - endMargin;
  39.   }
  40.     // child的width最大的可能就是 mySize - padding - margin
  41.   // 那么假设margin < 0 ?
  43.   // Figure out maximum size available to this view
  44.   final int maxAvailable = tempEnd - tempStart;
  46.   if (childStart != VALUE_NOT_SET && childEnd != VALUE_NOT_SET) {
  47.     // Constraints fixed both edges, so child must be an exact size.
  48.     // 如果都有值了，就会是需求的right - left的精确范围
  49.     childSpecMode = isUnspecified ? MeasureSpec.UNSPECIFIED : MeasureSpec.EXACTLY;
  50.     childSpecSize = Math.max(0, maxAvailable);
  51.   } else {
  52.     // 有至少一边没定下来
  53.     if (childSize >= 0) {
  54.       // width/height >= 0
  55.       // Child wanted an exact size. Give as much as possible.
  56.       childSpecMode = MeasureSpec.EXACTLY;
  58.       if (maxAvailable >= 0) {
  59.         // We have a maximum size in this dimension.
  60.         childSpecSize = Math.min(maxAvailable, childSize);
  61.       } else {
  62.         // We can grow in this dimension.
  63.         childSpecSize = childSize;
  64.       }
  65.     } else if (childSize == LayoutParams.MATCH_PARENT) {
  66.       // Child wanted to be as big as possible. Give all available
  67.       // space.
  68.       childSpecMode = isUnspecified ? MeasureSpec.UNSPECIFIED : MeasureSpec.EXACTLY;
  69.       childSpecSize = Math.max(0, maxAvailable);
  70.     } else if (childSize == LayoutParams.WRAP_CONTENT) {
  71.       // Child wants to wrap content. Use AT_MOST to communicate
  72.       // available space if we know our max size.
  73.       if (maxAvailable >= 0) {
  74.         // We have a maximum size in this dimension.
  75.         childSpecMode = MeasureSpec.AT_MOST;
  76.         childSpecSize = maxAvailable;
  77.       } else {
  78.         // We can grow in this dimension. Child can be as big as it
  79.         // wants.
  80.         childSpecMode = MeasureSpec.UNSPECIFIED;
  81.         childSpecSize = 0;
  82.       }
  83.     }
  84.   }
  86.   return MeasureSpec.makeMeasureSpec(childSpecSize, childSpecMode);
  87. }
  1. private void applyHorizontalSizeRules(LayoutParams childParams, int myWidth, int[] rules) {
  2.         RelativeLayout.LayoutParams anchorParams;
  4.         // VALUE_NOT_SET indicates a "soft requirement" in that direction. For example:
  5.         // left=10, right=VALUE_NOT_SET means the view must start at 10, but can go as far as it
  6.         // wants to the right
  7.         // left=VALUE_NOT_SET, right=10 means the view must end at 10, but can go as far as it
  8.         // wants to the left
  9.         // left=10, right=20 means the left and right ends are both fixed
  10.         childParams.mLeft = VALUE_NOT_SET; // defualt value
  11.         childParams.mRight = VALUE_NOT_SET;
  13.             // anchor是对方的，child是自己的
  14.             // 这里的left of从下文来看应该是指child left of 对方
  15.         anchorParams = getRelatedViewParams(rules, LEFT_OF);
  16.             // anchorParams可能为空的情况：1.Gone 2.没有这个View
  17.         if (anchorParams != null) {
  18.             // 对方的右边 - 双方margin = child左边
  19.             childParams.mRight = anchorParams.mLeft - (anchorParams.leftMargin + childParams.rightMargin);
  20.         } else if (childParams.alignWithParent && rules[LEFT_OF] != 0) {
  21.             // layout_alignWithParentIfMissing + left of的view不存在or gone
  22.             /* alignWithParent: When true, uese the parent as the anchor if the anchor doesn't exist or if the anchor's visibility is gone */
  23.             if (myWidth >= 0) {
  24.                 childParams.mRight = myWidth - mPaddingRight - childParams.rightMargin;
  25.             }
  26.         }
  27.             // 如果啥都没标注，此时应该left还是not set
  29.         anchorParams = getRelatedViewParams(rules, RIGHT_OF);
  30.         if (anchorParams != null) {
  31.             childParams.mLeft = anchorParams.mRight + (anchorParams.rightMargin + childParams.leftMargin);
  32.         } else if (childParams.alignWithParent && rules[RIGHT_OF] != 0) {
  33.             childParams.mLeft = mPaddingLeft + childParams.leftMargin;
  34.         }
  36.         anchorParams = getRelatedViewParams(rules, ALIGN_LEFT);
  37.         if (anchorParams != null) {
  38.             // 对方的margin此时已经被加进left了吗？
  39.             childParams.mLeft = anchorParams.mLeft + childParams.leftMargin;
  40.         } else if (childParams.alignWithParent && rules[ALIGN_LEFT] != 0) {
  41.             childParams.mLeft = mPaddingLeft + childParams.leftMargin;
  42.         }
  44.         anchorParams = getRelatedViewParams(rules, ALIGN_RIGHT);
  45.         if (anchorParams != null) {
  46.             childParams.mRight = anchorParams.mRight - childParams.rightMargin;
  47.         } else if (childParams.alignWithParent && rules[ALIGN_RIGHT] != 0) {
  48.             if (myWidth >= 0) {
  49.                 childParams.mRight = myWidth - mPaddingRight - childParams.rightMargin;
  50.             }
  51.         }
  53.         if (0 != rules[ALIGN_PARENT_LEFT]) {
  54.             childParams.mLeft = mPaddingLeft + childParams.leftMargin;
  55.         }
  57.         if (0 != rules[ALIGN_PARENT_RIGHT]) {
  58.             if (myWidth >= 0) {
  59.                 childParams.mRight = myWidth - mPaddingRight - childParams.rightMargin;
  60.             }
  61.         }
  62.             // 判断的顺序: left of, right of, align left, align right, align parnent left, align parent left
  63.             // 如果rules中什么都不包括，那么到了这里应该还是default value
  64.     }

sort过程：

会按照依赖关系进行排序，需要先处理的会被排序在前面

  1. @Override
  2. protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  3.     // ...
  4.     if (isWrapContentWidth) {
  5.       // Width already has left padding in it since it was calculated by looking at
  6.       // the right of each child view
  7.       width += mPaddingRight;
  9.       if (mLayoutParams != null && mLayoutParams.width >= 0) {
  10.         width = Math.max(width, mLayoutParams.width);
  11.       }
  13.       width = Math.max(width, getSuggestedMinimumWidth());
  14.       width = resolveSize(width, widthMeasureSpec);
  16.       if (offsetHorizontalAxis) {
  17.         for (int i = 0; i < count; i++) {
  18.           final View child = views[i];
  19.           if (child.getVisibility() != GONE) {
  20.             final LayoutParams params = (LayoutParams) child.getLayoutParams();
  21.             final int[] rules = params.getRules(layoutDirection);
  22.             if (rules[CENTER_IN_PARENT] != 0 || rules[CENTER_HORIZONTAL] != 0) {
  23.               centerHorizontal(child, params, width);
  24.             } else if (rules[ALIGN_PARENT_RIGHT] != 0) {
  25.               final int childWidth = child.getMeasuredWidth();
  26.               params.mLeft = width - mPaddingRight - childWidth;
  27.               params.mRight = params.mLeft + childWidth;
  28.             }
  29.           }
  30.         }
  31.       }
  32.     }
  33.     // ...
  34. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注