LinearLayout源码详解，android项目实例源码

int nonSkippedChildCount &＃61; 0;

首先初始化了一大堆常量&＃xff0c;这里我们只需要关注我注释了的几个就好了

for (int i &＃61; 0; i final View child &＃61; getVirtualChildAt(i);
if (child &＃61;&＃61; null) {
mTotalLength &＃43;&＃61; measureNullChild(i);
continue;
}

if (child.getVisibility() &＃61;&＃61; View.GONE) {
i &＃43;&＃61; getChildrenSkipCount(child, i);
continue;
}

nonSkippedChildCount&＃43;&＃43;;
if (hasDividerBeforeChildAt(i)) {
mTotalLength &＃43;&＃61; mDividerHeight;
}

首先是将子控件取出来&＃xff0c;判断控件是否为null&＃xff0c;如果为空或者Visibility为gone就直接下一个控件&＃xff0c;这里也可以看出来gone与invisible的区别&＃xff0c;如果有分割线&＃xff0c;再将分割线的高度也加上

//有时候我们在代码里面通过Inflater服务&＃xff0c;动态加载一个布局&＃xff0c;然后去设置他的LayoutParams&＃xff0c;如果不引用父容器的LayoutParams就会报一个强转错误&＃xff0c;原因就在这个 父容器在add,measure的时候都会把子View的LayoutParams强转成自己的类型
final LayoutParams lp &＃61; (LayoutParams) child.getLayoutParams();

// 得到每个子控件的LayoutParams后&＃xff0c;累加权重和&＃xff0c;后面用于跟weightSum相比较
totalWeight &＃43;&＃61; lp.weight;

// 我们都知道&＃xff0c;测量模式有三种&＃xff1a;
// * UNSPECIFIED&＃xff1a;父控件对子控件无约束&＃xff0c;一般只有在ScrollView这种滑动布局中才会用到
// * Exactly&＃xff1a;父控件对子控件强约束&＃xff0c;子控件永远在父控件边界内&＃xff0c;越界则裁剪。如果要记忆的话&＃xff0c;可以记忆为有对应的具体数值或者是Match_parent
// * AT_Most&＃xff1a;子控件为wrap_content的时候&＃xff0c;测量值为AT_MOST。

//下面的if/else分支都是跟weight相关
final boolean useExcessSpace &＃61; lp.height &＃61;&＃61; 0 && lp.weight > 0;
if (heightMode &＃61;&＃61; MeasureSpec.EXACTLY && useExcessSpace) {
// 这个if里面需要满足三个条件&＃xff1a;
// * LinearLayout的高度为match_parent(或者有具体值)
// * 子控件的高度为0
// * 子控件的weight>0
// 这其实就是我们通常情况下用weight时的写法
// 测量到这里的时候&＃xff0c;会给个标志位&＃xff0c;稍后再处理。此时会计算总高度
// 除开这种情况的子控件不需要measure&＃xff0c;其他的子控件都需要被measure一次&＃xff0c;所以这样设置属性也可以提升性能

// Optimization: don’t bother measuring children who are only
// laid out using excess space. These views will get measured
// later if we have space to distribute.
//优化:不要麻烦测量那些只使用多余空间的孩子。如果我们有空间分布&＃xff0c;这些视图将在稍后得到度量。
final int totalLength &＃61; mTotalLength;
mTotalLength &＃61; Math.max(totalLength, totalLength &＃43; lp.topMargin &＃43; lp.bottomMargin);
skippedMeasure &＃61; true;
} else {
if (useExcessSpace) {
// 满足这两个条件&＃xff0c;意味着父类即LinearLayout是wrap_content&＃xff0c;或者mode为UNSPECIFIED
// 那么此时将当前子控件的高度置为wrap_content
// 为何需要这么做&＃xff0c;主要是因为当父类为wrap_content时&＃xff0c;其大小实际上由子控件控制
// 我们都知道&＃xff0c;自定义控件的时候&＃xff0c;通常我们会指定测量模式为wrap_content时的默认大小
// 这里强制给定为wrap_content为的就是防止子控件高度为0.

// The heightMode is either UNSPECIFIED or AT_MOST, and
// this child is only laid out using excess space. Measure
// using WRAP_CONTENT so that we can find out the view’s
// optimal height. We’ll restore the original height of 0
// after measurement.
//heightMode 是 UNSPECIFIED or AT_MOST&＃xff0c; childView 只使用剩余空间
//使用WRAP_CONTENT进行测量&＃xff0c;以便找出视图的最佳高度。测量后恢复原来高度 0
lp.height &＃61; LayoutParams.WRAP_CONTENT;
}

// 如果当前的LinearLayout不是EXACTLY模式&＃xff0c;且子View的weight大于0&＃xff0c;优先会把当前LinearLayout的全部可用高度用于子View测量
// 我们在代码中也可以很清晰的看到&＃xff0c;在getChildMeasureSpec()中&＃xff0c;子控件需要把父控件的padding&＃xff0c;自身的margin以及一个可调节的量三者一起测量出自身的大小。那么假如在测量某个子控件之前&＃xff0c;weight一直都是0&＃xff0c;那么该控件在测量时&＃xff0c;需要考虑在本控件之前的总高度&＃xff0c;来根据剩余控件分配自身大小。而如果有weight&＃xff0c;那么就不考虑已经被占用的控件&＃xff0c;因为有了weight&＃xff0c;子控件的高度将会在后面重新赋值。

// Determine how big this child would like to be. If this or
// previous children have given a weight, then we allow it to
// use all available space (and we will shrink things later
// if needed).
//确定这个孩子想要多大。如果这个或前面的孩子给了一个权重&＃xff0c;那么我们允许它使用所有可用的空间
//(如果需要&＃xff0c;我们将在稍后缩小内容)。
final int usedHeight &＃61; totalWeight &＃61;&＃61; 0 ? mTotalLength : 0;
measureChildBeforeLayout(child, i, widthMeasureSpec, 0,
heightMeasureSpec, usedHeight);

// 重置子控件高度&＃xff0c;然后进行精确赋值
final int childHeight &＃61; child.getMeasuredHeight();
if (useExcessSpace) {
// Restore the original height and record how much space
// we’ve allocated to excess-only children so that we can
// match the behavior of EXACTLY measurement.
//恢复原来的高度&＃xff0c;并记录我们分配给 excess-only children 的空间大小&＃xff0c;以便我们能够准确地匹配测量的行为。
lp.height &＃61; 0;
consumedExcessSpace &＃43;&＃61; childHeight;
}

final int totalLength &＃61; mTotalLength;
// getNextLocationOffset返回的永远是0&＃xff0c;这里是加上子控件的margin值
mTotalLength &＃61; Math.max(totalLength, totalLength &＃43; childHeight &＃43; lp.topMargin &＃43;
lp.bottomMargin &＃43; getNextLocationOffset(child));
// 如果设置了measureWithLargestChild属性为true&＃xff0c;获取最高子控件的高度
if (useLargestChild) {
largestChildHeight &＃61; Math.max(childHeight, largestChildHeight);
}
}

useLargestChild 可以通过 xml 属性 android:measureWithLargestChild 设置的,含义是所有带权重属性的View都会使用最大View的最小尺寸

//useLargestChild 属性指定
//所以接下来根据 largestChildHeight 重新计算高度
if (useLargestChild &&
(heightMode &＃61;&＃61; MeasureSpec.AT_MOST || heightMode &＃61;&＃61; MeasureSpec.UNSPECIFIED)) {
mTotalLength &＃61; 0;

for (int i &＃61; 0; i final View child &＃61; getVirtualChildAt(i);
if (child &＃61;&＃61; null) {
mTotalLength &＃43;&＃61; measureNullChild(i);
continue;
}

if (child.getVisibility() &＃61;&＃61; GONE) {
i &＃43;&＃61; getChildrenSkipCount(child, i);
continue;
}

final LinearLayout.LayoutParams lp &＃61; (LinearLayout.LayoutParams)
child.getLayoutParams();
// Account for negative margins
final int totalLength &＃61; mTotalLength;
mTotalLength &＃61; Math.max(totalLength, totalLength &＃43; largestChildHeight &＃43;
lp.topMargin &＃43; lp.bottomMargin &＃43; getNextLocationOffset(child));
}
}

使用 largestChildHeight 重新计算mTotalLength&＃xff0c;在代码中也可以看到&＃xff0c;这个属性只在wrap_content情况下生效

到第二次测量中间还有一些其他的计算&＃xff0c;就不一一去看了&＃xff0c;直接看第二次测量

// Either expand children with weight to take up available
space or
// shrink them if they extend beyond our current bounds. If we skipped
// measurement on any children, we need to measure them now.
// 重新计算有 weight 属性的 childView 大小&＃xff0c;
// 如果还有可用的空间&＃xff0c;则扩展 childView&＃xff0c;计算其大小
// 如果 childView 超出了 LinearLayout 的边界&＃xff0c;则收缩 childView
int remainingExcess &＃61; heightSize - mTotalLength

• (mAllowInconsistentMeasurement ? 0 : consumedExcessSpace);
  if (skippedMeasure
  || ((sRemeasureWeightedChildren || remainingExcess !&＃61; 0) && totalWeight > 0.0f)) {
  // 根据 mWeightSum 计算得到 remainingWeightSum&＃xff0c;mWeightSum 是通过
  // android:weightSum&＃96; 属性设置的&＃xff0c;totalWeight 是通过第一次 for 循环计算得到的
  float remainingWeightSum &＃61; mWeightSum > 0.0f ? mWeightSum : totalWeight;

mTotalLength &＃61; 0;

for (int i &＃61; 0; i final View child &＃61; getVirtualChildAt(i);
if (child &＃61;&＃61; null || child.getVisibility() &＃61;&＃61; View.GONE) {
continue;
}

final LayoutParams lp &＃61; (LayoutParams) child.getLayoutParams();
final float childWeight &＃61; lp.weight;
// 这是设置了 weight 的情况下&＃xff0c;最重要的一行代码
// remainingExcess 剩余高度 * ( childView 的 weight / remainingWeightSum)
// share 便是此 childView 通过这个公式计算得到的高度&＃xff0c;
// 并重新计算剩余高度 remainingExcess 和剩余权重总和 remainingWeightSum
if (childWeight > 0) {
final int share &＃61; (int) (childWeight * remainingExcess / remainingWeightSum);
remainingExcess -&＃61; share;
remainingWeightSum -&＃61; childWeight;

final int childHeight;
if (mUseLargestChild && heightMode !&＃61; MeasureSpec.EXACTLY) {
childHeight &＃61; largestChildHeight;
} else if (lp.height &＃61;&＃61; 0 && (!mAllowInconsistentMeasurement
|| heightMode &＃61;&＃61; MeasureSpec.EXACTLY)) {
//如果是当前LinearLayout的模式是EXACTLY
//那么这个子View是没有被测量过的&＃xff0c;就需要测量一次
//如果不是EXACTLY的&＃xff0c;在第一次循环里就被测量一些了
// This child needs to be laid out from scratch using
// only its share of excess space.
childHeight &＃61; share;
} else {
//如果是非EXACTLY模式下的子View就再加上
//weight分配占比*剩余高度
// This child had some intrinsic height to which we
// need to add its share of excess space.
childHeight &＃61; child.getMeasuredHeight() &＃43; share;
}

final int childHeightMeasureSpec &＃61; MeasureSpec.makeMeasureSpec(
Math.max(0, childHeight), MeasureSpec.EXACTLY);
final int childWidthMeasureSpec &＃61; getChildMeasureSpec(widthMeasureSpec,
mPaddingLeft &＃43; mPaddingRight &＃43; lp.leftMargin &＃43; lp.rightMargin,
lp.width);
//重新测量一次&＃xff0c;因为高度发生了变化
child.measure(childWidthMeasureSpec, childHeightMeasureSpec);

// Child may now not fit in vertical dimension.
childState &＃61; combineMeasuredStates(childState, child.getMeasuredState()
& (MEASURED_STATE_MASK>>MEASURED_HEIGHT_STATE_SHIFT));
}

final int margin &＃61; lp.leftMargin &＃43; lp.rightMargin;
final int measuredWidth &＃61; child.getMeasuredWidth() &＃43; margin;
maxWidth &＃61; Math.max(maxWidth, measuredWidth);

boolean matchWidthLocally &＃61; widthMode !&＃61; MeasureSpec.EXACTLY &&
lp.width &＃61;&＃61; LayoutParams.MATCH_PARENT;

alternativeMaxWidth &＃61; Math.max(alternativeMaxWidth,
matchWidthLocally ? margin : measuredWidth);

allFillParent &＃61; allFillParent && lp.width &＃61;&＃61; LayoutParams.MATCH_PARENT;

final int totalLength &＃61; mTotalLength;
mTotalLength &＃61; Math.max(totalLength, totalLength &＃43; child.getMeasuredHeight() &＃43;
lp.topMargin &＃43; lp.bottomMargin &＃43; getNextLocationOffset(child));
}

// Add in our padding
mTotalLength &＃43;&＃61; mPaddingTop &＃43; mPaddingBottom;
// TODO: Should we recompute the heightSpec based on the new total length?
} else {
alternativeMaxWidth &＃61; 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 !&＃61; MeasureSpec.EXACTLY) {
for (int i &＃61; 0; i final View child &＃61; getVirtualChildAt(i);
if (child &＃61;&＃61; null || child.getVisibility() &＃61;&＃61; View.GONE) {
continue;
}

final LinearLayout.LayoutParams lp &＃61;
(LinearLayout.LayoutParams) child.getLayoutParams();

float childExtra &＃61; lp.weight;
i&＃43;&＃43;) {
final View child &＃61; getVirtualChildAt(i);
if (child &＃61;&＃61; null || child.getVisibility() &＃61;&＃61; View.GONE) {
continue;
}

final LinearLayout.LayoutParams lp &＃61;
(LinearLayout.LayoutParams) child.getLayoutParams();

float childExtra &＃61; lp.weight;