---

前言

• 自定义View是Android开发者必须了解的基础
• 网上有大量关于自定义View原理的文章，但存在一些问题：内容不全、思路不清晰、无源码分析、简单问题复杂化等等
• 今天，我将全面总结自定义View原理中的measure过程，我能保证这是市面上的最全面、最清晰、最易懂的
• 文章较长，建议收藏等充足时间再进行阅读

---

目录

---

1. 作用

测量View的宽/高

1. 在某些情况下，需要多次测量（measure）才能确定View最终的宽/高；
2. 在这种情况下measure过程后得到的宽/高可能是不准确的；
3. 建议在layout过程中onLayout()去获取最终的宽/高

---

2. 准备的基础

在了解measure 过程前，我们需要先了解measure过程中传递尺寸（宽 / 高测量值）的两个类：

• ViewGroup.LayoutParams （View 自身的布局参数）
• MeasureSpecs 类（父视图对子视图的测量要求）

2.1 ViewGroup.LayoutParams

• 这个类我们很常见，用来指定视图的高度（height）和宽度（width）等布局参数。可通过以下参数进行指定：

参数	解释
具体值	dp / px
fill_parent	强制性使子视图的大小扩展至与父视图大小相等（不含 padding )
match_parent	与fill_parent相同，用于Android 2.3及之后版本
wrap_content	自适应大小，强制性地使视图扩展以便显示其全部内容(含 padding )

android:layout_weight="wrap_content"   //自适应大小   android:layout_weight="match_parent"   //与父视图等高   android:layout_weight="fill_parent"    //与父视图等高   android:layout_weight="100dip"         //精确设置高度值为 100dip

• ViewGroup 的子类有其对应的 ViewGroup.LayoutParams 子类

  1. ViewGroup 的子类包括RelativeLayout、LinearLayout等；
  2. 如 RelativeLayout的 ViewGroup.LayoutParams 的子类是RelativeLayoutParams。

• 构造函数
  构造函数是View的入口，可以用于初始化一些的内容，和获取自定义属性。

// View的构造函数有四种重载     public DIY_View(Context context){         super(context);     }      public DIY_View(Context context,AttributeSet attrs){         super(context, attrs);     }      public DIY_View(Context context,AttributeSet attrs,int defStyleAttr ){         super(context, attrs,defStyleAttr);  // 第三个参数：默认Style // 默认Style：指在当前Application或Activity所用的Theme中的默认Style // 且只有在明确调用的时候才会生效，     }      public DIY_View(Context context,AttributeSet attrs,int defStyleAttr ，int defStyleRes){         super(context, attrs，defStyleAttr，defStyleRes);     }  // 最常用的是1和2 }

2.2 MeasureSpec

2.2.1 定义

测量规格

可以理解为：测量View的依据

2.2.2 类型

MeasureSpec的类型分为两种：

即每个MeasureSpec代表了一组宽度和高度的测量规格

2.2.3 作用

决定了一个View的大小（宽/高）

即宽测量值（widthMeasureSpec）和高测量值（heightMeasureSpec）决定了View的大小

2.2.4 组成

如下图：

其中，Mode模式共分为三类

• UNSPECIFIED模式
• EXACTLY模式
• AT_MOST模式

具体说明如下图：

2.2.5 MeasureSpec类的使用

• MeasureSpec 、Mode 和Size都封装在View类中的一个内部类里 – MeasureSpec类。
• MeasureSpec类通过使用二进制，将mode和size打包成一个int值来减少对象内存分配，用一个变量携带两个数据（size，mode），并提供了打包和解包的方法。具体源代码解析如下：

public class MeasureSpec {           //进位大小为2的30次方         //int的大小为32位，所以进位30位就是要使用int的32和31位做标志位)          private static final int MODE_SHIFT = 30;            // 运算遮罩，0x3为16进制，10进制为3，二进制为11。3向左进位30，就是11 00000000000(11后跟30个0)           // 遮罩的作用是用1标注需要的值，0标注不要的值。因为1与任何数做与运算都得任何数，0与任何数做与运算都得0         private static final int MODE_MASK  = 0x3 << MODE_SHIFT;            // 0向左进位30 = 00后跟30个0，即00 00000000000         public static final int UNSPECIFIED = 0 << MODE_SHIFT;            // 1向左进位30 = 01后跟30个0 ，即01 00000000000         public static final int EXACTLY     = 1 << MODE_SHIFT;            // 2向左进位30 = 10后跟30个0，即10 00000000000         public static final int AT_MOST     = 2 << MODE_SHIFT;            /* 根据提供的size和mode得到一个详细的测量结果 */           public static int makeMeasureSpec(int size, int mode) {           // measureSpec = size + mode         //注：二进制的加法，不是十进制的加法！             return size + mode;           //设计的目的就是使用一个32位的二进制数，32和31位代表了mode的值，后30位代表size的值           // 例如size=100(4)，mode=AT_MOST，则measureSpec=100+10000...00=10000..00100           }             /* 通过详细测量结果获得mode */            public static int getMode(int measureSpec) {            // mode = measureSpec & MODE_MASK;           // MODE_MASK = 11 00000000000(11后跟30个0)         //原理：用MODE_MASK后30位的0替换掉measureSpec后30位中的1,再保留32和31位的mode值。           // 例如10 00..00100 & 11 00..00(11后跟30个0) = 10 00..00(AT_MOST)，这样就得到了mode的值             return (measureSpec & MODE_MASK);           }              /* 通过详细测量结果获得size */            public static int getSize(int measureSpec) {            // size = measureSpec & ~MODE_MASK;           // 原理同上，不过这次是将MODE_MASK取反，也就是变成了00 111111(00后跟30个1)，将32,31替换成0也就是去掉mode，保留后30位的size               return (measureSpec & ~MODE_MASK);           }   }    // 可以通过下面方式获取specMode和SpecSize //获取specMode int specMode = MeasureSpec.getMode(measureSpec)  //获取SpecSize int specSize = MeasureSpec.getSize(measureSpec)  //也可以通过这两个值生成新的SpecMode int measureSpec=MeasureSpec.makeMeasureSpec(size, mode);

2.2.6 MeasureSpec值的确定

• 上面讲了那么久MeasureSpec，那么，MeasureSpec值到底是如何计算得来的呢?
• 结论：子View的MeasureSpec值是根据子View的布局参数（LayoutParams）和父容器的MeasureSpec值计算得来的，具体计算逻辑封装在getChildMeasureSpec()里。

如下图：

下面，我们来看getChildMeasureSpec()的源码分析：

//作用： / 根据父视图的MeasureSpec & 布局参数LayoutParams，计算单个子View的MeasureSpec //即子view的确切大小由两方面共同决定：父view的MeasureSpec 和 子view的LayoutParams属性    public static int getChildMeasureSpec(int spec, int padding, int childDimension) {     //参数说明  * @param spec 父view的详细测量值(MeasureSpec)   * @param padding view当前尺寸的的内边距和外边距(padding,margin)   * @param childDimension 子视图的布局参数（宽/高）      //父view的测量模式     int specMode = MeasureSpec.getMode(spec);           //父view的大小     int specSize = MeasureSpec.getSize(spec);           //通过父view计算出的子view = 父大小-边距（父要求的大小，但子view不一定用这个值）        int size = Math.max(0, specSize - padding);        //子view想要的实际大小和模式（需要计算）       int resultSize = 0;       int resultMode = 0;        //通过父view的MeasureSpec和子view的LayoutParams确定子view的大小         // 当父view的模式为EXACITY时，父view强加给子view确切的值    //一般是父view设置为match_parent或者固定值的ViewGroup      switch (specMode) {       case MeasureSpec.EXACTLY:           // 当子view的LayoutParams>0，即有确切的值           if (childDimension >= 0) {               //子view大小为子自身所赋的值，模式大小为EXACTLY               resultSize = childDimension;               resultMode = MeasureSpec.EXACTLY;            // 当子view的LayoutParams为MATCH_PARENT时(-1)           } else if (childDimension == LayoutParams.MATCH_PARENT) {               //子view大小为父view大小，模式为EXACTLY               resultSize = size;               resultMode = MeasureSpec.EXACTLY;            // 当子view的LayoutParams为WRAP_CONTENT时(-2)               } else if (childDimension == LayoutParams.WRAP_CONTENT) {               //子view决定自己的大小，但最大不能超过父view，模式为AT_MOST               resultSize = size;               resultMode = MeasureSpec.AT_MOST;           }           break;        // 当父view的模式为AT_MOST时，父view强加给子view一个最大的值。（一般是父view设置为wrap_content）       case MeasureSpec.AT_MOST:           // 道理同上           if (childDimension >= 0) {               resultSize = childDimension;               resultMode = MeasureSpec.EXACTLY;           } else if (childDimension == LayoutParams.MATCH_PARENT) {               resultSize = size;               resultMode = MeasureSpec.AT_MOST;           } else if (childDimension == LayoutParams.WRAP_CONTENT) {               resultSize = size;               resultMode = MeasureSpec.AT_MOST;           }           break;        // 当父view的模式为UNSPECIFIED时，父容器不对view有任何限制，要多大给多大     // 多见于ListView、GridView       case MeasureSpec.UNSPECIFIED:           if (childDimension >= 0) {               // 子view大小为子自身所赋的值               resultSize = childDimension;               resultMode = MeasureSpec.EXACTLY;           } else if (childDimension == LayoutParams.MATCH_PARENT) {               // 因为父view为UNSPECIFIED，所以MATCH_PARENT的话子类大小为0               resultSize = 0;               resultMode = MeasureSpec.UNSPECIFIED;           } else if (childDimension == LayoutParams.WRAP_CONTENT) {               // 因为父view为UNSPECIFIED，所以WRAP_CONTENT的话子类大小为0               resultSize = 0;               resultMode = MeasureSpec.UNSPECIFIED;           }           break;       }       return MeasureSpec.makeMeasureSpec(resultSize, resultMode);   }

• 关于getChildMeasureSpec()里对于子View的测量模式和大小的判断逻辑有点复杂；
• 别担心，我已经帮大家总结好。具体子View的测量模式和大小请看下表：

规律总结：(以子View为标准，横向观察)

• 当子View采用具体数值（dp / px）时
  无论父容器的测量模式是什么，子View的测量模式都是EXACTLY且大小等于设置的具体数值；
• 当子View采用match_parent时
  • 子View的测量模式与父容器的测量模式一致
  • 若测量模式为EXACTLY，则子View的大小为父容器的剩余空间；若测量模式为AT_MOST，则子View的大小不超过父容器的剩余空间
• 当子View采用wrap_parent时
  无论父容器的测量模式是什么，子View的测量模式都是AT_MOST且大小不超过父容器的剩余空间。

UNSPECIFIED模式：由于适用于系统内部多次measure情况，很少用到，故此处不讨论

注：区别于顶级View（即DecorView）的计算逻辑

2.3 最基本的知识储备

具体请看我写的另外一篇文章：自定义View基础 – 最易懂的自定义View原理系列

---

3. measure过程详解

measure过程根据View的类型分为两种情况：

1. View类型 = 单一View时：只测量自身一个View；
2. View类型 = ViewGroup时：对ViewGroup视图中所有的子View都进行测量
   

   即遍历去调用所有子元素的measure方法，然后各子元素再递归去执行这个流程。

接下来，我将详细分析这两个measure过程。

3.1 单一View的measure过程

• 应用场景
  在没有现成的View，需要自己实现的时候，就使用自定义View，一般继承自View，SurfaceView或其他的View，不包含子View。
  

  1. 如：制作一个支持加载网络图片的ImageView
  2. 特别注意：自定义View在大多数情况下都有替代方案，利用图片或者组合动画来实现，但是使用后者可能会面临内存耗费过大，制作麻烦更诸多问题。
     单一View的measure过程如下图所示：

下面我将一个个方法进行详细分析。

3.1.1 measure（）

• 作用：基本测量逻辑的判断；调用onMeasure()

  属于View.java类 & final类型，即子类不能重写此方法

• 源码分析如下：

public final void measure(int widthMeasureSpec, int heightMeasureSpec) {  //参数说明：View的宽 / 高测量规格     ...     int cacheIndex = (mPrivateFlags & PFLAG_FORCE_LAYOUT) == PFLAG_FORCE_LAYOUT ? -1 :             mMeasureCache.indexOfKey(key);     if (cacheIndex < 0 || sIgnoreMeasureCache) {         // 计算视图大小         onMeasure(widthMeasureSpec, heightMeasureSpec);         mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;     } else {         ...  }

measure()最终会调用onMeasure()方法。下面继续看onMeasure()的介绍

3.1.2 onMeasure（）

• 作用：调用getDefaultSize()定义对View尺寸的测量逻辑；调用setMeasuredDimension()存储测量后的View宽 / 高
• 源码分析如下：

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {   //参数说明：View的宽 / 高测量规格  //setMeasuredDimension()  用于获得View宽/高的测量值 //这两个参数是通过getDefaultSize()获得的 setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),              getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));   }

下面继续看setMeasuredDimension()的分析

3.1.3 setMeasuredDimension()

• 作用：存储测量后的View宽 / 高。

  该方法就是我们重写onMeasure()所要实现的最终目的

• 源码分析如下：

protected final void setMeasuredDimension(int measuredWidth, int measuredHeight) {    //参数说明：测量后子View的宽 / 高值  //将测量后子View的宽 / 高值进行传递     mMeasuredWidth = measuredWidth;       mMeasuredHeight = measuredHeight;        mPrivateFlags |= PFLAG_MEASURED_DIMENSION_SET;   }

由于setMeasuredDimension（int measuredWidth, int measuredHeight）的参数是从getDefaultSize()获得的，下面我们继续看getDefaultSize()的介绍

3.1.4 getDefaultSize（）

• 作用：根据View宽/高的测量规格计算View的宽/高值
• 源码分析如下：

public static int getDefaultSize(int size, int measureSpec) {    //参数说明： // 第一个参数size：提供的默认大小 // 第二个参数：宽/高的测量规格（含模式 & 测量大小）      //设置默认大小     int result = size;       //获取宽/高测量规格的模式 & 测量大小     int specMode = MeasureSpec.getMode(measureSpec);       int specSize = MeasureSpec.getSize(measureSpec);        switch (specMode) {           // 模式为UNSPECIFIED时，使用提供的默认大小         // 即第一个参数：size          case MeasureSpec.UNSPECIFIED:               result = size;               break;           // 模式为AT_MOST,EXACTLY时，使用View测量后的宽/高值         // 即measureSpec中的specSize         case MeasureSpec.AT_MOST:           case MeasureSpec.EXACTLY:               result = specSize;               break;       }     //返回View的宽/高值     return result;   }

• 上面提到，当模式是UNSPECIFIED时，使用的是提供的默认大小（即第一个参数size）。
  那么，提供的默认大小具体是多少呢？
• 答：在onMeasure（）方法中，getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec)中传入的默认大小是getSuggestedMinimumWidth()。

接下来我们继续看getSuggestedMinimumWidth()的源码分析

由于getSuggestedMinimumHeight()类似，所以此处仅分析getSuggestedMinimumWidth()

• 源码分析如下：

protected int getSuggestedMinimumWidth() {     return (mBackground == null) ? mMinWidth : max(mMinWidth,mBackground.getMinimumWidth()); }  //getSuggestedMinimumHeight()同理

从代码可以看出：

• 如果View没有设置背景，View的宽度为mMinWidth

  1. mMinWidth = android:minWidth属性所指定的值；
  2. 若android:minWidth没指定，则默认为0

• 如果View设置了背景，View的宽度为mMinWidth和mBackground.getMinimumWidth()中的最大值

那么，mBackground.getMinimumWidth()的大小具体是指多少呢？接下来继续看getMinimumWidth()的源码分析：

public int getMinimumWidth() {     final int intrinsicWidth = getIntrinsicWidth();     //返回背景图Drawable的原始宽度     return intrinsicWidth > 0 ? intrinsicWidth :0 ; }

由源码可知：mBackground.getMinimumWidth()的大小具体是指背景图Drawable的原始宽度。

1. 若无原始宽度，则为0；
2. 那么Drawable什么情况下有原始宽度？如：ShapeDrawable没有，但BitmapDrawable有。

总结：
对于getDefaultSize()计算View的宽/高值的逻辑如下：

至此，单一View的宽/高值已经测量完成，即对于单一View的measure过程已经完成。

3.1.6 总结

• 对于单一View的measure过程，如下：

• 对于每个方法的总结如下：

3.2 ViewGroup的measure过程

• 应用场景
  自定义ViewGroup一般是利用现有的组件根据特定的布局方式来组成新的组件，大多继承自ViewGroup或各种Layout（含有子View）。
  

  如：底部导航条中的条目，一般都是上图标(ImageView)、下文字(TextView)，那么这两个就可以用自定义ViewGroup组合成为一个Veiw，提供两个属性分别用来设置文字和图片，使用起来会更加方便。

  

  Paste_Image.png

• 原理
  通过遍历所有的子View进行子View的测量，然后将所有子View的尺寸进行合并，最终得到ViewGroup父视图的测量值。

这样自上而下、一层层地传递下去，直到完成整个View树的measure（）过程

• ViewGroup的measure过程
  如下图所示：
  

  ViewGroup的Measure过程

下面我将一个个方法进行详细分析。

3.2.1 measureChildren()

• 和单一View的measure过程是从measure（）开始不同，ViewGroup的measure过程是从measureChildren（）开始的。

  1. ViewGroup是一个抽象类，自身没有重写View的onMeasure（）；
  2. 若需要进行自定义View，则需要对onMeasure()进行重写，下文会提到

• 作用：遍历子View并调用measureChild()进行下一步测量

• 源码分析如下：

protected void measureChildren(int widthMeasureSpec, int heightMeasureSpec) { //参数说明：父视图的测量规格（MeasureSpec）          final int size = mChildrenCount;         final View[] children = mChildren;          //遍历所有的子view         for (int i = 0; i < size; ++i) {             final View child = children[i];         //如果View的状态不是GONE就调用measureChild()去进行下一步的测量             if ((child.mViewFlags & VISIBILITY_MASK) != GONE) {                 measureChild(child, widthMeasureSpec, heightMeasureSpec);             }         }     }

下面，我们继续看measureChild()的分析。

3.2.2 measureChild()

• 作用：计算单个子View的MeasureSpec；调用子View的measure()进行每个子View最后的宽 / 高测量

• 源码分析如下：

protected void measureChild(View child, int parentWidthMeasureSpec,             int parentHeightMeasureSpec) {          // 获取子视图的布局参数         final LayoutParams lp = child.getLayoutParams();          // 调用getChildMeasureSpec()，根据父视图的MeasureSpec & 布局参数LayoutParams，计算单个子View的MeasureSpec          // getChildMeasureSpec()请回看上面的解析         final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,// 获取 ChildView 的 widthMeasureSpec                 mPaddingLeft + mPaddingRight, lp.width);         final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,// 获取 ChildView 的 heightMeasureSpec                 mPaddingTop + mPaddingBottom, lp.height);          // 将计算好的子View的MeasureSpec值传入measure()，进行最后的测量         child.measure(childWidthMeasureSpec, childHeightMeasureSpec);     }

下面，我们继续看measure()的分析。

3.2.3 measure()

• 作用：基本测量逻辑的判断；调用onMeasure()
  

  与单一View measure过程中讲的measure()是一致的。

• 源码分析如下：

public final void measure(int widthMeasureSpec, int heightMeasureSpec) {     ...     int cacheIndex = (mPrivateFlags & PFLAG_FORCE_LAYOUT) == PFLAG_FORCE_LAYOUT ? -1 :             mMeasureCache.indexOfKey(key);     if (cacheIndex < 0 || sIgnoreMeasureCache) {          // 调用onMeasure()计算视图大小         onMeasure(widthMeasureSpec, heightMeasureSpec);         mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;     } else {         ...  }

下面，我们继续看onMeasure()的分析。

3.2.4 onMeasure()

• 首先明确：ViewGroup是一个抽象类，自身没有重写View的onMeasure（）；
• 问：为什么ViewGroup的measure过程不像单一View的measure过程那样对onMeasure（）做统一的实现？（如下代码）

//单一View中的onMeasure统一实现 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {    //setMeasuredDimension()  用于获得View宽/高的测量值 //这两个参数是通过getDefaultSize()获得的 //下面继续看setMeasuredDimension()  源码 setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),              getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));   }

• 答：因为不同的ViewGroup子类（LinearLayout、RelativeLayout或自定义ViewGroup子类等）具备不同的布局特性，这导致他们子View的测量方法各有不同；而onMeasure（）的作用在于测量View的宽/高值。
  因此，ViewGroup无法对onMeasure（）作统一实现。

在自定义View中，关键在于根据你的自定义View去复写onMeasure()从而实现你的子View测量逻辑。复写onMeasure()的模板如下：

//根据自身的测量逻辑复写onMeasure（）  @Override protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {          //定义存放测量后的View宽/高的变量       int widthMeasure ;       int heightMeasure ;         //定义测量方法       void measureCarson{         //定义测量的具体逻辑                  }  //记得！最后使用setMeasuredDimension()  存储测量后View宽/高的值 setMeasuredDimension(widthMeasure,  heightMeasure);   }  //最终setMeasuredDimension（）会像上面单一View的measure过程中提到的，存储好测量后View宽/高的值并进行传递。

上面说的便是单一View的measure过程与ViewGroup过程最大的不同：单一View measure过程的onMeasure（）具有统一实现，而ViewGroup则没有。

注：其实，在单一View measure过程中，getDefaultSize()只是简单的测量了宽高值，在实际使用时有时需要进行更精细的测量。所以有时候也需要重写onMeasure（）。

• 至此，ViewGroup的measure过程已经分析完毕。

3.2.5 总结

• 对于ViewGroup的measure过程，如下：

  

  ViewGroup的measure过程

• 对于每个方法的总结如下：

为了让大家更好地理解ViewGroup的measure过程（特别是复写onMeasure()），所以接下来，我将用ViewGroup的子类LinearLayout来分析下ViewGroup的measure过程。

3.2.6 实例解析（LinearLayout）

在上述流程中，前4个方法的实现与上面所说是一样的，这里不作过多阐述，直接进入LinearLayout复写的onMeasure（）代码分析：

// 详细分析请看代码注释 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {      //根据不同的布局属性进行不同的计算     if (mOrientation == VERTICAL) {         measureVertical(widthMeasureSpec, heightMeasureSpec);     } else {         measureHorizontal(widthMeasureSpec, heightMeasureSpec);     } }      // 此处只选垂直方向的测量过程，即measureVertical()     // 该方法代码非常多，此处仅分析重要的逻辑  void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {      // 获取垂直方向上的子View个数     final int count = getVirtualChildCount();      // 遍历子View获取其高度，并记录下子View中最高的高度数值     for (int i = 0; i < count; ++i) {         final View child = getVirtualChildAt(i);          // 子View不可见，直接跳过该View的measure过程，getChildrenSkipCount()返回值恒为0         // 注：若view的可见属性设置为VIEW.INVISIBLE，还是会计算该view大小         if (child.getVisibility() == View.GONE) {            i += getChildrenSkipCount(child, i);            continue;         }          // 记录子View是否有weight属性设置，用于后面判断是否需要二次measure         totalWeight += lp.weight;          if (heightMode == MeasureSpec.EXACTLY && lp.height == 0 && lp.weight > 0) {             // 如果LinearLayout的specMode为EXACTLY且子View设置了weight属性，在这里会跳过子View的measure过程             // 同时标记skippedMeasure属性为true，后面会根据该属性决定是否进行第二次measure           // 若LinearLayout的子View设置了weight，会进行两次measure计算，比较耗时             // 这就是为什么LinearLayout的子View需要使用weight属性时候，最好替换成RelativeLayout布局              final int totalLength = mTotalLength;             mTotalLength = Math.max(totalLength, totalLength + lp.topMargin + lp.bottomMargin);             skippedMeasure = true;         } else {             int oldHeight = Integer.MIN_VALUE;              // 在该方法内部，最终会调用到子View的measure方法，计算出子View的大小            //  即遍历子View并调用measure()，形成递归             measureChildBeforeLayout(                    child, i, widthMeasureSpec, 0, heightMeasureSpec,                    totalWeight == 0 ? mTotalLength : 0);              if (oldHeight != Integer.MIN_VALUE) {                lp.height = oldHeight;             }               final int childHeight = child.getMeasuredHeight();             // mTotalLength用于存储LinearLayout在竖直方向的高度             final int totalLength = mTotalLength;             //每测量一个子View的高度， mTotalLength就会增加             mTotalLength = Math.max(totalLength, totalLength + childHeight + lp.topMargin +                    lp.bottomMargin + getNextLocationOffset(child));     }      // 记录LinearLayout占用的总高度     // 即除了子View的高度，还有本身的padding属性值     mTotalLength += mPaddingTop + mPaddingBottom;     int heightSize = mTotalLength;   // 最终调用setMeasuredDimension()  设置测量后View宽/高的值 setMeasureDimension(resolveSizeAndState(maxWidth,width))     ... }

至此，自定义View的中最重要、最复杂的measure过程已经讲完了。

4. 总结

• 本文对自定义View中最重要、最复杂的measure过程进行了详细分析

• 如果希望继续了解自定义View的原理，请参考我写的文章：
  （1）自定义View基础 – 最易懂的自定义View原理系列
  （2）自定义View Measure过程 – 最易懂的自定义View原理系列
  （3）自定义View Layout过程 – 最易懂的自定义View原理系列
  （4）自定义View Draw过程- 最易懂的自定义View原理系列

• 接下来，我我将继续对自定义View的应用进行分析，有兴趣的可以继续关注Carson_Ho的安卓开发笔记

---

请点赞！因为你们的赞同/鼓励是我写作的最大动力！

相关文章阅读
Android开发：最全面、最易懂的Android屏幕适配解决方案
Android开发：史上最全的Android消息推送解决方案
Android开发：最全面、最易懂的Webview详解
Android开发：JSON简介及最全面解析方法!
Android四大组件：Service服务史上最全面解析
Android四大组件：BroadcastReceiver史上最全面解析

---

欢迎关注Carson_Ho的简书！

不定期分享关于安卓开发的干货，追求短、平、快，但却不缺深度。