Android四大组件系列3 Activity启动流程（下）
一 概述
Activity 的启动分为不同进程间和相同进程的启动。由于进程间 Activity 启动流程包括了相同进程 Activity 启动的流程。因此本文只分析不同进程间，比如点击 Launcher 桌面图标启动 Activity 的整个过程。在阅读本篇文章之前，建议同学们先了解下 AMS 相关的数据结构和管理机制，可参考 Android四大组件系列1 AMS相关数据结构。
本篇文章接上一篇文章 Android四大组件系列2 Activity启动流程（上）继续分析。上一篇文章我们分析了 startActivity阶段，pause阶段和新进程创建阶段，这篇文章我们分析剩下的 onCreate，onStart，onResume 函数阶段。
时序图如下：
点击查看大图。
二 onCreate阶段
接上一篇文章，经历 新进程创建阶段 后，同学们可以参考 Android系统启动系列7 进程创建流程，来详细了解新进程的创建过程，我们知道新进程创建成功后，会执行 ActivityTaskManagerService.attachApplication 方法，用来把新创建的应用信息绑定到 AMS 中，我们来看：
2.1 ActivityTaskManagerService.attachApplication
// 启动 Activity
public boolean attachApplication(WindowProcessController wpc)
throws RemoteException {
synchronized (mGlobalLockWithoutBoost) {
return mRootActivityContainer.attachApplication(wpc);
}
}
2.2 RootActivityContainer.attachApplication
boolean attachApplication(WindowProcessController app) throws RemoteException {
final String processName = app.mName;
boolean didSomething = false;
for (int displayNdx = mActivityDisplays.size() - 1;
displayNdx >= 0; --displayNdx) {
final ActivityDisplay display = mActivityDisplays.get(displayNdx);
final ActivityStack stack = display.getFocusedStack();
if (stack != null) {
stack.getAllRunningVisibleActivitiesLocked(mTmpActivityList);
final ActivityRecord top = stack.topRunningActivityLocked();
final int size = mTmpActivityList.size();
for (int i = 0; i < size; i++) {
final ActivityRecord activity = mTmpActivityList.get(i);
if (activity.app == null &&
app.mUid == activity.info.applicationInfo.uid
&& processName.equals(activity.processName)) {
// 启动Activity
if (mStackSupervisor.realStartActivityLocked(activity, app,
top == activity, true)) {
didSomething = true;
}
}
}
}
}
if (!didSomething) {
ensureActivitiesVisible(null, 0, false /* preserve_windows */);
}
return didSomething;
}
2.3 ActivityStackSupervisor.realStartActivityLocked
ActivityStackSupervisor.java
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
boolean andResume, boolean checkConfig) throws RemoteException {
......
final TaskRecord task = r.getTaskRecord();
final ActivityStack stack = task.getStack();
beginDeferResume();
try {
......
try {
......
// Create activity launch transaction.
final ClientTransaction clientTransaction = ClientTransaction.obtain(
proc.getThread(), r.appToken);
final DisplayContent dc = r.getDisplay().mDisplayContent;
// 关键调用，使用 ClientLifecycleManager，执行 Activity 的 onCreate
clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
System.identityHashCode(r), r.info,
mergedConfiguration.getGlobalConfiguration(),
mergedConfiguration.getOverrideConfiguration(), r.compat,
r.launchedFromPackage, task.voiceInteractor, proc.getReportedProcState(),
r.icicle, r.persistentState, results, newIntents,
dc.isNextTransitionForward(), proc.createProfilerInfoIfNeeded(),
r.assistToken));
// Set desired final state.
final ActivityLifecycleItem lifecycleItem;
if (andResume) {
// 把 ResumeActivityItem 也添加到 clientTransaction 中
lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());
} else {
lifecycleItem = PauseActivityItem.obtain();
}
clientTransaction.setLifecycleStateRequest(lifecycleItem);
// Schedule transaction.执行 clientTransaction
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
......
} catch (RemoteException e) {
......
}
} finally {
endDeferResume();
}
......
return true;
}
在这个方法中，会创建一个 ClientTransaction 对象，之前在分析 Activity 的 pause 流程时，也有一个对象 ClientTransaction，它会被传递到客户进程，这里就不再一步一步看了，忘记的同学可以回到上面 pause 流程去查看。同样通过 obtain() 方法创建出一个 ClientTransaction 实例，有一点与 pause 时不同的是，现在创建的这个 ClientTransaction 对象，调用了它的 addCallback() 方法，并传入了 LaunchActivityItem.obtain() 的返回值，先看一下 LaunchActivityItem 的 obtain() 方法。
2.4 LaunchActivityItem.obtain
LaunchActivityItem.java
public static LaunchActivityItem obtain(Intent intent, int ident, ......) {
LaunchActivityItem instance = ObjectPool.obtain(LaunchActivityItem.class);
if (instance == null) {
instance = new LaunchActivityItem();
}
setValues(instance, intent, ident, info, curConfig, ......);
return instance;
}
创建了一个 LaunchActivityItem 实例，并对参数进行了一些赋值操作。回到上面看一下 ClientTransaction 的 addCallback 方法，传入的参数就是这个 LaunchActivityItem 实例。
2.5 ClientTransaction.addCallback
ClientTransaction.java
private List<ClientTransactionItem> mActivityCallbacks;
......
public void addCallback(ClientTransactionItem activityCallback) {
if (mActivityCallbacks == null) {
mActivityCallbacks = new ArrayList<>();
}
mActivityCallbacks.add(activityCallback);
}
将这个 LaunchActivityItem 保存在了 ClientTransaction 的 mActivityCallbacks 数组中。回到 realStartActivityLocked() 方法。为 ClientTransaction 添加 mActivityCallback 后，也会调用 setLifecycleStateRequest 方法对 ClientTransaction 对象的 mLifecycleStateRequest 属性进行赋值，前面 pause 流程的时候就是通过的这个属性。这里会创建一个 ResumeActivityItem 对象添加到 mLifecycleStateRequest 中去。
我们再捋一下，和前面一样，这个 ClientTransaction 对象包含了与客户端通信的 IApplicationThread、token，并且还包括了一个存有 LaunchActivityItem 对象的 callback 和一个存有 ResumeActivityItem 对象的 mLifecycleStateRequest 变量。接着继续执行了 mService.getLifecycleManager().scheduleTransaction() 方法，这里就不看了，也是和前面一样的流程，最终同样会在客户端调用到 TransactionExecutor 的 execute() 方法。
以上都是关于 ClientLifecycleManager 机制的操作流程，如果想详细了解的话，请参考 深入理解 ClientLifecycleManager 机制。
接下来我们来看在 app 端通过 TransactionExecutor 来执行 ClientTransaction 的代码
2.6 TransactionExecutor.execute
TransactionExecutor.java
public void execute(ClientTransaction transaction) {
......
final IBinder token = transaction.getActivityToken();
......
// 先执行 callback
executeCallbacks(transaction);
// 后执行 lifecycleState
executeLifecycleState(transaction);
mPendingActions.clear();
......
}
首先需要注意的是在 execute 函数中是顺序执行 mActivityCallbacks 和 mLifecycleStateRequest 的。
可以回忆一下，在 pause 流程中，callback 是空的，只有一个 PauseActivityItem 类型的 lifecycleState。但是这一次，我们为 callback 赋值了。先看一下 executeCallbacks() 方法，onCreate 流程就是从这个方法开始一步一步执行到的。
2.7 TransactionExecutor.executeCallbacks
TransactionExecutor .java
public void executeCallbacks(ClientTransaction transaction) {
// 从服务端传来的 transaction 中取出 callbacks 数组
// pause 流程中这个列表是空，直接返回了
final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
if (callbacks == null || callbacks.isEmpty()) {
// No callbacks to execute, return early.
return;
}
final IBinder token = transaction.getActivityToken();
ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
final ActivityLifecycleItem finalStateRequest =
transaction.getLifecycleStateRequest();
final int finalState = finalStateRequest != null ?
finalStateRequest.getTargetState() : UNDEFINED;
final int lastCallbackRequestingState =
lastCallbackRequestingState(transaction);
final int size = callbacks.size();
// 遍历 callbacks 数组
for (int i = 0; i < size; ++i) {
// 从 callbacks 数组中取出 item
final ClientTransactionItem item = callbacks.get(i);
......
// 执行 item 的 execute 方法，这里的 item 就是 launchActivityItem
item.execute(mTransactionHandler, token, mPendingActions);
item.postExecute(mTransactionHandler, token, mPendingActions);
......
}
}
首先从系统进程传来的 ClientTransaction 中得到 mActivityCallbacks 列表。这个在前面 addcallback 的时候已经看了，里面保存了一个 LaunchActivityItem。接着通过遍历取出这个 LaunchActivityItem，接着调用了它的 execute() 方法，传入的第一个参数是持有的 ActivityThread 对象，第二个参数 token 是从系统进程传来的 activityToken。
2.8 LaunchActivityItem.execute
LaunchActivityItem.java
public void execute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
// 创建 ActivityClientRecord
ActivityClientRecord r =
new ActivityClientRecord(token, mIntent, mIdent, ......);
client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
调用了 ActivityThread 类的 handleLaunchActivity() 方法。这里注意把 ActivityClientRecord 作为参数传递到了 ActivityThread 中。
2.9 ActivityThread.handleLaunchActivity
ActivityThread.java
public Activity handleLaunchActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, Intent customIntent) {
......
final Activity a = performLaunchActivity(r, customIntent);
if (a != null) {
r.createdConfig = new Configuration(mConfiguration);
reportSizeConfigurations(r);
if (!r.activity.mFinished && pendingActions != null) {
pendingActions.setOldState(r.state);
pendingActions.setRestoreInstanceState(true);
pendingActions.setCallOnPostCreate(true);
}
} else {
......
}
return a;
}
2.10 ActivityThread.performLaunchActivity
private Activity performLaunchActivity(ActivityClientRecord r,
Intent customIntent) {
......
ContextImpl appContext = createBaseContextForActivity(r);
Activity activity = null;
try {
java.lang.ClassLoader cl = appContext.getClassLoader();
// 创建我们自己的 Activity 实例
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
StrictMode.incrementExpectedActivityCount(activity.getClass());
r.intent.setExtrasClassLoader(cl);
r.intent.prepareToEnterProcess();
if (r.state != null) {
r.state.setClassLoader(cl);
}
} catch (Exception e) {
......
}
try {
// 尝试创建 Application，其实前面已经创建过了。
Application app =
r.packageInfo.makeApplication(false, mInstrumentation);
......
if (activity != null) {
CharSequence title =
r.activityInfo.loadLabel(appContext.getPackageManager());
Configuration config = new Configuration(mCompatConfiguration);
if (r.overrideConfig != null) {
config.updateFrom(r.overrideConfig);
}
if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "
+ r.activityInfo.name + " with config " + config);
Window window = null;
if (r.mPendingRemoveWindow != null && r.mPreserveWindow) {
window = r.mPendingRemoveWindow;
r.mPendingRemoveWindow = null;
r.mPendingRemoveWindowManager = null;
}
appContext.setOuterContext(activity);
// 会在这个方法中创建 Activity 的 PhoneWindow，并绑定对应的 WindowManager。
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,
r.assistToken);
......
int theme = r.activityInfo.getThemeResource();
if (theme != 0) {
activity.setTheme(theme);
}
activity.mCalled = false;
// 执行我们新 Activity 的 OnCreate 生命周期。
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(
activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
......
}
r.setState(ON_CREATE);
......
} catch (SuperNotCalledException e) {
throw e;
} catch (Exception e) {
......
}
return activity;
}
这个方法做了很多事，主要分4个部分来看。
2.10.1 创建Activity实例
首先是 Activity 实例的创建，这里的 Activity 指的是我们要启动的新的 XXXActivity。调用了 Instrumentation 类的 newActivity() 方法。
Instrumentation.java
public Activity newActivity(ClassLoader cl, String className,
Intent intent)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException {
String pkg = intent != null && intent.getComponent() != null
? intent.getComponent().getPackageName() : null;
return getFactory(pkg).instantiateActivity(cl, className, intent);
}
getFactory(pkg) 返回的是 AppComponentFactory 类型的对象，调用了 AppComponentFactory 的 instantiateActivity() 方法。
AppComponentFactory.java
public @NonNull Activity instantiateActivity(@NonNull ClassLoader cl,
@NonNull String className, @Nullable Intent intent)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException {
return (Activity) cl.loadClass(className).newInstance();
}
看到这里，通过反射调用了我们要启动 Activity 的构造方法，然后返回了我们 Activity 的实例。
2.10.2 创建Application
接下来会尝试创建 Application，r.packageInfo 返回的是 LoadedApk 对象，调用了 LoadedApk 的 makeApplication() 方法。
LoadedApk.java
public Application makeApplication(boolean forceDefaultAppClass,
Instrumentation instrumentation) {
if (mApplication != null) {
return mApplication;
}
......
return app;
}
这个方法很长，主要是创建应用的 Application 实例。但是因为之前在 bindApplication 时已经创建了 Application，所以这里在一开始 if 的时候直接返回了。
2.10.3 Activity.attach
回到 performLaunchActivity() 方法，接着调用了 Activity 类的 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, String referrer, ......) {
attachBaseContext(context);
mFragments.attachHost(null /*parent*/);
// 创建 PhoneWindow
mWindow = new PhoneWindow(this, window, activityConfigCallback);
mWindow.setWindowControllerCallback(this);
mWindow.setCallback(this);
mWindow.setOnWindowDismissedCallback(this);
mWindow.getLayoutInflater().setPrivateFactory(this);
if (info.softInputMode !=
WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) {
mWindow.setSoftInputMode(info.softInputMode);
}
if (info.uiOptions != 0) {
mWindow.setUiOptions(info.uiOptions);
}
mUiThread = Thread.currentThread();
...
// 绑定 window 和 windowManger
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();
...
}
这个方法主要做的事情就是创建了 Activity 的 window，是一个 PhoneWiondow，在 Activity 界面的创建和显示流程的时候还会看到这里。并且将当前线程设置成了主线程。我们在这个 fork 出来的新进程中还没有创建其他线程，这个 Activity 也是该 App 启动的第一个 Activity，所以这个 Activity 就是在主线程中运行的。
2.10.4 Instrumentation.callActivityOnCreate
Instrumentation.java
public void callActivityOnCreate(Activity activity, Bundle icicle) {
prePerformCreate(activity);
activity.performCreate(icicle);
postPerformCreate(activity);
}
回到 performLaunchActivity 方法，调用了 Instrumentation 的 callActivityOnCreate() 方法。
2.11 Activity.performCreate
Activity.java
final void performCreate(Bundle icicle) {
performCreate(icicle, null);
}
final void performCreate(Bundle icicle, PersistableBundle persistentState) {
dispatchActivityPreCreated(icicle);
mCanEnterPictureInPicture = true;
restoreHasCurrentPermissionRequest(icicle);
if (persistentState != null) {diao
onCreate(icicle, persistentState);// 调用到了我们常见的 onCreate
} else {
onCreate(icicle);
}
......
}
在这个方法里调用了 Activity 的 onCreate 方法。这个 Activity 是我们前面通过反射实例化的新的 Activity，所以这也就调用了新 Activity 的 onCreate 方法。现在通过跟进 TransactionExecutor 的 executeCallbacks 方法已经执行了生命周期中的 onCreate 方法。
总结一下这一部分，从新进程执行的第一个方法：ActivityThread 的 main() 出发，通过 LaunchActivityItem 的 execute() 方法一步一步完成了新 Activity 生命周期的 onCreate 阶段，并在这个过程中，完成了 PhoneWindow 的创建，主线程Handler 的创建等几个重要的流程。接下来，onCreate 后该到 onStart 和 onResume 阶段了。
三 onStart阶段
首先说明下，onStart 的调用是在执行 ResumeActivityItem 的过程中实现的。
回到 TransactionExecutor 的 execute() 方法中，接着顺序执行了 executeLifecycleState 方法，这个流程和 pause 是一样的，最终会执行到 ResumeActivityItem 的 execute() 方法。不过要重点关注的是在执行ResumeActivityItem 的 execute() 方法之前，调用到了 cycleToPath 方法，而 onStart 函数的执行就是在这里触发的，（这一部分也在文章 深入理解 ClientLifecycleManager 机制 中有详细介绍）我们来看代码：
3.1 TransactionExecutor.executeLifecycleState
private void executeLifecycleState(ClientTransaction transaction) {
//获取ActivityLifecycleItem，我们知道这里获取的是我们之前添加的ResumeActivityItem
final ActivityLifecycleItem lifecycleItem =
transaction.getLifecycleStateRequest();
if (lifecycleItem == null) {
// No lifecycle request, return early.
return;
}
final IBinder token = transaction.getActivityToken();
final ActivityClientRecord r =
mTransactionHandler.getActivityClient(token);
if (DEBUG_RESOLVER) {
Slog.d(TAG, tId(transaction) + "Resolving lifecycle state: "
+ lifecycleItem + " for activity: "
+ getShortActivityName(token, mTransactionHandler));
}
if (r == null) {
// Ignore requests for non-existent client records for now.
return;
}
// Cycle to the state right before the final requested state.
// 关键点, ResumeActivityItem 的 getTargetState 是 ON_RESUME
cycleToPath(r, lifecycleItem.getTargetState(), true , transaction);
// Execute the final transition with proper parameters.
//执行 ResumeActivityItem 的 execute
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}
cycleToPath 函数非常重要，其中的 lifecycleItem.getTargetState() 返回值是 ON_RESUME。
3.2 TransactionExecutor.cycleToPath
TransactionExecutor.java
private void cycleToPath(ActivityClientRecord r, int finish,
boolean excludeLastState, ClientTransaction transaction) {
final int start = r.getLifecycleState();// 这里的 start 是 ON_CREATE
if (DEBUG_RESOLVER) {
......
}
// 这里的 start 是 ON_CREATE, finish 是 ON_RESUME
// 通过 mHelper 调用 getLifecyclePath 返回的 path 是 ON_START(以下3.2.1有分析)
// 这里是 Activity 执行 onStart 函数的关键所在
final IntArray path = mHelper.getLifecyclePath(
start, finish, excludeLastState);
// 执行 path 中的相关的生命周期函数
performLifecycleSequence(r, path, transaction);
}
private void performLifecycleSequence(ActivityClientRecord r,
IntArray path, ClientTransaction transaction) {
// 通过 mHelper 调用 getLifecyclePath 返回的 path 是 ON_START
final int size = path.size();
for (int i = 0, state; i < size; i++) {
state = path.get(i);
if (DEBUG_RESOLVER) {
......
}
switch (state) {
case ON_CREATE:
mTransactionHandler.handleLaunchActivity(
r, mPendingActions, null);
break;
case ON_START:
mTransactionHandler.handleStartActivity(
r, mPendingActions);
break;
case ON_RESUME:
mTransactionHandler.handleResumeActivity(
r.token, false, r.isForward,
"LIFECYCLER_RESUME_ACTIVITY");
break;
case ON_PAUSE:
mTransactionHandler.handlePauseActivity(r.token,
false, false, 0, mPendingActions,
"LIFECYCLER_PAUSE_ACTIVITY");
break;
case ON_STOP:
mTransactionHandler.handleStopActivity(r.token,
false, 0, mPendingActions, false,
"LIFECYCLER_STOP_ACTIVITY");
break;
case ON_DESTROY:
mTransactionHandler.handleDestroyActivity(r.token,
false, 0, false,
"performLifecycleSequence. cycling to:" +
path.get(size - 1));
break;
case ON_RESTART:
mTransactionHandler.performRestartActivity(
r.token, false);
break;
default:
throw new IllegalArgumentException(
"Unexpected lifecycle state: " + state);
}
}
}
3.2.1 TransactionExecutorHelper.getLifecyclePath
TransactionExecutorHelper.java
// excludeLastState 为 true, start 为 ON_CREATE, finish 为 ON_RESUME
public IntArray getLifecyclePath(int start, int finish,
boolean excludeLastState) {
if (start == UNDEFINED || finish == UNDEFINED) {
throw new IllegalArgumentException("......");
}
if (start == ON_RESTART || finish == ON_RESTART) {
throw new IllegalArgumentException(
"......");
}
if (finish == PRE_ON_CREATE && start != finish) {
throw new IllegalArgumentException("......");
}
mLifecycleSequence.clear();
if (finish >= start) {// 走到此分支
// just go there
for (int i = start + 1; i <= finish; i++) {
//把 ON_START 和 ON_RESUME 添加到 mLifecycleSequence 中
mLifecycleSequence.add(i);
}
} else { // finish < start, can't just cycle down
......
}
// Remove last transition in case we want to perform it
// with some specific params.
// 关键点:因为 excludeLastState 为 true, 所以删除掉 ON_RESUME 状态
// 只保留了 ON_START
if (excludeLastState && mLifecycleSequence.size() != 0) {
mLifecycleSequence.remove(mLifecycleSequence.size() - 1);
}
return mLifecycleSequence;
}
在 performLifecycleSequence 方法中，因为 state 为 ON_START 所以执行了 mTransactionHandler.handleStartActivity，由之前的分析，我们已经能够猜到这里最终会执行 Activity 的 onStart 函数。我们接下来来分析与验证。
3.3 ActivityThread.handleStartActivity
ActivityThread.java
public void handleStartActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions) {
final Activity activity = r.activity;
if (r.activity == null) {
// TODO(lifecycler): What do we do in this case?
return;
}
......
// Start
activity.performStart("handleStartActivity");
r.setState(ON_START);
......
}
3.4 Activity.performStart
final void performStart(String reason) {
......
mInstrumentation.callActivityOnStart(this);
writeEventLog(LOG_AM_ON_START_CALLED, reason);
......
GraphicsEnvironment.getInstance().showAngleInUseDialogBox(this);
mActivityTransitionState.enterReady(this);
dispatchActivityPostStarted();
}
3.5 Instrumentation.callActivityOnStart
Instrumentation.java
public void callActivityOnStart(Activity activity) {
activity.onStart();
}
可以看到，最终调用了 Activity 的 onStart 方法。至此 onStart 阶段执行完毕。
四 onResume阶段
继续回到 TransactionExecutor 的 executeLifecycleState() 方法中：
4.1 TransactionExecutor.executeLifecycleState
private void executeLifecycleState(ClientTransaction transaction) {
//获取ActivityLifecycleItem，我们知道这里获取的是我们之前添加的ResumeActivityItem
final ActivityLifecycleItem lifecycleItem =
transaction.getLifecycleStateRequest();
if (lifecycleItem == null) {
// No lifecycle request, return early.
return;
}
final IBinder token = transaction.getActivityToken();
final ActivityClientRecord r =
mTransactionHandler.getActivityClient(token);
if (DEBUG_RESOLVER) {
Slog.d(TAG, tId(transaction) + "Resolving lifecycle state: "
+ lifecycleItem + " for activity: "
+ getShortActivityName(token, mTransactionHandler));
}
if (r == null) {
// Ignore requests for non-existent client records for now.
return;
}
// Cycle to the state right before the final requested state.
// 关键点, ResumeActivityItem 的 getTargetState 是 ON_RESUME
cycleToPath(r, lifecycleItem.getTargetState(), true , transaction);
// Execute the final transition with proper parameters.
//执行 ResumeActivityItem 的 execute
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}
根据之前的分析我们知道在 executeLifecycleState 方法中，通过 cycleToPath 函数执行了 Activity 的 onStart 方法，接下来就是执行 ResumeActivityItem 的 execute() 方法了。我们来看代码：
4.2 ResumeActivityItem.execute
ResumeActivityItem.java
public void execute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityResume");
client.handleResumeActivity(token, true /* finalStateRequest */, mIsForward,
"RESUME_ACTIVITY");
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
与 onPause、onCreate 类似，实际调用了 ActivityThread 的 handleResumeActivity() 方法。
4.3 ActivityThread.handleResumeActivity
ActivityThread.java
public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward,
String reason) {
unscheduleGcIdler();
mSomeActivitiesChanged = true;
// TODO Push resumeArgs into the activity for consideration
final ActivityClientRecord r = performResumeActivity(token, finalStateRequest, reason);
if (r == null) {
return;
}
......
}
方法一开始调用 performResumeActivity 方法，这也是我们本次要关注的方法，下面其余的部分主要是进行了界面的显示逻辑，这也是为什么生命周期在执行到 onCreate 是不会显示界面，只有 onResume 执行完才能看到界面的原因。
4.4 ActivityThread.performResumeActivity
ActivityThread.java
public ActivityClientRecord performResumeActivity(IBinder token,
boolean finalStateRequest, String reason) {
......
try {
r.activity.onStateNotSaved();
r.activity.mFragments.noteStateNotSaved();
checkAndBlockForNetworkAccess();
......
r.activity.performResume(r.startsNotResumed, reason);
r.state = null;
r.persistentState = null;
r.setState(ON_RESUME);
reportTopResumedActivityChanged(
r, r.isTopResumedActivity, "topWhenResuming");
} catch (Exception e) {
....
}
}
return r;
}
调用了 Activity 类的 performResume() 方法。
4.4 Activity.performResume
Activity.java
final void performResume(boolean followedByPause, String reason) {
dispatchActivityPreResumed();
performRestart(true /* start */, reason);
mFragments.execPendingActions();
mLastNonConfigurationInstances = null;
......
mCalled = false;
// mResumed is set by the instrumentation
mInstrumentation.callActivityOnResume(this);
......
}
4.5 Instrumentation.callActivityOnResume
Instrumentation.java
public void callActivityOnResume(Activity activity) {
activity.mResumed = true;
activity.onResume();
if (mActivityMonitors != null) {
synchronized (mSync) {
final int N = mActivityMonitors.size();
for (int i=0; i<N; i++) {
final ActivityMonitor am = mActivityMonitors.get(i);
am.match(activity, activity, activity.getIntent());
}
}
}
}
最终调用了我们新的 Activity 的 onResume 方法。
至此，在桌面单击一个应用图标，从 Launcher 应用 Activity 执行 onPause，到新应用进程的创建，新应用 Application 的创建，新应用中的 Activity 顺序执行 onCreate、onStart、onResume 生命周期的流程就走了一遍了。调用判断条件很多，我们只是根据一般逻辑走了一遍，如果需要详细了解，则还要对代码细节做深入分析。
五 总结
本文从 startActivity 开始，详细分析了 Activity 的启动过程，以桌面点击应用图标为例大致流程如下。
- 调用 startActivityForResult，使用 Instrumentation 调用 execStartActivity，其中传入 Context、Intent、mApplicationThread 等引用
- execStartActivity 方法中通过 Binder 机制调用 ActivityTaskManagerService 的 startActivity 方法
- ActivityTaskManagerService.startActivity 方法调用 startActivityAsUser，传入 userId 等，经过重载的 startActivityAsUser，使用 getActivityStartController.obtaionStarter 创建了 ActivityStarter 类的实例，并执行其 execute 方法
- 进入 ActivityStarter.execute，Request.mayWait 为 true (在上一步创建 ActivityStarter 实例时调用 setMayWait 设置)，执行 startActivityMayWait 方法
- 经过多个 startActivity 重载方法的调用，触发 startActivityUncheck，在方法中执行一个重要方法：RootActivityContainer.resumeFocusedStacksTopActivities，接着调用 ActivitStack 的 resumeFocusedStackTopActivityLocked 方法
- 接着调用 resumeTopActivityInnerLocked，这个方法主要做两件事，首先获取先前焦点 Stack 的 ResumeActivity，并对其执行 startPausingLocked 方法；然后根据需要被启动的 Activity 所在进程是否启动，来决定是直接 Resume 还是触发 ActivityStackSupervisor.startSpecificActivityLocked
- 其中 startPausingLocked 方法会通过 ATMS 的 LifecycleManager 执行 scheduleTransaction 方法，进而执行 PauseActivityItem.execute，执行 ActivityThread 的 handlePauseActivity、performPauseActivity，并且在此执行被 Pause 的 Activity 的 onSaveInstanceState 和 onPause
- startSpecificActivityLocked 根据目标进程是否启动分别执行 realStartActivityLocked 方法或启动进程方法
- realStartActivityLocked 则会执行 scheduleTransaction 方法，此时执行的是 LaunchActivityItem、ResumeActivityItem 的 preExecute、execute、postExecute 方法
- LaunchActivityItem 的 execute 方法触发了 handleLaunchActivity、performLaunchActivity，其中 performLaunchActivity 中做了创建 ContextImpl、使用 Instrumentation.newActivity 创建 Activity 实例、调用 Activity.attach (此方法中创建了 PhoneWindow)、使用 Instrumentation 触发 Activity 的 onCreate 方法
- ResumeActivityItem 的 execute 方法触发了 handleResumeActivity、performResumeActivity，最后触发 Activity 的 performResume 和 onResume
- 此时，前一个 Activity 执行 onSaveInstanceState、onPause了，新的 Activity 分别执行 onCreate、onStart、onResume 了。
到此应用正式启动，开始进入应用的生命周期，执行完 onCreate，onStart，onResume 方法，makeVisible，UI 渲染结束后就可以看到 App 的主界面了。