How to attach jpype to a JVM launched with ctypes

[Lqm1]

I use ctypes to manually launch the JVM. This is because JNIEnv* is required and JNI functions in the so file must be called directly.
Because the JVM rules only allow one to be started at a time, you get a -5 error.

I have two questions.
1, Can jpype be linked to a JVM launched by ctypes?
2, Is it possible to get JNIEnv* from a JVM started by jpype?

[Thrameos]

1. You would likely need a custom extension module to get to the JPype internals, but yes both are possible. There is a pattern for android in which the JVM is launched completely externally of JPype that you can use though I am not sure if it is built into the default. Copy the pattern and call the bootstrap hook which launches all the JPype resources and JPype will run in environments like ctypes and jep. However, in the case of jep has its own wrapper types so I doubt they would play particularly nicely.

The hook point you would need in your external module would need to match something like this

`#ifdef ANDROID

static PyObject *PyJPModule_bootstrap(PyObject *module)
{
    // After all the internals are created we can connect the API with the internal module
    JNIEnv * env = Android_JNI_GetEnv();
    JPContext_global->attachJVM(env);
    PyJPModule_installGC(module);
    PyJPModule_loadResources(module);
    Py_RETURN_NONE;
}
#endif

You may want to remove the if statement so that it assumes attachJVM is always embedded. I don't recall why we needed special logic here.

void JPContext::attachJVM(JNIEnv* env)
{
    env->GetJavaVM(&m_JavaVM);
#ifndef ANDROID
    m_Embedded = true;
#endif
    initializeResources(env, false);
}

The downsides of this is... the reason the attach to existing JVM has not been tested is no one has ever supplied use with scripts that successfully launch the JVM outside of JPype then attempt to activate it. If you are willing to contribute such scripts that I can include all the hooks you require in 1.6.

2. If you just need to get to the JNIEnv then you can likely do so just using JNI calls completely outside of the JPype. Once the JVM is started by JPype, the Java method JNI_CreateJavaVM will provide you with all the JVM information you need. There is no need to go mucking in our internals. If you do need to get it is start with the exposed C++ object JPContext_global which exposes the methods getEnv() and getJavaVM().

[Thrameos]

I believe the second one is likely more compatible with your requirements. Launching JPype manually would require a bit of work. Letting it start then getting the JNIEnv from it likely would do what you want.

JPype has full support for seamless transfers of buffers and arrays. So mapping bytes to byte[] should be straightforward. If you need special interpretation of the bytes pass them through a numpy array so that you can set types, byte order, shape, etc. (bytes to float[], short[], int[]. long[]. double[], int[][], float16->float[], etc)

[Lqm1]

Excuse me, I have an additional question.
Can you tell me specifically how to access JPContext_global? I looked for it, but I couldn't find it.

[Thrameos]

It is an exported symbol in JPype module. Unfortunately it is a C++ structure so it may be hard to forward declare. What part of the context do you need to access?

[Lqm1]

I want to call "getEnv()" to get "JNIEnv*".

[Thrameos]

I gave the solution in another answer to how to get the JNIEnv. However, I would say that your effort is likely doomed without serious knowledge of JNI. As an expert it took me 3 hours chatting with an AI getting wrong answers to realize that it forgot that there was a functions structure. Worse to properly manage memory you would need to know and wrap all of the details of the Java frame construct or your references will just disappear out from under you. (To be honest I can't even tell if it is possible, as all I managed to do was get the version to print).

Next up you would need to use code like this....

// Get the env from JPContent_global
PyObject* env(PyObject *module, PyObject *other)
{
    if (JPContext_global == nullptr)
        Py_RETURN_NONE;
    return PyLong_FromVoidPtr(JPContext_global->getEnv());
}

to the numerous types in JPype such as array such that you can then cast.

For example to get to the jarray, you would need

static Py_ssize_t PyJPArray_java(PyJPArray *self)
{
    JP_PY_TRY("PyJPArray_java");
    if (self->m_Array == nullptr)
        JP_RAISE(PyExc_ValueError, "Null array"); // GCOVR_EXCL_LINE
    return PyLong_FromVoidPtr(self->m_Array->getJava());
    JP_PY_CATCH(-1);
}

static PyGetSetDef arrayGetSets[] = {
    {"length", (getter) (&PyJPArray_length), nullptr, (length_doc)},
    {"__java__", (getter) (&PyJPArray_java), nullptr, nullptr},
    {nullptr}
};

This would allow you to run code like this

import jpype
jpype.startJVM()

a = jpype.JInt[10]
ja = ctypes.cast(a, jarray)

So technically doable, but I would guess well above most coders skill level.

[Thrameos]

The way to access JNIEnv from ctypes using JPype would be the following....

import jpype
import ctypes
from ctypes import POINTER, byref, c_void_p, c_int, c_char_p
import os

jpype.startJVM()

########################################
# PAIN STARTS HERE

# Define JNI constants
JNI_VERSION_1_6 = 0x00010006

# libjvm was already loaded
libjvm = ctypes.CDLL(None)  # Access already loaded library

# Define JavaVMAttachArgs structure
class JavaVMAttachArgs(ctypes.Structure):
    _fields_ = [
        ("version", c_int),
        ("name", c_char_p),
        ("group", c_void_p)
    ]

# Define JNI types
jint = ctypes.c_int
jlong = ctypes.c_longlong
jfloat = ctypes.c_float
jdouble = ctypes.c_double
jboolean = ctypes.c_ubyte
jbyte = ctypes.c_byte
jchar = ctypes.c_ushort
jshort = ctypes.c_short
jvalue = ctypes.c_void_p  # Placeholder for union type
jobject = ctypes.c_void_p
jclass = jobject
jstring = jobject
jarray = jobject
jthrowable = jobject
jmethodID = ctypes.c_void_p
jfieldID = ctypes.c_void_p

# Define the JNIEnv structure
class JNINativeInterface(ctypes.Structure):
    pass
class JNIEnv(ctypes.Structure):
    _fields_ = [
        ("functions", ctypes.POINTER(JNINativeInterface))  # Pointer to the function table
    ]
JNIEnv_p = ctypes.POINTER(JNIEnv)
JNINativeInterface._fields_ = [
        # Reserved fields
        ("reserved0", ctypes.c_void_p),
        ("reserved1", ctypes.c_void_p),
        ("reserved2", ctypes.c_void_p),
        ("reserved3", ctypes.c_void_p),

        # JNI functions
        ("GetVersion", ctypes.CFUNCTYPE(jint, JNIEnv_p)),
        ("DefineClass", ctypes.CFUNCTYPE(jclass, JNIEnv_p, ctypes.c_char_p, jobject, ctypes.POINTER(ctypes.c_byte), jint)),
        ("FindClass", ctypes.CFUNCTYPE(jclass, JNIEnv_p, ctypes.c_char_p)),
        ("FromReflectedMethod", ctypes.CFUNCTYPE(jmethodID, JNIEnv_p, jobject)),
        ("FromReflectedField", ctypes.CFUNCTYPE(jfieldID, JNIEnv_p, jobject)),
        ("ToReflectedMethod", ctypes.CFUNCTYPE(jobject, JNIEnv_p, jclass, jmethodID, jboolean)),
        ("GetSuperclass", ctypes.CFUNCTYPE(jclass, JNIEnv_p, jclass)),
        ("IsAssignableFrom", ctypes.CFUNCTYPE(jboolean, JNIEnv_p, jclass, jclass)),
        ("ToReflectedField", ctypes.CFUNCTYPE(jobject, JNIEnv_p, jclass, jfieldID, jboolean)),
        ("Throw", ctypes.CFUNCTYPE(jint, JNIEnv_p, jthrowable)),
        ("ThrowNew", ctypes.CFUNCTYPE(jint, JNIEnv_p, jclass, ctypes.c_char_p)),
                ("ExceptionOccurred", ctypes.CFUNCTYPE(jthrowable, JNIEnv_p)),
        ("ExceptionDescribe", ctypes.CFUNCTYPE(None, JNIEnv_p)),
        ("ExceptionClear", ctypes.CFUNCTYPE(None, JNIEnv_p)),
        ("FatalError", ctypes.CFUNCTYPE(None, JNIEnv_p, ctypes.c_char_p)),
        ("PushLocalFrame", ctypes.CFUNCTYPE(jint, JNIEnv_p, jint)),
        ("PopLocalFrame", ctypes.CFUNCTYPE(jobject, JNIEnv_p, jobject)),
        ("NewGlobalRef", ctypes.CFUNCTYPE(jobject, JNIEnv_p, jobject)),
        ("DeleteGlobalRef", ctypes.CFUNCTYPE(None, JNIEnv_p, jobject)),
        ("DeleteLocalRef", ctypes.CFUNCTYPE(None, JNIEnv_p, jobject)),
        ("IsSameObject", ctypes.CFUNCTYPE(jboolean, JNIEnv_p, jobject, jobject)),
        ("NewLocalRef", ctypes.CFUNCTYPE(jobject, JNIEnv_p, jobject)),
        ("EnsureLocalCapacity", ctypes.CFUNCTYPE(jint, JNIEnv_p, jint)),
        ("AllocObject", ctypes.CFUNCTYPE(jobject, JNIEnv_p, jclass)),
        ("NewObject", ctypes.CFUNCTYPE(jobject, JNIEnv_p, jclass, jmethodID)),
        ("NewObjectV", ctypes.CFUNCTYPE(jobject, JNIEnv_p, jclass, jmethodID, JNIEnv_p)),
        ("NewObjectA", ctypes.CFUNCTYPE(jobject, JNIEnv_p, jclass, jmethodID, ctypes.POINTER(jvalue))),
        ("GetObjectClass", ctypes.CFUNCTYPE(jclass, JNIEnv_p, jobject)),
        ("IsInstanceOf", ctypes.CFUNCTYPE(jboolean, JNIEnv_p, jobject, jclass)),
        ("GetMethodID", ctypes.CFUNCTYPE(jmethodID, JNIEnv_p, jclass, ctypes.c_char_p, ctypes.c_char_p)),
        ("CallObjectMethod", ctypes.CFUNCTYPE(jobject, JNIEnv_p, jobject, jmethodID)),
        ("CallObjectMethodV", ctypes.CFUNCTYPE(jobject, JNIEnv_p, jobject, jmethodID, JNIEnv_p)),
        ("CallObjectMethodA", ctypes.CFUNCTYPE(jobject, JNIEnv_p, jobject, jmethodID, ctypes.POINTER(jvalue))),
        ("CallBooleanMethod", ctypes.CFUNCTYPE(jboolean, JNIEnv_p, jobject, jmethodID)),
        ("CallBooleanMethodV", ctypes.CFUNCTYPE(jboolean, JNIEnv_p, jobject, jmethodID, JNIEnv_p)),
        ("CallBooleanMethodA", ctypes.CFUNCTYPE(jboolean, JNIEnv_p, jobject, jmethodID, ctypes.POINTER(jvalue))),
        ("CallIntMethod", ctypes.CFUNCTYPE(jint, JNIEnv_p, jobject, jmethodID)),
        ("CallIntMethodV", ctypes.CFUNCTYPE(jint, JNIEnv_p, jobject, jmethodID, JNIEnv_p)),
        ("CallIntMethodA", ctypes.CFUNCTYPE(jint, JNIEnv_p, jobject, jmethodID, ctypes.POINTER(jvalue))),
        ("CallDoubleMethod", ctypes.CFUNCTYPE(jdouble, JNIEnv_p, jobject, jmethodID)),
        ("CallDoubleMethodV", ctypes.CFUNCTYPE(jdouble, JNIEnv_p, jobject, jmethodID, JNIEnv_p)),
        ("CallDoubleMethodA", ctypes.CFUNCTYPE(jdouble, JNIEnv_p, jobject, jmethodID, ctypes.POINTER(jvalue))),
        ("CallVoidMethod", ctypes.CFUNCTYPE(None, JNIEnv_p, jobject, jmethodID)),
        ("CallVoidMethodV", ctypes.CFUNCTYPE(None, JNIEnv_p, jobject, jmethodID, JNIEnv_p)),
        ( "CallVoidMethodA", ctypes.CFUNCTYPE(None, JNIEnv_p, jobject, jmethodID, ctypes.POINTER(jvalue))),

        # Field access methods
        ("GetFieldID", ctypes.CFUNCTYPE(jfieldID, JNIEnv_p, jclass, ctypes.c_char_p, ctypes.c_char_p)),
        ("GetObjectField", ctypes.CFUNCTYPE(jobject, JNIEnv_p, jobject, jfieldID)),
        ("GetBooleanField", ctypes.CFUNCTYPE(jboolean, JNIEnv_p, jobject, jfieldID)),
        ("GetByteField", ctypes.CFUNCTYPE(jbyte, JNIEnv_p, jobject, jfieldID)),
        ("GetCharField", ctypes.CFUNCTYPE(jchar, JNIEnv_p, jobject, jfieldID)),
        ("GetShortField", ctypes.CFUNCTYPE(jshort, JNIEnv_p, jobject, jfieldID)),
        ("GetIntField", ctypes.CFUNCTYPE(jint, JNIEnv_p, jobject, jfieldID)),
        ("GetLongField", ctypes.CFUNCTYPE(jlong, JNIEnv_p, jobject, jfieldID)),
        ("GetFloatField", ctypes.CFUNCTYPE(jfloat, JNIEnv_p, jobject, jfieldID)),
        ("GetDoubleField", ctypes.CFUNCTYPE(jdouble, JNIEnv_p, jobject, jfieldID)),
        ("SetObjectField", ctypes.CFUNCTYPE(None, JNIEnv_p, jobject, jfieldID, jobject)),
        ("SetBooleanField", ctypes.CFUNCTYPE(None, JNIEnv_p, jobject, jfieldID, jboolean)),
        ("SetByteField", ctypes.CFUNCTYPE(None, JNIEnv_p, jobject, jfieldID, jbyte)),
        ("SetCharField", ctypes.CFUNCTYPE(None, JNIEnv_p, jobject, jfieldID, jchar)),
        ("SetShortField", ctypes.CFUNCTYPE(None, JNIEnv_p, jobject, jfieldID, jshort)),
        ("SetIntField", ctypes.CFUNCTYPE(None, JNIEnv_p, jobject, jfieldID, jint)),
        ("SetLongField", ctypes.CFUNCTYPE(None, JNIEnv_p, jobject, jfieldID, jlong)),
        ("SetFloatField", ctypes.CFUNCTYPE(None, JNIEnv_p, jobject, jfieldID, jfloat)),
        ("SetDoubleField", ctypes.CFUNCTYPE(None, JNIEnv_p, jobject, jfieldID, jdouble)),

        # Static field access methods
        ("GetStaticFieldID", ctypes.CFUNCTYPE(jfieldID, JNIEnv_p, jclass, ctypes.c_char_p, ctypes.c_char_p)),
        ("GetStaticObjectField", ctypes.CFUNCTYPE(jobject, JNIEnv_p, jclass, jfieldID)),
        ("GetStaticBooleanField", ctypes.CFUNCTYPE(jboolean, JNIEnv_p, jclass, jfieldID)),
        ("GetStaticByteField", ctypes.CFUNCTYPE(jbyte, JNIEnv_p, jclass, jfieldID)),
        ("GetStaticCharField", ctypes.CFUNCTYPE(jchar, JNIEnv_p, jclass, jfieldID)),
        ("GetStaticShortField", ctypes.CFUNCTYPE(jshort, JNIEnv_p, jclass, jfieldID)),
        ("GetStaticIntField", ctypes.CFUNCTYPE(jint, JNIEnv_p, jclass, jfieldID)),
        ("GetStaticLongField", ctypes.CFUNCTYPE(jlong, JNIEnv_p, jclass, jfieldID)),
        ("GetStaticFloatField", ctypes.CFUNCTYPE(jfloat, JNIEnv_p, jclass, jfieldID)),
        ("GetStaticDoubleField", ctypes.CFUNCTYPE(jdouble, JNIEnv_p, jclass, jfieldID)),
        ("SetStaticObjectField", ctypes.CFUNCTYPE(None, JNIEnv_p, jclass, jfieldID, jobject)),
        ("SetStaticBooleanField", ctypes.CFUNCTYPE(None, JNIEnv_p, jclass, jfieldID, jboolean)),
        ("SetStaticByteField", ctypes.CFUNCTYPE(None, JNIEnv_p, jclass, jfieldID, jbyte)),
        ("SetStaticCharField", ctypes.CFUNCTYPE(None, JNIEnv_p, jclass, jfieldID, jchar)),
        ("SetStaticShortField", ctypes.CFUNCTYPE(None, JNIEnv_p, jclass, jfieldID, jshort)),
        ("SetStaticIntField", ctypes.CFUNCTYPE(None, JNIEnv_p, jclass, jfieldID, jint)),
        ("SetStaticLongField", ctypes.CFUNCTYPE(None, JNIEnv_p, jclass, jfieldID, jlong)),
        ("SetStaticFloatField", ctypes.CFUNCTYPE(None, JNIEnv_p, jclass, jfieldID, jfloat)),
        ("SetStaticDoubleField", ctypes.CFUNCTYPE(None, JNIEnv_p, jclass, jfieldID, jdouble)),

        # String operations
        ("NewString", ctypes.CFUNCTYPE(jstring, JNIEnv_p, ctypes.POINTER(jchar), jint)),
        ("GetStringLength", ctypes.CFUNCTYPE(jint, JNIEnv_p, jstring)),
        ("GetStringChars", ctypes.CFUNCTYPE(ctypes.POINTER(jchar), JNIEnv_p, jstring, ctypes.POINTER(jboolean))),
        ("ReleaseStringChars", ctypes.CFUNCTYPE(None, JNIEnv_p, jstring, ctypes.POINTER(jchar))),
        ("NewStringUTF", ctypes.CFUNCTYPE(jstring, JNIEnv_p, ctypes.c_char_p)),
        ("GetStringUTFLength", ctypes.CFUNCTYPE(jint, JNIEnv_p, jstring)),
        ("GetStringUTFChars", ctypes.CFUNCTYPE(ctypes.c_char_p, JNIEnv_p, jstring, ctypes.POINTER(jboolean))),
        ("ReleaseStringUTFChars", ctypes.CFUNCTYPE(None, JNIEnv_p, jstring, ctypes.c_char_p)),
        
        # Array operations
        ("GetArrayLength", ctypes.CFUNCTYPE(jint, JNIEnv_p, jarray)),
        ("NewObjectArray", ctypes.CFUNCTYPE(jarray, JNIEnv_p, jint, jclass, jobject)),
        ("GetObjectArrayElement", ctypes.CFUNCTYPE(jobject, JNIEnv_p, jarray, jint)),
        ("SetObjectArrayElement", ctypes.CFUNCTYPE(None, JNIEnv_p, jarray, jint, jobject)),
        ("NewBooleanArray", ctypes.CFUNCTYPE(jarray, JNIEnv_p, jint)),
        ("NewByteArray", ctypes.CFUNCTYPE(jarray, JNIEnv_p, jint)),
        ("NewCharArray", ctypes.CFUNCTYPE(jarray, JNIEnv_p, jint)),
        ("NewShortArray", ctypes.CFUNCTYPE(jarray, JNIEnv_p, jint)),
        ("NewIntArray", ctypes.CFUNCTYPE(jarray, JNIEnv_p, jint)),
        ("NewLongArray", ctypes.CFUNCTYPE(jarray, JNIEnv_p, jint)),
        ("NewFloatArray", ctypes.CFUNCTYPE(jarray, JNIEnv_p, jint)),
        ("NewDoubleArray", ctypes.CFUNCTYPE(jarray, JNIEnv_p, jint)),
        ("GetBooleanArrayElements", ctypes.CFUNCTYPE(ctypes.POINTER(jboolean), JNIEnv_p, jarray, ctypes.POINTER(jboolean))),
        ("GetByteArrayElements", ctypes.CFUNCTYPE(ctypes.POINTER(jbyte), JNIEnv_p, jarray, ctypes.POINTER(jboolean))),
        ("GetCharArrayElements", ctypes.CFUNCTYPE(ctypes.POINTER(jchar), JNIEnv_p, jarray, ctypes.POINTER(jboolean))),
        ("GetShortArrayElements", ctypes.CFUNCTYPE(ctypes.POINTER(jshort), JNIEnv_p, jarray, ctypes.POINTER(jboolean))),
        ("GetIntArrayElements", ctypes.CFUNCTYPE(ctypes.POINTER(jint), JNIEnv_p, jarray, ctypes.POINTER(jboolean))),
        ("GetLongArrayElements", ctypes.CFUNCTYPE(ctypes.POINTER(jlong), JNIEnv_p, jarray, ctypes.POINTER(jboolean))),
        ("GetFloatArrayElements", ctypes.CFUNCTYPE(ctypes.POINTER(jfloat), JNIEnv_p, jarray, ctypes.POINTER(jboolean))),
        ("GetDoubleArrayElements", ctypes.CFUNCTYPE(ctypes.POINTER(jdouble), JNIEnv_p, jarray, ctypes.POINTER(jboolean))),
        ("ReleaseBooleanArrayElements", ctypes.CFUNCTYPE(None, JNIEnv_p, jarray, ctypes.POINTER(jboolean), jint)),
        ("ReleaseByteArrayElements", ctypes.CFUNCTYPE(None, JNIEnv_p, jarray, ctypes.POINTER(jbyte), jint)),
        ("ReleaseCharArrayElements", ctypes.CFUNCTYPE(None, JNIEnv_p, jarray, ctypes.POINTER(jchar), jint)),
        ("ReleaseShortArrayElements", ctypes.CFUNCTYPE(None, JNIEnv_p, jarray, ctypes.POINTER(jshort), jint)),
        ("ReleaseIntArrayElements", ctypes.CFUNCTYPE(None, JNIEnv_p, jarray, ctypes.POINTER(jint), jint)),
        ("ReleaseLongArrayElements", ctypes.CFUNCTYPE(None, JNIEnv_p, jarray, ctypes.POINTER(jlong), jint)),
        ("ReleaseFloatArrayElements", ctypes.CFUNCTYPE(None, JNIEnv_p, jarray, ctypes.POINTER(jfloat), jint)),
        ("ReleaseDoubleArrayElements", ctypes.CFUNCTYPE(None, JNIEnv_p, jarray, ctypes.POINTER(jdouble), jint)),
        ("GetBooleanArrayRegion", ctypes.CFUNCTYPE(None, JNIEnv_p, jarray, jint, jint, ctypes.POINTER(jboolean))),
        ("GetByteArrayRegion", ctypes.CFUNCTYPE(None, JNIEnv_p, jarray, jint, jint, ctypes.POINTER(jbyte))),
        ("GetCharArrayRegion", ctypes.CFUNCTYPE(None, JNIEnv_p, jarray, jint, jint, ctypes.POINTER(jchar))),
        ("GetShortArrayRegion", ctypes.CFUNCTYPE(None, JNIEnv_p, jarray, jint, jint, ctypes.POINTER(jshort))),
        ("GetIntArrayRegion", ctypes.CFUNCTYPE(None, JNIEnv_p, jarray, jint, jint, ctypes.POINTER(jint))),
        ("GetLongArrayRegion", ctypes.CFUNCTYPE(None, JNIEnv_p, jarray, jint, jint, ctypes.POINTER(jlong))),
        ("GetFloatArrayRegion", ctypes.CFUNCTYPE(None, JNIEnv_p, jarray, jint, jint, ctypes.POINTER(jfloat))),
        ("GetDoubleArrayRegion", ctypes.CFUNCTYPE(None, JNIEnv_p, jarray, jint, jint, ctypes.POINTER(jdouble))),
        ("SetBooleanArrayRegion", ctypes.CFUNCTYPE(None, JNIEnv_p, jarray, jint, jint, ctypes.POINTER(jboolean))),
        ("SetByteArrayRegion", ctypes.CFUNCTYPE(None, JNIEnv_p, jarray, jint, jint, ctypes.POINTER(jbyte))),
        ("SetCharArrayRegion", ctypes.CFUNCTYPE(None, JNIEnv_p, jarray, jint, jint, ctypes.POINTER(jchar))),
        ("SetShortArrayRegion", ctypes.CFUNCTYPE(None, JNIEnv_p, jarray, jint, jint, ctypes.POINTER(jshort))),
        ("SetIntArrayRegion", ctypes.CFUNCTYPE(None, JNIEnv_p, jarray, jint, jint, ctypes.POINTER(jint))),
        ("SetLongArrayRegion", ctypes.CFUNCTYPE(None, JNIEnv_p, jarray, jint, jint, ctypes.POINTER(jlong))),
        ("SetFloatArrayRegion", ctypes.CFUNCTYPE(None, JNIEnv_p, jarray, jint, jint, ctypes.POINTER(jfloat))),
        ("SetDoubleArrayRegion", ctypes.CFUNCTYPE(None, JNIEnv_p, jarray, jint, jint, ctypes.POINTER(jdouble))),
    ]

# Define JNIInvokeInterface structure
class JNIInvokeInterface(ctypes.Structure):
    pass
class JavaVM(ctypes.Structure):
    _fields_ = [
        ("functions", ctypes.POINTER(JNIInvokeInterface))  # Pointer to the function table
    ]
JavaVM_p = ctypes.POINTER(JavaVM)
# Define JNIInvokeInterface structure
class JNIInvokeInterface(ctypes.Structure):
    pass
class JavaVM(ctypes.Structure):
    _fields_ = [
        ("functions", ctypes.POINTER(JNIInvokeInterface))  # Pointer to the function table
    ]
JavaVM_p = ctypes.POINTER(JavaVM)
JNIInvokeInterface._fields_ = [
        ("reserved0", c_void_p),
        ("reserved1", c_void_p),
        ("reserved2", c_void_p),
        ("DestroyJavaVM", ctypes.CFUNCTYPE(c_int, JavaVM_p)),
        ("AttachCurrentThread", ctypes.CFUNCTYPE(c_int, JavaVM_p, POINTER(JNIEnv_p), POINTER(JavaVMAttachArgs))),
        ("DetachCurrentThread", ctypes.CFUNCTYPE(c_int)),
        ("GetEnv", ctypes.CFUNCTYPE(c_int, JavaVM_p, POINTER(JNIEnv_p), c_int)),
        ("AttachCurrentThreadAsDaemon", ctypes.CFUNCTYPE(c_int, JavaVM_p, POINTER(JavaVMAttachArgs)))
    ]

# Define JNI_GetCreatedJavaVMs function signature
libjvm.JNI_GetCreatedJavaVMs.argtypes = [POINTER(JavaVM_p), c_int, POINTER(c_int)]
libjvm.JNI_GetCreatedJavaVMs.restype = c_int

# Call JNI_GetCreatedJavaVMs
jvm = JavaVM_p()
nVMs = c_int(0)
result = libjvm.JNI_GetCreatedJavaVMs(byref(jvm), 1, byref(nVMs))

if result != 0 or nVMs.value == 0:
    print("Failed to retrieve JavaVM instances.")
    exit(1)

print(f"nVMs={nVMs.value}")
print("jvm=",jvm)
print("jvm=",jvm.contents)

# Prepare JavaVMAttachArgs
args = JavaVMAttachArgs()
args.version = JNI_VERSION_1_6
args.name = None
args.group = None

# Prepare JNIEnv pointer
env = JNIEnv_p()

# Call AttachCurrentThread
print(jvm.contents.functions.contents.AttachCurrentThread(jvm, byref(env), byref(args)))
print(env)
print(hex(env.contents.functions.contents.GetVersion(env)))

However if you want to mix and match JPype with ctypes one would need to add accessors in the JPype types that exposed the corresponding Java objects. It is doable, but would require a lot of care to get right.

[Lqm1]

Thank you! Excellent.
"JNIEnv*" was successfully obtained. However, as you mentioned, there is still a process to execute the JNI function.
I created "jpype.JArray(jpype.JByte)(data)" using jpype, but the JNI function seems to take a pointer.

For now, the sample code you gave me is working normally.
This is my first time to know how to "ctypes.CDLL(None)." I learned a lot!