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

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

    Java代码  收藏代码
      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_ */  
  • 相关阅读:
    day10T3改错记
    day9T1改错记
    day8T1改错记
    洛谷P5068[Ynoi2015]我回来了(bfs+bitset)
    BZOJ4939[Ynoi2016]掉进兔子洞（莫队+bitset）
    [学习笔记]dsu on tree
    [学习笔记]FWT(快速沃尔什变换)
    [学习笔记]FMT(快速莫比乌斯变换)&子集卷积(待填坑)
    POJ-1743-Musical Theme（后缀数组）
    后缀数组模板
  • 原文地址：https://www.cnblogs.com/aituming/p/6045035.html
Copyright © 2020-2023  润新知