自定义 View - Measure 详解

1
2
3
4
5
FILL_PARENT
使子视图的大小扩展至与父视图大小相等（不含 padding )
match_parent	与fill_parent相同，用于Android 2.3 & 之后版本
wrap_content	自适应大小，使视图扩展以便显示其全部内容(含 padding )

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

public static class MeasureSpec {
// 移位数
private static final int MODE_SHIFT = 30;
// 遮罩位，二进制 11 左移 30 位，
// MeasureSpec 通过与 MODE_MASK 做 & 运算能够获取 SpecMode
// MeasureSpec 通过与 ~MODE_MASK 做 & 运算能够获取 SpecSize
private static final int MODE_MASK
= 0x3 << MODE_SHIFT;
// UNSPECIFIED 的数值
public static final int UNSPECIFIED = 0 << MODE_SHIFT;
// EXACTLY 的数值
public static final int EXACTLY
= 1 << MODE_SHIFT;
// AT_MOST 的数值
public static final int AT_MOST
= 2 << MODE_SHIFT;
// 将 SpecMode 和 SpecSize 合成 MeasureSpec
public static int makeMeasureSpec(int size, int mode) {
if (sUseBrokenMakeMeasureSpec) {
return size + mode;
} else {
return (size & ~MODE_MASK) | (mode & MODE_MASK);
}
}
// 获取 SpecMode， MeasureSpec 通过与 MODE_MASK 做 & 运算
public static int getMode(int measureSpec) {
//noinspection ResourceType
return (measureSpec & MODE_MASK);
}
// MeasureSpec 通过与 ~MODE_MASK 做 & 运算
public static int getSize(int measureSpec) {
return (measureSpec & ~MODE_MASK);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
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);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
// 获取父容器的 specMode 和 specSize
int specMode = MeasureSpec.getMode(spec);
int specSize = MeasureSpec.getSize(spec);
// 如果子 View 有 padding，需要减去 padding 的大小
int size = Math.max(0, specSize - padding);
// 子 View 的 size 和 mode 变量定义，也作为结果
int resultSize = 0;
int resultMode = 0;
// 需要看父容器的测量模式
switch (specMode) {
// (1) 父容器是精准测量模式
case MeasureSpec.EXACTLY:
// 子 View 设定了具体的尺寸，即我们在 xml 布局中指定了具体的 dp，子 View 的尺寸就是childDimension，测量模式为 EXACTLY
if (childDimension >= 0) {
resultSize = childDimension;
resultMode = MeasureSpec.EXACTLY;
} else if (childDimension == LayoutParams.MATCH_PARENT) {
// 子 View 在 xml 中设定的是 match_parent,这时子 View 的大小就是父容器大小，即 size，测量模式为 EXACTLY
resultSize = size;
resultMode = MeasureSpec.EXACTLY;
} else if (childDimension == LayoutParams.WRAP_CONTENT) {
// 子 View 在 xml 中设定的是 wrap_content,这时子 View 的大小不能超过父容器大小，即 size，测量模式为 AT_MOST
resultSize = size;
resultMode = MeasureSpec.AT_MOST;
}
break;
// (2) 父容器是 AT_MOST
case MeasureSpec.AT_MOST:
if (childDimension >= 0) {
// 子 View 设定了具体的尺寸，即我们在 xml 布局中指定了具体的 dp，子 View 的尺寸就是childDimension，测量模式为 EXACTLY
resultSize = childDimension;
resultMode = MeasureSpec.EXACTLY;
} else if (childDimension == LayoutParams.MATCH_PARENT) {
// 子 View 在 xml 中设定的是 match_parent,这时子 View 的大小不能超过父容器大小，即 size，测量模式为 AT_MOST
resultSize = size;
resultMode = MeasureSpec.AT_MOST;
} else if (childDimension == LayoutParams.WRAP_CONTENT) {
// 子 View 在 xml 中设定的是 wrap_content,这时子 View 的大小不能超过父容器大小，即 size，测量模式为 AT_MOST,可以看到父容器是 AT_MOST，子 View 如果不指定具体的数值，那么测量模式均为 AT_MOST，且大小为不超过父容器剩余空间的大小。
resultSize = size;
resultMode = MeasureSpec.AT_MOST;
}
break;
// (3) 父容器是 UNSPECIFIED 模式
case MeasureSpec.UNSPECIFIED:
if (childDimension >= 0) {
// 子 View 设定了具体的尺寸，即我们在 xml 布局中指定了具体的 dp，子 View 的尺寸就是childDimension，测量模式为 EXACTLY
resultSize = childDimension;
resultMode = MeasureSpec.EXACTLY;
} else if (childDimension == LayoutParams.MATCH_PARENT) {
// 父容器是 UNSPECIFIED 模式，子 View 一般为 0 
resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
resultMode = MeasureSpec.UNSPECIFIED;
} else if (childDimension == LayoutParams.WRAP_CONTENT) {
// 父容器是 UNSPECIFIED 模式，子 View 一般为 0 
resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
resultMode = MeasureSpec.UNSPECIFIED;
}
break;
}
return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
}

1
2
3
4
(1) 当子 View 是具体的数值时，无论父 View 是哪种测量模式，子 View 测量模式都是 EXACTLY，大小是子 View 设定的大小。
(2) 当父容器是 EXACTLY 模式，子 View 的 LayoutParams 的布局格式是 match_parent，子 View 测量模式是 EXACTLY，大小是父容器剩余大小。
(3) 当子 View 的 LayoutParams 的布局格式是 wrap_content，子 View 测量模式都是 AT_MOST，大小是父容器剩余大小。

1
2
3
(1) 单一 View 的测量过程，这个过程相对简单，通过 onMeasure 方法就完成了测量过程。
(2) ViewGroup 测量过程，ViewGroup 除了要完成自己的测量之外，还需要遍历完成各个子 View 的测量，这样才算测量过程。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
...
if (forceLayout || needsLayout) {
...
int cacheIndex = forceLayout ? -1 : mMeasureCache.indexOfKey(key);
if (cacheIndex < 0 || sIgnoreMeasureCache) {
onMeasure(widthMeasureSpec, heightMeasureSpec);
} else {
long value = mMeasureCache.valueAt(cacheIndex);
// Casting a long to int drops the high 32 bits, no mask needed
setMeasuredDimensionRaw((int) (value >> 32), (int) value);
mPrivateFlags3 |= PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
}
...
}
...
}

1
2
3
4
5
6

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
protected final void setMeasuredDimension(int measuredWidth, int measuredHeight) {
boolean optical = isLayoutModeOptical(this);
if (optical != isLayoutModeOptical(mParent)) {
Insets insets = getOpticalInsets();
int opticalWidth
= insets.left + insets.right;
int opticalHeight = insets.top
+ insets.bottom;
measuredWidth
+= optical ? opticalWidth
: -opticalWidth;
measuredHeight += optical ? opticalHeight : -opticalHeight;
}
setMeasuredDimensionRaw(measuredWidth, measuredHeight);
}
private void setMeasuredDimensionRaw(int measuredWidth, int measuredHeight) {
mMeasuredWidth = measuredWidth;
mMeasuredHeight = measuredHeight;
mPrivateFlags |= PFLAG_MEASURED_DIMENSION_SET;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// 设置 wrap_content 的默认宽 / 高值
// 可根据需要自己调整具体的数值
int mWidth = 200;
int mHeight =200;
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
// 获取宽-测量规则的模式和大小
int widthMode = MeasureSpec.getMode(widthMeasureSpec);
int widthSize = MeasureSpec.getSize(widthMeasureSpec);
// 获取高-测量规则的模式和大小
int heightMode = MeasureSpec.getMode(heightMeasureSpec);
int heightSize = MeasureSpec.getSize(heightMeasureSpec);
// 当布局参数设置为 wrap_content 时，设置默认值
if (getLayoutParams().width == ViewGroup.LayoutParams.WRAP_CONTENT && getLayoutParams().height == ViewGroup.LayoutParams.WRAP_CONTENT) {
setMeasuredDimension(mWidth, mHeight);
// 其中一个布局参数为 wrap_content 时，设置默认值
} else if (getLayoutParams().width == ViewGroup.LayoutParams.WRAP_CONTENT) {
setMeasuredDimension(mWidth, heightSize);
} else if (getLayoutParams().height == ViewGroup.LayoutParams.WRAP_CONTENT) {
setMeasuredDimension(widthSize, mHeight);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 遍历所有子 View，对所有子 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 的 measure 方法
protected void measureChild(View child, int parentWidthMeasureSpec,
int parentHeightMeasureSpec) {
final LayoutParams lp = child.getLayoutParams();
// 获取子 View 的 LayoutParams,并结合父容器的 MeasureSpec，来得到子 View 的 MeasureSpec
final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
mPaddingLeft + mPaddingRight, lp.width);
final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
mPaddingTop + mPaddingBottom, lp.height);
// 最终调用的是子 View 的 measure 方法
child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
if (mOrientation == VERTICAL) {
measureVertical(widthMeasureSpec, heightMeasureSpec);
} else {
measureHorizontal(widthMeasureSpec, heightMeasureSpec);
}
}
// 以垂直方向上为例进行主要部分的分析
void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {
mTotalLength = 0;
int maxWidth = 0;
int childState = 0;
int alternativeMaxWidth = 0;
int weightedMaxWidth = 0;
boolean allFillParent = true;
float totalWeight = 0;
final int count = getVirtualChildCount();
final int widthMode = MeasureSpec.getMode(widthMeasureSpec);
final int heightMode = MeasureSpec.getMode(heightMeasureSpec);
...
// 对每个子 View 进行测量
for (int i = 0; i < count; ++i) {
final View child = getVirtualChildAt(i);
// 子 View 为空，measureNullChild 实际也是 0
if (child == null) {
mTotalLength += measureNullChild(i);
continue;
}
// 当子 View 不显示时，不进行测量
if (child.getVisibility() == View.GONE) {
i += getChildrenSkipCount(child, i);
continue;
}
...
final int usedHeight = totalWeight == 0 ? mTotalLength : 0;
// 测量子 View
measureChildBeforeLayout(child, i, widthMeasureSpec, 0,
heightMeasureSpec, usedHeight);
final int childHeight = child.getMeasuredHeight();
// 在垂直方向上相加，同时需要考虑子 View 上下方向的 margin 以及 两个子 View 的间隔
final int totalLength = mTotalLength;
mTotalLength = Math.max(totalLength, totalLength + childHeight + lp.topMargin +
lp.bottomMargin + getNextLocationOffset(child));
}
...
// 需要 ViewGroup 自身的 Padding 值
maxWidth += mPaddingLeft + mPaddingRight;
// Check against our minimum width
maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());
// 保存测量值
setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
heightSizeAndState);
}

1
2
3
4
5
6
7
8
9
10
@Override
public void onWindowFocusChanged(boolean hasWindowFocus) {
super.onWindowFocusChanged(hasWindowFocus);
if(hasWindowFocus){
// view 可以通过 findViewById 的方式
int width = view.getMeasuredWidth();
int height = view.getMeasuredHight();
}
}

1
2
3
4
5
6
7
8
9
10
11
12
protected void onStart(){
super.onStart();
view.post(new Runnable() {
@Override
public void run() {
// view 可以通过 findViewById 的方式
int width = view.getMeasuredWidth();
int height = view.getMeasuredHight();
}
});
}

1
2
3
4
5
6
7
@Override
public void draw(Canvas canvas) {
super.draw(canvas);
int width = view.getMeasuredWidth();
int height = view.getMeasuredHight();
}

1
2
3
4
5
6
7
8

@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
super.onSizeChanged(w, h, oldw, oldh);
mWidth = w;
nHeight = h;
}