[Question]: How does one send a native rust function to java as a callback? about jni-rs HOT 2 OPEN

use jni::{
	JNIEnv,
	objects::{JClass, JObject, JString},
};
use std::{
	borrow::Cow,
	panic::{AssertUnwindSafe, catch_unwind},
	sync::MutexGuard,
};

// The callback function, in a box.
type BoxedCallback = Box<dyn Fn(&str) -> String + Send + 'static>;

// Instantiates a new `ExampleCallback` object, which will use `f` as the native callback.
fn instantiate_java_callback<'local>(
	env: &mut JNIEnv<'local>,
	f: impl Fn(&str) -> String + Send + Sync + 'static,
) -> jni::errors::Result<JObject<'local>> {
	// Box the callback function so we can store it in a Java object.
	let f: BoxedCallback = Box::new(f);

	// Instantiate the Java object.
	let object: JObject<'local> = env.new_object(
		"com/example/ExampleCallback",
		"()V",
		&[],
	)?;

	// Give ownership of the callback function to the Java object, by storing the pointer in its
	// `ptr` field.
	unsafe { env.set_rust_field(&object, "ptr", f)?; }

	// We're done here. Return the Java object.
	Ok(object)
}

// Implementation of `ExampleCallback.apply`. Extracts the callback function pointer and calls it.
#[no_mangle]
extern "system" fn Java_com_example_ExampleCallback_apply<'local>(
	env: JNIEnv<'local>,
	this: JObject<'local>,
	string: JString<'local>,
) -> JString<'local> {
	quick_and_dirty_error_handler(env, |mut env| {
		// Convert the input string from Java to Rust.
		let string = env.get_string(&string)?;
		let string: Cow<str> = (&string).into();

		// Get the pointer to the callback function.
		let f: MutexGuard<BoxedCallback> = unsafe {
			// Safety: The `ptr` field is only ever written by `JNIEnv::set_rust_field`, using the same
			// value type (`BoxedCallback`).
			env.get_rust_field(&this, "ptr")
		}?;

		// Call the callback function.
		let string: String = f(&*string);

		// Drop the mutex lock so we can use the `JNIEnv` again.
		drop(f);

		// Convert the output string back to Java, and return it.
		env.new_string(string)
	})
}

// Implementation of `ExampleCallback.finalize`. Deallocates the callback function.
#[no_mangle]
extern "system" fn Java_com_example_ExampleCallback_finalize(
	mut env: JNIEnv,
	this: JObject,
) {
	// Retake ownership of the box from Java.
	let _: jni::errors::Result<BoxedCallback> = unsafe {
		// Safety: The `ptr` field is only ever written by `JNIEnv::set_rust_field`, using the same
		// value type (`BoxedCallback`).
		env.take_rust_field(&this, "ptr")
	};

	// At this point, the `Box` (if any) will deallocate, freeing the memory it held, including the
	// inner `Box` and the callback function itself.
}

// Quick and dirty error handler. Handles errors and panics in a JNI-friendly way.
//
// This will hopefully be unnecessary in a future version of the jni crate.
// See discussion at: https://github.com/jni-rs/jni-rs/issues/432
fn quick_and_dirty_error_handler<'local, T>(
	env: JNIEnv<'local>,
	f: impl FnOnce(JNIEnv<'local>) -> jni::errors::Result<T>,
) -> T
where
	T: Default,
{
	let mut env_clone = unsafe { env.unsafe_clone() };

	match catch_unwind(AssertUnwindSafe(|| f(env))) {
		Ok(Ok(ok)) => ok,

		Err(_) => {
			if !(matches!(env_clone.exception_check(), Ok(true))) {
				let _ = env_clone.throw_new("java/lang/Error", "there was a Rust panic");
			}

			Default::default()
		}

		Ok(Err(error)) => {
			if !(matches!(env_clone.exception_check(), Ok(true))) {
				let _ = env_clone.throw_new("java/lang/Error", format!("there was an error: {error}"));
			}

			Default::default()
		}
	}
}

instantiate_java_callback(&mut env, |s| format!("{s}!"))