Hello everyone. A friend asked me if it is possible to build a library, based on coroutines, that interops with native code, targeted for Android. Please, any ideas?(or whether it is possible)

If native code is code using the Android SDK (not the NDK), then sure, people have been doing it since 2017 with success.

Please, @louiscad, can you give me some examples of such libraries?

So NDK… Then you'll need to do the callbacks wrapping and cancellation handling yourself…

OK I see... Thanks for the info👍

Not that I'm aware of

OK...

Now, Android Studio recent versions added autocompletion for JNI interop in Kotlin/C, so that might be helpful

OK. Noted. So I will have to write wrappers for coroutines in the form if callbacks...Serious lot of work...

Android Studio is free and is almost the same.

So I will have to write wrappers for coroutines in the form if callbacks...Serious lot of work...

Some C++ Future/Promice class can be exposed instead of callback, so it would be enough to write one single await() function for it, so it will be universal for all async calls to native code But in general it really depends what kind C code you try to integrate

But is it possible that I use Kotlin/Native and generate a library that I can then consume on the Android side?

Yes, but there's no java-like interop between Kotlin/Native and Kotlin/JVM, so you'll need glue code/an adapter. Also, kotlinx.coroutines is not available on the Android NDK (https://github.com/Kotlin/kotlinx.coroutines/issues/812), so you'll need to compile it yourself.

I really don’t think that you need Kotlin/Native if your final goal is to use some C API on Android/JVM, K/N is just one more layer which doesn’t improve anything Better to have JNI directly to C API from JVM (or any of options which generates JNI glue for you) And on top of this Java JNI API you can add coroutines

Thanks @gildor. But I have two questions. The first is, why can't I use K/N to avoid JNI altogether? and, How can I add coroutines on top of the JNI API?, because my goal is to use coroutines natively.

The first is, why can’t I use K/N to avoid JNI altogether

You can, but then you have to write JNI to talk with K/N from Android It maybe a viable option if most of loigic on k/n side and you have simple interaction with it

I am working on an image processing library, where most of the specific image processing code is already written in C. I want to use coroutines when calling specific functions from the C API, then generate the code I have written into library that I can then use on the Android side.

I don’t think so honestly

Yeah, seems like a more pragmatic solution.

if Android wouldn’t be involved, if fine solution, but writing one more layer of bindings on top of it looks as not the best idea

Yeah... Thanks a lot for your help, @louiscad, and @gildor. I really appreciate it. 🙏

you also can use something like JNA to wrap C API without writing all glue manually

Please @gildor, do you have any links or hints on how to achieve that? It will be of great help.

I meant that you can use something like JNA https://github.com/java-native-access/jna or similar approaches to generate jni

Ok. Thanks very much...🙏

Yeah, JNA works with standard interfaes, shouldn't be an issue

Thanks very much🙏