hongshaorou/rustdesk
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactor cm for clipboardfile

Browse Source
This commit is contained in:
rustdesk 2022-02-24 10:38:17 +08:00
parent 4fb8de9b68
commit 8770552448
1 changed files with 53 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

96
src/ui/cm.rs
View File

@ -111,8 +111,7 @@ impl ConnectionManager {
&self, &self,
id: i32, id: i32,
data: Data, data: Data,
_tx_clip_file: &mpsc::UnboundedSender<(i32, ipc::ClipbaordFile)>, _tx_clip_file: &mpsc::UnboundedSender<ClipboardFileData>,
_tx_clip_empty: &mpsc::UnboundedSender<i32>,
write_jobs: &mut Vec<fs::TransferJob>, write_jobs: &mut Vec<fs::TransferJob>,
conn: &mut Connection, conn: &mut Connection,
) { ) {
@ -195,14 +194,15 @@ impl ConnectionManager {
}, },
Data::ClipbaordFile(_clip) => { Data::ClipbaordFile(_clip) => {
#[cfg(windows)] #[cfg(windows)]
allow_err!(_tx_clip_file.send((id, _clip))); _tx_clip_file
.send(ClipboardFileData::Clip((id, _clip)))
.ok();
} }
Data::ClipboardFileEnabled(enabled) => { Data::ClipboardFileEnabled(enabled) => {
#[cfg(windows)] #[cfg(windows)]
set_conn_enabled(id, 0, enabled); _tx_clip_file
if !enabled { .send(ClipboardFileData::Enable((id, enabled)))
allow_err!(_tx_clip_empty.send(id)); .ok();
}
} }
_ => {} _ => {}
} }
@ -342,14 +342,18 @@ impl sciter::EventHandler for ConnectionManager {
} }
} }
enum ClipboardFileData {
Clip((i32, ipc::ClipbaordFile)),
Enable((i32, bool)),
}
#[tokio::main(flavor = "current_thread")] #[tokio::main(flavor = "current_thread")]
async fn start_ipc(cm: ConnectionManager) { async fn start_ipc(cm: ConnectionManager) {
let (tx_file, _rx_file) = mpsc::unbounded_channel::<(i32, ipc::ClipbaordFile)>(); let (tx_file, _rx_file) = mpsc::unbounded_channel::<ClipboardFileData>();
let (tx_clip_empty, _rx_clip_empty) = mpsc::unbounded_channel::<i32>();
#[cfg(windows)] #[cfg(windows)]
let cm_clip = cm.clone(); let cm_clip = cm.clone();
#[cfg(windows)] #[cfg(windows)]
std::thread::spawn(move || start_clipboard_file(cm_clip, _rx_file, _rx_clip_empty)); std::thread::spawn(move || start_clipboard_file(cm_clip, _rx_file));
match new_listener("_cm").await { match new_listener("_cm").await {
Ok(mut incoming) => { Ok(mut incoming) => {
@ -359,7 +363,6 @@ async fn start_ipc(cm: ConnectionManager) {
let mut stream = Connection::new(stream); let mut stream = Connection::new(stream);
let cm = cm.clone(); let cm = cm.clone();
let tx_file = tx_file.clone(); let tx_file = tx_file.clone();
let tx_clip_empty = tx_clip_empty.clone();
tokio::spawn(async move { tokio::spawn(async move {
let mut conn_id: i32 = 0; let mut conn_id: i32 = 0;
let (tx, mut rx) = mpsc::unbounded_channel::<Data>(); let (tx, mut rx) = mpsc::unbounded_channel::<Data>();
@ -376,20 +379,16 @@ async fn start_ipc(cm: ConnectionManager) {
match data { match data {
Data::Login{id, is_file_transfer, port_forward, peer_id, name, authorized, keyboard, clipboard, audio, file, file_transfer_enabled} => { Data::Login{id, is_file_transfer, port_forward, peer_id, name, authorized, keyboard, clipboard, audio, file, file_transfer_enabled} => {
conn_id = id; conn_id = id;
#[cfg(windows)] tx_file.send(ClipboardFileData::Enable((id, file_transfer_enabled))).ok();
set_conn_enabled(id, 0, file_transfer_enabled);
let _ = file_transfer_enabled;
cm.add_connection(id, is_file_transfer, port_forward, peer_id, name, authorized, keyboard, clipboard, audio, file, tx.clone()); cm.add_connection(id, is_file_transfer, port_forward, peer_id, name, authorized, keyboard, clipboard, audio, file, tx.clone());
} }
Data::Close => { Data::Close => {
allow_err!(tx_clip_empty.send(conn_id)); tx_file.send(ClipboardFileData::Enable((conn_id, false))).ok();
#[cfg(windows)]
set_conn_enabled(conn_id, 0, false);
log::info!("cm ipc connection closed from connection request"); log::info!("cm ipc connection closed from connection request");
break; break;
} }
_ => { _ => {
cm.handle_data(conn_id, data, &tx_file, &tx_clip_empty, &mut write_jobs, &mut stream).await; cm.handle_data(conn_id, data, &tx_file, &mut write_jobs, &mut stream).await;
} }
} }
} }
@ -420,10 +419,10 @@ async fn start_ipc(cm: ConnectionManager) {
#[cfg(target_os = "linux")] #[cfg(target_os = "linux")]
#[tokio::main(flavor = "current_thread")] #[tokio::main(flavor = "current_thread")]
async fn start_pa() { async fn start_pa() {
use crate::audio_service::AUDIO_DATA_SIZE_U8;
use hbb_common::config::APP_NAME; use hbb_common::config::APP_NAME;
use libpulse_binding as pulse; use libpulse_binding as pulse;
use libpulse_simple_binding as psimple; use libpulse_simple_binding as psimple;
use crate::audio_service::AUDIO_DATA_SIZE_U8;
match new_listener("_pa").await { match new_listener("_pa").await {
Ok(mut incoming) => { Ok(mut incoming) => {
@ -470,13 +469,14 @@ async fn start_pa() {
) { ) {
Ok(s) => loop { Ok(s) => loop {
if let Ok(_) = s.read(&mut buf) { if let Ok(_) = s.read(&mut buf) {
let out = if buf.iter().filter(|x| **x != 0).next().is_none(){ let out =
if buf.iter().filter(|x| **x != 0).next().is_none() {
vec![] vec![]
}else{ } else {
buf.clone() buf.clone()
}; };
if let Err(err) = stream.send_raw(out).await{ if let Err(err) = stream.send_raw(out).await {
log::error!("Failed to send audio data:{}",err); log::error!("Failed to send audio data:{}", err);
break; break;
} }
} }
@ -503,22 +503,9 @@ async fn start_pa() {
#[tokio::main(flavor = "current_thread")] #[tokio::main(flavor = "current_thread")]
async fn start_clipboard_file( async fn start_clipboard_file(
cm: ConnectionManager, cm: ConnectionManager,
mut rx: mpsc::UnboundedReceiver<(i32, ipc::ClipbaordFile)>, mut rx: mpsc::UnboundedReceiver<ClipboardFileData>,
mut rx_clip_empty: mpsc::UnboundedReceiver<i32>,
) { ) {
let mut cliprdr_context = match create_cliprdr_context(true, false) { let mut cliprdr_context = None;
Ok(context) => {
log::info!("clipboard context for file transfer created.");
context
}
Err(err) => {
log::error!(
"Create clipboard context for file transfer: {}",
err.to_string()
);
return;
}
};
let mut rx_clip_client = get_rx_clip_client().lock().await; let mut rx_clip_client = get_rx_clip_client().lock().await;
loop { loop {
@ -536,21 +523,36 @@ async fn start_clipboard_file(
} }
}, },
server_msg = rx.recv() => match server_msg { server_msg = rx.recv() => match server_msg {
Some((server_conn_id, clip)) => { Some(ClipboardFileData::Clip((server_conn_id, clip))) => {
let conn_id = ConnID { let conn_id = ConnID {
server_conn_id: server_conn_id as u32, server_conn_id: server_conn_id as u32,
remote_conn_id: 0, remote_conn_id: 0,
}; };
server_clip_file(&mut cliprdr_context, conn_id, clip); if let Some(ctx) = cliprdr_context.as_mut() {
server_clip_file(ctx, conn_id, clip);
} }
None => {
break
} }
}, Some(ClipboardFileData::Enable((id, enabled))) => {
server_conn_id = rx_clip_empty.recv() => match server_conn_id { if enabled && cliprdr_context.is_none() {
Some(server_conn_id) => { cliprdr_context = Some(match create_cliprdr_context(true, false) {
if !empty_clipboard(&mut cliprdr_context, server_conn_id, 0) { Ok(context) => {
// log::error!("failed to empty clipboard"); log::info!("clipboard context for file transfer created.");
context
}
Err(err) => {
log::error!(
"Create clipboard context for file transfer: {}",
err.to_string()
);
return;
}
});
}
set_conn_enabled(id, 0, enabled);
if !enabled {
if let Some(ctx) = cliprdr_context.as_mut() {
empty_clipboard(ctx, id, 0);
}
} }
} }
None => { None => {