介紹

View的工作流程主要是指measure、layout、draw這三大流程，即測量、布局和繪制，其中measure確定View的測量寬高，layout根據測量的寬高確定View在其父View中的四個頂點的位置，而draw則將View繪制到屏幕上，這樣通過ViewGroup的遞歸遍歷，一個View樹就展現在屏幕上了。說的簡單，下面帶大家一步一步從源碼中分析：

Android的View是樹形結構的：

基本概念

在介紹View的三大流程之前，我們必須先介紹一些基本的概念，才能更好地理解這整個過程。

Window的概念

Window表示的是一個窗口的概念，它是站在WindowManagerService角度上的一個抽象的概念，Android中所有的視圖都是通過Window來呈現的，不管是Activity、Dialog還是Toast，只要有View的地方就一定有Window。

這里需要注意的是，這個抽象的Window概念和PhoneWindow這個類并不是同一個東西，PhoneWindow表示的是手機屏幕的抽象，它充當Activity和DecorView之間的媒介，就算沒有PhoneWindow也是可以展示View的。

拋開一切，僅站在WindowManagerService的角度上，Android的界面就是由一個個Window層疊展現的，而Window又是一個抽象的概念，它并不是實際存在的，它是以View的形式存在，這個View就是DecorView。

關于Window這方面的內容，我們這里先了解一個大概

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對象中。

WindowManagerGlobal.java 
 
root = new ViewRootImpl(view.getContext(), display);   
root.setView(view, wparams, panelParentView);  

Java

View的繪制流程是從ViewRoot的performTraversals方法開始的，它經過measure、layout和draw三個過程才能最終將一個View繪制出來，大致流程如下圖：

Measure測量

為了更好地理解View的測量過程，我們還需要理解MeasureSpec，它是View的一個內部類，它表示對View的測量規格。MeasureSpec代表一個32位int值，高2位代表SpecMode(測量模式)，低30位代表SpecSize(測量大小)，我們可以看看它的具體實現： 

MeasureSpec.java 
 
public static class MeasureSpec {   
        private static final int MODE_SHIFT = 30; 
        private static final int MODE_MASK  = 0x3 << MODE_SHIFT; 
 
        /** 
          * UNSPECIFIED 模式： 
          * 父View不對子View有任何限制，子View需要多大就多大 
          */  
        public static final int UNSPECIFIED = 0 << MODE_SHIFT; 
 
        /** 
          * EXACTYLY 模式： 
          * 父View已經測量出子Viwe所需要的精確大小，這時候View的最終大小 
          * 就是SpecSize所指定的值。對應于match_parent和精確數值這兩種模式 
          */  
        public static final int EXACTLY     = 1 << MODE_SHIFT; 
 
        /** 
          * AT_MOST 模式： 
          * 子View的最終大小是父View指定的SpecSize值，并且子View的大小不能大于這個值， 
          * 即對應wrap_content這種模式 
          */  
        public static final int AT_MOST     = 2 << MODE_SHIFT; 
 
        //將size和mode打包成一個32位的int型數值 
        //高2位表示SpecMode，測量模式，低30位表示SpecSize，某種測量模式下的規格大小 
        public static int makeMeasureSpec(int size, int mode) { 
            if (sUseBrokenMakeMeasureSpec) { 
                return size + mode; 
            } else { 
                return (size & ~MODE_MASK) | (mode & MODE_MASK); 
            } 
        } 
 
        //將32位的MeasureSpec解包，返回SpecMode,測量模式 
        public static int getMode(int measureSpec) { 
            return (measureSpec & MODE_MASK); 
        } 
 
        //將32位的MeasureSpec解包，返回SpecSize，某種測量模式下的規格大小 
        public static int getSize(int measureSpec) { 
            return (measureSpec & ~MODE_MASK); 
        } 
        //... 
    }  

Java

MeasureSpec通過將SpecMode和SpecSize打包成一個int值來避免過多的對象內存分配，并提供了打包和解包的方法。

SpecMode有三種類型,每一類都表示特殊的含義：

UNSPECIFIED

父容器不對View有任何限制，要多大就給多大，這種情況一般用于系統內部，表示一種測量的狀態;

EXACTLY

父容器已經檢測出View所需的精確大小，這個時候View的最終打消就是SpecSize所指定的值。它對應于LayoutParams中的match_parent和具體數值這兩種模式。

AT_MOST

父容器指定了一個可用大小即SpecSize，View的大小不能大于這個值，具體是什么值要看不同View的具體實現。它對應于LayoutParams中wrap_content。

View的MeasureSpec是由父容器的MeasureSpec和自己的LayoutParams決定的，但是對于DecorView來說有點不同，因為它沒有父類。在ViewRootImpl中的measureHierarchy方法中有如下一段代碼展示了DecorView的MeasureSpec的創建過程，其中desiredWindowWidth和desireWindowHeight是屏幕的尺寸大小：

ViewGroup的measure

childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth, lp.width); 
 
childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height); 
 
performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);  

Java

再看看getRootMeasureSpec方法：

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; 
    }  

Java

通過以上代碼，DecorView的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); 
    }  

Java

上述方法會對子元素進行measure，在調用子元素的measure方法之前會先通過getChildMeasureSpec方法來得到子元素的MeasureSpec。從代碼上看，子元素的MeasureSpec的創建與父容器的MeasureSpec和本身的LayoutParams有關，此外和View的margin和父類的padding有關，現在看看getChildMeasureSpec的具體實現：

ViewGroup.java 
 
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); 
}  

Java

上述代碼根據父類的MeasureSpec和自身的LayoutParams創建子元素的MeasureSpec，具體過程同學們自行分析，最終的創建規則如下表：

ViewGroup在遍歷完子View后，需要根據子元素的測量結果來決定自己最終的測量大小，并調用setMeasuredDimension方法保存測量寬高值。

setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),heightSizeAndState); 

Java

這里調用了resolveSizeAndState來確定最終的大小，主要是保證測量的大小不能超過父容器的***剩余空間maxWidth，這里我們看看它里面的實現：

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: 
                if (specSize < size) { 
                    result = specSize | MEASURED_STATE_TOO_SMALL; 
                } else { 
                    result = size; 
                } 
                break; 
            case MeasureSpec.EXACTLY: 
                result = specSize; 
                break; 
            case MeasureSpec.UNSPECIFIED: 
            default: 
                result = size; 
        } 
        return result | (childMeasuredState & MEASURED_STATE_MASK); 
    }  

Java

關于具體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.java 
 
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 
        setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec), 
                getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec)); 
    }  

Java

代碼很簡單，我們繼續看看getDefaultSize方法的實現：

View.java 
 
    public static int getDefaultSize(int size, int measureSpec) { 
        int result = size; 
        int specMode = MeasureSpec.getMode(measureSpec); 
        int specSize = MeasureSpec.getSize(measureSpec); 
 
        switch (specMode) { 
        case MeasureSpec.UNSPECIFIED: 
            result = size; 
            break; 
        case MeasureSpec.AT_MOST: 
        case MeasureSpec.EXACTLY: 
            result = specSize; 
            break; 
        } 
        return result; 
    } 

Java

從上述代碼可以得出，View的寬/高由specSize決定，直接繼承View的自定義控件需要重寫onMeasure方法并設置wrap_content時的自身大小，否則在布局中使用wrap_content就相當于使用match_parent。

上述就是View的measure大致過程，在measure完成之后，通過getMeasuredWidth/Height方法就可以獲得測量后的寬高，這個寬高一般情況下就等于View的最終寬高了，因為View的layout布局的時候就是根據measureWidth/Height來設置寬高的，除非在layout中修改了measure值。

Layout布局

Layout的作用是ViewGroup用來確定子元素的位置，當ViewGroup的位置被確定后，它在onLayout中會遍歷所有的子元素并調用其layout方法。簡單的來說就是，layout方法確定View本身的位置，而onLayout方法則會確定所有子元素的位置。

先看看View的layout方法：

public void layout(int l, int t, int r, int b) { 
        if ((mPrivateFlags3 & PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT) != 0) { 
            onMeasure(mOldWidthMeasureSpec, mOldHeightMeasureSpec); 
            mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT; 
        } 
 
        int oldL = mLeft; 
        int oldT = mTop; 
        int oldB = mBottom; 
        int oldR = mRight; 
 
        boolean changed = isLayoutModeOptical(mParent) ? 
                setOpticalFrame(l, t, r, b) : setFrame(l, t, r, b); 
 
        if (changed || (mPrivateFlags & PFLAG_LAYOUT_REQUIRED) == PFLAG_LAYOUT_REQUIRED) { 
            onLayout(changed, l, t, r, b); 
 
            if (shouldDrawRoundScrollbar()) { 
                if(mRoundScrollbarRenderer == null) { 
                    mRoundScrollbarRenderer = new RoundScrollbarRenderer(this); 
                } 
            } else { 
                mRoundScrollbarRenderer = null; 
            } 
 
            mPrivateFlags &= ~PFLAG_LAYOUT_REQUIRED; 
 
            ListenerInfo li = mListenerInfo; 
            if (li != null && li.mOnLayoutChangeListeners != null) { 
                ArrayList<OnLayoutChangeListener> listenersCopy = 
                        (ArrayList<OnLayoutChangeListener>)li.mOnLayoutChangeListeners.clone(); 
                int numListeners = listenersCopy.size(); 
                for (int i = 0; i < numListeners; ++i) { 
                    listenersCopy.get(i).onLayoutChange(this, l, t, r, b, oldL, oldT, oldR, oldB); 
                } 
            } 
        } 
 
        mPrivateFlags &= ~PFLAG_FORCE_LAYOUT; 
        mPrivateFlags3 |= PFLAG3_IS_LAID_OUT; 
    }  

因微信字數限制，請點擊原文鏈接查看完整內容

總結

到這里，View的measure、layout、draw三大流程就說完了，這里做一下總結：

• 如果是自定義ViewGroup的話，需要重寫onMeasure方法，在onMeasure方法里面遍歷測量子元素，同理onLayout方法也是一樣，***實現onDraw方法繪制自己;
• 如果自定義View的話，則需要從寫onMeasure方法，處理wrap_content的情況，不需要處理onLayout，***實現onDraw方法繪制自己;