How to automate Java bindings for Rust code?

Question

I want to call Rust code from Java / Android, and I've found 3 variants to do so:

1. JNI
2. JNA
3. JNR FFI

JNI looks good and powerful enough, but you have to write too much code by hand.

JNA, if not taking into consideration that it crashes on my machine, requires writing Rust struct data type description in Java by hand, the same problem with JNR FFI.

So I wonder how difficult will be generate JNI code for traits and struct with macros or a compiler plugin? This compiler should match traits implementations for concrete struct, and also struct

#[JNI]
struct Foo {
    a: i32,
}

trait Boo {
    fn f(&self, b: f64) -> f64;
}
#[JNI]
impl Boo for Foo {
    fn f(&self, b: f64) -> f64 {
        0f64
    }
}

and create Java classes for struct and Java classes with native functions, plus generate pub no_mangle functions that wrap traits functions.

Answer 1

In order to provide #[jni] annotations that work like that you'd need to use a compiler plugin. It would be an awesome tool, but it doesn't exist yet, as far as I know.

There are bits and pieces of tooling lying around that might be helpful, if you want to create a project that does this.

Plugins are currently unstable, and don't work on non-nightly rust; you would probably want to use syntex, which provides a stable interface to compiler plugins. You could also write a raw plugin (see here for the API for those), but most people won't be able to use it.

There's rusty-cheddar, which generates c header files; you could take a look at that to see how it works. The author of that also seems to be working on a more general bindings-generation framework, but I don't know if it's active. You might be able to hook the output of cheddar up to something like JNAerator, but it probably won't create the prettiest interfaces on the java side.

There's also rust-bindgen and corrode, which work in the other direction; they translate c headers and arbitrary c code to rust respectively. I don't know if that's actually helpful.

JNI-sys provides low-level JNI bindings; rust-on-mobile is a small project that uses it. Also see First steps with Rust and Java, a blog post that shows some rudiments of getting things hooked up.

Finally, there's cbox, which lets you work around awkwardness with ownership and FFI.