View绘制作业流程专业资料.doc

View绘制流程第一步：递归measure源码分析

//final办法，子类不可重写
public final void measure(int widthMeasureSpec，int
heightMeasureSpec) {
......
//回调onMeasure()办法
onMeasure(widthMeasureSpec，heightMeasureSpec);
}
这个办法两个参数都是父View传递过来，代表了父view规格。她由两某些构成，高2位表达MODE，低30位表达size。

//ViewonMeasure默认实现办法
protected void onMeasure(int widthMeasureSpec，
int heightMeasureSpec) {
setMeasuredDimension(
getDefaultSize(getSuggestedMinimumWidth()，widthMeasureSpec),
getDefaultSize(getSuggestedMinimumHeight()，heightMeasureSpec)
);
}
对于非ViewGroupView而言，通过调用上面默认onMeasure即可完毕View测量。setMeasuredDimension函数是一种很核心函数，它完毕了对View成员变量mMeasuredWidth和mMeasuredHeight变量赋值。

public static int getDefaultSize(int size，int measureSpec) {
int result = size;
//通过MeasureSpec解析获取mode与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;
}
protected int getSuggestedMinimumWidth() {
return (mBackground == null) ?mMinWidth max(mMinWidth，
mBackground.getMinimumWidth());
}

protected int getSuggestedMinimumHeight() {
return (mBackground == null) ?mMinHeight ：max(mMinHeight，
mBackground.getMinimumHeight());
}

在ViewGroup中定义了measureChildren，measureChild，measureChildWith-
Margins办法来对子视图进行测量，measureChildren内部实质只是循环调用measureChild。
protected void measureChildWithMargins(View child,
int parentWidthMeasureSpec，int widthUsed,
int parentHeightMeasureSpec，int heightUsed) {
//获取子视图LayoutParams
final MarginLayoutParams lp = (MarginLayoutParams)
child.getLayoutParams();
//调节MeasureSpec
//通过这两个参数以及子视图自身LayoutParams来共同决定子视图测量规格
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);
//调运子Viewmeasure办法，子Viewmeasure中会回调子View//onMeasure办法
child.measure(childWidthMeasureSpec，childHeightMeasureSpec);
}
该办法就是对父视图提供measureSpec参数结合自身LayoutParams参数进行了调节，然后再来调用child.measure()办法，详细通过办法getChildMeasureSpec来进行参数调节。
public static int getChildMeasureSpec(int spec，int padding，int
childDimension) {
//获取当前Parent ViewMode和Size
int specMode = MeasureSpec.getMode(spec);
int specSize = MeasureSpec.getSize(spec);
//获取Parent size与padding差值（也就是Parent剩余大小），若差值不大于0直接返回0
int size = Math.max(0，specSize - padding);
//定义返回值存储变量
int resultSize = 0;
int resultMode = 0;
//根据当前ParentMode进行switch分支逻辑
switch (specMode) {
// Parent has imposed an exact size on us
//默认Root ViewMode就是EXACTLY
case MeasureSpec.EXACTLY:
if (childDimension >= 0) {
//如果childlayout_wOrh属性在xml或者java中予以详细大
//于等于0数值
//设立childsize为真实layout_wOrh属性值，mode为EXACTLY
resultSize = childDimension;
resultMode = MeasureSpec.EXACTLY;
} else if (childDimension == LayoutParams.MATCH_PARENT) {
//如果childlayout_wOrh属性在xml或者java中予以
//MATCH_PARENT
// Child wants to be our size. So be it.
//设立childsize为size，mode为EXACTLY
resultSize = size;
resultMode = MeasureSpec.EXACTLY;
} else if (childDimension == LayoutParams.WRAP_CONTENT) {
//如果childlayout_wOrh属性在xml或者java中予以
//WRAP_CONTENT
//设立childsize为size，mode为AT_MOST
// Child wants to determine its own size. It can't be
// bigger than us.
resultSize = size;
resultMode = MeasureSpec.AT_MOST;
}
break;
......
//其她Mode分支类似
}
//将mode与size通过MeasureSpec办法整合为32位整数返回
return MeasureSpec.makeMeasureSpec(resultSize，resultMode);
}

·用ViewgetMeasuredWidth()和getMeasuredHeight()办法来获取View测量宽高，必要保证这两个办法在onMeasure流程之后被调用才干返回有效值。
·MeasureSpec（View内部类）测量规格为int型，值由高2位规格模式specMode和低30位详细尺寸specSize构成。其中specMode只有三种值：
MeasureSpec.EXACTLY //拟定模式，父View但愿子View大小是拟定，由specSize决定；
MeasureSpec.AT_MOST //最多模式，父View但愿子View大小最多是specSize指定值；
MeasureSpec.UNSPECIFIED //未指定模式，父View完全根据子View设计值来决定；

View绘制流程第二步：递归layout源码分析

ViewGrouplayout办法，如下：
@Override
public final void layout(int l，int t，int r，int b) {
......
super.layout(l，t，r，b);
.....
}
调运了View父类layout办法，因此咱们看下Viewlayout源码，如下：
public void layout(int l，int t，int r，int b) {

//实质都是调用setFrame办法把参数分别赋值给mLeft、mTop、mRight和//mBottom这几种变量

//判断View位置与否发生过变化，以拟定有无必要对当前View进行重新//layout
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);
}

}
//ViewGrouponLayout办法，如下：
@Override
protected abstract void onLayout(boolean changed,
int l，int t，int r，int b);

关于getWidth()、getHeight()和getMeasuredWidth()、getMeasuredHeight()这两对办法之间区别
public final int getMeasuredWidth () {
return mMeasuredWidth & MEASURED_SIZE_MASK;
}

public final int getMeasuredHeight() {
return mMeasuredHeight & MEASURED_SIZE_MASK;
}

public final int getWidth() {
return mRight - mLeft;
}

public final int getHeight() {
return mBottom - mTop;
}

·View.layout办法可被重载，ViewGroup.layout为final不可重载，ViewGroup.onLayout为abstract，子类必要重载实现自己位置逻辑。
·凡是layout_XXX布局属性基本都针对是包括子ViewViewGroup，当对一种没有父容器View设立有关layout_XXX属性是没有任何意义
·使用ViewgetWidth()和getHeight()办法来获取View测量宽高，必要保证这两个办法在onLayout流程之后被调用才干返回有效值

View绘制流程第三步：递归draw源码分析
ViewGroup没有重写Viewdraw办法，因此如下直接从Viewdraw办法开始
public void draw(Canvas canvas) {

// Step 1，draw the background，if needed
if (!dirtyOpaque) {
drawBackground(canvas);
}

// skip step 2 & 5 if possible (common case)

// Step 2，save the canvas' layers
if (drawTop) {
canvas.saveLayer(left，top，right，top + length，null，flags);
}

// 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
if (drawTop) {
matrix.setScale(1，fadeHeight * topFadeStrength);
matrix.postTranslate(left，top);
fade.setLocalMatrix(matrix);
p.setShader(fade);
canvas.drawRect(left，top，right，top + length，p);
}

// Step 6，draw decorations (scrollbars)
onDrawScrollBars(canvas);
}

private void drawBackground(Canvas canvas) {
//获取xml中通过android:background属性或者代码中
//setBackgroundColor()、setBackgroundResource()等办法进行赋值背景
//Drawable
final Drawable background = mBackground;
......
//依照layout过程拟定View位置来设立背景绘制区域
if (mBackgroundSizeChanged) {
background.setBounds(0，0，mRight - mLeft，mBottom - mTop);
mBackgroundSizeChanged = false;
rebuildOutline();
}
......
//调用Drawabledraw()办法来完毕背景绘制工作
background.draw(canvas);
......
}

//ViewonDraw办法，这是一种空办法。由于每个View内容某些是各不相似，//因此需要由子类去实现详细逻辑。
protected void onDraw(Canvas canvas) {
}

// ViewdispatchDraw()办法是一种空办法，如果View包括子类需要重写她，所//以咱们有必要看下ViewGroupdispatchDraw办法源码
@Override
protected void dispatchDraw(Canvas canvas) {
......
final int childrenCount = mChildrenCount;
final View[] children = mChildren;

for (int i = 0；i < childrenCount；i++) {
if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE ||
child.getAnimation() != null) {
more |= drawChild(canvas，child，drawingTime);
}
}

// Draw any disappearing views that have animations
if (mDisappearingChildren != null) {
for (int i = disappearingCount；i >= 0；i--) {
more |= drawChild(canvas，child，drawingTime);
}
}
}
// ViewGroup的确重写了ViewdispatchDraw()办法，该办法内部会遍历每个子//View，然后调用drawChild()办法，咱们可以看下ViewGroupdrawChild办法
protected boolean drawChild(Canvas canvas，View child，
long drawingTime) {
return child.draw(canvas，this，drawingTime);
}
drawChild()办法调运了子Viewdraw)办法。因此说ViewGroup类已经为咱们重写了dispatchDraw()功能实现，咱们普通不需要重写该办法，但可以重载父类函数实现详细功能。

·在获取画布剪切区时会自动解决掉padding，子View获取Canvas不用关注这些逻辑，只用关怀如何绘制即可。

·默认状况下子ViewViewGroup.drawChild绘制顺序和子View被添加顺序一致，但是你也可以重载ViewGroup.getChildDrawingOrder()办法提供不同顺序。

Viewinvalidate办法源码分析

View类中某些invalidate办法
//This must be called from a UI thread. To call from a non-UI thread，
// call postInvalidate()
public void invalidate(Rect dirty) {
final int scrollX = mScrollX;
final int scrollY = mScrollY;
//实质还是调运invalidateInternal办法
invalidateInternal(dirty.left - scrollX，dirty.top - scrollY,
dirty.right - scrollX，dirty.bottom - scrollY，true，false);
}

//This must be called from a UI thread. To call from a non-UI thread，
// call postInvalidate()
public void invalidate(int l，int t，int r，int b) {
final int scrollX = mScrollX;
final int scrollY = mScrollY;
//实质还是调运invalidateInternal办法
invalidateInternal(l - scrollX，t - scrollY，r - scrollX，b - scrollY，true，false);
}

//This must be called from a UI thread. To call from a non-UI thread，
// call postInvalidate()
public void invalidate() {
//invalidate实质还是调运invalidateInternal办法
invalidate(true)
}

//this function can be called with invalidateCache set to false to //skip that invalidation step

void invalidate(boolean invalidateCache) {
//实质还是调运invalidateInternal办法
invalidateInternal(0，0，mRight - mLeft，mBottom - mTop，
invalidateCache，true);
}

//所有invalidate最后调运办法

void invalidateInternal(int l，int t，int r，int b，boolean invalidateCache，boolean fullInvalidate) {
......
// Propagate the damage rectangle to the parent view.
final AttachInfo ai = mAttachInfo;
final ViewParent p = mParent;
if (p != null && ai != null && l < r && t < b) {
final Rect damage = ai.mTmpInvalRect;
//设立刷新区域
damage.set(l，t，r，b);
//传递调运Parent ViewGroupinvalidateChild办法
p.invalidateChild(this，damage);
}
......
}

Viewinvalidate（invalidateInternal）办法实质是将要刷新区域直接传递给了父ViewGroupinvalidateChild办法，在invalidate中调用父ViewinvalidateChild，这是一种从当前向上级父View回溯过程

ViewGroupinvalidateChild办法
public final void invalidateChild(View child，final Rect dirty) {
ViewParent parent = this;
final AttachInfo attachInfo = mAttachInfo;
......
do {
//循环层层上级调运，直到ViewRootImpl会返回null
parent = parent.invalidateChildInParent(location，dirty);
} while (parent != null);
}

最后传递到ViewRootImplinvalidateChildInParent办法结束，因此咱们看下ViewRootImplinvalidateChildInParent办法
@Override
public ViewParent invalidateChildInParent(int[] location，
Rect dirty){
......
//View调运invalidate最后层层上传到ViewRootImpl后最后触发了该办法
scheduleTraversals();
......
return null;
}
这个ViewRootImpl类invalidateChildInParent办法直接返回了null，结束了那个do while循环。scheduleTraversals会通过HandlerRunnable发送一种异步消息，调运doTraversal办法，然后最后调用performTraversals()执行重绘。因此说View调运invalidate办法实质是层层上传到父级，直到传递到ViewRootImpl后触发了scheduleTraversals办法，然后整个View树开始重新按照上面分析View绘制流程进行重绘任务。

ViewpostInvalidate办法源码分析
invalidate办法只能在UI Thread中执行，其她线程中需要使用postInvalidate办法
public void postInvalidate() {
postInvalidateDelayed(0);
}

public void postInvalidateDelayed(long delayMilliseconds) {
final AttachInfo attachInfo = mAttachInfo;
//核心，实质就是调运了ViewRootImpl.dispatchInvalidateDelayed办法
if (attachInfo != null) {
attachInfo.mViewRootImpl.dispatchInvalidateDelayed(this，
delayMilliseconds);
}
}

public void dispatchInvalidateDelayed(View view，
long delayMilliseconds) {
Message msg = mHandler.obtainMessage(MSG_INVALIDATE，view);
mHandler.sendMessageDelayed(msg，delayMilliseconds);
}

调运ViewRootImpl类dispatchInvalidateDelayed办法，通过ViewRootImpl类Handler发送了一条MSG_INVALIDATE消息，继续追踪这条消息解决可以发现：
public void handleMessage(Message msg) {
......
switch (msg.what) {
case MSG_INVALIDATE:
((View)msg.obj).invalidate();
break;
......
}
......
}

invalidate系列办法祈求重绘View树（也就是draw办法），如果View大小没有发生变化就不会调用layout过程，并且只绘制那些“需要重绘”View，也就是哪个View(View只绘制该View，ViewGroup绘制整个ViewGroup)祈求invalidate系列办法，就绘制该View。

setContentView办法源码分析
@Override
public void setContentView(View view，ViewGroup.LayoutParams params){
......
//如果mContentParent为空进行某些初始化
if (mContentParent == null) {
installDecor();
}
......
//把咱们view追加到mContentParent
mContentParent.addView(view，params);
......
}

public void addView(View child) {
addView(child，-1);
}

public void addView(View child，int index) {
......
addView(child，index，params);
}

public void addView(View child，int index，LayoutParams params) {
......
requestLayout();
invalidate(true);
}
通过setContentView办法将咱们要展示界面传入该办法，该办法会将咱们界面通过addView追加到id为content一种FrameLayout中，然后addView办法中通过调运invalidate(true)去告知触发ViewRootImpl类performTraversals()办法，至此递归绘制咱们自定义所有布局。

ViewrequestLayout办法源码分析
public void requestLayout() {
......
if (mParent != null && !mParent.isLayoutRequested()) {
//由此向ViewParent祈求布局
//从这个View开始向上始终requestLayout，最后到达ViewRootImpl
//requestLayout
mParent.requestLayout();
}
......
}

@Override
public void requestLayout() {
if (!mHandlingLayoutInLayoutRequest) {
checkThread();
mLayoutRequested = true;
//View调运requestLayout最后层层上传到ViewRootImpl后最后触发了
//该办法
scheduleTraversals();
}
}
requestLayout()办法会调用measure过程和layout过程，不会调用draw过程，也不会重新绘制任何View涉及该调用者自身。