Android C+源码笔记(1)

 

const char* rootDir = getenv("ANDROID_ROOT");

    if (rootDir == NULL) {

        rootDir = "/system";

        if (!hasDir("/system")) {

            return;

        }

        setenv("ANDROID_ROOT", rootDir, 1);

}

设置环境变量

 

int AndroidRuntime::startVm(JavaVM** pJavaVM, JNIEnv** pEnv)

//pJavaVM Runtime 静态量

{

    int result = -1;

    JavaVMInitArgs initArgs;

    JavaVMOption opt;

    char propBuf[PROPERTY_VALUE_MAX];

    char stackTraceFileBuf[PROPERTY_VALUE_MAX];

    char dexoptFlagsBuf[PROPERTY_VALUE_MAX];

    char enableAssertBuf[sizeof("-ea:")-1 + PROPERTY_VALUE_MAX];

    char jniOptsBuf[sizeof("-Xjniopts:")-1 + PROPERTY_VALUE_MAX];

    char heapstartsizeOptsBuf[sizeof("-Xms")-1 + PROPERTY_VALUE_MAX];

    char heapsizeOptsBuf[sizeof("-Xmx")-1 + PROPERTY_VALUE_MAX];

    char heapgrowthlimitOptsBuf[sizeof("-XX:HeapGrowthLimit=")-1 + PROPERTY_VALUE_MAX];

    char extraOptsBuf[PROPERTY_VALUE_MAX];

    char* stackTraceFile = NULL;

    bool checkJni = false;

    bool checkDexSum = false;

    bool logStdio = false;

    enum {

      kEMDefault,

      kEMIntPortable,

      kEMIntFast,

#if defined(WITH_JIT)

      kEMJitCompiler,

#endif

    } executionMode = kEMDefault;

 

 

    property_get("dalvik.vm.checkjni", propBuf, "");

    if (strcmp(propBuf, "true") == 0) {

        checkJni = true;

    } else if (strcmp(propBuf, "false") != 0) {

        /* property is neither true nor false; fall back on kernel parameter */

        property_get("ro.kernel.android.checkjni", propBuf, "");

        if (propBuf[0] == '1') {

            checkJni = true;

        }

    }

 

    property_get("dalvik.vm.execution-mode", propBuf, "");

    if (strcmp(propBuf, "int:portable") == 0) {

        executionMode = kEMIntPortable;

    } else if (strcmp(propBuf, "int:fast") == 0) {

        executionMode = kEMIntFast;

#if defined(WITH_JIT)

    } else if (strcmp(propBuf, "int:jit") == 0) {

        executionMode = kEMJitCompiler;

#endif

    }

 

    property_get("dalvik.vm.stack-trace-file", stackTraceFileBuf, "");

 

    property_get("dalvik.vm.check-dex-sum", propBuf, "");

    if (strcmp(propBuf, "true") == 0) {

        checkDexSum = true;

    }

 

    property_get("log.redirect-stdio", propBuf, "");

    if (strcmp(propBuf, "true") == 0) {

        logStdio = true;

    }

 

    strcpy(enableAssertBuf, "-ea:");

    property_get("dalvik.vm.enableassertions", enableAssertBuf+4, "");

 

    strcpy(jniOptsBuf, "-Xjniopts:");

    property_get("dalvik.vm.jniopts", jniOptsBuf+10, "");

 

    /* route exit() to our handler */

    opt.extraInfo = (void*) runtime_exit;

    opt.optionString = "exit";

    mOptions.add(opt);

 

    /* route fprintf() to our handler */

    opt.extraInfo = (void*) runtime_vfprintf;

    opt.optionString = "vfprintf";

    mOptions.add(opt);

 

    /* register the framework-specific "is sensitive thread" hook */

    opt.extraInfo = (void*) runtime_isSensitiveThread;

    opt.optionString = "sensitiveThread";

    mOptions.add(opt);

 

    opt.extraInfo = NULL;

 

    /* enable verbose; standard options are { jni, gc, class } */

    //options[curOpt++].optionString = "-verbose:jni";

    opt.optionString = "-verbose:gc";

    mOptions.add(opt);

    //options[curOpt++].optionString = "-verbose:class";

 

    /*

     * The default starting and maximum size of the heap.  Larger

     * values should be specified in a product property override.

     */

    strcpy(heapstartsizeOptsBuf, "-Xms");

    property_get("dalvik.vm.heapstartsize", heapstartsizeOptsBuf+4, "4m");

    opt.optionString = heapstartsizeOptsBuf;

    mOptions.add(opt);

    strcpy(heapsizeOptsBuf, "-Xmx");

    property_get("dalvik.vm.heapsize", heapsizeOptsBuf+4, "16m");

    opt.optionString = heapsizeOptsBuf;

    mOptions.add(opt);

 

    strcpy(heapgrowthlimitOptsBuf, "-XX:HeapGrowthLimit=");

    property_get("dalvik.vm.heapgrowthlimit", heapgrowthlimitOptsBuf+20, "");

    if (heapgrowthlimitOptsBuf[20] != '\0') {

        opt.optionString = heapgrowthlimitOptsBuf;

        mOptions.add(opt);

    }

 

    /*

     * Enable or disable dexopt features, such as bytecode verification and

     * calculation of register maps for precise GC.

     */

    property_get("dalvik.vm.dexopt-flags", dexoptFlagsBuf, "");

    if (dexoptFlagsBuf[0] != '\0') {

        const char* opc;

        const char* val;

 

        opc = strstr(dexoptFlagsBuf, "v=");     /* verification */

        if (opc != NULL) {

            switch (*(opc+2)) {

            case 'n':   val = "-Xverify:none";      break;

            case 'r':   val = "-Xverify:remote";    break;

            case 'a':   val = "-Xverify:all";       break;

            default:    val = NULL;                 break;

            }

 

            if (val != NULL) {

                opt.optionString = val;

                mOptions.add(opt);

            }

        }

 

        opc = strstr(dexoptFlagsBuf, "o=");     /* optimization */

        if (opc != NULL) {

            switch (*(opc+2)) {

            case 'n':   val = "-Xdexopt:none";      break;

            case 'v':   val = "-Xdexopt:verified";  break;

            case 'a':   val = "-Xdexopt:all";       break;

            case 'f':   val = "-Xdexopt:full";      break;

            default:    val = NULL;                 break;

            }

 

            if (val != NULL) {

                opt.optionString = val;

                mOptions.add(opt);

            }

        }

 

        opc = strstr(dexoptFlagsBuf, "m=y");    /* register map */

        if (opc != NULL) {

            opt.optionString = "-Xgenregmap";

            mOptions.add(opt);

 

            /* turn on precise GC while we're at it */

            opt.optionString = "-Xgc:precise";

            mOptions.add(opt);

        }

    }

 

    /* enable debugging; set suspend=y to pause during VM init */

    /* use android ADB transport */

    opt.optionString =

        "-agentlib:jdwp=transport=dt_android_adb,suspend=n,server=y";

    mOptions.add(opt);

 

    LOGD("CheckJNI is %s\n", checkJni ? "ON" : "OFF");

    if (checkJni) {

        /* extended JNI checking */

        opt.optionString = "-Xcheck:jni";

        mOptions.add(opt);

 

        /* set a cap on JNI global references */

        opt.optionString = "-Xjnigreflimit:2000";

        mOptions.add(opt);

 

        /* with -Xcheck:jni, this provides a JNI function call trace */

        //opt.optionString = "-verbose:jni";

        //mOptions.add(opt);

    }

 

    char lockProfThresholdBuf[sizeof("-Xlockprofthreshold:") + sizeof(propBuf)];

    property_get("dalvik.vm.lockprof.threshold", propBuf, "");

    if (strlen(propBuf) > 0) {

      strcpy(lockProfThresholdBuf, "-Xlockprofthreshold:");

      strcat(lockProfThresholdBuf, propBuf);

      opt.optionString = lockProfThresholdBuf;

      mOptions.add(opt);

    }

 

#if defined(WITH_JIT)

    /* Force interpreter-only mode for selected opcodes. Eg "1-0a,3c,f1-ff" */

    char jitOpBuf[sizeof("-Xjitop:") + PROPERTY_VALUE_MAX];

    property_get("dalvik.vm.jit.op", propBuf, "");

    if (strlen(propBuf) > 0) {

        strcpy(jitOpBuf, "-Xjitop:");

        strcat(jitOpBuf, propBuf);

        opt.optionString = jitOpBuf;

        mOptions.add(opt);

    }

 

    /* Force interpreter-only mode for selected methods */

    char jitMethodBuf[sizeof("-Xjitmethod:") + PROPERTY_VALUE_MAX];

    property_get("dalvik.vm.jit.method", propBuf, "");

    if (strlen(propBuf) > 0) {

        strcpy(jitMethodBuf, "-Xjitmethod:");

        strcat(jitMethodBuf, propBuf);

        opt.optionString = jitMethodBuf;

        mOptions.add(opt);

    }

#endif

 

    if (executionMode == kEMIntPortable) {

        opt.optionString = "-Xint:portable";

        mOptions.add(opt);

    } else if (executionMode == kEMIntFast) {

        opt.optionString = "-Xint:fast";

        mOptions.add(opt);

#if defined(WITH_JIT)

    } else if (executionMode == kEMJitCompiler) {

        opt.optionString = "-Xint:jit";

        mOptions.add(opt);

#endif

    }

 

    if (checkDexSum) {

        /* perform additional DEX checksum tests */

        opt.optionString = "-Xcheckdexsum";

        mOptions.add(opt);

    }

 

    if (logStdio) {

        /* convert stdout/stderr to log messages */

        opt.optionString = "-Xlog-stdio";

        mOptions.add(opt);

    }

 

    if (enableAssertBuf[4] != '\0') {

        /* accept "all" to mean "all classes and packages" */

        if (strcmp(enableAssertBuf+4, "all") == 0)

            enableAssertBuf[3] = '\0';

        LOGI("Assertions enabled: '%s'\n", enableAssertBuf);

        opt.optionString = enableAssertBuf;

        mOptions.add(opt);

    } else {

        LOGV("Assertions disabled\n");

    }

 

    if (jniOptsBuf[10] != '\0') {

        LOGI("JNI options: '%s'\n", jniOptsBuf);

        opt.optionString = jniOptsBuf;

        mOptions.add(opt);

    }

 

    if (stackTraceFileBuf[0] != '\0') {

        static const char* stfOptName = "-Xstacktracefile:";

 

        stackTraceFile = (char*) malloc(strlen(stfOptName) +

            strlen(stackTraceFileBuf) +1);

        strcpy(stackTraceFile, stfOptName);

        strcat(stackTraceFile, stackTraceFileBuf);

        opt.optionString = stackTraceFile;

        mOptions.add(opt);

    }

 

    /* extra options; parse this late so it overrides others */

    property_get("dalvik.vm.extra-opts", extraOptsBuf, "");

    parseExtraOpts(extraOptsBuf);

 

    /* Set the properties for locale */

    {

        char langOption[sizeof("-Duser.language=") + 3];

        char regionOption[sizeof("-Duser.region=") + 3];

        strcpy(langOption, "-Duser.language=");

        strcpy(regionOption, "-Duser.region=");

        readLocale(langOption, regionOption);

        opt.extraInfo = NULL;

        opt.optionString = langOption;

        mOptions.add(opt);

        opt.optionString = regionOption;

        mOptions.add(opt);

    }

 

    /*

     * We don't have /tmp on the device, but we often have an SD card.  Apps

     * shouldn't use this, but some test suites might want to exercise it.

     */

    opt.optionString = "-Djava.io.tmpdir=/sdcard";

    mOptions.add(opt);

 

    initArgs.version = JNI_VERSION_1_4;

    initArgs.options = mOptions.editArray();

    initArgs.nOptions = mOptions.size();

    initArgs.ignoreUnrecognized = JNI_FALSE;

 

    /*

     * Initialize the VM.

     *

     * The JavaVM* is essentially per-process, and the JNIEnv* is per-thread.

     * If this call succeeds, the VM is ready, and we can start issuing

     * JNI calls.

     */

    if (JNI_CreateJavaVM(pJavaVM, pEnv, &initArgs) < 0) {

        LOGE("JNI_CreateJavaVM failed\n");

        goto bail;

    }

 

    result = 0;

 

bail:

    free(stackTraceFile);

    return result;

}