Activity启动过程中做了哪些事情？下面的时序图展示里启动过程中函数的调用过程, 从图中可以知道大概流程。
在介绍细节的时候是从上往下函数调用过程介绍的，如果不知道某个函数是在哪里被谁调用的，可以回过头来看下时序图。下面是对一些细节进行介绍。
1. 在Android中有两种操作会引发Activity的启动，一种用户点击Launcher的应用程序图标时，Launcher会为启动应用程序的主Activity。另外一种是在已经起来的Activity内部通过调用startActvity接口启动新的Activity。每一个Activity都可以在内部启动新的Activity。图中就是从一个Activity调用startActivity启动另外一个Activity开始。
startActivity()@Activity.java
public void startActivity(Intent intent, Bundle options) {
if (options != null) {
startActivityForResult(intent, -1, options);
} else {
// Note we want to go through this call for compatibility with
// applications that may have overridden the method.
startActivityForResult(intent, -1);
}
}
startActivity()中调用携带requestCode参数的startActivityForResult()启动新的activity。
startActivityForResult()@Activity.java
public void startActivityForResult(Intent intent, int requestCode, Bundle options) {
//一般的Activity的mParent为null
if (mParent == null) {
//调用Instrumentation.execStartActivity()启动新的Activity。mMainThread类型为ActivityThread, 在attach()函数被回调时被赋值。
Instrumentation.ActivityResult ar = mInstrumentation.execStartActivity(this, mMainThread.getApplicationThread(), mToken, this, intent, requestCode, options);
if (ar != null) { // 如果activity之前已经启动，而且处于阻塞状态，execStartActivity函数直接返回要启动的activity的result或者null。（注意：这就是Activity.onActivityResult()会在启动另外一个activity启动时被回调的原因。
// 若result非空，发送结果给本activity，即onActivityResult会被调用。
mMainThread.sendActivityResult(mToken, mEmbeddedID, requestCode, ar.getResultCode(),
ar.getResultData());
}
if (requestCode >= 0) {
// 如果这次启动需要被启动的activity返回一个结果，则在收到返回结果前，本activity保持不可见。
mStartedActivity = true;
}
final View decor = mWindow != null ? mWindow.peekDecorView() : null;
if (decor != null) {
decor.cancelPendingInputEvents();
}
// TODO Consider clearing/flushing other event sources and events for child windows.
} else {
//在ActivityGroup内部的Activity调用startActivity的时候会走到这里，内部处理逻辑和上面是类似的
if (options != null) {
mParent.startActivityFromChild(this, intent, requestCode, options);
} else {
mParent.startActivityFromChild(this, intent, requestCode);
}
}
}
Instrumentation类的功能是辅助Activity的监控和测试，接着看execStartActivity()函数的实现。
execStartActivity()@Instrumentation.java
1 public ActivityResult execStartActivity(
2 Context who, IBinder contextThread, IBinder token, Activity target,
3 Intent intent, int requestCode, Bundle options) {
4 //将contextThread转成ApplicationThread.
5 IApplicationThread whoThread = (IApplicationThread) contextThread;
6 if (mActivityMonitors != null) {
7 synchronized (mSync) {
8 //检查是否存在这个activity
9 final int N = mActivityMonitors.size();
10 for (int i=0; i<N; i++) {
11 final ActivityMonitor am = mActivityMonitors.get(i);
12 if (am.match(who, null, intent)) {
13 am.mHits++;
14 if (am.isBlocking()) { //若找到，而且处于阻塞状态，直接返回。
15 return requestCode >= 0 ? am.getResult() : null;
16 }
17 break;
18 }
19 }
20 }
21 }
22 try {
23 intent.migrateExtraStreamToClipData(); //转移数据
24 intent.prepareToLeaveProcess(); //准备让intent离开一个app进程
25 //通过AcitivityManagerNative与ActivityManagerService关联起来，两个类的关系如下图，由ActivityManagerService去执行实际动作。
26 int result = ActivityManagerNative.getDefault()
27 .startActivity(whoThread, who.getBasePackageName(), intent,
28 intent.resolveTypeIfNeeded(who.getContentResolver()),
29 token, target != null ? target.mEmbeddedID : null,
30 requestCode, 0, null, null, options);
31 //检查启动结果，如果无法打开activity，则抛出诸如ActivityNotFoundException类似的各种异常
32 checkStartActivityResult(result, intent);
33 } catch (RemoteException e) {
34 }
35 return null;
36 }
2. ActivityManager的功能是与系统中所有运行着的Activity交互提供了接口，主要的接口围绕着运行中的进程信息，任务信息，服务信息等，它的大多数功能都是调用了ActivityManagerNative类接口来完成的。
ActivityManager相关静态类图如下图，可以看出这是典型的Proxy模式：
结合面的类结构图，其中ActivityManager是一个客户端，为了减少它与ActivityManagerService的耦合度，在这中间使用了ActivityManagerNative类，该类内部使用ActivityManagerProxy代理类，所有对 ActivityManagerService的访问都转换成对代理类的访问，这样ActivityManager就与ActivityManagerService解耦了。
为了让代理类与被代理类保持一致的接口，由IActivityManager作为ActivityManagerProxy和ActivityManagerNative的公共接口，ActivityManagerService继承于ActivityManagerNative，也具有相同的接口。
图中绿色的部分是在SDK中开放给应用程序开发人员的接口，蓝色的部分是Proxy模式的实现，红色的部分是底层的服务实现，是真正的动作执行者。
3. startActivity()@ActivityManagerService.java
@Override
public final int startActivity(IApplicationThread caller, String callingPackage,
Intent intent, String resolvedType, IBinder resultTo,
String resultWho, int requestCode, int startFlags,
String profileFile, ParcelFileDescriptor profileFd, Bundle options) {
return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
resultWho, requestCode, startFlags, profileFile, profileFd, options, UserHandle.getCallingUserId());
}
@Override
public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
Intent intent, String resolvedType, IBinder resultTo,
String resultWho, int requestCode, int startFlags,
String profileFile, ParcelFileDescriptor profileFd, Bundle options, int userId) {
enforceNotIsolatedCaller("startActivity");
userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId,
false, true, "startActivity", null);
// TODO: Switch to user app stacks here.
return mStackSupervisor.startActivityMayWait(caller, -1, callingPackage, intent, resolvedType,
resultTo, resultWho, requestCode, startFlags, profileFile, profileFd,
null, null, options, userId);
}
类ActivityStackSupervisor是用来辅助ActivityManagerService对Activity和Task的管理的。其中用ActivityStackSupervisor类型来进行对Task的操作，用ActivityStack对Acitivity进行操作。
4. 调用mStackSupervisor.startActivityMayWait()函数后，会执行下面几个函数，调用关系参照时序图，函数里涉及很多细节，这里只简单描述下它们的主要功能：
调用9. ActivityStackSupervisor.startActivityLocked(): 检查启动权限，创建新的ActivityRecord。
调用10. ActivityStackSupervisor.startActivityUncheckedLocked()：处理intent携带的launch flags, launchMode。(后面再研究launch相关的flag和mode)
调用11. ActivityStack.startActivityLocked()：将activity放到所属task的顶部，重置Task（resetTaskIfNeededLocked），调用WindowManager.setAppStartingWindow()。
调用13. ActivityStackSupervisor.resumeTopActivitiesLocked()：判断ActivityStack数组中是否存在target ActivityStack。
调用14. ActivityStack.resumeTopActivityLocked(): 从当前activity切换到要启动的activity。
调用15. ActivityStackSupervisor.startSpecificActivityLocked():获取ProcessRecord(若要启动的activity的应用已经在运行)，若获取ProcessRecord存在则调用realStartActivityLocked()，否则调用 ActivityManagerServices.startProcessLocked()创建新的ProcessRecord，最后调用Process.start()启动新的进程（最终调用Zygote启动新的进程，为了避免混淆，这部分在时序图中没有体现，后面再研究）。
调用16. ActivityStackSupervisor.realStartActivityLocked(): 调用mWindowManager.setAppVisibility()设置app可见。
调用19. ActivityThread.scheduleLauncherActivity(): 发送Message LAUNCH_ACTIVITY给Handler.
5. Handler接收到message后，执行ActivityThread.handleLaunchActivity()。
handleLaunchActivity()@ActivityThread.java
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
......
Activity a = performLaunchActivity(r, customIntent); // 返回一个activity.
if (a != null) {
r.createdConfig = new Configuration(mConfiguration);
Bundle oldState = r.state;
handleResumeActivity(r.token, false, r.isForward, !r.activity.mFinished && !r.startsNotResumed);
if (!r.activity.mFinished && r.startsNotResumed) {
// 当这个activity没有finished而且没有处于resumed状态时，Acivity Manager实际上想要这个activity以paused状态开始，因为它需要可见，但是又不在前台。
// 为此，需要经过正常启动（因为activity希望在它们的window被显示前，它们第一次运行时通过onResume），然后暂停它。The activity manager actually wants this one to start out
//然而，在这种情况下，不需要走完整的暂停周期(比如freezing等)，因为activity假定它可以刚好保留它当前的所有状态。
try {
r.activity.mCalled = false;
mInstrumentation.callActivityOnPause(r.activity);
......
} catch (SuperNotCalledException e) {
......
} catch (Exception e) {
......
}
r.paused = true;
}
} else {
......
}
}
6.进一步看performLaunchActivity()，这个函数做了几件重要的事情：创建activity实例，调用Activity.attach()设置参数，触发Activity.onCreate()。
performLaunchActivity()@ActivityThread.java
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
ActivityInfo aInfo = r.activityInfo;
if (r.packageInfo == null) { // 填充package info
r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
Context.CONTEXT_INCLUDE_CODE);
}
ComponentName component = r.intent.getComponent();
if (component == null) {
component = r.intent.resolveActivity(mInitialApplication.getPackageManager());
r.intent.setComponent(component); //设置Component
}
if (r.activityInfo.targetActivity != null) {
component = new ComponentName(r.activityInfo.packageName,
r.activityInfo.targetActivity);
}
Activity activity = null;
try {
java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent); // 根据Activity的类名，通过Java反射机制创建对应的Activity.
StrictMode.incrementExpectedActivityCount(activity.getClass());
r.intent.setExtrasClassLoader(cl);
if (r.state != null) {
r.state.setClassLoader(cl);
}
} catch (Exception e) {
......
}
try {
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
if (activity != null) {
Context appContext = createBaseContextForActivity(r, activity); // Activity中getContext()函数返回的就是这个对象。
CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
Configuration config = new Configuration(mCompatConfiguration);
......
// 将Context，ActivityThread，Instrumentation，Application等设置给新建的Activity，供activity使用。
activity.attach(appContext, this, getInstrumentation(), r.token,
r.ident, app, r.intent, r.activityInfo, title, r.parent,
r.embeddedID, r.lastNonConfigurationInstances, config);
if (customIntent != null) {
activity.mIntent = customIntent;
}
r.lastNonConfigurationInstances = null;
activity.mStartedActivity = false;
int theme = r.activityInfo.getThemeResource();
if (theme != 0) {
activity.setTheme(theme); // 设置theme
}
activity.mCalled = false;
mInstrumentation.callActivityOnCreate(activity, r.state); // 这个函数会使Activity的onCreate()函数被调用
if (!activity.mCalled) {
throw new SuperNotCalledException(
"Activity " + r.intent.getComponent().toShortString() +
" did not call through to super.onCreate()");
}
r.activity = activity;
r.stopped = true;
if (!r.activity.mFinished) {
activity.performStart(); // 这个函数会使Activity的onStart()函数被调用
r.stopped = false;
}
if (!r.activity.mFinished) {
if (r.state != null) {
mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
}
}
if (!r.activity.mFinished) {
activity.mCalled = false;
mInstrumentation.callActivityOnPostCreate(activity, r.state);
if (!activity.mCalled) {
throw new SuperNotCalledException(
"Activity " + r.intent.getComponent().toShortString() +
" did not call through to super.onPostCreate()");
}
}
}
r.paused = true;
mActivities.put(r.token, r);
} catch (SuperNotCalledException e) {
......
} catch (Exception e) {
......
}
return activity;
}
7.下面分析下Activity.attach()函数，它创建window对象，设置window manager。
attach()@Activity.java
final void attach(Context context, ActivityThread aThread,
Instrumentation instr, IBinder token, int ident,
Application application, Intent intent, ActivityInfo info,
CharSequence title, Activity parent, String id,
NonConfigurationInstances lastNonConfigurationInstances,
Configuration config) {
attachBaseContext(context); // 把context赋值给父类的mBase成员
mFragments.attachActivity(this, mContainer, null);
mWindow = PolicyManager.makeNewWindow(this); // 调用PolicyManager的函数创建Window对象。
mWindow.setCallback(this);
mWindow.getLayoutInflater().setPrivateFactory(this);
if (info.softInputMode != WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) {
mWindow.setSoftInputMode(info.softInputMode); //设置输入法mode
}
if (info.uiOptions != 0) {
mWindow.setUiOptions(info.uiOptions);
}
mUiThread = Thread.currentThread();
// 赋值给Acitivity的各个成员
mMainThread = aThread; //mMainThread实际上为ActivityThread。
mInstrumentation = instr;
mToken = token;
mIdent = ident;
mApplication = application;
mIntent = intent;
mComponent = intent.getComponent();
mActivityInfo = info;
mTitle = title;
mParent = parent;
mEmbeddedID = id;
mLastNonConfigurationInstances = lastNonConfigurationInstances;
// 创建WindowManager对象并设置给window，供window使用.
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(); // 保存WindowManager对象.
mCurrentConfig = config;
}
8. 其中一个关键的函数PolicyManager.makeNewWindow()返回的Window对象，实际上是一个PhoneWindow对象。
具体创建过程参考下面代码：
class PolicyManager@PolicyManager.java
public final class PolicyManager {
private static final String POLICY_IMPL_CLASS_NAME =
"com.android.internal.policy.impl.Policy";
private static final IPolicy sPolicy; // sPolicy为单例的IPolicy对象。
static {
// Pull in the actual implementation of the policy at run-time
try {
Class policyClass = Class.forName(POLICY_IMPL_CLASS_NAME);
sPolicy = (IPolicy)policyClass.newInstance(); // 创建Policy对象。
} catch (ClassNotFoundException ex) {
......
}
}
// Cannot instantiate this class
private PolicyManager() {}
// The static methods to spawn new policy-specific objects
public static Window makeNewWindow(Context context) {
return sPolicy.makeNewWindow(context); //通过Policy对象的makeNewWindow创建一个Window。
}
......
}
class Policy@Policy.java
public class Policy implements IPolicy {
private static final String TAG = "PhonePolicy";
private static final String[] preload_classes = {
"com.android.internal.policy.impl.PhoneLayoutInflater",
"com.android.internal.policy.impl.PhoneWindow",
"com.android.internal.policy.impl.PhoneWindow$1",
"com.android.internal.policy.impl.PhoneWindow$DialogMenuCallback",
"com.android.internal.policy.impl.PhoneWindow$DecorView",
"com.android.internal.policy.impl.PhoneWindow$PanelFeatureState",
"com.android.internal.policy.impl.PhoneWindow$PanelFeatureState$SavedState",
};
static {
// For performance reasons, preload some policy specific classes when
// the policy gets loaded.
for (String s : preload_classes) { // 加载所有的类
try {
Class.forName(s);
} catch (ClassNotFoundException ex) {
......
}
}
}
public Window makeNewWindow(Context context) {
return new PhoneWindow(context); // 实际返回的PhoneWindow对象。
}
......
}
9. setWindowManager()@Window.java
public void setWindowManager(WindowManager wm, IBinder appToken, String appName,
boolean hardwareAccelerated) {
mAppToken = appToken;
mAppName = appName;
mHardwareAccelerated = hardwareAccelerated || SystemProperties.getBoolean(PROPERTY_HARDWARE_UI, false);
if (wm == null) {
wm = (WindowManager)mContext.getSystemService(Context.WINDOW_SERVICE);
}
mWindowManager = ((WindowManagerImpl)wm).createLocalWindowManager(this); // 创建一个WindowManagerImpl对象
}
到这里可以看到，Activity成员变量mWindow实际上是PhoneWindow类型， 变量mWindowManager实际上是WindowManagerImpl。这
10. Acitivity.attach()函数被调用之后，performLaunchActivity还会触发Activity.onCreate()函数被调用，在这个函数中会调用setContentView()函数设置Activity的UI内容。
setContentView()有三种实现，它们的功能基本一致，都是将view添加到mContentParent中：
setContentView()@Activity.java
// 通过一个布局资源设置activity的内容。
public void setContentView(int layoutResID) {
getWindow().setContentView(layoutResID);
initActionBar();
}
// 直接将View作为内容直接设置到activity的视图层次中。这种方式设置给view的layoutparams将不起作用，默认为MATCH_PARENT.
public void setContentView(View view) {
getWindow().setContentView(view);
initActionBar();
}
// 设置activity的内容为view, 并设置view的LayoutParams.
public void setContentView(View view, ViewGroup.LayoutParams params) {
getWindow().setContentView(view, params);
initActionBar();
}
下面给出其中一种实现：
setContentView()@PhoneWindow.java
public void setContentView(View view, ViewGroup.LayoutParams params) {
if (mContentParent == null) {
installDecor(); // 初始化DecorView和mContentParent.
} else {
mContentParent.removeAllViews();
}
mContentParent.addView(view, params);
final Callback cb = getCallback();
if (cb != null && !isDestroyed()) {
cb.onContentChanged();
}
}
installDecor()@PhoneWindow.java
private void installDecor() {
if (mDecor == null) {
mDecor = generateDecor();
......
}
if (mContentParent == null) {
mContentParent = generateLayout(mDecor);
mTitleView = (TextView)findViewById(com.android.internal.R.id.title); // 创建标题栏
......
}
}
generateDecor()@PhoneWindow.java
protected DecorView generateDecor() {
return new DecorView(getContext(), -1); // DecorView从FrameLayout派生,同时实现RootViewSurfaceTaker接口。
}
generateLayout()@PhoneWindow.java
protected ViewGroup generateLayout(DecorView decor) {
......
// Inflate the window decor.
int layoutResource; // 根据情况获取相应的标题栏资源ID。
int features = getLocalFeatures();
if ((features & ((1 << FEATURE_LEFT_ICON) | (1 << FEATURE_RIGHT_ICON))) != 0) {
if (mIsFloating) {
......
layoutResource = res.resourceId;
}
......
}
mDecor.startChanging();
View in = mLayoutInflater.inflate(layoutResource, null); //inflate 标题栏
decor.addView(in, new ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT)); // 加入标题栏
ViewGroup contentParent = (ViewGroup)findViewById(ID_ANDROID_CONTENT); // ID_ANDROID_CONTENT:xml布局文件中main layout的ID， 实际上是mDecorView的一部分。
......
mDecor.finishChanging();
return contentParent;
}
findViewById()@Window.java
public View findViewById(int id) {
return getDecorView().findViewById(id);
}
通过上面的代码可以看到，在Activity.onCreate()函数里调用setContentView设置的View，实际上会作为DecorView的子view。DecorView还处理了标题栏显示等工作。
addView()@ViewGroup.java
public void addView(View child, int index, LayoutParams params) {
// addViewInner()函数中设置LayoutParams时会调用child.requestLayout()，在这里调用，为了在这里阻塞child的request.
requestLayout();
invalidate(true); //在下一篇文章中会介绍这个函数
addViewInner(child, index, params, false);
}
11. 我们接着看handleLaunchActivity()中的handleResumeActivity()函数，
handleResumeActivity()@ActivityThread.java
final void handleResumeActivity(IBinder token, boolean clearHide, boolean isForward, boolean reallyResume) {
......
ActivityClientRecord r = performResumeActivity(token, clearHide); //会调用到Activity.onResume().
if (r != null) {
final Activity a = r.activity;
final int forwardBit = isForward ? WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION : 0;
// If the window hasn't yet been added to the window manager,
// and this guy didn't finish itself or start another activity,
// then go ahead and add the window.
// 若这个activity的window没有加到window manager中，而且它没有自己finish或者启动另外一个acitivity,那就继续，添加这个window.
boolean willBeVisible = !a.mStartedActivity;
if (!willBeVisible) {
try {
willBeVisible = ActivityManagerNative.getDefault().willActivityBeVisible(a.getActivityToken());
} catch (RemoteException e) {
}
}
if (r.window == null && !a.mFinished && willBeVisible) {
r.window = r.activity.getWindow(); // 获得在attach()函数中创建出来的window对象。
View decor = r.window.getDecorView(); // 获得一个View对象
decor.setVisibility(View.INVISIBLE);
ViewManager wm = a.getWindowManager(); // 获得ViewManager对象
WindowManager.LayoutParams l = r.window.getAttributes();
a.mDecor = decor;
l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
l.softInputMode |= forwardBit;
if (a.mVisibleFromClient) {
a.mWindowAdded = true;
wm.addView(decor, l); // 添加View对象到WindowManager中。
}
} else if (!willBeVisible) { // 如果window已经被添加了，但在resume时启动另外的activity,这个window将隐藏。
r.hideForNow = true;
}
// Get rid of anything left hanging around.
cleanUpPendingRemoveWindows(r);
// 如果window添加了，执行到这的时候就可见了。
if (!r.activity.mFinished && willBeVisible && r.activity.mDecor != null && !r.hideForNow) {
if (r.newConfig != null) {
performConfigurationChanged(r.activity, r.newConfig);
freeTextLayoutCachesIfNeeded(r.activity.mCurrentConfig.diff(r.newConfig));
r.newConfig = null;
}
WindowManager.LayoutParams l = r.window.getAttributes();
if ((l.softInputMode & WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) != forwardBit) {
l.softInputMode = (l.softInputMode
& (~WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION))
| forwardBit;
if (r.activity.mVisibleFromClient) {
ViewManager wm = a.getWindowManager();
View decor = r.window.getDecorView();
wm.updateViewLayout(decor, l); // 根据输入法显示模式调整winddow layout。
}
}
r.activity.mVisibleFromServer = true;
mNumVisibleActivities++;
if (r.activity.mVisibleFromClient) {
r.activity.makeVisible();
}
}
if (!r.onlyLocalRequest) {
r.nextIdle = mNewActivities;
mNewActivities = r;
Looper.myQueue().addIdleHandler(new Idler());
}
r.onlyLocalRequest = false;
// Tell the activity manager we have resumed.
if (reallyResume) {
try {
ActivityManagerNative.getDefault().activityResumed(token);
} catch (RemoteException ex) {
}
}
} else {
// If an exception was thrown when trying to resume, then just end this activity.
// 如果resume过程出现异常，就finish这个activity.
try {
ActivityManagerNative.getDefault().finishActivity(token, Activity.RESULT_CANCELED, null);
} catch (RemoteException ex) {
}
}
}
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); // 创建ViewRootImpl对象
view.setLayoutParams(wparams);
mViews.add(view);
mRoots.add(root);
mParams.add(wparams);
}
// do this last because it fires off messages to start doing things
try {
root.setView(view, wparams, panelParentView); // setView()内调用requestLayout(). 在被加到WindowManager之前调度第一次layout,确保收到系统事件之前重新进行了布局。
} catch (RuntimeException e) {
......
}
}
ViewRootImpl及setView()涉及到了UI绘制。启动相关更多的细节在下一篇中进行分析。