339 lines
8.1 KiB
Rust
339 lines
8.1 KiB
Rust
use jni::errors::Result;
|
|
use jni::objects::{GlobalRef, JClass, JList, JMap, JObject, JString, JValue};
|
|
use jni::sys::{jbyteArray, jint, jlong, jobject, jstring};
|
|
use jni::JNIEnv;
|
|
use std::{sync::mpsc, thread, time::Duration};
|
|
#[no_mangle]
|
|
pub extern "system" fn Java_me_ehlxr_HelloWorld_getField(
|
|
env: JNIEnv,
|
|
_class: JClass,
|
|
input: JObject,
|
|
) -> jobject {
|
|
// Map field operate
|
|
let jmap = env
|
|
.get_map(
|
|
env.get_field(input, "map", "Ljava/util/Map;")
|
|
.unwrap()
|
|
.l()
|
|
.unwrap(),
|
|
)
|
|
.unwrap();
|
|
let v1 = jmap
|
|
.get(JObject::from(env.new_string("k1").unwrap()))
|
|
.unwrap()
|
|
.unwrap();
|
|
println!("get map key k1, value: {}", long_value(env, v1));
|
|
|
|
if let Ok(_) = jmap.put(
|
|
JObject::from(env.new_string("k9").unwrap()),
|
|
long_to_jobj(env, 9 as i64),
|
|
) {
|
|
println!("put key ok");
|
|
};
|
|
|
|
jmap.iter().unwrap().into_iter().for_each(|jmap_iter| {
|
|
let key: JString = jmap_iter.0.into();
|
|
let value = jmap_iter.1;
|
|
println!(
|
|
"iter map key: {}, value: {}",
|
|
String::from(env.get_string(key).unwrap()),
|
|
long_value(env, value)
|
|
);
|
|
});
|
|
|
|
// List field operate
|
|
let jlist = env
|
|
.get_list(
|
|
env.get_field(input, "list", "Ljava/util/List;")
|
|
.unwrap()
|
|
.l()
|
|
.unwrap(),
|
|
)
|
|
.unwrap();
|
|
jlist.iter().unwrap().into_iter().for_each(|jobj| {
|
|
let jstr: JString = jobj.into();
|
|
println!(
|
|
"get list field: {}",
|
|
String::from(env.get_string(jstr).unwrap())
|
|
);
|
|
});
|
|
|
|
// int field operate
|
|
let age = env.get_field(input, "age", "I").unwrap().i().unwrap();
|
|
println!("get age field: {}", age);
|
|
|
|
// String field operate
|
|
let name: JString = env
|
|
.get_field(input, "name", "Ljava/lang/String;")
|
|
.unwrap()
|
|
.l()
|
|
.unwrap()
|
|
.into();
|
|
println!(
|
|
"get name field: {}",
|
|
String::from(env.get_string(name).unwrap())
|
|
);
|
|
|
|
// Long field operate
|
|
let no = long_value(
|
|
env,
|
|
env.get_field(input, "no", "Ljava/lang/Long;")
|
|
.unwrap()
|
|
.l()
|
|
.unwrap(),
|
|
);
|
|
println!("get no field: {}", no);
|
|
|
|
// call method operate
|
|
let out_str = if let JValue::Object(result) = env
|
|
.call_method(input, "getName", "()Ljava/lang/String;", &[])
|
|
.unwrap()
|
|
{
|
|
let jstr = env.get_string(JString::from(result)).unwrap();
|
|
// println!("call getNameStr result: {}", String::from(jstr));
|
|
String::from(jstr)
|
|
} else {
|
|
"".to_string()
|
|
};
|
|
println!("Hello {}! from Rust..", out_str);
|
|
|
|
// new ArrayList operate
|
|
let list = unwrap(
|
|
&env,
|
|
JList::from_env(
|
|
&env,
|
|
unwrap(&env, env.new_object("java/util/ArrayList", "()V", &[])),
|
|
),
|
|
);
|
|
|
|
// new LinkedHashMap operate
|
|
let map = unwrap(
|
|
&env,
|
|
JMap::from_env(
|
|
&env,
|
|
unwrap(&env, env.new_object("java/util/LinkedHashMap", "()V", &[])),
|
|
),
|
|
);
|
|
|
|
// Map put key value operate
|
|
unwrap(
|
|
&env,
|
|
map.put(
|
|
JObject::from(env.new_string("no").unwrap()),
|
|
long_to_jobj(env, no),
|
|
),
|
|
);
|
|
unwrap(
|
|
&env,
|
|
map.put(
|
|
JObject::from(env.new_string("age").unwrap()),
|
|
long_to_jobj(env, age as i64),
|
|
),
|
|
);
|
|
unwrap(
|
|
&env,
|
|
map.put(
|
|
JObject::from(env.new_string("name").unwrap()),
|
|
JObject::from(name),
|
|
),
|
|
);
|
|
unwrap(
|
|
&env,
|
|
map.put(
|
|
JObject::from(env.new_string("list").unwrap()),
|
|
JObject::from(jlist),
|
|
),
|
|
);
|
|
unwrap(
|
|
&env,
|
|
map.put(
|
|
JObject::from(env.new_string("map").unwrap()),
|
|
JObject::from(jmap),
|
|
),
|
|
);
|
|
let jmap2 = map.clone();
|
|
|
|
// List add element operate
|
|
unwrap(&env, list.add(JObject::from(map)));
|
|
unwrap(&env, list.add(jmap2));
|
|
|
|
println!("list size {}", list.size().unwrap());
|
|
|
|
list.into_inner()
|
|
|
|
// let output = env
|
|
// .new_string(format!("Hello {}! from Rust..", out_str))
|
|
// .expect("Couldn't create java string!");
|
|
// output.into_inner()
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub extern "system" fn Java_me_ehlxr_HelloWorld_hello(
|
|
env: JNIEnv,
|
|
_class: JClass,
|
|
input: JString,
|
|
) -> jstring {
|
|
let input: String = env
|
|
.get_string(input)
|
|
.expect("Couldn't get java string!")
|
|
.into();
|
|
|
|
let output = env
|
|
.new_string(format!("Hello, {}! from Rust..", input))
|
|
.expect("Couldn't create java string!");
|
|
output.into_inner()
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub extern "system" fn Java_me_ehlxr_HelloWorld_helloByte(
|
|
env: JNIEnv,
|
|
_class: JClass,
|
|
input: jbyteArray,
|
|
) -> jbyteArray {
|
|
let _input = env.convert_byte_array(input).unwrap();
|
|
|
|
let buf = [1; 2000];
|
|
let output = env.byte_array_from_slice(&buf).unwrap();
|
|
output
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub extern "system" fn Java_me_ehlxr_HelloWorld_factAndCallMeBack(
|
|
env: JNIEnv,
|
|
_class: JClass,
|
|
n: jint,
|
|
callback: JObject,
|
|
) {
|
|
let i = n as i32;
|
|
let res: jint = (2..i + 1).product();
|
|
|
|
env.call_method(callback, "factCallback", "(I)V", &[res.into()])
|
|
.unwrap();
|
|
}
|
|
|
|
struct Counter {
|
|
count: i32,
|
|
callback: GlobalRef,
|
|
}
|
|
|
|
impl Counter {
|
|
pub fn new(callback: GlobalRef) -> Counter {
|
|
Counter {
|
|
count: 0,
|
|
callback: callback,
|
|
}
|
|
}
|
|
|
|
pub fn increment(&mut self, env: JNIEnv) {
|
|
self.count = self.count + 1;
|
|
env.call_method(
|
|
&self.callback,
|
|
"counterCallback",
|
|
"(I)V",
|
|
&[self.count.into()],
|
|
)
|
|
.unwrap();
|
|
}
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "system" fn Java_me_ehlxr_HelloWorld_counterNew(
|
|
env: JNIEnv,
|
|
_class: JClass,
|
|
callback: JObject,
|
|
) -> jlong {
|
|
let global_ref = env.new_global_ref(callback).unwrap();
|
|
let counter = Counter::new(global_ref);
|
|
|
|
Box::into_raw(Box::new(counter)) as jlong
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "system" fn Java_me_ehlxr_HelloWorld_counterIncrement(
|
|
env: JNIEnv,
|
|
_class: JClass,
|
|
counter_ptr: jlong,
|
|
) {
|
|
let counter = &mut *(counter_ptr as *mut Counter);
|
|
|
|
counter.increment(env);
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "system" fn Java_me_ehlxr_HelloWorld_counterDestroy(
|
|
_env: JNIEnv,
|
|
_class: JClass,
|
|
counter_ptr: jlong,
|
|
) {
|
|
let _boxed_counter = Box::from_raw(counter_ptr as *mut Counter);
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub extern "system" fn Java_me_ehlxr_HelloWorld_asyncComputation(
|
|
env: JNIEnv,
|
|
_class: JClass,
|
|
callback: JObject,
|
|
) {
|
|
let jvm = env.get_java_vm().unwrap();
|
|
|
|
let callback = env.new_global_ref(callback).unwrap();
|
|
|
|
let (tx, rx) = mpsc::channel();
|
|
|
|
let _ = thread::spawn(move || {
|
|
tx.send(()).unwrap();
|
|
|
|
let env = jvm.attach_current_thread().unwrap();
|
|
|
|
for i in 0..11 {
|
|
let progress = (i * 10) as jint;
|
|
env.call_method(&callback, "asyncCallback", "(I)V", &[progress.into()])
|
|
.unwrap();
|
|
thread::sleep(Duration::from_millis(100));
|
|
}
|
|
});
|
|
|
|
rx.recv().unwrap();
|
|
}
|
|
|
|
fn long_value(env: JNIEnv, jobj: JObject) -> i64 {
|
|
env.call_method(jobj, "longValue", "()J", &[])
|
|
.unwrap()
|
|
.j()
|
|
.unwrap()
|
|
}
|
|
|
|
fn long_to_jobj<'a>(env: JNIEnv<'a>, lv: i64) -> JObject<'a> {
|
|
env.call_static_method(
|
|
"Ljava/lang/Long;",
|
|
"valueOf",
|
|
"(J)Ljava/lang/Long;",
|
|
&[JValue::from(lv)],
|
|
)
|
|
.unwrap()
|
|
.l()
|
|
.unwrap()
|
|
}
|
|
|
|
pub fn print_exception(env: &JNIEnv) {
|
|
let exception_occurred = env.exception_check().unwrap_or_else(|e| panic!("{:?}", e));
|
|
if exception_occurred {
|
|
env.exception_describe()
|
|
.unwrap_or_else(|e| panic!("{:?}", e));
|
|
}
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
pub fn unwrap<T>(env: &JNIEnv, res: Result<T>) -> T {
|
|
res.unwrap_or_else(|e| {
|
|
print_exception(&env);
|
|
panic!("{:#?}", e);
|
|
})
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
#[test]
|
|
fn it_works() {}
|
|
}
|