Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / art / ea4dca856f8c19299a1858d2cc1f35b03ca0f694 / . / src / jni_internal.cc
blob: a495d65e64eec624e03497090c36cca431ca731d [file] [log] [blame]
Ian Rogersdf20fe02011-07-20 20:34:16 -0700[diff] [blame]1// Copyright 2011 Google Inc. All Rights Reserved.
2
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700[diff] [blame]3#include "jni_internal.h"
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700[diff] [blame]4
5#include <vector>
6#include <utility>
7
Carl Shapiroea4dca82011-08-01 13:45:38 -0700[diff] [blame^]8#include "jni.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700[diff] [blame]9#include "logging.h"
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700[diff] [blame]10#include "runtime.h"
Carl Shapirofc322c72011-07-27 00:20:01 -0700[diff] [blame]11#include "scoped_ptr.h"
12#include "stringpiece.h"
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700[diff] [blame]13#include "thread.h"
Ian Rogersdf20fe02011-07-20 20:34:16 -0700[diff] [blame]14
15namespace art {
16
17static void JniMonitorEnter(JniEnvironment*, jobject) {
18 LOG(WARNING) << "Unimplemented: JNI Monitor Enter";
19}
20
21static void JniMonitorExit(JniEnvironment*, jobject) {
22 LOG(WARNING) << "Unimplemented: JNI Monitor Exit";
23}
24
25JniEnvironment::JniEnvironment() {
26 monitor_enter_ = &JniMonitorEnter;
27 monitor_exit_ = &JniMonitorExit;
28}
29
Carl Shapiroea4dca82011-08-01 13:45:38 -0700[diff] [blame^]30// JNI Native interface.
31
32jint JniNativeInterface::GetVersion(JNIEnv* env) {
33 return JNI_VERSION_1_6;
34}
35
36jclass JniNativeInterface::DefineClass(JNIEnv *env,
37 const char *name,
38 jobject loader,
39 const jbyte *buf,
40 jsize len) {
41 LOG(FATAL) << "Unimplemented";
42 return NULL;
43}
44
45jclass JniNativeInterface::FindClass(JNIEnv *env, const char *name) {
46 LOG(FATAL) << "Unimplemented";
47 return NULL;
48}
49
50jmethodID JniNativeInterface::FromReflectedMethod(JNIEnv* env, jobject method) {
51 LOG(FATAL) << "Unimplemented";
52 return NULL;
53}
54
55jfieldID JniNativeInterface::FromReflectedField(JNIEnv* env, jobject field) {
56 LOG(FATAL) << "Unimplemented";
57 return NULL;
58}
59
60jobject JniNativeInterface::ToReflectedMethod(JNIEnv* env,
61 jclass cls,
62 jmethodID methodID,
63 jboolean isStatic) {
64 LOG(FATAL) << "Unimplemented";
65 return NULL;
66}
67
68jclass JniNativeInterface::GetSuperclass(JNIEnv* env, jclass sub) {
69 LOG(FATAL) << "Unimplemented";
70 return NULL;
71}
72
73jboolean JniNativeInterface::IsAssignableFrom(JNIEnv* env,
74 jclass sub,
75 jclass sup) {
76 LOG(FATAL) << "Unimplemented";
77 return JNI_FALSE;
78}
79
80jobject JniNativeInterface::ToReflectedField(JNIEnv* env,
81 jclass cls,
82 jfieldID fieldID,
83 jboolean isStatic) {
84 LOG(FATAL) << "Unimplemented";
85 return NULL;
86}
87
88jint JniNativeInterface::Throw(JNIEnv* env, jthrowable obj) {
89 LOG(FATAL) << "Unimplemented";
90 return 0;
91}
92
93jint JniNativeInterface::ThrowNew(JNIEnv* env, jclass clazz, const char* msg) {
94 LOG(FATAL) << "Unimplemented";
95 return 0;
96}
97
98jthrowable JniNativeInterface::ExceptionOccurred(JNIEnv* env) {
99 LOG(FATAL) << "Unimplemented";
100 return NULL;
101}
102
103void JniNativeInterface::ExceptionDescribe(JNIEnv* env) {
104 LOG(FATAL) << "Unimplemented";
105}
106
107void JniNativeInterface::ExceptionClear(JNIEnv* env) {
108 LOG(FATAL) << "Unimplemented";
109}
110
111void JniNativeInterface::FatalError(JNIEnv* env, const char* msg) {
112 LOG(FATAL) << "Unimplemented";
113}
114
115jint JniNativeInterface::PushLocalFrame(JNIEnv* env, jint cap) {
116 LOG(FATAL) << "Unimplemented";
117 return 0;
118}
119
120jobject JniNativeInterface::PopLocalFrame(JNIEnv* env, jobject res) {
121 LOG(FATAL) << "Unimplemented";
122 return NULL;
123}
124
125jobject JniNativeInterface::NewGlobalRef(JNIEnv* env, jobject lobj) {
126 LOG(FATAL) << "Unimplemented";
127 return NULL;
128}
129
130void JniNativeInterface::DeleteGlobalRef(JNIEnv* env, jobject gref) {
131 LOG(FATAL) << "Unimplemented";
132}
133
134void JniNativeInterface::DeleteLocalRef(JNIEnv* env, jobject obj) {
135 LOG(FATAL) << "Unimplemented";
136}
137
138jboolean JniNativeInterface::IsSameObject(JNIEnv* env,
139 jobject obj1,
140 jobject obj2) {
141 LOG(FATAL) << "Unimplemented";
142 return JNI_FALSE;
143}
144
145jobject JniNativeInterface::NewLocalRef(JNIEnv* env, jobject ref) {
146 LOG(FATAL) << "Unimplemented";
147 return NULL;
148}
149
150jint JniNativeInterface::EnsureLocalCapacity(JNIEnv* env, jint) {
151 LOG(FATAL) << "Unimplemented";
152 return 0;
153}
154
155jobject JniNativeInterface::AllocObject(JNIEnv* env, jclass clazz) {
156 LOG(FATAL) << "Unimplemented";
157 return NULL;
158}
159
160jobject JniNativeInterface::NewObject(JNIEnv* env,
161 jclass clazz,
162 jmethodID methodID,
163 ...) {
164 LOG(FATAL) << "Unimplemented";
165 return NULL;
166}
167
168jobject JniNativeInterface::NewObjectV(JNIEnv* env,
169 jclass clazz,
170 jmethodID methodID,
171 va_list args) {
172 LOG(FATAL) << "Unimplemented";
173 return NULL;
174}
175
176jobject JniNativeInterface::NewObjectA(JNIEnv* env,
177 jclass clazz,
178 jmethodID methodID,
179 jvalue* args) {
180 LOG(FATAL) << "Unimplemented";
181 return NULL;
182}
183
184jclass JniNativeInterface::GetObjectClass(JNIEnv* env, jobject obj) {
185 LOG(FATAL) << "Unimplemented";
186 return NULL;
187}
188
189jboolean JniNativeInterface::IsInstanceOf(JNIEnv* env,
190 jobject obj,
191 jclass clazz) {
192 LOG(FATAL) << "Unimplemented";
193 return JNI_FALSE;
194}
195
196jmethodID JniNativeInterface::GetMethodID(JNIEnv* env,
197 jclass clazz,
198 const char* name,
199 const char* sig) {
200 LOG(FATAL) << "Unimplemented";
201 return NULL;
202}
203
204jobject JniNativeInterface::CallObjectMethod(JNIEnv* env,
205 jobject obj,
206 jmethodID methodID,
207 ...) {
208 LOG(FATAL) << "Unimplemented";
209 return NULL;
210}
211
212jobject JniNativeInterface::CallObjectMethodV(JNIEnv* env,
213 jobject obj,
214 jmethodID methodID,
215 va_list args) {
216 LOG(FATAL) << "Unimplemented";
217 return NULL;
218}
219
220jobject JniNativeInterface::CallObjectMethodA(JNIEnv* env,
221 jobject obj,
222 jmethodID methodID,
223 jvalue* args) {
224 LOG(FATAL) << "Unimplemented";
225 return NULL;
226}
227
228jboolean JniNativeInterface::CallBooleanMethod(JNIEnv* env,
229 jobject obj,
230 jmethodID methodID,
231 ...) {
232 LOG(FATAL) << "Unimplemented";
233 return JNI_FALSE;
234}
235
236jboolean JniNativeInterface::CallBooleanMethodV(JNIEnv* env,
237 jobject obj,
238 jmethodID methodID,
239 va_list args) {
240 LOG(FATAL) << "Unimplemented";
241 return JNI_FALSE;
242}
243
244jboolean JniNativeInterface::CallBooleanMethodA(JNIEnv* env,
245 jobject obj,
246 jmethodID methodID,
247 jvalue* args) {
248 LOG(FATAL) << "Unimplemented";
249 return JNI_FALSE;
250}
251
252jbyte JniNativeInterface::CallByteMethod(JNIEnv* env,
253 jobject obj,
254 jmethodID methodID,
255 ...) {
256 LOG(FATAL) << "Unimplemented";
257 return 0;
258}
259
260jbyte JniNativeInterface::CallByteMethodV(JNIEnv* env,
261 jobject obj,
262 jmethodID methodID,
263 va_list args) {
264 LOG(FATAL) << "Unimplemented";
265 return 0;
266}
267
268jbyte JniNativeInterface::CallByteMethodA(JNIEnv* env,
269 jobject obj,
270 jmethodID methodID,
271 jvalue* args) {
272 LOG(FATAL) << "Unimplemented";
273 return 0;
274}
275
276jchar JniNativeInterface::CallCharMethod(JNIEnv* env,
277 jobject obj,
278 jmethodID methodID, ...) {
279 LOG(FATAL) << "Unimplemented";
280 return 0;
281}
282
283jchar JniNativeInterface::CallCharMethodV(JNIEnv* env,
284 jobject obj,
285 jmethodID methodID,
286 va_list args) {
287 LOG(FATAL) << "Unimplemented";
288 return 0;
289}
290
291jchar JniNativeInterface::CallCharMethodA(JNIEnv* env,
292 jobject obj,
293 jmethodID methodID,
294 jvalue* args) {
295 LOG(FATAL) << "Unimplemented";
296 return 0;
297}
298
299jshort JniNativeInterface::CallShortMethod(JNIEnv* env,
300 jobject obj,
301 jmethodID methodID,
302 ...) {
303 LOG(FATAL) << "Unimplemented";
304 return 0;
305}
306
307jshort JniNativeInterface::CallShortMethodV(JNIEnv* env,
308 jobject obj,
309 jmethodID methodID,
310 va_list args) {
311 LOG(FATAL) << "Unimplemented";
312 return 0;
313}
314
315jshort JniNativeInterface::CallShortMethodA(JNIEnv* env,
316 jobject obj,
317 jmethodID methodID,
318 jvalue* args) {
319 LOG(FATAL) << "Unimplemented";
320 return 0;
321}
322
323jint JniNativeInterface::CallIntMethod(JNIEnv* env,
324 jobject obj,
325 jmethodID methodID,
326 ...) {
327 LOG(FATAL) << "Unimplemented";
328 return 0;
329}
330
331jint JniNativeInterface::CallIntMethodV(JNIEnv* env,
332 jobject obj,
333 jmethodID methodID,
334 va_list args) {
335 LOG(FATAL) << "Unimplemented";
336 return 0;
337}
338
339jint JniNativeInterface::CallIntMethodA(JNIEnv* env,
340 jobject obj,
341 jmethodID methodID,
342 jvalue* args) {
343 LOG(FATAL) << "Unimplemented";
344 return 0;
345}
346
347jlong JniNativeInterface::CallLongMethod(JNIEnv* env,
348 jobject obj,
349 jmethodID methodID,
350 ...) {
351 LOG(FATAL) << "Unimplemented";
352 return 0;
353}
354
355jlong JniNativeInterface::CallLongMethodV(JNIEnv* env,
356 jobject obj,
357 jmethodID methodID,
358 va_list args) {
359 LOG(FATAL) << "Unimplemented";
360 return 0;
361}
362
363jlong JniNativeInterface::CallLongMethodA(JNIEnv* env,
364 jobject obj,
365 jmethodID methodID,
366 jvalue* args) {
367 LOG(FATAL) << "Unimplemented";
368 return 0;
369}
370
371jfloat JniNativeInterface::CallFloatMethod(JNIEnv* env,
372 jobject obj,
373 jmethodID methodID,
374 ...) {
375 LOG(FATAL) << "Unimplemented";
376 return 0;
377}
378
379jfloat JniNativeInterface::CallFloatMethodV(JNIEnv* env,
380 jobject obj,
381 jmethodID methodID,
382 va_list args) {
383 LOG(FATAL) << "Unimplemented";
384 return 0;
385}
386
387jfloat JniNativeInterface::CallFloatMethodA(JNIEnv* env,
388 jobject obj,
389 jmethodID methodID,
390 jvalue* args) {
391 LOG(FATAL) << "Unimplemented";
392 return 0;
393}
394
395jdouble JniNativeInterface::CallDoubleMethod(JNIEnv* env,
396 jobject obj,
397 jmethodID methodID,
398 ...) {
399 LOG(FATAL) << "Unimplemented";
400 return 0;
401}
402
403jdouble JniNativeInterface::CallDoubleMethodV(JNIEnv* env,
404 jobject obj,
405 jmethodID methodID,
406 va_list args) {
407 LOG(FATAL) << "Unimplemented";
408 return 0;
409}
410
411jdouble JniNativeInterface::CallDoubleMethodA(JNIEnv* env,
412 jobject obj,
413 jmethodID methodID,
414 jvalue* args) {
415 LOG(FATAL) << "Unimplemented";
416 return 0;
417}
418
419void JniNativeInterface::CallVoidMethod(JNIEnv* env,
420 jobject obj,
421 jmethodID methodID,
422 ...) {
423 LOG(FATAL) << "Unimplemented";
424}
425
426void JniNativeInterface::CallVoidMethodV(JNIEnv* env,
427 jobject obj,
428 jmethodID methodID,
429 va_list args) {
430 LOG(FATAL) << "Unimplemented";
431}
432
433void JniNativeInterface::CallVoidMethodA(JNIEnv* env,
434 jobject obj,
435 jmethodID methodID,
436 jvalue* args) {
437 LOG(FATAL) << "Unimplemented";
438}
439
440jobject JniNativeInterface::CallNonvirtualObjectMethod(JNIEnv* env,
441 jobject obj,
442 jclass clazz,
443 jmethodID methodID,
444 ...) {
445 LOG(FATAL) << "Unimplemented";
446 return NULL;
447}
448
449jobject JniNativeInterface::CallNonvirtualObjectMethodV(JNIEnv* env,
450 jobject obj,
451 jclass clazz,
452 jmethodID methodID,
453 va_list args) {
454 LOG(FATAL) << "Unimplemented";
455 return NULL;
456}
457
458jobject JniNativeInterface::CallNonvirtualObjectMethodA(JNIEnv* env,
459 jobject obj,
460 jclass clazz,
461 jmethodID methodID,
462 jvalue* args) {
463 LOG(FATAL) << "Unimplemented";
464 return NULL;
465}
466
467jboolean JniNativeInterface::CallNonvirtualBooleanMethod(JNIEnv* env,
468 jobject obj,
469 jclass clazz,
470 jmethodID methodID,
471 ...) {
472 LOG(FATAL) << "Unimplemented";
473 return JNI_FALSE;
474}
475
476jboolean JniNativeInterface::CallNonvirtualBooleanMethodV(JNIEnv* env,
477 jobject obj,
478 jclass clazz,
479 jmethodID methodID,
480 va_list args) {
481 LOG(FATAL) << "Unimplemented";
482 return JNI_FALSE;
483}
484
485jboolean JniNativeInterface::CallNonvirtualBooleanMethodA(JNIEnv* env,
486 jobject obj,
487 jclass clazz,
488 jmethodID methodID,
489 jvalue* args) {
490 LOG(FATAL) << "Unimplemented";
491 return JNI_FALSE;
492}
493
494jbyte JniNativeInterface::CallNonvirtualByteMethod(JNIEnv* env,
495 jobject obj,
496 jclass clazz,
497 jmethodID methodID,
498 ...) {
499 LOG(FATAL) << "Unimplemented";
500 return 0;
501}
502
503jbyte JniNativeInterface::CallNonvirtualByteMethodV(JNIEnv* env,
504 jobject obj,
505 jclass clazz,
506 jmethodID methodID,
507 va_list args) {
508 LOG(FATAL) << "Unimplemented";
509 return 0;
510}
511
512jbyte JniNativeInterface::CallNonvirtualByteMethodA(JNIEnv* env,
513 jobject obj,
514 jclass clazz,
515 jmethodID methodID,
516 jvalue* args) {
517 LOG(FATAL) << "Unimplemented";
518 return 0;
519}
520
521jchar JniNativeInterface::CallNonvirtualCharMethod(JNIEnv* env,
522 jobject obj,
523 jclass clazz,
524 jmethodID methodID,
525 ...) {
526 LOG(FATAL) << "Unimplemented";
527 return 0;
528}
529
530jchar JniNativeInterface::CallNonvirtualCharMethodV(JNIEnv* env,
531 jobject obj,
532 jclass clazz,
533 jmethodID methodID,
534 va_list args) {
535 LOG(FATAL) << "Unimplemented";
536 return 0;
537}
538
539jchar JniNativeInterface::CallNonvirtualCharMethodA(JNIEnv* env,
540 jobject obj,
541 jclass clazz,
542 jmethodID methodID,
543 jvalue* args) {
544 LOG(FATAL) << "Unimplemented";
545 return 0;
546}
547
548jshort JniNativeInterface::CallNonvirtualShortMethod(JNIEnv* env,
549 jobject obj,
550 jclass clazz,
551 jmethodID methodID,
552 ...) {
553 LOG(FATAL) << "Unimplemented";
554 return 0;
555}
556
557jshort JniNativeInterface::CallNonvirtualShortMethodV(JNIEnv* env,
558 jobject obj,
559 jclass clazz,
560 jmethodID methodID,
561 va_list args) {
562 LOG(FATAL) << "Unimplemented";
563 return 0;
564}
565
566jshort JniNativeInterface::CallNonvirtualShortMethodA(JNIEnv* env,
567 jobject obj,
568 jclass clazz,
569 jmethodID methodID,
570 jvalue* args) {
571 LOG(FATAL) << "Unimplemented";
572 return 0;
573}
574
575jint JniNativeInterface::CallNonvirtualIntMethod(JNIEnv* env,
576 jobject obj,
577 jclass clazz,
578 jmethodID methodID,
579 ...) {
580 LOG(FATAL) << "Unimplemented";
581 return 0;
582}
583
584jint JniNativeInterface::CallNonvirtualIntMethodV(JNIEnv* env,
585 jobject obj,
586 jclass clazz,
587 jmethodID methodID,
588 va_list args) {
589 LOG(FATAL) << "Unimplemented";
590 return 0;
591}
592
593jint JniNativeInterface::CallNonvirtualIntMethodA(JNIEnv* env,
594 jobject obj,
595 jclass clazz,
596 jmethodID methodID,
597 jvalue* args) {
598 LOG(FATAL) << "Unimplemented";
599 return 0;
600}
601
602jlong JniNativeInterface::CallNonvirtualLongMethod(JNIEnv* env,
603 jobject obj,
604 jclass clazz,
605 jmethodID methodID,
606 ...) {
607 LOG(FATAL) << "Unimplemented";
608 return 0;
609}
610
611jlong JniNativeInterface::CallNonvirtualLongMethodV(JNIEnv* env,
612 jobject obj,
613 jclass clazz,
614 jmethodID methodID,
615 va_list args) {
616 LOG(FATAL) << "Unimplemented";
617 return 0;
618}
619
620jlong JniNativeInterface::CallNonvirtualLongMethodA(JNIEnv* env,
621 jobject obj,
622 jclass clazz,
623 jmethodID methodID,
624 jvalue* args) {
625 LOG(FATAL) << "Unimplemented";
626 return 0;
627}
628
629jfloat JniNativeInterface::CallNonvirtualFloatMethod(JNIEnv* env,
630 jobject obj,
631 jclass clazz,
632 jmethodID methodID,
633 ...) {
634 LOG(FATAL) << "Unimplemented";
635 return 0;
636}
637
638jfloat JniNativeInterface::CallNonvirtualFloatMethodV(JNIEnv* env,
639 jobject obj,
640 jclass clazz,
641 jmethodID methodID,
642 va_list args) {
643 LOG(FATAL) << "Unimplemented";
644 return 0;
645}
646
647jfloat JniNativeInterface::CallNonvirtualFloatMethodA(JNIEnv* env,
648 jobject obj,
649 jclass clazz,
650 jmethodID methodID,
651 jvalue* args) {
652 LOG(FATAL) << "Unimplemented";
653 return 0;
654}
655
656jdouble JniNativeInterface::CallNonvirtualDoubleMethod(JNIEnv* env,
657 jobject obj,
658 jclass clazz,
659 jmethodID methodID,
660 ...) {
661 LOG(FATAL) << "Unimplemented";
662 return 0;
663}
664
665jdouble JniNativeInterface::CallNonvirtualDoubleMethodV(JNIEnv* env,
666 jobject obj,
667 jclass clazz,
668 jmethodID methodID,
669 va_list args) {
670 LOG(FATAL) << "Unimplemented";
671 return 0;
672}
673
674jdouble JniNativeInterface::CallNonvirtualDoubleMethodA(JNIEnv* env,
675 jobject obj,
676 jclass clazz,
677 jmethodID methodID,
678 jvalue* args) {
679 LOG(FATAL) << "Unimplemented";
680 return 0;
681}
682
683void JniNativeInterface::CallNonvirtualVoidMethod(JNIEnv* env,
684 jobject obj,
685 jclass clazz,
686 jmethodID methodID,
687 ...) {
688 LOG(FATAL) << "Unimplemented";
689}
690
691void JniNativeInterface::CallNonvirtualVoidMethodV(JNIEnv* env,
692 jobject obj,
693 jclass clazz,
694 jmethodID methodID,
695 va_list args) {
696 LOG(FATAL) << "Unimplemented";
697}
698
699void JniNativeInterface::CallNonvirtualVoidMethodA(JNIEnv* env,
700 jobject obj,
701 jclass clazz,
702 jmethodID methodID,
703 jvalue* args) {
704 LOG(FATAL) << "Unimplemented";
705}
706
707jfieldID JniNativeInterface::GetFieldID(JNIEnv* env,
708 jclass clazz,
709 const char* name,
710 const char* sig) {
711 LOG(FATAL) << "Unimplemented";
712 return NULL;
713}
714
715jobject JniNativeInterface::GetObjectField(JNIEnv* env,
716 jobject obj,
717 jfieldID fieldID) {
718 LOG(FATAL) << "Unimplemented";
719 return NULL;
720}
721
722jboolean JniNativeInterface::GetBooleanField(JNIEnv* env,
723 jobject obj,
724 jfieldID fieldID) {
725 LOG(FATAL) << "Unimplemented";
726 return JNI_FALSE;
727}
728
729jbyte JniNativeInterface::GetByteField(JNIEnv* env,
730 jobject obj,
731 jfieldID fieldID) {
732 LOG(FATAL) << "Unimplemented";
733 return 0;
734}
735
736jchar JniNativeInterface::GetCharField(JNIEnv* env,
737 jobject obj,
738 jfieldID fieldID) {
739 LOG(FATAL) << "Unimplemented";
740 return 0;
741}
742
743jshort JniNativeInterface::GetShortField(JNIEnv* env,
744 jobject obj,
745 jfieldID fieldID) {
746 LOG(FATAL) << "Unimplemented";
747 return 0;
748}
749
750jint JniNativeInterface::GetIntField(JNIEnv* env,
751 jobject obj,
752 jfieldID fieldID) {
753 LOG(FATAL) << "Unimplemented";
754 return 0;
755}
756
757jlong JniNativeInterface::GetLongField(JNIEnv* env,
758 jobject obj,
759 jfieldID fieldID) {
760 LOG(FATAL) << "Unimplemented";
761 return 0;
762}
763
764jfloat JniNativeInterface::GetFloatField(JNIEnv* env,
765 jobject obj,
766 jfieldID fieldID) {
767 LOG(FATAL) << "Unimplemented";
768 return 0;
769}
770
771jdouble JniNativeInterface::GetDoubleField(JNIEnv* env,
772 jobject obj,
773 jfieldID fieldID) {
774 LOG(FATAL) << "Unimplemented";
775 return 0;
776}
777
778void JniNativeInterface::SetObjectField(JNIEnv* env,
779 jobject obj,
780 jfieldID fieldID,
781 jobject val) {
782 LOG(FATAL) << "Unimplemented";
783}
784
785void JniNativeInterface::SetBooleanField(JNIEnv* env,
786 jobject obj,
787 jfieldID fieldID,
788 jboolean val) {
789 LOG(FATAL) << "Unimplemented";
790}
791
792void JniNativeInterface::SetByteField(JNIEnv* env,
793 jobject obj,
794 jfieldID fieldID,
795 jbyte val) {
796 LOG(FATAL) << "Unimplemented";
797}
798
799void JniNativeInterface::SetCharField(JNIEnv* env,
800 jobject obj,
801 jfieldID fieldID,
802 jchar val) {
803 LOG(FATAL) << "Unimplemented";
804}
805
806void JniNativeInterface::SetShortField(JNIEnv* env,
807 jobject obj,
808 jfieldID fieldID,
809 jshort val) {
810 LOG(FATAL) << "Unimplemented";
811}
812
813void JniNativeInterface::SetIntField(JNIEnv* env,
814 jobject obj,
815 jfieldID fieldID,
816 jint val) {
817 LOG(FATAL) << "Unimplemented";
818}
819
820void JniNativeInterface::SetLongField(JNIEnv* env,
821 jobject obj,
822 jfieldID fieldID,
823 jlong val) {
824 LOG(FATAL) << "Unimplemented";
825}
826
827void JniNativeInterface::SetFloatField(JNIEnv* env,
828 jobject obj,
829 jfieldID fieldID,
830 jfloat val) {
831 LOG(FATAL) << "Unimplemented";
832}
833
834void JniNativeInterface::SetDoubleField(JNIEnv* env,
835 jobject obj,
836 jfieldID fieldID,
837 jdouble val) {
838 LOG(FATAL) << "Unimplemented";
839}
840
841jmethodID JniNativeInterface::GetStaticMethodID(JNIEnv* env,
842 jclass clazz,
843 const char* name,
844 const char* sig) {
845 LOG(FATAL) << "Unimplemented";
846 return NULL;
847}
848
849jobject JniNativeInterface::CallStaticObjectMethod(JNIEnv* env,
850 jclass clazz,
851 jmethodID methodID,
852 ...) {
853 LOG(FATAL) << "Unimplemented";
854 return NULL;
855}
856
857jobject JniNativeInterface::CallStaticObjectMethodV(JNIEnv* env,
858 jclass clazz,
859 jmethodID methodID,
860 va_list args) {
861 LOG(FATAL) << "Unimplemented";
862 return NULL;
863}
864
865jobject JniNativeInterface::CallStaticObjectMethodA(JNIEnv* env,
866 jclass clazz,
867 jmethodID methodID,
868 jvalue* args) {
869 LOG(FATAL) << "Unimplemented";
870 return NULL;
871}
872
873jboolean JniNativeInterface::CallStaticBooleanMethod(JNIEnv* env,
874 jclass clazz,
875 jmethodID methodID,
876 ...) {
877 LOG(FATAL) << "Unimplemented";
878 return JNI_FALSE;
879}
880
881jboolean JniNativeInterface::CallStaticBooleanMethodV(JNIEnv* env,
882 jclass clazz,
883 jmethodID methodID,
884 va_list args) {
885 LOG(FATAL) << "Unimplemented";
886 return JNI_FALSE;
887}
888
889jboolean JniNativeInterface::CallStaticBooleanMethodA(JNIEnv* env,
890 jclass clazz,
891 jmethodID methodID,
892 jvalue* args) {
893 LOG(FATAL) << "Unimplemented";
894 return JNI_FALSE;
895}
896
897jbyte JniNativeInterface::CallStaticByteMethod(JNIEnv* env,
898 jclass clazz,
899 jmethodID methodID,
900 ...) {
901 LOG(FATAL) << "Unimplemented";
902 return 0;
903}
904
905jbyte JniNativeInterface::CallStaticByteMethodV(JNIEnv* env,
906 jclass clazz,
907 jmethodID methodID,
908 va_list args) {
909 LOG(FATAL) << "Unimplemented";
910 return 0;
911}
912
913jbyte JniNativeInterface::CallStaticByteMethodA(JNIEnv* env,
914 jclass clazz,
915 jmethodID methodID,
916 jvalue* args) {
917 LOG(FATAL) << "Unimplemented";
918 return 0;
919}
920
921jchar JniNativeInterface::CallStaticCharMethod(JNIEnv* env,
922 jclass clazz,
923 jmethodID methodID,
924 ...) {
925 LOG(FATAL) << "Unimplemented";
926 return 0;
927}
928
929jchar JniNativeInterface::CallStaticCharMethodV(JNIEnv* env,
930 jclass clazz,
931 jmethodID methodID,
932 va_list args) {
933 LOG(FATAL) << "Unimplemented";
934 return 0;
935}
936
937jchar JniNativeInterface::CallStaticCharMethodA(JNIEnv* env,
938 jclass clazz,
939 jmethodID methodID,
940 jvalue* args) {
941 LOG(FATAL) << "Unimplemented";
942 return 0;
943}
944
945jshort JniNativeInterface::CallStaticShortMethod(JNIEnv* env,
946 jclass clazz,
947 jmethodID methodID,
948 ...) {
949 LOG(FATAL) << "Unimplemented";
950 return 0;
951}
952
953jshort JniNativeInterface::CallStaticShortMethodV(JNIEnv* env,
954 jclass clazz,
955 jmethodID methodID,
956 va_list args) {
957 LOG(FATAL) << "Unimplemented";
958 return 0;
959}
960
961jshort JniNativeInterface::CallStaticShortMethodA(JNIEnv* env,
962 jclass clazz,
963 jmethodID methodID,
964 jvalue* args) {
965 LOG(FATAL) << "Unimplemented";
966 return 0;
967}
968
969jint JniNativeInterface::CallStaticIntMethod(JNIEnv* env,
970 jclass clazz,
971 jmethodID methodID,
972 ...) {
973 LOG(FATAL) << "Unimplemented";
974 return 0;
975}
976
977jint JniNativeInterface::CallStaticIntMethodV(JNIEnv* env,
978 jclass clazz,
979 jmethodID methodID,
980 va_list args) {
981 LOG(FATAL) << "Unimplemented";
982 return 0;
983}
984
985jint JniNativeInterface::CallStaticIntMethodA(JNIEnv* env,
986 jclass clazz,
987 jmethodID methodID,
988 jvalue* args) {
989 LOG(FATAL) << "Unimplemented";
990 return 0;
991}
992
993jlong JniNativeInterface::CallStaticLongMethod(JNIEnv* env,
994 jclass clazz,
995 jmethodID methodID,
996 ...) {
997 LOG(FATAL) << "Unimplemented";
998 return 0;
999}
1000
1001jlong JniNativeInterface::CallStaticLongMethodV(JNIEnv* env,
1002 jclass clazz,
1003 jmethodID methodID,
1004 va_list args) {
1005 LOG(FATAL) << "Unimplemented";
1006 return 0;
1007}
1008
1009jlong JniNativeInterface::CallStaticLongMethodA(JNIEnv* env,
1010 jclass clazz,
1011 jmethodID methodID,
1012 jvalue* args) {
1013 LOG(FATAL) << "Unimplemented";
1014 return 0;
1015}
1016
1017jfloat JniNativeInterface::CallStaticFloatMethod(JNIEnv* env,
1018 jclass clazz,
1019 jmethodID methodID,
1020 ...) {
1021 LOG(FATAL) << "Unimplemented";
1022 return 0;
1023}
1024
1025jfloat JniNativeInterface::CallStaticFloatMethodV(JNIEnv* env,
1026 jclass clazz,
1027 jmethodID methodID,
1028 va_list args) {
1029 LOG(FATAL) << "Unimplemented";
1030 return 0;
1031}
1032
1033jfloat JniNativeInterface::CallStaticFloatMethodA(JNIEnv* env,
1034 jclass clazz,
1035 jmethodID methodID,
1036 jvalue* args) {
1037 LOG(FATAL) << "Unimplemented";
1038 return 0;
1039}
1040
1041jdouble JniNativeInterface::CallStaticDoubleMethod(JNIEnv* env,
1042 jclass clazz,
1043 jmethodID methodID,
1044 ...) {
1045 LOG(FATAL) << "Unimplemented";
1046 return 0;
1047}
1048
1049jdouble JniNativeInterface::CallStaticDoubleMethodV(JNIEnv* env,
1050 jclass clazz,
1051 jmethodID methodID,
1052 va_list args) {
1053 LOG(FATAL) << "Unimplemented";
1054 return 0;
1055}
1056
1057jdouble JniNativeInterface::CallStaticDoubleMethodA(JNIEnv* env,
1058 jclass clazz,
1059 jmethodID methodID,
1060 jvalue* args) {
1061 LOG(FATAL) << "Unimplemented";
1062 return 0;
1063}
1064
1065void JniNativeInterface::CallStaticVoidMethod(JNIEnv* env,
1066 jclass cls,
1067 jmethodID methodID,
1068 ...) {
1069 LOG(FATAL) << "Unimplemented";
1070}
1071
1072void JniNativeInterface::CallStaticVoidMethodV(JNIEnv* env,
1073 jclass cls,
1074 jmethodID methodID,
1075 va_list args) {
1076 LOG(FATAL) << "Unimplemented";
1077}
1078
1079void JniNativeInterface::CallStaticVoidMethodA(JNIEnv* env,
1080 jclass cls,
1081 jmethodID methodID,
1082 jvalue* args) {
1083 LOG(FATAL) << "Unimplemented";
1084}
1085
1086jfieldID JniNativeInterface::GetStaticFieldID(JNIEnv* env,
1087 jclass clazz,
1088 const char* name,
1089 const char* sig) {
1090 LOG(FATAL) << "Unimplemented";
1091 return 0;
1092}
1093
1094jobject JniNativeInterface::GetStaticObjectField(JNIEnv* env,
1095 jclass clazz,
1096 jfieldID fieldID) {
1097 LOG(FATAL) << "Unimplemented";
1098 return NULL;
1099}
1100
1101jboolean JniNativeInterface::GetStaticBooleanField(JNIEnv* env,
1102 jclass clazz,
1103 jfieldID fieldID) {
1104 LOG(FATAL) << "Unimplemented";
1105 return JNI_FALSE;
1106}
1107
1108jbyte JniNativeInterface::GetStaticByteField(JNIEnv* env,
1109 jclass clazz,
1110 jfieldID fieldID) {
1111 LOG(FATAL) << "Unimplemented";
1112 return 0;
1113}
1114
1115jchar JniNativeInterface::GetStaticCharField(JNIEnv* env,
1116 jclass clazz,
1117 jfieldID fieldID) {
1118 LOG(FATAL) << "Unimplemented";
1119 return 0;
1120}
1121
1122jshort JniNativeInterface::GetStaticShortField(JNIEnv* env,
1123 jclass clazz,
1124 jfieldID fieldID) {
1125 LOG(FATAL) << "Unimplemented";
1126 return 0;
1127}
1128
1129jint JniNativeInterface::GetStaticIntField(JNIEnv* env,
1130 jclass clazz,
1131 jfieldID fieldID) {
1132 LOG(FATAL) << "Unimplemented";
1133 return 0;
1134}
1135
1136jlong JniNativeInterface::GetStaticLongField(JNIEnv* env,
1137 jclass clazz,
1138 jfieldID fieldID) {
1139 LOG(FATAL) << "Unimplemented";
1140 return 0;
1141}
1142
1143jfloat JniNativeInterface::GetStaticFloatField(JNIEnv* env,
1144 jclass clazz,
1145 jfieldID fieldID) {
1146 LOG(FATAL) << "Unimplemented";
1147 return 0;
1148}
1149
1150jdouble JniNativeInterface::GetStaticDoubleField(JNIEnv* env,
1151 jclass clazz,
1152 jfieldID fieldID) {
1153 LOG(FATAL) << "Unimplemented";
1154 return 0;
1155}
1156
1157void JniNativeInterface::SetStaticObjectField(JNIEnv* env,
1158 jclass clazz,
1159 jfieldID fieldID,
1160 jobject value) {
1161 LOG(FATAL) << "Unimplemented";
1162}
1163
1164void JniNativeInterface::SetStaticBooleanField(JNIEnv* env,
1165 jclass clazz,
1166 jfieldID fieldID,
1167 jboolean value) {
1168 LOG(FATAL) << "Unimplemented";
1169}
1170
1171void JniNativeInterface::SetStaticByteField(JNIEnv* env,
1172 jclass clazz,
1173 jfieldID fieldID,
1174 jbyte value) {
1175 LOG(FATAL) << "Unimplemented";
1176}
1177
1178void JniNativeInterface::SetStaticCharField(JNIEnv* env,
1179 jclass clazz,
1180 jfieldID fieldID,
1181 jchar value) {
1182 LOG(FATAL) << "Unimplemented";
1183}
1184
1185void JniNativeInterface::SetStaticShortField(JNIEnv* env,
1186 jclass clazz,
1187 jfieldID fieldID,
1188 jshort value) {
1189 LOG(FATAL) << "Unimplemented";
1190}
1191
1192void JniNativeInterface::SetStaticIntField(JNIEnv* env,
1193 jclass clazz,
1194 jfieldID fieldID,
1195 jint value) {
1196 LOG(FATAL) << "Unimplemented";
1197}
1198
1199void JniNativeInterface::SetStaticLongField(JNIEnv* env,
1200 jclass clazz,
1201 jfieldID fieldID,
1202 jlong value) {
1203 LOG(FATAL) << "Unimplemented";
1204}
1205
1206void JniNativeInterface::SetStaticFloatField(JNIEnv* env,
1207 jclass clazz,
1208 jfieldID fieldID,
1209 jfloat value) {
1210 LOG(FATAL) << "Unimplemented";
1211}
1212
1213void JniNativeInterface::SetStaticDoubleField(JNIEnv* env,
1214 jclass clazz,
1215 jfieldID fieldID,
1216 jdouble value) {
1217 LOG(FATAL) << "Unimplemented";
1218}
1219
1220jstring JniNativeInterface::NewString(JNIEnv* env,
1221 const jchar* unicode,
1222 jsize len) {
1223 LOG(FATAL) << "Unimplemented";
1224 return NULL;
1225}
1226
1227jsize JniNativeInterface::GetStringLength(JNIEnv* env, jstring str) {
1228 LOG(FATAL) << "Unimplemented";
1229 return 0;
1230}
1231
1232const jchar* JniNativeInterface::GetStringChars(JNIEnv* env,
1233 jstring str,
1234 jboolean* isCopy) {
1235 LOG(FATAL) << "Unimplemented";
1236 return NULL;
1237}
1238
1239void JniNativeInterface::ReleaseStringChars(JNIEnv* env,
1240 jstring str,
1241 const jchar* chars) {
1242 LOG(FATAL) << "Unimplemented";
1243}
1244
1245jstring JniNativeInterface::NewStringUTF(JNIEnv* env, const char* utf) {
1246 LOG(FATAL) << "Unimplemented";
1247 return NULL;
1248}
1249
1250jsize JniNativeInterface::GetStringUTFLength(JNIEnv* env, jstring str) {
1251 LOG(FATAL) << "Unimplemented";
1252 return 0;
1253}
1254
1255const char* JniNativeInterface::GetStringUTFChars(JNIEnv* env,
1256 jstring str,
1257 jboolean* isCopy) {
1258 LOG(FATAL) << "Unimplemented";
1259 return NULL;
1260}
1261
1262void JniNativeInterface::ReleaseStringUTFChars(JNIEnv* env,
1263 jstring str,
1264 const char* chars) {
1265 LOG(FATAL) << "Unimplemented";
1266}
1267
1268jsize JniNativeInterface::GetArrayLength(JNIEnv* env, jarray array) {
1269 LOG(FATAL) << "Unimplemented";
1270 return 0;
1271}
1272
1273jobjectArray JniNativeInterface::NewObjectArray(JNIEnv* env,
1274 jsize len,
1275 jclass clazz,
1276 jobject init) {
1277 LOG(FATAL) << "Unimplemented";
1278 return NULL;
1279}
1280
1281jobject JniNativeInterface::GetObjectArrayElement(JNIEnv* env,
1282 jobjectArray array,
1283 jsize index) {
1284 LOG(FATAL) << "Unimplemented";
1285 return NULL;
1286}
1287
1288void JniNativeInterface::SetObjectArrayElement(JNIEnv* env,
1289 jobjectArray array,
1290 jsize index,
1291 jobject val) {
1292 LOG(FATAL) << "Unimplemented";
1293}
1294
1295jbooleanArray JniNativeInterface::NewBooleanArray(JNIEnv* env, jsize len) {
1296 LOG(FATAL) << "Unimplemented";
1297 return NULL;
1298}
1299
1300jbyteArray JniNativeInterface::NewByteArray(JNIEnv* env, jsize len) {
1301 LOG(FATAL) << "Unimplemented";
1302 return NULL;
1303}
1304
1305jcharArray JniNativeInterface::NewCharArray(JNIEnv* env, jsize len) {
1306 LOG(FATAL) << "Unimplemented";
1307 return NULL;
1308}
1309
1310jshortArray JniNativeInterface::NewShortArray(JNIEnv* env, jsize len) {
1311 LOG(FATAL) << "Unimplemented";
1312 return NULL;
1313}
1314
1315jintArray JniNativeInterface::NewIntArray(JNIEnv* env, jsize len) {
1316 LOG(FATAL) << "Unimplemented";
1317 return NULL;
1318}
1319
1320jlongArray JniNativeInterface::NewLongArray(JNIEnv* env, jsize len) {
1321 LOG(FATAL) << "Unimplemented";
1322 return NULL;
1323}
1324
1325jfloatArray JniNativeInterface::NewFloatArray(JNIEnv* env, jsize len) {
1326 LOG(FATAL) << "Unimplemented";
1327 return NULL;
1328}
1329
1330jdoubleArray JniNativeInterface::NewDoubleArray(JNIEnv* env, jsize len) {
1331 LOG(FATAL) << "Unimplemented";
1332 return NULL;
1333}
1334
1335jboolean* JniNativeInterface::GetBooleanArrayElements(JNIEnv* env,
1336 jbooleanArray array,
1337 jboolean* isCopy) {
1338 LOG(FATAL) << "Unimplemented";
1339 return NULL;
1340}
1341
1342jbyte* JniNativeInterface::GetByteArrayElements(JNIEnv* env,
1343 jbyteArray array,
1344 jboolean* isCopy) {
1345 LOG(FATAL) << "Unimplemented";
1346 return NULL;
1347}
1348
1349jchar* JniNativeInterface::GetCharArrayElements(JNIEnv* env,
1350 jcharArray array,
1351 jboolean* isCopy) {
1352 LOG(FATAL) << "Unimplemented";
1353 return NULL;
1354}
1355
1356jshort* JniNativeInterface::GetShortArrayElements(JNIEnv* env,
1357 jshortArray array,
1358 jboolean* isCopy) {
1359 LOG(FATAL) << "Unimplemented";
1360 return NULL;
1361}
1362
1363jint* JniNativeInterface::GetIntArrayElements(JNIEnv* env,
1364 jintArray array,
1365 jboolean* isCopy) {
1366 LOG(FATAL) << "Unimplemented";
1367 return NULL;
1368}
1369
1370jlong* JniNativeInterface::GetLongArrayElements(JNIEnv* env,
1371 jlongArray array,
1372 jboolean* isCopy) {
1373 LOG(FATAL) << "Unimplemented";
1374 return NULL;
1375}
1376
1377jfloat* JniNativeInterface::GetFloatArrayElements(JNIEnv* env,
1378 jfloatArray array,
1379 jboolean* isCopy) {
1380 LOG(FATAL) << "Unimplemented";
1381 return NULL;
1382}
1383
1384jdouble* JniNativeInterface::GetDoubleArrayElements(JNIEnv* env,
1385 jdoubleArray array,
1386 jboolean* isCopy) {
1387 LOG(FATAL) << "Unimplemented";
1388 return NULL;
1389}
1390
1391void JniNativeInterface::ReleaseBooleanArrayElements(JNIEnv* env,
1392 jbooleanArray array,
1393 jboolean* elems,
1394 jint mode) {
1395 LOG(FATAL) << "Unimplemented";
1396}
1397
1398void JniNativeInterface::ReleaseByteArrayElements(JNIEnv* env,
1399 jbyteArray array,
1400 jbyte* elems,
1401 jint mode) {
1402 LOG(FATAL) << "Unimplemented";
1403}
1404
1405void JniNativeInterface::ReleaseCharArrayElements(JNIEnv* env,
1406 jcharArray array,
1407 jchar* elems,
1408 jint mode) {
1409 LOG(FATAL) << "Unimplemented";
1410}
1411
1412void JniNativeInterface::ReleaseShortArrayElements(JNIEnv* env,
1413 jshortArray array,
1414 jshort* elems,
1415 jint mode) {
1416 LOG(FATAL) << "Unimplemented";
1417}
1418
1419void JniNativeInterface::ReleaseIntArrayElements(JNIEnv* env,
1420 jintArray array,
1421 jint* elems,
1422 jint mode) {
1423 LOG(FATAL) << "Unimplemented";
1424}
1425
1426void JniNativeInterface::ReleaseLongArrayElements(JNIEnv* env,
1427 jlongArray array,
1428 jlong* elems,
1429 jint mode) {
1430 LOG(FATAL) << "Unimplemented";
1431}
1432
1433void JniNativeInterface::ReleaseFloatArrayElements(JNIEnv* env,
1434 jfloatArray array,
1435 jfloat* elems,
1436 jint mode) {
1437 LOG(FATAL) << "Unimplemented";
1438}
1439
1440void JniNativeInterface::ReleaseDoubleArrayElements(JNIEnv* env,
1441 jdoubleArray array,
1442 jdouble* elems,
1443 jint mode) {
1444 LOG(FATAL) << "Unimplemented";
1445}
1446
1447void JniNativeInterface::GetBooleanArrayRegion(JNIEnv* env,
1448 jbooleanArray array,
1449 jsize start,
1450 jsize l,
1451 jboolean* buf) {
1452 LOG(FATAL) << "Unimplemented";
1453}
1454
1455void JniNativeInterface::GetByteArrayRegion(JNIEnv* env,
1456 jbyteArray array,
1457 jsize start,
1458 jsize len,
1459 jbyte* buf) {
1460 LOG(FATAL) << "Unimplemented";
1461}
1462
1463void JniNativeInterface::GetCharArrayRegion(JNIEnv* env,
1464 jcharArray array,
1465 jsize start,
1466 jsize len,
1467 jchar* buf) {
1468 LOG(FATAL) << "Unimplemented";
1469}
1470
1471void JniNativeInterface::GetShortArrayRegion(JNIEnv* env,
1472 jshortArray array,
1473 jsize start,
1474 jsize len,
1475 jshort* buf) {
1476 LOG(FATAL) << "Unimplemented";
1477}
1478
1479void JniNativeInterface::GetIntArrayRegion(JNIEnv* env,
1480 jintArray array,
1481 jsize start,
1482 jsize len,
1483 jint* buf) {
1484 LOG(FATAL) << "Unimplemented";
1485}
1486
1487void JniNativeInterface::GetLongArrayRegion(JNIEnv* env,
1488 jlongArray array,
1489 jsize start,
1490 jsize len,
1491 jlong* buf) {
1492 LOG(FATAL) << "Unimplemented";
1493}
1494
1495void JniNativeInterface::GetFloatArrayRegion(JNIEnv* env,
1496 jfloatArray array,
1497 jsize start,
1498 jsize len,
1499 jfloat* buf) {
1500 LOG(FATAL) << "Unimplemented";
1501}
1502
1503void JniNativeInterface::GetDoubleArrayRegion(JNIEnv* env,
1504 jdoubleArray array,
1505 jsize start,
1506 jsize len,
1507 jdouble* buf) {
1508 LOG(FATAL) << "Unimplemented";
1509}
1510
1511void JniNativeInterface::SetBooleanArrayRegion(JNIEnv* env,
1512 jbooleanArray array,
1513 jsize start,
1514 jsize l,
1515 const jboolean* buf) {
1516 LOG(FATAL) << "Unimplemented";
1517}
1518
1519void JniNativeInterface::SetByteArrayRegion(JNIEnv* env,
1520 jbyteArray array,
1521 jsize start,
1522 jsize len,
1523 const jbyte* buf) {
1524 LOG(FATAL) << "Unimplemented";
1525}
1526
1527void JniNativeInterface::SetCharArrayRegion(JNIEnv* env,
1528 jcharArray array,
1529 jsize start,
1530 jsize len,
1531 const jchar* buf) {
1532 LOG(FATAL) << "Unimplemented";
1533}
1534
1535void JniNativeInterface::SetShortArrayRegion(JNIEnv* env,
1536 jshortArray array,
1537 jsize start,
1538 jsize len,
1539 const jshort* buf) {
1540 LOG(FATAL) << "Unimplemented";
1541}
1542
1543void JniNativeInterface::SetIntArrayRegion(JNIEnv* env,
1544 jintArray array,
1545 jsize start,
1546 jsize len,
1547 const jint* buf) {
1548 LOG(FATAL) << "Unimplemented";
1549}
1550
1551void JniNativeInterface::SetLongArrayRegion(JNIEnv* env,
1552 jlongArray array,
1553 jsize start,
1554 jsize len,
1555 const jlong* buf) {
1556 LOG(FATAL) << "Unimplemented";
1557}
1558
1559void JniNativeInterface::SetFloatArrayRegion(JNIEnv* env,
1560 jfloatArray array,
1561 jsize start,
1562 jsize len,
1563 const jfloat* buf) {
1564 LOG(FATAL) << "Unimplemented";
1565}
1566
1567void JniNativeInterface::SetDoubleArrayRegion(JNIEnv* env,
1568 jdoubleArray array,
1569 jsize start,
1570 jsize len,
1571 const jdouble* buf) {
1572 LOG(FATAL) << "Unimplemented";
1573}
1574
1575jint JniNativeInterface::RegisterNatives(JNIEnv* env,
1576 jclass clazz,
1577 const JNINativeMethod* methods,
1578 jint nMethods) {
1579 LOG(FATAL) << "Unimplemented";
1580 return 0;
1581}
1582
1583jint JniNativeInterface::UnregisterNatives(JNIEnv* env, jclass clazz) {
1584 LOG(FATAL) << "Unimplemented";
1585 return 0;
1586}
1587
1588jint JniNativeInterface::MonitorEnter(JNIEnv* env, jobject obj) {
1589 LOG(FATAL) << "Unimplemented";
1590 return 0;
1591}
1592
1593jint JniNativeInterface::MonitorExit(JNIEnv* env, jobject obj) {
1594 LOG(FATAL) << "Unimplemented";
1595 return 0;
1596}
1597
1598jint JniNativeInterface::GetJavaVM(JNIEnv* env, JavaVM* *vm) {
1599 LOG(FATAL) << "Unimplemented";
1600 return 0;
1601}
1602
1603void JniNativeInterface::GetStringRegion(JNIEnv* env,
1604 jstring str,
1605 jsize start,
1606 jsize len,
1607 jchar* buf) {
1608 LOG(FATAL) << "Unimplemented";
1609}
1610
1611void JniNativeInterface::GetStringUTFRegion(JNIEnv* env,
1612 jstring str,
1613 jsize start,
1614 jsize len,
1615 char* buf) {
1616 LOG(FATAL) << "Unimplemented";
1617}
1618
1619void* JniNativeInterface::GetPrimitiveArrayCritical(JNIEnv* env,
1620 jarray array,
1621 jboolean* isCopy) {
1622 LOG(FATAL) << "Unimplemented";
1623 return NULL;
1624}
1625
1626void JniNativeInterface::ReleasePrimitiveArrayCritical(JNIEnv* env,
1627 jarray array,
1628 void* carray,
1629 jint mode) {
1630 LOG(FATAL) << "Unimplemented";
1631}
1632
1633const jchar* JniNativeInterface::GetStringCritical(JNIEnv* env,
1634 jstring s,
1635 jboolean* isCopy) {
1636 LOG(FATAL) << "Unimplemented";
1637 return NULL;
1638}
1639
1640void JniNativeInterface::ReleaseStringCritical(JNIEnv* env,
1641 jstring s,
1642 const jchar* cstr) {
1643 LOG(FATAL) << "Unimplemented";
1644}
1645
1646jweak JniNativeInterface::NewWeakGlobalRef(JNIEnv* env, jobject obj) {
1647 LOG(FATAL) << "Unimplemented";
1648 return NULL;
1649}
1650
1651void JniNativeInterface::DeleteWeakGlobalRef(JNIEnv* env, jweak obj) {
1652 LOG(FATAL) << "Unimplemented";
1653}
1654
1655jboolean JniNativeInterface::ExceptionCheck(JNIEnv* env) {
1656 LOG(FATAL) << "Unimplemented";
1657 return JNI_FALSE;
1658}
1659
1660jobject JniNativeInterface::NewDirectByteBuffer(JNIEnv* env,
1661 void* address,
1662 jlong capacity) {
1663 LOG(FATAL) << "Unimplemented";
1664 return NULL;
1665}
1666
1667
1668void* JniNativeInterface::GetDirectBufferAddress(JNIEnv* env, jobject buf) {
1669 LOG(FATAL) << "Unimplemented";
1670 return NULL;
1671}
1672
1673jlong JniNativeInterface::GetDirectBufferCapacity(JNIEnv* env, jobject buf) {
1674 LOG(FATAL) << "Unimplemented";
1675 return 0;
1676}
1677
1678jobjectRefType JniNativeInterface::GetObjectRefType(JNIEnv* env, jobject jobj) {
1679 LOG(FATAL) << "Unimplemented";
1680 return JNIInvalidRefType;
1681}
1682
1683struct JNINativeInterface JniNativeInterface::native_interface_ = {
1684 NULL, // reserved0.
1685 NULL, // reserved1.
1686 NULL, // reserved2.
1687 NULL, // reserved3.
1688 GetVersion,
1689 DefineClass,
1690 FindClass,
1691 FromReflectedMethod,
1692 FromReflectedField,
1693 ToReflectedMethod,
1694 GetSuperclass,
1695 IsAssignableFrom,
1696 ToReflectedField,
1697 Throw,
1698 ThrowNew,
1699 ExceptionOccurred,
1700 ExceptionDescribe,
1701 ExceptionClear,
1702 FatalError,
1703 PushLocalFrame,
1704 PopLocalFrame,
1705 NewGlobalRef,
1706 DeleteGlobalRef,
1707 DeleteLocalRef,
1708 IsSameObject,
1709 NewLocalRef,
1710 EnsureLocalCapacity,
1711 AllocObject,
1712 NewObject,
1713 NewObjectV,
1714 NewObjectA,
1715 GetObjectClass,
1716 IsInstanceOf,
1717 GetMethodID,
1718 CallObjectMethod,
1719 CallObjectMethodV,
1720 CallObjectMethodA,
1721 CallBooleanMethod,
1722 CallBooleanMethodV,
1723 CallBooleanMethodA,
1724 CallByteMethod,
1725 CallByteMethodV,
1726 CallByteMethodA,
1727 CallCharMethod,
1728 CallCharMethodV,
1729 CallCharMethodA,
1730 CallShortMethod,
1731 CallShortMethodV,
1732 CallShortMethodA,
1733 CallIntMethod,
1734 CallIntMethodV,
1735 CallIntMethodA,
1736 CallLongMethod,
1737 CallLongMethodV,
1738 CallLongMethodA,
1739 CallFloatMethod,
1740 CallFloatMethodV,
1741 CallFloatMethodA,
1742 CallDoubleMethod,
1743 CallDoubleMethodV,
1744 CallDoubleMethodA,
1745 CallVoidMethod,
1746 CallVoidMethodV,
1747 CallVoidMethodA,
1748 CallNonvirtualObjectMethod,
1749 CallNonvirtualObjectMethodV,
1750 CallNonvirtualObjectMethodA,
1751 CallNonvirtualBooleanMethod,
1752 CallNonvirtualBooleanMethodV,
1753 CallNonvirtualBooleanMethodA,
1754 CallNonvirtualByteMethod,
1755 CallNonvirtualByteMethodV,
1756 CallNonvirtualByteMethodA,
1757 CallNonvirtualCharMethod,
1758 CallNonvirtualCharMethodV,
1759 CallNonvirtualCharMethodA,
1760 CallNonvirtualShortMethod,
1761 CallNonvirtualShortMethodV,
1762 CallNonvirtualShortMethodA,
1763 CallNonvirtualIntMethod,
1764 CallNonvirtualIntMethodV,
1765 CallNonvirtualIntMethodA,
1766 CallNonvirtualLongMethod,
1767 CallNonvirtualLongMethodV,
1768 CallNonvirtualLongMethodA,
1769 CallNonvirtualFloatMethod,
1770 CallNonvirtualFloatMethodV,
1771 CallNonvirtualFloatMethodA,
1772 CallNonvirtualDoubleMethod,
1773 CallNonvirtualDoubleMethodV,
1774 CallNonvirtualDoubleMethodA,
1775 CallNonvirtualVoidMethod,
1776 CallNonvirtualVoidMethodV,
1777 CallNonvirtualVoidMethodA,
1778 GetFieldID,
1779 GetObjectField,
1780 GetBooleanField,
1781 GetByteField,
1782 GetCharField,
1783 GetShortField,
1784 GetIntField,
1785 GetLongField,
1786 GetFloatField,
1787 GetDoubleField,
1788 SetObjectField,
1789 SetBooleanField,
1790 SetByteField,
1791 SetCharField,
1792 SetShortField,
1793 SetIntField,
1794 SetLongField,
1795 SetFloatField,
1796 SetDoubleField,
1797 GetStaticMethodID,
1798 CallStaticObjectMethod,
1799 CallStaticObjectMethodV,
1800 CallStaticObjectMethodA,
1801 CallStaticBooleanMethod,
1802 CallStaticBooleanMethodV,
1803 CallStaticBooleanMethodA,
1804 CallStaticByteMethod,
1805 CallStaticByteMethodV,
1806 CallStaticByteMethodA,
1807 CallStaticCharMethod,
1808 CallStaticCharMethodV,
1809 CallStaticCharMethodA,
1810 CallStaticShortMethod,
1811 CallStaticShortMethodV,
1812 CallStaticShortMethodA,
1813 CallStaticIntMethod,
1814 CallStaticIntMethodV,
1815 CallStaticIntMethodA,
1816 CallStaticLongMethod,
1817 CallStaticLongMethodV,
1818 CallStaticLongMethodA,
1819 CallStaticFloatMethod,
1820 CallStaticFloatMethodV,
1821 CallStaticFloatMethodA,
1822 CallStaticDoubleMethod,
1823 CallStaticDoubleMethodV,
1824 CallStaticDoubleMethodA,
1825 CallStaticVoidMethod,
1826 CallStaticVoidMethodV,
1827 CallStaticVoidMethodA,
1828 GetStaticFieldID,
1829 GetStaticObjectField,
1830 GetStaticBooleanField,
1831 GetStaticByteField,
1832 GetStaticCharField,
1833 GetStaticShortField,
1834 GetStaticIntField,
1835 GetStaticLongField,
1836 GetStaticFloatField,
1837 GetStaticDoubleField,
1838 SetStaticObjectField,
1839 SetStaticBooleanField,
1840 SetStaticByteField,
1841 SetStaticCharField,
1842 SetStaticShortField,
1843 SetStaticIntField,
1844 SetStaticLongField,
1845 SetStaticFloatField,
1846 SetStaticDoubleField,
1847 NewString,
1848 GetStringLength,
1849 GetStringChars,
1850 ReleaseStringChars,
1851 NewStringUTF,
1852 GetStringUTFLength,
1853 GetStringUTFChars,
1854 ReleaseStringUTFChars,
1855 GetArrayLength,
1856 NewObjectArray,
1857 GetObjectArrayElement,
1858 SetObjectArrayElement,
1859 NewBooleanArray,
1860 NewByteArray,
1861 NewCharArray,
1862 NewShortArray,
1863 NewIntArray,
1864 NewLongArray,
1865 NewFloatArray,
1866 NewDoubleArray,
1867 GetBooleanArrayElements,
1868 GetByteArrayElements,
1869 GetCharArrayElements,
1870 GetShortArrayElements,
1871 GetIntArrayElements,
1872 GetLongArrayElements,
1873 GetFloatArrayElements,
1874 GetDoubleArrayElements,
1875 ReleaseBooleanArrayElements,
1876 ReleaseByteArrayElements,
1877 ReleaseCharArrayElements,
1878 ReleaseShortArrayElements,
1879 ReleaseIntArrayElements,
1880 ReleaseLongArrayElements,
1881 ReleaseFloatArrayElements,
1882 ReleaseDoubleArrayElements,
1883 GetBooleanArrayRegion,
1884 GetByteArrayRegion,
1885 GetCharArrayRegion,
1886 GetShortArrayRegion,
1887 GetIntArrayRegion,
1888 GetLongArrayRegion,
1889 GetFloatArrayRegion,
1890 GetDoubleArrayRegion,
1891 SetBooleanArrayRegion,
1892 SetByteArrayRegion,
1893 SetCharArrayRegion,
1894 SetShortArrayRegion,
1895 SetIntArrayRegion,
1896 SetLongArrayRegion,
1897 SetFloatArrayRegion,
1898 SetDoubleArrayRegion,
1899 RegisterNatives,
1900 UnregisterNatives,
1901 MonitorEnter,
1902 MonitorExit,
1903 GetJavaVM,
1904 GetStringRegion,
1905 GetStringUTFRegion,
1906 GetPrimitiveArrayCritical,
1907 ReleasePrimitiveArrayCritical,
1908 GetStringCritical,
1909 ReleaseStringCritical,
1910 NewWeakGlobalRef,
1911 DeleteWeakGlobalRef,
1912 ExceptionCheck,
1913 NewDirectByteBuffer,
1914 GetDirectBufferAddress,
1915 GetDirectBufferCapacity,
1916 GetObjectRefType,
1917};
1918
1919// JNI Invocation interface.
1920
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700[diff] [blame]1921extern "C" jint JNI_CreateJavaVM(JavaVM** p_vm, void** p_env, void* vm_args) {
1922 const JavaVMInitArgs* args = static_cast<JavaVMInitArgs*>(vm_args);
1923 if (args->version < JNI_VERSION_1_2) {
1924 return JNI_EVERSION;
1925 }
1926 Runtime::Options options;
1927 for (int i = 0; i < args->nOptions; ++i) {
1928 JavaVMOption* option = &args->options[i];
Carl Shapirofc322c72011-07-27 00:20:01 -0700[diff] [blame]1929 options.push_back(std::make_pair(StringPiece(option->optionString),
1930 option->extraInfo));
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700[diff] [blame]1931 }
1932 bool ignore_unrecognized = args->ignoreUnrecognized;
1933 scoped_ptr<Runtime> runtime(Runtime::Create(options, ignore_unrecognized));
1934 if (runtime == NULL) {
1935 return JNI_ERR;
1936 } else {
1937 *p_env = reinterpret_cast<JNIEnv*>(Thread::Current()->GetJniEnv());
1938 *p_vm = reinterpret_cast<JavaVM*>(runtime.release());
1939 return JNI_OK;
1940 }
1941}
1942
1943extern "C" jint JNI_GetCreatedJavaVMs(JavaVM** vmBuf, jsize bufLen,
1944 jsize* nVMs) {
1945 Runtime* runtime = Runtime::Current();
1946 if (runtime == NULL) {
1947 *nVMs = 0;
1948 } else {
1949 *nVMs = 1;
1950 vmBuf[0] = reinterpret_cast<JavaVM*>(runtime);
1951 }
1952 return JNI_OK;
1953}
1954
1955// Historically unsupported.
1956extern "C" jint JNI_GetDefaultJavaVMInitArgs(void* vm_args) {
1957 return JNI_ERR;
1958}
1959
Carl Shapiroea4dca82011-08-01 13:45:38 -0700[diff] [blame^]1960jint JniInvokeInterface::DestroyJavaVM(JavaVM* vm) {
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700[diff] [blame]1961 if (vm == NULL) {
1962 return JNI_ERR;
1963 } else {
1964 Runtime* runtime = reinterpret_cast<Runtime*>(vm);
1965 delete runtime;
1966 return JNI_OK;
1967 }
1968}
1969
Carl Shapiroea4dca82011-08-01 13:45:38 -0700[diff] [blame^]1970jint JniInvokeInterface::AttachCurrentThread(JavaVM* vm,
1971 JNIEnv** p_env,
1972 void* thr_args) {
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700[diff] [blame]1973 if (vm == NULL || p_env == NULL) {
1974 return JNI_ERR;
1975 }
1976 Runtime* runtime = reinterpret_cast<Runtime*>(vm);
1977 JniEnvironment** jni_env = reinterpret_cast<JniEnvironment**>(p_env);
1978 const char* name = NULL;
1979 if (thr_args != NULL) {
1980 // TODO: check version
1981 name = static_cast<JavaVMAttachArgs*>(thr_args)->name;
1982 // TODO: thread group
1983 }
1984 bool success = runtime->AttachCurrentThread(name, jni_env);
1985 if (!success) {
1986 return JNI_ERR;
1987 } else {
1988 return JNI_OK;
1989 }
1990}
1991
Carl Shapiroea4dca82011-08-01 13:45:38 -0700[diff] [blame^]1992jint JniInvokeInterface::DetachCurrentThread(JavaVM* vm) {
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700[diff] [blame]1993 if (vm == NULL) {
1994 return JNI_ERR;
1995 } else {
1996 Runtime* runtime = reinterpret_cast<Runtime*>(vm);
1997 runtime->DetachCurrentThread();
1998 return JNI_OK;
1999 }
2000}
2001
Carl Shapiroea4dca82011-08-01 13:45:38 -0700[diff] [blame^]2002jint JniInvokeInterface::GetEnv(JavaVM *vm, void **env, jint version) {
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700[diff] [blame]2003 if (version < JNI_VERSION_1_1 || version > JNI_VERSION_1_6) {
2004 return JNI_EVERSION;
2005 }
2006 if (vm == NULL || env == NULL) {
2007 return JNI_ERR;
2008 }
2009 Thread* thread = Thread::Current();
2010 if (thread == NULL) {
2011 *env = NULL;
2012 return JNI_EDETACHED;
2013 }
2014 *env = thread->GetJniEnv();
2015 return JNI_OK;
2016}
2017
Carl Shapiroea4dca82011-08-01 13:45:38 -0700[diff] [blame^]2018jint JniInvokeInterface::AttachCurrentThreadAsDaemon(JavaVM* vm,
2019 JNIEnv** p_env,
2020 void* thr_args) {
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700[diff] [blame]2021 if (vm == NULL || p_env == NULL) {
2022 return JNI_ERR;
2023 }
2024 Runtime* runtime = reinterpret_cast<Runtime*>(vm);
2025 JniEnvironment** jni_env = reinterpret_cast<JniEnvironment**>(p_env);
2026 const char* name = NULL;
2027 if (thr_args != NULL) {
2028 // TODO: check version
2029 name = static_cast<JavaVMAttachArgs*>(thr_args)->name;
2030 // TODO: thread group
2031 }
2032 bool success = runtime->AttachCurrentThreadAsDaemon(name, jni_env);
2033 if (!success) {
2034 return JNI_ERR;
2035 } else {
2036 return JNI_OK;
2037 }
2038}
2039
Carl Shapiroea4dca82011-08-01 13:45:38 -0700[diff] [blame^]2040struct JNIInvokeInterface JniInvokeInterface::invoke_interface_ = {
2041 NULL, // reserved0
2042 NULL, // reserved1
2043 NULL, // reserved2
2044 DestroyJavaVM,
2045 AttachCurrentThread,
2046 DetachCurrentThread,
2047 GetEnv,
2048 AttachCurrentThreadAsDaemon
2049};
2050
Ian Rogersdf20fe02011-07-20 20:34:16 -0700[diff] [blame]2051} // namespace art