在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.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中看看。
// 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的产生以及它的布局就到此为止了。
下面来总结一下 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的页面布局。
==============================================================================
在第一节中,我们已经创建并初始化好了一个DecorView,并且将其ContentView加载了我们自定义化的Layout。但是它们处于的生命周期还是在 onCreate
中,我们知道,只有在 onResume、onStart中,我们才能看到它。
在一开始的 handleLaunchActivity
中,我们还看到执行了 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,进入到绘制流程的源码中。
==================================================================================
我们知道在调用 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。
===================================================================================
measure的作用就是用来测量一个DecorView及其所有子View的宽和高。
它的流程分为View的measure流程和ViewGroup的measure流程。
而他们的入口,都是在于上一节中的 mView.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。
首先来看看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)
![](https://i-blog.csdnimg.cn/blog_migrate/7ae6882bb272b2f2e966c1b6e4acd829.jpeg)
总结:
面试是一个不断学习、不断自我提升的过程,有机会还是出去面面,至少能想到查漏补缺效果,而且有些知识点,可能你自以为知道,但让你说,并不一定能说得很好。
有些东西有压力才有动力,而学到的知识点,都是钱(因为技术人员大部分情况是根据你的能力来定级、来发薪水的),技多不压身。
附上我的面试各大专题整理: 面试指南,满满的都是干货,希望对大家有帮助!
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!
}
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移动开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
[外链图片转存中…(img-PTWBCRRM-1713681702550)]
[外链图片转存中…(img-WsfyoKKa-1713681702552)]
[外链图片转存中…(img-DwN8v4tK-1713681702553)]
[外链图片转存中…(img-V5ol3wsm-1713681702554)]
[外链图片转存中…(img-qEVdVRy6-1713681702555)]
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Android开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
如果你觉得这些内容对你有帮助,可以扫码获取!!(备注:Android)
![](https://i-blog.csdnimg.cn/blog_migrate/7ae6882bb272b2f2e966c1b6e4acd829.jpeg)
总结:
面试是一个不断学习、不断自我提升的过程,有机会还是出去面面,至少能想到查漏补缺效果,而且有些知识点,可能你自以为知道,但让你说,并不一定能说得很好。
有些东西有压力才有动力,而学到的知识点,都是钱(因为技术人员大部分情况是根据你的能力来定级、来发薪水的),技多不压身。
附上我的面试各大专题整理: 面试指南,满满的都是干货,希望对大家有帮助!
[外链图片转存中…(img-dunWPd7C-1713681702556)]
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!