提起View的绘制流程，相信大家立刻就能想到耳熟闻详的三个方法：onMeasure（测量）、onLayout（布局）、onDraw（绘制），这三个方法的确参与了View的绘制流程，除此之外还有MeasureSpec、LayoutParams等等。今天笔者就带领大家由顶级View：DecorView开始，从上至下，将View的绘制流程整体贯穿一下，希望大家阅读完本文后都能有所收获。
了解Activity窗口机制的朋友们肯定知道，DecorView作为Activity的顶级View，它本身是一个FrameLayout，DecorView下只有一个直接的子View，那就是LinearLayout，该LinearLayout的排列方式为竖直排列，包括有标题栏和id为content的内容部分，我们在Activity的onCreate方法中通过setContentView加载的布局文件就是作为直接子View add到这个id为content的FrameLayout中。好了，在这里我新创建一个Activity，对应的布局文件如下，下面我们就以此为例，由DecorView开始，从上至下来分析下View的绘制流程。
View绘制流程的起点为ViewRootImpl类中的performTraversals()方法，我们打开源码看下（为了便于分析，源码有所删减）：
private void performTraversals() {
...
//1.获取DecorView的测量规则，其中mWidth为屏幕的宽度，mHeight为屏幕的高度
//lp为DecorView自身的布局参数LayoutParams
int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);
//2.完成整个ViewTree的测量工作
performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
...
//3.完成整个ViewTree的布局工作
performLayout(lp, mWidth, mHeight);
...
//4.完成整个ViewTree的绘制工作
performDraw();
}
可以看到，在performTraversals方法中，首先调用到getRootMeasureSpec方法，创建顶级View DecorView的测量规则，接着依次调用到performMeasure、performLayout、performDraw方法，分别完成整个ViewTree的测量、布局、以及绘制工作。
我们首先看下1处DecorView MeasureSpec的创建，在这里我先简单说一下，DecorView测量规则的创建和我们普通View（包括有View以及ViewGroup）测量规则的创建略有不同。对于DecorView而言，它的MeasureSpec是由窗口尺寸和它自身的LayoutParams共同决定的，而我们的普通View，它的MeasureSpec则是由父容器的MeasureSpec和它自身的LayoutParams共同决定的。这一点通过源码就可以看出来。1处调用到getRootMeasureSpec方法，完成DecorView MeasureSpec的创建，getRootMeasureSpec方法中传的第一个参数为屏幕的宽高，第二个参数为DecorView自身的LayoutParams，不知道你有没有好奇DecorView的布局参数具体是什么呢？我们点进去 lp ，看下它是在哪里赋值的：
private void performTraversals() {
...
WindowManager.LayoutParams lp = mWindowAttributes;
}
你没看错，就是在performTraversals方法中一开始赋值的，那 mWindowAttributes 又是在哪里赋值的呢，我们接着跟：
final WindowManager.LayoutParams mWindowAttributes = new WindowManager.LayoutParams();
mWindowAttributes 为ViewRootImpl类中定义的final类型的成员变量，我们跟进去WindowManager.LayoutParams：
# WindowManager
public static class LayoutParams extends ViewGroup.LayoutParams implements Parcelable {
...
public LayoutParams() {
super(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
type = TYPE_APPLICATION;
format = PixelFormat.OPAQUE;
}
...
}
这下真相大白了吧，DecorView的布局参数lp.width为MATCH_PARENT，lp.height为MATCH_PARENT。好了好了，我们接着回到performTraversals()中的1处，跟进去getRootMeasureSpec方法，看下DecorView的MeasureSpec具体是怎么创建的：
private static int getRootMeasureSpec(int windowSize, int rootDimension) {
int measureSpec;
switch (rootDimension) {
//1.
case ViewGroup.LayoutParams.MATCH_PARENT:
// Window can't resize. Force root view to be windowSize.
measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.EXACTLY);
break;
//2.
case ViewGroup.LayoutParams.WRAP_CONTENT:
// Window can resize. Set max size for root view.
measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.AT_MOST);
break;
//3.
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的创建过程就很明确了，由于DecorView的布局参数lp.width为MATCH_PARENT，lp.height为MATCH_PARENT，所以程序实际上只会走第一个case语句。即DecorView 宽度SpecMode为MeasureSpec.EXACTLY，SpecSize为屏幕宽度，高度SpecMode为MeasureSpec.EXACTLY，SpecSize为屏幕高度。
我们接着回到performTraversals方法中，接着就是2处的performMeasure方法，跟进去：
private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {
if (mView == null) {
return;
}
Trace.traceBegin(Trace.TRACE_TAG_VIEW, "measure");
try {
//重点
mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);
} finally {
Trace.traceEnd(Trace.TRACE_TAG_VIEW);
}
}
performMeasure方法中传入的第一个参数childWidthMeasureSpec就是decorview宽度测量规则，传入的第二个参数childHeightMeasureSpec就是decorview高度测量规则，mView就是我们的decorview对象，可以看到performMeasure方法中调用到decorview的measure方法，将decorview的宽度测量规则和高度测量规则直接作为参数传入。我们跟进去decorview的measure方法看下（DecorView本质为FrameLayout，FrameLayout继承自ViewGroup，ViewGroup继承自View类，实质调用到View类的measure方法）：
#View
public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
...
onMeasure(widthMeasureSpec, heightMeasureSpec);
...
}
接着跟进去decorview的onMeasure方法：
#DecorView
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
...
//重点，调用到FrameLayout的onMeasure方法
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
...
}
我们来到FrameLayout类的onMeasure方法看下：
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
//获取到子View的数量，在这里由于我们的decorview只有一个直接的子View，那就是一个竖直排列的LinearLayout，所以count为1
int count = getChildCount();
//由我们上述分析可知，decorview的宽度测量规则为MeasureSpec.EXACTLY，高度测量规则为MeasureSpec.EXACTLY
//所以在这里measureMatchParentChildren的值 计算为false
final boolean measureMatchParentChildren =
MeasureSpec.getMode(widthMeasureSpec) != MeasureSpec.EXACTLY ||
MeasureSpec.getMode(heightMeasureSpec) != MeasureSpec.EXACTLY;
//mMatchParentChildren为ArrayList，调用mMatchParentChildren.clear()方法后，mMatchParentChildren的size为0
mMatchParentChildren.clear();
// maxHeight 代表framelayout中最大高度
// maxWidth 代表framelayout中最大宽度
int maxHeight = 0;
int maxWidth = 0;
int childState = 0;
//遍历framelayout中的所有子View，完成以该framelayout对象为首的ViewTree，其下所有子View的测量工作
for (int i = 0; i < count; i++) {
final View child = getChildAt(i);
if (mMeasureAllChildren || child.getVisibility() != GONE) {
//1. 重点！！！对子View进行测量
measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, 0);
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
//由FrameLayout的布局特点决定，framelayout的宽度为所有子view的最大宽度（将子view的leftMargin 以及 rightMargin考虑在内）+ 该framelayout的leftpadding 和 rightpadding
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());
//在这里mMatchParentChildren 为false，所以 mMatchParentChildren的 size 一直为 0
if (measureMatchParentChildren) {
if (lp.width == LayoutParams.MATCH_PARENT ||
lp.height == LayoutParams.MATCH_PARENT) {
mMatchParentChildren.add(child);
}
}
}
}
//考虑到framelayout的padding
maxWidth += getPaddingLeftWithForeground() + getPaddingRightWithForeground();
maxHeight += getPaddingTopWithForeground() + getPaddingBottomWithForeground();
// 考虑到framelayout的最小宽度和高度
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());
}
//2. 设置framelayout的测量宽高，在这里为设置decorview的测量宽高
setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
resolveSizeAndState(maxHeight, heightMeasureSpec,
childState << MEASURED_HEIGHT_STATE_SHIFT));
count = mMatchParentChildren.size();
//在这里count为 0 ，if 语句代码块不执行
if (count > 1) {
...
}
}
上述代码中重点部分已经做了详细的标注，相信大家都能理解，在这里FrameLayout就是我们的decorview对象，其下只有一个子View，那就是一个竖直排列的LinearLayout。所以measureChildWithMargins方法在这里完成了decorview中LinearLayout对象的测量。我们跟进去measureChildWithMargins方法看下：
#ViewGroup类
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);
}
可以看到，在 measureChildWithMargins 方法中，首先获取到子View的LayoutParams，然后调用getChildMeasureSpec方法来创建子View的MeasureSpec，最后调用到子View的measure方法，将子View的MeasureSpec作为参数传入。同时我们还可以分析出，子View MeasureSpec的创建与父容器的MeasureSpec和子View本身的LayoutParams有关，除此之外，还与父容器的padding以及子View的margin有关。我们跟进去 getChildMeasureSpec方法，看下子View的MeasureSpec具体是怎么创建的：
public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
//获取到父容器的测量模式
int specMode = MeasureSpec.getMode(spec);
//获取到父容器的测量大小
int specSize = MeasureSpec.getSize(spec);
//padding指父容器中已占用空间大小，size为当前子View最大可用大小
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);
}
上述代码清楚展示了普通View的MeasureSpec的创建规则，在这里就不赘述了。
好了，我们回到measureChildWithMargins方法中接着往下看，在这里decorview中子View LinearLayout对象的MeasureSpec创建完毕后，后续调用到LinearLayout的measure方法，将LinearLayout的测量规则传入，我们跟进去：
#View 同样是调用到View类
public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
...
onMeasure(widthMeasureSpec, heightMeasureSpec);
...
}
由于LinearLayout重写了View类的onMeasure方法，所以我们跟进去LinearLayout的onMeasure方法看一下：
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
if (mOrientation == VERTICAL) {
measureVertical(widthMeasureSpec, heightMeasureSpec);
} else {
measureHorizontal(widthMeasureSpec, heightMeasureSpec);
}
}
由上述代码可以看到，在LinearLayout的onMeasure方法中首先对 mOrientation的值进行了判断，mOrientation代表当前LinearLayout的排列顺序，我们说过，decorview中的LinearLayout的排列方式为竖直排列，所以 mOrientation == VERTICAL 的值为 true，我们跟进去 measureVertical方法去看下：
void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {
// See how tall everyone is. Also remember max width.
for (int i = 0; i < count; ++i) {
...
//1.
measureChildBeforeLayout(child, i, widthMeasureSpec, 0,
heightMeasureSpec, usedHeight);
...
}
//2.
setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
heightSizeAndState);
...
}
在LinearLayout的 measureVertical 方法中，同样是首先遍历当前LinearLayout下的所有子View，调用 measureChildBeforeLayout 方法完成当前LinearLayout下所有子View的测量工作，最后调用到 setMeasuredDimension方法，设置自己的测量宽高。我们跟进去 measureChildBeforeLayout方法：
#LinearLayout
void measureChildBeforeLayout(View child, int childIndex,
int widthMeasureSpec, int totalWidth, int heightMeasureSpec,
int totalHeight) {
measureChildWithMargins(child, widthMeasureSpec, totalWidth,
heightMeasureSpec, totalHeight);
}
哈哈哈，LinearLayout的 measureChildBeforeLayout方法中同样是调用到ViewGroup类的 measureChildWithMargins方法，首先获取到子View的MeasureSpec，然后调用到子View的measure方法来完成子View的测量工作。由于当前LinearLayout对象为DecorView的直接子View，所以当前LinearLayout的子View就是titlebar标题栏和id为content的FrameLayout。后续的测量过程类似，在这里我就不再赘述了。。。
好了，我们回过头接着分析下decorview中LinearLayout测量完毕后的操作，那就是2处的setMeasuredDimension方法。setMeasuredDimension方法接收两个参数，第一个参数为measuredWidth，就是测量后的宽度，第二个参数为measuredHeight，就是测量后的高度。由上述代码可以看到，decorview宽高的测量值是由resolveSizeAndState方法决定的，我们跟进去看下：
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);
}
由于decorview的宽度SpecMode和高度SpecMode都为MeasureSpec.EXACTLY，宽度的SpecSize和高度SpecSize分别为 屏幕宽度 和
屏幕高度 ，所以针对decorview而言，在resolveSizeAndState方法中只会走 case MeasureSpec.EXACTLY:代码块，即将屏幕宽度和屏幕高度直接return掉，我们接着看下setMeasuredDimension方法：
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);
}
接着跟进去setMeasuredDimensionRaw方法：
private void setMeasuredDimensionRaw(int measuredWidth, int measuredHeight) {
mMeasuredWidth = measuredWidth;
mMeasuredHeight = measuredHeight;
mPrivateFlags |= PFLAG_MEASURED_DIMENSION_SET;
}
可以看到在setMeasuredDimensionRaw方法中直接将我们传进来的measuredWidth 和 measuredHeight分别赋值给 decorview的成员变量： mMeasuredWidth 和 mMeasuredHeight 。即decorview的测量宽度为屏幕宽度，测量高度为屏幕高度。
按照程序代码的执行流程，到此为止，整个ViewTree的测量工作就完毕了，接下来程序会回到 ViewRootImpl 类中的 performTraversals方法接着执行 3 处的performLayout方法，来完成整个ViewTree的布局工作。我们跟进去看下：
#ViewRootImpl
private void performLayout(WindowManager.LayoutParams lp, int desiredWindowWidth,
int desiredWindowHeight) {
mLayoutRequested = false;
mScrollMayChange = true;
mInLayout = true;
//首先判断decorview对象是否为null，如果decorview为null，直接return掉
final View host = mView;
if (host == null) {
return;
}
Trace.traceBegin(Trace.TRACE_TAG_VIEW, "layout");
try {
//重点！！！调用到decorview的layout方法
host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());
mInLayout = false;
...
}
} finally {
Trace.traceEnd(Trace.TRACE_TAG_VIEW);
}
mInLayout = false;
}
我们接着跟进去decorview的layout方法看下：
#ViewGroup类
//对View类的layout方法进行了重写，所以首先会调用到ViewGroup类中的layout方法
@Override
public final void layout(int l, int t, int r, int b) {
if (!mSuppressLayout && (mTransition == null || !mTransition.isChangingLayout())) {
if (mTransition != null) {
mTransition.layoutChange(this);
}
//调用到View类中的layout方法
super.layout(l, t, r, b);
} else {
// record the fact that we noop'd it; request layout when transition finishes
mLayoutCalledWhileSuppressed = true;
}
}
我们接着跟进去View类的layout方法：
#View
public void layout(int l, int t, int r, int b) {
...
//1.调用setFrame方法，确定View本身的位置，在这里是确定decorview自身的位置
boolean changed = isLayoutModeOptical(mParent) ?
setOpticalFrame(l, t, r, b) : setFrame(l, t, r, b);
if (changed || (mPrivateFlags & PFLAG_LAYOUT_REQUIRED) == PFLAG_LAYOUT_REQUIRED) {
//2.调用到onLayout方法，确定子View的位置，在这里是确定decorview下LinearLayout的位置
onLayout(changed, l, t, r, b);
...
}
}
我们首先跟进去1处的setFrame方法：
protected boolean setFrame(int left, int top, int right, int bottom) {
...
mLeft = left;
mTop = top;
mRight = right;
mBottom = bottom;
...
}
可以看到在setFrame方法中将我们传进来的left、top、right、bottom分别赋值给mLeft、mTop、mRight、mBottom。就这样，decorview的位置就确定了。我们回过头接着看 2处decorview的onLayout方法，跟进去看下：
#DecorView
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
//调用到FrameLayout类中的onLayout方法
super.onLayout(changed, left, top, right, bottom);
...
}
我们跟进去FrameLayout类中看下：
#FrameLayout
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
layoutChildren(left, top, right, bottom, false /* no force left gravity */);
}
接着跟进去layoutChildren方法：
#FrameLayout
void layoutChildren(int left, int top, int right, int bottom, boolean forceLeftGravity) {
//获取到framelayout中子View的数量
final int count = getChildCount();
//分别获取到子View的left、right、top、bottom的边界坐标区域，
//坐标系转换，以当前父容器的左上角为坐标系原点，水平向右为X轴正向，竖直向下为Y轴正向。
//在这里 layoutChildren 方法传入的 left、top、right、bottom的值是当前父容器作为子View相对于其父容器来讲的坐标值，经过相减操作后就将坐标系转换成以当前父容器为基准坐标系
final int parentLeft = getPaddingLeftWithForeground();
final int parentRight = right - left - getPaddingRightWithForeground();
final int parentTop = getPaddingTopWithForeground();
final int parentBottom = bottom - top - getPaddingBottomWithForeground();
for (int i = 0; i < count; i++) {
final View child = getChildAt(i);
if (child.getVisibility() != GONE) {
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
//获取到当前子View的测量宽高值
final int width = child.getMeasuredWidth();
final int height = child.getMeasuredHeight();
int childLeft;
int childTop;
int gravity = lp.gravity;
if (gravity == -1) {
gravity = DEFAULT_CHILD_GRAVITY;
}
final int layoutDirection = getLayoutDirection();
final int absoluteGravity = Gravity.getAbsoluteGravity(gravity, layoutDirection);
final int verticalGravity = gravity & Gravity.VERTICAL_GRAVITY_MASK;
//确定当前子View的left坐标
switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
case Gravity.CENTER_HORIZONTAL:
childLeft = parentLeft + (parentRight - parentLeft - width) / 2 +
lp.leftMargin - lp.rightMargin;
break;
case Gravity.RIGHT:
if (!forceLeftGravity) {
childLeft = parentRight - width - lp.rightMargin;
break;
}
case Gravity.LEFT:
default:
childLeft = parentLeft + lp.leftMargin;
}
//确定当前子View的top坐标
switch (verticalGravity) {
case Gravity.TOP:
childTop = parentTop + lp.topMargin;
break;
case Gravity.CENTER_VERTICAL:
childTop = parentTop + (parentBottom - parentTop - height) / 2 +
lp.topMargin - lp.bottomMargin;
break;
case Gravity.BOTTOM:
childTop = parentBottom - height - lp.bottomMargin;
break;
default:
childTop = parentTop + lp.topMargin;
}
//重点！！！调用到子View的layout方法，将当前子View的left、top、right、bottom坐标值作为参数传入
child.layout(childLeft, childTop, childLeft + width, childTop + height);
}
}
}
上述代码中的注释已经很清楚了，在这里，当前父容器指的就是我们的decorview，所以计算好decorview下 linearLayout的坐标值后会调用LinearLayout的layout方法，确定linearLayout的位置，我们跟进去LinearLayout的layout方法去看下（同样调用到View类的layout方法）：
#View
public void layout(int l, int t, int r, int b) {
...
//1.调用setFrame方法，确定View本身的位置，在这里是确定decorview下LinearLayout自身的位置
boolean changed = isLayoutModeOptical(mParent) ?
setOpticalFrame(l, t, r, b) : setFrame(l, t, r, b);
if (changed || (mPrivateFlags & PFLAG_LAYOUT_REQUIRED) == PFLAG_LAYOUT_REQUIRED) {
//2.调用到onLayout方法，确定子View的位置，在这里是确定LinearLayout下titlebar和id为content的FrameLayout的位置
onLayout(changed, l, t, r, b);
...
}
}
LinearLayout类对onLayout方法进行了重写，所以我们跟进去看下：
#LinearLayout
@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);
}
}
decorview下的LinearLayout的排列方式为竖直排列，mOrientation == VERTICAL 的值为true，所以我们来到 layoutVertical方法：
#LinearLayout
void layoutVertical(int left, int top, int right, int bottom) {
final int paddingLeft = mPaddingLeft;
int childTop;
int childLeft;
// 获取到子View的right边界坐标值
final int width = right - left;
int childRight = width - mPaddingRight;
// 子View水平方向可用空间
int childSpace = width - paddingLeft - mPaddingRight;
//获取到子view的数量
final int count = getVirtualChildCount();
final int majorGravity = mGravity & Gravity.VERTICAL_GRAVITY_MASK;
final int minorGravity = mGravity & Gravity.RELATIVE_HORIZONTAL_GRAVITY_MASK;
//根据当前linearlayout的gravity属性值确定第一个子View的top坐标值
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) {
//获取到LinearLayout下子View的测量宽高
final int childWidth = child.getMeasuredWidth();
final int childHeight = child.getMeasuredHeight();
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);
//根据子View的属性值layout_gravity，确定子View的left坐标值
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;
}
//考虑到子View的layout_marginTop值
childTop += lp.topMargin;
//1. 调用到setChildFrame方法，确定子View的坐标位置
setChildFrame(child, childLeft, childTop + getLocationOffset(child),
childWidth, childHeight);
//当前父容器linearlayout的排列方式为竖直排列，所以childTop的值需要自增加上当前子View的测量高度以及子View bottomMargin的值
childTop += childHeight + lp.bottomMargin + getNextLocationOffset(child);
i += getChildrenSkipCount(child, i);
}
}
}
我们接着跟进去1处的 setChildFrame方法：
#LinearLayout
private void setChildFrame(View child, int left, int top, int width, int height) {
child.layout(left, top, left + width, top + height);
}
可以看到在LinearLayout的 setChildFrame 方法中直接调用到子View的layout方法，将子View的left、top、right、bottom坐标值作为参数传了进去。由于我们当前的LinearLayout为DecorView下的LinearLayout，所以这里的子View为titleBar和id为content的FrameLayout。后续的layout流程类似，这里笔者就赘述了。。。
整个ViewTree的layout布局工作完成以后，程序会回到 ViewRootImpl 类中的performTraversals()方法接着向下执行，也就是调用到 4 处的 performDraw 方法，完成整个ViewTree的绘制工作，我们跟进去看下：
#ViewRootImpl
private void performDraw() {
...
try {
//重点
draw(fullRedrawNeeded);
} finally {
mIsDrawing = false;
Trace.traceEnd(Trace.TRACE_TAG_VIEW);
}
...
}
我们接着跟进去 ViewRootImpl 类的draw方法去看下：
private void draw(boolean fullRedrawNeeded) {
...
if (!drawSoftware(surface, mAttachInfo, xOffset, yOffset, scalingRequired, dirty)) {
return;
}
...
}
我们紧着跟进去 drawSoftware 方法：
private boolean drawSoftware(Surface surface, AttachInfo attachInfo, int xoff, int yoff,
boolean scalingRequired, Rect dirty) {
...
try {
//调整画布位置
canvas.translate(-xoff, -yoff);
if (mTranslator != null) {
mTranslator.translateCanvas(canvas);
}
canvas.setScreenDensity(scalingRequired ? mNoncompatDensity : 0);
attachInfo.mSetIgnoreDirtyState = false;
//重点！！！调用到decorview的draw方法
mView.draw(canvas);
drawAccessibilityFocusedDrawableIfNeeded(canvas);
} finally {
if (!attachInfo.mSetIgnoreDirtyState) {
// Only clear the flag if it was not set during the mView.draw() call
attachInfo.mIgnoreDirtyState = false;
}
}
...
}
在 ViewRootImpl 类中的 drawSoftware 方法中终于调用到 decorview的draw方法进行绘制操作，我们跟进去看下：
#DecorView
@Override
public void draw(Canvas canvas) {
//调用到View类中的draw方法
super.draw(canvas);
if (mMenuBackground != null) {
mMenuBackground.draw(canvas);
}
}
可以看到在DecorView的draw方法中直接调用到 View类的draw方法，我们跟进去看下：
#View类
@CallSuper
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;
}
...
}
从上述代码可以看出，View的绘制过程遵循如下几步：1. 调用 drawBackground 方法绘制自身的背景 2. 调用 onDraw 方法绘制自己 3. 调用 dispatchDraw 方法绘制children 4. 调用 onDrawForeground 方法绘制装饰。
在这里当前View为decorview，所以decorview首先调用到onDraw方法绘制自己，然后调用到 dispatchDraw 方法绘制children，也就是decorview下的linearlayout对象。我们首先看下decorview的onDraw方法：
#DecorView
@Override
public void onDraw(Canvas c) {
//重点，直接调用到View类的onDraw方法
super.onDraw(c);
// When we are resizing, we need the fallback background to cover the area where we have our
// system bar background views as the navigation bar will be hidden during resizing.
mBackgroundFallback.draw(isResizing() ? this : mContentRoot, mContentRoot, c,
mWindow.mContentParent);
}
我们跟进去View类的onDraw方法去看下：
/**
* Implement this to do your drawing.
*
* @param canvas the canvas on which the background will be drawn
*/
protected void onDraw(Canvas canvas) {
}
对的你没有看错，decorview的onDraw方法内部只是调用到 mBackgroundFallback.draw，具体什么操作我们就不追究了，我们回过头接着看下decorview的dispatchDraw方法：
#ViewGroup
@Override
protected void dispatchDraw(Canvas canvas) {
...
more |= drawChild(canvas, child, drawingTime);
...
}
接着看下 drawChild 方法：
protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
//重点
return child.draw(canvas, this, drawingTime);
}
可以看到在 drawChild 方法中直接调用到 child.draw方法，由于我们当前View为decorview，也就是调用到decorview下linearlayout的draw方法，后续绘制流程类似，这里就不再赘述了。。。
整个ViewTree的绘制工作执行完毕后，确切说，ViewRootImpl 类中的performTraversals()方法就执行完毕了。
到这里为止，我们就从顶级View DecorView从上至下，将整个ViewTree的绘制流程贯穿了一遍。文章略长，感谢大家有耐心读完本文。