类概述
┌─────────────────────────────────────────────────────────────────┐
│ ActivityStarter │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 功能：解释"如何"启动Activity的控制器 │
│ │
│ 位置：services/core/java/com/android/server/wm/ │
│ │
│ 这是一个"决策中心"： │
│ ├── 解析Intent和Flags │
│ ├── 确定Activity放在哪个Task │
│ ├── 计算启动模式 │
│ ├── 处理权限检查 │
│ └── 协调窗口转换 │
│ │
└─────────────────────────────────────────────────────────────────┘
核心成员变量 (mStartActivity 相关状态)
ActivityStarter 关键状态变量
├── mStartActivity → 要启动的ActivityRecord
├── mIntent → 启动Intent
├── mSourceRecord → 来源Activity (启动者)
├── mOptions → ActivityOptions (启动选项)
│
├── mLaunchMode → 启动模式 (standard/singleTop/singleTask等)
├── mLaunchFlags → Intent的Flags
├── mLaunchParams → 启动参数 (显示区域/窗口模式)
│
├── mTargetTask → 目标Task
├── mTargetRootTask → 目标根Task
├── mSourceRootTask → 来源根Task
│
├── mPreferredTaskDisplayArea → 首选显示区域
├── mPreferredWindowingMode → 首选窗口模式
│
├── mDoResume → 是否要恢复Activity
├── mAddingToTask → 是否添加到现有Task
├── mMovedToFront → 是否移到前台
│
├── mBalCode → 后台Activity启动授权码
├── mCanMoveToFrontCode → 是否允许移到前台
│
└── mRequest → 请求详情 (包含所有启动参数)
内部类：Request (启动请求封装)
static class Request {
IApplicationThread caller; // 调用者进程
Intent intent; // 启动Intent
ActivityInfo activityInfo; // 解析后的Activity信息
ResolveInfo resolveInfo; // 解析信息
IBinder resultTo; // 结果返回目标
int requestCode; // 请求码
String callingPackage; // 调用者包名
int callingUid; // 调用者UID
int startFlags; // 启动标志
SafeActivityOptions activityOptions; // 启动选项
Task inTask; // 指定Task
TaskFragment inTaskFragment; // 指定TaskFragment
String reason; // 启动原因
int userId; // 用户ID
// ... 还有更多字段
}
核心方法调用流程
┌─────────────────────────────────────────────────────────────────┐
│ 入口：execute() │
│ [Line 800] │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 1️⃣ 获取调用者ActivityRecord │
│ └── ActivityRecord.forTokenLocked(mRequest.resultTo) │
│ │
│ 2️⃣ 解析Activity (如果还没解析) │
│ └── mRequest.resolveActivity(mSupervisor) │
│ │
│ 3️⃣ 检查启动权限 │
│ └── mSupervisor.checkStartAnyActivityPermission() │
│ │
│ 4️⃣ IntentFirewall检查 │
│ └── mService.mIntentFirewall.checkStartActivity() │
│ │
│ 5️⃣ 权限策略检查 │
│ └── mService.getPermissionPolicyInternal().checkStartActivity()│
│ │
│ 6️⃣ 后台Activity启动检查 (BAL) │
│ └── BackgroundActivityStartController.checkBackgroundActivityStart()│
│ │
│ 7️⃣ 创建ActivityRecord │
│ └── new ActivityRecord.Builder(mService)...build() │
│ │
│ 8️⃣ 执行启动 │
│ └── startActivityUnchecked() │
│ │
│ 9️⃣ 处理结果 │
│ └── notifyActivityLaunched() │
│ │
└─────────────────────────────────────────────────────────────────┘
关键方法详解
private int executeRequest(Request request) {
// 1️⃣ 验证调用者
WindowProcessController callerApp = mService.getProcessController(caller);
// 2️⃣ 解析用户ID和启动模式
final int userId = UserHandle.getUserId(aInfo.applicationInfo.uid);
final int launchMode = aInfo.launchMode;
// 3️⃣ 获取sourceRecord和resultRecord
ActivityRecord sourceRecord = ...; // 谁启动了我
ActivityRecord resultRecord = ...; // 结果返回给谁
// 4️⃣ 处理FLAG_ACTIVITY_FORWARD_RESULT
if ((launchFlags & FLAG_ACTIVITY_FORWARD_RESULT) != 0) {
// 转移结果目标
}
// 5️⃣ 权限检查
abort = !mSupervisor.checkStartAnyActivityPermission(...);
abort |= !mService.mIntentFirewall.checkStartActivity(...);
abort |= !mService.getPermissionPolicyInternal().checkStartActivity(...);
// 6️⃣ 创建ActivityRecord
final ActivityRecord r = new ActivityRecord.Builder(mService)
.setCaller(callerApp)
.setLaunchedFromPid(callingPid)
.setLaunchedFromUid(callingUid)
.setIntent(intent)
.setActivityInfo(aInfo)
// ... 更多配置
.build();
// 7️⃣ 后台启动检查
BalVerdict balVerdict = balController.checkBackgroundActivityStart(...);
// 8️⃣ 权限审查(如果需要)
if (mService.getPackageManagerInternalLocked()
.isPermissionsReviewRequired(aInfo.packageName, userId)) {
// 启动权限审查Activity
}
// 9️⃣ 最终启动
mLastStartActivityResult = startActivityUnchecked(r, ...);
}
setInitialState() Line 2666 - 初始化状态
private void setInitialState(ActivityRecord r, ActivityOptions options, ...) {
mStartActivity = r;
mIntent = r.intent;
mOptions = options;
// 计算启动参数 (显示区域、窗口模式)
mSupervisor.getLaunchParamsController().calculate(...);
mPreferredTaskDisplayArea = mLaunchParams.mPreferredTaskDisplayArea;
mPreferredWindowingMode = mLaunchParams.mWindowingMode;
// 设置启动模式
mLaunchMode = r.launchMode;
// 调整Launch Flags
mLaunchFlags = adjustLaunchFlagsToDocumentMode(...);
// 处理FLAG_ACTIVITY_NO_USER_ACTION
mSupervisor.mUserLeaving = (mLaunchFlags & FLAG_ACTIVITY_NO_USER_ACTION) == 0;
// 设置是否恢复
mDoResume = true; // 默认要恢复
if (!canShowActivity || mLaunchTaskBehind) {
mDoResume = false;
}
}
computeLaunchingTaskFlags() - 计算Task标志
private void computeLaunchingTaskFlags() {
// 情况1: 指定了Task (通过mInTask)
if (mSourceRecord == null && mInTask != null) {
if (root == null) {
// Task为空，添加第一个Activity
mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
mAddingToTask = true;
}
}
// 情况2: 没有source (非Activity context启动)
if (mSourceRecord == null) {
if ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) == 0) {
// 强制加NEW_TASK
mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
}
}
// 情况3: source是singleInstance
else if (mSourceRecord.launchMode == LAUNCH_SINGLE_INSTANCE) {
mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
}
// 情况4: 目标是singleInstance或singleTask
else if (isLaunchModeOneOf(LAUNCH_SINGLE_INSTANCE, LAUNCH_SINGLE_TASK)) {
mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
}
}
resolveReusableTask() - 解析可复用Task
private Task resolveReusableTask(boolean includeLaunchedFromBubble) {
// 1️⃣ 如果明确指定了TaskId
if (mOptions != null && mOptions.getLaunchTaskId() != INVALID_TASK_ID) {
return mRootWindowContainer.anyTaskForId(mOptions.getLaunchTaskId());
}
// 2️⃣ 判断是否应该放入已有Task
boolean putIntoExistingTask =
((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0 &&
(mLaunchFlags & FLAG_ACTIVITY_MULTIPLE_TASK) == 0)
|| isLaunchModeOneOf(LAUNCH_SINGLE_INSTANCE, LAUNCH_SINGLE_TASK);
// 3️⃣ 查找匹配的任务
if (putIntoExistingTask) {
if (LAUNCH_SINGLE_INSTANCE == mLaunchMode) {
// singleInstance: 找到唯一的Activity实例
intentActivity = mRootWindowContainer.findActivity(...);
} else if ((mLaunchFlags & FLAG_ACTIVITY_LAUNCH_ADJACENT) != 0) {
// 分屏启动: 只在已存在的Task中查找
intentActivity = mRootWindowContainer.findActivity(...);
} else {
// 普通情况: 找到最佳Task
intentActivity = mRootWindowContainer.findTask(...);
}
}
return intentActivity != null ? intentActivity.getTask() : null;
}
startActivityInner() - 内部启动逻辑
int startActivityInner(...) {
// 1️⃣ 初始化状态
setInitialState(r, options, inTask, ...);
// 2️⃣ 计算启动标志
computeLaunchingTaskFlags();
mIntent.setFlags(mLaunchFlags);
// 3️⃣ 解析可复用Task
final Task reusedTask = resolveReusableTask(...);
// 4️⃣ 计算目标Task
final Task targetTask = reusedTask != null ? reusedTask : computeTargetTask();
final boolean newTask = targetTask == null;
// 5️⃣ 检查是否允许启动
int startResult = isAllowedToStart(r, newTask, targetTask);
if (startResult != START_SUCCESS) return startResult;
// 6️⃣ 复用Task 或 添加到Task
if (targetTaskTop != null) {
// 复用已有Activity
startResult = recycleTask(targetTask, ...);
} else {
// 添加到新Task或现有Task
mAddingToTask = true;
}
// 7️⃣ 传递到当前Top Activity (如果是singleTop)
if (topRootTask != null) {
startResult = deliverToCurrentTopIfNeeded(topRootTask, ...);
}
}
启动模式处理流程图
┌─────────────────────────────────────────────────────────────────┐
│ Intent Flags 解析 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ FLAG_ACTIVITY_NEW_TASK │
│ │ │
│ ├─── singleTask/singleInstance → 强制 ✓ │
│ │ │
│ └─── 非特殊启动模式 → 检查是否需要强制添加 │
│ │
│ FLAG_ACTIVITY_SINGLE_TOP │
│ │ │
│ └─── 如果Top是目标Activity → deliverToCurrentTopIfNeeded() │
│ │
│ FLAG_ACTIVITY_CLEAR_TOP │
│ │ │
│ └─── 清除Top上的所有Activity (除了Root) │
│ │
│ FLAG_ACTIVITY_REORDER_TO_FRONT │
│ │ │
│ └─── 把已有Activity移到前台 │
│ │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Launch Mode 处理 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ standard │
│ └── 每次创建新Activity实例，放入当前Task │
│ │
│ singleTop │
│ └── 如果Top是目标Activity，复用并调用onNewIntent() │
│ │
│ singleTask │
│ └── 在新Task中创建，清除同Task所有上层Activity │
│ │
│ singleInstance │
│ └── 在新Task中创建，是Task中唯一Activity │
│ │
└─────────────────────────────────────────────────────────────────┘
ActivityStarter 与其他组件的关系
┌─────────────────────────────────────────────────────────────────┐
│ ActivityStarter │
│ (你正在学习的类) │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 依赖/引用： │
│ ├── ActivityTaskManagerService (ATMS) │
│ │ └── 获取系统服务、进程控制 │
│ │ │
│ ├── RootWindowContainer │
│ │ └── 窗口容器管理、Task查找 │
│ │ │
│ ├── ActivityTaskSupervisor │
│ │ └── 生命周期管理、权限检查 │
│ │ │
│ ├── ActivityStartInterceptor │
│ │ └── 启动拦截处理 │
│ │ │
│ ├── ActivityStartController │
│ │ └── 获取ActivityStarter实例 │
│ │ │
│ ├── LaunchParamsController │
│ │ └── 计算启动参数 │
│ │ │
│ ├── BackgroundActivityStartController │
│ │ └── 后台启动授权 │
│ │ │
│ └── IntentFirewall │
│ └── Intent防火墙检查 │
│ │
│ 创建/管理： │
│ └── ActivityRecord (你之前打开的文件) │
│ └── 代表一个启动的Activity实例 │
│ │
└─────────────────────────────────────────────────────────────────┘
ActivityStarter.java 流程：
executeRequest() [1042]
│
├─── 权限检查
│
▼
new ActivityRecord.Builder() [1475]
│ │
│ └── 创建 ActivityRecord 实例 ◄── ActivityRecord.java
│
▼
startActivityUnchecked() [1522]
│
▼
startActivityInner() [1875]
│
├─── setInitialState() [2666]
│
├─── computeLaunchingTaskFlags() [2853]
│
├─── resolveReusableTask() [2944]
│
└─── recycleTask() 或 addNewTask()
│
▼
ActivityRecord 被添加到 Task
│
▼
ActivityTaskSupervisor 管理生命周期
