Not sure how KN is transparently calling `Java_org...

# kotlin-native

[Gavin Ray]

Not sure how KN is transparently calling Java_org_jetbrains_skija_Canvas__1nDrawPicture without (what looks like) passing any JNIEnv 🤔

[alexander.gorshenev]

The calls are actually to
https://github.com/JetBrains/skiko/blob/023a169556129b0f68d236eac1c38d08d9741039/skiko/src/nativeMain/cpp/generated/Canvas.cc
Roughly the k/n friendly equivalents of jni function

[Gavin Ray]

Are these auto-generated (or at least mostly), Alexander?
The calls seem to be mostly identical except for swapping JNIEnv* pointer for kref __Kinstance

[olonho]

autogenerated only for simple cases, for harder cases JS and Native are the same and JVM are different

[Gavin Ray]

technically Skiko is an approach to multiplatform native interop for all major Kotlin targets

I am hoping for a not-so-distant future in which Skiko is used as the rendering backend for Compose on iOS.
Then you can use a single Kotlin codebase and UI framework to build experiences across all targets -- even the browser!

Unfortunately, it seems the KN part of Skiko is fairly young, was only MacOS supported until recently, now there is at least a Linux OpenGL renderer. Though it a stub for now

[Gavin Ray]

What Mono and .NET did for Skia was to wrap the C++ in a C ABI and then call this:
• https://github.com/mono/skia/blob/xamarin-mobile-bindings/include/c/sk_types.h
It is used here:
• https://github.com/mono/SkiaSharp

[Gavin Ray]

I have considered to build the xamarin-mobile-bindings branch which has the C ABI that Microsoft uses, and then generate Kotlin Native interop types from it and experiment with that. Would maybe save a lot of effort.

[olonho]

API shape would look uglier then. We considered such approach

[Gavin Ray]

I figured as such, Jetbrains has a lot of talented programmers, resources, and money. I thought they must have considered it and instead decide to maintain their own and build by hand over a longer time period for more control.

[smallshen]

@olonho
https://github.com/Kotlin/KEEP/pull/279
As I discussed here, we can write the library in Kotlin-Native, and use JNI to use the compiled kotlin native library directly. Which has several ways.
The way I use in my own project is to use ksp to generate classes that every method is export and use it on kotlin JVM, and create other sets of native platforms which are going to be used by JNI, using JNI in kotlin native is simple, cinterop support it.
For link the native method to JVM, you can simply use @CName("Java_org_jetbrains_skiko_blablabla")
or through JNI method

memScoped {
            val mP = alloc<JNINativeMethod> {
                name = methodName.cstr.ptr
                signature = descriptor.cstr.ptr
                fnPtr = m // native function pointer
            }
            env.pointed.pointed!!.RegisterNatives!!(env, findClass(className), mP.ptr, 1)
        }

The native function pointer can used as

staticCFunction<CPointer<JNIEnvVar>, jobject, jdouble> { env, t,  -> 
// same as fun yourMethod(env: CPointer<JNIEnvVar>, obj: jobject) : jdouble
// jdouble is a primitive, cinterop will make typealias points to kotlin.Double, the result can't be null
 }

[smallshen]

use kotlin ir to generating these are fast and simple, as long as the code is well organized

[Gavin Ray]

The way I use in my own project is to use ksp to generate classes that every method is export and use it on kotlin JVM, and create other sets of native platforms which are going to be used by JNI, using JNI in kotlin native is simple, cinterop support it.

For link the native method to JVM, you can simply use @CName("Java_org_jetbrains_skiko_blablabla")

or through JNI method

This is a really clever approach @smallshen!

[Gavin Ray]

memScoped {
            val mP = alloc<JNINativeMethod> {
                name = methodName.cstr.ptr
                signature = descriptor.cstr.ptr
                fnPtr = m // native function pointer
            }
            env.pointed.pointed!!.RegisterNatives!!(env, findClass(className), mP.ptr, 1)
        }

Do I understand right, that this snippet of code says?
• Allocate a value, mP, of type JNINativeMethod where:
◦ The name = the Kotlin Native method's name, as a cstr*
◦ The signature = the Kotlin Native method's descriptor, as a cstr*
◦ The fnPtr itself = m, which points to the Kotlin Native function
• Then, register a new JNI method in the JNIEnv natives from this KN definition

[Gavin Ray]

Do you have a very basic project on Github which shows using this for just a few functions as a demo?

[smallshen]

@Gavin Ray this is the actual code, just replace the values, I'll make a simple demo