前言
Activity的启动有两种流程，一种是入口Activity的启动，另外一种就是普通Activity启动。入口Activity是指应用程序启动的第一个Activity，它的启动过程也可以理解为应用程序的启动过程。普通Activity的流程相对简单很多，是入口Activity启动流程中的一部分，所以我们这里只看入口Activity启动流程。
Launcher请求AMS
前面的文章中知道Launcher启动后会将已安装程序的图标显示到桌面上，当点击这个图标的时候，Launcher就会请求AMS启动应用。过程如下：
可以看到依次调用了Activity的startActivity和startActivityForResult函数，这里来看看startActivityForResult的代码：
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 {
...
}
}
因为入口Activity还没创建出来，所以mParent是空（如果不为空说明应用已经启动，则就进入了普通Activity的流程），这样就执行了Instrumentation的execStartActivity方法。
在execStartActivity中会调用ActivityManager的getService方法来获取AMS的代理对象，然后调用它的startActivity方法，这样就将启动请求发送到AMS中了。
AMS处理请求
在AMS中会对请求进行一系列处理，最终会让ApplicationThread来处理，这部分时序图如下：
AMS的startActivity的代码如下：
@Override
public final int startActivity(IApplicationThread caller, String callingPackage,
Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
resultWho, requestCode, startFlags, profilerInfo, bOptions,
UserHandle.getCallingUserId());
}
直接调用了startActivityAsUser，这里通过 UserHandle.getCallingUserId() 获取了调用者的UserId，AMS就是根据这个id来确定调用者的权限，如果权限不够则不能启动该应用。
在startActivityAsUser中会依次调用ActivityStarter的startActivityMayWait、startActivityLocked和startActivity。这里重点说一下startActivity方法，它的主要代码如下：
private int startActivity(...) {
...
ProcessRecord callerApp = null;
if (caller != null) {
callerApp = mService.getRecordForAppLocked(caller);
if (callerApp != null) {
callingPid = callerApp.pid;
callingUid = callerApp.info.uid;
} else {
Slog.w(TAG, "Unable to find app for caller " + caller
+ " (pid=" + callingPid + ") when starting: "
+ intent.toString());
err = ActivityManager.START_PERMISSION_DENIED;
}
}
...
ActivityRecord r = new ActivityRecord(mService, callerApp, callingPid, callingUid,
callingPackage, intent, resolvedType, aInfo, mService.getGlobalConfiguration(),
resultRecord, resultWho, requestCode, componentSpecified, voiceSession != null,
mSupervisor, container, options, sourceRecord);
if (outActivity != null) {
outActivity[0] = r;
}
...
return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags, true,
options, inTask, outActivity);
}
首先判断caller是否为null，这个caller就是发起请求的应用进程（因为我们是从Launcher开始的，所以这里就是Launcher）的ApplicationThread对象。
然后看到调用了AMS的getRecordForAppLocked获取callerApp对象，它是ProcessRecord类型（ProcessRecord这个类用来描述应用程序进程）。
继续往下看，接下来创建了一个ActivityRecord对象，与ProcessRecord类似ActivityRecord用来记录一个Activity的信息。
最后调用了另外一个startActivity方法，在这个方法中会调用startActivityUnchecked方法，这个方法的代码如下：
private int startActivityUnchecked(...) {
...
if (mStartActivity.resultTo == null && mInTask == null && !mAddingToTask
&& (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
newTask = true;
result = setTaskFromReuseOrCreateNewTask(
taskToAffiliate, preferredLaunchStackId, topStack);
} else if (mSourceRecord != null) {
result = setTaskFromSourceRecord();
} else if (mInTask != null) {
result = setTaskFromInTask();
} else {
setTaskToCurrentTopOrCreateNewTask(); //代码1
}
...
if (mDoResume) {
final ActivityRecord topTaskActivity =
mStartActivity.getTask().topRunningActivityLocked();
if (!mTargetStack.isFocusable()
|| (topTaskActivity != null && topTaskActivity.mTaskOverlay
&& mStartActivity != topTaskActivity)) {
...
} else {
...
mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity, mOptions); //代码2
}
} else {
mTargetStack.addRecentActivityLocked(mStartActivity);
}
...
}
这个方法主要处理与栈管理相关逻辑，在代码1处的setTaskToCurrentTopOrCreateNewTask方法会创建一个新的TaskRecord，用来描述Activity任务栈，也就是说会创建一个新的Activity任务栈。
然后在代码2处调用ActivityStackSupervisor的resumeFocusedStackTopActivityLocked方法，代码如下：
boolean resumeFocusedStackTopActivityLocked(
ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
if (targetStack != null && isFocusedStack(targetStack)) {
return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
}
final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
if (r == null || r.state != RESUMED) {
mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
} else if (r.state == RESUMED) {
mFocusedStack.executeAppTransition(targetOptions);
}
return false;
}
这里判断如果Activity为null或者不是RESUMED状态会调用ActivityStack的resumeTopActivityUncheckedLocked方法。在这个方法中会调用resumeTopActivityInnerLocked，然后会调用ActivityStackSupervisor的startSpecificActivityLocked方法，来重点看看这个方法：
void startSpecificActivityLocked(ActivityRecord r,
boolean andResume, boolean checkConfig) {
ProcessRecord app = mService.getProcessRecordLocked(r.processName,
r.info.applicationInfo.uid, true);
r.getStack().setLaunchTime(r);
if (app != null && app.thread != null) {
try {
if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0
|| !"android".equals(r.info.packageName)) {
app.addPackage(r.info.packageName, r.info.applicationInfo.versionCode,
mService.mProcessStats);
}
realStartActivityLocked(r, app, andResume, checkConfig);
return;
} catch (RemoteException e) {
Slog.w(TAG, "Exception when starting activity "
+ r.intent.getComponent().flattenToShortString(), e);
}
}
mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
"activity", r.intent.getComponent(), false, false, true);
}
可以看到一开始获取了即将启动的Activity所在的应用进程，然后判断这个应用进程是否存在并且已经运行，如果没运行则直接跳到方法尾部，可以看到这里会调用startProcessLocked启动应用进程；如果已经运行则进入if语句，可以看到最终执行到realStartActivityLocked方法，这个方法的代码如下：
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,boolean andResume, boolean checkConfig) throws RemoteException {
...
try {
...
app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
System.identityHashCode(r), r.info,
mergedConfiguration.getGlobalConfiguration(),
mergedConfiguration.getOverrideConfiguration(), r.compat,
r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
r.persistentState, results, newIntents, !andResume,
mService.isNextTransitionForward(), profilerInfo);
...
} catch (RemoteException e) {
...
}
...
return true;
}
这里app.thread是IApplicationThread，它的实现是ActivityThread的内部类ApplicationThread。这里调用scheduleLaunchActivity就是在目标应用程序的进程中启动Activity。因为当前在AMS进程中，所以这里就需要通过ApplicationThread来与应用程序进程进行Binder通信，ApplicationThread就可以看作是AMS和应用程序进程的桥梁。
ActivityThread启动Activity
通过ApplicationThread我们就进入了应用程序进程中，来看看最后这部分的流程是什么样子的：
ApplicationThread将这个启动的消息传给ActivityThread，最后会调用它的handleLaunchActivity，代码如下：
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
......
Activity a = performLaunchActivity(r, customIntent); //1
if (a != null) {
r.createdConfig = new Configuration(mConfiguration);
Bundle oldState = r.state;
handleResumeActivity(r.token, false, r.isForward, !r.activity.mFinished && !r.startsNotResumed); //2
...
} else {
......
}
}
代码1处调用了performLaunchActivity来启动Activity，并返回得到一个Activity对象。代码2处则通过handleResumeActivity将这个Activity的状态设置为Resume。
接下来看看performLaunchActivity这个方法，这是启动环节一个很重要的节点，代码如下：
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
...
ActivityInfo aInfo = r.activityInfo; //1
if (r.packageInfo == null) {
r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo, //2
Context.CONTEXT_INCLUDE_CODE);
}
ComponentName component = r.intent.getComponent(); //3
...
Activity activity = null;
try {
java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent); //4
...
}
} catch (Exception e) {
...
}
try {
Application app = r.packageInfo.makeApplication(false, mInstrumentation); //5
...
if (activity != null) {
Context appContext = createBaseContextForActivity(r, activity);
...
}
//6
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);
...
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);//7
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
...
}
return activity;
}
代码1处获取ActivityInfo，这个info里存储一些Activity的信息，比如theme和launchMode；代码3处获取要启动Activity的ComponentName，这里存储着Activity的包名和类名；代码4则根据ComponentName创建了要启动的Activity对象；代码5调用makeApplication创建Application对象，这个方法内部会调用Application的onCreate方法；代码6则调用了Activity的attach方法，这个方法中会做一些初始化的工作；最后代码7调用Instrumentation的callActivityOnCreate来启动Activity。
allActivityOnCreate中调用了Activity的performCreate方法，而这个方法中会调用Activity的onCreate方法，这样Activity就启动起来了。
总结
上面可以看到，入口Activity的启动会涉及4个进程：Zygote进程，Launcher进程、AMS进程（SystemServer进程）和应用程序进程。
Launcher向AMS请求创建入口Activity，AMS先判断这个Activity的应用程序进程是否存在并启动，如果不存在会请求Zygote创建应用程序进程并启动。应用程序进程启动后，会通知给AMS， AMS这时候就会请求创建入口Activity并启动。如图：
注意：这个过程中，AMS与Zygote是Socket通信，而Launcher与AMS是Binder通信，同样AMS与应用程序进程也是Binder通信。
