30 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
68 changed files with 8200 additions and 956 deletions
+52 -1
View File
@@ -1,4 +1,4 @@
# QFT v0.4.7 implementation status # QFT v0.4.16 implementation status
## Windows → Android optical ## Windows → Android optical
@@ -40,6 +40,7 @@
- [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
@@ -49,6 +50,8 @@
- [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] 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
@@ -75,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.
+55 -9
View File
@@ -1,27 +1,73 @@
# QFT · 超速二维码文件传输 v0.4.7 # 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.7 提供两套互不依赖的传输方式: v0.4.16 提供两套互不依赖的传输方式:
- **电脑 → 手机(纯光学)**:文件数据只经过 Windows 屏幕 → Android 摄像头;Wi‑Fi、蓝牙、局域网和互联网都不参与文件数据传输。 - **电脑 → 手机(纯光学)**:文件数据只经过 Windows 屏幕 → Android 摄像头;Wi‑Fi、蓝牙、局域网和互联网都不参与文件数据传输。
- **扫码本地直传(双向)**:Windows 为“手机上传”和“电脑下发”分别生成方向明确的二维码。Android 扫码后连接 QFT 本地网络、通过 UDP/网关/子网探测定位电脑,并按二维码指定方向自动进入选文件上传或接收下载;文件数据不经过外网。 - **扫码本地直传(双向)**:Windows 为“手机上传”和“电脑下发”分别生成方向明确的二维码。Android 扫码后连接 QFT 本地网络、通过 UDP/网关/子网探测定位电脑,并按二维码指定方向自动进入选文件上传或接收下载;文件数据不经过外网。
### v0.4.7 直传稳定性与并发策略 ### v0.4.16 直传稳定性与并发策略
- **双向均使用并行分块**:每个可分块文件以 8 路为目标并发数;分块大小根据文件大小自适应,范围为 **64 KiB–16 MiB**。小于一个最小分块的文件会自然只有一个请求。 - **双向均使用并行分块**:每个可分块文件以 8 路为目标并发数;分块大小根据文件大小自适应,范围为 **64 KiB–16 MiB**。小于一个最小分块的文件会自然只有一个请求。
- **手机 → 电脑**:Android 使用 offset 定位的 Parallel v2 上传;Windows 对每块进行定位写入,重复块与完成请求可安全重试,最终以 SHA-256 校验后原子改名。 - **手机 → 电脑**:Android 使用 offset 定位的 Parallel v2 上传;Windows 对每块进行定位写入,重复块与完成请求可安全重试,最终以 SHA-256 校验后原子改名。
- **电脑 → 手机**:Windows 支持精确的 HTTP `Range`(`206 Partial Content`);Android 对未完成块创建多个独立 Range 请求,并用 `.qftpart` 与完成位图恢复中断传输。每块最多重试 5 次,完成后校验 SHA-256 再保存至 `Downloads/QFT`。 - **电脑 → 手机**:Windows 支持精确的 HTTP `Range`(`206 Partial Content`);Android 对未完成块创建多个独立 Range 请求,并用 `.qftpart` 与完成位图恢复中断传输。每块最多重试 5 次,完成后校验 SHA-256 再保存至 `Downloads/QFT`。
- **连接稳定性**:Windows 监听器保持非阻塞以便及时停止服务,但已连接的文件套接字会切换为带读写超时的阻塞模式,避免 Windows `WSAEWOULDBLOCK (10035)` 造成大文件中途失败。 - **连接稳定性**:Windows 监听器保持非阻塞以便及时停止服务,但已连接的文件套接字会切换为带读写超时的阻塞模式,避免 Windows `WSAEWOULDBLOCK (10035)` 造成大文件中途失败。
> v0.4.7 已完成协议、图像合成解码、ROI、双向并发传输、UDP 发现、内存预算和关键 Kotlin 源码测试。当前生成环境没有真实 Windows 显示器、Android 相机或 Wi‑Fi Direct 适配器,因此物理 30/45/60 FPS 和真实扫码配网仍需在你的设备上跑 `VERIFY_WINDOWS_HOST.ps1` 后做最终验收;详见 `TEST_REPORT.md`。 > 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:跨平台桌面端 + 电脑 ↔ 电脑互传 ## v0.4.8:跨平台桌面端 + 电脑 ↔ 电脑互传
### macOS:请用 QFT.app 启动,不要直接跑裸二进制 ### macOS:请用 QFT超速文件传输.app 启动,不要直接跑裸二进制
`./package.sh` 在 macOS 上会同时产出 `QFT-Desktop`(裸二进制)和 `QFT.app`, `./package.sh` 在 macOS 上会同时产出 `QFT超速文件传输`(裸二进制)和
**推荐用 `QFT.app`**。 `QFT超速文件传输.app`,**推荐使用 `.app` 版本**。
直接运行裸二进制时,AppKit 的部分行为会不稳定——最典型的是点「选择文件」时 直接运行裸二进制时,AppKit 的部分行为会不稳定——最典型的是点「选择文件」时
`+[NSOpenPanel openPanel]` 返回 NULL: `+[NSOpenPanel openPanel]` 返回 NULL:
@@ -256,7 +302,7 @@ APK:
## 一键打包 ## 一键打包
脚本只打包 `desktop/` 下的 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
+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.7 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.7 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.7 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.7 ## 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.7 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.7. 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.7 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 ==
+1 -1
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.7 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"
+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 = 19 versionCode = 28
versionName = "0.4.7" 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"
@@ -150,7 +150,7 @@ 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) discardTransferState(partial) if (partial.length() > expectedSize) discardTransferState(partial)
@@ -181,7 +181,7 @@ object DownloadClient {
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")
discardTransferState(partial) discardTransferState(partial)
if (round + 1 >= VERIFY_ROUNDS) { if (round + 1 >= VERIFY_ROUNDS) {
error("文件校验失败:重新完整下载后 SHA-256 仍不匹配,请让电脑重新生成二维码") error("文件校验失败:重新完整下载后 SHA-256 仍不匹配,请让发送端重新创建传输")
} }
onPhase("校验未通过,正在重新完整下载…") onPhase("校验未通过,正在重新完整下载…")
} }
@@ -379,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
@@ -466,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
@@ -482,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
@@ -550,7 +550,12 @@ object DownloadClient {
onProgress(initial, expectedSize) onProgress(initial, expectedSize)
if (ledger.allComplete()) return if (ledger.allComplete()) return
val workers = ledger.totalChunks.coerceAtMost(RANGE_WORKERS).coerceAtLeast(1) // 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") Log.i(TAG, "parallel start: chunks=${ledger.totalChunks}, workers=$workers, completed=$initial/$expectedSize")
val pool = Executors.newFixedThreadPool(workers) val pool = Executors.newFixedThreadPool(workers)
val next = AtomicInteger(0) val next = AtomicInteger(0)
@@ -584,6 +589,11 @@ object DownloadClient {
} finally { } finally {
pool.shutdownNow() 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()) { if (!ledger.allComplete()) {
error("并行下载未完成:${ledger.bytesComplete()}/$expectedSize") error("并行下载未完成:${ledger.bytesComplete()}/$expectedSize")
} }
@@ -653,7 +663,7 @@ object DownloadClient {
val offset = ledger.chunkOffset(index) val offset = ledger.chunkOffset(index)
val length = ledger.chunkLength(index) val length = ledger.chunkLength(index)
val end = offset + length - 1L val end = offset + 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 = 5_000 conn.connectTimeout = 5_000
@@ -667,7 +677,7 @@ object DownloadClient {
val code = conn.responseCode val code = conn.responseCode
if (code != HttpURLConnection.HTTP_PARTIAL) { if (code != HttpURLConnection.HTTP_PARTIAL) {
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("电脑下载服务未返回并行 Range(HTTP $code)${message?.let { ": $it" } ?: ""}") error("发送端下载服务未返回 Range(HTTP $code)${message?.let { ": $it" } ?: ""}")
} }
val expectedRange = "bytes $offset-$end/$expectedSize" val expectedRange = "bytes $offset-$end/$expectedSize"
if (conn.getHeaderField("Content-Range") != expectedRange) { if (conn.getHeaderField("Content-Range") != expectedRange) {
@@ -691,7 +701,6 @@ object DownloadClient {
while (bytes.hasRemaining()) channel.write(bytes) while (bytes.hasRemaining()) channel.write(bytes)
received += n.toLong() received += n.toLong()
} }
channel.force(false)
} }
} }
} }
@@ -779,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 -> decodeDense(centered, hybrid = true)?.let { result ->
updatePairRegion(result, centered) updatePairRegion(result, centered)
return result return result
} }
if (frameCounter % 3L == 0L) { // Global thresholding remains a cheap fallback for very clean displays,
decodeDense(centered, hybrid = true)?.let { result -> // 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) updatePairRegion(result, centered)
return result 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,6 +30,37 @@ 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
@@ -69,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()
@@ -76,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) {
@@ -117,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 }
@@ -138,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 }
@@ -159,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,
@@ -179,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 {
@@ -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()
@@ -167,10 +200,17 @@ class WifiConnector(context: Context) {
if (waited < 4_000L) { if (waited < 4_000L) {
"已取消系统配网。请重新点击「重试连接」,并在系统弹窗里选择 ${wifi.ssid} 后点连接。" "已取消系统配网。请重新点击「重试连接」,并在系统弹窗里选择 ${wifi.ssid} 后点连接。"
} else { } else {
"系统始终没有搜索到热点 ${wifi.ssid}。请确认:" + if (direction == TransferDirection.PHONE_TO_PHONE) {
"① 电脑上 QFT 接收页仍开着且显示 Direct 已启动;" + "系统始终没有搜索到热点 ${wifi.ssid}。请确认:" +
"② 手机 Wi-Fi 列表里能看到这个名字;" + "① 发送手机仍停留在二维码页面;" +
"③ 电脑与手机距离不要太远。" "② 两台手机距离不要太远;" +
"③ 发送手机没有关闭临时热点或进入省电状态。"
} else {
"系统始终没有搜索到热点 ${wifi.ssid}。请确认:" +
"① 电脑上 QFT 接收页仍开着且显示 Direct 已启动;" +
"② 手机 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
allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK) status = WifiConfiguration.Status.ENABLED
} allowedKeyManagement.clear()
wifiManager.addNetwork(config) allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK)
} }
// 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)
}
}
+1 -1
View File
@@ -2587,7 +2587,7 @@ checksum = "d55d956fa96f5ec02be2e13af0e20391a5aa83d6a074e3ad368959d0fab299ea"
[[package]] [[package]]
name = "qft-desktop" name = "qft-desktop"
version = "0.4.8" version = "0.4.16"
dependencies = [ dependencies = [
"anyhow", "anyhow",
"base64", "base64",
+2 -1
View File
@@ -1,6 +1,6 @@
[package] [package]
name = "qft-desktop" name = "qft-desktop"
version = "0.4.8" version = "0.4.16"
edition = "2024" edition = "2024"
rust-version = "1.95" rust-version = "1.95"
@@ -23,6 +23,7 @@ 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",
] } ] }
+123 -9
View File
@@ -7,15 +7,64 @@ use anyhow::Context;
use windows::{ use windows::{
core::HSTRING, core::HSTRING,
Devices::WiFiDirect::{ Devices::WiFiDirect::{
WiFiDirectAdvertisementPublisher, WiFiDirectAdvertisementPublisherStatus, WiFiDirectAdvertisementListenStateDiscoverability, WiFiDirectAdvertisementPublisher,
WiFiDirectAdvertisementPublisherStatus,
WiFiDirectAdvertisementPublisherStatusChangedEventArgs, WiFiDirectConnectionListener,
WiFiDirectConnectionRequestedEventArgs, WiFiDirectDevice,
}, },
Foundation::TypedEventHandler,
Security::Credentials::PasswordCredential, 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 struct DirectAp {
pub ssid: String, pub ssid: String,
#[cfg(windows)] #[cfg(windows)]
publisher: WiFiDirectAdvertisementPublisher, 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 { impl DirectAp {
@@ -32,6 +81,16 @@ impl DirectAp {
.context("创建 Wi-Fi Direct publisher 失败")?; .context("创建 Wi-Fi Direct publisher 失败")?;
let ad = publisher.Advertisement() let ad = publisher.Advertisement()
.context("读取 Wi-Fi Direct 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) ad.SetIsAutonomousGroupOwnerEnabled(true)
.context("启用 Autonomous Group Owner 失败")?; .context("启用 Autonomous Group Owner 失败")?;
let legacy = ad.LegacySettings() let legacy = ad.LegacySettings()
@@ -47,27 +106,74 @@ impl DirectAp {
legacy.SetPassphrase(&credential) legacy.SetPassphrase(&credential)
.context("应用 QFT 热点密码失败")?; .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.Start().context("启动 QFT Wi-Fi Direct AP 失败")?;
// Publisher startup is asynchronous. Do not expose the pairing QR until // Publisher startup is asynchronous. Do not expose the pairing QR until
// Windows reports Started; otherwise Android can scan a network that is // Windows reports Started; otherwise Android can scan a network that is
// not yet discoverable. // not yet discoverable.
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5); let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
loop { let (connection_listener, connection_requested_token) = loop {
let status = publisher.Status().context("读取 AP 状态失败")?; if let Ok(mut state) = listener_state.lock() {
if status == WiFiDirectAdvertisementPublisherStatus::Started { if let Some(result) = state.take() {
break; break result.map_err(anyhow::Error::msg)?;
}
} }
let status = publisher.Status().context("读取 AP 状态失败")?;
if status == WiFiDirectAdvertisementPublisherStatus::Aborted { if status == WiFiDirectAdvertisementPublisherStatus::Aborted {
bail!("Wi-Fi Direct AP 启动被系统中止。请确认 Windows Wi-Fi 已开启,且系统移动热点未占用 Wi-Fi Direct。") bail!("Wi-Fi Direct AP 启动被系统中止。请确认 Windows Wi-Fi 已开启,且系统移动热点未占用 Wi-Fi Direct。")
} }
if std::time::Instant::now() >= deadline { if std::time::Instant::now() >= deadline {
bail!("Wi-Fi Direct AP 启动超时。请确认无线网卡支持 Wi-Fi Direct,并关闭 Windows 移动热点后重试。") bail!("Wi-Fi Direct AP 或连接监听器启动超时。请确认无线网卡支持 Wi-Fi Direct,并关闭 Windows 移动热点后重试。")
} }
std::thread::sleep(std::time::Duration::from_millis(80)); std::thread::sleep(std::time::Duration::from_millis(25));
} };
let _ = publisher.RemoveStatusChanged(status_token);
Ok(Self { ssid, publisher }) // 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,
})
} }
} }
} }
@@ -76,6 +182,14 @@ impl Drop for DirectAp {
fn drop(&mut self) { fn drop(&mut self) {
#[cfg(windows)] #[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(); let _ = self.publisher.Stop();
} }
} }
+505 -47
View File
@@ -6,10 +6,11 @@
//! //!
//! 三条设计约束: //! 三条设计约束:
//! 1. **只在确实缺规则时申请**。每次启动都弹 UAC 是骚扰。 //! 1. **只在确实缺规则时申请**。每次启动都弹 UAC 是骚扰。
//! 2. **被拒绝就记住**。写一个标记文件,之后只在界面上留一个手动按钮, //! 2. **没有放行就不宣称 Direct 已就绪**。用户明确点击“启动直传/接收”时,
//! 不再自动弹窗。 //! 可以走一次标准 UAC;拒绝或复检失败就停止启动,不生成不可用二维码。
//! 3. **规则尽量窄**。只放行本程序这一个可执行文件,绝不整体关闭防火墙。 //! 3. **规则尽量窄**。程序规则之外只开放 QFT 固定的 TCP/UDP 两个端口,
//! 但**不能按网络配置文件收窄**——见下方 `grant()` 里的说明。 //! 绝不整体关闭防火墙;但**不能按网络配置文件收窄**——见下方
//! `grant()` 里的说明。
//! //!
//! 提权本身由操作系统的标准机制完成(Windows 的 UAC、macOS 的 //! 提权本身由操作系统的标准机制完成(Windows 的 UAC、macOS 的
//! 授权对话框),程序不接触也不存储任何凭据。 //! 授权对话框),程序不接触也不存储任何凭据。
@@ -21,6 +22,14 @@ use std::path::PathBuf;
// 仅 Windows 分支使用;其余平台整段被 cfg 编译掉 // 仅 Windows 分支使用;其余平台整段被 cfg 编译掉
#[cfg_attr(not(target_os = "windows"), allow(dead_code))] #[cfg_attr(not(target_os = "windows"), allow(dead_code))]
pub const RULE_NAME: &str = "QFT Desktop"; 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)] #[derive(Clone, Debug, PartialEq, Eq)]
pub enum FirewallStatus { pub enum FirewallStatus {
@@ -28,6 +37,20 @@ pub enum FirewallStatus {
Allowed, Allowed,
/// 缺少放行规则,入站很可能被拦 /// 缺少放行规则,入站很可能被拦
Missing, 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), Unknown(String),
/// 本平台不做自动放行(目前只有 Linux 会返回) /// 本平台不做自动放行(目前只有 Linux 会返回)
@@ -37,7 +60,32 @@ pub enum FirewallStatus {
impl FirewallStatus { impl FirewallStatus {
pub fn needs_action(&self) -> bool { pub fn needs_action(&self) -> bool {
matches!(self, Self::Missing) 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(),
}
} }
} }
@@ -47,37 +95,196 @@ fn current_exe() -> Result<PathBuf> {
// ---------------------------------------------------------------- Windows // ---------------------------------------------------------------- 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")] #[cfg(target_os = "windows")]
pub fn status() -> FirewallStatus { fn run_powershell(script: &str) -> std::io::Result<std::process::Output> {
use std::os::windows::process::CommandExt; use std::os::windows::process::CommandExt;
const CREATE_NO_WINDOW: u32 = 0x0800_0000; const CREATE_NO_WINDOW: u32 = 0x0800_0000;
std::process::Command::new("powershell")
let output = std::process::Command::new("netsh") .args(["-NoProfile", "-NonInteractive", "-Command", script])
.args([
"advfirewall",
"firewall",
"show",
"rule",
&format!("name={RULE_NAME}"),
])
.creation_flags(CREATE_NO_WINDOW) .creation_flags(CREATE_NO_WINDOW)
.output(); .output()
}
match output { #[cfg(target_os = "windows")]
Ok(out) if out.status.success() => { pub fn status() -> FirewallStatus {
// 光有同名规则还不够:规则若绑在不适用于当前网络的 profile 上, let exe = match current_exe() {
// 会出现「显示已启用但照样被拦」。所以要求它是 profile=any。 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); let text = String::from_utf8_lossy(&out.stdout);
let any_profile = text.contains("Any") || text.contains("任何"); if text.trim().is_empty() {
if any_profile { return FirewallStatus::Unknown(
FirewallStatus::Allowed "防火墙查询没有返回任何内容,可能是 PowerShell 执行策略受限".into(),
} else { );
FirewallStatus::Missing
} }
classify_probe(&text)
} }
// netsh 在找不到规则时退出码非 0 Err(e) => FirewallStatus::Unknown(format!("无法执行 PowerShell:{e}")),
Ok(_) => FirewallStatus::Missing,
Err(e) => FirewallStatus::Unknown(format!("无法执行 netsh:{e}")),
} }
} }
@@ -98,15 +305,19 @@ pub fn grant() -> Result<()> {
const CREATE_NO_WINDOW: u32 = 0x0800_0000; const CREATE_NO_WINDOW: u32 = 0x0800_0000;
let exe = current_exe()?; let exe = current_exe()?;
let script = std::env::temp_dir().join(format!("qft-firewall-{}.bat", std::process::id())); let temp = std::env::temp_dir();
let content = format!( let pid = std::process::id();
"@echo off\r\n\ // 写成 .ps1 文件而不是把命令塞进 -ArgumentList:程序路径里带空格时,
netsh advfirewall firewall delete rule name=\"{RULE_NAME}\" >nul 2>&1\r\n\ // 经过 PowerShell 再到子进程会被重新分词,引号层层嵌套极易出错。
netsh advfirewall firewall add rule name=\"{RULE_NAME}\" dir=in action=allow \ // 脚本文件里的单引号字符串不会被二次解析。
program=\"{}\" enable=yes profile=any\r\n", let script = temp.join(format!("qft-firewall-{pid}.ps1"));
exe.display() let marker = temp.join(format!("qft-firewall-{pid}.ok"));
); let _ = std::fs::remove_file(&marker);
std::fs::write(&script, content).context("写入临时放行脚本失败")?; std::fs::write(
&script,
grant_script(&exe.display().to_string(), &marker.display().to_string()),
)
.context("写入临时放行脚本失败")?;
let status = std::process::Command::new("powershell") let status = std::process::Command::new("powershell")
.args([ .args([
@@ -115,7 +326,7 @@ pub fn grant() -> Result<()> {
"Hidden", "Hidden",
"-Command", "-Command",
&format!( &format!(
"Start-Process -FilePath cmd -ArgumentList '/c','\"{}\"' -Verb RunAs -WindowStyle Hidden -Wait", "Start-Process -FilePath powershell -ArgumentList '-NoProfile','-ExecutionPolicy','Bypass','-File','\"{}\"' -Verb RunAs -WindowStyle Hidden -Wait",
script.display() script.display()
), ),
]) ])
@@ -123,9 +334,18 @@ pub fn grant() -> Result<()> {
.status(); .status();
let _ = std::fs::remove_file(&script); let _ = std::fs::remove_file(&script);
// 外层退出码只能说明「UAC 弹窗流程本身」没出错,说明不了脚本跑没跑通:
// Start-Process -Wait 返回的是启动器的退出码,不是被提权进程的。
// 上一版就是因此把一个语法错误的脚本误报成了放行成功。
let succeeded = marker.exists();
let _ = std::fs::remove_file(&marker);
match status { match status {
// 用户在 UAC 上点了「否」时 Start-Process 会失败,退出码非 0 // 用户在 UAC 上点了「否」时 Start-Process 会失败,退出码非 0
Ok(s) if s.success() => Ok(()), Ok(s) if s.success() && succeeded => Ok(()),
Ok(s) if s.success() => bail!(
"提权成功但放行脚本没有跑完,规则未生效。请点「复制手动放行命令」,\
在管理员 PowerShell 里执行并把报错发出来"
),
Ok(_) => bail!("未获得管理员授权,防火墙规则没有添加"), Ok(_) => bail!("未获得管理员授权,防火墙规则没有添加"),
Err(e) => bail!("调用提权失败:{e}"), Err(e) => bail!("调用提权失败:{e}"),
} }
@@ -222,11 +442,32 @@ pub fn manual_instructions(port: u16) -> String {
#[cfg(target_os = "windows")] #[cfg(target_os = "windows")]
{ {
// -Profile Any 是必须的。这里早先写的是 Private,Domain,与本模块
// grant() 的注释自相矛盾,照抄的用户会重建出一条在公用网络上
// (也就是 Direct AP 虚拟网卡上)根本不适用的规则。
// 剪贴板里**只放命令**,不放任何说明文字。用户是整段粘进 PowerShell 的,
// 混在里面的中文散文会被当成 cmdlet 名逐行报错,把真正的报错淹没掉。
// 同理绝不使用 `\` 续行——那是 bash 语法,PowerShell 用反引号;
// 一条命令就写一行,宁可长。
format!( format!(
"以管理员身份打开 PowerShell,执行:\n\n\ concat!(
New-NetFirewallRule -DisplayName \"{RULE_NAME}\" -Direction Inbound \\\n\ "# 在管理员 PowerShell 中整段粘贴执行\n",
\x20 -Program \"{exe}\" -Action Allow -Profile Private,Domain\n\n\ "$exe = \"{exe}\"\n",
或在「允许应用通过 Windows Defender 防火墙」里勾选该程序的专用网络。" "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")] #[cfg(target_os = "macos")]
@@ -263,12 +504,21 @@ mod tests {
FirewallStatus::Allowed FirewallStatus::Allowed
| FirewallStatus::Missing | FirewallStatus::Missing
| FirewallStatus::Unsupported(_) => {} | FirewallStatus::Unsupported(_) => {}
FirewallStatus::Unknown(reason) => assert!(!reason.is_empty(), "未知原因不能为空"), FirewallStatus::Unknown(reason)
| FirewallStatus::BlockedByPolicy(reason)
| FirewallStatus::BlockedByRule(reason) => {
assert!(!reason.is_empty(), "原因说明不能为空")
}
} }
// 只有 Missing 才该触发后续动作 // Allowed / Unknown / Unsupported 都不该催促用户去点按钮
assert_eq!( assert_eq!(
value.needs_action(), value.needs_action(),
matches!(value, FirewallStatus::Missing) matches!(
value,
FirewallStatus::Missing
| FirewallStatus::BlockedByPolicy(_)
| FirewallStatus::BlockedByRule(_)
)
); );
} }
@@ -283,10 +533,218 @@ mod tests {
); );
} }
// 探测脚本的输出形状是固定的,解析逻辑在任何平台上都能测。
// 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] #[test]
fn status_is_read_only_and_repeatable() { fn status_is_read_only_and_repeatable() {
// 检测必须无副作用:连续调用结果一致,且不改动任何系统设置 // 检测必须无副作用:连续调用结果一致,且不改动任何系统设置
assert_eq!(status(), status()); assert_eq!(status(), status());
} }
} }
+635 -168
View File
File diff suppressed because it is too large Load Diff
+203 -37
View File
@@ -50,18 +50,16 @@ struct DirectApIdentity {
} }
impl PairingPayload { impl PairingPayload {
/// v2 intentionally uses short JSON keys. The Direct-AP QR no longer carries /// v2 intentionally uses short JSON keys. A Direct-AP QR carries only the
/// a long transport string/security object and only keeps a small endpoint /// dedicated Wi-Fi identity, session and port: Android must join that Wi-Fi
/// fallback list. This materially lowers QR density and speeds phone scan. /// 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> { 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() { let endpoints: Vec<&str> = if self.wifi.is_some() {
self.endpoints.iter().take(1).map(String::as_str).collect() Vec::new()
} else { } else {
self.endpoints.iter().take(3).map(String::as_str).collect() self.endpoints.iter().take(4).map(String::as_str).collect()
}; };
let wifi = self.wifi.as_ref().map(|w| json!([w.ssid, w.passphrase])); let wifi = self.wifi.as_ref().map(|w| json!([w.ssid, w.passphrase]));
let mut value = json!({ let mut value = json!({
@@ -96,6 +94,24 @@ pub fn new_session_token() -> String {
URL_SAFE_NO_PAD.encode(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 /// 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 /// 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 /// active while QFT receive mode is running; the file-transfer session token is
@@ -187,9 +203,10 @@ pub fn local_ipv4_addresses() -> Vec<Ipv4Addr> {
} }
ips.sort_by_key(|ip| { ips.sort_by_key(|ip| {
let o = ip.octets(); let o = ip.octets();
if is_likely_virtual(*ip) {
return 4;
}
match (o[0], o[1]) { match (o[0], o[1]) {
// Windows 的 ICS / Wi-Fi Direct 固定网段,最可能是 QFT 自己拉起来的
(192, 168) if o[2] == 137 || o[2] == 49 => 0,
(192, 168) => 1, (192, 168) => 1,
(10, _) => 2, (10, _) => 2,
(172, 16..=31) => 3, (172, 16..=31) => 3,
@@ -199,35 +216,37 @@ pub fn local_ipv4_addresses() -> Vec<Ipv4Addr> {
ips ips
} }
pub fn local_ipv4_endpoints(port: u16) -> Vec<String> { /// 供二维码使用的端点列表。
let mut ips = Vec::<Ipv4Addr>::new(); ///
if let Ok(addrs) = if_addrs::get_if_addrs() { /// Direct AP 模式不广播任何电脑现有网卡地址。手机必须先加入二维码中的
for iface in addrs { /// 专用 Wi-Fi,再从 Android 为该连接提供的实际路由表读取网关。这样不会
let IpAddr::V4(ip) = iface.ip() else { continue }; /// 猜测 192.168.137.1/49.1,也不会误连 LAN、VPN、WSL 或虚拟机网卡。
if ip.is_loopback() || ip.is_unspecified() || ip.is_link_local() { pub fn qr_endpoints(port: u16, direct_ap_active: bool) -> Vec<String> {
continue; if direct_ap_active {
} return Vec::new();
if !ips.contains(&ip) {
ips.push(ip);
}
}
} }
local_ipv4_endpoints(port)
}
for fallback in [ fn is_likely_virtual(ip: Ipv4Addr) -> bool {
Ipv4Addr::new(192, 168, 137, 1), let o = ip.octets();
Ipv4Addr::new(192, 168, 49, 1), if o[3] != 1 {
] { return false;
if !ips.contains(&fallback) {
ips.push(fallback);
}
} }
ips.sort_by_key(|ip| { match (o[0], o[1]) {
if *ip == Ipv4Addr::new(192, 168, 137, 1) { 0 } // VMware Workstation 常用 192.168.(1..=254).1 里的高位段;
else if *ip == Ipv4Addr::new(192, 168, 49, 1) { 1 } // 这里只挑实测遇到的与常见默认值,避免误伤家用 192.168.0/1.1
else if ip.is_private() { 2 } (192, 168) => matches!(o[2], 30 | 31 | 56 | 99 | 100 | 152 | 174 | 226),
else { 3 } // WSL2 / Hyper-V 默认在 172.16-31 段
}); (172, 16..=31) => true,
ips.into_iter() _ => 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}")) .map(|ip| format!("http://{ip}:{port}"))
.collect() .collect()
} }
@@ -236,6 +255,18 @@ pub fn local_ipv4_endpoints(port: u16) -> Vec<String> {
mod tests { mod tests {
use super::*; 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] #[test]
fn download_pairing_uses_dedicated_short_prefix() { fn download_pairing_uses_dedicated_short_prefix() {
let payload = PairingPayload { let payload = PairingPayload {
@@ -256,3 +287,138 @@ mod tests {
assert!(text.len() < 800); 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()));
}
}
-4
View File
@@ -163,14 +163,11 @@ pub const fn platform_tag() -> &'static str {
/// 只有 Windows 走 WiFi Direct;macOS 无公开 API,Linux 各发行版 /// 只有 Windows 走 WiFi Direct;macOS 无公开 API,Linux 各发行版
/// NetworkManager 行为差异过大,都不做——UI 据此隐藏入口, /// NetworkManager 行为差异过大,都不做——UI 据此隐藏入口,
/// 而不是让用户点进去再失败。 /// 而不是让用户点进去再失败。
// UI 尚未据此隐藏 Direct AP 入口,留待 P1.7 收尾
#[allow(dead_code)]
pub enum DirectApSupport { pub enum DirectApSupport {
Supported, Supported,
Unsupported(&'static str), Unsupported(&'static str),
} }
#[allow(dead_code)]
pub const fn direct_ap_support() -> DirectApSupport { pub const fn direct_ap_support() -> DirectApSupport {
#[cfg(target_os = "windows")] #[cfg(target_os = "windows")]
{ {
@@ -183,7 +180,6 @@ pub const fn direct_ap_support() -> DirectApSupport {
} }
impl DirectApSupport { impl DirectApSupport {
#[allow(dead_code)]
pub const fn is_supported(&self) -> bool { pub const fn is_supported(&self) -> bool {
matches!(self, DirectApSupport::Supported) matches!(self, DirectApSupport::Supported)
} }
+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;
+15 -6
View File
@@ -27,6 +27,7 @@ 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 },
@@ -96,7 +97,8 @@ impl ReceiverServer {
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();
@@ -139,7 +141,6 @@ 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 的对端不知道令牌,需要先能把本机列出来 // PC↔PC 的对端不知道令牌,需要先能把本机列出来
let announce = crate::discovery::browse_reply(&crate::discovery::NodeAnnounce { let announce = crate::discovery::browse_reply(&crate::discovery::NodeAnnounce {
@@ -153,12 +154,17 @@ impl ReceiverServer {
match socket.recv_from(&mut buf) { match socket.recv_from(&mut buf) {
Ok((n, peer)) => { Ok((n, peer)) => {
match std::str::from_utf8(&buf[..n]).ok() { match std::str::from_utf8(&buf[..n]).ok() {
Some(text) if text == expected => {
let _ = socket.send_to(response.as_bytes(), peer);
}
Some(text) if text == crate::discovery::BROWSE_QUERY => { Some(text) if text == crate::discovery::BROWSE_QUERY => {
let _ = socket.send_to(&announce, peer); 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);
}
}
_ => {} _ => {}
} }
} }
@@ -452,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!("上传会话损坏"))?;
@@ -503,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("完成文件重命名失败")?;
+148 -14
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,
} }
@@ -138,14 +145,47 @@ fn handle_client(
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(':') {
@@ -155,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)
@@ -180,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()),
)?; )?;
@@ -203,7 +255,7 @@ fn handle_client(
} }
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<()> {
@@ -328,7 +380,7 @@ mod tests {
let mut client = TcpStream::connect(address).unwrap(); let mut client = TcpStream::connect(address).unwrap();
client.write_all( client.write_all(
b"GET /qft/download HTTP/1.1\r\nHost: localhost\r\nX-QFT-Token: session\r\n\r\n", b"GET /qft/download HTTP/1.1\r\nHost: localhost\r\nX-QFT-Token: session\r\nConnection: close\r\n\r\n",
).unwrap(); ).unwrap();
client.flush().unwrap(); client.flush().unwrap();
thread::sleep(Duration::from_millis(50)); thread::sleep(Duration::from_millis(50));
@@ -346,7 +398,7 @@ mod tests {
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();
@@ -365,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 不在本开发版本范围内。
+30
View File
@@ -98,3 +98,33 @@ Range: bytes=<start>-<end>
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 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`.
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. 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.
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)
+52 -14
View File
@@ -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 = 47;
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.7;
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 = 47; 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.7;
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
}
}
+241 -48
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
Task { @MainActor in self?.progress = value } let directory = try DownloadClient.defaultDestinationDirectory()
} let saved = try await download(
finish("已保存到「文件」App 的 QFT 文件夹", saved) 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 }
} })
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, "")
}
}
}
+206 -109
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 {
let size = UInt64(truncating: (attributes[.size] as? NSNumber) ?? 0) throw PeerLink.PeerError.protocolViolation("没有选择任何文件")
var hasher = SHA256()
let handle = try FileHandle(forReadingFrom: fileURL)
while let block = try handle.read(upToCount: 4 * 1024 * 1024), !block.isEmpty {
hasher.update(data: block)
} }
try handle.close()
let digest = hasher.finalize().map { String(format: "%02x", $0) }.joined()
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)
var hasher = SHA256()
let handle = try FileHandle(forReadingFrom: url)
var read: UInt64 = 0
while let block = try handle.read(upToCount: 4 * 1024 * 1024), !block.isEmpty {
hasher.update(data: block)
read &+= UInt64(block.count)
}
try handle.close()
// 文件选择器报告的大小偶尔会和实际内容对不上(iCloud 占位文件、
// 正在被其他 App 写入)。以实读为准,否则二维码里的总量是假的。
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
while let block = try handle.read(upToCount: PeerLink.chunkSize), !block.isEmpty { for (index, meta) in files.enumerated() {
try Task.checkCancellation() try Task.checkCancellation()
try await PeerLink.send(connection, type: .data, payload: block) try await PeerLink.sendJSON(connection, type: .fileBegin,
sent &+= UInt64(block.count) object: ["i": index, "name": meta.name])
let now = Date()
if now.timeIntervalSince(lastReport) > 0.1 || sent >= pairing.fileSize { let handle = try FileHandle(forReadingFrom: fileURLs[index])
lastReport = now defer { try? handle.close() }
onProgress(TransferProgress( var fileSent: UInt64 = 0
completed: sent, total: pairing.fileSize, while let block = try handle.read(upToCount: PeerLink.chunkSize), !block.isEmpty {
bytesPerSecond: Double(sent) / max(0.001, now.timeIntervalSince(startedAt)))) 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)
fileSent &+= UInt64(block.count)
sent &+= UInt64(block.count)
let now = Date()
if now.timeIntervalSince(lastReport) > 0.1 || sent >= pairing.totalSize {
lastReport = now
onProgress(PeerTransferUpdate(
progress: TransferProgress(
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,78 +445,122 @@ 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")
try? FileManager.default.removeItem(at: partURL)
FileManager.default.createFile(atPath: partURL.path, contents: nil)
let handle = try FileHandle(forWritingTo: partURL)
var hasher = SHA256() var saved: [URL] = []
var received: UInt64 = 0 var receivedTotal: UInt64 = 0
let startedAt = Date() let startedAt = Date()
var lastReport = Date.distantPast var lastReport = Date.distantPast
// --- 数据 --- for (index, meta) in files.enumerated() {
do { try Task.checkCancellation()
loop: while true { let (beginType, beginPayload) = try await PeerLink.receiveFrame(connection)
try Task.checkCancellation() guard beginType == .fileBegin,
let (type, payload) = try await PeerLink.receiveFrame(connection) let begin = try? JSONSerialization.jsonObject(with: beginPayload) as? [String: Any],
switch type { (begin["i"] as? Int) == index else {
case .data: throw PeerLink.PeerError.protocolViolation("第 \(index + 1) 个文件的起始帧无效")
guard received &+ UInt64(payload.count) <= pairing.fileSize else {
throw PeerLink.PeerError.protocolViolation("收到的数据超出声明大小")
}
try handle.write(contentsOf: payload)
hasher.update(data: payload)
received &+= UInt64(payload.count)
let now = Date()
if now.timeIntervalSince(lastReport) > 0.1 || received >= pairing.fileSize {
lastReport = now
onProgress(TransferProgress(
completed: received, total: pairing.fileSize,
bytesPerSecond: Double(received) / max(0.001, now.timeIntervalSince(startedAt))))
}
case .eof:
break loop
default:
throw PeerLink.PeerError.protocolViolation("数据阶段收到 \(type)")
}
} }
try handle.close()
} catch { let partURL = destinationDirectory.appendingPathComponent(meta.name + ".qftpart")
try? handle.close()
try? FileManager.default.removeItem(at: partURL) try? FileManager.default.removeItem(at: partURL)
throw error guard FileManager.default.createFile(atPath: partURL.path, contents: nil) else {
throw QFTError.malformedResponse("无法创建临时文件")
}
let handle = try FileHandle(forWritingTo: partURL)
var hasher = SHA256()
var received: UInt64 = 0
do {
loop: while true {
try Task.checkCancellation()
let (type, payload) = try await PeerLink.receiveFrame(connection)
switch type {
case .data:
guard received &+ UInt64(payload.count) <= meta.size else {
throw PeerLink.PeerError.protocolViolation("\(meta.name) 的数据超出声明大小")
}
try handle.write(contentsOf: payload)
hasher.update(data: payload)
received &+= UInt64(payload.count)
receivedTotal &+= UInt64(payload.count)
let now = Date()
if now.timeIntervalSince(lastReport) > 0.1 || receivedTotal >= pairing.totalSize {
lastReport = now
onProgress(PeerTransferUpdate(
progress: TransferProgress(
completed: receivedTotal, total: pairing.totalSize,
bytesPerSecond: Double(receivedTotal)
/ max(0.001, now.timeIntervalSince(startedAt))),
fileIndex: index, fileCount: files.count, fileName: meta.name))
}
case .fileEnd:
break loop
default:
throw PeerLink.PeerError.protocolViolation("数据阶段收到 \(type)")
}
}
try handle.close()
} catch {
try? handle.close()
try? FileManager.default.removeItem(at: partURL)
saved.forEach { try? FileManager.default.removeItem(at: $0) }
throw error
}
let actual = hasher.finalize().map { String(format: "%02x", $0) }.joined()
guard received == meta.size, actual == meta.sha256 else {
try? FileManager.default.removeItem(at: partURL)
saved.forEach { try? FileManager.default.removeItem(at: $0) }
throw QFTError.integrity(
"\(meta.name):收到 \(received)/\(meta.size) 字节,SHA-256 \(actual == meta.sha256 ? "一致" : "不一致")")
}
let finalURL = DownloadClient.uniqueURL(in: destinationDirectory, name: meta.name)
try FileManager.default.moveItem(at: partURL, to: finalURL)
saved.append(finalURL)
} }
// --- 校验 --- let (eofType, _) = try await PeerLink.receiveFrame(connection)
let actual = hasher.finalize().map { String(format: "%02x", $0) }.joined() guard eofType == .eof else {
guard received == pairing.fileSize, actual == pairing.sha256 else { throw PeerLink.PeerError.protocolViolation("队列结束帧无效")
try? FileManager.default.removeItem(at: partURL)
try? await PeerLink.send(connection, type: .result, payload: Data(
#"{"ok":false,"error":"integrity"}"#.utf8))
throw QFTError.integrity("收到 \(received)/\(pairing.fileSize) 字节,SHA-256 \(actual == pairing.sha256 ? "一致" : "不一致")")
} }
return saved
}
let finalURL = DownloadClient.uniqueURL(in: destinationDirectory, name: pairing.fileName) private func errorText(_ error: Error) -> String {
try FileManager.default.moveItem(at: partURL, to: finalURL) String(((error as? LocalizedError)?.errorDescription ?? "\(error)").prefix(200))
try await PeerLink.send(connection, type: .result, payload: Data(#"{"ok":true}"#.utf8))
return finalURL
} }
} }
+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>
+189 -49
View File
@@ -1,12 +1,30 @@
# QFT iOS 客户端 v0.4.7 # 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
选文件 → 算 SHA-256 ```
加入之后判据不是「系统说加好了」,而是**协议层握手成功**——能用正确令牌 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
启动 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.7" 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 = 47", "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
+55 -20
View File
@@ -4,7 +4,7 @@ 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 正式版中文打包 =="
if ! command -v cargo >/dev/null 2>&1; then if ! command -v cargo >/dev/null 2>&1; then
# rustup 装在 keg-only 目录里时不会自动进 PATH,这里兜一下, # rustup 装在 keg-only 目录里时不会自动进 PATH,这里兜一下,
# 避免用户明明装了工具链却被告知"没装"。 # 避免用户明明装了工具链却被告知"没装"。
@@ -23,35 +23,43 @@ command -v cargo >/dev/null 2>&1 || {
exit 1 exit 1
} }
echo "[1/3] Testing and building the Rust desktop release..." echo "[1/4] 测试并构建桌面正式版..."
( (
cd desktop 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}' desktop/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 "desktop/target/release/qft-desktop.exe" ]; then if [ -f "desktop/target/release/qft-desktop.exe" ]; then
cp "desktop/target/release/qft-desktop.exe" "$QFT_PACKAGE_DIR/QFT-Windows.exe" cp "desktop/target/release/qft-desktop.exe" "$QFT_PACKAGE_DIR/QFT超速文件传输.exe"
elif [ -f "desktop/target/release/qft-desktop" ]; then elif [ -f "desktop/target/release/qft-desktop" ]; then
cp "desktop/target/release/qft-desktop" "$QFT_PACKAGE_DIR/QFT-Desktop" cp "desktop/target/release/qft-desktop" "$QFT_PACKAGE_DIR/QFT超速文件传输"
# macOS 上额外产出 .app 包。AppKit 的若干行为(其中就包括 # macOS 上额外产出 .app 包。AppKit 的若干行为(其中就包括
# NSOpenPanel)依赖应用被正确注册为 GUI 程序,直接跑裸二进制时 # NSOpenPanel)依赖应用被正确注册为 GUI 程序,直接跑裸二进制时
# openPanel 会偶发返回 NULL 并导致崩溃。 # openPanel 会偶发返回 NULL 并导致崩溃。
if [ "$QFT_PLATFORM" = "darwin" ]; then if [ "$QFT_PLATFORM" = "darwin" ]; then
QFT_APP="$QFT_PACKAGE_DIR/QFT.app" QFT_APP="$QFT_PACKAGE_DIR/QFT超速文件传输.app"
mkdir -p "$QFT_APP/Contents/MacOS" mkdir -p "$QFT_APP/Contents/MacOS"
cp "desktop/target/release/qft-desktop" "$QFT_APP/Contents/MacOS/QFT" cp "desktop/target/release/qft-desktop" "$QFT_APP/Contents/MacOS/QFT"
chmod +x "$QFT_APP/Contents/MacOS/QFT" chmod +x "$QFT_APP/Contents/MacOS/QFT"
cat > "$QFT_APP/Contents/Info.plist" <<'PLIST' cat > "$QFT_APP/Contents/Info.plist" <<PLIST
<?xml version="1.0" encoding="UTF-8"?> <?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"> <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0"> <plist version="1.0">
@@ -61,35 +69,62 @@ elif [ -f "desktop/target/release/qft-desktop" ]; then
<key>CFBundleIdentifier</key><string>com.qft.desktop</string> <key>CFBundleIdentifier</key><string>com.qft.desktop</string>
<key>CFBundleExecutable</key><string>QFT</string> <key>CFBundleExecutable</key><string>QFT</string>
<key>CFBundlePackageType</key><string>APPL</string> <key>CFBundlePackageType</key><string>APPL</string>
<key>CFBundleShortVersionString</key><string>0.5.0</string> <key>CFBundleShortVersionString</key><string>${QFT_VERSION}</string>
<key>CFBundleVersion</key><string>1</string> <key>CFBundleVersion</key><string>1</string>
<key>NSHighResolutionCapable</key><true/> <key>NSHighResolutionCapable</key><true/>
<key>LSMinimumSystemVersion</key><string>11.0</string> <key>LSMinimumSystemVersion</key><string>11.0</string>
</dict> </dict>
</plist> </plist>
PLIST PLIST
echo " 已生成 QFT.app(推荐用它启动,比裸二进制稳定)" echo " 已生成 QFT超速文件传输.app(推荐使用)"
fi 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 会报错 # 只对普通文件求校验和:.app 是目录,直接喂给 sha256sum 会报错
if command -v sha256sum >/dev/null 2>&1; then if command -v sha256sum >/dev/null 2>&1; then
find . -type f ! -name SHA256SUMS.txt | sort | xargs sha256sum > SHA256SUMS.txt find . -type f ! -name SHA256校验.txt | sort | xargs sha256sum > SHA256校验.txt
else else
find . -type f ! -name SHA256SUMS.txt | sort | xargs 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',