diff --git a/.github/workflows/ffigen.yml b/.github/workflows/ffigen.yml
index 6e1690b92..ad7c487a4 100644
--- a/.github/workflows/ffigen.yml
+++ b/.github/workflows/ffigen.yml
@@ -58,13 +58,16 @@ jobs:
         with:
           channel: 'stable'
       - name: Install dependencies
-        run: flutter pub get
+        run: flutter pub get && flutter pub get --directory="../jni"
       - name: Install libclang-14-dev
         run: sudo apt-get install libclang-14-dev
       - name: Build test dylib and bindings
         run: dart test/setup.dart
       - name: Run VM tests
         run: dart test
+      - name: Generate package:jni bindings
+        run: dart run tool/generate_ffi_bindings.dart
+        working-directory: pkgs/jni/
 
   # Keep in sync with ffigen_weekly.yaml:test-mac-arm64
   test-mac:
@@ -79,11 +82,18 @@ jobs:
         with:
           channel: 'stable'
       - name: Install dependencies
-        run: flutter pub get && flutter pub get --directory="../objective_c"
+        run: flutter pub get && flutter pub get --directory="../objective_c" && flutter pub get --directory="../jni"
+      - name: Install clang-format
+        uses: ConorMacBride/install-package@3e7ad059e07782ee54fa35f827df52aae0626f30
+        with:
+          brew: clang-format
       - name: Build test dylib and bindings
         run: dart test/setup.dart
       - name: Run VM tests and collect coverage
         run: dart run coverage:test_with_coverage --scope-output=ffigen --scope-output=objective_c
+      - name: Generate package:jni bindings
+        run: dart run tool/generate_ffi_bindings.dart
+        working-directory: pkgs/jni/
       - name: Upload coverage
         uses: coverallsapp/github-action@cfd0633edbd2411b532b808ba7a8b5e04f76d2c8
         with:
@@ -128,11 +138,14 @@ jobs:
         with:
           channel: 'stable'
       - name: Install dependencies
-        run: flutter pub get
+        run: flutter pub get && flutter pub get --directory="../jni"
       - name: Build test dylib and bindings
         run: dart test/setup.dart
       - name: Run VM tests
         run: dart test
+      - name: Generate package:jni bindings
+        run: dart run tool/generate_ffi_bindings.dart
+        working-directory: pkgs/jni/
 
   # Sanity check the latest `flutter create --template plugin_ffi`.
   # This will break if we change the Flutter template or the generated code.
diff --git a/.github/workflows/ffigen_weekly.yml b/.github/workflows/ffigen_weekly.yml
index 863eac384..e40d77b3a 100644
--- a/.github/workflows/ffigen_weekly.yml
+++ b/.github/workflows/ffigen_weekly.yml
@@ -32,8 +32,15 @@ jobs:
         with:
           channel: 'stable'
       - name: Install dependencies
-        run: flutter pub get && flutter pub get --directory="../objective_c"
+        run: flutter pub get && flutter pub get --directory="../objective_c" && flutter pub get --directory="../jni"
+      - name: Install clang-format
+        uses: ConorMacBride/install-package@3e7ad059e07782ee54fa35f827df52aae0626f30
+        with:
+          brew: clang-format
       - name: Build test dylib and bindings
         run: dart test/setup.dart --main-thread-dispatcher
       - name: Run VM tests
         run: flutter test
+      - name: Generate package:jni bindings
+        run: dart run tool/generate_ffi_bindings.dart
+        working-directory: pkgs/jni/
diff --git a/pkgs/jni/lib/src/accessors.dart b/pkgs/jni/lib/src/accessors.dart
index 548acb4cd..b8429b835 100644
--- a/pkgs/jni/lib/src/accessors.dart
+++ b/pkgs/jni/lib/src/accessors.dart
@@ -62,6 +62,11 @@ extension JniResultMethods on JniResult {
     return value.l;
   }
 
+  JObjectRefType get referenceType {
+    check();
+    return JObjectRefType.fromValue(value.i);
+  }
+
   JReference get reference {
     final pointer = objectPointer;
     return pointer == nullptr ? jNullReference : JGlobalReference(pointer);
diff --git a/pkgs/jni/lib/src/errors.dart b/pkgs/jni/lib/src/errors.dart
index 6b50ac0db..966341fe9 100644
--- a/pkgs/jni/lib/src/errors.dart
+++ b/pkgs/jni/lib/src/errors.dart
@@ -22,25 +22,24 @@ final class DoubleReleaseError extends StateError {
   DoubleReleaseError() : super('Double release error');
 }
 
-/// Represents JNI errors that might be returned by methods like
-/// `JNI_CreateJavaVM`.
+/// Represents JNI errors that might be returned by methods like `CreateJavaVM`.
 sealed class JniError extends Error {
   static const _errors = {
-    JniErrorCode.JNI_ERR: JniGenericError.new,
-    JniErrorCode.JNI_EDETACHED: JniThreadDetachedError.new,
-    JniErrorCode.JNI_EVERSION: JniVersionError.new,
-    JniErrorCode.JNI_ENOMEM: JniOutOfMemoryError.new,
-    JniErrorCode.JNI_EEXIST: JniVmExistsError.new,
-    JniErrorCode.JNI_EINVAL: JniArgumentError.new,
+    JniErrorCode.ERR: JniGenericError.new,
+    JniErrorCode.EDETACHED: JniThreadDetachedError.new,
+    JniErrorCode.EVERSION: JniVersionError.new,
+    JniErrorCode.ENOMEM: JniOutOfMemoryError.new,
+    JniErrorCode.EEXIST: JniVmExistsError.new,
+    JniErrorCode.EINVAL: JniArgumentError.new,
   };
 
   final String message;
 
   JniError(this.message);
 
-  factory JniError.of(int status) {
+  factory JniError.of(JniErrorCode status) {
     if (!_errors.containsKey(status)) {
-      status = JniErrorCode.JNI_ERR;
+      status = JniErrorCode.ERR;
     }
     return _errors[status]!();
   }
diff --git a/pkgs/jni/lib/src/jni.dart b/pkgs/jni/lib/src/jni.dart
index 3429ae009..cfdfa645f 100644
--- a/pkgs/jni/lib/src/jni.dart
+++ b/pkgs/jni/lib/src/jni.dart
@@ -85,7 +85,7 @@ abstract final class Jni {
     List<String> jvmOptions = const [],
     List<String> classPath = const [],
     bool ignoreUnrecognized = false,
-    int jniVersion = JniVersions.JNI_VERSION_1_6,
+    JniVersions jniVersion = JniVersions.VERSION_1_6,
   }) {
     final status = spawnIfNotExists(
       dylibDir: dylibDir,
@@ -109,7 +109,7 @@ abstract final class Jni {
     List<String> jvmOptions = const [],
     List<String> classPath = const [],
     bool ignoreUnrecognized = false,
-    int jniVersion = JniVersions.JNI_VERSION_1_6,
+    JniVersions jniVersion = JniVersions.VERSION_1_6,
   }) =>
       using((arena) {
         _dylibDir = dylibDir ?? _dylibDir;
@@ -122,9 +122,9 @@ abstract final class Jni {
           allocator: arena,
         );
         final status = _bindings.SpawnJvm(jvmArgs);
-        if (status == JniErrorCode.JNI_OK) {
+        if (status == JniErrorCode.OK) {
           return true;
-        } else if (status == DART_JNI_SINGLETON_EXISTS) {
+        } else if (status == JniErrorCode.SINGLETON_EXISTS) {
           return false;
         } else {
           throw JniError.of(status);
@@ -136,7 +136,7 @@ abstract final class Jni {
     List<String> classPath = const [],
     String? dylibPath,
     bool ignoreUnrecognized = false,
-    int version = JniVersions.JNI_VERSION_1_6,
+    JniVersions version = JniVersions.VERSION_1_6,
     required Allocator allocator,
   }) {
     final args = allocator<JavaVMInitArgs>();
@@ -163,7 +163,7 @@ abstract final class Jni {
       args.ref.nOptions = count;
     }
     args.ref.ignoreUnrecognized = ignoreUnrecognized ? 1 : 0;
-    args.ref.version = version;
+    args.ref.version = version.value;
     return args;
   }
 
@@ -288,7 +288,7 @@ extension ProtectedJniExtensions on Jni {
   static Dart_FinalizableHandle newJObjectFinalizableHandle(
     Object object,
     Pointer<Void> reference,
-    int refType,
+    JObjectRefType refType,
   ) {
     ensureInitialized();
     return Jni._bindings
diff --git a/pkgs/jni/lib/src/third_party/global_env_extensions.dart b/pkgs/jni/lib/src/third_party/global_env_extensions.dart
index 4563d629c..60dc7955a 100644
--- a/pkgs/jni/lib/src/third_party/global_env_extensions.dart
+++ b/pkgs/jni/lib/src/third_party/global_env_extensions.dart
@@ -45,14 +45,17 @@ class GlobalJniEnv {
   late final _GetVersion =
       ptr.ref.GetVersion.asFunction<JniResult Function()>(isLeaf: true);
 
-  int GetVersion() => _GetVersion().integer;
+  DartJIntMarker GetVersion() => _GetVersion().integer;
 
   late final _DefineClass = ptr.ref.DefineClass.asFunction<
-      JniClassLookupResult Function(ffi.Pointer<ffi.Char> name,
-          JObjectPtr loader, ffi.Pointer<JByteMarker> buf, int bufLen)>();
+      JniClassLookupResult Function(
+          ffi.Pointer<ffi.Char> name,
+          JObjectPtr loader,
+          ffi.Pointer<JByteMarker> buf,
+          DartJIntMarker bufLen)>();
 
   JClassPtr DefineClass(ffi.Pointer<ffi.Char> name, JObjectPtr loader,
-          ffi.Pointer<JByteMarker> buf, int bufLen) =>
+          ffi.Pointer<JByteMarker> buf, DartJIntMarker bufLen) =>
       _DefineClass(name, loader, buf, bufLen).value;
 
   late final _FindClass = ptr.ref.FindClass
@@ -74,10 +77,11 @@ class GlobalJniEnv {
       _FromReflectedField(field).fieldID;
 
   late final _ToReflectedMethod = ptr.ref.ToReflectedMethod.asFunction<
-      JniResult Function(JClassPtr cls, JMethodIDPtr methodId, int isStatic)>();
+      JniResult Function(
+          JClassPtr cls, JMethodIDPtr methodId, DartJBooleanMarker isStatic)>();
 
   JObjectPtr ToReflectedMethod(
-          JClassPtr cls, JMethodIDPtr methodId, int isStatic) =>
+          JClassPtr cls, JMethodIDPtr methodId, DartJBooleanMarker isStatic) =>
       _ToReflectedMethod(cls, methodId, isStatic).objectPointer;
 
   late final _GetSuperclass = ptr.ref.GetSuperclass
@@ -93,21 +97,22 @@ class GlobalJniEnv {
       _IsAssignableFrom(clazz1, clazz2).boolean;
 
   late final _ToReflectedField = ptr.ref.ToReflectedField.asFunction<
-      JniResult Function(JClassPtr cls, JFieldIDPtr fieldID, int isStatic)>();
+      JniResult Function(
+          JClassPtr cls, JFieldIDPtr fieldID, DartJBooleanMarker isStatic)>();
 
   JObjectPtr ToReflectedField(
-          JClassPtr cls, JFieldIDPtr fieldID, int isStatic) =>
+          JClassPtr cls, JFieldIDPtr fieldID, DartJBooleanMarker isStatic) =>
       _ToReflectedField(cls, fieldID, isStatic).objectPointer;
 
   late final _Throw =
       ptr.ref.Throw.asFunction<JniResult Function(JThrowablePtr obj)>();
 
-  int Throw(JThrowablePtr obj) => _Throw(obj).integer;
+  DartJIntMarker Throw(JThrowablePtr obj) => _Throw(obj).integer;
 
   late final _ThrowNew = ptr.ref.ThrowNew.asFunction<
       JniResult Function(JClassPtr clazz, ffi.Pointer<ffi.Char> message)>();
 
-  int ThrowNew(JClassPtr clazz, ffi.Pointer<ffi.Char> message) =>
+  DartJIntMarker ThrowNew(JClassPtr clazz, ffi.Pointer<ffi.Char> message) =>
       _ThrowNew(clazz, message).integer;
 
   late final _ExceptionOccurred =
@@ -130,10 +135,11 @@ class GlobalJniEnv {
 
   void FatalError(ffi.Pointer<ffi.Char> msg) => _FatalError(msg).check();
 
-  late final _PushLocalFrame =
-      ptr.ref.PushLocalFrame.asFunction<JniResult Function(int capacity)>();
+  late final _PushLocalFrame = ptr.ref.PushLocalFrame
+      .asFunction<JniResult Function(DartJIntMarker capacity)>();
 
-  int PushLocalFrame(int capacity) => _PushLocalFrame(capacity).integer;
+  DartJIntMarker PushLocalFrame(DartJIntMarker capacity) =>
+      _PushLocalFrame(capacity).integer;
 
   late final _PopLocalFrame =
       ptr.ref.PopLocalFrame.asFunction<JniResult Function(JObjectPtr result)>();
@@ -170,9 +176,9 @@ class GlobalJniEnv {
   JObjectPtr NewLocalRef(JObjectPtr obj) => _NewLocalRef(obj).objectPointer;
 
   late final _EnsureLocalCapacity = ptr.ref.EnsureLocalCapacity
-      .asFunction<JniResult Function(int capacity)>();
+      .asFunction<JniResult Function(DartJIntMarker capacity)>();
 
-  int EnsureLocalCapacity(int capacity) =>
+  DartJIntMarker EnsureLocalCapacity(DartJIntMarker capacity) =>
       _EnsureLocalCapacity(capacity).integer;
 
   late final _AllocObject =
@@ -244,98 +250,98 @@ class GlobalJniEnv {
   late final _CallByteMethod = ptr.ref.CallByteMethod
       .asFunction<JniResult Function(JObjectPtr obj, JMethodIDPtr methodID)>();
 
-  int CallByteMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
+  DartJByteMarker CallByteMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
       _CallByteMethod(obj, methodID).byte;
 
   late final _CallByteMethodA = ptr.ref.CallByteMethodA.asFunction<
       JniResult Function(
           JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
 
-  int CallByteMethodA(
+  DartJByteMarker CallByteMethodA(
           JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
       _CallByteMethodA(obj, methodID, args).byte;
 
   late final _CallCharMethod = ptr.ref.CallCharMethod
       .asFunction<JniResult Function(JObjectPtr obj, JMethodIDPtr methodID)>();
 
-  int CallCharMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
+  DartJCharMarker CallCharMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
       _CallCharMethod(obj, methodID).char;
 
   late final _CallCharMethodA = ptr.ref.CallCharMethodA.asFunction<
       JniResult Function(
           JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
 
-  int CallCharMethodA(
+  DartJCharMarker CallCharMethodA(
           JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
       _CallCharMethodA(obj, methodID, args).char;
 
   late final _CallShortMethod = ptr.ref.CallShortMethod
       .asFunction<JniResult Function(JObjectPtr obj, JMethodIDPtr methodID)>();
 
-  int CallShortMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
+  DartJShortMarker CallShortMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
       _CallShortMethod(obj, methodID).short;
 
   late final _CallShortMethodA = ptr.ref.CallShortMethodA.asFunction<
       JniResult Function(
           JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
 
-  int CallShortMethodA(
+  DartJShortMarker CallShortMethodA(
           JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
       _CallShortMethodA(obj, methodID, args).short;
 
   late final _CallIntMethod = ptr.ref.CallIntMethod
       .asFunction<JniResult Function(JObjectPtr obj, JMethodIDPtr methodID)>();
 
-  int CallIntMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
+  DartJIntMarker CallIntMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
       _CallIntMethod(obj, methodID).integer;
 
   late final _CallIntMethodA = ptr.ref.CallIntMethodA.asFunction<
       JniResult Function(
           JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
 
-  int CallIntMethodA(
+  DartJIntMarker CallIntMethodA(
           JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
       _CallIntMethodA(obj, methodID, args).integer;
 
   late final _CallLongMethod = ptr.ref.CallLongMethod
       .asFunction<JniResult Function(JObjectPtr obj, JMethodIDPtr methodID)>();
 
-  int CallLongMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
+  DartJLongMarker CallLongMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
       _CallLongMethod(obj, methodID).long;
 
   late final _CallLongMethodA = ptr.ref.CallLongMethodA.asFunction<
       JniResult Function(
           JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
 
-  int CallLongMethodA(
+  DartJLongMarker CallLongMethodA(
           JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
       _CallLongMethodA(obj, methodID, args).long;
 
   late final _CallFloatMethod = ptr.ref.CallFloatMethod
       .asFunction<JniResult Function(JObjectPtr obj, JMethodIDPtr methodID)>();
 
-  double CallFloatMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
+  DartJFloatMarker CallFloatMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
       _CallFloatMethod(obj, methodID).float;
 
   late final _CallFloatMethodA = ptr.ref.CallFloatMethodA.asFunction<
       JniResult Function(
           JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
 
-  double CallFloatMethodA(
+  DartJFloatMarker CallFloatMethodA(
           JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
       _CallFloatMethodA(obj, methodID, args).float;
 
   late final _CallDoubleMethod = ptr.ref.CallDoubleMethod
       .asFunction<JniResult Function(JObjectPtr obj, JMethodIDPtr methodID)>();
 
-  double CallDoubleMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
+  DartJDoubleMarker CallDoubleMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
       _CallDoubleMethod(obj, methodID).doubleFloat;
 
   late final _CallDoubleMethodA = ptr.ref.CallDoubleMethodA.asFunction<
       JniResult Function(
           JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
 
-  double CallDoubleMethodA(
+  DartJDoubleMarker CallDoubleMethodA(
           JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
       _CallDoubleMethodA(obj, methodID, args).doubleFloat;
 
@@ -394,7 +400,7 @@ class GlobalJniEnv {
           JniResult Function(
               JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID)>();
 
-  int CallNonvirtualByteMethod(
+  DartJByteMarker CallNonvirtualByteMethod(
           JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
       _CallNonvirtualByteMethod(obj, clazz, methodID).byte;
 
@@ -403,7 +409,7 @@ class GlobalJniEnv {
           JniResult Function(JObjectPtr obj, JClassPtr clazz,
               JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
 
-  int CallNonvirtualByteMethodA(JObjectPtr obj, JClassPtr clazz,
+  DartJByteMarker CallNonvirtualByteMethodA(JObjectPtr obj, JClassPtr clazz,
           JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
       _CallNonvirtualByteMethodA(obj, clazz, methodID, args).byte;
 
@@ -412,7 +418,7 @@ class GlobalJniEnv {
           JniResult Function(
               JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID)>();
 
-  int CallNonvirtualCharMethod(
+  DartJCharMarker CallNonvirtualCharMethod(
           JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
       _CallNonvirtualCharMethod(obj, clazz, methodID).char;
 
@@ -421,7 +427,7 @@ class GlobalJniEnv {
           JniResult Function(JObjectPtr obj, JClassPtr clazz,
               JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
 
-  int CallNonvirtualCharMethodA(JObjectPtr obj, JClassPtr clazz,
+  DartJCharMarker CallNonvirtualCharMethodA(JObjectPtr obj, JClassPtr clazz,
           JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
       _CallNonvirtualCharMethodA(obj, clazz, methodID, args).char;
 
@@ -430,7 +436,7 @@ class GlobalJniEnv {
           JniResult Function(
               JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID)>();
 
-  int CallNonvirtualShortMethod(
+  DartJShortMarker CallNonvirtualShortMethod(
           JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
       _CallNonvirtualShortMethod(obj, clazz, methodID).short;
 
@@ -439,7 +445,7 @@ class GlobalJniEnv {
           JniResult Function(JObjectPtr obj, JClassPtr clazz,
               JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
 
-  int CallNonvirtualShortMethodA(JObjectPtr obj, JClassPtr clazz,
+  DartJShortMarker CallNonvirtualShortMethodA(JObjectPtr obj, JClassPtr clazz,
           JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
       _CallNonvirtualShortMethodA(obj, clazz, methodID, args).short;
 
@@ -448,7 +454,7 @@ class GlobalJniEnv {
           JniResult Function(
               JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID)>();
 
-  int CallNonvirtualIntMethod(
+  DartJIntMarker CallNonvirtualIntMethod(
           JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
       _CallNonvirtualIntMethod(obj, clazz, methodID).integer;
 
@@ -457,7 +463,7 @@ class GlobalJniEnv {
           JniResult Function(JObjectPtr obj, JClassPtr clazz,
               JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
 
-  int CallNonvirtualIntMethodA(JObjectPtr obj, JClassPtr clazz,
+  DartJIntMarker CallNonvirtualIntMethodA(JObjectPtr obj, JClassPtr clazz,
           JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
       _CallNonvirtualIntMethodA(obj, clazz, methodID, args).integer;
 
@@ -466,7 +472,7 @@ class GlobalJniEnv {
           JniResult Function(
               JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID)>();
 
-  int CallNonvirtualLongMethod(
+  DartJLongMarker CallNonvirtualLongMethod(
           JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
       _CallNonvirtualLongMethod(obj, clazz, methodID).long;
 
@@ -475,7 +481,7 @@ class GlobalJniEnv {
           JniResult Function(JObjectPtr obj, JClassPtr clazz,
               JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
 
-  int CallNonvirtualLongMethodA(JObjectPtr obj, JClassPtr clazz,
+  DartJLongMarker CallNonvirtualLongMethodA(JObjectPtr obj, JClassPtr clazz,
           JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
       _CallNonvirtualLongMethodA(obj, clazz, methodID, args).long;
 
@@ -484,7 +490,7 @@ class GlobalJniEnv {
           JniResult Function(
               JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID)>();
 
-  double CallNonvirtualFloatMethod(
+  DartJFloatMarker CallNonvirtualFloatMethod(
           JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
       _CallNonvirtualFloatMethod(obj, clazz, methodID).float;
 
@@ -493,7 +499,7 @@ class GlobalJniEnv {
           JniResult Function(JObjectPtr obj, JClassPtr clazz,
               JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
 
-  double CallNonvirtualFloatMethodA(JObjectPtr obj, JClassPtr clazz,
+  DartJFloatMarker CallNonvirtualFloatMethodA(JObjectPtr obj, JClassPtr clazz,
           JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
       _CallNonvirtualFloatMethodA(obj, clazz, methodID, args).float;
 
@@ -502,7 +508,7 @@ class GlobalJniEnv {
           JniResult Function(
               JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID)>();
 
-  double CallNonvirtualDoubleMethod(
+  DartJDoubleMarker CallNonvirtualDoubleMethod(
           JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
       _CallNonvirtualDoubleMethod(obj, clazz, methodID).doubleFloat;
 
@@ -511,7 +517,7 @@ class GlobalJniEnv {
           JniResult Function(JObjectPtr obj, JClassPtr clazz,
               JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
 
-  double CallNonvirtualDoubleMethodA(JObjectPtr obj, JClassPtr clazz,
+  DartJDoubleMarker CallNonvirtualDoubleMethodA(JObjectPtr obj, JClassPtr clazz,
           JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
       _CallNonvirtualDoubleMethodA(obj, clazz, methodID, args).doubleFloat;
 
@@ -559,49 +565,49 @@ class GlobalJniEnv {
       .asFunction<JniResult Function(JObjectPtr obj, JFieldIDPtr fieldID)>(
           isLeaf: true);
 
-  int GetByteField(JObjectPtr obj, JFieldIDPtr fieldID) =>
+  DartJByteMarker GetByteField(JObjectPtr obj, JFieldIDPtr fieldID) =>
       _GetByteField(obj, fieldID).byte;
 
   late final _GetCharField = ptr.ref.GetCharField
       .asFunction<JniResult Function(JObjectPtr obj, JFieldIDPtr fieldID)>(
           isLeaf: true);
 
-  int GetCharField(JObjectPtr obj, JFieldIDPtr fieldID) =>
+  DartJCharMarker GetCharField(JObjectPtr obj, JFieldIDPtr fieldID) =>
       _GetCharField(obj, fieldID).char;
 
   late final _GetShortField = ptr.ref.GetShortField
       .asFunction<JniResult Function(JObjectPtr obj, JFieldIDPtr fieldID)>(
           isLeaf: true);
 
-  int GetShortField(JObjectPtr obj, JFieldIDPtr fieldID) =>
+  DartJShortMarker GetShortField(JObjectPtr obj, JFieldIDPtr fieldID) =>
       _GetShortField(obj, fieldID).short;
 
   late final _GetIntField = ptr.ref.GetIntField
       .asFunction<JniResult Function(JObjectPtr obj, JFieldIDPtr fieldID)>(
           isLeaf: true);
 
-  int GetIntField(JObjectPtr obj, JFieldIDPtr fieldID) =>
+  DartJIntMarker GetIntField(JObjectPtr obj, JFieldIDPtr fieldID) =>
       _GetIntField(obj, fieldID).integer;
 
   late final _GetLongField = ptr.ref.GetLongField
       .asFunction<JniResult Function(JObjectPtr obj, JFieldIDPtr fieldID)>(
           isLeaf: true);
 
-  int GetLongField(JObjectPtr obj, JFieldIDPtr fieldID) =>
+  DartJLongMarker GetLongField(JObjectPtr obj, JFieldIDPtr fieldID) =>
       _GetLongField(obj, fieldID).long;
 
   late final _GetFloatField = ptr.ref.GetFloatField
       .asFunction<JniResult Function(JObjectPtr obj, JFieldIDPtr fieldID)>(
           isLeaf: true);
 
-  double GetFloatField(JObjectPtr obj, JFieldIDPtr fieldID) =>
+  DartJFloatMarker GetFloatField(JObjectPtr obj, JFieldIDPtr fieldID) =>
       _GetFloatField(obj, fieldID).float;
 
   late final _GetDoubleField = ptr.ref.GetDoubleField
       .asFunction<JniResult Function(JObjectPtr obj, JFieldIDPtr fieldID)>(
           isLeaf: true);
 
-  double GetDoubleField(JObjectPtr obj, JFieldIDPtr fieldID) =>
+  DartJDoubleMarker GetDoubleField(JObjectPtr obj, JFieldIDPtr fieldID) =>
       _GetDoubleField(obj, fieldID).doubleFloat;
 
   late final _SetObjectField = ptr.ref.SetObjectField.asFunction<
@@ -612,59 +618,63 @@ class GlobalJniEnv {
       _SetObjectField(obj, fieldID, val).check();
 
   late final _SetBooleanField = ptr.ref.SetBooleanField.asFunction<
-      JThrowablePtr Function(
-          JObjectPtr obj, JFieldIDPtr fieldID, int val)>(isLeaf: true);
+      JThrowablePtr Function(JObjectPtr obj, JFieldIDPtr fieldID,
+          DartJBooleanMarker val)>(isLeaf: true);
 
-  void SetBooleanField(JObjectPtr obj, JFieldIDPtr fieldID, int val) =>
+  void SetBooleanField(
+          JObjectPtr obj, JFieldIDPtr fieldID, DartJBooleanMarker val) =>
       _SetBooleanField(obj, fieldID, val).check();
 
   late final _SetByteField = ptr.ref.SetByteField.asFunction<
-      JThrowablePtr Function(
-          JObjectPtr obj, JFieldIDPtr fieldID, int val)>(isLeaf: true);
+      JThrowablePtr Function(JObjectPtr obj, JFieldIDPtr fieldID,
+          DartJByteMarker val)>(isLeaf: true);
 
-  void SetByteField(JObjectPtr obj, JFieldIDPtr fieldID, int val) =>
+  void SetByteField(JObjectPtr obj, JFieldIDPtr fieldID, DartJByteMarker val) =>
       _SetByteField(obj, fieldID, val).check();
 
   late final _SetCharField = ptr.ref.SetCharField.asFunction<
-      JThrowablePtr Function(
-          JObjectPtr obj, JFieldIDPtr fieldID, int val)>(isLeaf: true);
+      JThrowablePtr Function(JObjectPtr obj, JFieldIDPtr fieldID,
+          DartJCharMarker val)>(isLeaf: true);
 
-  void SetCharField(JObjectPtr obj, JFieldIDPtr fieldID, int val) =>
+  void SetCharField(JObjectPtr obj, JFieldIDPtr fieldID, DartJCharMarker val) =>
       _SetCharField(obj, fieldID, val).check();
 
   late final _SetShortField = ptr.ref.SetShortField.asFunction<
-      JThrowablePtr Function(
-          JObjectPtr obj, JFieldIDPtr fieldID, int val)>(isLeaf: true);
+      JThrowablePtr Function(JObjectPtr obj, JFieldIDPtr fieldID,
+          DartJShortMarker val)>(isLeaf: true);
 
-  void SetShortField(JObjectPtr obj, JFieldIDPtr fieldID, int val) =>
+  void SetShortField(
+          JObjectPtr obj, JFieldIDPtr fieldID, DartJShortMarker val) =>
       _SetShortField(obj, fieldID, val).check();
 
   late final _SetIntField = ptr.ref.SetIntField.asFunction<
-      JThrowablePtr Function(
-          JObjectPtr obj, JFieldIDPtr fieldID, int val)>(isLeaf: true);
+      JThrowablePtr Function(JObjectPtr obj, JFieldIDPtr fieldID,
+          DartJIntMarker val)>(isLeaf: true);
 
-  void SetIntField(JObjectPtr obj, JFieldIDPtr fieldID, int val) =>
+  void SetIntField(JObjectPtr obj, JFieldIDPtr fieldID, DartJIntMarker val) =>
       _SetIntField(obj, fieldID, val).check();
 
   late final _SetLongField = ptr.ref.SetLongField.asFunction<
-      JThrowablePtr Function(
-          JObjectPtr obj, JFieldIDPtr fieldID, int val)>(isLeaf: true);
+      JThrowablePtr Function(JObjectPtr obj, JFieldIDPtr fieldID,
+          DartJLongMarker val)>(isLeaf: true);
 
-  void SetLongField(JObjectPtr obj, JFieldIDPtr fieldID, int val) =>
+  void SetLongField(JObjectPtr obj, JFieldIDPtr fieldID, DartJLongMarker val) =>
       _SetLongField(obj, fieldID, val).check();
 
   late final _SetFloatField = ptr.ref.SetFloatField.asFunction<
-      JThrowablePtr Function(
-          JObjectPtr obj, JFieldIDPtr fieldID, double val)>(isLeaf: true);
+      JThrowablePtr Function(JObjectPtr obj, JFieldIDPtr fieldID,
+          DartJFloatMarker val)>(isLeaf: true);
 
-  void SetFloatField(JObjectPtr obj, JFieldIDPtr fieldID, double val) =>
+  void SetFloatField(
+          JObjectPtr obj, JFieldIDPtr fieldID, DartJFloatMarker val) =>
       _SetFloatField(obj, fieldID, val).check();
 
   late final _SetDoubleField = ptr.ref.SetDoubleField.asFunction<
-      JThrowablePtr Function(
-          JObjectPtr obj, JFieldIDPtr fieldID, double val)>(isLeaf: true);
+      JThrowablePtr Function(JObjectPtr obj, JFieldIDPtr fieldID,
+          DartJDoubleMarker val)>(isLeaf: true);
 
-  void SetDoubleField(JObjectPtr obj, JFieldIDPtr fieldID, double val) =>
+  void SetDoubleField(
+          JObjectPtr obj, JFieldIDPtr fieldID, DartJDoubleMarker val) =>
       _SetDoubleField(obj, fieldID, val).check();
 
   late final _GetStaticMethodID = ptr.ref.GetStaticMethodID.asFunction<
@@ -708,35 +718,38 @@ class GlobalJniEnv {
   late final _CallStaticByteMethod = ptr.ref.CallStaticByteMethod
       .asFunction<JniResult Function(JClassPtr clazz, JMethodIDPtr methodID)>();
 
-  int CallStaticByteMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
+  DartJByteMarker CallStaticByteMethod(
+          JClassPtr clazz, JMethodIDPtr methodID) =>
       _CallStaticByteMethod(clazz, methodID).byte;
 
   late final _CallStaticByteMethodA = ptr.ref.CallStaticByteMethodA.asFunction<
       JniResult Function(
           JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
 
-  int CallStaticByteMethodA(
+  DartJByteMarker CallStaticByteMethodA(
           JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
       _CallStaticByteMethodA(clazz, methodID, args).byte;
 
   late final _CallStaticCharMethod = ptr.ref.CallStaticCharMethod
       .asFunction<JniResult Function(JClassPtr clazz, JMethodIDPtr methodID)>();
 
-  int CallStaticCharMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
+  DartJCharMarker CallStaticCharMethod(
+          JClassPtr clazz, JMethodIDPtr methodID) =>
       _CallStaticCharMethod(clazz, methodID).char;
 
   late final _CallStaticCharMethodA = ptr.ref.CallStaticCharMethodA.asFunction<
       JniResult Function(
           JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
 
-  int CallStaticCharMethodA(
+  DartJCharMarker CallStaticCharMethodA(
           JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
       _CallStaticCharMethodA(clazz, methodID, args).char;
 
   late final _CallStaticShortMethod = ptr.ref.CallStaticShortMethod
       .asFunction<JniResult Function(JClassPtr clazz, JMethodIDPtr methodID)>();
 
-  int CallStaticShortMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
+  DartJShortMarker CallStaticShortMethod(
+          JClassPtr clazz, JMethodIDPtr methodID) =>
       _CallStaticShortMethod(clazz, methodID).short;
 
   late final _CallStaticShortMethodA = ptr.ref.CallStaticShortMethodA
@@ -744,42 +757,44 @@ class GlobalJniEnv {
           JniResult Function(JClassPtr clazz, JMethodIDPtr methodID,
               ffi.Pointer<JValue> args)>();
 
-  int CallStaticShortMethodA(
+  DartJShortMarker CallStaticShortMethodA(
           JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
       _CallStaticShortMethodA(clazz, methodID, args).short;
 
   late final _CallStaticIntMethod = ptr.ref.CallStaticIntMethod
       .asFunction<JniResult Function(JClassPtr clazz, JMethodIDPtr methodID)>();
 
-  int CallStaticIntMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
+  DartJIntMarker CallStaticIntMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
       _CallStaticIntMethod(clazz, methodID).integer;
 
   late final _CallStaticIntMethodA = ptr.ref.CallStaticIntMethodA.asFunction<
       JniResult Function(
           JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
 
-  int CallStaticIntMethodA(
+  DartJIntMarker CallStaticIntMethodA(
           JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
       _CallStaticIntMethodA(clazz, methodID, args).integer;
 
   late final _CallStaticLongMethod = ptr.ref.CallStaticLongMethod
       .asFunction<JniResult Function(JClassPtr clazz, JMethodIDPtr methodID)>();
 
-  int CallStaticLongMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
+  DartJLongMarker CallStaticLongMethod(
+          JClassPtr clazz, JMethodIDPtr methodID) =>
       _CallStaticLongMethod(clazz, methodID).long;
 
   late final _CallStaticLongMethodA = ptr.ref.CallStaticLongMethodA.asFunction<
       JniResult Function(
           JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
 
-  int CallStaticLongMethodA(
+  DartJLongMarker CallStaticLongMethodA(
           JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
       _CallStaticLongMethodA(clazz, methodID, args).long;
 
   late final _CallStaticFloatMethod = ptr.ref.CallStaticFloatMethod
       .asFunction<JniResult Function(JClassPtr clazz, JMethodIDPtr methodID)>();
 
-  double CallStaticFloatMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
+  DartJFloatMarker CallStaticFloatMethod(
+          JClassPtr clazz, JMethodIDPtr methodID) =>
       _CallStaticFloatMethod(clazz, methodID).float;
 
   late final _CallStaticFloatMethodA = ptr.ref.CallStaticFloatMethodA
@@ -787,14 +802,15 @@ class GlobalJniEnv {
           JniResult Function(JClassPtr clazz, JMethodIDPtr methodID,
               ffi.Pointer<JValue> args)>();
 
-  double CallStaticFloatMethodA(
+  DartJFloatMarker CallStaticFloatMethodA(
           JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
       _CallStaticFloatMethodA(clazz, methodID, args).float;
 
   late final _CallStaticDoubleMethod = ptr.ref.CallStaticDoubleMethod
       .asFunction<JniResult Function(JClassPtr clazz, JMethodIDPtr methodID)>();
 
-  double CallStaticDoubleMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
+  DartJDoubleMarker CallStaticDoubleMethod(
+          JClassPtr clazz, JMethodIDPtr methodID) =>
       _CallStaticDoubleMethod(clazz, methodID).doubleFloat;
 
   late final _CallStaticDoubleMethodA = ptr.ref.CallStaticDoubleMethodA
@@ -802,7 +818,7 @@ class GlobalJniEnv {
           JniResult Function(JClassPtr clazz, JMethodIDPtr methodID,
               ffi.Pointer<JValue> args)>();
 
-  double CallStaticDoubleMethodA(
+  DartJDoubleMarker CallStaticDoubleMethodA(
           JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
       _CallStaticDoubleMethodA(clazz, methodID, args).doubleFloat;
 
@@ -846,49 +862,50 @@ class GlobalJniEnv {
       .asFunction<JniResult Function(JClassPtr clazz, JFieldIDPtr fieldID)>(
           isLeaf: true);
 
-  int GetStaticByteField(JClassPtr clazz, JFieldIDPtr fieldID) =>
+  DartJByteMarker GetStaticByteField(JClassPtr clazz, JFieldIDPtr fieldID) =>
       _GetStaticByteField(clazz, fieldID).byte;
 
   late final _GetStaticCharField = ptr.ref.GetStaticCharField
       .asFunction<JniResult Function(JClassPtr clazz, JFieldIDPtr fieldID)>(
           isLeaf: true);
 
-  int GetStaticCharField(JClassPtr clazz, JFieldIDPtr fieldID) =>
+  DartJCharMarker GetStaticCharField(JClassPtr clazz, JFieldIDPtr fieldID) =>
       _GetStaticCharField(clazz, fieldID).char;
 
   late final _GetStaticShortField = ptr.ref.GetStaticShortField
       .asFunction<JniResult Function(JClassPtr clazz, JFieldIDPtr fieldID)>(
           isLeaf: true);
 
-  int GetStaticShortField(JClassPtr clazz, JFieldIDPtr fieldID) =>
+  DartJShortMarker GetStaticShortField(JClassPtr clazz, JFieldIDPtr fieldID) =>
       _GetStaticShortField(clazz, fieldID).short;
 
   late final _GetStaticIntField = ptr.ref.GetStaticIntField
       .asFunction<JniResult Function(JClassPtr clazz, JFieldIDPtr fieldID)>(
           isLeaf: true);
 
-  int GetStaticIntField(JClassPtr clazz, JFieldIDPtr fieldID) =>
+  DartJIntMarker GetStaticIntField(JClassPtr clazz, JFieldIDPtr fieldID) =>
       _GetStaticIntField(clazz, fieldID).integer;
 
   late final _GetStaticLongField = ptr.ref.GetStaticLongField
       .asFunction<JniResult Function(JClassPtr clazz, JFieldIDPtr fieldID)>(
           isLeaf: true);
 
-  int GetStaticLongField(JClassPtr clazz, JFieldIDPtr fieldID) =>
+  DartJLongMarker GetStaticLongField(JClassPtr clazz, JFieldIDPtr fieldID) =>
       _GetStaticLongField(clazz, fieldID).long;
 
   late final _GetStaticFloatField = ptr.ref.GetStaticFloatField
       .asFunction<JniResult Function(JClassPtr clazz, JFieldIDPtr fieldID)>(
           isLeaf: true);
 
-  double GetStaticFloatField(JClassPtr clazz, JFieldIDPtr fieldID) =>
+  DartJFloatMarker GetStaticFloatField(JClassPtr clazz, JFieldIDPtr fieldID) =>
       _GetStaticFloatField(clazz, fieldID).float;
 
   late final _GetStaticDoubleField = ptr.ref.GetStaticDoubleField
       .asFunction<JniResult Function(JClassPtr clazz, JFieldIDPtr fieldID)>(
           isLeaf: true);
 
-  double GetStaticDoubleField(JClassPtr clazz, JFieldIDPtr fieldID) =>
+  DartJDoubleMarker GetStaticDoubleField(
+          JClassPtr clazz, JFieldIDPtr fieldID) =>
       _GetStaticDoubleField(clazz, fieldID).doubleFloat;
 
   late final _SetStaticObjectField = ptr.ref.SetStaticObjectField.asFunction<
@@ -900,71 +917,82 @@ class GlobalJniEnv {
       _SetStaticObjectField(clazz, fieldID, val).check();
 
   late final _SetStaticBooleanField = ptr.ref.SetStaticBooleanField.asFunction<
-      JThrowablePtr Function(
-          JClassPtr clazz, JFieldIDPtr fieldID, int val)>(isLeaf: true);
+      JThrowablePtr Function(JClassPtr clazz, JFieldIDPtr fieldID,
+          DartJBooleanMarker val)>(isLeaf: true);
 
-  void SetStaticBooleanField(JClassPtr clazz, JFieldIDPtr fieldID, int val) =>
+  void SetStaticBooleanField(
+          JClassPtr clazz, JFieldIDPtr fieldID, DartJBooleanMarker val) =>
       _SetStaticBooleanField(clazz, fieldID, val).check();
 
   late final _SetStaticByteField = ptr.ref.SetStaticByteField.asFunction<
-      JThrowablePtr Function(
-          JClassPtr clazz, JFieldIDPtr fieldID, int val)>(isLeaf: true);
+      JThrowablePtr Function(JClassPtr clazz, JFieldIDPtr fieldID,
+          DartJByteMarker val)>(isLeaf: true);
 
-  void SetStaticByteField(JClassPtr clazz, JFieldIDPtr fieldID, int val) =>
+  void SetStaticByteField(
+          JClassPtr clazz, JFieldIDPtr fieldID, DartJByteMarker val) =>
       _SetStaticByteField(clazz, fieldID, val).check();
 
   late final _SetStaticCharField = ptr.ref.SetStaticCharField.asFunction<
-      JThrowablePtr Function(
-          JClassPtr clazz, JFieldIDPtr fieldID, int val)>(isLeaf: true);
+      JThrowablePtr Function(JClassPtr clazz, JFieldIDPtr fieldID,
+          DartJCharMarker val)>(isLeaf: true);
 
-  void SetStaticCharField(JClassPtr clazz, JFieldIDPtr fieldID, int val) =>
+  void SetStaticCharField(
+          JClassPtr clazz, JFieldIDPtr fieldID, DartJCharMarker val) =>
       _SetStaticCharField(clazz, fieldID, val).check();
 
   late final _SetStaticShortField = ptr.ref.SetStaticShortField.asFunction<
-      JThrowablePtr Function(
-          JClassPtr clazz, JFieldIDPtr fieldID, int val)>(isLeaf: true);
+      JThrowablePtr Function(JClassPtr clazz, JFieldIDPtr fieldID,
+          DartJShortMarker val)>(isLeaf: true);
 
-  void SetStaticShortField(JClassPtr clazz, JFieldIDPtr fieldID, int val) =>
+  void SetStaticShortField(
+          JClassPtr clazz, JFieldIDPtr fieldID, DartJShortMarker val) =>
       _SetStaticShortField(clazz, fieldID, val).check();
 
   late final _SetStaticIntField = ptr.ref.SetStaticIntField.asFunction<
-      JThrowablePtr Function(
-          JClassPtr clazz, JFieldIDPtr fieldID, int val)>(isLeaf: true);
+      JThrowablePtr Function(JClassPtr clazz, JFieldIDPtr fieldID,
+          DartJIntMarker val)>(isLeaf: true);
 
-  void SetStaticIntField(JClassPtr clazz, JFieldIDPtr fieldID, int val) =>
+  void SetStaticIntField(
+          JClassPtr clazz, JFieldIDPtr fieldID, DartJIntMarker val) =>
       _SetStaticIntField(clazz, fieldID, val).check();
 
   late final _SetStaticLongField = ptr.ref.SetStaticLongField.asFunction<
-      JThrowablePtr Function(
-          JClassPtr clazz, JFieldIDPtr fieldID, int val)>(isLeaf: true);
+      JThrowablePtr Function(JClassPtr clazz, JFieldIDPtr fieldID,
+          DartJLongMarker val)>(isLeaf: true);
 
-  void SetStaticLongField(JClassPtr clazz, JFieldIDPtr fieldID, int val) =>
+  void SetStaticLongField(
+          JClassPtr clazz, JFieldIDPtr fieldID, DartJLongMarker val) =>
       _SetStaticLongField(clazz, fieldID, val).check();
 
   late final _SetStaticFloatField = ptr.ref.SetStaticFloatField.asFunction<
-      JThrowablePtr Function(
-          JClassPtr clazz, JFieldIDPtr fieldID, double val)>(isLeaf: true);
+      JThrowablePtr Function(JClassPtr clazz, JFieldIDPtr fieldID,
+          DartJFloatMarker val)>(isLeaf: true);
 
-  void SetStaticFloatField(JClassPtr clazz, JFieldIDPtr fieldID, double val) =>
+  void SetStaticFloatField(
+          JClassPtr clazz, JFieldIDPtr fieldID, DartJFloatMarker val) =>
       _SetStaticFloatField(clazz, fieldID, val).check();
 
   late final _SetStaticDoubleField = ptr.ref.SetStaticDoubleField.asFunction<
-      JThrowablePtr Function(
-          JClassPtr clazz, JFieldIDPtr fieldID, double val)>(isLeaf: true);
+      JThrowablePtr Function(JClassPtr clazz, JFieldIDPtr fieldID,
+          DartJDoubleMarker val)>(isLeaf: true);
 
-  void SetStaticDoubleField(JClassPtr clazz, JFieldIDPtr fieldID, double val) =>
+  void SetStaticDoubleField(
+          JClassPtr clazz, JFieldIDPtr fieldID, DartJDoubleMarker val) =>
       _SetStaticDoubleField(clazz, fieldID, val).check();
 
   late final _NewString = ptr.ref.NewString.asFunction<
-      JniResult Function(ffi.Pointer<JCharMarker> unicodeChars, int len)>();
+      JniResult Function(
+          ffi.Pointer<JCharMarker> unicodeChars, DartJIntMarker len)>();
 
-  JStringPtr NewString(ffi.Pointer<JCharMarker> unicodeChars, int len) =>
+  JStringPtr NewString(
+          ffi.Pointer<JCharMarker> unicodeChars, DartJIntMarker len) =>
       _NewString(unicodeChars, len).objectPointer;
 
   late final _GetStringLength = ptr.ref.GetStringLength
       .asFunction<JniResult Function(JStringPtr string)>(isLeaf: true);
 
-  int GetStringLength(JStringPtr string) => _GetStringLength(string).integer;
+  DartJIntMarker GetStringLength(JStringPtr string) =>
+      _GetStringLength(string).integer;
 
   late final _GetStringChars = ptr.ref.GetStringChars.asFunction<
       JniPointerResult Function(
@@ -990,7 +1018,7 @@ class GlobalJniEnv {
   late final _GetStringUTFLength = ptr.ref.GetStringUTFLength
       .asFunction<JniResult Function(JStringPtr string)>(isLeaf: true);
 
-  int GetStringUTFLength(JStringPtr string) =>
+  DartJIntMarker GetStringUTFLength(JStringPtr string) =>
       _GetStringUTFLength(string).integer;
 
   late final _GetStringUTFChars = ptr.ref.GetStringUTFChars.asFunction<
@@ -1010,73 +1038,79 @@ class GlobalJniEnv {
   late final _GetArrayLength = ptr.ref.GetArrayLength
       .asFunction<JniResult Function(JArrayPtr array)>(isLeaf: true);
 
-  int GetArrayLength(JArrayPtr array) => _GetArrayLength(array).integer;
+  DartJIntMarker GetArrayLength(JArrayPtr array) =>
+      _GetArrayLength(array).integer;
 
   late final _NewObjectArray = ptr.ref.NewObjectArray.asFunction<
-      JniResult Function(
-          int length, JClassPtr elementClass, JObjectPtr initialElement)>();
+      JniResult Function(DartJIntMarker length, JClassPtr elementClass,
+          JObjectPtr initialElement)>();
 
-  JObjectArrayPtr NewObjectArray(
-          int length, JClassPtr elementClass, JObjectPtr initialElement) =>
+  JObjectArrayPtr NewObjectArray(DartJIntMarker length, JClassPtr elementClass,
+          JObjectPtr initialElement) =>
       _NewObjectArray(length, elementClass, initialElement).objectPointer;
 
-  late final _GetObjectArrayElement = ptr.ref.GetObjectArrayElement
-      .asFunction<JniResult Function(JObjectArrayPtr array, int index)>(
-          isLeaf: true);
+  late final _GetObjectArrayElement = ptr.ref.GetObjectArrayElement.asFunction<
+      JniResult Function(
+          JObjectArrayPtr array, DartJIntMarker index)>(isLeaf: true);
 
-  JObjectPtr GetObjectArrayElement(JObjectArrayPtr array, int index) =>
+  JObjectPtr GetObjectArrayElement(
+          JObjectArrayPtr array, DartJIntMarker index) =>
       _GetObjectArrayElement(array, index).objectPointer;
 
   late final _SetObjectArrayElement = ptr.ref.SetObjectArrayElement.asFunction<
-      JThrowablePtr Function(
-          JObjectArrayPtr array, int index, JObjectPtr val)>(isLeaf: true);
+      JThrowablePtr Function(JObjectArrayPtr array, DartJIntMarker index,
+          JObjectPtr val)>(isLeaf: true);
 
   void SetObjectArrayElement(
-          JObjectArrayPtr array, int index, JObjectPtr val) =>
+          JObjectArrayPtr array, DartJIntMarker index, JObjectPtr val) =>
       _SetObjectArrayElement(array, index, val).check();
 
-  late final _NewBooleanArray =
-      ptr.ref.NewBooleanArray.asFunction<JniResult Function(int length)>();
+  late final _NewBooleanArray = ptr.ref.NewBooleanArray
+      .asFunction<JniResult Function(DartJIntMarker length)>();
 
-  JBooleanArrayPtr NewBooleanArray(int length) =>
+  JBooleanArrayPtr NewBooleanArray(DartJIntMarker length) =>
       _NewBooleanArray(length).objectPointer;
 
-  late final _NewByteArray =
-      ptr.ref.NewByteArray.asFunction<JniResult Function(int length)>();
+  late final _NewByteArray = ptr.ref.NewByteArray
+      .asFunction<JniResult Function(DartJIntMarker length)>();
 
-  JByteArrayPtr NewByteArray(int length) => _NewByteArray(length).objectPointer;
+  JByteArrayPtr NewByteArray(DartJIntMarker length) =>
+      _NewByteArray(length).objectPointer;
 
-  late final _NewCharArray =
-      ptr.ref.NewCharArray.asFunction<JniResult Function(int length)>();
+  late final _NewCharArray = ptr.ref.NewCharArray
+      .asFunction<JniResult Function(DartJIntMarker length)>();
 
-  JCharArrayPtr NewCharArray(int length) => _NewCharArray(length).objectPointer;
+  JCharArrayPtr NewCharArray(DartJIntMarker length) =>
+      _NewCharArray(length).objectPointer;
 
-  late final _NewShortArray =
-      ptr.ref.NewShortArray.asFunction<JniResult Function(int length)>();
+  late final _NewShortArray = ptr.ref.NewShortArray
+      .asFunction<JniResult Function(DartJIntMarker length)>();
 
-  JShortArrayPtr NewShortArray(int length) =>
+  JShortArrayPtr NewShortArray(DartJIntMarker length) =>
       _NewShortArray(length).objectPointer;
 
-  late final _NewIntArray =
-      ptr.ref.NewIntArray.asFunction<JniResult Function(int length)>();
+  late final _NewIntArray = ptr.ref.NewIntArray
+      .asFunction<JniResult Function(DartJIntMarker length)>();
 
-  JIntArrayPtr NewIntArray(int length) => _NewIntArray(length).objectPointer;
+  JIntArrayPtr NewIntArray(DartJIntMarker length) =>
+      _NewIntArray(length).objectPointer;
 
-  late final _NewLongArray =
-      ptr.ref.NewLongArray.asFunction<JniResult Function(int length)>();
+  late final _NewLongArray = ptr.ref.NewLongArray
+      .asFunction<JniResult Function(DartJIntMarker length)>();
 
-  JLongArrayPtr NewLongArray(int length) => _NewLongArray(length).objectPointer;
+  JLongArrayPtr NewLongArray(DartJIntMarker length) =>
+      _NewLongArray(length).objectPointer;
 
-  late final _NewFloatArray =
-      ptr.ref.NewFloatArray.asFunction<JniResult Function(int length)>();
+  late final _NewFloatArray = ptr.ref.NewFloatArray
+      .asFunction<JniResult Function(DartJIntMarker length)>();
 
-  JFloatArrayPtr NewFloatArray(int length) =>
+  JFloatArrayPtr NewFloatArray(DartJIntMarker length) =>
       _NewFloatArray(length).objectPointer;
 
-  late final _NewDoubleArray =
-      ptr.ref.NewDoubleArray.asFunction<JniResult Function(int length)>();
+  late final _NewDoubleArray = ptr.ref.NewDoubleArray
+      .asFunction<JniResult Function(DartJIntMarker length)>();
 
-  JDoubleArrayPtr NewDoubleArray(int length) =>
+  JDoubleArrayPtr NewDoubleArray(DartJIntMarker length) =>
       _NewDoubleArray(length).objectPointer;
 
   late final _GetBooleanArrayElements = ptr.ref.GetBooleanArrayElements
@@ -1148,246 +1182,248 @@ class GlobalJniEnv {
   late final _ReleaseBooleanArrayElements = ptr.ref.ReleaseBooleanArrayElements
       .asFunction<
           JThrowablePtr Function(JBooleanArrayPtr array,
-              ffi.Pointer<JBooleanMarker> elems, int mode)>();
+              ffi.Pointer<JBooleanMarker> elems, DartJIntMarker mode)>();
 
   void ReleaseBooleanArrayElements(JBooleanArrayPtr array,
-          ffi.Pointer<JBooleanMarker> elems, int mode) =>
+          ffi.Pointer<JBooleanMarker> elems, DartJIntMarker mode) =>
       _ReleaseBooleanArrayElements(array, elems, mode).check();
 
   late final _ReleaseByteArrayElements = ptr.ref.ReleaseByteArrayElements
       .asFunction<
-          JThrowablePtr Function(
-              JByteArrayPtr array, ffi.Pointer<JByteMarker> elems, int mode)>();
+          JThrowablePtr Function(JByteArrayPtr array,
+              ffi.Pointer<JByteMarker> elems, DartJIntMarker mode)>();
 
-  void ReleaseByteArrayElements(
-          JByteArrayPtr array, ffi.Pointer<JByteMarker> elems, int mode) =>
+  void ReleaseByteArrayElements(JByteArrayPtr array,
+          ffi.Pointer<JByteMarker> elems, DartJIntMarker mode) =>
       _ReleaseByteArrayElements(array, elems, mode).check();
 
   late final _ReleaseCharArrayElements = ptr.ref.ReleaseCharArrayElements
       .asFunction<
-          JThrowablePtr Function(
-              JCharArrayPtr array, ffi.Pointer<JCharMarker> elems, int mode)>();
+          JThrowablePtr Function(JCharArrayPtr array,
+              ffi.Pointer<JCharMarker> elems, DartJIntMarker mode)>();
 
-  void ReleaseCharArrayElements(
-          JCharArrayPtr array, ffi.Pointer<JCharMarker> elems, int mode) =>
+  void ReleaseCharArrayElements(JCharArrayPtr array,
+          ffi.Pointer<JCharMarker> elems, DartJIntMarker mode) =>
       _ReleaseCharArrayElements(array, elems, mode).check();
 
   late final _ReleaseShortArrayElements = ptr.ref.ReleaseShortArrayElements
       .asFunction<
           JThrowablePtr Function(JShortArrayPtr array,
-              ffi.Pointer<JShortMarker> elems, int mode)>();
+              ffi.Pointer<JShortMarker> elems, DartJIntMarker mode)>();
 
-  void ReleaseShortArrayElements(
-          JShortArrayPtr array, ffi.Pointer<JShortMarker> elems, int mode) =>
+  void ReleaseShortArrayElements(JShortArrayPtr array,
+          ffi.Pointer<JShortMarker> elems, DartJIntMarker mode) =>
       _ReleaseShortArrayElements(array, elems, mode).check();
 
   late final _ReleaseIntArrayElements = ptr.ref.ReleaseIntArrayElements
       .asFunction<
-          JThrowablePtr Function(
-              JIntArrayPtr array, ffi.Pointer<JIntMarker> elems, int mode)>();
+          JThrowablePtr Function(JIntArrayPtr array,
+              ffi.Pointer<JIntMarker> elems, DartJIntMarker mode)>();
 
-  void ReleaseIntArrayElements(
-          JIntArrayPtr array, ffi.Pointer<JIntMarker> elems, int mode) =>
+  void ReleaseIntArrayElements(JIntArrayPtr array,
+          ffi.Pointer<JIntMarker> elems, DartJIntMarker mode) =>
       _ReleaseIntArrayElements(array, elems, mode).check();
 
   late final _ReleaseLongArrayElements = ptr.ref.ReleaseLongArrayElements
       .asFunction<
-          JThrowablePtr Function(
-              JLongArrayPtr array, ffi.Pointer<JLongMarker> elems, int mode)>();
+          JThrowablePtr Function(JLongArrayPtr array,
+              ffi.Pointer<JLongMarker> elems, DartJIntMarker mode)>();
 
-  void ReleaseLongArrayElements(
-          JLongArrayPtr array, ffi.Pointer<JLongMarker> elems, int mode) =>
+  void ReleaseLongArrayElements(JLongArrayPtr array,
+          ffi.Pointer<JLongMarker> elems, DartJIntMarker mode) =>
       _ReleaseLongArrayElements(array, elems, mode).check();
 
   late final _ReleaseFloatArrayElements = ptr.ref.ReleaseFloatArrayElements
       .asFunction<
           JThrowablePtr Function(JFloatArrayPtr array,
-              ffi.Pointer<JFloatMarker> elems, int mode)>();
+              ffi.Pointer<JFloatMarker> elems, DartJIntMarker mode)>();
 
-  void ReleaseFloatArrayElements(
-          JFloatArrayPtr array, ffi.Pointer<JFloatMarker> elems, int mode) =>
+  void ReleaseFloatArrayElements(JFloatArrayPtr array,
+          ffi.Pointer<JFloatMarker> elems, DartJIntMarker mode) =>
       _ReleaseFloatArrayElements(array, elems, mode).check();
 
   late final _ReleaseDoubleArrayElements = ptr.ref.ReleaseDoubleArrayElements
       .asFunction<
           JThrowablePtr Function(JDoubleArrayPtr array,
-              ffi.Pointer<JDoubleMarker> elems, int mode)>();
+              ffi.Pointer<JDoubleMarker> elems, DartJIntMarker mode)>();
 
-  void ReleaseDoubleArrayElements(
-          JDoubleArrayPtr array, ffi.Pointer<JDoubleMarker> elems, int mode) =>
+  void ReleaseDoubleArrayElements(JDoubleArrayPtr array,
+          ffi.Pointer<JDoubleMarker> elems, DartJIntMarker mode) =>
       _ReleaseDoubleArrayElements(array, elems, mode).check();
 
   late final _GetBooleanArrayRegion = ptr.ref.GetBooleanArrayRegion.asFunction<
-      JThrowablePtr Function(JBooleanArrayPtr array, int start, int len,
-          ffi.Pointer<JBooleanMarker> buf)>();
+      JThrowablePtr Function(JBooleanArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JBooleanMarker> buf)>();
 
-  void GetBooleanArrayRegion(JBooleanArrayPtr array, int start, int len,
-          ffi.Pointer<JBooleanMarker> buf) =>
+  void GetBooleanArrayRegion(JBooleanArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JBooleanMarker> buf) =>
       _GetBooleanArrayRegion(array, start, len, buf).check();
 
   late final _GetByteArrayRegion = ptr.ref.GetByteArrayRegion.asFunction<
-      JThrowablePtr Function(JByteArrayPtr array, int start, int len,
-          ffi.Pointer<JByteMarker> buf)>();
+      JThrowablePtr Function(JByteArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JByteMarker> buf)>();
 
-  void GetByteArrayRegion(JByteArrayPtr array, int start, int len,
-          ffi.Pointer<JByteMarker> buf) =>
+  void GetByteArrayRegion(JByteArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JByteMarker> buf) =>
       _GetByteArrayRegion(array, start, len, buf).check();
 
   late final _GetCharArrayRegion = ptr.ref.GetCharArrayRegion.asFunction<
-      JThrowablePtr Function(JCharArrayPtr array, int start, int len,
-          ffi.Pointer<JCharMarker> buf)>();
+      JThrowablePtr Function(JCharArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JCharMarker> buf)>();
 
-  void GetCharArrayRegion(JCharArrayPtr array, int start, int len,
-          ffi.Pointer<JCharMarker> buf) =>
+  void GetCharArrayRegion(JCharArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JCharMarker> buf) =>
       _GetCharArrayRegion(array, start, len, buf).check();
 
   late final _GetShortArrayRegion = ptr.ref.GetShortArrayRegion.asFunction<
-      JThrowablePtr Function(JShortArrayPtr array, int start, int len,
-          ffi.Pointer<JShortMarker> buf)>();
+      JThrowablePtr Function(JShortArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JShortMarker> buf)>();
 
-  void GetShortArrayRegion(JShortArrayPtr array, int start, int len,
-          ffi.Pointer<JShortMarker> buf) =>
+  void GetShortArrayRegion(JShortArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JShortMarker> buf) =>
       _GetShortArrayRegion(array, start, len, buf).check();
 
   late final _GetIntArrayRegion = ptr.ref.GetIntArrayRegion.asFunction<
-      JThrowablePtr Function(JIntArrayPtr array, int start, int len,
-          ffi.Pointer<JIntMarker> buf)>();
+      JThrowablePtr Function(JIntArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JIntMarker> buf)>();
 
-  void GetIntArrayRegion(JIntArrayPtr array, int start, int len,
-          ffi.Pointer<JIntMarker> buf) =>
+  void GetIntArrayRegion(JIntArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JIntMarker> buf) =>
       _GetIntArrayRegion(array, start, len, buf).check();
 
   late final _GetLongArrayRegion = ptr.ref.GetLongArrayRegion.asFunction<
-      JThrowablePtr Function(JLongArrayPtr array, int start, int len,
-          ffi.Pointer<JLongMarker> buf)>();
+      JThrowablePtr Function(JLongArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JLongMarker> buf)>();
 
-  void GetLongArrayRegion(JLongArrayPtr array, int start, int len,
-          ffi.Pointer<JLongMarker> buf) =>
+  void GetLongArrayRegion(JLongArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JLongMarker> buf) =>
       _GetLongArrayRegion(array, start, len, buf).check();
 
   late final _GetFloatArrayRegion = ptr.ref.GetFloatArrayRegion.asFunction<
-      JThrowablePtr Function(JFloatArrayPtr array, int start, int len,
-          ffi.Pointer<JFloatMarker> buf)>();
+      JThrowablePtr Function(JFloatArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JFloatMarker> buf)>();
 
-  void GetFloatArrayRegion(JFloatArrayPtr array, int start, int len,
-          ffi.Pointer<JFloatMarker> buf) =>
+  void GetFloatArrayRegion(JFloatArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JFloatMarker> buf) =>
       _GetFloatArrayRegion(array, start, len, buf).check();
 
   late final _GetDoubleArrayRegion = ptr.ref.GetDoubleArrayRegion.asFunction<
-      JThrowablePtr Function(JDoubleArrayPtr array, int start, int len,
-          ffi.Pointer<JDoubleMarker> buf)>();
+      JThrowablePtr Function(JDoubleArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JDoubleMarker> buf)>();
 
-  void GetDoubleArrayRegion(JDoubleArrayPtr array, int start, int len,
-          ffi.Pointer<JDoubleMarker> buf) =>
+  void GetDoubleArrayRegion(JDoubleArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JDoubleMarker> buf) =>
       _GetDoubleArrayRegion(array, start, len, buf).check();
 
   late final _SetBooleanArrayRegion = ptr.ref.SetBooleanArrayRegion.asFunction<
-      JThrowablePtr Function(JBooleanArrayPtr array, int start, int len,
-          ffi.Pointer<JBooleanMarker> buf)>();
+      JThrowablePtr Function(JBooleanArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JBooleanMarker> buf)>();
 
-  void SetBooleanArrayRegion(JBooleanArrayPtr array, int start, int len,
-          ffi.Pointer<JBooleanMarker> buf) =>
+  void SetBooleanArrayRegion(JBooleanArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JBooleanMarker> buf) =>
       _SetBooleanArrayRegion(array, start, len, buf).check();
 
   late final _SetByteArrayRegion = ptr.ref.SetByteArrayRegion.asFunction<
-      JThrowablePtr Function(JByteArrayPtr array, int start, int len,
-          ffi.Pointer<JByteMarker> buf)>();
+      JThrowablePtr Function(JByteArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JByteMarker> buf)>();
 
-  void SetByteArrayRegion(JByteArrayPtr array, int start, int len,
-          ffi.Pointer<JByteMarker> buf) =>
+  void SetByteArrayRegion(JByteArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JByteMarker> buf) =>
       _SetByteArrayRegion(array, start, len, buf).check();
 
   late final _SetCharArrayRegion = ptr.ref.SetCharArrayRegion.asFunction<
-      JThrowablePtr Function(JCharArrayPtr array, int start, int len,
-          ffi.Pointer<JCharMarker> buf)>();
+      JThrowablePtr Function(JCharArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JCharMarker> buf)>();
 
-  void SetCharArrayRegion(JCharArrayPtr array, int start, int len,
-          ffi.Pointer<JCharMarker> buf) =>
+  void SetCharArrayRegion(JCharArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JCharMarker> buf) =>
       _SetCharArrayRegion(array, start, len, buf).check();
 
   late final _SetShortArrayRegion = ptr.ref.SetShortArrayRegion.asFunction<
-      JThrowablePtr Function(JShortArrayPtr array, int start, int len,
-          ffi.Pointer<JShortMarker> buf)>();
+      JThrowablePtr Function(JShortArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JShortMarker> buf)>();
 
-  void SetShortArrayRegion(JShortArrayPtr array, int start, int len,
-          ffi.Pointer<JShortMarker> buf) =>
+  void SetShortArrayRegion(JShortArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JShortMarker> buf) =>
       _SetShortArrayRegion(array, start, len, buf).check();
 
   late final _SetIntArrayRegion = ptr.ref.SetIntArrayRegion.asFunction<
-      JThrowablePtr Function(JIntArrayPtr array, int start, int len,
-          ffi.Pointer<JIntMarker> buf)>();
+      JThrowablePtr Function(JIntArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JIntMarker> buf)>();
 
-  void SetIntArrayRegion(JIntArrayPtr array, int start, int len,
-          ffi.Pointer<JIntMarker> buf) =>
+  void SetIntArrayRegion(JIntArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JIntMarker> buf) =>
       _SetIntArrayRegion(array, start, len, buf).check();
 
   late final _SetLongArrayRegion = ptr.ref.SetLongArrayRegion.asFunction<
-      JThrowablePtr Function(JLongArrayPtr array, int start, int len,
-          ffi.Pointer<JLongMarker> buf)>();
+      JThrowablePtr Function(JLongArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JLongMarker> buf)>();
 
-  void SetLongArrayRegion(JLongArrayPtr array, int start, int len,
-          ffi.Pointer<JLongMarker> buf) =>
+  void SetLongArrayRegion(JLongArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JLongMarker> buf) =>
       _SetLongArrayRegion(array, start, len, buf).check();
 
   late final _SetFloatArrayRegion = ptr.ref.SetFloatArrayRegion.asFunction<
-      JThrowablePtr Function(JFloatArrayPtr array, int start, int len,
-          ffi.Pointer<JFloatMarker> buf)>();
+      JThrowablePtr Function(JFloatArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JFloatMarker> buf)>();
 
-  void SetFloatArrayRegion(JFloatArrayPtr array, int start, int len,
-          ffi.Pointer<JFloatMarker> buf) =>
+  void SetFloatArrayRegion(JFloatArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JFloatMarker> buf) =>
       _SetFloatArrayRegion(array, start, len, buf).check();
 
   late final _SetDoubleArrayRegion = ptr.ref.SetDoubleArrayRegion.asFunction<
-      JThrowablePtr Function(JDoubleArrayPtr array, int start, int len,
-          ffi.Pointer<JDoubleMarker> buf)>();
+      JThrowablePtr Function(JDoubleArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JDoubleMarker> buf)>();
 
-  void SetDoubleArrayRegion(JDoubleArrayPtr array, int start, int len,
-          ffi.Pointer<JDoubleMarker> buf) =>
+  void SetDoubleArrayRegion(JDoubleArrayPtr array, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JDoubleMarker> buf) =>
       _SetDoubleArrayRegion(array, start, len, buf).check();
 
   late final _RegisterNatives = ptr.ref.RegisterNatives.asFunction<
       JniResult Function(JClassPtr clazz, ffi.Pointer<JNINativeMethod> methods,
-          int nMethods)>();
+          DartJIntMarker nMethods)>();
 
-  int RegisterNatives(JClassPtr clazz, ffi.Pointer<JNINativeMethod> methods,
-          int nMethods) =>
+  DartJIntMarker RegisterNatives(JClassPtr clazz,
+          ffi.Pointer<JNINativeMethod> methods, DartJIntMarker nMethods) =>
       _RegisterNatives(clazz, methods, nMethods).integer;
 
   late final _UnregisterNatives = ptr.ref.UnregisterNatives
       .asFunction<JniResult Function(JClassPtr clazz)>();
 
-  int UnregisterNatives(JClassPtr clazz) => _UnregisterNatives(clazz).integer;
+  DartJIntMarker UnregisterNatives(JClassPtr clazz) =>
+      _UnregisterNatives(clazz).integer;
 
   late final _MonitorEnter =
       ptr.ref.MonitorEnter.asFunction<JniResult Function(JObjectPtr obj)>();
 
-  int MonitorEnter(JObjectPtr obj) => _MonitorEnter(obj).integer;
+  DartJIntMarker MonitorEnter(JObjectPtr obj) => _MonitorEnter(obj).integer;
 
   late final _MonitorExit =
       ptr.ref.MonitorExit.asFunction<JniResult Function(JObjectPtr obj)>();
 
-  int MonitorExit(JObjectPtr obj) => _MonitorExit(obj).integer;
+  DartJIntMarker MonitorExit(JObjectPtr obj) => _MonitorExit(obj).integer;
 
   late final _GetJavaVM = ptr.ref.GetJavaVM
-      .asFunction<JniResult Function(ffi.Pointer<ffi.Pointer<JavaVM1>> vm)>(
+      .asFunction<JniResult Function(ffi.Pointer<ffi.Pointer<JavaVM>> vm)>(
           isLeaf: true);
 
-  int GetJavaVM(ffi.Pointer<ffi.Pointer<JavaVM1>> vm) => _GetJavaVM(vm).integer;
+  DartJIntMarker GetJavaVM(ffi.Pointer<ffi.Pointer<JavaVM>> vm) =>
+      _GetJavaVM(vm).integer;
 
   late final _GetStringRegion = ptr.ref.GetStringRegion.asFunction<
-      JThrowablePtr Function(
-          JStringPtr str, int start, int len, ffi.Pointer<JCharMarker> buf)>();
+      JThrowablePtr Function(JStringPtr str, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<JCharMarker> buf)>();
 
-  void GetStringRegion(
-          JStringPtr str, int start, int len, ffi.Pointer<JCharMarker> buf) =>
+  void GetStringRegion(JStringPtr str, DartJIntMarker start, DartJIntMarker len,
+          ffi.Pointer<JCharMarker> buf) =>
       _GetStringRegion(str, start, len, buf).check();
 
   late final _GetStringUTFRegion = ptr.ref.GetStringUTFRegion.asFunction<
-      JThrowablePtr Function(
-          JStringPtr str, int start, int len, ffi.Pointer<ffi.Char> buf)>();
+      JThrowablePtr Function(JStringPtr str, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<ffi.Char> buf)>();
 
-  void GetStringUTFRegion(
-          JStringPtr str, int start, int len, ffi.Pointer<ffi.Char> buf) =>
+  void GetStringUTFRegion(JStringPtr str, DartJIntMarker start,
+          DartJIntMarker len, ffi.Pointer<ffi.Char> buf) =>
       _GetStringUTFRegion(str, start, len, buf).check();
 
   late final _GetPrimitiveArrayCritical = ptr.ref.GetPrimitiveArrayCritical
@@ -1401,11 +1437,11 @@ class GlobalJniEnv {
 
   late final _ReleasePrimitiveArrayCritical =
       ptr.ref.ReleasePrimitiveArrayCritical.asFunction<
-          JThrowablePtr Function(
-              JArrayPtr array, ffi.Pointer<ffi.Void> carray, int mode)>();
+          JThrowablePtr Function(JArrayPtr array, ffi.Pointer<ffi.Void> carray,
+              DartJIntMarker mode)>();
 
   void ReleasePrimitiveArrayCritical(
-          JArrayPtr array, ffi.Pointer<ffi.Void> carray, int mode) =>
+          JArrayPtr array, ffi.Pointer<ffi.Void> carray, DartJIntMarker mode) =>
       _ReleasePrimitiveArrayCritical(array, carray, mode).check();
 
   late final _GetStringCritical = ptr.ref.GetStringCritical.asFunction<
@@ -1440,9 +1476,11 @@ class GlobalJniEnv {
   bool ExceptionCheck() => _ExceptionCheck().boolean;
 
   late final _NewDirectByteBuffer = ptr.ref.NewDirectByteBuffer.asFunction<
-      JniResult Function(ffi.Pointer<ffi.Void> address, int capacity)>();
+      JniResult Function(
+          ffi.Pointer<ffi.Void> address, DartJLongMarker capacity)>();
 
-  JObjectPtr NewDirectByteBuffer(ffi.Pointer<ffi.Void> address, int capacity) =>
+  JObjectPtr NewDirectByteBuffer(
+          ffi.Pointer<ffi.Void> address, DartJLongMarker capacity) =>
       _NewDirectByteBuffer(address, capacity).objectPointer;
 
   late final _GetDirectBufferAddress = ptr.ref.GetDirectBufferAddress
@@ -1454,13 +1492,14 @@ class GlobalJniEnv {
   late final _GetDirectBufferCapacity = ptr.ref.GetDirectBufferCapacity
       .asFunction<JniResult Function(JObjectPtr buf)>(isLeaf: true);
 
-  int GetDirectBufferCapacity(JObjectPtr buf) =>
+  DartJLongMarker GetDirectBufferCapacity(JObjectPtr buf) =>
       _GetDirectBufferCapacity(buf).long;
 
   late final _GetObjectRefType = ptr.ref.GetObjectRefType
       .asFunction<JniResult Function(JObjectPtr obj)>(isLeaf: true);
 
-  int GetObjectRefType(JObjectPtr obj) => _GetObjectRefType(obj).integer;
+  JObjectRefType GetObjectRefType(JObjectPtr obj) =>
+      _GetObjectRefType(obj).referenceType;
 
   late final _GetBooleanArrayElement = ptr.ref.GetBooleanArrayElement
       .asFunction<JniResult Function(JBooleanArrayPtr array, int index)>(
diff --git a/pkgs/jni/lib/src/third_party/jni_bindings_generated.dart b/pkgs/jni/lib/src/third_party/jni_bindings_generated.dart
index e970cbe4b..6462c56a4 100644
--- a/pkgs/jni/lib/src/third_party/jni_bindings_generated.dart
+++ b/pkgs/jni/lib/src/third_party/jni_bindings_generated.dart
@@ -66,9 +66,9 @@ class JniBindings {
   late final ffi.Pointer<pthread_key_t> _tlsKey =
       _lookup<pthread_key_t>('tlsKey');
 
-  int get tlsKey => _tlsKey.value;
+  Dart__darwin_pthread_key_t get tlsKey => _tlsKey.value;
 
-  set tlsKey(int value) => _tlsKey.value = value;
+  set tlsKey(Dart__darwin_pthread_key_t value) => _tlsKey.value = value;
 
   JniClassLookupResult FindClass(
     ffi.Pointer<ffi.Char> name,
@@ -98,35 +98,35 @@ class JniBindings {
   late final _GetExceptionDetails = _GetExceptionDetailsPtr.asFunction<
       JniExceptionDetails Function(JThrowablePtr)>();
 
-  ffi.Pointer<JavaVM> GetJavaVM() {
+  ffi.Pointer<JavaVM1> GetJavaVM() {
     return _GetJavaVM();
   }
 
   late final _GetJavaVMPtr =
-      _lookup<ffi.NativeFunction<ffi.Pointer<JavaVM> Function()>>('GetJavaVM');
+      _lookup<ffi.NativeFunction<ffi.Pointer<JavaVM1> Function()>>('GetJavaVM');
   late final _GetJavaVM =
-      _GetJavaVMPtr.asFunction<ffi.Pointer<JavaVM> Function()>();
+      _GetJavaVMPtr.asFunction<ffi.Pointer<JavaVM1> Function()>();
 
-  ffi.Pointer<JniEnv> GetJniEnv() {
+  ffi.Pointer<JniEnv1> GetJniEnv() {
     return _GetJniEnv();
   }
 
   late final _GetJniEnvPtr =
-      _lookup<ffi.NativeFunction<ffi.Pointer<JniEnv> Function()>>('GetJniEnv');
+      _lookup<ffi.NativeFunction<ffi.Pointer<JniEnv1> Function()>>('GetJniEnv');
   late final _GetJniEnv =
-      _GetJniEnvPtr.asFunction<ffi.Pointer<JniEnv> Function()>();
+      _GetJniEnvPtr.asFunction<ffi.Pointer<JniEnv1> Function()>();
 
   /// Spawn a JVM with given arguments.
   ///
   /// Returns JNI_OK on success, and one of the documented JNI error codes on
   /// failure. It returns DART_JNI_SINGLETON_EXISTS if an attempt to spawn multiple
   /// JVMs is made, even if the underlying API potentially supports multiple VMs.
-  int SpawnJvm(
+  JniErrorCode SpawnJvm(
     ffi.Pointer<JavaVMInitArgs> args,
   ) {
-    return _SpawnJvm(
+    return JniErrorCode.fromValue(_SpawnJvm(
       args,
-    );
+    ));
   }
 
   late final _SpawnJvmPtr = _lookup<
@@ -244,19 +244,19 @@ class JniBindings {
   Dart_FinalizableHandle newJObjectFinalizableHandle(
     Object object,
     JObjectPtr reference,
-    int refType,
+    JObjectRefType refType,
   ) {
     return _newJObjectFinalizableHandle(
       object,
       reference,
-      refType,
+      refType.value,
     );
   }
 
   late final _newJObjectFinalizableHandlePtr = _lookup<
       ffi.NativeFunction<
           Dart_FinalizableHandle Function(ffi.Handle, JObjectPtr,
-              ffi.Int32)>>('newJObjectFinalizableHandle');
+              ffi.UnsignedInt)>>('newJObjectFinalizableHandle');
   late final _newJObjectFinalizableHandle = _newJObjectFinalizableHandlePtr
       .asFunction<Dart_FinalizableHandle Function(Object, JObjectPtr, int)>();
 
@@ -306,33 +306,186 @@ class JniBindings {
       _GetGlobalEnvPtr.asFunction<ffi.Pointer<GlobalJniEnvStruct> Function()>();
 }
 
-typedef pthread_key_t = __darwin_pthread_key_t;
-typedef __darwin_pthread_key_t = ffi.UnsignedLong;
+enum JniBooleanValues {
+  FALSE(0),
+  TRUE(1);
 
-/// Types used by JNI API to distinguish between primitive types.
-abstract class JniCallType {
-  static const int booleanType = 0;
-  static const int byteType = 1;
-  static const int shortType = 2;
-  static const int charType = 3;
-  static const int intType = 4;
-  static const int longType = 5;
-  static const int floatType = 6;
-  static const int doubleType = 7;
-  static const int objectType = 8;
-  static const int voidType = 9;
+  final int value;
+  const JniBooleanValues(this.value);
+
+  static JniBooleanValues fromValue(int value) => switch (value) {
+        0 => FALSE,
+        1 => TRUE,
+        _ => throw ArgumentError("Unknown value for JniBooleanValues: $value"),
+      };
 }
 
-/// Result type for use by JNI.
-///
-/// If [exception] is null, it means the result is valid.
-/// It's assumed that the caller knows the expected type in [result].
-final class JniResult extends ffi.Struct {
-  external JValue value;
+enum JniVersions {
+  VERSION_1_1(65537),
+  VERSION_1_2(65538),
+  VERSION_1_4(65540),
+  VERSION_1_6(65542);
+
+  final int value;
+  const JniVersions(this.value);
+
+  static JniVersions fromValue(int value) => switch (value) {
+        65537 => VERSION_1_1,
+        65538 => VERSION_1_2,
+        65540 => VERSION_1_4,
+        65542 => VERSION_1_6,
+        _ => throw ArgumentError("Unknown value for JniVersions: $value"),
+      };
+}
 
-  external JThrowablePtr exception;
+enum JniErrorCode {
+  /// no error
+  OK(0),
+
+  /// generic error
+  ERR(-1),
+
+  /// thread detached from the VM
+  EDETACHED(-2),
+
+  /// JNI version error
+  EVERSION(-3),
+
+  /// Out of memory
+  ENOMEM(-4),
+
+  /// VM already created
+  EEXIST(-5),
+
+  /// Invalid argument
+  EINVAL(-6),
+  SINGLETON_EXISTS(-99);
+
+  final int value;
+  const JniErrorCode(this.value);
+
+  static JniErrorCode fromValue(int value) => switch (value) {
+        0 => OK,
+        -1 => ERR,
+        -2 => EDETACHED,
+        -3 => EVERSION,
+        -4 => ENOMEM,
+        -5 => EEXIST,
+        -6 => EINVAL,
+        -99 => SINGLETON_EXISTS,
+        _ => throw ArgumentError("Unknown value for JniErrorCode: $value"),
+      };
+}
+
+enum JniBufferWriteBack {
+  /// copy content, do not free buffer
+  COMMIT(1),
+
+  /// free buffer w/o copying back
+  ABORT(2);
+
+  final int value;
+  const JniBufferWriteBack(this.value);
+
+  static JniBufferWriteBack fromValue(int value) => switch (value) {
+        1 => COMMIT,
+        2 => ABORT,
+        _ =>
+          throw ArgumentError("Unknown value for JniBufferWriteBack: $value"),
+      };
+}
+
+final class _opaque_pthread_mutex_t extends ffi.Struct {
+  @ffi.Long()
+  external int __sig;
+
+  @ffi.Array.multi([56])
+  external ffi.Array<ffi.Char> __opaque;
+}
+
+typedef __darwin_pthread_mutex_t = _opaque_pthread_mutex_t;
+typedef pthread_mutex_t = __darwin_pthread_mutex_t;
+typedef MutexLock = pthread_mutex_t;
+
+final class _opaque_pthread_cond_t extends ffi.Struct {
+  @ffi.Long()
+  external int __sig;
+
+  @ffi.Array.multi([40])
+  external ffi.Array<ffi.Char> __opaque;
 }
 
+typedef __darwin_pthread_cond_t = _opaque_pthread_cond_t;
+typedef pthread_cond_t = __darwin_pthread_cond_t;
+typedef ConditionVariable = pthread_cond_t;
+
+/// Reference types, in C.
+typedef JObjectPtr = ffi.Pointer<ffi.Void>;
+
+final class CallbackResult extends ffi.Struct {
+  external MutexLock lock;
+
+  external ConditionVariable cond;
+
+  @ffi.Int()
+  external int ready;
+
+  external JObjectPtr object;
+}
+
+typedef __darwin_pthread_key_t = ffi.UnsignedLong;
+typedef Dart__darwin_pthread_key_t = int;
+typedef pthread_key_t = __darwin_pthread_key_t;
+
+/// Types used by JNI API to distinguish between primitive types.
+enum JniCallType {
+  booleanType(0),
+  byteType(1),
+  shortType(2),
+  charType(3),
+  intType(4),
+  longType(5),
+  floatType(6),
+  doubleType(7),
+  objectType(8),
+  voidType(9);
+
+  final int value;
+  const JniCallType(this.value);
+
+  static JniCallType fromValue(int value) => switch (value) {
+        0 => booleanType,
+        1 => byteType,
+        2 => shortType,
+        3 => charType,
+        4 => intType,
+        5 => longType,
+        6 => floatType,
+        7 => doubleType,
+        8 => objectType,
+        9 => voidType,
+        _ => throw ArgumentError("Unknown value for JniCallType: $value"),
+      };
+}
+
+/// Primitive types that match up with Java equivalents.
+typedef JBooleanMarker = ffi.Uint8;
+typedef DartJBooleanMarker = int;
+typedef JByteMarker = ffi.Int8;
+typedef DartJByteMarker = int;
+typedef JCharMarker = ffi.Uint16;
+typedef DartJCharMarker = int;
+typedef JShortMarker = ffi.Int16;
+typedef DartJShortMarker = int;
+typedef JIntMarker = ffi.Int32;
+typedef DartJIntMarker = int;
+typedef JLongMarker = ffi.Int64;
+typedef DartJLongMarker = int;
+typedef JFloatMarker = ffi.Float;
+typedef DartJFloatMarker = double;
+typedef JDoubleMarker = ffi.Double;
+typedef DartJDoubleMarker = double;
+
 final class JValue extends ffi.Union {
   @JBooleanMarker()
   external int z;
@@ -361,20 +514,20 @@ final class JValue extends ffi.Union {
   external JObjectPtr l;
 }
 
-/// Primitive types that match up with Java equivalents.
-typedef JBooleanMarker = ffi.Uint8;
-typedef JByteMarker = ffi.Int8;
-typedef JCharMarker = ffi.Uint16;
-typedef JShortMarker = ffi.Int16;
-typedef JIntMarker = ffi.Int32;
-typedef JLongMarker = ffi.Int64;
-typedef JFloatMarker = ffi.Float;
-typedef JDoubleMarker = ffi.Double;
-
-/// Reference types, in C.
-typedef JObjectPtr = ffi.Pointer<ffi.Void>;
 typedef JThrowablePtr = JObjectPtr;
 
+/// Result type for use by JNI.
+///
+/// If [exception] is null, it means the result is valid.
+/// It's assumed that the caller knows the expected type in [result].
+final class JniResult extends ffi.Struct {
+  external JValue value;
+
+  external JThrowablePtr exception;
+}
+
+typedef JClassPtr = JObjectPtr;
+
 /// Similar to [JniResult] but for class lookups.
 final class JniClassLookupResult extends ffi.Struct {
   external JClassPtr value;
@@ -382,8 +535,6 @@ final class JniClassLookupResult extends ffi.Struct {
   external JThrowablePtr exception;
 }
 
-typedef JClassPtr = JObjectPtr;
-
 /// Similar to [JniResult] but for method/field ID lookups.
 final class JniPointerResult extends ffi.Struct {
   external ffi.Pointer<ffi.Void> value;
@@ -391,6 +542,8 @@ final class JniPointerResult extends ffi.Struct {
   external JThrowablePtr exception;
 }
 
+typedef JStringPtr = JObjectPtr;
+
 /// JniExceptionDetails holds 2 jstring objects, one is the result of
 /// calling `toString` on exception object, other is stack trace;
 final class JniExceptionDetails extends ffi.Struct {
@@ -399,49 +552,57 @@ final class JniExceptionDetails extends ffi.Struct {
   external JStringPtr stacktrace;
 }
 
-typedef JStringPtr = JObjectPtr;
 typedef JavaVM = ffi.Pointer<JNIInvokeInterface>;
+typedef JniEnv = ffi.Pointer<JNINativeInterface>;
 
-/// JNI invocation interface.
-final class JNIInvokeInterface extends ffi.Struct {
-  external ffi.Pointer<ffi.Void> reserved0;
+/// "cardinal indices and sizes"
+typedef JSizeMarker = JIntMarker;
 
-  external ffi.Pointer<ffi.Void> reserved1;
+final class jmethodID_ extends ffi.Opaque {}
 
-  external ffi.Pointer<ffi.Void> reserved2;
+typedef JMethodIDPtr = ffi.Pointer<jmethodID_>;
 
-  external ffi
-      .Pointer<ffi.NativeFunction<JIntMarker Function(ffi.Pointer<JavaVM1> vm)>>
-      DestroyJavaVM;
+final class jfieldID_ extends ffi.Opaque {}
 
-  external ffi.Pointer<
-      ffi.NativeFunction<
-          JIntMarker Function(
-              ffi.Pointer<JavaVM1> vm,
-              ffi.Pointer<ffi.Pointer<JniEnv>> p_env,
-              ffi.Pointer<ffi.Void> thr_args)>> AttachCurrentThread;
+typedef JFieldIDPtr = ffi.Pointer<jfieldID_>;
+typedef JArrayPtr = JObjectPtr;
+typedef JObjectArrayPtr = JArrayPtr;
+typedef JBooleanArrayPtr = JArrayPtr;
+typedef JByteArrayPtr = JArrayPtr;
+typedef JCharArrayPtr = JArrayPtr;
+typedef JShortArrayPtr = JArrayPtr;
+typedef JIntArrayPtr = JArrayPtr;
+typedef JLongArrayPtr = JArrayPtr;
+typedef JFloatArrayPtr = JArrayPtr;
+typedef JDoubleArrayPtr = JArrayPtr;
 
-  external ffi
-      .Pointer<ffi.NativeFunction<JIntMarker Function(ffi.Pointer<JavaVM1> vm)>>
-      DetachCurrentThread;
+final class JNINativeMethod extends ffi.Struct {
+  external ffi.Pointer<ffi.Char> name;
 
-  external ffi.Pointer<
-      ffi.NativeFunction<
-          JIntMarker Function(
-              ffi.Pointer<JavaVM1> vm,
-              ffi.Pointer<ffi.Pointer<ffi.Void>> p_env,
-              JIntMarker version)>> GetEnv;
+  external ffi.Pointer<ffi.Char> signature;
 
-  external ffi.Pointer<
-      ffi.NativeFunction<
-          JIntMarker Function(
-              ffi.Pointer<JavaVM1> vm,
-              ffi.Pointer<ffi.Pointer<JniEnv>> p_env,
-              ffi.Pointer<ffi.Void> thr_args)>> AttachCurrentThreadAsDaemon;
+  external ffi.Pointer<ffi.Void> fnPtr;
 }
 
-typedef JavaVM1 = ffi.Pointer<JNIInvokeInterface>;
-typedef JniEnv = ffi.Pointer<JNINativeInterface>;
+typedef JWeakPtr = JObjectPtr;
+
+enum JObjectRefType {
+  JNIInvalidRefType(0),
+  JNILocalRefType(1),
+  JNIGlobalRefType(2),
+  JNIWeakGlobalRefType(3);
+
+  final int value;
+  const JObjectRefType(this.value);
+
+  static JObjectRefType fromValue(int value) => switch (value) {
+        0 => JNIInvalidRefType,
+        1 => JNILocalRefType,
+        2 => JNIGlobalRefType,
+        3 => JNIWeakGlobalRefType,
+        _ => throw ArgumentError("Unknown value for JObjectRefType: $value"),
+      };
+}
 
 /// Table of interface function pointers.
 final class JNINativeInterface extends ffi.Struct {
@@ -453,14 +614,14 @@ final class JNINativeInterface extends ffi.Struct {
 
   external ffi.Pointer<ffi.Void> reserved3;
 
-  external ffi.Pointer<
-          ffi.NativeFunction<JIntMarker Function(ffi.Pointer<JniEnv1> env)>>
+  external ffi
+      .Pointer<ffi.NativeFunction<JIntMarker Function(ffi.Pointer<JniEnv> env)>>
       GetVersion;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JClassPtr Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               ffi.Pointer<ffi.Char> name,
               JObjectPtr loader,
               ffi.Pointer<JByteMarker> buf,
@@ -469,325 +630,325 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           JClassPtr Function(
-              ffi.Pointer<JniEnv1> env, ffi.Pointer<ffi.Char> name)>> FindClass;
+              ffi.Pointer<JniEnv> env, ffi.Pointer<ffi.Char> name)>> FindClass;
 
   external ffi.Pointer<
-          ffi.NativeFunction<
-              JMethodIDPtr Function(
-                  ffi.Pointer<JniEnv1> env, JObjectPtr method)>>
-      FromReflectedMethod;
+      ffi.NativeFunction<
+          JMethodIDPtr Function(
+              ffi.Pointer<JniEnv> env, JObjectPtr method)>> FromReflectedMethod;
 
   external ffi.Pointer<
           ffi.NativeFunction<
-              JFieldIDPtr Function(ffi.Pointer<JniEnv1> env, JObjectPtr field)>>
+              JFieldIDPtr Function(ffi.Pointer<JniEnv> env, JObjectPtr field)>>
       FromReflectedField;
 
   /// spec doesn't show jboolean parameter
   external ffi.Pointer<
       ffi.NativeFunction<
           JObjectPtr Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JClassPtr cls,
               JMethodIDPtr methodId,
               JBooleanMarker isStatic)>> ToReflectedMethod;
 
   external ffi.Pointer<
           ffi.NativeFunction<
-              JClassPtr Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz)>>
+              JClassPtr Function(ffi.Pointer<JniEnv> env, JClassPtr clazz)>>
       GetSuperclass;
 
   external ffi.Pointer<
-      ffi.NativeFunction<
-          JBooleanMarker Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz1,
-              JClassPtr clazz2)>> IsAssignableFrom;
+          ffi.NativeFunction<
+              JBooleanMarker Function(
+                  ffi.Pointer<JniEnv> env, JClassPtr clazz1, JClassPtr clazz2)>>
+      IsAssignableFrom;
 
   /// spec doesn't show jboolean parameter
   external ffi.Pointer<
       ffi.NativeFunction<
-          JObjectPtr Function(ffi.Pointer<JniEnv1> env, JClassPtr cls,
+          JObjectPtr Function(ffi.Pointer<JniEnv> env, JClassPtr cls,
               JFieldIDPtr fieldID, JBooleanMarker isStatic)>> ToReflectedField;
 
   external ffi.Pointer<
           ffi.NativeFunction<
-              JIntMarker Function(ffi.Pointer<JniEnv1> env, JThrowablePtr obj)>>
+              JIntMarker Function(ffi.Pointer<JniEnv> env, JThrowablePtr obj)>>
       Throw;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JIntMarker Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          JIntMarker Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               ffi.Pointer<ffi.Char> message)>> ThrowNew;
 
   external ffi.Pointer<
-          ffi.NativeFunction<JThrowablePtr Function(ffi.Pointer<JniEnv1> env)>>
+          ffi.NativeFunction<JThrowablePtr Function(ffi.Pointer<JniEnv> env)>>
       ExceptionOccurred;
 
   external ffi
-      .Pointer<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<JniEnv1> env)>>
+      .Pointer<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<JniEnv> env)>>
       ExceptionDescribe;
 
   external ffi
-      .Pointer<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<JniEnv1> env)>>
+      .Pointer<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<JniEnv> env)>>
       ExceptionClear;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env, ffi.Pointer<ffi.Char> msg)>> FatalError;
+              ffi.Pointer<JniEnv> env, ffi.Pointer<ffi.Char> msg)>> FatalError;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JIntMarker Function(
-              ffi.Pointer<JniEnv1> env, JIntMarker capacity)>> PushLocalFrame;
+              ffi.Pointer<JniEnv> env, JIntMarker capacity)>> PushLocalFrame;
 
   external ffi.Pointer<
           ffi.NativeFunction<
-              JObjectPtr Function(ffi.Pointer<JniEnv1> env, JObjectPtr result)>>
+              JObjectPtr Function(ffi.Pointer<JniEnv> env, JObjectPtr result)>>
       PopLocalFrame;
 
   external ffi.Pointer<
           ffi.NativeFunction<
-              JObjectPtr Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj)>>
+              JObjectPtr Function(ffi.Pointer<JniEnv> env, JObjectPtr obj)>>
       NewGlobalRef;
 
   external ffi.Pointer<
-      ffi.NativeFunction<
-          ffi.Void Function(
-              ffi.Pointer<JniEnv1> env, JObjectPtr globalRef)>> DeleteGlobalRef;
+          ffi.NativeFunction<
+              ffi.Void Function(ffi.Pointer<JniEnv> env, JObjectPtr globalRef)>>
+      DeleteGlobalRef;
 
   external ffi.Pointer<
           ffi.NativeFunction<
-              ffi.Void Function(ffi.Pointer<JniEnv1> env, JObjectPtr localRef)>>
+              ffi.Void Function(ffi.Pointer<JniEnv> env, JObjectPtr localRef)>>
       DeleteLocalRef;
 
   external ffi.Pointer<
           ffi.NativeFunction<
               JBooleanMarker Function(
-                  ffi.Pointer<JniEnv1> env, JObjectPtr ref1, JObjectPtr ref2)>>
+                  ffi.Pointer<JniEnv> env, JObjectPtr ref1, JObjectPtr ref2)>>
       IsSameObject;
 
   external ffi.Pointer<
           ffi.NativeFunction<
-              JObjectPtr Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj)>>
+              JObjectPtr Function(ffi.Pointer<JniEnv> env, JObjectPtr obj)>>
       NewLocalRef;
 
   external ffi.Pointer<
           ffi.NativeFunction<
               JIntMarker Function(
-                  ffi.Pointer<JniEnv1> env, JIntMarker capacity)>>
+                  ffi.Pointer<JniEnv> env, JIntMarker capacity)>>
       EnsureLocalCapacity;
 
   external ffi.Pointer<
           ffi.NativeFunction<
-              JObjectPtr Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz)>>
+              JObjectPtr Function(ffi.Pointer<JniEnv> env, JClassPtr clazz)>>
       AllocObject;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JObjectPtr Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          JObjectPtr Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JMethodIDPtr methodID)>> NewObject;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JObjectPtr Function(ffi.Pointer<JniEnv1>, JClassPtr, JMethodIDPtr,
+          JObjectPtr Function(ffi.Pointer<JniEnv>, JClassPtr, JMethodIDPtr,
               ffi.Pointer<ffi.Void>)>> NewObjectV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JObjectPtr Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          JObjectPtr Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JMethodIDPtr methodID, ffi.Pointer<JValue> args)>> NewObjectA;
 
   external ffi.Pointer<
           ffi.NativeFunction<
-              JClassPtr Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj)>>
+              JClassPtr Function(ffi.Pointer<JniEnv> env, JObjectPtr obj)>>
       GetObjectClass;
 
   external ffi.Pointer<
           ffi.NativeFunction<
               JBooleanMarker Function(
-                  ffi.Pointer<JniEnv1> env, JObjectPtr obj, JClassPtr clazz)>>
+                  ffi.Pointer<JniEnv> env, JObjectPtr obj, JClassPtr clazz)>>
       IsInstanceOf;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JMethodIDPtr Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JClassPtr clazz,
               ffi.Pointer<ffi.Char> name,
               ffi.Pointer<ffi.Char> sig)>> GetMethodID;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JObjectPtr Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          JObjectPtr Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JMethodIDPtr methodID)>> CallObjectMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JObjectPtr Function(ffi.Pointer<JniEnv1>, JObjectPtr, JMethodIDPtr,
+          JObjectPtr Function(ffi.Pointer<JniEnv>, JObjectPtr, JMethodIDPtr,
               ffi.Pointer<ffi.Void>)>> CallObjectMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JObjectPtr Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JMethodIDPtr methodID,
               ffi.Pointer<JValue> args)>> CallObjectMethodA;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JBooleanMarker Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          JBooleanMarker Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JMethodIDPtr methodID)>> CallBooleanMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JBooleanMarker Function(ffi.Pointer<JniEnv1>, JObjectPtr,
-              JMethodIDPtr, ffi.Pointer<ffi.Void>)>> CallBooleanMethodV;
+          JBooleanMarker Function(ffi.Pointer<JniEnv>, JObjectPtr, JMethodIDPtr,
+              ffi.Pointer<ffi.Void>)>> CallBooleanMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JBooleanMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JMethodIDPtr methodId,
               ffi.Pointer<JValue> args)>> CallBooleanMethodA;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JByteMarker Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          JByteMarker Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JMethodIDPtr methodID)>> CallByteMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JByteMarker Function(ffi.Pointer<JniEnv1>, JObjectPtr, JMethodIDPtr,
+          JByteMarker Function(ffi.Pointer<JniEnv>, JObjectPtr, JMethodIDPtr,
               ffi.Pointer<ffi.Void>)>> CallByteMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JByteMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JMethodIDPtr methodID,
               ffi.Pointer<JValue> args)>> CallByteMethodA;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JCharMarker Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          JCharMarker Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JMethodIDPtr methodID)>> CallCharMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JCharMarker Function(ffi.Pointer<JniEnv1>, JObjectPtr, JMethodIDPtr,
+          JCharMarker Function(ffi.Pointer<JniEnv>, JObjectPtr, JMethodIDPtr,
               ffi.Pointer<ffi.Void>)>> CallCharMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JCharMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JMethodIDPtr methodID,
               ffi.Pointer<JValue> args)>> CallCharMethodA;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JShortMarker Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          JShortMarker Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JMethodIDPtr methodID)>> CallShortMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JShortMarker Function(ffi.Pointer<JniEnv1>, JObjectPtr, JMethodIDPtr,
+          JShortMarker Function(ffi.Pointer<JniEnv>, JObjectPtr, JMethodIDPtr,
               ffi.Pointer<ffi.Void>)>> CallShortMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JShortMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JMethodIDPtr methodID,
               ffi.Pointer<JValue> args)>> CallShortMethodA;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JIntMarker Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          JIntMarker Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JMethodIDPtr methodID)>> CallIntMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JIntMarker Function(ffi.Pointer<JniEnv1>, JObjectPtr, JMethodIDPtr,
+          JIntMarker Function(ffi.Pointer<JniEnv>, JObjectPtr, JMethodIDPtr,
               ffi.Pointer<ffi.Void>)>> CallIntMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JIntMarker Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          JIntMarker Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JMethodIDPtr methodID, ffi.Pointer<JValue> args)>> CallIntMethodA;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JLongMarker Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          JLongMarker Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JMethodIDPtr methodID)>> CallLongMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JLongMarker Function(ffi.Pointer<JniEnv1>, JObjectPtr, JMethodIDPtr,
+          JLongMarker Function(ffi.Pointer<JniEnv>, JObjectPtr, JMethodIDPtr,
               ffi.Pointer<ffi.Void>)>> CallLongMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JLongMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JMethodIDPtr methodID,
               ffi.Pointer<JValue> args)>> CallLongMethodA;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JFloatMarker Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          JFloatMarker Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JMethodIDPtr methodID)>> CallFloatMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JFloatMarker Function(ffi.Pointer<JniEnv1>, JObjectPtr, JMethodIDPtr,
+          JFloatMarker Function(ffi.Pointer<JniEnv>, JObjectPtr, JMethodIDPtr,
               ffi.Pointer<ffi.Void>)>> CallFloatMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JFloatMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JMethodIDPtr methodID,
               ffi.Pointer<JValue> args)>> CallFloatMethodA;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JDoubleMarker Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          JDoubleMarker Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JMethodIDPtr methodID)>> CallDoubleMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JDoubleMarker Function(ffi.Pointer<JniEnv1>, JObjectPtr, JMethodIDPtr,
+          JDoubleMarker Function(ffi.Pointer<JniEnv>, JObjectPtr, JMethodIDPtr,
               ffi.Pointer<ffi.Void>)>> CallDoubleMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JDoubleMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JMethodIDPtr methodID,
               ffi.Pointer<JValue> args)>> CallDoubleMethodA;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          ffi.Void Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JMethodIDPtr methodID)>> CallVoidMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1>, JObjectPtr, JMethodIDPtr,
+          ffi.Void Function(ffi.Pointer<JniEnv>, JObjectPtr, JMethodIDPtr,
               ffi.Pointer<ffi.Void>)>> CallVoidMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JMethodIDPtr methodID,
               ffi.Pointer<JValue> args)>> CallVoidMethodA;
@@ -795,7 +956,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           JObjectPtr Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JClassPtr clazz,
               JMethodIDPtr methodID)>> CallNonvirtualObjectMethod;
@@ -803,7 +964,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           JObjectPtr Function(
-              ffi.Pointer<JniEnv1>,
+              ffi.Pointer<JniEnv>,
               JObjectPtr,
               JClassPtr,
               JMethodIDPtr,
@@ -812,7 +973,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           JObjectPtr Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JClassPtr clazz,
               JMethodIDPtr methodID,
@@ -821,7 +982,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           JBooleanMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JClassPtr clazz,
               JMethodIDPtr methodID)>> CallNonvirtualBooleanMethod;
@@ -829,7 +990,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           JBooleanMarker Function(
-              ffi.Pointer<JniEnv1>,
+              ffi.Pointer<JniEnv>,
               JObjectPtr,
               JClassPtr,
               JMethodIDPtr,
@@ -838,7 +999,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           JBooleanMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JClassPtr clazz,
               JMethodIDPtr methodID,
@@ -847,20 +1008,20 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           JByteMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JClassPtr clazz,
               JMethodIDPtr methodID)>> CallNonvirtualByteMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JByteMarker Function(ffi.Pointer<JniEnv1>, JObjectPtr, JClassPtr,
+          JByteMarker Function(ffi.Pointer<JniEnv>, JObjectPtr, JClassPtr,
               JMethodIDPtr, ffi.Pointer<ffi.Void>)>> CallNonvirtualByteMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JByteMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JClassPtr clazz,
               JMethodIDPtr methodID,
@@ -869,20 +1030,20 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           JCharMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JClassPtr clazz,
               JMethodIDPtr methodID)>> CallNonvirtualCharMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JCharMarker Function(ffi.Pointer<JniEnv1>, JObjectPtr, JClassPtr,
+          JCharMarker Function(ffi.Pointer<JniEnv>, JObjectPtr, JClassPtr,
               JMethodIDPtr, ffi.Pointer<ffi.Void>)>> CallNonvirtualCharMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JCharMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JClassPtr clazz,
               JMethodIDPtr methodID,
@@ -891,20 +1052,20 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           JShortMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JClassPtr clazz,
               JMethodIDPtr methodID)>> CallNonvirtualShortMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JShortMarker Function(ffi.Pointer<JniEnv1>, JObjectPtr, JClassPtr,
+          JShortMarker Function(ffi.Pointer<JniEnv>, JObjectPtr, JClassPtr,
               JMethodIDPtr, ffi.Pointer<ffi.Void>)>> CallNonvirtualShortMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JShortMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JClassPtr clazz,
               JMethodIDPtr methodID,
@@ -912,18 +1073,18 @@ final class JNINativeInterface extends ffi.Struct {
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JIntMarker Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          JIntMarker Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JClassPtr clazz, JMethodIDPtr methodID)>> CallNonvirtualIntMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JIntMarker Function(ffi.Pointer<JniEnv1>, JObjectPtr, JClassPtr,
+          JIntMarker Function(ffi.Pointer<JniEnv>, JObjectPtr, JClassPtr,
               JMethodIDPtr, ffi.Pointer<ffi.Void>)>> CallNonvirtualIntMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JIntMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JClassPtr clazz,
               JMethodIDPtr methodID,
@@ -932,20 +1093,20 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           JLongMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JClassPtr clazz,
               JMethodIDPtr methodID)>> CallNonvirtualLongMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JLongMarker Function(ffi.Pointer<JniEnv1>, JObjectPtr, JClassPtr,
+          JLongMarker Function(ffi.Pointer<JniEnv>, JObjectPtr, JClassPtr,
               JMethodIDPtr, ffi.Pointer<ffi.Void>)>> CallNonvirtualLongMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JLongMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JClassPtr clazz,
               JMethodIDPtr methodID,
@@ -954,20 +1115,20 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           JFloatMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JClassPtr clazz,
               JMethodIDPtr methodID)>> CallNonvirtualFloatMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JFloatMarker Function(ffi.Pointer<JniEnv1>, JObjectPtr, JClassPtr,
+          JFloatMarker Function(ffi.Pointer<JniEnv>, JObjectPtr, JClassPtr,
               JMethodIDPtr, ffi.Pointer<ffi.Void>)>> CallNonvirtualFloatMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JFloatMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JClassPtr clazz,
               JMethodIDPtr methodID,
@@ -976,7 +1137,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           JDoubleMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JClassPtr clazz,
               JMethodIDPtr methodID)>> CallNonvirtualDoubleMethod;
@@ -984,7 +1145,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           JDoubleMarker Function(
-              ffi.Pointer<JniEnv1>,
+              ffi.Pointer<JniEnv>,
               JObjectPtr,
               JClassPtr,
               JMethodIDPtr,
@@ -993,7 +1154,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           JDoubleMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JClassPtr clazz,
               JMethodIDPtr methodID,
@@ -1002,20 +1163,20 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JClassPtr clazz,
               JMethodIDPtr methodID)>> CallNonvirtualVoidMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1>, JObjectPtr, JClassPtr,
+          ffi.Void Function(ffi.Pointer<JniEnv>, JObjectPtr, JClassPtr,
               JMethodIDPtr, ffi.Pointer<ffi.Void>)>> CallNonvirtualVoidMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JObjectPtr obj,
               JClassPtr clazz,
               JMethodIDPtr methodID,
@@ -1024,285 +1185,285 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           JFieldIDPtr Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JClassPtr clazz,
               ffi.Pointer<ffi.Char> name,
               ffi.Pointer<ffi.Char> sig)>> GetFieldID;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JObjectPtr Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          JObjectPtr Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JFieldIDPtr fieldID)>> GetObjectField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JBooleanMarker Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          JBooleanMarker Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JFieldIDPtr fieldID)>> GetBooleanField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JByteMarker Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          JByteMarker Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JFieldIDPtr fieldID)>> GetByteField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JCharMarker Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          JCharMarker Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JFieldIDPtr fieldID)>> GetCharField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JShortMarker Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          JShortMarker Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JFieldIDPtr fieldID)>> GetShortField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JIntMarker Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          JIntMarker Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JFieldIDPtr fieldID)>> GetIntField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JLongMarker Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          JLongMarker Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JFieldIDPtr fieldID)>> GetLongField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JFloatMarker Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          JFloatMarker Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JFieldIDPtr fieldID)>> GetFloatField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JDoubleMarker Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          JDoubleMarker Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JFieldIDPtr fieldID)>> GetDoubleField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          ffi.Void Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JFieldIDPtr fieldID, JObjectPtr val)>> SetObjectField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          ffi.Void Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JFieldIDPtr fieldID, JBooleanMarker val)>> SetBooleanField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          ffi.Void Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JFieldIDPtr fieldID, JByteMarker val)>> SetByteField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          ffi.Void Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JFieldIDPtr fieldID, JCharMarker val)>> SetCharField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          ffi.Void Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JFieldIDPtr fieldID, JShortMarker val)>> SetShortField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          ffi.Void Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JFieldIDPtr fieldID, JIntMarker val)>> SetIntField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          ffi.Void Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JFieldIDPtr fieldID, JLongMarker val)>> SetLongField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          ffi.Void Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JFieldIDPtr fieldID, JFloatMarker val)>> SetFloatField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
+          ffi.Void Function(ffi.Pointer<JniEnv> env, JObjectPtr obj,
               JFieldIDPtr fieldID, JDoubleMarker val)>> SetDoubleField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JMethodIDPtr Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JClassPtr clazz,
               ffi.Pointer<ffi.Char> name,
               ffi.Pointer<ffi.Char> sig)>> GetStaticMethodID;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JObjectPtr Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          JObjectPtr Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JMethodIDPtr methodID)>> CallStaticObjectMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JObjectPtr Function(ffi.Pointer<JniEnv1>, JClassPtr, JMethodIDPtr,
+          JObjectPtr Function(ffi.Pointer<JniEnv>, JClassPtr, JMethodIDPtr,
               ffi.Pointer<ffi.Void>)>> CallStaticObjectMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JObjectPtr Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JClassPtr clazz,
               JMethodIDPtr methodID,
               ffi.Pointer<JValue> args)>> CallStaticObjectMethodA;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JBooleanMarker Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          JBooleanMarker Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JMethodIDPtr methodID)>> CallStaticBooleanMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JBooleanMarker Function(ffi.Pointer<JniEnv1>, JClassPtr, JMethodIDPtr,
+          JBooleanMarker Function(ffi.Pointer<JniEnv>, JClassPtr, JMethodIDPtr,
               ffi.Pointer<ffi.Void>)>> CallStaticBooleanMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JBooleanMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JClassPtr clazz,
               JMethodIDPtr methodID,
               ffi.Pointer<JValue> args)>> CallStaticBooleanMethodA;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JByteMarker Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          JByteMarker Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JMethodIDPtr methodID)>> CallStaticByteMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JByteMarker Function(ffi.Pointer<JniEnv1>, JClassPtr, JMethodIDPtr,
+          JByteMarker Function(ffi.Pointer<JniEnv>, JClassPtr, JMethodIDPtr,
               ffi.Pointer<ffi.Void>)>> CallStaticByteMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JByteMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JClassPtr clazz,
               JMethodIDPtr methodID,
               ffi.Pointer<JValue> args)>> CallStaticByteMethodA;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JCharMarker Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          JCharMarker Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JMethodIDPtr methodID)>> CallStaticCharMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JCharMarker Function(ffi.Pointer<JniEnv1>, JClassPtr, JMethodIDPtr,
+          JCharMarker Function(ffi.Pointer<JniEnv>, JClassPtr, JMethodIDPtr,
               ffi.Pointer<ffi.Void>)>> CallStaticCharMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JCharMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JClassPtr clazz,
               JMethodIDPtr methodID,
               ffi.Pointer<JValue> args)>> CallStaticCharMethodA;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JShortMarker Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          JShortMarker Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JMethodIDPtr methodID)>> CallStaticShortMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JShortMarker Function(ffi.Pointer<JniEnv1>, JClassPtr, JMethodIDPtr,
+          JShortMarker Function(ffi.Pointer<JniEnv>, JClassPtr, JMethodIDPtr,
               ffi.Pointer<ffi.Void>)>> CallStaticShortMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JShortMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JClassPtr clazz,
               JMethodIDPtr methodID,
               ffi.Pointer<JValue> args)>> CallStaticShortMethodA;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JIntMarker Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          JIntMarker Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JMethodIDPtr methodID)>> CallStaticIntMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JIntMarker Function(ffi.Pointer<JniEnv1>, JClassPtr, JMethodIDPtr,
+          JIntMarker Function(ffi.Pointer<JniEnv>, JClassPtr, JMethodIDPtr,
               ffi.Pointer<ffi.Void>)>> CallStaticIntMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JIntMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JClassPtr clazz,
               JMethodIDPtr methodID,
               ffi.Pointer<JValue> args)>> CallStaticIntMethodA;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JLongMarker Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          JLongMarker Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JMethodIDPtr methodID)>> CallStaticLongMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JLongMarker Function(ffi.Pointer<JniEnv1>, JClassPtr, JMethodIDPtr,
+          JLongMarker Function(ffi.Pointer<JniEnv>, JClassPtr, JMethodIDPtr,
               ffi.Pointer<ffi.Void>)>> CallStaticLongMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JLongMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JClassPtr clazz,
               JMethodIDPtr methodID,
               ffi.Pointer<JValue> args)>> CallStaticLongMethodA;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JFloatMarker Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          JFloatMarker Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JMethodIDPtr methodID)>> CallStaticFloatMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JFloatMarker Function(ffi.Pointer<JniEnv1>, JClassPtr, JMethodIDPtr,
+          JFloatMarker Function(ffi.Pointer<JniEnv>, JClassPtr, JMethodIDPtr,
               ffi.Pointer<ffi.Void>)>> CallStaticFloatMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JFloatMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JClassPtr clazz,
               JMethodIDPtr methodID,
               ffi.Pointer<JValue> args)>> CallStaticFloatMethodA;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JDoubleMarker Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          JDoubleMarker Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JMethodIDPtr methodID)>> CallStaticDoubleMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JDoubleMarker Function(ffi.Pointer<JniEnv1>, JClassPtr, JMethodIDPtr,
+          JDoubleMarker Function(ffi.Pointer<JniEnv>, JClassPtr, JMethodIDPtr,
               ffi.Pointer<ffi.Void>)>> CallStaticDoubleMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JDoubleMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JClassPtr clazz,
               JMethodIDPtr methodID,
               ffi.Pointer<JValue> args)>> CallStaticDoubleMethodA;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          ffi.Void Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JMethodIDPtr methodID)>> CallStaticVoidMethod;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1>, JClassPtr, JMethodIDPtr,
+          ffi.Void Function(ffi.Pointer<JniEnv>, JClassPtr, JMethodIDPtr,
               ffi.Pointer<ffi.Void>)>> CallStaticVoidMethodV;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JClassPtr clazz,
               JMethodIDPtr methodID,
               ffi.Pointer<JValue> args)>> CallStaticVoidMethodA;
@@ -1310,271 +1471,271 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           JFieldIDPtr Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JClassPtr clazz,
               ffi.Pointer<ffi.Char> name,
               ffi.Pointer<ffi.Char> sig)>> GetStaticFieldID;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JObjectPtr Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          JObjectPtr Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JFieldIDPtr fieldID)>> GetStaticObjectField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JBooleanMarker Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          JBooleanMarker Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JFieldIDPtr fieldID)>> GetStaticBooleanField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JByteMarker Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          JByteMarker Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JFieldIDPtr fieldID)>> GetStaticByteField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JCharMarker Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          JCharMarker Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JFieldIDPtr fieldID)>> GetStaticCharField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JShortMarker Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          JShortMarker Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JFieldIDPtr fieldID)>> GetStaticShortField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JIntMarker Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          JIntMarker Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JFieldIDPtr fieldID)>> GetStaticIntField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JLongMarker Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          JLongMarker Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JFieldIDPtr fieldID)>> GetStaticLongField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JFloatMarker Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          JFloatMarker Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JFieldIDPtr fieldID)>> GetStaticFloatField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JDoubleMarker Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          JDoubleMarker Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JFieldIDPtr fieldID)>> GetStaticDoubleField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          ffi.Void Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JFieldIDPtr fieldID, JObjectPtr val)>> SetStaticObjectField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          ffi.Void Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JFieldIDPtr fieldID, JBooleanMarker val)>> SetStaticBooleanField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          ffi.Void Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JFieldIDPtr fieldID, JByteMarker val)>> SetStaticByteField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          ffi.Void Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JFieldIDPtr fieldID, JCharMarker val)>> SetStaticCharField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          ffi.Void Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JFieldIDPtr fieldID, JShortMarker val)>> SetStaticShortField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          ffi.Void Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JFieldIDPtr fieldID, JIntMarker val)>> SetStaticIntField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          ffi.Void Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JFieldIDPtr fieldID, JLongMarker val)>> SetStaticLongField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          ffi.Void Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JFieldIDPtr fieldID, JFloatMarker val)>> SetStaticFloatField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
+          ffi.Void Function(ffi.Pointer<JniEnv> env, JClassPtr clazz,
               JFieldIDPtr fieldID, JDoubleMarker val)>> SetStaticDoubleField;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JStringPtr Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               ffi.Pointer<JCharMarker> unicodeChars,
               JSizeMarker len)>> NewString;
 
   external ffi.Pointer<
-      ffi.NativeFunction<
-          JSizeMarker Function(
-              ffi.Pointer<JniEnv1> env, JStringPtr string)>> GetStringLength;
+          ffi.NativeFunction<
+              JSizeMarker Function(ffi.Pointer<JniEnv> env, JStringPtr string)>>
+      GetStringLength;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Pointer<JCharMarker> Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JStringPtr string,
               ffi.Pointer<JBooleanMarker> isCopy)>> GetStringChars;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1> env, JStringPtr string,
+          ffi.Void Function(ffi.Pointer<JniEnv> env, JStringPtr string,
               ffi.Pointer<JCharMarker> isCopy)>> ReleaseStringChars;
 
   external ffi.Pointer<
           ffi.NativeFunction<
               JStringPtr Function(
-                  ffi.Pointer<JniEnv1> env, ffi.Pointer<ffi.Char> bytes)>>
+                  ffi.Pointer<JniEnv> env, ffi.Pointer<ffi.Char> bytes)>>
       NewStringUTF;
 
   external ffi.Pointer<
-      ffi.NativeFunction<
-          JSizeMarker Function(
-              ffi.Pointer<JniEnv1> env, JStringPtr string)>> GetStringUTFLength;
+          ffi.NativeFunction<
+              JSizeMarker Function(ffi.Pointer<JniEnv> env, JStringPtr string)>>
+      GetStringUTFLength;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Pointer<ffi.Char> Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JStringPtr string,
               ffi.Pointer<JBooleanMarker> isCopy)>> GetStringUTFChars;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1> env, JStringPtr string,
+          ffi.Void Function(ffi.Pointer<JniEnv> env, JStringPtr string,
               ffi.Pointer<ffi.Char> utf)>> ReleaseStringUTFChars;
 
   external ffi.Pointer<
           ffi.NativeFunction<
-              JSizeMarker Function(ffi.Pointer<JniEnv1> env, JArrayPtr array)>>
+              JSizeMarker Function(ffi.Pointer<JniEnv> env, JArrayPtr array)>>
       GetArrayLength;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JObjectArrayPtr Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JSizeMarker length,
               JClassPtr elementClass,
               JObjectPtr initialElement)>> NewObjectArray;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JObjectPtr Function(ffi.Pointer<JniEnv1> env, JObjectArrayPtr array,
+          JObjectPtr Function(ffi.Pointer<JniEnv> env, JObjectArrayPtr array,
               JSizeMarker index)>> GetObjectArrayElement;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1> env, JObjectArrayPtr array,
+          ffi.Void Function(ffi.Pointer<JniEnv> env, JObjectArrayPtr array,
               JSizeMarker index, JObjectPtr val)>> SetObjectArrayElement;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JBooleanArrayPtr Function(
-              ffi.Pointer<JniEnv1> env, JSizeMarker length)>> NewBooleanArray;
+              ffi.Pointer<JniEnv> env, JSizeMarker length)>> NewBooleanArray;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JByteArrayPtr Function(
-              ffi.Pointer<JniEnv1> env, JSizeMarker length)>> NewByteArray;
+              ffi.Pointer<JniEnv> env, JSizeMarker length)>> NewByteArray;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JCharArrayPtr Function(
-              ffi.Pointer<JniEnv1> env, JSizeMarker length)>> NewCharArray;
+              ffi.Pointer<JniEnv> env, JSizeMarker length)>> NewCharArray;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JShortArrayPtr Function(
-              ffi.Pointer<JniEnv1> env, JSizeMarker length)>> NewShortArray;
+              ffi.Pointer<JniEnv> env, JSizeMarker length)>> NewShortArray;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JIntArrayPtr Function(
-              ffi.Pointer<JniEnv1> env, JSizeMarker length)>> NewIntArray;
+              ffi.Pointer<JniEnv> env, JSizeMarker length)>> NewIntArray;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JLongArrayPtr Function(
-              ffi.Pointer<JniEnv1> env, JSizeMarker length)>> NewLongArray;
+              ffi.Pointer<JniEnv> env, JSizeMarker length)>> NewLongArray;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JFloatArrayPtr Function(
-              ffi.Pointer<JniEnv1> env, JSizeMarker length)>> NewFloatArray;
+              ffi.Pointer<JniEnv> env, JSizeMarker length)>> NewFloatArray;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JDoubleArrayPtr Function(
-              ffi.Pointer<JniEnv1> env, JSizeMarker length)>> NewDoubleArray;
+              ffi.Pointer<JniEnv> env, JSizeMarker length)>> NewDoubleArray;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Pointer<JBooleanMarker> Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JBooleanArrayPtr array,
               ffi.Pointer<JBooleanMarker> isCopy)>> GetBooleanArrayElements;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Pointer<JByteMarker> Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JByteArrayPtr array,
               ffi.Pointer<JBooleanMarker> isCopy)>> GetByteArrayElements;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Pointer<JCharMarker> Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JCharArrayPtr array,
               ffi.Pointer<JBooleanMarker> isCopy)>> GetCharArrayElements;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Pointer<JShortMarker> Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JShortArrayPtr array,
               ffi.Pointer<JBooleanMarker> isCopy)>> GetShortArrayElements;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Pointer<JIntMarker> Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JIntArrayPtr array,
               ffi.Pointer<JBooleanMarker> isCopy)>> GetIntArrayElements;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Pointer<JLongMarker> Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JLongArrayPtr array,
               ffi.Pointer<JBooleanMarker> isCopy)>> GetLongArrayElements;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Pointer<JFloatMarker> Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JFloatArrayPtr array,
               ffi.Pointer<JBooleanMarker> isCopy)>> GetFloatArrayElements;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Pointer<JDoubleMarker> Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JDoubleArrayPtr array,
               ffi.Pointer<JBooleanMarker> isCopy)>> GetDoubleArrayElements;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JBooleanArrayPtr array,
               ffi.Pointer<JBooleanMarker> elems,
               JIntMarker mode)>> ReleaseBooleanArrayElements;
@@ -1582,7 +1743,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JByteArrayPtr array,
               ffi.Pointer<JByteMarker> elems,
               JIntMarker mode)>> ReleaseByteArrayElements;
@@ -1590,7 +1751,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JCharArrayPtr array,
               ffi.Pointer<JCharMarker> elems,
               JIntMarker mode)>> ReleaseCharArrayElements;
@@ -1598,7 +1759,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JShortArrayPtr array,
               ffi.Pointer<JShortMarker> elems,
               JIntMarker mode)>> ReleaseShortArrayElements;
@@ -1606,7 +1767,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JIntArrayPtr array,
               ffi.Pointer<JIntMarker> elems,
               JIntMarker mode)>> ReleaseIntArrayElements;
@@ -1614,7 +1775,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JLongArrayPtr array,
               ffi.Pointer<JLongMarker> elems,
               JIntMarker mode)>> ReleaseLongArrayElements;
@@ -1622,7 +1783,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JFloatArrayPtr array,
               ffi.Pointer<JFloatMarker> elems,
               JIntMarker mode)>> ReleaseFloatArrayElements;
@@ -1630,7 +1791,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JDoubleArrayPtr array,
               ffi.Pointer<JDoubleMarker> elems,
               JIntMarker mode)>> ReleaseDoubleArrayElements;
@@ -1638,7 +1799,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JBooleanArrayPtr array,
               JSizeMarker start,
               JSizeMarker len,
@@ -1647,7 +1808,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JByteArrayPtr array,
               JSizeMarker start,
               JSizeMarker len,
@@ -1656,7 +1817,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JCharArrayPtr array,
               JSizeMarker start,
               JSizeMarker len,
@@ -1665,7 +1826,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JShortArrayPtr array,
               JSizeMarker start,
               JSizeMarker len,
@@ -1674,7 +1835,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JIntArrayPtr array,
               JSizeMarker start,
               JSizeMarker len,
@@ -1683,7 +1844,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JLongArrayPtr array,
               JSizeMarker start,
               JSizeMarker len,
@@ -1692,7 +1853,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JFloatArrayPtr array,
               JSizeMarker start,
               JSizeMarker len,
@@ -1701,7 +1862,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JDoubleArrayPtr array,
               JSizeMarker start,
               JSizeMarker len,
@@ -1711,7 +1872,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JBooleanArrayPtr array,
               JSizeMarker start,
               JSizeMarker len,
@@ -1720,7 +1881,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JByteArrayPtr array,
               JSizeMarker start,
               JSizeMarker len,
@@ -1729,7 +1890,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JCharArrayPtr array,
               JSizeMarker start,
               JSizeMarker len,
@@ -1738,7 +1899,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JShortArrayPtr array,
               JSizeMarker start,
               JSizeMarker len,
@@ -1747,7 +1908,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JIntArrayPtr array,
               JSizeMarker start,
               JSizeMarker len,
@@ -1756,7 +1917,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JLongArrayPtr array,
               JSizeMarker start,
               JSizeMarker len,
@@ -1765,7 +1926,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JFloatArrayPtr array,
               JSizeMarker start,
               JSizeMarker len,
@@ -1774,7 +1935,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JDoubleArrayPtr array,
               JSizeMarker start,
               JSizeMarker len,
@@ -1783,35 +1944,35 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           JIntMarker Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JClassPtr clazz,
               ffi.Pointer<JNINativeMethod> methods,
               JIntMarker nMethods)>> RegisterNatives;
 
   external ffi.Pointer<
           ffi.NativeFunction<
-              JIntMarker Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz)>>
+              JIntMarker Function(ffi.Pointer<JniEnv> env, JClassPtr clazz)>>
       UnregisterNatives;
 
   external ffi.Pointer<
           ffi.NativeFunction<
-              JIntMarker Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj)>>
+              JIntMarker Function(ffi.Pointer<JniEnv> env, JObjectPtr obj)>>
       MonitorEnter;
 
   external ffi.Pointer<
           ffi.NativeFunction<
-              JIntMarker Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj)>>
+              JIntMarker Function(ffi.Pointer<JniEnv> env, JObjectPtr obj)>>
       MonitorExit;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JIntMarker Function(ffi.Pointer<JniEnv1> env,
-              ffi.Pointer<ffi.Pointer<JavaVM1>> vm)>> GetJavaVM;
+          JIntMarker Function(ffi.Pointer<JniEnv> env,
+              ffi.Pointer<ffi.Pointer<JavaVM>> vm)>> GetJavaVM;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JStringPtr str,
               JSizeMarker start,
               JSizeMarker len,
@@ -1820,7 +1981,7 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JStringPtr str,
               JSizeMarker start,
               JSizeMarker len,
@@ -1829,14 +1990,14 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Pointer<ffi.Void> Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JArrayPtr array,
               ffi.Pointer<JBooleanMarker> isCopy)>> GetPrimitiveArrayCritical;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Void Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JArrayPtr array,
               ffi.Pointer<ffi.Void> carray,
               JIntMarker mode)>> ReleasePrimitiveArrayCritical;
@@ -1844,92 +2005,101 @@ final class JNINativeInterface extends ffi.Struct {
   external ffi.Pointer<
       ffi.NativeFunction<
           ffi.Pointer<JCharMarker> Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               JStringPtr str,
               ffi.Pointer<JBooleanMarker> isCopy)>> GetStringCritical;
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          ffi.Void Function(ffi.Pointer<JniEnv1> env, JStringPtr str,
+          ffi.Void Function(ffi.Pointer<JniEnv> env, JStringPtr str,
               ffi.Pointer<JCharMarker> carray)>> ReleaseStringCritical;
 
   external ffi.Pointer<
           ffi.NativeFunction<
-              JWeakPtr Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj)>>
+              JWeakPtr Function(ffi.Pointer<JniEnv> env, JObjectPtr obj)>>
       NewWeakGlobalRef;
 
   external ffi.Pointer<
           ffi.NativeFunction<
-              ffi.Void Function(ffi.Pointer<JniEnv1> env, JWeakPtr obj)>>
+              ffi.Void Function(ffi.Pointer<JniEnv> env, JWeakPtr obj)>>
       DeleteWeakGlobalRef;
 
   external ffi.Pointer<
-          ffi.NativeFunction<JBooleanMarker Function(ffi.Pointer<JniEnv1> env)>>
+          ffi.NativeFunction<JBooleanMarker Function(ffi.Pointer<JniEnv> env)>>
       ExceptionCheck;
 
   external ffi.Pointer<
       ffi.NativeFunction<
           JObjectPtr Function(
-              ffi.Pointer<JniEnv1> env,
+              ffi.Pointer<JniEnv> env,
               ffi.Pointer<ffi.Void> address,
               JLongMarker capacity)>> NewDirectByteBuffer;
 
   external ffi.Pointer<
-          ffi.NativeFunction<
-              ffi.Pointer<ffi.Void> Function(
-                  ffi.Pointer<JniEnv1> env, JObjectPtr buf)>>
-      GetDirectBufferAddress;
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<JniEnv> env, JObjectPtr buf)>> GetDirectBufferAddress;
 
   external ffi.Pointer<
           ffi.NativeFunction<
-              JLongMarker Function(ffi.Pointer<JniEnv1> env, JObjectPtr buf)>>
+              JLongMarker Function(ffi.Pointer<JniEnv> env, JObjectPtr buf)>>
       GetDirectBufferCapacity;
 
   /// added in JNI 1.6
   external ffi.Pointer<
-          ffi.NativeFunction<
-              ffi.Int32 Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj)>>
-      GetObjectRefType;
+      ffi.NativeFunction<
+          ffi.UnsignedInt Function(
+              ffi.Pointer<JniEnv> env, JObjectPtr obj)>> GetObjectRefType;
 }
 
 typedef JniEnv1 = ffi.Pointer<JNINativeInterface>;
 
-/// "cardinal indices and sizes"
-typedef JSizeMarker = JIntMarker;
-typedef JMethodIDPtr = ffi.Pointer<jmethodID_>;
+/// JNI invocation interface.
+final class JNIInvokeInterface extends ffi.Struct {
+  external ffi.Pointer<ffi.Void> reserved0;
 
-final class jmethodID_ extends ffi.Opaque {}
+  external ffi.Pointer<ffi.Void> reserved1;
 
-typedef JFieldIDPtr = ffi.Pointer<jfieldID_>;
+  external ffi.Pointer<ffi.Void> reserved2;
 
-final class jfieldID_ extends ffi.Opaque {}
+  external ffi
+      .Pointer<ffi.NativeFunction<JIntMarker Function(ffi.Pointer<JavaVM> vm)>>
+      DestroyJavaVM;
 
-typedef JArrayPtr = JObjectPtr;
-typedef JObjectArrayPtr = JArrayPtr;
-typedef JBooleanArrayPtr = JArrayPtr;
-typedef JByteArrayPtr = JArrayPtr;
-typedef JCharArrayPtr = JArrayPtr;
-typedef JShortArrayPtr = JArrayPtr;
-typedef JIntArrayPtr = JArrayPtr;
-typedef JLongArrayPtr = JArrayPtr;
-typedef JFloatArrayPtr = JArrayPtr;
-typedef JDoubleArrayPtr = JArrayPtr;
+  external ffi.Pointer<
+      ffi.NativeFunction<
+          JIntMarker Function(
+              ffi.Pointer<JavaVM> vm,
+              ffi.Pointer<ffi.Pointer<JniEnv1>> p_env,
+              ffi.Pointer<ffi.Void> thr_args)>> AttachCurrentThread;
 
-final class JNINativeMethod extends ffi.Struct {
-  external ffi.Pointer<ffi.Char> name;
+  external ffi
+      .Pointer<ffi.NativeFunction<JIntMarker Function(ffi.Pointer<JavaVM> vm)>>
+      DetachCurrentThread;
 
-  external ffi.Pointer<ffi.Char> signature;
+  external ffi.Pointer<
+      ffi.NativeFunction<
+          JIntMarker Function(
+              ffi.Pointer<JavaVM> vm,
+              ffi.Pointer<ffi.Pointer<ffi.Void>> p_env,
+              JIntMarker version)>> GetEnv;
 
-  external ffi.Pointer<ffi.Void> fnPtr;
+  external ffi.Pointer<
+      ffi.NativeFunction<
+          JIntMarker Function(
+              ffi.Pointer<JavaVM> vm,
+              ffi.Pointer<ffi.Pointer<JniEnv1>> p_env,
+              ffi.Pointer<ffi.Void> thr_args)>> AttachCurrentThreadAsDaemon;
 }
 
-typedef JWeakPtr = JObjectPtr;
+typedef JavaVM1 = ffi.Pointer<JNIInvokeInterface>;
+
+/// JNI 1.2+ initialization.  (As of 1.6, the pre-1.2 structures are no
+/// longer supported.)
+final class JavaVMOption extends ffi.Struct {
+  external ffi.Pointer<ffi.Char> optionString;
 
-abstract class JObjectRefType {
-  static const int JNIInvalidRefType = 0;
-  static const int JNILocalRefType = 1;
-  static const int JNIGlobalRefType = 2;
-  static const int JNIWeakGlobalRefType = 3;
+  external ffi.Pointer<ffi.Void> extraInfo;
 }
 
 final class JavaVMInitArgs extends ffi.Struct {
@@ -1946,53 +2116,10 @@ final class JavaVMInitArgs extends ffi.Struct {
   external int ignoreUnrecognized;
 }
 
-/// JNI 1.2+ initialization.  (As of 1.6, the pre-1.2 structures are no
-/// longer supported.)
-final class JavaVMOption extends ffi.Struct {
-  external ffi.Pointer<ffi.Char> optionString;
-
-  external ffi.Pointer<ffi.Void> extraInfo;
-}
-
-final class CallbackResult extends ffi.Struct {
-  external MutexLock lock;
-
-  external ConditionVariable cond;
-
-  @ffi.Int()
-  external int ready;
-
-  external JObjectPtr object;
-}
-
-typedef MutexLock = pthread_mutex_t;
-typedef pthread_mutex_t = __darwin_pthread_mutex_t;
-typedef __darwin_pthread_mutex_t = _opaque_pthread_mutex_t;
-
-final class _opaque_pthread_mutex_t extends ffi.Struct {
-  @ffi.Long()
-  external int __sig;
-
-  @ffi.Array.multi([56])
-  external ffi.Array<ffi.Char> __opaque;
-}
-
-typedef ConditionVariable = pthread_cond_t;
-typedef pthread_cond_t = __darwin_pthread_cond_t;
-typedef __darwin_pthread_cond_t = _opaque_pthread_cond_t;
-
-final class _opaque_pthread_cond_t extends ffi.Struct {
-  @ffi.Long()
-  external int __sig;
-
-  @ffi.Array.multi([40])
-  external ffi.Array<ffi.Char> __opaque;
-}
+final class _Dart_FinalizableHandle extends ffi.Opaque {}
 
 typedef Dart_FinalizableHandle = ffi.Pointer<_Dart_FinalizableHandle>;
 
-final class _Dart_FinalizableHandle extends ffi.Opaque {}
-
 final class GlobalJniEnvStruct extends ffi.Struct {
   external ffi.Pointer<ffi.Void> reserved0;
 
@@ -3196,7 +3323,7 @@ final class GlobalJniEnvStruct extends ffi.Struct {
 
   external ffi.Pointer<
       ffi.NativeFunction<
-          JniResult Function(ffi.Pointer<ffi.Pointer<JavaVM>> vm)>> GetJavaVM;
+          JniResult Function(ffi.Pointer<ffi.Pointer<JavaVM1>> vm)>> GetJavaVM;
 
   external ffi.Pointer<
       ffi.NativeFunction<
@@ -3339,50 +3466,3 @@ final class GlobalJniEnvStruct extends ffi.Struct {
           JThrowablePtr Function(JDoubleArrayPtr array, JSizeMarker index,
               JDoubleMarker element)>> SetDoubleArrayElement;
 }
-
-/// This file re-exports some JNI constants as enum, because they are not
-/// currently being included when they are in macro form.
-abstract class JniBooleanValues {
-  static const int JNI_FALSE = 0;
-  static const int JNI_TRUE = 1;
-}
-
-abstract class JniVersions {
-  static const int JNI_VERSION_1_1 = 65537;
-  static const int JNI_VERSION_1_2 = 65538;
-  static const int JNI_VERSION_1_4 = 65540;
-  static const int JNI_VERSION_1_6 = 65542;
-}
-
-abstract class JniErrorCode {
-  /// no error
-  static const int JNI_OK = 0;
-
-  /// generic error
-  static const int JNI_ERR = -1;
-
-  /// thread detached from the VM
-  static const int JNI_EDETACHED = -2;
-
-  /// JNI version error
-  static const int JNI_EVERSION = -3;
-
-  /// Out of memory
-  static const int JNI_ENOMEM = -4;
-
-  /// VM already created
-  static const int JNI_EEXIST = -5;
-
-  /// Invalid argument
-  static const int JNI_EINVAL = -6;
-}
-
-abstract class JniBufferWriteBack {
-  /// copy content, do not free buffer
-  static const int JNI_COMMIT = 1;
-
-  /// free buffer w/o copying back
-  static const int JNI_ABORT = 2;
-}
-
-const int DART_JNI_SINGLETON_EXISTS = -99;
diff --git a/pkgs/jni/pubspec.yaml b/pkgs/jni/pubspec.yaml
index 8546c5fb8..f895b98d2 100644
--- a/pkgs/jni/pubspec.yaml
+++ b/pkgs/jni/pubspec.yaml
@@ -30,7 +30,7 @@ dependencies:
 dev_dependencies:
   dart_flutter_team_lints: ^3.2.0
   ## Pin ffigen version because we are depending on internal APIs.
-  ffigen: 8.0.2
+  ffigen: 16.1.0
   logging: ^1.2.0
   test: ^1.25.8
 
@@ -46,3 +46,7 @@ flutter:
         ffiPlugin: true
         package: com.github.dart_lang.jni
         pluginClass: JniPlugin
+
+dependency_overrides:
+  ffigen:
+    path: ../ffigen
diff --git a/pkgs/jni/src/dartjni.c b/pkgs/jni/src/dartjni.c
index 26b9cc351..b23dcba8a 100644
--- a/pkgs/jni/src/dartjni.c
+++ b/pkgs/jni/src/dartjni.c
@@ -201,16 +201,16 @@ BOOL WINAPI DllMain(HINSTANCE hinstDLL,   // handle to DLL module
 pthread_mutex_t spawnLock = PTHREAD_MUTEX_INITIALIZER;
 #endif
 FFI_PLUGIN_EXPORT
-int SpawnJvm(JavaVMInitArgs* initArgs) {
+JniErrorCode SpawnJvm(JavaVMInitArgs* initArgs) {
   if (jni_context.jvm != NULL) {
-    return DART_JNI_SINGLETON_EXISTS;
+    return SINGLETON_EXISTS;
   }
 
   acquire_lock(&spawnLock);
   // Init may have happened in the meanwhile.
   if (jni_context.jvm != NULL) {
     release_lock(&spawnLock);
-    return DART_JNI_SINGLETON_EXISTS;
+    return SINGLETON_EXISTS;
   }
   JavaVMOption jvmopt[1];
   char class_path[] = "-Djava.class.path=.";
diff --git a/pkgs/jni/src/dartjni.h b/pkgs/jni/src/dartjni.h
index 5d182c13a..3139ee194 100644
--- a/pkgs/jni/src/dartjni.h
+++ b/pkgs/jni/src/dartjni.h
@@ -5,6 +5,7 @@
 #pragma once
 
 #include "include/dart_api_dl.h"
+#include "jni_constants.h"
 
 // Note: include appropriate system jni.h as found by CMake, not third_party/jni.h.
 #include <jni.h>
@@ -139,9 +140,6 @@ typedef struct JniLocks {
   MutexLock classLoadingLock;
 } JniLocks;
 
-/// Represents the error when dart-jni layer has already spawned singleton VM.
-#define DART_JNI_SINGLETON_EXISTS (-99);
-
 /// Stores the global state of the JNI.
 typedef struct JniContext {
   JavaVM* jvm;
@@ -237,7 +235,7 @@ FFI_PLUGIN_EXPORT JNIEnv* GetJniEnv(void);
 /// Returns JNI_OK on success, and one of the documented JNI error codes on
 /// failure. It returns DART_JNI_SINGLETON_EXISTS if an attempt to spawn multiple
 /// JVMs is made, even if the underlying API potentially supports multiple VMs.
-FFI_PLUGIN_EXPORT int SpawnJvm(JavaVMInitArgs* args);
+FFI_PLUGIN_EXPORT JniErrorCode SpawnJvm(JavaVMInitArgs* args);
 
 /// Returns Application classLoader (on Android),
 /// which can be used to load application and platform classes.
diff --git a/pkgs/jni/src/jni_constants.h b/pkgs/jni/src/jni_constants.h
index 8423ca10d..fee011ace 100644
--- a/pkgs/jni/src/jni_constants.h
+++ b/pkgs/jni/src/jni_constants.h
@@ -4,28 +4,35 @@
 
 // This file re-exports some JNI constants as enum, because they are not
 // currently being included when they are in macro form.
+#pragma once
 
-enum JniBooleanValues { JNI_FALSE = 0, JNI_TRUE = 1 };
+#include "jni.h"
 
-enum JniVersions {
-  JNI_VERSION_1_1 = 0x00010001,
-  JNI_VERSION_1_2 = 0x00010002,
-  JNI_VERSION_1_4 = 0x00010004,
-  JNI_VERSION_1_6 = 0x00010006,
-};
+typedef enum JniBooleanValues {
+  FALSE = JNI_FALSE,
+  TRUE = JNI_TRUE
+} JniBooleanValues;
 
-enum JniErrorCode {
+typedef enum JniVersions {
+  VERSION_1_1 = JNI_VERSION_1_1,
+  VERSION_1_2 = JNI_VERSION_1_2,
+  VERSION_1_4 = JNI_VERSION_1_4,
+  VERSION_1_6 = JNI_VERSION_1_6,
+} JniVersions;
+
+typedef enum JniErrorCode {
   // Error codes from JNI
-  JNI_OK = 0,         /* no error */
-  JNI_ERR = -1,       /* generic error */
-  JNI_EDETACHED = -2, /* thread detached from the VM */
-  JNI_EVERSION = -3,  /* JNI version error */
-  JNI_ENOMEM = -4,    /* Out of memory */
-  JNI_EEXIST = -5,    /* VM already created */
-  JNI_EINVAL = -6,    /* Invalid argument */
-};
+  OK = JNI_OK,               /* no error */
+  ERR = JNI_ERR,             /* generic error */
+  EDETACHED = JNI_EDETACHED, /* thread detached from the VM */
+  EVERSION = JNI_EVERSION,   /* JNI version error */
+  ENOMEM = JNI_ENOMEM,       /* Out of memory */
+  EEXIST = JNI_EEXIST,       /* VM already created */
+  EINVAL = JNI_EINVAL,       /* Invalid argument */
+  SINGLETON_EXISTS = -99,
+} JniErrorCode;
 
-enum JniBufferWriteBack {
-  JNI_COMMIT = 1, /* copy content, do not free buffer */
-  JNI_ABORT = 2,  /* free buffer w/o copying back */
-};
+typedef enum JniBufferWriteBack {
+  COMMIT = JNI_COMMIT, /* copy content, do not free buffer */
+  ABORT = JNI_ABORT,   /* free buffer w/o copying back */
+} JniBufferWriteBack;
diff --git a/pkgs/jni/src/third_party/global_jni_env.c b/pkgs/jni/src/third_party/global_jni_env.c
index 2e7e44829..76cbccf02 100644
--- a/pkgs/jni/src/third_party/global_jni_env.c
+++ b/pkgs/jni/src/third_party/global_jni_env.c
@@ -2421,11 +2421,7 @@ JniResult globalEnv_GetDirectBufferCapacity(jobject buf) {
 
 JniResult globalEnv_GetObjectRefType(jobject obj) {
   attach_thread();
-  int32_t _result = (*jniEnv)->GetObjectRefType(jniEnv, obj);
-  jthrowable _exception = check_exception();
-  if (_exception != NULL) {
-    return (JniResult){.value = {.j = 0}, .exception = _exception};
-  }
+  jobjectRefType _result = (*jniEnv)->GetObjectRefType(jniEnv, obj);
   return (JniResult){.value = {.i = _result}, .exception = NULL};
 }
 
diff --git a/pkgs/jni/tool/generate_ffi_bindings.dart b/pkgs/jni/tool/generate_ffi_bindings.dart
index c1a2b5e57..787df27fd 100644
--- a/pkgs/jni/tool/generate_ffi_bindings.dart
+++ b/pkgs/jni/tool/generate_ffi_bindings.dart
@@ -9,6 +9,7 @@ import 'dart:io';
 
 import 'package:args/args.dart';
 import 'package:ffigen/ffigen.dart' as ffigen;
+import 'package:ffigen/src/header_parser.dart' as ffigen;
 import 'package:logging/logging.dart';
 
 import 'wrapper_generators/generate_c_extensions.dart';
@@ -51,15 +52,15 @@ void main(List<String> args) {
   });
 
   logger.info('Generating C wrappers');
-  final minimalConfig = ffigen.Config.fromFile(File('ffigen_exts.yaml'));
+  final minimalConfig = ffigen.YamlConfig.fromFile(File('ffigen_exts.yaml'));
   final minimalLibrary = ffigen.parse(minimalConfig);
   generateCWrappers(minimalLibrary);
 
   logger.info('Generating FFI bindings for package:jni');
 
-  final config = ffigen.Config.fromFile(File('ffigen.yaml'));
+  final config = ffigen.YamlConfig.fromFile(File('ffigen.yaml'));
   final library = ffigen.parse(config);
-  final outputFile = File(config.output);
+  final outputFile = File(config.output.toFilePath());
   library.generateFile(outputFile);
 
   logger.info('Generating Dart extensions');
diff --git a/pkgs/jni/tool/wrapper_generators/ffigen_util.dart b/pkgs/jni/tool/wrapper_generators/ffigen_util.dart
index 975dc5f9d..2b65e7ccb 100644
--- a/pkgs/jni/tool/wrapper_generators/ffigen_util.dart
+++ b/pkgs/jni/tool/wrapper_generators/ffigen_util.dart
@@ -9,7 +9,11 @@ final dummyWriter = Writer(
   lookUpBindings: [],
   ffiNativeBindings: [],
   noLookUpBindings: [],
+  nativeEntryPoints: [],
   className: 'unused',
+  silenceEnumWarning: true,
+  generateForPackageObjectiveC: false,
+  nativeAssetId: null,
 );
 
 /// Find compound having [name] in [library].
diff --git a/pkgs/jni/tool/wrapper_generators/generate_c_extensions.dart b/pkgs/jni/tool/wrapper_generators/generate_c_extensions.dart
index a5ccef5d4..4fb0114a9 100644
--- a/pkgs/jni/tool/wrapper_generators/generate_c_extensions.dart
+++ b/pkgs/jni/tool/wrapper_generators/generate_c_extensions.dart
@@ -67,7 +67,7 @@ String getCType(Type type) {
   if (type is PointerType) {
     return '${getCType(type.child)}*';
   }
-  final cType = type.getCType(dummyWriter);
+  final cType = type.toString();
   const specialCaseMappings = {
     'JNIEnv1': 'JNIEnv',
     'ffi.Char': 'char',
@@ -91,7 +91,7 @@ String getWrapperFuncName(String name) {
 }
 
 // Returns declaration of function field in GlobalJniEnv struct
-String getFunctionFieldDecl(Member field, {required bool isField}) {
+String getFunctionFieldDecl(CompoundMember field, {required bool isField}) {
   final fieldType = field.type;
   if (fieldType is PointerType && fieldType.child is NativeFunc) {
     final nativeFunc = fieldType.child as NativeFunc;
@@ -180,6 +180,7 @@ ResultWrapper getResultWrapper(String returnType) {
       return ResultWrapper.unionType('JniPointerResult', 'NULL');
     case 'jclass':
       return ResultWrapper.unionType('JniClassLookupResult', 'NULL');
+    case 'jobjectRefType':
     case 'int32_t':
       return ResultWrapper.forJValueField('i');
     default:
@@ -224,9 +225,10 @@ const _noCheckException = {
   'GetStringCritical',
   'ExceptionClear',
   'ExceptionDescribe',
+  'GetObjectRefType',
 };
 
-String? getWrapperFunc(Member field) {
+String? getWrapperFunc(CompoundMember field) {
   final fieldType = field.type;
   if (fieldType is PointerType && fieldType.child is NativeFunc) {
     final functionType = (fieldType.child as NativeFunc).type;
diff --git a/pkgs/jni/tool/wrapper_generators/generate_dart_extensions.dart b/pkgs/jni/tool/wrapper_generators/generate_dart_extensions.dart
index 740434148..2ef1ec3ab 100644
--- a/pkgs/jni/tool/wrapper_generators/generate_dart_extensions.dart
+++ b/pkgs/jni/tool/wrapper_generators/generate_dart_extensions.dart
@@ -44,29 +44,31 @@ String getCheckedGetter(Type returnType) {
     final child = returnType.child.getCType(dummyWriter);
     return 'getPointer<$child>()';
   }
-  final cType = returnType.getCType(dummyWriter);
-  if (cType.endsWith('ArrayPtr')) {
+  final cType = returnType.toString();
+  if (cType.startsWith('j') && cType.endsWith('Array')) {
     return objectPointerGetter;
   }
   const mappings = {
-    'JBooleanMarker': 'boolean',
-    'JByteMarker': 'byte',
-    'JShortMarker': 'short',
-    'JCharMarker': 'char',
-    'JIntMarker': 'integer',
-    'JSizeMarker': 'integer', // jsize is aliased to jint
-    'JLongMarker': 'long',
-    'JFloatMarker': 'float',
-    'JDoubleMarker': 'doubleFloat',
-    'JObjectPtr': objectPointerGetter,
-    'JThrowablePtr': objectPointerGetter,
-    'JStringPtr': objectPointerGetter,
-    'JClassPtr': 'value',
-    'JFieldIDPtr': 'fieldID',
-    'JMethodIDPtr': 'methodID',
+    'jboolean': 'boolean',
+    'jbyte': 'byte',
+    'jshort': 'short',
+    'jchar': 'char',
+    'jint': 'integer',
+    'jsize': 'integer', // jsize is aliased to jint
+    'jlong': 'long',
+    'jfloat': 'float',
+    'jdouble': 'doubleFloat',
+    'jobject': objectPointerGetter,
+    'jobjectRefType': 'referenceType',
+    'jthrowable': objectPointerGetter,
+    'jstring': objectPointerGetter,
+    'jclass': 'value',
+    'jfieldID': 'fieldID',
+    'jmethodID': 'methodID',
     'ffi.Int32': 'integer',
+    'ffi.UnsignedInt': 'integer',
     'ffi.Void': 'check()',
-    'JWeakPtr': objectPointerGetter,
+    'jweak': objectPointerGetter,
   };
   if (mappings.containsKey(cType)) {
     return mappings[cType]!;
@@ -76,7 +78,7 @@ String getCheckedGetter(Type returnType) {
 }
 
 String? getGlobalEnvExtensionFunction(
-  Member field,
+  CompoundMember field,
   Type? checkedReturnType, {
   required bool isLeaf,
 }) {
@@ -276,7 +278,7 @@ class GlobalJniEnv {
 }
 
 String? getFunctionPointerExtensionFunction(
-  Member field, {
+  CompoundMember field, {
   bool indirect = false,
   bool implicitThis = false,
   required bool isLeaf,