在之前的文中，我們已經瞭解過了 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 作為兩個代表在兩個程式之間進行通訊。
在上面的一節中，我們已經說明了在應用程式沒有建立的時候是如何建立應用程式的。在建立應用程式的時候，會呼叫 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 應用啟動過程的原始碼分析，如有疑問，歡迎評論區交流！