一、概述
在 Android 中,
Activity
是四大组件之一,那么它是怎么被启动起来的呢?
本文来讲解一下Activity
的启动流程,其它几个组件也类似。
涉及到的知识点:
- 《源码分析 — Binder机制(一)(进程间通信)》
- 《源码分析 — Binder机制(二)之IActivityManager》
- 《源码分析 — ActivityThread(一)之main()的调用 (Android应用进程的孵化)》
- 《源码分析 — ActivityThread(二)之ActivityThread的浅析》
- 《源码分析 — PackageManagerService(二)之resolveIntent()》
主要分为几个阶段进行分析:
- 从启动应用到获取到
ActivityManagerProxy
的过程; - 从
ActivityManagerProxy
到创建应用进程的过程; - 从应用进程创建完成之后到启动
Activity
的过程; - 从
Activity
被启动到页面显示完成的过程; Activity
的Pause
的过程;
二、从启动应用到获取到 ActivityManagerProxy
的过程
2.1 时序图
2.2 源码分析
// Activity.class
public void startActivityForResult(Intent intent, int requestCode, @Nullable Bundle options) {
// 调用 Instrumentation.execStartActivity() 方法
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
// ...
}
/*
* Instrumentation.class
*
* contextThread 是 ApplicationThread实例
*/
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
// contextThread 是 ApplicationThread实例
IApplicationThread whoThread = (IApplicationThread) contextThread;
// ...
try {
// 获取 ActivityManagerProxy 实例,然后调用 startActivity() 方法;
int result = ActivityManagerNative.getDefault()
.startActivity(whoThread, who.getBasePackageName(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
token, target != null ? target.mEmbeddedID : null,
requestCode, 0, null, options);
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
2.3 小结
- 启动
startActivity()
后,经过一系列跳转,最终会调用到ActivityManagerProxy.startActivity()
方法; 而
ActivityManagerProxy.startActivity()
方法最终会调用到ActivityManagerService.startActivity()
方法;关于如何跳转到
ActivityManagerService.startActivity()
,请参考文章: 《源码分析 — Binder机制(二)之IActivityManager》
三、从ActivityManagerProxy
到创建应用进程的过程
3.1 时序图
3.2 源码分析
/*
* ActivityManagerService.class
*
* 注意:前面我们传入的参数caller是ApplicationThread对象;
* 在AMS.onTransact()方法中,caller被转换成ApplicationThreadProxy对象;
*/
public final int startActivity(IApplicationThread caller, ...) {
// 1.执行
return startActivityAsUser(caller, ...);
}
// ActivityManagerService.class
public final int startActivityAsUser(IApplicationThread caller, ...) {
// ...
// 2.执行
return mStackSupervisor.startActivityMayWait(caller, ...);
}
// ActivityStackSupervisor.class
final int startActivityMayWait(IApplicationThread caller, ...) {
// ...
// 这个方法时根据给定的Intent去解析对应的组件信息,具体请参考[《源码分析 — PackageManagerService(二)之resolveIntent()》](https://blog.csdn.net/love667767/article/details/79585080)
ActivityInfo aInfo = resolveActivity(intent, resolvedType,
startFlags, profilerInfo, userId);
synchronized (mService) {
// ...
// 3.执行
int res = startActivityLocked(caller, intent, ...);
// ...
return res;
}
}
// ActivityStackSupervisor.class
final int startActivityLocked(IApplicationThread caller, Intent intent, ...) {
// 将信息都存入到 ActivityRecord 对象中;
ActivityRecord r = new ActivityRecord(mService, callerApp, callingUid, callingPackage,
intent, resolvedType, aInfo, mService.mConfiguration, resultRecord, resultWho,
requestCode, componentSpecified, voiceSession != null, this, container, options);
// 4.执行
err = startActivityUncheckedLocked(r, sourceRecord, voiceSession, voiceInteractor,
startFlags, true, options, inTask);
return err;
}
// ActivityStackSupervisor.class
final int startActivityUncheckedLocked(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor, int startFlags,
boolean doResume, Bundle options, TaskRecord inTask) {
// 5.执行; ActivityStack.startActivityLocked()方法
targetStack.startActivityLocked(r, newTask, doResume, keepCurTransition, options);
// ...
return ActivityManager.START_SUCCESS;
}
// ActivityStack.class
final void startActivityLocked(ActivityRecord r, boolean newTask,
boolean doResume, boolean keepCurTransition, Bundle options) {
// ...
if (doResume) {
// 6.执行; ActivityStackSupervisor.resumeTopActivitiesLocked();
mStackSupervisor.resumeTopActivitiesLocked(this, r, options);
}
}
// ActivityStackSupervisor.class
boolean resumeTopActivitiesLocked(ActivityStack targetStack, ActivityRecord target,
Bundle targetOptions) {
// 这里判断被启动的 Activity 是否处于栈顶,这里是首次启动显然不处于栈顶;
if (isFrontStack(targetStack)) {
result = targetStack.resumeTopActivityLocked(target, targetOptions);
}
for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
final ActivityStack stack = stacks.get(stackNdx);
if (stack == targetStack) {
// Already started above.
continue;
}
if (isFrontStack(stack)) {
// 7.执行
stack.resumeTopActivityLocked(null);
}
}
}
return result;
}
// ActivityStack.class
final boolean resumeTopActivityLocked(ActivityRecord prev) {
// 8.执行
return resumeTopActivityLocked(prev, null);
}
// ActivityStack.class
final boolean resumeTopActivityLocked(ActivityRecord prev, Bundle options) {
// ...
// 9.执行
result = resumeTopActivityInnerLocked(prev, options);
return result;
}
// ActivityStack.class
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, Bundle options) {
// 当前应用的进程还没启动,所以 next.app == null
final ActivityRecord next = topRunningActivityLocked(null);
// ...省略大段代码...
// We need to start pausing the current activity so the top one can be resumed...
// 10.执行; 需要pause当前的Activity状态(这部分请参考本文第6部分:Activity的Pause过程)
boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, true, dontWaitForPause);
if (mResumedActivity != null) {
pausing |= startPausingLocked(userLeaving, false, true, dontWaitForPause);
}
if (next.app != null && next.app.thread != null) {
// ...
} else {
//...
// 11.执行
mStackSupervisor.startSpecificActivityLocked(next, true, true);
}
return true;
}
// ActivityStackSupervisor.class
void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig) {
// Is this activity's application already running?
// 这个被启动的Activity所在的应用进程是否已经启动(首次启动显然app==null)
ProcessRecord app = mService.getProcessRecordLocked(r.processName,
r.info.applicationInfo.uid, true);
if (app != null && app.thread != null) {
// 12.执行(非首次启动); 执行realStartActivityLocked()
realStartActivityLocked(r, app, andResume, checkConfig);
return;
}
// 12.执行(首次启动);
mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
"activity", r.intent.getComponent(), false, false, true);
}
由上面分析可知,最后会根据应用进程是否已经开始,来执行不同的操作;
- 若应用进程未创建,则调用
AMS.startProcessLocked()
方法先创建应用进程,然后再创建Activity; - 若应用进程已经创建,则调用
realStartActivityLocked()
方法创建Activity;
下面分析创建应用进程的过程:
// ActivityManagerService.class
final ProcessRecord startProcessLocked(String processName, ApplicationInfo info, ...) {
// 12.执行
return startProcessLocked(processName, info, knownToBeDead, intentFlags, hostingType,
hostingName, allowWhileBooting, isolated, 0 /* isolatedUid */, keepIfLarge,
null /* ABI override */, null /* entryPoint */, null /* entryPointArgs */,
null /* crashHandler */);
}
// ActivityManagerService.class
final ProcessRecord startProcessLocked(String processName, ApplicationInfo info, ...) {
// ...
// 13.执行
startProcessLocked(app, hostingType, hostingNameStr,
abiOverride, entryPoint, entryPointArgs);
return (app.pid != 0) ? app : null;
}
private final void startProcessLocked(ProcessRecord app, String hostingType,
String hostingNameStr, String abiOverride, String entryPoint, String[] entryPointArgs) {
// ...
// 14.执行(这里创建一个应用进程)
Process.ProcessStartResult startResult = Process.start(entryPoint,
app.processName, uid, uid, gids, debugFlags, mountExternal,
app.info.targetSdkVersion, app.info.seinfo, requiredAbi, instructionSet,
app.info.dataDir, entryPointArgs);
// ...
synchronized (mPidsSelfLocked) {
// 将应用进程的pid保存在 mPidsSelfLocked 中;
this.mPidsSelfLocked.put(startResult.pid, app);
// ...
}
}
由上面代码片段分析可知,其内部调用了 Process.start()
方法,最终会执行 ActivityThread.main()
方法;
关于
Process.start()
如何调起ActivityThread.main()
方法,请参考:
《源码分析 — ActivityThread(一)之main()的调用 (Android应用进程的孵化)》
四、从应用进程创建完成之后到启动 Activity
的过程;
4.1 时序图
4.2 源码分析
// ActivityThread.class
public static void main(String[] args) {
// ...
ActivityThread thread = new ActivityThread();
// 1.执行
thread.attach(false);
//...
}
// ActivityThread.class
private void attach(boolean system) {
if (!system) { // system = false
// ...
final IActivityManager mgr = ActivityManagerNative.getDefault();
// 2.执行; mAppThread = ApplicationThread()
mgr.attachApplication(mAppThread);
}
// ...
}
/*
* ActivityManagerService.class
*
* 由[《源码分析 — Binder机制(二)之IActivityManager》](https://blog.csdn.net/love667767/article/details/79653077)可知,
* 调用ActivityManagerProxy.attachApplication(),最终会调用到
* ActivityManagerService.attachApplication()方法;
*/
public final void attachApplication(IApplicationThread thread) {
synchronized (this) {
int callingPid = Binder.getCallingPid();
final long origId = Binder.clearCallingIdentity();
// 3.执行
attachApplicationLocked(thread, callingPid);
Binder.restoreCallingIdentity(origId);
}
}
// ActivityManagerService.class
private final boolean attachApplicationLocked(IApplicationThread thread, int pid) {
// ...
ProcessRecord app;
// 4.执行; 这里将参数thread赋值给ProcessRecord.thread中;
app.makeActive(thread, mProcessStats);
// ...
try {
// 5.执行; 这里最终执行到了ApplicationThread.bindApplication(),原理和AMS类似;
thread.bindApplication(processName, appInfo, providers, app.instrumentationClass,
profilerInfo, app.instrumentationArguments, app.instrumentationWatcher,
app.instrumentationUiAutomationConnection, testMode, enableOpenGlTrace,
isRestrictedBackupMode || !normalMode, app.persistent,
new Configuration(mConfiguration), app.compat,
getCommonServicesLocked(app.isolated),
mCoreSettingsObserver.getCoreSettingsLocked());
} catch (Exception e) {
// ...
return false;
}
// ...
// 注意:See if the top visible activity is waiting to run in this process...
if (normalMode) {
// 6.执行; (执行完第 5 步后,执行这里启动App首页)
if (mStackSupervisor.attachApplicationLocked(app)) {
didSomething = true;
}
}
// ...
return true;
}
// ApplicationThread.class
public final void bindApplication(String processName, ApplicationInfo appInfo, ...) {
// ...
AppBindData data = new AppBindData();
data.processName = processName;
data.appInfo = appInfo;
data.providers = providers;
// 7.执行; 经H.handleMessage()转发后,最终调用ActivityThread.handleBindApplication()方法;
sendMessage(H.BIND_APPLICATION, data);
}
// ActivityThread.class
private void handleBindApplication(AppBindData data) {
// ...
if (data.instrumentationName != null) {
// ...
ClassLoader cl = instrContext.getClassLoader();
mInstrumentation = (Instrumentation)
cl.loadClass(data.instrumentationName.getClassName()).newInstance();
// ...
} else {
// 8.执行; (创建Instrumentation对象)
mInstrumentation = new Instrumentation();
}
try {
// 9.执行(包含第11步); 调用LoadedApk.makeApplication()来创建Application实例
Application app = data.info.makeApplication(data.restrictedBackupMode, null);
mInitialApplication = app;
// 10.执行; 调用Application.onCreate()方法
mInstrumentation.callApplicationOnCreate(app);
} finally {
StrictMode.setThreadPolicy(savedPolicy);
}
}
/*
* LoadedApk.class
* 参数:instrumentation = null
*/
public Application makeApplication(boolean forceDefaultAppClass,
Instrumentation instrumentation) {
// 保证Application单例
if (mApplication != null) {
return mApplication;
}
Application app = null;
try {
// ...
// 11.执行; 通过Instrumentation.newApplication()来创建Application实例;
app = mActivityThread.mInstrumentation.newApplication(
cl, appClass, appContext);
appContext.setOuterContext(app);
} catch (Exception e) {
// ...
}
mApplication = app;
//这里不会执行Applications.onCreate()方法,因为参数instrumentation == null
if (instrumentation != null) {
instrumentation.callApplicationOnCreate(app);
}
// ...
return app;
}
到此,就完成了Application
的绑定过程;并调用了 Application.onCreate()
方法;
下面开始启动在应用进程启动时被悬置的 Activity
;
// ActivityStackSupervisor.class
boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
// ...
for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
// ...
// 拿到Activity栈最上层的Activity信息;
ActivityRecord hr = stack.topRunningActivityLocked(null);
if (hr != null) {
if (hr.app == null && app.uid == hr.info.applicationInfo.uid
&& processName.equals(hr.processName)) {
// 12.执行; 启动应用的第一个页面;
if (realStartActivityLocked(hr, app, true, true)) {
didSomething = true;
}
}
}
}
}
return didSomething;
}
/*
* ActivityStackSupervisor.class
* 如果应用不是第一次被打开,则会跳过前面的应用进程创建过程和 Application 绑定过程,而直接调用该方法;
* 该方法直接调用了IApplicationThread.scheduleLaunchActivity()方法;
*/
final boolean realStartActivityLocked(ActivityRecord r,
ProcessRecord app, boolean andResume, boolean checkConfig)
throws RemoteException {
// ...
try {
// ...
// 13.执行; 最终调用到ApplicationThread.scheduleLaunchActivity()来启动Activity;
app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration),
new Configuration(stack.mOverrideConfig), r.compat, r.launchedFromPackage,
task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results,
newIntents, !andResume, mService.isNextTransitionForward(), profilerInfo);
// ...
} catch (RemoteException e) {
// ...
}
return true;
}
五、从 Activity
被启动到页面显示完成的过程
5.1 时序图
5.2 源码分析
// ActivityThread.class
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
// ...
// 1.执行
Activity a = performLaunchActivity(r, customIntent);
if (a != null) {
r.createdConfig = new Configuration(mConfiguration);
Bundle oldState = r.state;
// 2.执行
handleResumeActivity(r.token, false, r.isForward,
!r.activity.mFinished && !r.startsNotResumed);
// ...
}
}
// ActivityThread.class
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
// ...
Activity activity = null;
try {
java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
// 3.通过Instrumentation.newActivity()方法创建Activity对象;
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
// ...
} catch (Exception e) {
}
try {
// 在BindApplication时,Application对象已经被创建了,所以这里并不会创建新的Application对象;
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
// ...
if (activity != null) {
// ...
// 4.执行; 调用Activity.attach()方法
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);
// ...
if (r.isPersistable()) {
// 5.执行(包含第 7,8 步); 调用Activity.OnCreate()方法
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
// ...
if (!r.activity.mFinished) {//当前Activity没有被finish
// 6.执行(包含第 9,10 步); 调用Activity.onStart()方法
activity.performStart();
r.stopped = false;
}
if (!r.activity.mFinished) {
if (r.isPersistable()) {
// 调用Activity.onRestoreInstanceState()方法
mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
r.persistentState);
} else if (r.state != null) {
mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
}
}
if (!r.activity.mFinished) {
activity.mCalled = false;
if (r.isPersistable()) {
// 调用Activity.onPostCreate()方法
mInstrumentation.callActivityOnPostCreate(activity, r.state,
r.persistentState);
} else {
mInstrumentation.callActivityOnPostCreate(activity, r.state);
}
}
}
r.paused = true;
// 将创建的Activity以token作为Key存入mActivities中;
mActivities.put(r.token, r);
} catch (Exception e) {
}
return activity;
}
// Instrumentation.class
public void callActivityOnCreate(Activity activity, Bundle icicle,
PersistableBundle persistentState) {
prePerformCreate(activity);
// 7.执行
activity.performCreate(icicle, persistentState);
postPerformCreate(activity);
}
// Activity.class
final void performCreate(Bundle icicle) {
// 8.执行
onCreate(icicle);
mActivityTransitionState.readState(icicle);
performCreateCommon();
}
// Activity.class
final void performStart() {
mActivityTransitionState.setEnterActivityOptions(this, getActivityOptions());
// ...
// 9.执行
mInstrumentation.callActivityOnStart(this);
// ...
}
// Instrumentation.class
public void callActivityOnStart(Activity activity) {
// 10.执行
activity.onStart();
}
以下是 Activity
的 Resume
过程:
- 先调用
Activity.onResume()
; - 然后通知
AMS
,当前这个Activity
已经处于Resume
状态;
// ActivityThread.class
final void handleResumeActivity(IBinder token,
boolean clearHide, boolean isForward, boolean reallyResume) {
// 11.执行
ActivityClientRecord r = performResumeActivity(token, clearHide);
if (r != null) {
// ...
if (reallyResume) {
// 当Activity处于Resume状态时,通知AMS;
ActivityManagerNative.getDefault().activityResumed(token);
}
} else {
ActivityManagerNative.getDefault()
.finishActivity(token, Activity.RESULT_CANCELED, null, false);
}
}
// ActivityThread.class
public final ActivityClientRecord performResumeActivity(IBinder token,
boolean clearHide) {
// token是Activity的唯一标识,mActivities存储了被启动的Activity
ActivityClientRecord r = mActivities.get(token);
if (r != null && !r.activity.mFinished) {
try {
// ...
// 12.执行
r.activity.performResume();
} catch (Exception e) {
}
}
return r;
}
// Activity.class
final void performResume() {
performRestart();
// mResumed is set by the instrumentation
// 13.执行
mInstrumentation.callActivityOnResume(this);
// ...
onPostResume();
}
// Instrumentation.class
public void callActivityOnResume(Activity activity) {
activity.mResumed = true;
// 14.执行
activity.onResume();
// ...
}
六、Activity
的 Pause
的过程
6.1 时序图
schedulePauseActivity()
时序图和 scheduleLaunchActivity()
类似;
6.2 源码分析
// ApplicationThread.class
final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping, boolean resuming,
boolean dontWait) {
ActivityRecord prev = mResumedActivity;
// ...
if (prev.app != null && prev.app.thread != null) {
try {
mService.updateUsageStats(prev, false);
// 1.执行; 最终调用ApplicationThread.schedulePauseActivity()方法;
prev.app.thread.schedulePauseActivity(prev.appToken, prev.finishing,
userLeaving, prev.configChangeFlags, dontWait);
} catch (Exception e) {
}
}
}
// ApplicationThread.class
public final void schedulePauseActivity(IBinder token, boolean finished,
boolean userLeaving, int configChanges, boolean dontReport) {
// 2.执行; 这里finished=false
sendMessage(
finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,
token,
(userLeaving ? 1 : 0) | (dontReport ? 2 : 0),
configChanges);
}
/*
* ActivityThread.class
* 根据条件H.PAUSE_ACTIVITY,最终在H.handlerMessage()中调用ActivityThread.handlePauseActivity()方法
*/
private void handlePauseActivity(IBinder token, boolean finished,
boolean userLeaving, int configChanges, boolean dontReport) {
// 获取Activity (Token是Activity的唯一标识)
ActivityClientRecord r = mActivities.get(token);
if (r != null) {
// ...
// 3.执行
performPauseActivity(token, finished, r.isPreHoneycomb());
// Tell the activity manager we have paused.
if (!dontReport) {
try {
// 4.执行(在通知AMS后,还有后续操作); 通知AMS,指定token(Activity)已经变为Pause状态
ActivityManagerNative.getDefault().activityPaused(token);
} catch (RemoteException ex) {
}
}
mSomeActivitiesChanged = true;
}
}
// ActivityThread.class
final Bundle performPauseActivity(IBinder token, boolean finished,
boolean saveState) {
ActivityClientRecord r = mActivities.get(token);
// 5.执行; 这里 (r != null) = true
return r != null ? performPauseActivity(r, finished, saveState) : null;
}
// ActivityThread.class
final Bundle performPauseActivity(ActivityClientRecord r, boolean finished,
boolean saveState) {
// ...
try {
// Next have the activity save its current state and managed dialogs...
if (!r.activity.mFinished && saveState) {
// 6.执行; 这里会调用Activity.onSaveInstanceState()方法,且在Activity.onPause()之前;
callCallActivityOnSaveInstanceState(r);
}
// Now we are idle. (将当前的Activity状态改为闲置状态)
r.activity.mCalled = false;
// 7.执行(这一步执行完之后,执行第 4 步); 执行Activity.onPause()方法
mInstrumentation.callActivityOnPause(r.activity);
}
// ...
}
// ActivityManagerService.class
public final void activityPaused(IBinder token) {
final long origId = Binder.clearCallingIdentity();
synchronized(this) {
ActivityStack stack = ActivityRecord.getStackLocked(token);
if (stack != null) {
// 8.执行
stack.activityPausedLocked(token, false);
}
}
}
// ActivityStack.class
final void activityPausedLocked(IBinder token, boolean timeout) {
final ActivityRecord r = isInStackLocked(token);
if (r != null) {
mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r);
if (mPausingActivity == r) {
// 9.执行;
completePauseLocked(true);
} else {
if (r.finishing && r.state == ActivityState.PAUSING) {
finishCurrentActivityLocked(r, FINISH_AFTER_VISIBLE, false);
}
}
}
}
// ActivityStack.class
private void completePauseLocked(boolean resumeNext) {
ActivityRecord prev = mPausingActivity;
// ...
if (resumeNext) {
final ActivityStack topStack = mStackSupervisor.getFocusedStack();
if (!mService.isSleepingOrShuttingDown()) {
// 10.执行;
mStackSupervisor.resumeTopActivitiesLocked(topStack, prev, null);
} else {
mStackSupervisor.checkReadyForSleepLocked();
ActivityRecord top = topStack.topRunningActivityLocked(null);
if (top == null || (prev != null && top != prev)) {
mStackSupervisor.resumeTopActivitiesLocked(topStack, null, null);
}
}
}
// ...
}
// ActivityStackSupervisor.class
boolean resumeTopActivitiesLocked(ActivityStack targetStack, ActivityRecord target,
Bundle targetOptions) {
if (isFrontStack(targetStack)) {
// 11.执行
result = targetStack.resumeTopActivityLocked(target, targetOptions);
}
// ...
return result;
}
// ActivityStack.class
final boolean resumeTopActivityLocked(ActivityRecord prev, Bundle options) {
// ...
// 12.执行; 这里又执行到了ActivityStack.resumeTopActivityInnerLocked()方法
result = resumeTopActivityInnerLocked(prev, options);
return result;
}
// ActivityStackSupervisor.class
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, Bundle options) {
// ...
// 13.执行; 这里启动了指定的Activity(请参考本文第 3 部分)
mStackSupervisor.startSpecificActivityLocked(next, true, true);
}