Android进阶之深入理解View的测量(Measure)流程机制

前言

View 的工作原理中最重要的就是测量、布局、绘制三大过程，而其中测量是最复杂的;

那么我们就来介绍下View 的测量过程;

一、MeasureSpec

测量自身的大小的时候，会执行measure(int widthMeasureSpec, int heightMeasureSpec)方法。注意方法中两个参数，它们其实是一个int 类型的MeasureSpec;

1、specMode

测量模式分为三种：

• UNSPECIFIED模式：本质就是不限制模式，父视图不对子View进行任何约束，View想要多大要多大，想要多长要多长;
• EXACTLY模式：该模式其实对应的场景就是match_parent或者是一个具体的数据(50dp或80px)，父视图为子View指定一个确切的大小，无论子View的值设置多大，都不能超出父视图的范围;
• AT_MOST模式：这个模式对应的场景就是wrap_content，其内容就是父视图给子View设置一个最大尺寸，子View只要不超过这个尺寸即可;

2、MeasureSpec

View的MeasureSpec值是根据子View的布局参数(LayoutParams)和父容器的MeasureSpec至计算而来的，其具体逻辑封装在了getChildMeasureSpec()方法中

1. publicstaticintgetChildMeasureSpec(
2. intspec,intpadding,intchildDimension){
3. //1、获取parent的specMode
4. intspecMode=MeasureSpec.getMode(spec);
5. //2、获取parent的specSize
6. intspecSize=MeasureSpec.getSize(spec);
7. //3、size=剩余的可用大小
8. intsize=Math.max(0,specSize-padding);
9. intresultSize=0;
10. intresultMode=0;
11. //4、通过switch语句判断parent的集中mode，分别处理
12. switch(specMode){
13. //5、parent为MeasureSpec.EXACTLY时
14. caseMeasureSpec.EXACTLY:
15. if(childDimension>=0){
16. //5.1、当childDimension大于0时，表示child的大小是
17. //明确指出的，如layout_width="100dp";
18. //此时child的大小=childDimension，
19. resultSize=childDimension;
20. //child的测量模式=MeasureSpec.EXACTLY
21. resultMode=MeasureSpec.EXACTLY;
22. }elseif(childDimension==LayoutParams.MATCH_PARENT){
23. //5.2、此时为LayoutParams.MATCH_PARENT
24. //也就是android:layout_width="match_parent"
25. //因为parent的大小是明确的，child要匹配parent的大小
26. //那么我们就直接让child=parent的大小就好
27. resultSize=size;
28. //同样，child的测量模式=MeasureSpec.EXACTLY
29. resultMode=MeasureSpec.EXACTLY;
30. }elseif(childDimension==LayoutParams.WRAP_CONTENT){
31. //5.3、此时为LayoutParams.WRAP_CONTENT
32. //也就是android:layout_width="wrap_content"
33. //这个模式需要特别对待，child说我要的大小刚好够放
34. //需要展示的内容就好，而此时我们并不知道child的内容
35. //需要多大的地方，暂时先把parent的size给他
36. resultSize=size;
37. //自然，child的mode就是MeasureSpec.AT_MOST的了
38. resultMode=MeasureSpec.AT_MOST;
39. }
40. break;
41. //5、parent为AT_MOST，此时child最大不能超过parent
42. caseMeasureSpec.AT_MOST:
43. if(childDimension>=0){
44. //同样child大小明确时，
45. //大小直接时指定的childDimension
46. resultSize=childDimension;
47. resultMode=MeasureSpec.EXACTLY;
48. }elseif(childDimension==LayoutParams.MATCH_PARENT){
49. //child要跟parent一样大，resultSize=可用大小
50. resultSize=size;
51. //因为parent是AT_MOST，child的大小也还是未定的，
52. //所以也是MeasureSpec.AT_MOST
53. resultMode=MeasureSpec.AT_MOST;
54. }elseif(childDimension==LayoutParams.WRAP_CONTENT){
55. //又是特殊情况，先给child可用的大小
56. resultSize=size;
57. resultMode=MeasureSpec.AT_MOST;
58. }
59. break;
60. //这种模式是很少用的，我们也看下吧
61. caseMeasureSpec.UNSPECIFIED:
62. if(childDimension>=0){
63. //与前面同样的处理
64. resultSize=childDimension;
65. resultMode=MeasureSpec.EXACTLY;
66. }elseif(childDimension==LayoutParams.MATCH_PARENT){
67. //Childwantstobeoursize...findouthowbigitshould
68. //be
69. resultSize=View.sUseZeroUnspecifiedMeasureSpec?0:size;
70. resultMode=MeasureSpec.UNSPECIFIED;
71. }elseif(childDimension==LayoutParams.WRAP_CONTENT){
72. //Childwantstodetermineitsownsize....findouthow
73. //bigitshouldbe
74. resultSize=View.sUseZeroUnspecifiedMeasureSpec?0:size;
75. resultMode=MeasureSpec.UNSPECIFIED;
76. }
77. break;
78. }
79. //通过传入resultSize和resultMode生成一个MeasureSpec.返回
80. returnMeasureSpec.makeMeasureSpec(resultSize,resultMode);
81. }

• ①当子View采用具体数值(dp / px)时：无论父容器的测量模式是什么，子View的测量模式都是EXACTLY且大小等于设置的具体数值;
• ②当子View采用match_parent时：子View的测量模式与父容器的测量模式一致;若测量模式为EXACTLY，则子View的大小为父容器的剩余空间;若测量模式为AT_MOST，则子View的大小不超过父容器的剩余空间;
• ③当子View采用wrap_parent时：如果父容器测量模式为UNSPECIFIED，子View也为UNSPECIFIED，否则子View为AT_MOST且大小不超过父容器的剩余空间;

二、view测量过程

1、performMeasure()

加载好系统布局资源后，会触发ViewRootImpl的performTraversals()方法，该方法内容会开始执行测量、布局和绘制的工作，我们来看这个方法的源码关键部分：

1. privatevoidperformTraversals(){
2. ...
3. if(!mStopped){
4. //获取顶层布局的childWidthMeasureSpec
5. intchildWidthMeasureSpec=getRootMeasureSpec(mWidth,lp.width);
6. //获取顶层布局的childHeightMeasureSpec
7. intchildHeightMeasureSpec=getRootMeasureSpec(mHeight,lp.height);
8. //测量开始测量
9. performMeasure(childWidthMeasureSpec,childHeightMeasureSpec);
10. }
11. }
12. if(didLayout){
13. //执行布局方法
14. performLayout(lp,desiredWindowWidth,desiredWindowHeight);
15. ...
16. }
17. if(!cancelDraw&&!newSurface){
18. ...
19. //开始绘制了哦
20. performDraw();
21. }
22. }
23. }

整个方法内部其实就是做了一些基础的判断后，再顺序的调用测量、布局和绘制的相关方法，从而完成自定义View的整个工作流程;

performTraversals方法，使用的是getRootMeasureSpec方法来获取子View的MeasureSpec;

整个Activity的顶层View其实就是一个DecorView，所以这里获取的其实是DeorView的MeasureSpec，然后将其传入performMeasure方法中去开始测量，现在看看PerformMeasure方法：

1. privatevoidperformMeasure(intchildWidthMeasureSpec,
2. intchildHeightMeasureSpec){
3. Trace.traceBegin(Trace.TRACE_TAG_VIEW,"measure");
4. try{
5. //mView其实就是我们的顶层DecorView，从DecorView开始测量
6. mView.measure(childWidthMeasureSpec,childHeightMeasureSpec);
7. }finally{
8. Trace.traceEnd(Trace.TRACE_TAG_VIEW);
9. }
10. }

2、measure()

源码中找到了measure方法

1. publicfinalvoidmeasure(intwidthMeasureSpec,intheightMeasureSpec){
2. booleanoptical=isLayoutModeOptical(this);
3. if(optical!=isLayoutModeOptical(mParent)){
4. Insetsinsets=getOpticalInsets();
5. intoWidth=insets.left+insets.right;
6. intoHeight=insets.top+insets.bottom;
7. widthMeasureSpec=MeasureSpec.adjust(widthMeasureSpec,optical?-oWidth:oWidth);
8. heightMeasureSpec=MeasureSpec.adjust(heightMeasureSpec,optical?-oHeight:oHeight);
9. }
10. //Suppresssignextensionforthelowbytes
11. longkey=(long)widthMeasureSpec<<32|(long)heightMeasureSpec&0xffffffffL;
12. if(mMeasureCache==null)mMeasureCache=newLongSparseLongArray(2);
13. finalbooleanforceLayout=(mPrivateFlags&PFLAG_FORCE_LAYOUT)==PFLAG_FORCE_LAYOUT;
14. //OptimizelayoutbyavoidinganextraEXACTLYpasswhentheviewis
15. //alreadymeasuredasthecorrectsize.InAPI23andbelow,this
16. //extrapassisrequiredtomakeLinearLayoutre-distributeweight.
17. finalbooleanspecChanged=widthMeasureSpec!=mOldWidthMeasureSpec
18. ||heightMeasureSpec!=mOldHeightMeasureSpec;
19. finalbooleanisSpecExactly=MeasureSpec.getMode(widthMeasureSpec)==MeasureSpec.EXACTLY
20. &&MeasureSpec.getMode(heightMeasureSpec)==MeasureSpec.EXACTLY;
21. finalbooleanmatchesSpecSize=getMeasuredWidth()==MeasureSpec.getSize(widthMeasureSpec)
22. &&getMeasuredHeight()==MeasureSpec.getSize(heightMeasureSpec);
23. finalbooleanneedsLayout=specChanged
24. &&(sAlwaysRemeasureExactly||!isSpecExactly||!matchesSpecSize);
25. if(forceLayout||needsLayout){
26. //firstclearsthemeasureddimensionflag
27. mPrivateFlags&=~PFLAG_MEASURED_DIMENSION_SET;
28. resolveRtlPropertiesIfNeeded();
29. intcacheIndex=forceLayout?-1:mMeasureCache.indexOfKey(key);
30. if(cacheIndex<0||sIgnoreMeasureCache){
31. //measureourselves,thisshouldsetthemeasureddimensionflagback
32. onMeasure(widthMeasureSpec,heightMeasureSpec);
33. mPrivateFlags3&=~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
34. }else{
35. longvalue=mMeasureCache.valueAt(cacheIndex);
36. //Castingalongtointdropsthehigh32bits,nomaskneeded
37. setMeasuredDimensionRaw((int)(value>>32),(int)value);
38. mPrivateFlags3|=PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
39. }
40. //flagnotset,setMeasuredDimension()wasnotinvoked,weraise
41. //anexceptiontowarnthedeveloper
42. if((mPrivateFlags&PFLAG_MEASURED_DIMENSION_SET)!=PFLAG_MEASURED_DIMENSION_SET){
43. thrownewIllegalStateException("Viewwithid"+getId()+":"
44. +getClass().getName()+"#onMeasure()didnotsetthe"
45. +"measureddimensionbycalling"
46. +"setMeasuredDimension()");
47. }
48. mPrivateFlags|=PFLAG_LAYOUT_REQUIRED;
49. }
50. mOldWidthMeasureSpec=widthMeasureSpec;
51. mOldHeightMeasureSpec=heightMeasureSpec;
52. mMeasureCache.put(key,((long)mMeasuredWidth)<<32|
53. (long)mMeasuredHeight&0xffffffffL);//suppresssignextension
54. }

View的测量是View.onMeasure而ViewGroup的测量则是XXLayout.onMeasure，这两种onMeasure方法的实现是不同的

3、View.onMeasure()

获取一个建议最小值;

调用getDefaultSize方法定义对View尺寸的测量逻辑;

调用setMeasureDimension()储存测量后的View宽/高;

1. protectedvoidonMeasure(intwidthMeasureSpec,
2. intheightMeasureSpec){
3. setMeasuredDimension(
4. getDefaultSize(getSuggestedMinimumWidth(),
5. widthMeasureSpec),
6. getDefaultSize(getSuggestedMinimumHeight(),
7. heightMeasureSpec));
8. }
9. getSuggestedMinimumWidth（）
10. protectedintgetSuggestedMinimumWidth(){
11. return(mBackground==null)?mMinWidth:max(mMinWidth,mBackground.getMinimumWidth());
12. }
13. 前View是否有背景?没有就返回android:minWidth设置的值:有就返回android:minWidth和mBackground.getMinimumWidth()中较大的那个值；
14. publicintgetMinimumWidth(){
15. finalintintrinsicWidth=getIntrinsicWidth();
16. //返回背景图Drawable的原始宽度
17. returnintrinsicWidth>0?intrinsicWidth:0;
18. }

getIntrinsicWidth()获取的是背景图的原始宽度，背景图是BitmapDrawable则有原始宽度，在没有原始宽度的情况下则返回0;

4、getDefaultSize()

1. publicstaticintgetDefaultSize(intsize,intmeasureSpec){
2. intresult=size;
3. //1、获得MeasureSpec的mode
4. intspecMode=MeasureSpec.getMode(measureSpec);
5. //2、获得MeasureSpec的specSize
6. intspecSize=MeasureSpec.getSize(measureSpec);
7. switch(specMode){
8. caseMeasureSpec.UNSPECIFIED:
9. //这个我们先不看他
10. result=size;
11. break;
12. caseMeasureSpec.AT_MOST:
13. caseMeasureSpec.EXACTLY:
14. //3、可以看到，最终返回的size就是我们MeasureSpec中测量得到的size
15. result=specSize;
16. break;
17. }
18. returnresult;
19. }

测量模式是AT_MOST还是EXACTLY，最终返回的Size是一样的;

5、setMeasureDimension

该方法是储存测量后的View的宽和高的，在自定义View的时候，我们自己重写的onMeasure方法最后一定要调用这个方法，否则会报错

1. protectedfinalvoidsetMeasuredDimension(intmeasuredWidth,intmeasuredHeight){
2. //1、判断是否使用视觉边界布局
3. booleanoptical=isLayoutModeOptical(this);
4. //2、判断view和parentView使用的视觉边界布局是否一致
5. if(optical!=isLayoutModeOptical(mParent)){
6. //不一致时要做一些边界的处理
7. Insetsinsets=getOpticalInsets();
8. intopticalWidth=insets.left+insets.right;
9. intopticalHeight=insets.top+insets.bottom;
10. measuredWidth+=optical?opticalWidth:-opticalWidth;
11. measuredHeight+=optical?opticalHeight:-opticalHeight;
12. }
13. //3、重点来了，经过过滤之后调用了setMeasuredDimensionRaw方法，看来应该是这个方法设置我们的view的大小
14. setMeasuredDimensionRaw(measuredWidth,measuredHeight);
15. }
16. setMeasureDimensionRaw方法：
17. privatevoidsetMeasuredDimensionRaw(intmeasuredWidth,intmeasuredHeight){
18. //最终将测量好的大小存储到mMeasuredWidth和mMeasuredHeight上，所以在测量之后
19. //我们可以通过调用getMeasuredWidth获得测量的宽、getMeasuredHeight获得高
20. mMeasuredWidth=measuredWidth;
21. mMeasuredHeight=measuredHeight;
22. mPrivateFlags|=PFLAG_MEASURED_DIMENSION_SET;
23. }

以上就是View的测量过程，其顺序为：

performTraversals->performMeasure->measure->onMeasure-> setMeasuredDimension-> setMeasuredDimensionRaw，由setMeasuredDimensionRaw最终保存测量的数据

三、ViewGroup的测量过程详解

1、measureChildren()

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

1. protectedvoidmeasureChildren(intwidthMeasureSpec,intheightMeasureSpec){
2. //参数说明：父视图的测量规格（MeasureSpec）
3. finalintsize=mChildrenCount;
4. finalView[]children=mChildren;
5. //遍历所有的子view
6. for(inti=0;i<size;++i){
7. finalViewchild=children[i];
8. //如果View的状态不是GONE就调用measureChild()去进行下一步的测量
9. if((child.mViewFlags&VISIBILITY_MASK)!=GONE){
10. measureChild(child,widthMeasureSpec,heightMeasureSpec);
11. }
12. }
13. }

2、measureChild()

作用就是计算单个子View的MeasureSpec，调用子View的measure进行每个子View最后的宽、高的测量

1. protectedvoidmeasureChild(Viewchild,intparentWidthMeasureSpec,
2. intparentHeightMeasureSpec){
3. //获取子视图的布局参数
4. finalLayoutParamslp=child.getLayoutParams();
5. //调用getChildMeasureSpec()，根据父视图的MeasureSpec&布局参数LayoutParams，计算单个子View的MeasureSpec
6. //getChildMeasureSpec()请回看上面的解析
7. //获取ChildView的widthMeasureSpec
8. finalintchildWidthMeasureSpec=getChildMeasureSpec(parentWidthMeasureSpec,
9. mPaddingLeft+mPaddingRight,lp.width);
10. //获取ChildView的heightMeasureSpec
11. finalintchildHeightMeasureSpec=getChildMeasureSpec(parentHeightMeasureSpec,
12. mPaddingTop+mPaddingBottom,lp.height);
13. //将计算好的子View的MeasureSpec值传入measure()，进行最后的测量
14. child.measure(childWidthMeasureSpec,childHeightMeasureSpec);
15. }

3、measure()

和View的measure一致

1. publicfinalvoidmeasure(intwidthMeasureSpec,intheightMeasureSpec){
2. ...
3. intcacheIndex=(mPrivateFlags&PFLAG_FORCE_LAYOUT)==PFLAG_FORCE_LAYOUT?-1:
4. mMeasureCache.indexOfKey(key);
5. if(cacheIndex<0||sIgnoreMeasureCache){
6. //调用onMeasure()计算视图大小
7. onMeasure(widthMeasureSpec,heightMeasureSpec);
8. mPrivateFlags3&=~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
9. }else{
10. ...
11. }

4、XXXLayout.onMeasure()

1. ViewGroup的onMeasure和View的onMeasure是不同的，究其原因其实是因为ViewGroup是一个抽象类，所以即便它继承了View也不用必须实现View中的onMeasure方法，而它的子类不具备通用的布局特性，这导致他们的子View的测量方法各不相同，因此，ViewGroup无法对onMeasure()做统一的实现
2. FrameLayout为例，看看它的onMeasure是如何实现的：
3. //这里的widthMeasureSpec、heightMeasureSpec
4. //其实就是我们frameLayout可用的widthMeasureSpec、
5. //heightMeasureSpec
6. protectedvoidonMeasure(intwidthMeasureSpec,intheightMeasureSpec){
7. //1、获得frameLayout下childView的个数
8. intcount=getChildCount();
9. //2、看这里的代码我们可以根据前面的Measure图来进行分析，因为只要parent
10. //不是EXACTLY模式，以frameLayout为例，假设frameLayout本身还不是EXACTL模式，
11. //那么表示他的大小此时还是不确定的，从表得知，此时frameLayout的大小是根据
12. //childView的最大值来设置的，这样就很好理解了，也就是childView测量好后还要再
13. //测量一次，因为此时frameLayout的值已经可以算出来了，对于child为MATCH_PARENT
14. //的，child的大小也就确定了，理解了这里，后面的代码就很容易看懂了
15. finalbooleanmeasureMatchParentChildren=
16. MeasureSpec.getMode(widthMeasureSpec)!=MeasureSpec.EXACTLY||
17. MeasureSpec.getMode(heightMeasureSpec)!=MeasureSpec.EXACTLY;
18. //3、清理存储模式为MATCH_PARENT的child的队列
19. mMatchParentChildren.clear();
20. //4、下面三个值最终会用来设置frameLayout的大小
21. intmaxHeight=0;
22. intmaxWidth=0;
23. intchildState=0;
24. //5、开始便利frameLayout下的所有child
25. for(inti=0;i<count;i++){
26. finalViewchild=getChildAt(i);
27. //6、小发现哦，只要mMeasureAllChildren是true，就算child是GONE也会被测量哦，
28. if(mMeasureAllChildren||child.getVisibility()!=GONE){
29. //7、开始测量childView
30. measureChildWithMargins(child,widthMeasureSpec,0,heightMeasureSpec,0);
31. //8、下面代码是获取child中的width和height的最大值，后面用来重新设置frameLayout，有需要的话
32. finalLayoutParamslp=(LayoutParams)child.getLayoutParams();
33. maxWidth=Math.max(maxWidth,
34. child.getMeasuredWidth()+lp.leftMargin+lp.rightMargin);
35. maxHeight=Math.max(maxHeight,
36. child.getMeasuredHeight()+lp.topMargin+lp.bottomMargin);
37. childState=combineMeasuredStates(childState,child.getMeasuredState());
38. //9、如果frameLayout不是EXACTLY，
39. if(measureMatchParentChildren){
40. if(lp.width==LayoutParams.MATCH_PARENT||
41. lp.height==LayoutParams.MATCH_PARENT){
42. //10、存储LayoutParams.MATCH_PARENT的child，因为现在还不知道frameLayout大小，
43. //也就无法设置child的大小，后面需重新测量
44. mMatchParentChildren.add(child);
45. }
46. }
47. }
48. }
49. ....
50. //11、这里开始设置frameLayout的大小
51. setMeasuredDimension(resolveSizeAndState(maxWidth,widthMeasureSpec,childState),
52. resolveSizeAndState(maxHeight,heightMeasureSpec,
53. childState<
54. //12、frameLayout大小确认了，我们就需要对宽或高为LayoutParams.MATCH_PARENTchild重新测量，设置大小
55. count=mMatchParentChildren.size();
56. if(count>1){
57. for(inti=0;i<count;i++){
58. finalViewchild=mMatchParentChildren.get(i);
59. finalMarginLayoutParamslp=(MarginLayoutParams)child.getLayoutParams();
60. finalintchildWidthMeasureSpec;
61. if(lp.width==LayoutParams.MATCH_PARENT){
62. finalintwidth=Math.max(0,getMeasuredWidth()
63. -getPaddingLeftWithForeground()-getPaddingRightWithForeground()
64. -lp.leftMargin-lp.rightMargin);
65. //13、注意这里，为child是EXACTLY类型的childWidthMeasureSpec，
66. //也就是大小已经测量出来了不需要再测量了
67. //通过MeasureSpec.makeMeasureSpec生成相应的MeasureSpec
68. childWidthMeasureSpec=MeasureSpec.makeMeasureSpec(
69. width,MeasureSpec.EXACTLY);
70. }else{
71. //14、如果不是，说明此时的child的MeasureSpec是EXACTLY的，直接获取child的MeasureSpec，
72. childWidthMeasureSpec=getChildMeasureSpec(widthMeasureSpec,
73. getPaddingLeftWithForeground()+getPaddingRightWithForeground()+
74. lp.leftMargin+lp.rightMargin,
75. lp.width);
76. }
77. //这里是对高做处理，与宽类似
78. finalintchildHeightMeasureSpec;
79. if(lp.height==LayoutParams.MATCH_PARENT){
80. finalintheight=Math.max(0,getMeasuredHeight()
81. -getPaddingTopWithForeground()-getPaddingBottomWithForeground()
82. -lp.topMargin-lp.bottomMargin);
83. childHeightMeasureSpec=MeasureSpec.makeMeasureSpec(
84. height,MeasureSpec.EXACTLY);
85. }else{
86. childHeightMeasureSpec=getChildMeasureSpec(heightMeasureSpec,
87. getPaddingTopWithForeground()+getPaddingBottomWithForeground()+
88. lp.topMargin+lp.bottomMargin,
89. lp.height);
90. }
91. //最终，再次测量child
92. child.measure(childWidthMeasureSpec,childHeightMeasureSpec);
93. }
94. }
95. }

总结

测量始于DecorView，通过不断的遍历子View的measure方法，根据ViewGroup的MeasureSpec及子View的LayoutParams来决定子View的MeasureSpec，进一步获取子View的测量宽高，然后逐层返回，不断保存ViewGroup的测量宽高;

单一View，一般重写此方法，针对wrap_content情况，规定View默认的大小值，避免于match_parent情况一致。ViewGroup，若不重写，就会执行和单子View中相同逻辑，不会测量子View。一般会重写onMeasure()方法，循环测量子View;

原文链接：https://mp.weixin.qq.com/s/egu-869d0KU_89p6OWJoDA