From 5164f7691949d68befb058f38485663c2e3353d9 Mon Sep 17 00:00:00 2001
From: cc-morning <90960002+cc-morning@users.noreply.github.com>
Date: Mon, 25 Oct 2021 16:25:23 +0800
Subject: [PATCH] Fix lost clipboard content again

---
 src/server/clipboard_service.rs | 81 +++++++++++++++++----------------
 1 file changed, 42 insertions(+), 39 deletions(-)

diff --git a/src/server/clipboard_service.rs b/src/server/clipboard_service.rs
index a0711c8d9..f972771c3 100644
--- a/src/server/clipboard_service.rs
+++ b/src/server/clipboard_service.rs
@@ -4,34 +4,25 @@ pub use crate::common::{
     CONTENT,
 };
 use clipboard_master::{CallbackResult, ClipboardHandler, Master};
-use hbb_common::ResultType;
-use std::{sync, sync::mpsc::Sender, thread};
-
-struct State {
-    ctx: Option<ClipboardContext>,
-}
-
-impl Default for State {
-    fn default() -> Self {
-        let ctx = match ClipboardContext::new() {
-            Ok(ctx) => Some(ctx),
-            Err(err) => {
-                log::error!("Failed to start {}: {}", NAME, err);
-                None
-            }
-        };
-        Self { ctx }
-    }
-}
-
-impl super::service::Reset for State {
-    fn reset(&mut self) {
-        *CONTENT.lock().unwrap() = Default::default();
-    }
-}
+use hbb_common::{anyhow, ResultType};
+use std::{
+    sync,
+    sync::mpsc::{Receiver, Sender},
+    thread,
+    time::Duration,
+};
 
 pub fn new() -> GenericService {
     let sp = GenericService::new(NAME, true);
+
+    thread::spawn(|| {
+        let (tx, rx) = sync::mpsc::channel();
+        unsafe {
+            listen::RECEIVER = Some(rx);
+        }
+        let _ = listen::notify(tx);
+    });
+
     sp.run::<_>(listen::run);
     sp
 }
@@ -39,6 +30,10 @@ pub fn new() -> GenericService {
 mod listen {
     use super::*;
 
+    pub(super) static mut RECEIVER: Option<Receiver<()>> = None;
+    static mut CTX: Option<ClipboardContext> = None;
+    static WAIT: Duration = Duration::from_millis(1000);
+
     struct ClipHandle {
         tx: Sender<()>,
     }
@@ -50,19 +45,33 @@ mod listen {
         }
     }
 
-    fn notify(tx: Sender<()>) -> ResultType<()> {
+    pub fn notify(tx: Sender<()>) -> ResultType<()> {
         Master::new(ClipHandle { tx }).run()?;
         Ok(())
     }
 
     pub fn run(sp: GenericService) -> ResultType<()> {
-        let mut state = State::default();
-        let (tx, rx) = sync::mpsc::channel::<()>();
-        thread::spawn(|| {
-            let _ = notify(tx);
-        });
+        if unsafe { CTX.as_ref() }.is_none() {
+            match ClipboardContext::new() {
+                Ok(ctx) => unsafe {
+                    CTX = Some(ctx);
+                },
+                Err(err) => {
+                    log::error!("Failed to start {}: {}", NAME, err);
+                    return Err(anyhow::Error::from(err));
+                }
+            };
+        }
 
         while sp.ok() {
+            if let Ok(_) = unsafe { RECEIVER.as_ref() }.unwrap().recv_timeout(WAIT) {
+                if let Some(mut ctx) = unsafe { CTX.as_mut() } {
+                    if let Some(msg) = check_clipboard(&mut ctx, None) {
+                        sp.send(msg);
+                    }
+                }
+            }
+
             sp.snapshot(|sps| {
                 let txt = crate::CONTENT.lock().unwrap().clone();
                 if !txt.is_empty() {
@@ -71,15 +80,9 @@ mod listen {
                 }
                 Ok(())
             })?;
-
-            if let Ok(()) = rx.recv() {
-                if let Some(ctx) = state.ctx.as_mut() {
-                    if let Some(msg) = check_clipboard(ctx, None) {
-                        sp.send(msg);
-                    }
-                }
-            }
         }
+
+        *CONTENT.lock().unwrap() = Default::default();
         Ok(())
     }
 }