在之前的文中，我们已经了解过了 Android 系统启动的过程。系统启动之后会由 PMS 安装系统应用，并启动 Launcher，也就是桌面程序。然后，我们安装的程序的图标将会显示到桌面上面。
所谓应用启动过程分成两种情形，一个是应用进程已经建立，一种是应用进程没有建立的情况下。后者需要先创建应用进程，然后再执行启动的过程。
安卓系统中的应用在源码中的位置是 platform/packages/apps。这里我们以 Launcher3 为例，它的 Launcher 类也就是我们通常所说的 Main Activity. 当系统启动的时候会由它来展示我们安装的各种应用。
当我们点击应用的图标的时候将会启动应用，它先以 Intent.FLAG_ACTIVITY_NEW_TASK 构建一个 Intent 来启动 Activity. 随后的过程就与启动一个普通的 Activity 差不多（调用 Activity 的 startActivity() 方法），只是当应用进程不存在的情况下，需要先创建应用进程。
1、应用进程启动的过程
从之前的文中，我们知道系统启动的时候会创建一个 Server 端的 Socket 等待 AMS 请求 Zygote 通过 fork 来创建应用进程。当 AMS 需要启动应用进程的时候，它将会调用下面的方法，
// platform\framework\base\services\core\java\com\android\server\am\ActivityManagerService.java
private ProcessStartResult startProcess(String hostingType, String entryPoint,
ProcessRecord app, int uid, int[] gids, int runtimeFlags, int mountExternal,
String seInfo, String requiredAbi, String instructionSet, String invokeWith,
long startTime) {
try {
final ProcessStartResult startResult;
if (hostingType.equals("webview_service")) {
startResult = startWebView(entryPoint,
app.processName, uid, uid, gids, runtimeFlags, mountExternal,
app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
app.info.dataDir, null,
new String[] {PROC_START_SEQ_IDENT + app.startSeq});
} else {
startResult = Process.start(entryPoint,
app.processName, uid, uid, gids, runtimeFlags, mountExternal,
app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
app.info.dataDir, invokeWith,
new String[] {PROC_START_SEQ_IDENT + app.startSeq});
}
return startResult;
}
}
当然，方法名称和调用的位置可能因为源码的版本不同而不同。但它们本质上都是通过调用 Process 的 start() 方法来最终启动应用进程的。
方法的调用会通过 Process 的 start() 方法直到 ZygoteProcess 的 startViaZygote(). 因为调用链比较简单，所以我们直接给出下面的方法即可，
// platform\framework\base\core\java\android\os\ZygoteProcess.java
private Process.ProcessStartResult startViaZygote(/* 各种参数 */)
throws ZygoteStartFailedEx {
ArrayList<String> argsForZygote = new ArrayList<String>();
// --runtime-args, --setuid=, --setgid=,
// and --setgroups= must go first
argsForZygote.add("--runtime-args");
argsForZygote.add("--setuid=" + uid);
argsForZygote.add("--setgid=" + gid);
argsForZygote.add("--runtime-flags=" + runtimeFlags);
if (mountExternal == Zygote.MOUNT_EXTERNAL_DEFAULT) {
argsForZygote.add("--mount-external-default");
} else if (mountExternal == Zygote.MOUNT_EXTERNAL_READ) {
argsForZygote.add("--mount-external-read");
} else if (mountExternal == Zygote.MOUNT_EXTERNAL_WRITE) {
argsForZygote.add("--mount-external-write");
}
argsForZygote.add("--target-sdk-version=" + targetSdkVersion);
// ... 准备各种参数
synchronized(mLock) {
return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi), argsForZygote);
}
}
可以看到，这里准备了一些用于 Zygote 的参数，然后调用了 zygoteSendArgsAndGetResult() 方法来向 Zygote 发送请求并获取返回结果。这个方法中要求输入一个 ZygoteState 类型的参数。这个类主要封装了一些与 Zygote 进程通信的状态。这个变量是通过 openZygoteSocketIfNeeded() 方法得到的，它用来建立与 Zygote 进程之间的 Socket 连接。
private static Process.ProcessStartResult zygoteSendArgsAndGetResult(
ZygoteState zygoteState, ArrayList<String> args)
throws ZygoteStartFailedEx {
try {
// ...
// 获取 Zygote 的读写流
final BufferedWriter writer = zygoteState.writer;
final DataInputStream inputStream = zygoteState.inputStream;
// 通过流向 Zygote 写命令
writer.write(Integer.toString(args.size()));
writer.newLine();
for (int i = 0; i < sz; i++) {
String arg = args.get(i);
writer.write(arg);
writer.newLine();
}
writer.flush();
// 读取返回结果
Process.ProcessStartResult result = new Process.ProcessStartResult();
result.pid = inputStream.readInt();
result.usingWrapper = inputStream.readBoolean();
if (result.pid < 0) {
throw new ZygoteStartFailedEx("fork() failed");
}
return result;
} catch (IOException ex) {
zygoteState.close();
throw new ZygoteStartFailedEx(ex);
}
}
上面我们也看到了，这里会先从 ZygoteState 中获取输入流和输出流，然后使用流来进行读写。实际上呢，在获取流之前先使用 ZygoteState 的 connect() 方法与 Zygote 建立了 Socket 连接。
这里是发送 Socket 给 Zygote，那么远程的 Zygote 是如何对连接进行处理的呢？如果你阅读过我们上一篇文章就会知道，ZygoteServer 启动的时候会执行 runSelectLoop() 方法不断对 Socket 进行监听，当收到 AMS 的创建应用进程的请求之后，会调用 Zygote 类的静态方法 forkAndSpecialize() 来创建子进程。读者可以参考下面的文章来了解，
创建子进程完毕之后会将创建的结果返回给调用者，然后 Zygote 需要对 fork 的子进程的结果进行后续处理，比如启动进程中的方法等。这些将交给 handleChildProc() 方法来完成，
// platform/framework/base/core/java/com/android/internal/os/ZygoteConnection.java
private Runnable handleChildProc(Arguments parsedArgs, FileDescriptor[] descriptors,
FileDescriptor pipeFd, boolean isZygote) {
// ...
if (parsedArgs.invokeWith != null) {
throw new IllegalStateException("WrapperInit.execApplication unexpectedly returned");
} else {
if (!isZygote) {
return ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs,
null /* classLoader */);
} else {
return ZygoteInit.childZygoteInit(parsedArgs.targetSdkVersion,
parsedArgs.remainingArgs, null /* classLoader */);
}
}
}
这里的 zygoteInit() 用来对 Zygote 的子进程进行处理。
public static final Runnable zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) {
RuntimeInit.redirectLogStreams();
RuntimeInit.commonInit();
ZygoteInit.nativeZygoteInit(); // 启动 Binder 线程池
return RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader); // 调用到 ActivityThread 的 main 方法
}
它主要做了两件事情：1).启动 Binder 线程池；2).调用到 ActivityThread 的 main 方法，这样程序就进入到了我们的 ActivityThread 中。启动 Binder 线程池的时候，将会通过 JNI 调用进入 AndroidRuntime.cpp 中，
static void com_android_internal_os_ZygoteInit_nativeZygoteInit(JNIEnv* env, jobject clazz)
{
gCurRuntime->onZygoteInit();
}
这里的 gCurRuntime 就是 AppRuntime 了，它定义在 app_main.cpp 文件中。它会调用下面的方法来启动 Binder 线程池，
virtual void onZygoteInit()
{
sp<ProcessState> proc = ProcessState::self();
proc->startThreadPool();
}
2、已存在应用进程的时候的启动过程
上面是创建应用进程的过程，下面我们再来看下当应用进程创建之后，应用将如何启动。当我们从 Launcher 页面启动 Activity 的时候会通过 Activity 的 startActivity() 启动 Activity. 最终所有的启动 Activity 的操作都将经过 startActivityForResult() 方法处理。它将调用 Instrumentation 的 execStartActivity() 方法来执行启动操作。
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
// 当前应用的 Binder
IApplicationThread whoThread = (IApplicationThread) contextThread;
Uri referrer = target != null ? target.onProvideReferrer() : null;
if (referrer != null) {
intent.putExtra(Intent.EXTRA_REFERRER, referrer);
}
if (mActivityMonitors != null) {
// ...
}
try {
intent.migrateExtraStreamToClipData();
intent.prepareToLeaveProcess(who);
// 获取 AMS 启动 Activity
int result = ActivityManager.getService()
.startActivity(whoThread, who.getBasePackageName(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
token, target != null ? target.mEmbeddedID : null,
requestCode, 0, null, options);
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
在这个方法中有两个比较关键的地方，一个是 IApplicationThread，它被用来交给 AMS 继续执行启动操作。AMS 通过 ActivityManager.getService()，它用来获取远程的 AMS 的 Binder 来调用。这里的 IApplicationThread 则是当前应用进程的代表，也是一个 Binder. 这样我们可以在当前应用进程中通过 AMS 执行启动操作（实际是在另一个进程完成的）。当启动操作完成了之后，AMS 可以通过当前进程的代表 IApplicationThread 调用本进程的方法来完成启动的后续任务，比如回调各个生命周期方法。
我们先来从整体的角度看一下。如下面的图所示，IApplicationThread 和 AMS 作为两个代表在两个进程之间进行通信。
[图片上传失败...(image-7e4d69-1551002834527)]
在上面的一节中，我们已经说明了在应用进程没有创建的时候是如何创建应用进程的。在创建应用进程的时候，会调用 ActivityThread 的 main 方法来，这个方法中会启动主线程的 Looper 来创建主线程的消息循环，这个 Looper 对应的消息处理的 Handler 就是 H. 以下面的程序为例，当 AMS 或者其他服务需要回调当前进程的方法的时候，可以直接调用下面的方法。其中的 scheduleLowMemory() 方法通过向 H 发送消息来在主线程中执行任务。这里的 scheduleTransaction() 是用来执行 Activity 等生命周期回调的。这里的 ClientTransaction 封装了回调的信息。Activity 的生命周期方法就是通过它来回调的。
private class ApplicationThread extends IApplicationThread.Stub {
@Override
public void scheduleLowMemory() {
sendMessage(H.LOW_MEMORY, null);
}
// ...
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
ActivityThread.this.scheduleTransaction(transaction);
}
}
class H extends Handler {
// ...
public static final int LOW_MEMORY = 124;
// ...
public void handleMessage(Message msg) {
switch (msg.what) {
// ...
case LOW_MEMORY:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "lowMemory");
handleLowMemory();
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
// ...
}
}
}
OK，上面我们分析了 Activity 启动过程中的主要的交互逻辑。下面我们就看下 AMS 在启动的过程中做了上面操作。
当启动过程进入到 AMS 之后，它会进行如下的处理，
public final int startActivityAsUser(/*各种参数*/) {
enforceNotIsolatedCaller("startActivity");
userId = mActivityStartController.checkTargetUser(userId, validateIncomingUser,
Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
return mActivityStartController.obtainStarter(intent, "startActivityAsUser")
.setCaller(caller)
// ... 基于构建者模式进行各种赋值
.execute();
}
它会先通过 UserHandle.getCallingUserId() 获取启动的进程的用户信息，然后用 Binder.getCallingPid() 和 Binder.getCallingUid() 分别获取调用方的进程 ID 和用户 ID. 然后使用 mActivityStartController 检查用户信息是否合法。它内部实际上使用的是 UserController 来进行检查的。当发现用户信息不合法的时候将会抛出一个异常。
然后，它通过 ActivityStartController 的 obtainStarter() 方法获取一个 ActivityStarter，使用构建者模式将启动信息传入之后，调用 execute() 方法执行启动逻辑。然后程序进入 ActivityStarter 的 startActivityMayWait() 方法。该方法中会先对传入的 Intent 的信息进行分析，比如传入的 ACTION_VIEW 等，然后调用 startActivity() 方法继续执行，从该方法中返回结果之后再对结果进行处理。随后，程序进入 startActivityUnchecked() 方法，这个方法主要负责与 Activity 栈相关的逻辑。Activity 的栈在 AMS 中使用 ActivityStack 类来表示，Activity 实例的信息则使用 ActivityRecord 来表示。
private int startActivityUnchecked(/*各种参数*/) {
// ...
int result = START_SUCCESS;
if (mStartActivity.resultTo == null && mInTask == null && !mAddingToTask
&& (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
newTask = true;
// 在新的任务栈中执行任务
result = setTaskFromReuseOrCreateNewTask(taskToAffiliate, topStack);
} else if (mSourceRecord != null) {
result = setTaskFromSourceRecord();
} else if (mInTask != null) {
result = setTaskFromInTask();
} else {
setTaskToCurrentTopOrCreateNewTask();
}
// ...
if (mDoResume) {
final ActivityRecord topTaskActivity =
mStartActivity.getTask().topRunningActivityLocked();
if (!mTargetStack.isFocusable()
|| (topTaskActivity != null && topTaskActivity.mTaskOverlay
&& mStartActivity != topTaskActivity)) {
// ...
} else {
if (mTargetStack.isFocusable() && !mSupervisor.isFocusedStack(mTargetStack)) {
mTargetStack.moveToFront("startActivityUnchecked");
}
// 将新的任务栈移动到前台（聚焦）
mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity, mOptions);
}
} else if (mStartActivity != null) {
mSupervisor.mRecentTasks.add(mStartActivity.getTask());
}
// ...
return START_SUCCESS;
}
startActivityUnchecked() 方法会根据 Activity 启动时指定的栈信息来决定创建新的栈还是在启动它的 Activity 所在的栈中执行。因为我们默认的启动类型时 NEW_TASK，因此我们将进入到 setTaskFromReuseOrCreateNewTask()。然后，新创建的栈将会被 focus，也就相当于移动到前台。这里调用了 ActivityStackSupervisor 的 resumeFocusedStackTopActivityLocked() 方法实现。在该方法中将根据当前的 ActivityRecord 是否已经进入了 RESUMED 状态来进行后续处理，它将调用当前栈的 resumeTopActivityUncheckedLocked() 方法。该方法的主要逻辑是对栈的 Activity 进行处理，因为一个新的 Activity 要加入，那么之前的 Activity 需要调用生命周期的方法，比如 onStop() 等，还要通知 WMS 进行处理。然后程序进入到 ActivityStackSupervisor 的 startSpecificActivityLocked() 方法中执行启动 Activity 真实的罗辑。在新版本的 Android 源码中，它采用如下的方式进行 Activity 的生命周期的回调，
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
boolean andResume, boolean checkConfig) throws RemoteException {
// ...
final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread, r.appToken);
clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
System.identityHashCode(r), r.info,
mergedConfiguration.getGlobalConfiguration(),
mergedConfiguration.getOverrideConfiguration(), r.compat,
r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
r.persistentState, results, newIntents, mService.isNextTransitionForward(),
profilerInfo));
// ...
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
// ...
}
最后当调用了 ClientTransaction 的 schedule() 方法的时候，它通过 IApplicationThread 的 scheduleTransaction() 方法将自身传递给当前应用的进程。当传递到当前进程之后，按照上面我们说的那样回调 Activity 的生命周期即可。
总结
在本文中我们分析了 Android 应用启动的源码。其分成两种情形，一个是应用的进程没有创建的时候，此时要通过 Socket 与服务端的 Socket 建立通信，通过 Zygote 创建当前进程的实例。另一个情形是应用已经启动的过程，此时我们的应用会通过 AMS 调用远程的服务，然后将 IApplicationThread 作为信使传递给 AMS，AMS 通过 IApplicationThread 调用当前应用的方法来回调 Activity 等的生命周期。
以上就是 Android 应用启动过程的源码分析，如有疑问，欢迎评论区交流！
