启动一个桌面 Activity（即点击应用图标启动）是一个涉及多个进程交互的复杂过程。简单来说，它分为发起请求、系统处理、创建进程、初始化应用 和生命周期回调几个核心阶段。
阶段一：发起请求，从Launcher到系统服务
当你点击桌面图标时，Launcher应用会调用startActivity()。这个调用会通过Instrumentation类，最终通过AIDL（Android接口定义语言）跨进程调用到系统服务ActivityTaskManagerService（ATMS）的startActivity()方法。
- 跨进程通信 ：应用进程与系统服务（运行在
system_server进程）的通信，核心是ApplicationThread这个Binder对象，它被传递给ATMS，作为系统向应用进程发送回调的"通道"。
scss
//frameworks/base/core/java/android/app/ContextImpl.java
public void startActivity(Intent intent, Bundle options) {
//检查调用方是否为系统进程
warnIfCallingFromSystemProcess();
//targetSdkVersion校验
//Android N 之前必须加 NEW_TASK 标志
//Android N - Android O允许不加 NEW_TASK（兼容期）
//Android P 及以上 恢复强制要求 NEW_TASK
final int targetSdkVersion = getApplicationInfo().targetSdkVersion;
if ((intent.getFlags() & Intent.FLAG_ACTIVITY_NEW_TASK) == 0
&& (targetSdkVersion < Build.VERSION_CODES.N
|| targetSdkVersion >= Build.VERSION_CODES.P)
&& (options == null
|| ActivityOptions.fromBundle(options).getLaunchTaskId() == -1)) {
throw new AndroidRuntimeException(
"Calling startActivity() from outside of an Activity "
+ " context requires the FLAG_ACTIVITY_NEW_TASK flag."
+ " Is this really what you want?");
}
//mMainThread = ActivityThread
//Instrumentation.execStartActivity()
mMainThread.getInstrumentation().execStartActivity(
getOuterContext(), mMainThread.getApplicationThread(), null,
(Activity) null, intent, -1, options);
}
//frameworks/base/core/java/android/app/Instrumentation.java
Context who, // 调用上下文
IBinder contextThread, // 应用主线程
IBinder token, // Activity Token
Activity target, // 目标 Activity（可为null）
Intent intent, // 启动意图
int requestCode, // 请求码
Bundle options // 启动选项
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
IApplicationThread whoThread = (IApplicationThread) contextThread;
//获取其referrer信息, 用于来源统计和安全校验（如防止点击劫持）
Uri referrer = target != null ? target.onProvideReferrer() : null;
if (referrer != null) {
intent.putExtra(Intent.EXTRA_REFERRER, referrer);
}
...
try {
intent.migrateExtraStreamToClipData(who); //处理大文件传输（URI权限）
intent.prepareToLeaveProcess(who); //准备跨进程传递
int result =
//ActivityTaskManagerService.startActivity()
ActivityTaskManager.getService().startActivity(whoThread,
who.getOpPackageName(), who.getAttributionTag(), 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;
}
//frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
public final int startActivity(IApplicationThread caller, String callingPackage,
String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo,
String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo,
Bundle bOptions) {
return startActivityAsUser(caller, callingPackage, callingFeatureId, intent, resolvedType,
resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions,
UserHandle.getCallingUserId());
}
private int startActivityAsUser(IApplicationThread caller, String callingPackage,
@Nullable String callingFeatureId, Intent intent, String resolvedType,
IBinder resultTo, String resultWho, int requestCode, int startFlags,
ProfilerInfo profilerInfo, Bundle bOptions, int userId, boolean validateIncomingUser) {
//确保调用包名与 UID 匹配，防止伪造包名
assertPackageMatchesCallingUid(callingPackage);
//禁止孤立进程（Isolated Process）启动 Activity，
//这类进程通常用于 WebView 渲染等沙箱场景
enforceNotIsolatedCaller("startActivityAsUser");
//校验目标用户是否合法
userId = getActivityStartController().checkTargetUser(userId, validateIncomingUser,
Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
//将启动参数封装为 `ActivityStarter` 对象
return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
.setCaller(caller)
.setCallingPackage(callingPackage)
.setCallingFeatureId(callingFeatureId)
.setResolvedType(resolvedType)
.setResultTo(resultTo)
.setResultWho(resultWho)
.setRequestCode(requestCode)
.setStartFlags(startFlags)
.setProfilerInfo(profilerInfo)
.setActivityOptions(bOptions)
.setUserId(userId)
.execute();
}阶段二：系统处理，解析与调度
ATMS接收到启动请求后，真正干活的"幕后管家"是ActivityStarter。它负责处理启动过程中的核心逻辑：
-
Intent解析与校验 ：根据
Intent找到要启动的目标Activity，并校验其在AndroidManifest.xml中是否声明、调用方是否有权限等。 -
任务栈与启动模式计算 ：根据
android:launchMode和Intent中的FLAG_ACTIVITY_*标志，计算目标Activity应该放在哪个任务栈（Task）中。 -
判断进程状态：最重要的一步，检查目标应用进程是否存在。
- 如果进程已存在（热启动），则直接通知该进程创建Activity实例。
- 如果进程不存在（冷启动），则需要请求创建一个新的应用进程。
scss
//frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
## 性能优化点
1. **对象池复用**：`ActivityStarter` 对象不频繁创建
2. **锁粒度优化**：仅在必要时持锁
3. **延迟解析**：避免不必要的 PackageManager 查询
4. **异步日志**：`ActivityMetricsLogger` 异步记录
int execute() {
try {
//禁止通过 Intent 传递 FileDescriptor
//原因：FD 是进程级资源，跨进程传递会导致**资源泄露**和**安全问题**
//正确方式：使用 `ContentProvider` 或 `FileProvider` 共享文件
if (mRequest.intent != null && mRequest.intent.hasFileDescriptors()) {
throw new IllegalArgumentException("File descriptors passed in Intent");
}
...
if (mRequest.activityInfo == null) {
//Intent 解析（延迟解析）
//查询PackageManager,处理Intent过滤匹配, 处理组件别名activity-alias
mRequest.resolveActivity(mSupervisor);
}
if (mRequest.intent != null) {
String intentAction = mRequest.intent.getAction();
String callingPackage = mRequest.callingPackage;
//特殊处理关机/重启 Intent,`ShutdownCheckPoints` 用于记录关机操作
//的调用来源
if (intentAction != null && callingPackage != null
&& (Intent.ACTION_REQUEST_SHUTDOWN.equals(intentAction)
|| Intent.ACTION_SHUTDOWN.equals(intentAction)
|| Intent.ACTION_REBOOT.equals(intentAction))) {
ShutdownCheckPoints.recordCheckPoint(intentAction, callingPackage, null);
}
}
int res;
synchronized (mService.mGlobalLock) {
//检查是否需要全局配置变更（如：语言、屏幕方向、密度等）
final boolean globalConfigWillChange = mRequest.globalConfig != null
&& mService.getGlobalConfiguration().diff(mRequest.globalConfig) != 0;
final Task rootTask = mRootWindowContainer.getTopDisplayFocusedRootTask();
if (rootTask != null) {
rootTask.mConfigWillChange = globalConfigWillChange;
}
final long origId = Binder.clearCallingIdentity();
...
//最核心的启动逻辑
res = executeRequest(mRequest);
Binder.restoreCallingIdentity(origId);
//如果配置变更
if (globalConfigWillChange) {
//权限检查
mService.mAmInternal.enforceCallingPermission(
android.Manifest.permission.CHANGE_CONFIGURATION,
"updateConfiguration()");
if (rootTask != null) {
rootTask.mConfigWillChange = false;
}
//更新配置
mService.updateConfigurationLocked(mRequest.globalConfig, null, false);
}
...
//通知监控系统启动完成 ,用于 **ANR 检测**、**启动耗时统计** mSupervisor.getActivityMetricsLogger().notifyActivityLaunched(launchingState, res,
newActivityCreated, mLastStartActivityRecord, originalOptions);
if (mRequest.waitResult != null) {
mRequest.waitResult.result = res;
//同步等待启动完成,
//主要用于 `startActivityForResult` 或测试场景
//会阻塞直到 Activity 完全启动并绘制完成
res = waitResultIfNeeded(mRequest.waitResult, mLastStartActivityRecord,
launchingState);
}
//`START_SUCCESS` → `Activity.RESULT_OK`
return getExternalResult(res);
}
} finally {
//释放 `ActivityStarter` 对象回对象池,重置内部状态
onExecutionComplete();
}
}
private int executeRequest(Request request) {
//每个启动请求必须有 `reason`（用于调试和日志）
if (TextUtils.isEmpty(request.reason)) {
throw new IllegalArgumentException("Need to specify a reason.");
}
//提取所有参数到局部变量（性能优化）
mLastStartReason = request.reason;
mLastStartActivityTimeMs = System.currentTimeMillis();
mLastStartActivityRecord = null;
final IApplicationThread caller = request.caller;
Intent intent = request.intent;
...
WindowProcessController callerApp = null;
//调用者进程解析
if (caller != null) {
callerApp = mService.getProcessController(caller);
if (callerApp != null) {
callingPid = callerApp.getPid();
callingUid = callerApp.mInfo.uid;
} else {
// 如果进程不存在，返回权限拒绝
err = ActivityManager.START_PERMISSION_DENIED;
}
}
final int userId = aInfo != null && aInfo.applicationInfo != null
? UserHandle.getUserId(aInfo.applicationInfo.uid) : 0;
if (err == ActivityManager.START_SUCCESS) {
}
ActivityRecord sourceRecord = null;
ActivityRecord resultRecord = null;
//`resultTo` 是启动者的 Activity Token
if (resultTo != null) {
//查找对应的 `ActivityRecord`，用于 `startActivityForResult`
sourceRecord = mRootWindowContainer.isInAnyTask(resultTo);
if (sourceRecord != null) {
if (requestCode >= 0 && !sourceRecord.finishing) {
resultRecord = sourceRecord;
}
}
}
final int launchFlags = intent.getFlags();
//FLAG_ACTIVITY_FORWARD_RESULT 处理
if ((launchFlags & Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0 && sourceRecord != null) {
//冲突
if (requestCode >= 0) {
SafeActivityOptions.abort(options);
return ActivityManager.START_FORWARD_AND_REQUEST_CONFLICT;
}
//将结果传递链转发
resultRecord = sourceRecord.resultTo;
if (resultRecord != null && !resultRecord.isInRootTaskLocked()) {
resultRecord = null;
}
resultWho = sourceRecord.resultWho;
requestCode = sourceRecord.requestCode;
sourceRecord.resultTo = null;
if (resultRecord != null) {
resultRecord.removeResultsLocked(sourceRecord, resultWho, requestCode);
}
if (sourceRecord.launchedFromUid == callingUid) {
callingPackage = sourceRecord.launchedFromPackage;
callingFeatureId = sourceRecord.launchedFromFeatureId;
}
}
...
//调用者是否有权限启动目标 Activity
boolean abort = !mSupervisor.checkStartAnyActivityPermission(intent, aInfo, resultWho,
requestCode, callingPid, callingUid, callingPackage, callingFeatureId,
request.ignoreTargetSecurity, inTask != null, callerApp, resultRecord,
resultRootTask);
//系统级 Intent 防火墙（由 OEM 或 IT 策略配置）
abort |= !mService.mIntentFirewall.checkStartActivity(intent, callingUid,
callingPid, resolvedType, aInfo.applicationInfo);
//Android 10+ 的权限策略检查
abort |= !mService.getPermissionPolicyInternal().checkStartActivity(intent, callingUid,
callingPackage);
boolean restrictedBgActivity = false;
if (!abort) {
try {
restrictedBgActivity =
//后台 Activity 启动限制 (Android 10+),防止后台应用突然弹窗干扰用户
//触发条件：应用在后台, 没有 `SYSTEM_ALERT_WINDOW` 权限,没有用户交互
//违反时会静默失败或通知用户
shouldAbortBackgroundActivityStart(callingUid,
callingPid, callingPackage, realCallingUid, realCallingPid, callerApp,
request.originatingPendingIntent, request.allowBackgroundActivityStart,
intent);
} finally {
Trace.traceEnd(Trace.TRACE_TAG_WINDOW_MANAGER);
}
}
...
//创建 ActivityRecord
final ActivityRecord r = new ActivityRecord.Builder(mService)
.setCaller(callerApp)
.setLaunchedFromPid(callingPid)
.setLaunchedFromUid(callingUid)
.setLaunchedFromPackage(callingPackage)
.setLaunchedFromFeature(callingFeatureId)
.setIntent(intent)
.setResolvedType(resolvedType)
.setActivityInfo(aInfo)
.setConfiguration(mService.getGlobalConfiguration())
.setResultTo(resultRecord)
.setResultWho(resultWho)
.setRequestCode(requestCode)
.setComponentSpecified(request.componentSpecified)
.setRootVoiceInteraction(voiceSession != null)
.setActivityOptions(checkedOptions)
.setSourceRecord(sourceRecord)
.build();
mLastStartActivityRecord = r;
...
//执行启动
mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession,
request.voiceInteractor, startFlags, true /* doResume */, checkedOptions, inTask,
restrictedBgActivity, intentGrants);
if (request.outActivity != null) {
request.outActivity[0] = mLastStartActivityRecord;
}
return mLastStartActivityResult;
}
//它是 Activity 启动流程中任务栈管理的前置处理层，
//负责协调窗口过渡动画、延迟布局和调用真正的栈操作
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, Task inTask,
boolean restrictedBgActivity, NeededUriGrants intentGrants) {
int result = START_CANCELED;
final Task startedActivityRootTask;
//Transition（过渡动画）
//替代旧的 `ActivityOptions.makeSceneTransitionAnimation()`
//支持跨 Activity/Window 的复杂动画编排
//创建过渡动画
final Transition newTransition = (!mService.getTransitionController().isCollecting()
&& mService.getTransitionController().getTransitionPlayer() != null)
? mService.getTransitionController().createTransition(TRANSIT_OPEN) : null;
//远程过渡动画:由其他进程（如 Launcher）提供的动画
//用于跨进程转场（例如：从 Launcher 启动应用）
//`takeRemoteTransition()` 从 ActivityRecord 中取出预置的远程动画
IRemoteTransition remoteTransition = r.takeRemoteTransition();
if (newTransition != null && remoteTransition != null) {
newTransition.setRemoteTransition(remoteTransition);
}
//收集动画参与者
mService.getTransitionController().collect(r);
try {
//延迟窗口布局（性能优化）
//1.暂停窗口布局计算
//2.批量处理多个窗口变化
//3.减少重绘次数，提升启动性能
mService.deferWindowLayout();
//启动Activity
result = startActivityInner(r, sourceRecord, voiceSession, voiceInteractor,
startFlags, doResume, options, inTask, restrictedBgActivity, intentGrants);
} finally {
//启动结果处理
//返回结果所在的 RootTask，用于后续动画和日志
startedActivityRootTask = handleStartResult(r, result);
mService.continueWindowLayout();
mSupervisor.mUserLeaving = false;
// Transition housekeeping
if (!ActivityManager.isStartResultSuccessful(result)) {
if (newTransition != null) {
//终止动画
newTransition.abort();
}
} else {
//允许移动到前台，需要 Resume (`mDoResume`)，
//启动者的 UID 在通知栏上方有可见窗口，
//启动者不是通知栏所有者
if (!mAvoidMoveToFront && mDoResume
&& mRootWindowContainer.hasVisibleWindowAboveButDoesNotOwnNotificationShade(
r.launchedFromUid)) {
StatusBarManagerInternal statusBar = mService.getStatusBarManagerInternal();
if (statusBar != null) {
//收起通知栏，防止通知栏遮挡新启动的 Activity
statusBar.collapsePanels();
}
}
if (result == START_SUCCESS || result == START_TASK_TO_FRONT) {
mService.getTransitionController().collectExistenceChange(r);
}
if (newTransition != null) {
//启动动画 mService.getTransitionController().requestStartTransition(newTransition,
mTargetTask, remoteTransition);
} else {
mService.getTransitionController().setReady(false);
}
}
}
//执行后续清理工作
postStartActivityProcessing(r, result, startedActivityRootTask);
return result;
}
- `r`：要启动的 Activity 记录
- `sourceRecord`：发起启动的源 Activity
- `voiceSession`/`voiceInteractor`：语音交互相关
- `startFlags`：启动标志
- `doResume`：是否立即恢复
- `options`：启动选项（动画、尺寸等）
- `inTask`：指定放入的 Task
- `restrictedBgActivity`：是否受限后台启动
- `intentGrants`：URI 权限授予信息
int startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, Task inTask,
boolean restrictedBgActivity, NeededUriGrants intentGrants) {
...
//根据 Intent Flags 和 LaunchMode 计算启动任务标志
computeLaunchingTaskFlags();
//计算源 Activity 所在的 RootTask（根任务容器）。
//从 `mSourceRecord` 追溯其所属的 RootTask。
computeSourceRootTask();
mIntent.setFlags(mLaunchFlags);
//将计算后的最终启动标志设置回 Intent 中。
final Task reusedTask = getReusableTask();
//冻结最近任务列表的重排序
if (mOptions != null && mOptions.freezeRecentTasksReordering()
&& mSupervisor.mRecentTasks.isCallerRecents(r.launchedFromUid)
&& !mSupervisor.mRecentTasks.isFreezeTaskListReorderingSet()) {
mFrozeTaskList = true;
mSupervisor.mRecentTasks.setFreezeTaskListReordering();
}
//查找是否有可以复用的 Task
//复用条件包括：
//1. `FLAG_ACTIVITY_NEW_TASK` 且 `taskAffinity` 匹配
//2. `singleTask` 或 `singleInstance` 模式
//3. `allowTaskReparenting` 为 true
// 如果有复用 Task，使用它
//否则调用 `computeTargetTask()` 计算目标
final Task targetTask = reusedTask != null ? reusedTask : computeTargetTask();
//`newTask = true` 表示需要创建新 Task
final boolean newTask = targetTask == null;
mTargetTask = targetTask;
//计算启动参数，主要是窗口尺寸和位置：
//1. 如果 `options` 中指定了尺寸，使用指定值
//2. 否则从源 Activity 继承或使用默认值
//3. 用于分屏、自由窗口等场景
computeLaunchParams(r, sourceRecord, targetTask);
// 启动许可检查。
//检查项：
//1. 权限检查（`checkStartAnyActivityPermission`）
//2. 设备策略限制（锁屏、设备管理器）
//3. 是否允许创建新 Task
//4. 是否允许在指定 Task 中启动
//返回 `START_SUCCESS` 或错误码。
int startResult = isAllowedToStart(r, newTask, targetTask);
if (startResult != START_SUCCESS) {
return startResult;
}
//获取目标 Task 的栈顶 Activity（非 finishing 状态）。
//如果是新 Task，为 null
//否则从 targetTask 获取顶部 Activity
final ActivityRecord targetTaskTop = newTask
? null : targetTask.getTopNonFinishingActivity();
if (targetTaskTop != null) {
//Task 回收/复用处理。
//如果 Task 有顶部 Activity：
//调用 `recycleTask()`，执行：
//1. 如果目标 Activity 已在栈顶 → 调用 `onNewIntent()`
//2. 如果目标 Activity 在栈中 → 清除其上所有 Activity
//3. 处理 `FLAG_ACTIVITY_CLEAR_TOP`
//4. 处理 `FLAG_ACTIVITY_SINGLE_TOP`
//如果 Task 为空：设置 `mAddingToTask = true`，
//表示要向空 Task 添加 Activity。
startResult = recycleTask(targetTask, targetTaskTop, reusedTask, intentGrants);
if (startResult != START_SUCCESS) {
return startResult;
}
} else {
mAddingToTask = true;
}
//处理栈顶重复启动。
//获取当前聚焦的 RootTask，调用 `deliverToCurrentTopIfNeeded()`：
//场景：当前栈顶是 Activity A，再次启动 A
final Task topRootTask = mPreferredTaskDisplayArea.getFocusedRootTask();
if (topRootTask != null) {
startResult = deliverToCurrentTopIfNeeded(topRootTask, intentGrants);
if (startResult != START_SUCCESS) {
return startResult;
}
}
if (mTargetRootTask == null) {
//获取/计算启动 RootTask。
//如果尚未设置目标 RootTask：
//根据 `launchFlags` 和 `targetTask` 计算
//选择根容器（RootTaskContainer 或 DisplayArea）
mTargetRootTask = getLaunchRootTask(mStartActivity, mLaunchFlags, targetTask, mOptions);
}
//创建新 Task 或添加到已有 Task。
if (newTask) {
//如果 `mLaunchTaskBehind` 为 true 且有源 Activity，
//关联到源 Task
final Task taskToAffiliate = (mLaunchTaskBehind && mSourceRecord != null)
? mSourceRecord.getTask() : null;
//创建 Task,设置 Affinity、TaskId、DisplayId
setNewTask(taskToAffiliate);
} else if (mAddingToTask) {
//将 Activity 添加或移动到 targetTask
addOrReparentStartingActivity(targetTask, "adding to task");
}
//允许移到前台且 `mDoResume`（需要恢复）
if (!mAvoidMoveToFront && mDoResume) {
//将 Task 移到前台,将 RootTask 移到显示区域最前面
mTargetRootTask.getRootTask().moveToFront("reuseOrNewTask", targetTask);
if (mOptions != null) {
if (mOptions.getTaskAlwaysOnTop()) {
//设置 Task 置顶
mTargetRootTask.setAlwaysOnTop(true);
}
}
//如果目标 Task 不在最前面，
//且系统处于 Dream（屏保/白日梦）状态
if (!mTargetRootTask.isTopRootTaskInDisplayArea() && mService.mInternal.isDreaming()) {
//1.将 Activity 启动在 Dream 后面
//2.设置 `mLaunchTaskBehind = true`
//3.这样 Activity 在可见状态下启动，但被 Dream 遮挡
mLaunchTaskBehind = true;
r.mLaunchTaskBehind = true;
}
}
//从 Intent 中提取 URI 权限授予信息
mService.mUgmInternal.grantUriPermissionUncheckedFromIntent(intentGrants,
mStartActivity.getUriPermissionsLocked());
//隐式权限授予（Android 10+ 特性）
if (mStartActivity.resultTo != null && mStartActivity.resultTo.info != null) {
final PackageManagerInternal pmInternal =
mService.getPackageManagerInternalLocked();
// 获取结果接收者的 UID
final int resultToUid = pmInternal.getPackageUid(
mStartActivity.resultTo.info.packageName, 0 /* flags */,
mStartActivity.mUserId);
//授予隐式权限,简化跨应用组件调用的权限管理
pmInternal.grantImplicitAccess(mStartActivity.mUserId, mIntent,
UserHandle.getAppId(mStartActivity.info.applicationInfo.uid) /*recipient*/,
resultToUid /*visible*/, true /*direct*/);
}
...
//清空目标 RootTask 的最后暂停 Activity。
mTargetRootTask.mLastPausedActivity = null;
//启动电源模式（如果必要）
//用于处理低功耗场景
//启动 Activity 可能需要提升 CPU/GPU 频率
//`forceSend = false`：仅在必要时发送
mRootWindowContainer.startPowerModeLaunchIfNeeded(
false /* forceSend */, mStartActivity);
//添加 Activity 到 Task
mTargetRootTask.startActivityLocked(mStartActivity,
topRootTask != null ? topRootTask.getTopNonFinishingActivity() : null, newTask,
mKeepCurTransition, mOptions, sourceRecord);
if (mDoResume) {
//处理Resume
final ActivityRecord topTaskActivity =
mStartActivity.getTask().topRunningActivityLocked();
//没有焦点或 Task Overlay
if (!mTargetRootTask.isTopActivityFocusable()
|| (topTaskActivity != null && topTaskActivity.isTaskOverlay()
&& mStartActivity != topTaskActivity)) {
//确保所有 Activity 可见（但不获取焦点）
mTargetRootTask.ensureActivitiesVisible(null /* starting */,
0 /* configChanges */, !PRESERVE_WINDOWS);
//执行过渡动画
mTargetRootTask.mDisplayContent.executeAppTransition();
} else {
// 如果目标 RootTask 有焦点但不在最前面，移到最前面
if (mTargetRootTask.isTopActivityFocusable()
&& !mRootWindowContainer.isTopDisplayFocusedRootTask(mTargetRootTask)) {
mTargetRootTask.moveToFront("startActivityInner");
}
//恢复栈顶 Activity ，RootWindowContainer
mRootWindowContainer.resumeFocusedTasksTopActivities(
mTargetRootTask, mStartActivity, mOptions, mTransientLaunch);
}
}
//更新用户与 RootTask 的映射
//用于多用户支持，关联用户 ID 和对应的 RootTask
mRootWindowContainer.updateUserRootTask(mStartActivity.mUserId, mTargetRootTask);
// 更新最近任务列表
//将当前 Task 添加到 Recents
//确保用户可以通过最近任务切换回来
mSupervisor.mRecentTasks.add(mStartActivity.getTask());
//处理不可调整大小的 Task。
//1.用于分屏/多窗口场景
//2.如果 Task 不支持调整大小，进行相应处理
//3.`mPreferredWindowingMode`：偏好窗口模式（全屏/分屏/自由窗口）
mSupervisor.handleNonResizableTaskIfNeeded(mStartActivity.getTask(),
mPreferredWindowingMode, mPreferredTaskDisplayArea, mTargetRootTask);
//返回成功
return START_SUCCESS;
}
//添加目标Activity 到 Task
//frameworks/base/services/core/java/com/android/server/wm/Task.java
- `r`：要启动的 ActivityRecord
- `focusedTopActivity`：当前聚焦的顶部 Activity（用于 PIP 判断）
- `newTask`：是否是新 Task
- `keepCurTransition`：是否保持当前过渡动画
- `options`：启动选项
- `sourceRecord`：源 Activity
void startActivityLocked(ActivityRecord r, @Nullable ActivityRecord focusedTopActivity,
boolean newTask, boolean keepCurTransition, ActivityOptions options,
@Nullable ActivityRecord sourceRecord) {
//获取 r 所属的 Task。此时 r 已经在之前的步骤中被分配了 Task
Task rTask = r.getTask();
//**检查是否允许移到前台**：
//`options == null`：允许（没有限制）
//`options.getAvoidMoveToFront()`：如果为 true，禁止移到前台（分屏场景使用）
final boolean allowMoveToFront = options == null || !options.getAvoidMoveToFront();
//**检查 Task 关系**：
//`rTask == this`：r 的 Task 就是当前 RootTask
// `hasChild(rTask)`：当前 RootTask 包含 rTask（用于 Task 嵌套）
final boolean isOrhasTask = rTask == this || hasChild(rTask);
// mLaunchTaskBehind tasks get placed at the back of the task stack.
if (!r.mLaunchTaskBehind && allowMoveToFront && (!isOrhasTask || newTask)) {
//`!r.mLaunchTaskBehind`：不是"启动在背后"模式
//`allowMoveToFront`：允许移到前台
// `(!isOrhasTask || newTask)`：Task 不属于当前 RootTask，或者是新 Task
//将 Task 移到 RootTask 顶部**。
positionChildAtTop(rTask);
}
Task task = null;
//非新 Task (`!newTask`) 且 Task 属于当前 RootTask (`isOrhasTask`)
if (!newTask && isOrhasTask) {
//检查目标 Activity 上面是否有遮挡 Activity
final ActivityRecord occludingActivity = getOccludingActivityAbove(r);
// 如果有遮挡 Activity：
if (occludingActivity != null) {
//直接将 Activity 添加到 Task 顶部 (`positionChildAtTop(r)`)
//Abort options
//`return` 提前返回，不启动 Activity
//等用户导航回来再启动
rTask.positionChildAtTop(r);
ActivityOptions.abort(options);
return;
}
}
//获取 r 所在的 Task
final Task activityTask = r.getTask();
if (task == activityTask && mChildren.indexOf(task) != (getChildCount() - 1)) {
//task 变量（之前声明）等于 activityTask
//该 Task 不在 RootTask 的最后一个位置（即不在最前面）
//设置 `mTaskSupervisor.mUserLeaving = false`
//当新 Activity 启动在背后时，不触发前台 Activity 的 `onUserLeaving()` 回调
mTaskSupervisor.mUserLeaving = false;
}
task = activityTask;
//**将 Activity 添加到 Task 顶部**。
task.positionChildAtTop(r);
//不是空的 Home/Recents Task，或者该 Task 有 Activity
//允许移到前台
if ((!isHomeOrRecentsRootTask() || hasActivity()) && allowMoveToFront) {
final DisplayContent dc = mDisplayContent;
//**准备过渡动画**。
if ((r.intent.getFlags() & Intent.FLAG_ACTIVITY_NO_ANIMATION) != 0) {
//设置无动画
dc.prepareAppTransition(TRANSIT_NONE);
//添加到无动画列表
mTaskSupervisor.mNoAnimActivities.add(r);
} else {
// 默认动画类型
int transit = TRANSIT_OLD_ACTIVITY_OPEN;
if (newTask) {
if (r.mLaunchTaskBehind) {
//设置动画类型
transit = TRANSIT_OLD_TASK_OPEN_BEHIND;
} else {
if (canEnterPipOnTaskSwitch(focusedTopActivity,
null /* toFrontTask */, r, options)) {
focusedTopActivity.supportsEnterPipOnTaskSwitch = true;
}
//设置动画类型
transit = TRANSIT_OLD_TASK_OPEN;
}
}
//准备打开过渡动画
dc.prepareAppTransition(TRANSIT_OPEN);
//从无动画列表移除
mTaskSupervisor.mNoAnimActivities.remove(r);
}
//是否显示启动窗口
boolean doShow = true;
if (newTask) {
if ((r.intent.getFlags() & Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) != 0) {
//重置 Task（移动匹配 Affinity 的 Activity）
resetTaskIfNeeded(r, r);
//如果 r 是栈顶 Activity，显示启动窗口
doShow = topRunningNonDelayedActivityLocked(null) == r;
}
} else if (options != null && options.getAnimationType()
== ActivityOptions.ANIM_SCENE_TRANSITION) {
//如果使用场景过渡动画
//不显示启动窗口（场景过渡有自己的加载状态）
doShow = false;
}
//**是否显示启动窗口**
if (r.mLaunchTaskBehind) {
r.setVisibility(true);
//确保所有 Activity 可见
ensureActivitiesVisible(null, 0, !PRESERVE_WINDOWS);
//立即执行过渡动画（不通过 Resume 通道）
mDisplayContent.executeAppTransition();
} else if (SHOW_APP_STARTING_PREVIEW && doShow) {
Task prevTask = r.getTask();
//获取有启动窗口的顶部 Activity
ActivityRecord prev = prevTask.topActivityWithStartingWindow();
if (prev != null) {
//在不同 Task，不复用
if (prev.getTask() != prevTask) {
prev = null;
}
//已可见，不复用
else if (prev.nowVisible) {
prev = null;
}
}
//显示启动窗口
r.showStartingWindow(prev, newTask, isTaskSwitch(r, focusedTopActivity),
true /* startActivity */, sourceRecord);
}
} else {
//不需要动画，因为没有任何东西在它上面做动画
// 释放 options 资源
ActivityOptions.abort(options);
}
}
//恢复栈顶Activity（包含刚添加到栈顶的Activity）
//frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java
boolean resumeFocusedTasksTopActivities(
Task targetRootTask, ActivityRecord target, ActivityOptions targetOptions,
boolean deferPause) {
if (!mTaskSupervisor.readyToResume()) {
return false;
}
boolean result = false;
//有指定的目标 RootTask，目标 RootTask 在显示区域顶部，目标 RootTask有焦点
if (targetRootTask != null && (targetRootTask.isTopRootTaskInDisplayArea()
|| getTopDisplayFocusedRootTask() == targetRootTask)) {
//执行 Resume
//启动新 Activity
result = targetRootTask.resumeTopActivityUncheckedLocked(target, targetOptions,
deferPause);
}
//**遍历所有 Display**（从后往前，即从最顶层开始）
//支持多显示器场景（外接屏幕、投屏等）。
for (int displayNdx = getChildCount() - 1; displayNdx >= 0; --displayNdx) { //获取当前 DisplayContent
final DisplayContent display = getChildAt(displayNdx);
//保存之前的执行结果
final boolean curResult = result;
boolean[] resumedOnDisplay = new boolean[1];
//**遍历当前 Display 下的所有 RootTask**
display.forAllRootTasks(rootTask -> {
//获取当前 RootTask 的顶部 Activity。
final ActivityRecord topRunningActivity = rootTask.topRunningActivity();
if (!rootTask.isFocusableAndVisible() || topRunningActivity == null) { //RootTask没有焦点或不可见，没有正在运行的 Activity
return;
}
//如果当前 RootTask 就是目标 RootTask：
if (rootTask == targetRootTask) {
//将之前的结果保存到 `resumedOnDisplay`
resumedOnDisplay[0] |= curResult;
return;
}
//**处理非目标 RootTask**：
//**RootTask 在顶部且 Activity 已处于 RESUMED 状态**
if (rootTask.getDisplayArea().isTopRootTask(rootTask)
&& topRunningActivity.isState(RESUMED)) {
//执行过渡动画
//确保动画正确执行，但不需要额外的生命周期变化
rootTask.executeAppTransition(targetOptions);
} else {
//尝试激活该 Activity
//会检查是否需要 Resume/Pause
resumedOnDisplay[0] |= topRunningActivity.makeActiveIfNeeded(target);
}
});
//**合并结果**。如果任一 Display 有 Resume 操作，整体结果为 true。
result |= resumedOnDisplay[0];
//**处理当前 Display 没有任何 Resume 的情况**。
if (!resumedOnDisplay[0]) {
//获取当前 Display 的聚焦 RootTask。
final Task focusedRoot = display.getFocusedRootTask();
//如果有聚焦的 RootTask
if (focusedRoot != null) {
result |= focusedRoot.resumeTopActivityUncheckedLocked(target, targetOptions);
} else if (targetRootTask == null) {
//启动 Home Activity（桌面）
result |= resumeHomeActivity(null /* prev */, "no-focusable-task",
display.getDefaultTaskDisplayArea());
}
}
}
return result;
}
//frameworks/base/services/core/java/com/android/server/wm/Task.java
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options,
boolean deferPause) {
//如果是正在执行Resume的Activity
if (mInResumeTopActivity) {
return false;
}
boolean someActivityResumed = false;
try {
mInResumeTopActivity = true;
//检查是否直接包含 Activity（没有子 Task）
if (isLeafTask()) {
//检查是否可聚焦且可见
if (isFocusableAndVisible()) {
//执行真正的 Resume
someActivityResumed = resumeTopActivityInnerLocked(prev, options, deferPause);
}
} else {
//非叶子 Task 处理（Task 嵌套）
//从最后一个子 Task 开始（最顶层）
int idx = mChildren.size() - 1;
while (idx >= 0) {
//获取子 Task
final Task child = (Task) getChildAt(idx--);
//跳过不可聚焦的子 Task
if (!child.isTopActivityFocusable()) {
continue;
}
//如果子 Task 不可见，停止遍历
if (child.getVisibility(null /* starting */) != TASK_VISIBILITY_VISIBLE) {
break;
}
//递归调用子 Task 的 Resume
someActivityResumed |= child.resumeTopActivityUncheckedLocked(prev, options,
deferPause);
//如果递归过程中层级结构变化，重新调整索引
if (idx >= mChildren.size()) {
idx = mChildren.size() - 1;
}
}
}
//获取当前正在运行的顶部 Activity
final ActivityRecord next = topRunningActivity(true /* focusableOnly */);
//没有 Activity）或 `!next.canTurnScreenOn()`（不能点亮屏幕）
if (next == null || !next.canTurnScreenOn()) {
//检查是否需要让系统进入休眠（如锁屏场景）
checkReadyForSleep();
}
} finally {
//无论成功还是异常，都清除递归保护标志。
mInResumeTopActivity = false;
}
return someActivityResumed;
}
//Task.resumeTopActivityInnerLocked阶段三：创建进程，Zygote的孵化
对于冷启动，ATMS会通过socket向Zygote进程 发送一个"孵化"新进程的请求。Zygote是Android系统的"孵化器"，所有应用进程都是由它fork（拷贝自身）出来的，这样能高效地让新进程继承预先加载好的Java虚拟机实例和系统资源。
新进程创建后，会执行ActivityThread类的main()方法，这是每个Android应用Java世界的入口。
阶段四：应用初始化，建立通信
在ActivityThread.main()中：
- 准备主线程Looper ：启动主线程的消息循环（
Looper.loop()），让应用可以开始处理系统消息。 - 通知系统 ：应用进程会通过
ApplicationThread这个Binder对象，向ATMS发送一个"我已准备就绪"的通知（attach方法）。这样，系统就知道了新进程的"联系方式"。
阶段五：Activity生命周期回调
ATMS接收到应用进程就绪的消息后，会通过之前建立的Binder通道，通知应用进程执行以下核心步骤：
- 初始化Application ：通过反射创建
Application对象，并依次回调attachBaseContext()和onCreate()方法。 - 启动Activity ：紧接着，系统会通知应用进程创建目标Activity实例，并开始执行它的生命周期方法：
onCreate()->onStart()->onResume()。至此，应用的界面才真正呈现给用户。