mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 16:50:41 +01:00
fix(viewer): reuse the SDL window for clipboard to stop GNOME Dock churn (#41)
* Fix viewer Dock churn by reusing SDL clipboard window * Handle clipboard text boundaries and read only after changes * Keep SDL clipboard scoped to the focused desktop and validate CI call sites
This commit is contained in:
1 parent
c38b41b543
commit
8967dfdd4b
9 files changed
+224
-36
No files matched your search
+96
-11
@@ -12,7 +12,19 @@ const POLL:Duration=Duration::from_millis(500);
|
||||
static WARNED:AtomicBool=AtomicBool::new(false);
|
||||
fn warn(){if !WARNED.swap(true,Ordering::Relaxed){log::warn!("Viewer text clipboard unavailable; synchronization disabled");}}
|
||||
#[derive(Clone)]
|
||||
struct Backend {read:PathBuf,read_args:Vec<&'static str>,write:PathBuf,write_args:Vec<&'static str>}
|
||||
struct CommandBackend {read:PathBuf,read_args:Vec<&'static str>,write:PathBuf,write_args:Vec<&'static str>}
|
||||
#[derive(Clone)]
|
||||
enum Backend {
|
||||
Command(CommandBackend),
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
Sdl(mpsc::Sender<ClipboardRequest>),
|
||||
}
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
pub enum ClipboardRequest {
|
||||
Read(tokio::sync::oneshot::Sender<Result<Option<String>,()>>),
|
||||
// false means the unfocused window skipped the write.
|
||||
Write(String,tokio::sync::oneshot::Sender<Result<bool,()>>),
|
||||
}
|
||||
fn executable(name:&str)->Option<PathBuf>{
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
std::env::var_os("PATH").and_then(|p|std::env::split_paths(&p).map(|d|d.join(name))
|
||||
@@ -23,9 +35,38 @@ impl Backend {
|
||||
if std::env::var("UU_VIEWER_CLIPBOARD").as_deref()==Ok("0"){return None}
|
||||
// Unit sessions must never inspect or change the developer's real clipboard.
|
||||
if !cfg!(target_os="linux") || cfg!(test){return None}
|
||||
let selected=Self::select(std::env::var_os("WAYLAND_DISPLAY").is_some_and(|v|!v.is_empty()),executable);
|
||||
let selected=CommandBackend::select(std::env::var_os("WAYLAND_DISPLAY").is_some_and(|v|!v.is_empty()),executable).map(Self::Command);
|
||||
if selected.is_none(){warn();}selected
|
||||
}
|
||||
async fn read(&self)->Result<Option<String>,()>{
|
||||
match self {
|
||||
Self::Command(backend)=>backend.read().await,
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
Self::Sdl(tx)=>{
|
||||
let(reply,rx)=tokio::sync::oneshot::channel();
|
||||
tokio::time::timeout(Duration::from_secs(2),async {
|
||||
tx.send(ClipboardRequest::Read(reply)).await.map_err(|_|())?;
|
||||
rx.await.map_err(|_|())?
|
||||
}).await.map_err(|_|())?
|
||||
}
|
||||
}
|
||||
}
|
||||
async fn write(&self,value:&str)->Result<bool,()>{
|
||||
if value.len()>MAX_TEXT || value.contains('\0'){return Err(())}
|
||||
match self {
|
||||
Self::Command(backend)=>backend.write(value).await.map(|()|true),
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
Self::Sdl(tx)=>{
|
||||
let(reply,rx)=tokio::sync::oneshot::channel();
|
||||
tokio::time::timeout(Duration::from_secs(2),async {
|
||||
tx.send(ClipboardRequest::Write(value.into(),reply)).await.map_err(|_|())?;
|
||||
rx.await.map_err(|_|())?
|
||||
}).await.map_err(|_|())?
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
impl CommandBackend {
|
||||
fn select(wayland:bool,find:impl Fn(&str)->Option<PathBuf>)->Option<Self>{
|
||||
let selected=if wayland{
|
||||
find("wl-paste").zip(find("wl-copy")).map(|(read,write)|Self{read,write,read_args:vec!["--no-newline","--type","text"],write_args:vec!["--type","text/plain;charset=utf-8"]})
|
||||
@@ -45,7 +86,6 @@ impl Backend {
|
||||
tokio::time::timeout(Duration::from_secs(2),operation).await.map_err(|_|())?
|
||||
}
|
||||
async fn write(&self,value:&str)->Result<(),()>{
|
||||
if value.len()>MAX_TEXT{return Err(())}
|
||||
let mut child=tokio::process::Command::new(&self.write).args(&self.write_args).stdin(Stdio::piped()).stdout(Stdio::null()).stderr(Stdio::null()).kill_on_drop(true).spawn().map_err(|_|())?;
|
||||
let operation=async{
|
||||
let mut stdin=child.stdin.take().ok_or(())?;stdin.write_all(value.as_bytes()).await.map_err(|_|())?;drop(stdin);
|
||||
@@ -58,9 +98,11 @@ impl Backend {
|
||||
struct SyncState {last:Option<String>,assembly:text::Assembly,rich:rich::State,seq:u64}
|
||||
impl SyncState {
|
||||
async fn apply(&mut self,backend:&Backend,value:String)->Result<(),()>{
|
||||
backend.write(&value).await?;
|
||||
log::info!("Viewer remote clipboard applied: bytes={}",value.len());
|
||||
self.last=Some(value);Ok(())
|
||||
if backend.write(&value).await? {
|
||||
log::info!("Viewer remote clipboard applied: bytes={}",value.len());
|
||||
self.last=Some(value);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn next(&mut self)->u64{self.seq=self.seq.wrapping_add(1).max(100);self.seq}
|
||||
/// Two requests per change: the rich format-list offer (this project's host asks for the data) and
|
||||
@@ -102,19 +144,24 @@ impl SyncState {
|
||||
_=>{},
|
||||
}
|
||||
}
|
||||
if value.as_ref().is_some_and(|text|text.contains('\0')){return Err("clipboard text contains NUL")}
|
||||
Ok((replies,value))
|
||||
}
|
||||
}
|
||||
async fn send(channel:&RTCDataChannel,message:Vec<u8>)->Result<(),()>{
|
||||
tokio::time::timeout(Duration::from_secs(2),channel.send(&bytes::Bytes::from(message))).await.map_err(|_|())?.map_err(|_|())?;Ok(())
|
||||
}
|
||||
pub fn available()->bool{Backend::detect().is_some()}
|
||||
pub struct Bridge {backend:Option<Backend>,pub enabled:bool,tx:Option<mpsc::Sender<Vec<u8>>>,task:Option<tokio::task::JoinHandle<()>>}
|
||||
impl Bridge {
|
||||
pub fn new(desktop:bool)->Self{
|
||||
let backend=if desktop{Backend::detect()}else{None};let enabled=backend.is_some();
|
||||
Self{backend,enabled,tx:None,task:None}
|
||||
}
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
pub fn sdl(tx:mpsc::Sender<ClipboardRequest>)->Self{
|
||||
let backend=(std::env::var("UU_VIEWER_CLIPBOARD").as_deref()!=Ok("0")).then_some(Backend::Sdl(tx));
|
||||
Self{enabled:backend.is_some(),backend,tx:None,task:None}
|
||||
}
|
||||
pub fn start(&mut self,channel:&Arc<RTCDataChannel>,control:&Arc<RTCDataChannel>,observed:Arc<Observed>){
|
||||
let Some(backend)=self.backend.take() else{return};
|
||||
let (tx,mut rx)=mpsc::channel::<Vec<u8>>(16);self.tx=Some(tx);
|
||||
@@ -173,8 +220,22 @@ impl Drop for Bridge{fn drop(&mut self){self.stop();}}
|
||||
|
||||
#[cfg(test)] mod tests {
|
||||
use super::*;
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
#[tokio::test] async fn sdl_backend_requests_and_invalid_text(){
|
||||
let(tx,mut rx)=mpsc::channel(8);let backend=Backend::Sdl(tx);
|
||||
let ui=tokio::spawn(async move{
|
||||
let Some(ClipboardRequest::Write(text,reply))=rx.recv().await else{panic!()};
|
||||
assert_eq!(text,"text\n");reply.send(Ok(true)).unwrap();
|
||||
let Some(ClipboardRequest::Read(reply))=rx.recv().await else{panic!()};
|
||||
reply.send(Ok(Some("text\n".into()))).unwrap();
|
||||
});
|
||||
assert!(backend.write("nul\0text").await.is_err());
|
||||
assert!(backend.write(&"a".repeat(MAX_TEXT+1)).await.is_err());
|
||||
backend.write("text\n").await.unwrap();assert_eq!(backend.read().await.unwrap().as_deref(),Some("text\n"));
|
||||
ui.await.unwrap();assert!(backend.read().await.is_err());
|
||||
}
|
||||
#[test] fn backend_priority_requires_a_complete_wayland_pair_and_falls_back(){
|
||||
let select=|wayland,names:&[&str]|Backend::select(wayland,|n|names.contains(&n).then(||PathBuf::from(n)));
|
||||
let select=|wayland,names:&[&str]|CommandBackend::select(wayland,|n|names.contains(&n).then(||PathBuf::from(n)));
|
||||
let all=["wl-copy","wl-paste","xclip","xsel"];
|
||||
assert_eq!(select(true,&all).unwrap().write,PathBuf::from("wl-copy"));
|
||||
assert_eq!(select(false,&all).unwrap().write,PathBuf::from("xclip"));
|
||||
@@ -182,6 +243,17 @@ impl Drop for Bridge{fn drop(&mut self){self.stop();}}
|
||||
assert_eq!(select(true,&["xsel"]).unwrap().write,PathBuf::from("xsel"));
|
||||
assert!(select(true,&[]).is_none());
|
||||
}
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
#[tokio::test] async fn unfocused_write_does_not_mark_remote_text_as_applied(){
|
||||
let(tx,mut rx)=mpsc::channel(8);let backend=Backend::Sdl(tx);
|
||||
let ui=tokio::spawn(async move{
|
||||
let Some(ClipboardRequest::Write(_,reply))=rx.recv().await else{panic!()};
|
||||
reply.send(Ok(false)).unwrap();
|
||||
});
|
||||
let mut state=SyncState::default();state.last=Some("local".into());
|
||||
state.apply(&backend,"remote".into()).await.unwrap();
|
||||
assert_eq!(state.last.as_deref(),Some("local"));ui.await.unwrap();
|
||||
}
|
||||
#[test] fn limits_match_host_and_unchanged_or_remote_text_is_not_reoffered(){
|
||||
assert!(include_str!("../clipboard.rs").contains("pub const MAX_TEXT: usize = 30 * 1024;"));
|
||||
assert!(POLL>=Duration::from_millis(500));
|
||||
@@ -212,6 +284,15 @@ impl Drop for Bridge{fn drop(&mut self){self.stop();}}
|
||||
assert!(state.receive(&wire::envelope(1,17,&[18,1,255])).is_err());
|
||||
assert!(state.receive(&wire::envelope(1,17,&text::encode(1,&"a".repeat(MAX_TEXT+1),false))).is_err());
|
||||
}
|
||||
#[test] fn rejected_nul_does_not_stop_later_valid_updates(){
|
||||
let mut state=SyncState::default();
|
||||
for kind in [17,21]{
|
||||
let payload=if kind==17{text::encode(1,"nul\0text",false)}else{text::text_request(73,"nul\0text")};
|
||||
assert!(state.receive(&wire::envelope(1,kind,&payload)).is_err());
|
||||
let(_,value)=state.receive(&wire::envelope(2,17,&text::encode(2,"valid",false))).unwrap();
|
||||
assert_eq!(value.as_deref(),Some("valid"));
|
||||
}
|
||||
}
|
||||
// Match webrtc.rs: CONTROL and TEXT have separate rich States, and only TEXT has a desktop sink.
|
||||
fn native_host_exchange(outbound:usize,reverse:bool)->(Option<String>,bool){
|
||||
let mut viewer=SyncState::default();let mut host=[rich::State::default(),rich::State::default()];let mut id=1000;
|
||||
@@ -269,9 +350,12 @@ impl Drop for Bridge{fn drop(&mut self){self.stop();}}
|
||||
assert!(!Bridge::new(false).enabled);assert!(!Bridge::new(true).enabled);
|
||||
let mut shape:wire::Shape=serde_json::from_str(include_str!("../../tests/fixtures/viewer/shape.json")).unwrap();
|
||||
shape.feature_flag=vec![[8,99]];
|
||||
let options=shape.connect_options("synthetic-device").unwrap();
|
||||
let options=shape.connect_options("synthetic-device",false).unwrap();
|
||||
let WireValue::Bytes(flags)=decode_wire(&options).unwrap().into_iter().find(|f|f.number==11).unwrap().value else{panic!()};
|
||||
assert!(!decode_wire(flags).unwrap().iter().any(|f|f.number==8));
|
||||
let options=shape.connect_options("synthetic-device",true).unwrap();
|
||||
let WireValue::Bytes(flags)=decode_wire(&options).unwrap().into_iter().find(|f|f.number==11).unwrap().value else{panic!()};
|
||||
assert!(decode_wire(flags).unwrap().iter().any(|f|f.number==8 && f.value==WireValue::Varint(3)));
|
||||
}
|
||||
#[tokio::test] async fn backend_uses_stdin_preserves_text_and_bounds_reads(){
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
@@ -279,14 +363,15 @@ impl Drop for Bridge{fn drop(&mut self){self.stop();}}
|
||||
let script=root.join("mock");
|
||||
std::fs::write(&script,b"#!/bin/sh\ncd -- \"${0%/*}\" || exit 1\ncase \"$1\" in read) cat data;; write) cat > data;; esac\n").unwrap();
|
||||
std::fs::set_permissions(&script,std::fs::Permissions::from_mode(0o700)).unwrap();
|
||||
let backend=Backend{read:script.clone(),write:script,read_args:vec!["read"],write_args:vec!["write"]};
|
||||
let command=CommandBackend{read:script.clone(),write:script,read_args:vec!["read"],write_args:vec!["write"]};
|
||||
let backend=Backend::Command(command.clone());
|
||||
let mut state=SyncState::default();
|
||||
for value in ["中文🙂\n", "", "literal $(echo secret) `echo secret`"]{
|
||||
state.apply(&backend,value.into()).await.unwrap();
|
||||
let read=backend.read().await.unwrap().unwrap();assert_eq!(read,value);
|
||||
assert!(state.local(read).unwrap().is_none());
|
||||
}
|
||||
let broken=Backend{write:root.join("missing"),..backend.clone()};
|
||||
let broken=Backend::Command(CommandBackend{write:root.join("missing"),..command});
|
||||
let previous=state.last.clone();assert!(state.apply(&broken,"failed".into()).await.is_err());assert_eq!(state.last,previous);
|
||||
std::fs::write(root.join("data"),vec![b'a';MAX_TEXT+1]).unwrap();assert!(backend.read().await.unwrap().is_none());
|
||||
std::fs::write(root.join("data"),[255]).unwrap();assert!(backend.read().await.unwrap().is_none());
|
||||
|
||||
+1
-2
@@ -63,7 +63,7 @@ fn media_engine(shape:&Shape)->Result<MediaEngine,String>{
|
||||
}Ok(engine)
|
||||
}
|
||||
impl Peer {
|
||||
pub async fn new(config:RTCConfiguration, shape:&Shape, app_id:&str, ice_id:&str, remote_client:&str, outbound:mpsc::Sender<Value>, settings:SettingEngine)->Result<Self,String> {
|
||||
pub async fn new(config:RTCConfiguration, shape:&Shape, app_id:&str, ice_id:&str, remote_client:&str, outbound:mpsc::Sender<Value>, settings:SettingEngine, mut clipboard:super::clipboard::Bridge)->Result<Self,String> {
|
||||
shape.validate_session()?;
|
||||
let mut engine=media_engine(shape)?;
|
||||
// UU RTP metadata the official Mac viewer offers (src/rtp_metadata.rs on the host side).
|
||||
@@ -155,7 +155,6 @@ impl Peer {
|
||||
}
|
||||
}
|
||||
let mut channels=Vec::new();
|
||||
let mut clipboard=super::clipboard::Bridge::new(shape.capture_type==1);
|
||||
let clipboard_enabled=clipboard.enabled;
|
||||
// Diagnostic: hosts may open their own channels; log the label and message count only.
|
||||
pc.on_data_channel(Box::new(|channel|Box::pin(async move {
|
||||
|
||||
+92
-3
@@ -1,18 +1,60 @@
|
||||
use super::{desktop::{Frame,FrameSink},input::{Input,Viewport},session::Session};
|
||||
use sdl2::{event::{Event,WindowEvent},mouse::MouseButton,pixels::PixelFormatEnum,rect::Rect};
|
||||
pub struct Window { canvas:sdl2::render::Canvas<sdl2::video::Window>, events:sdl2::EventPump, _sdl:sdl2::Sdl, frame:(u32,u32), focused:bool, files:bool, mac:bool }
|
||||
pub struct Window { canvas:sdl2::render::Canvas<sdl2::video::Window>, events:sdl2::EventPump, _sdl:sdl2::Sdl, frame:(u32,u32), focused:bool, files:bool, mac:bool,
|
||||
clipboard:sdl2::clipboard::ClipboardUtil, clipboard_dirty:bool, clipboard_tx:tokio::sync::mpsc::Sender<super::clipboard::ClipboardRequest>, clipboard_requests:tokio::sync::mpsc::Receiver<super::clipboard::ClipboardRequest> }
|
||||
impl Window {
|
||||
pub fn new()->Result<Self,String>{
|
||||
let sdl=sdl2::init()?;let video=sdl.video()?;
|
||||
let window=video.window("Native viewer (experimental)",1280,720).position_centered().resizable().build().map_err(|_|"Window creation failed")?;
|
||||
let canvas=window.into_canvas().build().map_err(|_|"Renderer creation failed")?;
|
||||
let events=sdl.event_pump()?;Ok(Self{canvas,events,_sdl:sdl,frame:(1920,1080),focused:true,files:false,mac:false})
|
||||
let events=sdl.event_pump()?;let clipboard=video.clipboard();
|
||||
let(clipboard_tx,clipboard_requests)=tokio::sync::mpsc::channel(16);
|
||||
Ok(Self{canvas,events,_sdl:sdl,frame:(1920,1080),focused:true,files:false,mac:false,clipboard,clipboard_dirty:true,clipboard_tx,clipboard_requests})
|
||||
}
|
||||
pub fn clipboard_bridge(&self)->super::clipboard::Bridge{super::clipboard::Bridge::sdl(self.clipboard_tx.clone())}
|
||||
pub fn set_mac(&mut self,mac:bool){self.mac=mac;}
|
||||
fn viewport(&self)->Viewport {Viewport::fit(self.canvas.window().size(),self.frame)}
|
||||
fn poll_clipboard(&mut self){
|
||||
// Use the existing SDL window; wl-paste creates a transient toplevel on GNOME every poll.
|
||||
while let Ok(request)=self.clipboard_requests.try_recv(){
|
||||
use super::clipboard::ClipboardRequest;
|
||||
match request {
|
||||
ClipboardRequest::Read(reply)=>{
|
||||
let result=if self.focused && std::mem::take(&mut self.clipboard_dirty) && self.clipboard.has_clipboard_text(){read_clipboard()}else{Ok(None)};
|
||||
let _=reply.send(result);
|
||||
},
|
||||
ClipboardRequest::Write(text,reply)=>{
|
||||
let result=if self.focused {
|
||||
self.clipboard_dirty=true;
|
||||
self.clipboard.set_clipboard_text(&text).map(|()|true).map_err(|_|())
|
||||
}else{Ok(false)};
|
||||
let _=reply.send(result);
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
pub fn poll(&mut self,input:&mut Input)->(bool,Vec<serde_json::Value>){
|
||||
let viewport=self.viewport();
|
||||
translate_actions(self.events.poll_iter(),input,viewport,&mut self.focused,&mut self.files)
|
||||
let dirty=&mut self.clipboard_dirty;
|
||||
let events=self.events.poll_iter().inspect(|event|{
|
||||
if matches!(event,Event::ClipboardUpdate{..}|Event::Window{win_event:WindowEvent::FocusGained,..}){*dirty=true;}
|
||||
});
|
||||
translate_actions(events,input,viewport,&mut self.focused,&mut self.files)
|
||||
}
|
||||
}
|
||||
fn clipboard_text(bytes:&[u8])->Option<String>{
|
||||
if bytes.len()>super::clipboard::MAX_TEXT{return None}
|
||||
std::str::from_utf8(bytes).ok().map(str::to_owned)
|
||||
}
|
||||
fn read_clipboard()->Result<Option<String>,()>{
|
||||
// SDL2 0.37's String wrapper panics on invalid UTF-8; validate native bytes before copying.
|
||||
// SDL still acquires the selection synchronously; the bridge timeout cannot interrupt it.
|
||||
unsafe{
|
||||
let data=sdl2::sys::SDL_GetClipboardText();
|
||||
if data.is_null(){return Err(())}
|
||||
let length=libc::strnlen(data,super::clipboard::MAX_TEXT+1);
|
||||
let text=clipboard_text(std::slice::from_raw_parts(data.cast::<u8>(),length));
|
||||
sdl2::sys::SDL_free(data.cast());Ok(text)
|
||||
}
|
||||
}
|
||||
fn translate(events:impl IntoIterator<Item=Event>,input:&mut Input,viewport:Viewport,focused:&mut bool)->(bool,Vec<serde_json::Value>){
|
||||
@@ -87,6 +129,7 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
|
||||
_=tick.tick()=>{
|
||||
if let Some(playback)=audio.as_mut(){if playback.pump().is_err(){log::warn!("Viewer audio playback stopped");audio=None;}}
|
||||
let (quit,messages)=window.poll(&mut input);
|
||||
window.poll_clipboard();
|
||||
requested|=std::mem::take(&mut window.files);
|
||||
#[cfg(uu_gtk)] {
|
||||
if files.as_ref().is_some_and(|f|f.is_finished()){
|
||||
@@ -119,6 +162,52 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
|
||||
|
||||
#[cfg(test)] mod tests {
|
||||
use super::*;
|
||||
#[tokio::test] async fn clipboard_requests_use_existing_window(){
|
||||
if std::env::var_os("UU_VIEWER_CLIPBOARD_TEST_CHILD").is_none(){
|
||||
let output=std::process::Command::new(std::env::current_exe().unwrap())
|
||||
.args(["--exact","viewer::sdl::tests::clipboard_requests_use_existing_window","--test-threads=1"])
|
||||
.env("SDL_VIDEODRIVER","dummy").env("UU_VIEWER_CLIPBOARD_TEST_CHILD","1").output().unwrap();
|
||||
assert!(output.status.success(),"{}{}",String::from_utf8_lossy(&output.stdout),String::from_utf8_lossy(&output.stderr));return
|
||||
}
|
||||
let mut window=Window::new().unwrap();
|
||||
let tx=window.clipboard_tx.clone();
|
||||
use super::super::clipboard::ClipboardRequest;
|
||||
for text in ["clipboard text\n",""]{
|
||||
let(reply,rx)=tokio::sync::oneshot::channel();
|
||||
tx.send(ClipboardRequest::Write(text.into(),reply)).await.unwrap();
|
||||
window.poll_clipboard();assert_eq!(rx.await.unwrap(),Ok(true));
|
||||
let(reply,rx)=tokio::sync::oneshot::channel();
|
||||
tx.send(ClipboardRequest::Read(reply)).await.unwrap();
|
||||
window.poll_clipboard();assert_eq!(rx.await.unwrap(),Ok((!text.is_empty()).then(||text.to_owned())));
|
||||
let(reply,rx)=tokio::sync::oneshot::channel();
|
||||
tx.send(ClipboardRequest::Read(reply)).await.unwrap();
|
||||
window.poll_clipboard();assert_eq!(rx.await.unwrap(),Ok(None));
|
||||
}
|
||||
window.focused=false;window.clipboard_dirty=true;
|
||||
let(reply,rx)=tokio::sync::oneshot::channel();
|
||||
tx.send(ClipboardRequest::Read(reply)).await.unwrap();
|
||||
window.poll_clipboard();assert_eq!(rx.await.unwrap(),Ok(None));assert!(window.clipboard_dirty);
|
||||
let(reply,rx)=tokio::sync::oneshot::channel();
|
||||
tx.send(ClipboardRequest::Write("background".into(),reply)).await.unwrap();
|
||||
window.poll_clipboard();assert_eq!(rx.await.unwrap(),Ok(false));
|
||||
window.focused=true;
|
||||
let(reply,rx)=tokio::sync::oneshot::channel();
|
||||
tx.send(ClipboardRequest::Read(reply)).await.unwrap();
|
||||
window.poll_clipboard();assert_eq!(rx.await.unwrap(),Ok(None));
|
||||
window.clipboard_dirty=false;
|
||||
window._sdl.event().unwrap().push_event(Event::Window{timestamp:0,window_id:window.canvas.window().id(),win_event:WindowEvent::FocusGained}).unwrap();
|
||||
window.poll(&mut Input::new(true));assert!(window.clipboard_dirty);
|
||||
let bridge=window.clipboard_bridge();assert!(bridge.enabled);
|
||||
drop(window);
|
||||
assert!(tx.is_closed());drop(bridge);
|
||||
let window=Window::new().unwrap();assert!(window.clipboard_bridge().enabled);
|
||||
}
|
||||
#[test] fn clipboard_text_rejects_invalid_or_large_data_and_keeps_empty_text(){
|
||||
assert_eq!(clipboard_text(b""),Some(String::new()));
|
||||
assert_eq!(clipboard_text(b"text\n"),Some("text\n".into()));
|
||||
assert_eq!(clipboard_text(&[255]),None);
|
||||
assert_eq!(clipboard_text(&vec![b'a';super::super::clipboard::MAX_TEXT+1]),None);
|
||||
}
|
||||
#[test] fn file_shortcut_is_local_in_control_and_watch_modes(){
|
||||
use sdl2::keyboard::{Scancode as S,Mod as M};
|
||||
for watch in [false,true]{
|
||||
|
||||
@@ -4,7 +4,7 @@ use std::{sync::atomic::Ordering,time::Duration};
|
||||
use tokio::sync::mpsc;
|
||||
use webrtc::api::setting_engine::SettingEngine;
|
||||
|
||||
pub struct Options {pub timeout:Duration,pub legacy_prefix:bool,pub ready_policy:ReadyPolicy}
|
||||
pub struct Options {pub timeout:Duration,pub legacy_prefix:bool,pub ready_policy:ReadyPolicy,pub clipboard:super::clipboard::Bridge}
|
||||
pub struct Session {pub peer:Peer,signal:Signal,candidates:mpsc::Receiver<Value>,policy:ReadyPolicy}
|
||||
impl Session {
|
||||
pub async fn open(room:&JoinData,shape:&Shape,device:&str,client:&str,options:Options,settings:SettingEngine)->Result<Self,String> {
|
||||
@@ -15,7 +15,7 @@ impl Session {
|
||||
let timeout=if room.ws_connect_timeout_ms>0 {Duration::from_millis(room.ws_connect_timeout_ms as u64)}else{options.timeout};
|
||||
let mut signal=Signal::connect(&room.signaling_list,&room.token,timeout,options.legacy_prefix).await?;
|
||||
let result=async {
|
||||
let result=signal.control(shape.control(client,&app,&ice)?,shape.connect_options(device)?,options.timeout).await?;
|
||||
let result=signal.control(shape.control(client,&app,&ice)?,shape.connect_options(device,options.clipboard.enabled)?,options.timeout).await?;
|
||||
// Key names per ICE entry and URL scheme only (no values) to see where TURN credentials live.
|
||||
if let Some(list)=result.get("iceServers").and_then(Value::as_array) {
|
||||
let summary:Vec<String>=list.iter().map(|s|{
|
||||
@@ -33,7 +33,7 @@ impl Session {
|
||||
let remote=result.get("client_id").and_then(Value::as_str).filter(|s|!s.is_empty()).ok_or("Control acknowledgement missing peer route")?;
|
||||
let config=rtc::configuration(&result)?;
|
||||
let(tx,rx)=mpsc::channel(256);
|
||||
let peer=Peer::new(config,&shape,&app,&ice,remote,tx,settings).await?;
|
||||
let peer=Peer::new(config,&shape,&app,&ice,remote,tx,settings,options.clipboard).await?;
|
||||
// The official host drops an offer whose ice_id is not yet in its connection table
|
||||
// (libstreamer 0xc3080); give it time to process be-controlled first.
|
||||
let delay=std::env::var("UU_VIEWER_OFFER_DELAY_MS").ok().and_then(|v|v.parse().ok()).unwrap_or(0u64).min(10_000);
|
||||
|
||||
+7
-7
@@ -148,7 +148,7 @@ async fn complete_session_uses_loopback_signaling_and_virtual_rtc_through_echo()
|
||||
}
|
||||
});
|
||||
let room:JoinData=serde_json::from_value(json!({"token":"synthetic-room-ticket","signaling_list":[url],"report_token":"synthetic-report","report_url":""})).unwrap();
|
||||
let options=Options{timeout:Duration::from_secs(3),legacy_prefix:false,ready_policy:ReadyPolicy::Explicit};
|
||||
let options=Options{timeout:Duration::from_secs(3),legacy_prefix:false,ready_policy:ReadyPolicy::Explicit,clipboard:super::clipboard::Bridge::new(false)};
|
||||
let mut session=Session::open(&room,&shape(),"synthetic-device","synthetic-client",options,viewer_settings).await.unwrap();
|
||||
assert_eq!(session.peer.channels.len(),5);
|
||||
let(tool_io,mut tool_rx)=super::tools::attach(&session.peer).unwrap();
|
||||
@@ -188,7 +188,7 @@ async fn complete_session_uses_loopback_signaling_and_virtual_rtc_through_echo()
|
||||
#[tokio::test]
|
||||
async fn early_candidates_and_foreign_session_messages_are_scoped() {
|
||||
let(settings,_,router)=virtual_network().await;let(tx,_rx)=mpsc::channel(256);
|
||||
let mut peer=Peer::new(RTCConfiguration::default(),&shape(),"synthetic-app","synthetic-ice","synthetic-host",tx,settings).await.unwrap();
|
||||
let mut peer=Peer::new(RTCConfiguration::default(),&shape(),"synthetic-app","synthetic-ice","synthetic-host",tx,settings,super::clipboard::Bridge::new(false)).await.unwrap();
|
||||
assert!(!peer.matches_route(&json!({"ice_id":"foreign"})));
|
||||
assert!(!peer.matches_route(&json!({"app_control_id":"foreign"})));
|
||||
peer.receive(&json!({"type":"answer","ice_id":"foreign","sdp":"invalid"})).await.unwrap();
|
||||
@@ -201,8 +201,8 @@ async fn early_candidates_and_foreign_session_messages_are_scoped() {
|
||||
async fn closing_one_peer_preserves_another_peer() {
|
||||
let(a,b,router)=virtual_network().await;
|
||||
let(tx1,_rx1)=mpsc::channel(256);let(tx2,_rx2)=mpsc::channel(256);
|
||||
let first=Peer::new(RTCConfiguration::default(),&shape(),"synthetic-first","synthetic-first-ice","synthetic-host",tx1,a).await.unwrap();
|
||||
let second=Peer::new(RTCConfiguration::default(),&shape(),"synthetic-second","synthetic-second-ice","synthetic-host",tx2,b).await.unwrap();
|
||||
let first=Peer::new(RTCConfiguration::default(),&shape(),"synthetic-first","synthetic-first-ice","synthetic-host",tx1,a,super::clipboard::Bridge::new(false)).await.unwrap();
|
||||
let second=Peer::new(RTCConfiguration::default(),&shape(),"synthetic-second","synthetic-second-ice","synthetic-host",tx2,b,super::clipboard::Bridge::new(false)).await.unwrap();
|
||||
first.close().await;
|
||||
assert_ne!(second.pc.connection_state(),webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Closed);
|
||||
assert_eq!(second.channels.len(),5);
|
||||
@@ -220,7 +220,7 @@ async fn opus_and_video_tracks_are_received_independently_in_memory() {
|
||||
let video=Arc::new(TrackLocalStaticRTP::new(RTCRtpCodecCapability{mime_type:"video/H264".into(),clock_rate:90000,sdp_fmtp_line:"level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f".into(),..Default::default()},"video".into(),"test".into()));
|
||||
host.add_track(audio.clone() as Arc<dyn TrackLocal+Send+Sync>).await.unwrap();host.add_track(video.clone() as Arc<dyn TrackLocal+Send+Sync>).await.unwrap();
|
||||
let(tx,_rx)=mpsc::channel(256);
|
||||
let peer=Peer::new(RTCConfiguration::default(),&shape().video_preferences(false),"app","ice","host",tx,viewer_settings).await.unwrap();
|
||||
let peer=Peer::new(RTCConfiguration::default(),&shape().video_preferences(false),"app","ice","host",tx,viewer_settings,super::clipboard::Bridge::new(false)).await.unwrap();
|
||||
let mut gathered=peer.pc.gathering_complete_promise().await;peer.offer().await.unwrap();gathered.recv().await;
|
||||
let offer=peer.pc.local_description().await.unwrap();assert!(offer.sdp.contains("m=audio") && offer.sdp.contains("opus/48000/2"));
|
||||
host.set_remote_description(offer).await.unwrap();let answer=host.create_answer(None).await.unwrap();
|
||||
@@ -267,7 +267,7 @@ async fn desktop_file_window_reattaches_without_replacing_peer(){
|
||||
}));}
|
||||
})}));
|
||||
let(tx,_rx)=mpsc::channel(256);
|
||||
let peer=Peer::new(RTCConfiguration::default(),&shape(),"app","ice","host",tx,viewer_settings).await.unwrap();
|
||||
let peer=Peer::new(RTCConfiguration::default(),&shape(),"app","ice","host",tx,viewer_settings,super::clipboard::Bridge::new(false)).await.unwrap();
|
||||
let mut gathered=peer.pc.gathering_complete_promise().await;peer.offer().await.unwrap();gathered.recv().await;
|
||||
host.set_remote_description(peer.pc.local_description().await.unwrap()).await.unwrap();
|
||||
let answer=host.create_answer(None).await.unwrap();let mut gathered=host.gathering_complete_promise().await;
|
||||
@@ -316,7 +316,7 @@ async fn hevc_track_uses_negotiated_payload_type_in_memory(){
|
||||
}
|
||||
})));
|
||||
let(tx,_rx)=mpsc::channel(256);
|
||||
let peer=Peer::new(RTCConfiguration::default(),&shape().video_preferences(false),"app","ice","host",tx,viewer_settings).await.unwrap();
|
||||
let peer=Peer::new(RTCConfiguration::default(),&shape().video_preferences(false),"app","ice","host",tx,viewer_settings,super::clipboard::Bridge::new(false)).await.unwrap();
|
||||
let mut gathered=peer.pc.gathering_complete_promise().await;peer.offer().await.unwrap();gathered.recv().await;
|
||||
host.set_remote_description(peer.pc.local_description().await.unwrap()).await.unwrap();
|
||||
let answer=host.create_answer(None).await.unwrap();
|
||||
|
||||
+5
-5
@@ -75,7 +75,7 @@ impl Shape {
|
||||
if h264_only {shape.decoders.retain(|d|d.codec==1);shape.codecs.retain(|c|c.video_codec==1);}
|
||||
shape
|
||||
}
|
||||
pub fn connect_options(&self, device:&str) -> Result<Vec<u8>,String> {
|
||||
pub fn connect_options(&self, device:&str, clipboard:bool) -> Result<Vec<u8>,String> {
|
||||
self.validate()?;
|
||||
let mut out=Vec::new(); int(1,self.capture_type.into(),&mut out);
|
||||
if [1,8].contains(&self.capture_type) { int(2,u64::MAX,&mut out); }
|
||||
@@ -100,7 +100,7 @@ impl Shape {
|
||||
int(8,self.platform.into(),&mut out); bytes(9,device.as_bytes(),&mut out); int(10,1,&mut out);
|
||||
if self.capture_type==1 {
|
||||
let mut flags=Vec::new(); for [field,version] in &self.feature_flag { if *field!=8 {int((*field).into(),(*version).into(),&mut flags);} }
|
||||
if super::clipboard::available(){int(8,3,&mut flags);}
|
||||
if clipboard{int(8,3,&mut flags);}
|
||||
bytes(11,&flags,&mut out);
|
||||
}
|
||||
if self.capture_type!=5 { bytes(12,self.client_version.as_bytes(),&mut out); }
|
||||
@@ -176,7 +176,7 @@ mod tests {
|
||||
let mut s=shape();
|
||||
for capture in [1,5,8,9] {
|
||||
s.capture_type=capture;
|
||||
let b=s.connect_options("synthetic-device").unwrap(); let f=decode_wire(&b).unwrap();
|
||||
let b=s.connect_options("synthetic-device",false).unwrap(); let f=decode_wire(&b).unwrap();
|
||||
let numbers:Vec<u32>=f.iter().map(|f|f.number).collect();
|
||||
let expected=match capture {1=>vec![1,2,3,4,4,4,4,6,6,7,8,9,10,11,12],5=>vec![1,3,4,4,4,4,6,6,7,8,9,10],8=>vec![1,2,8,9,10,12],_=>vec![1,8,9,10,12]};
|
||||
assert_eq!(numbers,expected);
|
||||
@@ -226,7 +226,7 @@ pub fn media_control(data:&[u8])->(Option<u32>,Option<u32>){
|
||||
let original:Shape=serde_json::from_str(include_str!("../../tests/fixtures/viewer/session-shape.json")).unwrap();
|
||||
for force in [false,true] {
|
||||
let s=original.video_preferences(force);s.validate_session().unwrap();assert_eq!(s.chroma,1);
|
||||
let options=s.connect_options("synthetic-device").unwrap();
|
||||
let options=s.connect_options("synthetic-device",false).unwrap();
|
||||
let mut caps=Vec::new();
|
||||
for f in decode_wire(&options).unwrap(){if let (4,WireValue::Bytes(cap))=(f.number,f.value){
|
||||
assert_eq!(super::super::tools::uint(cap,1),30);
|
||||
@@ -234,7 +234,7 @@ pub fn media_control(data:&[u8])->(Option<u32>,Option<u32>){
|
||||
caps.push((super::super::tools::uint(cap,2),super::super::tools::uint(cap,5)));
|
||||
}}
|
||||
assert_eq!(caps,if force{vec![(1,1),(1,3)]}else{vec![(2,1),(2,3),(1,1),(1,3)]});
|
||||
assert!(s.video_preferences(force).connect_options("synthetic-device").unwrap()==options);
|
||||
assert!(s.video_preferences(force).connect_options("synthetic-device",false).unwrap()==options);
|
||||
}
|
||||
}
|
||||
#[test] fn chroma_request_and_actual_sync_are_independent_of_encoder_list(){
|
||||
|
||||
+7
-3
@@ -100,7 +100,11 @@ async fn desktop_command(args:&[String],code:Option<String>)->Result<(),String>
|
||||
let device=account_connection.then_some(args[1].as_str());
|
||||
window.set_mac(api.target_is_mac(&room,device).await.map_err(|e|e.to_string())?);
|
||||
}
|
||||
let options=Options{timeout:Duration::from_secs(12),legacy_prefix:legacy,ready_policy:policy};
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
let clipboard=desktop.as_ref().map(|(window,_)|window.clipboard_bridge()).unwrap_or_else(||clipboard::Bridge::new(false));
|
||||
#[cfg(not(feature="viewer-sdl"))]
|
||||
let clipboard=clipboard::Bridge::new(shape.capture_type==1);
|
||||
let options=Options{timeout:Duration::from_secs(12),legacy_prefix:legacy,ready_policy:policy,clipboard};
|
||||
let mut session=Session::open(&room,&shape,&creds.device_id,&creds.client_id,options,Default::default()).await?;
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
let result=if let Some((window,decoder))=desktop.as_mut(){viewer::sdl::run(&mut session,window,decoder.as_mut(),view_only).await}else{session.run().await};
|
||||
@@ -147,7 +151,7 @@ async fn tool_command(args:&[String])->Result<(),String>{
|
||||
let creds=credentials()?;let api=Api::new(auth::UUAuthClient::new(creds.clone()),auth::BASE_URL);
|
||||
let room=api.join(&args[1],false,true).await.map_err(|e|e.to_string())?;
|
||||
// Match the existing UI connection framing (9bb42d5); the host tolerates this prefix.
|
||||
let options=Options{timeout:Duration::from_secs(12),legacy_prefix:true,ready_policy:ReadyPolicy::EchoOnly};
|
||||
let options=Options{timeout:Duration::from_secs(12),legacy_prefix:true,ready_policy:ReadyPolicy::EchoOnly,clipboard:clipboard::Bridge::new(false)};
|
||||
let mut session=Session::open(&room,&shape,&creds.device_id,&creds.client_id,options,Default::default()).await?;
|
||||
let result=async{
|
||||
let(io,rx)=viewer::tools::attach(&session.peer)?;
|
||||
@@ -176,7 +180,7 @@ async fn power_command(args:&[String])->Result<(),String>{
|
||||
shape.capture_type=5;shape.feature_flag.clear();
|
||||
let creds=credentials()?;let api=Api::new(auth::UUAuthClient::new(creds.clone()),auth::BASE_URL);
|
||||
let room=api.join(&args[1],false,true).await.map_err(|e|e.to_string())?;
|
||||
let options=Options{timeout:Duration::from_secs(12),legacy_prefix:true,ready_policy:ReadyPolicy::EchoOnly};
|
||||
let options=Options{timeout:Duration::from_secs(12),legacy_prefix:true,ready_policy:ReadyPolicy::EchoOnly,clipboard:clipboard::Bridge::new(false)};
|
||||
let mut session=Session::open(&room,&shape,&creds.device_id,&creds.client_id,options,Default::default()).await?;
|
||||
let result=viewer::power::run(&mut session,action).await;
|
||||
session.close().await;
|
||||
|
||||
Reference in new issue
Block a user