Android `startActivity` 流程分析Android startActivity 通过跨进程通信触发，

1. 应用进程侧：发起启动请求

1.1 `ContextWrapper.startActivity()`

调用入口：Activity 继承自 ContextWrapper，调用 startActivity() 方法。

源码路径：frameworks/base/core/java/android/content/ContextWrapper.java

@Override
public void startActivity(Intent intent) {
    mBase.startActivity(intent); // mBase 是 ContextImpl 实例
}

1.2 `ContextImpl.startActivity()`

核心实现：通过 Instrumentation 执行启动逻辑。

源码路径：frameworks/base/core/java/android/app/ContextImpl.java

@Override
public void startActivity(Intent intent, Bundle options) {
    // 检查权限和 Intent 合法性
    mMainThread.getInstrumentation().execStartActivity(
        getOuterContext(), mMainThread.getApplicationThread(), 
        null, (Activity) null, intent, -1, options
    );
}

1.3 `Instrumentation.execStartActivity()`

关键角色：监控 Activity 生命周期，通过 Binder 与 AMS 通信。

源码路径：frameworks/base/core/java/android/app/Instrumentation.java

public ActivityResult execStartActivity(...) {
    // 获取 AMS 的 Binder 代理对象 IActivityTaskManager
    int result = ActivityTaskManager.getService().startActivity(...);
    // 检查启动结果（例如 ActivityNotFound 异常）
    checkStartActivityResult(result, intent);
}

2. 系统服务进程（AMS）：处理启动逻辑

2.1 `ActivityTaskManagerService.startActivity()`

入口方法：处理来自应用进程的跨进程请求。

源码路径：frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java

@Override
public final int startActivity(...) {
    // 委托给 ActivityStarter 处理
    return getActivityStartController().obtainStarter(intent, "startActivity").execute();
}

2.2 `ActivityStarter.execute()`

核心逻辑：处理启动模式、权限校验、Intent 解析等。

源码路径：frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java

int execute() {
    // Step 1: 解析 Intent 并验证
    ResolveInfo rInfo = mService.resolveIntent(...);
    ActivityInfo aInfo = mSupervisor.resolveActivity(...);
    
    // Step 2: 权限校验（包括 manifest 权限和运行时权限）
    int grantResult = checkTargetPermissions(...);
    
    // Step 3: 创建 ActivityRecord（代表一个 Activity 实例）
    final ActivityRecord r = new ActivityRecord(...);
    
    // Step 4: 处理启动模式（FLAG_ACTIVITY_XXX）
    return startActivityUnchecked(r, sourceRecord, ...);
}

2.3 `ActivityStarter.startActivityUnchecked()`

关键逻辑：处理任务栈复用逻辑。

private int startActivityUnchecked(...) {
    // 根据 launchMode 和 Intent.FLAG 计算目标栈
    TargetStack = computeTargetStack();
    
    // 处理 "singleTask" 或 "singleInstance" 模式
    if (r.launchMode == LAUNCH_SINGLE_TASK) {
        reuseOrCreateNewTask(r, targetStack);
    }
    
    // 将 ActivityRecord 添加到栈顶
    targetStack.startActivityLocked(r, newTask, ...);
}

2.4 `ActivityStackSupervisor.startSpecificActivity()`

进程管理：决定是否创建新进程或复用已有进程。

源码路径：frameworks/base/services/core/java/com/android/server/wm/ActivityStackSupervisor.java

void startSpecificActivity(ActivityRecord r) {
    // 检查目标进程是否存在
    WindowProcessController app = mService.getProcessController(...);
    if (app != null && app.hasThread()) {
        // 进程已存在：直接启动 Activity
        realStartActivityLocked(r, app, ...);
    } else {
        // 进程不存在：创建新进程（通过 Zygote）
        mService.startProcessAsync(...);
    }
}

3. 目标应用进程：创建并启动 Activity

3.1 `ApplicationThread.scheduleLaunchActivity()`

跨进程通信：AMS 通过 Binder 调用应用进程的 ApplicationThread。

源码路径：frameworks/base/core/java/android/app/ActivityThread.java

private class ApplicationThread extends IApplicationThread.Stub {
    @Override
    public void scheduleLaunchActivity(...) {
        sendMessage(H.LAUNCH_ACTIVITY, r);
    }
}

3.2 `ActivityThread.H.handleMessage()`

主线程调度：通过 Handler 切换到主线程处理消息。

class H extends Handler {
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case LAUNCH_ACTIVITY:
                handleLaunchActivity((ActivityClientRecord) msg.obj);
                break;
        }
    }
}

3.3 `ActivityThread.handleLaunchActivity()`

创建 Activity 实例：反射调用构造函数，绑定 Context。

private void handleLaunchActivity(...) {
    // 创建 Activity 实例
    final Activity a = performLaunchActivity(r, customIntent);
    
    // 触发 onResume()
    handleResumeActivity(r.token, ...);
}

3.4 `ActivityThread.performLaunchActivity()`

生命周期触发：调用 onCreate()、onStart() 等方法。

private Activity performLaunchActivity(...) {
    // 反射创建 Activity 实例
    java.lang.ClassLoader cl = appContext.getClassLoader();
    Activity activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);
    
    // 绑定 Context 和 Window
    activity.attach(appContext, ..., r.token);
    
    // 调用 onCreate()
    if (r.isPersistable()) {
        mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
    } else {
        mInstrumentation.callActivityOnCreate(activity, r.state);
    }
    
    // 调用 onStart()
    activity.performStart();
}

4. 关键类

类名	职责描述
`Instrumentation`	监控应用与系统的交互，如 Activity 生命周期和启动流程。
`ActivityTaskManagerService`	管理所有 Activity 的任务栈和生命周期状态。
`ActivityStarter`	处理启动参数（Intent、Flag、权限校验等），生成启动策略。
`ActivityStackSupervisor`	管理多个 ActivityStack，协调栈之间的交互。
`ActivityRecord`	描述一个 Activity 实例的元数据（如配置、状态等）。
`ApplicationThread`	应用进程与 AMS 通信的 Binder 桥梁，接收 AMS 的跨进程调用。

5.时序图

sequenceDiagram
    participant App as 应用进程
    participant AMS as AMS 进程
    participant Target as 目标进程

    App->>App: 1. Activity.startActivity()
    App->>App: 2. ContextImpl.startActivity()
    App->>App: 3. Instrumentation.execStartActivity()
    App->>AMS: 4. IActivityTaskManager.startActivity() (Binder IPC)
    
    AMS->>AMS: 5. ActivityTaskManagerService.startActivity()
    AMS->>AMS: 6. ActivityStartController.obtainStarter()
    AMS->>AMS: 7. ActivityStarter.execute()
    AMS->>AMS: 8. 解析 Intent/权限校验
    AMS->>AMS: 9. ActivityStackSupervisor.startSpecificActivity()
    
    alt 目标进程已存在
        AMS->>Target: 10. ApplicationThread.scheduleLaunchActivity() (Binder IPC)
    else 目标进程不存在
        AMS->>AMS: 10. 创建新进程 (Zygote fork)
        AMS->>Target: 11. 初始化 ActivityThread.main()
        AMS->>Target: 12. ApplicationThread.scheduleLaunchActivity()
    end
    
    Target->>Target: 13. H.handleMessage(LAUNCH_ACTIVITY)
    Target->>Target: 14. ActivityThread.handleLaunchActivity()
    Target->>Target: 15. performLaunchActivity()
    Target->>Target: 16. Instrumentation.newActivity()
    Target->>Target: 17. Activity.attach()
    Target->>Target: 18. Instrumentation.callActivityOnCreate()
    Target->>Target: 19. Activity.performStart()
    Target->>Target: 20. handleResumeActivity()
    Target->>Target: 21. WindowManager.addView()

6. 总结

startActivity 的完整流程可概括为 跨进程协作的三段式架构：

应用进程发起请求
- 通过 Instrumentation 封装启动逻辑，经 Binder 将请求转发至 AMS。
AMS 决策与调度
- 校验权限、解析 Intent、处理启动模式和任务栈，决定是否创建新进程或复用现有组件。
目标进程执行创建
- 通过 ApplicationThread 回调到应用主线程，反射创建 Activity 实例并触发生命周期。

Android `startActivity` 流程分析

1. 应用进程侧：发起启动请求

1.1 ContextWrapper.startActivity()

1.2 ContextImpl.startActivity()

1.3 Instrumentation.execStartActivity()

2. 系统服务进程（AMS）：处理启动逻辑

2.1 ActivityTaskManagerService.startActivity()

2.2 ActivityStarter.execute()

2.3 ActivityStarter.startActivityUnchecked()

2.4 ActivityStackSupervisor.startSpecificActivity()