View在測量時的MeasureSpec由什麼決定？

我們都知道系統要確定View的大小，首先得先獲得MeasureSpec，再通過MeasureSpec來決定View的大小。

MeasureSpec（32為int值）由兩部分組成：

SpecMode（高2位）:測量模式。

SpecSize（低30位）：某種測量模式下的規格大小。

SpecMode有3類：

UNSPECIFIED: 父容器不對view做大小限制，一般用於系統內部，表示一種測量狀態。

EXACTLY:精確模式。對應於：LayoutPrams中的match_parent和具體數值。

AT_MOST:最大值模式。對應於LayoutParam中的wrap_content模式。

那麼問題來了，這個MeasureSpec又是由什麼決定的呢？我們從源代碼裡面入手。

ViewGroup裡面有一個方法，叫做measureChildWithMargins，用來測量子view的大小的。

/**
     * Ask one of the children of this view to measure itself, taking into
     * account both the MeasureSpec requirements for this view and its padding
     * and margins. The child must have MarginLayoutParams The heavy lifting is
     * done in getChildMeasureSpec.
     *
     * @param child The child to measure
     * @param parentWidthMeasureSpec The width requirements for this view
     * @param widthUsed Extra space that has been used up by the parent
     *        horizontally (possibly by other children of the parent)
     * @param parentHeightMeasureSpec The height requirements for this view
     * @param heightUsed Extra space that has been used up by the parent
     *        vertically (possibly by other children of the parent)
     */
    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);
    }

可以看出，在代碼里，會先獲取childWidthMeasureSpec和childHeightMeasureSpec，然後再測量子元素 child.measure(childWidthMeasureSpec, childHeightMeasureSpec);

我們關鍵是要看這兩個MeasureSpec是怎麼獲取到的，通過方法getChildMeasureSpec(parentWidthMeasureSpec,
                mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin
                        + widthUsed, lp.width);我們可以看出MeasureSpec的獲取不但與子元素本身的LayoutParam有關，還與父容器的MeasureSpec有關，當然，也與它的padding，margin有關。
我們進去看看，這部分代碼有點長，不過裡面的邏輯很簡單，我們直接在源代碼裡面通過加註釋來分析。

/**
     * Does the hard part of measureChildren: figuring out the MeasureSpec to
     * pass to a particular child. This method figures out the right MeasureSpec
     * for one dimension (height or width) of one child view.
     *
     * The goal is to combine information from our MeasureSpec with the
     * LayoutParams of the child to get the best possible results. For example,
     * if the this view knows its size (because its MeasureSpec has a mode of
     * EXACTLY), and the child has indicated in its LayoutParams that it wants
     * to be the same size as the parent, the parent should ask the child to
     * layout given an exact size.
     *
     * @param spec The requirements for this view
     * @param padding The padding of this view for the current dimension and
     *        margins, if applicable
     * @param childDimension How big the child wants to be in the current
     *        dimension
     * @return a MeasureSpec integer for the child
     */
    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; //子元素的specSize
        int resultMode = 0; //子元素的specMode

        switch (specMode) {
        // Parent has imposed an exact size on us
        case MeasureSpec.EXACTLY: //如果父容器的測量模式為EXACTLY
            if (childDimension >= 0) { //如果子元素的LayoutParam為具體數值>=0
                resultSize = childDimension; //那麼子元素的specSize就是childDimension
                resultMode = MeasureSpec.EXACTLY; //那麼子元素的specMode是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
                //這裡View.sUseZeroUnspecifiedMeasureSpec一直都是false，因此resultSize==0；
                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);
    }

由以上的分析可以看出子元素的MeasureSpec的獲取不但與子元素本身的LayoutParam有關，還與父容器的MeasureSpec有關，當然，也與它的padding，margin有關。

其實我們可以得出下麵的結論：

 parentSize是父容器的剩餘空間。

從上面的表格也可以看出，當我們直接繼承view來實現自定義控制項的時候，需要重寫onMeasure方法並設置wrap_content時候的自身大小，不然使用wrap_content得時候就相當於使用match_parent。我們可以用下麵的模板：

@Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        int widthSpecMode=MeasureSpec.getMode(widthMeasureSpec);
        int heightSpecMode=MeasureSpec.getMode(heightMeasureSpec);

        int widthSpecSize=MeasureSpec.getSize(widthMeasureSpec);
        int heightSpecSize=MeasureSpec.getSize(heightMeasureSpec);

        if (widthSpecMode==MeasureSpec.AT_MOST && heightSpecMode==MeasureSpec.AT_MOST)
        {
            setMeasuredDimension(100,100);
        }
        else if (widthSpecMode==MeasureSpec.AT_MOST)
        {
            setMeasuredDimension(100,heightSpecSize);
        }
        else if (heightSpecMode==MeasureSpec.AT_MOST)
        {
            setMeasuredDimension(widthSpecSize,100);
        }
    }

上面代碼中的100是我們自己設置的數值，你也可以用其他數值，根據自己需要。

以上便是對MeasureSpec由何決定的分析。