Android 自定义 View 之 onMeasure() 源码分析及重写

超、凢脫俗 2022-07-13 08:08 199阅读 0赞

从 Android 自定义 View 学习系列计划开始，到现在也有挺长时间了，上一篇 [Android 自定义 View 之常用工具源码分析][Android _ View]讲到了 Android 开发过程中常使用到的一些工具，都从源码上进行了分析，让大家对要使用的工具都有了一定的了解。

我们都知道，自定义 View 的三个重要过程分别是 measure、layout、draw，而 measure 处于这条处理链的首端，自然是非常重要的。所以接下来的这一篇 [Android 自定义 View 之 onMeasure() 的源码分析及重写][Android _ View _ onMeasure_]我们就来看一看自定义 View 里经常用到的 onMeasure() 方法的源码分析以及它们的重写！！

--------------------

系统显示一个 View，首先需要通过测量(measure)该 View 来获得其长和宽从而确定显示该 View 时需要多大的空间。而在测量的过程中 MeasureSpec 贯穿全程，发挥着不可或缺的作用。 所以，了解 View 的测量过程，最合适的切入点就是 MeasureSpec。

## MeasureSpec ##

我们来看一下 Google官方文档对 [MeasureSpec][] 的描述

> A MeasureSpec encapsulates the layout requirements passed from parent to child. Each MeasureSpec represents a requirement for either the width or the height. A MeasureSpec is comprised of a size and a mode.

大概意思就是，MeasureSpec 封装了从父节点传递给子节点的布局要求。每个 MeasureSpec 表示宽度或高度的要求。度量规格包括 size（大小）和 mode（模式）。

这句话里透漏了几个重点：

*  MeasureSpec 封装了从父节点传递给子节点的布局要求
 *  MeasureSpec 可以表示宽度和高度
 *  MeasureSpec 由 size 和 mode 组成

MeasureSpec 通常翻译为”测量规格”，它是一个 32 位的 int 数据。其中高 2 位代表 SpecMode 即某种测量模式(mode)，低 30位 为 SpecSize 代表在该模式下的规格大小(size)。  
可以通过如下方式分别获取这两个值：

获取模式(mode)

int specMode = MeasureSpec.getMode(measureSpec);

获取大小(size)

int specSize = MeasureSpec.getSize(measureSpec);

还可以通过上面的两个值生成新的MeasureSpec

int measureSpec=MeasureSpec.makeMeasureSpec(size, mode);

那么所谓从父节点传递给子节点的布局要求是什么呢？MeasureSpec里有着三种模式（mode），我们来看一下：

### UNSPECIFIED ###

> The parent has not imposed any constraint on the child. It can be whatever size it wants.

父View没有对子View施加任何约束。它可以是任何它想要的大小。

### EXACTLY ###

> The parent has determined an exact size for the child. The child is going to be given those bounds regardless of how big it wants to be.

父View已确定子View的确切大小。子View将被给予父View所确定的大小，无论它想要多大。

### AT\_MOST ###

> The child can be as large as it wants up to the specified size.

父View不限制View的大小，子View可以得到它想要达到的大小。

好了，接下来让我们从源码角度来分析一下它们是怎么形成的：

/** * @param child * 子View * @param parentWidthMeasureSpec * 父容器(比如LinearLayout)的宽的MeasureSpec * @param widthUsed * 父容器(比如LinearLayout)在水平方向已经占用的空间大小 * @param parentHeightMeasureSpec * 父容器(比如LinearLayout)的高的MeasureSpec * @param heightUsed * 父容器(比如LinearLayout)在垂直方向已经占用的空间大小 */
        protected void measureChildWithMargins(View child, int parentWidthMeasureSpec, int widthUsed,
                                               int parentHeightMeasureSpec, int heightUsed) {
            final MarginLayoutParams lp = (ViewGroup.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);
        }

需要注意里面的参数，通过这些参数看出，该方法要测量子View传进来的参数却包含了父容器的宽的MeasureSpec，父容器在水平方向已经占用的空间大小，父容器的高的MeasureSpec，父容器在垂直方向已经占用的空间大小等父View相关的信息。这在一定程度体现了：父View影响着子View的MeasureSpec的生成。

该方法主要有四步操作：

*  得到子View的LayoutParams
 *  得到子View的宽的MeasureSpec
 *  得到子View的高的MeasureSpec
 *  测量子View

我们可以看到第二步和第三步都调用到了getChildMeasureSpec()方法，那么在该方法内部又做了哪些操作呢？我们来看一下getChildMeasureSpec( )的源码

public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
            int specMode = View.MeasureSpec.getMode(spec);
            int specSize = View.MeasureSpec.getSize(spec);
    
            int size = Math.max(0, specSize - padding);
    
            int resultSize = 0;
            int resultMode = 0;
    
            switch (specMode) {
                case View.MeasureSpec.EXACTLY:
                    if (childDimension >= 0) {
                        resultSize = childDimension;
                        resultMode = View.MeasureSpec.EXACTLY;
                    } else if (childDimension == LayoutParams.MATCH_PARENT) {
                        resultSize = size;
                        resultMode = View.MeasureSpec.EXACTLY;
                    } else if (childDimension == LayoutParams.WRAP_CONTENT) {
                        resultSize = size;
                        resultMode = View.MeasureSpec.AT_MOST;
                    }
                    break;
    
                case View.MeasureSpec.AT_MOST:
                    if (childDimension >= 0) {
                        resultSize = childDimension;
                        resultMode = View.MeasureSpec.EXACTLY;
                    } else if (childDimension == LayoutParams.MATCH_PARENT) {
                        resultSize = size;
                        resultMode = View.MeasureSpec.AT_MOST;
                    } else if (childDimension == LayoutParams.WRAP_CONTENT) {
                        resultSize = size;
                        resultMode = View.MeasureSpec.AT_MOST;
                    }
                    break;
    
                case View.MeasureSpec.UNSPECIFIED:
                    if (childDimension >= 0) {
                        resultSize = childDimension;
                        resultMode = View.MeasureSpec.EXACTLY;
                    } else if (childDimension == LayoutParams.MATCH_PARENT) {
                        resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
                        resultMode = View.MeasureSpec.UNSPECIFIED;
                    } else if (childDimension == LayoutParams.WRAP_CONTENT) {
                        resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
                        resultMode = View.MeasureSpec.UNSPECIFIED;
                    }
                    break;
            }
            return View.MeasureSpec.makeMeasureSpec(resultSize, resultMode);
        }

应该可以看出来这就是确定子View的MeasureSpec的具体实现了吧！！

接下来我们对源码进行分析

首先来看一下getChildMeasureSpec()方法的内部参数

*  spec

> 父View（比如LinearLayout）的宽或高的MeasureSpec

*  padding

> 父容器(比如LinearLayout)在垂直方向或者水平方向已经被占用的空间。

为什么这么说呢？

我们可以看measureChildWithMargins()方法里调用getChildMeasureSpec()的这一部分，传递给getChildMeasureSpec()的第二个参数构成如下: 例如

mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin

其中

mPaddingLeft和mPaddingRight表示父容器左右两内侧的padding

lp.leftMargin和lp.rightMargin表示子View左右两外侧的margin

这四部分都不可以再被利用起来布局子View。所以说这些值的和表示:父容器在水平方向已经被占用的空间

同理，mPaddingTop + mPaddingBottom + lp.topMargin + lp.bottomMargin  
表示父容器(比如LinearLayout)在垂直方向已被占用的空间。

*  childDimension

> 通过子View的LayoutParams获取到的子View的宽或高

从getChildMeasureSpec()方法的第一个参数spec和第二个参数padding也可以看出，父容器(如LinearLayout)的MeasureSpec和子View的LayoutParams共同决定着子View的MeasureSpec！！

好，了解了方法的参数后我们来分析一下getChildMeasureSpec()方法的具体实现步骤

*  得到父容器的specMode和specSize
 *  得到父容器在水平方向或垂直方向可用的最大空间值
 *  确定子View的specMode和specSize

在这里有一个switch语句，该语句的判断条件就是父View的specMode；在此根据父View的specMode的不同来决定子View的specMode和specSize。

接下来我们来分析一下这个switch()语句

case 1 中父容器的specMode为EXACTLY，内部接 if else-if else-if语句，分别对应三种情况。

*  if (childDimension >= 0)
 *  else if (childDimension == LayoutParams.MATCH\_PARENT)
 *  else if (childDimension == LayoutParams.WRAP\_CONTENT)

有些朋友一看到 childDimension >= 0 就懵逼了，这是什么鬼？在这里我们有必要说明一下两个系统常量：

LayoutParams.MATCH\_PARENT=-1

LayoutParams.WRAP\_CONTENT=-2

所以 childDimension >= 0 的意思是除了MATCH\_PARENT和WRAP\_CONTENT这两种情况外的所有情况，其实也就是说当传入父容器的模式既不是MATCH\_PARENT也不是WRAP\_CONTENT，而是一个具体数值的情况时。

if (childDimension >= 0)

所以上面这一句代码的意思表示子View的宽或高不是match\_parent，也不是wrap\_content而是一个具体的数值，比如100px。

此时子View的size就是childDimension，子View的mode也为MeasureSpec.EXACTLY，即：

resultSize = childDimension; 
    resultMode = MeasureSpec.EXACTLY;

else if (childDimension == LayoutParams.MATCH_PARENT)

这一句代码表示子View的宽或高是LayoutParams.MATCH\_PARENT。

此时子View的size就是父容器在水平方向或垂直方向可用的最大空间值即size，子View的mode也为MeasureSpec.EXACTLY，即：

resultSize = size; 
    resultMode = MeasureSpec.EXACTLY;

else if (childDimension == LayoutParams.WRAP_CONTENT)

这一句表示子View的宽或高是LayoutParams.WRAP\_CONTENT。

此时子View的size就是父容器在水平方向或垂直方向可用的最大空间值即size，子View的mode为MeasureSpec.AT\_MOST，即：

resultSize = size; 
    resultMode = MeasureSpec.AT_MOST;

另外两种模式传入时父容器的specMode不同，同样对应三种情况以及不同的size和mode，就不再讲解了，大家对着源码看就知道了。

到这一步，我们已经可以清楚的知道

子View的MeasureSpec由其父容器的MeasureSpec和该子View本身的布局参数LayoutParams共同决定。

经过测量得出的子View的MeasureSpec是系统给出的一个期望值(参考值)，我们也可摒弃系统的这个测量流程，直接调用setMeasuredDimension( )设置子View的宽和高的测量值。

--------------------

## onMeasure()方法源码分析 ##

到这里终于把MeasureSpec搞懂了，那么接下来就可以开始看我们的主角了！！

我们来看一下View的onMeasure()方法的源码

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
           setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),  
                                getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));  
     }

onMeasure( )源码流程如下:

*  (1) 在onMeasure调用setMeasuredDimension( )设置View的宽和高
 *  (2)在setMeasuredDimension()中调用getDefaultSize()获取View的宽和高
 *  (3)在getDefaultSize()方法中会调用到getSuggestedMinimumWidth()或者getSuggestedMinimumHeight()获取到View宽和高的最小值

这些方法的调用顺序如下图所示

![这里写图片描述][SouthEast]

为了理解onMeasure到底做了什么，以及这几个方法分别做了什么，它们之间又有什么联系，我们从后面按顺序分别对这几个方法的源码进行分析，这样就可以更好的理解上一层方法是如何调用小一层方法的了。

首先是getSuggestedMinimumWidth()和getSuggestedMinimumHeight()，它们的源码如下

//Returns the suggested minimum width that the view should use 
    protected int getSuggestedMinimumWidth() {  
        return (mBackground == null) ? mMinWidth : max(mMinWidth, mBackground.getMinimumWidth());  
    }

//Returns the suggested minimum height that the view should use 
    protected int getSuggestedMinimumHeight() {  
        return (mBackground == null) ? mMinHeight : max(mMinHeight, mBackground.getMinimumHeight());  
    }

这两个方法分别返回View的宽度和高度的最小值MinimumWidth、MinimumHeight

在此需要注意该View是否有背景

(1) 若该View没有背景  
那么该MinimumWidth为View本身的最小宽度即mMinWidth

有两种方法可以设置该mMinWidth值：

*  在XML布局文件中定义minWidth
 *  调用View的setMinimumWidth()方法为该值赋值

(2) 若该View有背景  
那么该MinimumWidth为View本身最小宽度mMinWidth和View背景的最小宽度的最大值

getSuggestedMinimumHeight()方法与getSuggestedMinimumWidth()类似,不再多说

--------------------

然后是getDefaultSize()，我们来看一下它的源码

public static int getDefaultSize(int size, int measureSpec) {  
         int result = size;  
         int specMode = MeasureSpec.getMode(measureSpec);  
         int specSize = MeasureSpec.getSize(measureSpec);  
         switch (specMode) {  
           case MeasureSpec.UNSPECIFIED:  
               result = size;  
               break;  
           case MeasureSpec.AT_MOST:  
           case MeasureSpec.EXACTLY:  
               result = specSize;  
               break;  
         }  
         return result;  
    }

该方法用于获取View的宽或者高的大小

该方法的第一个输入参数size就是通过调用getSuggestedMinimumWidth()方法获得的View的宽或高的最小值

从getDefaultSize()的源码里的switch语句可看出该方法的返回值有两种情况:

(1) measureSpec的specMode为MeasureSpec.UNSPECIFIED 时  
在此情况下该方法的返回值就是View的宽或者高最小值  
这种情况很少见,可忽略不计

(2) measureSpec的specMode为MeasureSpec.AT\_MOST或MeasureSpec.EXACTLY 时:  
在此情况下getDefaultSize()的返回值就是该子View的measureSpec中的specSize

除去第一种情况以外,可知，在measure阶段View的宽和高由其measureSpec中的specSize决定！！

如果子View在XML布局文件中对于大小的设置采用wrap\_content，那么不管父View的specMode是 MeasureSpec.AT\_MOST还是MeasureSpec.EXACTLY 对于子View而言系统给它设置的specMode都是MeasureSpec.AT\_MOST，并且其大小都是parentLeftSize即父View目前剩余的可用空间。这时wrap\_content就失去了原本的意义，变成了match\_parent一样了。

所以自定义View在重写onMeasure()的过程中应该手动处理View的宽或高为wrap\_content的情况

--------------------

最后是setMeasuredDimension()，同样的，我们来看一下它的源码

protected final void setMeasuredDimension(int measuredWidth, int measuredHeight) {  
         mMeasuredWidth = measuredWidth;  
         mMeasuredHeight = measuredHeight;  
         mPrivateFlags |= MEASURED_DIMENSION_SET;  
    }

经过调用前面的各种方法，终于得到了View的宽度和高度

在这里就可以通过setMeasuredDimension()方法来设置View的宽度和高度的测量值

--------------------

## 重写onMeasure()方法 ##

上面说到，当子View在XML布局文件设置的宽或高为wrap\_content时，系统给子View设置的specMode都是MeasureSpec.AT\_MOST，这时wrap\_content就失去了原本的意义，变成了match\_parent一样。所以此时我们需要重写onMeasure来处理这种情况。

那么我们该怎么对这两种情况进行处理呢？

第一种情况：  
如果在xml布局中View的宽和高均用wrap\_content，那么需要设置View的宽和高为mWidth和mHeight

第二种情况：  
如果在xml布局中View的只是宽或高其中一个为wrap\_content,那么就将该值设置为默认的宽或高,另外的一个值采用系统测量的specSize即可

具体的实现可以这样做：

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    
        super.onMeasure(widthMeasureSpec , heightMeasureSpec);  
        int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);  
        int widthSpceSize = MeasureSpec.getSize(widthMeasureSpec);  
        int heightSpecMode=MeasureSpec.getMode(heightMeasureSpec);  
        int heightSpceSize=MeasureSpec.getSize(heightMeasureSpec);  
    
        if(widthSpecMode==MeasureSpec.AT_MOST&&heightSpecMode==MeasureSpec.AT_MOST){  
            setMeasuredDimension(mWidth, mHeight);  
        }else if(widthSpecMode==MeasureSpec.AT_MOST){  
            setMeasuredDimension(mWidth, heightSpceSize);  
        }else if(heightSpecMode==MeasureSpec.AT_MOST){  
            setMeasuredDimension(widthSpceSize, mHeight);  
        }  
    
     }

上面的代码主要分两步完成

*  调用super.onMeasure()
 *  处理View的大小为wrap\_content时的情况

我们看下面这张图，会更清晰一点，要进行处理的两种情况是最后一行左边两个mode为AT\_MOST的

<table> 
 <thead> 
  <tr> 
   <th align="center">parentSpecMode\childLayoutParams</th> 
   <th align="center">EXACTLY</th> 
   <th align="center">AT_MOST</th> 
   <th align="center">UNSPECIFIED</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">dp/px</td> 
   <td align="center">EXACTLY/childSize</td> 
   <td align="center">EXACTLY/childSize</td> 
   <td align="center">EXACTLY/childSize</td> 
  </tr> 
  <tr> 
   <td align="center">match_parent</td> 
   <td align="center">EXACTLY/parentS ize</td> 
   <td align="center">AT_MOST/parentSize</td> 
   <td align="center">UNSPECIFIED/0</td> 
  </tr> 
  <tr> 
   <td align="center">wrap_content</td> 
   <td align="center">AT_MOST/parentSize</td> 
   <td align="center">AT_MOST/parentSize</td> 
   <td align="center">UNSPECIFIED/0</td> 
  </tr> 
 </tbody> 
</table>

其实，Andorid系统的控件比如TextView等也在onMeasure()中对其大小为wrap\_content这一情况作了特殊的处理。

请注意在第二步的代码中用的判断条件:

widthSpecMode==MeasureSpec.AT\_MOST或者heightSpecMode==MeasureSpec.AT\_MOST或者兼而有之;

这里的关键是模式(mode)MeasureSpec.AT\_MOST

--------------------

## ViewGroup.measure ##

看完了View中的onMeasure方法，接下来我们继续看ViewGroup中的measure()方法

public abstract class ViewGroup extends View implements ViewParent,ViewManager{  
    }

我们可以看到ViewGroup是一个抽象类，它没有重写View的onMeasure( )但它提供了measureChildren( )测量所有的子View。在measureChildren()方法中调用measureChild( )测量每个子View，在该方法内又会调用到child.measure( )方法，这又回到了前面熟悉的流程。

即ViewGroup中测量子View的流程：

![这里写图片描述][SouthEast 1]

既然ViewGroup继承自View而且它是一个抽象类，那么ViewGroup的子类就应该根据自身的要求和特点重写onMeasure( )方法。

那么这些ViewGroup的子类会怎么测量子View和确定自身的大小呢？  
如果ViewGroup知道了每个子View的大小，将它们累加起来是不是就知道了自身的大小呢？

顺着这个思路，我们选择ViewGroup的子类LinearLayout来看，就从它的onMeasure( )开始看吧!!

@Override
        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
            if (mOrientation == VERTICAL) {
                measureVertical(widthMeasureSpec, heightMeasureSpec);
            } else {
                measureHorizontal(widthMeasureSpec, heightMeasureSpec);
            }
        }

我们可以看到，代码里分了水平线性和垂直线性这两种情况进行测量，类似的逻辑在其onLayout( )阶段也会看到。我们就选measureVertical( )继续往下看

void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {
            mTotalLength = 0;
            int maxWidth = 0;
            int childState = 0;
            int alternativeMaxWidth = 0;
            int weightedMaxWidth = 0;
            boolean allFillParent = true;
            float totalWeight = 0;
    
            final int count = getVirtualChildCount();
    
            final int widthMode = MeasureSpec.getMode(widthMeasureSpec);
            final int heightMode = MeasureSpec.getMode(heightMeasureSpec);
    
            boolean matchWidth = false;
            boolean skippedMeasure = false;
    
            final int baselineChildIndex = mBaselineAlignedChildIndex;        
            final boolean useLargestChild = mUseLargestChild;
    
            int largestChildHeight = Integer.MIN_VALUE;
    
            for (int i = 0; i < count; ++i) {
                final View child = getVirtualChildAt(i);
    
                if (child == null) {
                    mTotalLength += measureNullChild(i);
                    continue;
                }
    
                if (child.getVisibility() == View.GONE) {
                   i += getChildrenSkipCount(child, i);
                   continue;
                }
    
                if (hasDividerBeforeChildAt(i)) {
                    mTotalLength += mDividerHeight;
                }
    
                LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();
    
                totalWeight += lp.weight;
    
                if (heightMode == MeasureSpec.EXACTLY && lp.height == 0 && lp.weight > 0) {
                    final int totalLength = mTotalLength;
                    mTotalLength = Math.max(totalLength, totalLength + lp.topMargin + lp.bottomMargin);
                    skippedMeasure = true;
                } else {
                    int oldHeight = Integer.MIN_VALUE;
    
                    if (lp.height == 0 && lp.weight > 0) {
    
                        oldHeight = 0;
                        lp.height = LayoutParams.WRAP_CONTENT;
                    }
    
    
                    measureChildBeforeLayout(
                           child, i, widthMeasureSpec, 0, heightMeasureSpec,
                           totalWeight == 0 ? mTotalLength : 0);
    
                    if (oldHeight != Integer.MIN_VALUE) {
                       lp.height = oldHeight;
                    }
    
                    final int childHeight = child.getMeasuredHeight();
                    final int totalLength = mTotalLength;
                    mTotalLength = Math.max(totalLength, totalLength + childHeight + lp.topMargin +
                           lp.bottomMargin + getNextLocationOffset(child));
    
                    if (useLargestChild) {
                        largestChildHeight = Math.max(childHeight, largestChildHeight);
                    }
                }
    
    
                if ((baselineChildIndex >= 0) && (baselineChildIndex == i + 1)) {
                   mBaselineChildTop = mTotalLength;
                }
                if (i < baselineChildIndex && lp.weight > 0) {
                    throw new RuntimeException("Exception");
                }
    
                boolean matchWidthLocally = false;
                if (widthMode != MeasureSpec.EXACTLY && lp.width == LayoutParams.MATCH_PARENT) {
                    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);
                }
    
                i += getChildrenSkipCount(child, i);
            }
    
            if (mTotalLength > 0 && hasDividerBeforeChildAt(count)) {
                mTotalLength += mDividerHeight;
            }
    
            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();
                    final int totalLength = mTotalLength;
                    mTotalLength = Math.max(totalLength, totalLength + largestChildHeight +
                            lp.topMargin + lp.bottomMargin + getNextLocationOffset(child));
                }
            }
    
            mTotalLength += mPaddingTop + mPaddingBottom;
    
            int heightSize = mTotalLength;
    
            heightSize = Math.max(heightSize, getSuggestedMinimumHeight());
    
            int heightSizeAndState = resolveSizeAndState(heightSize, heightMeasureSpec, 0);
            heightSize = heightSizeAndState & MEASURED_SIZE_MASK;
    
            int delta = heightSize - mTotalLength;
            if (skippedMeasure || delta != 0 && totalWeight > 0.0f) {
                float weightSum = mWeightSum > 0.0f ? mWeightSum : totalWeight;
    
                mTotalLength = 0;
    
                for (int i = 0; i < count; ++i) {
                    final View child = getVirtualChildAt(i);
    
                    if (child.getVisibility() == View.GONE) {
                        continue;
                    }
    
                    LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();
    
                    float childExtra = lp.weight;
                    if (childExtra > 0) {
                        int share = (int) (childExtra * delta / weightSum);
                        weightSum -= childExtra;
                        delta -= share;
    
                        final int childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec,
                                mPaddingLeft + mPaddingRight +
                                        lp.leftMargin + lp.rightMargin, lp.width);
    
    
                        if ((lp.height != 0) || (heightMode != MeasureSpec.EXACTLY)) {
                            int childHeight = child.getMeasuredHeight() + share;
                            if (childHeight < 0) {
                                childHeight = 0;
                            }
    
                            child.measure(childWidthMeasureSpec,
                                    MeasureSpec.makeMeasureSpec(childHeight, MeasureSpec.EXACTLY));
                        } else {
                            child.measure(childWidthMeasureSpec,
                                    MeasureSpec.makeMeasureSpec(share > 0 ? share : 0,
                                            MeasureSpec.EXACTLY));
                        }
    
                        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));
                }
    
                mTotalLength += mPaddingTop + mPaddingBottom;
            } else {
                alternativeMaxWidth = Math.max(alternativeMaxWidth,
                                               weightedMaxWidth);
    
                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;
            maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());
    
            setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
                    heightSizeAndState);
    
            if (matchWidth) {
                forceUniformWidth(count, heightMeasureSpec);
            }
        }

代码有点多，但没关系，我们来分析一下其中的关键点，这段代码的主要操作其实就只有下面两点

*  遍历每个子View，并对每个子View调用measureChildBeforeLayout()，代码115-133行

在measureChildBeforeLayout()方法内又会调用measureChildWithMargins()从而测量每个子View的大小。在该过程中mTotalLength保存了LinearLayout的高度，所以每当测量完一个子View该值都会发生变化。

*  设置 LinearLayout 的大小，代码241行

[Android _ View]: http://blog.csdn.net/jim__charles/article/details/53784549
[Android _ View _ onMeasure_]: http://blog.csdn.net/jim__charles/article/details/53965738
[MeasureSpec]: https://developer.android.com/reference/android/view/View.MeasureSpec.html
[SouthEast]: /images/20220713/2f6cb3da397f4835bdf4b1760792f636.png
[SouthEast 1]: /images/20220713/95c0afb82c22429588259938827ff262.png