深度探索Activity(1): 系统服务初始化

引言：

这里想好好的对Android Framework中Activity的相关行为做一个研究，首先探讨的是Activity的生存环境，也就是系统服务初始化部分。

一、Zygote Service

凡事均想知道事物的来龙去脉，每次我看待一个课题，总会从系统初始化开始研究，在这里就从zygote的初始化看起。

在简明英汉词典中，zygote是受精卵、接合体的意思。从字面上看，Zygote Service应该是用作孵化功能，我的猜测是Zygote Service作为系统服务，而其他的进程均是由该服务派生出来的。

在日常调试的时候我们可以看到如果碰到Zygote Service出错的话，各个Service会相续退出，然后AndroidRuntime重启Zygote服务。

zygote是在哪里被载入系统的呢？我们在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

这里我们可以看到zygote服务是app_process进程，这个服务指定了一个Socket用于服务通信。在frameworks/base/cmds/app_process文件夹下我们只看到app_main.cpp这个文件，进程启动的自然就是该文件的main函数了。该main函数中有下面一段代码用于启动zygoteInit：

            bool
 startSystemServer = (i < argc) ? 

                    strcmp(argv[i], "--start-system-server
") == 0 : false
;

            setArgv0(argv0, "zygote
");

            set_process_name("zygote
");

            runtime.start("com.android.internal.os.ZygoteInit
",

                startSystemServer);

runtime.start调用了AndroidRuntime运行“com.android.internal.os.ZygoteInit”，我们把目光转向ZygoteInit.java。

同样是main入口：

    public
 static
 void
 main(String argv[]) {

        try
 {

            // Start profiling the zygote initialization.


            SamplingProfilerIntegration.start();



            registerZygoteSocket();

            EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,

                SystemClock.uptimeMillis());

            preloadClasses();

            //cacheRegisterMaps();


            preloadResources();

            EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,

                SystemClock.uptimeMillis());



            if
 (SamplingProfilerIntegration.isEnabled()) {

                SamplingProfiler sp = SamplingProfiler.getInstance();

                sp.pause();

                SamplingProfilerIntegration.writeZygoteSnapshot();

                sp.shutDown();

            }



            // Do an initial gc to clean up after startup


            gc();



            // If requested, start system server directly from Zygote


            if
 (argv.length != 2) {

                throw
 new
 RuntimeException(argv[0] + USAGE_STRING);

            }



            if
 (argv[1].equals("true
")) {

                startSystemServer();

            } else
 if
 (!argv[1].equals("false
")) {

                throw
 new
 RuntimeException(argv[0] + USAGE_STRING);

            }



            Log.i(TAG, "Accepting command socket connections
");



            if
 (ZYGOTE_FORK_MODE) {

                runForkMode();

            } else
 {

                runSelectLoopMode();

            }



            closeServerSocket();

        } catch
 (MethodAndArgsCaller caller) {

            caller.run();

        } catch
 (RuntimeException ex) {

            Log.e(TAG, "Zygote died with exception
", ex);

            closeServerSocket();

            throw
 ex;

        }

    }

前面调用registerZygoteSocket注册Zygote指定的Socket，然后调用startSystemServer初始化系统服务SystemServer，接着虽然ZYGOTE_FORK_MODE被赋予false，即调用runSelectLoopMode，这是一个死循环，循环检测Socket的连接消息，一旦有连接，则调用ZygoteConnect的Runonce，fork一个新的进程出来。

        if
 (pid == 0) {

            // in child


            handleChildProc(parsedArgs, descriptors, newStderr);

            // should never happen


            return
 true
;

        } else
 { /* pid != 0 */


            // in parent...pid of < 0 means failure


            return
 handleParentProc(pid, descriptors, parsedArgs);

        }

子进程调用handleChildProc，进而调用ZygoteInit.invokeStaticMain(cloader, className, mainArgs);进入进程主控类（由Socket的参数传递进来）的main函数中。后面我们可以看到传递进来的是ActivityThread类。

这样一整条进程的线就比较清晰了，我们开始分叉出来看系统服务。

 

二、SystemServer

startSystemServer初始化如下参数，并在fork之后传递给RuntimeInit.ZygoteInit进而调用invokeStaticMain来进入主控类的main函数。

        String args[] = {

            "--setuid=1000
",

            "--setgid=1000
",

            "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,3001,3002,3003
",

            "--capabilities=130104352,130104352
",

            "--runtime-init
",

            "--nice-name=system_server
",

            "com.android.server.SystemServer
",

        };

从这里我们可以看到fork出来的进程将执行的是com.android.server.SystemServer的main函数。OK，我们就从这个main继续旅程。

SystemServer的main很简单就是加载android_server库，然后调用native init1，该函数在com_android_server_SystemServer.cpp中，被映射到android_server_SystemServer_init1，进而调用library/system_init.cpp中的system_init。

system_init首先调用几个重要服务的instantiate()函数依次初始化"SurfaceFlinger“,"AudioFlinger”, "MediaPlayerService“,”CameraService”,”AudioPolicyService”。然后调用runtime->callStatic("com/android/server/SystemServer", "init2");进入SystemServer的init2，最后将自己加入到ThreadPool中。

init2创建执行了ServerThread，在ServerThread中初始化了各个Service，并在初始化完通知各个服务systemReady，这里就不一一介绍了，最后进入Looper.loop进行消息循环。

 

三、ZygoteInit调用

前面说到Zygote Service监听Socket连接，并处理fork进程的请求，我们来看一下Socket的Client是如何调用的。

我们在ActivityManagerService的startProcessLocked中看到这么一个调用：

            int
 pid = Process.start("android.app.ActivityThread
",

                    mSimpleProcessManagement ? app.processName : null
, uid, uid,

                    gids, debugFlags, null
);

这里将”android.app.ActivityThread”类名传递给Process.start，进而调用startViaZygote初始化参数，最后调用zygoteSendArgsAndGetPid连接Zygote Socket并发送请求。

从而我们可以知道当ActivityManagerService开启一个Process时，首先执行的应该是ActivityThread的main函数。