2019年百度Android面試題-公共技術點之 View 繪製流程

摘要： View 繪製機制 1. View 樹的繪圖流程 當 Activity 接收到焦點的時候，它會被請求繪製佈局,該請求由 Android framework 處理.繪製是從根節點開始，對佈局樹進行 measure 和 draw。整個 View 樹的繪圖流程在ViewRoot.java類的...

View 繪製機制

1. View 樹的繪圖流程

當 Activity 接收到焦點的時候，它會被請求繪製佈局,該請求由 Android framework 處理.繪製是從根節點開始，對佈局樹進行 measure 和 draw。整個 View 樹的繪圖流程在ViewRoot.java類的performTraversals()函式展開，該函式所做 的工作可簡單概況為是否需要重新計算檢視大小(measure)、是否需要重新安置檢視的位置(layout)、以及是否需要重繪(draw)，流程圖如下：

View 繪製流程函式呼叫鏈

需要說明的是，使用者主動呼叫 request，只會出發 measure 和 layout 過程，而不會執行 draw 過程

2. 概念

measure 和 layout

從整體上來看 Measure 和 Layout 兩個步驟的執行：

樹的遍歷是有序的，由父檢視到子檢視，每一個 ViewGroup 負責測繪它所有的子檢視，而最底層的 View 會負責測繪自身。

具體分析

measure 過程由measure(int, int)方法發起，從上到下有序的測量 View，在 measure 過程的最後，每個檢視儲存了自己的尺寸大小和測量規格。 layout 過程由layout(int, int, int, int)方法發起，也是自上而下進行遍歷。在該過程中，每個父檢視會根據 measure 過程得到的尺寸來擺放自己的子檢視。

measure 過程會為一個 View 及所有子節點的 mMeasuredWidth 和 mMeasuredHeight 變數賦值，該值可以通過getMeasuredWidth()和getMeasuredHeight()方法獲得。而且這兩個值必須在父檢視約束範圍之內，這樣才可以保證所有的父檢視都接收所有子檢視的測量。如果子檢視對於 Measure 得到的大小不滿意的時候，父檢視會介入並設定測量規則進行第二次 measure。比如，父檢視可以先根據未給定的 dimension 去測量每一個子檢視，如果最終子檢視的未約束尺寸太大或者太小的時候，父檢視就會使用一個確切的大小再次對子檢視進行 measure。

measure 過程傳遞尺寸的兩個類

1.ViewGroup.LayoutParams （View 自身的佈局引數）

2.MeasureSpecs 類（父檢視對子檢視的測量要求）

ViewGroup.LayoutParams

這個類我們很常見，就是用來指定檢視的高度和寬度等引數。對於每個檢視的 height 和 width，你有以下選擇：

1.具體值

2.MATCH_PARENT 表示子檢視希望和父檢視一樣大(不包含 padding 值)

3.WRAP_CONTENT 表示檢視為正好能包裹其內容大小(包含 padding 值)

ViewGroup 的子類有其對應的 ViewGroup.LayoutParams 的子類。比如 RelativeLayout 擁有的 ViewGroup.LayoutParams 的子類 RelativeLayoutParams。

有時我們需要使用 view.getLayoutParams() 方法獲取一個檢視 LayoutParams，然後進行強轉，但由於不知道其具體型別，可能會導致強轉錯誤。其實該方法得到的就是其所在父檢視型別的 LayoutParams，比如 View 的父控制元件為 RelativeLayout，那麼得到的 LayoutParams 型別就為 RelativeLayoutParams。

MeasureSpecs

測量規格，包含測量要求和尺寸的資訊，有三種模式:

1.UNSPECIFIED

父檢視不對子檢視有任何約束，它可以達到所期望的任意尺寸。比如 ListView、ScrollView，一般自定義 View 中用不到，

2.EXACTLY

父檢視為子檢視指定一個確切的尺寸，而且無論子檢視期望多大，它都必須在該指定大小的邊界內，對應的屬性為 match_parent 或具體值，比如 100dp，父控制元件可以通過MeasureSpec.getSize(measureSpec)直接得到子控制元件的尺寸。

3.AT_MOST

父檢視為子檢視指定一個最大尺寸。子檢視必須確保它自己所有子檢視可以適應在該尺寸範圍內，對應的屬性為 wrap_content，這種模式下，父控制元件無法確定子 View 的尺寸，只能由子控制元件自己根據需求去計算自己的尺寸，這種模式就是我們自定義檢視需要實現測量邏輯的情況。

3. measure 核心方法

measure(int widthMeasureSpec, int heightMeasureSpec)

該方法定義在View.java類中，為 final 型別，不可被複寫，但 measure 呼叫鏈最終會回撥 View/ViewGroup 物件的 onMeasure()方法，因此自定義檢視時，只需要複寫 onMeasure() 方法即可。

onMeasure(int widthMeasureSpec, int heightMeasureSpec)

該方法就是我們自定義檢視中實現測量邏輯的方法，該方法的引數是父檢視對子檢視的 width 和 height 的測量要求。在我們自身的自定義檢視中，要做的就是根據該 widthMeasureSpec 和 heightMeasureSpec 計算檢視的 width 和 height，不同的模式處理方式不同。

setMeasuredDimension()

測量階段終極方法，在 onMeasure(int widthMeasureSpec, int heightMeasureSpec) 方法中呼叫，將計算得到的尺寸，傳遞給該方法，測量階段即結束。該方法也是必須要呼叫的方法，否則會報異常。在我們在自定義檢視的時候，不需要關心繫統複雜的 Measure 過程的，只需呼叫setMeasuredDimension()設定根據 MeasureSpec 計算得到的尺寸即可，你可以參考 ViewPagerIndicator 的 onMeasure 方法。

下面我們取 ViewGroup 的 measureChildren（int widthMeasureSpec, int heightMeasureSpec) 方法對複合 View 的 Measure 流程做一個分析： MeasureChild 的方法呼叫流程圖：

原始碼分析

/**
* 請求所有子 View 去 measure 自己，要考慮的部分有對子 View 的測繪要求 MeasureSpec 以及其自身的 padding
* 這裡跳過所有為 GONE 狀態的子 View，最繁重的工作是在 getChildMeasureSpec 方法中處理的
*
* @param widthMeasureSpec對該 View 的 width 測繪要求
* @param heightMeasureSpec 對該 View 的 height 測繪要求
*/
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);
}
}
}
 
protected void measureChild(View child, int parentWidthMeasureSpec,
int parentHeightMeasureSpec) {
final LayoutParams lp = child.getLayoutParams();//獲取 Child 的 LayoutParams
 
final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,// 獲取 ChildView 的 widthMeasureSpec
mPaddingLeft + mPaddingRight, lp.width);
final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,// 獲取 ChildView 的 heightMeasureSpec
mPaddingTop + mPaddingBottom, lp.height);
 
child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}
 
/** 
* 該方法是 measureChildren 中最繁重的部分，為每一個 ChildView 計算出自己的 MeasureSpec。
* 目標是將 ChildView 的 MeasureSpec 和 LayoutParams 結合起來去得到一個最合適的結果。
*
* @param spec 對該 View 的測繪要求
* @param padding 當前 View 在當前唯獨上的 paddingand，也有可能含有 margins
*
* @param childDimension 在當前維度上（height 或 width）的具體指
* @return 子檢視的 MeasureSpec 
*/
public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
 
.........
 
// 根據獲取到的子檢視的測量要求和大小建立子檢視的 MeasureSpec
return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
}
 
/**
*
* 用於獲取 View 最終的大小，父檢視提供了寬、高的約束資訊
* 一個 View 的真正的測量工作是在 onMeasure(int, int) 中，由該方法呼叫。
* 因此，只有 onMeasure(int, int) 可以而且必須被子類複寫
*
* @param widthMeasureSpec 在水平方向上，父檢視指定的的 Measure 要求
* @param heightMeasureSpec 在豎直方向上，控制元件上父檢視指定的 Measure 要求
*
*/
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));
}

4. layout 相關概念及核心方法

首先要明確的是，子檢視的具體位置都是相對於父檢視而言的。View 的 onLayout 方法為空實現，而 ViewGroup 的 onLayout 為 abstract 的，因此，如果自定義的 View 要繼承 ViewGroup 時，必須實現 onLayout 函式。

在 layout 過程中，子檢視會呼叫getMeasuredWidth()和getMeasuredHeight()方法獲取到 measure 過程得到的 mMeasuredWidth 和 mMeasuredHeight，作為自己的 width 和 height。然後呼叫每一個子檢視的layout(l, t, r, b)函式，來確定每個子檢視在父檢視中的位置。

LinearLayout 的 onLayout 原始碼分析

@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
if (mOrientation == VERTICAL) {
layoutVertical(l, t, r, b);
} else {
layoutHorizontal(l, t, r, b);
}
}
 
/**
* 遍歷所有的子 View，為其設定相對父檢視的座標
*/
void layoutVertical(int left, int top, int right, int bottom) {
for (int i = 0; i < count; i++) {
final View child = getVirtualChildAt(i);
if (child == null) {
childTop += measureNullChild(i);
} else if (child.getVisibility() != GONE) {//不需要立即展示的 View 設定為 GONE 可加快繪製
final int childWidth = child.getMeasuredWidth();//measure 過程確定的 Width
final int childHeight = child.getMeasuredHeight();//measure 過程確定的 height
 
...確定 childLeft、childTop 的值
 
setChildFrame(child, childLeft, childTop + getLocationOffset(child),
childWidth, childHeight);
}
}
}
 
private void setChildFrame(View child, int left, int top, int width, int height) {
child.layout(left, top, left + width, top + height);
}
 
View.java
public void layout(int l, int t, int r, int b) {
...
setFrame(l, t, r, b)
}
 
/**
* 為該子 View 設定相對其父檢視上的座標
*/
protected boolean setFrame(int left, int top, int right, int bottom) {
...
}

5. 繪製流程相關概念及核心方法

先來看下與 draw 過程相關的函式：

View.draw(Canvas canvas)： 由於 ViewGroup 並沒有複寫此方法，因此，所有的檢視最終都是呼叫 View 的 draw 方法進行繪製的。在自定義的檢視中，也不應該複寫該方法，而是複寫 onDraw(Canvas) 方法進行繪製，如果自定義的檢視確實要複寫該方法，那麼請先呼叫 super.draw(canvas)完成系統的繪製，然後再進行自定義的繪製。

View.onDraw()：

View 的onDraw（Canvas）預設是空實現，自定義繪製過程需要複寫的方法，繪製自身的內容。

dispatchDraw() 發起對子檢視的繪製。View 中預設是空實現，ViewGroup 複寫了dispatchDraw()來對其子檢視進行繪製。該方法我們不用去管，自定義的 ViewGroup 不應該對dispatchDraw()進行復寫。

繪製流程圖

- View.draw(Canvas) 原始碼分析

/**
* Manually render this view (and all of its children) to the given Canvas.
* The view must have already done a full layout before this function is
* called.When implementing a view, implement
* {@link #onDraw(android.graphics.Canvas)} instead of overriding this method.
* If you do need to override this method, call the superclass version.
*
* @param canvas The Canvas to which the View is rendered.
*
* 根據給定的 Canvas 自動渲染 View（包括其所有子 View）。在呼叫該方法之前必須要完成 layout。當你自定義 view 的時候，
* 應該去是實現 onDraw(Canvas) 方法，而不是 draw(canvas) 方法。如果你確實需要複寫該方法，請記得先呼叫父類的方法。
*/
public void draw(Canvas canvas) {
 
/ * Draw traversal performs several drawing steps which must be executed
* in the appropriate order:
*
*1. Draw the background if need
*2. If necessary, save the canvas' layers to prepare for fading
*3. Draw view's content
*4. Draw children (dispatchDraw)
*5. If necessary, draw the fading edges and restore layers
*6. Draw decorations (scrollbars for instance)
*/
 
// Step 1, draw the background, if needed
if (!dirtyOpaque) {
drawBackground(canvas);
}
 
// skip step 2 & 5 if possible (common case)
final int viewFlags = mViewFlags;
if (!verticalEdges && !horizontalEdges) {
// Step 3, draw the content
if (!dirtyOpaque) onDraw(canvas);
 
// Step 4, draw the children
dispatchDraw(canvas);
 
// Step 6, draw decorations (scrollbars)
onDrawScrollBars(canvas);
 
if (mOverlay != null && !mOverlay.isEmpty()) {
mOverlay.getOverlayView().dispatchDraw(canvas);
}
 
// we're done...
return;
}
 
// Step 2, save the canvas' layers
...
 
// Step 3, draw the content
if (!dirtyOpaque) 
onDraw(canvas);
 
// Step 4, draw the children
dispatchDraw(canvas);
 
// Step 5, draw the fade effect and restore layers
 
// Step 6, draw decorations (scrollbars)
onDrawScrollBars(canvas);
}

由上面的處理過程，我們也可以得出一些優化的小技巧：當不需要繪製 Layer 的時候第二步和第五步會跳過。 因此在繪製的時候，能省的 layer 儘可省，可以提高繪製效率

ViewGroup.dispatchDraw() 原始碼分析

dispatchDraw(Canvas canvas){
 
...
 
 if ((flags & FLAG_RUN_ANIMATION) != 0 && canAnimate()) {//處理 ChildView 的動畫
final boolean buildCache = !isHardwareAccelerated();
for (int i = 0; i < childrenCount; i++) {
final View child = children[i];
if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE) {//只繪製 Visible 狀態的佈局，因此可以通過延時載入來提高效率
final LayoutParams params = child.getLayoutParams();
attachLayoutAnimationParameters(child, params, i, childrenCount);// 添加布局變化的動畫
bindLayoutAnimation(child);//為 Child 繫結動畫
if (cache) {
child.setDrawingCacheEnabled(true);
if (buildCache) {
child.buildDrawingCache(true);
}
}
}
}
 
final LayoutAnimationController controller = mLayoutAnimationController;
if (controller.willOverlap()) {
mGroupFlags |= FLAG_OPTIMIZE_INVALIDATE;
}
 
controller.start();// 啟動 View 的動畫
}
 
 // 繪製 ChildView
 for (int i = 0; i < childrenCount; i++) {
int childIndex = customOrder ? getChildDrawingOrder(childrenCount, i) : i;
final View child = (preorderedList == null)
? children[childIndex] : preorderedList.get(childIndex);
if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {
more |= drawChild(canvas, child, drawingTime);
}
}
 
...
 
}
 
protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
return child.draw(canvas, this, drawingTime);
}
 
/**
* This method is called by ViewGroup.drawChild() to have each child view draw itself.
* This draw() method is an implementation detail and is not intended to be overridden or
* to be called from anywhere else other than ViewGroup.drawChild().
*/
boolean draw(Canvas canvas, ViewGroup parent, long drawingTime) {
...
}

1.drawChild(canvas, this, drawingTime)直接呼叫了 View 的child.draw(canvas, this,drawingTime)方法，文件中也說明了，除了被ViewGroup.drawChild()方法外，你不應該在其它任何地方去複寫或呼叫該方法，它屬於 ViewGroup。而View.draw(Canvas)方法是我們自定義控制元件中可以複寫的方法，具體可以參考上述對view.draw(Canvas)的說明。從引數中可以看到，child.draw(canvas, this, drawingTime) 肯定是處理了和父檢視相關的邏輯，但 View 的最終繪製，還是 View.draw(Canvas)方法。

2.invalidate()請求重繪 View 樹，即 draw 過程，假如檢視發生大小沒有變化就不會呼叫layout()過程，並且只繪製那些呼叫了invalidate()方法的 View。

3.requestLayout()當佈局變化的時候，比如方向變化，尺寸的變化，會呼叫該方法，在自定義的檢視中，如果某些情況下希望重新測量尺寸大小，應該手動去呼叫該方法，它會觸發measure()和layout()過程，但不會進行 draw。