在Android的学习道路上，每一个人员都免不了去翻阅Android的源码，因为只有从源码的角度分析问题，我们才能真正的玩转Android开发。最近由于工作比较闲，总想着想写点什么东西，正好自己也可以整理一下。考虑到view的显示机制是自定义view的基础，也是面试中经常被问到的问题，所以记录此文，和大家共享，因水平有限，望大家踊跃拍砖，不胜感激。
有过自定义view的同行们都应该知道，view的显示依托于activity的setContentView方法依附到PhoneWindow窗体上的，在显示的过程中，这个view会经历测量（measure）、布局（layout）、draw（绘制）三个阶段， measure阶段就是得到每个View的大小，layout阶段就是计算每个View在UI上的坐标，draw阶段就是根据前面两个阶段的数据进行UI绘制。绘制完毕后方可被显示在界面上。
measure：
当我们要讲一个xml显示到ui上时，就是把layout的id传入到activity的setContentView中去，最终调用的是ViewRoot的performTraversals方法，此方法担任着view的绘制工作。
private void performTraversals() {
final View host = mView;
if (DBG) {
host.debug();
}
if (host == null || !mAdded)
return;
......
Rect frame = mWinFrame;
if (mFirst) {
fullRedrawNeeded = true;
mLayoutRequested = true;
DisplayMetrics packageMetrics = mView.getContext().getResources().getDisplayMetrics();
desiredWindowWidth = packageMetrics.widthPixels;
desiredWindowHeight = packageMetrics.heightPixels;
......
}
........
boolean insetsChanged = false;
if (mLayoutRequested) {
getRunQueue().executeActions(attachInfo.mHandler);
if (mFirst) {
host.fitSystemWindows(mAttachInfo.mContentInsets);
mAttachInfo.mInTouchMode = !mAddedTouchMode;
ensureTouchModeLocally(mAddedTouchMode);
} else {
if (!mAttachInfo.mContentInsets.equals(mPendingContentInsets)) {
mAttachInfo.mContentInsets.set(mPendingContentInsets);
host.fitSystemWindows(mAttachInfo.mContentInsets);
insetsChanged = true;
}
if (!mAttachInfo.mVisibleInsets.equals(mPendingVisibleInsets)) {
mAttachInfo.mVisibleInsets.set(mPendingVisibleInsets);
}
if (lp.width == ViewGroup.LayoutParams.WRAP_CONTENT
|| lp.height == ViewGroup.LayoutParams.WRAP_CONTENT) {
windowResizesToFitContent = true;
DisplayMetrics packageMetrics = mView.getContext().getResources().getDisplayMetrics();
desiredWindowWidth = packageMetrics.widthPixels;
desiredWindowHeight = packageMetrics.heightPixels;
}
}
childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth, lp.width);
childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height);
host.measure(childWidthMeasureSpec, childHeightMeasureSpec);
...........
}在getRootMeasureSpec中传入的参数中有一个参数是lp的属性，而lp的定义是这样的:
final WindowManager.LayoutParams mWindowAttributes = new WindowManager.LayoutParams();
WindowManager.LayoutParams lp = mWindowAttributes;
public LayoutParams() {
super(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
type = TYPE_APPLICATION;
format = PixelFormat.OPAQUE;
}所以也就意味着lp.width和lp.height的值都是match_parent。
在getRootMeasureSpec方法中，根据windowSize和rootDimension返回测量规格。拿lp.width打比方，也就是decorView的width。如果width的值是MATCH_PARENT，那么返回的测量规格就是windowSize + MeasureSpec.EXACTLY的值，如果是WRAP_CONTENT则是
windowSize + MeasureSpec.AT_MOST的值。
private 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;
}至于上述提到的为何将windowSize和rootDimension映射出来的mode值相加，我们需要了解另外一个知识点，先看下面的代码：
public static class MeasureSpec {
private static final int MODE_SHIFT = 30;
private static final int MODE_MASK = 0x3 << MODE_SHIFT;
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(int size, int mode) {
return size + mode;
}
public static int getMode(int measureSpec) {
return (measureSpec & MODE_MASK);
}
public static int getSize(int measureSpec) {
return (measureSpec & ~MODE_MASK);
}
..........
}MeasureSpec.makeMeasureSpec中只是简单的把size和mode进行相加然后返回。这里是因为这样的返回值可以表示出当前view的测量规格和测量大小，如AT_MOST、EXACTLY就是表示mode，他们都是占用2位并且都是int值，int值在java中是占用32位的，所以另外的30位在Android中被设计成了size。也就是说每个高2位表示specMode，而低30位表示尺寸的大小。
做完上一步操作后，就是开始调用host.measure操作来计算view的大小。而host代表的就是DecorView，decorView其实是个FrameLayout也就是个ViewGroup，但是在ViewGroup继承自View，而view的measure方法是不能被重写的，所以host.measure走的还是view的measure方法，在这个方法中调用了ViewGroup的 onMeasure(widthMeasureSpec, heightMeasureSpec)方法，所以我们移步到FrameLayout的onMeasure方法中
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
final int count = getChildCount();
int maxHeight = 0;
int maxWidth = 0;
// Find rightmost and bottommost child
for (int i = 0; i < count; i++) {
final View child = getChildAt(i);
if (mMeasureAllChildren || child.getVisibility() != GONE) {
measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, 0);
maxWidth = Math.max(maxWidth, child.getMeasuredWidth());
maxHeight = Math.max(maxHeight, child.getMeasuredHeight());
}
}
// Account for padding too
maxWidth += mPaddingLeft + mPaddingRight + mForegroundPaddingLeft + mForegroundPaddingRight;
maxHeight += mPaddingTop + mPaddingBottom + mForegroundPaddingTop + mForegroundPaddingBottom;
// 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());
}
setMeasuredDimension(resolveSize(maxWidth, widthMeasureSpec),
resolveSize(maxHeight, heightMeasureSpec));
}这个方法里面调用了measureChildWithMargins方法，其实ViewGroup的子类在测量的时候都会走这个方法，最后还是会调用View类的measure方法进行测量，原型如下：
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);
}在view的measure方法中的两个参数分别对应宽和高的measureSpec，该参数是父视图传递给子视图的一个整型值，也就是说是父视图提供给子视图的测量规格，因为子视图最终占用的窗体大小是由父视图和子视图共同决定的。因此childWidthMeasureSpec是父视图传递给子视图的一个建议值。在测量大小的时候，padding和margin的值也作为大小的一部分。
上面描述的仅仅是view的测量过程。下面分析一下LinearLayout的测量过程：
在LinearLayout的测量中以下为主要代码：
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
if (mOrientation == VERTICAL) {
measureVertical(widthMeasureSpec, heightMeasureSpec);
} else {
measureHorizontal(widthMeasureSpec, heightMeasureSpec);
}
}
/**
* 如果是垂直方向的布局
*/
void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {
mTotalLength = 0;
int maxWidth = 0;
int alternativeMaxWidth = 0;
int weightedMaxWidth = 0;
boolean allFillParent = true;
float totalWeight = 0;
final int count = getVirtualChildCount();
final int widthMode = MeasureSpec.getMode(widthMeasureSpec);
final int heightMode = MeasureSpec.getMode(heightMeasureSpec);
boolean matchWidth = false;
final int baselineChildIndex = mBaselineAlignedChildIndex;
final boolean useLargestChild = mUseLargestChild;
int largestChildHeight = Integer.MIN_VALUE;
// See how tall everyone is. Also remember max width.
// 遍历所有的子View，获取所有子View的总高度，并对每个子View进行measure操作
// 并且记录高度最高的子view
for (int i = 0; i < count; ++i) {
final View child = getVirtualChildAt(i);
if (child == null) {
// //如果child 是Null,则mTotalLength加0
mTotalLength += measureNullChild(i);
continue;
}
if (child.getVisibility() == View.GONE) {
如果child不可见，则跳过
i += getChildrenSkipCount(child, i);
continue;
}
//拿到child的LayoutParams
LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();
//将weight的值加到totalWeight,weight的值就是xml文件中的layout_weight属性的值
totalWeight += lp.weight;
if (heightMode == MeasureSpec.EXACTLY && lp.height == 0 && lp.weight > 0) {
/**
如果父View的mode是EXACTLY，并且height==0 并且lp.weight>0
那么就先不measure这个child，直接把topMargin和bottoMargin等属性加到totaoLength中
*/
final int totalLength = mTotalLength;
mTotalLength = Math.max(totalLength, totalLength + lp.topMargin + lp.bottomMargin);
} else {
int oldHeight = Integer.MIN_VALUE;
//如果父View不是EXACLTY,并且lp.height == 0 && lp.weight > 0，那么将子View的height变为WRAP_CONTENT
if (lp.height == 0 && lp.weight > 0) {
oldHeight = 0;
lp.height = LayoutParams.WRAP_CONTENT;
}
measureChildBeforeLayout(
child, i, widthMeasureSpec, 0, heightMeasureSpec, totalWeight == 0 ? mTotalLength : 0);
if (oldHeight != Integer.MIN_VALUE) {
lp.height = oldHeight;
}
final int childHeight = child.getMeasuredHeight();
final int totalLength = mTotalLength;
mTotalLength = Math.max(totalLength, totalLength + childHeight + lp.topMargin +
lp.bottomMargin + getNextLocationOffset(child));
if (useLargestChild) {
largestChildHeight = Math.max(childHeight, largestChildHeight);
}
}
if ((baselineChildIndex >= 0) && (baselineChildIndex == i + 1)) {
mBaselineChildTop = mTotalLength;
}
.....................
final int margin = lp.leftMargin + lp.rightMargin;
final int measuredWidth = child.getMeasuredWidth() + margin;
maxWidth = Math.max(maxWidth, measuredWidth);
allFillParent = allFillParent && lp.width == LayoutParams.MATCH_PARENT;
if (lp.weight > 0) {
weightedMaxWidth = Math.max(weightedMaxWidth,
matchWidthLocally ? margin : measuredWidth);
} else {
alternativeMaxWidth = Math.max(alternativeMaxWidth,
matchWidthLocally ? margin : measuredWidth);
}
i += getChildrenSkipCount(child, i);
}
if (useLargestChild && heightMode == MeasureSpec.AT_MOST) {
mTotalLength = 0;
for (int i = 0; i < count; ++i) {
final View child = getVirtualChildAt(i);
if (child == null) {
mTotalLength += measureNullChild(i);
continue;
}
if (child.getVisibility() == GONE) {
i += getChildrenSkipCount(child, i);
continue;
}
final LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams)
child.getLayoutParams();
// Account for negative margins
final int totalLength = mTotalLength;
mTotalLength = Math.max(totalLength, totalLength + largestChildHeight +
lp.topMargin + lp.bottomMargin + getNextLocationOffset(child));
}
}
// 给总高度加上自身的padding
mTotalLength += mPaddingTop + mPaddingBottom;
//将所有View的高度赋值给heightSize
int heightSize = mTotalLength;
// Check against our minimum height
// 最小的高度就是背景的高度mBGDrawable.getMinimumHeight()
heightSize = Math.max(heightSize, getSuggestedMinimumHeight());
//这里对heightSize再次赋值，不过如果LinearLayout是xml文件的根标签，并且设置到Activity的话
//此时heightSize的大小就是屏幕的高度，我们暂时就考虑等于屏幕高度的情况，其他情况类似
// Reconcile our calculated size with the heightMeasureSpec
// 如果heightMeasureSpec的size是精确的，那么这个heightsize值==heightMeasureSpec的size，也就是屏幕的高度
heightSize = resolveSize(heightSize, heightMeasureSpec);
// Either expand children with weight to take up available space or
// shrink them if they extend beyond our current bounds
//屏幕的高度还剩下delta
int delta = heightSize - mTotalLength;
if (delta != 0 && totalWeight > 0.0f) {
//如果设置了weightsum属性，这weightSum等于weightsum的属性，否则等于totalWeight
float weightSum = mWeightSum > 0.0f ? mWeightSum : totalWeight;
mTotalLength = 0;
for (int i = 0; i < count; ++i) {
final View child = getVirtualChildAt(i);
if (child.getVisibility() == View.GONE) {
continue;
}
LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();
float childExtra = lp.weight;
if (childExtra > 0) {
// Child said it could absorb extra space -- give him his share
// 计算方式:子view的weight属性值 * 剩余高度 / weight总和
int share = (int) (childExtra * delta / weightSum);
weightSum -= childExtra;
delta -= share;
final int childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec,
mPaddingLeft + mPaddingRight +
lp.leftMargin + lp.rightMargin, lp.width);
// TODO: Use a field like lp.isMeasured to figure out if this
// child has been previously measured
if ((lp.height != 0) || (heightMode != MeasureSpec.EXACTLY)) {
// child was measured once already above...
// base new measurement on stored values
// 重新设置子view的高度
int childHeight = child.getMeasuredHeight() + share;
if (childHeight < 0) {
childHeight = 0;
}
child.measure(childWidthMeasureSpec,
MeasureSpec.makeMeasureSpec(childHeight, MeasureSpec.EXACTLY));
} else {
// child was skipped in the loop above.
// Measure for this first time here
child.measure(childWidthMeasureSpec,
MeasureSpec.makeMeasureSpec(share > 0 ? share : 0,
MeasureSpec.EXACTLY));
}
}
final int margin = lp.leftMargin + lp.rightMargin;
final int measuredWidth = child.getMeasuredWidth() + margin;
maxWidth = Math.max(maxWidth, measuredWidth);
boolean matchWidthLocally = widthMode != MeasureSpec.EXACTLY &&
lp.width == LayoutParams.MATCH_PARENT;
alternativeMaxWidth = Math.max(alternativeMaxWidth,
matchWidthLocally ? margin : measuredWidth);
allFillParent = allFillParent && lp.width == LayoutParams.MATCH_PARENT;
final int totalLength = mTotalLength;
mTotalLength = Math.max(totalLength, totalLength + child.getMeasuredHeight() +
lp.topMargin + lp.bottomMargin + getNextLocationOffset(child));
}
// Add in our padding
mTotalLength += mPaddingTop + mPaddingBottom;
// TODO: Should we recompute the heightSpec based on the new total length?
} else {
alternativeMaxWidth = Math.max(alternativeMaxWidth,
weightedMaxWidth);
}
if (!allFillParent && widthMode != MeasureSpec.EXACTLY) {
maxWidth = alternativeMaxWidth;
}
maxWidth += mPaddingLeft + mPaddingRight;
// Check against our minimum width
maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());
//所有的孩子View测量完毕，为自己设置大小
setMeasuredDimension(resolveSize(maxWidth, widthMeasureSpec), heightSize);
if (matchWidth) {
forceUniformWidth(count, heightMeasureSpec);
}
}在测量的过程中，会遍历出所有的子view，计算出所有子View的总高度和totalWeight，并对每个子View进行measure操作 。
在遍历子view的child过程中，如果child 是Null,则mTotalLength加0 ，如果child是不可见的，不做任何操作继续遍历下一个子view，然后拿到child的layoutParams，取出child的layout_weight，然后 totalWeight加上weight值。
接着判断如果父视图提供的高度mode等于MeasureSpec.EXACTLY，并且child的height等于0，并且child的weight的值大于0的时候，则先不测量这个child，因为有了weight，在把所有的child测量完毕后，再根据weight的值分配高度，但是在这里还是要把child的margin值加上去的，因为就算weight怎么变，margin值是不影响的， mTotalLength = Math.max(totalLength, totalLength + lp.topMargin + lp.bottomMargin)。这里取max的原因是child的margin可能为负数。
如果不满足上一个条件mode等于MeasureSpec.EXACTLY，就需要测量child，经历过测量之后可以知道child的高度，然后把这个高度加入到mTotalLength 中。在这个条件里面，如果child的height等于0，并且child的weight的值大于0，会把当前view的height设置成LayoutParams.WRAP_CONTENT，然后去测量。
到目前为止只是测量出了总的高度，还没有按照weight分配高度，哈哈，上面说了这么多可能有读者快要晕了，没事，说完weight的分配，我会集合源码举个例子给大家讲述（见下一篇文章）。
紧接着给mTotalLength加上父视图的paddingTop和paddingBottom值，得出heightSize。但是每个view都是有背景的，背景是有个高度的，所以要比较heightSize和getSuggestedMinimumHeight()的值的大小，取最大值作为heightSize，getSuggestedMinimumHeight()返回的mBGDrawable.getMinimumHeight()也就是drawable背景的最小高度。接着通过resolveSize再次的给heightSize赋值，因为如果父视图的heightMeasureSpec的mode是精确的话，那么这个heightSize的最终值也就应该是父视图指定的大小。
接下来就开始按照weight分配高度了，在分配高度之前要保证余下的高度heightSize - mTotalLength 不能为0并且totalWeight要大于0。然后遍历子view，得到子view的weight，如果weight大于0，通过公式：child的weight属性值 * 剩余高度 / weight总和计算出child要从剩余的高度里面获得多少的高度值，然后刷新剩余的高度值，给child重新设置高度并进行测量。
最后所有的孩子View测量完毕，调用setMeasuredDimension为自己设置大小。
