@zsa233/frida-analykit-agent 2.0.0 → 2.0.2

package/dist/jni/env.js

@@ -0,0 +1,1054 @@
+import { Java } from "../bridges.js";
+import { IndirectRefKind, JNI_VT } from "./struct.js";
+import { nativeFunctionOptions } from '../consts.js';
+import { help, NativePointerObject } from "../helper.js";
+import { setGlobalProperties } from '../config.js';
+function getThreadFromEnv(env) {
+    return env.handle.add(Process.pointerSize).readPointer();
+}
+class MirrorObject extends NativePointerObject {
+    constructor(handle) {
+        super(handle);
+    }
+}
+export class jobject extends NativePointerObject {
+    constructor(handle, { parent = null, isStatic = parent?._isStatic || false, } = {}) {
+        super(handle);
+        this._isStatic = false;
+        this._deleted = false;
+        this._parent = parent;
+        this._isStatic = isStatic;
+    }
+    $unwrap() {
+        return {
+            isStatic: this._isStatic,
+            parent: this._parent,
+        };
+    }
+    $toString() {
+        const result = JNIEnv.CallObjectMethod(this, JNIEnv.javaLangObject().toString);
+        const utf16 = result.$jstring.toUTF16String();
+        const str = utf16.toString();
+        utf16.release();
+        result.$unref();
+        return str;
+    }
+    get $IndirectRefKind() {
+        return Number(this._handle.and(JniEnv.kKindMask));
+    }
+    $bind(kws) {
+        const opt = { ...this.$unwrap(), ...kws };
+        return new this.constructor(this._handle, opt);
+    }
+    get $class() {
+        if (this._class !== undefined) {
+            return this._class;
+        }
+        const cls = JNIEnv.GetObjectClass(this._handle).$globalRef().$jclass.$bind({ parent: this, isStatic: this._isStatic });
+        this._class = cls;
+        return cls;
+    }
+    $method(name, sig) {
+        return JNIEnv.GetMethodID(this.$class, name, sig);
+    }
+    $methodID(methodId) {
+        return JNIEnv.ToReflectedMethod(this.$class, methodId, this._isStatic).$bind({ parent: this });
+    }
+    $getName() {
+        const handle = this;
+        const javaLang = this._parent === null ? JNIEnv.javaLangClass() : JNIEnv.javaLangReflectMethod();
+        const result = JNIEnv.CallObjectMethod(handle, javaLang.getName);
+        const utf16 = result.$jstring.toUTF16String();
+        const str = utf16.toString();
+        utf16.release();
+        result.$unref();
+        return str;
+    }
+    get $jstring() { return new jstring(this.$handle, this.$unwrap()); }
+    get $jobject() { return new jobject(this.$handle, this.$unwrap()); }
+    get $jclass() { return new jclass(this.$handle, this.$unwrap()); }
+    get $jint() { return new jint(this.$handle); }
+    get $jfloat() { return new jfloat(this.$handle); }
+    get $jdouble() { return new jdouble(this.$handle); }
+    get $jbyte() { return new jbyte(this.$handle); }
+    get $jchar() { return new jchar(this.$handle); }
+    get $jlong() { return new jlong(this.$handle); }
+    get $jshort() { return new jshort(this.$handle); }
+    get $jboolean() { return new jboolean(this.$handle); }
+    get $jobjectArray() { return new jobjectArray(this.$handle); }
+    $decode(thread = null) {
+        return JNIEnv.DecodeJObject(thread, this);
+    }
+    $unref() {
+        if (this._deleted) {
+            return true;
+        }
+        this._deleted = true;
+        switch (this.$IndirectRefKind) {
+            case IndirectRefKind.kHandleScopeOrInvalid:
+            case IndirectRefKind.kLocal:
+                JNIEnv.DeleteLocalRef(this);
+                break;
+            case IndirectRefKind.kGlobal:
+                JNIEnv.DeleteGlobalRef(this);
+                break;
+            case IndirectRefKind.kWeakGlobal:
+                JNIEnv.DeleteWeakGlobalRef(this);
+                break;
+        }
+    }
+    $globalRef() {
+        if (this.$IndirectRefKind === IndirectRefKind.kGlobal) {
+            return this;
+        }
+        const glo = JNIEnv.NewGlobalRef(this);
+        const handle = ptr(glo.$handle.toString());
+        Script.bindWeak(glo.$handle, () => {
+            JNIEnv.DeleteGlobalRef(handle);
+        });
+        this.$unref();
+        return glo;
+    }
+    toString() {
+        return `<jobject: ${this.$handle}>[${this.$IndirectRefKind}]`;
+    }
+}
+export class jmethod extends jobject {
+    constructor(handle, opt = {}) {
+        if (!('parent' in opt)) {
+            opt.parent = new jobject(NULL);
+        }
+        super(handle, opt);
+    }
+    toString() {
+        return `<jmethod: ${this.$handle}>[${this.$IndirectRefKind}]`;
+    }
+}
+export class jclass extends jobject {
+    constructor(handle, { isStatic = false } = {}) {
+        super(handle, { isStatic });
+    }
+    toString() {
+        return `<jclass: ${this.$handle}>[${this.$IndirectRefKind}]`;
+    }
+    $methodID(methodId) {
+        return JNIEnv.ToReflectedMethod(this, methodId, this._isStatic).$bind({ parent: this });
+    }
+    $method(name, sig) {
+        return JNIEnv.GetMethodID(this, name, sig);
+    }
+    $toString() {
+        const isExcept = JNIEnv.ExceptionCheck();
+        if (isExcept) {
+            return '';
+        }
+        if (this.$handle.isNull() || JNIEnv.IsSameObject(this, NULL)) {
+            return '';
+        }
+        const result = JNIEnv.CallObjectMethod(this, JNIEnv.javaLangObject().toString);
+        const utf16 = result.$jstring.toUTF16String();
+        const str = utf16.toString();
+        utf16.release();
+        result.$unref();
+        return str;
+    }
+    $getName() {
+        const handle = this._parent ? this._parent : this;
+        const javaLang = JNIEnv.javaLangClass();
+        const result = JNIEnv.CallObjectMethod(handle, javaLang.getName);
+        const utf16 = result.$jstring.toUTF16String();
+        const str = utf16.toString();
+        utf16.release();
+        result.$unref();
+        return str;
+    }
+}
+export class jstring extends jobject {
+    toString() {
+        if (this.$handle.isNull() || this._str !== undefined) {
+            return this._str || '';
+        }
+        const utf16 = this.toUTF16String();
+        const str = utf16.toString();
+        this._str = str;
+        return str;
+    }
+    [Symbol.toPrimitive](hint) {
+        if (hint === "string") {
+            return `<jstring: ${this.$handle}>[${this.$IndirectRefKind}]`;
+        }
+        return "default";
+    }
+    toUTF16String() {
+        return new UTF16JString(this);
+    }
+    toUTF8String() {
+        return new UTF8JString(this);
+    }
+}
+export class jmethodID extends jobject {
+    $getName() {
+        const handle = this._parent;
+        const javaLang = JNIEnv.javaLangReflectMethod();
+        const result = JNIEnv.CallObjectMethod(handle, javaLang.getName);
+        const utf16 = result.$jstring.toUTF16String();
+        const str = utf16.toString();
+        utf16.release();
+        result.$unref();
+        return str;
+    }
+    toString() { return `<jmethodID: ${this.$handle}>[${this.$IndirectRefKind}]`; }
+}
+export class jboolean extends NativePointerObject {
+    toBool() {
+        return this._handle.toInt32() !== 0;
+    }
+    toString() { return `<jboolean: ${this.$handle}>`; }
+}
+export class jbyte extends NativePointerObject {
+    toByte() {
+        return this._handle.toInt32();
+    }
+    toString() { return `<jbyte: ${this.$handle}>`; }
+}
+export class jchar extends NativePointerObject {
+    toChar() {
+        return this._handle.toInt32();
+    }
+    toString() { return `<jchar: ${this.$handle}>`; }
+}
+export class jdouble extends NativePointerObject {
+    toDouble() {
+        return Number(this._handle);
+    }
+    toString() { return `<jdouble: ${this.$handle}>`; }
+}
+export class jfloat extends NativePointerObject {
+    toFloat() {
+        return Number(this._handle);
+    }
+    toString() { return `<jfloat: ${this.$handle}>`; }
+}
+export class jint extends NativePointerObject {
+    toInt() {
+        return Number(this._handle);
+    }
+    toString() { return `<jint: ${this.$handle}>`; }
+}
+export class jlong extends NativePointerObject {
+    toLong() {
+        return Number(this._handle);
+    }
+    toString() { return `<jlong: ${this.$handle}>`; }
+}
+export class jshort extends NativePointerObject {
+    toShort() {
+        return Number(this._handle);
+    }
+    toString() { return `<jshort: ${this.$handle}>`; }
+}
+export class jvoid extends NativePointerObject {
+    toString() { return `<jvoid: ${this.$handle}>`; }
+}
+export class jthrowable extends jobject {
+    toString() { return `<jthrowable: ${this.$handle}>`; }
+}
+export class jvalue {
+    constructor(handle) {
+        this._handle = handle;
+    }
+    $index(offset) {
+        return this._handle.add(offset * Process.pointerSize).readPointer();
+    }
+    jobject(offset) {
+        return new jobject(this.$index(offset));
+    }
+    jstring(offset) {
+        return new jstring(this.$index(offset));
+    }
+    toString() { return `<jvalue: ${this._handle}>`; }
+}
+export class jarray extends NativePointerObject {
+    constructor(handle) {
+        super(handle);
+        this._pointerSize = Process.pointerSize;
+    }
+    $index(index) {
+        return new this._wrapper(this._handle.add(index * this._pointerSize).readPointer());
+    }
+}
+export class jobjectArray extends jarray {
+    constructor() {
+        super(...arguments);
+        this._wrapper = jobject;
+    }
+    $index(index) {
+        return JNIEnv.GetObjectArrayElement(this.$handle, index);
+    }
+}
+export class jbooleanArray extends jarray {
+    constructor() {
+        super(...arguments);
+        this._pointerSize = 1;
+        this._wrapper = jboolean;
+    }
+}
+export class jbyteArray extends jarray {
+    constructor() {
+        super(...arguments);
+        this._pointerSize = 1;
+        this._wrapper = jbyte;
+    }
+}
+export class jcharArray extends jarray {
+    constructor() {
+        super(...arguments);
+        this._pointerSize = 2;
+        this._wrapper = jchar;
+    }
+}
+export class jdoubleArray extends jarray {
+    constructor() {
+        super(...arguments);
+        this._pointerSize = 8;
+        this._wrapper = jdouble;
+    }
+}
+export class jfloatArray extends jarray {
+    constructor() {
+        super(...arguments);
+        this._pointerSize = 4;
+        this._wrapper = jfloat;
+    }
+}
+export class jintArray extends jarray {
+    constructor() {
+        super(...arguments);
+        this._pointerSize = 4;
+        this._wrapper = jint;
+    }
+}
+export class jlongArray extends jarray {
+    constructor() {
+        super(...arguments);
+        this._pointerSize = 8;
+        this._wrapper = jlong;
+    }
+}
+export class jshortArray extends jarray {
+    constructor() {
+        super(...arguments);
+        this._pointerSize = 2;
+        this._wrapper = jshort;
+    }
+}
+export function unwrapJvalueArgs(args, n) {
+    const list = [];
+    for (let i = 0; i < n; i++) {
+        list.push(args.$index(i));
+    }
+    return list;
+}
+// utf16
+class UTF16JString {
+    constructor(jstr) {
+        this._length = null;
+        this._str = null;
+        this._cstrPtr = NULL;
+        this._released = false;
+        this.$getString = JNIEnv.GetStringChars;
+        this.$readString = (p, len) => p.readUtf16String(len);
+        this.$releaser = JNIEnv.ReleaseStringChars;
+        this._jstr = jstr;
+    }
+    get $length() {
+        return this._length !== null ? this._length : (this._length = JNIEnv.GetStringLength(this._jstr).toInt());
+    }
+    toString() {
+        if (this._str !== null) {
+            return this._str;
+        }
+        const cstr = this.$getString(this._jstr);
+        this._cstrPtr = cstr;
+        this._str = this.$readString(cstr, this.$length);
+        return this._str || '';
+    }
+    isNull() {
+        return this._jstr?.$handle.isNull();
+    }
+    release() {
+        if (this._cstrPtr.isNull()) {
+            return false;
+        }
+        return this._released ? true : (this._released = true,
+            this.$releaser(this._jstr, this._cstrPtr),
+            true);
+    }
+}
+// utf8
+class UTF8JString extends UTF16JString {
+    constructor() {
+        super(...arguments);
+        this.$getString = JNIEnv.GetStringUTFChars;
+        this.$readString = (p, len) => p.readUtf8String(len);
+        this.$releaser = JNIEnv.ReleaseStringUTFChars;
+    }
+    get $length() {
+        return this._length !== null ? this._length : (this._length = JNIEnv.GetStringUTFLength(this._jstr).toInt());
+    }
+    toString() {
+        return (this._str !== null ? this._str : (this._str = this._jstr.$handle.readUtf16String(this.$length))) || '';
+    }
+}
+function CLZ(val) {
+    val = val >>> 0;
+    return val === 0 ? 32 : 32 - val.toString(2).length;
+}
+function MinimumBitsToStore(value) {
+    return (value === 0 ? -1 : (32 - 1 - CLZ(value))) + 1;
+}
+function proxyCallMethod(env, offMethod, constructor = null, { retType = 'pointer', argTypes = ['pointer', 'pointer', 'pointer', 'pointer'] } = {}) {
+    const method = function (impl, ...args) {
+        return impl(this.handle, ...args);
+    };
+    return env.$proxy(method, retType, argTypes, offMethod, constructor);
+}
+function proxyCallNonvirtualMethod(env, offMethod, constructor = null, { retType = 'pointer', argTypes = ['pointer', 'pointer', 'pointer', 'pointer', 'pointer'] } = {}) {
+    return proxyCallMethod(env, offMethod, constructor, { retType, argTypes });
+}
+const callMethodVariadicArgTypes = ['pointer', 'pointer', 'pointer', '...', 'pointer'];
+const callNonvirtualMethodVariadictArgTypes = ['pointer', 'pointer', 'pointer', 'pointer', '...', 'pointer'];
+class JniEnvBase {
+    constructor(vm) {
+        this._vm = vm;
+    }
+    get $env() {
+        return this.$vm.getEnv();
+    }
+    get $vm() {
+        return this._vm ? this._vm : Java.vm;
+    }
+    // JNIEnvExt::
+    // [0] *JNINativeInterface
+    // [1] Thread * self_
+    get $thread() {
+        return this.$env.handle.add(JniEnvBase.ptrSize).readPointer();
+    }
+    $proxy(wrapFunc, retType, argTypes, index, constructor = null, optBuilder) {
+        let cache = null;
+        const getCache = () => {
+            const env = this.$env;
+            if (cache === null) {
+                const p = env.handle.readPointer();
+                const handle = p.add(index * JniEnvBase.ptrSize).readPointer();
+                const impl = new NativeFunction(handle, retType, argTypes, nativeFunctionOptions);
+                cache = {
+                    handle: handle,
+                    impl: impl,
+                };
+            }
+            return cache;
+        };
+        const func = (...args) => {
+            const env = this.$env;
+            const cache = getCache();
+            const result = wrapFunc.apply(env, [cache.impl, ...args.map(v => v instanceof NativePointerObject ? v.$handle : v)]);
+            if (constructor === null) {
+                return result;
+            }
+            let opt = {};
+            if (optBuilder) {
+                opt = optBuilder(...args);
+            }
+            return new constructor(result, opt);
+        };
+        Object.defineProperty(func, '$handle', {
+            get: function () {
+                return getCache()?.handle;
+            }
+        });
+        return func;
+    }
+    $symbol(wrapFunc, retType, argTypes, symbol, constructor = null) {
+        let cache = null;
+        const getCache = () => {
+            if (cache === null) {
+                const find = Java.api.find || ((name) => {
+                    const module = Java.api.module;
+                    let address = module.findExportByName(name);
+                    if (address === null) {
+                        address = module.findSymbolByName(name);
+                    }
+                    return address;
+                });
+                const handle = find(symbol);
+                if (!handle) {
+                    throw `symbol[${symbol}] 不存在于 art/dalvik so中`;
+                }
+                const impl = new NativeFunction(handle, retType, argTypes, nativeFunctionOptions);
+                cache = {
+                    handle: handle,
+                    impl: impl,
+                };
+            }
+            return cache;
+        };
+        const func = (...args) => {
+            const env = this.$env;
+            const cache = getCache();
+            const result = wrapFunc.apply(env, [cache.impl, ...args.map(v => v instanceof NativePointerObject ? v.$handle : v)]);
+            if (constructor === null) {
+                return result;
+            }
+            return new constructor(result);
+        };
+        Object.defineProperty(func, '$handle', {
+            get: function () {
+                return getCache()?.handle;
+            }
+        });
+        return func;
+    }
+}
+JniEnvBase.cacheClass = {};
+JniEnvBase.ptrSize = Process.pointerSize;
+JniEnvBase.kKindBits = MinimumBitsToStore(IndirectRefKind.kLastKind);
+JniEnvBase.kKindMask = (1 << JniEnvBase.kKindBits) - 1;
+class JniEnvCaller extends JniEnvBase {
+    constructor(vm) {
+        super(vm);
+        // jobject CallObjectMethod(JNIEnv* env, jobject obj, jmethodID mid, ...)
+        this.CallObjectMethod = proxyCallMethod(this, JNI_VT.CallObjectMethod, jobject, { argTypes: callMethodVariadicArgTypes });
+        // jobject CallObjectMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args)
+        this.CallObjectMethodV = proxyCallMethod(this, JNI_VT.CallObjectMethodV, jobject);
+        // jobject CallObjectMethodA(JNIEnv* env, jobject obj, jmethodID mid, const jvalue* args)
+        this.CallObjectMethodA = proxyCallMethod(this, JNI_VT.CallObjectMethodA, jobject);
+        // jboolean CallBooleanMethod(JNIEnv* env, jobject obj, jmethodID mid, ...)
+        this.CallBooleanMethod = proxyCallMethod(this, JNI_VT.CallBooleanMethod, jboolean, { argTypes: callMethodVariadicArgTypes });
+        // jboolean CallBooleanMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args)
+        this.CallBooleanMethodV = proxyCallMethod(this, JNI_VT.CallBooleanMethodV, jboolean);
+        // jboolean CallBooleanMethodA(JNIEnv* env, jobject obj, jmethodID mid, const jvalue* args)
+        this.CallBooleanMethodA = proxyCallMethod(this, JNI_VT.CallBooleanMethodA, jboolean);
+        // jbyte CallByteMethod(JNIEnv* env, jobject obj, jmethodID mid, ...)
+        this.CallByteMethod = proxyCallMethod(this, JNI_VT.CallBooleanMethod, jbyte, { argTypes: callMethodVariadicArgTypes });
+        // jbyte CallByteMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args)
+        this.CallByteMethodV = proxyCallMethod(this, JNI_VT.CallByteMethodV, jbyte);
+        // jbyte CallByteMethodA(JNIEnv* env, jobject obj, jmethodID mid, const jvalue* args)
+        this.CallByteMethodA = proxyCallMethod(this, JNI_VT.CallByteMethodA, jbyte);
+        // jchar CallCharMethod(JNIEnv* env, jobject obj, jmethodID mid, ...)
+        this.CallCharMethod = proxyCallMethod(this, JNI_VT.CallCharMethod, jchar, { argTypes: callMethodVariadicArgTypes });
+        // jchar CallCharMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args)
+        this.CallCharMethodV = proxyCallMethod(this, JNI_VT.CallCharMethodV, jchar);
+        // jchar CallCharMethodA(JNIEnv* env, jobject obj, jmethodID mid, const jvalue* args)
+        this.CallCharMethodA = proxyCallMethod(this, JNI_VT.CallCharMethodA, jchar);
+        // jshort CallShortMethod(JNIEnv* env, jobject obj, jmethodID mid, ...)
+        this.CallShortMethod = proxyCallMethod(this, JNI_VT.CallShortMethod, jshort, { argTypes: callMethodVariadicArgTypes });
+        // jshort CallShortMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args)
+        this.CallShortMethodV = proxyCallMethod(this, JNI_VT.CallShortMethodV, jshort);
+        // jshort CallShortMethodA(JNIEnv* env, jobject obj, jmethodID mid, const jvalue* args)
+        this.CallShortMethodA = proxyCallMethod(this, JNI_VT.CallShortMethodA, jshort);
+        // jint CallIntMethod(JNIEnv* env, jobject obj, jmethodID mid, ...)
+        this.CallIntMethod = proxyCallMethod(this, JNI_VT.CallIntMethod, jint, { argTypes: callMethodVariadicArgTypes });
+        // jint CallIntMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args)
+        this.CallIntMethodV = proxyCallMethod(this, JNI_VT.CallIntMethodV, jint);
+        // jint CallIntMethodA(JNIEnv* env, jobject obj, jmethodID mid, const jvalue* args)
+        this.CallIntMethodA = proxyCallMethod(this, JNI_VT.CallIntMethodA, jint);
+        // jlong CallLongMethod(JNIEnv* env, jobject obj, jmethodID mid, ...)
+        this.CallLongMethod = proxyCallMethod(this, JNI_VT.CallLongMethod, jint, { argTypes: callMethodVariadicArgTypes });
+        // jlong CallLongMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args)
+        this.CallLongMethodV = proxyCallMethod(this, JNI_VT.CallLongMethodV, jint);
+        // jlong CallLongMethodA(JNIEnv* env, jobject obj, jmethodID mid, const jvalue* args)
+        this.CallLongMethodA = proxyCallMethod(this, JNI_VT.CallLongMethodA, jint);
+        // jfloat CallFloatMethod(JNIEnv* env, jobject obj, jmethodID mid, ...)
+        this.CallFloatMethod = proxyCallMethod(this, JNI_VT.CallFloatMethod, jfloat, { argTypes: callMethodVariadicArgTypes });
+        // jfloat CallFloatMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args)
+        this.CallFloatMethodV = proxyCallMethod(this, JNI_VT.CallFloatMethodV, jfloat);
+        // jfloat CallFloatMethodA(JNIEnv* env, jobject obj, jmethodID mid, const jvalue* args)
+        this.CallFloatMethodA = proxyCallMethod(this, JNI_VT.CallFloatMethodA, jfloat);
+        // jdouble CallDoubleMethod(JNIEnv* env, jobject obj, jmethodID mid, ...)
+        this.CallDoubleMethod = proxyCallMethod(this, JNI_VT.CallDoubleMethod, jdouble, { argTypes: callMethodVariadicArgTypes });
+        // jdouble CallDoubleMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args)
+        this.CallDoubleMethodV = proxyCallMethod(this, JNI_VT.CallDoubleMethodV, jdouble);
+        // jdouble CallDoubleMethodA(JNIEnv* env, jobject obj, jmethodID mid, const jvalue* args)
+        this.CallDoubleMethodA = proxyCallMethod(this, JNI_VT.CallDoubleMethodA, jdouble);
+        // void CallVoidMethod(JNIEnv* env, jobject obj, jmethodID mid, ...)
+        this.CallVoidMethod = proxyCallMethod(this, JNI_VT.CallVoidMethod, jvoid, { argTypes: callMethodVariadicArgTypes });
+        // void CallVoidMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args)
+        this.CallVoidMethodV = proxyCallMethod(this, JNI_VT.CallVoidMethodV, jvoid);
+        // void CallVoidMethodA(JNIEnv* env, jobject obj, jmethodID mid, const jvalue* args)
+        this.CallVoidMethodA = proxyCallMethod(this, JNI_VT.CallVoidMethodA, jvoid);
+        // jobject CallNonvirtualObjectMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...)
+        this.CallNonvirtualObjectMethod = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualObjectMethod, jobject, { argTypes: callNonvirtualMethodVariadictArgTypes });
+        // jobject CallNonvirtualObjectMethodV(JNIEnv* env, jobject obj, jclass, jmethodID mid, va_list args)
+        this.CallNonvirtualObjectMethodV = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualObjectMethodV, jobject);
+        // jobject CallNonvirtualObjectMethodA(JNIEnv* env, jobject obj, jclass, jmethodID mid, const jvalue* args)
+        this.CallNonvirtualObjectMethodA = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualObjectMethodA, jobject);
+        // jboolean CallNonvirtualBooleanMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...)
+        this.CallNonvirtualBooleanMethod = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualBooleanMethod, jboolean, { argTypes: callNonvirtualMethodVariadictArgTypes });
+        // jboolean CallNonvirtualBooleanMethodV(JNIEnv* env, jobject obj, jclass, jmethodID mid, va_list args)
+        this.CallNonvirtualBooleanMethodV = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualBooleanMethodV, jboolean);
+        // jboolean CallNonvirtualBooleanMethodA(JNIEnv* env, jobject obj, jclass, jmethodID mid, const jvalue* args)
+        this.CallNonvirtualBooleanMethodA = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualBooleanMethodA, jboolean);
+        // jbyte CallNonvirtualByteMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...)
+        this.CallNonvirtualByteMethod = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualByteMethod, jbyte, { argTypes: callNonvirtualMethodVariadictArgTypes });
+        // jbyte CallNonvirtualByteMethodV(JNIEnv* env, jobject obj, jclass, jmethodID mid, va_list args)
+        this.CallNonvirtualByteMethodV = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualByteMethodV, jbyte);
+        // jbyte CallNonvirtualByteMethodA(JNIEnv* env, jobject obj, jclass, jmethodID mid, const jvalue* args)
+        this.CallNonvirtualByteMethodA = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualByteMethodA, jbyte);
+        // jchar CallNonvirtualCharMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...)
+        this.CallNonvirtualCharMethod = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualCharMethod, jchar, { argTypes: callNonvirtualMethodVariadictArgTypes });
+        // jchar CallNonvirtualCharMethodV(JNIEnv* env, jobject obj, jclass, jmethodID mid, va_list args)
+        this.CallNonvirtualCharMethodV = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualCharMethodV, jchar);
+        // jchar CallNonvirtualCharMethodA(JNIEnv* env, jobject obj, jclass, jmethodID mid, const jvalue* args)
+        this.CallNonvirtualCharMethodA = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualCharMethodA, jchar);
+        // jshort CallNonvirtualShortMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...)
+        this.CallNonvirtualShortMethod = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualShortMethod, jshort, { argTypes: callNonvirtualMethodVariadictArgTypes });
+        // jshort CallNonvirtualShortMethodV(JNIEnv* env, jobject obj, jclass, jmethodID mid, va_list args)
+        this.CallNonvirtualShortMethodV = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualShortMethodV, jshort);
+        // jshort CallNonvirtualShortMethodA(JNIEnv* env, jobject obj, jclass, jmethodID mid, const jvalue* args)
+        this.CallNonvirtualShortMethodA = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualShortMethodA, jshort);
+        // jint CallNonvirtualIntMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...)
+        this.CallNonvirtualIntMethod = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualIntMethod, jint, { argTypes: callNonvirtualMethodVariadictArgTypes });
+        // jint CallNonvirtualIntMethodV(JNIEnv* env, jobject obj, jclass, jmethodID mid, va_list args)
+        this.CallNonvirtualIntMethodV = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualIntMethodV, jint);
+        // jint CallNonvirtualIntMethodA(JNIEnv* env, jobject obj, jclass, jmethodID mid, const jvalue* args)
+        this.CallNonvirtualIntMethodA = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualIntMethodA, jint);
+        // jlong CallNonvirtualLongMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...)
+        this.CallNonvirtualLongMethod = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualLongMethod, jlong, { argTypes: callNonvirtualMethodVariadictArgTypes });
+        // jlong CallNonvirtualLongMethodV(JNIEnv* env, jobject obj, jclass, jmethodID mid, va_list args)
+        this.CallNonvirtualLongMethodV = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualLongMethodV, jlong);
+        // jlong CallNonvirtualLongMethodA(JNIEnv* env, jobject obj, jclass, jmethodID mid, const jvalue* args)
+        this.CallNonvirtualLongMethodA = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualLongMethodA, jlong);
+        // jfloat CallNonvirtualFloatMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...)
+        this.CallNonvirtualFloatMethod = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualFloatMethod, jfloat, { argTypes: callNonvirtualMethodVariadictArgTypes });
+        // jfloat CallNonvirtualFloatMethodV(JNIEnv* env, jobject obj, jclass, jmethodID mid, va_list args)
+        this.CallNonvirtualFloatMethodV = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualFloatMethodV, jfloat);
+        // jfloat CallNonvirtualFloatMethodA(JNIEnv* env, jobject obj, jclass, jmethodID mid, const jvalue* args)
+        this.CallNonvirtualFloatMethodA = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualFloatMethodA, jfloat);
+        // jdouble CallNonvirtualDoubleMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...)
+        this.CallNonvirtualDoubleMethod = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualDoubleMethod, jdouble, { argTypes: callNonvirtualMethodVariadictArgTypes });
+        // jdouble CallNonvirtualDoubleMethodV(JNIEnv* env, jobject obj, jclass, jmethodID mid, va_list args)
+        this.CallNonvirtualDoubleMethodV = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualDoubleMethodV, jdouble);
+        // jdouble CallNonvirtualDoubleMethodA(JNIEnv* env, jobject obj, jclass, jmethodID mid, const jvalue* args)
+        this.CallNonvirtualDoubleMethodA = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualDoubleMethodA, jdouble);
+        // jvoid CallNonvirtualVoidMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...)
+        this.CallNonvirtualVoidMethod = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualVoidMethod, jvoid, { argTypes: callNonvirtualMethodVariadictArgTypes });
+        // jvoid CallNonvirtualVoidMethodV(JNIEnv* env, jobject obj, jclass, jmethodID mid, va_list args)
+        this.CallNonvirtualVoidMethodV = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualVoidMethodV, jvoid);
+        // jvoid CallNonvirtualVoidMethodA(JNIEnv* env, jobject obj, jclass, jmethodID mid, const jvalue* args)
+        this.CallNonvirtualVoidMethodA = proxyCallNonvirtualMethod(this, JNI_VT.CallNonvirtualVoidMethodA, jvoid);
+        // jobject CallStaticObjectMethod(JNIEnv* env, jclass, jmethodID mid, ...)
+        this.CallStaticObjectMethod = proxyCallMethod(this, JNI_VT.CallStaticObjectMethod, jobject, { argTypes: callMethodVariadicArgTypes });
+        // jobject CallStaticObjectMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args)
+        this.CallStaticObjectMethodV = proxyCallMethod(this, JNI_VT.CallStaticObjectMethodV, jobject);
+        // jobject CallStaticObjectMethodA(JNIEnv* env, jclass, jmethodID mid, const jvalue* args)
+        this.CallStaticObjectMethodA = proxyCallMethod(this, JNI_VT.CallStaticObjectMethodA, jobject);
+        // jboolean CallStaticBooleanMethod(JNIEnv* env, jclass, jmethodID mid, ...)
+        this.CallStaticBooleanMethod = proxyCallMethod(this, JNI_VT.CallStaticBooleanMethod, jboolean, { argTypes: callMethodVariadicArgTypes });
+        // jboolean CallStaticBooleanMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args)
+        this.CallStaticBooleanMethodV = proxyCallMethod(this, JNI_VT.CallStaticBooleanMethodV, jboolean);
+        // jboolean CallStaticBooleanMethodA(JNIEnv* env, jclass, jmethodID mid, const jvalue* args)
+        this.CallStaticBooleanMethodA = proxyCallMethod(this, JNI_VT.CallStaticBooleanMethodA, jboolean);
+        // jbyte CallStaticByteMethod(JNIEnv* env, jclass, jmethodID mid, ...)
+        this.CallStaticByteMethod = proxyCallMethod(this, JNI_VT.CallStaticByteMethod, jbyte, { argTypes: callMethodVariadicArgTypes });
+        // jbyte CallStaticByteMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args)
+        this.CallStaticByteMethodV = proxyCallMethod(this, JNI_VT.CallStaticByteMethodV, jbyte);
+        // jbyte CallStaticByteMethodA(JNIEnv* env, jclass, jmethodID mid, const jvalue* args)
+        this.CallStaticByteMethodA = proxyCallMethod(this, JNI_VT.CallStaticByteMethodA, jbyte);
+        // jchar CallStaticCharMethod(JNIEnv* env, jclass, jmethodID mid, ...)
+        this.CallStaticCharMethod = proxyCallMethod(this, JNI_VT.CallStaticCharMethod, jchar, { argTypes: callMethodVariadicArgTypes });
+        // jchar CallStaticCharMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args)
+        this.CallStaticCharMethodV = proxyCallMethod(this, JNI_VT.CallStaticCharMethodV, jchar);
+        // jchar CallStaticCharMethodA(JNIEnv* env, jclass, jmethodID mid, const jvalue* args)
+        this.CallStaticCharMethodA = proxyCallMethod(this, JNI_VT.CallStaticCharMethodA, jchar);
+        // jshort CallStaticShortMethod(JNIEnv* env, jclass, jmethodID mid, ...)
+        this.CallStaticShortMethod = proxyCallMethod(this, JNI_VT.CallStaticShortMethod, jshort, { argTypes: callMethodVariadicArgTypes });
+        // jshort CallStaticShortMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args)
+        this.CallStaticShortMethodV = proxyCallMethod(this, JNI_VT.CallStaticShortMethodV, jshort);
+        // jshort CallStaticShortMethodA(JNIEnv* env, jclass, jmethodID mid, const jvalue* args)
+        this.CallStaticShortMethodA = proxyCallMethod(this, JNI_VT.CallStaticShortMethodA, jshort);
+        // jint CallStaticIntMethod(JNIEnv* env, jclass, jmethodID mid, ...)
+        this.CallStaticIntMethod = proxyCallMethod(this, JNI_VT.CallStaticIntMethod, jint, { argTypes: callMethodVariadicArgTypes });
+        // jint CallStaticIntMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args)
+        this.CallStaticIntMethodV = proxyCallMethod(this, JNI_VT.CallStaticIntMethodV, jint);
+        // jint CallStaticIntMethodA(JNIEnv* env, jclass, jmethodID mid, const jvalue* args)
+        this.CallStaticIntMethodA = proxyCallMethod(this, JNI_VT.CallStaticIntMethodA, jint);
+        // jlong CallStaticLongMethod(JNIEnv* env, jclass, jmethodID mid, ...)
+        this.CallStaticLongMethod = proxyCallMethod(this, JNI_VT.CallStaticLongMethod, jint, { argTypes: callMethodVariadicArgTypes });
+        // jlong CallStaticLongMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args)
+        this.CallStaticLongMethodV = proxyCallMethod(this, JNI_VT.CallStaticLongMethodV, jint);
+        // jlong CallStaticLongMethodA(JNIEnv* env, jclass, jmethodID mid, const jvalue* args)
+        this.CallStaticLongMethodA = proxyCallMethod(this, JNI_VT.CallStaticLongMethodA, jint);
+        // jfloat CallStaticFloatMethod(JNIEnv* env, jclass, jmethodID mid, ...)
+        this.CallStaticFloatMethod = proxyCallMethod(this, JNI_VT.CallStaticFloatMethod, jfloat, { argTypes: callMethodVariadicArgTypes });
+        // jfloat CallStaticFloatMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args)
+        this.CallStaticFloatMethodV = proxyCallMethod(this, JNI_VT.CallStaticFloatMethodV, jfloat);
+        // jfloat CallStaticFloatMethodA(JNIEnv* env, jclass, jmethodID mid, const jvalue* args)
+        this.CallStaticFloatMethodA = proxyCallMethod(this, JNI_VT.CallStaticFloatMethodA, jfloat);
+        // jdouble CallStaticDoubleMethod(JNIEnv* env, jclass, jmethodID mid, ...)
+        this.CallStaticDoubleMethod = proxyCallMethod(this, JNI_VT.CallStaticDoubleMethod, jdouble, { argTypes: callMethodVariadicArgTypes });
+        // jdouble CallStaticDoubleMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args)
+        this.CallStaticDoubleMethodV = proxyCallMethod(this, JNI_VT.CallStaticDoubleMethodV, jdouble);
+        // jdouble CallStaticDoubleMethodA(JNIEnv* env, jclass, jmethodID mid, const jvalue* args)
+        this.CallStaticDoubleMethodA = proxyCallMethod(this, JNI_VT.CallStaticDoubleMethodA, jdouble);
+        // void CallStaticVoidMethod(JNIEnv* env, jclass, jmethodID mid, ...)
+        this.CallStaticVoidMethod = proxyCallMethod(this, JNI_VT.CallStaticVoidMethod, jvoid, { argTypes: callMethodVariadicArgTypes });
+        // void CallStaticVoidMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args)
+        this.CallStaticVoidMethodV = proxyCallMethod(this, JNI_VT.CallStaticVoidMethodV, jvoid);
+        // void CallStaticVoidMethodA(JNIEnv* env, jclass, jmethodID mid, const jvalue* args)
+        this.CallStaticVoidMethodA = proxyCallMethod(this, JNI_VT.CallStaticVoidMethodA, jvoid);
+        // jfieldID GetFieldID(JNIEnv* env, jclass java_class, const char* name, const char* sig)
+        this.GetFieldID = this.$proxy(function (impl, java_class, name, sig) {
+            return impl(this.handle, java_class, Memory.allocUtf8String(name), Memory.allocUtf8String(sig));
+        }, 'pointer', ['pointer', 'pointer', 'pointer', 'pointer'], JNI_VT.GetFieldID, jobject);
+        // jfieldID GetStaticFieldID(JNIEnv* env, jclass java_class, const char* name, const char* sig)
+        this.GetStaticFieldID = this.$proxy(function (impl, java_class, name, sig) {
+            return impl(this.handle, java_class, Memory.allocUtf8String(name), Memory.allocUtf8String(sig));
+        }, 'pointer', ['pointer', 'pointer', 'pointer', 'pointer'], JNI_VT.GetStaticFieldID, jobject);
+        // jobject GetObjectField(JNIEnv* env, jobject obj, jfieldID fid)
+        this.GetObjectField = this.$proxy(function (impl, obj, fid) {
+            return impl(this.handle, obj, fid);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetObjectField, jobject);
+        // jboolean GetBooleanField(JNIEnv* env, jobject obj, jfieldID fid)
+        this.GetBooleanField = this.$proxy(function (impl, obj, fid) {
+            return impl(this.handle, obj, fid);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetBooleanField, jboolean);
+        // jbyte GetByteField(JNIEnv* env, jobject obj, jfieldID fid)
+        this.GetByteField = this.$proxy(function (impl, obj, fid) {
+            return impl(this.handle, obj, fid);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetByteField, jbyte);
+        // jchar GetCharField(JNIEnv* env, jobject obj, jfieldID fid)
+        this.GetCharField = this.$proxy(function (impl, obj, fid) {
+            return impl(this.handle, obj, fid);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetCharField, jchar);
+        // jshort GetShortField(JNIEnv* env, jobject obj, jfieldID fid)
+        this.GetShortField = this.$proxy(function (impl, obj, fid) {
+            return impl(this.handle, obj, fid);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetShortField, jshort);
+        // jint GetIntField(JNIEnv* env, jobject obj, jfieldID fid)
+        this.GetIntField = this.$proxy(function (impl, obj, fid) {
+            return impl(this.handle, obj, fid);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetIntField, jint);
+        // jlong GetLongField(JNIEnv* env, jobject obj, jfieldID fid)
+        this.GetLongField = this.$proxy(function (impl, obj, fid) {
+            return impl(this.handle, obj, fid);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetLongField, jlong);
+        // jfloat GetFloatField(JNIEnv* env, jobject obj, jfieldID fid)
+        this.GetFloatField = this.$proxy(function (impl, obj, fid) {
+            return impl(this.handle, obj, fid);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetFloatField, jfloat);
+        // jdouble GetDoubleField(JNIEnv* env, jobject obj, jfieldID fid)
+        this.GetDoubleField = this.$proxy(function (impl, obj, fid) {
+            return impl(this.handle, obj, fid);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetDoubleField, jdouble);
+        // jobject GetStaticObjectField(JNIEnv* env, jclass, jfieldID fid)
+        this.GetStaticObjectField = this.$proxy(function (impl, cls, fid) {
+            return impl(this.handle, cls, fid);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetStaticObjectField, jobject);
+        // jboolean GetStaticBooleanField(JNIEnv* env, jclass, jfieldID fid)
+        this.GetStaticBooleanField = this.$proxy(function (impl, obj, fid) {
+            return impl(this.handle, obj, fid);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetStaticBooleanField, jboolean);
+        // jbyte GetStaticByteField(JNIEnv* env, jclass, jfieldID fid)
+        this.GetStaticByteField = this.$proxy(function (impl, obj, fid) {
+            return impl(this.handle, obj, fid);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetStaticByteField, jbyte);
+        // jchar GetStaticCharField(JNIEnv* env, jclass, jfieldID fid)
+        this.GetStaticCharField = this.$proxy(function (impl, obj, fid) {
+            return impl(this.handle, obj, fid);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetStaticCharField, jchar);
+        // jshort GetStaticShortField(JNIEnv* env, jclass, jfieldID fid)
+        this.GetStaticShortField = this.$proxy(function (impl, obj, fid) {
+            return impl(this.handle, obj, fid);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetStaticShortField, jshort);
+        // jint GetStaticIntField(JNIEnv* env, jclass, jfieldID fid)
+        this.GetStaticIntField = this.$proxy(function (impl, obj, fid) {
+            return impl(this.handle, obj, fid);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetStaticIntField, jint);
+        // jlong GetStaticLongField(JNIEnv* env, jclass, jfieldID fid)
+        this.GetStaticLongField = this.$proxy(function (impl, obj, fid) {
+            return impl(this.handle, obj, fid);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetStaticLongField, jlong);
+        // jfloat GetStaticFloatField(JNIEnv* env, jclass, jfieldID fid)
+        this.GetStaticFloatField = this.$proxy(function (impl, obj, fid) {
+            return impl(this.handle, obj, fid);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetStaticFloatField, jfloat);
+        // jdouble GetStaticDoubleField(JNIEnv* env, jclass, jfieldID fid)
+        this.GetStaticDoubleField = this.$proxy(function (impl, obj, fid) {
+            return impl(this.handle, obj, fid);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetStaticDoubleField, jdouble);
+        // static jclass FindClass(JNIEnv* env, const char* name)
+        this.FindClass = this.$proxy(function (impl, name) {
+            const result = impl(this.handle, Memory.allocUtf8String(name));
+            this.throwIfExceptionPending();
+            return result;
+        }, 'pointer', ['pointer', 'pointer'], JNI_VT.FindClass, jclass);
+        // jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic)
+        this.ToReflectedMethod = this.$proxy(function (impl, klass, methodId, isStatic) {
+            return impl(this.handle, klass, methodId, isStatic ? 1 : 0);
+        }, 'pointer', ['pointer', 'pointer', 'pointer', 'uint8'], JNI_VT.ToReflectedMethod, jobject, ($0, $1, isStatic) => ({ isStatic }));
+        // jclass GetSuperclass(JNIEnv* env, jclass java_class)
+        this.GetSuperclass = this.$proxy(function (impl, java_class) {
+            return impl(this.handle, java_class);
+        }, 'pointer', ['pointer', 'pointer'], JNI_VT.GetSuperclass, jclass);
+        // jobject NewObject(JNIEnv* env, jclass java_class, jmethodID mid, ...)
+        this.NewObject = this.$proxy(function (impl, java_class, mid, ...args) {
+            return impl(this.handle, java_class, mid, ...args);
+        }, 'pointer', ['pointer', 'pointer', 'pointer', '...', 'pointer'], JNI_VT.NewObject, jobject);
+        // jobject NewObjectV(JNIEnv* env, jclass java_class, jmethodID mid, va_list args)
+        this.NewObjectV = this.$proxy(function (impl, java_class, mid, args) {
+            return impl(this.handle, java_class, mid, args);
+        }, 'pointer', ['pointer', 'pointer', 'pointer', 'pointer'], JNI_VT.NewObjectV, jobject);
+        // jobject NewObjectA(JNIEnv* env, jclass java_class, jmethodID mid, const jvalue* args)
+        this.NewObjectA = this.$proxy(function (impl, java_class, mid, args) {
+            return impl(this.handle, java_class, mid, args);
+        }, 'pointer', ['pointer', 'pointer', 'pointer', 'pointer'], JNI_VT.NewObjectA, jobject);
+        // jclass GetObjectClass(jobject obj)
+        this.GetObjectClass = this.$proxy(function (impl, obj) {
+            return impl(this.handle, obj);
+        }, 'pointer', ['pointer', 'pointer'], JNI_VT.GetObjectClass, jclass);
+        // jmethodID GetMethodID(jclass clazz, const char *name, const char *sig)
+        this.GetMethodID = this.$proxy(function (impl, klass, name, sig) {
+            return impl(this.handle, klass, Memory.allocUtf8String(name), Memory.allocUtf8String(sig));
+        }, 'pointer', ['pointer', 'pointer', 'pointer', 'pointer'], JNI_VT.GetMethodID, jmethodID);
+        // static jmethodID GetStaticMethodID(JNIEnv* env, jclass java_class, const char* name, const char* sig)
+        this.GetStaticMethodID = this.$proxy(function (impl, java_class, name, sig) {
+            return impl(this.handle, java_class, Memory.allocUtf8String(name), Memory.allocUtf8String(sig));
+        }, 'pointer', ['pointer', 'pointer', 'pointer', 'pointer'], JNI_VT.GetStaticMethodID, jmethodID);
+        // static const jchar* GetStringChars(JNIEnv* env, jstring java_string, jboolean* is_copy)
+        this.GetStringChars = this.$proxy(function (impl, str) {
+            return impl(this.handle, str, NULL);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetStringChars, NativePointer);
+        // jsize GetStringLength(JNIEnv* env, jstring java_string)
+        this.GetStringLength = this.$proxy(function (impl, java_string) {
+            return impl(this.handle, java_string);
+        }, 'pointer', ['pointer', 'pointer'], JNI_VT.GetStringLength, jint);
+        // void ReleaseStringChars(JNIEnv* env, jstring java_string, const jchar* chars)
+        this.ReleaseStringChars = this.$proxy(function (impl, java_string, chars) {
+            return impl(this.handle, java_string, chars);
+        }, 'void', ['pointer', 'pointer', 'pointer'], JNI_VT.ReleaseStringChars);
+        // const char* GetStringUTFChars(jstring str, jboolean *isCopy)
+        this.GetStringUTFChars = this.$proxy(function (impl, str) {
+            return impl(this.handle, str, NULL);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetStringUTFChars, NativePointer);
+        // jsize GetStringUTFLength(JNIEnv* env, jstring java_string)
+        this.GetStringUTFLength = this.$proxy(function (impl, java_string) {
+            return impl(this.handle, java_string);
+        }, 'pointer', ['pointer', 'pointer'], JNI_VT.GetStringUTFLength, jint);
+        // void ReleaseStringUTFChars(JNIEnv*, jstring, const char* chars)
+        this.ReleaseStringUTFChars = this.$proxy(function (impl, chars) {
+            return impl(this.handle, chars);
+        }, 'void', ['pointer', 'pointer'], JNI_VT.ReleaseStringUTFChars);
+        // jsize GetArrayLength(JNIEnv* env, jarray java_array)
+        this.GetArrayLength = this.$proxy(function (impl, java_array) {
+            return impl(this.handle, java_array);
+        }, 'int', ['pointer', 'pointer'], JNI_VT.GetArrayLength, jint);
+        // jobject GetObjectArrayElement(JNIEnv* env, jobjectArray java_array, jsize index)
+        this.GetObjectArrayElement = this.$proxy(function (impl, java_array, index) {
+            return impl(this.handle, java_array, index);
+        }, 'pointer', ['pointer', 'pointer', 'int'], JNI_VT.GetObjectArrayElement, jobject);
+        // jboolean* GetBooleanArrayElements(JNIEnv* env, jbooleanArray array, jboolean* is_copy)
+        this.GetBooleanArrayElements = this.$proxy(function (impl, java_array) {
+            return impl(this.handle, java_array, NULL);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetBooleanArrayElements, jbooleanArray);
+        // jbyte* GetByteArrayElements(JNIEnv* env, jbyteArray array, jboolean* is_copy)
+        this.GetByteArrayElements = this.$proxy(function (impl, java_array) {
+            return impl(this.handle, java_array, NULL);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetByteArrayElements, jbyteArray);
+        // jchar* GetCharArrayElements(JNIEnv* env, jcharArray array, jboolean* is_copy)
+        this.GetCharArrayElements = this.$proxy(function (impl, java_array) {
+            return impl(this.handle, java_array, NULL);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetCharArrayElements, jcharArray);
+        // jdouble* GetDoubleArrayElements(JNIEnv* env, jdoubleArray array, jboolean* is_copy)
+        this.GetDoubleArrayElements = this.$proxy(function (impl, java_array) {
+            return impl(this.handle, java_array, NULL);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetDoubleArrayElements, jdoubleArray);
+        // jfloat* GetFloatArrayElements(JNIEnv* env, jfloatArray array, jboolean* is_copy)
+        this.GetFloatArrayElements = this.$proxy(function (impl, java_array) {
+            return impl(this.handle, java_array, NULL);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetFloatArrayElements, jfloatArray);
+        // jint* GetIntArrayElements(JNIEnv* env, jintArray array, jboolean* is_copy)
+        this.GetIntArrayElements = this.$proxy(function (impl, java_array) {
+            return impl(this.handle, java_array, NULL);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetIntArrayElements, jintArray);
+        // jlong* GetLongArrayElements(JNIEnv* env, jlongArray array, jboolean* is_copy)
+        this.GetLongArrayElements = this.$proxy(function (impl, java_array) {
+            return impl(this.handle, java_array, NULL);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetLongArrayElements, jlongArray);
+        // jshort* GetShortArrayElements(JNIEnv* env, jshortArray array, jboolean* is_copy)
+        this.GetShortArrayElements = this.$proxy(function (impl, java_array) {
+            return impl(this.handle, java_array, NULL);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetShortArrayElements, jshortArray);
+        // void ReleaseBooleanArrayElements(JNIEnv* env, jbooleanArray array, jboolean* elements, jint mode)
+        this.ReleaseBooleanArrayElements = this.$proxy(function (impl, array, elements, mode) {
+            return impl(this.handle, array, elements, mode);
+        }, 'void', ['pointer', 'pointer', 'pointer', 'int'], JNI_VT.ReleaseBooleanArrayElements);
+        // void ReleaseByteArrayElements(JNIEnv* env, jbyteArray array, jbyte* elements, jint mode)
+        this.ReleaseByteArrayElements = this.$proxy(function (impl, array, elements, mode) {
+            return impl(this.handle, array, elements, mode);
+        }, 'void', ['pointer', 'pointer', 'pointer', 'int'], JNI_VT.ReleaseByteArrayElements);
+        // void ReleaseCharArrayElements(JNIEnv* env, jcharArray array, jchar* elements, jint mode)
+        this.ReleaseCharArrayElements = this.$proxy(function (impl, array, elements, mode) {
+            return impl(this.handle, array, elements, mode);
+        }, 'void', ['pointer', 'pointer', 'pointer', 'int'], JNI_VT.ReleaseCharArrayElements);
+        // void ReleaseFloatArrayElements(JNIEnv* env, jfloatArray array, jfloat* elements, jint mode)
+        this.ReleaseFloatArrayElements = this.$proxy(function (impl, array, elements, mode) {
+            return impl(this.handle, array, elements, mode);
+        }, 'void', ['pointer', 'pointer', 'pointer', 'int'], JNI_VT.ReleaseFloatArrayElements);
+        // void ReleaseDoubleArrayElements(JNIEnv* env, jdoubleArray array, jdouble* elements, jint mode)
+        this.ReleaseDoubleArrayElements = this.$proxy(function (impl, array, elements, mode) {
+            return impl(this.handle, array, elements, mode);
+        }, 'void', ['pointer', 'pointer', 'pointer', 'int'], JNI_VT.ReleaseDoubleArrayElements);
+        // void ReleaseIntArrayElements(JNIEnv* env, jintArray array, jint* elements, jint mode)
+        this.ReleaseIntArrayElements = this.$proxy(function (impl, array, elements, mode) {
+            return impl(this.handle, array, elements, mode);
+        }, 'void', ['pointer', 'pointer', 'pointer', 'int'], JNI_VT.ReleaseIntArrayElements);
+        // void ReleaseLongArrayElements(JNIEnv* env, jlongArray array, jlong* elements, jint mode)
+        this.ReleaseLongArrayElements = this.$proxy(function (impl, array, elements, mode) {
+            return impl(this.handle, array, elements, mode);
+        }, 'void', ['pointer', 'pointer', 'pointer', 'int'], JNI_VT.ReleaseLongArrayElements);
+        // void ReleaseShortArrayElements(JNIEnv* env, jshortArray array, jshort* elements, jint mode)
+        this.ReleaseShortArrayElements = this.$proxy(function (impl, array, elements, mode) {
+            return impl(this.handle, array, elements, mode);
+        }, 'void', ['pointer', 'pointer', 'pointer', 'int'], JNI_VT.ReleaseShortArrayElements);
+        // static const jchar* GetStringCritical(JNIEnv* env, jstring java_string, jboolean* is_copy)
+        this.GetStringCritical = this.$proxy(function (impl, str) {
+            return impl(this.handle, str, NULL).readCString();
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.GetStringCritical);
+        // jint Throw(JNIEnv* env, jthrowable java_exception)
+        this.Throw = this.$proxy(function (impl, java_exception) {
+            return impl(this.handle, java_exception);
+        }, 'pointer', ['pointer', 'pointer'], JNI_VT.Throw, jint);
+        // jint ThrowNew(JNIEnv* env, jclass c, const char* msg)
+        this.ThrowNew = this.$proxy(function (impl, c, msg) {
+            const cMsg = Memory.allocUtf8String(msg);
+            help.$error(`[ThrowNew]c[${c}], msg[${msg}]`);
+            return impl(this.handle, c, cMsg);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.ThrowNew, jint);
+        // jthrowable ExceptionOccurred(JNIEnv* env)
+        this.ExceptionOccurred = this.$proxy(function (impl) {
+            return impl(this.handle);
+        }, 'pointer', ['pointer'], JNI_VT.ExceptionOccurred, jthrowable);
+        // void ExceptionDescribe(JNIEnv* env)
+        this.ExceptionDescribe = this.$proxy(function (impl) {
+            return impl(this.handle);
+        }, 'void', ['pointer'], JNI_VT.ExceptionDescribe);
+        // void ExceptionClear(JNIEnv* env)
+        this.ExceptionClear = this.$proxy(function (impl) {
+            return impl(this.handle);
+        }, 'void', ['pointer'], JNI_VT.ExceptionClear);
+        // jboolean ExceptionCheck(JNIEnv* env)
+        this.ExceptionCheck = this.$proxy(function (impl) {
+            return impl(this.handle).toUInt32() != 0;
+        }, 'pointer', ['pointer'], JNI_VT.ExceptionCheck);
+        // void FatalError(JNIEnv*, const char* msg)
+        this.FatalError = this.$proxy(function (impl, msg) {
+            return impl(this.handle, Memory.allocUtf8String(msg));
+        }, 'pointer', ['pointer'], JNI_VT.FatalError);
+        // jint PushLocalFrame(JNIEnv* env, jint capacity)
+        this.PushLocalFrame = this.$proxy(function (impl, capacity) {
+            return impl(this.handle, capacity);
+        }, 'int', ['pointer', 'int'], JNI_VT.PushLocalFrame, jint);
+        // jobject PopLocalFrame(JNIEnv* env, jobject java_survivor)
+        this.PopLocalFrame = this.$proxy(function (impl, java_survivor) {
+            return impl(this.handle, java_survivor);
+        }, 'pointer', ['pointer', 'pointer'], JNI_VT.PopLocalFrame, jobject);
+        // static jobject NewGlobalRef(JNIEnv* env, jobject obj)
+        this.NewGlobalRef = this.$proxy(function (impl, obj) {
+            return impl(this.handle, obj);
+        }, 'pointer', ['pointer', 'pointer'], JNI_VT.NewGlobalRef, jobject);
+        // static jboolean IsSameObject(JNIEnv* env, jobject obj1, jobject obj2)
+        this.IsSameObject = this.$proxy(function (impl, obj1, obj2) {
+            return impl(this.handle, obj1, obj2) != 0;
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], JNI_VT.IsSameObject);
+        // jobject JNIEnvExt::NewLocalRef(mirror::Object* obj)
+        this.NewLocalRef = this.$proxy(function (impl, obj) {
+            return impl(this.handle, obj);
+        }, 'pointer', ['pointer', 'pointer'], JNI_VT.NewLocalRef, jobject);
+        // static void DeleteGlobalRef(JNIEnv* env, jobject obj)
+        this.DeleteGlobalRef = this.$proxy(function (impl, obj) {
+            impl(this.handle, obj);
+        }, 'pointer', ['pointer', 'pointer'], JNI_VT.DeleteGlobalRef);
+        // void DeleteLocalRef(JNIEnv* env, jobject obj)
+        this.DeleteLocalRef = this.$proxy(function (impl, obj) {
+            impl(this.handle, obj);
+        }, 'pointer', ['pointer', 'pointer'], JNI_VT.DeleteLocalRef);
+        // static void DeleteWeakGlobalRef(JNIEnv* env, jweak obj) 
+        this.DeleteWeakGlobalRef = this.$proxy(function (impl, obj) {
+            impl(this.handle, obj);
+        }, 'pointer', ['pointer', 'pointer'], JNI_VT.DeleteWeakGlobalRef);
+        // jint RegisterNatives(JNIEnv* env, jclass java_class, const JNINativeMethod* methods, jint method_count)
+        this.RegisterNatives = this.$proxy(function (impl, java_class, methods, method_count) {
+            return impl(this.handle, java_class, methods, method_count);
+        }, 'pointer', ['pointer', 'pointer', 'pointer', 'pointer'], JNI_VT.RegisterNatives, jint);
+        // jint UnregisterNatives(JNIEnv* env, jclass java_class)
+        this.UnregisterNatives = this.$proxy(function (impl, java_class) {
+            return impl(this.handle, java_class);
+        }, 'pointer', ['pointer', 'pointer'], JNI_VT.UnregisterNatives, jint);
+        // ObjPtr<mirror::Object> JavaVMExt::DecodeGlobal(IndirectRef ref)
+        this.DecodeGlobal = this.$symbol(function (impl, obj) {
+            return impl(this.vm.handle, obj);
+        }, 'pointer', ['pointer', 'pointer'], '_ZN3art9JavaVMExt12DecodeGlobalEPv', MirrorObject);
+        // ObjPtr<mirror::Object> Thread::DecodeJObject(jobject obj)
+        this.DecodeJObject = this.$symbol(function (impl, thread = null, obj) {
+            const th = thread ? thread : getThreadFromEnv(this);
+            return impl(th, obj);
+        }, 'pointer', ['pointer', 'pointer'], '_ZNK3art6Thread13DecodeJObjectEP8_jobject', MirrorObject);
+        // jobject JavaVMExt::AddGlobalRef(Thread* self, ObjPtr<mirror::Object> obj)
+        this.AddGlobalRef = this.$symbol(function (impl, thread = null, obj) {
+            const th = thread ? thread : getThreadFromEnv(this);
+            return impl(this.vm.handle, th, obj);
+        }, 'pointer', ['pointer', 'pointer', 'pointer'], '_ZN3art9JavaVMExt12AddGlobalRefEPNS_6ThreadENS_6ObjPtrINS_6mirror6ObjectEEE', jobject);
+        // IndirectReferenceTable::IndirectReferenceTable(size_t max_count, IndirectRefKind desired_kind, ResizableCapacity resizable, std::string * error_msg)
+        this.IndirectReferenceTable_$new = this.$symbol(function (impl, self, max_count, desired_kind, resizable, error_msg) {
+            return impl(self, max_count, desired_kind, resizable, error_msg);
+        }, 'pointer', ['pointer', 'size_t', 'pointer', 'pointer', 'pointer'], '_ZN3art22IndirectReferenceTableC2EmNS_15IndirectRefKindENS0_17ResizableCapacityEPNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE', NativePointer);
+        // IndirectReferenceTable::~IndirectReferenceTable
+        this.IndirectReferenceTable_$del = this.$symbol(function (impl, self) {
+            return impl(self);
+        }, 'void', ['pointer'], '_ZN3art22IndirectReferenceTableD2Ev');
+        // bool IndirectReferenceTable::Resize(size_t new_size, std::string* error_msg)
+        this.IndirectReferenceTable_Resize = this.$symbol(function (impl, new_size, error_msg) {
+            return impl(new_size, error_msg);
+        }, 'bool', ['size_t', 'pointer'], '_ZN3art22IndirectReferenceTable6ResizeEmPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE');
+    }
+    makeObjectArrayElements(java_array) {
+        return new jobjectArray(java_array);
+    }
+}
+class JniEnv extends JniEnvCaller {
+    constructor(vm) {
+        super(vm);
+        const that = this;
+        return new Proxy(this, {
+            get(target, prop) {
+                if (prop in target) {
+                    return target[prop];
+                }
+                const env = that.$vm.getEnv();
+                return env[prop];
+            }
+        });
+    }
+    $clone() {
+        return new JniEnv(this.$vm);
+    }
+    javaLangReflectMethod() {
+        if (!JniEnv._javaLangReflectMethod) {
+            const cache = this.$env.javaLangReflectMethod();
+            // patch
+            const jcls = this.FindClass('java/lang/reflect/Method');
+            const methodID = this.GetMethodID(jcls, 'getReturnType', '()Ljava/lang/Class;');
+            cache.getReturnType = methodID;
+            JniEnv._javaLangReflectMethod = cache;
+            jcls.$unref();
+        }
+        return JniEnv._javaLangReflectMethod;
+    }
+}
+export const JNIEnv = new JniEnv();
+setGlobalProperties({
+    'JNIEnv': JNIEnv,
+    'jobject': jobject,
+    'jclass': jclass,
+});