从Android init.rc到SystemServer.java

在上面一篇文章中，我们已经学习了Android系统启动的脚本文件init.rc，知道了init.c是怎么样解析脚本的。

之前的两篇文章：

1、解析Init.rc：http://my.oschina.net/u/561492/blog/144730

2、Android WIFI源码解读：http://my.oschina.net/u/561492/blog/142487

其中的第二篇文章，是从SystemServer.java说起的，那么Android系统是怎么从系统的启动脚本文件init.rc到SystemServer的呢？

1、回到init.rc文件中：

<!-- lang: shell -->
service zygote /system/bin/app\_process -Xzygote /system/bin --zygote --start-system-server
class main
socket zygote stream 666
onrestart write /sys/android\_power/request\_state wake
onrestart write /sys/power/state on
onrestart restart media
onrestart restart netd

service类型的section表示一个可执行程序，这里告诉init进程创建一个：zygote进程，其中可执行文件的位置在： /system/bin/app_process，后面跟的是需要传给app_process程序的参数。

app_process是一个可执行的程序，那么其源码在哪个位置呢？我们通过一下命令来查看：

<!-- lang: shell -->
ubuntu@ubuntu:~/android/source$ find ./ -name Android.mk | xargs grep app_process

./frameworks/base/cmds/app_process/Android.mk:LOCAL_MODULE:= app_process

可以看到，生成app_process可执行程序的位置在： ./frameworks/base/cmds/app_process/Android.mk，打开这个文件，内容如下：

<!-- lang: shell -->
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)

LOCAL_SRC_FILES:= \
    app_main.cpp

LOCAL_SHARED_LIBRARIES := \
    libcutils \
    libutils \
    libbinder \
    libandroid_runtime

LOCAL_MODULE:= app_process

include $(BUILD_EXECUTABLE)

从 LOCAL_SRC_FILES:= app_main.cpp 中，我们可以知道，其源码为：app_main.cpp

2、分析：app_main.cpp

打开app_main.cpp：./frameworks/base/cmds/app_process/，分析其结构。其中有两个最重要的部分，main函数，以及继承自AndroidRuntime的AppRuntime类。

<!-- lang: cpp -->
int main(int argc, const char* const argv[])
{
    // These are global variables in ProcessState.cpp
    mArgC = argc;
    mArgV = argv;

    mArgLen = 0;
    for (int i=0; i<argc; i++) {
        mArgLen += strlen(argv[i]) + 1;
    }
    mArgLen--;

    AppRuntime runtime;
    const char* argv0 = argv[0];

    // Process command line arguments
    // ignore argv[0]
    argc--;
    argv++;

    // Everything up to '--' or first non '-' arg goes to the vm

    int i = runtime.addVmArguments(argc, argv);

    // Parse runtime arguments.  Stop at first unrecognized option.
    bool zygote = false;
    bool startSystemServer = false;
    bool application = false;
    const char* parentDir = NULL;
    const char* niceName = NULL;
    const char* className = NULL;

    //解析由init.rc中传进来的参数--zygote --start-system-server
    while (i < argc) {
        const char* arg = argv[i++];
        if (!parentDir) {
            parentDir = arg;
        } else if (strcmp(arg, "--zygote") == 0) {
            zygote = true;
            niceName = "zygote";
        } 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 = arg + 12;
        } else {
            className = arg;
            break;
        }
    }

    if (niceName && *niceName) {
        setArgv0(argv0, niceName);
        set_process_name(niceName);
    }

    runtime.mParentDir = parentDir;

    if (zygote) {
        runtime.start("com.android.internal.os.ZygoteInit",
                startSystemServer ? "start-system-server" : "");
    } else if (className) {
        // Remainder of args get passed to startup class main()
        runtime.mClassName = className;
        runtime.mArgC = argc - i;
        runtime.mArgV = argv + i;
        runtime.start("com.android.internal.os.RuntimeInit",
                application ? "application" : "tool");
    } 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;
    }
}

其中的

<!-- lang: cpp -->
runtime.start("com.android.internal.os.ZygoteInit",
                startSystemServer ? "start-system-server" : "");

AppRuntime本身没有实现start方法，runtime.start继承了AndroidRuntime 的start。

frameworks/base/core/jni/AndroidRuntime.cpp

<!-- lang: cpp -->
void AndroidRuntime::start(const char* className, const char* options)
{

    /* start the virtual machine：启动虚拟机，后面分析 startVm()函数*/
    JNIEnv* env;
    if (startVm(&mJavaVM, &env) != 0) {
        return;
    }
    onVmCreated(env);

    /*
     * Register android functions.
     * 注册各种本地函数，具体可参看startReg()函数。
     */
    if (startReg(env) < 0) {
        LOGE("Unable to register all android natives\n");
        return;
    }

    /*
     * Start VM.  This thread becomes the main thread of the VM, and will
     * not return until the VM exits.
     */
      //这里的className为runtime.start()传进来的：com.android.internal.os.ZygoteInit
    char* slashClassName = toSlashClassName(className);
    jclass startClass = env->FindClass(slashClassName);
    if (startClass == NULL) {
        LOGE("JavaVM unable to locate class '%s'\n", slashClassName);
        /* keep going */
    } else {
        jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
            "([Ljava/lang/String;)V");

        //启动com.android.internal.os.ZygoteInit类中main函数
        env->CallStaticVoidMethod(startClass, startMeth, strArray);

    }

}

下面分析下：AndroidRuntime::startVm()

<!-- lang: cpp -->
int AndroidRuntime::startVm(JavaVM** pJavaVM, JNIEnv** pEnv)
{
    if (JNI_CreateJavaVM(pJavaVM, pEnv, &initArgs) < 0) {
            LOGE("JNI_CreateJavaVM failed\n");
            goto bail;
        }
｝

这里可以看到，JNI_CreateJavaVM(pJavaVM, pEnv, &initArgs) 方法创建了虚拟机！从上面的分析中，我们可以推出：
如何在C语言中运行（如果调用的话，可以简单的使用JNI即可）Java类！

（这部分，我想在以后的文章中具体讲解）
1、编写java程序
2、编写C 程序，其中在C中创建Java虚拟机，并调用创建好的虚拟机运行Java程序。
3、运行程序