WIP

Author: sungshik

src/main/rust/src/fs_monitor.rs

@@ -11,7 +11,7 @@ use std::{
     ptr,
     fs,
     os::raw::{c_char, c_void},
-    sync::atomic::{AtomicBool, Ordering}
+    sync::atomic::{AtomicBool, Ordering},
 };
 use dispatch2::ffi::{dispatch_object_t, dispatch_queue_t, DISPATCH_QUEUE_SERIAL, dispatch_queue_create};
 use core_foundation::{
@@ -75,8 +75,7 @@ impl NativeEventStream {
 
     pub fn stop(&self) {
         if self.closed.compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst).is_err() {
-            // we weren't the first one to close it
-            return;
+            return; // The stream has already been closed
         }
         match self.stream {
             Some(stream) => unsafe{
@@ -94,7 +93,7 @@ impl NativeEventStream {
 }
 
 struct ContextInfo {
-    handler: Box<dyn Fn(&String, Kind)>
+    handler: Box<dyn Fn(&String, Kind)>,
 }
 
 const FLAGS : fse::FSEventStreamCreateFlags

src/main/rust/src/lib.rs

@@ -1,95 +1,76 @@
 mod fs_monitor;
 
 use jni::{Executor, JNIEnv};
-
 use jni::objects::{GlobalRef, JClass, JMethodID, JObject, JString, JValue};
-
-use jni::sys::{jboolean, jlong, jint, jvalue, JNI_FALSE};
+use jni::sys::{jint, jlong};
 
 use crate::fs_monitor::{Kind, NativeEventStream};
 
-struct Runnable2 {
-    obj: GlobalRef,
-    class: GlobalRef, // just making sure we don't lose reference to this Runnable class
+#[allow(dead_code)]
+struct HandlerExecutor {
     executor: Executor,
-    root_path: String
+    obj: GlobalRef,
+    method: JMethodID,
+    path: String,
+    class: GlobalRef, // Ensure the reference to the class (of `obj`) isn't lost
 }
 
-impl Runnable2 {
-    pub fn new<'local>(env: &mut JNIEnv<'local>, root_path: String, local_recv: JObject<'local>) -> Result<Self, jni::errors::Error> {
-        let recv = env.new_global_ref(local_recv)?;
-        let class = env.new_global_ref(env.get_object_class(&recv)?)?;
+impl HandlerExecutor {
+    pub fn new<'local>(env: &mut JNIEnv<'local>, path: String, obj: JObject<'local>) -> Result<Self, jni::errors::Error> {
         let executor = Executor::new(Into::into(env.get_java_vm()?));
+        let obj = env.new_global_ref(obj)?;
+        let class = env.new_global_ref(env.get_object_class(&obj)?)?;
+        let method = env.get_method_id(
+            &class, "handle", "(Ljava/lang/String;Ljava/lang/String;I)V")?;
 
-        Ok(Self {
-            obj: recv,
-            class,
-            executor,
-            root_path
-        })
+        Ok(Self { executor, obj, method, path, class })
     }
 
-    pub fn run2<'local>(&self, path: &String, kind: Kind) {
+    pub fn execute<'local>(&self, path: &String, kind: Kind) {
         self.executor.with_attached(|env: &mut JNIEnv<'_>| -> Result<(), jni::errors::Error> {
-            // let message = env.new_string(&path).unwrap();
-            // eprintln!("Message: {:?}", &message.as_raw());
-            // let class = env.find_class("java/nio/file/StandardWatchEventKinds").unwrap();
-            // eprintln!("Class: {:?}", &class);
-            // let field = env.get_static_field(class, "ENTRY_CREATE", "Ljava/nio/file/WatchEvent$Kind;").unwrap();
-            // eprintln!("Field: {:?}", &field);
-
-
-            env.call_method(
-                self.obj.as_obj(),
-                "handle",
-                "(Ljava/lang/String;Ljava/lang/String;I)V",
-                &[
-                    JValue::Object(&env.new_string(&self.root_path).unwrap()),
-                    JValue::Object(&env.new_string(&path).unwrap()),
-                    JValue::Int(kind as jint)]);
-
-                // "(Ljava/lang/String;Ljava/nio/file/WatchEvent$Kind;)V",
-                // &[JValue::Object(&message), field.borrow()]);
-
+            unsafe {
+                env.call_method_unchecked(
+                    self.obj.as_obj(),
+                    self.method,
+                    jni::signature::ReturnType::Primitive(jni::signature::Primitive::Void),
+                    &[
+                        JValue::from(&env.new_string(&self.path).unwrap()).as_jni(),
+                        JValue::from(&env.new_string(&path).unwrap()).as_jni(),
+                        JValue::from(kind as jint).as_jni()]
+                )?;
+            }
             Ok(())
-        });
+        }).unwrap();
     }
 }
 
-
 #[unsafe(no_mangle)]
 #[allow(unused_variables)]
 pub extern "system" fn Java_engineering_swat_watch_impl_mac_jni_FileSystemEvents_start<'local>(
     mut env: JNIEnv<'local>,
     class: JClass<'local>,
     path: JString<'local>,
-    test: JObject<'local>
-) -> jlong {
-
-    let asdf: String = env.get_string(&path).expect("Should not fail to get string").into();
-
-    let g = Runnable2::new(&mut env, asdf.clone(), test).unwrap();
-    // let h = move |path: String, flags: u32| g.run2(path, flags);
-    let h = move |path: &String, kind: Kind| g.run2(path, kind);
-
-    let mut mon = NativeEventStream::new(
-        asdf,
-        h
-    );
-
+    handler: JObject<'local>,
+) -> jlong
+{
+    let path: String = env.get_string(&path).expect("Should not fail to get string").into();
+    let handler_executor = HandlerExecutor::new(&mut env, path.clone(), handler).unwrap();
+    let handler = move |path: &String, kind: Kind| handler_executor.execute(path, kind);
+    let mut mon = NativeEventStream::new(path, handler);
     mon.start();
     Box::into_raw(Box::new(mon)) as jlong
 }
 
 #[unsafe(no_mangle)]
 #[allow(unused_variables)]
 pub extern "system" fn Java_engineering_swat_watch_impl_mac_jni_FileSystemEvents_stop<'local>(
-    mut env: JNIEnv<'local>,
+    env: JNIEnv<'local>,
     class: JClass<'local>,
     stream: jlong,
-) {
+)
+{
     let mon_ptr = stream as *mut NativeEventStream;
     let mon = unsafe { Box::from_raw(mon_ptr) };
     mon.stop();
-    // after this the mon will be released, as we took it back into the box
+    // After this, the mon will be released, as it has been taken out of the box
 }