提纲（三）.png
在上一篇View绘制流程及源码解析(二)——onMeasure()流程分析这篇文章中，我们详细的分析了很多测量过程的细节（好吧，真是有点过于细节了，感觉寒假的时候这时间花的，简直心疼），这篇我们来分析三大流程最后两个流程，鉴于上一篇文章中事无巨细的分析细节造成的惨痛教训，这篇文章会避免对于细节的死扣，而更加注重整体流程的把握。
一.Layout流程
1.Layout的基本过程
Layout的过程就是ViewGroup用来确定子元素的位置，当ViewGroup的位置被确定之后，它在onLayout中会遍历所有的子元素并调用其Layout方法，在Layout方法中onLayout方法又会被调用。这段话摘自《Android开发艺术探索》，既然Layout的过程是ViewGroup用来确定子元素的位置的，那么ViewGroup的位置又是怎么确定的呢？实际上，类似于Measure()过程，整个布局的过程也是一个递归调用的过程——首先从最顶层的DecorView开始，我们说过，DecorView是一个FrameLayout，也就是一个ViewGroup，调用他的Layout方法，那么他会遍历循环他的子元素，并调用子元素的onLayout方法，如果子元素依然是个ViewGroup，那么调用这个子ViewGroup(如LinearLayout)重写过的onLayout方法；然后在该方法中又会接着往下遍历，调用子View的layout方法，一直扒到最后一层View，假设这个子View是TextView，那么就会调用TextView的onLayout的方法，具体的控件，他们的onLayout的方法都是重写过的，每个有每个自己的布局规矩。
screen_simple.xml中的关系.png
这里我们再贴一下前两篇中都提到的图，大家可以对着这个图心理想一遍这个递归调用的过程。
2.DecorView的Layout过程
首先我们要回到三大流程开始的地方，也就是ViewRootImpl类中的performTraversals()方法中：
(framewoks/base/core/java/android/view/ViewRootImpl):
if (didLayout) {
performLayout(lp, mWidth, mHeight);
在View绘制流程及源码解析(一)——performTraversals()源码分析这篇文章的“第二段代码”前面的一段中，我们说了这个mWidth与mHeight，这两个值实际上就表示的是当前窗口（Window）的大小，或者说当前DecorView的宽高，lp就是DecorView的布局参数。
我们接着看这个方法(framewoks/base/core/java/android/view/ViewRootImpl):
private void performLayout(WindowManager.LayoutParams lp, int desiredWindowWidth,
int desiredWindowHeight) {
......
final View host = mView;
Trace.traceBegin(Trace.TRACE_TAG_VIEW, "layout");
try {
host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());
这个方法中，可以看到host调用了layout()方法，这个host是mView赋值过来的，这个mView就是DecorView,我们去到View类中看下这个layout()方法(framewoks/base/core/java/android/view/View):
/*
* @param l Left position, relative to parent
* @param t Top position, relative to parent
* @param r Right position, relative to parent
* @param b Bottom position, relative to parent
*/
public void layout(int l, int t, int r, int b) {
......
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);
}
}
}
......
}
可以看到，调用了onLayout(changed, l, t, r, b);方法，这个方法的四个参数，看注释可以知道，依次是View/ViewGroup的左、上、右、下四个坐标，而他得调用方法是host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());，这里的host变量就是DecorView，那么传入的这四个参数是什么意思呢？首先我们知道，DecorView是Android屏幕的的顶级View,他上面已经没有父View了，而我们知道，Android当中的原点坐标系是从左上角开始的：
图解Android Window区域划分.png
我们贴一张之前贴过的图，注意左上角的那个红点，我们已经标出了他是Android坐标系的原点，以及DecorView的区域示意图(忽略过扫描区域，那玩意是在屏幕外面的)。因此，我们也不难理解，host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());中的参数了，前两个0,0表示的是Android的坐标系原点(DecorView的左上角)，后两个表示是DecorView的测量宽高。
回到上面的源码中，我们可以看到在layout()方法中，调用了onLayout()方法，我们来看看这个方法：
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
}
如你所见，这个方法是空的——上面我们已经提到，onLayout的实现方法，是整个下发到子View/ViewGroup中的，具体的View具体实现，我们对着上面的screen_simple.xml的结构层次图，试着分析一下LinearLayout的onLayout()方法：
3.LinearLayout的Layout过程
(framewroks/base/core/java/android/widget/linearlayout):
@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;
// Where right end of child should go
final int width = right - left;
int childRight = width - mPaddingRight; //确定子元素的右界限
// Space available for child
int childSpace = width - paddingLeft - mPaddingRight; //子元素的生存空间为，LinearLayout的宽度减左右Padding
final int count = getVirtualChildCount(); //获取子元素的个数
final int majorGravity = mGravity & Gravity.VERTICAL_GRAVITY_MASK;
final int minorGravity = mGravity & Gravity.RELATIVE_HORIZONTAL_GRAVITY_MASK;
switch (majorGravity) { //根据BOTTOM，CENTER_VERTICAL，TOP三种Gravity来确定childTop，即子元素的顶部位置
case Gravity.BOTTOM:
childTop = mPaddingTop + bottom - top - mTotalLength;
break;
......
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) { //可见性不是GONE的元素都参与布局
final int childWidth = child.getMeasuredWidth();
final int childHeight = child.getMeasuredHeight();
final LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();
......
switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) { //根据三种Gravity确定子元素左位置
case Gravity.CENTER_HORIZONTAL:
childLeft = paddingLeft + ((childSpace - childWidth) / 2)
+ lp.leftMargin - lp.rightMargin;
......
default:
childLeft = paddingLeft + lp.leftMargin;
break;
}
......
childTop += lp.topMargin;
setChildFrame(child, childLeft, childTop + getLocationOffset(child),childWidth, childHeight);
childTop += childHeight + lp.bottomMargin + getNextLocationOffset(child);
i += getChildrenSkipCount(child, i);
}
}
}
上面的流程比较清楚，我们加了一些必要的注释，就不死扣实现的细节了，可以看到调用了setChildFrame(child, childLeft, childTop + getLocationOffset(child),childWidth, childHeight);这个方法：
private void setChildFrame(View child, int left, int top, int width, int height) {
child.layout(left, top, left + width, top + height);
}
可以看到，这个方法中又调用了子View的layout()方法，如果此时子View也是个ViewGroup，那么回到上面的流程中接着调用；如果此时子View是一个View,那么调用子View（如TextView）的onLayout方法。
二.Draw流程
1.Canvas与Surface
上面performLayout()方法之之心完之后，就该执行performDraw()方法了，我们直接来看这个方法(framewoks/base/core/java/android/view/ViewRootImpl):
private void performDraw() {
......
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(fullRedrawNeeded);，这个fullRedrawNeeded意思是，需要完全重绘的意思，笔者看了下这个变量，整个ViewRootImpl类中，只有上面一段中的这句：
final boolean fullRedrawNeeded = mFullRedrawNeeded;
mFullRedrawNeeded = false;
mFullRedrawNeeded的值变为了false,其他地方均为true，也就是说，你可以先不管这个boolean值代表什么，只要知道他是一个true值就行了。
然后我们接着看draw(fullRedrawNeeded);方法:
private void draw(boolean fullRedrawNeeded) {
Surface surface = mSurface;
if (!surface.isValid()) {
return;
}
......
if (!drawSoftware(surface, mAttachInfo, xOffset, yOffset, scalingRequired, dirty)) {
return;
}
......
1).什么是surface？
这个surface是什么呢？Surface是原始图像缓冲区（raw buffer）的一个句柄，而原始图像缓冲区是由屏幕图像合成器（screen compositor）管理的。SDK的中对该类的注释为:Handle onto a raw buffer that is being managed by the screen compositor——处理由屏幕合成器管理的原始缓冲区。
- 句柄，英文：HANDLE，数据对象进入内存之后获取到内存地址，但是所在的内存地址并不是固定的，需要用句柄来存储内容所在的内存地址。从数据类型上来看它只是一个32位(或64位)的无符号整数。
- Surface 充当句柄的角色，用来获取原始图像缓冲区以及其中的内容。
- 原始图像缓冲区（raw buffer）用来保存当前窗口的像素数据。
看了这段话，我们大概已经知道了这个Surface是用来干什么的了，他就是一个用来获取原始图像缓冲区中图像数据的句柄~~我们接着看if (!drawSoftware(surface, mAttachInfo, xOffset, yOffset, scalingRequired, dirty))这个巨长的方法：
private boolean drawSoftware(Surface surface, AttachInfo attachInfo, int xoff, int yoff,
boolean scalingRequired, Rect dirty) {
// Draw with software renderer.
final Canvas canvas;
try {
......
canvas = mSurface.lockCanvas(dirty);
......
} catch (IllegalArgumentException e) {
......
}
......
try {
......
mView.draw(canvas);
.......
2).什么是Canvas ？
上面这段代码中出现了一个Canvas对象，我们省略了除了关键代码之外的所有代码。首先说一下Canvas是什么？
先看下这个类的注释:
/**
* The Canvas class holds the "draw" calls. To draw something, you need
* 4 basic components: A Bitmap to hold the pixels, a Canvas to host
* the draw calls (writing into the bitmap), a drawing primitive (e.g. Rect,
* Path, text, Bitmap), and a paint (to describe the colors and styles for the
* drawing).
* /
为了绘制一个东西，我们需要4个元素来协同完成：
- 位图：Bitmap 来保持（hold）那些像素
- 画布：Canvas 来响应画画（draw）的调用（并将其写入 bitmap）
- 画笔：paint 描述画画的颜色和样式等
- “颜料“：drawing primitive，比如矩形、路径、文字、位图等其他元素
关于这四个元素，我们如果了解自定义View的话应该很熟悉，这个Canvas实际上就是一个画布.
3).Surface与Canvas
可以看到，每一个Surface中保存了一个Canvas对象，因为Canvas是“画布”嘛，它可以暂时保存我们绘画的数据(当然最终是要存到BitMap中)；而Surface是操纵图像数据的句柄，因此他保存一个Canvas，通过这个Canvas我们就可以进行各种绘制的工作。
不论是普通的自定义View，还是SurfaceView自定义Veiw，我们都需要首先获取Surface中的Canvas，通过canvas = mSurface.lockCanvas(dirty);方法，然后才能进行一系列操作，并在操作完成后unlockCanvasAndPost(canvas)方法释放canvas——只不过在SurfaceView中需要手动调用这两个方法，但是在普通的View或者自定义View中，这两个方法是在ViewRootImpl类中由系统自行调用。
我们看看这句：canvas = mSurface.lockCanvas(dirty);，这句代码调用了Surface类中的lockCanvas()方法(framewoks/base/core/java/android/view/Surface):
public Canvas lockCanvas(Rect inOutDirty)
throws Surface.OutOfResourcesException, IllegalArgumentException {
synchronized (mLock) {
checkNotReleasedLocked();
if (mLockedObject != 0) {
throw new IllegalArgumentException("Surface was already locked");
}
mLockedObject = nativeLockCanvas(mNativeObject, mCanvas, inOutDirty);
return mCanvas;
}
}
可以看到，这个方法中，我们返回了一个Canvas对象，并调用native层的方法nativeLockCanvas()锁定这个画布。
2.绘制流程
之后我们就可以看上面那段代码中真正的开始绘制的地方了：mView.draw(canvas);，我们之前说过，mView表示的就是DecorView：
@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)
*/
// 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;
}
......
}
可以看到，上面的注释中说的很清楚了，绘制的过程主要分为4个步骤(本来6个步骤，一般情况下跳过2和5)：
①绘制背景 drawBackground(canvas);
②绘制自己onDraw(canvas)
/**
* Implement this to do your drawing.
*
* @param canvas the canvas on which the background will be drawn
*/
protected void onDraw(Canvas canvas) {
}
这个方法是一个空方法，不同的子View会重写这个方法来实现自己的绘制；ViewGroup里边没有实现这个方法，笔者看了一下，貌似只有LinearLayout实现了这个方法，但也仅仅是为了在其中调用分割线（drawable）的draw()方法，
③绘制childrendispatchDraw(canvas)
/**
* Called by draw to draw the child views. This may be overridden
* by derived classes to gain control just before its children are drawn
* (but after its own view has been drawn).
* @param canvas the canvas on which to draw the view
*/
protected void dispatchDraw(Canvas canvas) {
}
View的绘制机制通过dispatchDraw()方法来传递的，该方法在View类中是一个空方法，但是在ViewGroup类中确实实现的(framewoks/base/core/java/android/view/ViewGroup):
@Override
protected void dispatchDraw(Canvas canvas) {
boolean usingRenderNodeProperties = canvas.isRecordingFor(mRenderNode);
final int childrenCount = mChildrenCount;
final View[] children = mChildren;
int flags = mGroupFlags;
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();
attachLayoutAnimationParameters(child, params, i, childrenCount);
bindLayoutAnimation(child);
}
}
......
// Draw any disappearing views that have animations
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);
}
}
......
可以看到，在ViewGroup的这个方法中，我们循环遍历了子View,并调用他们的draw方法，如此draw事件就这样一层层传递下去了。
网友评论