1. SystemServer 进程概述
SystemServer 进程主要用于启动系统服务，SystemServer 进程做的几件事：
- 启动 Binder 线程池。
- 创建 SystemServerManager，用于对其他系统服务进行创建、启动和生命周期管理。
- 启动各种系统服务。
本文将基于 android-14.0.0_r9 版本代码对以上内容进行详细讲解。
2. 启动 SystemServer 进程
首先看一下 zygote 进程中 ZygoteInit 的 main 方法：
// com.android.internal.os.ZygoteInit
public static void main(String[] argv) {
...
try {
...
if (startSystemServer) {
// 启动 SystemServer 进程
Runnable r = forkSystemServer(abiList, zygoteSocketName, zygoteServer);
...
}
...
}
...
}
进一步调用了 forkSystemServer 方法创建 SystemServer 进程：
// com.android.internal.os.ZygoteInit
private static Runnable forkSystemServer(String abiList, String socketName,
com.android.internal.os.ZygoteServer zygoteServer) {
...
// 创建 args 数组，用来保存启动 SystemServer 的启动参数
String[] args = {
"--setuid=1000",
"--setgid=1000",
"--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1023,"
+ "1024,1032,1065,3001,3002,3003,3005,3006,3007,3009,3010,3011,3012",
"--capabilities=" + capabilities + "," + capabilities,
"--nice-name=system_server",
"--runtime-args",
"--target-sdk-version=" + VMRuntime.SDK_VERSION_CUR_DEVELOPMENT,
"com.android.server.SystemServer",
};
ZygoteArguments parsedArgs;
int pid;
try {
...
/* Request to fork the system server process */
// 创建子进程 SystemServer
pid = Zygote.forkSystemServer(
parsedArgs.mUid, parsedArgs.mGid,
parsedArgs.mGids,
parsedArgs.mRuntimeFlags,
null,
parsedArgs.mPermittedCapabilities,
parsedArgs.mEffectiveCapabilities);
} catch (IllegalArgumentException ex) {
throw new RuntimeException(ex);
}
// 当前代码运行在子线程中
if (pid == 0) {
if (hasSecondZygote(abiList)) {
waitForSecondaryZygote(socketName);
}
// 关闭 Zygote 进程创建的 Socket
zygoteServer.closeServerSocket();
// 处理 SystemServer 进程
return handleSystemServerProcess(parsedArgs);
}
return null;
}
通过 Zygote 的 forkSystemServer 创建了 SystemServer 进程，该进程复制了 Zygote 进程的地址空间，因此也会得到 Zygote 进程创建的 Socket，该 Socket 对于 SystemServer 进程没用，通过 closeServerSocket 方法关闭。
接着调用 handleSystemServerProcess 方法：
// com.android.internal.os.ZygoteInit
private static Runnable handleSystemServerProcess(ZygoteArguments parsedArgs) {
...
if (parsedArgs.mInvokeWith != null) {
...
} else {
// 创建了 PathClassLoader
ClassLoader cl = getOrCreateSystemServerClassLoader();
if (cl != null) {
Thread.currentThread().setContextClassLoader(cl);
}
// 调用 ZygoteInit 的 zygoteInit 方法
return ZygoteInit.zygoteInit(parsedArgs.mTargetSdkVersion,
parsedArgs.mDisabledCompatChanges,
parsedArgs.mRemainingArgs, cl);
}
/* should never reach here */
}
调用 ZygoteInit 的 zygoteInit 方法：
public static Runnable zygoteInit(int targetSdkVersion, long[] disabledCompatChanges,
String[] argv, ClassLoader classLoader) {
...
// 启动 Binder 线程池，可以使用 Binder 与其他进程进行通信
ZygoteInit.nativeZygoteInit();
// 进入 SystemServer 的 main 方法
return RuntimeInit.applicationInit(targetSdkVersion, disabledCompatChanges, argv,
classLoader);
}
调用 RuntimeInit 的 applicationInit 方法：
// frameworks/base/core/java/com/android/internal/os/RuntimeInit.java
protected static Runnable applicationInit(int targetSdkVersion, long[] disabledCompatChanges,
String[] argv, ClassLoader classLoader) {
...
return findStaticMain(args.startClass, args.startArgs, classLoader);
}
接着调用 findStaticMain 方法：
protected static Runnable findStaticMain(String className, String[] argv,
ClassLoader classLoader) {
Class<?> cl;
try {
// 通过反射得到 SystemServer 类
cl = Class.forName(className, true, classLoader);
}
...
Method m;
try {
// 找到 SystemServer 的 main 方法
m = cl.getMethod("main", new Class[] { String[].class });
}
...
return new MethodAndArgsCaller(m, argv);
}
将 SystemServer 的 main 方法传入 MethodAndArgsCaller 异常中并抛出该异常。在 ZygoteInit 的 main 方法中捕获异常。
findStaticMain 最后会创建一个 MethodAndArgsCaller 对象并将其返回，该对象传入了一个参数 m，此参数为 SystemServer 的 main 方法。经过层层返回，最终在 ZygoteInit 的 main 方法进行了处理，整个过程让 SystemServer 的 main 方法看起来像是 SystemServer 进程的入口方法：
// com.android.internal.os.ZygoteInit
public static void main(String[] argv) {
...
try {
...
if (startSystemServer) {
// 启动 SystemServer 进程
Runnable r = forkSystemServer(abiList, zygoteSocketName, zygoteServer);
if (r != null) {
r.run();
return;
}
}
...
}
...
}
调用 MethodAndArgsCaller 的 run 方法：
// frameworks/base/core/java/com/android/internal/os/RuntimeInit.java
static class MethodAndArgsCaller implements Runnable {
/** method to call */
private final Method mMethod;
/** argument array */
private final String[] mArgs;
public MethodAndArgsCaller(Method method, String[] args) {
mMethod = method;
mArgs = args;
}
public void run() {
try {
mMethod.invoke(null, new Object[] { mArgs });
}
...
}
}
MethodAndArgsCaller 是 RuntimeInit 的静态内部类。通过 invoke 方法，SystemServer 的 main 方法被调用，进入 SystemServer 的 main 方法。
3. 启动 Binder 线程池
在上文的 ZygoteInit 的 zygoteInit 方法中，还通过 nativeZygoteInit 方法启动 Binder 线程池，可以使用 Binder 与其他进程进行通信。
// frameworks/basecore/jni/AndroidRuntime.cpp
int register_com_android_internal_os_ZygoteInit_nativeZygoteInit(JNIEnv* env)
{
const JNINativeMethod methods[] = {
{ "nativeZygoteInit", "()V",
(void*) com_android_internal_os_ZygoteInit_nativeZygoteInit },
};
return jniRegisterNativeMethods(env, "com/android/internal/os/ZygoteInit",
methods, NELEM(methods));
}
通过 AndroidRuntime register_com_android_internal_os_ZygoteInit_nativeZygoteInit 可知 nativeZygoteInit 对应的是 com_android_internal_os_ZygoteInit_nativeZygoteInit 函数：
// frameworks/base/core/jni/AndroidRuntime.cpp
static void com_android_internal_os_ZygoteInit_nativeZygoteInit(JNIEnv* env, jobject clazz)
{
gCurRuntime->onZygoteInit();
}
gCurRuntime 是 AndroidRuntime 类型的指针，具体指向 AndroidRuntime 的子类 AppRuntime，在 app_mian.cpp 中定义：
virtual void onZygoteInit()
{
sp<ProcessState> proc = ProcessState::self();
ALOGV("App process: starting thread pool.\n");
proc->startThreadPool();
}
startThreadPool 启动一个 Binder 线程池，这样 SystemServer 进程就可以使用 Binder 与其他进程进行通信了。
4. SystemServer 进程启动系统服务
由上文可知，通过 invoke 方法，SystemServer 的 main 方法被调用，进入 SystemServer 的 main 方法：
// frameworks/base/services/java/com/android/server/SystemServer.java
public static void main(String[] args) {
new SystemServer().run();
}
调用 SystemServer 的 run 方法：
// frameworks/base/services/java/com/android/server/SystemServer.java
private void run() {
try {
...
// 创建 Looper
Looper.prepareMainLooper();
...
// 加载动态库 libandroid_services.so
System.loadLibrary("android_servers");
// Allow heap / perf profiling.
initZygoteChildHeapProfiling();
...
// 创建系统的 Context
createSystemContext();
...
// Create the system service manager.
mSystemServiceManager = new SystemServiceManager(mSystemContext);
mSystemServiceManager.setStartInfo(mRuntimeRestart,
mRuntimeStartElapsedTime, mRuntimeStartUptime);
mDumper.addDumpable(mSystemServiceManager);
LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
...
} finally {
t.traceEnd(); // InitBeforeStartServices
}
...
try {
t.traceBegin("StartServices");
// 启动引导服务
startBootstrapServices(t);
// 启动核心服务
startCoreServices(t);
// 启动其他服务
startOtherServices(t);
// 启动与 Apex 相关服务
startApexServices(t);
...
}
...
// Loop forever.
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
第17行，创建了 SystemServiceManager，他会对系统服务进行创建、启动和生命周期管理。
startBootstrapServices 方法中启动了 ActivityManagerService、ActivityTaskManagerService、PowerManagerService 等服务，这些服务具有相互依赖关系。
startCoreServices 方法中启动了 DropBoxMangerService、BatteryService、UsageStatsService 和 WebViewUpdateService。
startOtherServices 方法中启动了 CameraService、AlarmManagerService、VrManagerService 等服务。
这些系统的启动逻辑是相似的。
4.1 第一种启动方式
以启动 PowerMangerService 为例：
// frameworks/base/services/java/com/android/server/SystemServer.java
private void startBootstrapServices(@NonNull TimingsTraceAndSlog t) {
...
t.traceBegin("StartPowerStatsService");
// Tracks rail data to be used for power statistics.
mSystemServiceManager.startService(PowerStatsService.class);
t.traceEnd();
...
}
将 PowerStatsService.class 传入 startService 方法：
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;
} finally {
Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
}
}
将 service 传入 startService 方法:
// frameworks/base/services/core/java/com/android/server/SystemServiceManager.java
public void startService(@NonNull final SystemService service) {
// 注册 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");
}
最终调用 service 的 onStart 方法启动服务。
4.2 第二种启动方式
还可以用另一种方式启动系统服务，以 PackageManagerService 为例：
private void startBootstrapServices(@NonNull TimingsTraceAndSlog t) {
mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
domainVerificationService, mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF,
mOnlyCore);
}
直接调用 PackageManagerService 的 main 方法：
public static PackageManagerService main(Context context, Installer installer,
@NonNull DomainVerificationService domainVerificationService, boolean factoryTest,
boolean onlyCore) {
// 自检初始化设置
PackageManagerServiceCompilerMapping.checkProperties();
...
// 创建 PackageService
PackageManagerService m = new PackageManagerService(injector, onlyCore, factoryTest,
Build.FINGERPRINT, Build.IS_ENG, Build.IS_USERDEBUG, Build.VERSION.SDK_INT,
Build.VERSION.INCREMENTAL);
...
// 将 Service 注册到 ServiceManger 中
ServiceManager.addService("package", m);
final PackageManagerNative pmn = m.new PackageManagerNative();
ServiceManager.addService("package_native", pmn);
return m;
}
至此 SystemServer 进程主要流程介绍完毕，在 startOtherServices 中还会启动 Launcher 进程，接下来会对 Launcher 做详细讲解：Android 系统启动过程（四） —— Launcher 启动过程
