1 /* //device/libs/android_runtime/AndroidRuntime.cpp
2 **
3 ** Copyright 2006, The Android Open Source Project
4 **
5 ** Licensed under the Apache License, Version 2.0 (the "License");
6 ** you may not use this file except in compliance with the License.
7 ** You may obtain a copy of the License at
8 **
9 ** http://www.apache.org/licenses/LICENSE-2.0
10 **
11 ** Unless required by applicable law or agreed to in writing, software
12 ** distributed under the License is distributed on an "AS IS" BASIS,
13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 ** See the License for the specific language governing permissions and
15 ** limitations under the License.
16 */
17
18 #define LOG_TAG "AndroidRuntime"
19 //#define LOG_NDEBUG 0
20
21 #include <android_runtime/AndroidRuntime.h>
22 #include <binder/IBinder.h>
23 #include <binder/IServiceManager.h>
24 #include <utils/Log.h>
25 #include <utils/misc.h>
26 #include <binder/Parcel.h>
27 #include <utils/StringArray.h>
28 #include <utils/threads.h>
29 #include <cutils/properties.h>
30
31 #include <SkGraphics.h>
32 #include <SkImageDecoder.h>
33 #include <SkImageRef_GlobalPool.h>
34
35 #include "jni.h"
36 #include "JNIHelp.h"
37 #include "android_util_Binder.h"
38
39 #include <stdio.h>
40 #include <signal.h>
41 #include <sys/stat.h>
42 #include <sys/types.h>
43 #include <signal.h>
44 #include <dirent.h>
45 #include <assert.h>
46
47
48 using namespace android;
49
50 extern void register_BindTest();
51
52 extern int register_android_os_Binder(JNIEnv* env);
53 extern int register_android_os_Process(JNIEnv* env);
54 extern int register_android_graphics_Bitmap(JNIEnv*);
55 extern int register_android_graphics_BitmapFactory(JNIEnv*);
56 extern int register_android_graphics_Camera(JNIEnv* env);
57 extern int register_android_graphics_Graphics(JNIEnv* env);
58 extern int register_android_graphics_Interpolator(JNIEnv* env);
59 extern int register_android_graphics_LayerRasterizer(JNIEnv*);
60 extern int register_android_graphics_MaskFilter(JNIEnv* env);
61 extern int register_android_graphics_Movie(JNIEnv* env);
62 extern int register_android_graphics_NinePatch(JNIEnv*);
63 extern int register_android_graphics_PathEffect(JNIEnv* env);
64 extern int register_android_graphics_Region(JNIEnv* env);
65 extern int register_android_graphics_Shader(JNIEnv* env);
66 extern int register_android_graphics_Typeface(JNIEnv* env);
67
68 extern int register_com_google_android_gles_jni_EGLImpl(JNIEnv* env);
69 extern int register_com_google_android_gles_jni_GLImpl(JNIEnv* env);
70 extern int register_android_opengl_jni_GLES10(JNIEnv* env);
71 extern int register_android_opengl_jni_GLES10Ext(JNIEnv* env);
72 extern int register_android_opengl_jni_GLES11(JNIEnv* env);
73 extern int register_android_opengl_jni_GLES11Ext(JNIEnv* env);
74
75 extern int register_android_hardware_Camera(JNIEnv *env);
76
77 extern int register_android_hardware_SensorManager(JNIEnv *env);
78
79 extern int register_android_media_AudioRecord(JNIEnv *env);
80 extern int register_android_media_AudioSystem(JNIEnv *env);
81 extern int register_android_media_AudioTrack(JNIEnv *env);
82 extern int register_android_media_JetPlayer(JNIEnv *env);
83 extern int register_android_media_ToneGenerator(JNIEnv *env);
84
85 extern int register_android_message_digest_sha1(JNIEnv *env);
86
87 extern int register_android_util_FloatMath(JNIEnv* env);
88
89 namespace android {
90
91 /*
92 * JNI-based registration functions. Note these are properly contained in
93 * namespace android.
94 */
95 extern int register_android_content_AssetManager(JNIEnv* env);
96 extern int register_android_util_EventLog(JNIEnv* env);
97 extern int register_android_util_Log(JNIEnv* env);
98 extern int register_android_content_StringBlock(JNIEnv* env);
99 extern int register_android_content_XmlBlock(JNIEnv* env);
100 extern int register_android_emoji_EmojiFactory(JNIEnv* env);
101 extern int register_android_graphics_Canvas(JNIEnv* env);
102 extern int register_android_graphics_ColorFilter(JNIEnv* env);
103 extern int register_android_graphics_DrawFilter(JNIEnv* env);
104 extern int register_android_graphics_Matrix(JNIEnv* env);
105 extern int register_android_graphics_Paint(JNIEnv* env);
106 extern int register_android_graphics_Path(JNIEnv* env);
107 extern int register_android_graphics_PathMeasure(JNIEnv* env);
108 extern int register_android_graphics_Picture(JNIEnv*);
109 extern int register_android_graphics_PorterDuff(JNIEnv* env);
110 extern int register_android_graphics_Rasterizer(JNIEnv* env);
111 extern int register_android_graphics_Xfermode(JNIEnv* env);
112 extern int register_android_graphics_PixelFormat(JNIEnv* env);
113 extern int register_com_android_internal_graphics_NativeUtils(JNIEnv *env);
114 extern int register_android_view_Display(JNIEnv* env);
115 extern int register_android_view_Surface(JNIEnv* env);
116 extern int register_android_view_ViewRoot(JNIEnv* env);
117 extern int register_android_database_CursorWindow(JNIEnv* env);
118 extern int register_android_database_SQLiteDatabase(JNIEnv* env);
119 extern int register_android_database_SQLiteDebug(JNIEnv* env);
120 extern int register_android_database_SQLiteProgram(JNIEnv* env);
121 extern int register_android_database_SQLiteQuery(JNIEnv* env);
122 extern int register_android_database_SQLiteStatement(JNIEnv* env);
123 extern int register_android_debug_JNITest(JNIEnv* env);
124 extern int register_android_nio_utils(JNIEnv* env);
125 extern int register_android_pim_EventRecurrence(JNIEnv* env);
126 extern int register_android_text_format_Time(JNIEnv* env);
127 extern int register_android_os_Debug(JNIEnv* env);
128 extern int register_android_os_ParcelFileDescriptor(JNIEnv *env);
129 extern int register_android_os_Power(JNIEnv *env);
130 extern int register_android_os_StatFs(JNIEnv *env);
131 extern int register_android_os_SystemProperties(JNIEnv *env);
132 extern int register_android_os_Hardware(JNIEnv* env);
133 extern int register_android_os_SystemClock(JNIEnv* env);
134 extern int register_android_os_FileObserver(JNIEnv *env);
135 extern int register_android_os_FileUtils(JNIEnv *env);
136 extern int register_android_os_UEventObserver(JNIEnv* env);
137 extern int register_android_os_MemoryFile(JNIEnv* env);
138 extern int register_android_net_LocalSocketImpl(JNIEnv* env);
139 extern int register_android_net_NetworkUtils(JNIEnv* env);
140 extern int register_android_net_wifi_WifiManager(JNIEnv* env);
141 extern int register_android_security_Md5MessageDigest(JNIEnv *env);
142 extern int register_android_text_AndroidCharacter(JNIEnv *env);
143 extern int register_android_text_KeyCharacterMap(JNIEnv *env);
144 extern int register_android_opengl_classes(JNIEnv *env);
145 extern int register_android_bluetooth_HeadsetBase(JNIEnv* env);
146 extern int register_android_bluetooth_BluetoothAudioGateway(JNIEnv* env);
147 extern int register_android_bluetooth_BluetoothSocket(JNIEnv *env);
148 extern int register_android_bluetooth_ScoSocket(JNIEnv *env);
149 extern int register_android_server_BluetoothService(JNIEnv* env);
150 extern int register_android_server_BluetoothEventLoop(JNIEnv *env);
151 extern int register_android_server_BluetoothA2dpService(JNIEnv* env);
152 extern int register_android_ddm_DdmHandleNativeHeap(JNIEnv *env);
153 extern int register_com_android_internal_os_ZygoteInit(JNIEnv* env);
154 extern int register_android_util_Base64(JNIEnv* env);
155 extern int register_android_location_GpsLocationProvider(JNIEnv* env);
156 extern int register_android_backup_BackupDataInput(JNIEnv *env);
157 extern int register_android_backup_BackupDataOutput(JNIEnv *env);
158 extern int register_android_backup_FileBackupHelperBase(JNIEnv *env);
159 extern int register_android_backup_BackupHelperDispatcher(JNIEnv *env);
160
161 static AndroidRuntime* gCurRuntime = NULL;
162
doThrow(JNIEnv * env,const char * exc,const char * msg=NULL)163 static void doThrow(JNIEnv* env, const char* exc, const char* msg = NULL)
164 {
165 if (jniThrowException(env, exc, msg) != 0)
166 assert(false);
167 }
168
169 /*
170 * Code written in the Java Programming Language calls here from main().
171 */
com_android_internal_os_RuntimeInit_finishInit(JNIEnv * env,jobject clazz)172 static void com_android_internal_os_RuntimeInit_finishInit(JNIEnv* env, jobject clazz)
173 {
174 gCurRuntime->onStarted();
175 }
176
com_android_internal_os_RuntimeInit_zygoteInit(JNIEnv * env,jobject clazz)177 static void com_android_internal_os_RuntimeInit_zygoteInit(JNIEnv* env, jobject clazz)
178 {
179 gCurRuntime->onZygoteInit();
180 }
181
com_android_internal_os_RuntimeInit_isComputerOn(JNIEnv * env,jobject clazz)182 static jint com_android_internal_os_RuntimeInit_isComputerOn(JNIEnv* env, jobject clazz)
183 {
184 return 1;
185 }
186
com_android_internal_os_RuntimeInit_turnComputerOn(JNIEnv * env,jobject clazz)187 static void com_android_internal_os_RuntimeInit_turnComputerOn(JNIEnv* env, jobject clazz)
188 {
189 }
190
com_android_internal_os_RuntimeInit_getQwertyKeyboard(JNIEnv * env,jobject clazz)191 static jint com_android_internal_os_RuntimeInit_getQwertyKeyboard(JNIEnv* env, jobject clazz)
192 {
193 char* value = getenv("qwerty");
194 if (value != NULL && strcmp(value, "true") == 0) {
195 return 1;
196 }
197
198 return 0;
199 }
200
201 /*
202 * JNI registration.
203 */
204 static JNINativeMethod gMethods[] = {
205 { "finishInit", "()V",
206 (void*) com_android_internal_os_RuntimeInit_finishInit },
207 { "zygoteInitNative", "()V",
208 (void*) com_android_internal_os_RuntimeInit_zygoteInit },
209 { "isComputerOn", "()I",
210 (void*) com_android_internal_os_RuntimeInit_isComputerOn },
211 { "turnComputerOn", "()V",
212 (void*) com_android_internal_os_RuntimeInit_turnComputerOn },
213 { "getQwertyKeyboard", "()I",
214 (void*) com_android_internal_os_RuntimeInit_getQwertyKeyboard },
215 };
216
register_com_android_internal_os_RuntimeInit(JNIEnv * env)217 int register_com_android_internal_os_RuntimeInit(JNIEnv* env)
218 {
219 return jniRegisterNativeMethods(env, "com/android/internal/os/RuntimeInit",
220 gMethods, NELEM(gMethods));
221 }
222
223 // ----------------------------------------------------------------------
224
225 /*static*/ JavaVM* AndroidRuntime::mJavaVM = NULL;
226
227
AndroidRuntime()228 AndroidRuntime::AndroidRuntime()
229 {
230 SkGraphics::Init();
231 // this sets our preference for 16bit images during decode
232 // in case the src is opaque and 24bit
233 SkImageDecoder::SetDeviceConfig(SkBitmap::kRGB_565_Config);
234 // This cache is shared between browser native images, and java "purgeable"
235 // bitmaps. This globalpool is for images that do not either use the java
236 // heap, or are not backed by ashmem. See BitmapFactory.cpp for the key
237 // java call site.
238 SkImageRef_GlobalPool::SetRAMBudget(512 * 1024);
239 // There is also a global font cache, but its budget is specified in code
240 // see SkFontHost_android.cpp
241
242 // Pre-allocate enough space to hold a fair number of options.
243 mOptions.setCapacity(20);
244
245 assert(gCurRuntime == NULL); // one per process
246 gCurRuntime = this;
247 }
248
~AndroidRuntime()249 AndroidRuntime::~AndroidRuntime()
250 {
251 SkGraphics::Term();
252 }
253
254 /*
255 * Register native methods using JNI.
256 */
registerNativeMethods(JNIEnv * env,const char * className,const JNINativeMethod * gMethods,int numMethods)257 /*static*/ int AndroidRuntime::registerNativeMethods(JNIEnv* env,
258 const char* className, const JNINativeMethod* gMethods, int numMethods)
259 {
260 return jniRegisterNativeMethods(env, className, gMethods, numMethods);
261 }
262
263 /*
264 * Call a static Java Programming Language function that takes no arguments and returns void.
265 */
callStatic(const char * className,const char * methodName)266 status_t AndroidRuntime::callStatic(const char* className, const char* methodName)
267 {
268 JNIEnv* env;
269 jclass clazz;
270 jmethodID methodId;
271
272 env = getJNIEnv();
273 if (env == NULL)
274 return UNKNOWN_ERROR;
275
276 clazz = findClass(env, className);
277 if (clazz == NULL) {
278 LOGE("ERROR: could not find class '%s'\n", className);
279 return UNKNOWN_ERROR;
280 }
281 methodId = env->GetStaticMethodID(clazz, methodName, "()V");
282 if (methodId == NULL) {
283 LOGE("ERROR: could not find method %s.%s\n", className, methodName);
284 return UNKNOWN_ERROR;
285 }
286
287 env->CallStaticVoidMethod(clazz, methodId);
288
289 return NO_ERROR;
290 }
291
callMain(const char * className,int argc,const char * const argv[])292 status_t AndroidRuntime::callMain(
293 const char* className, int argc, const char* const argv[])
294 {
295 JNIEnv* env;
296 jclass clazz;
297 jmethodID methodId;
298
299 env = getJNIEnv();
300 if (env == NULL)
301 return UNKNOWN_ERROR;
302
303 clazz = findClass(env, className);
304 if (clazz == NULL) {
305 LOGE("ERROR: could not find class '%s'\n", className);
306 return UNKNOWN_ERROR;
307 }
308
309 methodId = env->GetStaticMethodID(clazz, "main", "([Ljava/lang/String;)V");
310 if (methodId == NULL) {
311 LOGE("ERROR: could not find method %s.main(String[])\n", className);
312 return UNKNOWN_ERROR;
313 }
314
315 /*
316 * We want to call main() with a String array with our arguments in it.
317 * Create an array and populate it.
318 */
319 jclass stringClass;
320 jobjectArray strArray;
321
322 stringClass = env->FindClass("java/lang/String");
323 strArray = env->NewObjectArray(argc, stringClass, NULL);
324
325 for (int i = 0; i < argc; i++) {
326 jstring argStr = env->NewStringUTF(argv[i]);
327 env->SetObjectArrayElement(strArray, i, argStr);
328 }
329
330 env->CallStaticVoidMethod(clazz, methodId, strArray);
331 return NO_ERROR;
332 }
333
334 /*
335 * Find the named class.
336 */
findClass(JNIEnv * env,const char * className)337 jclass AndroidRuntime::findClass(JNIEnv* env, const char* className)
338 {
339 char* convName = NULL;
340
341 if (env->ExceptionCheck()) {
342 LOGE("ERROR: exception pending on entry to findClass()\n");
343 return NULL;
344 }
345
346 /*
347 * JNI FindClass uses class names with slashes, but ClassLoader.loadClass
348 * uses the dotted "binary name" format. We don't need to convert the
349 * name with the new approach.
350 */
351 #if 0
352 /* (convName only created if necessary -- use className) */
353 for (char* cp = const_cast<char*>(className); *cp != '\0'; cp++) {
354 if (*cp == '.') {
355 if (convName == NULL) {
356 convName = strdup(className);
357 cp = convName + (cp-className);
358 className = convName;
359 }
360 *cp = '/';
361 }
362 }
363 #endif
364
365 /*
366 * This is a little awkward because the JNI FindClass call uses the
367 * class loader associated with the native method we're executing in.
368 * Because this native method is part of a "boot" class, JNI doesn't
369 * look for the class in CLASSPATH, which unfortunately is a likely
370 * location for it. (Had we issued the FindClass call before calling
371 * into the VM -- at which point there isn't a native method frame on
372 * the stack -- the VM would have checked CLASSPATH. We have to do
373 * this because we call into Java Programming Language code and
374 * bounce back out.)
375 *
376 * JNI lacks a "find class in a specific class loader" operation, so we
377 * have to do things the hard way.
378 */
379 jclass cls = NULL;
380 //cls = env->FindClass(className);
381
382 jclass javaLangClassLoader;
383 jmethodID getSystemClassLoader, loadClass;
384 jobject systemClassLoader;
385 jstring strClassName;
386
387 /* find the "system" class loader; none of this is expected to fail */
388 javaLangClassLoader = env->FindClass("java/lang/ClassLoader");
389 assert(javaLangClassLoader != NULL);
390 getSystemClassLoader = env->GetStaticMethodID(javaLangClassLoader,
391 "getSystemClassLoader", "()Ljava/lang/ClassLoader;");
392 loadClass = env->GetMethodID(javaLangClassLoader,
393 "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;");
394 assert(getSystemClassLoader != NULL && loadClass != NULL);
395 systemClassLoader = env->CallStaticObjectMethod(javaLangClassLoader,
396 getSystemClassLoader);
397 assert(systemClassLoader != NULL);
398
399 /* create an object for the class name string; alloc could fail */
400 strClassName = env->NewStringUTF(className);
401 if (env->ExceptionCheck()) {
402 LOGE("ERROR: unable to convert '%s' to string\n", className);
403 goto bail;
404 }
405 LOGV("system class loader is %p, loading %p (%s)\n",
406 systemClassLoader, strClassName, className);
407
408 /* try to find the named class */
409 cls = (jclass) env->CallObjectMethod(systemClassLoader, loadClass,
410 strClassName);
411 if (env->ExceptionCheck()) {
412 LOGE("ERROR: unable to load class '%s' from %p\n",
413 className, systemClassLoader);
414 cls = NULL;
415 goto bail;
416 }
417
418 bail:
419 free(convName);
420 return cls;
421 }
422
423 /*
424 * The VM calls this through the "exit" hook.
425 */
runtime_exit(int code)426 static void runtime_exit(int code)
427 {
428 gCurRuntime->onExit(code);
429 exit(code);
430 }
431
432 /*
433 * The VM calls this through the "vfprintf" hook.
434 *
435 * We ignore "fp" and just write the results to the log file.
436 */
runtime_vfprintf(FILE * fp,const char * format,va_list ap)437 static void runtime_vfprintf(FILE* fp, const char* format, va_list ap)
438 {
439 LOG_PRI_VA(ANDROID_LOG_INFO, "vm-printf", format, ap);
440 }
441
442
443 /**
444 * Add VM arguments to the to-be-executed VM
445 * Stops at first non '-' argument (also stops at an argument of '--')
446 * Returns the number of args consumed
447 */
addVmArguments(int argc,const char * const argv[])448 int AndroidRuntime::addVmArguments(int argc, const char* const argv[])
449 {
450 int i;
451
452 for (i = 0; i<argc; i++) {
453 if (argv[i][0] != '-') {
454 return i;
455 }
456 if (argv[i][1] == '-' && argv[i][2] == 0) {
457 return i+1;
458 }
459
460 JavaVMOption opt;
461 memset(&opt, 0, sizeof(opt));
462 opt.optionString = (char*)argv[i];
463 mOptions.add(opt);
464 }
465 return i;
466 }
467
hasDir(const char * dir)468 static int hasDir(const char* dir)
469 {
470 struct stat s;
471 int res = stat(dir, &s);
472 if (res == 0) {
473 return S_ISDIR(s.st_mode);
474 }
475 return 0;
476 }
477
478 /*
479 * We just want failed write() calls to just return with an error.
480 */
blockSigpipe()481 static void blockSigpipe()
482 {
483 sigset_t mask;
484
485 sigemptyset(&mask);
486 sigaddset(&mask, SIGPIPE);
487 if (sigprocmask(SIG_BLOCK, &mask, NULL) != 0)
488 LOGW("WARNING: SIGPIPE not blocked\n");
489 }
490
491 /*
492 * Read the persistent locale.
493 */
readLocale(char * language,char * region)494 static void readLocale(char* language, char* region)
495 {
496 char propLang[PROPERTY_VALUE_MAX], propRegn[PROPERTY_VALUE_MAX];
497
498 property_get("persist.sys.language", propLang, "");
499 property_get("persist.sys.country", propRegn, "");
500 if (*propLang == 0 && *propRegn == 0) {
501 /* Set to ro properties, default is en_US */
502 property_get("ro.product.locale.language", propLang, "en");
503 property_get("ro.product.locale.region", propRegn, "US");
504 }
505 strncat(language, propLang, 2);
506 strncat(region, propRegn, 2);
507 //LOGD("language=%s region=%s\n", language, region);
508 }
509
510 /*
511 * Start the Dalvik Virtual Machine.
512 *
513 * Various arguments, most determined by system properties, are passed in.
514 * The "mOptions" vector is updated.
515 *
516 * Returns 0 on success.
517 */
startVm(JavaVM ** pJavaVM,JNIEnv ** pEnv)518 int AndroidRuntime::startVm(JavaVM** pJavaVM, JNIEnv** pEnv)
519 {
520 int result = -1;
521 JavaVMInitArgs initArgs;
522 JavaVMOption opt;
523 char propBuf[PROPERTY_VALUE_MAX];
524 char stackTraceFileBuf[PROPERTY_VALUE_MAX];
525 char dexoptFlagsBuf[PROPERTY_VALUE_MAX];
526 char enableAssertBuf[sizeof("-ea:")-1 + PROPERTY_VALUE_MAX];
527 char jniOptsBuf[sizeof("-Xjniopts:")-1 + PROPERTY_VALUE_MAX];
528 char heapsizeOptsBuf[sizeof("-Xmx")-1 + PROPERTY_VALUE_MAX];
529 char* stackTraceFile = NULL;
530 bool checkJni = false;
531 bool checkDexSum = false;
532 bool logStdio = false;
533 enum {
534 kEMDefault,
535 kEMIntPortable,
536 kEMIntFast,
537 #if defined(WITH_JIT)
538 kEMJitCompiler,
539 #endif
540 } executionMode = kEMDefault;
541
542
543 property_get("dalvik.vm.checkjni", propBuf, "");
544 if (strcmp(propBuf, "true") == 0) {
545 checkJni = true;
546 } else if (strcmp(propBuf, "false") != 0) {
547 /* property is neither true nor false; fall back on kernel parameter */
548 property_get("ro.kernel.android.checkjni", propBuf, "");
549 if (propBuf[0] == '1') {
550 checkJni = true;
551 }
552 }
553
554 property_get("dalvik.vm.execution-mode", propBuf, "");
555 if (strcmp(propBuf, "int:portable") == 0) {
556 executionMode = kEMIntPortable;
557 } else if (strcmp(propBuf, "int:fast") == 0) {
558 executionMode = kEMIntFast;
559 #if defined(WITH_JIT)
560 } else if (strcmp(propBuf, "int:jit") == 0) {
561 executionMode = kEMJitCompiler;
562 #endif
563 }
564
565 property_get("dalvik.vm.stack-trace-file", stackTraceFileBuf, "");
566
567 property_get("dalvik.vm.check-dex-sum", propBuf, "");
568 if (strcmp(propBuf, "true") == 0) {
569 checkDexSum = true;
570 }
571
572 property_get("log.redirect-stdio", propBuf, "");
573 if (strcmp(propBuf, "true") == 0) {
574 logStdio = true;
575 }
576
577 strcpy(enableAssertBuf, "-ea:");
578 property_get("dalvik.vm.enableassertions", enableAssertBuf+4, "");
579
580 strcpy(jniOptsBuf, "-Xjniopts:");
581 property_get("dalvik.vm.jniopts", jniOptsBuf+10, "");
582
583 /* route exit() to our handler */
584 opt.extraInfo = (void*) runtime_exit;
585 opt.optionString = "exit";
586 mOptions.add(opt);
587
588 /* route fprintf() to our handler */
589 opt.extraInfo = (void*) runtime_vfprintf;
590 opt.optionString = "vfprintf";
591 mOptions.add(opt);
592
593 opt.extraInfo = NULL;
594
595 /* enable verbose; standard options are { jni, gc, class } */
596 //options[curOpt++].optionString = "-verbose:jni";
597 opt.optionString = "-verbose:gc";
598 mOptions.add(opt);
599 //options[curOpt++].optionString = "-verbose:class";
600
601 strcpy(heapsizeOptsBuf, "-Xmx");
602 property_get("dalvik.vm.heapsize", heapsizeOptsBuf+4, "16m");
603 //LOGI("Heap size: %s", heapsizeOptsBuf);
604 opt.optionString = heapsizeOptsBuf;
605 mOptions.add(opt);
606
607 /*
608 * Enable or disable dexopt features, such as bytecode verification and
609 * calculation of register maps for precise GC.
610 */
611 property_get("dalvik.vm.dexopt-flags", dexoptFlagsBuf, "");
612 if (dexoptFlagsBuf[0] != '\0') {
613 const char* opc;
614 const char* val;
615
616 opc = strstr(dexoptFlagsBuf, "v="); /* verification */
617 if (opc != NULL) {
618 switch (*(opc+2)) {
619 case 'n': val = "-Xverify:none"; break;
620 case 'r': val = "-Xverify:remote"; break;
621 case 'a': val = "-Xverify:all"; break;
622 default: val = NULL; break;
623 }
624
625 if (val != NULL) {
626 opt.optionString = val;
627 mOptions.add(opt);
628 }
629 }
630
631 opc = strstr(dexoptFlagsBuf, "o="); /* optimization */
632 if (opc != NULL) {
633 switch (*(opc+2)) {
634 case 'n': val = "-Xdexopt:none"; break;
635 case 'v': val = "-Xdexopt:verified"; break;
636 case 'a': val = "-Xdexopt:all"; break;
637 default: val = NULL; break;
638 }
639
640 if (val != NULL) {
641 opt.optionString = val;
642 mOptions.add(opt);
643 }
644 }
645
646 opc = strstr(dexoptFlagsBuf, "m=y"); /* register map */
647 if (opc != NULL) {
648 opt.optionString = "-Xgenregmap";
649 mOptions.add(opt);
650
651 /* turn on precise GC while we're at it */
652 opt.optionString = "-Xgc:precise";
653 mOptions.add(opt);
654 }
655 }
656
657 /* enable debugging; set suspend=y to pause during VM init */
658 #ifdef HAVE_ANDROID_OS
659 /* use android ADB transport */
660 opt.optionString =
661 "-agentlib:jdwp=transport=dt_android_adb,suspend=n,server=y";
662 #else
663 /* use TCP socket; address=0 means start at port 8000 and probe up */
664 LOGI("Using TCP socket for JDWP\n");
665 opt.optionString =
666 "-agentlib:jdwp=transport=dt_socket,suspend=n,server=y,address=0";
667 #endif
668 mOptions.add(opt);
669
670 char enableDPBuf[sizeof("-Xdeadlockpredict:") + PROPERTY_VALUE_MAX];
671 property_get("dalvik.vm.deadlock-predict", propBuf, "");
672 if (strlen(propBuf) > 0) {
673 strcpy(enableDPBuf, "-Xdeadlockpredict:");
674 strcat(enableDPBuf, propBuf);
675 opt.optionString = enableDPBuf;
676 mOptions.add(opt);
677 }
678
679 LOGD("CheckJNI is %s\n", checkJni ? "ON" : "OFF");
680 if (checkJni) {
681 /* extended JNI checking */
682 opt.optionString = "-Xcheck:jni";
683 mOptions.add(opt);
684
685 /* set a cap on JNI global references */
686 opt.optionString = "-Xjnigreflimit:2000";
687 mOptions.add(opt);
688
689 /* with -Xcheck:jni, this provides a JNI function call trace */
690 //opt.optionString = "-verbose:jni";
691 //mOptions.add(opt);
692 }
693
694 #if defined(WITH_JIT)
695 /* Minimal profile threshold to trigger JIT compilation */
696 char jitThresholdBuf[sizeof("-Xthreshold:") + PROPERTY_VALUE_MAX];
697 property_get("dalvik.vm.jit.threshold", propBuf, "");
698 if (strlen(propBuf) > 0) {
699 strcpy(jitThresholdBuf, "-Xthreshold:");
700 strcat(jitThresholdBuf, propBuf);
701 opt.optionString = jitThresholdBuf;
702 mOptions.add(opt);
703 }
704
705 /* Force interpreter-only mode for selected opcodes. Eg "1-0a,3c,f1-ff" */
706 char jitOpBuf[sizeof("-Xjitop:") + PROPERTY_VALUE_MAX];
707 property_get("dalvik.vm.jit.op", propBuf, "");
708 if (strlen(propBuf) > 0) {
709 strcpy(jitOpBuf, "-Xjitop:");
710 strcat(jitOpBuf, propBuf);
711 opt.optionString = jitOpBuf;
712 mOptions.add(opt);
713 }
714
715 /*
716 * Reverse the polarity of dalvik.vm.jit.op and force interpreter-only
717 * for non-selected opcodes.
718 */
719 property_get("dalvik.vm.jit.includeop", propBuf, "");
720 if (strlen(propBuf) > 0) {
721 opt.optionString = "-Xincludeselectedop";
722 mOptions.add(opt);
723 }
724
725 /* Force interpreter-only mode for selected methods */
726 char jitMethodBuf[sizeof("-Xjitmethod:") + PROPERTY_VALUE_MAX];
727 property_get("dalvik.vm.jit.method", propBuf, "");
728 if (strlen(propBuf) > 0) {
729 strcpy(jitMethodBuf, "-Xjitmethod:");
730 strcat(jitMethodBuf, propBuf);
731 opt.optionString = jitMethodBuf;
732 mOptions.add(opt);
733 }
734
735 /*
736 * Reverse the polarity of dalvik.vm.jit.method and force interpreter-only
737 * for non-selected methods.
738 */
739 property_get("dalvik.vm.jit.includemethod", propBuf, "");
740 if (strlen(propBuf) > 0) {
741 opt.optionString = "-Xincludeselectedmethod";
742 mOptions.add(opt);
743 }
744
745 /*
746 * Enable profile collection on JIT'ed code.
747 */
748 property_get("dalvik.vm.jit.profile", propBuf, "");
749 if (strlen(propBuf) > 0) {
750 opt.optionString = "-Xjitprofile";
751 mOptions.add(opt);
752 }
753 #endif
754
755 if (executionMode == kEMIntPortable) {
756 opt.optionString = "-Xint:portable";
757 mOptions.add(opt);
758 } else if (executionMode == kEMIntFast) {
759 opt.optionString = "-Xint:fast";
760 mOptions.add(opt);
761 #if defined(WITH_JIT)
762 } else if (executionMode == kEMJitCompiler) {
763 opt.optionString = "-Xint:jit";
764 mOptions.add(opt);
765 #endif
766 }
767
768 if (checkDexSum) {
769 /* perform additional DEX checksum tests */
770 opt.optionString = "-Xcheckdexsum";
771 mOptions.add(opt);
772 }
773
774 if (logStdio) {
775 /* convert stdout/stderr to log messages */
776 opt.optionString = "-Xlog-stdio";
777 mOptions.add(opt);
778 }
779
780 if (enableAssertBuf[4] != '\0') {
781 /* accept "all" to mean "all classes and packages" */
782 if (strcmp(enableAssertBuf+4, "all") == 0)
783 enableAssertBuf[3] = '\0';
784 LOGI("Assertions enabled: '%s'\n", enableAssertBuf);
785 opt.optionString = enableAssertBuf;
786 mOptions.add(opt);
787 } else {
788 LOGV("Assertions disabled\n");
789 }
790
791 if (jniOptsBuf[10] != '\0') {
792 LOGI("JNI options: '%s'\n", jniOptsBuf);
793 opt.optionString = jniOptsBuf;
794 mOptions.add(opt);
795 }
796
797 if (stackTraceFileBuf[0] != '\0') {
798 static const char* stfOptName = "-Xstacktracefile:";
799
800 stackTraceFile = (char*) malloc(strlen(stfOptName) +
801 strlen(stackTraceFileBuf) +1);
802 strcpy(stackTraceFile, stfOptName);
803 strcat(stackTraceFile, stackTraceFileBuf);
804 opt.optionString = stackTraceFile;
805 mOptions.add(opt);
806 }
807
808 /* Set the properties for locale */
809 {
810 char langOption[sizeof("-Duser.language=") + 3];
811 char regionOption[sizeof("-Duser.region=") + 3];
812 strcpy(langOption, "-Duser.language=");
813 strcpy(regionOption, "-Duser.region=");
814 readLocale(langOption, regionOption);
815 opt.extraInfo = NULL;
816 opt.optionString = langOption;
817 mOptions.add(opt);
818 opt.optionString = regionOption;
819 mOptions.add(opt);
820 }
821
822 /*
823 * We don't have /tmp on the device, but we often have an SD card. Apps
824 * shouldn't use this, but some test suites might want to exercise it.
825 */
826 opt.optionString = "-Djava.io.tmpdir=/sdcard";
827 mOptions.add(opt);
828
829 initArgs.version = JNI_VERSION_1_4;
830 initArgs.options = mOptions.editArray();
831 initArgs.nOptions = mOptions.size();
832 initArgs.ignoreUnrecognized = JNI_FALSE;
833
834 /*
835 * Initialize the VM.
836 *
837 * The JavaVM* is essentially per-process, and the JNIEnv* is per-thread.
838 * If this call succeeds, the VM is ready, and we can start issuing
839 * JNI calls.
840 */
841 if (JNI_CreateJavaVM(pJavaVM, pEnv, &initArgs) < 0) {
842 LOGE("JNI_CreateJavaVM failed\n");
843 goto bail;
844 }
845
846 result = 0;
847
848 bail:
849 free(stackTraceFile);
850 return result;
851 }
852
853 /*
854 * Start the Android runtime. This involves starting the virtual machine
855 * and calling the "static void main(String[] args)" method in the class
856 * named by "className".
857 */
start(const char * className,const bool startSystemServer)858 void AndroidRuntime::start(const char* className, const bool startSystemServer)
859 {
860 LOGD("\n>>>>>>>>>>>>>> AndroidRuntime START <<<<<<<<<<<<<<\n");
861
862 char* slashClassName = NULL;
863 char* cp;
864 JNIEnv* env;
865
866 blockSigpipe();
867
868 /*
869 * 'startSystemServer == true' means runtime is obslete and not run from
870 * init.rc anymore, so we print out the boot start event here.
871 */
872 if (startSystemServer) {
873 /* track our progress through the boot sequence */
874 const int LOG_BOOT_PROGRESS_START = 3000;
875 LOG_EVENT_LONG(LOG_BOOT_PROGRESS_START,
876 ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
877 }
878
879 const char* rootDir = getenv("ANDROID_ROOT");
880 if (rootDir == NULL) {
881 rootDir = "/system";
882 if (!hasDir("/system")) {
883 LOG_FATAL("No root directory specified, and /android does not exist.");
884 goto bail;
885 }
886 setenv("ANDROID_ROOT", rootDir, 1);
887 }
888
889 //const char* kernelHack = getenv("LD_ASSUME_KERNEL");
890 //LOGD("Found LD_ASSUME_KERNEL='%s'\n", kernelHack);
891
892 /* start the virtual machine */
893 if (startVm(&mJavaVM, &env) != 0)
894 goto bail;
895
896 /*
897 * Register android functions.
898 */
899 if (startReg(env) < 0) {
900 LOGE("Unable to register all android natives\n");
901 goto bail;
902 }
903
904 /*
905 * We want to call main() with a String array with arguments in it.
906 * At present we only have one argument, the class name. Create an
907 * array to hold it.
908 */
909 jclass stringClass;
910 jobjectArray strArray;
911 jstring classNameStr;
912 jstring startSystemServerStr;
913
914 stringClass = env->FindClass("java/lang/String");
915 assert(stringClass != NULL);
916 strArray = env->NewObjectArray(2, stringClass, NULL);
917 assert(strArray != NULL);
918 classNameStr = env->NewStringUTF(className);
919 assert(classNameStr != NULL);
920 env->SetObjectArrayElement(strArray, 0, classNameStr);
921 startSystemServerStr = env->NewStringUTF(startSystemServer ?
922 "true" : "false");
923 env->SetObjectArrayElement(strArray, 1, startSystemServerStr);
924
925 /*
926 * Start VM. This thread becomes the main thread of the VM, and will
927 * not return until the VM exits.
928 */
929 jclass startClass;
930 jmethodID startMeth;
931
932 slashClassName = strdup(className);
933 for (cp = slashClassName; *cp != '\0'; cp++)
934 if (*cp == '.')
935 *cp = '/';
936
937 startClass = env->FindClass(slashClassName);
938 if (startClass == NULL) {
939 LOGE("JavaVM unable to locate class '%s'\n", slashClassName);
940 /* keep going */
941 } else {
942 startMeth = env->GetStaticMethodID(startClass, "main",
943 "([Ljava/lang/String;)V");
944 if (startMeth == NULL) {
945 LOGE("JavaVM unable to find main() in '%s'\n", className);
946 /* keep going */
947 } else {
948 env->CallStaticVoidMethod(startClass, startMeth, strArray);
949
950 #if 0
951 if (env->ExceptionCheck())
952 threadExitUncaughtException(env);
953 #endif
954 }
955 }
956
957 LOGD("Shutting down VM\n");
958 if (mJavaVM->DetachCurrentThread() != JNI_OK)
959 LOGW("Warning: unable to detach main thread\n");
960 if (mJavaVM->DestroyJavaVM() != 0)
961 LOGW("Warning: VM did not shut down cleanly\n");
962
963 bail:
964 free(slashClassName);
965 }
966
start()967 void AndroidRuntime::start()
968 {
969 start("com.android.internal.os.RuntimeInit",
970 false /* Don't start the system server */);
971 }
972
onExit(int code)973 void AndroidRuntime::onExit(int code)
974 {
975 LOGI("AndroidRuntime onExit calling exit(%d)", code);
976 exit(code);
977 }
978
979 /*
980 * Get the JNIEnv pointer for this thread.
981 *
982 * Returns NULL if the slot wasn't allocated or populated.
983 */
getJNIEnv()984 /*static*/ JNIEnv* AndroidRuntime::getJNIEnv()
985 {
986 JNIEnv* env;
987 JavaVM* vm = AndroidRuntime::getJavaVM();
988 assert(vm != NULL);
989
990 if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK)
991 return NULL;
992 return env;
993 }
994
995 /*
996 * Makes the current thread visible to the VM.
997 *
998 * The JNIEnv pointer returned is only valid for the current thread, and
999 * thus must be tucked into thread-local storage.
1000 */
javaAttachThread(const char * threadName,JNIEnv ** pEnv)1001 static int javaAttachThread(const char* threadName, JNIEnv** pEnv)
1002 {
1003 JavaVMAttachArgs args;
1004 JavaVM* vm;
1005 jint result;
1006
1007 vm = AndroidRuntime::getJavaVM();
1008 assert(vm != NULL);
1009
1010 args.version = JNI_VERSION_1_4;
1011 args.name = (char*) threadName;
1012 args.group = NULL;
1013
1014 result = vm->AttachCurrentThread(pEnv, (void*) &args);
1015 if (result != JNI_OK)
1016 LOGE("ERROR: thread attach failed\n");
1017
1018 return result;
1019 }
1020
1021 /*
1022 * Detach the current thread from the set visible to the VM.
1023 */
javaDetachThread(void)1024 static int javaDetachThread(void)
1025 {
1026 JavaVM* vm;
1027 jint result;
1028
1029 vm = AndroidRuntime::getJavaVM();
1030 assert(vm != NULL);
1031
1032 result = vm->DetachCurrentThread();
1033 if (result != JNI_OK)
1034 LOGE("ERROR: thread detach failed\n");
1035 return result;
1036 }
1037
1038 /*
1039 * When starting a native thread that will be visible from the VM, we
1040 * bounce through this to get the right attach/detach action.
1041 * Note that this function calls free(args)
1042 */
javaThreadShell(void * args)1043 /*static*/ int AndroidRuntime::javaThreadShell(void* args) {
1044 void* start = ((void**)args)[0];
1045 void* userData = ((void **)args)[1];
1046 char* name = (char*) ((void **)args)[2]; // we own this storage
1047 free(args);
1048 JNIEnv* env;
1049 int result;
1050
1051 /* hook us into the VM */
1052 if (javaAttachThread(name, &env) != JNI_OK)
1053 return -1;
1054
1055 /* start the thread running */
1056 result = (*(android_thread_func_t)start)(userData);
1057
1058 /* unhook us */
1059 javaDetachThread();
1060 free(name);
1061
1062 return result;
1063 }
1064
1065 /*
1066 * This is invoked from androidCreateThreadEtc() via the callback
1067 * set with androidSetCreateThreadFunc().
1068 *
1069 * We need to create the new thread in such a way that it gets hooked
1070 * into the VM before it really starts executing.
1071 */
javaCreateThreadEtc(android_thread_func_t entryFunction,void * userData,const char * threadName,int32_t threadPriority,size_t threadStackSize,android_thread_id_t * threadId)1072 /*static*/ int AndroidRuntime::javaCreateThreadEtc(
1073 android_thread_func_t entryFunction,
1074 void* userData,
1075 const char* threadName,
1076 int32_t threadPriority,
1077 size_t threadStackSize,
1078 android_thread_id_t* threadId)
1079 {
1080 void** args = (void**) malloc(3 * sizeof(void*)); // javaThreadShell must free
1081 int result;
1082
1083 assert(threadName != NULL);
1084
1085 args[0] = (void*) entryFunction;
1086 args[1] = userData;
1087 args[2] = (void*) strdup(threadName); // javaThreadShell must free
1088
1089 result = androidCreateRawThreadEtc(AndroidRuntime::javaThreadShell, args,
1090 threadName, threadPriority, threadStackSize, threadId);
1091 return result;
1092 }
1093
1094 /*
1095 * Create a thread that is visible from the VM.
1096 *
1097 * This is called from elsewhere in the library.
1098 */
createJavaThread(const char * name,void (* start)(void *),void * arg)1099 /*static*/ void AndroidRuntime::createJavaThread(const char* name,
1100 void (*start)(void *), void* arg)
1101 {
1102 javaCreateThreadEtc((android_thread_func_t) start, arg, name,
1103 ANDROID_PRIORITY_DEFAULT, 0, NULL);
1104 }
1105
1106 #if 0
1107 static void quickTest(void* arg)
1108 {
1109 const char* str = (const char*) arg;
1110
1111 printf("In quickTest: %s\n", str);
1112 }
1113 #endif
1114
1115 #ifdef NDEBUG
1116 #define REG_JNI(name) { name }
1117 struct RegJNIRec {
1118 int (*mProc)(JNIEnv*);
1119 };
1120 #else
1121 #define REG_JNI(name) { name, #name }
1122 struct RegJNIRec {
1123 int (*mProc)(JNIEnv*);
1124 const char* mName;
1125 };
1126 #endif
1127
1128 typedef void (*RegJAMProc)();
1129
register_jni_procs(const RegJNIRec array[],size_t count,JNIEnv * env)1130 static int register_jni_procs(const RegJNIRec array[], size_t count, JNIEnv* env)
1131 {
1132 for (size_t i = 0; i < count; i++) {
1133 if (array[i].mProc(env) < 0) {
1134 #ifndef NDEBUG
1135 LOGD("----------!!! %s failed to load\n", array[i].mName);
1136 #endif
1137 return -1;
1138 }
1139 }
1140 return 0;
1141 }
1142
register_jam_procs(const RegJAMProc array[],size_t count)1143 static void register_jam_procs(const RegJAMProc array[], size_t count)
1144 {
1145 for (size_t i = 0; i < count; i++) {
1146 array[i]();
1147 }
1148 }
1149
1150 static const RegJNIRec gRegJNI[] = {
1151 REG_JNI(register_android_debug_JNITest),
1152 REG_JNI(register_com_android_internal_os_RuntimeInit),
1153 REG_JNI(register_android_os_SystemClock),
1154 REG_JNI(register_android_util_EventLog),
1155 REG_JNI(register_android_util_Log),
1156 REG_JNI(register_android_util_FloatMath),
1157 REG_JNI(register_android_text_format_Time),
1158 REG_JNI(register_android_pim_EventRecurrence),
1159 REG_JNI(register_android_content_AssetManager),
1160 REG_JNI(register_android_content_StringBlock),
1161 REG_JNI(register_android_content_XmlBlock),
1162 REG_JNI(register_android_emoji_EmojiFactory),
1163 REG_JNI(register_android_security_Md5MessageDigest),
1164 REG_JNI(register_android_text_AndroidCharacter),
1165 REG_JNI(register_android_text_KeyCharacterMap),
1166 REG_JNI(register_android_os_Process),
1167 REG_JNI(register_android_os_Binder),
1168 REG_JNI(register_android_os_Hardware),
1169 REG_JNI(register_android_view_Display),
1170 REG_JNI(register_android_nio_utils),
1171 REG_JNI(register_android_graphics_PixelFormat),
1172 REG_JNI(register_android_graphics_Graphics),
1173 REG_JNI(register_android_view_Surface),
1174 REG_JNI(register_android_view_ViewRoot),
1175 REG_JNI(register_com_google_android_gles_jni_EGLImpl),
1176 REG_JNI(register_com_google_android_gles_jni_GLImpl),
1177 REG_JNI(register_android_opengl_jni_GLES10),
1178 REG_JNI(register_android_opengl_jni_GLES10Ext),
1179 REG_JNI(register_android_opengl_jni_GLES11),
1180 REG_JNI(register_android_opengl_jni_GLES11Ext),
1181
1182 REG_JNI(register_android_graphics_Bitmap),
1183 REG_JNI(register_android_graphics_BitmapFactory),
1184 REG_JNI(register_android_graphics_Camera),
1185 REG_JNI(register_android_graphics_Canvas),
1186 REG_JNI(register_android_graphics_ColorFilter),
1187 REG_JNI(register_android_graphics_DrawFilter),
1188 REG_JNI(register_android_graphics_Interpolator),
1189 REG_JNI(register_android_graphics_LayerRasterizer),
1190 REG_JNI(register_android_graphics_MaskFilter),
1191 REG_JNI(register_android_graphics_Matrix),
1192 REG_JNI(register_android_graphics_Movie),
1193 REG_JNI(register_android_graphics_NinePatch),
1194 REG_JNI(register_android_graphics_Paint),
1195 REG_JNI(register_android_graphics_Path),
1196 REG_JNI(register_android_graphics_PathMeasure),
1197 REG_JNI(register_android_graphics_PathEffect),
1198 REG_JNI(register_android_graphics_Picture),
1199 REG_JNI(register_android_graphics_PorterDuff),
1200 REG_JNI(register_android_graphics_Rasterizer),
1201 REG_JNI(register_android_graphics_Region),
1202 REG_JNI(register_android_graphics_Shader),
1203 REG_JNI(register_android_graphics_Typeface),
1204 REG_JNI(register_android_graphics_Xfermode),
1205 REG_JNI(register_com_android_internal_graphics_NativeUtils),
1206
1207 REG_JNI(register_android_database_CursorWindow),
1208 REG_JNI(register_android_database_SQLiteDatabase),
1209 REG_JNI(register_android_database_SQLiteDebug),
1210 REG_JNI(register_android_database_SQLiteProgram),
1211 REG_JNI(register_android_database_SQLiteQuery),
1212 REG_JNI(register_android_database_SQLiteStatement),
1213 REG_JNI(register_android_os_Debug),
1214 REG_JNI(register_android_os_FileObserver),
1215 REG_JNI(register_android_os_FileUtils),
1216 REG_JNI(register_android_os_ParcelFileDescriptor),
1217 REG_JNI(register_android_os_Power),
1218 REG_JNI(register_android_os_StatFs),
1219 REG_JNI(register_android_os_SystemProperties),
1220 REG_JNI(register_android_os_UEventObserver),
1221 REG_JNI(register_android_net_LocalSocketImpl),
1222 REG_JNI(register_android_net_NetworkUtils),
1223 REG_JNI(register_android_net_wifi_WifiManager),
1224 REG_JNI(register_android_os_MemoryFile),
1225 REG_JNI(register_com_android_internal_os_ZygoteInit),
1226 REG_JNI(register_android_hardware_Camera),
1227 REG_JNI(register_android_hardware_SensorManager),
1228 REG_JNI(register_android_media_AudioRecord),
1229 REG_JNI(register_android_media_AudioSystem),
1230 REG_JNI(register_android_media_AudioTrack),
1231 REG_JNI(register_android_media_JetPlayer),
1232 REG_JNI(register_android_media_ToneGenerator),
1233
1234 REG_JNI(register_android_opengl_classes),
1235 REG_JNI(register_android_bluetooth_HeadsetBase),
1236 REG_JNI(register_android_bluetooth_BluetoothAudioGateway),
1237 REG_JNI(register_android_bluetooth_BluetoothSocket),
1238 REG_JNI(register_android_bluetooth_ScoSocket),
1239 REG_JNI(register_android_server_BluetoothService),
1240 REG_JNI(register_android_server_BluetoothEventLoop),
1241 REG_JNI(register_android_server_BluetoothA2dpService),
1242 REG_JNI(register_android_message_digest_sha1),
1243 REG_JNI(register_android_ddm_DdmHandleNativeHeap),
1244 REG_JNI(register_android_util_Base64),
1245 REG_JNI(register_android_location_GpsLocationProvider),
1246 REG_JNI(register_android_backup_BackupDataInput),
1247 REG_JNI(register_android_backup_BackupDataOutput),
1248 REG_JNI(register_android_backup_FileBackupHelperBase),
1249 REG_JNI(register_android_backup_BackupHelperDispatcher),
1250 };
1251
1252 /*
1253 * Register android native functions with the VM.
1254 */
startReg(JNIEnv * env)1255 /*static*/ int AndroidRuntime::startReg(JNIEnv* env)
1256 {
1257 /*
1258 * This hook causes all future threads created in this process to be
1259 * attached to the JavaVM. (This needs to go away in favor of JNI
1260 * Attach calls.)
1261 */
1262 androidSetCreateThreadFunc((android_create_thread_fn) javaCreateThreadEtc);
1263
1264 LOGD("--- registering native functions ---\n");
1265
1266 /*
1267 * Every "register" function calls one or more things that return
1268 * a local reference (e.g. FindClass). Because we haven't really
1269 * started the VM yet, they're all getting stored in the base frame
1270 * and never released. Use Push/Pop to manage the storage.
1271 */
1272 env->PushLocalFrame(200);
1273
1274 if (register_jni_procs(gRegJNI, NELEM(gRegJNI), env) < 0) {
1275 env->PopLocalFrame(NULL);
1276 return -1;
1277 }
1278 env->PopLocalFrame(NULL);
1279
1280 //createJavaThread("fubar", quickTest, (void*) "hello");
1281
1282 return 0;
1283 }
1284
getRuntime()1285 AndroidRuntime* AndroidRuntime::getRuntime()
1286 {
1287 return gCurRuntime;
1288 }
1289
1290 /**
1291 * Used by WithFramework to register native functions.
1292 */
1293 extern "C"
Java_com_android_internal_util_WithFramework_registerNatives(JNIEnv * env,jclass clazz)1294 jint Java_com_android_internal_util_WithFramework_registerNatives(
1295 JNIEnv* env, jclass clazz) {
1296 return register_jni_procs(gRegJNI, NELEM(gRegJNI), env);
1297 }
1298
1299 /**
1300 * Used by LoadClass to register native functions.
1301 */
1302 extern "C"
Java_LoadClass_registerNatives(JNIEnv * env,jclass clazz)1303 jint Java_LoadClass_registerNatives(JNIEnv* env, jclass clazz) {
1304 return register_jni_procs(gRegJNI, NELEM(gRegJNI), env);
1305 }
1306
1307 } // namespace android
1308