refactor remote interface

src/ui_session_interface.rs

@@ -0,0 +1,257 @@
+use crate::client::{
+    self, check_if_retry, handle_hash, handle_login_from_ui, handle_test_delay, input_os_password,
+    FileManager, LoginConfigHandler, QualityStatus, load_config,
+};
+use crate::{client::Data, client::Interface};
+use async_trait::async_trait;
+use hbb_common::config::PeerConfig;
+use hbb_common::message_proto::{CursorData, Hash, PeerInfo, TestDelay, CursorPosition};
+use hbb_common::tokio::{
+    self,
+    sync::mpsc,
+    time::{self, Duration, Instant, Interval},
+};
+use hbb_common::{get_version_number, log, Stream};
+use std::ops::{Deref, DerefMut};
+use std::sync::{Arc, RwLock};
+
+#[derive(Clone, Default)]
+pub struct Session<T: InvokeUi> {
+    pub cmd: String,
+    pub id: String,
+    pub password: String,
+    pub args: Vec<String>,
+    pub lc: Arc<RwLock<LoginConfigHandler>>,
+    pub sender: Arc<RwLock<Option<mpsc::UnboundedSender<Data>>>>,
+    pub ui_handler: T,
+}
+
+impl<T: InvokeUi> Session<T> {
+    pub fn get_option(&self, k: String) -> String {
+        self.lc.read().unwrap().get_option(&k)
+    }
+
+    pub fn set_option(&self, k: String, v: String) {
+        self.lc.write().unwrap().set_option(k, v);
+    }
+    
+    #[inline]
+    pub fn load_config(&self) -> PeerConfig {
+        load_config(&self.id)
+    }
+
+    #[inline]
+    pub(super) fn save_config(&self, config: PeerConfig) {
+        self.lc.write().unwrap().save_config(config);
+    }
+
+    pub fn is_restarting_remote_device(&self) -> bool {
+        self.lc.read().unwrap().restarting_remote_device
+    }
+
+    #[inline]
+    pub fn peer_platform(&self) -> String {
+        self.lc.read().unwrap().info.platform.clone()
+    }
+
+    pub fn get_platform(&mut self, is_remote: bool) -> String {
+        if is_remote {
+            self.peer_platform()
+        } else {
+            whoami::platform().to_string()
+        }
+    }
+
+    pub fn get_path_sep(&mut self, is_remote: bool) -> &'static str {
+        let p = self.get_platform(is_remote);
+        if &p == "Windows" {
+            return "\\";
+        } else {
+            return "/";
+        }
+    }
+}
+
+pub trait InvokeUi: Send + Sync + Clone + 'static + Sized + Default {
+    fn set_cursor_data(&self, cd: CursorData);
+    fn set_cursor_id(&self, id: String);
+    fn set_cursor_position(&self, cp:CursorPosition);
+    fn set_display(&self, x: i32, y: i32, w: i32, h: i32);
+    fn update_privacy_mode(&self);
+    fn set_permission(&self, name: &str, value: bool);
+    fn update_pi(&self, pi: PeerInfo);
+    fn close_success(&self);
+    fn update_quality_status(&self, qs: QualityStatus);
+    fn set_connection_type(&self,is_secured: bool, direct: bool);
+    fn job_error(&self,id:i32, err:String, file_num:i32);
+    fn job_done(&self,id:i32, file_num:i32);
+    fn clear_all_jobs(&self);
+    fn add_job(&self, id:i32, path:String, to:String, file_num:i32, show_hidden:bool, is_remote:bool);
+    fn update_transfer_list(&self);
+    // fn update_folder_files(&self); // TODO
+    fn confirm_delete_files(&self,id:i32, i:i32, name:String);
+    fn override_file_confirm(&self, id:i32, file_num:i32, to:String, is_upload:bool);
+    fn job_progress(&self, id:i32, file_num:i32, speed:f64, finished_size:f64);
+    fn adapt_size(&self);
+}
+
+
+impl<T: InvokeUi> Deref for Session<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.ui_handler
+    }
+}
+
+impl<T: InvokeUi> DerefMut for Session<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.ui_handler
+    }
+}
+
+impl<T: InvokeUi> FileManager for Session<T> {}
+
+#[async_trait]
+impl<T: InvokeUi> Interface for Session<T> {
+    fn send(&self, data: Data) {
+        if let Some(sender) = self.sender.read().unwrap().as_ref() {
+            sender.send(data).ok();
+        }
+    }
+
+    fn is_file_transfer(&self) -> bool {
+        self.cmd == "--file-transfer"
+    }
+
+    fn is_port_forward(&self) -> bool {
+        self.cmd == "--port-forward" || self.is_rdp()
+    }
+
+    fn is_rdp(&self) -> bool {
+        self.cmd == "--rdp"
+    }
+
+    fn msgbox(&self, msgtype: &str, title: &str, text: &str) {
+        let retry = check_if_retry(msgtype, title, text);
+        // self.call2("msgbox_retry", &make_args!(msgtype, title, text, retry));
+    }
+
+    fn handle_login_error(&mut self, err: &str) -> bool {
+        self.lc.write().unwrap().handle_login_error(err, self)
+    }
+
+    fn handle_peer_info(&mut self, pi: PeerInfo) {
+        // let mut pi_sciter = Value::map();
+        let username = self.lc.read().unwrap().get_username(&pi);
+        // pi_sciter.set_item("username", username.clone());
+        // pi_sciter.set_item("hostname", pi.hostname.clone());
+        // pi_sciter.set_item("platform", pi.platform.clone());
+        // pi_sciter.set_item("sas_enabled", pi.sas_enabled);
+        if get_version_number(&pi.version) < get_version_number("1.1.10") {
+            self.set_permission("restart", false);
+        }
+        if self.is_file_transfer() {
+            if pi.username.is_empty() {
+                self.on_error("No active console user logged on, please connect and logon first.");
+                return;
+            }
+        } else if !self.is_port_forward() {
+            if pi.displays.is_empty() {
+                self.lc.write().unwrap().handle_peer_info(username, pi);
+                self.update_privacy_mode();
+                self.msgbox("error", "Remote Error", "No Display");
+                return;
+            }
+            // let mut displays = Value::array(0);
+            // for ref d in pi.displays.iter() {
+            //     let mut display = Value::map();
+            //     display.set_item("x", d.x);
+            //     display.set_item("y", d.y);
+            //     display.set_item("width", d.width);
+            //     display.set_item("height", d.height);
+            //     displays.push(display);
+            // }
+            // pi_sciter.set_item("displays", displays);
+            let mut current = pi.current_display as usize;
+            if current >= pi.displays.len() {
+                current = 0;
+            }
+            // pi_sciter.set_item("current_display", current as i32);
+            let current = &pi.displays[current];
+            self.set_display(current.x, current.y, current.width, current.height);
+            // https://sciter.com/forums/topic/color_spaceiyuv-crash
+            // Nothing spectacular in decoder – done on CPU side.
+            // So if you can do BGRA translation on your side – the better.
+            // BGRA is used as internal image format so it will not require additional transformations.
+            // VIDEO.lock().unwrap().as_mut().map(|v| {
+            //     let ok = v.start_streaming(
+            //         (current.width as _, current.height as _),
+            //         COLOR_SPACE::Rgb32,
+            //         None,
+            //     );
+            //     log::info!("[video] initialized: {:?}", ok);
+            // });
+            let p = self.lc.read().unwrap().should_auto_login();
+            if !p.is_empty() {
+                input_os_password(p, true, self.clone());
+            }
+        }
+        self.lc.write().unwrap().handle_peer_info(username, pi);
+        self.update_privacy_mode();
+        // self.update_pi(pi);
+        if self.is_file_transfer() {
+            self.close_success();
+        } else if !self.is_port_forward() {
+            self.msgbox("success", "Successful", "Connected, waiting for image...");
+        }
+        #[cfg(windows)]
+        {
+            let mut path = std::env::temp_dir();
+            path.push(&self.id);
+            let path = path.with_extension(crate::get_app_name().to_lowercase());
+            std::fs::File::create(&path).ok();
+            if let Some(path) = path.to_str() {
+                crate::platform::windows::add_recent_document(&path);
+            }
+        }
+        // self.start_keyboard_hook(); // TODO
+    }
+
+    async fn handle_hash(&mut self, pass: &str, hash: Hash, peer: &mut Stream) {
+        handle_hash(self.lc.clone(), pass, hash, self, peer).await;
+    }
+
+    async fn handle_login_from_ui(&mut self, password: String, remember: bool, peer: &mut Stream) {
+        handle_login_from_ui(self.lc.clone(), password, remember, peer).await;
+    }
+
+    async fn handle_test_delay(&mut self, t: TestDelay, peer: &mut Stream) {
+        if !t.from_client {
+            self.update_quality_status(QualityStatus {
+                delay: Some(t.last_delay as _),
+                target_bitrate: Some(t.target_bitrate as _),
+                ..Default::default()
+            });
+            handle_test_delay(t, peer).await;
+        }
+    }
+
+    fn set_force_relay(&mut self, direct: bool, received: bool) {
+        let mut lc = self.lc.write().unwrap();
+        lc.force_relay = false;
+        if direct && !received {
+            let errno = errno::errno().0;
+            log::info!("errno is {}", errno);
+            // TODO: check mac and ios
+            if cfg!(windows) && errno == 10054 || !cfg!(windows) && errno == 104 {
+                lc.force_relay = true;
+                lc.set_option("force-always-relay".to_owned(), "Y".to_owned());
+            }
+        }
+    }
+
+    fn is_force_relay(&self) -> bool {
+        self.lc.read().unwrap().force_relay
+    }
+}