Android View 全解析(二) -- OnMeasure

| PV()
android
OnMeasure, view, window

MeasureSpec 的定义与实现

在上篇文章中，介绍了 view 与窗口系统的关系，以及在这个系统中是怎么触发 View 的三类重要事件的。接下来说说，三类事件中 onMeasure 事件，并以 FrameLayout 的 onMeasure 为例详细说明 measure 过程是如何进行的。

首先先看看 performTraversals 里是如何进行 Measure 过程的。由于这个方法代码繁多，这里只展示与 Measure 过程相关的代码。

1
2
3
4
int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);

performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);

首先说明一下这里的 MeasureSpec 是什么，这里是利用了位运算，将一个 int 类型包含了两种信息，分别是 size 和 mode。java 的 int 类型，可以表示 32 位数字，最高的两位数字用来表示 mode，其余的部分用来表示 size。对于手机屏幕而言，size 一般都优先，不用担心需要 31 位数字来表达 size 的情况。

MeasureSpec 分别有三种 mode，分别是 UNSPECIFIED, EXACTLY 和 AT_MOST.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
 * Measure specification mode: The parent has not imposed any constraint
 * on the child. It can be whatever size it wants.
 */
public static final int UNSPECIFIED = 0 << MODE_SHIFT;

/**
 * Measure specification mode: The parent has determined an exact size
 * for the child. The child is going to be given those bounds regardless
 * of how big it wants to be.
 */
public static final int EXACTLY     = 1 << MODE_SHIFT;

/**
 * Measure specification mode: The child can be as large as it wants up
 * to the specified size.
 */
public static final int AT_MOST     = 2 << MODE_SHIFT;

UNSPECIFIED: 标明自身对 View 大小没有任何限制，需要子 View 的信息来帮助协定

EXACTLY: View 已经确定自身的大小

AT_MOST: 父 View 已经限定了最大大小，具体 View 能不能超过这个限制，得看不同 View 的实现情况。

而对于 Size 而言，就是具体的数值大小了。Android 提供了生成 MeasureSpec 的静态方法。

1
2
3
4
5
6
7
public static int makeMeasureSpec(int size, int mode) {
    if (sUseBrokenMakeMeasureSpec) {
        return size + mode;
    } else {
        return (size & ~MODE_MASK) | (mode & MODE_MASK);
    }
}

至此，我们知道了 MeasureSpec 可以用来表征一个 View 的大小信息，接下来的章节看看，这些信息是如何应用的。

DecorView 的 MeasureSpec

回到最开始的代码片段，我们看看 getRootMeasureSpec 是如何实现的，通过这个方法我们就可以知道 DecorView 是如何定义自己的大小的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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;
}

从上面的代码中，我们可以看到 DecorView 的大小是与 Window 的大小和 layoutParams 相关的，如果是 MATCH_PARENT, 那么 DecorView 的 MeasureSpec 就是精确的 Window 大小。接下来看看 windowSize， rootDimension 是怎么赋值的？我这里直接贴代码。

1
2
3
4
5
6
7
8
9
final WindowManager.LayoutParams mWindowAttributes = new WindowManager.LayoutParams();

final WindowManager.LayoutParams lp = mWindowAttributes;

public LayoutParams() {
    super(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
    type = TYPE_APPLICATION;
    format = PixelFormat.OPAQUE;
}

从这里可以看到默认情况下，window 的 LayoutParams 就是 MATCH_PARENT, 这样 DecorView 的大小就是 Window 的大小。

View 的 Measure 实现

接着看最开始代码中 performMeasure 的实现。

1
2
3
4
5
6
7
8
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 方法里面。注意到下面的代码签名，使用了 final 关键字，这样任何继承自 View 的类都不能复写这个方法，因为在这个类中涉及到了 Measure 的重要流程，如果这个过程被打断，那么会导致整个流程失败，因而这里添加 final 关键字是很有必要的。代码中还省略了部分与缓存相关的代码，代码中的重点在于 onMeasure 这个方法，一定要在这个方法中，指定 MeasureSpec，否则就不能知道 view 的大小了，后续的步骤也不能继续。

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
public final void measure(int widthMeasureSpec, int heightMeasureSpec) {

        // Suppress sign extension for the low bytes
        long key = (long) widthMeasureSpec << 32 | (long) heightMeasureSpec & 0xffffffffL;

        if ((mPrivateFlags & PFLAG_FORCE_LAYOUT) == PFLAG_FORCE_LAYOUT ||
                widthMeasureSpec != mOldWidthMeasureSpec ||
                heightMeasureSpec != mOldHeightMeasureSpec) {

            int cacheIndex = (mPrivateFlags & PFLAG_FORCE_LAYOUT) == PFLAG_FORCE_LAYOUT ? -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;
            }

            // flag not set, setMeasuredDimension() was not invoked, we raise
            // an exception to warn the developer
            if ((mPrivateFlags & PFLAG_MEASURED_DIMENSION_SET) != PFLAG_MEASURED_DIMENSION_SET) {
                throw new IllegalStateException("View with id " + getId() + ": "
                        + getClass().getName() + "#onMeasure() did not set the"
                        + " measured dimension by calling"
                        + " setMeasuredDimension()");
            }

            mPrivateFlags |= PFLAG_LAYOUT_REQUIRED;
        }

    }

我们先看看 onMeasure 的默认实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
            getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
}

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 的 mode 仍旧为 UNSPECIFIED，将其指定为最小size(可以人为指定，否则为0，或者背景的最小值)，否则为 measureSpec 中指定的大小。

ViewGroup 的 Measure 实现

相对复杂的是 ViewGroup，ViewGroup 继承自 View，但 View 的 measure 方法是 final 的，ViewGroup 需要自定义 measure 过程时就得复写 onMeasure 方法。每个 ViewGroup 的需求不同，很难统一起来讲，这里以 FrameLayout 为例，讲述它的 Measure 过程，毕竟这是几个官方 ViewGroup 中最简单的一个。

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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    int count = getChildCount();

    // 是否高或者宽位置
    final boolean measureMatchParentChildren =
            MeasureSpec.getMode(widthMeasureSpec) != MeasureSpec.EXACTLY ||
            MeasureSpec.getMode(heightMeasureSpec) != MeasureSpec.EXACTLY;
    // 清除原有保留的对象
    mMatchParentChildren.clear();

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

    // 遍历每一个 view
    for (int i = 0; i < count; i++) {
        final View child = getChildAt(i);
        // 如果高宽位置，或者 child 是可见的，那么就需要对 child 进行 measure
        if (mMeasureAllChildren || child.getVisibility() != GONE) {
            // 调用这个方法时，会让 child 自身进行测量
            // 参数中的两个 0，表示父 Parent 已经占用的空间，这里为 0
            // widthMeasureSpec 和 heightMeasureSpec 分别是父 Parent 的 高宽 MeasureSpec
            measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, 0);
            // 经过 Measure 过程后，就能知道自己的 LayoutParams
            // LayoutParams 含有了自己的宽高信息
            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) {
                    // 要对 MatchParent 的做特殊处理，下面的代码可以看到
                    mMatchParentChildren.add(child);
                }
            }
        }
    }

    // Account for padding too
    // 加上前景的上下左右 padding
    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());
    }

    // 设置自身的 measureSpec
    // resolveSizeAndState 是 view 提供的静态方法，返回对应的 measureSpec
    setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
            resolveSizeAndState(maxHeight, heightMeasureSpec,
                    childState << MEASURED_HEIGHT_STATE_SHIFT));

    // 处理每个 LayoutParams 中含有 MATCH_PARENT 的情况。
    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();

            final int childWidthMeasureSpec;
            if (lp.width == LayoutParams.MATCH_PARENT) {
                // // MATCH_PARENT 的宽度设置为最大宽度
                final int width = Math.max(0, getMeasuredWidth()
                        - getPaddingLeftWithForeground() - getPaddingRightWithForeground()
                        - lp.leftMargin - lp.rightMargin);
                childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(
                        width, MeasureSpec.EXACTLY);
            } else {
                // 返回其默认的情况
                childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec,
                        getPaddingLeftWithForeground() + getPaddingRightWithForeground() +
                        lp.leftMargin + lp.rightMargin,
                        lp.width);
            }

            final int childHeightMeasureSpec;
            if (lp.height == LayoutParams.MATCH_PARENT) {
                final int height = Math.max(0, getMeasuredHeight()
                        - getPaddingTopWithForeground() - getPaddingBottomWithForeground()
                        - lp.topMargin - lp.bottomMargin);
                childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(
                        height, MeasureSpec.EXACTLY);
            } else {
                childHeightMeasureSpec = getChildMeasureSpec(heightMeasureSpec,
                        getPaddingTopWithForeground() + getPaddingBottomWithForeground() +
                        lp.topMargin + lp.bottomMargin,
                        lp.height);
            }

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

大部分代码都通过注释精选了说明，这里就自定义 View 中常用的几个 static 方法进行简单的说明，方便读者有一个大题的认识。

  • measureChildWithMargins
    要求 child 进行 Measure，在绘制的时候将自己的 padding 和 margins 考虑进去。经过 Measure 过后，可以得到对应的 LayoutParams
    这个方法要求 child 必须得是 MarginLayoutParams，大部分的容器 View (LinearLayout、FrameLayout等等)都是这个 MarginLayoutParams.

  • measureChild
    这个方法与前面这个是相对的，不同之处在于只考虑自身的 padding，不考虑 margin。

  • measureChildren
    对所有可见 view 调用 measureChild 方法。

  • getChildMeasureSpec
    这个是上述方法都会调用的方法，分别有三个参数，当前view的measureSpec, 当前view 的 padding(或者加上margin), 当前 view 期望的大小(不一定会实现)。

方法根据特定的规则来返回对应的 MeasureSpec，这是蔚为重要的一个方法。对应的规则简单如下：

child-measure

参考文献：

  1. http://ezio.farbox.com/post/android-view-measure-1
  2. http://www.liaohuqiu.net/posts/how-does-android-caculate-the-size-of-child-view/
  3. http://blog.qiji.tech/archives/7740

文档信息