TheLanc3/rustdesk
1
0
Fork 0
mirror of https://github.com/rustdesk/rustdesk.git synced 2026-03-20 19:51:04 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge translate mode

Browse Source
This commit is contained in:
Asura
2022-08-04 16:11:37 +08:00
parent d08931c317 8b56a1a271
commit 3b8032e5ec
91 changed files with 2869 additions and 1419 deletions
Download Patch File Download Diff File Expand all files Collapse all files

115
src/ui/remote.rs
View File

@@ -23,10 +23,6 @@ use clipboard::{
get_rx_clip_client, server_clip_file,
};
use enigo::{self, Enigo, KeyboardControllable};
use hbb_common::fs::{
can_enable_overwrite_detection, get_job, get_string, new_send_confirm, DigestCheckResult,
RemoveJobMeta,
};
use hbb_common::{
allow_err,
config::{Config, LocalConfig, PeerConfig},
@@ -44,6 +40,13 @@ use hbb_common::{
};
use hbb_common::{config::TransferSerde, fs::TransferJobMeta};
use rdev::{Event, EventType::*, Key as RdevKey};
use hbb_common::{
fs::{
can_enable_overwrite_detection, get_job, get_string, new_send_confirm, DigestCheckResult,
RemoveJobMeta,
},
get_version_number,
};
#[cfg(windows)]
use crate::clipboard_file::*;
@@ -89,6 +92,7 @@ pub struct Handler {
inner: Arc<RwLock<HandlerInner>>,
cmd: String,
id: String,
password: String,
args: Vec<String>,
lc: Arc<RwLock<LoginConfigHandler>>,
}
@@ -238,23 +242,16 @@ impl sciter::EventHandler for Handler {
fn has_hwcodec();
fn supported_hwcodec();
fn change_prefer_codec();
fn restart_remote_device();
}
}
#[derive(Debug, Default)]
struct QualityStatus {
speed: Option<String>,
fps: Option<i32>,
delay: Option<i32>,
target_bitrate: Option<i32>,
codec_format: Option<CodecFormat>,
}
impl Handler {
pub fn new(cmd: String, id: String, args: Vec<String>) -> Self {
pub fn new(cmd: String, id: String, password: String, args: Vec<String>) -> Self {
let me = Self {
cmd,
id: id.clone(),
password: password.clone(),
args,
..Default::default()
};
@@ -480,6 +477,17 @@ impl Handler {
self.send(Data::Message(msg));
}
fn restart_remote_device(&mut self) {
let mut lc = self.lc.write().unwrap();
lc.restarting_remote_device = true;
let msg = lc.restart_remote_device();
self.send(Data::Message(msg));
}
pub fn is_restarting_remote_device(&self) -> bool {
self.lc.read().unwrap().restarting_remote_device
}
fn t(&self, name: String) -> String {
crate::client::translate(name)
}
@@ -993,7 +1001,7 @@ impl Handler {
fn transfer_file(&mut self) {
let id = self.get_id();
let args = vec!["--file-transfer", &id];
let args = vec!["--file-transfer", &id, &self.password];
if let Err(err) = crate::run_me(args) {
log::error!("Failed to spawn file transfer: {}", err);
}
@@ -1001,7 +1009,7 @@ impl Handler {
fn tunnel(&mut self) {
let id = self.get_id();
let args = vec!["--port-forward", &id];
let args = vec!["--port-forward", &id, &self.password];
if let Err(err) = crate::run_me(args) {
log::error!("Failed to spawn IP tunneling: {}", err);
}
@@ -1390,6 +1398,7 @@ async fn start_one_port_forward(
handler.lc.write().unwrap().port_forward = (remote_host, remote_port);
if let Err(err) = crate::port_forward::listen(
handler.id.clone(),
handler.password.clone(),
port,
handler.clone(),
receiver,
@@ -1626,8 +1635,13 @@ impl Remote {
}
}
} else {
log::info!("Reset by the peer");
self.handler.msgbox("error", "Connection Error", "Reset by the peer");
if self.handler.is_restarting_remote_device() {
log::info!("Restart remote device");
self.handler.msgbox("restarting", "Restarting Remote Device", "remote_restarting_tip");
} else {
log::info!("Reset by the peer");
self.handler.msgbox("error", "Connection Error", "Reset by the peer");
}
break;
}
}
@@ -1808,7 +1822,6 @@ impl Remote {
}
async fn handle_msg_from_ui(&mut self, data: Data, peer: &mut Stream) -> bool {
// log::info!("new msg from ui, {}",data);
match data {
Data::Close => {
let mut misc = Misc::new();
@@ -2197,6 +2210,22 @@ impl Remote {
true
}
async fn send_opts_after_login(&self, peer: &mut Stream) {
if let Some(opts) = self
.handler
.lc
.read()
.unwrap()
.get_option_message_after_login()
{
let mut misc = Misc::new();
misc.set_option(opts);
let mut msg_out = Message::new();
msg_out.set_misc(misc);
allow_err!(peer.send(&msg_out).await);
}
}
async fn handle_msg_from_peer(&mut self, data: &[u8], peer: &mut Stream) -> bool {
if let Ok(msg_in) = Message::parse_from_bytes(&data) {
match msg_in.union {
@@ -2205,6 +2234,7 @@ impl Remote {
self.first_frame = true;
self.handler.call2("closeSuccess", &make_args!());
self.handler.call("adaptSize", &make_args!());
self.send_opts_after_login(peer).await;
}
let incomming_format = CodecFormat::from(&vf);
if self.video_format != incomming_format {
@@ -2217,7 +2247,9 @@ impl Remote {
self.video_sender.send(MediaData::VideoFrame(vf)).ok();
}
Some(message::Union::Hash(hash)) => {
self.handler.handle_hash(hash, peer).await;
self.handler
.handle_hash(&self.handler.password.clone(), hash, peer)
.await;
}
Some(message::Union::LoginResponse(lr)) => match lr.union {
Some(login_response::Union::Error(err)) => {
@@ -2458,6 +2490,10 @@ impl Remote {
self.handler
.call2("setPermission", &make_args!("file", p.enabled));
}
Permission::Restart => {
self.handler
.call2("setPermission", &make_args!("restart", p.enabled));
}
}
}
Some(misc::Union::SwitchDisplay(s)) => {
@@ -2513,14 +2549,14 @@ impl Remote {
match notification.union {
Some(back_notification::Union::BlockInputState(state)) => {
self.handle_back_msg_block_input(
state.enum_value_or(back_notification::BlockInputState::StateUnknown),
state.enum_value_or(back_notification::BlockInputState::BlkStateUnknown),
)
.await;
}
Some(back_notification::Union::PrivacyModeState(state)) => {
if !self
.handle_back_msg_privacy_mode(
state.enum_value_or(back_notification::PrivacyModeState::StateUnknown),
state.enum_value_or(back_notification::PrivacyModeState::PrvStateUnknown),
)
.await
{
@@ -2539,18 +2575,18 @@ impl Remote {
async fn handle_back_msg_block_input(&mut self, state: back_notification::BlockInputState) {
match state {
back_notification::BlockInputState::OnSucceeded => {
back_notification::BlockInputState::BlkOnSucceeded => {
self.update_block_input_state(true);
}
back_notification::BlockInputState::OnFailed => {
back_notification::BlockInputState::BlkOnFailed => {
self.handler
.msgbox("custom-error", "Block user input", "Failed");
self.update_block_input_state(false);
}
back_notification::BlockInputState::OffSucceeded => {
back_notification::BlockInputState::BlkOffSucceeded => {
self.update_block_input_state(false);
}
back_notification::BlockInputState::OffFailed => {
back_notification::BlockInputState::BlkOffFailed => {
self.handler
.msgbox("custom-error", "Unblock user input", "Failed");
}
@@ -2572,7 +2608,7 @@ impl Remote {
state: back_notification::PrivacyModeState,
) -> bool {
match state {
back_notification::PrivacyModeState::OnByOther => {
back_notification::PrivacyModeState::PrvOnByOther => {
self.handler.msgbox(
"error",
"Connecting...",
@@ -2580,46 +2616,46 @@ impl Remote {
);
return false;
}
back_notification::PrivacyModeState::NotSupported => {
back_notification::PrivacyModeState::PrvNotSupported => {
self.handler
.msgbox("custom-error", "Privacy mode", "Unsupported");
self.update_privacy_mode(false);
}
back_notification::PrivacyModeState::OnSucceeded => {
back_notification::PrivacyModeState::PrvOnSucceeded => {
self.handler
.msgbox("custom-nocancel", "Privacy mode", "In privacy mode");
self.update_privacy_mode(true);
}
back_notification::PrivacyModeState::OnFailedDenied => {
back_notification::PrivacyModeState::PrvOnFailedDenied => {
self.handler
.msgbox("custom-error", "Privacy mode", "Peer denied");
self.update_privacy_mode(false);
}
back_notification::PrivacyModeState::OnFailedPlugin => {
back_notification::PrivacyModeState::PrvOnFailedPlugin => {
self.handler
.msgbox("custom-error", "Privacy mode", "Please install plugins");
self.update_privacy_mode(false);
}
back_notification::PrivacyModeState::OnFailed => {
back_notification::PrivacyModeState::PrvOnFailed => {
self.handler
.msgbox("custom-error", "Privacy mode", "Failed");
self.update_privacy_mode(false);
}
back_notification::PrivacyModeState::OffSucceeded => {
back_notification::PrivacyModeState::PrvOffSucceeded => {
self.handler
.msgbox("custom-nocancel", "Privacy mode", "Out privacy mode");
self.update_privacy_mode(false);
}
back_notification::PrivacyModeState::OffByPeer => {
back_notification::PrivacyModeState::PrvOffByPeer => {
self.handler
.msgbox("custom-error", "Privacy mode", "Peer exit");
self.update_privacy_mode(false);
}
back_notification::PrivacyModeState::OffFailed => {
back_notification::PrivacyModeState::PrvOffFailed => {
self.handler
.msgbox("custom-error", "Privacy mode", "Failed to turn off");
}
back_notification::PrivacyModeState::OffUnknown => {
back_notification::PrivacyModeState::PrvOffUnknown => {
self.handler
.msgbox("custom-error", "Privacy mode", "Turned off");
// log::error!("Privacy mode is turned off with unknown reason");
@@ -2710,6 +2746,9 @@ impl Interface for Handler {
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.call2("setPermission", &make_args!("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.");
@@ -2777,8 +2816,8 @@ impl Interface for Handler {
self.start_keyboard_hook();
}
async fn handle_hash(&mut self, hash: Hash, peer: &mut Stream) {
handle_hash(self.lc.clone(), hash, self, peer).await;
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) {