从源码角度看Android系统SystemServer进程启动过程

copy frome :https://blog.csdn.net/salmon_zhang/article/details/93208135

SystemServer进程是由Zygote进程fork生成，进程名为system_server，主要用于创建系统服务。

备注：本文将结合Android8.0的源码看SystemServer进程的启动过程以及SystemServer进程做了哪些重要工作。

1. SystemServer进程启动的起点
从《从源码角度看Android系统Zygote进程启动过程》一文中可知：Zygote进程启动过程中会调用startSystemServer方法，而startSystemServer函数是system_server进程启动流程的起点。

代码路径：frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

深入到startSystemServer函数中：

private static boolean startSystemServer(String abiList, String socketName, ZygoteServer zygoteServer)
throws Zygote.MethodAndArgsCaller, RuntimeException {

...省略...

//参数准备，args数组中保存启动SystemServer的启动参数
String args[] = { //注释1
"--setuid=1000",
"--setgid=1000",
"--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1023,1032,3001,3002,3003,3006,3007,3009,3010",
"--capabilities=" + capabilities + "," + capabilities,
"--nice-name=system_server",
"--runtime-args",
"com.android.server.SystemServer",
};
ZygoteConnection.Arguments parsedArgs = null;
int pid;
try {
//用于解析参数，生成目标格式
parsedArgs = new ZygoteConnection.Arguments(args); //注释2
ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);

//fork子进程，也是创建SystemServer进程
pid = Zygote.forkSystemServer( //注释3
parsedArgs.uid, parsedArgs.gid,
parsedArgs.gids,
parsedArgs.debugFlags,
null,
parsedArgs.permittedCapabilities,
parsedArgs.effectiveCapabilities);
} catch (IllegalArgumentException ex) {
throw new RuntimeException(ex);
}

//运行在子进程中
if (pid == 0) {
if (hasSecondZygote(abiList)) {
waitForSecondaryZygote(socketName);
}
//关闭zygote原有的socket
zygoteServer.closeServerSocket();
//处理SystemServer进程
handleSystemServerProcess(parsedArgs); //注释4
}
return true;
}
注释解析：

注释1创建args数组，主要用来保存启动SystemServer的启动参数。
其中：

可以看出SystemServer进程的的用户id和用户组id都被设置为了1000，并且拥有用户组1001-1010、1018、1021、1032、3001-3010的权限。

进程名为：system_server

启动的类名为：com.android.server.SystemServer

注释2处将args数组封装成Arguments对象，并给注释3处的forkSystemServer函数调用

注释3处调用Zygote的forkSystemServer方法，其内部会调用nativeForkSystemServer这个Native方法，nativeForkSystemServer会通过fork函数在当前进程创建一个子进程，即SystemServer进程。

注释4处理SystemServer进程

2. 创建SystemServer进程
2.1 forkSystemServer
通过上面的注释3可知：是调用Zygote的forkSystemServer方法去创建SystemServer进程。

代码路径：frameworks/base/core/java/com/android/internal/os/Zygote.java

深入到函数forkSystemServer中：

public static int forkSystemServer(int uid, int gid, int[] gids, int debugFlags,
int[][] rlimits, long permittedCapabilities, long effectiveCapabilities) {
VM_HOOKS.preFork();
// Resets nice priority for zygote process.
resetNicePriority();
//调用natvie方法fork system_server进程
int pid = nativeForkSystemServer(
uid, gid, gids, debugFlags, rlimits, permittedCapabilities, effectiveCapabilities);
if (pid == 0) {
Trace.setTracingEnabled(true);
}
VM_HOOKS.postForkCommon();
return pid;
}

备注：这里继续往下看，需要懂一点JNI原理，这里不做介绍，后续会单独写一篇《JNI学习总结》。

nativeForkSystemServer()方法是在AndroidRuntime.cpp中注册的，通过com_android_internal_os_Zygote.cpp中的register_com_android_internal_os_Zygote()方法建立native方法的映射关系的。

2.2 nativeForkSystemServer
进入到com_android_internal_os_Zygote.cpp中：

代码路径：frameworks/base/core/jni/com_android_internal_os_Zygote.cpp

nativeForkSystemServer方法在JNI层对应的方法是：com_android_internal_os_Zygote_nativeForkSystemServer

深入到函数com_android_internal_os_Zygote_nativeForkSystemServer中：

static jint com_android_internal_os_Zygote_nativeForkSystemServer(
JNIEnv* env, jclass, uid_t uid, gid_t gid, jintArray gids,
jint debug_flags, jobjectArray rlimits, jlong permittedCapabilities,
jlong effectiveCapabilities) {
//fork 子进程
pid_t pid = ForkAndSpecializeCommon(env, uid, gid, gids,
debug_flags, rlimits,
permittedCapabilities, effectiveCapabilities,
MOUNT_EXTERNAL_DEFAULT, NULL, NULL, true, NULL,
NULL, NULL, NULL);
if (pid > 0) {
// zygote进程检测system_server进程是否创建
gSystemServerPid = pid;
int status;
if (waitpid(pid, &status, WNOHANG) == pid) {
ALOGE("System server process %d has died. Restarting Zygote!", pid);
// 当system_server进程死亡后，重启zygote进程
RuntimeAbort(env, __LINE__, "System server process has died. Restarting Zygote!");
}
}
return pid;
}
从上面可知：

1： 调用ForkAndSpecializeCommon()方法fork子进程

2： 当system_server进程死亡后，会重启zygote进程

扩展知识：

在Android5.0以上时，会有两个zygote进程，分别是zygote和zygote64。一般在64位系统中system_server的父进程是zygote64。

在64位系统中，kill system_server、zygote、zygote64三个进程是否重启的关系图如下：

继续深入到ForkAndSpecializeCommon()方法中。

2.3 ForkAndSpecializeCommon
代码路径：frameworks/base/core/jni/com_android_internal_os_Zygote.cpp

深入到ForkAndSpecializeCommon方法中：

static pid_t ForkAndSpecializeCommon(JNIEnv* env, uid_t uid, gid_t gid, jintArray javaGids,
jint debug_flags, jobjectArray javaRlimits,
jlong permittedCapabilities, jlong effectiveCapabilities,
jint mount_external,
jstring java_se_info, jstring java_se_name,
bool is_system_server, jintArray fdsToClose,
jintArray fdsToIgnore,
jstring instructionSet, jstring dataDir) {

//设置子进程的signal信号处理
SetSigChldHandler();

...省略...
//fork 子进程
pid_t pid = fork();
// 进入子进程
if (pid == 0) {

...省略...

//关闭并清除文件描述符
DetachDescriptors(env, fdsToClose);

...省略...

if (!is_system_server) {//如果是非system_server子进程，则创建进程组
int rc = createProcessGroup(uid, getpid());
if (rc != 0) {
if (rc == -EROFS) {
ALOGW("createProcessGroup failed, kernel missing CONFIG_CGROUP_CPUACCT?");
} else {
ALOGE("createProcessGroup(%d, %d) failed: %s", uid, pid, strerror(-rc));
}
}
}
//设置group
SetGids(env, javaGids);
//设置资源limit
SetRLimits(env, javaRlimits);

...省略...
//selinux上下文
rc = selinux_android_setcontext(uid, is_system_server, se_info_c_str, se_name_c_str);
if (rc == -1) {
ALOGE("selinux_android_setcontext(%d, %d, "%s", "%s") failed", uid,
is_system_server, se_info_c_str, se_name_c_str);
RuntimeAbort(env, __LINE__, "selinux_android_setcontext failed");
}
if (se_info_c_str == NULL && is_system_server) {
se_name_c_str = "system_server";
}
if (se_info_c_str != NULL) {
//设置线程名为system_server
SetThreadName(se_name_c_str);
}

delete se_info;
delete se_name;
//设置子进程的signal信号处理函数为默认函数
UnsetSigChldHandler();
//等价于调用zygote.callPostForkChildHooks()
env->CallStaticVoidMethod(gZygoteClass, gCallPostForkChildHooks, debug_flags,
is_system_server, instructionSet);
if (env->ExceptionCheck()) {
RuntimeAbort(env, __LINE__, "Error calling post fork hooks.");
}
} else if (pid > 0) {
//进入父进程（zygote进程）
if (sigprocmask(SIG_UNBLOCK, &sigchld, nullptr) == -1) {
ALOGE("sigprocmask(SIG_SETMASK, { SIGCHLD }) failed: %s", strerror(errno));
RuntimeAbort(env, __LINE__, "Call to sigprocmask(SIG_UNBLOCK, { SIGCHLD }) failed.");
}
}
return pid;
}
}

到这里system_server进程就已经创建成功了。接下来就是system_server进程开始真正工作了。

从前面的startSystemServer()方法中可知：zygote进程在执行forkSystemServer()方法后，即system_server进程创建后，就调用handleSystemServerProcess()方法处理system_server进程真正的工作。

3. SystemServer进程启动后的准备工作
3.1 handleSystemServerProcess
代码路径：frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

深入到handleSystemServerProcess函数中：

private static void handleSystemServerProcess(
ZygoteConnection.Arguments parsedArgs)
throws Zygote.MethodAndArgsCaller {

//设置当前进程名为"system_server"
if (parsedArgs.niceName != null) {
Process.setArgV0(parsedArgs.niceName);
}

final String systemServerClasspath = Os.getenv("SYSTEMSERVERCLASSPATH");
if (systemServerClasspath != null) {
//执行dex优化操作
performSystemServerDexOpt(systemServerClasspath); //注释1

...省略...
}

if (parsedArgs.invokeWith != null) {
String[] args = parsedArgs.remainingArgs;
if (systemServerClasspath != null) {
String[] amendedArgs = new String[args.length + 2];
amendedArgs[0] = "-cp";
amendedArgs[1] = systemServerClasspath;
System.arraycopy(args, 0, amendedArgs, 2, args.length);
args = amendedArgs;
}
//启动应用进程
WrapperInit.execApplication(parsedArgs.invokeWith,
parsedArgs.niceName, parsedArgs.targetSdkVersion,
VMRuntime.getCurrentInstructionSet(), null, args);
} else {
ClassLoader cl = null;
if (systemServerClasspath != null) {
cl = createPathClassLoader(systemServerClasspath, parsedArgs.targetSdkVersion); //注释2
Thread.currentThread().setContextClassLoader(cl);
}
ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl); //注释3
}

/* should never reach here */
}

注释解析：

注释1处执行dex优化操作

注释2处创建类加载器，并赋予给当前线程

注释3处调用 ZygoteInit的zygoteInit的方法

3.2 performSystemServerDexOpt
深入跟踪执行dex优化操作的逻辑。

代码路径：frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

深入到performSystemServerDexOpt函数中：

private static void performSystemServerDexOpt(String classPath) {
final String[] classPathElements = classPath.split(":");
//通过AIDL与installd建立连接
final IInstalld installd = IInstalld.Stub
.asInterface(ServiceManager.getService("installd"));
final String instructionSet = VMRuntime.getRuntime().vmInstructionSet();

String sharedLibraries = "";
for (String classPathElement : classPathElements) {

...省略...

if (dexoptNeeded != DexFile.NO_DEXOPT_NEEDED) {

...省略...

try {
//执行dex文件
installd.dexopt(classPathElement, Process.SYSTEM_UID, packageName,
instructionSet, dexoptNeeded, outputPath, dexFlags, compilerFilter,
uuid, sharedLibraries, seInfo);
} catch (RemoteException | ServiceSpecificException e) {
Log.w(TAG, "Failed compiling classpath element for system server: "
+ classPathElement, e);
}
}

if (!sharedLibraries.isEmpty()) {
sharedLibraries += ":";
}
sharedLibraries += classPathElement;
}
}

上面主要的操作就是将classPath字符串中的apk分别进行dex优化。而真正执行优化的工作是通过AIDL通信将命令参数传给installd来完成。

3.3 zygoteInit
深入跟踪上面3.1中注释3处的zygoteInit方法

代码路径：frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

深入到zygoteInit函数中：

public static final void zygoteInit(int targetSdkVersion, String[] argv,
ClassLoader classLoader) throws Zygote.MethodAndArgsCaller {
if (RuntimeInit.DEBUG) {
Slog.d(RuntimeInit.TAG, "RuntimeInit: Starting application from zygote");
}

Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ZygoteInit");
//重定向log输出
RuntimeInit.redirectLogStreams();
//初始化通用信息
RuntimeInit.commonInit();
//zygote初始化
ZygoteInit.nativeZygoteInit(); //注释1
//进入SystemServer的main方法
RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader); //注释2
}
注释解析：

注释1处调用Native层的代码，主要用来启动Binder线程池，从而SystemServer进程就可以使用Binder与其它进程进行通信。

注释2处是用于进入SystemServer的main方法

下面继续跟踪注释1和注释2的源码。

3.4 nativeZygoteInit
nativeZygoteInit是一个Native方法，在AndroidRuntime.cpp中，进行了jni映射。

代码路径：frameworks/base/core/jni/AndroidRuntime.cpp

int register_com_android_internal_os_ZygoteInit(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));
}

从上面可知：nativeZygoteInit()方法对应的是JNI文件AndroidRuntime.cpp中的com_android_internal_os_ZygoteInit_nativeZygoteInit函数：

static void com_android_internal_os_ZygoteInit_nativeZygoteInit(JNIEnv* env, jobject clazz)
{
gCurRuntime->onZygoteInit();
}

其中：gCurRuntime是AndroidRuntime类型的指针，具体指向的是AndroidRuntime的子类AppRuntime，而AppRuntime又是定义在app_main.cpp中的内部类。

故深入到app_main.cpp的内部类AppRuntime的onZygoteInit方法：

virtual void onZygoteInit()
{
sp<ProcessState> proc = ProcessState::self();
ALOGV("App process: starting thread pool. ");
proc->startThreadPool(); //注释1
}

注释解析：

注释1处启动了一个Binder线程池，这样SystemServer进程就可以使用Binder与其它进程进行通信了。
3.5 applicationInit
代码路径：frameworks/base/core/java/com/android/internal/os/RuntimeInit.java

深入到applicationInit函数中：

protected static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
throws Zygote.MethodAndArgsCaller {

//true代表应用程序退出时不调用AppRuntime.onExit()，否则会在退出前调用
nativeSetExitWithoutCleanup(true);

//设置虚拟机的内存利用率参数值为0.75
VMRuntime.getRuntime().setTargetHeapUtilization(0.75f);
VMRuntime.getRuntime().setTargetSdkVersion(targetSdkVersion);

final Arguments args;
try {
//解析参数
args = new Arguments(argv);
} catch (IllegalArgumentException ex) {
Slog.e(TAG, ex.getMessage());
return;
}

Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);

//继续调用invokeStaticMain方法
invokeStaticMain(args.startClass, args.startArgs, classLoader);
}

继续深入到invokeStaticMain方法中。

3.6 invokeStaticMain
代码路径：frameworks/base/core/java/com/android/internal/os/RuntimeInit.java

深入到invokeStaticMain函数中：

private static void invokeStaticMain(String className, String[] argv, ClassLoader classLoader)
throws Zygote.MethodAndArgsCaller {
Class<?> cl;

try {
//通过反射得到SystemServer类
cl = Class.forName(className, true, classLoader); //注释1
} catch (ClassNotFoundException ex) {
throw new RuntimeException(
"Missing class when invoking static main " + className,
ex);
}

Method m;
try {
//找到SystemServer的main方法
m = cl.getMethod("main", new Class[] { String[].class }); //注释2
} catch (NoSuchMethodException ex) {
throw new RuntimeException(
"Missing static main on " + className, ex);
} catch (SecurityException ex) {
throw new RuntimeException(
"Problem getting static main on " + className, ex);
}

int modifiers = m.getModifiers();
if (! (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))) {
throw new RuntimeException(
"Main method is not public and static on " + className);
}
//通过抛出异常，回到ZygoteInit.main()。这样做好处是能清空栈帧，提高栈帧利用率
throw new Zygote.MethodAndArgsCaller(m, argv); //注释3
}

注释解析：

注释1处的className为com.android.server.SystemServer，通过反射机制可以得到SystemServer类

注释2处找到SystemServer中的main方法

注释3处将找到的main方法传入到MethodAndArgsCaller异常中并抛出该异常，而捕获MethodAndArgsCaller异常的代码在ZygoteInit.java的main方法中，而这个方法又会调用SystemServer的main方法。

疑问：为什么不在invokeStaticMain中直接调用SystemServer的main方法呢？

因为：

这种抛出异常的处理会清除所有的设置过程需要的堆栈帧，提高了栈帧利用率。

让SystemServer的main方法看起来像是SystemServer进程的入口方法。

备注：其实在Zygote启动了SystemServer进程后，在调用SystemServer的main方法之前，已经做了很多准备工作，从而使得SystemServer的main方法不像是SystemServer进程的入口方法，而通过抛出异常交由ZygoteInit.java的main方法来处理，会让SystemServer的main方法看起来像是SystemServer进程的入口方法。

下面继续看ZygoteInit.java的main方法是如何捕获MethodAndArgsCaller异常：

3.7 ZygoteInit.java中捕获MethodAndArgsCaller异常
代码路径：frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

深入到捕获MethodAndArgsCaller异常的地方：

public static void main(String argv[]) {

...省略...

zygoteServer.closeServerSocket();
} catch (Zygote.MethodAndArgsCaller caller) { // 捕获MethodAndArgsCaller异常
caller.run();
} catch (Throwable ex) {
Log.e(TAG, "System zygote died with exception", ex);
zygoteServer.closeServerSocket();
throw ex;
}
}

从捕获MethodAndArgsCaller异常的地方可知，当捕获到MethodAndArgsCaller异常时，会调用Zygote.java中的静态内部类MethodAndArgsCaller

3.8 Zygote.java中的静态内部类MethodAndArgsCaller
代码路径：frameworks/base/core/java/com/android/internal/os/Zygote.java

深入到静态内部类MethodAndArgsCaller中：

public static class MethodAndArgsCaller extends Exception
implements Runnable {
private final Method mMethod;

private final String[] mArgs;

public MethodAndArgsCaller(Method method, String[] args) {
mMethod = method;
mArgs = args;
}

public void run() {
try {
//根据传递过来的参数，可知此处通过反射机制调用的是SystemServer.main()方法
mMethod.invoke(null, new Object[] { mArgs }); //注释1
} catch (IllegalAccessException ex) {
throw new RuntimeException(ex);
} catch (InvocationTargetException ex) {
Throwable cause = ex.getCause();
if (cause instanceof RuntimeException) {
throw (RuntimeException) cause;
} else if (cause instanceof Error) {
throw (Error) cause;
}
throw new RuntimeException(ex);
}
}
}

注释解析：

注释1处的mMethod指的就是SystemServer的main方法。
到此为止SystemServer的main方法就调用了，下面正式进入到SystemServer的main方法中。

3.9 SystemServer进程时序图和函数调用流程图
结合上面的源码跟踪分析，下面给出Zygote进程处理SystemServer进程时序图和启动流程图。

时序图：

启动流程图：

4. SystemServer进程启动后的核心工作
下面进入到SystemServer的main方法。

代码路径：frameworks/base/services/java/com/android/server/SystemServer.java

深入到main方法中：

public static void main(String[] args) {
//初始SystemServer对象，再调用run方法
new SystemServer().run();
}

可以看到main方法中只调用了SystemServer的run方法。

run方法如下：

private void run() {
try {
traceBeginAndSlog("InitBeforeStartServices");
//当系统时间比1970年更早，就设置当前系统时间为1970年
if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {
Slog.w(TAG, "System clock is before 1970; setting to 1970.");
SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);
}

//如果没有设置时区属性，则默认为GMT
String timezoneProperty = SystemProperties.get("persist.sys.timezone");
if (timezoneProperty == null || timezoneProperty.isEmpty()) {
Slog.w(TAG, "Timezone not set; setting to GMT.");
SystemProperties.set("persist.sys.timezone", "GMT");
}

...省略...

//设置虚拟机的库文件，在Android6.0上用的是libart.so
SystemProperties.set("persist.sys.dalvik.vm.lib.2", VMRuntime.getRuntime().vmLibrary());

...省略...

//清除vm内存增长上限，由于启动过程需要较多的虚拟机内存空间
VMRuntime.getRuntime().clearGrowthLimit();

//设置内存的可能有效使用率为0.8
VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);

//针对部分设备依赖于运行时就产生指纹信息，因此需要在开机完成前已经定义
Build.ensureFingerprintProperty();

//访问环境变量前，需要明确地指定用户
Environment.setUserRequired(true);

//在系统服务器中，应该对任何传入的bundle进行解压缩，以避免抛出BadParcelableException
BaseBundle.setShouldDefuse(true);

//确保当前系统进程的binder调用，总是运行在前台优先级
BinderInternal.disableBackgroundScheduling(true);

//增加system_server中binder线程的数量
BinderInternal.setMaxThreads(sMaxBinderThreads);

//为主looper thread做准备
android.os.Process.setThreadPriority(
android.os.Process.THREAD_PRIORITY_FOREGROUND);
android.os.Process.setCanSelfBackground(false);
//创建消息Looper
Looper.prepareMainLooper();

//加载android_servers.so库，该库包含的源码在frameworks/base/services/目录下
System.loadLibrary("android_servers");

//检测上次关机过程是否失败，该方法可能不会返回
performPendingShutdown(); //注释1

//初始化系统上下文
createSystemContext(); //注释2

//创建系统服务管理
mSystemServiceManager = new SystemServiceManager(mSystemContext); //注释3
mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
//将mSystemServiceManager添加到本地服务的成员sLocalServiceObjects
LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
//为可以并行化的init任务准备线程池
SystemServerInitThreadPool.get();
} finally {
traceEnd(); // InitBeforeStartServices
}

// Start services.
try {
traceBeginAndSlog("StartServices");
//启动引导服务
startBootstrapServices(); //注释4
//启动核心服务
startCoreServices(); //注释5
//启动其他服务
startOtherServices(); //注释6
SystemServerInitThreadPool.shutdown();
} catch (Throwable ex) {
Slog.e("System", "******************************************");
Slog.e("System", "************ Failure starting system services", ex);
throw ex;
} finally {
traceEnd();
}

//用于debug版本，将log事件不断循环地输出到dropbox（用于分析）
if (StrictMode.conditionallyEnableDebugLogging()) {
Slog.i(TAG, "Enabled StrictMode for system server main thread.");
}
if (!mRuntimeRestart && !isFirstBootOrUpgrade()) {
int uptimeMillis = (int) SystemClock.elapsedRealtime();
MetricsLogger.histogram(null, "boot_system_server_ready", uptimeMillis);
final int MAX_UPTIME_MILLIS = 60 * 1000;
if (uptimeMillis > MAX_UPTIME_MILLIS) {
Slog.wtf(SYSTEM_SERVER_TIMING_TAG,
"SystemServer init took too long. uptimeMillis=" + uptimeMillis);
}
}

//一直循环执行
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}

注释解析：

注释1处检查上次关机是否失败

注释2处创建系统上下文

注释3处创建SystemServiceManager，它会对系统服务进行创建、启动和生命周期管理

注释4处启动系统中的引导服务

注释5处启动系统中的核心服务

注释6处启动系统中的其它服务

下面分别对注释1-6对应的源码进行跟踪查阅。

4.1 performPendingShutdown
代码路径：frameworks/base/services/java/com/android/server/SystemServer.java

深入到performPendingShutdown函数中：

private void performPendingShutdown() {
final String shutdownAction = SystemProperties.get(
ShutdownThread.SHUTDOWN_ACTION_PROPERTY, "");
if (shutdownAction != null && shutdownAction.length() > 0) {
boolean reboot = (shutdownAction.charAt(0) == '1');

final String reason;
if (shutdownAction.length() > 1) {
reason = shutdownAction.substring(1, shutdownAction.length());
} else {
reason = null;
}
if (reason != null && reason.startsWith(PowerManager.REBOOT_RECOVERY_UPDATE)) {
File packageFile = new File(UNCRYPT_PACKAGE_FILE);
if (packageFile.exists()) {
String filename = null;
try {
filename = FileUtils.readTextFile(packageFile, 0, null);
} catch (IOException e) {
Slog.e(TAG, "Error reading uncrypt package file", e);
}

if (filename != null && filename.startsWith("/data")) {
if (!new File(BLOCK_MAP_FILE).exists()) {
Slog.e(TAG, "Can't find block map file, uncrypt failed or " +
"unexpected runtime restart?");
return;
}
}
}
}
//当"sys.shutdown.requested"值不为空,则会重启或者关机
ShutdownThread.rebootOrShutdown(null, reboot, reason);
}
}
4.2 createSystemContext
代码路径：frameworks/base/services/java/com/android/server/SystemServer.java

深入到createSystemContext函数中：

private void createSystemContext() {
//创建system_server进程的上下文信息
ActivityThread activityThread = ActivityThread.systemMain();
mSystemContext = activityThread.getSystemContext();
//设置主题
mSystemContext.setTheme(DEFAULT_SYSTEM_THEME);

//创建SystemUi的上下文信息并设置主题
final Context systemUiContext = activityThread.getSystemUiContext();
systemUiContext.setTheme(DEFAULT_SYSTEM_THEME);
}

4.3 SystemServiceManager启动Service
代码路径：frameworks/base/services/core/java/com/android/server/SystemServiceManager.java

系统服务启动的逻辑都是相似的，这里以PowerManagerService来举例，启动代码如下：

mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);
1
深入到SystemServiceManager的startService函数中：

public void startService(@NonNull final SystemService service) {
//注册Service
mServices.add(service); //注释1
long time = System.currentTimeMillis();
try {
//启动Service
service.onStart();
} catch (RuntimeException ex) {
throw new RuntimeException("Failed to start service " + service.getClass().getName()
+ ": onStart threw an exception", ex);
}
warnIfTooLong(System.currentTimeMillis() - time, service, "onStart");
}

除了调用SystemServiceManager的startService函数来启动系统服务外，也可以通过如下形式来启动系统服务，以PackageManagerServcie为例：

mPackageManagerService = PackageManagerServcie.main(mSystemContext,intaller,mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF,mOnlyCore);
1
直接调用了PackageManagerServcie的main方法。

代码路径：frameworks/base/services/core/java/com/android/server/pm/PackageManagerService.java

深入到PackageManagerServcie的main方法中：

public static PackageManagerService main(Context context, Installer installer,
boolean factoryTest, boolean onlyCore) {
//自检初始的设置
PackageManagerServiceCompilerMapping.checkProperties();
PackageManagerService m = new PackageManagerService(context, installer,
factoryTest, onlyCore); //注释1
m.enableSystemUserPackages();
ServiceManager.addService("package", m); //注释2
return m;
}

注释解析：

注释1处创建一个PackageManagerService对象

注释2处将创建的PackageManagerService对象注册到ServiceManager中

ServiceManager是用来管理系统中的各种Service，用于系统C/S架构中的Binder通信机制：Client端要使用某个Service，需要先到ServiceManager中查下Service的相关信息，然后根据Service的相关信息与Service所在的Server进程建立通信，这样Client就可以使用Service了。

4.4 startBootstrapServices
代码路径：frameworks/base/services/java/com/android/server/SystemServer.java

深入到startBootstrapServices函数中：

private void startBootstrapServices() {

...省略...
//阻塞等待与installd建立socket通道
Installer installer = mSystemServiceManager.startService(Installer.class);

...省略...
//在activity manager之前注册DeviceIdentifiersPolicyService
mSystemServiceManager.startService(DeviceIdentifiersPolicyService.class);

...省略...
//启动服务ActivityManagerService
mActivityManagerService = mSystemServiceManager.startService(
ActivityManagerService.Lifecycle.class).getService();
mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
mActivityManagerService.setInstaller(installer);

...省略...
//启动服务PowerManagerService
mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);

...省略...
//初始化PowerManagement
mActivityManagerService.initPowerManagement();

...省略...
//启动服务LightsService
mSystemServiceManager.startService(LightsService.class);

...省略...
//启动服务DisplayManagerService
mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);

...省略...
//Phase100: 在初始化package manager之前，需要默认的显示
mSystemServiceManager.startBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);

//当设备正在加密时，仅运行核心
String cryptState = SystemProperties.get("vold.decrypt");
if (ENCRYPTING_STATE.equals(cryptState)) {
Slog.w(TAG, "Detected encryption in progress - only parsing core apps");
mOnlyCore = true;
} else if (ENCRYPTED_STATE.equals(cryptState)) {
Slog.w(TAG, "Device encrypted - only parsing core apps");
mOnlyCore = true;
}...省略...

//启动服务PackageManagerService
mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
mFirstBoot = mPackageManagerService.isFirstBoot();
mPackageManager = mSystemContext.getPackageManager();

...省略...
//启动服务UserManagerService
mSystemServiceManager.startService(UserManagerService.LifeCycle.class);

//设置AMS
mActivityManagerService.setSystemProcess();

...省略...
//启动服务OverlayManagerService
mSystemServiceManager.startService(new OverlayManagerService(mSystemContext, installer));

mSensorServiceStart = SystemServerInitThreadPool.get().submit(() -> {
BootTimingsTraceLog traceLog = new BootTimingsTraceLog(
SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
traceLog.traceBegin(START_SENSOR_SERVICE);
//启动传感器服务
startSensorService();
traceLog.traceEnd();
}, START_SENSOR_SERVICE);
}


综上所述：该方法启动的引导服务有：ActivityManagerService、PowerManagerService、LightsService、DisplayManagerService、PackageManagerService、UserManagerService、OverlayManagerService和SensorService。

4.5 startCoreServices
代码路径：frameworks/base/services/java/com/android/server/SystemServer.java

深入到startCoreServices函数中：

private void startCoreServices() {
//启动服务DropBoxManagerService，用于生成和管理系统运行时的一些日志文件
mSystemServiceManager.startService(DropBoxManagerService.class);

//启动服务BatteryService，用于统计电池电量，需要LightService
mSystemServiceManager.startService(BatteryService.class);

//启动服务UsageStatsService，用于统计应用使用情况
mSystemServiceManager.startService(UsageStatsService.class);
mActivityManagerService.setUsageStatsManager(
LocalServices.getService(UsageStatsManagerInternal.class));

//启动服务WebViewUpdateService，用于WebView更新服务
mWebViewUpdateService = mSystemServiceManager.startService(WebViewUpdateService.class);
}

综上所述：该方法启动的核心服务有：DropBoxManagerService、BatteryService、UsageStatsService和WebViewUpdateService。

4.6 startOtherServices
代码路径：frameworks/base/services/java/com/android/server/SystemServer.java

深入到startOtherServices函数中：

private void startOtherServices() {

...省略...

mContentResolver = context.getContentResolver(); //resolver

...省略...
mActivityManagerService.installSystemProviders(); //provider

...省略...
//启动服务AlarmManagerService
mSystemServiceManager.startService(AlarmManagerService.class);

//初始化watchdog
watchdog.init(context, mActivityManagerService);

...省略...
inputManager = new InputManagerService(context); //input

//启动WindowManagerService
wm = WindowManagerService.main(context, inputManager,
mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL,
!mFirstBoot, mOnlyCore, new PhoneWindowManager());
ServiceManager.addService(Context.WINDOW_SERVICE, wm);
ServiceManager.addService(Context.INPUT_SERVICE, inputManager);

SystemServerInitThreadPool.get().submit(() -> {
traceBeginAndSlog(START_HIDL_SERVICES);
//启动服务startHidlServices
startHidlServices();
traceEnd();
}, START_HIDL_SERVICES);

if (!disableVrManager) {
traceBeginAndSlog("StartVrManagerService");
//启动服务VrManagerService
mSystemServiceManager.startService(VrManagerService.class);
traceEnd();
}

...省略...
//启动服务IpConnectivityMetrics
mSystemServiceManager.startService(IpConnectivityMetrics.class);

//启动服务PinnerService
mSystemServiceManager.startService(PinnerService.class);
traceEnd();
} catch (RuntimeException e) {
Slog.e("System", "******************************************");
Slog.e("System", "************ Failure starting core service", e);
}

...省略...

//准备好vibrator、lockSettings、window、power、package、display等服务
vibrator.systemReady();
lockSettings.systemReady();
wm.systemReady();
mPowerManagerService.systemReady(mActivityManagerService.getAppOpsService());
mPackageManagerService.systemReady();
mDisplayManagerService.systemReady(safeMode, mOnlyCore);

...省略...
}

该方法启动了一些非紧要和不需要立即启动的服务。

5. Android系统部分服务及其作用
在system_server进程启动中，将系统服务分为三大类：引导服务、核心服务和其他服务。下面简单的罗列下Android系统中常见的服务及其作用。

引导服务

Installer ：系统安装APK时的一个服务类，启动完成Installer服务之后才能启动其他的系统服务

ActivityManagerService ：负责四大组件的启动、切换、调度

PowerManagerService ：计算系统中与Power相关的计算，然后决策系统应该如何反应

LightsService ：管理和显示背光LED

DisplayManagerService ：用来管理所有显示设备

UserManagerService ：多用户模式管理

SensorService ：为系统提供各种感应器服务

PackageManagerService ：对apk进行安装、解析、删除、卸载等操作

…and so on …

核心服务

DropBoxManagerService ：用于生成和管理系统运行时的一些日志文件

BatteryService : 管理电池相关的服务

UsageStatsService : 收集用户使用每一个App的频率、使用时长

WebViewUpdateService :WebView更新服务

其他服务

CameraService :摄像头相关服务

AlarmManagerService : 全局定时器管理服务

InputManagerService : 管理输入事件

WindowManagerService :窗口管理服务

VrManagerService : VR模式管理服务

BluetoothService ： 蓝牙管理服务

NotificationManagerService : 通知管理服务

DeviceStorageMonitorService : 存储相关管理服务

LocationManagerService : 定位管理服务

AndioServcie : 音频相关管理服务

…and so on …

6. SystemServer进程启动总结
SystemServer进程被创建后，主要做了如下工作：

启动Binder线程池，使得system_server进程能与其它进程通信

创建SystemServiceManager，用于对系统的服务进程创建、启动和生命周期管理

启动系统中的引导服务、核心服务和其它服务

非常感谢您的耐心阅读，希望我的文章对您有帮助。欢迎点评、转发或分享给您的朋友或技术群。
————————————————
版权声明：本文为CSDN博主「salmon_zhang」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/salmon_zhang/article/details/93208135