1
public final class MeasureSpec {
2

3
  int size;     // 测量大小
4
  Mode mode;    // 测量模式
5

6
  enum Mode { UNSPECIFIED, EXACTLY, AT_MOST }
7

8
  MeasureSpec(Mode mode, int size){
9
    this.mode = Mode;
10
    this.size = size;
11
  }
12

13
  public int getSize() { return size; }
14

15
  public Mode getMode() { return mode; }
16
}

1
public static class MeasureSpec {
2
    private static final int MODE_SHIFT = 30; //移位位数为30
3
    //int类型占32位，向右移位30位，该属性表示掩码值，用来与size和mode进行"&"运算，获取对应值。
4
    private static final int MODE_MASK  = 0x3 << MODE_SHIFT;
5

6
    //00左移30位，其值为00 + (30位0)
7
    public static final int UNSPECIFIED = 0 << MODE_SHIFT;
8
    //01左移30位，其值为01 + (30位0)
9
    public static final int EXACTLY     = 1 << MODE_SHIFT;
10
    //10左移30位，其值为10 + (30位0)
11
    public static final int AT_MOST     = 2 << MODE_SHIFT;
12

13
    // 根据size和mode，创建一个测量要求
14
    public static int makeMeasureSpec(int size, int mode) {
15
        return size + mode;
16
    }
17

18
    // 根据规格提取出mode，
19
    public static int getMode(int measureSpec) {
20
        return (measureSpec & MODE_MASK);
21
    }
22

23
    // 根据规格提取出size
24
    public static int getSize(int measureSpec) {
25
        return (measureSpec & ~MODE_MASK);
26
    }
27
}

1
// 这个是父控件的代码，让子控件开始测量
2
child.measure(childWidthMeasureSpec, childHeightMeasureSpec);

1
public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
2
  // ... 公共逻辑
3

4
  // 开发者需要自己重写onMeasure函数，以自定义测量逻辑
5
  onMeasure(widthMeasureSpec, heightMeasureSpec);
6
}

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

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

1
public static int getDefaultSize(int size, int measureSpec) {
2
    // 宽度的默认值
3
    int result = size;
4
    int specMode = MeasureSpec.getMode(measureSpec);
5
    int specSize = MeasureSpec.getSize(measureSpec);
6

7
    // 根据不同的测量模式，返回的测量结果不同
8
    switch (specMode) {
9
      // 任意模式，宽度为默认值
10
      case MeasureSpec.UNSPECIFIED:
11
          result = size;
12
          break;
13
      // match_parent、wrap_content则返回布局要求中的size值
14
      case MeasureSpec.AT_MOST:
15
      case MeasureSpec.EXACTLY:
16
          result = specSize;
17
          break;
18
    }
19
    return result;
20
}

1
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
2
    // 普遍意义上，setMeasuredDimension()标志着测量结束
3
    setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
4
            getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
5
}
6

7
protected final void setMeasuredDimension(int measuredWidth, int measuredHeight) {
8
 // measuredWidth 测量结果，View的宽度
9
 // measuredHeight 测量结果，View的高度
10
 // 省略其它代码...
11

12
 // 该方法的本质就是将测量结果存起来，以便后续的layout和draw流程中获取控件的宽高
13
 mMeasuredWidth = measuredWidth;
14
 mMeasuredHeight = measuredHeight;
15
}

1
public final int getMeasuredWidth() {
2
    return mMeasuredWidth;
3
}
4
public final int getMeasuredHeight() {
5
    return mMeasuredHeight;
6
}
7

8
// 如何使用
9
int width = view.getMeasuredWidth();
10
int height = view.getMeasuredHeight()

1
// 1.0版本的LinearLayout
2
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
3
  // 1.通过遍历，对每个child进行测量
4
  for(int i = 0 ; i < getChildCount() ; i++){
5
    View child = getChildAt(i);
6
    // 2.直接测量子控件
7
    child.measure(widthMeasureSpec, heightMeasureSpec);
8
  }
9
  // ...
10
  // 3.所有子控件测量完毕...
11
  // ...
12
}

1
protected void measureChild(View child, int parentWidthMeasureSpec,
2
            int parentHeightMeasureSpec) {
3
    // 获取子元素的布局参数
4
    final LayoutParams lp = child.getLayoutParams();
5
    // 通过padding值，计算出子控件的布局要求
6
    final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
7
            mPaddingLeft + mPaddingRight, lp.width);
8
    final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
9
            mPaddingTop + mPaddingBottom, lp.height);
10
    // 将新的布局要求传入measure方法，完成子控件的测量
11
    child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
12
}

1
// 3.0版本的LinearLayout
2
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
3
  // 1.通过遍历，对每个child进行测量
4
  for(int i = 0 ; i < getChildCount() ; i++){
5
     View child = getChildAt(i);
6
     // 2.计算新的布局要求，并对子控件进行测量
7
     measureChild(child, widthMeasureSpec, heightMeasureSpec);
8
  }
9
  // 3.完成子控件的测量,对高度进行累加
10
  int height = 0;
11
  for(int i = 0 ; i < getChildCount() ; i++){
12
      height += child.getMeasuredHeight();
13
  }
14
  // 4.完成LinearLayout的测量
15
  setMeasuredDimension(width, height);
16
}