理解 MeasureSpec

 @Override protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { int expendSpec = MeasureSpec.makeMeasureSpec(Integer.MAX_VALUE >> 2, MeasureSpec.AT_MOST); super.onMeasure(widthMeasureSpec, expendSpec); }

确切的说，MeasureSpec 在很大程度上决定了一个 View 的尺寸规格，之所以说很大程度上是因为这个过程还受父容器的影响，因为父容器影响 View 的 MeasureSpec 创建过程，在测量过程中，系统会将 View 的 LayoutParams 根据父容器所施加的规转换成对应的 MeasureSpec，然后再根据这个 MeasureSpec 来测量出 View 的宽高，上面提到过，这里的宽高是测量的宽高，不一定等于 View 的最终宽高，MeasureSpec 看起来有点复杂，其实他的实现还是很简单的，下面会详细的分析MeasureSpec 

先来看一张图，带着问题来解读接下来要说的内容。

 private static final int MODE_SHIFT = 30; private static final int MODE_MASK = 0x3 << MODE_SHIFT; / @hide */ @IntDef({UNSPECIFIED, EXACTLY, AT_MOST}) @Retention(RetentionPolicy.SOURCE) public @interface MeasureSpecMode {} / * Measure specification mode: The parent has not imposed any constraint * on the child. It can be whatever size it wants. */ public static final int UNSPECIFIED = 0 << MODE_SHIFT; / * Measure specification mode: 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. */ public static final int EXACTLY = 1 << MODE_SHIFT; / * Measure specification mode: The child can be as large as it wants up * to the specified size. */ public static final int AT_MOST = 2 << MODE_SHIFT; / * Creates a measure specification based on the supplied size and mode. * * The mode must always be one of the following: * 
  

    * 
   
{@link android.view.View.MeasureSpec#UNSPECIFIED}
 * 
   
{@link android.view.View.MeasureSpec#EXACTLY}
 * 
   
{@link android.view.View.MeasureSpec#AT_MOST}
 * 
  
 * * 
Note: On API level 17 and lower, makeMeasureSpec's * implementation was such that the order of arguments did not matter * and overflow in either value could impact the resulting MeasureSpec. * {@link android.widget.RelativeLayout} was affected by this bug. * Apps targeting API levels greater than 17 will get the fixed, more strict * behavior.
 * * @param size the size of the measure specification * @param mode the mode of the measure specification * @return the measure specification based on size and mode */ public static int makeMeasureSpec(@IntRange(from = 0, to = (1 << MeasureSpec.MODE_SHIFT) - 1) int size, @MeasureSpecMode int mode) { if (sUseBrokenMakeMeasureSpec) { return size + mode; } else { return (size & ~MODE_MASK) | (mode & MODE_MASK); } } / * Like {@link #makeMeasureSpec(int, int)}, but any spec with a mode of UNSPECIFIED * will automatically get a size of 0. Older apps expect this. * * @hide internal use only for compatibility with system widgets and older apps */ public static int makeSafeMeasureSpec(int size, int mode) { if (sUseZeroUnspecifiedMeasureSpec && mode == UNSPECIFIED) { return 0; } return makeMeasureSpec(size, mode); } / * Extracts the mode from the supplied measure specification. * * @param measureSpec the measure specification to extract the mode from * @return {@link android.view.View.MeasureSpec#UNSPECIFIED}, * {@link android.view.View.MeasureSpec#AT_MOST} or * {@link android.view.View.MeasureSpec#EXACTLY} */ @MeasureSpecMode public static int getMode(int measureSpec) { //noinspection ResourceType return (measureSpec & MODE_MASK); } / * Extracts the size from the supplied measure specification. * * @param measureSpec the measure specification to extract the size from * @return the size in pixels defined in the supplied measure specification */ public static int getSize(int measureSpec) { return (measureSpec & ~MODE_MASK); }

上面提到，系统内部是通过 MeasureSpec 来进行 View 的测量的，但是正常情况下我们使用 View 指定 MeasureSpec，尽管如此，但是我们给 View 设置 LayoutParams，在 View 测量的时候，系统会将 LayoutParams 在父容器的约束下转换成 MeasureSpec，然后在根据  MeasureSpec 来确定 View 测量后的宽高，需要注意的是 MeasureSpec 不是唯一有 LayoutParams 决定的，LayoutParams 需要和父容器一起才能决定 View 的 MeasureSpec，从而进一步决定 View 的宽高。另外，对于顶级 View（DecorView）和普通 View 来说，MeasureSpec 的转换过程略有不同，其 MeasureSpec 有窗口的尺寸和其自身的 LayoutParams 来共同决定；对于普通的 View，其 MeasureSpec 由父容器的 MeasureSpec 和 自身的 LayoutParams 决定，MeasureSpec 一旦确定后，onMeasure 中就可以确定 View 的测量宽高。

对于 DecorView 来说，在RootViewImpl 中的 measureHierarcly 方法中 有如下一段代码，它展示了 DecorView 的 MeasureSpec 的创建过程，其中 desiredWindowWidth 和 desiredWindowHeight 是屏幕的尺寸大小：

 childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth, lp.width); childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height); performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);

接着再看一下 getRootMeasureSpec 方法实现：

/ * Figures out the measure spec for the root view in a window based on it's * layout params. * * @param windowSize * The available width or height of the window * * @param rootDimension * The layout params for one dimension (width or height) of the * window. * * @return The measure spec to use to measure the root view. */ private static int getRootMeasureSpec(int windowSize, int rootDimension) { int measureSpec; switch (rootDimension) { case ViewGroup.LayoutParams.MATCH_PARENT: // Window can't resize. Force root view to be windowSize. measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.EXACTLY); break; case ViewGroup.LayoutParams.WRAP_CONTENT: // Window can resize. Set max size for root view. measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.AT_MOST); break; default: // Window wants to be an exact size. Force root view to be that size. measureSpec = MeasureSpec.makeMeasureSpec(rootDimension, MeasureSpec.EXACTLY); break; } return measureSpec; } 

根据上述代码， DecorView 的 MeasureSpec 的产生过程就很明了了，具体来说遵守如下规则，根据它的 LayoutParams 中的宽高的参数来划分：

（1）LayoutParams.MATCH_PARENT：精确模式，大小就是窗口大小；

（2）LayoutParams.WARP_CONTENT：最大模式，大小不定，但是不能超过窗口的大小

（3）固定大小（不如100DP）：精确模式，大小为 LayoutParams 中指定的大小。

对于 View 来说，这里是指我们布局中的 View，View 的 measure 过程由 ViewGroup 传递过来，先看一下 ViewGroup 的 measureChildWithMargins2 方法：

 // Note: padding has already been removed from the supplied specs private void measureChildWithMargins2(View child, int parentWidthSpec, int parentHeightSpec, int childWidth, int childHeight) { int childWidthSpec = getChildMeasureSpec(parentWidthSpec, getTotalMargin(child, true), childWidth); int childHeightSpec = getChildMeasureSpec(parentHeightSpec, getTotalMargin(child, false), childHeight); child.measure(childWidthSpec, childHeightSpec); }

上述方法会对子元素进行 measure，在调用子元素的 measure 方法之前会先调通过 getChildMeasureSpec 的创建与父容器的 MeasureSpec 和子元素本身的 LayoutParams 有关，此外还和 View 的 margins 及 padding 有关，具体情况可以看一下 ViewGroup 的 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); }

上述方法不难理解，它的主要作用是根据父容器的 MeasureSpec 同时结合 View 本身的 LayoutParams 来确定子元素的 MeasureSpec ，参数中的 padding 是指父容器中已经占用的空间大小，因此子元素可用的大小为父容器的尺寸减去 padding ，具体代码如下：

 int specSize = MeasureSpec.getSize(spec); int size = Math.max(0, specSize - padding);

getChildMeasureSpec 清楚展示了普通 View 的 MeasureSpec 的创建规则。这个整个过程正好对应了文章开头那个表格，然后咱们再回来看下这个表格：

针对上图，这里再做下说明，前面已经提到，对于普通的 View，其 MeasureSpec 有父容器的 MeasureSpec 和自身的 LayoutParams 来决定的，那么针对不同的父容器和 View 本身不同的 LayoutParams，View 就可以有多张 MeasureSpec。这里简单说一下，当 View 采用固定宽高的时候，不管父容器的 MeasureSpec 是什么，View 的 MeasureSpec 都是精确模式并且大小遵循 LayoutParams 中的大小，当 View 中的宽高是 match_parent 时，如果父容器的模式是精准模式，那么 View 也是精准模式，其大小是父容器的剩余空间，如果父容器是最大模式，那么 View 也是最大模式但大小不会超过父容器的剩余空间。当 View 的宽高是 warp_content 时，不管父容器的模式是精准还是最大模式， View 的模式总是最大模式但大小不会超过父容器的剩余空间。至于 UNSPECIFIEND 模式，我是真的不知道有啥用，等以后弄明白了再补充吧，或者哪位大神知道，可以说下，谢谢！！

通过上边的表格可以看出，我们知道了父容器的 MeasureSpec 和子元素的 LayoutParams，就可以快速地确定出子元素的 MeasureSpec 了，有了 MeasureSpec 就可以进一步确定出子元素测量后的大小了。