前言
AMS 是 Android 中最核心的服务，主要负责系统中四大组件的启动、切换、调度及应用进程的管理和调度等工作。这也是到 Launcher 启动前的最后一个屏障。
一、AMS启动过程
在 SystemServer分析 中得知 SystemServer 会创建 SystemServiceManager 对象来创建和启动系统服务，包括 引导服务、核心服务、其他服务，这里所说的 AMS 即 AndroidManagerService 属于系统服务中的 引导服务。源码如下：
frameworks/base/services/java/com/android/server/SystemServer.java
private void startBootstrapServices() {
......
traceBeginAndSlog("StartActivityManager");
mActivityManagerService = mSystemServiceManager.startService(
ActivityManagerService.Lifecycle.class).getService();
mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
mActivityManagerService.setInstaller(installer);
traceEnd();
......
}
可以看到 SystemServiceManager 调用 startService 函数返回 ActivityManagerService 实例
frameworks/base/services/core/java/com/android/server/SystemServiceManager.java
public void startService(@NonNull final SystemService service) {
// 注释①
mServices.add(service);
// Start it.
long time = SystemClock.elapsedRealtime();
try {
service.onStart(); //注释②
} catch (RuntimeException ex) {
throw new RuntimeException("Failed to start service " + service.getClass().getName()
+ ": onStart threw an exception", ex);
}
warnIfTooLong(SystemClock.elapsedRealtime() - time, service, "onStart");
}
传入的 SystemService 类型的 Service 对象是 ActivityManagerService.Lifecycle.class，在 注释① 处添加到 mServices 集合中完成注册，并在 注释② 处启动服务。
那么这个 Lifecycle.class 又是什么东西呢？Lifecycle 是 AMS 的内部类，源码如下：
public static final class Lifecycle extends SystemService {
private final ActivityManagerService mService;
public Lifecycle(Context context) {
super(context);
// 创建AMS实例
mService = new ActivityManagerService(context);
}
@Override
public void onStart() {
//启动AMS ，
mService.start();
}
public ActivityManagerService getService() {
// 返回AMS实例
return mService;
}
}
二、AMS与应用程序进程
2.1 AMS启动应用程序简述
我们知道在 Zygote 进程中会创建一个 Server端 的 Socket 去等待 AMS 请求 Zygote 来创建新的应用程序进程。在启动应用进程时，AMS 会先检查应用程序所需的程序进程是否存在，不存在就会请求 Zygote 进程去创建。在这里先忽略上层流程，仅仅分析 AMS检测与创建应用进程的过程，以 Service 启动过程为例：
Service 在启动过程最终会调用 ActiveServices 的 bringUpServiceLocked 方法：
frameworks/base/services/core/java/com/android/server/am/ActiveServices.java
private String bringUpServiceLocked(ServiceRecord r, int intentFlags, boolean execInFg,
boolean whileRestarting, boolean permissionsReviewRequired)
throws TransactionTooLargeException {
// 获取 Service 想要在哪个进程运行 注释①
final String procName = r.processName;
String hostingType = "service";
ProcessRecord app;
if (!isolated) {
// 将procName 和 Service 的 uid 传入 AMS 的 getProcessRecordLocked方法
// 查询是否存在 ProcessRecord类型的对象 app
app = mAm.getProcessRecordLocked(procName, r.appInfo.uid, false);
if (DEBUG_MU) Slog.v(TAG_MU, "bringUpServiceLocked: appInfo.uid=" + r.appInfo.uid
+ " app=" + app);
if (app != null && app.thread != null) {
try {
app.addPackage(r.appInfo.packageName, r.appInfo.longVersionCode, mAm.mProcessStats);
//如果所需要的进程存在则 启动 Service 注释②
realStartServiceLocked(r, app, execInFg);
return null;
} catch (TransactionTooLargeException e) {
throw e;
} catch (RemoteException e) {
Slog.w(TAG, "Exception when starting service " + r.shortName, e);
}
}
}
//如果用来运行 Service 的进程不存在
if (app == null && !permissionsReviewRequired) {
//创建应用进程 注释③
if ((app=mAm.startProcessLocked(procName, r.appInfo, true, intentFlags,
hostingType, r.name, false, isolated, false)) == null) {
String msg = "Unable to launch app "
+ r.appInfo.packageName + "/"
+ r.appInfo.uid + " for service "
+ r.intent.getIntent() + ": process is bad";
Slog.w(TAG, msg);
bringDownServiceLocked(r);
return msg;
}
if (isolated) {
r.isolatedProc = app;
}
}
return null;
}
在 注释① 处得到的 ServiceRecord 的 processName 的值并赋值给 procName ，这个 processName 用来描述 Service 想要在哪个进程运行，默认是当前进程。在 注释③ 处，当判断用来运行 Service 的进程不存在时，就会调用 AMS 的 startProcessLocked 方法来进行创建。
2.2 AMS发送启动应用程序进程请求
2.2.1 时序图
2.2.2 connect
Socket 连接成功并匹配 ABI 后返回 ZygoteState 类型对象，在 zygoteSendArgsAndGetResult 方法中，会将应用进程的启动参数 argsForZygote 写入 ZygoteState 中，这样 Zygote 进程就会收到一个创建新的应用程序进程的请求。
/frameworks/base/core/java/android/os/ZygoteProcess.java
private ZygoteState openZygoteSocketIfNeeded(String abi) throws ZygoteStartFailedEx {
Preconditions.checkState(Thread.holdsLock(mLock), "ZygoteProcess lock not held");
if (primaryZygoteState == null || primaryZygoteState.isClosed()) {
try {
// 与 Zygote 进程建立 Socket 连接 注释①
primaryZygoteState = ZygoteState.connect(mSocket);
} catch (IOException ioe) {
throw new ZygoteStartFailedEx("Error connecting to primary zygote", ioe);
}
maybeSetApiBlacklistExemptions(primaryZygoteState, false);
maybeSetHiddenApiAccessLogSampleRate(primaryZygoteState);
}
// 连接Zygote主模式返回的 ZygoteState 是否与启动应用程序进程所需要的ABI匹配 注释②
if (primaryZygoteState.matches(abi)) {
return primaryZygoteState;
}
// 如果不匹配，则尝试连接Zygote辅模式
if (secondaryZygoteState == null || secondaryZygoteState.isClosed()) {
try {
secondaryZygoteState = ZygoteState.connect(mSecondarySocket); // 注释③
} catch (IOException ioe) {
throw new ZygoteStartFailedEx("Error connecting to secondary zygote", ioe);
}
maybeSetApiBlacklistExemptions(secondaryZygoteState, false);
maybeSetHiddenApiAccessLogSampleRate(secondaryZygoteState);
}
// 连接Zygote辅模式返回的ZygoteState是否与启动应用程序进程所需要的ABI匹配 注释④
if (secondaryZygoteState.matches(abi)) {
return secondaryZygoteState;
}
throw new ZygoteStartFailedEx("Unsupported zygote ABI: " + abi);
}
在 Zygote 进程启动过程中知道，在 Zygote 的 main 方法中创建 name 为 “zygote” 的 Server 端 Socket 。在注释① 处会调用 ZygoteState 的 connect 方法与名称为 ZYGOTE_SOCKET 的 Socket 建立连接，这里 ZYGOTE_SOCKET 的值为 zygote，在 注释① 处与 Zygote 进程建立 Socket 连接，并返回 ZygoteState 类型的 primaryZygoteState 对象，在 注释② 处如果 primaryZygoteState 与启动应用程序进程所需要的 ABI 不匹配，则会在 注释③ 处连接 name 为 zygote_secondary 的 Socket ，在之前的分析过程中得知 Zygote 的启动脚本有四种，如果采用的是 init.zygote32_64.rc 或者 init.zygote64_32.rc 则 name 为 "zygote" 的为主模式，name 为 "zygote_secondary" 的为辅模式。
2.3 Zygote 接收请求并创建应用程序进程
Socket 进程通过 fock 自身创建应用程序进程，这样应用程序进程创建过程中会获得 Zygote 进程在启动时创建的虚拟机实例，同时还创建了 Binder 线程池和消息循环，这样运行在应用进程中的应用程序就可以方便的使用 Binder 进行进程间通信。
