Files
QFT/desktop/src/main.rs
T
zhy200308 bdb822233f feat(desktop): 启动接收时自动检测并申请防火墙放行
上一次实测卡在「连接码解析正确但连不上」,根因是对端 Windows 防火墙
拦截入站,而用户几乎不可能自己联想到这一层。新增 firewall.rs,
在点「启动接收」时自动检测,缺规则就申请一次放行。

三条设计约束
1. 只在确实缺规则时申请。每次启动都弹 UAC 属于骚扰。
2. 被拒绝就记住。写标记文件到配置目录,之后只在界面留一个手动按钮,
   不再自动弹窗;用户点「放行防火墙」会清除标记重新申请。
3. 规则尽量窄。只放行本程序、只放行专用/域网络,不碰公用网络,
   更不整体关闭防火墙。

提权全部交给操作系统的标准机制(Windows UAC、macOS 授权对话框),
程序不接触也不存储任何凭据。

各平台
- Windows:netsh 查规则;添加时把命令写进临时批处理再用
  Start-Process -Verb RunAs 提权执行。不把参数塞进 PowerShell 的
  -ArgumentList —— 程序路径含空格时会被二次分词,引号层层嵌套极易出错,
  批处理里的引号由我们自己写死,不再被重新解析
- macOS:先查 socketfilterfw 全局状态,防火墙没开就直接判定无需处理;
  否则查本程序是否被拦,需要时用 osascript 的管理员授权添加。
  路径含引号或反斜杠时拒绝拼接命令,改为提示手动操作
- Linux:只检测与给出 ufw / firewalld 的命令,不自动改规则。
  各发行版防火墙前端差异过大,自动修改风险高于收益

界面
接收页在检测到可能被拦时显示橙色提示,附「放行防火墙」与
「复制手动放行命令」两个按钮。已放行或防火墙未开启时不显示任何东西。

验证:cargo test 35/35。防火墙相关 3 项均为只读,不改动任何系统设置:
状态查询不 panic 且分类正确、手动说明包含可操作信息、拒绝标记可持久化
往返。本机实测返回 Allowed(防火墙未开启),符合预期。

未验证:Windows 与 Linux 分支在这台 Mac 上无法执行,
netsh/UAC 那条路径需要在 Windows 上实测。
2026-08-11 18:07:53 +08:00

1647 lines
71 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.5.0-m1";
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 {
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,
}
#[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 {
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(),
},
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("同一局域网 · 6 位配对码 · 无需二维码");
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));
ui.horizontal_wrapped(|ui| {
ui.heading("Android → 电脑 · 扫码直连");
ui.separator();
ui.label("UDP 快速发现 · 64 KiB–16 MiB 自适应分块 · 目标 8 路并行 · 不经过外网");
});
ui.add_space(10.0);
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) = rfd::FileDialog::new().pick_folder() {
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");
if let Some(texture) = &self.receive.pair_texture {
let side = ui.available_width().min(420.0).max(260.0);
ui.vertical_centered(|ui| { let side = snap_to_physical(side, ui.ctx().pixels_per_point());
ui.image((texture.id(), egui::vec2(side, side))); });
}
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 · 扫码后立即下载");
});
ui.add_space(10.0);
ui.group(|ui| {
ui.heading("1 · 选择发送文件");
ui.horizontal_wrapped(|ui| {
if ui.add_enabled(!running, egui::Button::new("选择文件")).clicked() {
if let Some(path) = rfd::FileDialog::new().pick_file() {
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 side = ui.available_width().min(420.0).max(260.0);
ui.vertical_centered(|ui| { let side = snap_to_physical(side, ui.ctx().pixels_per_point());
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 optical_pick_file(&mut self, ctx: &egui::Context) {
let Some(path) = rfd::FileDialog::new().pick_file() 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) {
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::local_ipv4_endpoints(server.port),
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::local_ipv4_endpoints(server.port),
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.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("同一局域网 · 无需二维码 · 6 位配对码");
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() {
if let Some(dir) = rfd::FileDialog::new().pick_folder() {
self.pc.save_dir = Some(dir);
}
}
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();
if self.pc.firewall.needs_action() || !self.pc.firewall_note.is_empty() {
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);
}
});
if blocked {
ui.horizontal_wrapped(|ui| {
if ui.button("放行防火墙").clicked() {
firewall::forget_declined();
self.ensure_firewall();
}
if ui.small_button("复制手动放行命令").clicked() {
ui.ctx().copy_text(firewall::manual_instructions(port));
}
});
}
});
}
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("尚未搜索到设备。");
}
});
ui.add_space(12.0);
ui.group(|ui| {
ui.heading("2 · 选择文件并发送");
ui.horizontal_wrapped(|ui| {
if ui.button("选择文件").clicked() {
if let Some(files) = rfd::FileDialog::new().pick_files() {
self.pc.files = files;
}
}
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)));
}
});
}
/// 检测防火墙,必要时**自动**申请一次放行。
///
/// 只在确实缺规则、且用户此前没拒绝过时才弹系统授权框——
/// 每次启动都弹 UAC 属于骚扰。用户点过「否」就记住,
/// 之后只在界面上留一个手动按钮。
fn ensure_firewall(&mut self) {
self.pc.firewall = firewall::status();
if !self.pc.firewall.needs_action() {
self.pc.firewall_note.clear();
return;
}
if firewall::was_declined() {
self.pc.firewall_note =
"此前拒绝过防火墙授权。若对方连不上,请点下方按钮重新放行。".into();
return;
}
match firewall::grant() {
Ok(()) => {
self.pc.firewall = firewall::status();
self.pc.firewall_note = "已放行系统防火墙。".into();
}
Err(e) => {
firewall::remember_declined();
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.ensure_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 采样:绘制尺寸若落在半个物理像素上,
/// 相邻模块占用的物理像素数会一宽一窄,边缘出现锯齿,手机更难解码。
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)
}
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 时原样返回");
}
}