ActivityThread相关源码分析
前言
先看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）下面进入[email protected]
public static void main(String[] args) {
// 初始化Environment
Environment.initForCurrentUser();
// 初始化Event日志
EventLogger.setReporter(new EventLoggingReporter());
// 根据用户Id创建指定目录
final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
// 将当前线程作为主线程，初始化Looper
Looper.prepareMainLooper();
// 创建ActivityThread
ActivityThread thread = new ActivityThread();
// 如果是System则直接创建Application，如果非System则将ApplicationThread注册到AM中
thread.attach(false);
// 初始化Handler
if (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() {
@Override
public void run() {
ensureJitEnabled();
}
});
android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",
UserHandle.myUserId());
RuntimeInit.setApplicationObject(mAppThread.asBinder());
// 创建应用Application
final 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 {
...
// 绑定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());
...
} catch (Exception e) {
...
}
if (normalMode) {
try {
// 加载Launch Activity
if (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 Acitivity
Activity 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在这之中扮演的角色也比较清晰了。