From b7deaefff7a28481c0988aa40520f53ebc5bbadb Mon Sep 17 00:00:00 2001 From: Emmanuel Hansen Date: Mon, 9 Sep 2024 19:08:38 +0000 Subject: [PATCH] android - update jni --- Directory.Packages.props | 2 +- src/LibRyujinx/Android/Jni/Delegates.cs | 357 ++++++++++++++++++ .../{ => Android}/Jni/Identifiers/JFieldId.cs | 2 +- .../Jni/Identifiers/JMethodId.cs | 2 +- .../{ => Android}/Jni/JReferenceType.cs | 2 +- .../{ => Android}/Jni/JReleaseMode.cs | 3 +- src/LibRyujinx/{ => Android}/Jni/JResult.cs | 3 +- src/LibRyujinx/Android/Jni/JniHelper.cs | 234 ++++++++++++ .../{ => Android}/Jni/Pointers/JEnvRef.cs | 7 +- .../Android/Jni/Pointers/JavaVMRef.cs | 31 ++ .../Android/Jni/Primitives/JBoolean.cs | 67 ++++ .../{ => Android}/Jni/Primitives/JByte.cs | 2 +- .../{ => Android}/Jni/Primitives/JChar.cs | 2 +- .../{ => Android}/Jni/Primitives/JDouble.cs | 2 +- .../{ => Android}/Jni/Primitives/JFloat.cs | 2 +- .../{ => Android}/Jni/Primitives/JInt.cs | 2 +- .../{ => Android}/Jni/Primitives/JLong.cs | 2 +- .../{ => Android}/Jni/Primitives/JShort.cs | 2 +- .../Android/Jni/References/JArrayLocalRef.cs | 26 ++ .../Android/Jni/References/JClassLocalRef.cs | 29 ++ .../Android/Jni/References/JGlobalRef.cs | 28 ++ .../Jni/References/JObjectLocalRef.cs | 2 +- .../Android/Jni/References/JStringLocalRef.cs | 27 ++ .../Jni/References/JThrowableLocalRef.cs | 27 ++ .../Android/Jni/References/JWeakRef.cs | 26 ++ .../{ => Android}/Jni/Values/JEnvValue.cs | 2 +- .../Jni/Values/JInvokeInterface.cs | 2 +- .../Android/Jni/Values/JNativeInterface.cs | 247 ++++++++++++ .../Android/Jni/Values/JNativeMethod.cs | 11 + src/LibRyujinx/Android/Jni/Values/JValue.cs | 46 +++ .../Android/Jni/Values/JavaVMAttachArgs.cs | 13 + .../Jni/Values/JavaVMInitArgs.cs | 2 +- .../Android/Jni/Values/JavaVMOption.cs | 10 + .../Android/Jni/Values/JavaVMValue.cs | 29 ++ src/LibRyujinx/Jni/Delegates.cs | 286 -------------- src/LibRyujinx/Jni/Pointers/CCharSequence.cs | 36 -- src/LibRyujinx/Jni/Pointers/JBooleanRef.cs | 30 -- src/LibRyujinx/Jni/Pointers/JCharSequence.cs | 33 -- .../Jni/Pointers/JNativeMethodSequence.cs | 33 -- src/LibRyujinx/Jni/Pointers/JValueSequence.cs | 33 -- src/LibRyujinx/Jni/Pointers/JavaVMRef.cs | 25 -- src/LibRyujinx/Jni/Primitives/JBoolean.cs | 67 ---- .../Jni/References/JArrayLocalRef.cs | 28 -- .../Jni/References/JClassLocalRef.cs | 28 -- src/LibRyujinx/Jni/References/JGlobalRef.cs | 28 -- .../Jni/References/JStringLocalRef.cs | 28 -- .../Jni/References/JThrowableLocalRef.cs | 28 -- src/LibRyujinx/Jni/References/JWeakRef.cs | 28 -- src/LibRyujinx/Jni/Values/JNativeInterface.cs | 245 ------------ src/LibRyujinx/Jni/Values/JNativeMethod.cs | 12 - src/LibRyujinx/Jni/Values/JValue.cs | 47 --- src/LibRyujinx/Jni/Values/JavaVMAttachArgs.cs | 13 - src/LibRyujinx/Jni/Values/JavaVMOption.cs | 11 - src/LibRyujinx/LibRyujinx.csproj | 13 +- 54 files changed, 1238 insertions(+), 1065 deletions(-) create mode 100644 src/LibRyujinx/Android/Jni/Delegates.cs rename src/LibRyujinx/{ => Android}/Jni/Identifiers/JFieldId.cs (95%) rename src/LibRyujinx/{ => Android}/Jni/Identifiers/JMethodId.cs (95%) rename src/LibRyujinx/{ => Android}/Jni/JReferenceType.cs (91%) rename src/LibRyujinx/{ => Android}/Jni/JReleaseMode.cs (88%) rename src/LibRyujinx/{ => Android}/Jni/JResult.cs (93%) create mode 100644 src/LibRyujinx/Android/Jni/JniHelper.cs rename src/LibRyujinx/{ => Android}/Jni/Pointers/JEnvRef.cs (89%) create mode 100644 src/LibRyujinx/Android/Jni/Pointers/JavaVMRef.cs create mode 100644 src/LibRyujinx/Android/Jni/Primitives/JBoolean.cs rename src/LibRyujinx/{ => Android}/Jni/Primitives/JByte.cs (99%) rename src/LibRyujinx/{ => Android}/Jni/Primitives/JChar.cs (99%) rename src/LibRyujinx/{ => Android}/Jni/Primitives/JDouble.cs (99%) rename src/LibRyujinx/{ => Android}/Jni/Primitives/JFloat.cs (99%) rename src/LibRyujinx/{ => Android}/Jni/Primitives/JInt.cs (99%) rename src/LibRyujinx/{ => Android}/Jni/Primitives/JLong.cs (99%) rename src/LibRyujinx/{ => Android}/Jni/Primitives/JShort.cs (99%) create mode 100644 src/LibRyujinx/Android/Jni/References/JArrayLocalRef.cs create mode 100644 src/LibRyujinx/Android/Jni/References/JClassLocalRef.cs create mode 100644 src/LibRyujinx/Android/Jni/References/JGlobalRef.cs rename src/LibRyujinx/{ => Android}/Jni/References/JObjectLocalRef.cs (95%) create mode 100644 src/LibRyujinx/Android/Jni/References/JStringLocalRef.cs create mode 100644 src/LibRyujinx/Android/Jni/References/JThrowableLocalRef.cs create mode 100644 src/LibRyujinx/Android/Jni/References/JWeakRef.cs rename src/LibRyujinx/{ => Android}/Jni/Values/JEnvValue.cs (97%) rename src/LibRyujinx/{ => Android}/Jni/Values/JInvokeInterface.cs (94%) create mode 100644 src/LibRyujinx/Android/Jni/Values/JNativeInterface.cs create mode 100644 src/LibRyujinx/Android/Jni/Values/JNativeMethod.cs create mode 100644 src/LibRyujinx/Android/Jni/Values/JValue.cs create mode 100644 src/LibRyujinx/Android/Jni/Values/JavaVMAttachArgs.cs rename src/LibRyujinx/{ => Android}/Jni/Values/JavaVMInitArgs.cs (94%) create mode 100644 src/LibRyujinx/Android/Jni/Values/JavaVMOption.cs create mode 100644 src/LibRyujinx/Android/Jni/Values/JavaVMValue.cs delete mode 100644 src/LibRyujinx/Jni/Delegates.cs delete mode 100644 src/LibRyujinx/Jni/Pointers/CCharSequence.cs delete mode 100644 src/LibRyujinx/Jni/Pointers/JBooleanRef.cs delete mode 100644 src/LibRyujinx/Jni/Pointers/JCharSequence.cs delete mode 100644 src/LibRyujinx/Jni/Pointers/JNativeMethodSequence.cs delete mode 100644 src/LibRyujinx/Jni/Pointers/JValueSequence.cs delete mode 100644 src/LibRyujinx/Jni/Pointers/JavaVMRef.cs delete mode 100644 src/LibRyujinx/Jni/Primitives/JBoolean.cs delete mode 100644 src/LibRyujinx/Jni/References/JArrayLocalRef.cs delete mode 100644 src/LibRyujinx/Jni/References/JClassLocalRef.cs delete mode 100644 src/LibRyujinx/Jni/References/JGlobalRef.cs delete mode 100644 src/LibRyujinx/Jni/References/JStringLocalRef.cs delete mode 100644 src/LibRyujinx/Jni/References/JThrowableLocalRef.cs delete mode 100644 src/LibRyujinx/Jni/References/JWeakRef.cs delete mode 100644 src/LibRyujinx/Jni/Values/JNativeInterface.cs delete mode 100644 src/LibRyujinx/Jni/Values/JNativeMethod.cs delete mode 100644 src/LibRyujinx/Jni/Values/JValue.cs delete mode 100644 src/LibRyujinx/Jni/Values/JavaVMAttachArgs.cs delete mode 100644 src/LibRyujinx/Jni/Values/JavaVMOption.cs diff --git a/Directory.Packages.props b/Directory.Packages.props index 2c63988fc..ad4765153 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -49,6 +49,6 @@ - + diff --git a/src/LibRyujinx/Android/Jni/Delegates.cs b/src/LibRyujinx/Android/Jni/Delegates.cs new file mode 100644 index 000000000..a0d86c53a --- /dev/null +++ b/src/LibRyujinx/Android/Jni/Delegates.cs @@ -0,0 +1,357 @@ +using LibRyujinx.Jni.Identifiers; +using LibRyujinx.Jni.Pointers; +using LibRyujinx.Jni.Primitives; +using LibRyujinx.Jni.References; +using LibRyujinx.Jni.Values; +using System; + +using Rxmxnx.PInvoke; + +namespace LibRyujinx.Jni; + +internal delegate Int32 GetVersionDelegate(JEnvRef env); + +internal delegate JResult RegisterNativesDelegate(JEnvRef env, JClassLocalRef jClass, + ReadOnlyValPtr methods0, Int32 nMethods); + +internal delegate JResult UnregisterNativesDelegate(JEnvRef env, JClassLocalRef jClass); +internal delegate JResult MonitorEnterDelegate(JEnvRef env, JObjectLocalRef jClass); +internal delegate JResult MonitorExitDelegate(JEnvRef env, JObjectLocalRef jClass); +internal delegate JResult GetVirtualMachineDelegate(JEnvRef env, out JavaVMRef jvm); +internal delegate JResult DestroyVirtualMachineDelegate(JavaVMRef vm); +internal delegate JResult AttachCurrentThreadDelegate(JavaVMRef vm, out JEnvRef env, in JavaVMAttachArgs args); +internal delegate JResult DetachCurrentThreadDelegate(JavaVMRef vm); +internal delegate JResult GetEnvDelegate(JavaVMRef vm, out JEnvRef env, Int32 version); +internal delegate JResult AttachCurrentThreadAsDaemonDelegate(JavaVMRef vm, out JEnvRef env, in JavaVMAttachArgs args); + +internal delegate JResult GetCreatedVirtualMachinesDelegate(ValPtr buffer0, Int32 bufferLength, + out Int32 totalVms); + +internal delegate JStringLocalRef NewStringDelegate(JEnvRef env, ReadOnlyValPtr chars0, Int32 length); +internal delegate Int32 GetStringLengthDelegate(JEnvRef env, JStringLocalRef jString); + +internal delegate ReadOnlyValPtr + GetStringCharsDelegate(JEnvRef env, JStringLocalRef jString, out JBoolean isCopy); + +internal delegate void ReleaseStringCharsDelegate(JEnvRef env, JStringLocalRef jString, ReadOnlyValPtr chars0); +internal delegate JStringLocalRef NewStringUtfDelegate(JEnvRef env, ReadOnlyValPtr utf8Chars0); +internal delegate Int32 GetStringUtfLengthDelegate(JEnvRef env, JStringLocalRef jString); + +internal delegate ReadOnlyValPtr GetStringUtfCharsDelegate(JEnvRef env, JStringLocalRef jString, + out JBoolean isCopy); + +internal delegate void ReleaseStringUtfCharsDelegate(JEnvRef env, JStringLocalRef jString, + ReadOnlyValPtr utf8Chars0); + +internal delegate void GetStringRegionDelegate(JEnvRef env, JStringLocalRef jString, Int32 startIndex, Int32 length, + ValPtr buffer0); + +internal delegate void GetStringUtfRegionDelegate(JEnvRef env, JStringLocalRef jString, Int32 startIndex, Int32 length, + ValPtr buffer0); + +internal delegate ReadOnlyValPtr GetStringCriticalDelegate(JEnvRef env, JStringLocalRef jString, + out JBoolean isCopy); + +internal delegate void ReleaseStringCriticalDelegate(JEnvRef env, JStringLocalRef jString, ReadOnlyValPtr chars0); + +internal delegate JObjectLocalRef CallStaticObjectMethodADelegate(JEnvRef env, JClassLocalRef jClass, JMethodId jMethod, + ReadOnlyValPtr args0); + +internal delegate JBoolean CallStaticBooleanMethodADelegate(JEnvRef env, JClassLocalRef jClass, JMethodId jMethod, + ReadOnlyValPtr args0); + +internal delegate JByte CallStaticByteMethodADelegate(JEnvRef env, JClassLocalRef jClass, JMethodId jMethod, + ReadOnlyValPtr args0); + +internal delegate JChar CallStaticCharMethodADelegate(JEnvRef env, JClassLocalRef jClass, JMethodId jMethod, + ReadOnlyValPtr args0); + +internal delegate JShort CallStaticShortMethodADelegate(JEnvRef env, JClassLocalRef jClass, JMethodId jMethod, + ReadOnlyValPtr args0); + +internal delegate JInt CallStaticIntMethodADelegate(JEnvRef env, JClassLocalRef jClass, JMethodId jMethod, + ReadOnlyValPtr args0); + +internal delegate JLong CallStaticLongMethodADelegate(JEnvRef env, JClassLocalRef jClass, JMethodId jMethod, + ReadOnlyValPtr args0); + +internal delegate JFloat CallStaticFloatMethodADelegate(JEnvRef env, JClassLocalRef jClass, JMethodId jMethod, + ReadOnlyValPtr args0); + +internal delegate JDouble CallStaticDoubleMethodADelegate(JEnvRef env, JClassLocalRef jClass, JMethodId jMethod, + ReadOnlyValPtr args0); + +internal delegate void CallStaticVoidMethodADelegate(JEnvRef env, JClassLocalRef jClass, JMethodId jMethod, + ReadOnlyValPtr args0); + +internal delegate JObjectLocalRef GetStaticObjectFieldDelegate(JEnvRef env, JClassLocalRef jClass, JFieldId jField); +internal delegate JBoolean GetStaticBooleanFieldDelegate(JEnvRef env, JClassLocalRef jClass, JFieldId jField); +internal delegate JByte GetStaticByteFieldDelegate(JEnvRef env, JClassLocalRef jClass, JFieldId jField); +internal delegate JChar GetStaticCharFieldDelegate(JEnvRef env, JClassLocalRef jClass, JFieldId jField); +internal delegate JShort GetStaticShortFieldDelegate(JEnvRef env, JClassLocalRef jClass, JFieldId jField); +internal delegate JInt GetStaticIntFieldDelegate(JEnvRef env, JClassLocalRef jClass, JFieldId jField); +internal delegate JLong GetStaticLongFieldDelegate(JEnvRef env, JClassLocalRef jClass, JFieldId jField); +internal delegate JFloat GetStaticFloatFieldDelegate(JEnvRef env, JClassLocalRef jClass, JFieldId jField); +internal delegate JDouble GetStaticDoubleFieldDelegate(JEnvRef env, JClassLocalRef jClass, JFieldId jField); + +internal delegate void SetStaticObjectFieldDelegate(JEnvRef env, JClassLocalRef jClass, JFieldId jField, + JObjectLocalRef value); + +internal delegate void SetStaticBooleanFieldDelegate(JEnvRef env, JClassLocalRef jClass, JFieldId jField, + JBoolean value); + +internal delegate void SetStaticByteFieldDelegate(JEnvRef env, JClassLocalRef jClass, JFieldId jField, JByte value); +internal delegate void SetStaticCharFieldDelegate(JEnvRef env, JClassLocalRef jClass, JFieldId jField, JChar value); +internal delegate void SetStaticShortFieldDelegate(JEnvRef env, JClassLocalRef jClass, JFieldId jField, JShort value); +internal delegate void SetStaticIntFieldDelegate(JEnvRef env, JClassLocalRef jClass, JFieldId jField, JInt value); +internal delegate void SetStaticLongFieldDelegate(JEnvRef env, JClassLocalRef jClass, JFieldId jField, JLong value); +internal delegate void SetStaticFloatFieldDelegate(JEnvRef env, JClassLocalRef jClass, JFieldId jField, JFloat value); +internal delegate void SetStaticDoubleFieldDelegate(JEnvRef env, JClassLocalRef jClass, JFieldId jField, JDouble value); +internal delegate JMethodId FromReflectedMethodDelegate(JEnvRef env, JObjectLocalRef method); +internal delegate JFieldId FromReflectedFieldDelegate(JEnvRef env, JObjectLocalRef field); +internal delegate JResult PushLocalFrameDelegate(JEnvRef env, Int32 capacity); +internal delegate JObjectLocalRef PopLocalFrameDelegate(JEnvRef env, JObjectLocalRef result); +internal delegate JGlobalRef NewGlobalRefDelegate(JEnvRef env, JObjectLocalRef localRef); +internal delegate void DeleteGlobalRefDelegate(JEnvRef env, JGlobalRef globalRef); +internal delegate void DeleteLocalRefDelegate(JEnvRef env, JObjectLocalRef localRef); +internal delegate JBoolean IsSameObjectDelegate(JEnvRef env, JObjectLocalRef obj1, JObjectLocalRef obj2); +internal delegate JObjectLocalRef NewLocalRefDelegate(JEnvRef env, JObjectLocalRef objRef); +internal delegate JResult EnsureLocalCapacityDelegate(JEnvRef env, Int32 capacity); +internal delegate JWeakRef NewWeakGlobalRefDelegate(JEnvRef env, JObjectLocalRef obj); +internal delegate void DeleteWeakGlobalRefDelegate(JEnvRef env, JWeakRef jWeak); +internal delegate JReferenceType GetObjectRefTypeDelegate(JEnvRef env, JObjectLocalRef obj); + +internal delegate JObjectLocalRef CallNonVirtualObjectMethodADelegate(JEnvRef env, JObjectLocalRef obj, + JClassLocalRef jClass, JMethodId jMethod, ReadOnlyValPtr args0); + +internal delegate JBoolean CallNonVirtualBooleanMethodADelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jClass, + JMethodId jMethod, ReadOnlyValPtr args0); + +internal delegate JByte CallNonVirtualByteMethodADelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jClass, + JMethodId jMethod, ReadOnlyValPtr args0); + +internal delegate JChar CallNonVirtualCharMethodADelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jClass, + JMethodId jMethod, ReadOnlyValPtr args0); + +internal delegate JShort CallNonVirtualShortMethodADelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jClass, + JMethodId jMethod, ReadOnlyValPtr args0); + +internal delegate JInt CallNonVirtualIntMethodADelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jClass, + JMethodId jMethod, ReadOnlyValPtr args0); + +internal delegate JLong CallNonVirtualLongMethodADelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jClass, + JMethodId jMethod, ReadOnlyValPtr args0); + +internal delegate JFloat CallNonVirtualFloatMethodADelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jClass, + JMethodId jMethod, ReadOnlyValPtr args0); + +internal delegate JDouble CallNonVirtualDoubleMethodADelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jClass, + JMethodId jMethod, ReadOnlyValPtr args0); + +internal delegate void CallNonVirtualVoidMethodADelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jClass, + JMethodId jMethod, ReadOnlyValPtr args0); + +internal delegate JObjectLocalRef CallObjectMethodADelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, + ReadOnlyValPtr args0); + +internal delegate JBoolean CallBooleanMethodADelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, + ReadOnlyValPtr args0); + +internal delegate JByte CallByteMethodADelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, + ReadOnlyValPtr args0); + +internal delegate JChar CallCharMethodADelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, + ReadOnlyValPtr args0); + +internal delegate JShort CallShortMethodADelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, + ReadOnlyValPtr args0); + +internal delegate JInt CallIntMethodADelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, + ReadOnlyValPtr args0); + +internal delegate JLong CallLongMethodADelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, + ReadOnlyValPtr args0); + +internal delegate JFloat CallFloatMethodADelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, + ReadOnlyValPtr args0); + +internal delegate JDouble CallDoubleMethodADelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, + ReadOnlyValPtr args0); + +internal delegate void CallVoidMethodADelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, + ReadOnlyValPtr args0); + +internal delegate JObjectLocalRef GetObjectFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField); +internal delegate JBoolean GetBooleanFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField); +internal delegate JByte GetByteFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField); +internal delegate JChar GetCharFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField); +internal delegate JShort GetShortFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField); +internal delegate JInt GetIntFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField); +internal delegate JLong GetLongFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField); +internal delegate JFloat GetFloatFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField); +internal delegate JDouble GetDoubleFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField); +internal delegate void SetObjectFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField, JObjectLocalRef value); +internal delegate void SetBooleanFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField, JBoolean value); +internal delegate void SetByteFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField, JByte value); +internal delegate void SetCharFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField, JChar value); +internal delegate void SetShortFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField, JShort value); +internal delegate void SetIntFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField, JInt value); +internal delegate void SetLongFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField, JLong value); +internal delegate void SetFloatFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField, JFloat value); +internal delegate void SetDoubleFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField, JDouble value); +internal delegate JResult ThrowDelegate(JEnvRef env, JThrowableLocalRef obj); +internal delegate JResult ThrowNewDelegate(JEnvRef env, JClassLocalRef jClass, ReadOnlyValPtr messageChars0); +internal delegate JThrowableLocalRef ExceptionOccurredDelegate(JEnvRef env); +internal delegate void ExceptionDescribeDelegate(JEnvRef env); +internal delegate void ExceptionClearDelegate(JEnvRef env); +internal delegate void FatalErrorDelegate(JEnvRef env, ReadOnlyValPtr messageChars0); +internal delegate JBoolean ExceptionCheckDelegate(JEnvRef env); +internal delegate JObjectLocalRef NewDirectByteBufferDelegate(JEnvRef env, IntPtr address, Int64 capacity); +internal delegate IntPtr GetDirectBufferAddressDelegate(JEnvRef env, JObjectLocalRef buffObj); +internal delegate Int64 GetDirectBufferCapacityDelegate(JEnvRef env, JObjectLocalRef buffObj); + +internal delegate JClassLocalRef DefineClassDelegate(JEnvRef env, ReadOnlyValPtr nameChars0, + JObjectLocalRef loader, IntPtr binaryData, Int32 len); + +internal delegate JClassLocalRef FindClassDelegate(JEnvRef env, ReadOnlyValPtr nameChars0); + +internal delegate JObjectLocalRef ToReflectedMethodDelegate(JEnvRef env, JClassLocalRef jClass, JMethodId methodId, + JBoolean isStatic); + +internal delegate JClassLocalRef GetSuperclassDelegate(JEnvRef env, JClassLocalRef sub); +internal delegate JBoolean IsAssignableFromDelegate(JEnvRef env, JClassLocalRef sub, JClassLocalRef sup); +internal delegate JClassLocalRef GetObjectClassDelegate(JEnvRef env, JObjectLocalRef obj); +internal delegate JBoolean IsInstanceOfDelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jClass); + +internal delegate JObjectLocalRef ToReflectedFieldDelegate(JEnvRef env, JClassLocalRef jClass, JFieldId fieldId, + JBoolean isStatic); + +internal delegate JMethodId GetMethodIdDelegate(JEnvRef env, JClassLocalRef jClass, ReadOnlyValPtr nameChars0, + ReadOnlyValPtr signatureChars0); + +internal delegate JFieldId GetFieldIdDelegate(JEnvRef env, JClassLocalRef jClass, ReadOnlyValPtr nameChars0, + ReadOnlyValPtr signatureChars0); + +internal delegate JMethodId GetStaticMethodIdDelegate(JEnvRef env, JClassLocalRef jClass, + ReadOnlyValPtr nameChars0, ReadOnlyValPtr signatureChars0); + +internal delegate JFieldId GetStaticFieldIdDelegate(JEnvRef env, JClassLocalRef jClass, ReadOnlyValPtr nameChars0, + ReadOnlyValPtr signatureChars0); + +internal delegate Int32 GetArrayLengthDelegate(JEnvRef env, JArrayLocalRef array); + +internal delegate JArrayLocalRef NewObjectArrayDelegate(JEnvRef env, Int32 length, JClassLocalRef jClass, + JObjectLocalRef init); + +internal delegate JObjectLocalRef GetObjectArrayElementDelegate(JEnvRef env, JArrayLocalRef arrayRef, Int32 index); + +internal delegate void SetObjectArrayElementDelegate(JEnvRef env, JArrayLocalRef arrayRef, Int32 index, + JObjectLocalRef obj); + +internal delegate JArrayLocalRef NewBooleanArrayDelegate(JEnvRef env, Int32 length); +internal delegate JArrayLocalRef NewByteArrayDelegate(JEnvRef env, Int32 length); +internal delegate JArrayLocalRef NewCharArrayDelegate(JEnvRef env, Int32 length); +internal delegate JArrayLocalRef NewShortArrayDelegate(JEnvRef env, Int32 length); +internal delegate JArrayLocalRef NewIntArrayDelegate(JEnvRef env, Int32 length); +internal delegate JArrayLocalRef NewLongArrayDelegate(JEnvRef env, Int32 length); +internal delegate JArrayLocalRef NewFloatArrayDelegate(JEnvRef env, Int32 length); +internal delegate JArrayLocalRef NewDoubleArrayDelegate(JEnvRef env, Int32 length); + +internal delegate ValPtr GetBooleanArrayElementsDelegate(JEnvRef env, JArrayLocalRef arrayRef, + out JBoolean isCopy); + +internal delegate ValPtr GetByteArrayElementsDelegate(JEnvRef env, JArrayLocalRef arrayRef, out JBoolean isCopy); +internal delegate ValPtr GetCharArrayElementsDelegate(JEnvRef env, JArrayLocalRef arrayRef, out JBoolean isCopy); + +internal delegate ValPtr GetShortArrayElementsDelegate(JEnvRef env, JArrayLocalRef arrayRef, + out JBoolean isCopy); + +internal delegate ValPtr GetIntArrayElementsDelegate(JEnvRef env, JArrayLocalRef arrayRef, out JBoolean isCopy); +internal delegate ValPtr GetLongArrayElementsDelegate(JEnvRef env, JArrayLocalRef arrayRef, out JBoolean isCopy); + +internal delegate ValPtr GetFloatArrayElementsDelegate(JEnvRef env, JArrayLocalRef arrayRef, + out JBoolean isCopy); + +internal delegate ValPtr GetDoubleArrayElementsDelegate(JEnvRef env, JArrayLocalRef arrayRef, + out JBoolean isCopy); + +internal delegate void ReleaseBooleanArrayElementsDelegate(JEnvRef env, JArrayLocalRef arrayRef, + ReadOnlyValPtr elements0, JReleaseMode mode); + +internal delegate void ReleaseByteArrayElementsDelegate(JEnvRef env, JArrayLocalRef arrayRef, + ReadOnlyValPtr elements0, JReleaseMode mode); + +internal delegate void ReleaseCharArrayElementsDelegate(JEnvRef env, JArrayLocalRef arrayRef, + ReadOnlyValPtr elements0, JReleaseMode mode); + +internal delegate void ReleaseShortArrayElementsDelegate(JEnvRef env, JArrayLocalRef arrayRef, + ReadOnlyValPtr elements0, JReleaseMode mode); + +internal delegate void ReleaseIntArrayElementsDelegate(JEnvRef env, JArrayLocalRef arrayRef, + ReadOnlyValPtr elements0, JReleaseMode mode); + +internal delegate void ReleaseLongArrayElementsDelegate(JEnvRef env, JArrayLocalRef arrayRef, + ReadOnlyValPtr elements0, JReleaseMode mode); + +internal delegate void ReleaseFloatArrayElementsDelegate(JEnvRef env, JArrayLocalRef arrayRef, + ReadOnlyValPtr elements0, JReleaseMode mode); + +internal delegate void ReleaseDoubleArrayElementsDelegate(JEnvRef env, JArrayLocalRef arrayRef, + ReadOnlyValPtr elements0, JReleaseMode mode); + +internal delegate void GetBooleanArrayRegionDelegate(JEnvRef env, JArrayLocalRef arrayRef, Int32 startIndex, + Int32 length, ValPtr buffer0); + +internal delegate void GetByteArrayRegionDelegate(JEnvRef env, JArrayLocalRef arrayRef, Int32 startIndex, Int32 length, + ValPtr buffer0); + +internal delegate void GetCharArrayRegionDelegate(JEnvRef env, JArrayLocalRef arrayRef, Int32 startIndex, Int32 length, + ValPtr buffer0); + +internal delegate void GetShortArrayRegionDelegate(JEnvRef env, JArrayLocalRef arrayRef, Int32 startIndex, Int32 length, + ValPtr buffer0); + +internal delegate void GetIntArrayRegionDelegate(JEnvRef env, JArrayLocalRef arrayRef, Int32 startIndex, Int32 length, + ValPtr buffer0); + +internal delegate void GetLongArrayRegionDelegate(JEnvRef env, JArrayLocalRef arrayRef, Int32 startIndex, Int32 length, + ValPtr buffer0); + +internal delegate void GetFloatArrayRegionDelegate(JEnvRef env, JArrayLocalRef arrayRef, Int32 startIndex, Int32 length, + ValPtr buffer0); + +internal delegate void GetDoubleArrayRegionDelegate(JEnvRef env, JArrayLocalRef arrayRef, Int32 startIndex, + Int32 length, ValPtr buffer0); + +internal delegate void SetBooleanArrayRegionDelegate(JEnvRef env, JArrayLocalRef arrayRef, Int32 startIndex, + Int32 length, ReadOnlyValPtr buffer0); + +internal delegate void SetByteArrayRegionDelegate(JEnvRef env, JArrayLocalRef arrayRef, Int32 startIndex, Int32 length, + ReadOnlyValPtr buffer0); + +internal delegate void SetCharArrayRegionDelegate(JEnvRef env, JArrayLocalRef arrayRef, Int32 startIndex, Int32 length, + ReadOnlyValPtr buffer0); + +internal delegate void SetShortArrayRegionDelegate(JEnvRef env, JArrayLocalRef arrayRef, Int32 startIndex, Int32 length, + ReadOnlyValPtr buffer0); + +internal delegate void SetIntArrayRegionDelegate(JEnvRef env, JArrayLocalRef arrayRef, Int32 startIndex, Int32 length, + ReadOnlyValPtr buffer0); + +internal delegate void SetLongArrayRegionDelegate(JEnvRef env, JArrayLocalRef arrayRef, Int32 startIndex, Int32 length, + ReadOnlyValPtr buffer0); + +internal delegate void SetFloatArrayRegionDelegate(JEnvRef env, JArrayLocalRef arrayRef, Int32 startIndex, Int32 length, + ReadOnlyValPtr buffer0); + +internal delegate void SetDoubleArrayRegionDelegate(JEnvRef env, JArrayLocalRef arrayRef, Int32 startIndex, + Int32 length, ReadOnlyValPtr buffer0); + +internal delegate ValPtr GetPrimitiveArrayCriticalDelegate(JEnvRef env, JArrayLocalRef arrayRef, + out JBoolean isCopy); + +internal delegate void ReleasePrimitiveArrayCriticalDelegate(JEnvRef env, JArrayLocalRef arrayRef, + ValPtr elements, JReleaseMode mode); + +internal delegate JObjectLocalRef NewObjectADelegate(JEnvRef env, JClassLocalRef jClass, JMethodId jMethod, + ReadOnlyValPtr arg0); diff --git a/src/LibRyujinx/Jni/Identifiers/JFieldId.cs b/src/LibRyujinx/Android/Jni/Identifiers/JFieldId.cs similarity index 95% rename from src/LibRyujinx/Jni/Identifiers/JFieldId.cs rename to src/LibRyujinx/Android/Jni/Identifiers/JFieldId.cs index aa35f9074..1a776943c 100644 --- a/src/LibRyujinx/Jni/Identifiers/JFieldId.cs +++ b/src/LibRyujinx/Android/Jni/Identifiers/JFieldId.cs @@ -1,5 +1,5 @@ -using System.Diagnostics.CodeAnalysis; using System; +using System.Diagnostics.CodeAnalysis; namespace LibRyujinx.Jni.Identifiers { diff --git a/src/LibRyujinx/Jni/Identifiers/JMethodId.cs b/src/LibRyujinx/Android/Jni/Identifiers/JMethodId.cs similarity index 95% rename from src/LibRyujinx/Jni/Identifiers/JMethodId.cs rename to src/LibRyujinx/Android/Jni/Identifiers/JMethodId.cs index b8fee13c3..657ffce54 100644 --- a/src/LibRyujinx/Jni/Identifiers/JMethodId.cs +++ b/src/LibRyujinx/Android/Jni/Identifiers/JMethodId.cs @@ -1,5 +1,5 @@ -using System.Diagnostics.CodeAnalysis; using System; +using System.Diagnostics.CodeAnalysis; namespace LibRyujinx.Jni.Identifiers { diff --git a/src/LibRyujinx/Jni/JReferenceType.cs b/src/LibRyujinx/Android/Jni/JReferenceType.cs similarity index 91% rename from src/LibRyujinx/Jni/JReferenceType.cs rename to src/LibRyujinx/Android/Jni/JReferenceType.cs index 47c9f2aef..bd5c64c89 100644 --- a/src/LibRyujinx/Jni/JReferenceType.cs +++ b/src/LibRyujinx/Android/Jni/JReferenceType.cs @@ -1,4 +1,4 @@ -using System; +using System; namespace LibRyujinx.Jni { diff --git a/src/LibRyujinx/Jni/JReleaseMode.cs b/src/LibRyujinx/Android/Jni/JReleaseMode.cs similarity index 88% rename from src/LibRyujinx/Jni/JReleaseMode.cs rename to src/LibRyujinx/Android/Jni/JReleaseMode.cs index 4a86b5a0b..c273a28c5 100644 --- a/src/LibRyujinx/Jni/JReleaseMode.cs +++ b/src/LibRyujinx/Android/Jni/JReleaseMode.cs @@ -1,4 +1,5 @@ -using System; +using System; + namespace LibRyujinx.Jni { public enum JReleaseMode : Int32 diff --git a/src/LibRyujinx/Jni/JResult.cs b/src/LibRyujinx/Android/Jni/JResult.cs similarity index 93% rename from src/LibRyujinx/Jni/JResult.cs rename to src/LibRyujinx/Android/Jni/JResult.cs index d3cdddff9..bcfd470af 100644 --- a/src/LibRyujinx/Jni/JResult.cs +++ b/src/LibRyujinx/Android/Jni/JResult.cs @@ -1,4 +1,5 @@ -using System; +using System; + namespace LibRyujinx.Jni { public enum JResult : Int32 diff --git a/src/LibRyujinx/Android/Jni/JniHelper.cs b/src/LibRyujinx/Android/Jni/JniHelper.cs new file mode 100644 index 000000000..8838491cd --- /dev/null +++ b/src/LibRyujinx/Android/Jni/JniHelper.cs @@ -0,0 +1,234 @@ +using LibRyujinx.Jni.Identifiers; +using LibRyujinx.Jni.Pointers; +using LibRyujinx.Jni.Primitives; +using LibRyujinx.Jni.References; +using LibRyujinx.Jni.Values; +using System; + +using Rxmxnx.PInvoke; + +namespace LibRyujinx.Jni; + +internal static class JniHelper +{ + public const Int32 JniVersion = 0x00010006; //JNI_VERSION_1_6; + + public static JEnvRef? Attach(JavaVMRef javaVm, IReadOnlyFixedMemory threadName, out Boolean newAttach) + { + ref JavaVMValue value = ref javaVm.VirtualMachine; + ref JInvokeInterface jInvoke = ref value.Functions; + + IntPtr getEnvPtr = jInvoke.GetEnvPointer; + GetEnvDelegate getEnv = getEnvPtr.GetUnsafeDelegate()!; + + if (getEnv(javaVm, out JEnvRef jEnv, JniHelper.JniVersion) == JResult.Ok) + { + newAttach = false; + return jEnv; + } + + JavaVMAttachArgs args = new() { Version = JniHelper.JniVersion, Name = threadName.ValuePointer, }; + IntPtr attachCurrentThreadPtr = jInvoke.AttachCurrentThreadPointer; + AttachCurrentThreadDelegate attachCurrentThread = + attachCurrentThreadPtr.GetUnsafeDelegate()!; + + newAttach = true; + return attachCurrentThread(javaVm, out jEnv, in args) == JResult.Ok ? jEnv : null; + } + public static JEnvRef? AttachDaemon(JavaVMRef javaVm, IReadOnlyFixedMemory daemonName) + { + ref JavaVMValue value = ref javaVm.VirtualMachine; + ref JInvokeInterface jInvoke = ref value.Functions; + + JavaVMAttachArgs args = new() { Version = JniHelper.JniVersion, Name = daemonName.ValuePointer, }; + IntPtr attachCurrentThreadAsDaemonPtr = jInvoke.AttachCurrentThreadAsDaemonPointer; + AttachCurrentThreadAsDaemonDelegate attachCurrentThreadAsDaemon = + attachCurrentThreadAsDaemonPtr.GetUnsafeDelegate()!; + + return attachCurrentThreadAsDaemon(javaVm, out JEnvRef jEnv, in args) == JResult.Ok ? jEnv : null; + } + public static void Detach(JavaVMRef javaVm) + { + ref JavaVMValue value = ref javaVm.VirtualMachine; + ref JInvokeInterface jInvoke = ref value.Functions; + + IntPtr detachCurrentThreadPtr = jInvoke.DetachCurrentThreadPointer; + DetachCurrentThreadDelegate detachCurrentThread = + detachCurrentThreadPtr.GetUnsafeDelegate()!; + + detachCurrentThread(javaVm); + } + public static JGlobalRef? GetGlobalClass(JEnvRef jEnv, IReadOnlyFixedMemory className) + { + ref readonly JEnvValue value = ref jEnv.Environment; + ref JNativeInterface jInterface = ref value.Functions; + + IntPtr findClassPtr = jInterface.FindClassPointer; + FindClassDelegate findClass = findClassPtr.GetUnsafeDelegate()!; + JClassLocalRef jClass = findClass(jEnv, className.ValuePointer); + + if (JniHelper.ExceptionCheck(jEnv)) return default; + + IntPtr newGlobalRefPtr = jInterface.NewGlobalRefPointer; + NewGlobalRefDelegate newGlobalRef = newGlobalRefPtr.GetUnsafeDelegate()!; + + JGlobalRef jGlobal = newGlobalRef(jEnv, (JObjectLocalRef)jClass); + JniHelper.RemoveLocal(jEnv, (JObjectLocalRef)jClass); + + return !JniHelper.ExceptionCheck(jEnv) ? jGlobal : null; + } + public static void RemoveLocal(JEnvRef jEnv, JObjectLocalRef jObject) + { + ref readonly JEnvValue value = ref jEnv.Environment; + ref JNativeInterface jInterface = ref value.Functions; + + IntPtr deleteLocalRefPtr = jInterface.DeleteLocalRefPointer; + DeleteLocalRefDelegate deleteLocalRef = deleteLocalRefPtr.GetUnsafeDelegate()!; + + deleteLocalRef(jEnv, jObject); + } + public static void RemoveGlobal(JEnvRef jEnv, JGlobalRef jObject) + { + ref readonly JEnvValue value = ref jEnv.Environment; + ref JNativeInterface jInterface = ref value.Functions; + + IntPtr deleteGlobalRefPtr = jInterface.DeleteGlobalRefPointer; + DeleteGlobalRefDelegate deleteGlobalRef = deleteGlobalRefPtr.GetUnsafeDelegate()!; + + deleteGlobalRef(jEnv, jObject); + } + public static void RemoveWeakGlobal(JEnvRef jEnv, JWeakRef jObject) + { + ref readonly JEnvValue value = ref jEnv.Environment; + ref JNativeInterface jInterface = ref value.Functions; + + IntPtr deleteWeakGlobalRefPtr = jInterface.DeleteWeakGlobalRefPointer; + DeleteWeakGlobalRefDelegate deleteWeakGlobalRef = + deleteWeakGlobalRefPtr.GetUnsafeDelegate()!; + + deleteWeakGlobalRef(jEnv, jObject); + } + public static JStringLocalRef? CreateString(JEnvRef jEnv, String textValue) + { + ref readonly JEnvValue value = ref jEnv.Environment; + ref JNativeInterface jInterface = ref value.Functions; + + IntPtr newStringPtr = jInterface.NewStringPointer; + NewStringDelegate newString = newStringPtr.GetUnsafeDelegate()!; + using IReadOnlyFixedMemory.IDisposable ctx = textValue.AsMemory().GetFixedContext(); + JStringLocalRef jString = newString(jEnv, ctx.ValuePointer, ctx.Values.Length); + + return !JniHelper.ExceptionCheck(jEnv) ? jString : null; + } + public static JWeakRef? CreateWeakGlobal(JEnvRef jEnv, JObjectLocalRef jObject) + { + ref readonly JEnvValue value = ref jEnv.Environment; + ref JNativeInterface jInterface = ref value.Functions; + + IntPtr newWeakGlobalRefPtr = jInterface.NewWeakGlobalRefPointer; + NewWeakGlobalRefDelegate newWeakGlobalRef = newWeakGlobalRefPtr.GetUnsafeDelegate()!; + JWeakRef jWeak = newWeakGlobalRef(jEnv, jObject); + + return !JniHelper.ExceptionCheck(jEnv) ? jWeak : null; + } + private static Boolean ExceptionCheck(JEnvRef jEnv) + { + ref readonly JEnvValue value = ref jEnv.Environment; + ref JNativeInterface jInterface = ref value.Functions; + + IntPtr exceptionCheckPtr = jInterface.ExceptionCheckPointer; + ExceptionCheckDelegate exceptionCheck = exceptionCheckPtr.GetUnsafeDelegate()!; + + if (!exceptionCheck(jEnv)) return false; + IntPtr exceptionDescribePtr = jInterface.ExceptionDescribePointer; + IntPtr exceptionClearPtr = jInterface.ExceptionClearPointer; + + ExceptionDescribeDelegate exceptionDescribe = + exceptionDescribePtr.GetUnsafeDelegate()!; + ExceptionClearDelegate exceptionClear = exceptionClearPtr.GetUnsafeDelegate()!; + + exceptionDescribe(jEnv); + exceptionClear(jEnv); + return true; + } + public static JavaVMRef? GetVirtualMachine(JEnvRef jEnv) + { + ref readonly JEnvValue value = ref jEnv.Environment; + ref JNativeInterface jInterface = ref value.Functions; + + IntPtr getJavaVmPtr = jInterface.GetJavaVMPointer; + GetVirtualMachineDelegate getJavaVm = getJavaVmPtr.GetUnsafeDelegate()!; + return getJavaVm(jEnv, out JavaVMRef javaVm) == JResult.Ok ? javaVm : null; + } + public static Boolean? IsValidGlobalWeak(JEnvRef jEnv, JWeakRef jWeak) + { + ref readonly JEnvValue value = ref jEnv.Environment; + ref JNativeInterface jInterface = ref value.Functions; + + IntPtr isSameObjectPtr = jInterface.IsSameObjectPointer; + IsSameObjectDelegate isSameObject = isSameObjectPtr.GetUnsafeDelegate()!; + JBoolean result = isSameObject(jEnv, (JObjectLocalRef)jWeak, default); + return !JniHelper.ExceptionCheck(jEnv) ? !result : null; + } + public static JMethodId? GetMethodId(JEnvRef jEnv, JClassLocalRef jClass, IReadOnlyFixedMemory methodName, + IReadOnlyFixedMemory descriptor) + { + ref readonly JEnvValue value = ref jEnv.Environment; + ref JNativeInterface jInterface = ref value.Functions; + + IntPtr getMethodIdPtr = jInterface.GetMethodIdPointer; + GetMethodIdDelegate getMethodId = getMethodIdPtr.GetUnsafeDelegate()!; + JMethodId methodId = getMethodId(jEnv, jClass, methodName.ValuePointer, descriptor.ValuePointer); + return !JniHelper.ExceptionCheck(jEnv) ? methodId : null; + } + public static JMethodId? GetStaticMethodId(JEnvRef jEnv, JClassLocalRef jClass, + IReadOnlyFixedMemory methodName, IReadOnlyFixedMemory descriptor) + { + ref readonly JEnvValue value = ref jEnv.Environment; + ref JNativeInterface jInterface = ref value.Functions; + + IntPtr getStaticMethodIdPtr = jInterface.GetStaticMethodIdPointer; + GetStaticMethodIdDelegate getStaticMethodId = + getStaticMethodIdPtr.GetUnsafeDelegate()!; + JMethodId jMethodId = getStaticMethodId(jEnv, jClass, methodName.ValuePointer, descriptor.ValuePointer); + return !JniHelper.ExceptionCheck(jEnv) ? jMethodId : null; + } + public static void CallStaticVoidMethod(JEnvRef jEnv, JClassLocalRef jClass, JMethodId jMethodId, + params JValue[] args) + { + ref readonly JEnvValue value = ref jEnv.Environment; + ref JNativeInterface jInterface = ref value.Functions; + + IntPtr callStaticVoidMethodPtr = jInterface.CallStaticVoidMethodAPointer; + CallStaticVoidMethodADelegate callStaticVoidMethod = + callStaticVoidMethodPtr.GetUnsafeDelegate()!; + + using IReadOnlyFixedMemory.IDisposable fArgs = args.AsMemory().GetFixedContext(); + callStaticVoidMethod(jEnv, jClass, jMethodId, fArgs.ValuePointer); + } + public static JObjectLocalRef? CallStaticObjectMethod(JEnvRef jEnv, JClassLocalRef jClass, JMethodId jMethodId, + params JValue[] args) + { + ref readonly JEnvValue value = ref jEnv.Environment; + ref JNativeInterface jInterface = ref value.Functions; + + IntPtr callStaticObjectMethodPtr = jInterface.CallStaticObjectMethodAPointer; + CallStaticObjectMethodADelegate callStaticObjectMethod = + callStaticObjectMethodPtr.GetUnsafeDelegate()!; + + using IReadOnlyFixedMemory.IDisposable fArgs = args.AsMemory().GetFixedContext(); + JObjectLocalRef jObject = callStaticObjectMethod(jEnv, jClass, jMethodId, fArgs.ValuePointer); + return !JniHelper.ExceptionCheck(jEnv) ? jObject : null; + } + public static void CallVoidMethod(JEnvRef jEnv, JObjectLocalRef jObject, JMethodId jMethodId, params JValue[] args) + { + ref readonly JEnvValue value = ref jEnv.Environment; + ref JNativeInterface jInterface = ref value.Functions; + + IntPtr callVoidMethodPtr = jInterface.CallVoidMethodAPointer; + CallVoidMethodADelegate callVoidMethod = callVoidMethodPtr.GetUnsafeDelegate()!; + + using IReadOnlyFixedMemory.IDisposable fArgs = args.AsMemory().GetFixedContext(); + callVoidMethod(jEnv, jObject, jMethodId, fArgs.ValuePointer); + } +} diff --git a/src/LibRyujinx/Jni/Pointers/JEnvRef.cs b/src/LibRyujinx/Android/Jni/Pointers/JEnvRef.cs similarity index 89% rename from src/LibRyujinx/Jni/Pointers/JEnvRef.cs rename to src/LibRyujinx/Android/Jni/Pointers/JEnvRef.cs index f58c25d5e..20b07ad30 100644 --- a/src/LibRyujinx/Jni/Pointers/JEnvRef.cs +++ b/src/LibRyujinx/Android/Jni/Pointers/JEnvRef.cs @@ -1,4 +1,4 @@ -using LibRyujinx.Jni.Values; +using LibRyujinx.Jni.Values; using Rxmxnx.PInvoke; using System; @@ -11,6 +11,11 @@ namespace LibRyujinx.Jni.Pointers private readonly IntPtr _value; #pragma warning restore 0649 + public JEnvRef(IntPtr val) + { + _value = val; + } + #region Operators public static Boolean operator ==(JEnvRef a, JEnvRef b) => a._value.Equals(b._value); public static Boolean operator !=(JEnvRef a, JEnvRef b) => !a._value.Equals(b._value); diff --git a/src/LibRyujinx/Android/Jni/Pointers/JavaVMRef.cs b/src/LibRyujinx/Android/Jni/Pointers/JavaVMRef.cs new file mode 100644 index 000000000..80fc468f8 --- /dev/null +++ b/src/LibRyujinx/Android/Jni/Pointers/JavaVMRef.cs @@ -0,0 +1,31 @@ +using LibRyujinx.Jni.Values; + +using Rxmxnx.PInvoke; +using System; + +namespace LibRyujinx.Jni.Pointers; + +public readonly struct JavaVMRef : IEquatable +{ +#pragma warning disable 0649 + private readonly IntPtr _value; +#pragma warning restore 0649 + + #region Operators + public static Boolean operator ==(JavaVMRef a, JavaVMRef b) => a._value.Equals(b._value); + public static Boolean operator !=(JavaVMRef a, JavaVMRef b) => !a._value.Equals(b._value); + #endregion + + #region Public Properties + internal readonly ref JavaVMValue VirtualMachine => ref this._value.GetUnsafeReference(); + #endregion + + #region Public Methods + public Boolean Equals(JavaVMRef other) => this._value.Equals(other._value); + #endregion + + #region Overrided Methods + public override Boolean Equals(Object obj) => obj is JavaVMRef other && this.Equals(other); + public override Int32 GetHashCode() => this._value.GetHashCode(); + #endregion +} diff --git a/src/LibRyujinx/Android/Jni/Primitives/JBoolean.cs b/src/LibRyujinx/Android/Jni/Primitives/JBoolean.cs new file mode 100644 index 000000000..5f1315592 --- /dev/null +++ b/src/LibRyujinx/Android/Jni/Primitives/JBoolean.cs @@ -0,0 +1,67 @@ +using Rxmxnx.PInvoke; +using System; + +namespace LibRyujinx.Jni.Primitives; + +public readonly struct JBoolean : IComparable, IEquatable +{ + internal static readonly Type Type = typeof(JBoolean); + private const Byte trueByte = 1; + private const Byte falseByte = 0; + + public static readonly CString Signature = (CString)"Z"; + + private readonly Byte _value; + private Boolean Value => this._value == JBoolean.trueByte; + + private JBoolean(Boolean value) => this._value = value ? JBoolean.trueByte : JBoolean.falseByte; + + #region Operators + public static implicit operator JBoolean(Boolean value) => new(value); + public static implicit operator Boolean(JBoolean jValue) => jValue._value == 1; + public static JBoolean operator !(JBoolean a) => new(!a.Value); + public static JBoolean operator |(JBoolean a, JBoolean b) => new(a.Value || b.Value); + public static JBoolean operator |(Boolean a, JBoolean b) => new(a || b.Value); + public static JBoolean operator |(JBoolean a, Boolean b) => new(a.Value || b); + public static JBoolean operator &(JBoolean a, JBoolean b) => new(a.Value && b.Value); + public static JBoolean operator &(Boolean a, JBoolean b) => new(a && b.Value); + public static JBoolean operator &(JBoolean a, Boolean b) => new(a.Value && b); + public static Boolean operator ==(JBoolean a, JBoolean b) => a._value.Equals(b._value); + public static Boolean operator ==(Boolean a, JBoolean b) => a.Equals(b._value); + public static Boolean operator ==(JBoolean a, Boolean b) => a._value.Equals(b); + public static Boolean operator !=(JBoolean a, JBoolean b) => !a._value.Equals(b._value); + public static Boolean operator !=(Boolean a, JBoolean b) => !a.Equals(b._value); + public static Boolean operator !=(JBoolean a, Boolean b) => !a._value.Equals(b); + public static Boolean operator >(JBoolean a, JBoolean b) => a._value.CompareTo(b._value) > 0; + public static Boolean operator >(Boolean a, JBoolean b) => a.CompareTo(b._value) > 0; + public static Boolean operator >(JBoolean a, Boolean b) => a._value.CompareTo(b) > 0; + public static Boolean operator <(JBoolean a, JBoolean b) => a._value.CompareTo(b._value) < 0; + public static Boolean operator <(Boolean a, JBoolean b) => a.CompareTo(b._value) < 0; + public static Boolean operator <(JBoolean a, Boolean b) => a._value.CompareTo(b) < 0; + public static Boolean operator >=(JBoolean a, JBoolean b) => a._value.CompareTo(b._value) > 0 || a.Equals(b._value); + public static Boolean operator >=(Boolean a, JBoolean b) => a.CompareTo(b._value) > 0 || a.Equals(b._value); + public static Boolean operator >=(JBoolean a, Boolean b) => a._value.CompareTo(b) > 0 || a._value.Equals(b); + public static Boolean operator <=(JBoolean a, JBoolean b) => a._value.CompareTo(b._value) < 0 || a.Equals(b._value); + public static Boolean operator <=(Boolean a, JBoolean b) => a.CompareTo(b._value) < 0 || a.Equals(b._value); + public static Boolean operator <=(JBoolean a, Boolean b) => a._value.CompareTo(b) < 0 || a._value.Equals(b); + #endregion + + #region Public Methods + public Int32 CompareTo(Boolean other) => this._value.CompareTo(other); + public Int32 CompareTo(JBoolean other) => this._value.CompareTo(other._value); + public Int32 CompareTo(Object obj) + => obj is JBoolean jvalue ? this.CompareTo(jvalue) : + obj is Boolean value ? this.CompareTo(value) : this._value.CompareTo(obj); + public Boolean Equals(Boolean other) => this._value.Equals(other); + public Boolean Equals(JBoolean other) => this._value.Equals(other._value); + public String ToString(IFormatProvider formatProvider) => this._value.ToString(formatProvider); + #endregion + + #region Overrided Methods + public override String ToString() => this._value.ToString(); + public override Boolean Equals(Object obj) + => obj is JBoolean jvalue ? this.Equals(jvalue) : + obj is Boolean value ? this.Equals(value) : this._value.Equals(obj); + public override Int32 GetHashCode() => this._value.GetHashCode(); + #endregion +} diff --git a/src/LibRyujinx/Jni/Primitives/JByte.cs b/src/LibRyujinx/Android/Jni/Primitives/JByte.cs similarity index 99% rename from src/LibRyujinx/Jni/Primitives/JByte.cs rename to src/LibRyujinx/Android/Jni/Primitives/JByte.cs index a5ed5b0a4..18ed5092e 100644 --- a/src/LibRyujinx/Jni/Primitives/JByte.cs +++ b/src/LibRyujinx/Android/Jni/Primitives/JByte.cs @@ -1,4 +1,4 @@ -using Rxmxnx.PInvoke; +using Rxmxnx.PInvoke; using System; namespace LibRyujinx.Jni.Primitives diff --git a/src/LibRyujinx/Jni/Primitives/JChar.cs b/src/LibRyujinx/Android/Jni/Primitives/JChar.cs similarity index 99% rename from src/LibRyujinx/Jni/Primitives/JChar.cs rename to src/LibRyujinx/Android/Jni/Primitives/JChar.cs index b2ba3782d..310acf400 100644 --- a/src/LibRyujinx/Jni/Primitives/JChar.cs +++ b/src/LibRyujinx/Android/Jni/Primitives/JChar.cs @@ -1,4 +1,4 @@ -using Rxmxnx.PInvoke; +using Rxmxnx.PInvoke; using System; namespace LibRyujinx.Jni.Primitives diff --git a/src/LibRyujinx/Jni/Primitives/JDouble.cs b/src/LibRyujinx/Android/Jni/Primitives/JDouble.cs similarity index 99% rename from src/LibRyujinx/Jni/Primitives/JDouble.cs rename to src/LibRyujinx/Android/Jni/Primitives/JDouble.cs index 94f05eb9a..5fe0c2b5a 100644 --- a/src/LibRyujinx/Jni/Primitives/JDouble.cs +++ b/src/LibRyujinx/Android/Jni/Primitives/JDouble.cs @@ -1,4 +1,4 @@ -using Rxmxnx.PInvoke; +using Rxmxnx.PInvoke; using System; namespace LibRyujinx.Jni.Primitives diff --git a/src/LibRyujinx/Jni/Primitives/JFloat.cs b/src/LibRyujinx/Android/Jni/Primitives/JFloat.cs similarity index 99% rename from src/LibRyujinx/Jni/Primitives/JFloat.cs rename to src/LibRyujinx/Android/Jni/Primitives/JFloat.cs index 52f833241..0cd81879d 100644 --- a/src/LibRyujinx/Jni/Primitives/JFloat.cs +++ b/src/LibRyujinx/Android/Jni/Primitives/JFloat.cs @@ -1,4 +1,4 @@ -using Rxmxnx.PInvoke; +using Rxmxnx.PInvoke; using System; namespace LibRyujinx.Jni.Primitives diff --git a/src/LibRyujinx/Jni/Primitives/JInt.cs b/src/LibRyujinx/Android/Jni/Primitives/JInt.cs similarity index 99% rename from src/LibRyujinx/Jni/Primitives/JInt.cs rename to src/LibRyujinx/Android/Jni/Primitives/JInt.cs index adf86a8d7..8dfcc783f 100644 --- a/src/LibRyujinx/Jni/Primitives/JInt.cs +++ b/src/LibRyujinx/Android/Jni/Primitives/JInt.cs @@ -1,4 +1,4 @@ -using Rxmxnx.PInvoke; +using Rxmxnx.PInvoke; using System; namespace LibRyujinx.Jni.Primitives diff --git a/src/LibRyujinx/Jni/Primitives/JLong.cs b/src/LibRyujinx/Android/Jni/Primitives/JLong.cs similarity index 99% rename from src/LibRyujinx/Jni/Primitives/JLong.cs rename to src/LibRyujinx/Android/Jni/Primitives/JLong.cs index a5bd6613a..d80883917 100644 --- a/src/LibRyujinx/Jni/Primitives/JLong.cs +++ b/src/LibRyujinx/Android/Jni/Primitives/JLong.cs @@ -1,4 +1,4 @@ -using Rxmxnx.PInvoke; +using Rxmxnx.PInvoke; using System; namespace LibRyujinx.Jni.Primitives diff --git a/src/LibRyujinx/Jni/Primitives/JShort.cs b/src/LibRyujinx/Android/Jni/Primitives/JShort.cs similarity index 99% rename from src/LibRyujinx/Jni/Primitives/JShort.cs rename to src/LibRyujinx/Android/Jni/Primitives/JShort.cs index 78650c2fe..de959a48b 100644 --- a/src/LibRyujinx/Jni/Primitives/JShort.cs +++ b/src/LibRyujinx/Android/Jni/Primitives/JShort.cs @@ -1,4 +1,4 @@ -using Rxmxnx.PInvoke; +using Rxmxnx.PInvoke; using System; namespace LibRyujinx.Jni.Primitives diff --git a/src/LibRyujinx/Android/Jni/References/JArrayLocalRef.cs b/src/LibRyujinx/Android/Jni/References/JArrayLocalRef.cs new file mode 100644 index 000000000..73e9ecd93 --- /dev/null +++ b/src/LibRyujinx/Android/Jni/References/JArrayLocalRef.cs @@ -0,0 +1,26 @@ +using System; +using System.Diagnostics.CodeAnalysis; + +namespace LibRyujinx.Jni.References; + +public readonly struct JArrayLocalRef : IEquatable +{ +#pragma warning disable 0649 + private readonly JObjectLocalRef _value; +#pragma warning restore 0649 + + #region Public Methods + public Boolean Equals(JArrayLocalRef other) => this._value.Equals(other._value); + #endregion + + #region Override Methods + public override Boolean Equals([NotNullWhen(true)] Object obj) => obj is JArrayLocalRef other && this.Equals(other); + public override Int32 GetHashCode() => this._value.GetHashCode(); + #endregion + + #region Operators + public static explicit operator JObjectLocalRef(JArrayLocalRef a) => a._value; + public static Boolean operator ==(JArrayLocalRef a, JArrayLocalRef b) => a.Equals(b); + public static Boolean operator !=(JArrayLocalRef a, JArrayLocalRef b) => !a.Equals(b); + #endregion +} diff --git a/src/LibRyujinx/Android/Jni/References/JClassLocalRef.cs b/src/LibRyujinx/Android/Jni/References/JClassLocalRef.cs new file mode 100644 index 000000000..4f7bab33a --- /dev/null +++ b/src/LibRyujinx/Android/Jni/References/JClassLocalRef.cs @@ -0,0 +1,29 @@ +using System; +using System.Diagnostics.CodeAnalysis; + +namespace LibRyujinx.Jni.References; + +public readonly struct JClassLocalRef : IEquatable +{ +#pragma warning disable 0649 + private readonly JObjectLocalRef _value; +#pragma warning restore 0649 + + private JClassLocalRef(JObjectLocalRef value) => this._value = value; + + #region Public Methods + public Boolean Equals(JClassLocalRef other) => this._value.Equals(other._value); + #endregion + + #region Override Methods + public override Boolean Equals([NotNullWhen(true)] Object obj) => obj is JClassLocalRef other && this.Equals(other); + public override Int32 GetHashCode() => this._value.GetHashCode(); + #endregion + + #region Operators + public static explicit operator JObjectLocalRef(JClassLocalRef a) => a._value; + public static explicit operator JClassLocalRef(JObjectLocalRef a) => new(a); + public static Boolean operator ==(JClassLocalRef a, JClassLocalRef b) => a.Equals(b); + public static Boolean operator !=(JClassLocalRef a, JClassLocalRef b) => !a.Equals(b); + #endregion +} diff --git a/src/LibRyujinx/Android/Jni/References/JGlobalRef.cs b/src/LibRyujinx/Android/Jni/References/JGlobalRef.cs new file mode 100644 index 000000000..6fbd8fad8 --- /dev/null +++ b/src/LibRyujinx/Android/Jni/References/JGlobalRef.cs @@ -0,0 +1,28 @@ +using System; +using System.Diagnostics.CodeAnalysis; + +namespace LibRyujinx.Jni.References; + +public readonly struct JGlobalRef : IEquatable +{ +#pragma warning disable 0649 + private readonly JObjectLocalRef _value; + + public JObjectLocalRef Value => _value; +#pragma warning restore 0649 + + #region Public Methods + public Boolean Equals(JGlobalRef other) => this._value.Equals(other._value); + #endregion + + #region Override Methods + public override Boolean Equals([NotNullWhen(true)] Object obj) => obj is JGlobalRef other && this.Equals(other); + public override Int32 GetHashCode() => this._value.GetHashCode(); + #endregion + + #region Operators + public static explicit operator JObjectLocalRef(JGlobalRef a) => a._value; + public static Boolean operator ==(JGlobalRef a, JGlobalRef b) => a.Equals(b); + public static Boolean operator !=(JGlobalRef a, JGlobalRef b) => !a.Equals(b); + #endregion +} diff --git a/src/LibRyujinx/Jni/References/JObjectLocalRef.cs b/src/LibRyujinx/Android/Jni/References/JObjectLocalRef.cs similarity index 95% rename from src/LibRyujinx/Jni/References/JObjectLocalRef.cs rename to src/LibRyujinx/Android/Jni/References/JObjectLocalRef.cs index ff1953137..241cb0be0 100644 --- a/src/LibRyujinx/Jni/References/JObjectLocalRef.cs +++ b/src/LibRyujinx/Android/Jni/References/JObjectLocalRef.cs @@ -1,5 +1,5 @@ -using System.Diagnostics.CodeAnalysis; using System; +using System.Diagnostics.CodeAnalysis; namespace LibRyujinx.Jni.References { diff --git a/src/LibRyujinx/Android/Jni/References/JStringLocalRef.cs b/src/LibRyujinx/Android/Jni/References/JStringLocalRef.cs new file mode 100644 index 000000000..dcc5d9e27 --- /dev/null +++ b/src/LibRyujinx/Android/Jni/References/JStringLocalRef.cs @@ -0,0 +1,27 @@ +using System; +using System.Diagnostics.CodeAnalysis; + +namespace LibRyujinx.Jni.References; + +public readonly struct JStringLocalRef : IEquatable +{ +#pragma warning disable 0649 + private readonly JObjectLocalRef _value; +#pragma warning restore 0649 + + #region Public Methods + public Boolean Equals(JStringLocalRef other) => this._value.Equals(other._value); + #endregion + + #region Override Methods + public override Boolean Equals([NotNullWhen(true)] Object obj) + => obj is JStringLocalRef other && this.Equals(other); + public override Int32 GetHashCode() => this._value.GetHashCode(); + #endregion + + #region Operators + public static explicit operator JObjectLocalRef(JStringLocalRef a) => a._value; + public static Boolean operator ==(JStringLocalRef a, JStringLocalRef b) => a.Equals(b); + public static Boolean operator !=(JStringLocalRef a, JStringLocalRef b) => !a.Equals(b); + #endregion +} diff --git a/src/LibRyujinx/Android/Jni/References/JThrowableLocalRef.cs b/src/LibRyujinx/Android/Jni/References/JThrowableLocalRef.cs new file mode 100644 index 000000000..a27ba2318 --- /dev/null +++ b/src/LibRyujinx/Android/Jni/References/JThrowableLocalRef.cs @@ -0,0 +1,27 @@ +using System; +using System.Diagnostics.CodeAnalysis; + +namespace LibRyujinx.Jni.References; + +public readonly struct JThrowableLocalRef : IEquatable +{ +#pragma warning disable 0649 + private readonly JObjectLocalRef _value; +#pragma warning restore 0649 + + #region Public Methods + public Boolean Equals(JThrowableLocalRef other) => this._value.Equals(other._value); + #endregion + + #region Override Methods + public override Boolean Equals([NotNullWhen(true)] Object obj) + => obj is JThrowableLocalRef other && this.Equals(other); + public override Int32 GetHashCode() => this._value.GetHashCode(); + #endregion + + #region Operators + public static explicit operator JObjectLocalRef(JThrowableLocalRef a) => a._value; + public static Boolean operator ==(JThrowableLocalRef a, JThrowableLocalRef b) => a.Equals(b); + public static Boolean operator !=(JThrowableLocalRef a, JThrowableLocalRef b) => !a.Equals(b); + #endregion +} diff --git a/src/LibRyujinx/Android/Jni/References/JWeakRef.cs b/src/LibRyujinx/Android/Jni/References/JWeakRef.cs new file mode 100644 index 000000000..1a045006f --- /dev/null +++ b/src/LibRyujinx/Android/Jni/References/JWeakRef.cs @@ -0,0 +1,26 @@ +using System; +using System.Diagnostics.CodeAnalysis; + +namespace LibRyujinx.Jni.References; + +public readonly struct JWeakRef : IEquatable +{ +#pragma warning disable 0649 + private readonly JObjectLocalRef _value; +#pragma warning restore 0649 + + #region Public Methods + public Boolean Equals(JWeakRef other) => this._value.Equals(other._value); + #endregion + + #region Override Methods + public override Boolean Equals([NotNullWhen(true)] Object obj) => obj is JWeakRef other && this.Equals(other); + public override Int32 GetHashCode() => this._value.GetHashCode(); + #endregion + + #region Operators + public static explicit operator JObjectLocalRef(JWeakRef a) => a._value; + public static Boolean operator ==(JWeakRef a, JWeakRef b) => a.Equals(b); + public static Boolean operator !=(JWeakRef a, JWeakRef b) => !a.Equals(b); + #endregion +} diff --git a/src/LibRyujinx/Jni/Values/JEnvValue.cs b/src/LibRyujinx/Android/Jni/Values/JEnvValue.cs similarity index 97% rename from src/LibRyujinx/Jni/Values/JEnvValue.cs rename to src/LibRyujinx/Android/Jni/Values/JEnvValue.cs index dc4d8a17b..966fe73a8 100644 --- a/src/LibRyujinx/Jni/Values/JEnvValue.cs +++ b/src/LibRyujinx/Android/Jni/Values/JEnvValue.cs @@ -1,4 +1,4 @@ -using Rxmxnx.PInvoke; +using Rxmxnx.PInvoke; using System; namespace LibRyujinx.Jni.Values diff --git a/src/LibRyujinx/Jni/Values/JInvokeInterface.cs b/src/LibRyujinx/Android/Jni/Values/JInvokeInterface.cs similarity index 94% rename from src/LibRyujinx/Jni/Values/JInvokeInterface.cs rename to src/LibRyujinx/Android/Jni/Values/JInvokeInterface.cs index 14473c574..4d9ba71f5 100644 --- a/src/LibRyujinx/Jni/Values/JInvokeInterface.cs +++ b/src/LibRyujinx/Android/Jni/Values/JInvokeInterface.cs @@ -1,5 +1,5 @@ -using System.Diagnostics.CodeAnalysis; using System; +using System.Diagnostics.CodeAnalysis; namespace LibRyujinx.Jni.Values { diff --git a/src/LibRyujinx/Android/Jni/Values/JNativeInterface.cs b/src/LibRyujinx/Android/Jni/Values/JNativeInterface.cs new file mode 100644 index 000000000..35886bf25 --- /dev/null +++ b/src/LibRyujinx/Android/Jni/Values/JNativeInterface.cs @@ -0,0 +1,247 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using System.Runtime.InteropServices; + +namespace LibRyujinx.Jni.Values; + +[SuppressMessage("CodeQuality", "IDE0051:Remove unused private members", + Justification = "This struct is created only by binary operations.")] +[StructLayout(LayoutKind.Sequential)] +public readonly struct JNativeInterface +{ +#pragma warning disable 0169 + private readonly IntPtr _reserved0; + private readonly IntPtr _reserved1; + private readonly IntPtr _reserved2; + private readonly IntPtr _reserved3; +#pragma warning restore 0169 + internal readonly IntPtr GetVersionPointer { get; init; } + internal readonly IntPtr DefineClassPointer { get; init; } + internal readonly IntPtr FindClassPointer { get; init; } + internal readonly IntPtr FromReflectedMethodPointer { get; init; } + internal readonly IntPtr FromReflectedFieldPointer { get; init; } + internal readonly IntPtr ToReflectedMethodPointer { get; init; } + internal readonly IntPtr GetSuperclassPointer { get; init; } + internal readonly IntPtr IsAssignableFromPointer { get; init; } + internal readonly IntPtr ToReflectedFieldPointer { get; init; } + internal readonly IntPtr ThrowPointer { get; init; } + internal readonly IntPtr ThrowNewPointer { get; init; } + internal readonly IntPtr ExceptionOccurredPointer { get; init; } + internal readonly IntPtr ExceptionDescribePointer { get; init; } + internal readonly IntPtr ExceptionClearPointer { get; init; } + internal readonly IntPtr FatalErrorPointer { get; init; } + internal readonly IntPtr PushLocalFramePointer { get; init; } + internal readonly IntPtr PopLocalFramePointer { get; init; } + internal readonly IntPtr NewGlobalRefPointer { get; init; } + internal readonly IntPtr DeleteGlobalRefPointer { get; init; } + internal readonly IntPtr DeleteLocalRefPointer { get; init; } + internal readonly IntPtr IsSameObjectPointer { get; init; } + internal readonly IntPtr NewLocalRefPointer { get; init; } + internal readonly IntPtr EnsureLocalCapacityPointer { get; init; } + internal readonly IntPtr AllocObjectPointer { get; init; } + internal readonly IntPtr NewObjectPointer { get; init; } + internal readonly IntPtr NewObjectVPointer { get; init; } + internal readonly IntPtr NewObjectAPointer { get; init; } + internal readonly IntPtr GetObjectClassPointer { get; init; } + internal readonly IntPtr IsInstanceOfPointer { get; init; } + internal readonly IntPtr GetMethodIdPointer { get; init; } + private readonly IntPtr CallObjectMethodPointer { get; init; } + private readonly IntPtr CallObjectMethodVPointer { get; init; } + internal readonly IntPtr CallObjectMethodAPointer { get; init; } + private readonly IntPtr CallBooleanMethodPointer { get; init; } + private readonly IntPtr CallBooleanMethodVPointer { get; init; } + internal readonly IntPtr CallBooleanMethodAPointer { get; init; } + private readonly IntPtr CallByteMethodPointer { get; init; } + private readonly IntPtr CallByteMethodVPointer { get; init; } + internal readonly IntPtr CallByteMethodAPointer { get; init; } + private readonly IntPtr CallCharMethodPointer { get; init; } + private readonly IntPtr CallCharMethodVPointer { get; init; } + internal readonly IntPtr CallCharMethodAPointer { get; init; } + private readonly IntPtr CallShortMethodPointer { get; init; } + private readonly IntPtr CallShortMethodVPointer { get; init; } + internal readonly IntPtr CallShortMethodAPointer { get; init; } + private readonly IntPtr CallIntMethodPointer { get; init; } + private readonly IntPtr CallIntMethodVPointer { get; init; } + internal readonly IntPtr CallIntMethodAPointer { get; init; } + private readonly IntPtr CallLongMethodPointer { get; init; } + private readonly IntPtr CallLongMethodVPointer { get; init; } + internal readonly IntPtr CallLongMethodAPointer { get; init; } + private readonly IntPtr CallFloatMethodPointer { get; init; } + private readonly IntPtr CallFloatMethodVPointer { get; init; } + internal readonly IntPtr CallFloatMethodAPointer { get; init; } + private readonly IntPtr CallDoubleMethodPointer { get; init; } + private readonly IntPtr CallDoubleMethodVPointer { get; init; } + internal readonly IntPtr CallDoubleMethodAPointer { get; init; } + private readonly IntPtr CallVoidMethodPointer { get; init; } + private readonly IntPtr CallVoidMethodVPointer { get; init; } + internal readonly IntPtr CallVoidMethodAPointer { get; init; } + private readonly IntPtr CallNonVirtualObjectMethodPointer { get; init; } + private readonly IntPtr CallNonVirtualObjectMethodVPointer { get; init; } + internal readonly IntPtr CallNonVirtualObjectMethodAPointer { get; init; } + private readonly IntPtr CallNonVirtualBooleanMethodPointer { get; init; } + private readonly IntPtr CallNonVirtualBooleanMethodVPointer { get; init; } + internal readonly IntPtr CallNonVirtualBooleanMethodAPointer { get; init; } + private readonly IntPtr CallNonVirtualByteMethodPointer { get; init; } + private readonly IntPtr CallNonVirtualByteMethodVPointer { get; init; } + internal readonly IntPtr CallNonVirtualByteMethodAPointer { get; init; } + private readonly IntPtr CallNonVirtualCharMethodPointer { get; init; } + private readonly IntPtr CallNonVirtualCharMethodVPointer { get; init; } + internal readonly IntPtr CallNonVirtualCharMethodAPointer { get; init; } + private readonly IntPtr CallNonVirtualShortMethodPointer { get; init; } + private readonly IntPtr CallNonVirtualShortMethodVPointer { get; init; } + internal readonly IntPtr CallNonVirtualShortMethodAPointer { get; init; } + private readonly IntPtr CallNonVirtualIntMethodPointer { get; init; } + private readonly IntPtr CallNonVirtualIntMethodVPointer { get; init; } + internal readonly IntPtr CallNonVirtualIntMethodAPointer { get; init; } + private readonly IntPtr CallNonVirtualLongMethodPointer { get; init; } + private readonly IntPtr CallNonVirtualLongMethodVPointer { get; init; } + internal readonly IntPtr CallNonVirtualLongMethodAPointer { get; init; } + private readonly IntPtr CallNonVirtualFloatMethodPointer { get; init; } + private readonly IntPtr CallNonVirtualFloatMethodVPointer { get; init; } + internal readonly IntPtr CallNonVirtualFloatMethodAPointer { get; init; } + private readonly IntPtr CallNonVirtualDoubleMethodPointer { get; init; } + private readonly IntPtr CallNonVirtualDoubleMethodVPointer { get; init; } + internal readonly IntPtr CallNonVirtualDoubleMethodAPointer { get; init; } + private readonly IntPtr CallNonVirtualVoidMethodPointer { get; init; } + private readonly IntPtr CallNonVirtualVoidMethodVPointer { get; init; } + internal readonly IntPtr CallNonVirtualVoidMethodAPointer { get; init; } + internal readonly IntPtr GetFieldIdPointer { get; init; } + internal readonly IntPtr GetObjectFieldPointer { get; init; } + internal readonly IntPtr GetBooleanFieldPointer { get; init; } + internal readonly IntPtr GetByteFieldPointer { get; init; } + internal readonly IntPtr GetCharFieldPointer { get; init; } + internal readonly IntPtr GetShortFieldPointer { get; init; } + internal readonly IntPtr GetIntFieldPointer { get; init; } + internal readonly IntPtr GetLongFieldPointer { get; init; } + internal readonly IntPtr GetFloatFieldPointer { get; init; } + internal readonly IntPtr GetDoubleFieldPointer { get; init; } + internal readonly IntPtr SetObjectFieldPointer { get; init; } + internal readonly IntPtr SetBooleanFieldPointer { get; init; } + internal readonly IntPtr SetByteFieldPointer { get; init; } + internal readonly IntPtr SetCharFieldPointer { get; init; } + internal readonly IntPtr SetShortFieldPointer { get; init; } + internal readonly IntPtr SetIntFieldPointer { get; init; } + internal readonly IntPtr SetLongFieldPointer { get; init; } + internal readonly IntPtr SetFloatFieldPointer { get; init; } + internal readonly IntPtr SetDoubleFieldPointer { get; init; } + internal readonly IntPtr GetStaticMethodIdPointer { get; init; } + private readonly IntPtr CallStaticObjectMethodPointer { get; init; } + private readonly IntPtr CallStaticObjectMethodVPointer { get; init; } + internal readonly IntPtr CallStaticObjectMethodAPointer { get; init; } + private readonly IntPtr CallStaticBooleanMethodPointer { get; init; } + private readonly IntPtr CallStaticBooleanMethodVPointer { get; init; } + internal readonly IntPtr CallStaticBooleanMethodAPointer { get; init; } + private readonly IntPtr CallStaticByteMethodPointer { get; init; } + private readonly IntPtr CallStaticByteMethodVPointer { get; init; } + internal readonly IntPtr CallStaticByteMethodAPointer { get; init; } + private readonly IntPtr CallStaticCharMethodPointer { get; init; } + private readonly IntPtr CallStaticCharMethodVPointer { get; init; } + internal readonly IntPtr CallStaticCharMethodAPointer { get; init; } + private readonly IntPtr CallStaticShortMethodPointer { get; init; } + private readonly IntPtr CallStaticShortMethodVPointer { get; init; } + internal readonly IntPtr CallStaticShortMethodAPointer { get; init; } + private readonly IntPtr CallStaticIntMethodPointer { get; init; } + private readonly IntPtr CallStaticIntMethodVPointer { get; init; } + internal readonly IntPtr CallStaticIntMethodAPointer { get; init; } + private readonly IntPtr CallStaticLongMethodPointer { get; init; } + private readonly IntPtr CallStaticLongMethodVPointer { get; init; } + internal readonly IntPtr CallStaticLongMethodAPointer { get; init; } + private readonly IntPtr CallStaticFloatMethodPointer { get; init; } + private readonly IntPtr CallStaticFloatMethodVPointer { get; init; } + internal readonly IntPtr CallStaticFloatMethodAPointer { get; init; } + private readonly IntPtr CallStaticDoubleMethodPointer { get; init; } + private readonly IntPtr CallStaticDoubleMethodVPointer { get; init; } + internal readonly IntPtr CallStaticDoubleMethodAPointer { get; init; } + private readonly IntPtr CallStaticVoidMethodPointer { get; init; } + private readonly IntPtr CallStaticVoidMethodVPointer { get; init; } + internal readonly IntPtr CallStaticVoidMethodAPointer { get; init; } + internal readonly IntPtr GetStaticFieldIdPointer { get; init; } + internal readonly IntPtr GetStaticObjectFieldPointer { get; init; } + internal readonly IntPtr GetStaticBooleanFieldPointer { get; init; } + internal readonly IntPtr GetStaticByteFieldPointer { get; init; } + internal readonly IntPtr GetStaticCharFieldPointer { get; init; } + internal readonly IntPtr GetStaticShortFieldPointer { get; init; } + internal readonly IntPtr GetStaticIntFieldPointer { get; init; } + internal readonly IntPtr GetStaticLongFieldPointer { get; init; } + internal readonly IntPtr GetStaticFloatFieldPointer { get; init; } + internal readonly IntPtr GetStaticDoubleFieldPointer { get; init; } + internal readonly IntPtr SetStaticObjectFieldPointer { get; init; } + internal readonly IntPtr SetStaticBooleanFieldPointer { get; init; } + internal readonly IntPtr SetStaticByteFieldPointer { get; init; } + internal readonly IntPtr SetStaticCharFieldPointer { get; init; } + internal readonly IntPtr SetStaticShortFieldPointer { get; init; } + internal readonly IntPtr SetStaticIntFieldPointer { get; init; } + internal readonly IntPtr SetStaticLongFieldPointer { get; init; } + internal readonly IntPtr SetStaticFloatFieldPointer { get; init; } + internal readonly IntPtr SetStaticDoubleFieldPointer { get; init; } + internal readonly IntPtr NewStringPointer { get; init; } + internal readonly IntPtr GetStringLengthPointer { get; init; } + internal readonly IntPtr GetStringCharsPointer { get; init; } + internal readonly IntPtr ReleaseStringCharsPointer { get; init; } + internal readonly IntPtr NewStringUtfPointer { get; init; } + internal readonly IntPtr GetStringUtfLengthPointer { get; init; } + internal readonly IntPtr GetStringUtfCharsPointer { get; init; } + internal readonly IntPtr ReleaseStringUtfCharsPointer { get; init; } + internal readonly IntPtr GetArrayLengthPointer { get; init; } + internal readonly IntPtr NewObjectArrayPointer { get; init; } + internal readonly IntPtr GetObjectArrayElementPointer { get; init; } + internal readonly IntPtr SetObjectArrayElementPointer { get; init; } + internal readonly IntPtr NewBooleanArrayPointer { get; init; } + internal readonly IntPtr NewByteArrayPointer { get; init; } + internal readonly IntPtr NewCharArrayPointer { get; init; } + internal readonly IntPtr NewShortArrayPointer { get; init; } + internal readonly IntPtr NewIntArrayPointer { get; init; } + internal readonly IntPtr NewLongArrayPointer { get; init; } + internal readonly IntPtr NewFloatArrayPointer { get; init; } + internal readonly IntPtr NewDoubleArrayPointer { get; init; } + internal readonly IntPtr GetBooleanArrayElementsPointer { get; init; } + internal readonly IntPtr GetByteArrayElementsPointer { get; init; } + internal readonly IntPtr GetCharArrayElementsPointer { get; init; } + internal readonly IntPtr GetShortArrayElementsPointer { get; init; } + internal readonly IntPtr GetIntArrayElementsPointer { get; init; } + internal readonly IntPtr GetLongArrayElementsPointer { get; init; } + internal readonly IntPtr GetFloatArrayElementsPointer { get; init; } + internal readonly IntPtr GetDoubleArrayElementsPointer { get; init; } + internal readonly IntPtr ReleaseBooleanArrayElementsPointer { get; init; } + internal readonly IntPtr ReleaseByteArrayElementsPointer { get; init; } + internal readonly IntPtr ReleaseCharArrayElementsPointer { get; init; } + internal readonly IntPtr ReleaseShortArrayElementsPointer { get; init; } + internal readonly IntPtr ReleaseIntArrayElementsPointer { get; init; } + internal readonly IntPtr ReleaseLongArrayElementsPointer { get; init; } + internal readonly IntPtr ReleaseFloatArrayElementsPointer { get; init; } + internal readonly IntPtr ReleaseDoubleArrayElementsPointer { get; init; } + internal readonly IntPtr GetBooleanArrayRegionPointer { get; init; } + internal readonly IntPtr GetByteArrayRegionPointer { get; init; } + internal readonly IntPtr GetCharArrayRegionPointer { get; init; } + internal readonly IntPtr GetShortArrayRegionPointer { get; init; } + internal readonly IntPtr GetIntArrayRegionPointer { get; init; } + internal readonly IntPtr GetLongArrayRegionPointer { get; init; } + internal readonly IntPtr GetFloatArrayRegionPointer { get; init; } + internal readonly IntPtr GetDoubleArrayRegionPointer { get; init; } + internal readonly IntPtr SetBooleanArrayRegionPointer { get; init; } + internal readonly IntPtr SetByteArrayRegionPointer { get; init; } + internal readonly IntPtr SetCharArrayRegionPointer { get; init; } + internal readonly IntPtr SetShortArrayRegionPointer { get; init; } + internal readonly IntPtr SetIntArrayRegionPointer { get; init; } + internal readonly IntPtr SetLongArrayRegionPointer { get; init; } + internal readonly IntPtr SetFloatArrayRegionPointer { get; init; } + internal readonly IntPtr SetDoubleArrayRegionPointer { get; init; } + internal readonly IntPtr RegisterNativesPointer { get; init; } + internal readonly IntPtr UnregisterNativesPointer { get; init; } + internal readonly IntPtr MonitorEnterPointer { get; init; } + internal readonly IntPtr MonitorExitPointer { get; init; } + internal readonly IntPtr GetJavaVMPointer { get; init; } + internal readonly IntPtr GetStringRegionPointer { get; init; } + internal readonly IntPtr GetStringUtfRegionPointer { get; init; } + internal readonly IntPtr GetPrimitiveArrayCriticalPointer { get; init; } + internal readonly IntPtr ReleasePrimitiveArrayCriticalPointer { get; init; } + internal readonly IntPtr GetStringCriticalPointer { get; init; } + internal readonly IntPtr ReleaseStringCriticalPointer { get; init; } + internal readonly IntPtr NewWeakGlobalRefPointer { get; init; } + internal readonly IntPtr DeleteWeakGlobalRefPointer { get; init; } + internal readonly IntPtr ExceptionCheckPointer { get; init; } + internal readonly IntPtr NewDirectByteBufferPointer { get; init; } + internal readonly IntPtr GetDirectBufferAddressPointer { get; init; } + internal readonly IntPtr GetDirectBufferCapacityPointer { get; init; } + internal readonly IntPtr GetObjectRefTypePointer { get; init; } +} diff --git a/src/LibRyujinx/Android/Jni/Values/JNativeMethod.cs b/src/LibRyujinx/Android/Jni/Values/JNativeMethod.cs new file mode 100644 index 000000000..cf5c512e4 --- /dev/null +++ b/src/LibRyujinx/Android/Jni/Values/JNativeMethod.cs @@ -0,0 +1,11 @@ +using Rxmxnx.PInvoke; +using System; + +namespace LibRyujinx.Jni.Values; + +public readonly struct JNativeMethod +{ + internal ReadOnlyValPtr Name { get; init; } + internal ReadOnlyValPtr Signature { get; init; } + internal IntPtr Pointer { get; init; } +} diff --git a/src/LibRyujinx/Android/Jni/Values/JValue.cs b/src/LibRyujinx/Android/Jni/Values/JValue.cs new file mode 100644 index 000000000..45d077884 --- /dev/null +++ b/src/LibRyujinx/Android/Jni/Values/JValue.cs @@ -0,0 +1,46 @@ +using System; +using System.Runtime.CompilerServices; + +using LibRyujinx.Jni.References; + +using Rxmxnx.PInvoke; + +namespace LibRyujinx.Jni.Values; + +internal readonly struct JValue +{ + private delegate Boolean IsDefaultDelegate(in JValue value); + + private static readonly Int32 size = NativeUtilities.SizeOf(); + + private static readonly IsDefaultDelegate isDefault = JValue.GetIsDefault(); + +#pragma warning disable 0649 +#pragma warning disable 0169 + private readonly Byte _value1; + private readonly Byte _value2; + private readonly Int16 _value3; + private readonly Int32 _value4; +#pragma warning restore 0169 +#pragma warning restore 0649 + + public Boolean IsDefault => JValue.isDefault(this); + + public static JValue Create(in ReadOnlySpan source) + { + Byte[] result = new Byte[JValue.size]; + for (Int32 i = 0; i < source.Length; i++) + result[i] = source[i]; + return result.ToValue(); + } + + private static IsDefaultDelegate GetIsDefault() => Environment.Is64BitProcess ? JValue.DefaultLong : JValue.Default; + + private static Boolean Default(in JValue jValue) + => jValue._value1 + jValue._value2 + jValue._value3 == default && jValue._value4 == default; + + private static Boolean DefaultLong(in JValue jValue) + => Unsafe.AsRef(in jValue).Transform() == default; + + public static explicit operator JValue(JObjectLocalRef a) => JValue.Create(NativeUtilities.AsBytes(in a)); +} diff --git a/src/LibRyujinx/Android/Jni/Values/JavaVMAttachArgs.cs b/src/LibRyujinx/Android/Jni/Values/JavaVMAttachArgs.cs new file mode 100644 index 000000000..75bc87fb6 --- /dev/null +++ b/src/LibRyujinx/Android/Jni/Values/JavaVMAttachArgs.cs @@ -0,0 +1,13 @@ +using LibRyujinx.Jni.References; + +using Rxmxnx.PInvoke; +using System; + +namespace LibRyujinx.Jni.Values; + +public readonly struct JavaVMAttachArgs +{ + internal Int32 Version { get; init; } + internal ReadOnlyValPtr Name { get; init; } + internal JObjectLocalRef Group { get; init; } +} diff --git a/src/LibRyujinx/Jni/Values/JavaVMInitArgs.cs b/src/LibRyujinx/Android/Jni/Values/JavaVMInitArgs.cs similarity index 94% rename from src/LibRyujinx/Jni/Values/JavaVMInitArgs.cs rename to src/LibRyujinx/Android/Jni/Values/JavaVMInitArgs.cs index d9fa6d161..424dc3bbe 100644 --- a/src/LibRyujinx/Jni/Values/JavaVMInitArgs.cs +++ b/src/LibRyujinx/Android/Jni/Values/JavaVMInitArgs.cs @@ -1,4 +1,4 @@ -using System; +using System; namespace LibRyujinx.Jni.Values { diff --git a/src/LibRyujinx/Android/Jni/Values/JavaVMOption.cs b/src/LibRyujinx/Android/Jni/Values/JavaVMOption.cs new file mode 100644 index 000000000..84f9c969f --- /dev/null +++ b/src/LibRyujinx/Android/Jni/Values/JavaVMOption.cs @@ -0,0 +1,10 @@ +using Rxmxnx.PInvoke; +using System; + +namespace LibRyujinx.Jni.Values; + +public readonly struct JavaVMOption +{ + internal ReadOnlyValPtr Name { get; init; } + internal IntPtr ExtraInfo { get; init; } +} diff --git a/src/LibRyujinx/Android/Jni/Values/JavaVMValue.cs b/src/LibRyujinx/Android/Jni/Values/JavaVMValue.cs new file mode 100644 index 000000000..6767f6db7 --- /dev/null +++ b/src/LibRyujinx/Android/Jni/Values/JavaVMValue.cs @@ -0,0 +1,29 @@ +using Rxmxnx.PInvoke; +using System; + +namespace LibRyujinx.Jni.Values; + +internal readonly struct JavaVMValue : IEquatable +{ +#pragma warning disable 0649 + private readonly IntPtr _value; +#pragma warning restore 0649 + + #region Operators + public static Boolean operator ==(JavaVMValue a, JavaVMValue b) => a._value.Equals(b._value); + public static Boolean operator !=(JavaVMValue a, JavaVMValue b) => !a._value.Equals(b._value); + #endregion + + #region Public Properties + internal readonly ref JInvokeInterface Functions => ref this._value.GetUnsafeReference(); + #endregion + + #region Public Methods + public Boolean Equals(JavaVMValue other) => this._value.Equals(other._value); + #endregion + + #region Overrided Methods + public override Boolean Equals(Object obj) => obj is JavaVMValue other && this.Equals(other); + public override Int32 GetHashCode() => this._value.GetHashCode(); + #endregion +} diff --git a/src/LibRyujinx/Jni/Delegates.cs b/src/LibRyujinx/Jni/Delegates.cs deleted file mode 100644 index 683109ade..000000000 --- a/src/LibRyujinx/Jni/Delegates.cs +++ /dev/null @@ -1,286 +0,0 @@ -using LibRyujinx.Jni.Identifiers; -using LibRyujinx.Jni.Internal.Pointers; -using LibRyujinx.Jni.Pointers; -using LibRyujinx.Jni.Primitives; -using LibRyujinx.Jni.References; -using LibRyujinx.Jni.Values; -using System; - -namespace LibRyujinx.Jni -{ - internal delegate Int32 GetVersionDelegate(JEnvRef env); - - internal delegate JClassLocalRef DefineClassDelegate(JEnvRef env, CCharSequence name, JObjectLocalRef loader, IntPtr binaryData, Int32 len); - internal delegate JClassLocalRef FindClassDelegate(JEnvRef env, CCharSequence name); - - internal delegate JMethodId FromReflectedMethodDelegate(JEnvRef env, JObjectLocalRef method); - internal delegate JFieldId FromReflectedFieldIdDelegate(JEnvRef env, JObjectLocalRef field); - - internal delegate JObjectLocalRef ToReflectedMethodDelegate(JEnvRef env, JClassLocalRef jClass, JMethodId methodId, Boolean isStatic); - - internal delegate JClassLocalRef GetSuperclassDelegate(JEnvRef env, JClassLocalRef sub); - internal delegate Boolean IsAssignableFromDelegate(JEnvRef env, JClassLocalRef sub, JClassLocalRef sup); - - internal delegate JObjectLocalRef ToReflectedFieldIdDelegate(JEnvRef env, JClassLocalRef jClass, JFieldId fieldId, Boolean isStatic); - - internal delegate JResult ThrowDelegate(JEnvRef env, JThrowableLocalRef obj); - internal delegate JResult ThrowNewDelegate(JEnvRef env, JClassLocalRef jClass, CCharSequence msg); - internal delegate JThrowableLocalRef ExceptionOccurredDelegate(JEnvRef env); - internal delegate void ExceptionDescribeDelegate(JEnvRef env); - internal delegate void ExceptionClearDelegate(JEnvRef env); - internal delegate void FatalErrorDelegate(JEnvRef env, CCharSequence msg); - - internal delegate JResult PushLocalFrameDelegate(JEnvRef env, Int32 capacity); - internal delegate JObjectLocalRef PopLocalFrameDelegate(JEnvRef env, JObjectLocalRef result); - - internal delegate JGlobalRef NewGlobalRefDelegate(JEnvRef env, JObjectLocalRef lref); - internal delegate void DeleteGlobalRefDelegate(JEnvRef env, JGlobalRef gref); - internal delegate void DeleteLocalRefDelegate(JEnvRef env, JObjectLocalRef lref); - internal delegate Boolean IsSameObjectDelegate(JEnvRef env, JObjectLocalRef obj1, JObjectLocalRef obj2); - internal delegate JObjectLocalRef NewLocalRefDelegate(JEnvRef env, JObjectLocalRef objRef); - internal delegate JResult EnsureLocalCapacityDelegate(JEnvRef env, Int32 capacity); - - internal delegate JObjectLocalRef AllocObjectDelegate(JEnvRef env, JClassLocalRef jClass); - internal delegate JObjectLocalRef NewObjectDelegate(JEnvRef env, JClassLocalRef jClass, JMethodId jMethod, IntPtr args); - internal delegate JObjectLocalRef NewObjectVDelegate(JEnvRef env, JClassLocalRef jClass, JMethodId jMethod, ArgIterator args); - internal delegate JObjectLocalRef NewObjectADelegate(JEnvRef env, JClassLocalRef jClass, JMethodId jMethod, JValueSequence args); - - internal delegate JClassLocalRef GetObjectClassDelegate(JEnvRef env, JObjectLocalRef obj); - internal delegate Boolean IsInstanceOfDelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass); - - internal delegate JMethodId GetMethodIdDelegate(JEnvRef env, JClassLocalRef jClass, CCharSequence name, CCharSequence signature); - - internal delegate JObjectLocalRef CallObjectMethodDelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, IntPtr args); - internal delegate JObjectLocalRef CallObjectMethodVDelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, ArgIterator args); - internal delegate JObjectLocalRef CallObjectMethodADelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, JValueSequence args); - internal delegate JBoolean CallBooleanMethodDelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, IntPtr args); - internal delegate JBoolean CallBooleanMethodVDelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, ArgIterator args); - internal delegate JBoolean CallBooleanMethodADelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, JValueSequence args); - internal delegate JByte CallByteMethodDelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, IntPtr args); - internal delegate JByte CallByteMethodVDelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, ArgIterator args); - internal delegate JByte CallByteMethodADelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, JValueSequence args); - internal delegate JChar CallCharMethodDelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, IntPtr args); - internal delegate JChar CallCharMethodVDelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, ArgIterator args); - internal delegate JChar CallCharMethodADelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, JValueSequence args); - internal delegate JShort CallShortMethodDelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, IntPtr args); - internal delegate JShort CallShortMethodVDelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, ArgIterator args); - internal delegate JShort CallShortMethodADelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, JValueSequence args); - internal delegate JInt CallIntMethodDelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, IntPtr args); - internal delegate JInt CallIntMethodVDelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, ArgIterator args); - internal delegate JInt CallIntMethodADelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, JValueSequence args); - internal delegate JLong CallLongMethodDelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, IntPtr args); - internal delegate JLong CallLongMethodVDelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, ArgIterator args); - internal delegate JLong CallLongMethodADelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, JValueSequence args); - internal delegate JFloat CallFloatMethodDelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, IntPtr args); - internal delegate JFloat CallFloatMethodVDelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, ArgIterator args); - internal delegate JFloat CallFloatMethodADelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, JValueSequence args); - internal delegate JDouble CallDoubleMethodDelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, IntPtr args); - internal delegate JDouble CallDoubleMethodVDelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, ArgIterator args); - internal delegate JDouble CallDoubleMethodADelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, JValueSequence args); - internal delegate void CallVoidMethodDelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, IntPtr args); - internal delegate void CallVoidMethodVDelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, ArgIterator args); - internal delegate void CallVoidMethodADelegate(JEnvRef env, JObjectLocalRef obj, JMethodId jMethod, JValueSequence args); - - internal delegate JObjectLocalRef CallNonVirtualObjectMethodDelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, IntPtr args); - internal delegate JObjectLocalRef CallNonVirtualObjectMethodVDelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, ArgIterator args); - internal delegate JObjectLocalRef CallNonVirtualObjectMethodADelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, JValueSequence args); - internal delegate JBoolean CallNonVirtualBooleanMethodDelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, IntPtr args); - internal delegate JBoolean CallNonVirtualBooleanMethodVDelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, ArgIterator args); - internal delegate JBoolean CallNonVirtualBooleanMethodADelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, JValueSequence args); - internal delegate JByte CallNonVirtualByteMethodDelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, IntPtr args); - internal delegate JByte CallNonVirtualByteMethodVDelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, ArgIterator args); - internal delegate JByte CallNonVirtualByteMethodADelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, JValueSequence args); - internal delegate JChar CallNonVirtualCharMethodDelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, IntPtr args); - internal delegate JChar CallNonVirtualCharMethodVDelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, ArgIterator args); - internal delegate JChar CallNonVirtualCharMethodADelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, JValueSequence args); - internal delegate JShort CallNonVirtualShortMethodDelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, IntPtr args); - internal delegate JShort CallNonVirtualShortMethodVDelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, ArgIterator args); - internal delegate JShort CallNonVirtualShortMethodADelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, JValueSequence args); - internal delegate JInt CallNonVirtualIntMethodDelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, IntPtr args); - internal delegate JInt CallNonVirtualIntMethodVDelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, ArgIterator args); - internal delegate JInt CallNonVirtualIntMethodADelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, JValueSequence args); - internal delegate JLong CallNonVirtualLongMethodDelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, IntPtr args); - internal delegate JLong CallNonVirtualLongMethodVDelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, ArgIterator args); - internal delegate JLong CallNonVirtualLongMethodADelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, JValueSequence args); - internal delegate JFloat CallNonVirtualFloatMethodDelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, IntPtr args); - internal delegate JFloat CallNonVirtualFloatMethodVDelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, ArgIterator args); - internal delegate JFloat CallNonVirtualFloatMethodADelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, JValueSequence args); - internal delegate JDouble CallNonVirtualDoubleMethodDelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, IntPtr args); - internal delegate JDouble CallNonVirtualDoubleMethodVDelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, ArgIterator args); - internal delegate JDouble CallNonVirtualDoubleMethodADelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, JValueSequence args); - internal delegate void CallNonVirtualVoidMethodDelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, IntPtr args); - internal delegate void CallNonVirtualVoidMethodVDelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, ArgIterator args); - internal delegate void CallNonVirtualVoidMethodADelegate(JEnvRef env, JObjectLocalRef obj, JClassLocalRef jclass, JMethodId jMethod, JValueSequence args); - - internal delegate JFieldId GetFieldIdDelegate(JEnvRef env, JClassLocalRef jclass, CCharSequence name, CCharSequence signature); - - internal delegate JObjectLocalRef GetObjectFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField); - internal delegate JBoolean GetBooleanFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField); - internal delegate JByte GetByteFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField); - internal delegate JChar GetCharFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField); - internal delegate JShort GetShortFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField); - internal delegate JInt GetIntFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField); - internal delegate JLong GetLongFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField); - internal delegate JFloat GetFloatFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField); - internal delegate JDouble GetDoubleFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField); - internal delegate void SetObjectFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField, JObjectLocalRef value); - internal delegate void SetBooleanFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField, JBoolean value); - internal delegate void SetByteFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField, JByte value); - internal delegate void SetCharFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField, JChar value); - internal delegate void SetShortFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField, JShort value); - internal delegate void SetIntFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField, JInt value); - internal delegate void SetLongFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField, JLong value); - internal delegate void SetFloatFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField, JFloat value); - internal delegate void SetDoubleFieldDelegate(JEnvRef env, JObjectLocalRef obj, JFieldId jField, JDouble value); - - internal delegate JMethodId GetStaticMethodIdDelegate(JEnvRef env, JClassLocalRef jClass, CCharSequence name, CCharSequence signature); - - internal delegate JObjectLocalRef CallStaticObjectMethodDelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, IntPtr args); - internal delegate JObjectLocalRef CallStaticObjectMethodVDelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, ArgIterator args); - internal delegate JObjectLocalRef CallStaticObjectMethodADelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, JValueSequence args); - internal delegate JBoolean CallStaticBooleanMethodDelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, IntPtr args); - internal delegate JBoolean CallStaticBooleanMethodVDelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, ArgIterator args); - internal delegate JBoolean CallStaticBooleanMethodADelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, JValueSequence args); - internal delegate JByte CallStaticByteMethodDelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, IntPtr args); - internal delegate JByte CallStaticByteMethodVDelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, ArgIterator args); - internal delegate JByte CallStaticByteMethodADelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, JValueSequence args); - internal delegate JChar CallStaticCharMethodDelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, IntPtr args); - internal delegate JChar CallStaticCharMethodVDelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, ArgIterator args); - internal delegate JChar CallStaticCharMethodADelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, JValueSequence args); - internal delegate JShort CallStaticShortMethodDelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, IntPtr args); - internal delegate JShort CallStaticShortMethodVDelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, ArgIterator args); - internal delegate JShort CallStaticShortMethodADelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, JValueSequence args); - internal delegate JInt CallStaticIntMethodDelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, IntPtr args); - internal delegate JInt CallStaticIntMethodVDelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, ArgIterator args); - internal delegate JInt CallStaticIntMethodADelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, JValueSequence args); - internal delegate JLong CallStaticLongMethodDelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, IntPtr args); - internal delegate JLong CallStaticLongMethodVDelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, ArgIterator args); - internal delegate JLong CallStaticLongMethodADelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, JValueSequence args); - internal delegate JFloat CallStaticFloatMethodDelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, IntPtr args); - internal delegate JFloat CallStaticFloatMethodVDelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, ArgIterator args); - internal delegate JFloat CallStaticFloatMethodADelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, JValueSequence args); - internal delegate JDouble CallStaticDoubleMethodDelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, IntPtr args); - internal delegate JDouble CallStaticDoubleMethodVDelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, ArgIterator args); - internal delegate JDouble CallStaticDoubleMethodADelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, JValueSequence args); - internal delegate void CallStaticVoidMethodDelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, IntPtr args); - internal delegate void CallStaticVoidMethodVDelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, ArgIterator args); - internal delegate void CallStaticVoidMethodADelegate(JEnvRef env, JClassLocalRef jclass, JMethodId jMethod, JValueSequence args); - - internal delegate JFieldId GetStaticFieldIdDelegate(JEnvRef env, JClassLocalRef jclass, CCharSequence name, CCharSequence signature); - - internal delegate JObjectLocalRef GetStaticObjectFieldDelegate(JEnvRef env, JClassLocalRef jclass, JFieldId jField); - internal delegate JBoolean GetStaticBooleanFieldDelegate(JEnvRef env, JClassLocalRef jclass, JFieldId jField); - internal delegate JByte GetStaticByteFieldDelegate(JEnvRef env, JClassLocalRef jclass, JFieldId jField); - internal delegate JChar GetStaticCharFieldDelegate(JEnvRef env, JClassLocalRef jclass, JFieldId jField); - internal delegate JShort GetStaticShortFieldDelegate(JEnvRef env, JClassLocalRef jclass, JFieldId jField); - internal delegate JInt GetStaticIntFieldDelegate(JEnvRef env, JClassLocalRef jclass, JFieldId jField); - internal delegate JLong GetStaticLongFieldDelegate(JEnvRef env, JClassLocalRef jclass, JFieldId jField); - internal delegate JFloat GetStaticFloatFieldDelegate(JEnvRef env, JClassLocalRef jclass, JFieldId jField); - internal delegate JDouble GetStaticDoubleFieldDelegate(JEnvRef env, JClassLocalRef jclass, JFieldId jField); - internal delegate void SetStaticObjectFieldDelegate(JEnvRef env, JClassLocalRef jclass, JFieldId jField, JObjectLocalRef value); - internal delegate void SetStaticBooleanFieldDelegate(JEnvRef env, JClassLocalRef jclass, JFieldId jField, JBoolean value); - internal delegate void SetStaticByteFieldDelegate(JEnvRef env, JClassLocalRef jclass, JFieldId jField, JByte value); - internal delegate void SetStaticCharFieldDelegate(JEnvRef env, JClassLocalRef jclass, JFieldId jField, JChar value); - internal delegate void SetStaticShortFieldDelegate(JEnvRef env, JClassLocalRef jclass, JFieldId jField, JShort value); - internal delegate void SetStaticIntFieldDelegate(JEnvRef env, JClassLocalRef jclass, JFieldId jField, JInt value); - internal delegate void SetStaticLongFieldDelegate(JEnvRef env, JClassLocalRef jclass, JFieldId jField, JLong value); - internal delegate void SetStaticFloatFieldDelegate(JEnvRef env, JClassLocalRef jclass, JFieldId jField, JFloat value); - internal delegate void SetStaticDoubleFieldDelegate(JEnvRef env, JClassLocalRef jclass, JFieldId jField, JDouble value); - - internal delegate JStringLocalRef NewStringDelegate(JEnvRef env, JCharSequence unicode, Int32 length); - - internal delegate Int32 GetStringLengthDelegate(JEnvRef env, JStringLocalRef jString); - internal delegate JCharSequence GetStringCharsDelegate(JEnvRef env, JStringLocalRef jString, JBooleanRef isCopy); - internal delegate void ReleaseStringCharsDelegate(JEnvRef env, JStringLocalRef jString, JCharSequence chars); - - internal delegate JStringLocalRef NewStringUtfDelegate(JEnvRef env, CCharSequence unicode); - internal delegate Int32 GetStringUtfLengthDelegate(JEnvRef env, JStringLocalRef jString); - internal delegate CCharSequence GetStringUtfCharsDelegate(JEnvRef env, JStringLocalRef jString, JBooleanRef isCopy); - internal delegate void ReleaseStringUtfCharsDelegate(JEnvRef env, JStringLocalRef jString, CCharSequence chars); - - internal delegate Int32 GetArrayLengthDelegate(JEnvRef env, JArrayLocalRef array); - - internal delegate JArrayLocalRef NewObjectArrayDelegate(JEnvRef env, Int32 length, JClassLocalRef jClass, JObjectLocalRef init); - internal delegate JObjectLocalRef GetObjectArrayElementDelegate(JEnvRef env, JArrayLocalRef jArray, Int32 index); - internal delegate void SetObjectArrayElementDelegate(JEnvRef env, JArrayLocalRef jArray, Int32 index, JObjectLocalRef obj); - - internal delegate JArrayLocalRef NewBooleanArrayDelegate(JEnvRef env, Int32 length); - internal delegate JArrayLocalRef NewByteArrayDelegate(JEnvRef env, Int32 length); - internal delegate JArrayLocalRef NewCharArrayDelegate(JEnvRef env, Int32 length); - internal delegate JArrayLocalRef NewShortArrayDelegate(JEnvRef env, Int32 length); - internal delegate JArrayLocalRef NewIntArrayDelegate(JEnvRef env, Int32 length); - internal delegate JArrayLocalRef NewLongArrayDelegate(JEnvRef env, Int32 length); - internal delegate JArrayLocalRef NewFloatArrayDelegate(JEnvRef env, Int32 length); - internal delegate JArrayLocalRef NewDoubleArrayDelegate(JEnvRef env, Int32 length); - - internal delegate IntPtr GetBooleanArrayElementsDelegate(JEnvRef env, JArrayLocalRef jArray, JBooleanRef isCopy); - internal delegate IntPtr GetByteArrayElementsDelegate(JEnvRef env, JArrayLocalRef jArray, JBooleanRef isCopy); - internal delegate IntPtr GetCharArrayElementsDelegate(JEnvRef env, JArrayLocalRef jArray, JBooleanRef isCopy); - internal delegate IntPtr GetShortArrayElementsDelegate(JEnvRef env, JArrayLocalRef jArray, JBooleanRef isCopy); - internal delegate IntPtr GetIntArrayElementsDelegate(JEnvRef env, JArrayLocalRef jArray, JBooleanRef isCopy); - internal delegate IntPtr GetLongArrayElementsDelegate(JEnvRef env, JArrayLocalRef jArray, JBooleanRef isCopy); - internal delegate IntPtr GetFloatArrayElementsDelegate(JEnvRef env, JArrayLocalRef jArray, JBooleanRef isCopy); - internal delegate IntPtr GetDoubleArrayElementsDelegate(JEnvRef env, JArrayLocalRef jArray, JBooleanRef isCopy); - - internal delegate void ReleaseBooleanArrayElementsDelegate(JEnvRef env, JArrayLocalRef jArray, IntPtr elements, JReleaseMode mode); - internal delegate void ReleaseByteArrayElementsDelegate(JEnvRef env, JArrayLocalRef jArray, IntPtr elements, JReleaseMode mode); - internal delegate void ReleaseCharArrayElementsDelegate(JEnvRef env, JArrayLocalRef jArray, IntPtr elements, JReleaseMode mode); - internal delegate void ReleaseShortArrayElementsDelegate(JEnvRef env, JArrayLocalRef jArray, IntPtr elements, JReleaseMode mode); - internal delegate void ReleaseIntArrayElementsDelegate(JEnvRef env, JArrayLocalRef jArray, IntPtr elements, JReleaseMode mode); - internal delegate void ReleaseLongArrayElementsDelegate(JEnvRef env, JArrayLocalRef jArray, IntPtr elements, JReleaseMode mode); - internal delegate void ReleaseFloatArrayElementsDelegate(JEnvRef env, JArrayLocalRef jArray, IntPtr elements, JReleaseMode mode); - internal delegate void ReleaseDoubleArrayElementsDelegate(JEnvRef env, JArrayLocalRef jArray, IntPtr elements, JReleaseMode mode); - - internal delegate void GetBooleanArrayRegionDelegate(JEnvRef env, JArrayLocalRef jArray, Int32 startIndex, Int32 length, IntPtr buffer); - internal delegate void GetByteArrayRegionDelegate(JEnvRef env, JArrayLocalRef jArray, Int32 startIndex, Int32 length, IntPtr buffer); - internal delegate void GetCharArrayRegionDelegate(JEnvRef env, JArrayLocalRef jArray, Int32 startIndex, Int32 length, IntPtr buffer); - internal delegate void GetShortArrayRegionDelegate(JEnvRef env, JArrayLocalRef jArray, Int32 startIndex, Int32 length, IntPtr buffer); - internal delegate void GetIntArrayRegionDelegate(JEnvRef env, JArrayLocalRef jArray, Int32 startIndex, Int32 length, IntPtr buffer); - internal delegate void GetLongArrayRegionDelegate(JEnvRef env, JArrayLocalRef jArray, Int32 startIndex, Int32 length, IntPtr buffer); - internal delegate void GetFloatArrayRegionDelegate(JEnvRef env, JArrayLocalRef jArray, Int32 startIndex, Int32 length, IntPtr buffer); - internal delegate void GetDoubleArrayRegionDelegate(JEnvRef env, JArrayLocalRef jArray, Int32 startIndex, Int32 length, IntPtr buffer); - internal delegate void SetBooleanArrayRegionDelegate(JEnvRef env, JArrayLocalRef jArray, Int32 startIndex, Int32 length, IntPtr buffer); - internal delegate void SetByteArrayRegionDelegate(JEnvRef env, JArrayLocalRef jArray, Int32 startIndex, Int32 length, IntPtr buffer); - internal delegate void SetCharArrayRegionDelegate(JEnvRef env, JArrayLocalRef jArray, Int32 startIndex, Int32 length, IntPtr buffer); - internal delegate void SetShortArrayRegionDelegate(JEnvRef env, JArrayLocalRef jArray, Int32 startIndex, Int32 length, IntPtr buffer); - internal delegate void SetIntArrayRegionDelegate(JEnvRef env, JArrayLocalRef jArray, Int32 startIndex, Int32 length, IntPtr buffer); - internal delegate void SetLongArrayRegionDelegate(JEnvRef env, JArrayLocalRef jArray, Int32 startIndex, Int32 length, IntPtr buffer); - internal delegate void SetFloatArrayRegionDelegate(JEnvRef env, JArrayLocalRef jArray, Int32 startIndex, Int32 length, IntPtr buffer); - internal delegate void SetDoubleArrayRegionDelegate(JEnvRef env, JArrayLocalRef jArray, Int32 startIndex, Int32 length, IntPtr buffer); - - internal delegate JResult RegisterNativesDelegate(JEnvRef env, JClassLocalRef jClass, JNativeMethodSequence methods); - internal delegate JResult UnregisterNativesDelegate(JEnvRef env, JClassLocalRef jClass); - - internal delegate JResult MonitorEnterDelegate(JEnvRef env, JObjectLocalRef jClass); - internal delegate JResult MonitorExitDelegate(JEnvRef env, JObjectLocalRef jClass); - - internal delegate JResult GetJavaVMDelegate(JEnvRef env, ref JavaVMRef jvm); - - internal delegate void GetStringRegionDelegate(JEnvRef env, JStringLocalRef jString, Int32 startIndex, Int32 length, JCharSequence buffer); - internal delegate void GetStringUtfRegionDelegate(JEnvRef env, JStringLocalRef jString, Int32 startIndex, Int32 length, CCharSequence buffer); - - internal delegate IntPtr GetPrimitiveArrayCriticalDelegate(JEnvRef env, JArrayLocalRef jArray, JBooleanRef isCopy); - internal delegate void ReleasePrimitiveArrayCriticalDelegate(JEnvRef env, JArrayLocalRef jArray, IntPtr elements, JReleaseMode mode); - - internal delegate JCharSequence GetStringCriticalDelegate(JEnvRef env, JStringLocalRef jString, JBooleanRef isCopy); - internal delegate void ReleaseStringCriticalDelegate(JEnvRef env, JStringLocalRef jString, JCharSequence chars); - - internal delegate JWeakRef NewWeakGlobalRefDelegate(JEnvRef env, JObjectLocalRef obj); - internal delegate void DeleteWeakGlobalRefDelegate(JEnvRef env, JWeakRef jWeak); - - internal delegate Boolean ExceptionCheckDelegate(JEnvRef env); - - internal delegate JObjectLocalRef NewDirectByteBufferDelegate(JEnvRef env, IntPtr address, Int64 capacity); - internal delegate IntPtr GetDirectBufferAddressDelegate(JEnvRef env, JObjectLocalRef buffObj); - internal delegate Int64 GetDirectBufferCapacityDelegate(JEnvRef env, JObjectLocalRef buffObj); - - internal delegate JReferenceType GetObjectRefTypeDelegate(JEnvRef env, JObjectLocalRef obj); - - internal delegate JResult DestroyJavaVMDelegate(JavaVMRef vm); - internal delegate JResult AttachCurrentThreadDelegate(JavaVMRef vm, ref JEnvRef env, in JavaVMAttachArgs args); - internal delegate JResult DetachCurrentThreadDelegate(JavaVMRef vm); - - internal delegate JResult GetEnvDelegate(JavaVMRef vm, ref JEnvRef env, JInt version); - - internal delegate JResult AttachCurrentThreadAsDaemonDelegate(JavaVMRef vm, ref JEnvRef env, in JavaVMAttachArgs args); -} \ No newline at end of file diff --git a/src/LibRyujinx/Jni/Pointers/CCharSequence.cs b/src/LibRyujinx/Jni/Pointers/CCharSequence.cs deleted file mode 100644 index d52bcf6f4..000000000 --- a/src/LibRyujinx/Jni/Pointers/CCharSequence.cs +++ /dev/null @@ -1,36 +0,0 @@ -using System.Runtime.InteropServices; -using System; - -using Rxmxnx.PInvoke; - -namespace LibRyujinx.Jni.Pointers -{ - public readonly struct CCharSequence : IEquatable - { - private readonly IntPtr _value; - - private CCharSequence(IntPtr value) => this._value = value; - - #region Operators - public static implicit operator CCharSequence(IntPtr value) => new(value); - public static implicit operator CCharSequence(Span span) => new(span.GetUnsafeIntPtr()); - public static implicit operator CCharSequence(ReadOnlySpan readonlySpan) => new(readonlySpan.GetUnsafeIntPtr()); - - public static CCharSequence operator ++(CCharSequence a) => new(a._value + sizeof(Byte)); - public static CCharSequence operator --(CCharSequence a) => new(a._value - sizeof(Byte)); - public static Boolean operator ==(CCharSequence a, CCharSequence b) => a._value.Equals(b._value); - public static Boolean operator !=(CCharSequence a, CCharSequence b) => !a._value.Equals(b._value); - #endregion - - #region Public Methods - public Boolean Equals(CCharSequence other) => this._value.Equals(other._value); - public String AsString(Int32 length = 0) - => length == 0 ? Marshal.PtrToStringUTF8(_value) : Marshal.PtrToStringUTF8(_value, length); - #endregion - - #region Overrided Methods - public override Boolean Equals(Object obj) => obj is CCharSequence other && this.Equals(other); - public override Int32 GetHashCode() => this._value.GetHashCode(); - #endregion - } -} diff --git a/src/LibRyujinx/Jni/Pointers/JBooleanRef.cs b/src/LibRyujinx/Jni/Pointers/JBooleanRef.cs deleted file mode 100644 index 82c6d1767..000000000 --- a/src/LibRyujinx/Jni/Pointers/JBooleanRef.cs +++ /dev/null @@ -1,30 +0,0 @@ -using System.Runtime.CompilerServices; -using System; - -using LibRyujinx.Jni.Primitives; - -using Rxmxnx.PInvoke; - -namespace LibRyujinx.Jni.Pointers -{ - public readonly struct JBooleanRef - { - private static readonly Int32 JBooleanResultFalse = 0; - private static readonly Int32 JBooleanResultTrue = 1; - -#pragma warning disable IDE0052 - private readonly IntPtr _value; -#pragma warning restore IDE0052 - - public JBooleanRef(JBoolean? jBoolean) - => this._value = jBoolean.HasValue ? GetJBooleanRef(jBoolean.Value) : IntPtr.Zero; - - private static IntPtr GetJBooleanRef(Boolean value) - { - // Probably gonna break stuff - var t = JBooleanResultTrue; - var f = JBooleanResultFalse; - return value ? Unsafe.AsRef(ref f).GetUnsafeIntPtr() : Unsafe.AsRef(ref t).GetUnsafeIntPtr(); - } - } -} diff --git a/src/LibRyujinx/Jni/Pointers/JCharSequence.cs b/src/LibRyujinx/Jni/Pointers/JCharSequence.cs deleted file mode 100644 index 461944fc5..000000000 --- a/src/LibRyujinx/Jni/Pointers/JCharSequence.cs +++ /dev/null @@ -1,33 +0,0 @@ -using Rxmxnx.PInvoke; -using System; - -namespace LibRyujinx.Jni.Pointers -{ - public readonly struct JCharSequence : IEquatable - { - private readonly IntPtr _value; - - private JCharSequence(IntPtr value) => this._value = value; - - #region Operators - public static implicit operator JCharSequence(IntPtr value) => new(value); - public static implicit operator JCharSequence(Span span) => new(span.GetUnsafeIntPtr()); - public static implicit operator JCharSequence(ReadOnlySpan readonlySpan) => new(readonlySpan.GetUnsafeIntPtr()); - - public static JCharSequence operator ++(JCharSequence a) => new(a._value + sizeof(Char)); - public static JCharSequence operator --(JCharSequence a) => new(a._value - sizeof(Char)); - public static Boolean operator ==(JCharSequence a, JCharSequence b) => a._value.Equals(b._value); - public static Boolean operator !=(JCharSequence a, JCharSequence b) => !a._value.Equals(b._value); - #endregion - - #region Public Methods - public Boolean Equals(JCharSequence other) => this._value.Equals(other._value); - public String AsString(Int32 length = 0) => this._value.GetUnsafeString(length); - #endregion - - #region Overrided Methods - public override Boolean Equals(Object obj) => obj is JCharSequence other && this.Equals(other); - public override Int32 GetHashCode() => this._value.GetHashCode(); - #endregion - } -} diff --git a/src/LibRyujinx/Jni/Pointers/JNativeMethodSequence.cs b/src/LibRyujinx/Jni/Pointers/JNativeMethodSequence.cs deleted file mode 100644 index d5508714d..000000000 --- a/src/LibRyujinx/Jni/Pointers/JNativeMethodSequence.cs +++ /dev/null @@ -1,33 +0,0 @@ -using LibRyujinx.Jni.Values; - -using Rxmxnx.PInvoke; -using System; - -namespace LibRyujinx.Jni.Pointers -{ - public readonly struct JNativeMethodSequence : IEquatable - { - private readonly IntPtr _value; - - private JNativeMethodSequence(IntPtr value) => this._value = value; - - #region Operators - public static implicit operator JNativeMethodSequence(IntPtr value) => new(value); - public static implicit operator JNativeMethodSequence(ReadOnlySpan readonlySpan) => new(readonlySpan.GetUnsafeIntPtr()); - - public static JNativeMethodSequence operator ++(JNativeMethodSequence a) => new(a._value + JValue.Size); - public static JNativeMethodSequence operator --(JNativeMethodSequence a) => new(a._value - JValue.Size); - public static Boolean operator ==(JNativeMethodSequence a, JNativeMethodSequence b) => a._value.Equals(b._value); - public static Boolean operator !=(JNativeMethodSequence a, JNativeMethodSequence b) => !a._value.Equals(b._value); - #endregion - - #region Public Methods - public Boolean Equals(JNativeMethodSequence other) => this._value.Equals(other._value); - #endregion - - #region Overrided Methods - public override Boolean Equals(Object obj) => obj is JNativeMethodSequence other && this.Equals(other); - public override Int32 GetHashCode() => this._value.GetHashCode(); - #endregion - } -} diff --git a/src/LibRyujinx/Jni/Pointers/JValueSequence.cs b/src/LibRyujinx/Jni/Pointers/JValueSequence.cs deleted file mode 100644 index caa65ac9b..000000000 --- a/src/LibRyujinx/Jni/Pointers/JValueSequence.cs +++ /dev/null @@ -1,33 +0,0 @@ -using LibRyujinx.Jni.Values; - -using Rxmxnx.PInvoke; -using System; - -namespace LibRyujinx.Jni.Internal.Pointers -{ - internal readonly struct JValueSequence : IEquatable - { - private readonly IntPtr _value; - - private JValueSequence(IntPtr value) => this._value = value; - internal JValueSequence(ReadOnlySpan readonlySpan) : this(readonlySpan.GetUnsafeIntPtr()) { } - - #region Operators - public static implicit operator JValueSequence(IntPtr value) => new(value); - - public static JValueSequence operator ++(JValueSequence a) => new(a._value + JValue.Size); - public static JValueSequence operator --(JValueSequence a) => new(a._value - JValue.Size); - public static Boolean operator ==(JValueSequence a, JValueSequence b) => a._value.Equals(b._value); - public static Boolean operator !=(JValueSequence a, JValueSequence b) => !a._value.Equals(b._value); - #endregion - - #region Public Methods - public Boolean Equals(JValueSequence other) => this._value.Equals(other._value); - #endregion - - #region Overrided Methods - public override Boolean Equals(Object obj) => obj is JValueSequence other && this.Equals(other); - public override Int32 GetHashCode() => this._value.GetHashCode(); - #endregion - } -} diff --git a/src/LibRyujinx/Jni/Pointers/JavaVMRef.cs b/src/LibRyujinx/Jni/Pointers/JavaVMRef.cs deleted file mode 100644 index 27ba389f1..000000000 --- a/src/LibRyujinx/Jni/Pointers/JavaVMRef.cs +++ /dev/null @@ -1,25 +0,0 @@ -using System; - -namespace LibRyujinx.Jni.Pointers -{ - public readonly struct JavaVMRef : IEquatable - { -#pragma warning disable 0649 - private readonly IntPtr _value; -#pragma warning restore 0649 - - #region Operators - public static Boolean operator ==(JavaVMRef a, JavaVMRef b) => a._value.Equals(b._value); - public static Boolean operator !=(JavaVMRef a, JavaVMRef b) => !a._value.Equals(b._value); - #endregion - - #region Public Methods - public Boolean Equals(JavaVMRef other) => this._value.Equals(other._value); - #endregion - - #region Overrided Methods - public override Boolean Equals(Object obj) => obj is JavaVMRef other && this.Equals(other); - public override Int32 GetHashCode() => this._value.GetHashCode(); - #endregion - } -} diff --git a/src/LibRyujinx/Jni/Primitives/JBoolean.cs b/src/LibRyujinx/Jni/Primitives/JBoolean.cs deleted file mode 100644 index 88b4b7dba..000000000 --- a/src/LibRyujinx/Jni/Primitives/JBoolean.cs +++ /dev/null @@ -1,67 +0,0 @@ -using LibRyujinx.Jni.Pointers; - -using Rxmxnx.PInvoke; -using System; - -namespace LibRyujinx.Jni.Primitives -{ - public readonly struct JBoolean : IComparable, IEquatable - { - internal static readonly Type Type = typeof(JBoolean); - private static readonly Byte trueByte = 1; - private static readonly Byte falseByte = 2; - - public static readonly CString Signature = (CString)"Z"; - - private readonly Byte _value; - private Boolean Value => this._value == trueByte; - - private JBoolean(Boolean value) => this._value = value ? trueByte : falseByte; - - #region Operators - public static implicit operator JBoolean(Boolean value) => new(value); - public static implicit operator Boolean(JBoolean jValue) => jValue._value == 1; - public static implicit operator JBooleanRef(JBoolean? jValue) => new(jValue); - public static JBoolean operator !(JBoolean a) => new(!a.Value); - public static JBoolean operator |(JBoolean a, JBoolean b) => new(a.Value || b.Value); - public static JBoolean operator |(Boolean a, JBoolean b) => new(a || b.Value); - public static JBoolean operator |(JBoolean a, Boolean b) => new(a.Value || b); - public static JBoolean operator &(JBoolean a, JBoolean b) => new(a.Value && b.Value); - public static JBoolean operator &(Boolean a, JBoolean b) => new(a && b.Value); - public static JBoolean operator &(JBoolean a, Boolean b) => new(a.Value && b); - public static Boolean operator ==(JBoolean a, JBoolean b) => a._value.Equals(b._value); - public static Boolean operator ==(Boolean a, JBoolean b) => a.Equals(b._value); - public static Boolean operator ==(JBoolean a, Boolean b) => a._value.Equals(b); - public static Boolean operator !=(JBoolean a, JBoolean b) => !a._value.Equals(b._value); - public static Boolean operator !=(Boolean a, JBoolean b) => !a.Equals(b._value); - public static Boolean operator !=(JBoolean a, Boolean b) => !a._value.Equals(b); - public static Boolean operator >(JBoolean a, JBoolean b) => a._value.CompareTo(b._value) > 0; - public static Boolean operator >(Boolean a, JBoolean b) => a.CompareTo(b._value) > 0; - public static Boolean operator >(JBoolean a, Boolean b) => a._value.CompareTo(b) > 0; - public static Boolean operator <(JBoolean a, JBoolean b) => a._value.CompareTo(b._value) < 0; - public static Boolean operator <(Boolean a, JBoolean b) => a.CompareTo(b._value) < 0; - public static Boolean operator <(JBoolean a, Boolean b) => a._value.CompareTo(b) < 0; - public static Boolean operator >=(JBoolean a, JBoolean b) => a._value.CompareTo(b._value) > 0 || a.Equals(b._value); - public static Boolean operator >=(Boolean a, JBoolean b) => a.CompareTo(b._value) > 0 || a.Equals(b._value); - public static Boolean operator >=(JBoolean a, Boolean b) => a._value.CompareTo(b) > 0 || a._value.Equals(b); - public static Boolean operator <=(JBoolean a, JBoolean b) => a._value.CompareTo(b._value) < 0 || a.Equals(b._value); - public static Boolean operator <=(Boolean a, JBoolean b) => a.CompareTo(b._value) < 0 || a.Equals(b._value); - public static Boolean operator <=(JBoolean a, Boolean b) => a._value.CompareTo(b) < 0 || a._value.Equals(b); - #endregion - - #region Public Methods - public Int32 CompareTo(Boolean other) => this._value.CompareTo(other); - public Int32 CompareTo(JBoolean other) => this._value.CompareTo(other._value); - public Int32 CompareTo(Object obj) => obj is JBoolean jvalue ? this.CompareTo(jvalue) : obj is Boolean value ? this.CompareTo(value) : this._value.CompareTo(obj); - public Boolean Equals(Boolean other) => this._value.Equals(other); - public Boolean Equals(JBoolean other) => this._value.Equals(other._value); - public String ToString(IFormatProvider formatProvider) => this._value.ToString(formatProvider); - #endregion - - #region Overrided Methods - public override String ToString() => this._value.ToString(); - public override Boolean Equals(Object obj) => obj is JBoolean jvalue ? this.Equals(jvalue) : obj is Boolean value ? this.Equals(value) : this._value.Equals(obj); - public override Int32 GetHashCode() => this._value.GetHashCode(); - #endregion - } -} diff --git a/src/LibRyujinx/Jni/References/JArrayLocalRef.cs b/src/LibRyujinx/Jni/References/JArrayLocalRef.cs deleted file mode 100644 index 6501b4360..000000000 --- a/src/LibRyujinx/Jni/References/JArrayLocalRef.cs +++ /dev/null @@ -1,28 +0,0 @@ -using System.Diagnostics.CodeAnalysis; -using System; - -namespace LibRyujinx.Jni.References -{ - public readonly struct JArrayLocalRef : IEquatable - { -#pragma warning disable 0649 - private readonly JObjectLocalRef _value; -#pragma warning restore 0649 - - #region Public Methods - public Boolean Equals(JArrayLocalRef other) - => this._value.Equals(other._value); - #endregion - - #region Override Methods - public override Boolean Equals([NotNullWhen(true)] Object obj) - => obj is JArrayLocalRef other && this.Equals(other); - public override Int32 GetHashCode() => this._value.GetHashCode(); - #endregion - - #region Operators - public static Boolean operator ==(JArrayLocalRef a, JArrayLocalRef b) => a.Equals(b); - public static Boolean operator !=(JArrayLocalRef a, JArrayLocalRef b) => !a.Equals(b); - #endregion - } -} diff --git a/src/LibRyujinx/Jni/References/JClassLocalRef.cs b/src/LibRyujinx/Jni/References/JClassLocalRef.cs deleted file mode 100644 index 5880f5ddb..000000000 --- a/src/LibRyujinx/Jni/References/JClassLocalRef.cs +++ /dev/null @@ -1,28 +0,0 @@ -using System.Diagnostics.CodeAnalysis; -using System; - -namespace LibRyujinx.Jni.References -{ - public readonly struct JClassLocalRef : IEquatable - { -#pragma warning disable 0649 - public readonly JObjectLocalRef _value; -#pragma warning restore 0649 - - #region Public Methods - public Boolean Equals(JClassLocalRef other) - => this._value.Equals(other._value); - #endregion - - #region Override Methods - public override Boolean Equals([NotNullWhen(true)] Object obj) - => obj is JClassLocalRef other && this.Equals(other); - public override Int32 GetHashCode() => this._value.GetHashCode(); - #endregion - - #region Operators - public static Boolean operator ==(JClassLocalRef a, JClassLocalRef b) => a.Equals(b); - public static Boolean operator !=(JClassLocalRef a, JClassLocalRef b) => !a.Equals(b); - #endregion - } -} diff --git a/src/LibRyujinx/Jni/References/JGlobalRef.cs b/src/LibRyujinx/Jni/References/JGlobalRef.cs deleted file mode 100644 index 1befe7b94..000000000 --- a/src/LibRyujinx/Jni/References/JGlobalRef.cs +++ /dev/null @@ -1,28 +0,0 @@ -using System.Diagnostics.CodeAnalysis; -using System; - -namespace LibRyujinx.Jni.References -{ - public readonly struct JGlobalRef : IEquatable - { -#pragma warning disable 0649 - private readonly IntPtr _value; -#pragma warning restore 0649 - - #region Public Methods - public Boolean Equals(JGlobalRef other) - => this._value.Equals(other._value); - #endregion - - #region Override Methods - public override Boolean Equals([NotNullWhen(true)] Object obj) - => obj is JGlobalRef other && this.Equals(other); - public override Int32 GetHashCode() => this._value.GetHashCode(); - #endregion - - #region Operators - public static Boolean operator ==(JGlobalRef a, JGlobalRef b) => a.Equals(b); - public static Boolean operator !=(JGlobalRef a, JGlobalRef b) => !a.Equals(b); - #endregion - } -} diff --git a/src/LibRyujinx/Jni/References/JStringLocalRef.cs b/src/LibRyujinx/Jni/References/JStringLocalRef.cs deleted file mode 100644 index 002fd9942..000000000 --- a/src/LibRyujinx/Jni/References/JStringLocalRef.cs +++ /dev/null @@ -1,28 +0,0 @@ -using System.Diagnostics.CodeAnalysis; -using System; - -namespace LibRyujinx.Jni.References -{ - public readonly struct JStringLocalRef : IEquatable - { -#pragma warning disable 0649 - public readonly JObjectLocalRef _value; -#pragma warning restore 0649 - - #region Public Methods - public Boolean Equals(JStringLocalRef other) - => this._value.Equals(other._value); - #endregion - - #region Override Methods - public override Boolean Equals([NotNullWhen(true)] Object obj) - => obj is JStringLocalRef other && this.Equals(other); - public override Int32 GetHashCode() => this._value.GetHashCode(); - #endregion - - #region Operators - public static Boolean operator ==(JStringLocalRef a, JStringLocalRef b) => a.Equals(b); - public static Boolean operator !=(JStringLocalRef a, JStringLocalRef b) => !a.Equals(b); - #endregion - } -} diff --git a/src/LibRyujinx/Jni/References/JThrowableLocalRef.cs b/src/LibRyujinx/Jni/References/JThrowableLocalRef.cs deleted file mode 100644 index a7e5e3b40..000000000 --- a/src/LibRyujinx/Jni/References/JThrowableLocalRef.cs +++ /dev/null @@ -1,28 +0,0 @@ -using System.Diagnostics.CodeAnalysis; -using System; - -namespace LibRyujinx.Jni.References -{ - public readonly struct JThrowableLocalRef : IEquatable - { -#pragma warning disable 0649 - private readonly IntPtr _value; -#pragma warning restore 0649 - - #region Public Methods - public Boolean Equals(JThrowableLocalRef other) - => this._value.Equals(other._value); - #endregion - - #region Override Methods - public override Boolean Equals([NotNullWhen(true)] Object obj) - => obj is JThrowableLocalRef other && this.Equals(other); - public override Int32 GetHashCode() => this._value.GetHashCode(); - #endregion - - #region Operators - public static Boolean operator ==(JThrowableLocalRef a, JThrowableLocalRef b) => a.Equals(b); - public static Boolean operator !=(JThrowableLocalRef a, JThrowableLocalRef b) => !a.Equals(b); - #endregion - } -} diff --git a/src/LibRyujinx/Jni/References/JWeakRef.cs b/src/LibRyujinx/Jni/References/JWeakRef.cs deleted file mode 100644 index 9572c6035..000000000 --- a/src/LibRyujinx/Jni/References/JWeakRef.cs +++ /dev/null @@ -1,28 +0,0 @@ -using System.Diagnostics.CodeAnalysis; -using System; - -namespace LibRyujinx.Jni.References -{ - public readonly struct JWeakRef : IEquatable - { -#pragma warning disable 0649 - private readonly IntPtr _value; -#pragma warning restore 0649 - - #region Public Methods - public Boolean Equals(JWeakRef other) - => this._value.Equals(other._value); - #endregion - - #region Override Methods - public override Boolean Equals([NotNullWhen(true)] Object obj) - => obj is JWeakRef other && this.Equals(other); - public override Int32 GetHashCode() => this._value.GetHashCode(); - #endregion - - #region Operators - public static Boolean operator ==(JWeakRef a, JWeakRef b) => a.Equals(b); - public static Boolean operator !=(JWeakRef a, JWeakRef b) => !a.Equals(b); - #endregion - } -} diff --git a/src/LibRyujinx/Jni/Values/JNativeInterface.cs b/src/LibRyujinx/Jni/Values/JNativeInterface.cs deleted file mode 100644 index b3aa132ec..000000000 --- a/src/LibRyujinx/Jni/Values/JNativeInterface.cs +++ /dev/null @@ -1,245 +0,0 @@ -using System.Diagnostics.CodeAnalysis; -using System; - -namespace LibRyujinx.Jni.Values -{ - [SuppressMessage("CodeQuality", "IDE0051:Remove unused private members", Justification = "This struct is created only by binary operations.")] - public readonly struct JNativeInterface - { -#pragma warning disable 0169 - private readonly IntPtr _reserved0; - private readonly IntPtr _reserved1; - private readonly IntPtr _reserved2; - private readonly IntPtr _reserved3; -#pragma warning restore 0169 - internal readonly IntPtr GetVersionPointer { get; init; } - internal readonly IntPtr DefineClassPointer { get; init; } - internal readonly IntPtr FindClassPointer { get; init; } - internal readonly IntPtr FromReflectedMethodPointer { get; init; } - internal readonly IntPtr FromReflectedFieldPointer { get; init; } - internal readonly IntPtr ToReflectedMethodPointer { get; init; } - internal readonly IntPtr GetSuperclassPointer { get; init; } - internal readonly IntPtr IsAssignableFromPointer { get; init; } - internal readonly IntPtr ToReflectedFieldPointer { get; init; } - internal readonly IntPtr ThrowPointer { get; init; } - internal readonly IntPtr ThrowNewPointer { get; init; } - internal readonly IntPtr ExceptionOccurredPointer { get; init; } - internal readonly IntPtr ExceptionDescribePointer { get; init; } - internal readonly IntPtr ExceptionClearPointer { get; init; } - internal readonly IntPtr FatalErrorPointer { get; init; } - internal readonly IntPtr PushLocalFramePointer { get; init; } - internal readonly IntPtr PopLocalFramePointer { get; init; } - internal readonly IntPtr NewGlobalRefPointer { get; init; } - internal readonly IntPtr DeleteGlobalRefPointer { get; init; } - internal readonly IntPtr DeleteLocalRefPointer { get; init; } - internal readonly IntPtr IsSameObjectPointer { get; init; } - internal readonly IntPtr NewLocalRefPointer { get; init; } - internal readonly IntPtr EnsureLocalCapacityPointer { get; init; } - internal readonly IntPtr AllocObjectPointer { get; init; } - internal readonly IntPtr NewObjectPointer { get; init; } - internal readonly IntPtr NewObjectVPointer { get; init; } - internal readonly IntPtr NewObjectAPointer { get; init; } - internal readonly IntPtr GetObjectClassPointer { get; init; } - internal readonly IntPtr IsInstanceOfPointer { get; init; } - internal readonly IntPtr GetMethodIdPointer { get; init; } - internal readonly IntPtr CallObjectMethodPointer { get; init; } - internal readonly IntPtr CallObjectMethodVPointer { get; init; } - internal readonly IntPtr CallObjectMethodAPointer { get; init; } - internal readonly IntPtr CallBooleanMethodPointer { get; init; } - internal readonly IntPtr CallBooleanMethodVPointer { get; init; } - internal readonly IntPtr CallBooleanMethodAPointer { get; init; } - internal readonly IntPtr CallByteMethodPointer { get; init; } - internal readonly IntPtr CallByteMethodVPointer { get; init; } - internal readonly IntPtr CallByteMethodAPointer { get; init; } - internal readonly IntPtr CallCharMethodPointer { get; init; } - internal readonly IntPtr CallCharMethodVPointer { get; init; } - internal readonly IntPtr CallCharMethodAPointer { get; init; } - internal readonly IntPtr CallShortMethodPointer { get; init; } - internal readonly IntPtr CallShortMethodVPointer { get; init; } - internal readonly IntPtr CallShortMethodAPointer { get; init; } - internal readonly IntPtr CallIntMethodPointer { get; init; } - internal readonly IntPtr CallIntMethodVPointer { get; init; } - internal readonly IntPtr CallIntMethodAPointer { get; init; } - internal readonly IntPtr CallLongMethodPointer { get; init; } - internal readonly IntPtr CallLongMethodVPointer { get; init; } - internal readonly IntPtr CallLongMethodAPointer { get; init; } - internal readonly IntPtr CallFloatMethodPointer { get; init; } - internal readonly IntPtr CallFloatMethodVPointer { get; init; } - internal readonly IntPtr CallFloatMethodAPointer { get; init; } - internal readonly IntPtr CallDoubleMethodPointer { get; init; } - internal readonly IntPtr CallDoubleMethodVPointer { get; init; } - internal readonly IntPtr CallDoubleMethodAPointer { get; init; } - internal readonly IntPtr CallVoidMethodPointer { get; init; } - internal readonly IntPtr CallVoidMethodVPointer { get; init; } - internal readonly IntPtr CallVoidMethodAPointer { get; init; } - internal readonly IntPtr CallNonVirtualObjectMethodPointer { get; init; } - internal readonly IntPtr CallNonVirtualObjectMethodVPointer { get; init; } - internal readonly IntPtr CallNonVirtualObjectMethodAPointer { get; init; } - internal readonly IntPtr CallNonVirtualBooleanMethodPointer { get; init; } - internal readonly IntPtr CallNonVirtualBooleanMethodVPointer { get; init; } - internal readonly IntPtr CallNonVirtualBooleanMethodAPointer { get; init; } - internal readonly IntPtr CallNonVirtualByteMethodPointer { get; init; } - internal readonly IntPtr CallNonVirtualByteMethodVPointer { get; init; } - internal readonly IntPtr CallNonVirtualByteMethodAPointer { get; init; } - internal readonly IntPtr CallNonVirtualCharMethodPointer { get; init; } - internal readonly IntPtr CallNonVirtualCharMethodVPointer { get; init; } - internal readonly IntPtr CallNonVirtualCharMethodAPointer { get; init; } - internal readonly IntPtr CallNonVirtualShortMethodPointer { get; init; } - internal readonly IntPtr CallNonVirtualShortMethodVPointer { get; init; } - internal readonly IntPtr CallNonVirtualShortMethodAPointer { get; init; } - internal readonly IntPtr CallNonVirtualIntMethodPointer { get; init; } - internal readonly IntPtr CallNonVirtualIntMethodVPointer { get; init; } - internal readonly IntPtr CallNonVirtualIntMethodAPointer { get; init; } - internal readonly IntPtr CallNonVirtualLongMethodPointer { get; init; } - internal readonly IntPtr CallNonVirtualLongMethodVPointer { get; init; } - internal readonly IntPtr CallNonVirtualLongMethodAPointer { get; init; } - internal readonly IntPtr CallNonVirtualFloatMethodPointer { get; init; } - internal readonly IntPtr CallNonVirtualFloatMethodVPointer { get; init; } - internal readonly IntPtr CallNonVirtualFloatMethodAPointer { get; init; } - internal readonly IntPtr CallNonVirtualDoubleMethodPointer { get; init; } - internal readonly IntPtr CallNonVirtualDoubleMethodVPointer { get; init; } - internal readonly IntPtr CallNonVirtualDoubleMethodAPointer { get; init; } - internal readonly IntPtr CallNonVirtualVoidMethodPointer { get; init; } - internal readonly IntPtr CallNonVirtualVoidMethodVPointer { get; init; } - internal readonly IntPtr CallNonVirtualVoidMethodAPointer { get; init; } - internal readonly IntPtr GetFieldIdPointer { get; init; } - internal readonly IntPtr GetObjectFieldPointer { get; init; } - internal readonly IntPtr GetBooleanFieldPointer { get; init; } - internal readonly IntPtr GetByteFieldPointer { get; init; } - internal readonly IntPtr GetCharFieldPointer { get; init; } - internal readonly IntPtr GetShortFieldPointer { get; init; } - internal readonly IntPtr GetIntFieldPointer { get; init; } - internal readonly IntPtr GetLongFieldPointer { get; init; } - internal readonly IntPtr GetFloatFieldPointer { get; init; } - internal readonly IntPtr GetDoubleFieldPointer { get; init; } - internal readonly IntPtr SetObjectFieldPointer { get; init; } - internal readonly IntPtr SetBooleanFieldPointer { get; init; } - internal readonly IntPtr SetByteFieldPointer { get; init; } - internal readonly IntPtr SetCharFieldPointer { get; init; } - internal readonly IntPtr SetShortFieldPointer { get; init; } - internal readonly IntPtr SetIntFieldPointer { get; init; } - internal readonly IntPtr SetLongFieldPointer { get; init; } - internal readonly IntPtr SetFloatFieldPointer { get; init; } - internal readonly IntPtr SetDoubleFieldPointer { get; init; } - internal readonly IntPtr GetStaticMethodIdPointer { get; init; } - internal readonly IntPtr CallStaticObjectMethodPointer { get; init; } - internal readonly IntPtr CallStaticObjectMethodVPointer { get; init; } - internal readonly IntPtr CallStaticObjectMethodAPointer { get; init; } - internal readonly IntPtr CallStaticBooleanMethodPointer { get; init; } - internal readonly IntPtr CallStaticBooleanMethodVPointer { get; init; } - internal readonly IntPtr CallStaticBooleanMethodAPointer { get; init; } - internal readonly IntPtr CallStaticByteMethodPointer { get; init; } - internal readonly IntPtr CallStaticByteMethodVPointer { get; init; } - internal readonly IntPtr CallStaticByteMethodAPointer { get; init; } - internal readonly IntPtr CallStaticCharMethodPointer { get; init; } - internal readonly IntPtr CallStaticCharMethodVPointer { get; init; } - internal readonly IntPtr CallStaticCharMethodAPointer { get; init; } - internal readonly IntPtr CallStaticShortMethodPointer { get; init; } - internal readonly IntPtr CallStaticShortMethodVPointer { get; init; } - internal readonly IntPtr CallStaticShortMethodAPointer { get; init; } - internal readonly IntPtr CallStaticIntMethodPointer { get; init; } - internal readonly IntPtr CallStaticIntMethodVPointer { get; init; } - internal readonly IntPtr CallStaticIntMethodAPointer { get; init; } - internal readonly IntPtr CallStaticLongMethodPointer { get; init; } - internal readonly IntPtr CallStaticLongMethodVPointer { get; init; } - internal readonly IntPtr CallStaticLongMethodAPointer { get; init; } - internal readonly IntPtr CallStaticFloatMethodPointer { get; init; } - internal readonly IntPtr CallStaticFloatMethodVPointer { get; init; } - internal readonly IntPtr CallStaticFloatMethodAPointer { get; init; } - internal readonly IntPtr CallStaticDoubleMethodPointer { get; init; } - internal readonly IntPtr CallStaticDoubleMethodVPointer { get; init; } - internal readonly IntPtr CallStaticDoubleMethodAPointer { get; init; } - internal readonly IntPtr CallStaticVoidMethodPointer { get; init; } - internal readonly IntPtr CallStaticVoidMethodVPointer { get; init; } - internal readonly IntPtr CallStaticVoidMethodAPointer { get; init; } - internal readonly IntPtr GetStaticFieldIdPointer { get; init; } - internal readonly IntPtr GetStaticObjectFieldPointer { get; init; } - internal readonly IntPtr GetStaticBooleanFieldPointer { get; init; } - internal readonly IntPtr GetStaticByteFieldPointer { get; init; } - internal readonly IntPtr GetStaticCharFieldPointer { get; init; } - internal readonly IntPtr GetStaticShortFieldPointer { get; init; } - internal readonly IntPtr GetStaticIntFieldPointer { get; init; } - internal readonly IntPtr GetStaticLongFieldPointer { get; init; } - internal readonly IntPtr GetStaticFloatFieldPointer { get; init; } - internal readonly IntPtr GetStaticDoubleFieldPointer { get; init; } - internal readonly IntPtr SetStaticObjectFieldPointer { get; init; } - internal readonly IntPtr SetStaticBooleanFieldPointer { get; init; } - internal readonly IntPtr SetStaticByteFieldPointer { get; init; } - internal readonly IntPtr SetStaticCharFieldPointer { get; init; } - internal readonly IntPtr SetStaticShortFieldPointer { get; init; } - internal readonly IntPtr SetStaticIntFieldPointer { get; init; } - internal readonly IntPtr SetStaticLongFieldPointer { get; init; } - internal readonly IntPtr SetStaticFloatFieldPointer { get; init; } - internal readonly IntPtr SetStaticDoubleFieldPointer { get; init; } - internal readonly IntPtr NewStringPointer { get; init; } - internal readonly IntPtr GetStringLengthPointer { get; init; } - internal readonly IntPtr GetStringCharsPointer { get; init; } - internal readonly IntPtr ReleaseStringCharsPointer { get; init; } - internal readonly IntPtr NewStringUtfPointer { get; init; } - internal readonly IntPtr GetStringUtfLengthPointer { get; init; } - internal readonly IntPtr GetStringUtfCharsPointer { get; init; } - internal readonly IntPtr ReleaseStringUtfCharsPointer { get; init; } - internal readonly IntPtr GetArrayLengthPointer { get; init; } - internal readonly IntPtr NewObjectArrayPointer { get; init; } - internal readonly IntPtr GetObjectArrayElementPointer { get; init; } - internal readonly IntPtr SetObjectArrayElementPointer { get; init; } - internal readonly IntPtr NewBooleanArrayPointer { get; init; } - internal readonly IntPtr NewByteArrayPointer { get; init; } - internal readonly IntPtr NewCharArrayPointer { get; init; } - internal readonly IntPtr NewShortArrayPointer { get; init; } - internal readonly IntPtr NewIntArrayPointer { get; init; } - internal readonly IntPtr NewLongArrayPointer { get; init; } - internal readonly IntPtr NewFloatArrayPointer { get; init; } - internal readonly IntPtr NewDoubleArrayPointer { get; init; } - internal readonly IntPtr GetBooleanArrayElementsPointer { get; init; } - internal readonly IntPtr GetByteArrayElementsPointer { get; init; } - internal readonly IntPtr GetCharArrayElementsPointer { get; init; } - internal readonly IntPtr GetShortArrayElementsPointer { get; init; } - internal readonly IntPtr GetIntArrayElementsPointer { get; init; } - internal readonly IntPtr GetLongArrayElementsPointer { get; init; } - internal readonly IntPtr GetFloatArrayElementsPointer { get; init; } - internal readonly IntPtr GetDoubleArrayElementsPointer { get; init; } - internal readonly IntPtr ReleaseBooleanArrayElementsPointer { get; init; } - internal readonly IntPtr ReleaseByteArrayElementsPointer { get; init; } - internal readonly IntPtr ReleaseCharArrayElementsPointer { get; init; } - internal readonly IntPtr ReleaseShortArrayElementsPointer { get; init; } - internal readonly IntPtr ReleaseIntArrayElementsPointer { get; init; } - internal readonly IntPtr ReleaseLongArrayElementsPointer { get; init; } - internal readonly IntPtr ReleaseFloatArrayElementsPointer { get; init; } - internal readonly IntPtr ReleaseDoubleArrayElementsPointer { get; init; } - internal readonly IntPtr GetBooleanArrayRegionPointer { get; init; } - internal readonly IntPtr GetByteArrayRegionPointer { get; init; } - internal readonly IntPtr GetCharArrayRegionPointer { get; init; } - internal readonly IntPtr GetShortArrayRegionPointer { get; init; } - internal readonly IntPtr GetIntArrayRegionPointer { get; init; } - internal readonly IntPtr GetLongArrayRegionPointer { get; init; } - internal readonly IntPtr GetFloatArrayRegionPointer { get; init; } - internal readonly IntPtr GetDoubleArrayRegionPointer { get; init; } - internal readonly IntPtr SetBooleanArrayRegionPointer { get; init; } - internal readonly IntPtr SetByteArrayRegionPointer { get; init; } - internal readonly IntPtr SetCharArrayRegionPointer { get; init; } - internal readonly IntPtr SetShortArrayRegionPointer { get; init; } - internal readonly IntPtr SetIntArrayRegionPointer { get; init; } - internal readonly IntPtr SetLongArrayRegionPointer { get; init; } - internal readonly IntPtr SetFloatArrayRegionPointer { get; init; } - internal readonly IntPtr SetDoubleArrayRegionPointer { get; init; } - internal readonly IntPtr RegisterNativesPointer { get; init; } - internal readonly IntPtr UnregisterNativesPointer { get; init; } - internal readonly IntPtr MonitorEnterPointer { get; init; } - internal readonly IntPtr MonitorExitPointer { get; init; } - internal readonly IntPtr GetJavaVMPointer { get; init; } - internal readonly IntPtr GetStringRegionPointer { get; init; } - internal readonly IntPtr GetStringUtfRegionPointer { get; init; } - internal readonly IntPtr GetPrimitiveArrayCriticalPointer { get; init; } - internal readonly IntPtr ReleasePrimitiveArrayCriticalPointer { get; init; } - internal readonly IntPtr GetStringCriticalPointer { get; init; } - internal readonly IntPtr ReleaseStringCriticalPointer { get; init; } - internal readonly IntPtr NewWeakGlobalRefPointer { get; init; } - internal readonly IntPtr DeleteWeakGlobalRefPointer { get; init; } - internal readonly IntPtr ExceptionCheckPointer { get; init; } - internal readonly IntPtr NewDirectByteBufferPointer { get; init; } - internal readonly IntPtr GetDirectBufferAddressPointer { get; init; } - internal readonly IntPtr GetDirectBufferCapacityPointer { get; init; } - internal readonly IntPtr GetObjectRefTypePointer { get; init; } - } -} diff --git a/src/LibRyujinx/Jni/Values/JNativeMethod.cs b/src/LibRyujinx/Jni/Values/JNativeMethod.cs deleted file mode 100644 index 10315071e..000000000 --- a/src/LibRyujinx/Jni/Values/JNativeMethod.cs +++ /dev/null @@ -1,12 +0,0 @@ -using LibRyujinx.Jni.Pointers; -using System; - -namespace LibRyujinx.Jni.Values -{ - public readonly struct JNativeMethod - { - internal CCharSequence Name { get; init; } - internal CCharSequence Signature { get; init; } - internal IntPtr Pointer { get; init; } - } -} diff --git a/src/LibRyujinx/Jni/Values/JValue.cs b/src/LibRyujinx/Jni/Values/JValue.cs deleted file mode 100644 index f6fadd199..000000000 --- a/src/LibRyujinx/Jni/Values/JValue.cs +++ /dev/null @@ -1,47 +0,0 @@ -using System.Runtime.CompilerServices; - -using Rxmxnx.PInvoke; -using System; - -namespace LibRyujinx.Jni.Values -{ - internal readonly struct JValue - { - private delegate Boolean IsDefaultDelegate(in JValue value); - - public static readonly Int32 Size = NativeUtilities.SizeOf(); - - private static readonly IsDefaultDelegate isDefault = GetIsDefault(); - -#pragma warning disable 0649 -#pragma warning disable 0169 - private readonly Byte _value1; - private readonly Byte _value2; - private readonly Int16 _value3; - private readonly Int32 _value4; -#pragma warning restore 0169 -#pragma warning restore 0649 - - public Boolean IsDefault => isDefault(this); - - public static JValue Create(in ReadOnlySpan source) - { - Byte[] result = new Byte[Size]; - for (Int32 i = 0; i < source.Length; i++) - result[i] = source[i]; - return result.ToValue(); - } - - private static IsDefaultDelegate GetIsDefault() => Environment.Is64BitProcess ? DefaultLong : Default; - - private static Boolean Default(in JValue jValue) - => (jValue._value1 + jValue._value2 + jValue._value3) == default - && jValue._value4 == default; - - private static Boolean DefaultLong(in JValue jValue) - { - var jv = jValue; - return Unsafe.AsRef(ref jv).Transform() == default; - } - } -} diff --git a/src/LibRyujinx/Jni/Values/JavaVMAttachArgs.cs b/src/LibRyujinx/Jni/Values/JavaVMAttachArgs.cs deleted file mode 100644 index d8b827c4d..000000000 --- a/src/LibRyujinx/Jni/Values/JavaVMAttachArgs.cs +++ /dev/null @@ -1,13 +0,0 @@ -using LibRyujinx.Jni.Pointers; -using LibRyujinx.Jni.References; -using System; - -namespace LibRyujinx.Jni.Values -{ - public readonly struct JavaVMAttachArgs - { - internal Int32 Version { get; init; } - internal CCharSequence Name { get; init; } - internal JObjectLocalRef Group { get; init; } - } -} diff --git a/src/LibRyujinx/Jni/Values/JavaVMOption.cs b/src/LibRyujinx/Jni/Values/JavaVMOption.cs deleted file mode 100644 index 153fc64c3..000000000 --- a/src/LibRyujinx/Jni/Values/JavaVMOption.cs +++ /dev/null @@ -1,11 +0,0 @@ -using LibRyujinx.Jni.Pointers; -using System; - -namespace LibRyujinx.Jni.Values -{ - public readonly struct JavaVMOption - { - internal CCharSequence Name { get; init; } - internal IntPtr ExtraInfo { get; init; } - } -} diff --git a/src/LibRyujinx/LibRyujinx.csproj b/src/LibRyujinx/LibRyujinx.csproj index 8bbbfbd98..45ad7d359 100644 --- a/src/LibRyujinx/LibRyujinx.csproj +++ b/src/LibRyujinx/LibRyujinx.csproj @@ -34,22 +34,22 @@ - - + + - + - + - + @@ -73,7 +73,4 @@ - - -