在Android中,Veiw從內(nèi)存中到呈現(xiàn)在UI界面上需要經(jīng)過measure（測量）、layout（布局）、draw（繪制）這樣一個過程。為什么需要measure過程?因為在Android中View有自適應尺寸的機制，在用自適應尺寸來定義View大小的時候，View的真實尺寸還不能確定，這時候就需要根據(jù)View的寬高匹配規(guī)則，經(jīng)過計算，得到具體的像素值，measure過程就是干這件事。
本文將從源碼角度解析View的measure過程，這其中會涉及某些關(guān)鍵類以及關(guān)鍵方法。
MeasureSpec
MeasureSpec封裝了父布局傳遞給子布局的布局要求，它通過一個32位int類型的值來表示，該值包含了兩種信息，高兩位表示的是SpecMode（測量模式），低30位表示的是SpecSize（測量的具體大小）。下面通過注釋的方式來分析來類：
/**
* 三種SpecMode：
* 1.UNSPECIFIED
* 父ViewGroup沒有對子View施加任何約束，子view可以是任意大小。這種情況比較少見,主要用于系統(tǒng)內(nèi)部多次measure的情形，用到的一般都是可以滾動的容器中的子view，比如ListView、GridView、RecyclerView中某些情況下的子view就是這種模式。一般來說，我們不需要關(guān)注此模式。
* 2.EXACTLY
* 該view必須使用父ViewGroup給其指定的尺寸。對應match_parent或者具體數(shù)值（比如30dp）
* 3.AT_MOST
* 該View最大可以取父ViewGroup給其指定的尺寸。對應wrap_content
*
* MeasureSpec使用了二進制去減少對象的分配。
*/
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與任何數(shù)做與運算都得任何數(shù)，0與任何數(shù)做與運算都得0）
private static final int MODE_MASK = 0x3 << MODE_SHIFT;
// 0向左進位30，就是00 00000000000(00后跟30個0)
public static final int UNSPECIFIED = 0 << MODE_SHIFT;
// 1向左進位30，就是01 00000000000(01后跟30個0)
public static final int EXACTLY = 1 << MODE_SHIFT;
// 2向左進位30，就是10 00000000000(10后跟30個0)
public static final int AT_MOST = 2 << MODE_SHIFT;
/**
* 根據(jù)提供的size和mode得到一個詳細的測量結(jié)果
*/
// 第一個return：
// measureSpec = size + mode； (注意：二進制的加法，不是十進制的加法！)
// 這里設計的目的就是使用一個32位的二進制數(shù)，32和31位代表了mode的值，后30位代表size的值
// 例如size=100(4)，mode=AT_MOST，則measureSpec=100+10000...00=10000..00100
//
// 第二個return：
// size & ~MODE_MASK就是取size 的后30位，mode & MODE_MASK就是取mode的前兩位，最后執(zhí)行或運算，得出來的數(shù)字，前面2位包含代表mode，后面30位代表size
public static int makeMeasureSpec(int size, int mode) {
if (sUseBrokenMakeMeasureSpec) {
return size + mode;
} else {
return (size & ~MODE_MASK) | (mode & MODE_MASK);
}
}
/**
* 獲得SpecMode
*/
// 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的值
public static int getMode(int measureSpec) {
return (measureSpec & MODE_MASK);
}
/**
* 獲得SpecSize
*/
// size = measureSpec & ~MODE_MASK;
// 原理同上，不過這次是將MODE_MASK取反，也就是變成了00 111111(00后跟30個1)，將32,31替換成0也就是去掉mode，保留后30位的size
public static int getSize(int measureSpec) {
return (measureSpec & ~MODE_MASK);
}
}
measure()
當View的父ViewGroup對View進行測量時，會調(diào)用View的measure方法，ViewGroup會傳入widthMeasureSpec和heightMeasureSpec，分別表示父控件對View的寬度和高度的一些限制條件。源碼分析該方法:
public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
//首先判斷當前View的layoutMode是不是特例LAYOUT_MODE_OPTICAL_BOUNDS
boolean optical = isLayoutModeOptical(this);
if (optical != isLayoutModeOptical(mParent)) {
//LAYOUT_MODE_OPTICAL_BOUNDS是特例情況，比較少見,不分析
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);
}
//根據(jù)widthMeasureSpec和heightMeasureSpec計算key值，在下面用key值作為鍵，緩存我們測量得到的結(jié)果
long key = (long) widthMeasureSpec << 32 | (long) heightMeasureSpec & 0xffffffffL;
//mMeasureCache是LongSparseLongArray類型的成員變量，
//其緩存著View在不同widthMeasureSpec、heightMeasureSpec下測量過的結(jié)果
if (mMeasureCache == null) mMeasureCache = new LongSparseLongArray(2);
//mOldWidthMeasureSpec和mOldHeightMeasureSpec分別表示上次對View進行測量時的widthMeasureSpec和heightMeasureSpec
//執(zhí)行View的measure方法時，View總是先檢查一下是不是真的有必要費很大力氣去做真正的測量工作
//mPrivateFlags是一個Int類型的值，其記錄了View的各種狀態(tài)位
//如果(mPrivateFlags & PFLAG_FORCE_LAYOUT) == PFLAG_FORCE_LAYOUT，
//那么表示當前View需要強制進行l(wèi)ayout（比如執(zhí)行了View的forceLayout方法），所以這種情況下要嘗試進行測量
//如果新傳入的widthMeasureSpec/heightMeasureSpec與上次測量時的mOldWidthMeasureSpec/mOldHeightMeasureSpec不等，
//那么也就是說該View的父ViewGroup對該View的尺寸的限制情況有變化，這種情況下要嘗試進行測量
if ((mPrivateFlags & PFLAG_FORCE_LAYOUT) == PFLAG_FORCE_LAYOUT ||
widthMeasureSpec != mOldWidthMeasureSpec ||
heightMeasureSpec != mOldHeightMeasureSpec) {
//通過按位操作，重置View的狀態(tài)標志mPrivateFlags，將其標記為未測量狀態(tài)
mPrivateFlags &= ~PFLAG_MEASURED_DIMENSION_SET;
//對阿拉伯語、希伯來語等從右到左書寫、布局的語言進行特殊處理
resolveRtlPropertiesIfNeeded();
//在View真正進行測量之前，View還想進一步確認能不能從已有的緩存mMeasureCache中讀取緩存過的測量結(jié)果
//如果是強制layout導致的測量，那么將cacheIndex設置為-1，即不從緩存中讀取測量結(jié)果
//如果不是強制layout導致的測量，那么我們就用上面根據(jù)measureSpec計算出來的key值作為緩存索引cacheIndex,這時候有可能找到相應的值,找到就返回對應索引;也可能找不到,找不到就返回-1
int cacheIndex = (mPrivateFlags & PFLAG_FORCE_LAYOUT) == PFLAG_FORCE_LAYOUT ? -1 :
mMeasureCache.indexOfKey(key);
if (cacheIndex < 0 || sIgnoreMeasureCache) {
//在緩存中找不到相應的值或者需要忽略緩存結(jié)果的時候,重新測量一次
//此處調(diào)用onMeasure方法，并把尺寸限制條件widthMeasureSpec和heightMeasureSpec傳入進去
//onMeasure方法中將會進行實際的測量工作，并把測量的結(jié)果保存到成員變量中
onMeasure(widthMeasureSpec, heightMeasureSpec);
//onMeasure執(zhí)行完后，通過位操作，重置View的狀態(tài)mPrivateFlags，將其標記為在layout之前不必再進行測量的狀態(tài)
mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
} else {
//如果運行到此處，那么表示當前的條件允許View從緩存成員變量mMeasureCache中讀取測量過的結(jié)果
//用上面得到的cacheIndex從緩存mMeasureCache中取出值，不必在調(diào)用onMeasure方法進行測量了
long value = mMeasureCache.valueAt(cacheIndex);
//一旦我們從緩存中讀到值，我們就可以調(diào)用setMeasuredDimensionRaw方法將當前測量的結(jié)果保存到成員變量中
setMeasuredDimensionRaw((int) (value >> 32), (int) value);
mPrivateFlags3 |= PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
}
//如果我們自定義的View重寫了onMeasure方法，但是沒有調(diào)用setMeasuredDimension()方法，
//那么此處就會拋出異常，提醒開發(fā)者在onMeasure方法中調(diào)用setMeasuredDimension()方法
//Android是如何知道我們有沒有在onMeasure方法中調(diào)用setMeasuredDimension()方法的呢？
//方法很簡單，還是通過解析狀態(tài)位mPrivateFlags。
//setMeasuredDimension()方法中會將mPrivateFlags設置為PFLAG_MEASURED_DIMENSION_SET狀態(tài)，即已測量狀態(tài)，
//此處就檢查mPrivateFlags是否含有PFLAG_MEASURED_DIMENSION_SET狀態(tài)即可判斷setMeasuredDimension是否被調(diào)用
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()");
}
//到了這里,View已經(jīng)測量完了并且將測量的結(jié)果保存在View的mMeasuredWidth和mMeasuredHeight中,將標志位置為可以layout的狀態(tài)
mPrivateFlags |= PFLAG_LAYOUT_REQUIRED;
}
//mOldWidthMeasureSpec和mOldHeightMeasureSpec保存著最近一次測量時的MeasureSpec，
//在測量完成后將這次新傳入的MeasureSpec賦值給它們
mOldWidthMeasureSpec = widthMeasureSpec;
mOldHeightMeasureSpec = heightMeasureSpec;
//最后用上面計算出的key作為鍵，測量結(jié)果作為值，將該鍵值對放入成員變量mMeasureCache中，
//這樣就實現(xiàn)了對本次測量結(jié)果的緩存，以便在下次measure方法執(zhí)行的時候，有可能將其從中直接讀出，
//從而省去實際測量的步驟
mMeasureCache.put(key, ((long) mMeasuredWidth) << 32 |
(long) mMeasuredHeight & 0xffffffffL); // suppress sign extension
}
上面的注釋已經(jīng)一目了然,這里再總結(jié)一下measure()都干了什么事:
- 首先,調(diào)用
View.measure()方法時View并不是立即就去測量,而是先判斷一下是否有必要進行測量操作,如果不是強制測量或者MeasureSpec與上次的MeasureSpec相同的時候,那么View就不需要重新測量了. - 如果不滿足上面條件,View就考慮去做測量工作了.但在測量之前,View還想偷懶,如果能在緩存中找到上次的測量結(jié)果,那直接從緩存中獲取就可以了.它會以MeasureSpec計算出的key值作為鍵，去成員變量
mMeasureCache中查找是否緩存過對應key的測量結(jié)果，如果能找到，那么就簡單調(diào)用一下setMeasuredDimensionRaw方法，將從緩存中讀到的測量結(jié)果保存到成員變量mMeasuredWidth和mMeasuredHeight中。 - 如果不能從
mMeasureCache中讀到緩存過的測量結(jié)果，那么這次View就真的不能再偷懶了，只能乖乖地調(diào)用onMeasure()方法去完成實際的測量工作，并且將尺寸限制條件widthMeasureSpec和heightMeasureSpec傳遞給onMeasure()方法。關(guān)于onMeasure()方法，我們會在下面詳細介紹。 - 不論上面代碼走了哪個判斷的分支，最終View都會得到測量的結(jié)果，并且將結(jié)果保存到
mMeasuredWidth和mMeasuredHeight這兩個成員變量中,同時緩存到成員變量mMeasureCache中，以便下次執(zhí)行measure()方法時能夠從其中讀取緩存值。 - 需要說明的是，View有一個成員變量
mPrivateFlags，用以保存View的各種狀態(tài)位，在測量開始前，會將其設置為未測量狀態(tài)，在測量完成后會將其設置為已測量狀態(tài)。
onMeasure()
上面我們提到,View的measure()方法在需要進行實際的測量工作時會調(diào)用onMeasure()方法.看下源碼:
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
}
我們發(fā)現(xiàn)onMeasure()方法中調(diào)用了setMeasuredDimension()方法,setMeasuredDimension()又調(diào)用了getDefaultSize()方法.getDefaultSize()又調(diào)用了getSuggestedMinimumWidth()和getSuggestedMinimumHeight(),那我們反向研究一下,先看下getSuggestedMinimumWidth()方法(getSuggestedMinimumHeight()原理getSuggestedMinimumWidth()跟一樣).
getSuggestedMinimumWidth()
該方法返回View推薦的最小寬度,源碼如下:
protected int getSuggestedMinimumWidth() {
return (mBackground == null) ? mMinWidth : max(mMinWidth, mBackground.getMinimumWidth());
}
源碼很簡單,如果View沒有背景,就直接返回View本身的最小寬度mMinWidth;如果給View設置了背景,就取View本身的最小寬度mMinWidth和背景的最小寬度的最大值.
那么mMinWidth是哪里來的？搜索下源碼就可以知道，View的最小寬度mMinWidth可以有兩種方式進行設置：
-
第一種是在View的構(gòu)造方法中進行賦值的，View通過讀取XML文件中View設置的
minWidth屬性來為mMinWidth賦值：case R.styleable.View_minWidth: mMinWidth = a.getDimensionPixelSize(attr, 0); break; -
第二種是在調(diào)用View的
setMinimumWidth方法為mMinWidth賦值：public void setMinimumWidth(int minWidth) { mMinWidth = minWidth; requestLayout(); }
getDefaultSize()
知道了getSuggestedMinimumWidth()/getSuggestedMinimumHeight()這兩個方法返回的是View的最小寬度/高度之后，我們將得到的最小寬度/高度值作為參數(shù)傳給getDefaultSize(int size, int measureSpec)方法，看下源碼：
public static int getDefaultSize(int size, int measureSpec) {
//size是傳進來的View自己想要的最小寬度/高度
int result = size;
//measureSpec是父ViewGroup給View的限制條件，解析出specMode和specSize
int specMode = MeasureSpec.getMode(measureSpec);
int specSize = MeasureSpec.getSize(measureSpec);
switch (specMode) {
//如果specMode為UNSPECIFIED，就表明父ViewGroup沒有對該View尺寸進行限制，直接取View自己想要的寬高
case MeasureSpec.UNSPECIFIED:
result = size;
break;
//如果specMode為EXACTLY，表明父ViewGroup要求該View必須用父ViewGroup指定的尺寸（specSize），取父ViewGroup指定的寬高值
//如果specMode為AT_MOST，表明ViewGroup給該View指定了最大寬度/高度尺寸（specSize）,取父ViewGroup指定的最大寬度/高度。
//這里肯定有人有疑問了？為什么specMode為AT_MOST是取View能到達的最大寬高值specSize，跟EXACTLY模式下的取值一模一樣，聯(lián)想到EXACTLY對應match_parent，AT_MOST對應wrap_content，那這樣wrap_content不就跟match_parent一樣的效果么？是的，調(diào)用這個方法在測量的時候，wrap_content確實跟match_parent一樣的效果，這樣做有可能是Android還沒適配wrap_content而做的簡單處理，就像Recyclerview早期的版本就沒有適配wrap_content，導致wrap_content和match_parent一樣的效果，直到23.2.0版本才將match_parent和wrap_content區(qū)分開來。那適配了wrap_content的測量方法在哪里呢？下文會講到。
case MeasureSpec.AT_MOST:
case MeasureSpec.EXACTLY:
result = specSize;
break;
}
return result;
}
通過代碼可以看到，父ViewGroup通過measureSpec對View尺寸的限制作用已經(jīng)體現(xiàn)出來了。最終通過該方法可以得到View在符合ViewGroup的限制條件下的默認尺寸，即
getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec)：獲得該View在符合ViewGroup的限制條件下的默認寬度值
getDefaultSize(getSuggestedMinimumHeight(), widthMeasureSpec)：獲得該View在符合ViewGroup的限制條件下的默認高度值
從注釋可以看出，getDefaultSize()這個測量方法并沒有適配wrap_content這一種布局模式，只是簡單地將wrap_content跟match_parent等同起來。
到了這里，我們要注意一個問題，getDefaultSize()方法中wrap_content和match_parent屬性的效果是一樣的，而該方法是View的onMeasure()中默認調(diào)用的，也就是說，對于一個直接繼承自View的自定義View來說，它的wrap_content和match_parent屬性是一樣的效果，因此如果要實現(xiàn)自定義View的wrap_content，則要重寫onMeasure()方法，對wrap_content屬性進行處理。如何處理呢？也很簡單，代碼如下所示：
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec){
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
//取得父ViewGroup指定的寬高測量模式和尺寸
int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);
int widthSpecSize = MeasureSpec.getSize(widthMeasureSpec);
int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);
int heightSpecSize = MeasureSpec.getSize(heightMeasureSpec);
if (widthSpecMode == MeasureSpec.AT_MOST && heightSpecMode == MeasureSpec.AT_MOST) {
//如果寬高都是AT_MOST的話，即都是wrap_content布局模式，就用View自己想要的寬高值
setMeasuredDimension(mWidth, mHeight);
}else if (widthSpecMode == MeasureSpec.AT_MOST) {
//如果只有寬度都是AT_MOST的話，即只有寬度是wrap_content布局模式，寬度就用View自己想要的寬度值，高度就用父ViewGroup指定的高度值
setMeasuredDimension(mWidth, heightSpecSize);
}else if (heightSpecMode == MeasureSpec.AT_MOST) {
//如果只有高度都是AT_MOST的話，即只有高度是wrap_content布局模式，高度就用View自己想要的寬度值，寬度就用父ViewGroup指定的高度值
setMeasuredDimension(widthSpecSize, mHeight);
}
}
在上面的代碼中，我們要給View指定一個默認的內(nèi)部寬/高（mWidth和mHeight），并在wrap_content時設置此寬/高即可。
setMeasuredDimension()
現(xiàn)在再來看下setMeasuredDimension()這個方法，該方法將通過getDefaultSize()得到的寬高值作為參數(shù)傳進去，看下源碼都干了些什么：
protected final void setMeasuredDimension(int measuredWidth, int measuredHeight) {
boolean optical = isLayoutModeOptical(this);
if (optical != isLayoutModeOptical(mParent)) {
Insets insets = getOpticalInsets();
int opticalWidth = insets.left + insets.right;
int opticalHeight = insets.top + insets.bottom;
measuredWidth += optical ? opticalWidth : -opticalWidth;
measuredHeight += optical ? opticalHeight : -opticalHeight;
}
setMeasuredDimensionRaw(measuredWidth, measuredHeight);
}
該方法會在開始判斷l(xiāng)ayoutMode是不是LAYOUT_MODE_OPTICAL_BOUNDS的特殊情況，這種特例很少見，我們直接忽略掉。
setMeasuredDimension()方法最后將寬高值傳遞給方法setMeasuredDimensionRaw()，我們再研究一下setMeasuredDimensionRaw()這方法。
setMeasuredDimensionRaw()
該方法接受兩個參數(shù)，也就是測量完的寬度和高度，看源碼：
private void setMeasuredDimensionRaw(int measuredWidth, int measuredHeight) {
mMeasuredWidth = measuredWidth;
mMeasuredHeight = measuredHeight;
mPrivateFlags |= PFLAG_MEASURED_DIMENSION_SET;
}
看到了吧，這里就是把測量完的寬高值賦值給mMeasuredWidth、mMeasuredHeight這兩個View的屬性，然后將標志位置為已測量狀態(tài)。
View寬高尺寸值的state
至此，由父ViewGroup發(fā)起的向它內(nèi)部的每個子View發(fā)送measure命令，然后各個View根據(jù)ViewGroup給的限制條件測量出來的寬高尺寸已經(jīng)存到View的mMeasuredWidth、mMeasuredHeight這兩個屬性當中。但ViewGroup怎么知道他的子View是多大呢？View提供了以下三組方法：
-
getMeasuredWidth()和getMeasuredHeight() -
getMeasuredWidthAndState()和getMeasuredHeightAndState() getMeasuredState()
通過方法名稱可以猜出寬高的尺寸有state這個概念，我們再來研究View中保存測量結(jié)果的屬性mMeasuredWidth和mMeasuredHeight，其實只要討論mMeasuredWidth就可以了，mMeasuredHeight一樣的道理。
mMeasuredWidth是一個Int類型的值，其是由4個字節(jié)組成的。
Android為讓其View的父控件獲取更多的信息，就在mMeasuredWidth上下了很大功夫，雖然是一個Int值，但是想讓它存儲更多信息，具體來說就是把mMeasuredWidth分成兩部分：
- 其高位的第一個字節(jié)為第一部分，用于標記測量完的尺寸是不是達到了View想要的寬度，我們稱該信息為測量的state信息。
- 其低位的三個字節(jié)為第二部分，用于存儲測量到的寬度。
一個變量能包含兩個信息，這個有點類似于measureSpec，但是二者又有不同：
-
measureSpec是將限制條件從ViewGroup傳遞給其子View。 -
mMeasuredWidth、mMeasuredHeight是將帶有測量結(jié)果的state標志位信息從View傳遞給其父ViewGroup。
那是在哪里有對mMeasuredWidth的第一個字節(jié)進行處理呢？可以看到我們下面看一下View中的resolveSizeAndState()方法。
resolveSizeAndState()
這是View一個很重要的測量方法，直接看源碼：
public static int resolveSizeAndState(int size, int measureSpec, int childMeasuredState) {
final int specMode = MeasureSpec.getMode(measureSpec);
final int specSize = MeasureSpec.getSize(measureSpec);
final int result;
switch (specMode) {
case MeasureSpec.AT_MOST:
//當specMode為AT_MOST時，這時候specSize是父ViewGroup給該View指定的最大尺寸
if (specSize < size) {
//如果父ViewGroup指定的最大尺寸比View想要的尺寸還要小，這時候會使用MEASURED_STATE_TOO_SMALL這個掩碼向已經(jīng)測量出來的尺寸specSize加入尺寸太小的標志，然后將這個帶有標志的specSize返回
result = specSize | MEASURED_STATE_TOO_SMALL;
} else {
//如果父控件指定最大尺寸沒有比View想要的尺寸小，這時候就放棄之前已經(jīng)給View賦值的specSize，用View自己想要的尺寸就可以了。
result = size;
}
break;
case MeasureSpec.EXACTLY:
result = specSize;
break;
case MeasureSpec.UNSPECIFIED:
default:
result = size;
}
return result | (childMeasuredState & MEASURED_STATE_MASK);
}
這個方法的代碼結(jié)構(gòu)跟前文提到的getDefaultSize()方法很相似，主要的區(qū)別在于specMode為AT_MOST的情況。我們當時說getDefaultSize()方法是沒有適配wrap_content這種情況，而這個resolveSizeAndState()方法是已經(jīng)適配了wrap_content的布局方式，那具體怎么實現(xiàn)AT_MOST測量邏輯的呢？有兩種情況：
- 當父ViewGroup指定的最大尺寸比View想要的尺寸還要小時，會給這個父ViewGroup的指定的最大值
specSize加入一個尺寸太小的標志MEASURED_STATE_TOO_SMALL，然后將這個帶有標志的尺寸返回，父ViewGroup通過該標志就可以知道分配給View的空間太小了，在窗口協(xié)商測量的時候會根據(jù)這個標志位來做窗口大小的決策。 - 當父ViewGroup指定的最大尺寸比沒有比View想要的尺寸小時（相等或者View想要的尺寸更?。苯尤iew想要的尺寸，然后返回該尺寸。
getDefaultSize()方法只是onMeasure()方法中獲取最終尺寸的默認實現(xiàn)，其返回的信息比resolveSizeAndState()要少，那么什么時候才會調(diào)用resolveSizeAndState()方法呢？ 主要有兩種情況：
- Android中的大部分layout類都調(diào)用了
resolveSizeAndState()方法，比如LinearLayout在測量過程中會調(diào)用resolveSizeAndState()方法而非getDefaultSize()方法。 - 我們自己在實現(xiàn)自定義的View或ViewGroup時，我們可以重寫
onMeasure()方法，并在該方法內(nèi)調(diào)用resolveSizeAndState()方法。
getMeasureXXX系列方法
現(xiàn)在回過頭來看下以下三組方法：
-
getMeasuredWidth()和getMeasuredHeight()該組方法只返回測量結(jié)果的尺寸信息，去除掉高位字節(jié)的state信息，以
getMeasuredWidth()為例，源碼如下：public final int getMeasuredWidth() { // MEASURED_SIZE_MASK = 0x00ffffff,mMeasuredWidth與MEASURED_SIZE_MASK作與運算， // 就能將mMeasuredWidth的最高字節(jié)全部置0，從而去掉state信息 return mMeasuredWidth & MEASURED_SIZE_MASK; } -
getMeasuredWidthAndState()和getMeasuredHeightAndState()該組方法返回測量結(jié)果同時包含尺寸和state信息，以
getMeasuredWidthAndState()為例，源碼如下：public final int getMeasuredWidthAndState() { //由于mMeasuredWidth完整包含了尺寸和state信息，直接返回該信息 return mMeasuredWidth; }?
-
getMeasuredState()該方法返回一個int值，該值同時包含寬度的state以及高度的state信息，不包含任何的尺寸信息，源碼如下：
public final int getMeasuredState() { //將寬度state信息保存到int值的第一個字節(jié)中 //將高度state信息保存到int值的第三個字節(jié)中 return (mMeasuredWidth&MEASURED_STATE_MASK) | ((mMeasuredHeight>>MEASURED_HEIGHT_STATE_SHIFT) & (MEASURED_STATE_MASK>>MEASURED_HEIGHT_STATE_SHIFT)); }- MEASURED_STATE_MASK的值為0xff000000，其高字節(jié)的8位全部為1，低字節(jié)的24位全部為0。
- MEASURED_HEIGHT_STATE_SHIFT值為16。
- 將MEASURED_STATE_MASK與
mMeasuredWidth做與操作之后就取出了存儲在寬度首字節(jié)中的state信息，過濾掉低位三個字節(jié)的尺寸信息。 - 由于int有四個字節(jié)，首字節(jié)已經(jīng)存了寬度的state信息，那么高度的state信息就不能存在首位字節(jié)。MEASURED_STATE_MASK向右移16位，變成了0x0000ff00，這個值與高度值
mMeasuredHeight做與操作就取出了mMeasuredHeight第三個字節(jié)中的信息。而mMeasuredHeight的state信息是存在首字節(jié)中，所以也得對mMeasuredHeight向右移相同的位置，這樣就把state信息移到了第三個字節(jié)中。 - 最后，將得到的寬度state與高度state按位或操作，這樣就拼接成一個int值，該值首個字節(jié)存儲寬度的state信息，第三個字節(jié)存儲高度的state信息。
ViewGroup的measure過程
通過上面的介紹已經(jīng)知道了單個View的測量過程，現(xiàn)在看下ViewGroup是怎樣測量的。
對于ViewGroup來說，除了完成自己的measure過程，還會遍歷去調(diào)用所有子元素的measure()方法，各個子元素再遞歸去執(zhí)行這個過程。和View不同的是，ViewGroup是一個抽象類，它提供了一個叫measureChildren()的方法用于測量子元素，源碼如下：
protected void measureChildren(int widthMeasureSpec, int heightMeasureSpec) {
final int size = mChildrenCount;
final View[] children = mChildren;
for (int i = 0; i < size; ++i) {
final View child = children[i];
//遍歷每個子元素，如果該子元素不是GONE的話，就去測量該子元素
if ((child.mViewFlags & VISIBILITY_MASK) != GONE) {
measureChild(child, widthMeasureSpec, heightMeasureSpec);
}
}
}
從上述代碼來看，ViewGroup在measure時，會調(diào)用measureChild()這個方法對每一個子元素進行測量，該方法源碼如下：
protected void measureChild(View child, int parentWidthMeasureSpec,
int parentHeightMeasureSpec) {
//獲取child自身的LayoutParams屬性
final LayoutParams lp = child.getLayoutParams();
//根據(jù)父布局的MeasureSpec，父布局的padding和child的LayoutParams這三個參數(shù)，通過getChildMeasureSpec()方法計算出子元素的MeasureSpec
final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
mPaddingLeft + mPaddingRight, lp.width);
final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
mPaddingTop + mPaddingBottom, lp.height);
//調(diào)用measure()方法測量child，前文已經(jīng)解釋過這個方法，調(diào)用該方法之后會將view的寬高值保存在mMeasuredWidth和mMeasuredHeight這兩個屬性當中，這樣child的尺寸就已經(jīng)測量出來了
child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}
很顯然，measureChild()的思想就是取出子元素的LayoutParams，然后再通過getChildMeasureSpec()方法來創(chuàng)建子元素的MeasureSpec，接著將MeasureSpec傳給View的measure()方法來完成對子元素的測量。重點看下getChildMeasureSpec()這個方法。
getChildMeasureSpec()
該方法是根據(jù)父容器的MeasureSpec、padding和子元素的LayoutParams屬性得到子元素的MeasureSpec，進而根據(jù)這個MeasureSpec來測量子元素。源碼如下：
public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
//取得SpecMode和SpecSize
int specMode = MeasureSpec.getMode(spec);
int specSize = MeasureSpec.getSize(spec);
//子元素的可用大小為父容器的尺寸減去padding
int size = Math.max(0, specSize - padding);
int resultSize = 0;
int resultMode = 0;
switch (specMode) {
//父容器是EXACTLY模式，表明父容器本身的尺寸已經(jīng)是確定的了
case MeasureSpec.EXACTLY:
//childDimension是子元素的屬性值，如果大于等于0，就說明該子元素是指定寬/高尺寸的（比如20dp），
//因為MATCH_PARENT的值為-1，WRAP_CONTENT的值為-2，都是小于0的，所以大于等于0肯定是指定固定尺寸的。
//既然子元素都指定固定大小了，就直接取指定的尺寸，
//然后將子元素的測量模式定為EXACTLY模式，表明子元素的尺寸也確定了
if (childDimension >= 0) {
resultSize = childDimension;
resultMode = MeasureSpec.EXACTLY;
} else if (childDimension == LayoutParams.MATCH_PARENT) {
// 如果子元素是MATCH_PARENT，也就是希望占滿父容器的空間，那子元素的尺寸就取父容器的可用空間大小，模式也是EXACTLY，表明子元素的尺寸也確定了
resultSize = size;
resultMode = MeasureSpec.EXACTLY;
} else if (childDimension == LayoutParams.WRAP_CONTENT) {
// 如果子元素是WRAP_CONTENT，也就是寬/高希望能包裹自身的內(nèi)容就可以了，
//但由于這時子元素自身還沒測量，無法知道自己想要多大的尺寸，
//所以這時就先取父容器給子元素留下的最大空間，模式為AT_MOST，表示子元素的寬/高不能超過該最大值
resultSize = size;
resultMode = MeasureSpec.AT_MOST;
}
break;
// 父容器的尺寸還沒確定，但是不能超過最大值
case MeasureSpec.AT_MOST:
if (childDimension >= 0) {
// 子元素指定了大小，就取子元素的尺寸，模式為EXACTLY，表明該子元素確定了尺寸
// 這時父容器的限制對子元素來說是不起作用的，子元素的尺寸是可以超出了父容器的大小，超出的部分是顯示不出來的
resultSize = childDimension;
resultMode = MeasureSpec.EXACTLY;
} else if (childDimension == LayoutParams.MATCH_PARENT) {
// 子元素是MATCH_PARENT，表明子元素希望占滿父容器，
//但是父容器自身的大小還沒確定，也無法給子元素確切的尺寸，
//這時就先取父容器給子元素留下的最大空間，模式為AT_MOST，表示子元素不能超過該最大值
resultSize = size;
resultMode = MeasureSpec.AT_MOST;
} else if (childDimension == LayoutParams.WRAP_CONTENT) {
// 子元素的尺寸只希望能包裹自身的內(nèi)容就可以了，這時子元素還沒測量，無法知道具體尺寸，
// 就先取父容器給子元素留下的最大空間，模式為AT_MOST，表示子元素不能超過該最大值
resultSize = size;
resultMode = MeasureSpec.AT_MOST;
}
break;
// 父容器沒有對子元素的大小進行約束
case MeasureSpec.UNSPECIFIED:
if (childDimension >= 0) {
// 子元素指定了大小，就取子元素的尺寸，模式為EXACTLY，表明該子元素確定了尺寸
resultSize = childDimension;
resultMode = MeasureSpec.EXACTLY;
} else if (childDimension == LayoutParams.MATCH_PARENT) {
// 子元素想要占滿父容器，先判斷下子元素是否需要取0，
// 如果不需要取0，就先取父容器給子元素留下的最大空間，模式為UNSPECIFIED，表示子元素并沒有受到約束
resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
resultMode = MeasureSpec.UNSPECIFIED;
} else if (childDimension == LayoutParams.WRAP_CONTENT) {
// 子元素的尺寸只希望能包裹自身的內(nèi)容就可以了，判斷下需不需要取0，
// 如果不需要就先取父容器給子元素留下的最大空間，模式為UNSPECIFIED，表示子元素并沒有受到約束
resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
resultMode = MeasureSpec.UNSPECIFIED;
}
break;
}
//根據(jù)得到的大小和模式返回一個MeasureSpec
return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
}
getChildMeasureSpec()這個方法清楚展示了普通View的MeasureSpec的創(chuàng)建規(guī)則，每個View的MeasureSpec狀態(tài)量由其直接父View的MeasureSpec和View自身的屬性LayoutParams（LayoutParams有寬高尺寸值等信息）共同決定?？偨Y(jié)為下表:
| View的布局屬性\父ViewGroup的MeasurSpec | EXACTLY | AT_MOST | UNSPECIFIED |
|---|---|---|---|
| 非負具體值 | EXACTLY childSize | EXACTLY childSize | EXACTLY childSize |
| match_parent | EXACTLY parentSize | AT_MOST parentSize | UNSPECIFIED 0/parentSize |
| wrap_content | AT_MOST parentSize | AT_MOST parentSize | UNSPECIFIED 0/parentSize |
在得到View的MeasureSpec狀態(tài)后，將其與尺寸值通過makeMeasureSpec(int size,int mode)方法結(jié)合在一起，就是最終傳給View的onMeasure(int, int)方法的MeasureSpec值了。
查看源碼發(fā)現(xiàn)，ViewGroup并沒有定義其測量的具體過程方法，這是因為ViewGroup是一個抽象類，其測量過程的onMeasure()方法需要各個子類去實現(xiàn)，比如LinearLayout、RelativeLayout、ListView等。為什么ViewGroup不像View一樣對其onMeasure()方法做統(tǒng)一的實現(xiàn)呢？那是因為不同的ViewGroup子類有不同的布局特性，這導致它們的測量細節(jié)各不相同，因此ViewGroup無法做統(tǒng)一的實現(xiàn)。
需要注意的是，雖然View實現(xiàn)了onMeasure()方法，但也只是一種默認實現(xiàn)，前面也提到過View的這種默認實現(xiàn)是不區(qū)分wrap_content和match_parent的，而View的子類如果需要支持區(qū)分實現(xiàn)這兩種布局方式，就需要根據(jù)自身的特性自定義實現(xiàn)onMeasure()方法，比如TextView、ImageView等就都實現(xiàn)了onMeasure()方法，而且實現(xiàn)的方式各不相同，有興趣的同學可以去看下源碼，這里就不細講了。
DecorView和ViewRootImpl
本來關(guān)于View的measure過程到這里已經(jīng)介紹得七七八八了，但是為了更好的理解整個View樹結(jié)構(gòu)的測量過程，這里就先簡單提下DecorView和ViewRootImpl這兩個家伙。
我們知道，Android界面上的View其實是一個View樹結(jié)構(gòu)，而DecorView就是View樹的頂端，是視圖的頂級View，一般情況下它內(nèi)部會包含一個豎直方向的LinearLayout，在這個LinearLayout里面有上下兩個部分（具體情況和Android版本以及主題有關(guān)），上面是標題欄，下面是內(nèi)容欄。我們在創(chuàng)建Activity時通過setContentView()添加的布局文件其實就是被加到內(nèi)容欄之中，而內(nèi)容欄是一個id為content的FrameLayout，所以可以理解Activity指定布局的方法不叫setView()而叫setContentView()了吧。
每一個Activity組件都有一個關(guān)聯(lián)的Window對象，用來描述一個應用程序窗口。每一個應用程序窗口內(nèi)部又包含有一個View對象，用來描述應用程序窗口的視圖。在Activity創(chuàng)建完畢后，DecorView會被添加到Window中，之后我們才能在屏幕上看到應用程序的視圖效果。
而ViewRootImpl是連接WindowManager和DecorView的紐帶，控件的測量、布局、繪制以及輸入事件的分發(fā)處理都由ViewRootImpl觸發(fā)。它是WindowManagerGlobal工作的實際實現(xiàn)者，因此它還需要負責與WMS交互通信以調(diào)整窗口的位置大小，以及對來自WMS的事件（如窗口尺寸改變等）作出相應的處理。它調(diào)用了一個performTraversals()方法使得View樹開始三大工作流程，然后使得View展現(xiàn)在我們面前。關(guān)鍵源碼如下：
private void performTraversals() {
...
if (!mStopped || mReportNextDraw) {
int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width); // 1
int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);
performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
...
}
}
if (didLayout) {
performLayout(lp, desiredWindowWidth, desiredWindowHeight);
...
}
if (!cancelDraw && !newSurface) {
if (mPendingTransitions != null && mPendingTransitions.size() > 0) {
for (int i = 0; i < mPendingTransitions.size(); ++i) {
mPendingTransitions.get(i).startChangingAnimations();
}
mPendingTransitions.clear();
}
performDraw();
}
...
}
我們看到它里面執(zhí)行了三個方法，分別是performMeasure()、performLayout()、performDraw()這三個方法，這三個方法分別完成DecorView的measure、layout、和draw這三大流程，其中performMeasure()中會調(diào)用measure()方法，在measure()方法中又會調(diào)用onMeasure()方法，在onMeasure()方法中會對所有子元素進行measure過程，這個時候measure流程就從父容器傳遞到子元素中了，這樣就完成了一次measure過程。接著子元素會重復父容器的measure過程，如此反復就實現(xiàn)了從DecorView開始對整個View樹的遍歷測量，measure過程就這樣完成了。同理，performLayout()和performDraw()也是類似的傳遞流程。針對performTraveals()的大致流程，可以用以下流程圖來表示。
在performTraversals()方法中，其實對于View樹的測量、布局、繪制不是簡單地依次單次執(zhí)行，以上的流程圖只是一個為了便于理解而簡化版的流程，真正的流程應該分為以下五個工作階段：
- 預測量階段：這是進入
performTraversals()方法后的第一個階段，它會對View樹進行第一次測量。在此階段中將會計算出View樹為顯示其內(nèi)容所需的尺寸，即期望的窗口尺寸。（調(diào)用measureHierarchy()） - 布局窗口階段：根據(jù)預測量的結(jié)果，通過
IWindowSession.relayout()方法向WMS請求調(diào)整窗口的尺寸等屬性，這將引發(fā)WMS對窗口進行重新布局，并將布局結(jié)果返回給ViewRootImpl。（調(diào)用relayoutWindow()） - 最終測量階段：預測量的結(jié)果是View樹所期望的窗口尺寸。然而由于在WMS中影響窗口布局的因素很多，WMS不一定會將窗口準確地布局為View樹所要求的尺寸，而迫于WMS作為系統(tǒng)服務的強勢地位，View樹不得不接受WMS的布局結(jié)果。因此在這一階段，
performTraversals()將以窗口的實際尺寸對View樹進行最終測量。（調(diào)用performMeasure()） - 布局View樹階段：完成最終測量之后便可以對View樹進行布局了。（調(diào)用
performLayout()） - 繪制階段：這是performTraversals()的最終階段。確定了控件的位置與尺寸后，便可以對View樹進行繪制了。（調(diào)用
performDraw()）
也就是說，實際上多了預測量階段和布局窗口階段，這里面還有很多可以講的，但本文主要是介紹View的measure過程，相關(guān)性不大的盡量少涉及，以免太過混亂。
預測量階段和最終測量階段都會至少完整測量一次View樹，這兩個階段的區(qū)別也只是參數(shù)不同而已。預測量階段用到了一個measureHierarchy()方法，該方法傳入的參數(shù)desiredWindowWidth與desiredWindowHeight是期望的窗口尺寸。View樹本可以按照這兩個參數(shù)完成測量，但是measureHierarchy()有自己的考量，即如何將窗口布局地盡可能地優(yōu)雅。
這是針對將LayoutParams.width設置為了WRAP_CONTENT的懸浮窗口而言。如前文所述，在設置為WRAP_CONTENT時，指定的desiredWindowWidth是應用可用的最大寬度，如此可能會產(chǎn)生下面左圖所示的丑陋布局。這種情況較容易發(fā)生在AlertDialog中，當AlertDialog需要顯示一條比較長的消息時，由于給予的寬度足夠大，因此它有可能將這條消息以一行顯示，并使得其窗口充滿了整個屏幕寬度，在橫屏模式下這種布局尤為丑陋。
倘若能夠?qū)捎脤挾冗M行適當?shù)南拗?，迫使AlertDialog將消息換行顯示，則產(chǎn)生的布局結(jié)果將會優(yōu)雅得多，如圖下面右圖所示。但是，倘若不分清紅皂白地對寬度進行限制，當控件樹真正需要足夠的橫向空間時，會導致內(nèi)容無法顯示完全，或者無法達到最佳的顯示效果。例如當一個懸浮窗口希望盡可能大地顯示一張照片時就會出現(xiàn)這樣的情況。
那么measureHierarchy()如何解決這個問呢？它采取了與View樹進行協(xié)商的辦法，即先使用measureHierarchy()所期望的寬度限制嘗試對View樹進行測量，然后通過測量結(jié)果來檢查View樹是否能夠在此限制下滿足其充分顯示內(nèi)容的要求。倘若沒能滿足，則measureHierarchy()進行讓步，放寬對寬度的限制，然后再次進行測量，再做檢查。倘若仍不能滿足則再度進行讓步。
關(guān)鍵源碼如下：
private boolean measureHierarchy(final View host, final WindowManager.LayoutParams lp,
final Resources res, final int desiredWindowWidth, final int desiredWindowHeight) {
int childWidthMeasureSpec;
int childHeightMeasureSpec;
// 表示測量結(jié)果是否可能導致窗口的尺寸發(fā)生變化
boolean windowSizeMayChange = false;
//goodMeasure表示了測量是否能滿足View樹充分顯示內(nèi)容的要求
boolean goodMeasure = false;
//測量協(xié)商僅發(fā)生在LayoutParams.width被指定為WRAP_CONTENT的情況下
if (lp.width == ViewGroup.LayoutParams.WRAP_CONTENT) {
//第一次協(xié)商。measureHierarchy()使用它最期望的寬度限制進行測量。
//這一寬度限制定義為一個系統(tǒng)資源。
//可以在frameworks/base/core/res/res/values/config.xml找到它的定義
final DisplayMetrics packageMetrics = res.getDisplayMetrics();
res.getValue(com.android.internal.R.dimen.config_prefDialogWidth, mTmpValue, true);
// 寬度限制被存放在baseSize中
int baseSize = 0;
if (mTmpValue.type == TypedValue.TYPE_DIMENSION) {
baseSize = (int)mTmpValue.getDimension(packageMetrics);
}
if (baseSize != 0 && desiredWindowWidth > baseSize) {
childWidthMeasureSpec = getRootMeasureSpec(baseSize, lp.width);
childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height);
//第一次測量。調(diào)用performMeasure()進行測量
performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
//View樹的測量結(jié)果可以通過mView的getmeasuredWidthAndState()方法獲取。
//View樹對這個測量結(jié)果不滿意，則會在返回值中添加MEASURED_STATE_TOO_SMALL位
if ((host.getMeasuredWidthAndState()&View.MEASURED_STATE_TOO_SMALL) == 0) {
goodMeasure = true; // 控件樹對測量結(jié)果滿意，測量完成
} else {
//第二次協(xié)商。上次的測量結(jié)果表明View樹認為measureHierarchy()給予的寬度太小，在此
//在此適當?shù)胤艑拰挾鹊南拗?，使用最大寬度與期望寬度的中間值作為寬度限制
baseSize = (baseSize+desiredWindowWidth)/2;
childWidthMeasureSpec = getRootMeasureSpec(baseSize, lp.width);
//第二次測量
performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
// 再次檢查控件樹是否滿足此次測量
if ((host.getMeasuredWidthAndState()&View.MEASURED_STATE_TOO_SMALL) == 0) {
// 控件樹對測量結(jié)果滿意，測量完成
goodMeasure = true;
}
}
}
}
if (!goodMeasure) {
//最終測量。當View樹對上述兩次協(xié)商的結(jié)果都不滿意時，measureHierarchy()放棄所有限制
//做最終測量。這一次將不再檢查控件樹是否滿意了，因為即便其不滿意，measurehierarchy()也沒
//有更多的空間供其使用了
childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth, lp.width);
childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height);
performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
//如果測量結(jié)果與ViewRootImpl中當前的窗口尺寸不一致，則表明隨后可能有必要進行窗口尺寸的調(diào)整
if (mWidth != host.getMeasuredWidth() || mHeight != host.getMeasuredHeight()) {
windowSizeMayChange = true;
}
}
// 返回窗口尺寸是否可能需要發(fā)生變化
return windowSizeMayChange;
}
可以看到，measureHierarchy()方法最終也是調(diào)用了performMeasure()方法對View樹進行測量，只是多了協(xié)商測量的過程。
顯然，對于非懸浮窗口，即當LayoutParams.width被設置為MATCH_PARENT時，不存在協(xié)商過程，直接使用給定的desiredWindowWidth/Height進行測量即可。而對于懸浮窗口，measureHierarchy()可以連續(xù)進行兩次讓步,從而導致View的onMeasure()方法多次被調(diào)用。
這里也看到，在View的measure過程中設置的MEASURED_STATE_TOO_SMALL標志位就在測量協(xié)商過程中起作用了。
總結(jié)
看到了這里，我們發(fā)現(xiàn)Android中View的measure過程是很巧妙的，知道如何利用以前測量過的數(shù)據(jù)，如果情況有變，那么就調(diào)用onMeasure()方法進行實際的測量工作。真正實現(xiàn)對View本身的測量就是在onMeasure()中，在該方法中View要根據(jù)父ViewGroup給其傳遞進來的widthMeasureSpec和heightMeasureSpec，并結(jié)合View自身想要的尺寸，綜合考慮，計算出最終的寬度和高度，并存儲到相應的成員變量中，這才標志著該View測量有效的完成了，如果沒有將值存入到成員變量中，View會拋出異常。而且在成員變量中還儲藏著測量的狀態(tài)信息state，該信息表示了View對此次測量的結(jié)果是否滿意。而這個state信息有可能會在ViewRootImpl在做窗口大小決策的時候提供反饋，從而達到最佳的顯示效果。
相關(guān)閱讀：
http://blog.csdn.net/iispring/article/details/49403315
http://blog.csdn.net/a553181867/article/details/51494058
