AOSP15 WMS/AMS系统开发 - Activity 生命周期源码详细分析

基于 /home/zhangxiaoxiao/aosp15 源码，详细分析 Activity 启动(start)、暂停(pause)、恢复(resume)的完整流程。涵盖 App 进程侧、SystemServer 进程侧的完整调用链路。

一、整体架构概览
[二、Activity 启动流程 (Start)](#二、Activity 启动流程 (Start) "#%E4%BA%8Cactivity-%E5%90%AF%E5%8A%A8%E6%B5%81%E7%A8%8B-start")
- [2.1 App进程: Activity.startActivity](#2.1 App进程: Activity.startActivity "#21-app%E8%BF%9B%E7%A8%8B-activitystartactivity")
- [2.2 App进程: Instrumentation.execStartActivity](#2.2 App进程: Instrumentation.execStartActivity "#22-app%E8%BF%9B%E7%A8%8B-instrumentationexecstartactivity")
- [2.3 跨进程: Binder IPC 到 system_server](#2.3 跨进程: Binder IPC 到 system_server "#23-%E8%B7%A8%E8%BF%9B%E7%A8%8B-binder-ipc-%E5%88%B0-system_server")
- [2.4 SystemServer: ATMS.startActivityAsUser](#2.4 SystemServer: ATMS.startActivityAsUser "#24-systemserver-atmsstartactivityasuser")
- [2.5 SystemServer: ActivityStarter.execute](#2.5 SystemServer: ActivityStarter.execute "#25-systemserver-activitystarterexecute")
- [2.6 SystemServer: ActivityStarter.startActivityUnchecked](#2.6 SystemServer: ActivityStarter.startActivityUnchecked "#26-systemserver-activitystarterstartactivityunchecked")
- [2.7 SystemServer: ActivityStarter.startActivityInner](#2.7 SystemServer: ActivityStarter.startActivityInner "#27-systemserver-activitystarterstartactivityinner")
- [2.8 SystemServer: TaskFragment.resumeTopActivity 触发 Launch](#2.8 SystemServer: TaskFragment.resumeTopActivity 触发 Launch "#28-systemserver-taskfragmentresumetopactivity-%E8%A7%A6%E5%8F%91-launch")
- [2.9 SystemServer: ActivityTaskSupervisor.realStartActivityLocked 构建事务](#2.9 SystemServer: ActivityTaskSupervisor.realStartActivityLocked 构建事务 "#29-systemserver-activitytasksupervisorrealstartactivitylocked-%E6%9E%84%E5%BB%BA%E4%BA%8B%E5%8A%A1")
- [2.10 跨进程: ClientTransaction 传递回 App 进程](#2.10 跨进程: ClientTransaction 传递回 App 进程 "#210-%E8%B7%A8%E8%BF%9B%E7%A8%8B-clienttransaction-%E4%BC%A0%E9%80%92%E5%9B%9E-app-%E8%BF%9B%E7%A8%8B")
- [2.11 App进程: TransactionExecutor 执行事务](#2.11 App进程: TransactionExecutor 执行事务 "#211-app%E8%BF%9B%E7%A8%8B-transactionexecutor-%E6%89%A7%E8%A1%8C%E4%BA%8B%E5%8A%A1")
- [2.12 App进程: LaunchActivityItem → ActivityThread.handleLaunchActivity](#2.12 App进程: LaunchActivityItem → ActivityThread.handleLaunchActivity "#212-app%E8%BF%9B%E7%A8%8B-launchactivityitem--activitythreadhandlelaunchactivity")
- [2.13 App进程: ActivityThread.performLaunchActivity 创建 Activity](#2.13 App进程: ActivityThread.performLaunchActivity 创建 Activity "#213-app%E8%BF%9B%E7%A8%8B-activitythreadperformlaunchactivity-%E5%88%9B%E5%BB%BA-activity")
- [2.14 App进程: cycleToPath → handleStartActivity → onStart](#2.14 App进程: cycleToPath → handleStartActivity → onStart "#214-app%E8%BF%9B%E7%A8%8B-cycletopath--handlestartactivity--onstart")
- [2.15 App进程: ResumeActivityItem → handleResumeActivity → onResume](#2.15 App进程: ResumeActivityItem → handleResumeActivity → onResume "#215-app%E8%BF%9B%E7%A8%8B-resumeactivityitem--handleresumeactivity--onresume")
- [2.16 启动流程总结图](#2.16 启动流程总结图 "#216-%E5%90%AF%E5%8A%A8%E6%B5%81%E7%A8%8B%E6%80%BB%E7%BB%93%E5%9B%BE")
[三、Activity 暂停流程 (Pause)](#三、Activity 暂停流程 (Pause) "#%E4%B8%89activity-%E6%9A%82%E5%81%9C%E6%B5%81%E7%A8%8B-pause")
- [3.1 SystemServer: TaskFragment.startPausing](#3.1 SystemServer: TaskFragment.startPausing "#31-systemserver-taskfragmentstartpausing")
- [3.2 SystemServer: schedulePauseActivity 构建 PauseActivityItem](#3.2 SystemServer: schedulePauseActivity 构建 PauseActivityItem "#32-systemserver-schedulepauseactivity-%E6%9E%84%E5%BB%BA-pauseactivityitem")
- [3.3 跨进程: ClientLifecycleManager 发送 Pause 事务](#3.3 跨进程: ClientLifecycleManager 发送 Pause 事务 "#33-%E8%B7%A8%E8%BF%9B%E7%A8%8B-clientlifecyclemanager-%E5%8F%91%E9%80%81-pause-%E4%BA%8B%E5%8A%A1")
- [3.4 App进程: PauseActivityItem.execute → handlePauseActivity](#3.4 App进程: PauseActivityItem.execute → handlePauseActivity "#34-app%E8%BF%9B%E7%A8%8B-pauseactivityitemexecute--handlepauseactivity")
- [3.5 App进程: performPauseActivityIfNeeded → Activity.onPause](#3.5 App进程: performPauseActivityIfNeeded → Activity.onPause "#35-app%E8%BF%9B%E7%A8%8B-performpauseactivityifneeded--activityonpause")
- [3.6 App进程: PauseActivityItem.postExecute → 通知服务端](#3.6 App进程: PauseActivityItem.postExecute → 通知服务端 "#36-app%E8%BF%9B%E7%A8%8B-pauseactivityitempostexecute--%E9%80%9A%E7%9F%A5%E6%9C%8D%E5%8A%A1%E7%AB%AF")
- [3.7 SystemServer: completePause 完成暂停](#3.7 SystemServer: completePause 完成暂停 "#37-systemserver-completepause-%E5%AE%8C%E6%88%90%E6%9A%82%E5%81%9C")
- [3.8 暂停流程总结图](#3.8 暂停流程总结图 "#38-%E6%9A%82%E5%81%9C%E6%B5%81%E7%A8%8B%E6%80%BB%E7%BB%93%E5%9B%BE")
[四、Activity 恢复流程 (Resume)](#四、Activity 恢复流程 (Resume) "#%E5%9B%9Bactivity-%E6%81%A2%E5%A4%8D%E6%B5%81%E7%A8%8B-resume")
- [4.1 SystemServer: resumeFocusedTasksTopActivities](#4.1 SystemServer: resumeFocusedTasksTopActivities "#41-systemserver-resumefocusedtaskstopactivities")
- [4.2 SystemServer: TaskFragment.resumeTopActivity](#4.2 SystemServer: TaskFragment.resumeTopActivity "#42-systemserver-taskfragmentresumetopactivity")
- [4.3 跨进程: ResumeActivityItem 发送到 App 进程](#4.3 跨进程: ResumeActivityItem 发送到 App 进程 "#43-%E8%B7%A8%E8%BF%9B%E7%A8%8B-resumeactivityitem-%E5%8F%91%E9%80%81%E5%88%B0-app-%E8%BF%9B%E7%A8%8B")
- [4.4 App进程: ResumeActivityItem.execute → handleResumeActivity](#4.4 App进程: ResumeActivityItem.execute → handleResumeActivity "#44-app%E8%BF%9B%E7%A8%8B-resumeactivityitemexecute--handleresumeactivity")
- [4.5 App进程: performResumeActivity → Activity.performResume → onResume](#4.5 App进程: performResumeActivity → Activity.performResume → onResume "#45-app%E8%BF%9B%E7%A8%8B-performresumeactivity--activityperformresume--onresume")
- [4.6 App进程: handleResumeActivity 中的窗口管理](#4.6 App进程: handleResumeActivity 中的窗口管理 "#46-app%E8%BF%9B%E7%A8%8B-handleresumeactivity-%E4%B8%AD%E7%9A%84%E7%AA%97%E5%8F%A3%E7%AE%A1%E7%90%86")
- [4.7 App进程: ResumeActivityItem.postExecute → 通知服务端](#4.7 App进程: ResumeActivityItem.postExecute → 通知服务端 "#47-app%E8%BF%9B%E7%A8%8B-resumeactivityitempostexecute--%E9%80%9A%E7%9F%A5%E6%9C%8D%E5%8A%A1%E7%AB%AF")
- [4.8 SystemServer: completeResumeLocked](#4.8 SystemServer: completeResumeLocked "#48-systemserver-completeresumelocked")
- [4.9 恢复流程总结图](#4.9 恢复流程总结图 "#49-%E6%81%A2%E5%A4%8D%E6%B5%81%E7%A8%8B%E6%80%BB%E7%BB%93%E5%9B%BE")
五、生命周期状态机与事务机制
- [5.1 ClientTransaction 事务框架](#5.1 ClientTransaction 事务框架 "#51-clienttransaction-%E4%BA%8B%E5%8A%A1%E6%A1%86%E6%9E%B6")
- [5.2 TransactionExecutor 生命周期状态机](#5.2 TransactionExecutor 生命周期状态机 "#52-transactionexecutor-%E7%94%9F%E5%91%BD%E5%91%A8%E6%9C%9F%E7%8A%B6%E6%80%81%E6%9C%BA")
- [5.3 cycleToPath 状态路径计算](#5.3 cycleToPath 状态路径计算 "#53-cycletopath-%E7%8A%B6%E6%80%81%E8%B7%AF%E5%BE%84%E8%AE%A1%E7%AE%97")
六、全流程串联

一、整体架构概览

Activity 生命周期管理涉及两个进程之间的协作：

复制代码

┌─────────────────────────┐          Binder IPC           ┌──────────────────────────┐
│      App 进程            │ ◄──────────────────────────►  │    SystemServer 进程     │
│                         │                               │                          │
│  Activity               │                               │  ATMS                    │
│  Instrumentation        │  IActivityTaskManager.aidl    │  ActivityStarter         │
│  ActivityThread         │  ───────────────────────►     │  TaskFragment            │
│  TransactionExecutor    │                               │  ActivityRecord          │
│  LaunchActivityItem     │  IApplicationThread.aidl      │  RootWindowContainer     │
│  PauseActivityItem      │  ◄───────────────────────     │  ActivityTaskSupervisor  │
│  ResumeActivityItem     │                               │  ClientLifecycleManager  │
│  ClientTransaction      │                               │  ActivityClientController│
└─────────────────────────┘                               └──────────────────────────┘

核心设计模式 : Client-Server 架构，通过 ClientTransaction 事务机制 实现 SystemServer 到 App 进程的生命周期调度。

二、Activity 启动流程 (Start)

2.1 App进程: Activity.startActivity

文件 : Activity.java

所有 startActivity 重载最终汇聚到 startActivityForResult：

java 复制代码

// Activity.java
@Override
public void startActivity(Intent intent) {
    this.startActivity(intent, null);
}

// Activity.java
@Override
public void startActivity(Intent intent, @Nullable Bundle options) {
    getAutofillClientController().onStartActivity(intent, mIntent);
    if (options != null) {
        startActivityForResult(intent, -1, options);
    } else {
        startActivityForResult(intent, -1);
    }
}

// Activity.java
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
        @Nullable Bundle options) {
    if (mParent == null) {
        options = transferSpringboardActivityOptions(options);
        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);
    }
}

调用链:

scss 复制代码

startActivity(intent)
  → startActivity(intent, null)
    → startActivityForResult(intent, -1)
      → startActivityForResult(intent, -1, null)
        → mInstrumentation.execStartActivity(...)

关键参数:

mMainThread.getApplicationThread(): App 进程的 IApplicationThread Binder 对象，用于 system_server 回调
mToken: 当前 Activity 的 Binder token，用于标识调用者
requestCode: -1 表示不需要返回结果

2.2 App进程: Instrumentation.execStartActivity

文件 : Instrumentation.java

java 复制代码

public ActivityResult execStartActivity(
        Context who, IBinder contextThread, IBinder token, Activity target,
        Intent intent, int requestCode, Bundle options) {
    // ... ActivityMonitor 检测 ...

    try {
        intent.migrateExtraStreamToClipData(who);
        intent.prepareToLeaveProcess(who);
        int result = ActivityTaskManager.getService().startActivity(
                whoThread,                    // IApplicationThread caller
                who.getOpPackageName(),       // callingPackage
                who.getAttributionTag(),      // callingFeatureId
                intent,                       // intent
                intent.resolveTypeIfNeeded(who.getContentResolver()), // resolvedType
                token,                        // resultTo (调用者的token)
                target != null ? target.mEmbeddedID : null, // resultWho
                requestCode,                  // requestCode
                0,                            // startFlags
                null,                         // profilerInfo
                options);                     // options
        notifyStartActivityResult(result, options);
        checkStartActivityResult(result, intent);
    } catch (RemoteException e) {
        throw new RuntimeException("Failure from system", e);
    }
    return null;
}

核心调用 ：ActivityTaskManager.getService().startActivity(...) --- 这是 第一次跨进程调用。

ActivityTaskManager.getService() 获取的是 IActivityTaskManager 的 Binder 代理：

java 复制代码

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

private static final Singleton<IActivityTaskManager> IActivityTaskManagerSingleton =
        new Singleton<IActivityTaskManager>() {
            @Override
            protected IActivityTaskManager create() {
                final IBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);
                return IActivityTaskManager.Stub.asInterface(b);
            }
        };

2.3 跨进程: Binder IPC 到 system_server

AIDL接口 : IActivityTaskManager.aidl

java 复制代码

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);

跨进程方向：App进程 → SystemServer进程

关键传递参数：

参数	含义
`caller` (IApplicationThread)	调用方进程的 Binder 句柄
`resultTo` (IBinder)	调用方 Activity 的 token
`intent`	要启动的 Intent
`requestCode`	请求码，-1 表示不需要结果

2.4 SystemServer: ATMS.startActivityAsUser

文件 : ActivityTaskManagerService.java

java 复制代码

// ATMS.java --- 入口
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());
}

// ATMS.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) {
    mAmInternal.addCreatorToken(intent, callingPackage);
    final int callingPid = Binder.getCallingPid();
    final int callingUid = Binder.getCallingUid();
    final SafeActivityOptions opts = SafeActivityOptions.fromBundle(bOptions, callingPid, callingUid);

    assertPackageMatchesCallingUid(callingPackage);
    enforceNotIsolatedCaller("startActivityAsUser");

    userId = getActivityStartController().checkTargetUser(userId, validateIncomingUser,
            callingPid, callingUid, "startActivityAsUser");

    // 获取 ActivityStarter 并执行
    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();  // ← 关键调用
}

调用链:

scss 复制代码

ATMS.startActivity()
  → ATMS.startActivityAsUser()
    → ActivityStartController.obtainStarter(intent)
      → ActivityStarter.execute()

2.5 SystemServer: ActivityStarter.execute

文件 : ActivityStarter.java

java 复制代码

int execute() {
    String callerActivityName = null;
    ActivityRecord launchingRecord = null;
    try {
        onExecutionStarted();
        // ... intent 校验 ...

        int res = START_CANCELED;
        synchronized (mService.mGlobalLock) {
            final boolean globalConfigWillChange = mRequest.globalConfig != null
                    && mService.getGlobalConfiguration().diff(mRequest.globalConfig) != 0;

            res = resolveToHeavyWeightSwitcherIfNeeded();
            if (res != START_SUCCESS) {
                return res;
            }

            res = executeRequest(mRequest);  // ← 核心
        }
        // ... 处理结果 ...
    } finally {
        onExecutionComplete();
    }
}

executeRequest 进行：

权限检查、BAL (Background Activity Launch) 限制检查
创建 ActivityRecord
调用 startActivityUnchecked()

2.6 SystemServer: ActivityStarter.startActivityUnchecked

文件 : ActivityStarter.java

java 复制代码

private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
        IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
        int startFlags, ActivityOptions options, Task inTask,
        TaskFragment inTaskFragment, BalVerdict balVerdict,
        NeededUriGrants intentGrants, int realCallingUid,
        Transition transition, boolean isIndependentLaunch) {

    // 创建 display 快照、延迟窗口布局等准备工作
    // ...

    try {
        mService.deferWindowLayout();
        try {
            result = startActivityInner(r, sourceRecord, voiceSession, voiceInteractor,
                    startFlags, options, inTask, inTaskFragment, balVerdict,
                    intentGrants, realCallingUid);
        } catch (Exception e) {
            // 异常处理
        }
    } finally {
        mService.continueWindowLayout();
    }
    return result;
}

startActivityUnchecked 是 executeRequest 和 startActivityInner 之间的关键中间层，负责：

延迟窗口布局 (deferWindowLayout)，避免启动过程中的布局竞争
收集 Transition 信息
在 try-finally 中调用 startActivityInner，确保窗口布局总能恢复

2.7 SystemServer: ActivityStarter.startActivityInner

文件 : ActivityStarter.java

java 复制代码

int startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord,
        IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
        int startFlags, ActivityOptions options, Task inTask,
        TaskFragment inTaskFragment, BalVerdict balVerdict,
        NeededUriGrants intentGrants, int realCallingUid) {

    setInitialState(r, options, inTask, inTaskFragment, startFlags, sourceRecord,
            voiceSession, voiceInteractor, balVerdict.getCode(), realCallingUid);

    computeLaunchingTaskFlags();
    mIntent.setFlags(mLaunchFlags);

    final Task prevTopRootTask = mPreferredTaskDisplayArea.getFocusedRootTask();
    final Task prevTopTask = prevTopRootTask != null ? prevTopRootTask.getTopLeafTask() : null;

    // 解析可复用的 Task 或计算新的目标 Task
    final Task reusedTask = resolveReusableTask(includeLaunchedFromBubble);
    final Task targetTask = reusedTask != null ? reusedTask : computeTargetTask();
    final boolean newTask = targetTask == null;
    mTargetTask = targetTask;

    computeLaunchParams(r, sourceRecord, targetTask);

    // 检查是否允许启动
    int startResult = isAllowedToStart(r, newTask, targetTask);
    if (startResult != START_SUCCESS) {
        return startResult;
    }

    // ... 将 ActivityRecord 添加到 Task/TaskFragment 中 ...

    // 关键：触发 resume
    mRootWindowContainer.resumeFocusedTasksTopActivities(
            mTargetRootTask, r, mOptions, false /* deferPause */);
    // ...
}

startActivityInner 完成 Activity 在 Task 栈中的定位后，调用 resumeFocusedTasksTopActivities 触发目标 Activity 的实际启动和 resume。

2.8 SystemServer: TaskFragment.resumeTopActivity 触发 Launch

文件 : RootWindowContainer.java

java 复制代码

boolean resumeFocusedTasksTopActivities(
        Task targetRootTask, ActivityRecord target, ActivityOptions targetOptions,
        boolean deferPause) {
    if (!mTaskSupervisor.readyToResume()) {
        return false;
    }

    boolean result = false;
    if (targetRootTask != null && (targetRootTask.isTopRootTaskInDisplayArea()
            || getTopDisplayFocusedRootTask() == targetRootTask)) {
        result = targetRootTask.resumeTopActivityUncheckedLocked(target, targetOptions,
                deferPause);
    }
    // ... 遍历其他 display ...

    return result;
}

TaskFragment.resumeTopActivity (TaskFragment.java) 是核心方法：

java 复制代码

final boolean resumeTopActivity(ActivityRecord prev, ActivityOptions options,
        boolean skipPause) {
    ActivityRecord next = topRunningActivity(true /* focusableOnly */);

    // ... 校验 ...

    // 1. 先暂停当前 Resume 状态的 Activity
    boolean pausing = !skipPause && taskDisplayArea.pauseBackTasks(next);
    if (mResumedActivity != null) {
        pausing |= startPausing(mTaskSupervisor.mUserLeaving, false /* uiSleeping */,
                next, "resumeTopActivity");
    }

    // 2. 如果已经在 pause 中，等待 pause 完成
    if (pausing) {
        return true;
    }

    // ... 状态检查 ...

    // 3. 目标 Activity 已附加进程
    if (next.attachedToProcess()) {
        // 已有进程，直接 resume
        next.completeResumeLocked();
    } else {
        // 4. 目标 Activity 没有进程或进程未附加 → 启动新进程/发送 Launch 事务
        mTaskSupervisor.startSpecificActivity(next, true, true);
    }
}

2.9 SystemServer: ActivityTaskSupervisor.realStartActivityLocked 构建事务

文件 : ActivityTaskSupervisor.java

当目标 Activity 需要启动时（没有进程或进程未附加），调用链为：

scss 复制代码

startSpecificActivity()
  → realStartActivityLocked()

realStartActivityLocked 是构建 ClientTransaction 的核心方法：

java 复制代码

// ActivityTaskSupervisor.java (关键片段)
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
        boolean andResume, boolean checkConfig) throws RemoteException {

    // ... 各种准备工作 ...

    // 1. 创建 LaunchActivityItem
    final LaunchActivityItem launchActivityItem = new LaunchActivityItem(r.token,
            r.intent, System.identityHashCode(r), r.info,
            procConfig, overrideConfig, deviceId,
            r.getFilteredReferrer(r.launchedFromPackage), task.voiceInteractor,
            proc.getReportedProcState(), r.getSavedState(), r.getPersistentSavedState(),
            results, newIntents, r.takeSceneTransitionInfo(), isTransitionForward,
            proc.createProfilerInfoIfNeeded(), r.assistToken, activityClientController,
            r.shareableActivityToken, r.getLaunchedFromBubble(), fragmentToken,
            r.initialCallerInfoAccessToken, activityWindowInfo);

    // 2. 根据目标状态创建 LifecycleItem
    final ActivityLifecycleItem lifecycleItem;
    if (andResume) {
        lifecycleItem = new ResumeActivityItem(r.token, isTransitionForward,
                r.shouldSendCompatFakeFocus());
    } else if (r.isVisibleRequested()) {
        lifecycleItem = new PauseActivityItem(r.token);
    } else {
        lifecycleItem = new StopActivityItem(r.token);
    }

    // 3. 通过 ClientLifecycleManager 发送事务
    mService.getLifecycleManager().scheduleTransactionItems(
            proc.getThread(),                // IApplicationThread (目标进程)
            true /* shouldDispatchImmediately */,
            launchActivityItem,              // 回调项：执行 Launch
            lifecycleItem);                  // 生命周期项：最终状态 (Resume/Pause/Stop)
}

事务结构：

scss 复制代码

ClientTransaction
  ├── LaunchActivityItem  (ClientTransactionItem - 回调项)
  │     → 在 App 进程创建 Activity 并调用 onCreate
  └── ResumeActivityItem  (ActivityLifecycleItem - 生命周期项)
        → 在 App 进程执行 Resume 流程

2.10 跨进程: ClientTransaction 传递回 App 进程

文件 : ClientLifecycleManager.java

java 复制代码

// ClientLifecycleManager.java
void scheduleTransaction(@NonNull ClientTransaction transaction) throws RemoteException {
    final IApplicationThread client = transaction.getClient();
    transaction.schedule();  // ← 调用 IApplicationThread.scheduleTransaction()
}

void scheduleTransactionItem(@NonNull IApplicationThread client,
        @NonNull ClientTransactionItem item) throws RemoteException {
    final ClientTransaction clientTransaction = getOrCreatePendingTransaction(client);
    clientTransaction.addTransactionItem(item);
    onClientTransactionItemScheduled(clientTransaction, false);
}

ClientTransaction.schedule (ClientTransaction.java):

java 复制代码

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

跨进程方向：SystemServer → App进程 ，通过 IApplicationThread.scheduleTransaction(ClientTransaction) 传递。

2.11 App进程: TransactionExecutor 执行事务

文件 : TransactionExecutor.java

App 进程收到 scheduleTransaction 后：

java 复制代码

// ActivityThread.java
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    ActivityThread.this.scheduleTransaction(transaction);  // 调用父类 ClientTransactionHandler
}

ClientTransactionHandler.scheduleTransaction() 最终调用到 TransactionExecutor.execute()：

java 复制代码

// TransactionExecutor.java
public void execute(@NonNull ClientTransaction transaction) {
    try {
        executeTransactionItems(transaction);
    } catch (Exception e) {
        throw e;
    } finally {
        mPendingActions.clear();
    }
}

// TransactionExecutor.java
public void executeTransactionItems(@NonNull ClientTransaction transaction) {
    final List<ClientTransactionItem> items = transaction.getTransactionItems();
    final int size = items.size();
    for (int i = 0; i < size; i++) {
        final ClientTransactionItem item = items.get(i);
        if (item.isActivityLifecycleItem()) {
            executeLifecycleItem(transaction, (ActivityLifecycleItem) item);
        } else {
            executeNonLifecycleItem(transaction, item,
                    shouldExcludeLastLifecycleState(items, i));
        }
    }
}

执行顺序：

先执行非生命周期项（如 LaunchActivityItem）--- executeNonLifecycleItem
再执行生命周期项（如 ResumeActivityItem）--- executeLifecycleItem

对于 executeNonLifecycleItem（TransactionExecutor.java），它会：

调用 item.preExecute()
调用 item.execute() → item.postExecute()
如果该事务项指定了后续生命周期状态 （postExecutionState != UNDEFINED），还会调用 cycleToPath() 补齐中间状态

对于 executeLifecycleItem（TransactionExecutor.java），它会：

调用 cycleToPath(targetState, excludeLastState=true) 补齐中间生命周期状态（不包含目标状态本身）
调用 lifecycleItem.execute() → lifecycleItem.postExecute() 完成最终状态转换

2.12 App进程: LaunchActivityItem → ActivityThread.handleLaunchActivity

文件 : LaunchActivityItem.java

java 复制代码

@Override
public void execute(@NonNull ClientTransactionHandler client,
        @NonNull PendingTransactionActions pendingActions) {
    Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
    final ActivityClientRecord r = new ActivityClientRecord(mActivityToken, mIntent, mIdent,
            mInfo, mOverrideConfig, mReferrer, mVoiceInteractor, mState, mPersistentState,
            mPendingResults, mPendingNewIntents, mSceneTransitionInfo, mIsForward,
            mProfilerInfo, client, mAssistToken, mShareableActivityToken, mLaunchedFromBubble,
            mTaskFragmentToken, mInitialCallerInfoAccessToken, mActivityWindowInfo);
    client.handleLaunchActivity(r, pendingActions, mDeviceId, null /* customIntent */);
    Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}

ActivityThread.handleLaunchActivity (ActivityThread.java):

java 复制代码

public Activity handleLaunchActivity(ActivityClientRecord r,
        PendingTransactionActions pendingActions, int deviceId, Intent customIntent) {
    // ... 初始化 ...

    final Activity a = performLaunchActivity(r, customIntent);  // ← 核心

    if (a != null) {
        r.createdConfig = new Configuration(mConfigurationController.getConfiguration());
        reportSizeConfigurations(r);
        if (!r.activity.mFinished && pendingActions != null) {
            pendingActions.setOldState(r.state);
            pendingActions.setRestoreInstanceState(true);
            pendingActions.setCallOnPostCreate(true);
        }
        handleActivityWindowInfoChanged(r);
    } else {
        ActivityClient.getInstance().finishActivity(r.token, Activity.RESULT_CANCELED,
                null, Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
    }
    return a;
}

2.13 App进程: ActivityThread.performLaunchActivity 创建 Activity

文件 : ActivityThread.java

这是 App 进程中创建 Activity 实例 的核心方法：

java 复制代码

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    ActivityInfo aInfo = r.activityInfo;
    // 1. 获取或创建 Application
    if (r.packageInfo == null) {
        r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
                Context.CONTEXT_INCLUDE_CODE);
    }

    ComponentName component = r.intent.getComponent();
    // ... 创建 ComponentName ...

    // 2. 创建 Activity 实例
    ContextImpl activityBaseContext = createBaseContextForActivity(r);
    Activity activity = mInstrumentation.newActivity(
            r.packageInfo.getClassLoader(), component.getClassName(), r.intent);
    // ...

    try {
        Application app = r.packageInfo.makeApplication(false, mInstrumentation);

        // 3. 调用 activity.attach() --- 关键绑定
        activity.attach(activityBaseContext, this, getInstrumentation(), r.token,
                r.ident, app, r.intent, r.activityInfo, title, r.parent,
                r.embeddedID, r.lastNonConfigurationInstances, config,
                r.referrer, r.voiceInteractor, window, r.activityConfigCallback,
                r.assistToken, r.shareableActivityToken, r.initialCallerInfoAccessToken);

        // 4. 调用 onCreate
        if (r.isPersistable()) {
            mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
        } else {
            mInstrumentation.callActivityOnCreate(activity, r.state);
        }
    } catch (Exception e) { /* ... */ }
    return activity;
}

Instrumentation.newActivity (Instrumentation.java):

java 复制代码

public Activity newActivity(ClassLoader cl, String className, Intent intent)
        throws InstantiationException, IllegalAccessException, ClassNotFoundException {
    String pkg = intent != null && intent.getComponent() != null
            ? intent.getComponent().getPackageName() : null;
    return getFactory(pkg).instantiateActivity(cl, className, intent);
}

Instrumentation.callActivityOnCreate (Instrumentation.java):

java 复制代码

public void callActivityOnCreate(Activity activity, Bundle icicle) {
    prePerformCreate(activity);
    activity.performCreate(icicle);  // ← 调用 Activity.performCreate
    postPerformCreate(activity);
}

Activity.performCreate (Activity.java):

java 复制代码

final void performCreate(Bundle icicle, PersistableBundle persistentState) {
    dispatchActivityPreCreated(icicle);
    mCanEnterPictureInPicture = true;
    // ... 初始化多窗口、PiP 模式 ...

    if (persistentState != null) {
        onCreate(icicle, persistentState);
    } else {
        onCreate(icicle);  // ← 最终调用用户重写的 onCreate()
    }

    mVisibleFromClient = !mWindow.getWindowStyle().getBoolean(
            com.android.internal.R.styleable.Window_windowNoDisplay, false);
    mFragments.dispatchActivityCreated();
    dispatchActivityPostCreated(icicle);
}

至此，onCreate 被调用。Activity 实例已创建并绑定到窗口系统。

2.14 App进程: cycleToPath → handleStartActivity → onStart

注意：冷启动流程中，ON_START 不是由 StartActivityItem 触发的。StartActivityItem 仅用于从 STOPPED 状态恢复到 STARTED 状态的场景（如 ActivityRecord.makeActiveIfNeeded）。冷启动中 ON_START 是由 cycleToPath 在补齐中间状态时触发的。

在 executeNonLifecycleItem 中，LaunchActivityItem 的 execute() 已调用 handleLaunchActivity（触发 onCreate）。

随后 executeLifecycleItem 处理 ResumeActivityItem 时，TransactionExecutor 会通过 cycleToPath() 计算从当前状态（ON_CREATE）到目标状态（ON_RESUME）需要经过的生命周期路径：

复制代码

ON_CREATE → ON_START → ON_RESUME

由于 cycleToPath 传入 excludeLastState=true（见 TransactionExecutor.java），实际路径只包含中间状态 ON_START，最终的 ON_RESUME 由 ResumeActivityItem.execute() 完成。

cycleToPath 执行 performLifecycleSequence 补齐 ON_START：

java 复制代码

// TransactionExecutor.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_START:
                mTransactionHandler.handleStartActivity(r, mPendingActions,
                        null /* sceneTransitionInfo */);
                break;
            case ON_RESUME:
                mTransactionHandler.handleResumeActivity(r, false,
                        r.isForward, false, "LIFECYCLER_RESUME_ACTIVITY");
                break;
            // ... 其他状态 ...
        }
    }
}

ActivityThread.handleStartActivity (ActivityThread.java):

java 复制代码

public void handleStartActivity(ActivityClientRecord r,
        PendingTransactionActions pendingActions, SceneTransitionInfo sceneTransitionInfo) {
    final Activity activity = r.activity;
    if (!r.stopped) {
        throw new IllegalStateException("Can't start activity that is not stopped.");
    }
    if (r.activity.mFinished) {
        return;
    }

    unscheduleGcIdler();
    if (sceneTransitionInfo != null) {
        activity.mSceneTransitionInfo = sceneTransitionInfo;
    }

    // 调用 onStart
    activity.performStart("handleStartActivity");
    r.setState(ON_START);

    // ... 恢复实例状态 ...
    if (pendingActions.shouldRestoreInstanceState()) {
        if (r.isPersistable()) {
            if (r.state != null || r.persistentState != null) {
                mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
                        r.persistentState);
            }
        } else if (r.state != null) {
            mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
        }
    }
    // ...
}

Activity.performStart (Activity.java):

java 复制代码

final void performStart(String reason) {
    dispatchActivityPreStarted();
    mActivityTransitionState.setEnterSceneTransitionInfo(this, getSceneTransitionInfo());
    mFragments.noteStateNotSaved();
    mCalled = false;
    mFragments.execPendingActions();

    mInstrumentation.callActivityOnStart(this);  // ← 调用 onStart

    if (!mCalled) {
        throw new SuperNotCalledException(
                "Activity " + mComponent.toShortString() +
                " did not call through to super.onStart()");
    }
    mFragments.dispatchStart();
    mFragments.reportLoaderStart();
    // ...
    mActivityTransitionState.enterReady(this);
    dispatchActivityPostStarted();
}

Instrumentation.callActivityOnStart 内部直接调用 activity.onStart()。

至此，onStart 被调用。

2.15 App进程: ResumeActivityItem → handleResumeActivity → onResume

在 cycleToPath 补齐 ON_START 后，executeLifecycleItem 执行 ResumeActivityItem.execute()：

ResumeActivityItem.execute (ResumeActivityItem.java):

java 复制代码

@Override
public void execute(@NonNull ClientTransactionHandler client, @NonNull ActivityClientRecord r,
            @NonNull PendingTransactionActions pendingActions) {
    Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityResume");
    client.handleResumeActivity(r, true /* finalStateRequest */, mIsForward,
            mShouldSendCompatFakeFocus, "RESUME_ACTIVITY_ITEM");
    Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}

ActivityThread.handleResumeActivity (ActivityThread.java):

java 复制代码

@Override
public void handleResumeActivity(ActivityClientRecord r, boolean finalStateRequest,
        boolean isForward, boolean shouldSendCompatFakeFocus, String reason) {
    unscheduleGcIdler();
    mSomeActivitiesChanged = true;

    // 1. 执行 resume
    if (!performResumeActivity(r, finalStateRequest, reason)) {
        return;
    }

    if (mActivitiesToBeDestroyed.containsKey(r.token)) {
        return;
    }

    // 2. 窗口管理 --- 添加 DecorView 到 WindowManager
    final Activity a = r.activity;
    boolean willBeVisible = !a.mStartedActivity;
    if (!willBeVisible) {
        willBeVisible = ActivityClient.getInstance().willActivityBeVisible(
                a.getActivityToken());
    }

    if (r.window == null && !a.mFinished && willBeVisible) {
        r.window = r.activity.getWindow();
        View decor = r.window.getDecorView();
        decor.setVisibility(View.INVISIBLE);
        ViewManager wm = a.getWindowManager();
        WindowManager.LayoutParams l = r.window.getAttributes();
        // ... 设置窗口参数 ...
        wm.addView(decor, l);  // ← 将 DecorView 添加到 WindowManager
    }

    // 3. 使窗口可见
    if (!r.mWillBeVisible) {
        r.activity.makeVisible();
    }
    r.mWillBeVisible = false;
}

performResumeActivity (ActivityThread.java):

java 复制代码

public boolean performResumeActivity(ActivityClientRecord r, boolean finalStateRequest,
        String reason) {
    if (r.activity.mFinished) {
        return false;
    }
    if (r.getLifecycleState() == ON_RESUME) {
        return false;
    }

    try {
        r.activity.onStateNotSaved();
        r.activity.mFragments.noteStateNotSaved();
        checkAndBlockForNetworkAccess();

        // 分发 pending intents 和 results
        if (r.pendingIntents != null) {
            deliverNewIntents(r, r.pendingIntents);
            r.pendingIntents = null;
        }
        if (r.pendingResults != null) {
            deliverResults(r, r.pendingResults, reason);
            r.pendingResults = null;
        }

        // 调用 Activity.onResume()
        r.activity.performResume(r.startsNotResumed, reason);

        r.setState(ON_RESUME);
        reportTopResumedActivityChanged(r, r.isTopResumedActivity, "topWhenResuming");
    } catch (Exception e) { /* ... */ }
    return true;
}

Activity.performResume (Activity.java):

java 复制代码

final void performResume(boolean followedByPause, String reason) {
    dispatchActivityPreResumed();
    mCanEnterPictureInPicture = true;
    mFragments.execPendingActions();
    mLastNonConfigurationInstances = null;
    getAutofillClientController().onActivityPerformResume(followedByPause);

    mCalled = false;
    mInstrumentation.callActivityOnResume(this);  // ← 调用 onResume

    if (!mCalled) {
        throw new SuperNotCalledException(
                "Activity " + mComponent.toShortString() +
                " did not call through to super.onResume()");
    }

    mFragments.dispatchResume();
    mFragments.execPendingActions();
    onPostResume();  // ← 调用 onPostResume
    dispatchActivityPostResumed();
}

Instrumentation.callActivityOnResume (Instrumentation.java):

java 复制代码

public void callActivityOnResume(Activity activity) {
    activity.mResumed = true;
    activity.onResume();  // ← 直接调用 Activity.onResume()

    if (mActivityMonitors != null) {
        synchronized (mSync) {
            final int N = mActivityMonitors.size();
            for (int i = 0; i < N; i++) {
                final ActivityMonitor am = mActivityMonitors.get(i);
                am.match(activity, activity, activity.getIntent());
            }
        }
    }
}

至此，onResume 被调用。Activity 启动流程完成。

最后，ResumeActivityItem.postExecute() 通知 system_server：

java 复制代码

// ResumeActivityItem.java
@Override
public void postExecute(@NonNull ClientTransactionHandler client,
        @NonNull PendingTransactionActions pendingActions) {
    ActivityClient.getInstance().activityResumed(getActivityToken(),
            client.isHandleSplashScreenExit(getActivityToken()));
}

这是 第二次跨进程调用（App → SystemServer），告知 Activity 已完成 Resume。

2.16 启动流程总结图

scss 复制代码

┌─── App 进程 ───────────────────────────────────────────────────────────────────────────┐
│                                                                                          │
│  Activity.startActivity(intent)                                                          │
│    → startActivityForResult(intent, -1, options)                                         │
│      → Instrumentation.execStartActivity(...)                                            │
│        → ActivityTaskManager.getService().startActivity(...)  ───── Binder IPC ──────►   │
│                                                                                          │
└──────────────────────────────────────────────────────────────────────────────────────────┘

┌─── SystemServer 进程 ──────────────────────────────────────────────────────────────────┐
│                                                                                          │
│  ATMS.startActivity()                                                                    │
│    → ATMS.startActivityAsUser()                                                          │
│      → ActivityStartController.obtainStarter(intent).execute()                           │
│        → ActivityStarter.execute()                                                       │
│          → ActivityStarter.executeRequest(mRequest)                                      │
│            → ActivityStarter.startActivityUnchecked()                                     │
│              → ActivityStarter.startActivityInner()                                       │
│              → RootWindowContainer.resumeFocusedTasksTopActivities()                      │
│                → TaskFragment.resumeTopActivity()                                         │
│                  → startPausing()  // 先暂停当前 Activity                                 │
│                  → ActivityTaskSupervisor.startSpecificActivity()                         │
│                    → realStartActivityLocked()                                            │
│                      → 构建 ClientTransaction:                                            │
│                          [LaunchActivityItem, ResumeActivityItem]                         │
│                      → ClientLifecycleManager.scheduleTransactionItems()                  │
│                        → ClientTransaction.schedule()       ───── Binder IPC ──────►     │
│                                                                                          │
└──────────────────────────────────────────────────────────────────────────────────────────┘

┌─── App 进程 (目标 Activity 所在进程) ─────────────────────────────────────────────────┐
│                                                                                          │
│  ActivityThread.scheduleTransaction(transaction)                                         │
│    → TransactionExecutor.execute()                                                       │
│      → executeTransactionItems()                                                         │
│        ├─ [非生命周期项] LaunchActivityItem.execute()                                     │
│        │    → ActivityThread.handleLaunchActivity()                                       │
│        │      → performLaunchActivity()                                                  │
│        │        → Instrumentation.newActivity()         // 反射创建 Activity 实例        │
│        │        → activity.attach()                     // 绑定 Context/Window           │
│        │        → Instrumentation.callActivityOnCreate()                                 │
│        │          → Activity.performCreate()                                             │
│        │            → Activity.onCreate()               // ★ 用户回调                    │
│        │                                                                                 │
│        └─ [生命周期项] ResumeActivityItem                                                │
│             → TransactionExecutor.executeLifecycleItem()                                  │
│               → cycleToPath(ON_CREATE → ON_RESUME)                                       │
│                 → performLifecycleSequence()                                              │
│                   ├─ ON_START:                                                            │
│                   │  handleStartActivity()                                                │
│                   │    → Activity.performStart()                                          │
│                   │      → Instrumentation.callActivityOnStart()                          │
│                   │        → Activity.onStart()                // ★ 用户回调              │
│                   │                                                                       │
│                   └─ ON_RESUME: (ResumeActivityItem.execute)                             │
│                      handleResumeActivity()                                               │
│                        → performResumeActivity()                                          │
│                          → Activity.performResume()                                       │
│                            → Instrumentation.callActivityOnResume()                       │
│                              → Activity.onResume()              // ★ 用户回调             │
│                        → wm.addView(decorView, params)  // 添加窗口到 WMS                 │
│                                                                                          │
│             → ResumeActivityItem.postExecute()                                           │
│               → ActivityClient.activityResumed()   ───── Binder IPC ──────►              │
│                                                                                          │
└──────────────────────────────────────────────────────────────────────────────────────────┘

┌─── SystemServer 进程 (收到 Resume 回调) ──────────────────────────────────────────────┐
│                                                                                          │
│  ActivityClientController.activityResumed()                                              │
│    → ActivityRecord.completeResumeLocked()                                               │
│      → scheduleIdleTimeout()                                                             │
│      → resumeKeyDispatchingLocked()                                                      │
│      → 更新 Activity 状态为 RESUMED                                                       │
│                                                                                          │
└──────────────────────────────────────────────────────────────────────────────────────────┘

三、Activity 暂停流程 (Pause)

3.1 SystemServer: TaskFragment.startPausing

触发时机: 当需要启动新 Activity 或切换前台时，先暂停当前处于 RESUMED 状态的 Activity。

文件 : TaskFragment.java

java 复制代码

boolean startPausing(boolean userLeaving, boolean uiSleeping, ActivityRecord resuming,
        String reason) {
    // 检查是否已经在 pausing
    if (mPausingActivity != null) {
        Slog.wtf(TAG, "Going to pause when pause is already pending for " + mPausingActivity);
        // ...
    }

    ActivityRecord prev = mResumedActivity;

    // 将 Activity 状态设为 PAUSING
    ProtoLog.v(WM_DEBUG_STATES, "Moving to PAUSING: %s", prev);
    mPausingActivity = prev;
    mLastPausedActivity = prev;
    prev.setState(PAUSING, "startPausing");

    // 检查是否可以立即 pause（PiP 场景等）
    boolean pauseImmediately = false;
    boolean shouldAutoPip = false;
    // ... PiP 条件检查 ...

    if (prev.attachedToProcess()) {
        // 正常流程：发送 Pause 事务到 App 进程
        schedulePauseActivity(prev, userLeaving, pauseImmediately,
                false /* autoEnteringPip */, reason);
    }

    // 设置 Pause 超时（防止 App 进程无响应）
    prev.schedulePauseTimeout();

    return true;
}

3.2 SystemServer: schedulePauseActivity 构建 PauseActivityItem

文件 : TaskFragment.java

java 复制代码

void schedulePauseActivity(ActivityRecord prev, boolean userLeaving,
        boolean pauseImmediately, boolean autoEnteringPip, String reason) {
    ProtoLog.v(WM_DEBUG_STATES, "Enqueueing pending pause: %s", prev);
    try {
        prev.mPauseSchedulePendingForPip = false;
        EventLogTags.writeWmPauseActivity(prev.mUserId, System.identityHashCode(prev),
                prev.shortComponentName, "userLeaving=" + userLeaving, reason);

        // 创建 PauseActivityItem
        final PauseActivityItem item = new PauseActivityItem(prev.token, prev.finishing,
                userLeaving, pauseImmediately, autoEnteringPip);

        // 通过 ClientLifecycleManager 发送
        mAtmService.getLifecycleManager().scheduleTransactionItem(prev.app.getThread(), item);
    } catch (Exception e) {
        mPausingActivity = null;
        mLastPausedActivity = null;
    }
}

3.3 跨进程: ClientLifecycleManager 发送 Pause 事务

文件 : ClientLifecycleManager.java

java 复制代码

void scheduleTransactionItem(@NonNull IApplicationThread client,
        @NonNull ClientTransactionItem item) throws RemoteException {
    final ClientTransaction clientTransaction = getOrCreatePendingTransaction(client);
    clientTransaction.addTransactionItem(item);
    onClientTransactionItemScheduled(clientTransaction, false /* shouldDispatchImmediately */);
}

跨进程方向：SystemServer → App进程 ，通过 IApplicationThread.scheduleTransaction() 传递。

3.4 App进程: PauseActivityItem.execute → handlePauseActivity

文件 : PauseActivityItem.java

java 复制代码

@Override
public void execute(@NonNull ClientTransactionHandler client, @NonNull ActivityClientRecord r,
            @NonNull PendingTransactionActions pendingActions) {
    Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
    client.handlePauseActivity(r, mFinished, mUserLeaving, mAutoEnteringPip,
            pendingActions, "PAUSE_ACTIVITY_ITEM");
    Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}

ActivityThread.handlePauseActivity (ActivityThread.java):

java 复制代码

@Override
public void handlePauseActivity(ActivityClientRecord r, boolean finished, boolean userLeaving,
        boolean autoEnteringPip, PendingTransactionActions pendingActions, String reason) {
    // 处理 userLeaving
    if (userLeaving) {
        performUserLeavingActivity(r);
    }

    // PiP 模式处理
    if (autoEnteringPip) {
        r.activity.mIsInPictureInPictureMode = true;
    }

    // 执行 pause
    performPauseActivity(r, finished, reason, pendingActions);

    // 等待异步工作完成（兼容旧版本）
    if (r.isPreHoneycomb()) {
        QueuedWork.waitToFinish();
    }
    mSomeActivitiesChanged = true;
}

3.5 App进程: performPauseActivityIfNeeded → Activity.onPause

文件 : ActivityThread.java

java 复制代码

private Bundle performPauseActivity(ActivityClientRecord r, boolean finished, String reason,
        PendingTransactionActions pendingActions) {
    if (r.paused) {
        if (r.activity.mFinished) {
            return null;
        }
        // 已经 paused，不应该再 pause
    }

    if (finished) {
        r.activity.mFinished = true;
    }

    // 保存实例状态（兼容旧版本）
    final boolean shouldSaveState = !r.activity.mFinished && r.isPreHoneycomb();
    if (shouldSaveState) {
        callActivityOnSaveInstanceState(r);
    }

    // 执行 pause
    performPauseActivityIfNeeded(r, reason);

    // 通知 OnActivityPausedListener
    ArrayList<OnActivityPausedListener> listeners;
    synchronized (mOnPauseListeners) {
        listeners = mOnPauseListeners.remove(r.activity);
    }
    for (int i = 0; i < listeners.size(); i++) {
        listeners.get(i).onPaused(r.activity);
    }

    return shouldSaveState ? r.state : null;
}

performPauseActivityIfNeeded (ActivityThread.java):

java 复制代码

private void performPauseActivityIfNeeded(ActivityClientRecord r, String reason) {
    if (r.paused) {
        return;
    }

    // 通知 Top Resumed 位置丢失
    reportTopResumedActivityChanged(r, false /* onTop */, "pausing");

    try {
        r.activity.mCalled = false;
        // 通过 Instrumentation 调用 onPause
        mInstrumentation.callActivityOnPause(r.activity);
        if (!r.activity.mCalled) {
            throw new SuperNotCalledException("Activity " + safeToComponentShortString(r.intent)
                    + " did not call through to super.onPause()");
        }
    } catch (SuperNotCalledException e) {
        throw e;
    } catch (Exception e) {
        if (!mInstrumentation.onException(r.activity, e)) {
            throw new RuntimeException("Unable to pause activity "
                    + safeToComponentShortString(r.intent) + ": " + e.toString(), e);
        }
    }
    r.setState(ON_PAUSE);
}

Instrumentation.callActivityOnPause (Instrumentation.java):

java 复制代码

public void callActivityOnPause(Activity activity) {
    activity.performPause();  // ← 调用 Activity.performPause
}

Activity.performPause (Activity.java):

java 复制代码

final void performPause() {
    dispatchActivityPrePaused();
    mDoReportFullyDrawn = false;
    mFragments.dispatchPause();
    mCalled = false;
    onPause();  // ← 调用用户重写的 onPause()
    mResumed = false;
    if (!mCalled && getApplicationInfo().targetSdkVersion
            >= android.os.Build.VERSION_CODES.GINGERBREAD) {
        throw new SuperNotCalledException(
                "Activity " + mComponent.toShortString() +
                " did not call through to super.onPause()");
    }
    dispatchActivityPostPaused();
}

至此，onPause 被调用。

3.6 App进程: PauseActivityItem.postExecute → 通知服务端

文件 : PauseActivityItem.java

java 复制代码

@Override
public void postExecute(@NonNull ClientTransactionHandler client,
            @NonNull PendingTransactionActions pendingActions) {
    if (mDontReport) {
        return;  // pauseImmediately 为 true 时不通知
    }
    // 通知 system_server pause 完成
    ActivityClient.getInstance().activityPaused(getActivityToken());
}

跨进程方向：App进程 → SystemServer，告知 Activity 已完成 Pause。

3.7 SystemServer: completePause 完成暂停

文件 : TaskFragment.java

java 复制代码

@VisibleForTesting
void completePause(boolean resumeNext, ActivityRecord resuming) {
    ActivityRecord prev = mPausingActivity;
    ProtoLog.v(WM_DEBUG_STATES, "Complete pause: %s", prev);

    if (prev != null) {
        prev.setWillCloseOrEnterPip(false);
        final boolean wasStopping = prev.isState(STOPPING);

        // 设置 Activity 状态为 PAUSED
        prev.setState(PAUSED, "completePausedLocked");

        // 清除 pausing 引用
        mPausingActivity = null;

        // 处理 finishing 状态
        if (prev.finishing) {
            prev = prev.completeFinishing(false /* updateVisibility */,
                    "completePausedLocked");
        } else if (prev.attachedToProcess()) {
            // 如果不可见，添加到 stopping 列表
            if (!prev.isVisibleRequested() || shouldSleepOrShutDownActivities()) {
                prev.clearDeferHidingClient();
                prev.addToStopping(true /* scheduleIdle */, false /* idleDelayed */,
                        "completePauseLocked");
            }
        }
    }

    // 如果需要，恢复下一个 Activity
    if (resumeNext) {
        final Task topRootTask = mRootWindowContainer.getTopDisplayFocusedRootTask();
        if (topRootTask != null && !topRootTask.shouldSleepOrShutDownActivities()) {
            mRootWindowContainer.resumeFocusedTasksTopActivities(topRootTask, prev);
        }
    }

    mRootWindowContainer.ensureActivitiesVisible(resuming);
}

3.8 暂停流程总结图

scss 复制代码

┌─── SystemServer 进程 ──────────────────────────────────────────────────────────────────┐
│                                                                                          │
│  TaskFragment.resumeTopActivity()                                                        │
│    → startPausing(userLeaving, uiSleeping, resuming, reason)                             │
│      → prev.setState(PAUSING)                                                            │
│      → schedulePauseActivity(prev, ...)                                                  │
│        → new PauseActivityItem(prev.token, ...)                                          │
│        → ClientLifecycleManager.scheduleTransactionItem(appThread, item)                  │
│          → ClientTransaction.schedule()            ───── Binder IPC ──────►              │
│      → prev.schedulePauseTimeout()  // 设置超时保护                                       │
│                                                                                          │
└──────────────────────────────────────────────────────────────────────────────────────────┘

┌─── App 进程 ───────────────────────────────────────────────────────────────────────────┐
│                                                                                          │
│  ActivityThread.scheduleTransaction(transaction)                                         │
│    → TransactionExecutor.execute()                                                       │
│      → PauseActivityItem.execute()                                                       │
│        → ActivityThread.handlePauseActivity(r, finished, userLeaving, ...)               │
│          → performPauseActivity(r, finished, reason, ...)                                │
│            → performPauseActivityIfNeeded(r, reason)                                     │
│              → reportTopResumedActivityChanged(r, false, "pausing")                       │
│              → Instrumentation.callActivityOnPause(r.activity)                            │
│                → Activity.performPause()                                                  │
│                  → Activity.onPause()                           // ★ 用户回调              │
│              → r.setState(ON_PAUSE)                                                       │
│                                                                                          │
│      → PauseActivityItem.postExecute()                                                   │
│        → ActivityClient.activityPaused(token)          ───── Binder IPC ──────►           │
│                                                                                          │
└──────────────────────────────────────────────────────────────────────────────────────────┘

┌─── SystemServer 进程 (收到 Pause 完成回调) ────────────────────────────────────────────┐
│                                                                                          │
│  ActivityClientController.activityPaused()                                               │
│    → TaskFragment.completePause(resumeNext, resuming)                                     │
│      → prev.setState(PAUSED)                                                             │
│      → mPausingActivity = null                                                           │
│      → 如果 resumeNext: resumeFocusedTasksTopActivities()  // 触发下一个 Activity Resume  │
│      → ensureActivitiesVisible()                                                         │
│                                                                                          │
└──────────────────────────────────────────────────────────────────────────────────────────┘

四、Activity 恢复流程 (Resume)

4.1 SystemServer: resumeFocusedTasksTopActivities

触发时机:

Pause 完成后 (completePause 中 resumeNext=true)
Activity 启动后 (startActivityInner 中)
Task 切换到前台时

文件 : RootWindowContainer.java

java 复制代码

boolean resumeFocusedTasksTopActivities(
        Task targetRootTask, ActivityRecord target, ActivityOptions targetOptions,
        boolean deferPause) {
    if (!mTaskSupervisor.readyToResume()) {
        return false;
    }

    boolean result = false;
    if (targetRootTask != null && (targetRootTask.isTopRootTaskInDisplayArea()
            || getTopDisplayFocusedRootTask() == targetRootTask)) {
        result = targetRootTask.resumeTopActivityUncheckedLocked(target, targetOptions,
                deferPause);
    }

    for (int displayNdx = getChildCount() - 1; displayNdx >= 0; --displayNdx) {
        final DisplayContent display = getChildAt(displayNdx);
        final ActivityRecord topOfDisplay = display.topRunningActivity();
        display.forAllRootTasks(rootTask -> {
            final ActivityRecord topRunningActivity = rootTask.topRunningActivity();
            if (!rootTask.isFocusableAndVisible() || topRunningActivity == null) {
                return;
            }
            if (rootTask == targetRootTask) {
                return;  // 已经处理过
            }
            if (topRunningActivity.isState(RESUMED) && topRunningActivity == topOfDisplay) {
                rootTask.executeAppTransition(targetOptions);
            } else {
                resumedOnDisplay[0] |= topRunningActivity.makeActiveIfNeeded(target);
            }
        });
        // 如果没有 resume 任何 Activity，启动 Launcher
        if (!resumedOnDisplay[0]) {
            final Task focusedRoot = display.getFocusedRootTask();
            if (focusedRoot != null) {
                result |= focusedRoot.resumeTopActivityUncheckedLocked(
                        target, targetOptions, false);
            } else if (targetRootTask == null) {
                result |= resumeHomeActivity(null, "no-focusable-task",
                        display.getDefaultTaskDisplayArea());
            }
        }
    }
    return result;
}

4.2 SystemServer: TaskFragment.resumeTopActivity

文件 : TaskFragment.java

java 复制代码

final boolean resumeTopActivity(ActivityRecord prev, ActivityOptions options,
        boolean skipPause) {
    ActivityRecord next = topRunningActivity(true /* focusableOnly */);

    if (next == null || !next.canResumeByCompat()) {
        return false;
    }

    // 如果 next 已经 RESUMED，直接返回
    if (mResumedActivity == next && next.isState(RESUMED)
            && taskDisplayArea.allResumedActivitiesComplete()) {
        executeAppTransition(options);
        return true;
    }

    // 1. 暂停当前 Resume 状态的 Activity
    boolean pausing = !skipPause && taskDisplayArea.pauseBackTasks(next);
    if (mResumedActivity != null) {
        pausing |= startPausing(mTaskSupervisor.mUserLeaving, false, next, "resumeTopActivity");
    }
    if (pausing) {
        return true;  // 等 pause 完成后再 resume
    }

    // ... 状态检查 ...

    // 2. 如果 Activity 已附加进程 → 直接 Resume
    if (next.attachedToProcess()) {
        try {
            // 构建 ResumeActivityItem 并发送（实际代码在 TaskFragment.java）
            final ResumeActivityItem resumeActivityItem = new ResumeActivityItem(
                    next.token, topProcessState, dc.isNextTransitionForward(),
                    next.shouldSendCompatFakeFocus());
            mAtmService.getLifecycleManager().scheduleTransactionItem(
                    appThread, resumeActivityItem);
        } catch (Exception e) {
            // 失败处理
        }
        next.completeResumeLocked();
    } else {
        // 3. 如果 Activity 没有进程 → 启动进程并发送 Launch 事务
        mTaskSupervisor.startSpecificActivity(next, true, true);
    }
}

4.3 跨进程: ResumeActivityItem 发送到 App 进程

与 Pause 流程类似，通过 ClientLifecycleManager.scheduleTransactionItem() 发送单项事务，通过 IApplicationThread.scheduleTransaction() 跨进程传递。

跨进程方向：SystemServer → App进程

4.4 App进程: ResumeActivityItem.execute → handleResumeActivity

文件 : ResumeActivityItem.java

java 复制代码

// preExecute --- 更新进程状态
@Override
public void preExecute(@NonNull ClientTransactionHandler client) {
    if (mProcState != ActivityManager.PROCESS_STATE_UNKNOWN) {
        client.updateProcessState(mProcState, false);
    }
}

// execute --- 执行 Resume
@Override
public void execute(@NonNull ClientTransactionHandler client, @NonNull ActivityClientRecord r,
            @NonNull PendingTransactionActions pendingActions) {
    Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityResume");
    client.handleResumeActivity(r, true /* finalStateRequest */, mIsForward,
            mShouldSendCompatFakeFocus, "RESUME_ACTIVITY_ITEM");
    Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}

4.5 App进程: performResumeActivity → Activity.performResume → onResume

文件 : ActivityThread.java

java 复制代码

public boolean performResumeActivity(ActivityClientRecord r, boolean finalStateRequest,
        String reason) {
    if (r.activity.mFinished) {
        return false;
    }
    if (r.getLifecycleState() == ON_RESUME) {
        return false;  // 已经 RESUMED
    }

    try {
        r.activity.onStateNotSaved();
        r.activity.mFragments.noteStateNotSaved();

        // 分发 pending intents
        if (r.pendingIntents != null) {
            deliverNewIntents(r, r.pendingIntents);
            r.pendingIntents = null;
        }
        // 分发 pending results
        if (r.pendingResults != null) {
            deliverResults(r, r.pendingResults, reason);
            r.pendingResults = null;
        }

        // 调用 Activity.performResume → onResume
        r.activity.performResume(r.startsNotResumed, reason);

        r.setState(ON_RESUME);
        reportTopResumedActivityChanged(r, r.isTopResumedActivity, "topWhenResuming");
    } catch (Exception e) { /* ... */ }
    return true;
}

Activity.performResume (Activity.java):

java 复制代码

final void performResume(boolean followedByPause, String reason) {
    dispatchActivityPreResumed();
    mCanEnterPictureInPicture = true;
    mFragments.execPendingActions();
    mLastNonConfigurationInstances = null;

    mCalled = false;
    mInstrumentation.callActivityOnResume(this);  // ← 调用 onResume

    if (!mCalled) {
        throw new SuperNotCalledException(
                "Activity " + mComponent.toShortString() +
                " did not call through to super.onResume()");
    }

    mFragments.dispatchResume();
    mFragments.execPendingActions();
    onPostResume();
    dispatchActivityPostResumed();
}

Instrumentation.callActivityOnResume (Instrumentation.java):

java 复制代码

public void callActivityOnResume(Activity activity) {
    activity.mResumed = true;
    activity.onResume();  // ← 直接调用 Activity.onResume()

    // 通知 ActivityMonitor
    if (mActivityMonitors != null) {
        synchronized (mSync) {
            final int N = mActivityMonitors.size();
            for (int i = 0; i < N; i++) {
                final ActivityMonitor am = mActivityMonitors.get(i);
                am.match(activity, activity, activity.getIntent());
            }
        }
    }
}

至此，onResume 被调用。

4.6 App进程: handleResumeActivity 中的窗口管理

文件 : ActivityThread.java

在 performResumeActivity 之后，handleResumeActivity 还会处理窗口可见性：

java 复制代码

public void handleResumeActivity(ActivityClientRecord r, boolean finalStateRequest,
        boolean isForward, boolean shouldSendCompatFakeFocus, String reason) {
    // 1. 执行 resume
    if (!performResumeActivity(r, finalStateRequest, reason)) {
        return;
    }

    final Activity a = r.activity;

    // 2. 将 DecorView 添加到 WindowManager（如果还没添加）
    boolean willBeVisible = !a.mStartedActivity;
    if (!willBeVisible) {
        willBeVisible = ActivityClient.getInstance().willActivityBeVisible(
                a.getActivityToken());
    }

    if (r.window == null && !a.mFinished && willBeVisible) {
        r.window = r.activity.getWindow();
        View decor = r.window.getDecorView();
        decor.setVisibility(View.INVISIBLE);
        ViewManager wm = a.getWindowManager();
        WindowManager.LayoutParams l = r.window.getAttributes();
        // ... 设置参数 ...
        wm.addView(decor, l);  // ← 将 DecorView 添加到 WMS
    }

    // 3. 使窗口可见
    if (!r.mWillBeVisible) {
        r.activity.makeVisible();
    }
    r.mWillBeVisible = false;
}

4.7 App进程: ResumeActivityItem.postExecute → 通知服务端

文件 : ResumeActivityItem.java

java 复制代码

@Override
public void postExecute(@NonNull ClientTransactionHandler client,
            @NonNull PendingTransactionActions pendingActions) {
    ActivityClient.getInstance().activityResumed(getActivityToken(),
            client.isHandleSplashScreenExit(getActivityToken()));
}

跨进程方向：App进程 → SystemServer

4.8 SystemServer: completeResumeLocked

文件 : ActivityRecord.java

java 复制代码

void completeResumeLocked() {
    idle = false;
    results = null;
    if (newIntents != null && newIntents.size() > 0) {
        mLastNewIntent = newIntents.get(newIntents.size() - 1);
    }
    newIntents = null;

    mTaskSupervisor.updateHomeProcessIfNeeded(this);
    if (nowVisible) {
        mTaskSupervisor.stopWaitingForActivityVisible(this);
    }

    // 设置 idle 超时
    mTaskSupervisor.scheduleIdleTimeout(this);

    mTaskSupervisor.mStoppingActivities.remove(this);
    if (getDisplayArea().allResumedActivitiesComplete()) {
        mRootWindowContainer.executeAppTransitionForAllDisplay();
    }

    resumeKeyDispatchingLocked();
    // ...
}

4.9 恢复流程总结图

scss 复制代码

┌─── SystemServer 进程 ──────────────────────────────────────────────────────────────────┐
│                                                                                          │
│  RootWindowContainer.resumeFocusedTasksTopActivities()                                   │
│    → Task.resumeTopActivityUncheckedLocked()                                              │
│      → TaskFragment.resumeTopActivity()                                                   │
│        ├─ 如果当前有 Resumed Activity:                                                     │
│        │    startPausing() → 等 Pause 完成                                                │
│        │    → completePause(resumeNext=true)                                               │
│        │      → resumeFocusedTasksTopActivities() → 回到这里                               │
│        │                                                                                   │
│        └─ 如果需要 Resume next:                                                            │
│             ├─ next 已附加进程:                                                             │
│             │   new ResumeActivityItem(token, processState, isForward, ...)                 │
│             │   ClientLifecycleManager.scheduleTransactionItem(appThread, item)             │
│             │     → ClientTransaction.schedule()          ───── Binder IPC ──────►         │
│             │   next.completeResumeLocked()                                                │
│             │                                                                              │
│             └─ next 未附加进程:                                                             │
│                 startSpecificActivity() → realStartActivityLocked()                        │
│                 (参见启动流程)                                                               │
│                                                                                           │
└───────────────────────────────────────────────────────────────────────────────────────────┘

┌─── App 进程 ────────────────────────────────────────────────────────────────────────────┐
│                                                                                           │
│  ActivityThread.scheduleTransaction(transaction)                                          │
│    → TransactionExecutor.execute()                                                        │
│      → ResumeActivityItem.preExecute()                                                    │
│        → client.updateProcessState(mProcState)                                             │
│                                                                                           │
│      → TransactionExecutor.executeLifecycleItem()                                          │
│        → cycleToPath(currentState → ON_RESUME)                                             │
│          → performLifecycleSequence() // 补齐中间状态（如 ON_START）                        │
│                                                                                           │
│      → ResumeActivityItem.execute()                                                       │
│        → ActivityThread.handleResumeActivity()                                             │
│          → performResumeActivity()                                                         │
│            → Activity.performResume()                                                      │
│              → Instrumentation.callActivityOnResume(this)                                  │
│                → Activity.onResume()                        // ★ 用户回调                   │
│              → Fragment.dispatchResume()                                                   │
│              → Activity.onPostResume()                                                     │
│            → r.setState(ON_RESUME)                                                         │
│          → wm.addView(decorView, params)    // 添加 DecorView 到 WMS                      │
│          → activity.makeVisible()           // 使窗口可见                                  │
│                                                                                           │
│      → ResumeActivityItem.postExecute()                                                   │
│        → ActivityClient.activityResumed(token)            ───── Binder IPC ──────►         │
│                                                                                           │
└───────────────────────────────────────────────────────────────────────────────────────────┘

┌─── SystemServer 进程 (收到 Resume 回调) ───────────────────────────────────────────────┐
│                                                                                           │
│  ActivityClientController.activityResumed()                                               │
│    → ActivityRecord.completeResumeLocked()                                                 │
│      → scheduleIdleTimeout()                                                              │
│      → resumeKeyDispatchingLocked()                                                       │
│      → executeAppTransitionForAllDisplay()                                                │
│      → Activity 状态确认为 RESUMED                                                         │
│                                                                                           │
└───────────────────────────────────────────────────────────────────────────────────────────┘

五、生命周期状态机与事务机制

5.1 ClientTransaction 事务框架

Android 9 (Pie) 引入了 ClientTransaction 事务机制 ，替代了旧的直接调用 IApplicationThread 方法的方式。

核心设计：

swift 复制代码

ClientTransaction (事务载体，Parcelable)
  ├── mClient: IApplicationThread        // 目标进程的 Binder 句柄
  ├── mTransactionItems: List<ClientTransactionItem>  // 事务项列表
  │     ├── ClientTransactionItem (非生命周期项)
  │     │     ├── LaunchActivityItem      // 启动 Activity
  │     │     ├── NewIntentItem           // 分发新 Intent
  │     │     ├── ActivityResultItem      // 分发 Activity Result
  │     │     └── ...
  │     └── ActivityLifecycleItem (生命周期项)
  │           ├── StartActivityItem       // → ON_START
  │           ├── ResumeActivityItem      // → ON_RESUME
  │           ├── PauseActivityItem       // → ON_PAUSE
  │           ├── StopActivityItem        // → ON_STOP
  │           └── DestroyActivityItem     // → ON_DESTROY
  └── mLifecycleStateRequest: ActivityLifecycleItem  // 最终目标状态

事务项执行顺序：

所有项的 preExecute() 按添加顺序执行
非生命周期项的 execute() → postExecute()
生命周期项通过 cycleToPath() 补齐中间状态，再执行 execute() → postExecute()

5.2 TransactionExecutor 生命周期状态机

文件 : TransactionExecutor.java

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,
                        Context.DEVICE_ID_INVALID, null);
                break;
            case ON_START:
                mTransactionHandler.handleStartActivity(r, mPendingActions,
                        null);
                break;
            case ON_RESUME:
                mTransactionHandler.handleResumeActivity(r, false,
                        r.isForward, false, "LIFECYCLER_RESUME_ACTIVITY");
                break;
            case ON_PAUSE:
                mTransactionHandler.handlePauseActivity(r, false, false,
                        false, mPendingActions, "LIFECYCLER_PAUSE_ACTIVITY");
                break;
            case ON_STOP:
                mTransactionHandler.handleStopActivity(r, mPendingActions,
                        false, "LIFECYCLER_STOP_ACTIVITY");
                break;
            case ON_DESTROY:
                mTransactionHandler.handleDestroyActivity(r, false, false,
                        "performLifecycleSequence");
                break;
            case ON_RESTART:
                mTransactionHandler.performRestartActivity(r, false);
                break;
        }
    }
}

5.3 cycleToPath 状态路径计算

文件 : TransactionExecutor.java

java 复制代码

private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState,
        ClientTransaction transaction) {
    final int start = r.getLifecycleState();
    final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
    performLifecycleSequence(r, path, transaction);
}

状态常量：

常量	值	含义
ON_CREATE	1	Activity.onCreate()
ON_START	2	Activity.onStart()
ON_RESUME	3	Activity.onResume()
ON_PAUSE	4	Activity.onPause()
ON_STOP	5	Activity.onStop()
ON_DESTROY	6	Activity.onDestroy()
ON_RESTART	7	Activity.onRestart()

状态路径示例：

起始状态	目标状态	路径
ON_CREATE	ON_RESUME	ON_START → ON_RESUME
ON_STOP	ON_RESUME	ON_RESTART → ON_START → ON_RESUME
ON_RESUME	ON_PAUSE	ON_PAUSE
ON_RESUME	ON_STOP	ON_PAUSE → ON_STOP

六、全流程串联

以下是 从 Activity A 启动 Activity B 的完整生命周期流转：

css 复制代码

                        Activity A (当前前台)                 Activity B (目标)
                        状态: RESUMED                         状态: 不存在
                              │
    ┌─────────────────────────┼──────────────────────────────┐
    │  App进程 A              │                               │
    │  Activity.startActivity(intent)                        │
    │    → Instrumentation.execStartActivity()               │
    │      → IActivityTaskManager.startActivity()            │
    │            │                                           │
    └────────────┼───────────────────────────────────────────┘
                 │ Binder IPC (App → SystemServer)
                 ▼
    ┌──────────────────────────────────────────────────────────┐
    │  SystemServer进程                                         │
    │  ATMS.startActivityAsUser()                              │
    │    → ActivityStarter.execute()                           │
    │      → executeRequest()                                  │
    │        → startActivityUnchecked()                        │
    │          → startActivityInner()                          │
    │        → resumeFocusedTasksTopActivities()               │
    │          → TaskFragment.resumeTopActivity()              │
    │            │                                             │
    │            ├── 1. 暂停 Activity A:                        │
    │            │   startPausing()                            │
    │            │   → PauseActivityItem → 发送到 App进程 A      │
    │            │                                             │
    │            └── 2. 启动 Activity B:                        │
    │                startSpecificActivity()                   │
    │                → realStartActivityLocked()               │
    │                  → [LaunchActivityItem, ResumeActivityItem]│
    │                  → 发送到 App进程 B                        │
    │                                                          │
    └──────────────────────────────────────────────────────────┘
                 │                           │
                 │ Binder IPC                │ Binder IPC
                 │ (Server → App A)          │ (Server → App B)
                 ▼                           ▼
    ┌────────────────────────┐   ┌──────────────────────────────────┐
    │  App进程 A              │   │  App进程 B                       │
    │  PauseActivityItem     │   │  TransactionExecutor.execute()   │
    │    → handlePauseActivity│   │    ├─ LaunchActivityItem:       │
    │    → performPause()    │   │    │  handleLaunchActivity()     │
    │    → A.onPause()  ★    │   │    │  performLaunchActivity()    │
    │                        │   │    │  B.onCreate()  ★            │
    │  PauseActivityItem     │   │    │                             │
    │  .postExecute()        │   │    ├─ cycleToPath:               │
    │  → activityPaused()    │   │    │  ON_START:                  │
    │                        │   │    │  handleStartActivity()      │
    └────────────────────────┘   │    │  B.onStart()  ★             │
                                 │    │                             │
                                 │    ├─ ResumeActivityItem:        │
                                 │    │  handleResumeActivity()     │
                                 │    │  performResumeActivity()    │
                                 │    │  B.onResume()  ★            │
                                 │    │  wm.addView(decorView)      │
                                 │    │                             │
                                 │    └─ postExecute:               │
                                 │       activityResumed()          │
                                 └──────────────────────────────────┘
                                      │                    │
                                      │ Binder IPC         │ Binder IPC
                                      │ (App A → Server)   │ (App B → Server)
                                      ▼                    ▼
                              ┌──────────────────────────────────────┐
                              │  SystemServer进程                     │
                              │  activityPaused(A)                   │
                              │    → completePause()                 │
                              │    → A 状态: PAUSED                   │
                              │                                      │
                              │  activityResumed(B)                  │
                              │    → completeResumeLocked()          │
                              │    → B 状态: RESUMED                  │
                              └──────────────────────────────────────┘

最终状态:

Activity A: RESUMED → PAUSING → PAUSED (可能继续到 STOPPING → STOPPED)
Activity B: 不存在 → onCreate → onStart → onResume → RESUMED

AOSP15 WMS/AMS系统开发 - Activity 生命周期源码详细分析

目录

一、整体架构概览

二、Activity 启动流程 (Start)

2.1 App进程: Activity.startActivity

2.2 App进程: Instrumentation.execStartActivity

2.3 跨进程: Binder IPC 到 system_server

2.4 SystemServer: ATMS.startActivityAsUser

2.5 SystemServer: ActivityStarter.execute

2.6 SystemServer: ActivityStarter.startActivityUnchecked

2.7 SystemServer: ActivityStarter.startActivityInner

2.8 SystemServer: TaskFragment.resumeTopActivity 触发 Launch

2.9 SystemServer: ActivityTaskSupervisor.realStartActivityLocked 构建事务

2.10 跨进程: ClientTransaction 传递回 App 进程

2.11 App进程: TransactionExecutor 执行事务

2.12 App进程: LaunchActivityItem → ActivityThread.handleLaunchActivity

2.13 App进程: ActivityThread.performLaunchActivity 创建 Activity

2.14 App进程: cycleToPath → handleStartActivity → onStart

2.15 App进程: ResumeActivityItem → handleResumeActivity → onResume

2.16 启动流程总结图

三、Activity 暂停流程 (Pause)

3.1 SystemServer: TaskFragment.startPausing

3.2 SystemServer: schedulePauseActivity 构建 PauseActivityItem

3.3 跨进程: ClientLifecycleManager 发送 Pause 事务

3.4 App进程: PauseActivityItem.execute → handlePauseActivity

3.5 App进程: performPauseActivityIfNeeded → Activity.onPause

3.6 App进程: PauseActivityItem.postExecute → 通知服务端

3.7 SystemServer: completePause 完成暂停

3.8 暂停流程总结图

四、Activity 恢复流程 (Resume)

4.1 SystemServer: resumeFocusedTasksTopActivities

4.2 SystemServer: TaskFragment.resumeTopActivity

4.3 跨进程: ResumeActivityItem 发送到 App 进程

4.4 App进程: ResumeActivityItem.execute → handleResumeActivity

4.5 App进程: performResumeActivity → Activity.performResume → onResume

4.6 App进程: handleResumeActivity 中的窗口管理

4.7 App进程: ResumeActivityItem.postExecute → 通知服务端

4.8 SystemServer: completeResumeLocked

4.9 恢复流程总结图

五、生命周期状态机与事务机制

5.1 ClientTransaction 事务框架

5.2 TransactionExecutor 生命周期状态机

5.3 cycleToPath 状态路径计算

六、全流程串联