2024年Android最新源码分析View的绘制流程，2024年最新android高级面试题库

本文链接：https://blog.youkuaiyun.com/2401_84563561/article/details/138863068

最后，如果大伙有什么好的学习方法或建议欢迎大家在评论中积极留言哈，希望大家能够共同学习、共同努力、共同进步。

小编在这里祝小伙伴们在未来的日子里都可以升职加薪，当上总经理，出任CEO，迎娶白富美，走上人生巅峰！！

不论遇到什么困难，都不应该成为我们放弃的理由！

很多人在刚接触这个行业的时候或者是在遇到瓶颈期的时候，总会遇到一些问题，比如学了一段时间感觉没有方向感，不知道该从那里入手去学习

如果你看到了这里，觉得文章写得不错就给个赞呗？如果你觉得那里值得改进的，请给我留言，一定会认真查询，修正不足，谢谢。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

注释2：获取第一节中创建的 DecorView

注释3：获取第一节中通过 setWindowManager()创建好的 WindowManager

注释4：调用 WindowManager.addView(decor)，将DecorView绘制到屏幕上。

因为Android中，WindowManager家族使用了桥接模式，即WindowManager是一个抽象类，它的实现类是WindowManagerImpl，然后它桥接到 WindowManagerGlobal中，它是一个单例，一个进程中只有一个实例，实现了真正对View的增加(add)、修改(update)、删除(remove)方法。

具体可以看《Android进阶解密》关于WindowManagerService的讲解。

2.2 WindowManagerGlobal.addView()

来看看其 addView：

// WindowManagerGlobal.java

public void addView(View view, ViewGroup.LayoutParams params,

Display display, Window parentWindow) {

…

ViewRootImpl root;

View panelParentView = null;

synchronized (mLock) {

…

root = new ViewRootImpl(view.getContext(), display); // 1

view.setLayoutParams(wparams);

mViews.add(view);

mRoots.add(root);

mParams.add(wparams);

try {

root.setView(view, wparams, panelParentView); // 2

} catch (RuntimeException e) {

if (index >= 0) {

removeViewLocked(index, true);

}

throw e;

}

注释1创建了ViewRootImpl实例，然后让WindowManagerGlobal维护，注释1下面的代码就是将View的信息保存到WMG的管理的列表中。

ViewRootImpl 身负很多职责，主要有以下几点：

View树的根并管理View树
触发View的测量、布局和绘制
输入事件的中转站
管理Surface
负责与WMS进行进程间通信

注释2中调用 ViewRootImpl.setView：

// ViewRootImpl.java

public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {

synchronized (this) {

…

try {

mOrigWindowType = mWindowAttributes.type;

mAttachInfo.mRecomputeGlobalAttributes = true;

collectViewAttributes();

// 1

res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,

getHostVisibility(), mDisplay.getDisplayId(),

mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,

mAttachInfo.mOutsets, mInputChannel);

…

}

这里使用了AIDL，将代码转移到了 WindowManagerService中去了。当然，我们现在研究的是View的绘制流程，而WMS做的事情是配置/存储View信息，并没有涉及到绘制的内容，所以不用深入到SystemServer进程中。

setView()在WMS执行完后最终会执行scheduleTraversals，它会向主线程发消息，让主线程执行performTraversals()，这个方法就是绘制的入口，它是这样的：

// ViewRootImpl.java

private void performTraversals() {

…

relayoutResult = relayoutWindow(params, viewVisibility, insetsPending);

…

// 1

int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);

int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);

performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);

…

// 2

performLayout(lp, mWidth, mHeight);

…

// 3

performDraw();

…

}

在 performTraversals()中，走了三个方法， performMeasure()、performLayout()、performDraw()， performXXX的意思就是将要做XXX。所以很明显，这就是View绘制中三大流程的入口。

到这里，我们通过Activity的启动来到了Activity的绘制，它调用了 ViewRootImpl.setView()来进入到Acitivty绘制的入口。

我们使用的例子是Activity，而实际上，不只是Activity，任何View的添加、修改和删除，最终都会来到这个方法来。

再往下，我们就可以把Activity看成是一个ViewGroup，进入到绘制流程的源码中。

3. 解析MeasureSpec

==================================================================================

我们知道在调用 performMeasure()前，创建了宽高的MeasureSpec。我们要了解它是做什么的。

MeasureSpec是View的内部类，它封装了一个View的规格尺寸，包括View的宽和高的信息，它的作用是在Measure流程中，系统会将View的LayoutParams根据父容器所施加的规则转换成对应的MeasureSpec。然后在 onMeasure方法中根据这个MeasureSpec来确定View的宽和高。我们来看看它的源码：

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;

// size和mode，size范围在0~2^30-1 mode是0、1、2

public static int makeMeasureSpec(@IntRange(from = 0, to = (1 << MeasureSpec.MODE_SHIFT) - 1) int size,

@MeasureSpecMode int mode) {

if (sUseBrokenMakeMeasureSpec) {

return size + mode;

} else {

return (size & ~MODE_MASK) | (mode & MODE_MASK);

}

public static int makeSafeMeasureSpec(int size, int mode) {

if (sUseZeroUnspecifiedMeasureSpec && mode == UNSPECIFIED) {

return 0;

}

return makeMeasureSpec(size, mode);

}

public static int getMode(int measureSpec) {

return (measureSpec & MODE_MASK);

}

public static int getSize(int measureSpec) {

return (measureSpec & ~MODE_MASK);

}

static int adjust(int measureSpec, int delta) {

final int mode = getMode(measureSpec);

int size = getSize(measureSpec);

if (mode == UNSPECIFIED) {

return makeMeasureSpec(size, UNSPECIFIED);

}

size += delta;

if (size < 0) {

Log.e(VIEW_LOG_TAG, “MeasureSpec.adjust: new size would be negative! (” + size +

") spec: " + toString(measureSpec) + " delta: " + delta);

size = 0;

}

return makeMeasureSpec(size, mode);

}

从MeasureSpec的常量可以看出，它代表了32位的int值，其中高2位代表了SpecMode，低30位则代表SpecSize。SpecMode指的是测量模式，SpecSize指的是测量大小。SpecMode有3种模式，如下所示。

UNSPECIFIED：未指定模式，View想多大就多大，父容器不做限制，一般用于系统内部的测量。
AT_MOST：最大模式，对应于wrap_comtent属性，子View的最终大小是父View指定的SpecSize值，并且子View的大小不能大于这个值。
EXACTLY：精确模式，对应于 match_parent 属性和具体的数值，父容器测量出 View所需要的大小，也就是SpecSize的值。

对于每一个View，都持有一个MeasureSpec，而该MeasureSpec则保存了该View的尺寸规格。在View的测量流程中，通过makeMeasureSpec()来保存宽和高的信息。通过getMode或getSize得到模式和宽、高。MeasureSpec是受自身LayoutParams和父容器的MeasureSpec共同影响的。作为顶层View的DecorView来说，其并没有父容器，那么它的MeasureSpec是如何得来的呢？为了解决这个疑问，我们再回到ViewRootImpl的PerformTraveals方法，如下所示：

// ViewRootImpl.java

int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width); // 1

int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height); //2

performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);

注释1、2中的 getRootMeasureSpec()得到了DecorView的宽高的MeasureSpec，我们来看看它做了什么：

// ViewRootImpl.java

private static int getRootMeasureSpec(int windowSize, int rootDimension) {

int measureSpec;

switch (rootDimension) {

case ViewGroup.LayoutParams.MATCH_PARENT:

measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.EXACTLY);

break;

case ViewGroup.LayoutParams.WRAP_CONTENT:

measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.AT_MOST);

break;

default:

measureSpec = MeasureSpec.makeMeasureSpec(rootDimension, MeasureSpec.EXACTLY);

break;

}

return measureSpec;

}

getRootMeasureSpec的第一个参数时窗口的尺寸，对于DecorView来说，它的MeasureSpec是由自身的LayoutParams和窗口尺寸决定的，普通View获取MeasureSpec和它有区别的地方就在这里了。

再来看看 performMeasure方法：

// ViewRootImpl.java

private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {

if (mView == null) {

return;

}

Trace.traceBegin(Trace.TRACE_TAG_VIEW, “measure”);

try {

mView.measure(childWidthMeasureSpec, childHeightMeasureSpec); // 1

} finally {

Trace.traceEnd(Trace.TRACE_TAG_VIEW);

}

在DecorView得到了它的MeasureSpec后，就开始真正的measure流程了。这里的 mView指的就是 WindowManager.addView()进去的View，也就是DecorView。

4. View的measure流程

===================================================================================

measure的作用就是用来测量一个DecorView及其所有子View的宽和高。

它的流程分为View的measure流程和ViewGroup的measure流程。

而他们的入口，都是在于上一节中的 mView.measure()方法，我们从入口开始看起。

4.1 View的measure方法

因为DecorView、FrameLayout都没有重写measure方法，所以mView.measure方法其实调用了 View.measure()，我们来看看这个方法。

// View.java

public final void measure(int widthMeasureSpec, int heightMeasureSpec) {

…

if (forceLayout || needsLayout) {

…

int cacheIndex = forceLayout ? -1 : mMeasureCache.indexOfKey(key); // 1

if (cacheIndex < 0 || sIgnoreMeasureCache) {

onMeasure(widthMeasureSpec, heightMeasureSpec); // 2

mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;

} else {

long value = mMeasureCache.valueAt(cacheIndex);

setMeasuredDimensionRaw((int) (value >> 32), (int) value);

mPrivateFlags3 |= PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;

}

…

}

…

}

…

mMeasureCache.put(key, ((long) mMeasuredWidth) << 32 |

(long) mMeasuredHeight & 0xffffffffL); // 3

}

注释1：看看cache中有没有缓存

注释2：如果没有缓存就调用 onMeasure()计算View的 mMeasureWidth和mMeasureHeight

注释3：将注释2算出来的值放入到缓存中，下次再算此View时，如果此View没有做宽高的改变，就不用再计算宽高了。

在注释2中，因为继承和多态的关系，会先调用 DecorView.onMeasure()，因为DecorView的onMeausre和普通View的onMeasure方法区别并不大，我这里列出一个调用链：

ViewRootImpl.performMeasure() -> View.measure() -> DecorView.onMeasure() -> FrameLayout.onMeasure() -> ViewGroup.measureChildWithMargins() -> View.onMeasure()

其中最后一个方法的实现和 measureChild()一样，我们后面会讲到它。

可以看到这个调用链其实就是从最顶层的View开始走measure，然后其子View随其后而measure。

4.2 View的measure流程

首先来看看View的measure流程：

// View.java

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),

getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));

}

它调用了 getDefaultSize()和 setMeasuredDimension()、 getSuggestedMinimumXXX()方法。

我们先看看 setMeasuredDimension()方法做了什么：

// View.java

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);

}

上面的代码很明显是用来设置View的宽高。

再回头看看 getDefaultSize()是做了什么的：

// View.java

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;

}

这个代码就和上节讲到的MeasureSpec有关了。他根据不同的SpecMode来计算出不同的宽高值。

AT_MOST和EXACTLY这两个SpecMode下，返回的都是同一个值：measureSpec中的Size
而在 UNSPECIFIED，则计算出的值是传进来的宽高值。即 getSuggestedMinimumXXX()得到的数值。

我们来看看 getSuggestedMinimumXX()方法：

// View.java

protected int getSuggestedMinimumWidth() {

return (mBackground == null) ? mMinWidth : max(mMinWidth, mBackground.getMinimumWidth());

}

如果View没有设置背景Backgroud，则取值为 mMinWidth，这个值时可以设置的，它对应的是 Android:minWidth / View.setMinimumWidth，如果不指定的话，默认就是0，如果设置了背景，则取 mMinWidth和 mBackground.getMinimumWidth间的最大值。

mBackgroud是Drawable类型的，Drawable类的getMinmumWidth()方法：

// Drawable.java

public int getMinimumWidth() {

final int intrinsicWidth = getIntrinsicWidth();

return intrinsicWidth > 0 ? intrinsicWidth : 0;

}

而 intrinsicWidth值的就是Drawable的固有宽度，如果固有宽度大于0则返回固有宽度，否则返回0.

也就是说，如果如果一个View的宽/高设置的SpecMode为UNSPECIFIED，那么它这条边的长度就是mMinXXX和Drawable背景的最大值。如果一个View的宽/高的SpecMode为 AT_MOST或EXACTLY，那么它这条边长度就是SpecSize

4.3 ViewGroup的measureChildren方法

对于ViewGroup，它不只要测量自身，还要遍历地调用子元素的 measure()，ViewGroup中没有定义onMeasure方法，却定义了 measureChildren()方法：

// ViewGroup.java

protected void measureChildren(int widthMeasureSpec, int heightMeasureSpec) {

final int size = mChildrenCount;

final View[] children = mChildren;

for (int i = 0; i < size; ++i) { // 1

final View child = children[i];

if ((child.mViewFlags & VISIBILITY_MASK) != GONE) { // 2

measureChild(child, widthMeasureSpec, heightMeasureSpec); // 3

}

注释1：遍历所有子View

注释2、3：如果子View的不是GONE的，就调用 measureChild()，并传入自己的 MeaseSpec

来看看 measureChild()：

// ViewGroup.java

protected void measureChild(View child, int parentWidthMeasureSpec,

int parentHeightMeasureSpec) {

final LayoutParams lp = child.getLayoutParams(); // 1

final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,

mPaddingLeft + mPaddingRight, lp.width); // 2

final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,

mPaddingTop + mPaddingBottom, lp.height); // 3

child.measure(childWidthMeasureSpec, childHeightMeasureSpec); // 4

}

注释1：拿到子View的 LayoutParams

注释2、3：通过 getChildMeasureSpec()计算出子View的MeasureSpec

注释4：调用子View的measure方法。

这里有一个值得注意点，在注释2、3中，ViewGroup是如何通过自己的MeasureSpec和子View的LayoutParams来计算出子View的MeasureSpec的呢，我们有必要看看这个方法：

// ViewGroup.java

public static int getChildMeasureSpec(int spec, int padding, int childDimension) {

int specMode = MeasureSpec.getMode(spec); // 1

int specSize = MeasureSpec.getSize(spec); // 2

int size = Math.max(0, specSize - padding); // 3

int resultSize = 0;

int resultMode = 0;

switch (specMode) { // 3

case MeasureSpec.EXACTLY:

if (childDimension >= 0) {

resultSize = childDimension;

resultMode = MeasureSpec.EXACTLY;

} else if (childDimension == LayoutParams.MATCH_PARENT) {

resultSize = size;

resultMode = MeasureSpec.EXACTLY;

} else if (childDimension == LayoutParams.WRAP_CONTENT) {

resultSize = size;

resultMode = MeasureSpec.AT_MOST;

}

break;

case MeasureSpec.AT_MOST:

if (childDimension >= 0) {

resultSize = childDimension;

resultMode = MeasureSpec.EXACTLY;

} else if (childDimension == LayoutParams.MATCH_PARENT) {

resultSize = size;

resultMode = MeasureSpec.AT_MOST;

} else if (childDimension == LayoutParams.WRAP_CONTENT) {

resultSize = size;

resultMode = MeasureSpec.AT_MOST;

}

break;

case MeasureSpec.UNSPECIFIED:

if (childDimension >= 0) {

resultSize = childDimension;

resultMode = MeasureSpec.EXACTLY;

} else if (childDimension == LayoutParams.MATCH_PARENT) {

resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;

resultMode = MeasureSpec.UNSPECIFIED;

} else if (childDimension == LayoutParams.WRAP_CONTENT) {

resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;

resultMode = MeasureSpec.UNSPECIFIED;

}

break;

}

return MeasureSpec.makeMeasureSpec(resultSize, resultMode);

}

上面的代码虽然长，但是很好理解：

注释1：拿到ViewGroup的 SpecMode和SpecSize。

注释2：size为ViewGroup的SpecSize减去padding值，如果小于0，则取0

注释3：根据ViewGroup的SpecMode来确定子View的MeasuSpec。这里分为了多种情况，下面列个表：

（图源自自定义View：Measure过程说明之MeasureSpec类详细讲解）

在这里插入图片描述

就这样计算出了子View的MeasureSpec，接着就是调用子View的measure方法。

而调用每个View的measure方法，还会去计算这个View是否有子View，一层层的递归下去。

这样，当调用DecorView的onMeasure方法，相当于把一个屏幕所有View的宽高都给测量下来了。这也是剩下两个流程所用到的技巧。

5. View的layout流程

==================================================================================

layout流程的作用是用来确定元素的位置的。

和measure一样，layout的流程有View的layout流程，还有ViewGroup的layout流程。

5.1 performLayout方法

当然，我们的入口是 ViewRootImpl.performLayout()，看看它做了什么：

// ViewRootImpl.java

private void performLayout(WindowManager.LayoutParams lp, int desiredWindowWidth,

int desiredWindowHeight) {

…

final View host = mView;

if (host == null) {

return;

}

…

try {

host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());

…

}

} …

}

调用了 DecorView的 layout方法，这里有一个调用链：

ViewRootImpl.performLayout() -> View.layout() -> DecorView.onLayout() -> FrameLayout.onLayout() -> FrameLayout.layoutChildren()，由于FrameLayout自己实现了layout（一般来说，自定义ViewGroup都需要自己实现layout函数），所以我们不研究其函数。

而是研究一般的View、ViewGroup是这么Layout的。了解了他们，其他就是触类旁通。

5.2 View的layout流程

我们看看View的layout方法，View的layout是用来确定自身的位置：

// View.java

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); // 1

if (changed || (mPrivateFlags & PFLAG_LAYOUT_REQUIRED) == PFLAG_LAYOUT_REQUIRED) {

onLayout(changed, l, t, r, b); // 2

if (shouldDrawRoundScrollbar()) {

if(mRoundScrollbarRenderer == null) {

mRoundScrollbarRenderer = new RoundScrollbarRenderer(this);

}

} else {

mRoundScrollbarRenderer = null;

}

mPrivateFlags &= ~PFLAG_LAYOUT_REQUIRED;

ListenerInfo li = mListenerInfo;

if (li != null && li.mOnLayoutChangeListeners != null) {

ArrayList listenersCopy =

(ArrayList)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;

…

}

layout方法的4个参数l、t、r、b分别是View的左上右下相对于其父容器的距离。

注释1中调用了 setFrame()方法，setOpticalFrame()最终也会调用到setFrame()，它将这四个值设置给了View：

// View.java

protected boolean setFrame(int left, int top, int right, int bottom) {

boolean changed = false;

if (mLeft != left || mRight != right || mTop != top || mBottom != bottom) {

changed = true;

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(sizeChanged);

mLeft = left;

mTop = top;

mRight = right;

mBottom = bottom;

mRenderNode.setLeftTopRightBottom(mLeft, mTop, mRight, mBottom);

…

}

return changed;

}

setFrame方法用传进来的l、t、r、b这4个参数分别初始化给 mLeft、mTop、mRight、mBottom这4个值，这样就确定了该View在父容器中的位置。

回到上面的layout方法中，在调用完setFrame()，会调用 onLayout()，这个方法是一个空方法。无论是View还是ViewGroup，这是因为位置会因为不同的控件会有不同的实现，这个由开发者自己实现。

5.3 ViewGroup是如何用layout的

因为系统并没有给ViewGroup实现默认的onLayout()，所以这需要ViewGroup的创建者来自己实现。对自己ViewGroup下的每个组件实现位置的确定。而对于最下层的子View，只需要调用它的 layout()方法就行了。

我们来看看 FrameLayout是如何实现layout子布局的：

// FrameLayout.java

@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) {

…

for (int i = 0; i < count; i++) {

final View child = getChildAt(i);

if (child.getVisibility() != GONE) {

…

switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) {

case Gravity.CENTER_HORIZONTAL:

…

case Gravity.RIGHT:

…

}

switch (verticalGravity) {

case Gravity.TOP:

…

case Gravity.CENTER_VERTICAL:

…

}

child.layout(childLeft, childTop, childLeft + width, childTop + height);

}

其实很简单，就是遍历每个子View，然后拿到他们的测量宽高，根据子View在FrameLayout中设置的位置属性进行调整，最后调用每个子View的layout即 child.layout()。

这样，就和measure一样，把layout的过程交给了自己的子View。

在这里，我们不考虑FrameLayout实现layout的细节，因为它不是重点，但是我们平时自己在写ViewGroup的时候，layout是很重要的一环，我们要靠它实现各种View的展示。

6. View的draw流程

================================================================================

View的draw流程很简单，下面先来看看View的draw方法。在perform中自然也调用到了draw方法。

官方注释清楚的说明了每一步的做法：

如果需要，则绘制背景。
保存当前canvas层。
绘制View的内容。
绘制子View。
如果需要，则绘制View的褪色边缘，这类似于阴影效果。
绘制装饰，比如滚动条。

最后

针对于上面的问题，我总结出了互联网公司Android程序员面试涉及到的绝大部分面试题及答案，并整理做成了文档，以及系统的进阶学习视频资料。
（包括Java在Android开发中应用、APP框架知识体系、高级UI、全方位性能调优，NDK开发，音视频技术，人工智能技术，跨平台技术等技术资料），希望能帮助到你面试前的复习，且找到一个好的工作，也节省大家在网上搜索资料的时间来学习。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

case Gravity.RIGHT:

…

}

switch (verticalGravity) {

case Gravity.TOP:

…

case Gravity.CENTER_VERTICAL:

…

}

child.layout(childLeft, childTop, childLeft + width, childTop + height);

}

这样，就和measure一样，把layout的过程交给了自己的子View。

6. View的draw流程

================================================================================

View的draw流程很简单，下面先来看看View的draw方法。在perform中自然也调用到了draw方法。

官方注释清楚的说明了每一步的做法：

如果需要，则绘制背景。
保存当前canvas层。
绘制View的内容。
绘制子View。
如果需要，则绘制View的褪色边缘，这类似于阴影效果。
绘制装饰，比如滚动条。

最后

[外链图片转存中…(img-0UjswvK2-1715678995182)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取