public static unsafe void Unregister(JniHandle clazz, JNIEnv env)
 {
     JNIResult res = env.UnregisterNatives(clazz);
     if (res != JNIResult.JNI_OK)
     {
         throw new JNIException("Can't unbind native methods to class.");
     }
 }

 public void SetBooleanArrayRegion(JniHandle array, int start, int len, bool[] buf)
 {
     fixed (bool* ptr = &buf[0])
     {
         setBooleanArrayRegion(envPtr, array, start, len, (byte*) ptr);
     }
     ExceptionTest();
 }

 public void SetByteArrayRegion(JniHandle array, int start, int len, byte[] buf)
 {
     fixed (byte* ptr = &buf[0])
     {
         setByteArrayRegion(envPtr, array, start, len, ptr);
     }
     ExceptionTest();
 }

 public void SetCharArrayRegion(JniHandle array, int start, int len, char[] buf)
 {
     fixed (char* ptr = &buf[0])
     {
         setCharArrayRegion(envPtr, array, start, len, ptr);
     }
     ExceptionTest();
 }

 public void SetFloatArrayRegion(JniHandle array, int start, int len, float[] buf)
 {
     fixed (float* ptr = &buf[0])
     {
         setFloatArrayRegion(envPtr, array, start, len, ptr);
     }
     ExceptionTest();
 }

 public void SetLongArrayRegion(JniHandle array, int start, int len, long[] buf)
 {
     fixed (long* ptr = &buf[0])
     {
         setLongArrayRegion(envPtr, array, start, len, ptr);
     }
     ExceptionTest();
 }

 public static unsafe void Register(List<JNINativeMethod> registrations, JniHandle clazz, JNIEnv env)
 {
     JNINativeMethod[] methods = registrations.ToArray();
     JNIResult res = env.RegisterNatives(clazz, methods, methods.Length);
     if (res!=JNIResult.JNI_OK)
     {
         throw new JNIException("Can't bind native methods to class. Is it in system classloader?");
     }
 }

 public int GetArrayLength(JniHandle array)
 {
     int res = getArrayLength(envPtr, array);
     ExceptionTest();
     return res;
 }

 public void SetObjectArrayElement(JniHandle array, int index, JniHandle val)
 {
     setObjectArrayElement(envPtr, array, index, val);
     ExceptionTest();
 }

 public void GetShortArrayRegion(JniHandle array, int start, int len, short[] buf)
 {
     fixed (short* ptr = &buf[0])
     {
         getShortArrayRegion(envPtr, array, start, len, ptr);
     }
     ExceptionTest();
 }

 public void GetDoubleArrayRegion(JniHandle array, int start, int len, double[] buf)
 {
     fixed (double* ptr = &buf[0])
     {
         getDoubleArrayRegion(envPtr, array, start, len, ptr);
     }
     ExceptionTest();
 }

 internal void Throw(JniHandle ptr)
 {
     if (@throw(envPtr, ptr) != JNIResult.JNI_OK)
     {
         throw new JNIException("Can't throw");
     }
 }

 public JniLocalHandle NewObjectArray(int len, JniHandle clazz, JniHandle init)
 {
     JniLocalHandle res = newObjectArray(envPtr, len, clazz, init);
     ExceptionTest();
     return res;
 }

 internal void SetStaticDoubleField(JniHandle clazz, FieldId fieldID, double value)
 {
     setStaticDoubleField(envPtr, clazz, fieldID.native, value);
     ExceptionTest();
 }

 public double CallDoubleMethod(JniHandle obj, MethodId methodIdNative, params Value[] args)
 {
     double res = callDoubleMethod(envPtr, obj, methodIdNative.native, args);
     ExceptionTest();
     return res;
 }

 public JniLocalHandle GetStaticObjectField(JniHandle clazz, FieldId fieldID)
 {
     JniLocalHandle res = getStaticObjectField(envPtr, clazz, fieldID.native);
     ExceptionTest();
     return res;
 }

 internal void SetStaticObjectField(JniHandle clazz, FieldId fieldID, JavaObject value)
 {
     setStaticObjectField(envPtr, clazz, fieldID.native, value.JvmHandle);
     ExceptionTest();
 }

 public JniLocalHandle GetObjectField(JniHandle obj, FieldId fieldID)
 {
     JniLocalHandle res = getObjectField(envPtr, obj, fieldID.native);
     ExceptionTest();
     return res;
 }

 public JniLocalHandle ToReflectedMethod(JniHandle cls, MethodId methodId, bool isStatic)
 {
     JniLocalHandle res = toReflectedMethod.Invoke(envPtr, cls, methodId.native,
                                           isStatic ? (byte) 1 : (byte) 0);
     ExceptionTest();
     return res;
 }

 public JniLocalHandle ToReflectedField(JniHandle cls, FieldId fieldID, bool isStatic)
 {
     JniLocalHandle res = toReflectedField.Invoke(envPtr, cls, fieldID.native,
                                          isStatic ? (byte) 1 : (byte) 0);
     ExceptionTest();
     return res;
 }