View那些事儿(2) -- 理解MeasureSpec

View的绘制的三大流程的第一步就是Measure（测量），想要理解View的测量过程，必须要先理解MeasureSpec，从字面上看，MeasureSpec就是“测量规格”的意思。其实它在一定程度上决定了View的测量过程，具体来讲它包含了一个View的尺寸规格信息。在系统测量View的尺寸规格的时候会将View的LayoutParams根据父容器所施加的规则转换成对应的MeasureSpec，然后再根据MeasureSpec测量出View的宽高。

一.MeasureSpec的组成

MeasureSpec代表了一个32位的int值，高2位代表了SpecMode（测量模式），低30位代表了SpecSize（规格大小）。下面结合一段源码来分析：

public static class MeasureSpec {    private static final int MODE_SHIFT = 30;//二进制数左移的位数    private static final int MODE_MASK  = 0x3 << MODE_SHIFT;//将二进制数11左移动30位    public static final int UNSPECIFIED = 0 << MODE_SHIFT;//将二进制数00左移动30位              public static final int EXACTLY= 1 << MODE_SHIFT;//将二进制数01左移动30位    public static final int AT_MOST= 2 << MODE_SHIFT;//将二进制数10左移动30位      //将SpecMode和SpecSize包装成MeasureSpec    public static int makeMeasureSpec(int size, int mode ）{        if (sUseBrokenMakeMeasureSpec) {            return size + mode;        } else {            return (size & ~MODE_MASK) | (mode & MODE_MASK);        }    }    //从mesureSpec中取出SpecMode    public static int getMode(int measureSpec) {        return (measureSpec & MODE_MASK);    }    //从measureSpec中取出SpecSize    public static int getSize(int measureSpec) {        return (measureSpec & ~MODE_MASK);    }}

通过以上源码，便可以很清晰地看出整个MeasureSpec的工作原理，其中涉及到了java里的按位运算操作，“&”是按位与的意思，“～”则是按位取反的意思，“<<”是左移运算符（x<<1就表示x的值乘2），这些运算符都是在2进制数的层面上进行运算的，具体的运算规则google上面一大堆，这里就不多说了。
MeasrureSpec类的三个常量：UNSPECIFIED、EXACTLY、AT_MOST分别代表的三种SpecMode（测量模式）：

• UNSPECIFIED(不指定大小的)
  父容器不对View有任何限制，想要多大有多大，这种情况一般属于系统内部，表示一种测量状态，几乎用不到。例如：系统对ScrollView的绘制过程。
• EXACTLY（精确的）
  父容器已经检测出View所需要的精确的大小，这个时候View的最终大小就是SpecSize所指定的值。这里对应于：LayoutParams中的match_parent和具体的数值，如20dp。
• AT_MOST(最大的)
  这种模式稍微难处理一点，它指的是父容器指定了一个可用的大小（SpecSize），View的大小不能超过这个值的大小。如果超过了，就取父容器的大小，如果没超过，就取自身的大小。这里对应于：LayoutParams中的wrap_content模式。

全部都是些理论，没点demo怎么行，下面直接上一段代码吧：

首先，要实现的效果很简单，就是一个圆形的自定义View（我们主要是要处理wrap_content的情况下的数据，必须给它一个默认值）：

public class CircleView extends View {    Paint mPaint;//画笔类    public CircleView(Context context) {        super(context);    }    public CircleView(Context context, AttributeSet attrs) {        super(context, attrs);    }    public CircleView(Context context, AttributeSet attrs, int defStyleAttr) {        super(context, attrs, defStyleAttr);    }    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)    public CircleView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {        super(context, attrs, defStyleAttr, defStyleRes);    }    @Override    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {        super.onMeasure(widthMeasureSpec, heightMeasureSpec);        //第一步肯定是拿到View的测量宽高(SpecSize)和测量模式(SpecMode)        int widthMode = MeasureSpec.getMode(widthMeasureSpec);        int heightMode = MeasureSpec.getMode(heightMeasureSpec);        int widthSize = MeasureSpec.getSize(widthMeasureSpec);        int heightSize = MeasureSpec.getSize(heightMeasureSpec);        //View显示的时候的实际的大小        int width = 0;        int height = 0;        //开始处理宽度        //默认的宽度（在wrap_content的情况下必须有个默认的宽高）        int defaultWidth = 200;        //判断SpecMode(在xml中指定View的宽度的时候就已经决定了View的SpecMode)        switch (widthMode){            case MeasureSpec.AT_MOST://这里指的是wrap_content,在这个模式下不能超过父容器的宽度                width = defaultWidth;                break;            case MeasureSpec.EXACTLY://这里指的是match_parent或者具体的值，不需要做什么处理，width直接等于widthSize就可以了                width = widthSize;                break;            case MeasureSpec.UNSPECIFIED://这个模式用不到，完全可以忽略                width = defaultWidth;                break;            default:                width = defaultWidth;                break;        }        //开始处理高度        int defaultHeight = 200;        switch (heightMode){            case MeasureSpec.AT_MOST://这里指的是wrap_content,在这个模式下不能超过父容器的高度                height = defaultHeight;                break;            case MeasureSpec.EXACTLY://这里指的是match_parent或者具体的值，不需要做什么处理，height直接等于heightSize就可以了                height = heightSize;                break;            case MeasureSpec.UNSPECIFIED://这个模式用不到，完全可以忽略                height = defaultHeight;                break;            default:                height = defaultHeight;                break;        }        //最后必须调用父类的测量方法，来保存我们计算的宽度和高度，使得设置的测量值生效        setMeasuredDimension(width,height);    }    @Override    protected void onDraw(Canvas canvas) {        super.onDraw(canvas);        //初始化画笔，并进行一系列的设置，如颜色等。        mPaint = new Paint();        mPaint.setColor(Color.RED);        mPaint.setAntiAlias(true);//设置抗锯齿        //canvas.drawCircle的几个参数分别是：圆心的x坐标，y坐标，半径，画笔        canvas.drawCircle(getWidth()/2,getHeight()/2,Math.min(getWidth()/2,getHeight()/2),mPaint);    }}

显示效果如下：

大家可以试一下，如果把不在onMreasure中做以上处理（注释掉onMeasure方法即可看见效果），给CircleView设置的wrap_content会失效,实际的显示效果和match_parent没什么区别。
在这个地方提前写了一个自定义View是为了帮助读者理解MeasureSpec的相关用法，详细结合前一篇文章的讲解加上代码的注释，大家还是能很容易看懂的。
当然为了把这个过程表述清楚，我把代码写得很详细，显得有点累赘，实际中其实可以不用这么详细。

二.MeasureSpec和LayouParams的关系

上面都在讲MeasureSpec是什么，现在就该说说他是怎么来的了。
这里要分两部分说：第一是普通的View，第二是DecorView

• 在普通View测量过程中，系统会将View自身的LayoutParams在父容器的约束下转换为对应的MeasureSpec，然后再根据这个MeasureSpec来确定View测量后的宽和高；
• 在DecorView（顶级View）的测量过程中，系统会将View自生的LayoutParams在窗口尺寸的约束下转换为对应的MeasureSpec 。

1.首先，重点说一下普通的View

对于普通的View（即在布局文中的View）来说，它的measure过程由ViewGroup传递而来，所以先来看看ViewGroup的measureChildWithMargins()方法：

//对ViewGroup的子View进行Measure的方法protected void measureChildWithMargins(View child,            int parentWidthMeasureSpec, int widthUsed,              int parentHeightMeasureSpec, int heightUsed) {    //获取子View的布局参数信息（MarginLayoutParams是继承自ViewGroup.LayoutParmas的）    final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();    //获取子View的宽度的MeasureSpec，需要传入父容器的parentWidthMeasureSpec等信息    final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,            mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin                    + widthUsed, lp.width);    //获取子View的高度的MeasureSpec，需要传入父容器的parentHeightMeasureSpec等信息        final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,            mPaddingTop + mPaddingBottom + lp.topMargin + lp.bottomMargin                    + heightUsed, lp.height);    child.measure(childWidthMeasureSpec, childHeightMeasureSpec);}  

结合注释，从上面这段测量子View的MeasureSpec的源码中可以看出，在测量的时候传入了父容器的MeasureSpec信息和子View自身的LayoutParams信息（如margin、padding），所以才说普通View的测量过程与父容器和自身的LayoutParams有关。
那么像知道测量的具体过程就得看看getChildMeasureSpec（）这个方法了（看似代码较多，但是很简单）：

public static int getChildMeasureSpec(int spec, int padding, int childDimension) {          //还是先拿到specMode和specSize信息        int specMode = MeasureSpec.getMode(spec);        int specSize = MeasureSpec.getSize(spec);          //padding指的是父容器已经占据的空间大小，所以，子View的大小因为父容器的大小减去padding        int size = Math.max(0, specSize - padding);          //测量后View最终的specSize和specMode        int resultSize = 0;        int resultMode = 0;          //针对三种specMode进行判断        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);    }

上面的代码很清晰地展示这个测量过程，下面一个表格来梳理具体的判断逻辑。（parentSize是指父容器目前可使用的大小）

parentSpecMode →
childLayoutParams↓ EXACTLY AT_MOST UNSPICIFIED dp/px(确定的宽／高) EXACTLY
childSize EXACTLY
childSize EXACTLY
childSize match_parent EXACTLY
parentSize AT_MOST
parentSize UNSPECIFIED
0 wrap_content AT_MOST
parentSize AT_MOST
parentSize UNSPECIFIED
0

根据表格，getChildMeasureSpec()方法的判断规则一目了然：

• 当View的指定了确定的宽高的时候，无论父容器的SpecMode是什么，它的SpecMode都是EXACTLY，并且大小遵循LayoutParams中的大小；
• 当View的宽／高指定成match_parent的时候，它的SpecMode与父容器相同，并且大小不能超过父容器的剩余空间大小；
• 当View的宽／高指定成wrap_content的时候，它的SpecMode恒为（不考虑UNSPECIFIED的情况）AT_MOST，并且大小不能超过父容器的剩余空间大小。

由于UNSPECIFIED模式我们一般接触不到，故在这里不做讨论
从上面的总结来看，其实普通View的MeasureSpec的LayoutParams的关系还是很容易理解与记忆的。

2.下面该来看看DecorView（顶级View）了

对于DecorView来说，MeasureSpec是由窗口尺寸和自身的LayoutParams共同决定的。
还是来看看源码吧，在ViewRootImpl(这个类被隐藏了，需要手动搜索sdk目录找出ViewRootImpl.java才能看见源码)有一个meaureHierarchy()方法，其中有下面这段代码：

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

其中，desiredWindowWidth和desiredWindowHeight分别指的是屏幕的宽高。
看到这里就隐约感觉到DecorView的MeasureSpec会和窗口尺寸有关，再来看看getRootMeasureSpec就更明了了：

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

看到这里就豁然开朗了，DecorView的MeasureSpec的确和窗口尺寸有关。

所以，Decor的MeasureSpec根据它的LayoutParams遵循以下规则：

• LayoutParams.MATCH_PARENT: EXACTLY(精准模式)，大小就是窗口的大小；
• LayoutParams.WRAP_CONTENT: AT_MOST(最大模式)，大小不定，但是不能超过窗口的大小；
• 固定的大小（如200dp): EXACTLY(精准模式)，大小为LayoutParams所制定的大小。

至此，对MeasureSpec的理解就结束了