privacy_mode: win10 magnifier

Signed-off-by: fufesou <shuanglongchen@yeah.net>

src/server/connection.rs

@@ -50,8 +50,6 @@ enum MessageInput {
     Key((KeyEvent, bool)),
     BlockOn,
     BlockOff,
-    PrivacyOn,
-    PrivacyOff,
 }
 
 pub struct Connection {
@@ -74,7 +72,6 @@ pub struct Connection {
     image_quality: i32,
     lock_after_session_end: bool,
     show_remote_cursor: bool, // by peer
-    privacy_mode: bool,
     ip: String,
     disable_clipboard: bool,                  // by peer
     disable_audio: bool,                      // by peer
@@ -160,7 +157,6 @@ impl Connection {
             image_quality: ImageQuality::Balanced.value(),
             lock_after_session_end: false,
             show_remote_cursor: false,
-            privacy_mode: false,
             ip: "".to_owned(),
             disable_audio: false,
             enable_file_transfer: false,
@@ -281,6 +277,34 @@ impl Connection {
                                 allow_err!(conn.stream.send(&clip_2_msg(_clip)).await);
                             }
                         }
+                        ipc::Data::PrivacyModeState((_, state)) => {
+                            let msg_out = match state {
+                                ipc::PrivacyModeState::OffSucceeded => {
+                                    video_service::set_privacy_mode_conn_id(0);
+                                    crate::common::make_privacy_mode_msg(
+                                        back_notification::PrivacyModeState::OffSucceeded,
+                                    )
+                                }
+                                ipc::PrivacyModeState::OffFailed => {
+                                    crate::common::make_privacy_mode_msg(
+                                        back_notification::PrivacyModeState::OffFailed,
+                                    )
+                                }
+                                ipc::PrivacyModeState::OffByPeer => {
+                                    video_service::set_privacy_mode_conn_id(0);
+                                    crate::common::make_privacy_mode_msg(
+                                        back_notification::PrivacyModeState::OffByPeer,
+                                    )
+                                }
+                                ipc::PrivacyModeState::OffUnknown => {
+                                    video_service::set_privacy_mode_conn_id(0);
+                                     crate::common::make_privacy_mode_msg(
+                                        back_notification::PrivacyModeState::OffUnknown,
+                                    )
+                                }
+                            };
+                            conn.send(msg_out).await;
+                        }
                         _ => {}
                     }
                 },
@@ -362,9 +386,13 @@ impl Connection {
             }
         }
 
+        if video_service::get_privacy_mode_conn_id() == id {
+            video_service::set_privacy_mode_conn_id(0);
+            let _ = privacy_mode::turn_off_privacy(id).await;
+        }
         video_service::notify_video_frame_feched(id, None);
-        super::video_service::update_test_latency(id, 0);
-        super::video_service::update_image_quality(id, None);
+        video_service::update_test_latency(id, 0);
+        video_service::update_image_quality(id, None);
         if let Err(err) = conn.try_port_forward_loop(&mut rx_from_cm).await {
             conn.on_close(&err.to_string(), false);
         }
@@ -378,9 +406,6 @@ impl Connection {
     #[cfg(not(any(target_os = "android", target_os = "ios")))]
     fn handle_input(receiver: std_mpsc::Receiver<MessageInput>, tx: Sender) {
         let mut block_input_mode = false;
-        let (tx_blank, rx_blank) = std_mpsc::channel();
-
-        std::thread::spawn(|| Self::handle_blank(rx_blank));
 
         loop {
             match receiver.recv_timeout(std::time::Duration::from_millis(500)) {
@@ -402,28 +427,22 @@ impl Connection {
                         if crate::platform::block_input(true) {
                             block_input_mode = true;
                         } else {
-                            Self::send_option_error(&tx, "Failed to turn on block input mode");
+                            Self::send_block_input_error(
+                                &tx,
+                                back_notification::BlockInputState::OnFailed,
+                            );
                         }
                     }
                     MessageInput::BlockOff => {
                         if crate::platform::block_input(false) {
                             block_input_mode = false;
                         } else {
-                            Self::send_option_error(&tx, "Failed to turn off block input mode");
+                            Self::send_block_input_error(
+                                &tx,
+                                back_notification::BlockInputState::OffFailed,
+                            );
                         }
                     }
-                    MessageInput::PrivacyOn => {
-                        if crate::platform::block_input(true) {
-                            block_input_mode = true;
-                        }
-                        tx_blank.send(MessageInput::PrivacyOn).ok();
-                    }
-                    MessageInput::PrivacyOff => {
-                        if crate::platform::block_input(false) {
-                            block_input_mode = false;
-                        }
-                        tx_blank.send(MessageInput::PrivacyOff).ok();
-                    }
                 },
                 Err(err) => {
                     #[cfg(not(any(target_os = "android", target_os = "ios")))]
@@ -439,35 +458,6 @@ impl Connection {
         log::info!("Input thread exited");
     }
 
-    #[cfg(not(any(target_os = "android", target_os = "ios")))]
-    fn handle_blank(receiver: std_mpsc::Receiver<MessageInput>) {
-        let mut last_privacy = false;
-        loop {
-            match receiver.recv_timeout(std::time::Duration::from_millis(500)) {
-                Ok(v) => match v {
-                    MessageInput::PrivacyOn => {
-                        crate::platform::toggle_blank_screen(true);
-                        last_privacy = true;
-                    }
-                    MessageInput::PrivacyOff => {
-                        crate::platform::toggle_blank_screen(false);
-                        last_privacy = false;
-                    }
-                    _ => break,
-                },
-                Err(err) => {
-                    if last_privacy {
-                        crate::platform::toggle_blank_screen(true);
-                    }
-                    if std_mpsc::RecvTimeoutError::Disconnected == err {
-                        break;
-                    }
-                }
-            }
-        }
-        log::info!("Blank thread exited");
-    }
-
     async fn try_port_forward_loop(
         &mut self,
         rx_from_cm: &mut mpsc::UnboundedReceiver<Data>,
@@ -657,8 +647,19 @@ impl Connection {
             }
         }
         self.authorized = true;
-        pi.username = username;
-        pi.sas_enabled = sas_enabled;
+
+        let mut pi = PeerInfo {
+            hostname: whoami::hostname(),
+            username,
+            platform: whoami::platform().to_string(),
+            version: crate::VERSION.to_owned(),
+            sas_enabled,
+            features: Some(Features {
+                privacy_mode: video_service::is_privacy_mode_supported(),
+                ..Default::default()
+            }).into(),
+            ..Default::default()
+        };
         let mut sub_service = false;
         if self.file_transfer.is_some() {
             res.set_peer_info(pi);
@@ -755,13 +756,13 @@ impl Connection {
         self.send(msg_out).await;
     }
 
-    fn send_option_error<T: std::string::ToString>(s: &Sender, err: T) {
-        let mut msg_out = Message::new();
-        let mut res = OptionResponse::new();
+    #[inline]
+    pub fn send_block_input_error(s: &Sender, state: back_notification::BlockInputState) {
         let mut misc = Misc::new();
-        res.error = err.to_string();
-
-        misc.set_option_response(res);
+        let mut back_notification = BackNotification::new();
+        back_notification.set_block_input_state(state);
+        misc.set_back_notification(back_notification);
+        let mut msg_out = Message::new();
         msg_out.set_misc(misc);
         s.send((Instant::now(), Arc::new(msg_out))).ok();
     }
@@ -1162,12 +1163,44 @@ impl Connection {
             if self.keyboard {
                 match q {
                     BoolOption::Yes => {
-                        self.privacy_mode = true;
-                        self.tx_input.send(MessageInput::PrivacyOn).ok();
+                        let msg_out = if !video_service::is_privacy_mode_supported() {
+                            crate::common::make_privacy_mode_msg(
+                                back_notification::PrivacyModeState::NotSupported,
+                            )
+                        } else {
+                            video_service::set_privacy_mode_conn_id(0);
+                            match privacy_mode::turn_on_privacy(self.inner.id) {
+                                Ok(true) => {
+                                    video_service::set_privacy_mode_conn_id(self.inner.id);
+                                    crate::common::make_privacy_mode_msg(
+                                        back_notification::PrivacyModeState::OnSucceeded,
+                                    )
+                                }
+                                Ok(false) => {
+                                    crate::common::make_privacy_mode_msg(
+                                        back_notification::PrivacyModeState::OnFailedPlugin,
+                                    )
+                                }
+                                Err(e) => {
+                                    log::error!("Failed to turn on privacy mode. {}", e);
+                                    crate::common::make_privacy_mode_msg(
+                                        back_notification::PrivacyModeState::OnFailed,
+                                    )
+                                }
+                            }
+                        };
+                        self.send(msg_out).await;
                     }
                     BoolOption::No => {
-                        self.privacy_mode = false;
-                        self.tx_input.send(MessageInput::PrivacyOff).ok();
+                        let msg_out = if !video_service::is_privacy_mode_supported() {
+                            crate::common::make_privacy_mode_msg(
+                                back_notification::PrivacyModeState::NotSupported,
+                            )
+                        } else {
+                            video_service::set_privacy_mode_conn_id(0);
+                            privacy_mode::turn_off_privacy(self.inner.id).await
+                        };
+                        self.send(msg_out).await;
                     }
                     _ => {}
                 }
@@ -1318,3 +1351,43 @@ fn try_activate_screen() {
         mouse_move_relative(6, 6);
     });
 }
+
+mod privacy_mode {
+    use super::*;
+
+    pub(super) async fn turn_off_privacy(_conn_id: i32) -> Message {
+        #[cfg(windows)]
+        {
+            use crate::ui::win_privacy::*;
+
+            let res = turn_off_privacy(_conn_id, None);
+            match res {
+                Ok(_) => crate::common::make_privacy_mode_msg(
+                    back_notification::PrivacyModeState::OffSucceeded,
+                ),
+                Err(e) => {
+                    log::error!("Failed to turn off privacy mode{}", e);
+                    crate::common::make_privacy_mode_msg(
+                        back_notification::PrivacyModeState::OffFailed,
+                    )
+                }
+            }
+        }
+        #[cfg(not(windows))]
+        {
+            crate::common::make_privacy_mode_msg(back_notification::PrivacyModeState::OffFailed)
+        }
+    }
+
+    pub(super) fn turn_on_privacy(_conn_id: i32) -> ResultType<bool> {
+        #[cfg(windows)]
+        {
+            let plugin_exitst = crate::ui::win_privacy::turn_on_privacy(_conn_id)?;
+            Ok(plugin_exitst)
+        }
+        #[cfg(not(windows))]
+        {
+            Ok(true)
+        }
+    }
+}

src/server/service.rs

@@ -148,6 +148,16 @@ impl<T: Subscriber + From<ConnInner>> ServiceTmpl<T> {
         }
     }
 
+    pub fn send_to_others(&self, msg: Message, id: i32) {
+        let msg = Arc::new(msg);
+        let mut lock = self.0.write().unwrap();
+        for (sid, s) in lock.subscribes.iter_mut() {
+            if *sid != id {
+                s.send(msg.clone());
+            }
+        }
+    }
+
     pub fn send_shared(&self, msg: Arc<Message>) {
         let mut lock = self.0.write().unwrap();
         for s in lock.subscribes.values_mut() {

src/server/video_service.rs

@@ -26,10 +26,10 @@ use hbb_common::tokio::{
         Mutex as TokioMutex,
     },
 };
-use scrap::{Capturer, Config, Display, EncodeFrame, Encoder, VideoCodecId, STRIDE_ALIGN};
+use scrap::{Capturer, Config, Display, EncodeFrame, Encoder, Frame, VideoCodecId, STRIDE_ALIGN};
 use std::{
     collections::HashSet,
-    io::ErrorKind::WouldBlock,
+    io::{ErrorKind::WouldBlock, Result},
     time::{self, Duration, Instant},
 };
 
@@ -45,12 +45,36 @@ lazy_static::lazy_static! {
         let (tx, rx) = unbounded_channel();
         (tx, Arc::new(TokioMutex::new(rx)))
     };
+    static ref PRIVACY_MODE_CONN_ID: Mutex<i32> = Mutex::new(0);
+    static ref IS_CAPTURER_MAGNIFIER_SUPPORTED: bool = is_capturer_mag_supported();
+}
+
+fn is_capturer_mag_supported() -> bool {
+    #[cfg(windows)]
+    return scrap::CapturerMag::is_supported();
+    #[cfg(not(windows))]
+    false
 }
 
 pub fn notify_video_frame_feched(conn_id: i32, frame_tm: Option<Instant>) {
     FRAME_FETCHED_NOTIFIER.0.send((conn_id, frame_tm)).unwrap()
 }
 
+pub fn set_privacy_mode_conn_id(conn_id: i32) {
+    *PRIVACY_MODE_CONN_ID.lock().unwrap() = conn_id
+}
+
+pub fn get_privacy_mode_conn_id() -> i32 {
+    *PRIVACY_MODE_CONN_ID.lock().unwrap()
+}
+
+pub fn is_privacy_mode_supported() -> bool {
+    #[cfg(windows)]
+    return *IS_CAPTURER_MAGNIFIER_SUPPORTED;
+    #[cfg(not(windows))]
+    return false;
+}
+
 struct VideoFrameController {
     cur: Instant,
     send_conn_ids: HashSet<i32>,
@@ -120,6 +144,46 @@ impl VideoFrameController {
     }
 }
 
+trait TraitCapturer {
+    fn frame<'a>(&'a mut self, timeout_ms: u32) -> Result<Frame<'a>>;
+
+    #[cfg(windows)]
+    fn is_gdi(&self) -> bool;
+    #[cfg(windows)]
+    fn set_gdi(&mut self) -> bool;
+}
+
+impl TraitCapturer for Capturer {
+    fn frame<'a>(&'a mut self, timeout_ms: u32) -> Result<Frame<'a>> {
+        self.frame(timeout_ms)
+    }
+
+    #[cfg(windows)]
+    fn is_gdi(&self) -> bool {
+        self.is_gdi()
+    }
+
+    #[cfg(windows)]
+    fn set_gdi(&mut self) -> bool {
+        self.set_gdi()
+    }
+}
+
+#[cfg(windows)]
+impl TraitCapturer for scrap::CapturerMag {
+    fn frame<'a>(&'a mut self, _timeout_ms: u32) -> Result<Frame<'a>> {
+        self.frame(_timeout_ms)
+    }
+
+    fn is_gdi(&self) -> bool {
+        false
+    }
+
+    fn set_gdi(&mut self) -> bool {
+        false
+    }
+}
+
 pub fn new() -> GenericService {
     let sp = GenericService::new(NAME, true);
     sp.run(run);
@@ -156,6 +220,76 @@ fn check_display_changed(
     return false;
 }
 
+// Capturer object is expensive, avoiding to create it frequently.
+fn create_capturer(privacy_mode_id: i32, display: Display) -> ResultType<Box<dyn TraitCapturer>> {
+    let use_yuv = true;
+
+    #[cfg(not(windows))]
+    let c: Option<Box<dyn TraitCapturer>> = None;
+    #[cfg(windows)]
+    let mut c: Option<Box<dyn TraitCapturer>> = None;
+    if privacy_mode_id > 0 {
+        #[cfg(windows)]
+        {
+            use crate::ui::win_privacy::*;
+
+            match scrap::CapturerMag::new(
+                display.origin(),
+                display.width(),
+                display.height(),
+                use_yuv,
+            ) {
+                Ok(mut c1) => {
+                    let mut ok = false;
+                    let check_begin = Instant::now();
+                    while check_begin.elapsed().as_secs() < 5 {
+                        match c1.exclude("", PRIVACY_WINDOW_NAME) {
+                            Ok(false) => {
+                                ok = false;
+                                std::thread::sleep(std::time::Duration::from_millis(500));
+                            }
+                            Err(e) => {
+                                bail!(
+                                    "Failed to exclude privacy window {} - {}, err: {}",
+                                    "",
+                                    PRIVACY_WINDOW_NAME,
+                                    e
+                                );
+                            }
+                            _ => {
+                                ok = true;
+                                break;
+                            }
+                        }
+                    }
+                    if !ok {
+                        bail!(
+                            "Failed to exclude privacy window {} - {} ",
+                            "",
+                            PRIVACY_WINDOW_NAME
+                        );
+                    }
+                    c = Some(Box::new(c1));
+                }
+                Err(e) => {
+                    bail!(format!("Failed to create magnifier capture {}", e));
+                }
+            }
+        }
+    }
+
+    let c = match c {
+        Some(c1) => c1,
+        None => {
+            let c1 =
+                Capturer::new(display, use_yuv).with_context(|| "Failed to create capturer")?;
+            Box::new(c1)
+        }
+    };
+
+    Ok(c)
+}
+
 fn run(sp: GenericService) -> ResultType<()> {
     let fps = 30;
     let wait = 1000 / fps;
@@ -172,8 +306,9 @@ fn run(sp: GenericService) -> ResultType<()> {
         num_cpus::get_physical(),
         num_cpus::get(),
     );
-    // Capturer object is expensive, avoiding to create it frequently.
-    let mut c = Capturer::new(display, true).with_context(|| "Failed to create capturer")?;
+
+    let privacy_mode_id = *PRIVACY_MODE_CONN_ID.lock().unwrap();
+    let mut c = create_capturer(privacy_mode_id, display)?;
 
     let q = get_image_quality();
     let (bitrate, rc_min_quantizer, rc_max_quantizer, speed) = get_quality(width, height, q);
@@ -227,6 +362,7 @@ fn run(sp: GenericService) -> ResultType<()> {
             *SWITCH.lock().unwrap() = true;
             bail!("SWITCH");
         }
+        check_privacy_mode_changed(&sp, privacy_mode_id)?;
         if get_image_quality() != q {
             bail!("SWITCH");
         }
@@ -250,7 +386,7 @@ fn run(sp: GenericService) -> ResultType<()> {
         frame_controller.reset();
 
         #[cfg(any(target_os = "android", target_os = "ios"))]
-        let res = match c.frame(wait as _) {
+        let res = match (*c).frame(wait as _) {
             Ok(frame) => {
                 let time = now - start;
                 let ms = (time.as_secs() * 1000 + time.subsec_millis() as u64) as i64;
@@ -273,7 +409,7 @@ fn run(sp: GenericService) -> ResultType<()> {
         };
 
         #[cfg(not(any(target_os = "android", target_os = "ios")))]
-        let res = match c.frame(wait as _) {
+        let res = match (*c).frame(wait as _) {
             Ok(frame) => {
                 let time = now - start;
                 let ms = (time.as_secs() * 1000 + time.subsec_millis() as u64) as i64;
@@ -333,6 +469,21 @@ fn run(sp: GenericService) -> ResultType<()> {
     Ok(())
 }
 
+#[inline]
+fn check_privacy_mode_changed(sp: &GenericService, privacy_mode_id: i32) -> ResultType<()> {
+    let privacy_mode_id_2 = *PRIVACY_MODE_CONN_ID.lock().unwrap();
+    if privacy_mode_id != privacy_mode_id_2 {
+        if privacy_mode_id_2 != 0 {
+            let msg_out = crate::common::make_privacy_mode_msg(
+                back_notification::PrivacyModeState::OnByOther,
+            );
+            sp.send_to_others(msg_out, privacy_mode_id_2);
+        }
+        bail!("SWITCH");
+    }
+    Ok(())
+}
+
 #[inline]
 fn create_msg(vp9s: Vec<VP9>) -> Message {
     let mut msg_out = Message::new();