源码分析View的绘制流程

最新推荐文章于 2024-08-16 14:13:16 发布

史迪哇

最新推荐文章于 2024-08-16 14:13:16 发布

阅读量972

点赞数 9

分类专栏：程序员文章标签： android

本文链接：https://blog.csdn.net/m0_74931244/article/details/138033865

版权

程序员专栏收录该内容

186 篇文章 0 订阅

订阅专栏

在Android应用程序启动（根Activity）过程中，我们知道Activity启动流程的最后一步就是调用 ActivityThread.handleLaunchActivity()方法：

// ActivityThread.java

private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {

…

Activity a = performLaunchActivity(r, customIntent); // 1

if (a != null) {

r.createdConfig = new Configuration(mConfiguration);

reportSizeConfigurations®;

Bundle oldState = r.state;

handleResumeActivity(r.token, false, r.isForward,

!r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason); // 2

…

} …

}

注释1调用了 performLaunchActivity()，它的作用是创建PhoneWindow，执行Activity的onCreate方法，注释2是调用 handleResumeActivity()对Activity进入到resume状态中去。

很明显，在注释2调用resume方法时，Activity就必须完成布局的创建，而这个布局，最重要的是我们熟知的DecorView。

而注释2中，就需要将DecorView和其子View们在resume中被显示出来。这就涉及到了View的绘制。

我们先看看 PhoneWindow是如何被创建的。

1. DecorView的创建

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

1.1 performLaunchActivity()向下调用

进入到 performLaunchActivity()中：

// ActivityThread

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {

…

try {

Application app = r.packageInfo.makeApplication(false, mInstrumentation); // 1

…

if (activity != null) {

//2

activity.attach(appContext, this, getInstrumentation(), r.token,

r.ident, app, r.intent, r.activityInfo, title, r.parent,

r.embeddedID, r.lastNonConfigurationInstances, config,

r.referrer, r.voiceInteractor, window, r.configCallback);

…

if (r.isPersistable()) {

//3

mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);

}

注释1的makeApplication()之前有研究过，它会调用App的Application类的 onCreate()。

注释2：调用 Activity.attach()方法，这个方法将马上要产生的Activity和Context进行绑定，并创建一些Activity需要的东西：

// Activity.java

final void attach(Context context, ActivityThread aThread,

…) {

attachBaseContext(context);

mFragments.attachHost(null /parent/);

mWindow = new PhoneWindow(this, window, activityConfigCallback); // 1

…

// 2

mWindow.setWindowManager(

(WindowManager)context.getSystemService(Context.WINDOW_SERVICE),

mToken, mComponent.flattenToString(),

(info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0);

if (mParent != null) {

mWindow.setContainer(mParent.getWindow());

}

mWindowManager = mWindow.getWindowManager();

mCurrentConfig = config;

mWindow.setColorMode(info.colorMode);

}

注释1：new出一个 PhoneWindow，并赋值给 Window类型对象mWindow，我们知道在Android中，Window是以view的形式存在的，这个创建PhoneWindow，其实就是Activity最初始的View。

注释2：给mWindow对象设置一个新的 WindowManager用来管理界面，这样当我们在代码中调用getWindow()时，返回的是 mWindow，调用getWindowManager()时，返回的是mWindow的WindowManager。

对于绘制的角度来说，Activity.attach()已经创建了最初始的根View -> mWindow，接下来就是将mWindow作为DecorView展示出来。显然attach()方法已经没有这些代码了。我们回到 performLaunchActivity()的注释3中，看看 Instrumentation.callActivityOnCreate()：

// Instrumentation

public void callActivityOnCreate(Activity activity, Bundle icicle,

PersistableBundle persistentState) {

prePerformCreate(activity);

activity.performCreate(icicle, persistentState); // 1

postPerformCreate(activity);

}

注释1是关键，它调用了 Activity.oerformCreate()：

// Activity.java

final void performCreate(Bundle icicle, PersistableBundle persistentState) {

restoreHasCurrentPermissionRequest(icicle);

onCreate(icicle, persistentState); // 1

mActivityTransitionState.readState(icicle);

performCreateCommon();

}

它调用了我们Activity的onCreate()方法。而我们自己写的Activity中都会调用 setContentView()来设置一个布局：

// Activity.java

public void setContentView(View view) {

getWindow().setContentView(view); // 1

initWindowDecorActionBar();

}

注释1调用了 getWindow()，得到就是 PhoneWindow mWindow，然后调用其 setContentView()，我们就到PhoneWindow中看看。

1.2 真正的setContentView方法

// PhoneWindow.java

@Override

public void setContentView(View view, ViewGroup.LayoutParams params) {

if (mContentParent == null) { // 1

installDecor(); // 2

} else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {

mContentParent.removeAllViews();

}

if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) {

view.setLayoutParams(params);

final Scene newScene = new Scene(mContentParent, view);

transitionTo(newScene);

} else {

mContentParent.addView(view, params);

}

mContentParent.requestApplyInsets();

final Callback cb = getCallback();

if (cb != null && !isDestroyed()) {

cb.onContentChanged();

}

mContentParentExplicitlySet = true;

}

注释1：判断 mContextParent是否为null，由于Activity是第一次被创建，所以其 mContentParent肯定是null的，所以为执行注释2的代码。

注释2：调用 installDecor()

// PhoneWindow.java

private void installDecor() {

mForceDecorInstall = false;

if (mDecor == null) { // 1

mDecor = generateDecor(-1); // 2

mDecor.setDescendantFocusability(ViewGroup.FOCUS_AFTER_DESCENDANTS);

mDecor.setIsRootNamespace(true);

if (!mInvalidatePanelMenuPosted && mInvalidatePanelMenuFeatures != 0) {

mDecor.postOnAnimation(mInvalidatePanelMenuRunnable);

}

} else {

mDecor.setWindow(this);

}

if (mContentParent == null) {

mContentParent = generateLayout(mDecor); // 3

…

}

…

}

注释1：判断 mDecor是否为null，由于之前我们没有看到有关于mDecor的创建代码，所以显然它为null。

注释2：调用 generatorView()来创建一个 DecorView：

// PhoneWindow.java

protected DecorView generateDecor(int featureId) {

…

return new DecorView(context, featureId, this, getAttributes());

}

这里是本流程中第一次看到的调用了 new DecorView()方法.

注释3:调用了 generateLayout(mDecor)方法，创建了 mContentParent这个ViewGroup，其实在这里我们已经大概知道了 mCotnentParent就是 DecorView两个部分中的 ContentView。我们来看看这个方法：

// PhoneWindow.java

protected ViewGroup generateLayout(DecorView decor) {

…

int layoutResource; // 根据不同的情况加载不同的布局给layoutResource

int features = getLocalFeatures();

if ((features & (1 << FEATURE_SWIPE_TO_DISMISS)) != 0) {

layoutResource = R.layout.screen_swipe_dismiss;

setCloseOnSwipeEnabled(true);

} else if ((features & (1 << FEATURE_ACTION_MODE_OVERLAY)) != 0) {

layoutResource = R.layout.screen_simple_overlay_action_mode;

} …

} else {

layoutResource = R.layout.screen_simple; // 1

}

…

mDecor.onResourcesLoaded(mLayoutInflater, layoutResource); // 2

ViewGroup contentParent = (ViewGroup)findViewById(ID_ANDROID_CONTENT);

…

return contentParent;

}

这个代码非常长，它根据代码中所设置的FEATURE或者在AndroidManifest中对Activity设置的Flag来加载不同的资源。

然后在注释2中，让Activity加载这个资源。

在上面不同的资源中，我们需要留意的是注释1中的 R.layout.screen_simple，它是在Activity没有设置任何界面选项的情况下加载的，即默认布局，我们看看它是什么样的：

在这里插入图片描述

它分成了两个部分，顶部是一个ViewStub，它是一个 ActionBar状态栏，它下面是一个 FrameLayout，表示content。

这个时候 mContentParent通过findViewById得到了下面的content。最后在一开始的 setContentView中将mContentParent渲染上我们想要的layout。如下图所示：

在这里插入图片描述

至此，DecorView的产生以及它的布局就到此为止了。

1.3 小结

下面来总结一下 DecorView的创建

DecorView的创建来是在 Activity的加载过程中，在 ActivityThread.performLaunchActivity()中，创建了最初始的 PhoneWindow
在Activity.onCreate()中调用了 Activity.setContentView()来加载布局，其实是调用第一步创建的 PhoneWindow.setContentView
判断Activity的 DecorView是否为null，如果不存在，则创建一个 DecorView。DecorView被PhoneWindow持有着，继承自FrameLayout。
判断DecorView中有没有内容（即mContentParent），如果没有，则根据配置在DecorView上加载一个默认布局layout，一般来说，这个布局包含了Action Bar 和 ContentView
回到setContentView中，将我们写的layout布局加载到DecorView的 ContentView中。完成Activity的页面布局。

2. View绘制的入口

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

在第一节中，我们已经创建并初始化好了一个DecorView，并且将其ContentView加载了我们自定义化的Layout。但是它们处于的生命周期还是在 onCreate中，我们知道，只有在 onResume、onStart中，我们才能看到它。

在一开始的 handleLaunchActivity中，我们还看到执行了 handleResumeActivity()，它是执行了绘制的地方。

2.1 handleResumeActivity

final void handleResumeActivity(IBinder token,

boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason) {

ActivityClientRecord r = mActivities.get(token);

…

r = performResumeActivity(token, clearHide, reason); // 1

if (r != null) {

final Activity a = r.activity;

…

if (r.window == null && !a.mFinished && willBeVisible) {

r.window = r.activity.getWindow();

View decor = r.window.getDecorView(); // 2

decor.setVisibility(View.INVISIBLE);

ViewManager wm = a.getWindowManager(); // 3

WindowManager.LayoutParams l = r.window.getAttributes();

a.mDecor = decor;

…

if (a.mVisibleFromClient) {

if (!a.mWindowAdded) {

a.mWindowAdded = true;

wm.addView(decor, l); // 4

} else {

a.onWindowAttributesChanged(l);

}

…

}

…

}

注释1中：performResumeActivity()会调用Activity的onResume()方法。

注释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;

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

总结：

面试是一个不断学习、不断自我提升的过程，有机会还是出去面面，至少能想到查漏补缺效果，而且有些知识点，可能你自以为知道，但让你说，并不一定能说得很好。

有些东西有压力才有动力，而学到的知识点，都是钱（因为技术人员大部分情况是根据你的能力来定级、来发薪水的），技多不压身。

附上我的面试各大专题整理：面试指南，满满的都是干货，希望对大家有帮助！

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

}

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;

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

[外链图片转存中…(img-PTWBCRRM-1713681702550)]

[外链图片转存中…(img-WsfyoKKa-1713681702552)]

[外链图片转存中…(img-DwN8v4tK-1713681702553)]

[外链图片转存中…(img-V5ol3wsm-1713681702554)]

[外链图片转存中…(img-qEVdVRy6-1713681702555)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

总结：

有些东西有压力才有动力，而学到的知识点，都是钱（因为技术人员大部分情况是根据你的能力来定级、来发薪水的），技多不压身。

附上我的面试各大专题整理：面试指南，满满的都是干货，希望对大家有帮助！
[外链图片转存中…(img-dunWPd7C-1713681702556)]

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

史迪哇

关注

9
点赞
踩
29

收藏

觉得还不错? 一键收藏
0
评论
源码分析View的绘制流程

面试是一个不断学习、不断自我提升的过程，有机会还是出去面面，至少能想到查漏补缺效果，而且有些知识点，可能你自以为知道，但让你说，并不一定能说得很好。有些东西有压力才有动力，而学到的知识点，都是钱（因为技术人员大部分情况是根据你的能力来定级、来发薪水的），技多不压身。附上我的面试各大专题整理：面试指南，满满的都是干货，希望对大家有帮助！《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！break;break;
复制链接

扫一扫