Files
QFT/desktop/src/main.rs
T
zhy200308 13624d9747 fix(pairing): Direct AP 网关地址被挤出二维码,修复我上一版引入的回退
上一版号称把 AP 网关置顶,实测二维码里依然没有 192.168.137.1,
而手机连上 AP 后网关正是它。两个独立原因叠在一起:

1. 判断条件读了还没赋值的字段
   start_receiver 里 direct_ap 是局部变量,要到函数末尾才写回
   self.receive.direct_ap;而生成二维码那行读的正是 self.receive.direct_ap,
   此刻永远是 None,于是 direct_ap_active 恒为 false,置顶逻辑从未触发。
   改为直接用局部变量。发送端同一处问题一并修正。

2. 虚拟网卡把名额占满了
   实测机器上有 192.168.30.1、192.168.31.1、172.21.96.1 三个
   VMware / Hyper-V / WSL 的地址。它们是真实网卡、排序里与普通局域网
   同级,正好填满二维码仅有的 4 个名额,把 AP 网关顶了出去。手机
   永远到不了这些地址,却要为它们付出探测时间。
   新增 is_likely_virtual():按各家虚拟化产品的默认网段 + 以 .1 结尾
   (宿主机在虚拟网络里通常是网关)判断,只降权不丢弃——万一某台机器
   真用这些网段做局域网,仍能兜底。

新增三项用例:实测遇到的三个虚拟地址必须被识别;192.168.0.1 /
192.168.1.1 / 192.168.8.1 / 10.0.0.1 这些家用网关不得误伤;
只有 .1 结尾才参与判断,普通主机地址一律不降权。

cargo test 49/49。
2026-08-12 08:59:07 +08:00

2050 lines
89 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
mod base45;
mod client;
mod connect_code;
mod direct_ap;
mod discovery;
mod firewall;
mod optical_cache;
mod pairing;
mod platform;
mod protocol;
mod qr;
mod receiver;
mod sender;
use eframe::egui::{self, FontData, FontDefinitions, FontFamily, TextureHandle, TextureOptions};
use optical_cache::OpticalPrefetcher;
use pairing::{PairingDirection, PairingPayload, WifiCredentials};
use protocol::{hex_sha256, TransferSource};
use receiver::{ReceiverEvent, ReceiverServer};
use sender::{SenderEvent, SenderServer};
use std::{
path::{Path, PathBuf},
sync::{mpsc, Arc},
time::{Duration, Instant},
};
// A lower-density symbol gains more from reliable 25~30 FPS recognition than
// a nominally larger page that is only decoded 10~18 times per second.
const DEFAULT_CHUNK_SIZE: u16 = 320;
const UI_FONT_NAME: &str = "qft-ui";
const APP_VERSION: &str = "0.4.8";
fn main() -> eframe::Result {
let options = eframe::NativeOptions {
viewport: egui::ViewportBuilder::default()
.with_title("QFT · 超速二维码文件传输")
.with_inner_size([1040.0, 800.0])
.with_min_inner_size([800.0, 640.0]),
..Default::default()
};
eframe::run_native(
"QFT",
options,
Box::new(|cc| Ok(Box::new(QftApp::new(cc)))),
)
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum Screen {
Home,
OpticalSend,
PhoneToPc,
PcToPhone,
PcToPc,
}
struct OpticalState {
source: Option<Arc<TransferSource>>,
prefetch: Option<OpticalPrefetcher>,
texture: Option<TextureHandle>,
page_index: u32,
round: u64,
playing: bool,
fps: f32,
cache_mib: usize,
control_width: f32,
qr_zoom: f32,
focus_qr: bool,
advanced_open: bool,
last_advance: Instant,
fps_window_started: Instant,
displayed_in_window: u32,
actual_page_fps: f64,
status: String,
}
struct ReceiveState {
/// 专注模式:收起除二维码外的所有控件,把窗口全部让给码
focus_qr: bool,
qr_zoom: f32,
save_dir: Option<PathBuf>,
use_direct_ap: bool,
server: Option<ReceiverServer>,
direct_ap: Option<direct_ap::DirectAp>,
events: Option<mpsc::Receiver<ReceiverEvent>>,
pair_texture: Option<TextureHandle>,
session_token: String,
status: String,
connected_device: String,
current_file: String,
received: u64,
total: u64,
last_saved: String,
last_sha256: String,
transfer_started: Option<Instant>,
rate_bps: f64,
}
struct SendState {
file: Option<PathBuf>,
file_size: u64,
sha256: Option<String>,
use_direct_ap: bool,
server: Option<SenderServer>,
direct_ap: Option<direct_ap::DirectAp>,
events: Option<mpsc::Receiver<SenderEvent>>,
pair_texture: Option<TextureHandle>,
session_token: String,
status: String,
connected_device: String,
qr_focus: bool,
qr_controls_height: f32,
qr_zoom: f32,
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum PcMode {
Receive,
Send,
}
/// PC↔PC 传输的后台事件。传输跑在工作线程上,UI 只消费事件。
enum PcEvent {
Peers(Vec<discovery::Peer>),
Paired { base_url: String, token: String },
Progress { file: String, done: u64, total: u64 },
FileDone { file: String, sha256: String },
AllDone,
Failed(String),
}
struct PcPeerState {
mode: PcMode,
// 接收侧
save_dir: Option<PathBuf>,
server: Option<ReceiverServer>,
// 发送侧
peers: Vec<discovery::Peer>,
code_input: String,
token: Option<String>,
connected_base: Option<String>,
files: Vec<PathBuf>,
// 后台事件
events: Option<mpsc::Receiver<PcEvent>>,
busy: bool,
/// 仅在真正开始推送文件后为真。此前用 busy 兼作此用,
/// 导致配对阶段就显示「正在发送 0%」,误导用户以为传输已经开始。
transferring: bool,
current_file: String,
done: u64,
total: u64,
started: Option<Instant>,
status: String,
firewall: firewall::FirewallStatus,
firewall_note: String,
}
struct QftApp {
screen: Screen,
font_status: String,
local_device: String,
optical: OpticalState,
receive: ReceiveState,
send: SendState,
pc: PcPeerState,
}
impl QftApp {
fn new(cc: &eframe::CreationContext<'_>) -> Self {
// 不要写死 pixels_per_point。此前固定为 1.0,在 Retina/HiDPI 上会让
// 整个界面缩成实际尺寸的一半;缩放由 eframe 从系统取。
// 二维码需要的像素级精确由 snap_to_physical 在绘制时保证。
install_visuals(&cc.egui_ctx);
let font_status = match install_ttf_font(&cc.egui_ctx) {
Ok(path) => format!("字体:{}", path.display()),
Err(message) => format!("字体加载失败:{message}"),
};
Self {
screen: Screen::Home,
font_status,
local_device: protocol::local_device_name(),
optical: OpticalState {
source: None,
prefetch: None,
texture: None,
page_index: 0,
round: 0,
playing: false,
fps: 30.0,
cache_mib: 256,
control_width: 330.0,
qr_zoom: 1.0,
focus_qr: false,
advanced_open: false,
last_advance: Instant::now(),
fps_window_started: Instant::now(),
displayed_in_window: 0,
actual_page_fps: 0.0,
status: "选择文件后开始光学发送。v0.4 使用单个大二维码 + QFT2/Base45 低密度 450B 数据块,优先提高 Android 有效识别率。".into(),
},
receive: ReceiveState {
focus_qr: false,
qr_zoom: 1.0,
save_dir: None,
use_direct_ap: true,
server: None,
direct_ap: None,
events: None,
pair_texture: None,
session_token: String::new(),
status: "先选择接收文件夹,然后启动接收。".into(),
connected_device: "等待 Android 扫码".into(),
current_file: "—".into(),
received: 0,
total: 0,
last_saved: "—".into(),
last_sha256: String::new(),
transfer_started: None,
rate_bps: 0.0,
},
send: SendState {
file: None,
file_size: 0,
sha256: None,
use_direct_ap: true,
server: None,
direct_ap: None,
events: None,
pair_texture: None,
session_token: String::new(),
status: "选择文件后生成二维码;手机扫码会自动配网并开始下载。".into(),
connected_device: "等待 Android 扫码".into(),
qr_focus: false,
qr_controls_height: 220.0,
qr_zoom: 1.0,
},
pc: PcPeerState {
mode: PcMode::Receive,
save_dir: Some(platform::default_download_dir()),
server: None,
peers: Vec::new(),
code_input: String::new(),
token: None,
connected_base: None,
files: Vec::new(),
events: None,
busy: false,
transferring: false,
current_file: String::new(),
done: 0,
total: 0,
started: None,
status: "接收方启动后会显示连接码;发送方输入该码即可传输。".into(),
firewall: firewall::FirewallStatus::Unknown("尚未检测".into()),
firewall_note: String::new(),
},
}
}
fn header(&mut self, ui: &mut egui::Ui) {
ui.horizontal(|ui| {
ui.heading("QFT");
ui.label(format!("v{APP_VERSION}"));
ui.separator();
ui.label("扫码配对 · 本地直传 · 光学零网络");
let space = (ui.available_width() - 150.0).max(0.0);
ui.add_space(space);
if self.screen != Screen::Home && ui.button("← 返回首页").clicked() {
match self.screen {
Screen::PhoneToPc => self.stop_receiver(),
Screen::PcToPhone => self.stop_sender(),
Screen::OpticalSend => { self.optical.playing = false; self.optical.prefetch = None; },
Screen::PcToPc => self.stop_pc(),
Screen::Home => {}
}
self.screen = Screen::Home;
}
});
ui.separator();
}
fn home_ui(&mut self, ui: &mut egui::Ui) {
ui.add_space(22.0);
ui.vertical_centered(|ui| {
ui.heading("选择传输方向");
ui.label("两个方向采用不同链路,让速度、兼容性和“无需外网”同时成立。")
});
ui.add_space(24.0);
ui.columns(2, |cols| {
cols[0].group(|ui| {
ui.set_min_height(300.0);
ui.vertical_centered(|ui| {
ui.add_space(22.0);
ui.heading("电脑 → Android");
ui.label("光学传输");
ui.add_space(12.0);
ui.label("文件只经过:电脑屏幕 → 手机摄像头");
ui.label("不使用 Wi-Fi / 蓝牙 / 局域网 / 外网");
ui.add_space(24.0);
if ui.add_sized([220.0, 46.0], egui::Button::new("选择文件并开始光传")).clicked() {
self.screen = Screen::OpticalSend;
}
});
});
cols[1].group(|ui| {
ui.set_min_height(300.0);
ui.vertical_centered(|ui| {
ui.add_space(22.0);
ui.heading("Android → 电脑");
ui.label("扫码直连");
ui.add_space(12.0);
ui.label("电脑创建临时 QFT Wi-Fi Direct AP");
ui.label("Android 扫码配网后高速上传到指定文件夹");
ui.add_space(24.0);
if ui.add_sized([220.0, 46.0], egui::Button::new("电脑接收手机文件")).clicked() {
self.screen = Screen::PhoneToPc;
}
});
});
});
ui.add_space(18.0);
ui.group(|ui| {
ui.horizontal_wrapped(|ui| {
ui.heading("电脑 → Android · 扫码自动直传");
ui.separator();
ui.label("选择文件 · 生成 QFTSEND2 · 手机扫码后自动配网并下载到 Downloads/QFT");
if ui.add_sized([220.0, 42.0], egui::Button::new("直传文件到手机")).clicked() {
self.screen = Screen::PcToPhone;
}
});
});
ui.add_space(18.0);
ui.group(|ui| {
ui.horizontal_wrapped(|ui| {
ui.heading("电脑 ↔ 电脑");
ui.separator();
ui.label("输入对方的连接码即可 · 无需二维码");
if ui.add_sized([220.0, 42.0], egui::Button::new("电脑之间互传")).clicked() {
self.screen = Screen::PcToPc;
}
});
});
ui.add_space(18.0);
ui.group(|ui| {
ui.label(format!("本机设备:{}", self.local_device));
ui.small(&self.font_status);
});
}
fn optical_ui(&mut self, ui: &mut egui::Ui, ctx: &egui::Context) {
if self.optical.playing && self.optical.source.is_some() {
let interval = Duration::from_secs_f32(1.0 / self.optical.fps.max(1.0));
if self.optical.last_advance.elapsed() >= interval {
self.optical.last_advance = Instant::now();
self.optical_advance(ctx);
}
ctx.request_repaint_after((interval / 3).max(Duration::from_millis(1)));
}
ui.horizontal_wrapped(|ui| {
ui.heading("电脑 → Android · 单码锁定极速模式");
ui.separator();
ui.label("屏幕 → 摄像头 · 0 网络");
ui.separator();
if ui.button(if self.optical.focus_qr { "退出专注二维码" } else { "专注二维码" }).clicked() {
self.optical.focus_qr = !self.optical.focus_qr;
}
});
ui.add_space(8.0);
if self.optical.focus_qr {
ui.horizontal_wrapped(|ui| {
let enabled = self.optical.source.is_some();
if ui.add_enabled(enabled, egui::Button::new(if self.optical.playing { "暂停" } else { "播放" })).clicked() {
if !self.optical.playing && self.optical.prefetch.is_none() { self.restart_optical_pipeline(); }
self.optical.playing = !self.optical.playing;
self.optical.last_advance = Instant::now();
self.optical.fps_window_started = Instant::now();
self.optical.displayed_in_window = 0;
}
ui.label(format!("{:.0} FPS", self.optical.fps));
ui.add(egui::Slider::new(&mut self.optical.qr_zoom, 0.65..=1.0).text("二维码占比").show_value(false));
ui.small("控制区已收起,尽可能把屏幕面积留给二维码");
});
ui.separator();
self.optical_qr_panel(ui);
return;
}
let available = ui.available_size();
let min_qr_width = 360.0_f32.min(available.x * 0.55);
let max_control = (available.x - min_qr_width - 12.0).max(240.0);
self.optical.control_width = self.optical.control_width.clamp(240.0, max_control);
let split_height = ui.available_height().max(420.0);
ui.horizontal(|ui| {
ui.allocate_ui_with_layout(
egui::vec2(self.optical.control_width, split_height),
egui::Layout::top_down(egui::Align::Min),
|ui| {
egui::ScrollArea::vertical().show(ui, |ui| {
self.optical_controls(ui, ctx);
});
},
);
let (bar_rect, bar_response) = ui.allocate_exact_size(
egui::vec2(8.0, split_height),
egui::Sense::drag(),
);
let bar_color = if bar_response.dragged() || bar_response.hovered() {
ui.visuals().widgets.active.bg_fill
} else {
ui.visuals().widgets.inactive.bg_fill
};
ui.painter().rect_filled(bar_rect.shrink2(egui::vec2(2.0, 0.0)), 3.0, bar_color);
if bar_response.dragged() {
let dx = ui.input(|i| i.pointer.delta().x);
self.optical.control_width = (self.optical.control_width + dx).clamp(240.0, max_control);
ctx.request_repaint();
}
bar_response.on_hover_text("拖动压缩/展开控制区,右侧二维码会自动放大");
ui.allocate_ui_with_layout(
egui::vec2(ui.available_width(), split_height),
egui::Layout::top_down(egui::Align::Center),
|ui| self.optical_qr_panel(ui),
);
});
}
fn optical_controls(&mut self, ui: &mut egui::Ui, ctx: &egui::Context) {
ui.group(|ui| {
ui.heading("发送控制");
ui.horizontal_wrapped(|ui| {
if ui.button("选择文件").clicked() { self.optical_pick_file(ctx); }
let enabled = self.optical.source.is_some();
if ui.add_enabled(enabled, egui::Button::new(if self.optical.playing { "暂停" } else { "开始播放" })).clicked() {
if !self.optical.playing && self.optical.prefetch.is_none() { self.restart_optical_pipeline(); }
self.optical.playing = !self.optical.playing;
self.optical.last_advance = Instant::now();
self.optical.fps_window_started = Instant::now();
self.optical.displayed_in_window = 0;
}
if ui.add_enabled(enabled, egui::Button::new("回到第1帧")).clicked() {
self.optical.playing = false;
self.restart_optical_pipeline();
let _ = self.optical_render_first(ctx);
}
});
ui.add_space(6.0);
ui.label("显示刷新率");
ui.add(egui::Slider::new(&mut self.optical.fps, 5.0..=60.0).suffix(" FPS").step_by(1.0));
ui.horizontal_wrapped(|ui| {
if ui.small_button("稳定 30").clicked() { self.optical.fps = 30.0; }
if ui.small_button("平衡 45").clicked() { self.optical.fps = 45.0; }
if ui.small_button("最高 60").clicked() { self.optical.fps = 60.0; }
});
ui.small("Android 会先全屏搜索一次,然后锁定单个二维码区域进行局部高频解码;60 FPS 是显示目标,实际有效识别率由手机相机决定。");
});
ui.add_space(8.0);
ui.group(|ui| {
ui.heading("二维码可读性");
ui.label(format!("单码 · 每块 {} B · QFT2/Base45 · QR-L · 完整静区", DEFAULT_CHUNK_SIZE));
ui.add(egui::Slider::new(&mut self.optical.qr_zoom, 0.65..=1.0).text("画面占比"));
ui.small("v0.4 已彻底删除 4 码模式;QFT2 使用 Base45 让 QR 进入字母数字模式,比旧 Base64 文本更低密度。默认 450 B 数据块仍保持较低 QR 版本,让 Android 更容易稳定锁定。");
});
ui.add_space(8.0);
ui.checkbox(&mut self.optical.advanced_open, "高级设置");
if self.optical.advanced_open {
ui.group(|ui| {
let old_cache = self.optical.cache_mib;
ui.label("预编码缓存");
ui.add(egui::Slider::new(&mut self.optical.cache_mib, 64..=optical_cache::MAX_MANAGED_CACHE_MIB)
.suffix(" MiB").step_by(64.0));
ui.small(format!(
"托管缓存最多 {} MiB;整进程设计预算约 {} MiB。缓存只影响二维码预编码是否跟得上,不会把整个文件读进内存。",
optical_cache::MAX_MANAGED_CACHE_MIB, optical_cache::HARD_PROCESS_BUDGET_MIB
));
if old_cache != self.optical.cache_mib {
self.optical.playing = false;
self.restart_optical_pipeline();
let _ = self.optical_render_first(ctx);
}
});
}
ui.add_space(8.0);
if let Some(source) = self.optical.source.as_ref() {
let m = &source.manifest;
let pages = source.total_playlist_frames().max(1);
let payload_rate = self.optical.fps as f64 * m.chunk_size as f64;
ui.group(|ui| {
ui.small("实时状态");
ui.heading(format!("{:.1} 页/s", self.optical.actual_page_fps));
ui.label(format!("理论载荷 ≈ {}/s", human_bytes(payload_rate as u64)));
let cap = self.optical.prefetch.as_ref().map(|p| p.capacity_pages).unwrap_or(0);
let page_mib = self.optical.prefetch.as_ref().map(|p| p.estimated_page_mib).unwrap_or(0.0);
ui.small(format!("预编码缓存:{} MiB · 最多 {cap} 帧 · {page_mib:.1} MiB/帧", self.optical.cache_mib));
ui.separator();
ui.label(format!("设备:{} → Android", m.sender_device));
ui.label(format!("文件:{} · {}", m.file_name, human_bytes(m.file_size)));
ui.label(format!("帧:{}/{} · 完整轮次:{}", self.optical.page_index + 1, pages, self.optical.round));
ui.small(format!("SHA-256:{}", hex_sha256(&m.sha256)));
});
}
ui.add_space(6.0);
ui.label(&self.optical.status);
}
fn optical_qr_panel(&mut self, ui: &mut egui::Ui) {
if let Some(texture) = &self.optical.texture {
let avail = ui.available_size();
let reserved = if self.optical.focus_qr { 4.0 } else { 28.0 };
let base = avail.x.min((avail.y - reserved).max(220.0)).max(220.0);
let side = (base * self.optical.qr_zoom).clamp(220.0, base);
ui.vertical_centered(|ui| {
let side = snap_to_physical(side, ui.ctx().pixels_per_point());
ui.image((texture.id(), egui::vec2(side, side)));
if !self.optical.focus_qr {
ui.small("拖动左侧分隔条可继续放大二维码;也可点击顶部“专注二维码”占满可用区域。");
}
});
} else {
ui.vertical_centered(|ui| {
ui.add_space(120.0);
ui.heading("请选择一个文件");
ui.label("单个大二维码会在这里显示,Android 识别后自动锁定区域。");
});
}
}
fn receive_ui(&mut self, ui: &mut egui::Ui, ctx: &egui::Context) {
self.poll_receiver_events();
ctx.request_repaint_after(Duration::from_millis(100));
let has_qr = self.receive.pair_texture.is_some();
ui.horizontal_wrapped(|ui| {
ui.heading("Android → 电脑 · 扫码直连");
ui.separator();
ui.label("UDP 快速发现 · 64 KiB–16 MiB 自适应分块 · 目标 8 路并行 · 不经过外网");
if ui.add_enabled(has_qr, egui::Button::new("专注二维码")).clicked() {
self.receive.focus_qr = true;
}
});
ui.add_space(10.0);
// 专注模式下把整个窗口让给二维码。小窗口里控件会把码挤到显示不全,
// 而扫码时那些控件本来也用不上。
if self.receive.focus_qr && has_qr {
let texture = self.receive.pair_texture.clone();
let mut zoom = self.receive.qr_zoom;
let mut focus = self.receive.focus_qr;
qr_focus_view(ui, texture.as_ref(), &mut zoom, &mut focus, "手机扫码 · QFTPAIR2");
self.receive.qr_zoom = zoom;
self.receive.focus_qr = focus;
return;
}
let running = self.receive.server.is_some();
ui.group(|ui| {
ui.heading("1 · 保存位置");
ui.horizontal_wrapped(|ui| {
if ui.add_enabled(!running, egui::Button::new("选择接收文件夹")).clicked() {
if let Some(dir) = pick_folder_safely() {
self.receive.save_dir = Some(dir);
self.receive.status = "保存位置已选择,可以启动接收。".into();
}
}
ui.label(self.receive.save_dir.as_ref().map(|p| p.display().to_string()).unwrap_or_else(|| "尚未选择".into()));
});
});
ui.add_space(8.0);
ui.group(|ui| {
ui.heading("2 · 连接方式");
ui.add_enabled_ui(!running, |ui| {
ui.radio_value(&mut self.receive.use_direct_ap, true, "QFT Direct(推荐)· Windows 自动创建临时 Wi-Fi Direct AP");
ui.radio_value(&mut self.receive.use_direct_ap, false, "当前局域网(备用)· 手机和电脑已经在同一 Wi-Fi/LAN");
});
if self.receive.use_direct_ap {
ui.small("Android 10+ 使用 WifiNetworkSpecifier;Android 7~9 使用兼容配网。连接后先 UDP 广播发现,再并行探测网关/IP,避免“已连 Wi-Fi 找不到电脑”。");
if !running && ui.small_button("重置 QFT Direct 网络身份").clicked() {
match pairing::reset_direct_ap_credentials() {
Ok(()) => self.receive.status = "QFT Direct 网络身份已重置;下次启动接收会生成新的 SSID/密码,Android 需要重新批准一次。".into(),
Err(e) => self.receive.status = format!("重置 QFT Direct 网络身份失败:{e:#}"),
}
}
} else {
ui.small("二维码不携带 Wi-Fi 密码;Android 会先 UDP 快速发现电脑,再并行探测二维码内的本地 IP。");
}
if running { ui.small("接收运行中,停止接收后才能修改保存目录或连接方式。"); }
});
ui.add_space(8.0);
ui.group(|ui| {
ui.heading("3 · 启动并扫码");
ui.horizontal(|ui| {
if ui.add_enabled(!running && self.receive.save_dir.is_some(), egui::Button::new("启动接收并生成二维码")).clicked() {
self.start_receiver(ctx);
}
if ui.add_enabled(running, egui::Button::new("停止接收")).clicked() {
self.stop_receiver();
}
});
ui.label(&self.receive.status);
});
if self.receive.server.is_some() {
ui.add_space(10.0);
ui.columns(2, |cols| {
cols[0].group(|ui| {
ui.heading("手机扫码 · QFTPAIR2");
// Direct AP 的虚拟网卡最容易被防火墙拦住,把检测结果放在
// 二维码旁边——用户在这里停留最久,也正是在这一步失败的。
let listen_port = self.receive.server.as_ref().map(|s| s.port).unwrap_or(receiver::PREFERRED_PORT);
self.firewall_panel(ui, listen_port);
ui.add_space(8.0);
if let Some(texture) = &self.receive.pair_texture {
let qr_zoom = self.receive.qr_zoom;
ui.vertical_centered(|ui| {
let side = fit_qr_side(ui, qr_zoom, 12.0);
ui.image((texture.id(), egui::vec2(side, side)));
});
}
// 把二维码实际广播的地址摊开显示。手机报"找不到电脑"时,
// 第一件要确认的就是码里到底有没有它能到达的那个地址——
// 在这里一眼可见,不必等手机端的诊断。
ui.collapsing("二维码广播的地址", |ui| {
for endpoint in pairing::qr_endpoints(listen_port, self.receive.direct_ap.is_some()).iter().take(4) {
ui.monospace(endpoint);
}
ui.small("手机连上后会依次尝试这些地址;其中必须有一个与手机同网段。");
});
if let Some(ap) = &self.receive.direct_ap {
ui.label(format!("临时网络:{}", ap.ssid));
ui.small("网络身份会在这台电脑上复用以减少重复确认;每次接收仍会生成新的会话 Token。");
}
if !self.receive.session_token.is_empty() {
let short = &self.receive.session_token[..10.min(self.receive.session_token.len())];
ui.small(format!("临时会话:{short}… · 停止接收后立即失效"));
}
});
cols[1].group(|ui| {
ui.heading("接收状态 · Parallel v2");
ui.label(format!("电脑:{}", self.local_device));
ui.label(format!("手机:{}", self.receive.connected_device));
ui.separator();
ui.label(format!("当前文件:{}", self.receive.current_file));
let fraction = if self.receive.total == 0 { 0.0 } else { self.receive.received as f32 / self.receive.total as f32 };
ui.add(egui::ProgressBar::new(fraction.clamp(0.0, 1.0)).show_percentage());
ui.label(format!("已接收:{} / {}", human_bytes(self.receive.received), human_bytes(self.receive.total)));
if self.receive.rate_bps > 1.0 {
let eta = if self.receive.total > self.receive.received {
(self.receive.total - self.receive.received) as f64 / self.receive.rate_bps
} else { 0.0 };
ui.label(format!("速度:{}/s · 预计剩余:{}", human_bytes(self.receive.rate_bps as u64), human_duration(eta)));
}
ui.separator();
ui.label(format!("最近保存:{}", self.receive.last_saved));
if !self.receive.last_sha256.is_empty() { ui.small(format!("SHA-256:{}", self.receive.last_sha256)); }
});
});
}
}
fn pc_to_phone_ui(&mut self, ui: &mut egui::Ui, ctx: &egui::Context) {
self.poll_sender_events();
ctx.request_repaint_after(Duration::from_millis(100));
let running = self.send.server.is_some();
ui.horizontal_wrapped(|ui| {
ui.heading("电脑 → Android · 扫码自动直传");
ui.separator();
ui.label("QFTSEND2 · 自动连接本地 Wi-Fi · 扫码后立即下载");
if ui.add_enabled(
running,
egui::Button::new(if self.send.qr_focus { "退出专注二维码" } else { "专注二维码" }),
).clicked() {
self.send.qr_focus = !self.send.qr_focus;
}
});
ui.add_space(10.0);
if running {
if self.send.qr_focus {
self.pc_to_phone_qr_focus_ui(ui, ctx);
} else {
self.pc_to_phone_resizable_qr_ui(ui, ctx);
}
return;
}
ui.group(|ui| {
ui.heading("1 · 选择发送文件");
ui.horizontal_wrapped(|ui| {
if ui.add_enabled(!running, egui::Button::new("选择文件")).clicked() {
if let Some(path) = pick_file_safely() {
match TransferSource::open(&path, DEFAULT_CHUNK_SIZE) {
Ok(source) => {
self.send.file_size = source.manifest.file_size;
self.send.sha256 = Some(hex_sha256(&source.manifest.sha256));
self.send.file = Some(path);
self.send.status = "文件已就绪;生成二维码后,手机扫码会自动开始下载。".into();
}
Err(e) => self.send.status = format!("读取文件失败:{e:#}"),
}
}
}
if let Some(path) = &self.send.file {
ui.label(format!("{} · {}", path.display(), human_bytes(self.send.file_size)));
} else {
ui.label("尚未选择文件");
}
});
if let Some(sha) = &self.send.sha256 { ui.small(format!("SHA-256:{sha}")); }
});
ui.add_space(8.0);
ui.group(|ui| {
ui.heading("2 · 连接方式");
ui.add_enabled_ui(!running, |ui| {
ui.radio_value(&mut self.send.use_direct_ap, true, "QFT Direct(推荐)· Windows 自动创建临时 Wi-Fi");
ui.radio_value(&mut self.send.use_direct_ap, false, "当前局域网(备用)· 手机和电脑已在同一 Wi-Fi/LAN");
});
ui.small("手机扫描二维码后会自动请求连接;已经批准过同一台电脑的 QFT Direct 网络时,系统通常无需再次确认。");
});
ui.add_space(8.0);
ui.group(|ui| {
ui.heading("3 · 生成二维码并自动发送");
ui.horizontal_wrapped(|ui| {
if ui.add_enabled(!running && self.send.file.is_some(), egui::Button::new("启动直传并生成二维码")).clicked() {
self.start_sender(ctx);
}
if ui.add_enabled(running, egui::Button::new("停止直传")).clicked() { self.stop_sender(); }
});
ui.label(&self.send.status);
});
if self.send.server.is_some() {
ui.add_space(10.0);
ui.columns(2, |cols| {
cols[0].group(|ui| {
ui.heading("手机扫码 · QFTSEND2");
if let Some(texture) = &self.send.pair_texture {
let qr_zoom = self.send.qr_zoom;
ui.vertical_centered(|ui| {
let side = fit_qr_side(ui, qr_zoom, 12.0);
ui.image((texture.id(), egui::vec2(side, side)));
});
}
if let Some(ap) = &self.send.direct_ap {
ui.label(format!("临时网络:{}", ap.ssid));
}
});
cols[1].group(|ui| {
ui.heading("发送状态");
ui.label(format!("电脑:{}", self.local_device));
ui.label(format!("手机:{}", self.send.connected_device));
ui.label(self.send.file.as_ref().map(|v| format!("文件:{}", v.display())).unwrap_or_default());
ui.small("二维码只在本次直传会话有效;停止直传后立即失效。");
});
});
}
}
fn pc_to_phone_resizable_qr_ui(&mut self, ui: &mut egui::Ui, ctx: &egui::Context) {
const DIVIDER_HEIGHT: f32 = 10.0;
let available_height = ui.available_height();
let min_controls_height = 150.0;
let min_qr_height = 260.0_f32.min((available_height * 0.55).max(180.0));
let max_controls_height = (available_height - min_qr_height - DIVIDER_HEIGHT)
.max(min_controls_height);
self.send.qr_controls_height = self
.send
.qr_controls_height
.clamp(min_controls_height, max_controls_height);
ui.allocate_ui_with_layout(
egui::vec2(ui.available_width(), self.send.qr_controls_height),
egui::Layout::top_down(egui::Align::Min),
|ui| {
egui::ScrollArea::vertical().show(ui, |ui| {
self.pc_to_phone_running_controls(ui);
});
},
);
let (divider_rect, divider_response) = ui.allocate_exact_size(
egui::vec2(ui.available_width(), DIVIDER_HEIGHT),
egui::Sense::drag(),
);
let divider_response = divider_response.on_hover_cursor(egui::CursorIcon::ResizeVertical);
let divider_color = if divider_response.dragged() || divider_response.hovered() {
ui.visuals().widgets.active.bg_fill
} else {
ui.visuals().widgets.inactive.bg_fill
};
ui.painter().rect_filled(
divider_rect.shrink2(egui::vec2(0.0, 3.0)),
3.0,
divider_color,
);
if divider_response.dragged() {
let delta_y = ui.input(|input| input.pointer.delta().y);
self.send.qr_controls_height = (self.send.qr_controls_height + delta_y)
.clamp(min_controls_height, max_controls_height);
ctx.request_repaint();
}
divider_response.on_hover_text("上下拖动,调整控制区和二维码区域的高度");
self.pc_to_phone_qr_panel(ui, false);
}
fn pc_to_phone_running_controls(&mut self, ui: &mut egui::Ui) {
ui.group(|ui| {
ui.heading("直传控制");
ui.horizontal_wrapped(|ui| {
if ui.button("停止直传").clicked() {
self.stop_sender();
}
ui.add(egui::Slider::new(&mut self.send.qr_zoom, 0.65..=1.0)
.text("二维码占比"));
});
if let Some(file) = &self.send.file {
ui.label(format!("文件:{} · {}", file.display(), human_bytes(self.send.file_size)));
}
ui.label(&self.send.status);
ui.small("拖动下方分隔条可为二维码腾出更多高度;也可切换到“专注二维码”。");
});
ui.add_space(6.0);
ui.group(|ui| {
ui.label(format!("电脑:{}", self.local_device));
ui.label(format!("手机:{}", self.send.connected_device));
if let Some(ap) = &self.send.direct_ap {
ui.label(format!("临时网络:{}", ap.ssid));
}
});
}
fn pc_to_phone_qr_focus_ui(&mut self, ui: &mut egui::Ui, ctx: &egui::Context) {
if ctx.input(|input| input.key_pressed(egui::Key::Escape)) {
self.send.qr_focus = false;
self.receive.focus_qr = false;
return;
}
ui.horizontal_wrapped(|ui| {
if ui.button("退出专注二维码").clicked() {
self.send.qr_focus = false;
}
if ui.button("停止直传").clicked() {
self.stop_sender();
}
ui.add(egui::Slider::new(&mut self.send.qr_zoom, 0.65..=1.0)
.text("二维码占比"));
ui.small("按 Esc 也可退出专注模式");
});
ui.add_space(6.0);
self.pc_to_phone_qr_panel(ui, true);
}
fn pc_to_phone_qr_panel(&mut self, ui: &mut egui::Ui, focus: bool) {
let panel_height = ui.available_height();
if focus {
ui.group(|ui| {
ui.heading("手机扫码 · QFTSEND2");
ui.small("专注模式:二维码会始终按当前可用区域完整显示。");
if let Some(texture) = &self.send.pair_texture {
let available = ui.available_size();
let max_side = available.x.min((available.y - 32.0).max(1.0));
let side = (max_side * self.send.qr_zoom).max(1.0).min(max_side);
let side = snap_to_physical(side, ui.ctx().pixels_per_point());
ui.vertical_centered(|ui| {
ui.add_space(((available.y - side).max(0.0)) * 0.5);
ui.image((texture.id(), egui::vec2(side, side)));
});
}
ui.set_min_height(panel_height);
});
return;
}
ui.columns(2, |cols| {
cols[0].group(|ui| {
ui.heading("手机扫码 · QFTSEND2");
if let Some(texture) = &self.send.pair_texture {
let available = ui.available_size();
let max_side = available.x.min((available.y - 42.0).max(1.0));
let side = (max_side * self.send.qr_zoom).max(1.0).min(max_side);
let side = snap_to_physical(side, ui.ctx().pixels_per_point());
ui.vertical_centered(|ui| {
ui.image((texture.id(), egui::vec2(side, side)));
});
}
ui.set_min_height(panel_height);
});
cols[1].group(|ui| {
ui.heading("发送状态");
ui.label(format!("电脑:{}", self.local_device));
ui.label(format!("手机:{}", self.send.connected_device));
ui.label(self.send.file.as_ref().map(|file| format!("文件:{}", file.display())).unwrap_or_default());
ui.small("二维码只在本次直传会话有效;停止直传后立即失效。");
ui.set_min_height(panel_height);
});
});
}
fn optical_pick_file(&mut self, ctx: &egui::Context) {
let Some(path) = pick_file_safely() else { return };
match TransferSource::open(&path, DEFAULT_CHUNK_SIZE) {
Ok(source) => {
self.optical.source = Some(Arc::new(source));
self.optical.playing = false;
self.optical.actual_page_fps = 0.0;
self.restart_optical_pipeline();
if let Err(e) = self.optical_render_first(ctx) {
self.optical.status = format!("生成二维码失败:{e:#}");
} else {
self.optical.status = "文件已载入。默认单个大二维码 · QFT2/Base45 450B 数据块 · 45 FPS;可按手机能力切到 30 或 60 FPS。".into();
}
}
Err(e) => self.optical.status = format!("读取文件失败:{e:#}"),
}
}
fn optical_canvas_side(&self) -> usize {
1024
}
fn restart_optical_pipeline(&mut self) {
self.optical.prefetch = None;
self.optical.page_index = 0;
self.optical.round = 0;
let Some(source) = self.optical.source.clone() else { return };
self.optical.prefetch = Some(OpticalPrefetcher::start(
source,
self.optical_canvas_side(),
self.optical.cache_mib,
));
}
fn optical_render_first(&mut self, ctx: &egui::Context) -> anyhow::Result<()> {
let Some(source) = self.optical.source.as_ref() else { return Ok(()) };
let text = source.text_frame(0)?;
let image = qr::render_qr_fitted(&text, self.optical_canvas_side())?;
self.set_optical_texture(ctx, image);
self.optical.page_index = 0;
self.optical.round = 0;
Ok(())
}
fn set_optical_texture(&mut self, ctx: &egui::Context, image: egui::ColorImage) {
if let Some(texture) = self.optical.texture.as_mut() {
// Reuse one GPU texture instead of allocating/freeing a texture ID
// for every 60 Hz optical page. This materially reduces GPU/driver
// churn and keeps the presentation path deterministic.
texture.set(image, TextureOptions::NEAREST);
} else {
self.optical.texture = Some(ctx.load_texture(
"qft-optical-frame", image, TextureOptions::NEAREST,
));
}
}
fn optical_advance(&mut self, ctx: &egui::Context) {
let next = match self.optical.prefetch.as_ref() {
Some(prefetch) => prefetch.try_next(),
None => {
self.restart_optical_pipeline();
return;
}
};
match next {
Ok(page) => {
self.set_optical_texture(ctx, page.image);
self.optical.page_index = page.page_index;
self.optical.round = page.round;
self.optical.displayed_in_window = self.optical.displayed_in_window.saturating_add(1);
let elapsed = self.optical.fps_window_started.elapsed();
if elapsed >= Duration::from_secs(1) {
self.optical.actual_page_fps = self.optical.displayed_in_window as f64 / elapsed.as_secs_f64().max(0.001);
self.optical.displayed_in_window = 0;
self.optical.fps_window_started = Instant::now();
}
self.optical.status = if self.optical.actual_page_fps + 3.0 < self.optical.fps as f64 && self.optical.actual_page_fps > 1.0 {
"实际页面速率低于目标:可降低 FPS 或把缓存调高;文件数据仍会循环补帧。".into()
} else {
"正在光学发送 · 单个大二维码,Android 锁定后仅在二维码 ROI 内高频解码。".into()
};
}
Err(std::sync::mpsc::TryRecvError::Empty) => {
self.optical.status = "预编码缓存正在补充,暂缓换页以避免显示空帧。".into();
}
Err(std::sync::mpsc::TryRecvError::Disconnected) => {
self.optical.playing = false;
self.optical.status = "光学预编码线程已停止,请重新选择文件。".into();
}
}
}
fn start_receiver(&mut self, ctx: &egui::Context) {
// Direct AP 会新建一块虚拟网卡,其网络类型往往与主网卡不同,
// 因此每次启动接收都重新检测一次,而不是沿用上次结果。
self.refresh_firewall();
let Some(save_dir) = self.receive.save_dir.clone() else { return };
self.stop_receiver();
self.receive.status = "正在初始化接收服务…".into();
let token = pairing::new_session_token();
let (tx, rx) = mpsc::channel();
let server = match ReceiverServer::start(save_dir, token.clone(), tx) {
Ok(v) => v,
Err(e) => { self.receive.status = format!("接收服务启动失败:{e:#}"); return; }
};
let mut direct_ap = None;
let wifi = if self.receive.use_direct_ap {
let (ssid, passphrase) = match pairing::load_or_create_direct_ap_credentials(&self.local_device) {
Ok(v) => v,
Err(e) => {
drop(server);
self.receive.status = format!("读取 QFT Direct 配网身份失败:{e:#}");
return;
}
};
match direct_ap::DirectAp::start(ssid.clone(), passphrase.clone()) {
Ok(ap) => {
direct_ap = Some(ap);
Some(WifiCredentials { ssid, passphrase, security: "WPA2".into() })
}
Err(e) => {
drop(server);
self.receive.status = format!("QFT Direct 启动失败:{e:#}\n可切换到“当前局域网”备用模式。 ");
return;
}
}
} else { None };
// Give the virtual adapter a moment to appear before enumerating addresses.
if direct_ap.is_some() { std::thread::sleep(Duration::from_millis(250)); }
let payload = PairingPayload {
v: 2,
session: token.clone(),
pc_name: self.local_device.clone(),
transport: "http-parallel-v2".into(),
port: server.port,
endpoints: pairing::qr_endpoints(server.port, direct_ap.is_some()),
wifi,
direction: PairingDirection::Upload,
file_name: None,
file_size: None,
sha256: None,
};
let pair_text = match payload.encode_text() {
Ok(v) => v,
Err(e) => { self.receive.status = format!("配对信息生成失败:{e:#}"); return; }
};
let image = match qr::render_pair_qr(&pair_text, 520) {
Ok(v) => v,
Err(e) => { self.receive.status = format!("配对二维码生成失败:{e:#}"); return; }
};
let receiver_port = server.port;
self.receive.server = Some(server);
self.receive.direct_ap = direct_ap;
self.receive.events = Some(rx);
self.receive.pair_texture = Some(ctx.load_texture("qft-pair-code", image, TextureOptions::NEAREST));
self.receive.session_token = token;
self.receive.connected_device = "等待 Android 扫码".into();
self.receive.current_file = "—".into();
self.receive.received = 0;
self.receive.total = 0;
self.receive.last_saved = "—".into();
self.receive.last_sha256.clear();
self.receive.transfer_started = None;
self.receive.rate_bps = 0.0;
self.receive.status = if self.receive.use_direct_ap {
format!("接收已就绪 · TCP {} · UDP 发现 {}。Android 扫码后会自动配网并快速发现电脑。", receiver_port, receiver::DISCOVERY_PORT)
} else {
format!("接收已就绪 · TCP {} · UDP 发现 {}。Android 扫码后会自动发现同一局域网电脑。", receiver_port, receiver::DISCOVERY_PORT)
};
}
fn start_sender(&mut self, ctx: &egui::Context) {
let Some(file) = self.send.file.clone() else { return };
let Some(sha256) = self.send.sha256.clone() else { return };
let file_name = file.file_name().and_then(|v| v.to_str()).unwrap_or("qft-download.bin").to_owned();
self.stop_sender();
self.send.status = "正在初始化电脑发送服务…".into();
let token = pairing::new_session_token();
let (tx, rx) = mpsc::channel();
let server = match SenderServer::start(file, token.clone(), tx) {
Ok(v) => v,
Err(e) => { self.send.status = format!("发送服务启动失败:{e:#}"); return; }
};
let mut direct_ap = None;
let wifi = if self.send.use_direct_ap {
let (ssid, passphrase) = match pairing::load_or_create_direct_ap_credentials(&self.local_device) {
Ok(v) => v,
Err(e) => {
drop(server);
self.send.status = format!("读取 QFT Direct 配网身份失败:{e:#}");
return;
}
};
match direct_ap::DirectAp::start(ssid.clone(), passphrase.clone()) {
Ok(ap) => {
direct_ap = Some(ap);
Some(WifiCredentials { ssid, passphrase, security: "WPA2".into() })
}
Err(e) => {
drop(server);
self.send.status = format!("QFT Direct 启动失败:{e:#}\n可切换到“当前局域网”备用模式。");
return;
}
}
} else { None };
if direct_ap.is_some() { std::thread::sleep(Duration::from_millis(250)); }
let payload = PairingPayload {
v: 2,
session: token.clone(),
pc_name: self.local_device.clone(),
transport: "http-download-v2".into(),
port: server.port,
endpoints: pairing::qr_endpoints(server.port, direct_ap.is_some()),
wifi,
direction: PairingDirection::Download,
file_name: Some(file_name),
file_size: Some(self.send.file_size),
sha256: Some(sha256),
};
let pair_text = match payload.encode_text() {
Ok(v) => v,
Err(e) => { self.send.status = format!("发送二维码信息生成失败:{e:#}"); return; }
};
let image = match qr::render_pair_qr(&pair_text, 520) {
Ok(v) => v,
Err(e) => { self.send.status = format!("发送二维码生成失败:{e:#}"); return; }
};
let port = server.port;
self.send.server = Some(server);
self.send.direct_ap = direct_ap;
self.send.events = Some(rx);
self.send.pair_texture = Some(ctx.load_texture("qft-send-code", image, TextureOptions::NEAREST));
self.send.session_token = token;
self.send.connected_device = "等待 Android 扫码".into();
self.send.status = if self.send.use_direct_ap {
format!("直传已就绪 · TCP {port} · 手机扫码后会自动配网并开始下载。")
} else {
format!("直传已就绪 · TCP {port} · 请让手机扫码并使用当前局域网。")
};
}
fn stop_sender(&mut self) {
self.send.events = None;
self.send.server = None;
self.send.direct_ap = None;
self.send.pair_texture = None;
self.send.session_token.clear();
self.send.qr_focus = false;
self.send.connected_device = "等待 Android 扫码".into();
self.send.status = "直传已停止。".into();
}
fn poll_sender_events(&mut self) {
let mut pending = Vec::new();
if let Some(rx) = &self.send.events {
while let Ok(event) = rx.try_recv() { pending.push(event); }
}
for event in pending {
match event {
SenderEvent::ClientConnected { device } => {
self.send.connected_device = device;
self.send.status = "Android 已确认本次二维码会话,正在准备下载。".into();
}
SenderEvent::DownloadStarted { device, file_name, size } => {
self.send.connected_device = device;
self.send.status = format!("正在发送 {file_name} · {}", human_bytes(size));
}
SenderEvent::DownloadCompleted { device, file_name } => {
self.send.connected_device = device;
self.send.status = format!("发送完成:{file_name} 已由手机保存到 Downloads/QFT。");
}
SenderEvent::Error(message) => self.send.status = message,
}
}
}
// ==================== PC ↔ PC ====================
fn stop_pc(&mut self) {
self.pc.server = None;
self.receive.events = None;
self.pc.events = None;
self.pc.busy = false;
self.pc.transferring = false;
self.pc.token = None;
self.pc.connected_base = None;
}
fn pc_to_pc_ui(&mut self, ui: &mut egui::Ui, ctx: &egui::Context) {
self.drain_pc_events();
ctx.request_repaint_after(Duration::from_millis(150));
ui.horizontal_wrapped(|ui| {
ui.heading("电脑 ↔ 电脑");
ui.separator();
ui.label("同一局域网或可路由到达 · 无需二维码 · 一串连接码");
ui.separator();
ui.selectable_value(&mut self.pc.mode, PcMode::Receive, "我要接收");
ui.selectable_value(&mut self.pc.mode, PcMode::Send, "我要发送");
});
ui.add_space(10.0);
ui.label(egui::RichText::new(&self.pc.status).weak());
// 失败原因常常是多行的排查建议,需要完整展示而不是被截断
ui.add_space(10.0);
match self.pc.mode {
PcMode::Receive => self.pc_receive_ui(ui),
PcMode::Send => self.pc_send_ui(ui),
}
}
fn pc_receive_ui(&mut self, ui: &mut egui::Ui) {
ui.group(|ui| {
ui.heading("接收设置");
ui.horizontal_wrapped(|ui| {
if ui.button("选择保存文件夹").clicked() {
match pick_folder_safely() {
Some(dir) => self.pc.save_dir = Some(dir),
None => self.pc.status =
"系统文件夹对话框没有返回结果。当前仍使用上方显示的目录。".into(),
}
}
match self.pc.save_dir.as_ref() {
Some(dir) => ui.label(dir.display().to_string()),
None => ui.label("尚未选择"),
};
});
ui.add_space(8.0);
ui.horizontal_wrapped(|ui| {
let running = self.pc.server.is_some();
if ui.add_enabled(!running && self.pc.save_dir.is_some(),
egui::Button::new("启动接收")).clicked() {
self.start_pc_receiver();
}
if ui.add_enabled(running, egui::Button::new("停止接收")).clicked() {
self.stop_pc();
self.pc.status = "接收已停止。".into();
}
});
});
let Some(server) = self.pc.server.as_ref() else { return };
let port = server.port;
let secret = server.secret;
// 每个网卡各生成一个连接码:对方在哪个网段,就用哪一个。
// 地址已经编在码里,所以对方不需要再单独输入 IP。
let codes: Vec<(std::net::IpAddr, String)> = pairing::local_ipv4_addresses()
.into_iter()
.map(|address| {
let code = connect_code::ConnectCode::new(std::net::IpAddr::V4(address), port, secret);
(std::net::IpAddr::V4(address), code.encode())
})
.collect();
{
ui.add_space(10.0);
ui.group(|ui| {
let blocked = self.pc.firewall.needs_action();
let color = if blocked {
egui::Color32::from_rgb(220, 140, 60)
} else {
egui::Color32::from_rgb(80, 200, 120)
};
ui.horizontal_wrapped(|ui| {
ui.colored_label(color, if blocked { "⚠ 系统防火墙可能拦截入站连接" } else { "● 防火墙" });
if !self.pc.firewall_note.is_empty() {
ui.label(&self.pc.firewall_note);
}
});
ui.horizontal_wrapped(|ui| {
// 无论检测结果如何都保留入口:检测可能不准,
// 而用户遇到「对方连不上」时需要有地方可点。
if ui.button("放行防火墙(需要管理员授权)").clicked() {
self.request_firewall_grant();
}
if ui.small_button("复制手动放行命令").clicked() {
ui.ctx().copy_text(firewall::manual_instructions(port));
}
if ui.small_button("重新检测").clicked() {
self.refresh_firewall();
}
});
if !blocked {
ui.small("检测认为入站不会被拦。若对方仍连不上,可手动放行试试。");
}
});
}
ui.add_space(14.0);
ui.group(|ui| {
ui.heading("把连接码告诉发送方");
ui.small("码里已经包含地址,对方只需输入这一串,不用再报 IP 和端口。");
ui.add_space(8.0);
if codes.is_empty() {
ui.colored_label(egui::Color32::from_rgb(220, 120, 60), "没有可用的局域网地址,请检查网络连接。");
}
for (index, (address, code)) in codes.iter().enumerate() {
ui.horizontal(|ui| {
if index == 0 {
ui.heading(egui::RichText::new(code).monospace().strong());
} else {
ui.monospace(egui::RichText::new(code).strong());
}
if ui.small_button("复制").clicked() {
ui.ctx().copy_text(code.clone());
}
ui.weak(format!("({address})"));
});
}
ui.add_space(6.0);
ui.small("输错 5 次该码即作废,需要重新启动接收。");
if codes.len() > 1 {
ui.small("本机有多个网卡:对方在哪个网段就用对应的那一串。");
}
});
ui.add_space(14.0);
ui.group(|ui| {
ui.heading("接收进度");
ui.label(format!("来自:{}", self.receive.connected_device));
ui.label(format!("当前文件:{}", self.receive.current_file));
if self.receive.total > 0 {
let fraction = self.receive.received as f32 / self.receive.total as f32;
ui.add(egui::ProgressBar::new(fraction).show_percentage());
ui.label(format!("{} / {}",
human_bytes(self.receive.received), human_bytes(self.receive.total)));
}
if self.receive.last_saved != "—" {
ui.label(format!("已保存:{}", self.receive.last_saved));
}
});
}
fn pc_send_ui(&mut self, ui: &mut egui::Ui) {
ui.group(|ui| {
ui.heading("1 · 输入对方的连接码");
ui.horizontal_wrapped(|ui| {
let response = ui.add(
egui::TextEdit::singleline(&mut self.pc.code_input)
.hint_text("K7M2-9X4P-QR3T")
.desired_width(240.0)
.font(egui::TextStyle::Monospace),
);
let submitted = response.lost_focus()
&& ui.input(|i| i.key_pressed(egui::Key::Enter));
let parsed = connect_code::ConnectCode::decode(&self.pc.code_input);
let can_connect = !self.pc.busy && parsed.is_ok();
if ui.add_enabled(can_connect, egui::Button::new("连接")).clicked()
|| (submitted && can_connect)
{
self.pair_pc_peer();
}
if self.pc.busy {
ui.spinner();
ui.weak("正在建立连接…最多等 4 秒");
} else if self.pc.token.is_some() {
ui.colored_label(egui::Color32::from_rgb(80, 200, 120), "● 已连接");
}
});
// 边打边校验:CRC 能在连接之前就发现输错,不用等超时
if !self.pc.code_input.trim().is_empty() {
match connect_code::ConnectCode::decode(&self.pc.code_input) {
Ok(code) => ui.weak(format!("将连接 {}", code.base_url())),
Err(e) => ui.colored_label(egui::Color32::from_rgb(220, 120, 60), e.to_string()),
};
}
ui.add_space(4.0);
ui.small("连接码里已包含对方地址,不需要在同一网段——只要网络能路由到对方即可。");
});
ui.add_space(12.0);
ui.collapsing("搜索同网段的设备(可选)", |ui| {
ui.small("同一网段时可以免输码。跨网段、或 Wi-Fi 开了客户端隔离时搜不到,请改用连接码。");
if ui.add_enabled(!self.pc.busy, egui::Button::new("搜索")).clicked() {
self.browse_pc_peers();
}
for peer in &self.pc.peers {
if ui.button(format!("{} · {} · {}", peer.name, peer.platform, peer.base_url())).clicked() {
// 直接把对端地址填进码输入框还不够——秘密只有对方屏幕上有,
// 所以这里只做地址提示,仍需用户补齐连接码
self.pc.status = format!("请输入 {} 屏幕上显示的连接码", peer.name);
}
}
if self.pc.peers.is_empty() {
ui.weak("尚未搜索到设备。");
}
});
// 拖进窗口的文件直接进待发列表。拖拽不依赖系统文件对话框,
// 因此在 NSOpenPanel 失效时仍然可用。
let dropped = dropped_paths(ui.ctx());
if !dropped.is_empty() {
for path in dropped {
if path.is_file() && !self.pc.files.contains(&path) {
self.pc.files.push(path);
}
}
self.pc.status = format!("已加入 {} 个文件。", self.pc.files.len());
}
ui.add_space(12.0);
ui.group(|ui| {
ui.heading("2 · 选择文件并发送");
if is_hovering_files(ui.ctx()) {
ui.colored_label(egui::Color32::from_rgb(80, 200, 120), "松手即可加入待发送列表");
} else {
ui.small("可以直接把文件拖进这个窗口。");
}
ui.horizontal_wrapped(|ui| {
if ui.button("选择文件").clicked() {
match pick_files_safely() {
Some(files) => self.pc.files = files,
None => self.pc.status =
"系统文件对话框没有返回结果。可以直接把文件拖进窗口。".into(),
}
}
if ui.add_enabled(!self.pc.files.is_empty(), egui::Button::new("清空")).clicked() {
self.pc.files.clear();
}
let ready = !self.pc.busy && self.pc.token.is_some() && !self.pc.files.is_empty();
if ui.add_enabled(ready, egui::Button::new("开始发送")).clicked() {
self.send_pc_files();
}
});
for file in &self.pc.files {
let size = std::fs::metadata(file).map(|m| m.len()).unwrap_or(0);
ui.label(format!("• {} {}", file.display(), human_bytes(size)));
}
if self.pc.transferring || self.pc.total > 0 {
ui.add_space(8.0);
ui.label(format!("正在发送:{}", self.pc.current_file));
let fraction = if self.pc.total == 0 { 0.0 }
else { self.pc.done as f32 / self.pc.total as f32 };
ui.add(egui::ProgressBar::new(fraction).show_percentage());
let elapsed = self.pc.started.map(|t| t.elapsed().as_secs_f64()).unwrap_or(0.0).max(0.001);
ui.label(format!("{} / {} · {}/s",
human_bytes(self.pc.done), human_bytes(self.pc.total),
human_bytes((self.pc.done as f64 / elapsed) as u64)));
}
});
}
/// 防火墙状态面板。手机接收(Direct AP)与电脑互传都要用,
/// 因此抽出来共用——此前只有电脑互传页有,而 Direct AP 恰恰是
/// 最容易被防火墙拦住的路径:ICS 虚拟网卡有自己独立的网络类型,
/// 只覆盖专用/域网络的规则在它上面完全不生效。
fn firewall_panel(&mut self, ui: &mut egui::Ui, port: u16) {
let blocked = self.pc.firewall.needs_action();
ui.group(|ui| {
ui.horizontal_wrapped(|ui| {
if blocked {
ui.colored_label(
egui::Color32::from_rgb(220, 140, 60),
"⚠ 防火墙规则未覆盖当前网络类型,手机可能连不上",
);
} else {
ui.colored_label(egui::Color32::from_rgb(80, 200, 120), "● 防火墙");
}
if !self.pc.firewall_note.is_empty() {
ui.label(&self.pc.firewall_note);
}
});
if blocked {
ui.small(
"Direct AP 会新建一块虚拟网卡,Windows 常把它归类为「公用网络」。\
只覆盖专用/域网络的规则在这块网卡上不生效,表现就是手机连上了 Wi-Fi 却找不到电脑。",
);
}
ui.horizontal_wrapped(|ui| {
if ui.button("放行防火墙(需要管理员授权)").clicked() {
self.request_firewall_grant();
}
if ui.small_button("复制手动放行命令").clicked() {
ui.ctx().copy_text(firewall::manual_instructions(port));
}
if ui.small_button("重新检测").clicked() {
self.refresh_firewall();
}
});
});
}
/// 只做**只读检测**,不申请任何权限。
///
/// 早先版本会在启动接收时自动弹 UAC。实际用下来这太侵入:
/// 多数人只是想收个文件,却先被要求管理员授权。
/// 现在提权一律由用户点按钮触发(`request_firewall_grant`)。
fn refresh_firewall(&mut self) {
self.pc.firewall = firewall::status();
if !self.pc.firewall.needs_action() {
self.pc.firewall_note.clear();
}
}
/// 用户显式点击后才提权。
fn request_firewall_grant(&mut self) {
match firewall::grant() {
Ok(()) => {
self.pc.firewall = firewall::status();
self.pc.firewall_note = "已放行系统防火墙。".into();
}
Err(e) => self.pc.firewall_note = format!("{e}"),
}
}
fn start_pc_receiver(&mut self) {
let Some(dir) = self.pc.save_dir.clone() else { return };
self.stop_pc();
self.refresh_firewall();
let token = pairing::new_session_token();
let (tx, rx) = mpsc::channel();
match ReceiverServer::start(dir, token, tx) {
Ok(server) => {
self.pc.status = "接收中。把下面的连接码告诉发送方即可。".into();
self.pc.server = Some(server);
self.receive.events = Some(rx);
self.receive.connected_device = "等待对方连接".into();
self.receive.current_file = "—".into();
self.receive.received = 0;
self.receive.total = 0;
}
Err(e) => self.pc.status = format!("启动接收失败:{e:#}"),
}
}
fn browse_pc_peers(&mut self) {
let (tx, rx) = mpsc::channel();
self.pc.events = Some(rx);
self.pc.busy = true;
self.pc.status = "正在搜索附近的电脑…".into();
std::thread::spawn(move || {
let result = discovery::browse(receiver::DISCOVERY_PORT, Duration::from_millis(1200));
let _ = match result {
Ok(peers) => tx.send(PcEvent::Peers(peers)),
Err(e) => tx.send(PcEvent::Failed(format!("搜索失败:{e:#}"))),
};
});
}
fn pair_pc_peer(&mut self) {
let Ok(code) = connect_code::ConnectCode::decode(&self.pc.code_input) else { return };
let base_url = code.base_url();
let secret = code.secret_hex();
let device = self.local_device.clone();
let (tx, rx) = mpsc::channel();
self.pc.events = Some(rx);
self.pc.busy = true;
self.pc.status = format!("正在连接 {base_url}…");
std::thread::spawn(move || {
let _ = match client::PeerClient::pair(&base_url, &secret, &device) {
Ok(token) => tx.send(PcEvent::Paired { base_url, token }),
Err(e) => tx.send(PcEvent::Failed(format!("{e:#}"))),
};
});
}
fn send_pc_files(&mut self) {
let (Some(base_url), Some(token)) =
(self.pc.connected_base.clone(), self.pc.token.clone()) else { return };
let files = self.pc.files.clone();
let device = self.local_device.clone();
let total: u64 = files.iter()
.map(|f| std::fs::metadata(f).map(|m| m.len()).unwrap_or(0))
.sum();
let (tx, rx) = mpsc::channel();
self.pc.events = Some(rx);
self.pc.busy = true;
self.pc.transferring = true;
self.pc.done = 0;
self.pc.total = total;
self.pc.started = Some(Instant::now());
self.pc.status = format!("正在发送 {} 个文件…", files.len());
std::thread::spawn(move || {
let peer = client::PeerClient::new(base_url, token, device);
// 逐个文件累加,跨文件的进度用 base 偏移拼起来
let mut base = 0u64;
for path in files {
let name = path.file_name().and_then(|v| v.to_str()).unwrap_or("文件").to_string();
let size = std::fs::metadata(&path).map(|m| m.len()).unwrap_or(0);
let progress_tx = tx.clone();
let progress_name = name.clone();
let result = peer.upload_file(&path, |p| {
let _ = progress_tx.send(PcEvent::Progress {
file: progress_name.clone(),
done: base + p.done,
total,
});
});
match result {
Ok(sha256) => {
base += size;
let _ = tx.send(PcEvent::Progress { file: name.clone(), done: base, total });
let _ = tx.send(PcEvent::FileDone { file: name, sha256 });
}
Err(e) => {
let _ = tx.send(PcEvent::Failed(format!("{name} 发送失败:{e:#}")));
return;
}
}
}
let _ = tx.send(PcEvent::AllDone);
});
}
fn drain_pc_events(&mut self) {
// 接收侧完全复用既有的 ReceiverEvent 渲染逻辑,不另写一套
self.poll_receiver_events();
let Some(rx) = self.pc.events.take() else { return };
while let Ok(event) = rx.try_recv() {
match event {
PcEvent::Peers(peers) => {
self.pc.status = if peers.is_empty() {
"没有搜索到设备。确认对方已启动接收,或改用手动输入地址。".into()
} else {
format!("搜索到 {} 台设备。", peers.len())
};
self.pc.peers = peers;
self.pc.busy = false;
}
PcEvent::Paired { base_url, token } => {
self.pc.status = format!("已连接 {base_url},可以选择文件了。");
self.pc.connected_base = Some(base_url);
self.pc.token = Some(token);
self.pc.busy = false;
}
PcEvent::Progress { file, done, total } => {
self.pc.current_file = file;
self.pc.done = done;
self.pc.total = total;
}
PcEvent::FileDone { file, sha256 } => {
self.pc.status = format!("{file} 已送达 · SHA-256 {}", &sha256[..16.min(sha256.len())]);
}
PcEvent::AllDone => {
self.pc.busy = false;
self.pc.transferring = false;
self.pc.current_file.clear();
self.pc.status = "全部发送完成。".into();
}
PcEvent::Failed(message) => {
self.pc.busy = false;
self.pc.transferring = false;
self.pc.status = message;
}
}
}
self.pc.events = Some(rx);
}
fn stop_receiver(&mut self) {
self.receive.events = None;
self.receive.server = None;
self.receive.direct_ap = None;
self.receive.pair_texture = None;
self.receive.session_token.clear();
self.receive.connected_device = "等待 Android 扫码".into();
self.receive.current_file = "—".into();
self.receive.received = 0;
self.receive.total = 0;
self.receive.transfer_started = None;
self.receive.rate_bps = 0.0;
self.receive.status = "接收已停止。".into();
}
fn poll_receiver_events(&mut self) {
let mut pending = Vec::new();
if let Some(rx) = &self.receive.events {
while let Ok(event) = rx.try_recv() { pending.push(event); }
}
for event in pending {
match event {
ReceiverEvent::ClientConnected { device } => {
self.receive.connected_device = device;
self.receive.status = "Android 已连接到电脑。可以开始发送文件。".into();
}
ReceiverEvent::UploadStarted { device, file_name, size } => {
self.receive.connected_device = device;
self.receive.current_file = file_name;
self.receive.received = 0;
self.receive.total = size;
self.receive.transfer_started = Some(Instant::now());
self.receive.rate_bps = 0.0;
self.receive.status = "正在接收文件…".into();
}
ReceiverEvent::UploadProgress { device, file_name, received, size } => {
self.receive.connected_device = device;
self.receive.current_file = file_name;
self.receive.received = received;
self.receive.total = size;
if let Some(started) = self.receive.transfer_started {
let secs = started.elapsed().as_secs_f64().max(0.001);
self.receive.rate_bps = received as f64 / secs;
}
}
ReceiverEvent::UploadCompleted { device, file_name, saved_path, sha256 } => {
self.receive.connected_device = device;
self.receive.current_file = file_name;
self.receive.received = self.receive.total;
self.receive.last_saved = saved_path.display().to_string();
self.receive.last_sha256 = sha256;
if let Some(started) = self.receive.transfer_started {
let secs = started.elapsed().as_secs_f64().max(0.001);
self.receive.rate_bps = self.receive.total as f64 / secs;
}
self.receive.status = "文件接收完成。二维码会继续保持有效,可继续发送其他文件。".into();
}
ReceiverEvent::Error(message) => self.receive.status = message,
}
}
}
}
impl eframe::App for QftApp {
fn ui(&mut self, ui: &mut egui::Ui, _frame: &mut eframe::Frame) {
let ctx = ui.ctx().clone();
ui.spacing_mut().item_spacing = egui::vec2(10.0, 10.0);
ui.spacing_mut().button_padding = egui::vec2(14.0, 8.0);
egui::CentralPanel::default().show(ui, |ui| {
self.header(ui);
match self.screen {
Screen::Home => self.home_ui(ui),
Screen::OpticalSend => self.optical_ui(ui, &ctx),
Screen::PhoneToPc => self.receive_ui(ui, &ctx),
Screen::PcToPc => self.pc_to_pc_ui(ui, &ctx),
Screen::PcToPhone => self.pc_to_phone_ui(ui, &ctx),
}
});
}
}
fn install_visuals(ctx: &egui::Context) {
// eframe/egui 0.35 no longer exposes Context::style()/set_style().
// Keep theme initialization here; per-UI spacing is applied in App::ui.
ctx.set_visuals(egui::Visuals::dark());
}
fn install_ttf_font(ctx: &egui::Context) -> Result<PathBuf, String> {
let font_path = find_ttf_font().ok_or_else(|| {
"未找到任何可用的中文字体。请把字体复制到 desktop/assets/qft-ui.ttf,或用 QFT_FONT_PATH 指定。".to_owned()
})?;
let bytes = std::fs::read(&font_path).map_err(|e| format!("读取 {} 失败:{e}", font_path.display()))?;
let mut fonts = FontDefinitions::default();
fonts.font_data.insert(UI_FONT_NAME.to_owned(), Arc::new(FontData::from_owned(bytes)));
fonts.families.entry(FontFamily::Proportional).or_default().insert(0, UI_FONT_NAME.to_owned());
fonts.families.entry(FontFamily::Monospace).or_default().insert(0, UI_FONT_NAME.to_owned());
ctx.set_fonts(fonts);
Ok(font_path)
}
fn find_ttf_font() -> Option<PathBuf> {
let mut candidates = Vec::<PathBuf>::new();
if let Ok(explicit) = std::env::var("QFT_FONT_PATH") {
if !explicit.trim().is_empty() { candidates.push(PathBuf::from(explicit)); }
}
if let Ok(exe) = std::env::current_exe() {
if let Some(dir) = exe.parent() {
candidates.push(dir.join("qft-ui.ttf"));
candidates.push(dir.join("assets").join("qft-ui.ttf"));
}
}
candidates.push(PathBuf::from("assets").join("qft-ui.ttf"));
// 仓库不带字体,最终依赖系统自带的中文字体
candidates.extend(platform::system_font_candidates());
candidates.into_iter().find(|path| is_font_file(path.as_path()))
}
/// 按文件魔数判断是否为可用字体,而不是看扩展名。
///
/// 旧实现只接受 `.ttf`,于是 macOS 的 PingFang.ttc、新版 Windows 的
/// msyh.ttc、Linux 的 NotoSansCJK.ttc 全部被拒,界面只能显示豆腐块。
fn is_font_file(path: &Path) -> bool {
if !path.is_file() {
return false;
}
let Ok(mut file) = std::fs::File::open(path) else { return false };
let mut magic = [0u8; 4];
if std::io::Read::read_exact(&mut file, &mut magic).is_err() {
return false;
}
matches!(
&magic,
b"ttcf" // TrueType 集合
| b"OTTO" // CFF / OpenType
| [0x00, 0x01, 0x00, 0x00] // TrueType
| b"true" // 旧版 Apple TrueType
)
}
fn human_duration(seconds: f64) -> String {
if !seconds.is_finite() || seconds <= 0.5 { return "<1 秒".into(); }
let total = seconds.ceil() as u64;
let minutes = total / 60;
let secs = total % 60;
if minutes > 0 { format!("{minutes} 分 {secs} 秒") } else { format!("{secs} 秒") }
}
/// 把逻辑点尺寸吸附到物理像素整数上。
///
/// 二维码纹理用 NEAREST 采样:绘制尺寸若落在半个物理像素上,
/// 相邻模块占用的物理像素数会一宽一窄,边缘出现锯齿,手机更难解码。
/// 计算二维码的显示边长。
///
/// 必须**同时**受可用宽度与高度约束。此前只看宽度并硬性保底 260 点,
/// 窗口一矮二维码就溢出到可视区外——用户看到的是一个被截掉下半截、
/// 根本扫不了的码。这里宁可让码变小,也不让它跑出边界。
/// 专注模式:收起全部控件,只留二维码与一行说明。
///
/// 扫码时用户会把手机凑近屏幕,此刻界面上的按钮和状态都没有意义,
/// 反而在小窗口里把码挤到看不全。
fn qr_focus_view(
ui: &mut egui::Ui,
texture: Option<&TextureHandle>,
zoom: &mut f32,
focus: &mut bool,
caption: &str,
) {
ui.horizontal_wrapped(|ui| {
if ui.button("退出专注").clicked() {
*focus = false;
}
ui.add(egui::Slider::new(zoom, 0.4..=1.0).text("二维码占比").show_value(false));
ui.label(caption);
});
ui.separator();
let Some(texture) = texture else {
ui.centered_and_justified(|ui| ui.label("二维码尚未生成"));
return;
};
let value = *zoom;
ui.vertical_centered(|ui| {
let side = fit_qr_side(ui, value, 8.0);
ui.image((texture.id(), egui::vec2(side, side)));
});
}
fn fit_qr_side(ui: &egui::Ui, zoom: f32, reserve_height: f32) -> f32 {
let available = ui.available_size();
let limit = available
.x
.min((available.y - reserve_height).max(1.0))
.max(1.0);
let side = (limit * zoom.clamp(0.3, 1.0)).min(limit);
snap_to_physical(side.max(1.0), ui.ctx().pixels_per_point())
}
fn snap_to_physical(points: f32, pixels_per_point: f32) -> f32 {
if pixels_per_point <= 0.0 {
return points;
}
((points * pixels_per_point).round() / pixels_per_point).max(1.0)
}
/// 文件对话框的安全包装。
///
/// macOS 上 `+[NSOpenPanel openPanel]` 会偶发返回 NULL,rfd 遇到就直接 panic,
/// 整个程序随之退出——用户只是想选个文件,结果窗口没了。
/// 不管根因是什么,**选文件失败都不该终止程序**,所以在这里兜住。
///
/// 直接跑裸二进制(不是 .app 包)时更容易触发:AppKit 的若干行为依赖
/// 应用被正确注册为 GUI 程序。package.sh 现在会在 macOS 上额外产出 .app。
fn pick_files_safely() -> Option<Vec<PathBuf>> {
std::panic::catch_unwind(|| rfd::FileDialog::new().pick_files()).unwrap_or(None)
}
fn pick_folder_safely() -> Option<PathBuf> {
std::panic::catch_unwind(|| rfd::FileDialog::new().pick_folder()).unwrap_or(None)
}
fn pick_file_safely() -> Option<PathBuf> {
std::panic::catch_unwind(|| rfd::FileDialog::new().pick_file()).unwrap_or(None)
}
/// 取出本帧被拖进窗口的文件。
///
/// 拖拽不经过 NSOpenPanel,因此在文件对话框失效时仍然可用,
/// 同时它本来就是桌面端更顺手的交互。
fn dropped_paths(ctx: &egui::Context) -> Vec<PathBuf> {
ctx.input(|i| {
i.raw
.dropped_files
.iter()
.filter_map(|file| file.path.clone())
.collect()
})
}
/// 是否正有文件悬停在窗口上,用于给出放置提示。
fn is_hovering_files(ctx: &egui::Context) -> bool {
ctx.input(|i| !i.raw.hovered_files.is_empty())
}
fn human_bytes(v: u64) -> String {
const UNITS: [&str; 5] = ["B", "KB", "MB", "GB", "TB"];
let mut n = v as f64;
let mut i = 0usize;
while n >= 1024.0 && i < UNITS.len() - 1 { n /= 1024.0; i += 1; }
if i == 0 { format!("{} {}", v, UNITS[i]) } else { format!("{n:.2} {}", UNITS[i]) }
}
#[cfg(test)]
mod font_tests {
use super::*;
#[test]
fn detects_ttc_collections_not_just_ttf() {
// 旧实现只看扩展名,把 macOS/Linux 清一色的 .ttc 全拒了
for candidate in platform::system_font_candidates() {
if candidate.exists() {
assert!(
is_font_file(&candidate),
"系统字体 {} 应被识别为可用字体",
candidate.display()
);
}
}
assert!(!is_font_file(Path::new("/etc/hosts")), "非字体文件不应通过");
assert!(!is_font_file(Path::new("/no/such/file")), "不存在的路径不应通过");
}
#[test]
fn a_usable_cjk_font_exists_on_this_platform() {
let found = find_ttf_font();
assert!(
found.is_some(),
"本平台未找到任何中文字体,界面会显示豆腐块。候选:{:?}",
platform::system_font_candidates()
);
}
/// 真正的验收:把找到的字体装进 egui,渲染一个汉字并确认它有宽度。
/// 只检查"文件存在"是不够的——.ttc 若解析失败,字形宽度会是 0。
#[test]
fn renders_chinese_glyphs_with_nonzero_width() {
let ctx = egui::Context::default();
let path = find_ttf_font().expect("应能找到字体");
install_ttf_font(&ctx).expect("字体应能装载");
// egui 0.35:用 begin_pass/end_pass 触发一次布局,字体才会真正加载
ctx.begin_pass(Default::default());
let _ = ctx.end_pass();
let font_id = egui::FontId::proportional(16.0);
let width_cjk = ctx.fonts_mut(|f| f.glyph_width(&font_id, '中'));
let width_latin = ctx.fonts_mut(|f| f.glyph_width(&font_id, 'A'));
assert!(
width_cjk > 0.0,
"字体 {} 无法渲染汉字'中'(宽度 {width_cjk}),界面会是豆腐块",
path.display()
);
assert!(width_latin > 0.0, "拉丁字母也应有宽度");
// 中文是全宽字形,应明显宽于拉丁字母
assert!(
width_cjk > width_latin,
"汉字宽度 {width_cjk} 应大于拉丁字母 {width_latin}"
);
}
#[test]
fn qr_side_snaps_to_whole_physical_pixels() {
// 2x 屏:逻辑点 × 2 必须落在整数物理像素上
for ppp in [1.0_f32, 1.5, 2.0, 3.0] {
for desired in [220.4_f32, 317.7, 480.1, 733.3] {
let snapped = snap_to_physical(desired, ppp);
let physical = snapped * ppp;
assert!(
(physical - physical.round()).abs() < 1e-3,
"ppp={ppp} desired={desired} → {snapped} 点 = {physical} 物理像素,未落在整数上"
);
assert!((snapped - desired).abs() <= 1.0, "吸附不应改变尺寸超过 1 点");
}
}
assert_eq!(snap_to_physical(100.0, 0.0), 100.0, "非法 ppp 时原样返回");
}
}
#[cfg(test)]
mod qr_layout_tests {
/// 二维码边长必须同时受宽高约束。
///
/// 这是一个真实缺陷:此前只按 `available_width()` 计算并硬性保底 260 点,
/// 窗口一矮码就溢出到可视区外,用户看到的是被截掉下半截、根本扫不了的码。
/// 这里用纯函数复刻同一套算法做回归,避免再退回"只看宽度"。
fn fit(width: f32, height: f32, zoom: f32, reserve: f32) -> f32 {
let limit = width.min((height - reserve).max(1.0)).max(1.0);
(limit * zoom.clamp(0.3, 1.0)).min(limit).max(1.0)
}
#[test]
fn never_exceeds_either_dimension() {
let cases = [
(900.0_f32, 200.0_f32), // 矮窗口:截图里的情形
(300.0, 900.0), // 窄窗口
(600.0, 600.0),
(120.0, 120.0), // 极小窗口
];
for (width, height) in cases {
for zoom in [0.4_f32, 0.7, 1.0] {
let side = fit(width, height, zoom, 12.0);
assert!(side <= width + 0.01, "{width}x{height} zoom={zoom} 超出宽度:{side}");
assert!(side <= height + 0.01, "{width}x{height} zoom={zoom} 超出高度:{side}");
assert!(side > 0.0);
}
}
}
#[test]
fn zoom_scales_within_the_limit_and_is_clamped() {
let full = fit(600.0, 600.0, 1.0, 12.0);
let half = fit(600.0, 600.0, 0.5, 12.0);
assert!(half < full, "缩放应真的变小:{half} vs {full}");
// 过小的 zoom 被夹到 0.3,避免码小到扫不出来
assert_eq!(fit(600.0, 600.0, 0.01, 12.0), fit(600.0, 600.0, 0.3, 12.0));
assert_eq!(fit(600.0, 600.0, 5.0, 12.0), full, "zoom 上限为 1.0");
}
#[test]
fn degenerate_sizes_do_not_produce_zero_or_negative() {
// 布局初帧可能给出 0 甚至负的可用空间,不能因此算出非正边长
for (width, height) in [(0.0_f32, 0.0_f32), (10.0, 5.0), (1.0, 100.0)] {
let side = fit(width, height, 1.0, 12.0);
assert!(side >= 1.0, "{width}x{height} 得到非正边长 {side}");
}
}
}