ActivityThread

ActivityThread 与主线程 Looper 初始化

ActivityThread 是 Android 程序应用的入口。Java 的 main 方法就在此类中。在 main 方法中会初始化主线程的 Looper。并创建了一个 ActivityThread 示例，调用其 attach 方法。最后通过 Looper.loop 方法开启循环读取 MessageQueue 中的消息。如果 MessageQueue 中没有消息，那么 Looper.loop 方法则一直处于阻塞状态。main 的核心代码如下:

publicstaticvoidmain(String[] args) {
// ...Looper.prepareMainLooper();
// 初始化ActivityThreadActivityThreadthread = newActivityThread();
// 调用自身的 attach 方法。thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
Looper.loop();
thrownewRuntimeException("Main thread loop unexpectedly exited");
}

prepareMainLooper 方法会通过 myLooper 初始化主线程的 Looper，主线程 Looper 是一个位于 Looper 内部的静态成员变量 sMainLooper。

publicstaticvoidprepareMainLooper() {
// 初始化 Looper,设置为禁止退出prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
thrownewIllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
privatestaticvoidprepare(booleanquitAllowed) {
if (sThreadLocal.get() != null) {
thrownewRuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(newLooper(quitAllowed));
}
publicstatic@NullableLoopermyLooper() {
returnsThreadLocal.get();
}

关于 Looper 更多知识参考[Handler 实现原理](https://github.com/zhpanvip/AndroidNote/wiki/Handler%E5%AE%9E%E7%8E%B0%E5%8E%9F%E7%90%86)。

ActivityThread 与 Application 的创建

在上一章中，main 方法中会调用 ActivityThread 的构造方法进行初始化，它的构造方法如下：

ActivityThread() {
// 初始化ResourcesManagermResourcesManager = ResourcesManager.getInstance();
}

构造方法初始化了 ResourcesManager 的单利，ResourcesManager 是 APP 的资源管理类，所有的资源文件都是由它来管理的。

接着 main 方法中在 ActivityThread 实例化成功后会调用了自身的 attach 方法，且 attach 方法的参数为 false。attach 方法的核心代码如下：

privatevoidattach(booleansystem) {
sCurrentActivityThread = this;
mSystemThread = system;
if (!system) {
// ...android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",
UserHandle.myUserId());
RuntimeInit.setApplicationObject(mAppThread.asBinder());
finalIActivityManagermgr = ActivityManager.getService();
try {
mgr.attachApplication(mAppThread, startSeq);
} catch (RemoteExceptionex) {
throwex.rethrowFromSystemServer();
}
// Watch for getting close to heap limit.BinderInternal.addGcWatcher(newRunnable() {
@Overridepublicvoidrun() {
if (!mSomeActivitiesChanged) {
return;
}
Runtimeruntime = Runtime.getRuntime();
longdalvikMax = runtime.maxMemory();
longdalvikUsed = runtime.totalMemory() - runtime.freeMemory();
if (dalvikUsed > ((3*dalvikMax)/4)) {
if (DEBUG_MEMORY_TRIM) Slog.d(TAG, "Dalvik max=" + (dalvikMax/1024)
+ " total=" + (runtime.totalMemory()/1024)
+ " used=" + (dalvikUsed/1024));
mSomeActivitiesChanged = false;
try {
ActivityTaskManager.getService().releaseSomeActivities(mAppThread);
} catch (RemoteExceptione) {
throwe.rethrowFromSystemServer();
}
}
}
});
// ...
}
// ...
}

attach 方法中代码可以分为两块：

1. 设置 GC 监听 这块代码比较简单，通过 BinderInternal.addGcWatcher 方法设置了一个 GC 监听。在监听到 GC 发生时，则判断当前虚拟机使用的内存如果大于总内存的3/4，则尝试回收一些 Activity。
2. 获取 system_server 中 ActivityManagerService 的代理 ActivityManagerNative.getDefault() 获取到的是 IActivityManager。IActivityManager 是一个 AIDL 类。代码编译后会生成一个 IActivityManager#Stub 类。在系统源码中由 ActivityManagerService 继承了 IActivityManager#Stub。也就是说 IActivityManager 是一个 Binder 类。可以把它看作是 AMS 在客户端的代理。接着通过 IActivityManager 调用 attachApplication 方法，这是一次跨进程的通信。

// frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.javapublicfinalvoidattachApplication(IApplicationThreadthread, longstartSeq) {
if (thread == null) {
thrownewSecurityException("Invalid application interface");
}
synchronized (this) {
intcallingPid = Binder.getCallingPid();
finalintcallingUid = Binder.getCallingUid();
finallongorigId = Binder.clearCallingIdentity();
attachApplicationLocked(thread, callingPid, callingUid, startSeq);
Binder.restoreCallingIdentity(origId);
}
}

在 attachApplication 中又调用了 attachApplicationLocked 方法：

// frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.javaprivatevoidattachApplicationLocked(@NonNullIApplicationThreadthread,
intpid, intcallingUid, longstartSeq) {
// ...try {
// ...if (app.getIsolatedEntryPoint() != null) {
// This is an isolated process which should just call an entry point instead of// being bound to an application.thread.runIsolatedEntryPoint(
app.getIsolatedEntryPoint(), app.getIsolatedEntryPointArgs());
} else {
// ...thread.bindApplication(
processName,
appInfo,
app.sdkSandboxClientAppVolumeUuid,
app.sdkSandboxClientAppPackage,
isSdkInSandbox,
providerList,
instrumentationName,
profilerInfo,
instrumentationArgs,
instrumentationWatcher,
instrumentationUiConnection,
testMode,
mBinderTransactionTrackingEnabled,
enableTrackAllocation,
isRestrictedBackupMode || !normalMode,
app.isPersistent(),
preBindInfo.configuration,
app.getCompat(),
getCommonServicesLocked(app.isolated),
mCoreSettingsObserver.getCoreSettingsLocked(),
buildSerial,
autofillOptions,
contentCaptureOptions,
app.getDisabledCompatChanges(),
app.getLoggableCompatChanges(),
serializedSystemFontMap,
mApplicationSharedMemoryReadOnlyFd,
app.getStartElapsedTime(),
app.getStartUptime());
}
// ...// See if the top visible activity is waiting to run in this process...if (com.android.server.am.Flags.expediteActivityLaunchOnColdStart()) {
if (normalMode) {
// ActivityTaskManager#LocalService.attachApplicationmAtmInternal.attachApplication(app.getWindowProcessController());
}
}
updateOomAdjLocked(app, OOM_ADJ_REASON_PROCESS_BEGIN);
checkTime(startTime, "attachApplicationLocked: after updateOomAdjLocked");
if (!mConstants.mEnableWaitForFinishAttachApplication) {
finishAttachApplicationInner(startSeq, callingUid, pid);
}
maybeSendBootCompletedLocked(app, isRestrictedBackupMode);
} catch (Exceptione) {
// ...return;
}
}

thread.bindApplication 用于创建 Application，这里的 thread 对象是 ApplicationThread 在 AMS 中的代理对象。这里的bindApplication 方法最终会调用 ApplicationThread.bindApplication 方法，该方法会向 ActivityThread 的消息对应发送BIND_APPLICATION 的消息。消息的处理最终会调用 Application.onCreate 方法，因此 Application 的 onCreate 方法的调用时机比任何Activity 的 onCreate 方法都要早。

publicfinalvoidbindApplication(StringprocessName, ApplicationInfoappInfo,/**... 省略其它参数**/)
// ...// 通过Handler发送 BIND_APPLICATION 的消息。 sendMessage(H.BIND_APPLICATION, data);
}

在ActivityThread的内部类 H（继承Handler）中的 handleMessage 方法中判断如果是 BIND_APPLICATION 类型的消息则会调用了handleBindApplication(data) 方法。如下：

publicvoidhandleMessage(Messagemsg) {
switch (msg.what) {
caseBIND_APPLICATION:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");
AppBindDatadata = (AppBindData)msg.obj;
handleBindApplication(data);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
// ...
}
} 

privatevoidhandleBindApplication(AppBindDatadata) {
// ...// 创建Instrumentationif (data.instrumentationName != null) {
InstrumentationInfoii = null;
mInstrumentation.init(this, instrContext, appContext,
newComponentName(ii.packageName, ii.name), data.instrumentationWatcher,
data.instrumentationUiAutomationConnection);
} else {
mInstrumentation = newInstrumentation();
}
try {
// 创建ApplicationApplicationapp = data.info.makeApplication(data.restrictedBackupMode, null);
mInitialApplication = app;
try {
// 通过Instrumentaion初始化ApplicationmInstrumentation.callApplicationOnCreate(app);
} // ...
} // ...
}

handleBindApplication方法做了简化，这里主要是初始化 Instrumentation，并调用 Instrumentation.callApplicationOnCreate 方法执行 Application 的 onCreate。callApplicationOnCreate 源码如下：

publicvoidcallApplicationOnCreate(Applicationapp) {
app.onCreate();
}

代码很简单，仅仅是调用了Application的onCreate方法，此时，我们项目里边声明的 Application 的 onCreate 方法被调用。

mAtmInternal.attachApplication 用于创建 Activity。实际调用的是 ActivityTaskManager#LocalService.attachApplication。代码如下：

@OverridepublicbooleanattachApplication(WindowProcessControllerwpc) throwsRemoteException {
synchronized (mGlobalLockWithoutBoost) {
if (Trace.isTagEnabled(TRACE_TAG_WINDOW_MANAGER)) {
Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "attachApplication:" + wpc.mName);
}
try {
// frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java returnmRootWindowContainer.attachApplication(wpc);
} finally {
Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
}
}
}

又调用 RootWindowContainer 的 attachApplication：

booleanattachApplication(WindowProcessControllerapp) throwsRemoteException {
app.mHasEverAttached = true;
finalArrayList<ActivityRecord> activities = mService.mStartingProcessActivities;
RemoteExceptionremoteException = null;
booleanhasActivityStarted = false;
for (inti = activities.size() - 1; i >= 0; i--) {
finalActivityRecordr = activities.get(i);
if (app.mUid != r.info.applicationInfo.uid || !app.mName.equals(r.processName)) {
// The attaching process does not match the starting activity.continue;
}
// Consume the pending record.activities.remove(i);
finalTaskFragmenttf = r.getTaskFragment();
if (tf == null || r.finishing || r.app != null// Ignore keyguard because the app may use show-when-locked when creating.
|| !r.shouldBeVisible(true/* ignoringKeyguard */)
|| !r.showToCurrentUser()) {
continue;
}
try {
finalbooleancanResume = r.isFocusable() && r == tf.topRunningActivity();
if (mTaskSupervisor.realStartActivityLocked(r, app, canResume,
true/* checkConfig */)) {
hasActivityStarted = true;
}
} catch (RemoteExceptione) {
Slog.w(TAG, "Exception in new process when starting " + r, e);
remoteException = e;
}
}
if (remoteException != null) {
throwremoteException;
}
returnhasActivityStarted;
}

启动第一个页面的 Activity。

ActivityThread 与 Activity 启动

内容见：Activity 的启动流程#再探客户端的调用流程

参考：WMS添加Window过程]