前言

任何View要显示在屏幕上，都需要经过测量（measure）、布局（layout）、绘制（draw）三大流程，measure负责确定View的大小，layout负责确定View的位置，draw负责绘制View的内容。这篇我们就先来通过源码分析一下View的测量（measure）流程。源码基于Android API 21。

测量由ViewRootImpl#performTraversals开始

在[由setContentView探究Activity加载流程]中，我们提到View三大工作流程是从ViewRootImpl#performTraversals方法开始的，其中performMeasure、performLayout、performDraw方法分别对应了View的测量、布局、绘制。如下：

    private void performTraversals() {
        ...
        int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
        int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);

        performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
        ...
        performLayout(lp, desiredWindowWidth, desiredWindowHeight);
        ...
        performDraw();
    }

    private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {
        Trace.traceBegin(Trace.TRACE_TAG_VIEW, "measure");
        try {
            mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);
        } finally {
            Trace.traceEnd(Trace.TRACE_TAG_VIEW);
        }
    }

可以看到，在performMeasure方法中调用了 mView.measure(childWidthMeasureSpec, childHeightMeasureSpec)，这里的mView其实是DecorView，它并没有重写measure方法，因为View#measure方法被final修饰，不可被重写。因此我们看下View#measure方法。

    public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
          ······
          // measure ourselves, this should set the measured dimension flag back
                onMeasure(widthMeasureSpec, heightMeasureSpec);
          ······
    }

在View#measure中又调用了onMeasure(widthMeasureSpec, heightMeasureSpec)方法。并且DecorView重写了onMeasure方法，在DecorView#onMeasure方法中主要是
进一步确定自己的widthMeasureSpec、heightMeasureSpec，并调用super.onMeasure(widthMeasureSpec, heightMeasureSpec)即FrameLayout#onMeasure方法。

ViewGroup 的Measure过程

ViewGroup是一个抽象类，它并没有重写onMeasure方法，具体的实现交由子类去处理，如LinearLayout、RelativeLayout、FrameLayout，这是因为不同ViewGroup的布局特性和实现细节各异，无法统一处理。在这里我们以FrameLayout为例分析ViewGroup的测量过程。

FrameLayout#onMeasure

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int count = getChildCount();//获取子View的数量
        
        final boolean measureMatchParentChildren =
                MeasureSpec.getMode(widthMeasureSpec) != MeasureSpec.EXACTLY ||
                MeasureSpec.getMode(heightMeasureSpec) != MeasureSpec.EXACTLY;
        mMatchParentChildren.clear();

        int maxHeight = 0;
        int maxWidth = 0;
        int childState = 0;

        for (int i = 0; i < count; i++) {
            final View child = getChildAt(i);
            if (mMeasureAllChildren || child.getVisibility() != GONE) {
                measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, 0);
                final LayoutParams lp = (LayoutParams) child.getLayoutParams();
                maxWidth = Math.max(maxWidth,
                        child.getMeasuredWidth() + lp.leftMargin + lp.rightMargin);
                maxHeight = Math.max(maxHeight,
                        child.getMeasuredHeight() + lp.topMargin + lp.bottomMargin);
                childState = combineMeasuredStates(childState, child.getMeasuredState());
                if (measureMatchParentChildren) {
                    if (lp.width == LayoutParams.MATCH_PARENT ||
                            lp.height == LayoutParams.MATCH_PARENT) {
                        mMatchParentChildren.add(child);
                    }
                }
            }
        }

        // Account for padding too
        maxWidth += getPaddingLeftWithForeground() + getPaddingRightWithForeground();
        maxHeight += getPaddingTopWithForeground() + getPaddingBottomWithForeground();

        // Check against our minimum height and width
        maxHeight = Math.max(maxHeight, getSuggestedMinimumHeight());
        maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());

        // Check against our foreground's minimum height and width
        final Drawable drawable = getForeground();
        if (drawable != null) {
            maxHeight = Math.max(maxHeight, drawable.getMinimumHeight());
            maxWidth = Math.max(maxWidth, drawable.getMinimumWidth());
        }

        setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
                resolveSizeAndState(maxHeight, heightMeasureSpec,
                        childState << MEASURED_HEIGHT_STATE_SHIFT));

        count = mMatchParentChildren.size();
        if (count > 1) {
            for (int i = 0; i < count; i++) {
                final View child = mMatchParentChildren.get(i);

                final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();
                int childWidthMeasureSpec;
                int childHeightMeasureSpec;
                
                if (lp.width == LayoutParams.MATCH_PARENT) {
                    childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredWidth() -
                            getPaddingLeftWithForeground() - getPaddingRightWithForeground() -
                            lp.leftMargin - lp.rightMargin,
                            MeasureSpec.EXACTLY);
                } else {
                    childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec,
                            getPaddingLeftWithForeground() + getPaddingRightWithForeground() +
                            lp.leftMargin + lp.rightMargin,
                            lp.width);
                }
                
                if (lp.height == LayoutParams.MATCH_PARENT) {
                    childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredHeight() -
                            getPaddingTopWithForeground() - getPaddingBottomWithForeground() -
                            lp.topMargin - lp.bottomMargin,
                            MeasureSpec.EXACTLY);
                } else {
                    childHeightMeasureSpec = getChildMeasureSpec(heightMeasureSpec,
                            getPaddingTopWithForeground() + getPaddingBottomWithForeground() +
                            lp.topMargin + lp.bottomMargin,
                            lp.height);
                }

                child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
            }
        }
    }

View的Measure过程

先来看下View中的measure方法

    /**
     * <p>
     * The actual measurement work of a view is performed in
     * {@link #onMeasure(int, int)}, called by this method. Therefore, only
     * {@link #onMeasure(int, int)} can and must be overridden by subclasses.
     * </p>
     */
    public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
          ······
          // measure ourselves, this should set the measured dimension flag back
                onMeasure(widthMeasureSpec, heightMeasureSpec);
          ······
    }

可以看到此方法是final的，不可以被重写，并且注释中也表明实际的测量工作是在onMeasure方法中进行的，所以我们直接看onMeasure方法即可。

    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
                getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
    }

setMeasureDimension方法其实是用来存储View最终的测量大小的。这个方法我们稍后分析，先来看下getDefaultSize这个方法。

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

这个方法是用来确定View最终测量大小的。由View自身的measureSpec(测量规则)获取specMode(测量模式)和specSize(测量大小)，当specMode为AT_MOST、EXACTLY这两种模式时，返回的大小就是此View的测量大小。当specMode为UNSPECIFIED时，返回大小是getSuggestedMinimumWidth和getSuggestedMinimumHeight这两个方法的返回值。

    protected int getSuggestedMinimumHeight() {
        return (mBackground == null) ? mMinHeight : max(mMinHeight, mBackground.getMinimumHeight());
    }

    protected int getSuggestedMinimumWidth() {
        return (mBackground == null) ? mMinWidth : max(mMinWidth, mBackground.getMinimumWidth());
    }

这两个方法原理是一样的，这里选择getSuggestedMinimumWidth来分析。

首先判断View有没有设置背景，如果没有，则返回mMinWidh，mMinWidth对应于android:minWidth这个属性对应的值，如果没有指定这个属性值，则默认为0。

如果设置了背景，则返回mMinWidth和 getMinimumWidth返回值之间的最大值。

    public int getMinimumWidth() {
        final int intrinsicWidth = getIntrinsicWidth();
        return intrinsicWidth > 0 ? intrinsicWidth : 0;
    }

在getMinimumWidth方法中，getIntrinsicWidth得到是背景的原始高度，如果背景原始高度大于0，则返回背景的原始高度，否则返回0。

至此getDefaultSize方法具体返回值就确定了，View最终的测量大小也就确定了。

注意：
当自定义View时，如果直接继承了View，在必要的时候需要重写onMeasure方法并在其中对wrap_content的情况进行处理。这是为什么呢?

从getDefaultSize方法中可以看到，当specMode为AT_MOST时，返回的大小为specSize,这个specSize其实是父View的大小，如果这里不明白，可以参考Android中View测量之MeasureSpec中普通View的MeasureSpec创建过程。

当确定了View的最终测量大小后，会把测量的宽高作为参数传入setMeasuredDimension方法。

    /**
     * <p>This method must be called by {@link #onMeasure(int, int)} to store the
     * measured width and measured height. Failing to do so will trigger an
     * exception at measurement time.</p>
     */
    protected final void setMeasuredDimension(int measuredWidth, int measuredHeight) {
        ......
        setMeasuredDimensionRaw(measuredWidth, measuredHeight);
        ......
    }

    private void setMeasuredDimensionRaw(int measuredWidth, int measuredHeight) {
        mMeasuredWidth = measuredWidth;
        mMeasuredHeight = measuredHeight;

        mPrivateFlags |= PFLAG_MEASURED_DIMENSION_SET;
    }

看注释就可以明白，其实这个方法就是用来存储测量的宽和高，并且如果没有设置这个方法，测量时将会产生异常。
其内部通过setMeasuredDimensionRaw方法会将View的最终测量宽高赋值给变量mMeasuredWidth，mMeasuredHeight进行存储。
另外我们可以通过getMeasuredWidth，getMeasuredHeight方法得到mMeasuredWidth、mMeasuredHeight对应的值，即View的最终的测量宽高。如下：

    public final int getMeasuredWidth() {
        return mMeasuredWidth & MEASURED_SIZE_MASK;
    }

    public final int getMeasuredHeight() {
        return mMeasuredHeight & MEASURED_SIZE_MASK;
    }

至此View的measure过程就分析完了，不过这里的View指的是像TextView、ImageView、Button这中不能含有子View的View,如果是一个ViewGroup类型的View,像LinearLayout、RelativeLayout、FrameLayout可以包含多个子View，那么它的measure过程又是怎样的，我们接着分析ViewGroup的measure过程。

ViewGroup的Measure过程

ViewGroup是一个抽象类，它并没有重写onMeasure方法，具体的实现交由子类去处理，如LinearLayout、RelativeLayout、FrameLayout，这是因为不同ViewGroup的布局特性和实现细节各异，无法统一处理。对于ViewGroup，它不但要测量自身大小，还要去测量每个子View的大小，我们先来分析一下ViewGroup中measureChildren方法，看它是如何测量子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的数量，然后遍历子View，最后调用measureChild方法。

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

在measureChild方法中先获取了子View的布局参数，然后通过父View的MeasureSpec、和子View的布局参数经过getChildMeasureSpec方法创建子View的MeasureSpec，这个方法已经在Android中View测量之MeasureSpec中做了详细介绍，当确定了子View的MeasureSpec后，就可以测量子View的大小了，接着调用子View的measure方法。至此，测量过程就从父View传递到了子View了。如果子View也是个ViewGroup将会重复ViewGroup的Measure过程，如果子View是单个View，将执行View的Measure过程，如此反复，就完成了整个View树的测量。

那ViewGroup具体是怎么确定自身最终测量大小的呢，下面我们以LiearLayout为例，来分析一下其onMeasure方法。

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        if (mOrientation == VERTICAL) {
            measureVertical(widthMeasureSpec, heightMeasureSpec);
        } else {
            measureHorizontal(widthMeasureSpec, heightMeasureSpec);
        }
    }

我们以竖直方向为例，来看下measureVertical方法的主要内容。

        ...
        for (int i = 0; i < count; ++i) {
            LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();
            ...
            measureChildBeforeLayout(
                       child, i, widthMeasureSpec, 0, heightMeasureSpec,
                       totalWeight == 0 ? mTotalLength : 0);
            ...
            final int childHeight = child.getMeasuredHeight();
            final int totalLength = mTotalLength;
            mTotalLength = Math.max(totalLength, totalLength + childHeight + lp.topMargin +lp.bottomMargin + getNextLocationOffset(child));
            ...
            final int margin = lp.leftMargin + lp.rightMargin;
            final int measuredWidth = child.getMeasuredWidth() + margin;
            maxWidth = Math.max(maxWidth, measuredWidth);
            ...
        }

        ...
        // Add in our padding
        mTotalLength += mPaddingTop + mPaddingBottom;

        int heightSize = mTotalLength;

        // Check against our minimum height
        heightSize = Math.max(heightSize, getSuggestedMinimumHeight());
        // Reconcile our calculated size with the heightMeasureSpec
        int heightSizeAndState = resolveSizeAndState(heightSize, heightMeasureSpec, 0);
        heightSize = heightSizeAndState & MEASURED_SIZE_MASK;
        ...
        maxWidth += mPaddingLeft + mPaddingRight;

        // Check against our minimum width
        maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());

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

上述代码做了如下工作：

• 遍历LinearLayout中的所有子View,并调用measureChildBeforeLayout方法，这个方法内部会调用measureChildWithMargins（这个方法和上文提到的measureChild方法原理一样，只不过在创建子View的MeasureSpec的时候考虑了子View的margin）方法，接着在measureChildWithMargins内部会执行子View的measure方法来测量子View的大小。
• 当子View测量完毕后，就可以通过getMeasuredWidth方法获取子View的测量宽度，并且用变量maxWidth来存储所有子View中（状态为View.Gone的除外）child.getMeasuredWidth() + lp.leftMargin + lp.rightMargin + mPaddingLeft + mPaddingRight 中的最大值；
  通过getMeasuredHeight方法获取子View的测量高度，并用变量mTotalLength来存储所有子View（状态为View.Gone的除外）的childHeight + lp.topMargin +lp.bottomMargin + getNextLocationOffset(child) + mPaddingTop + mPaddingBottom之和；
• 最后执行resolveSizeAndState方法最终确定自身测量大小。

    public static int resolveSizeAndState(int size, int measureSpec, int childMeasuredState) {
        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:
            if (specSize < size) {
                result = specSize | MEASURED_STATE_TOO_SMALL;
            } else {
                result = size;
            }
            break;
        case MeasureSpec.EXACTLY:
            result = specSize;
            break;
        }
        return result | (childMeasuredState&MEASURED_STATE_MASK);
    }

• 水平方向上，如果LinearLayout的宽度为match_parent 或具体的数值（MeasureSpec.EXACTLY），则LinearLayout的宽度就为自身测量规则确定的大小，如果LinearLayout的宽度为wrap_parent（MeasureSpec.AT_MOST），则LinearLayout的高度就为所有子View中占用水平空间最大的那个View所占空间大小加上LinearLayout自身的水平方向上的padding，但是大小仍然不会超过父View的宽度。
• 在竖直方向上，如果LinearLayout的高度为match_parent 或具体的数值（MeasureSpec.EXACTLY），则LinearLayout的高度就为自身测量规则确定的大小，如果LinearLayout的高度为wrap_parent（MeasureSpec.AT_MOST），则LinearLayout的高度就为所有子View占用的空间大小加上LinearLayout自身的竖直方向上的padding，但是大小仍然不会超过父View的高度。

以上就是ViewGroup的measure过程。

至此，measure篇就讲完了，真心希望对各位猿宝宝在measure过程的理解上有所帮助！！！

若文中有错误或表述不当的地方还望指出，多多交流，共同进步。