您的位置: 首页  >  IT文章  >  Android jni系统变量、函数、接口定义汇总

Android jni系统变量、函数、接口定义汇总

分类: IT文章 • 2022-05-14 13:09:44

在做Android jni开发时，jni为我们提供了哪些函数、接口、变量，有时候一头雾水，今天就把jni.h中定义的所有内容列出来，供自己查阅： 

Java代码  Android jni系统变量、函数、接口定义汇总
    1. /* 
    2.  * Copyright (C) 2006 The Android Open Source Project 
    3.  * 
    4.  * Licensed under the Apache License, Version 2.0 (the "License"); 
    5.  * you may not use this file except in compliance with the License. 
    6.  * You may obtain a copy of the License at 
    7.  * 
    8.  *      http://www.apache.org/licenses/LICENSE-2.0 
    9.  * 
    10.  * Unless required by applicable law or agreed to in writing, software 
    11.  * distributed under the License is distributed on an "AS IS" BASIS, 
    12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
    13.  * See the License for the specific language governing permissions and 
    14.  * limitations under the License. 
    15.  */  
    16.   
    17. /* 
    18.  * JNI specification, as defined by Sun: 
    19.  * http://java.sun.com/javase/6/docs/technotes/guides/jni/spec/jniTOC.html 
    20.  * 
    21.  * Everything here is expected to be VM-neutral. 
    22.  */  
    23.   
    24. #ifndef JNI_H_  
    25. #define JNI_H_  
    26.   
    27. #include <sys/cdefs.h>  
    28. #include <stdarg.h>  
    29.   
    30. /* 
    31.  * Primitive types that match up with Java equivalents. 
    32.  */  
    33. #ifdef HAVE_INTTYPES_H  
    34. # include <inttypes.h>      /* C99 */  
    35. typedef uint8_t         jboolean;       /* unsigned 8 bits */  
    36. typedef int8_t          jbyte;          /* signed 8 bits */  
    37. typedef uint16_t        jchar;          /* unsigned 16 bits */  
    38. typedef int16_t         jshort;         /* signed 16 bits */  
    39. typedef int32_t         jint;           /* signed 32 bits */  
    40. typedef int64_t         jlong;          /* signed 64 bits */  
    41. typedef float           jfloat;         /* 32-bit IEEE 754 */  
    42. typedef double          jdouble;        /* 64-bit IEEE 754 */  
    43. #else  
    44. typedef unsigned char   jboolean;       /* unsigned 8 bits */  
    45. typedef signed char     jbyte;          /* signed 8 bits */  
    46. typedef unsigned short  jchar;          /* unsigned 16 bits */  
    47. typedef short           jshort;         /* signed 16 bits */  
    48. typedef int             jint;           /* signed 32 bits */  
    49. typedef long long       jlong;          /* signed 64 bits */  
    50. typedef float           jfloat;         /* 32-bit IEEE 754 */  
    51. typedef double          jdouble;        /* 64-bit IEEE 754 */  
    52. #endif  
    53.   
    54. /* "cardinal indices and sizes" */  
    55. typedef jint            jsize;  
    56.   
    57. #ifdef __cplusplus  
    58. /* 
    59.  * Reference types, in C++ 
    60.  */  
    61. class _jobject {};  
    62. class _jclass : public _jobject {};  
    63. class _jstring : public _jobject {};  
    64. class _jarray : public _jobject {};  
    65. class _jobjectArray : public _jarray {};  
    66. class _jbooleanArray : public _jarray {};  
    67. class _jbyteArray : public _jarray {};  
    68. class _jcharArray : public _jarray {};  
    69. class _jshortArray : public _jarray {};  
    70. class _jintArray : public _jarray {};  
    71. class _jlongArray : public _jarray {};  
    72. class _jfloatArray : public _jarray {};  
    73. class _jdoubleArray : public _jarray {};  
    74. class _jthrowable : public _jobject {};  
    75.   
    76. typedef _jobject*       jobject;  
    77. typedef _jclass*        jclass;  
    78. typedef _jstring*       jstring;  
    79. typedef _jarray*        jarray;  
    80. typedef _jobjectArray*  jobjectArray;  
    81. typedef _jbooleanArray* jbooleanArray;  
    82. typedef _jbyteArray*    jbyteArray;  
    83. typedef _jcharArray*    jcharArray;  
    84. typedef _jshortArray*   jshortArray;  
    85. typedef _jintArray*     jintArray;  
    86. typedef _jlongArray*    jlongArray;  
    87. typedef _jfloatArray*   jfloatArray;  
    88. typedef _jdoubleArray*  jdoubleArray;  
    89. typedef _jthrowable*    jthrowable;  
    90. typedef _jobject*       jweak;  
    91.   
    92.   
    93. #else /* not __cplusplus */  
    94.   
    95. /* 
    96.  * Reference types, in C. 
    97.  */  
    98. typedef void*           jobject;  
    99. typedef jobject         jclass;  
    100. typedef jobject         jstring;  
    101. typedef jobject         jarray;  
    102. typedef jarray          jobjectArray;  
    103. typedef jarray          jbooleanArray;  
    104. typedef jarray          jbyteArray;  
    105. typedef jarray          jcharArray;  
    106. typedef jarray          jshortArray;  
    107. typedef jarray          jintArray;  
    108. typedef jarray          jlongArray;  
    109. typedef jarray          jfloatArray;  
    110. typedef jarray          jdoubleArray;  
    111. typedef jobject         jthrowable;  
    112. typedef jobject         jweak;  
    113.   
    114. #endif /* not __cplusplus */  
    115.   
    116. struct _jfieldID;                       /* opaque structure */  
    117. typedef struct _jfieldID* jfieldID;     /* field IDs */  
    118.   
    119. struct _jmethodID;                      /* opaque structure */  
    120. typedef struct _jmethodID* jmethodID;   /* method IDs */  
    121.   
    122. struct JNIInvokeInterface;  
    123.   
    124. typedef union jvalue {  
    125.     jboolean    z;  
    126.     jbyte       b;  
    127.     jchar       c;  
    128.     jshort      s;  
    129.     jint        i;  
    130.     jlong       j;  
    131.     jfloat      f;  
    132.     jdouble     d;  
    133.     jobject     l;  
    134. } jvalue;  
    135.   
    136. typedef enum jobjectRefType {  
    137.     JNIInvalidRefType = 0,  
    138.     JNILocalRefType = 1,  
    139.     JNIGlobalRefType = 2,  
    140.     JNIWeakGlobalRefType = 3  
    141. } jobjectRefType;  
    142.   
    143. typedef struct {  
    144.     const char* name;  
    145.     const char* signature;  
    146.     void*       fnPtr;  
    147. } JNINativeMethod;  
    148.   
    149. struct _JNIEnv;  
    150. struct _JavaVM;  
    151. typedef const struct JNINativeInterface* C_JNIEnv;  
    152.   
    153. #if defined(__cplusplus)  
    154. typedef _JNIEnv JNIEnv;  
    155. typedef _JavaVM JavaVM;  
    156. #else  
    157. typedef const struct JNINativeInterface* JNIEnv;  
    158. typedef const struct JNIInvokeInterface* JavaVM;  
    159. #endif  
    160.   
    161. /* 
    162.  * Table of interface function pointers. 
    163.  */  
    164. struct JNINativeInterface {  
    165.     void*       reserved0;  
    166.     void*       reserved1;  
    167.     void*       reserved2;  
    168.     void*       reserved3;  
    169.   
    170.     jint        (*GetVersion)(JNIEnv *);  
    171.   
    172.     jclass      (*DefineClass)(JNIEnv*, const char*, jobject, const jbyte*,  
    173.                         jsize);  
    174.     jclass      (*FindClass)(JNIEnv*, const char*);  
    175.   
    176.     jmethodID   (*FromReflectedMethod)(JNIEnv*, jobject);  
    177.     jfieldID    (*FromReflectedField)(JNIEnv*, jobject);  
    178.     /* spec doesn't show jboolean parameter */  
    179.     jobject     (*ToReflectedMethod)(JNIEnv*, jclass, jmethodID, jboolean);  
    180.   
    181.     jclass      (*GetSuperclass)(JNIEnv*, jclass);  
    182.     jboolean    (*IsAssignableFrom)(JNIEnv*, jclass, jclass);  
    183.   
    184.     /* spec doesn't show jboolean parameter */  
    185.     jobject     (*ToReflectedField)(JNIEnv*, jclass, jfieldID, jboolean);  
    186.   
    187.     jint        (*Throw)(JNIEnv*, jthrowable);  
    188.     jint        (*ThrowNew)(JNIEnv *, jclass, const char *);  
    189.     jthrowable  (*ExceptionOccurred)(JNIEnv*);  
    190.     void        (*ExceptionDescribe)(JNIEnv*);  
    191.     void        (*ExceptionClear)(JNIEnv*);  
    192.     void        (*FatalError)(JNIEnv*, const char*);  
    193.   
    194.     jint        (*PushLocalFrame)(JNIEnv*, jint);  
    195.     jobject     (*PopLocalFrame)(JNIEnv*, jobject);  
    196.   
    197.     jobject     (*NewGlobalRef)(JNIEnv*, jobject);  
    198.     void        (*DeleteGlobalRef)(JNIEnv*, jobject);  
    199.     void        (*DeleteLocalRef)(JNIEnv*, jobject);  
    200.     jboolean    (*IsSameObject)(JNIEnv*, jobject, jobject);  
    201.   
    202.     jobject     (*NewLocalRef)(JNIEnv*, jobject);  
    203.     jint        (*EnsureLocalCapacity)(JNIEnv*, jint);  
    204.   
    205.     jobject     (*AllocObject)(JNIEnv*, jclass);  
    206.     jobject     (*NewObject)(JNIEnv*, jclass, jmethodID, ...);  
    207.     jobject     (*NewObjectV)(JNIEnv*, jclass, jmethodID, va_list);  
    208.     jobject     (*NewObjectA)(JNIEnv*, jclass, jmethodID, jvalue*);  
    209.   
    210.     jclass      (*GetObjectClass)(JNIEnv*, jobject);  
    211.     jboolean    (*IsInstanceOf)(JNIEnv*, jobject, jclass);  
    212.     jmethodID   (*GetMethodID)(JNIEnv*, jclass, const char*, const char*);  
    213.   
    214.     jobject     (*CallObjectMethod)(JNIEnv*, jobject, jmethodID, ...);  
    215.     jobject     (*CallObjectMethodV)(JNIEnv*, jobject, jmethodID, va_list);  
    216.     jobject     (*CallObjectMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);  
    217.     jboolean    (*CallBooleanMethod)(JNIEnv*, jobject, jmethodID, ...);  
    218.     jboolean    (*CallBooleanMethodV)(JNIEnv*, jobject, jmethodID, va_list);  
    219.     jboolean    (*CallBooleanMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);  
    220.     jbyte       (*CallByteMethod)(JNIEnv*, jobject, jmethodID, ...);  
    221.     jbyte       (*CallByteMethodV)(JNIEnv*, jobject, jmethodID, va_list);  
    222.     jbyte       (*CallByteMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);  
    223.     jchar       (*CallCharMethod)(JNIEnv*, jobject, jmethodID, ...);  
    224.     jchar       (*CallCharMethodV)(JNIEnv*, jobject, jmethodID, va_list);  
    225.     jchar       (*CallCharMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);  
    226.     jshort      (*CallShortMethod)(JNIEnv*, jobject, jmethodID, ...);  
    227.     jshort      (*CallShortMethodV)(JNIEnv*, jobject, jmethodID, va_list);  
    228.     jshort      (*CallShortMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);  
    229.     jint        (*CallIntMethod)(JNIEnv*, jobject, jmethodID, ...);  
    230.     jint        (*CallIntMethodV)(JNIEnv*, jobject, jmethodID, va_list);  
    231.     jint        (*CallIntMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);  
    232.     jlong       (*CallLongMethod)(JNIEnv*, jobject, jmethodID, ...);  
    233.     jlong       (*CallLongMethodV)(JNIEnv*, jobject, jmethodID, va_list);  
    234.     jlong       (*CallLongMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);  
    235.     jfloat      (*CallFloatMethod)(JNIEnv*, jobject, jmethodID, ...) __NDK_FPABI__;  
    236.     jfloat      (*CallFloatMethodV)(JNIEnv*, jobject, jmethodID, va_list) __NDK_FPABI__;  
    237.     jfloat      (*CallFloatMethodA)(JNIEnv*, jobject, jmethodID, jvalue*) __NDK_FPABI__;  
    238.     jdouble     (*CallDoubleMethod)(JNIEnv*, jobject, jmethodID, ...) __NDK_FPABI__;  
    239.     jdouble     (*CallDoubleMethodV)(JNIEnv*, jobject, jmethodID, va_list) __NDK_FPABI__;  
    240.     jdouble     (*CallDoubleMethodA)(JNIEnv*, jobject, jmethodID, jvalue*) __NDK_FPABI__;  
    241.     void        (*CallVoidMethod)(JNIEnv*, jobject, jmethodID, ...);  
    242.     void        (*CallVoidMethodV)(JNIEnv*, jobject, jmethodID, va_list);  
    243.     void        (*CallVoidMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);  
    244.   
    245.     jobject     (*CallNonvirtualObjectMethod)(JNIEnv*, jobject, jclass,  
    246.                         jmethodID, ...);  
    247.     jobject     (*CallNonvirtualObjectMethodV)(JNIEnv*, jobject, jclass,  
    248.                         jmethodID, va_list);  
    249.     jobject     (*CallNonvirtualObjectMethodA)(JNIEnv*, jobject, jclass,  
    250.                         jmethodID, jvalue*);  
    251.     jboolean    (*CallNonvirtualBooleanMethod)(JNIEnv*, jobject, jclass,  
    252.                         jmethodID, ...);  
    253.     jboolean    (*CallNonvirtualBooleanMethodV)(JNIEnv*, jobject, jclass,  
    254.                          jmethodID, va_list);  
    255.     jboolean    (*CallNonvirtualBooleanMethodA)(JNIEnv*, jobject, jclass,  
    256.                          jmethodID, jvalue*);  
    257.     jbyte       (*CallNonvirtualByteMethod)(JNIEnv*, jobject, jclass,  
    258.                         jmethodID, ...);  
    259.     jbyte       (*CallNonvirtualByteMethodV)(JNIEnv*, jobject, jclass,  
    260.                         jmethodID, va_list);  
    261.     jbyte       (*CallNonvirtualByteMethodA)(JNIEnv*, jobject, jclass,  
    262.                         jmethodID, jvalue*);  
    263.     jchar       (*CallNonvirtualCharMethod)(JNIEnv*, jobject, jclass,  
    264.                         jmethodID, ...);  
    265.     jchar       (*CallNonvirtualCharMethodV)(JNIEnv*, jobject, jclass,  
    266.                         jmethodID, va_list);  
    267.     jchar       (*CallNonvirtualCharMethodA)(JNIEnv*, jobject, jclass,  
    268.                         jmethodID, jvalue*);  
    269.     jshort      (*CallNonvirtualShortMethod)(JNIEnv*, jobject, jclass,  
    270.                         jmethodID, ...);  
    271.     jshort      (*CallNonvirtualShortMethodV)(JNIEnv*, jobject, jclass,  
    272.                         jmethodID, va_list);  
    273.     jshort      (*CallNonvirtualShortMethodA)(JNIEnv*, jobject, jclass,  
    274.                         jmethodID, jvalue*);  
    275.     jint        (*CallNonvirtualIntMethod)(JNIEnv*, jobject, jclass,  
    276.                         jmethodID, ...);  
    277.     jint        (*CallNonvirtualIntMethodV)(JNIEnv*, jobject, jclass,  
    278.                         jmethodID, va_list);  
    279.     jint        (*CallNonvirtualIntMethodA)(JNIEnv*, jobject, jclass,  
    280.                         jmethodID, jvalue*);  
    281.     jlong       (*CallNonvirtualLongMethod)(JNIEnv*, jobject, jclass,  
    282.                         jmethodID, ...);  
    283.     jlong       (*CallNonvirtualLongMethodV)(JNIEnv*, jobject, jclass,  
    284.                         jmethodID, va_list);  
    285.     jlong       (*CallNonvirtualLongMethodA)(JNIEnv*, jobject, jclass,  
    286.                         jmethodID, jvalue*);  
    287.     jfloat      (*CallNonvirtualFloatMethod)(JNIEnv*, jobject, jclass,  
    288.                         jmethodID, ...) __NDK_FPABI__;  
    289.     jfloat      (*CallNonvirtualFloatMethodV)(JNIEnv*, jobject, jclass,  
    290.                         jmethodID, va_list) __NDK_FPABI__;  
    291.     jfloat      (*CallNonvirtualFloatMethodA)(JNIEnv*, jobject, jclass,  
    292.                         jmethodID, jvalue*) __NDK_FPABI__;  
    293.     jdouble     (*CallNonvirtualDoubleMethod)(JNIEnv*, jobject, jclass,  
    294.                         jmethodID, ...) __NDK_FPABI__;  
    295.     jdouble     (*CallNonvirtualDoubleMethodV)(JNIEnv*, jobject, jclass,  
    296.                         jmethodID, va_list) __NDK_FPABI__;  
    297.     jdouble     (*CallNonvirtualDoubleMethodA)(JNIEnv*, jobject, jclass,  
    298.                         jmethodID, jvalue*) __NDK_FPABI__;  
    299.     void        (*CallNonvirtualVoidMethod)(JNIEnv*, jobject, jclass,  
    300.                         jmethodID, ...);  
    301.     void        (*CallNonvirtualVoidMethodV)(JNIEnv*, jobject, jclass,  
    302.                         jmethodID, va_list);  
    303.     void        (*CallNonvirtualVoidMethodA)(JNIEnv*, jobject, jclass,  
    304.                         jmethodID, jvalue*);  
    305.   
    306.     jfieldID    (*GetFieldID)(JNIEnv*, jclass, const char*, const char*);  
    307.   
    308.     jobject     (*GetObjectField)(JNIEnv*, jobject, jfieldID);  
    309.     jboolean    (*GetBooleanField)(JNIEnv*, jobject, jfieldID);  
    310.     jbyte       (*GetByteField)(JNIEnv*, jobject, jfieldID);  
    311.     jchar       (*GetCharField)(JNIEnv*, jobject, jfieldID);  
    312.     jshort      (*GetShortField)(JNIEnv*, jobject, jfieldID);  
    313.     jint        (*GetIntField)(JNIEnv*, jobject, jfieldID);  
    314.     jlong       (*GetLongField)(JNIEnv*, jobject, jfieldID);  
    315.     jfloat      (*GetFloatField)(JNIEnv*, jobject, jfieldID) __NDK_FPABI__;  
    316.     jdouble     (*GetDoubleField)(JNIEnv*, jobject, jfieldID) __NDK_FPABI__;  
    317.   
    318.     void        (*SetObjectField)(JNIEnv*, jobject, jfieldID, jobject);  
    319.     void        (*SetBooleanField)(JNIEnv*, jobject, jfieldID, jboolean);  
    320.     void        (*SetByteField)(JNIEnv*, jobject, jfieldID, jbyte);  
    321.     void        (*SetCharField)(JNIEnv*, jobject, jfieldID, jchar);  
    322.     void        (*SetShortField)(JNIEnv*, jobject, jfieldID, jshort);  
    323.     void        (*SetIntField)(JNIEnv*, jobject, jfieldID, jint);  
    324.     void        (*SetLongField)(JNIEnv*, jobject, jfieldID, jlong);  
    325.     void        (*SetFloatField)(JNIEnv*, jobject, jfieldID, jfloat) __NDK_FPABI__;  
    326.     void        (*SetDoubleField)(JNIEnv*, jobject, jfieldID, jdouble) __NDK_FPABI__;  
    327.   
    328.     jmethodID   (*GetStaticMethodID)(JNIEnv*, jclass, const char*, const char*);  
    329.   
    330.     jobject     (*CallStaticObjectMethod)(JNIEnv*, jclass, jmethodID, ...);  
    331.     jobject     (*CallStaticObjectMethodV)(JNIEnv*, jclass, jmethodID, va_list);  
    332.     jobject     (*CallStaticObjectMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);  
    333.     jboolean    (*CallStaticBooleanMethod)(JNIEnv*, jclass, jmethodID, ...);  
    334.     jboolean    (*CallStaticBooleanMethodV)(JNIEnv*, jclass, jmethodID,  
    335.                         va_list);  
    336.     jboolean    (*CallStaticBooleanMethodA)(JNIEnv*, jclass, jmethodID,  
    337.                         jvalue*);  
    338.     jbyte       (*CallStaticByteMethod)(JNIEnv*, jclass, jmethodID, ...);  
    339.     jbyte       (*CallStaticByteMethodV)(JNIEnv*, jclass, jmethodID, va_list);  
    340.     jbyte       (*CallStaticByteMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);  
    341.     jchar       (*CallStaticCharMethod)(JNIEnv*, jclass, jmethodID, ...);  
    342.     jchar       (*CallStaticCharMethodV)(JNIEnv*, jclass, jmethodID, va_list);  
    343.     jchar       (*CallStaticCharMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);  
    344.     jshort      (*CallStaticShortMethod)(JNIEnv*, jclass, jmethodID, ...);  
    345.     jshort      (*CallStaticShortMethodV)(JNIEnv*, jclass, jmethodID, va_list);  
    346.     jshort      (*CallStaticShortMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);  
    347.     jint        (*CallStaticIntMethod)(JNIEnv*, jclass, jmethodID, ...);  
    348.     jint        (*CallStaticIntMethodV)(JNIEnv*, jclass, jmethodID, va_list);  
    349.     jint        (*CallStaticIntMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);  
    350.     jlong       (*CallStaticLongMethod)(JNIEnv*, jclass, jmethodID, ...);  
    351.     jlong       (*CallStaticLongMethodV)(JNIEnv*, jclass, jmethodID, va_list);  
    352.     jlong       (*CallStaticLongMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);  
    353.     jfloat      (*CallStaticFloatMethod)(JNIEnv*, jclass, jmethodID, ...) __NDK_FPABI__;  
    354.     jfloat      (*CallStaticFloatMethodV)(JNIEnv*, jclass, jmethodID, va_list) __NDK_FPABI__;  
    355.     jfloat      (*CallStaticFloatMethodA)(JNIEnv*, jclass, jmethodID, jvalue*) __NDK_FPABI__;  
    356.     jdouble     (*CallStaticDoubleMethod)(JNIEnv*, jclass, jmethodID, ...) __NDK_FPABI__;  
    357.     jdouble     (*CallStaticDoubleMethodV)(JNIEnv*, jclass, jmethodID, va_list) __NDK_FPABI__;  
    358.     jdouble     (*CallStaticDoubleMethodA)(JNIEnv*, jclass, jmethodID, jvalue*) __NDK_FPABI__;  
    359.     void        (*CallStaticVoidMethod)(JNIEnv*, jclass, jmethodID, ...);  
    360.     void        (*CallStaticVoidMethodV)(JNIEnv*, jclass, jmethodID, va_list);  
    361.     void        (*CallStaticVoidMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);  
    362.   
    363.     jfieldID    (*GetStaticFieldID)(JNIEnv*, jclass, const char*,  
    364.                         const char*);  
    365.   
    366.     jobject     (*GetStaticObjectField)(JNIEnv*, jclass, jfieldID);  
    367.     jboolean    (*GetStaticBooleanField)(JNIEnv*, jclass, jfieldID);  
    368.     jbyte       (*GetStaticByteField)(JNIEnv*, jclass, jfieldID);  
    369.     jchar       (*GetStaticCharField)(JNIEnv*, jclass, jfieldID);  
    370.     jshort      (*GetStaticShortField)(JNIEnv*, jclass, jfieldID);  
    371.     jint        (*GetStaticIntField)(JNIEnv*, jclass, jfieldID);  
    372.     jlong       (*GetStaticLongField)(JNIEnv*, jclass, jfieldID);  
    373.     jfloat      (*GetStaticFloatField)(JNIEnv*, jclass, jfieldID) __NDK_FPABI__;  
    374.     jdouble     (*GetStaticDoubleField)(JNIEnv*, jclass, jfieldID) __NDK_FPABI__;  
    375.   
    376.     void        (*SetStaticObjectField)(JNIEnv*, jclass, jfieldID, jobject);  
    377.     void        (*SetStaticBooleanField)(JNIEnv*, jclass, jfieldID, jboolean);  
    378.     void        (*SetStaticByteField)(JNIEnv*, jclass, jfieldID, jbyte);  
    379.     void        (*SetStaticCharField)(JNIEnv*, jclass, jfieldID, jchar);  
    380.     void        (*SetStaticShortField)(JNIEnv*, jclass, jfieldID, jshort);  
    381.     void        (*SetStaticIntField)(JNIEnv*, jclass, jfieldID, jint);  
    382.     void        (*SetStaticLongField)(JNIEnv*, jclass, jfieldID, jlong);  
    383.     void        (*SetStaticFloatField)(JNIEnv*, jclass, jfieldID, jfloat) __NDK_FPABI__;  
    384.     void        (*SetStaticDoubleField)(JNIEnv*, jclass, jfieldID, jdouble) __NDK_FPABI__;  
    385.   
    386.     jstring     (*NewString)(JNIEnv*, const jchar*, jsize);  
    387.     jsize       (*GetStringLength)(JNIEnv*, jstring);  
    388.     const jchar* (*GetStringChars)(JNIEnv*, jstring, jboolean*);  
    389.     void        (*ReleaseStringChars)(JNIEnv*, jstring, const jchar*);  
    390.     jstring     (*NewStringUTF)(JNIEnv*, const char*);  
    391.     jsize       (*GetStringUTFLength)(JNIEnv*, jstring);  
    392.     /* JNI spec says this returns const jbyte*, but that's inconsistent */  
    393.     const char* (*GetStringUTFChars)(JNIEnv*, jstring, jboolean*);  
    394.     void        (*ReleaseStringUTFChars)(JNIEnv*, jstring, const char*);  
    395.     jsize       (*GetArrayLength)(JNIEnv*, jarray);  
    396.     jobjectArray (*NewObjectArray)(JNIEnv*, jsize, jclass, jobject);  
    397.     jobject     (*GetObjectArrayElement)(JNIEnv*, jobjectArray, jsize);  
    398.     void        (*SetObjectArrayElement)(JNIEnv*, jobjectArray, jsize, jobject);  
    399.   
    400.     jbooleanArray (*NewBooleanArray)(JNIEnv*, jsize);  
    401.     jbyteArray    (*NewByteArray)(JNIEnv*, jsize);  
    402.     jcharArray    (*NewCharArray)(JNIEnv*, jsize);  
    403.     jshortArray   (*NewShortArray)(JNIEnv*, jsize);  
    404.     jintArray     (*NewIntArray)(JNIEnv*, jsize);  
    405.     jlongArray    (*NewLongArray)(JNIEnv*, jsize);  
    406.     jfloatArray   (*NewFloatArray)(JNIEnv*, jsize);  
    407.     jdoubleArray  (*NewDoubleArray)(JNIEnv*, jsize);  
    408.   
    409.     jboolean*   (*GetBooleanArrayElements)(JNIEnv*, jbooleanArray, jboolean*);  
    410.     jbyte*      (*GetByteArrayElements)(JNIEnv*, jbyteArray, jboolean*);  
    411.     jchar*      (*GetCharArrayElements)(JNIEnv*, jcharArray, jboolean*);  
    412.     jshort*     (*GetShortArrayElements)(JNIEnv*, jshortArray, jboolean*);  
    413.     jint*       (*GetIntArrayElements)(JNIEnv*, jintArray, jboolean*);  
    414.     jlong*      (*GetLongArrayElements)(JNIEnv*, jlongArray, jboolean*);  
    415.     jfloat*     (*GetFloatArrayElements)(JNIEnv*, jfloatArray, jboolean*);  
    416.     jdouble*    (*GetDoubleArrayElements)(JNIEnv*, jdoubleArray, jboolean*);  
    417.   
    418.     void        (*ReleaseBooleanArrayElements)(JNIEnv*, jbooleanArray,  
    419.                         jboolean*, jint);  
    420.     void        (*ReleaseByteArrayElements)(JNIEnv*, jbyteArray,  
    421.                         jbyte*, jint);  
    422.     void        (*ReleaseCharArrayElements)(JNIEnv*, jcharArray,  
    423.                         jchar*, jint);  
    424.     void        (*ReleaseShortArrayElements)(JNIEnv*, jshortArray,  
    425.                         jshort*, jint);  
    426.     void        (*ReleaseIntArrayElements)(JNIEnv*, jintArray,  
    427.                         jint*, jint);  
    428.     void        (*ReleaseLongArrayElements)(JNIEnv*, jlongArray,  
    429.                         jlong*, jint);  
    430.     void        (*ReleaseFloatArrayElements)(JNIEnv*, jfloatArray,  
    431.                         jfloat*, jint);  
    432.     void        (*ReleaseDoubleArrayElements)(JNIEnv*, jdoubleArray,  
    433.                         jdouble*, jint);  
    434.   
    435.     void        (*GetBooleanArrayRegion)(JNIEnv*, jbooleanArray,  
    436.                         jsize, jsize, jboolean*);  
    437.     void        (*GetByteArrayRegion)(JNIEnv*, jbyteArray,  
    438.                         jsize, jsize, jbyte*);  
    439.     void        (*GetCharArrayRegion)(JNIEnv*, jcharArray,  
    440.                         jsize, jsize, jchar*);  
    441.     void        (*GetShortArrayRegion)(JNIEnv*, jshortArray,  
    442.                         jsize, jsize, jshort*);  
    443.     void        (*GetIntArrayRegion)(JNIEnv*, jintArray,  
    444.                         jsize, jsize, jint*);  
    445.     void        (*GetLongArrayRegion)(JNIEnv*, jlongArray,  
    446.                         jsize, jsize, jlong*);  
    447.     void        (*GetFloatArrayRegion)(JNIEnv*, jfloatArray,  
    448.                         jsize, jsize, jfloat*);  
    449.     void        (*GetDoubleArrayRegion)(JNIEnv*, jdoubleArray,  
    450.                         jsize, jsize, jdouble*);  
    451.   
    452.     /* spec shows these without const; some jni.h do, some don't */  
    453.     void        (*SetBooleanArrayRegion)(JNIEnv*, jbooleanArray,  
    454.                         jsize, jsize, const jboolean*);  
    455.     void        (*SetByteArrayRegion)(JNIEnv*, jbyteArray,  
    456.                         jsize, jsize, const jbyte*);  
    457.     void        (*SetCharArrayRegion)(JNIEnv*, jcharArray,  
    458.                         jsize, jsize, const jchar*);  
    459.     void        (*SetShortArrayRegion)(JNIEnv*, jshortArray,  
    460.                         jsize, jsize, const jshort*);  
    461.     void        (*SetIntArrayRegion)(JNIEnv*, jintArray,  
    462.                         jsize, jsize, const jint*);  
    463.     void        (*SetLongArrayRegion)(JNIEnv*, jlongArray,  
    464.                         jsize, jsize, const jlong*);  
    465.     void        (*SetFloatArrayRegion)(JNIEnv*, jfloatArray,  
    466.                         jsize, jsize, const jfloat*);  
    467.     void        (*SetDoubleArrayRegion)(JNIEnv*, jdoubleArray,  
    468.                         jsize, jsize, const jdouble*);  
    469.   
    470.     jint        (*RegisterNatives)(JNIEnv*, jclass, const JNINativeMethod*,  
    471.                         jint);  
    472.     jint        (*UnregisterNatives)(JNIEnv*, jclass);  
    473.     jint        (*MonitorEnter)(JNIEnv*, jobject);  
    474.     jint        (*MonitorExit)(JNIEnv*, jobject);  
    475.     jint        (*GetJavaVM)(JNIEnv*, JavaVM**);  
    476.   
    477.     void        (*GetStringRegion)(JNIEnv*, jstring, jsize, jsize, jchar*);  
    478.     void        (*GetStringUTFRegion)(JNIEnv*, jstring, jsize, jsize, char*);  
    479.   
    480.     void*       (*GetPrimitiveArrayCritical)(JNIEnv*, jarray, jboolean*);  
    481.     void        (*ReleasePrimitiveArrayCritical)(JNIEnv*, jarray, void*, jint);  
    482.   
    483.     const jchar* (*GetStringCritical)(JNIEnv*, jstring, jboolean*);  
    484.     void        (*ReleaseStringCritical)(JNIEnv*, jstring, const jchar*);  
    485.   
    486.     jweak       (*NewWeakGlobalRef)(JNIEnv*, jobject);  
    487.     void        (*DeleteWeakGlobalRef)(JNIEnv*, jweak);  
    488.   
    489.     jboolean    (*ExceptionCheck)(JNIEnv*);  
    490.   
    491.     jobject     (*NewDirectByteBuffer)(JNIEnv*, void*, jlong);  
    492.     void*       (*GetDirectBufferAddress)(JNIEnv*, jobject);  
    493.     jlong       (*GetDirectBufferCapacity)(JNIEnv*, jobject);  
    494.   
    495.     /* added in JNI 1.6 */  
    496.     jobjectRefType (*GetObjectRefType)(JNIEnv*, jobject);  
    497. };  
    498.   
    499. /* 
    500.  * C++ object wrapper. 
    501.  * 
    502.  * This is usually overlaid on a C struct whose first element is a 
    503.  * JNINativeInterface*.  We rely somewhat on compiler behavior. 
    504.  */  
    505. struct _JNIEnv {  
    506.     /* do not rename this; it does not seem to be entirely opaque */  
    507.     const struct JNINativeInterface* functions;  
    508.   
    509. #if defined(__cplusplus)  
    510.   
    511.     jint GetVersion()  
    512.     { return functions->GetVersion(this); }  
    513.   
    514.     jclass DefineClass(const char *name, jobject loader, const jbyte* buf,  
    515.         jsize bufLen)  
    516.     { return functions->DefineClass(this, name, loader, buf, bufLen); }  
    517.   
    518.     jclass FindClass(const char* name)  
    519.     { return functions->FindClass(this, name); }  
    520.   
    521.     jmethodID FromReflectedMethod(jobject method)  
    522.     { return functions->FromReflectedMethod(this, method); }  
    523.   
    524.     jfieldID FromReflectedField(jobject field)  
    525.     { return functions->FromReflectedField(this, field); }  
    526.   
    527.     jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic)  
    528.     { return functions->ToReflectedMethod(this, cls, methodID, isStatic); }  
    529.   
    530.     jclass GetSuperclass(jclass clazz)  
    531.     { return functions->GetSuperclass(this, clazz); }  
    532.   
    533.     jboolean IsAssignableFrom(jclass clazz1, jclass clazz2)  
    534.     { return functions->IsAssignableFrom(this, clazz1, clazz2); }  
    535.   
    536.     jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic)  
    537.     { return functions->ToReflectedField(this, cls, fieldID, isStatic); }  
    538.   
    539.     jint Throw(jthrowable obj)  
    540.     { return functions->Throw(this, obj); }  
    541.   
    542.     jint ThrowNew(jclass clazz, const char* message)  
    543.     { return functions->ThrowNew(this, clazz, message); }  
    544.   
    545.     jthrowable ExceptionOccurred()  
    546.     { return functions->ExceptionOccurred(this); }  
    547.   
    548.     void ExceptionDescribe()  
    549.     { functions->ExceptionDescribe(this); }  
    550.   
    551.     void ExceptionClear()  
    552.     { functions->ExceptionClear(this); }  
    553.   
    554.     void FatalError(const char* msg)  
    555.     { functions->FatalError(this, msg); }  
    556.   
    557.     jint PushLocalFrame(jint capacity)  
    558.     { return functions->PushLocalFrame(this, capacity); }  
    559.   
    560.     jobject PopLocalFrame(jobject result)  
    561.     { return functions->PopLocalFrame(this, result); }  
    562.   
    563.     jobject NewGlobalRef(jobject obj)  
    564.     { return functions->NewGlobalRef(this, obj); }  
    565.   
    566.     void DeleteGlobalRef(jobject globalRef)  
    567.     { functions->DeleteGlobalRef(this, globalRef); }  
    568.   
    569.     void DeleteLocalRef(jobject localRef)  
    570.     { functions->DeleteLocalRef(this, localRef); }  
    571.   
    572.     jboolean IsSameObject(jobject ref1, jobject ref2)  
    573.     { return functions->IsSameObject(this, ref1, ref2); }  
    574.   
    575.     jobject NewLocalRef(jobject ref)  
    576.     { return functions->NewLocalRef(this, ref); }  
    577.   
    578.     jint EnsureLocalCapacity(jint capacity)  
    579.     { return functions->EnsureLocalCapacity(this, capacity); }  
    580.   
    581.     jobject AllocObject(jclass clazz)  
    582.     { return functions->AllocObject(this, clazz); }  
    583.   
    584.     jobject NewObject(jclass clazz, jmethodID methodID, ...)  
    585.     {  
    586.         va_list args;  
    587.         va_start(args, methodID);  
    588.         jobject result = functions->NewObjectV(this, clazz, methodID, args);  
    589.         va_end(args);  
    590.         return result;  
    591.     }  
    592.   
    593.     jobject NewObjectV(jclass clazz, jmethodID methodID, va_list args)  
    594.     { return functions->NewObjectV(this, clazz, methodID, args); }  
    595.   
    596.     jobject NewObjectA(jclass clazz, jmethodID methodID, jvalue* args)  
    597.     { return functions->NewObjectA(this, clazz, methodID, args); }  
    598.   
    599.     jclass GetObjectClass(jobject obj)  
    600.     { return functions->GetObjectClass(this, obj); }  
    601.   
    602.     jboolean IsInstanceOf(jobject obj, jclass clazz)  
    603.     { return functions->IsInstanceOf(this, obj, clazz); }  
    604.   
    605.     jmethodID GetMethodID(jclass clazz, const char* name, const char* sig)  
    606.     { return functions->GetMethodID(this, clazz, name, sig); }  
    607.   
    608. #define CALL_TYPE_METHOD(_jtype, _jname)                                      
    609.     __NDK_FPABI__                                                             
    610.     _jtype Call##_jname##Method(jobject obj, jmethodID methodID, ...)         
    611.     {                                                                         
    612.         _jtype result;                                                        
    613.         va_list args;                                                         
    614.         va_start(args, methodID);                                             
    615.         result = functions->Call##_jname##MethodV(this, obj, methodID,        
    616.                     args);                                                    
    617.         va_end(args);                                                         
    618.         return result;                                                        
    619.     }  
    620. #define CALL_TYPE_METHODV(_jtype, _jname)                                     
    621.     __NDK_FPABI__                                                             
    622.     _jtype Call##_jname##MethodV(jobject obj, jmethodID methodID,             
    623.         va_list args)                                                         
    624.     { return functions->Call##_jname##MethodV(this, obj, methodID, args); }  
    625. #define CALL_TYPE_METHODA(_jtype, _jname)                                     
    626.     __NDK_FPABI__                                                             
    627.     _jtype Call##_jname##MethodA(jobject obj, jmethodID methodID,             
    628.         jvalue* args)                                                         
    629.     { return functions->Call##_jname##MethodA(this, obj, methodID, args); }  
    630.   
    631. #define CALL_TYPE(_jtype, _jname)                                             
    632.     CALL_TYPE_METHOD(_jtype, _jname)                                          
    633.     CALL_TYPE_METHODV(_jtype, _jname)                                         
    634.     CALL_TYPE_METHODA(_jtype, _jname)  
    635.   
    636.     CALL_TYPE(jobject, Object)  
    637.     CALL_TYPE(jboolean, Boolean)  
    638.     CALL_TYPE(jbyte, Byte)  
    639.     CALL_TYPE(jchar, Char)  
    640.     CALL_TYPE(jshort, Short)  
    641.     CALL_TYPE(jint, Int)  
    642.     CALL_TYPE(jlong, Long)  
    643.     CALL_TYPE(jfloat, Float)  
    644.     CALL_TYPE(jdouble, Double)  
    645.   
    646.     void CallVoidMethod(jobject obj, jmethodID methodID, ...)  
    647.     {  
    648.         va_list args;  
    649.         va_start(args, methodID);  
    650.         functions->CallVoidMethodV(this, obj, methodID, args);  
    651.         va_end(args);  
    652.     }  
    653.     void CallVoidMethodV(jobject obj, jmethodID methodID, va_list args)  
    654.     { functions->CallVoidMethodV(this, obj, methodID, args); }  
    655.     void CallVoidMethodA(jobject obj, jmethodID methodID, jvalue* args)  
    656.     { functions->CallVoidMethodA(this, obj, methodID, args); }  
    657.   
    658. #define CALL_NONVIRT_TYPE_METHOD(_jtype, _jname)                              
    659.     __NDK_FPABI__                                                             
    660.     _jtype CallNonvirtual##_jname##Method(jobject obj, jclass clazz,          
    661.         jmethodID methodID, ...)                                              
    662.     {                                                                         
    663.         _jtype result;                                                        
    664.         va_list args;                                                         
    665.         va_start(args, methodID);                                             
    666.         result = functions->CallNonvirtual##_jname##MethodV(this, obj,        
    667.                     clazz, methodID, args);                                   
    668.         va_end(args);                                                         
    669.         return result;                                                        
    670.     }  
    671. #define CALL_NONVIRT_TYPE_METHODV(_jtype, _jname)                             
    672.     __NDK_FPABI__                                                             
    673.     _jtype CallNonvirtual##_jname##MethodV(jobject obj, jclass clazz,         
    674.         jmethodID methodID, va_list args)                                     
    675.     { return functions->CallNonvirtual##_jname##MethodV(this, obj, clazz,     
    676.         methodID, args); }  
    677. #define CALL_NONVIRT_TYPE_METHODA(_jtype, _jname)                             
    678.     __NDK_FPABI__                                                             
    679.     _jtype CallNonvirtual##_jname##MethodA(jobject obj, jclass clazz,         
    680.         jmethodID methodID, jvalue* args)                                     
    681.     { return functions->CallNonvirtual##_jname##MethodA(this, obj, clazz,     
    682.         methodID, args); }  
    683.   
    684. #define CALL_NONVIRT_TYPE(_jtype, _jname)                                     
    685.     CALL_NONVIRT_TYPE_METHOD(_jtype, _jname)                                  
    686.     CALL_NONVIRT_TYPE_METHODV(_jtype, _jname)                                 
    687.     CALL_NONVIRT_TYPE_METHODA(_jtype, _jname)  
    688.   
    689.     CALL_NONVIRT_TYPE(jobject, Object)  
    690.     CALL_NONVIRT_TYPE(jboolean, Boolean)  
    691.     CALL_NONVIRT_TYPE(jbyte, Byte)  
    692.     CALL_NONVIRT_TYPE(jchar, Char)  
    693.     CALL_NONVIRT_TYPE(jshort, Short)  
    694.     CALL_NONVIRT_TYPE(jint, Int)  
    695.     CALL_NONVIRT_TYPE(jlong, Long)  
    696.     CALL_NONVIRT_TYPE(jfloat, Float)  
    697.     CALL_NONVIRT_TYPE(jdouble, Double)  
    698.   
    699.     void CallNonvirtualVoidMethod(jobject obj, jclass clazz,  
    700.         jmethodID methodID, ...)  
    701.     {  
    702.         va_list args;  
    703.         va_start(args, methodID);  
    704.         functions->CallNonvirtualVoidMethodV(this, obj, clazz, methodID, args);  
    705.         va_end(args);  
    706.     }  
    707.     void CallNonvirtualVoidMethodV(jobject obj, jclass clazz,  
    708.         jmethodID methodID, va_list args)  
    709.     { functions->CallNonvirtualVoidMethodV(this, obj, clazz, methodID, args); }  
    710.     void CallNonvirtualVoidMethodA(jobject obj, jclass clazz,  
    711.         jmethodID methodID, jvalue* args)  
    712.     { functions->CallNonvirtualVoidMethodA(this, obj, clazz, methodID, args); }  
    713.   
    714.     jfieldID GetFieldID(jclass clazz, const char* name, const char* sig)  
    715.     { return functions->GetFieldID(this, clazz, name, sig); }  
    716.   
    717.     jobject GetObjectField(jobject obj, jfieldID fieldID)  
    718.     { return functions->GetObjectField(this, obj, fieldID); }  
    719.     jboolean GetBooleanField(jobject obj, jfieldID fieldID)  
    720.     { return functions->GetBooleanField(this, obj, fieldID); }  
    721.     jbyte GetByteField(jobject obj, jfieldID fieldID)  
    722.     { return functions->GetByteField(this, obj, fieldID); }  
    723.     jchar GetCharField(jobject obj, jfieldID fieldID)  
    724.     { return functions->GetCharField(this, obj, fieldID); }  
    725.     jshort GetShortField(jobject obj, jfieldID fieldID)  
    726.     { return functions->GetShortField(this, obj, fieldID); }  
    727.     jint GetIntField(jobject obj, jfieldID fieldID)  
    728.     { return functions->GetIntField(this, obj, fieldID); }  
    729.     jlong GetLongField(jobject obj, jfieldID fieldID)  
    730.     { return functions->GetLongField(this, obj, fieldID); }  
    731.     __NDK_FPABI__  
    732.     jfloat GetFloatField(jobject obj, jfieldID fieldID)  
    733.     { return functions->GetFloatField(this, obj, fieldID); }  
    734.     __NDK_FPABI__  
    735.     jdouble GetDoubleField(jobject obj, jfieldID fieldID)  
    736.     { return functions->GetDoubleField(this, obj, fieldID); }  
    737.   
    738.     void SetObjectField(jobject obj, jfieldID fieldID, jobject value)  
    739.     { functions->SetObjectField(this, obj, fieldID, value); }  
    740.     void SetBooleanField(jobject obj, jfieldID fieldID, jboolean value)  
    741.     { functions->SetBooleanField(this, obj, fieldID, value); }  
    742.     void SetByteField(jobject obj, jfieldID fieldID, jbyte value)  
    743.     { functions->SetByteField(this, obj, fieldID, value); }  
    744.     void SetCharField(jobject obj, jfieldID fieldID, jchar value)  
    745.     { functions->SetCharField(this, obj, fieldID, value); }  
    746.     void SetShortField(jobject obj, jfieldID fieldID, jshort value)  
    747.     { functions->SetShortField(this, obj, fieldID, value); }  
    748.     void SetIntField(jobject obj, jfieldID fieldID, jint value)  
    749.     { functions->SetIntField(this, obj, fieldID, value); }  
    750.     void SetLongField(jobject obj, jfieldID fieldID, jlong value)  
    751.     { functions->SetLongField(this, obj, fieldID, value); }  
    752.     __NDK_FPABI__  
    753.     void SetFloatField(jobject obj, jfieldID fieldID, jfloat value)  
    754.     { functions->SetFloatField(this, obj, fieldID, value); }  
    755.     __NDK_FPABI__  
    756.     void SetDoubleField(jobject obj, jfieldID fieldID, jdouble value)  
    757.     { functions->SetDoubleField(this, obj, fieldID, value); }  
    758.   
    759.     jmethodID GetStaticMethodID(jclass clazz, const char* name, const char* sig)  
    760.     { return functions->GetStaticMethodID(this, clazz, name, sig); }  
    761.   
    762. #define CALL_STATIC_TYPE_METHOD(_jtype, _jname)                               
    763.     __NDK_FPABI__                                                             
    764.     _jtype CallStatic##_jname##Method(jclass clazz, jmethodID methodID,       
    765.         ...)                                                                  
    766.     {                                                                         
    767.         _jtype result;                                                        
    768.         va_list args;                                                         
    769.         va_start(args, methodID);                                             
    770.         result = functions->CallStatic##_jname##MethodV(this, clazz,          
    771.                     methodID, args);                                          
    772.         va_end(args);                                                         
    773.         return result;                                                        
    774.     }  
    775. #define CALL_STATIC_TYPE_METHODV(_jtype, _jname)                              
    776.     __NDK_FPABI__                                                             
    777.     _jtype CallStatic##_jname##MethodV(jclass clazz, jmethodID methodID,      
    778.         va_list args)                                                         
    779.     { return functions->CallStatic##_jname##MethodV(this, clazz, methodID,    
    780.         args); }  
    781. #define CALL_STATIC_TYPE_METHODA(_jtype, _jname)                              
    782.     __NDK_FPABI__                                                             
    783.     _jtype CallStatic##_jname##MethodA(jclass clazz, jmethodID methodID,      
    784.         jvalue* args)                                                         
    785.     { return functions->CallStatic##_jname##MethodA(this, clazz, methodID,    
    786.         args); }  
    787.   
    788. #define CALL_STATIC_TYPE(_jtype, _jname)                                      
    789.     CALL_STATIC_TYPE_METHOD(_jtype, _jname)                                   
    790.     CALL_STATIC_TYPE_METHODV(_jtype, _jname)                                  
    791.     CALL_STATIC_TYPE_METHODA(_jtype, _jname)  
    792.   
    793.     CALL_STATIC_TYPE(jobject, Object)  
    794.     CALL_STATIC_TYPE(jboolean, Boolean)  
    795.     CALL_STATIC_TYPE(jbyte, Byte)  
    796.     CALL_STATIC_TYPE(jchar, Char)  
    797.     CALL_STATIC_TYPE(jshort, Short)  
    798.     CALL_STATIC_TYPE(jint, Int)  
    799.     CALL_STATIC_TYPE(jlong, Long)  
    800.     CALL_STATIC_TYPE(jfloat, Float)  
    801.     CALL_STATIC_TYPE(jdouble, Double)  
    802.   
    803.     void CallStaticVoidMethod(jclass clazz, jmethodID methodID, ...)  
    804.     {  
    805.         va_list args;  
    806.         va_start(args, methodID);  
    807.         functions->CallStaticVoidMethodV(this, clazz, methodID, args);  
    808.         va_end(args);  
    809.     }  
    810.     void CallStaticVoidMethodV(jclass clazz, jmethodID methodID, va_list args)  
    811.     { functions->CallStaticVoidMethodV(this, clazz, methodID, args); }  
    812.     void CallStaticVoidMethodA(jclass clazz, jmethodID methodID, jvalue* args)  
    813.     { functions->CallStaticVoidMethodA(this, clazz, methodID, args); }  
    814.   
    815.     jfieldID GetStaticFieldID(jclass clazz, const char* name, const char* sig)  
    816.     { return functions->GetStaticFieldID(this, clazz, name, sig); }  
    817.   
    818.     jobject GetStaticObjectField(jclass clazz, jfieldID fieldID)  
    819.     { return functions->GetStaticObjectField(this, clazz, fieldID); }  
    820.     jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID)  
    821.     { return functions->GetStaticBooleanField(this, clazz, fieldID); }  
    822.     jbyte GetStaticByteField(jclass clazz, jfieldID fieldID)  
    823.     { return functions->GetStaticByteField(this, clazz, fieldID); }  
    824.     jchar GetStaticCharField(jclass clazz, jfieldID fieldID)  
    825.     { return functions->GetStaticCharField(this, clazz, fieldID); }  
    826.     jshort GetStaticShortField(jclass clazz, jfieldID fieldID)  
    827.     { return functions->GetStaticShortField(this, clazz, fieldID); }  
    828.     jint GetStaticIntField(jclass clazz, jfieldID fieldID)  
    829.     { return functions->GetStaticIntField(this, clazz, fieldID); }  
    830.     jlong GetStaticLongField(jclass clazz, jfieldID fieldID)  
    831.     { return functions->GetStaticLongField(this, clazz, fieldID); }  
    832.     __NDK_FPABI__  
    833.     jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID)  
    834.     { return functions->GetStaticFloatField(this, clazz, fieldID); }  
    835.     __NDK_FPABI__  
    836.     jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID)  
    837.     { return functions->GetStaticDoubleField(this, clazz, fieldID); }  
    838.   
    839.     void SetStaticObjectField(jclass clazz, jfieldID fieldID, jobject value)  
    840.     { functions->SetStaticObjectField(this, clazz, fieldID, value); }  
    841.     void SetStaticBooleanField(jclass clazz, jfieldID fieldID, jboolean value)  
    842.     { functions->SetStaticBooleanField(this, clazz, fieldID, value); }  
    843.     void SetStaticByteField(jclass clazz, jfieldID fieldID, jbyte value)  
    844.     { functions->SetStaticByteField(this, clazz, fieldID, value); }  
    845.     void SetStaticCharField(jclass clazz, jfieldID fieldID, jchar value)  
    846.     { functions->SetStaticCharField(this, clazz, fieldID, value); }  
    847.     void SetStaticShortField(jclass clazz, jfieldID fieldID, jshort value)  
    848.     { functions->SetStaticShortField(this, clazz, fieldID, value); }  
    849.     void SetStaticIntField(jclass clazz, jfieldID fieldID, jint value)  
    850.     { functions->SetStaticIntField(this, clazz, fieldID, value); }  
    851.     void SetStaticLongField(jclass clazz, jfieldID fieldID, jlong value)  
    852.     { functions->SetStaticLongField(this, clazz, fieldID, value); }  
    853.     __NDK_FPABI__  
    854.     void SetStaticFloatField(jclass clazz, jfieldID fieldID, jfloat value)  
    855.     { functions->SetStaticFloatField(this, clazz, fieldID, value); }  
    856.     __NDK_FPABI__  
    857.     void SetStaticDoubleField(jclass clazz, jfieldID fieldID, jdouble value)  
    858.     { functions->SetStaticDoubleField(this, clazz, fieldID, value); }  
    859.   
    860.     jstring NewString(const jchar* unicodeChars, jsize len)  
    861.     { return functions->NewString(this, unicodeChars, len); }  
    862.   
    863.     jsize GetStringLength(jstring string)  
    864.     { return functions->GetStringLength(this, string); }  
    865.   
    866.     const jchar* GetStringChars(jstring string, jboolean* isCopy)  
    867.     { return functions->GetStringChars(this, string, isCopy); }  
    868.   
    869.     void ReleaseStringChars(jstring string, const jchar* chars)  
    870.     { functions->ReleaseStringChars(this, string, chars); }  
    871.   
    872.     jstring NewStringUTF(const char* bytes)  
    873.     { return functions->NewStringUTF(this, bytes); }  
    874.   
    875.     jsize GetStringUTFLength(jstring string)  
    876.     { return functions->GetStringUTFLength(this, string); }  
    877.   
    878.     const char* GetStringUTFChars(jstring string, jboolean* isCopy)  
    879.     { return functions->GetStringUTFChars(this, string, isCopy); }  
    880.   
    881.     void ReleaseStringUTFChars(jstring string, const char* utf)  
    882.     { functions->ReleaseStringUTFChars(this, string, utf); }  
    883.   
    884.     jsize GetArrayLength(jarray array)  
    885.     { return functions->GetArrayLength(this, array); }  
    886.   
    887.     jobjectArray NewObjectArray(jsize length, jclass elementClass,  
    888.         jobject initialElement)  
    889.     { return functions->NewObjectArray(this, length, elementClass,  
    890.         initialElement); }  
    891.   
    892.     jobject GetObjectArrayElement(jobjectArray array, jsize index)  
    893.     { return functions->GetObjectArrayElement(this, array, index); }  
    894.   
    895.     void SetObjectArrayElement(jobjectArray array, jsize index, jobject value)  
    896.     { functions->SetObjectArrayElement(this, array, index, value); }  
    897.   
    898.     jbooleanArray NewBooleanArray(jsize length)  
    899.     { return functions->NewBooleanArray(this, length); }  
    900.     jbyteArray NewByteArray(jsize length)  
    901.     { return functions->NewByteArray(this, length); }  
    902.     jcharArray NewCharArray(jsize length)  
    903.     { return functions->NewCharArray(this, length); }  
    904.     jshortArray NewShortArray(jsize length)  
    905.     { return functions->NewShortArray(this, length); }  
    906.     jintArray NewIntArray(jsize length)  
    907.     { return functions->NewIntArray(this, length); }  
    908.     jlongArray NewLongArray(jsize length)  
    909.     { return functions->NewLongArray(this, length); }  
    910.     jfloatArray NewFloatArray(jsize length)  
    911.     { return functions->NewFloatArray(this, length); }  
    912.     jdoubleArray NewDoubleArray(jsize length)  
    913.     { return functions->NewDoubleArray(this, length); }  
    914.   
    915.     jboolean* GetBooleanArrayElements(jbooleanArray array, jboolean* isCopy)  
    916.     { return functions->GetBooleanArrayElements(this, array, isCopy); }  
    917.     jbyte* GetByteArrayElements(jbyteArray array, jboolean* isCopy)  
    918.     { return functions->GetByteArrayElements(this, array, isCopy); }  
    919.     jchar* GetCharArrayElements(jcharArray array, jboolean* isCopy)  
    920.     { return functions->GetCharArrayElements(this, array, isCopy); }  
    921.     jshort* GetShortArrayElements(jshortArray array, jboolean* isCopy)  
    922.     { return functions->GetShortArrayElements(this, array, isCopy); }  
    923.     jint* GetIntArrayElements(jintArray array, jboolean* isCopy)  
    924.     { return functions->GetIntArrayElements(this, array, isCopy); }  
    925.     jlong* GetLongArrayElements(jlongArray array, jboolean* isCopy)  
    926.     { return functions->GetLongArrayElements(this, array, isCopy); }  
    927.     jfloat* GetFloatArrayElements(jfloatArray array, jboolean* isCopy)  
    928.     { return functions->GetFloatArrayElements(this, array, isCopy); }  
    929.     jdouble* GetDoubleArrayElements(jdoubleArray array, jboolean* isCopy)  
    930.     { return functions->GetDoubleArrayElements(this, array, isCopy); }  
    931.   
    932.     void ReleaseBooleanArrayElements(jbooleanArray array, jboolean* elems,  
    933.         jint mode)  
    934.     { functions->ReleaseBooleanArrayElements(this, array, elems, mode); }  
    935.     void ReleaseByteArrayElements(jbyteArray array, jbyte* elems,  
    936.         jint mode)  
    937.     { functions->ReleaseByteArrayElements(this, array, elems, mode); }  
    938.     void ReleaseCharArrayElements(jcharArray array, jchar* elems,  
    939.         jint mode)  
    940.     { functions->ReleaseCharArrayElements(this, array, elems, mode); }  
    941.     void ReleaseShortArrayElements(jshortArray array, jshort* elems,  
    942.         jint mode)  
    943.     { functions->ReleaseShortArrayElements(this, array, elems, mode); }  
    944.     void ReleaseIntArrayElements(jintArray array, jint* elems,  
    945.         jint mode)  
    946.     { functions->ReleaseIntArrayElements(this, array, elems, mode); }  
    947.     void ReleaseLongArrayElements(jlongArray array, jlong* elems,  
    948.         jint mode)  
    949.     { functions->ReleaseLongArrayElements(this, array, elems, mode); }  
    950.     void ReleaseFloatArrayElements(jfloatArray array, jfloat* elems,  
    951.         jint mode)  
    952.     { functions->ReleaseFloatArrayElements(this, array, elems, mode); }  
    953.     void ReleaseDoubleArrayElements(jdoubleArray array, jdouble* elems,  
    954.         jint mode)  
    955.     { functions->ReleaseDoubleArrayElements(this, array, elems, mode); }  
    956.   
    957.     void GetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len,  
    958.         jboolean* buf)  
    959.     { functions->GetBooleanArrayRegion(this, array, start, len, buf); }  
    960.     void GetByteArrayRegion(jbyteArray array, jsize start, jsize len,  
    961.         jbyte* buf)  
    962.     { functions->GetByteArrayRegion(this, array, start, len, buf); }  
    963.     void GetCharArrayRegion(jcharArray array, jsize start, jsize len,  
    964.         jchar* buf)  
    965.     { functions->GetCharArrayRegion(this, array, start, len, buf); }  
    966.     void GetShortArrayRegion(jshortArray array, jsize start, jsize len,  
    967.         jshort* buf)  
    968.     { functions->GetShortArrayRegion(this, array, start, len, buf); }  
    969.     void GetIntArrayRegion(jintArray array, jsize start, jsize len,  
    970.         jint* buf)  
    971.     { functions->GetIntArrayRegion(this, array, start, len, buf); }  
    972.     void GetLongArrayRegion(jlongArray array, jsize start, jsize len,  
    973.         jlong* buf)  
    974.     { functions->GetLongArrayRegion(this, array, start, len, buf); }  
    975.     void GetFloatArrayRegion(jfloatArray array, jsize start, jsize len,  
    976.         jfloat* buf)  
    977.     { functions->GetFloatArrayRegion(this, array, start, len, buf); }  
    978.     void GetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,  
    979.         jdouble* buf)  
    980.     { functions->GetDoubleArrayRegion(this, array, start, len, buf); }  
    981.   
    982.     void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len,  
    983.         const jboolean* buf)  
    984.     { functions->SetBooleanArrayRegion(this, array, start, len, buf); }  
    985.     void SetByteArrayRegion(jbyteArray array, jsize start, jsize len,  
    986.         const jbyte* buf)  
    987.     { functions->SetByteArrayRegion(this, array, start, len, buf); }  
    988.     void SetCharArrayRegion(jcharArray array, jsize start, jsize len,  
    989.         const jchar* buf)  
    990.     { functions->SetCharArrayRegion(this, array, start, len, buf); }  
    991.     void SetShortArrayRegion(jshortArray array, jsize start, jsize len,  
    992.         const jshort* buf)  
    993.     { functions->SetShortArrayRegion(this, array, start, len, buf); }  
    994.     void SetIntArrayRegion(jintArray array, jsize start, jsize len,  
    995.         const jint* buf)  
    996.     { functions->SetIntArrayRegion(this, array, start, len, buf); }  
    997.     void SetLongArrayRegion(jlongArray array, jsize start, jsize len,  
    998.         const jlong* buf)  
    999.     { functions->SetLongArrayRegion(this, array, start, len, buf); }  
    1000.     void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len,  
    1001.         const jfloat* buf)  
    1002.     { functions->SetFloatArrayRegion(this, array, start, len, buf); }  
    1003.     void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,  
    1004.         const jdouble* buf)  
    1005.     { functions->SetDoubleArrayRegion(this, array, start, len, buf); }  
    1006.   
    1007.     jint RegisterNatives(jclass clazz, const JNINativeMethod* methods,  
    1008.         jint nMethods)  
    1009.     { return functions->RegisterNatives(this, clazz, methods, nMethods); }  
    1010.   
    1011.     jint UnregisterNatives(jclass clazz)  
    1012.     { return functions->UnregisterNatives(this, clazz); }  
    1013.   
    1014.     jint MonitorEnter(jobject obj)  
    1015.     { return functions->MonitorEnter(this, obj); }  
    1016.   
    1017.     jint MonitorExit(jobject obj)  
    1018.     { return functions->MonitorExit(this, obj); }  
    1019.   
    1020.     jint GetJavaVM(JavaVM** vm)  
    1021.     { return functions->GetJavaVM(this, vm); }  
    1022.   
    1023.     void GetStringRegion(jstring str, jsize start, jsize len, jchar* buf)  
    1024.     { functions->GetStringRegion(this, str, start, len, buf); }  
    1025.   
    1026.     void GetStringUTFRegion(jstring str, jsize start, jsize len, char* buf)  
    1027.     { return functions->GetStringUTFRegion(this, str, start, len, buf); }  
    1028.   
    1029.     void* GetPrimitiveArrayCritical(jarray array, jboolean* isCopy)  
    1030.     { return functions->GetPrimitiveArrayCritical(this, array, isCopy); }  
    1031.   
    1032.     void ReleasePrimitiveArrayCritical(jarray array, void* carray, jint mode)  
    1033.     { functions->ReleasePrimitiveArrayCritical(this, array, carray, mode); }  
    1034.   
    1035.     const jchar* GetStringCritical(jstring string, jboolean* isCopy)  
    1036.     { return functions->GetStringCritical(this, string, isCopy); }  
    1037.   
    1038.     void ReleaseStringCritical(jstring string, const jchar* carray)  
    1039.     { functions->ReleaseStringCritical(this, string, carray); }  
    1040.   
    1041.     jweak NewWeakGlobalRef(jobject obj)  
    1042.     { return functions->NewWeakGlobalRef(this, obj); }  
    1043.   
    1044.     void DeleteWeakGlobalRef(jweak obj)  
    1045.     { functions->DeleteWeakGlobalRef(this, obj); }  
    1046.   
    1047.     jboolean ExceptionCheck()  
    1048.     { return functions->ExceptionCheck(this); }  
    1049.   
    1050.     jobject NewDirectByteBuffer(void* address, jlong capacity)  
    1051.     { return functions->NewDirectByteBuffer(this, address, capacity); }  
    1052.   
    1053.     void* GetDirectBufferAddress(jobject buf)  
    1054.     { return functions->GetDirectBufferAddress(this, buf); }  
    1055.   
    1056.     jlong GetDirectBufferCapacity(jobject buf)  
    1057.     { return functions->GetDirectBufferCapacity(this, buf); }  
    1058.   
    1059.     /* added in JNI 1.6 */  
    1060.     jobjectRefType GetObjectRefType(jobject obj)  
    1061.     { return functions->GetObjectRefType(this, obj); }  
    1062. #endif /*__cplusplus*/  
    1063. };  
    1064.   
    1065.   
    1066. /* 
    1067.  * JNI invocation interface. 
    1068.  */  
    1069. struct JNIInvokeInterface {  
    1070.     void*       reserved0;  
    1071.     void*       reserved1;  
    1072.     void*       reserved2;  
    1073.   
    1074.     jint        (*DestroyJavaVM)(JavaVM*);  
    1075.     jint        (*AttachCurrentThread)(JavaVM*, JNIEnv**, void*);  
    1076.     jint        (*DetachCurrentThread)(JavaVM*);  
    1077.     jint        (*GetEnv)(JavaVM*, void**, jint);  
    1078.     jint        (*AttachCurrentThreadAsDaemon)(JavaVM*, JNIEnv**, void*);  
    1079. };  
    1080.   
    1081. /* 
    1082.  * C++ version. 
    1083.  */  
    1084. struct _JavaVM {  
    1085.     const struct JNIInvokeInterface* functions;  
    1086.   
    1087. #if defined(__cplusplus)  
    1088.     jint DestroyJavaVM()  
    1089.     { return functions->DestroyJavaVM(this); }  
    1090.     jint AttachCurrentThread(JNIEnv** p_env, void* thr_args)  
    1091.     { return functions->AttachCurrentThread(this, p_env, thr_args); }  
    1092.     jint DetachCurrentThread()  
    1093.     { return functions->DetachCurrentThread(this); }  
    1094.     jint GetEnv(void** env, jint version)  
    1095.     { return functions->GetEnv(this, env, version); }  
    1096.     jint AttachCurrentThreadAsDaemon(JNIEnv** p_env, void* thr_args)  
    1097.     { return functions->AttachCurrentThreadAsDaemon(this, p_env, thr_args); }  
    1098. #endif /*__cplusplus*/  
    1099. };  
    1100.   
    1101. struct JavaVMAttachArgs {  
    1102.     jint        version;    /* must be >= JNI_VERSION_1_2 */  
    1103.     const char* name;       /* NULL or name of thread as modified UTF-8 str */  
    1104.     jobject     group;      /* global ref of a ThreadGroup object, or NULL */  
    1105. };  
    1106. typedef struct JavaVMAttachArgs JavaVMAttachArgs;  
    1107.   
    1108. /* 
    1109.  * JNI 1.2+ initialization.  (As of 1.6, the pre-1.2 structures are no 
    1110.  * longer supported.) 
    1111.  */  
    1112. typedef struct JavaVMOption {  
    1113.     const char* optionString;  
    1114.     void*       extraInfo;  
    1115. } JavaVMOption;  
    1116.   
    1117. typedef struct JavaVMInitArgs {  
    1118.     jint        version;    /* use JNI_VERSION_1_2 or later */  
    1119.   
    1120.     jint        nOptions;  
    1121.     JavaVMOption* options;  
    1122.     jboolean    ignoreUnrecognized;  
    1123. } JavaVMInitArgs;  
    1124.   
    1125. #ifdef __cplusplus  
    1126. extern "C" {  
    1127. #endif  
    1128. /* 
    1129.  * VM initialization functions. 
    1130.  * 
    1131.  * Note these are the only symbols exported for JNI by the VM. 
    1132.  */  
    1133. #if 0  /* In practice, these are not exported by the NDK so don't declare them */  
    1134. jint JNI_GetDefaultJavaVMInitArgs(void*);  
    1135. jint JNI_CreateJavaVM(JavaVM**, JNIEnv**, void*);  
    1136. jint JNI_GetCreatedJavaVMs(JavaVM**, jsize, jsize*);  
    1137. #endif  
    1138.   
    1139. #define JNIIMPORT  
    1140. #define JNIEXPORT  __attribute__ ((visibility ("default")))  
    1141. #define JNICALL __NDK_FPABI__  
    1142.   
    1143. /* 
    1144.  * Prototypes for functions exported by loadable shared libs.  These are 
    1145.  * called by JNI, not provided by JNI. 
    1146.  */  
    1147. JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved);  
    1148. JNIEXPORT void JNICALL JNI_OnUnload(JavaVM* vm, void* reserved);  
    1149.   
    1150. #ifdef __cplusplus  
    1151. }  
    1152. #endif  
    1153.   
    1154.   
    1155. /* 
    1156.  * Manifest constants. 
    1157.  */  
    1158. #define JNI_FALSE   0  
    1159. #define JNI_TRUE    1  
    1160.   
    1161. #define JNI_VERSION_1_1 0x00010001  
    1162. #define JNI_VERSION_1_2 0x00010002  
    1163. #define JNI_VERSION_1_4 0x00010004  
    1164. #define JNI_VERSION_1_6 0x00010006  
    1165.   
    1166. #define JNI_OK          (0)         /* no error */  
    1167. #define JNI_ERR         (-1)        /* generic error */  
    1168. #define JNI_EDETACHED   (-2)        /* thread detached from the VM */  
    1169. #define JNI_EVERSION    (-3)        /* JNI version error */  
    1170.   
    1171. #define JNI_COMMIT      1           /* copy content, do not free buffer */  
    1172. #define JNI_ABORT       2           /* free buffer w/o copying back */  
    1173.   
    1174. #endif  /* JNI_H_ */  

相关推荐