Activity 的启动流程（Android 13）

Activity 的启动过程分为两种：一种是普通 Activity 的启动过程，另一种是根 Activity 的启动过程。普通 Activity 指的是除应用程序启动的第一个 Activity 之外的其他 Activity。根 Activity 指的是应用程序启动的第一个 Activity，因此，根 Activity 的启动过程一般情况下也可以理解为应用程序的启动过程。

1 普通 Activity 的启动流程

普通 Activity 的启动流程比较复杂，比如用 Activity A 打开 Activity B，这一过程开始于 A.startActivity(Intent) 经过 system_server 进程的处理，最终调用 B.finish() 结束生命周期。

普通 Activity 的启动流程可以分为以下 3 部分：

• Activity 请求 ActivityTaskManagerService(ATMS) 的过程
• ATMS 到 ApplicationThread 的调用过程
• ActivityThread 启动 Activity；

  1.1 Activity 请求 ActivityTaskManagerService(ATMS) 的过程

  以下是 Activity 请求 ATMS 的时序图：

  

  Instrumentation 负责调用 Activity 和 Application 的生命周期，具有跟踪 Application 和 Activity 生命周期的功能。 以下是 Instrumentation.execStartActivity 方法的相关源码：

  public class Instrumentation {
      public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
          ......
          try {
              int result = ActivityTaskManager.getService().startActivity(whoThread,
                      who.getOpPackageName(), who.getAttributionTag(), intent,
                      intent.resolveTypeIfNeeded(who.getContentResolver()), token,
                      target != null ? target.mEmbeddedID : null, 
                      requestCode, 0, null, options); // 1
              ...
          } catch (RemoteException e) {
             .....
          }
          return null;
      }
  }
  

  注释 1 处调用了 ActivityTaskManager.getService() 方法来获取 ATMS 的代理对象，接着调用了它的 startActivity 方法。以下是 ActivityTaskManager.getService() 的相关源码：

  @SystemService(Context.ACTIVITY_TASK_SERVICE)
  public class ActivityTaskManager {
      public static IActivityTaskManager getService() {
          return IActivityTaskManagerSingleton.get();
      }
      private static final Singleton IActivityTaskManagerSingleton =
              new Singleton() {
                  @Override
                  protected IActivityTaskManager create() {
                      final IBinder b = 
                        	ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE); // 1
                      return IActivityTaskManager.Stub.asInterface(b); // 2
                  }
              };
    }
  // /frameworks/base/core/java/android/content/Context.java
  public abstract class Context {
    	public static final String ACTIVITY_TASK_SERVICE = "activity_task";
  }
  

  ActivityTaskManager：是实现 Activity 与 ATMS 跨进程交互的接口，ATMS 的辅助类。

  从上述代码中可知，ActivityTaskManager.getService() 调用了 IActivityTaskManagerSingleton.get() 方法，IActivityTaskManagerSingleton 是一个 Singleton 类。注释 1 处得到一个名为 “activity_task” 的 Service 的引用，也就是 IBinder 类型的 ATMS 的引用。

  在注释 2 处将它转换成 IActivityTaskManager 类型的对象，这段代码采用的 AIDL，IActivityManager.java 类是由 AIDL 工具在编译时自动生成的，IActivityTaskManager.aidl 的文件路径为 /frameworks/base/core/java/android/app/IActivityTaskManager.aidl。要实现进程间通信，服务器端也就是 ATMS 只需要继承 IActivityTaskManager.Stub 类并实现相应的方法就可以了。IActivityTaskManager 是 ATMS 在本地的代理。

  以下是相关相关源码：

  interface IActivityTaskManager {
      int startActivity(in IApplicationThread caller, in String callingPackage,
              in String callingFeatureId, in Intent intent, in String resolvedType,
              in IBinder resultTo, in String resultWho, int requestCode,
              int flags, in ProfilerInfo profilerInfo, in Bundle options);
    	......
  }
  /**
   * System service for managing activities and their containers(task, displays, ...)
   * 
   */
  public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
      @Override
      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());
      }
  }
  

  ActivityTaskManagerService：是管理 Activity 以及其容器（task、stacks、displays）的系统服务，负责 Activity 管理和调度工作（Android 10 中新增）。ATMS 是 AMS 的一个辅助类，分担了 AMS 的一部分功能，继承自 IActivityTaskManager.Stub。

  1.2 ATMS 到 ApplicationThread 的调用过程

  Activity 请求 ATMS 后，代码逻辑就就进入到 ATMS 中，接着就是 ATMS 到 ApplicationThread 的调用流程，时序图如下所示：

  

  ATMS.startActivity 方法会调用其 startActivityAsUser 方法，在 ATMS.startActivityAsUser 方法中会调用 ATMS.getActivityStartController() 方法获取 ActivityStartController 对象：

  public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
    	private ActivityStartController mActivityStartController;
    
    	ActivityStartController getActivityStartController() {
          return mActivityStartController;
      }
    
    	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) {
        
       	...
          
        return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
                  .setCaller(caller)
                  .setCallingPackage(callingPackage)
                  .setCallingFeatureId(callingFeatureId)
                  .setResolvedType(resolvedType)
                  .setResultTo(resultTo)
                  .setResultWho(resultWho)
                  .setRequestCode(requestCode)
                  .setStartFlags(startFlags)
                  .setProfilerInfo(profilerInfo)
                  .setActivityOptions(opts)
                  .setUserId(userId)
                  .execute();
        
      }
  }
  

  ActivityStartController 是用于 Activity 启动的控制器。 通过调用其 obtainStarter 方法来获取 ActivityStarter 对象：

  /**
   * Controller for delegating activity launches. 
   * Activity 的启动的控制器
   */
  public class ActivityStartController {
    	/**
       * 返回一个启动器来配置和执行 Activity 的启动
       */
      ActivityStarter obtainStarter(Intent intent, String reason) {
          return mFactory.obtain().setIntent(intent).setReason(reason);
      }
    
  }
  

  ActivityStarter 是 Android 7.0 中新加入的类，是 Activity 的控制器，讲如何启动一个 Activity，会收集所有的逻辑来决定如何将 Intent 和 Flags 转换为 Activity，并将 Activity 和 Task 以及 Stack 相关联。

  /**
   * Controller for interpreting how and then launching an activity.
   * 
   * This class collects all the logic for determining how an intent and flags should be 
   * turned into an activity and associated task and root task.
   */
  class ActivityStarter {
    
  }
  

  Task 就是用户在执行某项工作时与之相关联的 Activity 集合。系统通过任务栈来管理这些 Activity，它们按照打开的顺序进入任务栈中。这些 Activity 可以来自同一个 APP，也可以来自不同的 APP，Activity 之间不一定非要有关联。

  当按 Home 键旁边的那个方形键（recent-apps）时，屏幕上展示的就是一个个的 Task。

  /**
   * {@link Task} is a TaskFragment that can contain a group of activities to perform a certain 
   * job.  Task 是 TaskFragment 的子类，可以包含执行某个任务的一组 activities。
   * 
   * Activities of the same task affinities usually group in the same {@link Task}. 
   * 具有相同的 task affinities 的 activities 通常分在同一个 Task 中
   * 
   * A {@link Task} can also be an entity that showing in the Recents Screen for a job that 
   * user interacted with.
   * 按下 Home 键旁边的那个方形键（recent-apps）时，屏幕上展示的就是一个个的 Task
   * 
   * A {@link Task} can also contain other {@link Task}s.
   * 一个 Task 也可以包含其他的 Task
   */
  class Task extends TaskFragment {
    
  }
  /**
   * A basic container that can be used to contain activities or other {@link TaskFragment}, 
   * which also able to manage the activity lifecycle and updates the visibilities of the 
   * activities in it.
   * 一个容器，可以用来放 activities 或者其它的 TaskFragment，也能够管理 activity 的生命周期或者更新
   * activities 的可见性。
   */
  class TaskFragment extends WindowContainer {
    
  }
  

  task affinity：在 manifest 文件中，注册 activity 时如果不申明 taskAffinity 属性，就是 APP 程序的默认包名，默认情况下，一个 APP 中所有的 Activity 都在一个 Task 中：

  启动根 Activity 时会将 Intent 的 Flag 设置为 FLAG_ACTIVITY_NEW_TASK，表示要创建一个新的 Task：

  class ActivityStarter {
    	private Task mTargetRootTask;
    	private final RootWindowContainer mRootWindowContainer;
    	
      private Task computeTargetTask() {
        if (mStartActivity.resultTo == null && mInTask == null && !mAddingToTask
                && (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) { // 1
            // A new task should be created instead of using existing one.
            return null;
        } else if (mSourceRecord != null) {
            return mSourceRecord.getTask();
        } else if (mInTask != null) {
            if (!mInTask.isAttached()) {
                getOrCreateRootTask(mStartActivity, mLaunchFlags, mInTask, mOptions);
            }
            return mInTask;
        } else {
            final Task rootTask = getOrCreateRootTask(mStartActivity, mLaunchFlags, 
       null /* task */, mOptions);
            final ActivityRecord top = rootTask.getTopNonFinishingActivity();
            if (top != null) {
                return top.getTask();
            } else {
                rootTask.removeIfPossible("computeTargetTask");
            }
        }
        return null;
      }
      private void setNewTask(Task taskToAffiliate) {
          final boolean toTop = !mLaunchTaskBehind && !mAvoidMoveToFront;
          final Task task = mTargetRootTask.reuseOrCreateTask(
                  mStartActivity.info, mIntent, mVoiceSession,
                  mVoiceInteractor, toTop, mStartActivity, mSourceRecord, mOptions);
          task.mTransitionController.collectExistenceChange(task);
          addOrReparentStartingActivity(task, "setTaskFromReuseOrCreateNewTask");
          ProtoLog.v(WM_DEBUG_TASKS, "Starting new activity %s in new task %s",
                  mStartActivity, mStartActivity.getTask());
          if (taskToAffiliate != null) {
              mStartActivity.setTaskToAffiliateWith(taskToAffiliate);
          }
      }
      int startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord,
              IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
              int startFlags, boolean doResume, ActivityOptions options, Task inTask,
              TaskFragment inTaskFragment, @BalCode int balCode,
              NeededUriGrants intentGrants) {
          ...
          // Compute if there is an existing task that should be used for.
          final Task targetTask = reusedTask != null ? reusedTask : computeTargetTask(); // 2
          final boolean newTask = targetTask == null; // 3
          mTargetTask = targetTask;
          ...
          if (newTask) { // 4
              final Task taskToAffiliate = (mLaunchTaskBehind && mSourceRecord != null)
                      ? mSourceRecord.getTask() : null;
              setNewTask(taskToAffiliate); // 5
          } else if (mAddingToTask) {
              addOrReparentStartingActivity(targetTask, "adding to task");
          }
          ...
          final boolean isTaskSwitch = startedTask != prevTopTask && !startedTask.isEmbedded();
          mTargetRootTask.startActivityLocked(mStartActivity, topRootTask, newTask, 
                                              isTaskSwitch, mOptions, sourceRecord); // 6
          if (mDoResume) {
              ...
              } else {
                  ...
                  mRootWindowContainer.resumeFocusedTasksTopActivities(
                          mTargetRootTask, mStartActivity, mOptions, mTransientLaunch); // 7
              }
          }
          ...
          return START_SUCCESS;
      }
    
  }
  

  如果注释 4 处的条件满足，表示需要创建一个新的 Task。在注释 6 处调用的是 Task.startActivityLocked 方法，注释 7 处调用的是 RootWindowContainer.resumeFocusedTasksTopActivities 方法。

  RootWindowContainer 表示窗口容器的根容器，是整个屏幕最顶层的容器。

  /** 
   * Root {@link WindowContainer} for the device. 
   * 设备的根
   */
  class RootWindowContainer extends WindowContainer
          implements DisplayManager.DisplayListener {
    
  }
  

  ActivityRecord：记录 Activity 的信息；TaskRecord：记录 Task 的信息；ActivityStack：栈信息；

  class Task extends TaskFragment {
    
      private boolean resumeTopActivityInnerLocked(ActivityRecord prev, 
                                         ActivityOptions options, boolean deferPause) {
          ...
  				// 1
          final ActivityRecord topActivity = topRunningActivity(true /* focusableOnly */); 
          if (topActivity == null) {
              // There are no activities left in this task, let's look somewhere else.
              return resumeNextFocusableActivityWhenRootTaskIsEmpty(prev, options);
          }
          final boolean[] resumed = new boolean[1];
          final TaskFragment topFragment = topActivity.getTaskFragment();
          resumed[0] = topFragment.resumeTopActivity(prev, options, deferPause);
          ...
          return resumed[0];
      }
    	
      ActivityRecord topRunningActivity(IBinder token, int taskId) {
          final PooledPredicate p = PooledLambda.obtainPredicate(Task::isTopRunning,
                  PooledLambda.__(ActivityRecord.class), taskId, token);
          final ActivityRecord r = getActivity(p);
          p.recycle();
          return r;
      }
    
  }
  

  注释 1 处调用 topRunningActivity 方法获取栈顶不是处于停止状态的 ActivityRecord，此处的栈指的是要启动的 Activity 所在的栈。

  从注释上来看，ActivityTaskSupervisor，翻译过来是“活动任务主管”，从注释中可以看出，这个类已经变成了垃圾倾倒场，页面层级相关的代码移动到 RootWindowContainer 中，与 Activity 生命周期相关的移动到 ActivityLifeCycler 中，接口相关的代码移动到 ATMS 中，等等。

  从功能上来看，可以理解成 ActivityTaskSupervisor 是用来辅助 ATMS 来对 Activity 和 Task 进行管理的。

  // TODO: This class has become a dumping ground. Let's
  // 这个类已经变成了垃圾请倒场
  // - Move things relating to the hierarchy to RootWindowContainer
  // - 把与层级相关的代码移动到 RootWindowContainer 中
  // - Move things relating to activity life cycles to maybe a new class called ActivityLifeCycler
  // - 与 Activity 生命周期相关的代码移动到 ActivityLifeCycler 中
  // - Move interface things to ActivityTaskManagerService.
  // - 接口相关的移动到 ActivityTaskManagerService 中
  // - All other little things to other files.
  public class ActivityTaskSupervisor implements RecentTasks.Callbacks {
      final ActivityTaskManagerService mService;
      void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {
          // 1 Is this activity's application already running?
          final WindowProcessController wpc =
                  mService.getProcessController(r.processName, r.info.applicationInfo.uid);
          boolean knownToBeDead = false;
          if (wpc != null && wpc.hasThread()) {
              try {
                  realStartActivityLocked(r, wpc, andResume, checkConfig); // 2
                  return;
              } catch (RemoteException e) {
                  Slog.w(TAG, "Exception when starting activity "
                          + r.intent.getComponent().flattenToShortString(), e);
              }
              ...
          }
          r.notifyUnknownVisibilityLaunchedForKeyguardTransition();
          final boolean isTop = andResume && r.isTopRunningActivity();
          mService.startProcessAsync(r, knownToBeDead, isTop,
                  isTop ? HostingRecord.HOSTING_TYPE_TOP_ACTIVITY
                          : HostingRecord.HOSTING_TYPE_ACTIVITY); // 3
      }
  }
  

  注释 1 处的来判断当前的 Activity 所在的应用程序进程是否存在，如果存在则调用注释 2 处的 realStartActivityLocked 方法继续 Activity 的启动流程，如果不存在在调用注释 3 处 ATMS.startProcessAsync 方法创建进程。

  /**
   * The Activity Manager (AM) package manages the lifecycle of processes in the system through
   * ProcessRecord. Activity Manager（AM）包通过 ProcessRecord 来管理系统中进程的生命周期
   * 
   * However, it is important for the Window Manager (WM) package to be aware
   * of the processes and their state since it affects how WM manages windows and activities. 
   * 但是，对于 Window Manager（WM）包来说，了解进程以及其状态是十分重要的，因为它会影响 Window Manager 管
   * 理 windows 和 activities 的方式 
   * 
   * This class that allows the ProcessRecord object in the AM package to communicate important
   * changes to its state to the WM package in a structured way. 
   * 这个类允许 ProcessRecord 对象以结构化的方式将其状态的重要改变传到给 WM 包
   * 
   * WM package also uses {@link WindowProcessListener} to request changes to the process state 
   * on the AM side.
   * WM 包也使用 WindowProcessListener 来请求更改 AM 端的进程状态
   * 
   * Note that public calls into this class are assumed to be originating from outside the
   * window manager so the window manager lock is held and appropriate permissions are checked 
   * before calls are allowed to proceed.
   * 请注意，假定对该类的公共调用来自窗口管理器的外部，因此将该持有窗口管理器锁，并在允许调用继续进行之前检查适当
   * 的权限。
   */
  public class WindowProcessController extends ConfigurationContainer
          implements ConfigurationContainerListener {
    
    	private IApplicationThread mThread;
    	
    	IApplicationThread getThread() {
          return mThread;
      }
      boolean hasThread() {
          return mThread != null;
      }
    
  }
  

  

  在 ActivityTaskSupervisor.realStartActivityLocked 方法中会调用 mService.getLifecycleManager().scheduleTransaction(clientTransaction);，这里的 mService 是 ATMS。

  在 ActivityTaskManagerService 中初始化了 ClientLifecycleManager（客户端事务管理类）的唯一实例，因此，所有的有关事务的操作都必须通过 ATMS 实例来发起。 以下是 ATMS 中的 ClientLifecycleManager 的相关初始化与获取操作：

  public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
    
    	private final ClientLifecycleManager mLifecycleManager;
    
    	public ActivityTaskManagerService(Context context) {
        	...
        	mLifecycleManager = new ClientLifecycleManager();
        	...
      }
    
      ClientLifecycleManager getLifecycleManager() {
          return mLifecycleManager;
      }
  }
  public class ActivityTaskSupervisor implements RecentTasks.Callbacks {
      final ActivityTaskManagerService mService;
      boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
                    boolean andResume, boolean checkConfig) throws RemoteException {
        	...
          // Create activity launch transaction.
          final ClientTransaction clientTransaction = ClientTransaction.obtain(
          proc.getThread(), r.token);
          final boolean isTransitionForward = r.isTransitionForward();
          final IBinder fragmentToken = r.getTaskFragment().getFragmentToken();
          // 注意：LaunchActivityItem
          clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
                System.identityHashCode(r), r.info,
                // TODO: Have this take the merged configuration instead of separate global
                // and override configs.
                mergedConfiguration.getGlobalConfiguration(),
                mergedConfiguration.getOverrideConfiguration(), r.compat,
                r.getFilteredReferrer(r.launchedFromPackage), task.voiceInteractor,
                proc.getReportedProcState(), r.getSavedState(), r.getPersistentSavedState(),
                results, newIntents, r.takeOptions(), isTransitionForward,
                proc.createProfilerInfoIfNeeded(), r.assistToken, activityClientController,
                r.shareableActivityToken, r.getLaunchedFromBubble(), fragmentToken));
          ...
          mService.getLifecycleManager().scheduleTransaction(clientTransaction); // 2
      }
  }
  

  ClientLifecycleManager：客户端事务管理类，能够组合多个客户端生命周期转换事务的请求和/或回调，并把它们作为单个事务执行。

  /**
    * Class that is able to combine multiple client lifecycle transition requests 
    * and/or callbacks, and execute them as a single transaction.
    * 
    * 客户端事务管理类，能够组合多个客户端生命周期转换事务的请求和/或回调，并把它们作为单个事务执行
    * 
    * @see ClientTransaction
    */
  class ClientLifecycleManager {
     
      /**
       * Schedule a transaction, which may consist of multiple callbacks and a lifecycle 
       * request. 
       * 调度一个事务，它可能由多个回调和一个生命周期请求组成
       *
       * @see ClientTransaction
       */
      void scheduleTransaction(ClientTransaction transaction) throws RemoteException { // 1
          final IApplicationThread client = transaction.getClient();
          transaction.schedule(); // 2
          if (!(client instanceof Binder)) {
              transaction.recycle();
          }
      }
    	
    	/**
       * Schedule a single lifecycle request or callback to client activity.
       * 
       * @param client Target client.
       * @param activityToken Target activity token.
       * @param stateRequest A request to move target activity to a desired lifecycle state.
       * @throws RemoteException
       *
       * @see ClientTransactionItem
       */
      void scheduleTransaction(@NonNull IApplicationThread client, 
                               @NonNull IBinder activityToken,
              @NonNull ActivityLifecycleItem stateRequest) throws RemoteException { // 3
          final ClientTransaction clientTransaction = transactionWithState(
            	                 client, activityToken, stateRequest);
          scheduleTransaction(clientTransaction);
      }
      /**
       * Schedule a single callback delivery to client activity.
       * @param client Target client.
       * @param activityToken Target activity token.
       * @param callback A request to deliver a callback.
       * @throws RemoteException
       *
       * @see ClientTransactionItem
       */
      void scheduleTransaction(@NonNull IApplicationThread client,
                               @NonNull IBinder activityToken,
              @NonNull ClientTransactionItem callback) throws RemoteException { // 4
          final ClientTransaction clientTransaction = transactionWithCallback(
            					client, activityToken, callback);
          scheduleTransaction(clientTransaction);
      }
      /**
       * Schedule a single callback delivery to client application.
       * @param client Target client.
       * @param callback A request to deliver a callback.
       * @throws RemoteException
       *
       * @see ClientTransactionItem
       */
      void scheduleTransaction(@NonNull IApplicationThread client,
              @NonNull ClientTransactionItem callback) throws RemoteException { // 5
          final ClientTransaction clientTransaction = transactionWithCallback(client,
                  null /* activityToken */, callback);
          scheduleTransaction(clientTransaction);
      }
      /**
       * @return A new instance of {@link ClientTransaction} with a single lifecycle state 
       * request.
       *
       * @see ClientTransaction
       * @see ClientTransactionItem
       */
      private static ClientTransaction transactionWithState(@NonNull IApplicationThread client,
            @NonNull IBinder activityToken, @NonNull ActivityLifecycleItem stateRequest) { // 6
          final ClientTransaction clientTransaction = ClientTransaction.obtain(
                                       client, activityToken);
          clientTransaction.setLifecycleStateRequest(stateRequest);
          return clientTransaction;
      }
      /**
       * @return A new instance of {@link ClientTransaction} with a single callback invocation.
       *
       * @see ClientTransaction
       * @see ClientTransactionItem
       */
      private static ClientTransaction transactionWithCallback(
        			@NonNull IApplicationThread client,
              IBinder activityToken, @NonNull ClientTransactionItem callback) { // 7
          final ClientTransaction clientTransaction = ClientTransaction.obtain(
                                         client, activityToken);
          clientTransaction.addCallback(callback);
          return clientTransaction;
      }
  }
  

  从上面的代码中可以看出，ClientLifecycleManager 对外暴露了 3 种事务调度的方法，一是直接调度客户端事务集 ClientTransaction（注释 1），二是调度生命周期事务 ActivityLifecycleItem（注释 3），三是调度客户端事务 ClientTransactionItem（注释 4），实际上无论是生命周期事务 ActivityLifecycleItem 还是客户端事务 ClientTransactionItem 都被封装成 ClientTransaction 客户端事务集的形式，因此，这个类中的核心方法就是 scheduleTransaction(ClientTransaction) ，在这个方法中传入 ClientTransation 类型的参数并调用它的 schedule() 方法做进一步处理（注释 2）。

  ClientTransaction 事务类集，一个事务集可以存放一系列的事务（ClientTransactionItem）以及一个生命周期事务（ActivityLifecycleItem）。

  public class ClientTransaction implements Parcelable, ObjectPoolItem {
      /** A list of individual callbacks to a client. */
      @UnsupportedAppUsage
      private List mActivityCallbacks; // 1
      /**
       * Final lifecycle state in which the client activity should be after the transaction is
       * executed.
       */
      private ActivityLifecycleItem mLifecycleStateRequest; // 2
      /** Target client. */
      private IApplicationThread mClient;
      /** Get the target client of the transaction. */
      public IApplicationThread getClient() {
          return mClient;
      }
      /**
       * Add a message to the end of the sequence of callbacks.
       * @param activityCallback A single message that can contain a lifecycle 
       * request/callback.
       */
      public void addCallback(ClientTransactionItem activityCallback) {
          if (mActivityCallbacks == null) {
              mActivityCallbacks = new ArrayList();
          }
          mActivityCallbacks.add(activityCallback);
      }
    
    	public void schedule() throws RemoteException {
          mClient.scheduleTransaction(this);
      }
    	
    	...
  }
  

  ClientTransactionItem 客户端事务，是一个抽象类，ActivityLifecycleItem 是它的一个子类：

  public abstract class ClientTransactionItem implements BaseClientRequest, Parcelable {
    /** Get the state that must follow this callback. */
    @LifecycleState
    public int getPostExecutionState() {
        return UNDEFINED;
    }
    // Parcelable
    @Override
    public int describeContents() {
        return 0;
    }
  }
  /**
   * Request to launch an activity.
   * @hide
   */
  public class LaunchActivityItem extends ClientTransactionItem { }
  public abstract class ActivityTransactionItem extends ClientTransactionItem { }
  public abstract class ActivityLifecycleItem extends ActivityTransactionItem { }
  public class ResumeActivityItem extends ActivityLifecycleItem { }
  public class PauseActivityItem extends ActivityLifecycleItem { }
  public class StopActivityItem extends ActivityLifecycleItem { }
  public class DestroyActivityItem extends ActivityLifecycleItem { }
  public class ActivityRelaunchItem extends ActivityTransactionItem { }
  

  ActivityLifecycleItem 是 Activity 生命周期事务类，其子类有 ResumeActivityItem、PauseActivityItem、StopActivityItem、DestroyActivityItem，表示具体的 Activity 的生命周期转换事务。

  LaunchActivityItem 请求启动一个 Activity，ActivityRelaunchItem 重启 Activity 的回调。

  对于 ClientTransaction.schedule() 方法：

  public class ClientTransaction implements Parcelable, ObjectPoolItem {
      /** Target client. */
      private IApplicationThread mClient; // 1
    
    	public void schedule() throws RemoteException {
          mClient.scheduleTransaction(this); // 2
      }
    
  }
  

  注释 1 处的 mClient 指的是 IApplicationThread，它的实现类是 ActivityThread 的内部类 ApplicationThread。ApplicationThread 继承了 IApplicationThread.Stub。当前代码运行在 ATMS 所在的进程（system_server）中，通过 IApplicationThread 与应用程序进程来进行 Binder 通信，换句话说 IApplicationThread 是 ATMS 所在的进程（system_server）和应用程序进程的通信桥梁。

  1.3 ActivityThread 启动 Activity 的过程

  

  目前的代码已经是运行在应用程序进程中了。

  public final class ActivityThread extends ClientTransactionHandler // 3
            implements ActivityThreadInternal {
    
    	private class ApplicationThread extends IApplicationThread.Stub { // 1
          @Override
          public void scheduleTransaction(ClientTransaction transaction) 
            										throws RemoteException {
              ActivityThread.this.scheduleTransaction(transaction); // 2
          }
  		}
  }
  

  从注释 1 处可知，ApplicationThread 是 ActivityThread 的内部类，也是 IApplicationThread 的实现类。注释 2 处 调用了 ActivityThread.this.scheduleTransaction 方法。从注释 3 处可以知道 ActivityThread 是 ClientTransactionHandler 的实现类，ClientTransactionHandler.scheduleTransaction 方法如下所示：

  /**
    * Defines operations that a {@link android.app.servertransaction.ClientTransaction} or its 
    * items can perform on client.
    * 定义了 ClientTransaction 或其 items 可以在客户端执行的操作
    * @hide
    */
  public abstract class ClientTransactionHandler {
    
      // Schedule phase related logic and handlers.
      /** Prepare and schedule transaction for execution. */
      void scheduleTransaction(ClientTransaction transaction) {
          transaction.preExecute(this);
          sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
      }
    
    	abstract void sendMessage(int what, Object obj);
  }
  

  对于抽象方法 sendMessage，在 ActivityThread 中有实现：

  public final class ActivityThread extends ClientTransactionHandler
            implements ActivityThreadInternal {
    
      final H mH = new H();
    
      void sendMessage(int what, Object obj) {
      		sendMessage(what, obj, 0, 0, false); 
      }
      private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
          Message msg = Message.obtain();
          msg.what = what;
          msg.obj = obj;
          msg.arg1 = arg1;
          msg.arg2 = arg2;
          if (async) {
              msg.setAsynchronous(true);
          }
          mH.sendMessage(msg);
      }
    
  }
  

  最终调用的是 mH.sendMessage 方法，mH 是 H 类型的对象，H 是 ActivityThread 的内部类，也是 Handler 的子类：

  public final class ActivityThread extends ClientTransactionHandler
            implements ActivityThreadInternal {
    	
    	class H extends Handler { }
  }
  

  对于 ActivityThread.H.EXECUTE_TRANSACTION 消息的处理：

  public final class ActivityThread extends ClientTransactionHandler
            implements ActivityThreadInternal {
    	
    	class H extends Handler {
        
    			public void handleMessage(Message msg) {
              case EXECUTE_TRANSACTION:
                  final ClientTransaction transaction = (ClientTransaction) msg.obj;
                  mTransactionExecutor.execute(transaction); // 1
                  if (isSystem()) {
                      // Client transactions inside system process are recycled on the client side
                      // instead of ClientLifecycleManager to avoid being cleared before this
                      // message is handled.
                      transaction.recycle();
                  }
                  // TODO(lifecycler): Recycle locally scheduled transactions.
                  break;
          }
  	  }
  }
  

  注释 1 处调用了 TransactionExecutor.execute 方法。

  ClientTransactionHandler：定义了客户端事务或其 Item 可以在客户端执行的操作，封装了 handleXXXActivity 方法，其实现类 ActivityThread 也会继承这些方法。

  /**
    * Defines operations that a {@link android.app.servertransaction.ClientTransaction} or its 
    * items can perform on client.
    * 定义了 ClientTransaction 或其 items 可以在客户端执行的操作
    * @hide
    */
  public abstract class ClientTransactionHandler {
      public abstract Activity handleLaunchActivity(@NonNull ActivityClientRecord r,
            PendingTransactionActions pendingActions, Intent customIntent);
      /** Perform activity launch. */
      public abstract Activity handleLaunchActivity(@NonNull ActivityClientRecord r,
              PendingTransactionActions pendingActions, Intent customIntent);
      /** Perform activity start. */
      public abstract void handleStartActivity(@NonNull ActivityClientRecord r,
              PendingTransactionActions pendingActions, ActivityOptions activityOptions);
      /** Resume the activity. */
      public abstract void handleResumeActivity(@NonNull ActivityClientRecord r,
              boolean finalStateRequest, boolean isForward, String reason);
      /** Pause the activity. */
      public abstract void handlePauseActivity(@NonNull ActivityClientRecord r, 
              boolean finished, boolean userLeaving, int configChanges, 
              PendingTransactionActions pendingActions, String reason);
      /** Stop the activity. */
      public abstract void handleStopActivity(@NonNull ActivityClientRecord r, 
              int configChanges, PendingTransactionActions pendingActions, 
              boolean finalStateRequest, String reason);
      public abstract void handleDestroyActivity(@NonNull ActivityClientRecord r, 
                   boolean finishing, int configChanges, boolean getNonConfigInstance, 
                   String reason);
      public abstract void handleRelaunchActivity(@NonNull ActivityClientRecord r,
                    PendingTransactionActions pendingActions);
  }
  

  TransactionExecutor：事务执行器，让事务按正确顺序执行的类。TransactionExecutor 持有 ClientTransactionHandler 对象，在其构造函数中作为参数传入，ClientTransactionHandler 才是任务的真正执行者。

  /**
    * Class that manages transaction execution in the correct order.
    * @hide
    */
  public class TransactionExecutor {
    	private ClientTransactionHandler mTransactionHandler;
    	
      /** Initialize an instance with transaction handler, that will execute all requested actions. */
      public TransactionExecutor(ClientTransactionHandler clientTransactionHandler) {
          mTransactionHandler = clientTransactionHandler;
      }
  }
  

  回到 TransactionExecutor.execute 方法中：

  public class TransactionExecutor {
    
      public void execute(ClientTransaction transaction) {
         ...
         executeCallbacks(transaction); // 1
         executeLifecycleState(transaction);
         ...
      }
    
      @VisibleForTesting
      public void executeCallbacks(ClientTransaction transaction) {
          final List callbacks = transaction.getCallbacks();
          if (callbacks == null || callbacks.isEmpty()) {
              // No callbacks to execute, return early.
              return;
          }
          ...
          final int size = callbacks.size();
          for (int i = 0; i  
  注释 3 处调用了 ClientTransactionItem.execute 方法，对于启动一个 Activity，此处的 ClientTransactionItem 是其子类 LaunchActivityItem，请求启动一个 Activity。
   
  /**
   * Request to launch an activity.
   * @hide
   */
  public class LaunchActivityItem extends ClientTransactionItem {
    
  }
  public abstract class ClientTransactionItem implements BaseClientRequest, Parcelable {
    
  }
   
  BaseClientRequest：事务的抽象类，定义了 preExecute、execute、postExecute 三个接口，分别代表事务执行前、执行中、执行后三个阶段的回调方法。
   
  public interface BaseClientRequest extends ObjectPoolItem {
      /**
       * Prepare the client request before scheduling.
       * An example of this might be informing about pending updates for some values.
       *
       * @param client Target client handler.
       * @param token  Target activity token.
       */
      default void preExecute(ClientTransactionHandler client, IBinder token) {
      }
      /**
       * Execute the request.
       * @param client Target client handler.
       * @param token Target activity token.
       * @param pendingActions Container that may have data pending to be used.
       */
      void execute(ClientTransactionHandler client, IBinder token,
              PendingTransactionActions pendingActions);
      /**
       * Perform all actions that need to happen after execution, e.g. report the result to server.
       * @param client Target client handler.
       * @param token Target activity token.
       * @param pendingActions Container that may have data pending to be used.
       */
      default void postExecute(ClientTransactionHandler client, IBinder token,
              PendingTransactionActions pendingActions) {
      }
  }
   
  LaunchActivityItem 重写了 execute 方法：
   
  public class LaunchActivityItem extends ClientTransactionItem {
      @Override
      public void execute(ClientTransactionHandler client, IBinder token,
              PendingTransactionActions pendingActions) {
          Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
          ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
                  mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, 
                  mPersistentState, mPendingResults, mPendingNewIntents, mActivityOptions, 
                  mIsForward, mProfilerInfo, client, mAssistToken, mShareableActivityToken, 
                  mLaunchedFromBubble, mTaskFragmentToken);
          client.handleLaunchActivity(r, pendingActions, null /* customIntent */); // 1
          Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
      }
    
  }
   
  注释 1 处的 client 的类型是 ClientTransactionHandler，ActivityThread 继承了 ClientTransactionHandler，是事务的真正执行者。
   
  public final class ActivityThread extends ClientTransactionHandler
          implements ActivityThreadInternal {
    
      @Override
      public Activity handleLaunchActivity(ActivityClientRecord r,
              PendingTransactionActions pendingActions, Intent customIntent) {
          ...
          final Activity a = performLaunchActivity(r, customIntent);
          ...
          return a;
      }
  }
   
  2 根 Activity 的启动过程
   
  根 Activity 的启动流程可以分为以下 3 部分：
   
  

  • Launcher 请求 ActivityTaskManagerService(ATMS) 的过程
  • ATMS 到 ApplicationThread 的调用过程
  • ActivityThread 启动 Activity；

    2.1 Launcher 请求 ATMS 过程

    Launcher 启动后会将已安装的应用程序的快捷图标显示到桌面上，这些应用程序的快捷图标就是启动根 Activity 的入口。当我们点击某个应用题程序的快捷图标时，就会通过 Launcher 请求 ATMS 来启动应用程序。

    以下是 Launcher 请求 ATMS 的时序图：

    

    点击应用程序的快捷图标时，就会调用 Launcher.startActivitySafely 方法：

    // /packages/apps/Launcher3/src/com/android/launcher3/Launcher.java
    public class Launcher extends StatefulActivity
            implements LauncherExterns, Callbacks, InvariantDeviceProfile.OnIDPChangeListener,
            PluginListener {
              
        public boolean startActivitySafely(View v, Intent intent, ItemInfo item,
                                 @Nullable String sourceContainer) {
            ...
            boolean success = super.startActivitySafely(v, intent, item, sourceContainer); // 1
            ...
        }       
    }
    public abstract class StatefulActivity
            extends BaseDraggingActivity {
      
    }
    public abstract class BaseDraggingActivity extends BaseActivity
            implements OnColorsChangedListener, DisplayInfoChangeListener {
      
    }
    public abstract class BaseActivity extends Activity implements ActivityContext {
      
    }
    

    注释 1 处调用的是 super.startActivitySafely 方法，这里的 super，由继承关系可以知道调用的是 ActivityContext.startActivitySafely 方法：

    // packages/apps/Launcher3/src/com/android/launcher3/views/ActivityContext.java
    public interface ActivityContext {
      
        default boolean startActivitySafely(View v, Intent intent, @Nullable ItemInfo item) {
            ...
            // Prepare intent
            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); // 1
            if (v != null) {
                intent.setSourceBounds(Utilities.getViewBounds(v));
            }
            try {
                boolean isShortcut = (item instanceof WorkspaceItemInfo)
                        && (item.itemType == LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT
                        || item.itemType == LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT)
                        && !((WorkspaceItemInfo) item).isPromise();
                if (isShortcut) {
                    // Shortcuts need some special checks due to legacy reasons.
                    startShortcutIntentSafely(intent, optsBundle, item);
                } else if (user == null || user.equals(Process.myUserHandle())) {
                    // Could be launching some bookkeeping activity
                    context.startActivity(intent, optsBundle); // 2
                } else {
                    context.getSystemService(LauncherApps.class).startMainActivity(
                            intent.getComponent(), user, intent.getSourceBounds(), optsBundle);
                }
                ...
                return true;
            } catch (NullPointerException | ActivityNotFoundException | SecurityException e) {
                ...
            }
            return false;
        }
    }
    

    注释 1 处将 Flag 设置为 Intent.FLAG_ACTIVITY_NEW_TASK，这样根 Activity 会在新的任务栈中启动，在注释 2 处调用了 Context.startActivity 方法，Context 是抽象类，其中定义了抽象方法 startActivity，在其子类 Activity 中实现：

    // frameworks/base/core/java/android/content/Context.java
    public abstract class Context {
      	public abstract void startActivity(@RequiresPermission Intent intent,
                @Nullable Bundle options); 
    }
    // frameworks/base/core/java/android/content/ContextWrapper.java
    public class ContextWrapper extends Context {
      	
    }
    // frameworks/base/core/java/android/content/ContextWrapper.java
    public class ContextThemeWrapper extends ContextWrapper {
      
    }
    // frameworks/base/core/java/android/app/Activity.java
    public class Activity extends ContextThemeWrapper
            implements LayoutInflater.Factory2,
            Window.Callback, KeyEvent.Callback,
            OnCreateContextMenuListener, ComponentCallbacks2,
            Window.OnWindowDismissedCallback,
            ContentCaptureManager.ContentCaptureClient {
              
        @Override
        public void startActivity(Intent intent, @Nullable Bundle options) {
            getAutofillClientController().onStartActivity(intent, mIntent);
            if (options != null) {
                startActivityForResult(intent, -1, options);
            } else {
                // Note we want to go through this call for compatibility with
                // applications that may have overridden the method.
                startActivityForResult(intent, -1);
            }
        }
              
    }
    

    2.2 ATMS 到 ApplicationThread 的调用过程

    Launcher 请求 ATMS 后，代码逻辑已经进入到 ATMS 中，接着是 ATMS 到 ApplicationThread 的调用流程：

    

    ActivityStackSupervisor.startSpecificActivityLocked 方法，代码如下所示：

    // /frameworks/base/services/core/java/com/android/server/wm/ActivityStackSupervisor.java
    // TODO: This class has become a dumping ground. Let's
    // 这个类已经变成了垃圾请倒场
    // - Move things relating to the hierarchy to RootWindowContainer
    // - 把与层级相关的代码移动到 RootWindowContainer 中
    // - Move things relating to activity life cycles to maybe a new class called ActivityLifeCycler
    // - 与 Activity 生命周期相关的代码移动到 ActivityLifeCycler 中
    // - Move interface things to ActivityTaskManagerService.
    // - 接口相关的移动到 ActivityTaskManagerService 中
    // - All other little things to other files.
    public class ActivityTaskSupervisor implements RecentTasks.Callbacks {
        final ActivityTaskManagerService mService;
        void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {
            // Is this activity's application already running?
            final WindowProcessController wpc =
                    mService.getProcessController(r.processName, r.info.applicationInfo.uid);
            boolean knownToBeDead = false;
            if (wpc != null && wpc.hasThread()) {
                try {
                    realStartActivityLocked(r, wpc, andResume, checkConfig); 
                    return;
                } catch (RemoteException e) {
                    Slog.w(TAG, "Exception when starting activity "
                            + r.intent.getComponent().flattenToShortString(), e);
                }
                ...
            }
            r.notifyUnknownVisibilityLaunchedForKeyguardTransition();
            final boolean isTop = andResume && r.isTopRunningActivity();
            mService.startProcessAsync(r, knownToBeDead, isTop,
                    isTop ? HostingRecord.HOSTING_TYPE_TOP_ACTIVITY
                            : HostingRecord.HOSTING_TYPE_ACTIVITY); // 1
        }
    }
    

    注释 1 处调用 ATMS.startProcessAsync 方法用来创建新的进程。Zygote 进程收到请求后，fork 出新的进程并调用 ActivityThread.main 方法。

    

    以下是 ActivityTaskManagerService.startProcessAsync 方法的相关源码：

    // frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
    public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
      
        void startProcessAsync(ActivityRecord activity, boolean knownToBeDead, boolean isTop,
                               String hostingType) {
            try {
              if (Trace.isTagEnabled(TRACE_TAG_WINDOW_MANAGER)) {
                  Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "dispatchingStartProcess:"
                          + activity.processName);
              }
              // Post message to start process to avoid possible deadlock of calling into AMS  
              // with the ATMS lock held.
              final Message m = PooledLambda.obtainMessage(ActivityManagerInternal::startProcess,
                      mAmInternal, activity.processName, activity.info.applicationInfo, 
                      knownToBeDead, isTop, hostingType, activity.intent.getComponent()); // 1
              mH.sendMessage(m);
            } finally {
              Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
            }
        }
      
    }
    

    ActivityManagerInternal.startProcess 方法是请求启动应用进程的起点。 注释 1 处的 PooledLambda.obtainMessage 获取一个 Message，并为其指定 Callback。

    // frameworks/base/core/java/com/android/internal/util/function/pooled/PooledLambda.java
    public interface PooledLambda {
        static  Message obtainMessage(
            HeptConsumer