大家先看一段代码
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent">
<LinearLayout
android:layout_width="match_parent"
android:layout_height="200dp"
android:orientation="vertical"
android:background="@mipmap/ic_launcher"
>
<View
android:layout_width="match_parent"
android:layout_height="200dp"
android:layout_weight="1"
android:background="@color/colorAccent"
/>
<View
android:layout_width="match_parent"
android:layout_height="60dp"
android:layout_weight="1"
android:background="@color/colorPrimary"
/>
</LinearLayout>
</LinearLayout>
你觉得上面布局中，两个View实际分配到的高度是多少？大家可以将代码运行下，其实最终第一个View分配到的高度是170dp，第二个是30dp；为什么呢，这就要熟读下面的分析了。
void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {
//记录测量的高度
mTotalLength = 0;
//记录LineraLayout 的最大宽度，每次测量子view时，都会对maxWidth赋值
int maxWidth = 0;
int childState = 0;
int alternativeMaxWidth = 0;
//记录设有权重的view的最大宽度
int weightedMaxWidth = 0;
boolean allFillParent = true;
//所有权重总和
float totalWeight = 0;
//所有子view数量
final int count = getVirtualChildCount();
//获取宽度测量模式
final int widthMode = MeasureSpec.getMode(widthMeasureSpec);
//获取高度测量模式
final int heightMode = MeasureSpec.getMode(heightMeasureSpec);
boolean matchWidth = false;
boolean skippedMeasure = false;
//这个baselineChildIndex 是什么东西
final int baselineChildIndex = mBaselineAlignedChildIndex;
//是否使用最大View的尺寸，默认情况下很少使用
final boolean useLargestChild = mUseLargestChild;
int largestChildHeight = Integer.MIN_VALUE;
//记录被消费的控件
int consumedExcessSpace = 0;
//记录真正测量的子view，即排除view==null或者view可见性为View.GONE
int nonSkippedChildCount = 0;
for (int i = 0; i < count; ++i) {
final View child = getVirtualChildAt(i);
if (child == null) {
//measureNullChild一般默认返回0；
mTotalLength += measureNullChild(i);
continue;
}
if (child.getVisibility() == View.GONE) {
//getChildrenSkipCount一般默认返回0；
i += getChildrenSkipCount(child, i);
continue;
}
nonSkippedChildCount++;
//如果子view之间有分割线，记录分割线的高度
if (hasDividerBeforeChildAt(i)) {
mTotalLength += mDividerHeight;
}
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
//累加设有权重的view
totalWeight += lp.weight;
final boolean useExcessSpace = lp.height == 0 && lp.weight > 0;
if (heightMode == MeasureSpec.EXACTLY && useExcessSpace) {
//如果是精确测量模式，并且子view属性layout_height=0；layout_weight>0 ;对于这种view，我们先不对view测量，先记录下topMargin和bottomMargin ，为什么要这样？把其他view消耗的高度测量出来，剩余高度然后根据权重比重新分配给设有权重的View，因此，我们在写LineraLayout布局时，layout_heigith>0的View，总是优先分配高度
mTotalLength = Math.max(totalLength, totalLength + lp.topMargin + lp.bottomMargin);
skippedMeasure = true;
} else {
/**
这个分支分以下几种情况
1.AT_MOST
1.1.height=0 && weight =0
1.2.height>0&&weight=0
1.3.height=0&&weight>0(在后面源码中设置成了同1.5)
1.4.height>0&&weihgt>0
1.5.height=wrap_parent&&weight>0
1.6.height=wrap_parent&&weight=0
1.7.height=match_parent&&weight>0
1.8.height=match_parent&&weight=0
2.EXACTLY
2.1.height=0 && weight =0
2.2.height>0&&weight=0
2.3.height>0&&weihgt>0
2.4.height=wrap_parent&&weight>0
2.5.height=wrap_parent&&weight=0
2.6.height=match_parent&&weight>0
2.7.height=match_parent&&weight=0
2.8.height=0&&weight>0(这个情况不会出现在这个分支，放一起好分析)
从上面情况结合下面measureChildBeforeLayout方法可以得出结论：
a.1.1;1.2;1.4;2.1;2.2;2.3;测得子view的height为view中的LayoutParams中的height，自己对自己的子view的测量模式为EXACTLY
b.1.3;1.5;1.6;1.7;1.8;2.4;2.5;测得子view的height为父view中期望高度-已使用的高度-子view的padding-子view中的margin，自己对自己的子view的测量模式为AT_MOST
c.2.6;2.7;测得子view的height为父view中期望高度-已使用的高度-子view的padding-子view中的margin，自己对自己的子view的测量模式为EXACTLY
d.2.8;只有某一个子view是2.8这种情况或者在a,b,c 这几种情况测量完成后剩余空间不为0（大于或小于0）并且子view中有weight>0d的，二者满足其一会再一次对权重大于0 的子view调试尺寸
*/
if (useExcessSpace) {
//对于1.3.height=0&&weight>0；为什么要这样设置，因为这样能给这类子view于父View中剩余最大高度尺寸，能最大限度的满足子view；无疑这样设计是最佳的选择
lp.height = LayoutParams.WRAP_CONTENT;
}
/*usedHeight 已使用的高度，如果totalWeight>0,说明之前有view设有权重，这里就采用了一种策略，先尽可能的给予每个设有权重的子view最大尺寸高度，后面再根据策略调整。*/
final int usedHeight = totalWeight == 0 ? mTotalLength : 0;
//测量子view的尺寸
measureChildBeforeLayout(child, i, widthMeasureSpec, 0,
heightMeasureSpec, usedHeight);
final int childHeight = child.getMeasuredHeight();
if (useExcessSpace) {
consumedExcessSpace += childHeight;
}
final int totalLength = mTotalLength;
//累计总高度
mTotalLength = Math.max(totalLength, totalLength + childHeight + lp.topMargin +
lp.bottomMargin + getNextLocationOffset(child));
//是否用最大view尺寸，不分析，默认不使用
if (useLargestChild) {
largestChildHeight = Math.max(childHeight, largestChildHeight);
}
}
if ((baselineChildIndex >= 0) && (baselineChildIndex == i + 1)) {
mBaselineChildTop = mTotalLength;
}
//view索引小于baselineChildIndex，如果设置了lp.weight 会有异常
if (i < baselineChildIndex && lp.weight > 0) {
throw new RuntimeException("A child of LinearLayout with index "
+ "less than mBaselineAlignedChildIndex has weight > 0, which "
+ "won't work. Either remove the weight, or don't set "
+ "mBaselineAlignedChildIndex.");
}
boolean matchWidthLocally = false;
if (widthMode != MeasureSpec.EXACTLY && lp.width == LayoutParams.MATCH_PARENT) {
//这种模式下，如果缩放LineraLayout ，view也需要相应重新测量，所以这里先做个标记，如果子view中有该种模式；
matchWidth = true;
matchWidthLocally = true;
}
final int margin = lp.leftMargin + lp.rightMargin;
final int measuredWidth = child.getMeasuredWidth() + margin;
maxWidth = Math.max(maxWidth, measuredWidth);
childState = combineMeasuredStates(childState, child.getMeasuredState());
allFillParent = allFillParent && lp.width == LayoutParams.MATCH_PARENT;
if (lp.weight > 0) {
weightedMaxWidth = Math.max(weightedMaxWidth,
matchWidthLocally ? margin : measuredWidth);
} else {
alternativeMaxWidth = Math.max(alternativeMaxWidth,
matchWidthLocally ? margin : measuredWidth);
}
//获取需要跳过测量的标示，getChildrenSkipCount默认返回0，如果返回1，则代表下一个view不需要测量
i += getChildrenSkipCount(child, i);
}
/*for循环结束，初步测量完成，总结下上面for循环干了啥事
1.测量出部分子view的高度，（父View为EXACTLY并且子view高度和weight都为0 ，这里view先不测量其高度，）
2.记录总的需要的高度如：mTotalLength，mTotalLength包含已测量的部分view 的高度和margin，分割线，父View为EXACTLY并且子view高度和weight都为0这类view的margin*/
if (nonSkippedChildCount > 0 && hasDividerBeforeChildAt(count)) {
mTotalLength += mDividerHeight;
}
//如果使用了使用最大子view尺寸，并且父view模式为Wrap_content,则需要重新计算mTotalLength，所以最好不要设置useLargestChild，效率低
if (useLargestChild &&
(heightMode == MeasureSpec.AT_MOST || heightMode == MeasureSpec.UNSPECIFIED)) {
mTotalLength = 0;
for (int i = 0; i < count; ++i) {
final View child = getVirtualChildAt(i);
if (child == null) {
mTotalLength += measureNullChild(i);
continue;
}
if (child.getVisibility() == GONE) {
i += getChildrenSkipCount(child, i);
continue;
}
final LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams)
child.getLayoutParams();
// Account for negative margins
final int totalLength = mTotalLength;
mTotalLength = Math.max(totalLength, totalLength + largestChildHeight +
lp.topMargin + lp.bottomMargin + getNextLocationOffset(child));
}
}
// Add in our padding
mTotalLength += mPaddingTop + mPaddingBottom;
int heightSize = mTotalLength;
// Check against our minimum height
//看下是否有背景宽高，取二者大的
heightSize = Math.max(heightSize, getSuggestedMinimumHeight());
//对比下heightSize 与父view期望的高度
//1.如果父view测量模式是EXACTLY，heightSizeAndState 赋值为父view的期望高度
//2.如果父view测量模式是AT_MOST，heightSizeAndState 赋值为父view的期望高度与heightSize 哪个小就用哪个；
int heightSizeAndState = resolveSizeAndState(heightSize, heightMeasureSpec, 0);
heightSize = heightSizeAndState & MEASURED_SIZE_MASK;
/**
remainingExcess的值用来判断剩余空间以便来决定是否需要缩小或者扩大weight>0的子view，如果remainingExcess的值大于0，则会扩大部分View高度，如果remainingExcess小于0，则会缩小部分view高度，remainingExcess等于0，就不用再测量，这是效率最高的测量模式。平时开发应该尽量满足。为什么remainingExcess会小于0，在上面的测量中，有如果view的高度在xml明确写明了的话，会直接将该高度作为初步测量高度。mTotalLength是每个测量好的view高度的累计，比如父view高度为100dp，但是子view有几个50dp的，那最终mTotalLength的高度肯定高于heightSize*/
int remainingExcess = heightSize - mTotalLength
+ (mAllowInconsistentMeasurement ? 0 : consumedExcessSpace);
/*下面的if条件满足以下其一都执行，if里面的逻辑主要是缩放子view
1.如果子view中满足父View为EXACTLY，子view高度和weight都为0
2.remainingExcess！=0 && 至少一个子view中的weight>0*/
if (skippedMeasure
|| ((sRemeasureWeightedChildren || remainingExcess != 0) && totalWeight > 0.0f)) {
float remainingWeightSum = mWeightSum > 0.0f ? mWeightSum : totalWeight;
//下面要重新计量高度了
mTotalLength = 0;
for (int i = 0; i < count; ++i) {
final View child = getVirtualChildAt(i);
if (child == null || child.getVisibility() == View.GONE) {
continue;
}
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
final float childWeight = lp.weight;
if (childWeight > 0) {
//share的值如果大于0；说明是给满足条件的view放大；如果小于0；则是缩小满足条件的
final int share = (int) (childWeight * remainingExcess / remainingWeightSum);
remainingExcess -= share;
remainingWeightSum -= childWeight;
final int childHeight;
//mUseLargestChild 默认为false
if (mUseLargestChild && heightMode != MeasureSpec.EXACTLY) {
childHeight = largestChildHeight;
} else if (lp.height == 0 && (!mAllowInconsistentMeasurement
|| heightMode == MeasureSpec.EXACTLY)) {
//这个就是为父View为EXACTLY，子view高度和weight都为0的这类view高度赋值，这类view在前面并没有参与测量。这类view的高度分配权最低；
childHeight = share;
} else {
//这类view为前面参与测量的view，重新分配高度
childHeight = child.getMeasuredHeight() + share;
}
//经过这次调整的View，都将自己对子view的高度测量模式设置为EXACTLY了，因为这次所有的view的高度尺寸都已知道了。
final int childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(
Math.max(0, childHeight), MeasureSpec.EXACTLY);
final int childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec,
mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin,
lp.width);
child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
// Child may now not fit in vertical dimension.
childState = combineMeasuredStates(childState, child.getMeasuredState()
& (MEASURED_STATE_MASK>>MEASURED_HEIGHT_STATE_SHIFT));
}
final int margin = lp.leftMargin + lp.rightMargin;
final int measuredWidth = child.getMeasuredWidth() + margin;
maxWidth = Math.max(maxWidth, measuredWidth);
boolean matchWidthLocally = widthMode != MeasureSpec.EXACTLY &&
lp.width == LayoutParams.MATCH_PARENT;
alternativeMaxWidth = Math.max(alternativeMaxWidth,
matchWidthLocally ? margin : measuredWidth);
allFillParent = allFillParent && lp.width == LayoutParams.MATCH_PARENT;
final int totalLength = mTotalLength;
mTotalLength = Math.max(totalLength, totalLength + child.getMeasuredHeight() +
lp.topMargin + lp.bottomMargin + getNextLocationOffset(child));
}
// Add in our padding
mTotalLength += mPaddingTop + mPaddingBottom;
// TODO: Should we recompute the heightSpec based on the new total length?
} else {
alternativeMaxWidth = Math.max(alternativeMaxWidth,
weightedMaxWidth);
// We have no limit, so make all weighted views as tall as the largest child.
// Children will have already been measured once.
if (useLargestChild && heightMode != MeasureSpec.EXACTLY) {
for (int i = 0; i < count; i++) {
final View child = getVirtualChildAt(i);
if (child == null || child.getVisibility() == View.GONE) {
continue;
}
final LinearLayout.LayoutParams lp =
(LinearLayout.LayoutParams) child.getLayoutParams();
float childExtra = lp.weight;
if (childExtra > 0) {
child.measure(
MeasureSpec.makeMeasureSpec(child.getMeasuredWidth(),
MeasureSpec.EXACTLY),
MeasureSpec.makeMeasureSpec(largestChildHeight,
MeasureSpec.EXACTLY));
}
}
}
}
if (!allFillParent && widthMode != MeasureSpec.EXACTLY) {
maxWidth = alternativeMaxWidth;
}
maxWidth += mPaddingLeft + mPaddingRight;
// Check against our minimum width
maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());
setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
heightSizeAndState);
if (matchWidth) {
forceUniformWidth(count, heightMeasureSpec);
}
}
通过上面的分析，可以总结如下集中模式，以后LinearLayout布局高度尺寸分配有什么疑惑直接套用就行了
1.父View高度测量模式AT_MOST
1.1.height=0 && weight =0(最终测量的高度为0)
1.2.height>0&&weight=0 （最终测量的高度为height）
1.3.height=0&&weight>0(最终测量的高度父view期望高度-已消耗的高度-padding-margin+调整尺寸)
1.4.height>0&&weihgt>0(height+调整尺寸)
1.5.height=wrap_parent&&weight>0(最终测量的高度父view期望高度-已消耗的高度-padding-margin+调整尺寸)
1.6.height=wrap_parent&&weight=0(最终测量的高度父view期望高度-已消耗的高度-padding-margin)
1.7.height=match_parent&&weight>0(最终测量的高度父view期望高度-已消耗的高度-padding-margin+调整尺寸)
1.8.height=match_parent&&weight=0(最终测量的高度父view期望高度-已消耗的高度-padding-margin)
2.父View高度测量模式EXACTLY
2.1.height=0 && weight =0(最终测量的高度为0)
2.2.height>0&&weight=0(最终测量的高度为height)
2.3.height>0&&weihgt>0(height+调整尺寸)
2.4.height=wrap_parent&&weight>0(最终测量的高度父view期望高度-已消耗的高度-padding-margin+调整尺寸)
2.5.height=wrap_parent&&weight=0(最终测量的高度父view期望高度-已消耗的高度-padding-margin)
2.6.height=match_parent&&weight>0(最终测量的高度父view期望高度-已消耗的高度-padding-margin+调整尺寸)
2.7.height=match_parent&&weight=0(最终测量的高度父view期望高度-已消耗的高度-padding-margin)
2.8.height=0&&weight>0(调整尺寸)
以上如果最终高度小0，则设置为0；
我们用这几种模式来套用开头的案例，案例中：父View高度为200dp,测量模式为EXACTLY,有两个子View，view1 高度为200dp，weight=1；view2高度为60dp，weight=1;
分析：两个子view都符合2.3这种情况；那么我们来看看其最终高度view1=200+调整尺寸；view2=60+调整尺寸；调整尺寸 = （父View高度-子view1高度-子view2高度）/2 = （200-200-60）/2 = -30 ;所以最终
view1的高度=200+（-30）=170；
view2的高度=60+（-30）=30；
当然以上计算还不严谨，但基本上可以用这个模型来阐述整个测量流程。算是有理有据吧。
好了再总结下流程和关键点
1.第一个for循环，首先是筛选出一批View先测量（父View高度测量模式== MeasureSpec.EXACTLY && lp.height == 0 && lp.weight > 0 ；这类view放后面测量）
2.计算下剩余高度（这个高度控制在父View期望高度以内，参看这句代码heightSizeAndState = resolveSizeAndState(heightSize, heightMeasureSpec, 0)）
3.a,如果高度有剩余,b.至少有一个子view为：父View高度测量模式== MeasureSpec.EXACTLY && lp.height == 0 && lp.weight > 0 ；c.至少一个子view的weight>0;如果满足a||(b&&c)则进入第二个for循环调整权重大于0的子view的高度
经过上面3个主要流程关键点，LinearLayout内部测量算是完成了。
通过以上学习，我们自问自答下。
1.通过这么多的测量，最终测量出来的高度会不会超过父view期望的高度？回答是不会。具体原因请参看文中int heightSizeAndState = resolveSizeAndState(heightSize, heightMeasureSpec, 0);这句代码上的解释。
2.如何提高测量效率？少用weight，少用userLargest模式
3.如何绘制分割线，如果控制是否需要测量？参考分析源码
写在后文：忘各位同道指正评论。
