View 绘制流程
一、需要了解的知识
DecorView
DecroView 其实是一个 FrameLayout，它包含了一个垂直的 LinerLayout，这个 LinerLayout 包含手机通知栏、 titlebar 标题栏，下部分为内容栏也就是 Activity 通过 setContentView 设置的布局。
内容栏的 id 为 content，布局加到了 id 为 content 的 FrameLayout 中。
获取 content 内容栏：
ViewGroup content = findViewById(R.android.id.content);
获取设置的布局 View：
content.getChildAt(0);
DecorView 层次图
ViewRoot 和 ViewRootImpl
ViewRoot 是连接 WindowManager 和 DecorView 的纽带，View 的三大流程均是通过 ViewRoot 来完成的。然而 ViewRoot 不是 View，它的实现类 ViewRootImpl 跟 View 也没有什么直接的关系。详情可阅Android里那些令人费解的命名(一)ViewRoot
MeasureSpec
MeasureSpec 是 View 的一个 static 类，这个词像两个单词的组成，翻译为“测量规格”或“测量参数”。
MeasureSpec 代表一个 32 位的 int 值，它包含了 View 的大小(低30位代表 SpecSize)和测量模式(高2位代表 SpecMode)。MeasureSpec 将这两个值打包在了一起并提供了打包和解包的方法。
简单地说，MeasureSpec 代表了某个 View 的测量大小和显示模式。
MeasureSpec一共有三种模式：
UPSPECIFIED : 父容器不对 View 有任何限制，要多大给多大，一般用于表示一种数值未定的测量状态；
EXACTLY：父容器已经检测或计算出 View 所需的大小，这是一个比较精确的数值，一般最终 View 的大小就是这里指定的 SpecSize；
AT_MOST：父容器指定了一个可用大小，View 的大小不能超过这个值。
二、从源头寻找 View 绘制流程
2.1 DecorView 的创建和测量
1.创建 ViewRootImpl 对象并调用 performTraversals 开始绘制
ActivityThread 中，当 Activity 对象创建完毕，会将 DecorView 添加到 Window 中，同时创建 ViewRootImpl 对象，并将 ViewRootImp 对象和 DecorView 建立关联。
// 创建 ViewRootImpl 对象
root = new ViewRootImpl(view.getContext(), display);
// 和 DecorView 建立关联
root.setView(view, wparams, panelParentView);
从 ViewRoot 的 performTraversals 方法开始，将 View 按照 measure、layout、和 draw 的过程绘制出来。performTraversals 方法会依次调用 performMeasure、performLayout、performDraw 来完成 DecroView 的绘制流程。
private void performTraversals() {
...
int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);
...
// performMeasure 执行测量
performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
...
WindowManager.LayoutParams lp = mWindowAttributes;
if (didLayout) {
// performLayout 执行 Layout，确定坐标
performLayout(lp, mWidth, mHeight);
...
}
...
// performDraw 执行绘制
performDraw();
...
}
private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {
...
mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);
...
}
/**
* 基于它的布局参数，计算出窗口中根视图的度量标准。
* 也就是根据屏幕宽高和 DecorView 布局参数来确定 DecorView 的 MeasureSpec
*
* @param windowSize
* 窗口的可用宽度或高度
*
* @param rootDimension
* 窗口的一维(宽度或高度)的布局参数。
*
* @return 用于度量根视图的度量指标。
*/
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 = View.MeasureSpec.makeMeasureSpec(windowSize, View.MeasureSpec.EXACTLY);
break;
...
}
return measureSpec;
}
ViewGroup：performMeasure --> measure --> onMeasure 在这个过程中，onMeasure 会对所有子元素进行 measure 。
ViewGroup：performLayout --> layout --> onLayout 然后对所有子元素进行 layout
ViewGroup：performDraw --> draw --> onDraw 传递过程通过 dispatchDraw 来完成
2. 开始测量 DecorView
performMeasure 中其实调用了 mView.measure(childWidthMeasureSpec, childHeightMeasureSpec); 方法，mView 可以看作是上文 ViewRootImpl 对象设置进来的 DecorView 的实例。接下来看一下 DecorView 的继承关系：
DecorView extends FrameLayout extends ViewGroup extends View
DecorView、FrameLayout 还有 ViewGroup 最终都继承了 View类，FrameLayout 和 ViewGroup 都没有 measure 方法，所以 mView.measure 最终会调用 View 类的 measure 方法。
measure 方法是 View 类的一个 final 方法，不可重写。DecorView 调用了 measure 方法，接下来看一下 View 调用 measure 方法做了什么。
View 类 measure 方法
public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
...
onMeasure(widthMeasureSpec,heightMeasureSpec);
..
}
插播 1：View 中 onMeasure 所做的事情：
measure 方法调用了 onMeasure 方法，所以具体 View 的测量工作是在 onMeasure 方法中进行的：
View 类 onMeasure 方法
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
}
setMeasuredDimension方法可以简单理解为给 View 的 mMeasuredWidth，和 mMeasuredWidth 设置值，也就是确定 View 的测量宽高。这里的测量宽高是通过传递过来的父 View 的 MeasureSpec 和子 View 的默认属性共同决定的，getDefaultSize 方法会证明这一点。设置完成后就代表当前 View 的宽/高测量值确定了。
那么 View 的测量宽高是通过 getDefaultSize 方法返回的参数来确定具体的测量值。
getDefaultSize 方法传入两个参数
第一个参数为 getSuggestedMinimumWidth 方法的返回值：
protected int getSuggestedMinimumWidth() {
return (mBackground == null) ? mMinWidth : max(mMinWidth, mBackground.getMinimumWidth());
}
根据该方法的返回值来看，如果当前 View 没有设置背景，则返回的值为 View 的 android:minWidth 属性所设置的值，可以为0。如果指定了背景，则返回的值为 android:minWidth 属性值和背景的最小宽度两者中的最大值。对于高度，逻辑也是一样的，android:minHeight 属性和背景共同决定。
第二个参数为 measure 方法中传递过来的宽/高的 MeasureSpec 格式的测量值，是由父 View 的MeasureSpec 和子 View 自己的 LayoutParams 共同决定的，后文再作分析。
View 类 getDefaultSize 方法
public static int getDefaultSize(int size, int measureSpec) {
int result = size;
int specMode = View.MeasureSpec.getMode(measureSpec);
int specSize = View.MeasureSpec.getSize(measureSpec);
// 根据父 View 传递来的 SpecMode 来决定返回 View 的测量值
switch (specMode) {
case View.MeasureSpec.UNSPECIFIED:
result = size;
break;
case View.MeasureSpec.AT_MOST:
case View.MeasureSpec.EXACTLY:
result = specSize;
break;
}
return result;
}
上面已经分析过这两个参数，getDefaultSize 默认返回的是传递来的第一个参数，也就是由最小宽高和背景宽高共同决定的值。接下来进入 switch 判断，如果传递来的 SpecMode 为 UNSPECIFIED，则返回由 minHeight/minWidth 和背景共同决定的值。如果是 AT_MOST(规定上限)或 EXACTLY(精确值)模式，则返回由父 View 的MeasureSpec 和子 View 自己的 LayoutParams 共同决定的测量参数的值，也就是第二个参数中的 SpecSize。
3. 递归测量 DecorView 的子 View，最后测量 DecorView
View 的 measure 方法会调用 onMeasure 来做具体的测量工作。DecorView 其实是一个 FrameLayout 且重写了 onMeasure 方法，所以接下来会进入 FrameLayout 的 onMeasure 方法。接着会调用父类 ViewGroup 的 measureChildWithMargins 方法来测量所有子 View。
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
...
int maxHeight = 0;
int maxWidth = 0;
int childState = 0;
// 遍历子 View 测量它们的值
for (int i = 0; i < count; i++) {
final View child = getChildAt(i);
// 不为 GONE 的子 View 都会参与测量
if (mMeasureAllChildren || child.getVisibility() != GONE) {
// 父类 ViewGroup 中的方法，用来测量所有子 View
measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, 0);
...
}
}
...
// 父类 View 中的方法，用来确定当前 View 的测量值(当前是 FrameLayout)
setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
resolveSizeAndState(maxHeight, heightMeasureSpec,
childState << MEASURED_HEIGHT_STATE_SHIFT));
...
}
插播 2：ViewGroup 中 measureChildWithMargins 所做的事情：
ViewGroup 类 measureChildWithMargins 方法源码
protected void measureChildWithMargins(View child,
int parentWidthMeasureSpec, int widthUsed,
int parentHeightMeasureSpec, int heightUsed) {
// child.getLayoutParams()获取的是子 View 在 xml 中所设置的布局参数
final ViewGroup.MarginLayoutParams lp = (ViewGroup.MarginLayoutParams) child.getLayoutParams();
// 根据父 View 的测量参数 parentWidthMeasureSpec/parentHeightMeasureSpec
// 以及子 View 的布局参数 Margin、Padding 和 width/height 来确定子 View 的测量参数
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);
// 算出宽和高的测量参数后，让子 View 继续测量。
// 如果子 View 是 ViewGroup 则会递归往下级 View 测量
child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}
简单理解：首先，拿到子 View 的 xml 设置的布局参数，父 View 的测量参数(MeasureSpec)是由父 View 的 onMeasure 传递过来的。接着，将这些参数传递到 getChildMeasureSpec 方法来计算出子 VIew 的测量参数。最后子 View 调用 measure 方法来继续测量，如果该子 View 是 ViewGroup，会继续调用 measureChildWithMargins 来递归测量下级 View，如果子 View 只剩一个单独的 View，则调用 measure 之后再调用
onMeasure 中的 setMeasuredDimension 来完成测量。
接下来看 getChildMeasureSpec 方法来计算出子 VIew 的测量参数的过程：
ViewGroup 类 getChildMeasureSpec 方法源码
/**
* @param spec 父 View 传递来的测量参数
* @param padding 上面方法传递来的父View的padding和子View的margin以及widthUsed(已使用的宽度/高度)
* lp 是子View的布局参数
* mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin + widthUsed
* @param childDimension 子View布局参数设定的宽或高
* @return 子View的布局参数
*/
public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
int specMode = View.MeasureSpec.getMode(spec); // 父View的SpecMode
int specSize = View.MeasureSpec.getSize(spec); // 父View的SpecSize
// 具体大小为父View的大小 减去 父View的padding和子View的margin以及widthUsed
// 暂时称之为 View剩余大小
int size = Math.max(0, specSize - padding);
// 用来生成子View的测量参数
int resultSize = 0;
int resultMode = 0;
switch (specMode) {
// 父View的大小是EXACTLY模式
case View.MeasureSpec.EXACTLY:
if (childDimension >= 0) { // 子View布局参数宽/高大于等于0
resultSize = childDimension; // 子View的宽/高为子View设置的布局参数值
resultMode = View.MeasureSpec.EXACTLY; // 子View的模式为精确模式
} else if (childDimension == ViewGroup.LayoutParams.MATCH_PARENT) { // 子View是MATCH_PARENT
resultSize = size; // 让子View的数值为计算好的View剩余大小
resultMode = View.MeasureSpec.EXACTLY; // 子View的模式为精确模式
} else if (childDimension == ViewGroup.LayoutParams.WRAP_CONTENT) { // 子View是WRAP_CONTENT
resultSize = size; // 子View的数值为计算好的View剩余大小
resultMode = View.MeasureSpec.AT_MOST; // 子View的模式为AT_MOST，表示不能超过这个View剩余大小
}
break;
// 父View的大小是AT_MOST模式
case View.MeasureSpec.AT_MOST:
if (childDimension >= 0) { // 子View布局参数宽/高大于等于0
resultSize = childDimension; // 子View的宽/高为子View设置的布局参数值
resultMode = View.MeasureSpec.EXACTLY; // 子View的模式为精确模式
} else if (childDimension == ViewGroup.LayoutParams.MATCH_PARENT) { // 子View是MATCH_PARENT
resultSize = size; // 子View的数值为View剩余大小
resultMode = View.MeasureSpec.AT_MOST; // 因为父View是AT_MOST模式其数据不确定，
// 所以子View也是AT_MOST不能超过View剩余大小
} else if (childDimension == ViewGroup.LayoutParams.WRAP_CONTENT) {// 子View是WRAP_CONTENT
// 子View想自适应，但它最大不能超过View剩余大小
resultSize = size;
resultMode = View.MeasureSpec.AT_MOST;
}
break;
// 父View的大小是UNSPECIFIED模式
case View.MeasureSpec.UNSPECIFIED:
if (childDimension >= 0) {// 子View布局参数宽/高大于等于0
// 子View宽高是精确数值，父View不限制所以子View也不加限制
resultSize = childDimension;
resultMode = View.MeasureSpec.EXACTLY; //子View宽高是精确数值所以其模式也应为EXACTLY
} else if (childDimension == ViewGroup.LayoutParams.MATCH_PARENT) {// 子View是MATCH_PARENT
// 如果父View的大小未确定，返回0，否则返回View剩余大小
resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
resultMode = View.MeasureSpec.UNSPECIFIED; // 父View大小无限制，子View也应是
} else if (childDimension == ViewGroup.LayoutParams.WRAP_CONTENT) {
// 判断模式与上一个类似
resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
resultMode = View.MeasureSpec.UNSPECIFIED;
}
break;
}
// 根据上文子View的SpecMode和SpecSize来打包成一个MeasureSpec对象
return View.MeasureSpec.makeMeasureSpec(resultSize, resultMode);
}
简单总结：
首先拿到父 View 的 specMode 和 specSize，specSize是父 View 的测量宽/高。使用 specSize 减去 父 View 的 padding 和子 View 的 margin 以及widthUsed 来计算出一个剩余大小，也就是子 View 能拿来用作显示的区域大小，暂且称之为 View 剩余大小。
然后根据父 View 的 specMode 和子 View 具体的布局参数来确定子 View 的 specMode 和 specSize：
父 View 是EXACTLY模式，说明父 View 的大小是精确的，一般来说，这个大小就是最终展示到屏幕上的大小。
如果子 View 的大小在布局中设定好了，并且大于等于 0，那么子 View 的值是确定的，并且其模式为 EXACTLY。无论父 View 的大小与模式。
如果子 View 的大小为 "match_parent"，当父 View 精确大小，那么子 View 的大小为计算好的 View 剩余大小，并且模式也是 EXACTLY。
如果子 View 的大小为 "wrap_content"，当父 View 精确大小，子 View 再怎么自适应也不应超过父 View 剩余大小，所以 specSize 为 View 剩余大小，specMode 为 AT_MOST。
父 View 是AT_MOST模式，说明父 View 的大小不确定，但是会小于某个固定值。
同样，如果子 View 的大小在布局中设定好了，并且大于等于 0，那么子 View 的值是确定的，并且其模式为 EXACTLY。无论父 View 的大小与模式。
如果子 View 的大小为 "match_parent"，子 View 的模式为 AT_MOST，并且其最大值为 View 剩余大小。
逻辑同上，也应是 AT_MOST 模式并且最大值为 View 剩余大小。
父 View 是UNSPECIFIED模式，表面父 View 的大小没有约束，所以子 View 的大小也可以是没有限制大小的。
同样，如果子 View 的大小在布局中设定好了，并且大于等于 0，那么子 View 的值是确定的，并且其模式为 EXACTLY。
如果子 View 的大小为 "match_parent"，子 View 的大小理所应当也是无限制模式的，并且如果父View的大小未确定，返回0，否则返回View剩余大小。
逻辑同上。
(3)DecorView 作为 FrameLayout 调用 FrameLayout 的 onMeasure 方法，onMeasure 方法又调用了 ViewGroup 的 measureChildWithMargins 方法来测量所有子 View。子 View 测量完毕后，接着调用父类 View 的 setMeasuredDimension 方法，这个方法在上面 View 的测量流程中有提到过。
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;
}
总之就是 DecorView 作为 FrameLayout 先测量子 View，然后再确定自己的测量值。关于子 View 是如何测量的，可以回去看第一条插播。
2.2 Layout 过程
DecroView 完成 performMeasure 中的 measure 过程后，就完成了 DecroView 的大小和绘制模式，接下来就会进行 Layout 过程来放置 DecroView 的具体位置。然后判断 didLayout (didLayout 由 Window 状态等参数决定)，如果为 true 则执行 Layout 过程。
private void performTraversals() {
...
// performMeasure 执行测量
performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
...
WindowManager.LayoutParams lp = mWindowAttributes;
if (didLayout) {
// performLayout 执行 Layout，确定坐标
performLayout(lp, mWidth, mHeight);
...
}
...
}
ViewRootImp 中 performLayout 方法
private void performLayout(WindowManager.LayoutParams lp, int desiredWindowWidth,
int desiredWindowHeight) {
...
// 赋值给 host 并判断是否为 null
final View host = mView;
if (host == null) {
return;
}
...
// 进行具体的 layout 过程
host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());
...
}
由上面代码可知 DecorView 调用 layout 方法，这个方法被 ViewGroup 重写为 final 类型(说明所有继承 ViewGroup 的 View 的 layout 过程被 ViewGroup 统一管理)，DecorView 是一个 FrameLayout 继承了 ViewGroup。所以会调用 ViewGroup 的 layout 方法。
ViewGroup layout 方法
@Override
public final void layout(int l, int t, int r, int b) {
// mSuppressLayout 判断当前布局是否被父 ViewGroup 进行增加或删除的动画效果
// mTransition 判断当前布局是否存在动画或动画正在改变布局
if (!mSuppressLayout && (mTransition == null || !mTransition.isChangingLayout())) {
if (mTransition != null) {
mTransition.layoutChange(this);
}
super.layout(l, t, r, b);
} else {
// transition 动画正在运行设置为 true，等待动画完成重新调用 requestLayout() 重新请求 Layout 步骤
// record the fact that we noop'd it; request layout when transition finishes
mLayoutCalledWhileSuppressed = true;
}
}
上述代码可以简单理解为 layout 之前先进行 Transition 动画的判定，如果有动画在执行则设置 mLayoutCalledWhileSuppressed 为 true 作为标记，等待动画完毕重新调用 layout。
如果Transition 没有在执行，则调用父类的 layout(l, t, r, b); 方法，也就是 View 类的 layout() 方法。
View layout 方法
public void layout(int l, int t, int r, int b) {
...
// 先标记旧的属性值
int oldL = mLeft;
int oldT = mTop;
int oldB = mBottom;
int oldR = mRight;
// 判断 LayoutMode 是否为 LAYOUT_MODE_OPTICAL_BOUNDS 模式，如果是则执行 setOpticalFrame。
// 不是则执行 setFrame，这个函数的作用为：判断当前 View 的属性是否发生变化，并返回是否有变化。
// 同时为当前 View 设置一个大小和位置。
boolean changed = isLayoutModeOptical(mParent) ?
setOpticalFrame(l, t, r, b) : setFrame(l, t, r, b);
// 判断当前 View 是否发生变化，来决定是否需要重新 layout
if (changed || (mPrivateFlags & PFLAG_LAYOUT_REQUIRED) == PFLAG_LAYOUT_REQUIRED) {
onLayout(changed, l, t, r, b);
// 判断是否在圆形可穿戴设备上绘制圆角
if (shouldDrawRoundScrollbar()) {
if(mRoundScrollbarRenderer == null) {
mRoundScrollbarRenderer = new RoundScrollbarRenderer(this);
}
} else {
mRoundScrollbarRenderer = null;
}
mPrivateFlags &= ~PFLAG_LAYOUT_REQUIRED;
...
}
...
}
拿到上下左右的属性值并标记，然后判断属性值是否发生变化并更新设置。
如果 View 发生了变化则回调 onLayout() 来确定坐标，在初始情况下各个属性都是默认的。一旦子 View 完成 measure 过程，这些属性都会被赋值，所以会回调具体类的 onLayout() 方法。View 类的 onLayout() 方法是空实现
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
}
由于 DecorView 继承 FrameLayout 又继承 ViewGroup 又继承 View，所以倒着来看 ：
ViewGroup 的 onLayout() 方法
@Override
protected abstract void onLayout(boolean changed,
int l, int t, int r, int b);
简单粗暴的一个抽象方法，也就是说需要子类具体的去实现。
FrameLayout 的 onLayout() 方法
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
layoutChildren(left, top, right, bottom, false /* no force left gravity */);
}
void layoutChildren(int left, int top, int right, int bottom, boolean forceLeftGravity) {
final int count = getChildCount();
// 获取父 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);
// 省略的是一些根据子 View 的 LayoutGravity 和父 View 的边界属性来重新计算的代码
...
// 计算完毕之后子 View 再递归进行 layout。根据具体的 View 回调相关的 onLayout 方法
child.layout(childLeft, childTop, childLeft + width, childTop + height);
}
}
到 layoutChildren 方法也是拿了一堆属性 ，然后遍历子 View 来balabala 进行计算(省略了)最终确定子 View 的左右上下边距再使用递归的方式来进行子 View 的 layout 方法。
进行 layout 会回调 onLayout 方法，不同的 View 会重写 onLayout 方法，具体可以去看不同 View 的源码。
onLayout(boolean changed, int left, int top, int right, int bottom) 方法中的各种属性在 measure 过程中计算好传递过来的，但是具体进行 layout 过程可能会根据子 View 的 LayoutGravity 模式来进行具体的更改。
至此，Layout 过程告一段落。
2.3 Draw 过程
performLayout 执行完毕之后会进行 performDraw 方法来进行绘制，
private void performTraversals() {
...
int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);
...
// performMeasure 执行测量
performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
...
WindowManager.LayoutParams lp = mWindowAttributes;
if (didLayout) {
// performLayout 执行 Layout，确定坐标
performLayout(lp, mWidth, mHeight);
...
}
...
// performDraw 执行绘制
performDraw();
...
}
performDraw()方法经过层层调用会执行mView.draw(canvas);方法，这里的 mView 依旧是 DecorView 的实例。因为View的draw 方法一般不去重写，官网文档也建议不要去重写 draw 方法，所以接下来进入 View 类的 draw 方法：
public void draw(Canvas canvas) {
...
/*
* 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);
...
// 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;
}
...
}
这块的注释写的非常清晰，一条条列出来了绘制步骤，其中第 2 步和第 5 步是在特点情况下才会进行的，所以分析时省略这两块的步骤：
绘制背景
private void drawBackground(Canvas canvas) {
Drawable final Drawable background = mBackground;
......
//mRight - mLeft, mBottom - mTop layout确定的四个点来设置背景的绘制区域
if (mBackgroundSizeChanged) {
background.setBounds(0, 0, mRight - mLeft, mBottom - mTop);
mBackgroundSizeChanged = false; rebuildOutline();
}
......
//调用Drawable的draw() 把背景图片画到画布上
background.draw(canvas);
......
}
如有必要，请保存画布图层以准备淡入淡出
绘制View的内容
View 的 onDraw() 和 ViewGroup 的 onDraw() 都是空实现，所以需要具体的子 View 去实现相应的绘制功能
绘制View的子View们
View 的 dispatchDraw(canvas); 方法也是一个空实现，ViewGroup 实现了这个方法，在 ViewGroup 中该函数遍历所有子元素的 draw 方法，这样绘制事件就一层一层地传递了下去。
ViewGroup 的 dispatchDraw 方法
@Override
protected void dispatchDraw(Canvas canvas) {
...
if ((flags & FLAG_USE_CHILD_DRAWING_ORDER) == 0) {
for (int i = 0; i < count; i++) {
final View child = children[i];
if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {
more |= drawChild(canvas, child, drawingTime);
}
}
} else {
for (int i = 0; i < count; i++) {
final View child = children[getChildDrawingOrder(count, i)];
if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {
more |= drawChild(canvas, child, drawingTime);
}
}
}
......
}
drawChild 方法直接调用了 child.draw(canvas, this, drawingTime); 方法。又是在循环中，所以会调用所有 child View 的 draw 方法。
如有必要，绘制渐变边缘并恢复图层
绘制装饰(例如滚动条)
绘制默认焦点高亮
到这里 View 的绘制流程就基本结束了。
参考资料：
865
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
