Activity启动流程(基于Android26)，Android开发必须要会

// 源 Activity 记录，即在哪个 Activity 进行 startActivity
ActivityRecord sourceRecord = null;
// 如果使用 startActivityForResult，result 返回的 Activity 称为结果 Activity
ActivityRecord resultRecord = null;
if (resultTo != null) {
// 获取 Activity Stack 中已经存在的源 Activity 记录
sourceRecord = mSupervisor.isInAnyStackLocked(resultTo);
if (sourceRecord != null) {
if (requestCode >= 0 && !sourceRecord.finishing) {
// requestCode >= 0，源 Activity 同时为 结果 Activity
resultRecord = sourceRecord;
}
}
}

final int launchFlags = intent.getFlags();

if ((launchFlags & Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0 && sourceRecord != null) {
// 使用 FLAG_ACTIVITY_FORWARD_RESULT，可以将返回结果的源 Activity 转移为当前正在新启动的 Activity
// 比如：A -> B,B - C 使用了 FLAG_ACTIVITY_FORWARD_RESULT,那么 C 的 setResult 会返回给 A
if (requestCode >= 0) {
// 不允许有 requestCode
ActivityOptions.abort(options);
return ActivityManager.START_FORWARD_AND_REQUEST_CONFLICT;
}
// 将源 Activity 的结果 Activity 设置为新 Activity 的结果 Activity
resultRecord = sourceRecord.resultTo;
if (resultRecord != null && !resultRecord.isInStackLocked()) {
resultRecord = null;
}
// requestCode 处理
resultWho = sourceRecord.resultWho;
requestCode = sourceRecord.requestCode;
sourceRecord.resultTo = null;
if (resultRecord != null) {
// 删除源 Activity 记录
resultRecord.removeResultsLocked(sourceRecord, resultWho, requestCode);
}
}

if (err == ActivityManager.START_SUCCESS && intent.getComponent() == null) {
// component 找不到
err = ActivityManager.START_INTENT_NOT_RESOLVED;
}

if (err == ActivityManager.START_SUCCESS && aInfo == null) {
// ActivityInfo 找不到
err = ActivityManager.START_CLASS_NOT_FOUND;
}

if (err == ActivityManager.START_SUCCESS && sourceRecord != null
&& sourceRecord.getTask().voiceSession != null) {
// 语音启动 Activity，检查是否符合
}

if (err == ActivityManager.START_SUCCESS && voiceSession != null) {
// 启动语音会话
}

final ActivityStack resultStack = resultRecord == null ? null : resultRecord.getStack();

if (err != START_SUCCESS) {
// 启动 Activity 失败
if (resultRecord != null) {
// 发送取消通知
resultStack.sendActivityResultLocked(
-1, resultRecord, resultWho, requestCode, RESULT_CANCELED, null);
}
ActivityOptions.abort(options);
return err;
}

// 进行一些权限检查，判断是否终止
if (abort) {
// 如果需要终止 Activity
if (resultRecord != null) {
resultStack.sendActivityResultLocked();
}
// 返回启动成功，实际终止
ActivityOptions.abort(options);
return START_SUCCESS;
}

// 如果权限检查是否在启动 Activity 之前，那么先启动权限检查的 Intent

// 处理 ephemeral app

// 构造一个 ActivityRecord
ActivityRecord r = new ActivityRecord();

final ActivityStack stack = mSupervisor.mFocusedStack;
if (voiceSession == null && (stack.mResumedActivity == null
|| stack.mResumedActivity.info.applicationInfo.uid != callingUid)) {
// 前台 stack 还没 resume 状态的 Activity，检查是否允许 app 切换
if (!mService.checkAppSwitchAllowedLocked() {
PendingActivityLaunch pal = new PendingActivityLaunch();
mPendingActivityLaunches.add(pal);
ActivityOptions.abort(options);
// 切换 app 失败
return ActivityManager.START_SWITCHES_CANCELED;
}
}

if (mService.mDidAppSwitch) {
// 从上次禁止 app 切换以来，这是第二次，允许 app 切换，并将切换时间设置为 0
mService.mAppSwitchesAllowedTime = 0;
} else {
mService.mDidAppSwitch = true;
}

// 执行因为不允许 app 切换，而加到等待启动的 Activity
doPendingActivityLaunchesLocked(false);

return startActivity();
}

private int startActivity() {
int result = START_CANCELED;
try {
mService.mWindowManager.deferSurfaceLayout();
// 下一步流程
result = startActivityUnchecked();
} finally {
// 如果启动 Activity 没有成功， 从 task 中移除 Activity
if (!ActivityManager.isStartResultSuccessful(result)
&& mStartActivity.getTask() != null) {
mStartActivity.getTask().removeActivity(mStartActivity);
}
mService.mWindowManager.continueSurfaceLayout();
}

postStartActivityProcessing();

return result;
}

private int startActivityUnchecked() {

// 设置一些初始化状态
setInitialState();
// 计算 launch flags
computeLaunchingTaskFlags();
//