[jnigen] Further FFI improvements (https://github.com/dart-lang/jnigen/issues/254)
* Add DllMain lock initialization in windows
* release lock on second init check
* Use wrapper class instead of extensions.
* Rename GlobalJniEnv in C to `GlobalJniEnvStruct`, and `JniAccessors` to `JniAccessorsStruct`
* In dart, generate wrapper classes that store a pointer to above.
* Then generate methods which are semantically equivalent to the extensions in previous iterations.
* But internally, results of `asFunction` are cached to late field instead of being called again. (This is what ffigen does too).
* Do not generate extensions for local env & javavm types
* Remove -j
* Add --test-randomize-ordering-seed random
diff --git a/.github/workflows/test-package.yml b/.github/workflows/test-package.yml
index f1afa9d..a5bb09e 100644
--- a/.github/workflows/test-package.yml
+++ b/.github/workflows/test-package.yml
@@ -169,7 +169,7 @@
- name: Get dependencies
run: dart pub get
- name: Run tests
- run: dart test
+ run: dart test --test-randomize-ordering-seed random
- name: Install coverage
run: dart pub global activate coverage
- name: Collect coverage
@@ -209,9 +209,7 @@
- run: Add-Content $env:GITHUB_PATH "$env:JAVA_HOME\bin\server"
- run: dart pub get
- run: dart run jni:setup
- ## TODO(#51): -j 1 is required to avoid a rare race condition which is caused by
- ## all tests which spawn JVM being run in same process.
- - run: dart test -j 1
+ - run: dart test --test-randomize-ordering-seed random
test_jnigen_windows_minimal:
needs: [analyze_jnigen]
@@ -266,9 +264,7 @@
java-version: '11'
- run: dart pub get
- run: dart run jni:setup
- ## TODO(#51): -j 1 is required to avoid a rare race condition which is caused by
- ## all tests which spawn JVM being run in same process.
- - run: dart test -j 1
+ - run: dart test --test-randomize-ordering-seed random
test_jnigen_macos_minimal:
needs: [analyze_jnigen]
diff --git a/pkgs/jni/lib/src/accessors.dart b/pkgs/jni/lib/src/accessors.dart
index 66045ae..e2bee89 100644
--- a/pkgs/jni/lib/src/accessors.dart
+++ b/pkgs/jni/lib/src/accessors.dart
@@ -100,7 +100,7 @@
}
}
-extension JniAccessorWrappers on Pointer<JniAccessors> {
+extension JniAccessorWrappers on JniAccessors {
/// Rethrows Java exception in Dart as [JniException].
///
/// The original exception object is deleted by this method. The message
diff --git a/pkgs/jni/lib/src/jni.dart b/pkgs/jni/lib/src/jni.dart
index 8ad7fd4..277c2a5 100644
--- a/pkgs/jni/lib/src/jni.dart
+++ b/pkgs/jni/lib/src/jni.dart
@@ -156,9 +156,9 @@
return _bindings.GetJavaVM();
}
- /// Returns the instance of [GlobalJniEnv], which is an abstraction over JNIEnv
+ /// Returns the instance of [GlobalJniEnvStruct], which is an abstraction over JNIEnv
/// without the same-thread restriction.
- static Pointer<GlobalJniEnv> _fetchGlobalEnv() {
+ static Pointer<GlobalJniEnvStruct> _fetchGlobalEnv() {
final env = _bindings.GetGlobalEnv();
if (env == nullptr) {
throw NoJvmInstanceException();
@@ -166,17 +166,17 @@
return env;
}
- static Pointer<GlobalJniEnv>? _env;
+ static GlobalJniEnv? _env;
- /// Points to a process-wide shared instance of [GlobalJniEnv].
+ /// Points to a process-wide shared instance of [GlobalJniEnvStruct].
///
/// It provides an indirection over [JniEnv] so that it can be used from
/// any thread, and always returns global object references.
- static Pointer<GlobalJniEnv> get env {
- return _env ??= _fetchGlobalEnv();
+ static GlobalJniEnv get env {
+ return _env ??= GlobalJniEnv(_fetchGlobalEnv());
}
- static Pointer<JniAccessors> get accessors => _bindings.GetAccessors();
+ static JniAccessors get accessors => JniAccessors(_bindings.GetAccessors());
/// Returns a new PortContinuation.
static JObjectPtr newPortContinuation(ReceivePort port) {
@@ -288,7 +288,7 @@
}
}
-extension AdditionalEnvMethods on Pointer<GlobalJniEnv> {
+extension AdditionalEnvMethods on GlobalJniEnv {
/// Convenience method for converting a [JStringPtr]
/// to dart string.
/// if [deleteOriginal] is specified, jstring passed will be deleted using
diff --git a/pkgs/jni/lib/src/jreference.dart b/pkgs/jni/lib/src/jreference.dart
index e71febf..3a96bb3 100644
--- a/pkgs/jni/lib/src/jreference.dart
+++ b/pkgs/jni/lib/src/jreference.dart
@@ -8,7 +8,8 @@
/// which disposes the reference(s).
abstract class JReference implements Finalizable {
//TODO(PR): Is it safe to cast void *f (void *) to void f (void *)?
- static final _finalizer = NativeFinalizer(_env.ref.DeleteGlobalRef.cast());
+ static final _finalizer =
+ NativeFinalizer(_env.ptr.ref.DeleteGlobalRef.cast());
JReference.fromRef(this.reference) {
_finalizer.attach(this, reference, detach: this);
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 e561eef..2d2a028 100644
--- a/pkgs/jni/lib/src/third_party/global_env_extensions.dart
+++ b/pkgs/jni/lib/src/third_party/global_env_extensions.dart
@@ -35,1357 +35,1480 @@
import "../accessors.dart";
-extension EnvExtension on ffi.Pointer<GlobalJniEnv> {
- int GetVersion() =>
- ref.GetVersion.asFunction<JniResult Function()>()().integer;
+/// Wraps over Pointer<GlobalJniEnvStruct> and exposes function pointer fields
+/// as methods.
+class GlobalJniEnv {
+ final ffi.Pointer<GlobalJniEnvStruct> ptr;
+ GlobalJniEnv(this.ptr);
+ late final _GetVersion =
+ ptr.ref.GetVersion.asFunction<JniResult Function()>();
+
+ int 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)>();
JClassPtr DefineClass(ffi.Pointer<ffi.Char> name, JObjectPtr loader,
ffi.Pointer<JByteMarker> buf, int bufLen) =>
- ref.DefineClass.asFunction<
- JniClassLookupResult Function(
- ffi.Pointer<ffi.Char> name,
- JObjectPtr loader,
- ffi.Pointer<JByteMarker> buf,
- int bufLen)>()(name, loader, buf, bufLen)
- .value;
+ _DefineClass(name, loader, buf, bufLen).value;
- JClassPtr FindClass(ffi.Pointer<ffi.Char> name) => ref.FindClass.asFunction<
- JniClassLookupResult Function(ffi.Pointer<ffi.Char> name)>()(name)
- .value;
+ late final _FindClass = ptr.ref.FindClass
+ .asFunction<JniClassLookupResult Function(ffi.Pointer<ffi.Char> name)>();
- JMethodIDPtr FromReflectedMethod(JObjectPtr method) => ref.FromReflectedMethod
- .asFunction<JniPointerResult Function(JObjectPtr method)>()(method)
- .methodID;
+ JClassPtr FindClass(ffi.Pointer<ffi.Char> name) => _FindClass(name).value;
- JFieldIDPtr FromReflectedField(JObjectPtr field) => ref.FromReflectedField
- .asFunction<JniPointerResult Function(JObjectPtr field)>()(field)
- .fieldID;
+ late final _FromReflectedMethod = ptr.ref.FromReflectedMethod
+ .asFunction<JniPointerResult Function(JObjectPtr method)>();
+
+ JMethodIDPtr FromReflectedMethod(JObjectPtr method) =>
+ _FromReflectedMethod(method).methodID;
+
+ late final _FromReflectedField = ptr.ref.FromReflectedField
+ .asFunction<JniPointerResult Function(JObjectPtr field)>();
+
+ JFieldIDPtr FromReflectedField(JObjectPtr field) =>
+ _FromReflectedField(field).fieldID;
+
+ late final _ToReflectedMethod = ptr.ref.ToReflectedMethod.asFunction<
+ JniResult Function(JClassPtr cls, JMethodIDPtr methodId, int isStatic)>();
JObjectPtr ToReflectedMethod(
JClassPtr cls, JMethodIDPtr methodId, int isStatic) =>
- ref.ToReflectedMethod.asFunction<
- JniResult Function(JClassPtr cls, JMethodIDPtr methodId,
- int isStatic)>()(cls, methodId, isStatic)
- .object;
+ _ToReflectedMethod(cls, methodId, isStatic).object;
- JClassPtr GetSuperclass(JClassPtr clazz) => ref.GetSuperclass.asFunction<
- JniClassLookupResult Function(JClassPtr clazz)>()(clazz)
- .value;
+ late final _GetSuperclass = ptr.ref.GetSuperclass
+ .asFunction<JniClassLookupResult Function(JClassPtr clazz)>();
+
+ JClassPtr GetSuperclass(JClassPtr clazz) => _GetSuperclass(clazz).value;
+
+ late final _IsAssignableFrom = ptr.ref.IsAssignableFrom
+ .asFunction<JniResult Function(JClassPtr clazz1, JClassPtr clazz2)>();
bool IsAssignableFrom(JClassPtr clazz1, JClassPtr clazz2) =>
- ref.IsAssignableFrom.asFunction<
- JniResult Function(
- JClassPtr clazz1, JClassPtr clazz2)>()(clazz1, clazz2)
- .boolean;
+ _IsAssignableFrom(clazz1, clazz2).boolean;
+
+ late final _ToReflectedField = ptr.ref.ToReflectedField.asFunction<
+ JniResult Function(JClassPtr cls, JFieldIDPtr fieldID, int isStatic)>();
JObjectPtr ToReflectedField(
JClassPtr cls, JFieldIDPtr fieldID, int isStatic) =>
- ref.ToReflectedField.asFunction<
- JniResult Function(JClassPtr cls, JFieldIDPtr fieldID,
- int isStatic)>()(cls, fieldID, isStatic)
- .object;
+ _ToReflectedField(cls, fieldID, isStatic).object;
- int Throw(JThrowablePtr obj) =>
- ref.Throw.asFunction<JniResult Function(JThrowablePtr obj)>()(obj)
- .integer;
+ late final _Throw =
+ ptr.ref.Throw.asFunction<JniResult Function(JThrowablePtr obj)>();
+
+ int 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) =>
- ref.ThrowNew.asFunction<
- JniResult Function(JClassPtr clazz,
- ffi.Pointer<ffi.Char> message)>()(clazz, message)
- .integer;
+ _ThrowNew(clazz, message).integer;
- JThrowablePtr ExceptionOccurred() =>
- ref.ExceptionOccurred.asFunction<JniResult Function()>()().object;
+ late final _ExceptionOccurred =
+ ptr.ref.ExceptionOccurred.asFunction<JniResult Function()>();
- void ExceptionDescribe() =>
- ref.ExceptionDescribe.asFunction<JThrowablePtr Function()>()().check();
+ JThrowablePtr ExceptionOccurred() => _ExceptionOccurred().object;
- void ExceptionClear() =>
- ref.ExceptionClear.asFunction<JThrowablePtr Function()>()().check();
+ late final _ExceptionDescribe =
+ ptr.ref.ExceptionDescribe.asFunction<JThrowablePtr Function()>();
- void FatalError(ffi.Pointer<ffi.Char> msg) => ref.FatalError.asFunction<
- JThrowablePtr Function(ffi.Pointer<ffi.Char> msg)>()(msg)
- .check();
+ void ExceptionDescribe() => _ExceptionDescribe().check();
- int PushLocalFrame(int capacity) =>
- ref.PushLocalFrame.asFunction<JniResult Function(int capacity)>()(
- capacity)
- .integer;
+ late final _ExceptionClear =
+ ptr.ref.ExceptionClear.asFunction<JThrowablePtr Function()>();
- JObjectPtr PopLocalFrame(JObjectPtr result) =>
- ref.PopLocalFrame.asFunction<JniResult Function(JObjectPtr result)>()(
- result)
- .object;
+ void ExceptionClear() => _ExceptionClear().check();
- JObjectPtr NewGlobalRef(JObjectPtr obj) =>
- ref.NewGlobalRef.asFunction<JniResult Function(JObjectPtr obj)>()(obj)
- .object;
+ late final _FatalError = ptr.ref.FatalError
+ .asFunction<JThrowablePtr Function(ffi.Pointer<ffi.Char> msg)>();
- void DeleteGlobalRef(JObjectPtr globalRef) => ref.DeleteGlobalRef.asFunction<
- JThrowablePtr Function(JObjectPtr globalRef)>()(globalRef)
- .check();
+ void FatalError(ffi.Pointer<ffi.Char> msg) => _FatalError(msg).check();
- void DeleteLocalRef(JObjectPtr localRef) => ref.DeleteLocalRef.asFunction<
- JThrowablePtr Function(JObjectPtr localRef)>()(localRef)
- .check();
+ late final _PushLocalFrame =
+ ptr.ref.PushLocalFrame.asFunction<JniResult Function(int capacity)>();
+
+ int PushLocalFrame(int capacity) => _PushLocalFrame(capacity).integer;
+
+ late final _PopLocalFrame =
+ ptr.ref.PopLocalFrame.asFunction<JniResult Function(JObjectPtr result)>();
+
+ JObjectPtr PopLocalFrame(JObjectPtr result) => _PopLocalFrame(result).object;
+
+ late final _NewGlobalRef =
+ ptr.ref.NewGlobalRef.asFunction<JniResult Function(JObjectPtr obj)>();
+
+ JObjectPtr NewGlobalRef(JObjectPtr obj) => _NewGlobalRef(obj).object;
+
+ late final _DeleteGlobalRef = ptr.ref.DeleteGlobalRef
+ .asFunction<JThrowablePtr Function(JObjectPtr globalRef)>();
+
+ void DeleteGlobalRef(JObjectPtr globalRef) =>
+ _DeleteGlobalRef(globalRef).check();
+
+ late final _DeleteLocalRef = ptr.ref.DeleteLocalRef
+ .asFunction<JThrowablePtr Function(JObjectPtr localRef)>();
+
+ void DeleteLocalRef(JObjectPtr localRef) => _DeleteLocalRef(localRef).check();
+
+ late final _IsSameObject = ptr.ref.IsSameObject
+ .asFunction<JniResult Function(JObjectPtr ref1, JObjectPtr ref2)>();
bool IsSameObject(JObjectPtr ref1, JObjectPtr ref2) =>
- ref.IsSameObject.asFunction<
- JniResult Function(
- JObjectPtr ref1, JObjectPtr ref2)>()(ref1, ref2)
- .boolean;
+ _IsSameObject(ref1, ref2).boolean;
- JObjectPtr NewLocalRef(JObjectPtr obj) =>
- ref.NewLocalRef.asFunction<JniResult Function(JObjectPtr obj)>()(obj)
- .object;
+ late final _NewLocalRef =
+ ptr.ref.NewLocalRef.asFunction<JniResult Function(JObjectPtr obj)>();
+
+ JObjectPtr NewLocalRef(JObjectPtr obj) => _NewLocalRef(obj).object;
+
+ late final _EnsureLocalCapacity = ptr.ref.EnsureLocalCapacity
+ .asFunction<JniResult Function(int capacity)>();
int EnsureLocalCapacity(int capacity) =>
- ref.EnsureLocalCapacity.asFunction<JniResult Function(int capacity)>()(
- capacity)
- .integer;
+ _EnsureLocalCapacity(capacity).integer;
- JObjectPtr AllocObject(JClassPtr clazz) =>
- ref.AllocObject.asFunction<JniResult Function(JClassPtr clazz)>()(clazz)
- .object;
+ late final _AllocObject =
+ ptr.ref.AllocObject.asFunction<JniResult Function(JClassPtr clazz)>();
+
+ JObjectPtr AllocObject(JClassPtr clazz) => _AllocObject(clazz).object;
+
+ late final _NewObject = ptr.ref.NewObject
+ .asFunction<JniResult Function(JClassPtr clazz, JMethodIDPtr methodID)>();
JObjectPtr NewObject(JClassPtr clazz, JMethodIDPtr methodID) =>
- ref.NewObject.asFunction<
- JniResult Function(
- JClassPtr clazz, JMethodIDPtr methodID)>()(clazz, methodID)
- .object;
+ _NewObject(clazz, methodID).object;
+
+ late final _NewObjectA = ptr.ref.NewObjectA.asFunction<
+ JniResult Function(
+ JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
JObjectPtr NewObjectA(
JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.NewObjectA.asFunction<
- JniResult Function(JClassPtr clazz, JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(clazz, methodID, args)
- .object;
+ _NewObjectA(clazz, methodID, args).object;
- JClassPtr GetObjectClass(JObjectPtr obj) => ref.GetObjectClass.asFunction<
- JniClassLookupResult Function(JObjectPtr obj)>()(obj)
- .value;
+ late final _GetObjectClass = ptr.ref.GetObjectClass
+ .asFunction<JniClassLookupResult Function(JObjectPtr obj)>();
+
+ JClassPtr GetObjectClass(JObjectPtr obj) => _GetObjectClass(obj).value;
+
+ late final _IsInstanceOf = ptr.ref.IsInstanceOf
+ .asFunction<JniResult Function(JObjectPtr obj, JClassPtr clazz)>();
bool IsInstanceOf(JObjectPtr obj, JClassPtr clazz) =>
- ref.IsInstanceOf.asFunction<
- JniResult Function(JObjectPtr obj, JClassPtr clazz)>()(obj, clazz)
- .boolean;
+ _IsInstanceOf(obj, clazz).boolean;
+
+ late final _GetMethodID = ptr.ref.GetMethodID.asFunction<
+ JniPointerResult Function(JClassPtr clazz, ffi.Pointer<ffi.Char> name,
+ ffi.Pointer<ffi.Char> sig)>();
JMethodIDPtr GetMethodID(JClassPtr clazz, ffi.Pointer<ffi.Char> name,
ffi.Pointer<ffi.Char> sig) =>
- ref.GetMethodID.asFunction<
- JniPointerResult Function(
- JClassPtr clazz,
- ffi.Pointer<ffi.Char> name,
- ffi.Pointer<ffi.Char> sig)>()(clazz, name, sig)
- .methodID;
+ _GetMethodID(clazz, name, sig).methodID;
+
+ late final _CallObjectMethod = ptr.ref.CallObjectMethod
+ .asFunction<JniResult Function(JObjectPtr obj, JMethodIDPtr methodID)>();
JObjectPtr CallObjectMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
- ref.CallObjectMethod.asFunction<
- JniResult Function(
- JObjectPtr obj, JMethodIDPtr methodID)>()(obj, methodID)
- .object;
+ _CallObjectMethod(obj, methodID).object;
+
+ late final _CallObjectMethodA = ptr.ref.CallObjectMethodA.asFunction<
+ JniResult Function(
+ JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
JObjectPtr CallObjectMethodA(
JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallObjectMethodA.asFunction<
- JniResult Function(JObjectPtr obj, JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(obj, methodID, args)
- .object;
+ _CallObjectMethodA(obj, methodID, args).object;
+
+ late final _CallBooleanMethod = ptr.ref.CallBooleanMethod
+ .asFunction<JniResult Function(JObjectPtr obj, JMethodIDPtr methodID)>();
bool CallBooleanMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
- ref.CallBooleanMethod.asFunction<
- JniResult Function(
- JObjectPtr obj, JMethodIDPtr methodID)>()(obj, methodID)
- .boolean;
+ _CallBooleanMethod(obj, methodID).boolean;
+
+ late final _CallBooleanMethodA = ptr.ref.CallBooleanMethodA.asFunction<
+ JniResult Function(
+ JObjectPtr obj, JMethodIDPtr methodId, ffi.Pointer<JValue> args)>();
bool CallBooleanMethodA(
JObjectPtr obj, JMethodIDPtr methodId, ffi.Pointer<JValue> args) =>
- ref.CallBooleanMethodA.asFunction<
- JniResult Function(JObjectPtr obj, JMethodIDPtr methodId,
- ffi.Pointer<JValue> args)>()(obj, methodId, args)
- .boolean;
+ _CallBooleanMethodA(obj, methodId, args).boolean;
+
+ late final _CallByteMethod = ptr.ref.CallByteMethod
+ .asFunction<JniResult Function(JObjectPtr obj, JMethodIDPtr methodID)>();
int CallByteMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
- ref.CallByteMethod.asFunction<
- JniResult Function(
- JObjectPtr obj, JMethodIDPtr methodID)>()(obj, methodID)
- .byte;
+ _CallByteMethod(obj, methodID).byte;
+
+ late final _CallByteMethodA = ptr.ref.CallByteMethodA.asFunction<
+ JniResult Function(
+ JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
int CallByteMethodA(
JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallByteMethodA.asFunction<
- JniResult Function(JObjectPtr obj, JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(obj, methodID, args)
- .byte;
+ _CallByteMethodA(obj, methodID, args).byte;
+
+ late final _CallCharMethod = ptr.ref.CallCharMethod
+ .asFunction<JniResult Function(JObjectPtr obj, JMethodIDPtr methodID)>();
int CallCharMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
- ref.CallCharMethod.asFunction<
- JniResult Function(
- JObjectPtr obj, JMethodIDPtr methodID)>()(obj, methodID)
- .char;
+ _CallCharMethod(obj, methodID).char;
+
+ late final _CallCharMethodA = ptr.ref.CallCharMethodA.asFunction<
+ JniResult Function(
+ JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
int CallCharMethodA(
JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallCharMethodA.asFunction<
- JniResult Function(JObjectPtr obj, JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(obj, methodID, args)
- .char;
+ _CallCharMethodA(obj, methodID, args).char;
+
+ late final _CallShortMethod = ptr.ref.CallShortMethod
+ .asFunction<JniResult Function(JObjectPtr obj, JMethodIDPtr methodID)>();
int CallShortMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
- ref.CallShortMethod.asFunction<
- JniResult Function(
- JObjectPtr obj, JMethodIDPtr methodID)>()(obj, methodID)
- .short;
+ _CallShortMethod(obj, methodID).short;
+
+ late final _CallShortMethodA = ptr.ref.CallShortMethodA.asFunction<
+ JniResult Function(
+ JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
int CallShortMethodA(
JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallShortMethodA.asFunction<
- JniResult Function(JObjectPtr obj, JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(obj, methodID, args)
- .short;
+ _CallShortMethodA(obj, methodID, args).short;
+
+ late final _CallIntMethod = ptr.ref.CallIntMethod
+ .asFunction<JniResult Function(JObjectPtr obj, JMethodIDPtr methodID)>();
int CallIntMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
- ref.CallIntMethod.asFunction<
- JniResult Function(
- JObjectPtr obj, JMethodIDPtr methodID)>()(obj, methodID)
- .integer;
+ _CallIntMethod(obj, methodID).integer;
+
+ late final _CallIntMethodA = ptr.ref.CallIntMethodA.asFunction<
+ JniResult Function(
+ JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
int CallIntMethodA(
JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallIntMethodA.asFunction<
- JniResult Function(JObjectPtr obj, JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(obj, methodID, args)
- .integer;
+ _CallIntMethodA(obj, methodID, args).integer;
+
+ late final _CallLongMethod = ptr.ref.CallLongMethod
+ .asFunction<JniResult Function(JObjectPtr obj, JMethodIDPtr methodID)>();
int CallLongMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
- ref.CallLongMethod.asFunction<
- JniResult Function(
- JObjectPtr obj, JMethodIDPtr methodID)>()(obj, methodID)
- .long;
+ _CallLongMethod(obj, methodID).long;
+
+ late final _CallLongMethodA = ptr.ref.CallLongMethodA.asFunction<
+ JniResult Function(
+ JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
int CallLongMethodA(
JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallLongMethodA.asFunction<
- JniResult Function(JObjectPtr obj, JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(obj, methodID, args)
- .long;
+ _CallLongMethodA(obj, methodID, args).long;
+
+ late final _CallFloatMethod = ptr.ref.CallFloatMethod
+ .asFunction<JniResult Function(JObjectPtr obj, JMethodIDPtr methodID)>();
double CallFloatMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
- ref.CallFloatMethod.asFunction<
- JniResult Function(
- JObjectPtr obj, JMethodIDPtr methodID)>()(obj, methodID)
- .float;
+ _CallFloatMethod(obj, methodID).float;
+
+ late final _CallFloatMethodA = ptr.ref.CallFloatMethodA.asFunction<
+ JniResult Function(
+ JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
double CallFloatMethodA(
JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallFloatMethodA.asFunction<
- JniResult Function(JObjectPtr obj, JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(obj, methodID, args)
- .float;
+ _CallFloatMethodA(obj, methodID, args).float;
+
+ late final _CallDoubleMethod = ptr.ref.CallDoubleMethod
+ .asFunction<JniResult Function(JObjectPtr obj, JMethodIDPtr methodID)>();
double CallDoubleMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
- ref.CallDoubleMethod.asFunction<
- JniResult Function(
- JObjectPtr obj, JMethodIDPtr methodID)>()(obj, methodID)
- .doubleFloat;
+ _CallDoubleMethod(obj, methodID).doubleFloat;
+
+ late final _CallDoubleMethodA = ptr.ref.CallDoubleMethodA.asFunction<
+ JniResult Function(
+ JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
double CallDoubleMethodA(
JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallDoubleMethodA.asFunction<
- JniResult Function(JObjectPtr obj, JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(obj, methodID, args)
- .doubleFloat;
+ _CallDoubleMethodA(obj, methodID, args).doubleFloat;
+
+ late final _CallVoidMethod = ptr.ref.CallVoidMethod.asFunction<
+ JThrowablePtr Function(JObjectPtr obj, JMethodIDPtr methodID)>();
void CallVoidMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
- ref.CallVoidMethod.asFunction<
- JThrowablePtr Function(
- JObjectPtr obj, JMethodIDPtr methodID)>()(obj, methodID)
- .check();
+ _CallVoidMethod(obj, methodID).check();
+
+ late final _CallVoidMethodA = ptr.ref.CallVoidMethodA.asFunction<
+ JThrowablePtr Function(
+ JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
void CallVoidMethodA(
JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallVoidMethodA.asFunction<
- JThrowablePtr Function(JObjectPtr obj, JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(obj, methodID, args)
- .check();
+ _CallVoidMethodA(obj, methodID, args).check();
+
+ late final _CallNonvirtualObjectMethod = ptr.ref.CallNonvirtualObjectMethod
+ .asFunction<
+ JniResult Function(
+ JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID)>();
JObjectPtr CallNonvirtualObjectMethod(
JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
- ref.CallNonvirtualObjectMethod.asFunction<
- JniResult Function(JObjectPtr obj, JClassPtr clazz,
- JMethodIDPtr methodID)>()(obj, clazz, methodID)
- .object;
+ _CallNonvirtualObjectMethod(obj, clazz, methodID).object;
+
+ late final _CallNonvirtualObjectMethodA = ptr.ref.CallNonvirtualObjectMethodA
+ .asFunction<
+ JniResult Function(JObjectPtr obj, JClassPtr clazz,
+ JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
JObjectPtr CallNonvirtualObjectMethodA(JObjectPtr obj, JClassPtr clazz,
JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallNonvirtualObjectMethodA.asFunction<
- JniResult Function(
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(obj, clazz, methodID, args)
- .object;
+ _CallNonvirtualObjectMethodA(obj, clazz, methodID, args).object;
+
+ late final _CallNonvirtualBooleanMethod = ptr.ref.CallNonvirtualBooleanMethod
+ .asFunction<
+ JniResult Function(
+ JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID)>();
bool CallNonvirtualBooleanMethod(
JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
- ref.CallNonvirtualBooleanMethod.asFunction<
- JniResult Function(JObjectPtr obj, JClassPtr clazz,
- JMethodIDPtr methodID)>()(obj, clazz, methodID)
- .boolean;
+ _CallNonvirtualBooleanMethod(obj, clazz, methodID).boolean;
+
+ late final _CallNonvirtualBooleanMethodA =
+ ptr.ref.CallNonvirtualBooleanMethodA.asFunction<
+ JniResult Function(JObjectPtr obj, JClassPtr clazz,
+ JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
bool CallNonvirtualBooleanMethodA(JObjectPtr obj, JClassPtr clazz,
JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallNonvirtualBooleanMethodA.asFunction<
- JniResult Function(
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(obj, clazz, methodID, args)
- .boolean;
+ _CallNonvirtualBooleanMethodA(obj, clazz, methodID, args).boolean;
+
+ late final _CallNonvirtualByteMethod = ptr.ref.CallNonvirtualByteMethod
+ .asFunction<
+ JniResult Function(
+ JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID)>();
int CallNonvirtualByteMethod(
JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
- ref.CallNonvirtualByteMethod.asFunction<
- JniResult Function(JObjectPtr obj, JClassPtr clazz,
- JMethodIDPtr methodID)>()(obj, clazz, methodID)
- .byte;
+ _CallNonvirtualByteMethod(obj, clazz, methodID).byte;
+
+ late final _CallNonvirtualByteMethodA = ptr.ref.CallNonvirtualByteMethodA
+ .asFunction<
+ JniResult Function(JObjectPtr obj, JClassPtr clazz,
+ JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
int CallNonvirtualByteMethodA(JObjectPtr obj, JClassPtr clazz,
JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallNonvirtualByteMethodA.asFunction<
- JniResult Function(
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(obj, clazz, methodID, args)
- .byte;
+ _CallNonvirtualByteMethodA(obj, clazz, methodID, args).byte;
+
+ late final _CallNonvirtualCharMethod = ptr.ref.CallNonvirtualCharMethod
+ .asFunction<
+ JniResult Function(
+ JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID)>();
int CallNonvirtualCharMethod(
JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
- ref.CallNonvirtualCharMethod.asFunction<
- JniResult Function(JObjectPtr obj, JClassPtr clazz,
- JMethodIDPtr methodID)>()(obj, clazz, methodID)
- .char;
+ _CallNonvirtualCharMethod(obj, clazz, methodID).char;
+
+ late final _CallNonvirtualCharMethodA = ptr.ref.CallNonvirtualCharMethodA
+ .asFunction<
+ JniResult Function(JObjectPtr obj, JClassPtr clazz,
+ JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
int CallNonvirtualCharMethodA(JObjectPtr obj, JClassPtr clazz,
JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallNonvirtualCharMethodA.asFunction<
- JniResult Function(
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(obj, clazz, methodID, args)
- .char;
+ _CallNonvirtualCharMethodA(obj, clazz, methodID, args).char;
+
+ late final _CallNonvirtualShortMethod = ptr.ref.CallNonvirtualShortMethod
+ .asFunction<
+ JniResult Function(
+ JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID)>();
int CallNonvirtualShortMethod(
JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
- ref.CallNonvirtualShortMethod.asFunction<
- JniResult Function(JObjectPtr obj, JClassPtr clazz,
- JMethodIDPtr methodID)>()(obj, clazz, methodID)
- .short;
+ _CallNonvirtualShortMethod(obj, clazz, methodID).short;
+
+ late final _CallNonvirtualShortMethodA = ptr.ref.CallNonvirtualShortMethodA
+ .asFunction<
+ JniResult Function(JObjectPtr obj, JClassPtr clazz,
+ JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
int CallNonvirtualShortMethodA(JObjectPtr obj, JClassPtr clazz,
JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallNonvirtualShortMethodA.asFunction<
- JniResult Function(
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(obj, clazz, methodID, args)
- .short;
+ _CallNonvirtualShortMethodA(obj, clazz, methodID, args).short;
+
+ late final _CallNonvirtualIntMethod = ptr.ref.CallNonvirtualIntMethod
+ .asFunction<
+ JniResult Function(
+ JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID)>();
int CallNonvirtualIntMethod(
JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
- ref.CallNonvirtualIntMethod.asFunction<
- JniResult Function(JObjectPtr obj, JClassPtr clazz,
- JMethodIDPtr methodID)>()(obj, clazz, methodID)
- .integer;
+ _CallNonvirtualIntMethod(obj, clazz, methodID).integer;
+
+ late final _CallNonvirtualIntMethodA = ptr.ref.CallNonvirtualIntMethodA
+ .asFunction<
+ JniResult Function(JObjectPtr obj, JClassPtr clazz,
+ JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
int CallNonvirtualIntMethodA(JObjectPtr obj, JClassPtr clazz,
JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallNonvirtualIntMethodA.asFunction<
- JniResult Function(
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(obj, clazz, methodID, args)
- .integer;
+ _CallNonvirtualIntMethodA(obj, clazz, methodID, args).integer;
+
+ late final _CallNonvirtualLongMethod = ptr.ref.CallNonvirtualLongMethod
+ .asFunction<
+ JniResult Function(
+ JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID)>();
int CallNonvirtualLongMethod(
JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
- ref.CallNonvirtualLongMethod.asFunction<
- JniResult Function(JObjectPtr obj, JClassPtr clazz,
- JMethodIDPtr methodID)>()(obj, clazz, methodID)
- .long;
+ _CallNonvirtualLongMethod(obj, clazz, methodID).long;
+
+ late final _CallNonvirtualLongMethodA = ptr.ref.CallNonvirtualLongMethodA
+ .asFunction<
+ JniResult Function(JObjectPtr obj, JClassPtr clazz,
+ JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
int CallNonvirtualLongMethodA(JObjectPtr obj, JClassPtr clazz,
JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallNonvirtualLongMethodA.asFunction<
- JniResult Function(
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(obj, clazz, methodID, args)
- .long;
+ _CallNonvirtualLongMethodA(obj, clazz, methodID, args).long;
+
+ late final _CallNonvirtualFloatMethod = ptr.ref.CallNonvirtualFloatMethod
+ .asFunction<
+ JniResult Function(
+ JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID)>();
double CallNonvirtualFloatMethod(
JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
- ref.CallNonvirtualFloatMethod.asFunction<
- JniResult Function(JObjectPtr obj, JClassPtr clazz,
- JMethodIDPtr methodID)>()(obj, clazz, methodID)
- .float;
+ _CallNonvirtualFloatMethod(obj, clazz, methodID).float;
+
+ late final _CallNonvirtualFloatMethodA = ptr.ref.CallNonvirtualFloatMethodA
+ .asFunction<
+ JniResult Function(JObjectPtr obj, JClassPtr clazz,
+ JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
double CallNonvirtualFloatMethodA(JObjectPtr obj, JClassPtr clazz,
JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallNonvirtualFloatMethodA.asFunction<
- JniResult Function(
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(obj, clazz, methodID, args)
- .float;
+ _CallNonvirtualFloatMethodA(obj, clazz, methodID, args).float;
+
+ late final _CallNonvirtualDoubleMethod = ptr.ref.CallNonvirtualDoubleMethod
+ .asFunction<
+ JniResult Function(
+ JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID)>();
double CallNonvirtualDoubleMethod(
JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
- ref.CallNonvirtualDoubleMethod.asFunction<
- JniResult Function(JObjectPtr obj, JClassPtr clazz,
- JMethodIDPtr methodID)>()(obj, clazz, methodID)
- .doubleFloat;
+ _CallNonvirtualDoubleMethod(obj, clazz, methodID).doubleFloat;
+
+ late final _CallNonvirtualDoubleMethodA = ptr.ref.CallNonvirtualDoubleMethodA
+ .asFunction<
+ JniResult Function(JObjectPtr obj, JClassPtr clazz,
+ JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
double CallNonvirtualDoubleMethodA(JObjectPtr obj, JClassPtr clazz,
JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallNonvirtualDoubleMethodA.asFunction<
- JniResult Function(
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(obj, clazz, methodID, args)
- .doubleFloat;
+ _CallNonvirtualDoubleMethodA(obj, clazz, methodID, args).doubleFloat;
+
+ late final _CallNonvirtualVoidMethod = ptr.ref.CallNonvirtualVoidMethod
+ .asFunction<
+ JThrowablePtr Function(
+ JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID)>();
void CallNonvirtualVoidMethod(
JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
- ref.CallNonvirtualVoidMethod.asFunction<
- JThrowablePtr Function(JObjectPtr obj, JClassPtr clazz,
- JMethodIDPtr methodID)>()(obj, clazz, methodID)
- .check();
+ _CallNonvirtualVoidMethod(obj, clazz, methodID).check();
+
+ late final _CallNonvirtualVoidMethodA = ptr.ref.CallNonvirtualVoidMethodA
+ .asFunction<
+ JThrowablePtr Function(JObjectPtr obj, JClassPtr clazz,
+ JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
void CallNonvirtualVoidMethodA(JObjectPtr obj, JClassPtr clazz,
JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallNonvirtualVoidMethodA.asFunction<
- JThrowablePtr Function(
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(obj, clazz, methodID, args)
- .check();
+ _CallNonvirtualVoidMethodA(obj, clazz, methodID, args).check();
+
+ late final _GetFieldID = ptr.ref.GetFieldID.asFunction<
+ JniPointerResult Function(JClassPtr clazz, ffi.Pointer<ffi.Char> name,
+ ffi.Pointer<ffi.Char> sig)>();
JFieldIDPtr GetFieldID(JClassPtr clazz, ffi.Pointer<ffi.Char> name,
ffi.Pointer<ffi.Char> sig) =>
- ref.GetFieldID.asFunction<
- JniPointerResult Function(
- JClassPtr clazz,
- ffi.Pointer<ffi.Char> name,
- ffi.Pointer<ffi.Char> sig)>()(clazz, name, sig)
- .fieldID;
+ _GetFieldID(clazz, name, sig).fieldID;
+
+ late final _GetObjectField = ptr.ref.GetObjectField
+ .asFunction<JniResult Function(JObjectPtr obj, JFieldIDPtr fieldID)>();
JObjectPtr GetObjectField(JObjectPtr obj, JFieldIDPtr fieldID) =>
- ref.GetObjectField.asFunction<
- JniResult Function(
- JObjectPtr obj, JFieldIDPtr fieldID)>()(obj, fieldID)
- .object;
+ _GetObjectField(obj, fieldID).object;
+
+ late final _GetBooleanField = ptr.ref.GetBooleanField
+ .asFunction<JniResult Function(JObjectPtr obj, JFieldIDPtr fieldID)>();
bool GetBooleanField(JObjectPtr obj, JFieldIDPtr fieldID) =>
- ref.GetBooleanField.asFunction<
- JniResult Function(
- JObjectPtr obj, JFieldIDPtr fieldID)>()(obj, fieldID)
- .boolean;
+ _GetBooleanField(obj, fieldID).boolean;
+
+ late final _GetByteField = ptr.ref.GetByteField
+ .asFunction<JniResult Function(JObjectPtr obj, JFieldIDPtr fieldID)>();
int GetByteField(JObjectPtr obj, JFieldIDPtr fieldID) =>
- ref.GetByteField.asFunction<
- JniResult Function(
- JObjectPtr obj, JFieldIDPtr fieldID)>()(obj, fieldID)
- .byte;
+ _GetByteField(obj, fieldID).byte;
+
+ late final _GetCharField = ptr.ref.GetCharField
+ .asFunction<JniResult Function(JObjectPtr obj, JFieldIDPtr fieldID)>();
int GetCharField(JObjectPtr obj, JFieldIDPtr fieldID) =>
- ref.GetCharField.asFunction<
- JniResult Function(
- JObjectPtr obj, JFieldIDPtr fieldID)>()(obj, fieldID)
- .char;
+ _GetCharField(obj, fieldID).char;
+
+ late final _GetShortField = ptr.ref.GetShortField
+ .asFunction<JniResult Function(JObjectPtr obj, JFieldIDPtr fieldID)>();
int GetShortField(JObjectPtr obj, JFieldIDPtr fieldID) =>
- ref.GetShortField.asFunction<
- JniResult Function(
- JObjectPtr obj, JFieldIDPtr fieldID)>()(obj, fieldID)
- .short;
+ _GetShortField(obj, fieldID).short;
+
+ late final _GetIntField = ptr.ref.GetIntField
+ .asFunction<JniResult Function(JObjectPtr obj, JFieldIDPtr fieldID)>();
int GetIntField(JObjectPtr obj, JFieldIDPtr fieldID) =>
- ref.GetIntField.asFunction<
- JniResult Function(
- JObjectPtr obj, JFieldIDPtr fieldID)>()(obj, fieldID)
- .integer;
+ _GetIntField(obj, fieldID).integer;
+
+ late final _GetLongField = ptr.ref.GetLongField
+ .asFunction<JniResult Function(JObjectPtr obj, JFieldIDPtr fieldID)>();
int GetLongField(JObjectPtr obj, JFieldIDPtr fieldID) =>
- ref.GetLongField.asFunction<
- JniResult Function(
- JObjectPtr obj, JFieldIDPtr fieldID)>()(obj, fieldID)
- .long;
+ _GetLongField(obj, fieldID).long;
+
+ late final _GetFloatField = ptr.ref.GetFloatField
+ .asFunction<JniResult Function(JObjectPtr obj, JFieldIDPtr fieldID)>();
double GetFloatField(JObjectPtr obj, JFieldIDPtr fieldID) =>
- ref.GetFloatField.asFunction<
- JniResult Function(
- JObjectPtr obj, JFieldIDPtr fieldID)>()(obj, fieldID)
- .float;
+ _GetFloatField(obj, fieldID).float;
+
+ late final _GetDoubleField = ptr.ref.GetDoubleField
+ .asFunction<JniResult Function(JObjectPtr obj, JFieldIDPtr fieldID)>();
double GetDoubleField(JObjectPtr obj, JFieldIDPtr fieldID) =>
- ref.GetDoubleField.asFunction<
- JniResult Function(
- JObjectPtr obj, JFieldIDPtr fieldID)>()(obj, fieldID)
- .doubleFloat;
+ _GetDoubleField(obj, fieldID).doubleFloat;
+
+ late final _SetObjectField = ptr.ref.SetObjectField.asFunction<
+ JThrowablePtr Function(
+ JObjectPtr obj, JFieldIDPtr fieldID, JObjectPtr val)>();
void SetObjectField(JObjectPtr obj, JFieldIDPtr fieldID, JObjectPtr val) =>
- ref.SetObjectField.asFunction<
- JThrowablePtr Function(JObjectPtr obj, JFieldIDPtr fieldID,
- JObjectPtr val)>()(obj, fieldID, val)
- .check();
+ _SetObjectField(obj, fieldID, val).check();
+
+ late final _SetBooleanField = ptr.ref.SetBooleanField.asFunction<
+ JThrowablePtr Function(JObjectPtr obj, JFieldIDPtr fieldID, int val)>();
void SetBooleanField(JObjectPtr obj, JFieldIDPtr fieldID, int val) =>
- ref.SetBooleanField.asFunction<
- JThrowablePtr Function(JObjectPtr obj, JFieldIDPtr fieldID,
- int val)>()(obj, fieldID, val)
- .check();
+ _SetBooleanField(obj, fieldID, val).check();
+
+ late final _SetByteField = ptr.ref.SetByteField.asFunction<
+ JThrowablePtr Function(JObjectPtr obj, JFieldIDPtr fieldID, int val)>();
void SetByteField(JObjectPtr obj, JFieldIDPtr fieldID, int val) =>
- ref.SetByteField.asFunction<
- JThrowablePtr Function(JObjectPtr obj, JFieldIDPtr fieldID,
- int val)>()(obj, fieldID, val)
- .check();
+ _SetByteField(obj, fieldID, val).check();
+
+ late final _SetCharField = ptr.ref.SetCharField.asFunction<
+ JThrowablePtr Function(JObjectPtr obj, JFieldIDPtr fieldID, int val)>();
void SetCharField(JObjectPtr obj, JFieldIDPtr fieldID, int val) =>
- ref.SetCharField.asFunction<
- JThrowablePtr Function(JObjectPtr obj, JFieldIDPtr fieldID,
- int val)>()(obj, fieldID, val)
- .check();
+ _SetCharField(obj, fieldID, val).check();
+
+ late final _SetShortField = ptr.ref.SetShortField.asFunction<
+ JThrowablePtr Function(JObjectPtr obj, JFieldIDPtr fieldID, int val)>();
void SetShortField(JObjectPtr obj, JFieldIDPtr fieldID, int val) =>
- ref.SetShortField.asFunction<
- JThrowablePtr Function(JObjectPtr obj, JFieldIDPtr fieldID,
- int val)>()(obj, fieldID, val)
- .check();
+ _SetShortField(obj, fieldID, val).check();
+
+ late final _SetIntField = ptr.ref.SetIntField.asFunction<
+ JThrowablePtr Function(JObjectPtr obj, JFieldIDPtr fieldID, int val)>();
void SetIntField(JObjectPtr obj, JFieldIDPtr fieldID, int val) =>
- ref.SetIntField.asFunction<
- JThrowablePtr Function(JObjectPtr obj, JFieldIDPtr fieldID,
- int val)>()(obj, fieldID, val)
- .check();
+ _SetIntField(obj, fieldID, val).check();
+
+ late final _SetLongField = ptr.ref.SetLongField.asFunction<
+ JThrowablePtr Function(JObjectPtr obj, JFieldIDPtr fieldID, int val)>();
void SetLongField(JObjectPtr obj, JFieldIDPtr fieldID, int val) =>
- ref.SetLongField.asFunction<
- JThrowablePtr Function(JObjectPtr obj, JFieldIDPtr fieldID,
- int val)>()(obj, fieldID, val)
- .check();
+ _SetLongField(obj, fieldID, val).check();
+
+ late final _SetFloatField = ptr.ref.SetFloatField.asFunction<
+ JThrowablePtr Function(
+ JObjectPtr obj, JFieldIDPtr fieldID, double val)>();
void SetFloatField(JObjectPtr obj, JFieldIDPtr fieldID, double val) =>
- ref.SetFloatField.asFunction<
- JThrowablePtr Function(JObjectPtr obj, JFieldIDPtr fieldID,
- double val)>()(obj, fieldID, val)
- .check();
+ _SetFloatField(obj, fieldID, val).check();
+
+ late final _SetDoubleField = ptr.ref.SetDoubleField.asFunction<
+ JThrowablePtr Function(
+ JObjectPtr obj, JFieldIDPtr fieldID, double val)>();
void SetDoubleField(JObjectPtr obj, JFieldIDPtr fieldID, double val) =>
- ref.SetDoubleField.asFunction<
- JThrowablePtr Function(JObjectPtr obj, JFieldIDPtr fieldID,
- double val)>()(obj, fieldID, val)
- .check();
+ _SetDoubleField(obj, fieldID, val).check();
+
+ late final _GetStaticMethodID = ptr.ref.GetStaticMethodID.asFunction<
+ JniPointerResult Function(JClassPtr clazz, ffi.Pointer<ffi.Char> name,
+ ffi.Pointer<ffi.Char> sig)>();
JMethodIDPtr GetStaticMethodID(JClassPtr clazz, ffi.Pointer<ffi.Char> name,
ffi.Pointer<ffi.Char> sig) =>
- ref.GetStaticMethodID.asFunction<
- JniPointerResult Function(
- JClassPtr clazz,
- ffi.Pointer<ffi.Char> name,
- ffi.Pointer<ffi.Char> sig)>()(clazz, name, sig)
- .methodID;
+ _GetStaticMethodID(clazz, name, sig).methodID;
+
+ late final _CallStaticObjectMethod = ptr.ref.CallStaticObjectMethod
+ .asFunction<JniResult Function(JClassPtr clazz, JMethodIDPtr methodID)>();
JObjectPtr CallStaticObjectMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
- ref.CallStaticObjectMethod.asFunction<
- JniResult Function(
- JClassPtr clazz, JMethodIDPtr methodID)>()(clazz, methodID)
- .object;
+ _CallStaticObjectMethod(clazz, methodID).object;
+
+ late final _CallStaticObjectMethodA = ptr.ref.CallStaticObjectMethodA
+ .asFunction<
+ JniResult Function(JClassPtr clazz, JMethodIDPtr methodID,
+ ffi.Pointer<JValue> args)>();
JObjectPtr CallStaticObjectMethodA(
JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallStaticObjectMethodA.asFunction<
- JniResult Function(JClassPtr clazz, JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(clazz, methodID, args)
- .object;
+ _CallStaticObjectMethodA(clazz, methodID, args).object;
+
+ late final _CallStaticBooleanMethod = ptr.ref.CallStaticBooleanMethod
+ .asFunction<JniResult Function(JClassPtr clazz, JMethodIDPtr methodID)>();
bool CallStaticBooleanMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
- ref.CallStaticBooleanMethod.asFunction<
- JniResult Function(
- JClassPtr clazz, JMethodIDPtr methodID)>()(clazz, methodID)
- .boolean;
+ _CallStaticBooleanMethod(clazz, methodID).boolean;
+
+ late final _CallStaticBooleanMethodA = ptr.ref.CallStaticBooleanMethodA
+ .asFunction<
+ JniResult Function(JClassPtr clazz, JMethodIDPtr methodID,
+ ffi.Pointer<JValue> args)>();
bool CallStaticBooleanMethodA(
JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallStaticBooleanMethodA.asFunction<
- JniResult Function(JClassPtr clazz, JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(clazz, methodID, args)
- .boolean;
+ _CallStaticBooleanMethodA(clazz, methodID, args).boolean;
+
+ late final _CallStaticByteMethod = ptr.ref.CallStaticByteMethod
+ .asFunction<JniResult Function(JClassPtr clazz, JMethodIDPtr methodID)>();
int CallStaticByteMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
- ref.CallStaticByteMethod.asFunction<
- JniResult Function(
- JClassPtr clazz, JMethodIDPtr methodID)>()(clazz, methodID)
- .byte;
+ _CallStaticByteMethod(clazz, methodID).byte;
+
+ late final _CallStaticByteMethodA = ptr.ref.CallStaticByteMethodA.asFunction<
+ JniResult Function(
+ JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
int CallStaticByteMethodA(
JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallStaticByteMethodA.asFunction<
- JniResult Function(JClassPtr clazz, JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(clazz, methodID, args)
- .byte;
+ _CallStaticByteMethodA(clazz, methodID, args).byte;
+
+ late final _CallStaticCharMethod = ptr.ref.CallStaticCharMethod
+ .asFunction<JniResult Function(JClassPtr clazz, JMethodIDPtr methodID)>();
int CallStaticCharMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
- ref.CallStaticCharMethod.asFunction<
- JniResult Function(
- JClassPtr clazz, JMethodIDPtr methodID)>()(clazz, methodID)
- .char;
+ _CallStaticCharMethod(clazz, methodID).char;
+
+ late final _CallStaticCharMethodA = ptr.ref.CallStaticCharMethodA.asFunction<
+ JniResult Function(
+ JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
int CallStaticCharMethodA(
JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallStaticCharMethodA.asFunction<
- JniResult Function(JClassPtr clazz, JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(clazz, methodID, args)
- .char;
+ _CallStaticCharMethodA(clazz, methodID, args).char;
+
+ late final _CallStaticShortMethod = ptr.ref.CallStaticShortMethod
+ .asFunction<JniResult Function(JClassPtr clazz, JMethodIDPtr methodID)>();
int CallStaticShortMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
- ref.CallStaticShortMethod.asFunction<
- JniResult Function(
- JClassPtr clazz, JMethodIDPtr methodID)>()(clazz, methodID)
- .short;
+ _CallStaticShortMethod(clazz, methodID).short;
+
+ late final _CallStaticShortMethodA = ptr.ref.CallStaticShortMethodA
+ .asFunction<
+ JniResult Function(JClassPtr clazz, JMethodIDPtr methodID,
+ ffi.Pointer<JValue> args)>();
int CallStaticShortMethodA(
JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallStaticShortMethodA.asFunction<
- JniResult Function(JClassPtr clazz, JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(clazz, methodID, args)
- .short;
+ _CallStaticShortMethodA(clazz, methodID, args).short;
+
+ late final _CallStaticIntMethod = ptr.ref.CallStaticIntMethod
+ .asFunction<JniResult Function(JClassPtr clazz, JMethodIDPtr methodID)>();
int CallStaticIntMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
- ref.CallStaticIntMethod.asFunction<
- JniResult Function(
- JClassPtr clazz, JMethodIDPtr methodID)>()(clazz, methodID)
- .integer;
+ _CallStaticIntMethod(clazz, methodID).integer;
+
+ late final _CallStaticIntMethodA = ptr.ref.CallStaticIntMethodA.asFunction<
+ JniResult Function(
+ JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
int CallStaticIntMethodA(
JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallStaticIntMethodA.asFunction<
- JniResult Function(JClassPtr clazz, JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(clazz, methodID, args)
- .integer;
+ _CallStaticIntMethodA(clazz, methodID, args).integer;
+
+ late final _CallStaticLongMethod = ptr.ref.CallStaticLongMethod
+ .asFunction<JniResult Function(JClassPtr clazz, JMethodIDPtr methodID)>();
int CallStaticLongMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
- ref.CallStaticLongMethod.asFunction<
- JniResult Function(
- JClassPtr clazz, JMethodIDPtr methodID)>()(clazz, methodID)
- .long;
+ _CallStaticLongMethod(clazz, methodID).long;
+
+ late final _CallStaticLongMethodA = ptr.ref.CallStaticLongMethodA.asFunction<
+ JniResult Function(
+ JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
int CallStaticLongMethodA(
JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallStaticLongMethodA.asFunction<
- JniResult Function(JClassPtr clazz, JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(clazz, methodID, args)
- .long;
+ _CallStaticLongMethodA(clazz, methodID, args).long;
+
+ late final _CallStaticFloatMethod = ptr.ref.CallStaticFloatMethod
+ .asFunction<JniResult Function(JClassPtr clazz, JMethodIDPtr methodID)>();
double CallStaticFloatMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
- ref.CallStaticFloatMethod.asFunction<
- JniResult Function(
- JClassPtr clazz, JMethodIDPtr methodID)>()(clazz, methodID)
- .float;
+ _CallStaticFloatMethod(clazz, methodID).float;
+
+ late final _CallStaticFloatMethodA = ptr.ref.CallStaticFloatMethodA
+ .asFunction<
+ JniResult Function(JClassPtr clazz, JMethodIDPtr methodID,
+ ffi.Pointer<JValue> args)>();
double CallStaticFloatMethodA(
JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallStaticFloatMethodA.asFunction<
- JniResult Function(JClassPtr clazz, JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(clazz, methodID, args)
- .float;
+ _CallStaticFloatMethodA(clazz, methodID, args).float;
+
+ late final _CallStaticDoubleMethod = ptr.ref.CallStaticDoubleMethod
+ .asFunction<JniResult Function(JClassPtr clazz, JMethodIDPtr methodID)>();
double CallStaticDoubleMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
- ref.CallStaticDoubleMethod.asFunction<
- JniResult Function(
- JClassPtr clazz, JMethodIDPtr methodID)>()(clazz, methodID)
- .doubleFloat;
+ _CallStaticDoubleMethod(clazz, methodID).doubleFloat;
+
+ late final _CallStaticDoubleMethodA = ptr.ref.CallStaticDoubleMethodA
+ .asFunction<
+ JniResult Function(JClassPtr clazz, JMethodIDPtr methodID,
+ ffi.Pointer<JValue> args)>();
double CallStaticDoubleMethodA(
JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallStaticDoubleMethodA.asFunction<
- JniResult Function(JClassPtr clazz, JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(clazz, methodID, args)
- .doubleFloat;
+ _CallStaticDoubleMethodA(clazz, methodID, args).doubleFloat;
+
+ late final _CallStaticVoidMethod = ptr.ref.CallStaticVoidMethod.asFunction<
+ JThrowablePtr Function(JClassPtr clazz, JMethodIDPtr methodID)>();
void CallStaticVoidMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
- ref.CallStaticVoidMethod.asFunction<
- JThrowablePtr Function(
- JClassPtr clazz, JMethodIDPtr methodID)>()(clazz, methodID)
- .check();
+ _CallStaticVoidMethod(clazz, methodID).check();
+
+ late final _CallStaticVoidMethodA = ptr.ref.CallStaticVoidMethodA.asFunction<
+ JThrowablePtr Function(
+ JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args)>();
void CallStaticVoidMethodA(
JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- ref.CallStaticVoidMethodA.asFunction<
- JThrowablePtr Function(JClassPtr clazz, JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(clazz, methodID, args)
- .check();
+ _CallStaticVoidMethodA(clazz, methodID, args).check();
+
+ late final _GetStaticFieldID = ptr.ref.GetStaticFieldID.asFunction<
+ JniPointerResult Function(JClassPtr clazz, ffi.Pointer<ffi.Char> name,
+ ffi.Pointer<ffi.Char> sig)>();
JFieldIDPtr GetStaticFieldID(JClassPtr clazz, ffi.Pointer<ffi.Char> name,
ffi.Pointer<ffi.Char> sig) =>
- ref.GetStaticFieldID.asFunction<
- JniPointerResult Function(
- JClassPtr clazz,
- ffi.Pointer<ffi.Char> name,
- ffi.Pointer<ffi.Char> sig)>()(clazz, name, sig)
- .fieldID;
+ _GetStaticFieldID(clazz, name, sig).fieldID;
+
+ late final _GetStaticObjectField = ptr.ref.GetStaticObjectField
+ .asFunction<JniResult Function(JClassPtr clazz, JFieldIDPtr fieldID)>();
JObjectPtr GetStaticObjectField(JClassPtr clazz, JFieldIDPtr fieldID) =>
- ref.GetStaticObjectField.asFunction<
- JniResult Function(
- JClassPtr clazz, JFieldIDPtr fieldID)>()(clazz, fieldID)
- .object;
+ _GetStaticObjectField(clazz, fieldID).object;
+
+ late final _GetStaticBooleanField = ptr.ref.GetStaticBooleanField
+ .asFunction<JniResult Function(JClassPtr clazz, JFieldIDPtr fieldID)>();
bool GetStaticBooleanField(JClassPtr clazz, JFieldIDPtr fieldID) =>
- ref.GetStaticBooleanField.asFunction<
- JniResult Function(
- JClassPtr clazz, JFieldIDPtr fieldID)>()(clazz, fieldID)
- .boolean;
+ _GetStaticBooleanField(clazz, fieldID).boolean;
+
+ late final _GetStaticByteField = ptr.ref.GetStaticByteField
+ .asFunction<JniResult Function(JClassPtr clazz, JFieldIDPtr fieldID)>();
int GetStaticByteField(JClassPtr clazz, JFieldIDPtr fieldID) =>
- ref.GetStaticByteField.asFunction<
- JniResult Function(
- JClassPtr clazz, JFieldIDPtr fieldID)>()(clazz, fieldID)
- .byte;
+ _GetStaticByteField(clazz, fieldID).byte;
+
+ late final _GetStaticCharField = ptr.ref.GetStaticCharField
+ .asFunction<JniResult Function(JClassPtr clazz, JFieldIDPtr fieldID)>();
int GetStaticCharField(JClassPtr clazz, JFieldIDPtr fieldID) =>
- ref.GetStaticCharField.asFunction<
- JniResult Function(
- JClassPtr clazz, JFieldIDPtr fieldID)>()(clazz, fieldID)
- .char;
+ _GetStaticCharField(clazz, fieldID).char;
+
+ late final _GetStaticShortField = ptr.ref.GetStaticShortField
+ .asFunction<JniResult Function(JClassPtr clazz, JFieldIDPtr fieldID)>();
int GetStaticShortField(JClassPtr clazz, JFieldIDPtr fieldID) =>
- ref.GetStaticShortField.asFunction<
- JniResult Function(
- JClassPtr clazz, JFieldIDPtr fieldID)>()(clazz, fieldID)
- .short;
+ _GetStaticShortField(clazz, fieldID).short;
+
+ late final _GetStaticIntField = ptr.ref.GetStaticIntField
+ .asFunction<JniResult Function(JClassPtr clazz, JFieldIDPtr fieldID)>();
int GetStaticIntField(JClassPtr clazz, JFieldIDPtr fieldID) =>
- ref.GetStaticIntField.asFunction<
- JniResult Function(
- JClassPtr clazz, JFieldIDPtr fieldID)>()(clazz, fieldID)
- .integer;
+ _GetStaticIntField(clazz, fieldID).integer;
+
+ late final _GetStaticLongField = ptr.ref.GetStaticLongField
+ .asFunction<JniResult Function(JClassPtr clazz, JFieldIDPtr fieldID)>();
int GetStaticLongField(JClassPtr clazz, JFieldIDPtr fieldID) =>
- ref.GetStaticLongField.asFunction<
- JniResult Function(
- JClassPtr clazz, JFieldIDPtr fieldID)>()(clazz, fieldID)
- .long;
+ _GetStaticLongField(clazz, fieldID).long;
+
+ late final _GetStaticFloatField = ptr.ref.GetStaticFloatField
+ .asFunction<JniResult Function(JClassPtr clazz, JFieldIDPtr fieldID)>();
double GetStaticFloatField(JClassPtr clazz, JFieldIDPtr fieldID) =>
- ref.GetStaticFloatField.asFunction<
- JniResult Function(
- JClassPtr clazz, JFieldIDPtr fieldID)>()(clazz, fieldID)
- .float;
+ _GetStaticFloatField(clazz, fieldID).float;
+
+ late final _GetStaticDoubleField = ptr.ref.GetStaticDoubleField
+ .asFunction<JniResult Function(JClassPtr clazz, JFieldIDPtr fieldID)>();
double GetStaticDoubleField(JClassPtr clazz, JFieldIDPtr fieldID) =>
- ref.GetStaticDoubleField.asFunction<
- JniResult Function(
- JClassPtr clazz, JFieldIDPtr fieldID)>()(clazz, fieldID)
- .doubleFloat;
+ _GetStaticDoubleField(clazz, fieldID).doubleFloat;
+
+ late final _SetStaticObjectField = ptr.ref.SetStaticObjectField.asFunction<
+ JThrowablePtr Function(
+ JClassPtr clazz, JFieldIDPtr fieldID, JObjectPtr val)>();
void SetStaticObjectField(
JClassPtr clazz, JFieldIDPtr fieldID, JObjectPtr val) =>
- ref.SetStaticObjectField.asFunction<
- JThrowablePtr Function(JClassPtr clazz, JFieldIDPtr fieldID,
- JObjectPtr val)>()(clazz, fieldID, val)
- .check();
+ _SetStaticObjectField(clazz, fieldID, val).check();
+
+ late final _SetStaticBooleanField = ptr.ref.SetStaticBooleanField.asFunction<
+ JThrowablePtr Function(JClassPtr clazz, JFieldIDPtr fieldID, int val)>();
void SetStaticBooleanField(JClassPtr clazz, JFieldIDPtr fieldID, int val) =>
- ref.SetStaticBooleanField.asFunction<
- JThrowablePtr Function(JClassPtr clazz, JFieldIDPtr fieldID,
- int val)>()(clazz, fieldID, val)
- .check();
+ _SetStaticBooleanField(clazz, fieldID, val).check();
+
+ late final _SetStaticByteField = ptr.ref.SetStaticByteField.asFunction<
+ JThrowablePtr Function(JClassPtr clazz, JFieldIDPtr fieldID, int val)>();
void SetStaticByteField(JClassPtr clazz, JFieldIDPtr fieldID, int val) =>
- ref.SetStaticByteField.asFunction<
- JThrowablePtr Function(JClassPtr clazz, JFieldIDPtr fieldID,
- int val)>()(clazz, fieldID, val)
- .check();
+ _SetStaticByteField(clazz, fieldID, val).check();
+
+ late final _SetStaticCharField = ptr.ref.SetStaticCharField.asFunction<
+ JThrowablePtr Function(JClassPtr clazz, JFieldIDPtr fieldID, int val)>();
void SetStaticCharField(JClassPtr clazz, JFieldIDPtr fieldID, int val) =>
- ref.SetStaticCharField.asFunction<
- JThrowablePtr Function(JClassPtr clazz, JFieldIDPtr fieldID,
- int val)>()(clazz, fieldID, val)
- .check();
+ _SetStaticCharField(clazz, fieldID, val).check();
+
+ late final _SetStaticShortField = ptr.ref.SetStaticShortField.asFunction<
+ JThrowablePtr Function(JClassPtr clazz, JFieldIDPtr fieldID, int val)>();
void SetStaticShortField(JClassPtr clazz, JFieldIDPtr fieldID, int val) =>
- ref.SetStaticShortField.asFunction<
- JThrowablePtr Function(JClassPtr clazz, JFieldIDPtr fieldID,
- int val)>()(clazz, fieldID, val)
- .check();
+ _SetStaticShortField(clazz, fieldID, val).check();
+
+ late final _SetStaticIntField = ptr.ref.SetStaticIntField.asFunction<
+ JThrowablePtr Function(JClassPtr clazz, JFieldIDPtr fieldID, int val)>();
void SetStaticIntField(JClassPtr clazz, JFieldIDPtr fieldID, int val) =>
- ref.SetStaticIntField.asFunction<
- JThrowablePtr Function(JClassPtr clazz, JFieldIDPtr fieldID,
- int val)>()(clazz, fieldID, val)
- .check();
+ _SetStaticIntField(clazz, fieldID, val).check();
+
+ late final _SetStaticLongField = ptr.ref.SetStaticLongField.asFunction<
+ JThrowablePtr Function(JClassPtr clazz, JFieldIDPtr fieldID, int val)>();
void SetStaticLongField(JClassPtr clazz, JFieldIDPtr fieldID, int val) =>
- ref.SetStaticLongField.asFunction<
- JThrowablePtr Function(JClassPtr clazz, JFieldIDPtr fieldID,
- int val)>()(clazz, fieldID, val)
- .check();
+ _SetStaticLongField(clazz, fieldID, val).check();
+
+ late final _SetStaticFloatField = ptr.ref.SetStaticFloatField.asFunction<
+ JThrowablePtr Function(
+ JClassPtr clazz, JFieldIDPtr fieldID, double val)>();
void SetStaticFloatField(JClassPtr clazz, JFieldIDPtr fieldID, double val) =>
- ref.SetStaticFloatField.asFunction<
- JThrowablePtr Function(JClassPtr clazz, JFieldIDPtr fieldID,
- double val)>()(clazz, fieldID, val)
- .check();
+ _SetStaticFloatField(clazz, fieldID, val).check();
+
+ late final _SetStaticDoubleField = ptr.ref.SetStaticDoubleField.asFunction<
+ JThrowablePtr Function(
+ JClassPtr clazz, JFieldIDPtr fieldID, double val)>();
void SetStaticDoubleField(JClassPtr clazz, JFieldIDPtr fieldID, double val) =>
- ref.SetStaticDoubleField.asFunction<
- JThrowablePtr Function(JClassPtr clazz, JFieldIDPtr fieldID,
- double val)>()(clazz, fieldID, val)
- .check();
+ _SetStaticDoubleField(clazz, fieldID, val).check();
+
+ late final _NewString = ptr.ref.NewString.asFunction<
+ JniResult Function(ffi.Pointer<JCharMarker> unicodeChars, int len)>();
JStringPtr NewString(ffi.Pointer<JCharMarker> unicodeChars, int len) =>
- ref.NewString.asFunction<
- JniResult Function(ffi.Pointer<JCharMarker> unicodeChars,
- int len)>()(unicodeChars, len)
- .object;
+ _NewString(unicodeChars, len).object;
- int GetStringLength(JStringPtr string) =>
- ref.GetStringLength.asFunction<JniResult Function(JStringPtr string)>()(
- string)
- .integer;
+ late final _GetStringLength = ptr.ref.GetStringLength
+ .asFunction<JniResult Function(JStringPtr string)>();
+
+ int GetStringLength(JStringPtr string) => _GetStringLength(string).integer;
+
+ late final _GetStringChars = ptr.ref.GetStringChars.asFunction<
+ JniPointerResult Function(
+ JStringPtr string, ffi.Pointer<JBooleanMarker> isCopy)>();
ffi.Pointer<JCharMarker> GetStringChars(
JStringPtr string, ffi.Pointer<JBooleanMarker> isCopy) =>
- ref.GetStringChars.asFunction<
- JniPointerResult Function(JStringPtr string,
- ffi.Pointer<JBooleanMarker> isCopy)>()(string, isCopy)
- .getPointer<JCharMarker>();
+ _GetStringChars(string, isCopy).getPointer<JCharMarker>();
+
+ late final _ReleaseStringChars = ptr.ref.ReleaseStringChars.asFunction<
+ JThrowablePtr Function(
+ JStringPtr string, ffi.Pointer<JCharMarker> isCopy)>();
void ReleaseStringChars(JStringPtr string, ffi.Pointer<JCharMarker> isCopy) =>
- ref.ReleaseStringChars.asFunction<
- JThrowablePtr Function(JStringPtr string,
- ffi.Pointer<JCharMarker> isCopy)>()(string, isCopy)
- .check();
+ _ReleaseStringChars(string, isCopy).check();
- JStringPtr NewStringUTF(ffi.Pointer<ffi.Char> bytes) => ref.NewStringUTF
- .asFunction<JniResult Function(ffi.Pointer<ffi.Char> bytes)>()(bytes)
- .object;
+ late final _NewStringUTF = ptr.ref.NewStringUTF
+ .asFunction<JniResult Function(ffi.Pointer<ffi.Char> bytes)>();
- int GetStringUTFLength(JStringPtr string) => ref.GetStringUTFLength
- .asFunction<JniResult Function(JStringPtr string)>()(string)
- .integer;
+ JStringPtr NewStringUTF(ffi.Pointer<ffi.Char> bytes) =>
+ _NewStringUTF(bytes).object;
+
+ late final _GetStringUTFLength = ptr.ref.GetStringUTFLength
+ .asFunction<JniResult Function(JStringPtr string)>();
+
+ int GetStringUTFLength(JStringPtr string) =>
+ _GetStringUTFLength(string).integer;
+
+ late final _GetStringUTFChars = ptr.ref.GetStringUTFChars.asFunction<
+ JniPointerResult Function(
+ JStringPtr string, ffi.Pointer<JBooleanMarker> isCopy)>();
ffi.Pointer<ffi.Char> GetStringUTFChars(
JStringPtr string, ffi.Pointer<JBooleanMarker> isCopy) =>
- ref.GetStringUTFChars.asFunction<
- JniPointerResult Function(JStringPtr string,
- ffi.Pointer<JBooleanMarker> isCopy)>()(string, isCopy)
- .getPointer<ffi.Char>();
+ _GetStringUTFChars(string, isCopy).getPointer<ffi.Char>();
+
+ late final _ReleaseStringUTFChars = ptr.ref.ReleaseStringUTFChars.asFunction<
+ JThrowablePtr Function(JStringPtr string, ffi.Pointer<ffi.Char> utf)>();
void ReleaseStringUTFChars(JStringPtr string, ffi.Pointer<ffi.Char> utf) =>
- ref.ReleaseStringUTFChars.asFunction<
- JThrowablePtr Function(
- JStringPtr string, ffi.Pointer<ffi.Char> utf)>()(string, utf)
- .check();
+ _ReleaseStringUTFChars(string, utf).check();
- int GetArrayLength(JArrayPtr array) =>
- ref.GetArrayLength.asFunction<JniResult Function(JArrayPtr array)>()(
- array)
- .integer;
+ late final _GetArrayLength =
+ ptr.ref.GetArrayLength.asFunction<JniResult Function(JArrayPtr array)>();
+
+ int GetArrayLength(JArrayPtr array) => _GetArrayLength(array).integer;
+
+ late final _NewObjectArray = ptr.ref.NewObjectArray.asFunction<
+ JniResult Function(
+ int length, JClassPtr elementClass, JObjectPtr initialElement)>();
JObjectArrayPtr NewObjectArray(
int length, JClassPtr elementClass, JObjectPtr initialElement) =>
- ref.NewObjectArray.asFunction<
- JniResult Function(int length, JClassPtr elementClass,
- JObjectPtr initialElement)>()(
- length, elementClass, initialElement)
- .object;
+ _NewObjectArray(length, elementClass, initialElement).object;
+
+ late final _GetObjectArrayElement = ptr.ref.GetObjectArrayElement
+ .asFunction<JniResult Function(JObjectArrayPtr array, int index)>();
JObjectPtr GetObjectArrayElement(JObjectArrayPtr array, int index) =>
- ref.GetObjectArrayElement.asFunction<
- JniResult Function(
- JObjectArrayPtr array, int index)>()(array, index)
- .object;
+ _GetObjectArrayElement(array, index).object;
+
+ late final _SetObjectArrayElement = ptr.ref.SetObjectArrayElement.asFunction<
+ JThrowablePtr Function(
+ JObjectArrayPtr array, int index, JObjectPtr val)>();
void SetObjectArrayElement(
JObjectArrayPtr array, int index, JObjectPtr val) =>
- ref.SetObjectArrayElement.asFunction<
- JThrowablePtr Function(JObjectArrayPtr array, int index,
- JObjectPtr val)>()(array, index, val)
- .check();
+ _SetObjectArrayElement(array, index, val).check();
+
+ late final _NewBooleanArray =
+ ptr.ref.NewBooleanArray.asFunction<JniResult Function(int length)>();
JBooleanArrayPtr NewBooleanArray(int length) =>
- ref.NewBooleanArray.asFunction<JniResult Function(int length)>()(length)
- .object;
+ _NewBooleanArray(length).object;
- JByteArrayPtr NewByteArray(int length) =>
- ref.NewByteArray.asFunction<JniResult Function(int length)>()(length)
- .object;
+ late final _NewByteArray =
+ ptr.ref.NewByteArray.asFunction<JniResult Function(int length)>();
- JCharArrayPtr NewCharArray(int length) =>
- ref.NewCharArray.asFunction<JniResult Function(int length)>()(length)
- .object;
+ JByteArrayPtr NewByteArray(int length) => _NewByteArray(length).object;
- JShortArrayPtr NewShortArray(int length) =>
- ref.NewShortArray.asFunction<JniResult Function(int length)>()(length)
- .object;
+ late final _NewCharArray =
+ ptr.ref.NewCharArray.asFunction<JniResult Function(int length)>();
- JIntArrayPtr NewIntArray(int length) =>
- ref.NewIntArray.asFunction<JniResult Function(int length)>()(length)
- .object;
+ JCharArrayPtr NewCharArray(int length) => _NewCharArray(length).object;
- JLongArrayPtr NewLongArray(int length) =>
- ref.NewLongArray.asFunction<JniResult Function(int length)>()(length)
- .object;
+ late final _NewShortArray =
+ ptr.ref.NewShortArray.asFunction<JniResult Function(int length)>();
- JFloatArrayPtr NewFloatArray(int length) =>
- ref.NewFloatArray.asFunction<JniResult Function(int length)>()(length)
- .object;
+ JShortArrayPtr NewShortArray(int length) => _NewShortArray(length).object;
- JDoubleArrayPtr NewDoubleArray(int length) =>
- ref.NewDoubleArray.asFunction<JniResult Function(int length)>()(length)
- .object;
+ late final _NewIntArray =
+ ptr.ref.NewIntArray.asFunction<JniResult Function(int length)>();
+
+ JIntArrayPtr NewIntArray(int length) => _NewIntArray(length).object;
+
+ late final _NewLongArray =
+ ptr.ref.NewLongArray.asFunction<JniResult Function(int length)>();
+
+ JLongArrayPtr NewLongArray(int length) => _NewLongArray(length).object;
+
+ late final _NewFloatArray =
+ ptr.ref.NewFloatArray.asFunction<JniResult Function(int length)>();
+
+ JFloatArrayPtr NewFloatArray(int length) => _NewFloatArray(length).object;
+
+ late final _NewDoubleArray =
+ ptr.ref.NewDoubleArray.asFunction<JniResult Function(int length)>();
+
+ JDoubleArrayPtr NewDoubleArray(int length) => _NewDoubleArray(length).object;
+
+ late final _GetBooleanArrayElements = ptr.ref.GetBooleanArrayElements
+ .asFunction<
+ JniPointerResult Function(
+ JBooleanArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy)>();
ffi.Pointer<JBooleanMarker> GetBooleanArrayElements(
JBooleanArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy) =>
- ref.GetBooleanArrayElements.asFunction<
- JniPointerResult Function(JBooleanArrayPtr array,
- ffi.Pointer<JBooleanMarker> isCopy)>()(array, isCopy)
- .getPointer<JBooleanMarker>();
+ _GetBooleanArrayElements(array, isCopy).getPointer<JBooleanMarker>();
+
+ late final _GetByteArrayElements = ptr.ref.GetByteArrayElements.asFunction<
+ JniPointerResult Function(
+ JByteArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy)>();
ffi.Pointer<JByteMarker> GetByteArrayElements(
JByteArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy) =>
- ref.GetByteArrayElements.asFunction<
- JniPointerResult Function(JByteArrayPtr array,
- ffi.Pointer<JBooleanMarker> isCopy)>()(array, isCopy)
- .getPointer<JByteMarker>();
+ _GetByteArrayElements(array, isCopy).getPointer<JByteMarker>();
+
+ late final _GetCharArrayElements = ptr.ref.GetCharArrayElements.asFunction<
+ JniPointerResult Function(
+ JCharArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy)>();
ffi.Pointer<JCharMarker> GetCharArrayElements(
JCharArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy) =>
- ref.GetCharArrayElements.asFunction<
- JniPointerResult Function(JCharArrayPtr array,
- ffi.Pointer<JBooleanMarker> isCopy)>()(array, isCopy)
- .getPointer<JCharMarker>();
+ _GetCharArrayElements(array, isCopy).getPointer<JCharMarker>();
+
+ late final _GetShortArrayElements = ptr.ref.GetShortArrayElements.asFunction<
+ JniPointerResult Function(
+ JShortArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy)>();
ffi.Pointer<JShortMarker> GetShortArrayElements(
JShortArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy) =>
- ref.GetShortArrayElements.asFunction<
- JniPointerResult Function(JShortArrayPtr array,
- ffi.Pointer<JBooleanMarker> isCopy)>()(array, isCopy)
- .getPointer<JShortMarker>();
+ _GetShortArrayElements(array, isCopy).getPointer<JShortMarker>();
+
+ late final _GetIntArrayElements = ptr.ref.GetIntArrayElements.asFunction<
+ JniPointerResult Function(
+ JIntArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy)>();
ffi.Pointer<JIntMarker> GetIntArrayElements(
JIntArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy) =>
- ref.GetIntArrayElements.asFunction<
- JniPointerResult Function(JIntArrayPtr array,
- ffi.Pointer<JBooleanMarker> isCopy)>()(array, isCopy)
- .getPointer<JIntMarker>();
+ _GetIntArrayElements(array, isCopy).getPointer<JIntMarker>();
+
+ late final _GetLongArrayElements = ptr.ref.GetLongArrayElements.asFunction<
+ JniPointerResult Function(
+ JLongArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy)>();
ffi.Pointer<JLongMarker> GetLongArrayElements(
JLongArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy) =>
- ref.GetLongArrayElements.asFunction<
- JniPointerResult Function(JLongArrayPtr array,
- ffi.Pointer<JBooleanMarker> isCopy)>()(array, isCopy)
- .getPointer<JLongMarker>();
+ _GetLongArrayElements(array, isCopy).getPointer<JLongMarker>();
+
+ late final _GetFloatArrayElements = ptr.ref.GetFloatArrayElements.asFunction<
+ JniPointerResult Function(
+ JFloatArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy)>();
ffi.Pointer<JFloatMarker> GetFloatArrayElements(
JFloatArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy) =>
- ref.GetFloatArrayElements.asFunction<
- JniPointerResult Function(JFloatArrayPtr array,
- ffi.Pointer<JBooleanMarker> isCopy)>()(array, isCopy)
- .getPointer<JFloatMarker>();
+ _GetFloatArrayElements(array, isCopy).getPointer<JFloatMarker>();
+
+ late final _GetDoubleArrayElements = ptr.ref.GetDoubleArrayElements
+ .asFunction<
+ JniPointerResult Function(
+ JDoubleArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy)>();
ffi.Pointer<JDoubleMarker> GetDoubleArrayElements(
JDoubleArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy) =>
- ref.GetDoubleArrayElements.asFunction<
- JniPointerResult Function(JDoubleArrayPtr array,
- ffi.Pointer<JBooleanMarker> isCopy)>()(array, isCopy)
- .getPointer<JDoubleMarker>();
+ _GetDoubleArrayElements(array, isCopy).getPointer<JDoubleMarker>();
+
+ late final _ReleaseBooleanArrayElements = ptr.ref.ReleaseBooleanArrayElements
+ .asFunction<
+ JThrowablePtr Function(JBooleanArrayPtr array,
+ ffi.Pointer<JBooleanMarker> elems, int mode)>();
void ReleaseBooleanArrayElements(JBooleanArrayPtr array,
ffi.Pointer<JBooleanMarker> elems, int mode) =>
- ref.ReleaseBooleanArrayElements.asFunction<
- JThrowablePtr Function(
- JBooleanArrayPtr array,
- ffi.Pointer<JBooleanMarker> elems,
- int mode)>()(array, elems, mode)
- .check();
+ _ReleaseBooleanArrayElements(array, elems, mode).check();
+
+ late final _ReleaseByteArrayElements = ptr.ref.ReleaseByteArrayElements
+ .asFunction<
+ JThrowablePtr Function(
+ JByteArrayPtr array, ffi.Pointer<JByteMarker> elems, int mode)>();
void ReleaseByteArrayElements(
JByteArrayPtr array, ffi.Pointer<JByteMarker> elems, int mode) =>
- ref.ReleaseByteArrayElements.asFunction<
- JThrowablePtr Function(
- JByteArrayPtr array,
- ffi.Pointer<JByteMarker> elems,
- int mode)>()(array, elems, mode)
- .check();
+ _ReleaseByteArrayElements(array, elems, mode).check();
+
+ late final _ReleaseCharArrayElements = ptr.ref.ReleaseCharArrayElements
+ .asFunction<
+ JThrowablePtr Function(
+ JCharArrayPtr array, ffi.Pointer<JCharMarker> elems, int mode)>();
void ReleaseCharArrayElements(
JCharArrayPtr array, ffi.Pointer<JCharMarker> elems, int mode) =>
- ref.ReleaseCharArrayElements.asFunction<
- JThrowablePtr Function(
- JCharArrayPtr array,
- ffi.Pointer<JCharMarker> elems,
- int mode)>()(array, elems, mode)
- .check();
+ _ReleaseCharArrayElements(array, elems, mode).check();
+
+ late final _ReleaseShortArrayElements = ptr.ref.ReleaseShortArrayElements
+ .asFunction<
+ JThrowablePtr Function(JShortArrayPtr array,
+ ffi.Pointer<JShortMarker> elems, int mode)>();
void ReleaseShortArrayElements(
JShortArrayPtr array, ffi.Pointer<JShortMarker> elems, int mode) =>
- ref.ReleaseShortArrayElements.asFunction<
- JThrowablePtr Function(
- JShortArrayPtr array,
- ffi.Pointer<JShortMarker> elems,
- int mode)>()(array, elems, mode)
- .check();
+ _ReleaseShortArrayElements(array, elems, mode).check();
+
+ late final _ReleaseIntArrayElements = ptr.ref.ReleaseIntArrayElements
+ .asFunction<
+ JThrowablePtr Function(
+ JIntArrayPtr array, ffi.Pointer<JIntMarker> elems, int mode)>();
void ReleaseIntArrayElements(
JIntArrayPtr array, ffi.Pointer<JIntMarker> elems, int mode) =>
- ref.ReleaseIntArrayElements.asFunction<
- JThrowablePtr Function(
- JIntArrayPtr array,
- ffi.Pointer<JIntMarker> elems,
- int mode)>()(array, elems, mode)
- .check();
+ _ReleaseIntArrayElements(array, elems, mode).check();
+
+ late final _ReleaseLongArrayElements = ptr.ref.ReleaseLongArrayElements
+ .asFunction<
+ JThrowablePtr Function(
+ JLongArrayPtr array, ffi.Pointer<JLongMarker> elems, int mode)>();
void ReleaseLongArrayElements(
JLongArrayPtr array, ffi.Pointer<JLongMarker> elems, int mode) =>
- ref.ReleaseLongArrayElements.asFunction<
- JThrowablePtr Function(
- JLongArrayPtr array,
- ffi.Pointer<JLongMarker> elems,
- int mode)>()(array, elems, mode)
- .check();
+ _ReleaseLongArrayElements(array, elems, mode).check();
+
+ late final _ReleaseFloatArrayElements = ptr.ref.ReleaseFloatArrayElements
+ .asFunction<
+ JThrowablePtr Function(JFloatArrayPtr array,
+ ffi.Pointer<JFloatMarker> elems, int mode)>();
void ReleaseFloatArrayElements(
JFloatArrayPtr array, ffi.Pointer<JFloatMarker> elems, int mode) =>
- ref.ReleaseFloatArrayElements.asFunction<
- JThrowablePtr Function(
- JFloatArrayPtr array,
- ffi.Pointer<JFloatMarker> elems,
- int mode)>()(array, elems, mode)
- .check();
+ _ReleaseFloatArrayElements(array, elems, mode).check();
+
+ late final _ReleaseDoubleArrayElements = ptr.ref.ReleaseDoubleArrayElements
+ .asFunction<
+ JThrowablePtr Function(JDoubleArrayPtr array,
+ ffi.Pointer<JDoubleMarker> elems, int mode)>();
void ReleaseDoubleArrayElements(
JDoubleArrayPtr array, ffi.Pointer<JDoubleMarker> elems, int mode) =>
- ref.ReleaseDoubleArrayElements.asFunction<
- JThrowablePtr Function(
- JDoubleArrayPtr array,
- ffi.Pointer<JDoubleMarker> elems,
- int mode)>()(array, elems, mode)
- .check();
+ _ReleaseDoubleArrayElements(array, elems, mode).check();
+
+ late final _GetBooleanArrayRegion = ptr.ref.GetBooleanArrayRegion.asFunction<
+ JThrowablePtr Function(JBooleanArrayPtr array, int start, int len,
+ ffi.Pointer<JBooleanMarker> buf)>();
void GetBooleanArrayRegion(JBooleanArrayPtr array, int start, int len,
ffi.Pointer<JBooleanMarker> buf) =>
- ref.GetBooleanArrayRegion.asFunction<
- JThrowablePtr Function(JBooleanArrayPtr array, int start, int len,
- ffi.Pointer<JBooleanMarker> buf)>()(array, start, len, buf)
- .check();
+ _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)>();
void GetByteArrayRegion(JByteArrayPtr array, int start, int len,
ffi.Pointer<JByteMarker> buf) =>
- ref.GetByteArrayRegion.asFunction<
- JThrowablePtr Function(JByteArrayPtr array, int start, int len,
- ffi.Pointer<JByteMarker> buf)>()(array, start, len, buf)
- .check();
+ _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)>();
void GetCharArrayRegion(JCharArrayPtr array, int start, int len,
ffi.Pointer<JCharMarker> buf) =>
- ref.GetCharArrayRegion.asFunction<
- JThrowablePtr Function(JCharArrayPtr array, int start, int len,
- ffi.Pointer<JCharMarker> buf)>()(array, start, len, buf)
- .check();
+ _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)>();
void GetShortArrayRegion(JShortArrayPtr array, int start, int len,
ffi.Pointer<JShortMarker> buf) =>
- ref.GetShortArrayRegion.asFunction<
- JThrowablePtr Function(JShortArrayPtr array, int start, int len,
- ffi.Pointer<JShortMarker> buf)>()(array, start, len, buf)
- .check();
+ _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)>();
void GetIntArrayRegion(JIntArrayPtr array, int start, int len,
ffi.Pointer<JIntMarker> buf) =>
- ref.GetIntArrayRegion.asFunction<
- JThrowablePtr Function(JIntArrayPtr array, int start, int len,
- ffi.Pointer<JIntMarker> buf)>()(array, start, len, buf)
- .check();
+ _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)>();
void GetLongArrayRegion(JLongArrayPtr array, int start, int len,
ffi.Pointer<JLongMarker> buf) =>
- ref.GetLongArrayRegion.asFunction<
- JThrowablePtr Function(JLongArrayPtr array, int start, int len,
- ffi.Pointer<JLongMarker> buf)>()(array, start, len, buf)
- .check();
+ _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)>();
void GetFloatArrayRegion(JFloatArrayPtr array, int start, int len,
ffi.Pointer<JFloatMarker> buf) =>
- ref.GetFloatArrayRegion.asFunction<
- JThrowablePtr Function(JFloatArrayPtr array, int start, int len,
- ffi.Pointer<JFloatMarker> buf)>()(array, start, len, buf)
- .check();
+ _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)>();
void GetDoubleArrayRegion(JDoubleArrayPtr array, int start, int len,
ffi.Pointer<JDoubleMarker> buf) =>
- ref.GetDoubleArrayRegion.asFunction<
- JThrowablePtr Function(JDoubleArrayPtr array, int start, int len,
- ffi.Pointer<JDoubleMarker> buf)>()(array, start, len, buf)
- .check();
+ _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)>();
void SetBooleanArrayRegion(JBooleanArrayPtr array, int start, int len,
ffi.Pointer<JBooleanMarker> buf) =>
- ref.SetBooleanArrayRegion.asFunction<
- JThrowablePtr Function(JBooleanArrayPtr array, int start, int len,
- ffi.Pointer<JBooleanMarker> buf)>()(array, start, len, buf)
- .check();
+ _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)>();
void SetByteArrayRegion(JByteArrayPtr array, int start, int len,
ffi.Pointer<JByteMarker> buf) =>
- ref.SetByteArrayRegion.asFunction<
- JThrowablePtr Function(JByteArrayPtr array, int start, int len,
- ffi.Pointer<JByteMarker> buf)>()(array, start, len, buf)
- .check();
+ _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)>();
void SetCharArrayRegion(JCharArrayPtr array, int start, int len,
ffi.Pointer<JCharMarker> buf) =>
- ref.SetCharArrayRegion.asFunction<
- JThrowablePtr Function(JCharArrayPtr array, int start, int len,
- ffi.Pointer<JCharMarker> buf)>()(array, start, len, buf)
- .check();
+ _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)>();
void SetShortArrayRegion(JShortArrayPtr array, int start, int len,
ffi.Pointer<JShortMarker> buf) =>
- ref.SetShortArrayRegion.asFunction<
- JThrowablePtr Function(JShortArrayPtr array, int start, int len,
- ffi.Pointer<JShortMarker> buf)>()(array, start, len, buf)
- .check();
+ _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)>();
void SetIntArrayRegion(JIntArrayPtr array, int start, int len,
ffi.Pointer<JIntMarker> buf) =>
- ref.SetIntArrayRegion.asFunction<
- JThrowablePtr Function(JIntArrayPtr array, int start, int len,
- ffi.Pointer<JIntMarker> buf)>()(array, start, len, buf)
- .check();
+ _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)>();
void SetLongArrayRegion(JLongArrayPtr array, int start, int len,
ffi.Pointer<JLongMarker> buf) =>
- ref.SetLongArrayRegion.asFunction<
- JThrowablePtr Function(JLongArrayPtr array, int start, int len,
- ffi.Pointer<JLongMarker> buf)>()(array, start, len, buf)
- .check();
+ _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)>();
void SetFloatArrayRegion(JFloatArrayPtr array, int start, int len,
ffi.Pointer<JFloatMarker> buf) =>
- ref.SetFloatArrayRegion.asFunction<
- JThrowablePtr Function(JFloatArrayPtr array, int start, int len,
- ffi.Pointer<JFloatMarker> buf)>()(array, start, len, buf)
- .check();
+ _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)>();
void SetDoubleArrayRegion(JDoubleArrayPtr array, int start, int len,
ffi.Pointer<JDoubleMarker> buf) =>
- ref.SetDoubleArrayRegion.asFunction<
- JThrowablePtr Function(JDoubleArrayPtr array, int start, int len,
- ffi.Pointer<JDoubleMarker> buf)>()(array, start, len, buf)
- .check();
+ _SetDoubleArrayRegion(array, start, len, buf).check();
+
+ late final _RegisterNatives = ptr.ref.RegisterNatives.asFunction<
+ JniResult Function(JClassPtr clazz, ffi.Pointer<JNINativeMethod> methods,
+ int nMethods)>();
int RegisterNatives(JClassPtr clazz, ffi.Pointer<JNINativeMethod> methods,
int nMethods) =>
- ref.RegisterNatives.asFunction<
- JniResult Function(
- JClassPtr clazz,
- ffi.Pointer<JNINativeMethod> methods,
- int nMethods)>()(clazz, methods, nMethods)
- .integer;
+ _RegisterNatives(clazz, methods, nMethods).integer;
- int UnregisterNatives(JClassPtr clazz) =>
- ref.UnregisterNatives.asFunction<JniResult Function(JClassPtr clazz)>()(
- clazz)
- .integer;
+ late final _UnregisterNatives = ptr.ref.UnregisterNatives
+ .asFunction<JniResult Function(JClassPtr clazz)>();
- int MonitorEnter(JObjectPtr obj) =>
- ref.MonitorEnter.asFunction<JniResult Function(JObjectPtr obj)>()(obj)
- .integer;
+ int UnregisterNatives(JClassPtr clazz) => _UnregisterNatives(clazz).integer;
- int MonitorExit(JObjectPtr obj) =>
- ref.MonitorExit.asFunction<JniResult Function(JObjectPtr obj)>()(obj)
- .integer;
+ late final _MonitorEnter =
+ ptr.ref.MonitorEnter.asFunction<JniResult Function(JObjectPtr obj)>();
- int GetJavaVM(ffi.Pointer<ffi.Pointer<JavaVM1>> vm) =>
- ref.GetJavaVM.asFunction<
- JniResult Function(ffi.Pointer<ffi.Pointer<JavaVM1>> vm)>()(vm)
- .integer;
+ int MonitorEnter(JObjectPtr obj) => _MonitorEnter(obj).integer;
+
+ late final _MonitorExit =
+ ptr.ref.MonitorExit.asFunction<JniResult Function(JObjectPtr obj)>();
+
+ int MonitorExit(JObjectPtr obj) => _MonitorExit(obj).integer;
+
+ late final _GetJavaVM = ptr.ref.GetJavaVM
+ .asFunction<JniResult Function(ffi.Pointer<ffi.Pointer<JavaVM1>> vm)>();
+
+ int GetJavaVM(ffi.Pointer<ffi.Pointer<JavaVM1>> vm) => _GetJavaVM(vm).integer;
+
+ late final _GetStringRegion = ptr.ref.GetStringRegion.asFunction<
+ JThrowablePtr Function(
+ JStringPtr str, int start, int len, ffi.Pointer<JCharMarker> buf)>();
void GetStringRegion(
JStringPtr str, int start, int len, ffi.Pointer<JCharMarker> buf) =>
- ref.GetStringRegion.asFunction<
- JThrowablePtr Function(JStringPtr str, int start, int len,
- ffi.Pointer<JCharMarker> buf)>()(str, start, len, buf)
- .check();
+ _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)>();
void GetStringUTFRegion(
JStringPtr str, int start, int len, ffi.Pointer<ffi.Char> buf) =>
- ref.GetStringUTFRegion.asFunction<
- JThrowablePtr Function(JStringPtr str, int start, int len,
- ffi.Pointer<ffi.Char> buf)>()(str, start, len, buf)
- .check();
+ _GetStringUTFRegion(str, start, len, buf).check();
+
+ late final _GetPrimitiveArrayCritical = ptr.ref.GetPrimitiveArrayCritical
+ .asFunction<
+ JniPointerResult Function(
+ JArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy)>();
ffi.Pointer<ffi.Void> GetPrimitiveArrayCritical(
JArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy) =>
- ref.GetPrimitiveArrayCritical.asFunction<
- JniPointerResult Function(JArrayPtr array,
- ffi.Pointer<JBooleanMarker> isCopy)>()(array, isCopy)
- .getPointer<ffi.Void>();
+ _GetPrimitiveArrayCritical(array, isCopy).getPointer<ffi.Void>();
+
+ late final _ReleasePrimitiveArrayCritical =
+ ptr.ref.ReleasePrimitiveArrayCritical.asFunction<
+ JThrowablePtr Function(
+ JArrayPtr array, ffi.Pointer<ffi.Void> carray, int mode)>();
void ReleasePrimitiveArrayCritical(
JArrayPtr array, ffi.Pointer<ffi.Void> carray, int mode) =>
- ref.ReleasePrimitiveArrayCritical.asFunction<
- JThrowablePtr Function(
- JArrayPtr array,
- ffi.Pointer<ffi.Void> carray,
- int mode)>()(array, carray, mode)
- .check();
+ _ReleasePrimitiveArrayCritical(array, carray, mode).check();
+
+ late final _GetStringCritical = ptr.ref.GetStringCritical.asFunction<
+ JniPointerResult Function(
+ JStringPtr str, ffi.Pointer<JBooleanMarker> isCopy)>();
ffi.Pointer<JCharMarker> GetStringCritical(
JStringPtr str, ffi.Pointer<JBooleanMarker> isCopy) =>
- ref.GetStringCritical.asFunction<
- JniPointerResult Function(JStringPtr str,
- ffi.Pointer<JBooleanMarker> isCopy)>()(str, isCopy)
- .getPointer<JCharMarker>();
+ _GetStringCritical(str, isCopy).getPointer<JCharMarker>();
+
+ late final _ReleaseStringCritical = ptr.ref.ReleaseStringCritical.asFunction<
+ JThrowablePtr Function(
+ JStringPtr str, ffi.Pointer<JCharMarker> carray)>();
void ReleaseStringCritical(JStringPtr str, ffi.Pointer<JCharMarker> carray) =>
- ref.ReleaseStringCritical.asFunction<
- JThrowablePtr Function(JStringPtr str,
- ffi.Pointer<JCharMarker> carray)>()(str, carray)
- .check();
+ _ReleaseStringCritical(str, carray).check();
- JWeakPtr NewWeakGlobalRef(JObjectPtr obj) =>
- ref.NewWeakGlobalRef.asFunction<JniResult Function(JObjectPtr obj)>()(obj)
- .object;
+ late final _NewWeakGlobalRef =
+ ptr.ref.NewWeakGlobalRef.asFunction<JniResult Function(JObjectPtr obj)>();
- void DeleteWeakGlobalRef(JWeakPtr obj) => ref.DeleteWeakGlobalRef.asFunction<
- JThrowablePtr Function(JWeakPtr obj)>()(obj)
- .check();
+ JWeakPtr NewWeakGlobalRef(JObjectPtr obj) => _NewWeakGlobalRef(obj).object;
- bool ExceptionCheck() =>
- ref.ExceptionCheck.asFunction<JniResult Function()>()().boolean;
+ late final _DeleteWeakGlobalRef = ptr.ref.DeleteWeakGlobalRef
+ .asFunction<JThrowablePtr Function(JWeakPtr obj)>();
+
+ void DeleteWeakGlobalRef(JWeakPtr obj) => _DeleteWeakGlobalRef(obj).check();
+
+ late final _ExceptionCheck =
+ ptr.ref.ExceptionCheck.asFunction<JniResult Function()>();
+
+ bool ExceptionCheck() => _ExceptionCheck().boolean;
+
+ late final _NewDirectByteBuffer = ptr.ref.NewDirectByteBuffer.asFunction<
+ JniResult Function(ffi.Pointer<ffi.Void> address, int capacity)>();
JObjectPtr NewDirectByteBuffer(ffi.Pointer<ffi.Void> address, int capacity) =>
- ref.NewDirectByteBuffer.asFunction<
- JniResult Function(ffi.Pointer<ffi.Void> address,
- int capacity)>()(address, capacity)
- .object;
+ _NewDirectByteBuffer(address, capacity).object;
+
+ late final _GetDirectBufferAddress = ptr.ref.GetDirectBufferAddress
+ .asFunction<JniPointerResult Function(JObjectPtr buf)>();
ffi.Pointer<ffi.Void> GetDirectBufferAddress(JObjectPtr buf) =>
- ref.GetDirectBufferAddress.asFunction<
- JniPointerResult Function(JObjectPtr buf)>()(buf)
- .getPointer<ffi.Void>();
+ _GetDirectBufferAddress(buf).getPointer<ffi.Void>();
- int GetDirectBufferCapacity(JObjectPtr buf) => ref.GetDirectBufferCapacity
- .asFunction<JniResult Function(JObjectPtr buf)>()(buf)
- .long;
+ late final _GetDirectBufferCapacity = ptr.ref.GetDirectBufferCapacity
+ .asFunction<JniResult Function(JObjectPtr buf)>();
- int GetObjectRefType(JObjectPtr obj) =>
- ref.GetObjectRefType.asFunction<JniResult Function(JObjectPtr obj)>()(obj)
- .integer;
+ int GetDirectBufferCapacity(JObjectPtr buf) =>
+ _GetDirectBufferCapacity(buf).long;
+
+ late final _GetObjectRefType =
+ ptr.ref.GetObjectRefType.asFunction<JniResult Function(JObjectPtr obj)>();
+
+ int GetObjectRefType(JObjectPtr obj) => _GetObjectRefType(obj).integer;
}
-extension JniAccessorsExtension on ffi.Pointer<JniAccessors> {
- JniClassLookupResult getClass(ffi.Pointer<ffi.Char> internalName) =>
- ref.getClass.asFunction<
- JniClassLookupResult Function(
- ffi.Pointer<ffi.Char> internalName)>()(internalName);
+/// Wraps over the function pointers in JniAccessorsStruct and exposes them as methods.
+class JniAccessors {
+ final ffi.Pointer<JniAccessorsStruct> ptr;
+ JniAccessors(this.ptr);
+ late final _getClass = ptr.ref.getClass.asFunction<
+ JniClassLookupResult Function(ffi.Pointer<ffi.Char> internalName)>();
+ JniClassLookupResult getClass(ffi.Pointer<ffi.Char> internalName) =>
+ _getClass(internalName);
+
+ late final _getFieldID = ptr.ref.getFieldID.asFunction<
+ JniPointerResult Function(JClassPtr cls, ffi.Pointer<ffi.Char> fieldName,
+ ffi.Pointer<ffi.Char> signature)>();
JniPointerResult getFieldID(JClassPtr cls, ffi.Pointer<ffi.Char> fieldName,
ffi.Pointer<ffi.Char> signature) =>
- ref.getFieldID.asFunction<
- JniPointerResult Function(
- JClassPtr cls,
- ffi.Pointer<ffi.Char> fieldName,
- ffi.Pointer<ffi.Char> signature)>()(cls, fieldName, signature);
+ _getFieldID(cls, fieldName, signature);
+ late final _getStaticFieldID = ptr.ref.getStaticFieldID.asFunction<
+ JniPointerResult Function(JClassPtr cls, ffi.Pointer<ffi.Char> fieldName,
+ ffi.Pointer<ffi.Char> signature)>();
JniPointerResult getStaticFieldID(JClassPtr cls,
ffi.Pointer<ffi.Char> fieldName, ffi.Pointer<ffi.Char> signature) =>
- ref.getStaticFieldID.asFunction<
- JniPointerResult Function(
- JClassPtr cls,
- ffi.Pointer<ffi.Char> fieldName,
- ffi.Pointer<ffi.Char> signature)>()(cls, fieldName, signature);
+ _getStaticFieldID(cls, fieldName, signature);
+ late final _getMethodID = ptr.ref.getMethodID.asFunction<
+ JniPointerResult Function(JClassPtr cls, ffi.Pointer<ffi.Char> methodName,
+ ffi.Pointer<ffi.Char> signature)>();
JniPointerResult getMethodID(JClassPtr cls, ffi.Pointer<ffi.Char> methodName,
ffi.Pointer<ffi.Char> signature) =>
- ref.getMethodID.asFunction<
- JniPointerResult Function(
- JClassPtr cls,
- ffi.Pointer<ffi.Char> methodName,
- ffi.Pointer<ffi.Char> signature)>()(cls, methodName, signature);
+ _getMethodID(cls, methodName, signature);
+ late final _getStaticMethodID = ptr.ref.getStaticMethodID.asFunction<
+ JniPointerResult Function(JClassPtr cls, ffi.Pointer<ffi.Char> methodName,
+ ffi.Pointer<ffi.Char> signature)>();
JniPointerResult getStaticMethodID(JClassPtr cls,
ffi.Pointer<ffi.Char> methodName, ffi.Pointer<ffi.Char> signature) =>
- ref.getStaticMethodID.asFunction<
- JniPointerResult Function(
- JClassPtr cls,
- ffi.Pointer<ffi.Char> methodName,
- ffi.Pointer<ffi.Char> signature)>()(cls, methodName, signature);
+ _getStaticMethodID(cls, methodName, signature);
+ late final _newObject = ptr.ref.newObject.asFunction<
+ JniResult Function(
+ JClassPtr cls, JMethodIDPtr ctor, ffi.Pointer<JValue> args)>();
JniResult newObject(
JClassPtr cls, JMethodIDPtr ctor, ffi.Pointer<JValue> args) =>
- ref.newObject.asFunction<
- JniResult Function(JClassPtr cls, JMethodIDPtr ctor,
- ffi.Pointer<JValue> args)>()(cls, ctor, args);
+ _newObject(cls, ctor, args);
+ late final _newPrimitiveArray = ptr.ref.newPrimitiveArray
+ .asFunction<JniPointerResult Function(int length, int type)>();
JniPointerResult newPrimitiveArray(int length, int type) =>
- ref.newPrimitiveArray
- .asFunction<JniPointerResult Function(int length, int type)>()(
- length, type);
+ _newPrimitiveArray(length, type);
+ late final _newObjectArray = ptr.ref.newObjectArray.asFunction<
+ JniPointerResult Function(
+ int length, JClassPtr elementClass, JObjectPtr initialElement)>();
JniPointerResult newObjectArray(
int length, JClassPtr elementClass, JObjectPtr initialElement) =>
- ref.newObjectArray.asFunction<
- JniPointerResult Function(int length, JClassPtr elementClass,
- JObjectPtr initialElement)>()(
- length, elementClass, initialElement);
+ _newObjectArray(length, elementClass, initialElement);
+ late final _getArrayElement = ptr.ref.getArrayElement
+ .asFunction<JniResult Function(JArrayPtr array, int index, int type)>();
JniResult getArrayElement(JArrayPtr array, int index, int type) =>
- ref.getArrayElement.asFunction<
- JniResult Function(
- JArrayPtr array, int index, int type)>()(array, index, type);
+ _getArrayElement(array, index, type);
+ late final _callMethod = ptr.ref.callMethod.asFunction<
+ JniResult Function(JObjectPtr obj, JMethodIDPtr methodID, int callType,
+ ffi.Pointer<JValue> args)>();
JniResult callMethod(JObjectPtr obj, JMethodIDPtr methodID, int callType,
ffi.Pointer<JValue> args) =>
- ref.callMethod.asFunction<
- JniResult Function(
- JObjectPtr obj,
- JMethodIDPtr methodID,
- int callType,
- ffi.Pointer<JValue> args)>()(obj, methodID, callType, args);
+ _callMethod(obj, methodID, callType, args);
+ late final _callStaticMethod = ptr.ref.callStaticMethod.asFunction<
+ JniResult Function(JClassPtr cls, JMethodIDPtr methodID, int callType,
+ ffi.Pointer<JValue> args)>();
JniResult callStaticMethod(JClassPtr cls, JMethodIDPtr methodID, int callType,
ffi.Pointer<JValue> args) =>
- ref.callStaticMethod.asFunction<
- JniResult Function(JClassPtr cls, JMethodIDPtr methodID, int callType,
- ffi.Pointer<JValue> args)>()(cls, methodID, callType, args);
+ _callStaticMethod(cls, methodID, callType, args);
+ late final _getField = ptr.ref.getField.asFunction<
+ JniResult Function(JObjectPtr obj, JFieldIDPtr fieldID, int callType)>();
JniResult getField(JObjectPtr obj, JFieldIDPtr fieldID, int callType) =>
- ref.getField.asFunction<
- JniResult Function(JObjectPtr obj, JFieldIDPtr fieldID,
- int callType)>()(obj, fieldID, callType);
+ _getField(obj, fieldID, callType);
+ late final _getStaticField = ptr.ref.getStaticField.asFunction<
+ JniResult Function(JClassPtr cls, JFieldIDPtr fieldID, int callType)>();
JniResult getStaticField(JClassPtr cls, JFieldIDPtr fieldID, int callType) =>
- ref.getStaticField.asFunction<
- JniResult Function(JClassPtr cls, JFieldIDPtr fieldID,
- int callType)>()(cls, fieldID, callType);
+ _getStaticField(cls, fieldID, callType);
- JniExceptionDetails getExceptionDetails(JThrowablePtr exception) => ref
- .getExceptionDetails
- .asFunction<JniExceptionDetails Function(JThrowablePtr exception)>()(
- exception);
+ late final _getExceptionDetails = ptr.ref.getExceptionDetails
+ .asFunction<JniExceptionDetails Function(JThrowablePtr exception)>();
+ JniExceptionDetails getExceptionDetails(JThrowablePtr exception) =>
+ _getExceptionDetails(exception);
}
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 eb5ba0b..6d54cda 100644
--- a/pkgs/jni/lib/src/third_party/jni_bindings_generated.dart
+++ b/pkgs/jni/lib/src/third_party/jni_bindings_generated.dart
@@ -63,15 +63,15 @@
lookup)
: _lookup = lookup;
- ffi.Pointer<JniAccessors> GetAccessors() {
+ ffi.Pointer<JniAccessorsStruct> GetAccessors() {
return _GetAccessors();
}
late final _GetAccessorsPtr =
- _lookup<ffi.NativeFunction<ffi.Pointer<JniAccessors> Function()>>(
+ _lookup<ffi.NativeFunction<ffi.Pointer<JniAccessorsStruct> Function()>>(
'GetAccessors');
late final _GetAccessors =
- _GetAccessorsPtr.asFunction<ffi.Pointer<JniAccessors> Function()>();
+ _GetAccessorsPtr.asFunction<ffi.Pointer<JniAccessorsStruct> Function()>();
ffi.Pointer<JavaVM> GetJavaVM() {
return _GetJavaVM();
@@ -192,15 +192,15 @@
late final _PortContinuation__ctor =
_PortContinuation__ctorPtr.asFunction<JniResult Function(int)>();
- ffi.Pointer<GlobalJniEnv> GetGlobalEnv() {
+ ffi.Pointer<GlobalJniEnvStruct> GetGlobalEnv() {
return _GetGlobalEnv();
}
late final _GetGlobalEnvPtr =
- _lookup<ffi.NativeFunction<ffi.Pointer<GlobalJniEnv> Function()>>(
+ _lookup<ffi.NativeFunction<ffi.Pointer<GlobalJniEnvStruct> Function()>>(
'GetGlobalEnv');
late final _GetGlobalEnv =
- _GetGlobalEnvPtr.asFunction<ffi.Pointer<GlobalJniEnv> Function()>();
+ _GetGlobalEnvPtr.asFunction<ffi.Pointer<GlobalJniEnvStruct> Function()>();
}
/// Types used by JNI API to distinguish between primitive types.
@@ -301,7 +301,7 @@
/// Flutter embedding checks for pending JNI exceptions before an FFI transition, which requires us
/// to check for and clear the exception before returning to dart code, which requires these functions
/// to return result types.
-class JniAccessors extends ffi.Struct {
+class JniAccessorsStruct extends ffi.Struct {
external ffi.Pointer<
ffi.NativeFunction<
JniClassLookupResult Function(
@@ -1936,7 +1936,7 @@
external ffi.Pointer<ffi.Void> extraInfo;
}
-class GlobalJniEnv extends ffi.Struct {
+class GlobalJniEnvStruct extends ffi.Struct {
external ffi.Pointer<ffi.Void> reserved0;
external ffi.Pointer<ffi.Void> reserved1;
diff --git a/pkgs/jni/lib/src/third_party/jnienv_javavm_extensions.dart b/pkgs/jni/lib/src/third_party/jnienv_javavm_extensions.dart
deleted file mode 100644
index 7c145f9..0000000
--- a/pkgs/jni/lib/src/third_party/jnienv_javavm_extensions.dart
+++ /dev/null
@@ -1,1409 +0,0 @@
-// Auto generated file. Do not edit.
-
-// This is generated from JNI header in Android NDK. License for the same is
-// provided below.
-
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/*
- * JNI specification, as defined by Sun:
- * http://java.sun.com/javase/6/docs/technotes/guides/jni/spec/jniTOC.html
- *
- * Everything here is expected to be VM-neutral.
- */
-
-// ignore_for_file: non_constant_identifier_names
-// coverage:ignore-file
-
-import "dart:ffi" as ffi;
-
-import "jni_bindings_generated.dart";
-
-extension JniEnvExtension on ffi.Pointer<JniEnv> {
- int GetVersion() => value.ref.GetVersion
- .asFunction<int Function(ffi.Pointer<JniEnv1> env)>()(this);
-
- JClassPtr DefineClass(ffi.Pointer<ffi.Char> name, JObjectPtr loader,
- ffi.Pointer<JByteMarker> buf, int bufLen) =>
- value.ref.DefineClass.asFunction<
- JClassPtr Function(
- ffi.Pointer<JniEnv1> env,
- ffi.Pointer<ffi.Char> name,
- JObjectPtr loader,
- ffi.Pointer<JByteMarker> buf,
- int bufLen)>()(this, name, loader, buf, bufLen);
-
- JClassPtr FindClass(ffi.Pointer<ffi.Char> name) => value.ref.FindClass
- .asFunction<
- JClassPtr Function(ffi.Pointer<JniEnv1> env,
- ffi.Pointer<ffi.Char> name)>()(this, name);
-
- JMethodIDPtr FromReflectedMethod(JObjectPtr method) =>
- value.ref.FromReflectedMethod.asFunction<
- JMethodIDPtr Function(
- ffi.Pointer<JniEnv1> env, JObjectPtr method)>()(this, method);
-
- JFieldIDPtr FromReflectedField(JObjectPtr field) =>
- value.ref.FromReflectedField.asFunction<
- JFieldIDPtr Function(
- ffi.Pointer<JniEnv1> env, JObjectPtr field)>()(this, field);
-
- JObjectPtr ToReflectedMethod(
- JClassPtr cls, JMethodIDPtr methodId, int isStatic) =>
- value.ref.ToReflectedMethod.asFunction<
- JObjectPtr Function(
- ffi.Pointer<JniEnv1> env,
- JClassPtr cls,
- JMethodIDPtr methodId,
- int isStatic)>()(this, cls, methodId, isStatic);
-
- JClassPtr GetSuperclass(JClassPtr clazz) =>
- value.ref.GetSuperclass.asFunction<
- JClassPtr Function(
- ffi.Pointer<JniEnv1> env, JClassPtr clazz)>()(this, clazz);
-
- int IsAssignableFrom(JClassPtr clazz1, JClassPtr clazz2) =>
- value.ref.IsAssignableFrom.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz1,
- JClassPtr clazz2)>()(this, clazz1, clazz2);
-
- JObjectPtr ToReflectedField(
- JClassPtr cls, JFieldIDPtr fieldID, int isStatic) =>
- value.ref.ToReflectedField.asFunction<
- JObjectPtr Function(
- ffi.Pointer<JniEnv1> env,
- JClassPtr cls,
- JFieldIDPtr fieldID,
- int isStatic)>()(this, cls, fieldID, isStatic);
-
- int Throw(JThrowablePtr obj) => value.ref.Throw.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JThrowablePtr obj)>()(this, obj);
-
- int ThrowNew(JClassPtr clazz, ffi.Pointer<ffi.Char> message) =>
- value.ref.ThrowNew.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- ffi.Pointer<ffi.Char> message)>()(this, clazz, message);
-
- JThrowablePtr ExceptionOccurred() => value.ref.ExceptionOccurred
- .asFunction<JThrowablePtr Function(ffi.Pointer<JniEnv1> env)>()(this);
-
- void ExceptionDescribe() => value.ref.ExceptionDescribe
- .asFunction<void Function(ffi.Pointer<JniEnv1> env)>()(this);
-
- void ExceptionClear() => value.ref.ExceptionClear
- .asFunction<void Function(ffi.Pointer<JniEnv1> env)>()(this);
-
- void FatalError(ffi.Pointer<ffi.Char> msg) => value.ref.FatalError.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env, ffi.Pointer<ffi.Char> msg)>()(this, msg);
-
- int PushLocalFrame(int capacity) => value.ref.PushLocalFrame
- .asFunction<int Function(ffi.Pointer<JniEnv1> env, int capacity)>()(
- this, capacity);
-
- JObjectPtr PopLocalFrame(JObjectPtr result) => value.ref.PopLocalFrame
- .asFunction<
- JObjectPtr Function(
- ffi.Pointer<JniEnv1> env, JObjectPtr result)>()(this, result);
-
- JObjectPtr NewGlobalRef(JObjectPtr obj) => value.ref.NewGlobalRef.asFunction<
- JObjectPtr Function(
- ffi.Pointer<JniEnv1> env, JObjectPtr obj)>()(this, obj);
-
- void DeleteGlobalRef(JObjectPtr globalRef) =>
- value.ref.DeleteGlobalRef.asFunction<
- void Function(ffi.Pointer<JniEnv1> env, JObjectPtr globalRef)>()(
- this, globalRef);
-
- void DeleteLocalRef(JObjectPtr localRef) =>
- value.ref.DeleteLocalRef.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env, JObjectPtr localRef)>()(this, localRef);
-
- int IsSameObject(JObjectPtr ref1, JObjectPtr ref2) =>
- value.ref.IsSameObject.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JObjectPtr ref1,
- JObjectPtr ref2)>()(this, ref1, ref2);
-
- JObjectPtr NewLocalRef(JObjectPtr obj) => value.ref.NewLocalRef.asFunction<
- JObjectPtr Function(
- ffi.Pointer<JniEnv1> env, JObjectPtr obj)>()(this, obj);
-
- int EnsureLocalCapacity(int capacity) => value.ref.EnsureLocalCapacity
- .asFunction<int Function(ffi.Pointer<JniEnv1> env, int capacity)>()(
- this, capacity);
-
- JObjectPtr AllocObject(JClassPtr clazz) => value.ref.AllocObject.asFunction<
- JObjectPtr Function(
- ffi.Pointer<JniEnv1> env, JClassPtr clazz)>()(this, clazz);
-
- JObjectPtr NewObject(JClassPtr clazz, JMethodIDPtr methodID) =>
- value.ref.NewObject.asFunction<
- JObjectPtr Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JMethodIDPtr methodID)>()(this, clazz, methodID);
-
- JObjectPtr NewObjectA(
- JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.NewObjectA.asFunction<
- JObjectPtr Function(
- ffi.Pointer<JniEnv1> env,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, clazz, methodID, args);
-
- JClassPtr GetObjectClass(JObjectPtr obj) =>
- value.ref.GetObjectClass.asFunction<
- JClassPtr Function(
- ffi.Pointer<JniEnv1> env, JObjectPtr obj)>()(this, obj);
-
- int IsInstanceOf(JObjectPtr obj, JClassPtr clazz) =>
- value.ref.IsInstanceOf.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JClassPtr clazz)>()(this, obj, clazz);
-
- JMethodIDPtr GetMethodID(JClassPtr clazz, ffi.Pointer<ffi.Char> name,
- ffi.Pointer<ffi.Char> sig) =>
- value.ref.GetMethodID.asFunction<
- JMethodIDPtr Function(
- ffi.Pointer<JniEnv1> env,
- JClassPtr clazz,
- ffi.Pointer<ffi.Char> name,
- ffi.Pointer<ffi.Char> sig)>()(this, clazz, name, sig);
-
- JObjectPtr CallObjectMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
- value.ref.CallObjectMethod.asFunction<
- JObjectPtr Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JMethodIDPtr methodID)>()(this, obj, methodID);
-
- JObjectPtr CallObjectMethodA(
- JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallObjectMethodA.asFunction<
- JObjectPtr Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, obj, methodID, args);
-
- int CallBooleanMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
- value.ref.CallBooleanMethod.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JMethodIDPtr methodID)>()(this, obj, methodID);
-
- int CallBooleanMethodA(
- JObjectPtr obj, JMethodIDPtr methodId, ffi.Pointer<JValue> args) =>
- value.ref.CallBooleanMethodA.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JMethodIDPtr methodId,
- ffi.Pointer<JValue> args)>()(this, obj, methodId, args);
-
- int CallByteMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
- value.ref.CallByteMethod.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JMethodIDPtr methodID)>()(this, obj, methodID);
-
- int CallByteMethodA(
- JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallByteMethodA.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, obj, methodID, args);
-
- int CallCharMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
- value.ref.CallCharMethod.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JMethodIDPtr methodID)>()(this, obj, methodID);
-
- int CallCharMethodA(
- JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallCharMethodA.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, obj, methodID, args);
-
- int CallShortMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
- value.ref.CallShortMethod.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JMethodIDPtr methodID)>()(this, obj, methodID);
-
- int CallShortMethodA(
- JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallShortMethodA.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, obj, methodID, args);
-
- int CallIntMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
- value.ref.CallIntMethod.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JMethodIDPtr methodID)>()(this, obj, methodID);
-
- int CallIntMethodA(
- JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallIntMethodA.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, obj, methodID, args);
-
- int CallLongMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
- value.ref.CallLongMethod.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JMethodIDPtr methodID)>()(this, obj, methodID);
-
- int CallLongMethodA(
- JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallLongMethodA.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, obj, methodID, args);
-
- double CallFloatMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
- value.ref.CallFloatMethod.asFunction<
- double Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JMethodIDPtr methodID)>()(this, obj, methodID);
-
- double CallFloatMethodA(
- JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallFloatMethodA.asFunction<
- double Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, obj, methodID, args);
-
- double CallDoubleMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
- value.ref.CallDoubleMethod.asFunction<
- double Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JMethodIDPtr methodID)>()(this, obj, methodID);
-
- double CallDoubleMethodA(
- JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallDoubleMethodA.asFunction<
- double Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, obj, methodID, args);
-
- void CallVoidMethod(JObjectPtr obj, JMethodIDPtr methodID) =>
- value.ref.CallVoidMethod.asFunction<
- void Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JMethodIDPtr methodID)>()(this, obj, methodID);
-
- void CallVoidMethodA(
- JObjectPtr obj, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallVoidMethodA.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, obj, methodID, args);
-
- JObjectPtr CallNonvirtualObjectMethod(
- JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
- value.ref.CallNonvirtualObjectMethod.asFunction<
- JObjectPtr Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID)>()(this, obj, clazz, methodID);
-
- JObjectPtr CallNonvirtualObjectMethodA(JObjectPtr obj, JClassPtr clazz,
- JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallNonvirtualObjectMethodA.asFunction<
- JObjectPtr Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, obj, clazz, methodID, args);
-
- int CallNonvirtualBooleanMethod(
- JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
- value.ref.CallNonvirtualBooleanMethod.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID)>()(this, obj, clazz, methodID);
-
- int CallNonvirtualBooleanMethodA(JObjectPtr obj, JClassPtr clazz,
- JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallNonvirtualBooleanMethodA.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, obj, clazz, methodID, args);
-
- int CallNonvirtualByteMethod(
- JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
- value.ref.CallNonvirtualByteMethod.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID)>()(this, obj, clazz, methodID);
-
- int CallNonvirtualByteMethodA(JObjectPtr obj, JClassPtr clazz,
- JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallNonvirtualByteMethodA.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, obj, clazz, methodID, args);
-
- int CallNonvirtualCharMethod(
- JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
- value.ref.CallNonvirtualCharMethod.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID)>()(this, obj, clazz, methodID);
-
- int CallNonvirtualCharMethodA(JObjectPtr obj, JClassPtr clazz,
- JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallNonvirtualCharMethodA.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, obj, clazz, methodID, args);
-
- int CallNonvirtualShortMethod(
- JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
- value.ref.CallNonvirtualShortMethod.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID)>()(this, obj, clazz, methodID);
-
- int CallNonvirtualShortMethodA(JObjectPtr obj, JClassPtr clazz,
- JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallNonvirtualShortMethodA.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, obj, clazz, methodID, args);
-
- int CallNonvirtualIntMethod(
- JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
- value.ref.CallNonvirtualIntMethod.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID)>()(this, obj, clazz, methodID);
-
- int CallNonvirtualIntMethodA(JObjectPtr obj, JClassPtr clazz,
- JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallNonvirtualIntMethodA.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, obj, clazz, methodID, args);
-
- int CallNonvirtualLongMethod(
- JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
- value.ref.CallNonvirtualLongMethod.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID)>()(this, obj, clazz, methodID);
-
- int CallNonvirtualLongMethodA(JObjectPtr obj, JClassPtr clazz,
- JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallNonvirtualLongMethodA.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, obj, clazz, methodID, args);
-
- double CallNonvirtualFloatMethod(
- JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
- value.ref.CallNonvirtualFloatMethod.asFunction<
- double Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID)>()(this, obj, clazz, methodID);
-
- double CallNonvirtualFloatMethodA(JObjectPtr obj, JClassPtr clazz,
- JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallNonvirtualFloatMethodA.asFunction<
- double Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, obj, clazz, methodID, args);
-
- double CallNonvirtualDoubleMethod(
- JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
- value.ref.CallNonvirtualDoubleMethod.asFunction<
- double Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID)>()(this, obj, clazz, methodID);
-
- double CallNonvirtualDoubleMethodA(JObjectPtr obj, JClassPtr clazz,
- JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallNonvirtualDoubleMethodA.asFunction<
- double Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, obj, clazz, methodID, args);
-
- void CallNonvirtualVoidMethod(
- JObjectPtr obj, JClassPtr clazz, JMethodIDPtr methodID) =>
- value.ref.CallNonvirtualVoidMethod.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID)>()(this, obj, clazz, methodID);
-
- void CallNonvirtualVoidMethodA(JObjectPtr obj, JClassPtr clazz,
- JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallNonvirtualVoidMethodA.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JObjectPtr obj,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, obj, clazz, methodID, args);
-
- JFieldIDPtr GetFieldID(JClassPtr clazz, ffi.Pointer<ffi.Char> name,
- ffi.Pointer<ffi.Char> sig) =>
- value.ref.GetFieldID.asFunction<
- JFieldIDPtr Function(
- ffi.Pointer<JniEnv1> env,
- JClassPtr clazz,
- ffi.Pointer<ffi.Char> name,
- ffi.Pointer<ffi.Char> sig)>()(this, clazz, name, sig);
-
- JObjectPtr GetObjectField(JObjectPtr obj, JFieldIDPtr fieldID) =>
- value.ref.GetObjectField.asFunction<
- JObjectPtr Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JFieldIDPtr fieldID)>()(this, obj, fieldID);
-
- int GetBooleanField(JObjectPtr obj, JFieldIDPtr fieldID) =>
- value.ref.GetBooleanField.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JFieldIDPtr fieldID)>()(this, obj, fieldID);
-
- int GetByteField(JObjectPtr obj, JFieldIDPtr fieldID) =>
- value.ref.GetByteField.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JFieldIDPtr fieldID)>()(this, obj, fieldID);
-
- int GetCharField(JObjectPtr obj, JFieldIDPtr fieldID) =>
- value.ref.GetCharField.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JFieldIDPtr fieldID)>()(this, obj, fieldID);
-
- int GetShortField(JObjectPtr obj, JFieldIDPtr fieldID) =>
- value.ref.GetShortField.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JFieldIDPtr fieldID)>()(this, obj, fieldID);
-
- int GetIntField(JObjectPtr obj, JFieldIDPtr fieldID) =>
- value.ref.GetIntField.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JFieldIDPtr fieldID)>()(this, obj, fieldID);
-
- int GetLongField(JObjectPtr obj, JFieldIDPtr fieldID) =>
- value.ref.GetLongField.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JFieldIDPtr fieldID)>()(this, obj, fieldID);
-
- double GetFloatField(JObjectPtr obj, JFieldIDPtr fieldID) =>
- value.ref.GetFloatField.asFunction<
- double Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JFieldIDPtr fieldID)>()(this, obj, fieldID);
-
- double GetDoubleField(JObjectPtr obj, JFieldIDPtr fieldID) =>
- value.ref.GetDoubleField.asFunction<
- double Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JFieldIDPtr fieldID)>()(this, obj, fieldID);
-
- void SetObjectField(JObjectPtr obj, JFieldIDPtr fieldID, JObjectPtr val) =>
- value.ref.SetObjectField.asFunction<
- void Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JFieldIDPtr fieldID, JObjectPtr val)>()(this, obj, fieldID, val);
-
- void SetBooleanField(JObjectPtr obj, JFieldIDPtr fieldID, int val) =>
- value.ref.SetBooleanField.asFunction<
- void Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JFieldIDPtr fieldID, int val)>()(this, obj, fieldID, val);
-
- void SetByteField(JObjectPtr obj, JFieldIDPtr fieldID, int val) =>
- value.ref.SetByteField.asFunction<
- void Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JFieldIDPtr fieldID, int val)>()(this, obj, fieldID, val);
-
- void SetCharField(JObjectPtr obj, JFieldIDPtr fieldID, int val) =>
- value.ref.SetCharField.asFunction<
- void Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JFieldIDPtr fieldID, int val)>()(this, obj, fieldID, val);
-
- void SetShortField(JObjectPtr obj, JFieldIDPtr fieldID, int val) =>
- value.ref.SetShortField.asFunction<
- void Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JFieldIDPtr fieldID, int val)>()(this, obj, fieldID, val);
-
- void SetIntField(JObjectPtr obj, JFieldIDPtr fieldID, int val) =>
- value.ref.SetIntField.asFunction<
- void Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JFieldIDPtr fieldID, int val)>()(this, obj, fieldID, val);
-
- void SetLongField(JObjectPtr obj, JFieldIDPtr fieldID, int val) =>
- value.ref.SetLongField.asFunction<
- void Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JFieldIDPtr fieldID, int val)>()(this, obj, fieldID, val);
-
- void SetFloatField(JObjectPtr obj, JFieldIDPtr fieldID, double val) =>
- value.ref.SetFloatField.asFunction<
- void Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JFieldIDPtr fieldID, double val)>()(this, obj, fieldID, val);
-
- void SetDoubleField(JObjectPtr obj, JFieldIDPtr fieldID, double val) =>
- value.ref.SetDoubleField.asFunction<
- void Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj,
- JFieldIDPtr fieldID, double val)>()(this, obj, fieldID, val);
-
- JMethodIDPtr GetStaticMethodID(JClassPtr clazz, ffi.Pointer<ffi.Char> name,
- ffi.Pointer<ffi.Char> sig) =>
- value.ref.GetStaticMethodID.asFunction<
- JMethodIDPtr Function(
- ffi.Pointer<JniEnv1> env,
- JClassPtr clazz,
- ffi.Pointer<ffi.Char> name,
- ffi.Pointer<ffi.Char> sig)>()(this, clazz, name, sig);
-
- JObjectPtr CallStaticObjectMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
- value.ref.CallStaticObjectMethod.asFunction<
- JObjectPtr Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JMethodIDPtr methodID)>()(this, clazz, methodID);
-
- JObjectPtr CallStaticObjectMethodA(
- JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallStaticObjectMethodA.asFunction<
- JObjectPtr Function(
- ffi.Pointer<JniEnv1> env,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, clazz, methodID, args);
-
- int CallStaticBooleanMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
- value.ref.CallStaticBooleanMethod.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JMethodIDPtr methodID)>()(this, clazz, methodID);
-
- int CallStaticBooleanMethodA(
- JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallStaticBooleanMethodA.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, clazz, methodID, args);
-
- int CallStaticByteMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
- value.ref.CallStaticByteMethod.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JMethodIDPtr methodID)>()(this, clazz, methodID);
-
- int CallStaticByteMethodA(
- JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallStaticByteMethodA.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, clazz, methodID, args);
-
- int CallStaticCharMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
- value.ref.CallStaticCharMethod.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JMethodIDPtr methodID)>()(this, clazz, methodID);
-
- int CallStaticCharMethodA(
- JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallStaticCharMethodA.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, clazz, methodID, args);
-
- int CallStaticShortMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
- value.ref.CallStaticShortMethod.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JMethodIDPtr methodID)>()(this, clazz, methodID);
-
- int CallStaticShortMethodA(
- JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallStaticShortMethodA.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, clazz, methodID, args);
-
- int CallStaticIntMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
- value.ref.CallStaticIntMethod.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JMethodIDPtr methodID)>()(this, clazz, methodID);
-
- int CallStaticIntMethodA(
- JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallStaticIntMethodA.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, clazz, methodID, args);
-
- int CallStaticLongMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
- value.ref.CallStaticLongMethod.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JMethodIDPtr methodID)>()(this, clazz, methodID);
-
- int CallStaticLongMethodA(
- JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallStaticLongMethodA.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, clazz, methodID, args);
-
- double CallStaticFloatMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
- value.ref.CallStaticFloatMethod.asFunction<
- double Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JMethodIDPtr methodID)>()(this, clazz, methodID);
-
- double CallStaticFloatMethodA(
- JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallStaticFloatMethodA.asFunction<
- double Function(
- ffi.Pointer<JniEnv1> env,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, clazz, methodID, args);
-
- double CallStaticDoubleMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
- value.ref.CallStaticDoubleMethod.asFunction<
- double Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JMethodIDPtr methodID)>()(this, clazz, methodID);
-
- double CallStaticDoubleMethodA(
- JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallStaticDoubleMethodA.asFunction<
- double Function(
- ffi.Pointer<JniEnv1> env,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, clazz, methodID, args);
-
- void CallStaticVoidMethod(JClassPtr clazz, JMethodIDPtr methodID) =>
- value.ref.CallStaticVoidMethod.asFunction<
- void Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JMethodIDPtr methodID)>()(this, clazz, methodID);
-
- void CallStaticVoidMethodA(
- JClassPtr clazz, JMethodIDPtr methodID, ffi.Pointer<JValue> args) =>
- value.ref.CallStaticVoidMethodA.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JClassPtr clazz,
- JMethodIDPtr methodID,
- ffi.Pointer<JValue> args)>()(this, clazz, methodID, args);
-
- JFieldIDPtr GetStaticFieldID(JClassPtr clazz, ffi.Pointer<ffi.Char> name,
- ffi.Pointer<ffi.Char> sig) =>
- value.ref.GetStaticFieldID.asFunction<
- JFieldIDPtr Function(
- ffi.Pointer<JniEnv1> env,
- JClassPtr clazz,
- ffi.Pointer<ffi.Char> name,
- ffi.Pointer<ffi.Char> sig)>()(this, clazz, name, sig);
-
- JObjectPtr GetStaticObjectField(JClassPtr clazz, JFieldIDPtr fieldID) =>
- value.ref.GetStaticObjectField.asFunction<
- JObjectPtr Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JFieldIDPtr fieldID)>()(this, clazz, fieldID);
-
- int GetStaticBooleanField(JClassPtr clazz, JFieldIDPtr fieldID) =>
- value.ref.GetStaticBooleanField.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JFieldIDPtr fieldID)>()(this, clazz, fieldID);
-
- int GetStaticByteField(JClassPtr clazz, JFieldIDPtr fieldID) =>
- value.ref.GetStaticByteField.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JFieldIDPtr fieldID)>()(this, clazz, fieldID);
-
- int GetStaticCharField(JClassPtr clazz, JFieldIDPtr fieldID) =>
- value.ref.GetStaticCharField.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JFieldIDPtr fieldID)>()(this, clazz, fieldID);
-
- int GetStaticShortField(JClassPtr clazz, JFieldIDPtr fieldID) =>
- value.ref.GetStaticShortField.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JFieldIDPtr fieldID)>()(this, clazz, fieldID);
-
- int GetStaticIntField(JClassPtr clazz, JFieldIDPtr fieldID) =>
- value.ref.GetStaticIntField.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JFieldIDPtr fieldID)>()(this, clazz, fieldID);
-
- int GetStaticLongField(JClassPtr clazz, JFieldIDPtr fieldID) =>
- value.ref.GetStaticLongField.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JFieldIDPtr fieldID)>()(this, clazz, fieldID);
-
- double GetStaticFloatField(JClassPtr clazz, JFieldIDPtr fieldID) =>
- value.ref.GetStaticFloatField.asFunction<
- double Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JFieldIDPtr fieldID)>()(this, clazz, fieldID);
-
- double GetStaticDoubleField(JClassPtr clazz, JFieldIDPtr fieldID) =>
- value.ref.GetStaticDoubleField.asFunction<
- double Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JFieldIDPtr fieldID)>()(this, clazz, fieldID);
-
- void SetStaticObjectField(
- JClassPtr clazz, JFieldIDPtr fieldID, JObjectPtr val) =>
- value.ref.SetStaticObjectField.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JClassPtr clazz,
- JFieldIDPtr fieldID,
- JObjectPtr val)>()(this, clazz, fieldID, val);
-
- void SetStaticBooleanField(JClassPtr clazz, JFieldIDPtr fieldID, int val) =>
- value.ref.SetStaticBooleanField.asFunction<
- void Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JFieldIDPtr fieldID, int val)>()(this, clazz, fieldID, val);
-
- void SetStaticByteField(JClassPtr clazz, JFieldIDPtr fieldID, int val) =>
- value.ref.SetStaticByteField.asFunction<
- void Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JFieldIDPtr fieldID, int val)>()(this, clazz, fieldID, val);
-
- void SetStaticCharField(JClassPtr clazz, JFieldIDPtr fieldID, int val) =>
- value.ref.SetStaticCharField.asFunction<
- void Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JFieldIDPtr fieldID, int val)>()(this, clazz, fieldID, val);
-
- void SetStaticShortField(JClassPtr clazz, JFieldIDPtr fieldID, int val) =>
- value.ref.SetStaticShortField.asFunction<
- void Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JFieldIDPtr fieldID, int val)>()(this, clazz, fieldID, val);
-
- void SetStaticIntField(JClassPtr clazz, JFieldIDPtr fieldID, int val) =>
- value.ref.SetStaticIntField.asFunction<
- void Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JFieldIDPtr fieldID, int val)>()(this, clazz, fieldID, val);
-
- void SetStaticLongField(JClassPtr clazz, JFieldIDPtr fieldID, int val) =>
- value.ref.SetStaticLongField.asFunction<
- void Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JFieldIDPtr fieldID, int val)>()(this, clazz, fieldID, val);
-
- void SetStaticFloatField(JClassPtr clazz, JFieldIDPtr fieldID, double val) =>
- value.ref.SetStaticFloatField.asFunction<
- void Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JFieldIDPtr fieldID, double val)>()(this, clazz, fieldID, val);
-
- void SetStaticDoubleField(JClassPtr clazz, JFieldIDPtr fieldID, double val) =>
- value.ref.SetStaticDoubleField.asFunction<
- void Function(ffi.Pointer<JniEnv1> env, JClassPtr clazz,
- JFieldIDPtr fieldID, double val)>()(this, clazz, fieldID, val);
-
- JStringPtr NewString(ffi.Pointer<JCharMarker> unicodeChars, int len) =>
- value.ref.NewString.asFunction<
- JStringPtr Function(
- ffi.Pointer<JniEnv1> env,
- ffi.Pointer<JCharMarker> unicodeChars,
- int len)>()(this, unicodeChars, len);
-
- int GetStringLength(JStringPtr string) =>
- value.ref.GetStringLength.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env, JStringPtr string)>()(this, string);
-
- ffi.Pointer<JCharMarker> GetStringChars(
- JStringPtr string, ffi.Pointer<JBooleanMarker> isCopy) =>
- value.ref.GetStringChars.asFunction<
- ffi.Pointer<JCharMarker> Function(
- ffi.Pointer<JniEnv1> env,
- JStringPtr string,
- ffi.Pointer<JBooleanMarker> isCopy)>()(this, string, isCopy);
-
- void ReleaseStringChars(JStringPtr string, ffi.Pointer<JCharMarker> isCopy) =>
- value.ref.ReleaseStringChars.asFunction<
- void Function(ffi.Pointer<JniEnv1> env, JStringPtr string,
- ffi.Pointer<JCharMarker> isCopy)>()(this, string, isCopy);
-
- JStringPtr NewStringUTF(ffi.Pointer<ffi.Char> bytes) =>
- value.ref.NewStringUTF.asFunction<
- JStringPtr Function(ffi.Pointer<JniEnv1> env,
- ffi.Pointer<ffi.Char> bytes)>()(this, bytes);
-
- int GetStringUTFLength(JStringPtr string) =>
- value.ref.GetStringUTFLength.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env, JStringPtr string)>()(this, string);
-
- ffi.Pointer<ffi.Char> GetStringUTFChars(
- JStringPtr string, ffi.Pointer<JBooleanMarker> isCopy) =>
- value.ref.GetStringUTFChars.asFunction<
- ffi.Pointer<ffi.Char> Function(
- ffi.Pointer<JniEnv1> env,
- JStringPtr string,
- ffi.Pointer<JBooleanMarker> isCopy)>()(this, string, isCopy);
-
- void ReleaseStringUTFChars(JStringPtr string, ffi.Pointer<ffi.Char> utf) =>
- value.ref.ReleaseStringUTFChars.asFunction<
- void Function(ffi.Pointer<JniEnv1> env, JStringPtr string,
- ffi.Pointer<ffi.Char> utf)>()(this, string, utf);
-
- int GetArrayLength(JArrayPtr array) => value.ref.GetArrayLength.asFunction<
- int Function(ffi.Pointer<JniEnv1> env, JArrayPtr array)>()(this, array);
-
- JObjectArrayPtr NewObjectArray(
- int length, JClassPtr elementClass, JObjectPtr initialElement) =>
- value.ref.NewObjectArray.asFunction<
- JObjectArrayPtr Function(ffi.Pointer<JniEnv1> env, int length,
- JClassPtr elementClass, JObjectPtr initialElement)>()(
- this, length, elementClass, initialElement);
-
- JObjectPtr GetObjectArrayElement(JObjectArrayPtr array, int index) =>
- value.ref.GetObjectArrayElement.asFunction<
- JObjectPtr Function(ffi.Pointer<JniEnv1> env, JObjectArrayPtr array,
- int index)>()(this, array, index);
-
- void SetObjectArrayElement(
- JObjectArrayPtr array, int index, JObjectPtr val) =>
- value.ref.SetObjectArrayElement.asFunction<
- void Function(ffi.Pointer<JniEnv1> env, JObjectArrayPtr array,
- int index, JObjectPtr val)>()(this, array, index, val);
-
- JBooleanArrayPtr NewBooleanArray(int length) =>
- value.ref.NewBooleanArray.asFunction<
- JBooleanArrayPtr Function(
- ffi.Pointer<JniEnv1> env, int length)>()(this, length);
-
- JByteArrayPtr NewByteArray(int length) => value.ref.NewByteArray.asFunction<
- JByteArrayPtr Function(
- ffi.Pointer<JniEnv1> env, int length)>()(this, length);
-
- JCharArrayPtr NewCharArray(int length) => value.ref.NewCharArray.asFunction<
- JCharArrayPtr Function(
- ffi.Pointer<JniEnv1> env, int length)>()(this, length);
-
- JShortArrayPtr NewShortArray(int length) =>
- value.ref.NewShortArray.asFunction<
- JShortArrayPtr Function(
- ffi.Pointer<JniEnv1> env, int length)>()(this, length);
-
- JIntArrayPtr NewIntArray(int length) => value.ref.NewIntArray.asFunction<
- JIntArrayPtr Function(
- ffi.Pointer<JniEnv1> env, int length)>()(this, length);
-
- JLongArrayPtr NewLongArray(int length) => value.ref.NewLongArray.asFunction<
- JLongArrayPtr Function(
- ffi.Pointer<JniEnv1> env, int length)>()(this, length);
-
- JFloatArrayPtr NewFloatArray(int length) =>
- value.ref.NewFloatArray.asFunction<
- JFloatArrayPtr Function(
- ffi.Pointer<JniEnv1> env, int length)>()(this, length);
-
- JDoubleArrayPtr NewDoubleArray(int length) => value.ref.NewDoubleArray
- .asFunction<
- JDoubleArrayPtr Function(
- ffi.Pointer<JniEnv1> env, int length)>()(this, length);
-
- ffi.Pointer<JBooleanMarker> GetBooleanArrayElements(
- JBooleanArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy) =>
- value.ref.GetBooleanArrayElements.asFunction<
- ffi.Pointer<JBooleanMarker> Function(
- ffi.Pointer<JniEnv1> env,
- JBooleanArrayPtr array,
- ffi.Pointer<JBooleanMarker> isCopy)>()(this, array, isCopy);
-
- ffi.Pointer<JByteMarker> GetByteArrayElements(
- JByteArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy) =>
- value.ref.GetByteArrayElements.asFunction<
- ffi.Pointer<JByteMarker> Function(
- ffi.Pointer<JniEnv1> env,
- JByteArrayPtr array,
- ffi.Pointer<JBooleanMarker> isCopy)>()(this, array, isCopy);
-
- ffi.Pointer<JCharMarker> GetCharArrayElements(
- JCharArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy) =>
- value.ref.GetCharArrayElements.asFunction<
- ffi.Pointer<JCharMarker> Function(
- ffi.Pointer<JniEnv1> env,
- JCharArrayPtr array,
- ffi.Pointer<JBooleanMarker> isCopy)>()(this, array, isCopy);
-
- ffi.Pointer<JShortMarker> GetShortArrayElements(
- JShortArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy) =>
- value.ref.GetShortArrayElements.asFunction<
- ffi.Pointer<JShortMarker> Function(
- ffi.Pointer<JniEnv1> env,
- JShortArrayPtr array,
- ffi.Pointer<JBooleanMarker> isCopy)>()(this, array, isCopy);
-
- ffi.Pointer<JIntMarker> GetIntArrayElements(
- JIntArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy) =>
- value.ref.GetIntArrayElements.asFunction<
- ffi.Pointer<JIntMarker> Function(
- ffi.Pointer<JniEnv1> env,
- JIntArrayPtr array,
- ffi.Pointer<JBooleanMarker> isCopy)>()(this, array, isCopy);
-
- ffi.Pointer<JLongMarker> GetLongArrayElements(
- JLongArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy) =>
- value.ref.GetLongArrayElements.asFunction<
- ffi.Pointer<JLongMarker> Function(
- ffi.Pointer<JniEnv1> env,
- JLongArrayPtr array,
- ffi.Pointer<JBooleanMarker> isCopy)>()(this, array, isCopy);
-
- ffi.Pointer<JFloatMarker> GetFloatArrayElements(
- JFloatArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy) =>
- value.ref.GetFloatArrayElements.asFunction<
- ffi.Pointer<JFloatMarker> Function(
- ffi.Pointer<JniEnv1> env,
- JFloatArrayPtr array,
- ffi.Pointer<JBooleanMarker> isCopy)>()(this, array, isCopy);
-
- ffi.Pointer<JDoubleMarker> GetDoubleArrayElements(
- JDoubleArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy) =>
- value.ref.GetDoubleArrayElements.asFunction<
- ffi.Pointer<JDoubleMarker> Function(
- ffi.Pointer<JniEnv1> env,
- JDoubleArrayPtr array,
- ffi.Pointer<JBooleanMarker> isCopy)>()(this, array, isCopy);
-
- void ReleaseBooleanArrayElements(JBooleanArrayPtr array,
- ffi.Pointer<JBooleanMarker> elems, int mode) =>
- value.ref.ReleaseBooleanArrayElements.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JBooleanArrayPtr array,
- ffi.Pointer<JBooleanMarker> elems,
- int mode)>()(this, array, elems, mode);
-
- void ReleaseByteArrayElements(
- JByteArrayPtr array, ffi.Pointer<JByteMarker> elems, int mode) =>
- value.ref.ReleaseByteArrayElements.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JByteArrayPtr array,
- ffi.Pointer<JByteMarker> elems,
- int mode)>()(this, array, elems, mode);
-
- void ReleaseCharArrayElements(
- JCharArrayPtr array, ffi.Pointer<JCharMarker> elems, int mode) =>
- value.ref.ReleaseCharArrayElements.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JCharArrayPtr array,
- ffi.Pointer<JCharMarker> elems,
- int mode)>()(this, array, elems, mode);
-
- void ReleaseShortArrayElements(
- JShortArrayPtr array, ffi.Pointer<JShortMarker> elems, int mode) =>
- value.ref.ReleaseShortArrayElements.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JShortArrayPtr array,
- ffi.Pointer<JShortMarker> elems,
- int mode)>()(this, array, elems, mode);
-
- void ReleaseIntArrayElements(
- JIntArrayPtr array, ffi.Pointer<JIntMarker> elems, int mode) =>
- value.ref.ReleaseIntArrayElements.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JIntArrayPtr array,
- ffi.Pointer<JIntMarker> elems,
- int mode)>()(this, array, elems, mode);
-
- void ReleaseLongArrayElements(
- JLongArrayPtr array, ffi.Pointer<JLongMarker> elems, int mode) =>
- value.ref.ReleaseLongArrayElements.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JLongArrayPtr array,
- ffi.Pointer<JLongMarker> elems,
- int mode)>()(this, array, elems, mode);
-
- void ReleaseFloatArrayElements(
- JFloatArrayPtr array, ffi.Pointer<JFloatMarker> elems, int mode) =>
- value.ref.ReleaseFloatArrayElements.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JFloatArrayPtr array,
- ffi.Pointer<JFloatMarker> elems,
- int mode)>()(this, array, elems, mode);
-
- void ReleaseDoubleArrayElements(
- JDoubleArrayPtr array, ffi.Pointer<JDoubleMarker> elems, int mode) =>
- value.ref.ReleaseDoubleArrayElements.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JDoubleArrayPtr array,
- ffi.Pointer<JDoubleMarker> elems,
- int mode)>()(this, array, elems, mode);
-
- void GetBooleanArrayRegion(JBooleanArrayPtr array, int start, int len,
- ffi.Pointer<JBooleanMarker> buf) =>
- value.ref.GetBooleanArrayRegion.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JBooleanArrayPtr array,
- int start,
- int len,
- ffi.Pointer<JBooleanMarker> buf)>()(this, array, start, len, buf);
-
- void GetByteArrayRegion(JByteArrayPtr array, int start, int len,
- ffi.Pointer<JByteMarker> buf) =>
- value.ref.GetByteArrayRegion.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JByteArrayPtr array,
- int start,
- int len,
- ffi.Pointer<JByteMarker> buf)>()(this, array, start, len, buf);
-
- void GetCharArrayRegion(JCharArrayPtr array, int start, int len,
- ffi.Pointer<JCharMarker> buf) =>
- value.ref.GetCharArrayRegion.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JCharArrayPtr array,
- int start,
- int len,
- ffi.Pointer<JCharMarker> buf)>()(this, array, start, len, buf);
-
- void GetShortArrayRegion(JShortArrayPtr array, int start, int len,
- ffi.Pointer<JShortMarker> buf) =>
- value.ref.GetShortArrayRegion.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JShortArrayPtr array,
- int start,
- int len,
- ffi.Pointer<JShortMarker> buf)>()(this, array, start, len, buf);
-
- void GetIntArrayRegion(JIntArrayPtr array, int start, int len,
- ffi.Pointer<JIntMarker> buf) =>
- value.ref.GetIntArrayRegion.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JIntArrayPtr array,
- int start,
- int len,
- ffi.Pointer<JIntMarker> buf)>()(this, array, start, len, buf);
-
- void GetLongArrayRegion(JLongArrayPtr array, int start, int len,
- ffi.Pointer<JLongMarker> buf) =>
- value.ref.GetLongArrayRegion.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JLongArrayPtr array,
- int start,
- int len,
- ffi.Pointer<JLongMarker> buf)>()(this, array, start, len, buf);
-
- void GetFloatArrayRegion(JFloatArrayPtr array, int start, int len,
- ffi.Pointer<JFloatMarker> buf) =>
- value.ref.GetFloatArrayRegion.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JFloatArrayPtr array,
- int start,
- int len,
- ffi.Pointer<JFloatMarker> buf)>()(this, array, start, len, buf);
-
- void GetDoubleArrayRegion(JDoubleArrayPtr array, int start, int len,
- ffi.Pointer<JDoubleMarker> buf) =>
- value.ref.GetDoubleArrayRegion.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JDoubleArrayPtr array,
- int start,
- int len,
- ffi.Pointer<JDoubleMarker> buf)>()(this, array, start, len, buf);
-
- void SetBooleanArrayRegion(JBooleanArrayPtr array, int start, int len,
- ffi.Pointer<JBooleanMarker> buf) =>
- value.ref.SetBooleanArrayRegion.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JBooleanArrayPtr array,
- int start,
- int len,
- ffi.Pointer<JBooleanMarker> buf)>()(this, array, start, len, buf);
-
- void SetByteArrayRegion(JByteArrayPtr array, int start, int len,
- ffi.Pointer<JByteMarker> buf) =>
- value.ref.SetByteArrayRegion.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JByteArrayPtr array,
- int start,
- int len,
- ffi.Pointer<JByteMarker> buf)>()(this, array, start, len, buf);
-
- void SetCharArrayRegion(JCharArrayPtr array, int start, int len,
- ffi.Pointer<JCharMarker> buf) =>
- value.ref.SetCharArrayRegion.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JCharArrayPtr array,
- int start,
- int len,
- ffi.Pointer<JCharMarker> buf)>()(this, array, start, len, buf);
-
- void SetShortArrayRegion(JShortArrayPtr array, int start, int len,
- ffi.Pointer<JShortMarker> buf) =>
- value.ref.SetShortArrayRegion.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JShortArrayPtr array,
- int start,
- int len,
- ffi.Pointer<JShortMarker> buf)>()(this, array, start, len, buf);
-
- void SetIntArrayRegion(JIntArrayPtr array, int start, int len,
- ffi.Pointer<JIntMarker> buf) =>
- value.ref.SetIntArrayRegion.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JIntArrayPtr array,
- int start,
- int len,
- ffi.Pointer<JIntMarker> buf)>()(this, array, start, len, buf);
-
- void SetLongArrayRegion(JLongArrayPtr array, int start, int len,
- ffi.Pointer<JLongMarker> buf) =>
- value.ref.SetLongArrayRegion.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JLongArrayPtr array,
- int start,
- int len,
- ffi.Pointer<JLongMarker> buf)>()(this, array, start, len, buf);
-
- void SetFloatArrayRegion(JFloatArrayPtr array, int start, int len,
- ffi.Pointer<JFloatMarker> buf) =>
- value.ref.SetFloatArrayRegion.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JFloatArrayPtr array,
- int start,
- int len,
- ffi.Pointer<JFloatMarker> buf)>()(this, array, start, len, buf);
-
- void SetDoubleArrayRegion(JDoubleArrayPtr array, int start, int len,
- ffi.Pointer<JDoubleMarker> buf) =>
- value.ref.SetDoubleArrayRegion.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JDoubleArrayPtr array,
- int start,
- int len,
- ffi.Pointer<JDoubleMarker> buf)>()(this, array, start, len, buf);
-
- int RegisterNatives(JClassPtr clazz, ffi.Pointer<JNINativeMethod> methods,
- int nMethods) =>
- value.ref.RegisterNatives.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env,
- JClassPtr clazz,
- ffi.Pointer<JNINativeMethod> methods,
- int nMethods)>()(this, clazz, methods, nMethods);
-
- int UnregisterNatives(JClassPtr clazz) =>
- value.ref.UnregisterNatives.asFunction<
- int Function(
- ffi.Pointer<JniEnv1> env, JClassPtr clazz)>()(this, clazz);
-
- int MonitorEnter(JObjectPtr obj) => value.ref.MonitorEnter
- .asFunction<int Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj)>()(
- this, obj);
-
- int MonitorExit(JObjectPtr obj) => value.ref.MonitorExit
- .asFunction<int Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj)>()(
- this, obj);
-
- int GetJavaVM(ffi.Pointer<ffi.Pointer<JavaVM1>> vm) =>
- value.ref.GetJavaVM.asFunction<
- int Function(ffi.Pointer<JniEnv1> env,
- ffi.Pointer<ffi.Pointer<JavaVM1>> vm)>()(this, vm);
-
- void GetStringRegion(
- JStringPtr str, int start, int len, ffi.Pointer<JCharMarker> buf) =>
- value.ref.GetStringRegion.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JStringPtr str,
- int start,
- int len,
- ffi.Pointer<JCharMarker> buf)>()(this, str, start, len, buf);
-
- void GetStringUTFRegion(
- JStringPtr str, int start, int len, ffi.Pointer<ffi.Char> buf) =>
- value.ref.GetStringUTFRegion.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JStringPtr str,
- int start,
- int len,
- ffi.Pointer<ffi.Char> buf)>()(this, str, start, len, buf);
-
- ffi.Pointer<ffi.Void> GetPrimitiveArrayCritical(
- JArrayPtr array, ffi.Pointer<JBooleanMarker> isCopy) =>
- value.ref.GetPrimitiveArrayCritical.asFunction<
- ffi.Pointer<ffi.Void> Function(
- ffi.Pointer<JniEnv1> env,
- JArrayPtr array,
- ffi.Pointer<JBooleanMarker> isCopy)>()(this, array, isCopy);
-
- void ReleasePrimitiveArrayCritical(
- JArrayPtr array, ffi.Pointer<ffi.Void> carray, int mode) =>
- value.ref.ReleasePrimitiveArrayCritical.asFunction<
- void Function(
- ffi.Pointer<JniEnv1> env,
- JArrayPtr array,
- ffi.Pointer<ffi.Void> carray,
- int mode)>()(this, array, carray, mode);
-
- ffi.Pointer<JCharMarker> GetStringCritical(
- JStringPtr str, ffi.Pointer<JBooleanMarker> isCopy) =>
- value.ref.GetStringCritical.asFunction<
- ffi.Pointer<JCharMarker> Function(
- ffi.Pointer<JniEnv1> env,
- JStringPtr str,
- ffi.Pointer<JBooleanMarker> isCopy)>()(this, str, isCopy);
-
- void ReleaseStringCritical(JStringPtr str, ffi.Pointer<JCharMarker> carray) =>
- value.ref.ReleaseStringCritical.asFunction<
- void Function(ffi.Pointer<JniEnv1> env, JStringPtr str,
- ffi.Pointer<JCharMarker> carray)>()(this, str, carray);
-
- JWeakPtr NewWeakGlobalRef(JObjectPtr obj) =>
- value.ref.NewWeakGlobalRef.asFunction<
- JWeakPtr Function(
- ffi.Pointer<JniEnv1> env, JObjectPtr obj)>()(this, obj);
-
- void DeleteWeakGlobalRef(JWeakPtr obj) => value.ref.DeleteWeakGlobalRef
- .asFunction<void Function(ffi.Pointer<JniEnv1> env, JWeakPtr obj)>()(
- this, obj);
-
- int ExceptionCheck() => value.ref.ExceptionCheck
- .asFunction<int Function(ffi.Pointer<JniEnv1> env)>()(this);
-
- JObjectPtr NewDirectByteBuffer(ffi.Pointer<ffi.Void> address, int capacity) =>
- value.ref.NewDirectByteBuffer.asFunction<
- JObjectPtr Function(
- ffi.Pointer<JniEnv1> env,
- ffi.Pointer<ffi.Void> address,
- int capacity)>()(this, address, capacity);
-
- ffi.Pointer<ffi.Void> GetDirectBufferAddress(JObjectPtr buf) =>
- value.ref.GetDirectBufferAddress.asFunction<
- ffi.Pointer<ffi.Void> Function(
- ffi.Pointer<JniEnv1> env, JObjectPtr buf)>()(this, buf);
-
- int GetDirectBufferCapacity(JObjectPtr buf) => value
- .ref.GetDirectBufferCapacity
- .asFunction<int Function(ffi.Pointer<JniEnv1> env, JObjectPtr buf)>()(
- this, buf);
-
- int GetObjectRefType(JObjectPtr obj) => value.ref.GetObjectRefType
- .asFunction<int Function(ffi.Pointer<JniEnv1> env, JObjectPtr obj)>()(
- this, obj);
-}
-
-extension JavaVMExtension on ffi.Pointer<JavaVM> {
- int DestroyJavaVM() => value.ref.DestroyJavaVM
- .asFunction<int Function(ffi.Pointer<JavaVM1> vm)>()(this);
-
- int AttachCurrentThread(ffi.Pointer<ffi.Pointer<JniEnv>> p_env,
- ffi.Pointer<ffi.Void> thr_args) =>
- value.ref.AttachCurrentThread.asFunction<
- int Function(
- ffi.Pointer<JavaVM1> vm,
- ffi.Pointer<ffi.Pointer<JniEnv>> p_env,
- ffi.Pointer<ffi.Void> thr_args)>()(this, p_env, thr_args);
-
- int DetachCurrentThread() => value.ref.DetachCurrentThread
- .asFunction<int Function(ffi.Pointer<JavaVM1> vm)>()(this);
-
- int GetEnv(ffi.Pointer<ffi.Pointer<ffi.Void>> p_env, int version) =>
- value.ref.GetEnv.asFunction<
- int Function(
- ffi.Pointer<JavaVM1> vm,
- ffi.Pointer<ffi.Pointer<ffi.Void>> p_env,
- int version)>()(this, p_env, version);
-
- int AttachCurrentThreadAsDaemon(ffi.Pointer<ffi.Pointer<JniEnv>> p_env,
- ffi.Pointer<ffi.Void> thr_args) =>
- value.ref.AttachCurrentThreadAsDaemon.asFunction<
- int Function(
- ffi.Pointer<JavaVM1> vm,
- ffi.Pointer<ffi.Pointer<JniEnv>> p_env,
- ffi.Pointer<ffi.Void> thr_args)>()(this, p_env, thr_args);
-}
diff --git a/pkgs/jni/lib/src/types.dart b/pkgs/jni/lib/src/types.dart
index cc2dbec..90b9378 100644
--- a/pkgs/jni/lib/src/types.dart
+++ b/pkgs/jni/lib/src/types.dart
@@ -19,8 +19,8 @@
part 'jobject.dart';
part 'jstring.dart';
-final Pointer<JniAccessors> _accessors = Jni.accessors;
-final Pointer<GlobalJniEnv> _env = Jni.env;
+final JniAccessors _accessors = Jni.accessors;
+final GlobalJniEnv _env = Jni.env;
// This typedef is needed because void is a keyword and cannot be used in
// type switch like a regular type.
typedef _VoidType = void;
diff --git a/pkgs/jni/src/dartjni.c b/pkgs/jni/src/dartjni.c
index 74c4a11..7346fef 100644
--- a/pkgs/jni/src/dartjni.c
+++ b/pkgs/jni/src/dartjni.c
@@ -129,11 +129,43 @@
// Sometimes you may get linker error trying to link JNI_CreateJavaVM APIs
// on Android NDK. So IFDEF is required.
#else
+#ifdef _WIN32
+// Pre-initialization of critical section on windows - this is required because
+// there's no coordination between multiple isolates calling Spawn.
+//
+// Taken from https://stackoverflow.com/a/12858955
+CRITICAL_SECTION spawnLock = {0};
+BOOL WINAPI DllMain(HINSTANCE hinstDLL, // handle to DLL module
+ DWORD fdwReason, // reason for calling function
+ LPVOID lpReserved) { // reserved
+ switch (fdwReason) {
+ case DLL_PROCESS_ATTACH:
+ // Initialize once for each new process.
+ // Return FALSE to fail DLL load.
+ InitializeCriticalSection(&spawnLock);
+ break;
+ case DLL_PROCESS_DETACH:
+ // Perform any necessary cleanup.
+ DeleteCriticalSection(&spawnLock);
+ break;
+ }
+ return TRUE; // Successful DLL_PROCESS_ATTACH.
+}
+#else
+pthread_mutex_t spawnLock = PTHREAD_MUTEX_INITIALIZER;
+#endif
FFI_PLUGIN_EXPORT
int SpawnJvm(JavaVMInitArgs* initArgs) {
if (jni_context.jvm != NULL) {
return DART_JNI_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;
+ }
JavaVMOption jvmopt[1];
char class_path[] = "-Djava.class.path=.";
jvmopt[0].optionString = class_path;
@@ -152,6 +184,8 @@
}
initAllLocks(&jni_context.locks);
initExceptionHandling(&exceptionMethods);
+ release_lock(&spawnLock);
+
return JNI_OK;
}
#endif
@@ -496,7 +530,7 @@
return details;
}
-JniAccessors accessors = {
+JniAccessorsStruct accessors = {
.getClass = getClass,
.getFieldID = getFieldID,
.getStaticFieldID = getStaticFieldID,
@@ -513,7 +547,7 @@
.getExceptionDetails = getExceptionDetails,
};
-FFI_PLUGIN_EXPORT JniAccessors* GetAccessors() {
+FFI_PLUGIN_EXPORT JniAccessorsStruct* GetAccessors() {
return &accessors;
}
diff --git a/pkgs/jni/src/dartjni.h b/pkgs/jni/src/dartjni.h
index eb73318..21cef20 100644
--- a/pkgs/jni/src/dartjni.h
+++ b/pkgs/jni/src/dartjni.h
@@ -163,7 +163,7 @@
/// Flutter embedding checks for pending JNI exceptions before an FFI transition, which requires us
/// to check for and clear the exception before returning to dart code, which requires these functions
/// to return result types.
-typedef struct JniAccessors {
+typedef struct JniAccessorsStruct {
JniClassLookupResult (*getClass)(char* internalName);
JniPointerResult (*getFieldID)(jclass cls, char* fieldName, char* signature);
JniPointerResult (*getStaticFieldID)(jclass cls,
@@ -192,9 +192,9 @@
JniResult (*getField)(jobject obj, jfieldID fieldID, int callType);
JniResult (*getStaticField)(jclass cls, jfieldID fieldID, int callType);
JniExceptionDetails (*getExceptionDetails)(jthrowable exception);
-} JniAccessors;
+} JniAccessorsStruct;
-FFI_PLUGIN_EXPORT JniAccessors* GetAccessors();
+FFI_PLUGIN_EXPORT JniAccessorsStruct* GetAccessors();
FFI_PLUGIN_EXPORT JavaVM* GetJavaVM(void);
diff --git a/pkgs/jni/src/third_party/global_jni_env.c b/pkgs/jni/src/third_party/global_jni_env.c
index 600b585..c5be7b0 100644
--- a/pkgs/jni/src/third_party/global_jni_env.c
+++ b/pkgs/jni/src/third_party/global_jni_env.c
@@ -2269,7 +2269,7 @@
return (JniResult){.value = {.i = _result}, .exception = NULL};
}
-GlobalJniEnv globalJniEnv = {
+GlobalJniEnvStruct globalJniEnv = {
.reserved0 = NULL,
.reserved1 = NULL,
.reserved2 = NULL,
@@ -2505,7 +2505,7 @@
.GetObjectRefType = globalEnv_GetObjectRefType,
};
FFI_PLUGIN_EXPORT
-GlobalJniEnv* GetGlobalEnv() {
+GlobalJniEnvStruct* GetGlobalEnv() {
if (jni->jvm == NULL) {
return NULL;
}
diff --git a/pkgs/jni/src/third_party/global_jni_env.h b/pkgs/jni/src/third_party/global_jni_env.h
index 8966d2b..562b1bf 100644
--- a/pkgs/jni/src/third_party/global_jni_env.h
+++ b/pkgs/jni/src/third_party/global_jni_env.h
@@ -29,7 +29,7 @@
#include <stdint.h>
#include "../dartjni.h"
-typedef struct GlobalJniEnv {
+typedef struct GlobalJniEnvStruct {
void* reserved0;
void* reserved1;
void* reserved2;
@@ -430,5 +430,5 @@
JniPointerResult (*GetDirectBufferAddress)(jobject buf);
JniResult (*GetDirectBufferCapacity)(jobject buf);
JniResult (*GetObjectRefType)(jobject obj);
-} GlobalJniEnv;
-FFI_PLUGIN_EXPORT GlobalJniEnv* GetGlobalEnv();
+} GlobalJniEnvStruct;
+FFI_PLUGIN_EXPORT GlobalJniEnvStruct* GetGlobalEnv();
diff --git a/pkgs/jni/tool/wrapper_generators/generate_c_extensions.dart b/pkgs/jni/tool/wrapper_generators/generate_c_extensions.dart
index ef907bf..cde47c9 100644
--- a/pkgs/jni/tool/wrapper_generators/generate_c_extensions.dart
+++ b/pkgs/jni/tool/wrapper_generators/generate_c_extensions.dart
@@ -29,7 +29,7 @@
const envType = 'JNINativeInterface';
/// Name of wrapper to JNIEnv
-const wrapperName = 'GlobalJniEnv';
+const wrapperName = 'GlobalJniEnvStruct';
const wrapperIncludes = '''
#include "global_jni_env.h"
diff --git a/pkgs/jni/tool/wrapper_generators/generate_dart_extensions.dart b/pkgs/jni/tool/wrapper_generators/generate_dart_extensions.dart
index 1ec422d..c78b883 100644
--- a/pkgs/jni/tool/wrapper_generators/generate_dart_extensions.dart
+++ b/pkgs/jni/tool/wrapper_generators/generate_dart_extensions.dart
@@ -21,6 +21,8 @@
bindingsDir.resolve("jnienv_javavm_extensions.dart");
}
+const writeLocalEnvExtensions = false;
+
void executeDartFormat(List<Uri> files) {
final paths = files.map((u) => u.toFilePath()).toList();
logger.info('execute dart format ${paths.join(" ")}');
@@ -31,7 +33,7 @@
}
}
-const globalEnvType = 'GlobalJniEnv';
+const globalEnvType = 'GlobalJniEnvStruct';
const localEnvType = 'JNINativeInterface';
const jvmType = 'JNIInvokeInterface';
@@ -97,9 +99,13 @@
if (checkedGetter == 'boolean') {
returns = 'bool';
}
- return '$returns ${field.name}($signature) => '
- 'ref.${field.name}.asFunction<$dartType>()($callArgs)'
- '.$checkedGetter;\n';
+ return '''
+late final _${field.name} =
+ ptr.ref.${field.name}.asFunction<$dartType>();\n
+$returns ${field.name}($signature) =>
+ _${field.name}($callArgs).$checkedGetter;
+
+''';
}
return null;
}
@@ -119,26 +125,38 @@
''';
final globalEnvExtension = getGlobalEnvExtension(library);
- final accessorExtension =
- getFunctionPointerExtension(library, 'JniAccessors');
- final envExtension = getFunctionPointerExtension(
+ final accessorExtension = getFunctionPointerExtension(
library,
- 'JniEnv',
- indirect: true,
- implicitThis: true,
- );
- final jvmExtension = getFunctionPointerExtension(
- library,
- 'JavaVM',
- indirect: true,
- implicitThis: true,
+ 'JniAccessorsStruct',
+ 'JniAccessors',
);
File.fromUri(Paths.globalEnvExts).writeAsStringSync(preamble +
header +
importAccessors +
globalEnvExtension +
accessorExtension);
- File.fromUri(Paths.localEnvExts)
+ final localEnvExtsFile = File.fromUri(Paths.localEnvExts);
+ if (localEnvExtsFile.existsSync()) {
+ localEnvExtsFile.deleteSync();
+ }
+ if (!writeLocalEnvExtensions) {
+ return;
+ }
+ final envExtension = getFunctionPointerExtension(
+ library,
+ 'JniEnv',
+ 'LocalJniEnv',
+ indirect: true,
+ implicitThis: true,
+ );
+ final jvmExtension = getFunctionPointerExtension(
+ library,
+ 'JavaVM',
+ 'JniJavaVM',
+ indirect: true,
+ implicitThis: true,
+ );
+ localEnvExtsFile
.writeAsStringSync(preamble + header + envExtension + jvmExtension);
}
@@ -159,8 +177,15 @@
.map((m) => getGlobalEnvExtensionFunction(m, checkedReturnTypes[m.name]))
.whereNotNull()
.join('\n');
- return 'extension EnvExtension on ffi.Pointer<$globalEnvType> '
- '{$extensionFunctions}';
+ return '''
+/// Wraps over Pointer<GlobalJniEnvStruct> and exposes function pointer fields
+/// as methods.
+class GlobalJniEnv {
+ final ffi.Pointer<GlobalJniEnvStruct> ptr;
+ GlobalJniEnv(this.ptr);
+ $extensionFunctions
+}
+''';
}
String? getFunctionPointerExtensionFunction(Member field,
@@ -184,18 +209,23 @@
final dartType = FunctionType(returnType: returnType, parameters: params)
.getDartType(dummyWriter);
final callArgs = [
- if (implicitThis) 'this',
+ if (implicitThis) 'ptr',
...visibleParams.map((p) => p.name)
].join(', ');
final returns = returnType.getDartType(dummyWriter);
final dereference = indirect ? 'value.ref' : 'ref';
- return '$returns ${field.name}($signature) => '
- '$dereference.${field.name}.asFunction<$dartType>()($callArgs);\n';
+ return '''
+late final _${field.name} =
+ ptr.$dereference.${field.name}.asFunction<$dartType>();
+$returns ${field.name}($signature) => _${field.name}($callArgs);
+
+''';
}
return null;
}
-String getFunctionPointerExtension(Library library, String type,
+String getFunctionPointerExtension(
+ Library library, String type, String wrapperClassName,
{bool indirect = false, bool implicitThis = false}) {
final typeBinding =
library.bindings.firstWhere((b) => b.name == type) as Type;
@@ -205,8 +235,16 @@
indirect: indirect, implicitThis: implicitThis))
.whereNotNull()
.join('\n');
- return 'extension ${type}Extension on ffi.Pointer<$type> '
- '{$extensionFunctions}';
+ return '''
+/// Wraps over the function pointers in $type and exposes them as methods.
+class $wrapperClassName {
+ final ffi.Pointer<$type> ptr;
+ $wrapperClassName(this.ptr);
+
+ $extensionFunctions
+}
+
+''';
}
void generateDartExtensions(Library library) {
diff --git a/pkgs/jnigen/example/in_app_java/src/android_utils/dartjni.h b/pkgs/jnigen/example/in_app_java/src/android_utils/dartjni.h
index eb73318..21cef20 100644
--- a/pkgs/jnigen/example/in_app_java/src/android_utils/dartjni.h
+++ b/pkgs/jnigen/example/in_app_java/src/android_utils/dartjni.h
@@ -163,7 +163,7 @@
/// Flutter embedding checks for pending JNI exceptions before an FFI transition, which requires us
/// to check for and clear the exception before returning to dart code, which requires these functions
/// to return result types.
-typedef struct JniAccessors {
+typedef struct JniAccessorsStruct {
JniClassLookupResult (*getClass)(char* internalName);
JniPointerResult (*getFieldID)(jclass cls, char* fieldName, char* signature);
JniPointerResult (*getStaticFieldID)(jclass cls,
@@ -192,9 +192,9 @@
JniResult (*getField)(jobject obj, jfieldID fieldID, int callType);
JniResult (*getStaticField)(jclass cls, jfieldID fieldID, int callType);
JniExceptionDetails (*getExceptionDetails)(jthrowable exception);
-} JniAccessors;
+} JniAccessorsStruct;
-FFI_PLUGIN_EXPORT JniAccessors* GetAccessors();
+FFI_PLUGIN_EXPORT JniAccessorsStruct* GetAccessors();
FFI_PLUGIN_EXPORT JavaVM* GetJavaVM(void);
diff --git a/pkgs/jnigen/example/kotlin_plugin/src/dartjni.h b/pkgs/jnigen/example/kotlin_plugin/src/dartjni.h
index eb73318..21cef20 100644
--- a/pkgs/jnigen/example/kotlin_plugin/src/dartjni.h
+++ b/pkgs/jnigen/example/kotlin_plugin/src/dartjni.h
@@ -163,7 +163,7 @@
/// Flutter embedding checks for pending JNI exceptions before an FFI transition, which requires us
/// to check for and clear the exception before returning to dart code, which requires these functions
/// to return result types.
-typedef struct JniAccessors {
+typedef struct JniAccessorsStruct {
JniClassLookupResult (*getClass)(char* internalName);
JniPointerResult (*getFieldID)(jclass cls, char* fieldName, char* signature);
JniPointerResult (*getStaticFieldID)(jclass cls,
@@ -192,9 +192,9 @@
JniResult (*getField)(jobject obj, jfieldID fieldID, int callType);
JniResult (*getStaticField)(jclass cls, jfieldID fieldID, int callType);
JniExceptionDetails (*getExceptionDetails)(jthrowable exception);
-} JniAccessors;
+} JniAccessorsStruct;
-FFI_PLUGIN_EXPORT JniAccessors* GetAccessors();
+FFI_PLUGIN_EXPORT JniAccessorsStruct* GetAccessors();
FFI_PLUGIN_EXPORT JavaVM* GetJavaVM(void);
diff --git a/pkgs/jnigen/example/notification_plugin/src/dartjni.h b/pkgs/jnigen/example/notification_plugin/src/dartjni.h
index eb73318..21cef20 100644
--- a/pkgs/jnigen/example/notification_plugin/src/dartjni.h
+++ b/pkgs/jnigen/example/notification_plugin/src/dartjni.h
@@ -163,7 +163,7 @@
/// Flutter embedding checks for pending JNI exceptions before an FFI transition, which requires us
/// to check for and clear the exception before returning to dart code, which requires these functions
/// to return result types.
-typedef struct JniAccessors {
+typedef struct JniAccessorsStruct {
JniClassLookupResult (*getClass)(char* internalName);
JniPointerResult (*getFieldID)(jclass cls, char* fieldName, char* signature);
JniPointerResult (*getStaticFieldID)(jclass cls,
@@ -192,9 +192,9 @@
JniResult (*getField)(jobject obj, jfieldID fieldID, int callType);
JniResult (*getStaticField)(jclass cls, jfieldID fieldID, int callType);
JniExceptionDetails (*getExceptionDetails)(jthrowable exception);
-} JniAccessors;
+} JniAccessorsStruct;
-FFI_PLUGIN_EXPORT JniAccessors* GetAccessors();
+FFI_PLUGIN_EXPORT JniAccessorsStruct* GetAccessors();
FFI_PLUGIN_EXPORT JavaVM* GetJavaVM(void);
diff --git a/pkgs/jnigen/example/pdfbox_plugin/src/third_party/dartjni.h b/pkgs/jnigen/example/pdfbox_plugin/src/third_party/dartjni.h
index eb73318..21cef20 100644
--- a/pkgs/jnigen/example/pdfbox_plugin/src/third_party/dartjni.h
+++ b/pkgs/jnigen/example/pdfbox_plugin/src/third_party/dartjni.h
@@ -163,7 +163,7 @@
/// Flutter embedding checks for pending JNI exceptions before an FFI transition, which requires us
/// to check for and clear the exception before returning to dart code, which requires these functions
/// to return result types.
-typedef struct JniAccessors {
+typedef struct JniAccessorsStruct {
JniClassLookupResult (*getClass)(char* internalName);
JniPointerResult (*getFieldID)(jclass cls, char* fieldName, char* signature);
JniPointerResult (*getStaticFieldID)(jclass cls,
@@ -192,9 +192,9 @@
JniResult (*getField)(jobject obj, jfieldID fieldID, int callType);
JniResult (*getStaticField)(jclass cls, jfieldID fieldID, int callType);
JniExceptionDetails (*getExceptionDetails)(jthrowable exception);
-} JniAccessors;
+} JniAccessorsStruct;
-FFI_PLUGIN_EXPORT JniAccessors* GetAccessors();
+FFI_PLUGIN_EXPORT JniAccessorsStruct* GetAccessors();
FFI_PLUGIN_EXPORT JavaVM* GetJavaVM(void);
diff --git a/pkgs/jnigen/test/kotlin_test/src/dartjni.h b/pkgs/jnigen/test/kotlin_test/src/dartjni.h
index eb73318..21cef20 100644
--- a/pkgs/jnigen/test/kotlin_test/src/dartjni.h
+++ b/pkgs/jnigen/test/kotlin_test/src/dartjni.h
@@ -163,7 +163,7 @@
/// Flutter embedding checks for pending JNI exceptions before an FFI transition, which requires us
/// to check for and clear the exception before returning to dart code, which requires these functions
/// to return result types.
-typedef struct JniAccessors {
+typedef struct JniAccessorsStruct {
JniClassLookupResult (*getClass)(char* internalName);
JniPointerResult (*getFieldID)(jclass cls, char* fieldName, char* signature);
JniPointerResult (*getStaticFieldID)(jclass cls,
@@ -192,9 +192,9 @@
JniResult (*getField)(jobject obj, jfieldID fieldID, int callType);
JniResult (*getStaticField)(jclass cls, jfieldID fieldID, int callType);
JniExceptionDetails (*getExceptionDetails)(jthrowable exception);
-} JniAccessors;
+} JniAccessorsStruct;
-FFI_PLUGIN_EXPORT JniAccessors* GetAccessors();
+FFI_PLUGIN_EXPORT JniAccessorsStruct* GetAccessors();
FFI_PLUGIN_EXPORT JavaVM* GetJavaVM(void);
diff --git a/pkgs/jnigen/test/simple_package_test/src/dartjni.h b/pkgs/jnigen/test/simple_package_test/src/dartjni.h
index eb73318..21cef20 100644
--- a/pkgs/jnigen/test/simple_package_test/src/dartjni.h
+++ b/pkgs/jnigen/test/simple_package_test/src/dartjni.h
@@ -163,7 +163,7 @@
/// Flutter embedding checks for pending JNI exceptions before an FFI transition, which requires us
/// to check for and clear the exception before returning to dart code, which requires these functions
/// to return result types.
-typedef struct JniAccessors {
+typedef struct JniAccessorsStruct {
JniClassLookupResult (*getClass)(char* internalName);
JniPointerResult (*getFieldID)(jclass cls, char* fieldName, char* signature);
JniPointerResult (*getStaticFieldID)(jclass cls,
@@ -192,9 +192,9 @@
JniResult (*getField)(jobject obj, jfieldID fieldID, int callType);
JniResult (*getStaticField)(jclass cls, jfieldID fieldID, int callType);
JniExceptionDetails (*getExceptionDetails)(jthrowable exception);
-} JniAccessors;
+} JniAccessorsStruct;
-FFI_PLUGIN_EXPORT JniAccessors* GetAccessors();
+FFI_PLUGIN_EXPORT JniAccessorsStruct* GetAccessors();
FFI_PLUGIN_EXPORT JavaVM* GetJavaVM(void);
