feat: clipboard, multi formats (#8733)

Signed-off-by: fufesou <linlong1266@gmail.com>

src/server/clipboard_service.rs

@@ -1,49 +1,79 @@
 use super::*;
 pub use crate::clipboard::{
-    check_clipboard, ClipboardContext, CLIPBOARD_INTERVAL as INTERVAL, CLIPBOARD_NAME as NAME,
-    CONTENT,
+    check_clipboard, ClipboardContext, ClipboardSide, CLIPBOARD_INTERVAL as INTERVAL,
+    CLIPBOARD_NAME as NAME,
+};
+use clipboard_master::{CallbackResult, ClipboardHandler};
+use std::{
+    io,
+    sync::mpsc::{channel, RecvTimeoutError, Sender},
+    time::Duration,
 };
 
-#[derive(Default)]
-struct State {
+struct Handler {
+    sp: EmptyExtraFieldService,
     ctx: Option<ClipboardContext>,
-}
-
-impl super::service::Reset for State {
-    fn reset(&mut self) {
-        *CONTENT.lock().unwrap() = Default::default();
-        self.ctx = None;
-    }
-
-    fn init(&mut self) {
-        let ctx = match ClipboardContext::new(true) {
-            Ok(ctx) => Some(ctx),
-            Err(err) => {
-                log::error!("Failed to start {}: {}", NAME, err);
-                None
-            }
-        };
-        self.ctx = ctx;
-    }
+    tx_cb_result: Sender<CallbackResult>,
 }
 
 pub fn new() -> GenericService {
     let svc = EmptyExtraFieldService::new(NAME.to_owned(), true);
-    GenericService::repeat::<State, _, _>(&svc.clone(), INTERVAL, run);
+    GenericService::run(&svc.clone(), run);
     svc.sp
 }
 
-fn run(sp: EmptyExtraFieldService, state: &mut State) -> ResultType<()> {
-    if let Some(msg) = check_clipboard(&mut state.ctx, None) {
-        sp.send(msg);
-    }
-    sp.snapshot(|sps| {
-        let data = CONTENT.lock().unwrap().clone();
-        if !data.is_empty() {
-            let msg_out = data.create_msg();
-            sps.send_shared(Arc::new(msg_out));
+fn run(sp: EmptyExtraFieldService) -> ResultType<()> {
+    let (tx_cb_result, rx_cb_result) = channel();
+    let handler = Handler {
+        sp: sp.clone(),
+        ctx: Some(ClipboardContext::new()?),
+        tx_cb_result,
+    };
+
+    let (tx_start_res, rx_start_res) = channel();
+    let h = crate::clipboard::start_clipbard_master_thread(handler, tx_start_res);
+    let shutdown = match rx_start_res.recv() {
+        Ok((Some(s), _)) => s,
+        Ok((None, err)) => {
+            bail!(err);
         }
-        Ok(())
-    })?;
+        Err(e) => {
+            bail!("Failed to create clipboard listener: {}", e);
+        }
+    };
+
+    while sp.ok() {
+        match rx_cb_result.recv_timeout(Duration::from_millis(INTERVAL)) {
+            Ok(CallbackResult::Stop) => {
+                log::debug!("Clipboard listener stopped");
+                break;
+            }
+            Ok(CallbackResult::StopWithError(err)) => {
+                bail!("Clipboard listener stopped with error: {}", err);
+            }
+            Err(RecvTimeoutError::Timeout) => {}
+            _ => {}
+        }
+    }
+    shutdown.signal();
+    h.join().ok();
+
     Ok(())
 }
+
+impl ClipboardHandler for Handler {
+    fn on_clipboard_change(&mut self) -> CallbackResult {
+        self.sp.snapshot(|_sps| Ok(())).ok();
+        if let Some(msg) = check_clipboard(&mut self.ctx, ClipboardSide::Host, false) {
+            self.sp.send(msg);
+        }
+        CallbackResult::Next
+    }
+
+    fn on_clipboard_error(&mut self, error: io::Error) -> CallbackResult {
+        self.tx_cb_result
+            .send(CallbackResult::StopWithError(error))
+            .ok();
+        CallbackResult::Next
+    }
+}

src/server/connection.rs

@@ -1,6 +1,6 @@
 use super::{input_service::*, *};
 #[cfg(not(any(target_os = "android", target_os = "ios")))]
-use crate::clipboard::update_clipboard;
+use crate::clipboard::{update_clipboard, ClipboardSide};
 #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
 use crate::clipboard_file::*;
 #[cfg(target_os = "android")]
@@ -682,8 +682,19 @@ impl Connection {
                                 msg = Arc::new(new_msg);
                             }
                         }
+                        Some(message::Union::MultiClipboards(_multi_clipboards)) => {
+                            #[cfg(not(any(target_os = "android", target_os = "ios")))]
+                            if let Some(msg_out) = crate::clipboard::get_msg_if_not_support_multi_clip(&conn.lr.version, &conn.lr.my_platform, _multi_clipboards) {
+                                if let Err(err) = conn.stream.send(&msg_out).await {
+                                    conn.on_close(&err.to_string(), false).await;
+                                    break;
+                                }
+                                continue;
+                            }
+                        }
                         _ => {}
                     }
+
                     let msg: &Message = &msg;
                     if let Err(err) = conn.stream.send(msg).await {
                         conn.on_close(&err.to_string(), false).await;
@@ -2049,7 +2060,7 @@ impl Connection {
                 Some(message::Union::Clipboard(cb)) => {
                     if self.clipboard {
                         #[cfg(not(any(target_os = "android", target_os = "ios")))]
-                        update_clipboard(cb, None);
+                        update_clipboard(vec![cb], ClipboardSide::Host);
                         #[cfg(all(feature = "flutter", target_os = "android"))]
                         {
                             let content = if cb.compress {
@@ -2070,6 +2081,13 @@ impl Connection {
                         }
                     }
                 }
+                Some(message::Union::MultiClipboards(_mcb)) =>
+                {
+                    #[cfg(not(any(target_os = "android", target_os = "ios")))]
+                    if self.clipboard {
+                        update_clipboard(_mcb.clipboards, ClipboardSide::Host);
+                    }
+                }
                 Some(message::Union::Cliprdr(_clip)) =>
                 {
                     #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]