1、ViewRoot 和DecorView
ViewRoot 对应于 ViewRootImpl，是连接WindowManager 和DecorView 的纽带，View 的三大流程均是通过ViewRoot 来完成的。在ActivityThread 中，当Activity 对象被创建完毕后，会将DecorView 添加到 Window 中， 同时创建ViewRootImpl 对象，并将 ViewRootImpl 对象和DecorView 建立关联，这个过程可参考如下源码:
root = new ViewRootImpl(view.getContext(),display); root.setView(view,wparams,panelParentView);
View 的绘制流程是从 ViewRoot 的 performTraversals 方法开始的，它经过measure（测量）、layout（布局）、draw（绘制） 三个过程才最终将一个 View 绘制出来，performTraversals 的大致流程如下：
如图所示，performTraversals 会依次调用 performMeasure、performLayout、performDraw 三个方法， 这三个方法分别完成顶级 View 的measure、layout、draw三个流程，其中 performMeasure 中会调用 measure 方法，在measure 方法中又会调用 onMeasure 方法，在 onMeasure 方法中会对所有的子元素进行 measure 过程，此时 measure 流程就从父容器传递到子元素中了，这样就完成了一次 measure 过程，接着子元素会重复父容器的 measure 过程，如此反复就完成了整个View 树的遍历。performLayout、performDraw 同理。
MeasureSpec：
MeasureSpec是一个32位的int值，高2位代表模式（SpecMode），低30位代表具体的值（SpecSize），为了提高并优化效率采用了位与运算。
MeasureSpce 源码：
public static class MeasureSpec {
private static final int MODE_SHIFT = 30;
private static final int MODE_MASK = 0x3 << MODE_SHIFT;
/** @hide */
@IntDef({UNSPECIFIED, EXACTLY, AT_MOST})
@Retention(RetentionPolicy.SOURCE)
public @interface MeasureSpecMode {}
public static final int UNSPECIFIED = 0 << MODE_SHIFT;
public static final int EXACTLY = 1 << MODE_SHIFT;
public static final int AT_MOST = 2 << MODE_SHIFT;
public static int makeMeasureSpec(@IntRange(from = 0, to = (1 << MeasureSpec.MODE_SHIFT) - 1) int size,
@MeasureSpecMode int mode) {
if (sUseBrokenMakeMeasureSpec) {
return size + mode;
} else {
return (size & ~MODE_MASK) | (mode & MODE_MASK);
}
}
public static int makeSafeMeasureSpec(int size, int mode) {
if (sUseZeroUnspecifiedMeasureSpec && mode == UNSPECIFIED) {
return 0;
}
return makeMeasureSpec(size, mode);
}
@MeasureSpecMode
public static int getMode(int measureSpec) {
//noinspection ResourceType
return (measureSpec & MODE_MASK);
}
public static int getSize(int measureSpec) {
return (measureSpec & ~MODE_MASK);
}
static int adjust(int measureSpec, int delta) {
final int mode = getMode(measureSpec);
int size = getSize(measureSpec);
if (mode == UNSPECIFIED) {
// No need to adjust size for UNSPECIFIED mode.
return makeMeasureSpec(size, UNSPECIFIED);
}
size += delta;
if (size < 0) {
Log.e(VIEW_LOG_TAG, "MeasureSpec.adjust: new size would be negative! (" + size +
") spec: " + toString(measureSpec) + " delta: " + delta);
size = 0;
}
return makeMeasureSpec(size, mode);
}
/**
* Returns a String representation of the specified measure
* specification.
*
* @param measureSpec the measure specification to convert to a String
* @return a String with the following format: "MeasureSpec: MODE SIZE"
*/
public static String toString(int measureSpec) {
int mode = getMode(measureSpec);
int size = getSize(measureSpec);
StringBuilder sb = new StringBuilder("MeasureSpec: ");
if (mode == UNSPECIFIED)
sb.append("UNSPECIFIED ");
else if (mode == EXACTLY)
sb.append("EXACTLY ");
else if (mode == AT_MOST)
sb.append("AT_MOST ");
else
sb.append(mode).append(" ");
sb.append(size);
return sb.toString();
}
}
测量模式（SpecMode）有三种，如下所示：
- EXACTLY(精确测量)： 对应布局中控件的 layout_width 或 layout_height 属性指定了具体的数值，或指定为match_parent属性时的模式。
- AT_MOST(最大值)： 对应布局中控件的 layout_width 或 layout_height 属性指定为wrap_content时。
- UNSPECIFIED(不确定)：不指定View大小测量模式，View可以想多大就多大，这种情况一般用于系统内部，表示测量的状态。
View 的默认 onMeasure()方法 只支持 EXACTLY 测量模式，该模式下不用重写 onMeasure() 方法，即 View 的宽高是精确的，如果是其它模式，则必须重写 onMeasure() 方法
重写onMeaseur() 中会调用父类的 setMeasureDimension(int measuredWidth，int measureHeight)方法，将测量后的宽高设置进去，完成测量的工作。
1、MeasureSpec 和 LayoutParams 的关系：
LayoutParams 需要和父容器一起才能决定View 的MeasureSpec，从而进一步决定View 的宽高。对于顶级View（即DecorView）和普通View来说，MeasureSpec 的转换过程略有不同。对于DecorView ，其MeasureSpec 由窗口尺寸和其自身的 LayoutParams 来共同确定；对于普通View 来说，其MeasureSpec 由父容器的 MeasureSpec 和自身的 LayoutParams 来共同决定， MeasureSpec 一旦确定后， onMeasure 中就可以确定 View 的测量宽高。
DecorView：
在ViewRootImpl 中的 measureHierarchy 方法中的如下代码展示了 DecorView 的MeasureSpec 的创建过程，其中 desiredWindowWidth、desiredWindowHeight 是屏幕的尺寸
childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth, lp.width);
childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height);
performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
接着看getRootMeasureSpec 方法的实现
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 的MeasureSpec 的产生过程遵循如下规则，根据它的 LayoutParams 中的宽高的参数来划分：
- LayoutParams.MATCH_PARENT：精确模式，大小就是窗口的大小
- LayoutParams.WRAP_CONTENT：最大模式，大小不定，但不能超过窗口的大小
- 固定大小（比如100dp）：精确模式，大小为LayoutParams 中指定的大小
对于普通View 来说，View 的measure过程由 ViewGroup 传递而来，先看下ViewGroup 的measureVhildWithMargins 方法：
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);
}
从上述代码可知，子元素的MeasureSpec 的创建与父容器的 MeasureSpec 和子元素本身的 LayoutParams 有关，还和View 的 margin及 padding 有关，具体情况可以看一下ViewGroup 的 getChildMeasureSpec 方法，如下所示：
public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
int specMode = MeasureSpec.getMode(spec);
int specSize = MeasureSpec.getSize(spec);
int size = Math.max(0, specSize - padding);
int resultSize = 0;
int resultMode = 0;
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);
}
上述方法主要是根据父容器的MeasureSpec 同时结合View 自身的 LayoutParams 来确定子元素的 MeasureSpec，参数中 padding 是指父容器中已占用的空间大小，因此子元素的可用大小为父容器的尺寸减去 padding，具体代码如下所示：
int specSize = MeasureSpec.getSize(spec);
int size = Math.max(0, specSize - padding);
下表是针对 getChildMeasureSpec 的工作原理做的梳理，parentSize 是指父容器中目前可使用的大小
扫描二维码关注公众号，回复：
1694472 查看本文章
表1 普通View 的 MeasureSpec 的创建规则
由表中可知，
- 如果View 的宽高为精确值，则其大小为 LayoutParams 中的大小
- 如果View 的宽高是 match_parent 时，View 的模式和父容器的模式一致，且其大小为父容器的剩余空间
- 如果View 的宽高是 wrap_content 时，不管父容器为何种模式，View 都是最大模式，且其大小为父容器的剩余空间
View 的工作流程：
View 的工作流程主要是指measure（测量）、layout（布局）、draw（绘制） 这三大流程，其中 measure 确定View 的测量宽高，layout 确定 View 的最终宽高和四个顶点的位置，draw 则将 View 绘制到屏幕上。
View 的 measure 过程
View的 measure 过程由其 measure 方法来完成，measure 方法是一个 final 类型方法，在其中会调用Viw 的onMeasure 方法，onMeasure 方法如下所示：
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
}
在onMeasure 方法中，会调用setMeasuredDimension 方法设置View 宽高的测量值，其中getDefaultSize 方法如下所示：
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;
}
由上可以看出，AT_MOST、EXACTLY 这两种情况下，getDefaultSize 方法返回的大小就是measureSpec 中的 specSize（就是View 测量后的大小），这里多次提到测量后的大小，是因为View 的最终大小是在layout 阶段确定的。
UNSPECIFIED情况一般用于系统内部的测量过程，在这种情况下，View 的大小为
getDefaultSize 的第一个参数，即宽高分别为getSuggestedMinimumWidth、getSuggestedMinimumHeight 方法的返回值，它们的源码如下所示：
protected int getSuggestedMinimumWidth() {
return (mBackground == null) ? mMinWidth : max(mMinWidth, mBackground.getMinimumWidth());
}
protected int getSuggestedMinimumHeight() {
return (mBackground == null) ? mMinHeight : max(mMinHeight, mBackground.getMinimumHeight());
}
从上述代码中可以看出，如果View 没有设置背景，则View 的宽度为 mMinWidth，而mMinWidth 对应于 android:minWidth 属性所制定的值，故View 的宽度即为 android:minWidth 属性所指定的值。如果这个属性不指定，则mMinWidth 默认为0；如果View指定了背景，则 View 的宽度为 max(mMinWidth, mBackground.getMinimumWidth())中的最大值，getMinimumWidth 的源码如下：
public int getMinimumWidth() {
final int intrinsicWidth = getIntrinsicWidth();
return intrinsicWidth > 0 ? intrinsicWidth : 0;
}
getMinimumWidth 返回的就是Drawable 的原始宽度，前提是这个Drawable 有原始宽度，否则就返回0。
Drawable 什么情况下由原始宽度？比如ShapeDrawable 无原始宽高，而BitmapDrawable 有原始宽高（图片的尺寸）
总结：
从getDefualSize 方法的实现来看，View 的宽高有specSize 决定，结合上述表1 普通View 的 MeasureSpec 的创建规则我们可以得出如下结论：
直接继承View 的自定义控件需要重写 onMeasure 方法，并设置 wrap_content时的View 的自身大小，否则在布局中使用 wrap_content 就相当于使用 match_parent。
如何解决这个问题，代码如下：
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);
int widthSpecSize = MeasureSpec.getSize(widthMeasureSpec);
int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);
int heightSpecSize = MeasureSpec.getSize(heightMeasureSpec);
if (widthSpecMode == MeasureSpec.AT_MOST && heightSpecMode == MeasureSpec.AT_MOST) {
setMeasuredDimension(mWidth, mHeigth);
} else if (widthSpecMode == MeasureSpec.AT_MOST) {
setMeasuredDimension(mWidth,heightSpecSize);
} else if (heightSpecMode==MeasureSpec.AT_MOST) {
setMeasuredDimension(widthSpecSize,mHeight);
}
}
中mWidth、mHeight 为View 的默认宽高
ViewGroup 的 measure 过程其
对于ViewGroup来说，不仅要完成自己的 measure 过程，还要遍历去调用所有子元素的 measure 方法，各个子元素再递归去执行这个过程。和View 不同的是，ViewGroup 是一个抽象类，没有重写View 的onMeasure 方法，但提供了一个叫 measureChildern 的方法，如下所示：
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);
}
}
}
从源码中可知，ViewGroup 在 measure 时，会对每一个子元素进行 measure，其中 measureChild 源码如下：
protected void measureChild(View child, int parentWidthMeasureSpec,
int parentHeightMeasureSpec) {
final LayoutParams lp = child.getLayoutParams();
final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
mPaddingLeft + mPaddingRight, lp.width);
final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
mPaddingTop + mPaddingBottom, lp.height);
child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}
measureChild 的主要作用就是获取子元素的 LayoutParams，然后通过 getChildMeasureSpec 构建子元素的 MeasureSpec，最后将获取的 MeasureSpec 直接传递给View 的measure 方法进行测量。
ViewGroup 并没有定义其测量的具体过程，这是因为ViewGroup 是一个抽象类，其测量过程的 onMeasure 方法需要各个子类去具体实现，比如LinearLayout、RelativeLayout等，因为不同的ViewGroup 子类具有不同的布局特性，这导致它们的测量细节各不相同，比如LinearLayout 和RelativeLayout 两者的布局特性明显不同，因此ViewGroup 无法统一实现onMeasure 方法。
下面是LinearLayout 的onMeasure 方法来分析ViewGroup 的measure 过程
LinearLayout 的onMeasure 方法：
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
if (mOrientation == VERTICAL) {
measureVertical(widthMeasureSpec, heightMeasureSpec);
} else {
measureHorizontal(widthMeasureSpec, heightMeasureSpec);
}
}
上述代码是针对不同布局的不同测量方法， 我们选竖直布局的LinearLayout 的测量过程，即measureVertical 方法，如下：
void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {
...
// See how tall everyone is. Also remember max width.
for (int i = 0; i < count; ++i) {//遍历测量子元素
final View child = getVirtualChildAt(i);
if (child == null) {
mTotalLength += measureNullChild(i);
continue;
}
if (child.getVisibility() == View.GONE) {//子元素隐藏，跳过
i += getChildrenSkipCount(child, i);
continue;
}
nonSkippedChildCount++;
if (hasDividerBeforeChildAt(i)) {//测量子元素之间的间隔
mTotalLength += mDividerHeight;
}
final LayoutParams lp = (LayoutParams) child.getLayoutParams();//获取子元素的 LayoutParams
totalWeight += lp.weight;
final boolean useExcessSpace = lp.height == 0 && lp.weight > 0;
//根据不同的测量模式获取子元素的高河竖直方向上的 margin
if (heightMode == MeasureSpec.EXACTLY && useExcessSpace) {
...
}else {
...
measureChildBeforeLayout(child, i, widthMeasureSpec, 0,
heightMeasureSpec, usedHeight);
...
}
//测量自己的大小
// Add in our padding
mTotalLength += mPaddingTop + mPaddingBottom;
int heightSize = mTotalLength;
// Check against our minimum height
heightSize = Math.max(heightSize, getSuggestedMinimumHeight());
...
maxWidth += mPaddingLeft + mPaddingRight;
// Check against our minimum width
maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());
setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
heightSizeAndState);
if (matchWidth) {
forceUniformWidth(count, heightMeasureSpec);
}
}
上述代码中可以看出，首先系统会遍历子元素并对每个子元素执行measureChildBeforeLayout方法，这个方法内部会调用子元素的measure 方法，这样各个子元素会依次进入自己的measure过程，系统会通过 mTotalLength 这个变量来存储 LinearLayout 在竖直方向上的高度，该高度为子元素的高度和竖直方向上的 margin等，测量完子元素后，LinearLayout 会根据子元素的情况测量自己的大小，同时根据LayoutParams 中布局模式，获取不同的高度总和，最终高度还需要考虑竖直方向上的 padding 值，此过程如下所示：
public static int resolveSizeAndState(int size, int measureSpec, int childMeasuredState) {
final int specMode = MeasureSpec.getMode(measureSpec);
final int specSize = MeasureSpec.getSize(measureSpec);
final int result;
switch (specMode) {
case MeasureSpec.AT_MOST:
if (specSize < size) {
result = specSize | MEASURED_STATE_TOO_SMALL;
} else {
result = size;
}
break;
case MeasureSpec.EXACTLY:
result = specSize;
break;
case MeasureSpec.UNSPECIFIED:
default:
result = size;
}
return result | (childMeasuredState & MEASURED_STATE_MASK);
}
View 的measure 过程是三大流程中最复杂的一个，measure 完成以后，通过getMeasureWidth/Height 方法可以正确的获取到View 的测量宽高。但是在某些极端的情况下，系统可能需要多次measure 才能确定最终的测量宽高，在这种情形下，在onMeasure 方法中拿到的测量宽高很可能是不准确的，建议在onLayout 中去获取 View 的测量宽高或最终宽高。
场景：比如我们想在Activity 已启动的时候就做一件任务，这个任务需要获取到某个View 的宽高。
因为View 的measure 过程和 Activity 的生命周期方法不是同步执行的，因此无法保证Activity 执行了 onCreat、onStart、onResume 时某个View 已经测量完毕了，如果View 还没测量完毕，则获取的宽高就是0；故在Activity 的onCreat、onStart、onResume中无法正确的获取到View 的宽高，但可通过以下四种方法解决这个问题：
1）、Activity/View#onWindowFocusChange
onWindowFocusChange 含义：View 已经初始化完毕，宽高已经准备好了，此时去获取View 的宽高是没问题的。但需注意，onWindowFocusChange 会被调用多次，当Activity 的窗口得到焦点和失去焦点时均会被调用一次。即当Activity 频繁的进行onResume 和 onPause时，onWindowFocusChange也会被频繁的调用，典型代码如下：
@Override
public void onWindowFocusChanged(boolean hasFocus) {
super.onWindowFocusChanged(hasFocus);
if (hasFocus) {
int width = view.getMeasuredWidth();
int height = view.getMeasuredHeight();
}
}
2）、view.post(runnable)
通过 post 可以讲一个runnable 投递到消息队列的尾部，然后等待 Looper 调用此 runnable 的时候，View 也已经初始化好了，典型代码如下：
@Override
protected void onStart() {
super.onStart();
view.post(new Runnable() {
@Override
public void run() {
int width = view.getMeasuredWidth();
int height = view.getMeasuredHeight();
}
});
}
3)、ViewTreeObserver
使用 ViewTreeObserver 的总舵回调可以完成这个功能，比如使用 addOnGlobalLayoutListener 这个家口，当View 树的状态发生改变或者 View 树内部的View 可见性发生改变时，onGlobalLayout方法会被回调，因此这是获取 View 的宽高一个很好的时机。但需注意，伴随着View 树的状态改变等，onGlobalLayout 会被多次调用。典型代码如下所示：
@Override
protected void onStart() {
super.onStart();
ViewTreeObserver viewTreeObserver = view.getViewTreeObserver();
viewTreeObserver.addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
@Override
public void onGlobalLayout() {
view.getViewTreeObserver().removeOnGlobalLayoutListener(this);
int width = view.getMeasuredWidth();
int height = view.getMeasuredHeight();
}
});
}
4）、view.measure(int widthMeasureSpec, int heightMeasureSpec)
通过手动对View 进行measure 来得到 View 的宽高，这种方法比较复杂，需要根据View 的LayoutParams 来分情况处理：
match_parent
直接放弃，无法measure 出具体的宽高，因为根据View 的measure 过程，如上表1 所述，构造此种MeasureSpec 需要知道 parentSize，即父容器的剩余空间，而这时我们无法知道parentSize 的大小，所以理论上不可能测量出 View 的大小。
具体的数值（dp/px）
比如宽高都是100 px，如下measure：
int widthMeasureSpec = MeasureSpec.makeMeasureSpec(100, MeasureSpec.EXACTLY);
int heightMeasureSpec = MeasureSpec.makeMeasureSpec(100, MeasureSpec.EXACTLY);
view.measure(widthMeasureSpec, heightMeasureSpec);
wrap_content
如下 measure：
int widthMeasureSpec = MeasureSpec.makeMeasureSpec((1<<30)-1, MeasureSpec.AT_MOST);
int heightMeasureSpec = MeasureSpec.makeMeasureSpec((1<<30)-1, MeasureSpec.AT_MOST);
view.measure(widthMeasureSpec, heightMeasureSpec);
这里的 (1<<30)-1 是View的尺寸使用30位二进制表示，即最大值就是(1<<30)-1，在最大化模式下，我们使用理论上View能支持的最大值去构造MeasureSpec是合理的。
layout 过程：
Layout 的作用是ViewGroup 用来确定子元素位置的，当 ViewGroup 的位置被确定为后，在它的onLayout 中会遍历所有的子元素并调用它们的 拉有方法，在layout 方法中又会调用自己的 onLayout方法，最终确定自身的位置，View 的layout 方法如下所示：
@SuppressWarnings({"unchecked"})
public void layout(int l, int t, int r, int b) {
if ((mPrivateFlags3 & PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT) != 0) {
onMeasure(mOldWidthMeasureSpec, mOldHeightMeasureSpec);
mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
}
int oldL = mLeft;
int oldT = mTop;
int oldB = mBottom;
int oldR = mRight;
//setFrame(l, t, r, b) 方法设定 View 的四个顶点
boolean changed = isLayoutModeOptical(mParent) ?
setOpticalFrame(l, t, r, b) : setFrame(l, t, r, b);
if (changed || (mPrivateFlags & PFLAG_LAYOUT_REQUIRED) == PFLAG_LAYOUT_REQUIRED) {
onLayout(changed, l, t, r, b);//调用 onLayout 方法
if (shouldDrawRoundScrollbar()) {
if(mRoundScrollbarRenderer == null) {
mRoundScrollbarRenderer = new RoundScrollbarRenderer(this);
}
} else {
mRoundScrollbarRenderer = null;
}
mPrivateFlags &= ~PFLAG_LAYOUT_REQUIRED;
ListenerInfo li = mListenerInfo;
if (li != null && li.mOnLayoutChangeListeners != null) {
ArrayList<OnLayoutChangeListener> listenersCopy =
(ArrayList<OnLayoutChangeListener>)li.mOnLayoutChangeListeners.clone();
int numListeners = listenersCopy.size();
for (int i = 0; i < numListeners; ++i) {
listenersCopy.get(i).onLayoutChange(this, l, t, r, b, oldL, oldT, oldR, oldB);
}
}
}
mPrivateFlags &= ~PFLAG_FORCE_LAYOUT;
mPrivateFlags3 |= PFLAG3_IS_LAID_OUT;
if ((mPrivateFlags3 & PFLAG3_NOTIFY_AUTOFILL_ENTER_ON_LAYOUT) != 0) {
mPrivateFlags3 &= ~PFLAG3_NOTIFY_AUTOFILL_ENTER_ON_LAYOUT;
notifyEnterOrExitForAutoFillIfNeeded(true);
}
}
layout 方法的大致流程如下：首先会通过 setFrame 方法来设置View 的四个顶点的位置，即初始化 mLeft 、mTop、mRight 、mBottom；
View 的四个顶点位置确定后，View 在父容器中的位置也就确定了。接着会调用onLayout 方法，这个方法的用途是父容器确定子元素的位置，它是一个抽象方法，它的具体实现和具体的布局有关。
setFrame 源码：
protected boolean setFrame(int left, int top, int right, int bottom) {
boolean changed = false;
if (DBG) {
Log.d("View", this + " View.setFrame(" + left + "," + top + ","
+ right + "," + bottom + ")");
}
if (mLeft != left || mRight != right || mTop != top || mBottom != bottom) {
changed = true;
// Remember our drawn bit
int drawn = mPrivateFlags & PFLAG_DRAWN;
int oldWidth = mRight - mLeft;
int oldHeight = mBottom - mTop;
int newWidth = right - left;
int newHeight = bottom - top;
boolean sizeChanged = (newWidth != oldWidth) || (newHeight != oldHeight);
// Invalidate our old position
invalidate(sizeChanged);
//初始化赋值
mLeft = left;
mTop = top;
mRight = right;
mBottom = bottom;
mRenderNode.setLeftTopRightBottom(mLeft, mTop, mRight, mBottom);
mPrivateFlags |= PFLAG_HAS_BOUNDS;
if (sizeChanged) {
sizeChange(newWidth, newHeight, oldWidth, oldHeight);
}
if ((mViewFlags & VISIBILITY_MASK) == VISIBLE || mGhostView != null) {
// If we are visible, force the DRAWN bit to on so that
// this invalidate will go through (at least to our parent).
// This is because someone may have invalidated this view
// before this call to setFrame came in, thereby clearing
// the DRAWN bit.
mPrivateFlags |= PFLAG_DRAWN;
invalidate(sizeChanged);
// parent display list may need to be recreated based on a change in the bounds
// of any child
invalidateParentCaches();
}
// Reset drawn bit to original value (invalidate turns it off)
mPrivateFlags |= drawn;
mBackgroundSizeChanged = true;
mDefaultFocusHighlightSizeChanged = true;
if (mForegroundInfo != null) {
mForegroundInfo.mBoundsChanged = true;
}
notifySubtreeAccessibilityStateChangedIfNeeded();
}
return changed;
}
下面是LinearLayout 的 onLayout 方法：
@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
if (mOrientation == VERTICAL) {
layoutVertical(l, t, r, b);
} else {
layoutHorizontal(l, t, r, b);
}
}
layoutVertical 的源码：
void layoutVertical(int left, int top, int right, int bottom) {
final int paddingLeft = mPaddingLeft;
int childTop;
int childLeft;
// Where right end of child should go
final int width = right - left;
int childRight = width - mPaddingRight;
// Space available for child
int childSpace = width - paddingLeft - mPaddingRight;
final int count = getVirtualChildCount();
final int majorGravity = mGravity & Gravity.VERTICAL_GRAVITY_MASK;
final int minorGravity = mGravity & Gravity.RELATIVE_HORIZONTAL_GRAVITY_MASK;
switch (majorGravity) {
case Gravity.BOTTOM:
// mTotalLength contains the padding already
childTop = mPaddingTop + bottom - top - mTotalLength;
break;
// mTotalLength contains the padding already
case Gravity.CENTER_VERTICAL:
childTop = mPaddingTop + (bottom - top - mTotalLength) / 2;
break;
case Gravity.TOP:
default:
childTop = mPaddingTop;
break;
}
//遍历子元素
for (int i = 0; i < count; i++) {
final View child = getVirtualChildAt(i);
if (child == null) {
childTop += measureNullChild(i);
} else if (child.getVisibility() != GONE) {
//子元素的宽高
final int childWidth = child.getMeasuredWidth();
final int childHeight = child.getMeasuredHeight();
//获取子元素的 LayoutParams
final LinearLayout.LayoutParams lp =
(LinearLayout.LayoutParams) child.getLayoutParams();
int gravity = lp.gravity;
if (gravity < 0) {
gravity = minorGravity;
}
final int layoutDirection = getLayoutDirection();
final int absoluteGravity = Gravity.getAbsoluteGravity(gravity, layoutDirection);
switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
case Gravity.CENTER_HORIZONTAL:
childLeft = paddingLeft + ((childSpace - childWidth) / 2)
+ lp.leftMargin - lp.rightMargin;
break;
case Gravity.RIGHT:
childLeft = childRight - childWidth - lp.rightMargin;
break;
case Gravity.LEFT:
default:
childLeft = paddingLeft + lp.leftMargin;
break;
}
if (hasDividerBeforeChildAt(i)) {
childTop += mDividerHeight;
}
childTop += lp.topMargin;
//设置子元素的位置，内部会调用子元素的layou 方法
setChildFrame(child, childLeft, childTop + getLocationOffset(child),
childWidth, childHeight);
childTop += childHeight + lp.bottomMargin + getNextLocationOffset(child);
i += getChildrenSkipCount(child, i);
}
}
}
从上述代码中可看出，layoutVertical 首先会遍历所有子元素并调用setChildFrame 方法来为子元素指定位置，其中 childTop 会逐渐增大，意味着后面的子元素会被放置在靠下的位置，刚好符合竖直方向的LinearLayout 特性，同时setChildFrame 方法内部会调用子元素的 layout 方法，由前面可知，layout 方法会调用内部的 onLayout 方法来确定自己的位置，就这样一层层传递下去完成整个Viw 树的 layou过程。
setChildFrame源码：
private void setChildFrame(View child, int left, int top, int width, int height) {
child.layout(left, top, left + width, top + height);
}
getWidth/getHeight 源码：
@ViewDebug.ExportedProperty(category = "layout")
public final int getWidth() {
return mRight - mLeft;
}
/**
* Return the height of your view.
*
* @return The height of your view, in pixels.
*/
@ViewDebug.ExportedProperty(category = "layout")
public final int getHeight() {
return mBottom - mTop;
}
从源码我们可以得知，getWidth/getHeight 获取的值就是View 的测量宽高，但在某些情况下我们可以改变getWidth/getHeight 的返回值，如下所示：
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
super.onLayout(changed, left, top, right+100, bottom+100);
}
这样我们通过getWidth/getHeight 获取的View 的宽高和View 测量的宽高就会不一致
Tip：getMeasuredWidth/getMeasuredHeight 和 getWidth/getHeight 的区别？
getMeasuredWidth/getMeasuredHeight 在View 的 measure 流程中被赋值，getWidth/getHeight 在View 的layout 流程中被赋值，默认情况下两者的值相等，但在 layout 流程中可以改变View 的最终 宽高，
draw 过程
draw过程的作用是将View 绘制到屏幕上，View 的绘制过程遵循如下几步：
- 绘制背景 background.draw(canvas)
- 会致自己 onDraw
- 绘制 children（dispatchDraw）
- 绘制装饰（onDrawForeground(canvas)）
这一点从draw 的源码可以看出，源码如下：
public void draw(Canvas canvas) {
final int privateFlags = mPrivateFlags;
final boolean dirtyOpaque = (privateFlags & PFLAG_DIRTY_MASK) == PFLAG_DIRTY_OPAQUE &&
(mAttachInfo == null || !mAttachInfo.mIgnoreDirtyState);
mPrivateFlags = (privateFlags & ~PFLAG_DIRTY_MASK) | PFLAG_DRAWN;
/*
* Draw traversal performs several drawing steps which must be executed
* in the appropriate order:
*
* 1. Draw the background
* 2. If necessary, save the canvas' layers to prepare for fading
* 3. Draw view's content
* 4. Draw children
* 5. If necessary, draw the fading edges and restore layers
* 6. Draw decorations (scrollbars for instance)
*/
// Step 1, draw the background, if needed
int saveCount;
if (!dirtyOpaque) {
drawBackground(canvas);//绘制背景
}
// skip step 2 & 5 if possible (common case)
final int viewFlags = mViewFlags;
boolean horizontalEdges = (viewFlags & FADING_EDGE_HORIZONTAL) != 0;
boolean verticalEdges = (viewFlags & FADING_EDGE_VERTICAL) != 0;
if (!verticalEdges && !horizontalEdges) {
// Step 3, draw the content
if (!dirtyOpaque) onDraw(canvas);//绘制自己
// Step 4, draw the children
dispatchDraw(canvas);//绘制子元素
drawAutofilledHighlight(canvas);
// Overlay is part of the content and draws beneath Foreground
if (mOverlay != null && !mOverlay.isEmpty()) {
mOverlay.getOverlayView().dispatchDraw(canvas);
}
// Step 6, draw decorations (foreground, scrollbars)
onDrawForeground(canvas);//绘制装饰
// Step 7, draw the default focus highlight
drawDefaultFocusHighlight(canvas);
if (debugDraw()) {
debugDrawFocus(canvas);
}
// we're done...
return;
}
/*
* Here we do the full fledged routine...
* (this is an uncommon case where speed matters less,
* this is why we repeat some of the tests that have been
* done above)
*/
boolean drawTop = false;
boolean drawBottom = false;
boolean drawLeft = false;
boolean drawRight = false;
float topFadeStrength = 0.0f;
float bottomFadeStrength = 0.0f;
float leftFadeStrength = 0.0f;
float rightFadeStrength = 0.0f;
// Step 2, save the canvas' layers
int paddingLeft = mPaddingLeft;
final boolean offsetRequired = isPaddingOffsetRequired();
if (offsetRequired) {
paddingLeft += getLeftPaddingOffset();
}
int left = mScrollX + paddingLeft;
int right = left + mRight - mLeft - mPaddingRight - paddingLeft;
int top = mScrollY + getFadeTop(offsetRequired);
int bottom = top + getFadeHeight(offsetRequired);
if (offsetRequired) {
right += getRightPaddingOffset();
bottom += getBottomPaddingOffset();
}
final ScrollabilityCache scrollabilityCache = mScrollCache;
final float fadeHeight = scrollabilityCache.fadingEdgeLength;
int length = (int) fadeHeight;
// clip the fade length if top and bottom fades overlap
// overlapping fades produce odd-looking artifacts
if (verticalEdges && (top + length > bottom - length)) {
length = (bottom - top) / 2;
}
// also clip horizontal fades if necessary
if (horizontalEdges && (left + length > right - length)) {
length = (right - left) / 2;
}
if (verticalEdges) {
topFadeStrength = Math.max(0.0f, Math.min(1.0f, getTopFadingEdgeStrength()));
drawTop = topFadeStrength * fadeHeight > 1.0f;
bottomFadeStrength = Math.max(0.0f, Math.min(1.0f, getBottomFadingEdgeStrength()));
drawBottom = bottomFadeStrength * fadeHeight > 1.0f;
}
if (horizontalEdges) {
leftFadeStrength = Math.max(0.0f, Math.min(1.0f, getLeftFadingEdgeStrength()));
drawLeft = leftFadeStrength * fadeHeight > 1.0f;
rightFadeStrength = Math.max(0.0f, Math.min(1.0f, getRightFadingEdgeStrength()));
drawRight = rightFadeStrength * fadeHeight > 1.0f;
}
saveCount = canvas.getSaveCount();
int solidColor = getSolidColor();
if (solidColor == 0) {
final int flags = Canvas.HAS_ALPHA_LAYER_SAVE_FLAG;
if (drawTop) {
canvas.saveLayer(left, top, right, top + length, null, flags);
}
if (drawBottom) {
canvas.saveLayer(left, bottom - length, right, bottom, null, flags);
}
if (drawLeft) {
canvas.saveLayer(left, top, left + length, bottom, null, flags);
}
if (drawRight) {
canvas.saveLayer(right - length, top, right, bottom, null, flags);
}
} else {
scrollabilityCache.setFadeColor(solidColor);
}
// Step 3, draw the content
if (!dirtyOpaque) onDraw(canvas);
// Step 4, draw the children
dispatchDraw(canvas);
// Step 5, draw the fade effect and restore layers
final Paint p = scrollabilityCache.paint;
final Matrix matrix = scrollabilityCache.matrix;
final Shader fade = scrollabilityCache.shader;
if (drawTop) {
matrix.setScale(1, fadeHeight * topFadeStrength);
matrix.postTranslate(left, top);
fade.setLocalMatrix(matrix);
p.setShader(fade);
canvas.drawRect(left, top, right, top + length, p);
}
if (drawBottom) {
matrix.setScale(1, fadeHeight * bottomFadeStrength);
matrix.postRotate(180);
matrix.postTranslate(left, bottom);
fade.setLocalMatrix(matrix);
p.setShader(fade);
canvas.drawRect(left, bottom - length, right, bottom, p);
}
if (drawLeft) {
matrix.setScale(1, fadeHeight * leftFadeStrength);
matrix.postRotate(-90);
matrix.postTranslate(left, top);
fade.setLocalMatrix(matrix);
p.setShader(fade);
canvas.drawRect(left, top, left + length, bottom, p);
}
if (drawRight) {
matrix.setScale(1, fadeHeight * rightFadeStrength);
matrix.postRotate(90);
matrix.postTranslate(right, top);
fade.setLocalMatrix(matrix);
p.setShader(fade);
canvas.drawRect(right - length, top, right, bottom, p);
}
canvas.restoreToCount(saveCount);
drawAutofilledHighlight(canvas);
// Overlay is part of the content and draws beneath Foreground
if (mOverlay != null && !mOverlay.isEmpty()) {
mOverlay.getOverlayView().dispatchDraw(canvas);
}
// Step 6, draw decorations (foreground, scrollbars)
onDrawForeground(canvas);
if (debugDraw()) {
debugDrawFocus(canvas);
}
}
View 的绘制过程的传递是通过 dispatchDraw 来实现的，dispatchDraw 会遍历所有子元素的 draw 方法，如此 draw 事件就一层一层的传递下去。
View 有一个特殊的方法，setWillNotDraw 源码如下：
/**
* If this view doesn't do any drawing on its own, set this flag to
* allow further optimizations. By default, this flag is not set on
* View, but could be set on some View subclasses such as ViewGroup.
*
* Typically, if you override {@link #onDraw(android.graphics.Canvas)}
* you should clear this flag.
*
* @param willNotDraw whether or not this View draw on its own
*/
public void setWillNotDraw(boolean willNotDraw) {
setFlags(willNotDraw ? WILL_NOT_DRAW : 0, DRAW_MASK);
}
这个方法表示，如果一个View 不需要绘制任何内容，那么设置这个标记位为 true 后，系统会进行相应的优化。默认情况下，View 没有启用这个优化标记位，但是ViewGroup 会默认启用这个优化标记位。
这个标记位对实际开发的意义是：当我们的自定义控件继承于 ViewGroup 并且本身不具备绘制功能时，就可以开启这个标记位从而便于系统进行后续的优化。当明确知道一个ViewGroup 需要通过onDraw 来绘制内容时，我们需要显示地关闭 WILL_NOT_DRAW 这个标记位。