Android系统启动流程
操作系统本身也是一个程序，只是这个程序是用来管理我们 App 应用程序的。 从系统的角度上来讲，Android系统的启动过程可以分为 bootloader 引导，装载和启动 linux内核，启动Android系统。
Bootloader 相当于电脑上的Bios 他的主要作用就是初始化基本的硬件设备，建立内存空间映射，为装载linux内核准备好运行环境，当linux内核加载完毕之后，bootloder就会从内存中清除。
Android 系统虽然也是基于 Linux 系统的，但是由于 Android 属于移动设备，并没有像 PC 那样的 BIOS 程序。 取而代之的是 BootLoader (系统启动加载器)。 它类似于 BIOS，在系统加载前，用以初始化硬件设备，建立内存空间的映像图，为最终调用系统内核准备好环境。 在 Android 里没有硬盘，而是 ROM，它类似于硬盘存放操作系统，用户程序等。 ROM 跟硬盘一样也会划分为不同的区域，用于放置不同的程序。当 Linux 内核启动后会初始化各种软硬件环境，加载驱动程序，挂载根文件系统，Linux 内核加载的准备完毕后就开始加载一些特定的程序(进程)了。
具体流程，可以参考下流程图：
[图片上传失败...(image-abada2-1632755937198)]
对于纯Android应用层开发来讲，了解一些Android的启动流程的知识并不会直接提高自己的代码质量。但是作为整个Android系统的开端，这部分的流程时刻影响着应用层的方方面面。这些知识也是作为Android开发进阶必须要了解的一部分。对于前面的bootloader引导也好，装载启动linux文件都是很底层的东西，感兴趣的可以自行了解一下，我们从启动androng系统开始分析，第一个加载的就是 init 进程。
一：init进程
我们应该都知道不管是 Java 还是 C/C++ 去运行某一个程序(进程)都是 XXX.xxx 的 main 方法作为入口，相信有很多大佬都跟我一样，App 开发做久了渐渐就忘记了还有个 main 方法。因此我们找到 /system/core/init/Init.cpp 的 main() 方法：
int main(int argc,char ** argv){
...
if(is_first_stage){
//创建和挂在启动所需要的文件目录
mount("tmpfs","/dev","tmpfs",MS_NOSUID,"mode=0755");
mkdir("/dev/pts",0755);
//创建和挂在很多...
...
}
...
//对属性服务进行初始化
property_init();
...
//用于设置子进程信号处理函数（如Zygote），如果子进程异常退出，init进程会调用该函数中设定的信号处理函数来处理
signal_handler_init();
...
//启动属性服务
start_property_service();
...
//解析init.rc配置文件
parser.ParseConfig("/init.rc");
}
main 方法里面有 148 行代码（不包括子函数代码）具体分为四个步骤：1.创建目录,挂载分区，2.解析启动脚本，3.启动解析的服务，4.守护解析的服务。init.rc 文件是 Android 系统的重要配置文件，位于 /system/core/rootdir/init.rc
import /init.environ.rc
import /init.usb.rc
// 当前硬件版本的脚本
import /init.${ro.hardware}.rc
import /init.${ro.zygote}.rc
import /init.trace.rc
on early-init
...
on init
...
// 服务 服务名称 执行文件路径 执行参数
// 有几个重要的服务
service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server
service servicemanager /system/bin/servicemanager
service surfaceflinger /system/bin/surfaceflinger
service media /system/bin/mediaserver
service installd /system/bin/installd
在处理了繁多的任务后，init进程会进行最关键的一部操作: 启动Zygote
至此 init 进程已全部分析完毕，有四个步骤：1. 创建目录,挂载分区，2. 解析启动脚本，3. 启动解析的服务，4. 守护解析的服务。最需要注意的是 init 创建了 zygote(创建 App 应用的服务)、servicemanager (client 与 service 通信管理的服务)、surfaceflinger(显示渲染服务) 和 media(多媒体服务) 等 service 进程。
二：Zygote
Zygote 进程是由 init 进程通过解析 init.rc 文件而创建的。
service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
socket zygote stream 666
onrestart write /sys/android_power/request_state wake
onrestart write /sys/power/state on
onrestart restart media
onrestart restart netd
对应找到 /frameworks/base/cmds/app_process/app_main.cpp 源码文件中的 main 方法
int main(int argc, char* const argv[])
{
// AppRuntime 继承 AndoirdRuntime
AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
// 过滤第一个参数
argc--;
argv++;
...
bool zygote = false;
bool startSystemServer = false;
bool application = false;
String8 niceName;
String8 className;
++i; // Skip unused "parent dir" argument.
// 解析参数
while (i < argc) {
const char* arg = argv[i++];
if (strcmp(arg, "--zygote") == 0) {
zygote = true;
niceName = ZYGOTE_NICE_NAME;
} else if (strcmp(arg, "--start-system-server") == 0) {
startSystemServer = true;
} else if (strcmp(arg, "--application") == 0) {
application = true;
} else if (strncmp(arg, "--nice-name=", 12) == 0) {
niceName.setTo(arg + 12);
} else if (strncmp(arg, "--", 2) != 0) {
className.setTo(arg);
break;
} else {
--i;
break;
}
}
...
//设置进程名
if (!niceName.isEmpty()) {
runtime.setArgv0(niceName.string());
set_process_name(niceName.string());
}
// 如果 zygote ，AndroidRuntime 执行 com.android.internal.os.ZygoteInit
// 看上面解析的脚本参数执行的是这里。
if (zygote) {
runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
} else if (className) {
runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
} else {
fprintf(stderr, "Error: no class name or --zygote supplied.\n");
app_usage();
LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
return 10;
}
}
上面首先是解析参数，然后来到 /frameworks/base/core/jni/AndroidRuntime.cpp 中的 start 方法：
/*
* Start the Android runtime. This involves starting the virtual machine
* and calling the "static void main(String[] args)" method in the class
* named by "className".
*
* Passes the main function two arguments, the class name and the specified
* options string.
*/
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
...
// 创建一个虚拟机的实例
/* start the virtual machine */
JniInvocation jni_invocation;
jni_invocation.Init(NULL);
JNIEnv* env;
if (startVm(&mJavaVM, &env, zygote) != 0) {
return;
}
onVmCreated(env);
// JNI 方法注册
/*
* Register android functions.
*/
if (startReg(env) < 0) {
ALOGE("Unable to register all android natives\n");
return;
}
/*
* We want to call main() with a String array with arguments in it.
* At present we have two arguments, the class name and an option string.
* Create an array to hold them.
*/
jclass stringClass;
jobjectArray strArray;
jstring classNameStr;
// strArray= new String[options.size() + 1];
stringClass = env->FindClass("java/lang/String");
strArray = env->NewObjectArray(options.size() + 1, stringClass, NULL);
// strArray[0] = "com.android.internal.os.ZygoteInit"
classNameStr = env->NewStringUTF(className);
env->SetObjectArrayElement(strArray, 0, classNameStr);
// strArray[1] = "start-system-server"；
// strArray[2] = "--abi-list=系统响应的cpu架构类型"；
for (size_t i = 0; i < options.size(); ++i) {
jstring optionsStr = env->NewStringUTF(options.itemAt(i).string());
env->SetObjectArrayElement(strArray, i + 1, optionsStr);
}
// slashClassName = "com/android/internal/os/ZygoteInit"
char* slashClassName = toSlashClassName(className);
jclass startClass = env->FindClass(slashClassName);
if (startClass == NULL) {
ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
/* keep going */
} else {
// 获取 ZygoteInit.java 的 main 方法
jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
"([Ljava/lang/String;)V");
if (startMeth == NULL) {
ALOGE("JavaVM unable to find main() in '%s'\n", className);
/* keep going */
} else {
// 执行 ZygoteInit.java 的 main 方法，从 Native 世界进入 Java 世界
env->CallStaticVoidMethod(startClass, startMeth, strArray);
}
}
...
}
Java 代码是跑在 Java 虚拟机上的，而 Java 与 native 通信采用的是 JNI ，从这里我们就开始进入 Java 世界：
public static void main(String argv[]) {
try {
// 解析参数
boolean startSystemServer = false;
String socketName = "zygote";
String abiList = null;
for (int i = 1; i < argv.length; i++) {
if ("start-system-server".equals(argv[i])) {
startSystemServer = true;
} else if (argv[i].startsWith(ABI_LIST_ARG)) {
abiList = argv[i].substring(ABI_LIST_ARG.length());
} else if (argv[i].startsWith(SOCKET_NAME_ARG)) {
socketName = argv[i].substring(SOCKET_NAME_ARG.length());
} else {
throw new RuntimeException("Unknown command line argument: " + argv[i]);
}
}
...
// 为 Zygote 注册 socket 用于通信
registerZygoteSocket(socketName);
// 预加载类和资源
preload();
// 启动 system_server
if (startSystemServer) {
startSystemServer(abiList, socketName);
}
// 进入循环模式，等待孵化进程
runSelectLoop(abiList);
closeServerSocket();
} catch (MethodAndArgsCaller caller) {
caller.run();
} catch (RuntimeException ex) {
closeServerSocket();
throw ex;
}
}
private static void registerZygoteSocket(String socketName) {
if (sServerSocket == null) {
int fileDesc;
final String fullSocketName = ANDROID_SOCKET_PREFIX + socketName;
try {
String env = System.getenv(fullSocketName);
fileDesc = Integer.parseInt(env);
} catch (RuntimeException ex) {
...
}
try {
FileDescriptor fd = new FileDescriptor();
// 设置文件描述符
fd.setInt$(fileDesc);
// 创建 Socket 的本地服务端
sServerSocket = new LocalServerSocket(fd);
} catch (IOException ex) {
...
}
}
}
static void preload() {
// 预加载位于 /system/etc/preloaded-classes 文件中的类
preloadClasses();
// 预加载资源，包含 drawable 和 color 资源
preloadResources();
// 预加载 OpenGL
preloadOpenGL();
// 通过 System.loadLibrary() 方法，
// 预加载 "android", "compiler_rt", "jnigraphics" 这3个共享库
preloadSharedLibraries();
// 预加载 文本连接符资源
preloadTextResources();
// 仅用于 zygote 进程，用于内存共享的进程
WebViewFactory.prepareWebViewInZygote();
}
private static boolean startSystemServer(String abiList, String socketName) throws MethodAndArgsCaller, RuntimeException {
...
// 设置一些参数
String args[] = {
"--setuid=1000",
"--setgid=1000",
"--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1032,3001,3002,3003,3006,3007",
"--capabilities=" + capabilities + "," + capabilities,
"--nice-name=system_server",
"--runtime-args",
"com.android.server.SystemServer",
};
ZygoteConnection.Arguments parsedArgs = null;
int pid;
try {
...
// fork 创建 system_server 进程，后面会具体分析
pid = Zygote.forkSystemServer(
parsedArgs.uid, parsedArgs.gid,
parsedArgs.gids,
parsedArgs.debugFlags,
null,
parsedArgs.permittedCapabilities,
parsedArgs.effectiveCapabilities);
} catch (IllegalArgumentException ex) {
throw new RuntimeException(ex);
}
// pid == 0 代表子进程，也就是 system_server 进程
if (pid == 0) {
// 执行初始化 system_server 进程
handleSystemServerProcess(parsedArgs);
}
return true;
}
private static void runSelectLoop(String abiList) throws MethodAndArgsCaller {
ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
// sServerSocket 是 registerZygoteSocket 中创建的，即 zygote 进程。保存到 fds[0]
fds.add(sServerSocket.getFileDescriptor());
peers.add(null);
while (true) {
// 给 pollFds 设置参数，fds.size 是 1 ，也就是说 pollFds 里面只有 sServerSocket.getFileDescriptor()
StructPollfd[] pollFds = new StructPollfd[fds.size()];
for (int i = 0; i < pollFds.length; ++i) {
pollFds[i] = new StructPollfd();
pollFds[i].fd = fds.get(i);
pollFds[i].events = (short) POLLIN;
}
try {
// 处理轮询状态，当 pollFds 有事件到来则往下执行，否则阻塞在这里
Os.poll(pollFds, -1);
} catch (ErrnoException ex) {
...
}
for (int i = pollFds.length - 1; i >= 0; --i) {
if (i == 0) {
// 即fds[0]，代表的是 sServerSocket，则意味着有客户端连接请求；
// 则创建 ZygoteConnection 对象,并添加到 fds。
ZygoteConnection newPeer = acceptCommandPeer(abiList);
peers.add(newPeer);
//添加到 fds.
fds.add(newPeer.getFileDesciptor());
} else {
// i>0，则代表通过 socket 接收来自对端的数据，并执行相应操作
boolean done = peers.get(i).runOnce();
if (done) {
peers.remove(i);
// 处理完则从fds中移除该文件描述符
fds.remove(i);
}
}
}
}
}
boolean runOnce() throws ZygoteInit.MethodAndArgsCaller {
String args[];
Arguments parsedArgs = null;
FileDescriptor[] descriptors;
try {
// 读取 socket 客户端发送过来的参数列表
args = readArgumentList();
descriptors = mSocket.getAncillaryFileDescriptors();
} catch (IOException ex) {
...
return true;
}
...
try {
// 将 binder 客户端传递过来的参数，解析成 Arguments 对象格式
parsedArgs = new Arguments(args);
...
// fork 创建一个新的进程
pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,
parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,
parsedArgs.niceName, fdsToClose, parsedArgs.instructionSet,
parsedArgs.appDataDir);
} catch (Exception e) {
...
}
try {
if (pid == 0) {
// pid == 0 执行子进程的逻辑
IoUtils.closeQuietly(serverPipeFd);
serverPipeFd = null;
// 进入子进程流程
handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);
return true;
} else {
// pid>0 执行父进程的逻辑
IoUtils.closeQuietly(childPipeFd);
childPipeFd = null;
return handleParentProc(pid, descriptors, serverPipeFd, parsedArgs);
}
} finally {
IoUtils.closeQuietly(childPipeFd);
IoUtils.closeQuietly(serverPipeFd);
}
}
相信很多人都跟我一样，刚开始看这样的代码有一定的难度，毕竟都是大学时期学的，不涉及底层开发的，看起来有些吃力，但是仔细阅读之后，或者通过命名，都可以大致看得懂流程。
Zygote 进程是由 init 进程解析 init.rc 脚本创建的，其具体的执行源码是在 App_main.main 方法，首先会创建一个虚拟机实例，然后注册 JNI 方法，最后通过 JNI 调用进入 Java 世界来到 ZygoteInit.main 方法。在 Java 世界中我们会为 Zygote 注册 socket 用于进程间通信，预加载一些通用的类和资源，启动 system_server 进程，循环等待孵化创建新的进程。总结一下ZygoteInit的main方法都做了哪些事情：
1.创建了一个Server端的Socket
2.预加载类和资源
3.启动了SystemServer进程
4.等待AMS请求创建新的应用程序进程
Zygote进程启动后，总共做了哪几件事：
1.创建AndroidRuntime并调用其start方法，启动Zygote进程。
2.创建Java虚拟机并为Java虚拟机注册JNI方法。
3.通过JNI调用ZygoteInit的main函数进入Zygote的java框架层。
4.通过registerZygoteSocket方法创建服务端Socket，并通过runSelectLoop方法等待AMS的请求来创建新的应用程序进程。
5.启动SystemServer。
三：SystemService
Zygote 进程的启动过程中会调用 startSystemServer 方法来启动 SystemServer 进程：
private static boolean startSystemServer(String abiList, String socketName) throws MethodAndArgsCaller, RuntimeException {
...
// 设置一些参数
String args[] = {
"--setuid=1000",
"--setgid=1000",
"--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1032,3001,3002,3003,3006,3007",
"--capabilities=" + capabilities + "," + capabilities,
"--nice-name=system_server",
"--runtime-args",
"com.android.server.SystemServer",
};
ZygoteConnection.Arguments parsedArgs = null;
int pid;
try {
...
// fork 创建 system_server 进程，后面会具体分析
pid = Zygote.forkSystemServer(
parsedArgs.uid, parsedArgs.gid,
parsedArgs.gids,
parsedArgs.debugFlags,
null,
parsedArgs.permittedCapabilities,
parsedArgs.effectiveCapabilities);
} catch (IllegalArgumentException ex) {
throw new RuntimeException(ex);
}
// pid == 0 代表子进程，也就是 system_server 进程
if (pid == 0) {
// 执行初始化 system_server 进程
handleSystemServerProcess(parsedArgs);
}
return true;
}
1. 启动 SystemServer
public static int forkSystemServer(int uid, int gid, int[] gids, int debugFlags,
int[][] rlimits, long permittedCapabilities, long effectiveCapabilities) {
VM_HOOKS.preFork();
int pid = nativeForkSystemServer(uid, gid, gids, debugFlags, rlimits, permittedCapabilities, effectiveCapabilities);
// Enable tracing as soon as we enter the system_server.
if (pid == 0) {
Trace.setTracingEnabled(true);
}
VM_HOOKS.postForkCommon();
return pid;
}
// 调用的 native 方法去创建的，nativeForkSystemServer() 方法在 AndroidRuntime.cpp 中注册的，调用 com_android_internal_os_Zygote.cpp 中的 com_android_internal_os_Zygote_nativeForkSystemServer() 方法
native private static int nativeForkSystemServer(int uid, int gid, int[] gids, int debugFlags,int[][] rlimits, long permittedCapabilities, long effectiveCapabilities);
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 创建 systemserver 进程
pid_t pid = ForkAndSpecializeCommon(env, uid, gid, gids,
debug_flags, rlimits, permittedCapabilities, effectiveCapabilities,
MOUNT_EXTERNAL_DEFAULT, NULL, NULL, true, NULL,NULL, NULL);
// pid > 0 是父进程执行的逻辑
if (pid > 0) {
// waitpid 等待 SystemServer 进程的退出，如果退出了重启 zygote 进程
if (waitpid(pid, &status, WNOHANG) == pid) {
RuntimeAbort(env);
}
}
return pid;
}
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, jstring instructionSet, jstring dataDir) {
//设置子进程的 signal 信号处理函数
SetSigChldHandler();
// fork 子进程(SystemServer)
pid_t pid = fork();
if (pid == 0) {
// 进入子进程
...
// gZygoteClass = com/android/internal/os/Zygote
// gCallPostForkChildHooks = GetStaticMethodIDOrDie(env, gZygoteClass, "callPostForkChildHooks", "(ILjava/lang/String;)V");
// 等价于调用 Zygote.callPostForkChildHooks()
env->CallStaticVoidMethod(gZygoteClass, gCallPostForkChildHooks, debug_flags,is_system_server ? NULL : instructionSet);
...
} else if (pid > 0) {
// the parent process
}
return pid;
}
private static void handleSystemServerProcess( ZygoteConnection.Arguments parsedArgs) throws ZygoteInit.MethodAndArgsCaller {
...
if (parsedArgs.invokeWith != null) {
...
} else {
ClassLoader cl = null;
if (systemServerClasspath != null) {
// 创建类加载器，并赋予当前线程
cl = new PathClassLoader(systemServerClasspath, ClassLoader.getSystemClassLoader());
Thread.currentThread().setContextClassLoader(cl);
}
// RuntimeInit.zygoteInit
RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
}
}
public static final void zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) throws ZygoteInit.MethodAndArgsCaller {
...
// 通用的一些初始化
commonInit();
// 这个方法是 native 方法，主要是打开 binder 驱动，启动 binder 线程，后面分析 binder 驱动的时候再详解。
nativeZygoteInit();
// 应用初始化
applicationInit(targetSdkVersion, argv, classLoader);
}
private static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) throws ZygoteInit.MethodAndArgsCaller {
...
final Arguments args;
try {
// 解析参数 Arguments
args = new Arguments(argv);
} catch (IllegalArgumentException ex) {
return;
}
...
invokeStaticMain(args.startClass, args.startArgs, classLoader);
}
private static void invokeStaticMain(String className, String[] argv, ClassLoader classLoader) throws ZygoteInit.MethodAndArgsCaller {
Class<?> cl = Class.forName(className, true, classLoader);
...
Method m;
try {
m = cl.getMethod("main", new Class[] { String[].class });
} catch (NoSuchMethodException ex) {
...
} catch (SecurityException ex) {
...
}
...
// 通过抛出异常，回到了 ZygoteInit.main()
// try{} catch (MethodAndArgsCaller caller) {caller.run();}
throw new ZygoteInit.MethodAndArgsCaller(m, argv);
}
绕了一大圈我们发现是通过抛异常回到了 ZygoteInit.main() 方法中的 try…catch(){MethodAndArgsCaller.run() }
2. 创建 SystemServer
public static class MethodAndArgsCaller extends Exception implements Runnable {
...
public void run() {
try {
// 根据传递过来的参数可知，此处通过反射机制调用的是 SystemServer.main() 方法
mMethod.invoke(null, new Object[] { mArgs });
} catch (IllegalAccessException ex) {
...
}
}
public final class SystemServer {
...
public static void main(String[] args) {
new SystemServer().run();
}
private void run() {
// 主线程 looper
Looper.prepareMainLooper();
// 初始化系统上下文
createSystemContext();
// 创建系统服务管理
mSystemServiceManager = new SystemServiceManager(mSystemContext);
// 将 mSystemServiceManager 添加到本地服务的成员 sLocalServiceObjects，sLocalServiceObjects 里面是一个静态的 map 集合
LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
//启动各种系统服务
try {
// 启动引导服务
startBootstrapServices();
// 启动核心服务
startCoreServices();
// 启动其他服务
startOtherServices();
} catch (Throwable ex) {
Slog.e("System", "************ Failure starting system services", ex);
throw ex;
}
// 一直循环执行
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
private void createSystemContext() {
// 创建系统进程的上下文信息，这个在进程启动再详解
ActivityThread activityThread = ActivityThread.systemMain();
mSystemContext = activityThread.getSystemContext();
...
}
private void startBootstrapServices() {
// 阻塞等待与 installd 建立 socket 通道
Installer installer = mSystemServiceManager.startService(Installer.class);
// 启动服务 ActivityManagerService
mActivityManagerService = mSystemServiceManager.startService(ActivityManagerService.Lifecycle.class).getService();
mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
// 启动服务 PackageManagerService
mPackageManagerService = PackageManagerService.main(mSystemContext, installer, mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
mPackageManager = mSystemContext.getPackageManager();
// 设置 AMS , 把自己交给 ServiceManager. addService 去管理
mActivityManagerService.setSystemProcess();
...
}
private void startCoreServices() {
...
}
private void startOtherServices() {
// 启动闹钟服务
mSystemServiceManager.startService(AlarmManagerService.class);
// 初始化 Watchdog
final Watchdog watchdog = Watchdog.getInstance();
watchdog.init(context, mActivityManagerService);
// 输入管理的 service
inputManager = new InputManagerService(context);
// WindowManagerService
wm = WindowManagerService.main(...);
// InputManagerService 和 WindowManagerService 都交给 ServiceManager 管理
ServiceManager.addService(Context.WINDOW_SERVICE, wm);
ServiceManager.addService(Context.INPUT_SERVICE, inputManager);
// 启动input
inputManager.start();
// 显示启动界面
ActivityManagerNative.getDefault().showBootMessage(...);
// 状态栏管理
statusBar = new StatusBarManagerService(context, wm);
// JobSchedulerService
mSystemServiceManager.startService(JobSchedulerService.class);
...
// 准备好了 wms, pms, ams 服务
wm.systemReady();
mPackageManagerService.systemReady();
mActivityManagerService.systemReady();
}
...
}
我们可以看到SystemServer在启动后，陆续启动了各项服务，包括ActivityManagerService，PowerManagerService，PackageManagerService等等，而这些服务的父类都是SystemService。
最后总结一下SystemServer进程：
1.启动Binder线程池
2.创建了SystemServiceManager（用于对系统服务进行创建、启动和生命周期管理）
3.启动了各种服务
3. 管理 SystemServer
系统服务启动后都会交给 ServiceManager 来管理，无论是 mSystemServiceManager.startService 还是 ServiceManager.addService 都是走的 ServiceManager.addService() 方法：
public static void addService(String name, IBinder service) {
try {
getIServiceManager().addService(name, service, false);
} catch (RemoteException e) {
Log.e(TAG, "error in addService", e);
}
}
private static IServiceManager getIServiceManager() {
if (sServiceManager != null) {
return sServiceManager;
}
sServiceManager = ServiceManagerNative.asInterface(BinderInternal.getContextObject());
return sServiceManager;
}
public abstract class ServiceManagerNative extends Binder implements IServiceManager {
static public IServiceManager asInterface(IBinder obj) {
if (obj == null) {
return null;
}
IServiceManager in =(IServiceManager)obj.queryLocalInterface(descriptor);
if (in != null) {
return in;
}
// 创建 ServiceManagerProxy 对象
return new ServiceManagerProxy(obj);
}
}
class ServiceManagerProxy implements IServiceManager {
private IBinder mRemote;
public ServiceManagerProxy(IBinder remote) {
mRemote = remote;
}
...
// IPC binder 驱动
public void addService(String name, IBinder service, boolean allowIsolated)
throws RemoteException {
Parcel data = Parcel.obtain();
Parcel reply = Parcel.obtain();
data.writeInterfaceToken(IServiceManager.descriptor);
data.writeString(name);
data.writeStrongBinder(service);
data.writeInt(allowIsolated ? 1 : 0);
// mRemote 是 IBinder 对象
mRemote.transact(ADD_SERVICE_TRANSACTION, data, reply, 0);
reply.recycle();
data.recycle();
}
}
最后我们再来总结一下：SystemServer 进程是由 Zygote 进程 fork 创建的，SystemServer 进程创建后会创建启动引导服务、核心服务和其他服务，并且将所创建的服务，通过跨进程通信交给 ServiceManager 进程来管理。
哈哈，看完这么多，是不是感觉有点了解，然后又不是特别了解，有一定的了解，就会想去深入了解，花点时间，慢慢去消化，主体流程了解，具体的底层实现，有兴趣可以多了解。
