Activity启动源码解析（Android12）

语言: CN / TW / HK
时间 2023-03-27 09:15:06
主题:

theme: channing-cyan

android源码分析目录

四大组件系列

Activity启动源码解析

Service启动源码解析

BroadcastReceiver源码解析

ContentProvider源码解析

一概述

Activity 的启动非常复杂，其中涉及到多个进程参与工作。Activity 所在的进程，系统进程（Zygote），AMS 进程，还有点击桌面图标所在的 Launch 进程。由于这个原因，所以很难在一篇文章中，将它们所有的工作内容梳理清楚。并且由于其中大部分逻辑，都是在 AMS 中完成的，所以我打算本篇仅描述 Activity 的启动流程，关于进程的启动，Activity 的栈管理，都放在 AMS 的篇章中。

本篇先梳理整个启动流程。关于启动流程，本篇只梳理出大致脉络即可，关于其中的进程启动，进程管理，任务栈管理，后续会单独列举出来介绍。

二 startActivity

首先是我们熟悉的 startActivity，需要注意的是，startActivity 需要区分 Activity 中的 startActivity 和 Context 中的 startActivity，这一点在后面有不同的逻辑。

2.1 Context 的 startActivity

startActivity 前面这些流程大家应该都比较熟悉，所以我就简单跳过了。Context 中的 startActivity 会调用到 ContextImpl.startActivity。

```java [frameworks/base/core/java/android/app/ContextImpl.java]

public void startActivity(Intent intent, Bundle options) { warnIfCallingFromSystemProcess();

// 一些异常判断
...

// 调用 Instrumentation 的 execStartActivity
mMainThread.getInstrumentation().execStartActivity(
        getOuterContext(), mMainThread.getApplicationThread(), null,
        (Activity) null, intent, -1, options);

} ```

2.2 Activity 的 startActivity

```java public void startActivityForResult(@RequiresPermission Intent intent, int requestCode, @Nullable Bundle options) { if (mParent == null) { options = transferSpringboardActivityOptions(options); // 调用 Instrumentation 的 execStartActivity Instrumentation.ActivityResult ar = mInstrumentation.execStartActivity( this, mMainThread.getApplicationThread(), mToken, this, intent, requestCode, options);

} else {
    if (options != null) {
        mParent.startActivityFromChild(this, intent, requestCode, options);
    } else {
        mParent.startActivityFromChild(this, intent, requestCode);
    }
}

} ```

对比两个两个 startActivity，我们发现 Activity 中的 startActivity 多了几个参数，分别是 mToken 和 this。这两个值决定了之后 Activity 启动中的栈管理逻辑，它们一个是后续的 token，一个则是 resultTo。

Activity 的栈管理是 Activity 启动的重要内容，后面在 AMS 中会详细讲述。

mMainThread 的类似是 ActivityThread，这里其实就是获取 ActivityThread 中的 Instrumentation，调用 Instrumentation.execStartActivity。

三 Instrumentation.execStartActivity

```java public ActivityResult execStartActivity( Context who, IBinder contextThread, IBinder token, Activity target, Intent intent, int requestCode, Bundle options) {

...

try {
    intent.migrateExtraStreamToClipData(who);
    intent.prepareToLeaveProcess(who);

    // 启动 Activity
    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);

    notifyStartActivityResult(result, options);
    checkStartActivityResult(result, intent);
} catch (RemoteException e) {
    throw new RuntimeException("Failure from system", e);
}
return null;

} ```

在 execStartActivity 中，会通过 ActivityTaskManager（后面检查 ATM） 的 getService 来启动 Activity。这里 getService 拿到的就是 ActivityTaskManagerService（后面简称为 ATMS）。

注意，我们需要关注mToken 和 this这两个参数的变化，这里它们变成了token和target，最后token会变成resultTo

3.1 ActivityTaskManager.getService

获取 ATMS 服务的 IBinder 对象，这个服务在之前 AMS 服务启动的时候会发布。到这里，就会通过 IBinder 调用到对应的 AMS 进程，后续的逻辑就是在 AMS 进程中运行了。

```java [frameworks/base/core/java/android/app/ActivityTaskManager.java]

public static IActivityTaskManager getService() { return IActivityTaskManagerSingleton.get(); }

@UnsupportedAppUsage(trackingBug = 129726065) private static final Singleton IActivityTaskManagerSingleton = new Singleton() { @Override protected IActivityTaskManager create() { // 从 ServiceManager 获取 Context.ACTIVITY_TASK_SERVICE final IBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE); return IActivityTaskManager.Stub.asInterface(b); } }; ```

3.2 ActivityTaskManagerService.onStart

java public void onStart() { publishBinderService(Context.ACTIVITY_TASK_SERVICE, mService); mService.start(); }

Context.ACTIVITY_TASK_SERVICE 服务其实就是 ATMS，在 ATMS 的 onStart 中，会将自己发布到 ServiceManager。所以启动 Activitiy 最终会调用到 ATMS 的 startActivity。

然后在 ATMS 的 startActivity 内部，会调用到 startActivityAsUser，所以我们直接看 startActivityAsUser。

3.3 ActivityTaskManagerService.startActivityAsUser

```java 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) { assertPackageMatchesCallingUid(callingPackage); enforceNotIsolatedCaller("startActivityAsUser");

userId = getActivityStartController().checkTargetUser(userId, validateIncomingUser,
        Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");

 // 获取 一个 ActivityStartController，然后通过它获取一个 ActivityStarter
// 然后执行 execute
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();

} ```

startActivityAsUser 这个函数更简单，就是获取一个 ActivityStarter，然后设置一堆的参数之后，调用 execute。这里的参数很多，但是我们只需要关注其中重要的几个即可

  • intent：启动 Activity 传入的参数
  • caller：这次调用的 ApplicationThread。（传入的是 IApplicationThread，ApplicationThread 是 ActivityThread 的内部类，它继承自 IApplicationThread，IApplicationThread 又继承自 IInterface，ApplicationThread 是用于应用进程和系统进程通信使用的）
  • resultTo：这次启动的动作来自哪个 Activity（可以是同一个进程，也可以是不同的进程，例如桌面的 Launch 进程。或者可以为空，例如从 Service 或其他非 Activity 的 Context 中启动），传入的是当前 Activity 的 Token（Token 是每个 Activity 的唯一标识）。

四 ActivityStarter

ActivityStarter 看名字也就知道，它这个类的任务就是用来启动 Activity 的。

4.1 ActivityStarter.obtainStarter

首先会通过一个工厂来获得 ActivityStarter，工厂中有一个 ActivityStarter 池，ActivityStarter 是可以复用的。

java [frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java] ActivityStarter obtainStarter(Intent intent, String reason) { // Factory 其实就是 ActivityStarter 的一个内部类。 // 这里获取 ActivityStarter 其实就是从 Factory 中的一个 ActivityStarter 池获取 return mFactory.obtain().setIntent(intent).setReason(reason); }

obtainStarter 其实就是从 ActivityStarter.Factory 的池子中，取出一个 ActivityStarter。因为 ActivityStarter 是可以复用的，所以有些参数并不需要每次都设置，它会使用之前的参数。

4.2 ActivityStarter.execute

```java [frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java]

int execute() { try { ...

    int res;
    synchronized (mService.mGlobalLock) {
        // 前面做了很多关于 Intent 参数的判断和参数解析相关的操作
        ...

        // 执行启动流程
        res = executeRequest(mRequest);
        ...
    }
} finally {
    onExecutionComplete();
}

} ```

4.3 ActivityStarter.executeRequest

executeRequest 开始就准备启动 Activity 了。这个函数很长，有 400 多行，根据 Google 官方的注释解释。这个函数主要做了这么两件事

  1. 首先执行初步的检查
  2. 调用 startActivityUnchecked 到 startActivityInner

```java

private int executeRequest(Request request) {

...
// 前面会通过 Supervisor.resolveActivity 做一些 Activity 和 Intent 的解析，
// 判断是否有匹配要启动的 Activity
// 如果存在多个，则会调用到 ActivityTaskSupervisor.resolveIntent 中
// 最后通过 PMS 让用户选择

// 前面做了好多检查，最后会把这些参数封装到一个 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);

...

return mLastStartActivityResult;

} ```

在 executeRequest 中，会将请求的参数封装到一个 ActivityRecord 中，然后调用 startActivityUnchecked。

4.4 ActivityStarter.startActivityUnchecked

startActivityUnchecked 主要就是调用了 startActivityInner，它才是真正执行启动 Activity 的逻辑。

```java private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord, IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor, int startFlags, boolean doResume, ActivityOptions options, Task inTask, boolean restrictedBgActivity, NeededUriGrants intentGrants) {

...

try {
    ...

    // 真正执行启动 Activity 的逻辑
    result = startActivityInner(r, sourceRecord, voiceSession, voiceInteractor,
            startFlags, doResume, options, inTask, restrictedBgActivity, intentGrants);
} finally {
    Trace.traceEnd(Trace.TRACE_TAG_WINDOW_MANAGER);
    ...
}

postStartActivityProcessing(r, result, startedActivityRootTask);

return result;

} ```

4.5 ActivityStarter.startActivityInner

从这一步开始，就是正式的启动 Activity 了，当然，启动 Activity 的过程中有三个重点

  1. 不同启动模式的 Activity 的启动原理
  2. 冷启动和热启动的原理
  3. Activity 是如何显示到界面上的

```java [frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java]

int startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord, IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor, int startFlags, boolean doResume, ActivityOptions options, Task inTask, boolean restrictedBgActivity, NeededUriGrants intentGrants) {

// 设置初始状态
setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,
        voiceInteractor, restrictedBgActivity);

// 首先就是计算 Activity 的启动模式
// 获得一个的 Flag，这玩意就是我们设置给 Intent 的。
computeLaunchingTaskFlags();

// 处理源 Activity 的任务栈
// 如果源 Activity 正在 finish 则需要开启一个新的栈
computeSourceRootTask();

// mLaunchFlags 就是前面计算的，这里设置给 mIntent
// 其实和我们启动 Activity 时自定义 Flag 很像
mIntent.setFlags(mLaunchFlags);

// Reusable 复用，这里是获取可以复用的 Task
final Task reusedTask = getReusableTask();

//是否需要冻结 Task 列表
if (mOptions != null && mOptions.freezeRecentTasksReordering()
        && mSupervisor.mRecentTasks.isCallerRecents(r.launchedFromUid)
        && !mSupervisor.mRecentTasks.isFreezeTaskListReorderingSet()) {
    mFrozeTaskList = true;
    mSupervisor.mRecentTasks.setFreezeTaskListReordering();
}

// 是否存在一个可以现在使用的 Task
// 是否有复用，如果没有，是否可以计算获取一个
final Task targetTask = reusedTask != null ? reusedTask : computeTargetTask();
// 如果没有可以现在使用的 Task，那么就创建一个新 Task
final boolean newTask = targetTask == null;
mTargetTask = targetTask;

// 计算启动参数
computeLaunchParams(r, sourceRecord, targetTask);

// 判断是否可以通过 targetTask 或者新建 Task 启动的 Activity
int startResult = isAllowedToStart(r, newTask, targetTask);
if (startResult != START_SUCCESS) {
    return startResult;
}

// 获取栈顶没有 finish 的 activity
final ActivityRecord targetTaskTop = newTask
        ? null : targetTask.getTopNonFinishingActivity();
if (targetTaskTop != null) {
    // 看一下栈顶的 Task targetTaskTop 是否可以回收复用
    startResult = recycleTask(targetTask, targetTaskTop, reusedTask, intentGrants);
    if (startResult != START_SUCCESS) {
        return startResult;
    }
} else {
    mAddingToTask = true;
}

// 如果要启动的 Activity 与当前在顶部的 Activity 相同，那么我们需要检查它是否应该只被启动一次。
final Task topRootTask = mPreferredTaskDisplayArea.getFocusedRootTask();

if (topRootTask != null) {
    startResult = deliverToCurrentTopIfNeeded(topRootTask, intentGrants);
    if (startResult != START_SUCCESS) {
        return startResult;
    }
}

if (mTargetRootTask == null) {
    // 获得一个栈 Task
    mTargetRootTask = getLaunchRootTask(mStartActivity, mLaunchFlags, targetTask, mOptions);
}

if (newTask) {
    // 如果是新建 Task
    final Task taskToAffiliate = (mLaunchTaskBehind && mSourceRecord != null)
            ? mSourceRecord.getTask() : null;
    // 关联 Task 与 ActivityRecord
    // 这个函数也会调用 addOrReparentStartingActivity
    setNewTask(taskToAffiliate);
} else if (mAddingToTask) {
    // 将要启动的 Activity 添加到 targetTask
    // 并且会将此 Activity 添加到最近启动的 ActivityRecord 中，后续可以通过 findActivity 复用
    addOrReparentStartingActivity(targetTask, "adding to task");
}

if (!mAvoidMoveToFront && mDoResume) {
    mTargetRootTask.getRootTask().moveToFront("reuseOrNewTask", targetTask);
    if (mOptions != null) {
        if (mOptions.getTaskAlwaysOnTop()) {
            mTargetRootTask.setAlwaysOnTop(true);
        }
    }
    if (!mTargetRootTask.isTopRootTaskInDisplayArea() && mService.mInternal.isDreaming()) {
        // Launching underneath dream activity (fullscreen, always-on-top). Run the launch-
        // -behind transition so the Activity gets created and starts in visible state.
        mLaunchTaskBehind = true;
        r.mLaunchTaskBehind = true;
    }
}

mService.mUgmInternal.grantUriPermissionUncheckedFromIntent(intentGrants,
        mStartActivity.getUriPermissionsLocked());
if (mStartActivity.resultTo != null && mStartActivity.resultTo.info != null) {
    // we need to resolve resultTo to a uid as grantImplicitAccess deals explicitly in UIDs
    final PackageManagerInternal pmInternal =
            mService.getPackageManagerInternalLocked();
    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*/);
}
if (newTask) {
    EventLogTags.writeWmCreateTask(mStartActivity.mUserId,
            mStartActivity.getTask().mTaskId);
}
mStartActivity.logStartActivity(
        EventLogTags.WM_CREATE_ACTIVITY, mStartActivity.getTask());

mTargetRootTask.mLastPausedActivity = null;

mRootWindowContainer.startPowerModeLaunchIfNeeded(
        false /* forceSend */, mStartActivity);

mTargetRootTask.startActivityLocked(mStartActivity,
        topRootTask != null ? topRootTask.getTopNonFinishingActivity() : null, newTask,
        mKeepCurTransition, mOptions, sourceRecord);
if (mDoResume) {
    final ActivityRecord topTaskActivity =
            mStartActivity.getTask().topRunningActivityLocked();


    // 要启动的 Activity 无法获取焦点
    if (!mTargetRootTask.isTopActivityFocusable()
            || (topTaskActivity != null && topTaskActivity.isTaskOverlay()
            && mStartActivity != topTaskActivity)) {

        // 如果 Activity 不可见就无法恢复
        // 如有要确保可见，就会触发进入动画
        // 并且，被覆盖的 Activity，直到覆盖物被移除前，都是不可见的
        mTargetRootTask.ensureActivitiesVisible(null /* starting */,
                0 /* configChanges */, !PRESERVE_WINDOWS);
        // 告诉 WMS 继续执行，因为现在 Activity 还无法恢复。
        mTargetRootTask.mDisplayContent.executeAppTransition();
    } else {
        //
        if (mTargetRootTask.isTopActivityFocusable()
                && !mRootWindowContainer.isTopDisplayFocusedRootTask(mTargetRootTask)) {
            mTargetRootTask.moveToFront("startActivityInner");
        }

        // 恢复栈顶的 Activity
        mRootWindowContainer.resumeFocusedTasksTopActivities(
                mTargetRootTask, mStartActivity, mOptions, mTransientLaunch);
    }
}
mRootWindowContainer.updateUserRootTask(mStartActivity.mUserId, mTargetRootTask);

// Activity 启动时立即更新最近的任务列表
mSupervisor.mRecentTasks.add(mStartActivity.getTask());
mSupervisor.handleNonResizableTaskIfNeeded(mStartActivity.getTask(),
        mPreferredWindowingMode, mPreferredTaskDisplayArea, mTargetRootTask);

return START_SUCCESS;

} ```

startActivityInner 这个函数做了很多事，但是这里就不展开了，后面在 Activity 的栈管理中还会详细说明这个函数。我们现在知道，它通过 RootWindowContainer 调用了 resumeFocusedTasksTopActivities。

五 RootWindowContainer

5.1 resumeFocusedTasksTopActivities

```java [frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java]

boolean resumeFocusedTasksTopActivities( Task targetRootTask, ActivityRecord target, ActivityOptions targetOptions, boolean deferPause) {

//  mTaskSupervisor 判断是否恢复状态
if (!mTaskSupervisor.readyToResume()) {
    return false;
}

boolean result = false;
if (targetRootTask != null && (targetRootTask.isTopRootTaskInDisplayArea()
        || getTopDisplayFocusedRootTask() == targetRootTask)) {

    // 恢复栈顶的 Activity
    result = targetRootTask.resumeTopActivityUncheckedLocked(target, targetOptions,
            deferPause);
}

for (int displayNdx = getChildCount() - 1; displayNdx >= 0; --displayNdx) {
    ...
    if (!resumedOnDisplay[0]) {

        ...

        if (focusedRoot != null) {
            final Task focusedRoot = display.getFocusedRootTask();
            // 恢复栈顶的 Activity
            result |= focusedRoot.resumeTopActivityUncheckedLocked(target, targetOptions);
        } else if (targetRootTask == null) {
            result |= resumeHomeActivity(null /* prev */, "no-focusable-task",
                    display.getDefaultTaskDisplayArea());
        }
    }
}

return result;

} ```

然后在 resumeTopActivityUncheckedLocked 中，调用到了 Task.resumeTopActivityInnerLocked。

六 Task

Task 是系统对 ActivityRecord 的又一层封装。

Task.resumeTopActivityInnerLocked

```java

@GuardedBy("mService") private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options, boolean deferPause) { ...

if (next.attachedToProcess()) {
    ...

    try {
        final ClientTransaction transaction =
                ClientTransaction.obtain(next.app.getThread(), next.appToken);
        ...

        // 启动事务
        mAtmService.getLifecycleManager().scheduleTransaction(transaction);
    } catch (Exception e) {
        // Whoops, need to restart this activity!
        ...

        // 调用
        mTaskSupervisor.startSpecificActivity(next, true, false);
        return true;
    }

    ...
} else {
    // Whoops, need to restart this activity!
    ...
    mTaskSupervisor.startSpecificActivity(next, true, true);
}

return true;

} ```

七 ActivityTaskSupervisor

ActivityTaskSupervisor 是 Activity 栈的超级管理者，所以它负责者 Activity 的栈的。

7.1 startSpecificActivity

```java void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) { ... if (wpc != null && wpc.hasThread()) { try {

              // 真正启动 Activity
        realStartActivityLocked(r, wpc, andResume, checkConfig);
        return;
    } catch (RemoteException e) {
        Slog.w(TAG, "Exception when starting activity "
                + r.intent.getComponent().flattenToShortString(), e);
    }

    ...
}

...

} ```

7.2 realStartActivityLocked

```java

boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc, boolean andResume, boolean checkConfig) throws RemoteException {

    ...

    // 这里的 proc.getThread() 其实拿到的是 ActivityThread
    final ClientTransaction clientTransaction = ClientTransaction.obtain(
                        proc.getThread(), r.appToken);

    try {
        ...

        // 启动事务，mService 是 ActivityTaskManagerService
        // 拿到的 Manager 是 ClientLifecycleManager
        mService.getLifecycleManager().scheduleTransaction(clientTransaction);

        ...

    } catch (RemoteException e) {
        ...

return true;

} ```

realStartActivityLocked 里首先会通过 proc.getThread 拿到一个 ActivityThread，然后通过 ActivityThread 拿到一个 ClientTransaction。

然后会有一个 mService，它就是 ATMS，然后通过 ATMS 的 getLifecycleManager 拿到 ClientLifecycleManager 并调用它的 scheduleTransaction。

八 ClientLifecycleManager

8.1 scheduleTransaction

```java void scheduleTransaction(ClientTransaction transaction) throws RemoteException { final IApplicationThread client = transaction.getClient();

// 执行 ClientTransaction 的 schedule
transaction.schedule();
if (!(client instanceof Binder)) {
    // 如果客户端不是 Binder 的实例--即这是一个远程调用，
    // 此时回收该对象是安全的。
    // 所有用于本地调用的对象在 ActivityThread 中的客户端上执行完事务后将被回收
    transaction.recycle();
}

} ```

九 ClientTransaction

9.1 schedule

```java [frameworks/base/core/java/android/app/servertransaction/ClientTransaction.java]

// 这个 mClient，其实就是之前创建的 private IApplicationThread mClient;

public void schedule() throws RemoteException { mClient.scheduleTransaction(this); } ```

这里有一个 mClient，其实就是之前 obtain 中传入的 proc.getThread。而这个 proc 其实就是 WindowProcessController。而获取到的 Thread 就是 IApplicationThread。

这里用到了跨进程通信，这个 IApplicationThread 真正的实现是 ActivityThread 的内部类 ApplicationThread。

所以前面调用的 transaction.schedule 其实就是 ApplicationThread.scheduleTransaction。而 ApplicationThread 其实是 ActivityThread 的内部类。

十 ActivityThread

10.1 scheduleTransaction

java public void scheduleTransaction(ClientTransaction transaction) throws RemoteException { ActivityThread.this.scheduleTransaction(transaction); }

调用到了 ActivityThread 的 scheduleTransaction，然后 ActivityThread 里并没有 scheduleTransaction，仔细一看，原来它继承自 ClientTransactionHandler，真正的实现在它的父类。

java public final class ActivityThread extends ClientTransactionHandler implements ActivityThreadInternal {

十一 ClientTransactionHandler

11.1 scheduleTransaction

```java [frameworks/base/core/java/android/app/ClientTransactionHandler.java]

void scheduleTransaction(ClientTransaction transaction) { transaction.preExecute(this); sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction); } ```

然后在父类 ClientTransactionHandler 中，会通过消息机制发送一条 EXECUTE_TRANSACTION 的消息，这个会调用到 ActivityThread 的 Handle 中。

在 ActivityThread 的消息处理中，首先会执行这个 ClientTransaction，然后再将它回收（调用 recycle）。

java case EXECUTE_TRANSACTION: final ClientTransaction transaction = (ClientTransaction) msg.obj; mTransactionExecutor.execute(transaction); 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;

接下来的流程就比较简单了，通过消息机制，在 ActivityThread 的 handleMessage 中，调用了 execute 执行之前传递过来的 ClientTransaction。

十二 TransactionExecutor

12.1 execute

```java [frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java]

public void execute(ClientTransaction transaction) {

...

executeCallbacks(transaction);

executeLifecycleState(transaction);
mPendingActions.clear();

} ```

12.2 executeCallbacks

```java @VisibleForTesting public void executeCallbacks(ClientTransaction transaction) { ... for (int i = 0; i < size; ++i) { ...

    cycleToPath(r, postExecutionState, shouldExcludeLastTransition, transaction);
}

} ```

12.3 cycleToPath

java private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState, ClientTransaction transaction) { ... performLifecycleSequence(r, path, transaction); }

12.4 performLifecycleSequence

TransactionExecutor 中有一个 mTransactionHandler，它的类型是 ClientTransactionHandler，这个变量其实就是在创建的时候初始化的，在 ActivityThread 中，ActivityThread 将自己作为参数传递了进来，所以这个 mTransactionHandler 其实就是 ActivityThread。

```java private void performLifecycleSequence(ActivityClientRecord r, IntArray path, ClientTransaction transaction) { final int size = path.size(); for (int i = 0, state; i < size; i++) { state = path.get(i);

    switch (state) {
        case ON_CREATE:
            mTransactionHandler.handleLaunchActivity(r, mPendingActions,
                    null /* customIntent */);
            break;
        case ON_START:
            mTransactionHandler.handleStartActivity(r, mPendingActions,
                    null /* activityOptions */);
            break;
        case ON_RESUME:
            mTransactionHandler.handleResumeActivity(r, false /* finalStateRequest */,
                    r.isForward, "LIFECYCLER_RESUME_ACTIVITY");
            break;
        case ON_PAUSE:
            mTransactionHandler.handlePauseActivity(r, false /* finished */,
                    false /* userLeaving */, 0 /* configChanges */,
                    false /* autoEnteringPip */, mPendingActions,
                    "LIFECYCLER_PAUSE_ACTIVITY");
            break;
        case ON_STOP:
            mTransactionHandler.handleStopActivity(r, 0 /* configChanges */,
                    mPendingActions, false /* finalStateRequest */,
                    "LIFECYCLER_STOP_ACTIVITY");
            break;
        case ON_DESTROY:
            mTransactionHandler.handleDestroyActivity(r, false /* finishing */,
                    0 /* configChanges */, false /* getNonConfigInstance */,
                    "performLifecycleSequence. cycling to:" + path.get(size - 1));
            break;
        case ON_RESTART:
            mTransactionHandler.performRestartActivity(r, false /* start */);
            break;
        default:
            throw new IllegalArgumentException("Unexpected lifecycle state: " + state);
    }
}

} ```

最后就通过这里的 ActivityThread 调用到了对应的生命周期。

十三 总结

到这里，Activity 的启动流程我们算是梳理完了，但是，Activity 启动的复杂程度远不止如此，本篇博客中，我忽略了其中的很多细节。例如：

  1. 进程的启动（启动 Activity 时会判断进程的存在与否，应用的进程是如何启动的）
  2. 进程的管理（通过进程的启动，引申出进程是如何管理的，Activity 的前后台切换，优先级与系统杀进程）
  3. Activity 栈的管理（Activity 栈是如何复用的）

由于以上的逻辑涉及很多 AMS 的工作原理，所以我打算放 AMS 源码解析中说明。下面我们用一幅图来总结一下 Activity 的启动的大致流程。

startActivity流程~1.png

「」