android View绘制流程分为3个步骤：分别是measure、 layout、 draw 。今天我们先来探究一下measure的过程。在上一节android开发笔记（三十四）中，我们研究了DecorView绘制到PhoneWindow上的流程，也就是View绘制的概况性流程（DecorView extends View）, 我们回顾一下那个流程图：
今天我们要研究的就是measure阶段，上图中用红线圈住的部分。performMeasure函数会执行View的measure函数，而measure函数又会执行onMeasure函数。下面我们来分析一下这些测量相关的函数源码。
1. View.measure函数
代码如下：
-
/**
-
* <p>
-
* This is called to find out how big a view should be. The parent
-
* supplies constraint information in the width and height parameters.
-
* </p>
-
*
-
* <p>
-
* The actual measurement work of a view is performed in
-
* {@link #onMeasure(int, int)}, called by this method. Therefore, only
-
* {@link #onMeasure(int, int)} can and must be overridden by subclasses.
-
* </p>
-
*
-
*
-
* @param widthMeasureSpec Horizontal space requirements as imposed by the
-
* parent
-
* @param heightMeasureSpec Vertical space requirements as imposed by the
-
* parent
-
*
-
* @see #onMeasure(int, int)
-
*/
-
public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
-
boolean optical = isLayoutModeOptical(this);
-
if (optical != isLayoutModeOptical(mParent)) {
-
Insets insets = getOpticalInsets();
-
int oWidth = insets.left + insets.right;
-
int oHeight = insets.top + insets.bottom;
-
widthMeasureSpec = MeasureSpec.adjust(widthMeasureSpec, optical ? -oWidth : oWidth);
-
heightMeasureSpec = MeasureSpec.adjust(heightMeasureSpec, optical ? -oHeight : oHeight);
-
}
-
-
// Suppress sign extension for the low bytes
-
long key = (long) widthMeasureSpec << 32 | (long) heightMeasureSpec & 0xffffffffL;
-
if (mMeasureCache == null) mMeasureCache = new LongSparseLongArray(2);
-
-
final boolean forceLayout = (mPrivateFlags & PFLAG_FORCE_LAYOUT) == PFLAG_FORCE_LAYOUT;
-
-
// Optimize layout by avoiding an extra EXACTLY pass when the view is
-
// already measured as the correct size. In API 23 and below, this
-
// extra pass is required to make LinearLayout re-distribute weight.
-
final boolean specChanged = widthMeasureSpec != mOldWidthMeasureSpec
-
|| heightMeasureSpec != mOldHeightMeasureSpec;
-
final boolean isSpecExactly = MeasureSpec.getMode(widthMeasureSpec) == MeasureSpec.EXACTLY
-
&& MeasureSpec.getMode(heightMeasureSpec) == MeasureSpec.EXACTLY;
-
final boolean matchesSpecSize = getMeasuredWidth() == MeasureSpec.getSize(widthMeasureSpec)
-
&& getMeasuredHeight() == MeasureSpec.getSize(heightMeasureSpec);
-
final boolean needsLayout = specChanged
-
&& (sAlwaysRemeasureExactly || !isSpecExactly || !matchesSpecSize);
-
-
if (forceLayout || needsLayout) {
-
// first clears the measured dimension flag
-
mPrivateFlags &= ~PFLAG_MEASURED_DIMENSION_SET;
-
-
resolveRtlPropertiesIfNeeded();
-
-
int cacheIndex = forceLayout ? -1 : mMeasureCache.indexOfKey(key);
-
if (cacheIndex < 0 || sIgnoreMeasureCache) {
-
// measure ourselves, this should set the measured dimension flag back
-
onMeasure(widthMeasureSpec, heightMeasureSpec);
-
mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
-
} else {
-
long value = mMeasureCache.valueAt(cacheIndex);
-
// Casting a long to int drops the high 32 bits, no mask needed
-
setMeasuredDimensionRaw((int) (value >> 32), (int) value);
-
mPrivateFlags3 |= PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
-
}
-
-
// flag not set, setMeasuredDimension() was not invoked, we raise
-
// an exception to warn the developer
-
if ((mPrivateFlags & PFLAG_MEASURED_DIMENSION_SET) != PFLAG_MEASURED_DIMENSION_SET) {
-
throw new IllegalStateException("View with id " + getId() + ": "
-
+ getClass().getName() + "#onMeasure() did not set the"
-
+ " measured dimension by calling"
-
+ " setMeasuredDimension()");
-
}
-
-
mPrivateFlags |= PFLAG_LAYOUT_REQUIRED;
-
}
-
-
mOldWidthMeasureSpec = widthMeasureSpec;
-
mOldHeightMeasureSpec = heightMeasureSpec;
-
-
mMeasureCache.put(key, ((long) mMeasuredWidth) << 32 |
-
(long) mMeasuredHeight & 0xffffffffL); // suppress sign extension
-
}
1.1 参数解释
void measure(int widthMeasureSpec, int heightMeasureSpec) 先看这个函数的2个参数：
1.1.1 widthMeasureSpec参数
int widthMeasureSpec：父容器给的测量规格（宽度），用于测量当前子View的宽度，也就是说在测量View时不但要考虑自身内容的宽度，还要考虑父容器的限制, 例如父容器要求子View的宽度最大不能超过父容器它自身的宽度，这就是一个限制，这个宽度限制用这个参数 ”widthMeasureSpec“ 来表示，这个int型参数总共占4个字节32位，高2位代表”测量模式“，后30位是父容器给子View指定的宽度大小。也就是说widthMeasureSpec这个规格，总共由 测试模式与宽度大小组成。这里我们解释一下测量模式，最后随着对测量程序的深入分析，来指出这些测量模式有什么用。
测量模式分为3种：
1. MeasureSpec.UNSPECIFIED: 未限制，子VIEW想要多大就多大（宽、高），常见的是Scrollview作为父容器，ListView控件。
2. MeasureSpec.AT_MOST：限制子View的大小最大不能超过父容器的大小specialSize,specialSize就是widthMeasureSpec中低30个bit所表示的大小（包括宽、高）。
3. MeasureSpec.EXACTLY：父容器已经测出了子VIEW的大小， 为子VIEW指定了一个精确值，这个值就是specialSize。通常子VIEW的宽高属性是一个确定值或match_parent。
1.1.2 heightMeasureSpec参数
int heightMeasureSpec：父容器给的测量规格（高度），用于测量当前子View的高度，它的概念可以参考上述 widthMeasureSpec，也有3种测试模式，在此不再赘述。测量规格暂且先简单介绍到这里，我们继续分析测量过程，在分析代码的过程中理解MeasureSpec上述View的measure方法中可以得知最终调用了onMeasure(widthMeasureSpec,heightMeasureSpec),测量当前View的核心代码都在这个函数里，我们可以看到在这里将widthMeasureSpec和heightMeasureSpec续传给了onMeasure。
2. View.onMeasure
-
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
-
setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
-
getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
-
}
2.1 参数解释
参数：widthMeasureSpec，heightMeasureSpec，父容器给的测量约束（测量规格）；
widthMeasureSpec：horizontal space requirements as imposed by the parent. 水平空间上的约束，这个约束来自父容器； heightMeasureSpec：Vertical space requirements as imposed by the parent. 垂直空间上的约束，这个约束来自父容器。
2.2 onMeasure函数体分析
这个方法的作用测量当前View，和它里面的内容来决定View的宽、高
2.2.1 setMeasuredDimension作用
onMeasure中调用了setMeasuredDimension，用来存储View的宽高的，因为最终调用了setMeasuredDimensionRaw，而在setMeasuredDimensionRaw函数里将measuredWidth和measuredHeight保存在了View的成员变量里，代码如下：
-
private void setMeasuredDimensionRaw(int measuredWidth, int measuredHeight) {
-
mMeasuredWidth = measuredWidth;
-
mMeasuredHeight = measuredHeight;
-
-
mPrivateFlags |= PFLAG_MEASURED_DIMENSION_SET;
-
}
2.2.2 onMeasure深入分析
onMeasure通常会被子类重写，如FrameLayout里就重写了onMeasure函数，用于重新测量自己的宽高以及childview的宽高。那么我们就来分析一下FrameLayout的这个onMeasure函数，先贴出代码如下：
-
@Override
-
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
-
int count = getChildCount();
-
-
final boolean measureMatchParentChildren =
-
MeasureSpec.getMode(widthMeasureSpec) != MeasureSpec.EXACTLY ||
-
MeasureSpec.getMode(heightMeasureSpec) != MeasureSpec.EXACTLY;
-
mMatchParentChildren.clear();
-
-
int maxHeight = 0;
-
int maxWidth = 0;
-
int childState = 0;
-
-
for (int i = 0; i < count; i++) {
-
final View child = getChildAt(i);
-
if (mMeasureAllChildren || child.getVisibility() != GONE) {
-
measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, 0);
-
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
-
maxWidth = Math.max(maxWidth,
-
child.getMeasuredWidth() + lp.leftMargin + lp.rightMargin);
-
maxHeight = Math.max(maxHeight,
-
child.getMeasuredHeight() + lp.topMargin + lp.bottomMargin);
-
childState = combineMeasuredStates(childState, child.getMeasuredState());
-
if (measureMatchParentChildren) {
-
if (lp.width == LayoutParams.MATCH_PARENT ||
-
lp.height == LayoutParams.MATCH_PARENT) {
-
mMatchParentChildren.add(child);
-
}
-
}
-
}
-
}
-
-
// Account for padding too
-
maxWidth += getPaddingLeftWithForeground() + getPaddingRightWithForeground();
-
maxHeight += getPaddingTopWithForeground() + getPaddingBottomWithForeground();
-
-
// Check against our minimum height and width
-
maxHeight = Math.max(maxHeight, getSuggestedMinimumHeight());
-
maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());
-
-
// Check against our foreground's minimum height and width
-
final Drawable drawable = getForeground();
-
if (drawable != null) {
-
maxHeight = Math.max(maxHeight, drawable.getMinimumHeight());
-
maxWidth = Math.max(maxWidth, drawable.getMinimumWidth());
-
}
-
-
setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
-
resolveSizeAndState(maxHeight, heightMeasureSpec,
-
childState << MEASURED_HEIGHT_STATE_SHIFT));
-
-
count = mMatchParentChildren.size();
-
if (count > 1) {
-
for (int i = 0; i < count; i++) {
-
final View child = mMatchParentChildren.get(i);
-
final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();
-
-
final int childWidthMeasureSpec;
-
if (lp.width == LayoutParams.MATCH_PARENT) {
-
final int width = Math.max(0, getMeasuredWidth()
-
- getPaddingLeftWithForeground() - getPaddingRightWithForeground()
-
- lp.leftMargin - lp.rightMargin);
-
childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(
-
width, MeasureSpec.EXACTLY);
-
} else {
-
childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec,
-
getPaddingLeftWithForeground() + getPaddingRightWithForeground() +
-
lp.leftMargin + lp.rightMargin,
-
lp.width);
-
}
-
-
final int childHeightMeasureSpec;
-
if (lp.height == LayoutParams.MATCH_PARENT) {
-
final int height = Math.max(0, getMeasuredHeight()
-
- getPaddingTopWithForeground() - getPaddingBottomWithForeground()
-
- lp.topMargin - lp.bottomMargin);
-
childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(
-
height, MeasureSpec.EXACTLY);
-
} else {
-
childHeightMeasureSpec = getChildMeasureSpec(heightMeasureSpec,
-
getPaddingTopWithForeground() + getPaddingBottomWithForeground() +
-
lp.topMargin + lp.bottomMargin,
-
lp.height);
-
}
-
-
child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
-
}
-
}
-
}
2.2.2.1 onMeasure参数解释
首先这个onMeasure的功能是测量Framelayout这个父布局的宽高，onMeasure的两个参数widthMeasureSpec和heightMeasureSpec是这个FrameLayout的父容器给这个FrameLayout的宽、高约束规格，在这里我们以DecorView为例（DecorView继承于FrameLayout，DecorView的onMeasure最终还是调用了FrameLayout的onMeasure），它的父容器是window窗口，window窗口给DecorView的宽高约束是：大小为windowSize，测量模式为MeasureSpec.EXACTLY，说明DecorView将来的宽高正好是一个确切值：windowSize，即宽高铺满整个屏幕。
下面两行代码就是window窗口为Decorview创建的宽，高规格，我们发现大小为windowSize，模式为EXACTLY
widthMeasureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.EXACTLY);
heightMeasureSpec= MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.EXACTLY);
那么为什么说在EXACTLY模式下，DecorView的宽高，正好是windowSize呢，这个结论是如何得出的呢？
我们看onMeasure函数中的这段代码：
-
setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
-
resolveSizeAndState(maxHeight, heightMeasureSpec,
-
childState << MEASURED_HEIGHT_STATE_SHIFT));
这个函数比较熟悉吧，它就是最终用来保存一个容器ViewGroup（或view）的宽高的，将宽高值赋值给了view的成员变量：mMeasuredWidth，mMeasuredHeight;
resolveSizeAndState函数，在这里分别确定了宽高值，我们来分析一下resolveSizeAndState内部代码，就会得出上面那个结论：EXACTLY模式下，DecorView的宽高，正好是windowSize。贴出resolveSizeAndState函数的函数体如下：
-
/**
-
* Utility to reconcile a desired size and state, with constraints imposed
-
* by a MeasureSpec. Will take the desired size, unless a different size
-
* is imposed by the constraints. The returned value is a compound integer,
-
* with the resolved size in the {@link #MEASURED_SIZE_MASK} bits and
-
* optionally the bit {@link #MEASURED_STATE_TOO_SMALL} set if the
-
* resulting size is smaller than the size the view wants to be.
-
*
-
* @param size How big the view wants to be.
-
* @param measureSpec Constraints imposed by the parent.
-
* @param childMeasuredState Size information bit mask for the view's
-
* children.
-
* @return Size information bit mask as defined by
-
* {@link #MEASURED_SIZE_MASK} and
-
* {@link #MEASURED_STATE_TOO_SMALL}.
-
*/
-
public static int resolveSizeAndState(int size, int measureSpec, int childMeasuredState) {
-
final int specMode = MeasureSpec.getMode(measureSpec);
-
final int specSize = MeasureSpec.getSize(measureSpec);
-
final int result;
-
switch (specMode) {
-
case MeasureSpec.AT_MOST:
-
if (specSize < size) {
-
result = specSize | MEASURED_STATE_TOO_SMALL;
-
} else {
-
result = size;
-
}
-
break;
-
case MeasureSpec.EXACTLY:
-
result = specSize;
-
break;
-
case MeasureSpec.UNSPECIFIED:
-
default:
-
result = size;
-
}
-
return result | (childMeasuredState & MEASURED_STATE_MASK);
-
}
-
final int specMode = MeasureSpec.getMode(measureSpec);
-
获取父容器给的宽（高）规格中的测试模式，在这里specMode 是EXACT,因为Window（父容器）给Decorview（子ViewGroup）
-
的测试模式就是EXACT ,final int specSize = MeasureSpec.getSize(measureSpec);获取获取父容器给的宽（高）规格中的大小，
-
在这里因为测试模式是EXACT，所以将来Decorview的宽（高）就是一个精确值：specSize，代码依据如下：
-
case MeasureSpec.EXACTLY:
-
result = specSize;
-
break;
Ok，我们总结一下我们上面所讲的，我们主要说明了
onMeasure(int widthMeasureSpec, int heightMeasureSpec)中的两个参数widthMeasureSpec和heightMeasureSpec，
是父容器给的测量规格，用以测量当前FrameLayout（ViewGroup）的宽和高，同时当测量规格中的测量模式为EXACT时，
那么当前FrameLayout（ViewGroup）的宽和高就是测量规格中指定的宽和高，也就是说父容器指示给它的大小。
2.2.2.2 测量自己先得测量出子child
1. for循环测量各child的宽高，才能测量出自己的宽高
接下来继续看一下这个FrameLayout（ViewGroup）的测量函数onMeasure,内部有一个for循环，用于测量当前FrameLayout的子View。这里为什么要去测量FrameLayout的子View呢？如果子View又是一个ViewGroup容器类型，那么将继续嵌套递归测量更深层次的子View，直到子View不是一个容器，就可以结束了，并逐渐递归返回了。这里我们先贴出代码再加以分析，for循环测量子View的代码如下：
-
for (int i = 0; i < count; i++) {
-
final View child = getChildAt(i);
-
if (mMeasureAllChildren || child.getVisibility() != GONE) {
-
measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, 0);
-
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
-
maxWidth = Math.max(maxWidth,
-
child.getMeasuredWidth() + lp.leftMargin + lp.rightMargin);
-
maxHeight = Math.max(maxHeight,
-
child.getMeasuredHeight() + lp.topMargin + lp.bottomMargin);
-
childState = combineMeasuredStates(childState, child.getMeasuredState());
-
if (measureMatchParentChildren) {
-
if (lp.width == LayoutParams.MATCH_PARENT ||
-
lp.height == LayoutParams.MATCH_PARENT) {
-
mMatchParentChildren.add(child);
-
}
-
}
-
}
-
}
首先，我们来回答我们刚才提出的问题，为什么要去测量子View？这是因为当前容器的大小有时候会受子View大小的影响，例如当FrameLaout的宽高属性设置为wrap_content时。FrameLaout的宽应该取各个子View宽度的最大值，同理高度也一样，取Views高度的最大值。
下面这个函数就是用于测量子View的宽高。
measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, 0);
下面这段代码就是用于获取各个子View的宽高的最大值。
-
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
-
maxWidth = Math.max(maxWidth,
-
child.getMeasuredWidth() + lp.leftMargin + lp.rightMargin);
-
maxHeight = Math.max(maxHeight,
-
child.getMeasuredHeight() + lp.topMargin + lp.bottomMargin);
我们再回头看一下这行代码：
-
setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
-
resolveSizeAndState(maxHeight, heightMeasureSpec,
-
childState << MEASURED_HEIGHT_STATE_SHIFT));
其中resolveSizeAndState函数，给当前FrameLayout的默认宽高正是maxWidth,maxHeight,然后再结合widthMeasureSpec和heightMeasureSpec来共同决定当前FrameLayout容器的最终大小。
2. measureChildWithMargins分析（深入分析如何测量child）
measureChildWithMargins配合for循环用来测量FrameLayout的各个子View的宽高，我们来分析它的源码。源码如下：
-
/**
-
* Ask one of the children of this view to measure itself, taking into
-
* account both the MeasureSpec requirements for this view and its padding
-
* and margins. The child must have MarginLayoutParams The heavy lifting is
-
* done in getChildMeasureSpec.
-
*
-
* @param child The child to measure
-
* @param parentWidthMeasureSpec The width requirements for this view
-
* @param widthUsed Extra space that has been used up by the parent
-
* horizontally (possibly by other children of the parent)
-
* @param parentHeightMeasureSpec The height requirements for this view
-
* @param heightUsed Extra space that has been used up by the parent
-
* vertically (possibly by other children of the parent)
-
*/
-
protected void measureChildWithMargins(View child,
-
int parentWidthMeasureSpec, int widthUsed,
-
int parentHeightMeasureSpec, int heightUsed) {
-
final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();
-
-
final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
-
mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin
-
+ widthUsed, lp.width);
-
final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
-
mPaddingTop + mPaddingBottom + lp.topMargin + lp.bottomMargin
-
+ heightUsed, lp.height);
-
-
child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
-
}
（1）参数说明
protected void measureChildWithMargins(
View child, ： 被测量的child
int parentWidthMeasureSpec, 父容器的测量宽度规格（即child的 “祖父容器” 给child的父容器的测量规格）
int widthUsed, child的父容器已被其它子child占用的宽度空间
int parentHeightMeasureSpec, 父容器的测量高度规格（即child的 “祖父容器” 给child的父容器的测量规格）
int heightUsed child的父容器已被其它子child占用的高度空间
)
（2）. 测量child的流程
1）按照惯例，需先得到child的父容器指定给child的测量规格，childWidthMeasureSpec 和childHeightMeasureSpec 。
measureChildWithMargins函数的如下代码实现了childWidthMeasureSpec和childHeightMeasureSpec的生成。
-
final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
-
mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin
-
+ widthUsed, lp.width);
-
final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
-
mPaddingTop + mPaddingBottom + lp.topMargin + lp.bottomMargin
-
+ heightUsed, lp.height);
我们可以看到getChildMeasureSpec函数，用到了parentWidthMeasureSpec和parentHeightMeasureSpec，可见子child的测量规格的生成离不开它的父容器的测量规格。我们深入getChildMeasureSpec：
-
/**
-
* Does the hard part of measureChildren: figuring out the MeasureSpec to
-
* pass to a particular child. This method figures out the right MeasureSpec
-
* for one dimension (height or width) of one child view.
-
*
-
* The goal is to combine information from our MeasureSpec with the
-
* LayoutParams of the child to get the best possible results. For example,
-
* if the this view knows its size (because its MeasureSpec has a mode of
-
* EXACTLY), and the child has indicated in its LayoutParams that it wants
-
* to be the same size as the parent, the parent should ask the child to
-
* layout given an exact size.
-
*
-
* @param spec The requirements for this view
-
* @param padding The padding of this view for the current dimension and
-
* margins, if applicable
-
* @param childDimension How big the child wants to be in the current
-
* dimension
-
* @return a MeasureSpec integer for the child
-
*/
-
public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
-
int specMode = MeasureSpec.getMode(spec);
-
int specSize = MeasureSpec.getSize(spec);
-
-
int size = Math.max(0, specSize - padding);
-
-
int resultSize = 0;
-
int resultMode = 0;
-
-
switch (specMode) {
-
// Parent has imposed an exact size on us
-
case MeasureSpec.EXACTLY:
-
if (childDimension >= 0) {
-
resultSize = childDimension;
-
resultMode = MeasureSpec.EXACTLY;
-
} else if (childDimension == LayoutParams.MATCH_PARENT) {
-
// Child wants to be our size. So be it.
-
resultSize = size;
-
resultMode = MeasureSpec.EXACTLY;
-
} else if (childDimension == LayoutParams.WRAP_CONTENT) {
-
// Child wants to determine its own size. It can't be
-
// bigger than us.
-
resultSize = size;
-
resultMode = MeasureSpec.AT_MOST;
-
}
-
break;
-
-
// Parent has imposed a maximum size on us
-
case MeasureSpec.AT_MOST:
-
if (childDimension >= 0) {
-
// Child wants a specific size... so be it
-
resultSize = childDimension;
-
resultMode = MeasureSpec.EXACTLY;
-
} else if (childDimension == LayoutParams.MATCH_PARENT) {
-
// Child wants to be our size, but our size is not fixed.
-
// Constrain child to not be bigger than us.
-
resultSize = size;
-
resultMode = MeasureSpec.AT_MOST;
-
} else if (childDimension == LayoutParams.WRAP_CONTENT) {
-
// Child wants to determine its own size. It can't be
-
// bigger than us.
-
resultSize = size;
-
resultMode = MeasureSpec.AT_MOST;
-
}
-
break;
-
-
// Parent asked to see how big we want to be
-
case MeasureSpec.UNSPECIFIED:
-
if (childDimension >= 0) {
-
// Child wants a specific size... let him have it
-
resultSize = childDimension;
-
resultMode = MeasureSpec.EXACTLY;
-
} else if (childDimension == LayoutParams.MATCH_PARENT) {
-
// Child wants to be our size... find out how big it should
-
// be
-
resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
-
resultMode = MeasureSpec.UNSPECIFIED;
-
} else if (childDimension == LayoutParams.WRAP_CONTENT) {
-
// Child wants to determine its own size.... find out how
-
// big it should be
-
resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
-
resultMode = MeasureSpec.UNSPECIFIED;
-
}
-
break;
-
}
-
//noinspection ResourceType
-
return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
-
}
目前对于DecorView来说，这里的specMode就是EXACT, specSize实质就是child的父容器FrameLayout的宽高。
int size = Math.max(0, specSize - padding);中的size实质就是父容器DecorView留给child的最大空间。
当
childDimension>0 时，说明child的宽，高属性是一个数值，一个确切的值，那么结合父容器DecorView的测量模式为EXACT，会为child生成一个EXACT模式的测量规格，大小就是这个确切值：childDimension; 最终计算出两个测量规格childWidthMeasureSpec 和childHeightMeasureSpec，它们的测量模式都是EXACT，指定child的大小是一个精确值childDimension。
childDimension为match_parent时，说明child的宽，高是铺满整个父容器DecorView的，所以child的宽，高是确定的，就是父容器的宽，高(这里为可利用区域的宽，高)。所以在这里为child生成了一个EXACT模式的测量规格，并且大小是size（父容器的宽高减去父容器的padding和child的margin，即父容器的可利用区域，同时也是child所能占用的空间）。最终计算出两个测量规格childWidthMeasureSpec 和childHeightMeasureSpec，它们的测量模式都是EXACT，指定child的大小是一个精确值size。
childDimension为wrap_content,说明child的宽，高是随自己内容的大小而变化的，但是最大不能超过父容器给的可利用区域，即size. 所以在这里为child生成了一个测量模式为AT_MOST的测量规格，大小为size,也就是说 child想要多大（宽和高）凭自己的内容大小，但是最大不能超过 size。最终生成两个测量规格childWidthMeasureSpec 和childHeightMeasureSpec，它们的测量模式都是AT_MOST，指定child的大小最大不能超过size的值。
好了，有了childWidthMeasureSpec 和childHeightMeasureSpec，就可以用这两个测量规格（约束）来测量自己了，childWidthMeasureSpec 和childHeightMeasureSpec实质就是child的父容器给child的测量规格，因为它们的生成，用到了父容器自己的测量规格，结合child的 宽高属性配置（childDimension），所以说childWidthMeasureSpec 和childHeightMeasureSpec是父容器(DecorView)给child的测量规格，一点儿也不为过。
在这里我们只分析了父容器测量规格是EXACT的情况下，如何生成child的测量规格，至于其它测量模式的分支代码，读者可以自行分析。
Ok，child得到了childWidthMeasureSpec 和childHeightMeasureSpec，接下来就可以测量自己了，然后调用
child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
这行代码我们似曾相识，我们可以知道child.measure完后，又会调用child.onMeasure,就又会走一遍我们上面分析的onMeasure的代码，如果当前child是一个类似于DecorView的ViewGroup容器的话，有会用for循环去测量当前child的child，是一个不断嵌套递归的过程。如果child本身就是叶子节点，是一个普通的view，则for循环不会进入，直接调用onMeasure中的
-
setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
-
resolveSizeAndState(maxHeight, heightMeasureSpec,
-
childState << MEASURED_HEIGHT_STATE_SHIFT));
就能测量出它的大小，然后递归返回child测量出的宽，高，作为child的父容器DecorView(FrameLayout extends ViewGroup)测量宽高的依据或者说参数吧。
3. 总结：
所谓递归，就是要测量自身（继承于ViewGroup的容器）的大小，先得测量出child的大小，要想测出child的大小，又得先测量出child的child的大小。最终的叶子节点child的大小测量出之后，会层层返回（归的含义），逐层测量出每一个阶段的child的大小，最终递归到最外层的父容器，从而得到最初的父容器的大小，当然在这个递归过程中，各层的容器或view都得到了测量。所以，一个View（ViewGroup）的测量是一个递归的过程，同时每一层View的测量都离不开上层容器指定给它的两个测量规格：childWidthMeasureSpec 和childHeightMeasureSpec。
文章来源: blog.csdn.net，作者：冉航--小虾米，版权归原作者所有，如需转载，请联系作者。
原文链接：blog.csdn.net/gaoxiaoweiandy/article/details/101163576