View的绘制是从ViewRoot的performTraversals()开始的，该函数做的执行过程主要是根据之前设置的状态，判断是否重新计算视图大小(measure)、是否重新放置视图的位置(layout)、以及是否重绘(draw)，其核心也就是通过判断来选择顺序执行这三个方法中的哪个。performTraversals()这个方法完成了对顶级View的measure，layout，draw三个过程，其中又会分别对子View进行遍历，实现整个View的绘制。
private void performTraversals() {
......
//lp.width和lp.height在创建ViewGroup实例时等于MATCH_PARENT
int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);
......
mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);
......
mView.layout(0, 0, mView.getMeasuredWidth(), mView.getMeasuredHeight());
......
mView.draw(canvas);
......
}在第5~6行获取了根视图的MeasureSpec，size等于屏幕的大小，mode是At_Most。接着就调用measure()方法进行测量，所以首先看看measure的过程。
View的measure过程
measure()方法
public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
......
// measure ourselves, this should set the measured dimension flag back
onMeasure(widthMeasureSpec, heightMeasureSpec);
......
}其中传入的两个参数信息是宽高的参数信息，用于计算实际宽高，它真实的测量是在onMeasure(int, int)中完成的，并且可以看到measure()方法是一个final方法，所以不能重写，所以我们只需要重写onMeasure()方法。至于widthMeasureSpec和heightMeasureSpec从哪里来的，下面会分析到。
onMeasure()方法
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
}MeasureSpec
它是一个32位的int值，高两位代表模式，低30位代表大小，模式有以下三种：
UNSPECIFIED：父容器对这个view没有任何限制，可以得到任意它想要的大小
EXACTLY：父容器已经决定了View的精确大小，也就是父容器的SpecSize的大小，相当于我们的match_parent
AT_MOST：父容器指定了一个大小SpecSize，View不能超过这个大小，具体根据实际情况，相当于wrap_content
一个View的MeasureSpec确定了，再通过onMeasure()方法，那么它的大小也就确定了，一个View的MeasureSpec的确定是由父容器的MeasureSpec和它自身的LayoutParams共同决定的。
getDefaultSize()方法
public static int getDefaultSize(int size, int measureSpec) {
int result = size;
int specMode = MeasureSpec.getMode(measureSpec);
int specSize = MeasureSpec.getSize(measureSpec);
switch (specMode) {
case MeasureSpec.UNSPECIFIED:
result = size;
break;
case MeasureSpec.AT_MOST:
case MeasureSpec.EXACTLY:
result = specSize;
break;
}
return result;
}第3~4行，根据父类的MeasureSpec来计算出其中的mode和size。
第6~14行，用一个switch语句根据父类不同的mode来返回不同的大小。
protected int getSuggestedMinimumWidth() {
return (mBackground == null) ? mMinWidth : max(mMinWidth, mBackground.getMinimumWidth());
}
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);
} private void setMeasuredDimensionRaw(int measuredWidth, int measuredHeight) {
mMeasuredWidth = measuredWidth;
mMeasuredHeight = measuredHeight;
mPrivateFlags |= PFLAG_MEASURED_DIMENSION_SET;
}至此一个简单view的测量就完毕了。可以知道基本上view都是嵌套的，并不会一个view这么简单，所以下面看看ViewGroup的测量。
ViewGroup的measure()
对于ViewGrouo来说，除了完成自身的measure之外，还需要去遍历所以的子元素，去调用它们的measure()方法，然后各个子View再递归去执行这个过程。ViewGroup是一个抽象类，并没有去重写View的onMeasure()方法，并没有定义具体的测量过程，所以需要它的子类去实现onMeasure()方法，这是因为各个ViewGroup的子类的特效不同导致的测量方法不同，但是ViewGroup中提供了measureChildren, measureChild, measureChildWithMargins方法来进行测量。
measureChildren()
protected void measureChildren(int widthMeasureSpec, int heightMeasureSpec) {
final int size = mChildrenCount;
final View[] children = mChildren;
for (int i = 0; i < size; ++i) {
final View child = children[i];
if ((child.mViewFlags & VISIBILITY_MASK) != GONE) {
measureChild(child, widthMeasureSpec, heightMeasureSpec);
}
}
}
measureChild()
protected void measureChild(View child, int parentWidthMeasureSpec,
int parentHeightMeasureSpec) {
final LayoutParams lp = child.getLayoutParams();
final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
mPaddingLeft + mPaddingRight, lp.width);
final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
mPaddingTop + mPaddingBottom, lp.height);
child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}getChildMeasureSpec()
public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
//获取父类MeasureSpec的size和mode
int specMode = View.MeasureSpec.getMode(spec);
int specSize = View.MeasureSpec.getSize(spec);
//得到父类的除去padding的剩余大小
int size = Math.max(0, specSize - padding);
int resultSize = 0;
int resultMode = 0;
//根据父类的mode做switch语句
switch (specMode) {
// Parent has imposed an exact size on us
case View.MeasureSpec.EXACTLY:
if (childDimension >= 0) {
//如果layout_width(layout_height)属性设置了具体的值，并且大于0
//那么child的size就等于这个具体的值，mode为Exactly
resultSize = childDimension;
resultMode = View.MeasureSpec.EXACTLY;
} else if (childDimension == LayoutParams.MATCH_PARENT) {
// 如果layout_width(layout_height)属性设置为match_parent
//意味着child想要尽可能大，最大为多少，当然是父类剩余的大小，这个大小是个确定的值所以mode为Exactly
resultSize = size;
resultMode = View.MeasureSpec.EXACTLY;
} else if (childDimension == LayoutParams.WRAP_CONTENT) {
// 如果layout_width(layout_height)属性设置为wrap_content
//意味着自身想要多大就给多大，但是不能超出父类的限制
resultSize = size;
resultMode = View.MeasureSpec.AT_MOST;
}
break;
//下面的情况就和上面的类似了
// Parent has imposed a maximum size on us
case View.MeasureSpec.AT_MOST:
if (childDimension >= 0) {
// Child wants a specific size... so be it
resultSize = childDimension;
resultMode = View.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 = View.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 = View.MeasureSpec.AT_MOST;
}
break;
// Parent asked to see how big we want to be
case View.MeasureSpec.UNSPECIFIED:
if (childDimension >= 0) {
// Child wants a specific size... let him have it
resultSize = childDimension;
resultMode = View.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 = View.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 = View.MeasureSpec.UNSPECIFIED;
}
break;
}
return View.MeasureSpec.makeMeasureSpec(resultSize, resultMode);
}这个方法主要就是通过自身的LayoutParams和父类的MeasureSpec来获得child的MeasureSpec，根据上面的情况可以得到下面的对照表：
记得之前在view的getDefaultSize()方法中，无论mode是At_Most或者Exactly都是返回specSize，根据这个表对照，可以知道当我们自定义一个View，对它的onMeasure不做任何处理的话，宽高设置成match_parent或者wrap_content，返回的大小都是parentSize，也就是充满父容器，当然设置具体的值返回的就是childSize了。所以那么如果我们要自定义view设置wrap_content时，不要充满父容器的效果该怎么实现，看看下面的处理方式。
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
//通过getChildMeasureSpec()方法获取到的MeasureSpec，获取到它们的mode和size
int widthMode = MeasureSpec.getMode(widthMeasureSpec);
int widthSize = MeasureSpec.getSize(widthMeasureSpec);
int heightMode = MeasureSpec.getMode(heightMeasureSpec);
int heightSize = MeasureSpec.getSize(heightMeasureSpec);
//mWidth、mHeight是固定的值
if (widthMode == MeasureSpec.AT_MOST && heightMode == MeasureSpec.AT_MOST) {
//宽高都设置为wrap_content
setMeasuredDimension(mWidth, mHeight);
} else if (widthMode == MeasureSpec.AT_MOST) {
//宽度设置为wrap_content
setMeasuredDimension(mWidth, heightSize);
} else if (heightMode == MeasureSpec.AT_MOST) {
//高度设置为wrap_content
setMeasuredDimension(widthSize, mHeight);
}
}
measure总结
从最开始遍历ViewGroup的子View，如果这个子View是ViewGroup那么再重复上面的过程，如果是View，那么就调用它的measure()方法，在measure()方法中会调用onMeasure()方法，在onMeasure()又会最终调用setMeasuredDimension()，把测量值存储起来，这样递归调用就完成了View的测量过程。
measure()方法是final的，所以不能重写，只能重写onMeasure()方法实现自己的逻辑，但是在onMeasure()方法中必须去调用setMeasuredDimension()，因为这个方法才最终完成测量，所以要么自己去调用要么写supper.onMeasure()
一个View的大小是由MeasureSpec决定的，一个MeasureSpec是由它父类的MeasureSpec和自身的LayoutParams决定的。
可以调用getMeasuredWidth()和getMeasuredHeight()来获得测量大小，但是必须在测量后调用。
layout过程
layout是用来确定视图的位置，是View绘制的第二阶段，parent会调用每一个子view的layout方法去放置它。首先看看View的layout()方法
public void layout(int l, int t, int r, int b) {
if ((mPrivateFlags3 & PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT) != 0) {
onMeasure(mOldWidthMeasureSpec, mOldHeightMeasureSpec);
mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
}
int oldL = mLeft;
int oldT = mTop;
int oldB = mBottom;
int oldR = mRight;
boolean changed = isLayoutModeOptical(mParent) ?
setOpticalFrame(l, t, r, b) : setFrame(l, t, r, b);
if (changed || (mPrivateFlags & PFLAG_LAYOUT_REQUIRED) == PFLAG_LAYOUT_REQUIRED) {
onLayout(changed, l, t, r, b);
mPrivateFlags &= ~PFLAG_LAYOUT_REQUIRED;
ListenerInfo li = mListenerInfo;
if (li != null && li.mOnLayoutChangeListeners != null) {
ArrayList<OnLayoutChangeListener> listenersCopy =
(ArrayList<OnLayoutChangeListener>)li.mOnLayoutChangeListeners.clone();
int numListeners = listenersCopy.size();
for (int i = 0; i < numListeners; ++i) {
listenersCopy.get(i).onLayoutChange(this, l, t, r, b, oldL, oldT, oldR, oldB);
}
}
}
mPrivateFlags &= ~PFLAG_FORCE_LAYOUT;
mPrivateFlags3 |= PFLAG3_IS_LAID_OUT;
}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);
}
super.layout(l, t, r, b);
} else {
// record the fact that we noop'd it; request layout when transition finishes
mLayoutCalledWhileSuppressed = true;
}
}
/**
* {@inheritDoc}
*/
@Override
protected abstract void onLayout(boolean changed,
int l, int t, int r, int b);LinearLayout的onLayout
@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
if (mOrientation == VERTICAL) {
layoutVertical(l, t, r, b);
} else {
layoutHorizontal(l, t, r, b);
}
}void layoutVertical(int left, int top, int right, int bottom) {
final int paddingLeft = mPaddingLeft;
int childTop;
int childLeft;
//得到宽度
final int width = right - left;
int childRight = width - mPaddingRight;
//出去padding的宽度
int childSpace = width - paddingLeft - mPaddingRight;
final int count = getVirtualChildCount();
//根据Gravity计算childTop
final int majorGravity = mGravity & Gravity.VERTICAL_GRAVITY_MASK;
final int minorGravity = mGravity & Gravity.RELATIVE_HORIZONTAL_GRAVITY_MASK;
switch (majorGravity) {
case Gravity.BOTTOM:
// mTotalLength contains the padding already
childTop = mPaddingTop + bottom - top - mTotalLength;
break;
// mTotalLength contains the padding already
case Gravity.CENTER_VERTICAL:
childTop = mPaddingTop + (bottom - top - mTotalLength) / 2;
break;
case Gravity.TOP:
default:
childTop = mPaddingTop;
break;
}
//开始遍历
for (int i = 0; i < count; i++) {
final View child = getVirtualChildAt(i);
if (child == null) {
childTop += measureNullChild(i);
} else if (child.getVisibility() != GONE) {
//获取child测量后的宽高
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;
}
//计算childLeft
final int layoutDirection = getLayoutDirection();
final int absoluteGravity = Gravity.getAbsoluteGravity(gravity, layoutDirection);
switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
case Gravity.CENTER_HORIZONTAL:
childLeft = paddingLeft + ((childSpace - childWidth) / 2)
+ lp.leftMargin - lp.rightMargin;
break;
case Gravity.RIGHT:
childLeft = childRight - childWidth - lp.rightMargin;
break;
case Gravity.LEFT:
default:
childLeft = paddingLeft + lp.leftMargin;
break;
}
//加上分割线的高度
if (hasDividerBeforeChildAt(i)) {
childTop += mDividerHeight;
}
//加上子View的marginTop
childTop += lp.topMargin;
setChildFrame(child, childLeft, childTop + getLocationOffset(child),
childWidth, childHeight);
//childTop加上这个放置了的child的高度和marginBottom
childTop += childHeight + lp.bottomMargin + getNextLocationOffset(child);
i += getChildrenSkipCount(child, i);
}
}
}所以在parent调用自己的layout()方法后，就会调用onLayout方法，在这个方法中又会去调用子View的layout方法，就这样一层层的传递下去就完成了整个View的layout。
private void setChildFrame(View child, int left, int top, int width, int height) {
child.layout(left, top, left + width, top + height);
}
public final int getWidth() {
return mRight - mLeft;
}
draw过程
public void draw(Canvas canvas) {
final int privateFlags = mPrivateFlags;
final boolean dirtyOpaque = (privateFlags & PFLAG_DIRTY_MASK) == PFLAG_DIRTY_OPAQUE &&
(mAttachInfo == null || !mAttachInfo.mIgnoreDirtyState);
mPrivateFlags = (privateFlags & ~PFLAG_DIRTY_MASK) | PFLAG_DRAWN;
/*
* Draw traversal performs several drawing steps which must be executed
* in the appropriate order:
*
* 1. Draw the background
* 2. If necessary, save the canvas' layers to prepare for fading
* 3. Draw view's content
* 4. Draw children
* 5. If necessary, draw the fading edges and restore layers
* 6. Draw decorations (scrollbars for instance)
*/
// Step 1, draw the background, if needed
int saveCount;
if (!dirtyOpaque) {
drawBackground(canvas);
}
// skip step 2 & 5 if possible (common case)
final int viewFlags = mViewFlags;
boolean horizontalEdges = (viewFlags & FADING_EDGE_HORIZONTAL) != 0;
boolean verticalEdges = (viewFlags & FADING_EDGE_VERTICAL) != 0;
if (!verticalEdges && !horizontalEdges) {
// Step 3, draw the content
if (!dirtyOpaque) onDraw(canvas);
// Step 4, draw the children
dispatchDraw(canvas);
// 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;
}
277
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
