Android启动（二）-----如何从C层到Java层

之前讲到，init进程会启动zygote进程，那么zygote进程会做些什么？而且目前为止仍然是运行在C/C++层的程序，那么什么时候会进入Java层呢？

源码参考Android4.1.1，涉及文件有 App_main.cpp,AndroidRuntime.h，AndroidRuntime.cpp (framework文件夹下)

zygote是受精卵的意思。Android这样起名字很明显，说明zygote会分裂产生新的系统服务进程，当然和开发者最贴近的，是zygote会分裂产生应用进程，每一个APP要启动，都要通知zygote，让他分裂一个进程给上层。所以在应用开发的时候，如果出现某些错误，也可能会定位到zygote这一层，说明分裂不成功（当然，往往是因为自己的一些空指针什么的）。
App_main.cpp的main函数（部分）

 while (i < argc) {
        const char* arg = argv[i++];
        if (!parentDir) {
            parentDir = arg;
        } else if (strcmp(arg, "--zygote") == 0) {//判断是否为zygote
            zygote = true;
            niceName = "zygote";//下行:若有参数"--start-system-server"
        } 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) {//若是zygote进程
        runtime.start("com.android.internal.os.ZygoteInit",
                startSystemServer ? "start-system-server" : "");
    }

• 在while循环中，可以看到一个有意思的现象，就是zygote进程的名字原本不叫zygote，是在这个时候改了名字。
• 关于argv数组，其实可以直接参考上一篇文章中给出的init.rc中的zygote配置信息：“--zygote --start-system-server”
• 在最后我们果然看到了一个runtime.start()函数，一言不合就start。当然可以看到它尝试去开启SystemServer

SystemServer是个了不起的系统进程，它的责任就是管理其他的关键系统服务，比如AMS

但是首先我们需要了解runtime,它源自一个AppRuntime类，而这个类的父类是AndroidRuntime(这个类定义在AndroidRuntime头文件中).
继承结构图如下：

AndroidRuntime_appruntime

• 从上面可以看到，其实runtime虽然是AppRuntime类型，但是其实调用的start函数是父类的函数。
  AndroidRuntime.start():

void AndroidRuntime::start(const char* className, const char* options)
{
    ALOGD("\n>>>>>> AndroidRuntime START %s <<<<<<\n",
            className != NULL ? className : "(unknown)");

    blockSigpipe();

    /*
     * 'startSystemServer == true' means runtime is obsolete and not run from
     * init.rc anymore, so we print out the boot start event here.
     */
    if (strcmp(options, "start-system-server") == 0) {
        /* track our progress through the boot sequence */
        const int LOG_BOOT_PROGRESS_START = 3000;
        LOG_EVENT_LONG(LOG_BOOT_PROGRESS_START,
                       ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
    }

    const char* rootDir = getenv("ANDROID_ROOT");
    if (rootDir == NULL) {
        rootDir = "/system";
        if (!hasDir("/system")) {
            LOG_FATAL("No root directory specified, and /android does not exist.");
            return;
        }
        setenv("ANDROID_ROOT", rootDir, 1);
    }

    //const char* kernelHack = getenv("LD_ASSUME_KERNEL");
    //ALOGD("Found LD_ASSUME_KERNEL='%s'\n", kernelHack);

    /* start the virtual machine */
    JNIEnv* env;
    if (startVm(&mJavaVM, &env) != 0) {    //大家快看啊，它创建了虚拟机
        return;
    }
    onVmCreated(env);

    /*
     * Register android functions.
     */
    if (startReg(env) < 0) {     //它在注册jni函数
        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;
    jstring optionsStr;

  //熟悉JNI开发的同学估计很熟悉这些env->XXX()的函数调用
    stringClass = env->FindClass("java/lang/String");
    assert(stringClass != NULL);
    strArray = env->NewObjectArray(2, stringClass, NULL);
    assert(strArray != NULL);
    classNameStr = env->NewStringUTF(className);
    assert(classNameStr != NULL);
    env->SetObjectArrayElement(strArray, 0, classNameStr);
    optionsStr = env->NewStringUTF(options);
    env->SetObjectArrayElement(strArray, 1, optionsStr);
//上面这一段的意思大概是，创建Java层的String数组对象，然后做一些赋值工作。
//比如数组第一个赋值为“com.android.internal.os.ZygoteInit”。

    /*
     * Start VM.  This thread becomes the main thread of the VM, and will
     * not return until the VM exits.
     */
    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中的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 {
            //这是更加关键的一步，从c层调用调用Java层的方法。
            env->CallStaticVoidMethod(startClass, startMeth, strArray);

#if 0
            if (env->ExceptionCheck())
                threadExitUncaughtException(env);
#endif
        }
    }
    free(slashClassName);

    ALOGD("Shutting down VM\n");
    if (mJavaVM->DetachCurrentThread() != JNI_OK)
        ALOGW("Warning: unable to detach main thread\n");
    if (mJavaVM->DestroyJavaVM() != 0)
        ALOGW("Warning: VM did not shut down cleanly\n");
}

总结一下：

1. 创建VM-----startVm()
2. 注册JNI函数------startReg()
3. 在C层做一些向Java层的赋值工作
4. 获取Java层的ZygoteInit.main方法id
5. 调用main方法，进入Java世界。

至此，Android如何从C层到Java层已经讲完了，其实就是通过JIN调用了Java层的main函数。但是需要注意的是，目前zygote还是没有启动那个吊炸天的SystemSever进程，虽然前面嚷嚷了半天要启动它，但是，显然还没有