I’m trying to write a JNI implementation of some function that is called from JVM. That function at some point needs to convert a JVM String to a Kotlin String. This means that I have to call the GetStringUTFChars
function so that the JVM will return me a pointer to the UTF8 string.
This function has a C interface defined as:
const char * GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy);
The third argument points to a jboolean
(which is a UByte
) that will be changed by the JVM; so I need to pass an adress of UByte to this function.
I know that I can allocate memory by using memScoped
+alloc
, and currently this solution works:
memScoped {
val copiedPtr = alloc<UByte>(0U)
val jvmString = native.GetStringUTFChars!!(env, path, copiedPtr.ptr)
if (jvmString != null) {
val s = jvmString.toKString()
println("(copied=${copiedPtr.value}) $s")
native.ReleaseStringUTFChars!!(env, path, jvmString)
}
}
However, this seems to perform a malloc
-style call inside alloc<>
, and will call free()
on the end of the scope (or is it wrong?). It seems to be a pretty high overkill. Is there any possibility of just declaring an UByte, or allocating it on the stack instead of on the heap, and getting the CPointer<UByte>
of that stack-allocated variable?