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;

}

更多相关文章

随机推荐