SS诞生后，便和生父Zygote分道扬镳，它有了自己的历史使命。它的使命是什么呢？其代码如下所示： ~~~ pid =Zygote.forkSystemServer(); if(pid == 0) { //SS进程返回0，那么下面这句话就是SS的使命： handleSystemServerProcess(parsedArgs); } ~~~ SS调用handleSystemServerProcess来承担自己的职责。 **ZygoteInit.java** ~~~ private static void handleSystemServerProcess( ZygoteConnection.ArgumentsparsedArgs) throws ZygoteInit.MethodAndArgsCaller { //关闭从Zygote那里继承下来的Socket。 closeServerSocket(); //设置SS进程的一些参数。 setCapabilities(parsedArgs.permittedCapabilities, parsedArgs.effectiveCapabilities); //调用ZygoteInit函数。 RuntimeInit.zygoteInit(parsedArgs.remainingArgs); } ~~~ 好了，SS走到RuntimeInit了，它的代码在RuntimeInit.java中，如下所示： **RuntimeInit.java** ~~~ public static final void zygoteInit(String[]argv) throws ZygoteInit.MethodAndArgsCaller { //做一些常规初始化 commonInit(); //①native层的初始化。 zygoteInitNative(); intcurArg = 0; for (/* curArg */ ; curArg < argv.length; curArg++) { String arg = argv[curArg]; if (arg.equals("--")) { curArg++; break; } else if (!arg.startsWith("--")) { break; } else if (arg.startsWith("--nice-name=")) { String niceName = arg.substring(arg.indexOf('=') + 1); //设置进程名为niceName，也就是"system_server" Process.setArgV0(niceName); } } //startClass名为"com.android.server.SystemServer" String startClass = argv[curArg++]; String[] startArgs = new String[argv.length - curArg]; System.arraycopy(argv, curArg, startArgs, 0, startArgs.length); //②调用startClass，也就是com.android.server.SystemServer类的main函数。 invokeStaticMain(startClass, startArgs); } ~~~ 对于上面列举出的两个关键点，我们一个一个地分析。 1. zygoteInitNative分析 先看zygoteInitNative，它是一个native函数，实现在AndroidRuntime.cpp中。 **AndroidRuntime.cpp** ~~~ static voidcom_android_internal_os_RuntimeInit_zygoteInit( JNIEnv* env,jobject clazz) { gCurRuntime->onZygoteInit(); } //gCurRuntime是什么？还记得我们在本章开始说的app_process的main函数吗？ int main(int argc, const char* const argv[]) { AppRuntime runtime;// 就是这个。当时我们没顾及它的构造函数，现在回过头看看。 } //AppRuntime的定义 class AppRuntime : public AndroidRuntime static AndroidRuntime* gCurRuntime = NULL; // gCurRuntime为全局变量。 AndroidRuntime::AndroidRuntime() { SkGraphics::Init();//Skia库初始化 SkImageDecoder::SetDeviceConfig(SkBitmap::kRGB_565_Config); SkImageRef_GlobalPool::SetRAMBudget(512 * 1024); gCurRuntime= this; //gCurRuntime被设置为AndroidRuntime对象自己 } ~~~ 由于SS是从Zygote fork出来的，所以它也拥有Zygote进程中定义的这个gCurRuntime，也就是AppRuntime对象。那么，它的onZygoteInit会干些什么呢？它的代码在App_main.cpp中，我们一起来看： **App_main.cpp** ~~~ virtual void onZygoteInit() { //下面这些东西和Binder有关系，但读者可以先不管它。 sp<ProcessState> proc = ProcessState::self(); if(proc->supportsProcesses()) { proc->startThreadPool();//启动一个线程，用于Binder通信。 } } ~~~ 一言以蔽之，SS调用zygoteInitNative后，将和Binder通信系统建立联系，这样SS就能够使用Binder了。关于Binder的知识，在第6章中将详细介绍，读者朋友现在不必关注。 2. invokeStaticMain分析 再来看第二个关键点invokeStaticMain。代码如下所示： **RuntimeInit.java** ~~~ private static void invokeStaticMain(StringclassName, String[] argv) throws ZygoteInit.MethodAndArgsCaller { ......//注意我们的参数，className为"com.android.server.SystemServer" Class<?> cl; try { cl = Class.forName(className); }catch (ClassNotFoundException ex) { throw new RuntimeException( "Missing class wheninvoking static main " + className, ex); } Method m; try { //找到com.android.server.SystemServer类的main函数，肯定有地方要调用它 m = cl.getMethod("main", new Class[] { String[].class }); }catch (NoSuchMethodException ex) { ...... }catch (SecurityException ex) { ...... } int modifiers = m.getModifiers(); if(! (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))) { ...... } //抛出一个异常，为什么不在这里直接调用上面的main函数呢？ throw new ZygoteInit.MethodAndArgsCaller(m, argv); } ~~~ invokeStaticMain竟然抛出了一个异常，它是在哪里被截获呢？原来是在ZygoteInit的main函数中。请看这段代码： 注意：我们所在的进程是system_server。 **ZygoteInit.java** ~~~ .... if (argv[1].equals("true")) { //SS进程中，抛出一个异常MethodAndArgsCaller startSystemServer(); ...... catch(MethodAndArgsCaller caller) { //被截获，调用caller的run函数 caller.run(); } ~~~ 再来看看MethodAndArgsCaller的run函数。 ~~~ public void run() { try { //这个mMethod为com.android.server.SystemServer的main函数 mMethod.invoke(null, new Object[] { mArgs }); } catch(IllegalAccessException ex) { ...... } } ~~~ 抛出的这个异常最后会导致com.android.server.SystemServer类的main函数被调用。不过这里有一个疑问，为什么不在invokeStaticMain那里直接调用，而是采用这种抛异常的方式呢？我对这个问题的看法是： - 这个调用是在ZygoteInit.main中，相当于Native的main函数，即入口函数，位于堆栈的顶层。如果不采用抛异常的方式，而是在invokeStaticMain那里调用，则会浪费之前函数调用所占用的一些调用堆栈。 关于这个问题的深层思考，读者可以利用fork和exec的知识。对这种抛异常的方式，我个人觉得是对exec的一种近似模拟，因为后续的工作将交给com.android.server.SystemServer类来处理。 3. SystemServer的真面目 ZygoteInit分裂产生的SS，其实就是为了调用com.android.server.SystemServer的main函数，这简直就是改头换面！下面就来看看这个真实的main函数，代码如下所示： **SystemServer.java** ~~~ public static void main(String[] args) { ...... //加载libandroid_servers.so System.loadLibrary("android_servers"); //调用native的init1函数。 init1(args); } ~~~ 其中main函数将加载libandroid_server.so库，这个库所包含的源码文件在文件夹framework/base/services/jni下。 （1）init1分析 init1是native函数，在com_android_server_SystemServer.cpp中实现。来看看它，代码如下所示： **com_android_server_SystemServer.cpp** ~~~ extern "C" int system_init(); static voidandroid_server_SystemServer_init1(JNIEnv* env, jobject clazz) { system_init();//调用另外一个函数。 } ~~~ system_init的实现在system_init.cpp中，它的代码如下所示： **system_init.cpp** ~~~ extern "C" status_t system_init() { //下面这些调用和Binder有关，我们会在第6章中讲述，这里先不必管它。 sp<ProcessState> proc(ProcessState::self()); sp<IServiceManager> sm = defaultServiceManager(); sp<GrimReaper>grim = new GrimReaper(); sm->asBinder()->linkToDeath(grim, grim.get(), 0); charpropBuf[PROPERTY_VALUE_MAX]; property_get("system_init.startsurfaceflinger", propBuf,"1"); if(strcmp(propBuf, "1") == 0) { //SurfaceFlinger服务在system_server进程创建 SurfaceFlinger::instantiate(); } ...... //调用com.android.server.SystemServer类的init2函数 AndroidRuntime* runtime = AndroidRuntime::getRuntime(); runtime->callStatic("com/android/server/SystemServer","init2"); //下面这几个函数调用和Binder通信有关，具体内容在第6章中介绍。 if (proc->supportsProcesses()) { ProcessState::self()->startThreadPool(); //调用joinThreadPool后，当前线程也加入到Binder通信的大潮中 IPCThreadState::self()->joinThreadPool(); } returnNO_ERROR; } ~~~ init1函数创建了一些系统服务，然后把调用线程加入Binder通信中。不过其间还通过JNI调用了com.android.server.SystemServer类的init2函数，下面就来看看这个init2函数。 （2）init2分析 init2在Java层，代码在SystemServer.java中，如下所示： **SystemServer.java** ~~~ public static final void init2() { Threadthr = new ServerThread(); thr.setName("android.server.ServerThread"); thr.start();//启动一个ServerThread } ~~~ 启动了一个ServerThread线程。请直接看它的run函数。这个函数比较长，大概看看它干了什么即可。 **SystemServer.java::ServerThread的run函数** ~~~ public void run(){ .... //启动Entropy Service ServiceManager.addService("entropy",new EntropyService()); //启动电源管理服务 power =new PowerManagerService(); ServiceManager.addService(Context.POWER_SERVICE, power); //启动电池管理服务。 battery= new BatteryService(context); ServiceManager.addService("battery", battery); //初始化看门狗，在拓展部分将介绍关于看门狗的知识 Watchdog.getInstance().init(context,battery, power, alarm, ActivityManagerService.self()); //启动WindowManager服务 wm =WindowManagerService.main(context, power, factoryTest !=SystemServer.FACTORY_TEST_LOW_LEVEL); ServiceManager.addService(Context.WINDOW_SERVICE,wm); //启动ActivityManager服务 (ActivityManagerService)ServiceManager.getService("activity")) .setWindowManager(wm); ......//总之，系统各种重要服务都在这里启动 Looper.loop(); //进行消息循环，然后处理消息。关于这部分内容参见第5章。 } ~~~ init2函数比较简单，就是单独创建一个线程，用以启动系统各项服务，至此，读者或许能理解SS的重要性了吧？ - **Java世界的核心Service都在这里启动，所以它非常重要。** * * * * * **说明**：本书不对这些Service做进一步分析，今后有机会再做做专门介绍。 * * * * *