深度探索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函数。

 

下期预告

系统服务的初始化到这里就暂时告一段落了，下一次旅行我们将一起去看看Home Activity的启动过程。