背景
本章作为Activity 启动过程的最后一章，主要探讨Activity如何在进程中运行起来。
先来回顾一下前面两章的内容。Android Activity启动过程（一） 中，主要描述了从源Activity启动一个应用，启动过程截止到ActivityManagerService，主要包括跨进程通信，调用AMS执行启动请求；Android Activity启动过程（二）主要描述了为了进行Activity管理，AMS中的数据结构，以及AMS对启动请求的处理，直至AMS将启动一个新的进程。本节接着探究，如何运行Activity线程。
使用源码：Nougat - 7.0.0_r1
startActivity（三）
接着上文中Process.start的过程，调用方法为：
Process.start(entryPoint,
app.processName, uid, uid, gids, debugFlags, mountExternal,
app.info.targetSdkVersion, app.info.seinfo, requiredAbi, instructionSet,
app.info.dataDir, entryPointArgs);
其中，entryPoint = "android.app.ActivityThread"，那么，入口实际上就是"android.app.ActivityThread"中的mian方法。
main方法如下：
public static void main(String[] args) {
...
Process.setArgV0("<pre-initialized>");
Looper.prepareMainLooper();
// 创建一个新的ActivityThread
ActivityThread thread = new ActivityThread();
//告知AMS启动完成。这实际又是一个跨进程请求AMS处理的过程。
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
...
//开启消息循环
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
通过 attach 方法，再次通过Binder机制，和AMS通信，请求AMS处理。接着看流程：
下面对主要步骤进行简要说明：
1. 通过binderApplication，将执行Application。也就是说，如果我们为应用中的Application重写了onCreate的声明周期回调，将在这里执行。同时，需要注意，每启动一个进程，Application就会被创建一次，也就是说，我们需要注意如果在自己的应用中，开启了多个进程，注意Application中的响应回调会被多次执行。如果你在Application的onCreate方法中，做了某些初始化动作，默认该初始化会被多次执行。
//ActivityThread 的方法
private void handleBindApplication(AppBindData data) {
...
//创建 Application
Application app = data.info.makeApplication(data.restrictedBackupMode, null);
mInitialApplication = app;
...
// Application 的 onCreate 回调
mInstrumentation.callApplicationOnCreate(app);
...
}
其中，这里对 Application 的创建做一个展开，它的创建，最终是调用 Instrumentation 中的方法
//Instrumentation 的方法
static public Application newApplication(Class<?> clazz, Context context)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException {
Application app = (Application)clazz.newInstance();
//注意，这里传入的实际上是一个 ContextImpl，Context 的实现类；
//Application 是继承自 ContextWrapper 的，但是实际上具体实现却是通过此处传入的 ContextImpl
//同时，attach 是 final 的，不可以 Override，但是它实际上调用的是 attachBaseContext，这个方法是可以 Override 的
//这同时意味着，我们如果要在 Application 中使用 Context 的方法，需要在 attachBaseContext 之后
app.attach(context);
return app;
}
2. 拿到被激活任务栈中置顶的ActivityRecord，通过Binder机制，交给目标进程处理
//ActivityStackSupervisor 中的方法
boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
...
//取出顶部活跃的 ActivityRecord
ActivityRecord hr = stack.topRunningActivityLocked();
...
if (realStartActivityLocked(hr, app, true, true)) {
didSomething = true;
}
...
}
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
boolean andResume, boolean checkConfig) throws RemoteException {
...
//回到 ActivityThread 中处理
app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration),
new Configuration(task.mOverrideConfig), r.compat, r.launchedFromPackage,
task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results,
newIntents, !andResume, mService.isNextTransitionForward(), profilerInfo);
...
}
3. 回到目标进程中，准备在ActivityThread中真正把Activity启动起来
4. 发送消息给Handler H，告知要启动Activity
5. 在这里就熟悉了，我们的 onCreate 将在这里被回调了。
上述过程，首先，我们来看看handleLauchActivity
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
...
//通过反射，创建一个Activity实例，并执行它的onCreate回调
Activity a = performLaunchActivity(r, customIntent);
...
handleResumeActivity(r.token, false, r.isForward,
!r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
...
}
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
...
Activity activity = null;
try {
java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
//通过发射和组件名，获取Activity实例
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
StrictMode.incrementExpectedActivityCount(activity.getClass());
r.intent.setExtrasClassLoader(cl);
r.intent.prepareToEnterProcess();
if (r.state != null) {
r.state.setClassLoader(cl);
}
} catch (Exception e) {
if (!mInstrumentation.onException(activity, e)) {
throw new RuntimeException(
"Unable to instantiate activity " + component
+ ": " + e.toString(), e);
}
}
...
if (r.isPersistable()) {
//onCeate的回调
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
...
}
final void handleResumeActivity(IBinder token,
boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason) {
...
r.window = r.activity.getWindow();
View decor = r.window.getDecorView();
decor.setVisibility(View.INVISIBLE);
ViewManager wm = a.getWindowManager();
WindowManager.LayoutParams l = r.window.getAttributes();
a.mDecor = decor;
l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
l.softInputMode |= forwardBit;
if (r.mPreserveWindow) {
a.mWindowAdded = true;
r.mPreserveWindow = false;
// Normally the ViewRoot sets up callbacks with the Activity
// in addView->ViewRootImpl#setView. If we are instead reusing
// the decor view we have to notify the view root that the
// callbacks may have changed.
ViewRootImpl impl = decor.getViewRootImpl();
if (impl != null) {
impl.notifyChildRebuilt();
}
}
if (a.mVisibleFromClient && !a.mWindowAdded) {
a.mWindowAdded = true;
//和UI部分挂钩了,非常重要的一个步骤，涉及到和wms、sf之间的通信。
wm.addView(decor, l);
}
...
}
到这里，Activity整个启动流程就完成了。本文描述的是一个完整的过程，其他情况，比如 子Activity 的启动过程与此类似，不过是很多东西在 根Activity 启动的时候已经创建好了，在 子Activity 启动的时候直接复用就好了。
小结
通过对 Activity 的启动分析，获取颇多。对于Activity有了较为清晰的认识。同时，对AMS的管理方式、数据结构、运行机制有了更进一步的了解。ActivityThread与AMS之间，存在大量的跨进程通信过程（Binder），CS角色不断变换。
