編輯：關於android開發
前面的幾篇文章寫的都非常好的，非常的了不起，介紹的非常的詳細
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的生命周期。
[android] 練習viewpagerindicator的使用（二），viewpagerindicator
[android] 練習viewpagerindicator的使用（二），viewpagerindicator主要還是想實現滑動的tab切換效果 MainActivit
RecyclerView，androidrecyclerview
RecyclerView，androidrecyclerview1.簡介 RecyclerView是一種新的視圖組，目標是為任何基於適配器的視圖提供相似的渲染方式。它
第 1 章 前言，前言
第 1 章 前言，前言1.什麼是3G 3G，全稱為3rd Generation，中文含義就是指第三代數字通信。 所謂3G，是指將無線通信與國際互聯網等多媒體通信結合的新一
Android Drawable的9種子類 介紹
Android Drawable的9種子類 介紹 Drawable 在android裡面 就是代表著圖像，注意是圖像 而不是圖片。 圖片是圖像的子集。圖像除了可以包含
