前言

先看ActivityThread相关类图

 

分析核心的类：ActivityThread

各个关键类简介：

      1、ActivityThread（进程内唯一）：负责进程下Application、所有Activity

      2、Instrumentation（进程内唯一）：作为ActivityThread组合部分，负责统一创建Application，创建Activity，管理某一个Activity生命周期。

      3、ApplicationThread（进程内唯一）：作为ActivityThread组合部分，管理整个App的生命周期，例如：通知App进入sleep状态，广播接收，应用退出等一堆App事件的分发。

      4、H（进程内唯一）：作为ActivityThread组合部分，继承于Handler，分发App内部Framework层的所有事件，将异步事件转入主线程。

      5、LoadedApk（进程内唯一）：常用变量名称：packageInfo。所以顾名思义，该类表示包相关的信息，例如：APK数据文件地址、ApplicationInfo（由此可知，LoadedApk含有Application的所有信息）

      6、ActivityClientRecord：新建Activity时会创建，用来持有Activity、ActivityInfo、LoadedApk等和具体Activity有关的信息

      7、ActivityManagerService：管理Activity、Service等活动栈、记录及与C++层交互

      8、ActivityStarter：主要负责Activity的启动，及联系Activity的Stack和Task相关

启动ActivityThread

1）启动入口

      看源码，我们可以发现，ActivityThread的构造器被两个静态方法使用，一个是ActivityThread的main方法，一个是ActivityThread的systemMain方法。

      先看systemMain方法，其由SystemServer的createSystemContext方法调用，同时该方法又被SystemServer的run方法调用。从Android启动源码那篇博客可以知道，run方法为System进程Java端的初始化过程。所以可以看出该方法是专门为SystemServer创建ActivityThread使用的。

      相对的，那么ActivityThread的main方法为普通App进程的启动方式。

2）下面进入main@ActivityThread

public static void main(String[] args) {// 初始化EnvironmentEnvironment.initForCurrentUser();// 初始化Event日志EventLogger.setReporter(new EventLoggingReporter());// 根据用户Id创建指定目录final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());// 将当前线程作为主线程，初始化LooperLooper.prepareMainLooper();// 创建ActivityThreadActivityThread thread = new ActivityThread();// 如果是System则直接创建Application，如果非System则将ApplicationThread注册到AM中thread.attach(false);// 初始化Handlerif (sMainThreadHandler == null) {sMainThreadHandler = thread.getHandler();}// 无限循环中Looper.loop();// 异常终止，注意这里的异常通常是执行不到的，上方loop有异常也不会执行到这里。throw new RuntimeException("Main thread loop unexpectedly exited");
}

      ActivityThread 构造器仅仅new ResourcesManager()；ResourceManager，顾名思义，是我们获取资源的管理类，DisplayMetrics和AssetManager也都是其负责的。

      main方法进入循环前只执行了一个方法：thread.attach(false);而后进入循环，说明了在该方法里面，集合了整个应用进程的生命周期。

3）开启应用App创建，查看thread.attach(false);

private void attach(boolean system) {sCurrentActivityThread = this;mSystemThread = system;if (!system) { // 进入应用创建ViewRootImpl.addFirstDrawHandler(new Runnable() {@Overridepublic void run() {ensureJitEnabled();}});android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",UserHandle.myUserId());RuntimeInit.setApplicationObject(mAppThread.asBinder());// 创建应用Applicationfinal IActivityManager mgr = ActivityManagerNative.getDefault();try {   mgr.attachApplication(mAppThread);} catch (RemoteException ex) {throw ex.rethrowFromSystemServer();}...} else { // 进入SystemServer创建...try {// 创建Activity生命周期管理类mInstrumentation = new Instrumentation();// 创建系统级别的上下文ContextImpl context = ContextImpl.createAppContext(this, getSystemContext().mPackageInfo);// 创建Application，并启动onCreate方法mInitialApplication = context.mPackageInfo.makeApplication(true, null);mInitialApplication.onCreate();} catch (Exception e) {throw new RuntimeException("Unable to instantiate Application():" + e.toString(), e);}}// 记录着系统关键log信息，主要功能用于Debug调试DropBox.setReporter(new DropBoxReporter());// 注册到ViewRootImpl中，监听组件配置信息变化监听ViewRootImpl.addConfigCallback(new ComponentCallbacks2() {...});
}

创建System的Application代码比较明显，但是创建应用Application链路比较长，我们将这里分析下：

attach()中进入应用Application的入口：

final IActivityManager mgr = ActivityManagerNative.getDefault();
try {mgr.attachApplication(mAppThread);
} catch (RemoteException ex) {throw ex.rethrowFromSystemServer();
}

mgr在这里就是ActivityManagerProxy（可以看gDefault这个单例，里面先找到AMS，再利用AMS创建了ActivityManagerProxy），看ActivityManagerProxy里面的attachApplication，这里面执行了：

mRemote.transact(ATTACH_APPLICATION_TRANSACTION, data, reply, 0);

mRemote为创建ActivityManagerProxy时传入的IBinder，也就是AMS。这里执行的就是跨进程了。

通过ATTACH_APPLICATION_TRANSACTION可以确定，处理的代码在AMS的父类ActivityManagerNative中onTransact，

case ATTACH_APPLICATION_TRANSACTION: {data.enforceInterface(IActivityManager.descriptor);IApplicationThread app = ApplicationThreadNative.asInterface(data.readStrongBinder());if (app != null) {attachApplication(app);}reply.writeNoException();return true;
}

4）下一步执行attachApplication(app);这里执行的代码不再是ActivityManagerProxy，而是在AMS中：

@Override
public final void attachApplication(IApplicationThread thread) {synchronized (this) {int callingPid = Binder.getCallingPid();final long origId = Binder.clearCallingIdentity();attachApplicationLocked(thread, callingPid);Binder.restoreCallingIdentity(origId);}
}private final boolean attachApplicationLocked(IApplicationThread thread,int pid) {...try {...// 绑定Applicationthread.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());...} catch (Exception e) {...}if (normalMode) {try {// 加载Launch Activityif (mStackSupervisor.attachApplicationLocked(app)) {didSomething = true;}} catch (Exception e) {Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);badApp = true;}}...return true;
}

看源码，可以发现，创建Application，下一步应该是在这个传入的IApplicationThread的bindApplication方法中执行，从之前的代码中我们可以看到，ActivityThread传入了

mgr.attachApplication(mAppThread);

mAppThread为ApplicationThread，所以，AMS中执行的thread为ApplicationThread的Binder，最终代码我们看ApplicationThread的bindApplication方法。

创建Application

1）查看ApplicationThread的bindApplication方法

public final void bindApplication(String processName, ApplicationInfo appInfo,
List<ProviderInfo> 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<String, IBinder> services, Bundle coreSettings) {...sendMessage(H.BIND_APPLICATION, data);
}

ApplicationThread为ActivityThread的内部类，这里刚好有这么一个方法，同时参数都对应的上，说明我们之前确实没有找错对象。可以看到该方法最终又找到了H这个Handler，进而在主线程中执行了ActivityThread的handleBindApplication();

2）看handleBindApplication：

private void handleBindApplication(AppBindData data) {...try {...Application app = data.info.makeApplication(data.restrictedBackupMode, null);mInitialApplication = app;...try {// 该方法为空，应该是预留方法mInstrumentation.onCreate(data.instrumentationArgs);} catch (Exception e) {...}try {// 开启Application的onCreate方法mInstrumentation.callApplicationOnCreate(app);} catch (Exception e) {...}...} finally {StrictMode.setThreadPolicy(savedPolicy);}
}

到了这里我们的Application已经启动了。

启动Launch Activity

下面分析Activity启动，这里要回到ActivityThread启动的第4步，执行：

1）第一步：m.attachApplicationLocked(app)；

boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {...for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {...try {if (realStartActivityLocked(hr, app, true, true)) {didSomething = true;}} catch (RemoteException e) {...throw e;}...}...return didSomething;
}

2）第二步：StackSupervisor的realStartActivityLocked方法

final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
boolean andResume, boolean checkConfig) throws RemoteException {...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);...
}

通之前的Application一样，这里的thread为ApplicationThread

3）第三步：ApplicationThread的scheduleLaunchActivity

@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<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,
boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) {...sendMessage(H.LAUNCH_ACTIVITY, r);
}

4）第四步：ActivityThread的handleLaunchActivity

private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {...// 初始化窗体WindowManagerGlobal.initialize();// 启动Launch AcitivityActivity a = performLaunchActivity(r, customIntent);if(a != null){...// 将Activity状态置为Resume状态handleResumeActivity(r.token, false, r.isForward,!r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);...}...
}

5）第五步：ActivityThread的performLaunchActivity

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {...Activity activity = null;try {java.lang.ClassLoader cl = r.packageInfo.getClassLoader();// 创建Actiivty实体类activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);...} catch (Exception e) {...}try {// 如果packageinfo中没有Application，则创建新的Application，并onCreate()，否则直接返回Application app = r.packageInfo.makeApplication(false, mInstrumentation);if (activity != null) {// 绑定上下文，Window设置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);// Activity onCreate方法if (r.isPersistable()) {mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);} else {mInstrumentation.callActivityOnCreate(activity, r.state);}// 执行 onStart()方法if (!r.activity.mFinished) {activity.performStart();r.stopped = false;}// 执行状态恢复生命周期if (!r.activity.mFinished) {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);}}...}r.paused = true;mActivities.put(r.token, r);} catch (SuperNotCalledException e) {...}return activity;
}

代码执行完performLaunchActivity，Launch Activity已经进入了onStart。而后回到第四步，进入handleResumeActivity，使Activity进入Resume状态。

至此，我们的Launch Activity已经完成启动，ActivityThread在这之中扮演的角色也比较清晰了。