Android 7.0 ActivityManagerService(2) 启动Activity的过程：一

从这一篇博客开始，我们将阅读AMS启动一个Activity的代码流程。

自己对Activity的启动过程也不是很了解，这里就初步做一个代码阅读笔记，为以后的迭代打下一个基础。

一、基础知识

在分析Activity的启动过程前，有必要先了解一下Activity相关的基础知识。

1、Task和Activity的设计理念

关于Android中Task和Activity的介绍，个人觉得《深入理解Android》中的例子不错。

我们就借鉴其中的例子，进行相应的说明：



上图列出了用户在Android系统上想干的三件事，分别用A、B、C表示。

在Android中，每一件事可以被看作是一个Task；一个Task可以被细分成多个子步骤，每个子步骤可以被看作是一个Activity。

从上图可以看出，A、B两个Task使用了不同的Activity来完成相应的任务，即A、B两个Task的Activity之间没有复用。

但是在Task C中，分别使用了Task A中的A1、Task B中的B2。

这么设计的原因是：用户想做的事情（Task）即使完全不同，但是当细分Task为Activity时，就可能出现Activity功能类似的情况。

当Task A和Task B中已经有能满足需求的Activity时，Task C就会优先复用而不是重新创建Activity。

通过重用Activity可以节省一定的开销，同时为用户提供一致的界面和用户体验。

对Android的设计理念有一定的了解后，我们看看Android是如何组织Task及它所包含的Activity。



上图为一个比较经典的示例：图中的Task包含4个Activity。用户可以单击按钮跳转到下一个Activity。同时，通过返回键可以回到上一个Activity。

图中虚线下方为Activity的组织方式。从图中可以看出，Android是以Stack的方式来管理Activity的。

先启动的Activity成为栈底成员，被启动的Activity将作为栈顶成员显示在界面上。

当按返回键时，栈顶成员出栈，前一个Activity成为栈顶显示在界面上。

以上是一个Task的情况。当有多个Task时，Android系统只支持一个处于前台的Task，其余的Task均处于后台。

这些后台Task内部Activity保持顺序不变。用户可以一次将整个Task挪到后台或置为前台，如下图所示：



在AMS中，将用ActivityRecord来作为Activity的记录者、TaskRecord作为Task的记录者，TaskRecord中有对应的ActivityStack专门管理ActivityRecord。

2、启动模式

Android定义了4种Activity的启动模式，分别为Standard、SingleTop、SingleTask和SingleInstance。

Standard模式

我们平时直接创建的Activity都是这种模式。

这种模式的Activity的特点是：只要你创建并启动了Activity实例，Android就会向当前的任务栈中加入新创建的实例。退出该Activity时，Android就会在任务栈中销毁该实例。

因此，一个Task中可以有多个相同类型的Activity（类型相同，但不是同一个对象）。

Standard模式启动Activity的栈结构如下图所示：



SingleTop模式

这种模式会考虑当前要激活的Activity实例在任务栈中是否正处于栈顶。

如果处于栈顶则无需重新创建新的实例，将重用已存在的实例，

否则会在任务栈中创建新的实例。

SingleTop模式启动Activity的栈结构如下图所示：



注意：当用SingleTop模式启动位于栈顶的Activity时，并不会创建新的Activity，但栈顶Activity的onNewIntent函数将被调用。

SingleTask模式

在该种模式下，只要Activity在一个栈中存在，那么多次启动此Activity都不会重新创建实例。和SingleTop一样，系统也会回调其onNewIntent。

具体一点，当一个具有singleTask模式的Activity A请求启动后，系统先会寻找是否存在A想要的任务栈。

如果不存在对应任务栈，就重新创建一个任务栈，然后创建A的实例后，把A放到任务栈中。

如果存在A所需的任务栈，那么系统将判断该任务栈中是否有实例A。

如果有实例A，那么系统就将A调到栈顶并调用其onNewIntent方法（会清空A之上的Activity）。

如果没有实例A，那么系统就创建实例A并压入栈中。

SingleTask模式启动Activity的栈结构如下图所示：



SingleInstance模式

SingleInstance模式是一种加强版的SingleTask模式，它除了具有SingleTask所有的特性外，还加强了一点，那就是具有此模式的Activity只能单独地位于一个任务栈中。

3、Intent Flags

启动模式主要是配置在xml文件中的，例如：

<activity android:name=".TestActivity"
android:launchMode="singleTask"
>

除了启动模式外，Android在用Intent拉起Activity时，还可以使用Intent Flags控制Activity及Task之间的关系。

Intent Flags数量非常多，这里只列举其中的一部分：

Intent.FLAG_ACTIVITY_NEW_TASK

默认的跳转类型，将目标Activity放到一个新的Task中。

Intent.FLAG_ACTIVITY_CLEAR_TASK

当用这个FLAG启动一个Activity时，系统会先把与该Activity有关联的Task释放掉，然后启动一个新的Task，并把目标Activity放到新的Task。

该标志必须和Intent.FLAG_ACTIVITY_NEW_TASK一起使用。

FLAG_ACTIVITY_SINGLE_TOP

这个FLAG就相当于启动模式中的singleTop。

例如:原来栈中结构是A B C D。现在，在D中启动D，那么栈中的结构还是A B C D。

FLAG_ACTIVITY_CLEAR_TOP

这个FLAG类似于启动模式中的SingleTask。

这种FLAG启动的Activity会其之上的Activity全部弹出栈空间。

例如：原来栈中的结构是A B C D ，从D中跳转到B，栈中的结构就变为了A B了。

FLAG_ACTIVITY_NO_HISTORY

用这个FLAG启动的Activity，一旦退出，就不会存在于栈中。

例如：原来栈中的结构是A B C，现在用这个FLAG启动D。然后在D中启动E，栈中的结构为A B C E。

对这些基础知识有了一定的了解后，我们来看看AMS启动Activity的代码级流程。

在这一篇博客中，我们对代码流程的分析，将截止于启动Activity对应的进程。

于是，这部分流程中大部分的内容，将围绕Activity如何选择对应的Task来展开，

由于Task的选择还要涉及对启动模式、Intent Flags等的判断，

因此整个代码将极其的琐碎，需要很有耐心才能较仔细地看完。

二、am命令

我们将看看利用am命令如何启动一个Activity。

之所以选择从am命令入手，是因为当我们从一个Activity拉起另一个Activity时，

当前Activity对应的进程需要和AMS进行交互，

这就要求我们需要对进程中与AMS交互的对象比较了解时，才比较容易分析。

而从am入手分析，当被启动Activity被创建后，代码流程自然就会涉及到这个进程与AMS的交互，

整个逻辑的顺序很容易理解。

当我们利用adb shell进入到手机的控制台后，可以利用am命令启动Activity、Service等。

具体的格式类似于：

am start -W -n 包名(package)/包名.activity名称

例如，启动浏览器的命令是：

am start -W -n com.android.browser/com.android.browser.BrowserActivity

上面命令中的-W是一个可选项，表示等待目标activity启动后，am才返回结果；

-n ，表示后接COMPONENT。

am命令可接的参数有很多种，有兴趣可以研究一下，此处不再一一列举。

如同之前介绍pm安装apk的流程中提及的，pm命令是一个执行脚本。

am与pm一样，同样是定义于手机中的执行脚本。

am脚本的文件路径是frameworks/base/cms/am，其内容如下：

#!/system/bin/sh
#
# Script to start "am" on the device, which has a very rudimentary
# shell.
#
base=/system
export CLASSPATH=$base/framework/am.jar
exec app_process $base/bin com.android.commands.am.Am "$@"

与调用pm命令类似，调用am命令同样最终会调用到Am.java(frameworks/base/cmds/am/src/com/android/commands/am)的main函数。

这里的调用过程可以参考Android7.0 PackageManagerService (3) APK安装的第二部分。

现在我们直接看看Am.java的main函数:

/**
* Command-line entry point.
*
* @param args The command-line arguments
*/
public static void main(String[] args) {
//创建一个Am对象，然后执行run函数
(new Am()).run(args);
}

Am继承自BaseCommand，上面的run函数定义于BaseCommand中：

/**
* Call to run the command.
*/
public void run(String[] args) {
..........
//将字符串封装到对象中，mArgs的类型为ShellCommand
mArgs.init(null, null, null, null, args, 0);
..........
try {
//子类实现
onRun();
} catch (IllegalArgumentException e) {
......
} catch (Exception e) {
......
}
}

现在进入到Am.java的onRun函数：

public void onRun() throws Exception {
mAm = ActivityManagerNative.getDefault();
..............
mPm = IPackageManager.Stub.asInterface(ServiceManager.getService("package"));
...............
//从父类的mArgs中中取出第一个参数
String op = nextArgRequired();

if (op.equals("start")) {
runStart();
} else if (op.equals("startservice")) {
runStartService();
} .........
...........
}

从代码可以看出，am命令的功能很多，此处我们主要看看start相关的runStart函数：

private void runStart() throws Exception {
//makeIntent会解析参数，得到对应的Intent
//主要是结合Intent的parseCommandArgs函数和Am内部定义的CommandOptionHandler解析字符串
//比较简单，不做深入分析
Intent intent = makeIntent(UserHandle.USER_CURRENT);
..........
//获取mimeType
String mimeType = intent.getType();
if (mimeType == null && intent.getData() != null
&& "content".equals(intent.getData().getScheme())) {
//如果是"content"类型的数据，那么利用AMS获取对应的mimeType
mimeType = mAm.getProviderMimeType(intent.getData(), mUserId);
}
..........
do {
if (mStopOption) {
//处理-S选项，即先停止对应的Activity，再启动它
//这些变量，均是makeIntent函数解析参数得到的
...............
}
............
//通过am命令启动的Activity，附加了标志FLAG_ACTIVITY_NEW_TASK
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
............
if (mProfileFile != null) {
//处理-P选项，用于性能统计
.............
}
.............
//通过添加参数--stack，可以指定Activity加入到特定的Task中
//此处就是将对应的Stack Id将被写入到options中
//与脚本命令中的 -W 一样，--stack是一个可选项
ActivityOptions options = null;
if (mStackId != INVALID_STACK_ID) {
options = ActivityOptions.makeBasic();
options.setLaunchStackId(mStackId);
}

if (mWaitOption) {
//如果有-W选项，进入该分支
result = mAm.startActivityAndWait(null, null, intent, mimeType,
null, null, 0, mStartFlags, profilerInfo,
options != null ? options.toBundle() : null, mUserId);
res = result.result;
} else {
//不等待activity启动，直接返回
res = mAm.startActivityAsUser(null, null, intent, mimeType,
null, null, 0, mStartFlags, profilerInfo,
options != null ? options.toBundle() : null, mUserId);
}
//判断am命令是否执行成功，成功时会break
..........
mRepeat--;
.........
}while (mRepeat > 1);
}

从上面的代码可以看出，am最终将调用AMS的startActivityAndWait或startActivityAsUser函数，来启动参数指定的Activity。

我们以startActivityAndWait为例进行分析。

三、startActivityAndWait流程

startActivityAndWait的参数比较多，先来大致看一下参数的含义：

public final WaitResult startActivityAndWait(
//在多数情况下，一个Activity的启动是由一个应用进程发起的
//IApplicationThread是应用进程和AMS交互的通道
//通过am启动Activity时，该参数为null
IApplicationThread caller,

//应用进程对应的pacakge
String callingPackage,

//启动使用的Intent和resolvedType
Intent intent, String resolvedType,

//均是给Activity.java中定义的startActivityForResult使用的
//resultTo用于接收返回的结果，resultWho用于描述接收结果的对象
//requestCode由调用者定义
IBinder resultTo, String resultWho, int requestCode,

//Intent携带的start activity对应的flag
int startFlags,

//性能统计有关
ProfilerInfo profilerInfo,

//用于指定Activity的一些选项
//从前面调用的代码来看，应该是指定Activity需要加入的Task
Bundle bOptions,

//表示调用的用户ID
int userId) {
..................
}

现在我们看看startActivityAndWait函数的具体内容：

public final WaitResult startActivityAndWait(....) {
//进行权限检查相关的工作
.............

//用于存储处理结果
WaitResult res = new WaitResult();

//进入ActivityStarter中的流程
mActivityStarter.startActivityMayWait(caller, -1, callingPackage, intent, resolvedType,
null, null, resultTo, resultWho, requestCode, startFlags, profilerInfo, res, null,
bOptions, false, userId, null, null);

return res;
}

上面代码中的ActivityStarter初始化于AMS的构造函数中，专门负载启动Activity相关的工作。

当我们通过am命令启动一个Activity时，假设系统之前没有启动过该Activity，那么从功能的角度来看，ActivityStarter调用artActivityMayWait函数后，系统将完成以下工作：

1、上文提及在Am.java中，为Intent增加了标志位FLAG_ACTIVITY_NEW_TASK，因此系统将为Activity创建ActivityRecord和对应的TaskRecord。

2、系统需要启动一个新的应用进程以加载并运行该Activity。

3、还需要停止当前正在显示的Activity。

接下来，我们跟进一下ActivityStarter的startActivityMayWait函数。

我们可以将该函数分为三部分进行分析：

1 第一部分

final int startActivityMayWait(............) {
...............
//判断是否指定了组件名
boolean componentSpecified = intent.getComponent() != null;
...............

//利用PKMS解析满足Intent等参数要求的信息
ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId);
...............

// Collect information about the target of the Intent.
// mSupervisor的类型为ActivityStackSupervisor， 负责管理Activity和对应Task之间的关系
// 此处，ActivityStackSupervisor实际仅从ResolveInfo中取出对应的ActivityInfo
ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);

//得到options，其中可能指定了Activity需要加入的Task
ActivityOptions options = ActivityOptions.fromBundle(bOptions);

ActivityStackSupervisor.ActivityContainer container =
(ActivityStackSupervisor.ActivityContainer)iContainer;
synchronized (mService) {
//从am启动时，container为null
if (container != null && container.mParentActivity != null &&
container.mParentActivity.state != RESUMED) {
// Cannot start a child activity if the parent is not resumed.

//如果从一个Activity启动另一个Activity，从此处代码可以看出，
//要求父Activity已经执行过onResume
return ActivityManager.START_CANCELED;
}

final int realCallingPid = Binder.getCallingPid();
final int realCallingUid = Binder.getCallingUid();
....................

//以下代码是决定启动Activity时的Task
final ActivityStack stack;
if (container == null || container.mStack.isOnHomeDisplay()) {
//am启动，或Home来启动Activity
//stack为前台栈
stack = mSupervisor.mFocusedStack;
} else {
//当从一个Activity启动另一个Activity时，
//启动栈为父Activity的Task
stack = container.mStack;
}

//am启动时config == null
stack.mConfigWillChange = config != null && mService.mConfiguration.diff(config) != 0;
.................

//正常情况下，当一个Application退到后台时，系统会为它保存状态；当调度其到前台时，恢复它之前的状态，以保证用户体验的连续性
//AndroidManifest.xml中的Application标签可以申明一个CANT_SAVE_STATE属性
//设置了该属性的Application将不享受系统提供的状态保存/恢复功能，被称为heavy-weight process
if (aInfo != null &&
(aInfo.applicationInfo.privateFlags
& ApplicationInfo.PRIVATE_FLAG_CANT_SAVE_STATE) != 0) {
............................
}
...................
}
}

从上面的代码来看，startActivityMayWait在第一阶段最主要的工作其实就是：

1、解析出与Intent相匹配的ActivityInfo。

2、得到启动该Activity的Task，即父Activity的Task或前台Task。

2 第二部分

..................
//用于保存启动Activity后，对应的ActivityRecord
final ActivityRecord[] outRecord = new ActivityRecord[1];

//调用startActivityLocked函数，进行实际的启动工作
int res = startActivityLocked(...............);
..................

这一部分中，涉及到了启动Activity的核心函数startActivityLocked。该函数比较复杂，我们在后面单独分析。

当该函数成功执行完毕后，Activity将会被启动，并形成对应的ActivityRecord被AMS统一管理。

我们先看看startActivityMayWait函数第三部分的工作。

3 第三部分

...................
//outResult不等于null，表示等待启动结果
//目标Activity要运行在一个新的应用进程中，因此需要等待应用进程正常启动并处理相关请求
if (outResult != null) {
outResult.result = res;
if (res == ActivityManager.START_SUCCESS) {
mSupervisor.mWaitingActivityLaunched.add(outResult);
do {
try {
//一直等待，直到outResult显示Activity对应的Task成为front task
mService.wait();
} catch (InterruptedException e) {
}
} while (outResult.result != START_TASK_TO_FRONT
&& !outResult.timeout && outResult.who == null);

if (outResult.result == START_TASK_TO_FRONT) {
res = START_TASK_TO_FRONT;
}
}

if (res == START_TASK_TO_FRONT) {
//Activity对应的task拉到前台后，一直要等到该界面被加载
ActivityRecord r = stack.topRunningActivityLocked();
if (r.nowVisible && r.state == RESUMED) {
outResult.timeout = false;
outResult.who = new ComponentName(r.info.packageName, r.info.name);
outResult.totalTime = 0;
outResult.thisTime = 0;
} else {
outResult.thisTime = SystemClock.uptimeMillis();
mSupervisor.mWaitingActivityVisible.add(outResult);
do {
try {
mService.wait();
} catch (InterruptedException e) {
}
} while (!outResult.timeout && outResult.who == null);
}
}
}
...............

从上面的代码可以看出，第三阶段的工作就是根据返回值做一些处理。

由于我们在输入的命令时，指定了-W选项，因此将进入wait状态等待Activity界面被显示。

四、startActivityLocked流程

接下来，我们看看上面提及到的核心函数startActivityLocked：

final int startActivityLocked(..............) {
//err用于保存错误信息
int err = ActivityManager.START_SUCCESS;

//用于保存启动Activity对应的进程信息
ProcessRecord callerApp = null;

//如果参数中的调用者不为空，则从AMS中找到对应的ProcessRecord，目的是得到调用者的pid和uid
//当利用am命令启动时，caller等于null
if (caller != null) {
callerApp = mService.getRecordForAppLocked(caller);
if (callerApp != null) {
callingPid = callerApp.pid;
callingUid = callerApp.info.uid;
} else {
................
}
}

final int userId = aInfo != null ? UserHandle.getUserId(aInfo.applicationInfo.uid) : 0;
.........................
//sourceRecord用于保存父Activity的信息
ActivityRecord sourceRecord = null;

//resultRecord用于保存接收启动结果的Activity
ActivityRecord resultRecord = null;

//对于startActivityForResult才有意义
if (resultTo != null) {
//利用ActivityStackSupervisor判断是否有resultTo对应的ActivityRecord
//这里的隐含条件是，resultTo的对象就是父Activity
sourceRecord = mSupervisor.isInAnyStackLocked(resultTo);
.................
if (sourceRecord != null) {
if (requestCode >= 0 && !sourceRecord.finishing) {
resultRecord = sourceRecord;
}
}
}

//得到启动Activity使用的标志位
final int launchFlags = intent.getFlags();

if ((launchFlags & Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0 && sourceRecord != null) {
// Transfer the result target from the source activity to the new
// one being started, including any failures.
//以这个标签启动的Activity，将接收原本发往父Activity的result
//这部分代码没细看，感觉没什么用吧。。。
....................
}

//检查一些条件是否满足，修改err的状态
.....................

//得到接收启动结果的Task
final ActivityStack resultStack = resultRecord == null ? null : resultRecord.task.stack;

if (err != START_SUCCESS) {
if (resultRecord != null) {
//如果存在err，需要返回错误信息
resultStack.sendActivityResultLocked(
-1, resultRecord, resultWho, requestCode, RESULT_CANCELED, null);
}
ActivityOptions.abort(options);
return err;
}

//检查权限
boolean abort = !mSupervisor.checkStartAnyActivityPermission(.............);

//根据IntentFirewall判断Intent是否满足要求
abort |= !mService.mIntentFirewall.checkStartActivity(.............);

//通过接口，可以为AMS设置一个IActivityController类型的监听者；AMS进行操作时，将会回调该监听者
//例如进行Monkey测试的时候，Monkey会设置该回调对象
if (mService.mController != null) {
try {
Intent watchIntent = intent.cloneFilter();

//交给回调对象处理，判断能否进行后续流程
//进行Monkey测试时，可以设置黑名单，处于黑名单中的Activity将不能启动
abort |= !mService.mController.activityStarting(watchIntent,
aInfo.applicationInfo.packageName);
} catch (RemoteException e) {
mService.mController = null;
}
}
................
//以上任一条件不满足时，进行通知
if (abort) {
if (resultRecord != null) {
resultStack.sendActivityResultLocked(-1, resultRecord, resultWho, requestCode,
RESULT_CANCELED, null);
}
// We pretend to the caller that it was really started, but
// they will just get a cancel result.
ActivityOptions.abort(options);
return START_SUCCESS;
}

// If permissions need a review before any of the app components can run, we
// launch the review activity and pass a pending intent to start the activity
// we are to launching now after the review is completed.
//在必要时，再检查一下权限，代码未细看，暂时觉得没有必要看
if (Build.PERMISSIONS_REVIEW_REQUIRED && aInfo != null) {
................
}
..............
//创建一个ActivityRecord对象
ActivityRecord r = new ActivityRecord(.........);
if (outActivity != null) {
outActivity[0] = r;
}
.........................
final ActivityStack stack = mSupervisor.mFocusedStack;
if (voiceSession == null && (stack.mResumedActivity == null
|| stack.mResumedActivity.info.applicationInfo.uid != callingUid)) {
//检查调用进程是否有权限切换Activity
if (!mService.checkAppSwitchAllowedLocked(callingPid, callingUid,
realCallingPid, realCallingUid, "Activity start")) {

//如果调用进程没有权限进行切换，则将本次Activity的启动请求保存起来
//后续有机会再进行启动
PendingActivityLaunch pal =  new PendingActivityLaunch(r,
sourceRecord, startFlags, stack, callerApp);
mPendingActivityLaunches.add(pal);
ActivityOptions.abort(options);
return ActivityManager.START_SWITCHES_CANCELED;
}
}

//用于控制app switch
if (mService.mDidAppSwitch) {
mService.mAppSwitchesAllowedTime = 0;
} else {
mService.mDidAppSwitch = true;
}

//启动处于pending状态的Activity
doPendingActivityLaunchesLocked(false);

try {
//WindowManager延迟绘制
//个人觉得可能是为了优化性能，比如当前界面还有细节未绘制完，但要拉起一个新的界面，那么此时就不需要绘制了）
mService.mWindowManager.deferSurfaceLayout();

//调用startActivityUnchecked
err = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
true, options, inTask);
} finally {
//WindowManager重新开始绘制（绘制当前的前台界面）
mService.mWindowManager.continueSurfaceLayout();
}
//此处将通知ActivityStarter, Activity对应的Task被移动到前台
postStartActivityUncheckedProcessing(r, err, stack.mStackId, mSourceRecord, mTargetStack);
return err;
}

startActivityLocked函数比较长，但主干比较清晰，只是添加许多条件判断。

从代码来看主要工作包括：

1、处理sourceRecord和resultRecord。

sourceRecord表示发起本次请求的Activity，即父Activity对应的信息；

resultRecord表示接收处理结果的Activity。

在一般情况下，sourceRecord和resultRecord应指向同一个Activity。

2、处理app switch。

如果AMS当前禁止app switch，那么AMS会将本次请求保存起来，以待允许app switch时再进行处理。

从代码可以看出，当AMS可以进行app switch时，在处理本次的请求前，会先调用doPendingActivityLaunchesLocked函数。

doPendingActivityLaunchesLocked函数将启动之前因系统禁止app switch而保存的请求。

3、调用startActivityUnchecked处理本次Activity的启动请求。

在分析接下来的流程前，我们先看看app switch相关的内容。

在AMS中，提供了两个函数stopAppSwitches和resumeAppSwitches，用于暂时禁止App切换及恢复切换。

这种需求的考虑是：当某些重要的Activity处于前台时，不希望系统因为用户操作之外的原因切换Activity。

1、stopAppSwitches

先来看看stopAppSwitches：

public void stopAppSwitches() {
//检查调用进程是否有STOP_APP_SWITCHES权限
..............

synchronized(this) {
//设置了一个超时时间，目前为5s
//过了该时间，AMS可以重新切换App
mAppSwitchesAllowedTime = SystemClock.uptimeMillis()
+ APP_SWITCH_DELAY_TIME;
mDidAppSwitch = false;

//发送一个延迟消息，触发允许App Switch的操作
mHandler.removeMessages(DO_PENDING_ACTIVITY_LAUNCHES_MSG);
Message msg = mHandler.obtainMessage(DO_PENDING_ACTIVITY_LAUNCHES_MSG);
mHandler.sendMessageDelayed(msg, APP_SWITCH_DELAY_TIME);
}
}

对于上面的代码，需要注意两点：

1、此处的控制机制名为app switch，而不是Activity switch。

这是因为如果从受保护的Activity中启动另一个Activity，那么这个新的Activity的目的应该是针对同一个任务。

于是这次的启动就不应该受app switch的制约。

2、执行stopAppSwitches后，应用程序应该调用resumeAppSwitches以允许app switch。

为了防止应用程序有意或者无意没调用resumeAppSwitches，在stopAppSwitches中设置了一个超时时间，过了此超时时间，系统会发送一个消息触发App Switch的操作。

2、resumeAppSwitches

现在我们看看resumeAppSwitches的代码：

public void resumeAppSwitches() {
//同样是进行权限检查
.............

synchronized(this) {
// Note that we don't execute any pending app switches... we will
// let those wait until either the timeout, or the next start
// activity request.
mAppSwitchesAllowedTime = 0;
}
}

从代码可以看出，resumeAppSwitches只设置了mAppSwitchesAllowedTime的值为0，它并不处理在stop和resume这段时间内积攒起的Pending请求。

根据前面startActivityLocked函数，我们知道如果在执行resume app switch后，又有新的请求需要处理，则先调用doPendingActivityLaunchesLocked处理那些pending的请求。

此外，resumeAppSwitches函数中并没有撤销stopAppSwitches函数中设置的超时消息，所以当该消息被处理时，同样会触发处理pending请求的流程。

五、startActivityUnchecked流程

顺着请求的处理流程，我们接下来看看startActivityUnchecked函数。

startActivityUnchecked函数比较长，我们分段看一下。

Part-I

第一部分如下代码所示，主要用于判断是否需要为新的Activity创建一个Task。

private int startActivityUnchecked(.......) {
//根据参数重新设置类的成员变量
//将存储当前Activity对应的启动模式等信息
setInitialState(............);

computeLaunchingTaskFlags();

computeSourceStack();

mIntent.setFlags(mLaunchFlags);
...................

我们依次看看上述代码中的几个函数：

1、setInitialState

private void setInitialState(.........) {
//重置当前类的成员变量
reset();

//用于保存当前准备启动的Activity
mStartActivity = r;

mIntent = r.intent;
...........
mSourceRecord = sourceRecord;
...........

mLaunchSingleTop = r.launchMode == LAUNCH_SINGLE_TOP;
mLaunchSingleInstance = r.launchMode == LAUNCH_SINGLE_INSTANCE;
mLaunchSingleTask = r.launchMode == LAUNCH_SINGLE_TASK;
................

// We'll invoke onUserLeaving before onPause only if the launching
// activity did not explicitly state that this is an automated launch.
//判断是否需要调用因本次Activity启动，而被系统移到后台的当前Activity的onUserLeaveHint函数
mSupervisor.mUserLeaving = (mLaunchFlags & FLAG_ACTIVITY_NO_USER_ACTION) == 0;
................

if (mOptions != null && mOptions.getLaunchTaskId() != -1 && mOptions.getTaskOverlay()) {
r.mTaskOverlay = true;
final TaskRecord task = mSupervisor.anyTaskForIdLocked(mOptions.getLaunchTaskId());
final ActivityRecord top = task != null ? task.getTopActivity() : null;
if (top != null && !top.visible) {

// The caller specifies that we'd like to be avoided to be moved to the front, so be
// it!
// 从代码来看，这一处有些奇怪
// 如果启动参数中指定了Activity需要加入的Task，但该Task的top Activity当前是不可见的
// 那么新启动的Activity也将不可见
mDoResume = false;
mAvoidMoveToFront = true;
}
}
............................
mNoAnimation = (mLaunchFlags & FLAG_ACTIVITY_NO_ANIMATION) != 0;
}

上面的这部分代码，有些参数的用途目前还不太清楚，没有进行记录，以后重新阅读时，再进行添加和修改。

Activity启动时，Intent可以选择的Flag太多了，setInitialState对于一些不太常用的Flag也进行了判断。

因此，如果需要真正弄懂这一部分，还是要看看关于Intent中Flag相关的文档。

2、computeLaunchingTaskFlags

private void computeLaunchingTaskFlags() {
// If the caller is not coming from another activity, but has given us an explicit task into
// which they would like us to launch the new activity, then let's see about doing that.

//mSourceRecord == null，意味着新启动的Activity没有Activity
//mInTask != null && mInTask.stack != null, 意味着该请求指定了对应的希望加入的Task
//这些参数都是setInitialState解析函数输入参数得到的
if (mSourceRecord == null && mInTask != null && mInTask.stack != null) {
final Intent baseIntent = mInTask.getBaseIntent();
final ActivityRecord root = mInTask.getRootActivity();
.......................

// If this task is empty, then we are adding the first activity -- it
// determines the root, and must be launching as a NEW_TASK.
//如果以SingleInstance或SingleTask启动，判断一些条件是否满足
//从代码来看，如果参数指定Activity启动在某个Task中，同时启动模式又定义为SingleInstance或SingleTask
//那么对应的Task必须是空的，否则会报错
if (mLaunchSingleInstance || mLaunchSingleTask) {
.....................
}

// If task is empty, then adopt the interesting intent launch flags in to the
// activity being started.
if (root == null) {
//重新调整一下flag
......................
mIntent.setFlags(mLaunchFlags);
mInTask.setIntent(mStartActivity);

//表示将加入到指定的Task中
mAddingToTask = true;

// If the task is not empty and the caller is asking to start it as the root of
// a new task, then we don't actually want to start this on the task. We will
// bring the task to the front, and possibly give it a new intent.
} else if ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
//如果指定Task不为空，同时启动参数携带了FLAG_ACTIVITY_NEW_TASK
//那么最终这个Activity还是会启动在一个新创建的Task内，因此mAddingToTask为false
mAddingToTask = false;
} else {
mAddingToTask = true;
}

//mInTask不为null时，说明要复用
mReuseTask = mInTask;
} else {
//这一部分才是我们比较常见的，即不指定启动Task的情况

mInTask = null;

// Launch ResolverActivity in the source task, so that it stays in the task bounds
// when in freeform workspace.
// Also put noDisplay activities in the source task. These by itself can be placed
// in any task/stack, however it could launch other activities like ResolverActivity,
// and we want those to stay in the original task.

//参考上面注释和下面代码，可以看出这是对特殊情况的处理
//当被启动的Activity是ResolverActivity或不需要显示的Activity时，
//如果父Activity存在且有足够的空间，那么这类Activity无条件地启动在父Activity所在的Task中
if ((mStartActivity.isResolverActivity() || mStartActivity.noDisplay) && mSourceRecord != null
&& mSourceRecord.isFreeform())  {
mAddingToTask = true;
}
}

//如果还没有找到待启动Activity对应的Task
//在下列情况下，为Activity添加FLAG_ACTIVITY_NEW_TASK标志
//参考注释和代码，比较容易理解
if (mInTask == null) {
if (mSourceRecord == null) {
// This activity is not being started from another...  in this
// case we -always- start a new task.
if ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) == 0 && mInTask == null) {
...............
mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
}
} else if (mSourceRecord.launchMode == LAUNCH_SINGLE_INSTANCE) {
// The original activity who is starting us is running as a single
// instance...  this new activity it is starting must go on its
// own task.
mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
} else if (mLaunchSingleInstance || mLaunchSingleTask) {
// The activity being started is a single instance...  it always
// gets launched into its own task.
mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
}
}
}

如同函数名一样，这部分代码主要用于决策是否在LaunchFlags中添加FLAG_ACTIVITY_NEW_TASK。

主要的思想可以简化为：

1、如果参数中，指定了希望Activity加入的Task，同时这个Task确实可用（不与当前的LaunchFlags矛盾），那么mInTask和mReuseTask的值不为null，不需要添加FLAG_ACTIVITY_NEW_TASK。

2、如果不满足1中的条件，即没有指定希望Activity加入的Task，或者指定的Task无法使用，在满足条件的情况下，会为LaunchFlags添加FLAG_ACTIVITY_NEW_TASK。

简单的一句话就是：在正常情况下，若现存Task中，没有待启动Activity可以使用的，就重新为其创建一个。

3、computeSourceStack

private void computeSourceStack() {
if (mSourceRecord == null) {
//无父Activity，对应的TaskRecord为null
mSourceStack = null;
return;
}
if (!mSourceRecord.finishing) {
//有父Activity，同时该Activity没有finishing，则记录对应的TaskRecord
mSourceStack = mSourceRecord.task.stack;
return;
}

// If the source is finishing, we can't further count it as our source. This is because the
// task it is associated with may now be empty and on its way out, so we don't want to
// blindly throw it in to that task.  Instead we will take the NEW_TASK flow and try to find
// a task for it. But save the task information so it can be used when creating the new task.
// 阅读注释即可
if ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) == 0) {
................
mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
mNewTaskInfo = mSourceRecord.info;
mNewTaskIntent = mSourceRecord.task.intent;
}
mSourceRecord = null;
mSourceStack = null;
}

这一部分代码主要用于记录父Activity对应的TaskRecord信息。

如同注释部分，当父Activity Finishing时，此父Activity对应Task不再作为新Activity的sourceStack，因为该Task有可能会被Android系统清理掉。

在这种情况下，Android系统将创建新的Task作为sourceStack，同时使这个新Task的信息与父Activity原有sourceTask信息相同。

至此，startActivityUnchecked的第一部分结束。

在这一部分中，代码主要判断Activity是否需要插入到现有Task中，同时当存在父Activity时，判断sourceTask是否有效。

所有的这些判断，最后都用于决策新启动的Activity是否需要携带FLAG_ACTIVITY_NEW_TASK标志，即是否需要新建一个Task对象。

Part-II

接下来，我们看看startActivityUnchecked的第二部分。

...................
//决定是否将新的Activity插入到现有的Task中
//返回null表示否
mReusedActivity = getReusableIntentActivity();

//从参数中得到希望Activity加入的Task对应的stackId
final int preferredLaunchStackId =
(mOptions != null) ? mOptions.getLaunchStackId() : INVALID_STACK_ID;

//以下，皆是当需要将新的Activity插入到现有的Task时，对应的处理过程
if (mReusedActivity != null) {
//LockTaskMode相关的处理，目前不太懂
.........

if (mStartActivity.task == null) {
//设置待启动Activity的Task
mStartActivity.task = mReusedActivity.task;
}

if (mReusedActivity.task.intent == null) {
// This task was started because of movement of the activity based on affinity...
// Now that we are actually launching it, we can assign the base intent.

//如果复用Activity之前的Task没有Intent，现在重新设置
mReusedActivity.task.setIntent(mStartActivity);
}

// This code path leads to delivering a new intent, we want to make sure we schedule it
// as the first operation, in case the activity will be resumed as a result of later
// operations.
//这里就是之前分析启动模式时提过的，以singleTask等方式启动现有Task中的Activity，将会清空其上的Activity
if ((mLaunchFlags & FLAG_ACTIVITY_CLEAR_TOP) != 0
|| mLaunchSingleInstance || mLaunchSingleTask) {
// In this situation we want to remove all activities from the task up to the one
// being started. In most cases this means we are resetting the task to its initial
// state.

//这里进行清空操作
final ActivityRecord top = mReusedActivity.task.performClearTaskForReuseLocked(
mStartActivity, mLaunchFlags);

if (top != null) {
if (top.frontOfTask) {
// Activity aliases may mean we use different intents for the top activity,
// so make sure the task now has the identity of the new intent.

//top Activity将会是待启动的Activity
top.task.setIntent(mStartActivity);
}
..................
//这里最后会出发待启动Activity的onNewIntent方法
top.deliverNewIntentLocked(mCallingUid, mStartActivity.intent,
mStartActivity.launchedFromPackage);
}
}

//这里应该是将复用Activity对应的Task移动到前台
mReusedActivity = setTargetStackAndMoveToFrontIfNeeded(mReusedActivity);
.......................

//最后根据复用Activity的信息，修改待加入Task相关的变量
setTaskFromIntentActivity(mReusedActivity);
.......................
}

..................

这一段代码主要是针对复用Activity的场景，代码逻辑比较繁杂，但主要目的是：

当判断新启动的Activity可以复用现有Task中的Activity时，则按照Activity的启动模式，对该Activity所在的Task执行相应的操作。

接下来，我们看看其中比较关键的函数。

1、getReusableIntentActivity

getReusableIntentActivity将决定新启动的Activity是否可以复用现有的Activity。

/**
* Decide whether the new activity should be inserted into an existing task. Returns null
* if not or an ActivityRecord with the task into which the new activity should be added.
*/

private ActivityRecord getReusableIntentActivity() {
// We may want to try to place the new activity in to an existing task.  We always
// do this if the target activity is singleTask or singleInstance; we will also do
// this if NEW_TASK has been requested, and there is not an additional qualifier telling
// us to still place it in a new task: multi task, always doc mode, or being asked to
// launch this as a new task behind the current one.

//根据标志位和启动模式，决定新启动的Activity是否要放入到已有的Task中，参看注释
boolean putIntoExistingTask = ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0 &&
(mLaunchFlags & FLAG_ACTIVITY_MULTIPLE_TASK) == 0)
|| mLaunchSingleInstance || mLaunchSingleTask;

// If bring to front is requested, and no result is requested and we have not been given
// an explicit task to launch in to, and we can find a task that was started with this
// same component, then instead of launching bring that one to the front.
putIntoExistingTask &= mInTask == null && mStartActivity.resultTo == null;

//保存返回结果
ActivityRecord intentActivity = null;

//如果启动参数中指定了TaskId，那么优先使用对应的Task
if (mOptions != null && mOptions.getLaunchTaskId() != -1) {
//ActivityStackSupervisor统一管理Task和Activity的组织关系
final TaskRecord task = mSupervisor.anyTaskForIdLocked(mOptions.getLaunchTaskId());
intentActivity = task != null ? task.getTopActivity() : null;
} else if (putIntoExistingTask) {
if (mLaunchSingleInstance) {
// There can be one and only one instance of single instance activity in the
// history, and it is always in its own unique task, so we do a special search.

intentActivity = mSupervisor.findActivityLocked(mIntent, mStartActivity.info, false);
} else if ((mLaunchFlags & FLAG_ACTIVITY_LAUNCH_ADJACENT) != 0) {
// For the launch adjacent case we only want to put the activity in an existing
// task if the activity already exists in the history.

intentActivity = mSupervisor.findActivityLocked(mIntent, mStartActivity.info,
!mLaunchSingleTask);
} else {
// Otherwise find the best task to put the activity in.
intentActivity = mSupervisor.findTaskLocked(mStartActivity);
}
}

return intentActivity;
}

这段代码参照注释，不难理解它的意思：

当我们启动一个Activity时，优先是想进行复用。因此，需要寻找匹配该Activity的Task。

如果在启动参数中，指定了目标Task，那么显然需要利用ActivityStackSupervisor找到指定的Task。

如果指定的Task存在，那么新启动的Activity将插入到该Task的Top位置。

如果启动参数未指定启动Task，那么就需要根据Activity信息，利用ActivityStackSupervisor在当前的Task中进行匹配了。

具体的匹配规则，在这里就不做进一步展开了。

2、setTargetStackAndMoveToFrontIfNeeded

这一部分代码应该是，当可以进行Activity复用时，在必要的情况下，将待启动Activity所在的Task移动到前台。

private ActivityRecord setTargetStackAndMoveToFrontIfNeeded(ActivityRecord intentActivity) {
//保存待移动的ActivityStack
//这里也可以看出，每个Task有对应的ActivityStack，用于管理运行在其中的Activity
mTargetStack = intentActivity.task.stack;
mTargetStack.mLastPausedActivity = null;

// If the target task is not in the front, then we need to bring it to the front...
// except...  well, with SINGLE_TASK_LAUNCH it's not entirely clear. We'd like to have
// the same behavior as if a new instance was being started, which means not bringing it
// to the front if the caller is not itself in the front.

//得到前台栈的top Activity
final ActivityStack focusStack = mSupervisor.getFocusedStack();
ActivityRecord curTop = (focusStack == null)
? null : focusStack.topRunningNonDelayedActivityLocked(mNotTop);

//条件满足时，需要进行移动到前台的操作
if (curTop != null
&& (curTop.task != intentActivity.task || curTop.task != focusStack.topTask())
&& !mAvoidMoveToFront) {
//添加对应的标志位
mStartActivity.intent.addFlags(Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT);

//觉得这里的判断是指，当父Activity存在时，才说明原来存在一个前台栈，才需要进行栈的移动
if (mSourceRecord == null || (mSourceStack.topActivity() != null &&
mSourceStack.topActivity().task == mSourceRecord.task)) {
// We really do want to push this one into the user's face, right now.

//mLaunchTaskBehind由特殊的标志决定
if (mLaunchTaskBehind && mSourceRecord != null) {
intentActivity.setTaskToAffiliateWith(mSourceRecord.task);
}

mMovedOtherTask = true;

// If the launch flags carry both NEW_TASK and CLEAR_TASK, the task's activities
// will be cleared soon by ActivityStarter in setTaskFromIntentActivity().
// So no point resuming any of the activities here, it just wastes one extra
// resuming, plus enter AND exit transitions.
// Here we only want to bring the target stack forward. Transition will be applied
// to the new activity that's started after the old ones are gone.

//前面介绍flag时，已经提到过当FLAG_ACTIVITY_CLEAR_TASK被使用时，
//被复用的Task整体会被清空，这里就是判断是否需要clear Task
final boolean willClearTask =
(mLaunchFlags & (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK))
== (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK);

if (!willClearTask) {
//得到待启动Activity将要加入的ActivityStack
//正常情况下，launchStack和TargetStack一致
final ActivityStack launchStack = getLaunchStack(
mStartActivity, mLaunchFlags, mStartActivity.task, mOptions);

if (launchStack == null || launchStack == mTargetStack) {
// We only want to move to the front, if we aren't going to launch on a
// different stack. If we launch on a different stack, we will put the
// task on top there.

//launchStack和TargetStack一致时，将ActivityStack对应的Task移动到前台
mTargetStack.moveTaskToFrontLocked(
intentActivity.task, mNoAnimation, mOptions,
mStartActivity.appTimeTracker, "bringingFoundTaskToFront");
mMovedToFront = true;

//以下是对不一致时的处理
} else if (launchStack.mStackId == DOCKED_STACK_ID
|| launchStack.mStackId == FULLSCREEN_WORKSPACE_STACK_ID) {
if ((mLaunchFlags & FLAG_ACTIVITY_LAUNCH_ADJACENT) != 0) {
// If we want to launch adjacent and mTargetStack is not the computed
// launch stack - move task to top of computed stack.

mSupervisor.moveTaskToStackLocked(intentActivity.task.taskId,
launchStack.mStackId, ON_TOP, FORCE_FOCUS, "launchToSide",
ANIMATE);
} else {
// We choose to move task to front instead of launching it adjacent
// when specific stack was requested explicitly and it appeared to be
// adjacent stack, but FLAG_ACTIVITY_LAUNCH_ADJACENT was not set.

mTargetStack.moveTaskToFrontLocked(intentActivity.task, mNoAnimation,
mOptions, mStartActivity.appTimeTracker,
"bringToFrontInsteadOfAdjacentLaunch");
}
mMovedToFront = true;
}
.............
}
....................
}
}

if (!mMovedToFront && mDoResume) {
..............
mTargetStack.moveToFront("intentActivityFound");
}
......................
return intentActivity;
}

这段代码背后的逻辑还是比较复杂的。

不过从代码来看，在正常的情况下，若待启动的Activity可以被复用，那么对应的Task会被移动到前台。

至此，startActivityUnchecked第二部分代码分析完毕。

这部分代码我略去了很多的细节，但仍然很难一眼就看懂。

目前，我们仅需要记住这段代码的核心目的：当发现待启动的Activity可以复用时，在必要时将对应的Task移动到前台。

至于其它的判断分支，主要依赖于启动模式之类的信息。

Part-III

..............
// If the activity being launched is the same as the one currently at the top, then
// we need to check if it should only be launched once.
// 下面这段代码的功能就是判断，当待启动的Activity已经位于前台栈顶时，是否需要重新启动一个实例
final ActivityStack topStack = mSupervisor.mFocusedStack;
final ActivityRecord top = topStack.topRunningNonDelayedActivityLocked(mNotTop);

final boolean dontStart = top != null && mStartActivity.resultTo == null
&& top.realActivity.equals(mStartActivity.realActivity)
&& top.userId == mStartActivity.userId
&& top.app != null && top.app.thread != null
//可以粗略的认为，上面的判断是为了确保待启动的Activity与当前的前台Activity一致
//下面的判断，决定了是否需要重新创建一个实例
&& ((mLaunchFlags & FLAG_ACTIVITY_SINGLE_TOP) != 0
|| mLaunchSingleTop || mLaunchSingleTask);

if (dontStart) {
................
if (mDoResume) {
//resume top activity
mSupervisor.resumeFocusedStackTopActivityLocked();
}
...............
//调用onNewIntent函数
top.deliverNewIntentLocked(
mCallingUid, mStartActivity.intent, mStartActivity.launchedFromPackage);
..............
return START_DELIVERED_TO_TOP;
}

//表示是否创建新的Task
boolean newTask = false;

//得到Affiliate Task，这个具体的含义，不是很懂
final TaskRecord taskToAffiliate = (mLaunchTaskBehind && mSourceRecord != null)
? mSourceRecord.task : null;

if (mStartActivity.resultTo == null && mInTask == null && !mAddingToTask
&& (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
newTask = true;
//如果mReuseTask不为null，那么将mStartActivity的Task设置为mReuseTask
//否则，重新创建一个Task给mStartActivity使用
setTaskFromReuseOrCreateNewTask(taskToAffiliate);
...................
} else if (mSourceRecord != null) {
..................
//待启动的Activity使用父Activity的Task
//其中在必要时将父Activity的Task移动到前台
//若待启动的Activity存在于Task中，但不在Task的顶部，还需要将Activity移动到顶部
final int result = setTaskFromSourceRecord();
.................
} else if (mInTask != null) {
................
//对应于以指定Task启动Activity的情况
final int result = setTaskFromInTask();
................
} else {
// This not being started from an existing activity, and not part of a new task...
// just put it in the top task, though these days this case should never happen.
//待启动的Activity使用前台Task或重新创建一个Task
setTaskToCurrentTopOrCreateNewTask();
}
......................
//将待启动的Activity加入到mTargetStack的记录中，同时调用WindowManager准备App切换相关的工作
mTargetStack.startActivityLocked(mStartActivity, newTask, mKeepCurTransition, mOptions);

if (mDoResume) {
..................
final ActivityRecord topTaskActivity = mStartActivity.task.topRunningActivityLocked();

//待启动的Activity不可见的情况
if (!mTargetStack.isFocusable()
|| (topTaskActivity != null && topTaskActivity.mTaskOverlay
&& mStartActivity != topTaskActivity)) {
..................................
} else {
//最终调用resumeFocusedStackTopActivityLocked
mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,
mOptions);
}
} else {
.............
}
..............

startActivityUnchecked第三部分代码最核心的内容是：决定是否为待启动的Activity创建对应的Task，同时将Activity和Task关联起来。

最后，调用ActivityStackSupervisor的resumeFocusedStackTopActivityLocked函数。

六、resumeFocusedStackTopActivityLocked流程

顺着代码流程，我们看看ActivityStackSupervisor中的resumeFocusedStackTopActivityLocked函数：

boolean resumeFocusedStackTopActivityLocked(
ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions)) {
//待启动Activity对应的Task为前台Task时，调用该Task对应ActivityStack的resumeTopActivityUncheckedLocked函数
if (targetStack != null && isFocusedStack(targetStack)) {
return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
}

final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
if (r == null || r.state != RESUMED) {
//否则只是调用当前前台栈的resumeTopActivityUncheckedLocked
mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
}
return false;
}

我们跟进ActivityStack的resumeTopActivityUncheckedLocked函数：

boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
...............
try {
............
result = resumeTopActivityInnerLocked(prev, options);
} finally {
..........
}
.........
}

private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
....................
// Find the first activity that is not finishing.
//从当前ActivityStack的记录中，找到第一个待启动的ActivityRecord
final ActivityRecord next = topRunningActivityLocked();
....................
if (next == null) {
..............
//当前的ActivityStack没有等待启动的Activity时，将启动Home
return isOnHomeDisplay() &&
mStackSupervisor.resumeHomeStackTask(returnTaskType, prev, reason);
}
..............
// The activity may be waiting for stop, but that is no longer
// appropriate for it.
// 将待启动的Activity从下面几个队列中移除
mStackSupervisor.mStoppingActivities.remove(next);
mStackSupervisor.mGoingToSleepActivities.remove(next);
next.sleeping = false;
mStackSupervisor.mWaitingVisibleActivities.remove(next);

// If we are currently pausing an activity, then don't do anything until that is done.
//如果系统当前正在中断一个Activity，需要先等待那个Activity paus完毕，
//之后系统会重新调用resumeTopActivityInnerLocked函数，找到下一个要启动的Activity
if (!mStackSupervisor.allPausedActivitiesComplete()) {
...............
return false;
}

mStackSupervisor.setLaunchSource(next.info.applicationInfo.uid);

// We need to start pausing the current activity so the top one can be resumed...
final boolean dontWaitForPause = (next.info.flags & FLAG_RESUME_WHILE_PAUSING) != 0;

//中断后台栈？
boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, true, dontWaitForPause);

//mResumedActivity指向上一次启动的Activity，也就是当前界面显示的Activity
if (mResumedActivity != null) {
..........
//如果当前界面显示了一个Activity，那么在启动新的Activity之前，必须中断当前的Activity
pausing |= startPausingLocked(userLeaving, false, true, dontWaitForPause);
}

if (pausing) {
................
// At this point we want to put the upcoming activity's process
// at the top of the LRU list, since we know we will be needing it
// very soon and it would be a waste to let it get killed if it
// happens to be sitting towards the end.
if (next.app != null && next.app.thread != null) {
//在中断当前界面的Activity时，调用待启动Activity所在进程的优先级，保证其不被kill
mService.updateLruProcessLocked(next.app, true, null);
}
................
return true;
} else if (mResumedActivity == next && next.state == ActivityState.RESUMED &&
mStackSupervisor.allResumedActivitiesComplete()){
// It is possible for the activity to be resumed when we paused back stacks above if the
// next activity doesn't have to wait for pause to complete.
// So, nothing else to-do except:
// Make sure we have executed any pending transitions, since there
// should be nothing left to do at this point.
//特殊情况，上面的代码中断后台栈，同时启动模式指定了FLAG_RESUME_WHILE_PAUSING
mWindowManager.executeAppTransition();
mNoAnimActivities.clear();
..........
return true;
}

// If the most recent activity was noHistory but was only stopped rather
// than stopped+finished because the device went to sleep, we need to make
// sure to finish it as we're making a new activity topmost.
//若之前存在未正常结束的Activity，那么要优先结束掉这些Activity
if (mService.isSleepingLocked() && mLastNoHistoryActivity != null &&
!mLastNoHistoryActivity.finishing) {
................
requestFinishActivityLocked(mLastNoHistoryActivity.appToken, Activity.RESULT_CANCELED,
null, "resume-no-history", false);
mLastNoHistoryActivity = null;
................
}
..............
// Launching this app's activity, make sure the app is no longer
// considered stopped.
try {
//通过PKMS，修改待启动Activity对应Package的stop状态
AppGlobals.getPackageManager().setPackageStoppedState(
next.packageName, false, next.userId); /* TODO: Verify if correct userid */
} catch (RemoteException e1) {
} catch (IllegalArgumentException e) {
.................
}
...............
// We are starting up the next activity, so tell the window manager
// that the previous one will be hidden soon.  This way it can know
// to ignore it when computing the desired screen orientation.
// 与WindowManager有关，通知它停止绘画
if (prev != null) {
............
} else {
............
}

//处理动画相关的选项
Bundle resumeAnimOptions = null;
if (anim) {
ActivityOptions opts = next.getOptionsForTargetActivityLocked();
if (opts != null) {
resumeAnimOptions = opts.toBundle();
}
next.applyOptionsLocked();
} else {
next.clearOptionsLocked();
}
...............
if (next.app != null && next.app.thread != null) {
//如果待启动的Activity已有对应的进程存在，则只需要重启Activity
..............
} else {
............
mStackSupervisor.startSpecificActivityLocked(next, true, true);
..............
}
.............
return true;
}

resumeTopActivityInnerLocked函数非常繁琐，但整体来讲应该只有两个比较关键的地方：

1、如果mResumedActivity不为空，则需要先暂停这个Activity。

mResumedActivity代表当前已经存在于界面的Activity。当需要启动一个新的Activity时，需要先停止当前的Activity。

这部分工作由startPausingLocked函数来完成。

当前的Activity被中断后，将重新启动新的Activity。

2、当mResumedActivity为空时，若待启动的Activity对应的应用存在，那么仅需要重新启动该Activity；

否则，需要调用ActivityStackSupervisor的startSpecificActivityLocked函数，启动整个进程。

需要说明的是：

1、当系统启动第一个Activity，即Home时，mResumedActivity的值才会为null。

因此，即使我们以脚本的方式，启动一个Activity，也必须先中断当前的界面，才能进行后续的操作。

2、分析startPausingLocked函数时，将涉及到当前界面对应的进程、新启动Activity所在的进程，与AMS之间的交互，整体比较复杂。

因此还是先从简单的情况入手，看看直接启动新Activity所在进程的startSpecificActivityLocked函数。

从逻辑上看，猜测startPausingLocked函数中断现有Activity后，最终也会调用startSpecificActivityLocked启动新Activity。

七、startSpecificActivityLocked流程

现在我们跟进一下startSpecificActivityLocked函数：

void startSpecificActivityLocked(ActivityRecord r,
boolean andResume, boolean checkConfig) {
// Is this activity's application already running?
//从AMS中查询是否已经存在满足要求的进程
ProcessRecord app = mService.getProcessRecordLocked(r.processName,
r.info.applicationInfo.uid, true);

//设置启动时间
r.task.stack.setLaunchTime(r);

//如果对应进程已经存在，并向AMS注册过
if (app != null && app.thread != null) {
try {
if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0
|| !"android".equals(r.info.packageName)) {
// Don't add this if it is a platform component that is marked
// to run in multiple processes, because this is actually
// part of the framework so doesn't make sense to track as a
// separate apk in the process.

//单进程非系统应用，向app中增加activity对应的package信息
//app中可能已经有对应的package信息了
app.addPackage(r.info.packageName, r.info.applicationInfo.versionCode,
mService.mProcessStats);
}

//通知进程启动目标Activity
realStartActivityLocked(r, app, andResume, checkConfig);
return;
} catch() {
............
}
}

//如果进程不存在，利用AMS的startProcessLocked函数，创建一个新的进程
mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
"activity", r.intent.getComponent(), false, false, true);
}

顺着流程，进入AMS的startProcessLocked函数：

//一大堆的参数，遇到了再分析吧。。。。。
final ProcessRecord startProcessLocked(..........) {
//转调用
return startProcessLocked(..........);
}

final ProcessRecord startProcessLocked(......) {
long startTime = SystemClock.elapsedRealtime();
ProcessRecord app;

//isolated为false
if (!isolated) {
//根据processName和uid寻找是否已经存在processRecord
app = getProcessRecordLocked(processName, info.uid, keepIfLarge);
..............

//FLAG_FROM_BACKGROUND表示发起这次启动的Task属于后台任务
//如果没有设置该标志，那么本次启动请求就是由前台Task触发的
if ((intentFlags & Intent.FLAG_FROM_BACKGROUND) != 0) {
// If we are in the background, then check to see if this process
// is bad.  If so, we will just silently fail.

//如果一个应用在1分钟内连续崩溃超过两次，AMS就会将其ProcessRecord加入到BadProcesses中
//正常情况下，一个应用崩溃后，系统会弹出一个警告框以提醒用户

//但是如果一个后台Task启动BadProcess，然后该Process崩溃，由于用户看不到该Process对应的界面，
//若弹出一个警告框，用户将觉得奇怪；因此，此处禁止后台Task启动BadProcess
if (mAppErrors.isBadProcessLocked(info)) {
........
return null;
}
} else {
// When the user is explicitly starting a process, then clear its
// crash count so that we won't make it bad until they see at
// least one crash dialog again, and make the process good again
// if it had been bad.
.........
//如果用户从界面主动选择启动一个Process，即使该Process是BadProcess，也不能禁止该操作
//而且还要清空对应Process的“不良”记录

//对比上面的代码，可以看出这其实是一种安全机制，防止不健全的程序不断启动潜在的崩溃组件，但该机制不限制用户行为
mAppErrors.resetProcessCrashTimeLocked(info);
if (mAppErrors.isBadProcessLocked(info)) {
........
mAppErrors.clearBadProcessLocked(info);
if (app != null) {
app.bad = false;
}
}
}
} else {
// If this is an isolated process, it can't re-use an existing process.
app = null;
}
.........
// We don't have to do anything more if:
// (1) There is an existing application record; and
// (2) The caller doesn't think it is dead, OR there is no thread
//     object attached to it so we know it couldn't have crashed; and
// (3) There is a pid assigned to it, so it is either starting or
//     already running.
............
if (app != null && app.pid > 0) {
if ((!knownToBeDead && !app.killed) || app.thread == null) {
// We already have the app running, or are waiting for it to
// come up (we have a pid but not yet its thread), so keep it.
............
// If this is a new package in the process, add the package to the list
//这个之前已经做过了，android代码写的比较冗余
app.addPackage(info.packageName, info.versionCode, mProcessStats);
..........
return app;
}

// An application record is attached to a previous process,
// clean it up now.
..............
//kill bad processes
.............
killProcessGroup(app.uid, app.pid);
handleAppDiedLocked(app, true, true);
..............
}
..................
if (app == null) {
..............
/创建出一个新的Process
app = newProcessRecordLocked(info, processName, isolated, isolatedUid);
..........
app.crashHandler = crashHandler;
.............
} else {
// If this is a new package in the process, add the package to the list
app.addPackage(info.packageName, info.versionCode, mProcessStats);
............
}

// If the system is not ready yet, then hold off on starting this
// process until it is.
if (!mProcessesReady
&& !isAllowedWhileBooting(info)
&& !allowWhileBooting) {
if (!mProcessesOnHold.contains(app)) {
mProcessesOnHold.add(app);
}
........
return app;
}
.............
//调用下一个startProcessLocked函数
startProcessLocked(
app, hostingType, hostingNameStr, abiOverride, entryPoint, entryPointArgs);
.......
return (app.pid != 0) ? app : null;
}

这段代码对是否应该创建新进程进行判断，若需要创建新进程，将进一步调用重载后的startProcessLocked函数。

private final void startProcessLocked(......) {
.................
//启动一个进程
//若AMS之前维持着这个进程的信息，那么现在需要移除
if (app.pid > 0 && app.pid != MY_PID) {
................
synchronized (mPidsSelfLocked) {
mPidsSelfLocked.remove(app.pid);
mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app);
}
...........
app.setPid(0);
}
..............
//mProcessesOnHold用于保存那些在系统还没有准备好就提前请求启动的ProcessRecord
mProcessesOnHold.remove(app);
..............
updateCpuStats();
.............
try {
try {
final int userId = UserHandle.getUserId(app.uid);
//通过PKMS检查待启动进程对应的package是否满足启动条件
AppGlobals.getPackageManager().checkPackageStartable(app.info.packageName, userId);
} catch (RemoteException e) {
throw e.rethrowAsRuntimeException();
}

int uid = app.uid;
int[] gids = null;
int mountExternal = Zygote.MOUNT_EXTERNAL_NONE;
if (!app.isolated) {
int[] permGids = null;
try {
final IPackageManager pm = AppGlobals.getPackageManager();
//通过PKMS得到进程对应的Gid
permGids = pm.getPackageGids(app.info.packageName,
MATCH_DEBUG_TRIAGED_MISSING, app.userId);
MountServiceInternal mountServiceInternal = LocalServices.getService(
MountServiceInternal.class);
//这里应该是判断进程对外部存储设备的访问模式
mountExternal = mountServiceInternal.getExternalStorageMountMode(uid,
app.info.packageName);
} catch (RemoteException e) {
..............
}

/*
* Add shared application and profile GIDs so applications can share some
* resources like shared libraries and access user-wide resources
*/
if (ArrayUtils.isEmpty(permGids)) {
gids = new int[2];
} else {
gids = new int[permGids.length + 2];
//permGid放到2，3号位置
System.arraycopy(permGids, 0, gids, 2, permGids.length);
}

//得到共享应用的gid信息
gids[0] = UserHandle.getSharedAppGid(UserHandle.getAppId(uid));
gids[1] = UserHandle.getUserGid(UserHandle.getUserId(uid));
}
................
//ABI表示应用程序二进制接口，ABI精确地定义了你的应用程序及其代码期在运行时如何和系统交互
String requiredAbi = (abiOverride != null) ? abiOverride : app.info.primaryCpuAbi;
if (requiredAbi == null) {
requiredAbi = Build.SUPPORTED_ABIS[0];
}

String instructionSet = null;
if (app.info.primaryCpuAbi != null) {
//得到对应的指令集
instructionSet = VMRuntime.getInstructionSet(app.info.primaryCpuAbi);
}

app.gids = gids;
app.requiredAbi = requiredAbi;
app.instructionSet = instructionSet;

// Start the process.  It will either succeed and return a result containing
// the PID of the new process, or else throw a RuntimeException.
..........................
//指定反射的className
if (entryPoint == null) entryPoint = "android.app.ActivityThread";

//Process.java的start函数，将通过socket发送消息给zygote
//zygote将派生出一个子进程，子进程将通过反射调用ActivityThread的main函数
//注意此时传递给zygote的参数并没有包含任何与Activity相关的信息
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);
...................
//增加电量统计项
mBatteryStatsService.noteProcessStart(app.processName, app.info.uid);
...................
if (app.persistent) {
//实际仅判断启动的进程是否为com.android.phone
//如果是Phone进程，watchdog将保留对应的pid
//watchdog打印dump日志时，会打印phone对应的dump信息
Watchdog.getInstance().processStarted(app.processName, startResult.pid);
}
..............
//利用启动的结果，更新ProcessRecord
app.setPid(startResult.pid);
app.usingWrapper = startResult.usingWrapper;
app.removed = false;
app.killed = false;
app.killedByAm = false;
...............
synchronized (mPidsSelfLocked) {
//AMS以键值对的形式，保存pid和processRecord
this.mPidsSelfLocked.put(startResult.pid, app);
if (isActivityProcess) {
Message msg = mHandler.obtainMessage(PROC_START_TIMEOUT_MSG);
msg.obj = app;
//发送一个延迟消息
//在消息被处理前，若新创建的进程没有和AMS交互，那么该进程启动失败
//正常延迟时间为10s
//若通过wrapper（例如valgrind）加载，应用程序将在wrapper的运行环境中工作，耗时较长，延迟时间在N中定义为1200s
mHandler.sendMessageDelayed(msg, startResult.usingWrapper
? PROC_START_TIMEOUT_WITH_WRAPPER : PROC_START_TIMEOUT);
}
}
............
} catch (RuntimeException e) {
...............
}
}

至此，startSpecificActivityLocked函数分析完毕，Android系统开始通过创建zygote创建应用进程。

总结

至此，AMS启动Activity的第一部分分析完毕。后续部分可以参考启动Activity的过程：二

这一部分相对比较杂乱，需要考虑Activity的启动模式、Intent Flags等信息，以决定Activity与Task之间的关系。

这部分代码还需要判断Activity是否复用，是否需要移动对应的Task到前台，及在必要时，按照启动模式和Intent Flags对Task中的内容进行调整。

最后，判断Activity对应的进程是否存在。若对应进程存在，进需要重启Activity；否则，需要发送消息给zygote启动进程。

整体来讲，这部分代码的流程基本可以用下图表示：



大图地址

自己对AMS的驾驭能力还不够，不能较好地精炼出最核心的流程，因此这部分分析不够简洁，

目前的分析只能算作一个代码阅读笔记，如有不恰当的地方，欢迎指正。