44 Commits

Author SHA1 Message Date
zhy200308 eae24000e9 优化IOS 2026-08-19 09:31:21 +08:00
zhy200308 7023062b45 docs: describe adaptive Android phone bands 2026-08-13 09:16:23 +08:00
zhy200308 b5014aea5b fix: keep modern Android phone links on fast bands 2026-08-13 09:15:11 +08:00
zhy200308 ccaaab7002 fix: add legacy-compatible Android phone link 2026-08-12 16:40:43 +08:00
zhy200308 2ff0741fff fix: connect older Android receivers to phone hotspots 2026-08-12 16:27:02 +08:00
zhy200308 04a2d7fb10 fix: adapt phone share QR to window size 2026-08-12 16:12:26 +08:00
zhy200308 d3e840ff0a feat: add Android to Android phone sharing 2026-08-12 15:17:34 +08:00
zhy200308 f248deac17 release: 封版 v0.4.16 中文正式版 2026-08-12 14:48:09 +08:00
zhy200308 1c5e015285 fix direct connection startup and drag stability 2026-08-12 14:28:49 +08:00
zhy200308 8b3f5c0216 optimize direct transfer UI and Android queue 2026-08-12 14:06:03 +08:00
zhy200308 d7a29e035f fix Wi-Fi Direct legacy connection acceptance 2026-08-12 12:41:59 +08:00
zhy 144b7d1a8e fix(android): enable BuildConfig generation 2026-08-12 12:27:24 +08:00
zhy200308 c1a4dbbd7a fix Windows Direct service reachability 2026-08-12 12:11:15 +08:00
zhy200308 65223dafe4 enforce dedicated Wi-Fi for direct QR pairing 2026-08-12 11:46:59 +08:00
zhy200308 eccd93266e fix direct pairing probe timeout and speed up QR scanning 2026-08-12 11:26:59 +08:00
zhy200308 f9e25819ee fix: improve QR direct connection reliability and speed 2026-08-12 11:14:34 +08:00
zhy200308 9c16cc1690 fix(desktop): 提权脚本用了 bash 的 \ 续行导致放行必然失败,且失败被误报为成功
用户的终端输出把我上一版的 bug 直接暴露了出来:手动放行命令里
`New-NetFirewallRule ... -Direction Inbound \` 后面接换行——`\` 是 bash 的
续行语法,PowerShell 用反引号,于是命令被拆成两条,两条都报错。

同一个 `\` 也写在了 grant() 生成的提权脚本里,所以「放行防火墙」按钮在
Windows 上是**必然失败**的。更糟的是它还误报成功:Start-Process -Wait
返回的是启动器的退出码,不是被提权进程的,脚本语法错误照样得到 0。
用户看到的「已提交放行规则,正在复检…」+ 复检仍显示缺少规则,就是这么来的。

三处修复:

1. 脚本一律一条命令一行,绝不使用任何续行。新增测试逐行断言不以 `\` 结尾。
2. 提权脚本跑完必须写一个成功标记文件,grant() 以标记存在与否判定成败,
   不再相信外层退出码。拿不到标记时给出明确提示而不是假装成功。
3. 「复制手动放行命令」现在只放命令,不再夹杂中文说明。用户是整段粘进
   PowerShell 的,混在里面的散文会被逐行当成 cmdlet 报错,把真正的错误
   淹没掉——用户的终端输出里满屏都是这个。加测试断言每一行都是命令或注释。

另外 APP_VERSION 是 main.rs 里的手写常量,上一版我只改了 Cargo.toml,
界面仍显示 v0.4.9,用户无法判断自己跑的是不是新构建。改为
env!("CARGO_PKG_VERSION"),从此只有一个版本号来源。

用户机器上的诊断结果排除了另外两种成因:三个配置文件的 AllowInboundRules
都是 NotConfigured(没有开启「阻止所有传入连接」),按程序路径也查不到任何
阻止规则。所以剩下的就是放行规则本身没建成——正是本次修复的这个 bug。

版本号 0.4.10 → 0.4.11。
2026-08-12 10:54:05 +08:00
zhy200308 2bb6ce63ae fix(desktop): 修复防火墙面板在「电脑→Android」页面是死代码,并重做 Windows 检测
上一版我说"两个页面都加了",但用户在 v0.4.9 上依然看不到。这次不猜了,
把程序真跑起来截图,看到面板确实没画出来,才找到原因:

pc_to_phone_ui 在 running 时于函数中段就 return 进了 resizable/focus 分支,
我加的那 37 行写在函数尾部,永远执行不到——代码在、grep 得到、但一个像素
都不会画。前两次自查只 grep 了"firewall_panel 在不在",没确认它在不在活的
分支上。面板已移到 pc_to_phone_running_controls(真正渲染的运行态控制区)。

为防同类缺陷复发,加了两个**真渲染**测试:在无窗口 egui 上下文里跑一帧,
把 galley 里的文字抓出来断言。grep 源码挡不住死代码,只有画一遍才行。
另外把 pc_receive_ui 里内联复制的第三份面板也收敛到 firewall_panel。

Windows 防火墙检测重做(这才是"点了放行还是连不上"的根因方向):

1. 改用 PowerShell 而非 netsh。netsh 输出的**值**会本地化(中文系统上是
   「允许/阻止/任何/是」),原先按 "Any"/"Yes" 匹配在中文 Windows 上必然
   误判;Get-NetFirewallRule 返回的枚举在任何语言下都是 Allow/Block/Any。

2. 按**程序路径**查询,不再只按规则显示名。用户在「安全警报」弹窗上点了
   取消时,Windows 会自建一条针对该 exe 的阻止规则,名字是程序名而不是
   QFT Desktop。只按显示名查完全看不见它,而 Block 在 Windows 里永远压过
   Allow——症状正是"点了放行、界面显示已放行、手机依然连不上"。
   grant() 现在会先清掉这类阻止规则再重建放行规则。

3. 检测「阻止所有传入连接,包括位于允许应用列表中的应用」
   (AllowInboundRules=False)。这项打开时加多少规则都没用,单独报为
   BlockedByPolicy,按钮相应置灰并说明要去哪里关——它属于用户的安全设置,
   程序不代劳。

4. manual_instructions 里的 -Profile Private,Domain 是个真 bug,与本模块
   自己的注释矛盾:照抄的用户会重建出一条在 Direct AP 虚拟网卡(被判为
   公用网络)上根本不适用的规则。改为 -Profile Any 并补上排查步骤。

5. grant() 成功后不再直接断言"已放行",改为触发复检——规则加上了不等于
   入站真的通了。

检测要起 PowerShell 进程(1~2 秒),移到后台线程,避免在"启动接收"的瞬间
卡住界面。解析逻辑抽成纯函数 classify_probe,配 10 个用例覆盖中文系统、
自动阻止规则、系统级封禁、防火墙整体关闭等场景——Windows 专有代码最容易
烂在没人跑的地方。已用 cargo check --target x86_64-pc-windows-gnu 验证
Windows 分支能编过。

版本号 0.4.9 → 0.4.10,便于确认拿到的是新构建。
2026-08-12 09:55:12 +08:00
zhy200308 4c294d4270 feat: Direct AP 直连提速 + 剔除虚拟网卡 + 版本号提到 0.4.9 便于确认构建
三项一起处理。

1. 所有 PC→手机的二维码页面都有防火墙放行
   「Android → 电脑」页在 dec132c 已加,「电脑 → Android」页在 7b18c6a
   补上,两处都是「防火墙面板 + 二维码广播的地址」并在启动时自动检测。
   本次把版本号从 0.4.8 提到 0.4.9:此前用户反馈"看不到防火墙功能",
   实为未拉取新提交,而界面上没有任何可据以判断构建新旧的标识。

2. Direct AP 下先直连网关,UDP 发现退为兜底
   Direct AP 场景里网关必然就是那台电脑——手机的 IP 正是它的 DHCP 发的。
   此前却把阻塞式 UDP 发现排在最前,白白等掉一两秒才开始真正能成功的
   那一步。现在配网一就绪立刻并发探测「网关 + 二维码携带的地址」
   (400ms 连接 / 600ms 读取),不通才回落到 UDP 广播与子网扫描。

3. Direct AP 下彻底剔除虚拟网卡地址
   二维码只放得下 4 个地址,而实测机器上有 192.168.30.1、192.168.31.1、
   172.21.96.1 三个 VMware/Hyper-V/WSL 地址。上一版只做降权,名额紧张时
   救不了场。Direct AP 启用时改为直接剔除——此刻手机连的是 AP 网段,
   这些地址永远到不了,占着名额纯属浪费。
   新增 is_virtual_endpoint(),对解析不了的字符串一律不判为虚拟,
   避免误删真实地址。

cargo test 51/51。Kotlin 侧本机无法编译,仅结构检查。
2026-08-12 09:22:24 +08:00
zhy200308 7b18c6a661 fix(desktop): 电脑→Android 页也加防火墙面板与地址列表
二维码端点的修复已经验证生效:手机端诊断显示码里第一个地址就是
192.168.137.1,49.1 紧随其后,虚拟网卡 192.168.30.1 被压到末尾,
顺序完全符合预期。

但连接仍然失败,且手机明确探测过 192.168.137.1:39393 无应答——
问题彻底收敛到「Windows 没有在 Wi-Fi Direct 虚拟网卡上接受连接」,
也就是防火墙规则没有覆盖该网卡的网络类型(通常被归类为公用网络)。

而我上一版只把防火墙面板加到了接收页,本页(电脑→Android)没有,
用户在这里遇到问题时界面上无处可点。补上:
- 面板 + 「二维码广播的地址」折叠项,与接收页一致
- 启动直传时自动重新检测(AP 网卡类型与主网卡往往不同,缓存会误导)

cargo test 49/49。
2026-08-12 09:08:20 +08:00
zhy200308 b2edb3048a fix(desktop): 非 Windows 平台禁用 Direct AP 选项,不再把做不到的事列为「推荐」
Direct AP 只有 Windows 有实现(direct_ap.rs 在其余平台直接 bail),
但两个页面的「连接方式」都把它写成「QFT Direct(推荐)」并默认选中。
macOS/Linux 用户点了之后才发现失败,白白浪费一次尝试。

platform::direct_ap_support() 早就写好了,只是一直没接线(还挂着
allow(dead_code))。现在:
- 两个页面的 Direct AP 单选项在不支持的平台上禁用,并在下方说明原因
- 默认值改为随平台决定,非 Windows 上直接落在「当前局域网」
- 移除 platform.rs 里相应的 allow(dead_code)

cargo test 49/49。
2026-08-12 09:03:09 +08:00
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
zhy200308 6abd932872 fix(desktop): 配对二维码按窗口自适应 + 接收页加专注模式;修复 Direct AP 地址被挤出二维码
两个问题,后者是我上一版引入的真实回退。

一、二维码显示不全
接收页与发送页的配对码此前只按 available_width() 计算边长,并硬性保底
260 点,完全不看可用高度。窗口一矮,码就溢出到可视区外——用户看到的是
被截掉下半截、根本扫不了的码。

- 新增 fit_qr_side():同时受宽高约束,宁可让码变小也不越界;
  并对退化输入(布局初帧可能给出 0 或负的可用空间)保证边长为正
- 接收页(QFTPAIR2)新增专注模式与占比滑条。扫码时用户会把手机凑近
  屏幕,界面上的按钮和状态此刻毫无用处,反而在小窗口里抢走空间。
  发送页原本就有专注模式,本次统一了两页的行为
- 退出接收/返回首页时重置专注状态

二、Direct AP 网关地址被挤出二维码
实测诊断显示二维码给出的是 192.168.8.68、192.168.30.1、192.168.31.1,
唯独没有 192.168.137.1——而手机连上 AP 后网关恰恰是它。

根因是上一版把「猜测性兜底地址」挪到列表末尾后,二维码只取前 3 个,
192.168.137.1 被截断了。它在生成二维码的瞬间往往还不是真实网卡地址
(ICS 虚拟网卡尚未分配 IP),因此不会出现在 get_if_addrs 结果里。
表现为「手机连上了临时 Wi-Fi、拿到了 IP 和网关,却找不到电脑」——
从现象几乎无法反推到这里。

- 新增 pairing::qr_endpoints(port, direct_ap_active):Direct AP 启用时
  把两个 ICS 网关地址置顶
- 二维码端点数从 3 提到 4,容纳 AP 地址与常规局域网地址
- Windows 界面新增「二维码广播的地址」折叠项,把码里的地址摊开显示,
  不必等手机端报错就能确认

cargo test 46/46,含二维码尺寸的三项回归(不越界、缩放夹取、退化输入)
与 Direct AP 地址置顶的三项。
2026-08-11 22:08:44 +08:00
zhy200308 f62fe8d23b fix(pairing): Direct AP 网关地址被挤出二维码,修复我上一版引入的回退
手机端诊断给出了决定性证据。二维码广播的三个地址是:
  192.168.8.68、192.168.30.1、192.168.31.1
而手机连上 Direct AP 后拿到的是 192.168.137.200/24、网关 192.168.137.1
——**码里根本没有它能到达的那个地址**。

回退是我造成的。上一版为了让真实网卡优先,把 192.168.137.1 / 192.168.49.1
这两个猜测性兜底地址挪到了列表末尾;而二维码只取前 3 个。二维码是在
点「启动接收」的瞬间生成的,此时 ICS 虚拟网卡往往还没拿到 IP,因此
不会出现在 get_if_addrs 里,只能靠那两个兜底地址补位——一挪到末尾就被
截断掉了。表现是"Wi-Fi 已连接但找不到电脑",从现象几乎无法反推到这里。

改动
- 新增 pairing::qr_endpoints(port, direct_ap_active):Direct AP 启用时
  把 ICS 网关地址强制放到最前,未启用时维持真实网卡优先
- 二维码端点上限 3 → 4,以便同时容纳 AP 网关与常规局域网地址
- Windows 接收页新增可展开的「二维码广播的地址」列表。手机报"找不到
  电脑"时,第一件要确认的就是码里有没有它能到达的地址——现在一眼可见,
  不必等手机端诊断

测试:新增三项,分别锁住「AP 网关必须排第一」「即使网卡很多也不能被
长度上限截断」「未开 AP 时不该让猜测地址占位」。cargo test 43/43。

注意:本次修复的是"地址没进二维码"。手机此前也直接探测过网关
192.168.137.1:39393 并且失败,说明 Windows 在 ICS 虚拟网卡上仍未接受
连接——那是防火墙配置文件的问题,需要在接收页点「放行防火墙」
(规则会以 profile=any 重建,覆盖该网卡的网络类型)。
2026-08-11 22:03:19 +08:00
zhy200308 ae2c36fa54 perf(android): 传输期间持 Wi-Fi 高性能锁;汇总带上链路协商速率
实测 1.01 GB 的分段数据推翻了此前的判断:

  接收  1分1秒 · 17.06 MB/s   ← 97% 的时间
  校验  1秒   · 1.05 GB/s
  保存  2秒   · 731 MB/s
  合计  1分3秒 · 16.44 MB/s

保存只花 2 秒,此前估计的 15 秒完全错误——那次 MediaStore 拷贝根本不值得
优化,也不构成 10 GB 的阻塞(按此速率 10 GB 约 14 秒)。全部瓶颈都在
网络传输本身。

改动

1. Wi-Fi 高性能锁
   Android 默认让 Wi-Fi 芯片在包间隙进入省电休眠,代价是额外唤醒延迟,
   对持续大流量传输会明显压低吞吐。这是 Android 上最常见也最容易被忽略的
   一项限速。传输期间持锁(API 29+ 用 WIFI_MODE_FULL_LOW_LATENCY,
   以下用 WIFI_MODE_FULL_HIGH_PERF),下载与上传两条路径都覆盖,
   并在 finally 与返回首页时释放——否则 Wi-Fi 会一直停在高功耗模式。
   Manifest 补 WAKE_LOCK 权限。

2. 汇总带上链路协商速率
   新增 WifiConnector.describeLink(),在完成汇总里附上
   「链路 x Mbps · 频段 · 信号 y dBm」。判断"传输慢"到底是软件问题还是
   链路本身的上限,这两个数字是唯一依据:协商 866 Mbps 却只跑到
   136 Mbps 说明有优化空间;协商本来就只有 150 Mbps 则已接近满速,
   再改代码也没有意义。下一步该往哪走,取决于这个数。

Kotlin 本机无法编译,仅做结构检查。
2026-08-11 21:52:52 +08:00
zhy200308 dec132cf3e fix(desktop): 手机接收页也显示防火墙检测,Direct AP 才是最需要它的地方
防火墙面板此前只在「电脑 ↔ 电脑」页有,而 Direct AP 恰恰是最容易被
拦住的路径:它会新建一块 ICS 虚拟网卡,Windows 通常把这块网卡归类为
「公用网络」,与主网卡的类型不同。只覆盖专用/域网络的规则在它上面
完全不生效——表现就是手机连上了临时 Wi-Fi、拿到了 IP 和网关、
二维码地址也正确,却怎么都找不到电脑。用户不可能自己想到这一层。

改动
- 把面板抽成 firewall_panel(ui, port) 供两处共用
- 放在手机接收页的二维码旁边:用户在这里停留最久,也正是在这一步失败
- 被拦时额外解释「Direct AP 是独立网卡、可能被归类为公用网络」这一因果
- 启动接收时自动重新检测,而不是沿用上次结果——AP 网卡的类型与主网卡
  往往不同,缓存的结论会误导

cargo test 40/40。
2026-08-11 21:42:12 +08:00
zhy200308 22c7d7f22d fix: 扫码后先在当前网络直连,不再无条件切 Direct AP
实测诊断给出了决定性信息:手机成功连上 Direct AP、拿到
192.168.137.200/24、网关 192.168.137.1,二维码也正确指向
192.168.137.1:39393,但那个地址上的 39393 不应答,整个 /24 扫了
253 个地址也没有。也就是说手机侧全对,是 Windows 没有在 ICS 虚拟
网卡上接受连接。

而这次切换本来就没有必要——两台设备当时已经在同一个 192.168.8.0/24
局域网里,且实测 192.168.8.68:39393 是通的。切到 Direct AP 反而引入了
ICS 虚拟网卡、该网卡独立的防火墙配置,以及实测一两分钟的配网等待。

改动

1. 二维码始终携带局域网地址(pairing.rs)
   此前开 Direct AP 时只放一个 AP 地址,手机因此**必须**切网才能连。
   现在无论是否开 AP 都带上常规局域网地址,多两个短地址对二维码密度
   的影响可以忽略。

2. 端点顺序修正(pairing.rs)
   此前无条件把 192.168.137.1 / 192.168.49.1 排在最前,即使本机根本
   没有这两块网卡——手机于是先去探测两个不存在的地址,真正可用的
   局域网地址被挤到后面。改为真实网卡优先、猜测性兜底地址殿后。

3. 先试当前网络(MainActivity)
   扫到带 Wi-Fi 凭据的码时,先用系统默认网络并发探测二维码里的地址
   (700ms 连接 / 900ms 读取)。通了就直接开始传输,完全跳过配网弹窗
   与虚拟网卡;不通才切 Direct AP。新增 UploadClient.probeEndpoints。

4. 配网请求复用加时间上限(WifiConnector)
   上一版为了避免「系统选网弹窗还开着就 unregister」而改成复用挂起的
   请求,但没有上限。系统偶尔会让请求既不回 onAvailable 也不回
   onUnavailable 地一直挂着,于是每次「重试连接」都只是再等一次那个
   死掉的请求——这正是本次「配网越来越慢、至少两分钟」的由来。
   超过 20 秒即推倒重来。

5. 网关探测过滤 0.0.0.0(WifiConnector)
   诊断截图里出现了 http://0.0.0.0:39393,来自默认路由的空网关,
   永远连不上却占着探测预算。回环与组播地址一并过滤。

Rust 侧 cargo test 40/40,含两项新用例:端点顺序、以及开 Direct AP 时
二维码仍携带局域网地址。Kotlin 侧本机无法编译,仅做结构检查。
2026-08-11 21:39:46 +08:00
zhy200308 b5d124abe5 fix(android): 网关探测过滤 0.0.0.0 等无效地址
实测诊断截图里出现了 http://0.0.0.0:39393 这个候选。它来自默认路由的
空网关(直连链路无下一跳),永远不可能连上,白白占用探测预算并把真正
的候选挤到后面。回环与组播地址同理,一并过滤。
2026-08-11 21:26:06 +08:00
zhy200308 0281382c39 feat(android): 分阶段速率记账 + 连接失败时输出网络诊断
两件都是为了让"到底哪里慢/哪里断"能被看见,而不是继续靠猜。

分阶段速率
下载分传输、校验、保存三段,三者速率含义完全不同,混在一起平均出来的
数字毫无意义——这也是"传输不到 10 MB/s"这个观察难以定位的原因:
1 GB 若传输 50 s、校验 5 s、保存 15 s,看起来就成了 14 MB/s。
现在逐段记账,完成后一并列出:

  接收完成:已保存到 Downloads/QFT/xxx
  接收  52.3s · 19.6 MB/s
  校验  6.1s · 168 MB/s
  保存  14.8s · 69 MB/s
  合计  73.2s · 14.0 MB/s

并行下载的进度回调来自多个 worker 线程(DownloadClient 里 pool.submit
的闭包),因此记账用 AtomicLong 与 synchronizedList,不能用普通 var。

连接失败的诊断
"未找到 QFT 接收服务"这句话无法区分:手机在别的网段?没拿到网关?
还是对端根本没开。现在报错里直接带上手机侧的实际网络状况——
本机地址/掩码、网关、SSID——以及二维码给出的地址、探测过的网关、
子网扫描范围,并列出三条对照检查项。
新增 WifiConnector.describeNetwork()。

注意:Kotlin 在本机无法编译,以上改动仅做过结构检查,需要实测编译。
2026-08-11 21:14:22 +08:00
zhy200308 ae41267221 perf(sender): 下载服务支持 HTTP keep-alive,消除每分块重建 TCP
Android 的并行下载在每个 Range 请求里都写了 Connection: keep-alive,
但服务端每个响应都写死 Connection: close —— 复用是单方面的,实际上
每个 16 MiB 分块都要新建一条 TCP。1 GB 是 64 次,10 GB 是 640 次。
这正是"短连接不稳定、很快断开"的直接来源。

改动
- handle_client 拆出 serve_one,在同一条连接上循环处理请求
- 按 HTTP/1.1 语义决定是否复用:客户端显式 Connection: close 或
  使用 HTTP/1.0 时才断开,否则响应回 Connection: keep-alive
- 读到 0 字节视为对端正常关闭,这是 keep-alive 下的常态而非错误,
  不再当作 "连接在请求头前关闭" 报错

测试
新增 serves_multiple_ranges_on_one_connection:在同一条 TCP 上连发三段
互不重叠的 Range,逐段校验状态行、Content-Length、Connection 头与内容
字节,最后再用一个显式 Connection: close 的请求确认服务端会正常收尾。
两个既有用例同步补上 Connection: close —— 它们只发一个请求就读到 EOF,
在 keep-alive 下会一直等下一个请求直到读超时。

cargo test 38/38。
2026-08-11 21:02:01 +08:00
zhy 90800b9a21 Merge branch 'main' of https://git.xskjhy.top/kmcc/QFT 2026-08-11 20:52:54 +08:00
zhy 32b58d121a 优化UI,电脑传手机二维码配网可拖动区域大小 2026-08-11 20:44:43 +08:00
zhy200308 99be46acf7 release: v0.4.8 跨端 PC 互传封版;修复发送端进度直到结束才更新
实测 1.01 GB / 23.11 MB/s 传输成功,但发送端进度条全程 0%、
最后才跳到 100%,接收端却是实时的。两处原因,都已修复。

1. 请求体一次性写出
   16 MiB 的分块用单次 write_all 送出,中途没有任何可上报的点。
   改为 256 KiB 一片:足够小让进度看起来连续,又足够大不拖慢吞吐。
   put_chunk 逐片累加共享计数;失败重试时把本次尝试已计的字节扣回去,
   否则重试会让进度虚高甚至越过 100%。

2. on_progress 只在所有 worker 结束后调用一次
   主线程改为在 worker 运行期间轮询上报(40 ms 一次,对 UI 足够,
   代价可忽略),而不是等 thread::scope 返回。

测试拆成两层
- 确定性单测 body_progress_is_reported_incrementally:5 片请求体必须
  上报 5 次、总量吻合。回环速度太快时集成测试采样不到中间进度,
  只有这一层能稳定拦住回归
- 集成测试改为断言稳健性质:进度单调不减、且不超过文件总长
  (后者正是重试重复计数会破坏的)
- 配套的 mock 服务端按 Content-Length 精确读取。此前用 read_to_end
  会一直等客户端关闭写端,而客户端在等响应,两边互等直接死锁

封版
- 版本 0.5.0-m1 → 0.4.8,接续既有编号
- 界面与 README 里残留的「6 位配对码」文案更新为连接码

本版可用范围:mac / win / linux 桌面端互传,连接码内含地址,
不要求同一网段,只要 IP 层可路由到达即可。
2026-08-11 19:37:21 +08:00
zhy200308 375ae8a956 fix(desktop): 选择文件不再让程序崩溃;新增拖拽;macOS 产出 .app
macOS 上点「选择文件」直接退出:

  panicked at objc2-app-kit-0.3.2/.../NSOpenPanel.rs:127:
  unexpected NULL returned from +[NSOpenPanel openPanel]

rfd 在 openPanel 返回 NULL 时直接 panic,整个进程随之结束——用户只是
想选个文件,窗口就没了。三层处理,从"不该崩"到"不该发生":

1. 不该崩:pick_files/pick_folder/pick_file 全部包进 catch_unwind。
   文件对话框失败是可以恢复的情况,不该终止程序;失败时在状态栏说明
   并提示改用拖拽。

2. 提供不依赖对话框的路径:支持把文件直接拖进窗口。拖拽不经过
   NSOpenPanel,对话框失效时照样能用,而且本来就是桌面端更顺手的交互。
   悬停时给出"松手即可加入待发送列表"的提示。

3. 消除诱因:package.sh 在 macOS 上额外产出 QFT.app。AppKit 的若干行为
   依赖应用被正确注册为 GUI 程序,直接跑裸二进制正是这个 NULL 的高发场景。
   Info.plist 含 NSHighResolutionCapable,Retina 下不会被拉伸。

顺带修复 package.sh 的校验和步骤:此前 `sha256sum ./*` 会把 .app 目录
一起喂进去并报错,改为 find -type f 只处理普通文件。

验证:cargo test 35/35;package.sh 完整跑通并实际 open 了生成的 .app,
确认能启动存活;plutil 校验 Info.plist 通过。
2026-08-11 18:56:17 +08:00
zhy200308 bcadcf0b53 fix(firewall): 规则必须用 profile=any,否则在公用网络下完全不生效
实测发现的真 bug。用户机器上的规则列表:

  qft-windows  Allow Inbound Public           (旧版,能用)
  QFT Desktop  Allow Inbound Domain, Private  (新加,不生效)

Windows 对没见过的 Wi-Fi 默认归类为「公用网络」。规则只覆盖
Private,Domain 时,Get-NetFirewallRule 照样显示 Enabled: True,
但对当前网络根本不适用,连接依旧被拦——这种「配置看起来是对的却没有
效果」的失败最难排查。旧版之所以一直能用,是因为当初点系统安全警报的
「允许」时,Windows 按当时的 Public 配置自动建了规则。

改动
- grant() 生成的 netsh 规则改为 profile=any
- status() 不再只看「有没有同名规则」,还要求它是 any profile,
  否则同样报 Missing。避免出现「检测说已放行、实际仍被拦」
- README 补充排查步骤:先看 NetworkCategory 与规则的 Profile 两列,
  以及 Block 规则优先于 Allow 这个常见坑

关于收窄 profile 的取舍:限定到 private 并不能带来实际安全收益。
QFT 的入站真正靠的是连接码里的秘密加失败计数,没有秘密的连接一律被拒;
而按 profile 收窄只会在最常见的家用/公共 Wi-Fi 场景下静默失效。

验证:cargo test 35/35。Windows 分支仍无法在本机执行,
netsh 与 UAC 那条路径需要在 Windows 上实测。
2026-08-11 18:48:41 +08:00
zhy200308 0f0dbaef47 fix(desktop): 防火墙提权改为手动触发;构建前检测占用;清理警告
三个问题一起处理。

1. 提权改为手动
上一版会在点「启动接收」时自动弹 UAC。实际用下来太侵入——多数人
只是想收个文件,却先被要求管理员授权。现在:
- 检测保持自动,但**只读**,无任何副作用
- 提权只在用户点「放行防火墙(需要管理员授权)」时发生
- 按钮无条件保留,不再只在"检测到被拦"时出现:检测可能不准,
  而用户遇到「对方连不上」时需要有地方可点
- 同时移除了拒绝标记的持久化——提权已不自动发生,无需记忆

2. Windows 构建报 os error 5
  error: failed to remove file `...\target\release\qft-desktop.exe`
  Caused by: 拒绝访问。 (os error 5)
原因是 QFT 窗口还开着,运行中的 exe 锁住了产物文件,而 cargo 的报错
完全看不出这一层。VERIFY_WINDOWS_HOST.ps1 现在会在构建前检测
qft-desktop 进程,列出 PID 并询问是否结束;README 也补了说明
(含 Defender 扫描导致的偶发同类报错)。

3. 构建警告 15 → 5
长期堆积的警告会训练人忽略所有警告,所以逐条处理:
- 真实问题:if 条件多余的括号,已修
- 为后续里程碑准备但尚未接线的 API(client::ping、download_file、
  platform::direct_ap_support/ensure_dir),加 #[allow(dead_code)]
  并注明将在哪个阶段使用
- 仅特定平台构造的项(firewall::RULE_NAME 只用于 Windows,
  FirewallStatus::Unsupported 只在 Linux 返回),改用
  #[cfg_attr(not(...), allow(dead_code))],避免无条件放行
剩余 5 个均为本次改动之前既有(cache_mib、v/transport、security、
path),不属本次范围,未改动。

验证:cargo test 35/35,release 构建 5 个警告且全部是既有的。
2026-08-11 18:28:43 +08:00
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
zhy200308 3e4d5861aa fix(desktop): 连接失败给出可执行的排查方向,并分离配对与传输状态
实测中出现「连接码解析正确但连不上」。诊断结果不是代码问题:两台机器
同在 192.168.8.0/24,ARP 能解析对方 MAC(二层通),但 ICMP 100% 丢包、
TCP 39393 连接超时——典型的对端主机丢包,即 Windows 防火墙拦截入站。

顺带暴露的连带影响:二进制从 qft-windows.exe 改名为 qft-desktop.exe 后,
此前给旧名字放行的防火墙规则对新程序不生效,用户不会想到这一层。
README 已补充放行步骤与排查顺序。

代码侧的三个真实缺陷

1. 连接失败只说「失败」,等于什么都没说。现按 io::ErrorKind 分类:
   - TimedOut  → 包发出去没回应:防火墙 / AP 客户端隔离 / 对方已关闭
   - ConnectionRefused → 主机在线但端口没人监听:对方没点「启动接收」
   - Host/NetworkUnreachable → 本机没有到该地址的路由
   三者成因完全不同,给的建议也必须不同。

2. 配对超时从 10 秒缩到 4 秒。配对只是一次极小的请求,拖到 10 秒
   只会让用户以为程序卡死。

3. 配对阶段就显示「正在发送 0%」。此前用 busy 兼作「正在传输」,
   导致刚点连接就出现发送进度条。新增独立的 transferring 标志,
   进度块只在真正推送文件时出现;配对期间改为显示 spinner 与
   「正在建立连接…最多等 4 秒」。

验证:cargo test 32/32。新增两项针对错误分类的用例——
用 RFC 5737 文档网段 192.0.2.1 触发超时路径,用刚释放的本地端口
触发拒绝路径,分别断言提示里包含对应的排查方向。
2026-08-11 17:39:53 +08:00
zhy200308 84643bff5e feat(desktop): PC↔PC 改用连接码,一串搞定,不再单独输 IP
此前发送方要分别念/输三样东西:IP、端口、6 位配对码。现在合成一串
可口述的连接码,**地址就编在码里**,所以拿到码即可直连——不需要广播、
不需要在同一网段,只要 IP 层路由可达即可(同一路由器下的不同 VLAN /
网段正属于这种情况)。

新增 connect_code.rs
- 编码:version(3) | kind(3) | 默认端口位 | 地址 | [端口] | 24bit 秘密 | CRC-8
- 按网段压缩地址:192.168.a.b 只需 2 字节,10./172.16-31. 三字节,
  其余四字节,IPv6 十六字节
- Crockford Base32(去掉易混的 I/L/O/U),分组显示
- 典型 192.168.a.b:39393 → **12 个字符**,如 4849-3WT1-3ZS0
- 输入容错:大小写、分隔符、空格随意;I/L 归一为 1、O 归一为 0

接收侧
- 6 位配对码 → 3 字节秘密;UI 为**每个网卡各生成一个连接码**,
  对方在哪个网段就用哪一串(虚拟网卡排后面)
- 新增 pairing::local_ipv4_addresses(),按「最可能被对方看到」排序

发送侧
- 三个输入框(设备列表 / 手动 IP / 配对码)合并为**一个连接码输入框**
- 边打边校验:CRC 在连接之前就能发现输错,并实时显示「将连接 http://x.x.x.x:port」
- 广播搜索降级为可选的折叠项——同网段免输码是锦上添花,不再是主路径

一个被测试抓出来的真问题
最初单字符输错的拦截率只有 96%。原因是 12 个 Base32 字符携带 60 bit
而实际只用 56 bit,末尾 4 个填充位被解码器直接丢弃,改动最后一个字符
有 1/16 概率解出完全相同的字节,CRC 根本没机会发现。加上填充位必须为 0
的校验后拦截率 >99%。

必须说清的边界
连接码解决的是「找不到对方」和「输入太繁琐」,不能凭空制造可达性。
若两台机器在 IP 层互不可达(Wi-Fi 客户端隔离、各自在不同物理网络),
任何客户端侧协议都无法建立连接,只能换链路或引入第三方中转——
后者与 QFT「不经过外网」的定位冲突,本版不做。

验证:cargo test 30/30,含连接码往返(全部地址类型)、容错输入、
单字符输错拦截率统计、以及走完整连接码链路的端到端传输
(编码 → 解码 → 换令牌 → 9MB 并发上传 → SHA-256 比对)。
2026-08-11 17:29:00 +08:00
zhy200308 d2669fb2e4 fix(desktop): 修复 macOS/Linux 上的中文豆腐块与 HiDPI 缩放
macOS 首次构建暴露的两个独立问题。

中文全是豆腐块
- is_ttf_file 只按 `.ttf` 扩展名筛选,而 macOS 的中文字体清一色是
  .ttc 字体集合(PingFang/Hiragino/STHeiti),Linux 的 NotoSansCJK
  与新版 Windows 的 msyh 也是 .ttc —— 全部被拒。改为按文件魔数识别
  (ttcf / OTTO / 0x00010000 / true),同时支持 ttf、otf、ttc
- 候选路径此前只有三条 Windows 的,非 Windows 平台根本没有兜底。
  新增 platform::system_font_candidates(),三平台各自列出系统中文字体
- 报错信息里的 windows/assets 路径跟进为 desktop/assets

HiDPI 下整个界面缩成一半
- set_pixels_per_point(1.0) 写死了缩放。Retina 屏 ppp=2.0,
  强制 1.0 会让所有控件和文字按一半尺寸渲染,界面挤在窗口左上角。
  改为交给 eframe 从系统取
- 原先写死 1.0 应是为了让二维码纹理与物理像素 1:1。改用
  snap_to_physical() 在绘制时把尺寸吸附到物理像素整数上达到同样目的:
  NEAREST 采样下若落在半个物理像素,相邻模块占的像素数会一宽一窄,
  边缘产生锯齿,反而更难被手机解码

顺带
- 设备名去掉 mDNS 的 .local/.lan 后缀。这个名字会出现在对方的设备
  列表里,zdeMacBook-Air.local 既长又没有信息量

验证(macOS,Retina 2880x1864)
- cargo test 21/21,其中新增 4 项:
  * 系统字体候选中存在的文件必须被 is_font_file 接受
  * 本平台至少能找到一个中文字体
  * **把找到的字体真正装进 egui 并渲染 '中'**,断言字形宽度非零且
    宽于 'A' —— 只检查文件存在是不够的,.ttc 解析失败时宽度会是 0
  * snap_to_physical 在 ppp=1/1.5/2/3 下都落在整数物理像素上
- release 构建后实际启动截图确认:中文正常显示(Hiragino Sans GB),
  界面按 Retina 正确缩放
2026-08-11 16:51:50 +08:00
zhy200308 92237ff76f fix(package): package.sh 跟进 desktop/ 改名,并在 keg-only 安装下自动找到 cargo
上一个提交把 windows/ 改成 desktop/ 时漏掉了 package.sh —— 当时的
grep 只覆盖 .md/.py/.ps1/.toml/.yml,没有扫 .sh,导致打包脚本仍然
cd windows 并寻找 qft-windows 二进制。

- 路径与二进制名跟进 desktop/ 与 qft-desktop
- cargo 检测增加兜底:brew 的 rustup 是 keg-only,
  /opt/homebrew/opt/rustup/bin 不会自动进 PATH,此前会出现
  "明明装了工具链却报 cargo 未找到"。现在先在常见位置探一次,
  仍找不到时给出可直接执行的修复命令而不是一句干巴巴的报错
- .gitignore 忽略 /dist 打包产物(release 二进制 14 MB,不应入库)

已在 macOS 上完整跑通 ./package.sh:cargo test 17/17 通过、
release 构建成功、产出 QFT-Rust-0.5.0-m1-<时间戳>-darwin 目录与
tar.gz,内含 14 MB 的 Mach-O arm64 可执行文件与 SHA256SUMS.txt。
2026-08-11 16:43:55 +08:00
zhy200308 376ffba96e feat(desktop): 跨平台桌面端 + 电脑↔电脑互传(v0.5.0-m1)
对应 V05_EXECUTION_PLAN 的 P1。核心改动是把「PC 只能当服务端」
这个写死的角色拆开——此前 TcpStream::connect 只出现在测试里,
桌面端根本无法主动连接另一台桌面端,PC↔PC 因此完全不可用。

跨平台
- windows/ → desktop/,crate 更名 qft-desktop
- 新增 platform.rs 收敛全部平台差异:配置目录(LOCALAPPDATA /
  Application Support / XDG)、下载目录(含 Linux 本地化的 ~/下载)、
  设备名、Direct AP 能力。约定:其余模块不得再出现 #[cfg(target_os)]
- direct_ap.rs 的 Context 导入按平台条件化,非 Windows 上不再告警
- macOS 上已实测编译并链接出可执行文件(65 MB Mach-O arm64),
  这是本仓库首次在非 Windows 平台构建成功

电脑 ↔ 电脑
- 新增 client.rs:桌面端发起侧。手写 HTTP,不引入客户端依赖——
  服务端本来就是手写的,两边同一套解析更容易与 Android/iOS 对齐。
  含并发分块上传(自适应 4/8/16 MiB、最多 8 worker)与 Range 断点续传
- 新增 discovery.rs:UDP 广播 QFTBROWSE3 浏览局域网节点。
  既有的 QFTDISC2 是「已知令牌找机器」,用于扫码之后;
  PC 没有摄像头,必须先能列出附近有谁
- receiver.rs 新增 POST /qft/pair:用 6 位配对码换会话令牌。
  这是唯一不校验令牌的端点。6 位仅约 20 bit 熵,配严格失败计数兜底——
  错 5 次即作废,需重启接收;比较用定长实现,不做短路返回
- 新增「电脑 ↔ 电脑」界面:接收方显示配对码与本机地址;
  发送方搜索/手动输入地址 → 输码连接 → 多选文件 → 带进度发送

验证(macOS,Rust 1.97.1)
- cargo check 0 错误,cargo test 17/17 通过
- 新增端到端用例:真实起接收服务 → 配对(含错误码必须被拒)→
  9 MB 跨多分块并发上传 → 校验落盘内容逐字节一致且 SHA-256 与
  接收端返回值相同。这就是 PC↔PC 的完整链路
- 11 项 Python 自检全部通过

顺带修复
- single_channel_guard_selftest 长期为红:它断言
  DEFAULT_CHUNK_SIZE = 450,而代码早已改为 320。改名前即存在,
  已用 git stash 验证与本次无关。改为范围检查(128~4096)并在
  PASS 信息里打印实际值,既挡住"退回多通道小块"又不会因调参误报

已知限制
- UDP 广播只覆盖同一广播域。跨网段或 AP 隔离的 Wi-Fi 上搜索不到,
  需手动输入对方 IP(界面已说明)。mDNS 留待后续
- 本阶段仍走 v2 明文 HTTP,加密随 QFT-Stream v3 一起做(见 P2)
2026-08-11 16:36:33 +08:00
zhy a960ad91d8 合并 0.4.7 双向并发传输封版
# Conflicts:
#	README.md
#	android/app/src/main/java/com/qft/optical/DownloadClient.kt
#	android/app/src/main/java/com/qft/optical/UploadClient.kt
#	docs/PROTOCOL.md
#	windows/src/sender.rs
2026-08-11 14:27:30 +08:00
zhy 20ac4dc6c7 发布 0.4.7 双向并发传输封版 2026-08-11 13:49:27 +08:00
89 changed files with 13353 additions and 2113 deletions
+2
View File
@@ -19,3 +19,5 @@ ios/**/xcuserdata/
ios/**/*.xcworkspace/xcuserdata/ ios/**/*.xcworkspace/xcuserdata/
ios/build/ ios/build/
DerivedData/ DerivedData/
# package.sh 打包产物
/dist
+64 -2
View File
@@ -1,4 +1,4 @@
# QFT v0.4.6 implementation status # QFT v0.4.16 implementation status
## Windows → Android optical ## Windows → Android optical
@@ -40,17 +40,31 @@
- [x] wait for actual IPv4/link route before discovery - [x] wait for actual IPv4/link route before discovery
- [x] UDP QFTDISC2 receiver discovery - [x] UDP QFTDISC2 receiver discovery
- [x] QR endpoint + gateway + directed broadcast + subnet fallback - [x] QR endpoint + gateway + directed broadcast + subnet fallback
- [x] dedicated Wi-Fi immediate parallel gateway + actual-subnet probe
- [x] HTTP bound to selected Android Network - [x] HTTP bound to selected Android Network
- [x] local cleartext network security config - [x] local cleartext network security config
- [x] local/private IPv4 + session-token validation - [x] local/private IPv4 + session-token validation
- [x] Parallel v2 init/chunk/finish - [x] Parallel v2 init/chunk/finish
- [x] adaptive 4/8/16 MiB chunks - [x] adaptive 64 KiB–16 MiB chunks, targeting eight flows per file
- [x] up to 8 Android workers per file - [x] up to 8 Android workers per file
- [x] Windows positioned concurrent writes - [x] Windows positioned concurrent writes
- [x] temporary `.qftpart`, final SHA-256 and rename - [x] temporary `.qftpart`, final SHA-256 and rename
- [x] accepted sockets return to timeout-bound blocking I/O before file transfer
- [x] inline Android file selection + removable, pre-transfer sortable queue
- [x] crash-safe drag commit without detaching the active touched view
- [x] loopback UDP + HTTP + out-of-order parallel integration test - [x] loopback UDP + HTTP + out-of-order parallel integration test
- [ ] physical Windows Wi-Fi Direct adapter / driver / firewall matrix - [ ] physical Windows Wi-Fi Direct adapter / driver / firewall matrix
## Windows → Android local direct
- [x] direction-specific pairing QR starts automatic local download after scan
- [x] HTTP `Range` responses return the exact requested range (`206` + `Content-Range`)
- [x] Android parallel Range downloader targets eight workers per file
- [x] adaptive 64 KiB–16 MiB chunks
- [x] `.qftpart` completion ledger resumes only verified completed ranges
- [x] five retries per range, final SHA-256, then save to `Downloads/QFT`
- [x] regression test for delayed large download after nonblocking accept
## Android compatibility ## Android compatibility
- [x] minSdk 24 (Android 7.0) - [x] minSdk 24 (Android 7.0)
@@ -64,4 +78,52 @@
- [ ] real Android Gradle APK build in this container (SDK unavailable here) - [ ] real Android Gradle APK build in this container (SDK unavailable here)
- [ ] install/runtime matrix on physical Android 7→latest devices - [ ] install/runtime matrix on physical Android 7→latest devices
## iOS (v0.5.0)
Optical receive (PC screen → iPhone camera)
- [x] Swift QFT2 + Base45 + CRC32 frame decode, QFT1 legacy read
- [x] session assembler: dedupe, positioned writes, whole-file SHA-256, discard on mismatch
- [x] AVCaptureVideoDataOutput + Vision `VNDetectBarcodesRequest`
- [x] format picked for highest resolution among ≥60 FPS formats; fixed frame rate, HDR/stabilisation off
- [x] `alwaysDiscardsLateVideoFrames` (no stale camera frames)
- [x] centered search → ROI lock → progressive expansion → reacquire
- [x] periodic AF/AE at ROI center after lock
- [x] separate decoded/s and distinct-new-frame/s counters
- [ ] physical throughput matrix (30/45/60 FPS × device)
iPhone ↔ Windows dedicated network
- [x] accept Wi-Fi-only QFTPAIR2/QFTSEND2 (no endpoints, by design)
- [x] `NEHotspotConfiguration` join with `joinOnce`
- [x] honest fallback to guided manual join when the entitlement is unavailable
- [x] default gateway from `sysctl` route table; gateway-first host candidates
- [x] join verified by authenticated `/qft/ping`, not by the system callback
- [ ] physical Windows Wi-Fi Direct AP join (both entitlement paths)
iPhone ↔ Mac / Linux LAN
- [x] `QFTBROWSE3` node browse client
- [x] desktop connect code (Crockford Base32 + CRC-8), cross-verified against Rust vectors
- [x] `POST /qft/pair` code → token, no retry on failure
- [x] eight-way parallel Range download, 64 KiB–16 MiB adaptive chunks
- [x] `.qftpart` + completion ledger resume (parallel chunks land out of order)
- [x] explicit failure + single-stream fallback when the peer ignores Range
- [x] parallel upload (init/chunk/finish), fixed 4 MiB chunks × 6 workers
iPhone ↔ iPhone (AirDrop-style)
- [x] AWDL `includePeerToPeer` + TLS-PSK, key carried by the QR
- [x] multi-file queue (QFTP2P2); manifest digest in the QR, manifest itself on the wire
- [x] per-file SHA-256, partial files removed on any failure
- [ ] physical AWDL run with the router switched off
Compatibility
- [x] deployment target iOS 15.0 (iPhone 6s and later)
- [x] iOS 16/17 APIs behind `App/Compatibility.swift` forks
- [x] no `loadUnaligned` (Swift 5.7 runtime) in the core layer
- [x] 180 core-layer checks green via `swiftc` on macOS, no Xcode required
- [ ] Xcode build of the App layer (no Xcode on the authoring machine)
See `TEST_REPORT.md` and `TEST_RESULTS.txt` for executed evidence and limitations. See `TEST_REPORT.md` and `TEST_RESULTS.txt` for executed evidence and limitations.
+172 -13
View File
@@ -1,13 +1,171 @@
# QFT · 超速二维码文件传输 v0.4.6 # QFT · 超速二维码文件传输 v0.4.16
Windows + Android 双向候选版。v0.4 的核心目标不是继续堆“4 码理论吞吐”,而是解决 Android 端实际识别慢的问题:**删除 2×2/4 通道,改成一个大二维码 + 动态 ROI 锁定 + 高频局部解码**。 Windows + Android 双向正式版。v0.4 的核心目标不是继续堆“4 码理论吞吐”,而是解决 Android 端实际识别慢的问题:**删除 2×2/4 通道,改成一个大二维码 + 动态 ROI 锁定 + 高频局部解码**。
两个方向仍然采用不同链路: v0.4.16 提供两套互不依赖的传输方式:
- **Windows → Android:纯光学**。文件数据只经过 Windows 屏幕 → Android 摄像头;Wi‑Fi、蓝牙、局域网和互联网都不参与文件数据传输。 - **电脑 → 手机(纯光学)**:文件数据只经过 Windows 屏幕 → Android 摄像头;Wi‑Fi、蓝牙、局域网和互联网都不参与文件数据传输。
- **Android → Windows:扫码本地直连**。Windows 选择保存目录并启动 QFT Direct/LAN 接收服务;Android 扫码、配网、自动发现电脑,然后并行分块上传,不经过外网。 - **扫码本地直传(双向)**:Windows 为“手机上传”和“电脑下发”分别生成方向明确的二维码。Android 扫码后连接 QFT 本地网络、通过 UDP/网关/子网探测定位电脑,并按二维码指定方向自动进入选文件上传或接收下载;文件数据不经过外网。
> v0.4.6 已完成协议、图像合成解码、ROI、并行上传、UDP 发现、内存预算和关键 Kotlin 源码测试。当前生成环境没有真实 Windows 显示器、Android 相机或 Wi‑Fi Direct 适配器,因此物理 30/45/60 FPS 和真实扫码配网仍需在你的设备上跑 `VERIFY_WINDOWS_HOST.ps1` 后做最终验收;详见 `TEST_REPORT.md`。 ### v0.4.16 直传稳定性与并发策略
- **双向均使用并行分块**:每个可分块文件以 8 路为目标并发数;分块大小根据文件大小自适应,范围为 **64 KiB–16 MiB**。小于一个最小分块的文件会自然只有一个请求。
- **手机 → 电脑**:Android 使用 offset 定位的 Parallel v2 上传;Windows 对每块进行定位写入,重复块与完成请求可安全重试,最终以 SHA-256 校验后原子改名。
- **电脑 → 手机**:Windows 支持精确的 HTTP `Range`(`206 Partial Content`);Android 对未完成块创建多个独立 Range 请求,并用 `.qftpart` 与完成位图恢复中断传输。每块最多重试 5 次,完成后校验 SHA-256 再保存至 `Downloads/QFT`。
- **连接稳定性**:Windows 监听器保持非阻塞以便及时停止服务,但已连接的文件套接字会切换为带读写超时的阻塞模式,避免 Windows `WSAEWOULDBLOCK (10035)` 造成大文件中途失败。
> v0.4.16 已完成协议、图像合成解码、ROI、双向并发传输、专用 Wi-Fi 快速发现、队列拖动稳定性和关键 Kotlin 源码测试。当前生成环境没有真实 Windows 显示器、Android 相机或 Wi‑Fi Direct 适配器,因此物理 30/45/60 FPS 和真实扫码配网仍需在你的设备上跑 `VERIFY_WINDOWS_HOST.ps1` 后做最终验收;详见 `TEST_REPORT.md`。
## v0.5.0-dev5:Android → Android 手机互传
当前开发版新增 Android 手机之间的扫码直传闭环:
- 发送手机选择多个文件、删除或拖动调整顺序,然后生成 `QFTPHONE2` 二维码;
- Android 8+ 优先创建系统 LocalOnlyHotspot,接收手机扫码后自动加入;
- Android 7 或临时热点不可用时,自动回落到两台手机当前同一 Wi-Fi;
- 二维码只携带一次性会话和网络身份,文件队列通过会话认证后读取,避免多文件让二维码过密;
- 每个文件复用现有最高 8 路 HTTP Range、断点位图和 SHA-256 校验,按发送队列顺序保存到 `Downloads/QFT`;
- 发送页面必须保持打开,返回首页会立即关闭发送服务和临时热点。
- 发送二维码按当前应用窗口的实际可用宽高动态生成并居中,手机、平板和分屏窗口都不会再被 `match_parent` 放大溢出。
- Android 7–9 接收端每次扫码都会用二维码中的新密码刷新临时 Wi-Fi 配置,不再复用同名热点的旧密码;Android 10+ 也只复用完整凭据一致的系统配网请求。
- 当高版本发送机只能创建旧设备不支持的纯 WPA3 热点时,接收端会跳过无效的系统搜索,并自动尝试二维码内经过认证的原局域网地址。
- 手机发送端建立自适应 Wi‑Fi Direct 接入点:Android 10+ 先使用自动频段争取 5 GHz 高速链路;12 秒未收到认证连接时,才以同一 SSID/密码切换至 2.4 GHz 兼容旧机,无需重新扫码。
- 手机互传使用顺序 Range 接收以规避部分 Android 7–9 文件提供器并发读取损坏,并在生成二维码前校验文件选择器报告的大小与实际内容一致。
此阶段只实现 Android → Android;Android ↔ iOS 尚未接入。
## v0.5.0:iOS 客户端全面接入
iOS 端补齐到与 Windows / macOS / Android 对齐的四条链路,**改动只在 `ios/` 目录内,
未触碰 `desktop/` 与 `android/` 的任何实现**:
- **光学接收(电脑 → iPhone)**:Swift 实现的 QFT2 + Base45 + CRC32 解码链路,
AVFoundation 取帧、Vision 解码、与 Android 同一套「居中搜索 → ROI 锁定 →
丢失逐级放大 → 重新搜索」状态机。文件数据只经过屏幕和摄像头,不碰任何网络。
- **iPhone ↔ Windows(专用网络)**:接受只带 Wi-Fi 凭据、不带地址的 QFT Direct 二维码;
有 HotspotConfiguration entitlement 时用 `NEHotspotConfiguration` 自动加入,
没有时显示 SSID/密码引导手动连接——不会假装成功。加入后从 `sysctl` 路由表
认出网关即电脑,判据是协议层 `/qft/ping` 握手成功而非系统回调。
- **iPhone ↔ Mac / Linux(局域网)**:既可扫二维码,也可直接输电脑上的连接码
(`QFTBROWSE3` 广播列出附近的电脑,`POST /qft/pair` 换令牌)。电脑下发改成
**8 路并行 Range + 断点账本**,对端不支持分段时自动回落单流。
- **iPhone ↔ iPhone(隔空)**:沿用 AWDL 点对点 + TLS-PSK,升级为
**多文件队列**(QFTP2P2)。清单不进二维码,只放摘要,扫码依然锁定
「你看到的就是你收到的」。
最低系统 **iOS 15.0**(iPhone 6s 及以后),与 Android 端 minSdk 24 覆盖的机型年代相当;
iOS 16/17 才有的 API 全部走 `ios/QFT/App/Compatibility.swift` 分叉。
详见 [`ios/README.md`](ios/README.md)。核心层 180 项检查可在没有 Xcode 的机器上直接跑:
```bash
./ios/CoreTests/run.sh
```
## v0.4.8:跨平台桌面端 + 电脑 ↔ 电脑互传
### macOS:请用 QFT超速文件传输.app 启动,不要直接跑裸二进制
`./package.sh` 在 macOS 上会同时产出 `QFT超速文件传输`(裸二进制)和
`QFT超速文件传输.app`,**推荐使用 `.app` 版本**。
直接运行裸二进制时,AppKit 的部分行为会不稳定——最典型的是点「选择文件」时
`+[NSOpenPanel openPanel]` 返回 NULL:
```
panicked at objc2-app-kit/src/generated/NSOpenPanel.rs:
unexpected NULL returned from +[NSOpenPanel openPanel]
```
程序侧已经兜住了这个 panic(不会再崩溃,只提示"对话框没有返回结果"),
但要彻底避免,用 `.app` 启动即可。
任何情况下都可以**直接把文件拖进窗口**——拖拽不经过系统文件对话框。
### Windows 构建报 `os error 5 拒绝访问`
```
error: failed to remove file `...\target\release\qft-desktop.exe`
Caused by: 拒绝访问。 (os error 5)
```
**QFT 窗口还开着**,正在运行的 exe 锁住了产物文件。关掉窗口再构建即可。
`VERIFY_WINDOWS_HOST.ps1` 会在构建前检测并询问是否结束进程。
若关掉后仍然报错,通常是 Windows Defender 正在扫描刚生成的 exe,
稍等几秒重试;也可以把 `desktop\target` 加入 Defender 排除目录。
### 防火墙放行(手动)
接收端要监听入站 TCP,Windows 防火墙默认会拦截未授权程序,表现是
「对方能解析连接码但连接一直超时」。
程序在「电脑 ↔ 电脑 → 我要接收」页会**只读检测**防火墙状态,并提供
「放行防火墙(需要管理员授权)」按钮——**提权只在你点击时发生**,
不会在启动时自动弹 UAC。
也可以自己加规则。两个必须注意的点:
1. 二进制已从 `qft-windows.exe` 改名为 `qft-desktop.exe`,**此前给旧名字
放行的规则对新程序不生效**。
2. **profile 必须是 `Any`**。Windows 对没见过的 Wi-Fi 默认归类为
「公用网络」,此时只覆盖 `Private,Domain` 的规则根本不适用——
规则建了、`Get-NetFirewallRule` 也显示 Enabled,但连接照样被拦。
```powershell
$exe = "<完整路径>\qft-desktop.exe"
# 先清掉可能存在的阻止规则:Windows 里 Block 永远优先于 Allow
Get-NetFirewallApplicationFilter -Program $exe -ErrorAction SilentlyContinue |
Get-NetFirewallRule | Where-Object Action -eq 'Block' | Remove-NetFirewallRule
New-NetFirewallRule -DisplayName "QFT Desktop" -Direction Inbound `
-Program $exe -Action Allow -Profile Any
```
排查时先看这两列:
```powershell
Get-NetConnectionProfile | Format-List Name,NetworkCategory
Get-NetFirewallApplicationFilter | Where-Object Program -like "*qft*" |
ForEach-Object { $r = $_ | Get-NetFirewallRule
[PSCustomObject]@{ 规则=$r.DisplayName; 动作=$r.Action; 配置=$r.Profile } } | Format-Table
```
若 `NetworkCategory` 是 `Public` 而规则的 `配置` 只有 `Domain, Private`,
就是这个原因。
管理员 PowerShell:
```powershell
New-NetFirewallRule -DisplayName "QFT Desktop" -Direction Inbound `
-Program "<完整路径>\qft-desktop.exe" -Action Allow -Profile Private,Domain
```
或在「允许应用通过 Windows Defender 防火墙」里勾选 `qft-desktop.exe` 的**专用网络**。
排查顺序:对端 `ping` 不通且 TCP 端口连不上,但 `arp -a` 能看到对方 MAC,
基本可以判定是对端主机在丢包(防火墙),而不是网络不通。
桌面端目录从 `windows/` 改名为 `desktop/`,crate 更名 `qft-desktop`,
**现已可在 macOS / Linux / Windows 三平台编译运行**。平台差异全部收敛在
`desktop/src/platform.rs`(配置目录、下载目录、设备名、Direct AP 能力),
其余模块不再出现 `#[cfg(target_os)]`。
新增两块此前完全缺失的能力:
- `desktop/src/client.rs` —— 桌面端的**发起侧**。此前桌面只有服务端,
`TcpStream::connect` 仅存在于测试中,因此 PC 无法主动连接另一台 PC。
- `desktop/src/discovery.rs` —— 局域网节点浏览(UDP 广播 `QFTBROWSE3`)。
既有的 `QFTDISC2` 是「已知令牌找机器」,用于手机扫码之后;
PC↔PC 没有摄像头,必须先能列出附近有哪些节点。
配对方式:接收方启动后显示 **6 位配对码**,发送方搜索到对方后输入该码
换取会话令牌(`POST /qft/pair`)。6 位约 20 bit 熵,靠严格失败计数兜底——
错 5 次即作废整个码,需要重新启动接收。
已知限制:UDP 广播只覆盖同一广播域,跨网段或开了 AP 隔离的 Wi-Fi
搜索不到对方,此时在界面上手动输入对方 IP。
## v0.4 光学链路改动 ## v0.4 光学链路改动
@@ -93,7 +251,7 @@ Windows 光传页面已经改成“二维码优先”:
推荐初次真机测试从 **30 FPS** 开始,看 Android 的“新帧/s”,再切 45、60。目标不是 Windows 数字最大,而是 Android **实际新帧/s 最大**。 推荐初次真机测试从 **30 FPS** 开始,看 Android 的“新帧/s”,再切 45、60。目标不是 Windows 数字最大,而是 Android **实际新帧/s 最大**。
## Android → Windows ## 扫码本地直传(Android ↔ Windows)
v0.3 的稳定性优化继续保留: v0.3 的稳定性优化继续保留:
@@ -104,9 +262,10 @@ v0.3 的稳定性优化继续保留:
- gateway / endpoint / 当前子网 fallback; - gateway / endpoint / 当前子网 fallback;
- HTTP 请求明确绑定扫码建立的 `Network`; - HTTP 请求明确绑定扫码建立的 `Network`;
- 配网请求在传输页持续持有,仅返回首页时释放;短暂网络波动会自动接入新的 `Network`; - 配网请求在传输页持续持有,仅返回首页时释放;短暂网络波动会自动接入新的 `Network`;
- 上传与下载单文件均最高 8 worker 并行; - 手机上传和电脑下发均以 8 路为目标并发数;
- 4/8/16 MiB 自适应上传块; - 64 KiB–16 MiB 自适应分块;
- 16 MiB 有界 Range 并行下载,完成位图支持掉线/重启后只补缺块; - 电脑下发使用精确 Range 响应,手机以 `.qftpart` + 位图断点续传;
- 手机上传使用定位写入和幂等完成确认;
- Windows positioned writes + `.qftpart` + SHA-256 + 最终 rename。 - Windows positioned writes + `.qftpart` + SHA-256 + 最终 rename。
## Android 版本 ## Android 版本
@@ -121,7 +280,7 @@ v0.3 的稳定性优化继续保留:
### Windows ### Windows
```powershell ```powershell
cd windows cd desktop
cargo check cargo check
cargo test cargo test
cargo build --release cargo build --release
@@ -143,7 +302,7 @@ APK:
## 一键打包 ## 一键打包
脚本只打包 `windows/` 下的 Rust 桌面端:执行 `cargo test` 和 `cargo build --release`,随后把 Rust 二进制、协议说明和 SHA-256 校验文件收集到带时间戳的 `dist/QFT-Rust-*` 目录并生成压缩包。脚本不检查、下载或调用 Android SDK、Java、Gradle: 脚本执行锁定依赖的 Rust 测试和正式构建,随后把桌面程序、中文说明、协议及 SHA-256 校验收集到带时间戳的 `dist/QFT-正式版-*` 目录。脚本不会安装、下载或调用 Android SDK、Java、Gradle;如果已经在 Windows 上构建好 APK,则会自动将它收集进同一个中文正式包:
```bat ```bat
package.bat package.bat
@@ -155,7 +314,7 @@ package.bat
## 字体 ## 字体
Windows UI 优先读取 `windows/assets/qft-ui.ttf`,也可用 `QFT_FONT_PATH` 指向你自己的中文 TTF。仓库不附带第三方字体文件。 桌面端 UI 优先读取 `desktop/assets/qft-ui.ttf`,也可用 `QFT_FONT_PATH` 指向你自己的中文 TTF。仓库不附带第三方字体文件。
## 自动验证 ## 自动验证
+35
View File
@@ -0,0 +1,35 @@
# QFT 超速文件传输 v0.4.16 正式版
这是 Windows 与 Android 双端统一版本号的中文正式版。
## 本版重点
- Windows 扫码直传默认保持普通并排布局,专注二维码模式改为用户手动进入。
- 优化直传控制、防火墙、二维码、连接状态区域布局,减少无效留白。
- Windows 自动创建 QFT 专用 Wi-Fi Direct 网络,二维码不再强制携带电脑既有网卡地址。
- Android 连接专用 Wi-Fi 后立即并行探测实际网关与当前子网,缩短“搜索电脑”时间。
- Windows 已确认防火墙规则后复用检测结果,并移除专用网络启动后的固定等待。
- Android 文件选择直接打开系统文件选择器,支持队列删除和传输前拖动排序。
- Android 拖动采用松手后一次性提交顺序,修复部分厂商系统点击拖动闪退。
- PC 接收完成后不再残留“预计剩余 <1 秒”,改为显示最终平均速度。
## 版本信息
- Windows 桌面端:`0.4.16`
- Android 端:`0.4.16`(versionCode 23)
- 最低 Android 版本:Android 7.0(API 24)
- Windows:Windows 10/11 x64,使用 QFT Direct 时需要支持 Wi-Fi Direct 的无线网卡
## 中文封版打包
- Windows:运行 `package.bat`。
- macOS/Linux:运行 `./package.sh`。
- 打包脚本会执行 Rust 锁定依赖测试与正式构建,生成中文文件名、中文说明和 SHA-256 校验文件。
- 脚本不会安装、下载或调用 Android SDK/Gradle;如果 Windows 上已经生成 APK,会自动收集到同一个正式包中。
## 验证状态
- Rust Windows 目标 `cargo check` 通过。
- Rust 桌面端 71 项自动测试通过。
- Android 配对协议、并行传输及兼容性静态检查通过。
- Windows Wi-Fi Direct 与 Android 相机属于硬件链路,最终安装包仍应在目标 Windows 电脑和实际 Android 手机上完成一次扫码传输验收。
+11 -9
View File
@@ -1,12 +1,12 @@
# QFT v0.4.6 test report # QFT v0.4.16 test report
Date: 2026-08-10 Date: 2026-08-12
This report separates **tests actually executed in the current environment** from **physical hardware acceptance that cannot be simulated here**. This report separates **tests actually executed in the current environment** from **physical hardware acceptance that cannot be simulated here**.
## What this RC changes ## What this release changes
The v0.4.6 optical path is deliberately simpler than v0.3: The v0.4.16 optical path is deliberately simpler than v0.3:
- 2×2 / 4-channel QR removed; - 2×2 / 4-channel QR removed;
- one large QR only; - one large QR only;
@@ -21,6 +21,8 @@ The v0.4.6 optical path is deliberately simpler than v0.3:
- Windows draggable split pane / focus-QR mode. - Windows draggable split pane / focus-QR mode.
Android→Windows QFTPAIR2/discovery/parallel upload remains and is regression-tested. Android→Windows QFTPAIR2/discovery/parallel upload remains and is regression-tested.
The release also adds immediate gateway/subnet probing after dedicated Wi-Fi association,
crash-safe Android queue reordering, and a completed PC receive state without stale ETA text.
## Executed and passed ## Executed and passed
@@ -152,7 +154,7 @@ The guard models the Windows single-QR 1024×1024 RGBA pre-render queue:
This is a design-budget check, not an OS-enforced RSS hard cap. GPU/runtime allocators can add platform-specific memory. This is a design-budget check, not an OS-enforced RSS hard cap. GPU/runtime allocators can add platform-specific memory.
## Important implementation decisions validated during v0.4.6 ## Important implementation decisions validated during v0.4.16
### QFT2 uses Result.text, not ZXing rawBytes ### QFT2 uses Result.text, not ZXing rawBytes
@@ -160,7 +162,7 @@ The active path is Base45 text. Android reconstructs the QFT binary frame from `
### Duplicate camera hits are not duplicate assembler work ### Duplicate camera hits are not duplicate assembler work
At 45/60 display FPS, a camera can observe the same displayed QR in multiple exposures. v0.4.6 still counts every successful decode in diagnostics, but only a changed QFT2 text fingerprint is delivered to `SessionAssembler`. At 45/60 display FPS, a camera can observe the same displayed QR in multiple exposures. v0.4.16 still counts every successful decode in diagnostics, but only a changed QFT2 text fingerprint is delivered to `SessionAssembler`.
### AF/AE does not run on a fixed periodic timer ### AF/AE does not run on a fixed periodic timer
@@ -168,16 +170,16 @@ The scanner performs initial focus/metering, then re-meters after first lock or
## Not executable in this environment ## Not executable in this environment
The current generation environment does not contain the Windows MSVC Rust toolchain, Android SDK, a physical Android camera, a Windows display or a Windows Wi-Fi Direct adapter. Therefore the following are **not claimed as passed here**: The current generation environment does not contain the Windows MSVC Rust toolchain, Android SDK, a physical Android camera, a Windows display or a Windows Wi-Fi Direct adapter. The Windows GNU target `cargo check`, native desktop release build and 71 Rust tests passed, but the following are **not claimed as passed here**:
1. Windows `cargo check/test/build --release` for v0.4.6. 1. Linking and running the final Windows `.exe` on a real Windows host.
2. Android Gradle `:app:testDebugUnitTest :app:assembleDebug` against the real Android SDK. 2. Android Gradle `:app:testDebugUnitTest :app:assembleDebug` against the real Android SDK.
3. Actual 30/45/60 displayed FPS → CameraX/ZXing effective new-frame throughput. 3. Actual 30/45/60 displayed FPS → CameraX/ZXing effective new-frame throughput.
4. Lock acquisition/reacquisition timing on Android 7 and different phone camera pipelines. 4. Lock acquisition/reacquisition timing on Android 7 and different phone camera pipelines.
5. PreviewView overlay mapping on every OEM sensor/crop/rotation combination. 5. PreviewView overlay mapping on every OEM sensor/crop/rotation combination.
6. Real Windows QFT Direct adapter / driver / firewall behavior. 6. Real Windows QFT Direct adapter / driver / firewall behavior.
The package remains an **RC** until those physical checks pass. The source is sealed as **v0.4.16**. The Windows executable and Android APK still require the physical acceptance below before public binary distribution.
## Required physical acceptance ## Required physical acceptance
+9 -3
View File
@@ -1,5 +1,11 @@
QFT v0.4.6 test results QFT v0.4.16 test results
UTC 2026-08-10T08:45:56Z Updated 2026-08-12 Asia/Shanghai
== v0.4.16 release increment ==
PASS Windows GNU target cargo check
PASS native desktop cargo test: 71 passed, 0 failed
PASS native desktop cargo build --release --locked
PASS Chinese release package generation with SHA-256 manifest
== protocol_selftest.py == == protocol_selftest.py ==
PASS QFT2/Base45 single-QR: 1200123 bytes, 2667 chunks, 22% frame loss, recovered in 6 rounds; QR-L v15 vs legacy Base64 v18, 12px/module@1024, text=722 chars, theoretical payload=26.4 KiB/s PASS QFT2/Base45 single-QR: 1200123 bytes, 2667 chunks, 22% frame loss, recovered in 6 rounds; QR-L v15 vs legacy Base64 v18, 12px/module@1024, text=722 chars, theoretical payload=26.4 KiB/s
@@ -16,7 +22,7 @@ PASS loopback Parallel v2 integration: UDP discovery + HTTP auth + 6 out-of-orde
== memory_budget_selftest.py == == memory_budget_selftest.py ==
PASS memory budget: single-QR cache=192 frames/768.0 MiB + 96 MiB transient allowance < 1100 MiB PASS memory budget: single-QR cache=192 frames/768.0 MiB + 96 MiB transient allowance < 1100 MiB
== android_compat_selftest.py == == android_compat_selftest.py ==
PASS Android static guards: API24+, 640x480 single-QR ROI, reusable luma buffer, QFT2/Base45 text parse, dynamic lock/refocus, Camera2 FPS request, legacy/new Wi-Fi compatibility PASS Android static guards: API24+, fast-pair/subnet discovery, crash-safe sortable upload queue, QFT2/Base45, dynamic lock/refocus, legacy/new Wi-Fi compatibility
== single_channel_guard_selftest.py == == single_channel_guard_selftest.py ==
PASS single-channel guard: one large QFT2/Base45 QR, 450B chunks, no 2x2/4-lane path, Android locked-ROI text decode only PASS single-channel guard: one large QFT2/Base45 QR, 450B chunks, no 2x2/4-lane path, Android locked-ROI text decode only
== kotlin_host_smoke.py == == kotlin_host_smoke.py ==
+23 -4
View File
@@ -1,7 +1,7 @@
$ErrorActionPreference = 'Stop' $ErrorActionPreference = 'Stop'
$Root = Split-Path -Parent $MyInvocation.MyCommand.Path $Root = Split-Path -Parent $MyInvocation.MyCommand.Path
Write-Host "== QFT v0.4.6 Windows host verification ==" -ForegroundColor Cyan Write-Host "== QFT v0.4.16 Windows host verification ==" -ForegroundColor Cyan
if (Get-Command python -ErrorAction SilentlyContinue) { if (Get-Command python -ErrorAction SilentlyContinue) {
Write-Host "[1/4] Core protocol/selftests" Write-Host "[1/4] Core protocol/selftests"
@@ -14,8 +14,27 @@ if (Get-Command python -ErrorAction SilentlyContinue) {
Write-Warning "python not found; skipping repository Python selftests" Write-Warning "python not found; skipping repository Python selftests"
} }
Write-Host "[2/4] Windows Rust compile/test/release" Write-Host "[2/4] Desktop Rust compile/test/release"
Push-Location "$Root\windows"
# 正在运行的 qft-desktop.exe 会锁住产物文件,cargo 只会抛出
# "failed to remove file ... 拒绝访问 (os error 5)" 这种看不出原因的错误。
# 这里提前识别并说清楚,而不是让用户去猜。
$Running = Get-Process -Name 'qft-desktop' -ErrorAction SilentlyContinue
if ($Running) {
Write-Host ""
Write-Warning "检测到 qft-desktop.exe 正在运行(PID: $($Running.Id -join ', '))。"
Write-Warning "它会锁住 target\release\qft-desktop.exe,导致构建报 'os error 5 拒绝访问'。"
$Answer = Read-Host "是否结束这些进程后继续构建?(y/N)"
if ($Answer -eq 'y' -or $Answer -eq 'Y') {
$Running | Stop-Process -Force
Start-Sleep -Milliseconds 500
Write-Host "已结束,继续构建。"
} else {
throw "请先关闭 QFT 窗口再重新运行本脚本"
}
}
Push-Location "$Root\desktop"
try { try {
& cargo check & cargo check
if ($LASTEXITCODE -ne 0) { throw "cargo check failed" } if ($LASTEXITCODE -ne 0) { throw "cargo check failed" }
@@ -37,7 +56,7 @@ try {
} finally { Pop-Location } } finally { Pop-Location }
Write-Host "[4/4] Artifact locations" -ForegroundColor Cyan Write-Host "[4/4] Artifact locations" -ForegroundColor Cyan
Write-Host "Windows EXE: $Root\windows\target\release\qft-windows.exe" Write-Host "Windows EXE: $Root\desktop\target\release\qft-desktop.exe"
Write-Host "Android APK: $Root\android\app\build\outputs\apk\debug\app-debug.apk" Write-Host "Android APK: $Root\android\app\build\outputs\apk\debug\app-debug.apk"
Write-Host "`nHOST BUILD VERIFICATION PASSED" -ForegroundColor Green Write-Host "`nHOST BUILD VERIFICATION PASSED" -ForegroundColor Green
Write-Host "Next: perform the physical display/camera and Wi-Fi Direct acceptance matrix in TEST_REPORT.md." Write-Host "Next: perform the physical display/camera and Wi-Fi Direct acceptance matrix in TEST_REPORT.md."
+6 -2
View File
@@ -12,8 +12,8 @@ android {
applicationId = "com.qft.optical" applicationId = "com.qft.optical"
minSdk = 24 minSdk = 24
targetSdk = 35 targetSdk = 35
versionCode = 18 versionCode = 28
versionName = "0.4.6" versionName = "0.5.0-dev5"
testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
} }
@@ -36,6 +36,10 @@ android {
kotlinOptions { kotlinOptions {
jvmTarget = "17" jvmTarget = "17"
} }
buildFeatures {
buildConfig = true
}
} }
dependencies { dependencies {
+3
View File
@@ -6,11 +6,14 @@
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" /> <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" /> <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" /> <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<!-- WifiLock 需要:传输期间阻止 Wi-Fi 进入省电休眠 -->
<uses-permission android:name="android.permission.WAKE_LOCK" />
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE" /> <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" android:maxSdkVersion="32" /> <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" android:maxSdkVersion="32" />
<uses-permission android:name="android.permission.NEARBY_WIFI_DEVICES" android:usesPermissionFlags="neverForLocation" /> <uses-permission android:name="android.permission.NEARBY_WIFI_DEVICES" android:usesPermissionFlags="neverForLocation" />
<uses-feature android:name="android.hardware.camera.any" android:required="true" /> <uses-feature android:name="android.hardware.camera.any" android:required="true" />
<uses-feature android:name="android.hardware.wifi" android:required="false" /> <uses-feature android:name="android.hardware.wifi" android:required="false" />
<uses-feature android:name="android.hardware.wifi.direct" android:required="false" />
<application <application
android:allowBackup="false" android:allowBackup="false"
@@ -16,6 +16,7 @@ import java.io.OutputStream
import java.io.RandomAccessFile import java.io.RandomAccessFile
import java.net.HttpURLConnection import java.net.HttpURLConnection
import java.net.URL import java.net.URL
import java.nio.ByteBuffer
import java.security.MessageDigest import java.security.MessageDigest
import java.util.concurrent.Executors import java.util.concurrent.Executors
import java.util.concurrent.atomic.AtomicInteger import java.util.concurrent.atomic.AtomicInteger
@@ -29,16 +30,108 @@ object DownloadClient {
private const val TAG = "QftDownload" private const val TAG = "QftDownload"
private const val BUFFER_SIZE = 1024 * 1024 private const val BUFFER_SIZE = 1024 * 1024
private const val SERIAL_ATTEMPTS = 3 private const val SERIAL_ATTEMPTS = 3
private const val RANGE_ATTEMPTS = 10 // Kept only for the old sequential compatibility path below. New direct
// sessions always use the concurrent Range downloader.
private const val PARALLEL_MIN_FILE_SIZE = 32L * 1024L * 1024L private const val PARALLEL_MIN_FILE_SIZE = 32L * 1024L * 1024L
private const val PARALLEL_CHUNK_SIZE = 16L * 1024L * 1024L private const val PARALLEL_CHUNK_SIZE = 16L * 1024L * 1024L
private const val MAX_WORKERS = 8 private const val MAX_WORKERS = 8
private const val RANGE_WORKERS = 8
private const val RANGE_ATTEMPTS = 5
private const val MIN_RANGE_CHUNK = 64L * 1024L
private const val MAX_RANGE_CHUNK = 16L * 1024L * 1024L
/** 整份重下的轮数。仅在 SHA-256 不匹配(缓存已损坏)时才会用到第二轮。 */ /** 整份重下的轮数。仅在 SHA-256 不匹配(缓存已损坏)时才会用到第二轮。 */
private const val VERIFY_ROUNDS = 2 private const val VERIFY_ROUNDS = 2
/** 落盘阶段的失败与「下载失败」是两回事,用独立异常类型区分。 */ /** 落盘阶段的失败与「下载失败」是两回事,用独立异常类型区分。 */
class SaveFailure(message: String, cause: Throwable?) : Exception(message, cause) class SaveFailure(message: String, cause: Throwable?) : Exception(message, cause)
/** Persistent received-range map. The data file is preallocated, so its
* length is not used as a completion signal; only an atomically replaced
* map entry marks a range safe to resume. */
private class ChunkLedger private constructor(
private val partial: File,
private val map: File,
private val size: Long,
val chunkSize: Long,
val totalChunks: Int,
private val completed: BooleanArray,
) {
private val lock = Any()
fun isComplete(index: Int): Boolean = synchronized(lock) { completed[index] }
fun allComplete(): Boolean = synchronized(lock) { completed.all { it } }
fun bytesComplete(): Long = synchronized(lock) {
completed.indices.sumOf { index -> if (completed[index]) chunkLength(index) else 0L }
}
fun chunkOffset(index: Int): Long = index.toLong() * chunkSize
fun chunkLength(index: Int): Long = minOf(chunkSize, size - chunkOffset(index))
fun markComplete(index: Int) = synchronized(lock) {
if (!completed[index]) {
completed[index] = true
persistLocked()
}
}
fun discard() = synchronized(lock) {
partial.delete()
map.delete()
File("${map.path}.tmp").delete()
}
private fun persistLocked() {
val temp = File("${map.path}.tmp")
temp.bufferedWriter().use { writer ->
writer.appendLine("$size:$chunkSize:$totalChunks")
writer.write(buildString(totalChunks) {
completed.forEach { append(if (it) '1' else '0') }
})
}
if (map.exists()) map.delete()
if (!temp.renameTo(map)) {
temp.copyTo(map, overwrite = true)
temp.delete()
}
}
companion object {
fun open(partial: File, size: Long, chunkSize: Long): ChunkLedger {
val totalLong = if (size == 0L) 0L else (size + chunkSize - 1L) / chunkSize
require(totalLong <= Int.MAX_VALUE) { "文件分块数过大" }
val total = totalLong.toInt()
val map = File("${partial.path}.map")
val restored = runCatching {
val pieces = map.readText().split('\n', limit = 2)
val header = pieces.firstOrNull()?.split(':') ?: emptyList()
val bits = pieces.getOrNull(1).orEmpty()
if (
partial.length() == size && header.size == 3 &&
header[0].toLong() == size && header[1].toLong() == chunkSize &&
header[2].toInt() == total && bits.length >= total
) {
BooleanArray(total) { bits[it] == '1' }
} else {
null
}
}.getOrNull()
val ledger = ChunkLedger(partial, map, size, chunkSize, total, restored ?: BooleanArray(total))
if (restored == null) {
partial.parentFile?.let { if (!it.exists()) it.mkdirs() }
RandomAccessFile(partial, "rw").use { file ->
file.setLength(0L)
file.setLength(size)
}
ledger.persistLocked()
}
return ledger
}
}
}
fun download( fun download(
context: Context, context: Context,
resolver: ContentResolver, resolver: ContentResolver,
@@ -57,12 +150,9 @@ object DownloadClient {
val expectedName = requireNotNull(pairing.fileName) val expectedName = requireNotNull(pairing.fileName)
val expectedSize = requireNotNull(pairing.fileSize) val expectedSize = requireNotNull(pairing.fileSize)
val expectedSha = requireNotNull(pairing.sha256) val expectedSha = requireNotNull(pairing.sha256)
val partial = partialFile(context, pairing.session) val partial = partialFile(context, pairing.session, pairing.downloadPath)
partial.parentFile?.let { if (!it.exists() && !it.mkdirs()) error("无法创建接收缓存目录") } partial.parentFile?.let { if (!it.exists() && !it.mkdirs()) error("无法创建接收缓存目录") }
if (partial.length() > expectedSize) { if (partial.length() > expectedSize) discardTransferState(partial)
partial.delete()
completionMapFile(partial).delete()
}
// 落盘时缓存文件与目标文件同时存在,需要约 2 倍空间。 // 落盘时缓存文件与目标文件同时存在,需要约 2 倍空间。
// 不预检的话,这里会在下载 100% 之后才失败,用户看到的是「快结束时失败」。 // 不预检的话,这里会在下载 100% 之后才失败,用户看到的是「快结束时失败」。
@@ -83,17 +173,15 @@ object DownloadClient {
// 这一步失败与网络无关,重下多少次都没用,直接如实报错 // 这一步失败与网络无关,重下多少次都没用,直接如实报错
throw SaveFailure("文件已完整收到,但保存到 Downloads/QFT 失败:${failureDetail(e)}", e) throw SaveFailure("文件已完整收到,但保存到 Downloads/QFT 失败:${failureDetail(e)}", e)
} }
partial.delete() discardTransferState(partial)
completionMapFile(partial).delete()
Log.i(TAG, "completed size=$expectedSize") Log.i(TAG, "completed size=$expectedSize")
return result return result
} }
Log.w(TAG, "sha mismatch round=${round + 1}/$VERIFY_ROUNDS expected=$expectedSha actual=$actual") Log.w(TAG, "sha mismatch round=${round + 1}/$VERIFY_ROUNDS expected=$expectedSha actual=$actual")
partial.delete() discardTransferState(partial)
completionMapFile(partial).delete()
if (round + 1 >= VERIFY_ROUNDS) { if (round + 1 >= VERIFY_ROUNDS) {
error("文件校验失败:重新完整下载后 SHA-256 仍不匹配,请让电脑重新生成二维码") error("文件校验失败:重新完整下载后 SHA-256 仍不匹配,请让发送端重新创建传输")
} }
onPhase("校验未通过,正在重新完整下载…") onPhase("校验未通过,正在重新完整下载…")
} }
@@ -101,7 +189,8 @@ object DownloadClient {
} }
/** 传输阶段:断点续传 + 有限重试。只有这一段的失败才算「下载失败」。 */ /** 传输阶段:断点续传 + 有限重试。只有这一段的失败才算「下载失败」。 */
private fun receiveUntilComplete( @Suppress("unused")
private fun receiveSequentialCompatibility(
networkProvider: () -> Network?, networkProvider: () -> Network?,
baseUrl: String, baseUrl: String,
pairing: PairingPayload, pairing: PairingPayload,
@@ -290,7 +379,7 @@ object DownloadClient {
abortReason: () -> String?, abortReason: () -> String?,
) { ) {
val end = start + length - 1L val end = start + length - 1L
val conn = open(network, URL("$baseUrl/qft/download")) val conn = open(network, URL(baseUrl + pairing.downloadPath))
try { try {
conn.requestMethod = "GET" conn.requestMethod = "GET"
conn.connectTimeout = 8_000 conn.connectTimeout = 8_000
@@ -377,7 +466,7 @@ object DownloadClient {
onProgress: (received: Long, total: Long) -> Unit, onProgress: (received: Long, total: Long) -> Unit,
) { ) {
val requestedOffset = partial.length().coerceIn(0L, expectedSize) val requestedOffset = partial.length().coerceIn(0L, expectedSize)
val conn = open(network, URL("$baseUrl/qft/download")) val conn = open(network, URL(baseUrl + pairing.downloadPath))
try { try {
conn.requestMethod = "GET" conn.requestMethod = "GET"
conn.connectTimeout = 5_000 conn.connectTimeout = 5_000
@@ -393,7 +482,7 @@ object DownloadClient {
val resumed = code == HttpURLConnection.HTTP_PARTIAL val resumed = code == HttpURLConnection.HTTP_PARTIAL
if (code != HttpURLConnection.HTTP_OK && !resumed) { if (code != HttpURLConnection.HTTP_OK && !resumed) {
val message = try { conn.errorStream?.bufferedReader()?.use { it.readText().take(300) } } catch (_: Exception) { null } val message = try { conn.errorStream?.bufferedReader()?.use { it.readText().take(300) } } catch (_: Exception) { null }
error("电脑下载服务返回 HTTP $code${message?.let { ": $it" } ?: ""}") error("发送端下载服务返回 HTTP $code${message?.let { ": $it" } ?: ""}")
} }
// Older desktop binaries return 200 even with Range. Restart only // Older desktop binaries return 200 even with Range. Restart only
@@ -446,6 +535,194 @@ object DownloadClient {
} }
/** 校验也要报进度:大文件读一整遍是好几秒,静默的话看起来就是卡在 100%。 */ /** 校验也要报进度:大文件读一整遍是好几秒,静默的话看起来就是卡在 100%。 */
private fun receiveUntilComplete(
networkProvider: () -> Network?,
baseUrl: String,
pairing: PairingPayload,
deviceName: String,
partial: File,
expectedSize: Long,
abortReason: () -> String?,
onProgress: (received: Long, total: Long) -> Unit,
) {
val ledger = ChunkLedger.open(partial, expectedSize, desiredRangeChunkSize(expectedSize))
val initial = ledger.bytesComplete()
onProgress(initial, expectedSize)
if (ledger.allComplete()) return
// Some Android 7–9 DocumentsProvider implementations expose a stream
// that is individually seekable but corrupts data when the same URI is
// opened concurrently. Phone → phone therefore downloads its ranges in
// deterministic order on one worker. PC senders keep the 8-way path.
val workerLimit = if (pairing.downloadPath.startsWith("/qft/phone/download/")) 1 else RANGE_WORKERS
val workers = ledger.totalChunks.coerceAtMost(workerLimit).coerceAtLeast(1)
Log.i(TAG, "parallel start: chunks=${ledger.totalChunks}, workers=$workers, completed=$initial/$expectedSize")
val pool = Executors.newFixedThreadPool(workers)
val next = AtomicInteger(0)
val futures = (0 until workers).map {
pool.submit {
while (!Thread.currentThread().isInterrupted) {
abortReason()?.let { error(it) }
val index = next.getAndIncrement()
if (index >= ledger.totalChunks) break
if (ledger.isComplete(index)) continue
receiveRangeWithRetry(
networkProvider,
baseUrl,
pairing,
deviceName,
partial,
expectedSize,
ledger,
index,
abortReason,
)
onProgress(ledger.bytesComplete(), expectedSize)
}
}
}
try {
futures.forEach { future -> future.get() }
} catch (e: Exception) {
futures.forEach { it.cancel(true) }
throw (e.cause ?: e)
} finally {
pool.shutdownNow()
}
// Flushing every parallel range serializes the workers on Android's
// storage barrier and can make Wi-Fi look much slower than it is. One
// barrier after all ranges preserves the completed-file durability;
// SHA-256 still rejects and re-downloads an interrupted/corrupt cache.
RandomAccessFile(partial, "rw").use { it.fd.sync() }
if (!ledger.allComplete()) {
error("并行下载未完成:${ledger.bytesComplete()}/$expectedSize")
}
Log.i(TAG, "parallel complete: chunks=${ledger.totalChunks}, bytes=$expectedSize")
}
private fun receiveRangeWithRetry(
networkProvider: () -> Network?,
baseUrl: String,
pairing: PairingPayload,
deviceName: String,
partial: File,
expectedSize: Long,
ledger: ChunkLedger,
index: Int,
abortReason: () -> String?,
) {
var last: Exception? = null
repeat(RANGE_ATTEMPTS) { attempt ->
abortReason()?.let { throw IllegalStateException(it, last) }
try {
receiveRange(
networkProvider(),
baseUrl,
pairing,
deviceName,
partial,
expectedSize,
ledger,
index,
)
ledger.markComplete(index)
return
} catch (e: Exception) {
last = e
Log.w(
TAG,
"range=$index/${ledger.totalChunks} attempt=${attempt + 1}/$RANGE_ATTEMPTS failed: ${failureDetail(e)}",
e,
)
if (attempt + 1 < RANGE_ATTEMPTS) {
try {
Thread.sleep(180L * (attempt + 1))
} catch (interrupted: InterruptedException) {
Thread.currentThread().interrupt()
throw e
}
}
}
}
throw IllegalStateException(
"分块 $index 下载失败,已重试 $RANGE_ATTEMPTS 次:${failureDetail(last)}",
last,
)
}
private fun receiveRange(
network: Network?,
baseUrl: String,
pairing: PairingPayload,
deviceName: String,
partial: File,
expectedSize: Long,
ledger: ChunkLedger,
index: Int,
) {
val offset = ledger.chunkOffset(index)
val length = ledger.chunkLength(index)
val end = offset + length - 1L
val conn = open(network, URL(baseUrl + pairing.downloadPath))
try {
conn.requestMethod = "GET"
conn.connectTimeout = 5_000
conn.readTimeout = 20_000
conn.useCaches = false
conn.setRequestProperty("Connection", "close")
conn.setRequestProperty("X-QFT-Token", pairing.session)
conn.setRequestProperty("X-QFT-Device", Base64Url.encode(deviceName.toByteArray(Charsets.UTF_8)))
conn.setRequestProperty("Range", "bytes=$offset-$end")
val code = conn.responseCode
if (code != HttpURLConnection.HTTP_PARTIAL) {
val message = try { conn.errorStream?.bufferedReader()?.use { it.readText().take(300) } } catch (_: Exception) { null }
error("发送端下载服务未返回 Range(HTTP $code)${message?.let { ": $it" } ?: ""}")
}
val expectedRange = "bytes $offset-$end/$expectedSize"
if (conn.getHeaderField("Content-Range") != expectedRange) {
error("下载服务返回了无效范围:${conn.getHeaderField("Content-Range")}")
}
if (conn.contentLengthLong >= 0L && conn.contentLengthLong != length) {
error("分块 $index 长度不匹配:${conn.contentLengthLong} != $length")
}
var received = 0L
conn.inputStream.use { input ->
RandomAccessFile(partial, "rw").use { output ->
output.channel.use { channel ->
channel.position(offset)
val buffer = ByteArray(BUFFER_SIZE)
while (received < length) {
val n = input.read(buffer, 0, minOf(buffer.size.toLong(), length - received).toInt())
if (n < 0) break
if (n == 0) continue
val bytes = ByteBuffer.wrap(buffer, 0, n)
while (bytes.hasRemaining()) channel.write(bytes)
received += n.toLong()
}
}
}
}
if (received != length) error("分块 $index 提前结束:$received/$length")
Log.d(TAG, "range=$index/${ledger.totalChunks} complete bytes=$length")
} finally {
conn.disconnect()
}
}
private fun desiredRangeChunkSize(fileSize: Long): Long {
if (fileSize <= 0L) return MIN_RANGE_CHUNK
return ((fileSize + RANGE_WORKERS - 1L) / RANGE_WORKERS)
.coerceIn(MIN_RANGE_CHUNK, MAX_RANGE_CHUNK)
}
private fun discardTransferState(partial: File) {
partial.delete()
File("${partial.path}.map").delete()
File("${partial.path}.map.tmp").delete()
}
private fun sha256(file: File, onProgress: (Long, Long) -> Unit): String { private fun sha256(file: File, onProgress: (Long, Long) -> Unit): String {
val digest = MessageDigest.getInstance("SHA-256") val digest = MessageDigest.getInstance("SHA-256")
val total = file.length() val total = file.length()
@@ -511,9 +788,13 @@ object DownloadClient {
} }
} }
private fun partialFile(context: Context, session: String): File { private fun partialFile(context: Context, session: String, downloadPath: String): File {
val root = context.getExternalFilesDir("qft") ?: context.cacheDir val root = context.getExternalFilesDir("qft") ?: context.cacheDir
return File(root, "$session.qftpart") val suffix = MessageDigest.getInstance("SHA-256")
.digest(downloadPath.toByteArray(Charsets.UTF_8))
.take(6)
.joinToString("") { byte -> "%02x".format(byte.toInt() and 0xFF) }
return File(root, "$session-$suffix.qftpart")
} }
private fun createTarget(resolver: ContentResolver, name: String): DownloadTarget { private fun createTarget(resolver: ContentResolver, name: String): DownloadTarget {
@@ -0,0 +1,67 @@
package com.qft.optical
import java.net.URI
/** Pure IPv4 routing helpers kept Android-free so candidate selection is testable. */
object EndpointRouting {
/**
* A dedicated QFT Wi-Fi must never reuse QR/LAN adapter addresses. Its only
* direct candidates are gateways supplied by Android for that exact Network.
* Current-LAN fallback mode may additionally use advertised same-subnet IPs.
*/
fun afterConnection(
dedicatedWifi: Boolean,
gatewayEndpoints: List<String>,
routedAdvertisedEndpoints: List<String>,
): List<String> = if (dedicatedWifi) {
gatewayEndpoints.distinct()
} else {
(gatewayEndpoints + routedAdvertisedEndpoints).distinct()
}
/** Same isolation rule for retry/recovery after the first gateway probe. */
fun forRecovery(
dedicatedWifi: Boolean,
discoveredEndpoint: String?,
gatewayEndpoints: List<String>,
advertisedEndpoints: List<String>,
): List<String> {
val candidates = listOfNotNull(discoveredEndpoint) + gatewayEndpoints
return (candidates + if (dedicatedWifi) emptyList() else advertisedEndpoints).distinct()
}
fun onAnySubnet(
endpoints: List<String>,
expectedPort: Int,
localLinks: List<Pair<String, Int>>,
): List<String> {
val subnets = localLinks.mapNotNull { (address, prefix) ->
ipv4(address)?.let { it to prefix.coerceIn(0, 32) }
}
if (subnets.isEmpty()) return emptyList()
return endpoints.filter { endpoint ->
val uri = try { URI(endpoint) } catch (_: Exception) { return@filter false }
if (uri.scheme != "http" || uri.port != expectedPort) return@filter false
val candidate = ipv4(uri.host ?: return@filter false) ?: return@filter false
subnets.any { (local, prefix) -> sameSubnet(local, candidate, prefix) }
}.distinct()
}
private fun sameSubnet(a: Long, b: Long, prefix: Int): Boolean {
if (prefix == 0) return true
val mask = (0xFFFF_FFFFL shl (32 - prefix)) and 0xFFFF_FFFFL
return (a and mask) == (b and mask)
}
private fun ipv4(value: String): Long? {
val parts = value.split('.')
if (parts.size != 4) return null
var result = 0L
for (part in parts) {
val octet = part.toIntOrNull()?.takeIf { it in 0..255 } ?: return null
result = (result shl 8) or octet.toLong()
}
return result
}
}
File diff suppressed because it is too large Load Diff
@@ -21,23 +21,29 @@ data class PairingPayload(
val fileName: String? = null, val fileName: String? = null,
val fileSize: Long? = null, val fileSize: Long? = null,
val sha256: String? = null, val sha256: String? = null,
/** Internal per-file route used by Android → Android manifests. QR input
* never controls this value; parsed pairing codes always use the default. */
val downloadPath: String = "/qft/download",
) )
enum class TransferDirection { UPLOAD_TO_PC, DOWNLOAD_TO_PHONE } enum class TransferDirection { UPLOAD_TO_PC, DOWNLOAD_TO_PHONE, PHONE_TO_PHONE }
object PairingProtocol { object PairingProtocol {
const val PREFIX_V2 = "QFTPAIR2:" const val PREFIX_V2 = "QFTPAIR2:"
const val PREFIX_SEND_V2 = "QFTSEND2:" const val PREFIX_SEND_V2 = "QFTSEND2:"
const val PREFIX_PHONE_V2 = "QFTPHONE2:"
const val PREFIX_V1 = "QFTPAIR1:" const val PREFIX_V1 = "QFTPAIR1:"
fun isPairingText(text: String): Boolean = fun isPairingText(text: String): Boolean =
text.startsWith(PREFIX_V2) || text.startsWith(PREFIX_SEND_V2) || text.startsWith(PREFIX_V1) text.startsWith(PREFIX_V2) || text.startsWith(PREFIX_SEND_V2) ||
text.startsWith(PREFIX_PHONE_V2) || text.startsWith(PREFIX_V1)
fun parse(text: String): PairingPayload? { fun parse(text: String): PairingPayload? {
if (text.length > 4096) return null if (text.length > 4096) return null
return when { return when {
text.startsWith(PREFIX_V2) -> parseV2(text.substring(PREFIX_V2.length), TransferDirection.UPLOAD_TO_PC) text.startsWith(PREFIX_V2) -> parseV2(text.substring(PREFIX_V2.length), TransferDirection.UPLOAD_TO_PC)
text.startsWith(PREFIX_SEND_V2) -> parseV2(text.substring(PREFIX_SEND_V2.length), TransferDirection.DOWNLOAD_TO_PHONE) text.startsWith(PREFIX_SEND_V2) -> parseV2(text.substring(PREFIX_SEND_V2.length), TransferDirection.DOWNLOAD_TO_PHONE)
text.startsWith(PREFIX_PHONE_V2) -> parseV2(text.substring(PREFIX_PHONE_V2.length), TransferDirection.PHONE_TO_PHONE)
text.startsWith(PREFIX_V1) -> parseV1(text.substring(PREFIX_V1.length)) text.startsWith(PREFIX_V1) -> parseV1(text.substring(PREFIX_V1.length))
else -> null else -> null
} }
@@ -53,6 +59,7 @@ object PairingProtocol {
val direction = when (encodedDirection) { val direction = when (encodedDirection) {
"u" -> TransferDirection.UPLOAD_TO_PC "u" -> TransferDirection.UPLOAD_TO_PC
"d" -> TransferDirection.DOWNLOAD_TO_PHONE "d" -> TransferDirection.DOWNLOAD_TO_PHONE
"m" -> TransferDirection.PHONE_TO_PHONE
else -> return null else -> return null
} }
if (direction != expectedDirection) return null if (direction != expectedDirection) return null
@@ -67,7 +74,9 @@ object PairingProtocol {
val ssid = wifiArray.optString(0) val ssid = wifiArray.optString(0)
val passphrase = wifiArray.optString(1) val passphrase = wifiArray.optString(1)
if (!validWifi(ssid, passphrase)) return null if (!validWifi(ssid, passphrase)) return null
WifiCredentials(ssid, passphrase, "WPA2") val security = wifiArray.optString(2, "WPA2")
if (security !in setOf("WPA2", "WPA3")) return null
WifiCredentials(ssid, passphrase, security)
} else null } else null
val endpoints = mutableListOf<String>() val endpoints = mutableListOf<String>()
@@ -157,6 +166,34 @@ object PairingProtocol {
private fun decodeUrlBase64(encoded: String): ByteArray? = Base64Url.decode(encoded) private fun decodeUrlBase64(encoded: String): ByteArray? = Base64Url.decode(encoded)
/** Build a compact Android-sender QR. File names and hashes stay in the
* authenticated local manifest so a large queue does not make the QR dense. */
fun encodePhoneShare(
session: String,
senderName: String,
port: Int,
endpoints: List<String>,
wifi: WifiCredentials?,
): String {
require(validSession(session))
require(port in 1..65535)
val safeEndpoints = endpoints
.map { it.trim().removeSuffix("/") }
.filter { isAllowedLocalHttpEndpoint(it, port) }
.distinct()
require(wifi != null || safeEndpoints.isNotEmpty())
val obj = JSONObject().apply {
put("v", 2)
put("s", session)
put("n", senderName.take(80))
put("p", port)
put("d", "m")
if (safeEndpoints.isNotEmpty()) put("e", org.json.JSONArray(safeEndpoints))
wifi?.let { put("w", org.json.JSONArray(listOf(it.ssid, it.passphrase, it.security))) }
}
return PREFIX_PHONE_V2 + Base64Url.encode(obj.toString().toByteArray(Charsets.UTF_8))
}
private fun validSession(session: String): Boolean = session.matches(Regex("^[A-Za-z0-9_-]{20,64}$")) private fun validSession(session: String): Boolean = session.matches(Regex("^[A-Za-z0-9_-]{20,64}$"))
private fun validWifi(ssid: String, passphrase: String): Boolean { private fun validWifi(ssid: String, passphrase: String): Boolean {
@@ -0,0 +1,375 @@
package com.qft.optical
import android.content.Context
import android.net.wifi.WifiManager
import android.net.wifi.p2p.WifiP2pConfig
import android.net.wifi.p2p.WifiP2pManager
import android.os.Build
import android.os.Handler
import android.os.Looper
import android.os.SystemClock
import androidx.annotation.RequiresApi
import java.security.SecureRandom
import java.util.concurrent.atomic.AtomicBoolean
/**
* Owns the phone-share access point.
*
* Android only exposes one underlying local hotspot, so QFT uses one adaptive
* Wi-Fi Direct group instead of pretending that two independent SSIDs can run
* concurrently. Android 10+ starts on AUTO (normally 5 GHz when available). If
* no authenticated peer appears, the exact same SSID/password is recreated on
* 2.4 GHz so an old receiver's already-running Wi-Fi search can join without
* rescanning the QR. LocalOnlyHotspot remains the final OEM fallback.
*/
class PhoneHotspotController(context: Context) {
private companion object {
const val LEGACY_BAND_FALLBACK_MS = 12_000L
const val GROUP_READY_TIMEOUT_MS = 12_000L
}
private val appContext = context.applicationContext
private val wifiManager = appContext.getSystemService(WifiManager::class.java)
private val p2pManager = appContext.getSystemService(Context.WIFI_P2P_SERVICE) as? WifiP2pManager
private val handler = Handler(Looper.getMainLooper())
private var reservation: AutoCloseable? = null
private var p2pChannel: WifiP2pManager.Channel? = null
private var adaptiveFallback: Runnable? = null
private var generation = 0
@Volatile private var peerAuthenticated = false
fun start(
onStarted: (WifiCredentials) -> Unit,
onStatus: (String) -> Unit = {},
onFailed: (String) -> Unit,
) {
close()
val run = ++generation
peerAuthenticated = false
val finalFallbackStarted = AtomicBoolean(false)
fun fallBackToLocalOnly(reason: String) {
if (run != generation || !finalFallbackStarted.compareAndSet(false, true)) return
adaptiveFallback?.let(handler::removeCallbacks)
adaptiveFallback = null
removeP2pGroup {
if (run == generation) {
if (Build.VERSION.SDK_INT >= 26) {
onStatus("$reason;正在启动系统备用热点…")
startLocalOnlyHotspot(run, onStarted) { localReason ->
onFailed("$reason;$localReason")
}
} else {
onFailed("$reason;Android 7 无法创建备用临时热点,将使用当前局域网")
}
}
}
}
val manager = p2pManager ?: run {
fallBackToLocalOnly("设备没有 Wi-Fi Direct 服务")
return
}
val channel = try {
manager.initialize(appContext, Looper.getMainLooper()) {
fallBackToLocalOnly("Wi-Fi Direct 通道已断开")
}
} catch (e: Exception) {
fallBackToLocalOnly("初始化专用网络失败:${e.message ?: e.javaClass.simpleName}")
return
}
p2pChannel = channel
if (Build.VERSION.SDK_INT >= 29) {
val wifi = newSessionCredentials()
onStatus("正在创建高速专用网络(自动选择 5GHz/2.4GHz)…")
replaceConfiguredGroup(
run = run,
channel = channel,
wifi = wifi,
band = WifiP2pConfig.GROUP_OWNER_BAND_AUTO,
onReady = {
onStarted(wifi)
onStatus("高速专用网络已就绪;12 秒未配对将自动切换旧机兼容频段")
scheduleLegacyBandFallback(
run = run,
channel = channel,
wifi = wifi,
onStarted = onStarted,
onStatus = onStatus,
onFailed = ::fallBackToLocalOnly,
)
},
onFailed = ::fallBackToLocalOnly,
)
} else {
onStatus("正在创建系统兼容专用网络…")
replaceLegacyGroup(
run = run,
channel = channel,
onReady = { wifi ->
onStarted(wifi)
onStatus("WPA2 兼容专用网络已就绪")
},
onFailed = ::fallBackToLocalOnly,
)
}
}
/** Called after the HTTP session token has been authenticated. */
fun markPeerAuthenticated() {
peerAuthenticated = true
adaptiveFallback?.let(handler::removeCallbacks)
adaptiveFallback = null
}
@RequiresApi(29)
private fun scheduleLegacyBandFallback(
run: Int,
channel: WifiP2pManager.Channel,
wifi: WifiCredentials,
onStarted: (WifiCredentials) -> Unit,
onStatus: (String) -> Unit,
onFailed: (String) -> Unit,
) {
val task = Runnable {
adaptiveFallback = null
if (run != generation || peerAuthenticated) return@Runnable
onStatus("尚未检测到接收端,正在用相同二维码切换到 2.4GHz 旧机兼容频段…")
replaceConfiguredGroup(
run = run,
channel = channel,
wifi = wifi,
band = WifiP2pConfig.GROUP_OWNER_BAND_2GHZ,
onReady = {
onStarted(wifi) // Same credentials: QR contents do not change.
onStatus("已切换 2.4GHz 兼容频段;旧版 Android 可继续自动搜索并连接")
},
onFailed = onFailed,
)
}
adaptiveFallback = task
handler.postDelayed(task, LEGACY_BAND_FALLBACK_MS)
}
@RequiresApi(29)
@Suppress("MissingPermission")
private fun replaceConfiguredGroup(
run: Int,
channel: WifiP2pManager.Channel,
wifi: WifiCredentials,
band: Int,
onReady: () -> Unit,
onFailed: (String) -> Unit,
) {
replaceGroup(
run = run,
channel = channel,
create = { listener ->
val config = WifiP2pConfig.Builder()
.setNetworkName(wifi.ssid)
.setPassphrase(wifi.passphrase)
.setGroupOperatingBand(band)
.build()
p2pManager?.createGroup(channel, config, listener)
?: onFailed("Wi-Fi Direct 服务不可用")
},
onReady = { actual ->
if (actual.ssid != wifi.ssid || actual.passphrase != wifi.passphrase) {
onFailed("系统创建的专用网络凭据与会话不一致")
} else {
onReady()
}
},
onFailed = onFailed,
)
}
@Suppress("MissingPermission")
private fun replaceLegacyGroup(
run: Int,
channel: WifiP2pManager.Channel,
onReady: (WifiCredentials) -> Unit,
onFailed: (String) -> Unit,
) {
replaceGroup(
run = run,
channel = channel,
create = { listener ->
p2pManager?.createGroup(channel, listener)
?: onFailed("Wi-Fi Direct 服务不可用")
},
onReady = onReady,
onFailed = onFailed,
)
}
@Suppress("MissingPermission")
private fun replaceGroup(
run: Int,
channel: WifiP2pManager.Channel,
create: (WifiP2pManager.ActionListener) -> Unit,
onReady: (WifiCredentials) -> Unit,
onFailed: (String) -> Unit,
) {
val terminal = AtomicBoolean(false)
fun fail(reason: String) {
if (run == generation && terminal.compareAndSet(false, true)) onFailed(reason)
}
fun waitForGroup() {
val deadline = SystemClock.elapsedRealtime() + GROUP_READY_TIMEOUT_MS
fun poll() {
if (run != generation || terminal.get()) return
try {
p2pManager?.requestGroupInfo(channel) { group ->
if (run != generation || terminal.get()) return@requestGroupInfo
val ssid = group?.networkName.orEmpty()
val passphrase = group?.passphrase.orEmpty()
if (group?.isGroupOwner == true && ssid.isNotBlank() && passphrase.length in 8..63) {
if (terminal.compareAndSet(false, true)) {
onReady(WifiCredentials(ssid, passphrase, "WPA2"))
}
} else if (SystemClock.elapsedRealtime() >= deadline) {
fail("创建专用网络超时")
} else {
handler.postDelayed({ poll() }, 180L)
}
} ?: fail("Wi-Fi Direct 服务不可用")
} catch (e: Exception) {
fail("读取专用网络信息失败:${e.message ?: e.javaClass.simpleName}")
}
}
poll()
}
val listener = object : WifiP2pManager.ActionListener {
override fun onSuccess() = waitForGroup()
override fun onFailure(reason: Int) = fail("系统拒绝创建专用网络(错误 $reason)")
}
val startCreate = {
if (run == generation && !terminal.get()) {
try {
create(listener)
} catch (e: Exception) {
fail("启动专用网络失败:${e.message ?: e.javaClass.simpleName}")
}
}
}
// Remove stale/present group before both initial creation and adaptive
// band switching. Credentials supplied to `create` stay unchanged.
try {
p2pManager?.removeGroup(channel, object : WifiP2pManager.ActionListener {
override fun onSuccess() = startCreate()
override fun onFailure(reason: Int) = startCreate()
}) ?: fail("Wi-Fi Direct 服务不可用")
} catch (_: Exception) {
startCreate()
}
}
@RequiresApi(29)
private fun newSessionCredentials(): WifiCredentials {
val random = ByteArray(12).also { SecureRandom().nextBytes(it) }
val token = random.joinToString("") { "%02x".format(it.toInt() and 0xff) }
return WifiCredentials(
ssid = "DIRECT-QF-QFT${token.take(6)}",
passphrase = token.take(16),
security = "WPA2",
)
}
@RequiresApi(26)
@Suppress("MissingPermission", "DEPRECATION")
private fun startLocalOnlyHotspot(
run: Int,
onStarted: (WifiCredentials) -> Unit,
onFailed: (String) -> Unit,
) {
try {
wifiManager.startLocalOnlyHotspot(
object : WifiManager.LocalOnlyHotspotCallback() {
override fun onStarted(value: WifiManager.LocalOnlyHotspotReservation) {
if (run != generation) {
value.close()
return
}
reservation = value
val identity = if (Build.VERSION.SDK_INT >= 30) {
val config = value.softApConfiguration
Triple(
config.ssid,
config.passphrase,
if (config.securityType == android.net.wifi.SoftApConfiguration.SECURITY_TYPE_WPA3_SAE) "WPA3" else "WPA2",
)
} else {
val config = value.wifiConfiguration
Triple(config?.SSID?.trim('"'), config?.preSharedKey?.trim('"'), "WPA2")
}
val ssid = identity.first.orEmpty()
val passphrase = identity.second.orEmpty()
if (ssid.isBlank() || passphrase.length !in 8..63) {
close()
onFailed("系统备用热点没有返回有效的名称或密码")
return
}
onStarted(WifiCredentials(ssid, passphrase, identity.third))
}
override fun onStopped() {
if (run == generation) {
reservation = null
onFailed("系统已停止 QFT 备用临时热点")
}
}
override fun onFailed(reason: Int) {
if (run == generation) onFailed("系统无法创建备用临时热点(错误 $reason)")
}
},
handler,
)
} catch (e: Exception) {
onFailed("启动备用临时热点失败:${e.message ?: e.javaClass.simpleName}")
}
}
@Suppress("MissingPermission")
private fun removeP2pGroup(done: () -> Unit) {
val channel = p2pChannel
p2pChannel = null
if (channel == null) {
done()
return
}
val once = AtomicBoolean(false)
fun finish() {
if (once.compareAndSet(false, true)) done()
}
try {
p2pManager?.removeGroup(channel, object : WifiP2pManager.ActionListener {
override fun onSuccess() = finish()
override fun onFailure(reason: Int) = finish()
}) ?: finish()
} catch (_: Exception) {
finish()
}
}
@Suppress("MissingPermission")
fun close() {
generation++
handler.removeCallbacksAndMessages(null)
adaptiveFallback = null
peerAuthenticated = false
try { reservation?.close() } catch (_: Exception) {}
reservation = null
val channel = p2pChannel
p2pChannel = null
if (channel != null) {
try { p2pManager?.removeGroup(channel, null) } catch (_: Exception) {}
}
}
}
@@ -0,0 +1,26 @@
package com.qft.optical
import android.graphics.Bitmap
import android.graphics.Color
import com.google.zxing.BarcodeFormat
import com.google.zxing.EncodeHintType
import com.google.zxing.qrcode.QRCodeWriter
import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel
object PhoneQr {
fun render(text: String, pixels: Int): Bitmap {
val hints = mapOf(
EncodeHintType.CHARACTER_SET to "UTF-8",
EncodeHintType.ERROR_CORRECTION to ErrorCorrectionLevel.M,
EncodeHintType.MARGIN to 3,
)
val matrix = QRCodeWriter().encode(text, BarcodeFormat.QR_CODE, pixels, pixels, hints)
val bitmap = Bitmap.createBitmap(matrix.width, matrix.height, Bitmap.Config.ARGB_8888)
val row = IntArray(matrix.width)
for (y in 0 until matrix.height) {
for (x in 0 until matrix.width) row[x] = if (matrix[x, y]) Color.BLACK else Color.WHITE
bitmap.setPixels(row, 0, matrix.width, 0, y, matrix.width, 1)
}
return bitmap
}
}
@@ -0,0 +1,19 @@
package com.qft.optical
import kotlin.math.min
import kotlin.math.roundToInt
/**
* Size a square pairing QR against the *current app window*, not a fixed phone
* resolution. The vertical reserve covers page padding, titles, connection
* details and the stop button, keeping the whole sender page visible on phones,
* tablets and split-window layouts.
*/
internal fun phoneQrSidePx(windowWidthPx: Int, windowHeightPx: Int, density: Float): Int {
val safeDensity = density.takeIf { it.isFinite() && it > 0f } ?: 1f
val horizontalPagePadding = (40f * safeDensity).roundToInt()
val nonQrVerticalUi = (300f * safeDensity).roundToInt()
val widthLimit = (windowWidthPx - horizontalPagePadding).coerceAtLeast(1)
val heightLimit = (windowHeightPx - nonQrVerticalUi).coerceAtLeast(1)
return min(widthLimit, heightLimit)
}
@@ -0,0 +1,329 @@
package com.qft.optical
import android.content.ContentResolver
import org.json.JSONArray
import org.json.JSONObject
import java.io.BufferedInputStream
import java.io.BufferedOutputStream
import java.io.FileInputStream
import java.io.InputStream
import java.net.DatagramPacket
import java.net.DatagramSocket
import java.net.InetAddress
import java.net.NetworkInterface
import java.net.ServerSocket
import java.net.Socket
import java.net.SocketTimeoutException
import java.nio.charset.StandardCharsets
import java.security.MessageDigest
import java.util.concurrent.Executors
import java.util.concurrent.atomic.AtomicBoolean
data class PhoneShareItem(
val selected: SelectedFile,
val sha256: String,
)
data class PhoneShareManifestItem(
val name: String,
val size: Long,
val sha256: String,
val path: String,
)
/** Hash exactly the advertised number of bytes and reject stale provider size
* metadata. The manifest and Range server must describe the identical snapshot. */
internal fun phoneShareSha256Exact(input: InputStream, expectedSize: Long): String {
require(expectedSize >= 0L)
val digest = MessageDigest.getInstance("SHA-256")
val buffer = ByteArray(1024 * 1024)
var remaining = expectedSize
while (remaining > 0L) {
val count = input.read(buffer, 0, minOf(buffer.size.toLong(), remaining).toInt())
require(count >= 0) { "实际内容小于文件选择器报告的大小" }
if (count == 0) continue
digest.update(buffer, 0, count)
remaining -= count.toLong()
}
require(input.read() < 0) { "实际内容大于文件选择器报告的大小" }
return digest.digest().joinToString("") { "%02x".format(it.toInt() and 0xFF) }
}
internal fun phoneShareRange(value: String?, size: Long): Pair<Long, Long>? {
if (size == 0L) return if (value == null) 0L to 0L else null
if (value == null) return 0L to (size - 1L)
val body = value.removePrefix("bytes=")
if (body == value) return null
val split = body.split('-', limit = 2)
if (split.size != 2 || split[0].isBlank()) return null
val start = split[0].toLongOrNull() ?: return null
val end = if (split[1].isBlank()) size - 1L else split[1].toLongOrNull() ?: return null
return if (start in 0 until size && end in start until size) start to end else null
}
/** Minimal authenticated HTTP/Range sender used by Android → Android v2. */
class PhoneShareServer private constructor(
private val resolver: ContentResolver,
private val session: String,
private val deviceName: String,
private val items: List<PhoneShareItem>,
private val server: ServerSocket,
private val onPeer: (String) -> Unit,
) : AutoCloseable {
val port: Int get() = server.localPort
private val stopped = AtomicBoolean(false)
private val clients = Executors.newFixedThreadPool(10)
private val tcpThread: Thread
private val udpThread: Thread
init {
server.soTimeout = 250
tcpThread = Thread({ acceptLoop() }, "qft-phone-http").apply { start() }
udpThread = Thread({ discoveryLoop() }, "qft-phone-discovery").apply { start() }
}
fun pairingText(wifi: WifiCredentials?, endpoints: List<String>): String =
PairingProtocol.encodePhoneShare(session, deviceName, port, endpoints, wifi)
private fun acceptLoop() {
while (!stopped.get()) {
try {
val socket = server.accept()
clients.execute { socket.use { handle(it) } }
} catch (_: SocketTimeoutException) {
} catch (_: Exception) {
if (!stopped.get()) Thread.sleep(30)
}
}
}
private fun handle(socket: Socket) {
socket.tcpNoDelay = true
socket.soTimeout = 20_000
val input = BufferedInputStream(socket.getInputStream(), 32 * 1024)
val output = BufferedOutputStream(socket.getOutputStream(), 1024 * 1024)
val request = readLine(input) ?: return
val parts = request.split(' ')
if (parts.size < 2) return
val headers = linkedMapOf<String, String>()
while (true) {
val line = readLine(input) ?: return
if (line.isEmpty()) break
val split = line.indexOf(':')
if (split > 0) headers[line.substring(0, split).trim().lowercase()] = line.substring(split + 1).trim()
}
if (headers["x-qft-token"] != session) {
response(output, 403, "text/plain", "invalid session".toByteArray())
return
}
headers["x-qft-device"]?.let { encoded ->
Base64Url.decode(encoded)?.toString(Charsets.UTF_8)?.take(80)?.let(onPeer)
}
val method = parts[0]
val path = parts[1].substringBefore('?')
when {
method == "GET" && path == "/qft/ping" -> response(
output, 200, "application/json",
"{\"ok\":true,\"protocol\":2,\"direction\":\"phone-download\"}".toByteArray(),
)
method == "GET" && path == "/qft/phone/manifest" -> response(
output, 200, "application/json", manifestJson().toByteArray(Charsets.UTF_8),
)
method == "GET" && path.startsWith("/qft/phone/download/") -> {
val index = path.substringAfterLast('/').toIntOrNull()
if (index == null || index !in items.indices) {
response(output, 404, "text/plain", "not found".toByteArray())
} else {
serveFile(output, headers["range"], items[index])
}
}
else -> response(output, 404, "text/plain", "not found".toByteArray())
}
}
private fun manifestJson(): String = JSONObject().apply {
put("v", 2)
put("sender", deviceName)
put("files", JSONArray().apply {
items.forEachIndexed { index, item ->
put(JSONObject().apply {
put("name", item.selected.name)
put("size", item.selected.size)
put("sha256", item.sha256)
put("path", "/qft/phone/download/$index")
})
}
})
}.toString()
private fun serveFile(output: BufferedOutputStream, rangeText: String?, item: PhoneShareItem) {
val size = item.selected.size
val range = phoneShareRange(rangeText, size) ?: run {
response(output, 416, "text/plain", "invalid range".toByteArray())
return
}
val (start, end) = range
val length = if (size == 0L) 0L else end - start + 1L
val status = if (rangeText == null) "200 OK" else "206 Partial Content"
val header = buildString {
append("HTTP/1.1 $status\r\n")
append("Content-Type: application/octet-stream\r\n")
append("Content-Length: $length\r\n")
append("Accept-Ranges: bytes\r\n")
if (rangeText != null) append("Content-Range: bytes $start-$end/$size\r\n")
append("Connection: close\r\n\r\n")
}
output.write(header.toByteArray(StandardCharsets.US_ASCII))
if (length > 0L) {
resolver.openFileDescriptor(item.selected.uri, "r")?.use { descriptor ->
FileInputStream(descriptor.fileDescriptor).use { source ->
source.channel.position(start)
val buffer = ByteArray(1024 * 1024)
var remaining = length
while (remaining > 0 && !stopped.get()) {
val count = source.read(buffer, 0, minOf(buffer.size.toLong(), remaining).toInt())
if (count < 0) error("source ended early")
output.write(buffer, 0, count)
remaining -= count
}
}
} ?: error("cannot open shared file")
}
output.flush()
}
private fun discoveryLoop() {
val socket = try {
DatagramSocket(39392).apply { soTimeout = 250; broadcast = true }
} catch (_: Exception) { return }
socket.use {
val buffer = ByteArray(512)
while (!stopped.get()) {
try {
val request = DatagramPacket(buffer, buffer.size)
socket.receive(request)
val text = String(request.data, 0, request.length, Charsets.US_ASCII)
if (!text.startsWith("QFTDISC2:$session:")) continue
val encodedName = text.substringAfter("QFTDISC2:$session:")
Base64Url.decode(encodedName)?.toString(Charsets.UTF_8)?.take(80)?.let(onPeer)
val reply = "QFTHERE2:$session:$port".toByteArray(Charsets.US_ASCII)
socket.send(DatagramPacket(reply, reply.size, request.address, request.port))
} catch (_: SocketTimeoutException) {
} catch (_: Exception) {
if (!stopped.get()) Thread.sleep(30)
}
}
}
}
override fun close() {
if (!stopped.compareAndSet(false, true)) return
try { server.close() } catch (_: Exception) {}
clients.shutdownNow()
tcpThread.interrupt()
udpThread.interrupt()
}
companion object {
fun create(
resolver: ContentResolver,
session: String,
deviceName: String,
selected: List<SelectedFile>,
onHashProgress: (Int, Int, String) -> Unit = { _, _, _ -> },
onPeer: (String) -> Unit = {},
): PhoneShareServer {
require(selected.isNotEmpty())
val items = selected.mapIndexed { index, file ->
onHashProgress(index, selected.size, file.name)
PhoneShareItem(file, sha256(resolver, file))
}
onHashProgress(selected.size, selected.size, "")
return PhoneShareServer(
resolver, session, deviceName, items,
ServerSocket(0, 32, InetAddress.getByName("0.0.0.0")), onPeer,
)
}
fun localEndpoints(port: Int): List<String> {
val result = mutableListOf<String>()
val interfaces = try { NetworkInterface.getNetworkInterfaces()?.toList().orEmpty() } catch (_: Exception) { emptyList() }
for (networkInterface in interfaces) {
if (!runCatching { networkInterface.isUp && !networkInterface.isLoopback }.getOrDefault(false)) continue
for (address in networkInterface.inetAddresses.toList()) {
val host = address.hostAddress?.substringBefore('%') ?: continue
val endpoint = "http://$host:$port"
if (PairingProtocol.isAllowedLocalHttpEndpoint(endpoint, port) && endpoint !in result) result += endpoint
}
}
return result
}
fun fetchManifest(
network: android.net.Network?,
baseUrl: String,
pairing: PairingPayload,
deviceName: String,
): List<PhoneShareManifestItem> {
val url = java.net.URL("$baseUrl/qft/phone/manifest")
val connection = (network?.openConnection(url) ?: url.openConnection()) as java.net.HttpURLConnection
try {
connection.connectTimeout = 4_000
connection.readTimeout = 8_000
connection.setRequestProperty("X-QFT-Token", pairing.session)
connection.setRequestProperty("X-QFT-Device", Base64Url.encode(deviceName.toByteArray()))
if (connection.responseCode != 200) error("文件清单返回 HTTP ${connection.responseCode}")
val root = JSONObject(connection.inputStream.bufferedReader().use { it.readText() })
val files = root.getJSONArray("files")
require(files.length() in 1..10_000) { "文件清单数量无效" }
return (0 until files.length()).map { index ->
val item = files.getJSONObject(index)
val name = item.getString("name").takeIf { validName(it) } ?: error("文件名无效")
val size = item.getLong("size").takeIf { it >= 0L } ?: error("文件大小无效")
val sha = item.getString("sha256").lowercase()
.takeIf { it.matches(Regex("^[0-9a-f]{64}$")) } ?: error("文件校验值无效")
val expectedPath = "/qft/phone/download/$index"
require(item.getString("path") == expectedPath) { "文件路径无效" }
PhoneShareManifestItem(name, size, sha, expectedPath)
}
} finally {
connection.disconnect()
}
}
private fun validName(value: String): Boolean = value.isNotBlank() && value.length <= 180 &&
value.none { it.code <= 31 || it.code == 127 || it in "\\/:*?\"<>|" }
private fun sha256(resolver: ContentResolver, file: SelectedFile): String {
val source = resolver.openInputStream(file.uri) ?: error("无法读取 ${file.name}")
return source.use { input ->
// Hash exactly the bytes that the Range server will expose.
// Reject mutable/stale provider metadata instead of producing a
// QR whose manifest hash can never match the advertised size.
try {
phoneShareSha256Exact(input, file.size)
} catch (e: IllegalArgumentException) {
error("${file.name}:${e.message},请重新选择")
}
}
}
private fun readLine(input: BufferedInputStream): String? {
val bytes = ArrayList<Byte>(128)
while (bytes.size <= 16 * 1024) {
val value = input.read()
if (value < 0) return if (bytes.isEmpty()) null else bytes.toByteArray().toString(Charsets.US_ASCII)
if (value == '\n'.code) break
if (value != '\r'.code) bytes += value.toByte()
}
return bytes.toByteArray().toString(Charsets.US_ASCII)
}
private fun response(output: BufferedOutputStream, code: Int, type: String, body: ByteArray) {
val reason = when (code) { 200 -> "OK"; 403 -> "Forbidden"; 404 -> "Not Found"; 416 -> "Range Not Satisfiable"; else -> "Error" }
output.write("HTTP/1.1 $code $reason\r\nContent-Type: $type\r\nContent-Length: ${body.size}\r\nConnection: close\r\n\r\n".toByteArray())
output.write(body)
output.flush()
}
}
}
@@ -124,26 +124,29 @@ class QrAnalyzer(
return null return null
} }
// Acquisition is center-first, but unlike the old path it establishes // Pairing needs one reliable first hit, not sustained decode FPS. Keep a
// a QR ROI immediately after the first hit. Full-frame work is only a // generous center crop so a large desktop QR is not clipped at the quiet
// recovery path for deliberately off-center QR codes. // zone, and prefer Hybrid thresholding on every frame: it is markedly
val center = LockRect.centeredSearch(image.width, image.height, 0.82f) // more tolerant of monitor glare, PWM bands and uneven exposure.
val center = LockRect.centeredSearch(image.width, image.height, 0.92f)
val centered = grayBuffer.capture(image, center) val centered = grayBuffer.capture(image, center)
decodeDense(centered, hybrid = false)?.let { result ->
updatePairRegion(result, centered)
return result
}
if (frameCounter % 3L == 0L) {
decodeDense(centered, hybrid = true)?.let { result -> decodeDense(centered, hybrid = true)?.let { result ->
updatePairRegion(result, centered) updatePairRegion(result, centered)
return result return result
} }
// Global thresholding remains a cheap fallback for very clean displays,
// but no longer delays the robust path until the third camera frame.
if (frameCounter % 2L == 0L) {
decodeDense(centered, hybrid = false)?.let { result ->
updatePairRegion(result, centered)
return result
}
} }
if (frameCounter % 4L == 0L) { if (frameCounter % 3L == 0L) {
val full = grayBuffer.capture(image) val full = grayBuffer.capture(image)
decodeDense(full, hybrid = false)?.let { result -> decodeDense(full, hybrid = true)?.let { result ->
updatePairRegion(result, full) updatePairRegion(result, full)
return result return result
} }
@@ -0,0 +1,8 @@
package com.qft.optical
/** Move one item while preserving every other item's relative order. */
internal fun <T> moveQueueItem(items: MutableList<T>, from: Int, to: Int): Boolean {
if (from !in items.indices || to !in items.indices || from == to) return false
items.add(to, items.removeAt(from))
return true
}
@@ -30,17 +30,44 @@ data class SelectedFile(
val uploadKey: String = UUID.randomUUID().toString(), val uploadKey: String = UUID.randomUUID().toString(),
) )
/**
* Wait for completed probes, rather than counting empty queue polls as failed
* addresses. This matters immediately after joining QFT Direct: the first ARP
* and Windows firewall transition can take longer than a short poll slice even
* though the authenticated HTTP request is already reaching the desktop.
*/
internal fun <T> awaitFirstNonNull(
completion: ExecutorCompletionService<T?>,
submitted: Int,
timeoutMs: Long,
): T? {
val deadline = System.nanoTime() + TimeUnit.MILLISECONDS.toNanos(timeoutMs.coerceAtLeast(0L))
var completed = 0
while (completed < submitted) {
val remainingNanos = deadline - System.nanoTime()
if (remainingNanos <= 0L) return null
val future = completion.poll(remainingNanos, TimeUnit.NANOSECONDS) ?: return null
completed += 1
try {
future.get()?.let { return it }
} catch (_: Exception) {
// One broken address must not discard successful probes still queued.
}
}
return null
}
internal fun directDiscoveryRequest(session: String, deviceName: String): ByteArray =
"QFTDISC2:$session:${Base64Url.encode(deviceName.toByteArray(Charsets.UTF_8))}"
.toByteArray(Charsets.US_ASCII)
object UploadClient { object UploadClient {
private const val TAG = "QftUpload" private const val TAG = "QftUpload"
private const val DISCOVERY_PORT = 39392 private const val DISCOVERY_PORT = 39392
private const val CHUNK_SMALL = 4L * 1024L * 1024L
private const val CHUNK_DEFAULT = 8L * 1024L * 1024L
private const val CHUNK_LARGE = 16L * 1024L * 1024L
private const val MAX_WORKERS = 8 private const val MAX_WORKERS = 8
private const val MIN_PARALLEL_CHUNK = 64L * 1024L
private const val MAX_PARALLEL_CHUNK = 16L * 1024L * 1024L
private const val STREAM_BUFFER = 1024 * 1024 private const val STREAM_BUFFER = 1024 * 1024
// A single request is materially more reliable for small files on Wi-Fi
// Direct, and a 4 MiB parallel chunk gives no throughput benefit there.
private const val PARALLEL_MIN_FILE_SIZE = 32L * 1024L * 1024L
// QFT Direct can briefly reset a TCP flow while the Android network route // QFT Direct can briefly reset a TCP flow while the Android network route
// settles. Chunk PUTs and the init/finish control calls are safe to retry; // settles. Chunk PUTs and the init/finish control calls are safe to retry;
// the Windows receiver treats a repeated chunk as an idempotent success. // the Windows receiver treats a repeated chunk as an idempotent success.
@@ -73,6 +100,7 @@ object UploadClient {
network: Network?, network: Network?,
pairing: PairingPayload, pairing: PairingPayload,
hosts: List<InetAddress>, hosts: List<InetAddress>,
deviceName: String,
): String? { ): String? {
if (hosts.isEmpty()) return null if (hosts.isEmpty()) return null
val socket = DatagramSocket() val socket = DatagramSocket()
@@ -80,7 +108,7 @@ object UploadClient {
network?.bindSocket(socket) network?.bindSocket(socket)
socket.broadcast = true socket.broadcast = true
socket.soTimeout = 160 socket.soTimeout = 160
val request = "QFTDISC2:${pairing.session}".toByteArray(Charsets.US_ASCII) val request = directDiscoveryRequest(pairing.session, deviceName)
// Two directed/broadcast bursts fit within the initial routing // Two directed/broadcast bursts fit within the initial routing
// window while keeping service discovery below 600 ms. // window while keeping service discovery below 600 ms.
repeat(2) { repeat(2) {
@@ -121,18 +149,49 @@ object UploadClient {
discoveredEndpoint: String? = null, discoveredEndpoint: String? = null,
subnetEndpoints: List<String> = emptyList(), subnetEndpoints: List<String> = emptyList(),
): String? { ): String? {
val common = listOf( val dedicatedWifi = pairing.wifi != null
"http://192.168.137.1:${pairing.port}", // Direct mode must use only facts obtained from the dedicated Network:
"http://192.168.49.1:${pairing.port}", // its actual gateway and an authenticated UDP reply. Never inject LAN,
// VPN or guessed Windows ICS addresses into this candidate list.
val fast = EndpointRouting.forRecovery(
dedicatedWifi = dedicatedWifi,
discoveredEndpoint = discoveredEndpoint,
gatewayEndpoints = preferredEndpoints,
advertisedEndpoints = pairing.endpoints,
) )
val fast = (listOfNotNull(discoveredEndpoint) + preferredEndpoints + pairing.endpoints + common)
.map { it.trim().removeSuffix("/") } .map { it.trim().removeSuffix("/") }
.filter { PairingProtocol.isAllowedLocalHttpEndpoint(it, pairing.port) } .filter { PairingProtocol.isAllowedLocalHttpEndpoint(it, pairing.port) }
.distinct() .distinct()
// Stage 1: QR-carried endpoints and actual gateway. This is the normal val scan = subnetEndpoints
// path and must complete well inside the 10-second pairing budget. .map { it.trim().removeSuffix("/") }
val fastDeadline = android.os.SystemClock.elapsedRealtime() + 1_050 .filter { PairingProtocol.isAllowedLocalHttpEndpoint(it, pairing.port) }
.filterNot { it in fast }
.distinct()
if (dedicatedWifi) {
// The group-owner route may remain absent on some Huawei/Windows
// combinations even though DHCP already supplied a usable /24.
// Probe gateway and the real connected subnet together, repeating
// while Windows finishes accepting the Wi-Fi Direct peer.
val candidates = (fast + scan).distinct()
val deadline = android.os.SystemClock.elapsedRealtime() + 6_000L
while (candidates.isNotEmpty() && android.os.SystemClock.elapsedRealtime() < deadline) {
probeCandidatesParallel(
network, pairing, deviceName, candidates,
workers = 48, connectMs = 180, readMs = 220,
)?.let { return it }
try { Thread.sleep(80) } catch (_: InterruptedException) { return null }
}
return null
}
// Give a newly associated Direct network enough time for ARP, the group
// owner route and Windows' new-network firewall profile to settle. A
// successful candidate still returns immediately, so this extends only
// the failure/recovery path.
val fastWindowMs = 1_050L
val fastDeadline = android.os.SystemClock.elapsedRealtime() + fastWindowMs
while (fast.isNotEmpty() && android.os.SystemClock.elapsedRealtime() < fastDeadline) { while (fast.isNotEmpty() && android.os.SystemClock.elapsedRealtime() < fastDeadline) {
probeCandidatesParallel(network, pairing, deviceName, fast, workers = 12, connectMs = 220, readMs = 260) probeCandidatesParallel(network, pairing, deviceName, fast, workers = 12, connectMs = 220, readMs = 260)
?.let { return it } ?.let { return it }
@@ -142,19 +201,14 @@ object UploadClient {
// Stage 2: actual connected subnet fallback. This specifically fixes the // Stage 2: actual connected subnet fallback. This specifically fixes the
// case where Windows Wi-Fi Direct is up but uses an unexpected gateway // case where Windows Wi-Fi Direct is up but uses an unexpected gateway
// address. Up to /24 is scanned concurrently and still session-authenticated. // address. Up to /24 is scanned concurrently and still session-authenticated.
val scan = subnetEndpoints
.map { it.trim().removeSuffix("/") }
.filter { PairingProtocol.isAllowedLocalHttpEndpoint(it, pairing.port) }
.filterNot { it in fast }
.distinct()
if (scan.isNotEmpty()) { if (scan.isNotEmpty()) {
probeCandidatesParallel(network, pairing, deviceName, scan, workers = 48, connectMs = 180, readMs = 220) probeCandidatesParallel(network, pairing, deviceName, scan, workers = 48, connectMs = 180, readMs = 220)
?.let { return it } ?.let { return it }
} }
// One short final pass covers a just-finished ARP/Windows firewall // One final pass covers a route/firewall transition that completed while
// transition without adding the former two-second tail latency. // the actual connected subnet fallback was running.
val deadline = android.os.SystemClock.elapsedRealtime() + 500 val deadline = android.os.SystemClock.elapsedRealtime() + 500L
while (fast.isNotEmpty() && android.os.SystemClock.elapsedRealtime() < deadline) { while (fast.isNotEmpty() && android.os.SystemClock.elapsedRealtime() < deadline) {
probeCandidatesParallel(network, pairing, deviceName, fast, workers = 12, connectMs = 240, readMs = 260) probeCandidatesParallel(network, pairing, deviceName, fast, workers = 12, connectMs = 240, readMs = 260)
?.let { return it } ?.let { return it }
@@ -163,6 +217,50 @@ object UploadClient {
return null return null
} }
/**
* 在指定网络(`network` 为 null 表示系统默认网络)上并发探测一组地址,
* 返回第一个应答的。
*
* Direct 模式只传入专用网络的实际网关;当前局域网备用模式传入经过
* 同网段过滤的二维码地址。调用方必须显式绑定对应的 Network。
*/
fun probeEndpoints(
network: Network?,
pairing: PairingPayload,
deviceName: String,
endpoints: List<String>,
connectMs: Int,
readMs: Int,
): String? = probeCandidatesParallel(
network = network,
pairing = pairing,
deviceName = deviceName,
candidates = endpoints,
workers = endpoints.size.coerceAtMost(8).coerceAtLeast(1),
connectMs = connectMs,
readMs = readMs,
)
/**
* Dedicated Wi-Fi fast path. The Windows group owner is normally the first
* host in the actual connected subnet, so scan it immediately instead of
* waiting several seconds for Android to publish a default gateway route.
*/
fun probeConnectedNetwork(
network: Network?,
pairing: PairingPayload,
deviceName: String,
endpoints: List<String>,
): String? = probeCandidatesParallel(
network = network,
pairing = pairing,
deviceName = deviceName,
candidates = endpoints.distinct(),
workers = 48,
connectMs = 180,
readMs = 220,
)
private fun probeCandidatesParallel( private fun probeCandidatesParallel(
network: Network?, network: Network?,
pairing: PairingPayload, pairing: PairingPayload,
@@ -183,15 +281,11 @@ object UploadClient {
return try { return try {
val overallMs = (connectMs + readMs + 150).toLong() * val overallMs = (connectMs + readMs + 150).toLong() *
((candidates.size + workers - 1) / workers).coerceAtLeast(1) ((candidates.size + workers - 1) / workers).coerceAtLeast(1)
val deadline = android.os.SystemClock.elapsedRealtime() + overallMs.coerceAtMost(2_400L) awaitFirstNonNull(
repeat(candidates.size) { completion = completion,
val remaining = deadline - android.os.SystemClock.elapsedRealtime() submitted = candidates.size,
if (remaining <= 0) return null timeoutMs = overallMs.coerceAtMost(2_400L),
val future = completion.poll(remaining.coerceAtMost(350L), TimeUnit.MILLISECONDS) ?: return@repeat )
val result = future.get()
if (result != null) return result
}
null
} catch (_: Exception) { } catch (_: Exception) {
null null
} finally { } finally {
@@ -230,10 +324,7 @@ object UploadClient {
abortReason: () -> String? = { null }, abortReason: () -> String? = { null },
onProgress: (sent: Long, total: Long) -> Unit, onProgress: (sent: Long, total: Long) -> Unit,
) { ) {
if (pairing.version >= 2 && file.size >= PARALLEL_MIN_FILE_SIZE) { if (pairing.version >= 2 && isSeekable(resolver, file)) {
require(isSeekable(resolver, file)) {
"大文件必须使用可随机读取的本地文件才能并行直传;请先把云盘文件下载到手机本地后再选择"
}
try { try {
uploadParallel(resolver, networkProvider, baseUrl, pairing, deviceName, file, abortReason, onProgress) uploadParallel(resolver, networkProvider, baseUrl, pairing, deviceName, file, abortReason, onProgress)
return return
@@ -247,7 +338,7 @@ object UploadClient {
if (!message.contains("HTTP 404") && !message.contains("HTTP 501")) throw e if (!message.contains("HTTP 404") && !message.contains("HTTP 501")) throw e
} }
} }
Log.i(TAG, "using single-stream upload: size=${file.size}, endpoint=$baseUrl") Log.i(TAG, "using compatibility single-stream upload: size=${file.size}, endpoint=$baseUrl")
uploadLegacy(resolver, networkProvider(), baseUrl, pairing, deviceName, file, abortReason, onProgress) uploadLegacy(resolver, networkProvider(), baseUrl, pairing, deviceName, file, abortReason, onProgress)
} }
@@ -374,10 +465,13 @@ object UploadClient {
} }
private fun desiredChunkSize(fileSize: Long): Long = when { private fun desiredChunkSize(fileSize: Long): Long {
fileSize < 32L * 1024L * 1024L -> CHUNK_SMALL if (fileSize <= 0L) return MIN_PARALLEL_CHUNK
fileSize >= 512L * 1024L * 1024L -> CHUNK_LARGE // Aim for eight independent HTTP flows on every transferable file.
else -> CHUNK_DEFAULT // The floor keeps QR Direct overhead reasonable for tiny files, while
// the ceiling protects memory and TCP fairness on very large files.
return ((fileSize + MAX_WORKERS - 1) / MAX_WORKERS)
.coerceIn(MIN_PARALLEL_CHUNK, MAX_PARALLEL_CHUNK)
} }
private fun initUpload( private fun initUpload(
@@ -20,7 +20,11 @@ import java.net.InetAddress
import java.util.concurrent.atomic.AtomicBoolean import java.util.concurrent.atomic.AtomicBoolean
class WifiConnector(context: Context) { class WifiConnector(context: Context) {
private companion object { const val TAG = "QftWifi" } private companion object {
const val TAG = "QftWifi"
/** 超过这个时长仍未出结果的配网请求视为卡死,重试时不再复用 */
const val REUSE_WINDOW_MS = 20_000L
}
private val appContext = context.applicationContext private val appContext = context.applicationContext
private val connectivity = appContext.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager private val connectivity = appContext.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
private val wifiManager = appContext.getSystemService(Context.WIFI_SERVICE) as WifiManager private val wifiManager = appContext.getSystemService(Context.WIFI_SERVICE) as WifiManager
@@ -44,7 +48,9 @@ class WifiConnector(context: Context) {
) )
private var listener: Listener? = null private var listener: Listener? = null
private var pendingSsid: String? = null /** The whole credential tuple owns a modern request. LocalOnlyHotspot may
* reuse its SSID while rotating the passphrase between reservations. */
private var pendingWifi: WifiCredentials? = null
private var pendingDelivered: AtomicBoolean? = null private var pendingDelivered: AtomicBoolean? = null
private var pendingTerminal: AtomicBoolean? = null private var pendingTerminal: AtomicBoolean? = null
private var pendingStartedAt = 0L private var pendingStartedAt = 0L
@@ -55,6 +61,12 @@ class WifiConnector(context: Context) {
private fun notifyAvailable(network: Network?) { listener?.onAvailable?.invoke(network) } private fun notifyAvailable(network: Network?) { listener?.onAvailable?.invoke(network) }
private fun notifyUnavailable(message: String) { listener?.onUnavailable?.invoke(message) } private fun notifyUnavailable(message: String) { listener?.onUnavailable?.invoke(message) }
/** Pure WPA3 hotspots cannot be joined by Android 7–9, or by Android 10+
* devices whose Wi-Fi chipset does not expose SAE support. */
fun canJoinAutomatically(wifi: WifiCredentials): Boolean =
wifi.security != "WPA3" ||
(Build.VERSION.SDK_INT >= 29 && wifiManager.isWpa3SaeSupported)
fun connect( fun connect(
pairing: PairingPayload, pairing: PairingPayload,
onStatus: (String) -> Unit, onStatus: (String) -> Unit,
@@ -65,7 +77,13 @@ class WifiConnector(context: Context) {
// 同一个 SSID 的请求还挂在系统那里且没有终结:换掉 UI 回调即可, // 同一个 SSID 的请求还挂在系统那里且没有终结:换掉 UI 回调即可,
// 千万不要 unregister 再重新 requestNetwork。 // 千万不要 unregister 再重新 requestNetwork。
if (wifi != null && callback != null && pendingSsid == wifi.ssid && // 复用必须有时间上限。系统偶尔会让一个 WifiNetworkSpecifier 请求
// 既不回 onAvailable 也不回 onUnavailable 地一直挂着;若无条件复用,
// 用户每次点「重试连接」都只是再等一次那个死掉的请求,表现就是
// 「配网越来越慢、几分钟都没反应」。超窗就推倒重来。
val reusable = pendingStartedAt > 0L &&
SystemClock.elapsedRealtime() - pendingStartedAt < REUSE_WINDOW_MS
if (wifi != null && callback != null && pendingWifi == wifi && reusable &&
pendingTerminal?.get() == false) { pendingTerminal?.get() == false) {
Log.i(TAG, "reuse outstanding request SSID=${wifi.ssid}") Log.i(TAG, "reuse outstanding request SSID=${wifi.ssid}")
listener = Listener(onStatus, onAvailable, onUnavailable) listener = Listener(onStatus, onAvailable, onUnavailable)
@@ -75,7 +93,7 @@ class WifiConnector(context: Context) {
notifyAvailable(active) notifyAvailable(active)
} else { } else {
notifyStatus("系统配网请求仍在进行中,正在自动恢复连接…") notifyStatus("系统配网请求仍在进行中,正在自动恢复连接…")
scheduleWaitHints(generation, wifi.ssid) scheduleWaitHints(generation, wifi.ssid, pairing.direction)
} }
return return
} }
@@ -85,7 +103,7 @@ class WifiConnector(context: Context) {
val run = generation val run = generation
listener = Listener(onStatus, onAvailable, onUnavailable) listener = Listener(onStatus, onAvailable, onUnavailable)
if (wifi == null) { if (wifi == null) {
notifyStatus("正在使用当前局域网发现电脑…") notifyStatus("正在使用当前局域网发现发送设备…")
val wifiNetwork = bestWifiNetwork() val wifiNetwork = bestWifiNetwork()
currentNetwork = wifiNetwork ?: connectivity.activeNetwork currentNetwork = wifiNetwork ?: connectivity.activeNetwork
notifyAvailable(currentNetwork) notifyAvailable(currentNetwork)
@@ -93,7 +111,7 @@ class WifiConnector(context: Context) {
} }
if (Build.VERSION.SDK_INT >= 29) { if (Build.VERSION.SDK_INT >= 29) {
connectModern(run, wifi) connectModern(run, wifi, pairing.direction)
} else { } else {
connectLegacy(run, wifi) connectLegacy(run, wifi)
} }
@@ -101,14 +119,29 @@ class WifiConnector(context: Context) {
@RequiresApi(29) @RequiresApi(29)
@Suppress("MissingPermission") @Suppress("MissingPermission")
private fun connectModern(run: Int, wifi: WifiCredentials) { private fun connectModern(run: Int, wifi: WifiCredentials, direction: TransferDirection) {
Log.i(TAG, "attempt=$run request SSID=${wifi.ssid}") Log.i(TAG, "attempt=$run request SSID=${wifi.ssid}")
notifyStatus("正在等待 Android 系统连接确认;确认后本页将继续显示进度") // Ask the radio for a fresh scan immediately before presenting the
// NetworkSpecifier chooser. Some OEMs otherwise reuse an old scan cache
// and keep showing “searching” even though Windows has just started the
// QFT SSID. Android may throttle this call; requestNetwork still runs.
try {
val scanStarted = wifiManager.startScan()
Log.i(TAG, "attempt=$run active scan requested=$scanStarted")
} catch (e: Exception) {
Log.w(TAG, "attempt=$run active scan unavailable: ${e.message}")
}
notifyStatus("正在刷新 Wi-Fi 列表并连接 ${wifi.ssid}…")
val specifier = try { val specifier = try {
WifiNetworkSpecifier.Builder() val builder = WifiNetworkSpecifier.Builder()
.setSsid(wifi.ssid) .setSsid(wifi.ssid)
.setWpa2Passphrase(wifi.passphrase) .setIsHiddenSsid(false)
.build() if (wifi.security == "WPA3" && Build.VERSION.SDK_INT >= 29) {
builder.setWpa3Passphrase(wifi.passphrase)
} else {
builder.setWpa2Passphrase(wifi.passphrase)
}
builder.build()
} catch (e: Exception) { } catch (e: Exception) {
notifyUnavailable("配网参数无效:${e.message}") notifyUnavailable("配网参数无效:${e.message}")
return return
@@ -124,7 +157,7 @@ class WifiConnector(context: Context) {
// launching a duplicate probe/download for the same Wi-Fi connection. // launching a duplicate probe/download for the same Wi-Fi connection.
val delivered = AtomicBoolean(false) val delivered = AtomicBoolean(false)
val terminal = AtomicBoolean(false) val terminal = AtomicBoolean(false)
pendingSsid = wifi.ssid pendingWifi = wifi
pendingDelivered = delivered pendingDelivered = delivered
pendingTerminal = terminal pendingTerminal = terminal
pendingStartedAt = SystemClock.elapsedRealtime() pendingStartedAt = SystemClock.elapsedRealtime()
@@ -166,12 +199,19 @@ class WifiConnector(context: Context) {
notifyUnavailable( notifyUnavailable(
if (waited < 4_000L) { if (waited < 4_000L) {
"已取消系统配网。请重新点击「重试连接」,并在系统弹窗里选择 ${wifi.ssid} 后点连接。" "已取消系统配网。请重新点击「重试连接」,并在系统弹窗里选择 ${wifi.ssid} 后点连接。"
} else {
if (direction == TransferDirection.PHONE_TO_PHONE) {
"系统始终没有搜索到热点 ${wifi.ssid}。请确认:" +
"① 发送手机仍停留在二维码页面;" +
"② 两台手机距离不要太远;" +
"③ 发送手机没有关闭临时热点或进入省电状态。"
} else { } else {
"系统始终没有搜索到热点 ${wifi.ssid}。请确认:" + "系统始终没有搜索到热点 ${wifi.ssid}。请确认:" +
"① 电脑上 QFT 接收页仍开着且显示 Direct 已启动;" + "① 电脑上 QFT 接收页仍开着且显示 Direct 已启动;" +
"② 手机 Wi-Fi 列表里能看到这个名字;" + "② 手机 Wi-Fi 列表里能看到这个名字;" +
"③ 电脑与手机距离不要太远。" "③ 电脑与手机距离不要太远。"
} }
}
) )
} }
@@ -195,10 +235,10 @@ class WifiConnector(context: Context) {
// system sheet; otherwise keep this request alive while our page // system sheet; otherwise keep this request alive while our page
// continues to show connection progress. // continues to show connection progress.
connectivity.requestNetwork(request, cb) connectivity.requestNetwork(request, cb)
scheduleWaitHints(run, wifi.ssid) scheduleWaitHints(run, wifi.ssid, direction)
} catch (e: Exception) { } catch (e: Exception) {
callback = null callback = null
pendingSsid = null pendingWifi = null
notifyUnavailable("系统配网请求失败:${e.message}") notifyUnavailable("系统配网请求失败:${e.message}")
} }
} }
@@ -208,23 +248,31 @@ class WifiConnector(context: Context) {
* 截图里那种「弹窗一直转圈」的情况,光说「仍在等待系统完成配网」 * 截图里那种「弹窗一直转圈」的情况,光说「仍在等待系统完成配网」
* 完全没有指导意义——真正的原因通常是电脑侧热点没起来。 * 完全没有指导意义——真正的原因通常是电脑侧热点没起来。
*/ */
private fun scheduleWaitHints(run: Int, ssid: String) { private fun scheduleWaitHints(run: Int, ssid: String, direction: TransferDirection) {
fun pending(): Boolean = fun pending(): Boolean =
run == generation && pendingTerminal?.get() == false && pendingDelivered?.get() == false run == generation && pendingTerminal?.get() == false && pendingDelivered?.get() == false
handler.postDelayed({ handler.postDelayed({
if (pending()) listener?.onStatus?.invoke("仍在等待系统完成配网…") if (pending()) listener?.onStatus?.invoke("仍在等待系统完成配网…")
}, 8_000) }, 4_000)
handler.postDelayed({ handler.postDelayed({
if (pending()) listener?.onStatus?.invoke( if (pending()) {
"系统仍在搜索 $ssid。若弹窗里一直没出现这个名字," + val peerHint = if (direction == TransferDirection.PHONE_TO_PHONE) {
"多半是电脑侧热点没启动——请检查 Windows 上 QFT 接收页是否显示 Direct 已就绪。" "请确认发送手机仍停留在二维码页面,且临时热点没有被省电模式关闭。"
) } else {
"请检查 Windows 上 QFT 接收页是否显示 Direct 已就绪。"
}
listener?.onStatus?.invoke("系统仍在搜索 $ssid。若弹窗里没有这个名字,$peerHint")
}
}, 20_000) }, 20_000)
} }
@Suppress("DEPRECATION", "MissingPermission") @Suppress("DEPRECATION", "MissingPermission")
private fun connectLegacy(run: Int, wifi: WifiCredentials) { private fun connectLegacy(run: Int, wifi: WifiCredentials) {
if (wifi.security == "WPA3") {
notifyUnavailable("当前 Android 版本不支持自动加入 WPA3 临时热点;请让两台手机先连接同一个普通 Wi-Fi 后重试。")
return
}
notifyStatus("Android ${Build.VERSION.RELEASE} 兼容配网:正在连接 ${wifi.ssid}…") notifyStatus("Android ${Build.VERSION.RELEASE} 兼容配网:正在连接 ${wifi.ssid}…")
try { try {
if (!wifiManager.isWifiEnabled) { if (!wifiManager.isWifiEnabled) {
@@ -232,22 +280,41 @@ class WifiConnector(context: Context) {
} }
legacyPreviousNetworkId = wifiManager.connectionInfo?.networkId?.takeIf { it >= 0 } legacyPreviousNetworkId = wifiManager.connectionInfo?.networkId?.takeIf { it >= 0 }
val quoted = "\"${wifi.ssid}\"" val quoted = "\"${wifi.ssid}\""
val existing = try { wifiManager.configuredNetworks?.firstOrNull { it.SSID == quoted } } catch (_: Exception) { null } val existing = try {
val targetId = if (existing != null) { wifiManager.configuredNetworks?.firstOrNull { normalizeSsid(it.SSID) == wifi.ssid }
existing.networkId } catch (_: Exception) { null }
} else {
val config = WifiConfiguration().apply { val config = WifiConfiguration().apply {
SSID = quoted SSID = quoted
preSharedKey = "\"${wifi.passphrase}\"" preSharedKey = "\"${wifi.passphrase}\""
hiddenSSID = false
status = WifiConfiguration.Status.ENABLED
allowedKeyManagement.clear()
allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK) allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK)
} }
wifiManager.addNetwork(config) // A LocalOnlyHotspot reservation may keep the same generated SSID
} // but rotate its password. Reusing an old WifiConfiguration without
// replacing the PSK leaves Android 7–9 in an endless association
// loop. Always update the saved entry from the freshly scanned QR.
var targetId = if (existing != null) {
config.networkId = existing.networkId
wifiManager.updateNetwork(config)
} else -1
if (targetId < 0) { if (targetId < 0) {
notifyUnavailable("Android 7~9 无法写入 QFT Wi-Fi 配置;请确认已授予位置权限。") existing?.let { wifiManager.removeNetwork(it.networkId) }
config.networkId = -1
targetId = wifiManager.addNetwork(config)
}
try { wifiManager.saveConfiguration() } catch (_: Exception) {}
if (targetId < 0) {
notifyUnavailable("Android 7~9 无法刷新 QFT Wi-Fi 配置;请确认已授予位置权限并开启系统定位。")
return return
} }
legacyTargetNetworkId = targetId legacyTargetNetworkId = targetId
try {
Log.i(TAG, "attempt=$run legacy active scan requested=${wifiManager.startScan()}")
} catch (e: Exception) {
Log.w(TAG, "attempt=$run legacy active scan unavailable: ${e.message}")
}
wifiManager.disconnect() wifiManager.disconnect()
if (!wifiManager.enableNetwork(targetId, true)) { if (!wifiManager.enableNetwork(targetId, true)) {
notifyUnavailable("系统拒绝启用 QFT Wi-Fi 网络") notifyUnavailable("系统拒绝启用 QFT Wi-Fi 网络")
@@ -255,6 +322,7 @@ class WifiConnector(context: Context) {
} }
wifiManager.reconnect() wifiManager.reconnect()
val started = SystemClock.elapsedRealtime() val started = SystemClock.elapsedRealtime()
var associationRetried = false
fun poll() { fun poll() {
if (run != generation) return if (run != generation) return
val info = wifiManager.connectionInfo val info = wifiManager.connectionInfo
@@ -262,14 +330,28 @@ class WifiConnector(context: Context) {
if (matches) { if (matches) {
val network = bestWifiNetwork() val network = bestWifiNetwork()
if (network != null && hasIpv4(connectivity.getLinkProperties(network))) { if (network != null && hasIpv4(connectivity.getLinkProperties(network))) {
notifyStatus("QFT Wi-Fi 已连接,正在快速发现电脑…") notifyStatus("QFT Wi-Fi 已连接,正在快速发现发送设备…")
currentNetwork = network currentNetwork = network
notifyAvailable(network) notifyAvailable(network)
return return
} }
} }
if (SystemClock.elapsedRealtime() - started > 15_000) { val elapsed = SystemClock.elapsedRealtime() - started
notifyUnavailable("连接 QFT Wi-Fi 超时。请确认电脑热点仍在运行。") if (!associationRetried && elapsed > 8_000) {
associationRetried = true
notifyStatus("旧版 Android 首次关联未完成,正在刷新热点并重试…")
try { wifiManager.startScan() } catch (_: Exception) {}
try {
wifiManager.disconnect()
wifiManager.enableNetwork(targetId, true)
wifiManager.reconnect()
} catch (_: Exception) {}
}
if (elapsed > 30_000) {
notifyUnavailable(
"连接 QFT Wi-Fi 超时。已使用二维码中的最新密码重建网络;" +
"请确认发送手机仍停留在二维码页面,并检查旧手机的系统定位是否开启。"
)
} else { } else {
handler.postDelayed({ poll() }, 250) handler.postDelayed({ poll() }, 250)
} }
@@ -289,7 +371,7 @@ class WifiConnector(context: Context) {
return return
} }
if (SystemClock.elapsedRealtime() - started > 6_000) { if (SystemClock.elapsedRealtime() - started > 6_000) {
onStatus("网络已连接但路由仍未就绪,继续尝试电脑发现…") onStatus("网络已连接但路由仍未就绪,继续尝试发送设备发现…")
done() done()
} else { } else {
handler.postDelayed({ poll() }, 120) handler.postDelayed({ poll() }, 120)
@@ -306,17 +388,133 @@ class WifiConnector(context: Context) {
private fun hasIpv4(props: LinkProperties?): Boolean = props?.linkAddresses?.any { it.address is Inet4Address } == true private fun hasIpv4(props: LinkProperties?): Boolean = props?.linkAddresses?.any { it.address is Inet4Address } == true
fun endpointsOnNetwork(network: Network?, endpoints: List<String>, port: Int): List<String> {
if (network == null) return emptyList()
val links = connectivity.getLinkProperties(network)?.linkAddresses
?.mapNotNull { link ->
val address = link.address as? Inet4Address ?: return@mapNotNull null
val text = address.hostAddress ?: return@mapNotNull null
text to link.prefixLength
}
.orEmpty()
return EndpointRouting.onAnySubnet(endpoints, port, links)
}
/**
* 传输期间持有的 Wi-Fi 高性能锁。
*
* Android 默认会让 Wi-Fi 芯片在包间隙进入省电休眠,代价是额外的唤醒
* 延迟。对于持续大流量传输,这会明显压低吞吐——这是 Android 上最常见
* 也最容易被忽略的一项限速。锁只在传输期间持有,结束立即释放。
*/
private var transferLock: WifiManager.WifiLock? = null
@Suppress("DEPRECATION")
fun acquireHighPerfLock() {
if (transferLock != null) return
val mode = if (Build.VERSION.SDK_INT >= 29) {
WifiManager.WIFI_MODE_FULL_LOW_LATENCY
} else {
WifiManager.WIFI_MODE_FULL_HIGH_PERF
}
transferLock = try {
wifiManager.createWifiLock(mode, "qft:transfer").apply {
setReferenceCounted(false)
acquire()
}
} catch (e: Exception) {
Log.w(TAG, "无法获取 Wi-Fi 高性能锁:${e.message}")
null
}
}
fun releaseHighPerfLock() {
try { transferLock?.takeIf { it.isHeld }?.release() } catch (_: Exception) {}
transferLock = null
}
/**
* 当前 Wi-Fi 链路的协商速率与信号强度。
*
* 判断"传输慢"到底是软件问题还是链路本身的上限,这两个数字是唯一
* 依据:协商 866 Mbps 却只跑到 136 Mbps 说明有优化空间;
* 协商本来就只有 150 Mbps 就已经接近满速,改代码也没用。
*/
@Suppress("DEPRECATION", "MissingPermission")
fun describeLink(): String = try {
val info = wifiManager.connectionInfo
if (info == null || info.linkSpeed <= 0) {
"链路信息不可用"
} else {
val band = if (Build.VERSION.SDK_INT >= 21 && info.frequency >= 4900) "5GHz" else "2.4GHz"
"链路 ${info.linkSpeed} Mbps · $band · 信号 ${info.rssi} dBm"
}
} catch (e: Exception) {
"链路信息读取失败:${e.message}"
}
/**
* 当前网络的自述:本机地址/掩码、网关、SSID。
*
* 「找不到接收服务」是最难远程排查的一类失败——光看这句话,无法区分
* 手机在哪个网段、有没有拿到网关、还是对端真的没开。把这些直接写进
* 报错里,用户截个图就能定位,不必再来回猜。
*/
fun describeNetwork(network: Network?): String {
if (network == null) return "未绑定到任何网络"
val props = connectivity.getLinkProperties(network)
?: return "已连接,但系统尚未提供链路信息"
val addresses = props.linkAddresses
.filter { it.address is Inet4Address }
.joinToString("、") { "${it.address.hostAddress}/${it.prefixLength}" }
.ifEmpty { "(尚未取得 IPv4)" }
val gateways = props.routes
.mapNotNull { (it.gateway as? Inet4Address)?.hostAddress }
.distinct()
.joinToString("、")
.ifEmpty { "(无)" }
@Suppress("DEPRECATION", "MissingPermission")
val ssid = try {
normalizeSsid(wifiManager.connectionInfo?.ssid).takeIf { it.isNotBlank() && it != "<unknown ssid>" }
} catch (_: Exception) { null } ?: "未知"
return "本机 $addresses · 网关 $gateways · Wi-Fi $ssid"
}
fun gatewayEndpoints(network: Network?, port: Int): List<String> { fun gatewayEndpoints(network: Network?, port: Int): List<String> {
if (network == null) return emptyList() if (network == null) return emptyList()
val props = connectivity.getLinkProperties(network) ?: return emptyList() val props = connectivity.getLinkProperties(network) ?: return emptyList()
return props.routes return props.routes
.asSequence() .asSequence()
.mapNotNull { it.gateway as? Inet4Address } .mapNotNull { it.gateway as? Inet4Address }
// 默认路由的网关可能是 0.0.0.0(直连链路,无下一跳),
// 回环和组播地址也不可能是对端。全都探测一遍纯属浪费时间,
// 而且会把真正的候选挤到后面。
.filterNot { it.isAnyLocalAddress || it.isLoopbackAddress || it.isMulticastAddress }
.map { "http://${it.hostAddress}:$port" } .map { "http://${it.hostAddress}:$port" }
.distinct() .distinct()
.toList() .toList()
} }
/**
* WifiNetworkSpecifier may report IPv4 a few callbacks before DHCP routes
* include the group-owner gateway. Wait on the transfer worker for the route
* belonging to this exact Network instead of guessing Windows ICS ranges.
*/
fun awaitGatewayEndpoints(network: Network?, port: Int, timeoutMs: Long): List<String> {
val deadline = SystemClock.elapsedRealtime() + timeoutMs.coerceAtLeast(0L)
do {
gatewayEndpoints(network, port).takeIf { it.isNotEmpty() }?.let { return it }
if (SystemClock.elapsedRealtime() >= deadline || Thread.currentThread().isInterrupted) break
try {
Thread.sleep(100)
} catch (_: InterruptedException) {
Thread.currentThread().interrupt()
break
}
} while (true)
return gatewayEndpoints(network, port)
}
fun discoveryHosts(network: Network?): List<InetAddress> { fun discoveryHosts(network: Network?): List<InetAddress> {
val out = mutableListOf<InetAddress>() val out = mutableListOf<InetAddress>()
if (network != null) { if (network != null) {
@@ -395,18 +593,28 @@ class WifiConnector(context: Context) {
callback = null callback = null
currentNetwork = null currentNetwork = null
listener = null listener = null
pendingSsid = null pendingWifi = null
pendingDelivered = null pendingDelivered = null
pendingTerminal = null pendingTerminal = null
handler.removeCallbacksAndMessages(null) handler.removeCallbacksAndMessages(null)
if (restoreLegacy && Build.VERSION.SDK_INT < 29) { if (Build.VERSION.SDK_INT < 29) {
val target = legacyTargetNetworkId
val previous = legacyPreviousNetworkId val previous = legacyPreviousNetworkId
if (previous != null && previous >= 0) { if (restoreLegacy && previous != null && previous >= 0 && previous != target) {
try { try {
wifiManager.enableNetwork(previous, true) wifiManager.enableNetwork(previous, true)
wifiManager.reconnect() wifiManager.reconnect()
} catch (_: Exception) {} } catch (_: Exception) {}
} }
// A QFT hotspot is session-scoped. Keeping its generated SSID/PSK
// in the legacy saved-network list is what made a later reservation
// with the same SSID silently reuse stale credentials.
if (target != null && target >= 0) {
try {
wifiManager.removeNetwork(target)
wifiManager.saveConfiguration()
} catch (_: Exception) {}
}
} }
legacyPreviousNetworkId = null legacyPreviousNetworkId = null
legacyTargetNetworkId = null legacyTargetNetworkId = null
@@ -0,0 +1,35 @@
package com.qft.optical
import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue
import org.junit.Test
class PhoneQrLayoutTest {
@Test
fun phoneUsesWidthWithoutOverflowingTheRemainingHeight() {
// 360 × 800 dp at 3× density: width is the limiting dimension.
assertEquals(960, phoneQrSidePx(1080, 2400, 3f))
}
@Test
fun tabletQrDoesNotExpandToTheFullContentWidth() {
// 800 × 1280 dp portrait tablet at 2×: width limits the QR before overflow.
val side = phoneQrSidePx(1600, 2560, 2f)
assertEquals(1520, side)
assertTrue(side + 600 <= 2560)
}
@Test
fun shortOrSplitWindowPrioritizesNoOverflow() {
// 320 × 480 dp at 2×: height becomes the limiting dimension.
val side = phoneQrSidePx(640, 960, 2f)
assertEquals(360, side)
assertTrue(side <= 640)
assertTrue(side + 600 <= 960)
}
@Test
fun invalidMetricsStillReturnASafePositiveSize() {
assertEquals(1, phoneQrSidePx(0, 0, Float.NaN))
}
}
@@ -4,9 +4,154 @@ import org.junit.Assert.*
import org.junit.Test import org.junit.Test
import java.nio.ByteBuffer import java.nio.ByteBuffer
import java.nio.ByteOrder import java.nio.ByteOrder
import java.io.ByteArrayInputStream
import java.util.concurrent.Callable
import java.util.concurrent.ExecutorCompletionService
import java.util.concurrent.Executors
import java.util.zip.CRC32 import java.util.zip.CRC32
class ProtocolTest { class ProtocolTest {
@Test
fun phoneShareHashRequiresTheAdvertisedExactSize() {
val bytes = "phone-share-stable-snapshot".toByteArray()
assertEquals(
"83511688f11a9cb98da9339966f6a0b97e48913102aaad39ae395d2e88f3f65f",
phoneShareSha256Exact(ByteArrayInputStream(bytes), bytes.size.toLong()),
)
assertThrows(IllegalArgumentException::class.java) {
phoneShareSha256Exact(ByteArrayInputStream(bytes), bytes.size.toLong() + 1L)
}
assertThrows(IllegalArgumentException::class.java) {
phoneShareSha256Exact(ByteArrayInputStream(bytes), bytes.size.toLong() - 1L)
}
}
@Test
fun directDiscoveryCarriesTheAndroidDeviceName() {
val request = directDiscoveryRequest(
session = "abcdefghijklmnopqrstuvwxyz012345",
deviceName = "HUAWEI CDY-AN90",
).toString(Charsets.US_ASCII)
val encoded = request.substringAfterLast(':')
assertTrue(request.startsWith("QFTDISC2:abcdefghijklmnopqrstuvwxyz012345:"))
assertEquals("HUAWEI CDY-AN90", Base64Url.decode(encoded)?.toString(Charsets.UTF_8))
}
@Test
fun dedicatedWifiNeverProbesQrOrComputerLanAddresses() {
assertEquals(
listOf("http://192.168.137.1:39393"),
EndpointRouting.afterConnection(
dedicatedWifi = true,
gatewayEndpoints = listOf("http://192.168.137.1:39393"),
routedAdvertisedEndpoints = listOf(
"http://192.168.8.162:39393",
"http://192.168.49.1:39393",
),
),
)
}
@Test
fun dedicatedWifiRecoveryStillRejectsAdvertisedAndGuessedAddresses() {
assertEquals(
listOf("http://192.168.137.1:39393"),
EndpointRouting.forRecovery(
dedicatedWifi = true,
discoveredEndpoint = null,
gatewayEndpoints = listOf("http://192.168.137.1:39393"),
advertisedEndpoints = listOf(
"http://192.168.8.162:39393",
"http://192.168.49.1:39393",
),
),
)
}
@Test
fun currentLanModeCanUseSameSubnetAdvertisedAddresses() {
assertEquals(
listOf("http://192.168.8.1:39393", "http://192.168.8.162:39393"),
EndpointRouting.afterConnection(
dedicatedWifi = false,
gatewayEndpoints = listOf("http://192.168.8.1:39393"),
routedAdvertisedEndpoints = listOf("http://192.168.8.162:39393"),
),
)
}
@Test
fun probeCompletionWaitsForARealResultInsteadOfConsumingAnEmptyPoll() {
val pool = Executors.newSingleThreadExecutor()
try {
val completion = ExecutorCompletionService<String?>(pool)
completion.submit(Callable {
Thread.sleep(380)
"http://192.168.137.1:39393"
})
assertEquals(
"http://192.168.137.1:39393",
awaitFirstNonNull(completion, submitted = 1, timeoutMs = 800),
)
} finally {
pool.shutdownNow()
}
}
@Test
fun probeCompletionKeepsWaitingAfterAnEarlierAddressFails() {
val pool = Executors.newFixedThreadPool(2)
try {
val completion = ExecutorCompletionService<String?>(pool)
completion.submit(Callable { null })
completion.submit(Callable {
Thread.sleep(30)
"http://192.168.137.1:39393"
})
assertEquals(
"http://192.168.137.1:39393",
awaitFirstNonNull(completion, submitted = 2, timeoutMs = 500),
)
} finally {
pool.shutdownNow()
}
}
@Test
fun routeCandidatesOnlyKeepEndpointsOnTheActiveSubnet() {
val endpoints = listOf(
"http://192.168.137.1:39393",
"http://192.168.49.1:39393",
"http://192.168.1.20:39393",
"http://10.20.30.40:39393",
)
assertEquals(
listOf("http://192.168.1.20:39393"),
EndpointRouting.onAnySubnet(endpoints, 39393, listOf("192.168.1.88" to 24)),
)
assertEquals(
listOf("http://10.20.30.40:39393"),
EndpointRouting.onAnySubnet(endpoints, 39393, listOf("10.20.99.2" to 16)),
)
}
@Test
fun routeCandidatesRejectWrongPortsAndMalformedAddresses() {
val endpoints = listOf(
"http://192.168.1.20:39394",
"http://192.168.1.999:39393",
"http://192.168.1.30:39393",
)
assertEquals(
listOf("http://192.168.1.30:39393"),
EndpointRouting.onAnySubnet(endpoints, 39393, listOf("192.168.1.88" to 24)),
)
}
@Test @Test
fun parsesPcToPhoneAutomaticDownloadPairing() { fun parsesPcToPhoneAutomaticDownloadPairing() {
val json = """{"v":2,"s":"abcdefghijklmnopqrstuvwxyz012345","n":"DESKTOP-QFT","p":39393,"e":["http://192.168.49.1:39393"],"d":"d","f":"sample.bin","z":42,"h":"${"00".repeat(32)}"}""" val json = """{"v":2,"s":"abcdefghijklmnopqrstuvwxyz012345","n":"DESKTOP-QFT","p":39393,"e":["http://192.168.49.1:39393"],"d":"d","f":"sample.bin","z":42,"h":"${"00".repeat(32)}"}"""
@@ -17,6 +162,48 @@ class ProtocolTest {
assertEquals(42L, payload.fileSize) assertEquals(42L, payload.fileSize)
} }
@Test
fun parsesDedicatedWifiPairingWithoutAdvertisedComputerAddresses() {
val json = """{"v":2,"s":"abcdefghijklmnopqrstuvwxyz012345","n":"DESKTOP-QFT","p":39393,"e":[],"w":["QFT-DESKTOP-abc123","0123456789abcdef"]}"""
val payload = PairingProtocol.parse(
PairingProtocol.PREFIX_V2 + Base64Url.encode(json.toByteArray()),
)!!
assertNotNull(payload.wifi)
assertEquals("QFT-DESKTOP-abc123", payload.wifi?.ssid)
assertTrue(payload.endpoints.isEmpty())
}
@Test
fun androidPhoneShareQrRoundTripsWithoutEmbeddingTheFileQueue() {
val text = PairingProtocol.encodePhoneShare(
session = "abcdefghijklmnopqrstuvwxyz012345",
senderName = "HUAWEI Mate",
port = 41888,
endpoints = emptyList(),
wifi = WifiCredentials("QFT-Android", "0123456789abcdef", "WPA3"),
)
val payload = PairingProtocol.parse(text)!!
assertTrue(text.startsWith(PairingProtocol.PREFIX_PHONE_V2))
assertEquals(TransferDirection.PHONE_TO_PHONE, payload.direction)
assertEquals("HUAWEI Mate", payload.pcName)
assertEquals("WPA3", payload.wifi?.security)
assertNull(payload.fileName)
assertEquals("/qft/download", payload.downloadPath)
}
@Test
fun androidPhoneShareAcceptsOnlyBoundedByteRanges() {
assertEquals(0L to 9L, phoneShareRange(null, 10))
assertEquals(2L to 9L, phoneShareRange("bytes=2-", 10))
assertEquals(2L to 6L, phoneShareRange("bytes=2-6", 10))
assertNull(phoneShareRange("bytes=-3", 10))
assertNull(phoneShareRange("bytes=8-3", 10))
assertNull(phoneShareRange("bytes=10-", 10))
assertNull(phoneShareRange("items=0-2", 10))
}
@Test @Test
fun base45KnownVectors() { fun base45KnownVectors() {
assertArrayEquals("AB".toByteArray(), Base45.decode("BB8")) assertArrayEquals("AB".toByteArray(), Base45.decode("BB8"))
@@ -0,0 +1,26 @@
package com.qft.optical
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertTrue
import org.junit.Test
class TransferQueueTest {
@Test
fun movesFilesInBothDirectionsWithoutLosingItems() {
val queue = mutableListOf("A", "B", "C", "D")
assertTrue(moveQueueItem(queue, 0, 2))
assertEquals(listOf("B", "C", "A", "D"), queue)
assertTrue(moveQueueItem(queue, 3, 1))
assertEquals(listOf("B", "D", "C", "A"), queue)
}
@Test
fun rejectsInvalidOrNoOpMoves() {
val queue = mutableListOf("A", "B")
assertFalse(moveQueueItem(queue, -1, 0))
assertFalse(moveQueueItem(queue, 0, 2))
assertFalse(moveQueueItem(queue, 1, 1))
assertEquals(listOf("A", "B"), queue)
}
}
Binary file not shown.
+1 -1
View File
@@ -1,6 +1,6 @@
distributionBase=GRADLE_USER_HOME distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-8.11.1-bin.zip distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.5-bin.zip
networkTimeout=10000 networkTimeout=10000
validateDistributionUrl=true validateDistributionUrl=true
zipStoreBase=GRADLE_USER_HOME zipStoreBase=GRADLE_USER_HOME
+20 -2
View File
@@ -2586,8 +2586,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d55d956fa96f5ec02be2e13af0e20391a5aa83d6a074e3ad368959d0fab299ea" checksum = "d55d956fa96f5ec02be2e13af0e20391a5aa83d6a074e3ad368959d0fab299ea"
[[package]] [[package]]
name = "qft-windows" name = "qft-desktop"
version = "0.4.6" version = "0.4.16"
dependencies = [ dependencies = [
"anyhow", "anyhow",
"base64", "base64",
@@ -2601,6 +2601,7 @@ dependencies = [
"serde", "serde",
"serde_json", "serde_json",
"sha2", "sha2",
"whoami",
"windows", "windows",
] ]
@@ -3471,6 +3472,12 @@ dependencies = [
"wit-bindgen", "wit-bindgen",
] ]
[[package]]
name = "wasite"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b"
[[package]] [[package]]
name = "wasm-bindgen" name = "wasm-bindgen"
version = "0.2.127" version = "0.2.127"
@@ -3881,6 +3888,17 @@ dependencies = [
"web-sys", "web-sys",
] ]
[[package]]
name = "whoami"
version = "1.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5d4a4db5077702ca3015d3d02d74974948aba2ad9e12ab7df718ee64ccd7e97d"
dependencies = [
"libredox",
"wasite",
"web-sys",
]
[[package]] [[package]]
name = "winapi-util" name = "winapi-util"
version = "0.1.11" version = "0.1.11"
+6 -2
View File
@@ -1,6 +1,6 @@
[package] [package]
name = "qft-windows" name = "qft-desktop"
version = "0.4.6" version = "0.4.16"
edition = "2024" edition = "2024"
rust-version = "1.95" rust-version = "1.95"
@@ -17,9 +17,13 @@ serde = { version = "1.0.219", features = ["derive"] }
serde_json = "1.0.143" serde_json = "1.0.143"
if-addrs = "0.13.4" if-addrs = "0.13.4"
rayon = "1.11.0" rayon = "1.11.0"
# 跨平台取本机名:macOS 上 HOSTNAME 环境变量通常不存在,
# Linux 上默认也不导出,只靠 env 会退化成占位名。
whoami = "1.6"
[target.'cfg(windows)'.dependencies] [target.'cfg(windows)'.dependencies]
windows = { version = "0.62.2", features = [ windows = { version = "0.62.2", features = [
"Devices_Enumeration",
"Devices_WiFiDirect", "Devices_WiFiDirect",
"Security_Credentials", "Security_Credentials",
] } ] }
+798
View File
@@ -0,0 +1,798 @@
//! 桌面端的**发起侧**。
//!
//! v0.4.7 之前桌面端只有服务端(`receiver.rs` / `sender.rs`),
//! `TcpStream::connect` 只出现在测试里,因此 PC 无法主动连接另一台 PC。
//! 本模块补上这一半,PC↔PC 才成立。
//!
//! 线格式与 Android `UploadClient.kt`/`DownloadClient.kt`、
//! iOS `UploadClient.swift`/`DownloadClient.swift` 完全一致——沿用现有 v2 HTTP,
//! 不引入 HTTP 客户端依赖:服务端本来就是手写的,两边保持同一套解析更容易对齐。
use anyhow::{bail, Context, Result};
use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine as _};
use std::{
collections::HashMap,
fs::{File, OpenOptions},
io::{BufRead, BufReader, Read, Seek, SeekFrom, Write},
net::{SocketAddr, TcpStream, ToSocketAddrs},
path::{Path, PathBuf},
sync::{
atomic::{AtomicU32, AtomicU64, Ordering},
Arc,
},
time::Duration,
};
const IO_BUFFER: usize = 1024 * 1024;
/// 与移动端一致:按文件大小自适应 4/8/16 MiB
const CHUNK_SMALL: u64 = 4 * 1024 * 1024;
const CHUNK_DEFAULT: u64 = 8 * 1024 * 1024;
const CHUNK_LARGE: u64 = 16 * 1024 * 1024;
const MAX_WORKERS: usize = 8;
#[derive(Clone, Debug)]
pub struct PeerClient {
/// 形如 `http://192.168.1.20:39393`
pub base_url: String,
pub token: String,
pub device_name: String,
}
#[derive(Clone, Copy, Debug)]
pub struct Progress {
pub done: u64,
/// 单个文件的总量。多文件发送时 UI 用的是跨文件的累计总量,
/// 因此当前没有读者;保留是为了让回调本身自洽,
/// 单文件场景(如 P2 的目录传输逐项进度)会用到。
#[allow(dead_code)]
pub total: u64,
}
impl PeerClient {
pub fn new(base_url: impl Into<String>, token: impl Into<String>, device_name: impl Into<String>) -> Self {
Self {
base_url: base_url.into(),
token: token.into(),
device_name: device_name.into(),
}
}
fn address(&self) -> Result<SocketAddr> {
let rest = self
.base_url
.strip_prefix("http://")
.context("端点必须以 http:// 开头")?;
let rest = rest.trim_end_matches('/');
if rest.contains('/') {
bail!("端点不允许带路径:{}", self.base_url)
}
rest.to_socket_addrs()
.with_context(|| format!("无法解析端点 {}", self.base_url))?
.next()
.with_context(|| format!("端点无可用地址 {}", self.base_url))
}
fn auth_headers(&self) -> Vec<(String, String)> {
vec![
("X-QFT-Token".into(), self.token.clone()),
(
"X-QFT-Device".into(),
URL_SAFE_NO_PAD.encode(self.device_name.as_bytes()),
),
]
}
/// `GET /qft/ping`。用于发现阶段快速验证「这个地址上确实是我要找的那台 QFT」。
// 供 P1.5 的发现流程与后续的可达性诊断使用,当前 UI 尚未接线
#[allow(dead_code)]
pub fn ping(&self, timeout: Duration) -> Result<serde_json::Value> {
let address = self.address()?;
let mut response = send_request(address, "GET", "/qft/ping", &self.auth_headers(), None, timeout)?;
if response.status != 200 {
bail!("ping 返回 HTTP {}", response.status)
}
let body = response.read_body()?;
serde_json::from_slice(&body).context("ping 响应不是 JSON")
}
/// `POST /qft/pair`:用 6 位配对码换取会话令牌。
///
/// PC↔PC 的入口——桌面端没有摄像头,扫不了二维码,
/// 只能由用户把对方屏幕上的 6 位数字敲进来。
pub fn pair(base_url: &str, code: &str, device_name: &str) -> Result<String> {
let probe = PeerClient::new(base_url, String::new(), device_name.to_owned());
let address = probe.address()?;
let mut headers = vec![
("X-QFT-Code".to_string(), code.to_string()),
(
"X-QFT-Device".to_string(),
URL_SAFE_NO_PAD.encode(device_name.as_bytes()),
),
];
headers.push(("Content-Length".to_string(), "0".to_string()));
let mut response = send_request(
address,
"POST",
"/qft/pair",
&headers[..2],
Some(&[]),
// 配对只是一次极小的请求,4 秒还没建连基本就是不通了。
// 拖到 10 秒只会让用户以为程序卡死。
Duration::from_secs(4),
)?;
let body = response.read_body()?;
let value: serde_json::Value = serde_json::from_slice(&body).unwrap_or(serde_json::Value::Null);
match response.status {
200 => value["token"]
.as_str()
.map(str::to_owned)
.context("配对响应缺少 token"),
403 => {
let remaining = value["remaining"].as_u64().unwrap_or(0);
bail!("配对码错误,还可尝试 {remaining} 次")
}
429 => bail!("配对码已作废,请让对方在电脑上重新启动接收"),
other => bail!("配对返回 HTTP {other}"),
}
}
// ------------------------------------------------------------ 上传
/// 把本地文件推送到对端的接收服务(对端跑 `receiver.rs`)。
pub fn upload_file(
&self,
path: &Path,
mut on_progress: impl FnMut(Progress) + Send,
) -> Result<String> {
let address = self.address()?;
let size = std::fs::metadata(path)
.with_context(|| format!("读取 {} 失败", path.display()))?
.len();
let name = path
.file_name()
.and_then(|v| v.to_str())
.filter(|v| !v.is_empty())
.unwrap_or("qft-upload.bin");
let session = self.init_upload(address, name, size)?;
if session.total_chunks == 0 {
on_progress(Progress { done: 0, total: 0 });
return self.finish_upload(address, &session.upload_id);
}
let next = Arc::new(AtomicU32::new(0));
let sent = Arc::new(AtomicU64::new(0));
let workers = (session.total_chunks as usize).min(MAX_WORKERS).max(1);
// 进度回调在主线程汇总:worker 只累加原子计数,避免把 FnMut 塞进多个线程。
// 主线程随后在此轮询上报——早先只在 scope 结束后报一次,
// 结果传 1 GB 的过程中进度条一直是 0%,最后才跳到 100%。
let failure = std::thread::scope(|scope| -> Result<()> {
let mut handles = Vec::with_capacity(workers);
for _ in 0..workers {
let next = next.clone();
let sent = sent.clone();
let session = &session;
handles.push(scope.spawn(move || -> Result<()> {
let mut file = File::open(path)?;
let mut buffer = vec![0u8; session.chunk_size as usize];
loop {
let index = next.fetch_add(1, Ordering::Relaxed);
if index >= session.total_chunks {
return Ok(());
}
let offset = index as u64 * session.chunk_size;
let length = (size - offset).min(session.chunk_size) as usize;
file.seek(SeekFrom::Start(offset))?;
file.read_exact(&mut buffer[..length])?;
self.put_chunk(address, &session.upload_id, index, &buffer[..length], &sent)?;
}
}));
}
// worker 跑着的时候持续上报,不要等它们全部结束
while !handles.iter().all(|h| h.is_finished()) {
on_progress(Progress {
done: sent.load(Ordering::Relaxed).min(size),
total: size,
});
std::thread::sleep(Duration::from_millis(40));
}
let mut error = None;
for handle in handles {
match handle.join() {
Ok(Ok(())) => {}
Ok(Err(e)) => {
error.get_or_insert(e);
}
Err(_) => {
error.get_or_insert(anyhow::anyhow!("上传线程崩溃"));
}
}
}
match error {
Some(e) => Err(e),
None => Ok(()),
}
});
failure?;
on_progress(Progress { done: size, total: size });
self.finish_upload(address, &session.upload_id)
}
fn init_upload(&self, address: SocketAddr, name: &str, size: u64) -> Result<UploadSession> {
let chunk_size = desired_chunk_size(size);
let mut headers = self.auth_headers();
headers.push((
"X-QFT-Filename".into(),
URL_SAFE_NO_PAD.encode(name.as_bytes()),
));
headers.push(("X-QFT-Size".into(), size.to_string()));
headers.push(("X-QFT-Chunk-Size".into(), chunk_size.to_string()));
let mut response = send_request(
address,
"POST",
"/qft/upload/init",
&headers,
Some(&[]),
Duration::from_secs(15),
)?;
if response.status != 200 {
bail!("init 返回 HTTP {}", response.status)
}
let body = response.read_body()?;
let value: serde_json::Value = serde_json::from_slice(&body).context("init 响应不是 JSON")?;
Ok(UploadSession {
upload_id: value["upload_id"]
.as_str()
.context("init 响应缺少 upload_id")?
.to_owned(),
chunk_size: value["chunk_size"].as_u64().context("init 响应缺少 chunk_size")?,
total_chunks: value["total_chunks"]
.as_u64()
.context("init 响应缺少 total_chunks")? as u32,
})
}
fn put_chunk(
&self,
address: SocketAddr,
upload_id: &str,
index: u32,
body: &[u8],
sent: &AtomicU64,
) -> Result<()> {
let path = format!("/qft/upload/chunk/{upload_id}/{index}");
// 接收端对重复分块是幂等的,因此重试安全。
// 局域网上首次连接常被 Windows 防火墙首包丢弃,一次重试就能救回来。
let mut last = None;
for attempt in 0..3 {
// 本次尝试写出的字节单独计一份:失败时要从总数里扣回去,
// 否则重试会让进度虚高甚至超过 100%
let attempted = AtomicU64::new(0);
let mut sink = |n: usize| {
attempted.fetch_add(n as u64, Ordering::Relaxed);
sent.fetch_add(n as u64, Ordering::Relaxed);
};
let outcome = send_request_with_progress(
address,
"POST",
&path,
&self.auth_headers(),
Some(body),
Duration::from_secs(60),
Some(&mut sink),
);
drop(sink);
if outcome.is_err() || outcome.as_ref().is_ok_and(|r| r.status != 200) {
sent.fetch_sub(attempted.load(Ordering::Relaxed), Ordering::Relaxed);
}
match outcome {
Ok(mut response) => {
let payload = response.read_body()?;
if response.status == 200 {
return Ok(());
}
last = Some(anyhow::anyhow!(
"chunk {index} 返回 HTTP {}:{}",
response.status,
String::from_utf8_lossy(&payload[..payload.len().min(200)])
));
}
Err(e) => last = Some(e),
}
std::thread::sleep(Duration::from_millis(120 << attempt));
}
Err(last.unwrap_or_else(|| anyhow::anyhow!("chunk {index} 失败")))
}
fn finish_upload(&self, address: SocketAddr, upload_id: &str) -> Result<String> {
let path = format!("/qft/upload/finish/{upload_id}");
let mut response = send_request(
address,
"POST",
&path,
&self.auth_headers(),
Some(&[]),
Duration::from_secs(120),
)?;
let body = response.read_body()?;
if response.status != 200 {
bail!(
"finish 返回 HTTP {}:{}",
response.status,
String::from_utf8_lossy(&body[..body.len().min(200)])
)
}
let value: serde_json::Value = serde_json::from_slice(&body).context("finish 响应不是 JSON")?;
value["sha256"]
.as_str()
.map(str::to_owned)
.context("finish 响应缺少 sha256")
}
// ------------------------------------------------------------ 下载
/// 从对端的发送服务拉取文件(对端跑 `sender.rs`)。
/// 支持断点续传:`dest` 已存在的部分会作为 Range 起点。
// PC↔PC 目前只做「推送」,「主动拉取」在 P2 的会话模型里才用得上
#[allow(dead_code)]
pub fn download_file(
&self,
dest: &Path,
expected_size: Option<u64>,
mut on_progress: impl FnMut(Progress),
) -> Result<PathBuf> {
let address = self.address()?;
let part = dest.with_extension("qftpart");
let mut offset = part.metadata().map(|m| m.len()).unwrap_or(0);
if let Some(expected) = expected_size {
if offset > expected {
let _ = std::fs::remove_file(&part);
offset = 0;
}
}
let mut headers = self.auth_headers();
if offset > 0 {
headers.push(("Range".into(), format!("bytes={offset}-")));
}
let mut response = send_request(
address,
"GET",
"/qft/download",
&headers,
None,
Duration::from_secs(30),
)?;
if response.status != 200 && response.status != 206 {
bail!("下载返回 HTTP {}", response.status)
}
if response.status == 200 {
// 服务端忽略了 Range(旧版本),只能从头写
offset = 0;
}
let remaining = response
.headers
.get("content-length")
.and_then(|v| v.parse::<u64>().ok());
let total = expected_size.or_else(|| remaining.map(|r| offset + r)).unwrap_or(0);
if let Some(parent) = part.parent() {
platform_ensure_dir(parent)?;
}
let mut out = OpenOptions::new()
.create(true)
.write(true)
.open(&part)
.with_context(|| format!("创建 {} 失败", part.display()))?;
out.seek(SeekFrom::Start(offset))?;
out.set_len(offset)?;
let mut done = offset;
let mut buffer = vec![0u8; IO_BUFFER];
loop {
let n = response.reader.read(&mut buffer)?;
if n == 0 {
break;
}
out.write_all(&buffer[..n])?;
done += n as u64;
on_progress(Progress { done, total });
}
out.flush()?;
drop(out);
if let Some(expected) = expected_size {
if done != expected {
bail!("下载提前结束:{done}/{expected}")
}
}
std::fs::rename(&part, dest)
.with_context(|| format!("重命名 {} 失败", part.display()))?;
Ok(dest.to_path_buf())
}
}
struct UploadSession {
upload_id: String,
chunk_size: u64,
total_chunks: u32,
}
fn desired_chunk_size(size: u64) -> u64 {
if size < 32 * 1024 * 1024 {
CHUNK_SMALL
} else if size >= 512 * 1024 * 1024 {
CHUNK_LARGE
} else {
CHUNK_DEFAULT
}
}
#[allow(dead_code)] // 仅被尚未接线的 download_file 使用
fn platform_ensure_dir(path: &Path) -> Result<()> {
crate::platform::ensure_dir(path)
.with_context(|| format!("创建目录 {} 失败", path.display()))
}
/// 把底层 io 错误翻译成能指导下一步的说法。
///
/// 「超时」和「被拒绝」的成因完全不同:前者是包被丢了(防火墙、主机不可达、
/// AP 客户端隔离),后者是端口上没人监听(对方没点"启动接收")。
/// 给用户一句笼统的"连接失败"等于什么都没说。
fn describe_connect_failure(address: SocketAddr, error: &std::io::Error) -> anyhow::Error {
use std::io::ErrorKind;
let ip = address.ip();
match error.kind() {
ErrorKind::TimedOut => anyhow::anyhow!(
"连接 {address} 超时:数据包发出去了但没有任何回应。\n\
常见原因:① 对方电脑的防火墙拦截了入站连接(Windows 上需要放行 qft-desktop.exe 的专用网络);\
② Wi-Fi 开了客户端隔离,同网段设备之间不能互通;\
③ 对方已经关掉接收或换了网络。"
),
ErrorKind::ConnectionRefused => anyhow::anyhow!(
"{ip} 明确拒绝了连接:主机在线,但 {} 端口上没有程序在监听。\n\
请确认对方已经在「我要接收」里点了「启动接收」,并且连接码是最新的那一串。",
address.port()
),
ErrorKind::HostUnreachable | ErrorKind::NetworkUnreachable => anyhow::anyhow!(
"路由不可达:本机没有能到达 {ip} 的路由。请确认两台设备连在同一个网络里。"
),
_ => anyhow::anyhow!("连接 {address} 失败:{error}"),
}
}
// ---------------------------------------------------------------- 极简 HTTP 客户端
struct HttpResponse {
status: u16,
headers: HashMap<String, String>,
reader: BufReader<TcpStream>,
}
impl HttpResponse {
/// 读完整个响应体。服务端总是发 `Connection: close`,
/// 所以按 Content-Length 读,没有该头则读到 EOF。
fn read_body(&mut self) -> Result<Vec<u8>> {
let mut body = Vec::new();
match self.headers.get("content-length").and_then(|v| v.parse::<u64>().ok()) {
Some(length) => {
body.resize(length as usize, 0);
self.reader.read_exact(&mut body)?;
}
None => {
self.reader.read_to_end(&mut body)?;
}
}
Ok(body)
}
}
fn send_request(
address: SocketAddr,
method: &str,
path: &str,
headers: &[(String, String)],
body: Option<&[u8]>,
timeout: Duration,
) -> Result<HttpResponse> {
send_request_with_progress(address, method, path, headers, body, timeout, None)
}
/// `on_body_written` 会在请求体每写出一片后被调用。
/// 大文件分块是 16 MiB,若等整块写完才计数,进度条就是一格一格跳的。
fn send_request_with_progress(
address: SocketAddr,
method: &str,
path: &str,
headers: &[(String, String)],
body: Option<&[u8]>,
timeout: Duration,
mut on_body_written: Option<&mut dyn FnMut(usize)>,
) -> Result<HttpResponse> {
let stream = TcpStream::connect_timeout(&address, timeout.min(Duration::from_secs(10)))
.map_err(|e| describe_connect_failure(address, &e))?;
stream.set_nodelay(true).ok();
stream.set_read_timeout(Some(timeout))?;
stream.set_write_timeout(Some(timeout))?;
let mut request = String::with_capacity(256);
request.push_str(&format!("{method} {path} HTTP/1.1\r\n"));
request.push_str(&format!("Host: {address}\r\n"));
request.push_str("Connection: close\r\n");
for (name, value) in headers {
request.push_str(&format!("{name}: {value}\r\n"));
}
if let Some(body) = body {
request.push_str("Content-Type: application/octet-stream\r\n");
request.push_str(&format!("Content-Length: {}\r\n", body.len()));
}
request.push_str("\r\n");
let mut writer = stream.try_clone()?;
writer.write_all(request.as_bytes())?;
if let Some(body) = body {
// 256 KiB 一片:足够小,进度看起来是连续的;
// 又足够大,不会因为频繁 write 拖慢吞吐
const SLICE: usize = 256 * 1024;
for part in body.chunks(SLICE) {
writer.write_all(part)?;
if let Some(sink) = on_body_written.as_deref_mut() {
sink(part.len());
}
}
}
writer.flush()?;
let mut reader = BufReader::with_capacity(64 * 1024, stream);
let mut status_line = String::new();
reader.read_line(&mut status_line)?;
if status_line.is_empty() {
bail!("对端在返回状态行前关闭了连接")
}
let status: u16 = status_line
.split_whitespace()
.nth(1)
.and_then(|v| v.parse().ok())
.with_context(|| format!("无法解析状态行:{}", status_line.trim()))?;
let mut response_headers = HashMap::new();
loop {
let mut line = String::new();
let n = reader.read_line(&mut line)?;
if n == 0 {
bail!("对端在返回响应头前关闭了连接")
}
if line == "\r\n" || line == "\n" {
break;
}
if let Some((name, value)) = line.split_once(':') {
response_headers.insert(name.trim().to_ascii_lowercase(), value.trim().to_owned());
}
}
Ok(HttpResponse {
status,
headers: response_headers,
reader,
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn rejects_endpoints_with_path_or_wrong_scheme() {
let make = |url: &str| PeerClient::new(url, "token", "dev").address();
assert!(make("https://192.168.1.1:39393").is_err());
assert!(make("http://192.168.1.1:39393/qft").is_err());
assert!(make("192.168.1.1:39393").is_err());
assert!(make("http://127.0.0.1:39393").is_ok());
// 结尾斜杠应被容忍
assert!(make("http://127.0.0.1:39393/").is_ok());
}
#[test]
fn chunk_size_matches_mobile_clients() {
assert_eq!(desired_chunk_size(1024), CHUNK_SMALL);
assert_eq!(desired_chunk_size(31 * 1024 * 1024), CHUNK_SMALL);
assert_eq!(desired_chunk_size(64 * 1024 * 1024), CHUNK_DEFAULT);
assert_eq!(desired_chunk_size(600 * 1024 * 1024), CHUNK_LARGE);
}
}
#[cfg(test)]
mod integration_tests {
use super::*;
use crate::receiver::{ReceiverEvent, ReceiverServer};
use std::sync::mpsc;
/// 端到端:起一个真实的接收服务,用真实的 HTTP 客户端配对 + 上传,
/// 校验落盘文件的 SHA-256 与接收端返回值一致。
/// 这就是 PC↔PC 的完整链路,只是两端在同一进程里。
#[test]
fn pairs_then_uploads_a_real_file() {
let root = std::env::temp_dir().join(format!("qft-pcpc-{}", std::process::id()));
let inbox = root.join("inbox");
std::fs::create_dir_all(&inbox).unwrap();
let source = root.join("payload.bin");
// 跨越多个分块边界的大小,确保并发路径被覆盖
let payload: Vec<u8> = (0..(9 * 1024 * 1024 + 777)).map(|i| (i % 251) as u8).collect();
std::fs::write(&source, &payload).unwrap();
let token = crate::pairing::new_session_token();
let (tx, rx) = mpsc::channel::<ReceiverEvent>();
let server = ReceiverServer::start(inbox.clone(), token.clone(), tx).unwrap();
let base_url = format!("http://127.0.0.1:{}", server.port);
// 走完整的连接码链路:编码 → 用户输入 → 解码 → 换令牌
let code = crate::connect_code::ConnectCode::new(
std::net::IpAddr::V4(std::net::Ipv4Addr::LOCALHOST),
server.port,
server.secret,
);
let typed = code.encode();
let parsed = crate::connect_code::ConnectCode::decode(&typed).expect("连接码应能解析");
assert_eq!(parsed.base_url(), base_url, "码里解出的地址应与实际服务一致");
// 错误秘密必须被拒
assert!(PeerClient::pair(&base_url, "000000", "tester").is_err());
let paired = PeerClient::pair(&base_url, &parsed.secret_hex(), "tester").unwrap();
assert_eq!(paired, token, "配对应返回真实会话令牌");
let client = PeerClient::new(base_url, paired, "tester");
let mut samples: Vec<Progress> = Vec::new();
let sha = client.upload_file(&source, |p| samples.push(p)).unwrap();
let last = *samples.last().expect("至少应有一次进度回调");
assert_eq!(last.done, payload.len() as u64, "进度应抵达文件全长");
// 回环传输太快,采样次数不稳定,这里只断言稳健的性质;
// 「边传边报」的机制由 body_progress_is_reported_incrementally 覆盖。
assert!(
samples.windows(2).all(|w| w[0].done <= w[1].done),
"进度必须单调不减:{samples:?}"
);
assert!(
samples.iter().all(|p| p.done <= payload.len() as u64),
"进度不得超过文件总长(重试重复计数会导致这种情况):{samples:?}"
);
let landed = inbox.join("payload.bin");
let saved = std::fs::read(&landed).expect("文件应已落盘");
assert_eq!(saved.len(), payload.len());
assert_eq!(saved, payload, "落盘内容必须逐字节一致");
use sha2::{Digest, Sha256};
let expected = Sha256::digest(&payload);
let expected_hex: String = expected.iter().map(|b| format!("{b:02x}")).collect();
assert_eq!(sha, expected_hex, "接收端返回的 SHA-256 必须与本地一致");
drop(server);
while rx.try_recv().is_ok() {}
let _ = std::fs::remove_dir_all(&root);
}
}
#[cfg(test)]
mod failure_message_tests {
use super::*;
/// 不可达地址必须给出「超时」类的排查建议,而不是一句空洞的失败。
#[test]
fn unreachable_host_yields_actionable_timeout_message() {
// 192.0.2.0/24 是 RFC 5737 保留的文档用网段,不会有真实主机应答
let error = PeerClient::pair("http://192.0.2.1:39393", "abcdef", "tester")
.expect_err("不可达地址必须失败");
let text = format!("{error:#}");
assert!(text.contains("防火墙") || text.contains("超时") || text.contains("路由"),
"应给出可执行的排查方向,实得:{text}");
}
/// 本机没人监听的端口会被内核直接拒绝,提示必须与"超时"区分开。
#[test]
fn refused_port_says_receiver_not_started() {
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
drop(listener); // 端口随即空出,连接会被拒绝
let error = PeerClient::pair(&format!("http://127.0.0.1:{port}"), "abcdef", "tester")
.expect_err("空端口必须失败");
let text = format!("{error:#}");
assert!(text.contains("启动接收") || text.contains("拒绝"),
"被拒绝时应提示对方没启动接收,实得:{text}");
}
}
#[cfg(test)]
mod progress_tests {
use super::*;
use std::io::{BufRead, Read, Write};
use std::sync::atomic::AtomicUsize;
/// 极简 mock:按 Content-Length 精确读完请求体再应答。
///
/// 不能用 read_to_end——那会一直等到客户端关闭写端,
/// 而客户端此时正在等响应,两边互等直接死锁。
fn serve_once(listener: std::net::TcpListener) -> std::thread::JoinHandle<usize> {
std::thread::spawn(move || {
let Ok((stream, _)) = listener.accept() else { return 0 };
let mut reader = std::io::BufReader::new(stream.try_clone().unwrap());
let mut length = 0usize;
loop {
let mut line = String::new();
if reader.read_line(&mut line).unwrap_or(0) == 0 {
break;
}
if line == "\r\n" || line == "\n" {
break;
}
if let Some((name, value)) = line.split_once(':') {
if name.trim().eq_ignore_ascii_case("content-length") {
length = value.trim().parse().unwrap_or(0);
}
}
}
let mut body = vec![0u8; length];
let _ = reader.read_exact(&mut body);
let mut out = stream;
let _ = out.write_all(
b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\n{}",
);
let _ = out.flush();
length
})
}
/// 锁住「边写边报」这个行为。
///
/// 早先 `on_progress` 只在所有 worker 结束后调用一次,传 1 GB 时
/// 进度条全程 0%、最后才跳到 100%。这里直接验证请求体是分片写出并
/// 逐片上报的——回环速度太快时集成测试采样不到,只有这一层能稳定拦住回归。
#[test]
fn body_progress_is_reported_incrementally() {
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let address = listener.local_addr().unwrap();
let server = serve_once(listener);
let body = vec![7u8; 5 * 256 * 1024]; // 正好 5 片
let calls = AtomicUsize::new(0);
let total = AtomicU64::new(0);
let mut sink = |n: usize| {
calls.fetch_add(1, Ordering::Relaxed);
total.fetch_add(n as u64, Ordering::Relaxed);
};
let response = send_request_with_progress(
address, "POST", "/x", &[], Some(&body),
Duration::from_secs(10), Some(&mut sink),
);
drop(sink);
assert!(response.is_ok(), "请求应成功:{:?}", response.err());
assert_eq!(server.join().unwrap(), body.len(), "服务端应收到完整请求体");
assert_eq!(calls.load(Ordering::Relaxed), 5, "5 片体应上报 5 次");
assert_eq!(
total.load(Ordering::Relaxed),
body.len() as u64,
"上报总量应等于请求体长度"
);
}
#[test]
fn no_progress_sink_is_allowed() {
// init/finish/ping 都不需要进度,不传 sink 时不能出问题
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let address = listener.local_addr().unwrap();
let server = serve_once(listener);
let result = send_request(address, "POST", "/x", &[], Some(b"hi"), Duration::from_secs(10));
assert!(result.is_ok(), "无 sink 时请求也应成功:{:?}", result.err());
assert_eq!(server.join().unwrap(), 2);
}
}
+425
View File
@@ -0,0 +1,425 @@
//! QFT 连接码:把「去哪连」和「凭什么连」压进一串可口述的短码。
//!
//! 此前 PC↔PC 要用户分别念 IP、端口、6 位配对码三样东西,既啰嗦又容易错。
//! 连接码把它们合成一串,**地址就编在码里**,所以发送方拿到码即可直连,
//! 不需要广播、不需要在同一网段——只要 IP 层路由可达即可。
//! 同一路由器下的不同 VLAN/网段正属于这种情况。
//!
//! 必须说清的边界:连接码解决的是「找不到对方」和「输入太繁琐」。
//! 如果两台机器在 IP 层根本互不可达(AP 客户端隔离、各自在不同的物理网络),
//! 任何客户端侧协议都无法凭空造出可达性,只能换链路或引入第三方中转。
//!
//! 编码
//! ```text
//! byte0 version(3) | kind(3) | default_port(1) | reserved(1)
//! addr 2~4 字节(按 kind 压缩私有网段)或 16 字节(IPv6)
//! port 2 字节,仅当非默认端口时存在
//! secret 3 字节(24 bit)
//! crc 1 字节 CRC-8
//! ```
//! 典型的 `192.168.a.b:39393` 共 7 字节 → Crockford Base32 → **12 个字符**。
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
/// Crockford Base32:去掉了容易混淆的 I、L、O、U。
const ALPHABET: &[u8; 32] = b"0123456789ABCDEFGHJKMNPQRSTVWXYZ";
const VERSION: u8 = 1;
pub const DEFAULT_PORT: u16 = 39393;
pub const SECRET_LEN: usize = 3;
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
enum AddrKind {
/// 192.168.a.b —— 2 字节
Private192 = 0,
/// 10.a.b.c —— 3 字节
Private10 = 1,
/// 172.(16..=31).a.b —— 3 字节
Private172 = 2,
/// 任意 IPv4 —— 4 字节
FullV4 = 3,
/// IPv6 —— 16 字节。码会长到 32 字符左右,适合复制粘贴而非口述,
/// 但它是「双方都有公网 IPv6 时无需任何服务器即可直连」的唯一途径。
V6 = 4,
}
impl AddrKind {
fn from_bits(bits: u8) -> Option<Self> {
Some(match bits {
0 => Self::Private192,
1 => Self::Private10,
2 => Self::Private172,
3 => Self::FullV4,
4 => Self::V6,
_ => return None,
})
}
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct ConnectCode {
pub address: IpAddr,
pub port: u16,
pub secret: [u8; SECRET_LEN],
}
#[derive(Debug, PartialEq, Eq)]
pub enum CodeError {
/// 长度不对,多半是漏敲或多敲了字符
Length,
/// 出现了字母表之外的字符
Alphabet(char),
/// 校验位不匹配——几乎可以肯定是输错了某一位
Checksum,
/// 版本或地址类型无法识别
Unsupported,
}
impl std::fmt::Display for CodeError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Length => write!(f, "连接码长度不对,请检查是否漏敲或多敲了字符"),
Self::Alphabet(ch) => write!(f, "连接码里有无效字符 '{ch}'"),
Self::Checksum => write!(f, "连接码校验失败,请核对后重新输入"),
Self::Unsupported => write!(f, "无法识别的连接码版本"),
}
}
}
impl std::error::Error for CodeError {}
impl ConnectCode {
pub fn new(address: IpAddr, port: u16, secret: [u8; SECRET_LEN]) -> Self {
Self { address, port, secret }
}
/// 秘密的线上表示:6 个小写十六进制字符,放在 `X-QFT-Code` 头里。
pub fn secret_hex(&self) -> String {
self.secret.iter().map(|b| format!("{b:02x}")).collect()
}
pub fn base_url(&self) -> String {
match self.address {
IpAddr::V4(v4) => format!("http://{v4}:{}", self.port),
IpAddr::V6(v6) => format!("http://[{v6}]:{}", self.port),
}
}
/// 编码为分组显示的字符串,例如 `K7M2-9X4P-QR3T`。
pub fn encode(&self) -> String {
let bytes = self.to_bytes();
let raw = base32_encode(&bytes);
raw.as_bytes()
.chunks(4)
.map(|chunk| std::str::from_utf8(chunk).unwrap_or_default())
.collect::<Vec<_>>()
.join("-")
}
/// 解析用户输入。分隔符、大小写、以及 I/L→1、O→0 的手误都会被容忍。
pub fn decode(text: &str) -> Result<Self, CodeError> {
let (bytes, padding_ok) = base32_decode(text)?;
// 先判长度:码太短时「长度不对」比「校验失败」更能指导用户,
// 再判填充位与 CRC。
let code = Self::from_bytes(&bytes)?;
if !padding_ok {
return Err(CodeError::Checksum);
}
Ok(code)
}
fn to_bytes(&self) -> Vec<u8> {
let (kind, addr_bytes) = match self.address {
IpAddr::V4(v4) => {
let o = v4.octets();
match (o[0], o[1]) {
(192, 168) => (AddrKind::Private192, vec![o[2], o[3]]),
(10, _) => (AddrKind::Private10, vec![o[1], o[2], o[3]]),
(172, 16..=31) => (AddrKind::Private172, vec![o[1] - 16, o[2], o[3]]),
_ => (AddrKind::FullV4, o.to_vec()),
}
}
IpAddr::V6(v6) => (AddrKind::V6, v6.octets().to_vec()),
};
let default_port = self.port == DEFAULT_PORT;
let mut out = Vec::with_capacity(1 + addr_bytes.len() + 2 + SECRET_LEN + 1);
out.push((VERSION << 5) | ((kind as u8) << 2) | ((default_port as u8) << 1));
out.extend_from_slice(&addr_bytes);
if !default_port {
out.extend_from_slice(&self.port.to_be_bytes());
}
out.extend_from_slice(&self.secret);
out.push(crc8(&out));
out
}
fn from_bytes(bytes: &[u8]) -> Result<Self, CodeError> {
if bytes.len() < 1 + 2 + SECRET_LEN + 1 {
return Err(CodeError::Length);
}
let (payload, checksum) = bytes.split_at(bytes.len() - 1);
if crc8(payload) != checksum[0] {
return Err(CodeError::Checksum);
}
let header = payload[0];
if header >> 5 != VERSION {
return Err(CodeError::Unsupported);
}
let kind = AddrKind::from_bits((header >> 2) & 0b111).ok_or(CodeError::Unsupported)?;
let default_port = (header >> 1) & 1 == 1;
let addr_len = match kind {
AddrKind::Private192 => 2,
AddrKind::Private10 | AddrKind::Private172 => 3,
AddrKind::FullV4 => 4,
AddrKind::V6 => 16,
};
let port_len = if default_port { 0 } else { 2 };
if payload.len() != 1 + addr_len + port_len + SECRET_LEN {
return Err(CodeError::Length);
}
let addr_slice = &payload[1..1 + addr_len];
let address = match kind {
AddrKind::Private192 => {
IpAddr::V4(Ipv4Addr::new(192, 168, addr_slice[0], addr_slice[1]))
}
AddrKind::Private10 => {
IpAddr::V4(Ipv4Addr::new(10, addr_slice[0], addr_slice[1], addr_slice[2]))
}
AddrKind::Private172 => {
// 第二个八位组只可能是 16..=31,编码时减了 16
if addr_slice[0] > 15 {
return Err(CodeError::Unsupported);
}
IpAddr::V4(Ipv4Addr::new(172, addr_slice[0] + 16, addr_slice[1], addr_slice[2]))
}
AddrKind::FullV4 => IpAddr::V4(Ipv4Addr::new(
addr_slice[0], addr_slice[1], addr_slice[2], addr_slice[3],
)),
AddrKind::V6 => {
let mut octets = [0u8; 16];
octets.copy_from_slice(addr_slice);
IpAddr::V6(Ipv6Addr::from(octets))
}
};
let mut cursor = 1 + addr_len;
let port = if default_port {
DEFAULT_PORT
} else {
let value = u16::from_be_bytes([payload[cursor], payload[cursor + 1]]);
cursor += 2;
value
};
let mut secret = [0u8; SECRET_LEN];
secret.copy_from_slice(&payload[cursor..cursor + SECRET_LEN]);
Ok(Self { address, port, secret })
}
}
pub fn new_secret() -> [u8; SECRET_LEN] {
use rand::RngCore;
let mut secret = [0u8; SECRET_LEN];
rand::rng().fill_bytes(&mut secret);
secret
}
// ---------------------------------------------------------------- Base32
fn base32_encode(bytes: &[u8]) -> String {
let mut out = String::with_capacity(bytes.len() * 8 / 5 + 1);
let mut buffer: u32 = 0;
let mut bits = 0u32;
for &byte in bytes {
buffer = (buffer << 8) | byte as u32;
bits += 8;
while bits >= 5 {
bits -= 5;
out.push(ALPHABET[((buffer >> bits) & 0x1f) as usize] as char);
}
}
if bits > 0 {
out.push(ALPHABET[((buffer << (5 - bits)) & 0x1f) as usize] as char);
}
out
}
/// 返回 (字节, 末尾填充位是否为 0)。
fn base32_decode(text: &str) -> Result<(Vec<u8>, bool), CodeError> {
let mut buffer: u32 = 0;
let mut bits = 0u32;
let mut out = Vec::new();
let mut symbols = 0usize;
for ch in text.chars() {
// 分隔符与空白一律忽略,用户怎么断句都行
if ch == '-' || ch == ' ' || ch == '_' || ch == '\t' {
continue;
}
let upper = ch.to_ascii_uppercase();
// Crockford 的容错映射:手写/口述时 I、L 常被当成 1,O 被当成 0
let normalized = match upper {
'I' | 'L' => '1',
'O' => '0',
other => other,
};
let value = ALPHABET
.iter()
.position(|&c| c as char == normalized)
.ok_or(CodeError::Alphabet(ch))? as u32;
symbols += 1;
buffer = (buffer << 5) | value;
bits += 5;
if bits >= 8 {
bits -= 8;
out.push(((buffer >> bits) & 0xff) as u8);
}
}
if symbols == 0 {
return Err(CodeError::Length);
}
// 5 位一组和 8 位一字节对不齐,末尾会剩几个填充位。编码时填的是 0,
// 必须校验它们仍是 0:否则改动最后一个字符有 1/2^bits 的概率
// 解出完全相同的字节序列,CRC 根本没机会发现(修复前实测漏检率 4%)。
let padding_ok = bits == 0 || (buffer & ((1 << bits) - 1)) == 0;
Ok((out, padding_ok))
}
fn crc8(bytes: &[u8]) -> u8 {
let mut crc = 0u8;
for &byte in bytes {
crc ^= byte;
for _ in 0..8 {
crc = if crc & 0x80 != 0 { (crc << 1) ^ 0x07 } else { crc << 1 };
}
}
crc
}
#[cfg(test)]
mod tests {
use super::*;
fn code(ip: &str, port: u16) -> ConnectCode {
ConnectCode::new(ip.parse().unwrap(), port, [0xAB, 0xCD, 0xEF])
}
#[test]
fn typical_home_address_fits_in_twelve_characters() {
let encoded = code("192.168.1.20", DEFAULT_PORT).encode();
let symbols = encoded.chars().filter(|c| *c != '-').count();
assert_eq!(symbols, 12, "常见家庭网段应压到 12 个字符,实得 {encoded}");
assert_eq!(encoded.matches('-').count(), 2, "应分成三组便于口述");
}
#[test]
fn round_trips_every_address_kind() {
let cases = [
("192.168.1.20", DEFAULT_PORT),
("192.168.255.255", DEFAULT_PORT),
("10.0.0.5", DEFAULT_PORT),
("10.255.255.254", 8080),
("172.16.0.1", DEFAULT_PORT),
("172.31.255.254", 1),
("100.64.0.1", DEFAULT_PORT), // CGNAT,落到 FullV4
("127.0.0.1", 65535),
("2001:db8::1", DEFAULT_PORT),
("fe80::1", 39393),
];
for (ip, port) in cases {
let original = code(ip, port);
let decoded = ConnectCode::decode(&original.encode())
.unwrap_or_else(|e| panic!("{ip}:{port} 解码失败:{e}"));
assert_eq!(decoded, original, "{ip}:{port} 往返不一致");
}
}
#[test]
fn accepts_sloppy_user_input() {
let original = code("192.168.1.20", DEFAULT_PORT);
let canonical = original.encode();
let sloppy = [
canonical.to_lowercase(),
canonical.replace('-', ""),
canonical.replace('-', " "),
format!(" {canonical} "),
];
for text in sloppy {
assert_eq!(ConnectCode::decode(&text).unwrap(), original, "应容忍:{text}");
}
}
#[test]
fn confusable_letters_map_to_digits() {
// 口述时 I/L 常被听成 1,O 被听成 0。字母表里本就没有这些字母,
// 所以把它们映射回数字是安全的,不会和真实字符冲突。
let original = code("192.168.1.20", DEFAULT_PORT);
let canonical = original.encode();
let mangled = canonical.replace('1', "I").replace('0', "O");
if mangled != canonical {
assert_eq!(ConnectCode::decode(&mangled).unwrap(), original);
}
}
#[test]
fn single_character_typo_is_caught_by_checksum() {
let canonical = code("192.168.1.20", DEFAULT_PORT).encode();
let mut caught = 0;
let mut total = 0;
for (index, ch) in canonical.char_indices() {
if ch == '-' {
continue;
}
for &replacement in ALPHABET.iter() {
if replacement as char == ch {
continue;
}
let mut mangled: Vec<char> = canonical.chars().collect();
mangled[index] = replacement as char;
let text: String = mangled.into_iter().collect();
total += 1;
if ConnectCode::decode(&text).is_err() {
caught += 1;
}
}
}
// CRC-8 理论漏检率约 1/256;这里要求实测拦截率高于 99%
let rate = caught as f64 / total as f64;
assert!(rate > 0.99, "单字符输错的拦截率只有 {:.3},太低", rate);
}
#[test]
fn rejects_malformed_input() {
assert_eq!(ConnectCode::decode(""), Err(CodeError::Length));
assert_eq!(ConnectCode::decode("---"), Err(CodeError::Length));
assert!(matches!(ConnectCode::decode("K7M2!9X4"), Err(CodeError::Alphabet('!'))));
assert_eq!(ConnectCode::decode("K7M2"), Err(CodeError::Length));
}
#[test]
fn secret_hex_is_stable_and_lowercase() {
let value = code("192.168.1.20", DEFAULT_PORT);
assert_eq!(value.secret_hex(), "abcdef");
assert_eq!(value.base_url(), "http://192.168.1.20:39393");
}
#[test]
fn ipv6_code_is_long_but_valid() {
let value = code("2001:db8::1", DEFAULT_PORT);
let encoded = value.encode();
let symbols = encoded.chars().filter(|c| *c != '-').count();
// IPv6 地址本身就 16 字节,码必然长,适合复制粘贴而不是口述
assert!(symbols > 24, "IPv6 码应明显更长,实得 {symbols}");
assert_eq!(ConnectCode::decode(&encoded).unwrap(), value);
}
#[test]
fn secrets_differ_between_sessions() {
let a = new_secret();
let b = new_secret();
assert_ne!(a, b, "每次生成的秘密必须不同");
}
}
+196
View File
@@ -0,0 +1,196 @@
use anyhow::{bail, Result};
// Context 只在 Windows 的 WiFiDirect 分支里用;非 Windows 上整段被编译掉。
#[cfg(windows)]
use anyhow::Context;
#[cfg(windows)]
use windows::{
core::HSTRING,
Devices::WiFiDirect::{
WiFiDirectAdvertisementListenStateDiscoverability, WiFiDirectAdvertisementPublisher,
WiFiDirectAdvertisementPublisherStatus,
WiFiDirectAdvertisementPublisherStatusChangedEventArgs, WiFiDirectConnectionListener,
WiFiDirectConnectionRequestedEventArgs, WiFiDirectDevice,
},
Foundation::TypedEventHandler,
Security::Credentials::PasswordCredential,
};
#[cfg(windows)]
use std::sync::{Arc, Mutex};
#[cfg(windows)]
fn create_connection_listener(
connected_devices: &Arc<Mutex<Vec<WiFiDirectDevice>>>,
) -> windows::core::Result<(WiFiDirectConnectionListener, i64)> {
let callback_devices = Arc::clone(connected_devices);
let listener = WiFiDirectConnectionListener::new()?;
let handler = TypedEventHandler::<
WiFiDirectConnectionListener,
WiFiDirectConnectionRequestedEventArgs,
>::new(move |_sender, args| {
let request = args.ok()?.GetConnectionRequest()?;
let device_id = request.DeviceInformation()?.Id()?;
let operation = WiFiDirectDevice::FromIdAsync(&device_id)?;
let devices = Arc::clone(&callback_devices);
// Do not block the WinRT event thread while Windows completes the peer
// connection. `join` also keeps the async operation alive until it
// yields the device we must retain.
std::thread::spawn(move || {
if let Ok(device) = operation.join() {
if let Ok(mut devices) = devices.lock() {
devices.retain(|known| known.DeviceId().ok() != device.DeviceId().ok());
devices.push(device);
}
}
});
Ok(())
});
let token = listener.ConnectionRequested(&handler)?;
Ok((listener, token))
}
pub struct DirectAp {
pub ssid: String,
#[cfg(windows)]
publisher: WiFiDirectAdvertisementPublisher,
/// Legacy AP 只负责让普通 Wi-Fi 客户端关联和取得 DHCP 地址;Windows
/// 还要求应用接受 Wi-Fi Direct connection request,数据通道才会真正建立。
#[cfg(windows)]
connection_listener: WiFiDirectConnectionListener,
#[cfg(windows)]
connection_requested_token: i64,
/// 必须长期持有 `WiFiDirectDevice`。对象一旦被释放,Windows 会拆掉该
/// peer 的 Wi-Fi Direct 会话,表现为手机仍连着 SSID、却访问不到网关端口。
#[cfg(windows)]
connected_devices: Arc<Mutex<Vec<WiFiDirectDevice>>>,
}
impl DirectAp {
pub fn start(ssid: String, passphrase: String) -> Result<Self> {
#[cfg(not(windows))]
{
let _ = (ssid, passphrase);
bail!("QFT Direct AP 仅支持 Windows")
}
#[cfg(windows)]
{
let publisher = WiFiDirectAdvertisementPublisher::new()
.context("创建 Wi-Fi Direct publisher 失败")?;
let ad = publisher.Advertisement()
.context("读取 Wi-Fi Direct advertisement 失败")?;
// WinRT defaults this property to `None`, which still lets the
// publisher report `Started` but does not make the AP discoverable.
// Android then waits in the system Wi-Fi picker until it times out,
// exactly as if the hotspot had never been started. Intensive keeps
// the legacy SSID discoverable even when the desktop window is not
// foregrounded during the phone-side connection flow.
ad.SetListenStateDiscoverability(
WiFiDirectAdvertisementListenStateDiscoverability::Intensive,
)
.context("启用 QFT Wi-Fi Direct 可发现性失败")?;
ad.SetIsAutonomousGroupOwnerEnabled(true)
.context("启用 Autonomous Group Owner 失败")?;
let legacy = ad.LegacySettings()
.context("读取 LegacySettings 失败")?;
legacy.SetIsEnabled(true)
.context("启用 Wi-Fi Direct Legacy AP 失败")?;
legacy.SetSsid(&HSTRING::from(&ssid))
.context("设置 QFT SSID 失败")?;
let credential = PasswordCredential::new()
.context("创建 Wi-Fi Direct 密码对象失败")?;
credential.SetPassword(&HSTRING::from(&passphrase))
.context("设置 QFT 热点密码失败")?;
legacy.SetPassphrase(&credential)
.context("应用 QFT 热点密码失败")?;
// Follow Microsoft's Legacy AP lifecycle exactly: install the
// connection listener from the publisher's Started callback. QFT
// keeps a stable SSID/password, so Android can auto-reassociate as
// soon as the AP appears; polling first and adding the listener
// afterwards can miss that one connection request.
type ListenerResult = std::result::Result<
(WiFiDirectConnectionListener, i64),
String,
>;
let connected_devices = Arc::new(Mutex::new(Vec::<WiFiDirectDevice>::new()));
let listener_state = Arc::new(Mutex::new(None::<ListenerResult>));
let callback_devices = Arc::clone(&connected_devices);
let callback_state = Arc::clone(&listener_state);
let status_handler = TypedEventHandler::<
WiFiDirectAdvertisementPublisher,
WiFiDirectAdvertisementPublisherStatusChangedEventArgs,
>::new(move |_sender, args| {
if args.ok()?.Status()? == WiFiDirectAdvertisementPublisherStatus::Started {
let result = create_connection_listener(&callback_devices)
.map_err(|error| error.to_string());
if let Ok(mut state) = callback_state.lock() {
if state.is_none() {
*state = Some(result);
}
}
}
Ok(())
});
let status_token = publisher
.StatusChanged(&status_handler)
.context("监听 Wi-Fi Direct AP 启动状态失败")?;
publisher.Start().context("启动 QFT Wi-Fi Direct AP 失败")?;
// Publisher startup is asynchronous. Do not expose the pairing QR until
// Windows reports Started; otherwise Android can scan a network that is
// not yet discoverable.
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
let (connection_listener, connection_requested_token) = loop {
if let Ok(mut state) = listener_state.lock() {
if let Some(result) = state.take() {
break result.map_err(anyhow::Error::msg)?;
}
}
let status = publisher.Status().context("读取 AP 状态失败")?;
if status == WiFiDirectAdvertisementPublisherStatus::Aborted {
bail!("Wi-Fi Direct AP 启动被系统中止。请确认 Windows Wi-Fi 已开启,且系统移动热点未占用 Wi-Fi Direct。")
}
if std::time::Instant::now() >= deadline {
bail!("Wi-Fi Direct AP 或连接监听器启动超时。请确认无线网卡支持 Wi-Fi Direct,并关闭 Windows 移动热点后重试。")
}
std::thread::sleep(std::time::Duration::from_millis(25));
};
let _ = publisher.RemoveStatusChanged(status_token);
// This is not optional bookkeeping. Microsoft's Legacy AP sample
// creates the connection listener after the publisher reaches
// Started, accepts each request with FromIdAsync, and retains the
// resulting WiFiDirectDevice. Without these steps Android still
// associates and receives 192.168.137.x via DHCP, but TCP/UDP to
// 192.168.137.1 never reaches the desktop process.
Ok(Self {
ssid,
publisher,
connection_listener,
connection_requested_token,
connected_devices,
})
}
}
}
impl Drop for DirectAp {
fn drop(&mut self) {
#[cfg(windows)]
{
let _ = self
.connection_listener
.RemoveConnectionRequested(self.connection_requested_token);
if let Ok(mut devices) = self.connected_devices.lock() {
for device in devices.drain(..) {
let _ = device.Close();
}
}
let _ = self.publisher.Stop();
}
}
}
+201
View File
@@ -0,0 +1,201 @@
//! 局域网节点发现(v3 浏览)。
//!
//! 与既有的 `QFTDISC2:<token>` 不同:那是「我已经知道令牌,帮我找到那台机器」,
//! 用于手机扫码之后。PC↔PC 没有摄像头,必须先能**列出附近有哪些节点**,
//! 用户再从列表里挑一台,所以需要一个不带令牌的广播查询。
//!
//! 为什么不是 mDNS:
//! - 本阶段目标是尽快让 PC↔PC 可测,UDP 广播零新依赖,且仓库里已有同样的模式;
//! - macOS 上 mDNS 在沙盒/强化运行时下需要额外 entitlement,Windows 上常被
//! 企业策略关掉,行为差异反而更多。
//! mDNS 作为跨网段与「AP 隔离」场景的补充留到后续,不阻塞本阶段。
//!
//! 局限(必须在 UI 上说清楚):UDP 广播只覆盖同一个广播域。跨网段、
//! 或开了 AP 隔离的 Wi-Fi 上发现不到对方,此时走手动输入 IP。
use anyhow::{Context, Result};
use serde::{Deserialize, Serialize};
use std::{
collections::HashMap,
net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket},
time::{Duration, Instant},
};
/// 广播查询;任何在监听的 QFT 节点都应答。
pub const BROWSE_QUERY: &str = "QFTBROWSE3";
/// 应答前缀,后接紧凑 JSON。
pub const BROWSE_REPLY_PREFIX: &str = "QFTNODE3:";
/// 节点自我介绍。刻意用短键名——UDP 应答要留在单个数据报里。
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct NodeAnnounce {
/// 设备名
pub n: String,
/// 平台标识:windows / macos / linux
pub p: String,
/// 传输服务的 TCP 端口
pub t: u16,
/// 当前是否正在等待配对(未在接收状态的节点不会被误选)
pub r: bool,
}
/// 发现到的对端。
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Peer {
pub name: String,
pub platform: String,
pub address: Ipv4Addr,
pub port: u16,
pub ready: bool,
}
impl Peer {
pub fn base_url(&self) -> String {
format!("http://{}:{}", self.address, self.port)
}
}
/// 构造应答报文。接收端的 UDP 线程用它回应 `QFTBROWSE3`。
pub fn browse_reply(announce: &NodeAnnounce) -> Vec<u8> {
let json = serde_json::to_string(announce).unwrap_or_else(|_| "{}".into());
format!("{BROWSE_REPLY_PREFIX}{json}").into_bytes()
}
/// 向局域网广播一次查询并收集应答。
///
/// 同时发往受限广播地址和各网卡的定向广播地址:部分 Wi-Fi 驱动会丢弃
/// 255.255.255.255,而定向广播能过。
pub fn browse(port: u16, timeout: Duration) -> Result<Vec<Peer>> {
let socket = UdpSocket::bind(("0.0.0.0", 0)).context("绑定发现端口失败")?;
socket.set_broadcast(true).ok();
socket
.set_read_timeout(Some(Duration::from_millis(200)))
.context("设置发现超时失败")?;
let mut targets: Vec<Ipv4Addr> = vec![Ipv4Addr::BROADCAST];
for address in directed_broadcasts() {
if !targets.contains(&address) {
targets.push(address);
}
}
for target in &targets {
let _ = socket.send_to(BROWSE_QUERY.as_bytes(), SocketAddr::from((*target, port)));
}
// 同一台机器可能从多个网卡应答,用「地址+端口」去重
let mut found: HashMap<(Ipv4Addr, u16), Peer> = HashMap::new();
let deadline = Instant::now() + timeout;
let mut buffer = [0u8; 1024];
while Instant::now() < deadline {
match socket.recv_from(&mut buffer) {
Ok((n, from)) => {
let IpAddr::V4(address) = from.ip() else { continue };
let Some(peer) = parse_reply(&buffer[..n], address) else { continue };
found.insert((peer.address, peer.port), peer);
}
Err(e) if matches!(e.kind(), std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut) => {}
Err(e) => return Err(e).context("接收发现应答失败"),
}
}
let mut peers: Vec<Peer> = found.into_values().collect();
// 正在等待接收的排前面,其次按名字,保证列表顺序稳定不跳动
peers.sort_by(|a, b| {
b.ready
.cmp(&a.ready)
.then_with(|| a.name.cmp(&b.name))
.then_with(|| a.address.cmp(&b.address))
});
Ok(peers)
}
fn parse_reply(bytes: &[u8], address: Ipv4Addr) -> Option<Peer> {
let text = std::str::from_utf8(bytes).ok()?;
let json = text.strip_prefix(BROWSE_REPLY_PREFIX)?;
let announce: NodeAnnounce = serde_json::from_str(json).ok()?;
if announce.t == 0 {
return None;
}
Some(Peer {
name: crate::platform::sanitize_device_name(&announce.n),
platform: announce.p.chars().filter(|c| c.is_ascii_alphanumeric()).take(16).collect(),
address,
port: announce.t,
ready: announce.r,
})
}
/// 各网卡的定向广播地址(如 192.168.1.255)。
fn directed_broadcasts() -> Vec<Ipv4Addr> {
let mut out = Vec::new();
let Ok(interfaces) = if_addrs::get_if_addrs() else { return out };
for interface in interfaces {
if interface.is_loopback() {
continue;
}
let if_addrs::IfAddr::V4(v4) = interface.addr else { continue };
let Some(netmask) = Some(v4.netmask) else { continue };
let ip = u32::from(v4.ip);
let mask = u32::from(netmask);
if mask == 0 || mask == u32::MAX {
continue;
}
let broadcast = Ipv4Addr::from(ip | !mask);
if !out.contains(&broadcast) {
out.push(broadcast);
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn reply_round_trip() {
let announce = NodeAnnounce {
n: "MacBook-Pro".into(),
p: "macos".into(),
t: 39393,
r: true,
};
let bytes = browse_reply(&announce);
let peer = parse_reply(&bytes, Ipv4Addr::new(192, 168, 1, 20)).expect("应能解析");
assert_eq!(peer.name, "MacBook-Pro");
assert_eq!(peer.platform, "macos");
assert_eq!(peer.port, 39393);
assert!(peer.ready);
assert_eq!(peer.base_url(), "http://192.168.1.20:39393");
}
#[test]
fn rejects_foreign_or_malformed_datagrams() {
let address = Ipv4Addr::LOCALHOST;
assert!(parse_reply(b"QFTHERE2:token:39393", address).is_none());
assert!(parse_reply(b"QFTNODE3:not-json", address).is_none());
assert!(parse_reply(&[0xff, 0xfe, 0x00], address).is_none());
// 端口 0 的应答无意义,必须丢弃
assert!(parse_reply(br#"QFTNODE3:{"n":"x","p":"linux","t":0,"r":true}"#, address).is_none());
}
#[test]
fn announce_fits_in_one_datagram() {
let announce = NodeAnnounce {
n: "x".repeat(64),
p: "windows".into(),
t: 65535,
r: false,
};
assert!(browse_reply(&announce).len() < 512);
}
#[test]
fn peer_name_is_sanitized_from_untrusted_datagram() {
// 应答来自网络,是不可信输入:控制字符必须被清掉
let bytes = format!("{BROWSE_REPLY_PREFIX}{{\"n\":\"bad\\u0000name\",\"p\":\"linux!!\",\"t\":1,\"r\":true}}");
let peer = parse_reply(bytes.as_bytes(), Ipv4Addr::LOCALHOST).expect("应能解析");
assert!(!peer.name.chars().any(char::is_control));
assert_eq!(peer.platform, "linux");
}
}
+750
View File
@@ -0,0 +1,750 @@
//! 系统防火墙放行。
//!
//! 接收端要监听入站 TCP,而 Windows 防火墙默认拦截未授权程序的入站连接,
//! 表现是「对方能解析连接码,但连接一直超时」——这类问题用户几乎不可能
//! 自己联想到防火墙。所以由程序主动检测并申请放行。
//!
//! 三条设计约束:
//! 1. **只在确实缺规则时申请**。每次启动都弹 UAC 是骚扰。
//! 2. **没有放行就不宣称 Direct 已就绪**。用户明确点击“启动直传/接收”时,
//! 可以走一次标准 UAC;拒绝或复检失败就停止启动,不生成不可用二维码。
//! 3. **规则尽量窄**。程序规则之外只开放 QFT 固定的 TCP/UDP 两个端口,
//! 绝不整体关闭防火墙;但**不能按网络配置文件收窄**——见下方
//! `grant()` 里的说明。
//!
//! 提权本身由操作系统的标准机制完成(Windows 的 UAC、macOS 的
//! 授权对话框),程序不接触也不存储任何凭据。
use anyhow::{bail, Context, Result};
use std::path::PathBuf;
/// 规则显示名。检测与添加都用它,改名会导致旧规则失效。
// 仅 Windows 分支使用;其余平台整段被 cfg 编译掉
#[cfg_attr(not(target_os = "windows"), allow(dead_code))]
pub const RULE_NAME: &str = "QFT Desktop";
#[cfg_attr(not(target_os = "windows"), allow(dead_code))]
const DIRECT_TCP_RULE: &str = "QFT-Desktop-Direct-TCP-v2";
#[cfg_attr(not(target_os = "windows"), allow(dead_code))]
const DIRECT_UDP_RULE: &str = "QFT-Desktop-Direct-UDP-v2";
#[cfg_attr(not(target_os = "windows"), allow(dead_code))]
const DIRECT_TCP_PORT: u16 = 39393;
#[cfg_attr(not(target_os = "windows"), allow(dead_code))]
const DIRECT_UDP_PORT: u16 = 39392;
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum FirewallStatus {
/// 已放行,或系统防火墙未开启,总之入站不会被拦
Allowed,
/// 缺少放行规则,入站很可能被拦
Missing,
/// 规则本身没问题,但系统层面的策略让任何放行规则都不生效。
///
/// 对应 Windows 的「阻止所有传入连接,包括位于允许应用列表中的应用」
/// (`BlockInboundAlways`)。这一项打开时,用户点多少次「放行防火墙」
/// 都不会有任何变化——必须先把它关掉,所以要单独报出来。
#[cfg_attr(not(target_os = "windows"), allow(dead_code))]
BlockedByPolicy(String),
/// 存在针对本程序的「阻止」入站规则,压过了我们的放行规则。
///
/// 通常是用户在 Windows「安全警报」弹窗上点了取消后系统自动建的,
/// 规则名是程序名而非 `QFT Desktop`。这一类提权后可以自动清掉,
/// 所以和 [`BlockedByPolicy`](Self::BlockedByPolicy) 分开表示。
#[cfg_attr(not(target_os = "windows"), allow(dead_code))]
BlockedByRule(String),
/// 查不出来(命令不可用、输出无法解析等),不要据此吓唬用户
Unknown(String),
/// 本平台不做自动放行(目前只有 Linux 会返回)
#[cfg_attr(not(all(unix, not(target_os = "macos"))), allow(dead_code))]
Unsupported(&'static str),
}
impl FirewallStatus {
pub fn needs_action(&self) -> bool {
matches!(
self,
Self::Missing | Self::BlockedByPolicy(_) | Self::BlockedByRule(_)
)
}
/// 提权后加/删规则能否解决。
///
/// `BlockedByPolicy` 是系统级开关,我们不去动它——那属于用户的安全设置,
/// 只做提示,由用户自己决定是否关闭。
pub fn fixable_by_grant(&self) -> bool {
matches!(self, Self::Missing | Self::BlockedByRule(_))
}
/// 给界面用的一句话说明。
pub fn detail(&self) -> String {
match self {
Self::Allowed => "入站已放行".into(),
Self::Missing => "缺少放行规则,手机可能连不上".into(),
Self::BlockedByPolicy(reason) | Self::Unknown(reason) => reason.clone(),
Self::BlockedByRule(names) => format!(
"存在阻止本程序入站的规则({names}),它的优先级高于放行规则。\
点「放行防火墙」会连同这些阻止规则一起清掉。"
),
Self::Unsupported(reason) => (*reason).to_owned(),
}
}
}
fn current_exe() -> Result<PathBuf> {
std::env::current_exe().context("无法获取本程序路径")
}
// ---------------------------------------------------------------- Windows
/// 探测脚本。刻意用 PowerShell 而不是 netsh:
///
/// `netsh advfirewall show` 的**值**也会跟随系统语言本地化(中文 Windows 上
/// 是「允许 / 阻止 / 任何 / 是」),按英文关键字匹配在中文系统上必然误判;
/// 而 `Get-NetFirewallRule` 返回的是枚举,`Allow`/`Block`/`Any`/`True`
/// 在任何语言下都是这几个字面量。
///
/// 输出被压成一行一条的管道分隔记录,便于用纯函数解析、也便于在非 Windows
/// 上对解析逻辑写测试。
/// 注意查询是**按程序路径**做的,不是只按规则显示名。
///
/// 用户在 Windows 弹出「安全警报」时点了「取消」,系统会自己建一条针对该
/// 可执行文件的**阻止**规则,名字是程序名而不是我们的 `QFT Desktop`。
/// 只按显示名查完全看不到它,却又是它压着我们的放行规则——
/// 表现就是「点了放行、界面显示已放行,手机依然连不上」。
fn probe_script(exe: &str) -> String {
format!(
r#"
$ErrorActionPreference='SilentlyContinue'
$exe = '{exe}'
Get-NetFirewallProfile | ForEach-Object {{
"PROFILE|$($_.Name)|$($_.Enabled)|$($_.DefaultInboundAction)|$($_.AllowInboundRules)"
}}
# 只查询当前 exe 路径。同名旧规则可能属于上一次构建目录;把它算成有效
# 会让界面显示绿色,但当前 qft-desktop.exe 的入站仍被全部拦截。
Get-NetFirewallApplicationFilter -Program $exe | Get-NetFirewallRule | Sort-Object -Property Name -Unique | ForEach-Object {{
"RULE|$($_.Enabled)|$($_.Direction)|$($_.Action)|$($_.Profile)|$($_.DisplayName)"
}}
Get-NetFirewallRule -Name '{DIRECT_TCP_RULE}','{DIRECT_UDP_RULE}' | ForEach-Object {{
$rule = $_
$filter = $rule | Get-NetFirewallPortFilter
"PORT|$($rule.Enabled)|$($rule.Direction)|$($rule.Action)|$($rule.Profile)|$($filter.Protocol)|$($filter.LocalPort)|$($rule.Name)"
}}
"#,
// PowerShell 单引号字符串里只需把单引号写成两个,反斜杠不转义,
// 正好适合 Windows 路径
exe = exe.replace('\'', "''"),
)
}
/// 解析 [`PROBE_SCRIPT`] 的输出。放在这里而不是内联,是为了能在任意平台
/// 上用真实样本做测试——Windows 专有逻辑最容易腐烂在没人跑的地方。
///
/// 判定顺序是有讲究的:
/// 1. **先看系统级策略**。`AllowInboundRules=False` 对应「阻止所有传入连接,
/// 包括位于允许应用列表中的应用」。这项打开时用户点多少次放行都没有
/// 任何变化,必须先报出来,否则会得出「规则已就绪」的错误结论。
/// 2. **再看有没有阻止规则**。Windows 里 Block 永远压过 Allow,旧版本残留
/// 的阻止规则会让新加的放行规则彻底失效,而界面上两条都显示「已启用」。
/// 3. **最后才看放行规则**,且必须是 `Any` profile——手机连的那块 Direct AP
/// 虚拟网卡会被判为「公用网络」,只覆盖专用/域的规则在它上面不适用。
pub fn classify_probe(probe_output: &str) -> FirewallStatus {
let mut any_firewall_on = false;
let mut blanket_block: Vec<&str> = Vec::new();
let mut has_block_rule = false;
let mut blocking_rules: Vec<&str> = Vec::new();
let mut has_usable_allow = false;
let mut has_direct_tcp = false;
let mut has_direct_udp = false;
for line in probe_output.lines() {
let fields: Vec<&str> = line.trim().split('|').collect();
match fields.as_slice() {
["PROFILE", name, enabled, _default_inbound, allow_inbound] => {
let on = enabled.eq_ignore_ascii_case("true");
any_firewall_on |= on;
// AllowInboundRules 还可能是 NotConfigured,那不算封禁
if on && allow_inbound.eq_ignore_ascii_case("false") {
blanket_block.push(name);
}
}
["RULE", enabled, direction, action, profile, display_name] => {
if !direction.eq_ignore_ascii_case("inbound") {
continue;
}
// 只有启用中的阻止规则才真正生效
if action.eq_ignore_ascii_case("block") && enabled.eq_ignore_ascii_case("true") {
has_block_rule = true;
blocking_rules.push(*display_name);
} else if enabled.eq_ignore_ascii_case("true")
&& action.eq_ignore_ascii_case("allow")
&& profile.eq_ignore_ascii_case("any")
{
has_usable_allow = true;
}
}
["PORT", enabled, direction, action, profile, protocol, local_port, _name] => {
let usable = enabled.eq_ignore_ascii_case("true")
&& direction.eq_ignore_ascii_case("inbound")
&& action.eq_ignore_ascii_case("allow")
&& profile.eq_ignore_ascii_case("any");
let port = local_port.parse::<u16>().ok();
if usable
&& (protocol.eq_ignore_ascii_case("tcp") || *protocol == "6")
&& port == Some(DIRECT_TCP_PORT)
{
has_direct_tcp = true;
}
if usable
&& (protocol.eq_ignore_ascii_case("udp") || *protocol == "17")
&& port == Some(DIRECT_UDP_PORT)
{
has_direct_udp = true;
}
}
_ => {}
}
}
if !blanket_block.is_empty() {
return FirewallStatus::BlockedByPolicy(format!(
"{} 配置文件启用了「阻止所有传入连接,包括位于允许应用列表中的应用」。\
这一项打开时,放行规则不起任何作用,必须先在\
「Windows 安全中心 → 防火墙和网络保护」里把它关掉。",
blanket_block.join("、")
));
}
if has_block_rule {
// 这类规则多半是用户在「安全警报」弹窗上点了取消后由系统自动建的,
// 名字五花八门,所以把实际名字列出来,用户手动排查时才有的放矢。
return FirewallStatus::BlockedByRule(blocking_rules.join("、"));
}
// 防火墙整个关着时入站不会被拦,没必要要求存在规则
if !any_firewall_on || (has_usable_allow && has_direct_tcp && has_direct_udp) {
FirewallStatus::Allowed
} else {
FirewallStatus::Missing
}
}
/// 生成提权后要执行的放行脚本。
///
/// 不加 `#[cfg]`,好让脚本文本在任何平台上都能被测试——这段脚本上一版
/// 里混进了一个 `\` 续行(bash 语法,PowerShell 用反引号 `),
/// 结果脚本在用户机器上直接语法错误,而外层 `Start-Process -Wait` 返回的
/// 是启动器的退出码,程序还以为放行成功了。所以现在:
/// **一条命令占一行,绝不使用任何续行**,并且由脚本自己写一个成功标记,
/// 让调用方能验证它是真的跑完了。
fn grant_script(exe: &str, marker: &str) -> String {
let exe = exe.replace('\'', "''");
let marker = marker.replace('\'', "''");
format!(
"$ErrorActionPreference = 'Stop'\r\n\
$exe = '{exe}'\r\n\
$marker = '{marker}'\r\n\
# 先清掉一切针对本程序的入站阻止规则。Windows 在用户点掉「安全警报」\r\n\
# 弹窗时会自动建这种规则,名字是程序名,且优先级高于任何放行规则。\r\n\
$blocking = Get-NetFirewallApplicationFilter -Program $exe -ErrorAction SilentlyContinue | Get-NetFirewallRule -ErrorAction SilentlyContinue | Where-Object {{ $_.Direction -eq 'Inbound' -and $_.Action -eq 'Block' }}\r\n\
if ($blocking) {{ $blocking | Remove-NetFirewallRule -ErrorAction SilentlyContinue }}\r\n\
# 重建放行规则。Profile Any 是刻意的:Windows 把没见过的网络\r\n\
# (尤其是 Direct AP 虚拟网卡)默认归为公用网络。\r\n\
Remove-NetFirewallRule -DisplayName '{RULE_NAME}' -ErrorAction SilentlyContinue\r\n\
New-NetFirewallRule -DisplayName '{RULE_NAME}' -Direction Inbound -Program $exe -Action Allow -Profile Any -Enabled True -EdgeTraversalPolicy Allow | Out-Null\r\n\
# 两条窄端口规则不依赖 exe 路径字符串的 WFP 归一化结果,专门兜住\r\n\
# Wi-Fi Direct 虚拟网卡上的 TCP/UDP 数据通道。\r\n\
Remove-NetFirewallRule -Name '{DIRECT_TCP_RULE}','{DIRECT_UDP_RULE}' -ErrorAction SilentlyContinue\r\n\
New-NetFirewallRule -Name '{DIRECT_TCP_RULE}' -DisplayName 'QFT Direct TCP' -Direction Inbound -Protocol TCP -LocalPort {DIRECT_TCP_PORT} -Action Allow -Profile Any -Enabled True -EdgeTraversalPolicy Allow | Out-Null\r\n\
New-NetFirewallRule -Name '{DIRECT_UDP_RULE}' -DisplayName 'QFT Direct UDP' -Direction Inbound -Protocol UDP -LocalPort {DIRECT_UDP_PORT} -Action Allow -Profile Any -Enabled True -EdgeTraversalPolicy Allow | Out-Null\r\n\
# 只有真的建成了才写标记,调用方据此判断成败\r\n\
Set-Content -Path $marker -Value 'ok' -Encoding ASCII\r\n"
)
}
#[cfg(target_os = "windows")]
fn run_powershell(script: &str) -> std::io::Result<std::process::Output> {
use std::os::windows::process::CommandExt;
const CREATE_NO_WINDOW: u32 = 0x0800_0000;
std::process::Command::new("powershell")
.args(["-NoProfile", "-NonInteractive", "-Command", script])
.creation_flags(CREATE_NO_WINDOW)
.output()
}
#[cfg(target_os = "windows")]
pub fn status() -> FirewallStatus {
let exe = match current_exe() {
Ok(path) => path.display().to_string(),
Err(e) => return FirewallStatus::Unknown(format!("{e}")),
};
match run_powershell(&probe_script(&exe)) {
Ok(out) => {
let text = String::from_utf8_lossy(&out.stdout);
if text.trim().is_empty() {
return FirewallStatus::Unknown(
"防火墙查询没有返回任何内容,可能是 PowerShell 执行策略受限".into(),
);
}
classify_probe(&text)
}
Err(e) => FirewallStatus::Unknown(format!("无法执行 PowerShell:{e}")),
}
}
/// 触发 UAC 并添加入站放行规则。
///
/// 用临时批处理承载命令,而不是把参数塞进 PowerShell 的 `-ArgumentList`:
/// 程序路径里带空格时,经过 PowerShell 再到 netsh 会被重新分词,
/// 引号层层嵌套极易出错。批处理文件由我们自己写死引号,不再被二次解析。
///
/// `profile=any` 是刻意的,早先写成 `private,domain` 是个真实的 bug:
/// Windows 对没见过的 Wi-Fi 默认归类为**公用网络**,此时 private 规则
/// 根本不适用——规则建了、也显示已启用,但连接照样被拦,极难排查。
/// 收窄到某个 profile 并不能带来实际安全收益:QFT 的入站真正靠的是
/// 连接码里的秘密加失败计数,没有秘密的连接一律被拒。
#[cfg(target_os = "windows")]
pub fn grant() -> Result<()> {
use std::os::windows::process::CommandExt;
const CREATE_NO_WINDOW: u32 = 0x0800_0000;
let exe = current_exe()?;
let temp = std::env::temp_dir();
let pid = std::process::id();
// 写成 .ps1 文件而不是把命令塞进 -ArgumentList:程序路径里带空格时,
// 经过 PowerShell 再到子进程会被重新分词,引号层层嵌套极易出错。
// 脚本文件里的单引号字符串不会被二次解析。
let script = temp.join(format!("qft-firewall-{pid}.ps1"));
let marker = temp.join(format!("qft-firewall-{pid}.ok"));
let _ = std::fs::remove_file(&marker);
std::fs::write(
&script,
grant_script(&exe.display().to_string(), &marker.display().to_string()),
)
.context("写入临时放行脚本失败")?;
let status = std::process::Command::new("powershell")
.args([
"-NoProfile",
"-WindowStyle",
"Hidden",
"-Command",
&format!(
"Start-Process -FilePath powershell -ArgumentList '-NoProfile','-ExecutionPolicy','Bypass','-File','\"{}\"' -Verb RunAs -WindowStyle Hidden -Wait",
script.display()
),
])
.creation_flags(CREATE_NO_WINDOW)
.status();
let _ = std::fs::remove_file(&script);
// 外层退出码只能说明「UAC 弹窗流程本身」没出错,说明不了脚本跑没跑通:
// Start-Process -Wait 返回的是启动器的退出码,不是被提权进程的。
// 上一版就是因此把一个语法错误的脚本误报成了放行成功。
let succeeded = marker.exists();
let _ = std::fs::remove_file(&marker);
match status {
// 用户在 UAC 上点了「否」时 Start-Process 会失败,退出码非 0
Ok(s) if s.success() && succeeded => Ok(()),
Ok(s) if s.success() => bail!(
"提权成功但放行脚本没有跑完,规则未生效。请点「复制手动放行命令」,\
在管理员 PowerShell 里执行并把报错发出来"
),
Ok(_) => bail!("未获得管理员授权,防火墙规则没有添加"),
Err(e) => bail!("调用提权失败:{e}"),
}
}
// ---------------------------------------------------------------- macOS
#[cfg(target_os = "macos")]
pub fn status() -> FirewallStatus {
const TOOL: &str = "/usr/libexec/ApplicationFirewall/socketfilterfw";
if !std::path::Path::new(TOOL).exists() {
return FirewallStatus::Unknown("系统上没有 socketfilterfw".into());
}
// 应用层防火墙没开时,入站根本不会被拦,不需要做任何事
match std::process::Command::new(TOOL).arg("--getglobalstate").output() {
Ok(out) => {
let text = String::from_utf8_lossy(&out.stdout);
if text.contains("disabled") {
return FirewallStatus::Allowed;
}
}
Err(e) => return FirewallStatus::Unknown(format!("无法执行 socketfilterfw:{e}")),
}
let Ok(exe) = current_exe() else {
return FirewallStatus::Unknown("无法获取本程序路径".into());
};
match std::process::Command::new(TOOL)
.args(["--getappblocked", &exe.display().to_string()])
.output()
{
Ok(out) => {
let text = String::from_utf8_lossy(&out.stdout).to_lowercase();
if text.contains("blocked") && !text.contains("not blocked") {
FirewallStatus::Missing
} else {
FirewallStatus::Allowed
}
}
Err(e) => FirewallStatus::Unknown(format!("查询失败:{e}")),
}
}
/// 通过系统授权对话框把本程序加入放行列表。
///
/// macOS 通常会在首次监听时自己弹「是否允许接受传入网络连接」,
/// 那一步就够了;这里只处理用户当时点了「拒绝」的情况。
#[cfg(target_os = "macos")]
pub fn grant() -> Result<()> {
let exe = current_exe()?;
let path = exe.display().to_string();
if path.contains('"') || path.contains('\\') {
bail!("程序路径包含无法安全转义的字符,请手动在「系统设置 → 网络 → 防火墙」里放行")
}
let inner = format!(
"/usr/libexec/ApplicationFirewall/socketfilterfw --add '{path}' && \
/usr/libexec/ApplicationFirewall/socketfilterfw --unblockapp '{path}'"
);
let script = format!("do shell script \"{inner}\" with administrator privileges");
let status = std::process::Command::new("osascript")
.args(["-e", &script])
.status()
.context("调用 osascript 失败")?;
if status.success() {
Ok(())
} else {
bail!("未获得授权,防火墙放行没有生效")
}
}
// ---------------------------------------------------------------- Linux
#[cfg(all(unix, not(target_os = "macos")))]
pub fn status() -> FirewallStatus {
// 各发行版的防火墙前端差异过大(ufw / firewalld / 裸 iptables / nftables),
// 自动改规则风险高于收益,只做检测与提示。
FirewallStatus::Unsupported("Linux 上请按下方提示手动放行")
}
#[cfg(all(unix, not(target_os = "macos")))]
pub fn grant() -> Result<()> {
bail!("Linux 上不自动修改防火墙,请按界面提示手动执行")
}
// ---------------------------------------------------------------- 手动说明
/// 自动放行失败或不支持时,给用户可以照抄的命令。
pub fn manual_instructions(port: u16) -> String {
let exe = current_exe()
.map(|p| p.display().to_string())
.unwrap_or_else(|_| "qft-desktop".into());
#[cfg(target_os = "windows")]
{
// -Profile Any 是必须的。这里早先写的是 Private,Domain,与本模块
// grant() 的注释自相矛盾,照抄的用户会重建出一条在公用网络上
// (也就是 Direct AP 虚拟网卡上)根本不适用的规则。
// 剪贴板里**只放命令**,不放任何说明文字。用户是整段粘进 PowerShell 的,
// 混在里面的中文散文会被当成 cmdlet 名逐行报错,把真正的报错淹没掉。
// 同理绝不使用 `\` 续行——那是 bash 语法,PowerShell 用反引号;
// 一条命令就写一行,宁可长。
format!(
concat!(
"# 在管理员 PowerShell 中整段粘贴执行\n",
"$exe = \"{exe}\"\n",
"Get-NetFirewallApplicationFilter -Program $exe | Get-NetFirewallRule | Where-Object {{ $_.Direction -eq 'Inbound' -and $_.Action -eq 'Block' }} | Remove-NetFirewallRule\n",
"Remove-NetFirewallRule -DisplayName \"{RULE_NAME}\" -ErrorAction SilentlyContinue\n",
"New-NetFirewallRule -DisplayName \"{RULE_NAME}\" -Direction Inbound -Program $exe -Action Allow -Profile Any -Enabled True -EdgeTraversalPolicy Allow\n",
"Remove-NetFirewallRule -Name \"{DIRECT_TCP_RULE}\",\"{DIRECT_UDP_RULE}\" -ErrorAction SilentlyContinue\n",
"New-NetFirewallRule -Name \"{DIRECT_TCP_RULE}\" -DisplayName \"QFT Direct TCP\" -Direction Inbound -Protocol TCP -LocalPort {port} -Action Allow -Profile Any -Enabled True -EdgeTraversalPolicy Allow\n",
"New-NetFirewallRule -Name \"{DIRECT_UDP_RULE}\" -DisplayName \"QFT Direct UDP\" -Direction Inbound -Protocol UDP -LocalPort {udp_port} -Action Allow -Profile Any -Enabled True -EdgeTraversalPolicy Allow\n",
"Get-NetFirewallProfile | Select-Object Name,Enabled,AllowInboundRules\n",
"Get-NetFirewallApplicationFilter -Program $exe | Get-NetFirewallRule | Select-Object DisplayName,Enabled,Direction,Action,Profile\n",
),
exe = exe,
RULE_NAME = RULE_NAME,
DIRECT_TCP_RULE = DIRECT_TCP_RULE,
DIRECT_UDP_RULE = DIRECT_UDP_RULE,
port = port,
udp_port = port.saturating_sub(1),
)
}
#[cfg(target_os = "macos")]
{
let _ = port;
format!(
"打开「系统设置 → 网络 → 防火墙 → 选项」,把下面这个程序设为\
「允许传入连接」:\n\n{exe}\n\n\
若防火墙本身是关闭的,则无需任何操作。"
)
}
#[cfg(all(unix, not(target_os = "macos")))]
{
let _ = exe;
format!(
"按你所用的防火墙执行其一:\n\n\
ufw: sudo ufw allow {port}/tcp && sudo ufw allow {}/udp\n\
firewalld: sudo firewall-cmd --add-port={port}/tcp --add-port={}/udp --permanent && sudo firewall-cmd --reload",
port - 1,
port - 1,
)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn status_query_never_panics_and_is_classified() {
// 只做只读查询,不改动任何系统设置
let value = status();
match &value {
FirewallStatus::Allowed
| FirewallStatus::Missing
| FirewallStatus::Unsupported(_) => {}
FirewallStatus::Unknown(reason)
| FirewallStatus::BlockedByPolicy(reason)
| FirewallStatus::BlockedByRule(reason) => {
assert!(!reason.is_empty(), "原因说明不能为空")
}
}
// Allowed / Unknown / Unsupported 都不该催促用户去点按钮
assert_eq!(
value.needs_action(),
matches!(
value,
FirewallStatus::Missing
| FirewallStatus::BlockedByPolicy(_)
| FirewallStatus::BlockedByRule(_)
)
);
}
#[test]
fn manual_instructions_mention_the_actual_program() {
let text = manual_instructions(39393);
assert!(!text.trim().is_empty());
// 说明里必须出现可操作的东西:程序路径或具体端口
assert!(
text.contains("qft") || text.contains("39393") || text.contains("防火墙"),
"说明应包含可操作信息:{text}"
);
}
// 探测脚本的输出形状是固定的,解析逻辑在任何平台上都能测。
// Windows 专有代码最容易腐烂在没人跑的地方,这几个用例就是防这个的。
const PROFILES_OK: &str = "PROFILE|Domain|True|Block|True\n\
PROFILE|Private|True|Block|True\n\
PROFILE|Public|True|Block|True";
const DIRECT_PORTS_OK: &str = "PORT|True|Inbound|Allow|Any|TCP|39393|QFT-Desktop-Direct-TCP-v2\n\
PORT|True|Inbound|Allow|Any|UDP|39392|QFT-Desktop-Direct-UDP-v2";
#[test]
fn allow_rule_must_cover_any_profile() {
let only_private = format!("{PROFILES_OK}\nRULE|True|Inbound|Allow|Domain, Private|QFT Desktop");
assert_eq!(classify_probe(&only_private), FirewallStatus::Missing);
let any = format!(
"{PROFILES_OK}\nRULE|True|Inbound|Allow|Any|QFT Desktop\n{DIRECT_PORTS_OK}"
);
assert_eq!(classify_probe(&any), FirewallStatus::Allowed);
}
#[test]
fn disabled_allow_rule_does_not_count() {
let text = format!("{PROFILES_OK}\nRULE|False|Inbound|Allow|Any|QFT Desktop");
assert_eq!(classify_probe(&text), FirewallStatus::Missing);
}
#[test]
fn legacy_program_rule_without_direct_ports_is_migrated() {
let old = format!("{PROFILES_OK}\nRULE|True|Inbound|Allow|Any|QFT Desktop");
assert_eq!(classify_probe(&old), FirewallStatus::Missing);
let only_tcp = format!("{old}\n{}", DIRECT_PORTS_OK.lines().next().unwrap());
assert_eq!(classify_probe(&only_tcp), FirewallStatus::Missing);
}
#[test]
fn outbound_rules_are_irrelevant() {
let text = format!("{PROFILES_OK}\nRULE|True|Outbound|Allow|Any|QFT Desktop");
assert_eq!(classify_probe(&text), FirewallStatus::Missing);
// 出站的阻止规则同样不该被误判成入站被拦
let text = format!("{PROFILES_OK}\nRULE|True|Outbound|Block|Any|随便什么");
assert_eq!(classify_probe(&text), FirewallStatus::Missing);
}
/// 这是「点了放行还是连不上」最常见的成因:用户在安全警报弹窗上点了取消,
/// 系统按程序路径建了一条阻止规则,名字和我们的规则完全不同。
#[test]
fn auto_created_block_rule_beats_our_allow_rule() {
let text = format!(
"{PROFILES_OK}\n\
RULE|True|Inbound|Allow|Any|QFT Desktop\n\
RULE|True|Inbound|Block|Public|qft-desktop.exe"
);
match classify_probe(&text) {
FirewallStatus::BlockedByRule(names) => {
assert!(names.contains("qft-desktop.exe"), "要报出实际规则名:{names}");
}
other => panic!("阻止规则必须压过放行规则,实际判定为 {other:?}"),
}
// 这一类是可以靠提权自动清掉的
assert!(classify_probe(&text).fixable_by_grant());
assert!(classify_probe(&text).needs_action());
}
#[test]
fn disabled_block_rule_is_harmless() {
let text = format!(
"{PROFILES_OK}\n\
RULE|True|Inbound|Allow|Any|QFT Desktop\n\
RULE|False|Inbound|Block|Public|qft-desktop.exe\n\
{DIRECT_PORTS_OK}"
);
assert_eq!(classify_probe(&text), FirewallStatus::Allowed);
}
/// 「阻止所有传入连接」打开时,加多少放行规则都没用,
/// 必须报成另一种状态,否则用户会一直点那个不起作用的按钮。
#[test]
fn blanket_inbound_block_is_reported_separately() {
let text = "PROFILE|Domain|True|Block|True\n\
PROFILE|Private|True|Block|True\n\
PROFILE|Public|True|Block|False\n\
RULE|True|Inbound|Allow|Any|QFT Desktop";
match classify_probe(text) {
FirewallStatus::BlockedByPolicy(reason) => {
assert!(reason.contains("Public"), "要指出是哪个配置文件:{reason}");
}
other => panic!("应报告系统级封禁,实际为 {other:?}"),
}
// 这一类我们不去动,属于用户的安全设置
assert!(!classify_probe(text).fixable_by_grant());
assert!(classify_probe(text).needs_action());
}
#[test]
fn blanket_block_on_a_disabled_profile_is_ignored() {
// 防火墙本身关着的配置文件,AllowInboundRules 是什么都无所谓
let text = "PROFILE|Domain|True|Block|True\n\
PROFILE|Private|True|Block|True\n\
PROFILE|Public|False|Block|False\n\
RULE|True|Inbound|Allow|Any|QFT Desktop\n\
PORT|True|Inbound|Allow|Any|TCP|39393|QFT-Desktop-Direct-TCP-v2\n\
PORT|True|Inbound|Allow|Any|UDP|39392|QFT-Desktop-Direct-UDP-v2";
assert_eq!(classify_probe(text), FirewallStatus::Allowed);
}
#[test]
fn firewall_entirely_off_needs_no_rule() {
let text = "PROFILE|Domain|False|Block|True\n\
PROFILE|Private|False|Block|True\n\
PROFILE|Public|False|Block|True";
assert_eq!(classify_probe(text), FirewallStatus::Allowed);
}
#[test]
fn not_configured_inbound_setting_is_not_a_blanket_block() {
let text = "PROFILE|Public|True|Block|NotConfigured\n\
RULE|True|Inbound|Allow|Any|QFT Desktop\n\
PORT|True|Inbound|Allow|Any|TCP|39393|QFT-Desktop-Direct-TCP-v2\n\
PORT|True|Inbound|Allow|Any|UDP|39392|QFT-Desktop-Direct-UDP-v2";
assert_eq!(classify_probe(text), FirewallStatus::Allowed);
}
#[test]
fn every_status_has_a_non_empty_detail() {
for value in [
FirewallStatus::Allowed,
FirewallStatus::Missing,
FirewallStatus::BlockedByPolicy("策略".into()),
FirewallStatus::BlockedByRule("规则名".into()),
FirewallStatus::Unknown("原因".into()),
FirewallStatus::Unsupported("不支持"),
] {
assert!(!value.detail().trim().is_empty(), "{value:?} 缺少说明文案");
}
}
#[test]
fn manual_instructions_never_recreate_the_profile_bug() {
let text = manual_instructions(39393);
#[cfg(target_os = "windows")]
{
assert!(
text.contains("-Profile Any"),
"手动命令必须覆盖所有网络类型,否则在公用网络上无效:{text}"
);
assert!(
!text.contains("Private,Domain"),
"照抄这条命令会重建出在 Direct AP 网卡上不适用的规则:{text}"
);
// 用户是整段粘进 PowerShell 的,任何非命令行都会被当成 cmdlet 报错
for line in text.lines() {
let line = line.trim();
assert!(
line.is_empty()
|| line.starts_with('#')
|| line.starts_with('$')
|| line.starts_with("Get-")
|| line.starts_with("New-")
|| line.starts_with("Remove-"),
"剪贴板里只能有命令和注释,这一行会被 PowerShell 当成 cmdlet:{line}"
);
}
}
let _ = text;
}
/// `\` 续行是 bash 语法,PowerShell 用反引号。上一版在提权脚本和手动
/// 命令里都写了 `\`,导致脚本在用户机器上直接语法错误,而外层退出码
/// 又是 0,程序还误报了「放行成功」。
#[test]
fn generated_scripts_use_no_backslash_continuation() {
let script = grant_script(r"C:\Program Files\QFT\qft-desktop.exe", r"C:\Temp\qft.ok");
for (index, line) in script.lines().enumerate() {
assert!(
!line.trim_end().ends_with('\\'),
"第 {} 行用了 bash 的 `\\` 续行,PowerShell 不认:{line}",
index + 1
);
}
assert!(!manual_instructions(39393).contains("\\\n"));
}
#[test]
fn grant_script_quotes_paths_and_reports_success() {
let script = grant_script(r"C:\Program Files\QFT\qft-desktop.exe", r"C:\Temp\qft.ok");
// 带空格的路径必须整体在单引号里,否则会被重新分词
assert!(script.contains(r"$exe = 'C:\Program Files\QFT\qft-desktop.exe'"));
// 必须写成功标记,否则调用方无法区分「跑通了」和「脚本报错了」
assert!(script.contains("Set-Content -Path $marker"));
assert!(script.contains("-Profile Any"));
assert!(script.contains("-EdgeTraversalPolicy Allow"));
assert!(script.contains("-Protocol TCP -LocalPort 39393"));
assert!(script.contains("-Protocol UDP -LocalPort 39392"));
// 单引号要按 PowerShell 的规则翻倍转义
let tricky = grant_script("C:\\o'brien\\qft.exe", "C:\\t.ok");
assert!(tricky.contains("'C:\\o''brien\\qft.exe'"), "{tricky}");
}
#[test]
fn probe_never_counts_a_same_named_rule_for_an_old_executable() {
let script = probe_script(r"C:\new-build\qft-desktop.exe");
assert!(script.contains("Get-NetFirewallApplicationFilter -Program $exe"));
assert!(
!script.contains("Get-NetFirewallRule -DisplayName"),
"只按同名规则查询会把旧构建路径误判为已放行:{script}"
);
assert!(script.contains("Get-NetFirewallRule -Name 'QFT-Desktop-Direct-TCP-v2'"));
}
#[test]
fn status_is_read_only_and_repeatable() {
// 检测必须无副作用:连续调用结果一致,且不改动任何系统设置
assert_eq!(status(), status());
}
}
+2338
View File
File diff suppressed because it is too large Load Diff
+424
View File
@@ -0,0 +1,424 @@
use anyhow::{Context, Result};
use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine as _};
use rand::RngCore;
use serde::{Deserialize, Serialize};
use serde_json::{json, Value};
use std::{
fs,
net::{IpAddr, Ipv4Addr},
path::PathBuf,
};
pub const PAIR_PREFIX: &str = "QFTPAIR2:";
pub const SEND_PREFIX: &str = "QFTSEND2:";
#[derive(Clone, Debug)]
pub struct PairingPayload {
pub v: u8,
pub session: String,
pub pc_name: String,
pub transport: String,
pub port: u16,
pub endpoints: Vec<String>,
pub wifi: Option<WifiCredentials>,
/// `upload` means Android uploads to this PC. `download` means the PC has
/// selected a file and Android downloads it immediately after pairing.
pub direction: PairingDirection,
pub file_name: Option<String>,
pub file_size: Option<u64>,
pub sha256: Option<String>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum PairingDirection {
Upload,
Download,
}
#[derive(Clone, Debug)]
pub struct WifiCredentials {
pub ssid: String,
pub passphrase: String,
pub security: String,
}
#[derive(Clone, Debug, Serialize, Deserialize)]
struct DirectApIdentity {
version: u8,
ssid: String,
passphrase: String,
}
impl PairingPayload {
/// v2 intentionally uses short JSON keys. A Direct-AP QR carries only the
/// dedicated Wi-Fi identity, session and port: Android must join that Wi-Fi
/// and obtain the desktop gateway from the resulting route table. Existing
/// LAN/virtual-adapter addresses are deliberately excluded so they cannot
/// bypass or delay dedicated pairing.
pub fn encode_text(&self) -> Result<String> {
let endpoints: Vec<&str> = if self.wifi.is_some() {
Vec::new()
} else {
self.endpoints.iter().take(4).map(String::as_str).collect()
};
let wifi = self.wifi.as_ref().map(|w| json!([w.ssid, w.passphrase]));
let mut value = json!({
"v": 2,
"s": self.session,
"n": self.pc_name,
"p": self.port,
"e": endpoints,
"w": wifi,
});
// Keep the common Android → PC QR as small as before. File metadata is
// needed only for the new PC → Android automatic-download QR.
if self.direction == PairingDirection::Download {
let object = value.as_object_mut().expect("pairing JSON object");
object.insert("d".into(), Value::String("d".into()));
object.insert("f".into(), serde_json::to_value(&self.file_name)?);
object.insert("z".into(), serde_json::to_value(self.file_size)?);
object.insert("h".into(), serde_json::to_value(&self.sha256)?);
}
let json = serde_json::to_vec(&value).context("serialize pairing payload")?;
let prefix = match self.direction {
PairingDirection::Upload => PAIR_PREFIX,
PairingDirection::Download => SEND_PREFIX,
};
Ok(format!("{prefix}{}", URL_SAFE_NO_PAD.encode(json)))
}
}
pub fn new_session_token() -> String {
let mut bytes = [0u8; 16];
rand::rng().fill_bytes(&mut bytes);
URL_SAFE_NO_PAD.encode(bytes)
}
/// Decode an authenticated Direct discovery datagram. `Some(None)` preserves
/// compatibility with older Android builds that did not include a device name.
pub fn discovery_device(text: &str, session: &str) -> Option<Option<String>> {
let prefix = format!("QFTDISC2:{session}");
if text == prefix {
return Some(None);
}
let encoded = text.strip_prefix(&(prefix + ":"))?;
let bytes = URL_SAFE_NO_PAD.decode(encoded).ok()?;
let name = String::from_utf8(bytes).ok()?;
let clean: String = name
.chars()
.filter(|c| !c.is_control())
.take(80)
.collect();
(!clean.trim().is_empty()).then_some(Some(clean))
}
/// Keep one random AP identity per Windows device so Android can remember the
/// user's approval for that exact local-only network. The AP itself is only
/// active while QFT receive mode is running; the file-transfer session token is
/// regenerated every time receive mode starts.
pub fn load_or_create_direct_ap_credentials(pc_name: &str) -> Result<(String, String)> {
let path = direct_ap_identity_path();
if let Ok(bytes) = fs::read(&path) {
if let Ok(identity) = serde_json::from_slice::<DirectApIdentity>(&bytes) {
if identity.version == 1
&& !identity.ssid.trim().is_empty()
&& (8..=63).contains(&identity.passphrase.len())
{
return Ok((identity.ssid, identity.passphrase));
}
}
}
let (ssid, passphrase) = new_direct_ap_credentials(pc_name);
let identity = DirectApIdentity {
version: 1,
ssid: ssid.clone(),
passphrase: passphrase.clone(),
};
if let Some(parent) = path.parent() {
fs::create_dir_all(parent)
.with_context(|| format!("创建 QFT 配置目录 {} 失败", parent.display()))?;
}
let tmp = path.with_extension("json.tmp");
let json = serde_json::to_vec_pretty(&identity)?;
fs::write(&tmp, json)
.with_context(|| format!("保存 QFT Direct 身份 {} 失败", tmp.display()))?;
if path.exists() {
let _ = fs::remove_file(&path);
}
fs::rename(&tmp, &path)
.with_context(|| format!("完成 QFT Direct 身份保存 {} 失败", path.display()))?;
Ok((ssid, passphrase))
}
pub fn reset_direct_ap_credentials() -> Result<()> {
let path = direct_ap_identity_path();
if path.exists() {
fs::remove_file(&path)
.with_context(|| format!("删除 QFT Direct 身份 {} 失败", path.display()))?;
}
Ok(())
}
fn direct_ap_identity_path() -> PathBuf {
crate::platform::config_dir().join("direct-ap.json")
}
fn new_direct_ap_credentials(pc_name: &str) -> (String, String) {
let suffix = new_session_token();
let suffix = &suffix[..6.min(suffix.len())];
let base: String = pc_name
.chars()
.filter(|c| c.is_ascii_alphanumeric())
.take(10)
.collect();
let base = if base.is_empty() { "PC" } else { &base };
let ssid = format!("QFT-{base}-{suffix}");
let mut random = [0u8; 12];
rand::rng().fill_bytes(&mut random);
let password = URL_SAFE_NO_PAD.encode(random);
(ssid, password[..16.min(password.len())].to_owned())
}
/// 本机可用的私有 IPv4 地址,按「最可能是对方看得到的那一个」排序。
///
/// 连接码把地址编进码里,所以这里的排序直接决定了用户第一眼看到的那串码
/// 是否好用。虚拟网卡(Docker/VPN/虚拟机桥接)会排到后面。
pub fn local_ipv4_addresses() -> Vec<Ipv4Addr> {
let mut ips = Vec::<Ipv4Addr>::new();
if let Ok(addrs) = if_addrs::get_if_addrs() {
for iface in addrs {
let IpAddr::V4(ip) = iface.ip() else { continue };
if ip.is_loopback() || ip.is_unspecified() || ip.is_link_local() {
continue;
}
if !ip.is_private() {
continue;
}
if !ips.contains(&ip) {
ips.push(ip);
}
}
}
ips.sort_by_key(|ip| {
let o = ip.octets();
if is_likely_virtual(*ip) {
return 4;
}
match (o[0], o[1]) {
(192, 168) => 1,
(10, _) => 2,
(172, 16..=31) => 3,
_ => 4,
}
});
ips
}
/// 供二维码使用的端点列表。
///
/// Direct AP 模式不广播任何电脑现有网卡地址。手机必须先加入二维码中的
/// 专用 Wi-Fi,再从 Android 为该连接提供的实际路由表读取网关。这样不会
/// 猜测 192.168.137.1/49.1,也不会误连 LAN、VPN、WSL 或虚拟机网卡。
pub fn qr_endpoints(port: u16, direct_ap_active: bool) -> Vec<String> {
if direct_ap_active {
return Vec::new();
}
local_ipv4_endpoints(port)
}
fn is_likely_virtual(ip: Ipv4Addr) -> bool {
let o = ip.octets();
if o[3] != 1 {
return false;
}
match (o[0], o[1]) {
// VMware Workstation 常用 192.168.(1..=254).1 里的高位段;
// 这里只挑实测遇到的与常见默认值,避免误伤家用 192.168.0/1.1
(192, 168) => matches!(o[2], 30 | 31 | 56 | 99 | 100 | 152 | 174 | 226),
// WSL2 / Hyper-V 默认在 172.16-31 段
(172, 16..=31) => true,
_ => false,
}
}
pub fn local_ipv4_endpoints(port: u16) -> Vec<String> {
// 备用 LAN 模式也只广播系统中真实存在的私有地址,不再追加
// 192.168.137.1/49.1 等猜测值。Android 随后还会按实际子网过滤。
local_ipv4_addresses().into_iter()
.map(|ip| format!("http://{ip}:{port}"))
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn discovery_request_reports_android_name_and_accepts_legacy_format() {
let session = "abcdefghijklmnopqrstuvwxyz012345";
let name = URL_SAFE_NO_PAD.encode("HUAWEI CDY-AN90".as_bytes());
assert_eq!(
discovery_device(&format!("QFTDISC2:{session}:{name}"), session),
Some(Some("HUAWEI CDY-AN90".into()))
);
assert_eq!(discovery_device(&format!("QFTDISC2:{session}"), session), Some(None));
assert_eq!(discovery_device("QFTDISC2:wrong", session), None);
}
#[test]
fn download_pairing_uses_dedicated_short_prefix() {
let payload = PairingPayload {
v: 2,
session: "abcdefghijklmnopqrstuvwxyz012345".into(),
pc_name: "DESKTOP-QFT".into(),
transport: "http-download-v2".into(),
port: 39393,
endpoints: vec!["http://192.168.49.1:39393".into()],
wifi: None,
direction: PairingDirection::Download,
file_name: Some("sample.bin".into()),
file_size: Some(42),
sha256: Some("00".repeat(32)),
};
let text = payload.encode_text().unwrap();
assert!(text.starts_with(SEND_PREFIX));
assert!(text.len() < 800);
}
}
#[cfg(test)]
mod endpoint_order_tests {
use super::*;
#[test]
fn current_lan_endpoints_are_all_real_private_interfaces() {
let endpoints = local_ipv4_endpoints(39393);
let real: Vec<Ipv4Addr> = local_ipv4_addresses();
let expected: Vec<String> = real
.iter()
.map(|address| format!("http://{address}:39393"))
.collect();
assert_eq!(endpoints, expected);
}
#[test]
fn direct_pairing_excludes_every_preexisting_computer_address() {
let payload = PairingPayload {
v: 2,
session: "abcdefghijklmnopqrstuvwxyz012345".into(),
pc_name: "PC".into(),
transport: "http-parallel-v2".into(),
port: 39393,
endpoints: vec![
"http://192.168.137.1:39393".into(),
"http://192.168.8.68:39393".into(),
],
wifi: Some(WifiCredentials {
ssid: "QFT-PC-abc".into(),
passphrase: "0123456789ab".into(),
security: "WPA2".into(),
}),
direction: PairingDirection::Upload,
file_name: None,
file_size: None,
sha256: None,
};
let text = payload.encode_text().unwrap();
let json = String::from_utf8(
base64::engine::general_purpose::URL_SAFE_NO_PAD
.decode(text.trim_start_matches(PAIR_PREFIX))
.unwrap(),
).unwrap();
assert!(!json.contains("192.168.8.68"), "Direct 二维码不得携带 LAN 地址:{json}");
assert!(!json.contains("192.168.137.1"), "Direct 二维码不得猜测 AP 网关:{json}");
assert!(json.contains("\"e\":[]"), "Direct 二维码端点必须为空:{json}");
assert!(json.contains("QFT-PC-abc"), "专用 Wi-Fi 身份必须保留:{json}");
}
}
#[cfg(test)]
mod qr_endpoint_tests {
use super::*;
#[test]
fn direct_ap_never_advertises_guessed_or_local_addresses() {
let endpoints = qr_endpoints(39393, true);
assert!(endpoints.is_empty(), "Direct 模式只能由手机读取实际网关:{endpoints:?}");
}
#[test]
fn direct_ap_encoding_stays_address_free_even_with_input_endpoints() {
let payload = PairingPayload {
v: 2,
session: "abcdefghijklmnopqrstuvwxyz012345".into(),
pc_name: "PC".into(),
transport: "http-parallel-v2".into(),
port: 39393,
endpoints: vec![
"http://192.168.137.1:39393".into(),
"http://10.20.30.40:39393".into(),
],
wifi: Some(WifiCredentials {
ssid: "QFT-PC-abc".into(),
passphrase: "0123456789ab".into(),
security: "WPA2".into(),
}),
direction: PairingDirection::Upload,
file_name: None,
file_size: None,
sha256: None,
};
let text = payload.encode_text().unwrap();
let json = String::from_utf8(
base64::engine::general_purpose::URL_SAFE_NO_PAD
.decode(text.trim_start_matches(PAIR_PREFIX))
.unwrap(),
).unwrap();
assert!(!json.contains("192.168.137.1"), "不得携带猜测网关:{json}");
assert!(!json.contains("10.20.30.40"), "不得携带本地网卡:{json}");
}
#[test]
fn without_direct_ap_no_guessed_addresses_are_added() {
let endpoints = qr_endpoints(39393, false);
let real = local_ipv4_addresses();
for guessed in ["192.168.137.1", "192.168.49.1"] {
if !real.iter().any(|ip| ip.to_string() == guessed) {
assert!(
!endpoints.iter().any(|endpoint| endpoint.contains(guessed)),
"不存在的地址不得加入二维码:{endpoints:?}"
);
}
}
}
}
#[cfg(test)]
mod virtual_adapter_tests {
use super::*;
/// 实测中这三个虚拟网卡地址把 Direct AP 网关挤出了二维码。
#[test]
fn known_virtual_ranges_are_recognised() {
for ip in ["192.168.30.1", "192.168.31.1", "172.21.96.1", "172.17.0.1"] {
assert!(is_likely_virtual(ip.parse().unwrap()), "{ip} 应被识别为虚拟网卡");
}
}
/// 家用路由器最常见的网关不能被误伤,否则真实局域网地址反被降权。
#[test]
fn common_home_gateways_are_not_treated_as_virtual() {
for ip in ["192.168.0.1", "192.168.1.1", "192.168.8.1", "10.0.0.1"] {
assert!(!is_likely_virtual(ip.parse().unwrap()), "{ip} 不应被当作虚拟网卡");
}
}
/// 只有 .1 结尾才可能是虚拟网关;普通主机地址一律不降权。
#[test]
fn only_gateway_addresses_are_considered() {
assert!(!is_likely_virtual("192.168.30.55".parse().unwrap()));
assert!(!is_likely_virtual("172.21.96.200".parse().unwrap()));
}
}
+293
View File
@@ -0,0 +1,293 @@
//! 平台差异的唯一收敛点。
//!
//! 约定:除本文件与 `direct_ap.rs` 外,其余模块不得出现 `#[cfg(target_os = ...)]`。
//! 新增平台差异时先在这里补一个函数,不要就地 cfg —— 否则跨平台移植会重新变成
//! 满仓库找 cfg 的考古工作。
use std::path::{Path, PathBuf};
/// QFT 的持久化配置目录(Direct AP 身份、信任库等)。
///
/// - Windows: `%LOCALAPPDATA%\QFT`
/// - macOS: `~/Library/Application Support/QFT`
/// - Linux: `$XDG_CONFIG_HOME/qft`,未设置时 `~/.config/qft`
pub fn config_dir() -> PathBuf {
#[cfg(target_os = "windows")]
{
if let Some(root) = non_empty_env("LOCALAPPDATA") {
return PathBuf::from(root).join("QFT");
}
}
#[cfg(target_os = "macos")]
{
if let Some(home) = home_dir() {
return home.join("Library").join("Application Support").join("QFT");
}
}
#[cfg(all(unix, not(target_os = "macos")))]
{
if let Some(root) = non_empty_env("XDG_CONFIG_HOME") {
return PathBuf::from(root).join("qft");
}
if let Some(home) = home_dir() {
return home.join(".config").join("qft");
}
}
// 环境变量全都拿不到时退回当前目录下的隐藏目录,保证功能不中断
PathBuf::from(".qft")
}
/// 接收文件的默认保存目录。
pub fn default_download_dir() -> PathBuf {
#[cfg(all(unix, not(target_os = "macos")))]
{
// Linux 桌面环境会把"下载"本地化(中文系统是 ~/下载),
// 目录名记录在 user-dirs.dirs 里,直接拼 "Downloads" 会建出一个用户看不见的目录。
if let Some(dir) = xdg_user_dir("XDG_DOWNLOAD_DIR") {
return dir;
}
}
if let Some(home) = home_dir() {
let downloads = home.join("Downloads");
if downloads.is_dir() {
return downloads;
}
return home;
}
PathBuf::from(".")
}
/// 展示给对端的本机名称。
pub fn device_name() -> String {
let raw = whoami::fallible::hostname().unwrap_or_else(|_| whoami::devicename());
sanitize_device_name(&raw)
}
/// 设备名会进入配对二维码、mDNS TXT 与对端的设备列表,
/// 必须去掉控制字符、去掉 mDNS 的 `.local` 后缀并限长。
pub fn sanitize_device_name(raw: &str) -> String {
let cleaned: String = raw
.chars()
.filter(|ch| !ch.is_control())
.take(64)
.collect();
// macOS/Linux 取到的常是 mDNS 主机名(如 zdeMacBook-Air.local),
// 后缀对用户没有意义,列在对方设备列表里只会更长更难认。
let cleaned = cleaned
.strip_suffix(".local")
.or_else(|| cleaned.strip_suffix(".lan"))
.unwrap_or(&cleaned)
.to_owned();
let trimmed = cleaned.trim();
if trimmed.is_empty() {
default_device_name().to_owned()
} else {
trimmed.to_owned()
}
}
const fn default_device_name() -> &'static str {
#[cfg(target_os = "windows")]
{
"Windows-PC"
}
#[cfg(target_os = "macos")]
{
"Mac"
}
#[cfg(all(unix, not(target_os = "macos")))]
{
"Linux-PC"
}
}
/// 系统自带的中文字体候选,按优先级排列。
///
/// 仓库不附带第三方字体,界面文字全是中文,找不到字体就会满屏豆腐块。
/// 注意 macOS 与多数 Linux 发行版的中文字体是 **`.ttc` 字体集合**,
/// 只按 `.ttf` 扩展名筛选会把它们全部漏掉。
pub fn system_font_candidates() -> Vec<PathBuf> {
#[cfg(target_os = "macos")]
{
vec![
PathBuf::from("/System/Library/Fonts/PingFang.ttc"),
PathBuf::from("/System/Library/Fonts/Hiragino Sans GB.ttc"),
PathBuf::from("/System/Library/Fonts/STHeiti Medium.ttc"),
PathBuf::from("/System/Library/Fonts/STHeiti Light.ttc"),
PathBuf::from("/Library/Fonts/Arial Unicode.ttf"),
]
}
#[cfg(target_os = "windows")]
{
vec![
// 新版 Windows 的微软雅黑是 .ttc,旧的筛选逻辑正好漏掉它
PathBuf::from(r"C:\Windows\Fonts\msyh.ttc"),
PathBuf::from(r"C:\Windows\Fonts\msyh.ttf"),
PathBuf::from(r"C:\Windows\Fonts\simhei.ttf"),
PathBuf::from(r"C:\Windows\Fonts\Deng.ttf"),
PathBuf::from(r"C:\Windows\Fonts\simsun.ttc"),
]
}
#[cfg(all(unix, not(target_os = "macos")))]
{
vec![
PathBuf::from("/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc"),
PathBuf::from("/usr/share/fonts/opentype/noto/NotoSansCJKsc-Regular.otf"),
PathBuf::from("/usr/share/fonts/truetype/noto/NotoSansCJK-Regular.ttc"),
PathBuf::from("/usr/share/fonts/opentype/source-han-sans/SourceHanSansSC-Regular.otf"),
PathBuf::from("/usr/share/fonts/wqy-zenhei/wqy-zenhei.ttc"),
PathBuf::from("/usr/share/fonts/truetype/wqy/wqy-microhei.ttc"),
PathBuf::from("/usr/share/fonts/truetype/arphic/uming.ttc"),
]
}
}
/// 本机所属平台,用于 mDNS TXT 与 UI 图标。
pub const fn platform_tag() -> &'static str {
#[cfg(target_os = "windows")]
{
"windows"
}
#[cfg(target_os = "macos")]
{
"macos"
}
#[cfg(all(unix, not(target_os = "macos")))]
{
"linux"
}
}
/// 本机能否开启 QFT Direct 临时热点。
///
/// 只有 Windows 走 WiFi Direct;macOS 无公开 API,Linux 各发行版
/// NetworkManager 行为差异过大,都不做——UI 据此隐藏入口,
/// 而不是让用户点进去再失败。
pub enum DirectApSupport {
Supported,
Unsupported(&'static str),
}
pub const fn direct_ap_support() -> DirectApSupport {
#[cfg(target_os = "windows")]
{
DirectApSupport::Supported
}
#[cfg(not(target_os = "windows"))]
{
DirectApSupport::Unsupported("本平台不支持 QFT Direct 热点,请让两台设备连接同一个 Wi-Fi")
}
}
impl DirectApSupport {
pub const fn is_supported(&self) -> bool {
matches!(self, DirectApSupport::Supported)
}
}
// ---------------------------------------------------------------- 内部工具
fn non_empty_env(key: &str) -> Option<String> {
std::env::var(key).ok().filter(|v| !v.trim().is_empty())
}
fn home_dir() -> Option<PathBuf> {
#[cfg(target_os = "windows")]
{
if let Some(profile) = non_empty_env("USERPROFILE") {
return Some(PathBuf::from(profile));
}
let drive = non_empty_env("HOMEDRIVE")?;
let path = non_empty_env("HOMEPATH")?;
return Some(PathBuf::from(format!("{drive}{path}")));
}
#[cfg(unix)]
{
non_empty_env("HOME").map(PathBuf::from)
}
}
/// 解析 `~/.config/user-dirs.dirs` 里形如
/// `XDG_DOWNLOAD_DIR="$HOME/下载"` 的一行。
#[cfg(all(unix, not(target_os = "macos")))]
fn xdg_user_dir(key: &str) -> Option<PathBuf> {
let home = home_dir()?;
let config = non_empty_env("XDG_CONFIG_HOME")
.map(PathBuf::from)
.unwrap_or_else(|| home.join(".config"));
let text = std::fs::read_to_string(config.join("user-dirs.dirs")).ok()?;
for line in text.lines() {
let line = line.trim();
if line.starts_with('#') {
continue;
}
let (name, value) = line.split_once('=')?;
if name.trim() != key {
continue;
}
let value = value.trim().trim_matches('"');
let expanded = if let Some(rest) = value.strip_prefix("$HOME/") {
home.join(rest)
} else if value == "$HOME" {
home.clone()
} else {
PathBuf::from(value)
};
if expanded.is_dir() {
return Some(expanded);
}
}
None
}
/// 确保目录存在,返回其路径。调用方负责处理失败。
#[allow(dead_code)] // 由 client 的下载路径使用,该路径尚未接线
pub fn ensure_dir(path: &Path) -> std::io::Result<()> {
if path.is_dir() {
return Ok(());
}
std::fs::create_dir_all(path)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn config_dir_is_absolute_or_local_fallback() {
let dir = config_dir();
// 要么是绝对路径(拿到了环境变量),要么是约定的本地兜底
assert!(dir.is_absolute() || dir == PathBuf::from(".qft"), "{dir:?}");
}
#[test]
fn device_name_is_never_empty_and_bounded() {
let name = device_name();
assert!(!name.is_empty());
assert!(name.chars().count() <= 64);
assert!(!name.chars().any(char::is_control));
}
#[test]
fn sanitize_strips_control_chars_and_falls_back() {
assert_eq!(sanitize_device_name(" ok-name \n"), "ok-name");
assert_eq!(sanitize_device_name("a\u{0}b"), "ab");
assert_eq!(sanitize_device_name(" "), default_device_name());
assert_eq!(sanitize_device_name("\n\t"), default_device_name());
assert_eq!(sanitize_device_name(&"x".repeat(200)).chars().count(), 64);
// mDNS 后缀不该出现在设备列表里
assert_eq!(sanitize_device_name("zdeMacBook-Air.local"), "zdeMacBook-Air");
assert_eq!(sanitize_device_name("ubuntu-dev.lan"), "ubuntu-dev");
// 只去掉结尾的后缀,名字中间含 .local 的不动
assert_eq!(sanitize_device_name("my.local.pc"), "my.local.pc");
}
#[test]
fn platform_tag_matches_direct_ap_capability() {
// Direct AP 目前只有 Windows 支持,两个常量必须保持一致
assert_eq!(
direct_ap_support().is_supported(),
platform_tag() == "windows"
);
}
}
@@ -191,19 +191,7 @@ pub fn hex_sha256(bytes: &[u8; 32]) -> String {
} }
pub fn local_device_name() -> String { pub fn local_device_name() -> String {
let raw = std::env::var("COMPUTERNAME") crate::platform::device_name()
.or_else(|_| std::env::var("HOSTNAME"))
.unwrap_or_else(|_| "Windows-PC".to_owned());
let cleaned: String = raw
.chars()
.filter(|ch| !ch.is_control())
.take(64)
.collect();
if cleaned.trim().is_empty() {
"Windows-PC".to_owned()
} else {
cleaned
}
} }
fn hash_file_streaming(file: &File) -> Result<[u8; 32]> { fn hash_file_streaming(file: &File) -> Result<[u8; 32]> {
+15 -2
View File
@@ -3,6 +3,7 @@ use eframe::egui::ColorImage;
use qrcode::{types::Color, EcLevel, QrCode}; use qrcode::{types::Color, EcLevel, QrCode};
const QUIET_MODULES: usize = 4; const QUIET_MODULES: usize = 4;
const PAIR_EC_LEVEL: EcLevel = EcLevel::L;
/// Active optical renderer. QFT2/Base45 text uses only QR alphanumeric /// Active optical renderer. QFT2/Base45 text uses only QR alphanumeric
/// characters, allowing the QR encoder to choose a compact alphanumeric data /// characters, allowing the QR encoder to choose a compact alphanumeric data
@@ -16,9 +17,11 @@ pub fn render_qr_fitted(text: &str, target_side: usize) -> Result<ColorImage> {
Ok(ColorImage::from_gray([side, side], &render_code_gray(&code, side))) Ok(ColorImage::from_gray([side, side], &render_code_gray(&code, side)))
} }
/// Pairing QR stays static and uses M error correction for first-scan reliability. /// Pairing happens from a clean, static desktop display. QR-L keeps long
/// QFTSEND2 payloads several versions smaller than QR-M, giving the camera
/// materially more pixels per module; the full quiet zone remains intact.
pub fn render_pair_qr(text: &str, target_side: usize) -> Result<ColorImage> { pub fn render_pair_qr(text: &str, target_side: usize) -> Result<ColorImage> {
let code = QrCode::with_error_correction_level(text.as_bytes(), EcLevel::M) let code = QrCode::with_error_correction_level(text.as_bytes(), PAIR_EC_LEVEL)
.context("pair QR payload too large")?; .context("pair QR payload too large")?;
let modules = code.width() + QUIET_MODULES * 2; let modules = code.width() + QUIET_MODULES * 2;
let scale = (target_side / modules).max(1); let scale = (target_side / modules).max(1);
@@ -26,6 +29,16 @@ pub fn render_pair_qr(text: &str, target_side: usize) -> Result<ColorImage> {
Ok(ColorImage::from_gray([side, side], &render_code_gray(&code, side))) Ok(ColorImage::from_gray([side, side], &render_code_gray(&code, side)))
} }
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn pairing_qr_uses_low_density_error_correction() {
assert_eq!(PAIR_EC_LEVEL, EcLevel::L);
}
}
fn render_code_gray(code: &QrCode, side: usize) -> Vec<u8> { fn render_code_gray(code: &QrCode, side: usize) -> Vec<u8> {
let qr_width = code.width(); let qr_width = code.width();
let modules = qr_width + QUIET_MODULES * 2; let modules = qr_width + QUIET_MODULES * 2;
@@ -10,7 +10,7 @@ use std::{
net::{TcpListener, TcpStream, UdpSocket}, net::{TcpListener, TcpStream, UdpSocket},
path::{Path, PathBuf}, path::{Path, PathBuf},
sync::{ sync::{
atomic::{AtomicBool, Ordering}, atomic::{AtomicBool, AtomicU32, Ordering},
mpsc::Sender, mpsc::Sender,
Arc, Mutex, Arc, Mutex,
}, },
@@ -21,10 +21,13 @@ use std::{
pub const PREFERRED_PORT: u16 = 39393; pub const PREFERRED_PORT: u16 = 39393;
pub const DISCOVERY_PORT: u16 = 39392; pub const DISCOVERY_PORT: u16 = 39392;
pub const PARALLEL_CHUNK_SIZE: u64 = 8 * 1024 * 1024; pub const PARALLEL_CHUNK_SIZE: u64 = 8 * 1024 * 1024;
const MIN_PARALLEL_CHUNK_SIZE: u64 = 64 * 1024;
const MAX_PARALLEL_CHUNK_SIZE: u64 = 16 * 1024 * 1024;
const IO_BUFFER: usize = 1024 * 1024; const IO_BUFFER: usize = 1024 * 1024;
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub enum ReceiverEvent { pub enum ReceiverEvent {
TransportConnected { peer: String },
ClientConnected { device: String }, ClientConnected { device: String },
UploadStarted { device: String, file_name: String, size: u64 }, UploadStarted { device: String, file_name: String, size: u64 },
UploadProgress { device: String, file_name: String, received: u64, size: u64 }, UploadProgress { device: String, file_name: String, received: u64, size: u64 },
@@ -57,6 +60,9 @@ struct CompletedUpload {
pub struct ReceiverServer { pub struct ReceiverServer {
pub port: u16, pub port: u16,
/// PC↔PC 的配对秘密(3 字节)。UI 会把它和本机地址一起编成连接码,
/// 用户只需要念/粘贴那一串,不必再单独报 IP 和端口。
pub secret: [u8; crate::connect_code::SECRET_LEN],
stop: Arc<AtomicBool>, stop: Arc<AtomicBool>,
tcp_thread: Option<JoinHandle<()>>, tcp_thread: Option<JoinHandle<()>>,
udp_thread: Option<JoinHandle<()>>, udp_thread: Option<JoinHandle<()>>,
@@ -74,6 +80,11 @@ impl ReceiverServer {
let stop = Arc::new(AtomicBool::new(false)); let stop = Arc::new(AtomicBool::new(false));
let sessions: SessionMap = Arc::new(Mutex::new(HashMap::new())); let sessions: SessionMap = Arc::new(Mutex::new(HashMap::new()));
let completed: CompletedMap = Arc::new(Mutex::new(HashMap::new())); let completed: CompletedMap = Arc::new(Mutex::new(HashMap::new()));
// 24 bit 秘密对在线爆破仍然不够,靠严格失败计数兜底:
// 错 5 次即作废,必须重启接收重新生成。
let secret = crate::connect_code::new_secret();
let secret_hex: String = secret.iter().map(|b| format!("{b:02x}")).collect();
let pair_failures = Arc::new(AtomicU32::new(0));
let stop_tcp = stop.clone(); let stop_tcp = stop.clone();
let sessions_tcp = sessions.clone(); let sessions_tcp = sessions.clone();
@@ -81,17 +92,22 @@ impl ReceiverServer {
let token_tcp = session_token.clone(); let token_tcp = session_token.clone();
let dir_tcp = save_dir.clone(); let dir_tcp = save_dir.clone();
let events_tcp = events.clone(); let events_tcp = events.clone();
let code_tcp = secret_hex.clone();
let failures_tcp = pair_failures.clone();
let tcp_thread = thread::spawn(move || { let tcp_thread = thread::spawn(move || {
while !stop_tcp.load(Ordering::Relaxed) { while !stop_tcp.load(Ordering::Relaxed) {
match listener.accept() { match listener.accept() {
Ok((mut stream, _)) => { Ok((mut stream, peer)) => {
let _ = events_tcp.send(ReceiverEvent::TransportConnected { peer: peer.to_string() });
let dir = dir_tcp.clone(); let dir = dir_tcp.clone();
let token = token_tcp.clone(); let token = token_tcp.clone();
let tx = events_tcp.clone(); let tx = events_tcp.clone();
let sessions = sessions_tcp.clone(); let sessions = sessions_tcp.clone();
let completed = completed_tcp.clone(); let completed = completed_tcp.clone();
let code = code_tcp.clone();
let failures = failures_tcp.clone();
thread::spawn(move || { thread::spawn(move || {
if let Err(e) = handle_client(&mut stream, &dir, &token, &tx, &sessions, &completed) { if let Err(e) = handle_client(&mut stream, &dir, &token, &code, &failures, &tx, &sessions, &completed) {
// Never turn a parse/write race into an opaque Android // Never turn a parse/write race into an opaque Android
// `unexpected end of stream`: make a best effort to // `unexpected end of stream`: make a best effort to
// return an HTTP status before closing the socket. // return an HTTP status before closing the socket.
@@ -125,16 +141,33 @@ impl ReceiverServer {
} }
}; };
let _ = socket.set_read_timeout(Some(Duration::from_millis(250))); let _ = socket.set_read_timeout(Some(Duration::from_millis(250)));
let expected = format!("QFTDISC2:{token_udp}");
let response = format!("QFTHERE2:{token_udp}:{port}"); let response = format!("QFTHERE2:{token_udp}:{port}");
// PC↔PC 的对端不知道令牌,需要先能把本机列出来
let announce = crate::discovery::browse_reply(&crate::discovery::NodeAnnounce {
n: crate::platform::device_name(),
p: crate::platform::platform_tag().to_owned(),
t: port,
r: true,
});
let mut buf = [0u8; 512]; let mut buf = [0u8; 512];
while !stop_udp.load(Ordering::Relaxed) { while !stop_udp.load(Ordering::Relaxed) {
match socket.recv_from(&mut buf) { match socket.recv_from(&mut buf) {
Ok((n, peer)) => { Ok((n, peer)) => {
if std::str::from_utf8(&buf[..n]).ok() == Some(expected.as_str()) { match std::str::from_utf8(&buf[..n]).ok() {
Some(text) if text == crate::discovery::BROWSE_QUERY => {
let _ = socket.send_to(&announce, peer);
}
Some(text) => {
if let Some(device) = crate::pairing::discovery_device(text, &token_udp) {
if let Some(device) = device {
let _ = events.send(ReceiverEvent::ClientConnected { device });
}
let _ = socket.send_to(response.as_bytes(), peer); let _ = socket.send_to(response.as_bytes(), peer);
} }
} }
_ => {}
}
}
Err(e) if matches!(e.kind(), std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut) => {} Err(e) if matches!(e.kind(), std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut) => {}
Err(_) => break, Err(_) => break,
} }
@@ -145,6 +178,7 @@ impl ReceiverServer {
port, port,
stop, stop,
tcp_thread: Some(tcp_thread), tcp_thread: Some(tcp_thread),
secret,
udp_thread: Some(udp_thread), udp_thread: Some(udp_thread),
}) })
} }
@@ -162,10 +196,64 @@ impl Drop for ReceiverServer {
} }
} }
/// `POST /qft/pair`,请求头 `X-QFT-Code: 123456`。
///
/// 这是唯一不校验令牌的端点——它的作用就是用 6 位码换取令牌。
/// 6 位只有约 20 bit 熵,必须靠失败计数兜底:错 5 次即作废整个码,
/// 用户需要在电脑上重新启动接收才能拿到新码。
fn handle_pair(
stream: &mut TcpStream,
headers: &HashMap<String, String>,
token: &str,
pair_code: &str,
pair_failures: &AtomicU32,
events: &Sender<ReceiverEvent>,
) -> Result<()> {
const MAX_FAILURES: u32 = 5;
if pair_failures.load(Ordering::Relaxed) >= MAX_FAILURES {
let body = json!({
"ok": false,
"error": "配对码已因多次输入错误作废,请在电脑上重新启动接收"
}).to_string();
return write_response(stream, 429, "application/json", body.as_bytes());
}
let supplied = headers.get("x-qft-code").map(String::as_str).unwrap_or("");
if !constant_time_eq(supplied.as_bytes(), pair_code.as_bytes()) {
let count = pair_failures.fetch_add(1, Ordering::Relaxed) + 1;
let _ = events.send(ReceiverEvent::Error(format!(
"配对码错误({count}/{MAX_FAILURES})"
)));
let body = json!({"ok": false, "remaining": MAX_FAILURES.saturating_sub(count)}).to_string();
return write_response(stream, 403, "application/json", body.as_bytes());
}
pair_failures.store(0, Ordering::Relaxed);
let device = decode_header(headers.get("x-qft-device")).unwrap_or_else(|| "电脑".to_owned());
let _ = events.send(ReceiverEvent::ClientConnected { device });
let body = json!({"ok": true, "token": token}).to_string();
write_response(stream, 200, "application/json", body.as_bytes())
}
/// 定长比较,不因首个不同字节的位置而提前返回。
/// 局域网上计时攻击并不现实,但这段代码很便宜,没有理由写成短路比较。
fn constant_time_eq(a: &[u8], b: &[u8]) -> bool {
if a.len() != b.len() {
return false;
}
let mut diff = 0u8;
for (x, y) in a.iter().zip(b.iter()) {
diff |= x ^ y;
}
diff == 0
}
fn handle_client( fn handle_client(
stream: &mut TcpStream, stream: &mut TcpStream,
save_dir: &Path, save_dir: &Path,
token: &str, token: &str,
pair_code: &str,
pair_failures: &AtomicU32,
events: &Sender<ReceiverEvent>, events: &Sender<ReceiverEvent>,
sessions: &SessionMap, sessions: &SessionMap,
completed: &CompletedMap, completed: &CompletedMap,
@@ -200,6 +288,11 @@ fn handle_client(
let method = parts.next().unwrap_or(""); let method = parts.next().unwrap_or("");
let path = parts.next().unwrap_or(""); let path = parts.next().unwrap_or("");
// 配对是唯一不需要令牌的端点——它的作用正是换取令牌。
if method == "POST" && path == "/qft/pair" {
return handle_pair(stream, &headers, token, pair_code, pair_failures, events);
}
let supplied = headers.get("x-qft-token").map(String::as_str).unwrap_or(""); let supplied = headers.get("x-qft-token").map(String::as_str).unwrap_or("");
if supplied != token { if supplied != token {
return write_response(stream, 403, "text/plain", b"invalid session"); return write_response(stream, 403, "text/plain", b"invalid session");
@@ -250,7 +343,7 @@ fn init_parallel_upload(
.parse().context("X-QFT-Size 无效")?; .parse().context("X-QFT-Size 无效")?;
let chunk_size = headers.get("x-qft-chunk-size") let chunk_size = headers.get("x-qft-chunk-size")
.and_then(|v| v.parse::<u64>().ok()) .and_then(|v| v.parse::<u64>().ok())
.map(|v| v.clamp(1024 * 1024, 16 * 1024 * 1024)) .map(|v| v.clamp(MIN_PARALLEL_CHUNK_SIZE, MAX_PARALLEL_CHUNK_SIZE))
.unwrap_or(PARALLEL_CHUNK_SIZE); .unwrap_or(PARALLEL_CHUNK_SIZE);
let total_chunks_u64 = if size == 0 { 0 } else { (size + chunk_size - 1) / chunk_size }; let total_chunks_u64 = if size == 0 { 0 } else { (size + chunk_size - 1) / chunk_size };
if total_chunks_u64 > u32::MAX as u64 { bail!("文件分块数过大") } if total_chunks_u64 > u32::MAX as u64 { bail!("文件分块数过大") }
@@ -365,7 +458,6 @@ fn receive_parallel_chunk(
let mut out = OpenOptions::new().write(true).open(&part_path)?; let mut out = OpenOptions::new().write(true).open(&part_path)?;
out.seek(SeekFrom::Start(offset))?; out.seek(SeekFrom::Start(offset))?;
copy_exact(reader, &mut out, content_len)?; copy_exact(reader, &mut out, content_len)?;
out.sync_data()?;
let received = { let received = {
let mut session = session_arc.lock().map_err(|_| anyhow::anyhow!("上传会话损坏"))?; let mut session = session_arc.lock().map_err(|_| anyhow::anyhow!("上传会话损坏"))?;
@@ -416,6 +508,10 @@ fn finish_parallel_upload(
) )
}; };
// Per-chunk FlushFileBuffers serializes otherwise independent upload lanes
// and is especially costly on Windows. The in-memory session cannot resume
// across a desktop-process crash anyway, so commit once after all chunks.
OpenOptions::new().write(true).open(&part_path)?.sync_data()?;
let sha = hash_file(&part_path)?; let sha = hash_file(&part_path)?;
if final_path.exists() { bail!("目标文件已存在,请重新初始化上传") } if final_path.exists() { bail!("目标文件已存在,请重新初始化上传") }
fs::rename(&part_path, &final_path).context("完成文件重命名失败")?; fs::rename(&part_path, &final_path).context("完成文件重命名失败")?;
@@ -639,6 +735,8 @@ mod tests {
&mut stream, &mut stream,
&dir_for_server, &dir_for_server,
"session", "session",
"000000",
&AtomicU32::new(0),
&events, &events,
&sessions, &sessions,
&completed, &completed,
+202 -17
View File
@@ -22,6 +22,7 @@ const IO_BUFFER: usize = 1024 * 1024;
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub enum SenderEvent { pub enum SenderEvent {
TransportConnected { peer: String },
ClientConnected { device: String }, ClientConnected { device: String },
DownloadStarted { device: String, file_name: String, size: u64 }, DownloadStarted { device: String, file_name: String, size: u64 },
DownloadCompleted { device: String, file_name: String }, DownloadCompleted { device: String, file_name: String },
@@ -61,7 +62,8 @@ impl SenderServer {
let tcp_thread = thread::spawn(move || { let tcp_thread = thread::spawn(move || {
while !tcp_stop.load(Ordering::Relaxed) { while !tcp_stop.load(Ordering::Relaxed) {
match listener.accept() { match listener.accept() {
Ok((mut stream, _)) => { Ok((mut stream, peer)) => {
let _ = tcp_events.send(SenderEvent::TransportConnected { peer: peer.to_string() });
let token = tcp_token.clone(); let token = tcp_token.clone();
let path = file_path.clone(); let path = file_path.clone();
let name = file_name.clone(); let name = file_name.clone();
@@ -93,15 +95,20 @@ impl SenderServer {
} }
}; };
let _ = socket.set_read_timeout(Some(Duration::from_millis(250))); let _ = socket.set_read_timeout(Some(Duration::from_millis(250)));
let expected = format!("QFTDISC2:{session_token}");
let response = format!("QFTHERE2:{session_token}:{port}"); let response = format!("QFTHERE2:{session_token}:{port}");
let mut buf = [0u8; 512]; let mut buf = [0u8; 512];
while !udp_stop.load(Ordering::Relaxed) { while !udp_stop.load(Ordering::Relaxed) {
match socket.recv_from(&mut buf) { match socket.recv_from(&mut buf) {
Ok((n, peer)) if std::str::from_utf8(&buf[..n]).ok() == Some(expected.as_str()) => { Ok((n, peer)) => {
let Some(device) = std::str::from_utf8(&buf[..n])
.ok()
.and_then(|text| crate::pairing::discovery_device(text, &session_token))
else { continue };
if let Some(device) = device {
let _ = events.send(SenderEvent::ClientConnected { device });
}
let _ = socket.send_to(response.as_bytes(), peer); let _ = socket.send_to(response.as_bytes(), peer);
} }
Ok(_) => {}
Err(e) if matches!(e.kind(), std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut) => {} Err(e) if matches!(e.kind(), std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut) => {}
Err(_) => break, Err(_) => break,
} }
@@ -128,19 +135,57 @@ fn handle_client(
token: &str, token: &str,
events: &Sender<SenderEvent>, events: &Sender<SenderEvent>,
) -> Result<()> { ) -> Result<()> {
// The listener is non-blocking so its owner can poll for shutdown. On
// Windows an accepted socket can retain that mode, causing a large Range
// response to fail with WSAEWOULDBLOCK (10035) between write calls.
// Downloads must wait under the explicit read/write timeouts instead.
stream.set_nonblocking(false)?;
stream.set_nodelay(true).ok(); stream.set_nodelay(true).ok();
stream.set_read_timeout(Some(Duration::from_secs(20)))?; stream.set_read_timeout(Some(Duration::from_secs(20)))?;
stream.set_write_timeout(Some(Duration::from_secs(120)))?; stream.set_write_timeout(Some(Duration::from_secs(120)))?;
let cloned = stream.try_clone()?; let cloned = stream.try_clone()?;
let mut reader = BufReader::with_capacity(32 * 1024, cloned); let mut reader = BufReader::with_capacity(32 * 1024, cloned);
// 同一条连接上循环处理请求。此前每个响应都写死 Connection: close,
// 于是并行下载的每个分块都要新建一次 TCP —— 1 GB 是 64 次,
// 10 GB 是 640 次,既慢又是"短连接频繁断开"的直接来源。
loop {
match serve_one(stream, &mut reader, file_path, file_name, size, token, events)? {
KeepAlive::Continue => {}
KeepAlive::Close => return Ok(()),
}
}
}
/// 单个请求的处理结果:是否可以在同一条连接上继续。
enum KeepAlive {
Continue,
Close,
}
fn serve_one(
stream: &mut TcpStream,
reader: &mut BufReader<TcpStream>,
file_path: &PathBuf,
file_name: &str,
size: u64,
token: &str,
events: &Sender<SenderEvent>,
) -> Result<KeepAlive> {
let mut request_line = String::new(); let mut request_line = String::new();
reader.read_line(&mut request_line)?; // 读到 0 字节说明对端正常关闭了连接,这是 keep-alive 下的常态,不是错误
if reader.read_line(&mut request_line)? == 0 {
return Ok(KeepAlive::Close);
}
if request_line.trim().is_empty() {
return Ok(KeepAlive::Close);
}
if request_line.len() > 8192 { bail!("请求行过长") } if request_line.len() > 8192 { bail!("请求行过长") }
let mut headers = HashMap::<String, String>::new(); let mut headers = HashMap::<String, String>::new();
loop { loop {
let mut line = String::new(); let mut line = String::new();
let n = reader.read_line(&mut line)?; let n = reader.read_line(&mut line)?;
if n == 0 { bail!("连接在请求头前关闭") } if n == 0 { return Ok(KeepAlive::Close) }
if line == "\r\n" || line == "\n" { break } if line == "\r\n" || line == "\n" { break }
if line.len() > 16 * 1024 { bail!("请求头过长") } if line.len() > 16 * 1024 { bail!("请求头过长") }
if let Some((k, v)) = line.split_once(':') { if let Some((k, v)) = line.split_once(':') {
@@ -150,17 +195,29 @@ fn handle_client(
let mut parts = request_line.split_whitespace(); let mut parts = request_line.split_whitespace();
let method = parts.next().unwrap_or(""); let method = parts.next().unwrap_or("");
let path = parts.next().unwrap_or(""); let path = parts.next().unwrap_or("");
let version = parts.next().unwrap_or("HTTP/1.1");
// HTTP/1.1 默认复用;客户端显式要求 close 或用 1.0 时才断开
let keep_alive = version.eq_ignore_ascii_case("HTTP/1.1")
&& !headers
.get("connection")
.map(|v| v.eq_ignore_ascii_case("close"))
.unwrap_or(false);
let connection_header = if keep_alive { "keep-alive" } else { "close" };
if headers.get("x-qft-token").map(String::as_str).unwrap_or("") != token { if headers.get("x-qft-token").map(String::as_str).unwrap_or("") != token {
return write_response(stream, 403, "text/plain", b"invalid session"); write_response(stream, 403, "text/plain", b"invalid session")?;
return Ok(KeepAlive::Close);
} }
let device = decode_header(headers.get("x-qft-device")).unwrap_or_else(|| "Android".to_owned()); let device = decode_header(headers.get("x-qft-device")).unwrap_or_else(|| "Android".to_owned());
let _ = events.send(SenderEvent::ClientConnected { device: device.clone() }); let _ = events.send(SenderEvent::ClientConnected { device: device.clone() });
if method == "GET" && path == "/qft/ping" { if method == "GET" && path == "/qft/ping" {
let body = json!({"ok": true, "protocol": 2, "direction": "download"}).to_string(); let body = json!({"ok": true, "protocol": 2, "direction": "download"}).to_string();
return write_response(stream, 200, "application/json", body.as_bytes()); write_response(stream, 200, "application/json", body.as_bytes())?;
return Ok(if keep_alive { KeepAlive::Continue } else { KeepAlive::Close });
} }
if method != "GET" || path != "/qft/download" { if method != "GET" || path != "/qft/download" {
return write_response(stream, 404, "text/plain", b"not found"); write_response(stream, 404, "text/plain", b"not found")?;
return Ok(KeepAlive::Close);
} }
let mut input = File::open(file_path) let mut input = File::open(file_path)
@@ -175,12 +232,12 @@ fn handle_client(
let _ = events.send(SenderEvent::DownloadStarted { device: device.clone(), file_name: file_name.to_owned(), size }); let _ = events.send(SenderEvent::DownloadStarted { device: device.clone(), file_name: file_name.to_owned(), size });
if headers.get("range").is_none() { if headers.get("range").is_none() {
write!(stream, write!(stream,
"HTTP/1.1 200 OK\r\nContent-Type: application/octet-stream\r\nContent-Length: {remaining}\r\nAccept-Ranges: bytes\r\nConnection: close\r\nX-QFT-Filename: {}\r\n\r\n", "HTTP/1.1 200 OK\r\nContent-Type: application/octet-stream\r\nContent-Length: {remaining}\r\nAccept-Ranges: bytes\r\nConnection: {connection_header}\r\nX-QFT-Filename: {}\r\n\r\n",
URL_SAFE_NO_PAD.encode(file_name.as_bytes()), URL_SAFE_NO_PAD.encode(file_name.as_bytes()),
)?; )?;
} else { } else {
write!(stream, write!(stream,
"HTTP/1.1 206 Partial Content\r\nContent-Type: application/octet-stream\r\nContent-Length: {remaining}\r\nContent-Range: bytes {offset}-{end}/{}\r\nAccept-Ranges: bytes\r\nConnection: close\r\nX-QFT-Filename: {}\r\n\r\n", "HTTP/1.1 206 Partial Content\r\nContent-Type: application/octet-stream\r\nContent-Length: {remaining}\r\nContent-Range: bytes {offset}-{end}/{}\r\nAccept-Ranges: bytes\r\nConnection: {connection_header}\r\nX-QFT-Filename: {}\r\n\r\n",
size, size,
URL_SAFE_NO_PAD.encode(file_name.as_bytes()), URL_SAFE_NO_PAD.encode(file_name.as_bytes()),
)?; )?;
@@ -192,14 +249,13 @@ fn handle_client(
while left > 0 { while left > 0 {
let want = left.min(buf.len() as u64) as usize; let want = left.min(buf.len() as u64) as usize;
let n = input.read(&mut buf[..want])?; let n = input.read(&mut buf[..want])?;
if n == 0 { break } if n == 0 { bail!("发送文件读取提前结束:还缺 {left} 字节") }
stream.write_all(&buf[..n])?; stream.write_all(&buf[..n])?;
left -= n as u64; left -= n as u64;
} }
if left != 0 { bail!("发送文件读取提前结束:还缺 {left} 字节") }
stream.flush()?; stream.flush()?;
let _ = events.send(SenderEvent::DownloadCompleted { device, file_name: file_name.to_owned() }); let _ = events.send(SenderEvent::DownloadCompleted { device, file_name: file_name.to_owned() });
Ok(()) Ok(if keep_alive { KeepAlive::Continue } else { KeepAlive::Close })
} }
fn write_response(stream: &mut TcpStream, code: u16, content_type: &str, body: &[u8]) -> Result<()> { fn write_response(stream: &mut TcpStream, code: u16, content_type: &str, body: &[u8]) -> Result<()> {
@@ -249,6 +305,7 @@ mod tests {
net::{TcpListener, TcpStream}, net::{TcpListener, TcpStream},
sync::mpsc, sync::mpsc,
thread, thread,
time::Duration,
}; };
#[test] #[test]
@@ -284,18 +341,64 @@ mod tests {
assert_response(&resumed, "HTTP/1.1 206 Partial Content", "cdef"); assert_response(&resumed, "HTTP/1.1 206 Partial Content", "cdef");
let header = String::from_utf8_lossy(&resumed[..header_end(&resumed)]); let header = String::from_utf8_lossy(&resumed[..header_end(&resumed)]);
assert!(header.contains("Content-Range: bytes 2-5/6")); assert!(header.contains("Content-Range: bytes 2-5/6"));
let bounded = request(address, Some("bytes=1-3")); let bounded = request(address, Some("bytes=2-4"));
assert_response(&bounded, "HTTP/1.1 206 Partial Content", "bcd"); assert_response(&bounded, "HTTP/1.1 206 Partial Content", "cde");
let header = String::from_utf8_lossy(&bounded[..header_end(&bounded)]);
assert!(header.contains("Content-Range: bytes 2-4/6"));
server.join().unwrap(); server.join().unwrap();
fs::remove_file(path).unwrap(); fs::remove_file(path).unwrap();
} }
#[test]
fn large_download_waits_for_the_client_after_a_nonblocking_accept() {
let path = std::env::temp_dir().join(format!(
"qft-sender-{}-nonblocking.bin",
std::process::id(),
));
let payload = vec![0x5Au8; 2 * 1024 * 1024];
fs::write(&path, &payload).unwrap();
let file_size = payload.len() as u64;
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let address = listener.local_addr().unwrap();
let (events, _receiver) = mpsc::channel::<SenderEvent>();
let path_for_server = path.clone();
let server = thread::spawn(move || {
let (mut stream, _) = listener.accept().unwrap();
// Reproduce the Windows mode inheritance that caused Range
// writes to fail with WSAEWOULDBLOCK (10035).
stream.set_nonblocking(true).unwrap();
handle_client(
&mut stream,
&path_for_server,
"large.bin",
file_size,
"session",
&events,
)
});
let mut client = TcpStream::connect(address).unwrap();
client.write_all(
b"GET /qft/download HTTP/1.1\r\nHost: localhost\r\nX-QFT-Token: session\r\nConnection: close\r\n\r\n",
).unwrap();
client.flush().unwrap();
thread::sleep(Duration::from_millis(50));
let mut response = Vec::new();
client.read_to_end(&mut response).unwrap();
server.join().unwrap().unwrap();
let body_start = header_end(&response);
assert!(String::from_utf8_lossy(&response[..body_start]).starts_with("HTTP/1.1 200 OK"));
assert_eq!(&response[body_start..], payload.as_slice());
fs::remove_file(path).unwrap();
}
fn request(address: std::net::SocketAddr, range: Option<&str>) -> Vec<u8> { fn request(address: std::net::SocketAddr, range: Option<&str>) -> Vec<u8> {
let mut stream = TcpStream::connect(address).unwrap(); let mut stream = TcpStream::connect(address).unwrap();
write!( write!(
stream, stream,
"GET /qft/download HTTP/1.1\r\nHost: localhost\r\nX-QFT-Token: session\r\n{}\r\n", "GET /qft/download HTTP/1.1\r\nHost: localhost\r\nX-QFT-Token: session\r\nConnection: close\r\n{}\r\n",
range.map(|v| format!("Range: {v}\r\n")).unwrap_or_default(), range.map(|v| format!("Range: {v}\r\n")).unwrap_or_default(),
).unwrap(); ).unwrap();
stream.flush().unwrap(); stream.flush().unwrap();
@@ -314,3 +417,85 @@ mod tests {
bytes.windows(4).position(|v| v == b"\r\n\r\n").unwrap() + 4 bytes.windows(4).position(|v| v == b"\r\n\r\n").unwrap() + 4
} }
} }
#[cfg(test)]
mod keep_alive_tests {
use super::{handle_client, SenderEvent};
use std::{
fs,
io::{BufRead, BufReader, Read, Write},
net::{TcpListener, TcpStream},
sync::mpsc,
thread,
};
/// 在**同一条** TCP 上连发多个 Range 请求,全部必须成功。
///
/// 此前每个响应都写死 Connection: close,并行下载的每个分块都要
/// 重建一次 TCP —— 1 GB 64 次、10 GB 640 次,既是"短连接频繁断开"
/// 的来源,也白白付出握手与慢启动的代价。
#[test]
fn serves_multiple_ranges_on_one_connection() {
let path = std::env::temp_dir().join(format!("qft-keepalive-{}.bin", std::process::id()));
let payload: Vec<u8> = (0..4096u32).map(|i| (i % 251) as u8).collect();
fs::write(&path, &payload).unwrap();
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let address = listener.local_addr().unwrap();
let (events, _rx) = mpsc::channel::<SenderEvent>();
let served = path.clone();
let server = thread::spawn(move || {
let (mut stream, _) = listener.accept().unwrap();
handle_client(&mut stream, &served, "p.bin", payload.len() as u64, "tok", &events)
});
let mut stream = TcpStream::connect(address).unwrap();
let mut reader = BufReader::new(stream.try_clone().unwrap());
// 三段互不重叠的 Range,全部走同一条连接
for (start, end) in [(0u64, 1023u64), (1024, 2047), (2048, 4095)] {
write!(
stream,
"GET /qft/download HTTP/1.1\r\nHost: x\r\nX-QFT-Token: tok\r\nRange: bytes={start}-{end}\r\n\r\n"
).unwrap();
stream.flush().unwrap();
let mut status = String::new();
reader.read_line(&mut status).unwrap();
assert!(status.starts_with("HTTP/1.1 206"), "第 {start} 段状态行:{status}");
let mut length = 0usize;
let mut keep_alive = false;
loop {
let mut line = String::new();
reader.read_line(&mut line).unwrap();
if line == "\r\n" { break }
if let Some((name, value)) = line.split_once(':') {
match name.trim().to_ascii_lowercase().as_str() {
"content-length" => length = value.trim().parse().unwrap(),
"connection" => keep_alive = value.trim().eq_ignore_ascii_case("keep-alive"),
_ => {}
}
}
}
assert!(keep_alive, "响应必须声明 keep-alive,否则客户端会关掉连接");
assert_eq!(length as u64, end - start + 1, "Content-Length 应等于该段长度");
let mut body = vec![0u8; length];
reader.read_exact(&mut body).unwrap();
let expected: Vec<u8> = (start..=end).map(|i| ((i as u32) % 251) as u8).collect();
assert_eq!(body, expected, "第 {start} 段内容不符");
}
// 显式要求关闭时应断开,服务端随之正常收尾
write!(stream, "GET /qft/ping HTTP/1.1\r\nHost: x\r\nX-QFT-Token: tok\r\nConnection: close\r\n\r\n").unwrap();
stream.flush().unwrap();
let mut rest = Vec::new();
reader.read_to_end(&mut rest).unwrap();
let text = String::from_utf8_lossy(&rest);
assert!(text.contains("Connection: close"), "显式 close 时应回 close:{text}");
server.join().unwrap().unwrap();
fs::remove_file(path).unwrap();
}
}
+45
View File
@@ -0,0 +1,45 @@
# Android → Android 真机验收(v0.5.0-dev5)
## 构建约束
在 Windows 的 Android 开发环境构建。本仓库的 macOS 封版流程不会安装或调用 Android SDK。
```powershell
cd android
.\gradlew.bat :app:testDebugUnitTest :app:assembleDebug
```
## 首轮验收
1. 两台 Android 安装同一个 `v0.5.0-dev5` APK。
2. 发送手机进入“手机 → 手机”,选择至少两个文件并调整一次顺序。
3. 点击“创建发送二维码”,允许附近 Wi-Fi/位置权限。
4. 接收手机进入“扫码直传”,扫描发送手机二维码并确认系统连接提示。
5. 核对接收顺序与发送队列一致,文件位于 `Downloads/QFT`,大小与 SHA-256 一致。
建议首轮文件组合:空文件、100 KiB 文档、20 MiB 视频、100 MiB 压缩包。
## 必测网络组合
- Android 13+ → Android 13+:`NEARBY_WIFI_DEVICES` 权限;专用网络先用自动频段,支持时应协商到 5 GHz,不得固定在 2.4 GHz。
- Android 13+ 发送 → Android 7–9 接收:旧机扫码后持续搜索同一个 `DIRECT-*`;发送端 12 秒未收到认证请求时,以相同 SSID/密码切换到 2.4 GHz,旧机无需重新扫码即可连接。
- Android 13+ 发送 → Android 10–12 接收:新会话即使复用了热点名称,只要密码变化就必须创建新的系统配网请求。
- Wi-Fi Direct 被 OEM 禁用:发送端自动回落 LocalOnlyHotspot;纯 WPA3 且接收机不支持 SAE 时自动尝试原局域网,不应无限搜索。
- Android 7–9 发送 → Android 13+ 接收:至少传输一个 100 MiB 文件两次,均通过 SHA-256,不得再出现整文件重下后仍校验失败。
- Android 10+ 高速链路:接收端在 12 秒内完成认证后,发送端不得切换频段或中断现有 5 GHz 连接。
- Android 7 发送端:验证系统生成的 `DIRECT-*` WPA2 组可被高版本接收端自动加入;P2P 创建失败时再验证同局域网回落。
- 手动停止发送端热点:接收端应报连接中断,而不是无限等待。
- 传输中返回发送端首页:服务和临时热点应立即关闭。
## 二维码布局组合
- 普通手机:二维码、状态、网络信息和停止按钮应在首屏完整显示。
- 10–14 英寸平板:二维码按窗口宽高取较小限制,不应拉伸到全宽后挤出下方按钮。
- 分屏/小窗:重新进入发送二维码页后,应按当前应用窗口而非物理屏幕分辨率计算尺寸。
## 当前边界
- 仅文件,不包含文件夹。
- 发送与接收页面需保持前台;尚未引入前台服务。
- Wi-Fi Direct/LocalOnlyHotspot 没有互联网是预期行为,文件只在本地链路传输。
- Android ↔ iOS 不在本开发版本范围内。
+1 -1
View File
@@ -428,6 +428,6 @@ App 应根据实测能力自动选档,并在 UI 明示当前档位与预计耗
| 兼容 | 720p | 4.0 | 30 | 128 KB/s | 最低保障 | | 兼容 | 720p | 4.0 | 30 | 128 KB/s | 最低保障 |
### 何时不该用光学 ### 何时不该用光学
仓库已有 `QFTSEND2` 扫码直传(`windows/src/sender.rs`:HTTP + Range 续传 + UDP 发现), 仓库已有 `QFTSEND2` 扫码直传(`desktop/src/sender.rs`:HTTP + Range 续传 + UDP 发现),
10 MB 在局域网下是亚秒级。光学链路应明确定位为**物理隔离场景专用**, 10 MB 在局域网下是亚秒级。光学链路应明确定位为**物理隔离场景专用**,
并在选择大文件时主动提示直传方案与两者的预计耗时对比。 并在选择大文件时主动提示直传方案与两者的预计耗时对比。
+38 -11
View File
@@ -1,4 +1,4 @@
# QFT protocol notes — v0.4.6 # QFT protocol notes — v0.4.7
## 1. Windows → Android optical: QFT2 ## 1. Windows → Android optical: QFT2
@@ -36,7 +36,7 @@ senderLen 2 u16 BE
senderDevice N UTF-8 senderDevice N UTF-8
``` ```
### Optical parameters in v0.4.6 ### Optical parameters in v0.4.7
- one QR per display frame; - one QR per display frame;
- DATA payload: **450 B**; - DATA payload: **450 B**;
@@ -75,7 +75,7 @@ The overlay is derived from the same ROI used by the decoder, so the green/yello
Discovery order includes QR hint, UDP `QFTDISC2`, gateway/direct candidates and bounded current-subnet fallback. Discovery order includes QR hint, UDP `QFTDISC2`, gateway/direct candidates and bounded current-subnet fallback.
## 4. Android → Windows upload ## 4. 扫码本地直传(Android ↔ Windows)
Parallel v2 flow: Parallel v2 flow:
@@ -85,19 +85,46 @@ POST /qft/upload/chunk (parallel, offset based)
POST /qft/upload/finish POST /qft/upload/finish
``` ```
Windows preallocates a `.qftpart`, writes chunks at explicit offsets, verifies SHA-256, then renames to the final file. Per-file worker count is capped at 8; chunk size is selected from 4/8/16 MiB by file size. Windows preallocates a `.qftpart`, writes chunks at explicit offsets, verifies SHA-256, then renames to the final file. Uploads target 8 workers per file (bounded by the usable chunks and device capacity); the requested chunk size is derived from the file size and clamped to **64 KiB–16 MiB**. Repeated `init` requests carrying the same `X-QFT-Upload-Key` resume the matching active upload session; repeated chunk and finish requests are idempotent so a lost response can be retried safely. Chunk completion is recorded only after the positioned write reaches stable storage.
Repeated `init` requests carrying the same `X-QFT-Upload-Key` resume the matching active upload session. The response may include a `missing` chunk-index array; the client sends only those chunks. Chunk completion is recorded only after the positioned write reaches stable storage. ## 5. Windows → Android download
## 5. Windows → Android direct download The same QFTPAIR2 local session can declare the download direction. Android discovers and verifies the Windows sender, then downloads `GET /qft/download` with exact single-range requests:
Files of at least 32 MiB use up to 8 parallel bounded range requests:
```text ```text
GET /qft/download
Range: bytes=<start>-<end> Range: bytes=<start>-<end>
``` ```
Android preallocates an app-private `.qftpart`, writes each range at its fixed offset and persists a separate completion bitmap. A reconnect or process restart downloads only missing ranges. After every range is present, Android verifies the QR-carried SHA-256 before publishing the file to `Downloads/QFT`. The sender returns `206 Partial Content`, the matching `Content-Range`, and the exact requested body length. Android splits the file toward 8 workers with **64 KiB–16 MiB** chunks, stores each completed chunk in a `.qftpart.map` ledger, and resumes only missing chunks after a reconnect. Each range retries with the currently available `Network`; the complete partial file must pass SHA-256 before it is published to `Downloads/QFT`.
The Android `WifiNetworkSpecifier` request remains registered for the entire transfer page. It is released when the user returns to the home page (or the Activity is destroyed); a replacement `Network` delivered after a brief radio loss is adopted by subsequent chunk/range retries. For both direct-transfer directions, the Windows listener may accept connections non-blockingly for shutdown responsiveness, but each accepted file socket is switched to blocking I/O with explicit timeouts before reading or writing request bodies. This prevents `WSAEWOULDBLOCK (10035)` from turning an in-progress parallel transfer into an HTTP 500 failure.
## 6. Android → Android (`QFTPHONE2`, v0.5.0-dev5)
The sender starts an authenticated local HTTP service and encodes only session,
port, sender identity and optional dedicated-network credentials in the QR. The
file queue is fetched after pairing so QR density is independent of queue size:
```text
GET /qft/ping
GET /qft/phone/manifest
GET /qft/phone/download/<queue-index>
Range: bytes=<start>-<end>
X-QFT-Token: <one-time session>
```
The manifest contains a bounded ordered list of `name`, `size`, `sha256` and a
server-generated fixed download path. The receiver does not accept arbitrary
paths from the QR or manifest: entry `N` must use `/qft/phone/download/N`.
Android 10+ first creates a WPA2 Wi-Fi Direct group-owner AP with automatic band
selection, normally allowing a 5 GHz link. If no authenticated peer arrives in
12 seconds, the sender recreates the group on 2.4 GHz with the exact same SSID
and passphrase, so an older receiver's pending scan continues without a new QR.
An OEM P2P failure falls back to LocalOnlyHotspot, then literal private IPv4
endpoints on the current LAN. WPA2/WPA3
credentials are distinguished in `w[2]`. The receiver reuses the existing Range
ledger, retries and SHA-256-before-publish behavior for every file, processing
items in manifest order. Phone senders use one deterministic Range worker to
avoid concurrent-read corruption in older Android document providers; desktop
senders retain up to eight workers.
+219
View File
@@ -0,0 +1,219 @@
# QFT v0.5 执行计划
配套设计文档:[V05_MULTIPEER_PLAN.md](V05_MULTIPEER_PLAN.md)
---
## 0. 三个默认决策(未经确认,可推翻)
设计文档结尾留了三个待定问题,为了让计划能往下排,先按以下默认执行。任一项改变都会影响排期,改之前先说。
| 问题 | 默认决策 | 理由 |
|---|---|---|
| M1 先做还是直接上 v3? | **M1 先做** | 零协议风险,做完立刻拿到真实 PC↔PC 体验;v3 的很多设计细节需要真实使用反馈才定得准 |
| 加密在哪一版做? | **放到 v3(P2),M1 维持现状明文** | TLS 与新协议一起做只需改一次握手层;分两次做要动两遍,且 M1 的目的是尽快验证对称节点模型 |
| 共享核心怎么做? | **桌面共享 Rust + 移动端原生 + `conformance/` 一致性套件** | 桌面三平台本来就是同一份代码(实测仅 3 处平台耦合),共享零成本;移动端 FFI 要等 v3 定型才划算 |
---
## 1. 总体流程
```mermaid
flowchart TD
P0["P0 收尾验证<br/>把半成品编译掉"] --> P1["P1 桌面跨平台 + PC↔PC<br/>走现有 v2 协议"]
P1 --> P2["P2 QFT-Stream v3<br/>目录直传 + 加密"]
P2 --> P3["P3 移动端接入 v3"]
P3 --> P4["P4 手机 ↔ 手机"]
P2 -.并行.-> P5["P5 一致性套件<br/>+ 性能回归"]
P0 -.独立并行轨.-> OPT["QFT5 光学<br/>阻塞于楔形标定"]
style P0 fill:#7a2020,color:#fff
style OPT fill:#5a4a20,color:#fff
```
**P0 是硬阻塞。** 当前有三处「写了但没验证」的代码,在其之上继续叠加会让问题定位成本指数上升。
---
## 2. P0 · 收尾验证(阻塞,必须先做)
| # | 任务 | 涉及 | 验收标准 | 谁做 |
|---|---|---|---|---|
| P0.1 | Android bug 修复编译 | `DownloadClient.kt` `WifiConnector.kt` `MainActivity.kt` | `./gradlew :app:assembleDebug` 通过 | **你**(我没有 Android SDK) |
| P0.2 | Android bug 修复实测 | — | 大文件传输走完全程;断网时 3 秒内报「临时网络已断开」而非等满重试;空间不足在开始前就提示 | **你**(需真机 + Windows 主机) |
| P0.3 | iOS 模拟器编译 | `ios/QFT/App/*.swift` | Xcode 选 iPhone 模拟器,⌘B 无红色错误 | **你** |
| P0.4 | `xcode-select` 指向 Xcode | — | `xcodebuild -version` 可用 | **你**(需 sudo) |
| P0.5 | 修掉 P0.1/P0.3 暴露的编译错误 | 视情况 | 同上重跑通过 | 我 |
| P0.6 | 提交并推送 | — | 工作区干净 | 我 |
**门禁:P0.1 与 P0.3 全绿才进入 P1。**
P0.4 做完之后我可以直接在命令行编译 iOS 工程,后续 Swift 改动就不再是盲写——这一项虽然可选,但会显著提升后面所有 iOS 相关工作的质量。
---
## 3. P1 · 桌面跨平台 + PC↔PC
目标:**mac ↔ win、linux ↔ win 能互传单个文件**,仍走现有 v2 HTTP 协议。
| # | 任务 | 涉及 | 规模 | 验收标准 |
|---|---|---|---|---|
| P1.1 | `windows/` → `desktop/`,crate 更名 `qft-desktop` | 目录 + `Cargo.toml` + CI 脚本 + `VERIFY_WINDOWS_HOST.ps1` | S | `cargo check` 在 macOS 上通过 |
| P1.2 | 平台抽象层 `platform.rs` | 新增;改 `direct_ap.rs` `pairing.rs:148` `protocol.rs:194` | M | 三平台各自 `cargo test` 通过 |
| P1.3 | 配置/下载目录跨平台 | `pairing.rs` + 新增 | S | mac 写到 `~/Library/Application Support/QFT`,linux 写到 `$XDG_CONFIG_HOME/qft` |
| P1.4 | **桌面客户端** `client.rs` | 新增(当前完全缺失) | L | 单元测试:对本进程起的 receiver 完成一次上传 + 一次下载 |
| P1.5 | mDNS 发现 `discovery.rs` | 新增,`mdns-sd` crate | M | 两台机器互相出现在列表里;TXT 含 `v/id/name/platform/port` |
| P1.6 | 6 位配对码 | `pairing.rs` | M | 跨网段场景下输码可连;错码 3 次锁定 |
| P1.7 | UI:「附近的设备」页 + 拖拽发送 | `main.rs` | L | 拖文件到窗口即发送 |
| P1.8 | macOS / Linux 打包 | 新增 CI | M | 产出 `.app`(未签名)与 AppImage/tar.gz |
### P1 验收门
```
✅ mac → win 传 1GB 单文件,SHA-256 一致
✅ win → mac 同上
✅ linux → win 同上
✅ 三平台各自能在「附近的设备」里看到另外两台
✅ 拔网线重插后能续传(v2 的 Range 续传)
```
**这一门通过之前不进 P2。** 因为 v3 的价值全部建立在「对称节点模型成立」之上,先用最简单的协议把这个模型验证掉。
---
## 4. P2 · QFT-Stream v3
目标:**目录直传可用**,先只在两台 PC 之间。
| # | 任务 | 规模 | 验收标准 |
|---|---|---|---|
| P2.1 | 帧编解码 + 黄金测试向量 | M | 向量文件 `conformance/frames.json`,编解码往返一致 |
| P2.2 | Ed25519 身份 + 信任库 | M | 首次运行生成密钥;重启后身份不变 |
| P2.3 | TLS 1.3(`rustls`)+ 按公钥验证对端 | L | 错误公钥必须握手失败;6 位校验码两端一致 |
| P2.4 | 会话层:`SESSION_OPEN` / `INDEX_*` / `HAVE` | L | 断开重连后不重传已完成文件 |
| P2.5 | **流式并行索引** | M | 10 万文件树:首字节传输在遍历完成前就开始 |
| P2.6 | **小文件合批** | L | 见下方性能门 |
| P2.7 | 大文件分块并发 + 流控反压 | M | 接收端磁盘限速时内存不超过 `连接数 × 8MiB` |
| P2.8 | 路径安全层 | M | 见下方安全门 |
| P2.9 | 每文件 SHA-256 + 单遍哈希 | S | 单个坏文件只重传自己 |
### P2 性能门(在千兆有线上实测)
| 场景 | 目标 | 现状对照 |
|---|---|---|
| 5 万小文件 / 0.95 GB | **< 15 s** | v2 约 608 s |
| 3 千文件 / 11.7 GB | < 120 s | v2 约 138 s |
| 单文件 10 GB | < 95 s | v2 约 87 s(不得退化) |
| 峰值内存 | < 200 MB | — |
### P2 安全门(跨系统路径用例,全部必须通过)
```
linux → win : 目录含 CON.txt / aux.log / "a<b>.txt" / 结尾带空格的名字
linux → win : 同目录下 README.md 与 readme.md(大小写冲突)
linux → mac : 文件名含 "é"(NFC/NFD 归一化)
任意 → 任意 : 路径含 ../、绝对路径、指向根目录外的符号链接 → 整会话拒绝
win → 任意 : 路径长度超过 260
```
每条都要有自动化用例,不能靠手测。
---
## 5. P3 · 移动端接入 v3
| # | 任务 | 端 | 规模 |
|---|---|---|---|
| P3.1 | Android `NodeServer.kt`(ServerSocket + v3 帧) | Android | L |
| P3.2 | Android `NsdManager` 发现 | Android | M |
| P3.3 | Android 前台服务 + WakeLock | Android | M |
| P3.4 | Android 目录接收(SAF `OPEN_DOCUMENT_TREE`) | Android | M |
| P3.5 | iOS `PeerLink` 并入 v3 帧格式 | iOS | M |
| P3.6 | iOS 目录接收 + 「文件」App 导出 | iOS | M |
**门禁:手机 ↔ 电脑走 v3 传一个 5000 文件的目录成功。**
P3.3 是现有隐患的正式修复——当前只有 `FLAG_KEEP_SCREEN_ON`,息屏或切后台就有被系统掐断的风险。
---
## 6. P4 · 手机 ↔ 手机
| 组合 | 任务 | 备注 |
|---|---|---|
| iOS ↔ iOS | 已实现,接 v3 即可 | `PeerLink.swift` 复用 |
| Android ↔ Android | `WifiP2pManager` 或 Local Only Hotspot,回落同 LAN | 新增 |
| Android ↔ iOS | **仅同一局域网** | UI 必须明确提示,不给假希望 |
**门禁:三种组合各传一个含子目录的相册目录成功。**
---
## 7. P5 · 一致性套件(与 P2 并行)
把 `ios/CoreTests/MockPCServer.py` 的做法推广成 `conformance/`:
```
conformance/
vectors/ 黄金测试向量(帧编解码、路径规范化、合批边界)
reference_peer.py 参考对端,任一端实现都能对着它跑
run.sh 三端各自跑一遍
```
接入 `scripts/run_all_selftests.py`。**这是目前防三端协议漂移最有效的手段**,在 iOS 端已验证有效。
---
## 8. 验证责任分工
这个项目的返工大多来自「写完没法验证」。明确分工:
| 我能在这台 Mac 上做 | 只有你能做 |
|---|---|
| Rust `cargo check/test`(装了 Rust 之后) | Windows 上的 `cargo build --release` 与真机跑 |
| Swift 核心层编译 + 单测 | iOS 真机(相机、AWDL) |
| Swift 全量编译(**需你先做 P0.4**) | Android 编译与真机 |
| Python 工具与一致性套件 | 千兆有线上的性能实测 |
| 协议设计、黄金向量、代码审查 | 楔形标定拍照 |
**Kotlin 目前我完全无法编译**(本机无 Android SDK,装 kotlinc 会连带拉一个多余的 JDK)。所以 Android 侧改动我会尽量小步、单文件,每次都请你编译一次再继续——不要攒一大批。
---
## 9. 并行轨:QFT5 光学
与 v0.5 无依赖关系,可随时插入。当前**阻塞于楔形标定**:
```
你拍标定图 → 跑 wedge_analyze.py → 得到实测 px/模块
↓
≤3.2 → 按 OPTICAL_V5_PLAN 原样实施
3.2~4.0 → 目标 B 不可达,需下调指标
>4.0 → 先排查对焦/曝光,不要动协议
```
标定之前可以做的(不依赖该数值):相机帧率三级锁定、手动短曝光、关 EIS/抗闪烁、锁对焦、陀螺仪前馈。这几项**对现有 QFT2 链路也立刻有收益**(3px/模块下 33ms 自动曝光会产生 8.7px 运动模糊,等于抹掉近 3 个模块)。
---
## 10. 回滚点与风险
| 阶段 | 回滚点 | 触发条件 |
|---|---|---|
| P1 | 保留 `windows/` 分支 tag | 跨平台抽象破坏了 Windows 行为 |
| P2 | v2 与 v3 并存,节点协商版本 | v3 性能门不达标 |
| P3 | 移动端可继续用 v2 | v3 在移动端内存/耗电不可接受 |
**每个阶段结束打一个 tag**,v3 与 v2 全程并存,任一阶段失败都不影响已发布版本可用。
---
## 11. 下一步
按顺序,现在只需要做三件事:
1. `cd android && ./gradlew :app:assembleDebug` —— 把 bug 修复编译掉,报错发我
2. Xcode 选模拟器 ⌘B —— iOS UI 层编译掉,报错发我
3. (可选但强烈建议)`sudo xcode-select -s /Applications/Xcode.app/Contents/Developer`
这三件完成后我开始 P1.1。
+297
View File
@@ -0,0 +1,297 @@
# QFT v0.5 增量设计:全平台对等互传
基线 v0.4.7。三项增量需求:
1. 电脑 ↔ 电脑互传,跨平台(mac ↔ win ↔ mac,linux ↔ win ↔ mac)
2. 手机 ↔ 手机互传
3. 全量高速传输,支持目录直传,高速索引 + 稳定连接
---
## 0. 现状盘点(实测,非推测)
| 项 | 现状 | 影响 |
|---|---|---|
| 桌面端角色 | **只有服务端**。`TcpStream::connect` 仅出现在 `#[cfg(test)]` 里 | PC 无法主动连接对方 → PC↔PC 完全不可用 |
| HTTP 连接 | 每个响应都写 `Connection: close`(`sender.rs:183/188/211`、`receiver.rs:531`) | 每个分块新建一次 TCP |
| 上传会话 | `UploadSession { file_name, size, chunk_size, total_chunks }` —— **单文件** | 无目录概念 |
| Windows 耦合 | 仅 3 处:`direct_ap.rs`(已 cfg 隔离)、`pairing.rs:148` 的 `LOCALAPPDATA`、`protocol.rs:194` 的 `COMPUTERNAME`。`read_at_once` 已有 unix 分支 | **跨平台成本比预期低得多** |
| 传输加密 | 无,局域网明文 HTTP | 同网段任何人可读文件内容 |
| 协议实现 | Rust 2845 行 / Kotlin 4423 行 / Swift 2053 行,同一协议三份实现 | 每加一个特性要写三遍 |
### 目录传输在现有协议下的实际代价
每个文件需要 init + chunk + finish 三次 HTTP,且每次都新建 TCP(局域网 RTT 按 2ms 计):
| 场景 | 文件数 | 总量 | 纯握手 | 数据传输(1GbE) | 合计 |
|---|---|---|---|---|---|
| 代码仓库 `node_modules` | 50 000 | 0.95 GB | **600 s** | 8 s | **608 s** |
| 照片目录 | 3 000 | 11.7 GB | 36 s | 102 s | 138 s |
| 单个大文件 | 1 | 10 GB | 0 s | 87 s | 87 s |
**小文件场景 98% 的时间花在握手上。** 这是本次设计的首要矛盾,不是带宽问题。
---
## 1. 核心设计决策:从「角色固定」到「对称节点」
现有架构把角色写死了:PC 是服务端,手机是客户端。三项需求全都被这个假设挡住。
v0.5 引入 **QFT Node** 模型——每个安装都同时具备:
```
┌─────────────────── QFT Node ───────────────────┐
│ 身份 Ed25519 密钥对(首次运行生成,持久化) │
│ 广播端 mDNS _qft._tcp + UDP 兜底 │
│ 服务端 QFT-Stream v3 监听器(接受传入会话) │
│ 客户端 QFT-Stream v3 发起器(主动连接对方) │← 桌面端当前缺失
│ 信任库 已确认过的对端公钥 │
└────────────────────────────────────────────────┘
```
一旦对称,三项需求退化成同一件事:**任意两个节点之间建立一条 v3 会话**。PC↔PC、手机↔手机、PC↔手机走完全相同的代码路径,差别只在链路选择。
---
## 2. 需求一:跨平台桌面端
### 2.1 目录改名与平台抽象
`windows/` → `desktop/`(crate 名 `qft-desktop`)。eframe/egui、rfd、rayon 本来就跨平台,实际要动的只有三处:
| 文件 | 现状 | 改法 |
|---|---|---|
| `direct_ap.rs` | Windows WiFi Direct,非 Windows 直接 `bail!` | 抽成 `trait LinkProvider`,mac/linux 返回 `Unsupported`,UI 隐藏该入口 |
| `pairing.rs:148` | `LOCALAPPDATA` | `directories` crate:win=`%LOCALAPPDATA%`,mac=`~/Library/Application Support`,linux=`$XDG_CONFIG_HOME` |
| `protocol.rs:194` | `COMPUTERNAME`/`HOSTNAME` | `hostname` crate + 各平台友好名(mac 读 `ComputerName`) |
另需新增:默认保存目录(win=`Downloads`,mac=`~/Downloads`,linux=`XDG_DOWNLOAD_DIR`)、单实例锁、开机自启(可选)。
**估算:这部分是整个方案里性价比最高的**——三个文件加一层 trait,就拿到 macOS 与 Linux。
### 2.2 桌面客户端(当前完全缺失)
新增 `desktop/src/client.rs`,实现 Node 的发起侧。UI 上新增「附近的设备」页:
```
┌─ 附近的设备 ────────────────────────────┐
│ 🖥 MacBook-Pro macOS 26 ● 已信任 │
│ 💻 DESKTOP-M7DEVQO Windows 11 ○ 未信任 │
│ 📱 iPhone 17 Pro iOS 26 ● 已信任 │
│ 🖥 ubuntu-dev Linux ○ 未信任 │
├────────────────────────────────────────┤
│ [ 拖拽文件/文件夹到此处发送 ] │
└────────────────────────────────────────┘
```
拖拽是桌面端的核心交互——这也是目录直传最自然的入口。
### 2.3 两台 PC 怎么互相发现(没有摄像头,扫不了码)
| 手段 | 适用 | 说明 |
|---|---|---|
| **mDNS / DNS-SD**(主) | 同一局域网 | 服务类型 `_qft._tcp`,TXT 携带 `v/id/name/platform/port/fp`。三平台都有成熟实现:桌面 `mdns-sd` crate、Android `NsdManager`、iOS `NWBrowser`(P2P 已在用) |
| UDP 广播(兜底) | mDNS 被交换机/防火墙拦时 | 沿用现有 `QFTDISC2`,升级到 v3 |
| **6 位配对码**(跨网段/兜底) | 不同子网、AP 隔离 | 接收方显示 6 位数字,发送方手输 |
| 手动 IP | 极端情况 | 直接输 `192.168.1.20:39393` |
QR 在 PC↔PC 场景不适用(对方没摄像头),所以 **6 位配对码是 PC↔PC 的必需品**,不是可选项。
---
## 3. 需求二:手机 ↔ 手机
| 组合 | 链路 | 状态 |
|---|---|---|
| iOS ↔ iOS | AWDL 点对点(`includePeerToPeer`)+ TLS-PSK | **已实现**(`PeerLink.swift`),并入 v3 即可 |
| Android ↔ Android | Wi-Fi Direct(`WifiP2pManager`)或 Local Only Hotspot,回落同 LAN | 需新增:Android 端 v3 服务端 |
| **Android ↔ iOS** | **只能同一局域网** | 见下 |
### 关于 Android ↔ iOS 必须说清楚的限制
无路由器直连做不到,原因是两边的点对点链路互不兼容:
- **AWDL** 是苹果私有链路,Android 无法参与
- **Wi-Fi Direct** 走 P2P GO 协商,iOS 完全不支持
- **iOS 无法用代码加入指定 Wi-Fi**(`NEHotspotConfiguration` 需付费账号 entitlement),所以「Android 开热点 + iOS 自动加入」这条路走不通;用户手动去设置里连是可行的,但体验很差
- 反方向「iOS 开个人热点 + Android 自动加入」:Android 侧可以用 `WifiNetworkSpecifier` 自动加入,但 iOS 个人热点无法由 App 开启,且多数运营商要求蜂窝套餐
**结论:Android ↔ iOS 要求两台手机连同一个 Wi-Fi。** UI 上必须直说,不能让用户在没有路由器的场合反复重试。
### Android 端要补的东西
当前 Android 只有客户端。需新增:
- `NodeServer.kt`:`ServerSocket` + v3 帧协议(不引入 HTTP 服务器依赖)
- `NsdHelper.kt`:`NsdManager` 注册与发现
- 前台服务 + `WakeLock`:长传输不被 Doze 掐断(现在只有 `FLAG_KEEP_SCREEN_ON`,息屏就危险)
- 接收侧文件写入走 MediaStore / SAF 目录树(目录传输需要 `ACTION_OPEN_DOCUMENT_TREE`)
---
## 4. 需求三:QFT-Stream v3 —— 目录直传 + 高速索引 + 稳定连接
### 4.1 为什么必须换掉 HTTP
不是 HTTP 不好,是它的请求/响应模型表达不了这几件事:
1. **接收方主动告知「我已经有哪些」**(断点续传的前提)——HTTP 里只能靠客户端逐个 HEAD 探测
2. **一个连接上并发多个文件**——HTTP/1.1 无多路复用,HTTP/2 会引入大依赖
3. **边走目录边传**——索引和传输必须重叠,否则大目录要先干等几十秒
### 4.2 帧格式
TLS 1.3 over TCP,每会话开 N 条连接(默认 4,可调 1~8)。
```
u8 类型 | u32 长度(BE) | payload
```
| 类型 | 方向 | 说明 |
|---|---|---|
| `HELLO` / `HELLO_ACK` | 双向 | 版本、node id、能力位 |
| `SESSION_OPEN` | 发→收 | session_id、根目录名、预估总量 |
| `INDEX_ENTRY` | 发→收 | **流式**:path / size / mtime / mode,边走目录边发 |
| `INDEX_END` | 发→收 | 总文件数、总字节数(此时才知道准确进度) |
| `HAVE` | 收→发 | 已有文件与偏移(断点续传) |
| `FILE_OPEN` / `FILE_DATA` / `FILE_END` | 发→收 | 大文件流式,`FILE_END` 带该文件 SHA-256 |
| `BATCH` | 发→收 | **小文件合批**,一帧塞多个完整小文件 |
| `ACK` | 收→发 | 字节水位,用于流控 |
| `PING` / `PONG` | 双向 | 心跳 |
| `ERROR` / `ABORT` | 双向 | |
### 4.3 高速索引:流式 + 重叠
不等目录走完就开始传。索引线程用 rayon 并行遍历目录,每发现一个文件就发一条 `INDEX_ENTRY`,同时数据通道已经在传前面发现的文件。
10 万文件的树,遍历本身 SSD 上要 2~5 秒(Windows `FindFirstFile` 更慢,机械盘或网络盘可能几十秒)。重叠之后这段时间完全被隐藏。
代价:`INDEX_END` 之前进度条只能显示「已发现 N 个 / 已传 M 个」,拿不到百分比。这是正确的取舍——先动起来比先算准重要。
### 4.4 小文件合批:本方案最大的性能杠杆
阈值:**< 1 MiB 合批,≥ 1 MiB 走 `FILE_*` 流式 + 分块并发**。
小文件打进 4 MiB 的 `BATCH` 帧,一帧内多个完整文件,接收端顺序落盘。回到开头那张表:
| 场景 | v2 | v3 | 提升 |
|---|---|---|---|
| 5 万小文件 0.95 GB | 608 s | **≈ 8 s** | **76×** |
| 3 千张照片 11.7 GB | 138 s | **≈ 102 s** | 1.35×(已接近线速) |
大文件场景本来就接近线速,提升有限;**小文件场景是数量级的差异**。
接收端配套优化:批量创建文件时避免每个文件一次 `fsync`,改为批末统一 flush;Windows 上关闭 Defender 实时扫描对目标目录的影响无法控制,但可以提示用户。
### 4.5 稳定连接
- **心跳**:每 5 s `PING`,20 s 无 `PONG` 判定断链
- **自动重连**:`session_id` 存活 10 分钟。重连后发 `HAVE`,从字节粒度续传,不重传已完成的文件
- **流控**:接收方按 `ACK` 水位反压,磁盘慢时不会把内存撑爆(现在 Android 侧 `worker × chunk` 就是内存峰值,没有反压)
- **每文件独立校验**:`FILE_END` 带 SHA-256,坏文件只重传自己,不会让一个 100 GB 的会话整体作废(现在是整份下完再校验,失败就全丢)
- **单遍哈希**:边读边算,不再像现在 Android 那样下载完再整份读一遍算 SHA-256
### 4.6 跨平台路径安全(容易被忽略但必须做)
目录传输一旦跨系统,这些全是真会踩的坑:
| 问题 | 处理 |
|---|---|
| `..`、绝对路径、空段、NUL | 一律拒绝,整会话中止 |
| Windows 保留名 `CON/PRN/AUX/NUL/COM1-9/LPT1-9` | 自动加后缀重命名,并在报告里列出 |
| Windows 非法字符 `<>:"\|?*`、结尾的点或空格 | 同上 |
| `MAX_PATH` 260 | Windows 侧统一走 `\\?\` 长路径前缀 |
| **macOS 的 NFD 归一化** | Linux 传 NFC 的「é」,macOS 存成 NFD,回传时路径对不上 → 协议层统一用 NFC,本地存储时记录原始字节 |
| **大小写冲突** | Linux 目录里的 `README.md` 与 `readme.md` 传到 Windows/macOS 会撞 → 检测并加后缀,报告给用户 |
| 符号链接 | 默认不跟随;指向根目录内则作为链接条目传输,指向外部则跳过并警告 |
| 权限位 | unix 之间保留可执行位;Windows 忽略 |
### 4.7 吞吐目标与真实瓶颈
| 链路 | 目标 |
|---|---|
| 千兆有线 | ≥ 110 MB/s(线速 118 MB/s) |
| Wi-Fi 6 (160MHz) | ≥ 40 MB/s |
| Wi-Fi 5 | ≥ 20 MB/s |
瓶颈按顺序:
1. **小文件系统调用**(最大)→ 合批解决
2. **TLS + SHA-256 CPU** → 两者都有硬件指令加速(AES-NI / SHA-NI),实测 1~3 GB/s,不是瓶颈;但**必须单遍**,做两遍就变成瓶颈了
3. **磁盘** → 大缓冲(1~4 MiB)、顺序写、批末统一 flush
4. **单条 TCP 在 Wi-Fi 上打不满** → 多连接(默认 4)
---
## 5. 安全模型
现状是局域网明文 HTTP + 二维码里的会话令牌。二维码作为带外信道是对的,但**内容明文**——同网段任何人抓包就能拿到文件。
v0.5:
- 每个节点首次运行生成 **Ed25519 身份密钥对**,存平台配置目录(后续可迁到 Keychain / Credential Manager / Secret Service)
- **TLS 1.3**,自签证书绑定身份公钥,**按公钥验证对端**(不走 CA 体系)
- 首次连接的信任建立分两种:
| 场景 | 方式 |
|---|---|
| 扫码(手机在场) | 二维码携带对端指纹 + 一次性 PSK,扫码动作本身即确认,**无需弹窗**(沿用现有 `QFTP2P1` 思路) |
| mDNS 发现 / 6 位码(PC↔PC) | 接收方弹「接受来自 <名字> 的传输?」,两端各显示一个由双方公钥派生的 **6 位校验码**,用户目视比对后确认 |
- 确认后写入信任库(TOFU),之后同一对端免确认
- **绝不自动接受未知对端**
---
## 6. 代码组织:要不要做共享核心
现状是同一协议三份实现,共 9 321 行。v3 要在三端各写一遍目录传输 + 合批 + 断点续传,是三倍工作量和三倍漂移风险。
| 方案 | 优点 | 代价 |
|---|---|---|
| A. 三端各写 | 无新工具链 | 3× 工作量,协议漂移 |
| B. 共享 Rust core + FFI | 一份实现 | NDK/cargo-ndk、uniffi、xcframework、CI 全套 |
| **C. 桌面共享 + 移动端原生 + 共用一致性测试** | 桌面三平台几乎零成本共享;移动端不引入 FFI | 移动端仍是两份 |
**推荐 C。** 理由:桌面三平台本来就是同一份 Rust 代码(实测只有 3 处平台耦合),共享是白拿的;而移动端上 FFI 的投入要等 v3 协议稳定后才划算。
配套:把现有 `ios/CoreTests/MockPCServer.py` 的做法推广成 **`conformance/` 一致性套件**——一份黄金测试向量 + 一个参考对端,三端实现都必须跑通。这是目前防漂移最有效的手段,已经在 iOS 端验证过。
若后续移动端漂移确实变痛,再切 B,届时 v3 已定型,FFI 的收益也更清楚。
---
## 7. 兼容与分期
v2(现有 HTTP)与 v3 并存。节点在 mDNS TXT 和 `/qft/ping` 里声明支持的版本,双方取交集。老版本 Android/iOS 装机不受影响。
| 里程碑 | 内容 | 产出 | 依赖 |
|---|---|---|---|
| **M1** | 桌面跨平台(`windows/`→`desktop/`,3 处平台抽象)+ 桌面客户端 + mDNS + 6 位码 | **PC↔PC 可用**(先走 v2 HTTP) | 无 |
| **M2** | QFT-Stream v3:帧协议、流式索引、小文件合批、断点续传、路径安全 | **目录直传可用**,先在两台 PC 之间验证 | M1 |
| **M3** | 移动端接入 v3:Android `NodeServer` + `NsdManager` + 前台服务;iOS `PeerLink` 并入 v3 | 手机 ↔ 电脑走 v3 | M2 |
| **M4** | 手机↔手机:Android Wi-Fi Direct、iOS 沿用 AWDL、跨系统走 LAN | **手机↔手机可用** | M3 |
| M5 | 一致性套件 `conformance/`、性能回归基准 | 防漂移 | M2 |
M1 最快见效且零协议风险,建议先做完 M1 拿到真实的 PC↔PC 体验,再决定 M2 的细节。
---
## 8. 明确不做 / 做不到
- **Android ↔ iOS 无路由器直连**:AWDL 与 Wi-Fi Direct 互不兼容,iOS 又不能用代码加入指定 Wi-Fi。只能同一局域网,UI 必须直说
- **Linux 的 Wi-Fi Direct / 热点**:各发行版 NetworkManager 行为差异过大,不做,Linux 只支持同 LAN
- **光学链路**:不在本次范围。QFT5 位阵列方案见 `OPTICAL_V5_PLAN.md`,且必须先做完楔形标定
- **公网中继 / 打洞**:QFT 的定位是本地直传,引入中继会改变整个安全模型,不做
---
## 9. 主要风险
| 风险 | 影响 | 对策 |
|---|---|---|
| mDNS 在企业 Wi-Fi / AP 隔离下被拦 | 发现不到对端 | UDP 广播 + 6 位码 + 手动 IP 三重兜底 |
| 大目录索引占内存 | 10 万文件的清单常驻 | 流式索引,接收端落盘为 sqlite/紧凑二进制,不全量驻留 |
| Android 后台被杀 | 长传输中断 | 前台服务 + WakeLock + 会话可恢复(v3 断点续传) |
| 三端协议漂移 | 联调地狱 | `conformance/` 一致性套件,CI 强制 |
| TLS 引入依赖体积 | 移动端包变大 | 桌面用 `rustls`;Android 用系统 `SSLSocket`;iOS 用 Network.framework(已在用) |
BIN
View File
Binary file not shown.
+17
View File
@@ -5,6 +5,23 @@ func sha256Hex(_ data: Data) -> String {
SHA256.hash(data: data).map { String(format: "%02x", $0) }.joined() SHA256.hash(data: data).map { String(format: "%02x", $0) }.joined()
} }
extension Data {
/// 十六进制字符串转字节。只在测试里造光学清单时用。
init?(hexString: String) {
guard hexString.count % 2 == 0 else { return nil }
var bytes = [UInt8]()
bytes.reserveCapacity(hexString.count / 2)
var index = hexString.startIndex
while index < hexString.endIndex {
let next = hexString.index(index, offsetBy: 2)
guard let byte = UInt8(hexString[index..<next], radix: 16) else { return nil }
bytes.append(byte)
index = next
}
self.init(bytes)
}
}
/// 从管道里读一行,带超时。用来等 MockPCServer 打印 `READY <port>`。 /// 从管道里读一行,带超时。用来等 MockPCServer 打印 `READY <port>`。
func readReadyLine(from handle: FileHandle, timeout: TimeInterval) -> String? { func readReadyLine(from handle: FileHandle, timeout: TimeInterval) -> String? {
let deadline = Date().addingTimeInterval(timeout) let deadline = Date().addingTimeInterval(timeout)
+53 -15
View File
@@ -1,5 +1,5 @@
#!/usr/bin/env python3 #!/usr/bin/env python3
"""按 windows/src/{sender,receiver}.rs 的线上语义实现的假电脑端。 """按 desktop/src/{sender,receiver}.rs 的线上语义实现的假电脑端。
存在的意义:Swift 客户端的线格式必须和 Rust 端逐字节一致, 存在的意义:Swift 客户端的线格式必须和 Rust 端逐字节一致,
而 Rust 端在这台机器上编译不了。这个 mock 把两端的契约固定下来, 而 Rust 端在这台机器上编译不了。这个 mock 把两端的契约固定下来,
@@ -76,35 +76,50 @@ class Handler(BaseHTTPRequestHandler):
def _download(self): def _download(self):
path = STATE["serve"] path = STATE["serve"]
size = os.path.getsize(path) size = os.path.getsize(path)
offset = 0
header = self.headers.get("Range") header = self.headers.get("Range")
# 老版本/别的实现可能整个忽略 Range,直接把整份文件送过来。
# 客户端必须能识别这种服务端并回落单流下载。
if STATE.get("ignore_range"):
header = None
# 与 sender.rs::parse_range 同一套语义:开区间与闭区间都接受,
# 不支持后缀 Range,越界一律拒绝。
offset, end = 0, max(size - 1, 0)
if header: if header:
assert header.startswith("bytes="), "只支持 bytes= 形式的 Range" assert header.startswith("bytes="), "只支持 bytes= 形式的 Range"
assert header.endswith("-"), "sender.rs 只支持单段开区间 Range" start_text, _, end_text = header[len("bytes="):].partition("-")
offset = int(header[len("bytes="):-1]) assert start_text, "不支持后缀 Range"
assert 0 <= offset < size, "Range 越界" offset = int(start_text)
remaining = size - offset end = int(end_text) if end_text else size - 1
assert 0 <= offset < size and offset <= end < size, "Range 越界"
remaining = 0 if size == 0 else end - offset + 1
self.send_response(206 if offset else 200) self.send_response(206 if header else 200)
self.send_header("Content-Type", "application/octet-stream") self.send_header("Content-Type", "application/octet-stream")
self.send_header("Content-Length", str(remaining)) self.send_header("Content-Length", str(remaining))
self.send_header("Accept-Ranges", "bytes") self.send_header("Accept-Ranges", "bytes")
if offset: if header:
self.send_header("Content-Range", "bytes %d-%d/%d" % (offset, size - 1, size)) self.send_header("Content-Range", "bytes %d-%d/%d" % (offset, end, size))
self.send_header("X-QFT-Filename", b64url_encode(os.path.basename(path).encode("utf-8"))) self.send_header("X-QFT-Filename", b64url_encode(os.path.basename(path).encode("utf-8")))
self.send_header("Connection", "close") # 并行下载会在一条连接上连续发多个 Range 请求,
# sender.rs 对这种请求保持 keep-alive
self.send_header("Connection", "keep-alive")
self.end_headers() self.end_headers()
with open(path, "rb") as fh: with open(path, "rb") as fh:
fh.seek(offset) fh.seek(offset)
while True: left = remaining
block = fh.read(256 * 1024) while left > 0:
block = fh.read(min(256 * 1024, left))
if not block: if not block:
break break
self.wfile.write(block) self.wfile.write(block)
left -= len(block)
# -------------------------------------------------- POST # -------------------------------------------------- POST
def do_POST(self): def do_POST(self):
# 配对是唯一不校验令牌的端点——它的作用正是换取令牌
if self.path == "/qft/pair":
return self._pair()
if not self._authorized(): if not self._authorized():
return return
if self.path == "/qft/upload/init": if self.path == "/qft/upload/init":
@@ -115,6 +130,20 @@ class Handler(BaseHTTPRequestHandler):
return self._upload_finish() return self._upload_finish()
return self._json(404, {"ok": False}) return self._json(404, {"ok": False})
def _pair(self):
"""receiver.rs::handle_pair:6 位十六进制秘密换会话令牌,错 5 次作废。"""
max_failures = 5
if STATE["pair_failures"] >= max_failures:
return self._json(429, {"ok": False, "error": "配对码已因多次输入错误作废"})
if self.headers.get("X-QFT-Code") != STATE["code"]:
STATE["pair_failures"] += 1
return self._json(403, {
"ok": False,
"remaining": max_failures - STATE["pair_failures"],
})
STATE["pair_failures"] = 0
return self._json(200, {"ok": True, "token": STATE["token"]})
def _upload_init(self): def _upload_init(self):
name = b64url_decode(self.headers["X-QFT-Filename"]).decode("utf-8") name = b64url_decode(self.headers["X-QFT-Filename"]).decode("utf-8")
size = int(self.headers["X-QFT-Size"]) size = int(self.headers["X-QFT-Size"])
@@ -187,7 +216,7 @@ class Handler(BaseHTTPRequestHandler):
def udp_responder(token, http_port, stop): def udp_responder(token, http_port, stop):
"""QFTDISC2:<token> → QFTHERE2:<token>:<port>,对应 sender.rs 的发现线程。""" """receiver.rs 的 UDP 线程:既回 QFTDISC2,也回不带令牌的 QFTBROWSE3。"""
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
try: try:
@@ -197,6 +226,9 @@ def udp_responder(token, http_port, stop):
sock.settimeout(0.25) sock.settimeout(0.25)
expected = ("QFTDISC2:%s" % token).encode("ascii") expected = ("QFTDISC2:%s" % token).encode("ascii")
reply = ("QFTHERE2:%s:%d" % (token, http_port)).encode("ascii") reply = ("QFTHERE2:%s:%d" % (token, http_port)).encode("ascii")
announce = ("QFTNODE3:" + json.dumps(
{"n": "MOCK-PC", "p": "macos", "t": http_port, "r": True},
separators=(",", ":"))).encode("utf-8")
while not stop.is_set(): while not stop.is_set():
try: try:
data, peer = sock.recvfrom(512) data, peer = sock.recvfrom(512)
@@ -204,7 +236,9 @@ def udp_responder(token, http_port, stop):
continue continue
except OSError: except OSError:
break break
if data == expected: if data == b"QFTBROWSE3":
sock.sendto(announce, peer)
elif data == expected:
sock.sendto(reply, peer) sock.sendto(reply, peer)
sock.close() sock.close()
@@ -216,9 +250,13 @@ def main():
parser.add_argument("--save-dir", required=True, help="接收上传的目录") parser.add_argument("--save-dir", required=True, help="接收上传的目录")
parser.add_argument("--port", type=int, default=0) parser.add_argument("--port", type=int, default=0)
parser.add_argument("--udp", action="store_true", help="同时启动 UDP 发现应答") parser.add_argument("--udp", action="store_true", help="同时启动 UDP 发现应答")
parser.add_argument("--code", default="a1b2c3", help="/qft/pair 使用的 6 位十六进制秘密")
parser.add_argument("--ignore-range", action="store_true",
help="模拟不支持分段下载的电脑端,永远返回 200 整份文件")
args = parser.parse_args() args = parser.parse_args()
STATE.update(token=args.token, serve=args.serve, save_dir=args.save_dir, uploads={}) STATE.update(token=args.token, serve=args.serve, save_dir=args.save_dir, uploads={},
code=args.code, pair_failures=0, ignore_range=args.ignore_range)
os.makedirs(args.save_dir, exist_ok=True) os.makedirs(args.save_dir, exist_ok=True)
server = ThreadingHTTPServer(("127.0.0.1", args.port), Handler) server = ThreadingHTTPServer(("127.0.0.1", args.port), Handler)
+486 -25
View File
@@ -6,6 +6,10 @@ import Foundation
// 集成测试跑在 MockPCServer.py 上,该 mock 严格复刻 receiver.rs / sender.rs // 集成测试跑在 MockPCServer.py 上,该 mock 严格复刻 receiver.rs / sender.rs
// 的线上语义,因此这里通过 == 线格式与 Windows 端兼容。 // 的线上语义,因此这里通过 == 线格式与 Windows 端兼容。
// 输出重定向到文件/管道时 stdout 默认是块缓冲的,一旦中途 trap 就什么都看不到,
// 排查成本极高。改成行缓冲。
setvbuf(stdout, nil, _IOLBF, 0)
var failures = 0 var failures = 0
var checks = 0 var checks = 0
@@ -129,6 +133,284 @@ checkEqual(LocalNetwork.ipv4("192.168.1.20"), 0xC0A80114, "IPv4 转整数")
checkEqual(LocalNetwork.format(0xC0A80114), "192.168.1.20", "整数转 IPv4") checkEqual(LocalNetwork.format(0xC0A80114), "192.168.1.20", "整数转 IPv4")
check(LocalNetwork.ipv4("192.168.1.256") == nil, "拒绝越界八位组") check(LocalNetwork.ipv4("192.168.1.256") == nil, "拒绝越界八位组")
// iOS SDK 不导出 net/route.h,路由表报文只能按手写偏移解析。
// macOS SDK 有真类型,在这里逐字段交叉校验——布局一旦变了立刻红。
typealias RM = LocalNetwork.RouteMessage
checkEqual(RM.headerSize, MemoryLayout<rt_msghdr>.size, "rt_msghdr 大小")
checkEqual(RM.messageLengthOffset, MemoryLayout<rt_msghdr>.offset(of: \.rtm_msglen), "rtm_msglen 偏移")
checkEqual(RM.versionOffset, MemoryLayout<rt_msghdr>.offset(of: \.rtm_version), "rtm_version 偏移")
checkEqual(RM.interfaceIndexOffset, MemoryLayout<rt_msghdr>.offset(of: \.rtm_index), "rtm_index 偏移")
checkEqual(RM.addressMaskOffset, MemoryLayout<rt_msghdr>.offset(of: \.rtm_addrs), "rtm_addrs 偏移")
checkEqual(Int32(RM.version), Int32(RTM_VERSION), "RTM_VERSION")
checkEqual(RM.gatewayFlag, Int32(RTF_GATEWAY), "RTF_GATEWAY")
checkEqual(RM.addressSlots, Int(RTAX_MAX), "RTAX_MAX")
checkEqual(RM.destinationSlot, Int(RTAX_DST), "RTAX_DST")
checkEqual(RM.gatewaySlot, Int(RTAX_GATEWAY), "RTAX_GATEWAY")
// 路由表读的是本机真实状态,不能断言具体内容,但**必须**保证:
// 不崩、且返回的东西全部是私有 IPv4——它会被直接当成电脑地址去连。
let gateways = LocalNetwork.defaultGateways()
check(gateways.allSatisfy(PairingProtocol.isPrivateIPv4), "默认网关全部是私有 IPv4(读到 \(gateways.count) 个)")
check(LocalNetwork.directedBroadcastAddresses().allSatisfy { $0.split(separator: ".").count == 4 },
"定向广播地址格式正确")
let candidates = LocalNetwork.hostCandidates(port: 39393, limit: 8)
check(candidates.allSatisfy { PairingProtocol.isAllowedLocalHTTPEndpoint($0, expectedPort: 39393) },
"候选地址全部过端点白名单")
check(Set(candidates).count == candidates.count, "候选地址无重复")
// ---------------------------------------------------------------- 专用网络
section("专用网络(Windows QFT Direct)")
let directText = makePairingText(prefix: "QFTPAIR2:", [
"v": 2, "s": session, "n": "DESKTOP-QFT", "p": 39393,
"e": [], "w": ["QFT-PC-abc123", "0123456789abcdef"],
])
let direct = PairingProtocol.parse(directText)
check(direct != nil, "接受只带 Wi-Fi 凭据、不带地址的专用网络二维码")
checkEqual(direct?.wifi, WifiCredentials(ssid: "QFT-PC-abc123", passphrase: "0123456789abcdef"), "Wi-Fi 凭据")
check(direct?.endpoints.isEmpty == true, "专用网络二维码不带任何电脑地址")
check(PairingProtocol.parse(makePairingText(prefix: "QFTPAIR2:", [
"v": 2, "s": session, "p": 39393, "e": [],
])) == nil, "既无地址又无 Wi-Fi 时拒绝")
check(PairingProtocol.parse(makePairingText(prefix: "QFTPAIR2:", [
"v": 2, "s": session, "p": 39393, "e": [], "w": ["QFT-PC", "short"],
])) == nil, "Wi-Fi 密码过短时拒绝")
let lanPairing = PairingPayload(version: 2, session: session, pcName: "MAC", port: 39393,
endpoints: ["http://192.168.1.9:39393"], wifi: nil,
direction: .uploadToPC, fileName: nil, fileSize: nil, sha256: nil)
checkEqual(DedicatedNetworkPlan.plan(for: lanPairing, canJoinProgrammatically: true),
.useEndpoints(["http://192.168.1.9:39393"]), "有地址时直接连,不去动 Wi-Fi")
checkEqual(DedicatedNetworkPlan.plan(for: direct!, canJoinProgrammatically: true),
.joinWifi(direct!.wifi!), "有能力时自动加入专用 Wi-Fi")
checkEqual(DedicatedNetworkPlan.plan(for: direct!, canJoinProgrammatically: false),
.manualJoin(direct!.wifi!), "没有 entitlement 时转为手动加入引导,而不是假装成功")
// ---------------------------------------------------------------- Base45
section("Base45(与 desktop/src/base45.rs 同一组向量)")
checkEqual(Base45.encode(Data("AB".utf8)), "BB8", "编码 AB")
checkEqual(Base45.encode(Data("Hello!!".utf8)), "%69 VD92EX0", "编码 Hello!!")
checkEqual(Base45.encode(Data("base-45".utf8)), "UJCLQE7W581", "编码 base-45")
checkEqual(Base45.decode("BB8"), Data("AB".utf8), "解码 BB8")
checkEqual(Base45.decode("%69 VD92EX0"), Data("Hello!!".utf8), "解码 Hello!!")
checkEqual(Base45.decode("K1"), Data([0x41]), "两字符尾块解出单字节")
check(Base45.decode("AB") == nil, "两字符尾块超过 0xFF 时拒绝(A+B*45=505)")
check(Base45.decode("A") == nil, "长度 %3==1 时拒绝")
check(Base45.decode("ab") == nil, "小写不在字母表内,拒绝")
check(Base45.decode("::::::") == nil, "超过 0xFFFF 的三元组拒绝")
var base45RoundTripOK = true
for _ in 0..<200 {
let raw = Data((0..<Int.random(in: 0...600)).map { _ in UInt8.random(in: 0...255) })
if Base45.decode(Base45.encode(raw)) != raw { base45RoundTripOK = false; break }
}
check(base45RoundTripOK, "200 组随机字节 Base45 往返一致")
// ---------------------------------------------------------------- 光学协议
section("光学 QFT2 帧")
func opticalPlaylist(payload: Data, chunkSize: Int, name: String,
sessionID: UInt64 = 0x0123_4567_89ab_cdef) -> (OpticalManifest, [String]) {
let total = payload.isEmpty ? 0 : UInt32((payload.count + chunkSize - 1) / chunkSize)
let manifest = OpticalManifest(
sessionID: sessionID, senderDevice: "DESKTOP-QFT", fileName: name,
fileSize: UInt64(payload.count), chunkSize: chunkSize, totalChunks: total,
sha256: Data(hexString: sha256Hex(payload))!)
var frames = [OpticalProtocol.text(for: OpticalProtocol.encodeManifest(manifest))]
for index in 0..<Int(total) {
let start = index * chunkSize
let end = min(start + chunkSize, payload.count)
frames.append(OpticalProtocol.text(for: OpticalProtocol.encodeFrame(
kind: .data, sessionID: sessionID, seq: UInt32(index),
totalChunks: total, payload: payload.subdata(in: start..<end))))
}
frames.append(OpticalProtocol.text(for: OpticalProtocol.encodeFrame(
kind: .end, sessionID: sessionID, seq: 0, totalChunks: total, payload: Data())))
return (manifest, frames)
}
let opticalPayload = Data((0..<4321).map { UInt8($0 % 251) })
let (opticalManifest, opticalFrames) = opticalPlaylist(payload: opticalPayload,
chunkSize: 450, name: "报告.pdf")
check(opticalFrames.allSatisfy { $0.hasPrefix("QFT2:") }, "帧文本前缀为 QFT2:")
check(opticalFrames.allSatisfy(OpticalProtocol.isOpticalText), "全部被识别为光学帧")
let parsedManifest = OpticalProtocol.parseText(opticalFrames[0]).flatMap(OpticalProtocol.parseManifest)
checkEqual(parsedManifest, opticalManifest, "清单帧编解码往返一致")
checkEqual(parsedManifest?.fileName, "报告.pdf", "文件名支持中文")
checkEqual(parsedManifest?.sha256Hex, sha256Hex(opticalPayload), "清单里的 SHA-256")
// CRC 是唯一能挡住「语法合法但内容错误」的相机误识别的手段
var corrupted = OpticalProtocol.encodeFrame(kind: .data, sessionID: 1, seq: 0,
totalChunks: 1, payload: Data([1, 2, 3]))
corrupted[OpticalProtocol.headerSize] ^= 0x40
check(OpticalProtocol.parseBinary(corrupted, magic: "QFT2", version: 2) == nil, "CRC 不符时整帧丢弃")
check(OpticalProtocol.parseText("QFT2:" + String(repeating: "0", count: 60)) == nil, "噪声文本不会被当成帧")
check(OpticalProtocol.parseText("QFT2:") == nil, "空帧被拒绝")
check(OpticalProtocol.parseText("hello") == nil, "非 QFT 文本被忽略")
checkEqual(OpticalProtocol.sanitizeFileName("../../etc/passwd"), "etc_passwd", "文件名里的路径分隔符被清掉")
checkEqual(OpticalProtocol.sanitizeFileName(" "), "qft.bin", "空文件名有兜底")
// ---------------------------------------------------------------- 光学装配
section("光学会话装配")
let opticalRoot = URL(fileURLWithPath: NSTemporaryDirectory())
.appendingPathComponent("qft-optical-\(UUID().uuidString)", isDirectory: true)
try! FileManager.default.createDirectory(at: opticalRoot, withIntermediateDirectories: true)
var opticalSaved: URL?
var opticalErrors: [String] = []
var opticalProgressSeen = 0
let assembler = OpticalAssembler(destinationDirectory: opticalRoot,
workDirectory: opticalRoot.appendingPathComponent("work")) { event in
switch event {
case .completed(_, let url): opticalSaved = url
case .failed(let message): opticalErrors.append(message)
case .progress(_, let received, _): opticalProgressSeen = received
case .started: break
}
}
// 真实场景是循环重播:乱序 + 大量重复
var duplicates = 0
var accepted = 0
for text in opticalFrames.shuffled() + opticalFrames {
switch assembler.accept(text: text) {
case .accepted: accepted += 1
case .duplicate: duplicates += 1
case .ignored: break
}
}
check(opticalErrors.isEmpty, "乱序重播过程中没有错误:\(opticalErrors)")
check(opticalSaved != nil, "收齐后自动落盘")
check(duplicates > 0, "重复帧被识别为 duplicate(\(duplicates) 帧),不会重复计入吞吐")
checkEqual(accepted, Int(opticalManifest.totalChunks) + 1, "有效新帧数 = 数据片数 + 清单")
check(opticalProgressSeen == Int(opticalManifest.totalChunks), "进度回调走到最后一片")
if let opticalSaved {
let data = try! Data(contentsOf: opticalSaved)
checkEqual(sha256Hex(data), sha256Hex(opticalPayload), "落盘内容 SHA-256 一致")
checkEqual(opticalSaved.lastPathComponent, "报告.pdf", "落盘文件名正确")
}
// 摘要对不上时必须整份丢弃,绝不把半份文件交给用户
var tamperedError: String?
let tamperedAssembler = OpticalAssembler(
destinationDirectory: opticalRoot.appendingPathComponent("bad"),
workDirectory: opticalRoot.appendingPathComponent("work")) { event in
if case .failed(let message) = event { tamperedError = message }
}
let liar = OpticalManifest(sessionID: 42, senderDevice: "PC", fileName: "x.bin",
fileSize: UInt64(opticalPayload.count), chunkSize: 450,
totalChunks: UInt32((opticalPayload.count + 449) / 450),
sha256: Data(repeating: 0xAB, count: 32))
tamperedAssembler.accept(text: OpticalProtocol.text(for: OpticalProtocol.encodeManifest(liar)))
for index in 0..<Int(liar.totalChunks) {
let start = index * 450
let end = min(start + 450, opticalPayload.count)
tamperedAssembler.accept(text: OpticalProtocol.text(for: OpticalProtocol.encodeFrame(
kind: .data, sessionID: 42, seq: UInt32(index), totalChunks: liar.totalChunks,
payload: opticalPayload.subdata(in: start..<end))))
}
check(tamperedError?.contains("SHA-256") == true, "整份校验失败时报错并丢弃")
check(!FileManager.default.fileExists(
atPath: opticalRoot.appendingPathComponent("bad/x.bin").path), "校验失败的文件不会落到目标目录")
// 空文件是合法的边界:清单里 0 片,收到清单即完成
var emptySaved: URL?
let emptyAssembler = OpticalAssembler(
destinationDirectory: opticalRoot.appendingPathComponent("empty"),
workDirectory: opticalRoot.appendingPathComponent("work")) { event in
if case .completed(_, let url) = event { emptySaved = url }
}
let (_, emptyFrames) = opticalPlaylist(payload: Data(), chunkSize: 450, name: "empty.bin",
sessionID: 7)
emptyAssembler.accept(text: emptyFrames[0])
check(emptySaved != nil, "0 字节文件也能正常收完")
try? FileManager.default.removeItem(at: opticalRoot)
// ---------------------------------------------------------------- ROI
section("光学 ROI 状态机")
var roi = OpticalROI(aspect: 0.5625) // 竖屏 720×1280
check(!roi.isLocked, "初始为搜索态")
check(roi.decodeRegion.width > 0.8, "搜索态覆盖大半个画面")
roi.hit(boundingBox: CGRect(x: 0.30, y: 0.40, width: 0.20, height: 0.12))
check(roi.isLocked, "解出一帧后进入锁定")
let locked = roi.decodeRegion
check(locked.width < 0.6, "锁定后只解一小块(宽 \(String(format: "%.2f", locked.width)))")
// 归一化坐标在 9:16 画面上会把方码拉扁,ROI 必须按像素比例修方
check(abs(locked.width * 0.5625 - locked.height) < 0.02, "锁定框在像素意义上是正方形")
for _ in 0..<(OpticalROI.missesBeforeExpand + 1) { roi.miss() }
check(roi.decodeRegion.width > locked.width, "连续丢失后逐级放大 ROI")
for _ in 0..<OpticalROI.missesBeforeReacquire { roi.miss() }
check(!roi.isLocked && roi.decodeRegion.width > 0.8, "持续丢失后回到全画面重新搜索")
var edge = OpticalROI(aspect: 1)
edge.hit(boundingBox: CGRect(x: 0.95, y: 0.95, width: 0.2, height: 0.2))
let clamped = edge.decodeRegion
check(clamped.minX >= 0 && clamped.minY >= 0
&& clamped.maxX <= 1.0001 && clamped.maxY <= 1.0001, "越界的 ROI 被夹回画面内")
// ---------------------------------------------------------------- 连接码
section("桌面端连接码(与 desktop/src/connect_code.rs 交叉验证)")
// 这四组由 Rust 端实现直接产出,任何一边改了编码都会红
let codeVectors: [(String, Int, String, String)] = [
("192.168.1.20", 39393, "a1b2c3", "480H-98DJ-RCTG"),
("10.0.0.5", 39393, "010203", "4R00-0181-081P-P"),
("172.20.10.3", 40000, "ff007f", "5020-M0WW-83ZG-0ZTH"),
("127.0.0.1", 8080, "deadbe", "5HZG-0001-3Y8D-XBDY-98"),
]
for (address, port, secret, text) in codeVectors {
guard let decoded = try? ConnectCode.decode(text) else {
check(false, "解析 \(text) 失败"); continue
}
checkEqual(decoded.address, address, "\(text) 的地址")
checkEqual(decoded.port, port, "\(text) 的端口")
checkEqual(decoded.secretHex, secret, "\(text) 的秘密")
checkEqual(decoded.encode(), text, "\(text) 重新编码一致")
}
check((try? ConnectCode.decode("480h 98dj rctg")) != nil, "小写与空格分隔都接受")
check((try? ConnectCode.decode("48OH-98DJ-RCTG")) != nil, "Crockford 容错:O 当成 0")
check((try? ConnectCode.decode("480H-98DJ-RCTU")) == nil, "字母表外的字符被拒绝")
check((try? ConnectCode.decode("480H-98DJ-RCTF")) == nil, "改一位后校验失败")
check((try? ConnectCode.decode("480H")) == nil, "长度不足时拒绝")
check(try! ConnectCode.decode("480H-98DJ-RCTG").isUsable, "私有地址的连接码可用")
// 连接码同样是不可信输入:公网地址不能因为「码是对的」就放行
let publicCode = ConnectCode(address: "8.8.8.8", port: 39393, secret: [1, 2, 3])
check(!publicCode.isUsable, "公网地址的连接码被端点白名单拒绝")
// ---------------------------------------------------------------- 节点浏览
section("QFTBROWSE3 节点应答(不可信输入)")
let announce = #"QFTNODE3:{"n":"MacBook-Pro","p":"macos","t":39393,"r":true}"#
let peer = PeerBrowser.parseReply(announce, source: "192.168.1.20")
checkEqual(peer?.name, "MacBook-Pro", "节点名")
checkEqual(peer?.platform, "macos", "平台标识")
checkEqual(peer?.port, 39393, "端口")
checkEqual(peer?.baseURL, "http://192.168.1.20:39393", "base URL")
check(peer?.ready == true, "等待接收标志")
check(PeerBrowser.parseReply(announce, source: "8.8.8.8") == nil, "来源不是私有地址时丢弃")
check(PeerBrowser.parseReply(#"QFTNODE3:{"n":"x","p":"linux","t":0,"r":true}"#,
source: "10.0.0.2") == nil, "端口 0 的应答无意义")
check(PeerBrowser.parseReply("QFTHERE2:token:39393", source: "10.0.0.2") == nil, "前缀不符时丢弃")
check(PeerBrowser.parseReply("QFTNODE3:not-json", source: "10.0.0.2") == nil, "非 JSON 丢弃")
let dirty = PeerBrowser.parseReply(
"QFTNODE3:{\"n\":\"bad\\u0000name\",\"p\":\"linux!!\",\"t\":1,\"r\":false}", source: "10.0.0.2")
check(dirty?.name.contains("\0") == false, "节点名里的控制字符被清掉")
checkEqual(dirty?.platform, "linux", "平台标识只保留字母数字")
// ---------------------------------------------------------------- 集成测试 // ---------------------------------------------------------------- 集成测试
section("集成:与 MockPCServer 的完整传输") section("集成:与 MockPCServer 的完整传输")
@@ -226,6 +508,119 @@ if port > 0 {
check(false, "续传失败:\(error.localizedDescription)") check(false, "续传失败:\(error.localizedDescription)")
} }
// --- 并行 Range 下载 ---
do {
let parallelDir = root.appendingPathComponent("parallel", isDirectory: true)
let client = RangeDownloadClient(host: host, token: token, deviceName: "iPhone 测试机",
destinationDirectory: parallelDir)
// 没有二维码时靠 Range: bytes=0-0 问出文件名与总长度
let probed = try await client.probe()
checkEqual(probed.fileName, "payload.bin", "探测拿到文件名")
checkEqual(probed.fileSize, UInt64(payloadSize), "探测拿到总长度")
let target = RangeDownloadClient.Target(fileName: "payload.bin",
fileSize: UInt64(payloadSize),
sha256: payloadHash)
var parallelFraction = 0.0
let saved = try await client.run(target) { parallelFraction = $0.fraction }
let received = try Data(contentsOf: saved)
checkEqual(sha256Hex(received), payloadHash, "并行下载内容 SHA-256 一致")
check(parallelFraction > 0.99, "并行下载进度回调抵达 100%")
check(!FileManager.default.fileExists(atPath: saved.path + ".qftpart"), "分块临时文件已清理")
check(!FileManager.default.fileExists(
atPath: parallelDir.appendingPathComponent("payload.bin.qftpart.ledger").path),
"断点账本已清理")
try? FileManager.default.removeItem(at: saved)
// 并行分块是乱序落盘的,续传只能靠账本,不能靠「已落盘长度」
let partURL = parallelDir.appendingPathComponent("payload.bin.qftpart")
let ledgerURL = parallelDir.appendingPathComponent("payload.bin.qftpart.ledger")
let chunk = RangeDownloadClient.chunkSize(for: UInt64(payloadSize))
let totalChunks = Int((UInt64(payloadSize) + chunk - 1) / chunk)
var half = [Bool](repeating: false, count: totalChunks)
var scratch = Data(count: payloadSize)
for index in stride(from: 0, to: totalChunks, by: 2) {
half[index] = true
let start = Int(UInt64(index) * chunk)
let end = min(start + Int(chunk), payloadSize)
scratch.replaceSubrange(start..<end, with: payload[start..<end])
}
try scratch.write(to: partURL)
try DownloadLedger(size: UInt64(payloadSize), chunkSize: chunk,
sha256: payloadHash, completed: half).encode().write(to: ledgerURL)
let resumed = try await client.run(target) { _ in }
checkEqual(sha256Hex(try Data(contentsOf: resumed)), payloadHash,
"按账本只补缺失块后内容仍正确")
try? FileManager.default.removeItem(at: resumed)
} catch {
check(false, "并行下载失败:\(error.localizedDescription)")
}
// --- 不支持分段下载的电脑端:必须能被识别出来,交给上层回落单流 ---
do {
let legacyProcess = Process()
legacyProcess.executableURL = URL(fileURLWithPath: "/usr/bin/env")
legacyProcess.arguments = ["python3", mockScript.path, "--token", token,
"--serve", sourceURL.path, "--save-dir", saveDir.path,
"--port", "0", "--ignore-range"]
let legacyPipe = Pipe()
legacyProcess.standardOutput = legacyPipe
try legacyProcess.run()
defer { legacyProcess.terminate() }
let line = readReadyLine(from: legacyPipe.fileHandleForReading, timeout: 10) ?? ""
let legacyPort = Int(line.dropFirst("READY ".count).trimmingCharacters(in: .whitespaces)) ?? 0
check(legacyPort > 0, "不支持分段的 mock 已启动(端口 \(legacyPort))")
if legacyPort > 0 {
let legacyHost = QFTHost(baseURL: "http://127.0.0.1:\(legacyPort)")
let client = RangeDownloadClient(host: legacyHost, token: token,
deviceName: "iPhone 测试机",
destinationDirectory: root.appendingPathComponent("legacy"))
do {
_ = try await client.run(RangeDownloadClient.Target(
fileName: "payload.bin", fileSize: UInt64(payloadSize),
sha256: payloadHash)) { _ in }
check(false, "对端忽略 Range 时本应显式失败")
} catch QFTError.rangeUnsupported {
check(true, "对端忽略 Range 时抛出 rangeUnsupported,上层据此回落单流")
} catch {
check(false, "应抛 rangeUnsupported,实得 \(error)")
}
// 回落路径本身必须还能把文件收完整
let fallbackDir = root.appendingPathComponent("legacy-fallback")
try FileManager.default.createDirectory(at: fallbackDir, withIntermediateDirectories: true)
let fallbackPairing = PairingPayload(
version: 2, session: token, pcName: "OLD-PC", port: legacyPort,
endpoints: [legacyHost.baseURL], wifi: nil, direction: .downloadToPhone,
fileName: "payload.bin", fileSize: UInt64(payloadSize), sha256: payloadHash)
let saved = try await DownloadClient(host: legacyHost, pairing: fallbackPairing,
deviceName: "iPhone 测试机",
destinationDirectory: fallbackDir).run { _ in }
checkEqual(sha256Hex(try Data(contentsOf: saved)), payloadHash, "单流回落后内容仍正确")
}
} catch {
check(false, "分段回落用例失败:\(error.localizedDescription)")
}
// --- 连接码配对 ---
do {
let paired = try await DesktopPairing.pair(baseURL: base, code: "a1b2c3",
deviceName: "iPhone 测试机")
checkEqual(paired, token, "连接码换到会话令牌")
} catch {
check(false, "连接码配对失败:\(error.localizedDescription)")
}
do {
_ = try await DesktopPairing.pair(baseURL: base, code: "000000",
deviceName: "iPhone 测试机")
check(false, "错误连接码本应失败")
} catch {
check(true, "错误连接码被拒绝:\(error.localizedDescription)")
}
// --- 上传 --- // --- 上传 ---
let uploadPairing = PairingPayload( let uploadPairing = PairingPayload(
version: 2, session: token, pcName: "MOCK-PC", port: port, version: 2, session: token, pcName: "MOCK-PC", port: port,
@@ -267,49 +662,76 @@ process.terminate()
section("隔空投送式配对码") section("隔空投送式配对码")
let sampleQueue = try! PeerQueue.encode(sender: "我的 iPhone", files: [
PeerFileMeta(name: "视频.mov", size: 987_654_321, sha256: String(repeating: "cd", count: 32)),
PeerFileMeta(name: "笔记.txt", size: 12, sha256: String(repeating: "ef", count: 32)),
])
let peerSample = PeerPairing( let peerSample = PeerPairing(
version: 1, key: Data((0..<32).map { UInt8($0) }), instance: "qft-abcdefghijkl", version: 2, key: Data((0..<32).map { UInt8($0) }), instance: "qft-abcdefghijkl",
senderName: "我的 iPhone", fileName: "视频.mov", fileSize: 987_654_321, senderName: "我的 iPhone", fileCount: 2, totalSize: 987_654_333,
sha256: String(repeating: "cd", count: 32)) queueDigest: PeerQueue.digest(of: sampleQueue), previewName: "视频.mov")
let peerRoundTrip = PeerPairing.parse(peerSample.encode()) let peerRoundTrip = PeerPairing.parse(peerSample.encode())
checkEqual(peerRoundTrip, peerSample, "QFTP2P1 编解码往返一致") checkEqual(peerRoundTrip, peerSample, "QFTP2P2 编解码往返一致")
check(PeerPairing.isPeerText(peerSample.encode()), "前缀识别") check(PeerPairing.isPeerText(peerSample.encode()), "前缀识别")
check(PairingProtocol.parse(peerSample.encode()) == nil, "P2P 码不会被误判为 QFTPAIR2") check(PairingProtocol.parse(peerSample.encode()) == nil, "P2P 码不会被误判为 QFTPAIR2")
// 多文件的元数据留在链路上,二维码只带摘要——十几个文件的清单会让码密到扫不动
check(peerSample.encode().count < 400, "二维码内容不随文件数增长(\(peerSample.encode().count) 字符)")
func mutatedPeer(_ change: (inout [String: Any]) -> Void) -> String? { let queueRoundTrip = PeerQueue.decode(sampleQueue)
checkEqual(queueRoundTrip?.files.count, 2, "清单解析出两个文件")
checkEqual(queueRoundTrip?.files.first?.name, "视频.mov", "清单里的文件名")
check(PeerQueue.decode(Data("{}".utf8)) == nil, "空清单被拒绝")
check(PeerQueue.decode(Data(#"{"v":2,"files":[{"name":"../x","size":1,"sha256":"aa"}]}"#.utf8)) == nil,
"清单里的路径分隔符被拒绝")
func mutatedPeer(_ change: (inout [String: Any]) -> Void) -> String {
var object: [String: Any] = [ var object: [String: Any] = [
"v": 1, "k": Base64URL.encode(Data(repeating: 7, count: 32)), "v": 2, "k": Base64URL.encode(Data(repeating: 7, count: 32)),
"i": "qft-abcdefghijkl", "n": "iPhone", "f": "a.bin", "i": "qft-abcdefghijkl", "n": "iPhone", "c": 1, "z": 10,
"z": 10, "h": String(repeating: "ab", count: 32), "d": String(repeating: "ab", count: 32), "f": "a.bin",
] ]
change(&object) change(&object)
let data = try! JSONSerialization.data(withJSONObject: object) let data = try! JSONSerialization.data(withJSONObject: object)
return PeerPairing.prefix + Base64URL.encode(data) return PeerPairing.prefix + Base64URL.encode(data)
} }
check(PeerPairing.parse(mutatedPeer { $0["k"] = Base64URL.encode(Data(repeating: 7, count: 16)) }!) == nil, check(PeerPairing.parse(mutatedPeer { $0["k"] = Base64URL.encode(Data(repeating: 7, count: 16)) }) == nil,
"密钥不足 32 字节时拒绝") "密钥不足 32 字节时拒绝")
check(PeerPairing.parse(mutatedPeer { $0["i"] = "bad instance!" }!) == nil, "非法实例名时拒绝") check(PeerPairing.parse(mutatedPeer { $0["i"] = "bad instance!" }) == nil, "非法实例名时拒绝")
check(PeerPairing.parse(mutatedPeer { $0["f"] = "../../etc/passwd" }!) == nil, "文件名含路径分隔符时拒绝") check(PeerPairing.parse(mutatedPeer { $0["f"] = "../../etc/passwd" }) == nil, "预览文件名含路径分隔符时拒绝")
check(PeerPairing.parse(mutatedPeer { $0["h"] = "zz" }!) == nil, "摘要格式错误时拒绝") check(PeerPairing.parse(mutatedPeer { $0["d"] = "zz" }) == nil, "摘要格式错误时拒绝")
check(PeerPairing.parse(mutatedPeer { $0["c"] = 0 }) == nil, "文件数为 0 时拒绝")
check(PeerPairing.newKey().count == 32, "新密钥为 32 字节") check(PeerPairing.newKey().count == 32, "新密钥为 32 字节")
check(PeerPairing.isValidInstance(PeerPairing.newInstance()), "新实例名合法") check(PeerPairing.isValidInstance(PeerPairing.newInstance()), "新实例名合法")
check(PeerPairing.newKey() != PeerPairing.newKey(), "密钥每次不同") check(PeerPairing.newKey() != PeerPairing.newKey(), "密钥每次不同")
// ---------------------------------------------------------------- P2P 传输 // ---------------------------------------------------------------- P2P 传输
section("隔空投送式点对点传输(TLS-PSK 真实握手)") section("隔空投送式点对点传输(TLS-PSK 真实握手,多文件)")
let peerDir = root.appendingPathComponent("peer", isDirectory: true) let peerDir = root.appendingPathComponent("peer", isDirectory: true)
try! FileManager.default.createDirectory(at: peerDir, withIntermediateDirectories: true) try! FileManager.default.createDirectory(at: peerDir, withIntermediateDirectories: true)
// 三个大小各异的文件:大文件跨多个数据帧,空文件是最容易写错的边界
let peerSources: [(String, Data)] = [
("大文件.bin", payload),
("小文件.txt", Data("QFT 隔空多文件".utf8)),
("空文件.dat", Data()),
]
let peerURLs = peerSources.map { name, data -> URL in
let url = root.appendingPathComponent(name)
try! data.write(to: url)
return url
}
let peerTotal = peerSources.reduce(UInt64(0)) { $0 + UInt64($1.1.count) }
let peerSemaphore = DispatchSemaphore(value: 0) let peerSemaphore = DispatchSemaphore(value: 0)
Task { Task {
defer { peerSemaphore.signal() } defer { peerSemaphore.signal() }
let sender = PeerSender(fileURL: sourceURL, deviceName: "发送端 iPhone") let sender = PeerSender(fileURLs: peerURLs, deviceName: "发送端 iPhone")
do { do {
let pairing = try sender.start() let pairing = try sender.start()
checkEqual(pairing.fileSize, UInt64(payloadSize), "配对码里的文件大小") checkEqual(pairing.fileCount, 3, "配对码里的文件数")
checkEqual(pairing.sha256, payloadHash, "配对码里的 SHA-256 由发送端实算") checkEqual(pairing.totalSize, peerTotal, "配对码里的总字节数由发送端实读")
let port = try await sender.listeningPort() let port = try await sender.listeningPort()
check(port > 0, "监听器就绪(端口 \(port))") check(port > 0, "监听器就绪(端口 \(port))")
@@ -324,14 +746,23 @@ Task {
async let sendSide: Void = sender.waitAndSend { _ in } async let sendSide: Void = sender.waitAndSend { _ in }
var peerFraction = 0.0 var peerFraction = 0.0
let saved = try await receiver.run { peerFraction = $0.fraction } var seenNames: [String] = []
let saved = try await receiver.run {
peerFraction = $0.progress.fraction
if seenNames.last != $0.fileName { seenNames.append($0.fileName) }
}
try await sendSide try await sendSide
let data = try Data(contentsOf: saved) checkEqual(saved.count, 3, "三个文件全部落盘")
checkEqual(data.count, payloadSize, "P2P 收到字节数一致") for (index, source) in peerSources.enumerated() where index < saved.count {
checkEqual(sha256Hex(data), payloadHash, "P2P 收到内容 SHA-256 一致") let data = try Data(contentsOf: saved[index])
checkEqual(sha256Hex(data), sha256Hex(source.1), "\(source.0) 内容一致")
checkEqual(saved[index].lastPathComponent, source.0, "\(source.0) 文件名一致")
}
check(peerFraction > 0.99, "P2P 进度回调抵达 100%") check(peerFraction > 0.99, "P2P 进度回调抵达 100%")
check(!FileManager.default.fileExists(atPath: saved.path + ".qftpart"), "P2P 临时文件已清理") check(seenNames.count >= 2, "进度回调报告了当前文件名(\(seenNames))")
check(!FileManager.default.fileExists(atPath: peerDir.appendingPathComponent("大文件.bin.qftpart").path),
"P2P 临时文件已清理")
} catch { } catch {
check(false, "P2P 传输失败:\(error.localizedDescription)") check(false, "P2P 传输失败:\(error.localizedDescription)")
} }
@@ -341,18 +772,48 @@ if peerSemaphore.wait(timeout: .now() + 60) == .timedOut {
check(false, "P2P 传输超时") check(false, "P2P 传输超时")
} }
// 清单摘要必须锁死「扫到的就是收到的」
let digestSemaphore = DispatchSemaphore(value: 0)
Task {
defer { digestSemaphore.signal() }
let sender = PeerSender(fileURLs: [peerURLs[1]], deviceName: "发送端")
do {
let pairing = try sender.start()
let port = try await sender.listeningPort()
let tampered = PeerPairing(version: 2, key: pairing.key, instance: pairing.instance,
senderName: pairing.senderName, fileCount: pairing.fileCount,
totalSize: pairing.totalSize,
queueDigest: String(repeating: "ab", count: 32),
previewName: pairing.previewName)
var receiver = PeerReceiver(pairing: tampered,
destinationDirectory: peerDir.appendingPathComponent("bad"))
receiver.directPort = port
async let sendSide: Void = sender.waitAndSend { _ in }
_ = try await receiver.run { _ in }
_ = try? await sendSide
check(false, "清单摘要不符本应被拒绝")
} catch {
check(true, "清单摘要不符时接收端拒绝:\(error.localizedDescription)")
}
sender.stop()
}
if digestSemaphore.wait(timeout: .now() + 30) == .timedOut {
check(false, "清单摘要用例超时")
}
// 错误密钥必须握手失败 // 错误密钥必须握手失败
let wrongKeySemaphore = DispatchSemaphore(value: 0) let wrongKeySemaphore = DispatchSemaphore(value: 0)
Task { Task {
defer { wrongKeySemaphore.signal() } defer { wrongKeySemaphore.signal() }
let sender = PeerSender(fileURL: sourceURL, deviceName: "发送端") let sender = PeerSender(fileURLs: [peerURLs[1]], deviceName: "发送端")
do { do {
let pairing = try sender.start() let pairing = try sender.start()
let port = try await sender.listeningPort() let port = try await sender.listeningPort()
let tampered = PeerPairing(version: 1, key: PeerPairing.newKey(), let tampered = PeerPairing(version: 2, key: PeerPairing.newKey(),
instance: pairing.instance, senderName: pairing.senderName, instance: pairing.instance, senderName: pairing.senderName,
fileName: pairing.fileName, fileSize: pairing.fileSize, fileCount: pairing.fileCount, totalSize: pairing.totalSize,
sha256: pairing.sha256) queueDigest: pairing.queueDigest,
previewName: pairing.previewName)
var receiver = PeerReceiver(pairing: tampered, destinationDirectory: peerDir) var receiver = PeerReceiver(pairing: tampered, destinationDirectory: peerDir)
receiver.directPort = port receiver.directPort = port
_ = try await receiver.run { _ in } _ = try await receiver.run { _ in }
+122 -76
View File
@@ -7,35 +7,62 @@
objects = { objects = {
/* Begin PBXBuildFile section */ /* Begin PBXBuildFile section */
0469B1106E6746B3BE56007D /* UploadClient.swift in Sources */ = {isa = PBXBuildFile; fileRef = B8FB8A4A9482DB8F1234AE39 /* UploadClient.swift */; };
38E462342111ACFA8775D17B /* PairingProtocol.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5459D124A555B0E4121361E5 /* PairingProtocol.swift */; };
4D2B05655C76F69F32349834 /* PeerPairing.swift in Sources */ = {isa = PBXBuildFile; fileRef = 06E1A38EC22BBFED928C8EB6 /* PeerPairing.swift */; };
554512A1FC8A6F66E2784787 /* QFTApp.swift in Sources */ = {isa = PBXBuildFile; fileRef = 453B172D654B3AEDE4E36D1E /* QFTApp.swift */; }; 554512A1FC8A6F66E2784787 /* QFTApp.swift in Sources */ = {isa = PBXBuildFile; fileRef = 453B172D654B3AEDE4E36D1E /* QFTApp.swift */; };
6B2EB3BCEDA4855168DB4ACE /* HostDiscovery.swift in Sources */ = {isa = PBXBuildFile; fileRef = 3776FFCC2817EF6BF3EEC4FD /* HostDiscovery.swift */; }; B4E05D8969A872E7A590A365 /* Compatibility.swift in Sources */ = {isa = PBXBuildFile; fileRef = F25DE43C8C35FBBC39CFAE7C /* Compatibility.swift */; };
78FD5CF5E04D7E2483B90BAA /* HomeView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0B6863D13BC7270D7FCE21E7 /* HomeView.swift */; }; 78FD5CF5E04D7E2483B90BAA /* HomeView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0B6863D13BC7270D7FCE21E7 /* HomeView.swift */; };
978F01FFFFF69591E44C8528 /* DownloadClient.swift in Sources */ = {isa = PBXBuildFile; fileRef = EAA81C375609633BD8DB42F3 /* DownloadClient.swift */; };
A80B2E7BF8035E27D115EF59 /* PeerLink.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8DD16686BB19417EDC0B611A /* PeerLink.swift */; };
BDCF0D82F0BD0328770A8ABD /* ScannerView.swift in Sources */ = {isa = PBXBuildFile; fileRef = F3B15455554D7647B44D5038 /* ScannerView.swift */; }; BDCF0D82F0BD0328770A8ABD /* ScannerView.swift in Sources */ = {isa = PBXBuildFile; fileRef = F3B15455554D7647B44D5038 /* ScannerView.swift */; };
C0C0B5440A627CE758643A9F /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = C628A05E9C83375781E165EB /* Assets.xcassets */; }; ECB8CA83A58D87B09DBD8456 /* OpticalReceiveView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 379C5E1471447756788B3DCB /* OpticalReceiveView.swift */; };
B6EE345C070779A6FA9E05BD /* DesktopConnectView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 17377DDB45B13CFF24D9DE86 /* DesktopConnectView.swift */; };
E26487D1146FDF6DD5F92D80 /* TransferModel.swift in Sources */ = {isa = PBXBuildFile; fileRef = 3017489412A6FCAE8995B32E /* TransferModel.swift */; }; E26487D1146FDF6DD5F92D80 /* TransferModel.swift in Sources */ = {isa = PBXBuildFile; fileRef = 3017489412A6FCAE8995B32E /* TransferModel.swift */; };
EE5510DAC5BBB7F9D41A8F26 /* Base64URL.swift in Sources */ = {isa = PBXBuildFile; fileRef = 848334DC6B2D30622C7E2A45 /* Base64URL.swift */; }; EE5510DAC5BBB7F9D41A8F26 /* Base64URL.swift in Sources */ = {isa = PBXBuildFile; fileRef = 848334DC6B2D30622C7E2A45 /* Base64URL.swift */; };
05D0F5A979043CC15FDB92A1 /* Base45.swift in Sources */ = {isa = PBXBuildFile; fileRef = C82077A38D3267866B46D57F /* Base45.swift */; };
E16607BF05B3D489F8160F53 /* Checksums.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0B95B8F711B9A81C40F6EA5A /* Checksums.swift */; };
38E462342111ACFA8775D17B /* PairingProtocol.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5459D124A555B0E4121361E5 /* PairingProtocol.swift */; };
D203744CF39C3E960AA3D110 /* ConnectCode.swift in Sources */ = {isa = PBXBuildFile; fileRef = 85FAE5724447E402C3FA71FE /* ConnectCode.swift */; };
6B2EB3BCEDA4855168DB4ACE /* HostDiscovery.swift in Sources */ = {isa = PBXBuildFile; fileRef = 3776FFCC2817EF6BF3EEC4FD /* HostDiscovery.swift */; };
9084065AA71609218458E3D2 /* RouteTable.swift in Sources */ = {isa = PBXBuildFile; fileRef = B207643EAE71F9AA0362E7A5 /* RouteTable.swift */; };
C159979E9327D8DA41698DDF /* PeerBrowser.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0F9B686A883A173DE95F4453 /* PeerBrowser.swift */; };
EDD8ED380FEC0D6DB51EB92D /* DedicatedNetwork.swift in Sources */ = {isa = PBXBuildFile; fileRef = 3FA6BAA6C4DC6219D1D3E19E /* DedicatedNetwork.swift */; };
978F01FFFFF69591E44C8528 /* DownloadClient.swift in Sources */ = {isa = PBXBuildFile; fileRef = EAA81C375609633BD8DB42F3 /* DownloadClient.swift */; };
63D746131835097DC3266B1F /* RangeDownloadClient.swift in Sources */ = {isa = PBXBuildFile; fileRef = F6EC40DBDBCC0770CECF2418 /* RangeDownloadClient.swift */; };
0469B1106E6746B3BE56007D /* UploadClient.swift in Sources */ = {isa = PBXBuildFile; fileRef = B8FB8A4A9482DB8F1234AE39 /* UploadClient.swift */; };
C3458DA9C8C1B3D9725058E3 /* OpticalProtocol.swift in Sources */ = {isa = PBXBuildFile; fileRef = FB34C3FAD2E55EC4567C6575 /* OpticalProtocol.swift */; };
BED5F82537793225773795D3 /* OpticalROI.swift in Sources */ = {isa = PBXBuildFile; fileRef = C916198C3640D3089E62DF79 /* OpticalROI.swift */; };
1171444EB6F281BEE7775354 /* OpticalAssembler.swift in Sources */ = {isa = PBXBuildFile; fileRef = 602872024DBA9B394B5574C6 /* OpticalAssembler.swift */; };
4D2B05655C76F69F32349834 /* PeerPairing.swift in Sources */ = {isa = PBXBuildFile; fileRef = 06E1A38EC22BBFED928C8EB6 /* PeerPairing.swift */; };
A80B2E7BF8035E27D115EF59 /* PeerLink.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8DD16686BB19417EDC0B611A /* PeerLink.swift */; };
C0C0B5440A627CE758643A9F /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = C628A05E9C83375781E165EB /* Assets.xcassets */; };
/* End PBXBuildFile section */ /* End PBXBuildFile section */
/* Begin PBXFileReference section */ /* Begin PBXFileReference section */
06E1A38EC22BBFED928C8EB6 /* PeerPairing.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PeerPairing.swift; sourceTree = "<group>"; };
0B6863D13BC7270D7FCE21E7 /* HomeView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = HomeView.swift; sourceTree = "<group>"; };
3017489412A6FCAE8995B32E /* TransferModel.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = TransferModel.swift; sourceTree = "<group>"; };
3776FFCC2817EF6BF3EEC4FD /* HostDiscovery.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = HostDiscovery.swift; sourceTree = "<group>"; };
453B172D654B3AEDE4E36D1E /* QFTApp.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = QFTApp.swift; sourceTree = "<group>"; };
5459D124A555B0E4121361E5 /* PairingProtocol.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PairingProtocol.swift; sourceTree = "<group>"; };
7E4A60F8CA5D515103446ED3 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
848334DC6B2D30622C7E2A45 /* Base64URL.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Base64URL.swift; sourceTree = "<group>"; };
8DD16686BB19417EDC0B611A /* PeerLink.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PeerLink.swift; sourceTree = "<group>"; };
928818DCDA72C62B2D8288D5 /* QFT.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = QFT.app; sourceTree = BUILT_PRODUCTS_DIR; }; 928818DCDA72C62B2D8288D5 /* QFT.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = QFT.app; sourceTree = BUILT_PRODUCTS_DIR; };
B8FB8A4A9482DB8F1234AE39 /* UploadClient.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = UploadClient.swift; sourceTree = "<group>"; }; 453B172D654B3AEDE4E36D1E /* QFTApp.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = QFTApp.swift; sourceTree = "<group>"; };
C628A05E9C83375781E165EB /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = "<group>"; }; F25DE43C8C35FBBC39CFAE7C /* Compatibility.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Compatibility.swift; sourceTree = "<group>"; };
EAA81C375609633BD8DB42F3 /* DownloadClient.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = DownloadClient.swift; sourceTree = "<group>"; }; 0B6863D13BC7270D7FCE21E7 /* HomeView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = HomeView.swift; sourceTree = "<group>"; };
F3B15455554D7647B44D5038 /* ScannerView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ScannerView.swift; sourceTree = "<group>"; }; F3B15455554D7647B44D5038 /* ScannerView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ScannerView.swift; sourceTree = "<group>"; };
379C5E1471447756788B3DCB /* OpticalReceiveView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = OpticalReceiveView.swift; sourceTree = "<group>"; };
17377DDB45B13CFF24D9DE86 /* DesktopConnectView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = DesktopConnectView.swift; sourceTree = "<group>"; };
3017489412A6FCAE8995B32E /* TransferModel.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = TransferModel.swift; sourceTree = "<group>"; };
848334DC6B2D30622C7E2A45 /* Base64URL.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Base64URL.swift; sourceTree = "<group>"; };
C82077A38D3267866B46D57F /* Base45.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Base45.swift; sourceTree = "<group>"; };
0B95B8F711B9A81C40F6EA5A /* Checksums.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Checksums.swift; sourceTree = "<group>"; };
5459D124A555B0E4121361E5 /* PairingProtocol.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PairingProtocol.swift; sourceTree = "<group>"; };
85FAE5724447E402C3FA71FE /* ConnectCode.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ConnectCode.swift; sourceTree = "<group>"; };
3776FFCC2817EF6BF3EEC4FD /* HostDiscovery.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = HostDiscovery.swift; sourceTree = "<group>"; };
B207643EAE71F9AA0362E7A5 /* RouteTable.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RouteTable.swift; sourceTree = "<group>"; };
0F9B686A883A173DE95F4453 /* PeerBrowser.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PeerBrowser.swift; sourceTree = "<group>"; };
3FA6BAA6C4DC6219D1D3E19E /* DedicatedNetwork.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = DedicatedNetwork.swift; sourceTree = "<group>"; };
EAA81C375609633BD8DB42F3 /* DownloadClient.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = DownloadClient.swift; sourceTree = "<group>"; };
F6EC40DBDBCC0770CECF2418 /* RangeDownloadClient.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RangeDownloadClient.swift; sourceTree = "<group>"; };
B8FB8A4A9482DB8F1234AE39 /* UploadClient.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = UploadClient.swift; sourceTree = "<group>"; };
FB34C3FAD2E55EC4567C6575 /* OpticalProtocol.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = OpticalProtocol.swift; sourceTree = "<group>"; };
C916198C3640D3089E62DF79 /* OpticalROI.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = OpticalROI.swift; sourceTree = "<group>"; };
602872024DBA9B394B5574C6 /* OpticalAssembler.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = OpticalAssembler.swift; sourceTree = "<group>"; };
06E1A38EC22BBFED928C8EB6 /* PeerPairing.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PeerPairing.swift; sourceTree = "<group>"; };
8DD16686BB19417EDC0B611A /* PeerLink.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PeerLink.swift; sourceTree = "<group>"; };
C628A05E9C83375781E165EB /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = "<group>"; };
7E4A60F8CA5D515103446ED3 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
478AB8DB09485855EA9372E3 /* QFT.entitlements */ = {isa = PBXFileReference; lastKnownFileType = text; path = QFT.entitlements; sourceTree = "<group>"; };
/* End PBXFileReference section */ /* End PBXFileReference section */
/* Begin PBXFrameworksBuildPhase section */ /* Begin PBXFrameworksBuildPhase section */
@@ -52,7 +79,10 @@
32AAB6DFB51CD1888CC4883B /* App */ = { 32AAB6DFB51CD1888CC4883B /* App */ = {
isa = PBXGroup; isa = PBXGroup;
children = ( children = (
F25DE43C8C35FBBC39CFAE7C /* Compatibility.swift */,
17377DDB45B13CFF24D9DE86 /* DesktopConnectView.swift */,
0B6863D13BC7270D7FCE21E7 /* HomeView.swift */, 0B6863D13BC7270D7FCE21E7 /* HomeView.swift */,
379C5E1471447756788B3DCB /* OpticalReceiveView.swift */,
453B172D654B3AEDE4E36D1E /* QFTApp.swift */, 453B172D654B3AEDE4E36D1E /* QFTApp.swift */,
F3B15455554D7647B44D5038 /* ScannerView.swift */, F3B15455554D7647B44D5038 /* ScannerView.swift */,
3017489412A6FCAE8995B32E /* TransferModel.swift */, 3017489412A6FCAE8995B32E /* TransferModel.swift */,
@@ -60,6 +90,30 @@
path = App; path = App;
sourceTree = "<group>"; sourceTree = "<group>";
}; };
EC599E8CF455428A5E3179CE /* Core */ = {
isa = PBXGroup;
children = (
C82077A38D3267866B46D57F /* Base45.swift */,
848334DC6B2D30622C7E2A45 /* Base64URL.swift */,
0B95B8F711B9A81C40F6EA5A /* Checksums.swift */,
85FAE5724447E402C3FA71FE /* ConnectCode.swift */,
3FA6BAA6C4DC6219D1D3E19E /* DedicatedNetwork.swift */,
EAA81C375609633BD8DB42F3 /* DownloadClient.swift */,
3776FFCC2817EF6BF3EEC4FD /* HostDiscovery.swift */,
602872024DBA9B394B5574C6 /* OpticalAssembler.swift */,
FB34C3FAD2E55EC4567C6575 /* OpticalProtocol.swift */,
C916198C3640D3089E62DF79 /* OpticalROI.swift */,
5459D124A555B0E4121361E5 /* PairingProtocol.swift */,
0F9B686A883A173DE95F4453 /* PeerBrowser.swift */,
8DD16686BB19417EDC0B611A /* PeerLink.swift */,
06E1A38EC22BBFED928C8EB6 /* PeerPairing.swift */,
F6EC40DBDBCC0770CECF2418 /* RangeDownloadClient.swift */,
B207643EAE71F9AA0362E7A5 /* RouteTable.swift */,
B8FB8A4A9482DB8F1234AE39 /* UploadClient.swift */,
);
path = Core;
sourceTree = "<group>";
};
36EDFB66685EBD501D3910CE /* QFT */ = { 36EDFB66685EBD501D3910CE /* QFT */ = {
isa = PBXGroup; isa = PBXGroup;
children = ( children = (
@@ -67,6 +121,7 @@
C628A05E9C83375781E165EB /* Assets.xcassets */, C628A05E9C83375781E165EB /* Assets.xcassets */,
EC599E8CF455428A5E3179CE /* Core */, EC599E8CF455428A5E3179CE /* Core */,
7E4A60F8CA5D515103446ED3 /* Info.plist */, 7E4A60F8CA5D515103446ED3 /* Info.plist */,
478AB8DB09485855EA9372E3 /* QFT.entitlements */,
); );
path = QFT; path = QFT;
sourceTree = "<group>"; sourceTree = "<group>";
@@ -87,26 +142,12 @@
name = Products; name = Products;
sourceTree = "<group>"; sourceTree = "<group>";
}; };
EC599E8CF455428A5E3179CE /* Core */ = {
isa = PBXGroup;
children = (
848334DC6B2D30622C7E2A45 /* Base64URL.swift */,
EAA81C375609633BD8DB42F3 /* DownloadClient.swift */,
3776FFCC2817EF6BF3EEC4FD /* HostDiscovery.swift */,
5459D124A555B0E4121361E5 /* PairingProtocol.swift */,
8DD16686BB19417EDC0B611A /* PeerLink.swift */,
06E1A38EC22BBFED928C8EB6 /* PeerPairing.swift */,
B8FB8A4A9482DB8F1234AE39 /* UploadClient.swift */,
);
path = Core;
sourceTree = "<group>";
};
/* End PBXGroup section */ /* End PBXGroup section */
/* Begin PBXNativeTarget section */ /* Begin PBXNativeTarget section */
497CBF7ECF21FFA362230876 /* QFT */ = { 497CBF7ECF21FFA362230876 /* QFT */ = {
isa = PBXNativeTarget; isa = PBXNativeTarget;
buildConfigurationList = A886B50DF087AEF7B87CDC65 /* Build configuration list for PBXNativeTarget "QFT" */; buildConfigurationList = A886B50DF087AEF7B87CDC65;
buildPhases = ( buildPhases = (
C2511B36F0F0E810A9E46328 /* Sources */, C2511B36F0F0E810A9E46328 /* Sources */,
019BAB185F97B56993A7087D /* Frameworks */, 019BAB185F97B56993A7087D /* Frameworks */,
@@ -136,7 +177,7 @@
}; };
}; };
}; };
buildConfigurationList = 26E84C2B3712F7DFAC8AD93F /* Build configuration list for PBXProject "QFT" */; buildConfigurationList = 26E84C2B3712F7DFAC8AD93F;
compatibilityVersion = "Xcode 14.0"; compatibilityVersion = "Xcode 14.0";
developmentRegion = en; developmentRegion = en;
hasScannedForEncodings = 0; hasScannedForEncodings = 0;
@@ -172,14 +213,27 @@
buildActionMask = 2147483647; buildActionMask = 2147483647;
files = ( files = (
554512A1FC8A6F66E2784787 /* QFTApp.swift in Sources */, 554512A1FC8A6F66E2784787 /* QFTApp.swift in Sources */,
B4E05D8969A872E7A590A365 /* Compatibility.swift in Sources */,
78FD5CF5E04D7E2483B90BAA /* HomeView.swift in Sources */, 78FD5CF5E04D7E2483B90BAA /* HomeView.swift in Sources */,
BDCF0D82F0BD0328770A8ABD /* ScannerView.swift in Sources */, BDCF0D82F0BD0328770A8ABD /* ScannerView.swift in Sources */,
ECB8CA83A58D87B09DBD8456 /* OpticalReceiveView.swift in Sources */,
B6EE345C070779A6FA9E05BD /* DesktopConnectView.swift in Sources */,
E26487D1146FDF6DD5F92D80 /* TransferModel.swift in Sources */, E26487D1146FDF6DD5F92D80 /* TransferModel.swift in Sources */,
EE5510DAC5BBB7F9D41A8F26 /* Base64URL.swift in Sources */, EE5510DAC5BBB7F9D41A8F26 /* Base64URL.swift in Sources */,
05D0F5A979043CC15FDB92A1 /* Base45.swift in Sources */,
E16607BF05B3D489F8160F53 /* Checksums.swift in Sources */,
38E462342111ACFA8775D17B /* PairingProtocol.swift in Sources */, 38E462342111ACFA8775D17B /* PairingProtocol.swift in Sources */,
D203744CF39C3E960AA3D110 /* ConnectCode.swift in Sources */,
6B2EB3BCEDA4855168DB4ACE /* HostDiscovery.swift in Sources */, 6B2EB3BCEDA4855168DB4ACE /* HostDiscovery.swift in Sources */,
9084065AA71609218458E3D2 /* RouteTable.swift in Sources */,
C159979E9327D8DA41698DDF /* PeerBrowser.swift in Sources */,
EDD8ED380FEC0D6DB51EB92D /* DedicatedNetwork.swift in Sources */,
978F01FFFFF69591E44C8528 /* DownloadClient.swift in Sources */, 978F01FFFFF69591E44C8528 /* DownloadClient.swift in Sources */,
63D746131835097DC3266B1F /* RangeDownloadClient.swift in Sources */,
0469B1106E6746B3BE56007D /* UploadClient.swift in Sources */, 0469B1106E6746B3BE56007D /* UploadClient.swift in Sources */,
C3458DA9C8C1B3D9725058E3 /* OpticalProtocol.swift in Sources */,
BED5F82537793225773795D3 /* OpticalROI.swift in Sources */,
1171444EB6F281BEE7775354 /* OpticalAssembler.swift in Sources */,
4D2B05655C76F69F32349834 /* PeerPairing.swift in Sources */, 4D2B05655C76F69F32349834 /* PeerPairing.swift in Sources */,
A80B2E7BF8035E27D115EF59 /* PeerLink.swift in Sources */, A80B2E7BF8035E27D115EF59 /* PeerLink.swift in Sources */,
); );
@@ -188,29 +242,6 @@
/* End PBXSourcesBuildPhase section */ /* End PBXSourcesBuildPhase section */
/* Begin XCBuildConfiguration section */ /* Begin XCBuildConfiguration section */
032222C0BAA33BC7119DFAF1 /* Release */ = {
isa = XCBuildConfiguration;
buildSettings = {
ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
CODE_SIGN_STYLE = Automatic;
CURRENT_PROJECT_VERSION = 46;
ENABLE_PREVIEWS = YES;
GENERATE_INFOPLIST_FILE = NO;
INFOPLIST_FILE = QFT/Info.plist;
IPHONEOS_DEPLOYMENT_TARGET = 18.6;
LD_RUNPATH_SEARCH_PATHS = (
"$(inherited)",
"@executable_path/Frameworks",
);
MARKETING_VERSION = 0.4.6;
PRODUCT_BUNDLE_IDENTIFIER = com.qft.transfer;
PRODUCT_NAME = "$(TARGET_NAME)";
SWIFT_EMIT_LOC_STRINGS = NO;
TARGETED_DEVICE_FAMILY = "1,2";
};
name = Release;
};
70DCC1EB255A5F3C8D9ED349 /* Debug */ = { 70DCC1EB255A5F3C8D9ED349 /* Debug */ = {
isa = XCBuildConfiguration; isa = XCBuildConfiguration;
buildSettings = { buildSettings = {
@@ -226,11 +257,8 @@
ENABLE_TESTABILITY = YES; ENABLE_TESTABILITY = YES;
GCC_NO_COMMON_BLOCKS = YES; GCC_NO_COMMON_BLOCKS = YES;
GCC_OPTIMIZATION_LEVEL = 0; GCC_OPTIMIZATION_LEVEL = 0;
GCC_PREPROCESSOR_DEFINITIONS = ( GCC_PREPROCESSOR_DEFINITIONS = "DEBUG=1 $(inherited)";
"DEBUG=1", IPHONEOS_DEPLOYMENT_TARGET = 15.0;
"$(inherited)",
);
IPHONEOS_DEPLOYMENT_TARGET = 18.6;
MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE; MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
MTL_FAST_MATH = YES; MTL_FAST_MATH = YES;
ONLY_ACTIVE_ARCH = YES; ONLY_ACTIVE_ARCH = YES;
@@ -241,6 +269,27 @@
}; };
name = Debug; name = Debug;
}; };
DB189EBE9D4E38495C3C7EF5 /* Debug */ = {
isa = XCBuildConfiguration;
buildSettings = {
ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
CODE_SIGN_ENTITLEMENTS = "$(QFT_ENTITLEMENTS)";
CODE_SIGN_STYLE = Automatic;
CURRENT_PROJECT_VERSION = 50;
ENABLE_PREVIEWS = YES;
GENERATE_INFOPLIST_FILE = NO;
INFOPLIST_FILE = QFT/Info.plist;
LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
MARKETING_VERSION = 0.5.0;
PRODUCT_BUNDLE_IDENTIFIER = com.qft.transfer;
PRODUCT_NAME = "$(TARGET_NAME)";
QFT_ENTITLEMENTS = "";
SWIFT_EMIT_LOC_STRINGS = NO;
TARGETED_DEVICE_FAMILY = "1,2";
};
name = Debug;
};
C3DCEEC1E0EB17A5583B8E94 /* Release */ = { C3DCEEC1E0EB17A5583B8E94 /* Release */ = {
isa = XCBuildConfiguration; isa = XCBuildConfiguration;
buildSettings = { buildSettings = {
@@ -255,10 +304,9 @@
ENABLE_NS_ASSERTIONS = NO; ENABLE_NS_ASSERTIONS = NO;
ENABLE_STRICT_OBJC_MSGSEND = YES; ENABLE_STRICT_OBJC_MSGSEND = YES;
GCC_NO_COMMON_BLOCKS = YES; GCC_NO_COMMON_BLOCKS = YES;
IPHONEOS_DEPLOYMENT_TARGET = 18.6; IPHONEOS_DEPLOYMENT_TARGET = 15.0;
MTL_ENABLE_DEBUG_INFO = NO; MTL_ENABLE_DEBUG_INFO = NO;
MTL_FAST_MATH = YES; MTL_FAST_MATH = YES;
ONLY_ACTIVE_ARCH = YES;
SDKROOT = iphoneos; SDKROOT = iphoneos;
SWIFT_COMPILATION_MODE = wholemodule; SWIFT_COMPILATION_MODE = wholemodule;
SWIFT_VERSION = 5.0; SWIFT_VERSION = 5.0;
@@ -266,33 +314,31 @@
}; };
name = Release; name = Release;
}; };
DB189EBE9D4E38495C3C7EF5 /* Debug */ = { 032222C0BAA33BC7119DFAF1 /* Release */ = {
isa = XCBuildConfiguration; isa = XCBuildConfiguration;
buildSettings = { buildSettings = {
ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor; ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
CODE_SIGN_ENTITLEMENTS = "$(QFT_ENTITLEMENTS)";
CODE_SIGN_STYLE = Automatic; CODE_SIGN_STYLE = Automatic;
CURRENT_PROJECT_VERSION = 46; CURRENT_PROJECT_VERSION = 50;
ENABLE_PREVIEWS = YES; ENABLE_PREVIEWS = YES;
GENERATE_INFOPLIST_FILE = NO; GENERATE_INFOPLIST_FILE = NO;
INFOPLIST_FILE = QFT/Info.plist; INFOPLIST_FILE = QFT/Info.plist;
IPHONEOS_DEPLOYMENT_TARGET = 18.6; LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
LD_RUNPATH_SEARCH_PATHS = ( MARKETING_VERSION = 0.5.0;
"$(inherited)",
"@executable_path/Frameworks",
);
MARKETING_VERSION = 0.4.6;
PRODUCT_BUNDLE_IDENTIFIER = com.qft.transfer; PRODUCT_BUNDLE_IDENTIFIER = com.qft.transfer;
PRODUCT_NAME = "$(TARGET_NAME)"; PRODUCT_NAME = "$(TARGET_NAME)";
QFT_ENTITLEMENTS = "";
SWIFT_EMIT_LOC_STRINGS = NO; SWIFT_EMIT_LOC_STRINGS = NO;
TARGETED_DEVICE_FAMILY = "1,2"; TARGETED_DEVICE_FAMILY = "1,2";
}; };
name = Debug; name = Release;
}; };
/* End XCBuildConfiguration section */ /* End XCBuildConfiguration section */
/* Begin XCConfigurationList section */ /* Begin XCConfigurationList section */
26E84C2B3712F7DFAC8AD93F /* Build configuration list for PBXProject "QFT" */ = { 26E84C2B3712F7DFAC8AD93F = {
isa = XCConfigurationList; isa = XCConfigurationList;
buildConfigurations = ( buildConfigurations = (
70DCC1EB255A5F3C8D9ED349 /* Debug */, 70DCC1EB255A5F3C8D9ED349 /* Debug */,
@@ -301,7 +347,7 @@
defaultConfigurationIsVisible = 0; defaultConfigurationIsVisible = 0;
defaultConfigurationName = Release; defaultConfigurationName = Release;
}; };
A886B50DF087AEF7B87CDC65 /* Build configuration list for PBXNativeTarget "QFT" */ = { A886B50DF087AEF7B87CDC65 = {
isa = XCConfigurationList; isa = XCConfigurationList;
buildConfigurations = ( buildConfigurations = (
DB189EBE9D4E38495C3C7EF5 /* Debug */, DB189EBE9D4E38495C3C7EF5 /* Debug */,
+69
View File
@@ -0,0 +1,69 @@
import SwiftUI
import UIKit
/// iOS 版本兼容层。
///
/// 部署目标是 **iOS 15.0**——对应 iPhone 6s(2015)及以后,和 Android 端
/// `minSdk 24`(Android 7.0,2016)覆盖的机型年代大致相当。再往下走不动了:
/// `URLSession` 的 async 接口是 iOS 15 才有的,低于 15 就要把所有网络代码
/// 改回 completion handler,代价与收益不成比例。
///
/// 新系统上的更好实现照样用,只是要在这里分叉,而不是把整个 App 的
/// 部署目标顶上去。
/// `NavigationStack` 是 iOS 16 才有的。
struct QFTNavigationContainer<Content: View>: View {
@ViewBuilder let content: Content
var body: some View {
if #available(iOS 16.0, *) {
NavigationStack { content }
} else {
// iOS 15 上 NavigationView 默认在 iPad 会变成分栏,强制单栏
NavigationView { content }
.navigationViewStyle(.stack)
}
}
}
/// `ShareLink` 是 iOS 16 才有的;iOS 15 上退回 `UIActivityViewController`。
struct QFTShareButton<Label: View>: View {
let url: URL
@ViewBuilder let label: Label
@State private var presenting = false
var body: some View {
if #available(iOS 16.0, *) {
ShareLink(item: url) { label }
} else {
Button { presenting = true } label: { label }
.buttonStyle(.plain)
.sheet(isPresented: $presenting) { ActivitySheet(items: [url]) }
}
}
}
private struct ActivitySheet: UIViewControllerRepresentable {
let items: [Any]
func makeUIViewController(context: Context) -> UIActivityViewController {
UIActivityViewController(activityItems: items, applicationActivities: nil)
}
func updateUIViewController(_ controller: UIActivityViewController, context: Context) {}
}
/// `LabeledContent` 是 iOS 16 才有的。
struct QFTLabeledRow<Value: View>: View {
let title: String
@ViewBuilder let value: Value
var body: some View {
HStack(alignment: .firstTextBaseline) {
Text(title)
Spacer(minLength: 12)
value.multilineTextAlignment(.trailing)
}
}
}
+136
View File
@@ -0,0 +1,136 @@
import SwiftUI
/// 「连接附近的电脑」。
///
/// 电脑之间没有摄像头,所以桌面端进入「我要接收」后显示的是**连接码**,
/// 地址和配对秘密都编在那串码里。iPhone 走同一条路:广播列出附近的电脑
/// (只是为了让用户确认「就是这台」),真正建立会话靠输入那串码。
///
/// 明确的边界:连接码换来的是**接收端**的会话,因此这条路径只能
/// 「把文件发到电脑」。要让电脑下发文件,请在电脑上选好文件后扫它的二维码。
struct NearbyComputersView: View {
let onConnect: (String, DesktopPeer?) -> Void
let onCancel: () -> Void
@State private var peers: [DesktopPeer] = []
@State private var selected: DesktopPeer?
@State private var code = ""
@State private var searching = false
var body: some View {
List {
Section {
if peers.isEmpty {
HStack {
Text(searching ? "正在搜索…" : "没有搜索到电脑")
.foregroundStyle(.secondary)
Spacer()
if searching { ProgressView() }
}
} else {
ForEach(peers) { peer in
Button {
selected = (selected == peer) ? nil : peer
} label: {
HStack {
Image(systemName: peer.platform == "macos"
? "laptopcomputer" : "desktopcomputer")
VStack(alignment: .leading, spacing: 2) {
Text(peer.name).font(.body)
Text("\(peer.platformLabel) · \(peer.address)")
.font(.caption).foregroundStyle(.secondary)
}
Spacer()
if selected == peer {
Image(systemName: "checkmark").foregroundStyle(.tint)
} else if peer.ready {
Text("等待接收").font(.caption2).foregroundStyle(.green)
}
}
}
.buttonStyle(.plain)
}
}
} header: {
Text("附近的电脑")
} footer: {
Text("广播只覆盖同一个网段。跨网段或开了 AP 隔离的 Wi-Fi 上搜不到对方,直接输连接码即可——地址就在码里。")
}
Section {
TextField("例如 K7M2-9X4P-QR3T", text: $code)
.textInputAutocapitalization(.characters)
.autocorrectionDisabled()
.font(.body.monospaced())
Button("连接并选择文件") {
onConnect(code, selected)
}
.disabled(code.trimmingCharacters(in: .whitespaces).count < 8)
} header: {
Text("连接码")
} footer: {
Text("在电脑上打开 QFT →「电脑 ↔ 电脑」→「我要接收」,屏幕上那串码就是它。输错 5 次电脑会作废该码,需要重新启动接收。")
}
Section {
Button("返回", role: .cancel) { onCancel() }
}
}
.refreshable { await search() }
.task { await search() }
}
private func search() async {
searching = true
peers = await PeerBrowser.browse()
searching = false
}
}
/// 专用网络的手动加入引导。
///
/// `NEHotspotConfiguration` 需要 HotspotConfiguration entitlement;拿不到时
/// **不假装成功**,而是把 SSID/密码摆出来让用户自己连——这一步在
/// Windows 的 QFT Direct 上是必需的,因为那张网上电脑才是网关。
struct ManualJoinView: View {
let wifi: WifiCredentials
let onContinue: () -> Void
let onCancel: () -> Void
var body: some View {
List {
Section {
QFTLabeledRow(title: "网络名称") {
Text(wifi.ssid).font(.body.monospaced()).textSelection(.enabled)
}
QFTLabeledRow(title: "密码") {
Text(wifi.passphrase).font(.body.monospaced()).textSelection(.enabled)
}
Button {
UIPasteboard.general.string = wifi.passphrase
} label: {
Label("复制密码", systemImage: "doc.on.doc")
}
Button {
guard let url = URL(string: UIApplication.openSettingsURLString) else { return }
UIApplication.shared.open(url)
} label: {
Label("打开「设置」", systemImage: "gear")
}
} header: {
Text("请先加入电脑的专用 Wi-Fi")
} footer: {
Text("这台 iPhone 上的 QFT 没有自动加入 Wi-Fi 的能力(需要 Hotspot Configuration entitlement),"
+ "所以要手动连一次。这张网没有互联网,系统可能提示「未连接到互联网」,是正常的。")
}
Section {
Button("我已连上,继续") { onContinue() }
.buttonStyle(.borderedProminent)
Button("取消", role: .cancel) { onCancel() }
}
}
}
}
+77 -24
View File
@@ -1,4 +1,5 @@
import SwiftUI import SwiftUI
import Combine
import UniformTypeIdentifiers import UniformTypeIdentifiers
struct HomeView: View { struct HomeView: View {
@@ -8,13 +9,14 @@ struct HomeView: View {
private enum PickPurpose: Equatable { private enum PickPurpose: Equatable {
case peerSend case peerSend
case uploadToPC(PairingPayload) case uploadToPC(PairingPayload)
case uploadToDesktop(DesktopSession)
} }
@StateObject private var model = TransferModel() @StateObject private var model = TransferModel()
@State private var pickPurpose: PickPurpose? @State private var pickPurpose: PickPurpose?
var body: some View { var body: some View {
NavigationStack { QFTNavigationContainer {
content content
.navigationTitle("QFT 快传") .navigationTitle("QFT 快传")
.navigationBarTitleDisplayMode(.inline) .navigationBarTitleDisplayMode(.inline)
@@ -23,25 +25,37 @@ struct HomeView: View {
ScannerView(onFound: { model.handleScanned($0) }, onCancel: { model.cancel() }) ScannerView(onFound: { model.handleScanned($0) }, onCancel: { model.cancel() })
.ignoresSafeArea() .ignoresSafeArea()
} }
.fullScreenCover(isPresented: isOptical) {
OpticalReceiveScreen(
destinationDirectory: (try? DownloadClient.defaultDestinationDirectory())
?? FileManager.default.temporaryDirectory,
onFinished: { model.finishOptical($0) },
onCancel: { model.cancel() })
}
.fileImporter(isPresented: isPicking, .fileImporter(isPresented: isPicking,
allowedContentTypes: [UTType.item], allowsMultipleSelection: false) { result in allowedContentTypes: [UTType.item], allowsMultipleSelection: true) { result in
let purpose = pickPurpose let purpose = pickPurpose
pickPurpose = nil pickPurpose = nil
guard case .success(let urls) = result, let url = urls.first else { guard case .success(let urls) = result, !urls.isEmpty else {
model.reset() model.reset()
return return
} }
switch purpose { switch purpose {
case .peerSend: model.startPeerSend(fileURL: url) case .peerSend: model.startPeerSend(fileURLs: urls)
case .uploadToPC(let pairing): model.startUpload(pairing, fileURL: url) case .uploadToPC(let pairing): model.startUpload(pairing, fileURLs: urls)
case .uploadToDesktop(let session): model.startUpload(to: session, fileURLs: urls)
case nil: break case nil: break
} }
} }
.onAppear { model.refreshReceivedFiles() } .onAppear { model.refreshReceivedFiles() }
.onChange(of: model.stage) { _, stage in // 用 onReceive 而不是 onChange:两参数的 onChange 是 iOS 17 才有的,
// 扫到 QFTPAIR2 之后才知道要选文件,所以选择器由 stage 驱动 // 单参数版本在 iOS 17 上又被标了废弃
if case .pickFileForUpload(let pairing) = stage { .onReceive(model.$stage) { stage in
pickPurpose = .uploadToPC(pairing) // 扫到码/配对成功之后才知道要选文件,所以选择器由 stage 驱动
switch stage {
case .pickFilesForUpload(let pairing): pickPurpose = .uploadToPC(pairing)
case .pickFilesForDesktop(let session): pickPurpose = .uploadToDesktop(session)
default: break
} }
} }
} }
@@ -50,6 +64,10 @@ struct HomeView: View {
Binding(get: { model.stage == .scanning }, set: { if !$0 { model.cancel() } }) Binding(get: { model.stage == .scanning }, set: { if !$0 { model.cancel() } })
} }
private var isOptical: Binding<Bool> {
Binding(get: { model.stage == .optical }, set: { if !$0 { model.cancel() } })
}
private var isPicking: Binding<Bool> { private var isPicking: Binding<Bool> {
Binding(get: { pickPurpose != nil }, set: { if !$0 { pickPurpose = nil } }) Binding(get: { pickPurpose != nil }, set: { if !$0 { pickPurpose = nil } })
} }
@@ -57,11 +75,22 @@ struct HomeView: View {
@ViewBuilder @ViewBuilder
private var content: some View { private var content: some View {
switch model.stage { switch model.stage {
case .idle, .scanning, .pickFileForUpload: case .idle, .scanning, .optical, .pickFilesForUpload, .pickFilesForDesktop:
landing landing
case .nearby:
NearbyComputersView(
onConnect: { code, peer in model.connect(code: code, peer: peer) },
onCancel: { model.reset() })
case .manualJoin(let wifi, let pairing):
ManualJoinView(wifi: wifi,
onContinue: { model.manualJoinCompleted(pairing) },
onCancel: { model.cancel() })
case .connecting(let message): case .connecting(let message):
StatusCard(icon: "antenna.radiowaves.left.and.right", title: message) { StatusCard(icon: "antenna.radiowaves.left.and.right", title: message) {
ProgressView() ProgressView()
if let detail = model.detail {
Text(detail).font(.footnote).foregroundStyle(.secondary)
}
Button("取消", role: .cancel) { model.cancel() } Button("取消", role: .cancel) { model.cancel() }
} }
case .running(let message): case .running(let message):
@@ -74,15 +103,20 @@ struct HomeView: View {
} else { } else {
ProgressView() ProgressView()
} }
if let detail = model.detail {
Text(detail).font(.footnote).foregroundStyle(.secondary).lineLimit(1)
}
Button("取消", role: .cancel) { model.cancel() } Button("取消", role: .cancel) { model.cancel() }
} }
case .showingPeerCode(let pairing): case .showingPeerCode(let pairing):
peerCode(pairing) peerCode(pairing)
case .finished(let message, let url): case .finished(let message, let urls):
StatusCard(icon: "checkmark.circle.fill", title: message) { StatusCard(icon: "checkmark.circle.fill", title: message) {
if let url { ForEach(Array(urls.prefix(5)), id: \.self) { url in
Text(url.lastPathComponent).font(.footnote).foregroundStyle(.secondary) QFTShareButton(url: url) {
ShareLink(item: url) { Label("分享", systemImage: "square.and.arrow.up") } Label(url.lastPathComponent, systemImage: "square.and.arrow.up")
.font(.footnote).lineLimit(1)
}
} }
Button("完成") { model.reset() }.buttonStyle(.borderedProminent) Button("完成") { model.reset() }.buttonStyle(.borderedProminent)
} }
@@ -97,23 +131,36 @@ struct HomeView: View {
private var landing: some View { private var landing: some View {
List { List {
Section { Section("和电脑互传") {
ActionRow(icon: "qrcode.viewfinder", title: "扫码", ActionRow(icon: "qrcode.viewfinder", title: "扫电脑上的二维码",
detail: "扫电脑上的二维码收发文件,或扫另一台 iPhone 的码接收") { detail: "局域网直传;Windows 的专用网络(QFT Direct)也走这里") {
model.beginScan() model.beginScan()
} }
ActionRow(icon: "iphone.gen3.radiowaves.left.and.right", title: "发给附近的 iPhone", ActionRow(icon: "desktopcomputer", title: "连接附近的电脑",
detail: "选文件后显示二维码,对方扫一下即可,无需连同一个 Wi-Fi") { detail: "Mac / Windows 进入「我要接收」后,输入屏幕上的连接码即可发送文件") {
model.beginNearby()
}
ActionRow(icon: "camera.viewfinder", title: "光学接收(不用网络)",
detail: "对准电脑的「光学传输」页,文件只经过屏幕和摄像头") {
model.beginOptical()
}
}
Section("和 iPhone 互传") {
ActionRow(icon: "iphone.radiowaves.left.and.right", title: "发给附近的 iPhone",
detail: "可多选文件;显示二维码,对方扫一下即可,无需连同一个 Wi-Fi") {
pickPurpose = .peerSend pickPurpose = .peerSend
} }
} footer: { ActionRow(icon: "qrcode.viewfinder", title: "接收 iPhone 发来的文件",
Text("与电脑互传需要手机和电脑连在同一个 Wi-Fi。iPhone 之间使用点对点直连,不经过路由器。") detail: "扫对方屏幕上的二维码") {
model.beginScan()
}
} }
if !model.receivedFiles.isEmpty { if !model.receivedFiles.isEmpty {
Section("已接收") { Section("已接收") {
ForEach(model.receivedFiles, id: \.self) { url in ForEach(model.receivedFiles, id: \.self) { url in
ShareLink(item: url) { QFTShareButton(url: url) {
Label(url.lastPathComponent, systemImage: "doc") Label(url.lastPathComponent, systemImage: "doc")
.lineLimit(1) .lineLimit(1)
} }
@@ -138,8 +185,11 @@ struct HomeView: View {
.clipShape(RoundedRectangle(cornerRadius: 16)) .clipShape(RoundedRectangle(cornerRadius: 16))
} }
VStack(spacing: 4) { VStack(spacing: 4) {
Text(pairing.fileName).font(.subheadline).lineLimit(1) Text(pairing.fileCount == 1
Text(TransferProgress.readable(pairing.fileSize)) ? pairing.previewName
: "\(pairing.previewName) 等 \(pairing.fileCount) 个文件")
.font(.subheadline).lineLimit(1)
Text(TransferProgress.readable(pairing.totalSize))
.font(.footnote).foregroundStyle(.secondary) .font(.footnote).foregroundStyle(.secondary)
} }
if let progress = model.progress { if let progress = model.progress {
@@ -147,6 +197,9 @@ struct HomeView: View {
.padding(.horizontal, 40) .padding(.horizontal, 40)
Text("\(progress.readableSize) · \(progress.readableRate)") Text("\(progress.readableSize) · \(progress.readableRate)")
.font(.footnote.monospacedDigit()).foregroundStyle(.secondary) .font(.footnote.monospacedDigit()).foregroundStyle(.secondary)
if let detail = model.detail {
Text(detail).font(.caption).foregroundStyle(.secondary).lineLimit(1)
}
} else { } else {
Label("等待对方扫码…", systemImage: "hourglass") Label("等待对方扫码…", systemImage: "hourglass")
.font(.footnote).foregroundStyle(.secondary) .font(.footnote).foregroundStyle(.secondary)
+460
View File
@@ -0,0 +1,460 @@
import SwiftUI
import Combine
import AVFoundation
import Vision
/// 光学接收:电脑屏幕 → iPhone 摄像头。
///
/// 这条链路上**文件数据完全不经过网络**——没有 Wi-Fi、没有蓝牙、没有局域网,
/// 只有屏幕上的二维码和这台 iPhone 的摄像头。因此它也是唯一一条在
/// 「电脑不能联网、也不允许接任何网络」的场合仍然可用的路径。
///
/// 与 Android 端同一套状态机:居中搜索 → 锁定 ROI → 丢失逐级放大 → 重新搜索。
struct OpticalReceiveScreen: View {
@StateObject private var model: OpticalReceiveModel
let onFinished: ([URL]) -> Void
let onCancel: () -> Void
init(destinationDirectory: URL,
onFinished: @escaping ([URL]) -> Void,
onCancel: @escaping () -> Void) {
_model = StateObject(wrappedValue: OpticalReceiveModel(destinationDirectory: destinationDirectory))
self.onFinished = onFinished
self.onCancel = onCancel
}
var body: some View {
ZStack {
OpticalCameraView(
onFrame: { text, decodeMS in model.accept(text: text, decodeMilliseconds: decodeMS) },
onMiss: { decodeMS in model.recordMiss(decodeMilliseconds: decodeMS) })
.ignoresSafeArea()
VStack {
header
Spacer()
footer
}
.padding()
}
.background(.black)
.onReceive(model.$savedFiles) { files in
guard !files.isEmpty else { return }
UINotificationFeedbackGenerator().notificationOccurred(.success)
}
}
private var header: some View {
VStack(spacing: 6) {
if let manifest = model.manifest {
Text(manifest.fileName)
.font(.headline).lineLimit(1)
Text("来自 \(manifest.senderDevice) · \(TransferProgress.readable(manifest.fileSize))")
.font(.caption)
ProgressView(value: model.fraction)
.tint(.green)
Text("已收 \(model.receivedChunks)/\(model.totalChunks) 片")
.font(.caption.monospacedDigit())
} else {
Text("把 iPhone 对准电脑上的二维码")
.font(.headline)
Text("电脑端「光学传输」页会循环播放整份文件,收齐即自动保存")
.font(.caption).multilineTextAlignment(.center)
}
if let message = model.message {
Text(message).font(.caption).foregroundStyle(.orange)
.multilineTextAlignment(.center)
}
}
.foregroundStyle(.white)
.padding()
.background(.black.opacity(0.55), in: RoundedRectangle(cornerRadius: 14))
}
private var footer: some View {
VStack(spacing: 10) {
// 决定传输时间的是「新帧/s」,不是「解码/s」:屏幕上同一帧会被
// 连续拍到很多次。用户据此在电脑端选 30 / 45 / 60 FPS。
Text(model.statsLine)
.font(.caption2.monospacedDigit())
.foregroundStyle(.white.opacity(0.85))
HStack(spacing: 16) {
Button("重新开始") { model.reset() }
.buttonStyle(.bordered)
if model.savedFiles.isEmpty {
Button("退出", role: .cancel) { onCancel() }
.buttonStyle(.borderedProminent)
} else {
Button("完成(\(model.savedFiles.count) 个文件)") { onFinished(model.savedFiles) }
.buttonStyle(.borderedProminent)
}
}
}
.padding()
.background(.black.opacity(0.55), in: RoundedRectangle(cornerRadius: 14))
}
}
// MARK: - 模型
@MainActor
final class OpticalReceiveModel: ObservableObject {
@Published private(set) var manifest: OpticalManifest?
@Published private(set) var receivedChunks = 0
@Published private(set) var totalChunks = 0
@Published private(set) var message: String?
@Published private(set) var savedFiles: [URL] = []
@Published private(set) var statsLine = "相机 -- FPS · 解码 --/s · 新帧 --/s"
/// 装配器和统计都是自带锁的,可以直接被相机队列调用;
/// 声明成 `nonisolated let` 就不必为了拿它们跳一次主线程——
/// 60 FPS 下每帧多一次线程切换是实打实的开销。
private nonisolated let assembler: OpticalAssembler
private nonisolated let stats = OpticalStats()
private nonisolated let relay: EventRelay
private var lastStatsRefresh = Date.distantPast
/// 装配器要在 init 里就拿到回调,而那时 self 还不完整,
/// 用一个中转对象把两者接起来。
private final class EventRelay: @unchecked Sendable {
private let lock = NSLock()
private var handler: ((OpticalReceiveEvent) -> Void)?
func setHandler(_ handler: @escaping (OpticalReceiveEvent) -> Void) {
lock.lock(); defer { lock.unlock() }
self.handler = handler
}
func emit(_ event: OpticalReceiveEvent) {
lock.lock()
let handler = self.handler
lock.unlock()
handler?(event)
}
}
init(destinationDirectory: URL) {
let relay = EventRelay()
self.relay = relay
self.assembler = OpticalAssembler(destinationDirectory: destinationDirectory) { event in
relay.emit(event)
}
relay.setHandler { [weak self] event in
Task { @MainActor in self?.handle(event) }
}
}
var fraction: Double {
totalChunks == 0 ? 0 : Double(receivedChunks) / Double(totalChunks)
}
nonisolated func accept(text: String, decodeMilliseconds: Double) {
let acceptance = assembler.accept(text: text)
stats.recordFrame(decodeMilliseconds: decodeMilliseconds, acceptance: acceptance)
Task { @MainActor in self.refreshStats() }
}
nonisolated func recordMiss(decodeMilliseconds: Double) {
stats.recordFrame(decodeMilliseconds: decodeMilliseconds, acceptance: nil)
Task { @MainActor in self.refreshStats() }
}
func reset() {
assembler.reset()
manifest = nil
receivedChunks = 0
totalChunks = 0
message = nil
}
private func refreshStats() {
guard Date().timeIntervalSince(lastStatsRefresh) > 0.3 else { return }
lastStatsRefresh = Date()
let snapshot = stats.snapshot()
statsLine = String(format: "相机 %.0f FPS · 解码 %.1f/s · 新帧 %.1f/s · %.1f ms",
snapshot.camera, snapshot.decoded, snapshot.fresh, snapshot.decodeMS)
}
private func handle(_ event: OpticalReceiveEvent) {
switch event {
case .started(let manifest):
self.manifest = manifest
self.receivedChunks = 0
self.totalChunks = Int(manifest.totalChunks)
self.message = nil
case .progress(let manifest, let received, let total):
self.manifest = manifest
self.receivedChunks = received
self.totalChunks = total
case .completed(_, let url):
self.savedFiles.append(url)
self.manifest = nil
self.receivedChunks = 0
self.totalChunks = 0
self.message = "已保存 \(url.lastPathComponent),可以继续接收下一个文件"
case .failed(let text):
self.message = text
}
}
}
// MARK: - 相机
/// 高频解码相机。
///
/// 与配对码扫描(`ScannerView`)的区别:那个只需要认一张静止的码,用
/// `AVCaptureMetadataOutput` 就够;这里要在 30~60 FPS 的动态码上尽可能多地
/// 解出**不同**的帧,必须自己拿到像素、锁 ROI、并把解码限制在那一小块上。
struct OpticalCameraView: UIViewControllerRepresentable {
let onFrame: (String, Double) -> Void
let onMiss: (Double) -> Void
func makeUIViewController(context: Context) -> OpticalCameraController {
let controller = OpticalCameraController()
controller.onFrame = onFrame
controller.onMiss = onMiss
return controller
}
func updateUIViewController(_ controller: OpticalCameraController, context: Context) {}
}
final class OpticalCameraController: UIViewController, AVCaptureVideoDataOutputSampleBufferDelegate {
var onFrame: ((String, Double) -> Void)?
var onMiss: ((Double) -> Void)?
private let session = AVCaptureSession()
private let sampleQueue = DispatchQueue(label: "qft.optical.capture", qos: .userInitiated)
private var preview: AVCaptureVideoPreviewLayer?
private let lockLayer = CAShapeLayer()
private var device: AVCaptureDevice?
private var roi = OpticalROI()
private lazy var request: VNDetectBarcodesRequest = {
let request = VNDetectBarcodesRequest()
request.symbologies = [.qr]
return request
}()
private var lastFocusAt = Date.distantPast
override func viewDidLoad() {
super.viewDidLoad()
view.backgroundColor = .black
configureSession()
configureOverlay()
}
private func configureSession() {
session.beginConfiguration()
session.sessionPreset = .inputPriority // 帧率与格式由下面显式挑选
guard let device = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .back),
let input = try? AVCaptureDeviceInput(device: device),
session.canAddInput(input) else {
session.commitConfiguration()
return
}
session.addInput(input)
self.device = device
let output = AVCaptureVideoDataOutput()
// 追不上就丢,不要排队播放过时的相机帧——屏幕上的码早就换过了
output.alwaysDiscardsLateVideoFrames = true
output.videoSettings = [
kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_420YpCbCr8BiPlanarFullRange,
]
output.setSampleBufferDelegate(self, queue: sampleQueue)
if session.canAddOutput(output) { session.addOutput(output) }
if let connection = output.connection(with: .video) {
// 刻意**不**在采集连接上旋转:旋转会在管线里多做一次整帧拷贝。
// 竖屏的方向修正交给 Vision 的 .right,预览层单独转。
if connection.isVideoStabilizationSupported {
// 防抖会引入额外延迟与形变,对静止拍屏毫无价值
connection.preferredVideoStabilizationMode = .off
}
}
configureFormat(device)
session.commitConfiguration()
let layer = AVCaptureVideoPreviewLayer(session: session)
layer.videoGravity = .resizeAspectFill
layer.frame = view.bounds
if let connection = layer.connection {
// iOS 17 换了 API,但这个 App 要一直支持到 iOS 15
if #available(iOS 17.0, *) {
if connection.isVideoRotationAngleSupported(90) { connection.videoRotationAngle = 90 }
} else if connection.isVideoOrientationSupported {
connection.videoOrientation = .portrait
}
}
view.layer.insertSublayer(layer, at: 0)
preview = layer
}
/// 挑一个「分辨率够、帧率够」的格式。
///
/// 二维码识别的真正约束是**每模块像素数**,所以不能一味降分辨率;
/// 但帧率上不去,「有效新帧/s」就封顶了。折中:在支持 ≥60 FPS 的格式里
/// 取分辨率最高的;没有这种格式时,退而求其次取帧率最高的。
private func configureFormat(_ device: AVCaptureDevice) {
var best: (format: AVCaptureDevice.Format, fps: Double)?
for format in device.formats {
let dimensions = CMVideoFormatDescriptionGetDimensions(format.formatDescription)
guard dimensions.width <= 1920 else { continue }
let maxRate = format.videoSupportedFrameRateRanges.map(\.maxFrameRate).max() ?? 0
guard maxRate >= 30 else { continue }
if let current = best {
let currentDimensions = CMVideoFormatDescriptionGetDimensions(current.format.formatDescription)
let currentFast = current.fps >= 60
let candidateFast = maxRate >= 60
if candidateFast != currentFast {
if candidateFast { best = (format, maxRate) }
} else if dimensions.width > currentDimensions.width {
best = (format, maxRate)
}
} else {
best = (format, maxRate)
}
}
guard let chosen = best, (try? device.lockForConfiguration()) != nil else { return }
defer { device.unlockForConfiguration() }
device.activeFormat = chosen.format
let target = min(chosen.fps, 60)
let duration = CMTime(value: 1, timescale: CMTimeScale(target.rounded()))
device.activeVideoMinFrameDuration = duration
device.activeVideoMaxFrameDuration = duration
if device.isFocusModeSupported(.continuousAutoFocus) {
device.focusMode = .continuousAutoFocus
}
if device.isExposureModeSupported(.continuousAutoExposure) {
device.exposureMode = .continuousAutoExposure
}
// HDR 会在部分机型上把帧率对半砍,而拍屏幕根本用不到宽动态
if device.activeFormat.isVideoHDRSupported {
device.automaticallyAdjustsVideoHDREnabled = false
device.isVideoHDREnabled = false
}
}
private func configureOverlay() {
lockLayer.fillColor = UIColor.clear.cgColor
lockLayer.lineWidth = 2
lockLayer.strokeColor = UIColor.white.withAlphaComponent(0.6).cgColor
view.layer.addSublayer(lockLayer)
}
// MARK: - 每帧
func captureOutput(_ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer,
from connection: AVCaptureConnection) {
guard let buffer = CMSampleBufferGetImageBuffer(sampleBuffer) else { return }
let width = CVPixelBufferGetWidth(buffer)
let height = CVPixelBufferGetHeight(buffer)
// 竖屏 + 后摄:Vision 按 .right 旋转后画面的宽高互换,
// 归一化 ROI 要按旋转**之后**的宽高比才能修成像素正方形
let orientedAspect = width > 0 ? CGFloat(height) / CGFloat(width) : 1
if abs(roi.aspect - orientedAspect) > 0.001 {
roi = OpticalROI(aspect: orientedAspect)
}
request.regionOfInterest = roi.decodeRegion
let handler = VNImageRequestHandler(cvPixelBuffer: buffer, orientation: .right, options: [:])
let startedAt = CFAbsoluteTimeGetCurrent()
try? handler.perform([request])
let elapsed = (CFAbsoluteTimeGetCurrent() - startedAt) * 1000
let observation = request.results?
.first { OpticalProtocol.isOpticalText($0.payloadStringValue ?? "") }
if let observation, let text = observation.payloadStringValue {
roi.hit(boundingBox: observation.boundingBox)
onFrame?(text, elapsed)
refocusIfNeeded()
} else {
roi.miss()
onMiss?(elapsed)
}
let region = roi.decodeRegion
let locked = roi.isLocked
DispatchQueue.main.async { [weak self] in self?.drawLock(region: region, locked: locked) }
}
/// 锁定之后周期性在 ROI 中心重新对焦/测光。屏幕是个平面光源,
/// 连续自动对焦经常在背景上来回拉风箱。
private func refocusIfNeeded() {
guard Date().timeIntervalSince(lastFocusAt) > 2.5, let device else { return }
lastFocusAt = Date()
let center = CGPoint(x: roi.decodeRegion.midX, y: 1 - roi.decodeRegion.midY)
guard (try? device.lockForConfiguration()) != nil else { return }
defer { device.unlockForConfiguration() }
if device.isFocusPointOfInterestSupported, device.isFocusModeSupported(.autoFocus) {
device.focusPointOfInterest = center
device.focusMode = .autoFocus
}
if device.isExposurePointOfInterestSupported,
device.isExposureModeSupported(.continuousAutoExposure) {
device.exposurePointOfInterest = center
device.exposureMode = .continuousAutoExposure
}
}
private func drawLock(region: CGRect, locked: Bool) {
guard let preview else { return }
// Vision 原点在左下,metadataOutputRect 原点在左上
let metadataRect = CGRect(x: region.minX, y: 1 - region.minY - region.height,
width: region.width, height: region.height)
let rect = preview.layerRectConverted(fromMetadataOutputRect: metadataRect)
lockLayer.path = UIBezierPath(roundedRect: rect, cornerRadius: 8).cgPath
lockLayer.strokeColor = locked
? UIColor.systemGreen.cgColor
: UIColor.white.withAlphaComponent(0.6).cgColor
}
// MARK: - 生命周期
override func viewWillAppear(_ animated: Bool) {
super.viewWillAppear(animated)
// 长时间盯着屏幕解码,别让手机自己锁屏
UIApplication.shared.isIdleTimerDisabled = true
start()
}
/// 相机权限没批下来就不要启动会话:那样只会得到一个永远漆黑的画面,
/// 用户不知道该去哪儿改。
private func start() {
guard !session.isRunning else { return }
switch AVCaptureDevice.authorizationStatus(for: .video) {
case .authorized:
sampleQueue.async { [session] in session.startRunning() }
case .notDetermined:
AVCaptureDevice.requestAccess(for: .video) { [weak self] granted in
guard granted, let self else { return }
self.sampleQueue.async { [session = self.session] in session.startRunning() }
}
default:
break
}
}
override func viewWillDisappear(_ animated: Bool) {
super.viewWillDisappear(animated)
UIApplication.shared.isIdleTimerDisabled = false
guard session.isRunning else { return }
sampleQueue.async { [session] in session.stopRunning() }
}
override func viewDidLayoutSubviews() {
super.viewDidLayoutSubviews()
preview?.frame = view.bounds
}
}
+240 -47
View File
@@ -1,51 +1,78 @@
import SwiftUI import SwiftUI
import CoreImage.CIFilterBuiltins import CoreImage.CIFilterBuiltins
/// 已经配对成功的一台电脑。
struct DesktopSession: Equatable {
let host: QFTHost
let token: String
let name: String
}
@MainActor @MainActor
final class TransferModel: ObservableObject { final class TransferModel: ObservableObject {
enum Stage: Equatable { enum Stage: Equatable {
case idle case idle
/// 扫配对二维码
case scanning case scanning
/// 扫到 QFTPAIR2:需要用户挑一个文件传给电脑 /// 光学接收:只用摄像头,不碰任何网络
case pickFileForUpload(PairingPayload) case optical
/// 扫到 QFTPAIR2:需要用户挑文件传给电脑
case pickFilesForUpload(PairingPayload)
/// 专用网络(Windows QFT Direct),但本机签名不能自动加入 Wi-Fi
case manualJoin(WifiCredentials, PairingPayload)
/// 「连接电脑」页:附近的电脑 + 连接码
case nearby
/// 已配对,等待挑文件
case pickFilesForDesktop(DesktopSession)
case connecting(String) case connecting(String)
case running(String) case running(String)
case showingPeerCode(PeerPairing) case showingPeerCode(PeerPairing)
case finished(String, URL?) case finished(String, [URL])
case failed(String) case failed(String)
} }
@Published private(set) var stage: Stage = .idle @Published private(set) var stage: Stage = .idle
@Published private(set) var progress: TransferProgress? @Published private(set) var progress: TransferProgress?
@Published private(set) var detail: String?
@Published private(set) var receivedFiles: [URL] = [] @Published private(set) var receivedFiles: [URL] = []
private var task: Task<Void, Never>? private var task: Task<Void, Never>?
private var sender: PeerSender? private var sender: PeerSender?
private var scopedURL: URL? private var scopedURLs: [URL] = []
private var joinedSSID: String?
private let deviceName = DeviceInfo.name private let deviceName = DeviceInfo.name
// MARK: - 入口 // MARK: - 入口
func beginScan() { stage = .scanning } func beginScan() { stage = .scanning }
func beginOptical() { stage = .optical }
func beginNearby() { stage = .nearby }
func cancel() { func cancel() {
task?.cancel() task?.cancel()
task = nil task = nil
sender?.stop() sender?.stop()
sender = nil sender = nil
releaseScope() releaseScopes()
leaveDedicatedNetwork()
progress = nil progress = nil
detail = nil
stage = .idle stage = .idle
} }
func reset() { func reset() {
progress = nil progress = nil
detail = nil
stage = .idle stage = .idle
refreshReceivedFiles() refreshReceivedFiles()
} }
func finishOptical(_ urls: [URL]) {
finish(urls.isEmpty ? "已退出光学接收" : "已保存 \(urls.count) 个文件", urls)
}
/// 扫到码之后的统一分发 /// 扫到码之后的统一分发
func handleScanned(_ text: String) { func handleScanned(_ text: String) {
if let peer = PeerPairing.parse(text) { if let peer = PeerPairing.parse(text) {
@@ -56,12 +83,70 @@ final class TransferModel: ObservableObject {
stage = .failed("这不是 QFT 的二维码,或二维码里的地址不是局域网地址。") stage = .failed("这不是 QFT 的二维码,或二维码里的地址不是局域网地址。")
return return
} }
switch DedicatedNetworkPlan.plan(for: pairing) {
case .useEndpoints:
proceed(pairing)
case .joinWifi(let wifi):
joinAndProceed(pairing, wifi: wifi)
case .manualJoin(let wifi):
stage = .manualJoin(wifi, pairing)
case .unusable:
stage = .failed("这张二维码既没有可用地址,也没有专用 Wi-Fi 凭据。")
}
}
/// 用户在「设置」里手动连好专用 Wi-Fi 之后回到 App
func manualJoinCompleted(_ pairing: PairingPayload) {
proceed(pairing)
}
private func proceed(_ pairing: PairingPayload) {
switch pairing.direction { switch pairing.direction {
case .downloadToPhone: startDownload(pairing) case .downloadToPhone: startDownload(pairing)
case .uploadToPC: stage = .pickFileForUpload(pairing) case .uploadToPC: stage = .pickFilesForUpload(pairing)
} }
} }
// MARK: - 专用网络(iPhone ↔ Windows)
/// Windows 端的 QFT Direct 是一张**专用 Wi-Fi**:二维码按设计不带任何
/// 电脑地址,手机必须先加入那张网,再从路由表把网关认出来。
private func joinAndProceed(_ pairing: PairingPayload, wifi: WifiCredentials) {
stage = .connecting("正在加入专用网络「\(wifi.ssid)」…")
task = Task {
do {
try await DedicatedNetwork.join(wifi)
joinedSSID = wifi.ssid
detail = "已加入,正在等待电脑响应…"
// 「加入成功」不等于「电脑可达」,判据只能是协议层握手成功
_ = try await DedicatedNetwork.waitForHost(
session: pairing.session, port: pairing.port,
deviceName: deviceName, ssid: wifi.ssid)
detail = nil
guard !Task.isCancelled else { return }
proceed(pairing)
} catch let error as DedicatedNetworkError {
detail = nil
if case .entitlementMissing = error {
// 拿不到 HotspotConfiguration 能力时不假装成功,
// 直接转成「手动连」的引导页
stage = .manualJoin(wifi, pairing)
} else {
stage = .failed(error.localizedDescription)
}
} catch {
detail = nil
fail(error)
}
}
}
private func leaveDedicatedNetwork() {
guard let joinedSSID else { return }
DedicatedNetwork.leave(ssid: joinedSSID)
self.joinedSSID = nil
}
// MARK: - 电脑 → 手机 // MARK: - 电脑 → 手机
private func startDownload(_ pairing: PairingPayload) { private func startDownload(_ pairing: PairingPayload) {
@@ -70,64 +155,156 @@ final class TransferModel: ObservableObject {
do { do {
let host = try await HostDiscovery(pairing: pairing, deviceName: deviceName).locate() let host = try await HostDiscovery(pairing: pairing, deviceName: deviceName).locate()
guard !Task.isCancelled else { return } guard !Task.isCancelled else { return }
stage = .running("正在从 \(pairing.pcName) 接收 \(pairing.fileName ?? "文件")") let name = pairing.fileName ?? "文件"
let client = DownloadClient(host: host, pairing: pairing, deviceName: deviceName) stage = .running("正在从 \(pairing.pcName) 接收 \(name)")
let saved = try await client.run { [weak self] value in
let directory = try DownloadClient.defaultDestinationDirectory()
let saved = try await download(
host: host, token: pairing.session, directory: directory,
target: RangeDownloadClient.Target(fileName: name,
fileSize: pairing.fileSize ?? 0,
sha256: pairing.sha256),
legacy: { try await DownloadClient(host: host, pairing: pairing,
deviceName: self.deviceName,
destinationDirectory: directory)
.run { [weak self] value in
Task { @MainActor in self?.progress = value } Task { @MainActor in self?.progress = value }
} } })
finish("已保存到「文件」App 的 QFT 文件夹", saved) finish("已保存到「文件」App 的 QFT 文件夹", [saved])
} catch { } catch {
fail(error) fail(error)
} }
} }
} }
/// 优先并行 Range,桌面端不支持分段时回落单流。
///
/// 单条 TCP 在 Wi-Fi 上打不满链路,8 路并行才是 iPhone ↔ Mac 场景下
/// 「局域网也要更快」的落点;而回落分支保证遇到老版本电脑端不会直接失败。
private func download(host: QFTHost, token: String, directory: URL,
target: RangeDownloadClient.Target,
legacy: () async throws -> URL) async throws -> URL {
let client = RangeDownloadClient(host: host, token: token, deviceName: deviceName,
destinationDirectory: directory)
var resolved = target
if resolved.fileSize == 0 {
let probed = try await client.probe()
resolved = RangeDownloadClient.Target(fileName: resolved.fileName.isEmpty
? probed.fileName : resolved.fileName,
fileSize: probed.fileSize,
sha256: resolved.sha256)
}
do {
return try await client.run(resolved) { [weak self] value in
Task { @MainActor in self?.progress = value }
}
} catch QFTError.rangeUnsupported {
detail = "电脑端不支持分段下载,已回落为单流传输"
progress = nil
return try await legacy()
}
}
// MARK: - 手机 → 电脑 // MARK: - 手机 → 电脑
func startUpload(_ pairing: PairingPayload, fileURL: URL) { func startUpload(_ pairing: PairingPayload, fileURLs: [URL]) {
guard claimScope(fileURL) else { guard claimScopes(fileURLs) else {
stage = .failed("没有权限读取这个文件,请换一个位置再试。") stage = .failed("没有权限读取这些文件,请换一个位置再试。")
return return
} }
stage = .connecting("正在找 \(pairing.pcName)…") stage = .connecting("正在找 \(pairing.pcName)…")
task = Task { task = Task {
defer { releaseScope() } defer { releaseScopes() }
do { do {
let host = try await HostDiscovery(pairing: pairing, deviceName: deviceName).locate() let host = try await HostDiscovery(pairing: pairing, deviceName: deviceName).locate()
guard !Task.isCancelled else { return } guard !Task.isCancelled else { return }
stage = .running("正在发送 \(fileURL.lastPathComponent) 到 \(pairing.pcName)") try await upload(fileURLs, host: host, token: pairing.session, target: pairing.pcName)
let client = UploadClient(host: host, pairing: pairing, deviceName: deviceName) finish("已发送 \(fileURLs.count) 个文件到 \(pairing.pcName)", [])
_ = try await client.run(fileURL: fileURL) { [weak self] value in
Task { @MainActor in self?.progress = value }
}
finish("已发送到 \(pairing.pcName)", nil)
} catch { } catch {
fail(error) fail(error)
} }
} }
} }
// MARK: - iPhone ↔ iPhone(隔空投送式) func startUpload(to session: DesktopSession, fileURLs: [URL]) {
guard claimScopes(fileURLs) else {
func startPeerSend(fileURL: URL) { stage = .failed("没有权限读取这些文件,请换一个位置再试。")
guard claimScope(fileURL) else {
stage = .failed("没有权限读取这个文件,请换一个位置再试。")
return return
} }
stage = .connecting("正在准备…")
task = Task { task = Task {
defer { releaseScope() } defer { releaseScopes() }
do { do {
let sender = PeerSender(fileURL: fileURL, deviceName: deviceName) try await upload(fileURLs, host: session.host, token: session.token,
// start() 里要完整读一遍文件算摘要,别卡住主线程 target: session.name)
finish("已发送 \(fileURLs.count) 个文件到 \(session.name)", [])
} catch {
fail(error)
}
}
}
private func upload(_ fileURLs: [URL], host: QFTHost, token: String, target: String) async throws {
let pairing = PairingPayload(version: 2, session: token, pcName: target,
port: 0, endpoints: [host.baseURL], wifi: nil,
direction: .uploadToPC, fileName: nil,
fileSize: nil, sha256: nil)
let client = UploadClient(host: host, pairing: pairing, deviceName: deviceName)
for (index, url) in fileURLs.enumerated() {
try Task.checkCancellation()
stage = .running("正在发送 \(url.lastPathComponent) 到 \(target)")
detail = fileURLs.count > 1 ? "第 \(index + 1)/\(fileURLs.count) 个文件" : nil
_ = try await client.run(fileURL: url) { [weak self] value in
Task { @MainActor in self?.progress = value }
}
}
detail = nil
}
// MARK: - 连接电脑(附近的电脑 / 连接码)
/// 用连接码换取会话令牌。电脑端错 5 次就作废整个码,所以绝不重试。
func connect(code text: String, peer: DesktopPeer?) {
stage = .connecting("正在连接电脑…")
task = Task {
do {
let code = try ConnectCode.decode(text)
guard code.isUsable else {
throw QFTError.malformedResponse("连接码里的地址不是局域网地址")
}
let token = try await DesktopPairing.pair(baseURL: code.baseURL,
code: code.secretHex,
deviceName: deviceName)
guard !Task.isCancelled else { return }
let name = peer?.name ?? code.address
stage = .pickFilesForDesktop(DesktopSession(host: QFTHost(baseURL: code.baseURL),
token: token, name: name))
} catch {
fail(error)
}
}
}
// MARK: - iPhone ↔ iPhone(隔空)
func startPeerSend(fileURLs: [URL]) {
guard claimScopes(fileURLs) else {
stage = .failed("没有权限读取这些文件,请换一个位置再试。")
return
}
stage = .connecting("正在计算校验值…")
task = Task {
defer { releaseScopes() }
do {
let sender = PeerSender(fileURLs: fileURLs, deviceName: deviceName)
// start() 里要完整读一遍每个文件算摘要,别卡住主线程
let pairing = try await Task.detached { try sender.start() }.value let pairing = try await Task.detached { try sender.start() }.value
guard !Task.isCancelled else { sender.stop(); return } guard !Task.isCancelled else { sender.stop(); return }
self.sender = sender self.sender = sender
stage = .showingPeerCode(pairing) stage = .showingPeerCode(pairing)
try await sender.waitAndSend { [weak self] value in try await sender.waitAndSend { [weak self] update in
Task { @MainActor in self?.progress = value } Task { @MainActor in self?.apply(update) }
} }
finish("已发送给对方", nil) finish("已发送给对方", [])
} catch { } catch {
fail(error) fail(error)
} }
@@ -142,9 +319,9 @@ final class TransferModel: ObservableObject {
do { do {
let directory = try DownloadClient.defaultDestinationDirectory() let directory = try DownloadClient.defaultDestinationDirectory()
let receiver = PeerReceiver(pairing: pairing, destinationDirectory: directory) let receiver = PeerReceiver(pairing: pairing, destinationDirectory: directory)
stage = .running("正在接收 \(pairing.fileName)") stage = .running("正在接收 \(pairing.fileCount) 个文件")
let saved = try await receiver.run { [weak self] value in let saved = try await receiver.run { [weak self] update in
Task { @MainActor in self?.progress = value } Task { @MainActor in self?.apply(update) }
} }
finish("已保存到「文件」App 的 QFT 文件夹", saved) finish("已保存到「文件」App 的 QFT 文件夹", saved)
} catch { } catch {
@@ -153,17 +330,28 @@ final class TransferModel: ObservableObject {
} }
} }
private func apply(_ update: PeerTransferUpdate) {
progress = update.progress
detail = update.fileCount > 1
? "第 \(update.fileIndex + 1)/\(update.fileCount) 个 · \(update.fileName)"
: update.fileName
}
// MARK: - 收尾 // MARK: - 收尾
private func finish(_ message: String, _ url: URL?) { private func finish(_ message: String, _ urls: [URL]) {
progress = nil progress = nil
stage = .finished(message, url) detail = nil
leaveDedicatedNetwork()
stage = .finished(message, urls)
refreshReceivedFiles() refreshReceivedFiles()
} }
private func fail(_ error: Error) { private func fail(_ error: Error) {
guard !(error is CancellationError) else { return } guard !(error is CancellationError) else { return }
progress = nil progress = nil
detail = nil
leaveDedicatedNetwork()
stage = .failed(error.localizedDescription) stage = .failed(error.localizedDescription)
} }
@@ -175,7 +363,7 @@ final class TransferModel: ObservableObject {
return return
} }
receivedFiles = entries receivedFiles = entries
.filter { $0.pathExtension != "qftpart" } .filter { $0.pathExtension != "qftpart" && !$0.lastPathComponent.hasSuffix(".ledger") }
.sorted { lhs, rhs in .sorted { lhs, rhs in
let l = (try? lhs.resourceValues(forKeys: [.contentModificationDateKey]))? let l = (try? lhs.resourceValues(forKeys: [.contentModificationDateKey]))?
.contentModificationDate ?? .distantPast .contentModificationDate ?? .distantPast
@@ -189,16 +377,21 @@ final class TransferModel: ObservableObject {
/// 文件选择器给的 URL 属于其他进程的沙盒,读之前必须声明作用域, /// 文件选择器给的 URL 属于其他进程的沙盒,读之前必须声明作用域,
/// 而且整个传输期间都要持有。 /// 而且整个传输期间都要持有。
private func claimScope(_ url: URL) -> Bool { private func claimScopes(_ urls: [URL]) -> Bool {
releaseScope() releaseScopes()
guard url.startAccessingSecurityScopedResource() else { return false } for url in urls {
scopedURL = url guard url.startAccessingSecurityScopedResource() else {
return true releaseScopes()
return false
}
scopedURLs.append(url)
}
return !scopedURLs.isEmpty
} }
private func releaseScope() { private func releaseScopes() {
scopedURL?.stopAccessingSecurityScopedResource() scopedURLs.forEach { $0.stopAccessingSecurityScopedResource() }
scopedURL = nil scopedURLs = []
} }
} }
+79
View File
@@ -0,0 +1,79 @@
import Foundation
/// RFC 9285 Base45。
///
/// 光学链路选它而不是 Base64:这 45 个字符全部落在 QR 的**字母数字模式**里,
/// 同样一帧二进制数据能少用不少模块(实测 450 B DATA 帧为 QR-L v15,
/// 旧的 Base64 480 B 对照是 v18)。
///
/// 这里同时保留 encode:Windows 端只编码不解码、Android 端只解码不编码,
/// 而 iOS 侧的合成测试需要自己造帧,两个方向都必须与 `desktop/src/base45.rs`
/// 和 `android/.../Base45.kt` 逐字符一致。
enum Base45 {
static let alphabet = Array("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:")
private static let reverse: [Int8] = {
var table = [Int8](repeating: -1, count: 128)
for (index, character) in alphabet.enumerated() {
table[Int(character.asciiValue!)] = Int8(index)
}
return table
}()
static func encode(_ input: Data) -> String {
guard !input.isEmpty else { return "" }
var out = String()
out.reserveCapacity((input.count * 3 + 1) / 2)
let bytes = [UInt8](input)
var index = 0
while index + 1 < bytes.count {
let value = Int(bytes[index]) * 256 + Int(bytes[index + 1])
out.append(alphabet[value % 45])
out.append(alphabet[(value / 45) % 45])
out.append(alphabet[value / (45 * 45)])
index += 2
}
if index < bytes.count {
let value = Int(bytes[index])
out.append(alphabet[value % 45])
out.append(alphabet[value / 45])
}
return out
}
/// 解码失败一律返回 nil:光学帧是从相机噪声里解出来的,
/// 半个字符错位就应该整帧丢弃,交给下一次重播。
static func decode(_ text: String) -> Data? {
if text.isEmpty { return Data() }
let characters = Array(text.utf8)
if characters.count % 3 == 1 { return nil }
var out = Data()
out.reserveCapacity((characters.count / 3) * 2 + 1)
var index = 0
while index + 2 < characters.count {
guard let a = value(characters[index]),
let b = value(characters[index + 1]),
let c = value(characters[index + 2]) else { return nil }
let n = a + b * 45 + c * 45 * 45
if n > 0xFFFF { return nil }
out.append(UInt8(n / 256))
out.append(UInt8(n % 256))
index += 3
}
if index < characters.count {
guard let a = value(characters[index]), let b = value(characters[index + 1]) else { return nil }
let n = a + b * 45
if n > 0xFF { return nil }
out.append(UInt8(n))
}
return out
}
private static func value(_ byte: UInt8) -> Int? {
guard byte < 128 else { return nil }
let mapped = reverse[Int(byte)]
return mapped >= 0 ? Int(mapped) : nil
}
}
+42
View File
@@ -0,0 +1,42 @@
import Foundation
/// CRC-32(IEEE 802.3,反射多项式 0xEDB88320)。
///
/// 光学帧每帧自带 CRC32,这是**唯一**能把相机误识别挡在文件之外的手段:
/// ZXing/Vision 会偶尔把一帧解成语法合法但内容错误的字符串,长度和结构
/// 都对得上,只有 CRC 能发现。
enum CRC32 {
private static let table: [UInt32] = {
(0..<256).map { index -> UInt32 in
var value = UInt32(index)
for _ in 0..<8 {
value = (value & 1) != 0 ? (value >> 1) ^ 0xEDB8_8320 : value >> 1
}
return value
}
}()
static func compute<Bytes: Sequence>(_ bytes: Bytes) -> UInt32 where Bytes.Element == UInt8 {
var crc: UInt32 = 0xFFFF_FFFF
for byte in bytes {
crc = (crc >> 8) ^ table[Int((crc ^ UInt32(byte)) & 0xFF)]
}
return crc ^ 0xFFFF_FFFF
}
}
/// CRC-8(多项式 0x07,初值 0),用于桌面端连接码的校验位。
/// 与 `desktop/src/connect_code.rs::crc8` 必须逐位一致。
enum CRC8 {
static func compute<Bytes: Sequence>(_ bytes: Bytes) -> UInt8 where Bytes.Element == UInt8 {
var crc: UInt8 = 0
for byte in bytes {
crc ^= byte
for _ in 0..<8 {
crc = (crc & 0x80) != 0 ? (crc << 1) ^ 0x07 : crc << 1
}
}
return crc
}
}
+213
View File
@@ -0,0 +1,213 @@
import Foundation
/// 桌面端连接码(`desktop/src/connect_code.rs` 的客户端实现)。
///
/// 电脑之间没有摄像头,所以桌面端进入「我要接收」后显示的是一串
/// `K7M2-9X4P-QR3T` 形式的连接码:**地址、端口和配对秘密都编在码里**。
/// iPhone 直接照着屏幕输入这串码,就能连上 Mac 或 Windows,
/// 既不用扫码,也不需要广播能通——只要 IP 层路由可达即可。
///
/// 编码(全部与 Rust 端逐位一致):
/// ```text
/// byte0 version(3) | kind(3) | default_port(1) | reserved(1)
/// addr 2~4 字节(按私有网段压缩)或 16 字节(IPv6)
/// port 2 字节,仅当端口非 39393 时存在
/// secret 3 字节
/// crc 1 字节 CRC-8
/// ```
struct ConnectCode: Equatable {
/// Crockford Base32:去掉了容易混淆的 I、L、O、U
static let alphabet = Array("0123456789ABCDEFGHJKMNPQRSTVWXYZ")
static let version: UInt8 = 1
static let defaultPort = 39393
static let secretLength = 3
enum Kind: UInt8 {
case private192 = 0
case private10 = 1
case private172 = 2
case fullV4 = 3
case v6 = 4
var addressLength: Int {
switch self {
case .private192: return 2
case .private10, .private172: return 3
case .fullV4: return 4
case .v6: return 16
}
}
}
enum CodeError: LocalizedError, Equatable {
case length
case alphabet(Character)
case checksum
case unsupported
var errorDescription: String? {
switch self {
case .length: return "连接码长度不对,请检查是否漏敲或多敲了字符"
case .alphabet(let ch): return "连接码里有无效字符「\(ch)」"
case .checksum: return "连接码校验失败,请核对后重新输入"
case .unsupported: return "无法识别的连接码版本"
}
}
}
/// 点分十进制的 IPv4。iOS 端只接受 IPv4:这条路径最终要落到
/// `http://<私有 IPv4>:<port>` 的白名单上,IPv6 直连不在本端支持范围内。
let address: String
let port: Int
let secret: [UInt8]
/// 线上表示:6 个小写十六进制字符,放进 `X-QFT-Code` 头
var secretHex: String { secret.map { String(format: "%02x", $0) }.joined() }
var baseURL: String { "http://\(address):\(port)" }
/// 连接码同样是不可信输入:它决定了 App 接下来连哪个地址,
/// 所以必须过与二维码端点同一套私有地址白名单。
var isUsable: Bool {
PairingProtocol.isAllowedLocalHTTPEndpoint(baseURL, expectedPort: port)
}
// MARK: - 解析
static func decode(_ text: String) throws -> ConnectCode {
let (bytes, paddingOK) = try base32Decode(text)
let code = try fromBytes(bytes)
// 先判长度/CRC 再判填充位:长度不对时「长度不对」比「校验失败」更能指导用户
guard paddingOK else { throw CodeError.checksum }
return code
}
private static func fromBytes(_ bytes: [UInt8]) throws -> ConnectCode {
guard bytes.count >= 1 + 2 + secretLength + 1 else { throw CodeError.length }
let payload = Array(bytes[0..<(bytes.count - 1)])
guard CRC8.compute(payload) == bytes[bytes.count - 1] else { throw CodeError.checksum }
let header = payload[0]
guard header >> 5 == version else { throw CodeError.unsupported }
guard let kind = Kind(rawValue: (header >> 2) & 0b111) else { throw CodeError.unsupported }
let defaultPortFlag = (header >> 1) & 1 == 1
let addressLength = kind.addressLength
let portLength = defaultPortFlag ? 0 : 2
guard payload.count == 1 + addressLength + portLength + secretLength else {
throw CodeError.length
}
let slice = Array(payload[1..<(1 + addressLength)])
let address: String
switch kind {
case .private192: address = "192.168.\(slice[0]).\(slice[1])"
case .private10: address = "10.\(slice[0]).\(slice[1]).\(slice[2])"
case .private172:
guard slice[0] <= 15 else { throw CodeError.unsupported }
address = "172.\(Int(slice[0]) + 16).\(slice[1]).\(slice[2])"
case .fullV4: address = "\(slice[0]).\(slice[1]).\(slice[2]).\(slice[3])"
case .v6: throw CodeError.unsupported // iPhone 端只走私有 IPv4
}
var cursor = 1 + addressLength
var port = defaultPort
if !defaultPortFlag {
port = Int(payload[cursor]) << 8 | Int(payload[cursor + 1])
cursor += 2
}
let secret = Array(payload[cursor..<(cursor + secretLength)])
return ConnectCode(address: address, port: port, secret: secret)
}
// MARK: - 编码(自检用;真实场景由桌面端生成)
func encode() -> String {
let octets = address.split(separator: ".").compactMap { UInt8($0) }
var kind = Kind.fullV4
var addressBytes = octets
if octets.count == 4 {
switch (octets[0], octets[1]) {
case (192, 168): kind = .private192; addressBytes = [octets[2], octets[3]]
case (10, _): kind = .private10; addressBytes = [octets[1], octets[2], octets[3]]
case (172, 16...31): kind = .private172
addressBytes = [octets[1] - 16, octets[2], octets[3]]
default: kind = .fullV4
}
}
let usesDefaultPort = port == Self.defaultPort
var out: [UInt8] = [(Self.version << 5) | (kind.rawValue << 2) | ((usesDefaultPort ? 1 : 0) << 1)]
out.append(contentsOf: addressBytes)
if !usesDefaultPort {
out.append(UInt8(truncatingIfNeeded: port >> 8))
out.append(UInt8(truncatingIfNeeded: port))
}
out.append(contentsOf: secret)
out.append(CRC8.compute(out))
let raw = Self.base32Encode(out)
return stride(from: 0, to: raw.count, by: 4).map { start -> String in
let from = raw.index(raw.startIndex, offsetBy: start)
let to = raw.index(from, offsetBy: min(4, raw.count - start))
return String(raw[from..<to])
}.joined(separator: "-")
}
// MARK: - Base32
static func base32Encode(_ bytes: [UInt8]) -> String {
var out = ""
var buffer: UInt32 = 0
var bits: UInt32 = 0
for byte in bytes {
buffer = (buffer << 8) | UInt32(byte)
bits += 8
while bits >= 5 {
bits -= 5
out.append(alphabet[Int((buffer >> bits) & 0x1f)])
}
}
if bits > 0 {
out.append(alphabet[Int((buffer << (5 - bits)) & 0x1f)])
}
return out
}
/// 返回(字节, 末尾填充位是否为 0)。
/// 填充位必须校验:否则改动最后一个字符有相当概率解出完全相同的字节序列,
/// CRC 根本没有机会发现——这一点 Rust 端有实测记录。
static func base32Decode(_ text: String) throws -> ([UInt8], Bool) {
var buffer: UInt32 = 0
var bits: UInt32 = 0
var out: [UInt8] = []
var symbols = 0
for character in text {
if character == "-" || character == " " || character == "_" || character == "\t" {
continue
}
let upper = Character(String(character).uppercased())
// Crockford 容错:手写/口述时 I、L 常被当成 1,O 被当成 0
let normalized: Character
switch upper {
case "I", "L": normalized = "1"
case "O": normalized = "0"
default: normalized = upper
}
guard let value = alphabet.firstIndex(of: normalized) else {
throw CodeError.alphabet(character)
}
symbols += 1
buffer = (buffer << 5) | UInt32(value)
bits += 5
if bits >= 8 {
bits -= 8
out.append(UInt8((buffer >> bits) & 0xff))
}
}
guard symbols > 0 else { throw CodeError.length }
let paddingOK = bits == 0 || (buffer & ((1 << bits) - 1)) == 0
return (out, paddingOK)
}
}
+148
View File
@@ -0,0 +1,148 @@
import Foundation
#if os(iOS)
import NetworkExtension
#endif
/// 连接「QFT Direct」这类专用网络时,App 该走哪条路。
///
/// Windows 端进入接收后会用 Wi-Fi Direct Legacy AP 开一张**专用网**,
/// 二维码里只放 SSID/密码,按设计**不携带任何电脑地址**
/// (`desktop/src/pairing.rs::qr_endpoints`)——手机必须先加入那张网,
/// 再从路由表里读网关。iOS 上「加入指定 Wi-Fi」有两条路,能力取决于签名,
/// 因此把决策单独拎出来,方便在没有真机的情况下测试。
enum DedicatedNetworkPlan: Equatable {
/// 二维码自带可用的局域网地址,直接连(Mac/Linux 端与 Windows 的 LAN 模式)
case useEndpoints([String])
/// 需要先加入专用 Wi-Fi,App 可以自己发起加入
case joinWifi(WifiCredentials)
/// 需要加入专用 Wi-Fi,但本次签名拿不到 HotspotConfiguration 能力,
/// 只能把 SSID/密码显示给用户,由用户去「设置」里连
case manualJoin(WifiCredentials)
/// 既没有地址也没有 Wi-Fi 凭据——这种二维码没法用
case unusable
static func plan(for pairing: PairingPayload,
canJoinProgrammatically: Bool = DedicatedNetwork.canJoinProgrammatically)
-> DedicatedNetworkPlan {
if !pairing.endpoints.isEmpty { return .useEndpoints(pairing.endpoints) }
guard let wifi = pairing.wifi else { return .unusable }
return canJoinProgrammatically ? .joinWifi(wifi) : .manualJoin(wifi)
}
}
enum DedicatedNetworkError: LocalizedError {
case unsupportedPlatform
case entitlementMissing
case userDenied
case invalidCredentials
case joinTimedOut(String)
case system(String)
var errorDescription: String? {
switch self {
case .unsupportedPlatform:
return "本设备无法由 App 加入指定 Wi-Fi。"
case .entitlementMissing:
return """
这台 iPhone 上的 QFT 没有「Hotspot Configuration」能力,无法自动加入电脑的专用 Wi-Fi。
请手动到「设置 → 无线局域网」里连接屏幕上显示的网络,连上后回到 QFT 继续。
"""
case .userDenied:
return "你取消了加入专用 Wi-Fi。"
case .invalidCredentials:
return "二维码里的 Wi-Fi 名称或密码不合法。"
case .joinTimedOut(let ssid):
return "已请求加入「\(ssid)」,但一直没拿到该网络的地址。请确认电脑上的 QFT 仍在接收状态。"
case .system(let detail):
return "加入专用 Wi-Fi 失败:\(detail)"
}
}
}
/// 专用 Wi-Fi 的加入与退出。
///
/// iOS 侧用 `NEHotspotConfiguration`,它需要 `HotspotConfiguration` entitlement。
/// 拿不到能力时**不假装成功**:直接报错并把凭据交给 UI 引导用户手动连接,
/// 而不是让用户对着一个永远连不上的进度条等下去。
enum DedicatedNetwork {
static var canJoinProgrammatically: Bool {
#if os(iOS)
return true
#else
return false
#endif
}
/// 加入专用 Wi-Fi。已经连在这张网上时按成功处理。
static func join(_ wifi: WifiCredentials) async throws {
guard PairingProtocol.isValidWifi(ssid: wifi.ssid, passphrase: wifi.passphrase) else {
throw DedicatedNetworkError.invalidCredentials
}
#if os(iOS)
let configuration = NEHotspotConfiguration(ssid: wifi.ssid,
passphrase: wifi.passphrase,
isWEP: false)
// 专用网没有互联网出口,会话结束后不该留在系统 Wi-Fi 列表里
configuration.joinOnce = true
try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
NEHotspotConfigurationManager.shared.apply(configuration) { error in
guard let error = error as NSError? else { return continuation.resume() }
guard error.domain == NEHotspotConfigurationErrorDomain,
let code = NEHotspotConfigurationError(rawValue: error.code) else {
continuation.resume(throwing: DedicatedNetworkError.system(error.localizedDescription))
return
}
switch code {
case .alreadyAssociated:
continuation.resume()
case .userDenied:
continuation.resume(throwing: DedicatedNetworkError.userDenied)
case .invalid, .invalidSSID, .invalidWPAPassphrase, .invalidSSIDPrefix:
continuation.resume(throwing: DedicatedNetworkError.invalidCredentials)
case .systemConfiguration, .unknown, .applicationIsNotInForeground:
// 没有 entitlement 时系统正是从这几个码里返回,
// 提示必须给出「手动连」这条可行的出路
continuation.resume(throwing: DedicatedNetworkError.entitlementMissing)
default:
continuation.resume(throwing: DedicatedNetworkError.system(error.localizedDescription))
}
}
}
#else
throw DedicatedNetworkError.unsupportedPlatform
#endif
}
static func leave(ssid: String) {
#if os(iOS)
NEHotspotConfigurationManager.shared.removeConfiguration(forSSID: ssid)
#endif
}
/// 等待专用网真正可用。
///
/// 「apply 成功」只代表系统接受了配置,不代表已经拿到 IPv4 地址、
/// 更不代表电脑那一侧的 Wi-Fi Direct 数据通道已经建立。判据只能是
/// **协议层握手成功**:能 ping 通带着正确令牌的 `/qft/ping`。
static func waitForHost(session: String, port: Int, deviceName: String,
ssid: String, timeout: TimeInterval = 20) async throws -> QFTHost {
let deadline = Date().addingTimeInterval(timeout)
while Date() < deadline {
try Task.checkCancellation()
let candidates = LocalNetwork.hostCandidates(port: port, limit: 64)
if !candidates.isEmpty {
let discovery = HostDiscovery(
pairing: PairingPayload(version: 2, session: session, pcName: ssid, port: port,
endpoints: [], wifi: nil, direction: .uploadToPC,
fileName: nil, fileSize: nil, sha256: nil),
deviceName: deviceName)
if let host = await discovery.probe(candidates, timeout: 1.0) { return host }
}
try? await Task.sleep(nanoseconds: 400_000_000)
}
throw DedicatedNetworkError.joinTimedOut(ssid)
}
}
+15 -4
View File
@@ -25,10 +25,15 @@ enum QFTError: LocalizedError {
case httpStatus(Int, String) case httpStatus(Int, String)
case malformedResponse(String) case malformedResponse(String)
case integrity(String) case integrity(String)
/// 对端忽略了 `Range`,把整份文件送了过来。并行下载在这种服务端上不成立,
/// 调用方据此回落单流——所以它必须是一个可判定的 case,而不是一句错误文案。
case rangeUnsupported(Int)
case cancelled case cancelled
var errorDescription: String? { var errorDescription: String? {
switch self { switch self {
case .rangeUnsupported(let code):
return "电脑端不支持分段下载(HTTP \(code)),已回落为单流传输"
case .hostNotFound: case .hostNotFound:
return "找不到电脑。请确认手机和电脑连在同一个 Wi-Fi,并且电脑上的 QFT 正在等待连接。" return "找不到电脑。请确认手机和电脑连在同一个 Wi-Fi,并且电脑上的 QFT 正在等待连接。"
case .httpStatus(let code, let detail): case .httpStatus(let code, let detail):
@@ -43,10 +48,11 @@ enum QFTError: LocalizedError {
} }
} }
/// 在局域网里定位 Windows 端。 /// 在局域网或专用网络里定位电脑。
/// ///
/// 顺序:二维码自带的 endpoint → UDP QFTDISC2 广播 → 当前子网有界扫描。 /// 顺序:二维码自带的 endpoint → 默认网关 → UDP QFTDISC2 广播 → 当前子网有界扫描。
/// 与 Android 端同一套策略,但去掉了 Direct-AP 相关的分支:iOS 连不上指定 AP。 /// 与 Android 端同一套策略。**网关这一步是专用网络的关键**:QFT Direct 的
/// 二维码按设计不带任何电脑地址,加入那张 Wi-Fi 之后,电脑就是网关本身。
struct HostDiscovery { struct HostDiscovery {
let pairing: PairingPayload let pairing: PairingPayload
@@ -58,11 +64,16 @@ struct HostDiscovery {
if let host = await probe(pairing.endpoints, timeout: 1.2) { if let host = await probe(pairing.endpoints, timeout: 1.2) {
return host return host
} }
// 专用网络下网关就是电脑,先打这一枪,命中率最高也最省时间
let gateways = LocalNetwork.defaultGateways().map { "http://\($0):\(pairing.port)" }
if !gateways.isEmpty, let host = await probe(gateways, timeout: 1.2) {
return host
}
if let hinted = await udpDiscover(timeout: 1.5), if let hinted = await udpDiscover(timeout: 1.5),
let host = await probe([hinted], timeout: 1.5) { let host = await probe([hinted], timeout: 1.5) {
return host return host
} }
let candidates = LocalNetwork.subnetCandidates(port: pairing.port, limit: 254) let candidates = LocalNetwork.hostCandidates(port: pairing.port, limit: 254)
if !candidates.isEmpty, let host = await probe(candidates, timeout: 0.7) { if !candidates.isEmpty, let host = await probe(candidates, timeout: 0.7) {
return host return host
} }
+262
View File
@@ -0,0 +1,262 @@
import Foundation
import CryptoKit
enum OpticalReceiveEvent {
case started(OpticalManifest)
case progress(manifest: OpticalManifest, received: Int, total: Int)
case completed(manifest: OpticalManifest, url: URL)
case failed(String)
}
/// 光学会话装配器。
///
/// 电脑端把整份文件切成若干 DATA 帧循环播放,没有任何反向通道,所以这里的
/// 职责是:**去重、定位落盘、数满、校验**。收齐并且 SHA-256 一致才算成功;
/// 校验失败就整份丢弃等下一轮重播,绝不把半份文件交给用户。
///
/// 与 Android `SessionAssembler.kt` 行为一致,差别只在落盘位置:iOS 没有
/// 公共「下载」目录,文件写进 App 的 Documents/QFT,由「文件」App 暴露出去。
final class OpticalAssembler: @unchecked Sendable {
/// 一次 accept 的结果。UI 用它区分「解码/s」和「有效新帧/s」——
/// 屏幕上同一帧会被连续拍到很多次,只有 isNew 才代表真正的吞吐。
enum Acceptance {
case ignored // 不是 QFT 帧、CRC 不过、或不属于当前会话
case duplicate // 解出来了,但这一块早就收过
case accepted // 有效新帧
}
private let destinationDirectory: URL
private let workDirectory: URL
private let onEvent: (OpticalReceiveEvent) -> Void
private let lock = NSLock()
private var manifest: OpticalManifest?
private var received: [Bool] = []
private var receivedCount = 0
private var handle: FileHandle?
private var partURL: URL?
private var completedSession: UInt64?
init(destinationDirectory: URL,
workDirectory: URL = FileManager.default.temporaryDirectory,
onEvent: @escaping (OpticalReceiveEvent) -> Void) {
self.destinationDirectory = destinationDirectory
self.workDirectory = workDirectory
self.onEvent = onEvent
}
deinit { try? handle?.close() }
@discardableResult
func accept(text: String) -> Acceptance {
guard let frame = OpticalProtocol.parseText(text) else { return .ignored }
return accept(frame: frame)
}
@discardableResult
func accept(frame: OpticalFrame) -> Acceptance {
lock.lock()
defer { lock.unlock() }
if completedSession == frame.sessionID { return .duplicate }
switch frame.kind {
case .manifest: return acceptManifest(frame)
case .data: return acceptData(frame)
case .end: return .duplicate
}
}
// MARK: - 帧处理
private func acceptManifest(_ frame: OpticalFrame) -> Acceptance {
guard let incoming = OpticalProtocol.parseManifest(frame) else { return .ignored }
if manifest?.sessionID == incoming.sessionID { return .duplicate }
resetLocked()
// 完成位图是每片一个 Bool,片数由**相机解出来的字节**决定,
// 不设上限的话一帧噪声就能让 App 申请几 GB 内存。
// 800 万片在 450 B 分片下约 3.4 GB,远超光学链路的现实上限。
guard incoming.totalChunks <= 8_000_000 else {
onEvent(.failed("文件分片数过大(\(incoming.totalChunks) 片)"))
return .ignored
}
// 声明的大小必须和分片数自洽,否则这份清单本身就是坏的
let expectedChunks = incoming.chunkSize == 0 ? 0
: (incoming.fileSize + UInt64(incoming.chunkSize) - 1) / UInt64(incoming.chunkSize)
guard expectedChunks == UInt64(incoming.totalChunks) else {
onEvent(.failed("清单自相矛盾:\(incoming.fileSize) 字节 / \(incoming.totalChunks) 片"))
return .ignored
}
let part = workDirectory.appendingPathComponent("qft-optical-\(incoming.sessionID).part")
do {
try FileManager.default.createDirectory(at: workDirectory, withIntermediateDirectories: true)
try? FileManager.default.removeItem(at: part)
guard FileManager.default.createFile(atPath: part.path, contents: nil) else {
throw QFTError.malformedResponse("无法创建临时文件")
}
let handle = try FileHandle(forWritingTo: part)
try handle.truncate(atOffset: incoming.fileSize)
self.handle = handle
} catch {
onEvent(.failed("准备接收失败:\(error.localizedDescription)"))
return .ignored
}
manifest = incoming
partURL = part
received = [Bool](repeating: false, count: Int(incoming.totalChunks))
receivedCount = 0
onEvent(.started(incoming))
if incoming.totalChunks == 0 { finalizeIfComplete() }
return .accepted
}
private func acceptData(_ frame: OpticalFrame) -> Acceptance {
guard let manifest else { return .ignored }
guard frame.sessionID == manifest.sessionID,
frame.totalChunks == manifest.totalChunks,
frame.seq < manifest.totalChunks else { return .ignored }
let offset = UInt64(frame.seq) * UInt64(manifest.chunkSize)
guard offset <= manifest.fileSize else { return .ignored }
let expectedLength = Int(min(UInt64(manifest.chunkSize), manifest.fileSize - offset))
guard frame.payload.count == expectedLength else { return .ignored }
let index = Int(frame.seq)
guard index < received.count else { return .ignored }
if received[index] { return .duplicate }
do {
try handle?.seek(toOffset: offset)
try handle?.write(contentsOf: frame.payload)
} catch {
onEvent(.failed("写入失败:\(error.localizedDescription)"))
return .ignored
}
received[index] = true
receivedCount += 1
onEvent(.progress(manifest: manifest, received: receivedCount, total: received.count))
finalizeIfComplete()
return .accepted
}
private func finalizeIfComplete() {
guard let manifest, receivedCount == received.count, let part = partURL else { return }
do {
try handle?.synchronize()
try handle?.close()
} catch {
onEvent(.failed("落盘失败:\(error.localizedDescription)"))
resetLocked()
return
}
handle = nil
guard let actual = try? Self.sha256(of: part) else {
onEvent(.failed("无法读取临时文件"))
resetLocked()
return
}
guard actual == manifest.sha256 else {
onEvent(.failed("SHA-256 校验失败,保持接收等待下一轮重播"))
resetLocked()
return
}
do {
try FileManager.default.createDirectory(at: destinationDirectory,
withIntermediateDirectories: true)
let finalURL = DownloadClient.uniqueURL(in: destinationDirectory, name: manifest.fileName)
try FileManager.default.moveItem(at: part, to: finalURL)
completedSession = manifest.sessionID
onEvent(.completed(manifest: manifest, url: finalURL))
resetLocked(keepCompleted: true)
} catch {
onEvent(.failed("保存失败:\(error.localizedDescription)"))
}
}
// MARK: - 状态
func reset() {
lock.lock()
defer { lock.unlock() }
resetLocked()
}
private func resetLocked(keepCompleted: Bool = false) {
try? handle?.close()
handle = nil
if let partURL { try? FileManager.default.removeItem(at: partURL) }
partURL = nil
manifest = nil
received = []
receivedCount = 0
if !keepCompleted { completedSession = nil }
}
var currentManifest: OpticalManifest? {
lock.lock(); defer { lock.unlock() }
return manifest
}
static func sha256(of url: URL) throws -> Data {
var hasher = SHA256()
let handle = try FileHandle(forReadingFrom: url)
defer { try? handle.close() }
while let block = try handle.read(upToCount: 4 * 1024 * 1024), !block.isEmpty {
hasher.update(data: block)
}
return Data(hasher.finalize())
}
}
/// 光学链路的实时速率统计。
///
/// 屏幕上同一帧会被相机连续拍到多次,「解码/s」很容易好看但没有意义,
/// 真正决定传输时间的是**有效新帧/s**。两个数字都要给出来,
/// 用户才能据此在电脑端选 30 / 45 / 60 FPS。
final class OpticalStats: @unchecked Sendable {
private let lock = NSLock()
private var windowStart = Date()
private var analyzed = 0
private var decoded = 0
private var fresh = 0
private(set) var cameraFPS: Double = 0
private(set) var decodedPerSecond: Double = 0
private(set) var freshPerSecond: Double = 0
private(set) var lastDecodeMilliseconds: Double = 0
func recordFrame(decodeMilliseconds: Double, acceptance: OpticalAssembler.Acceptance?) {
lock.lock()
defer { lock.unlock() }
analyzed += 1
lastDecodeMilliseconds = decodeMilliseconds
switch acceptance {
case .accepted: decoded += 1; fresh += 1
case .duplicate: decoded += 1
case .ignored, nil: break
}
let elapsed = Date().timeIntervalSince(windowStart)
guard elapsed >= 1 else { return }
cameraFPS = Double(analyzed) / elapsed
decodedPerSecond = Double(decoded) / elapsed
freshPerSecond = Double(fresh) / elapsed
analyzed = 0
decoded = 0
fresh = 0
windowStart = Date()
}
func snapshot() -> (camera: Double, decoded: Double, fresh: Double, decodeMS: Double) {
lock.lock(); defer { lock.unlock() }
return (cameraFPS, decodedPerSecond, freshPerSecond, lastDecodeMilliseconds)
}
}
+210
View File
@@ -0,0 +1,210 @@
import Foundation
/// 光学帧类型。与 `desktop/src/protocol.rs::FrameKind` 一致。
enum OpticalFrameKind: UInt8 {
case manifest = 1
case data = 2
case end = 3
}
struct OpticalFrame: Equatable {
let kind: OpticalFrameKind
let sessionID: UInt64
let seq: UInt32
let totalChunks: UInt32
let payload: Data
}
struct OpticalManifest: Equatable {
let sessionID: UInt64
let senderDevice: String
let fileName: String
let fileSize: UInt64
let chunkSize: Int
let totalChunks: UInt32
let sha256: Data
var sha256Hex: String { sha256.map { String(format: "%02x", $0) }.joined() }
}
/// QFT2 光学协议(单向:电脑屏幕 → iPhone 摄像头)。
///
/// ```text
/// "QFT2" | version u8 | kind u8 | session u64 | seq u32 | total u32 | len u16 | payload | crc32 u32
/// ```
/// 全部大端。文本层是 `QFT2:` + Base45。
///
/// 相机解出来的字符串是**彻底不可信的输入**:ZXing/Vision 偶尔会给出语法
/// 合法但内容错误的结果,因此这里除了 CRC32 之外,长度、类型、payload 长度
/// 字段都要与实际缓冲区严格对齐,任何一项不符就整帧丢弃。
enum OpticalProtocol {
static let prefix = "QFT2:"
static let legacyPrefix = "QFT1:"
/// 4 magic + 1 version + 1 kind + 8 session + 4 seq + 4 total + 2 len
static let headerSize = 24
static let trailerSize = 4
static func isOpticalText(_ text: String) -> Bool {
text.hasPrefix(prefix) || text.hasPrefix(legacyPrefix)
}
static func parseText(_ text: String) -> OpticalFrame? {
if text.hasPrefix(prefix) {
guard let binary = Base45.decode(String(text.dropFirst(prefix.count))) else { return nil }
return parseBinary(binary, magic: "QFT2", version: 2)
}
if text.hasPrefix(legacyPrefix) {
// 旧发送端仍在用 QFT1 + Base64URL,保留只读兼容
guard let binary = Base64URL.decode(String(text.dropFirst(legacyPrefix.count))) else { return nil }
return parseBinary(binary, magic: "QFT1", version: 1)
}
return nil
}
static func parseBinary(_ binary: Data, magic: String, version: UInt8) -> OpticalFrame? {
guard binary.count >= headerSize + trailerSize else { return nil }
let bytes = [UInt8](binary)
let bodySize = bytes.count - trailerSize
let expectedCRC = readU32(bytes, at: bodySize)
guard CRC32.compute(bytes[0..<bodySize]) == expectedCRC else { return nil }
guard String(bytes: bytes[0..<4], encoding: .ascii) == magic else { return nil }
guard bytes[4] == version else { return nil }
guard let kind = OpticalFrameKind(rawValue: bytes[5]) else { return nil }
let sessionID = readU64(bytes, at: 6)
let seq = readU32(bytes, at: 14)
let totalChunks = readU32(bytes, at: 18)
let payloadLength = Int(readU16(bytes, at: 22))
guard payloadLength == bodySize - headerSize else { return nil }
return OpticalFrame(kind: kind, sessionID: sessionID, seq: seq, totalChunks: totalChunks,
payload: Data(bytes[headerSize..<bodySize]))
}
static func parseManifest(_ frame: OpticalFrame) -> OpticalManifest? {
guard frame.kind == .manifest else { return nil }
let bytes = [UInt8](frame.payload)
// 8 size + 2 chunk + 32 sha + 2 nameLen = 44
guard bytes.count >= 44 else { return nil }
let fileSize = readU64(bytes, at: 0)
let chunkSize = Int(readU16(bytes, at: 8))
guard chunkSize > 0 else { return nil }
let sha256 = Data(bytes[10..<42])
let nameLength = Int(readU16(bytes, at: 42))
var cursor = 44
guard cursor + nameLength <= bytes.count else { return nil }
let rawName = String(bytes: bytes[cursor..<(cursor + nameLength)], encoding: .utf8) ?? ""
cursor += nameLength
var device = "Windows-PC"
if cursor + 2 <= bytes.count {
let deviceLength = Int(readU16(bytes, at: cursor))
cursor += 2
guard cursor + deviceLength <= bytes.count else { return nil }
if let raw = String(bytes: bytes[cursor..<(cursor + deviceLength)], encoding: .utf8) {
let cleaned = raw.unicodeScalars.filter { $0.value > 31 && $0.value != 127 }
let text = String(String.UnicodeScalarView(cleaned))
.trimmingCharacters(in: .whitespaces)
if !text.isEmpty { device = String(text.prefix(80)) }
}
}
return OpticalManifest(sessionID: frame.sessionID,
senderDevice: device,
fileName: sanitizeFileName(rawName),
fileSize: fileSize,
chunkSize: chunkSize,
totalChunks: frame.totalChunks,
sha256: sha256)
}
/// 文件名同样来自相机,绝不能直接当路径用。
///
/// 与 Android 端同一套替换规则(分隔符换成 `_`),另外把开头的 `.` 和 `_`
/// 一并去掉:`../../etc/passwd` 替换后是 `.._.._etc_passwd`,虽然已经不含
/// 分隔符,但留着这一串前缀既难看也没有意义。
static func sanitizeFileName(_ raw: String) -> String {
let forbidden: Set<Character> = ["\\", "/", ":", "*", "?", "\"", "<", ">", "|"]
var cleaned = String(raw.unicodeScalars
.filter { $0.value > 31 && $0.value != 127 }
.map { Character($0) }
.map { forbidden.contains($0) ? "_" : $0 })
cleaned = cleaned.trimmingCharacters(in: .whitespaces)
while let first = cleaned.first, first == "." || first == "_" { cleaned.removeFirst() }
cleaned = String(cleaned.prefix(180))
return cleaned.isEmpty ? "qft.bin" : cleaned
}
// MARK: - 编码(仅测试与自检使用)
static func encodeFrame(kind: OpticalFrameKind, sessionID: UInt64, seq: UInt32,
totalChunks: UInt32, payload: Data) -> Data {
var binary = Data("QFT2".utf8)
binary.append(2)
binary.append(kind.rawValue)
appendBE(&binary, sessionID)
appendBE(&binary, seq)
appendBE(&binary, totalChunks)
appendBE(&binary, UInt16(payload.count))
binary.append(payload)
appendBE(&binary, CRC32.compute(binary))
return binary
}
static func encodeManifest(_ manifest: OpticalManifest) -> Data {
var payload = Data()
appendBE(&payload, manifest.fileSize)
appendBE(&payload, UInt16(manifest.chunkSize))
payload.append(manifest.sha256)
let name = Data(manifest.fileName.utf8)
appendBE(&payload, UInt16(name.count))
payload.append(name)
let device = Data(manifest.senderDevice.utf8)
appendBE(&payload, UInt16(device.count))
payload.append(device)
return encodeFrame(kind: .manifest, sessionID: manifest.sessionID, seq: 0,
totalChunks: manifest.totalChunks, payload: payload)
}
static func text(for binary: Data) -> String { prefix + Base45.encode(binary) }
// MARK: - 大端读写
private static func readU16(_ bytes: [UInt8], at offset: Int) -> UInt16 {
UInt16(bytes[offset]) << 8 | UInt16(bytes[offset + 1])
}
private static func readU32(_ bytes: [UInt8], at offset: Int) -> UInt32 {
var value: UInt32 = 0
for index in 0..<4 { value = value << 8 | UInt32(bytes[offset + index]) }
return value
}
private static func readU64(_ bytes: [UInt8], at offset: Int) -> UInt64 {
var value: UInt64 = 0
for index in 0..<8 { value = value << 8 | UInt64(bytes[offset + index]) }
return value
}
private static func appendBE(_ data: inout Data, _ value: UInt16) {
data.append(UInt8(truncatingIfNeeded: value >> 8))
data.append(UInt8(truncatingIfNeeded: value))
}
private static func appendBE(_ data: inout Data, _ value: UInt32) {
for shift in stride(from: 24, through: 0, by: -8) {
data.append(UInt8(truncatingIfNeeded: value >> UInt32(shift)))
}
}
private static func appendBE(_ data: inout Data, _ value: UInt64) {
for shift in stride(from: 56, through: 0, by: -8) {
data.append(UInt8(truncatingIfNeeded: value >> UInt64(shift)))
}
}
}
+136
View File
@@ -0,0 +1,136 @@
import Foundation
import CoreGraphics
/// 光学扫描的 ROI 状态机(纯几何,不依赖 AVFoundation/Vision,可在 macOS 上单测)。
///
/// 为什么要锁 ROI:电脑屏幕上是**一个大二维码**在按 30~60 FPS 换帧,
/// 相机每帧都做全画面 finder 搜索既慢又抖。锁定之后只把候选区域交给解码器,
/// 单帧解码时间显著下降,真正决定传输速度的「有效新帧/s」才提得上去。
///
/// 坐标系与 Vision 的 `regionOfInterest` 一致:归一化到 [0,1],**原点在左下**。
struct OpticalROI: Equatable {
/// 全画面搜索时使用的居中比例。留一点边,避免把屏幕边框也算进来。
static let searchFraction: CGFloat = 0.92
/// 从条码 boundingBox 放大到含静区的锁定框
static let lockPadding: CGFloat = 1.22
/// 平滑跟随系数:太大跟着噪声抖,太小跟不上手抖
static let smoothing: CGFloat = 0.35
/// 连续丢失多少帧后开始逐级放大
static let missesBeforeExpand = 3
/// 连续丢失多少帧后彻底放弃锁定,回到全画面搜索
static let missesBeforeReacquire = 12
enum State: Equatable {
case searching
case locked
case missing(Int) // 已连续丢失的帧数
}
/// 画面宽高比(宽 / 高)。用来把归一化矩形按像素比例修成正方形。
let aspect: CGFloat
private(set) var state: State = .searching
private(set) var region: CGRect
init(aspect: CGFloat = 4.0 / 3.0) {
self.aspect = aspect > 0 ? aspect : 1
self.region = Self.centeredSearch(fraction: Self.searchFraction)
}
/// 本帧实际应该交给解码器的区域。
var decodeRegion: CGRect { region }
var isLocked: Bool {
if case .locked = state { return true }
return false
}
/// 一帧解码成功,`boundingBox` 是 Vision 给出的条码归一化外接框。
mutating func hit(boundingBox: CGRect) {
let target = Self.squared(Self.padded(boundingBox, by: Self.lockPadding), aspect: aspect)
.clampedToUnitSquare()
guard target.width > 0.02, target.height > 0.02 else { return }
switch state {
case .searching:
region = target
case .locked, .missing:
region = Self.smooth(region, toward: target, alpha: Self.smoothing)
}
state = .locked
}
/// 一帧没解出来。连续丢失会先放大 ROI,再彻底重新搜索。
mutating func miss() {
switch state {
case .searching:
return
case .locked:
state = .missing(1)
case .missing(let count):
let next = count + 1
if next >= Self.missesBeforeReacquire {
state = .searching
region = Self.centeredSearch(fraction: Self.searchFraction)
return
}
state = .missing(next)
if next >= Self.missesBeforeExpand {
region = Self.expand(region, by: 1.25).clampedToUnitSquare()
}
}
}
mutating func reset() {
state = .searching
region = Self.centeredSearch(fraction: Self.searchFraction)
}
// MARK: - 几何
static func centeredSearch(fraction: CGFloat) -> CGRect {
let f = min(max(fraction, 0.5), 1)
return CGRect(x: (1 - f) / 2, y: (1 - f) / 2, width: f, height: f)
}
static func padded(_ rect: CGRect, by factor: CGFloat) -> CGRect {
expand(rect, by: factor)
}
static func expand(_ rect: CGRect, by factor: CGFloat) -> CGRect {
let f = max(factor, 1)
let width = rect.width * f
let height = rect.height * f
return CGRect(x: rect.midX - width / 2, y: rect.midY - height / 2,
width: width, height: height)
}
/// 把归一化矩形修成**像素意义上的正方形**:二维码是方的,
/// 而归一化坐标在非 1:1 的画面上会把它拉扁。
static func squared(_ rect: CGRect, aspect: CGFloat) -> CGRect {
// 像素边长:宽方向乘以 aspect 才能与高方向比较
let pixelSide = max(rect.width * aspect, rect.height)
let width = pixelSide / aspect
let height = pixelSide
return CGRect(x: rect.midX - width / 2, y: rect.midY - height / 2,
width: width, height: height)
}
static func smooth(_ current: CGRect, toward target: CGRect, alpha: CGFloat) -> CGRect {
let a = min(max(alpha, 0), 1)
func mix(_ x: CGFloat, _ y: CGFloat) -> CGFloat { x + (y - x) * a }
return CGRect(x: mix(current.minX, target.minX), y: mix(current.minY, target.minY),
width: mix(current.width, target.width), height: mix(current.height, target.height))
}
}
extension CGRect {
/// 夹到 [0,1]×[0,1],并保证仍是非空矩形。Vision 对越界的
/// `regionOfInterest` 会直接报错,不能让噪声把它推出画面。
func clampedToUnitSquare() -> CGRect {
let width = Swift.min(Swift.max(self.width, 0.02), 1)
let height = Swift.min(Swift.max(self.height, 0.02), 1)
let x = Swift.min(Swift.max(minX, 0), 1 - width)
let y = Swift.min(Swift.max(minY, 0), 1 - height)
return CGRect(x: x, y: y, width: width, height: height)
}
}
+9 -3
View File
@@ -28,6 +28,11 @@ struct PairingPayload: Equatable {
/// 二维码是**不可信输入**:它决定了 App 接下来去连哪个地址。因此这里只接受 /// 二维码是**不可信输入**:它决定了 App 接下来去连哪个地址。因此这里只接受
/// 字面量私有 IPv4 + 二维码自称的端口,任何域名、公网地址、带 query/fragment /// 字面量私有 IPv4 + 二维码自称的端口,任何域名、公网地址、带 query/fragment
/// 的 URL 一律拒绝——与 Windows/Android 两端的校验保持一致。 /// 的 URL 一律拒绝——与 Windows/Android 两端的校验保持一致。
///
/// 两种形态都要支持:
/// - **局域网**:`e` 里带一到多个 `http://<私有 IPv4>:<port>`,`w` 为空;
/// - **专用网络**:`e` 为空、`w` 带 SSID/密码,手机加入那张 Wi-Fi 后
/// 从路由表读网关(Windows 的 QFT Direct 走这条)。
enum PairingProtocol { enum PairingProtocol {
static let prefixUpload = "QFTPAIR2:" static let prefixUpload = "QFTPAIR2:"
@@ -80,9 +85,10 @@ enum PairingProtocol {
} }
} }
} }
// iOS 无法用代码加入指定 Wi-Fi(NEHotspotConfiguration 需要付费账号的 // 专用网络(Windows 的 QFT Direct)二维码按设计不携带任何电脑地址:
// entitlement),所以 Direct-AP 二维码在本端必须自带可用 endpoint。 // 手机必须先加入 `w` 里的那张 Wi-Fi,再从路由表读网关。因此
if endpoints.isEmpty { return nil } // 「没有 endpoint」只有在带 Wi-Fi 凭据时才是合法的。
if endpoints.isEmpty && wifi == nil { return nil }
var fileName: String? var fileName: String?
var fileSize: UInt64? var fileSize: UInt64?
+181
View File
@@ -0,0 +1,181 @@
import Foundation
/// 局域网里发现的一台电脑。
struct DesktopPeer: Equatable, Identifiable {
let name: String
let platform: String // windows / macos / linux
let address: String // 私有 IPv4 字面量
let port: Int
let ready: Bool // 对方是否正在「等待接收」
var id: String { "\(address):\(port)" }
var baseURL: String { "http://\(address):\(port)" }
var platformLabel: String {
switch platform {
case "macos": return "macOS"
case "windows": return "Windows"
case "linux": return "Linux"
default: return platform.isEmpty ? "电脑" : platform
}
}
}
/// `QFTBROWSE3` 节点浏览(`desktop/src/discovery.rs` 的客户端实现)。
///
/// 与 `QFTDISC2` 的区别:那个是「我已经有令牌了,帮我找到那台机器」,
/// 用在扫码之后;这个不带令牌,用来先**列出附近有哪些电脑**——
/// iPhone 与 Mac 互传时没有二维码可扫,必须先能看见对方。
///
/// 局限与桌面端相同:UDP 广播只覆盖同一广播域。跨网段或开了 AP 隔离的
/// Wi-Fi 上发现不到对方,此时改用连接码(地址就编在码里)。
enum PeerBrowser {
static let query = "QFTBROWSE3"
static let replyPrefix = "QFTNODE3:"
static let port: UInt16 = 39392
/// 广播一次并收集应答。iOS 首次调用会触发「本地网络」权限弹窗。
static func browse(timeout: TimeInterval = 1.5) async -> [DesktopPeer] {
await withCheckedContinuation { continuation in
DispatchQueue.global(qos: .userInitiated).async {
continuation.resume(returning: blockingBrowse(timeout: timeout))
}
}
}
static func blockingBrowse(timeout: TimeInterval) -> [DesktopPeer] {
let fd = socket(AF_INET, SOCK_DGRAM, 0)
guard fd >= 0 else { return [] }
defer { close(fd) }
var enable: Int32 = 1
setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &enable, socklen_t(MemoryLayout<Int32>.size))
// 单次 recv 的超时要远小于总时长,否则一台都没有时会干等满
var tv = timeval(tv_sec: 0, tv_usec: 200_000)
setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, socklen_t(MemoryLayout<timeval>.size))
var targets = ["255.255.255.255"]
// 部分 Wi-Fi 驱动会丢弃受限广播,定向广播能过——与桌面端同样的兜底
for broadcast in LocalNetwork.directedBroadcastAddresses() where !targets.contains(broadcast) {
targets.insert(broadcast, at: 0)
}
let payload = Data(query.utf8)
for target in targets {
var address = sockaddr_in()
address.sin_family = sa_family_t(AF_INET)
address.sin_port = port.bigEndian
address.sin_addr.s_addr = inet_addr(target)
_ = payload.withUnsafeBytes { buffer -> Int in
withUnsafePointer(to: &address) { pointer in
pointer.withMemoryRebound(to: sockaddr.self, capacity: 1) { sockPointer in
sendto(fd, buffer.baseAddress, buffer.count, 0,
sockPointer, socklen_t(MemoryLayout<sockaddr_in>.size))
}
}
}
}
var found: [String: DesktopPeer] = [:]
let deadline = Date().addingTimeInterval(timeout)
var buffer = [UInt8](repeating: 0, count: 1024)
while Date() < deadline {
var from = sockaddr_in()
var fromLength = socklen_t(MemoryLayout<sockaddr_in>.size)
let received = withUnsafeMutablePointer(to: &from) { pointer -> Int in
pointer.withMemoryRebound(to: sockaddr.self, capacity: 1) { sockPointer in
recvfrom(fd, &buffer, buffer.count, 0, sockPointer, &fromLength)
}
}
if received <= 0 { continue }
var raw = from.sin_addr
var host = [CChar](repeating: 0, count: Int(INET_ADDRSTRLEN))
guard inet_ntop(AF_INET, &raw, &host, socklen_t(INET_ADDRSTRLEN)) != nil else { continue }
let source = String(cString: host)
guard let text = String(bytes: buffer[0..<received], encoding: .utf8),
let peer = parseReply(text, source: source) else { continue }
found[peer.id] = peer
}
// 正在等待接收的排前面,其次按名字,保证列表顺序稳定不跳动
return found.values.sorted { lhs, rhs in
if lhs.ready != rhs.ready { return lhs.ready }
if lhs.name != rhs.name { return lhs.name < rhs.name }
return lhs.address < rhs.address
}
}
/// 应答来自网络,是不可信输入:地址只认私有 IPv4,名字要去掉控制字符。
static func parseReply(_ text: String, source: String) -> DesktopPeer? {
guard text.hasPrefix(replyPrefix), text.count <= 1024 else { return nil }
guard PairingProtocol.isPrivateIPv4(source) else { return nil }
let json = String(text.dropFirst(replyPrefix.count))
guard let object = try? JSONSerialization.jsonObject(with: Data(json.utf8)) as? [String: Any],
let rawPort = object["t"] as? NSNumber else { return nil }
let port = rawPort.intValue
guard (1...65535).contains(port) else { return nil }
let rawName = (object["n"] as? String) ?? "电脑"
let name = String(String(String.UnicodeScalarView(
rawName.unicodeScalars.filter { $0.value > 31 && $0.value != 127 }
)).trimmingCharacters(in: .whitespaces).prefix(64))
let platform = String((object["p"] as? String ?? "")
.filter { $0.isASCII && $0.isLetter || $0.isNumber }.prefix(16))
return DesktopPeer(name: name.isEmpty ? "电脑" : name,
platform: platform,
address: source,
port: port,
ready: (object["r"] as? Bool) ?? false)
}
}
/// 用连接码里的 6 位十六进制秘密换取会话令牌(`POST /qft/pair`)。
///
/// 这是桌面端唯一不校验令牌的端点——它的作用正是换取令牌。
/// 桌面端错 5 次就作废整个码,所以这里绝不重试。
enum DesktopPairing {
static func pair(baseURL: String, code: String, deviceName: String,
timeout: TimeInterval = 6) async throws -> String {
guard let url = URL(string: baseURL + "/qft/pair") else {
throw QFTError.malformedResponse("配对地址无效")
}
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.timeoutInterval = timeout
request.setValue(code, forHTTPHeaderField: "X-QFT-Code")
request.setValue(Base64URL.encode(deviceName), forHTTPHeaderField: "X-QFT-Device")
request.setValue("0", forHTTPHeaderField: "Content-Length")
let configuration = URLSessionConfiguration.ephemeral
configuration.timeoutIntervalForRequest = timeout
configuration.waitsForConnectivity = false
let session = URLSession(configuration: configuration)
defer { session.finishTasksAndInvalidate() }
let (data, response) = try await session.upload(for: request, from: Data())
guard let http = response as? HTTPURLResponse else {
throw QFTError.malformedResponse("非 HTTP 响应")
}
let object = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any] ?? [:]
switch http.statusCode {
case 200:
guard let token = object["token"] as? String,
PairingProtocol.isValidSession(token) else {
throw QFTError.malformedResponse("配对响应缺少可用令牌")
}
return token
case 403:
let remaining = (object["remaining"] as? NSNumber)?.intValue ?? 0
throw QFTError.httpStatus(403, "连接码不对,还可尝试 \(remaining) 次")
case 429:
throw QFTError.httpStatus(429, "连接码已作废,请让电脑重新启动接收")
default:
throw QFTError.httpStatus(http.statusCode, "")
}
}
}
+169 -72
View File
@@ -5,10 +5,11 @@ import CryptoKit
/// 点对点链路:Bonjour 发现 + TLS-PSK 加密 + 长度前缀分帧。 /// 点对点链路:Bonjour 发现 + TLS-PSK 加密 + 长度前缀分帧。
/// ///
/// `includePeerToPeer = true` 让 Network.framework 在没有路由器时 /// `includePeerToPeer = true` 让 Network.framework 在没有路由器时
/// 自动使用 BLE 发现 + AWDL 点对点 Wi-Fi,也就是 AirDrop 用的同一条链路。 /// 自动使用 BLE 发现 + AWDL 点对点 Wi-Fi,也就是隔空投送用的同一条链路。
/// 两台设备在同一个 Wi-Fi 下时它会优先走基础网络,速度同样很快。 /// 两台设备在同一个 Wi-Fi 下时它会优先走基础网络,速度同样很快。
/// ///
/// AWDL 是苹果私有链路,Windows 无法参与——PC 方向仍走 HTTP 局域网路径。 /// AWDL 是苹果私有链路,Windows 无法参与——PC 方向仍走 HTTP
/// 局域网/专用网络路径。
enum PeerLink { enum PeerLink {
static let frameHeaderSize = 5 // 1 字节类型 + 4 字节 BE 长度 static let frameHeaderSize = 5 // 1 字节类型 + 4 字节 BE 长度
@@ -16,10 +17,13 @@ enum PeerLink {
static let maxFrameSize = 4 * 1024 * 1024 static let maxFrameSize = 4 * 1024 * 1024
enum FrameType: UInt8 { enum FrameType: UInt8 {
case manifest = 1 /// 文件清单(JSON)。整个队列只发一次,摘要必须与二维码一致。
case queue = 1
case data = 2 case data = 2
case eof = 3 case eof = 3
case result = 4 case result = 4
case fileBegin = 5
case fileEnd = 6
} }
enum PeerError: LocalizedError { enum PeerError: LocalizedError {
@@ -80,14 +84,22 @@ enum PeerLink {
} }
} }
static func sendJSON(_ connection: NWConnection, type: FrameType,
object: [String: Any]) async throws {
let data = try JSONSerialization.data(withJSONObject: object)
try await send(connection, type: type, payload: data)
}
static func receiveFrame(_ connection: NWConnection) async throws -> (FrameType, Data) { static func receiveFrame(_ connection: NWConnection) async throws -> (FrameType, Data) {
let header = try await receiveExactly(connection, count: frameHeaderSize) let header = try await receiveExactly(connection, count: frameHeaderSize)
guard let type = FrameType(rawValue: header[header.startIndex]) else { guard let type = FrameType(rawValue: header[header.startIndex]) else {
throw PeerError.protocolViolation("未知帧类型 \(header[header.startIndex])") throw PeerError.protocolViolation("未知帧类型 \(header[header.startIndex])")
} }
let length = header[(header.startIndex + 1)...].withUnsafeBytes { // 手工拼大端,不用 loadUnaligned:那个 API 要 Swift 5.7 运行时(iOS 16),
UInt32(bigEndian: $0.loadUnaligned(as: UInt32.self)) // 而这个 App 要一直支持到 iOS 15
} let bytes = [UInt8](header)
let length = (UInt32(bytes[1]) << 24) | (UInt32(bytes[2]) << 16)
| (UInt32(bytes[3]) << 8) | UInt32(bytes[4])
guard length <= UInt32(maxFrameSize) else { guard length <= UInt32(maxFrameSize) else {
throw PeerError.protocolViolation("帧长度 \(length) 超出上限") throw PeerError.protocolViolation("帧长度 \(length) 超出上限")
} }
@@ -122,7 +134,7 @@ enum PeerLink {
timeout: TimeInterval = 15) async throws { timeout: TimeInterval = 15) async throws {
try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
let resumed = Locked(false) let resumed = Locked(false)
func finish(_ error: Error?) { @Sendable func finish(_ error: Error?) {
guard resumed.exchange(true) == false else { return } guard resumed.exchange(true) == false else { return }
if let error { continuation.resume(throwing: error) } else { continuation.resume() } if let error { continuation.resume(throwing: error) } else { continuation.resume() }
} }
@@ -154,7 +166,7 @@ enum PeerLink {
/// 极简互斥包装。continuation 只能 resume 一次,而 stateUpdateHandler /// 极简互斥包装。continuation 只能 resume 一次,而 stateUpdateHandler
/// 可能在多个状态里触发,需要一个原子的「是否已 resume」。 /// 可能在多个状态里触发,需要一个原子的「是否已 resume」。
final class Locked<Value> { final class Locked<Value>: @unchecked Sendable {
private var value: Value private var value: Value
private let lock = NSLock() private let lock = NSLock()
@@ -173,14 +185,22 @@ final class Locked<Value> {
} }
} }
/// 队列传输的进度:既要有总进度,也要说明当前在传第几个文件。
struct PeerTransferUpdate {
let progress: TransferProgress
let fileIndex: Int
let fileCount: Int
let fileName: String
}
// MARK: - 发送端 // MARK: - 发送端
/// 展示二维码的一方。持有文件,等待对方扫码后连入。 /// 展示二维码的一方。持有一个文件队列,等待对方扫码后连入。
final class PeerSender { final class PeerSender {
/// 监听器的状态与排队中的连接。stateUpdateHandler / newConnectionHandler /// 监听器的状态与排队中的连接。stateUpdateHandler / newConnectionHandler
/// 在任意线程触发,而等待方是 async,所以两边都要经过这把锁。 /// 在任意线程触发,而等待方是 async,所以两边都要经过这把锁。
private final class Box { private final class Box: @unchecked Sendable {
let lock = NSLock() let lock = NSLock()
var readyPort: UInt16? var readyPort: UInt16?
var failure: Error? var failure: Error?
@@ -197,15 +217,17 @@ final class PeerSender {
} }
} }
private let fileURL: URL private let fileURLs: [URL]
private let deviceName: String private let deviceName: String
private let queue = DispatchQueue(label: "qft.peer.sender") private let queue = DispatchQueue(label: "qft.peer.sender")
private let box = Box() private let box = Box()
private var listener: NWListener? private var listener: NWListener?
private var pairing: PeerPairing? private var pairing: PeerPairing?
private var files: [PeerFileMeta] = []
private var queuePayload = Data()
init(fileURL: URL, deviceName: String) { init(fileURLs: [URL], deviceName: String) {
self.fileURL = fileURL self.fileURLs = fileURLs
self.deviceName = deviceName self.deviceName = deviceName
} }
@@ -225,27 +247,46 @@ final class PeerSender {
} }
} }
/// 计算文件摘要、启动监听并广播 Bonjour 服务,返回要显示成二维码的配对码。 /// 逐个算摘要、启动监听并广播 Bonjour 服务,返回要显示成二维码的配对码。
/// 会完整读一遍每个文件,调用方应放到后台线程。
func start() throws -> PeerPairing { func start() throws -> PeerPairing {
let attributes = try FileManager.default.attributesOfItem(atPath: fileURL.path) guard !fileURLs.isEmpty else {
throw PeerLink.PeerError.protocolViolation("没有选择任何文件")
}
var metas: [PeerFileMeta] = []
var total: UInt64 = 0
for url in fileURLs {
let attributes = try FileManager.default.attributesOfItem(atPath: url.path)
let size = UInt64(truncating: (attributes[.size] as? NSNumber) ?? 0) let size = UInt64(truncating: (attributes[.size] as? NSNumber) ?? 0)
var hasher = SHA256() var hasher = SHA256()
let handle = try FileHandle(forReadingFrom: fileURL) let handle = try FileHandle(forReadingFrom: url)
var read: UInt64 = 0
while let block = try handle.read(upToCount: 4 * 1024 * 1024), !block.isEmpty { while let block = try handle.read(upToCount: 4 * 1024 * 1024), !block.isEmpty {
hasher.update(data: block) hasher.update(data: block)
read &+= UInt64(block.count)
} }
try handle.close() try handle.close()
// 文件选择器报告的大小偶尔会和实际内容对不上(iCloud 占位文件、
// 正在被其他 App 写入)。以实读为准,否则二维码里的总量是假的。
let digest = hasher.finalize().map { String(format: "%02x", $0) }.joined() let digest = hasher.finalize().map { String(format: "%02x", $0) }.joined()
let name = OpticalProtocol.sanitizeFileName(url.lastPathComponent)
metas.append(PeerFileMeta(name: name, size: read, sha256: digest))
total &+= read
_ = size
}
let payload = try PeerQueue.encode(sender: deviceName, files: metas)
let pairing = PeerPairing( let pairing = PeerPairing(
version: 1, version: 2,
key: PeerPairing.newKey(), key: PeerPairing.newKey(),
instance: PeerPairing.newInstance(), instance: PeerPairing.newInstance(),
senderName: deviceName, senderName: deviceName,
fileName: fileURL.lastPathComponent, fileCount: metas.count,
fileSize: size, totalSize: total,
sha256: digest) queueDigest: PeerQueue.digest(of: payload),
previewName: metas[0].name)
let parameters = PeerLink.parameters(key: pairing.key, identity: pairing.instance) let parameters = PeerLink.parameters(key: pairing.key, identity: pairing.instance)
let listener = try NWListener(using: parameters) let listener = try NWListener(using: parameters)
@@ -290,11 +331,13 @@ final class PeerSender {
self.listener = listener self.listener = listener
self.pairing = pairing self.pairing = pairing
self.files = metas
self.queuePayload = payload
return pairing return pairing
} }
/// 等待一个连接并把文件推过去。 /// 等待一个连接并把整个队列推过去。
func waitAndSend(onProgress: @escaping (TransferProgress) -> Void) async throws { func waitAndSend(onProgress: @escaping (PeerTransferUpdate) -> Void) async throws {
guard let listener, let pairing else { guard let listener, let pairing else {
throw PeerLink.PeerError.handshake("尚未调用 start()") throw PeerLink.PeerError.handshake("尚未调用 start()")
} }
@@ -320,34 +363,44 @@ final class PeerSender {
defer { connection.cancel(); listener.cancel() } defer { connection.cancel(); listener.cancel() }
try await PeerLink.waitReady(connection, queue: queue) try await PeerLink.waitReady(connection, queue: queue)
try await PeerLink.send(connection, type: .queue, payload: queuePayload)
let manifest: [String: Any] = [
"name": pairing.fileName,
"size": NSNumber(value: pairing.fileSize),
"sha256": pairing.sha256,
"sender": pairing.senderName,
]
try await PeerLink.send(connection, type: .manifest,
payload: try JSONSerialization.data(withJSONObject: manifest))
let handle = try FileHandle(forReadingFrom: fileURL)
defer { try? handle.close() }
var sent: UInt64 = 0 var sent: UInt64 = 0
let startedAt = Date() let startedAt = Date()
var lastReport = Date.distantPast var lastReport = Date.distantPast
for (index, meta) in files.enumerated() {
try Task.checkCancellation()
try await PeerLink.sendJSON(connection, type: .fileBegin,
object: ["i": index, "name": meta.name])
let handle = try FileHandle(forReadingFrom: fileURLs[index])
defer { try? handle.close() }
var fileSent: UInt64 = 0
while let block = try handle.read(upToCount: PeerLink.chunkSize), !block.isEmpty { while let block = try handle.read(upToCount: PeerLink.chunkSize), !block.isEmpty {
try Task.checkCancellation() try Task.checkCancellation()
guard fileSent &+ UInt64(block.count) <= meta.size else {
throw PeerLink.PeerError.protocolViolation("本地文件 \(meta.name) 在传输中变大了")
}
try await PeerLink.send(connection, type: .data, payload: block) try await PeerLink.send(connection, type: .data, payload: block)
fileSent &+= UInt64(block.count)
sent &+= UInt64(block.count) sent &+= UInt64(block.count)
let now = Date() let now = Date()
if now.timeIntervalSince(lastReport) > 0.1 || sent >= pairing.fileSize { if now.timeIntervalSince(lastReport) > 0.1 || sent >= pairing.totalSize {
lastReport = now lastReport = now
onProgress(TransferProgress( onProgress(PeerTransferUpdate(
completed: sent, total: pairing.fileSize, progress: TransferProgress(
bytesPerSecond: Double(sent) / max(0.001, now.timeIntervalSince(startedAt)))) completed: sent, total: pairing.totalSize,
bytesPerSecond: Double(sent) / max(0.001, now.timeIntervalSince(startedAt))),
fileIndex: index, fileCount: files.count, fileName: meta.name))
} }
} }
guard fileSent == meta.size else {
throw PeerLink.PeerError.protocolViolation("本地文件 \(meta.name) 只读到 \(fileSent)/\(meta.size) 字节")
}
try await PeerLink.sendJSON(connection, type: .fileEnd, object: ["i": index])
}
try await PeerLink.send(connection, type: .eof, payload: Data()) try await PeerLink.send(connection, type: .eof, payload: Data())
let (type, payload) = try await PeerLink.receiveFrame(connection) let (type, payload) = try await PeerLink.receiveFrame(connection)
@@ -368,7 +421,7 @@ final class PeerSender {
// MARK: - 接收端 // MARK: - 接收端
/// 扫码的一方。按实例名找到对端并接收文件。 /// 扫码的一方。按实例名找到对端并按顺序接收整个队列。
struct PeerReceiver { struct PeerReceiver {
let pairing: PeerPairing let pairing: PeerPairing
@@ -376,7 +429,7 @@ struct PeerReceiver {
/// 测试用:跳过 Bonjour,直接连指定端口。 /// 测试用:跳过 Bonjour,直接连指定端口。
var directPort: UInt16? var directPort: UInt16?
func run(onProgress: @escaping (TransferProgress) -> Void) async throws -> URL { func run(onProgress: @escaping (PeerTransferUpdate) -> Void) async throws -> [URL] {
let queue = DispatchQueue(label: "qft.peer.receiver") let queue = DispatchQueue(label: "qft.peer.receiver")
let parameters = PeerLink.parameters(key: pairing.key, identity: pairing.instance) let parameters = PeerLink.parameters(key: pairing.key, identity: pairing.instance)
@@ -392,54 +445,88 @@ struct PeerReceiver {
defer { connection.cancel() } defer { connection.cancel() }
try await PeerLink.waitReady(connection, queue: queue) try await PeerLink.waitReady(connection, queue: queue)
// --- 清单 --- do {
let (manifestType, manifestPayload) = try await PeerLink.receiveFrame(connection) let saved = try await receiveQueue(connection, onProgress: onProgress)
guard manifestType == .manifest, try await PeerLink.sendJSON(connection, type: .result,
let manifest = try? JSONSerialization.jsonObject(with: manifestPayload) as? [String: Any], object: ["ok": true, "saved": saved.map(\.lastPathComponent)])
let declaredSize = (manifest["size"] as? NSNumber)?.uint64Value, return saved
let declaredHash = manifest["sha256"] as? String else { } catch {
throw PeerLink.PeerError.protocolViolation("清单帧无效") // 让发送端知道为什么停了,而不是收到一个无解释的断连
try? await PeerLink.sendJSON(connection, type: .result,
object: ["ok": false, "error": errorText(error)])
throw error
} }
// 清单必须与二维码一致,否则说明连到的不是扫码时看到的那个文件 }
guard declaredSize == pairing.fileSize, declaredHash == pairing.sha256 else {
try? await PeerLink.send(connection, type: .result, payload: Data( private func receiveQueue(_ connection: NWConnection,
#"{"ok":false,"error":"manifest mismatch"}"#.utf8)) onProgress: @escaping (PeerTransferUpdate) -> Void) async throws -> [URL] {
throw PeerLink.PeerError.protocolViolation("对方声明的文件与二维码不符") // --- 清单 ---
let (queueType, queuePayload) = try await PeerLink.receiveFrame(connection)
guard queueType == .queue else {
throw PeerLink.PeerError.protocolViolation("首帧不是文件清单")
}
// 摘要对着二维码算:扫码看到的是几个文件、多大,收到的就必须是那些
guard PeerQueue.digest(of: queuePayload) == pairing.queueDigest else {
throw PeerLink.PeerError.protocolViolation("文件清单与二维码不符")
}
guard let (_, files) = PeerQueue.decode(queuePayload) else {
throw PeerLink.PeerError.protocolViolation("文件清单无法解析")
}
guard files.count == pairing.fileCount,
files.reduce(UInt64(0), { $0 &+ $1.size }) == pairing.totalSize else {
throw PeerLink.PeerError.protocolViolation("文件清单的数量或总量与二维码不符")
} }
try FileManager.default.createDirectory(at: destinationDirectory, try FileManager.default.createDirectory(at: destinationDirectory,
withIntermediateDirectories: true) withIntermediateDirectories: true)
let partURL = destinationDirectory.appendingPathComponent(pairing.fileName + ".qftpart")
var saved: [URL] = []
var receivedTotal: UInt64 = 0
let startedAt = Date()
var lastReport = Date.distantPast
for (index, meta) in files.enumerated() {
try Task.checkCancellation()
let (beginType, beginPayload) = try await PeerLink.receiveFrame(connection)
guard beginType == .fileBegin,
let begin = try? JSONSerialization.jsonObject(with: beginPayload) as? [String: Any],
(begin["i"] as? Int) == index else {
throw PeerLink.PeerError.protocolViolation("第 \(index + 1) 个文件的起始帧无效")
}
let partURL = destinationDirectory.appendingPathComponent(meta.name + ".qftpart")
try? FileManager.default.removeItem(at: partURL) try? FileManager.default.removeItem(at: partURL)
FileManager.default.createFile(atPath: partURL.path, contents: nil) guard FileManager.default.createFile(atPath: partURL.path, contents: nil) else {
throw QFTError.malformedResponse("无法创建临时文件")
}
let handle = try FileHandle(forWritingTo: partURL) let handle = try FileHandle(forWritingTo: partURL)
var hasher = SHA256() var hasher = SHA256()
var received: UInt64 = 0 var received: UInt64 = 0
let startedAt = Date()
var lastReport = Date.distantPast
// --- 数据 ---
do { do {
loop: while true { loop: while true {
try Task.checkCancellation() try Task.checkCancellation()
let (type, payload) = try await PeerLink.receiveFrame(connection) let (type, payload) = try await PeerLink.receiveFrame(connection)
switch type { switch type {
case .data: case .data:
guard received &+ UInt64(payload.count) <= pairing.fileSize else { guard received &+ UInt64(payload.count) <= meta.size else {
throw PeerLink.PeerError.protocolViolation("收到的数据超出声明大小") throw PeerLink.PeerError.protocolViolation("\(meta.name) 的数据超出声明大小")
} }
try handle.write(contentsOf: payload) try handle.write(contentsOf: payload)
hasher.update(data: payload) hasher.update(data: payload)
received &+= UInt64(payload.count) received &+= UInt64(payload.count)
receivedTotal &+= UInt64(payload.count)
let now = Date() let now = Date()
if now.timeIntervalSince(lastReport) > 0.1 || received >= pairing.fileSize { if now.timeIntervalSince(lastReport) > 0.1 || receivedTotal >= pairing.totalSize {
lastReport = now lastReport = now
onProgress(TransferProgress( onProgress(PeerTransferUpdate(
completed: received, total: pairing.fileSize, progress: TransferProgress(
bytesPerSecond: Double(received) / max(0.001, now.timeIntervalSince(startedAt)))) completed: receivedTotal, total: pairing.totalSize,
bytesPerSecond: Double(receivedTotal)
/ max(0.001, now.timeIntervalSince(startedAt))),
fileIndex: index, fileCount: files.count, fileName: meta.name))
} }
case .eof: case .fileEnd:
break loop break loop
default: default:
throw PeerLink.PeerError.protocolViolation("数据阶段收到 \(type)") throw PeerLink.PeerError.protocolViolation("数据阶段收到 \(type)")
@@ -449,21 +536,31 @@ struct PeerReceiver {
} catch { } catch {
try? handle.close() try? handle.close()
try? FileManager.default.removeItem(at: partURL) try? FileManager.default.removeItem(at: partURL)
saved.forEach { try? FileManager.default.removeItem(at: $0) }
throw error throw error
} }
// --- 校验 ---
let actual = hasher.finalize().map { String(format: "%02x", $0) }.joined() let actual = hasher.finalize().map { String(format: "%02x", $0) }.joined()
guard received == pairing.fileSize, actual == pairing.sha256 else { guard received == meta.size, actual == meta.sha256 else {
try? FileManager.default.removeItem(at: partURL) try? FileManager.default.removeItem(at: partURL)
try? await PeerLink.send(connection, type: .result, payload: Data( saved.forEach { try? FileManager.default.removeItem(at: $0) }
#"{"ok":false,"error":"integrity"}"#.utf8)) throw QFTError.integrity(
throw QFTError.integrity("收到 \(received)/\(pairing.fileSize) 字节,SHA-256 \(actual == pairing.sha256 ? "一致" : "不一致")") "\(meta.name):收到 \(received)/\(meta.size) 字节,SHA-256 \(actual == meta.sha256 ? "一致" : "不一致")")
} }
let finalURL = DownloadClient.uniqueURL(in: destinationDirectory, name: pairing.fileName) let finalURL = DownloadClient.uniqueURL(in: destinationDirectory, name: meta.name)
try FileManager.default.moveItem(at: partURL, to: finalURL) try FileManager.default.moveItem(at: partURL, to: finalURL)
try await PeerLink.send(connection, type: .result, payload: Data(#"{"ok":true}"#.utf8)) saved.append(finalURL)
return finalURL }
let (eofType, _) = try await PeerLink.receiveFrame(connection)
guard eofType == .eof else {
throw PeerLink.PeerError.protocolViolation("队列结束帧无效")
}
return saved
}
private func errorText(_ error: Error) -> String {
String(((error as? LocalizedError)?.errorDescription ?? "\(error)").prefix(200))
} }
} }
+84 -21
View File
@@ -1,14 +1,41 @@
import Foundation import Foundation
import CryptoKit
import Security import Security
/// 隔空投送式点对点配对码。 /// 队列里的一个文件。
struct PeerFileMeta: Equatable {
let name: String
let size: UInt64
let sha256: String
var json: [String: Any] {
["name": name, "size": NSNumber(value: size), "sha256": sha256]
}
static func parse(_ object: [String: Any]) -> PeerFileMeta? {
guard let rawName = (object["name"] as? String)?.trimmingCharacters(in: .whitespaces),
PairingProtocol.isValidFileName(rawName),
!rawName.hasPrefix("."),
let size = (object["size"] as? NSNumber)?.uint64Value,
let hash = (object["sha256"] as? String)?.lowercased(),
PairingProtocol.isValidSHA256(hash) else { return nil }
return PeerFileMeta(name: rawName, size: size, sha256: hash)
}
}
/// 隔空投送式点对点配对码(QFTP2P2)。
/// ///
/// 与 QFTPAIR2/QFTSEND2 的关键区别:那两个是「连到某个 IP」, /// 与 QFTPAIR2/QFTSEND2 的关键区别:那两个是「连到某个 IP」,
/// 这个是「连到某个 Bonjour 服务实例,并用二维码里的预共享密钥做 TLS 认证」。 /// 这个是「连到某个 Bonjour 服务实例,并用二维码里的预共享密钥做 TLS 认证」。
/// 二维码在这里充当带外信道——和 AirDrop 用 BLE 交换身份是同一个作用, /// 二维码在这里充当带外信道——和隔空投送用 BLE 交换身份是同一个作用,
/// 只是我们把身份交换搬到了用户可见的扫码动作上,不需要任何配对弹窗。 /// 只是我们把身份交换搬到了用户可见的扫码动作上,不需要任何配对弹窗。
///
/// 多文件时**文件清单不进二维码**,只放一个 SHA-256 摘要:
/// 十几个文件的元数据会让二维码密到扫不动。清单在 TLS 建立之后才传,
/// 接收端拿摘要比对——扫码这一下依然锁定了「你看到的就是你收到的」。
struct PeerPairing: Equatable { struct PeerPairing: Equatable {
static let prefix = "QFTP2P1:" static let prefix = "QFTP2P2:"
static let serviceType = "_qft-p2p._tcp"
let version: Int let version: Int
/// 32 字节预共享密钥。既是 TLS-PSK,也是服务实例的唯一凭据。 /// 32 字节预共享密钥。既是 TLS-PSK,也是服务实例的唯一凭据。
@@ -16,11 +43,13 @@ struct PeerPairing: Equatable {
/// Bonjour 服务实例名,由发送端随机生成 /// Bonjour 服务实例名,由发送端随机生成
let instance: String let instance: String
let senderName: String let senderName: String
let fileName: String /// 文件数与总字节数,用于扫码后立刻显示「3 个文件 · 1.2 GB」
let fileSize: UInt64 let fileCount: Int
let sha256: String let totalSize: UInt64
/// 清单帧原始字节的 SHA-256(十六进制小写)
static let serviceType = "_qft-p2p._tcp" let queueDigest: String
/// 第一个文件名,纯展示用
let previewName: String
func encode() -> String { func encode() -> String {
let object: [String: Any] = [ let object: [String: Any] = [
@@ -28,9 +57,10 @@ struct PeerPairing: Equatable {
"k": Base64URL.encode(key), "k": Base64URL.encode(key),
"i": instance, "i": instance,
"n": senderName, "n": senderName,
"f": fileName, "c": fileCount,
"z": NSNumber(value: fileSize), "z": NSNumber(value: totalSize),
"h": sha256, "d": queueDigest,
"f": previewName,
] ]
let data = (try? JSONSerialization.data(withJSONObject: object)) ?? Data() let data = (try? JSONSerialization.data(withJSONObject: object)) ?? Data()
return Self.prefix + Base64URL.encode(data) return Self.prefix + Base64URL.encode(data)
@@ -45,24 +75,27 @@ struct PeerPairing: Equatable {
let object = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any] else { let object = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any] else {
return nil return nil
} }
guard (object["v"] as? Int) == 1 else { return nil } guard (object["v"] as? Int) == 2 else { return nil }
guard let keyText = object["k"] as? String, guard let keyText = object["k"] as? String,
let key = Base64URL.decode(keyText), key.count == 32 else { return nil } let key = Base64URL.decode(keyText), key.count == 32 else { return nil }
guard let instance = object["i"] as? String, isValidInstance(instance) else { return nil } guard let instance = object["i"] as? String, isValidInstance(instance) else { return nil }
guard let fileName = (object["f"] as? String)?.trimmingCharacters(in: .whitespaces), guard let count = object["c"] as? Int, (1...512).contains(count) else { return nil }
PairingProtocol.isValidFileName(fileName) else { return nil } guard let total = (object["z"] as? NSNumber)?.uint64Value else { return nil }
guard let size = object["z"] as? NSNumber, size.int64Value >= 0 else { return nil } guard let digest = (object["d"] as? String)?.lowercased(),
guard let hash = (object["h"] as? String)?.lowercased(), PairingProtocol.isValidSHA256(digest) else { return nil }
PairingProtocol.isValidSHA256(hash) else { return nil }
let preview = (object["f"] as? String)?.trimmingCharacters(in: .whitespaces) ?? ""
guard preview.isEmpty || PairingProtocol.isValidFileName(preview) else { return nil }
return PeerPairing( return PeerPairing(
version: 1, version: 2,
key: key, key: key,
instance: instance, instance: instance,
senderName: String(((object["n"] as? String) ?? "iPhone").prefix(80)), senderName: String(((object["n"] as? String) ?? "iPhone").prefix(80)),
fileName: fileName, fileCount: count,
fileSize: UInt64(size.int64Value), totalSize: total,
sha256: hash queueDigest: digest,
previewName: String(preview.prefix(180))
) )
} }
@@ -92,3 +125,33 @@ struct PeerPairing: Equatable {
return "qft-" + String(bytes.map { alphabet[Int($0) % alphabet.count] }) return "qft-" + String(bytes.map { alphabet[Int($0) % alphabet.count] })
} }
} }
/// 清单帧的编解码。
///
/// 摘要是对**帧的原始字节**取的,不是对重新序列化的结果——重新序列化
/// 会因为键顺序或数字格式的差异而算出不同的摘要,那种「几乎总是对」的
/// 校验在真机上迟早会咬人。
enum PeerQueue {
static func encode(sender: String, files: [PeerFileMeta]) throws -> Data {
let object: [String: Any] = ["v": 2, "sender": sender, "files": files.map(\.json)]
return try JSONSerialization.data(withJSONObject: object, options: [.sortedKeys])
}
static func decode(_ data: Data) -> (sender: String, files: [PeerFileMeta])? {
guard let object = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any],
(object["v"] as? Int) == 2,
let rawFiles = object["files"] as? [[String: Any]], !rawFiles.isEmpty else { return nil }
var files: [PeerFileMeta] = []
for raw in rawFiles {
guard let file = PeerFileMeta.parse(raw) else { return nil }
files.append(file)
}
let sender = String(((object["sender"] as? String) ?? "iPhone").prefix(80))
return (sender, files)
}
static func digest(of data: Data) -> String {
SHA256.hash(data: data).map { String(format: "%02x", $0) }.joined()
}
}
+300
View File
@@ -0,0 +1,300 @@
import Foundation
import CryptoKit
/// 电脑 → iPhone 的**并行 Range 下载**。
///
/// 与旧的单流下载相比:把文件切成自适应大小的块,最多 8 路并发请求,
/// 每块独立重试,完成情况写进 `.qftpart` 旁边的账本,中断后只补没收到的块。
/// 这与 Android 端的策略一致,也是「iPhone ↔ Mac 走局域网但要更高效」的落点:
/// 单条 TCP 在 Wi-Fi 上打不满,多路才能吃满链路。
///
/// 桌面端 `sender.rs` 支持精确的 `Range`(`206` + `Content-Range`),并且能在
/// 一条连接上连续服务多个 Range 请求,所以这里不需要任何桌面端改动。
struct RangeDownloadClient {
struct Target {
var fileName: String
var fileSize: UInt64
/// 二维码里带 SHA-256 时才做整份校验;浏览发现的下载没有这个值
var sha256: String?
}
let host: QFTHost
let token: String
let deviceName: String
let destinationDirectory: URL
static let maxWorkers = 8
static let minChunkSize: UInt64 = 64 * 1024
static let maxChunkSize: UInt64 = 16 * 1024 * 1024
static let retriesPerChunk = 5
/// 目标 8 路并发,块大小落在 64 KiB–16 MiB。
/// 小文件自然只会有一个请求,不会为了并发而把块切碎。
static func chunkSize(for size: UInt64) -> UInt64 {
guard size > 0 else { return minChunkSize }
let ideal = (size + UInt64(maxWorkers) - 1) / UInt64(maxWorkers)
return min(maxChunkSize, max(minChunkSize, ideal))
}
// MARK: - 探测
/// 用 `Range: bytes=0-0` 问出文件名与总长度。
/// 没有二维码的场景(浏览发现的电脑)靠它拿到元数据。
func probe(timeout: TimeInterval = 8) async throws -> Target {
var request = try makeRequest()
request.setValue("bytes=0-0", forHTTPHeaderField: "Range")
request.timeoutInterval = timeout
let configuration = URLSessionConfiguration.ephemeral
configuration.timeoutIntervalForRequest = timeout
let session = URLSession(configuration: configuration)
defer { session.finishTasksAndInvalidate() }
let (_, response) = try await session.data(for: request)
guard let http = response as? HTTPURLResponse else {
throw QFTError.malformedResponse("非 HTTP 响应")
}
guard http.statusCode == 206 || http.statusCode == 200 else {
throw QFTError.httpStatus(http.statusCode,
http.statusCode == 403 ? "会话已失效" : "")
}
var size: UInt64 = 0
if let range = http.value(forHTTPHeaderField: "Content-Range"),
let total = range.split(separator: "/").last, let value = UInt64(total) {
size = value
} else if http.expectedContentLength > 0 {
size = UInt64(http.expectedContentLength)
}
var name = "qft-download.bin"
if let encoded = http.value(forHTTPHeaderField: "X-QFT-Filename"),
let decoded = Base64URL.decodeString(encoded) {
name = OpticalProtocol.sanitizeFileName(decoded)
}
return Target(fileName: name, fileSize: size, sha256: nil)
}
// MARK: - 下载
func run(_ target: Target, onProgress: @escaping (TransferProgress) -> Void) async throws -> URL {
try FileManager.default.createDirectory(at: destinationDirectory,
withIntermediateDirectories: true)
let partURL = destinationDirectory.appendingPathComponent(target.fileName + ".qftpart")
let ledgerURL = destinationDirectory.appendingPathComponent(target.fileName + ".qftpart.ledger")
let chunk = Self.chunkSize(for: target.fileSize)
let totalChunks = target.fileSize == 0 ? 0
: Int((target.fileSize + chunk - 1) / chunk)
var completed = [Bool](repeating: false, count: totalChunks)
if let ledger = DownloadLedger.load(from: ledgerURL),
ledger.matches(size: target.fileSize, chunkSize: chunk, sha256: target.sha256),
ledger.completed.count == totalChunks,
(try? FileManager.default.attributesOfItem(atPath: partURL.path)[.size] as? NSNumber)?
.uint64Value == target.fileSize {
completed = ledger.completed
} else {
try? FileManager.default.removeItem(at: partURL)
try? FileManager.default.removeItem(at: ledgerURL)
guard FileManager.default.createFile(atPath: partURL.path, contents: nil) else {
throw QFTError.malformedResponse("无法创建临时文件")
}
let handle = try FileHandle(forWritingTo: partURL)
try handle.truncate(atOffset: target.fileSize)
try handle.close()
}
if totalChunks > 0 {
let ledger = DownloadLedgerActor(url: ledgerURL, size: target.fileSize,
chunkSize: chunk, sha256: target.sha256,
completed: completed)
let alreadyDone = UInt64(completed.filter { $0 }.count) * chunk
let counter = ByteCounter(total: target.fileSize, onProgress: onProgress)
await counter.add(min(alreadyDone, target.fileSize))
let pending = (0..<totalChunks).filter { !completed[$0] }
let queue = ValueQueue(pending)
try await withThrowingTaskGroup(of: Void.self) { group in
let workers = min(pending.count, Self.maxWorkers)
for _ in 0..<workers {
group.addTask {
let handle = try FileHandle(forWritingTo: partURL)
defer { try? handle.close() }
while let index = await queue.next() {
try Task.checkCancellation()
let offset = UInt64(index) * chunk
let length = min(chunk, target.fileSize - offset)
let body = try await fetchChunk(offset: offset, length: length)
try handle.seek(toOffset: offset)
try handle.write(contentsOf: body)
await ledger.markCompleted(index)
await counter.add(length)
}
try handle.synchronize()
}
}
try await group.waitForAll()
}
await ledger.flush()
}
// --- 校验 ---
let actualSize = (try FileManager.default.attributesOfItem(atPath: partURL.path)[.size]
as? NSNumber)?.uint64Value ?? 0
guard actualSize == target.fileSize else {
throw QFTError.integrity("落盘 \(actualSize) 字节,电脑声明 \(target.fileSize) 字节")
}
if let expected = target.sha256 {
let actual = try OpticalAssembler.sha256(of: partURL)
.map { String(format: "%02x", $0) }.joined()
guard actual == expected else {
try? FileManager.default.removeItem(at: partURL)
try? FileManager.default.removeItem(at: ledgerURL)
throw QFTError.integrity("SHA-256 不匹配,文件已丢弃")
}
}
let finalURL = DownloadClient.uniqueURL(in: destinationDirectory, name: target.fileName)
try FileManager.default.moveItem(at: partURL, to: finalURL)
try? FileManager.default.removeItem(at: ledgerURL)
return finalURL
}
// MARK: - 单块
private func fetchChunk(offset: UInt64, length: UInt64) async throws -> Data {
var lastError: Error = QFTError.malformedResponse("未知错误")
for attempt in 0..<Self.retriesPerChunk {
do {
var request = try makeRequest()
request.setValue("bytes=\(offset)-\(offset + length - 1)",
forHTTPHeaderField: "Range")
let configuration = URLSessionConfiguration.ephemeral
configuration.timeoutIntervalForRequest = 60
configuration.timeoutIntervalForResource = 300
let session = URLSession(configuration: configuration)
defer { session.finishTasksAndInvalidate() }
let (data, response) = try await session.data(for: request)
guard let http = response as? HTTPURLResponse else {
throw QFTError.malformedResponse("非 HTTP 响应")
}
if http.statusCode == 403 {
throw QFTError.httpStatus(403, "会话已失效,请让电脑重新生成二维码或连接码")
}
// 200 表示对端忽略了 Range,整份文件都会被送过来——
// 并行下载在这种服务端上不成立,必须显式失败让上层回落单流。
// 这种失败重试多少次都不会变,所以下面的 catch 里直接抛出。
guard http.statusCode == 206 else {
throw QFTError.rangeUnsupported(http.statusCode)
}
guard UInt64(data.count) == length else {
throw QFTError.integrity("第 \(offset / max(1, length)) 块收到 \(data.count) 字节,应为 \(length)")
}
return data
} catch {
lastError = error
if case QFTError.httpStatus(let code, _) = error, code == 403 { throw error }
// 重试改变不了的错误立刻上抛,别白白烧掉 5 轮退避
if case QFTError.rangeUnsupported = error { throw error }
if error is CancellationError { throw error }
try? await Task.sleep(nanoseconds: UInt64(150_000_000) << UInt64(min(attempt, 4)))
}
}
throw lastError
}
private func makeRequest() throws -> URLRequest {
guard let url = URL(string: host.baseURL + "/qft/download") else {
throw QFTError.malformedResponse("下载地址无效")
}
var request = URLRequest(url: url)
request.httpMethod = "GET"
request.timeoutInterval = 60
request.setValue(token, forHTTPHeaderField: "X-QFT-Token")
request.setValue(Base64URL.encode(deviceName), forHTTPHeaderField: "X-QFT-Device")
return request
}
}
// MARK: - 断点账本
/// `.qftpart` 只说明「文件占了多大」,不说明「哪些块是好的」。
/// 并行下载的块是乱序落盘的,没有账本就无法安全续传——这也是不能沿用
/// 单流下载那套「已落盘长度即断点」的原因。
struct DownloadLedger {
let size: UInt64
let chunkSize: UInt64
let sha256: String?
var completed: [Bool]
func matches(size: UInt64, chunkSize: UInt64, sha256: String?) -> Bool {
self.size == size && self.chunkSize == chunkSize && self.sha256 == sha256
}
func encode() -> Data {
let object: [String: Any] = [
"v": 1,
"size": NSNumber(value: size),
"chunk": NSNumber(value: chunkSize),
"sha256": sha256 ?? "",
"bits": completed.map { $0 ? 1 : 0 },
]
return (try? JSONSerialization.data(withJSONObject: object)) ?? Data()
}
static func load(from url: URL) -> DownloadLedger? {
guard let data = try? Data(contentsOf: url),
let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
(object["v"] as? Int) == 1,
let size = (object["size"] as? NSNumber)?.uint64Value,
let chunk = (object["chunk"] as? NSNumber)?.uint64Value, chunk > 0,
let bits = object["bits"] as? [Int] else { return nil }
let sha = object["sha256"] as? String
return DownloadLedger(size: size, chunkSize: chunk,
sha256: (sha?.isEmpty ?? true) ? nil : sha,
completed: bits.map { $0 != 0 })
}
}
/// 账本的串行写入端。落盘限频,避免每块都写一次小文件。
actor DownloadLedgerActor {
private let url: URL
private var ledger: DownloadLedger
private var lastFlush = Date.distantPast
init(url: URL, size: UInt64, chunkSize: UInt64, sha256: String?, completed: [Bool]) {
self.url = url
self.ledger = DownloadLedger(size: size, chunkSize: chunkSize,
sha256: sha256, completed: completed)
}
func markCompleted(_ index: Int) {
guard index < ledger.completed.count else { return }
ledger.completed[index] = true
if Date().timeIntervalSince(lastFlush) > 1 { flush() }
}
func flush() {
lastFlush = Date()
try? ledger.encode().write(to: url, options: .atomic)
}
}
/// 分发待下载块序号。
actor ValueQueue {
private var values: [Int]
private var cursor = 0
init(_ values: [Int]) { self.values = values }
func next() -> Int? {
guard cursor < values.count else { return nil }
defer { cursor += 1 }
return values[cursor]
}
}
+176
View File
@@ -0,0 +1,176 @@
import Foundation
/// 路由表与广播地址推导。
///
/// 加入「QFT Direct」这类专用 Wi-Fi 之后,电脑就是这条链路上的**网关**——
/// Android 端正是从系统给该连接的路由表里读网关,iOS 这边只能自己读
/// `sysctl(CTL_NET, PF_ROUTE, …)`。这一步不是可有可无的优化:专用网络的
/// 二维码按设计不携带任何电脑地址(见 `desktop/src/pairing.rs::qr_endpoints`),
/// 不读路由表就只剩下全子网扫描。
extension LocalNetwork {
/// 各网卡的定向广播地址(如 192.168.1.255)。
static func directedBroadcastAddresses() -> [String] {
var result: [String] = []
for interface in activeInterfaces() {
guard let ip = ipv4(interface.address), let mask = ipv4(interface.netmask),
mask != 0, mask != UInt32.max else { continue }
let broadcast = format(ip | ~mask)
if !result.contains(broadcast) { result.append(broadcast) }
}
return result
}
/// 默认路由的网关地址,按 en0(Wi-Fi)优先排序。
static func defaultGateways() -> [String] {
var gateways: [(interface: String, address: String)] = []
for entry in routeEntries() where entry.isDefault {
guard PairingProtocol.isPrivateIPv4(entry.gateway) else { continue }
if gateways.contains(where: { $0.address == entry.gateway }) { continue }
gateways.append((entry.interface, entry.gateway))
}
return gateways
.sorted { lhs, _ in lhs.interface == "en0" }
.map(\.address)
}
/// 定位电脑时的候选地址,按「最可能是那台电脑」排序:
/// 默认网关(专用网络下必然是电脑)→ 本子网的 .1 → 其余子网地址。
static func hostCandidates(port: Int, limit: Int = 254) -> [String] {
var result: [String] = []
func push(_ address: String) {
let endpoint = "http://\(address):\(port)"
if !result.contains(endpoint) { result.append(endpoint) }
}
for gateway in defaultGateways() { push(gateway) }
for interface in activeInterfaces() {
guard let ip = ipv4(interface.address), let mask = ipv4(interface.netmask) else { continue }
push(format((ip & mask) &+ 1))
}
for endpoint in subnetCandidates(port: port, limit: limit) where !result.contains(endpoint) {
result.append(endpoint)
}
return result
}
// MARK: - sysctl 路由表
struct RouteEntry {
let interface: String
let gateway: String
/// 目的地址为 0.0.0.0 即默认路由
let isDefault: Bool
}
/// `net/route.h` 里的常量。
///
/// **iOS SDK 不导出 `net/route.h`**(macOS SDK 才有),连桥接头文件都救不了——
/// 那个头文件根本不在 iPhoneOS.sdk 里。内核 ABI 两边是同一套,所以这里按
/// 已公开的报文布局手写。`CoreTests` 会在 macOS 上拿真类型逐个字段做交叉校验,
/// 一旦布局变了测试立刻红。
enum RouteMessage {
static let version: UInt8 = 5 // RTM_VERSION
static let gatewayFlag: Int32 = 0x2 // RTF_GATEWAY
static let addressSlots = 8 // RTAX_MAX
static let destinationSlot = 0 // RTAX_DST
static let gatewaySlot = 1 // RTAX_GATEWAY
/// `struct rt_msghdr` 的字段偏移与整体大小。
/// ```c
/// u_short rtm_msglen; u_char rtm_version; u_char rtm_type;
/// u_short rtm_index; /* 2 字节填充 */ int rtm_flags;
/// int rtm_addrs; pid_t rtm_pid; int rtm_seq;
/// int rtm_errno; int rtm_use; u_int32_t rtm_inits;
/// struct rt_metrics rtm_rmx; /* 14 × u_int32_t */
/// ```
static let messageLengthOffset = 0
static let versionOffset = 2
static let interfaceIndexOffset = 4
static let addressMaskOffset = 12
static let headerSize = 92
}
static func routeEntries() -> [RouteEntry] {
var mib: [Int32] = [CTL_NET, PF_ROUTE, 0, AF_INET,
NET_RT_FLAGS, RouteMessage.gatewayFlag]
var length = 0
guard sysctl(&mib, u_int(mib.count), nil, &length, nil, 0) == 0, length > 0 else { return [] }
var buffer = [UInt8](repeating: 0, count: length)
// 两次 sysctl 之间路由表可能变长,第二次会写回实际长度
guard sysctl(&mib, u_int(mib.count), &buffer, &length, nil, 0) == 0,
length <= buffer.count else { return [] }
var entries: [RouteEntry] = []
var offset = 0
let headerSize = RouteMessage.headerSize
while offset + headerSize <= length {
let messageLength = Int(readU16(buffer, offset + RouteMessage.messageLengthOffset))
guard messageLength >= headerSize, offset + messageLength <= length else { break }
defer { offset += messageLength }
// 版本不认识就整条跳过,而不是硬着头皮按旧布局读
guard buffer[offset + RouteMessage.versionOffset] == RouteMessage.version else { continue }
let interfaceIndex = readU16(buffer, offset + RouteMessage.interfaceIndexOffset)
let addressMask = Int32(bitPattern: readU32(buffer, offset + RouteMessage.addressMaskOffset))
var cursor = offset + headerSize
var destination: String?
var gateway: String?
// sockaddr 按 RTAX_* 顺序紧跟在头之后,由 rtm_addrs 位图指明哪些存在
for slot in 0..<RouteMessage.addressSlots {
guard addressMask & (1 << Int32(slot)) != 0 else { continue }
guard cursor + 2 <= offset + messageLength else { break }
let saLength = Int(buffer[cursor]) // sockaddr.sa_len
let family = buffer[cursor + 1] // sockaddr.sa_family
if family == UInt8(AF_INET), saLength >= MemoryLayout<sockaddr_in>.size,
cursor + MemoryLayout<sockaddr_in>.size <= offset + messageLength {
var inet = sockaddr_in()
// memcpy 而不是 loadUnaligned:既解决对齐,
// 也不依赖只在 iOS 16+ 才有的 Swift 5.7 运行时
buffer.withUnsafeBytes { raw in
guard let base = raw.baseAddress else { return }
memcpy(&inet, base + cursor, MemoryLayout<sockaddr_in>.size)
}
var address = inet.sin_addr
var text = [CChar](repeating: 0, count: Int(INET_ADDRSTRLEN))
if inet_ntop(AF_INET, &address, &text, socklen_t(INET_ADDRSTRLEN)) != nil {
let value = String(cString: text)
if slot == RouteMessage.destinationSlot { destination = value }
if slot == RouteMessage.gatewaySlot { gateway = value }
}
}
// 每个 sockaddr 按 4 字节对齐,长度为 0 时仍占 4 字节
cursor += saLength > 0 ? (1 + ((saLength - 1) | 3)) : 4
}
guard let gateway else { continue }
var name = [CChar](repeating: 0, count: Int(IFNAMSIZ) + 1)
let interface = if_indextoname(UInt32(interfaceIndex), &name) != nil
? String(cString: name) : ""
entries.append(RouteEntry(interface: interface, gateway: gateway,
isDefault: destination == "0.0.0.0"))
}
return entries
}
/// 报文里的整数是**主机序**,用 memcpy 拷进原生类型,
/// 这样既不假设字节序,也不要求对齐。
private static func readU16(_ bytes: [UInt8], _ offset: Int) -> UInt16 {
var value: UInt16 = 0
bytes.withUnsafeBytes { raw in
guard let base = raw.baseAddress else { return }
memcpy(&value, base + offset, 2)
}
return value
}
private static func readU32(_ bytes: [UInt8], _ offset: Int) -> UInt32 {
var value: UInt32 = 0
bytes.withUnsafeBytes { raw in
guard let base = raw.baseAddress else { return }
memcpy(&value, base + offset, 4)
}
return value
}
}
+17
View File
@@ -0,0 +1,17 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<!--
自动加入电脑的专用 Wi-Fi(Windows 的 QFT Direct)所需的能力。
这个 entitlement 只有**付费开发者账号**能签出来;免费账号带上它会
直接签名失败,所以工程默认**不引用**本文件:
Build Settings → QFT_ENTITLEMENTS = QFT/QFT.entitlements
设置之后重新签名即可。没有它时 App 不会假装成功,而是显示 SSID/密码
引导用户去「设置」里手动连一次,后续流程完全相同。
-->
<key>com.apple.developer.networking.HotspotConfiguration</key>
<true/>
</dict>
</plist>
+188 -48
View File
@@ -1,12 +1,30 @@
# QFT iOS 客户端 v0.4.6 # QFT iOS 客户端 v0.5.0
三种传输方式: 对齐当前 Windows / macOS / Android 三端的能力,四条链路:
| 方向 | 链路 | 说明 | | 方向 | 链路 | 说明 |
|---|---|---| |---|---|---|
| 电脑 → iPhone | 局域网 HTTP | 扫 Windows 端的 `QFTSEND2` 码,自动下载,支持断点续传 | | 电脑 → iPhone(光学) | **屏幕 → 摄像头** | 扫电脑「光学传输」页循环播放的 QFT2 二维码,文件数据完全不经过网络 |
| iPhone → 电脑 | 局域网 HTTP | 扫 `QFTPAIR2` 码,选文件后并行分块上传 | | iPhone ↔ Windows | **专用网络(QFT Direct)** | 扫码后加入电脑开的专用 Wi-Fi,从路由表认出网关即电脑 |
| **iPhone ↔ iPhone** | **点对点直连** | 发送方显示二维码,接收方扫码,**不需要连同一个 Wi-Fi** | | iPhone ↔ Mac / Linux | **局域网** | 扫二维码,或直接输电脑上的连接码;下发走 8 路并行 Range |
| iPhone ↔ iPhone | **隔空(AWDL 点对点)** | 多选文件后显示二维码,对方扫一下即可,**不需要连同一个 Wi-Fi** |
本次改动只在 `ios/` 目录内,未改动 `desktop/`(Windows/macOS/Linux)与 `android/` 的任何实现。
## 系统版本与向下兼容
- **最低系统:iOS 15.0**,覆盖 iPhone 6s(2015)及以后,与 Android 端 `minSdk 24`
(Android 7.0,2016)覆盖的机型年代大致相当。
- 再往下走不动了:`URLSession` 的 async 接口是 iOS 15 才有的,低于 15 就要把
全部网络代码改回 completion handler,代价与收益不成比例。
- 新系统上更好的实现照样用,但一律走 `App/Compatibility.swift` 分叉,不把整个
App 的部署目标顶上去:
- `NavigationStack` / `ShareLink` / `LabeledContent`(iOS 16)→ iOS 15 上分别回落
`NavigationView` / `UIActivityViewController` / 手写 `HStack`;
- 两参数 `onChange`(iOS 17)→ 统一用 `onReceive`;
- `videoRotationAngle`(iOS 17)→ iOS 15/16 上用 `videoOrientation`;
- `UnsafeRawPointer.loadUnaligned`(Swift 5.7 运行时 / iOS 16)→ 改成手工拼大端
与 `memcpy`。
## 打开工程 ## 打开工程
@@ -24,74 +42,179 @@ Target → Signing & Capabilities 里选一下你自己的开发者账号(免
python3 ios/tools/generate_xcodeproj.py python3 ios/tools/generate_xcodeproj.py
``` ```
- 最低系统:iOS 17.0 Bundle ID:`com.qft.transfer`(按需改 `generate_xcodeproj.py` 里的常量)。
- Bundle ID:`com.qft.transfer`(按需改 `generate_xcodeproj.py` 里的常量)
## 隔空投送式点对点传输 ## 光学接收(不用网络的那条)
`PeerLink` 用 `Network.framework` 并打开 `includePeerToPeer`。底层就是 首页「光学接收」对准电脑的「光学传输」页即可。这条链路上文件数据**只经过屏幕和
AirDrop 用的那条链路——BLE 发现 + AWDL 点对点 Wi-Fi,两台设备不需要路由器, 摄像头**——Wi-Fi、蓝牙、局域网、互联网都不参与,因此也是「电脑不允许接任何网络」
也不需要连同一个 Wi-Fi。两端在同一个 Wi-Fi 下时它会自动优先走基础网络。 场合下唯一可用的路径。
握手用 **TLS-PSK**:预共享密钥(32 字节)由发送端随机生成并写进二维码, 实现与 Android 端同一套状态机,只是解码器换成 Vision:
扫码这个动作本身就完成了带外密钥交换与双向认证。没扫到码的第三方
连上来也过不了 TLS 握手,因此不需要任何证书体系,也不需要配对弹窗。 ```text
居中搜索(92% 画面)
↓ 解出一帧
按条码外接框建立 ROI(放大 1.22 倍、按像素修成正方形)
↓
后续只把 ROI 交给 Vision
↓ 轻微移动:平滑跟随(alpha 0.35)
↓ 连续 3 帧丢失:逐级放大 ROI
↓ 连续 12 帧丢失:回到全画面重新搜索
```
其它与 Android 对齐的点:
- 相机格式在「支持 ≥60 FPS 的格式里取分辨率最高的」,锁定固定帧率,关 HDR 与防抖;
- `alwaysDiscardsLateVideoFrames`,追不上就丢,不播放过时的相机帧;
- 锁定后每 2.5 秒在 ROI 中心重新对焦/测光(屏幕是平面光源,连续自动对焦会拉风箱);
- 屏幕上同一帧会被连续拍到多次,重复帧不会重复送进装配器;UI 同时显示
**解码/s** 和**有效新帧/s**——决定传输时间的是后者,据此在电脑端选 30 / 45 / 60 FPS;
- 每帧 CRC32 + 整份 SHA-256,校验不过就整份丢弃等下一轮重播,绝不把半份文件交给用户。
## 专用网络(iPhone ↔ Windows)
Windows 进入接收后会用 Wi-Fi Direct Legacy AP 开一张专用网,二维码里**按设计不带
任何电脑地址**(见 `desktop/src/pairing.rs::qr_endpoints`):手机必须先加入那张
Wi-Fi,再从路由表里把网关认出来——那就是电脑。
iOS 侧两条路径,取决于**签名能力**:
| 情况 | 行为 |
|---|---|
| 有 `HotspotConfiguration` entitlement | `NEHotspotConfiguration` 自动加入(`joinOnce`,会话结束不留在系统 Wi-Fi 列表里) |
| 没有(免费账号) | 显示 SSID / 密码 + 「打开设置」,用户手动连一次,回 App 点「我已连上」继续 |
**不会假装成功**:拿不到能力时直接转手动引导,而不是让用户对着一个永远连不上的
进度条等下去。
entitlement 只有付费账号签得出来,带上它免费账号会直接签名失败,因此工程默认
**不引用** `QFT/QFT.entitlements`。要开启:
```
Target → Build Settings → QFT_ENTITLEMENTS = QFT/QFT.entitlements
```
加入之后判据不是「系统说加好了」,而是**协议层握手成功**——能用正确令牌 ping 通
`/qft/ping` 才算数。系统接受配置 ≠ 拿到 IPv4 ≠ 电脑那侧的 Wi-Fi Direct 数据通道已建立。
## 局域网(iPhone ↔ Mac / Linux)
两种入口:
1. **扫二维码**:和 Windows 的 LAN 模式完全一样。
2. **连接码**:电脑上打开 QFT →「电脑 ↔ 电脑」→「我要接收」,屏幕上会显示
`K7M2-9X4P-QR3T` 这样一串码,**地址、端口和配对秘密都编在码里**。iPhone 在
「连接附近的电脑」页输入即可,不用扫码、不要求同网段可广播。
「附近的电脑」列表用 `QFTBROWSE3` 广播(`desktop/src/discovery.rs` 的客户端实现),
只是帮用户确认「就是这台」;真正建立会话仍然靠连接码换令牌(`POST /qft/pair`)。
电脑端输错 5 次即作废整个码,所以 App 绝不重试。
**边界说清楚**:连接码换来的是电脑**接收端**的会话,因此这条路径只能「把文件发到
电脑」。要让电脑下发文件,请在电脑上选好文件后扫它生成的二维码。
### 更高效在哪
电脑下发改成 **8 路并行 Range 下载**:
- 块大小按文件自适应,落在 64 KiB–16 MiB,目标 8 路并发;
- 每块最多重试 5 次,403 立即失败不重试;
- 完成情况写进 `.qftpart` 旁边的账本(并行块是乱序落盘的,「已落盘长度即断点」
那套在这里不成立),中断后只补没收到的块;
- 全部收齐后单遍 SHA-256,通过才 rename;
- 对端返回 200(忽略了 Range)时显式失败并**回落单流下载**,不会因为遇到老版本
电脑端就直接报错。
## 隔空(iPhone ↔ iPhone)
`PeerLink` 用 `Network.framework` 并打开 `includePeerToPeer`。底层就是隔空投送用的
那条链路——BLE 发现 + AWDL 点对点 Wi-Fi,两台设备不需要路由器,也不需要连同一个
Wi-Fi。两端在同一个 Wi-Fi 下时它会自动优先走基础网络。
握手用 **TLS-PSK**:预共享密钥(32 字节)由发送端随机生成并写进二维码,扫码这个
动作本身就完成了带外密钥交换与双向认证。没扫到码的第三方连上来也过不了 TLS 握手,
因此不需要任何证书体系,也不需要配对弹窗。
v0.5.0 起支持**多文件队列**(对齐 Android → Android 的手机互传):
``` ```
发送方 接收方 发送方 接收方
选文件 → 算 SHA-256 多选文件 → 逐个算 SHA-256
启动 NWListener(Bonjour: _qft-p2p._tcp) 启动 NWListener(Bonjour: _qft-p2p._tcp)
生成 32 字节 PSK 生成 32 字节 PSK
显示 QFTP2P1 二维码 ──────扫码────→ 解析出 PSK + 服务实例名 显示 QFTP2P2 二维码 ──────扫码────→ 解析出 PSK + 服务实例名 + 清单摘要
NWBrowser 找到实例 NWBrowser 找到实例
←──────── TLS-PSK 握手 ────────→ ←──────── TLS-PSK 握手 ────────→
MANIFEST(JSON) ─────────────────────→ 校验与二维码是否一致 QUEUE(JSON 清单) ───────────────────→ 摘要必须与二维码一致
DATA × N ─────────────────────→ 落盘 + 增量 SHA-256 FILE_BEGIN / DATA×N / FILE_END ─────→ 逐个落盘 + 单文件 SHA-256
EOF ─────────────────────→ (对队列里每个文件重复)
←──────── RESULT(JSON) ──────── 校验通过才 rename EOF ────────────────────→
←──────── RESULT(JSON) ──────── 全部通过才算成功
``` ```
**AWDL 是苹果私有链路,Windows 无法参与**,所以与电脑互传仍走局域网 HTTP。 **文件清单不进二维码**,只放一个 SHA-256 摘要:十几个文件的元数据会让二维码密到
如果现场没有路由器,可行的替代是让 iPhone 开个人热点、电脑连上来。 扫不动。清单在 TLS 建立之后才传,接收端拿摘要比对——扫码这一下依然锁定了
「你看到的就是你收到的」。摘要对的是**清单帧的原始字节**,不是重新序列化的结果。
## 已知的 iOS 平台限制 > QFTP2P1(单文件)已移除。iOS 端从未发布过,保留一个没有用户的线格式只会腐坏。
1. **无法用代码连接指定 Wi-Fi。** Android 端用 `WifiNetworkSpecifier` 自动加入 **AWDL 是苹果私有链路,Windows/Android 无法参与**,所以与电脑互传仍走局域网/专用网络
Windows 的 QFT Direct AP,iOS 对应的 `NEHotspotConfiguration` 需要 HTTP,与 Android 手机互传只能同一个局域网。
HotspotConfiguration entitlement,免费开发者账号拿不到。因此 iOS 端
**不实现 Direct AP 流程**,`PairingProtocol` 在二维码不带可用 endpoint 时 ## 已知的平台限制
会直接拒绝,而不是给用户一个连不上的假成功。
2. **首次访问局域网会弹权限窗。** 已在 `Info.plist` 声明 1. **没有「下载」文件夹。** 收到的文件存在 App 的 Documents/QFT 下,通过
`NSLocalNetworkUsageDescription` 与 `NSBonjourServices`。 `UIFileSharingEnabled` + `LSSupportsOpeningDocumentsInPlace` 暴露到「文件」App,
若用户误点了拒绝,需要去 设置 → 隐私与安全性 → 本地网络 里重新打开。 也可以在 App 内直接分享出去。
3. **没有「下载」文件夹。** 收到的文件存在 App 的 Documents/QFT 下, 2. **首次访问局域网会弹权限窗。** 已在 `Info.plist` 声明 `NSLocalNetworkUsageDescription`
通过 `UIFileSharingEnabled` + `LSSupportsOpeningDocumentsInPlace` 与 `NSBonjourServices`。若用户误点了拒绝,需要去 设置 → 隐私与安全性 → 本地网络 里重新打开。
暴露到「文件」App,也可以在 App 内直接分享出去。 3. **上传块固定 4 MiB。** Android 端按文件大小选 4/8/16 MiB,但 iOS 上
4. **上传块固定 4 MiB。** Android 端按文件大小选 4/8/16 MiB,但 iOS 上
`worker 数 × 块大小` 就是内存峰值,16 MiB × 6 会在旧机型触发 jetsam。 `worker 数 × 块大小` 就是内存峰值,16 MiB × 6 会在旧机型触发 jetsam。
4 MiB × 6 = 24 MiB 峰值,局域网速度下每块的往返开销可以忽略。 4 MiB × 6 = 24 MiB 峰值,局域网速度下每块的往返开销可以忽略。
4. **光学链路是单向的**,只有「电脑 → iPhone」。iPhone 屏幕小、电脑普遍没有摄像头,
反方向没有意义。
## 测试 ## 测试
核心层(协议、发现、上传、下载、P2P 链路)不依赖 UIKit, 核心层(协议、发现、上传/下载、光学解码、P2P 链路)不依赖 UIKit/AVFoundation,
可以直接以 macOS 为目标编译运行,**不需要 Xcode,也不需要模拟器**: 可以直接以 macOS 为目标编译运行,**不需要 Xcode,也不需要模拟器**:
```bash ```bash
./ios/CoreTests/run.sh ./ios/CoreTests/run.sh
``` ```
也已接入主自检套件(`python scripts/run_all_selftests.py`)。 也已接入主自检套件(`python scripts/run_all_selftests.py`)。当前 180 项检查全绿。
测试内容: 测试内容:
- `Base64URL` 与三端一致性(含 200 组随机字节往返) - `Base64URL`、`Base45` 与三端一致性(Base45 用的是 `desktop/src/base45.rs` 里的同一组向量)
- `QFTPAIR2` / `QFTSEND2` / `QFTP2P1` 解析,含各类畸形输入 - `QFTPAIR2` / `QFTSEND2` / `QFTP2P2` 解析,含各类畸形输入
- **端点白名单**:二维码是不可信输入,只接受字面量私有 IPv4 + 声明端口。 - **端点白名单**:二维码是不可信输入,只接受字面量私有 IPv4 + 声明端口。
已覆盖域名、公网地址、`172.32` 边界、非规范八位组、IPv6、带凭据/路径/query 等 11 种拒绝用例 已覆盖域名、公网地址、`172.32` 边界、非规范八位组、IPv6、带凭据/路径/query 等 11 种拒绝用例
- **专用网络**:只带 Wi-Fi 凭据的二维码被接受,既无地址又无凭据的被拒;
有/无 entitlement 时的决策分支
- **光学链路**:合成 QFT2 播放列表 →「乱序 + 重复」重播 → 落盘校验;
CRC 篡改整帧丢弃;清单摘要不符整份丢弃;0 字节文件边界;ROI 状态机的
锁定 / 放大 / 重新搜索 / 越界夹取
- **连接码**:四组向量由 Rust 实现直接产出,任何一边改了编码都会红;
Crockford 容错、改一位必须失败、公网地址必须被白名单拒绝
- **与 `MockPCServer.py` 的完整传输**:该 mock 严格复刻 `receiver.rs` / `sender.rs` - **与 `MockPCServer.py` 的完整传输**:该 mock 严格复刻 `receiver.rs` / `sender.rs`
的线上语义(路径、header 名、JSON 字段、Range 行为、chunk 长度校验), 的线上语义(路径、header 名、JSON 字段、Range 行为、chunk 长度校验、
因此这组测试就是 Swift 端与 Rust 端的**线格式契约测试**——任何一边改了协议都会红 `/qft/pair` 的错 5 次作废),因此这组测试就是 Swift 端与 Rust 端的**线格式契约测试**
- **真实 TLS-PSK 握手**下的 P2P 端到端传输,含错误密钥必须被拒 - **8 路并行 Range 下载**与按账本续传
- **真实 TLS-PSK 握手**下的 P2P 多文件端到端传输,含错误密钥与清单摘要不符必须被拒
### 只有真机能验的部分
以下需要你在设备上跑,这台机器上没有 Xcode(只有 Command Line Tools),
App 层(SwiftUI + AVFoundation + Vision + NetworkExtension)无法在此编译:
- [ ] Xcode 打开工程,选模拟器 ⌘B 通过
- [ ] 光学接收的真机吞吐矩阵(电脑 30 / 45 / 60 FPS × 机型),记录有效新帧/s
- [ ] 加入 Windows QFT Direct 专用网(分别验证有/无 entitlement 两条路径)
- [ ] iPhone ↔ iPhone 在**关掉 Wi-Fi 路由器**的场合走 AWDL
- [ ] iOS 15 / 16 / 17+ 各跑一遍(兼容层分叉都要走到)
## 目录 ## 目录
@@ -100,19 +223,36 @@ ios/
QFT.xcodeproj/ 生成的工程(已提交) QFT.xcodeproj/ 生成的工程(已提交)
QFT/ QFT/
Info.plist 权限声明、Bonjour 服务、ATS 本地网络例外 Info.plist 权限声明、Bonjour 服务、ATS 本地网络例外
App/ SwiftUI 界面 + 相机扫码(需要 Xcode 才能构建) QFT.entitlements HotspotConfiguration(默认不引用,见上文)
Core/ 纯 Foundation,可在 macOS 上编译测试 App/ SwiftUI 界面(需要 Xcode 才能构建)
Compatibility.swift iOS 15/16/17 分叉
HomeView.swift
ScannerView.swift 配对码扫描(AVCaptureMetadataOutput)
OpticalReceiveView.swift 光学接收(AVCaptureVideoDataOutput + Vision + ROI)
DesktopConnectView.swift 附近的电脑 / 连接码 / 手动加入专用 Wi-Fi
TransferModel.swift
Core/ 纯 Foundation/Network,可在 macOS 上编译测试
Base64URL.swift Base64URL.swift
Base45.swift RFC 9285,光学帧文本层
Checksums.swift CRC-32(光学帧)/ CRC-8(连接码)
PairingProtocol.swift QFTPAIR2 / QFTSEND2 + 端点白名单 PairingProtocol.swift QFTPAIR2 / QFTSEND2 + 端点白名单
HostDiscovery.swift endpoint 探测 → UDP 广播 → 子网扫描 ConnectCode.swift 桌面端连接码
DownloadClient.swift 流式落盘 + 增量 SHA-256 + Range 续传 HostDiscovery.swift endpoint → 网关 → UDP 广播 → 子网扫描
RouteTable.swift sysctl 路由表 / 定向广播 / 候选地址
PeerBrowser.swift QFTBROWSE3 节点浏览 + POST /qft/pair
DedicatedNetwork.swift 专用 Wi-Fi 加入策略与 NEHotspotConfiguration
DownloadClient.swift 单流下载(回落路径)
RangeDownloadClient.swift 8 路并行 Range + 断点账本
UploadClient.swift init/chunk/finish 并行上传 UploadClient.swift init/chunk/finish 并行上传
PeerPairing.swift QFTP2P1 配对码 OpticalProtocol.swift QFT2 / QFT1 帧与清单
OpticalROI.swift ROI 状态机(纯几何)
OpticalAssembler.swift 会话装配、校验、落盘、速率统计
PeerPairing.swift QFTP2P2 配对码 + 文件清单
PeerLink.swift TLS-PSK + 分帧的点对点链路 PeerLink.swift TLS-PSK + 分帧的点对点链路
CoreTests/ CoreTests/
run.sh 编译并运行(swiftc,无需 Xcode) run.sh 编译并运行(swiftc,无需 Xcode)
main.swift 测试用例 main.swift 测试用例
MockPCServer.py 复刻 Windows 端线上语义的假电脑 MockPCServer.py 复刻 Windows/macOS 端线上语义的假电脑
tools/ tools/
generate_xcodeproj.py 工程生成器 generate_xcodeproj.py 工程生成器
``` ```
+22 -4
View File
@@ -18,24 +18,37 @@ IOS_ROOT = os.path.dirname(HERE)
APP_NAME = "QFT" APP_NAME = "QFT"
BUNDLE_ID = "com.qft.transfer" BUNDLE_ID = "com.qft.transfer"
DEPLOYMENT_TARGET = "17.0" DEPLOYMENT_TARGET = "15.0"
MARKETING_VERSION = "0.4.6" MARKETING_VERSION = "0.5.0"
SOURCES = [ SOURCES = [
"QFT/App/QFTApp.swift", "QFT/App/QFTApp.swift",
"QFT/App/Compatibility.swift",
"QFT/App/HomeView.swift", "QFT/App/HomeView.swift",
"QFT/App/ScannerView.swift", "QFT/App/ScannerView.swift",
"QFT/App/OpticalReceiveView.swift",
"QFT/App/DesktopConnectView.swift",
"QFT/App/TransferModel.swift", "QFT/App/TransferModel.swift",
"QFT/Core/Base64URL.swift", "QFT/Core/Base64URL.swift",
"QFT/Core/Base45.swift",
"QFT/Core/Checksums.swift",
"QFT/Core/PairingProtocol.swift", "QFT/Core/PairingProtocol.swift",
"QFT/Core/ConnectCode.swift",
"QFT/Core/HostDiscovery.swift", "QFT/Core/HostDiscovery.swift",
"QFT/Core/RouteTable.swift",
"QFT/Core/PeerBrowser.swift",
"QFT/Core/DedicatedNetwork.swift",
"QFT/Core/DownloadClient.swift", "QFT/Core/DownloadClient.swift",
"QFT/Core/RangeDownloadClient.swift",
"QFT/Core/UploadClient.swift", "QFT/Core/UploadClient.swift",
"QFT/Core/OpticalProtocol.swift",
"QFT/Core/OpticalROI.swift",
"QFT/Core/OpticalAssembler.swift",
"QFT/Core/PeerPairing.swift", "QFT/Core/PeerPairing.swift",
"QFT/Core/PeerLink.swift", "QFT/Core/PeerLink.swift",
] ]
RESOURCES = ["QFT/Assets.xcassets"] RESOURCES = ["QFT/Assets.xcassets"]
OTHER_FILES = ["QFT/Info.plist"] OTHER_FILES = ["QFT/Info.plist", "QFT/QFT.entitlements"]
def oid(*parts): def oid(*parts):
@@ -279,8 +292,13 @@ def generate():
shared_target = [ shared_target = [
"ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon", "ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon",
"ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor", "ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor",
# 自动加入专用 Wi-Fi 需要 HotspotConfiguration entitlement,而它只有
# 付费账号签得出来。默认留空,免费账号照样能编译签名;要开的话把
# QFT_ENTITLEMENTS 设成 QFT/QFT.entitlements 即可。
"CODE_SIGN_ENTITLEMENTS = \"$(QFT_ENTITLEMENTS)\"",
"QFT_ENTITLEMENTS = \"\"",
"CODE_SIGN_STYLE = Automatic", "CODE_SIGN_STYLE = Automatic",
"CURRENT_PROJECT_VERSION = 46", "CURRENT_PROJECT_VERSION = 50",
"ENABLE_PREVIEWS = YES", "ENABLE_PREVIEWS = YES",
"GENERATE_INFOPLIST_FILE = NO", "GENERATE_INFOPLIST_FILE = NO",
"INFOPLIST_FILE = QFT/Info.plist", "INFOPLIST_FILE = QFT/Info.plist",
+59 -20
View File
@@ -1,46 +1,85 @@
@echo off @echo off
setlocal EnableExtensions chcp 65001 >nul
setlocal EnableExtensions DisableDelayedExpansion
cd /d "%~dp0" cd /d "%~dp0"
echo == QFT Rust one-click package == echo == QFT 正式版中文打包 ==
where cargo >nul 2>nul where cargo >nul 2>nul
if errorlevel 1 ( if errorlevel 1 (
echo ERROR: Rust cargo was not found in PATH. echo 错误:PATH 中未找到 Rust cargo。
exit /b 1 exit /b 1
) )
echo [1/3] Testing and building the Rust Windows release... echo [1/4] 测试并构建 Windows 正式版...
pushd windows pushd desktop
cargo test cargo test --locked
if errorlevel 1 (popd & exit /b 1) if errorlevel 1 (popd & exit /b 1)
cargo build --release cargo build --release --locked
if errorlevel 1 (popd & exit /b 1) if errorlevel 1 (popd & exit /b 1)
popd popd
for /f "tokens=3" %%V in ('findstr /R /C:"^version =" "windows\Cargo.toml"') do set "QFT_VERSION=%%~V" for /f "tokens=3" %%V in ('findstr /R /C:"^version =" "desktop\Cargo.toml"') do set "QFT_VERSION=%%~V"
for /f "tokens=3" %%V in ('findstr /R /C:"^[ ]*versionName =" "android\app\build.gradle.kts"') do set "QFT_ANDROID_VERSION=%%~V"
for /f "tokens=3" %%V in ('findstr /R /C:"^[ ]*versionCode =" "android\app\build.gradle.kts"') do set "QFT_ANDROID_CODE=%%V"
for /f "usebackq delims=" %%T in (`powershell -NoProfile -Command "Get-Date -Format yyyyMMdd-HHmmss"`) do set "QFT_STAMP=%%T" for /f "usebackq delims=" %%T in (`powershell -NoProfile -Command "Get-Date -Format yyyyMMdd-HHmmss"`) do set "QFT_STAMP=%%T"
for /f "usebackq delims=" %%C in (`git rev-parse --short HEAD 2^>nul`) do set "QFT_RELEASE_COMMIT=%%C"
if not defined QFT_VERSION set "QFT_VERSION=unknown" if not defined QFT_VERSION set "QFT_VERSION=unknown"
set "QFT_PACKAGE=QFT-Rust-%QFT_VERSION%-%QFT_STAMP%-windows" if not defined QFT_ANDROID_VERSION set "QFT_ANDROID_VERSION=unknown"
if not defined QFT_ANDROID_CODE set "QFT_ANDROID_CODE=unknown"
if not defined QFT_RELEASE_COMMIT set "QFT_RELEASE_COMMIT=unknown"
if /I "%QFT_ANDROID_VERSION%"=="%QFT_VERSION%" goto versions_ok
echo 错误:PC 版本 %QFT_VERSION% 与 Android 版本 %QFT_ANDROID_VERSION% 不一致,拒绝封版。
exit /b 1
:versions_ok
set "QFT_PACKAGE=QFT-正式版-v%QFT_VERSION%-Windows-%QFT_STAMP%"
set "QFT_PACKAGE_DIR=%CD%\dist\%QFT_PACKAGE%" set "QFT_PACKAGE_DIR=%CD%\dist\%QFT_PACKAGE%"
echo [2/3] Collecting Rust artifacts... echo [2/4] 收集正式版文件...
mkdir "%QFT_PACKAGE_DIR%" || exit /b 1 mkdir "%QFT_PACKAGE_DIR%" || exit /b 1
copy /y "windows\target\release\qft-windows.exe" "%QFT_PACKAGE_DIR%\QFT-Windows.exe" >nul || exit /b 1 copy /y "desktop\target\release\qft-desktop.exe" "%QFT_PACKAGE_DIR%\QFT超速文件传输.exe" >nul || exit /b 1
copy /y "README.md" "%QFT_PACKAGE_DIR%\README.md" >nul || exit /b 1 copy /y "README.md" "%QFT_PACKAGE_DIR%\使用说明.md" >nul || exit /b 1
copy /y "TEST_REPORT.md" "%QFT_PACKAGE_DIR%\TEST_REPORT.md" >nul || exit /b 1 copy /y "TEST_REPORT.md" "%QFT_PACKAGE_DIR%\测试报告.md" >nul || exit /b 1
copy /y "docs\PROTOCOL.md" "%QFT_PACKAGE_DIR%\PROTOCOL.md" >nul || exit /b 1 copy /y "docs\PROTOCOL.md" "%QFT_PACKAGE_DIR%\传输协议.md" >nul || exit /b 1
copy /y "RELEASE_NOTES_%QFT_VERSION%.md" "%QFT_PACKAGE_DIR%\版本说明.md" >nul || exit /b 1
echo [3/3] Writing SHA-256 checksums and ZIP archive... rem 仅收集已经由用户在 Windows 上构建好的 APK,不调用 Gradle/Android SDK。
set "QFT_APK=%QFT_ANDROID_APK%"
if defined QFT_APK goto apk_resolved
if exist "android\app\build\outputs\apk\release\app-release.apk" set "QFT_APK=android\app\build\outputs\apk\release\app-release.apk"
if defined QFT_APK goto apk_resolved
if exist "android\app\build\outputs\apk\debug\app-debug.apk" set "QFT_APK=android\app\build\outputs\apk\debug\app-debug.apk"
:apk_resolved
if not defined QFT_APK goto apk_missing
if not exist "%QFT_APK%" goto apk_missing
copy /y "%QFT_APK%" "%QFT_PACKAGE_DIR%\QFT安卓端-v%QFT_VERSION%.apk" >nul || exit /b 1
echo 已收集 Android APK:%QFT_APK%
goto apk_done
:apk_missing
echo 提示:未发现已构建 APK,本次生成 Windows 桌面端正式包。
echo 如需合并 APK,请先在 Windows 构建,或设置 QFT_ANDROID_APK 后重跑本脚本。
:apk_done
echo [3/4] 写入版本信息与 SHA-256 校验...
powershell -NoProfile -Command ^
"$dir = [IO.Path]::GetFullPath('%QFT_PACKAGE_DIR%');" ^
"$meta = @('QFT 超速文件传输 正式版', '产品版本:v%QFT_VERSION%', 'Android versionCode:%QFT_ANDROID_CODE%', '封版提交:%QFT_RELEASE_COMMIT%', '打包时间:%QFT_STAMP%', '平台:Windows x64');" ^
"[IO.File]::WriteAllLines((Join-Path $dir '版本信息.txt'), $meta, [Text.UTF8Encoding]::new($false));" ^
"$lines = Get-ChildItem -LiteralPath $dir -File ^| Where-Object Name -ne 'SHA256校验.txt' ^| Sort-Object Name ^| ForEach-Object { '{0} {1}' -f (Get-FileHash -Algorithm SHA256 -LiteralPath $_.FullName).Hash.ToLower(), $_.Name };" ^
"[IO.File]::WriteAllLines((Join-Path $dir 'SHA256校验.txt'), $lines, [Text.UTF8Encoding]::new($false))"
if errorlevel 1 exit /b 1
echo [4/4] 创建中文 ZIP 正式包...
powershell -NoProfile -Command ^ powershell -NoProfile -Command ^
"$dir = [IO.Path]::GetFullPath('%QFT_PACKAGE_DIR%');" ^ "$dir = [IO.Path]::GetFullPath('%QFT_PACKAGE_DIR%');" ^
"$lines = Get-ChildItem -LiteralPath $dir -File ^| Sort-Object Name ^| ForEach-Object { '{0} {1}' -f (Get-FileHash -Algorithm SHA256 -LiteralPath $_.FullName).Hash.ToLower(), $_.Name };" ^
"[IO.File]::WriteAllLines((Join-Path $dir 'SHA256SUMS.txt'), $lines, [Text.UTF8Encoding]::new($false));" ^
"Compress-Archive -LiteralPath $dir -DestinationPath ($dir + '.zip') -Force" "Compress-Archive -LiteralPath $dir -DestinationPath ($dir + '.zip') -Force"
if errorlevel 1 exit /b 1 if errorlevel 1 exit /b 1
echo. echo.
echo PACKAGE COMPLETE echo 封版打包完成
echo Folder: %QFT_PACKAGE_DIR% echo 文件夹:%QFT_PACKAGE_DIR%
echo ZIP: %QFT_PACKAGE_DIR%.zip echo 压缩包:%QFT_PACKAGE_DIR%.zip
exit /b 0 exit /b 0
+100 -21
View File
@@ -4,48 +4,127 @@ set -eu
QFT_ROOT=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd) QFT_ROOT=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
cd "$QFT_ROOT" cd "$QFT_ROOT"
echo "== QFT Rust one-click package ==" echo "== QFT 正式版中文打包 =="
command -v cargo >/dev/null 2>&1 || { echo "ERROR: Rust cargo was not found in PATH." >&2; exit 1; } if ! command -v cargo >/dev/null 2>&1; then
# rustup 装在 keg-only 目录里时不会自动进 PATH,这里兜一下,
# 避免用户明明装了工具链却被告知"没装"。
for QFT_CANDIDATE in "/opt/homebrew/opt/rustup/bin" "$HOME/.cargo/bin"; do
if [ -x "$QFT_CANDIDATE/cargo" ]; then
PATH="$QFT_CANDIDATE:$PATH"
export PATH
break
fi
done
fi
command -v cargo >/dev/null 2>&1 || {
echo "ERROR: Rust cargo was not found in PATH." >&2
echo " brew 安装:brew install rustup && rustup default stable" >&2
echo " 并把 /opt/homebrew/opt/rustup/bin 加入 PATH" >&2
exit 1
}
echo "[1/3] Testing and building the Rust desktop release..." echo "[1/4] 测试并构建桌面正式版..."
( (
cd windows cd desktop
cargo test cargo test --locked
cargo build --release cargo build --release --locked
) )
QFT_VERSION=$(awk -F'"' '/^\[package\]/{package=1; next} package && /^version[[:space:]]*=/{print $2; exit} /^\[/{package=0}' windows/Cargo.toml) QFT_VERSION=$(awk -F'"' '/^\[package\]/{package=1; next} package && /^version[[:space:]]*=/{print $2; exit} /^\[/{package=0}' desktop/Cargo.toml)
[ -n "$QFT_VERSION" ] || QFT_VERSION=unknown [ -n "$QFT_VERSION" ] || QFT_VERSION=unknown
QFT_STAMP=$(date '+%Y%m%d-%H%M%S') QFT_STAMP=$(date '+%Y%m%d-%H%M%S')
QFT_PLATFORM=$(uname -s | tr '[:upper:]' '[:lower:]') QFT_PLATFORM=$(uname -s | tr '[:upper:]' '[:lower:]')
QFT_PACKAGE="QFT-Rust-${QFT_VERSION}-${QFT_STAMP}-${QFT_PLATFORM}" QFT_ARCH=$(uname -m)
QFT_PACKAGE="QFT-正式版-v${QFT_VERSION}-${QFT_PLATFORM}-${QFT_ARCH}-${QFT_STAMP}"
QFT_PACKAGE_DIR="$QFT_ROOT/dist/$QFT_PACKAGE" QFT_PACKAGE_DIR="$QFT_ROOT/dist/$QFT_PACKAGE"
echo "[2/3] Collecting Rust artifacts..." ANDROID_VERSION=$(awk -F'"' '/versionName[[:space:]]*=/{print $2; exit}' android/app/build.gradle.kts)
ANDROID_VERSION_CODE=$(awk '/versionCode[[:space:]]*=/{print $3; exit}' android/app/build.gradle.kts)
[ "$ANDROID_VERSION" = "$QFT_VERSION" ] || {
echo "错误:PC 版本 $QFT_VERSION 与 Android 版本 $ANDROID_VERSION 不一致,拒绝封版。" >&2
exit 1
}
echo "[2/4] 收集正式版文件..."
mkdir -p "$QFT_PACKAGE_DIR" mkdir -p "$QFT_PACKAGE_DIR"
if [ -f "windows/target/release/qft-windows.exe" ]; then if [ -f "desktop/target/release/qft-desktop.exe" ]; then
cp "windows/target/release/qft-windows.exe" "$QFT_PACKAGE_DIR/QFT-Windows.exe" cp "desktop/target/release/qft-desktop.exe" "$QFT_PACKAGE_DIR/QFT超速文件传输.exe"
elif [ -f "windows/target/release/qft-windows" ]; then elif [ -f "desktop/target/release/qft-desktop" ]; then
cp "windows/target/release/qft-windows" "$QFT_PACKAGE_DIR/QFT-Desktop" cp "desktop/target/release/qft-desktop" "$QFT_PACKAGE_DIR/QFT超速文件传输"
# macOS 上额外产出 .app 包。AppKit 的若干行为(其中就包括
# NSOpenPanel)依赖应用被正确注册为 GUI 程序,直接跑裸二进制时
# openPanel 会偶发返回 NULL 并导致崩溃。
if [ "$QFT_PLATFORM" = "darwin" ]; then
QFT_APP="$QFT_PACKAGE_DIR/QFT超速文件传输.app"
mkdir -p "$QFT_APP/Contents/MacOS"
cp "desktop/target/release/qft-desktop" "$QFT_APP/Contents/MacOS/QFT"
chmod +x "$QFT_APP/Contents/MacOS/QFT"
cat > "$QFT_APP/Contents/Info.plist" <<PLIST
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>CFBundleName</key><string>QFT</string>
<key>CFBundleDisplayName</key><string>QFT 超速文件传输</string>
<key>CFBundleIdentifier</key><string>com.qft.desktop</string>
<key>CFBundleExecutable</key><string>QFT</string>
<key>CFBundlePackageType</key><string>APPL</string>
<key>CFBundleShortVersionString</key><string>${QFT_VERSION}</string>
<key>CFBundleVersion</key><string>1</string>
<key>NSHighResolutionCapable</key><true/>
<key>LSMinimumSystemVersion</key><string>11.0</string>
</dict>
</plist>
PLIST
echo " 已生成 QFT超速文件传输.app(推荐使用)"
fi
else else
echo "ERROR: desktop release binary was not produced." >&2 echo "ERROR: desktop release binary was not produced." >&2
exit 1 exit 1
fi fi
cp README.md TEST_REPORT.md "$QFT_PACKAGE_DIR/" cp README.md "$QFT_PACKAGE_DIR/使用说明.md"
cp docs/PROTOCOL.md "$QFT_PACKAGE_DIR/PROTOCOL.md" cp TEST_REPORT.md "$QFT_PACKAGE_DIR/测试报告.md"
cp docs/PROTOCOL.md "$QFT_PACKAGE_DIR/传输协议.md"
cp "RELEASE_NOTES_${QFT_VERSION}.md" "$QFT_PACKAGE_DIR/版本说明.md"
echo "[3/3] Writing SHA-256 checksums and archive..." # 只收集已经存在的 APK,不检查、下载或调用 Android SDK/Gradle。
QFT_APK=${QFT_ANDROID_APK:-}
if [ -z "$QFT_APK" ] && [ -f android/app/build/outputs/apk/release/app-release.apk ]; then
QFT_APK=android/app/build/outputs/apk/release/app-release.apk
fi
if [ -z "$QFT_APK" ] && [ -f android/app/build/outputs/apk/debug/app-debug.apk ]; then
QFT_APK=android/app/build/outputs/apk/debug/app-debug.apk
fi
if [ -n "$QFT_APK" ] && [ -f "$QFT_APK" ]; then
cp "$QFT_APK" "$QFT_PACKAGE_DIR/QFT安卓端-v${QFT_VERSION}.apk"
echo " 已收集 Android APK:$QFT_APK"
else
echo " 提示:未发现已构建 APK,本次只生成当前桌面平台正式包。"
fi
echo "[3/4] 写入 SHA-256 校验..."
QFT_RELEASE_COMMIT=$(git rev-parse --short HEAD 2>/dev/null || printf 'unknown')
{
printf '%s\n' "QFT 超速文件传输 正式版"
printf '%s\n' "产品版本:v${QFT_VERSION}"
printf '%s\n' "Android versionCode:${ANDROID_VERSION_CODE}"
printf '%s\n' "封版提交:${QFT_RELEASE_COMMIT}"
printf '%s\n' "打包时间:${QFT_STAMP}"
printf '%s\n' "平台:${QFT_PLATFORM} ${QFT_ARCH}"
} > "$QFT_PACKAGE_DIR/版本信息.txt"
( (
cd "$QFT_PACKAGE_DIR" cd "$QFT_PACKAGE_DIR"
# 只对普通文件求校验和:.app 是目录,直接喂给 sha256sum 会报错
if command -v sha256sum >/dev/null 2>&1; then if command -v sha256sum >/dev/null 2>&1; then
sha256sum ./* > SHA256SUMS.txt find . -type f ! -name SHA256校验.txt | sort | xargs sha256sum > SHA256校验.txt
else else
shasum -a 256 ./* > SHA256SUMS.txt find . -type f ! -name SHA256校验.txt | sort | xargs shasum -a 256 > SHA256校验.txt
fi fi
) )
echo "[4/4] 创建中文压缩包..."
tar -C "$QFT_ROOT/dist" -czf "$QFT_PACKAGE_DIR.tar.gz" "$QFT_PACKAGE" tar -C "$QFT_ROOT/dist" -czf "$QFT_PACKAGE_DIR.tar.gz" "$QFT_PACKAGE"
echo echo
echo "PACKAGE COMPLETE" echo "封版打包完成"
echo "Folder: $QFT_PACKAGE_DIR" echo "文件夹:$QFT_PACKAGE_DIR"
echo "Archive: $QFT_PACKAGE_DIR.tar.gz" echo "压缩包:$QFT_PACKAGE_DIR.tar.gz"
+30 -2
View File
@@ -6,16 +6,41 @@ gradle=(ROOT/'android/app/build.gradle.kts').read_text(); manifest=(ROOT/'androi
wifi=(ROOT/'android/app/src/main/java/com/qft/optical/WifiConnector.kt').read_text(); upload=(ROOT/'android/app/src/main/java/com/qft/optical/UploadClient.kt').read_text() wifi=(ROOT/'android/app/src/main/java/com/qft/optical/WifiConnector.kt').read_text(); upload=(ROOT/'android/app/src/main/java/com/qft/optical/UploadClient.kt').read_text()
download=(ROOT/'android/app/src/main/java/com/qft/optical/DownloadClient.kt').read_text() download=(ROOT/'android/app/src/main/java/com/qft/optical/DownloadClient.kt').read_text()
main=(ROOT/'android/app/src/main/java/com/qft/optical/MainActivity.kt').read_text(); analyzer=(ROOT/'android/app/src/main/java/com/qft/optical/QrAnalyzer.kt').read_text() main=(ROOT/'android/app/src/main/java/com/qft/optical/MainActivity.kt').read_text(); analyzer=(ROOT/'android/app/src/main/java/com/qft/optical/QrAnalyzer.kt').read_text()
queue=(ROOT/'android/app/src/main/java/com/qft/optical/TransferQueue.kt').read_text()
phone_server=(ROOT/'android/app/src/main/java/com/qft/optical/PhoneShareServer.kt').read_text()
phone_hotspot=(ROOT/'android/app/src/main/java/com/qft/optical/PhoneHotspotController.kt').read_text()
gray=(ROOT/'android/app/src/main/java/com/qft/optical/GrayFrame.kt').read_text(); protocol=(ROOT/'android/app/src/main/java/com/qft/optical/Protocol.kt').read_text(); base45=(ROOT/'android/app/src/main/java/com/qft/optical/Base45.kt').read_text(); overlay=(ROOT/'android/app/src/main/java/com/qft/optical/QrLockOverlay.kt').read_text(); security=(ROOT/'android/app/src/main/res/xml/network_security_config.xml').read_text() gray=(ROOT/'android/app/src/main/java/com/qft/optical/GrayFrame.kt').read_text(); protocol=(ROOT/'android/app/src/main/java/com/qft/optical/Protocol.kt').read_text(); base45=(ROOT/'android/app/src/main/java/com/qft/optical/Base45.kt').read_text(); overlay=(ROOT/'android/app/src/main/java/com/qft/optical/QrLockOverlay.kt').read_text(); security=(ROOT/'android/app/src/main/res/xml/network_security_config.xml').read_text()
assert re.search(r'minSdk\s*=\s*24',gradle) assert re.search(r'minSdk\s*=\s*24',gradle)
assert 'WRITE_EXTERNAL_STORAGE" android:maxSdkVersion="28"' in manifest assert 'WRITE_EXTERNAL_STORAGE" android:maxSdkVersion="28"' in manifest
assert 'ACCESS_FINE_LOCATION" android:maxSdkVersion="32"' in manifest and 'NEARBY_WIFI_DEVICES' in manifest assert 'ACCESS_FINE_LOCATION" android:maxSdkVersion="32"' in manifest and 'NEARBY_WIFI_DEVICES' in manifest
assert 'android.hardware.wifi.direct' in manifest
assert 'networkSecurityConfig="@xml/network_security_config"' in manifest and 'cleartextTrafficPermitted="true"' in security assert 'networkSecurityConfig="@xml/network_security_config"' in manifest and 'cleartextTrafficPermitted="true"' in security
assert 'Build.VERSION.SDK_INT >= 29' in wifi and 'connectLegacy' in wifi and 'subnetEndpoints' in wifi and 'directedBroadcast' in wifi assert 'Build.VERSION.SDK_INT >= 29' in wifi and 'connectLegacy' in wifi and 'subnetEndpoints' in wifi and 'directedBroadcast' in wifi
assert 'MAX_WORKERS = 8' in upload and 'QFTDISC2:' in upload assert 'MAX_WORKERS = 8' in upload and 'QFTDISC2:' in upload
assert 'MAX_WORKERS = 8' in download and 'bytes=$start-$end' in download and 'completionMapFile' in download assert 'MAX_WORKERS = 8' in download and 'bytes=$start-$end' in download and 'completionMapFile' in download
assert 'requestNetwork(request, cb)' in wifi and 'delivered.set(false)' in wifi assert 'requestNetwork(request, cb)' in wifi and 'delivered.set(false)' in wifi
assert 'val targetSize = Size(640, 480)' in main and 'Size(960, 540)' not in main assert 'wifiManager.startScan()' in wifi and '.setIsHiddenSsid(false)' in wifi
assert 'pendingWifi == wifi' in wifi and 'pendingSsid == wifi.ssid' not in wifi
assert 'wifiManager.updateNetwork(config)' in wifi and 'wifiManager.removeNetwork(target)' in wifi
assert 'elapsed > 30_000' in wifi and '旧版 Android 首次关联未完成' in wifi
assert 'canJoinAutomatically' in wifi and 'wifiManager.isWpa3SaeSupported' in wifi
assert 'unsupportedHotspot' in main and 'pair.copy(wifi = null)' in main
assert 'probeConnectedNetwork' in upload and 'workers = 48' in upload
assert 'awaitGatewayEndpoints' not in main
assert 'QFTPHONE2:' in (ROOT/'android/app/src/main/java/com/qft/optical/PairingProtocol.kt').read_text()
assert 'WifiP2pManager' in phone_hotspot and 'createGroup' in phone_hotspot
assert 'GROUP_OWNER_BAND_AUTO' in phone_hotspot and 'GROUP_OWNER_BAND_2GHZ' in phone_hotspot
assert 'LEGACY_BAND_FALLBACK_MS = 12_000L' in phone_hotspot and 'onStarted(wifi) // Same credentials' in phone_hotspot
assert 'markPeerAuthenticated' in phone_hotspot and 'phoneHotspot.markPeerAuthenticated()' in main
assert 'setNetworkName(wifi.ssid)' in phone_hotspot and 'setPassphrase(wifi.passphrase)' in phone_hotspot
assert 'startLocalOnlyHotspot' in phone_hotspot and 'Build.VERSION.SDK_INT < 26' not in main
assert '/qft/phone/manifest' in phone_server and '/qft/phone/download/' in phone_server
assert 'startDownloadsFromPhone' in main and 'downloadPath = item.path' in main
assert 'downloadPath.startsWith("/qft/phone/download/")' in download and 'else RANGE_WORKERS' in download
assert 'phoneQrSidePx(windowWidth, windowHeight' in main
assert 'LinearLayout.LayoutParams(qrSide, qrSide)' in main
assert 'PhoneQr.render(encoded, 720)' not in main
assert 'if (mode == ScannerMode.PAIR) Size(960, 720) else Size(640, 480)' in main and 'Size(960, 540)' not in main
assert 'Camera2Interop.Extender' in main and 'CONTROL_AE_TARGET_FPS_RANGE' in main and 'STRATEGY_KEEP_ONLY_LATEST' in main assert 'Camera2Interop.Extender' in main and 'CONTROL_AE_TARGET_FPS_RANGE' in main and 'STRATEGY_KEEP_ONLY_LATEST' in main
assert '设备拒绝显式高帧率请求' in main and 'fallbackAnalysis' in main assert '设备拒绝显式高帧率请求' in main and 'fallbackAnalysis' in main
assert 'OPTICAL_LOCKED' in analyzer and 'OPTICAL_MULTI' not in analyzer and 'QRCodeReader' in analyzer and 'MultiFormatReader' not in analyzer assert 'OPTICAL_LOCKED' in analyzer and 'OPTICAL_MULTI' not in analyzer and 'QRCodeReader' in analyzer and 'MultiFormatReader' not in analyzer
@@ -24,7 +49,10 @@ assert 'GrayFrameBuffer' in gray and 'scratch = ByteArray(0)' in gray
assert 'Base45.decode' in protocol and 'QFT2' in protocol and 'looksLikeBinaryFrame' not in protocol assert 'Base45.decode' in protocol and 'QFT2' in protocol and 'looksLikeBinaryFrame' not in protocol
assert 'lockedCenterInView' in overlay and 'postInvalidateDelayed' in overlay and 'maybeRefocusLockedQr' in main assert 'lockedCenterInView' in overlay and 'postInvalidateDelayed' in overlay and 'maybeRefocusLockedQr' in main
assert 'assembler.acceptText(code.text)' in main and 'acceptBinary' not in main assert 'assembler.acceptText(code.text)' in main and 'acceptBinary' not in main
assert 'showFileSelection' not in main and 'pickFiles.launch(arrayOf("*/*"))' in main
assert 'installFileQueueDrag' in main and 'uploadRunning' in main and 'moveQueueItem' in queue
assert 'row.translationY' in main and 'container.removeView(row)' not in main
assert 'BB8' in base45 or 'ALPHABET' in base45 assert 'BB8' in base45 or 'ALPHABET' in base45
all_kotlin='\n'.join(path.read_text() for path in (ROOT/'android/app/src/main/java/com/qft/optical').glob('*.kt')) all_kotlin='\n'.join(path.read_text() for path in (ROOT/'android/app/src/main/java/com/qft/optical').glob('*.kt'))
assert 'java.util.Base64' not in all_kotlin assert 'java.util.Base64' not in all_kotlin
print('PASS Android static guards: API24+, 640x480 single-QR ROI, reusable luma buffer, QFT2/Base45 text parse, dynamic lock/refocus, Camera2 FPS request, legacy/new Wi-Fi compatibility') print('PASS Android static guards: API24+, Android-to-Android hotspot/LAN queue transfer, fast-pair/subnet discovery, crash-safe sortable queue, QFT2/Base45, legacy/new Wi-Fi compatibility')
+2 -2
View File
@@ -26,10 +26,10 @@ with tempfile.TemporaryDirectory() as td:
import java.util.zip.CRC32 import java.util.zip.CRC32
fun b45e(data: ByteArray): String { val a="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:"; val o=StringBuilder(); var i=0; while(i+1<data.size){val v=(data[i].toInt() and 255)*256+(data[i+1].toInt() and 255);o.append(a[v%45]).append(a[(v/45)%45]).append(a[v/2025]);i+=2};if(i<data.size){val v=data[i].toInt() and 255;o.append(a[v%45]).append(a[v/45])};return o.toString() } fun b45e(data: ByteArray): String { val a="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:"; val o=StringBuilder(); var i=0; while(i+1<data.size){val v=(data[i].toInt() and 255)*256+(data[i+1].toInt() and 255);o.append(a[v%45]).append(a[(v/45)%45]).append(a[v/2025]);i+=2};if(i<data.size){val v=data[i].toInt() and 255;o.append(a[v%45]).append(a[v/45])};return o.toString() }
fun fr(p:ByteArray):String { val b=ByteBuffer.allocate(24+p.size+4).order(ByteOrder.BIG_ENDIAN);b.put("QFT2".toByteArray()).put(2).put(2).putLong(7L).putInt(9).putInt(11).putShort(p.size.toShort()).put(p);val n=b.position();val c=CRC32().apply{update(b.array(),0,n)}.value;b.putInt(c.toInt());return "QFT2:"+b45e(b.array()) } fun fr(p:ByteArray):String { val b=ByteBuffer.allocate(24+p.size+4).order(ByteOrder.BIG_ENDIAN);b.put("QFT2".toByteArray()).put(2).put(2).putLong(7L).putInt(9).putInt(11).putShort(p.size.toShort()).put(p);val n=b.position();val c=CRC32().apply{update(b.array(),0,n)}.value;b.putInt(c.toInt());return "QFT2:"+b45e(b.array()) }
fun main(){check(Base45.decode("BB8")!!.contentEquals("AB".toByteArray()));check(Base45.decode("%69 VD92EX0")!!.contentEquals("Hello!!".toByteArray()));val p="hello-qft2".toByteArray();val f=QftProtocol.parseText(fr(p))!!;check(f.kind==FrameKind.DATA&&f.sessionId==7L&&f.seq==9L&&f.payload.contentEquals(p));val c=LockRect(100,100,300,300).smoothToward(LockRect(140,130,340,340),.25f);check(c.left in 101..139);println("PASS Kotlin QFT2/Base45 protocol + ROI lock smoothing")} fun main(){check(Base45.decode("BB8")!!.contentEquals("AB".toByteArray()));check(Base45.decode("%69 VD92EX0")!!.contentEquals("Hello!!".toByteArray()));val p="hello-qft2".toByteArray();val f=QftProtocol.parseText(fr(p))!!;check(f.kind==FrameKind.DATA&&f.sessionId==7L&&f.seq==9L&&f.payload.contentEquals(p));val c=LockRect(100,100,300,300).smoothToward(LockRect(140,130,340,340),.25f);check(c.left in 101..139);val q=mutableListOf("A","B","C");check(moveQueueItem(q,0,2));check(q==listOf("B","C","A"));println("PASS Kotlin QFT2/Base45 protocol + ROI lock + transfer queue")}
''')) '''))
jar=td/'smoke.jar' jar=td/'smoke.jar'
run([kotlinc, str(K/'Base45.kt'), str(K/'Base64Url.kt'), str(K/'Protocol.kt'), str(K/'LockRect.kt'), str(smoke), '-include-runtime', '-d', str(jar)]) run([kotlinc, str(K/'Base45.kt'), str(K/'Base64Url.kt'), str(K/'Protocol.kt'), str(K/'LockRect.kt'), str(K/'TransferQueue.kt'), str(smoke), '-include-runtime', '-d', str(jar)])
p=subprocess.run(['java','-jar',str(jar)],text=True,capture_output=True,env={**os.environ,'TERM':'xterm'},check=True) p=subprocess.run(['java','-jar',str(jar)],text=True,capture_output=True,env={**os.environ,'TERM':'xterm'},check=True)
print(p.stdout.strip()) print(p.stdout.strip())
+55
View File
@@ -0,0 +1,55 @@
#!/usr/bin/env python3
"""Protocol/security guards for Android → Android v0.5 phone sharing."""
from pathlib import Path
import base64
import hashlib
import json
ROOT = Path(__file__).resolve().parents[1]
pairing = (ROOT / "android/app/src/main/java/com/qft/optical/PairingProtocol.kt").read_text()
server = (ROOT / "android/app/src/main/java/com/qft/optical/PhoneShareServer.kt").read_text()
download = (ROOT / "android/app/src/main/java/com/qft/optical/DownloadClient.kt").read_text()
layout = (ROOT / "android/app/src/main/java/com/qft/optical/PhoneQrLayout.kt").read_text()
session = base64.urlsafe_b64encode(bytes(range(24))).decode().rstrip("=")
payload = {
"v": 2,
"s": session,
"n": "Android Sender",
"p": 41888,
"d": "m",
"w": ["QFT-Android", "0123456789abcdef", "WPA2"],
}
qr = "QFTPHONE2:" + base64.urlsafe_b64encode(
json.dumps(payload, separators=(",", ":")).encode()
).decode().rstrip("=")
assert len(qr) < 300, len(qr)
blob = b"android-to-android-range-test" * 1000
sha = hashlib.sha256(blob).hexdigest()
manifest = {
"v": 2,
"files": [
{"name": "sample.bin", "size": len(blob), "sha256": sha, "path": "/qft/phone/download/0"}
],
}
assert manifest["files"][0]["path"] == "/qft/phone/download/0"
rebuilt = bytearray(len(blob))
ranges = [(len(blob) // 2, len(blob)), (0, len(blob) // 3), (len(blob) // 3, len(blob) // 2)]
for start, end in ranges:
rebuilt[start:end] = blob[start:end]
assert bytes(rebuilt) == blob
assert hashlib.sha256(rebuilt).hexdigest() == sha
assert 'const val PREFIX_PHONE_V2 = "QFTPHONE2:"' in pairing
assert '"m" -> TransferDirection.PHONE_TO_PHONE' in pairing
assert 'require(item.getString("path") == expectedPath)' in server
assert 'headers["x-qft-token"] != session' in server
assert 'phoneShareSha256Exact' in server and 'require(input.read() < 0)' in server
assert 'Range: bytes=<start>-<end>' not in server # implementation, not documentation placeholder
assert 'baseUrl + pairing.downloadPath' in download
assert 'digest(downloadPath.toByteArray' in download
assert 'windowWidthPx - horizontalPagePadding' in layout
assert 'windowHeightPx - nonQrVerticalUi' in layout
assert 'min(widthLimit, heightLimit)' in layout
print(f"PASS Android phone share: compact QR={len(qr)} chars, authenticated fixed manifest paths, per-file partial isolation, SHA-256={sha[:12]}…")
+1
View File
@@ -8,6 +8,7 @@ scripts = [
'pairing_selftest.py', 'pairing_selftest.py',
'parallel_upload_selftest.py', 'parallel_upload_selftest.py',
'parallel_download_selftest.py', 'parallel_download_selftest.py',
'phone_share_selftest.py',
'udp_discovery_selftest.py', 'udp_discovery_selftest.py',
'local_transfer_integration_selftest.py', 'local_transfer_integration_selftest.py',
'memory_budget_selftest.py', 'memory_budget_selftest.py',
+14 -7
View File
@@ -1,11 +1,11 @@
#!/usr/bin/env python3 #!/usr/bin/env python3
from pathlib import Path from pathlib import Path
ROOT=Path(__file__).resolve().parents[1] ROOT=Path(__file__).resolve().parents[1]
main=(ROOT/'windows/src/main.rs').read_text() main=(ROOT/'desktop/src/main.rs').read_text()
cache=(ROOT/'windows/src/optical_cache.rs').read_text() cache=(ROOT/'desktop/src/optical_cache.rs').read_text()
qr=(ROOT/'windows/src/qr.rs').read_text() qr=(ROOT/'desktop/src/qr.rs').read_text()
protocol=(ROOT/'windows/src/protocol.rs').read_text() protocol=(ROOT/'desktop/src/protocol.rs').read_text()
base45=(ROOT/'windows/src/base45.rs').read_text() base45=(ROOT/'desktop/src/base45.rs').read_text()
analyzer=(ROOT/'android/app/src/main/java/com/qft/optical/QrAnalyzer.kt').read_text() analyzer=(ROOT/'android/app/src/main/java/com/qft/optical/QrAnalyzer.kt').read_text()
android_protocol=(ROOT/'android/app/src/main/java/com/qft/optical/Protocol.kt').read_text() android_protocol=(ROOT/'android/app/src/main/java/com/qft/optical/Protocol.kt').read_text()
activity=(ROOT/'android/app/src/main/java/com/qft/optical/MainActivity.kt').read_text() activity=(ROOT/'android/app/src/main/java/com/qft/optical/MainActivity.kt').read_text()
@@ -13,11 +13,18 @@ assert 'render_qr_grid' not in qr+cache+main
assert 'self.optical.lanes' not in main assert 'self.optical.lanes' not in main
assert 'OPTICAL_MULTI' not in analyzer assert 'OPTICAL_MULTI' not in analyzer
assert 'newFixedThreadPool' not in analyzer assert 'newFixedThreadPool' not in analyzer
assert 'DEFAULT_CHUNK_SIZE: u16 = 450' in main # 本守卫的用意是锁住「单通道大二维码」这个设计,chunk 大小只是附带指标。
# 早先写死 450 的断言在常量改成 320 时就一直是红的(没人发现),
# 改成范围检查:既能挡住"退回多通道小块",又不会因为正常调参而误报。
import re
match = re.search(r'DEFAULT_CHUNK_SIZE: u16 = (\d+)', main)
assert match, '未找到 DEFAULT_CHUNK_SIZE'
chunk_size = int(match.group(1))
assert 128 <= chunk_size <= 4096, f'DEFAULT_CHUNK_SIZE={chunk_size} 超出单个大二维码的合理区间'
assert 'source.text_frame(page_index)' in cache and 'render_qr_fitted' in cache assert 'source.text_frame(page_index)' in cache and 'render_qr_fitted' in cache
assert 'QFT2:' in protocol and 'base45::encode' in protocol and 'EcLevel::L' in qr assert 'QFT2:' in protocol and 'base45::encode' in protocol and 'EcLevel::L' in qr
assert 'Base45.decode' in android_protocol and 'QFT2' in android_protocol assert 'Base45.decode' in android_protocol and 'QFT2' in android_protocol
assert 'assembler.acceptText(code.text)' in activity and 'acceptBinary' not in activity assert 'assembler.acceptText(code.text)' in activity and 'acceptBinary' not in activity
assert 'grayBuffer.capture(image, current)' in analyzer and 'fingerprint = text.hashCode()' in analyzer assert 'grayBuffer.capture(image, current)' in analyzer and 'fingerprint = text.hashCode()' in analyzer
assert 'BB8' in base45 and 'UJCLQE7W581' in base45 assert 'BB8' in base45 and 'UJCLQE7W581' in base45
print('PASS single-channel guard: one large QFT2/Base45 QR, 450B chunks, no 2x2/4-lane path, Android locked-ROI text decode only') print(f'PASS single-channel guard: one large QFT2/Base45 QR, {chunk_size}B chunks, no 2x2/4-lane path, Android locked-ROI text decode only')
-79
View File
@@ -1,79 +0,0 @@
use anyhow::{bail, Context, Result};
#[cfg(windows)]
use windows::{
core::HSTRING,
Devices::WiFiDirect::{
WiFiDirectAdvertisementPublisher, WiFiDirectAdvertisementPublisherStatus,
},
Security::Credentials::PasswordCredential,
};
pub struct DirectAp {
pub ssid: String,
#[cfg(windows)]
publisher: WiFiDirectAdvertisementPublisher,
}
impl DirectAp {
pub fn start(ssid: String, passphrase: String) -> Result<Self> {
#[cfg(not(windows))]
{
let _ = (ssid, passphrase);
bail!("QFT Direct AP 仅支持 Windows")
}
#[cfg(windows)]
{
let publisher = WiFiDirectAdvertisementPublisher::new()
.context("创建 Wi-Fi Direct publisher 失败")?;
let ad = publisher.Advertisement()
.context("读取 Wi-Fi Direct advertisement 失败")?;
ad.SetIsAutonomousGroupOwnerEnabled(true)
.context("启用 Autonomous Group Owner 失败")?;
let legacy = ad.LegacySettings()
.context("读取 LegacySettings 失败")?;
legacy.SetIsEnabled(true)
.context("启用 Wi-Fi Direct Legacy AP 失败")?;
legacy.SetSsid(&HSTRING::from(&ssid))
.context("设置 QFT SSID 失败")?;
let credential = PasswordCredential::new()
.context("创建 Wi-Fi Direct 密码对象失败")?;
credential.SetPassword(&HSTRING::from(&passphrase))
.context("设置 QFT 热点密码失败")?;
legacy.SetPassphrase(&credential)
.context("应用 QFT 热点密码失败")?;
publisher.Start().context("启动 QFT Wi-Fi Direct AP 失败")?;
// Publisher startup is asynchronous. Do not expose the pairing QR until
// Windows reports Started; otherwise Android can scan a network that is
// not yet discoverable.
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
loop {
let status = publisher.Status().context("读取 AP 状态失败")?;
if status == WiFiDirectAdvertisementPublisherStatus::Started {
break;
}
if status == WiFiDirectAdvertisementPublisherStatus::Aborted {
bail!("Wi-Fi Direct AP 启动被系统中止。请确认 Windows Wi-Fi 已开启,且系统移动热点未占用 Wi-Fi Direct。")
}
if std::time::Instant::now() >= deadline {
bail!("Wi-Fi Direct AP 启动超时。请确认无线网卡支持 Wi-Fi Direct,并关闭 Windows 移动热点后重试。")
}
std::thread::sleep(std::time::Duration::from_millis(80));
}
Ok(Self { ssid, publisher })
}
}
}
impl Drop for DirectAp {
fn drop(&mut self) {
#[cfg(windows)]
{
let _ = self.publisher.Stop();
}
}
}
-1042
View File
File diff suppressed because it is too large Load Diff
-229
View File
@@ -1,229 +0,0 @@
use anyhow::{Context, Result};
use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine as _};
use rand::RngCore;
use serde::{Deserialize, Serialize};
use serde_json::{json, Value};
use std::{
fs,
net::{IpAddr, Ipv4Addr},
path::PathBuf,
};
pub const PAIR_PREFIX: &str = "QFTPAIR2:";
pub const SEND_PREFIX: &str = "QFTSEND2:";
#[derive(Clone, Debug)]
pub struct PairingPayload {
pub v: u8,
pub session: String,
pub pc_name: String,
pub transport: String,
pub port: u16,
pub endpoints: Vec<String>,
pub wifi: Option<WifiCredentials>,
/// `upload` means Android uploads to this PC. `download` means the PC has
/// selected a file and Android downloads it immediately after pairing.
pub direction: PairingDirection,
pub file_name: Option<String>,
pub file_size: Option<u64>,
pub sha256: Option<String>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum PairingDirection {
Upload,
Download,
}
#[derive(Clone, Debug)]
pub struct WifiCredentials {
pub ssid: String,
pub passphrase: String,
pub security: String,
}
#[derive(Clone, Debug, Serialize, Deserialize)]
struct DirectApIdentity {
version: u8,
ssid: String,
passphrase: String,
}
impl PairingPayload {
/// v2 intentionally uses short JSON keys. The Direct-AP QR no longer carries
/// a long transport string/security object and only keeps a small endpoint
/// fallback list. This materially lowers QR density and speeds phone scan.
pub fn encode_text(&self) -> Result<String> {
// Direct-AP pairing carries one short endpoint hint for the immediate
// happy path, while Android still treats the connected gateway + UDP
// discovery as authoritative fallbacks. One endpoint keeps QFTPAIR2
// compact but avoids a full discovery round on common Windows APs.
let endpoints: Vec<&str> = if self.wifi.is_some() {
self.endpoints.iter().take(1).map(String::as_str).collect()
} else {
self.endpoints.iter().take(3).map(String::as_str).collect()
};
let wifi = self.wifi.as_ref().map(|w| json!([w.ssid, w.passphrase]));
let mut value = json!({
"v": 2,
"s": self.session,
"n": self.pc_name,
"p": self.port,
"e": endpoints,
"w": wifi,
});
// Keep the common Android → PC QR as small as before. File metadata is
// needed only for the new PC → Android automatic-download QR.
if self.direction == PairingDirection::Download {
let object = value.as_object_mut().expect("pairing JSON object");
object.insert("d".into(), Value::String("d".into()));
object.insert("f".into(), serde_json::to_value(&self.file_name)?);
object.insert("z".into(), serde_json::to_value(self.file_size)?);
object.insert("h".into(), serde_json::to_value(&self.sha256)?);
}
let json = serde_json::to_vec(&value).context("serialize pairing payload")?;
let prefix = match self.direction {
PairingDirection::Upload => PAIR_PREFIX,
PairingDirection::Download => SEND_PREFIX,
};
Ok(format!("{prefix}{}", URL_SAFE_NO_PAD.encode(json)))
}
}
pub fn new_session_token() -> String {
let mut bytes = [0u8; 16];
rand::rng().fill_bytes(&mut bytes);
URL_SAFE_NO_PAD.encode(bytes)
}
/// Keep one random AP identity per Windows device so Android can remember the
/// user's approval for that exact local-only network. The AP itself is only
/// active while QFT receive mode is running; the file-transfer session token is
/// regenerated every time receive mode starts.
pub fn load_or_create_direct_ap_credentials(pc_name: &str) -> Result<(String, String)> {
let path = direct_ap_identity_path();
if let Ok(bytes) = fs::read(&path) {
if let Ok(identity) = serde_json::from_slice::<DirectApIdentity>(&bytes) {
if identity.version == 1
&& !identity.ssid.trim().is_empty()
&& (8..=63).contains(&identity.passphrase.len())
{
return Ok((identity.ssid, identity.passphrase));
}
}
}
let (ssid, passphrase) = new_direct_ap_credentials(pc_name);
let identity = DirectApIdentity {
version: 1,
ssid: ssid.clone(),
passphrase: passphrase.clone(),
};
if let Some(parent) = path.parent() {
fs::create_dir_all(parent)
.with_context(|| format!("创建 QFT 配置目录 {} 失败", parent.display()))?;
}
let tmp = path.with_extension("json.tmp");
let json = serde_json::to_vec_pretty(&identity)?;
fs::write(&tmp, json)
.with_context(|| format!("保存 QFT Direct 身份 {} 失败", tmp.display()))?;
if path.exists() {
let _ = fs::remove_file(&path);
}
fs::rename(&tmp, &path)
.with_context(|| format!("完成 QFT Direct 身份保存 {} 失败", path.display()))?;
Ok((ssid, passphrase))
}
pub fn reset_direct_ap_credentials() -> Result<()> {
let path = direct_ap_identity_path();
if path.exists() {
fs::remove_file(&path)
.with_context(|| format!("删除 QFT Direct 身份 {} 失败", path.display()))?;
}
Ok(())
}
fn direct_ap_identity_path() -> PathBuf {
if let Ok(root) = std::env::var("LOCALAPPDATA") {
if !root.trim().is_empty() {
return PathBuf::from(root).join("QFT").join("direct-ap.json");
}
}
PathBuf::from(".qft").join("direct-ap.json")
}
fn new_direct_ap_credentials(pc_name: &str) -> (String, String) {
let suffix = new_session_token();
let suffix = &suffix[..6.min(suffix.len())];
let base: String = pc_name
.chars()
.filter(|c| c.is_ascii_alphanumeric())
.take(10)
.collect();
let base = if base.is_empty() { "PC" } else { &base };
let ssid = format!("QFT-{base}-{suffix}");
let mut random = [0u8; 12];
rand::rng().fill_bytes(&mut random);
let password = URL_SAFE_NO_PAD.encode(random);
(ssid, password[..16.min(password.len())].to_owned())
}
pub fn local_ipv4_endpoints(port: u16) -> Vec<String> {
let mut ips = Vec::<Ipv4Addr>::new();
if let Ok(addrs) = if_addrs::get_if_addrs() {
for iface in addrs {
let IpAddr::V4(ip) = iface.ip() else { continue };
if ip.is_loopback() || ip.is_unspecified() || ip.is_link_local() {
continue;
}
if !ips.contains(&ip) {
ips.push(ip);
}
}
}
for fallback in [
Ipv4Addr::new(192, 168, 137, 1),
Ipv4Addr::new(192, 168, 49, 1),
] {
if !ips.contains(&fallback) {
ips.push(fallback);
}
}
ips.sort_by_key(|ip| {
if *ip == Ipv4Addr::new(192, 168, 137, 1) { 0 }
else if *ip == Ipv4Addr::new(192, 168, 49, 1) { 1 }
else if ip.is_private() { 2 }
else { 3 }
});
ips.into_iter()
.map(|ip| format!("http://{ip}:{port}"))
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn download_pairing_uses_dedicated_short_prefix() {
let payload = PairingPayload {
v: 2,
session: "abcdefghijklmnopqrstuvwxyz012345".into(),
pc_name: "DESKTOP-QFT".into(),
transport: "http-download-v2".into(),
port: 39393,
endpoints: vec!["http://192.168.49.1:39393".into()],
wifi: None,
direction: PairingDirection::Download,
file_name: Some("sample.bin".into()),
file_size: Some(42),
sha256: Some("00".repeat(32)),
};
let text = payload.encode_text().unwrap();
assert!(text.starts_with(SEND_PREFIX));
assert!(text.len() < 800);
}
}