Optimize clipboard change listener

src/server/clipboard_service.rs

@@ -1,3 +1,7 @@
+use std::sync::mpsc::Sender;
+
+use clipboard_master::{CallbackResult, ClipboardHandler, Master};
+
 use super::*;
 pub use crate::common::{
     check_clipboard, ClipboardContext, CLIPBOARD_INTERVAL as INTERVAL, CLIPBOARD_NAME as NAME,
@@ -27,12 +31,28 @@ impl super::service::Reset for State {
     }
 }
 
+struct ClipHandle {
+    tx: Sender<bool>,
+}
+
+impl ClipboardHandler for ClipHandle {
+    fn on_clipboard_change(&mut self) -> CallbackResult {
+        let _ = self.tx.send(true);
+        CallbackResult::Next
+    }
+}
+
 pub fn new() -> GenericService {
     let sp = GenericService::new(NAME, true);
-    sp.repeat::<State, _>(INTERVAL, run);
+    sp.listen::<State, _, _>(notify, run);
     sp
 }
 
+fn notify(tx: Sender<bool>) -> ResultType<()> {
+    Master::new(ClipHandle { tx }).run()?;
+    Ok(())
+}
+
 fn run(sp: GenericService, state: &mut State) -> ResultType<()> {
     if let Some(ctx) = state.ctx.as_mut() {
         if let Some(msg) = check_clipboard(ctx, None) {

src/server/service.rs

@@ -1,5 +1,6 @@
 use super::*;
 use std::{
+    sync::{self, mpsc::Sender},
     thread::{self, JoinHandle},
     time,
 };
@@ -153,6 +154,39 @@ impl<T: Subscriber + From<ConnInner>> ServiceTmpl<T> {
         }
     }
 
+    pub fn listen<S, N, F>(&self, notify: N, callback: F)
+    where
+        N: 'static + FnMut(Sender<bool>) -> ResultType<()> + Send,
+        F: 'static + FnMut(Self, &mut S) -> ResultType<()> + Send,
+        S: 'static + Default + Reset,
+    {
+        let mut notify = notify;
+        let mut callback = callback;
+        let sp = self.clone();
+        let (tx, rx) = sync::mpsc::channel();
+        thread::spawn(move || {
+            let _ = notify(tx);
+        });
+
+        let thread = thread::spawn(move || {
+            let mut state = S::default();
+            while let Ok(changed) = rx.recv() {
+                if changed && sp.active() {
+                    if sp.has_subscribes() {
+                        if let Err(err) = callback(sp.clone(), &mut state) {
+                            log::error!("Error of {} service: {}", sp.name(), err);
+                            #[cfg(windows)]
+                            crate::platform::windows::try_change_desktop();
+                        }
+                    } else {
+                        state.reset();
+                    }
+                }
+            }
+        });
+        self.0.write().unwrap().handle = Some(thread);
+    }
+
     pub fn repeat<S, F>(&self, interval_ms: u64, callback: F)
     where
         F: 'static + FnMut(Self, &mut S) -> ResultType<()> + Send,