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

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); //注释2ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);//fork子进程，也是创建SystemServer进程pid = Zygote.forkSystemServer( //注释3parsedArgs.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原有的socketzygoteServer.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));}}}//设置groupSetGids(env, javaGids);//设置资源limitSetRLimits(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_serverSetThreadName(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); //注释2Thread.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.\n");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.75VMRuntime.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 Exceptionimplements 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);}//如果没有设置时区属性，则默认为GMTString 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.soSystemProperties.set("persist.sys.dalvik.vm.lib.2", VMRuntime.getRuntime().vmLibrary());...省略...//清除vm内存增长上限，由于启动过程需要较多的虚拟机内存空间VMRuntime.getRuntime().clearGrowthLimit();//设置内存的可能有效使用率为0.8VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);//针对部分设备依赖于运行时就产生指纹信息，因此需要在开机完成前已经定义Build.ensureFingerprintProperty();//访问环境变量前，需要明确地指定用户Environment.setUserRequired(true);//在系统服务器中，应该对任何传入的bundle进行解压缩，以避免抛出BadParcelableExceptionBaseBundle.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);//创建消息LooperLooper.prepareMainLooper();//加载android_servers.so库，该库包含的源码在frameworks/base/services/目录下System.loadLibrary("android_servers");//检测上次关机过程是否失败，该方法可能不会返回performPendingShutdown(); //注释1//初始化系统上下文createSystemContext(); //注释2//创建系统服务管理mSystemServiceManager = new SystemServiceManager(mSystemContext); //注释3mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);//将mSystemServiceManager添加到本地服务的成员sLocalServiceObjectsLocalServices.addService(SystemServiceManager.class, mSystemServiceManager);//为可以并行化的init任务准备线程池SystemServerInitThreadPool.get();} finally {traceEnd();  // InitBeforeStartServices}// Start services.try {traceBeginAndSlog("StartServices");//启动引导服务startBootstrapServices(); //注释4//启动核心服务startCoreServices(); //注释5//启动其他服务startOtherServices(); //注释6SystemServerInitThreadPool.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);

深入到SystemServiceManager的startService函数中：

public void startService(@NonNull final SystemService service) {//注册ServicemServices.add(service); //注释1long time = System.currentTimeMillis();try {//启动Serviceservice.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);

直接调用了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); //注释1m.enableSystemUserPackages();ServiceManager.addService("package", m); //注释2return 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之前注册DeviceIdentifiersPolicyServicemSystemServiceManager.startService(DeviceIdentifiersPolicyService.class);...省略...//启动服务ActivityManagerServicemActivityManagerService = mSystemServiceManager.startService(ActivityManagerService.Lifecycle.class).getService();mActivityManagerService.setSystemServiceManager(mSystemServiceManager);mActivityManagerService.setInstaller(installer);...省略...//启动服务PowerManagerServicemPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);...省略...//初始化PowerManagementmActivityManagerService.initPowerManagement();...省略...//启动服务LightsServicemSystemServiceManager.startService(LightsService.class);...省略...//启动服务DisplayManagerServicemDisplayManagerService = 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;}...省略...//启动服务PackageManagerServicemPackageManagerService = PackageManagerService.main(mSystemContext, installer,mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);mFirstBoot = mPackageManagerService.isFirstBoot();mPackageManager = mSystemContext.getPackageManager();...省略...//启动服务UserManagerServicemSystemServiceManager.startService(UserManagerService.LifeCycle.class);//设置AMSmActivityManagerService.setSystemProcess();...省略...//启动服务OverlayManagerServicemSystemServiceManager.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，用于统计电池电量，需要LightServicemSystemServiceManager.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...省略...//启动服务AlarmManagerServicemSystemServiceManager.startService(AlarmManagerService.class);//初始化watchdogwatchdog.init(context, mActivityManagerService);...省略...inputManager = new InputManagerService(context); //input//启动WindowManagerServicewm = 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);//启动服务startHidlServicesstartHidlServices();traceEnd();}, START_HIDL_SERVICES);if (!disableVrManager) {traceBeginAndSlog("StartVrManagerService");//启动服务VrManagerServicemSystemServiceManager.startService(VrManagerService.class);traceEnd();}...省略...//启动服务IpConnectivityMetricsmSystemServiceManager.startService(IpConnectivityMetrics.class);//启动服务PinnerServicemSystemServiceManager.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，用于对系统的服务进程创建、启动和生命周期管理
启动系统中的引导服务、核心服务和其它服务

非常感谢您的耐心阅读，希望我的文章对您有帮助。欢迎点评、转发或分享给您的朋友或技术群。