Android View的绘制流程三部曲 —— Measure

在刚开始学习Java的时候，我看的是Mars老师的视频。Mars老师说过的一句话让我印象很深刻：要有一颗面向对象的心。

如果我们用面向对象的思维方式来思考，就会觉的View的绘制机制是很合理，很科学的。我们要在一张纸上画一幅画，首先要测量一下这幅画有多大吧，然后确定在这张纸的哪个地方画会显得比较美观，最后才是用画笔工具将画绘制在纸上。
在Android中也是一样的。View的绘制流程主要是指measure，layout，draw这三步，即测量，布局，绘制。首先是要测量View的宽高，然后布局确定在父容器中的位置坐标，最后才是绘制显示出来。

View的绘制流程从ViewRootImpl的performTraversals方法开始，在performTraversals方法中会调用performMeasure、performLayout、performDraw三个方法来遍历完成整棵视图树的绘制。

那这篇博客就一起来探索View的绘制流程中的第一步，measure。

MeasureSpec

performMeasure方法是这样被调用的，

performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);

接收了两个参数，很好奇这两个参数是什么。看名字是“子View宽测量说明书”和“子View高测量说明书”？应该先来了解一下MeasureSpec。

MeasureSpec是一个32位的int值，高2位是specMode记录的是测量模式，低30位是specSize记录的是测量大小。

specMode有三种类型：

EXACTLY ： 精确值模式，表示父视图希望子视图的大小应该是由specSize的值来决定的，这个时候View的最终大小就是specSize所记录的大小。对应于LayoutParams中的 match_parent和具体数值的形式。比如 android:layout_width=”match_parent”，android:layout_width=”50dp”

AT_MOST ： 最大值模式，表示父容器指定了一个可用大小specSize，子视图最多只能是specSize中指定的大小，不能大于这个值。对应于LayoutParams中的 wrap_content的形式。

UNSPECIFIED ：父容器不对View有任何限制，View想多大就多大，一般不会用到

MeasureSpec到底是用来干嘛的？
系统是通过View的MeasureSpec来确定View的测量宽高的

MeasureSpec是怎么来的？
对于普通的View来说，其MeasureSpec由父容器的MeasureSpec和自身的LayoutParams共同确定。对于顶级View（DecorView），其MeasureSpec由窗口的尺寸和其自身的LayoutParams共同确定。

一个View是有两个MeasureSpec的，一个用于确定测量的宽，一个用于确定测量的高。
我们回到performMeasure方法，来看看参数childWidthMeasureSpec和childHeightMeasureSpec，这两个MeasureSpec是顶级View的，它们由窗口的尺寸和其自身的LayoutParams共同确定。那它们又是怎么产生的？接下来就是揭晓谜底时候。

在ViewRootImpl的measureHierarchy方法中，有两行代码是这样的

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

getRootMeasureSpec方法获取到根View（DecorView）的MeasureSpec。哈哈找到了。然后赋值给childWidthMeasureSpec和childHeightMeasureSpec。desiredWindowWidth和desiredWindowHeight是屏幕的尺寸。lp.width 和lp.height都是MATCH_PARENT。

那么探探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;
}

会转到MeasureSpec的makeMeasureSpec方法，而makeMeasureSpec方法就是将SpecSize和SpecMode包装成32位的int值。在这里，SpecSize是windowSize，即屏幕的尺寸，SpecMode是EXACTLY（精确值模式）。那makeMeasureSpec方法是怎么组装MeasureSpec的呢？如下：

public static int makeMeasureSpec(@IntRange(from = 0, to = (1 << MeasureSpec.MODE_SHIFT) - 1) int size,
                                  @MeasureSpecMode int mode) {
    if (sUseBrokenMakeMeasureSpec) {
        return size + mode;
    } else {
        return (size & ~MODE_MASK) | (mode & MODE_MASK);
    }
}

这样，根View的MeasureSpec就诞生了。它将参与构成子元素的MeasureSpec。

而对于普通的View，其MeasureSpec由父容器的MeasureSpec和自身的LayoutParams共同构成。我们知道刚才getRootMeasureSpec方法获取到的是顶级View的MeasureSpec，顶级View本身就是父容器。
那现在看看ViewGroup的measureChild方法，这个方法是用来测量子View的。如下：

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

首先是调用子元素的getLayoutParams方法获取到子元素的LayoutParams，之后调用了getChildMeasureSpec方法来获取到子元素的MeasureSpec，可以看到传入了父元素的MeasureSpec（parentWidthMeasureSpec、parentHeightMeasureSpec）。

getChildMeasureSpec方法很重要，能让我们了解子元素MeasureSpec的产生过程，如下：

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

如果父容器的specMode是EXACTLY，子元素的大小是精确的大小（设置了比如android:layout_width=”50dp”），那么子元素的specSize是childDimension（如50dp） ，specMode也是EXACTLY。其他的分支都是差不多的。
这个方法代码虽然长长的，但逻辑并不复杂，就是根据父容器的MeasureSpec和子元素的LayoutParams来组装子元素的MeasureSpec。所以说普通View的MeasureSpec由父容器的MeasureSpec和自身的LayoutParams共同决定。

MeasureSpec就那么多知识点，其实我觉的View的绘制过程中，measure过程之所以是复杂的，就是因为MeasureSpec的构成受到父容器MeasureSpec和自身LayoutParams的影响，分了多种情况。好多要记的。
有了MeasureSpec后，真正的测量过程，其实就是根据MeasureSpec的测量模式来确定测量大小。就是这样。

那么现在我们已经搞定了MeasureSpec，之后回到performMeasure方法，这里传入的是顶级View（DecorView）的MeasureSpec。那么我们就跟进看看到底View的测量过程是怎样的。

View的测量

performMeasure方法源码如下：

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

转到了View的measure方法，如下：

public final void measure(int widthMeasureSpec, int heightMeasureSpec) {

    //代码省略

    final boolean forceLayout = (mPrivateFlags & PFLAG_FORCE_LAYOUT) == PFLAG_FORCE_LAYOUT;

    //代码省略
    if (forceLayout || needsLayout) {
        // first clears the measured dimension flag
        mPrivateFlags &= ~PFLAG_MEASURED_DIMENSION_SET;

        resolveRtlPropertiesIfNeeded();

        int cacheIndex = forceLayout ? -1 : mMeasureCache.indexOfKey(key);
        if (cacheIndex < 0 || sIgnoreMeasureCache) {
            // measure ourselves, this should set the measured dimension flag back
            onMeasure(widthMeasureSpec, heightMeasureSpec);
            mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
        } 

        //代码省略

    mOldWidthMeasureSpec = widthMeasureSpec;
    mOldHeightMeasureSpec = heightMeasureSpec;

    mMeasureCache.put(key, ((long) mMeasuredWidth) << 32 |
            (long) mMeasuredHeight & 0xffffffffL); // suppress sign extension
}

可以看到View的measure方法是带final的，不允许子类重写。
经过一系列的处理，核心过程会转到onMeasure方法真正去测量，而这个onMeasure方法一般是需要重写，比如DecorView重写了View的onMeasure方法，TextView也是。

但是View也定义了onMeasure方法的默认实现，那就跟进onMeasure方法探探，

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

调用了setMeasuredDimension将测量的宽高设置进去，好像很简单的说。如果我们要重写onMeasure方法，去测量宽高，最后也要调用setMeasuredDimension将测量的宽高设置进去。好，接着继续

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

其实内部逻辑是很简单的，从measureSpec中取出specMode和specSize，然后就是AT_MOST和EXACTLY的情况下，都返回specSize，这个specSize就是测量的值了。

以上就是View的测量过程。

ViewGroup的测量

那么接下来是ViewGroup的测量过程，ViewGroup中是没有重写onMeasure方法的，这也是很合理的。怎么能定义出一个符合很多种ViewGroup的onMeasure方法呢？很显然LinearLayout和RelativeLayout的onMeasure方法实现是不一样的。一个是线性布局，一个是相对布局。

ViewGroup除了完成自身的测量，还会遍历子元素，如此循环完成整棵视图树的测量过程。在ViewGroup中定义了一个measureChildren方法去遍历子元素，如下：

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

会转到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);
}

就这样，ViewGroup将measure过程传递到了子元素。如此反复完成整棵视图树的绘制。

以上就是ViewGroup的测量过程

总结

我觉的学习View的绘制，可以看看一些系统的View的源码，比如LinearLayout的，TextView的，TextView的比较难，可以挑个简单点的。

来举个例子梳理一下，activity_main.xml文件如下所示：

<LinearLayout 
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="horizontal"
    >
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="helloworld"
        />

</LinearLayout>

View的绘制流程从ViewRootImpl的performTraversals方法开始，在performTraversals方法中会调用performMeasure方法。而在performMeasure中会调用DecorView的measure方法，这样整个视图树的测量也就开始了。
之后DecorView会调用它重写的onMeasure方法，在DecorView的onMeasure方法中，又会调用其父类FrameLayout的onMeasure方法，在FrameLayout的onMeasure方法中，才将measure过程传递到子元素，即调用了子元素的measure方法。这个时候就到了我们的activity_main.xml文件对应的ContentView了。这就是ViewGroup的measure传递过程。
上面贴出了View的measure方法，我们知道了measure方法是不允许子类重写的，但它很重要。measure方法是传递的入口，比如父元素传递measure过程给子元素一般都是这样的，

child.measure(childWidthMeasureSpec, childHeightMeasureSpec)

measure方法传入子元素的MeasureSpec，而这个MeasureSpec是通过父元素的MeasureSpec和子元素自身LayoutParams共同决定的，详细过程会看上面的measureChild方法。
然后在子元素的measure中会调用onMeasure方法去真正测量View。onMeasure方法通常都要重写。根据MeasureSpec来最终确定出View的测量宽高。

呼！真的要去看下系统控件源码，或者是去看下大神们写的自定义View，能帮助我们梳理View的绘制的知识。
比如郭神写过一篇文章介绍Scroller，还介绍了简易版ViewPager的实现，这个自定义的ViewPager的方法是这样重写onMeasure方法的：

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
     super.onMeasure(widthMeasureSpec, heightMeasureSpec);
     int childCount = getChildCount();
     for (int i = 0; i < childCount; i++) {
         View childView = getChildAt(i);
         // 为ScrollerLayout中的每一个子控件测量大小
         measureChild(childView, widthMeasureSpec, heightMeasureSpec);
     }
}

学习的时候就可以思考，为什么郭大侠会这样写？第一行super.onMeasure是测量自身（View的onMeasure是有用的！），然后是遍历子元素，调用measureChild方法来测量子元素，完毕！这也验证了ViewGroup除了测量自身，还会遍历测量子元素。

这些都是我学习View的绘制，自定义View的方法。