| /* |
| * Copyright (C) 2006 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /* |
| * JNI specification, as defined by Sun: |
| * http://java.sun.com/javase/6/docs/technotes/guides/jni/spec/jniTOC.html |
| * |
| * Everything here is expected to be VM-neutral. |
| */ |
| |
| #ifndef JNI_H_ |
| #define JNI_H_ |
| |
| #include <sys/cdefs.h> |
| #include <stdarg.h> |
| |
| /* |
| * Primitive types that match up with Java equivalents. |
| */ |
| #ifdef HAVE_INTTYPES_H |
| # include <inttypes.h> /* C99 */ |
| typedef uint8_t jboolean; /* unsigned 8 bits */ |
| typedef int8_t jbyte; /* signed 8 bits */ |
| typedef uint16_t jchar; /* unsigned 16 bits */ |
| typedef int16_t jshort; /* signed 16 bits */ |
| typedef int32_t jint; /* signed 32 bits */ |
| typedef int64_t jlong; /* signed 64 bits */ |
| typedef float jfloat; /* 32-bit IEEE 754 */ |
| typedef double jdouble; /* 64-bit IEEE 754 */ |
| #else |
| typedef unsigned char jboolean; /* unsigned 8 bits */ |
| typedef signed char jbyte; /* signed 8 bits */ |
| typedef unsigned short jchar; /* unsigned 16 bits */ |
| typedef short jshort; /* signed 16 bits */ |
| typedef int jint; /* signed 32 bits */ |
| typedef long long jlong; /* signed 64 bits */ |
| typedef float jfloat; /* 32-bit IEEE 754 */ |
| typedef double jdouble; /* 64-bit IEEE 754 */ |
| #endif |
| |
| /* "cardinal indices and sizes" */ |
| typedef jint jsize; |
| |
| #ifdef __cplusplus |
| /* |
| * Reference types, in C++ |
| */ |
| class _jobject {}; |
| class _jclass : public _jobject {}; |
| class _jstring : public _jobject {}; |
| class _jarray : public _jobject {}; |
| class _jobjectArray : public _jarray {}; |
| class _jbooleanArray : public _jarray {}; |
| class _jbyteArray : public _jarray {}; |
| class _jcharArray : public _jarray {}; |
| class _jshortArray : public _jarray {}; |
| class _jintArray : public _jarray {}; |
| class _jlongArray : public _jarray {}; |
| class _jfloatArray : public _jarray {}; |
| class _jdoubleArray : public _jarray {}; |
| class _jthrowable : public _jobject {}; |
| |
| typedef _jobject* jobject; |
| typedef _jclass* jclass; |
| typedef _jstring* jstring; |
| typedef _jarray* jarray; |
| typedef _jobjectArray* jobjectArray; |
| typedef _jbooleanArray* jbooleanArray; |
| typedef _jbyteArray* jbyteArray; |
| typedef _jcharArray* jcharArray; |
| typedef _jshortArray* jshortArray; |
| typedef _jintArray* jintArray; |
| typedef _jlongArray* jlongArray; |
| typedef _jfloatArray* jfloatArray; |
| typedef _jdoubleArray* jdoubleArray; |
| typedef _jthrowable* jthrowable; |
| typedef _jobject* jweak; |
| |
| |
| #else /* not __cplusplus */ |
| |
| /* |
| * Reference types, in C. |
| */ |
| typedef void* jobject; |
| typedef jobject jclass; |
| typedef jobject jstring; |
| typedef jobject jarray; |
| typedef jarray jobjectArray; |
| typedef jarray jbooleanArray; |
| typedef jarray jbyteArray; |
| typedef jarray jcharArray; |
| typedef jarray jshortArray; |
| typedef jarray jintArray; |
| typedef jarray jlongArray; |
| typedef jarray jfloatArray; |
| typedef jarray jdoubleArray; |
| typedef jobject jthrowable; |
| typedef jobject jweak; |
| |
| #endif /* not __cplusplus */ |
| |
| struct _jfieldID; /* opaque structure */ |
| typedef struct _jfieldID* jfieldID; /* field IDs */ |
| |
| struct _jmethodID; /* opaque structure */ |
| typedef struct _jmethodID* jmethodID; /* method IDs */ |
| |
| struct JNIInvokeInterface; |
| |
| typedef union jvalue { |
| jboolean z; |
| jbyte b; |
| jchar c; |
| jshort s; |
| jint i; |
| jlong j; |
| jfloat f; |
| jdouble d; |
| jobject l; |
| } jvalue; |
| |
| typedef enum jobjectRefType { |
| JNIInvalidRefType = 0, |
| JNILocalRefType = 1, |
| JNIGlobalRefType = 2, |
| JNIWeakGlobalRefType = 3 |
| } jobjectRefType; |
| |
| typedef struct { |
| const char* name; |
| const char* signature; |
| void* fnPtr; |
| } JNINativeMethod; |
| |
| struct _JNIEnv; |
| struct _JavaVM; |
| typedef const struct JNINativeInterface* C_JNIEnv; |
| |
| #if defined(__cplusplus) |
| typedef _JNIEnv JNIEnv; |
| typedef _JavaVM JavaVM; |
| #else |
| typedef const struct JNINativeInterface* JNIEnv; |
| typedef const struct JNIInvokeInterface* JavaVM; |
| #endif |
| |
| /* |
| * Table of interface function pointers. |
| */ |
| struct JNINativeInterface { |
| void* reserved0; |
| void* reserved1; |
| void* reserved2; |
| void* reserved3; |
| |
| jint (*GetVersion)(JNIEnv *); |
| |
| jclass (*DefineClass)(JNIEnv*, const char*, jobject, const jbyte*, |
| jsize); |
| jclass (*FindClass)(JNIEnv*, const char*); |
| |
| jmethodID (*FromReflectedMethod)(JNIEnv*, jobject); |
| jfieldID (*FromReflectedField)(JNIEnv*, jobject); |
| /* spec doesn't show jboolean parameter */ |
| jobject (*ToReflectedMethod)(JNIEnv*, jclass, jmethodID, jboolean); |
| |
| jclass (*GetSuperclass)(JNIEnv*, jclass); |
| jboolean (*IsAssignableFrom)(JNIEnv*, jclass, jclass); |
| |
| /* spec doesn't show jboolean parameter */ |
| jobject (*ToReflectedField)(JNIEnv*, jclass, jfieldID, jboolean); |
| |
| jint (*Throw)(JNIEnv*, jthrowable); |
| jint (*ThrowNew)(JNIEnv *, jclass, const char *); |
| jthrowable (*ExceptionOccurred)(JNIEnv*); |
| void (*ExceptionDescribe)(JNIEnv*); |
| void (*ExceptionClear)(JNIEnv*); |
| void (*FatalError)(JNIEnv*, const char*); |
| |
| jint (*PushLocalFrame)(JNIEnv*, jint); |
| jobject (*PopLocalFrame)(JNIEnv*, jobject); |
| |
| jobject (*NewGlobalRef)(JNIEnv*, jobject); |
| void (*DeleteGlobalRef)(JNIEnv*, jobject); |
| void (*DeleteLocalRef)(JNIEnv*, jobject); |
| jboolean (*IsSameObject)(JNIEnv*, jobject, jobject); |
| |
| jobject (*NewLocalRef)(JNIEnv*, jobject); |
| jint (*EnsureLocalCapacity)(JNIEnv*, jint); |
| |
| jobject (*AllocObject)(JNIEnv*, jclass); |
| jobject (*NewObject)(JNIEnv*, jclass, jmethodID, ...); |
| jobject (*NewObjectV)(JNIEnv*, jclass, jmethodID, va_list); |
| jobject (*NewObjectA)(JNIEnv*, jclass, jmethodID, jvalue*); |
| |
| jclass (*GetObjectClass)(JNIEnv*, jobject); |
| jboolean (*IsInstanceOf)(JNIEnv*, jobject, jclass); |
| jmethodID (*GetMethodID)(JNIEnv*, jclass, const char*, const char*); |
| |
| jobject (*CallObjectMethod)(JNIEnv*, jobject, jmethodID, ...); |
| jobject (*CallObjectMethodV)(JNIEnv*, jobject, jmethodID, va_list); |
| jobject (*CallObjectMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); |
| jboolean (*CallBooleanMethod)(JNIEnv*, jobject, jmethodID, ...); |
| jboolean (*CallBooleanMethodV)(JNIEnv*, jobject, jmethodID, va_list); |
| jboolean (*CallBooleanMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); |
| jbyte (*CallByteMethod)(JNIEnv*, jobject, jmethodID, ...); |
| jbyte (*CallByteMethodV)(JNIEnv*, jobject, jmethodID, va_list); |
| jbyte (*CallByteMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); |
| jchar (*CallCharMethod)(JNIEnv*, jobject, jmethodID, ...); |
| jchar (*CallCharMethodV)(JNIEnv*, jobject, jmethodID, va_list); |
| jchar (*CallCharMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); |
| jshort (*CallShortMethod)(JNIEnv*, jobject, jmethodID, ...); |
| jshort (*CallShortMethodV)(JNIEnv*, jobject, jmethodID, va_list); |
| jshort (*CallShortMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); |
| jint (*CallIntMethod)(JNIEnv*, jobject, jmethodID, ...); |
| jint (*CallIntMethodV)(JNIEnv*, jobject, jmethodID, va_list); |
| jint (*CallIntMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); |
| jlong (*CallLongMethod)(JNIEnv*, jobject, jmethodID, ...); |
| jlong (*CallLongMethodV)(JNIEnv*, jobject, jmethodID, va_list); |
| jlong (*CallLongMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); |
| jfloat (*CallFloatMethod)(JNIEnv*, jobject, jmethodID, ...); |
| jfloat (*CallFloatMethodV)(JNIEnv*, jobject, jmethodID, va_list); |
| jfloat (*CallFloatMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); |
| jdouble (*CallDoubleMethod)(JNIEnv*, jobject, jmethodID, ...); |
| jdouble (*CallDoubleMethodV)(JNIEnv*, jobject, jmethodID, va_list); |
| jdouble (*CallDoubleMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); |
| void (*CallVoidMethod)(JNIEnv*, jobject, jmethodID, ...); |
| void (*CallVoidMethodV)(JNIEnv*, jobject, jmethodID, va_list); |
| void (*CallVoidMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); |
| |
| jobject (*CallNonvirtualObjectMethod)(JNIEnv*, jobject, jclass, |
| jmethodID, ...); |
| jobject (*CallNonvirtualObjectMethodV)(JNIEnv*, jobject, jclass, |
| jmethodID, va_list); |
| jobject (*CallNonvirtualObjectMethodA)(JNIEnv*, jobject, jclass, |
| jmethodID, jvalue*); |
| jboolean (*CallNonvirtualBooleanMethod)(JNIEnv*, jobject, jclass, |
| jmethodID, ...); |
| jboolean (*CallNonvirtualBooleanMethodV)(JNIEnv*, jobject, jclass, |
| jmethodID, va_list); |
| jboolean (*CallNonvirtualBooleanMethodA)(JNIEnv*, jobject, jclass, |
| jmethodID, jvalue*); |
| jbyte (*CallNonvirtualByteMethod)(JNIEnv*, jobject, jclass, |
| jmethodID, ...); |
| jbyte (*CallNonvirtualByteMethodV)(JNIEnv*, jobject, jclass, |
| jmethodID, va_list); |
| jbyte (*CallNonvirtualByteMethodA)(JNIEnv*, jobject, jclass, |
| jmethodID, jvalue*); |
| jchar (*CallNonvirtualCharMethod)(JNIEnv*, jobject, jclass, |
| jmethodID, ...); |
| jchar (*CallNonvirtualCharMethodV)(JNIEnv*, jobject, jclass, |
| jmethodID, va_list); |
| jchar (*CallNonvirtualCharMethodA)(JNIEnv*, jobject, jclass, |
| jmethodID, jvalue*); |
| jshort (*CallNonvirtualShortMethod)(JNIEnv*, jobject, jclass, |
| jmethodID, ...); |
| jshort (*CallNonvirtualShortMethodV)(JNIEnv*, jobject, jclass, |
| jmethodID, va_list); |
| jshort (*CallNonvirtualShortMethodA)(JNIEnv*, jobject, jclass, |
| jmethodID, jvalue*); |
| jint (*CallNonvirtualIntMethod)(JNIEnv*, jobject, jclass, |
| jmethodID, ...); |
| jint (*CallNonvirtualIntMethodV)(JNIEnv*, jobject, jclass, |
| jmethodID, va_list); |
| jint (*CallNonvirtualIntMethodA)(JNIEnv*, jobject, jclass, |
| jmethodID, jvalue*); |
| jlong (*CallNonvirtualLongMethod)(JNIEnv*, jobject, jclass, |
| jmethodID, ...); |
| jlong (*CallNonvirtualLongMethodV)(JNIEnv*, jobject, jclass, |
| jmethodID, va_list); |
| jlong (*CallNonvirtualLongMethodA)(JNIEnv*, jobject, jclass, |
| jmethodID, jvalue*); |
| jfloat (*CallNonvirtualFloatMethod)(JNIEnv*, jobject, jclass, |
| jmethodID, ...); |
| jfloat (*CallNonvirtualFloatMethodV)(JNIEnv*, jobject, jclass, |
| jmethodID, va_list); |
| jfloat (*CallNonvirtualFloatMethodA)(JNIEnv*, jobject, jclass, |
| jmethodID, jvalue*); |
| jdouble (*CallNonvirtualDoubleMethod)(JNIEnv*, jobject, jclass, |
| jmethodID, ...); |
| jdouble (*CallNonvirtualDoubleMethodV)(JNIEnv*, jobject, jclass, |
| jmethodID, va_list); |
| jdouble (*CallNonvirtualDoubleMethodA)(JNIEnv*, jobject, jclass, |
| jmethodID, jvalue*); |
| void (*CallNonvirtualVoidMethod)(JNIEnv*, jobject, jclass, |
| jmethodID, ...); |
| void (*CallNonvirtualVoidMethodV)(JNIEnv*, jobject, jclass, |
| jmethodID, va_list); |
| void (*CallNonvirtualVoidMethodA)(JNIEnv*, jobject, jclass, |
| jmethodID, jvalue*); |
| |
| jfieldID (*GetFieldID)(JNIEnv*, jclass, const char*, const char*); |
| |
| jobject (*GetObjectField)(JNIEnv*, jobject, jfieldID); |
| jboolean (*GetBooleanField)(JNIEnv*, jobject, jfieldID); |
| jbyte (*GetByteField)(JNIEnv*, jobject, jfieldID); |
| jchar (*GetCharField)(JNIEnv*, jobject, jfieldID); |
| jshort (*GetShortField)(JNIEnv*, jobject, jfieldID); |
| jint (*GetIntField)(JNIEnv*, jobject, jfieldID); |
| jlong (*GetLongField)(JNIEnv*, jobject, jfieldID); |
| jfloat (*GetFloatField)(JNIEnv*, jobject, jfieldID); |
| jdouble (*GetDoubleField)(JNIEnv*, jobject, jfieldID); |
| |
| void (*SetObjectField)(JNIEnv*, jobject, jfieldID, jobject); |
| void (*SetBooleanField)(JNIEnv*, jobject, jfieldID, jboolean); |
| void (*SetByteField)(JNIEnv*, jobject, jfieldID, jbyte); |
| void (*SetCharField)(JNIEnv*, jobject, jfieldID, jchar); |
| void (*SetShortField)(JNIEnv*, jobject, jfieldID, jshort); |
| void (*SetIntField)(JNIEnv*, jobject, jfieldID, jint); |
| void (*SetLongField)(JNIEnv*, jobject, jfieldID, jlong); |
| void (*SetFloatField)(JNIEnv*, jobject, jfieldID, jfloat); |
| void (*SetDoubleField)(JNIEnv*, jobject, jfieldID, jdouble); |
| |
| jmethodID (*GetStaticMethodID)(JNIEnv*, jclass, const char*, const char*); |
| |
| jobject (*CallStaticObjectMethod)(JNIEnv*, jclass, jmethodID, ...); |
| jobject (*CallStaticObjectMethodV)(JNIEnv*, jclass, jmethodID, va_list); |
| jobject (*CallStaticObjectMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); |
| jboolean (*CallStaticBooleanMethod)(JNIEnv*, jclass, jmethodID, ...); |
| jboolean (*CallStaticBooleanMethodV)(JNIEnv*, jclass, jmethodID, |
| va_list); |
| jboolean (*CallStaticBooleanMethodA)(JNIEnv*, jclass, jmethodID, |
| jvalue*); |
| jbyte (*CallStaticByteMethod)(JNIEnv*, jclass, jmethodID, ...); |
| jbyte (*CallStaticByteMethodV)(JNIEnv*, jclass, jmethodID, va_list); |
| jbyte (*CallStaticByteMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); |
| jchar (*CallStaticCharMethod)(JNIEnv*, jclass, jmethodID, ...); |
| jchar (*CallStaticCharMethodV)(JNIEnv*, jclass, jmethodID, va_list); |
| jchar (*CallStaticCharMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); |
| jshort (*CallStaticShortMethod)(JNIEnv*, jclass, jmethodID, ...); |
| jshort (*CallStaticShortMethodV)(JNIEnv*, jclass, jmethodID, va_list); |
| jshort (*CallStaticShortMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); |
| jint (*CallStaticIntMethod)(JNIEnv*, jclass, jmethodID, ...); |
| jint (*CallStaticIntMethodV)(JNIEnv*, jclass, jmethodID, va_list); |
| jint (*CallStaticIntMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); |
| jlong (*CallStaticLongMethod)(JNIEnv*, jclass, jmethodID, ...); |
| jlong (*CallStaticLongMethodV)(JNIEnv*, jclass, jmethodID, va_list); |
| jlong (*CallStaticLongMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); |
| jfloat (*CallStaticFloatMethod)(JNIEnv*, jclass, jmethodID, ...); |
| jfloat (*CallStaticFloatMethodV)(JNIEnv*, jclass, jmethodID, va_list); |
| jfloat (*CallStaticFloatMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); |
| jdouble (*CallStaticDoubleMethod)(JNIEnv*, jclass, jmethodID, ...); |
| jdouble (*CallStaticDoubleMethodV)(JNIEnv*, jclass, jmethodID, va_list); |
| jdouble (*CallStaticDoubleMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); |
| void (*CallStaticVoidMethod)(JNIEnv*, jclass, jmethodID, ...); |
| void (*CallStaticVoidMethodV)(JNIEnv*, jclass, jmethodID, va_list); |
| void (*CallStaticVoidMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); |
| |
| jfieldID (*GetStaticFieldID)(JNIEnv*, jclass, const char*, |
| const char*); |
| |
| jobject (*GetStaticObjectField)(JNIEnv*, jclass, jfieldID); |
| jboolean (*GetStaticBooleanField)(JNIEnv*, jclass, jfieldID); |
| jbyte (*GetStaticByteField)(JNIEnv*, jclass, jfieldID); |
| jchar (*GetStaticCharField)(JNIEnv*, jclass, jfieldID); |
| jshort (*GetStaticShortField)(JNIEnv*, jclass, jfieldID); |
| jint (*GetStaticIntField)(JNIEnv*, jclass, jfieldID); |
| jlong (*GetStaticLongField)(JNIEnv*, jclass, jfieldID); |
| jfloat (*GetStaticFloatField)(JNIEnv*, jclass, jfieldID); |
| jdouble (*GetStaticDoubleField)(JNIEnv*, jclass, jfieldID); |
| |
| void (*SetStaticObjectField)(JNIEnv*, jclass, jfieldID, jobject); |
| void (*SetStaticBooleanField)(JNIEnv*, jclass, jfieldID, jboolean); |
| void (*SetStaticByteField)(JNIEnv*, jclass, jfieldID, jbyte); |
| void (*SetStaticCharField)(JNIEnv*, jclass, jfieldID, jchar); |
| void (*SetStaticShortField)(JNIEnv*, jclass, jfieldID, jshort); |
| void (*SetStaticIntField)(JNIEnv*, jclass, jfieldID, jint); |
| void (*SetStaticLongField)(JNIEnv*, jclass, jfieldID, jlong); |
| void (*SetStaticFloatField)(JNIEnv*, jclass, jfieldID, jfloat); |
| void (*SetStaticDoubleField)(JNIEnv*, jclass, jfieldID, jdouble); |
| |
| jstring (*NewString)(JNIEnv*, const jchar*, jsize); |
| jsize (*GetStringLength)(JNIEnv*, jstring); |
| const jchar* (*GetStringChars)(JNIEnv*, jstring, jboolean*); |
| void (*ReleaseStringChars)(JNIEnv*, jstring, const jchar*); |
| jstring (*NewStringUTF)(JNIEnv*, const char*); |
| jsize (*GetStringUTFLength)(JNIEnv*, jstring); |
| /* JNI spec says this returns const jbyte*, but that's inconsistent */ |
| const char* (*GetStringUTFChars)(JNIEnv*, jstring, jboolean*); |
| void (*ReleaseStringUTFChars)(JNIEnv*, jstring, const char*); |
| jsize (*GetArrayLength)(JNIEnv*, jarray); |
| jobjectArray (*NewObjectArray)(JNIEnv*, jsize, jclass, jobject); |
| jobject (*GetObjectArrayElement)(JNIEnv*, jobjectArray, jsize); |
| void (*SetObjectArrayElement)(JNIEnv*, jobjectArray, jsize, jobject); |
| |
| jbooleanArray (*NewBooleanArray)(JNIEnv*, jsize); |
| jbyteArray (*NewByteArray)(JNIEnv*, jsize); |
| jcharArray (*NewCharArray)(JNIEnv*, jsize); |
| jshortArray (*NewShortArray)(JNIEnv*, jsize); |
| jintArray (*NewIntArray)(JNIEnv*, jsize); |
| jlongArray (*NewLongArray)(JNIEnv*, jsize); |
| jfloatArray (*NewFloatArray)(JNIEnv*, jsize); |
| jdoubleArray (*NewDoubleArray)(JNIEnv*, jsize); |
| |
| jboolean* (*GetBooleanArrayElements)(JNIEnv*, jbooleanArray, jboolean*); |
| jbyte* (*GetByteArrayElements)(JNIEnv*, jbyteArray, jboolean*); |
| jchar* (*GetCharArrayElements)(JNIEnv*, jcharArray, jboolean*); |
| jshort* (*GetShortArrayElements)(JNIEnv*, jshortArray, jboolean*); |
| jint* (*GetIntArrayElements)(JNIEnv*, jintArray, jboolean*); |
| jlong* (*GetLongArrayElements)(JNIEnv*, jlongArray, jboolean*); |
| jfloat* (*GetFloatArrayElements)(JNIEnv*, jfloatArray, jboolean*); |
| jdouble* (*GetDoubleArrayElements)(JNIEnv*, jdoubleArray, jboolean*); |
| |
| void (*ReleaseBooleanArrayElements)(JNIEnv*, jbooleanArray, |
| jboolean*, jint); |
| void (*ReleaseByteArrayElements)(JNIEnv*, jbyteArray, |
| jbyte*, jint); |
| void (*ReleaseCharArrayElements)(JNIEnv*, jcharArray, |
| jchar*, jint); |
| void (*ReleaseShortArrayElements)(JNIEnv*, jshortArray, |
| jshort*, jint); |
| void (*ReleaseIntArrayElements)(JNIEnv*, jintArray, |
| jint*, jint); |
| void (*ReleaseLongArrayElements)(JNIEnv*, jlongArray, |
| jlong*, jint); |
| void (*ReleaseFloatArrayElements)(JNIEnv*, jfloatArray, |
| jfloat*, jint); |
| void (*ReleaseDoubleArrayElements)(JNIEnv*, jdoubleArray, |
| jdouble*, jint); |
| |
| void (*GetBooleanArrayRegion)(JNIEnv*, jbooleanArray, |
| jsize, jsize, jboolean*); |
| void (*GetByteArrayRegion)(JNIEnv*, jbyteArray, |
| jsize, jsize, jbyte*); |
| void (*GetCharArrayRegion)(JNIEnv*, jcharArray, |
| jsize, jsize, jchar*); |
| void (*GetShortArrayRegion)(JNIEnv*, jshortArray, |
| jsize, jsize, jshort*); |
| void (*GetIntArrayRegion)(JNIEnv*, jintArray, |
| jsize, jsize, jint*); |
| void (*GetLongArrayRegion)(JNIEnv*, jlongArray, |
| jsize, jsize, jlong*); |
| void (*GetFloatArrayRegion)(JNIEnv*, jfloatArray, |
| jsize, jsize, jfloat*); |
| void (*GetDoubleArrayRegion)(JNIEnv*, jdoubleArray, |
| jsize, jsize, jdouble*); |
| |
| /* spec shows these without const; some jni.h do, some don't */ |
| void (*SetBooleanArrayRegion)(JNIEnv*, jbooleanArray, |
| jsize, jsize, const jboolean*); |
| void (*SetByteArrayRegion)(JNIEnv*, jbyteArray, |
| jsize, jsize, const jbyte*); |
| void (*SetCharArrayRegion)(JNIEnv*, jcharArray, |
| jsize, jsize, const jchar*); |
| void (*SetShortArrayRegion)(JNIEnv*, jshortArray, |
| jsize, jsize, const jshort*); |
| void (*SetIntArrayRegion)(JNIEnv*, jintArray, |
| jsize, jsize, const jint*); |
| void (*SetLongArrayRegion)(JNIEnv*, jlongArray, |
| jsize, jsize, const jlong*); |
| void (*SetFloatArrayRegion)(JNIEnv*, jfloatArray, |
| jsize, jsize, const jfloat*); |
| void (*SetDoubleArrayRegion)(JNIEnv*, jdoubleArray, |
| jsize, jsize, const jdouble*); |
| |
| jint (*RegisterNatives)(JNIEnv*, jclass, const JNINativeMethod*, |
| jint); |
| jint (*UnregisterNatives)(JNIEnv*, jclass); |
| jint (*MonitorEnter)(JNIEnv*, jobject); |
| jint (*MonitorExit)(JNIEnv*, jobject); |
| jint (*GetJavaVM)(JNIEnv*, JavaVM**); |
| |
| void (*GetStringRegion)(JNIEnv*, jstring, jsize, jsize, jchar*); |
| void (*GetStringUTFRegion)(JNIEnv*, jstring, jsize, jsize, char*); |
| |
| void* (*GetPrimitiveArrayCritical)(JNIEnv*, jarray, jboolean*); |
| void (*ReleasePrimitiveArrayCritical)(JNIEnv*, jarray, void*, jint); |
| |
| const jchar* (*GetStringCritical)(JNIEnv*, jstring, jboolean*); |
| void (*ReleaseStringCritical)(JNIEnv*, jstring, const jchar*); |
| |
| jweak (*NewWeakGlobalRef)(JNIEnv*, jobject); |
| void (*DeleteWeakGlobalRef)(JNIEnv*, jweak); |
| |
| jboolean (*ExceptionCheck)(JNIEnv*); |
| |
| jobject (*NewDirectByteBuffer)(JNIEnv*, void*, jlong); |
| void* (*GetDirectBufferAddress)(JNIEnv*, jobject); |
| jlong (*GetDirectBufferCapacity)(JNIEnv*, jobject); |
| |
| /* added in JNI 1.6 */ |
| jobjectRefType (*GetObjectRefType)(JNIEnv*, jobject); |
| }; |
| |
| /* |
| * C++ object wrapper. |
| * |
| * This is usually overlaid on a C struct whose first element is a |
| * JNINativeInterface*. We rely somewhat on compiler behavior. |
| */ |
| struct _JNIEnv { |
| /* do not rename this; it does not seem to be entirely opaque */ |
| const struct JNINativeInterface* functions; |
| |
| #if defined(__cplusplus) |
| |
| jint GetVersion() |
| { return functions->GetVersion(this); } |
| |
| jclass DefineClass(const char *name, jobject loader, const jbyte* buf, |
| jsize bufLen) |
| { return functions->DefineClass(this, name, loader, buf, bufLen); } |
| |
| jclass FindClass(const char* name) |
| { return functions->FindClass(this, name); } |
| |
| jmethodID FromReflectedMethod(jobject method) |
| { return functions->FromReflectedMethod(this, method); } |
| |
| jfieldID FromReflectedField(jobject field) |
| { return functions->FromReflectedField(this, field); } |
| |
| jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) |
| { return functions->ToReflectedMethod(this, cls, methodID, isStatic); } |
| |
| jclass GetSuperclass(jclass clazz) |
| { return functions->GetSuperclass(this, clazz); } |
| |
| jboolean IsAssignableFrom(jclass clazz1, jclass clazz2) |
| { return functions->IsAssignableFrom(this, clazz1, clazz2); } |
| |
| jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic) |
| { return functions->ToReflectedField(this, cls, fieldID, isStatic); } |
| |
| jint Throw(jthrowable obj) |
| { return functions->Throw(this, obj); } |
| |
| jint ThrowNew(jclass clazz, const char* message) |
| { return functions->ThrowNew(this, clazz, message); } |
| |
| jthrowable ExceptionOccurred() |
| { return functions->ExceptionOccurred(this); } |
| |
| void ExceptionDescribe() |
| { functions->ExceptionDescribe(this); } |
| |
| void ExceptionClear() |
| { functions->ExceptionClear(this); } |
| |
| void FatalError(const char* msg) |
| { functions->FatalError(this, msg); } |
| |
| jint PushLocalFrame(jint capacity) |
| { return functions->PushLocalFrame(this, capacity); } |
| |
| jobject PopLocalFrame(jobject result) |
| { return functions->PopLocalFrame(this, result); } |
| |
| jobject NewGlobalRef(jobject obj) |
| { return functions->NewGlobalRef(this, obj); } |
| |
| void DeleteGlobalRef(jobject globalRef) |
| { functions->DeleteGlobalRef(this, globalRef); } |
| |
| void DeleteLocalRef(jobject localRef) |
| { functions->DeleteLocalRef(this, localRef); } |
| |
| jboolean IsSameObject(jobject ref1, jobject ref2) |
| { return functions->IsSameObject(this, ref1, ref2); } |
| |
| jobject NewLocalRef(jobject ref) |
| { return functions->NewLocalRef(this, ref); } |
| |
| jint EnsureLocalCapacity(jint capacity) |
| { return functions->EnsureLocalCapacity(this, capacity); } |
| |
| jobject AllocObject(jclass clazz) |
| { return functions->AllocObject(this, clazz); } |
| |
| jobject NewObject(jclass clazz, jmethodID methodID, ...) |
| { |
| va_list args; |
| va_start(args, methodID); |
| jobject result = functions->NewObjectV(this, clazz, methodID, args); |
| va_end(args); |
| return result; |
| } |
| |
| jobject NewObjectV(jclass clazz, jmethodID methodID, va_list args) |
| { return functions->NewObjectV(this, clazz, methodID, args); } |
| |
| jobject NewObjectA(jclass clazz, jmethodID methodID, jvalue* args) |
| { return functions->NewObjectA(this, clazz, methodID, args); } |
| |
| jclass GetObjectClass(jobject obj) |
| { return functions->GetObjectClass(this, obj); } |
| |
| jboolean IsInstanceOf(jobject obj, jclass clazz) |
| { return functions->IsInstanceOf(this, obj, clazz); } |
| |
| jmethodID GetMethodID(jclass clazz, const char* name, const char* sig) |
| { return functions->GetMethodID(this, clazz, name, sig); } |
| |
| #define CALL_TYPE_METHOD(_jtype, _jname) \ |
| \ |
| _jtype Call##_jname##Method(jobject obj, jmethodID methodID, ...) \ |
| { \ |
| _jtype result; \ |
| va_list args; \ |
| va_start(args, methodID); \ |
| result = functions->Call##_jname##MethodV(this, obj, methodID, \ |
| args); \ |
| va_end(args); \ |
| return result; \ |
| } |
| #define CALL_TYPE_METHODV(_jtype, _jname) \ |
| \ |
| _jtype Call##_jname##MethodV(jobject obj, jmethodID methodID, \ |
| va_list args) \ |
| { return functions->Call##_jname##MethodV(this, obj, methodID, args); } |
| #define CALL_TYPE_METHODA(_jtype, _jname) \ |
| \ |
| _jtype Call##_jname##MethodA(jobject obj, jmethodID methodID, \ |
| jvalue* args) \ |
| { return functions->Call##_jname##MethodA(this, obj, methodID, args); } |
| |
| #define CALL_TYPE(_jtype, _jname) \ |
| CALL_TYPE_METHOD(_jtype, _jname) \ |
| CALL_TYPE_METHODV(_jtype, _jname) \ |
| CALL_TYPE_METHODA(_jtype, _jname) |
| |
| CALL_TYPE(jobject, Object) |
| CALL_TYPE(jboolean, Boolean) |
| CALL_TYPE(jbyte, Byte) |
| CALL_TYPE(jchar, Char) |
| CALL_TYPE(jshort, Short) |
| CALL_TYPE(jint, Int) |
| CALL_TYPE(jlong, Long) |
| CALL_TYPE(jfloat, Float) |
| CALL_TYPE(jdouble, Double) |
| |
| void CallVoidMethod(jobject obj, jmethodID methodID, ...) |
| { |
| va_list args; |
| va_start(args, methodID); |
| functions->CallVoidMethodV(this, obj, methodID, args); |
| va_end(args); |
| } |
| void CallVoidMethodV(jobject obj, jmethodID methodID, va_list args) |
| { functions->CallVoidMethodV(this, obj, methodID, args); } |
| void CallVoidMethodA(jobject obj, jmethodID methodID, jvalue* args) |
| { functions->CallVoidMethodA(this, obj, methodID, args); } |
| |
| #define CALL_NONVIRT_TYPE_METHOD(_jtype, _jname) \ |
| \ |
| _jtype CallNonvirtual##_jname##Method(jobject obj, jclass clazz, \ |
| jmethodID methodID, ...) \ |
| { \ |
| _jtype result; \ |
| va_list args; \ |
| va_start(args, methodID); \ |
| result = functions->CallNonvirtual##_jname##MethodV(this, obj, \ |
| clazz, methodID, args); \ |
| va_end(args); \ |
| return result; \ |
| } |
| #define CALL_NONVIRT_TYPE_METHODV(_jtype, _jname) \ |
| \ |
| _jtype CallNonvirtual##_jname##MethodV(jobject obj, jclass clazz, \ |
| jmethodID methodID, va_list args) \ |
| { return functions->CallNonvirtual##_jname##MethodV(this, obj, clazz, \ |
| methodID, args); } |
| #define CALL_NONVIRT_TYPE_METHODA(_jtype, _jname) \ |
| \ |
| _jtype CallNonvirtual##_jname##MethodA(jobject obj, jclass clazz, \ |
| jmethodID methodID, jvalue* args) \ |
| { return functions->CallNonvirtual##_jname##MethodA(this, obj, clazz, \ |
| methodID, args); } |
| |
| #define CALL_NONVIRT_TYPE(_jtype, _jname) \ |
| CALL_NONVIRT_TYPE_METHOD(_jtype, _jname) \ |
| CALL_NONVIRT_TYPE_METHODV(_jtype, _jname) \ |
| CALL_NONVIRT_TYPE_METHODA(_jtype, _jname) |
| |
| CALL_NONVIRT_TYPE(jobject, Object) |
| CALL_NONVIRT_TYPE(jboolean, Boolean) |
| CALL_NONVIRT_TYPE(jbyte, Byte) |
| CALL_NONVIRT_TYPE(jchar, Char) |
| CALL_NONVIRT_TYPE(jshort, Short) |
| CALL_NONVIRT_TYPE(jint, Int) |
| CALL_NONVIRT_TYPE(jlong, Long) |
| CALL_NONVIRT_TYPE(jfloat, Float) |
| CALL_NONVIRT_TYPE(jdouble, Double) |
| |
| void CallNonvirtualVoidMethod(jobject obj, jclass clazz, |
| jmethodID methodID, ...) |
| { |
| va_list args; |
| va_start(args, methodID); |
| functions->CallNonvirtualVoidMethodV(this, obj, clazz, methodID, args); |
| va_end(args); |
| } |
| void CallNonvirtualVoidMethodV(jobject obj, jclass clazz, |
| jmethodID methodID, va_list args) |
| { functions->CallNonvirtualVoidMethodV(this, obj, clazz, methodID, args); } |
| void CallNonvirtualVoidMethodA(jobject obj, jclass clazz, |
| jmethodID methodID, jvalue* args) |
| { functions->CallNonvirtualVoidMethodA(this, obj, clazz, methodID, args); } |
| |
| jfieldID GetFieldID(jclass clazz, const char* name, const char* sig) |
| { return functions->GetFieldID(this, clazz, name, sig); } |
| |
| jobject GetObjectField(jobject obj, jfieldID fieldID) |
| { return functions->GetObjectField(this, obj, fieldID); } |
| jboolean GetBooleanField(jobject obj, jfieldID fieldID) |
| { return functions->GetBooleanField(this, obj, fieldID); } |
| jbyte GetByteField(jobject obj, jfieldID fieldID) |
| { return functions->GetByteField(this, obj, fieldID); } |
| jchar GetCharField(jobject obj, jfieldID fieldID) |
| { return functions->GetCharField(this, obj, fieldID); } |
| jshort GetShortField(jobject obj, jfieldID fieldID) |
| { return functions->GetShortField(this, obj, fieldID); } |
| jint GetIntField(jobject obj, jfieldID fieldID) |
| { return functions->GetIntField(this, obj, fieldID); } |
| jlong GetLongField(jobject obj, jfieldID fieldID) |
| { return functions->GetLongField(this, obj, fieldID); } |
| |
| jfloat GetFloatField(jobject obj, jfieldID fieldID) |
| { return functions->GetFloatField(this, obj, fieldID); } |
| |
| jdouble GetDoubleField(jobject obj, jfieldID fieldID) |
| { return functions->GetDoubleField(this, obj, fieldID); } |
| |
| void SetObjectField(jobject obj, jfieldID fieldID, jobject value) |
| { functions->SetObjectField(this, obj, fieldID, value); } |
| void SetBooleanField(jobject obj, jfieldID fieldID, jboolean value) |
| { functions->SetBooleanField(this, obj, fieldID, value); } |
| void SetByteField(jobject obj, jfieldID fieldID, jbyte value) |
| { functions->SetByteField(this, obj, fieldID, value); } |
| void SetCharField(jobject obj, jfieldID fieldID, jchar value) |
| { functions->SetCharField(this, obj, fieldID, value); } |
| void SetShortField(jobject obj, jfieldID fieldID, jshort value) |
| { functions->SetShortField(this, obj, fieldID, value); } |
| void SetIntField(jobject obj, jfieldID fieldID, jint value) |
| { functions->SetIntField(this, obj, fieldID, value); } |
| void SetLongField(jobject obj, jfieldID fieldID, jlong value) |
| { functions->SetLongField(this, obj, fieldID, value); } |
| |
| void SetFloatField(jobject obj, jfieldID fieldID, jfloat value) |
| { functions->SetFloatField(this, obj, fieldID, value); } |
| |
| void SetDoubleField(jobject obj, jfieldID fieldID, jdouble value) |
| { functions->SetDoubleField(this, obj, fieldID, value); } |
| |
| jmethodID GetStaticMethodID(jclass clazz, const char* name, const char* sig) |
| { return functions->GetStaticMethodID(this, clazz, name, sig); } |
| |
| #define CALL_STATIC_TYPE_METHOD(_jtype, _jname) \ |
| \ |
| _jtype CallStatic##_jname##Method(jclass clazz, jmethodID methodID, \ |
| ...) \ |
| { \ |
| _jtype result; \ |
| va_list args; \ |
| va_start(args, methodID); \ |
| result = functions->CallStatic##_jname##MethodV(this, clazz, \ |
| methodID, args); \ |
| va_end(args); \ |
| return result; \ |
| } |
| #define CALL_STATIC_TYPE_METHODV(_jtype, _jname) \ |
| \ |
| _jtype CallStatic##_jname##MethodV(jclass clazz, jmethodID methodID, \ |
| va_list args) \ |
| { return functions->CallStatic##_jname##MethodV(this, clazz, methodID, \ |
| args); } |
| #define CALL_STATIC_TYPE_METHODA(_jtype, _jname) \ |
| \ |
| _jtype CallStatic##_jname##MethodA(jclass clazz, jmethodID methodID, \ |
| jvalue* args) \ |
| { return functions->CallStatic##_jname##MethodA(this, clazz, methodID, \ |
| args); } |
| |
| #define CALL_STATIC_TYPE(_jtype, _jname) \ |
| CALL_STATIC_TYPE_METHOD(_jtype, _jname) \ |
| CALL_STATIC_TYPE_METHODV(_jtype, _jname) \ |
| CALL_STATIC_TYPE_METHODA(_jtype, _jname) |
| |
| CALL_STATIC_TYPE(jobject, Object) |
| CALL_STATIC_TYPE(jboolean, Boolean) |
| CALL_STATIC_TYPE(jbyte, Byte) |
| CALL_STATIC_TYPE(jchar, Char) |
| CALL_STATIC_TYPE(jshort, Short) |
| CALL_STATIC_TYPE(jint, Int) |
| CALL_STATIC_TYPE(jlong, Long) |
| CALL_STATIC_TYPE(jfloat, Float) |
| CALL_STATIC_TYPE(jdouble, Double) |
| |
| void CallStaticVoidMethod(jclass clazz, jmethodID methodID, ...) |
| { |
| va_list args; |
| va_start(args, methodID); |
| functions->CallStaticVoidMethodV(this, clazz, methodID, args); |
| va_end(args); |
| } |
| void CallStaticVoidMethodV(jclass clazz, jmethodID methodID, va_list args) |
| { functions->CallStaticVoidMethodV(this, clazz, methodID, args); } |
| void CallStaticVoidMethodA(jclass clazz, jmethodID methodID, jvalue* args) |
| { functions->CallStaticVoidMethodA(this, clazz, methodID, args); } |
| |
| jfieldID GetStaticFieldID(jclass clazz, const char* name, const char* sig) |
| { return functions->GetStaticFieldID(this, clazz, name, sig); } |
| |
| jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) |
| { return functions->GetStaticObjectField(this, clazz, fieldID); } |
| jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) |
| { return functions->GetStaticBooleanField(this, clazz, fieldID); } |
| jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) |
| { return functions->GetStaticByteField(this, clazz, fieldID); } |
| jchar GetStaticCharField(jclass clazz, jfieldID fieldID) |
| { return functions->GetStaticCharField(this, clazz, fieldID); } |
| jshort GetStaticShortField(jclass clazz, jfieldID fieldID) |
| { return functions->GetStaticShortField(this, clazz, fieldID); } |
| jint GetStaticIntField(jclass clazz, jfieldID fieldID) |
| { return functions->GetStaticIntField(this, clazz, fieldID); } |
| jlong GetStaticLongField(jclass clazz, jfieldID fieldID) |
| { return functions->GetStaticLongField(this, clazz, fieldID); } |
| |
| jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) |
| { return functions->GetStaticFloatField(this, clazz, fieldID); } |
| |
| jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) |
| { return functions->GetStaticDoubleField(this, clazz, fieldID); } |
| |
| void SetStaticObjectField(jclass clazz, jfieldID fieldID, jobject value) |
| { functions->SetStaticObjectField(this, clazz, fieldID, value); } |
| void SetStaticBooleanField(jclass clazz, jfieldID fieldID, jboolean value) |
| { functions->SetStaticBooleanField(this, clazz, fieldID, value); } |
| void SetStaticByteField(jclass clazz, jfieldID fieldID, jbyte value) |
| { functions->SetStaticByteField(this, clazz, fieldID, value); } |
| void SetStaticCharField(jclass clazz, jfieldID fieldID, jchar value) |
| { functions->SetStaticCharField(this, clazz, fieldID, value); } |
| void SetStaticShortField(jclass clazz, jfieldID fieldID, jshort value) |
| { functions->SetStaticShortField(this, clazz, fieldID, value); } |
| void SetStaticIntField(jclass clazz, jfieldID fieldID, jint value) |
| { functions->SetStaticIntField(this, clazz, fieldID, value); } |
| void SetStaticLongField(jclass clazz, jfieldID fieldID, jlong value) |
| { functions->SetStaticLongField(this, clazz, fieldID, value); } |
| |
| void SetStaticFloatField(jclass clazz, jfieldID fieldID, jfloat value) |
| { functions->SetStaticFloatField(this, clazz, fieldID, value); } |
| |
| void SetStaticDoubleField(jclass clazz, jfieldID fieldID, jdouble value) |
| { functions->SetStaticDoubleField(this, clazz, fieldID, value); } |
| |
| jstring NewString(const jchar* unicodeChars, jsize len) |
| { return functions->NewString(this, unicodeChars, len); } |
| |
| jsize GetStringLength(jstring string) |
| { return functions->GetStringLength(this, string); } |
| |
| const jchar* GetStringChars(jstring string, jboolean* isCopy) |
| { return functions->GetStringChars(this, string, isCopy); } |
| |
| void ReleaseStringChars(jstring string, const jchar* chars) |
| { functions->ReleaseStringChars(this, string, chars); } |
| |
| jstring NewStringUTF(const char* bytes) |
| { return functions->NewStringUTF(this, bytes); } |
| |
| jsize GetStringUTFLength(jstring string) |
| { return functions->GetStringUTFLength(this, string); } |
| |
| const char* GetStringUTFChars(jstring string, jboolean* isCopy) |
| { return functions->GetStringUTFChars(this, string, isCopy); } |
| |
| void ReleaseStringUTFChars(jstring string, const char* utf) |
| { functions->ReleaseStringUTFChars(this, string, utf); } |
| |
| jsize GetArrayLength(jarray array) |
| { return functions->GetArrayLength(this, array); } |
| |
| jobjectArray NewObjectArray(jsize length, jclass elementClass, |
| jobject initialElement) |
| { return functions->NewObjectArray(this, length, elementClass, |
| initialElement); } |
| |
| jobject GetObjectArrayElement(jobjectArray array, jsize index) |
| { return functions->GetObjectArrayElement(this, array, index); } |
| |
| void SetObjectArrayElement(jobjectArray array, jsize index, jobject value) |
| { functions->SetObjectArrayElement(this, array, index, value); } |
| |
| jbooleanArray NewBooleanArray(jsize length) |
| { return functions->NewBooleanArray(this, length); } |
| jbyteArray NewByteArray(jsize length) |
| { return functions->NewByteArray(this, length); } |
| jcharArray NewCharArray(jsize length) |
| { return functions->NewCharArray(this, length); } |
| jshortArray NewShortArray(jsize length) |
| { return functions->NewShortArray(this, length); } |
| jintArray NewIntArray(jsize length) |
| { return functions->NewIntArray(this, length); } |
| jlongArray NewLongArray(jsize length) |
| { return functions->NewLongArray(this, length); } |
| jfloatArray NewFloatArray(jsize length) |
| { return functions->NewFloatArray(this, length); } |
| jdoubleArray NewDoubleArray(jsize length) |
| { return functions->NewDoubleArray(this, length); } |
| |
| jboolean* GetBooleanArrayElements(jbooleanArray array, jboolean* isCopy) |
| { return functions->GetBooleanArrayElements(this, array, isCopy); } |
| jbyte* GetByteArrayElements(jbyteArray array, jboolean* isCopy) |
| { return functions->GetByteArrayElements(this, array, isCopy); } |
| jchar* GetCharArrayElements(jcharArray array, jboolean* isCopy) |
| { return functions->GetCharArrayElements(this, array, isCopy); } |
| jshort* GetShortArrayElements(jshortArray array, jboolean* isCopy) |
| { return functions->GetShortArrayElements(this, array, isCopy); } |
| jint* GetIntArrayElements(jintArray array, jboolean* isCopy) |
| { return functions->GetIntArrayElements(this, array, isCopy); } |
| jlong* GetLongArrayElements(jlongArray array, jboolean* isCopy) |
| { return functions->GetLongArrayElements(this, array, isCopy); } |
| jfloat* GetFloatArrayElements(jfloatArray array, jboolean* isCopy) |
| { return functions->GetFloatArrayElements(this, array, isCopy); } |
| jdouble* GetDoubleArrayElements(jdoubleArray array, jboolean* isCopy) |
| { return functions->GetDoubleArrayElements(this, array, isCopy); } |
| |
| void ReleaseBooleanArrayElements(jbooleanArray array, jboolean* elems, |
| jint mode) |
| { functions->ReleaseBooleanArrayElements(this, array, elems, mode); } |
| void ReleaseByteArrayElements(jbyteArray array, jbyte* elems, |
| jint mode) |
| { functions->ReleaseByteArrayElements(this, array, elems, mode); } |
| void ReleaseCharArrayElements(jcharArray array, jchar* elems, |
| jint mode) |
| { functions->ReleaseCharArrayElements(this, array, elems, mode); } |
| void ReleaseShortArrayElements(jshortArray array, jshort* elems, |
| jint mode) |
| { functions->ReleaseShortArrayElements(this, array, elems, mode); } |
| void ReleaseIntArrayElements(jintArray array, jint* elems, |
| jint mode) |
| { functions->ReleaseIntArrayElements(this, array, elems, mode); } |
| void ReleaseLongArrayElements(jlongArray array, jlong* elems, |
| jint mode) |
| { functions->ReleaseLongArrayElements(this, array, elems, mode); } |
| void ReleaseFloatArrayElements(jfloatArray array, jfloat* elems, |
| jint mode) |
| { functions->ReleaseFloatArrayElements(this, array, elems, mode); } |
| void ReleaseDoubleArrayElements(jdoubleArray array, jdouble* elems, |
| jint mode) |
| { functions->ReleaseDoubleArrayElements(this, array, elems, mode); } |
| |
| void GetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len, |
| jboolean* buf) |
| { functions->GetBooleanArrayRegion(this, array, start, len, buf); } |
| void GetByteArrayRegion(jbyteArray array, jsize start, jsize len, |
| jbyte* buf) |
| { functions->GetByteArrayRegion(this, array, start, len, buf); } |
| void GetCharArrayRegion(jcharArray array, jsize start, jsize len, |
| jchar* buf) |
| { functions->GetCharArrayRegion(this, array, start, len, buf); } |
| void GetShortArrayRegion(jshortArray array, jsize start, jsize len, |
| jshort* buf) |
| { functions->GetShortArrayRegion(this, array, start, len, buf); } |
| void GetIntArrayRegion(jintArray array, jsize start, jsize len, |
| jint* buf) |
| { functions->GetIntArrayRegion(this, array, start, len, buf); } |
| void GetLongArrayRegion(jlongArray array, jsize start, jsize len, |
| jlong* buf) |
| { functions->GetLongArrayRegion(this, array, start, len, buf); } |
| void GetFloatArrayRegion(jfloatArray array, jsize start, jsize len, |
| jfloat* buf) |
| { functions->GetFloatArrayRegion(this, array, start, len, buf); } |
| void GetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len, |
| jdouble* buf) |
| { functions->GetDoubleArrayRegion(this, array, start, len, buf); } |
| |
| void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len, |
| const jboolean* buf) |
| { functions->SetBooleanArrayRegion(this, array, start, len, buf); } |
| void SetByteArrayRegion(jbyteArray array, jsize start, jsize len, |
| const jbyte* buf) |
| { functions->SetByteArrayRegion(this, array, start, len, buf); } |
| void SetCharArrayRegion(jcharArray array, jsize start, jsize len, |
| const jchar* buf) |
| { functions->SetCharArrayRegion(this, array, start, len, buf); } |
| void SetShortArrayRegion(jshortArray array, jsize start, jsize len, |
| const jshort* buf) |
| { functions->SetShortArrayRegion(this, array, start, len, buf); } |
| void SetIntArrayRegion(jintArray array, jsize start, jsize len, |
| const jint* buf) |
| { functions->SetIntArrayRegion(this, array, start, len, buf); } |
| void SetLongArrayRegion(jlongArray array, jsize start, jsize len, |
| const jlong* buf) |
| { functions->SetLongArrayRegion(this, array, start, len, buf); } |
| void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len, |
| const jfloat* buf) |
| { functions->SetFloatArrayRegion(this, array, start, len, buf); } |
| void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len, |
| const jdouble* buf) |
| { functions->SetDoubleArrayRegion(this, array, start, len, buf); } |
| |
| jint RegisterNatives(jclass clazz, const JNINativeMethod* methods, |
| jint nMethods) |
| { return functions->RegisterNatives(this, clazz, methods, nMethods); } |
| |
| jint UnregisterNatives(jclass clazz) |
| { return functions->UnregisterNatives(this, clazz); } |
| |
| jint MonitorEnter(jobject obj) |
| { return functions->MonitorEnter(this, obj); } |
| |
| jint MonitorExit(jobject obj) |
| { return functions->MonitorExit(this, obj); } |
| |
| jint GetJavaVM(JavaVM** vm) |
| { return functions->GetJavaVM(this, vm); } |
| |
| void GetStringRegion(jstring str, jsize start, jsize len, jchar* buf) |
| { functions->GetStringRegion(this, str, start, len, buf); } |
| |
| void GetStringUTFRegion(jstring str, jsize start, jsize len, char* buf) |
| { return functions->GetStringUTFRegion(this, str, start, len, buf); } |
| |
| void* GetPrimitiveArrayCritical(jarray array, jboolean* isCopy) |
| { return functions->GetPrimitiveArrayCritical(this, array, isCopy); } |
| |
| void ReleasePrimitiveArrayCritical(jarray array, void* carray, jint mode) |
| { functions->ReleasePrimitiveArrayCritical(this, array, carray, mode); } |
| |
| const jchar* GetStringCritical(jstring string, jboolean* isCopy) |
| { return functions->GetStringCritical(this, string, isCopy); } |
| |
| void ReleaseStringCritical(jstring string, const jchar* carray) |
| { functions->ReleaseStringCritical(this, string, carray); } |
| |
| jweak NewWeakGlobalRef(jobject obj) |
| { return functions->NewWeakGlobalRef(this, obj); } |
| |
| void DeleteWeakGlobalRef(jweak obj) |
| { functions->DeleteWeakGlobalRef(this, obj); } |
| |
| jboolean ExceptionCheck() |
| { return functions->ExceptionCheck(this); } |
| |
| jobject NewDirectByteBuffer(void* address, jlong capacity) |
| { return functions->NewDirectByteBuffer(this, address, capacity); } |
| |
| void* GetDirectBufferAddress(jobject buf) |
| { return functions->GetDirectBufferAddress(this, buf); } |
| |
| jlong GetDirectBufferCapacity(jobject buf) |
| { return functions->GetDirectBufferCapacity(this, buf); } |
| |
| /* added in JNI 1.6 */ |
| jobjectRefType GetObjectRefType(jobject obj) |
| { return functions->GetObjectRefType(this, obj); } |
| #endif /*__cplusplus*/ |
| }; |
| |
| |
| /* |
| * JNI invocation interface. |
| */ |
| struct JNIInvokeInterface { |
| void* reserved0; |
| void* reserved1; |
| void* reserved2; |
| |
| jint (*DestroyJavaVM)(JavaVM*); |
| jint (*AttachCurrentThread)(JavaVM*, JNIEnv**, void*); |
| jint (*DetachCurrentThread)(JavaVM*); |
| jint (*GetEnv)(JavaVM*, void**, jint); |
| jint (*AttachCurrentThreadAsDaemon)(JavaVM*, JNIEnv**, void*); |
| }; |
| |
| /* |
| * C++ version. |
| */ |
| struct _JavaVM { |
| const struct JNIInvokeInterface* functions; |
| |
| #if defined(__cplusplus) |
| jint DestroyJavaVM() |
| { return functions->DestroyJavaVM(this); } |
| jint AttachCurrentThread(JNIEnv** p_env, void* thr_args) |
| { return functions->AttachCurrentThread(this, p_env, thr_args); } |
| jint DetachCurrentThread() |
| { return functions->DetachCurrentThread(this); } |
| jint GetEnv(void** env, jint version) |
| { return functions->GetEnv(this, env, version); } |
| jint AttachCurrentThreadAsDaemon(JNIEnv** p_env, void* thr_args) |
| { return functions->AttachCurrentThreadAsDaemon(this, p_env, thr_args); } |
| #endif /*__cplusplus*/ |
| }; |
| |
| struct JavaVMAttachArgs { |
| jint version; /* must be >= JNI_VERSION_1_2 */ |
| const char* name; /* NULL or name of thread as modified UTF-8 str */ |
| jobject group; /* global ref of a ThreadGroup object, or NULL */ |
| }; |
| typedef struct JavaVMAttachArgs JavaVMAttachArgs; |
| |
| /* |
| * JNI 1.2+ initialization. (As of 1.6, the pre-1.2 structures are no |
| * longer supported.) |
| */ |
| typedef struct JavaVMOption { |
| const char* optionString; |
| void* extraInfo; |
| } JavaVMOption; |
| |
| typedef struct JavaVMInitArgs { |
| jint version; /* use JNI_VERSION_1_2 or later */ |
| |
| jint nOptions; |
| JavaVMOption* options; |
| jboolean ignoreUnrecognized; |
| } JavaVMInitArgs; |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| /* |
| * VM initialization functions. |
| * |
| * Note these are the only symbols exported for JNI by the VM. |
| */ |
| #if 0 /* In practice, these are not exported by the NDK so don't declare them */ |
| jint JNI_GetDefaultJavaVMInitArgs(void*); |
| jint JNI_CreateJavaVM(JavaVM**, JNIEnv**, void*); |
| jint JNI_GetCreatedJavaVMs(JavaVM**, jsize, jsize*); |
| #endif |
| |
| #define JNIIMPORT |
| #define JNIEXPORT __attribute__ ((visibility ("default"))) |
| #define JNICALL |
| |
| /* |
| * Prototypes for functions exported by loadable shared libs. These are |
| * called by JNI, not provided by JNI. |
| */ |
| JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved); |
| JNIEXPORT void JNICALL JNI_OnUnload(JavaVM* vm, void* reserved); |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| |
| /* |
| * Manifest constants. |
| */ |
| #define JNI_FALSE 0 |
| #define JNI_TRUE 1 |
| |
| #define JNI_VERSION_1_1 0x00010001 |
| #define JNI_VERSION_1_2 0x00010002 |
| #define JNI_VERSION_1_4 0x00010004 |
| #define JNI_VERSION_1_6 0x00010006 |
| |
| #define JNI_OK (0) /* no error */ |
| #define JNI_ERR (-1) /* generic error */ |
| #define JNI_EDETACHED (-2) /* thread detached from the VM */ |
| #define JNI_EVERSION (-3) /* JNI version error */ |
| |
| #define JNI_COMMIT 1 /* copy content, do not free buffer */ |
| #define JNI_ABORT 2 /* free buffer w/o copying back */ |
| |
| #endif /* JNI_H_ */ |
