performTraversals方法会经过measure、layout和draw三个流程才能将一帧View需要显示的内容绘制到屏幕上，用最简化的方式看ViewRootImpl.performTraversals()方法，如下。
private void performTraversals() {
...
performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
...
performLayout(lp, mWidth, mHeight);
...
performDraw();
. ..
｝
首先来说这三个流程的意义：
performMeasure()：从根节点向下遍历View树，完成所有ViewGroup和View的测量工作，计算出所有ViewGroup和View显示出来需要的高度和宽度；
performLayout()：从根节点向下遍历View树，完成所有ViewGroup和View的布局计算工作，根据测量出来的宽高及自身属性，计算出所有ViewGroup和View显示在屏幕上的区域；
performDraw()：从根节点向下遍历View树，完成所有ViewGroup和View的绘制工作，根据布局过程计算出的显示区域，将所有View的当前需显示的内容画到屏幕上。
再来具体分析这三个流程：
1. performMeasure()流程
在ViewRootImpl.java中调用performMeasure()方法传入的参数为childWidthMeasureSpec和childHeightMeasureSpec。在performTraversals能找到它们初始化的地方如下。
int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);
通过getRootMeasureSpec能够计算出一个MeasureSpec值，该值一般是父布局调用子布局的measure()是传入的参数，这个参数是由父布局的宽高和子布局的LayoutParams参数计算得到的，这两个参数用于子布局的measure过程，很大程度上决定着子View的宽高。上面代码出计算出来的childWidthMeasureSpec和childHeightMeasureSpec则是根据Window相关属性得到的MeasureSpec，因为DecorView本身没有父布局，所以传入给DecorView进行measure的MeasureSpec值是由Window的尺寸（mWidth、mHeigth）和DecorView的LayoutParams得到的；而对于普通的View，它的MeasureSpec 由父容器的 MeasureSpec 和自身的 LayoutParams 来共同决定。
方法中的lp.width和lp.heigth表示布局类型，这里指的是DecorView的布局类型。布局类型举例来说，写布局xml时android:layout_width="wrap_content"中设置的wrap_content值，共有三种类型MATCH_PARENT、WRAP_CONTENT以及直接写入了确定大小。进入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;
}
实际上getRootMeasureSpec()方法就是根据传入的窗口大小和类型，通过MeasureSpec.makeMeasureSpec()方法合并成一个int型的measureSpec值。该值代表一个32位 int 值，高2位代表 SpecMode（测量模式），由传入的布局类型转化而来，有三种类型，MeasureSpec.EXACTLY：确定大小，parent view为child view指定固定大小；MeasureSpec.AT_MOST：最大大小；child view在parent view中取值；MeasureSpec.UNSPECIFIED：无限制，parent view不约束child view的大小。该值低30位代表 SpecSize，指在某个测量模式下的规格大小。后面的方法中会通过MeasureSpec.getMode()和MeasureSpec.getSize()方法来解析出这两个值。
从这里就可以看到childWidthMeasureSpec, childHeightMeasureSpec实际上表示的就是DecorView的宽高和布局类型。进入到performMeasure()方法。
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);
}
}
该方法设置完TraceView的起始点和结束点后直接便是进入到了mView.measure()方法，进入对应View.measure()方法代码。
public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
...
//是否有重新Layout的标志
final boolean forceLayout = (mPrivateFlags & PFLAG_FORCE_LAYOUT) == PFLAG_FORCE_LAYOUT;
// Optimize layout by avoiding an extra EXACTLY pass when the view is
// already measured as the correct size. In API 23 and below, this
// extra pass is required to make LinearLayout re-distribute weight.
//与上一次的MeasureSpec进行对比确定是否需要重新绘制
final boolean specChanged = widthMeasureSpec != mOldWidthMeasureSpec
|| heightMeasureSpec != mOldHeightMeasureSpec;
final boolean isSpecExactly = MeasureSpec.getMode(widthMeasureSpec) == MeasureSpec.EXACTLY
&& MeasureSpec.getMode(heightMeasureSpec) == MeasureSpec.EXACTLY;
final boolean matchesSpecSize = getMeasuredWidth() == MeasureSpec.getSize(widthMeasureSpec)
&& getMeasuredHeight() == MeasureSpec.getSize(heightMeasureSpec);
final boolean needsLayout = specChanged
&& (sAlwaysRemeasureExactly || !isSpecExactly || !matchesSpecSize);
if (forceLayout || needsLayout) {
// first clears the measured dimension flag
mPrivateFlags &= ~PFLAG_MEASURED_DIMENSION_SET;
resolveRtlPropertiesIfNeeded();
//key的值是由widthMeasureSpec和heightMeasureSpece
//在MeasureCache中查看在当前传入的宽高的MeasureSpec是否已经执行过onMeasure计算
//如果已经执行过，则直接取出结果通过setMeasuredDimemsionRaw()设置测量出的相关参数
//如果没有执行过，才会调用onMeasure()方法进行测量工作
//mPrivateFlags3的设置，在后面介绍的View.layout()方法中会用到
//在后面layout()方法中会判断该flag，如果此时没有调用，则那layout会再调用measure（）
int cacheIndex = forceLayout ? -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;
} else {
long value = mMeasureCache.valueAt(cacheIndex);
// Casting a long to int drops the high 32 bits, no mask needed
setMeasuredDimensionRaw((int) (value >> 32), (int) value);
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) { （2）
throw new IllegalStateException("View with id " + getId() + ": "
+ getClass().getName() + "#onMeasure() did not set the"
+ " measured dimension by calling"
+ " setMeasuredDimension()");
}
mPrivateFlags |= PFLAG_LAYOUT_REQUIRED;
}
...
}
实际的measure过程是在onMeasure()方法中完成的，这里进入到调用到View.onMeasure()方法。
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
}
大家注意这里要注意performMeasure()方法是final类型的，即是不能被父类重载的，所以无论是对于任何一种Layout（父类为ViewGroup.java，ViewGroup.java父类为View.java）的measure()方法调用，或是任何一个控件比如TextView的measure()方法调用，执行代码都是View.java中的measure()方法；而不同的控件measure过程的区别是通过重写onMeasure()方法来实现的。所以在measure()方法里调用的onMeasure()方法并未直接走到View.onMeasure()方法，而是走到了View的父类中重写的onMeasure()方法。但是，这里我们要注意到上一段代码的（2）处，这段代码是在调用后onMeasure()方法之后的一个判断，上面的注释的意思是如果到现在还没有调用过setMeasuredDimension()方法，就会抛出下面的异常，所以在View的父类重写onMeasure()方法时，一定要执行一次setMeasuredDimension()方法。那这个方法做了什么事呢？进入View.setMeasuredDimension()方法代码。
protected final void setMeasuredDimension(int measuredWidth, int measuredHeight) {
//根据自己与父布局的android:layoutMode的值调整传入参数
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;
}
这里我们可以看到setMeasuredDimension()实际上就是将传入的参数设置到View的变量mMeasuredWidth和mMeasuredHeight中。这也是实际上measure流程所要完成的任务，即是调用到布局树上的所有ViewGroup和View的measure()，让所有的ViewGroup和View计算出对应的宽、高的值保存到自己的mMeasuredWidth、mMeasuredHeight变量中。
我们继续来分析DecorView的measure流程，进入DecorView.onMeasure()方法。
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
final DisplayMetrics metrics = getContext().getResources().getDisplayMetrics();
final boolean isPortrait =
getResources().getConfiguration().orientation == ORIENTATION_PORTRAIT; final int widthMode = getMode(widthMeasureSpec);
final int heightMode = getMode(heightMeasureSpec); boolean fixedWidth = false;
mApplyFloatingHorizontalInsets = false; //如果SpecMode不是EXACTLY的，则需要在这里调整为EXACTLY
if (widthMode == AT_MOST) {
final TypedValue tvw = isPortrait ? mWindow.mFixedWidthMinor : mWindow.mFixedWidthMajor;
if (tvw != null && tvw.type != TypedValue.TYPE_NULL) {
final int w;
//根据DecorView属性，计算出DecorView需要的宽度
if (tvw.type == TypedValue.TYPE_DIMENSION) {
w = (int) tvw.getDimension(metrics);
} else if (tvw.type == TypedValue.TYPE_FRACTION) {
w = (int) tvw.getFraction(metrics.widthPixels, metrics.widthPixels);
} else {
w = 0;
}
if (DEBUG_MEASURE) Log.d(mLogTag, "Fixed width: " + w);
final int widthSize = MeasureSpec.getSize(widthMeasureSpec);
//根据上面计算出来的需要的宽度生成新的MeasureSpec用于DecorView的测量流程
if (w > 0) {
widthMeasureSpec = MeasureSpec.makeMeasureSpec(
Math.min(w, widthSize), EXACTLY);
fixedWidth = true;
} else {
widthMeasureSpec = MeasureSpec.makeMeasureSpec(
widthSize - mFloatingInsets.left - mFloatingInsets.right,
AT_MOST);
mApplyFloatingHorizontalInsets = true;
}
}
} mApplyFloatingVerticalInsets = false;
if (heightMode == AT_MOST) {
... //逻辑同上
} ...super.onMeasure(widthMeasureSpec, heightMeasureSpec); ...
}
由于DecorView.java父类是FrameLayout.java，所以调用super.onMeasure()时进入FrameworkLayout.onMeasure()方法。
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
int count = getChildCount();
//如果宽、高的MeasureSpec的Mode有一个不是EXACTLY，这里就是true
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);
if (mMeasureAllChildren || child.getVisibility() != GONE) {
//子View的测量，方法内会调用到child.measure()，后文详解
measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, 0);
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
//计算出所有子布局中宽度和高度最大的值
//由于子布局占用的尺寸除了自身宽高之外，还包含了其距离父布局的边界的值，所以需要加上左右Margin值
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());
//当前的FrameLayout的MeasureSpec不都是EXACTLY,且其子View为MATCH_PARENT，
//则子View保存到mMatchParentChildren中，后面重新测量
//DecorView不会走这个逻辑，因为进过了DecorView的onMeasure()流程，MeasureSpec一定都为EXACTLY
//会走到下面流程的情况举例：用户自布局一个FrameLayout属性为WRAP_CONTENT是，但子布局为MATCH_PARENT
if (measureMatchParentChildren) {
if (lp.width == LayoutParams.MATCH_PARENT ||
lp.height == LayoutParams.MATCH_PARENT) {
mMatchParentChildren.add(child);
}
}
}
}
//最后计算得到的maxWidth和maxHeight的值需要保证能够容纳下当前Layout下所有子View，所以需要对各类情况进行处理
//所以有以下的加上Padding值，用户设置的Mini尺寸值的对比，设置了背景图片情况的图片大小对比
// Account for padding too
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());
}
//设置测量结果，相当于完成自己View的measure
setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
resolveSizeAndState(maxHeight, heightMeasureSpec,
childState << MEASURED_HEIGHT_STATE_SHIFT));
//会走到这里的情况见前面注释
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) {
//根据当前FrameLayout已经测量出来的mMeasureWidth，计算出MATCH_PARENT的子View的宽度值
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);
} ... //childHeigthMeasureSpe的设置，逻辑同上一段 child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}
}
}
首先是对于maxHeight和maxWith的宽度的计算，为何能通过所有子布局中最大的子布局的尺寸来决定自己的尺寸呢？首先要回顾下FrameLayout的布局模式，简单来说，就是所有放在布局里的控件，都按照层次堆叠在屏幕的左上角，后加进来的控件覆盖前面的控件。正是因为要实现这样的布局模式，才决定了FrameLayout的measure算法，所有的子View都是堆叠在屏幕左上角，自然只需要根据最大的子View的尺寸来设置自己（还需要加一些特殊情况的处理），即可能够放下所有的子View。如果是LinearLayout的onMeasure()方法，则又会实现不同的测量逻辑，在测量时则会考虑到多个View依次摆放的问题。
再来关注代码中第一个加粗的方法measureChildWithMargins()，这里逻辑是依次调用该方法完成FrameLayout所有子View的measure工作。该方法在父类ViewGroup.java类中实现的，进入ViewGroup.measureChildWithMargins()方法代码。
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);
}
这个方法比较简单，首先关注下widthUsed和heithUsed的意义，表示的是父布局已经占用的大小，上面的FrameLayout.onMeasure()代码中调用时传入的是0。为何是0？因为FrameLayout的逻辑是全部堆叠在右上角，所以这个子View放到FrameLayout中时，不会被其它子View提前使用了FrameLayout的空间。
重点关注下getChildMeasureSpec()方法，通过该方法能够得到子View的MeasureSpec，所以才能调用子View的measure()方法，完成子View的测量。注意，这里传入的lp.width表示的是布局中的android:layout_width对应的值，可能是确定的值，可能是LayoutParams.MATCH_PARENT或LayoutParams.WRAP_CONTENT。进入ViewGroup.getChildMeasureSpec()方法。
public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
//父布局的SpecMode和Size
int specMode = MeasureSpec.getMode(spec);
int specSize = MeasureSpec.getSize(spec);
//父布局中剩下的能够提供给子View使用的尺寸，通过后面计算得到子View需要多少
int size = Math.max(0, specSize - padding);
//用于保存子布局的进行measure的MeasureSpec的两个参数
int resultSize = 0;
int resultMode = 0;
switch (specMode) {
// Parent has imposed an exact size on us
//如果父布局是Mode是EXACTY
case MeasureSpec.EXACTLY:
if (childDimension >= 0) {
//子View赋值了固定大小
//则子View的SpecSize就是自己想要的大小
//则子View的SpecMode是EXACTY
resultSize = childDimension;
resultMode = MeasureSpec.EXACTLY;
} else if (childDimension == LayoutParams.MATCH_PARENT) {
// Child wants to be our size. So be it.
//子View是MATCH_PARENT
//子View想要父布局所有大小，则把父布局剩余的大小都给子View
//子View的SpecMode是EXACTLY
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.
//子View是WRAP_CONTENT
//子View想要在后面自己计算自己需要多少大小
//则把父布局剩余的大小存入SpecSize，但SpecMode为AT_MOST
//表示子布局在后面measure自己大小的同时不能超过SpecSize的值
resultSize = size;
resultMode = MeasureSpec.AT_MOST;
}
break;
// Parent has imposed a maximum size on us
//父布局Mode为AT_MOST
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.
//子View是MATCH_PARENT
//由于父布局没有确定大小，所以子布局在确定自己需要多少大小前不能给出确定大小
//则把父布局剩余的大小存入SpecSize，但SpecMode为AT_MOST
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
//如果子View是MATFH_PARENT
//由于父布局没有限定子布局大小，则设置SpecSize值为0 （需要View支持这种模式）
//设置SpecMode类型还是为UNSPECIFIED，这样最后计算出有多大就给多大，没有父布局的限制（下同）
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
//生成MeasureSpec
return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
}
在计算出用于子View进行measure的高和宽的MeasureSpec后，便会进入到子View的measure()方法。如果子View是ViewGroup类型，则会继续调用到其子View的measure()方法，并调用setMeasuredDimension()方法设置mMeasureHeight和mMeasureWidth完成自己的measure；如果是子View是一个控件（例如TextView），则会根据自己onMeasure()的实现完成自身的测量，也是调用setMeasuredDimension()方法设置变量。通过这样的方式便个遍历完View树上所有的ViewGroup中间节点和View叶节点，完成measure流程。
2. performLayout()流程
进入ViewRootImpl.performLayout()源码。
private void performLayout(WindowManager.LayoutParams lp, int desiredWindowWidth,
int desiredWindowHeight) {
... Trace.traceBegin(Trace.TRACE_TAG_VIEW, "layout");
try {
host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());
... } finally {
Trace.traceEnd(Trace.TRACE_TAG_VIEW);
}
mInLayout = false;
}
这里调用的到DecorView的layout方法，该方法是实际上是调用到到了ViewGroup的layout()方法。上面介绍measure流程时我们知道了两个相关方法measure()和onMeasure()，其中measure()方法在所有视图到基类View中实现的，且不能被重写；而onMeasure()方法实现了实际的测量过程，需要由继承了View的视图子类重写该方法从而实现了自己的测量逻辑。而对于Layout流程，也有着两个相关方法layout()和onLayout()，进入View.java代码看这连个方法。View.layout()方法后面详讲。
public void layout(int l, int t, int r, int b) {
...
onLayout(changed, l, t, r, b);
...
}
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
}
首先这里的layout()方法没有final修饰符，表示layout()方法可以被重写，另外onLayout()方法是一个空方法，所以需要View的子类根据自己需求来重写该方法来完成layout流程。再来看下继承自View的ViewGroup类的layout()和onLayout()方法。
@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);
}
super.layout(l, t, r, b);
} else {
// record the fact that we noop'd it; request layout when transition finishes
mLayoutCalledWhileSuppressed = true;
}
} @Override
protected abstract void onLayout(boolean changed,
int l, int t, int r, int b);
ViewGroup的layout()方法加上了final修饰符，而onLayout()方法则是抽象类型的，所以所有继承自ViewGroup类的布局类（例如FrameLayout.java）都需要实现onLayout()方法，而不能重写layout()方法。并且ViewGroup中的layout()的方法只是加上一些对于过渡动画逻辑的处理，本质上是调回了View的layout()方法。
在ViewRootImpl.performLayout()方法中调用到了DecorView的layout()的方法，根据上方代码super.layout()实际调用到了View的layout()方法。注意这里传入的四个参数，分别为0，0, host.getMeasuredWidth(), host.getMeasuredHeight()，后两个值就是在measure流程中计算出来的mMeasuredWidth和MeasuredHeigth，用于表示需要的宽度和高度。进入View.layout()方法代码。
public void layout(int l, int t, int r, int b) {
//mPrivateFlag3记录了measure过程是否被跳过，如果被跳过则这时候再调用一次measure()，前文有提
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;
//layoutoutMode为Optical则会调到setOpticalFrame()
//setOpticalFrame()会对传入的参数进行调整，但还是调用到setFrame()方法
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);
...
}
mPrivateFlags &= ~PFLAG_FORCE_LAYOUT;
mPrivateFlags3 |= PFLAG3_IS_LAID_OUT;
}
首先会调用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;
//会回调onSizeChanged()方法
if (sizeChanged) {
sizeChange(newWidth, newHeight, oldWidth, oldHeight);
}
...
}
return changed;
}
这个方法比较简单，主要是将父类传入的区域保存到View的mLeft、mTop、mRight、mBottom。在执行完setFrame()之后便会执行到onLayout()方法。这里我们通过插入一段TextView.java类的onLayout()方法，来探究下layout这个流程究竟是要完成什么工作？TextView的layout也是从其父类传入四个参数调用到View.layout()方法（上面代码），然后setFrame()，然后就会进入到进入TextView.onLayout()代码。
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
super.onLayout(changed, left, top, right, bottom);
if (mDeferScroll >= 0) {
int curs = mDeferScroll;
mDeferScroll = -1;
bringPointIntoView(Math.min(curs, mText.length()));
}
}
可以看到这里只是在调用了View.onLayout()后添加了一个DeferScroll的逻辑处理。而回想下View.onLayout()方法其实什么都没有做，但这样TextView的layout流程就结束了。那对于TextView来说，layout流程到底做了什么事呢？其实主要就是设置了mLeft、mTop、mRight、mBottom这四个变量，这四个变量指示了这个TextView在屏幕上应该出现的坐标位置区域；而这四个变量，是由TextView的父布局View计算好了，再调用到TextView.layout()方法时传入的。所以整个layout过程，实际遍历整个View树，根据measure过程计算出的View需要的宽度和高度值结合自己的LayoutParam属性，计算出所有View在相对于自己父布局View的边界的位置，并保存到mLeft、mTop、mRight、mBottom变量中，用于后面的绘制操作。
上面可以知道TextView的layout计算出来的现实区域直接时父布局传入的，所以较为复杂的计算逻辑是处于Layout类onLayout()源码中的。DecorView继承自FrameLayout，DecorView.onLayout()方法会调用到其父类FrameLayout类的onLayout()方法，进入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();
//计算当前Layout的边界padding值
final int parentLeft = getPaddingLeftWithForeground();
final int parentRight = right - left - getPaddingRightWithForeground();
final int parentTop = getPaddingTopWithForeground();
final int parentBottom = bottom - top - getPaddingBottomWithForeground();
//遍历该Layout的所有子View
//结合子View的measure值，即自己的属性，计算出子View的layout区域，并调用子View的layout()方法
for (int i = 0; i < count; i++) {
final View child = getChildAt(i);
if (child.getVisibility() != GONE) {
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
//获得该子布局measure出来的宽、高值
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; //该Layout水平方向的gravity属性各种情况下的处理
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;
}
//该Layout垂直方法的gravity属性各种情况的处理
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的区域
child.layout(childLeft, childTop, childLeft + width, childTop + height);
}
}
}
这样随着Layout的onLayout()调用到所有子View的layout()方法，而子View的layout()又会继续往下遍历直至遍历到View树到所有节电，这样就完成了整个layout的流程。
3. perfromDraw()流程
执行完performLayout()方法，便会调用到performDraw()方法，进入到ViewRootImpl.performDraw()方法。
private void performDraw() {
if (mAttachInfo.mDisplayState == Display.STATE_OFF && !mReportNextDraw) {
return;
}
//是否需要全部重绘的标志
final boolean fullRedrawNeeded = mFullRedrawNeeded;
mFullRedrawNeeded = false;
mIsDrawing = true;
Trace.traceBegin(Trace.TRACE_TAG_VIEW, "draw");
try {
draw(fullRedrawNeeded);
} finally {
mIsDrawing = false;
Trace.traceEnd(Trace.TRACE_TAG_VIEW);
}
...
}
这里主要关注调用到了draw()方法，进入ViewRootImpl.draw()代码。
private void draw(boolean fullRedrawNeeded) {
...
//如果是第一次绘制，则会回调到sFirstDrawHandlers中的事件
//在ActivityThread.attch()方法中有将回调事件加入该队列
//回调时会执行ActivityThread.ensureJitEnable来确保即时编译相关功能
if (!sFirstDrawComplete) {
synchronized (sFirstDrawHandlers) {
sFirstDrawComplete = true;
final int count = sFirstDrawHandlers.size();
for (int i = 0; i< count; i++) {
mHandler.post(sFirstDrawHandlers.get(i));
}
}
}
//滚动相关处理，如果scroll发生改变，则回调dispatchOnScrollChanged()方法
scrollToRectOrFocus(null, false);
if (mAttachInfo.mViewScrollChanged) {
mAttachInfo.mViewScrollChanged = false;
mAttachInfo.mTreeObserver.dispatchOnScrollChanged();
}
//窗口当前是否有动画需要执行
boolean animating = mScroller != null && mScroller.computeScrollOffset();
... //scroll相关处理
final Rect dirty = mDirty;
...
if (fullRedrawNeeded) {
mAttachInfo.mIgnoreDirtyState = true;
dirty.set(0, 0, (int) (mWidth * appScale + 0.5f), (int) (mHeight * appScale + 0.5f));
}
...
if (!dirty.isEmpty() || mIsAnimating || accessibilityFocusDirty) {
//mAttachInfo.mHardwareRenderer不为null，则表示该Window使用硬件加速进行绘制
//执行ViewRootImpl.set()方法会判断是否使用硬件加速
//若判断使用会调用ViewRootImpl.enableHardwareAcceleration()来初始化mHardwareRenderer
//该View设置为使用硬件加速，且当前硬件加速处于可用状态
if (mAttachInfo.mHardwareRenderer != null && mAttachInfo.mHardwareRenderer.isEnabled()) {
...
//使用硬件加速绘制方式
mAttachInfo.mHardwareRenderer.draw(mView, mAttachInfo, this);
} else {// If we get here with a disabled & requested hardware renderer, something went
// wrong (an invalidate posted right before we destroyed the hardware surface
// for instance) so we should just bail out. Locking the surface with software
// rendering at this point would lock it forever and prevent hardware renderer
// from doing its job when it comes back.
// Before we request a new frame we must however attempt to reinitiliaze the
// hardware renderer if it's in requested state. This would happen after an
// eglTerminate() for instance.
//如果当前View要求使用硬件加速，但硬件加速处于disable状态
//可能是由于硬件加速在销毁之前的surface实例时会发出无效的宣告导致的
if (mAttachInfo.mHardwareRenderer != null &&
!mAttachInfo.mHardwareRenderer.isEnabled() &&
mAttachInfo.mHardwareRenderer.isRequested()) {
try {
//尝试重新初始化当前window的硬件加速
mAttachInfo.mHardwareRenderer.initializeIfNeeded(
mWidth, mHeight, mAttachInfo, mSurface, surfaceInsets);
} catch (OutOfResourcesException e) {
handleOutOfResourcesException(e);
return;
}
mFullRedrawNeeded = true;
scheduleTraversals();
return;
}
//使用软件渲染绘制方式
if (!drawSoftware(surface, mAttachInfo, xOffset, yOffset, scalingRequired, dirty)) {
return;
}
}
}
...
}
mDirty表示的是当前需要更新的区域，即脏区域。经过一些scroll相关的处理后，如果脏区域不为空或者有动画需要执行时，便会执行重绘窗口的工作。有两种绘制方式，硬件加速绘制方式和软件渲染绘制方式，在创建窗口流程的ViewRootImpl.setView()中，会根据不同情况，来选择是否创mAttachInfo.mHardwareRenderer对象。如果该对象不为空，则会进入硬件加速绘制方式，即调用到ThreadedRenderer.draw()；否则则会进入软件渲染的绘制方式，调用到ViewRootImpl.drawSoftware()方法。但是无论哪种方式，都会走到mView.draw()方法，即DecorView.draw()方法。该方法是实际调用到到是View.draw(Canvas canvas)方法。
在调用View.draw()方式时调用该方法时会传入canvas参数，硬件加速和软件渲染这两种方式会创建出不同的Canvas用以执行View的draw流程。Canvas顾名思义就是画布的意思，这个类一方面代表了当前用于绘制的区域及区域属性相关信息，同时也提供了各类接口用于在这片区域上画出给类图形，比如调用canvas.drawCircle(...)方法就根据传入参数在屏幕上画出一个特定的圆圈。硬件加速和软件渲染这两种方式对于Canvas有着不同的底层实现，带来的效果和对系统性能及内存这些的影响也不一样，这里我们不再展开介绍。直接看来View.draw()方法。
@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)
*/
//根据上面注释可以知道draw的过程分为5步
//1.画出背景background
//2.判断是否需要画边缘的渐变效果
//3.画出当前View需要显示的内容，调用onDraw()来实现
//4.调用dispatchDraw()方法，进入子视图的draw逻辑
//5.如果需要花边缘渐变效果，则在这里画
//6.绘制装饰（如滚动条） // 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;
//如果不需要绘制边缘渐变效果，跳过了step5
if (!verticalEdges && !horizontalEdges) {
// Step 3, draw the content
//绘制自己View的内容
if (!dirtyOpaque) onDraw(canvas); // Step 4, draw the children
//调起子View的Draw过程
dispatchDraw(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); // 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)
*/
... //有边缘渐变效果的处理// 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
... //画出边缘渐变效果// 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);
}
注释已经很清楚，View的draw过程分为了五个步骤，如果没有边缘渐变效果则会跳过第五步。这里我们关注onDraw()方法实现了自己View内容的绘制和dispatchDraw()方法调起了自己的子View的绘制过程。首先，在调用View中调用onDraw()时，由于走的时DecorView的流程，所以会调用到DecorView.onDraw()方法，代码如下。
@Override
public void onDraw(Canvas c) {
super.onDraw(c);
//DecorView设置了一个BackgroundFallback，该对象用于应用没有设置window背景时，会显示该对象指示的背景
mBackgroundFallback.draw(mContentRoot, c, mWindow.mContentParent);
}
这里实际调用到的是父类的onDraw()方法，但是在DecorView的父类FrameLayout及更上一层的ViewGroup上都没有实现该方法，所以super.onDraw()实际调用到了View.onDraw()方法。
protected void onDraw(Canvas canvas) {
}
但是View.onDraw()方法是一个空实现，这里可以看出来，onDraw()方法是用于父类进行重写来实现画出自己内容的方法，而ViewGroup及其各种Layout子类都没有实现该方法，因为对于布局来说本身就是用来放置控件的，自己是没有什么内容好绘制的，所以在onDraw()是并未执行什么内容。自然作为FrameLayout子类的DecorView也没有什么好画出来的，除了画出一个FallbackBackground。但如果当前的View不是DecorView，也不是其它布局View，而是一个控件类型的View，那在onDraw()时就会根据自己的属性及自己需要显示的区，通过调用传入的Canvas对象的各种方法，来在屏幕上画出自己需要显示的内容。
再来看View.draw()方法里的Step4调用到disptachDraw()方法，在View.dispatchDraw()方法还是一个空实现，说明是希望View的子类来实现的。而一般的非ViewGroup的控件子View类则不会实现该方法，因为这里View是没有子View的，所以当遍历到控件类型的View时，这一步实际上是什么都没有做的。我们继续来看DecorView的draw流程，这里调用到dispatchDraw()实际调用到到是ViewGroup.dispatchDraw()方法，进入该代码。
@Override
protected void dispatchDraw(Canvas canvas) {
boolean usingRenderNodeProperties = canvas.isRecordingFor(mRenderNode);
final int childrenCount = mChildrenCount;
final View[] children = mChildren;
int flags = mGroupFlags;
//如果当前的ViewGroup需要执行Layout级别的动画
if ((flags & FLAG_RUN_ANIMATION) != 0 && canAnimate()) {
final boolean buildCache = !isHardwareAccelerated();
for (int i = 0; i < childrenCount; i++) {
final View child = children[i];
if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE) {
final LayoutParams params = child.getLayoutParams();
//将需要执行的动画设置到子View的对应属性上
attachLayoutAnimationParameters(child, params, i, childrenCount);
bindLayoutAnimation(child);
}
} final LayoutAnimationController controller = mLayoutAnimationController;
if (controller.willOverlap()) {
mGroupFlags |= FLAG_OPTIMIZE_INVALIDATE;
}
//启动mLayoutAnimationControlle中设置的动画
controller.start(); mGroupFlags &= ~FLAG_RUN_ANIMATION;
mGroupFlags &= ~FLAG_ANIMATION_DONE;
//动画启动时的回调
if (mAnimationListener != null) {
mAnimationListener.onAnimationStart(controller.getAnimation());
}
} int clipSaveCount = 0;
final boolean clipToPadding = (flags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK;
//如果当前的ViewGroup设置了Padding的属性
if (clipToPadding) {
clipSaveCount = canvas.save();
//将父视图传入的canvas裁剪去padding的区域
canvas.clipRect(mScrollX + mPaddingLeft, mScrollY + mPaddingTop,
mScrollX + mRight - mLeft - mPaddingRight,
mScrollY + mBottom - mTop - mPaddingBottom);
} ...
for (int i = 0; i < childrenCount; i++) {
... //TransientView的处理 final int childIndex = getAndVerifyPreorderedIndex(childrenCount, i, customOrder);
final View child = getAndVerifyPreorderedView(preorderedList, children, childIndex);
if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {
more |= drawChild(canvas, child, drawingTime);
}
}
...
// Draw any disappearing views that have animations
//绘制mDisappearingChildren列别中的子视图，指正在处于消失动画状态的子View
if (mDisappearingChildren != null) {
final ArrayList<View> disappearingChildren = mDisappearingChildren;
final int disappearingCount = disappearingChildren.size() - 1;
// Go backwards -- we may delete as animations finish
for (int i = disappearingCount; i >= 0; i--) {
final View child = disappearingChildren.get(i);
more |= drawChild(canvas, child, drawingTime);
}
}
...
//检查动画是否完成，如果完成则发送一个异步消息，通知应用程序
if ((flags & FLAG_ANIMATION_DONE) == 0 && (flags & FLAG_NOTIFY_ANIMATION_LISTENER) == 0 &&
mLayoutAnimationController.isDone() && !more) {
// We want to erase the drawing cache and notify the listener after the
// next frame is drawn because one extra invalidate() is caused by
// drawChild() after the animation is over
mGroupFlags |= FLAG_NOTIFY_ANIMATION_LISTENER;
final Runnable end = new Runnable() {
@Override
public void run() {
notifyAnimationListener();
}
};
post(end);
}
}
在dispatch中会遍历当前ViewGroup的子视图，然后调用drawChild()方法来依次调起子视图的绘制过程，进入ViewGroup.drawChild()代码。
protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
return child.draw(canvas, this, drawingTime);
}
这里直接就调用到了child.draw()方法，但是注意，这里的draw()方法与我们之前分析过的View.draw()方法参数不一样，不仅传入了父布局视图的画布，还把父布局视图视图自身作为参数传入了。进入有三个参数的View.draw()方法的代码。
/**
* This method is called by ViewGroup.drawChild() to have each child view draw itself.
*
* This is where the View specializes rendering behavior based on layer type,
* and hardware acceleration.
*/
//这个方法是专门用于ViewGroup来调其子View的绘制过程的方法
//方法会传入当前View的父布局View，用来进行父布局canvas画布的区域移动和裁剪工作
//该方法会根据绘制类型（硬件加速、软件渲染）结合View属性进行一些canvas和painter属性设置工作
boolean draw(Canvas canvas, ViewGroup parent, long drawingTime) {
...
draw(canvas);
...
}
这个方法很长，但都是逻辑算法类型的，不影响到后面的流程，方法的作用见*注释。我们回想一下之前的流程，从canvas的创建，到视图使用canvas进行绘制，并未涉及到canvas的裁剪动作。那是是因为我们是从DecorView进行分析的，在我们略过的canvas初始化动作时就根据DecorView在layout布局时计算出来的显示区域，进行了canvas画布区域的实质；而对于其它的ViewGroup在调起其子View的绘制动作时，就会调用到上方有三个参数的View.draw()方法，在该方法中结合layout过程中的计算结果，完成canvas画布的裁剪，然后再调用View.draw(Canvas)方法（之前介绍过的包含五个步骤的方法）来完成当前View的绘制过程。通过这样一个流程，便能够调用到视图树上所有ViewGroup和控件View的draw()方法，画出了所有View需要显示的内容，完成了一次绘制过程。