Android探究之View的繪制流程
Android中Activity是作為應用程序的載體存在，代表著一個完整的用戶界面，提供了一個窗口來繪制各種視圖，當Activity啟動時，我們會通過setContentView方法來設置一個內容視圖，這個內容視圖就是用戶看到的界面。
PhoneWindow是Android系統中最基本的窗口系統，每個Activity會創建一個。PhoneWindow是Activity和View系統交互的接口。一個PhoneWindow對應一個DecorView跟一個ViewRootImpl，DecorView是ViewTree裏面的頂層布局，是繼承於FrameLayout，是Activity中所有View的祖先。ViewRootImpl建立DecorView和Window之間的聯系。
下面介紹一些相關的概念：
- Window
Window表示的是一個窗口，它是站在WindowManagerService角度上的一個抽象的概念，Android中所有的視圖都是通過Window來呈現的，不管是Activity、Dialog還是Toast，只要有View的地方就一定有Window。
這裏需要註意的是，這個抽象的Window概念和PhoneWindow這個類並不是同一個東西，PhoneWindow表示的是手機屏幕的抽象，它充當Activity和DecorView之間的媒介，就算沒有PhoneWindow也是可以展示View的。
拋開一切，僅站在WindowManagerService的角度上，Android的界面就是由一個個Window層疊展現的，而Window又是一個抽象的概念，它並不是實際存在的，它是以View的形式存在，這個View就是DecorView。 - DecorView
DecorView是整個Window界面的最頂層View，View的測量、布局、繪制、事件分發都是由DecorView往下遍歷這個View樹。DecorView作為頂級View，一般情況下它內部會包含一個豎直方向的LinearLayout，在這個LinearLayout裏面有上下兩個部分(具體情況和Android的版本及主題有關)，上面是標題欄，下面是內容欄。在Activity中我們通過setContentView所設置的布局文件其實就是被加載到內容欄中的，而內容欄的id是content，因此指定布局的方法叫setContent()。 ViewRoot
ViewRoot對應於ViewRootImpl類，它是連接WindowManager和DecorView的紐帶，View的三大流程均是通過ViewRoot來完成的。在ActivityThread中，當Activity對象被創建完之後，會將DecorView添加到Window中，同時會創建對應的ViewRootImpl，並將ViewRootImpl和DecorView建立關聯，並保存到WindowManagerGlobal對象中。### 繪制的流程
當一個應用啟動時，會啟動一個主Activity，Android系統會根據Activity的布局來對它進行繪制。繪制會從根視圖ViewRootImpl的performTraversals()方法開始，從上到下遍歷整個視圖樹，每個View控制負責繪制自己，而ViewGroup還需要負責通知自己的子View進行繪制操作。View的繪制流程主要是指measure、layout、draw這三大流程，即測量、布局和繪制，其中measure確定View的測量寬高，layout根據測量的寬高確定View在其父View中的四個頂點的位置，而draw則將View繪制到屏幕上。通過ViewGroup的遞歸遍歷，一個View樹就展現在屏幕上了。
performTraversals()方法在類ViewRootImpl內，其核心代碼如下：int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width); int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height); ... // 測量 performMeasure(childWidthMeasureSpec, childHeightMeasureSpec); ... // 布局 performLayout(lp, mWidth, mHeight); ... // 繪制 performDraw();- measure：根據父View傳遞的MeasureSpec進行計算大小，確定View的測量寬高。
- layout：根據measure子View所得到的布局大小和布局參數，確定子View在其父View中的四個頂點的位置。
draw：把View繪制到屏幕上。
### MeasureSpec
為了更好地理解View的測量過程，我們需要理解MeasureSpec，它是View的一個內部類，它表示對View的測量規格。
在Google官方文檔中是這麽定義MeasureSpec的：A MeasureSpec encapsulates the layout requirements passed from parent to child. Each MeasureSpec represents a requirement for either the width or the height. A MeasureSpec is comprised of a size and a mode.
MeasureSpec是一個32位二進制的整數，由SpecMode和SpecSize兩部分組成。其中，高2位為SpecMode(測量模式)，低30位為SpecSize(測量大小)。
SpecMode的取值可為以下三種：
- UNSPECIFIED：不指定測量模式，父視圖沒有限制子視圖的大小，子視圖可以是想要的任何尺寸，通常用於系統內部，應用開發中很少使用到。
- EXACTLY：精確測量模式，表示父視圖已經決定了子視圖的精確大小，這種模式下View的測量值就是SpecSize的值。對應View的LayoutParams的match_parent或者精確數值。
AT_MOST：最大值模式，父視圖已經限制子視圖的大小，此時子視圖的尺寸可以是不超過父視圖運行的最大尺寸的任何尺寸。對應View的LayoutParams的wrap_content。
### Measure
ViewGroup的measure
ViewGroup在它的measureChild方法中傳遞給子View。ViewGroup通過遍歷自身所有的子View，並逐個調用子View的measure方法實現測量操作。ViewGroup在遍歷完子View後，需要根據子元素的測量結果來決定自己最終的測量大小，並調用setMeasuredDimension方法保存測量寬高值。
// 遍歷測量 ViewGroup 中所有的 View
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];
if ((child.mViewFlags & VISIBILITY_MASK) != GONE) {
measureChild(child, widthMeasureSpec, heightMeasureSpec);
}
}
}//測量某個指定的View
protected void measureChild(View child, int parentWidthMeasureSpec,
int parentHeightMeasureSpec) {
final LayoutParams lp = child.getLayoutParams();final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec, mPaddingLeft + mPaddingRight, lp.width); final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec, mPaddingTop + mPaddingBottom, lp.height); child.measure(childWidthMeasureSpec, childHeightMeasureSpec);}
View的MeasureSpec是由父容器的MeasureSpec和自己的LayoutParams決定的，但是對於DecorView來說有點不同，因為它沒有父類。在ViewRootImpl中的measureHierarchy方法中有如下一段代碼展示了DecorView的MeasureSpec的創建過程，其中desiredWindowWidth和desireWindowHeight是屏幕的尺寸大小。
private boolean measureHierarchy(final View host, final WindowManager.LayoutParams lp,
final Resources res, final int desiredWindowWidth, final int desiredWindowHeight) {
...
childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth, lp.width);
childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height);
performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
...
}
private static int getRootMeasureSpec(int windowSize, int rootDimension) {
int measureSpec;
switch (rootDimension) {
case ViewGroup.LayoutParams.MATCH_PARENT:
// Window can‘t resize. Force root view to be windowSize.
measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.EXACTLY);
break;
case ViewGroup.LayoutParams.WRAP_CONTENT:
// Window can resize. Set max size for root view.
measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.AT_MOST);
break;
default:
// Window wants to be an exact size. Force root view to be that size.
measureSpec = MeasureSpec.makeMeasureSpec(rootDimension, MeasureSpec.EXACTLY);
break;
}
return measureSpec;
}DecorView是FrameLyaout的子類，屬於ViewGroup，對於ViewGroup來說，除了完成自己的measure過程外，還會遍歷去調用所有子元素的measure方法，各個子元素再遞歸去執行這個過程。和View不同的是，ViewGroup是一個抽象類，他沒有重寫View的onMeasure方法，這裏很好理解，因為每個具體的ViewGroup實現類的功能是不同的，如何測量應該讓它自己決定，比如LinearLayout和RelativeLayout。
因此在具體的ViewGroup中需要遍歷去測量子View，這裏我們看看ViewGroup中提供的測量子View的measureChildWithMargins方法：
protected void measureChildWithMargins(View child,
int parentWidthMeasureSpec, int widthUsed,
int parentHeightMeasureSpec, int heightUsed) {
final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();
final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin
+ widthUsed, lp.width);
final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
mPaddingTop + mPaddingBottom + lp.topMargin + lp.bottomMargin
+ heightUsed, lp.height);
child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}上述方法會對子元素進行measure，在調用子元素的measure方法之前會先通過getChildMeasureSpec方法來得到子元素的MeasureSpec。從代碼上看，子元素的MeasureSpec的創建與父容器的MeasureSpec和本身的LayoutParams有關，此外和View的margin和父類的padding有關，現在看看getChildMeasureSpec的具體實現：
public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
int specMode = MeasureSpec.getMode(spec);
int specSize = MeasureSpec.getSize(spec);
int size = Math.max(0, specSize - padding);
int resultSize = 0;
int resultMode = 0;
switch (specMode) {
// Parent has imposed an exact size on us
case MeasureSpec.EXACTLY:
if (childDimension >= 0) {
resultSize = childDimension;
resultMode = MeasureSpec.EXACTLY;
} else if (childDimension == LayoutParams.MATCH_PARENT) {
// Child wants to be our size. So be it.
resultSize = size;
resultMode = MeasureSpec.EXACTLY;
} else if (childDimension == LayoutParams.WRAP_CONTENT) {
// Child wants to determine its own size. It can‘t be
// bigger than us.
resultSize = size;
resultMode = MeasureSpec.AT_MOST;
}
break;
// Parent has imposed a maximum size on us
case MeasureSpec.AT_MOST:
if (childDimension >= 0) {
// Child wants a specific size... so be it
resultSize = childDimension;
resultMode = MeasureSpec.EXACTLY;
} else if (childDimension == LayoutParams.MATCH_PARENT) {
// Child wants to be our size, but our size is not fixed.
// Constrain child to not be bigger than us.
resultSize = size;
resultMode = MeasureSpec.AT_MOST;
} else if (childDimension == LayoutParams.WRAP_CONTENT) {
// Child wants to determine its own size. It can‘t be
// bigger than us.
resultSize = size;
resultMode = MeasureSpec.AT_MOST;
}
break;
// Parent asked to see how big we want to be
case MeasureSpec.UNSPECIFIED:
if (childDimension >= 0) {
// Child wants a specific size... let him have it
resultSize = childDimension;
resultMode = MeasureSpec.EXACTLY;
} else if (childDimension == LayoutParams.MATCH_PARENT) {
// Child wants to be our size... find out how big it should
// be
resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
resultMode = MeasureSpec.UNSPECIFIED;
} else if (childDimension == LayoutParams.WRAP_CONTENT) {
// Child wants to determine its own size.... find out how
// big it should be
resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
resultMode = MeasureSpec.UNSPECIFIED;
}
break;
}
//noinspection ResourceType
return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
}當父View的mode是EXACTLY的時候：說明父View的size是確定的。
子View的寬或高是具體數值：子view的size已經固定了，子View的size就是固定這個數值，mode=EXACTLY。
子View的寬或高是MATCH_PARENT：子View的size=父View的size，mode=EXACTLY。
子View的寬或高是WRAP_CONTENT：子View是包裹布局，說明子View的size還不確定，所以子View的size最大不能超過父View的size，mode=AT_MOST。當父View的mode是AT_MOST的時候：說明父View的size是不確定的。
子View的寬或高是具體數值：子view的size已經固定了，子View的size就是固定這個數值，mode=EXACTLY。
子View的寬或高是MATCH_PARENT：父View的size是不確定的，子View是填充布局情況，也不能確定size，所以子View的size不能超過父View的size，mode=AT_MOST。
子View的寬或高是WRAP_CONTENT：子View是包裹布局，size不能超過父View的size，mode=AT_MOST。當父View的mode是UNSPECIFIED的時候：說明父View不指定測量模式，父View沒有限制子視圖的大小，子View可以是想要的任何尺寸。
子View的寬或高是具體數值：子view的size已經固定了，子View的size就是固定這個數值，mode=EXACTLY。
子View的寬或高是MATCH_PARENT：子視圖可以是想要的任何尺寸，mode=UNSPECIFIED。
子View的寬或高是WRAP_CONTENT：子視圖可以是想要的任何尺寸，mode=UNSPECIFIED。
需要註意一點就是，此時的MeasureSpec並不是View真正的大小，只有setMeasuredDimension之後才能真正確定View的大小。
關於具體ViewGroup的onMeasure過程這裏不做分析，由於每種布局的測量方式不一樣，不可能逐個分析，但在它們的onMeasure裏面的步驟是有一定規律的：
1.根據各自的測量規則遍歷Children元素，調用getChildMeasureSpec方法得到Child的measureSpec;
2.調用Child的measure方法;
3.調用setMeasuredDimension確定最終的大小。
View的measure
View的measure過程由其measure方法來完成，measure方法是一個final類型的方法，這意味著子類不能重寫此方法，在View的measure方法裏面會去調用onMeasure方法，我們可以通過復寫onMeasure()方法去測量設置View的大小。如下：
public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
...
onMeasure(widthMeasureSpec, heightMeasureSpec);
....
}
//如果需要自定義測量，子類需重寫這個方法
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
}
//將測量好的寬跟高進行存儲
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);
}
//如果View沒有重寫onMeasure方法，默認會直接調用getDefaultSize
public static int getDefaultSize(int size, int measureSpec) {
int result = size;
//獲取父View傳遞過來的模式
int specMode = MeasureSpec.getMode(measureSpec);
//獲取父View傳遞過來的大小
int specSize = MeasureSpec.getSize(measureSpec);
switch (specMode) {
case MeasureSpec.UNSPECIFIED:
//View的大小父View未定，設置為建議最小值
result = size;
break;
case MeasureSpec.AT_MOST:
case MeasureSpec.EXACTLY:
result = specSize;
break;
}
return result;
}從上述代碼可以得出，View的寬/高由specSize決定，直接繼承View的自定義控件需要重寫onMeasure方法並設置wrap_content時的自身大小，否則在布局中使用wrap_content就相當於使用match_parent。
上述就是View的measure大致過程，在measure完成之後，通過getMeasuredWidth/Height方法就可以獲得測量後的寬高，這個寬高一般情況下就等於View的最終寬高，因為View的layout布局的時候就是根據measureWidth/Height來設置寬高的，除非在layout中修改了measure值。
### Layout
measure()方法中我們已經測量出View的大小，根據這些大小，我們接下來就要確定View在父View的布局位置。Layout的作用是ViewGroup用來確定子元素的位置，當ViewGroup的位置被確定後，它在onLayout中會遍歷所有的子元素並調用其layout方法。簡單的來說就是，layout方法確定View本身的位置，而onLayout方法則會確定所有子元素的位置。
View的layout方法代碼：
可以看到這是一個空實現，和onMeasure方法類似，onLayout的實現和具體的布局有關，具體ViewGroup的子類需要重寫onLayout方法，並根據具體布局規則遍歷調用Children的layout方法。public void layout(int l, int t, int r, int b) { ... onLayout(changed, l, t, r, b); ... } //空方法，子類如果是ViewGroup類型，則重寫這個方法，實現ViewGroup中所有View控件布局 protected void onLayout(boolean changed, int left, int top, int right, int bottom) { }
通過上面的分析，可以得到兩個結論：
View通過layout方法來確認自己在父容器中的位置。
ViewGroup通過onLayout方法來確定View在容器中的位置。FrameLayout的onLayout方法代碼：
@Override protected void onLayout(boolean changed, int left, int top, int right, int bottom) { layoutChildren(left, top, right, bottom, false); } void layoutChildren(int left, int top, int right, int bottom, boolean forceLeftGravity) { final int count = getChildCount(); final int parentLeft = getPaddingLeftWithForeground(); final int parentRight = right - left - getPaddingRightWithForeground(); final int parentTop = getPaddingTopWithForeground(); final int parentBottom = bottom - top - getPaddingBottomWithForeground(); for (int i = 0; i < count; i++) { final View child = getChildAt(i); if (child.getVisibility() != GONE) { final LayoutParams lp = (LayoutParams) child.getLayoutParams(); final int width = child.getMeasuredWidth(); final int height = child.getMeasuredHeight(); int childLeft; int childTop; int gravity = lp.gravity; if (gravity == -1) { gravity = DEFAULT_CHILD_GRAVITY; } final int layoutDirection = getLayoutDirection(); final int absoluteGravity = Gravity.getAbsoluteGravity(gravity, layoutDirection); final int verticalGravity = gravity & Gravity.VERTICAL_GRAVITY_MASK; switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) { case Gravity.CENTER_HORIZONTAL: childLeft = parentLeft + (parentRight - parentLeft - width) / 2 + lp.leftMargin - lp.rightMargin; break; case Gravity.RIGHT: if (!forceLeftGravity) { childLeft = parentRight - width - lp.rightMargin; break; } case Gravity.LEFT: default: childLeft = parentLeft + lp.leftMargin; } switch (verticalGravity) { case Gravity.TOP: childTop = parentTop + lp.topMargin; break; case Gravity.CENTER_VERTICAL: childTop = parentTop + (parentBottom - parentTop - height) / 2 + lp.topMargin - lp.bottomMargin; break; case Gravity.BOTTOM: childTop = parentBottom - height - lp.bottomMargin; break; default: childTop = parentTop + lp.topMargin; } child.layout(childLeft, childTop, childLeft + width, childTop + height); } } }
1、獲取父View的內邊距padding的值。
2、遍歷子View，處理子View的layout_gravity屬性、根據View測量後的寬和高、父View的padding值、來確定子View的布局參數。
3、調用child.layout方法，對子View進行布局。
### Draw
經過前面的測量和布局之後，接下來就是繪制了，也就是真正把View繪制在屏幕可見視圖上。Draw操作用來將控件繪制出來，繪制的流程從performDraw()方法開始。performDraw()方法在類ViewRootImpl內，其核心代碼如下：
private void performDraw() {
...
boolean canUseAsync = draw(fullRedrawNeeded);
...
}
private boolean draw(boolean fullRedrawNeeded) {
...
if (!drawSoftware(surface, mAttachInfo, xOffset, yOffset,
scalingRequired, dirty, surfaceInsets)) {
return false;
}
...
}
private boolean drawSoftware(Surface surface, AttachInfo attachInfo, int xoff, int yoff,
boolean scalingRequired, Rect dirty, Rect surfaceInsets) {
...
mView.draw(canvas);
...
}最終調用到View的draw方法繪制每個具體的View，繪制基本上可以分為七個步驟。
public void draw(Canvas canvas) {
...
// Step 1, draw the background, if needed
int saveCount;
if (!dirtyOpaque) {
drawBackground(canvas);
}
...
// Step 2, If necessary, save the canvas‘ layers to prepare for fading
saveCount = canvas.getSaveCount();
canvas.saveUnclippedLayer(left, top, right, top + length);
...
// Step 3, draw the content
if (!dirtyOpaque) onDraw(canvas);
...
// Step 4, draw the children
dispatchDraw(canvas);
...
// Step 5, If necessary, draw the fading edges and restore layers
canvas.drawRect(left, top, right, top + length, p);
...
canvas.restoreToCount(saveCount);
...
// Step 6, draw decorations (foreground, scrollbars)
onDrawForeground(canvas);
...
// Step 7, draw the default focus highlight
drawDefaultFocusHighlight(canvas);
...
}第一步：drawBackground(canvas)：作用就是繪制View的背景。
第二步：saveUnclippedLayer：保存畫布的圖層。
第三步：onDraw(canvas)：繪制View的內容。View的內容是根據自己需求自己繪制的，所以方法是一個空方法，View的繼承類自己復寫實現繪制內容。
第四步：dispatchDraw（canvas）：遍歷子View進行繪制內容。在View裏面是一個空實現，ViewGroup裏面才會有實現。View的繪制過程的傳遞通過dispatchDraw來實現的，dispatchDraw會遍歷調用所有子元素的draw方法，如此draw事件就一層層地傳遞了下去。在自定義ViewGroup一般不用復寫這個方法，因為它在裏面的實現幫我們實現了子View的繪制過程，基本滿足需求。
第五步：drawRect：繪制邊緣和恢復畫布的圖層。
第六步：onDrawForeground(canvas)：對前景色跟滾動條進行繪制。
第七步：drawDefaultFocusHighlight(canvas)：繪制默認焦點高亮。
### 總結
如果是自定義ViewGroup的話，需要重寫onMeasure方法，在onMeasure方法裏面遍歷測量子元素，同理onLayout方法也是一樣，最後實現onDraw方法繪制自己；
如果自定義View的話，則需要從寫onMeasure方法，處理wrap_content的情況，不需要處理onLayout，最後實現onDraw方法繪制自己。
Android探究之View的繪制流程