android視圖學習---從源碼角度來理解onMeasure過程

前面的幾篇文章寫的都非常好的，非常的了不起，介紹的非常的詳細

view的繪制：onMeasure onLayout onDraw 執行流程 【這裡其實就是RootViewImpl 裡面setView之後的一個流程】

這裡是ViewRoot的子類，也叫實現類裡面的ViewRootImpl

android怎麼把view添加到窗口的：這裡面進一步讓我們知道整個視圖的組成是有window,phoneWindow,decorview【這裡面從setContentView,到addView 其實就走到setView】

這裡是ViewRoot裡面的

surface分析：這裡面更深一步的讓我們知道了activity是怎麼獲得一塊顯存，然後把視圖畫出來的，ViewRoot在這一步如何跟系統服務交互的，也就是怎麼拿到顯存的，

ViewRoot是整個顯示系統中最為關鍵的東西，看起來這個東西好像和View有那麼點關系，其實它根本和View等UI關系不大，它不過是一個Handler罷了，唯一有關系的就是它其中有一個變量為Surface類型

正是ViewRoot是一個handle類的派生，就讓activityTread和System Service 進程服務搞起來了，

 

接下來的內容又回到view的繪制過程裡面，再一次看看onMeasure詳細的繪制流程，

 

從源碼步驟來看：

1.setView()函數裡面：

有行代碼 requestLayout(),只是執行的第一部，

2.在requestLayout()裡面：

執行了調度遍歷 scheduleTraversals();

3.在調度遍歷函數scheduleTraversals裡面：

發送了一個空的handle消息

4.在handleMessage裡面：

調用 執行遍歷函數 performTraversals();到了這一步，也就是基本到了文章1裡面說的繪制流程了，但是我們只是分析下onMeasure的詳細過程

5.在performTraversals函數裡面：這個函數太長了，

如果是初次調用：host.dispatchAttachToWindow() 這個函數的作用就是把視圖與window窗口關聯起來，

這裡面詳細有三個函數：onAttachToWindow();參數信息

listener.onViewAttachToWindow();回調

onWindowVisibilityChanged()

host.fitSystemWindow():這一步計算視圖跟window之間的padding

而且這裡面要非常的注意，執行了requestLayout（）方法，一層一層的調用父視圖

最後一步就是拿到window的寬和高

如果不是初次調用：直接拿到window的寬和高 供後面的Measure 測量用的

6.在measure裡面：

有兩個參數,寬和高，這個是父親傳遞給孩子的規格，而這個規格的測量是調用getRootMeasure(window的期望孩子的寬高，LayoutParams的寬高)

7.onMeasure()函數：

這個韓式在measure裡面調用的，只有你要求我重新繪制，或者高度和寬度變了，我才重新繪制 調用SetMeasureDimension()

8.SetMeasureDimension():這個函數非常的重要，但是裡面的代碼非常的簡單，也是我們重載需要寫的，它決定了測量之後獲得的寬高

9.getDefaultSize :返回一個默認值，這個默認值調用了 makMesaureSpec 這個函數也非常的簡單，size+mode,是二進制的加法

 

整個過程就結束了，這就是整個onMeasure的詳細過程，當然這裡面還涉及到非常的詳細知識。

 

下面的文章是參考：

 

一、Measure本質

小福：我今天分享是的measure架構設計相關的，先問一個問題，measure的本質是什麼？
小黑：這個我知道，是Android系統創建UI界面的measure、layout、draw三步驟的第一步，主要用於測量視圖大小，更詳細點說是把“相對值”（WRAP_CONTENT, FILL_PARENT, MATCH_PARENT）轉換為具體指的過程。


小福：小黑說的對，再問一個問題，視圖大小指的是什麼？
小白：視圖大小是在視圖在屏幕上顯示的大小，也就是開發的時候通過layout_width與layout_heigh設置的？
小福：小白說的只是其中一個作為開發人員的角度。Android系統設計中Canvas是無窮大的，假如一個屏幕的大小是320 * 480 ，但是layout_width="480px", layout_heigh="800px"，很明顯視圖的寬高大於實際屏幕大小。 問題來了，視圖的大小到底是屏幕上顯示的大小，還是視圖的實際大小（即使是超過了屏幕大小）？
小黑：具體視圖顯示大小是由開發人員設置，之後由我控件開發工程師在onMeasure中決定，如果向小福說的尺寸，即使超過屏幕我可以決定是width=320, heigh = 480 還是widt= 480, heigh = 800 ，決定權在我這裡，一會在我分享的時候會寫一個Demo來演示。 （視圖根據繪制大小不同分類：內容型視圖、圖形型視圖）


小白：Canvas是什麼？小福：這個在之後分享draw過程的時候在詳細討論，可以籠統的理解為畫畫時使用的畫布。
小福：Measure的本質是把視圖布局時使用的相對值轉換為具體值的過程。
 

二、Measure代碼流程

小福：先從源碼看下measure執行流程，看看這些過程中都做了些什麼。以下都是android.view.ViewRootImpl.java類中的源碼

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

public final class ViewRootImpl extends Handler implements ViewParent,

View.AttachInfo.Callbacks, HardwareRenderer.HardwareDrawCallbacks {

 

// 1 所有子視圖的requestLayout方法，最總都會觸發根視圖此方法

public void requestLayout() {

checkThread();

// 需要重新布局

mLayoutRequested = true;

 

scheduleTraversals();

}

 

// 調度遍歷

public void scheduleTraversals() {

if (!mTraversalScheduled) {

mTraversalScheduled = true;

 

.....

 

// 當前類繼承自Handler，發出一個空消息，目的是加入Message隊列

sendEmptyMessage(DO_TRAVERSAL);

}

}

 

@Override

public void handleMessage(Message msg) {

switch (msg.what) {

 

...

 

case DO_TRAVERSAL:

...

// 處理DO_TRAVERSAL消息

performTraversals();

...

break;

 

.....

}

}

 

// 執行遍歷

private void performTraversals() {

 

final View host = mView;

 

int desiredWindowWidth;

int desiredWindowHeight;

int childWidthMeasureSpec;

int childHeightMeasureSpec;

......

 

if (mLayoutRequested && !mStopped) {

......

childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth, lp.width);

childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height);

......

// host是一個View對象

host.measure(childWidthMeasureSpec, childHeightMeasureSpec);

......

}

 

......

}

}

注意：以上代碼中getRootMeasureSpec方法可以或者跟視圖中childWidthMeasureSpec與childHeightMeasureSpec，感興趣的可以自己看下desiredWindowWidth變量的賦值其獲取的是窗口的寬高。
上面的代碼一共分為5個步驟 1 requestLayout() -> 2scheduleTraversals() -> 3 handleMessage() -> 4 performTraversals() ->5 host.measure(childWidthMeasureSpec, childHeightMeasureSpec);

界面中所有視圖執行requestLayout，重新布局請求會逐步向上傳遞，最終傳執行當前ViewRootImpl的requestLaout()步驟1中會執行scheduleTraversals，其中發送一個空的消息，把重新布局的請求通過Handler發送到主線程的MeassQueue等待執行（具體可以學習Handler）。因為當前ViewRootImpl是繼承自Handler，所以直接查找覆寫的handleMessage方法，因為傳遞的消息是DO_TRAVERSAL，分支調用performTraversalsperformTraversals方法中調用host.measure(childWidthMeasureSpec,childHeightMeasureSpec); 因為host是View對象所以接下來需要查看View.measure方法，才能進一步分析measure流程

 

接著上面的measure流程的第五步走下去，以下是android.view.View.java文件中的源碼：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

public class View implements Drawable.Callback, Drawable.Callback2, KeyEvent.Callback,

AccessibilityEventSource {

 

 

// 方法是final類型，說明不能被覆寫或者重載

public final void measure(int widthMeasureSpec, int heightMeasureSpec) {

 

// 如果有重新請求標志，或者寬高發生改變

if ((mPrivateFlags & FORCE_LAYOUT) == FORCE_LAYOUT ||

widthMeasureSpec != mOldWidthMeasureSpec ||

heightMeasureSpec != mOldHeightMeasureSpec) {

 

......

 

// 真正執行測量視圖大小操作

// measure ourselves, this should set the measured dimension flag back

onMeasure(widthMeasureSpec, heightMeasureSpec);

 

......

 

// 添加重新請求子視圖布局標志

mPrivateFlags |= LAYOUT_REQUIRED;

}

 

......

}

 

/**

* Call this when something has changed which has invalidated the

* layout of this view. This will schedule a layout pass of the view

* tree.

*/

public void requestLayout() {

if (ViewDebug.TRACE_HIERARCHY) {

ViewDebug.trace(this, ViewDebug.HierarchyTraceType.REQUEST_LAYOUT);

}

 

// 添加重新請求布局標志

mPrivateFlags |= FORCE_LAYOUT;

mPrivateFlags |= INVALIDATED;

 

if (mParent != null) {

if (mLayoutParams != null) {

mLayoutParams.resolveWithDirection(getResolvedLayoutDirection());

}

if (!mParent.isLayoutRequested()) {

mParent.requestLayout();

}

}

}

 

 

}

 

上面代碼的measure流程可以分為4個步驟
1 measure與requestLayout -> 2 onMeasure

measure方法是final類型，說明此方法不能被修改。其中判斷條件(mPrivateFlags & FORCE_LAYOUT) == FORCE_LAYOUT的值是在requestLayout 進行賦值的。只要測量的寬高等發生改變都會觸發第二步。執行當前的onMeasure方法，通過Hierarchy Viewer等工具可以獲知根視圖是FrameLayout類型（這裡就不從源碼驗證了）

緊接著看下android.widget.FrameLayout類的onMeasure總都做了什麼？

 

 

三、onMeasure方法與MeasureSpec

上面顯示的代碼中參數int widthMeasureSpec, int heightMeasureSpec都是通過MeasureSpec類進行統一處理。 MeasureSpec是一個android.view.View的內部類，封裝了從父類傳送到子類的布局要求信息。每個MeasureSpec對象描述了空間的高度或寬度。 MeasureSpec由size和mode組成。
1. MeasureSpec的方法介紹：

類名.方法名

解釋

MeasureSpec.getMode(int measureSpec)

根據提供的測量值(格式)提取模式(上述三個模式之一)

MeasureSpec.getSize(int measureSpec)

根據提供的測量值(格式)提取大小值

MeasureSpec.makeMeasureSpec(int size,int mode)

根據提供的大小值和模式創建一個測量值(格式)

2. MeasureSpec有三種mode，分別說明並描述模式與layout參數值的對應關系

模式

翻譯

模式與Layout參數對應關系

模式描述

UNSPECIFIED

無限制

parent view不約束child view的大小

AT_MOST

最多的

wrap_content

child view可以在parent view范圍內取值

EXACTLY

准確的

fill_parent（例如50dip）

parent view為child view指定固定大小

3. MeasureSpec通過位運行從int類型的值中獲取mode與sieze
 

MeasureSpec：

因為MeasureSpec類很小，而且設計的很巧妙，所以我貼出了全部的源碼並進行了詳細的標注。（掌握MeasureSpec的機制後會對整個Measure方法有更深刻的理解。）

[java]viewplaincopy

1. /**

2. *MeasureSpec封裝了父布局傳遞給子布局的布局要求，每個MeasureSpec代表了一組寬度和高度的要求

3. *MeasureSpec由size和mode組成。

4. *三種Mode：

5. *1.UNSPECIFIED

6. *父不沒有對子施加任何約束，子可以是任意大小（也就是未指定）

7. *(UNSPECIFIED在源碼中的處理和EXACTLY一樣。當View的寬高值設置為0的時候或者沒有設置寬高時，模式為UNSPECIFIED

8. *2.EXACTLY

9. *父決定子的確切大小，子被限定在給定的邊界裡，忽略本身想要的大小。

10. *(當設置width或height為match_parent時，模式為EXACTLY，因為子view會占據剩余容器的空間，所以它大小是確定的)

11. *3.AT_MOST

12. *子最大可以達到的指定大小

13. *(當設置為wrap_content時，模式為AT_MOST,表示子view的大小最多是多少，這樣子view會根據這個上限來設置自己的尺寸)

14. *

15. *MeasureSpecs使用了二進制去減少對象的分配。

16. */

17. publicclassMeasureSpec{

18. //進位大小為2的30次方(int的大小為32位，所以進位30位就是要使用int的最高位和倒數第二位也就是32和31位做標志位)

19. privatestaticfinalintMODE_SHIFT=30;

20.

21. //運算遮罩，0x3為16進制，10進制為3，二進制為11。3向左進位30，就是1100000000000(11後跟30個0)

22. //(遮罩的作用是用1標注需要的值，0標注不要的值。因為1與任何數做與運算都得任何數，0與任何數做與運算都得0）

23. privatestaticfinalintMODE_MASK=0x3<

24.

25. //0向左進位30，就是0000000000000(00後跟30個0)

26. publicstaticfinalintUNSPECIFIED=0<

27. //1向左進位30，就是0100000000000(01後跟30個0)

28. publicstaticfinalintEXACTLY=1<

29. //2向左進位30，就是1000000000000(10後跟30個0)

30. publicstaticfinalintAT_MOST=2<

31.

32. /**

33. *根據提供的size和mode得到一個詳細的測量結果

34. */

35. //measureSpec=size+mode；(注意：二進制的加法，不是10進制的加法！)

36. //這裡設計的目的就是使用一個32位的二進制數，32和31位代表了mode的值，後30位代表size的值

37. //例如size=100(4)，mode=AT_MOST，則measureSpec=100+10000...00=10000..00100

38. publicstaticintmakeMeasureSpec(intsize,intmode){

39. returnsize+mode;

40. }

41.

42. /**

43. *通過詳細測量結果獲得mode

44. */

45. //mode=measureSpec&MODE_MASK;

46. //MODE_MASK=1100000000000(11後跟30個0)，原理是用MODE_MASK後30位的0替換掉measureSpec後30位中的1,再保留32和31位的mode值。

47. //例如1000..00100&1100..00(11後跟30個0)=1000..00(AT_MOST)，這樣就得到了mode的值

48. publicstaticintgetMode(intmeasureSpec){

49. return(measureSpec&MODE_MASK);

50. }

51.

52. /**

53. *通過詳細測量結果獲得size

54. */

55. //size=measureSpec&~MODE_MASK;

56. //原理同上，不過這次是將MODE_MASK取反，也就是變成了00111111(00後跟30個1)，將32,31替換成0也就是去掉mode，保留後30位的size

57. publicstaticintgetSize(intmeasureSpec){

58. return(measureSpec&~MODE_MASK);

59. }

60.

61. /**

62. *重寫的toString方法，打印mode和size的信息，這裡省略

63. */

64. publicstaticStringtoString(intmeasureSpec){

65. returnnull;

66. }

67. }

 

源碼中的onMeasure()：

知道了widthMeasureSpec和heightMeasureSpec是什麼以後，我們就可以來看onMeasure方法了：

[java]viewplaincopy

1. /**

2. *這個方法需要被重寫，應該由子類去決定測量的寬高值，

3. */

4. protectedvoidonMeasure(intwidthMeasureSpec,intheightMeasureSpec){

5. setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(),widthMeasureSpec),

6. getDefaultSize(getSuggestedMinimumHeight(),heightMeasureSpec));

7. }

在onMeasure中只調用了setMeasuredDimension()方法，接受兩個參數，這兩個參數是通過getDefaultSize方法得到的，我們到源碼裡看看getDefaultSize究竟做了什麼。

getDefaultSize():

[java]viewplaincopy

1. /**

2. *作用是返回一個默認的值，如果MeasureSpec沒有強制限制的話則使用提供的大小.否則在允許范圍內可任意指定大小

3. *第一個參數size為提供的默認大小，第二個參數為測量的大小

4. */

5. publicstaticintgetDefaultSize(intsize,intmeasureSpec){

6. intresult=size;

7. intspecMode=MeasureSpec.getMode(measureSpec);

8. intspecSize=MeasureSpec.getSize(measureSpec);

9.

10. switch(specMode){

11. //Mode=UNSPECIFIED,AT_MOST時使用提供的默認大小

12. caseMeasureSpec.UNSPECIFIED:

13. result=size;

14. break;

15. caseMeasureSpec.AT_MOST:

16. //Mode=EXACTLY時使用測量的大小

17. caseMeasureSpec.EXACTLY:

18. result=specSize;

19. break;

20. }

21. returnresult;

22. }

getDefaultSize(getSuggestedMinimumWidth(),widthMeasureSpec)，這裡就是獲取最小寬度作為默認值，然後再根據具體的測量值和選用的模式來得到widthMeasureSpec。heightMeasureSpec同理。之後將widthMeasureSpec，heightMeasureSpec傳入setMeasuredDimension()方法。

 

setMeasuredDimension()：

[java]viewplaincopy

1. /**

2. *這個方法必須由onMeasure(int,int)來調用，來存儲測量的寬，高值。

3. */

4. protectedfinalvoidsetMeasuredDimension(intmeasuredWidth,intmeasuredHeight){

5. mMeasuredWidth=measuredWidth;

6. mMeasuredHeight=measuredHeight;

7.

8. mPrivateFlags|=PFLAG_MEASURED_DIMENSION_SET;

9. }

這個方法就是我們重寫onMeasure()所要實現的最終目的。它的作用就是存儲我們測量好的寬高值。

這下思路清晰了，現在的任務就是計算出准確的measuredWidth和heightMeasureSpec並傳遞進去，我們所有的測量任務就算完成了。

源碼中使用的getDefaultSize()只是簡單的測量了寬高值，在實際使用時需要精細、具體的測量。而具體的測量任務就交給我們在子類中重寫的onMeasure方法。

measureChildren()

[java]viewplaincopy

1. /**

2. *遍歷所有的子view去測量自己（跳過GONE類型View）

3. *@paramwidthMeasureSpec父視圖的寬詳細測量值

4. *@paramheightMeasureSpec父視圖的高詳細測量值

5. */

6. protectedvoidmeasureChildren(intwidthMeasureSpec,intheightMeasureSpec){

7. finalintsize=mChildrenCount;

8. finalView[]children=mChildren;

9. for(inti=0;i

10. finalViewchild=children[i];

11. if((child.mViewFlags&VISIBILITY_MASK)!=GONE){

12. measureChild(child,widthMeasureSpec,heightMeasureSpec);

13. }

14. }

15. }

代碼很簡單，就是遍歷所有的子View，如果View的狀態不是GONE就調用measureChild去進行下一步的測量

 

measureChild()

[java]viewplaincopy

1. /**

2. *測量單個視圖，將寬高和padding加在一起後交給getChildMeasureSpec去獲得最終的測量值

3. *@paramchild需要測量的子視圖

4. *@paramparentWidthMeasureSpec父視圖的寬詳細測量值

5. *@paramparentHeightMeasureSpec父視圖的高詳細測量值

6. */

7. protectedvoidmeasureChild(Viewchild,intparentWidthMeasureSpec,

8. intparentHeightMeasureSpec){

9. //取得子視圖的布局參數

10. finalLayoutParamslp=child.getLayoutParams();

11.

12. //通過getChildMeasureSpec獲取最終的寬高詳細測量值

13. finalintchildWidthMeasureSpec=getChildMeasureSpec(parentWidthMeasureSpec,

14. mPaddingLeft+mPaddingRight,lp.width);

15. finalintchildHeightMeasureSpec=getChildMeasureSpec(parentHeightMeasureSpec,

16. mPaddingTop+mPaddingBottom,lp.height);

17.

18. //將計算好的寬高詳細測量值傳入measure方法，完成最後的測量

19. child.measure(childWidthMeasureSpec,childHeightMeasureSpec);

20. }

 

getChildMeasureSpec()

[java]viewplaincopy

1. /**

2. *在measureChildren中最難的部分：找出傳遞給child的MeasureSpec。

3. *目的是結合父view的MeasureSpec與子view的LayoutParams信息去找到最好的結果

4. *（也就是說子view的確切大小由兩方面共同決定：1.父view的MeasureSpec2.子view的LayoutParams屬性）

5. *

6. *@paramspec父view的詳細測量值(MeasureSpec)

7. *@parampaddingview當前尺寸的的內邊距和外邊距(padding,margin)

8. *@paramchildDimensionchild在當前尺寸下的布局參數寬高值(LayoutParam.width,height)

9. */

10. publicstaticintgetChildMeasureSpec(intspec,intpadding,intchildDimension){

11. //父view的模式和大小

12. intspecMode=MeasureSpec.getMode(spec);

13. intspecSize=MeasureSpec.getSize(spec);

14.

15. //通過父view計算出的子view=父大小-邊距（父要求的大小，但子view不一定用這個值）

16. intsize=Math.max(0,specSize-padding);

17.

18. //子view想要的實際大小和模式（需要計算）

19. intresultSize=0;

20. intresultMode=0;

21.

22. //通過1.父view的MeasureSpec2.子view的LayoutParams屬性這兩點來確定子view的大小

23. switch(specMode){

24. //當父view的模式為EXACITY時，父view強加給子view確切的值

25. caseMeasureSpec.EXACTLY:

26. //當子view的LayoutParams>0也就是有確切的值

27. if(childDimension>=0){

28. //子view大小為子自身所賦的值，模式大小為EXACTLY

29. resultSize=childDimension;

30. resultMode=MeasureSpec.EXACTLY;

31. //當子view的LayoutParams為MATCH_PARENT時(-1)

32. }elseif(childDimension==LayoutParams.MATCH_PARENT){

33. //子view大小為父view大小，模式為EXACTLY

34. resultSize=size;

35. resultMode=MeasureSpec.EXACTLY;

36. //當子view的LayoutParams為WRAP_CONTENT時(-2)

37. }elseif(childDimension==LayoutParams.WRAP_CONTENT){

38. //子view決定自己的大小，但最大不能超過父view，模式為AT_MOST

39. resultSize=size;

40. resultMode=MeasureSpec.AT_MOST;

41. }

42. break;

43.

44. //當父view的模式為AT_MOST時，父view強加給子view一個最大的值。

45. caseMeasureSpec.AT_MOST:

46. //道理同上

47. if(childDimension>=0){

48. resultSize=childDimension;

49. resultMode=MeasureSpec.EXACTLY;

50. }elseif(childDimension==LayoutParams.MATCH_PARENT){

51. resultSize=size;

52. resultMode=MeasureSpec.AT_MOST;

53. }elseif(childDimension==LayoutParams.WRAP_CONTENT){

54. resultSize=size;

55. resultMode=MeasureSpec.AT_MOST;

56. }

57. break;

58.

59. //當父view的模式為UNSPECIFIED時，子view為想要的值

60. caseMeasureSpec.UNSPECIFIED:

61. if(childDimension>=0){

62. //子view大小為子自身所賦的值

63. resultSize=childDimension;

64. resultMode=MeasureSpec.EXACTLY;

65. }elseif(childDimension==LayoutParams.MATCH_PARENT){

66. //因為父view為UNSPECIFIED，所以MATCH_PARENT的話子類大小為0

67. resultSize=0;

68. resultMode=MeasureSpec.UNSPECIFIED;

69. }elseif(childDimension==LayoutParams.WRAP_CONTENT){

70. //因為父view為UNSPECIFIED，所以WRAP_CONTENT的話子類大小為0

71. resultSize=0;

72. resultMode=MeasureSpec.UNSPECIFIED;

73. }

74. break;

75. }

76. returnMeasureSpec.makeMeasureSpec(resultSize,resultMode);

77. }

到這一步整個測量基本就結束了：

view.getWidth()與view.getMeasuredWidth()

getMeasuredWidth是視圖onMeasure指定的寬度（可以籠統的理解為視圖內容區域的大小，雖然不嚴謹但是系統提供的布局控件都是這樣，僅在自定義視圖中因為覆寫onMeasure可以忽略layout_width，layout_heigh隨意指定其寬高），而getWidth是視圖父視圖指定當前視圖可以在屏幕上顯示的區域。

 

/**

* Like {@link#getMeasuredWidthAndState()}, but only returns the

* raw width component (thatis the result is masked by

* {@link #MEASURED_SIZE_MASK}).

*

* @return The raw measuredwidth of this view.

*/

public final int getMeasuredWidth() {

// 直接返回mMeasuredWidth與後者相與清理掉其他開關獲取真是measure大小

returnmMeasuredWidth & MEASURED_SIZE_MASK;

}

2.如何正確獲取view的寬高呢，這個經常被面試官問了，如果你直接說view.getWidth，那肯定是錯的，返回的是0，

通過前面的許多的文章分析，這個為什麼是0的結果就非常的好說了，執行onCreate函數的時候，執行setContentView（）這個過程，這個過程涉及到很多很多過程，但是不論怎麼樣，他的返回的結果就是給你顯卡，然後讓你自己繪制，只有當顯示給你了，你才能去執行setView了，

我們在activity的生命周期中知道，視圖是什麼時候可見，什麼時候可以操作的呢，onCreate()這個生命周期裡面什麼都干不了，不可見不可操作，可以肯定的是onMeasure函數在onCreate函數執行完之後才會執行，onStart生命周期裡面是可見的，但是這個過程裡面視圖到底繪制好了嗎 其實應該是繪制好了，onResume裡面是可見可操作，有的人說在這個裡面拿不就是了，理論上沒有錯的，就需要分析下這個原因了，【先給出結論：這個時間點真的不知道在哪裡，到底什麼時候繪制好了，】

我們都知道在onCreate()裡面獲取控件的高度是0,這是為什麼呢?我們來看一下示例:

首先我們自己寫一個控件,這個控件非常簡單:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

public class MyImageView extends ImageView {

public MyImageView(Context context, AttributeSet attrs) {

super(context, attrs);

}

public MyImageView(Context context) {

super(context);

}

 

@Override

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

super.onMeasure(widthMeasureSpec, heightMeasureSpec);

System.out.println("onMeasure 我被調用了"+System.currentTimeMillis());

}

 

@Override

protected void onDraw(Canvas canvas) {

super.onDraw(canvas);

System.out.println("onDraw 我被調用了"+System.currentTimeMillis());

}

}

布局文件:

1

2

3

4

5

android:id="@+id/imageview"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:src="@drawable/test" />

測試的Activity的onCreate():

1

2

3

4

5

6

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

System.out.println("執行完畢.."+System.currentTimeMillis());

}

現在我們現在來看一下結果:

說明等onCreate方法執行完了,我們定義的控件才會被度量(measure),所以我們在onCreate方法裡面通過view.getHeight()獲取控件的高度或者寬度肯定是0,因為它自己還沒有被度量,也就是說他自己都不知道自己有多高,而你這時候去獲取它的尺寸,肯定是不行的.

有如下兩種方法可以解決這個問題:

----------------------------------
 

方法一：使用view的measure方法。

------------------------------
 

優點：可以立即獲得寬和高
 

缺點：人為的多了一次測量過程

這種方法適用於需要在onCreate完成之前就獲得一個view的寬和高的情況。

比如獲得一個LinearLayout寬和高

1

2

3

4

5

6

7

8

9

10

//寬

public int getViewWidth(LinearLayout view){

view.measure(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);

return view.getMeasuredWidth();

}

//高

public int getViewHeight(LinearLayout view){

view.measure(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);

return view.getMeasuredHeight();

}

這種方法的原理是直接調用一個view或者viewgroup的measure方法去測量，測量之後該view的getMeasuredHeight()就會返回剛才測量所得的高，getMeasuredWidth返回測量所得寬。本來在布局加載的過程中，view的measure方法一定會被系統調用，但這發生在我們所不知道的某個時間點，為了在這之前提前得到測量結果，我們主動調用measure方法，但是這樣做的好處是可以立即獲得寬和高，壞處是多了一次測量過程。

至於為什麼參數是LayoutParams.WRAP_CONTENT，那是因為我假設這個view的layout_width和layout_height為wrap_content,因為如果為一個確切的值，還有必要測量嗎？

-------------------------------------------------------------------

方法二：布局監聽類ViewTreeObserver的OnGlobalLayoutListener

-------------------------------------------------------------

當一個view的布局加載完成或者布局發生改變時OnGlobalLayoutListener可以監聽到，利用這點我們可以在布局加載完成的瞬間獲得一個view的寬高。

1

2

3

4

5

6

7

8

9

10

11

int mHeaderViewHeight;

mHeaderView.getViewTreeObserver().addOnGlobalLayoutListener(

new OnGlobalLayoutListener() {

@Override

public void onGlobalLayout() {

 

mHeaderViewHeight = mHeaderView.getHeight();

getViewTreeObserver()

.removeGlobalOnLayoutListener(this);

}

});

這種方法無法像第一種方法那樣通過一個函數返回值，因為他是基於listener的，OnGlobalLayoutListener的onGlobalLayout被回調之前是沒有值的。由於布局狀態可能會發生多次改變，因此OnGlobalLayoutListener的onGlobalLayout可能被回調多次，所以我們在第一次獲得值之後就將listener注銷掉。

優點：不需要額外的測量過程

缺點：只有在布局加載完成後，才能得到寬和高

其實在activity的onResume中可以直接調用view.getWidth獲得寬，那是不是第二種方法就失去意義了呢？

當然不是，如果我們自定義一個view，需要在view的內部獲得某個子view的寬和高，而view本身又沒有onResume這樣的生命周期方法，這時OnGlobalLayoutListener的onGlobalLayout就起作用了，可以認為onGlobalLayout就是相當於一個view的生命周期。