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 的完整流程可概括为 跨进程协作的三段式架构：

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