当我们点击一个应用图标，应用的LancherActivity（mainActivity）开始启动，启动的请求以一种IPC方式传入AMS，AMS开始处理启动请求。伴随着Intent和Flag的解析和Activity栈的进出，Activity的生命周期从onCreate()开始变化。

系统内部是如何启动一个Activity？新Activity对象是何时创建？Activity的onCreate是在何时被系统回调？

一、基础认识

1.1 核心角色

先认识一下Activity启动过程涉及到的一些核心角色。

Instrumentation ：负责调用Activity和Application生命周期。每一个应用的进程都有一个ActivityThread对象，每一个ActivityThread对象都有一个Instrumentation mInstrumentation成员变量，可以理解为应用进程关键。ActivityThread要创建或暂停某个Activity，都需要通过Instrumentation进行具体操作。

AMS(ActivityManagerService)：组件调度管理中心，服务端对象，主要负责系统中四大组件的启动、切换、调度及应用进程的管理和调度等工作

ActivityStarter：Activity启动的控制器，处理Intent和Flag对Activity启动的影响

ActivityTaskManager：Activity，Service等与ATMS跨进程交互的接口，ATMS的辅助类

ActivityTaskManagerService：负责Activity管理和调度等工作

ActivityStackSupervisior ：负责所有Activity栈的管理

ActivityStack：负责单个Activity栈的状态和管理

ActivityThread ：App的真正入口，开启app后回调用main()开始运行。开启消息循环队列，即UI线程或主线程。处理ATMS的调度和执行Activity，Broadcast及相关

ApplicationThread：用来实现ActivityTaskManagerService与ActivityThread之间的交互 ，是一个IBinder。 在ActivityTaskManagerService需要管理相关Application中的Activity的生命周期时，通过ApplicationThread的代理对象与ActivityThread通讯。

......

1.2 启动过程预览

Activity启动流程主要涉及四个进程：

• 调用者进程：如果是桌面启动应用就是Launcher应用进程
• ActivityManagerService等所在的System Server进程：该进程主要运行着系统服务组件。
• Zygote进程：该进程主要用来fork新进程
• 新启动的APP进程：该进程就是用来承载应用运行的进程了，它也是应用的主线程（新创建的进程就是主线程），处理组件生命周期、界面绘制等相关事情。

Activity冷启动流程：

1. 点击桌面应用图标，Launch进程将启动Activity的请求以Binder的方式发送给AMS
2. AMS接收Activity启动请求后，交付ActivityStarter处理Intent和Flag等信息，然后再交给ActivityStackSupervisior/ActivityStack处理Activity进栈相关流程。之后根据进程名称和进程id等信息判断应用所在的任务栈、进程是否存在？如果不存在，创建新进程
3. AMS并不直接创建应用进程，而是以Socket方式请求Zygote进程fork新进程。Zygote接收到新进程创建请求后**fork出新进程**
4. 通过跨进程方式，立即启动ActivityThread线程，并进入它的main方法，进程从SystemServer进程到应用进程。
5. 调用了ApplicationThread的bindApplication()方法去初始化Application，接着调用ATMS的attachApplication()方法去启动Activity。
6. ActivityThread利用ClassLoader去加载Activity、创建Activity实例，并回调Activity的onCreate()方法。这样便完成了Activity的启动。

启动过程的进程跳转：Launch进程 => AMS进程 =>Zygote进程 => App进程 => AMS进程 => app 进程 => AMS 进程 => APP进程

普通Activity启动流程：

1. 目标Activity跳转，App进程将启动Activity（MainActivity）的请求以**Binder的方式**发送给AMS
2. AMS接收Activity启动请求后，交付ActivityStarter处理Intent和Flag等信息，然后再交给ActivityStackSupervisior/ActivityStack处理Activity进栈相关流程。之后根据进程名称和进程id等信息判断应用所在的任务栈、进程是否存在？如果存在，则进行Activity启动
3. ActivityThread利用ClassLoader去加载Activity、创建Activity实例，并回调Activity的onCreate()方法。这样便完成了Activity的启动。

启动过程的进程跳转：**APP进程 => AMS进程 => App进程 **

关于Activity启动的流程图如下图所示：

上述图片引用自源码解析，基于Android 10的Activity启动解析绘制，与本文分析的Android 12内容存在一些细微的差别。

二、原理解析

相关源码解析基于Android 12

2.1 Activity启动

一般通过startActivity启动目标Activity，跟踪该方法实现，最终由startActivityForResult()实现

public void startActivityForResult(@RequiresPermission Intent intent, int requestCode, @Nullable Bundle options) {
    //......
    //1. Activity启动的核心代码
    Instrumentation.ActivityResult ar =
        mInstrumentation.execStartActivity(
        this, mMainThread.getApplicationThread(), mToken, this,
        intent, requestCode, options);
    if (ar != null) {
        mMainThread.sendActivityResult(
            mToken, mEmbeddedID, requestCode, ar.getResultCode(),
            ar.getResultData());
    }
    if (requestCode >= 0) {
        mStartedActivity = true;
    }
    //......
}

startActivityForResult()方法中启动Activity的核心是由Instrumentation的execStartActivity实现。

execStartActivity()方法其中有一个参数mMainThread.getApplicationThread()，其类型是ApplicationThread，是ActivityThread的一个内部类，继承IApplicationThread.Stub，是个Binder，在Activity工作流程中有重要作用。

先看一下execStartActivity()的输入参数

参数	含义
Context who	启动其他Activity的当前Activity
IBinder contextThread	ActivityThread中的mApplicationThread
IBinder token	ActivityManagerService中ActivityRecord中传入的域IApplicationToken.Stub appToken
Activity target	启动其他Activity的当前Activity
Intent intent	要启动的目标intent
int requestCode	启动请求码
Bundle options	启动的额外参数

看一下该方法实现

public ActivityResult execStartActivity(.......) {
    // ......
    intent.migrateExtraStreamToClipData(who);
    intent.prepareToLeaveProcess(who);
    //1. 将Activity启动交由ActivityTaskManager.getService()处理
    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);
    // 检查Activity的启动结果
    checkStartActivityResult(result, intent);
    // ......
}

Instructmentation的exectStartActivity()方法将Activity的启动交由ActivityManager.getService().startActivity()完成。

看一下ActivityManager.getService()实现

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

private static final Singleton<IActivityTaskManager> IActivityTaskManagerSingleton =
    new Singleton<IActivityTaskManager>() {
    @Override
    protected IActivityTaskManager create() {
        //获取跨进程服务 ActivityTaskManagerService
        final IBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);
        return IActivityTaskManager.Stub.asInterface(b);
    }
};

ActivityManager.getService()获取到了ATMS代理对象IActivityTaskManager，该IActivityTaskManager代理对象是一个接口，实现类为ActivityTaskManagerService。

ATMS是在Android10中新增的，分担了之前AMS一部分功能。Android 10之前，这里获取的是服务AMS。

ATMS用于管理Activity及其容器（任务、堆栈、显示等）的系统服务，运行在系统服务进程之中，与AMS同属于一个进程，二者之间用Handler通信。

回过头简单看一下checkStartActivityResult()方法，ActivityTaskManager.getService().startActivity有个返回值result，并调用了checkStartActivityResult()方法

public static void checkStartActivityResult(int res, Object intent) {
    if (!ActivityManager.isStartResultFatalError(res)) {
        return;
    }

    switch (res) {
        case ActivityManager.START_INTENT_NOT_RESOLVED:
        case ActivityManager.START_CLASS_NOT_FOUND:
            if (intent instanceof Intent && ((Intent)intent).getComponent() != null)
                throw new ActivityNotFoundException(
                "Unable to find explicit activity class "
                + ((Intent)intent).getComponent().toShortString()
                + "; have you declared this activity in your AndroidManifest.xml?");
            throw new ActivityNotFoundException(
                "No Activity found to handle " + intent);
        case ActivityManager.START_PERMISSION_DENIED:
            throw new SecurityException("Not allowed to start activity "
                                        + intent);
            //......
    }
}

checkStartActivityResult()用来检查Activity启动的结果。如果发生致命错误，就会抛出对应的异常。

小结：

1. 通过startActivity启动目标Activity，最终由startActivityForResult()实现，其启动Activity的核心是由Instrumentation的execStartActivity实现。
2. execStartActivity将Activity交由ActivityTaskManagerService的startActivity()实现，这是一个跨进程通信行为。

2.2 ATMS中启动Activity

ActivityManager.getService()获取到ATMS代理对象，Activity的启动跨进程转移到系统进程提供的服务ATMS中。

跟踪ATMS的startActivity方法调用，来到startActivityAsUser()中

private int startActivityAsUser(IApplicationThread caller, ......) {
    //......
    //1. 获取ActivityStarter实例，启动Activity
    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()方法中通过getActivityStartController().obtainStarter()方法获取ActivityStarter实例，调用一系列方法后，通过execute方法开始启动

ActivityStarter类

在ActivityStarter类中，看一下execute()实现。

int execute() {
    //......
    //1. 执行启动
    res = executeRequest(mRequest);
    //......
    //2. activity 启动日志
    mSupervisor.getActivityMetricsLogger().notifyActivityLaunched(launchingState, res,
                                                                  newActivityCreated, mLastStartActivityRecord, originalOptions);
}

看一下executeRequest()方法实现

private int executeRequest(Request request) {
    // ......
    //1. 收集intent 所指向的 activity 信息
    ActivityInfo aInfo = request.activityInfo;
    //2. 处理 intent 信息，当存在多个 activity 时，弹出 resolverAcitvity
    ResolveInfo rInfo = request.resolveInfo;
    //......
    //3. 获取调用者的进程记录对象
    callerApp = mService.getProcessController(caller);
    if (callerApp != null) {
        callingPid = callerApp.getPid();
        callingUid = callerApp.mInfo.uid;
    }
    //......
    //4. 获取调用者所在的Activity
    sourceRecord = mRootWindowContainer.isInAnyTask(resultTo);
    // ......
    //5. 创建 activity 记录对象
    final ActivityRecord r = new ActivityRecord.Builder(mService).....;
    //......
    // 6. Activity启动核心，调用startActivityUnchecked方法
    mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession,
                                                      request.voiceInteractor, startFlags, true /* doResume */, checkedOptions, inTask,
                                                      restrictedBgActivity, intentGrants);
    // ......
    return mLastStartActivityResult;
}

executeRequest()方法主要内容：进行Activity启动前的信息检查，包括权限检查，根据启动标志位和Activity启动模式来决定如何启动一个Activity等。最终调用到startActivityUnchecked()进行Activity启动

跟踪startActivityUnchecked()方法，来到startActivityInner()方法中

int startActivityInner(final ActivityRecord r, ......) {
    //......
    //1. 计算启动 Activity 的 Flag 值
    computeLaunchingTaskFlags();
    //......
    //2. 处理 Task 和 Activity 的进栈操作
    mTargetRootTask.startActivityLocked(mStartActivity,
                                        topRootTask != null ? topRootTask.getTopNonFinishingActivity() : null, newTask,
                                        mKeepCurTransition, mOptions, sourceRecord);
    // ......
    //3. 启动栈中顶部的Activity
    mRootWindowContainer.resumeFocusedTasksTopActivities(
        mTargetRootTask, mStartActivity, mOptions, mTransientLaunch);
    // ......
}

看一下RootActivityContainer的resumeFocusedStacksTopActivities()方法实现

boolean resumeFocusedTasksTopActivities(......) {
    //......
    //1. 调用了Task类的resumeTopActivityUncheckedLocked()
    result = targetRootTask.resumeTopActivityUncheckedLocked(target, targetOptions,deferPause);
    // ......
	return result;
}

看一下Task的resumeTopActivityUncheckedLocked()实现

boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ......) {
    // ......
    //1. 防止递归
    mInResumeTopActivity = true;
    // ......
    //2. 关键执行
    someActivityResumed = resumeTopActivityInnerLocked(prev, options, deferPause);
    //......
    return someActivityResumed;
}

跟进resumeTopActivityInnerLocked()方法实现

private boolean resumeTopActivityInnerLocked(......) {
    // 系统没有进入 booting 或 booted 状态，则不允许启动 Activity
    if (!mAtmService.isBooting() && !mAtmService.isBooted()) {
        return false;
    }
    // ......
    //1. 暂停上一个Activity
    if (mResumedActivity != null) {
        ProtoLog.d(WM_DEBUG_STATES, "resumeTopActivityLocked: Pausing %s", mResumedActivity);
        pausing |= startPausingLocked(false /* uiSleeping */, next,
                                      "resumeTopActivityInnerLocked");
    }
    //......
    //2. 取根activity的主题背景 展示StartingWindow，冷启动白屏的原因
    if (SHOW_APP_STARTING_PREVIEW) {
        next.showStartingWindow(false /* taskSwich */);
    }
    //......
    //3. 继续当前Activity的启动
    mTaskSupervisor.startSpecificActivity(next, true, true);
    //......
}

在resumeTopActivityInnerLocked()方法中，判断是否有Activity处于Resume状态。若有，先让该Activity执行Pausing过程，再执行startSpecificActivity启动目标Activity

小结：

1. ActivityTaskManagerService的startActivity()最终由ActivityStarter类的execute()方法实现
2. ActivityStarter类的execute()经过executeRequest()、startActivityUnchecked()、startActivityInner()方法，最后由RootActivityContainer的resumeFocusedStacksTopActivities()方法实现
3. RootActivityContainer的resumeFocusedStacksTopActivities()方法调用了Task类的resumeTopActivityUncheckedLocked()方法，然后在resumeTopActivityInnerLocked()方法进行Activity启动状态判断。如果有Activity处于Resume状态。若有，先让该Activity执行Pausing过程，再执行startSpecificActivity启动目标Activity

2.2.1 onPause

resumeTopActivityInnerLocked()会让当前处理Resume状态的Activity执行Pausing过程，先看一下该流程。

final boolean startPausingLocked(......) {
    //......
    //mResumedActivity表示当前处于Resume状态的Activity
    ActivityRecord prev = mResumedActivity;
    //......
    //1. 把 prev 赋值给 mPausingActivity
    mPausingActivity = prev;
    mLastPausedActivity = prev;
    //......
    //2. 将该Activity状态置为PAUSING
    prev.setState(PAUSING, "startPausingLocked");
    // ......
    //3. 通过 ClientLifecycleManager 的 scheduleTransaction() 方法把 PauseActivityItem 事件加入到执行计划中，开始栈顶的 pausing 过程
    mAtmService.getLifecycleManager().scheduleTransaction(prev.app.getThread(),prev.appToken, PauseActivityItem.obtain(prev.finishing, userLeaving,prev.configChangeFlags, pauseImmediately));
	//......
}

startPausingLocked()主要内容：得到要Pause的Activity prev，设置该Activity的状态，并通过 ClientLifecycleManager 的 scheduleTransaction() 方法把 PauseActivityItem 事件加入到执行计划中，开始栈顶的 pausing 过程

跟踪scheduleTransaction()实现，来到ClientTransaction的schedule()方法。

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

mClient是一个IApplicationThread类型，ActivityThread 的内部类 ApplicationThread实现了该接口，其是一个Binder对象。看一下ApplicationThread的scheduleTransaction() 方法。

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

ActivityThread为定义该方法，看一下其父类ClientTransactionHandler的scheduleTransaction()方法

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

该方法发送了一个ActivityThread.H.EXECUTE_TRANSACTION给Handler

case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
//Handler H 的实例接收到 EXECUTE_TRANSACTION 消息后调用TransactionExecutor.execute() 方法切换 Activity 状态
mTransactionExecutor.execute(transaction);
if (isSystem()) {
    transaction.recycle();
}
break;

public void execute(ClientTransaction transaction) {
    //......
    final IBinder token = transaction.getActivityToken();
    // ......
    // 处理添加的 callback
    executeCallbacks(transaction);
    // 处理 当前状态 设置的 LifecycleStateRequest 状态
    executeLifecycleState(transaction);
    mPendingActions.clear();
    // ......
}

看一下TransactionExecutor的executeCallbacks()实现

public void executeCallbacks(ClientTransaction transaction) {
    final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
    //......
    final int size = callbacks.size();
    for (int i = 0; i < size; ++i) {
        final ClientTransactionItem item = callbacks.get(i);
        //......
        item.execute(mTransactionHandler, token, mPendingActions);
        item.postExecute(mTransactionHandler, token, mPendingActions);
        //......
    }
    //......
}

回到最开始的startPausingLocked() 方法，可知此时传递的是 PauseActivityItem，所以会调用PauseActivityItem的execute方法。

其中mTransactionHandler 就是 ActivityThread

private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this);

public TransactionExecutor(ClientTransactionHandler clientTransactionHandler) {
    mTransactionHandler = clientTransactionHandler;
}

看一下PauseActivityItem的execute()方法实现

public void execute(ClientTransactionHandler client, ......) {
    Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
    // 跳转到 ActivityThread.handlePauseActivity 方法
    client.handlePauseActivity(r, mFinished, mUserLeaving, mConfigChanges, pendingActions,
                               "PAUSE_ACTIVITY_ITEM");
    Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}

接着看一下ActivityThread的handlePauseActivity()方法

public void handlePauseActivity(ActivityClientRecord r, ......) {
    // ......
    //调用performPauseActivity方法来处理
    performPauseActivity(r, finished, reason, pendingActions);
    //......
}

private Bundle performPauseActivity(ActivityClientRecord r, ......) {
    // ......
    // 1. 在进行Pausing之前进行数据保存
    if (shouldSaveState) {
        callActivityOnSaveInstanceState(r);
    }
    // 关键执行
    performPauseActivityIfNeeded(r, reason);
    //......
}

看一下performPauseActivityIfNeeded()的实现

private void performPauseActivityIfNeeded(ActivityClientRecord r, String reason) {
    // ......
    r.activity.mCalled = false;
    //关键执行
    mInstrumentation.callActivityOnPause(r.activity);
    // ......
    r.setState(ON_PAUSE);
}

Activity的实际操作类还是回到Instrumentation，看一下该方法实现

public void callActivityOnPause(Activity activity) {
    activity.performPause();
}

final void performPause() {
    // ......
    dispatchActivityPrePaused();
    mDoReportFullyDrawn = false;
    mFragments.dispatchPause();
    mCalled = false;
    // 执行onPause暂停方法
    onPause();
    // ......
    dispatchActivityPostPaused();
    // ......
}

到这里基本完成了onPause()的流程分析。

启动一个 Activity 的时候最先被执行的是栈顶的 Activity 的 onPause() 方法

小结：

1. 在Task的resumeTopActivityInnerLocked()方法中，判断到有Activity处于Resume状态，调用startPausingLocked()方法，将该Activity进行Pausing
2. 通过 ClientLifecycleManager 的 scheduleTransaction() 方法把 PauseActivityItem 事件加入到执行计划中，开始栈顶的 pausing 过程，最终由ClientTransaction的schedule()方法实现
3. 通过Binder跨进程通信，回到应用进程，执行ApplicationThread的scheduleTransaction() 方法，其通过Handler消息机制，最终由TransactionExecutor的execute(）方法实现
4. 其最终通过PauseActivityItem的execute()等方法，回到Instrumentation类，由其callActivityOnPause()方法实现
5. callActivityOnPause()最终调用Activity到的onPause()，完成该方法的回调。

2.2.2 startSpecificActivity

回到resumeTopActivityInnerLocked()方法，看一下startSpecificActivity()方法实现

void startSpecificActivity(ActivityRecord r) {
    // Is this activity's application already running?
    final WindowProcessController wpc =
        mService.getProcessController(r.processName, r.info.applicationInfo.uid);
    boolean knownToBeDead = false;
    // 如果 app 存在，并且已经启动
    if (wpc != null && wpc.hasThread()) {
        // ......
        //关键执行
        realStartActivityLocked(r, wpc, andResume, checkConfig);
        // ......
    }
    r.notifyUnknownVisibilityLaunchedForKeyguardTransition();

    final boolean isTop = andResume && r.isTopRunningActivity();
    // 目标进程未创建，启动新的进程
    mService.startProcessAsync(r, knownToBeDead, isTop, isTop ? "top-activity" : "activity");
}

startSpecificActivity()方法主要内容：判断目标进程是否已启动。如果已经启动，就会调用 realStartActivityLocked() 方法继续处理；如果没有启动，则会调用 ActivityTaskManagerService.startProcessAsync() 方法创建新的进程。

其中mService 是 ActivityTaskManagerService

这里先重点看一下目标进程未启动时的处理逻辑，看一下startProcessAsync()方法实现。

2.3 创建目标进程

void startProcessAsync(ActivityRecord activity, ......) {
    // ......
    //发送一个创建新进程的message，该Message 包含一个 ActivityManagerInternal::startProcess
    final Message m = PooledLambda.obtainMessage(ActivityManagerInternal::startProcess,
                                                 mAmInternal, activity.processName, activity.info.applicationInfo, knownToBeDead,
                                                 isTop, hostingType, activity.intent.getComponent());
    mH.sendMessage(m);
    // ......
}

startProcess()是一个抽象方法，由ActivityManagerService 内部类 LocalService 实现

public final class LocalService extends ActivityManagerInternal
    implements ActivityManagerLocal {
    public void startProcess(String processName, ApplicationInfo info, ......) {
        //......
        //调用 startProcessLocked() 方法
        startProcessLocked(processName, info, knownToBeDead, 0 /* intentFlags */,
                           new HostingRecord(hostingType, hostingName, isTop),
                           ZYGOTE_POLICY_FLAG_LATENCY_SENSITIVE, false /* allowWhileBooting */,
                           false /* isolated */);
        //......

    }
}

通过mService.mH.sendMessage(msg)发送handle消息告诉AMS类去执行startProcess()方法，这里mService为ATMS对象，mH是定义在ATMS类中的一个handler

看一下AMS中的startProcessLocked()方法实现

final ProcessRecord startProcessLocked(String processName, ......) {
    return mProcessList.startProcessLocked(processName, info, knownToBeDead, intentFlags,
                                           hostingRecord, zygotePolicyFlags, allowWhileBooting, isolated, 0 /* isolatedUid */,
                                           null /* ABI override */, null /* entryPoint */,
                                           null /* entryPointArgs */, null /* crashHandler */);
}

接着看一下ProcessList的startProcessLocked()方法实现

ProcessRecord startProcessLocked(String processName, ...... ) {
    //......
    checkSlow(startTime, "startProcess: stepping in to startProcess");
    //关键执行
    final boolean success =
        startProcessLocked(app, hostingRecord, zygotePolicyFlags, abiOverride);
    checkSlow(startTime, "startProcess: done starting proc!");
    return success ? app : null;
}

跟踪startProcessLocked()方法来到startProcess()方法

private Process.ProcessStartResult startProcess(HostingRecord hostingRecord, ......) {
    // ......
    //创建进程
    startResult = Process.start(entryPoint,......);
    //......
}

ATMS.startProcessLocked() 方法经过多次跳转最终会通过 Process.start() 方法来为应用创建进程。

public static ProcessStartResult start(......) {
    return ZYGOTE_PROCESS.start(processClass, niceName,.....);
}

最终，调用了ZYGOTE_PROCESS.start()方法。ZYGOTE_PROCESS就是系统中的Zygote进程，Android中所有的App进程都是由Zygote进程fork生成的，包括SystemServer进程。Zygote是所有Java进程的父进程，到这里就开始了目标APP进程的创建了。目标APP进程创建成功，会立即启动ActivityThread线程，并进入它的main方法。

小结：

1. Task中resumeTopActivityInnerLocked()调用ActivityStackSupervisor的startSpecificActivity()方法启动Activity。其会先判断目标进程是否已启动。若未启动，会通过ActivityTaskManagerService.startProcessAsync() 方法创建新的进程
2. 通过一系列方法调用，通过发送handle消息告诉AMS类去执行startProcess()方法。经过多次跳转最终会通过 Process.start() 方法来为应用创建进程。
3. 最终，调用了ZYGOTE_PROCESS.start()方法，完成目标进程的创建

2.4 进入App进程初始化

目标APP进程创建成功，会立即启动ActivityThread线程，并进入它的main方法，执行主线程的初始化工作。

看一下ActivityThread的main()方法实现

public static void main(String[] args) {
    //......
    //1. 创建主线程looper
    Looper.prepareMainLooper();
    // ......
    //2. 初始化ActivityThread实例
    ActivityThread thread = new ActivityThread();
    //3. attach 到系统进程
    thread.attach(false, startSeq);

    if (sMainThreadHandler == null) {
        sMainThreadHandler = thread.getHandler();
    }
    //......
    //3. 主线程启动，进入循环状态
    Looper.loop();
    //......
}

回到了目标APP进程中，这里又完成了一次跨进程。

ActivityThread的Main入口主要工作内容：调用Looper.prepareMainLooper创建一个消息循环队列，然后调用Looper.loop进入消息循环，当前线程进入消息循环中，使当前线程成为新进程的主线程，然后创建一个ActivityThread对象，调用attach方法。

看一下attach方法实现

private void attach(boolean system, long startSeq) {
    //......
    //1. 通过 ActivityManagerService 为这个应用绑定一个 Application
    final IActivityManager mgr = ActivityManager.getService();
    try {
        mgr.attachApplication(mAppThread, startSeq);
    } catch (RemoteException ex) {
        throw ex.rethrowFromSystemServer();
    }
    //2. 添加一个垃圾回收观察者，系统触发垃圾回收的时候就会计算内存使用情况，超过阈值尝试进行内存释放
    BinderInternal.addGcWatcher(......);
    // ......
}

IActivityManager 的实现类是 ActivityManagerService 。

在ActivityThread.attach()方法中，首先通过ActivityManagerService为这个应用绑定一个Application。ApplicationThread是一个ActivityThread本地binder对象，Binder的服务端在ActivityThread中。将Binder对象传递给AMS服务，则AMS服务中保存它的代理，AMS就获得了与新进程通信的方式。

小结：

1. 目标APP进程创建成功，会立即启动ActivityThread线程，并进入它的main方法，执行主线程的初始化工作。
2. 调用Looper.prepareMainLooper创建一个消息循环队列，调用Looper.loop进入消息循环，当前线程进入消息循环中，使当前线程成为新进程的主线程，然后创建一个ActivityThread对象，调用attach方法。
3. 在attact()方法中，通过 ActivityManagerService 为这个应用绑定一个 Application。这也是一个Binder进程通信，调用AMS进程的attachApplication()方法。

2.5 AMS进程执行Application初始化

我们进入AMS进程，看一下attachApplication()方法的具体实现

public final void attachApplication(IApplicationThread thread, long startSeq) {
    // ......
    synchronized (this) {
        int callingPid = Binder.getCallingPid();
        final int callingUid = Binder.getCallingUid();
        final long origId = Binder.clearCallingIdentity();
        //关键执行
        attachApplicationLocked(thread, callingPid, callingUid, startSeq);
        Binder.restoreCallingIdentity(origId);
    }
}

private boolean attachApplicationLocked(@NonNull IApplicationThread thread,......) {
    //......
    //1. 调用ActivityThread的bindApplication方法，初始化Application
    thread.bindApplication(processName....);
    //......
    if (normalMode) {
        try {
            //2. 调用 attachApplication()启动新的Activity
            didSomething = mAtmInternal.attachApplication(app.getWindowProcessController());
        } catch (Exception e) {
            Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
            badApp = true;
        }
    }
    //......
}

mAtmInternal是ActivityTaskManagerInternal类型，其实现类为ActivityTaskManagerService。

attachApplicationLocked()方法的主要内容：通过进程间通信请求，调用thread的bindApplication方法，进行Application的初始化。然后通过ATMS去启动目标Activity。

2.6 应用进程Application初始化

先回到应用进程，看一下bindApplication()的具体实现。

public final void bindApplication(String processName, ......) {
    //......
    AppBindData data = new AppBindData();
    //......
    //1. 发送了一个 H.BIND_APPLICATION消息
    sendMessage(H.BIND_APPLICATION, data);
}

bindApplication()发送了一个H.BIND_APPLICATION消息，看一下消息处理逻辑

case BIND_APPLICATION:
    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");
    AppBindData data = (AppBindData)msg.obj;
    //关键执行
    handleBindApplication(data);
    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
    break;

看一下handleBindApplication()方法实现

private void handleBindApplication(AppBindData data) {
    //......
    //1. 初始化仪表盘
    if (ii != null) {
        initInstrumentation(ii, data, appContext);
    } else {
        mInstrumentation = new Instrumentation();
        mInstrumentation.basicInit(this);
    }
    
    //......
    //2. 创建Application
    app = data.info.makeApplication(data.restrictedBackupMode, null);
    // ......
    //3.安装相关的ContentProvider
    installContentProviders(app, data.providers);
    // ......
    //4. 调用Application的onCreate()方法
    mInstrumentation.callApplicationOnCreate(app);
    //......
}

handleBindApplication()方法主要内容：创建仪表盘，创建Application，安装相关的ContentProvider，最后通过Instrumentation调用Application的onCreate()方法，完成Application的初始化。

2.7 AMS进程启动Activity

继续回到AMS的attachApplicationLocked()方法，看一下attachApplication()的具体实现

public boolean attachApplication(WindowProcessController wpc) throws RemoteException {
    //......
    //关键执行
    return mRootWindowContainer.attachApplication(wpc);
    //......
}

看一下RootWindowContainer的attachApplication()实现

boolean attachApplication(WindowProcessController app) throws RemoteException {
    // ......
    //1. 关键执行
    final PooledFunction c = PooledLambda.obtainFunction(
        RootWindowContainer::startActivityForAttachedApplicationIfNeeded, this, ......);
    rootTask.forAllActivities(c);
    c.recycle();
    //......
}

看一下RootWindowContainer的startActivityForAttachedApplicationIfNeeded()实现

private boolean startActivityForAttachedApplicationIfNeeded(ActivityRecord r,) {
    //......
    //1. ActivityStackSupervisor.realStartActivityLocked()
    if (mTaskSupervisor.realStartActivityLocked(r, app,
                                                top == r && r.isFocusable() /*andResume*/, true /*checkConfig*/)) {
        mTmpBoolean = true;
    }
    //......
}

最终通过ActivityStackSupervisor.realStartActivityLocked()方法来启动Activity。这与前述在AMS进程中的startSpectificActivity()分析对应上了。如果进程已启动，也是通过realStartActivityLocked()来启动Activity。

看一下realStartActivityLocked()方法实现

boolean realStartActivityLocked(ActivityRecord r, ......) {
    //......
    // 1. 创建一个Activity启动的事务
    final ClientTransaction clientTransaction = ClientTransaction.obtain(
        proc.getThread(), r.appToken);
    final boolean isTransitionForward = r.isTransitionForward();
    //2. 为 ClientTransaction 对象添加 LaunchActivityItem 的 callback
    clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent), ......));
    //3. 设置期望的生命周期状态
    final ActivityLifecycleItem lifecycleItem;
    if (andResume) {
        lifecycleItem = ResumeActivityItem.obtain(isTransitionForward);
    } else {
        lifecycleItem = PauseActivityItem.obtain();
    }
    clientTransaction.setLifecycleStateRequest(lifecycleItem);
    //4. 调用 ClientLifecycleManager.scheduleTransaction 方法,启动事务
    mService.getLifecycleManager().scheduleTransaction(clientTransaction);
    //......
}

realStartActivityLocked()方法主要内容：创建事务，同时传入ApplicationThread。ApplicationThread继承于Binder，主要用来在后面跟目标APP进程通信。最后启动事务

关于ClientLifecycleManager在onPause部分已经进行分析了，这里直接看一下传入的LaunchActivityItem的execute()方法

public void execute(ClientTransactionHandler client, IBinder token,
                    PendingTransactionActions pendingActions) {
    Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
    ActivityClientRecord r = client.getLaunchingActivity(token);
    //关键执行，调用ActivityThread的handleLaunchActivity方法
    client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
    Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}

这是一个跨进程行为，回到应用进程，看一下该方法具体实现

小结：

1. AMS的attachApplicationLocked()方法通过一系列方法调用，最终通过ActivityStackSupervisor.realStartActivityLocked()方法来启动Activity。如果一开始目标进程就已启动，也是通过realStartActivityLocked()来启动Activity。
2. realStartActivityLocked()方法通过ClientLifecycleManager来进行Activity的启动，此时传入的是LaunchActivityItem，执行其execute()方法。
3. 最终，会通过跨进程通信的方式，回调应用进程，调用ActivityThread的handleLaunchActivity()方法

2.8 应用进程创建Activity

回到应用进程，看一下handleLaunchActivity的实现

public Activity handleLaunchActivity(ActivityClientRecord r ......) {
    //.....
    //1. 初始化Activity的WindowManager
    WindowManagerGlobal.initialize();
    GraphicsEnvironment.hintActivityLaunch();
    //2. 关键执行
    final Activity a = performLaunchActivity(r, customIntent);
    //......
}

handleLaunchActivity()方法通过performLaunchActivity()方法创建和显示Activity。看一下其具体实现

private Activity performLaunchActivity(ActivityClientRecord r ......) {
    //......
    //1. 进行初始化ComponentName
    ComponentName component = r.intent.getComponent();
    //.....
    //2. 初始化ContextImpl，并通过反射创建目标Activity对象
    ContextImpl appContext = createBaseContextForActivity(r);
    Activity activity = null;
    //......
    //3. 初始化Application
    Application app = r.packageInfo.makeApplication(false, mInstrumentation);
    //......
    //4. 调用 attach 方法建立 Activity 与 Context 之间的联系，创建 PhoneWindow 对象，并与 Activity 进行关联操作
    appContext.setOuterContext(activity);
    activity.attach(appContext, 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.configCallback,
                    r.assistToken, r.shareableActivityToken);
    //......
    //5. 设置Activity的主题
    int theme = r.activityInfo.getThemeResource();
    if (theme != 0) {
        activity.setTheme(theme);
    }
    //......
    //6. 通过 Instrumentation 最终调用 Activity 的 onCreate 方法
    if (r.isPersistable()) {
        mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
    } else {
        mInstrumentation.callActivityOnCreate(activity, r.state);
    }
    //......
}

performLaunchActivity()的主要内容：反射创建目标Activity对象；创建PhoneWindow对象；调用attach方法绑定Activity；调用 Activity 的 onCreate 方法

重点看一下callActivityOnCreate()实现

public void callActivityOnCreate(Activity activity, Bundle icicle,
                                 PersistableBundle persistentState) {
    prePerformCreate(activity);
    //1. 调用Activity的performCreate()方法
    activity.performCreate(icicle, persistentState);
    postPerformCreate(activity);
}

跟踪Activity的performCreate()方法实现，其最终调用了onCreate()方法。至此，完成了目标Activity的创建，并开始了生命周期的回调。

2.9 onStart、onResume回调

onStart、onResume是在什么时候进行回调的呢？回到前述onPause部分，在执行完executeCallbacks(transaction)，需要再执行executeLifecycleState(transaction)代码。看一下其实现

private void executeLifecycleState(ClientTransaction transaction) {
    //1. 获取期望达到的Lifecycle最终状态，这里为ResumeActivityItem，在realStartActivityLocked()中进行了设置
    final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
    //......
    cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction);
    //......
}

看一下cycleToPath()方法实现

private void cycleToPath(ActivityClientRecord r, ......) {
    final int start = r.getLifecycleState();
    //......
    //1. 计算需要执行哪些生命周期
    final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
    //2. 执行相关生命周期回调
    performLifecycleSequence(r, path, transaction);
}

先看一下getLifecyclePath()方法实现

public IntArray getLifecyclePath(int start, int finish, boolean excludeLastState) {
    //......
    mLifecycleSequence.clear();
    if (finish >= start) {
        if (start == ON_START && finish == ON_STOP) {
            // A case when we from start to stop state soon, we don't need to go
                // through the resumed, paused state.
            mLifecycleSequence.add(ON_STOP);
        } else {
            // just go there
            for (int i = start + 1; i <= finish; i++) {
                mLifecycleSequence.add(i);
            }
        }
    }
    //......
    return mLifecycleSequence;
}

这里start 为 ON_CREATE = 1 ，finish 为 ON_RESUME = 3

接着看一下performLifecycleSequence()方法实现

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;
                //......
        }
    }

这里state是由ON_START 到 ON_RESUME，其分别会执行handleStartActivity()和handleResumeActivity()方法。

跟踪上述两个方法的执行，可知其最终分别调用了onStart()和onResume()方法，完成了二者的方法回调。

2.10 onStop、onDestroy回调

onStop、onDestroy是在什么时候进行回调的呢？

首先看一下handleResumeActivity()方法

public void handleResumeActivity(ActivityClientRecord r,) {
    //......
    //1. 往当前线程添加一个闲时消息，即当 MessageQueue 空闲的时候就会执行这个 Handler
    Looper.myQueue().addIdleHandler(new Idler());
}

handleResumeActivity()方法在最后往当前线程Looper中的消息队列添加了一个闲时消息Idler。当消息队列中无消息处理时将回调它的queueIdle方法。该接口如果返回 false ，那么就会移除它，返回 true 就会在下次 message 处理完了的时候继续回调。

看一下Idler的queueIdle()方法实现

private class Idler implements MessageQueue.IdleHandler {
    @Override
    public final boolean queueIdle() {
        //......
        final ActivityClient ac = ActivityClient.getInstance();
        //......
        //1. 调用ActivityClient.activityIdle() 方法
        if (a.activity != null && !a.activity.mFinished) {
            ac.activityIdle(a.token, a.createdConfig, stopProfiling);
            a.createdConfig = null;
        }
        //......
        return false;
    }
}

我们activityIdle()进行跟踪，最终调用到ActivityClientController的activityIdle()方法

public void activityIdle(IBinder token, Configuration config, boolean stopProfiling) {
    //......
    //关键执行
    mTaskSupervisor.activityIdleInternal(r, false /* fromTimeout */,
                                         false /* processPausingActivities */, config);
    //......
}

看一下activityIdleInternal()的实现

void activityIdleInternal(ActivityRecord r, ......) {
    //......
    //1. 关键执行
    processStoppingAndFinishingActivities(r, processPausingActivities, "idle");
    //......
}

/**
     * Processes the activities to be stopped or destroyed. This should be called when the resumed
     * activities are idle or drawn.
     */
private void processStoppingAndFinishingActivities(ActivityRecord launchedActivity,) {
    //......
    //1. 添加需要 stop 的 activity
    readyToStopActivities.add(s);
    // ......
    //2. stop或destroy Activity
    for (int i = 0; i < numReadyStops; i++) {
        final ActivityRecord r = readyToStopActivities.get(i);
        if (r.isInHistory()) {
            if (r.finishing) {
                // TODO(b/137329632): Wait for idle of the right activity, not just any.
                r.destroyIfPossible(reason);
            } else {
                r.stopIfPossible();
            }
        }
    }
    //......
    //3. destroy Activity
    mFinishingActivities.clear();
    for (int i = 0; i < numFinishingActivities; i++) {
        final ActivityRecord r = finishingActivities.get(i);
        if (r.isInHistory()) {
            r.destroyImmediately("finish-" + reason);
        }
    }
}

先看一下stopIfPossible()方法实现

void stopIfPossible() {
    //......
    //1. 关键执行
    mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), appToken,
                                                          StopActivityItem.obtain(configChangeFlags));
}

关于 mAtmService.getLifecycleManager().scheduleTransaction()的实现这里不再赘述，在前述分析中已多次分析过。其最终会执行StopActivityItem.execute()，最终执行到onStop()方法。

最后看一下destroyIfPossible()实现

boolean destroyIfPossible(String reason) {
    //......
    //1. 关键执行
    final boolean activityRemoved = destroyImmediately("finish-imm:" + reason);
    //......
}

boolean destroyImmediately(String reason) {
    //......
    //1. 关键执行
    mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), appToken,
                                                          DestroyActivityItem.obtain(finishing, configChangeFlags));
    //......
}

关于 mAtmService.getLifecycleManager().scheduleTransaction()的实现这里不再赘述，其最终会执行DestroyActivityItem.execute()，最终执行到onDestroy()方法。

Activity的启动主要分两个支线，一个是：

1、启动进程start目标Activity，并进入AMS。

2、AMS判断目标Activity所属进程是否存在，存在就去通知ApplicationThread启动目标Activity。

3、目标ActivityThread收到通知，执行Activity的创建、初始化操作。

另一个是：

1、启动进程start目标Activity，并进入AMS。

2、AMS判断目标Activity所属进程是否存在，不存在就去通知Zygote进程创建一个新的进程。

3、新的进程进入ActivityThread的main入口，初始化Looper，并通知AMS进程去初始化Application。

4、同时AMS又去执行Activity的启动，接着通知ApplicationThread启动目标Activity。

5、目标ActivityThread收到通知，执行Activity的创建、初始化操作。

Activity的启动简单流程图如下：