mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 16:50:41 +01:00
控制端:原生分辨率、中英文界面、控制中心、实测 RTT 与稳定性修复 (#129)
* viewer: decode at the host's native size and filter window scaling Every frame was scaled into a fixed 1920x1080 canvas and SDL then stretched it to the window with nearest-neighbour sampling, so remote text looked uneven and blurry. Decode at the native size (read from ffmpeg's verbose scaler line), restart the decoder when the host resolution changes, and use linear render scaling. UU_VIEWER_SIZE keeps the fixed canvas, now resampled with Lanczos. Co-Authored-By: Claude Opus 5.5 <[email protected]> * Add Chinese/English UI language All GTK windows (viewer launcher, tool windows, host main window and QR login) and viewer messages are available in Chinese and English. The language comes from UU_LANG, the choice saved in Settings -> General, then the locale. README: document the fork's changes and language selection. Co-Authored-By: Claude Opus 5.5 <[email protected]> * Host main window: add the language selector Co-Authored-By: Claude Opus 5.5 <[email protected]> * viewer: control center, network status, loading screen, device previews In-window chrome drawn on the SDL canvas with a fontconfig font (ab_glyph): - loading animation with the connection stage instead of a black window - control center (Ctrl+Alt+M or the top tab): quality, fps, true color, resolution, fit/1:1, volume, auto lock and host mute (SimpleAction 19, 14/18/16), system shortcut grab, file transfer, watch mode, full screen, disconnect - network status panel (Ctrl+Alt+G): time, route, fps, bitrate, RTT, loss - launcher device previews from the last remote picture (local 0600 cache) - viewer sign-in keeps the local host user service running, so this computer joins the account's device list; the settings switch controls it Co-Authored-By: Claude Opus 5.5 <[email protected]> * viewer: compact cascading control center Narrow category list with an options card beside the selected row, sized to its content; opaque cards with a hairline border and soft shadow, so the remote picture no longer shows through. Co-Authored-By: Claude Opus 5.5 <[email protected]> * viewer: keep the control center responsive; resync on a key frame The menu was rasterized on every mouse event just to hit-test it; hit testing now uses the layout alone and the drawn menu is cached until what it shows changes. A stalled UI overflowed the access-unit queue, and the reset decoder then smeared P-frames into blocks; after a reset it now waits for an IDR/IRAP while requesting key frames. The tab icon is drawn, since fonts without U+2630 showed a box. Co-Authored-By: Claude Opus 5.5 <[email protected]> * viewer: measured RTT, no crash on closing tool windows, account card webrtc-ice never measured the round trip, so the network panel always read 'RTT --'. Binding responses now record it on their pair, and the selected pair is pinged when the sample is older than the keepalive interval, since a streaming pair never idles (vendor/webrtc-ice/PATCHES.md). On Wayland, libdecor's GTK plugin drew SDL's title bar with GTK3 from SDL's thread while the file window ran gtk_main on its own; closing that window crashed in GTK's style code. GTK builds now offer libdecor only the cairo plugin unless LIBDECOR_PLUGIN_DIR is set. Settings > General gets an Account card with the signed-in user and Sign out. Co-Authored-By: Claude Opus 5.5 <[email protected]> * README: keep the language section, without the fork notes Co-Authored-By: Claude Opus 5.5 <[email protected]> * viewer: English server errors in the English UI; stable type_ipc tests UU servers answer in Chinese only. The English UI now translates the known messages (2002 target already controlled, assistance refusals) and shows the code for unknown ones instead of Chinese text. type_ipc tests shared one temp directory per process and read XDG_RUNTIME_DIR while another test pointed it at a planted directory; each call now gets its own directory and socket tests hold the environment lock. Co-Authored-By: Claude Opus 5.5 <[email protected]> * viewer launcher: switching the language restarts the launcher The choice was saved but took effect only on the next start, so the window seemed to ignore it. The launcher now re-executes itself in place; session windows are separate processes and stay connected. Co-Authored-By: Claude Opus 5.5 <[email protected]> * viewer: show pictures as soon as decoded; coalesce mouse motion The raw-stream parser closed an access unit only when the next began, and frames were collected only when another one arrived, so a single remote change (a typed letter) waited for the next one. An access unit delimiter now follows each unit and the loop drains finished frames between units. Motions within one 8 ms poll collapse to the newest position (click order kept), so a drag no longer queues behind itself on a relayed path. Co-Authored-By: Claude Opus 5.5 <[email protected]> * viewer launcher: hosting is opt-in Signing in to the viewer no longer installs or enables uuremote-native.service. Only the Settings switch enables or disables it, and the unit's enabled state is the saved choice, so turning it off survives a restart. A new sign-in restarts the host only when the user turned it on and it is running. PATCHES.md: the RTT keepalive also runs on the host; checked with the official Android client controlling a Linux host. Co-Authored-By: Claude Opus 5.5 <[email protected]> * viewer: drop SDL event types sdl2 0.37 does not define sdl2 0.37 transmutes every event type into SDL_EventType. sdl2-compat on SDL3 delivers types SDL 2 does not define (0x207), which is undefined behaviour and aborts with debug checks (clipboard_requests_use_existing_window on Fedora 44). Poll raw events and skip those types before the crate converts them. Co-Authored-By: Claude Opus 5.5 <[email protected]> * Keep the package version at 0.2.39 The maintainer sets the version at release time. Co-Authored-By: Claude Opus 5.5 <[email protected]> --------- Co-authored-by: Claude Opus 5.5 <[email protected]>
This commit is contained in:
1 parent
47c7728822
commit
0cbfc5b4f1
37 files changed
+1644
-380
No files matched your search
+57
@@ -0,0 +1,57 @@
|
||||
//! UI language: Chinese (the official clients' wording) or English.
|
||||
//! `UU_LANG=zh|en`, else the choice saved from the settings window (`language` next to config.json),
|
||||
//! else the locale (`LC_ALL` / `LC_MESSAGES` / `LANG` starting with `zh` → Chinese, anything else → English).
|
||||
use std::sync::OnceLock;
|
||||
|
||||
static ENGLISH: OnceLock<bool> = OnceLock::new();
|
||||
|
||||
fn parse(value: &str) -> Option<bool> {
|
||||
let value = value.trim().to_ascii_lowercase();
|
||||
if value.starts_with("zh") { Some(false) } else if value.starts_with("en") { Some(true) } else { None }
|
||||
}
|
||||
|
||||
fn saved_path() -> std::path::PathBuf {
|
||||
crate::config::path().parent().map_or_else(|| "language".into(), |dir| dir.join("language"))
|
||||
}
|
||||
|
||||
fn detect() -> bool {
|
||||
if let Some(english) = std::env::var("UU_LANG").ok().as_deref().and_then(parse) { return english; }
|
||||
if let Some(english) = std::fs::read_to_string(saved_path()).ok().as_deref().and_then(parse) { return english; }
|
||||
let locale = ["LC_ALL", "LC_MESSAGES", "LANG"].iter()
|
||||
.find_map(|name| std::env::var(name).ok().filter(|v| !v.is_empty()));
|
||||
!locale.is_some_and(|v| v.to_ascii_lowercase().starts_with("zh"))
|
||||
}
|
||||
|
||||
pub fn english() -> bool { *ENGLISH.get_or_init(detect) }
|
||||
|
||||
/// Pick the text for the current language.
|
||||
pub fn s(zh: &'static str, en: &'static str) -> &'static str { if english() { en } else { zh } }
|
||||
|
||||
/// Saves the settings-window choice; it applies on the next start.
|
||||
pub fn save(english: bool) -> std::io::Result<()> {
|
||||
let path = saved_path();
|
||||
if let Some(dir) = path.parent() { std::fs::create_dir_all(dir)?; }
|
||||
std::fs::write(path, if english { "en\n" } else { "zh\n" })
|
||||
}
|
||||
|
||||
/// `tr!("连接失败:{e}", "Connection failed: {e}")` formats the string for the current language.
|
||||
#[macro_export]
|
||||
macro_rules! tr {
|
||||
($zh:literal, $en:literal $(, $arg:expr)* $(,)?) => {
|
||||
if $crate::i18n::english() { format!($en $(, $arg)*) } else { format!($zh $(, $arg)*) }
|
||||
};
|
||||
}
|
||||
|
||||
// The GTK windows (c_engine/i18n.h) ask the same question so both halves always agree.
|
||||
#[no_mangle] pub extern "C" fn uu_i18n_english() -> std::os::raw::c_int { english().into() }
|
||||
#[no_mangle] pub extern "C" fn uu_i18n_save(english: std::os::raw::c_int) -> std::os::raw::c_int {
|
||||
save(english != 0).is_ok().into()
|
||||
}
|
||||
|
||||
#[cfg(test)] mod tests {
|
||||
#[test] fn language_values_are_parsed(){
|
||||
assert_eq!(super::parse("zh_CN.UTF-8"),Some(false));
|
||||
assert_eq!(super::parse("EN\n"),Some(true));
|
||||
assert_eq!(super::parse("sr_RS"),None);
|
||||
}
|
||||
}
|
||||
+21
-21
@@ -140,10 +140,10 @@ enum QrPollAction { Wait(i64), Scanned, Confirmed, Refresh(Duration), Failed(&'s
|
||||
/// Preserve the official refresh policy; a failed query says nothing about QR expiry.
|
||||
fn qr_poll_action(last_status: i64, http_status: u16, body: &Value) -> QrPollAction {
|
||||
if body.get("code").and_then(Value::as_i64) == Some(QR_EXPIRED) {
|
||||
return QrPollAction::Failed("二维码已失效");
|
||||
return QrPollAction::Failed(crate::i18n::s("二维码已失效","QR code expired"));
|
||||
}
|
||||
let Ok(data) = qr_data("qrcode status", http_status, body) else {
|
||||
return QrPollAction::Failed("二维码状态查询失败");
|
||||
return QrPollAction::Failed(crate::i18n::s("二维码状态查询失败","QR status check failed"));
|
||||
};
|
||||
match data.get("status").and_then(Value::as_i64) {
|
||||
Some(1) => QrPollAction::Wait(1),
|
||||
@@ -152,7 +152,7 @@ fn qr_poll_action(last_status: i64, http_status: u16, body: &Value) -> QrPollAct
|
||||
Some(0) => QrPollAction::Refresh(Duration::from_millis(350)),
|
||||
Some(3) => QrPollAction::Refresh(Duration::ZERO),
|
||||
Some(4) => QrPollAction::Confirmed,
|
||||
_ => QrPollAction::Failed("二维码状态响应异常"),
|
||||
_ => QrPollAction::Failed(crate::i18n::s("二维码状态响应异常","Unexpected QR status response")),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -247,10 +247,10 @@ pub async fn run(gui: bool) -> Result<(), String> {
|
||||
};
|
||||
match &result {
|
||||
Ok(name) => {
|
||||
ui.done(&format!("登录成功\n{name}"));
|
||||
ui.status("登录信息已保存到本机配置,可以关闭此窗口", Tone::Ok);
|
||||
ui.done(&crate::tr!("登录成功\n{name}","Signed in\n{name}"));
|
||||
ui.status(crate::i18n::s("登录信息已保存到本机配置,可以关闭此窗口","Sign-in saved to the local config; you can close this window"), Tone::Ok);
|
||||
}
|
||||
Err(e) => { eprintln!("login failed: {e}"); ui.status(&format!("登录失败:{e}"), Tone::Error); }
|
||||
Err(e) => { eprintln!("login failed: {e}"); ui.status(&crate::tr!("登录失败:{e}","Sign-in failed: {e}"), Tone::Error); }
|
||||
}
|
||||
if ui.shown() { ui.wait_closed().await; }
|
||||
result.map(|_| ())
|
||||
@@ -328,14 +328,14 @@ pub(crate) async fn flow(ui: &LoginUi) -> Result<String, String> {
|
||||
Ok(r) => r,
|
||||
Err(e) if e.response_received() => {
|
||||
eprintln!("QR generation response failed: {e}");
|
||||
wait_for_refresh(ui, "二维码加载失败").await;
|
||||
wait_for_refresh(ui, crate::i18n::s("二维码加载失败","QR code failed to load")).await;
|
||||
continue;
|
||||
}
|
||||
Err(e) => return Err(format!("QR generation failed: {e}")),
|
||||
};
|
||||
let d = match qr_data("qrcode gen", status, &resp) {
|
||||
Ok(d) => d.clone(),
|
||||
Err(e) => { println!("QR code could not be loaded ({e})"); wait_for_refresh(ui, "二维码加载失败").await; continue; }
|
||||
Err(e) => { println!("QR code could not be loaded ({e})"); wait_for_refresh(ui, crate::i18n::s("二维码加载失败","QR code failed to load")).await; continue; }
|
||||
};
|
||||
let url = d.get("qrcode_jump_url").and_then(|v| v.as_str()).ok_or("qrcode gen returned no qrcode_jump_url")?.to_string();
|
||||
let ticket = qr_ticket(&d).ok_or("qrcode gen returned no status ticket")?.to_string();
|
||||
@@ -344,7 +344,7 @@ pub(crate) async fn flow(ui: &LoginUi) -> Result<String, String> {
|
||||
let modules = qrcode::QrCode::new(url.as_bytes()).map_err(|e| e.to_string())?.width() + 2;
|
||||
let (rgba, edge) = qr_rgba(&url, (224 / modules).max(2), 1)?;
|
||||
ui.qr(&rgba, edge);
|
||||
ui.status("等待扫码…", Tone::Info);
|
||||
ui.status(crate::i18n::s("等待扫码…","Waiting for scan…"), Tone::Info);
|
||||
}
|
||||
if let Some(path)=std::env::var_os("UU_LOGIN_QR_PNG") {
|
||||
use std::io::Write;
|
||||
@@ -362,20 +362,20 @@ pub(crate) async fn flow(ui: &LoginUi) -> Result<String, String> {
|
||||
Err(e) => {
|
||||
eprintln!("QR status query failed: {e}; last_status={login_status}");
|
||||
break match e.kind {
|
||||
QrRequestErrorKind::Timeout => "二维码状态查询超时(不代表二维码已失效)",
|
||||
_ => "二维码状态查询失败(不代表二维码已失效)",
|
||||
QrRequestErrorKind::Timeout => crate::i18n::s("二维码状态查询超时(不代表二维码已失效)","QR status check timed out (the QR code may still be valid)"),
|
||||
_ => crate::i18n::s("二维码状态查询失败(不代表二维码已失效)","QR status check failed (the QR code may still be valid)"),
|
||||
};
|
||||
}
|
||||
};
|
||||
match qr_poll_action(login_status, status, &resp) {
|
||||
QrPollAction::Wait(st) => {
|
||||
if st == 1 && login_status != 1 { ui.status("等待扫码…", Tone::Info); }
|
||||
if st == 1 && login_status != 1 { ui.status(crate::i18n::s("等待扫码…","Waiting for scan…"), Tone::Info); }
|
||||
login_status = st;
|
||||
}
|
||||
QrPollAction::Scanned => {
|
||||
login_status = 2;
|
||||
println!("已扫码,请在手机上确认 (scanned, confirm on the phone)");
|
||||
ui.status("已扫码,请在手机上确认登录", Tone::Ok);
|
||||
ui.status(crate::i18n::s("已扫码,请在手机上确认登录","Scanned, confirm the sign-in on your phone"), Tone::Ok);
|
||||
}
|
||||
QrPollAction::Refresh(delay) => {
|
||||
if delay.is_zero() { println!("QR code expired; generating a new one"); }
|
||||
@@ -384,19 +384,19 @@ pub(crate) async fn flow(ui: &LoginUi) -> Result<String, String> {
|
||||
}
|
||||
QrPollAction::Confirmed => {
|
||||
println!("已确认,正在完成登录 (confirmed, completing login)");
|
||||
ui.status("已确认,正在完成登录…", Tone::Info);
|
||||
ui.status(crate::i18n::s("已确认,正在完成登录…","Confirmed, finishing sign-in…"), Tone::Info);
|
||||
let body = json!({"token": ticket, "qrcode_jump_url": url});
|
||||
let (status, resp) = match client.post_with_timeout("/api/v1/login/by_qrcode", Some(&body), timeout).await {
|
||||
Ok(r) => r,
|
||||
Err(e) if e.response_received() => {
|
||||
eprintln!("QR login exchange response failed: {e}");
|
||||
break "登录失败";
|
||||
break crate::i18n::s("登录失败","Sign-in failed");
|
||||
}
|
||||
Err(e) => return Err(format!("QR login exchange failed: {e}")),
|
||||
};
|
||||
let d = match qr_data("qrcode login", status, &resp) {
|
||||
Ok(d) => d,
|
||||
Err(e) => { println!("QR login not granted ({e})"); break "登录失败"; }
|
||||
Err(e) => { println!("QR login not granted ({e})"); break crate::i18n::s("登录失败","Sign-in failed"); }
|
||||
};
|
||||
let token = d.get("token").and_then(|v| v.as_str()).ok_or("login returned no token")?;
|
||||
let user = d.get("user_id").and_then(|v| v.as_str()).ok_or("login returned no user_id")?;
|
||||
@@ -434,7 +434,7 @@ fn qr_ticket(gen: &Value) -> Option<&str> {
|
||||
/// or (no window and no terminal, e.g. a service) one minute.
|
||||
async fn wait_for_refresh(ui: &LoginUi, reason: &str) {
|
||||
use std::io::IsTerminal;
|
||||
ui.status(&format!("{reason},请点击「刷新二维码」"), Tone::Error);
|
||||
ui.status(&crate::tr!("{reason},请点击「刷新二维码」","{reason}. Click \"Refresh QR code\"."), Tone::Error);
|
||||
ui.offer_refresh(true);
|
||||
let terminal = !ui.quiet() && std::io::stdin().is_terminal();
|
||||
if terminal { println!("{reason}. Press Enter to show a new QR code (按回车刷新二维码)"); }
|
||||
@@ -462,18 +462,18 @@ mod tests {
|
||||
assert_eq!(qr_poll_action(2, 200, &reply(4)), QrPollAction::Confirmed);
|
||||
assert_eq!(qr_poll_action(1, 200, &reply(0)), QrPollAction::Refresh(Duration::from_millis(350)));
|
||||
assert_eq!(qr_poll_action(2, 200, &reply(3)), QrPollAction::Refresh(Duration::ZERO));
|
||||
assert_eq!(qr_poll_action(2, 400, &json!({"code": 1190})), QrPollAction::Failed("二维码已失效"));
|
||||
assert_eq!(qr_poll_action(2, 400, &json!({"code": 1190})), QrPollAction::Failed(crate::i18n::s("二维码已失效","QR code expired")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn qr_poll_failures_do_not_imply_expiry_or_confirmation() {
|
||||
for last in [1, 2] {
|
||||
for body in [json!(null), json!({"code": 1}), json!({"code": 0, "data": {"status": 4}})] {
|
||||
assert_eq!(qr_poll_action(last, 503, &body), QrPollAction::Failed("二维码状态查询失败"));
|
||||
assert_eq!(qr_poll_action(last, 503, &body), QrPollAction::Failed(crate::i18n::s("二维码状态查询失败","QR status check failed")));
|
||||
}
|
||||
assert_eq!(qr_poll_action(last, 200, &json!({"code": 1})), QrPollAction::Failed("二维码状态查询失败"));
|
||||
assert_eq!(qr_poll_action(last, 200, &json!({"code": 1})), QrPollAction::Failed(crate::i18n::s("二维码状态查询失败","QR status check failed")));
|
||||
for data in [json!(null), json!({}), json!({"status": "4"}), json!({"status": 99}), json!({"status": -1})] {
|
||||
assert_eq!(qr_poll_action(last, 200, &json!({"code": 0, "data": data})), QrPollAction::Failed("二维码状态响应异常"));
|
||||
assert_eq!(qr_poll_action(last, 200, &json!({"code": 0, "data": data})), QrPollAction::Failed(crate::i18n::s("二维码状态响应异常","Unexpected QR status response")));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -16,6 +16,7 @@ mod wayland;
|
||||
mod auth;
|
||||
mod assist;
|
||||
mod config;
|
||||
mod i18n;
|
||||
mod login;
|
||||
mod login_ui;
|
||||
mod session_lock;
|
||||
|
||||
+4
-4
@@ -376,11 +376,11 @@ pub fn check_ffmpeg_usable() {
|
||||
if crate::desktop_backend::headless() { return; }
|
||||
tokio::spawn(async {
|
||||
static LAST_NOTICE: std::sync::Mutex<Option<Instant>> = std::sync::Mutex::new(None);
|
||||
const SUMMARY: &str = "无法传输远程画面";
|
||||
let summary = crate::i18n::s("无法传输远程画面","Cannot stream the remote desktop");
|
||||
match ffmpeg_encoders().await {
|
||||
None => {
|
||||
log::error!("FFmpeg is not runnable: desktop video cannot start and viewers stay on 正在传输画面. Install ffmpeg (Debian/Ubuntu: sudo apt install ffmpeg; Arch: sudo pacman -S ffmpeg; Fedora: ffmpeg from RPM Fusion), or set ffmpeg_root, then check `uuremote-server doctor`");
|
||||
let text = "未找到可运行的 FFmpeg,客户端会一直停在「正在传输画面」。\n请安装后重新连接:sudo apt install ffmpeg(Arch:sudo pacman -S ffmpeg;Fedora 需先启用 RPM Fusion)";
|
||||
let text = crate::i18n::s("未找到可运行的 FFmpeg,客户端会一直停在「正在传输画面」。\n请安装后重新连接:sudo apt install ffmpeg(Arch:sudo pacman -S ffmpeg;Fedora 需先启用 RPM Fusion)","No runnable FFmpeg found; viewers stay on the loading screen.\nInstall it and reconnect: sudo apt install ffmpeg (Arch: sudo pacman -S ffmpeg; Fedora: enable RPM Fusion first)");
|
||||
let previous = {
|
||||
let mut last = LAST_NOTICE.lock().unwrap_or_else(|e| e.into_inner());
|
||||
let previous = *last;
|
||||
@@ -389,7 +389,7 @@ pub fn check_ffmpeg_usable() {
|
||||
due.then_some(previous)
|
||||
};
|
||||
// The notification is a blocking D-Bus call (bounded to 3 s).
|
||||
let told = tokio::task::spawn_blocking(move || crate::assist::show_problem(SUMMARY, Some(text), previous.is_some())).await.unwrap_or(false);
|
||||
let told = tokio::task::spawn_blocking(move || crate::assist::show_problem(summary, Some(text), previous.is_some())).await.unwrap_or(false);
|
||||
// Only a notice that reached the person starts the 5-minute quiet period.
|
||||
if let (Some(previous), false) = (previous, told) {
|
||||
*LAST_NOTICE.lock().unwrap_or_else(|e| e.into_inner()) = previous;
|
||||
@@ -398,7 +398,7 @@ pub fn check_ffmpeg_usable() {
|
||||
}
|
||||
Some(found) => {
|
||||
if !found.contains(&"libx264") { log::warn!("FFmpeg has no libx264: CPU encoding and the fallback after a hardware encoder failure are unavailable. Install a full ffmpeg build"); }
|
||||
tokio::task::spawn_blocking(|| crate::assist::show_problem(SUMMARY, None, false));
|
||||
tokio::task::spawn_blocking(move || crate::assist::show_problem(summary, None, false));
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
+27
-10
@@ -22,20 +22,35 @@ fn device_platform(data:&Value,device:&str)->Option<i64>{
|
||||
.find(|d|d.get("device_id").and_then(Value::as_str)==Some(device))
|
||||
.and_then(|d|d.get("platform")).and_then(Value::as_i64)
|
||||
}
|
||||
/// English for server messages observed in assistance and connection replies.
|
||||
fn english_message(msg: &str) -> Option<&'static str> {
|
||||
Some(match msg {
|
||||
"验证码错误" => "Wrong verification code",
|
||||
"对方未开启协助" => "The partner has not turned on remote assistance",
|
||||
"无法对同账号的设备发起远程协助" => "Remote assistance between devices of the same account is not possible",
|
||||
"被控端正在被远控中,无法发起连接" => "This computer is already being controlled from another device",
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
pub enum Error { AuthenticationExpired, Api(i32, String), InvalidResponse, Transport, MissingRoom, InvalidDevice, InvalidAssist, UnknownKeyboardPlatform }
|
||||
impl std::fmt::Display for Error {
|
||||
// The server's short message is user-facing (e.g. 2002 「被控端正在被远控中,无法发起连接」).
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
Error::Api(code, msg) if !msg.is_empty() => write!(f, "{msg} (code {code})"),
|
||||
Error::AuthenticationExpired => write!(f, "登录已过期,请重新登录"),
|
||||
Error::Transport => write!(f, "网络连接失败"),
|
||||
Error::InvalidAssist => write!(f, "请输入对方的设备 ID 和有效验证码"),
|
||||
Error::InvalidResponse => write!(f, "服务器响应格式无效"),
|
||||
Error::MissingRoom => write!(f, "服务器未返回可用的房间或信令信息"),
|
||||
Error::UnknownKeyboardPlatform => write!(f, "无法确定目标键盘平台,不能启用控制"),
|
||||
Error::Api(code, _) => write!(f, "连接请求失败(错误码 {code})"),
|
||||
// Observed 2002: the target already has a controller (another viewer, a phone).
|
||||
Error::Api(2002, _) => f.write_str(crate::i18n::s("被控端正在被远控中,无法发起连接(错误码 2002)",
|
||||
"This computer is already being controlled from another device; disconnect there and try again (error 2002)")),
|
||||
// Server messages are Chinese only: the English UI translates the known ones.
|
||||
Error::Api(code, msg) if !msg.is_empty() && !crate::i18n::english() => write!(f, "{msg} (code {code})"),
|
||||
Error::Api(code, msg) if english_message(msg).is_some() => write!(f, "{} (code {code})", english_message(msg).unwrap_or_default()),
|
||||
Error::AuthenticationExpired => f.write_str(crate::i18n::s("登录已过期,请重新登录","Sign-in expired, please sign in again")),
|
||||
Error::Transport => f.write_str(crate::i18n::s("网络连接失败","Network connection failed")),
|
||||
Error::InvalidAssist => f.write_str(crate::i18n::s("请输入对方的设备 ID 和有效验证码","Enter the partner's device ID and a valid code")),
|
||||
Error::InvalidResponse => f.write_str(crate::i18n::s("服务器响应格式无效","Invalid server response")),
|
||||
Error::MissingRoom => f.write_str(crate::i18n::s("服务器未返回可用的房间或信令信息","The server returned no usable room or signaling info")),
|
||||
Error::UnknownKeyboardPlatform => f.write_str(crate::i18n::s("无法确定目标键盘平台,不能启用控制","Unknown remote keyboard platform; control is disabled")),
|
||||
Error::Api(code, _) => f.write_str(&crate::tr!("连接请求失败(错误码 {code})","Connection request failed (error {code})")),
|
||||
_ => write!(f, "viewer API: {self:?}"),
|
||||
}
|
||||
}
|
||||
@@ -237,7 +252,8 @@ mod tests {
|
||||
assert_eq!(parse_share(200,v,&[]).err().unwrap(),Error::MissingRoom);
|
||||
}
|
||||
for msg in ["验证码错误","对方未开启协助","无法对同账号的设备发起远程协助"] {
|
||||
assert_eq!(parse_share(422,json!({"code":9876,"msg":msg}),&[]).err().unwrap().to_string(),format!("{msg} (code 9876)"));
|
||||
let shown=if crate::i18n::english() {english_message(msg).unwrap()} else {msg};
|
||||
assert_eq!(parse_share(422,json!({"code":9876,"msg":msg}),&[]).err().unwrap().to_string(),format!("{shown} (code 9876)"));
|
||||
}
|
||||
assert_eq!(parse_share(422,json!({"code":9876,"msg":"fixture-code\nfixture-token"}),&["fixture-code","fixture-token",""]).err().unwrap(),Error::Api(9876,"[已隐藏][已隐藏]".into()));
|
||||
assert_eq!(parse_share(422,json!({"code":1120,"msg":"expired"}),&[]).err().unwrap(),Error::AuthenticationExpired);
|
||||
@@ -405,7 +421,8 @@ mod http_tests {
|
||||
for msg in ["验证码错误","对方未开启协助","无法对同账号的设备发起远程协助"] {
|
||||
let(url,job)=server(vec![(422,json!({"code":9876,"msg":msg}))]).await;
|
||||
let error=Api::new(signer(),&url).join_share("synthetic-id","synthetic-code").await.err().unwrap();
|
||||
assert_eq!(error.to_string(),format!("{msg} (code 9876)"));assert_eq!(job.await.unwrap().len(),1);
|
||||
let shown=if crate::i18n::english() {english_message(msg).unwrap()} else {msg};
|
||||
assert_eq!(error.to_string(),format!("{shown} (code 9876)"));assert_eq!(job.await.unwrap().len(),1);
|
||||
}
|
||||
for (status,body,expected) in [
|
||||
(200,json!({"code":405,"msg":"业务拒绝"}),Error::Api(405,"业务拒绝".into())),
|
||||
|
||||
@@ -4,10 +4,10 @@ use tokio::{io::AsyncWriteExt,process::{Child,Command}};
|
||||
|
||||
pub fn read_code(input: impl BufRead) -> Result<String,String> {
|
||||
let mut code=String::new();
|
||||
input.take(1025).read_line(&mut code).map_err(|_|"无法从 stdin 读取验证码")?;
|
||||
if code.len()>1024 {return Err("验证码过长".into())}
|
||||
input.take(1025).read_line(&mut code).map_err(|_|crate::i18n::s("无法从 stdin 读取验证码","Cannot read the code from stdin"))?;
|
||||
if code.len()>1024 {return Err(crate::i18n::s("验证码过长","Code is too long").into())}
|
||||
if code.ends_with('\n') {code.pop();if code.ends_with('\r'){code.pop();}}
|
||||
if code.trim().is_empty() || code.chars().any(char::is_control) {return Err("请输入有效验证码".into())}
|
||||
if code.trim().is_empty() || code.chars().any(char::is_control) {return Err(crate::i18n::s("请输入有效验证码","Enter a valid code").into())}
|
||||
Ok(code)
|
||||
}
|
||||
pub fn command(exe:&Path,id:&str)->Command {
|
||||
@@ -17,10 +17,10 @@ pub fn command(exe:&Path,id:&str)->Command {
|
||||
}
|
||||
pub async fn send_code(child:&mut Child,code:&str)->Result<(),String> {
|
||||
let result=async {
|
||||
let mut stdin=child.stdin.take().ok_or("无法打开会话输入管道")?;
|
||||
stdin.write_all(code.as_bytes()).await.map_err(|_|"无法向会话传递验证码")?;
|
||||
stdin.write_all(b"\n").await.map_err(|_|"无法向会话传递验证码")?;
|
||||
stdin.shutdown().await.map_err(|_|"无法关闭会话输入管道")
|
||||
let mut stdin=child.stdin.take().ok_or(crate::i18n::s("无法打开会话输入管道","Cannot open the session input pipe"))?;
|
||||
stdin.write_all(code.as_bytes()).await.map_err(|_|crate::i18n::s("无法向会话传递验证码","Cannot pass the code to the session"))?;
|
||||
stdin.write_all(b"\n").await.map_err(|_|crate::i18n::s("无法向会话传递验证码","Cannot pass the code to the session"))?;
|
||||
stdin.shutdown().await.map_err(|_|crate::i18n::s("无法关闭会话输入管道","Cannot close the session input pipe"))
|
||||
}.await;
|
||||
if result.is_err() {let _=child.kill().await;}
|
||||
result.map_err(str::to_owned)
|
||||
|
||||
+4
-3
@@ -93,20 +93,21 @@ mod playback {
|
||||
if let Some(mut child)=self.child.take() {let _=child.start_kill();tokio::spawn(async move {let _=child.wait().await;});}
|
||||
}
|
||||
}
|
||||
pub struct Playback { queue:sdl2::audio::AudioQueue<i16>, decoder:Decoder }
|
||||
pub struct Playback { queue:sdl2::audio::AudioQueue<i16>, decoder:Decoder, pub volume:u8 }
|
||||
impl Playback {
|
||||
pub fn new(sdl:&sdl2::Sdl,audio:Audio)->Option<Self> {
|
||||
if !audio.enabled {return None}
|
||||
let result=(|| {
|
||||
let subsystem=sdl.audio()?;
|
||||
let queue=subsystem.open_queue::<i16,_>(None,&sdl2::audio::AudioSpecDesired{freq:Some(48000),channels:Some(2),samples:Some(960)})?;
|
||||
let decoder=Decoder::new(audio)?;queue.resume();Ok::<_,String>(Self{queue,decoder})
|
||||
let decoder=Decoder::new(audio)?;queue.resume();Ok::<_,String>(Self{queue,decoder,volume:100})
|
||||
})();
|
||||
match result {Ok(p)=>Some(p),Err(_)=>{log::warn!("Viewer audio playback unavailable");None}}
|
||||
}
|
||||
pub fn pump(&mut self)->Result<(),String> {
|
||||
if !self.decoder.alive() {return Err("Audio decoder stopped".into())}
|
||||
while let Some(samples)=self.decoder.pcm.pop() {
|
||||
while let Some(mut samples)=self.decoder.pcm.pop() {
|
||||
if self.volume<100 {let v=i32::from(self.volume);for s in samples.iter_mut(){*s=(i32::from(*s)*v/100) as i16;}}
|
||||
if self.queue.size()+samples.len() as u32*2>SDL_BYTES {self.queue.clear();}
|
||||
self.queue.queue_audio(&samples).map_err(|_|"Audio queue failed")?;
|
||||
}Ok(())
|
||||
|
||||
+82
-29
@@ -1,34 +1,35 @@
|
||||
//! H.264/H.265 decoding through an external `ffmpeg` process, like the host's encoder pipeline.
|
||||
//! Needs only the ffmpeg CLI, not FFmpeg development libraries.
|
||||
//! Output is scaled into a fixed letterboxed canvas so every frame has a known byte length; the
|
||||
//! source size from ffmpeg's stream line tells the window which sub-rectangle is picture content.
|
||||
//! Frames are decoded at the host's native size (resampling the picture blurs text); ffmpeg's verbose
|
||||
//! scaler line gives the size before the first frame. `UU_VIEWER_SIZE` keeps the old fixed letterboxed
|
||||
//! canvas, where the stream line tells the window which sub-rectangle is picture content.
|
||||
use super::desktop::{Decoder,Frame};
|
||||
use super::media::Codec;
|
||||
use std::io::{BufRead,Read,Write};
|
||||
use std::process::{Child,ChildStdin,Command,Stdio};
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::{AtomicU64,Ordering};
|
||||
use std::sync::atomic::{AtomicBool,AtomicU64,Ordering};
|
||||
use std::sync::mpsc::{Receiver,TryRecvError};
|
||||
|
||||
pub struct Cli { child:Child, input:Option<ChildStdin>, codec:Codec, frames:Receiver<Vec<u8>>, width:u32, height:u32, source:Arc<AtomicU64> }
|
||||
pub struct Cli { child:Child, input:Option<ChildStdin>, codec:Codec, frames:Receiver<(u32,u32,Vec<u8>)>, fixed:Option<(u32,u32)>, source:Arc<AtomicU64>, resized:Arc<AtomicBool> }
|
||||
|
||||
impl Cli {
|
||||
/// `UU_VIEWER_SIZE=WxH` picks the decoded size (default 1920x1080); `UU_VIEWER_FFMPEG` the binary.
|
||||
/// `UU_VIEWER_SIZE=WxH` scales into a fixed canvas (default: native size); `UU_VIEWER_FFMPEG` the binary.
|
||||
pub fn new()->Result<Self,String> {
|
||||
let (width,height)=std::env::var("UU_VIEWER_SIZE").ok()
|
||||
let fixed=std::env::var("UU_VIEWER_SIZE").ok()
|
||||
.and_then(|v|{let (w,h)=v.split_once('x')?;Some((w.parse().ok()?,h.parse().ok()?))})
|
||||
.filter(|&(w,h):&(u32,u32)|(16..=8192).contains(&w)&&(16..=8192).contains(&h)&&w%2==0&&h%2==0)
|
||||
.unwrap_or((1920,1080));
|
||||
Self::with_codec(Codec::H264,width,height)
|
||||
.filter(|&(w,h):&(u32,u32)|(16..=8192).contains(&w)&&(16..=8192).contains(&h)&&w%2==0&&h%2==0);
|
||||
Self::with_codec(Codec::H264,fixed)
|
||||
}
|
||||
fn with_codec(codec:Codec,width:u32,height:u32)->Result<Self,String> {
|
||||
fn with_codec(codec:Codec,fixed:Option<(u32,u32)>)->Result<Self,String> {
|
||||
let ffmpeg=std::env::var("UU_VIEWER_FFMPEG").unwrap_or_else(|_|"ffmpeg".into());
|
||||
let filter=format!("scale={width}:{height}:force_original_aspect_ratio=decrease,pad={width}:{height}:(ow-iw)/2:(oh-ih)/2");
|
||||
let filter=fixed.map(|(width,height)|format!("scale={width}:{height}:force_original_aspect_ratio=decrease:flags=lanczos,pad={width}:{height}:(ow-iw)/2:(oh-ih)/2"));
|
||||
let passthrough=passthrough_args(&ffmpeg);
|
||||
let mut child=Command::new(&ffmpeg)
|
||||
.args(["-hide_banner","-loglevel","info","-nostats","-nostdin","-threads","1","-probesize","32","-analyzeduration","0",
|
||||
"-fflags","nobuffer","-flags","low_delay","-f",codec.demuxer(),"-i","pipe:0","-an","-vf",&filter,
|
||||
"-pix_fmt","rgb24",
|
||||
let mut command=Command::new(&ffmpeg);
|
||||
command.args(["-hide_banner","-loglevel","verbose","-nostats","-nostdin","-threads","1","-probesize","32","-analyzeduration","0",
|
||||
"-fflags","nobuffer","-flags","low_delay","-f",codec.demuxer(),"-i","pipe:0","-an"]);
|
||||
if let Some(filter)=&filter {command.args(["-vf",filter]);}
|
||||
let mut child=command.args(["-pix_fmt","rgb24",
|
||||
// Raw H.264/H.265 carries no timestamps; constant-rate output dropped almost every frame of
|
||||
// the official Mac host's stream (270 → 2). Pass frames through unchanged.
|
||||
passthrough.0,passthrough.1,"-f","rawvideo","pipe:1"])
|
||||
@@ -37,30 +38,58 @@ impl Cli {
|
||||
let input=child.stdin.take().ok_or("ffmpeg stdin missing")?;
|
||||
let mut output=child.stdout.take().ok_or("ffmpeg stdout missing")?;
|
||||
// Source picture size from the one-time stream line; 0 until parsed. Only the numbers are kept.
|
||||
let source=Arc::new(AtomicU64::new(0));
|
||||
let source=Arc::new(AtomicU64::new(0));let resized=Arc::new(AtomicBool::new(false));
|
||||
let (size_tx,size_rx)=std::sync::mpsc::sync_channel::<(u32,u32)>(1);
|
||||
if let Some((w,h))=fixed {let _=size_tx.send((w,h));}
|
||||
if let Some(stderr)=child.stderr.take() {
|
||||
let source=source.clone();
|
||||
let (source,resized)=(source.clone(),resized.clone());
|
||||
let _=std::thread::Builder::new().name("uu-viewer-ffmpeg-info".into()).spawn(move||{
|
||||
let mut native=None;
|
||||
for line in std::io::BufReader::new(stderr).lines().map_while(Result::ok) {
|
||||
if source.load(Ordering::Relaxed)!=0 {continue}
|
||||
if let Some((w,h))=parse_video_size(&line) {source.store((u64::from(w)<<32)|u64::from(h),Ordering::Relaxed);}
|
||||
if fixed.is_some() {
|
||||
if source.load(Ordering::Relaxed)!=0 {continue}
|
||||
if let Some((w,h))=parse_video_size(&line) {source.store((u64::from(w)<<32)|u64::from(h),Ordering::Relaxed);}
|
||||
continue
|
||||
}
|
||||
// Native: the first scaler line fixes the output size; ffmpeg auto-scales a later
|
||||
// resolution change to it, so a different input size means the decoder must restart.
|
||||
let Some((input,out))=parse_scaler_sizes(&line) else {continue};
|
||||
match native {
|
||||
None=>{native=Some(out);let _=size_tx.send(out);},
|
||||
Some(size) if input!=size=>resized.store(true,Ordering::Release),
|
||||
Some(_)=>{},
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
let size=width as usize*height as usize*3;
|
||||
// Bounded: a slow window drops decoded frames instead of growing memory.
|
||||
let (tx,frames)=std::sync::mpsc::sync_channel(2);
|
||||
std::thread::Builder::new().name("uu-viewer-decode".into()).spawn(move||{
|
||||
let Ok((width,height))=size_rx.recv() else {return};
|
||||
let size=width as usize*height as usize*3;
|
||||
loop {
|
||||
let mut frame=vec![0;size];
|
||||
if output.read_exact(&mut frame).is_err() {break;}
|
||||
match tx.try_send(frame) { Ok(())|Err(std::sync::mpsc::TrySendError::Full(_))=>{}, Err(_)=>break }
|
||||
match tx.try_send((width,height,frame)) { Ok(())|Err(std::sync::mpsc::TrySendError::Full(_))=>{}, Err(_)=>break }
|
||||
}
|
||||
}).map_err(|e|format!("Decoder reader: {e}"))?;
|
||||
Ok(Self{child,input:Some(input),codec,frames,width,height,source})
|
||||
Ok(Self{child,input:Some(input),codec,frames,fixed,source,resized})
|
||||
}
|
||||
}
|
||||
|
||||
/// Verbose swscale setup line: `[auto_scale_0 @ 0x..] w:3024 h:1964 fmt:yuv420p ... -> w:3024 h:1964 fmt:rgb24 ...`.
|
||||
fn parse_scaler_sizes(line:&str)->Option<((u32,u32),(u32,u32))> {
|
||||
let (input,out)=line.split_once(" -> ")?;
|
||||
if !out.contains(" fmt:") {return None}
|
||||
fn size(part:&str)->Option<(u32,u32)> {
|
||||
let mut words=part.split_whitespace();
|
||||
let w=words.find_map(|t|t.strip_prefix("w:"))?.parse().ok()?;
|
||||
let h=words.next()?.strip_prefix("h:")?.parse().ok()?;
|
||||
((16..=16384).contains(&w)&&(16..=16384).contains(&h)).then_some((w,h))
|
||||
}
|
||||
Some((size(input.rsplit_once("] ").map_or(input,|(_,rest)|rest))?,size(out)?))
|
||||
}
|
||||
|
||||
/// `30000/1001`-style or display strings are irrelevant here: the first WxH on a `Video:` line is the
|
||||
/// coded picture size, which is the aspect the scale+pad filter letterboxes into the canvas.
|
||||
fn parse_video_size(line:&str)->Option<(u32,u32)> {
|
||||
@@ -93,19 +122,33 @@ fn passthrough_args(ffmpeg:&str)->(&'static str,&'static str) {
|
||||
|
||||
impl Decoder for Cli {
|
||||
fn set_codec(&mut self,codec:Codec)->Result<(),String>{
|
||||
if self.codec!=codec {*self=Self::with_codec(codec,self.width,self.height)?;}Ok(())
|
||||
if self.codec!=codec {*self=Self::with_codec(codec,self.fixed)?;}Ok(())
|
||||
}
|
||||
fn reset(&mut self) {}
|
||||
fn decode(&mut self,au:&[u8])->Result<Vec<Frame>,String> {
|
||||
if self.resized.load(Ordering::Acquire) {
|
||||
// The caller resets and asks for a key frame; the new process sizes itself from it.
|
||||
*self=Self::with_codec(self.codec,self.fixed)?;
|
||||
return Err("remote resolution changed".into());
|
||||
}
|
||||
let input=self.input.as_mut().ok_or("ffmpeg input closed")?;
|
||||
input.write_all(au).and_then(|_|input.flush()).map_err(|_|"ffmpeg decoder exited")?;
|
||||
// The raw-stream parser ends an access unit only when the next one starts; an access unit
|
||||
// delimiter right after it releases the picture now instead of one remote frame later.
|
||||
let delimiter:&[u8]=match self.codec {Codec::H264=>&[0,0,0,1,0x09,0xf0],Codec::H265=>&[0,0,0,1,0x46,0x01,0x50]};
|
||||
input.write_all(au).and_then(|_|input.write_all(delimiter)).and_then(|_|input.flush()).map_err(|_|"ffmpeg decoder exited")?;
|
||||
self.take_frames()
|
||||
}
|
||||
fn poll(&mut self)->Vec<Frame> {self.take_frames().unwrap_or_default()}
|
||||
}
|
||||
impl Cli {
|
||||
fn take_frames(&mut self)->Result<Vec<Frame>,String> {
|
||||
let mut out=Vec::new();
|
||||
loop {
|
||||
match self.frames.try_recv() {
|
||||
Ok(rgb)=>{
|
||||
Ok((width,height,rgb))=>{
|
||||
let source=self.source.load(Ordering::Relaxed);
|
||||
let content=(source!=0).then(||((source>>32) as u32,source as u32));
|
||||
out.push(Frame{width:self.width,height:self.height,rgb,content})
|
||||
let content=(self.fixed.is_some()&&source!=0).then(||((source>>32) as u32,source as u32));
|
||||
out.push(Frame{width,height,rgb,content})
|
||||
},
|
||||
Err(TryRecvError::Empty)=>break,
|
||||
Err(TryRecvError::Disconnected)=>return Err("ffmpeg decoder exited".into()),
|
||||
@@ -135,7 +178,9 @@ impl Drop for Cli { fn drop(&mut self) { let _=self.child.kill(); let _=self.chi
|
||||
Err(e) if e.kind()==std::io::ErrorKind::NotFound=>{eprintln!("skip: ffmpeg is not on PATH");return},
|
||||
result=>assert!(result.expect("ffmpeg availability").success()),
|
||||
}
|
||||
let mut cli=Cli::with_codec(Codec::H265,32,32).unwrap();
|
||||
// Native size and the fixed UU_VIEWER_SIZE canvas.
|
||||
for fixed in [None,Some((32,32))] {
|
||||
let mut cli=Cli::with_codec(Codec::H265,fixed).unwrap();
|
||||
for (codec,data) in [
|
||||
(Codec::H264,&include_bytes!("../../tests/fixtures/viewer/red-420.h264")[..]),
|
||||
(Codec::H265,&include_bytes!("../../tests/fixtures/viewer/red-420.hevc")[..]),
|
||||
@@ -146,7 +191,7 @@ impl Drop for Cli { fn drop(&mut self) { let _=self.child.kill(); let _=self.chi
|
||||
// Exercise the same streaming process and RGB conversion as SDL, then drain at EOF.
|
||||
let mut frames=cli.decode(data).unwrap();drop(cli.input.take());
|
||||
loop {match cli.frames.recv_timeout(std::time::Duration::from_secs(5)) {
|
||||
Ok(rgb)=>frames.push(Frame{width:32,height:32,rgb,content:None}),
|
||||
Ok((width,height,rgb))=>frames.push(Frame{width,height,rgb,content:None}),
|
||||
Err(std::sync::mpsc::RecvTimeoutError::Disconnected)=>break,
|
||||
Err(e)=>panic!("{codec:?} decoder did not finish: {e}"),
|
||||
}}
|
||||
@@ -155,9 +200,17 @@ impl Drop for Cli { fn drop(&mut self) { let _=self.child.kill(); let _=self.chi
|
||||
assert!(!frames.is_empty(),"{codec:?}: no RGB frames");
|
||||
for frame in frames {
|
||||
assert_eq!(frame.rgb.len(),32*32*3);
|
||||
assert_eq!((frame.width,frame.height),(32,32));
|
||||
assert!(frame.rgb.chunks_exact(3).all(|p|p[0]>220 && p[1]<30 && p[2]<30),"{codec:?}: RGB conversion");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#[test] fn native_size_is_read_from_the_scaler_line(){
|
||||
assert_eq!(super::parse_scaler_sizes("[auto_scale_0 @ 0x7f55ac005f40] w:3024 h:1964 fmt:yuv420p csp:unknown range:unknown sar:1/1 -> w:3024 h:1964 fmt:rgb24 csp:gbr range:pc sar:1/1 flags:0x00000004"),Some(((3024,1964),(3024,1964))));
|
||||
assert_eq!(super::parse_scaler_sizes("[auto_scaler_0 @ 0x55d] w:2560 h:1440 fmt:yuv444p sar:1/1 -> w:1920 h:1080 fmt:rgb24 sar:1/1 flags:0x4"),Some(((2560,1440),(1920,1080))));
|
||||
assert_eq!(super::parse_scaler_sizes("[Parsed_pad_1 @ 0x7f00] w:32 h:32 -> w:64 h:32 x:16 y:0 color:0x000000FF"),None);
|
||||
assert_eq!(super::parse_scaler_sizes(" Stream #0:0 -> #0:0 (h264 (native) -> rawvideo (native))"),None);
|
||||
}
|
||||
#[test] fn source_size_is_read_from_the_ffmpeg_stream_line(){
|
||||
assert_eq!(super::parse_video_size(" Stream #0:0: Video: h264 (High), yuv420p(progressive), 3024x1964, 25 fps"),Some((3024,1964)));
|
||||
|
||||
+23
-1
@@ -7,11 +7,26 @@ impl Default for Desktop {
|
||||
}
|
||||
/// `content` is the source picture size inside the (possibly padded) RGB canvas; None = full frame.
|
||||
pub struct Frame { pub width:u32, pub height:u32, pub rgb:Vec<u8>, pub content:Option<(u32,u32)> }
|
||||
pub trait Decoder { fn set_codec(&mut self,codec:super::media::Codec)->Result<(),String>; fn decode(&mut self, au:&[u8])->Result<Vec<Frame>,String>; fn reset(&mut self); }
|
||||
pub trait Decoder { fn set_codec(&mut self,codec:super::media::Codec)->Result<(),String>; fn decode(&mut self, au:&[u8])->Result<Vec<Frame>,String>; fn reset(&mut self);
|
||||
/// Frames finished since the last call, without new input; an asynchronous decoder
|
||||
/// returns a picture here instead of holding it until the next access unit arrives.
|
||||
fn poll(&mut self)->Vec<Frame> {Vec::new()} }
|
||||
pub trait FrameSink { fn present(&mut self,frame:&Frame)->Result<(),String>; }
|
||||
/// Counts only (access units, presented frames, decode errors) for the periodic stats line.
|
||||
pub static STATS:[std::sync::atomic::AtomicU64;3]=[std::sync::atomic::AtomicU64::new(0),std::sync::atomic::AtomicU64::new(0),std::sync::atomic::AtomicU64::new(0)];
|
||||
fn wants_key_frame(units:u64,presented:u64)->bool {presented==0 && units%30==0}
|
||||
/// True when an Annex-B access unit carries an IDR/IRAP slice the decoder can restart from.
|
||||
pub fn is_key_frame(codec:super::media::Codec,au:&[u8])->bool {
|
||||
au.windows(4).enumerate().filter(|(_,w)|w[..3]==[0,0,1]).any(|(_,w)|match codec {
|
||||
super::media::Codec::H264=>w[3]&0x1f==5,
|
||||
super::media::Codec::H265=>(16..=21).contains(&((w[3]>>1)&0x3f)),
|
||||
})
|
||||
}
|
||||
/// Shows the newest frame a decoder finished between access units.
|
||||
pub fn drain(decoder:&mut dyn Decoder,sink:&mut dyn FrameSink)->Result<(),String> {
|
||||
if let Some(frame)=decoder.poll().pop() {STATS[1].fetch_add(1,Ordering::Relaxed);sink.present(&frame)?;}
|
||||
Ok(())
|
||||
}
|
||||
pub fn display(decoder:&mut dyn Decoder,sink:&mut dyn FrameSink,au:&[u8],codec:super::media::Codec,pli:&AtomicBool)->Result<(),String> {
|
||||
let units=STATS[0].fetch_add(1,Ordering::Relaxed)+1;
|
||||
// A later session can join a clean stream with no IDR in flight (#124): keep asking until a frame shows.
|
||||
@@ -35,6 +50,13 @@ pub fn display(decoder:&mut dyn Decoder,sink:&mut dyn FrameSink,au:&[u8],codec:s
|
||||
}
|
||||
}
|
||||
#[cfg(test)] mod tests {
|
||||
#[test] fn key_frames_by_nal_type(){
|
||||
use crate::viewer::media::Codec;
|
||||
assert!(super::is_key_frame(Codec::H264,&[0,0,0,1,0x67,1,0,0,0,1,0x68,2,0,0,0,1,0x65,3]));
|
||||
assert!(!super::is_key_frame(Codec::H264,&[0,0,0,1,0x61,1]));
|
||||
assert!(super::is_key_frame(Codec::H265,&[0,0,0,1,0x40,1,0,0,1,0x26,1,3]));
|
||||
assert!(!super::is_key_frame(Codec::H265,&[0,0,0,1,0x02,1]));
|
||||
}
|
||||
use super::*;
|
||||
struct Mock(bool);impl Decoder for Mock {fn set_codec(&mut self,_:crate::viewer::media::Codec)->Result<(),String>{Ok(())} fn decode(&mut self,_:&[u8])->Result<Vec<Frame>,String>{if self.0{Err("synthetic".into())}else{Ok(vec![Frame{width:1,height:1,rgb:vec![0;3],content:None}])}} fn reset(&mut self){self.0=false;}}
|
||||
struct Sink(usize);impl FrameSink for Sink{fn present(&mut self,f:&Frame)->Result<(),String>{assert_eq!(f.rgb.len(),3);self.0+=1;Ok(())}}
|
||||
|
||||
@@ -0,0 +1,55 @@
|
||||
//! "Allow the same account to control this device": the Settings switch runs this computer's own
|
||||
//! host (`uuremote-server`, the sibling binary) as the systemd user service, so the Linux machine
|
||||
//! shows up in every client of that account. Hosting is opt-in: the viewer never enables the
|
||||
//! service by itself, and the unit's enabled state is the saved choice. The host reads the shared
|
||||
//! config.json, so a running host only needs a restart to go online with a new account.
|
||||
use std::process::{Command, Stdio};
|
||||
|
||||
const UNIT: &str = "uuremote-native.service";
|
||||
/// `UU_VIEWER_HOST=0` leaves the host service alone.
|
||||
pub fn managed() -> bool { std::env::var("UU_VIEWER_HOST").as_deref() != Ok("0") }
|
||||
fn systemctl(args: &[&str]) -> bool {
|
||||
Command::new("systemctl").arg("--user").args(args).stdin(Stdio::null()).stdout(Stdio::null()).stderr(Stdio::null())
|
||||
.status().is_ok_and(|s| s.success())
|
||||
}
|
||||
pub fn active() -> bool { systemctl(&["is-active", "--quiet", UNIT]) }
|
||||
fn installed() -> bool { systemctl(&["cat", UNIT]) }
|
||||
|
||||
/// Same unit as packaging/deb and README (graphical-session.target imports DISPLAY / WAYLAND_DISPLAY).
|
||||
fn unit_text(server: &std::path::Path) -> String {
|
||||
format!("[Unit]\nDescription=UU Remote Linux host (unofficial)\nAfter=graphical-session.target\nPartOf=graphical-session.target\n\n\
|
||||
[Service]\nEnvironment=RUST_LOG=info\nExecStart={}\nRestart=always\nRestartSec=5\n\n[Install]\nWantedBy=graphical-session.target\n", server.display())
|
||||
}
|
||||
fn install(server: &std::path::Path) -> Result<(), String> {
|
||||
let base = std::env::var_os("XDG_CONFIG_HOME").map(std::path::PathBuf::from).filter(|p| p.is_absolute())
|
||||
.or_else(|| std::env::var_os("HOME").map(|h| std::path::PathBuf::from(h).join(".config"))).ok_or("No config directory")?;
|
||||
let dir = base.join("systemd/user");
|
||||
std::fs::create_dir_all(&dir).map_err(|_| "Cannot create the systemd user directory")?;
|
||||
std::fs::write(dir.join(UNIT), unit_text(server)).map_err(|_| "Cannot write the host service")?;
|
||||
if systemctl(&["daemon-reload"]) { Ok(()) } else { Err("systemctl --user daemon-reload failed".into()) }
|
||||
}
|
||||
|
||||
/// Starts the host and keeps it enabled (installing the user unit next to the viewer's binary if
|
||||
/// there is none). Only the Settings switch calls this.
|
||||
pub fn enable(viewer: &std::path::Path) -> Result<(), String> {
|
||||
if !installed() {
|
||||
let server = viewer.with_file_name("uuremote-server");
|
||||
if !server.is_file() { return Err("uuremote-server is not installed next to the viewer".into()) }
|
||||
install(&server)?;
|
||||
}
|
||||
if systemctl(&["enable", "--now", UNIT]) { log::info!("Host service enabled"); Ok(()) } else { Err("Cannot start the host service".into()) }
|
||||
}
|
||||
/// The account changed: a running host reloads its credentials. A stopped host stays stopped.
|
||||
pub fn restart() -> Result<(), String> {
|
||||
if systemctl(&["try-restart", UNIT]) { log::info!("Host service restarted"); Ok(()) } else { Err("Cannot restart the host service".into()) }
|
||||
}
|
||||
pub fn disable() -> Result<(), String> {
|
||||
if systemctl(&["disable", "--now", UNIT]) { log::info!("Host service disabled"); Ok(()) } else { Err("Cannot stop the host service".into()) }
|
||||
}
|
||||
|
||||
#[cfg(test)] mod tests {
|
||||
#[test] fn unit_runs_the_given_server(){
|
||||
let text=super::unit_text(std::path::Path::new("/opt/uu/uuremote-server"));
|
||||
assert!(text.contains("ExecStart=/opt/uu/uuremote-server\n"));assert!(text.contains("WantedBy=graphical-session.target"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,374 @@
|
||||
//! In-window viewer chrome drawn over the remote picture, like the official client's: the loading
|
||||
//! screen, the network-status panel (Ctrl+Alt+G), the control-center tab and its menu (Ctrl+Alt+M).
|
||||
//! Shapes and text are rasterized on the CPU into small RGBA layers (anti-aliased); text uses a system
|
||||
//! font found with fc-match (CJK capable). Without a font only shapes are drawn.
|
||||
use ab_glyph::{Font, FontVec, PxScale, ScaleFont};
|
||||
use crate::i18n::s;
|
||||
|
||||
pub type Rgba = [u8; 4];
|
||||
const PANEL: Rgba = [32, 34, 40, 255];
|
||||
const HOVER: Rgba = [255, 255, 255, 16];
|
||||
const TEXT: Rgba = [240, 242, 245, 255];
|
||||
const DIM: Rgba = [160, 166, 176, 255];
|
||||
const ACCENT: Rgba = [59, 130, 246, 255];
|
||||
const DANGER: Rgba = [248, 113, 113, 255];
|
||||
|
||||
/// Straight-alpha RGBA pixels, uploaded as SDL_PIXELFORMAT_RGBA32 with alpha blending.
|
||||
pub struct Layer { pub w: u32, pub h: u32, pub px: Vec<u8> }
|
||||
impl Layer {
|
||||
pub fn new(w: u32, h: u32) -> Self { Self { w: w.max(1), h: h.max(1), px: vec![0; w.max(1) as usize * h.max(1) as usize * 4] } }
|
||||
fn blend(&mut self, x: i32, y: i32, c: Rgba, coverage: f32) {
|
||||
if x < 0 || y < 0 || x >= self.w as i32 || y >= self.h as i32 || coverage <= 0. { return }
|
||||
let i = (y as usize * self.w as usize + x as usize) * 4;
|
||||
let sa = c[3] as f32 / 255. * coverage.min(1.);
|
||||
let da = self.px[i + 3] as f32 / 255.;
|
||||
let oa = sa + da * (1. - sa);
|
||||
if oa <= 0. { return }
|
||||
for k in 0..3 { self.px[i + k] = ((c[k] as f32 * sa + self.px[i + k] as f32 * da * (1. - sa)) / oa).round() as u8; }
|
||||
self.px[i + 3] = (oa * 255.).round() as u8;
|
||||
}
|
||||
/// Anti-aliased rounded rectangle; coverage from the signed distance to the rounded edge.
|
||||
pub fn round_rect(&mut self, x: f32, y: f32, w: f32, h: f32, r: f32, c: Rgba) {
|
||||
let r = r.min(w / 2.).min(h / 2.);
|
||||
for py in y.floor() as i32..(y + h).ceil() as i32 { for px in x.floor() as i32..(x + w).ceil() as i32 {
|
||||
let (fx, fy) = (px as f32 + 0.5, py as f32 + 0.5);
|
||||
let qx = (fx - (x + w / 2.)).abs() - (w / 2. - r);
|
||||
let qy = (fy - (y + h / 2.)).abs() - (h / 2. - r);
|
||||
let d = (qx.max(0.).hypot(qy.max(0.))) + qx.max(qy).min(0.) - r;
|
||||
self.blend(px, py, c, 0.5 - d);
|
||||
}}
|
||||
}
|
||||
pub fn circle(&mut self, cx: f32, cy: f32, r: f32, c: Rgba) { self.round_rect(cx - r, cy - r, r * 2., r * 2., r, c); }
|
||||
/// Text with its top-left at (x, y); returns the advance width.
|
||||
pub fn text(&mut self, font: Option<&FontVec>, x: f32, y: f32, text: &str, size: f32, c: Rgba) -> f32 {
|
||||
let Some(font) = font else { return 0. };
|
||||
let scaled = font.as_scaled(PxScale::from(size));
|
||||
let mut caret = x;
|
||||
for ch in text.chars() {
|
||||
let id = scaled.glyph_id(ch);
|
||||
let glyph = id.with_scale_and_position(PxScale::from(size), ab_glyph::point(caret, y + scaled.ascent()));
|
||||
caret += scaled.h_advance(id);
|
||||
if let Some(outline) = font.outline_glyph(glyph) {
|
||||
let b = outline.px_bounds();
|
||||
outline.draw(|gx, gy, v| self.blend(b.min.x.floor() as i32 + gx as i32, b.min.y.floor() as i32 + gy as i32, c, v));
|
||||
}
|
||||
}
|
||||
caret - x
|
||||
}
|
||||
}
|
||||
pub fn measure(font: Option<&FontVec>, text: &str, size: f32) -> f32 {
|
||||
let Some(font) = font else { return text.chars().count() as f32 * size * 0.55 };
|
||||
let scaled = font.as_scaled(PxScale::from(size));
|
||||
text.chars().map(|ch| scaled.h_advance(scaled.glyph_id(ch))).sum()
|
||||
}
|
||||
|
||||
/// The UI font: `UU_VIEWER_FONT` (a .ttf/.otf/.ttc path), else fontconfig's CJK-capable sans-serif.
|
||||
pub fn load_font() -> Option<FontVec> {
|
||||
let (path, index) = match std::env::var("UU_VIEWER_FONT") {
|
||||
Ok(p) if !p.is_empty() => (p, 0),
|
||||
_ => {
|
||||
let out = std::process::Command::new("fc-match").args(["-f", "%{file}\t%{index}", "sans-serif:lang=zh-cn"]).output().ok()?;
|
||||
let line = String::from_utf8(out.stdout).ok()?;
|
||||
let (file, index) = line.split_once('\t').unwrap_or((line.as_str(), "0"));
|
||||
// fontconfig puts the variable-font named instance in the upper 16 bits; the face is below.
|
||||
(file.to_owned(), index.trim().parse::<u32>().unwrap_or(0) & 0xffff)
|
||||
}
|
||||
};
|
||||
let data = std::fs::read(&path).ok()?;
|
||||
let mut font = FontVec::try_from_vec_and_index(data, index).ok()?;
|
||||
// Variable CJK fonts default to their lightest master; use a regular UI weight.
|
||||
use ab_glyph::VariableFont;
|
||||
font.set_variation(b"wght", 450.);
|
||||
Some(font)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- loading screen
|
||||
|
||||
pub fn spinner(t: f32, size: u32) -> Layer {
|
||||
let mut l = Layer::new(size, size);
|
||||
let c = size as f32 / 2.;
|
||||
let head = (t * 1.1).fract() * std::f32::consts::TAU;
|
||||
for i in 0..12 {
|
||||
let a = i as f32 / 12. * std::f32::consts::TAU;
|
||||
// Brightness falls off smoothly behind the rotating head.
|
||||
let behind = (head - a).rem_euclid(std::f32::consts::TAU) / std::f32::consts::TAU;
|
||||
let alpha = (255. * (1. - behind).powf(1.6)).max(40.) as u8;
|
||||
l.circle(c + a.sin() * c * 0.72, c - a.cos() * c * 0.72, size as f32 * 0.07, [255, 255, 255, alpha]);
|
||||
}
|
||||
l
|
||||
}
|
||||
|
||||
pub fn label_layer(font: Option<&FontVec>, text: &str, size: f32, c: Rgba) -> Layer {
|
||||
let mut l = Layer::new(measure(font, text, size).ceil() as u32 + 4, (size * 1.4).ceil() as u32);
|
||||
l.text(font, 2., 0., text, size, c);
|
||||
l
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- network status
|
||||
|
||||
#[derive(Default, Clone, PartialEq)]
|
||||
pub struct NetStats { pub elapsed: u64, pub route: String, pub fps: u32, pub kbps: f64, pub rtt_ms: Option<u32>, pub loss: f64, pub size: (u32, u32), pub codec: &'static str, pub chroma: u32 }
|
||||
pub fn stats_lines(n: &NetStats) -> Vec<String> {
|
||||
let rate = if n.kbps >= 1000. { format!("{:.1} Mbps", n.kbps / 1000.) } else { format!("{:.0} Kbps", n.kbps) };
|
||||
vec![
|
||||
format!("{:02}:{:02}:{:02}", n.elapsed / 3600, n.elapsed / 60 % 60, n.elapsed % 60),
|
||||
if n.route.is_empty() { "--".into() } else { n.route.clone() },
|
||||
format!("{} fps · {}", n.fps, n.codec),
|
||||
rate,
|
||||
n.rtt_ms.map_or_else(|| "RTT --".into(), |r| format!("RTT {r} ms")),
|
||||
format!("{} {:.1}%", s("丢包", "Loss"), n.loss),
|
||||
format!("{}×{} · {}", n.size.0, n.size.1, if n.chroma == 3 { "4:4:4" } else { "4:2:0" }),
|
||||
]
|
||||
}
|
||||
pub fn stats_layer(font: Option<&FontVec>, lines: &[String], scale: f32) -> Layer {
|
||||
let size = 13. * scale;
|
||||
let w = lines.iter().map(|l| measure(font, l, size)).fold(0., f32::max) + 24. * scale;
|
||||
let h = lines.len() as f32 * size * 1.45 + 16. * scale;
|
||||
let mut l = Layer::new(w.ceil() as u32, h.ceil() as u32);
|
||||
l.round_rect(0., 0., w, h, 8. * scale, [0, 0, 0, 150]);
|
||||
for (i, line) in lines.iter().enumerate() { l.text(font, 12. * scale, 8. * scale + i as f32 * size * 1.45, line, size, TEXT); }
|
||||
l
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- control center
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Debug)]
|
||||
pub enum Command {
|
||||
Quality(u64), Fps(u32), Chroma(u32), FollowRemote(bool), OneToOne(bool), Volume(u8),
|
||||
AutoLock(bool), HostMute(bool), GrabKeys(bool), Files, Watch(bool), Stats(bool), HideTab(bool), Fullscreen, Disconnect,
|
||||
}
|
||||
/// What the menu shows as selected. Remote settings start at the official viewer's defaults and
|
||||
/// reflect only this session's choices; the host does not report them back.
|
||||
#[derive(Clone, PartialEq)]
|
||||
pub struct State {
|
||||
pub quality: u64, pub fps: u32, pub chroma: u32, pub follow_remote: bool, pub one_to_one: bool, pub volume: u8,
|
||||
pub auto_lock: bool, pub host_mute: bool, pub grab_keys: bool, pub watch: bool, pub stats: bool, pub hide_tab: bool, pub fullscreen: bool,
|
||||
}
|
||||
impl Default for State {
|
||||
fn default() -> Self { Self { quality: 5, fps: 60, chroma: 1, follow_remote: true, one_to_one: false, volume: 100, auto_lock: false,
|
||||
host_mute: false, grab_keys: false, watch: false, stats: false, hide_tab: false, fullscreen: false } }
|
||||
}
|
||||
|
||||
enum Opt { Header(&'static str), Radio(&'static str, bool, Command), Check(&'static str, bool, Command), Action(&'static str, Command, &'static str), Slider }
|
||||
fn categories() -> [&'static str; 10] {
|
||||
[s("显示屏", "Display"), s("画质", "Quality"), s("窗口", "Window"), s("声音", "Sound"), s("安全", "Security"),
|
||||
s("外设", "Peripherals"), s("工具", "Tools"), s("更多", "More"), s("全屏", "Full screen"), s("退出远控", "Disconnect")]
|
||||
}
|
||||
fn options(cat: usize, st: &State) -> Vec<Opt> {
|
||||
use Opt::*;
|
||||
match cat {
|
||||
0 => vec![Header(s("分辨率", "Resolution")), Radio(s("跟随被控端", "Follow the remote"), st.follow_remote, Command::FollowRemote(true)),
|
||||
Radio(s("跟随当前窗口", "Match this window"), !st.follow_remote, Command::FollowRemote(false))],
|
||||
1 => vec![Radio(s("自动", "Auto"), st.quality == 5, Command::Quality(5)), Radio(s("原画 20M", "Original 20M"), st.quality == 4, Command::Quality(4)),
|
||||
Radio(s("超清 8M", "Ultra HD 8M"), st.quality == 3, Command::Quality(3)), Radio(s("高清 2M", "HD 2M"), st.quality == 2, Command::Quality(2)),
|
||||
Header(s("帧率", "Frame rate")), Radio(s("144 帧", "144 fps"), st.fps == 144, Command::Fps(144)), Radio(s("90 帧", "90 fps"), st.fps == 90, Command::Fps(90)),
|
||||
Radio(s("60 帧", "60 fps"), st.fps == 60, Command::Fps(60)), Radio(s("30 帧", "30 fps"), st.fps == 30, Command::Fps(30)),
|
||||
Header(s("色彩", "Color")), Radio(s("真彩 4:4:4", "True color 4:4:4"), st.chroma == 3, Command::Chroma(3)),
|
||||
Radio(s("常规色彩", "Standard color"), st.chroma != 3, Command::Chroma(1))],
|
||||
2 => vec![Radio(s("自适应", "Fit to window"), !st.one_to_one, Command::OneToOne(false)), Radio(s("实际大小 1:1", "Actual size 1:1"), st.one_to_one, Command::OneToOne(true))],
|
||||
3 => vec![Slider],
|
||||
4 => vec![Check(s("远程结束后,被控端自动锁屏", "Lock the remote when the session ends"), st.auto_lock, Command::AutoLock(!st.auto_lock)),
|
||||
Check(s("被控端静音运行", "Mute the remote while connected"), st.host_mute, Command::HostMute(!st.host_mute))],
|
||||
5 => vec![Header(s("键盘", "Keyboard")), Check(s("发送系统快捷键到被控端", "Send system shortcuts (Alt+Tab)"), st.grab_keys, Command::GrabKeys(!st.grab_keys))],
|
||||
6 => vec![Action(s("文件传输", "File transfer"), Command::Files, "Ctrl+Alt+F"), Check(s("观看模式", "Watch mode"), st.watch, Command::Watch(!st.watch))],
|
||||
7 => vec![Check(s("显示网络状态", "Show network status"), st.stats, Command::Stats(!st.stats)),
|
||||
Check(s("全屏状态隐藏控制按钮", "Hide the control tab in full screen"), st.hide_tab, Command::HideTab(!st.hide_tab))],
|
||||
_ => vec![],
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, PartialEq)]
|
||||
pub enum Hit { Tab, Category(usize), Option(usize, usize), Slider(f32, f32), Panel }
|
||||
#[derive(Clone, PartialEq)]
|
||||
pub struct Menu { pub open: bool, pub category: usize, pub hover: Option<Hit>, pub dragging: bool }
|
||||
impl Default for Menu { fn default() -> Self { Self { open: false, category: 1, hover: None, dragging: false } } }
|
||||
|
||||
pub struct Rect { pub x: f32, pub y: f32, pub w: f32, pub h: f32 }
|
||||
impl Rect { pub fn contains(&self, x: f32, y: f32) -> bool { x >= self.x && y >= self.y && x < self.x + self.w && y < self.y + self.h } }
|
||||
|
||||
pub const TAB_H: f32 = 30.;
|
||||
pub fn tab_text() -> &'static str { s("控制中心", "Control center") }
|
||||
/// Width of the drawn menu icon plus its gap; fonts without U+2630 would show a box.
|
||||
const ICON_W: f32 = 18.;
|
||||
pub fn tab_rect(font: Option<&FontVec>, window: (u32, u32), scale: f32) -> Rect {
|
||||
let w = measure(font, tab_text(), 13. * scale) + (28. + ICON_W) * scale;
|
||||
Rect { x: (window.0 as f32 - w) / 2., y: 0., w, h: TAB_H * scale }
|
||||
}
|
||||
pub fn tab_layer(font: Option<&FontVec>, scale: f32, hover: bool) -> Layer {
|
||||
let r = tab_rect(font, (0, 0), scale);
|
||||
let mut l = Layer::new(r.w.ceil() as u32, r.h.ceil() as u32);
|
||||
// Flat top edge: the pill hangs from the window border.
|
||||
l.round_rect(0., -12. * scale, r.w, r.h + 12. * scale, 12. * scale, if hover { [40, 44, 52, 235] } else { [24, 26, 31, 205] });
|
||||
for i in 0..3 { l.round_rect(14. * scale, r.h / 2. + (i as f32 * 4. - 5.) * scale, 11. * scale, 1.6 * scale, 0.8 * scale, TEXT); }
|
||||
l.text(font, (14. + ICON_W) * scale, (r.h - 13. * scale * 1.25) / 2., tab_text(), 13. * scale, TEXT);
|
||||
l
|
||||
}
|
||||
|
||||
/// Menu geometry relative to its own layer; the same list drives drawing and hit testing.
|
||||
/// Cascading like the official client: a narrow category list and, beside the hovered row,
|
||||
/// a card sized to the selected category's options.
|
||||
pub struct Layout { pub w: f32, pub h: f32, pub items: Vec<(Rect, Hit)>, pub panels: Vec<Rect> }
|
||||
const ROW: f32 = 30.; const HEADER: f32 = 22.; const SLIDER: f32 = 36.; const PAD: f32 = 6.; const SHADOW: f32 = 14.;
|
||||
const MAIN_W: f32 = 150.; const GAP: f32 = 6.; const TEXT_SIZE: f32 = 13.;
|
||||
fn option_height(opt: &Opt) -> f32 { match opt { Opt::Header(_) => HEADER, Opt::Slider => SLIDER, _ => ROW } }
|
||||
fn option_width(font: Option<&FontVec>, opt: &Opt, scale: f32) -> f32 {
|
||||
let text = |t: &str, size: f32| measure(font, t, size * scale);
|
||||
match opt {
|
||||
Opt::Header(t) => text(t, 11.) + 28. * scale,
|
||||
Opt::Radio(t, ..) | Opt::Check(t, ..) => text(t, TEXT_SIZE) + 52. * scale,
|
||||
Opt::Action(t, _, key) => text(t, TEXT_SIZE) + text(key, 11.) + 72. * scale,
|
||||
Opt::Slider => 210. * scale,
|
||||
}
|
||||
}
|
||||
pub fn layout(font: Option<&FontVec>, st: &State, menu: &Menu, scale: f32) -> Layout {
|
||||
let k = |v: f32| v * scale;
|
||||
let cats = categories().len();
|
||||
let main = Rect { x: k(SHADOW), y: k(SHADOW), w: k(MAIN_W), h: k(PAD * 2. + ROW * cats as f32) };
|
||||
let mut items: Vec<(Rect, Hit)> = (0..cats).map(|i| (Rect { x: main.x + k(PAD), y: main.y + k(PAD + ROW * i as f32), w: main.w - k(PAD * 2.), h: k(ROW) }, Hit::Category(i))).collect();
|
||||
let mut panels = vec![Rect { x: main.x, y: main.y, w: main.w, h: main.h }];
|
||||
let opts = options(menu.category, st);
|
||||
let (mut w, mut h) = (main.x + main.w + k(SHADOW), main.y + main.h + k(SHADOW));
|
||||
if !opts.is_empty() {
|
||||
let sub_w = opts.iter().map(|o| option_width(font, o, scale)).fold(k(180.), f32::max);
|
||||
let sub_h = k(PAD * 2.) + opts.iter().map(|o| k(option_height(o))).sum::<f32>();
|
||||
// Aligned with the selected category row, kept inside the main panel's height when possible.
|
||||
let row_y = main.y + k(PAD + ROW * menu.category as f32) - k(PAD);
|
||||
let sub = Rect { x: main.x + main.w + k(GAP), y: row_y.min((main.y + main.h - sub_h).max(main.y)), w: sub_w, h: sub_h };
|
||||
let mut y = sub.y + k(PAD);
|
||||
for (i, opt) in opts.iter().enumerate() {
|
||||
let r = Rect { x: sub.x + k(PAD), y, w: sub.w - k(PAD * 2.), h: k(option_height(opt)) };
|
||||
match opt {
|
||||
Opt::Header(_) => {}
|
||||
Opt::Slider => items.push((r, Hit::Slider(sub.x + k(18.), sub.w - k(70.)))),
|
||||
_ => items.push((r, Hit::Option(menu.category, i))),
|
||||
}
|
||||
y += k(option_height(opt));
|
||||
}
|
||||
w = sub.x + sub.w + k(SHADOW); h = h.max(sub.y + sub.h + k(SHADOW));
|
||||
panels.push(sub);
|
||||
}
|
||||
Layout { w, h, items, panels }
|
||||
}
|
||||
fn card(l: &mut Layer, r: &Rect, scale: f32) {
|
||||
// Soft drop shadow, then an opaque card with a hairline border.
|
||||
for i in (1..=6).rev() {
|
||||
let e = i as f32 * 2. * scale;
|
||||
l.round_rect(r.x - e / 2., r.y - e / 2. + 3. * scale, r.w + e, r.h + e, 10. * scale + e / 2., [0, 0, 0, 9]);
|
||||
}
|
||||
l.round_rect(r.x - 1., r.y - 1., r.w + 2., r.h + 2., 10. * scale + 1., [255, 255, 255, 26]);
|
||||
l.round_rect(r.x, r.y, r.w, r.h, 10. * scale, PANEL);
|
||||
}
|
||||
pub fn menu_layer(font: Option<&FontVec>, st: &State, menu: &Menu, scale: f32) -> (Layer, Layout) {
|
||||
let lay = layout(font, st, menu, scale);
|
||||
let k = |v: f32| v * scale;
|
||||
let mut l = Layer::new(lay.w.ceil() as u32, lay.h.ceil() as u32);
|
||||
for p in &lay.panels { card(&mut l, p, scale); }
|
||||
let size = k(TEXT_SIZE);
|
||||
let mid = |r: &Rect, size: f32| r.y + (r.h - size * 1.25) / 2.;
|
||||
let opts = options(menu.category, st);
|
||||
for (i, name) in categories().iter().enumerate() {
|
||||
let r = &lay.items[i].0;
|
||||
let selected = menu.category == i && !opts.is_empty();
|
||||
if selected { l.round_rect(r.x, r.y + 1., r.w, r.h - 2., k(6.), [255, 255, 255, 30]); }
|
||||
else if menu.hover == Some(Hit::Category(i)) { l.round_rect(r.x, r.y + 1., r.w, r.h - 2., k(6.), HOVER); }
|
||||
if i == 9 { l.round_rect(r.x + k(4.), r.y - k(1.), r.w - k(8.), 1., 0., [255, 255, 255, 22]); }
|
||||
l.text(font, r.x + k(10.), mid(r, size), name, size, if i == 9 { DANGER } else { TEXT });
|
||||
if !options(i, st).is_empty() { l.text(font, r.x + r.w - k(14.), mid(r, size), "›", size, if selected { TEXT } else { DIM }); }
|
||||
}
|
||||
if let Some(sub) = lay.panels.get(1) {
|
||||
let mut y = sub.y + k(PAD);
|
||||
for (i, opt) in opts.iter().enumerate() {
|
||||
let r = Rect { x: sub.x + k(PAD), y, w: sub.w - k(PAD * 2.), h: k(option_height(opt)) };
|
||||
if menu.hover == Some(Hit::Option(menu.category, i)) { l.round_rect(r.x, r.y + 1., r.w, r.h - 2., k(6.), HOVER); }
|
||||
match opt {
|
||||
Opt::Header(t) => { l.text(font, r.x + k(10.), r.y + k(6.), t, k(11.), DIM); }
|
||||
Opt::Radio(t, on, _) => {
|
||||
if *on { l.circle(r.x + k(16.), r.y + r.h / 2., k(3.), ACCENT); }
|
||||
l.text(font, r.x + k(30.), mid(&r, size), t, size, if *on { TEXT } else { [214, 218, 224, 255] });
|
||||
}
|
||||
Opt::Check(t, on, _) => {
|
||||
// Drawn check mark: fonts without U+2713 would show a box.
|
||||
if *on { let (cx, cy) = (r.x + k(16.), r.y + r.h / 2.);
|
||||
for j in 0..8 { let f = j as f32 / 7.; l.circle(cx - k(4.) + f * k(3.), cy + f * k(3.), k(1.1), ACCENT); l.circle(cx - k(1.) + f * k(6.), cy + k(3.) - f * k(7.), k(1.1), ACCENT); } }
|
||||
l.text(font, r.x + k(30.), mid(&r, size), t, size, if *on { TEXT } else { [214, 218, 224, 255] });
|
||||
}
|
||||
Opt::Action(t, _, key) => {
|
||||
l.text(font, r.x + k(30.), mid(&r, size), t, size, TEXT);
|
||||
let kw = measure(font, key, k(11.));
|
||||
l.text(font, r.x + r.w - kw - k(10.), mid(&r, k(11.)), key, k(11.), DIM);
|
||||
}
|
||||
Opt::Slider => {
|
||||
let (a, len) = (sub.x + k(18.), sub.w - k(70.));
|
||||
let v = st.volume as f32 / 100.; let cy = r.y + r.h / 2.;
|
||||
l.round_rect(a, cy - k(2.), len, k(4.), k(2.), [255, 255, 255, 40]);
|
||||
l.round_rect(a, cy - k(2.), (len * v).max(k(4.)), k(4.), k(2.), ACCENT);
|
||||
l.circle(a + len * v, cy, k(7.), [0, 0, 0, 60]);
|
||||
l.circle(a + len * v, cy, k(6.), [255, 255, 255, 255]);
|
||||
let label = format!("{}%", st.volume);
|
||||
l.text(font, sub.x + sub.w - k(14.) - measure(font, &label, k(12.)), mid(&r, k(12.)), &label, k(12.), DIM);
|
||||
}
|
||||
}
|
||||
y += r.h;
|
||||
}
|
||||
}
|
||||
(l, lay)
|
||||
}
|
||||
/// The command for a click on an option row.
|
||||
pub fn option_command(st: &State, cat: usize, index: usize) -> Option<Command> {
|
||||
match options(cat, st).get(index)? { Opt::Radio(_, _, c) | Opt::Check(_, _, c) | Opt::Action(_, c, _) => Some(*c), _ => None }
|
||||
}
|
||||
pub fn category_command(cat: usize) -> Option<Command> { match cat { 8 => Some(Command::Fullscreen), 9 => Some(Command::Disconnect), _ => None } }
|
||||
pub fn slider_value(x: f32, a: f32, len: f32) -> u8 { (((x - a) / len).clamp(0., 1.) * 100.).round() as u8 }
|
||||
|
||||
/// Viewer preferences that outlive a session (`viewer.json` next to config.json).
|
||||
pub fn load_prefs(st: &mut State) {
|
||||
let Ok(text) = std::fs::read_to_string(prefs_path()) else { return };
|
||||
let Ok(v) = serde_json::from_str::<serde_json::Value>(&text) else { return };
|
||||
if let Some(b) = v["stats"].as_bool() { st.stats = b; }
|
||||
if let Some(b) = v["hide_tab_fullscreen"].as_bool() { st.hide_tab = b; }
|
||||
if let Some(b) = v["one_to_one"].as_bool() { st.one_to_one = b; }
|
||||
if let Some(n) = v["volume"].as_u64() { st.volume = n.min(100) as u8; }
|
||||
}
|
||||
pub fn save_prefs(st: &State) {
|
||||
let path = prefs_path();
|
||||
if let Some(dir) = path.parent() { let _ = std::fs::create_dir_all(dir); }
|
||||
let v = serde_json::json!({"stats": st.stats, "hide_tab_fullscreen": st.hide_tab, "one_to_one": st.one_to_one, "volume": st.volume});
|
||||
let _ = std::fs::write(path, v.to_string());
|
||||
}
|
||||
fn prefs_path() -> std::path::PathBuf { crate::config::path().parent().map_or_else(|| "viewer.json".into(), |d| d.join("viewer.json")) }
|
||||
|
||||
#[cfg(test)] mod tests {
|
||||
use super::*;
|
||||
#[test] fn layers_blend_inside_bounds_only(){
|
||||
let mut l=Layer::new(8,8);l.round_rect(-4.,-4.,20.,20.,3.,[255,0,0,255]);l.circle(100.,100.,5.,[0,0,0,255]);
|
||||
assert!(l.px.chunks_exact(4).all(|p|p==[255,0,0,255]));
|
||||
let mut l=Layer::new(4,4);l.round_rect(0.,0.,4.,4.,0.,[0,0,255,128]);assert_eq!(&l.px[..4],&[0,0,255,128]);
|
||||
}
|
||||
#[test] fn every_option_row_has_a_command_and_categories_map_actions(){
|
||||
let st=State::default();
|
||||
for cat in 0..10 { let lay=layout(None,&st,&Menu{category:cat,..Default::default()},1.);
|
||||
for (_,hit) in &lay.items { if let Hit::Option(c,i)=hit { assert!(option_command(&st,*c,*i).is_some()); } } }
|
||||
assert_eq!(category_command(9),Some(Command::Disconnect));assert_eq!(category_command(1),None);
|
||||
assert_eq!(slider_value(150.,100.,100.),50);assert_eq!(slider_value(0.,100.,100.),0);
|
||||
}
|
||||
/// `UU_HUD_PREVIEW=dir cargo test render_preview -- --ignored` writes the chrome as PNGs (visual check).
|
||||
#[test] #[ignore] fn render_preview(){
|
||||
let Some(dir)=std::env::var_os("UU_HUD_PREVIEW") else {return};let dir=std::path::PathBuf::from(dir);
|
||||
let font=load_font();let font=font.as_ref();
|
||||
let save=|name:&str,l:&Layer,bg:[u8;3]|{
|
||||
let rgb:Vec<u8>=l.px.chunks_exact(4).flat_map(|p|{let a=p[3] as u32;(0..3).map(move|k|((p[k] as u32*a+bg[k] as u32*(255-a))/255) as u8)}).collect();
|
||||
crate::viewer::type_ipc::write_png_rgb(&dir.join(name),l.w,l.h,&rgb,false).unwrap();
|
||||
};
|
||||
let st=State{stats:true,..State::default()};
|
||||
for cat in [1usize,3,4] {let (l,_)=menu_layer(font,&st,&Menu{open:true,category:cat,hover:Some(Hit::Option(cat,1)),dragging:false},1.);save(&format!("menu{cat}.png"),&l,[200,200,210]);}
|
||||
save("tab.png",&tab_layer(font,1.,false),[230,230,230]);
|
||||
let n=NetStats{elapsed:57,route:"UDP · relay".into(),fps:60,kbps:8420.,rtt_ms:Some(36),loss:0.,size:(1920,1080),codec:"H.265",chroma:1};
|
||||
save("stats.png",&stats_layer(font,&stats_lines(&n),1.),[230,230,230]);
|
||||
save("spinner.png",&spinner(0.3,56),[17,19,24]);
|
||||
save("title.png",&label_layer(font,"Connecting to PUNOSEVAC",20.,[240,242,245,255]),[17,19,24]);
|
||||
}
|
||||
#[test] fn stats_lines_format_numbers(){
|
||||
let n=NetStats{elapsed:3723,route:"UDP · relay".into(),fps:60,kbps:8420.,rtt_ms:Some(36),loss:0.25,size:(1920,1080),codec:"H.265",chroma:3};
|
||||
let l=stats_lines(&n);assert_eq!(l[0],"01:02:03");assert_eq!(l[3],"8.4 Mbps");assert_eq!(l[4],"RTT 36 ms");assert!(l[6].ends_with("4:4:4"));
|
||||
}
|
||||
}
|
||||
@@ -66,6 +66,7 @@ impl Input {
|
||||
pub fn new(view_only:bool)->Self {Self{view_only,..Default::default()}}
|
||||
pub fn set_mac(&mut self,mac:bool){self.mac=mac;}
|
||||
pub fn enabled(&self)->bool {!self.view_only}
|
||||
pub fn set_view_only(&mut self,view_only:bool){self.view_only=view_only;}
|
||||
pub fn key(&mut self,scan:i32,down:bool)->Option<Value> {
|
||||
if self.view_only {return None}
|
||||
let vk=if self.mac{mac_keycode(scan)}else{windows_vk(scan)}?;
|
||||
|
||||
+6
-3
@@ -16,6 +16,9 @@ pub mod desktop;
|
||||
#[cfg(uu_gtk)] pub mod ui;
|
||||
#[cfg(uu_gtk)] pub mod tools_ui;
|
||||
#[cfg(feature="viewer-sdl")] pub mod sdl;
|
||||
#[cfg(feature="viewer-sdl")] pub mod hud;
|
||||
pub mod thumbs;
|
||||
#[cfg(uu_gtk)] pub mod host;
|
||||
|
||||
pub mod tools;
|
||||
|
||||
@@ -25,7 +28,7 @@ pub mod secure_input;
|
||||
pub mod type_ipc;
|
||||
|
||||
fn device_label(name:Option<&str>)->&str{
|
||||
name.filter(|name|!name.is_empty()).unwrap_or("远端设备")
|
||||
name.filter(|name|!name.is_empty()).unwrap_or_else(||crate::i18n::s("远端设备","Remote device"))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -33,7 +36,7 @@ mod device_label_tests {
|
||||
#[test]
|
||||
fn device_name_or_fallback(){
|
||||
assert_eq!(super::device_label(Some("测试电脑")),"测试电脑");
|
||||
assert_eq!(super::device_label(None),"远端设备");
|
||||
assert_eq!(super::device_label(Some("")),"远端设备");
|
||||
assert_eq!(super::device_label(None),crate::i18n::s("远端设备","Remote device"));
|
||||
assert_eq!(super::device_label(Some("")),crate::i18n::s("远端设备","Remote device"));
|
||||
}
|
||||
}
|
||||
@@ -36,6 +36,10 @@ pub struct Observed {
|
||||
pub media_packets:AtomicU64,
|
||||
pub encoder_codecs:AtomicU32,
|
||||
pub chroma:AtomicU32,
|
||||
/// Received RTP payload bytes and video packets vs. sequence span, for the network-status panel.
|
||||
pub media_bytes:AtomicU64,
|
||||
pub video_received:AtomicU64,
|
||||
pub video_expected:AtomicU64,
|
||||
}
|
||||
pub struct Peer {
|
||||
clipboard:super::clipboard::Bridge,
|
||||
@@ -115,11 +119,22 @@ impl Peer {
|
||||
let mut receiver=super::media::Receiver::new(super::media::Codec::from_mime(&track.codec().capability.mime_type).unwrap_or_default());
|
||||
let mut tick=tokio::time::interval(std::time::Duration::from_millis(40));
|
||||
let mut last_pli=std::time::Instant::now()-std::time::Duration::from_secs(1);
|
||||
let mut span:Option<(u16,u64)>=None;
|
||||
loop {
|
||||
let output=tokio::select! {
|
||||
packet=track.read_rtp()=>match packet {
|
||||
Ok((p,_))=>{
|
||||
counters.media_packets.fetch_add(1,Ordering::Relaxed);
|
||||
counters.media_bytes.fetch_add(p.payload.len() as u64+12,Ordering::Relaxed);
|
||||
if video {
|
||||
// Extended sequence span: forward steps add, reordered/old packets do not.
|
||||
let seq=p.header.sequence_number;
|
||||
let (last,expected)=span.unwrap_or((seq.wrapping_sub(1),0));
|
||||
let step=seq.wrapping_sub(last);
|
||||
span=Some(if step!=0 && step<32768 {(seq,expected+u64::from(step))} else {(last,expected)});
|
||||
counters.video_expected.store(span.map_or(0,|s|s.1),Ordering::Relaxed);
|
||||
counters.video_received.fetch_add(1,Ordering::Relaxed);
|
||||
}
|
||||
if !video {if opus {audio.push(p.header.sequence_number,&p.payload);}continue}
|
||||
// TrackRemote updates codec from the negotiated payload type on each read.
|
||||
let Some(codec)=super::media::Codec::from_mime(&track.codec().capability.mime_type) else{continue};
|
||||
@@ -295,6 +310,25 @@ impl Peer {
|
||||
if channel.ready_state()!=webrtc::data_channel::data_channel_state::RTCDataChannelState::Open {return Err("CONTROL is not open".into())}
|
||||
channel.send(&bytes::Bytes::from(value.to_string())).await.map_err(|_|"CONTROL input send failed")?;Ok(())
|
||||
}
|
||||
/// Binary CONTROL message (protobuf envelope), e.g. capture settings and SimpleActions.
|
||||
pub async fn send_control(&self,data:Vec<u8>)->Result<(),String> {
|
||||
let channel=&self.channels[0];
|
||||
if channel.ready_state()!=webrtc::data_channel::data_channel_state::RTCDataChannelState::Open {return Err("CONTROL is not open".into())}
|
||||
channel.send(&bytes::Bytes::from(data)).await.map_err(|_|"CONTROL send failed")?;Ok(())
|
||||
}
|
||||
/// Selected ICE pair: (round-trip ms, "UDP · direct" / "TCP · relay" ...). Addresses are not kept.
|
||||
pub async fn route(&self)->(Option<u32>,String) {
|
||||
use webrtc::stats::StatsReportType as T;
|
||||
let report=self.pc.get_stats().await;
|
||||
let pair=report.reports.values().filter_map(|r|match r{T::CandidatePair(p) if p.nominated=>Some(p),_=>None}).max_by_key(|p|p.bytes_received);
|
||||
let Some(pair)=pair else {return (None,String::new())};
|
||||
let local=report.reports.get(&pair.local_candidate_id).and_then(|r|match r{T::LocalCandidate(c)=>Some(c),_=>None});
|
||||
let remote=report.reports.get(&pair.remote_candidate_id).and_then(|r|match r{T::RemoteCandidate(c)=>Some(c),_=>None});
|
||||
let relay=[local,remote].iter().flatten().any(|c|c.candidate_type==webrtc::ice::candidate::CandidateType::Relay);
|
||||
let tcp=local.is_some_and(|c|c.network_type.to_string().to_ascii_lowercase().contains("tcp") || c.relay_protocol.eq_ignore_ascii_case("tcp"));
|
||||
let rtt=(pair.current_round_trip_time>0.).then(||(pair.current_round_trip_time*1000.).round() as u32);
|
||||
(rtt,format!("{} · {}",if tcp{"TCP"}else{"UDP"},if relay{"relay"}else{"direct"}))
|
||||
}
|
||||
pub async fn close(&self) {self.clipboard.stop();self.tools.lock().unwrap().take();let _=self.pc.close().await;}
|
||||
}
|
||||
fn answer_sdp(body:&Value)->Result<String,String> {
|
||||
|
||||
+333
-18
@@ -3,22 +3,42 @@ use sdl2::{event::{Event,WindowEvent},mouse::MouseButton,pixels::PixelFormatEnum
|
||||
#[derive(Debug)] enum Command { Files, Type }
|
||||
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>,
|
||||
pub last_frame:Option<Frame> }
|
||||
pub last_frame:Option<Frame>, chrome:Chrome }
|
||||
/// In-window chrome state (src/viewer/hud.rs): menu, network panel, loading screen.
|
||||
struct Chrome { font:Option<ab_glyph::FontVec>, scale:f32, pub state:hud::State, menu:hud::Menu, net:Option<hud::NetStats>, tab_hover:bool, tab_down:bool,
|
||||
commands:Vec<hud::Command>, started:std::time::Instant, last_loading:std::time::Instant, title:String, stage:String, labels:std::collections::HashMap<(String,u32,u32),hud::Layer>,
|
||||
menu_cache:Option<(hud::State,hud::Menu,f32,hud::Layer)> }
|
||||
use super::hud;
|
||||
impl Window {
|
||||
pub fn new()->Result<Self,String>{
|
||||
// SDL's default nearest-neighbour scaling makes remote text uneven whenever the window size
|
||||
// differs from the stream; filter instead. Set before the renderer/textures exist.
|
||||
sdl2::hint::set_with_priority("SDL_RENDER_SCALE_QUALITY","linear",&sdl2::hint::Hint::Default);
|
||||
#[cfg(uu_gtk)] cairo_decorations();
|
||||
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 name=super::device_label(std::env::var("UU_VIEWER_DEVICE_NAME").ok().as_deref()).to_owned();
|
||||
let window=video.window(&format!("{name} · {}",crate::i18n::s("UU 远程 Linux 控制端","UU Remote Linux viewer")),1280,720).position_centered().resizable().build().map_err(|_|"Window creation failed")?;
|
||||
let mut canvas=window.into_canvas().build().map_err(|_|"Renderer creation failed")?;
|
||||
// Wayland maps a toplevel only after its first buffer; without this the window stays
|
||||
// invisible until the first decoded frame, which a stalled stream never delivers.
|
||||
canvas.set_draw_color(sdl2::pixels::Color::BLACK);canvas.clear();canvas.present();
|
||||
canvas.set_draw_color(LOADING_BG);canvas.clear();canvas.present();
|
||||
let scale=std::env::var("UU_VIEWER_UI_SCALE").ok().and_then(|v|v.parse::<f32>().ok()).filter(|v|(0.5..=4.).contains(v)).unwrap_or(1.);
|
||||
let mut state=hud::State::default();hud::load_prefs(&mut state);
|
||||
let now=std::time::Instant::now();
|
||||
let chrome=Chrome{font:hud::load_font(),scale,state,menu:hud::Menu::default(),net:None,tab_hover:false,tab_down:false,commands:Vec::new(),started:now,last_loading:now-std::time::Duration::from_secs(1),
|
||||
title:crate::tr!("正在连接 {name}","Connecting to {name}"),stage:crate::i18n::s("正在连接远端设备…","Contacting the remote device…").into(),labels:Default::default(),menu_cache:None};
|
||||
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,last_frame:None})
|
||||
Ok(Self{canvas,events,_sdl:sdl,frame:(1920,1080),focused:true,files:false,mac:false,clipboard,clipboard_dirty:true,clipboard_tx,clipboard_requests,last_frame:None,chrome})
|
||||
}
|
||||
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 viewport(&self)->Viewport {
|
||||
let window=self.canvas.window().size();
|
||||
if !self.chrome.state.one_to_one {return Viewport::fit(window,self.frame)}
|
||||
let (w,h)=(self.frame.0 as f64,self.frame.1 as f64);
|
||||
Viewport{x:((window.0 as f64-w)/2.).round(),y:((window.1 as f64-h)/2.).round(),width:w,height:h}
|
||||
}
|
||||
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(){
|
||||
@@ -41,21 +61,183 @@ impl Window {
|
||||
}
|
||||
pub fn poll(&mut self,input:&mut Input)->(bool,Vec<serde_json::Value>){
|
||||
let viewport=self.viewport();
|
||||
let dirty=&mut self.clipboard_dirty;let mut redraw=false;
|
||||
let events=self.events.poll_iter().inspect(|event|{
|
||||
if matches!(event,Event::ClipboardUpdate{..}|Event::Window{win_event:WindowEvent::FocusGained,..}){*dirty=true;}
|
||||
redraw|=needs_redraw(event);
|
||||
});
|
||||
let result=translate_actions(events,input,viewport,&mut self.focused,&mut self.files);
|
||||
let mut redraw=false;
|
||||
let events=poll_events(&mut self.events);
|
||||
let mut forward=Vec::with_capacity(events.len());
|
||||
for event in events {
|
||||
if matches!(event,Event::ClipboardUpdate{..}|Event::Window{win_event:WindowEvent::FocusGained,..}){self.clipboard_dirty=true;}
|
||||
redraw|=needs_redraw(&event);
|
||||
let (consumed,changed)=self.chrome_event(&event);redraw|=changed;
|
||||
if !consumed {forward.push(event);}
|
||||
}
|
||||
let result=translate_actions(forward,input,viewport,&mut self.focused,&mut self.files);
|
||||
// A compositor resize (tiling, maximize) leaves the surface without a buffer of the new size
|
||||
// until the next frame; a static remote desktop sends none, so repaint the last frame now.
|
||||
if redraw {if let Some(frame)=self.last_frame.take(){
|
||||
log::debug!("Viewer window resized: {:?}",self.canvas.window().size());
|
||||
if let Err(e)=self.draw(&frame){log::warn!("Viewer redraw failed: {e}");}
|
||||
self.last_frame=Some(frame);
|
||||
}else{self.canvas.set_draw_color(sdl2::pixels::Color::BLACK);self.canvas.clear();self.canvas.present();}}
|
||||
}else{self.loading_frame(true);}}
|
||||
result
|
||||
}
|
||||
/// Menu, hotkeys and the control tab. Returns (consumed, needs redraw).
|
||||
fn chrome_event(&mut self,event:&Event)->(bool,bool){
|
||||
use sdl2::keyboard::{Mod,Scancode};
|
||||
let size=self.canvas.window().size();let scale=self.chrome.scale;
|
||||
let tab=hud::tab_rect(self.chrome.font.as_ref(),size,scale);
|
||||
let tab_visible=self.tab_visible();
|
||||
if let Event::KeyDown{scancode:Some(code),keymod,repeat,..}=event {
|
||||
let chord=keymod.intersects(Mod::LCTRLMOD|Mod::RCTRLMOD)&&keymod.intersects(Mod::LALTMOD|Mod::RALTMOD);
|
||||
let command=match code {Scancode::M=>Some(None),Scancode::G=>Some(Some(hud::Command::Stats(!self.chrome.state.stats))),Scancode::Return=>Some(Some(hud::Command::Fullscreen)),_=>None};
|
||||
if chord { if let Some(command)=command {
|
||||
if !repeat { match command {None=>self.chrome.menu.open^=true,Some(c)=>self.command(c)} }
|
||||
return (true,true)
|
||||
}}
|
||||
if self.chrome.menu.open { if *code==Scancode::Escape {self.chrome.menu.open=false;} return (true,true) }
|
||||
}
|
||||
if !self.chrome.menu.open {
|
||||
return match *event {
|
||||
Event::MouseMotion{x,y,..}=>{let h=tab_visible&&tab.contains(x as f32,y as f32);let changed=h!=self.chrome.tab_hover;self.chrome.tab_hover=h;(false,changed)},
|
||||
Event::MouseButtonDown{x,y,mouse_btn:MouseButton::Left,..} if tab_visible&&tab.contains(x as f32,y as f32)=>{self.chrome.menu.open=true;self.chrome.tab_down=true;(true,true)},
|
||||
Event::MouseButtonUp{mouse_btn:MouseButton::Left,..} if self.chrome.tab_down=>{self.chrome.tab_down=false;(true,false)},
|
||||
_=>(false,false),
|
||||
}
|
||||
}
|
||||
let lay=hud::layout(self.chrome.font.as_ref(),&self.chrome.state,&self.chrome.menu,scale);let origin=self.menu_origin(&lay);
|
||||
let hit=|x:i32,y:i32|->Option<hud::Hit>{
|
||||
let (lx,ly)=(x as f32-origin.0,y as f32-origin.1);
|
||||
if tab.contains(x as f32,y as f32) {return Some(hud::Hit::Tab)}
|
||||
if !lay.panels.iter().any(|p|p.contains(lx,ly)) {return None}
|
||||
Some(lay.items.iter().find(|(r,_)|r.contains(lx,ly)).map_or(hud::Hit::Panel,|(_,h)|*h))
|
||||
};
|
||||
match *event {
|
||||
Event::MouseMotion{x,y,..}=>{
|
||||
if self.chrome.menu.dragging { if let Some((a,len))=slider(&lay) {self.command(hud::Command::Volume(hud::slider_value(x as f32-origin.0,a,len)));} return (true,true) }
|
||||
let h=hit(x,y);
|
||||
if let Some(hud::Hit::Category(i))=h { if hud::category_command(i).is_none() {self.chrome.menu.category=i;} }
|
||||
let changed=h!=self.chrome.menu.hover;self.chrome.menu.hover=h;(true,changed)
|
||||
},
|
||||
Event::MouseButtonDown{x,y,mouse_btn:MouseButton::Left,..}=>{
|
||||
match hit(x,y) {
|
||||
None|Some(hud::Hit::Tab)=>{self.chrome.menu.open=false;self.chrome.tab_down=true},
|
||||
Some(hud::Hit::Category(i))=>match hud::category_command(i) {Some(c)=>{self.chrome.menu.open=false;self.command(c)},None=>self.chrome.menu.category=i},
|
||||
Some(hud::Hit::Option(c,i))=>if let Some(command)=hud::option_command(&self.chrome.state,c,i) {
|
||||
if command==hud::Command::Files {self.chrome.menu.open=false;}
|
||||
self.command(command);
|
||||
},
|
||||
Some(hud::Hit::Slider(a,len))=>{self.chrome.menu.dragging=true;self.command(hud::Command::Volume(hud::slider_value(x as f32-origin.0,a,len)))},
|
||||
Some(hud::Hit::Panel)=>{},
|
||||
}
|
||||
(true,true)
|
||||
},
|
||||
Event::MouseButtonUp{..}=>{self.chrome.tab_down=false;if std::mem::take(&mut self.chrome.menu.dragging){hud::save_prefs(&self.chrome.state);}(true,true)},
|
||||
Event::MouseButtonDown{..}|Event::MouseWheel{..}|Event::KeyUp{..}|Event::TextInput{..}=>(true,false),
|
||||
_=>(false,false),
|
||||
}
|
||||
}
|
||||
/// Local effects happen here; remote ones are drained by `run` through `take_commands`.
|
||||
fn command(&mut self,command:hud::Command){
|
||||
let st=&mut self.chrome.state;
|
||||
match command {
|
||||
hud::Command::Quality(q)=>st.quality=q, hud::Command::Fps(f)=>st.fps=f, hud::Command::Chroma(c)=>st.chroma=c,
|
||||
hud::Command::FollowRemote(b)=>st.follow_remote=b, hud::Command::Volume(v)=>st.volume=v,
|
||||
hud::Command::AutoLock(b)=>st.auto_lock=b, hud::Command::HostMute(b)=>st.host_mute=b, hud::Command::Watch(b)=>st.watch=b,
|
||||
hud::Command::OneToOne(b)=>{st.one_to_one=b;hud::save_prefs(st)},
|
||||
hud::Command::Stats(b)=>{st.stats=b;hud::save_prefs(st)},
|
||||
hud::Command::HideTab(b)=>{st.hide_tab=b;hud::save_prefs(st)},
|
||||
hud::Command::GrabKeys(b)=>{st.grab_keys=b;self.canvas.window_mut().set_keyboard_grab(b)},
|
||||
hud::Command::Fullscreen=>{
|
||||
st.fullscreen^=true;let mode=if st.fullscreen{sdl2::video::FullscreenType::Desktop}else{sdl2::video::FullscreenType::Off};
|
||||
let _=self.canvas.window_mut().set_fullscreen(mode);
|
||||
},
|
||||
hud::Command::Files=>self.files=true,
|
||||
hud::Command::Disconnect=>{},
|
||||
}
|
||||
self.chrome.commands.push(command);
|
||||
}
|
||||
pub fn take_commands(&mut self)->Vec<hud::Command>{std::mem::take(&mut self.chrome.commands)}
|
||||
pub fn state(&self)->&hud::State{&self.chrome.state}
|
||||
pub fn sync_chroma(&mut self,chroma:u32){if chroma!=0 {self.chrome.state.chroma=chroma;}}
|
||||
pub fn set_stage(&mut self,stage:&str){self.chrome.stage=stage.into();}
|
||||
pub fn window_size(&self)->(u32,u32){self.canvas.window().size()}
|
||||
pub fn has_picture(&self)->bool{self.last_frame.is_some()}
|
||||
pub fn set_net(&mut self,net:hud::NetStats){
|
||||
let show=self.chrome.state.stats;let changed=self.chrome.net.as_ref()!=Some(&net);
|
||||
self.chrome.net=Some(net);
|
||||
if show && changed {self.redraw();}
|
||||
}
|
||||
fn tab_visible(&self)->bool{!(self.chrome.state.fullscreen&&self.chrome.state.hide_tab)||self.chrome.menu.open}
|
||||
fn menu_layout(&self)->(hud::Layer,hud::Layout){hud::menu_layer(self.chrome.font.as_ref(),&self.chrome.state,&self.chrome.menu,self.chrome.scale)}
|
||||
fn menu_origin(&self,lay:&hud::Layout)->(f32,f32){
|
||||
let size=self.canvas.window().size();
|
||||
// The category list sits centered under the tab; the cascade card grows to its right.
|
||||
let shadow=14.*self.chrome.scale;let main=lay.panels.first().map_or(lay.w,|p|p.w);
|
||||
(((size.0 as f32-main)/2.-shadow).max(-shadow).min(size.0 as f32-lay.w+shadow).round(),(hud::TAB_H*self.chrome.scale+4.-shadow).round())
|
||||
}
|
||||
pub fn redraw(&mut self){
|
||||
if let Some(frame)=self.last_frame.take(){if let Err(e)=self.draw(&frame){log::warn!("Viewer redraw failed: {e}");}self.last_frame=Some(frame);}
|
||||
else {self.loading_frame(true);}
|
||||
}
|
||||
fn blit(&mut self,layer:&hud::Layer,x:i32,y:i32)->Result<(),String>{
|
||||
let creator=self.canvas.texture_creator();
|
||||
let mut t=creator.create_texture_streaming(PixelFormatEnum::RGBA32,layer.w,layer.h).map_err(|_|"Texture creation failed")?;
|
||||
t.set_blend_mode(sdl2::render::BlendMode::Blend);
|
||||
t.update(None,&layer.px,layer.w as usize*4).map_err(|_|"Texture update failed")?;
|
||||
self.canvas.copy(&t,None,Some(Rect::new(x,y,layer.w,layer.h)))
|
||||
}
|
||||
fn label(&mut self,text:&str,size:f32,color:hud::Rgba)->hud::Layer{
|
||||
let key=(text.to_owned(),size.to_bits(),u32::from_le_bytes(color));
|
||||
if self.chrome.labels.len()>64 {self.chrome.labels.clear();}
|
||||
let font=self.chrome.font.as_ref();
|
||||
let layer=self.chrome.labels.entry(key).or_insert_with(||hud::label_layer(font,text,size,color));
|
||||
hud::Layer{w:layer.w,h:layer.h,px:layer.px.clone()}
|
||||
}
|
||||
/// Network panel, control tab and menu over the picture.
|
||||
fn draw_chrome(&mut self)->Result<(),String>{
|
||||
let size=self.canvas.window().size();let scale=self.chrome.scale;
|
||||
if self.chrome.state.stats { if let Some(net)=self.chrome.net.clone() {
|
||||
let layer=hud::stats_layer(self.chrome.font.as_ref(),&hud::stats_lines(&net),scale);
|
||||
self.blit(&layer,size.0 as i32-layer.w as i32-(12.*scale) as i32,size.1 as i32-layer.h as i32-(12.*scale) as i32)?;
|
||||
}}
|
||||
if self.tab_visible() {
|
||||
let r=hud::tab_rect(self.chrome.font.as_ref(),size,scale);
|
||||
let layer=hud::tab_layer(self.chrome.font.as_ref(),scale,self.chrome.tab_hover||self.chrome.menu.open);
|
||||
self.blit(&layer,r.x.round() as i32,0)?;
|
||||
}
|
||||
if self.chrome.menu.open {
|
||||
// Rasterizing the menu is costly; reuse it until what it shows changes.
|
||||
let c=&self.chrome;
|
||||
let cached=matches!(&c.menu_cache,Some((st,m,sc,_)) if *st==c.state&&*m==c.menu&&*sc==c.scale);
|
||||
if !cached {let (layer,_)=self.menu_layout();self.chrome.menu_cache=Some((self.chrome.state.clone(),self.chrome.menu.clone(),scale,layer));}
|
||||
let lay=hud::layout(self.chrome.font.as_ref(),&self.chrome.state,&self.chrome.menu,scale);let o=self.menu_origin(&lay);
|
||||
let (st,m,sc,layer)=self.chrome.menu_cache.take().expect("menu cached above");
|
||||
let r=self.blit(&layer,o.0 as i32,o.1 as i32);
|
||||
self.chrome.menu_cache=Some((st,m,sc,layer));r?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
/// Animated "connecting" screen until the first remote picture; throttled to ~60 fps.
|
||||
pub fn loading_frame(&mut self,force:bool){
|
||||
let now=std::time::Instant::now();
|
||||
if !force && now.duration_since(self.chrome.last_loading)<std::time::Duration::from_millis(16) {return}
|
||||
self.chrome.last_loading=now;
|
||||
let size=self.canvas.window().size();let scale=self.chrome.scale;
|
||||
self.canvas.set_draw_color(LOADING_BG);self.canvas.clear();
|
||||
let t=now.duration_since(self.chrome.started).as_secs_f32();
|
||||
let spin=hud::spinner(t,(56.*scale) as u32);
|
||||
let cy=size.1 as i32/2-(40.*scale) as i32;
|
||||
let _=self.blit(&spin,(size.0 as i32-spin.w as i32)/2,cy-spin.h as i32/2);
|
||||
let (title,stage)=(self.chrome.title.clone(),self.chrome.stage.clone());
|
||||
let a=self.label(&title,20.*scale,[240,242,245,255]);
|
||||
let _=self.blit(&a,(size.0 as i32-a.w as i32)/2,cy+(48.*scale) as i32);
|
||||
// The stage line breathes gently so a long wait still looks alive.
|
||||
let alpha=(170.+60.*(t*2.2).sin()) as u8;
|
||||
let b=self.label(&stage,14.*scale,[160,166,176,255]);
|
||||
let mut b2=b;for p in b2.px.chunks_exact_mut(4){p[3]=(u16::from(p[3])*u16::from(alpha)/255) as u8;}
|
||||
let _=self.blit(&b2,(size.0 as i32-b2.w as i32)/2,cy+(84.*scale) as i32);
|
||||
if self.chrome.menu.open||self.tab_visible() {let _=self.draw_chrome();}
|
||||
self.canvas.present();
|
||||
}
|
||||
fn draw(&mut self,frame:&Frame)->Result<(),String>{
|
||||
// Pad bars belong to the decoded canvas, not the remote picture: viewport and input use the
|
||||
// content aspect, and only the content sub-rectangle of the texture is drawn.
|
||||
@@ -66,9 +248,61 @@ impl Window {
|
||||
self.canvas.set_draw_color(sdl2::pixels::Color::BLACK);self.canvas.clear();
|
||||
let src=super::input::content_rect((frame.width,frame.height),content)
|
||||
.map(|(x,y,w,h)|Rect::new(x.round() as i32,y.round() as i32,w.round().max(1.) as u32,h.round().max(1.) as u32));
|
||||
self.canvas.copy(&texture,src,Some(Rect::new(v.x.round() as i32,v.y.round() as i32,v.width.round().max(1.) as u32,v.height.round().max(1.) as u32)))?;self.canvas.present();Ok(())
|
||||
self.canvas.copy(&texture,src,Some(Rect::new(v.x.round() as i32,v.y.round() as i32,v.width.round().max(1.) as u32,v.height.round().max(1.) as u32)))?;
|
||||
drop(texture);self.draw_chrome()?;self.canvas.present();Ok(())
|
||||
}
|
||||
}
|
||||
/// On Wayland SDL draws its title bar through libdecor; the GTK plugin calls GTK3 from SDL's thread
|
||||
/// while the tool windows run gtk_main on theirs, and the two crash in GTK's style code (SIGSEGV on
|
||||
/// closing the file window). Offer libdecor only its cairo plugin unless the user chose a directory.
|
||||
#[cfg(uu_gtk)]
|
||||
fn cairo_decorations(){
|
||||
if std::env::var_os("LIBDECOR_PLUGIN_DIR").is_some() {return}
|
||||
let Some(cairo)=["/usr/lib64/libdecor/plugins-1","/usr/lib/x86_64-linux-gnu/libdecor/plugins-1","/usr/lib/libdecor/plugins-1"]
|
||||
.iter().map(|d|std::path::Path::new(d).join("libdecor-cairo.so")).find(|p|p.exists()) else {return};
|
||||
let dir=std::env::var_os("XDG_RUNTIME_DIR").map_or_else(std::env::temp_dir,std::path::PathBuf::from).join("uuremote-libdecor");
|
||||
let link=dir.join("libdecor-cairo.so");
|
||||
if std::fs::create_dir_all(&dir).is_ok() && (link.exists() || std::os::unix::fs::symlink(&cairo,&link).is_ok()) {
|
||||
std::env::set_var("LIBDECOR_PLUGIN_DIR",&dir);
|
||||
}
|
||||
}
|
||||
const LOADING_BG:sdl2::pixels::Color=sdl2::pixels::Color::RGB(17,19,24);
|
||||
/// sdl2 0.37 transmutes every event type into its `SDL_EventType` enum, which is undefined
|
||||
/// behaviour for a type SDL 2 does not define (an abort with debug checks). sdl2-compat on SDL3
|
||||
/// delivers such types (e.g. 0x207), so drop them before the crate converts the event.
|
||||
fn poll_events(_pump:&mut sdl2::EventPump)->Vec<Event>{
|
||||
let mut events=Vec::new();
|
||||
loop{
|
||||
let mut raw=std::mem::MaybeUninit::<sdl2::sys::SDL_Event>::uninit();
|
||||
// SAFETY: the pump proves SDL events are initialised on this thread; SDL_PollEvent fills the event when it returns 1.
|
||||
if unsafe{sdl2::sys::SDL_PollEvent(raw.as_mut_ptr())}!=1 {return events}
|
||||
let raw=unsafe{raw.assume_init()};
|
||||
if sdl2_event_type(unsafe{raw.type_}) {events.push(Event::from_ll(raw));}
|
||||
}
|
||||
}
|
||||
/// The values of sdl2-sys 0.37 `SDL_EventType`.
|
||||
fn sdl2_event_type(t:u32)->bool{
|
||||
matches!(t,0|0x100..=0x107|0x150|0x200|0x201|0x300..=0x305|0x400..=0x403|0x600..=0x607|0x650..=0x659|0x700..=0x702
|
||||
|0x800..=0x802|0x900|0x1000..=0x1003|0x1100|0x1101|0x1200|0x2000|0x2001|0x7F00|0x8000|0xFFFF)
|
||||
}
|
||||
fn slider(lay:&hud::Layout)->Option<(f32,f32)>{lay.items.iter().find_map(|(_,h)|match h{hud::Hit::Slider(a,len)=>Some((*a,*len)),_=>None})}
|
||||
/// Runs `fut` while the window shows the loading animation; closing the window cancels it.
|
||||
pub async fn loading<T>(window:Option<&mut Window>,stage:&str,fut:impl std::future::Future<Output=T>)->Result<T,String>{
|
||||
let Some(window)=window else {return Ok(fut.await)};
|
||||
window.set_stage(stage);
|
||||
tokio::pin!(fut);
|
||||
let mut tick=tokio::time::interval(std::time::Duration::from_millis(16));
|
||||
loop {tokio::select!{
|
||||
value=&mut fut=>return Ok(value),
|
||||
_=tick.tick()=>{
|
||||
for event in poll_events(&mut window.events) {
|
||||
if matches!(event,Event::Quit{..}|Event::Window{win_event:WindowEvent::Close,..}) {return Err("Viewer window closed".into())}
|
||||
let _=window.chrome_event(&event);
|
||||
}
|
||||
window.loading_frame(false);
|
||||
},
|
||||
}}
|
||||
}
|
||||
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)
|
||||
@@ -111,7 +345,13 @@ fn translate_actions(events:impl IntoIterator<Item=Event>,input:&mut Input,viewp
|
||||
input.scroll(dx,dy)
|
||||
},
|
||||
_=>None,
|
||||
};if let Some(m)=message{messages.push(m);}
|
||||
};if let Some(m)=message{
|
||||
// Several motions in one poll: only the newest position matters. Sending each one
|
||||
// queues a drag behind itself on a slow (relayed) path; clicks keep their order.
|
||||
let motion=|m:&serde_json::Value|m.get("action").and_then(serde_json::Value::as_str)==Some("mouse_move_absolute");
|
||||
if motion(&m) && messages.last().is_some_and(motion) {messages.pop();}
|
||||
messages.push(m);
|
||||
}
|
||||
} (quit,messages)
|
||||
}
|
||||
|
||||
@@ -158,6 +398,15 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
|
||||
let mut input=Input::new(view_only);input.set_mac(window.mac);let mut tick=tokio::time::interval(std::time::Duration::from_millis(8));
|
||||
let mut heartbeat=tokio::time::interval(std::time::Duration::from_secs(1));
|
||||
let deadline=tokio::time::sleep(std::time::Duration::from_secs(30));tokio::pin!(deadline);
|
||||
window.set_stage(crate::i18n::s("正在传输画面…","Waiting for the remote picture…"));
|
||||
if let Some(playback)=audio.as_mut(){playback.volume=window.state().volume;}
|
||||
if window.state().grab_keys {window.canvas.window_mut().set_keyboard_grab(true);}
|
||||
let started=std::time::Instant::now();let mut seq=3_000_000u64;
|
||||
let mut last=(0u64,0u64,0u64,0u64,std::time::Instant::now());
|
||||
let mut codec_name="--";
|
||||
// After a local drop the decoder has no reference picture; P-frames would only smear blocks.
|
||||
let mut await_key=false;
|
||||
let mut next_thumb=std::time::Instant::now()+std::time::Duration::from_secs(5);
|
||||
let result=async {
|
||||
loop {tokio::select!{
|
||||
command=commands.recv(),if command_open=>{
|
||||
@@ -195,10 +444,47 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
|
||||
let o=&session.peer.observed;let s=&super::desktop::STATS;let r=std::sync::atomic::Ordering::Relaxed;
|
||||
log::info!("Viewer desktop stats: control_open={} echo={} media_packets={} access_units={} presented={} decode_errors={}",
|
||||
o.control_open.load(r),o.echo_received.load(r),o.media_packets.load(r),s[0].load(r),s[1].load(r),s[2].load(r));
|
||||
// Network-status panel: per-second deltas of local counters plus the selected ICE pair.
|
||||
let now=(s[1].load(r),o.media_bytes.load(r),o.video_received.load(r),o.video_expected.load(r),std::time::Instant::now());
|
||||
let secs=now.4.duration_since(last.4).as_secs_f64().max(0.2);
|
||||
let expected=now.3.saturating_sub(last.3);let lost=expected.saturating_sub(now.2.saturating_sub(last.2));
|
||||
let (rtt_ms,route)=session.peer.route().await;
|
||||
window.sync_chroma(o.chroma.load(r));
|
||||
let size=window.last_frame.as_ref().map_or((0,0),|f|f.content.unwrap_or((f.width,f.height)));
|
||||
window.set_net(hud::NetStats{elapsed:started.elapsed().as_secs(),route,fps:((now.0-last.0) as f64/secs).round() as u32,
|
||||
kbps:(now.1-last.1) as f64*8./1000./secs,rtt_ms,loss:if expected>0 {lost as f64*100./expected as f64} else {0.},size,
|
||||
codec:codec_name,chroma:window.state().chroma});
|
||||
last=now;
|
||||
if std::time::Instant::now()>=next_thumb { if let Some(frame)=window.last_frame.as_ref() {
|
||||
if let Err(e)=super::thumbs::save(device,frame){log::debug!("Viewer thumbnail not saved: {e}");}
|
||||
next_thumb=std::time::Instant::now()+std::time::Duration::from_secs(30);
|
||||
}}
|
||||
},
|
||||
_=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);
|
||||
let (quit,mut messages)=window.poll(&mut input);
|
||||
if !window.has_picture() {window.loading_frame(false);}
|
||||
for command in window.take_commands() {
|
||||
seq+=1;
|
||||
let control=match command {
|
||||
hud::Command::Quality(q)=>Some(super::wire::capture_setting(seq,&[(2,q)])),
|
||||
hud::Command::Fps(f)=>Some(super::wire::capture_setting(seq,&[(1,match f{30=>1,60=>2,90=>3,_=>4}),(18,u64::from(f))])),
|
||||
hud::Command::Chroma(c)=>Some(super::wire::capture_setting(seq,&[(7,u64::from(c))])),
|
||||
hud::Command::FollowRemote(true)=>Some(super::wire::capture_setting(seq,&[(10,3)])),
|
||||
hud::Command::FollowRemote(false)=>{let (w,h)=window.window_size();let (w,h)=(u64::from(w&!1),u64::from(h&!1));
|
||||
Some(super::wire::capture_setting(seq,&[(5,w),(6,h),(16,w),(17,h)]))},
|
||||
// 远程结束后自动锁屏: SimpleAction 19, value 2 = on, 1 = off.
|
||||
hud::Command::AutoLock(on)=>Some(super::wire::simple_action(seq,19,Some(if on {2} else {1}))),
|
||||
// 静音运行: on = SimpleAction 14 then 18, off = 16 (src/system_actions.rs).
|
||||
hud::Command::HostMute(true)=>{let _=session.peer.send_control(super::wire::simple_action(seq,14,None)).await;seq+=1;Some(super::wire::simple_action(seq,18,None))},
|
||||
hud::Command::HostMute(false)=>Some(super::wire::simple_action(seq,16,None)),
|
||||
hud::Command::Volume(v)=>{if let Some(playback)=audio.as_mut(){playback.volume=v;}None},
|
||||
hud::Command::Watch(on)=>{messages.extend(input.release_all());input.set_view_only(on||view_only);None},
|
||||
hud::Command::Disconnect=>return Ok(()),
|
||||
_=>None,
|
||||
};
|
||||
if let Some(data)=control { if let Err(e)=session.peer.send_control(data).await {log::warn!("Viewer control command not sent: {e}");} }
|
||||
}
|
||||
window.poll_clipboard();
|
||||
requested|=std::mem::take(&mut window.files);
|
||||
#[cfg(uu_gtk)] {
|
||||
@@ -247,12 +533,21 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
|
||||
if quit{return Ok(())}
|
||||
// At most one AU per iteration keeps local event polling responsive.
|
||||
if let Some(au)=session.peer.desktop.units.pop(){
|
||||
if session.peer.desktop.reset.swap(false,std::sync::atomic::Ordering::AcqRel){decoder.reset();}
|
||||
decoder.set_codec(au.codec)?;
|
||||
super::desktop::display(decoder,window,&au.data,au.codec,&session.peer.desktop.pli)?;}
|
||||
if session.peer.desktop.reset.swap(false,std::sync::atomic::Ordering::AcqRel){decoder.reset();await_key=true;}
|
||||
if await_key && !super::desktop::is_key_frame(au.codec,&au.data) {session.peer.desktop.pli.store(true,std::sync::atomic::Ordering::Release);}
|
||||
else {
|
||||
await_key=false;
|
||||
decoder.set_codec(au.codec)?;
|
||||
codec_name=if au.codec==super::media::Codec::H265 {"H.265"} else {"H.264"};
|
||||
super::desktop::display(decoder,window,&au.data,au.codec,&session.peer.desktop.pli)?;
|
||||
}}
|
||||
// A picture can finish after its access unit was written; show it without waiting
|
||||
// for the next one (a single keystroke may change the remote screen only once).
|
||||
else {super::desktop::drain(decoder,window)?;}
|
||||
}
|
||||
}}
|
||||
}.await;
|
||||
if let Some(frame)=window.last_frame.as_ref() {if let Err(e)=super::thumbs::save(device,frame){log::debug!("Viewer thumbnail not saved: {e}");}}
|
||||
#[cfg(uu_gtk)] if let Some(f)=files {f.abort();let _=f.await;super::tools_ui::hide();session.peer.tools.lock().unwrap().take();}
|
||||
if let Some(t)=type_ipc {t.abort();let _=t.await;}
|
||||
for m in input.release_all(){let _=session.peer.send_input(&m).await;}
|
||||
@@ -442,6 +737,15 @@ async fn pump_type_job(job: &mut TypeJob, session: &mut Session, window: &mut Wi
|
||||
assert!(tx.is_closed());drop(bridge);
|
||||
let window=Window::new().unwrap();assert!(window.clipboard_bridge().enabled);
|
||||
}
|
||||
#[test] fn only_event_types_sdl2_defines_reach_the_crate(){
|
||||
use sdl2::sys::SDL_EventType as T;
|
||||
for t in [T::SDL_QUIT,T::SDL_LOCALECHANGED,T::SDL_DISPLAYEVENT,T::SDL_WINDOWEVENT,T::SDL_TEXTEDITING_EXT,T::SDL_MOUSEWHEEL,
|
||||
T::SDL_JOYBATTERYUPDATED,T::SDL_CONTROLLERSENSORUPDATE,T::SDL_FINGERMOTION,T::SDL_MULTIGESTURE,T::SDL_CLIPBOARDUPDATE,
|
||||
T::SDL_DROPCOMPLETE,T::SDL_AUDIODEVICEREMOVED,T::SDL_SENSORUPDATE,T::SDL_RENDER_DEVICE_RESET,T::SDL_POLLSENTINEL,T::SDL_USEREVENT]{
|
||||
assert!(sdl2_event_type(t as u32),"{:#x}",t as u32);
|
||||
}
|
||||
for t in [0x151,0x202,0x207,0x306,0x404,0x608,0x65A,0x703,0x901,0x1004,0x1102,0x1201,0x2002,0x8001]{assert!(!sdl2_event_type(t),"{t:#x}");}
|
||||
}
|
||||
#[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()));
|
||||
@@ -497,6 +801,17 @@ async fn pump_type_job(job: &mut TypeJob, session: &mut Session, window: &mut Wi
|
||||
let (quit,out)=translate(events,&mut input,Viewport::fit((800,600),(1920,1080)),&mut focused);
|
||||
assert!(quit);assert!(out.is_empty());assert!(input.release_all().is_empty());
|
||||
}
|
||||
#[test] fn motions_in_one_poll_send_only_the_newest_and_keep_click_order(){
|
||||
let mut input=Input::default();let mut focused=true;
|
||||
let motion=|x,y|Event::MouseMotion{timestamp:0,window_id:1,which:0,mousestate:sdl2::mouse::MouseState::from_sdl_state(0),x,y,xrel:1,yrel:1};
|
||||
let down=Event::MouseButtonDown{timestamp:0,window_id:1,which:0,mouse_btn:MouseButton::Left,clicks:1,x:0,y:0};
|
||||
let v=Viewport::fit((800,600),(800,600));
|
||||
let (_,out)=translate([motion(10,10),motion(20,20),down,motion(30,30),motion(40,40)],&mut input,v,&mut focused);
|
||||
let actions:Vec<&str>=out.iter().map(|m|m["action"].as_str().unwrap()).collect();
|
||||
assert_eq!(actions.len(),3,"{out:?}");
|
||||
assert_eq!(actions[0],"mouse_move_absolute");assert_eq!(actions[2],"mouse_move_absolute");assert_ne!(actions[1],"mouse_move_absolute");
|
||||
assert!((out[0]["abs_x"].as_f64().unwrap()-20./800.).abs()<0.01 && (out[2]["abs_x"].as_f64().unwrap()-40./800.).abs()<0.01,"{out:?}");
|
||||
}
|
||||
#[test] fn focus_event_releases_and_suppresses_input_until_focus_returns(){
|
||||
let mut input=Input::default();input.key(4,true);input.button(1,true);let mut focused=true;
|
||||
let focus=|win_event|Event::Window{timestamp:0,window_id:1,win_event};
|
||||
|
||||
@@ -0,0 +1,58 @@
|
||||
//! Device preview pictures for the launcher, like the official client's device card: the desktop
|
||||
//! window saves a small PNG of the last remote picture. Local only (`$XDG_CACHE_HOME/uuremote/thumbs`,
|
||||
//! 0700 directory, 0600 files); `UU_VIEWER_THUMBNAILS=0` turns it off.
|
||||
use std::path::PathBuf;
|
||||
|
||||
pub fn enabled() -> bool { std::env::var("UU_VIEWER_THUMBNAILS").as_deref() != Ok("0") }
|
||||
fn dir() -> Option<PathBuf> {
|
||||
let base = std::env::var_os("XDG_CACHE_HOME").map(PathBuf::from).filter(|p| p.is_absolute())
|
||||
.or_else(|| std::env::var_os("HOME").map(|h| PathBuf::from(h).join(".cache")))?;
|
||||
Some(base.join("uuremote").join("thumbs"))
|
||||
}
|
||||
pub fn path(device: &str) -> Option<PathBuf> { Some(dir()?.join(format!("{}.png", &super::type_ipc::device_key(device)[..32]))) }
|
||||
pub fn existing(device: &str) -> Option<PathBuf> { enabled().then(|| path(device)).flatten().filter(|p| p.is_file()) }
|
||||
|
||||
/// Box-filtered downscale of the content rectangle to at most `max_w` pixels wide.
|
||||
pub fn downscale(width: u32, height: u32, rgb: &[u8], content: (u32, u32, u32, u32), max_w: u32) -> (u32, u32, Vec<u8>) {
|
||||
let (cx, cy, cw, ch) = content;
|
||||
let ratio = (cw as f64 / max_w as f64).max(1.);
|
||||
let (w, h) = (((cw as f64 / ratio).round() as u32).max(1), ((ch as f64 / ratio).round() as u32).max(1));
|
||||
let mut out = Vec::with_capacity(w as usize * h as usize * 3);
|
||||
for y in 0..h { for x in 0..w {
|
||||
let (x0, x1) = (cx + (x as f64 * ratio) as u32, (cx + ((x + 1) as f64 * ratio) as u32).max(cx + (x as f64 * ratio) as u32 + 1).min(cx + cw).min(width));
|
||||
let (y0, y1) = (cy + (y as f64 * ratio) as u32, (cy + ((y + 1) as f64 * ratio) as u32).max(cy + (y as f64 * ratio) as u32 + 1).min(cy + ch).min(height));
|
||||
let mut sum = [0u64; 3]; let mut n = 0u64;
|
||||
for sy in y0..y1 { for sx in x0..x1 {
|
||||
let i = (sy as usize * width as usize + sx as usize) * 3;
|
||||
for k in 0..3 { sum[k] += u64::from(rgb[i + k]); } n += 1;
|
||||
}}
|
||||
for k in 0..3 { out.push((sum[k] / n.max(1)) as u8); }
|
||||
}}
|
||||
(w, h, out)
|
||||
}
|
||||
|
||||
pub fn save(device: &str, frame: &super::desktop::Frame) -> Result<(), String> {
|
||||
if !enabled() { return Ok(()) }
|
||||
let path = path(device).ok_or("No cache directory")?;
|
||||
let dir = path.parent().ok_or("No cache directory")?;
|
||||
use std::os::unix::fs::{DirBuilderExt, PermissionsExt};
|
||||
std::fs::DirBuilder::new().recursive(true).mode(0o700).create(dir).map_err(|_| "Cannot create the thumbnail directory")?;
|
||||
let _ = std::fs::set_permissions(dir, std::fs::Permissions::from_mode(0o700));
|
||||
let content = super::input::content_rect((frame.width, frame.height), frame.content.unwrap_or((frame.width, frame.height)))
|
||||
.map_or((0, 0, frame.width, frame.height), |(x, y, w, h)| (x as u32, y as u32, w as u32, h as u32));
|
||||
let (w, h, rgb) = downscale(frame.width, frame.height, &frame.rgb, content, 640);
|
||||
// Write then rename, so the launcher never reads a half-written file.
|
||||
let tmp = path.with_extension("tmp");
|
||||
let _ = std::fs::remove_file(&tmp);
|
||||
super::type_ipc::write_png_rgb(&tmp, w, h, &rgb, true)?;
|
||||
std::fs::rename(&tmp, &path).map_err(|_| "Cannot store the thumbnail".into())
|
||||
}
|
||||
|
||||
#[cfg(test)] mod tests {
|
||||
#[test] fn downscale_averages_and_keeps_aspect(){
|
||||
let rgb:Vec<u8>=(0..4*2).flat_map(|i|if i%2==0{[0,0,0]}else{[200,100,50]}).collect();
|
||||
let (w,h,out)=super::downscale(4,2,&rgb,(0,0,4,2),2);
|
||||
assert_eq!((w,h),(2,1));assert_eq!(&out[..3],&[100,50,25]);
|
||||
assert_eq!(super::downscale(4,2,&rgb,(0,0,4,2),640).0,4);
|
||||
}
|
||||
}
|
||||
@@ -161,7 +161,7 @@ pub fn session_rows(sessions:&[Value])->String{
|
||||
let mut rows:Vec<_>=sessions.iter().filter_map(|s|{
|
||||
let id=u32::try_from(s["session_id"].as_u64()?).ok().filter(|n|*n!=0)?;
|
||||
let shell=s["shell"].as_str().unwrap_or("--").chars().take(256).collect::<String>().replace(['\t','\n','\r','\0']," ");
|
||||
let state=match s["state"].as_str(){Some("running")=>"运行中",Some("detached")=>"已分离",_=>"--"};
|
||||
let state=match s["state"].as_str(){Some("running")=>crate::i18n::s("运行中","Running"),Some("detached")=>crate::i18n::s("已分离","Detached"),_=>"--"};
|
||||
Some((id,format!("{id}\t{shell}\t{}\t{state}\n",s["created_at_ms"].as_u64().unwrap_or(0))))
|
||||
}).collect();rows.sort_by_key(|r|r.0);rows.into_iter().map(|r|r.1).collect()
|
||||
}
|
||||
@@ -156,7 +156,7 @@ fn terminal_metadata_is_allowlisted_and_sorted(){
|
||||
serde_json::json!({"session_id":2,"shell":"/bin/bash","state":"running"}),
|
||||
serde_json::json!({"session_id":0}),serde_json::json!({"session_id":4294967296u64}),
|
||||
]);
|
||||
assert_eq!(rows,"2\t/bin/bash\t0\t运行中\n9\t/bin/sh X Y \t123\t已分离\n");
|
||||
assert_eq!(rows,format!("2\t/bin/bash\t0\t{}\n9\t/bin/sh X Y \t123\t{}\n",crate::i18n::s("运行中","Running"),crate::i18n::s("已分离","Detached")));
|
||||
assert!(!rows.contains("PRIVATE"));assert!(terminal::session_rows(&[]).is_empty());
|
||||
}
|
||||
#[tokio::test]
|
||||
|
||||
+18
-18
@@ -54,7 +54,7 @@ fn task(id:i32,name:&str,status:&str,done:u64,total:u64,from:&str,to:&str,state:
|
||||
let(n,s,f,t)=(c(name),c(status),c(from),c(to));
|
||||
unsafe{uu_files_ui_task(id,n.as_ptr(),s.as_ptr(),done,total,f.as_ptr(),t.as_ptr(),state)}
|
||||
}
|
||||
fn reason(error:&str)->String{if error.contains("canceled"){"已取消".into()}else{format!("失败:{error}")}}
|
||||
fn reason(error:&str)->String{if error.contains("canceled"){crate::i18n::s("已取消","Canceled").into()}else{crate::tr!("失败:{error}","Failed: {error}")}}
|
||||
|
||||
pub async fn files(io:Transport,rx:mpsc::Receiver<Packet>,name:&str)->Result<(),String>{
|
||||
start("files",name)?;
|
||||
@@ -67,7 +67,7 @@ pub async fn files(io:Transport,rx:mpsc::Receiver<Packet>,name:&str)->Result<(),
|
||||
let mut guard=shown.lock().unwrap();let Some(a)=guard.as_mut() else{continue};
|
||||
if a.last.elapsed()<Duration::from_millis(200) && p.transferred<p.total{continue}a.last=Instant::now();
|
||||
let percent=if p.total>0{p.transferred*100/p.total}else{0};
|
||||
task(a.id,&a.name,&format!("传输中 {percent}%"),p.transferred,p.total,&a.from,&a.to,0);
|
||||
task(a.id,&a.name,&crate::tr!("传输中 {percent}%","Transferring {percent}%"),p.transferred,p.total,&a.from,&a.to,0);
|
||||
}
|
||||
});
|
||||
let _reporter=super::tools::Cancel(reporter.abort_handle());
|
||||
@@ -79,24 +79,24 @@ pub async fn files(io:Transport,rx:mpsc::Receiver<Packet>,name:&str)->Result<(),
|
||||
while let Some(job)=queue.recv().await{if worker_closing.load(Ordering::Acquire){break}match job{
|
||||
Job::List(path)=>match worker_f.list_dir(&path).await{
|
||||
Ok(entries)=>{remote=path.clone();let(p,r)=(c(&path),c(&entry_rows(&entries)));unsafe{uu_files_ui_set_remote(p.as_ptr(),r.as_ptr())}}
|
||||
Err(e)=>toast(&format!("无法读取远端目录:{e}")),
|
||||
Err(e)=>toast(&crate::tr!("无法读取远端目录:{e}","Cannot read remote folder: {e}")),
|
||||
},
|
||||
Job::Mkdir(path,parent)=>match worker_f.mkdir(&path).await{
|
||||
Ok(())=>if parent==remote{if let Ok(entries)=worker_f.list_dir(&remote).await{let(p,r)=(c(&remote),c(&entry_rows(&entries)));unsafe{uu_files_ui_set_remote(p.as_ptr(),r.as_ptr())}}},
|
||||
Err(e)=>toast(&format!("无法创建远端文件夹:{e}")),
|
||||
Err(e)=>toast(&crate::tr!("无法创建远端文件夹:{e}","Cannot create remote folder: {e}")),
|
||||
},
|
||||
Job::Transfer{id,upload,from,dir,generation}=>{
|
||||
let name=base_name(&from).to_owned();
|
||||
let to=if upload{remote_join(&dir,&name)}else{free_local(std::path::Path::new(&dir),&name).to_string_lossy().into_owned()};
|
||||
if generation!=worker_gen.load(Ordering::Acquire){task(id,&name,"已取消",0,0,&from,&to,2);continue}
|
||||
if generation!=worker_gen.load(Ordering::Acquire){task(id,&name,crate::i18n::s("已取消","Canceled"),0,0,&from,&to,2);continue}
|
||||
*worker_active.lock().unwrap()=Some(Active{id,name:name.clone(),from:from.clone(),to:to.clone(),last:Instant::now()});
|
||||
task(id,&name,"传输中",0,0,&from,&to,0);
|
||||
task(id,&name,crate::i18n::s("传输中","Transferring"),0,0,&from,&to,0);
|
||||
let result=if upload{worker_f.upload(&from,&to).await}else{worker_f.download(&from,&to).await};
|
||||
*worker_active.lock().unwrap()=None;
|
||||
match result{
|
||||
Ok(())=>{
|
||||
let size=std::fs::metadata(if upload{&from}else{&to}).map(|m|if m.is_file(){m.len()}else{0}).unwrap_or(0);
|
||||
task(id,&name,"已完成",size,size,&from,&to,1);
|
||||
task(id,&name,crate::i18n::s("已完成","Done"),size,size,&from,&to,1);
|
||||
if upload{if dir==remote{if let Ok(entries)=worker_f.list_dir(&remote).await{let(p,r)=(c(&remote),c(&entry_rows(&entries)));unsafe{uu_files_ui_set_remote(p.as_ptr(),r.as_ptr())}}}}
|
||||
else{unsafe{uu_files_ui_refresh_local()}}
|
||||
}
|
||||
@@ -118,7 +118,7 @@ pub async fn files(io:Transport,rx:mpsc::Receiver<Packet>,name:&str)->Result<(),
|
||||
["mkdir",path]=>{let parent=path.rfind(['/','\\']).map(|i|path[..i.max(1)].to_owned()).unwrap_or_default();let _=jobs.send(Job::Mkdir((*path).into(),parent));}
|
||||
[kind@("put"|"get"),from,dir]=>{
|
||||
let(id,upload)=(NEXT_TASK.fetch_add(1,Ordering::Relaxed),*kind=="put");
|
||||
let name=base_name(from);task(id,name,"等待中",0,0,from,dir,0);
|
||||
let name=base_name(from);task(id,name,crate::i18n::s("等待中","Waiting"),0,0,from,dir,0);
|
||||
let _=jobs.send(Job::Transfer{id,upload,from:(*from).into(),dir:(*dir).into(),generation:generation.load(Ordering::Acquire)});
|
||||
}
|
||||
["cancel"]=>{generation.fetch_add(1,Ordering::AcqRel);f.cancel();}
|
||||
@@ -147,12 +147,12 @@ pub async fn portmap(io:Transport,rx:mpsc::Receiver<Packet>,name:&str)->Result<(
|
||||
["add",rule,local,host,port]=>match(local.parse::<u16>(),port.parse::<u16>()){
|
||||
(Ok(local),Ok(port))=>match p.add_rule(*rule,local,*host,port).await{
|
||||
Ok(id)=>{targets.insert(id,format!("{host}:{port}"));}
|
||||
Err(e)=>toast(&format!("添加失败:{}",if e.contains("bind"){"本地端口已被占用".to_owned()}else{e})),
|
||||
Err(e)=>toast(&crate::tr!("添加失败:{}","Add failed: {}",if e.contains("bind"){crate::i18n::s("本地端口已被占用","Local port is already in use").to_owned()}else{e})),
|
||||
},
|
||||
_=>toast("端口无效"),
|
||||
_=>toast(crate::i18n::s("端口无效","Invalid port")),
|
||||
},
|
||||
["remove",id]=>if let Ok(id)=id.parse::<u64>(){
|
||||
if let Err(e)=p.remove_rule(id).await{toast(&format!("删除失败:{e}"))}targets.remove(&id);
|
||||
if let Err(e)=p.remove_rule(id).await{toast(&crate::tr!("删除失败:{e}","Remove failed: {e}"))}targets.remove(&id);
|
||||
},
|
||||
_=>{}
|
||||
}
|
||||
@@ -160,9 +160,9 @@ pub async fn portmap(io:Transport,rx:mpsc::Receiver<Packet>,name:&str)->Result<(
|
||||
let mut status=p.status();status.sort_by_key(|s|s.id);
|
||||
let rows:String=status.iter().map(|s|format!("{}\t{}\t127.0.0.1:{}\t{}\t{}\n",s.id,s.name.replace(['\t','\n']," "),s.local_port,
|
||||
targets.get(&s.id).map(String::as_str).unwrap_or("-"),
|
||||
if s.failures>0{format!("已启用 · {} 个连接 · {} 次失败",s.streams,s.failures)}else{format!("已启用 · {} 个连接",s.streams)})).collect();
|
||||
if s.failures>0{crate::tr!("已启用 · {} 个连接 · {} 次失败","On · {} connections · {} failures",s.streams,s.failures)}else{crate::tr!("已启用 · {} 个连接","On · {} connections",s.streams)})).collect();
|
||||
if rows!=last{let r=c(&rows);unsafe{uu_portmap_ui_set_rules(r.as_ptr())};last=rows;}
|
||||
tokio::select!{_=&mut closed_transport=>{toast("连接已断开");tokio::time::sleep(Duration::from_secs(3)).await;break Err("Forwarding transport closed".into())},_=tokio::time::sleep(Duration::from_millis(200))=>{}}
|
||||
tokio::select!{_=&mut closed_transport=>{toast(crate::i18n::s("连接已断开","Disconnected"));tokio::time::sleep(Duration::from_secs(3)).await;break Err("Forwarding transport closed".into())},_=tokio::time::sleep(Duration::from_millis(200))=>{}}
|
||||
};
|
||||
let ids:Vec<u64>=p.status().iter().map(|s|s.id).collect();for id in ids{let _=p.remove_rule(id).await;}
|
||||
result
|
||||
@@ -190,14 +190,14 @@ pub async fn terminal(io:Transport,rx:mpsc::Receiver<Packet>,_device:&str,name:&
|
||||
unsafe{uu_terminal_ui_set(rows.as_ptr(),1)}
|
||||
},
|
||||
id=queue.recv()=>match id{
|
||||
Some(id)=>{if t.kill(id).await.is_err(){toast("结束会话失败,会话可能已退出")}
|
||||
Some(id)=>{if t.kill(id).await.is_err(){toast(crate::i18n::s("结束会话失败,会话可能已退出","Could not end the session; it may have exited"))}
|
||||
let rows=c(&session_rows(&t.list_sessions().await?));unsafe{uu_terminal_ui_set(rows.as_ptr(),1)}},
|
||||
None=>return Ok::<(),String>(()),
|
||||
},
|
||||
_=tokio::time::sleep(Duration::from_millis(100)),if relay.0.is_finished()=>return Err("Terminal channel closed".into()),
|
||||
}}
|
||||
}.await;
|
||||
if operation.is_err(){unsafe{uu_terminal_ui_set(c("").as_ptr(),0)};toast("终端连接已断开,请关闭窗口后重试")}
|
||||
if operation.is_err(){unsafe{uu_terminal_ui_set(c("").as_ptr(),0)};toast(crate::i18n::s("终端连接已断开,请关闭窗口后重试","Terminal disconnected. Close the window and try again"))}
|
||||
});
|
||||
let _worker=super::tools::Cancel(worker.abort_handle());
|
||||
let mut children:Vec<std::process::Child>=Vec::new();
|
||||
@@ -205,7 +205,7 @@ pub async fn terminal(io:Transport,rx:mpsc::Receiver<Packet>,_device:&str,name:&
|
||||
if worker.is_finished(){ipc.0.abort();}
|
||||
children.retain_mut(|child|matches!(child.try_wait(),Ok(None)));
|
||||
while let Some(cmd)=take(){
|
||||
if worker.is_finished(){toast("连接已断开");continue}
|
||||
if worker.is_finished(){toast(crate::i18n::s("连接已断开","Disconnected"));continue}
|
||||
let parts:Vec<_>=cmd.split('\t').collect();
|
||||
let session=match parts.as_slice(){
|
||||
["create"]=>None,
|
||||
@@ -214,8 +214,8 @@ pub async fn terminal(io:Transport,rx:mpsc::Receiver<Packet>,_device:&str,name:&
|
||||
_=>continue,
|
||||
};
|
||||
match local_terminal_command(&exe,&path,session){
|
||||
Some(mut command)=>match command.spawn(){Ok(child)=>children.push(child),Err(_)=>toast("无法启动本机终端程序")},
|
||||
None=>toast("没有找到本机终端程序(可设置 TERMINAL 环境变量)"),
|
||||
Some(mut command)=>match command.spawn(){Ok(child)=>children.push(child),Err(_)=>toast(crate::i18n::s("无法启动本机终端程序","Cannot start a local terminal"))},
|
||||
None=>toast(crate::i18n::s("没有找到本机终端程序(可设置 TERMINAL 环境变量)","No local terminal found (set the TERMINAL environment variable)")),
|
||||
}
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
|
||||
@@ -392,7 +392,10 @@ mod tests {
|
||||
|
||||
fn tempfile_dir() -> PathBuf {
|
||||
use std::os::unix::fs::DirBuilderExt;
|
||||
let dir = std::env::temp_dir().join(format!("uu-type-ipc-test-{}", std::process::id()));
|
||||
// One directory per call: tests run in parallel and must not remove each other's files.
|
||||
static NEXT: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
|
||||
let dir = std::env::temp_dir().join(format!("uu-type-ipc-test-{}-{}", std::process::id(),
|
||||
NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed)));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
std::fs::DirBuilder::new()
|
||||
.mode(0o700)
|
||||
@@ -404,6 +407,8 @@ mod tests {
|
||||
#[tokio::test]
|
||||
async fn server_client_roundtrip_and_uid_gate() {
|
||||
let device = format!("ipc-test-{}", uuidish());
|
||||
// XDG_RUNTIME_DIR is process-wide; another test points it at a planted directory.
|
||||
let _env = crate::viewer::secure_input::ENV_LOCK.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
|
||||
let server = Server::bind(&device).await.unwrap();
|
||||
let path = server.path.clone();
|
||||
let (tx, mut rx) = mpsc::channel::<PendingType>(4);
|
||||
@@ -463,6 +468,8 @@ mod tests {
|
||||
#[tokio::test]
|
||||
async fn oversized_frame_rejected() {
|
||||
let device = format!("oversize-{}", uuidish());
|
||||
// XDG_RUNTIME_DIR is process-wide; another test points it at a planted directory.
|
||||
let _env = crate::viewer::secure_input::ENV_LOCK.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
|
||||
let server = Server::bind(&device).await.unwrap();
|
||||
let path = server.path.clone();
|
||||
let (tx, mut rx) = mpsc::channel::<PendingType>(1);
|
||||
|
||||
+54
-23
@@ -13,6 +13,7 @@ extern "C" {
|
||||
fn uu_viewer_ui_closed() -> c_int;
|
||||
fn uu_viewer_ui_confirm_replace() -> c_int;
|
||||
fn uu_viewer_ui_toast(text: *const c_char);
|
||||
fn uu_viewer_ui_set_host(active: c_int);
|
||||
}
|
||||
fn toast(text: &str) { let t = c(text); unsafe { uu_viewer_ui_toast(t.as_ptr()) } }
|
||||
|
||||
@@ -46,12 +47,12 @@ fn watch_session(mut child: tokio::process::Child, mut cancel: tokio::sync::ones
|
||||
}).await;
|
||||
if !status.is_ok_and(|s| s.success()) {
|
||||
let reason = match last.as_str() {
|
||||
"" => "连接已断开".to_owned(),
|
||||
"CONTROL echo timed out" => "连接超时:被控端没有响应(官方主机互通尚未完成)".to_owned(),
|
||||
"Remote session released" => "被控端结束了本次连接".to_owned(),
|
||||
"" => crate::i18n::s("连接已断开","Disconnected").to_owned(),
|
||||
"CONTROL echo timed out" => crate::i18n::s("连接超时:被控端没有响应(官方主机互通尚未完成)","Timed out: the remote device did not answer (official host interop is not finished)").to_owned(),
|
||||
"Remote session released" => crate::i18n::s("被控端结束了本次连接","The remote device ended the connection").to_owned(),
|
||||
other => other.to_owned(),
|
||||
};
|
||||
toast(&format!("连接失败:{reason}"));
|
||||
toast(&crate::tr!("连接失败:{reason}","Connection failed: {reason}"));
|
||||
} else if let Some(message) = success { toast(message); }
|
||||
})
|
||||
}
|
||||
@@ -81,7 +82,8 @@ pub fn device_rows(devices: &[Value], current: Option<&str>) -> String {
|
||||
let name = d.get("alias").and_then(Value::as_str).unwrap_or(id);
|
||||
let platform = d.get("platform").and_then(Value::as_i64).unwrap_or(0);
|
||||
let online = d.get("status").and_then(Value::as_str) == Some("CONNECTED");
|
||||
Some(format!("{}\t{}\t{}\t{}\t{}\n", clean(id), clean(name), platform, online as u8, (current == Some(id)) as u8))
|
||||
let thumb = super::thumbs::existing(id).map(|p| clean(&p.to_string_lossy())).unwrap_or_default();
|
||||
Some(format!("{}\t{}\t{}\t{}\t{}\t{}\n", clean(id), clean(name), platform, online as u8, (current == Some(id)) as u8, thumb))
|
||||
}).collect()
|
||||
}
|
||||
|
||||
@@ -94,6 +96,10 @@ pub async fn run(credentials: impl Fn() -> Result<crate::auth::Credentials, Stri
|
||||
let mut next_refresh = Instant::now();
|
||||
let mut sessions:std::collections::HashMap<String,Running>=Default::default();
|
||||
let mut names: std::collections::HashMap<String, String> = Default::default();
|
||||
// Account token seen last; a new sign-in restarts a host the user turned on.
|
||||
let mut host_token: Option<String> = None;
|
||||
let mut just_logged_in = false;
|
||||
unsafe { uu_viewer_ui_set_host(super::host::active().into()) }
|
||||
let refresh = |creds: &crate::auth::Credentials| {
|
||||
let api = super::api::Api::new(crate::auth::UUAuthClient::new(creds.clone()), crate::auth::BASE_URL);
|
||||
async move { api.device_list().await }
|
||||
@@ -103,27 +109,40 @@ pub async fn run(credentials: impl Fn() -> Result<crate::auth::Credentials, Stri
|
||||
sessions.retain(|_,s| !s.task.is_finished());
|
||||
if let Some(child) = login.as_mut() {
|
||||
if let Ok(meta) = std::fs::metadata(&qr) {
|
||||
if meta.modified().ok() != qr_seen { qr_seen = meta.modified().ok(); set_login(false, &qr.to_string_lossy(), "请用手机扫码并确认", ""); }
|
||||
if meta.modified().ok() != qr_seen { qr_seen = meta.modified().ok(); set_login(false, &qr.to_string_lossy(), crate::i18n::s("请用手机扫码并确认","Scan with your phone and confirm"), ""); }
|
||||
}
|
||||
if let Ok(Some(_)) = child.try_wait() { login = None; let _ = std::fs::remove_file(&qr); next_refresh = Instant::now(); }
|
||||
if let Ok(Some(_)) = child.try_wait() { login = None; let _ = std::fs::remove_file(&qr); next_refresh = Instant::now(); just_logged_in = true; }
|
||||
} else if Instant::now() >= next_refresh {
|
||||
next_refresh = Instant::now() + Duration::from_secs(30);
|
||||
match credentials() {
|
||||
Ok(creds) => {
|
||||
set_login(true, "", "", "已登录");
|
||||
set_login(true, "", "", crate::i18n::s("已登录","Signed in"));
|
||||
// Hosting is opt-in (Settings switch): signing in never starts the host, but a
|
||||
// host the user turned on goes online with the new account.
|
||||
if host_token.as_deref() != Some(creds.token.as_str()) {
|
||||
let changed = host_token.is_some() || std::mem::take(&mut just_logged_in);
|
||||
if changed && super::host::managed() && super::host::active() {
|
||||
match super::host::restart() {
|
||||
Ok(()) => toast(crate::i18n::s("本机已上线,可在你的其他设备上远程控制","This computer is online; control it from your other devices")),
|
||||
Err(e) => log::warn!("Host service not restarted: {e}"),
|
||||
}
|
||||
unsafe { uu_viewer_ui_set_host(super::host::active().into()) }
|
||||
}
|
||||
host_token = Some(creds.token.clone());
|
||||
}
|
||||
match refresh(&creds).await {
|
||||
Ok(data) => {
|
||||
let list = data.get("my_binded_devices").and_then(Value::as_array).cloned().unwrap_or_default();
|
||||
let current = data.pointer("/current_device/device_id").and_then(Value::as_str);
|
||||
names = list.iter().filter_map(|d| Some((d.get("device_id")?.as_str()?.to_owned(),
|
||||
d.get("alias").and_then(Value::as_str).unwrap_or("远端设备").to_owned()))).collect();
|
||||
d.get("alias").and_then(Value::as_str).unwrap_or_else(|| crate::i18n::s("远端设备","Remote device")).to_owned()))).collect();
|
||||
let rows = c(&device_rows(&list, current)); unsafe { uu_viewer_ui_set_devices(rows.as_ptr()) }
|
||||
}
|
||||
Err(super::api::Error::AuthenticationExpired) => set_login(false, "", "登录已过期,请重新登录", ""),
|
||||
Err(super::api::Error::AuthenticationExpired) => set_login(false, "", crate::i18n::s("登录已过期,请重新登录","Sign-in expired, please sign in again"), ""),
|
||||
Err(_) => {}
|
||||
}
|
||||
}
|
||||
Err(_) => set_login(false, "", "尚未登录", ""),
|
||||
Err(_) => set_login(false, "", crate::i18n::s("尚未登录","Not signed in"), ""),
|
||||
}
|
||||
}
|
||||
while let Some(cmd) = take() {
|
||||
@@ -131,6 +150,18 @@ pub async fn run(credentials: impl Fn() -> Result<crate::auth::Credentials, Stri
|
||||
match parts.as_slice() {
|
||||
["quit"] => break,
|
||||
["refresh"] => next_refresh = Instant::now(),
|
||||
["relaunch"] => {
|
||||
// Language is read once at start: restart the launcher in place. Open
|
||||
// sessions are separate processes and keep running.
|
||||
use std::os::unix::process::CommandExt;
|
||||
let _ = std::process::Command::new(&exe).args(std::env::args_os().skip(1)).exec();
|
||||
toast(crate::i18n::s("请重新启动控制端以切换语言","Restart the viewer to switch the language"));
|
||||
}
|
||||
["host", state] => {
|
||||
let result = if *state == "on" { super::host::enable(&exe) } else { super::host::disable() };
|
||||
if let Err(e) = result { toast(&crate::tr!("本机被控设置失败:{e}","Could not change hosting: {e}")); }
|
||||
unsafe { uu_viewer_ui_set_host(super::host::active().into()) }
|
||||
}
|
||||
["logout"] => {
|
||||
// Sign out locally: drop the account token, keep the device identity.
|
||||
let path = crate::config::path();
|
||||
@@ -140,7 +171,7 @@ pub async fn run(credentials: impl Fn() -> Result<crate::auth::Credentials, Stri
|
||||
}
|
||||
for (_,s) in sessions.drain() { s.stop().await; }
|
||||
unsafe { uu_viewer_ui_set_devices(c("").as_ptr()) }
|
||||
set_login(false, "", "已退出登录", "");
|
||||
set_login(false, "", crate::i18n::s("已退出登录","Signed out"), "");
|
||||
next_refresh = Instant::now() + Duration::from_secs(3600);
|
||||
}
|
||||
["login"] if login.is_none() => {
|
||||
@@ -149,7 +180,7 @@ pub async fn run(credentials: impl Fn() -> Result<crate::auth::Credentials, Stri
|
||||
.env("UU_LOGIN_QR_PNG", &qr).stdin(std::process::Stdio::null())
|
||||
.stdout(std::process::Stdio::null()).stderr(std::process::Stdio::null())
|
||||
.kill_on_drop(true).spawn().ok();
|
||||
if login.is_none() { set_login(false, "", "找不到配套的 uuremote-server", ""); }
|
||||
if login.is_none() { set_login(false, "", crate::i18n::s("找不到配套的 uuremote-server","The matching uuremote-server was not found"), ""); }
|
||||
}
|
||||
["connect", id, kind] if matches!(*kind, "desktop" | "watch") => {
|
||||
if !replace(&mut sessions,id).await{continue}
|
||||
@@ -161,38 +192,38 @@ pub async fn run(credentials: impl Fn() -> Result<crate::auth::Credentials, Stri
|
||||
match command.env("UU_VIEWER_COMMANDS","1").stdin(std::process::Stdio::piped())
|
||||
.stderr(std::process::Stdio::piped()).kill_on_drop(true).spawn() {
|
||||
Ok(mut child) => { let input=child.stdin.take();let (cancel,rx)=tokio::sync::oneshot::channel();let task=watch_session(child,rx,None);sessions.insert((*id).into(),Running{cancel,task,input}); }
|
||||
Err(_) => toast("连接失败:无法启动会话进程"),
|
||||
Err(_) => toast(crate::i18n::s("连接失败:无法启动会话进程","Connection failed: cannot start the session process")),
|
||||
}
|
||||
}
|
||||
["assist", id, code] => {
|
||||
match super::assist::command(&exe, id).spawn() {
|
||||
Ok(mut child) => match super::assist::send_code(&mut child, code).await {
|
||||
Ok(()) => { let (cancel,rx)=tokio::sync::oneshot::channel();let task=watch_session(child,rx,None);sessions.insert(format!("assist:{id}"),Running{cancel,task,input:None}); }
|
||||
Err(reason) => toast(&format!("连接失败:{reason}")),
|
||||
Err(reason) => toast(&crate::tr!("连接失败:{reason}","Connection failed: {reason}")),
|
||||
},
|
||||
Err(_) => toast("连接失败:无法启动协助会话进程"),
|
||||
Err(_) => toast(crate::i18n::s("连接失败:无法启动协助会话进程","Connection failed: cannot start the assistance session")),
|
||||
}
|
||||
}
|
||||
["connect", id, kind @ ("file" | "portmap" | "terminal")] => {
|
||||
if *kind=="file" {if let Some(s)=sessions.get_mut(*id){if let Some(input)=s.input.as_mut(){
|
||||
use tokio::io::AsyncWriteExt;
|
||||
if input.write_all(b"files\n").await.is_err(){toast("桌面会话命令发送失败,请重试")}continue
|
||||
if input.write_all(b"files\n").await.is_err(){toast(crate::i18n::s("桌面会话命令发送失败,请重试","Could not send the command to the desktop session, try again"))}continue
|
||||
}}}
|
||||
if !replace(&mut sessions,id).await{continue}
|
||||
let name = names.get(*id).cloned().unwrap_or_else(|| "远端设备".into());
|
||||
let name = names.get(*id).cloned().unwrap_or_else(|| crate::i18n::s("远端设备","Remote device").into());
|
||||
let tool = if *kind == "file" { "files-ui" } else if *kind == "terminal" { "terminal-ui" } else { "portmap-ui" };
|
||||
match tokio::process::Command::new(&exe).args([tool, id, &name])
|
||||
.stderr(std::process::Stdio::piped()).kill_on_drop(true).spawn() {
|
||||
Ok(child) => { let (cancel,rx)=tokio::sync::oneshot::channel();let task=watch_session(child,rx,None);sessions.insert((*id).into(),Running{cancel,task,input:None}); }
|
||||
Err(_) => toast("连接失败:无法启动工具进程"),
|
||||
Err(_) => toast(crate::i18n::s("连接失败:无法启动工具进程","Connection failed: cannot start the tool process")),
|
||||
}
|
||||
}
|
||||
["connect", id, kind @ ("reboot" | "shutdown")] => {
|
||||
if !replace(&mut sessions,id).await{continue}
|
||||
match tokio::process::Command::new(&exe).args(["power", id, kind])
|
||||
.stdout(std::process::Stdio::null()).stderr(std::process::Stdio::piped()).kill_on_drop(true).spawn() {
|
||||
Ok(child) => { let (cancel,rx)=tokio::sync::oneshot::channel();let task=watch_session(child,rx,Some("电源指令已发送,未确认远端执行结果"));sessions.insert((*id).into(),Running{cancel,task,input:None}); }
|
||||
Err(_) => toast("电源指令失败:无法启动会话进程"),
|
||||
Ok(child) => { let (cancel,rx)=tokio::sync::oneshot::channel();let task=watch_session(child,rx,Some(crate::i18n::s("电源指令已发送,未确认远端执行结果","Power command sent; the result on the remote device is not confirmed")));sessions.insert((*id).into(),Running{cancel,task,input:None}); }
|
||||
Err(_) => toast(crate::i18n::s("电源指令失败:无法启动会话进程","Power command failed: cannot start the session process")),
|
||||
}
|
||||
}
|
||||
["connect", id, "unbind"] => {
|
||||
@@ -201,7 +232,7 @@ pub async fn run(credentials: impl Fn() -> Result<crate::auth::Credentials, Stri
|
||||
Ok(creds)=>super::api::Api::new(crate::auth::UUAuthClient::new(creds),crate::auth::BASE_URL).unbind(id,false).await.map_err(|e|e.to_string()),
|
||||
Err(e)=>Err(e),
|
||||
};
|
||||
match result {Ok(())=>toast("设备已从账号删除"),Err(e)=>toast(&format!("删除设备失败:{e}"))}
|
||||
match result {Ok(())=>toast(crate::i18n::s("设备已从账号删除","Device removed from the account")),Err(e)=>toast(&crate::tr!("删除设备失败:{e}","Removing the device failed: {e}"))}
|
||||
next_refresh=Instant::now();
|
||||
}
|
||||
["connect", _, kind] => log::info!("Viewer UI: {kind} is not supported yet"),
|
||||
@@ -221,6 +252,6 @@ pub async fn run(credentials: impl Fn() -> Result<crate::auth::Credentials, Stri
|
||||
serde_json::json!({"device_id":"d2","platform":1,"status":"DISCONNECTED"}),
|
||||
serde_json::json!({"alias":"no id"}),
|
||||
], Some("d2"));
|
||||
assert_eq!(rows, "d1\ta b\t4\t1\t0\nd2\td2\t1\t0\t1\n");
|
||||
assert_eq!(rows, "d1\ta b\t4\t1\t0\t\nd2\td2\t1\t0\t1\t\n");
|
||||
}
|
||||
}
|
||||
@@ -213,6 +213,19 @@ pub fn request_chroma444()->Vec<u8>{
|
||||
let mut rpc=Vec::new();bytes(1,&header,&mut rpc);bytes(2,&setting,&mut rpc);
|
||||
envelope(2_000_000,21,&rpc)
|
||||
}
|
||||
/// RpcRequest case 2 CaptureSettingRequest with the given (field, value) pairs: 1 fps option
|
||||
/// index, 18 fpsCount, 2 quality, 7 chroma, 10 resolution_type, 16/17 pixel size (src/capture_setting.rs).
|
||||
pub fn capture_setting(seq:u64,fields:&[(u32,u64)])->Vec<u8>{
|
||||
let mut header=Vec::new();int(1,seq,&mut header);
|
||||
let mut setting=Vec::new();for &(f,v) in fields {int(f,v,&mut setting);}
|
||||
let mut rpc=Vec::new();bytes(1,&header,&mut rpc);bytes(2,&setting,&mut rpc);
|
||||
envelope(seq,21,&rpc)
|
||||
}
|
||||
/// Message 3 SimpleAction {1 action, 5 value} as the official 安全 menu sends it.
|
||||
pub fn simple_action(seq:u64,action:u64,value:Option<u64>)->Vec<u8>{
|
||||
let mut body=Vec::new();int(1,action,&mut body);if let Some(v)=value {int(5,v,&mut body);}
|
||||
envelope(seq,3,&body)
|
||||
}
|
||||
/// Message 18 is an encoder capability LIST, not the chosen codec; RTP's negotiated PT is authoritative.
|
||||
/// Message 25 reports actual encoded chroma, which may fall back to 4:2:0.
|
||||
pub fn media_control(data:&[u8])->(Option<u32>,Option<u32>){
|
||||
|
||||
+16
-10
@@ -2,6 +2,7 @@
|
||||
#![allow(dead_code)]
|
||||
#[path = "auth.rs"] mod auth;
|
||||
#[path = "config.rs"] mod config;
|
||||
#[path = "i18n.rs"] mod i18n;
|
||||
#[path = "protocol.rs"] mod protocol;
|
||||
mod ws_transport;
|
||||
mod viewer;
|
||||
@@ -57,8 +58,8 @@ async fn run(args:&[String])->Result<(),String> {
|
||||
Ok(())
|
||||
}
|
||||
Some("unbind") if (args.len()==2 || (args.len()==3 && args[2]=="--shared")) && !args[1].is_empty() => {
|
||||
api()?.unbind(&args[1],args.len()==3).await.map_err(|e|format!("删除设备失败:{e}"))?;
|
||||
println!("已从账号删除设备");Ok(())
|
||||
api()?.unbind(&args[1],args.len()==3).await.map_err(|e|crate::tr!("删除设备失败:{e}","Removing the device failed: {e}"))?;
|
||||
println!("{}",crate::i18n::s("已从账号删除设备","Device removed from the account"));Ok(())
|
||||
}
|
||||
Some("power")=>power_command(args).await,
|
||||
Some("type")=>type_command(args).await,
|
||||
@@ -69,7 +70,7 @@ async fn run(args:&[String])->Result<(),String> {
|
||||
Some("terminal"|"files"|"portmap"|"files-ui"|"portmap-ui"|"terminal-ui")=>tool_command(args).await,
|
||||
Some("assist") if args.len()==2=> {
|
||||
let code=viewer::assist::read_code(std::io::stdin().lock())?;
|
||||
desktop_command(&["connect".into(),args[1].clone(),"false".into(),"-".into(),"echo".into(),"legacy".into()],Some(code)).await.map_err(|e|format!("协助连接失败:{e}"))
|
||||
desktop_command(&["connect".into(),args[1].clone(),"false".into(),"-".into(),"echo".into(),"legacy".into()],Some(code)).await.map_err(|e|crate::tr!("协助连接失败:{e}","Assistance connection failed: {e}"))
|
||||
}
|
||||
Some("connect") if args.len()==6 || args.len()==7=> desktop_command(args,None).await,
|
||||
_=>Err(HELP.into()),
|
||||
@@ -96,11 +97,16 @@ async fn desktop_command(args:&[String],code:Option<String>)->Result<(),String>
|
||||
let creds=credentials()?;
|
||||
let api=Api::new(auth::UUAuthClient::new(creds.clone()),auth::BASE_URL);
|
||||
let account_connection=code.is_none();
|
||||
let room=match code {
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
macro_rules! wait {($stage:expr,$fut:expr)=>{viewer::sdl::loading(desktop.as_mut().map(|d|&mut d.0),$stage,$fut).await?}}
|
||||
#[cfg(not(feature="viewer-sdl"))]
|
||||
macro_rules! wait {($stage:expr,$fut:expr)=>{{let _=$stage;$fut.await}}}
|
||||
let contacting=i18n::s("正在连接远端设备…","Contacting the remote device…");
|
||||
let room=wait!(contacting,async{match code {
|
||||
Some(code)=>api.join_share(&args[1],&code).await,
|
||||
None=>api.join(&args[1],force,true).await,
|
||||
}.map_err(|e|e.to_string())?;
|
||||
let target_mac=if shape.capture_type==1 {api.target_is_mac(&room,account_connection.then_some(args[1].as_str())).await} else {Err(viewer::api::Error::UnknownKeyboardPlatform)};
|
||||
}}).map_err(|e|e.to_string())?;
|
||||
let target_mac=if shape.capture_type==1 {wait!(contacting,api.target_is_mac(&room,account_connection.then_some(args[1].as_str())))} else {Err(viewer::api::Error::UnknownKeyboardPlatform)};
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
if let Some((window,_))=desktop.as_mut().filter(|_|!view_only){
|
||||
window.set_mac(*target_mac.as_ref().map_err(|e|e.to_string())?);
|
||||
@@ -111,7 +117,7 @@ async fn desktop_command(args:&[String],code:Option<String>)->Result<(),String>
|
||||
let mut clipboard=clipboard::Bridge::new(shape.capture_type==1);
|
||||
clipboard.set_target_mac(target_mac.ok());
|
||||
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?;
|
||||
let mut session=wait!(i18n::s("正在建立安全连接…","Establishing a secure connection…"),Session::open(&room,&shape,&creds.device_id,&creds.client_id,options,Default::default()))?;
|
||||
#[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,&args[1]).await}else{session.run().await};
|
||||
#[cfg(not(feature="viewer-sdl"))]
|
||||
@@ -169,7 +175,7 @@ async fn type_command(args:&[String])->Result<(),String>{
|
||||
if !response.ok {
|
||||
return Err(response.error.unwrap_or_else(||"Secure input failed on running viewer".into()));
|
||||
}
|
||||
println!("安全输入已发送({} 个按键事件,{} 字符)。", response.events, response.chars);
|
||||
println!("{}",crate::tr!("安全输入已发送({} 个按键事件,{} 字符)。","Secure input sent ({} key events, {} characters).", response.events, response.chars));
|
||||
if let Some(path)=response.snapshot {
|
||||
println!("snapshot={path}");
|
||||
log::info!("Secure input snapshot: {path}");
|
||||
@@ -196,7 +202,7 @@ async fn type_command(args:&[String])->Result<(),String>{
|
||||
let mut session=Session::open(&room,&shape,&creds.device_id,&creds.client_id,options,Default::default()).await?;
|
||||
let result=viewer::secure_input::run_session(&mut session,actions.as_slice(),delay).await;
|
||||
session.close().await;
|
||||
if result.is_ok(){println!("安全输入已发送({event_count} 个按键事件);新会话路径无截图。");}
|
||||
if result.is_ok(){println!("{}",crate::tr!("安全输入已发送({event_count} 个按键事件);新会话路径无截图。","Secure input sent ({event_count} key events); no snapshot on the new-session path."));}
|
||||
result
|
||||
}
|
||||
|
||||
@@ -295,6 +301,6 @@ async fn power_command(args:&[String])->Result<(),String>{
|
||||
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;
|
||||
if result.is_ok(){println!("电源指令已发送;未确认远端执行结果。");}
|
||||
if result.is_ok(){println!("{}",crate::i18n::s("电源指令已发送;未确认远端执行结果。","Power command sent; the result on the remote device is not confirmed."));}
|
||||
result
|
||||
}
|
||||
Reference in new issue
Block a user