ActivityManagerService分析（一）——启动流程
（注：源代码为android-8.1）
0. 前言
前文《Android源码阅读分析：从Activity开始（一）——启动流程》中我简单地讲解了Activity是如何被启动的。其中涉及到了ActivityManagerService。在Android系统中，ActivityManagerService即AMS是管理Android四大组件的核心，其重要性不言而喻。那么，从本篇文章就开始分析AMS的源码，理解其内部的逻辑。
本篇文章主要分析ActivityManagerService的创建和启动逻辑。
1. ActivityManagerService对象的创建
我们要分析一个问题，首先就要从这个问题的源头来分析起。所以，我们先看一下ActivityManagerService是如何被创建起来的。
经过查找，发现ActivityManagerService最初的创建位置在SystemServer的startBootstrapServices方法内。
(frameworks/base/servces/java/com/android/server/SystemServer.java)
private void startBootstrapServices() {
...
// 启动Activity Manager
mActivityManagerService = mSystemServiceManager.startService(ActivityManagerService.Lifecycle.class).getService();
mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
mActivityManagerService.setInstaller(installer);
...
// 为系统进程创建并启动Application实例
mActivityManagerService.setSystemProcess();
...
} 该方法表示通过SystemServiceManager的startService方法，启动Lifecycle后获取服务。然后为系统进程创建并启动Application实例。
Lifecycle是ActivityManagerService的内部静态类。
(frameworks/base/servces/core/java/com/android/server/am/ActivityManagerService.java)
public static final class Lifecycle extends SystemService {
private final ActivityManagerService mService;
public Lifecycle(Context context) {
super(context);
mService = new ActivityManagerService(context);
}
@Override
public void onStart() {
mService.start();
}
@Override
public void onCleanupUser(int userId) {
mService.mBatteryStatsService.onCleanupUser(userId);
}
public ActivityManagerService getService() {
return mService;
}
} 可以看出Lifecycle类的作用，就是在ActivityManagerSerivce与SystemService之间充当适配器的作用。
再回头看一下SystemServiceManager的startService方法做了什么。
(frameworks/base/services/core/java/com/android/server/SystemServiceManager.java)
public <T extends SystemService> T startService(Class<T> serviceClass) {
try {
final String name = serviceClass.getName();
...
final T service;
try {
Constructor<T> constructor = serviceClass.getConstructor(Context.class);
service = constructor.newInstance(mContext);
}
...
startService(service);
return service;
}
...
} 这里通过构造器创建一个SystemService的子类实例，这里即Lifecycle类的实例，再调用startService(SystemService)方法。
在Lifecycle的构造方法中，会根据传入的Context参数创建一个ActivityManagerService对象。那我们看一下ActivityManagerService的构造方法。
(frameworks/base/servces/core/java/com/android/server/am/ActivityManagerService.java)
public ActivityManagerService(Context systemContext) {
...
mInjector = new Injector();
mContext = systemContext;
mFactoryTest = FactoryTest.getMode();
mSystemThread = ActivityThread.currentActivityThread();
mUiContext = mSystemThread.getSystemUiContext();
...
// 创建名为ActivityManagerService的前台线程
mHandlerThread = new ServiceThread(TAG, THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
mHandlerThread.start();
mHandler = new MainHandler(mHandlerThread.getLooper());
// 创建UI线程
mUiHandler = mInjector.getUiHandler(this);
...
// 创建前台广播队列和后台广播队列
mFgBroadcastQueue = new BroadcastQueue(this, mHandler, "foreground", BROADCAST_FG_TIMEOUT, false);
mBgBroadcastQueue = new BroadcastQueue(this, mHandler, "background", BROADCAST_BG_TIMEOUT, true);
mBroadcastQueues[0] = mFgBroadcastQueue;
mBroadcastQueues[1] = mBgBroadcastQueue;
...
// 创建"/data/system"目录
File dataDir = Environment.getDataDirectory();
File systemDir = new File(dataDir, "system");
systemDir.mkdirs();
...
// 所有Activity的启动都要通过mStackSupervisor执行
mStackSupervisor = createStackSupervisor();
...
mActivityStarter = new ActivityStarter(this, mStackSupervisor);
...
mProcessCpuThread = new Thread("CpuTracker") {
@Override
public void run() {
synchronized (mProcessCpuTracker) {
mProcessCpuInitLatch.countDown();
mProcessCpuTracker.init();
}
...
}
}
} ActivityManagerService的构造方法创建了ActivityManagerService线程、UI线程和CpuTracker线程，同时创建了系统目录以及用于创建Activity的StackSupervisor和ActivityStarter。
到这里，ActivityManagerService对象就创建完毕。
2. ActivityManagerService对象创建后操作
下面我们在看一下startService(SystemService)方法。
(frameworks/base/services/core/java/com/android/server/SystemServiceManager.java)
public void startService(@NonNull final SystemService service) {
mServices.add(service);
...
try {
service.onStart();
}
...
} 这个方法主要做了两件事情，一个是注册服务，另一个就是启动服务。而Lifecycle的onStart方法中又会调用ActivityManagerService的start方法，下面跟踪一下该方法。
(frameworks/base/servces/core/java/com/android/server/am/ActivityManagerService.java)
private void start() {
// 删除所有进程组
removeAllProcessGroups();
// 启动CpuTracker线程
mProcessCpuThread.start();
mBatteryStatsService.publish();
mAppOpsService.publish(mContext);
LocalServices.addService(ActivityManagerInternal.class, new LocalService());
try {
mProcessCpuInitLatch.await();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new IllegalStateException("Interrupted wait during start");
}
} 到这里，ActivityManagerService就已经创建起来了。
我们再回到SystemServer的startBootstrapServices方法中，在创建了ActivityManagerService后，又调用了其setSystemProcess方法。
(frameworks/base/servces/core/java/com/android/server/am/ActivityManagerService.java)
public void setSystemProcess() {
try {
ServiceManager.addService(Context.ACTIVITY_SERVICE, this, true);
ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
ServiceManager.addService("meminfo", new MemBinder(this));
ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
ServiceManager.addService("dbinfo", new DbBinder(this));
if (MONITOR_CPU_USAGE) {
ServiceManager.addService("cpuinfo", new CpuBinder(this));
}
ServiceManager.addService("permission", new PermissionController(this));
ServiceManager.addService("processinfo", new ProcessInfoService(this));
ApplicationInfo info = mContext.getPackageManager().getApplicationInfo("android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());
synchronized (this) {
ProcessRecord app = newProcessRecordLocked(info, info.processName, false, 0);
app.persistent = true;
app.pid = MY_PID;
app.maxAdj = ProcessList.SYSTEM_ADJ;
app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
synchronized (mPidsSelfLocked) {
mPidsSelfLocked.put(app.pid, app);
}
updateLruProcessLocked(app, false, null);
updateOomAdjLocked();
}
}
...
} 该方法的主要作用是为系统进程创建并启动Application实例并启动，同时也注册一些服务。
现在我们再回头看一下SystemServer调用startBootstrapServices方法的地方。
(frameworks/base/servces/java/com/android/server/SystemServer.java)
// zygote的主进入点
public static void main(String[] args) {
new SystemServer().run();
}
private void run() {
...
try {
traceBeginAndSlog("StartServices");
startBootstrapServices();
startCoreServices();
startOtherServices();
SystemServerInitThreadPool.shutdown();
}
...
} 在执行了startBootstrapServices方法后，又接着调用了startCoreServices方法和startOtherServices方法。这两个方法用于启动一些在startBootstrapServices方法内没有启动的必要服务和其他各种服务。
(frameworks/base/servces/java/com/android/server/SystemServer.java)
private void startCoreServices() {
...
// 检测应用统计
mActivityManagerService.setUsageStatsManager(LocalServices.getService(UsageStatsManagerInternal.class));
...
}
private void startOtherServices() {
...
mActivityManagerService.installSystemProviders();
...
final Watchdog watchdog = Watchdog.getInstance();
watchdog.init(context, mActivityManagerService);
...
// 通知ActivityManagerService
mActivityManagerService.systemReady(() -> {
...
mSystemServiceManager.startBootPhase(SystemService.PHASE_ACTIVITY_MANAGER_READY);
...
try {
mActivityManagerService.startObservingNativeCrashes();
}
...
try {
startSystemUi(context, windowManagerF);
}
...
// 通知若干系统服务systemReady
...
// 启动Watchdog
Watchdog.getInstance().start();
...
// 通知若干系统服务systemRunning
...
}, BOOT_TIMINGS_TRACE_LOG);
} 这里调用了ActivityManagerService的systemReady方法，其中的Lambda表达式应为Runnable类型。
(frameworks/base/servces/core/java/com/android/server/am/ActivityManagerService.java)
public void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
synchronized(this) {
if (mSystemReady) {
if (goingCallback != null) {
// 执行回调
goingCallback.run();
}
return;
}
mLocalDeviceIdleController = LocalServices.getService(DeviceIdleController.LocalService.class);
mAssistUtils = new AssistUtils(mContext);
mVrController.onSystemReady();
mUserController.onSystemReady();
mRecentTasks.onSystemReadyLocked();
mAppOpsService.systemReady();
mSystemReady = true;
}
...
// 检查需要kill的进程，并执行kill，且不允许重启
ArrayList<ProcessRecord> procsToKill = null;
synchronized(mPidsSelfLocked) {
for (int i=mPidsSelfLocked.size()-1; i>=0; i--) {
ProcessRecord proc = mPidsSelfLocked.valueAt(i);
if (!isAllowedWhileBooting(proc.info)){
if (procsToKill == null) {
procsToKill = new ArrayList<ProcessRecord>();
}
procsToKill.add(proc);
}
}
}
synchronized(this) {
if (procsToKill != null) {
for (int i=procsToKill.size()-1; i>=0; i--) {
ProcessRecord proc = procsToKill.get(i);
removeProcessLocked(proc, true, false, "system update done");
}
}
mProcessesReady = true;
}
...
retrieveSettings();
...
// 执行回调
if (goingCallback != null) goingCallback.run();
...
synchronized (this) {
// 启动持久化进程
startPersistentApps(PackageManager.MATCH_DIRECT_BOOT_AWARE);
...
// 启动桌面Activity
startHomeActivityLocked(currentUserId, "systemReady");
...
try {
// 发送ACTION_USER_STARTED广播
Intent intent = new Intent(Intent.ACTION_USER_STARTED);
intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY | Intent.FLAG_RECEIVER_FOREGROUND);
intent.putExtra(Intent.EXTRA_USER_HANDLE, currentUserId);
broadcastIntentLocked(null, null, intent, null, null, 0, null, null, null, AppOpsManager.OP_NONE, null, false, false, MY_PID, SYSTEM_UID, currentUserId);
// 发送ACTION_USER_STARTING广播
intent = new Intent(Intent.ACTION_USER_STARTING);
intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
intent.putExtra(Intent.EXTRA_USER_HANDLE, currentUserId);
broadcastIntentLocked(null, null, intent, null,
new IIntentReceiver.Stub() {
@Override
public void performReceive(Intent intent, int resultCode, String data, Bundle extras, boolean ordered, boolean sticky, int sendingUser) throws RemoteException {
}
},
0, null, null, new String[] {INTERACT_ACROSS_USERS}, AppOpsManager.OP_NONE, null, true, false, MY_PID, SYSTEM_UID, UserHandle.USER_ALL);
}
...
mStackSupervisor.resumeFocusedStackTopActivityLocked();
...
}
} 该方法可以根据goingCallback.run()的执行时间，分为三个部分。
1. 在goingCallback.run()执行之前的主要操作是通知systemReady和杀掉启动时不被允许的进程。
2. goingCallback.run()方法主要用于启动各种系统服务进程
3. 在goingCallback.run()执行之后的主要操作是启动持久化进程、启动桌面Activity、发布ACTION_USER_STARTED和ACTION_USER_STARTING广播。
3. 总结
本篇文章主要分析ActivityManagerService的创建和启动逻辑。在后续文章中，会对ActivityManangerService的具体使用，对四大组件进行管理，以及内存管理等内容进行分析。
相关文章：
《Android源码阅读分析：ActivityManagerService分析（二）——Activity管理》
