在Activity启动流程源码分析中我讲了就是普通的启动Activity，但是其实他们的启动过程基本是差不多，要说区别就是启动主Activity是需要创建进程的Application和很多的初始化的操作。
public static void main(String[] args) {
//在当前线程创建Looper，也就是主线程的Looper
Looper.prepareMainLooper();
//c创建ActivityThread
ActivityThread thread = new ActivityThread();
//依附mAppThread给AMS
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
//开始消息循环
Looper.loop();
}
接着看 thread.attach(false);
private void attach(boolean system) {
//依附mAppThread给AMS,也就是把ApplicationThread客户端代理传给了AMS，之后又AMS通过调用AppThread的各种
//scheduleXX方法调度四大组件的生命周期方法
final IActivityManager mgr = ActivityManagerNative.getDefault();
try {
//依附AppThread给AMS，其中ApplicationThread是IApplicationThread的代理类，实际上是调用了AMS的attachApplication
mgr.attachApplication(mAppThread);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
}
//ActivityManagerNative
public abstract class ActivityManagerNative extends Binder implements IActivityManager {
//省略很代码.................
case ATTACH_APPLICATION_TRANSACTION: {
data.enforceInterface(IActivityManager.descriptor);
//拿到ApplicationThread的代理
IApplicationThread app = ApplicationThreadNative.asInterface(
data.readStrongBinder());
if (app != null) {
//调用AMS自己的方法
attachApplication(app);
}
reply.writeNoException();
return true;
}
//省略很代码.................
}
为了简洁我删了很多代码，上面代码知道，首先拿到AMS的服务代理，之后将ApplicationThread作为参数传进去，那肯定会回调ActivityManagerNative的onTransact把ApplicationThread实例传给AMS服务。其实ApplicationThread是Client端的Binder，里面有操作scheduleXX方法处理四大组件的生命周期方法，所以AMS服务想要调用启动组件，那就必须持有ApplicationThread的实例，如调用ApplicationThread的scheduleLaunchActivity方法，最后在scheduleLaunchActivity方法中sendMessage方法发送消息，scheduleLaunchActivity方法代码如下。
//ams最终回调这个方法启动Activity
@Override
public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
ActivityInfo info, Configuration curConfig, Configuration overrideConfig,
CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor,
int procState, Bundle state, PersistableBundle persistentState,
List pendingResults, List pendingNewIntents,
boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) {
ActivityClientRecord r = new ActivityClientRecord();
//此处省略很多代码
//发送消息启动Activity
sendMessage(H.LAUNCH_ACTIVITY, r);
}
上面代码知道系统服务启动Activity并不是发送消息过来的，而是通过调用ApplicationThread的方法来完成这些过程的,ApplicationThread代码如下。
//IApplicationThread
public interface IApplicationThread extends IInterface {
//省略很多代码.................
}
//ApplicationThreadNative
public abstract class ApplicationThreadNative extends Binder implements IApplicationThread {
public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
throws RemoteException {
case SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION:
{
//省略很多代码.................
//实际上是调用了ApplicationThreadNative的子类ApplicationThread，在ActivityThread中定义,反正他仅仅是做和Binder相关的处理，基本的业务交个子类Application处理
scheduleLaunchActivity(intent, b, ident, info, curConfig, overrideConfig, compatInfo,
referrer, voiceInteractor, procState, state, persistentState, ri, pi,
notResumed, isForward, profilerInfo);
return true;
}
//省略很多代码.................
}
}
//ActivityThread.ApplicationThread
//Client端的Binder
private class ApplicationThread extends ApplicationThreadNative {
//省略很多代码.................
public final void schedulePauseActivity(IBinder token, boolean finished,
boolean userLeaving, int configChanges, boolean dontReport) {
int seq = getLifecycleSeq();
if (DEBUG_ORDER) Slog.d(TAG, "pauseActivity " + ActivityThread.this
+ " operation received seq: " + seq);
//发送消息给H类，是以Handler类，ActivityThread.H类
sendMessage(
finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,
token,
(userLeaving ? USER_LEAVING : 0) | (dontReport ? DONT_REPORT : 0),
configChanges,
seq);
}
//省略很多代码.................
}
ApplicationThread是ActivityThread的内部类，它继承了ApplicationThreadNative，而ApplicationThreadNative则继承了Binder类和实现了IApplicationThread接口，足以证明ApplicationThreadNative是Binder类，而ApplicationThreadNative是抽象类它仅仅处理基本的Binder操作，其余的交给的它的子类ApplicationThread。
接着在ActivityThread把ApplicationThread的代理传进AMS中，接着调用MAS的attachApplication方法，代码如下：
@Override
public final void attachApplication(IApplicationThread thread) {
synchronized (this) {
int callingPid = Binder.getCallingPid();
final long origId = Binder.clearCallingIdentity();
attachApplicationLocked(thread, callingPid);
Binder.restoreCallingIdentity(origId);
}
}
这里没什么好说的，就是获取pid，接着调用attachApplicationLocked方法，代码如下：
private final boolean attachApplicationLocked(IApplicationThread thread, int pid) {
//省略很多代码.................
//绑定进程，还会创建Application
thread.bindApplication(processName, appInfo, providers, app.instrumentationClass,
profilerInfo, app.instrumentationArguments, app.instrumentationWatcher,
app.instrumentationUiAutomationConnection, testMode,
mBinderTransactionTrackingEnabled, enableTrackAllocation,
isRestrictedBackupMode || !normalMode, app.persistent,
new Configuration(mConfiguration), app.compat,
getCommonServicesLocked(app.isolated),
mCoreSettingsObserver.getCoreSettingsLocked());
//省略很多代码.................
if (normalMode) {
try {
if (mStackSupervisor.attachApplicationLocked(app)) {
didSomething = true;
}
} catch (Exception e) {
Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
badApp = true;
}
}
}
这里也是省略很多代码，之后回调到ApplicationThread的bindApplication方法，代码如下：
public final void bindApplication(String processName, ApplicationInfo appInfo,
List providers, ComponentName instrumentationName,
ProfilerInfo profilerInfo, Bundle instrumentationArgs,
IInstrumentationWatcher instrumentationWatcher,
IUiAutomationConnection instrumentationUiConnection, int debugMode,
boolean enableBinderTracking, boolean trackAllocation,
boolean isRestrictedBackupMode, boolean persistent, Configuration config,
CompatibilityInfo compatInfo, Map services, Bundle coreSettings) {
if (services != null) {
// Setup the service cache in the ServiceManager
ServiceManager.initServiceCache(services);
}
sendMessage(H.BIND_APPLICATION, data);
}
然后调用handleBindApplication方法，代码如下：
private void handleBindApplication(AppBindData data) {
Application app = data.info.makeApplication(data.restrictedBackupMode, null);
}
可以知道在handleBindApplication中有调用LoadedApk的makeApplication方法创建Application，代码如下：
public Application makeApplication(boolean forceDefaultAppClass,
Instrumentation instrumentation) {
................
//如果app已经存在了，就直接返回
if (mApplication != null) {
return mApplication;
}
............
Application app = null;
......................
try {
java.lang.ClassLoader cl = getClassLoader();
//创建AppConte
ContextImpl appContext = ContextImpl.createAppContex(mActivityThread, this);
//调用Instrumentation的newApplication方法通过反射创建Application，并且调用Applciation的attach方法
app = mActivityThread.mInstrumentation.newApplication(cl, appClass, appContext);
appContext.setOuterContext(app);
} catch (Exception e) {
....................
}
mActivityThread.mAllApplications.add(app);
mApplication = app;
...............
if (instrumentation != null) {
try {
//调用Application的onCreate方法
instrumentation.callApplicationOnCreate(app);
} catch (Exception e) {
.............
}
}
return app;
}
在makeApplication方法中，首先判断app是否已经存在了，存在就直接返回app实例，否则通过调用Instrumentation的newApplication方法，反射创建Application，并且调用Applciation的attach方法反射创建Application，最后在LoadedApk的makeApplication方法中调用instrumentation.callApplicationOnCreate(app)，也就是直接调用app.onCreate()，所以上面讲解了Application启动的过程，所以在回到AMS中的attachApplicationLocked方法。
private final boolean attachApplicationLocked(IApplicationThread thread, int pid) {
//省略很多代码.................
//绑定进程，还会创建Application
thread.bindApplication(processName, appInfo, providers, app.instrumentationClass,
profilerInfo, app.instrumentationArguments, app.instrumentationWatcher,
app.instrumentationUiAutomationConnection, testMode,
mBinderTransactionTrackingEnabled, enableTrackAllocation,
isRestrictedBackupMode || !normalMode, app.persistent,
new Configuration(mConfiguration), app.compat,
getCommonServicesLocked(app.isolated),
mCoreSettingsObserver.getCoreSettingsLocked());
//省略很多代码.................
if (normalMode) {
try {
//注释A
if (mStackSupervisor.attachApplicationLocked(app)) {
didSomething = true;
}
} catch (Exception e) {
Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
badApp = true;
}
}
}
就是当绑定application结束，即bindApplication方法处理完成，最后到注释A的位置调用了ActivityStackSupervisor的attachApplicationLocked方法，代码如下：
boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
final String processName = app.processName;
boolean didSomething = false;
for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
ArrayList stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
final ActivityStack stack = stacks.get(stackNdx);
if (!isFocusedStack(stack)) {
continue;
}
//栈顶activity
ActivityRecord hr = stack.topRunningActivityLocked();
if (hr != null) {
if (hr.app == null && app.uid == hr.info.applicationInfo.uid && processName.equals(hr.processName)) {
try {
if (realStartActivityLocked(hr, app, true, true)) {
didSomething = true;
}
} catch (RemoteException e) {
................
}
}
}
}
}
if (!didSomething) {
ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
}
return didSomething;
}
上面查找栈顶的Activity，最后又ActivityStackSupervisor的realStartActivityLocked方法启动Activity了，代码如下：
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,boolean andResume, boolean checkConfig) throws RemoteException {
...................
//调度ApplicationThread，启动Activity
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);
....................
}
可以看到在ActivityStackSupervisor.realStartActivityLocked方法中，直接就调用ApplicationThread的scheduleLaunchActivity方法，顾名思义，启动Activity。
//ams最终回调这个方法启动Activity
@Override
public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
ActivityInfo info, Configuration curConfig, Configuration overrideConfig,
CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor,
int procState, Bundle state, PersistableBundle persistentState,
List pendingResults, List pendingNewIntents,
boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) {
........................
ActivityClientRecord r = new ActivityClientRecord();
......................
//发送消息启动Activity
sendMessage(H.LAUNCH_ACTIVITY, r);
}
在ApplicationThread.scheduleLaunchActivity方法中有调用sendMessage(H.LAUNCH_ACTIVITY, r)方法，代码如下：
private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
Message msg = Message.obtain();
msg.what = what;
msg.obj = obj;
msg.arg1 = arg1;
msg.arg2 = arg2;
if (async) {
msg.setAsynchronous(true);
}
mH.sendMessage(msg);
}
在sendMessage方法中调用 mH.sendMessage(msg)，其实mH是Handler的子类，发消息到handleMessage方法中，代码如下：
public void handleMessage(Message msg) {
..........
switch (msg.what) {
case LAUNCH_ACTIVITY: {
final ActivityClientRecord r = (ActivityClientRecord) msg.obj;
r.packageInfo = getPackageInfoNoCheck(r.activityInfo.applicationInfo, r.compatInfo);
//最终启动Activity
handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
}
...............
}
在handleMessage方法中有调用ActivityThread的handleLaunchActivity方法去启动Activity，代码如下：
//运行Activity开始的地方，就是Activity的生命周期的开始
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
// 在创建Activity之前初始化，实际上是创建了WMS的代理，即在WindowManagerGlobal管理者WMS
WindowManagerGlobal.initialize();
//处理启动Activity
Activity a = performLaunchActivity(r, customIntent);
........................
if (a != null) {
//执行onResume方法
handleResumeActivity(r.token, false, r.isForward,
!r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
..............
} else {
.................
}
}
之后有调用performLaunchActivity方法，启动Activity，代码如下：
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
ActivityInfo aInfo = r.activityInfo;
................
//解析intent数据
ComponentName component = r.intent.getComponent();
if (component == null) {
component = r.intent.resolveActivity(mInitialApplication.getPackageManager());
r.intent.setComponent(component);
}
if (r.activityInfo.targetActivity != null) {
component = new ComponentName(r.activityInfo.packageName,
r.activityInfo.targetActivity);
}
//通过反射创建Activity实例
Activity activity = null;
try {
java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
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) {
............
}
try {
//创建Application
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
if (activity != null) {
//这里面做创建了PhoneWindow
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 (customIntent != null) {
activity.mIntent = customIntent;
}
r.lastNonConfigurationInstances = null;
//标志activity还未开始
activity.mStartedActivity = false;
//获取主题资源id
int theme = r.activityInfo.getThemeResource();
if (theme != 0) {
//为activity设置主题
activity.setTheme(theme);
}
activity.mCalled = false;
//指示如何在重新启动时保留此activity,以便在“最近”列表中进行还原的值,这里回调onCreate方法，将进行setContentView
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
...........
r.activity = activity;
r.stopped = true;
if (!r.activity.mFinished) {
//执行onStart方法
activity.performStart();
r.stopped = false;
}
if (!r.activity.mFinished) {
//看看有没有持久化的数据，比如由于系统内存紧张而回收activity
if (r.isPersistable()) {
if (r.state != null || r.persistentState != null) {
mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
r.persistentState);
}
} else if (r.state != null) {
mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
}
}
if (!r.activity.mFinished) {
activity.mCalled = false;
if (r.isPersistable()) {
mInstrumentation.callActivityOnPostCreate(activity, r.state,
r.persistentState);
} else {
mInstrumentation.callActivityOnPostCreate(activity, r.state);
}
.................
}
}
r.paused = true;
mActivities.put(r.token, r);
} catch (SuperNotCalledException e) {
throw e;
} catch (Exception e) {
..............
}
return activity;
}
在performLaunchActivity方法中，首先解析intent数据，获取启动Activity的数据，然后调用Instrumentation.newActivity方法通过反射创建Activity实例，接着调用Activity的activity.attach方法，创建PhoneWindow并将PhoneWindow实例依附到WindowManager，接着在performLaunchActivity方法调用Instrumentation.callActivityOnCreate方法间接回调Activity的生命周期方法onCreate，紧接着 activity.performStart()回调Activity的生命周期方法onStart,所以再回到handleLaunchActivity方法中直接调用handleResumeActivity方法去运行Activity，也就是Activity的onResume方法，这里就不展开讲，你只需要知道这里就是Activity运行了就行，因为handleResumeActivity这个下一篇会讲，这里会涉及View的绘制相关的知识，所以暂时不讲。
总结
实际上整个流程由ActivityThread.main方法开始，因为是应用进程为启动，所以需要去创建Applicatio并绑定到ActivityThread也就是主线程，紧接着进程信息初始化完成之后，就进入启动根Activity(Root Activity)，当Activity启动完成之后就开始执行该Activity的生命周期，值得说的是，在Activity.attach方法中，将AppThread依附给AMS，其中ApplicationThread是IApplicationThread的代理类，实际上是调用了AMS的attachApplication方法，并且ApplicationThread是Client的Binder，负责接收AMS调用分别做不同的处理，比如：启动Activity以及Activity的生命周期方法，就是说AMS服务是系统引导服务，系统进程，所以AMS想要通知Client端的做处理，就需要通过Binder做跨进程操作，所以ApplicationThread作为Client端的Binder，是Binder的Service端，AMS远程调用ApplicationThread的方法，然后ApplicationThread通过Activity内部类H发消息去做处理。