一、前言
在 Android 知识体系中，View 是很重要的角色，因此 View 的工作原理是非常有必要去了解的，本章我们讲解 View 的工作原理中的第一个环节 ：measure。
二、MeasureSpec
2.1 MeasureSpec 简介
MeasureSpec 代表测量规格，是一个 32 位的 int 值，高 2 位代表 SpecMode（测量模式），低 30 位代表 SpecSize（测量大小）。
MeasureSpec 通过将 SpecMode 和 SpecSize 打包成一个 int 值来避免过多的内存分配，并提供了打包和解包的方法。我们可以通过以下代码获取宽高的 SpecMode 和 Spec Size。
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
int widthMode = MeasureSpec.getMode(widthMeasureSpec);
int widthSize = MeasureSpec.getSize(widthMeasureSpec);
int heightMode = MeasureSpec.getMode(heightMeasureSpec);
int heightSize = MeasureSpec.getSize(heightMeasureSpec);
...
}SpecMode 有三种，如下：
2.2 MeasureSpec 值的计算
View 的 MeasureSpec 值是由 View 的布局参数和父容器 的 MeasureSpec 值计算而来。具体计算逻辑封装在父容器即 ViewGroup 的 getChildMeasureSpec() 方法里。MeasureSpec 一旦确定后，onMeasure() 方法中就可以确定 View 的测量宽、高。
下面我们来看 getChildMeasureSpec() 中是如何计算的 ：
/**
* 源码分析：getChildMeasureSpec（）
* 作用：根据父视图的MeasureSpec & 布局参数LayoutParams，计算单个子View的MeasureSpec
* 注：子view的大小由父view的MeasureSpec值 和 子view的LayoutParams属性 共同决定
* 参数说明
* @param spec 父view的详细测量值 (MeasureSpec)
* @param padding view当前尺寸的的内边距和外边距(padding, margin)
* @param childDimension 子视图的布局参数（宽 / 高）
**/
public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
//父view的测量模式
int specMode = MeasureSpec.getMode(spec);
//父view的大小
int specSize = MeasureSpec.getSize(spec);
//通过父view计算出的子view = 父大小-边距（父要求的大小，但子view不一定用这个值）
int size = Math.max(0, specSize - padding);
//子view想要的实际大小和模式（需要计算）
int resultSize = 0;
int resultMode = 0;
//通过父view的MeasureSpec和子view的LayoutParams确定子view的大小
// 当父view的模式为EXACITY时，父view强加给子view确切的值
//一般是父view设置为match_parent或者固定值的ViewGroup
switch (specMode) {
case MeasureSpec.EXACTLY:
// 当子view的LayoutParams>0，即有确切的值
if (childDimension >= 0) {
//子view大小为子自身所赋的值，模式大小为EXACTLY
resultSize = childDimension;
resultMode = MeasureSpec.EXACTLY;
// 当子view的LayoutParams为MATCH_PARENT时(-1)
} else if (childDimension == LayoutParams.MATCH_PARENT) {
//子view大小为父view大小，模式为EXACTLY
resultSize = size;
resultMode = MeasureSpec.EXACTLY;
// 当子view的LayoutParams为WRAP_CONTENT时(-2)
} else if (childDimension == LayoutParams.WRAP_CONTENT) {
//子view决定自己的大小，但最大不能超过父view，模式为AT_MOST
resultSize = size;
resultMode = MeasureSpec.AT_MOST;
}
break;
// 当父view的模式为AT_MOST时，父view强加给子view一个最大的值。（一般是父view设置为wrap_content）
case MeasureSpec.AT_MOST:
// 道理同上
if (childDimension >= 0) {
resultSize = childDimension;
resultMode = MeasureSpec.EXACTLY;
} else if (childDimension == LayoutParams.MATCH_PARENT) {
resultSize = size;
resultMode = MeasureSpec.AT_MOST;
} else if (childDimension == LayoutParams.WRAP_CONTENT) {
resultSize = size;
resultMode = MeasureSpec.AT_MOST;
}
break;
// 当父view的模式为UNSPECIFIED时，父容器不对view有任何限制，要多大给多大
// 多见于ListView、GridView
case MeasureSpec.UNSPECIFIED:
if (childDimension >= 0) {
// 子view大小为子自身所赋的值
resultSize = childDimension;
resultMode = MeasureSpec.EXACTLY;
} else if (childDimension == LayoutParams.MATCH_PARENT) {
// 因为父view为UNSPECIFIED，所以MATCH_PARENT的话子类大小为0
resultSize = 0;
resultMode = MeasureSpec.UNSPECIFIED;
} else if (childDimension == LayoutParams.WRAP_CONTENT) {
// 因为父view为UNSPECIFIED，所以WRAP_CONTENT的话子类大小为0
resultSize = 0;
resultMode = MeasureSpec.UNSPECIFIED;
}
break;
}
return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
}上面的计算过程总结下来就是下面这张表：
可以总结出规律：
上述计算过程是针对普通 View 的，如果是顶级 View（即 DecorVIew），它的计算逻辑取决于自身布局参数 & 窗口尺寸。
三、measure 过程解析
measure 过程分为 View 和 ViewGroup 两种类型：
3.1 View 的 measure 过程
View 的 measure 过程由其 measure() 方法完成：
/**
* 源码分析：measure（）
* 定义：Measure过程的入口；属于View.java类 & final类型，即子类不能重写此方法
* 作用：基本测量逻辑的判断
**/
public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
// 参数说明：View的宽 / 高测量规格
...
onMeasure(widthMeasureSpec, heightMeasureSpec);
...
}
/**
* 分析1：onMeasure（）
* 作用：a. 根据View宽/高的测量规格计算View的宽/高值：getDefaultSize()
* b. 存储测量后的View宽 / 高：setMeasuredDimension()
**/
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
// 参数说明：View的宽 / 高测量规格
setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
// setMeasuredDimension() ：获得View宽/高的测量值 ->>分析2
// 传入的参数通过getDefaultSize()获得 ->>分析3
}setMeasuredDimension() 方法会设置 View 的宽/高的测量值，因此我们只需要看 getDefaultSize() 方法即可：
/**
* @param size 提供的默认大小
* @param measureSpec 宽/高的测量规格
*/
public static int getDefaultSize(int size, int measureSpec) {
// 设置默认大小
int result = size;
// 获取宽/高测量规格的模式 & 测量大小
int specMode = MeasureSpec.getMode(measureSpec);
int specSize = MeasureSpec.getSize(measureSpec);
switch (specMode) {
// 模式为UNSPECIFIED时，使用提供的默认大小 = 参数Size
case MeasureSpec.UNSPECIFIED:
result = size;
break;
// 模式为AT_MOST,EXACTLY时，使用View测量后的宽/高值 = measureSpec中的Size
case MeasureSpec.AT_MOST:
case MeasureSpec.EXACTLY:
result = specSize;
break;
}
// 返回View的宽/高值
return result;
} 可以看到当模式是 UNSPECIFIED 时，使用的是提供的默认大小（即第一个参数 size），即 getDefaultSize() 中传入的默认大小是 getSuggestedMinimumWidth()、getSuggestedMinimumHeight()。我们只看其中一个即可：
protected int getSuggestedMinimumWidth() {
return (mBackground == null) ? mMinWidth : max(mMinWidth,mBackground.getMinimumWidth());
}从代码可以看出：
- 若 View 无设置背景，那么 View 的宽度 = mMinWidth。mMinWidth 为 android:minWidth 属性所指定的值，默认为 0。
- 若 View设置了背景，View 的宽度为 mMinWidth 和 mBackground.getMinimumWidth() 中的最大值。
mBackgroud.getMinimumWidth() 是什么呢，我们继续跟进到 Drawble 的 getMinimumWidth() 方法去看看：
public int getMinimumWidth() {
final int intrinsicWidth = getIntrinsicWidth();
//返回背景图Drawable的原始宽度
return intrinsicWidth > 0 ? intrinsicWidth :0 ;
}由源码可知：mBackground.getMinimumWidth() 的大小 = 背景图 Drawable 的原始宽度，若这个 Drawable 无原始宽度，则为0。举个例子 BitmapDrawable 有原始宽度（图片的尺寸），而 ShapeDrawable 没有。
在 getDefaultSize() 方法中我们可以看到，如果 View 在布局中使用使用 wrap_content，根据表1可知它的 specMode 是 AT_MOST 模式，在这种模式下它的 specSize 是 parentSize，而 parentSize 是父容器中目前可以使用的大小，也就是父容器当前剩余的空间大小。很显然 View 的宽高就等于父容器当前剩余的空间大小，这种效果和在布局中使用 match_parent 完全一致。所以我们得出结论：直接继承 View 的自定义控件需要重写 onMeasure() 方法并设置 wrap_content 时的自身大小，否则在布局中使用 wrap_content 就相当于使用 match_parent。
总结一下 getDefaultSize() 计算宽/高值的逻辑：
至此，View 的宽/高值已经测量完成，即对于 View 的 measure 过程已经完成。流程如下：
实际作用的方法：getDefaultSize() = 计算 View 的宽/高值、setMeasuredDimension() = 存储测量后的 View 宽 / 高
3.2 ViewGroup 的 measure 过程
对于 ViewGroup 来说，除了完成自己的 measure 过程以外，还会遍历去调用所有子元素的 measure 方法，各个子元素再递归去执行这个过程。和 View 不同的是，ViewGroup 是一个抽象类，因此它没有重写 View 的 onMeasure() 方法。但它提供了 measureChildren() 方法。
onMeasure() 的作用是测量 View 的宽高值，而不同的 ViewGroup 子类（LinearLayout、RelativeLayout、自定义 ViewGroup 子类等）具备不同的布局特性，这导致它们的子 View 的测量方法各有不同。这也是 View 与 ViewGroup 的 measure 过程最大的不同，其次，在 View 的 measure 过程中，getDefaultSize() 方法只是简单的测量了宽高值，在实际使用时有时需要更精细的测量，所以有时候也需要重写 onMeasure()。
根据自身需求的测量逻辑复写 onMeasure()，步骤分为 3 步：
- 遍历所有子 View & 测量：measureChildren()
- 合并所有子 View 的尺寸大小，最终得到 ViewGroup 的测量值（需自身实现）
- 存储测量后 View 宽/高的值：调用 setMeasuredDimension()
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
// 定义存放测量后的View宽/高的变量
int widthMeasure ;
int heightMeasure ;
// 1. 遍历所有子 View & 测量(measureChildren())
measureChildren(widthMeasureSpec, heightMeasureSpec)；
// 2. 合并所有子View的尺寸大小，最终得到ViewGroup父视图的测量值
// 需自身实现
measureMerge();
// 3. 存储测量后View宽/高的值：调用setMeasuredDimension()
// 类似单一View的过程，此处不作过多描述
setMeasuredDimension(widthMeasure, heightMeasure);
}从上可看出，复写 onMeasure() 有三步，其中两步是直接调用系统方法，需我们自身实现的功能仅为步骤2。我们看下 measureChildren() 方法：
protected void measureChildren(int widthMeasureSpec, int heightMeasureSpec) {
// 参数说明：父视图的测量规格（MeasureSpec）
final int size = mChildrenCount;
final View[] children = mChildren;
// 遍历所有子view
for (int i = 0; i < size; ++i) {
final View child = children[i];
// 调用 measureChild() 进行下一步的测量
if ((child.mViewFlags & VISIBILITY_MASK) != GONE) {
measureChild(child, widthMeasureSpec, heightMeasureSpec);
}
}
}上述代码会遍历子 View 并且调用 measureChild() 进行下一步测量，我们跟进去看看：
protected void measureChild(View child, int parentWidthMeasureSpec,int parentHeightMeasureSpec) {
// 1. 获取子视图的布局参数
final LayoutParams lp = child.getLayoutParams();
// 2. 根据父视图的MeasureSpec & 布局参数LayoutParams，计算单个子View的MeasureSpec
// 获取 ChildView 的 widthMeasureSpec
final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,mPaddingLeft + mPaddingRight, lp.width);
// 获取 ChildView 的 heightMeasureSpec
final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,mPaddingTop + mPaddingBottom, lp.height);
// 3. 将计算好的子View的MeasureSpec值传入measure()，进行最后的测量
// 下面的流程即类似单一View的过程，此处不作过多描述
child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}上述代码会计算单个子 View 的 MeasureSpec，调用子 View 的 measure() 测量每个子 View 最后的宽 / 高。
总结一下整体过程如下：
3.3 ViewGroup 子类（LinearLayout）的 measure 过程分析
我们直接看它的 onMeasure() 方法：
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
// 根据不同的布局属性进行不同的计算
if (mOrientation == VERTICAL) {
measureVertical(widthMeasureSpec, heightMeasureSpec);
} else {
measureHorizontal(widthMeasureSpec, heightMeasureSpec);
}
}可以看到，会根据 LinearLayout 的方向（vertical、horizontal）进入不同的测量过程，这里我们只选垂直方向的测量过程，即measureVertical()。
void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {
// 获取垂直方向上的子View个数
final int count = getVirtualChildCount();
// 遍历子View获取其高度，并记录下子View中最高的高度数值
for (int i = 0; i < count; ++i) {
final View child = getVirtualChildAt(i);
// 子View不可见，直接跳过该View的measure过程，getChildrenSkipCount()返回值恒为0
// 注：若view的可见属性设置为VIEW.INVISIBLE，还是会计算该view大小
if (child.getVisibility() == View.GONE) {
i += getChildrenSkipCount(child, i);
continue;
}
// 记录子View是否有weight属性设置，用于后面判断是否需要二次measure
totalWeight += lp.weight;
if (heightMode == MeasureSpec.EXACTLY && lp.height == 0 && lp.weight > 0) {
// 如果LinearLayout的specMode为EXACTLY且子View设置了weight属性，在这里会跳过子View的measure过程
// 同时标记skippedMeasure属性为true，后面会根据该属性决定是否进行第二次measure
// 若LinearLayout的子View设置了weight，会进行两次measure计算，比较耗时
// 这就是为什么LinearLayout的子View需要使用weight属性时候，最好替换成RelativeLayout布局
final int totalLength = mTotalLength;
mTotalLength = Math.max(totalLength, totalLength + lp.topMargin + lp.bottomMargin);
skippedMeasure = true;
} else {
int oldHeight = Integer.MIN_VALUE;
// 步骤1：遍历所有子View & 测量：measureChildren（）
// 注：该方法内部，最终会调用measureChildren（），从而 遍历所有子View & 测量
measureChildBeforeLayout(child, i, widthMeasureSpec, 0, heightMeasureSpec, totalWeight == 0 ? mTotalLength : 0);
...
//步骤2：合并所有子View的尺寸大小,最终得到ViewGroup父视图的测量值（自身实现）
final int childHeight = child.getMeasuredHeight();
// 1. mTotalLength用于存储LinearLayout在竖直方向的高度
final int totalLength = mTotalLength;
// 2. 每测量一个子View的高度， mTotalLength就会增加
mTotalLength = Math.max(totalLength, totalLength + childHeight + lp.topMargin +
lp.bottomMargin + getNextLocationOffset(child));
}
}
// 3. 记录LinearLayout占用的总高度
// 即除了子View的高度，还有本身的padding属性值
mTotalLength += mPaddingTop + mPaddingBottom;
int heightSize = mTotalLength;
int heightSizeAndState = resolveSizeAndState(heightSize, heightMeasureSpec, 0);
//步骤3：存储测量后View宽/高的值：调用setMeasuredDimension()
setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState), heightSizeAndState);
...
}
四、获取 View 的宽高
View 的 measure 过程是三大流程中最复杂的一个，measure 完成以后，通过 getMeasuredWidth/Height 方法就可以正确地获取到 View 的测量宽/高。需要注意的是，在某些极端情况下，系统可能需要多次 measure() 才能确定最终的测量宽/高，在这种情形下，在 onMeasure() 方法中拿到的测量宽/高很可能是不准确的。一个比较好的习惯是在 onLayout 方法中去获取 View 的测量宽/高或最终宽/高。
Activity 启动时，在 onCreate()、onStart()、onResume() 中均无法正确的得到某个 View 的宽高信息，这是因为 View 的 measure 过程和 Activity 的生命周期方法不是同步执行的，因此无法保证 Activity 执行了 onCreate()、onStart()、onResume() 时某个 View 已经测量完毕了，如果 View 还没有测量完毕，那么获得的宽高就是 0。因此我们只能通过其他方法来解决这个问题：
（1）Activity 的 onWindowFocusChanged()
onWindowFocusChanged() 这个方法的含义是 View 已经初始化完毕了，宽/高已经准备好了，这个时候去获取宽高是没有问题的。需要注意的是，onWindowFocusChanged() 会被调用多次，当 Activity 的窗口得到焦点和失去焦点时均会被调用一次。具体来说，当 Activity 继续执行和暂停执行时，onWindowFocusChanged() 均会被调用，如果频繁的执行 onResume() 和 onPause()，那么 onWindowFocusChanged() 也会被频繁的调用。使用如下：
@Override
public void onWindowFocusChanged(boolean hasWindowFocus) {
super.onWindowFocusChanged(hasWindowFocus);
if(hasWindowFocus){
int width = view.getMeasuredWidth();
int height = view.getMeasuredHeight();
}
}（2）View.post(runnable)
通过 post 可以将一个 runnable 投递到消息队列的尾部，然后等待 Looper 调用此 runnable 的时候，View 也已经初始化好了。使用如下：
mView.post(new Runnable() {
@Override
public void run() {
int width = mView.getMeasuredWidth();
int height = mView.getMeasuredHeight();
}
});（3）ViewTreeObserver
当View树的状态发生改变或者View树内部View的可见性发生改变的时候，onGlobalLayout将会被回调。注意：伴随着View树的状态改变，onGlobalLayout会被调用多次。实现如下：
ViewTreeObserver observer = mView.getViewTreeObserver();
observer.addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
@Override
public void onGlobalLayout() {
mView.getViewTreeObserver().removeOnGlobalLayoutListener(this);
int width = mView.getMeasuredWidth();
int height = mView.getMeasuredHeight();
}
});（4）手动调用 View 的 measure 方法
手动调用 measure(int widthMeasureSpec, int heightMeasureSpec) 后，View会调用 onMeasure() 方法对 View 发起测量，测量完后，就可以获取测量后的宽度和高度了。但是要对 View 的 LayoutParams 的参数分情况处理才能得到具体的参数值：
match_parent：这种情况下无法获取到具体宽高值，因为当 View 的测量模式为 match_parent 时，宽高值是取父容器的剩余空间大小作为它自己的宽高。而这时无法获取到父容器的尺寸大小，因此获取会失败。
具体数值（dp/px）：
比如宽/高都是 100 px，如下 measure：
int width =View.MeasureSpec.makeMeasureSpec(100, View.MeasureSpec.EXACTLY);
int height =View.MeasureSpec.makeMeasureSpec(100, View.MeasureSpec.EXACTLY);
view.measure(width,height);
int height=view.getMeasuredHeight();
int width=view.getMeasuredWidth();wrap_content：
int width =View.MeasureSpec.makeMeasureSpec((1<<30)-1,View.MeasureSpec.AT_MOST);
int height =View.MeasureSpec.makeMeasureSpec((1<<30)-1,View.MeasureSpec.AT_MOST);
view.measure(width,height);
int height=view.getMeasuredHeight();
int width=view.getMeasuredWidth();
扫一扫
1320
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
