Android View框架的measure機制

概述

        Android中View框架的工做機制中，主要有三個過程：

                一、View樹的測量（measure）Android View框架的measure機制

                二、View樹的佈局（layout） Android View框架的layout機制

                三、View樹的繪製（draw）Android View框架的draw機制

        View框架的工做流程爲：測量每一個View大小（measure）-->把每一個View放置到相應的位置（layout）-->繪製每一個View（draw）。

 

         本文主要講述三大流程中的measure過程。

 

 

 

帶着問題來思考整個measure過程。

 

一、系統爲何要有measure過程？

        開發人員在繪製UI的時候，基本都是經過XML佈局文件的方式來配置UI，而每一個View必需要設置的兩個羣屬性就是layout_width和layout_height，這兩個屬性表明着當前View的尺寸。

官方文檔截圖：

        因此這兩個屬性的值是必需要指定的，這兩個屬性的取值只能爲三種類型：

                 一、固定的大小，好比100dp。

                 二、恰好包裹其中的內容，wrap_content。

                 三、想要和父佈局同樣大，match_parent / fill_parent。

        因爲Android但願提供一個更優雅的GUI框架，因此提供了自適應的尺寸，也就是 wrap_content 和 match_parent 。

        試想一下，那若是這些屬性只容許設置固定的大小，那麼每一個View的尺寸在繪製的時候就已經肯定了，因此可能都不須要measure過程。可是因爲須要知足自適應尺寸的機制，因此須要一個measure過程。

 

 

二、measure過程都幹了點什麼事？

        因爲上面提到的自適應尺寸的機制，因此在用自適應尺寸來定義View大小的時候，View的真實尺寸還不能肯定。可是View尺寸最終須要映射到屏幕上的像素大小，因此measure過程就是幹這件事，把各類尺寸值，通過計算，獲得具體的像素值。measure過程會遍歷整棵View樹，而後依次測量每一個View真實的尺寸。具體是每一個ViewGroup會向它內部的每一個子View發送measure命令，而後由具體子View的onMeasure()來測量本身的尺寸。最後測量的結果保存在View的mMeasuredWidth和mMeasuredHeight中，保存的數據單位是像素。

 

 

三、對於自適應的尺寸機制，如何合理的測量一顆View樹？

        系統在遍歷完佈局文件後，針對佈局文件，在內存中生成對應的View樹結構，這個時候，整棵View樹種的全部View對象，都尚未具體的尺寸，由於measure過程最終是要肯定每一個View打的準確尺寸，也就是準確的像素值。可是剛開始的時候，View中layout_width和layout_height兩個屬性的值，都只是自適應的尺寸，也就是match_parent和wrap_content，這兩個值在系統中爲負數，因此係統不會把它們當成具體的尺寸值。因此當一個View須要把它內部的match_parent或者wrap_content轉換成具體的像素值的時候，他須要知道兩個信息。

        一、針對於match_parent，父佈局當前具體像素值是多少，由於match_parent就是子View想要和父佈局同樣大。

        二、針對wrap_content，子View須要根據當前本身內部的content，算出一個合理的能包裹全部內容的最小值。可是若是這個最小值比當前父佈局還大，那不行，父佈局會告訴你，我只有這麼大，你也不該該超過這個尺寸。

        因爲樹這種數據結構的特殊性，咱們在研究measure的過程時，能夠只研究一個ViewGroup和2個View的簡單場景。大概示意圖以下：

        也就是說，在measure過程當中，ViewGroup會根據本身當前的情況，結合子View的尺寸數據，進行一個綜合評定，而後把相關信息告訴子View，而後子View在onMeasure本身的時候，一邊須要考慮到本身的content大小，一邊還要考慮的父佈局的限制信息，而後綜合評定，測量出一個最優的結果。

 

四、那麼ViewGroup是如何向子View傳遞限制信息的？

        談到傳遞限制信息，那就是MeasureSpec類了，該類貫穿於整個measure過程，用來傳遞父佈局對子View尺寸測量的約束信息。簡單來講，該類就保存兩類數據。

                一、子View當前所在父佈局的具體尺寸。

                二、父佈局對子View的限制類型。

        那麼限制類型又分爲三種類型：

                一、UNSPECIFIED，不限定。意思就是，子View想要多大，我就能夠給你多大，你放心大膽的measure吧，不用管其餘的。也不用管我傳遞給你的尺寸值。（其實Android高版本中推薦，只要是這個模式，尺寸設置爲0）

                二、EXACTLY，精確的。意思就是，根據我當前的情況，結合你指定的尺寸參數來考慮，你就應該是這個尺寸，具體大小在MeasureSpec的尺寸屬性中，本身去查看吧，你也不要管你的content有多大了，就用這個尺寸吧。

                三、AT_MOST，最多的。意思就是，根據我當前的狀況，結合你指定的尺寸參數來考慮，在不超過我給你限定的尺寸的前提下，你測量一個剛好能包裹你內容的尺寸就能夠了。

 

 

 

源代碼分析

        在View的源代碼中，提取到了下面一些關於measure過程的信息。

        咱們知道，整棵View樹的根節點是DecorView，它是一個FrameLayout，因此它是一個ViewGroup，因此整棵View樹的測量是從一個ViewGroup對象的measure方法開始的。

 

View：

一、measure

/** 開始測量一個View有多大，parent會在參數中提供約束信息，實際的測量工做是在onMeasure()中進行的，該方法會調用onMeasure()方法，因此只有onMeasure能被也必需要被override */
public final void measure(int widthMeasureSpec, int heightMeasureSpec);

父佈局會在本身的onMeasure方法中，調用child.measure ，這就把measure過程轉移到了子View中。

 

二、onMeasure

/** 具體測量過程，測量view和它的內容，來決定測量的寬高（mMeasuredWidth  mMeasuredHeight ）。該方法中必需要調用setMeasuredDimension(int, int)來保存該view測量的寬高。 */
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec);

子View會在該方法中，根據父佈局給出的限制信息，和本身的content大小，來合理的測量本身的尺寸。

 

三、setMeasuredDimension

 
/** 保存測量結果 */
protected final void setMeasuredDimension(int measuredWidth, int measuredHeight);

當View測量結束後，把測量結果保存起來，具體保存在mMeasuredWidth和mMeasuredHeight中。

 

ViewGroup：

一、measureChildren

/** 讓全部子view測量本身的尺寸，須要考慮當前ViewGroup的MeasureSpec和Padding。跳過狀態爲gone的子view */
protected void measureChildren(int widthMeasureSpec, int heightMeasureSpec);-->getChildMeasureSpec()-->child.measure();

測量全部的子View尺寸，把measure過程交到子View內部。

 

二、measureChild

/** 測量單個View，須要考慮當前ViewGroup的MeasureSpec和Padding。 */
protected void measureChild(View child, int parentWidthMeasureSpec, int parentHeightMeasureSpec);-->getChildMeasureSpec()-->child.measure();

對每個具體的子View進行測量。

 

三、measureChildWithMargins

 

/** 測量單個View，須要考慮當前ViewGroup的MeasureSpec和Padding、margins。 */
protected void measureChildWithMargins(View child, int parentWidthMeasureSpec, int widthUsed, int parentHeightMeasureSpec, int heightUsed);-->getChildMeasureSpec()-->child.measure();

對每個具體的子View進行測量。可是須要考慮到margin等信息。

 

四、getChildMeasureSpec

/** measureChildren過程當中最困難的一部分，爲child計算MeasureSpec。該方法爲每一個child的每一個維度（寬、高）計算正確的MeasureSpec。目標就是把當前viewgroup的MeasureSpec和child的LayoutParams結合起來，生成最合理的結果。
好比，當前ViewGroup知道本身的準確大小，由於MeasureSpec的mode爲EXACTLY，而child但願可以match_parent，這時就會爲child生成一個mode爲EXACTLY，大小爲ViewGroup大小的MeasureSpec。
 */
public static int getChildMeasureSpec(int spec, int padding, int childDimension);

根據當前自身的情況，以及特定子View的尺寸參數，爲特定子View計算一個合理的限制信息。

源代碼：

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;
        }
        return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
    }

 

 

僞代碼：

public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
        獲取限制信息中的尺寸和模式。
        switch (限制信息中的模式) {
            case 當前容器的父容器，給當前容器設置了一個精確的尺寸:
                if (子View申請固定的尺寸) {
                    你就用你本身申請的尺寸值就好了;
                } else if (子View但願和父容器同樣大) {
                    你就用父容器的尺寸值就好了;
                } else if (子View但願包裹內容) {
                    你最大尺寸值爲父容器的尺寸值，可是你仍是要儘量小的測量本身的尺寸，包裹你的內容就足夠了;
                } 
                    break;
            case 當前容器的父容器，給當前容器設置了一個最大尺寸:
                if (子View申請固定的尺寸) {
                    你就用你本身申請的尺寸值就好了;
                } else if (子View但願和父容器同樣大) {
                    你最大尺寸值爲父容器的尺寸值，可是你仍是要儘量小的測量本身的尺寸，包裹你的內容就足夠了;
                } else if (子View但願包裹內容) {
                    你最大尺寸值爲父容器的尺寸值，可是你仍是要儘量小的測量本身的尺寸，包裹你的內容就足夠了;
                } 
                    break;
            case 當前容器的父容器，對當前容器的尺寸不限制:
                if (子View申請固定的尺寸) {
                    你就用你本身申請的尺寸值就好了;
                } else if (子View但願和父容器同樣大) {
                    父容器對子View尺寸不作限制。
                } else if (子View但願包裹內容) {
                    父容器對子View尺寸不作限制。
                }
                    break;
        } return 對子View尺寸的限制信息;
    }

 

 

        當自定義View的時候，也須要處理measure過程，主要有兩種狀況。

        一、繼承自View的子類。

                須要覆寫onMeasure來正確測量本身。最後都須要調用setMeasuredDimension來保存測量結果

                通常來講，自定義View的measure過程僞代碼爲：

int mode = MeasureSpec.getMode(measureSpec);
int size = MeasureSpec.getSize(measureSpec);

int viewSize = 0;

swith (mode) {
    case MeasureSpec.EXACTLY:
        viewSize = size; //當前View尺寸設置爲父佈局尺寸
        break;
    case MeasureSpec.AT_MOST:
        viewSize = Math.min(size, getContentSize()); //當前View尺寸爲內容尺寸和父佈局尺寸當中的最小值
        break;
    case MeasureSpec.UNSPECIFIED:
        viewSize = getContentSize(); //內容有多大，就設置尺寸爲多大
        break;
    default:
        break;
}

setMeasuredDimension(viewSize);

 

 

        二、繼承自ViewGroup的子類。

                不但須要覆寫onMeasure來正確測量本身，可能還要覆寫一系列measureChild方法，來正確的測量子view，好比ScrollView。或者乾脆放棄父類實現的measureChild規則，本身從新實現一套測量子view的規則，好比RelativeLayout。最後都須要調用setMeasuredDimension來保存測量結果。

                通常來講，自定義ViewGroup的measure過程的僞代碼爲：

                

//ViewGroup開始測量本身的尺寸
viewGroup.onMeasure();
//ViewGroup爲每一個child計算測量限制信息（MeasureSpec）
viewGroup.getChildMeasureSpec();
//把上一步生成的限制信息，傳遞給每一個子View，而後子View開始measure本身的尺寸
child.measure();
//子View測量完成後，ViewGroup就能夠獲取每一個子View測量後的尺寸
child.getChildMeasuredSize();
//ViewGroup根據本身自身情況，好比Padding等，計算本身的尺寸
viewGroup.calculateSelfSize();
//ViewGroup保存本身的尺寸
viewGroupsetMeasuredDimension();

 

 

 

案例分析

        不少開發人員都遇到過這種需求，就是ScrollView內部嵌套ListView，而該ListView數據條數是不肯定的，因此須要設置爲包裹內容，而後就會發現ListView就會顯示第一行出來。而後就會百度到一條解決方案，繼承ListView，覆寫onMeasure方法。

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int expandSpec = MeasureSpec.makeMeasureSpec(Integer.MAX_VALUE >> 2, MeasureSpec.AT_MOST);
        super.onMeasure(widthMeasureSpec, expandSpec);
    }

 

 

問題是解決了，可是不少開發人員並不知道爲何。

 

下面會從ScrollView和ListView的measure過程來分析一下。

一、爲何會出現上述問題？

備註：截取部分問題相關代碼，並非完整代碼。

看看ListView的onMeasure：

@Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        final View child = obtainView(0, mIsScrap);
        childHeight = child.getMeasuredHeight();
        if (heightMode == MeasureSpec.UNSPECIFIED) {
            heightSize = mListPadding.top + mListPadding.bottom + childHeight + getVerticalFadingEdgeLength() * 2;
            if (heightMode == MeasureSpec.AT_MOST) {
                // TODO: after first layout we should maybe start at the first visible position, not 0 
                heightSize = measureHeightOfChildren(widthMeasureSpec, 0, NO_POSITION, heightSize, -1);
            }
            setMeasuredDimension(widthSize, heightSize);
            mWidthMeasureSpec = widthMeasureSpec;
        }
    }

 

 

當MeasureSpec mode爲UNSPECIFIED的時候，只測量第一個item打的高度，跟問題描述相符，因此咱們猜想多是由於ScrollView傳遞了一個UNSPECIFIED限制給ListView。

 

再來看ScrollView的onMeasure代碼：

 @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    }

 

 

調用了父類的onMeasure：

 

看看FrameLayout的onMeasure：

 @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        for (int i = 0; i < count; i++) {
            final View child = getChildAt(i);
            if (mMeasureAllChildren || child.getVisibility() != GONE) {
                measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, 0);
            }
        }
    }

 

 

調用了measureChildWithMargins，可是由於ScrollView覆寫了該方法，因此看看ScrollView的measureChildWithMargins方法：

@Override
    protected void measureChildWithMargins(View child, int parentWidthMeasureSpec, int widthUsed, 
                                           int parentHeightMeasureSpec, int heightUsed) {
        final int childHeightMeasureSpec = 
                MeasureSpec.makeSafeMeasureSpec(MeasureSpec.getSize(parentHeightMeasureSpec), 
                        MeasureSpec.UNSPECIFIED);
        child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
    }

 

 

果真，它向ListView的onMeasure傳遞了一個UNSPECIFIED的限制。

 

爲何呢，想一想，由於ScrollView，原本就是能夠在豎直方向滾動的佈局，因此，它對它全部的子View的高度就是UNSPECIFIED，意思就是，不限制子View有多高，由於我原本就是須要豎直滑動的，它的本意就是如此，因此它對子View高度不作任何限制。

 

二、爲何這種解決方法能夠解決這個問題？

看看ListView的onMeasure：

@Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        final View child = obtainView(0, mIsScrap);
        childHeight = child.getMeasuredHeight();
        if (heightMode == MeasureSpec.UNSPECIFIED) {
            heightSize = mListPadding.top + mListPadding.bottom + childHeight + getVerticalFadingEdgeLength() * 2;
            if (heightMode == MeasureSpec.AT_MOST) {
                // TODO: after first layout we should maybe start at the first visible position, not 0 
                heightSize = measureHeightOfChildren(widthMeasureSpec, 0, NO_POSITION, heightSize, -1);
            }
            setMeasuredDimension(widthSize, heightSize);
            mWidthMeasureSpec = widthMeasureSpec;
        }
    }

 

 

只要讓heightMode == MeasureSpec.AT_MOST，它就會測量它的完整高度，因此第一個數據，限制mode的值就肯定下來了。第二個數據就是尺寸上限，若是給個200，那麼當ListView數據過多的時候，該ListView最大高度就是200了，仍是不能徹底顯示內容，怎麼辦？那麼就給個最大值吧，最大值是多少呢，Integer.MAX_VALUE?

先看一下MeasureSpec的代碼說明：

        private static final int MODE_SHIFT = 30;
        public static final int UNSPECIFIED = 0 << MODE_SHIFT;
        public static final int EXACTLY = 1 << MODE_SHIFT;
        public static final int AT_MOST = 2 << MODE_SHIFT;

 

 

他用最高兩位存儲mode，用其餘剩餘未存儲size。因此Integer.MAX_VALUE >> 2，就是限制信息所能攜帶的最大尺寸數據。因此最後就須要用這兩個值作成一個限制信息，傳遞給ListView的height維度。

也就是以下代碼：

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int expandSpec = MeasureSpec.makeMeasureSpec(Integer.MAX_VALUE >> 2, MeasureSpec.AT_MOST);
        super.onMeasure(widthMeasureSpec, expandSpec);
    }

 

 

 

本身動手

        下面咱們本身寫一個自定義的ViewGroup，讓它內部的每個子View都垂直排布，而且讓每個子View的左邊界都距離上一個子View的左邊界必定的距離。而且支持wrap_content。大概看起來以下圖所示：

 實際運行效果以下圖所示：

 

 代碼以下：

public class VerticalOffsetLayout extends ViewGroup {

    private static final int OFFSET = 100;

    public VerticalOffsetLayout(Context context) {
        super(context);
    }

    public VerticalOffsetLayout(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public VerticalOffsetLayout(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);

        int widthMode = MeasureSpec.getMode(widthMeasureSpec);
        int heightMode = MeasureSpec.getMode(heightMeasureSpec);
        int widthSize = MeasureSpec.getSize(widthMeasureSpec);
        int heightSize = MeasureSpec.getSize(heightMeasureSpec);

        int width = 0;
        int height = 0;

        int childCount = getChildCount();
        for (int i = 0; i < childCount; i++) {
            View child = getChildAt(i);
            ViewGroup.LayoutParams lp = child.getLayoutParams();
            int childWidthSpec = getChildMeasureSpec(widthMeasureSpec, 0, lp.width);
            int childHeightSpec = getChildMeasureSpec(heightMeasureSpec, 0, lp.height);
            child.measure(childWidthSpec, childHeightSpec);
        }

        switch (widthMode) {
            case MeasureSpec.EXACTLY:
                width = widthSize;
                break;
            case MeasureSpec.AT_MOST:
            case MeasureSpec.UNSPECIFIED:
                for (int i = 0; i < childCount; i++) {
                    View child = getChildAt(i);
                    int widthAddOffset = i * OFFSET + child.getMeasuredWidth();
                    width = Math.max(width, widthAddOffset);
                }
                break;
            default:
                break;

        }

        switch (heightMode) {
            case MeasureSpec.EXACTLY:
                height = heightSize;
                break;
            case MeasureSpec.AT_MOST:
            case MeasureSpec.UNSPECIFIED:
                for (int i = 0; i < childCount; i++) {
                    View child = getChildAt(i);
                    height = height + child.getMeasuredHeight();
                }
                break;
            default:
                break;

        }

        setMeasuredDimension(width, height);
    }

    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        int left = 0;
        int right = 0;
        int top = 0;
        int bottom = 0;

        int childCount = getChildCount();

        for (int i = 0; i < childCount; i++) {
            View child = getChildAt(i);
            left = i * OFFSET;
            right = left + child.getMeasuredWidth();
            bottom = top + child.getMeasuredHeight();

            child.layout(left, top, right, bottom);

            top += child.getMeasuredHeight();
        }
    }
}