Android-View-Measure测量过程分析

一、概述

我们直到android的View类的布局渲染包括三个部分，测量视图，布局视图，绘制视图

分别对应的measure、layout、draw

今天我们来分析下measure这个过程

二、问题

1、整体的流程是什么

2、过程分析和解读

3、MeasureSpec解读

4、例子分析

三、分析

1、整体的流程是什么

上面这个图很好的展示了View、ViewRootImpl、ViewGroup的调用过程

总结起来：measure的过程是不断的从根视图往子视图，不断测量的过程，直到最后一个子视图测试完成

2、过程分析和解读

上面我们了解了整个测量的调用过程了，那么我们现在来详细的看下这个过程

具体的View的绘制流程在我的另外一边文章有写（Android-View的绘制流程分析 https://editor.csdn.net/md/?articleId=121084883）

我们就从ViewRootImpl的performMeasure开始说起（performMeasure是在performTraversals中调用的）

1、ViewRootImpl#performMeasure

2013                      int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
2014                      int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);
2015  
2016                      if (DEBUG_LAYOUT) Log.v(mTag, "Ooops, something changed!  mWidth="
2017                              + mWidth + " measuredWidth=" + host.getMeasuredWidth()
2018                              + " mHeight=" + mHeight
2019                              + " measuredHeight=" + host.getMeasuredHeight()
2020                              + " coveredInsetsChanged=" + contentInsetsChanged);
2021  
2022                       // Ask host how big it wants to be
2023                      performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);

上面这个方法是ViewRootImpl中的performMeasure里的，计算了屏幕的高宽，加上sizemode，传入到performMeasure中

2、ViewRootImpl#performMeasure

 private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {
2273          Trace.traceBegin(Trace.TRACE_TAG_VIEW, "measure");
2274          try {
2275              mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);
2276          } finally {
2277              Trace.traceEnd(Trace.TRACE_TAG_VIEW);
2278          }
2279      }

这个方法很短，就是调用了mView的measure，前面已经说了mView就是window的顶层视图，DectorView继承自Framelayout

这个measure是View中的方法，我们来继续看下

3、View#measure()

public final void measure(int widthMeasureSpec, int heightMeasureSpec) {boolean optical = isLayoutModeOptical(this);if (optical != isLayoutModeOptical(mParent)) {Insets insets = getOpticalInsets();int oWidth  = insets.left + insets.right;int oHeight = insets.top  + insets.bottom;widthMeasureSpec  = MeasureSpec.adjust(widthMeasureSpec,  optical ? -oWidth  : oWidth);heightMeasureSpec = MeasureSpec.adjust(heightMeasureSpec, optical ? -oHeight : oHeight);}// Suppress sign extension for the low bytes/*计算得到一个measure缓存的key这个key从代码可以看出，是一个long类型，高32位是宽度width，低32位是高度组成的*/long key = (long) widthMeasureSpec << 32 | (long) heightMeasureSpec & 0xffffffffL;if (mMeasureCache == null) mMeasureCache = new LongSparseLongArray(2);//如果强制布局了，这里这个强制布局是指的是用户调用了requestLayout这个，//requestLayout调用后mPrivateFlags |= PFLAG_FORCE_LAYOUT 添加了这个标志final boolean forceLayout = (mPrivateFlags |=  & PFLAG_FORCE_LAYOUT) == PFLAG_FORCE_LAYOUT;// Optimize layout by avoiding an extra EXACTLY pass when the view is// already measured as the correct size. In API 23 and below, this// extra pass is required to make LinearLayout re-distribute weight.//如果测量前后吃尺寸改变final boolean specChanged = widthMeasureSpec != mOldWidthMeasureSpec|| heightMeasureSpec != mOldHeightMeasureSpec;//如果宽和高都是精确值final boolean isSpecExactly = MeasureSpec.getMode(widthMeasureSpec) == MeasureSpec.EXACTLY&& MeasureSpec.getMode(heightMeasureSpec) == MeasureSpec.EXACTLY;//如果现在View里的高宽和当前父视图传入的宽高一样final boolean matchesSpecSize = getMeasuredWidth() == MeasureSpec.getSize(widthMeasureSpec)&& getMeasuredHeight() == MeasureSpec.getSize(heightMeasureSpec);//如果下面的条件 就需要布局final boolean needsLayout = specChanged&& (sAlwaysRemeasureExactly || !isSpecExactly || !matchesSpecSize);//如果调用了requestLayout 或则 满足needsLayout 就测量if (forceLayout || needsLayout ) {// first clears the measured dimension flag//删除开始测量的标记mPrivateFlags &= ~PFLAG_MEASURED_DIMENSION_SET;//设置rtl，这个是从右边往左边读的配置resolveRtlPropertiesIfNeeded();//从缓存中提取缓存index。然后根据这个判断是否有缓存int cacheIndex = forceLayout ? -1 : mMeasureCache.indexOfKey(key);if (cacheIndex < 0 || sIgnoreMeasureCache) {// measure ourselves, this should set the measured dimension flag back//如果没有缓存就直接走onMeasureonMeasure(widthMeasureSpec, heightMeasureSpec);mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;} else {//如果有缓存就走缓存设置long value = mMeasureCache.valueAt(cacheIndex);// Casting a long to int drops the high 32 bits, no mask neededsetMeasuredDimensionRaw((int) (value >> 32), (int) value);mPrivateFlags3 |= PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;}// flag not set, setMeasuredDimension() was not invoked, we raise// an exception to warn the developer//不管上面走不走缓存都必须设置测量的结果，就是必须调用setMeasuredDimension//setMeasuredDimension调用后PFLAG_MEASURED_DIMENSION_SET标志会被添加//不然抛异常if ((mPrivateFlags & PFLAG_MEASURED_DIMENSION_SET) != PFLAG_MEASURED_DIMENSION_SET) {throw new IllegalStateException("View with id " + getId() + ": "+ getClass().getName() + "#onMeasure() did not set the"+ " measured dimension by calling"+ " setMeasuredDimension()");}//测量完成，开始添加布局layout的request的标志位PFLAG_LAYOUT_REQUIRED，准备layout操作mPrivateFlags |= PFLAG_LAYOUT_REQUIRED;}//设置自己的宽度和高度mOldWidthMeasureSpec = widthMeasureSpec;mOldHeightMeasureSpec = heightMeasureSpec;//添加缓存mMeasureCache.put(key, ((long) mMeasuredWidth) << 32 |(long) mMeasuredHeight & 0xffffffffL); // suppress sign extension
}

上面的代码我做了很充分的注释

总的来说这个方法主要干了1件事情，调用自己的onMeasure，这个onMeasure是子类需要重写的方法，这个设计就增强了View的扩展性

4、View#onMeasure()或者ViewGroup子类#onMeasure()

这里View不是ViewGroup，比如是TextView，就直接走onMeasure,这里就结束了，

如果是ViewGroup，因为ViewGroup没有对onMeasure重写，所以我要看下子类是如何做的

这里我就用Framelayout为例子看下，这里只简单说下，后面在例子中会详细说下这个方法

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {int count = getChildCount();final boolean measureMatchParentChildren =MeasureSpec.getMode(widthMeasureSpec) != MeasureSpec.EXACTLY ||MeasureSpec.getMode(heightMeasureSpec) != MeasureSpec.EXACTLY;mMatchParentChildren.clear();int maxHeight = 0;int maxWidth = 0;int childState = 0;//下面这个for循环主要是遍历子类视图，然后分辨对子视图测量//测量子视图后，又回到前面的那个循环了for (int i = 0; i < count; i++) {final View child = getChildAt(i);if (mMeasureAllChildren || child.getVisibility() != GONE) {//调用ViewGroup的measureChildWithMargins方法measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, 0);final LayoutParams lp = (LayoutParams) child.getLayoutParams();maxWidth = Math.max(maxWidth,child.getMeasuredWidth() + lp.leftMargin + lp.rightMargin);maxHeight = Math.max(maxHeight,child.getMeasuredHeight() + lp.topMargin + lp.bottomMargin);childState = combineMeasuredStates(childState, child.getMeasuredState());if (measureMatchParentChildren) {if (lp.width == LayoutParams.MATCH_PARENT ||lp.height == LayoutParams.MATCH_PARENT) {mMatchParentChildren.add(child);}}}}// Account for padding toomaxWidth += getPaddingLeftWithForeground() + getPaddingRightWithForeground();maxHeight += getPaddingTopWithForeground() + getPaddingBottomWithForeground();// Check against our minimum height and widthmaxHeight = Math.max(maxHeight, getSuggestedMinimumHeight());maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());// Check against our foreground's minimum height and widthfinal Drawable drawable = getForeground();if (drawable != null) {maxHeight = Math.max(maxHeight, drawable.getMinimumHeight());maxWidth = Math.max(maxWidth, drawable.getMinimumWidth());}setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),resolveSizeAndState(maxHeight, heightMeasureSpec,childState << MEASURED_HEIGHT_STATE_SHIFT));count = mMatchParentChildren.size();if (count > 1) {for (int i = 0; i < count; i++) {final View child = mMatchParentChildren.get(i);final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();final int childWidthMeasureSpec;if (lp.width == LayoutParams.MATCH_PARENT) {final int width = Math.max(0, getMeasuredWidth()- getPaddingLeftWithForeground() - getPaddingRightWithForeground()- lp.leftMargin - lp.rightMargin);childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY);} else {childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec,getPaddingLeftWithForeground() + getPaddingRightWithForeground() +lp.leftMargin + lp.rightMargin,lp.width);}final int childHeightMeasureSpec;if (lp.height == LayoutParams.MATCH_PARENT) {final int height = Math.max(0, getMeasuredHeight()- getPaddingTopWithForeground() - getPaddingBottomWithForeground()- lp.topMargin - lp.bottomMargin);childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY);} else {childHeightMeasureSpec = getChildMeasureSpec(heightMeasureSpec,getPaddingTopWithForeground() + getPaddingBottomWithForeground() +lp.topMargin + lp.bottomMargin,lp.height);}child.measure(childWidthMeasureSpec, childHeightMeasureSpec);}}
}

5、ViewGroup#measureChildWithMargins

protected void measureChildWithMargins(View child,int parentWidthMeasureSpec, int widthUsed,int parentHeightMeasureSpec, int heightUsed) {final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();//这个方法会根据 传入的参数计算出合适的测量值，这些都和xml布局中的match,warp,或者准确数值有关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);//核心代码，这里就调用了子视图的measure方法，循环回去了child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}

到此整个的过程分析完了

3、MeasureSpec解读

上面的分析中重复的出现了MeasureSpec类，我们来看下这个类什么样的

这个类是View的内部静态类

public static class 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 {}public static final int UNSPECIFIED = 0 << MODE_SHIFT;public static final int EXACTLY     = 1 << MODE_SHIFT;public static final int AT_MOST     = 2 << MODE_SHIFT;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);}}@UnsupportedAppUsagepublic static int makeSafeMeasureSpec(int size, int mode) {if (sUseZeroUnspecifiedMeasureSpec && mode == UNSPECIFIED) {return 0;}return makeMeasureSpec(size, mode);}@MeasureSpecModepublic static int getMode(int measureSpec) {//noinspection ResourceTypereturn (measureSpec & MODE_MASK);}public static int getSize(int measureSpec) {return (measureSpec & ~MODE_MASK);}static int adjust(int measureSpec, int delta) {final int mode = getMode(measureSpec);int size = getSize(measureSpec);if (mode == UNSPECIFIED) {// No need to adjust size for UNSPECIFIED mode.return makeMeasureSpec(size, UNSPECIFIED);}size += delta;if (size < 0) {Log.e(VIEW_LOG_TAG, "MeasureSpec.adjust: new size would be negative! (" + size +") spec: " + toString(measureSpec) + " delta: " + delta);size = 0;}return makeMeasureSpec(size, mode);}

MeasureSpec的精妙之处在于只通过一个int类型就可以标识尺寸的模式还有尺寸的数值，内存开销少，参数传递简洁

MeasureSpec的宽度和高度都是int类型，int类型是4个字节，32位，高2位是mode，低30位是数值

举个例子

00000000 00000000 00000001 00101100 高2位是00，代表 UNSPECIFIED 低30位是数值300

01000000 00000000 00000001 00101111 高2位是01，代表 EXACTLY低30位是数值303

10000000 00000000 00000001 00102100 高2位是10，代表 AT_MOST低30位是数值284

如果我们要提取这个int数字中的mode怎么办呢？

以00000000 00000000 00000001 00101100位例子，我们只需要11000000 00000000 00000000 00000000

做按位与&操作就可以得到mode值了

实际MeasureSpec也是这么做的,MODE_MASK=3<<30 其实就是上面那个11000000 00000000 00000000 00000000

@MeasureSpecModepublic static int getMode(int measureSpec) {//noinspection ResourceTypereturn (measureSpec & MODE_MASK);}

提取size呢？和上面提取mode同理操作就可以了

public static int getSize(int measureSpec) {//这里这个~MODE_MASK=00111111  11111111  11111111 11111111//按位& 就可以获得后面的sizereturn (measureSpec & ~MODE_MASK);}

如果把mode和size合并位一个int呢？

//参数通过注解 设置了取值范围，这里这个size 不是完全的int的范围，因为高2位被占用了  
public static int makeMeasureSpec(@IntRange(from = 0, to = (1 << MeasureSpec.MODE_SHIFT) - 1) int size,@MeasureSpecMode int mode) {//sUseBrokenMakeMeasureSpec 这个不用管，是一个新老版本的代码问题，sdk》17后 就用下面的方式了if (sUseBrokenMakeMeasureSpec ) {return size + mode;} else {//经过上面的讲解，相信下面的写法，你也可以理解了return (size & ~MODE_MASK) | (mode & MODE_MASK);}}

我们再来说下这个mode

• 当 specmode 为 UNSPECIFIED 时，使用自身期望的大小；
• 当 specmode 为 EXACTLY 时，使用指定的确定的值（通常为layoutparams中确定的值）；
• 当 specmode 为 AT_MOST 时，判断自身期望是否超过父 view 的限制，若未超过，则使用自身期望的值，若超过，则使用父view限制的最大值。

4、例子

这里我们就用Framelayout的onMeasure来讲解，看看是如何实现的

这个方法的目的就是计算自身的尺寸还有计算子视图的尺寸

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {int count = getChildCount();//这个的作用是标记当前这个Framelayout的长款尺寸是否是精确的的//如果是的话就不需要对里面的子视图进行第二次测量了//如果不是比如，含有at_most,就需要对自身精确测量后，再次测量子视图中含有MATCH_PARENT的子视图//整个过程大家可以体会，是不是这个逻辑final boolean measureMatchParentChildren =MeasureSpec.getMode(widthMeasureSpec) != MeasureSpec.EXACTLY ||MeasureSpec.getMode(heightMeasureSpec) != MeasureSpec.EXACTLY;//先情况集合mMatchParentChildren.clear();//这个就是不断的获取最大值，最后来设置自己的尺寸int maxHeight = 0;int maxWidth = 0;int childState = 0;for (int i = 0; i < count; i++) {final View child = getChildAt(i);//测量那些Visiable或者InVisiable的View，这里记住InVisiable的View也要测量，我们直到InVisiable也是要占用空间的//mMeasureAllChildren 如果设置了强制测量全部View的标志，就需要全部测量if (mMeasureAllChildren || child.getVisibility() != GONE) {//测量子视图的大小，测量的时候需要计算Framelayout的pading还有Child的margin//计算完之后child就有了宽高，这个方法会触发子视图的measure树，测量下面的所有View//这里里面有个ViewGroup中很重要的方法：getChildMeasureSpec(int spec, int padding, int childDimension)//继承子ViewGroup的子类一般都直接调用measureChildWithMargins就可以了，这个规则是android系统的统一设置，用户一般不要自行改变measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, 0);final LayoutParams lp = (LayoutParams) child.getLayoutParams();//获取最大值maxWidth = Math.max(maxWidth,child.getMeasuredWidth() + lp.leftMargin + lp.rightMargin);maxHeight = Math.max(maxHeight,child.getMeasuredHeight() + lp.topMargin + lp.bottomMargin);childState = combineMeasuredStates(childState, child.getMeasuredState());if (measureMatchParentChildren) {if (lp.width == LayoutParams.MATCH_PARENT ||lp.height == LayoutParams.MATCH_PARENT) {//子视图的宽高中只要有一个等于MATCH_PARENT 就需要添加进去 后面重新测量//因为之前不知道Framelayout的尺寸，测量不准确mMatchParentChildren.add(child);}}}}// Account for padding too//根据自身的padding 这个是前景图的的maxWidth += getPaddingLeftWithForeground() + getPaddingRightWithForeground();maxHeight += getPaddingTopWithForeground() + getPaddingBottomWithForeground();// Check against our minimum height and width//根据自身设置的最大值 最小值 计算尺寸maxHeight = Math.max(maxHeight, getSuggestedMinimumHeight());maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());// Check against our foreground's minimum height and width//如果设置了前景图，需要考虑前景图的尺寸的大小，也要算进去final Drawable drawable = getForeground();if (drawable != null) {maxHeight = Math.max(maxHeight, drawable.getMinimumHeight());maxWidth = Math.max(maxWidth, drawable.getMinimumWidth());}/*resolveSizeAndState：public static int resolveSizeAndState(int size, int measureSpec, int childMeasuredState) {上面那个size是自己希望要的尺寸final int specMode = MeasureSpec.getMode(measureSpec);//specSize 是父视图结合自身的设置 给的尺寸final int specSize = MeasureSpec.getSize(measureSpec);final int result;switch (specMode) {//这个是尽可能的大，case MeasureSpec.AT_MOST://下面这个是取值最小那个if (specSize < size) {result = specSize | MEASURED_STATE_TOO_SMALL;} else {result = size;}break;//尺寸确定了，那么就按照上面传下来的设置case MeasureSpec.EXACTLY:result = specSize;break;//如果没有任何要求，就设置子视图 小计算出来 想要的尺寸case MeasureSpec.UNSPECIFIED:default:result = size;}return result | (childMeasuredState & MEASURED_STATE_MASK);}这个方法就是根据mode来计算合适的尺寸，这个大家可以体会*///这个方法就是设置Framelayout 自身的尺寸setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),resolveSizeAndState(maxHeight, heightMeasureSpec,childState << MEASURED_HEIGHT_STATE_SHIFT));//下面这个就是要重新测量的View集合了，原因最上面已经说了count = mMatchParentChildren.size();if (count > 1) {for (int i = 0; i < count; i++) {final View child = mMatchParentChildren.get(i);final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();final int childWidthMeasureSpec;if (lp.width == LayoutParams.MATCH_PARENT) {//getMeasuredWidth 这个值 之前已经测量完成了，跟之前的不一样，所以需要重新测量、//当子视图的宽度是MATCH_PARENT 那么他自己的宽度就是下面的计算，要尽可能贴着父视图final int width = Math.max(0, getMeasuredWidth()- getPaddingLeftWithForeground() - getPaddingRightWithForeground()- lp.leftMargin - lp.rightMargin);childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY);} else {childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec,getPaddingLeftWithForeground() + getPaddingRightWithForeground() +lp.leftMargin + lp.rightMargin,lp.width);}final int childHeightMeasureSpec;if (lp.height == LayoutParams.MATCH_PARENT) {final int height = Math.max(0, getMeasuredHeight()- getPaddingTopWithForeground() - getPaddingBottomWithForeground()- lp.topMargin - lp.bottomMargin);childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY);} else {childHeightMeasureSpec = getChildMeasureSpec(heightMeasureSpec,getPaddingTopWithForeground() + getPaddingBottomWithForeground() +lp.topMargin + lp.bottomMargin,lp.height);}//重新测量child.measure(childWidthMeasureSpec, childHeightMeasureSpec);}}
}

上面我们调用了measureChildWithMargins方法，经过跟踪，最终会调用到ViewGroup的getChildMeasureSpec

方法，这个是方法是ViewGroup的子类通用的测量规则，这个方法主要是通过父视图的建议尺寸和自己的设置情况计算出合理的，适合自己的尺寸

我们来看下

//childDimension 这个参数是child自己本身的设置尺寸，是自己希望的尺寸
//childDimension 这个尺寸包括具体的尺寸，也包括MATCH_PARENT，WRAP_CONTENT
public static int getChildMeasureSpec(int spec, int padding, int childDimension) {//从spec中获取mode，这个mode之前说过，应该有三种类型，0，1，2int specMode = MeasureSpec.getMode(spec);//从spec中获取size，这个size是真正的数值int specSize = MeasureSpec.getSize(spec);//这个size 是刨去了padding 之后留给childview剩余的空间了，这个padding包括父视图的padding和自己//的margin，这个值是子视图尽可能最大的时候，能取到的最大值了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.//如果父视图尺寸确定，那么子视图设置了MATCH_PARENT,意思是尽可能最大，但是不超过父视图//所以这个size只能是父视图的size-padding//mode应该设置EXACTLYresultSize = size;resultMode = MeasureSpec.EXACTLY;} else if (childDimension == LayoutParams.WRAP_CONTENT) {// Child wants to determine its own size. It can't be// bigger than us.//如果父视图尺寸确定，那么子视图设置了WRAP_CONTENT，WRAP_CONTENT是自适应尺寸，那么子视图最大不能超过父视图给的空间，根据自己情况设置尺寸//那么这个mode=AT_MOST，resultSize = size;resultMode = MeasureSpec.AT_MOST;}break;// Parent has imposed a maximum size on uscase MeasureSpec.AT_MOST:if (childDimension >= 0) {// Child wants a specific size... so be it//子视图设置了精确的值，就应该设置他自己的值，模式也是EXACTLYresultSize = 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.//由于这个子视图 的父视图 或在在往上，肯定有个父视图设置了WRAP_CONTENT，所以自己也要设置为//AT_MOST//大小是父视图规定的最大范围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 becase MeasureSpec.UNSPECIFIED:if (childDimension >= 0) {//子视图设置了精确的值，就应该设置他自己的值，模式也是EXACTLY// Child wants a specific size... let him have itresultSize = childDimension;resultMode = MeasureSpec.EXACTLY;} else if (childDimension == LayoutParams.MATCH_PARENT) {// Child wants to be our size... find out how big it should// beresultSize = 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//这里有个sUseZeroUnspecifiedMeasureSpec，只是UNSPECIFIED 模式下返回0//这个是在sdk<23是这样的，大于23了就返回size了resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;resultMode = MeasureSpec.UNSPECIFIED;}break;}//noinspection ResourceTypereturn MeasureSpec.makeMeasureSpec(resultSize, resultMode);
}

总结getChildMeasureSpec 规律：

1、子视图自身设置了明确的数值尺寸，那么子视图的数值结果就是这个值，模式是EXACTLY

2、如果父视图是AT_MOST ，除去1情况，那么子视图数值是父视图给的最大值，mode是AT_MOST

所以AT_MOST 这个模式，会一直往子视图下传递，直到遇到设置了精确数值的View

3、如果父视图UNSPECIFIED不确定的，除去1情况，那么子视图数值是父视图给的最大值，mode是UNSPECIFIED，所以UNSPECIFIED 这个模式，会一直往子视图下传递，直到遇到设置了精确数值的View

4、除了精确设置自己的尺寸外，数值上来将都是取父视图的留给子视图的最大值

四、总结

1、View中的measure过程就是从根视图触发，然后不断层层遍历子视图测量的过程，大家要深入理解这个过程

2、子视图在计算自己的尺寸时，要考虑父视图给的控件还有模式，还要考虑自己设置的数值，ViewGroup#getChildMeasureSpec这里实现了

3、MeasureSpec设计采用了一个int来标识mode和size，其中采用了位操作来实现，还是很精妙

到此View的测量分析就到此结束