JNI Example

jni.nim

include jni_export

type
  va_list = distinct pointer # ugly hack    
  
  jint* = clong  #machine-dependent
  jlong* = int64 #machine-dependent
  jbyte* = char  #machine-dependent

  jboolean* = uint8
  jchar* = cushort
  jshort* = cshort
  jfloat* = cfloat
  jdouble* = cdouble
  jsize* = jint

  jobject* = distinct pointer
  jclass* = jobject
  jthrowable* = jobject
  jstring* = jobject
  jarray* = jobject
  jbooleanArray* = jarray
  jbyteArray* = jarray
  jcharArray* = jarray
  jshortArray* = jarray
  jintArray* = jarray
  jlongArray* = jarray
  jfloatArray* = jarray
  jdoubleArray* = jarray
  jobjectArray* = jarray

  jweak* = jobject

  jvalue* {.union.} = object
    z: jboolean
    b: jbyte
    c: jchar
    s: jshort
    i: jint
    j: jlong
    f: jfloat
    d: jdouble
    o: jobject #change 'l' to 'o'

  jfieldID* = distinct pointer
  jmethodID* = distinct pointer

  # Return values from jobjectRefType
  jobjectRefType* = enum
    JNIInvalidRefType    = 0
    JNILocalRefType      = 1
    JNIGlobalRefType     = 2
    JNIWeakGlobalRefType = 3

  # used in RegisterNatives to describe native method name, signature,
  # and function pointer.

  JNINativeMethod* = object
    name: cstring
    signature: cstring
    fnPtr: pointer


const
  # jboolean constants
  JNI_FALSE* = 0
  JNI_TRUE*  = 1

  # possible return values for JNI functions.
  JNI_OK*          = 0   # success
  JNI_ERR*         = -1  # unknown error
  JNI_EDETACHED*   = -2  # thread detached from the VM
  JNI_EVERSION*    = -3  # JNI version error
  JNI_ENOMEM*      = -4  # not enough memory
  JNI_EEXIST*      = -5  # VM already created
  JNI_EINVAL*      = -6  # invalid arguments

  # used in ReleaseScalarArrayElements
  JNI_COMMIT* = 1
  JNI_ABORT*  = 2

type
  JavaVM* = JNIInvokeInterface
  JNIInvokeInterface* = object
    reserved0: pointer
    reserved1: pointer
    reserved2: pointer

    DestroyJavaVM: proc(vm: ptr JavaVM): jint {.JNICALL.}
    AttachCurrentThread: proc(vm: ptr JavaVM, penv: var pointer, args: pointer): jint {.JNICALL.}
    DetachCurrentThread: proc(vm: ptr JavaVM): jint {.JNICALL.}
    GetEnv: proc(vm: ptr JavaVM, penv: ptr pointer, version: jint): jint {.JNICALL.}
    AttachCurrentThreadAsDaemon: proc(vm: ptr JavaVM, penv: var pointer, args: pointer): jint {.JNICALL.}

  JNIEnv* = ptr JNINativeInterface
  JNINativeInterface* = object
    reserved0: pointer
    reserved1: pointer
    reserved2: pointer
    reserved3: pointer

    GetVersion*: proc(env: ptr JNIEnv): jint {.JNICALL.}
    
    DefineClass*: proc(env: ptr JNIEnv, name: cstring, loader: jobject, buf: ptr jbyte, len: jsize):jclass {.JNICALL.}
    FindClass*: proc(env: ptr JNIEnv, name: cstring): jclass {.JNICALL.}
    
    FromReflectedMethod*: proc(env: ptr JNIEnv, theMethod: jobject): jmethodID {.JNICALL.}
    FromReflectedField*: proc(env: ptr JNIEnv, field: jobject): jfieldID {.JNICALL.}
    
    ToReflectedMethod*: proc(env: ptr JNIEnv, cls: jclass, methodID: jmethodID, isStatic: jboolean): jobject {.JNICALL.}
    
    GetSuperclass*: proc(env: ptr JNIEnv, sub: jclass): jclass {.JNICALL.}
    IsAssignableFrom*: proc(env: ptr JNIEnv, sub: jclass, sup: jclass): jboolean {.JNICALL.}
    
    ToReflectedField*: proc(env: ptr JNIEnv, cls: jclass, fieldID: jfieldID, isStatic: jboolean): jobject {.JNICALL.}
    
    Throw*: proc(env: ptr JNIEnv, obj: jthrowable): jint {.JNICALL.}
    ThrowNew*: proc(env: ptr JNIEnv, clazz: jclass, msg: cstring): jint {.JNICALL.}
    ExceptionOccurred*: proc(env: ptr JNIEnv): jthrowable {.JNICALL.}
    ExceptionDescribe*: proc(env: ptr JNIEnv): void {.JNICALL.}
    ExceptionClear*: proc(env: ptr JNIEnv): void {.JNICALL.}
    FatalError*: proc(env: ptr JNIEnv, msg: cstring): void {.JNICALL.}
    
    PushLocalFrame*: proc(env: ptr JNIEnv, capacity: jint): jint {.JNICALL.}
    PopLocalFrame*: proc(env: ptr JNIEnv, result: jobject): jobject {.JNICALL.}
    
    NewGlobalRef*: proc(env: ptr JNIEnv, lobj: jobject): jobject {.JNICALL.}
    DeleteGlobalRef*: proc(env: ptr JNIEnv, gref: jobject): void {.JNICALL.}
    DeleteLocalRef*: proc(env: ptr JNIEnv, obj: jobject): void {.JNICALL.}
    IsSameObject*: proc(env: ptr JNIEnv, obj1: jobject, obj2: jobject): jboolean {.JNICALL.}
    NewLocalRef*: proc(env: ptr JNIEnv, theRef: jobject): jobject {.JNICALL.}
    EnsureLocalCapacity*: proc(env: ptr JNIEnv, capacity: jint): jint {.JNICALL.}
    
    AllocObject*: proc(env: ptr JNIEnv, clazz: jclass): jobject {.JNICALL.}
    NewObject*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID): jobject {.JNICALL, varargs.}
    NewObjectV*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID, args: va_list): jobject {.JNICALL.}
    NewObjectA*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID, args: ptr jvalue): jobject {.JNICALL.}
    
    GetObjectClass*: proc(env: ptr JNIEnv, obj: jobject): jclass {.JNICALL.}
    IsInstanceOf*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass): jboolean {.JNICALL.}
    
    GetMethodID*: proc(env: ptr JNIEnv, clazz: jclass, name: cstring, sig: cstring): jmethodID {.JNICALL.}
    
    CallObjectMethod*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID): jobject {.JNICALL, varargs.}
    CallObjectMethodV*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID, args: va_list): jobject {.JNICALL.}
    CallObjectMethodA*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID, args: ptr jvalue): jobject {.JNICALL.}
    
    CallBooleanMethod*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID): jboolean {.JNICALL, varargs.}
    CallBooleanMethodV*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID, args: va_list): jboolean {.JNICALL.}
    CallBooleanMethodA*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID, args: ptr jvalue): jboolean {.JNICALL.}
    
    CallByteMethod*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID): jbyte {.JNICALL, varargs.}
    CallByteMethodV*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID, args: va_list): jbyte {.JNICALL.}
    CallByteMethodA*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID, args: ptr jvalue): jbyte {.JNICALL.}
    
    CallCharMethod*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID): jchar {.JNICALL, varargs.}
    CallCharMethodV*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID, args: va_list): jchar {.JNICALL.}
    CallCharMethodA*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID, args: ptr jvalue): jchar {.JNICALL.}
    
    CallShortMethod*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID): jshort {.JNICALL, varargs.}
    CallShortMethodV*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID, args: va_list): jshort {.JNICALL.}
    CallShortMethodA*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID, args: ptr jvalue): jshort {.JNICALL.}
    
    CallIntMethod*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID): jint {.JNICALL, varargs.}
    CallIntMethodV*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID, args: va_list): jint {.JNICALL.}
    CallIntMethodA*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID, args: ptr jvalue): jint {.JNICALL.}
    
    CallLongMethod*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID): jlong {.JNICALL, varargs.}
    CallLongMethodV*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID, args: va_list): jlong {.JNICALL.}
    CallLongMethodA*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID, args: ptr jvalue): jlong {.JNICALL.}
    
    CallFloatMethod*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID): jfloat {.JNICALL, varargs.}
    CallFloatMethodV*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID, args: va_list): jfloat {.JNICALL.}
    CallFloatMethodA*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID, args: ptr jvalue): jfloat {.JNICALL.}
    
    CallDoubleMethod*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID): jdouble {.JNICALL, varargs.}
    CallDoubleMethodV*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID, args: va_list): jdouble {.JNICALL.}
    CallDoubleMethodA*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID, args: ptr jvalue): jdouble {.JNICALL.}
    
    CallVoidMethod*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID) {.JNICALL, varargs.}
    CallVoidMethodV*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID, args: va_list) {.JNICALL.}
    CallVoidMethodA*: proc(env: ptr JNIEnv, obj: jobject, methodID: jmethodID, args: ptr jvalue) {.JNICALL.}
    
    CallNonvirtualObjectMethod*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID): jobject {.JNICALL, varargs.}
    CallNonvirtualObjectMethodV*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID, args: va_list): jobject {.JNICALL.}
    CallNonvirtualObjectMethodA*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID, args: ptr jvalue): jobject {.JNICALL.}
    
    CallNonvirtualBooleanMethod*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID): jboolean {.JNICALL, varargs.}
    CallNonvirtualBooleanMethodV*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID, args: va_list): jboolean {.JNICALL.}
    CallNonvirtualBooleanMethodA*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID, args: ptr jvalue): jboolean {.JNICALL.}
    
    CallNonvirtualByteMethod*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID): jbyte {.JNICALL, varargs.}
    CallNonvirtualByteMethodV*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID, args: va_list): jbyte {.JNICALL.}
    CallNonvirtualByteMethodA*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID, args: ptr jvalue): jbyte {.JNICALL.}
    
    CallNonvirtualCharMethod*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID): jchar {.JNICALL, varargs.}
    CallNonvirtualCharMethodV*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID, args: va_list): jchar {.JNICALL.}
    CallNonvirtualCharMethodA*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID, args: ptr jvalue): jchar {.JNICALL.}
    
    CallNonvirtualShortMethod*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID): jshort {.JNICALL, varargs.}
    CallNonvirtualShortMethodV*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID, args: va_list): jshort {.JNICALL.}
    CallNonvirtualShortMethodA*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID, args: ptr jvalue): jshort {.JNICALL.}
    
    CallNonvirtualIntMethod*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID): jint {.JNICALL, varargs.}
    CallNonvirtualIntMethodV*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID, args: va_list): jint {.JNICALL.}
    CallNonvirtualIntMethodA*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID, args: ptr jvalue): jint {.JNICALL.}
    
    CallNonvirtualLongMethod*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID): jlong {.JNICALL, varargs.}
    CallNonvirtualLongMethodV*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID, args: va_list): jlong {.JNICALL.}
    CallNonvirtualLongMethodA*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID, args: ptr jvalue): jlong {.JNICALL.}
    
    CallNonvirtualFloatMethod*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID): jfloat {.JNICALL, varargs.}
    CallNonvirtualFloatMethodV*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID, args: va_list): jfloat {.JNICALL.}
    CallNonvirtualFloatMethodA*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID, args: ptr jvalue): jfloat {.JNICALL.}
    
    CallNonvirtualDoubleMethod*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID): jdouble {.JNICALL, varargs.}
    CallNonvirtualDoubleMethodV*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID, args: va_list): jdouble {.JNICALL.}
    CallNonvirtualDoubleMethodA*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID, args: ptr jvalue): jdouble {.JNICALL.}
    
    CallNonvirtualVoidMethod*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID) {.JNICALL, varargs.}
    CallNonvirtualVoidMethodV*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID, args: va_list) {.JNICALL.}
    CallNonvirtualVoidMethodA*: proc(env: ptr JNIEnv, obj: jobject, clazz: jclass, methodID: jmethodID, args: ptr jvalue) {.JNICALL.}
    
    GetFieldID*: proc(env: ptr JNIEnv, clazz: jclass, name: cstring, sig: cstring): jfieldID {.JNICALL.}
    
    GetObjectField*: proc(env: ptr JNIEnv, obj: jobject, fieldID: jfieldID): jobject {.JNICALL.}
    GetBooleanField*: proc(env: ptr JNIEnv, obj: jobject, fieldID: jfieldID): jboolean {.JNICALL.}
    GetByteField*: proc(env: ptr JNIEnv, obj: jobject, fieldID: jfieldID): jbyte {.JNICALL.}
    GetCharField*: proc(env: ptr JNIEnv, obj: jobject, fieldID: jfieldID): jchar {.JNICALL.}
    GetShortField*: proc(env: ptr JNIEnv, obj: jobject, fieldID: jfieldID): jshort {.JNICALL.}
    GetIntField*: proc(env: ptr JNIEnv, obj: jobject, fieldID: jfieldID): jint {.JNICALL.}
    GetLongField*: proc(env: ptr JNIEnv, obj: jobject, fieldID: jfieldID): jlong {.JNICALL.}
    GetFloatField*: proc(env: ptr JNIEnv, obj: jobject, fieldID: jfieldID): jfloat {.JNICALL.}
    GetDoubleField*: proc(env: ptr JNIEnv, obj: jobject, fieldID: jfieldID): jdouble {.JNICALL.}
    
    SetObjectField*: proc(env: ptr JNIEnv, obj: jobject, fieldID: jfieldID, val: jobject): void {.JNICALL.}
    SetBooleanField*: proc(env: ptr JNIEnv, obj: jobject, fieldID: jfieldID, val: jboolean): void {.JNICALL.}
    SetByteField*: proc(env: ptr JNIEnv, obj: jobject, fieldID: jfieldID, val: jbyte): void {.JNICALL.}
    SetCharField*: proc(env: ptr JNIEnv, obj: jobject, fieldID: jfieldID, val: jchar): void {.JNICALL.}
    SetShortField*: proc(env: ptr JNIEnv, obj: jobject, fieldID: jfieldID, val: jshort): void {.JNICALL.}
    SetIntField*: proc(env: ptr JNIEnv, obj: jobject, fieldID: jfieldID, val: jint): void {.JNICALL.}
    SetLongField*: proc(env: ptr JNIEnv, obj: jobject, fieldID: jfieldID, val: jlong): void {.JNICALL.}
    SetFloatField*: proc(env: ptr JNIEnv, obj: jobject, fieldID: jfieldID, val: jfloat): void {.JNICALL.}
    SetDoubleField*: proc(env: ptr JNIEnv, obj: jobject, fieldID: jfieldID, val: jdouble): void {.JNICALL.}
    
    GetStaticMethodID*: proc(env: ptr JNIEnv, clazz: jclass, name: cstring, sig: cstring): jmethodID {.JNICALL.}
    
    CallStaticObjectMethod*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID): jobject {.JNICALL, varargs.}
    CallStaticObjectMethodV*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID, args: va_list): jobject {.JNICALL.}
    CallStaticObjectMethodA*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID, args: ptr jvalue): jobject {.JNICALL.}
    
    CallStaticBooleanMethod*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID): jboolean {.JNICALL, varargs.}
    CallStaticBooleanMethodV*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID, args: va_list): jboolean {.JNICALL.}
    CallStaticBooleanMethodA*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID, args: ptr jvalue): jboolean {.JNICALL.}
    
    CallStaticByteMethod*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID): jbyte {.JNICALL, varargs.}
    CallStaticByteMethodV*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID, args: va_list): jbyte {.JNICALL.}
    CallStaticByteMethodA*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID, args: ptr jvalue): jbyte {.JNICALL.}
    
    CallStaticCharMethod*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID): jchar {.JNICALL, varargs.}
    CallStaticCharMethodV*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID, args: va_list): jchar {.JNICALL.}
    CallStaticCharMethodA*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID, args: ptr jvalue): jchar {.JNICALL.}
    
    CallStaticShortMethod*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID): jshort {.JNICALL, varargs.}
    CallStaticShortMethodV*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID, args: va_list): jshort {.JNICALL.}
    CallStaticShortMethodA*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID, args: ptr jvalue): jshort {.JNICALL.}
    
    CallStaticIntMethod*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID): jint {.JNICALL, varargs.}
    CallStaticIntMethodV*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID, args: va_list): jint {.JNICALL.}
    CallStaticIntMethodA*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID, args: ptr jvalue): jint {.JNICALL.}
    
    CallStaticLongMethod*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID): jlong {.JNICALL, varargs.}
    CallStaticLongMethodV*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID, args: va_list): jlong {.JNICALL.}
    CallStaticLongMethodA*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID, args: ptr jvalue): jlong {.JNICALL.}
    
    CallStaticFloatMethod*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID): jfloat {.JNICALL, varargs.}
    CallStaticFloatMethodV*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID, args: va_list): jfloat {.JNICALL.}
    CallStaticFloatMethodA*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID, args: ptr jvalue): jfloat {.JNICALL.}
    
    CallStaticDoubleMethod*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID): jdouble {.JNICALL, varargs.}
    CallStaticDoubleMethodV*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID, args: va_list): jdouble {.JNICALL.}
    CallStaticDoubleMethodA*: proc(env: ptr JNIEnv, clazz: jclass, methodID: jmethodID, args: ptr jvalue): jdouble {.JNICALL.}
    
    CallStaticVoidMethod*: proc(env: ptr JNIEnv, cls: jclass, methodID: jmethodID): void {.JNICALL, varargs.}
    CallStaticVoidMethodV*: proc(env: ptr JNIEnv, cls: jclass, methodID: jmethodID, args: va_list): void {.JNICALL.}
    CallStaticVoidMethodA*: proc(env: ptr JNIEnv, cls: jclass, methodID: jmethodID, args: ptr jvalue): void {.JNICALL.}
    
    GetStaticFieldID*: proc(env: ptr JNIEnv, clazz: jclass, name: cstring, sig: cstring): jfieldID {.JNICALL.}
    GetStaticObjectField*: proc(env: ptr JNIEnv, clazz: jclass, fieldID: jfieldID): jobject {.JNICALL.}
    GetStaticBooleanField*: proc(env: ptr JNIEnv, clazz: jclass, fieldID: jfieldID): jboolean {.JNICALL.}
    GetStaticByteField*: proc(env: ptr JNIEnv, clazz: jclass, fieldID: jfieldID): jbyte {.JNICALL.}
    GetStaticCharField*: proc(env: ptr JNIEnv, clazz: jclass, fieldID: jfieldID): jchar {.JNICALL.}
    GetStaticShortField*: proc(env: ptr JNIEnv, clazz: jclass, fieldID: jfieldID): jshort {.JNICALL.}
    GetStaticIntField*: proc(env: ptr JNIEnv, clazz: jclass, fieldID: jfieldID): jint {.JNICALL.}
    GetStaticLongField*: proc(env: ptr JNIEnv, clazz: jclass, fieldID: jfieldID): jlong {.JNICALL.}
    GetStaticFloatField*: proc(env: ptr JNIEnv, clazz: jclass, fieldID: jfieldID): jfloat {.JNICALL.}
    GetStaticDoubleField*: proc(env: ptr JNIEnv, clazz: jclass, fieldID: jfieldID): jdouble {.JNICALL.}
    
    SetStaticObjectField*: proc(env: ptr JNIEnv, clazz: jclass, fieldID: jfieldID, val: jobject): void {.JNICALL.}
    SetStaticBooleanField*: proc(env: ptr JNIEnv, clazz: jclass, fieldID: jfieldID, val: jboolean): void {.JNICALL.}
    SetStaticByteField*: proc(env: ptr JNIEnv, clazz: jclass, fieldID: jfieldID, val: jbyte): void {.JNICALL.}
    SetStaticCharField*: proc(env: ptr JNIEnv, clazz: jclass, fieldID: jfieldID, val: jchar): void {.JNICALL.}
    SetStaticShortField*: proc(env: ptr JNIEnv, clazz: jclass, fieldID: jfieldID, val: jshort): void {.JNICALL.}
    SetStaticIntField*: proc(env: ptr JNIEnv, clazz: jclass, fieldID: jfieldID, val: jint): void {.JNICALL.}
    SetStaticLongField*: proc(env: ptr JNIEnv, clazz: jclass, fieldID: jfieldID, val: jlong): void {.JNICALL.}
    SetStaticFloatField*: proc(env: ptr JNIEnv, clazz: jclass, fieldID: jfieldID, val: jfloat): void {.JNICALL.}
    SetStaticDoubleField*: proc(env: ptr JNIEnv, clazz: jclass, fieldID: jfieldID, val: jdouble): void {.JNICALL.}
    
    NewString*: proc(env: ptr JNIEnv, unicode: ptr jchar, len: jsize): jstring {.JNICALL.}
    GetStringLength*: proc(env: ptr JNIEnv, str: jstring): jsize {.JNICALL.}
    GetStringChars*: proc(env: ptr JNIEnv, str: jstring, isCopy: var jboolean): ptr jchar {.JNICALL.}
    ReleaseStringChars*: proc(env: ptr JNIEnv, str: jstring, chars: ptr jchar) {.JNICALL.}
    
    NewStringUTF*: proc(env: ptr JNIEnv, utf: cstring): jstring {.JNICALL.}
    GetStringUTFLength*: proc(env: ptr JNIEnv, str: jstring): jsize {.JNICALL.}
    GetStringUTFChars*: proc(env: ptr JNIEnv, str: jstring, isCopy: var jboolean): cstring {.JNICALL.}
    ReleaseStringUTFChars*: proc(env: ptr JNIEnv, str: jstring, chars: cstring) {.JNICALL.}
    
    GetArrayLength*: proc(env: ptr JNIEnv, arr: jarray): jsize {.JNICALL.}
    
    NewObjectArray*: proc(env: ptr JNIEnv, len: jsize, clazz: jclass, init: jobject): jobjectArray {.JNICALL.}
    GetObjectArrayElement*: proc(env: ptr JNIEnv, arr: jobjectArray, index: jsize): jobject {.JNICALL.}
    SetObjectArrayElement*: proc(env: ptr JNIEnv, arr: jobjectArray, index: jsize, val: jobject) {.JNICALL.}
    
    NewBooleanArray*: proc(env: ptr JNIEnv, len: jsize): jbooleanArray {.JNICALL.}
    NewByteArray*: proc(env: ptr JNIEnv, len: jsize): jbyteArray {.JNICALL.}
    NewCharArray*: proc(env: ptr JNIEnv, len: jsize): jcharArray {.JNICALL.}
    NewShortArray*: proc(env: ptr JNIEnv, len: jsize): jshortArray {.JNICALL.}
    NewIntArray*: proc(env: ptr JNIEnv, len: jsize): jintArray {.JNICALL.}
    NewLongArray*: proc(env: ptr JNIEnv, len: jsize): jlongArray {.JNICALL.}
    NewFloatArray*: proc(env: ptr JNIEnv, len: jsize): jfloatArray {.JNICALL.}
    NewDoubleArray*: proc(env: ptr JNIEnv, len: jsize): jdoubleArray {.JNICALL.}
    
    GetBooleanArrayElements*: proc(env: ptr JNIEnv, arr: jbooleanArray, isCopy: var jboolean): ptr jboolean {.JNICALL.}
    GetByteArrayElements*: proc(env: ptr JNIEnv, arr: jbyteArray, isCopy: var jboolean): ptr jbyte {.JNICALL.}
    GetCharArrayElements*: proc(env: ptr JNIEnv, arr: jcharArray, isCopy: var jboolean): ptr jchar {.JNICALL.}
    GetShortArrayElements*: proc(env: ptr JNIEnv, arr: jshortArray, isCopy: var jboolean): ptr jshort {.JNICALL.}
    GetIntArrayElements*: proc(env: ptr JNIEnv, arr: jintArray, isCopy: var jboolean): ptr jint {.JNICALL.}
    GetLongArrayElements*: proc(env: ptr JNIEnv, arr: jlongArray, isCopy: var jboolean): ptr jlong {.JNICALL.}
    GetFloatArrayElements*: proc(env: ptr JNIEnv, arr: jfloatArray, isCopy: var jboolean): ptr jfloat {.JNICALL.}
    GetDoubleArrayElements*: proc(env: ptr JNIEnv, arr: jdoubleArray, isCopy: var jboolean): ptr jdouble {.JNICALL.}
    
    ReleaseBooleanArrayElements*: proc(env: ptr JNIEnv, arr: jbooleanArray, elems: ptr jboolean, mode: jint): void {.JNICALL.}
    ReleaseByteArrayElements*: proc(env: ptr JNIEnv, arr: jbyteArray, elems: ptr jbyte, mode: jint): void {.JNICALL.}
    ReleaseCharArrayElements*: proc(env: ptr JNIEnv, arr: jcharArray, elems: ptr jchar, mode: jint): void {.JNICALL.}
    ReleaseShortArrayElements*: proc(env: ptr JNIEnv, arr: jshortArray, elems: ptr jshort, mode: jint): void {.JNICALL.}
    ReleaseIntArrayElements*: proc(env: ptr JNIEnv, arr: jintArray, elems: ptr jint, mode: jint): void {.JNICALL.}
    ReleaseLongArrayElements*: proc(env: ptr JNIEnv, arr: jlongArray, elems: ptr jlong, mode: jint): void {.JNICALL.}
    ReleaseFloatArrayElements*: proc(env: ptr JNIEnv, arr: jfloatArray, elems: ptr jfloat, mode: jint): void {.JNICALL.}
    ReleaseDoubleArrayElements*: proc(env: ptr JNIEnv, arr: jdoubleArray, elems: ptr jdouble, mode: jint): void {.JNICALL.}
    
    GetBooleanArrayRegion*: proc(env: ptr JNIEnv, arr: jbooleanArray, start: jsize, len: jsize, buf: ptr jboolean): void {.JNICALL.}
    GetByteArrayRegion*: proc(env: ptr JNIEnv, arr: jbyteArray, start: jsize, len: jsize, buf: ptr jbyte): void {.JNICALL.}
    GetCharArrayRegion*: proc(env: ptr JNIEnv, arr: jcharArray, start: jsize, len: jsize, buf: ptr jchar): void {.JNICALL.}
    GetShortArrayRegion*: proc(env: ptr JNIEnv, arr: jshortArray, start: jsize, len: jsize, buf: ptr jshort): void {.JNICALL.}
    GetIntArrayRegion*: proc(env: ptr JNIEnv, arr: jintArray, start: jsize, len: jsize, buf: ptr jint): void {.JNICALL.}
    GetLongArrayRegion*: proc(env: ptr JNIEnv, arr: jlongArray, start: jsize, len: jsize, buf: ptr jlong): void {.JNICALL.}
    GetFloatArrayRegion*: proc(env: ptr JNIEnv, arr: jfloatArray, start: jsize, len: jsize, buf: ptr jfloat): void {.JNICALL.}
    GetDoubleArrayRegion*: proc(env: ptr JNIEnv, arr: jdoubleArray, start: jsize, len: jsize, buf: ptr jdouble): void {.JNICALL.}
    
    SetBooleanArrayRegion*: proc(env: ptr JNIEnv, arr: jbooleanArray, start: jsize, len: jsize, buf: ptr jboolean): void {.JNICALL.}
    SetByteArrayRegion*: proc(env: ptr JNIEnv, arr: jbyteArray, start: jsize, len: jsize, buf: ptr jbyte): void {.JNICALL.}
    SetCharArrayRegion*: proc(env: ptr JNIEnv, arr: jcharArray, start: jsize, len: jsize, buf: ptr jchar): void {.JNICALL.}
    SetShortArrayRegion*: proc(env: ptr JNIEnv, arr: jshortArray, start: jsize, len: jsize, buf: ptr jshort): void {.JNICALL.}
    SetIntArrayRegion*: proc(env: ptr JNIEnv, arr: jintArray, start: jsize, len: jsize, buf: ptr jint): void {.JNICALL.}
    SetLongArrayRegion*: proc(env: ptr JNIEnv, arr: jlongArray, start: jsize, len: jsize, buf: ptr jlong): void {.JNICALL.}
    SetFloatArrayRegion*: proc(env: ptr JNIEnv, arr: jfloatArray, start: jsize, len: jsize, buf: ptr jfloat): void {.JNICALL.}
    SetDoubleArrayRegion*: proc(env: ptr JNIEnv, arr: jdoubleArray, start: jsize, len: jsize, buf: ptr jdouble): void {.JNICALL.}
    
    RegisterNatives*: proc(env: ptr JNIEnv, clazz: jclass, methods: ptr JNINativeMethod, nMethods: jint): jint {.JNICALL.}
    UnregisterNatives*: proc(env: ptr JNIEnv, clazz: jclass): jint {.JNICALL.}
    
    MonitorEnter*: proc(env: ptr JNIEnv, obj: jobject): jint {.JNICALL.}
    MonitorExit*: proc(env: ptr JNIEnv, obj: jobject): jint {.JNICALL.}
    
    GetJavaVM*: proc(env: ptr JNIEnv, vm: var ptr JavaVM): jint {.JNICALL.}
    
    GetStringRegion*: proc(env: ptr JNIEnv, str: jstring, start: jsize, len: jsize, buf: ptr jchar) {.JNICALL.}
    GetStringUTFRegion*: proc(env: ptr JNIEnv, str: jstring, start: jsize, len: jsize, buf: cstring) {.JNICALL.}
    
    GetPrimitiveArrayCritical*: proc(env: ptr JNIEnv, jarray, isCopy: var jboolean): pointer {.JNICALL.}
    ReleasePrimitiveArrayCritical*: proc(env: ptr JNIEnv, jarray, carray: pointer, mode: jint) {.JNICALL.}
    
    GetStringCritical*: proc(env: ptr JNIEnv, str: jstring, isCopy: var jboolean): ptr jchar {.JNICALL.}
    ReleaseStringCritical*: proc(env: ptr JNIEnv, str: jstring, cstr: ptr jchar) {.JNICALL.}
    
    NewWeakGlobalRef*: proc(env: ptr JNIEnv, obj: jobject): jweak {.JNICALL.}
    DeleteWeakGlobalRef*: proc(env: ptr JNIEnv, theRef: jweak) {.JNICALL.}
    
    ExceptionCheck*: proc(env: ptr JNIEnv): jboolean {.JNICALL.}
    
    NewDirectByteBuffer*: proc(env: ptr JNIEnv, address: pointer, capacity: jlong): jobject {.JNICALL.}
    GetDirectBufferAddress*: proc(env: ptr JNIEnv, buf: jobject): pointer {.JNICALL.}
    GetDirectBufferCapacity*: proc(env: ptr JNIEnv, buf: jobject): jlong {.JNICALL.}
    
    # New JNI 1.6 Features
    GetObjectRefType*: proc(env: ptr JNIEnv, obj: jobject): jobjectRefType {.JNICALL.}

proc JNI_GetDefaultJavaVMInitArgs(args: pointer): jint {.JNIIMPORT.}
proc JNI_CreateJavaVM(pvm: var ptr JavaVM, penv: var pointer, args: pointer): jint {.JNIIMPORT.}
proc JNI_GetCreatedJavaVMs(pvm: var ptr JavaVM, arg1: jsize, arg2: var jsize): jint {.JNIIMPORT.}

# Defined by native libraries.
#proc JNI_OnLoad(vm: ptr JavaVM, reserved: pointer): jint {.JNIEXPORT.}
#proc JNI_OnUnload(vm: ptr JavaVM, reserved: pointer) {.JNIEXPORT.}

jni_dynlib.nim

when defined(MACOSX):
  const
    JVM_LIB_NAME* = "jvm.dylib"
elif defined(UNIX):
  const
    JVM_LIB_NAME* = "jvm.so"
else:
  const
    JVM_LIB_NAME* = "jvm.dll"

jni_export.nim

import jni_dynlib

when defined(windows):
  {.pragma: JNIEXPORT, stdcall, exportc, dynlib.}
  {.pragma: JNIIMPORT, stdcall, importc, dynlib: JVM_LIB_NAME.}
  {.pragma: JNICALL, stdcall.}
else:
  {.pragma: JNIEXPORT, cdecl, exportc, dynlib.}
  {.pragma: JNIIMPORT, cdecl, importc, dynlib: JVM_LIB_NAME.}
  {.pragma: JNICALL, cdecl.}

Sample1.java

public class Sample1
{
  public native int intMethod(int n);
  public native boolean booleanMethod(boolean bool);
  public native String stringMethod(String text);
  public native int intArrayMethod(int[] intArray);

  public static void main(String[] args)
  {
    System.loadLibrary("Sample1");
    Sample1 sample = new Sample1();
    int     square = sample.intMethod(5);
    boolean bool   = sample.booleanMethod(true);
    String  text   = sample.stringMethod("JAVA");
    int     sum    = sample.intArrayMethod(new int[]{1,1,2,3,5,8,13} );

    System.out.println("intMethod: " + square);
    System.out.println("booleanMethod: " + bool);
    System.out.println("stringMethod: " + text);
    System.out.println("intArrayMethod: " + sum);
  }
}

Sample1.nim

import jni, strutils
include jni_export

proc Java_Sample1_intMethod(env: ptr JNIEnv, obj: jobject, num: jint): jint {.JNIEXPORT.} =
  result = num * num

proc Java_Sample1_booleanMethod(env: ptr JNIEnv, obj: jobject, boolean: jboolean): jboolean {.JNIEXPORT.} =  
  result = if boolean == JNI_FALSE: JNI_TRUE else: JNI_FALSE

proc Java_Sample1_stringMethod(env: ptr JNIEnv, obj: jobject, input: jstring): jstring {.JNIEXPORT.} =
  var isCopy: jboolean
  var str = env[].GetStringUTFChars(env, input, isCopy)
  var cap = $str
  env[].ReleaseStringUTFChars(env, input, str)
  result = env[].NewStringUTF(env, cap.toUpper)

proc Java_Sample1_intArrayMethod(env: ptr JNIEnv, obj: jobject, input: jintArray): jint {.JNIEXPORT.} =
  proc `[]`[T](a: ptr T, i: int): T =
    result = cast[ptr T](cast[ByteAddress](a) + i * sizeof(T))[]
      
  var 
    sum: jint = 0
    isCopy: jboolean
    
  let
    len = env[].GetArrayLength(env, input)
    body = env[].GetIntArrayElements(env, input, isCopy)
    
  for i in 0.. <len:
    inc(sum, body[i])
    
  env[].ReleaseIntArrayElements(env, input, body, 0)
  result = sum