自定义View中的Mesure

我们在编写layout的xml文件时会碰到layout_width和layout_height两个属性，对于这两个属性我们有三种选择：赋值成具体的数值，match_parent或者wrap_content，而measure过程就是用来处理match_parent或者wrap_content，假如layout中规定所有View的layout_width和layout_height必须赋值成具体的数值，那么measure其实是没有必要的，但是google在设计Android的时候考虑加入match_parent或者wrap_content肯定是有原因的，它们会使得布局更加灵活。

      首先我们来看几个关键的函数和参数：

      

[java] view plain copy print ?

1. 1、public final void measue(int widthMeasureSpec, int heightMeasureSpec);  
2.   
3. 2、protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)；  
4.   
5. 3、protected void measureChildren(int widthMeasureSpec, int heightMeasureSpec)  
6.   
7. 4、protected void measureChild(View child, int parentWidthMeasureSpec, int parentHeightMeasureSpec)  
8.   
9. 5、protected void measureChildWithMargins(View child,int parentWidthMeasureSpec, int widthUsed, int parentHeightMeasureSpec, int heightUsed)  

     接着我们来看View类中measure和onMeasure函数的源码：

[java] view plain copy print ?

1. public final void measure(int widthMeasureSpec, int heightMeasureSpec) {  
2.         if ((mPrivateFlags & FORCE_LAYOUT) == FORCE_LAYOUT ||  
3.                 widthMeasureSpec != mOldWidthMeasureSpec ||  
4.                 heightMeasureSpec != mOldHeightMeasureSpec) {  
5.   
6.             // first clears the measured dimension flag  
7.             mPrivateFlags &= ~MEASURED_DIMENSION_SET;  
8.   
9.             if (ViewDebug.TRACE_HIERARCHY) {  
10.                 ViewDebug.trace(this, ViewDebug.HierarchyTraceType.ON_MEASURE);  
11.             }  
12.   
13.             // measure ourselves, this should set the measured dimension flag back  
14.             onMeasure(widthMeasureSpec, heightMeasureSpec);  
15.   
16.             // flag not set, setMeasuredDimension() was not invoked, we raise  
17.             // an exception to warn the developer  
18.             if ((mPrivateFlags & MEASURED_DIMENSION_SET) != MEASURED_DIMENSION_SET) {  
19.                 throw new IllegalStateException("onMeasure() did not set the"  
20.                         + " measured dimension by calling"  
21.                         + " setMeasuredDimension()");  
22.             }  
23.   
24.             mPrivateFlags |= LAYOUT_REQUIRED;  
25.         }  
26.   
27.         mOldWidthMeasureSpec = widthMeasureSpec;  
28.         mOldHeightMeasureSpec = heightMeasureSpec;  
29.     }  

由于函数原型中有final字段，那么measure根本没打算被子类继承，也就是说measure的过程是固定的，而measure中调用了onMeasure函数，因此真正有变数的是onMeasure函数，onMeasure的默认实现很简单，源码如下：

[java] view plain copy print ?

1. protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
2.         setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),  
3.                 getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));  
4.     }  

onMeasure默认的实现仅仅调用了setMeasuredDimension，setMeasuredDimension函数是一个很关键的函数，它对View的成员变量mMeasuredWidth和mMeasuredHeight变量赋值，而measure的主要目的就是对View树中的每个View的mMeasuredWidth和mMeasuredHeight进行赋值，一旦这两个变量被赋值，则意味着该View的测量工作结束。

 

[java] view plain copy print ?

1. protected final void setMeasuredDimension(int measuredWidth, int measuredHeight) {  
2.         mMeasuredWidth = measuredWidth;  
3.         mMeasuredHeight = measuredHeight;  
4.   
5.         mPrivateFlags |= MEASURED_DIMENSION_SET;  
6.     }  

对于非ViewGroup的View而言，通过调用上面默认的measure——>onMeasure，即可完成View的测量，当然你也可以重载onMeasure，并调用setMeasuredDimension来设置任意大小的布局，但一般不这么做，因为这种做法太“专政”，至于为何“专政”，读完本文就会明白。

      对于ViewGroup的子类而言，往往会重载onMeasure函数负责其children的measure工作，重载时不要忘记调用setMeasuredDimension来设置自身的mMeasuredWidth和mMeasuredHeight。如果我们在layout的时候不需要依赖子视图的大小，那么不重载onMeasure也可以，但是必须重载onLayout来安排子视图的位置，这在下一篇博客中会介绍。  

      再来看下measue(int widthMeasureSpec, int heightMeasureSpec)中的两个参数， 这两个参数分别是父视图提供的测量规格，当父视图调用子视图的measure函数对子视图进行测量时，会传入这两个参数，通过这两个参数以及子视图本身的LayoutParams来共同决定子视图的测量规格，在ViewGroup的measureChildWithMargins函数中体现了这个过程，稍后会介绍。

     MeasureSpec参数的值为int型，分为高32位和低16为，高32位保存的是specMode，低16位表示specSize，specMode分三种：

      1、MeasureSpec.UNSPECIFIED,父视图不对子视图施加任何限制，子视图可以得到任意想要的大小；

      2、MeasureSpec.EXACTLY，父视图希望子视图的大小是specSize中指定的大小；

      3、MeasureSpec.AT_MOST，子视图的大小最多是specSize中的大小。

      以上施加的限制只是父视图“希望”子视图的大小按MeasureSpec中描述的那样，但是子视图的具体大小取决于多方面的。

      ViewGroup中定义了measureChildren, measureChild,  measureChildWithMargins来对子视图进行测量，measureChildren内部只是循环调用measureChild，measureChild和measureChildWithMargins的区别就是是否把margin和padding也作为子视图的大小，我们主要分析measureChildWithMargins的执行过程：

[java] view plain copy print ?

1. protected void measureChildWithMargins(View child,  
2.            int parentWidthMeasureSpec, int widthUsed,  
3.            int parentHeightMeasureSpec, int heightUsed) {  
4.        final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();  
5.   
6.        final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,  
7.                mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin  
8.                        + widthUsed, lp.width);  
9.        final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,  
10.                mPaddingTop + mPaddingBottom + lp.topMargin + lp.bottomMargin  
11.                        + heightUsed, lp.height);  
12.   
13.        child.measure(childWidthMeasureSpec, childHeightMeasureSpec);  
14.    }  

总的来看该函数就是对父视图提供的measureSpec参数进行了调整（结合自身的LayoutParams参数），然后再来调用child.measure()函数，具体通过函数getChildMeasureSpec来进行参数调整，过程如下：

[java] view plain copy print ?

1. public static int getChildMeasureSpec(int spec, int padding, int childDimension) {  
2.         int specMode = MeasureSpec.getMode(spec);  
3.         int specSize = MeasureSpec.getSize(spec);  
4.   
5.         int size = Math.max(0, specSize - padding);  
6.   
7.         int resultSize = 0;  
8.         int resultMode = 0;  
9.   
10.         switch (specMode) {  
11.         // Parent has imposed an exact size on us  
12.         case MeasureSpec.EXACTLY:  
13.             if (childDimension >= 0) {  
14.                 resultSize = childDimension;  
15.                 resultMode = MeasureSpec.EXACTLY;  
16.             } else if (childDimension == LayoutParams.MATCH_PARENT) {  
17.                 // Child wants to be our size. So be it.  
18.                 resultSize = size;  
19.                 resultMode = MeasureSpec.EXACTLY;  
20.             } else if (childDimension == LayoutParams.WRAP_CONTENT) {  
21.                 // Child wants to determine its own size. It can't be  
22.                 // bigger than us.  
23.                 resultSize = size;  
24.                 resultMode = MeasureSpec.AT_MOST;  
25.             }  
26.             break;  
27.   
28.         // Parent has imposed a maximum size on us  
29.         case MeasureSpec.AT_MOST:  
30.             if (childDimension >= 0) {  
31.                 // Child wants a specific size... so be it  
32.                 resultSize = childDimension;  
33.                 resultMode = MeasureSpec.EXACTLY;  
34.             } else if (childDimension == LayoutParams.MATCH_PARENT) {  
35.                 // Child wants to be our size, but our size is not fixed.  
36.                 // Constrain child to not be bigger than us.  
37.                 resultSize = size;  
38.                 resultMode = MeasureSpec.AT_MOST;  
39.             } else if (childDimension == LayoutParams.WRAP_CONTENT) {  
40.                 // Child wants to determine its own size. It can't be  
41.                 // bigger than us.  
42.                 resultSize = size;  
43.                 resultMode = MeasureSpec.AT_MOST;  
44.             }  
45.             break;  
46.   
47.         // Parent asked to see how big we want to be  
48.         case MeasureSpec.UNSPECIFIED:  
49.             if (childDimension >= 0) {  
50.                 // Child wants a specific size... let him have it  
51.                 resultSize = childDimension;  
52.                 resultMode = MeasureSpec.EXACTLY;  
53.             } else if (childDimension == LayoutParams.MATCH_PARENT) {  
54.                 // Child wants to be our size... find out how big it should  
55.                 // be  
56.                 resultSize = 0;  
57.                 resultMode = MeasureSpec.UNSPECIFIED;  
58.             } else if (childDimension == LayoutParams.WRAP_CONTENT) {  
59.                 // Child wants to determine its own size.... find out how  
60.                 // big it should be  
61.                 resultSize = 0;  
62.                 resultMode = MeasureSpec.UNSPECIFIED;  
63.             }  
64.             break;  
65.         }  
66.         return MeasureSpec.makeMeasureSpec(resultSize, resultMode);  
67.     }  

getChildMeasureSpec的总体思路就是通过其父视图提供的MeasureSpec参数得到specMode和specSize，并根据计算出来的specMode以及子视图的childDimension（layout_width和layout_height中定义的）来计算自身的measureSpec，如果其本身包含子视图，则计算出来的measureSpec将作为调用其子视图measure函数的参数，同时也作为自身调用setMeasuredDimension的参数，如果其不包含子视图则默认情况下最终会调用onMeasure的默认实现，并最终调用到setMeasuredDimension，而该函数的参数正是这里计算出来的。

 

      总结：从上面的描述看出，决定权最大的就是View的设计者，因为设计者可以通过调用setMeasuredDimension决定视图的最终大小，例如调用setMeasuredDimension（100， 100）将视图的mMeasuredWidth和mMeasuredHeight设置为100，100，那么父视图提供的大小以及程序员在xml中设置的layout_width和layout_height将完全不起作用，当然良好的设计一般会根据子视图的measureSpec来设置mMeasuredWidth和mMeasuredHeight的大小，已尊重程序员的意图。