Compare commits
16 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| 99be46acf7 | |||
| 375ae8a956 | |||
| bcadcf0b53 | |||
| 0f0dbaef47 | |||
| bdb822233f | |||
| 3e4d5861aa | |||
| 84643bff5e | |||
| d2669fb2e4 | |||
| 92237ff76f | |||
| 376ffba96e | |||
| a960ad91d8 | |||
| 20ac4dc6c7 | |||
| cb92397300 | |||
| dffee5365d | |||
| a4edf734b6 | |||
| f260ff4266 |
@@ -19,3 +19,5 @@ ios/**/xcuserdata/
|
||||
ios/**/*.xcworkspace/xcuserdata/
|
||||
ios/build/
|
||||
DerivedData/
|
||||
# package.sh 打包产物
|
||||
/dist
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
# QFT v0.4.6 implementation status
|
||||
# QFT v0.4.7 implementation status
|
||||
|
||||
## Windows → Android optical
|
||||
|
||||
@@ -44,13 +44,24 @@
|
||||
- [x] local cleartext network security config
|
||||
- [x] local/private IPv4 + session-token validation
|
||||
- [x] Parallel v2 init/chunk/finish
|
||||
- [x] adaptive 4/8/16 MiB chunks
|
||||
- [x] adaptive 64 KiB–16 MiB chunks, targeting eight flows per file
|
||||
- [x] up to 8 Android workers per file
|
||||
- [x] Windows positioned concurrent writes
|
||||
- [x] temporary `.qftpart`, final SHA-256 and rename
|
||||
- [x] accepted sockets return to timeout-bound blocking I/O before file transfer
|
||||
- [x] loopback UDP + HTTP + out-of-order parallel integration test
|
||||
- [ ] physical Windows Wi-Fi Direct adapter / driver / firewall matrix
|
||||
|
||||
## Windows → Android local direct
|
||||
|
||||
- [x] direction-specific pairing QR starts automatic local download after scan
|
||||
- [x] HTTP `Range` responses return the exact requested range (`206` + `Content-Range`)
|
||||
- [x] Android parallel Range downloader targets eight workers per file
|
||||
- [x] adaptive 64 KiB–16 MiB chunks
|
||||
- [x] `.qftpart` completion ledger resumes only verified completed ranges
|
||||
- [x] five retries per range, final SHA-256, then save to `Downloads/QFT`
|
||||
- [x] regression test for delayed large download after nonblocking accept
|
||||
|
||||
## Android compatibility
|
||||
|
||||
- [x] minSdk 24 (Android 7.0)
|
||||
|
||||
@@ -1,13 +1,125 @@
|
||||
# QFT · 超速二维码文件传输 v0.4.6
|
||||
# QFT · 超速二维码文件传输 v0.4.7
|
||||
|
||||
Windows + Android 双向候选版。v0.4 的核心目标不是继续堆“4 码理论吞吐”,而是解决 Android 端实际识别慢的问题:**删除 2×2/4 通道,改成一个大二维码 + 动态 ROI 锁定 + 高频局部解码**。
|
||||
|
||||
两个方向仍然采用不同链路:
|
||||
v0.4.7 提供两套互不依赖的传输方式:
|
||||
|
||||
- **Windows → Android:纯光学**。文件数据只经过 Windows 屏幕 → Android 摄像头;Wi‑Fi、蓝牙、局域网和互联网都不参与文件数据传输。
|
||||
- **Android → Windows:扫码本地直连**。Windows 选择保存目录并启动 QFT Direct/LAN 接收服务;Android 扫码、配网、自动发现电脑,然后并行分块上传,不经过外网。
|
||||
- **电脑 → 手机(纯光学)**:文件数据只经过 Windows 屏幕 → Android 摄像头;Wi‑Fi、蓝牙、局域网和互联网都不参与文件数据传输。
|
||||
- **扫码本地直传(双向)**:Windows 为“手机上传”和“电脑下发”分别生成方向明确的二维码。Android 扫码后连接 QFT 本地网络、通过 UDP/网关/子网探测定位电脑,并按二维码指定方向自动进入选文件上传或接收下载;文件数据不经过外网。
|
||||
|
||||
> v0.4.6 已完成协议、图像合成解码、ROI、并行上传、UDP 发现、内存预算和关键 Kotlin 源码测试。当前生成环境没有真实 Windows 显示器、Android 相机或 Wi‑Fi Direct 适配器,因此物理 30/45/60 FPS 和真实扫码配网仍需在你的设备上跑 `VERIFY_WINDOWS_HOST.ps1` 后做最终验收;详见 `TEST_REPORT.md`。
|
||||
### v0.4.7 直传稳定性与并发策略
|
||||
|
||||
- **双向均使用并行分块**:每个可分块文件以 8 路为目标并发数;分块大小根据文件大小自适应,范围为 **64 KiB–16 MiB**。小于一个最小分块的文件会自然只有一个请求。
|
||||
- **手机 → 电脑**:Android 使用 offset 定位的 Parallel v2 上传;Windows 对每块进行定位写入,重复块与完成请求可安全重试,最终以 SHA-256 校验后原子改名。
|
||||
- **电脑 → 手机**:Windows 支持精确的 HTTP `Range`(`206 Partial Content`);Android 对未完成块创建多个独立 Range 请求,并用 `.qftpart` 与完成位图恢复中断传输。每块最多重试 5 次,完成后校验 SHA-256 再保存至 `Downloads/QFT`。
|
||||
- **连接稳定性**:Windows 监听器保持非阻塞以便及时停止服务,但已连接的文件套接字会切换为带读写超时的阻塞模式,避免 Windows `WSAEWOULDBLOCK (10035)` 造成大文件中途失败。
|
||||
|
||||
> v0.4.7 已完成协议、图像合成解码、ROI、双向并发传输、UDP 发现、内存预算和关键 Kotlin 源码测试。当前生成环境没有真实 Windows 显示器、Android 相机或 Wi‑Fi Direct 适配器,因此物理 30/45/60 FPS 和真实扫码配网仍需在你的设备上跑 `VERIFY_WINDOWS_HOST.ps1` 后做最终验收;详见 `TEST_REPORT.md`。
|
||||
|
||||
## v0.4.8:跨平台桌面端 + 电脑 ↔ 电脑互传
|
||||
|
||||
### macOS:请用 QFT.app 启动,不要直接跑裸二进制
|
||||
|
||||
`./package.sh` 在 macOS 上会同时产出 `QFT-Desktop`(裸二进制)和 `QFT.app`,
|
||||
**推荐用 `QFT.app`**。
|
||||
|
||||
直接运行裸二进制时,AppKit 的部分行为会不稳定——最典型的是点「选择文件」时
|
||||
`+[NSOpenPanel openPanel]` 返回 NULL:
|
||||
|
||||
```
|
||||
panicked at objc2-app-kit/src/generated/NSOpenPanel.rs:
|
||||
unexpected NULL returned from +[NSOpenPanel openPanel]
|
||||
```
|
||||
|
||||
程序侧已经兜住了这个 panic(不会再崩溃,只提示"对话框没有返回结果"),
|
||||
但要彻底避免,用 `.app` 启动即可。
|
||||
|
||||
任何情况下都可以**直接把文件拖进窗口**——拖拽不经过系统文件对话框。
|
||||
|
||||
### Windows 构建报 `os error 5 拒绝访问`
|
||||
|
||||
```
|
||||
error: failed to remove file `...\target\release\qft-desktop.exe`
|
||||
Caused by: 拒绝访问。 (os error 5)
|
||||
```
|
||||
|
||||
**QFT 窗口还开着**,正在运行的 exe 锁住了产物文件。关掉窗口再构建即可。
|
||||
`VERIFY_WINDOWS_HOST.ps1` 会在构建前检测并询问是否结束进程。
|
||||
|
||||
若关掉后仍然报错,通常是 Windows Defender 正在扫描刚生成的 exe,
|
||||
稍等几秒重试;也可以把 `desktop\target` 加入 Defender 排除目录。
|
||||
|
||||
### 防火墙放行(手动)
|
||||
|
||||
|
||||
接收端要监听入站 TCP,Windows 防火墙默认会拦截未授权程序,表现是
|
||||
「对方能解析连接码但连接一直超时」。
|
||||
|
||||
程序在「电脑 ↔ 电脑 → 我要接收」页会**只读检测**防火墙状态,并提供
|
||||
「放行防火墙(需要管理员授权)」按钮——**提权只在你点击时发生**,
|
||||
不会在启动时自动弹 UAC。
|
||||
|
||||
也可以自己加规则。两个必须注意的点:
|
||||
|
||||
1. 二进制已从 `qft-windows.exe` 改名为 `qft-desktop.exe`,**此前给旧名字
|
||||
放行的规则对新程序不生效**。
|
||||
2. **profile 必须是 `Any`**。Windows 对没见过的 Wi-Fi 默认归类为
|
||||
「公用网络」,此时只覆盖 `Private,Domain` 的规则根本不适用——
|
||||
规则建了、`Get-NetFirewallRule` 也显示 Enabled,但连接照样被拦。
|
||||
|
||||
```powershell
|
||||
$exe = "<完整路径>\qft-desktop.exe"
|
||||
# 先清掉可能存在的阻止规则:Windows 里 Block 永远优先于 Allow
|
||||
Get-NetFirewallApplicationFilter -Program $exe -ErrorAction SilentlyContinue |
|
||||
Get-NetFirewallRule | Where-Object Action -eq 'Block' | Remove-NetFirewallRule
|
||||
New-NetFirewallRule -DisplayName "QFT Desktop" -Direction Inbound `
|
||||
-Program $exe -Action Allow -Profile Any
|
||||
```
|
||||
|
||||
排查时先看这两列:
|
||||
|
||||
```powershell
|
||||
Get-NetConnectionProfile | Format-List Name,NetworkCategory
|
||||
Get-NetFirewallApplicationFilter | Where-Object Program -like "*qft*" |
|
||||
ForEach-Object { $r = $_ | Get-NetFirewallRule
|
||||
[PSCustomObject]@{ 规则=$r.DisplayName; 动作=$r.Action; 配置=$r.Profile } } | Format-Table
|
||||
```
|
||||
|
||||
若 `NetworkCategory` 是 `Public` 而规则的 `配置` 只有 `Domain, Private`,
|
||||
就是这个原因。
|
||||
|
||||
管理员 PowerShell:
|
||||
|
||||
```powershell
|
||||
New-NetFirewallRule -DisplayName "QFT Desktop" -Direction Inbound `
|
||||
-Program "<完整路径>\qft-desktop.exe" -Action Allow -Profile Private,Domain
|
||||
```
|
||||
|
||||
或在「允许应用通过 Windows Defender 防火墙」里勾选 `qft-desktop.exe` 的**专用网络**。
|
||||
|
||||
排查顺序:对端 `ping` 不通且 TCP 端口连不上,但 `arp -a` 能看到对方 MAC,
|
||||
基本可以判定是对端主机在丢包(防火墙),而不是网络不通。
|
||||
|
||||
|
||||
桌面端目录从 `windows/` 改名为 `desktop/`,crate 更名 `qft-desktop`,
|
||||
**现已可在 macOS / Linux / Windows 三平台编译运行**。平台差异全部收敛在
|
||||
`desktop/src/platform.rs`(配置目录、下载目录、设备名、Direct AP 能力),
|
||||
其余模块不再出现 `#[cfg(target_os)]`。
|
||||
|
||||
新增两块此前完全缺失的能力:
|
||||
|
||||
- `desktop/src/client.rs` —— 桌面端的**发起侧**。此前桌面只有服务端,
|
||||
`TcpStream::connect` 仅存在于测试中,因此 PC 无法主动连接另一台 PC。
|
||||
- `desktop/src/discovery.rs` —— 局域网节点浏览(UDP 广播 `QFTBROWSE3`)。
|
||||
既有的 `QFTDISC2` 是「已知令牌找机器」,用于手机扫码之后;
|
||||
PC↔PC 没有摄像头,必须先能列出附近有哪些节点。
|
||||
|
||||
配对方式:接收方启动后显示 **6 位配对码**,发送方搜索到对方后输入该码
|
||||
换取会话令牌(`POST /qft/pair`)。6 位约 20 bit 熵,靠严格失败计数兜底——
|
||||
错 5 次即作废整个码,需要重新启动接收。
|
||||
|
||||
已知限制:UDP 广播只覆盖同一广播域,跨网段或开了 AP 隔离的 Wi-Fi
|
||||
搜索不到对方,此时在界面上手动输入对方 IP。
|
||||
|
||||
## v0.4 光学链路改动
|
||||
|
||||
@@ -93,7 +205,7 @@ Windows 光传页面已经改成“二维码优先”:
|
||||
|
||||
推荐初次真机测试从 **30 FPS** 开始,看 Android 的“新帧/s”,再切 45、60。目标不是 Windows 数字最大,而是 Android **实际新帧/s 最大**。
|
||||
|
||||
## Android → Windows
|
||||
## 扫码本地直传(Android ↔ Windows)
|
||||
|
||||
v0.3 的稳定性优化继续保留:
|
||||
|
||||
@@ -103,8 +215,11 @@ v0.3 的稳定性优化继续保留:
|
||||
- 扫码连接后 UDP `QFTDISC2` 快速发现;
|
||||
- gateway / endpoint / 当前子网 fallback;
|
||||
- HTTP 请求明确绑定扫码建立的 `Network`;
|
||||
- 单文件最高 8 worker 并行;
|
||||
- 4/8/16 MiB 自适应上传块;
|
||||
- 配网请求在传输页持续持有,仅返回首页时释放;短暂网络波动会自动接入新的 `Network`;
|
||||
- 手机上传和电脑下发均以 8 路为目标并发数;
|
||||
- 64 KiB–16 MiB 自适应分块;
|
||||
- 电脑下发使用精确 Range 响应,手机以 `.qftpart` + 位图断点续传;
|
||||
- 手机上传使用定位写入和幂等完成确认;
|
||||
- Windows positioned writes + `.qftpart` + SHA-256 + 最终 rename。
|
||||
|
||||
## Android 版本
|
||||
@@ -119,7 +234,7 @@ v0.3 的稳定性优化继续保留:
|
||||
### Windows
|
||||
|
||||
```powershell
|
||||
cd windows
|
||||
cd desktop
|
||||
cargo check
|
||||
cargo test
|
||||
cargo build --release
|
||||
@@ -139,9 +254,21 @@ APK:
|
||||
|
||||
`android/app/build/outputs/apk/debug/app-debug.apk`
|
||||
|
||||
## 一键打包
|
||||
|
||||
脚本只打包 `desktop/` 下的 Rust 桌面端:执行 `cargo test` 和 `cargo build --release`,随后把 Rust 二进制、协议说明和 SHA-256 校验文件收集到带时间戳的 `dist/QFT-Rust-*` 目录并生成压缩包。脚本不检查、下载或调用 Android SDK、Java、Gradle:
|
||||
|
||||
```bat
|
||||
package.bat
|
||||
```
|
||||
|
||||
```bash
|
||||
./package.sh
|
||||
```
|
||||
|
||||
## 字体
|
||||
|
||||
Windows UI 优先读取 `windows/assets/qft-ui.ttf`,也可用 `QFT_FONT_PATH` 指向你自己的中文 TTF。仓库不附带第三方字体文件。
|
||||
桌面端 UI 优先读取 `desktop/assets/qft-ui.ttf`,也可用 `QFT_FONT_PATH` 指向你自己的中文 TTF。仓库不附带第三方字体文件。
|
||||
|
||||
## 自动验证
|
||||
|
||||
|
||||
+5
-5
@@ -1,4 +1,4 @@
|
||||
# QFT v0.4.6 test report
|
||||
# QFT v0.4.7 test report
|
||||
|
||||
Date: 2026-08-10
|
||||
|
||||
@@ -6,7 +6,7 @@ This report separates **tests actually executed in the current environment** fro
|
||||
|
||||
## What this RC changes
|
||||
|
||||
The v0.4.6 optical path is deliberately simpler than v0.3:
|
||||
The v0.4.7 optical path is deliberately simpler than v0.3:
|
||||
|
||||
- 2×2 / 4-channel QR removed;
|
||||
- one large QR only;
|
||||
@@ -152,7 +152,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.
|
||||
|
||||
## Important implementation decisions validated during v0.4.6
|
||||
## Important implementation decisions validated during v0.4.7
|
||||
|
||||
### QFT2 uses Result.text, not ZXing rawBytes
|
||||
|
||||
@@ -160,7 +160,7 @@ The active path is Base45 text. Android reconstructs the QFT binary frame from `
|
||||
|
||||
### Duplicate camera hits are not duplicate assembler work
|
||||
|
||||
At 45/60 display FPS, a camera can observe the same displayed QR in multiple exposures. v0.4.6 still counts every successful decode in diagnostics, but only a changed QFT2 text fingerprint is delivered to `SessionAssembler`.
|
||||
At 45/60 display FPS, a camera can observe the same displayed QR in multiple exposures. v0.4.7 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
|
||||
|
||||
@@ -170,7 +170,7 @@ The scanner performs initial focus/metering, then re-meters after first lock or
|
||||
|
||||
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**:
|
||||
|
||||
1. Windows `cargo check/test/build --release` for v0.4.6.
|
||||
1. Windows `cargo check/test/build --release` for v0.4.7.
|
||||
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.
|
||||
4. Lock acquisition/reacquisition timing on Android 7 and different phone camera pipelines.
|
||||
|
||||
+1
-1
@@ -1,4 +1,4 @@
|
||||
QFT v0.4.6 test results
|
||||
QFT v0.4.7 test results
|
||||
UTC 2026-08-10T08:45:56Z
|
||||
|
||||
== protocol_selftest.py ==
|
||||
|
||||
+23
-4
@@ -1,7 +1,7 @@
|
||||
$ErrorActionPreference = 'Stop'
|
||||
$Root = Split-Path -Parent $MyInvocation.MyCommand.Path
|
||||
|
||||
Write-Host "== QFT v0.4.6 Windows host verification ==" -ForegroundColor Cyan
|
||||
Write-Host "== QFT v0.4.7 Windows host verification ==" -ForegroundColor Cyan
|
||||
|
||||
if (Get-Command python -ErrorAction SilentlyContinue) {
|
||||
Write-Host "[1/4] Core protocol/selftests"
|
||||
@@ -14,8 +14,27 @@ if (Get-Command python -ErrorAction SilentlyContinue) {
|
||||
Write-Warning "python not found; skipping repository Python selftests"
|
||||
}
|
||||
|
||||
Write-Host "[2/4] Windows Rust compile/test/release"
|
||||
Push-Location "$Root\windows"
|
||||
Write-Host "[2/4] Desktop Rust compile/test/release"
|
||||
|
||||
# 正在运行的 qft-desktop.exe 会锁住产物文件,cargo 只会抛出
|
||||
# "failed to remove file ... 拒绝访问 (os error 5)" 这种看不出原因的错误。
|
||||
# 这里提前识别并说清楚,而不是让用户去猜。
|
||||
$Running = Get-Process -Name 'qft-desktop' -ErrorAction SilentlyContinue
|
||||
if ($Running) {
|
||||
Write-Host ""
|
||||
Write-Warning "检测到 qft-desktop.exe 正在运行(PID: $($Running.Id -join ', '))。"
|
||||
Write-Warning "它会锁住 target\release\qft-desktop.exe,导致构建报 'os error 5 拒绝访问'。"
|
||||
$Answer = Read-Host "是否结束这些进程后继续构建?(y/N)"
|
||||
if ($Answer -eq 'y' -or $Answer -eq 'Y') {
|
||||
$Running | Stop-Process -Force
|
||||
Start-Sleep -Milliseconds 500
|
||||
Write-Host "已结束,继续构建。"
|
||||
} else {
|
||||
throw "请先关闭 QFT 窗口再重新运行本脚本"
|
||||
}
|
||||
}
|
||||
|
||||
Push-Location "$Root\desktop"
|
||||
try {
|
||||
& cargo check
|
||||
if ($LASTEXITCODE -ne 0) { throw "cargo check failed" }
|
||||
@@ -37,7 +56,7 @@ try {
|
||||
} finally { Pop-Location }
|
||||
|
||||
Write-Host "[4/4] Artifact locations" -ForegroundColor Cyan
|
||||
Write-Host "Windows EXE: $Root\windows\target\release\qft-windows.exe"
|
||||
Write-Host "Windows EXE: $Root\desktop\target\release\qft-desktop.exe"
|
||||
Write-Host "Android APK: $Root\android\app\build\outputs\apk\debug\app-debug.apk"
|
||||
Write-Host "`nHOST BUILD VERIFICATION PASSED" -ForegroundColor Green
|
||||
Write-Host "Next: perform the physical display/camera and Wi-Fi Direct acceptance matrix in TEST_REPORT.md."
|
||||
|
||||
@@ -12,8 +12,8 @@ android {
|
||||
applicationId = "com.qft.optical"
|
||||
minSdk = 24
|
||||
targetSdk = 35
|
||||
versionCode = 18
|
||||
versionName = "0.4.6"
|
||||
versionCode = 19
|
||||
versionName = "0.4.7"
|
||||
|
||||
testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
|
||||
}
|
||||
|
||||
@@ -13,9 +13,14 @@ import java.io.File
|
||||
import java.io.FileInputStream
|
||||
import java.io.FileOutputStream
|
||||
import java.io.OutputStream
|
||||
import java.io.RandomAccessFile
|
||||
import java.net.HttpURLConnection
|
||||
import java.net.URL
|
||||
import java.nio.ByteBuffer
|
||||
import java.security.MessageDigest
|
||||
import java.util.concurrent.Executors
|
||||
import java.util.concurrent.atomic.AtomicInteger
|
||||
import java.util.concurrent.atomic.AtomicLong
|
||||
|
||||
data class DownloadedFile(val name: String, val size: Long, val uri: Uri?)
|
||||
|
||||
@@ -24,17 +29,113 @@ data class DownloadedFile(val name: String, val size: Long, val uri: Uri?)
|
||||
object DownloadClient {
|
||||
private const val TAG = "QftDownload"
|
||||
private const val BUFFER_SIZE = 1024 * 1024
|
||||
private const val ATTEMPTS = 5
|
||||
private const val SERIAL_ATTEMPTS = 3
|
||||
// Kept only for the old sequential compatibility path below. New direct
|
||||
// sessions always use the concurrent Range downloader.
|
||||
private const val PARALLEL_MIN_FILE_SIZE = 32L * 1024L * 1024L
|
||||
private const val PARALLEL_CHUNK_SIZE = 16L * 1024L * 1024L
|
||||
private const val MAX_WORKERS = 8
|
||||
private const val RANGE_WORKERS = 8
|
||||
private const val RANGE_ATTEMPTS = 5
|
||||
private const val MIN_RANGE_CHUNK = 64L * 1024L
|
||||
private const val MAX_RANGE_CHUNK = 16L * 1024L * 1024L
|
||||
/** 整份重下的轮数。仅在 SHA-256 不匹配(缓存已损坏)时才会用到第二轮。 */
|
||||
private const val VERIFY_ROUNDS = 2
|
||||
|
||||
/** 落盘阶段的失败与「下载失败」是两回事,用独立异常类型区分。 */
|
||||
class SaveFailure(message: String, cause: Throwable?) : Exception(message, cause)
|
||||
|
||||
/** Persistent received-range map. The data file is preallocated, so its
|
||||
* length is not used as a completion signal; only an atomically replaced
|
||||
* map entry marks a range safe to resume. */
|
||||
private class ChunkLedger private constructor(
|
||||
private val partial: File,
|
||||
private val map: File,
|
||||
private val size: Long,
|
||||
val chunkSize: Long,
|
||||
val totalChunks: Int,
|
||||
private val completed: BooleanArray,
|
||||
) {
|
||||
private val lock = Any()
|
||||
|
||||
fun isComplete(index: Int): Boolean = synchronized(lock) { completed[index] }
|
||||
|
||||
fun allComplete(): Boolean = synchronized(lock) { completed.all { it } }
|
||||
|
||||
fun bytesComplete(): Long = synchronized(lock) {
|
||||
completed.indices.sumOf { index -> if (completed[index]) chunkLength(index) else 0L }
|
||||
}
|
||||
|
||||
fun chunkOffset(index: Int): Long = index.toLong() * chunkSize
|
||||
|
||||
fun chunkLength(index: Int): Long = minOf(chunkSize, size - chunkOffset(index))
|
||||
|
||||
fun markComplete(index: Int) = synchronized(lock) {
|
||||
if (!completed[index]) {
|
||||
completed[index] = true
|
||||
persistLocked()
|
||||
}
|
||||
}
|
||||
|
||||
fun discard() = synchronized(lock) {
|
||||
partial.delete()
|
||||
map.delete()
|
||||
File("${map.path}.tmp").delete()
|
||||
}
|
||||
|
||||
private fun persistLocked() {
|
||||
val temp = File("${map.path}.tmp")
|
||||
temp.bufferedWriter().use { writer ->
|
||||
writer.appendLine("$size:$chunkSize:$totalChunks")
|
||||
writer.write(buildString(totalChunks) {
|
||||
completed.forEach { append(if (it) '1' else '0') }
|
||||
})
|
||||
}
|
||||
if (map.exists()) map.delete()
|
||||
if (!temp.renameTo(map)) {
|
||||
temp.copyTo(map, overwrite = true)
|
||||
temp.delete()
|
||||
}
|
||||
}
|
||||
|
||||
companion object {
|
||||
fun open(partial: File, size: Long, chunkSize: Long): ChunkLedger {
|
||||
val totalLong = if (size == 0L) 0L else (size + chunkSize - 1L) / chunkSize
|
||||
require(totalLong <= Int.MAX_VALUE) { "文件分块数过大" }
|
||||
val total = totalLong.toInt()
|
||||
val map = File("${partial.path}.map")
|
||||
val restored = runCatching {
|
||||
val pieces = map.readText().split('\n', limit = 2)
|
||||
val header = pieces.firstOrNull()?.split(':') ?: emptyList()
|
||||
val bits = pieces.getOrNull(1).orEmpty()
|
||||
if (
|
||||
partial.length() == size && header.size == 3 &&
|
||||
header[0].toLong() == size && header[1].toLong() == chunkSize &&
|
||||
header[2].toInt() == total && bits.length >= total
|
||||
) {
|
||||
BooleanArray(total) { bits[it] == '1' }
|
||||
} else {
|
||||
null
|
||||
}
|
||||
}.getOrNull()
|
||||
val ledger = ChunkLedger(partial, map, size, chunkSize, total, restored ?: BooleanArray(total))
|
||||
if (restored == null) {
|
||||
partial.parentFile?.let { if (!it.exists()) it.mkdirs() }
|
||||
RandomAccessFile(partial, "rw").use { file ->
|
||||
file.setLength(0L)
|
||||
file.setLength(size)
|
||||
}
|
||||
ledger.persistLocked()
|
||||
}
|
||||
return ledger
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun download(
|
||||
context: Context,
|
||||
resolver: ContentResolver,
|
||||
network: Network?,
|
||||
networkProvider: () -> Network?,
|
||||
baseUrl: String,
|
||||
pairing: PairingPayload,
|
||||
deviceName: String,
|
||||
@@ -51,14 +152,14 @@ object DownloadClient {
|
||||
val expectedSha = requireNotNull(pairing.sha256)
|
||||
val partial = partialFile(context, pairing.session)
|
||||
partial.parentFile?.let { if (!it.exists() && !it.mkdirs()) error("无法创建接收缓存目录") }
|
||||
if (partial.length() > expectedSize) partial.delete()
|
||||
if (partial.length() > expectedSize) discardTransferState(partial)
|
||||
|
||||
// 落盘时缓存文件与目标文件同时存在,需要约 2 倍空间。
|
||||
// 不预检的话,这里会在下载 100% 之后才失败,用户看到的是「快结束时失败」。
|
||||
ensureSpaceForTransfer(partial, expectedSize)
|
||||
|
||||
repeat(VERIFY_ROUNDS) { round ->
|
||||
receiveUntilComplete(network, baseUrl, pairing, deviceName, partial,
|
||||
receiveUntilComplete(networkProvider, baseUrl, pairing, deviceName, partial,
|
||||
expectedSize, abortReason, onProgress)
|
||||
|
||||
onPhase("正在校验文件完整性…")
|
||||
@@ -72,13 +173,13 @@ object DownloadClient {
|
||||
// 这一步失败与网络无关,重下多少次都没用,直接如实报错
|
||||
throw SaveFailure("文件已完整收到,但保存到 Downloads/QFT 失败:${failureDetail(e)}", e)
|
||||
}
|
||||
partial.delete()
|
||||
discardTransferState(partial)
|
||||
Log.i(TAG, "completed size=$expectedSize")
|
||||
return result
|
||||
}
|
||||
|
||||
Log.w(TAG, "sha mismatch round=${round + 1}/$VERIFY_ROUNDS expected=$expectedSha actual=$actual")
|
||||
partial.delete()
|
||||
discardTransferState(partial)
|
||||
if (round + 1 >= VERIFY_ROUNDS) {
|
||||
error("文件校验失败:重新完整下载后 SHA-256 仍不匹配,请让电脑重新生成二维码")
|
||||
}
|
||||
@@ -88,8 +189,9 @@ object DownloadClient {
|
||||
}
|
||||
|
||||
/** 传输阶段:断点续传 + 有限重试。只有这一段的失败才算「下载失败」。 */
|
||||
private fun receiveUntilComplete(
|
||||
network: Network?,
|
||||
@Suppress("unused")
|
||||
private fun receiveSequentialCompatibility(
|
||||
networkProvider: () -> Network?,
|
||||
baseUrl: String,
|
||||
pairing: PairingPayload,
|
||||
deviceName: String,
|
||||
@@ -98,13 +200,19 @@ object DownloadClient {
|
||||
abortReason: () -> String?,
|
||||
onProgress: (received: Long, total: Long) -> Unit,
|
||||
) {
|
||||
if (expectedSize >= PARALLEL_MIN_FILE_SIZE && expectedSize > 0L) {
|
||||
receiveParallel(networkProvider, baseUrl, pairing, deviceName, partial,
|
||||
expectedSize, abortReason, onProgress)
|
||||
return
|
||||
}
|
||||
|
||||
var last: Exception? = null
|
||||
repeat(ATTEMPTS) { attempt ->
|
||||
repeat(SERIAL_ATTEMPTS) { attempt ->
|
||||
abortReason()?.let { throw IllegalStateException(it, last) }
|
||||
try {
|
||||
Log.i(TAG, "attempt=${attempt + 1}/$ATTEMPTS partial=${partial.length()}/$expectedSize endpoint=$baseUrl")
|
||||
Log.i(TAG, "serial attempt=${attempt + 1}/$SERIAL_ATTEMPTS partial=${partial.length()}/$expectedSize endpoint=$baseUrl")
|
||||
if (partial.length() < expectedSize) {
|
||||
receiveAttempt(network, baseUrl, pairing, deviceName, partial,
|
||||
receiveAttempt(networkProvider(), baseUrl, pairing, deviceName, partial,
|
||||
expectedSize, abortReason, onProgress)
|
||||
}
|
||||
if (partial.length() != expectedSize) {
|
||||
@@ -113,9 +221,9 @@ object DownloadClient {
|
||||
return
|
||||
} catch (e: Exception) {
|
||||
last = e
|
||||
Log.w(TAG, "attempt=${attempt + 1}/$ATTEMPTS failed partial=${partial.length()}/$expectedSize: ${failureDetail(e)}", e)
|
||||
Log.w(TAG, "serial attempt=${attempt + 1}/$SERIAL_ATTEMPTS failed partial=${partial.length()}/$expectedSize: ${failureDetail(e)}", e)
|
||||
abortReason()?.let { throw IllegalStateException(it, e) }
|
||||
if (attempt + 1 < ATTEMPTS) {
|
||||
if (attempt + 1 < SERIAL_ATTEMPTS) {
|
||||
try {
|
||||
Thread.sleep(250L * (attempt + 1))
|
||||
} catch (interrupted: InterruptedException) {
|
||||
@@ -127,11 +235,209 @@ object DownloadClient {
|
||||
}
|
||||
val progressed = partial.length()
|
||||
throw IllegalStateException(
|
||||
"从电脑下载失败,已重试 $ATTEMPTS 次(已收到 ${progressed}/$expectedSize 字节):${failureDetail(last)}",
|
||||
"从电脑下载失败(断点 ${progressed}/$expectedSize 字节):${failureDetail(last)}",
|
||||
last,
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* 大文件并行直传。每个 worker 请求一个有界 HTTP Range,并写入预分配文件的
|
||||
* 固定 offset。完成位图单独落盘,所以应用进程或某条 TCP 流中断后只补缺块,
|
||||
* 不会把 1 GB 文件从头再传一遍。
|
||||
*/
|
||||
private fun receiveParallel(
|
||||
networkProvider: () -> Network?,
|
||||
baseUrl: String,
|
||||
pairing: PairingPayload,
|
||||
deviceName: String,
|
||||
partial: File,
|
||||
expectedSize: Long,
|
||||
abortReason: () -> String?,
|
||||
onProgress: (received: Long, total: Long) -> Unit,
|
||||
) {
|
||||
val totalChunks = ((expectedSize + PARALLEL_CHUNK_SIZE - 1L) / PARALLEL_CHUNK_SIZE).toInt()
|
||||
val mapFile = completionMapFile(partial)
|
||||
val completed = loadCompletionMap(mapFile, totalChunks)
|
||||
|
||||
// A partial from the old sequential downloader has no bitmap. Preserve
|
||||
// only complete chunks; an incomplete tail is safely downloaded again.
|
||||
val oldLength = partial.length()
|
||||
if (!mapFile.exists() && oldLength in 1 until expectedSize) {
|
||||
for (index in completed.indices) {
|
||||
val endExclusive = minOf(expectedSize, (index + 1L) * PARALLEL_CHUNK_SIZE)
|
||||
if (endExclusive <= oldLength) completed[index] = true
|
||||
}
|
||||
}
|
||||
RandomAccessFile(partial, "rw").use { it.setLength(expectedSize) }
|
||||
persistCompletionMap(mapFile, completed)
|
||||
|
||||
val initialBytes = completed.indices.sumOf { index ->
|
||||
if (completed[index]) chunkLength(index, expectedSize) else 0L
|
||||
}
|
||||
val received = AtomicLong(initialBytes)
|
||||
val lastReport = AtomicLong(0L)
|
||||
val next = AtomicInteger(0)
|
||||
onProgress(initialBytes, expectedSize)
|
||||
|
||||
val workers = totalChunks.coerceAtMost(
|
||||
Runtime.getRuntime().availableProcessors().coerceIn(2, MAX_WORKERS)
|
||||
).coerceAtLeast(1)
|
||||
Log.i(TAG, "parallel download chunks=$totalChunks workers=$workers completed=$initialBytes/$expectedSize")
|
||||
val pool = Executors.newFixedThreadPool(workers)
|
||||
val futures = (0 until workers).map {
|
||||
pool.submit {
|
||||
RandomAccessFile(partial, "rw").use { output ->
|
||||
while (!Thread.currentThread().isInterrupted) {
|
||||
abortReason()?.let { error(it) }
|
||||
val index = next.getAndIncrement()
|
||||
if (index >= totalChunks) break
|
||||
if (completed[index]) continue
|
||||
val start = index.toLong() * PARALLEL_CHUNK_SIZE
|
||||
val length = chunkLength(index, expectedSize)
|
||||
receiveRangeWithRetry(
|
||||
networkProvider, baseUrl, pairing, deviceName,
|
||||
output, index, start, length, expectedSize, abortReason,
|
||||
)
|
||||
// Data reaches stable storage before its completion bit.
|
||||
// A crash can therefore only cause a harmless re-download.
|
||||
output.fd.sync()
|
||||
synchronized(completed) {
|
||||
completed[index] = true
|
||||
persistCompletionMap(mapFile, completed)
|
||||
}
|
||||
val done = received.addAndGet(length)
|
||||
val now = android.os.SystemClock.elapsedRealtime()
|
||||
val previous = lastReport.get()
|
||||
if (now - previous >= 80L && lastReport.compareAndSet(previous, now)) {
|
||||
onProgress(done.coerceAtMost(expectedSize), expectedSize)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
val failures = mutableListOf<Throwable>()
|
||||
try {
|
||||
futures.forEach { future ->
|
||||
try { future.get() } catch (e: Exception) { failures += (e.cause ?: e) }
|
||||
}
|
||||
} finally {
|
||||
pool.shutdownNow()
|
||||
}
|
||||
if (failures.isNotEmpty()) throw IllegalStateException(
|
||||
"并行直传中断,已完成 ${received.get()}/$expectedSize 字节;下次将只补传缺块:${failureDetail(failures.first())}",
|
||||
failures.first(),
|
||||
)
|
||||
if (completed.any { !it }) error("并行直传结束但仍有缺块")
|
||||
onProgress(expectedSize, expectedSize)
|
||||
}
|
||||
|
||||
private fun receiveRangeWithRetry(
|
||||
networkProvider: () -> Network?,
|
||||
baseUrl: String,
|
||||
pairing: PairingPayload,
|
||||
deviceName: String,
|
||||
output: RandomAccessFile,
|
||||
index: Int,
|
||||
start: Long,
|
||||
length: Long,
|
||||
expectedSize: Long,
|
||||
abortReason: () -> String?,
|
||||
) {
|
||||
var last: Exception? = null
|
||||
repeat(RANGE_ATTEMPTS) { attempt ->
|
||||
abortReason()?.let { error(it) }
|
||||
try {
|
||||
receiveRange(
|
||||
networkProvider(), baseUrl, pairing, deviceName, output,
|
||||
start, length, expectedSize, abortReason,
|
||||
)
|
||||
return
|
||||
} catch (e: Exception) {
|
||||
last = e
|
||||
Log.w(TAG, "range=$index attempt=${attempt + 1}/$RANGE_ATTEMPTS failed: ${failureDetail(e)}")
|
||||
if (attempt + 1 < RANGE_ATTEMPTS) {
|
||||
try { Thread.sleep((200L shl attempt).coerceAtMost(3_000L)) }
|
||||
catch (_: InterruptedException) {
|
||||
Thread.currentThread().interrupt()
|
||||
throw e
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
throw IllegalStateException("区段 $index 传输失败:${failureDetail(last)}", last)
|
||||
}
|
||||
|
||||
private fun receiveRange(
|
||||
network: Network?,
|
||||
baseUrl: String,
|
||||
pairing: PairingPayload,
|
||||
deviceName: String,
|
||||
output: RandomAccessFile,
|
||||
start: Long,
|
||||
length: Long,
|
||||
expectedSize: Long,
|
||||
abortReason: () -> String?,
|
||||
) {
|
||||
val end = start + length - 1L
|
||||
val conn = open(network, URL("$baseUrl/qft/download"))
|
||||
try {
|
||||
conn.requestMethod = "GET"
|
||||
conn.connectTimeout = 8_000
|
||||
conn.readTimeout = 90_000
|
||||
conn.useCaches = false
|
||||
conn.setRequestProperty("Connection", "keep-alive")
|
||||
conn.setRequestProperty("X-QFT-Token", pairing.session)
|
||||
conn.setRequestProperty("X-QFT-Device", Base64Url.encode(deviceName.toByteArray(Charsets.UTF_8)))
|
||||
conn.setRequestProperty("Range", "bytes=$start-$end")
|
||||
val code = conn.responseCode
|
||||
if (code != HttpURLConnection.HTTP_PARTIAL) {
|
||||
val message = try { conn.errorStream?.bufferedReader()?.use { it.readText().take(300) } } catch (_: Exception) { null }
|
||||
error("电脑端不支持并行 Range(HTTP $code)${message?.let { ": $it" } ?: ""}")
|
||||
}
|
||||
val contentRange = conn.getHeaderField("Content-Range").orEmpty()
|
||||
if (contentRange != "bytes $start-$end/$expectedSize") {
|
||||
error("下载服务返回了无效区段:$contentRange")
|
||||
}
|
||||
if (conn.contentLengthLong >= 0L && conn.contentLengthLong != length) {
|
||||
error("区段长度不匹配:${conn.contentLengthLong} != $length")
|
||||
}
|
||||
output.seek(start)
|
||||
var remaining = length
|
||||
conn.inputStream.use { input ->
|
||||
val buffer = ByteArray(BUFFER_SIZE)
|
||||
while (remaining > 0L) {
|
||||
abortReason()?.let { error(it) }
|
||||
val n = input.read(buffer, 0, minOf(buffer.size.toLong(), remaining).toInt())
|
||||
if (n < 0) error("区段提前结束:还缺 $remaining 字节")
|
||||
if (n == 0) continue
|
||||
output.write(buffer, 0, n)
|
||||
remaining -= n.toLong()
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
conn.disconnect()
|
||||
}
|
||||
}
|
||||
|
||||
private fun chunkLength(index: Int, total: Long): Long =
|
||||
minOf(PARALLEL_CHUNK_SIZE, total - index.toLong() * PARALLEL_CHUNK_SIZE)
|
||||
|
||||
private fun completionMapFile(partial: File): File = File(partial.parentFile, partial.name + ".map")
|
||||
|
||||
private fun loadCompletionMap(file: File, count: Int): BooleanArray {
|
||||
val result = BooleanArray(count)
|
||||
val bytes = try { if (file.exists()) file.readBytes() else ByteArray(0) } catch (_: Exception) { ByteArray(0) }
|
||||
if (bytes.size == count) bytes.indices.forEach { result[it] = bytes[it].toInt() == 1 }
|
||||
return result
|
||||
}
|
||||
|
||||
private fun persistCompletionMap(file: File, completed: BooleanArray) {
|
||||
FileOutputStream(file, false).use { output ->
|
||||
output.write(ByteArray(completed.size) { if (completed[it]) 1 else 0 })
|
||||
output.fd.sync()
|
||||
}
|
||||
}
|
||||
|
||||
/** 传输 + 落盘阶段合计需要的可用空间。 */
|
||||
private fun ensureSpaceForTransfer(partial: File, expectedSize: Long) {
|
||||
val root = partial.parentFile ?: return
|
||||
@@ -164,13 +470,9 @@ object DownloadClient {
|
||||
try {
|
||||
conn.requestMethod = "GET"
|
||||
conn.connectTimeout = 5_000
|
||||
// A QFT LAN transfer should start immediately. The old 120-second
|
||||
// read timeout let Huawei tear down a local-only Wi-Fi request
|
||||
// before a retry could occur. A short timeout safely resumes from
|
||||
// the persisted Range offset and finishes all retries sooner.
|
||||
conn.readTimeout = 12_000
|
||||
conn.readTimeout = 60_000
|
||||
conn.useCaches = false
|
||||
conn.setRequestProperty("Connection", "close")
|
||||
conn.setRequestProperty("Connection", "keep-alive")
|
||||
conn.setRequestProperty("X-QFT-Token", pairing.session)
|
||||
conn.setRequestProperty("X-QFT-Device", Base64Url.encode(deviceName.toByteArray(Charsets.UTF_8)))
|
||||
if (requestedOffset > 0L) conn.setRequestProperty("Range", "bytes=$requestedOffset-")
|
||||
@@ -208,8 +510,7 @@ object DownloadClient {
|
||||
FileOutputStream(partial, offset > 0L).use { output ->
|
||||
val buffer = ByteArray(BUFFER_SIZE)
|
||||
while (true) {
|
||||
// 网络已断开时立刻收手:否则会在 readTimeout 上白等 12 秒,
|
||||
// 再乘以 5 次重试,用户等一分钟才看到错误。
|
||||
// 用户明确返回首页时才中止;普通 TCP 波动由 Range 续传恢复。
|
||||
abortReason()?.let { error(it) }
|
||||
val n = input.read(buffer)
|
||||
if (n < 0) break
|
||||
@@ -234,6 +535,185 @@ object DownloadClient {
|
||||
}
|
||||
|
||||
/** 校验也要报进度:大文件读一整遍是好几秒,静默的话看起来就是卡在 100%。 */
|
||||
private fun receiveUntilComplete(
|
||||
networkProvider: () -> Network?,
|
||||
baseUrl: String,
|
||||
pairing: PairingPayload,
|
||||
deviceName: String,
|
||||
partial: File,
|
||||
expectedSize: Long,
|
||||
abortReason: () -> String?,
|
||||
onProgress: (received: Long, total: Long) -> Unit,
|
||||
) {
|
||||
val ledger = ChunkLedger.open(partial, expectedSize, desiredRangeChunkSize(expectedSize))
|
||||
val initial = ledger.bytesComplete()
|
||||
onProgress(initial, expectedSize)
|
||||
if (ledger.allComplete()) return
|
||||
|
||||
val workers = ledger.totalChunks.coerceAtMost(RANGE_WORKERS).coerceAtLeast(1)
|
||||
Log.i(TAG, "parallel start: chunks=${ledger.totalChunks}, workers=$workers, completed=$initial/$expectedSize")
|
||||
val pool = Executors.newFixedThreadPool(workers)
|
||||
val next = AtomicInteger(0)
|
||||
val futures = (0 until workers).map {
|
||||
pool.submit {
|
||||
while (!Thread.currentThread().isInterrupted) {
|
||||
abortReason()?.let { error(it) }
|
||||
val index = next.getAndIncrement()
|
||||
if (index >= ledger.totalChunks) break
|
||||
if (ledger.isComplete(index)) continue
|
||||
receiveRangeWithRetry(
|
||||
networkProvider,
|
||||
baseUrl,
|
||||
pairing,
|
||||
deviceName,
|
||||
partial,
|
||||
expectedSize,
|
||||
ledger,
|
||||
index,
|
||||
abortReason,
|
||||
)
|
||||
onProgress(ledger.bytesComplete(), expectedSize)
|
||||
}
|
||||
}
|
||||
}
|
||||
try {
|
||||
futures.forEach { future -> future.get() }
|
||||
} catch (e: Exception) {
|
||||
futures.forEach { it.cancel(true) }
|
||||
throw (e.cause ?: e)
|
||||
} finally {
|
||||
pool.shutdownNow()
|
||||
}
|
||||
if (!ledger.allComplete()) {
|
||||
error("并行下载未完成:${ledger.bytesComplete()}/$expectedSize")
|
||||
}
|
||||
Log.i(TAG, "parallel complete: chunks=${ledger.totalChunks}, bytes=$expectedSize")
|
||||
}
|
||||
|
||||
private fun receiveRangeWithRetry(
|
||||
networkProvider: () -> Network?,
|
||||
baseUrl: String,
|
||||
pairing: PairingPayload,
|
||||
deviceName: String,
|
||||
partial: File,
|
||||
expectedSize: Long,
|
||||
ledger: ChunkLedger,
|
||||
index: Int,
|
||||
abortReason: () -> String?,
|
||||
) {
|
||||
var last: Exception? = null
|
||||
repeat(RANGE_ATTEMPTS) { attempt ->
|
||||
abortReason()?.let { throw IllegalStateException(it, last) }
|
||||
try {
|
||||
receiveRange(
|
||||
networkProvider(),
|
||||
baseUrl,
|
||||
pairing,
|
||||
deviceName,
|
||||
partial,
|
||||
expectedSize,
|
||||
ledger,
|
||||
index,
|
||||
)
|
||||
ledger.markComplete(index)
|
||||
return
|
||||
} catch (e: Exception) {
|
||||
last = e
|
||||
Log.w(
|
||||
TAG,
|
||||
"range=$index/${ledger.totalChunks} attempt=${attempt + 1}/$RANGE_ATTEMPTS failed: ${failureDetail(e)}",
|
||||
e,
|
||||
)
|
||||
if (attempt + 1 < RANGE_ATTEMPTS) {
|
||||
try {
|
||||
Thread.sleep(180L * (attempt + 1))
|
||||
} catch (interrupted: InterruptedException) {
|
||||
Thread.currentThread().interrupt()
|
||||
throw e
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
throw IllegalStateException(
|
||||
"分块 $index 下载失败,已重试 $RANGE_ATTEMPTS 次:${failureDetail(last)}",
|
||||
last,
|
||||
)
|
||||
}
|
||||
|
||||
private fun receiveRange(
|
||||
network: Network?,
|
||||
baseUrl: String,
|
||||
pairing: PairingPayload,
|
||||
deviceName: String,
|
||||
partial: File,
|
||||
expectedSize: Long,
|
||||
ledger: ChunkLedger,
|
||||
index: Int,
|
||||
) {
|
||||
val offset = ledger.chunkOffset(index)
|
||||
val length = ledger.chunkLength(index)
|
||||
val end = offset + length - 1L
|
||||
val conn = open(network, URL("$baseUrl/qft/download"))
|
||||
try {
|
||||
conn.requestMethod = "GET"
|
||||
conn.connectTimeout = 5_000
|
||||
conn.readTimeout = 20_000
|
||||
conn.useCaches = false
|
||||
conn.setRequestProperty("Connection", "close")
|
||||
conn.setRequestProperty("X-QFT-Token", pairing.session)
|
||||
conn.setRequestProperty("X-QFT-Device", Base64Url.encode(deviceName.toByteArray(Charsets.UTF_8)))
|
||||
conn.setRequestProperty("Range", "bytes=$offset-$end")
|
||||
|
||||
val code = conn.responseCode
|
||||
if (code != HttpURLConnection.HTTP_PARTIAL) {
|
||||
val message = try { conn.errorStream?.bufferedReader()?.use { it.readText().take(300) } } catch (_: Exception) { null }
|
||||
error("电脑下载服务未返回并行 Range(HTTP $code)${message?.let { ": $it" } ?: ""}")
|
||||
}
|
||||
val expectedRange = "bytes $offset-$end/$expectedSize"
|
||||
if (conn.getHeaderField("Content-Range") != expectedRange) {
|
||||
error("下载服务返回了无效范围:${conn.getHeaderField("Content-Range")}")
|
||||
}
|
||||
if (conn.contentLengthLong >= 0L && conn.contentLengthLong != length) {
|
||||
error("分块 $index 长度不匹配:${conn.contentLengthLong} != $length")
|
||||
}
|
||||
|
||||
var received = 0L
|
||||
conn.inputStream.use { input ->
|
||||
RandomAccessFile(partial, "rw").use { output ->
|
||||
output.channel.use { channel ->
|
||||
channel.position(offset)
|
||||
val buffer = ByteArray(BUFFER_SIZE)
|
||||
while (received < length) {
|
||||
val n = input.read(buffer, 0, minOf(buffer.size.toLong(), length - received).toInt())
|
||||
if (n < 0) break
|
||||
if (n == 0) continue
|
||||
val bytes = ByteBuffer.wrap(buffer, 0, n)
|
||||
while (bytes.hasRemaining()) channel.write(bytes)
|
||||
received += n.toLong()
|
||||
}
|
||||
channel.force(false)
|
||||
}
|
||||
}
|
||||
}
|
||||
if (received != length) error("分块 $index 提前结束:$received/$length")
|
||||
Log.d(TAG, "range=$index/${ledger.totalChunks} complete bytes=$length")
|
||||
} finally {
|
||||
conn.disconnect()
|
||||
}
|
||||
}
|
||||
|
||||
private fun desiredRangeChunkSize(fileSize: Long): Long {
|
||||
if (fileSize <= 0L) return MIN_RANGE_CHUNK
|
||||
return ((fileSize + RANGE_WORKERS - 1L) / RANGE_WORKERS)
|
||||
.coerceIn(MIN_RANGE_CHUNK, MAX_RANGE_CHUNK)
|
||||
}
|
||||
|
||||
private fun discardTransferState(partial: File) {
|
||||
partial.delete()
|
||||
File("${partial.path}.map").delete()
|
||||
File("${partial.path}.map.tmp").delete()
|
||||
}
|
||||
|
||||
private fun sha256(file: File, onProgress: (Long, Long) -> Unit): String {
|
||||
val digest = MessageDigest.getInstance("SHA-256")
|
||||
val total = file.length()
|
||||
|
||||
@@ -76,7 +76,7 @@ class MainActivity : ComponentActivity() {
|
||||
private lateinit var progress: ProgressBar
|
||||
|
||||
private var pendingPair: PairingPayload? = null
|
||||
private var connectedNetwork: Network? = null
|
||||
@Volatile private var connectedNetwork: Network? = null
|
||||
private var connectedBaseUrl: String? = null
|
||||
private val selectedFiles = mutableListOf<SelectedFile>()
|
||||
private var managingFilesForPair: PairingPayload? = null
|
||||
@@ -146,6 +146,7 @@ class MainActivity : ComponentActivity() {
|
||||
}
|
||||
|
||||
private fun showHome(message: String? = null) {
|
||||
transferAbortReason = "已返回首页,传输已停止"
|
||||
pairConnectionAttempt++
|
||||
stopCamera()
|
||||
scannerMode = ScannerMode.NONE
|
||||
@@ -193,7 +194,7 @@ class MainActivity : ComponentActivity() {
|
||||
) { showReceivedFiles() })
|
||||
root.addView(space(22))
|
||||
root.addView(text("本机设备:$receiverDeviceLabel", 13f, MUTED))
|
||||
root.addView(text("QFT v0.4.6 · Android 7+ 到最新", 12f, MUTED))
|
||||
root.addView(text("QFT v0.4.7 · Android 7+ 到最新", 12f, MUTED))
|
||||
setContentView(ScrollView(this).apply { setBackgroundColor(BG); addView(root) })
|
||||
}
|
||||
|
||||
@@ -602,6 +603,7 @@ class MainActivity : ComponentActivity() {
|
||||
|
||||
private fun connectPair(pair: PairingPayload) {
|
||||
val attempt = ++pairConnectionAttempt
|
||||
transferAbortReason = null
|
||||
showConnecting(pair, pair.wifi?.let { "正在请求连接 ${it.ssid}…" } ?: "正在使用当前局域网探测电脑…")
|
||||
wifiConnector.connect(
|
||||
pairing = pair,
|
||||
@@ -611,6 +613,10 @@ class MainActivity : ComponentActivity() {
|
||||
onAvailable = available@{ network ->
|
||||
if (attempt != pairConnectionAttempt) return@available
|
||||
connectedNetwork = network
|
||||
// A retained WifiNetworkSpecifier request may deliver a fresh
|
||||
// Network after a brief radio fluctuation. Do not restart the
|
||||
// page or transfer; chunk retries will use this new handle.
|
||||
if (connectedBaseUrl != null) return@available
|
||||
transferExecutor.execute {
|
||||
if (attempt != pairConnectionAttempt) return@execute
|
||||
runOnUiThread { updateConnectingStatus("网络路由已就绪 · 正在 UDP 快速发现电脑…") }
|
||||
@@ -657,14 +663,10 @@ class MainActivity : ComponentActivity() {
|
||||
},
|
||||
onUnavailable = { message -> runOnUiThread {
|
||||
if (attempt != pairConnectionAttempt) return@runOnUiThread
|
||||
// Huawei can report onLost while a bound local-only HTTP
|
||||
// socket is unwinding. Let DownloadClient surface its precise
|
||||
// HTTP/timeout cause instead of replacing it with this generic
|
||||
// message mid-retry.
|
||||
// onLost is recovered inside WifiConnector. onUnavailable is
|
||||
// terminal (system/user rejected the retained request), so it
|
||||
// is the only network callback that aborts an active transfer.
|
||||
if (pair.direction == TransferDirection.DOWNLOAD_TO_PHONE && downloadRunning) {
|
||||
// 让下载线程立刻收手并如实报告断网,而不是继续跑完
|
||||
// 5 次「重试 → 12 秒超时」,最后给出一个与真因无关的
|
||||
// 「下载失败,已重试 N 次」。
|
||||
transferAbortReason = message
|
||||
downloadStatusText?.apply {
|
||||
text = "QFT 本地网络已断开,正在结束当前下载请求…"
|
||||
@@ -705,8 +707,8 @@ class MainActivity : ComponentActivity() {
|
||||
private fun showPairError(pair: PairingPayload?, message: String) {
|
||||
// Do not unregister here: Android may still be displaying its
|
||||
// Wi-Fi-selection sheet, and unregistering at that moment produces
|
||||
// "the app cancelled the device selection request". The next attempt
|
||||
// (or returning home) releases the previous request safely.
|
||||
// "the app cancelled the device selection request". A retry reuses
|
||||
// this retained request; returning home is what explicitly releases it.
|
||||
pairConnectionAttempt++
|
||||
connectedNetwork = null
|
||||
connectedBaseUrl = null
|
||||
@@ -718,7 +720,7 @@ class MainActivity : ComponentActivity() {
|
||||
root.addView(button("重试连接").apply { setOnClickListener { ensureWifiPermissionThenConnect(pair) } })
|
||||
root.addView(space(10))
|
||||
}
|
||||
root.addView(button("重新扫码").apply { setOnClickListener { requestScanner(ScannerMode.PAIR) } })
|
||||
root.addView(button("返回首页重新扫码").apply { setOnClickListener { showHome() } })
|
||||
root.addView(space(10))
|
||||
root.addView(button("返回首页").apply { setOnClickListener { showHome() } })
|
||||
setContentView(ScrollView(this).apply { setBackgroundColor(BG); addView(root) })
|
||||
@@ -732,7 +734,7 @@ class MainActivity : ComponentActivity() {
|
||||
root.addView(card().apply {
|
||||
addView(text("连接状态", 14f, MUTED))
|
||||
addView(text("● 本地直连已就绪", 17f, SUCCESS, true), matchWrap(top = 8))
|
||||
addView(text(if (pair.version >= 2) "Parallel v2 · 自适应最高 8 路并发 · 4/8/16 MiB 自适应分块" else "兼容单流模式", 13f, ACCENT), matchWrap(top = 5))
|
||||
addView(text(if (pair.version >= 2) "Parallel v2 · 目标 8 路并发 · 64 KiB–16 MiB 自适应分块" else "兼容单流模式", 13f, ACCENT), matchWrap(top = 5))
|
||||
addView(text("目标:$baseUrl", 12f, MUTED), matchWrap(top = 6))
|
||||
pair.wifi?.let { addView(text("QFT 临时网络:${it.ssid}", 12f, MUTED), matchWrap(top = 4)) }
|
||||
})
|
||||
@@ -776,7 +778,13 @@ class MainActivity : ComponentActivity() {
|
||||
root.addView(space(18))
|
||||
root.addView(card().apply {
|
||||
addView(text("扫码配置已完成", 17f, SUCCESS, true))
|
||||
addView(text("电脑已自动确认会话,正在通过本地网络直接传输。", 14f, MUTED), matchWrap(top = 8))
|
||||
addView(text(
|
||||
if (total >= 32L * 1024L * 1024L)
|
||||
"连接将保持到返回首页;正在通过本地网络进行最高 8 路并行直传。"
|
||||
else
|
||||
"连接将保持到返回首页;正在通过本地网络直接传输。",
|
||||
14f, MUTED,
|
||||
), matchWrap(top = 8))
|
||||
addView(text(fileName, 15f, Color.WHITE), matchWrap(top = 12))
|
||||
addView(text(humanBytes(total), 13f, MUTED), matchWrap(top = 4))
|
||||
})
|
||||
@@ -801,7 +809,7 @@ class MainActivity : ComponentActivity() {
|
||||
val saved = DownloadClient.download(
|
||||
context = this@MainActivity,
|
||||
resolver = contentResolver,
|
||||
network = connectedNetwork,
|
||||
networkProvider = { connectedNetwork },
|
||||
baseUrl = baseUrl,
|
||||
pairing = pair,
|
||||
deviceName = receiverDeviceLabel,
|
||||
@@ -980,11 +988,12 @@ class MainActivity : ComponentActivity() {
|
||||
}
|
||||
UploadClient.upload(
|
||||
resolver = contentResolver,
|
||||
network = connectedNetwork,
|
||||
networkProvider = { connectedNetwork },
|
||||
baseUrl = baseUrl,
|
||||
pairing = pair,
|
||||
deviceName = receiverDeviceLabel,
|
||||
file = file,
|
||||
abortReason = { transferAbortReason },
|
||||
) { sent, total ->
|
||||
runOnUiThread {
|
||||
val p = if (total == 0L) 1000 else ((sent.toDouble() / total) * 1000).toInt().coerceIn(0, 1000)
|
||||
|
||||
@@ -20,29 +20,27 @@ import java.util.concurrent.Executors
|
||||
import java.util.concurrent.TimeUnit
|
||||
import java.util.concurrent.atomic.AtomicInteger
|
||||
import java.util.concurrent.atomic.AtomicLong
|
||||
import java.util.UUID
|
||||
|
||||
|
||||
data class SelectedFile(
|
||||
val uri: Uri,
|
||||
val name: String,
|
||||
val size: Long,
|
||||
val uploadKey: String = UUID.randomUUID().toString(),
|
||||
)
|
||||
|
||||
object UploadClient {
|
||||
private const val TAG = "QftUpload"
|
||||
private const val DISCOVERY_PORT = 39392
|
||||
private const val CHUNK_SMALL = 4L * 1024L * 1024L
|
||||
private const val CHUNK_DEFAULT = 8L * 1024L * 1024L
|
||||
private const val CHUNK_LARGE = 16L * 1024L * 1024L
|
||||
private const val MAX_WORKERS = 8
|
||||
private const val MIN_PARALLEL_CHUNK = 64L * 1024L
|
||||
private const val MAX_PARALLEL_CHUNK = 16L * 1024L * 1024L
|
||||
private const val STREAM_BUFFER = 1024 * 1024
|
||||
// A single request is materially more reliable for small files on Wi-Fi
|
||||
// Direct, and a 4 MiB parallel chunk gives no throughput benefit there.
|
||||
private const val PARALLEL_MIN_FILE_SIZE = 32L * 1024L * 1024L
|
||||
// QFT Direct can briefly reset a TCP flow while the Android network route
|
||||
// settles. Chunk PUTs and the init/finish control calls are safe to retry;
|
||||
// the Windows receiver treats a repeated chunk as an idempotent success.
|
||||
private const val LOCAL_REQUEST_ATTEMPTS = 3
|
||||
private const val LOCAL_REQUEST_ATTEMPTS = 8
|
||||
|
||||
fun describeFile(resolver: ContentResolver, uri: Uri): SelectedFile? {
|
||||
var name = "qft-upload.bin"
|
||||
@@ -220,16 +218,17 @@ object UploadClient {
|
||||
|
||||
fun upload(
|
||||
resolver: ContentResolver,
|
||||
network: Network?,
|
||||
networkProvider: () -> Network?,
|
||||
baseUrl: String,
|
||||
pairing: PairingPayload,
|
||||
deviceName: String,
|
||||
file: SelectedFile,
|
||||
abortReason: () -> String? = { null },
|
||||
onProgress: (sent: Long, total: Long) -> Unit,
|
||||
) {
|
||||
if (pairing.version >= 2 && file.size >= PARALLEL_MIN_FILE_SIZE && isSeekable(resolver, file)) {
|
||||
if (pairing.version >= 2 && isSeekable(resolver, file)) {
|
||||
try {
|
||||
uploadParallel(resolver, network, baseUrl, pairing, deviceName, file, onProgress)
|
||||
uploadParallel(resolver, networkProvider, baseUrl, pairing, deviceName, file, abortReason, onProgress)
|
||||
return
|
||||
} catch (e: Exception) {
|
||||
// Never mask a transient v2 failure by immediately switching to a
|
||||
@@ -241,15 +240,21 @@ object UploadClient {
|
||||
if (!message.contains("HTTP 404") && !message.contains("HTTP 501")) throw e
|
||||
}
|
||||
}
|
||||
Log.i(TAG, "using single-stream upload: size=${file.size}, endpoint=$baseUrl")
|
||||
uploadLegacy(resolver, network, baseUrl, pairing, deviceName, file, onProgress)
|
||||
Log.i(TAG, "using compatibility single-stream upload: size=${file.size}, endpoint=$baseUrl")
|
||||
uploadLegacy(resolver, networkProvider(), baseUrl, pairing, deviceName, file, abortReason, onProgress)
|
||||
}
|
||||
|
||||
private data class InitReply(val uploadId: String, val chunkSize: Long, val totalChunks: Int)
|
||||
private data class InitReply(
|
||||
val uploadId: String,
|
||||
val chunkSize: Long,
|
||||
val totalChunks: Int,
|
||||
val pendingChunks: IntArray,
|
||||
)
|
||||
|
||||
private fun <T> retryLocalRequest(label: String, block: () -> T): T {
|
||||
private fun <T> retryLocalRequest(label: String, abortReason: () -> String?, block: () -> T): T {
|
||||
var last: Throwable? = null
|
||||
repeat(LOCAL_REQUEST_ATTEMPTS) { attempt ->
|
||||
abortReason()?.let { throw IllegalStateException(it, last) }
|
||||
try {
|
||||
return block()
|
||||
} catch (e: Throwable) {
|
||||
@@ -260,7 +265,7 @@ object UploadClient {
|
||||
e,
|
||||
)
|
||||
if (attempt + 1 < LOCAL_REQUEST_ATTEMPTS) {
|
||||
try { Thread.sleep(120L * (attempt + 1)) } catch (_: InterruptedException) {
|
||||
try { Thread.sleep((250L shl attempt).coerceAtMost(3_000L)) } catch (_: InterruptedException) {
|
||||
Thread.currentThread().interrupt()
|
||||
throw e
|
||||
}
|
||||
@@ -288,27 +293,37 @@ object UploadClient {
|
||||
|
||||
private fun uploadParallel(
|
||||
resolver: ContentResolver,
|
||||
network: Network?,
|
||||
networkProvider: () -> Network?,
|
||||
baseUrl: String,
|
||||
pairing: PairingPayload,
|
||||
deviceName: String,
|
||||
file: SelectedFile,
|
||||
abortReason: () -> String?,
|
||||
onProgress: (sent: Long, total: Long) -> Unit,
|
||||
) {
|
||||
Log.i(TAG, "parallel init: size=${file.size}, endpoint=$baseUrl")
|
||||
val init = initUpload(network, baseUrl, pairing, deviceName, file)
|
||||
Log.i(TAG, "parallel init complete: chunks=${init.totalChunks}, chunkSize=${init.chunkSize}")
|
||||
val init = initUpload(networkProvider, baseUrl, pairing, deviceName, file, file.uploadKey, abortReason)
|
||||
Log.i(TAG, "parallel init complete: chunks=${init.totalChunks}, pending=${init.pendingChunks.size}, chunkSize=${init.chunkSize}")
|
||||
if (init.totalChunks == 0) {
|
||||
finishUpload(network, baseUrl, pairing, deviceName, init.uploadId)
|
||||
finishUpload(networkProvider, baseUrl, pairing, deviceName, init.uploadId, abortReason)
|
||||
onProgress(0, 0)
|
||||
return
|
||||
}
|
||||
|
||||
val cpuWorkers = Runtime.getRuntime().availableProcessors().coerceIn(2, MAX_WORKERS)
|
||||
val workerCount = init.totalChunks.coerceAtMost(cpuWorkers).coerceAtLeast(1)
|
||||
// Upload workers are network/disk bound, not CPU bound. Large files
|
||||
// therefore use all eight lanes even on a 4-core phone.
|
||||
if (init.pendingChunks.isEmpty()) {
|
||||
finishUpload(networkProvider, baseUrl, pairing, deviceName, init.uploadId, abortReason)
|
||||
onProgress(file.size, file.size)
|
||||
return
|
||||
}
|
||||
val workerCount = init.pendingChunks.size.coerceAtMost(MAX_WORKERS).coerceAtLeast(1)
|
||||
val pool = Executors.newFixedThreadPool(workerCount)
|
||||
val next = AtomicInteger(0)
|
||||
val sent = AtomicLong(0)
|
||||
val pendingBytes = init.pendingChunks.sumOf { index ->
|
||||
minOf(init.chunkSize, file.size - index.toLong() * init.chunkSize)
|
||||
}
|
||||
val sent = AtomicLong((file.size - pendingBytes).coerceAtLeast(0L))
|
||||
val lastReport = AtomicLong(0)
|
||||
val failures = mutableListOf<Throwable>()
|
||||
val futures = (0 until workerCount).map {
|
||||
@@ -318,13 +333,15 @@ object UploadClient {
|
||||
val channel = input.channel
|
||||
val buffer = ByteBuffer.allocate(STREAM_BUFFER)
|
||||
while (!Thread.currentThread().isInterrupted) {
|
||||
val index = next.getAndIncrement()
|
||||
if (index >= init.totalChunks) break
|
||||
abortReason()?.let { error(it) }
|
||||
val pendingIndex = next.getAndIncrement()
|
||||
if (pendingIndex >= init.pendingChunks.size) break
|
||||
val index = init.pendingChunks[pendingIndex]
|
||||
val offset = index.toLong() * init.chunkSize
|
||||
val length = minOf(init.chunkSize, file.size - offset)
|
||||
sendChunk(
|
||||
network, baseUrl, pairing, deviceName,
|
||||
init.uploadId, index, channel, offset, length, buffer,
|
||||
networkProvider, baseUrl, pairing, deviceName,
|
||||
init.uploadId, index, channel, offset, length, buffer, abortReason,
|
||||
)
|
||||
val totalSent = sent.addAndGet(length)
|
||||
val now = android.os.SystemClock.elapsedRealtime()
|
||||
@@ -345,22 +362,25 @@ object UploadClient {
|
||||
pool.shutdownNow()
|
||||
}
|
||||
if (failures.isNotEmpty()) throw failures.first()
|
||||
finishUpload(network, baseUrl, pairing, deviceName, init.uploadId)
|
||||
finishUpload(networkProvider, baseUrl, pairing, deviceName, init.uploadId, abortReason)
|
||||
onProgress(file.size, file.size)
|
||||
}
|
||||
|
||||
|
||||
private fun desiredChunkSize(fileSize: Long): Long = when {
|
||||
fileSize < 32L * 1024L * 1024L -> CHUNK_SMALL
|
||||
fileSize >= 512L * 1024L * 1024L -> CHUNK_LARGE
|
||||
else -> CHUNK_DEFAULT
|
||||
private fun desiredChunkSize(fileSize: Long): Long {
|
||||
if (fileSize <= 0L) return MIN_PARALLEL_CHUNK
|
||||
// Aim for eight independent HTTP flows on every transferable file.
|
||||
// The floor keeps QR Direct overhead reasonable for tiny files, while
|
||||
// the ceiling protects memory and TCP fairness on very large files.
|
||||
return ((fileSize + MAX_WORKERS - 1) / MAX_WORKERS)
|
||||
.coerceIn(MIN_PARALLEL_CHUNK, MAX_PARALLEL_CHUNK)
|
||||
}
|
||||
|
||||
private fun initUpload(
|
||||
network: Network?, baseUrl: String, pairing: PairingPayload,
|
||||
deviceName: String, file: SelectedFile,
|
||||
): InitReply = retryLocalRequest("本地上传初始化失败") {
|
||||
val conn = open(network, URL("$baseUrl/qft/upload/init"))
|
||||
networkProvider: () -> Network?, baseUrl: String, pairing: PairingPayload,
|
||||
deviceName: String, file: SelectedFile, requestKey: String, abortReason: () -> String?,
|
||||
): InitReply = retryLocalRequest("本地上传初始化失败", abortReason) {
|
||||
val conn = open(networkProvider(), URL("$baseUrl/qft/upload/init"))
|
||||
try {
|
||||
conn.requestMethod = "POST"
|
||||
conn.doOutput = true
|
||||
@@ -371,15 +391,27 @@ object UploadClient {
|
||||
conn.setRequestProperty("X-QFT-Filename", b64(file.name))
|
||||
conn.setRequestProperty("X-QFT-Size", file.size.toString())
|
||||
conn.setRequestProperty("X-QFT-Chunk-Size", desiredChunkSize(file.size).toString())
|
||||
conn.setRequestProperty("X-QFT-Upload-Key", requestKey)
|
||||
conn.outputStream.close()
|
||||
val code = conn.responseCode
|
||||
if (code != 200) error("初始化并行上传失败 HTTP $code")
|
||||
val body = conn.inputStream.bufferedReader().use { it.readText() }
|
||||
val obj = JSONObject(body)
|
||||
val totalChunks = obj.getInt("total_chunks")
|
||||
val missing = obj.optJSONArray("missing")
|
||||
val pending = if (missing == null) {
|
||||
IntArray(totalChunks) { it }
|
||||
} else {
|
||||
IntArray(missing.length()) { missing.getInt(it) }
|
||||
}
|
||||
if (pending.any { it !in 0 until totalChunks } || pending.distinct().size != pending.size) {
|
||||
error("电脑返回了无效的缺块列表")
|
||||
}
|
||||
InitReply(
|
||||
uploadId = obj.getString("upload_id"),
|
||||
chunkSize = obj.getLong("chunk_size"),
|
||||
totalChunks = obj.getInt("total_chunks"),
|
||||
totalChunks = totalChunks,
|
||||
pendingChunks = pending,
|
||||
)
|
||||
} finally {
|
||||
conn.disconnect()
|
||||
@@ -387,17 +419,17 @@ object UploadClient {
|
||||
}
|
||||
|
||||
private fun sendChunk(
|
||||
network: Network?, baseUrl: String, pairing: PairingPayload, deviceName: String,
|
||||
networkProvider: () -> Network?, baseUrl: String, pairing: PairingPayload, deviceName: String,
|
||||
uploadId: String, index: Int, channel: FileChannel, offset: Long, length: Long,
|
||||
buffer: ByteBuffer,
|
||||
) = retryLocalRequest("分块 $index 上传失败") {
|
||||
buffer: ByteBuffer, abortReason: () -> String?,
|
||||
) = retryLocalRequest("分块 $index 上传失败", abortReason) {
|
||||
Log.d(TAG, "chunk start: index=$index, bytes=$length, endpoint=$baseUrl")
|
||||
val conn = open(network, URL("$baseUrl/qft/upload/chunk/$uploadId/$index"))
|
||||
val conn = open(networkProvider(), URL("$baseUrl/qft/upload/chunk/$uploadId/$index"))
|
||||
try {
|
||||
conn.requestMethod = "POST"
|
||||
conn.doOutput = true
|
||||
conn.connectTimeout = 4_000
|
||||
conn.readTimeout = 15_000
|
||||
conn.connectTimeout = 8_000
|
||||
conn.readTimeout = 90_000
|
||||
conn.setFixedLengthStreamingMode(length)
|
||||
conn.setRequestProperty("Content-Type", "application/octet-stream")
|
||||
commonHeaders(conn, pairing, deviceName)
|
||||
@@ -406,6 +438,7 @@ object UploadClient {
|
||||
var remaining = length
|
||||
val array = buffer.array()
|
||||
while (remaining > 0) {
|
||||
abortReason()?.let { error(it) }
|
||||
buffer.clear()
|
||||
buffer.limit(minOf(array.size.toLong(), remaining).toInt())
|
||||
val n = channel.read(buffer)
|
||||
@@ -428,10 +461,10 @@ object UploadClient {
|
||||
}
|
||||
|
||||
private fun finishUpload(
|
||||
network: Network?, baseUrl: String, pairing: PairingPayload,
|
||||
deviceName: String, uploadId: String,
|
||||
) = retryLocalRequest("本地上传完成确认失败") {
|
||||
val conn = open(network, URL("$baseUrl/qft/upload/finish/$uploadId"))
|
||||
networkProvider: () -> Network?, baseUrl: String, pairing: PairingPayload,
|
||||
deviceName: String, uploadId: String, abortReason: () -> String?,
|
||||
) = retryLocalRequest("本地上传完成确认失败", abortReason) {
|
||||
val conn = open(networkProvider(), URL("$baseUrl/qft/upload/finish/$uploadId"))
|
||||
try {
|
||||
conn.requestMethod = "POST"
|
||||
conn.doOutput = true
|
||||
@@ -458,6 +491,7 @@ object UploadClient {
|
||||
pairing: PairingPayload,
|
||||
deviceName: String,
|
||||
file: SelectedFile,
|
||||
abortReason: () -> String?,
|
||||
onProgress: (sent: Long, total: Long) -> Unit,
|
||||
) {
|
||||
val conn = open(network, URL("$baseUrl/qft/upload"))
|
||||
@@ -478,6 +512,7 @@ object UploadClient {
|
||||
var sent = 0L
|
||||
var lastReport = 0L
|
||||
while (true) {
|
||||
abortReason()?.let { error(it) }
|
||||
val n = input.read(buf)
|
||||
if (n <= 0) break
|
||||
output.write(buf, 0, n)
|
||||
@@ -520,7 +555,7 @@ object UploadClient {
|
||||
|
||||
private fun commonHeaders(conn: HttpURLConnection, pairing: PairingPayload, deviceName: String) {
|
||||
conn.useCaches = false
|
||||
conn.setRequestProperty("Connection", "close")
|
||||
conn.setRequestProperty("Connection", "keep-alive")
|
||||
conn.setRequestProperty("X-QFT-Token", pairing.session)
|
||||
conn.setRequestProperty("X-QFT-Device", b64(deviceName))
|
||||
}
|
||||
|
||||
@@ -26,6 +26,7 @@ class WifiConnector(context: Context) {
|
||||
private val wifiManager = appContext.getSystemService(Context.WIFI_SERVICE) as WifiManager
|
||||
private val handler = Handler(Looper.getMainLooper())
|
||||
private var callback: ConnectivityManager.NetworkCallback? = null
|
||||
@Volatile private var currentNetwork: Network? = null
|
||||
private var generation = 0
|
||||
private var legacyPreviousNetworkId: Int? = null
|
||||
private var legacyTargetNetworkId: Int? = null
|
||||
@@ -65,11 +66,17 @@ class WifiConnector(context: Context) {
|
||||
// 同一个 SSID 的请求还挂在系统那里且没有终结:换掉 UI 回调即可,
|
||||
// 千万不要 unregister 再重新 requestNetwork。
|
||||
if (wifi != null && callback != null && pendingSsid == wifi.ssid &&
|
||||
pendingTerminal?.get() == false && pendingDelivered?.get() == false) {
|
||||
pendingTerminal?.get() == false) {
|
||||
Log.i(TAG, "reuse outstanding request SSID=${wifi.ssid}")
|
||||
listener = Listener(onStatus, onAvailable, onUnavailable)
|
||||
notifyStatus("系统配网请求仍在进行中,正在继续等待…")
|
||||
scheduleWaitHints(generation, wifi.ssid)
|
||||
val active = currentNetwork
|
||||
if (active != null) {
|
||||
notifyStatus("QFT 本地网络仍保持连接")
|
||||
notifyAvailable(active)
|
||||
} else {
|
||||
notifyStatus("系统配网请求仍在进行中,正在自动恢复连接…")
|
||||
scheduleWaitHints(generation, wifi.ssid)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
@@ -80,7 +87,8 @@ class WifiConnector(context: Context) {
|
||||
if (wifi == null) {
|
||||
notifyStatus("正在使用当前局域网发现电脑…")
|
||||
val wifiNetwork = bestWifiNetwork()
|
||||
notifyAvailable(wifiNetwork ?: connectivity.activeNetwork)
|
||||
currentNetwork = wifiNetwork ?: connectivity.activeNetwork
|
||||
notifyAvailable(currentNetwork)
|
||||
return
|
||||
}
|
||||
|
||||
@@ -125,10 +133,12 @@ class WifiConnector(context: Context) {
|
||||
val cb = object : ConnectivityManager.NetworkCallback() {
|
||||
override fun onAvailable(network: Network) {
|
||||
if (run != generation || terminal.get()) return
|
||||
currentNetwork = network
|
||||
Log.i(TAG, "attempt=$run framework onAvailable network=$network")
|
||||
notifyStatus("Wi-Fi 已关联,正在等待本地 IP/路由…")
|
||||
waitUntilUsable(run, network, ::notifyStatus) {
|
||||
if (run == generation && !terminal.get() && delivered.compareAndSet(false, true)) {
|
||||
if (run == generation && !terminal.get() && currentNetwork == network &&
|
||||
delivered.compareAndSet(false, true)) {
|
||||
Log.i(TAG, "attempt=$run route ready network=$network")
|
||||
notifyStatus("QFT 本地网络已就绪,正在快速发现电脑…")
|
||||
notifyAvailable(network)
|
||||
@@ -137,8 +147,9 @@ class WifiConnector(context: Context) {
|
||||
}
|
||||
|
||||
override fun onLinkPropertiesChanged(network: Network, linkProperties: LinkProperties) {
|
||||
if (run != generation || terminal.get() || delivered.get()) return
|
||||
if (run != generation || terminal.get() || delivered.get() || currentNetwork != network) return
|
||||
if (hasIpv4(linkProperties) && delivered.compareAndSet(false, true)) {
|
||||
currentNetwork = network
|
||||
Log.i(TAG, "attempt=$run IPv4 ready network=$network")
|
||||
notifyStatus("QFT 本地网络已就绪,正在快速发现电脑…")
|
||||
notifyAvailable(network)
|
||||
@@ -147,6 +158,7 @@ class WifiConnector(context: Context) {
|
||||
|
||||
override fun onUnavailable() {
|
||||
if (run != generation || !terminal.compareAndSet(false, true)) return
|
||||
currentNetwork = null
|
||||
val waited = SystemClock.elapsedRealtime() - startedAt
|
||||
Log.w(TAG, "attempt=$run framework onUnavailable after ${waited}ms")
|
||||
// Android 不区分「用户点了取消」和「始终没扫到这个热点」,
|
||||
@@ -164,9 +176,14 @@ class WifiConnector(context: Context) {
|
||||
}
|
||||
|
||||
override fun onLost(network: Network) {
|
||||
if (run != generation || !delivered.get() || !terminal.compareAndSet(false, true)) return
|
||||
if (run != generation || terminal.get() || currentNetwork != network) return
|
||||
Log.w(TAG, "attempt=$run network lost network=$network")
|
||||
notifyUnavailable("QFT 临时网络已断开")
|
||||
currentNetwork = null
|
||||
delivered.set(false)
|
||||
// requestNetwork stays registered. Android can therefore
|
||||
// deliver a replacement Network without another system picker;
|
||||
// range/chunk retries wait for and then use that new handle.
|
||||
notifyStatus("QFT 网络短暂波动,正在保持会话并自动恢复…")
|
||||
}
|
||||
}
|
||||
callback = cb
|
||||
@@ -246,6 +263,7 @@ class WifiConnector(context: Context) {
|
||||
val network = bestWifiNetwork()
|
||||
if (network != null && hasIpv4(connectivity.getLinkProperties(network))) {
|
||||
notifyStatus("QFT Wi-Fi 已连接,正在快速发现电脑…")
|
||||
currentNetwork = network
|
||||
notifyAvailable(network)
|
||||
return
|
||||
}
|
||||
@@ -375,6 +393,7 @@ class WifiConnector(context: Context) {
|
||||
try { connectivity.unregisterNetworkCallback(it) } catch (_: Exception) {}
|
||||
}
|
||||
callback = null
|
||||
currentNetwork = null
|
||||
listener = null
|
||||
pendingSsid = null
|
||||
pendingDelivered = null
|
||||
|
||||
Generated
+20
-2
@@ -2586,8 +2586,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d55d956fa96f5ec02be2e13af0e20391a5aa83d6a074e3ad368959d0fab299ea"
|
||||
|
||||
[[package]]
|
||||
name = "qft-windows"
|
||||
version = "0.4.6"
|
||||
name = "qft-desktop"
|
||||
version = "0.4.8"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"base64",
|
||||
@@ -2601,6 +2601,7 @@ dependencies = [
|
||||
"serde",
|
||||
"serde_json",
|
||||
"sha2",
|
||||
"whoami",
|
||||
"windows",
|
||||
]
|
||||
|
||||
@@ -3471,6 +3472,12 @@ dependencies = [
|
||||
"wit-bindgen",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wasite"
|
||||
version = "0.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b"
|
||||
|
||||
[[package]]
|
||||
name = "wasm-bindgen"
|
||||
version = "0.2.127"
|
||||
@@ -3881,6 +3888,17 @@ dependencies = [
|
||||
"web-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "whoami"
|
||||
version = "1.6.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5d4a4db5077702ca3015d3d02d74974948aba2ad9e12ab7df718ee64ccd7e97d"
|
||||
dependencies = [
|
||||
"libredox",
|
||||
"wasite",
|
||||
"web-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "winapi-util"
|
||||
version = "0.1.11"
|
||||
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "qft-windows"
|
||||
version = "0.4.6"
|
||||
name = "qft-desktop"
|
||||
version = "0.4.8"
|
||||
edition = "2024"
|
||||
rust-version = "1.95"
|
||||
|
||||
@@ -17,6 +17,9 @@ serde = { version = "1.0.219", features = ["derive"] }
|
||||
serde_json = "1.0.143"
|
||||
if-addrs = "0.13.4"
|
||||
rayon = "1.11.0"
|
||||
# 跨平台取本机名:macOS 上 HOSTNAME 环境变量通常不存在,
|
||||
# Linux 上默认也不导出,只靠 env 会退化成占位名。
|
||||
whoami = "1.6"
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
windows = { version = "0.62.2", features = [
|
||||
@@ -0,0 +1,798 @@
|
||||
//! 桌面端的**发起侧**。
|
||||
//!
|
||||
//! v0.4.7 之前桌面端只有服务端(`receiver.rs` / `sender.rs`),
|
||||
//! `TcpStream::connect` 只出现在测试里,因此 PC 无法主动连接另一台 PC。
|
||||
//! 本模块补上这一半,PC↔PC 才成立。
|
||||
//!
|
||||
//! 线格式与 Android `UploadClient.kt`/`DownloadClient.kt`、
|
||||
//! iOS `UploadClient.swift`/`DownloadClient.swift` 完全一致——沿用现有 v2 HTTP,
|
||||
//! 不引入 HTTP 客户端依赖:服务端本来就是手写的,两边保持同一套解析更容易对齐。
|
||||
|
||||
use anyhow::{bail, Context, Result};
|
||||
use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine as _};
|
||||
use std::{
|
||||
collections::HashMap,
|
||||
fs::{File, OpenOptions},
|
||||
io::{BufRead, BufReader, Read, Seek, SeekFrom, Write},
|
||||
net::{SocketAddr, TcpStream, ToSocketAddrs},
|
||||
path::{Path, PathBuf},
|
||||
sync::{
|
||||
atomic::{AtomicU32, AtomicU64, Ordering},
|
||||
Arc,
|
||||
},
|
||||
time::Duration,
|
||||
};
|
||||
|
||||
const IO_BUFFER: usize = 1024 * 1024;
|
||||
/// 与移动端一致:按文件大小自适应 4/8/16 MiB
|
||||
const CHUNK_SMALL: u64 = 4 * 1024 * 1024;
|
||||
const CHUNK_DEFAULT: u64 = 8 * 1024 * 1024;
|
||||
const CHUNK_LARGE: u64 = 16 * 1024 * 1024;
|
||||
const MAX_WORKERS: usize = 8;
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct PeerClient {
|
||||
/// 形如 `http://192.168.1.20:39393`
|
||||
pub base_url: String,
|
||||
pub token: String,
|
||||
pub device_name: String,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct Progress {
|
||||
pub done: u64,
|
||||
/// 单个文件的总量。多文件发送时 UI 用的是跨文件的累计总量,
|
||||
/// 因此当前没有读者;保留是为了让回调本身自洽,
|
||||
/// 单文件场景(如 P2 的目录传输逐项进度)会用到。
|
||||
#[allow(dead_code)]
|
||||
pub total: u64,
|
||||
}
|
||||
|
||||
impl PeerClient {
|
||||
pub fn new(base_url: impl Into<String>, token: impl Into<String>, device_name: impl Into<String>) -> Self {
|
||||
Self {
|
||||
base_url: base_url.into(),
|
||||
token: token.into(),
|
||||
device_name: device_name.into(),
|
||||
}
|
||||
}
|
||||
|
||||
fn address(&self) -> Result<SocketAddr> {
|
||||
let rest = self
|
||||
.base_url
|
||||
.strip_prefix("http://")
|
||||
.context("端点必须以 http:// 开头")?;
|
||||
let rest = rest.trim_end_matches('/');
|
||||
if rest.contains('/') {
|
||||
bail!("端点不允许带路径:{}", self.base_url)
|
||||
}
|
||||
rest.to_socket_addrs()
|
||||
.with_context(|| format!("无法解析端点 {}", self.base_url))?
|
||||
.next()
|
||||
.with_context(|| format!("端点无可用地址 {}", self.base_url))
|
||||
}
|
||||
|
||||
fn auth_headers(&self) -> Vec<(String, String)> {
|
||||
vec![
|
||||
("X-QFT-Token".into(), self.token.clone()),
|
||||
(
|
||||
"X-QFT-Device".into(),
|
||||
URL_SAFE_NO_PAD.encode(self.device_name.as_bytes()),
|
||||
),
|
||||
]
|
||||
}
|
||||
|
||||
/// `GET /qft/ping`。用于发现阶段快速验证「这个地址上确实是我要找的那台 QFT」。
|
||||
// 供 P1.5 的发现流程与后续的可达性诊断使用,当前 UI 尚未接线
|
||||
#[allow(dead_code)]
|
||||
pub fn ping(&self, timeout: Duration) -> Result<serde_json::Value> {
|
||||
let address = self.address()?;
|
||||
let mut response = send_request(address, "GET", "/qft/ping", &self.auth_headers(), None, timeout)?;
|
||||
if response.status != 200 {
|
||||
bail!("ping 返回 HTTP {}", response.status)
|
||||
}
|
||||
let body = response.read_body()?;
|
||||
serde_json::from_slice(&body).context("ping 响应不是 JSON")
|
||||
}
|
||||
|
||||
/// `POST /qft/pair`:用 6 位配对码换取会话令牌。
|
||||
///
|
||||
/// PC↔PC 的入口——桌面端没有摄像头,扫不了二维码,
|
||||
/// 只能由用户把对方屏幕上的 6 位数字敲进来。
|
||||
pub fn pair(base_url: &str, code: &str, device_name: &str) -> Result<String> {
|
||||
let probe = PeerClient::new(base_url, String::new(), device_name.to_owned());
|
||||
let address = probe.address()?;
|
||||
let mut headers = vec![
|
||||
("X-QFT-Code".to_string(), code.to_string()),
|
||||
(
|
||||
"X-QFT-Device".to_string(),
|
||||
URL_SAFE_NO_PAD.encode(device_name.as_bytes()),
|
||||
),
|
||||
];
|
||||
headers.push(("Content-Length".to_string(), "0".to_string()));
|
||||
|
||||
let mut response = send_request(
|
||||
address,
|
||||
"POST",
|
||||
"/qft/pair",
|
||||
&headers[..2],
|
||||
Some(&[]),
|
||||
// 配对只是一次极小的请求,4 秒还没建连基本就是不通了。
|
||||
// 拖到 10 秒只会让用户以为程序卡死。
|
||||
Duration::from_secs(4),
|
||||
)?;
|
||||
let body = response.read_body()?;
|
||||
let value: serde_json::Value = serde_json::from_slice(&body).unwrap_or(serde_json::Value::Null);
|
||||
match response.status {
|
||||
200 => value["token"]
|
||||
.as_str()
|
||||
.map(str::to_owned)
|
||||
.context("配对响应缺少 token"),
|
||||
403 => {
|
||||
let remaining = value["remaining"].as_u64().unwrap_or(0);
|
||||
bail!("配对码错误,还可尝试 {remaining} 次")
|
||||
}
|
||||
429 => bail!("配对码已作废,请让对方在电脑上重新启动接收"),
|
||||
other => bail!("配对返回 HTTP {other}"),
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------ 上传
|
||||
|
||||
/// 把本地文件推送到对端的接收服务(对端跑 `receiver.rs`)。
|
||||
pub fn upload_file(
|
||||
&self,
|
||||
path: &Path,
|
||||
mut on_progress: impl FnMut(Progress) + Send,
|
||||
) -> Result<String> {
|
||||
let address = self.address()?;
|
||||
let size = std::fs::metadata(path)
|
||||
.with_context(|| format!("读取 {} 失败", path.display()))?
|
||||
.len();
|
||||
let name = path
|
||||
.file_name()
|
||||
.and_then(|v| v.to_str())
|
||||
.filter(|v| !v.is_empty())
|
||||
.unwrap_or("qft-upload.bin");
|
||||
|
||||
let session = self.init_upload(address, name, size)?;
|
||||
if session.total_chunks == 0 {
|
||||
on_progress(Progress { done: 0, total: 0 });
|
||||
return self.finish_upload(address, &session.upload_id);
|
||||
}
|
||||
|
||||
let next = Arc::new(AtomicU32::new(0));
|
||||
let sent = Arc::new(AtomicU64::new(0));
|
||||
let workers = (session.total_chunks as usize).min(MAX_WORKERS).max(1);
|
||||
|
||||
// 进度回调在主线程汇总:worker 只累加原子计数,避免把 FnMut 塞进多个线程。
|
||||
// 主线程随后在此轮询上报——早先只在 scope 结束后报一次,
|
||||
// 结果传 1 GB 的过程中进度条一直是 0%,最后才跳到 100%。
|
||||
let failure = std::thread::scope(|scope| -> Result<()> {
|
||||
let mut handles = Vec::with_capacity(workers);
|
||||
for _ in 0..workers {
|
||||
let next = next.clone();
|
||||
let sent = sent.clone();
|
||||
let session = &session;
|
||||
handles.push(scope.spawn(move || -> Result<()> {
|
||||
let mut file = File::open(path)?;
|
||||
let mut buffer = vec![0u8; session.chunk_size as usize];
|
||||
loop {
|
||||
let index = next.fetch_add(1, Ordering::Relaxed);
|
||||
if index >= session.total_chunks {
|
||||
return Ok(());
|
||||
}
|
||||
let offset = index as u64 * session.chunk_size;
|
||||
let length = (size - offset).min(session.chunk_size) as usize;
|
||||
file.seek(SeekFrom::Start(offset))?;
|
||||
file.read_exact(&mut buffer[..length])?;
|
||||
self.put_chunk(address, &session.upload_id, index, &buffer[..length], &sent)?;
|
||||
}
|
||||
}));
|
||||
}
|
||||
// worker 跑着的时候持续上报,不要等它们全部结束
|
||||
while !handles.iter().all(|h| h.is_finished()) {
|
||||
on_progress(Progress {
|
||||
done: sent.load(Ordering::Relaxed).min(size),
|
||||
total: size,
|
||||
});
|
||||
std::thread::sleep(Duration::from_millis(40));
|
||||
}
|
||||
|
||||
let mut error = None;
|
||||
for handle in handles {
|
||||
match handle.join() {
|
||||
Ok(Ok(())) => {}
|
||||
Ok(Err(e)) => {
|
||||
error.get_or_insert(e);
|
||||
}
|
||||
Err(_) => {
|
||||
error.get_or_insert(anyhow::anyhow!("上传线程崩溃"));
|
||||
}
|
||||
}
|
||||
}
|
||||
match error {
|
||||
Some(e) => Err(e),
|
||||
None => Ok(()),
|
||||
}
|
||||
});
|
||||
failure?;
|
||||
|
||||
on_progress(Progress { done: size, total: size });
|
||||
self.finish_upload(address, &session.upload_id)
|
||||
}
|
||||
|
||||
fn init_upload(&self, address: SocketAddr, name: &str, size: u64) -> Result<UploadSession> {
|
||||
let chunk_size = desired_chunk_size(size);
|
||||
let mut headers = self.auth_headers();
|
||||
headers.push((
|
||||
"X-QFT-Filename".into(),
|
||||
URL_SAFE_NO_PAD.encode(name.as_bytes()),
|
||||
));
|
||||
headers.push(("X-QFT-Size".into(), size.to_string()));
|
||||
headers.push(("X-QFT-Chunk-Size".into(), chunk_size.to_string()));
|
||||
|
||||
let mut response = send_request(
|
||||
address,
|
||||
"POST",
|
||||
"/qft/upload/init",
|
||||
&headers,
|
||||
Some(&[]),
|
||||
Duration::from_secs(15),
|
||||
)?;
|
||||
if response.status != 200 {
|
||||
bail!("init 返回 HTTP {}", response.status)
|
||||
}
|
||||
let body = response.read_body()?;
|
||||
let value: serde_json::Value = serde_json::from_slice(&body).context("init 响应不是 JSON")?;
|
||||
Ok(UploadSession {
|
||||
upload_id: value["upload_id"]
|
||||
.as_str()
|
||||
.context("init 响应缺少 upload_id")?
|
||||
.to_owned(),
|
||||
chunk_size: value["chunk_size"].as_u64().context("init 响应缺少 chunk_size")?,
|
||||
total_chunks: value["total_chunks"]
|
||||
.as_u64()
|
||||
.context("init 响应缺少 total_chunks")? as u32,
|
||||
})
|
||||
}
|
||||
|
||||
fn put_chunk(
|
||||
&self,
|
||||
address: SocketAddr,
|
||||
upload_id: &str,
|
||||
index: u32,
|
||||
body: &[u8],
|
||||
sent: &AtomicU64,
|
||||
) -> Result<()> {
|
||||
let path = format!("/qft/upload/chunk/{upload_id}/{index}");
|
||||
// 接收端对重复分块是幂等的,因此重试安全。
|
||||
// 局域网上首次连接常被 Windows 防火墙首包丢弃,一次重试就能救回来。
|
||||
let mut last = None;
|
||||
for attempt in 0..3 {
|
||||
// 本次尝试写出的字节单独计一份:失败时要从总数里扣回去,
|
||||
// 否则重试会让进度虚高甚至超过 100%
|
||||
let attempted = AtomicU64::new(0);
|
||||
let mut sink = |n: usize| {
|
||||
attempted.fetch_add(n as u64, Ordering::Relaxed);
|
||||
sent.fetch_add(n as u64, Ordering::Relaxed);
|
||||
};
|
||||
let outcome = send_request_with_progress(
|
||||
address,
|
||||
"POST",
|
||||
&path,
|
||||
&self.auth_headers(),
|
||||
Some(body),
|
||||
Duration::from_secs(60),
|
||||
Some(&mut sink),
|
||||
);
|
||||
drop(sink);
|
||||
if outcome.is_err() || outcome.as_ref().is_ok_and(|r| r.status != 200) {
|
||||
sent.fetch_sub(attempted.load(Ordering::Relaxed), Ordering::Relaxed);
|
||||
}
|
||||
match outcome {
|
||||
Ok(mut response) => {
|
||||
let payload = response.read_body()?;
|
||||
if response.status == 200 {
|
||||
return Ok(());
|
||||
}
|
||||
last = Some(anyhow::anyhow!(
|
||||
"chunk {index} 返回 HTTP {}:{}",
|
||||
response.status,
|
||||
String::from_utf8_lossy(&payload[..payload.len().min(200)])
|
||||
));
|
||||
}
|
||||
Err(e) => last = Some(e),
|
||||
}
|
||||
std::thread::sleep(Duration::from_millis(120 << attempt));
|
||||
}
|
||||
Err(last.unwrap_or_else(|| anyhow::anyhow!("chunk {index} 失败")))
|
||||
}
|
||||
|
||||
fn finish_upload(&self, address: SocketAddr, upload_id: &str) -> Result<String> {
|
||||
let path = format!("/qft/upload/finish/{upload_id}");
|
||||
let mut response = send_request(
|
||||
address,
|
||||
"POST",
|
||||
&path,
|
||||
&self.auth_headers(),
|
||||
Some(&[]),
|
||||
Duration::from_secs(120),
|
||||
)?;
|
||||
let body = response.read_body()?;
|
||||
if response.status != 200 {
|
||||
bail!(
|
||||
"finish 返回 HTTP {}:{}",
|
||||
response.status,
|
||||
String::from_utf8_lossy(&body[..body.len().min(200)])
|
||||
)
|
||||
}
|
||||
let value: serde_json::Value = serde_json::from_slice(&body).context("finish 响应不是 JSON")?;
|
||||
value["sha256"]
|
||||
.as_str()
|
||||
.map(str::to_owned)
|
||||
.context("finish 响应缺少 sha256")
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------ 下载
|
||||
|
||||
/// 从对端的发送服务拉取文件(对端跑 `sender.rs`)。
|
||||
/// 支持断点续传:`dest` 已存在的部分会作为 Range 起点。
|
||||
// PC↔PC 目前只做「推送」,「主动拉取」在 P2 的会话模型里才用得上
|
||||
#[allow(dead_code)]
|
||||
pub fn download_file(
|
||||
&self,
|
||||
dest: &Path,
|
||||
expected_size: Option<u64>,
|
||||
mut on_progress: impl FnMut(Progress),
|
||||
) -> Result<PathBuf> {
|
||||
let address = self.address()?;
|
||||
let part = dest.with_extension("qftpart");
|
||||
let mut offset = part.metadata().map(|m| m.len()).unwrap_or(0);
|
||||
if let Some(expected) = expected_size {
|
||||
if offset > expected {
|
||||
let _ = std::fs::remove_file(&part);
|
||||
offset = 0;
|
||||
}
|
||||
}
|
||||
|
||||
let mut headers = self.auth_headers();
|
||||
if offset > 0 {
|
||||
headers.push(("Range".into(), format!("bytes={offset}-")));
|
||||
}
|
||||
let mut response = send_request(
|
||||
address,
|
||||
"GET",
|
||||
"/qft/download",
|
||||
&headers,
|
||||
None,
|
||||
Duration::from_secs(30),
|
||||
)?;
|
||||
if response.status != 200 && response.status != 206 {
|
||||
bail!("下载返回 HTTP {}", response.status)
|
||||
}
|
||||
if response.status == 200 {
|
||||
// 服务端忽略了 Range(旧版本),只能从头写
|
||||
offset = 0;
|
||||
}
|
||||
|
||||
let remaining = response
|
||||
.headers
|
||||
.get("content-length")
|
||||
.and_then(|v| v.parse::<u64>().ok());
|
||||
let total = expected_size.or_else(|| remaining.map(|r| offset + r)).unwrap_or(0);
|
||||
|
||||
if let Some(parent) = part.parent() {
|
||||
platform_ensure_dir(parent)?;
|
||||
}
|
||||
let mut out = OpenOptions::new()
|
||||
.create(true)
|
||||
.write(true)
|
||||
.open(&part)
|
||||
.with_context(|| format!("创建 {} 失败", part.display()))?;
|
||||
out.seek(SeekFrom::Start(offset))?;
|
||||
out.set_len(offset)?;
|
||||
|
||||
let mut done = offset;
|
||||
let mut buffer = vec![0u8; IO_BUFFER];
|
||||
loop {
|
||||
let n = response.reader.read(&mut buffer)?;
|
||||
if n == 0 {
|
||||
break;
|
||||
}
|
||||
out.write_all(&buffer[..n])?;
|
||||
done += n as u64;
|
||||
on_progress(Progress { done, total });
|
||||
}
|
||||
out.flush()?;
|
||||
drop(out);
|
||||
|
||||
if let Some(expected) = expected_size {
|
||||
if done != expected {
|
||||
bail!("下载提前结束:{done}/{expected}")
|
||||
}
|
||||
}
|
||||
std::fs::rename(&part, dest)
|
||||
.with_context(|| format!("重命名 {} 失败", part.display()))?;
|
||||
Ok(dest.to_path_buf())
|
||||
}
|
||||
}
|
||||
|
||||
struct UploadSession {
|
||||
upload_id: String,
|
||||
chunk_size: u64,
|
||||
total_chunks: u32,
|
||||
}
|
||||
|
||||
fn desired_chunk_size(size: u64) -> u64 {
|
||||
if size < 32 * 1024 * 1024 {
|
||||
CHUNK_SMALL
|
||||
} else if size >= 512 * 1024 * 1024 {
|
||||
CHUNK_LARGE
|
||||
} else {
|
||||
CHUNK_DEFAULT
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(dead_code)] // 仅被尚未接线的 download_file 使用
|
||||
fn platform_ensure_dir(path: &Path) -> Result<()> {
|
||||
crate::platform::ensure_dir(path)
|
||||
.with_context(|| format!("创建目录 {} 失败", path.display()))
|
||||
}
|
||||
|
||||
/// 把底层 io 错误翻译成能指导下一步的说法。
|
||||
///
|
||||
/// 「超时」和「被拒绝」的成因完全不同:前者是包被丢了(防火墙、主机不可达、
|
||||
/// AP 客户端隔离),后者是端口上没人监听(对方没点"启动接收")。
|
||||
/// 给用户一句笼统的"连接失败"等于什么都没说。
|
||||
fn describe_connect_failure(address: SocketAddr, error: &std::io::Error) -> anyhow::Error {
|
||||
use std::io::ErrorKind;
|
||||
let ip = address.ip();
|
||||
match error.kind() {
|
||||
ErrorKind::TimedOut => anyhow::anyhow!(
|
||||
"连接 {address} 超时:数据包发出去了但没有任何回应。\n\
|
||||
常见原因:① 对方电脑的防火墙拦截了入站连接(Windows 上需要放行 qft-desktop.exe 的专用网络);\
|
||||
② Wi-Fi 开了客户端隔离,同网段设备之间不能互通;\
|
||||
③ 对方已经关掉接收或换了网络。"
|
||||
),
|
||||
ErrorKind::ConnectionRefused => anyhow::anyhow!(
|
||||
"{ip} 明确拒绝了连接:主机在线,但 {} 端口上没有程序在监听。\n\
|
||||
请确认对方已经在「我要接收」里点了「启动接收」,并且连接码是最新的那一串。",
|
||||
address.port()
|
||||
),
|
||||
ErrorKind::HostUnreachable | ErrorKind::NetworkUnreachable => anyhow::anyhow!(
|
||||
"路由不可达:本机没有能到达 {ip} 的路由。请确认两台设备连在同一个网络里。"
|
||||
),
|
||||
_ => anyhow::anyhow!("连接 {address} 失败:{error}"),
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- 极简 HTTP 客户端
|
||||
|
||||
struct HttpResponse {
|
||||
status: u16,
|
||||
headers: HashMap<String, String>,
|
||||
reader: BufReader<TcpStream>,
|
||||
}
|
||||
|
||||
impl HttpResponse {
|
||||
/// 读完整个响应体。服务端总是发 `Connection: close`,
|
||||
/// 所以按 Content-Length 读,没有该头则读到 EOF。
|
||||
fn read_body(&mut self) -> Result<Vec<u8>> {
|
||||
let mut body = Vec::new();
|
||||
match self.headers.get("content-length").and_then(|v| v.parse::<u64>().ok()) {
|
||||
Some(length) => {
|
||||
body.resize(length as usize, 0);
|
||||
self.reader.read_exact(&mut body)?;
|
||||
}
|
||||
None => {
|
||||
self.reader.read_to_end(&mut body)?;
|
||||
}
|
||||
}
|
||||
Ok(body)
|
||||
}
|
||||
}
|
||||
|
||||
fn send_request(
|
||||
address: SocketAddr,
|
||||
method: &str,
|
||||
path: &str,
|
||||
headers: &[(String, String)],
|
||||
body: Option<&[u8]>,
|
||||
timeout: Duration,
|
||||
) -> Result<HttpResponse> {
|
||||
send_request_with_progress(address, method, path, headers, body, timeout, None)
|
||||
}
|
||||
|
||||
/// `on_body_written` 会在请求体每写出一片后被调用。
|
||||
/// 大文件分块是 16 MiB,若等整块写完才计数,进度条就是一格一格跳的。
|
||||
fn send_request_with_progress(
|
||||
address: SocketAddr,
|
||||
method: &str,
|
||||
path: &str,
|
||||
headers: &[(String, String)],
|
||||
body: Option<&[u8]>,
|
||||
timeout: Duration,
|
||||
mut on_body_written: Option<&mut dyn FnMut(usize)>,
|
||||
) -> Result<HttpResponse> {
|
||||
let stream = TcpStream::connect_timeout(&address, timeout.min(Duration::from_secs(10)))
|
||||
.map_err(|e| describe_connect_failure(address, &e))?;
|
||||
stream.set_nodelay(true).ok();
|
||||
stream.set_read_timeout(Some(timeout))?;
|
||||
stream.set_write_timeout(Some(timeout))?;
|
||||
|
||||
let mut request = String::with_capacity(256);
|
||||
request.push_str(&format!("{method} {path} HTTP/1.1\r\n"));
|
||||
request.push_str(&format!("Host: {address}\r\n"));
|
||||
request.push_str("Connection: close\r\n");
|
||||
for (name, value) in headers {
|
||||
request.push_str(&format!("{name}: {value}\r\n"));
|
||||
}
|
||||
if let Some(body) = body {
|
||||
request.push_str("Content-Type: application/octet-stream\r\n");
|
||||
request.push_str(&format!("Content-Length: {}\r\n", body.len()));
|
||||
}
|
||||
request.push_str("\r\n");
|
||||
|
||||
let mut writer = stream.try_clone()?;
|
||||
writer.write_all(request.as_bytes())?;
|
||||
if let Some(body) = body {
|
||||
// 256 KiB 一片:足够小,进度看起来是连续的;
|
||||
// 又足够大,不会因为频繁 write 拖慢吞吐
|
||||
const SLICE: usize = 256 * 1024;
|
||||
for part in body.chunks(SLICE) {
|
||||
writer.write_all(part)?;
|
||||
if let Some(sink) = on_body_written.as_deref_mut() {
|
||||
sink(part.len());
|
||||
}
|
||||
}
|
||||
}
|
||||
writer.flush()?;
|
||||
|
||||
let mut reader = BufReader::with_capacity(64 * 1024, stream);
|
||||
let mut status_line = String::new();
|
||||
reader.read_line(&mut status_line)?;
|
||||
if status_line.is_empty() {
|
||||
bail!("对端在返回状态行前关闭了连接")
|
||||
}
|
||||
let status: u16 = status_line
|
||||
.split_whitespace()
|
||||
.nth(1)
|
||||
.and_then(|v| v.parse().ok())
|
||||
.with_context(|| format!("无法解析状态行:{}", status_line.trim()))?;
|
||||
|
||||
let mut response_headers = HashMap::new();
|
||||
loop {
|
||||
let mut line = String::new();
|
||||
let n = reader.read_line(&mut line)?;
|
||||
if n == 0 {
|
||||
bail!("对端在返回响应头前关闭了连接")
|
||||
}
|
||||
if line == "\r\n" || line == "\n" {
|
||||
break;
|
||||
}
|
||||
if let Some((name, value)) = line.split_once(':') {
|
||||
response_headers.insert(name.trim().to_ascii_lowercase(), value.trim().to_owned());
|
||||
}
|
||||
}
|
||||
|
||||
Ok(HttpResponse {
|
||||
status,
|
||||
headers: response_headers,
|
||||
reader,
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn rejects_endpoints_with_path_or_wrong_scheme() {
|
||||
let make = |url: &str| PeerClient::new(url, "token", "dev").address();
|
||||
assert!(make("https://192.168.1.1:39393").is_err());
|
||||
assert!(make("http://192.168.1.1:39393/qft").is_err());
|
||||
assert!(make("192.168.1.1:39393").is_err());
|
||||
assert!(make("http://127.0.0.1:39393").is_ok());
|
||||
// 结尾斜杠应被容忍
|
||||
assert!(make("http://127.0.0.1:39393/").is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chunk_size_matches_mobile_clients() {
|
||||
assert_eq!(desired_chunk_size(1024), CHUNK_SMALL);
|
||||
assert_eq!(desired_chunk_size(31 * 1024 * 1024), CHUNK_SMALL);
|
||||
assert_eq!(desired_chunk_size(64 * 1024 * 1024), CHUNK_DEFAULT);
|
||||
assert_eq!(desired_chunk_size(600 * 1024 * 1024), CHUNK_LARGE);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod integration_tests {
|
||||
use super::*;
|
||||
use crate::receiver::{ReceiverEvent, ReceiverServer};
|
||||
use std::sync::mpsc;
|
||||
|
||||
/// 端到端:起一个真实的接收服务,用真实的 HTTP 客户端配对 + 上传,
|
||||
/// 校验落盘文件的 SHA-256 与接收端返回值一致。
|
||||
/// 这就是 PC↔PC 的完整链路,只是两端在同一进程里。
|
||||
#[test]
|
||||
fn pairs_then_uploads_a_real_file() {
|
||||
let root = std::env::temp_dir().join(format!("qft-pcpc-{}", std::process::id()));
|
||||
let inbox = root.join("inbox");
|
||||
std::fs::create_dir_all(&inbox).unwrap();
|
||||
let source = root.join("payload.bin");
|
||||
// 跨越多个分块边界的大小,确保并发路径被覆盖
|
||||
let payload: Vec<u8> = (0..(9 * 1024 * 1024 + 777)).map(|i| (i % 251) as u8).collect();
|
||||
std::fs::write(&source, &payload).unwrap();
|
||||
|
||||
let token = crate::pairing::new_session_token();
|
||||
let (tx, rx) = mpsc::channel::<ReceiverEvent>();
|
||||
let server = ReceiverServer::start(inbox.clone(), token.clone(), tx).unwrap();
|
||||
let base_url = format!("http://127.0.0.1:{}", server.port);
|
||||
|
||||
// 走完整的连接码链路:编码 → 用户输入 → 解码 → 换令牌
|
||||
let code = crate::connect_code::ConnectCode::new(
|
||||
std::net::IpAddr::V4(std::net::Ipv4Addr::LOCALHOST),
|
||||
server.port,
|
||||
server.secret,
|
||||
);
|
||||
let typed = code.encode();
|
||||
let parsed = crate::connect_code::ConnectCode::decode(&typed).expect("连接码应能解析");
|
||||
assert_eq!(parsed.base_url(), base_url, "码里解出的地址应与实际服务一致");
|
||||
|
||||
// 错误秘密必须被拒
|
||||
assert!(PeerClient::pair(&base_url, "000000", "tester").is_err());
|
||||
|
||||
let paired = PeerClient::pair(&base_url, &parsed.secret_hex(), "tester").unwrap();
|
||||
assert_eq!(paired, token, "配对应返回真实会话令牌");
|
||||
|
||||
let client = PeerClient::new(base_url, paired, "tester");
|
||||
let mut samples: Vec<Progress> = Vec::new();
|
||||
let sha = client.upload_file(&source, |p| samples.push(p)).unwrap();
|
||||
let last = *samples.last().expect("至少应有一次进度回调");
|
||||
assert_eq!(last.done, payload.len() as u64, "进度应抵达文件全长");
|
||||
|
||||
// 回环传输太快,采样次数不稳定,这里只断言稳健的性质;
|
||||
// 「边传边报」的机制由 body_progress_is_reported_incrementally 覆盖。
|
||||
assert!(
|
||||
samples.windows(2).all(|w| w[0].done <= w[1].done),
|
||||
"进度必须单调不减:{samples:?}"
|
||||
);
|
||||
assert!(
|
||||
samples.iter().all(|p| p.done <= payload.len() as u64),
|
||||
"进度不得超过文件总长(重试重复计数会导致这种情况):{samples:?}"
|
||||
);
|
||||
|
||||
let landed = inbox.join("payload.bin");
|
||||
let saved = std::fs::read(&landed).expect("文件应已落盘");
|
||||
assert_eq!(saved.len(), payload.len());
|
||||
assert_eq!(saved, payload, "落盘内容必须逐字节一致");
|
||||
|
||||
use sha2::{Digest, Sha256};
|
||||
let expected = Sha256::digest(&payload);
|
||||
let expected_hex: String = expected.iter().map(|b| format!("{b:02x}")).collect();
|
||||
assert_eq!(sha, expected_hex, "接收端返回的 SHA-256 必须与本地一致");
|
||||
|
||||
drop(server);
|
||||
while rx.try_recv().is_ok() {}
|
||||
let _ = std::fs::remove_dir_all(&root);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod failure_message_tests {
|
||||
use super::*;
|
||||
|
||||
/// 不可达地址必须给出「超时」类的排查建议,而不是一句空洞的失败。
|
||||
#[test]
|
||||
fn unreachable_host_yields_actionable_timeout_message() {
|
||||
// 192.0.2.0/24 是 RFC 5737 保留的文档用网段,不会有真实主机应答
|
||||
let error = PeerClient::pair("http://192.0.2.1:39393", "abcdef", "tester")
|
||||
.expect_err("不可达地址必须失败");
|
||||
let text = format!("{error:#}");
|
||||
assert!(text.contains("防火墙") || text.contains("超时") || text.contains("路由"),
|
||||
"应给出可执行的排查方向,实得:{text}");
|
||||
}
|
||||
|
||||
/// 本机没人监听的端口会被内核直接拒绝,提示必须与"超时"区分开。
|
||||
#[test]
|
||||
fn refused_port_says_receiver_not_started() {
|
||||
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let port = listener.local_addr().unwrap().port();
|
||||
drop(listener); // 端口随即空出,连接会被拒绝
|
||||
|
||||
let error = PeerClient::pair(&format!("http://127.0.0.1:{port}"), "abcdef", "tester")
|
||||
.expect_err("空端口必须失败");
|
||||
let text = format!("{error:#}");
|
||||
assert!(text.contains("启动接收") || text.contains("拒绝"),
|
||||
"被拒绝时应提示对方没启动接收,实得:{text}");
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod progress_tests {
|
||||
use super::*;
|
||||
use std::io::{BufRead, Read, Write};
|
||||
use std::sync::atomic::AtomicUsize;
|
||||
|
||||
/// 极简 mock:按 Content-Length 精确读完请求体再应答。
|
||||
///
|
||||
/// 不能用 read_to_end——那会一直等到客户端关闭写端,
|
||||
/// 而客户端此时正在等响应,两边互等直接死锁。
|
||||
fn serve_once(listener: std::net::TcpListener) -> std::thread::JoinHandle<usize> {
|
||||
std::thread::spawn(move || {
|
||||
let Ok((stream, _)) = listener.accept() else { return 0 };
|
||||
let mut reader = std::io::BufReader::new(stream.try_clone().unwrap());
|
||||
let mut length = 0usize;
|
||||
loop {
|
||||
let mut line = String::new();
|
||||
if reader.read_line(&mut line).unwrap_or(0) == 0 {
|
||||
break;
|
||||
}
|
||||
if line == "\r\n" || line == "\n" {
|
||||
break;
|
||||
}
|
||||
if let Some((name, value)) = line.split_once(':') {
|
||||
if name.trim().eq_ignore_ascii_case("content-length") {
|
||||
length = value.trim().parse().unwrap_or(0);
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut body = vec![0u8; length];
|
||||
let _ = reader.read_exact(&mut body);
|
||||
let mut out = stream;
|
||||
let _ = out.write_all(
|
||||
b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\n{}",
|
||||
);
|
||||
let _ = out.flush();
|
||||
length
|
||||
})
|
||||
}
|
||||
|
||||
/// 锁住「边写边报」这个行为。
|
||||
///
|
||||
/// 早先 `on_progress` 只在所有 worker 结束后调用一次,传 1 GB 时
|
||||
/// 进度条全程 0%、最后才跳到 100%。这里直接验证请求体是分片写出并
|
||||
/// 逐片上报的——回环速度太快时集成测试采样不到,只有这一层能稳定拦住回归。
|
||||
#[test]
|
||||
fn body_progress_is_reported_incrementally() {
|
||||
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let server = serve_once(listener);
|
||||
|
||||
let body = vec![7u8; 5 * 256 * 1024]; // 正好 5 片
|
||||
let calls = AtomicUsize::new(0);
|
||||
let total = AtomicU64::new(0);
|
||||
let mut sink = |n: usize| {
|
||||
calls.fetch_add(1, Ordering::Relaxed);
|
||||
total.fetch_add(n as u64, Ordering::Relaxed);
|
||||
};
|
||||
|
||||
let response = send_request_with_progress(
|
||||
address, "POST", "/x", &[], Some(&body),
|
||||
Duration::from_secs(10), Some(&mut sink),
|
||||
);
|
||||
drop(sink);
|
||||
assert!(response.is_ok(), "请求应成功:{:?}", response.err());
|
||||
assert_eq!(server.join().unwrap(), body.len(), "服务端应收到完整请求体");
|
||||
|
||||
assert_eq!(calls.load(Ordering::Relaxed), 5, "5 片体应上报 5 次");
|
||||
assert_eq!(
|
||||
total.load(Ordering::Relaxed),
|
||||
body.len() as u64,
|
||||
"上报总量应等于请求体长度"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn no_progress_sink_is_allowed() {
|
||||
// init/finish/ping 都不需要进度,不传 sink 时不能出问题
|
||||
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let server = serve_once(listener);
|
||||
let result = send_request(address, "POST", "/x", &[], Some(b"hi"), Duration::from_secs(10));
|
||||
assert!(result.is_ok(), "无 sink 时请求也应成功:{:?}", result.err());
|
||||
assert_eq!(server.join().unwrap(), 2);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,425 @@
|
||||
//! QFT 连接码:把「去哪连」和「凭什么连」压进一串可口述的短码。
|
||||
//!
|
||||
//! 此前 PC↔PC 要用户分别念 IP、端口、6 位配对码三样东西,既啰嗦又容易错。
|
||||
//! 连接码把它们合成一串,**地址就编在码里**,所以发送方拿到码即可直连,
|
||||
//! 不需要广播、不需要在同一网段——只要 IP 层路由可达即可。
|
||||
//! 同一路由器下的不同 VLAN/网段正属于这种情况。
|
||||
//!
|
||||
//! 必须说清的边界:连接码解决的是「找不到对方」和「输入太繁琐」。
|
||||
//! 如果两台机器在 IP 层根本互不可达(AP 客户端隔离、各自在不同的物理网络),
|
||||
//! 任何客户端侧协议都无法凭空造出可达性,只能换链路或引入第三方中转。
|
||||
//!
|
||||
//! 编码
|
||||
//! ```text
|
||||
//! byte0 version(3) | kind(3) | default_port(1) | reserved(1)
|
||||
//! addr 2~4 字节(按 kind 压缩私有网段)或 16 字节(IPv6)
|
||||
//! port 2 字节,仅当非默认端口时存在
|
||||
//! secret 3 字节(24 bit)
|
||||
//! crc 1 字节 CRC-8
|
||||
//! ```
|
||||
//! 典型的 `192.168.a.b:39393` 共 7 字节 → Crockford Base32 → **12 个字符**。
|
||||
|
||||
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
|
||||
|
||||
/// Crockford Base32:去掉了容易混淆的 I、L、O、U。
|
||||
const ALPHABET: &[u8; 32] = b"0123456789ABCDEFGHJKMNPQRSTVWXYZ";
|
||||
const VERSION: u8 = 1;
|
||||
pub const DEFAULT_PORT: u16 = 39393;
|
||||
pub const SECRET_LEN: usize = 3;
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
|
||||
enum AddrKind {
|
||||
/// 192.168.a.b —— 2 字节
|
||||
Private192 = 0,
|
||||
/// 10.a.b.c —— 3 字节
|
||||
Private10 = 1,
|
||||
/// 172.(16..=31).a.b —— 3 字节
|
||||
Private172 = 2,
|
||||
/// 任意 IPv4 —— 4 字节
|
||||
FullV4 = 3,
|
||||
/// IPv6 —— 16 字节。码会长到 32 字符左右,适合复制粘贴而非口述,
|
||||
/// 但它是「双方都有公网 IPv6 时无需任何服务器即可直连」的唯一途径。
|
||||
V6 = 4,
|
||||
}
|
||||
|
||||
impl AddrKind {
|
||||
fn from_bits(bits: u8) -> Option<Self> {
|
||||
Some(match bits {
|
||||
0 => Self::Private192,
|
||||
1 => Self::Private10,
|
||||
2 => Self::Private172,
|
||||
3 => Self::FullV4,
|
||||
4 => Self::V6,
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
|
||||
pub struct ConnectCode {
|
||||
pub address: IpAddr,
|
||||
pub port: u16,
|
||||
pub secret: [u8; SECRET_LEN],
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
pub enum CodeError {
|
||||
/// 长度不对,多半是漏敲或多敲了字符
|
||||
Length,
|
||||
/// 出现了字母表之外的字符
|
||||
Alphabet(char),
|
||||
/// 校验位不匹配——几乎可以肯定是输错了某一位
|
||||
Checksum,
|
||||
/// 版本或地址类型无法识别
|
||||
Unsupported,
|
||||
}
|
||||
|
||||
impl std::fmt::Display for CodeError {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
Self::Length => write!(f, "连接码长度不对,请检查是否漏敲或多敲了字符"),
|
||||
Self::Alphabet(ch) => write!(f, "连接码里有无效字符 '{ch}'"),
|
||||
Self::Checksum => write!(f, "连接码校验失败,请核对后重新输入"),
|
||||
Self::Unsupported => write!(f, "无法识别的连接码版本"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::error::Error for CodeError {}
|
||||
|
||||
impl ConnectCode {
|
||||
pub fn new(address: IpAddr, port: u16, secret: [u8; SECRET_LEN]) -> Self {
|
||||
Self { address, port, secret }
|
||||
}
|
||||
|
||||
/// 秘密的线上表示:6 个小写十六进制字符,放在 `X-QFT-Code` 头里。
|
||||
pub fn secret_hex(&self) -> String {
|
||||
self.secret.iter().map(|b| format!("{b:02x}")).collect()
|
||||
}
|
||||
|
||||
pub fn base_url(&self) -> String {
|
||||
match self.address {
|
||||
IpAddr::V4(v4) => format!("http://{v4}:{}", self.port),
|
||||
IpAddr::V6(v6) => format!("http://[{v6}]:{}", self.port),
|
||||
}
|
||||
}
|
||||
|
||||
/// 编码为分组显示的字符串,例如 `K7M2-9X4P-QR3T`。
|
||||
pub fn encode(&self) -> String {
|
||||
let bytes = self.to_bytes();
|
||||
let raw = base32_encode(&bytes);
|
||||
raw.as_bytes()
|
||||
.chunks(4)
|
||||
.map(|chunk| std::str::from_utf8(chunk).unwrap_or_default())
|
||||
.collect::<Vec<_>>()
|
||||
.join("-")
|
||||
}
|
||||
|
||||
/// 解析用户输入。分隔符、大小写、以及 I/L→1、O→0 的手误都会被容忍。
|
||||
pub fn decode(text: &str) -> Result<Self, CodeError> {
|
||||
let (bytes, padding_ok) = base32_decode(text)?;
|
||||
// 先判长度:码太短时「长度不对」比「校验失败」更能指导用户,
|
||||
// 再判填充位与 CRC。
|
||||
let code = Self::from_bytes(&bytes)?;
|
||||
if !padding_ok {
|
||||
return Err(CodeError::Checksum);
|
||||
}
|
||||
Ok(code)
|
||||
}
|
||||
|
||||
fn to_bytes(&self) -> Vec<u8> {
|
||||
let (kind, addr_bytes) = match self.address {
|
||||
IpAddr::V4(v4) => {
|
||||
let o = v4.octets();
|
||||
match (o[0], o[1]) {
|
||||
(192, 168) => (AddrKind::Private192, vec![o[2], o[3]]),
|
||||
(10, _) => (AddrKind::Private10, vec![o[1], o[2], o[3]]),
|
||||
(172, 16..=31) => (AddrKind::Private172, vec![o[1] - 16, o[2], o[3]]),
|
||||
_ => (AddrKind::FullV4, o.to_vec()),
|
||||
}
|
||||
}
|
||||
IpAddr::V6(v6) => (AddrKind::V6, v6.octets().to_vec()),
|
||||
};
|
||||
|
||||
let default_port = self.port == DEFAULT_PORT;
|
||||
let mut out = Vec::with_capacity(1 + addr_bytes.len() + 2 + SECRET_LEN + 1);
|
||||
out.push((VERSION << 5) | ((kind as u8) << 2) | ((default_port as u8) << 1));
|
||||
out.extend_from_slice(&addr_bytes);
|
||||
if !default_port {
|
||||
out.extend_from_slice(&self.port.to_be_bytes());
|
||||
}
|
||||
out.extend_from_slice(&self.secret);
|
||||
out.push(crc8(&out));
|
||||
out
|
||||
}
|
||||
|
||||
fn from_bytes(bytes: &[u8]) -> Result<Self, CodeError> {
|
||||
if bytes.len() < 1 + 2 + SECRET_LEN + 1 {
|
||||
return Err(CodeError::Length);
|
||||
}
|
||||
let (payload, checksum) = bytes.split_at(bytes.len() - 1);
|
||||
if crc8(payload) != checksum[0] {
|
||||
return Err(CodeError::Checksum);
|
||||
}
|
||||
|
||||
let header = payload[0];
|
||||
if header >> 5 != VERSION {
|
||||
return Err(CodeError::Unsupported);
|
||||
}
|
||||
let kind = AddrKind::from_bits((header >> 2) & 0b111).ok_or(CodeError::Unsupported)?;
|
||||
let default_port = (header >> 1) & 1 == 1;
|
||||
|
||||
let addr_len = match kind {
|
||||
AddrKind::Private192 => 2,
|
||||
AddrKind::Private10 | AddrKind::Private172 => 3,
|
||||
AddrKind::FullV4 => 4,
|
||||
AddrKind::V6 => 16,
|
||||
};
|
||||
let port_len = if default_port { 0 } else { 2 };
|
||||
if payload.len() != 1 + addr_len + port_len + SECRET_LEN {
|
||||
return Err(CodeError::Length);
|
||||
}
|
||||
|
||||
let addr_slice = &payload[1..1 + addr_len];
|
||||
let address = match kind {
|
||||
AddrKind::Private192 => {
|
||||
IpAddr::V4(Ipv4Addr::new(192, 168, addr_slice[0], addr_slice[1]))
|
||||
}
|
||||
AddrKind::Private10 => {
|
||||
IpAddr::V4(Ipv4Addr::new(10, addr_slice[0], addr_slice[1], addr_slice[2]))
|
||||
}
|
||||
AddrKind::Private172 => {
|
||||
// 第二个八位组只可能是 16..=31,编码时减了 16
|
||||
if addr_slice[0] > 15 {
|
||||
return Err(CodeError::Unsupported);
|
||||
}
|
||||
IpAddr::V4(Ipv4Addr::new(172, addr_slice[0] + 16, addr_slice[1], addr_slice[2]))
|
||||
}
|
||||
AddrKind::FullV4 => IpAddr::V4(Ipv4Addr::new(
|
||||
addr_slice[0], addr_slice[1], addr_slice[2], addr_slice[3],
|
||||
)),
|
||||
AddrKind::V6 => {
|
||||
let mut octets = [0u8; 16];
|
||||
octets.copy_from_slice(addr_slice);
|
||||
IpAddr::V6(Ipv6Addr::from(octets))
|
||||
}
|
||||
};
|
||||
|
||||
let mut cursor = 1 + addr_len;
|
||||
let port = if default_port {
|
||||
DEFAULT_PORT
|
||||
} else {
|
||||
let value = u16::from_be_bytes([payload[cursor], payload[cursor + 1]]);
|
||||
cursor += 2;
|
||||
value
|
||||
};
|
||||
let mut secret = [0u8; SECRET_LEN];
|
||||
secret.copy_from_slice(&payload[cursor..cursor + SECRET_LEN]);
|
||||
|
||||
Ok(Self { address, port, secret })
|
||||
}
|
||||
}
|
||||
|
||||
pub fn new_secret() -> [u8; SECRET_LEN] {
|
||||
use rand::RngCore;
|
||||
let mut secret = [0u8; SECRET_LEN];
|
||||
rand::rng().fill_bytes(&mut secret);
|
||||
secret
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- Base32
|
||||
|
||||
fn base32_encode(bytes: &[u8]) -> String {
|
||||
let mut out = String::with_capacity(bytes.len() * 8 / 5 + 1);
|
||||
let mut buffer: u32 = 0;
|
||||
let mut bits = 0u32;
|
||||
for &byte in bytes {
|
||||
buffer = (buffer << 8) | byte as u32;
|
||||
bits += 8;
|
||||
while bits >= 5 {
|
||||
bits -= 5;
|
||||
out.push(ALPHABET[((buffer >> bits) & 0x1f) as usize] as char);
|
||||
}
|
||||
}
|
||||
if bits > 0 {
|
||||
out.push(ALPHABET[((buffer << (5 - bits)) & 0x1f) as usize] as char);
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// 返回 (字节, 末尾填充位是否为 0)。
|
||||
fn base32_decode(text: &str) -> Result<(Vec<u8>, bool), CodeError> {
|
||||
let mut buffer: u32 = 0;
|
||||
let mut bits = 0u32;
|
||||
let mut out = Vec::new();
|
||||
let mut symbols = 0usize;
|
||||
|
||||
for ch in text.chars() {
|
||||
// 分隔符与空白一律忽略,用户怎么断句都行
|
||||
if ch == '-' || ch == ' ' || ch == '_' || ch == '\t' {
|
||||
continue;
|
||||
}
|
||||
let upper = ch.to_ascii_uppercase();
|
||||
// Crockford 的容错映射:手写/口述时 I、L 常被当成 1,O 被当成 0
|
||||
let normalized = match upper {
|
||||
'I' | 'L' => '1',
|
||||
'O' => '0',
|
||||
other => other,
|
||||
};
|
||||
let value = ALPHABET
|
||||
.iter()
|
||||
.position(|&c| c as char == normalized)
|
||||
.ok_or(CodeError::Alphabet(ch))? as u32;
|
||||
symbols += 1;
|
||||
buffer = (buffer << 5) | value;
|
||||
bits += 5;
|
||||
if bits >= 8 {
|
||||
bits -= 8;
|
||||
out.push(((buffer >> bits) & 0xff) as u8);
|
||||
}
|
||||
}
|
||||
if symbols == 0 {
|
||||
return Err(CodeError::Length);
|
||||
}
|
||||
// 5 位一组和 8 位一字节对不齐,末尾会剩几个填充位。编码时填的是 0,
|
||||
// 必须校验它们仍是 0:否则改动最后一个字符有 1/2^bits 的概率
|
||||
// 解出完全相同的字节序列,CRC 根本没机会发现(修复前实测漏检率 4%)。
|
||||
let padding_ok = bits == 0 || (buffer & ((1 << bits) - 1)) == 0;
|
||||
Ok((out, padding_ok))
|
||||
}
|
||||
|
||||
fn crc8(bytes: &[u8]) -> u8 {
|
||||
let mut crc = 0u8;
|
||||
for &byte in bytes {
|
||||
crc ^= byte;
|
||||
for _ in 0..8 {
|
||||
crc = if crc & 0x80 != 0 { (crc << 1) ^ 0x07 } else { crc << 1 };
|
||||
}
|
||||
}
|
||||
crc
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn code(ip: &str, port: u16) -> ConnectCode {
|
||||
ConnectCode::new(ip.parse().unwrap(), port, [0xAB, 0xCD, 0xEF])
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typical_home_address_fits_in_twelve_characters() {
|
||||
let encoded = code("192.168.1.20", DEFAULT_PORT).encode();
|
||||
let symbols = encoded.chars().filter(|c| *c != '-').count();
|
||||
assert_eq!(symbols, 12, "常见家庭网段应压到 12 个字符,实得 {encoded}");
|
||||
assert_eq!(encoded.matches('-').count(), 2, "应分成三组便于口述");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn round_trips_every_address_kind() {
|
||||
let cases = [
|
||||
("192.168.1.20", DEFAULT_PORT),
|
||||
("192.168.255.255", DEFAULT_PORT),
|
||||
("10.0.0.5", DEFAULT_PORT),
|
||||
("10.255.255.254", 8080),
|
||||
("172.16.0.1", DEFAULT_PORT),
|
||||
("172.31.255.254", 1),
|
||||
("100.64.0.1", DEFAULT_PORT), // CGNAT,落到 FullV4
|
||||
("127.0.0.1", 65535),
|
||||
("2001:db8::1", DEFAULT_PORT),
|
||||
("fe80::1", 39393),
|
||||
];
|
||||
for (ip, port) in cases {
|
||||
let original = code(ip, port);
|
||||
let decoded = ConnectCode::decode(&original.encode())
|
||||
.unwrap_or_else(|e| panic!("{ip}:{port} 解码失败:{e}"));
|
||||
assert_eq!(decoded, original, "{ip}:{port} 往返不一致");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn accepts_sloppy_user_input() {
|
||||
let original = code("192.168.1.20", DEFAULT_PORT);
|
||||
let canonical = original.encode();
|
||||
let sloppy = [
|
||||
canonical.to_lowercase(),
|
||||
canonical.replace('-', ""),
|
||||
canonical.replace('-', " "),
|
||||
format!(" {canonical} "),
|
||||
];
|
||||
for text in sloppy {
|
||||
assert_eq!(ConnectCode::decode(&text).unwrap(), original, "应容忍:{text}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn confusable_letters_map_to_digits() {
|
||||
// 口述时 I/L 常被听成 1,O 被听成 0。字母表里本就没有这些字母,
|
||||
// 所以把它们映射回数字是安全的,不会和真实字符冲突。
|
||||
let original = code("192.168.1.20", DEFAULT_PORT);
|
||||
let canonical = original.encode();
|
||||
let mangled = canonical.replace('1', "I").replace('0', "O");
|
||||
if mangled != canonical {
|
||||
assert_eq!(ConnectCode::decode(&mangled).unwrap(), original);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn single_character_typo_is_caught_by_checksum() {
|
||||
let canonical = code("192.168.1.20", DEFAULT_PORT).encode();
|
||||
let mut caught = 0;
|
||||
let mut total = 0;
|
||||
for (index, ch) in canonical.char_indices() {
|
||||
if ch == '-' {
|
||||
continue;
|
||||
}
|
||||
for &replacement in ALPHABET.iter() {
|
||||
if replacement as char == ch {
|
||||
continue;
|
||||
}
|
||||
let mut mangled: Vec<char> = canonical.chars().collect();
|
||||
mangled[index] = replacement as char;
|
||||
let text: String = mangled.into_iter().collect();
|
||||
total += 1;
|
||||
if ConnectCode::decode(&text).is_err() {
|
||||
caught += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
// CRC-8 理论漏检率约 1/256;这里要求实测拦截率高于 99%
|
||||
let rate = caught as f64 / total as f64;
|
||||
assert!(rate > 0.99, "单字符输错的拦截率只有 {:.3},太低", rate);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_malformed_input() {
|
||||
assert_eq!(ConnectCode::decode(""), Err(CodeError::Length));
|
||||
assert_eq!(ConnectCode::decode("---"), Err(CodeError::Length));
|
||||
assert!(matches!(ConnectCode::decode("K7M2!9X4"), Err(CodeError::Alphabet('!'))));
|
||||
assert_eq!(ConnectCode::decode("K7M2"), Err(CodeError::Length));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn secret_hex_is_stable_and_lowercase() {
|
||||
let value = code("192.168.1.20", DEFAULT_PORT);
|
||||
assert_eq!(value.secret_hex(), "abcdef");
|
||||
assert_eq!(value.base_url(), "http://192.168.1.20:39393");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ipv6_code_is_long_but_valid() {
|
||||
let value = code("2001:db8::1", DEFAULT_PORT);
|
||||
let encoded = value.encode();
|
||||
let symbols = encoded.chars().filter(|c| *c != '-').count();
|
||||
// IPv6 地址本身就 16 字节,码必然长,适合复制粘贴而不是口述
|
||||
assert!(symbols > 24, "IPv6 码应明显更长,实得 {symbols}");
|
||||
assert_eq!(ConnectCode::decode(&encoded).unwrap(), value);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn secrets_differ_between_sessions() {
|
||||
let a = new_secret();
|
||||
let b = new_secret();
|
||||
assert_ne!(a, b, "每次生成的秘密必须不同");
|
||||
}
|
||||
}
|
||||
@@ -1,4 +1,7 @@
|
||||
use anyhow::{bail, Context, Result};
|
||||
use anyhow::{bail, Result};
|
||||
// Context 只在 Windows 的 WiFiDirect 分支里用;非 Windows 上整段被编译掉。
|
||||
#[cfg(windows)]
|
||||
use anyhow::Context;
|
||||
|
||||
#[cfg(windows)]
|
||||
use windows::{
|
||||
@@ -0,0 +1,201 @@
|
||||
//! 局域网节点发现(v3 浏览)。
|
||||
//!
|
||||
//! 与既有的 `QFTDISC2:<token>` 不同:那是「我已经知道令牌,帮我找到那台机器」,
|
||||
//! 用于手机扫码之后。PC↔PC 没有摄像头,必须先能**列出附近有哪些节点**,
|
||||
//! 用户再从列表里挑一台,所以需要一个不带令牌的广播查询。
|
||||
//!
|
||||
//! 为什么不是 mDNS:
|
||||
//! - 本阶段目标是尽快让 PC↔PC 可测,UDP 广播零新依赖,且仓库里已有同样的模式;
|
||||
//! - macOS 上 mDNS 在沙盒/强化运行时下需要额外 entitlement,Windows 上常被
|
||||
//! 企业策略关掉,行为差异反而更多。
|
||||
//! mDNS 作为跨网段与「AP 隔离」场景的补充留到后续,不阻塞本阶段。
|
||||
//!
|
||||
//! 局限(必须在 UI 上说清楚):UDP 广播只覆盖同一个广播域。跨网段、
|
||||
//! 或开了 AP 隔离的 Wi-Fi 上发现不到对方,此时走手动输入 IP。
|
||||
|
||||
use anyhow::{Context, Result};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::{
|
||||
collections::HashMap,
|
||||
net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket},
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
|
||||
/// 广播查询;任何在监听的 QFT 节点都应答。
|
||||
pub const BROWSE_QUERY: &str = "QFTBROWSE3";
|
||||
/// 应答前缀,后接紧凑 JSON。
|
||||
pub const BROWSE_REPLY_PREFIX: &str = "QFTNODE3:";
|
||||
|
||||
/// 节点自我介绍。刻意用短键名——UDP 应答要留在单个数据报里。
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct NodeAnnounce {
|
||||
/// 设备名
|
||||
pub n: String,
|
||||
/// 平台标识:windows / macos / linux
|
||||
pub p: String,
|
||||
/// 传输服务的 TCP 端口
|
||||
pub t: u16,
|
||||
/// 当前是否正在等待配对(未在接收状态的节点不会被误选)
|
||||
pub r: bool,
|
||||
}
|
||||
|
||||
/// 发现到的对端。
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct Peer {
|
||||
pub name: String,
|
||||
pub platform: String,
|
||||
pub address: Ipv4Addr,
|
||||
pub port: u16,
|
||||
pub ready: bool,
|
||||
}
|
||||
|
||||
impl Peer {
|
||||
pub fn base_url(&self) -> String {
|
||||
format!("http://{}:{}", self.address, self.port)
|
||||
}
|
||||
}
|
||||
|
||||
/// 构造应答报文。接收端的 UDP 线程用它回应 `QFTBROWSE3`。
|
||||
pub fn browse_reply(announce: &NodeAnnounce) -> Vec<u8> {
|
||||
let json = serde_json::to_string(announce).unwrap_or_else(|_| "{}".into());
|
||||
format!("{BROWSE_REPLY_PREFIX}{json}").into_bytes()
|
||||
}
|
||||
|
||||
/// 向局域网广播一次查询并收集应答。
|
||||
///
|
||||
/// 同时发往受限广播地址和各网卡的定向广播地址:部分 Wi-Fi 驱动会丢弃
|
||||
/// 255.255.255.255,而定向广播能过。
|
||||
pub fn browse(port: u16, timeout: Duration) -> Result<Vec<Peer>> {
|
||||
let socket = UdpSocket::bind(("0.0.0.0", 0)).context("绑定发现端口失败")?;
|
||||
socket.set_broadcast(true).ok();
|
||||
socket
|
||||
.set_read_timeout(Some(Duration::from_millis(200)))
|
||||
.context("设置发现超时失败")?;
|
||||
|
||||
let mut targets: Vec<Ipv4Addr> = vec![Ipv4Addr::BROADCAST];
|
||||
for address in directed_broadcasts() {
|
||||
if !targets.contains(&address) {
|
||||
targets.push(address);
|
||||
}
|
||||
}
|
||||
for target in &targets {
|
||||
let _ = socket.send_to(BROWSE_QUERY.as_bytes(), SocketAddr::from((*target, port)));
|
||||
}
|
||||
|
||||
// 同一台机器可能从多个网卡应答,用「地址+端口」去重
|
||||
let mut found: HashMap<(Ipv4Addr, u16), Peer> = HashMap::new();
|
||||
let deadline = Instant::now() + timeout;
|
||||
let mut buffer = [0u8; 1024];
|
||||
while Instant::now() < deadline {
|
||||
match socket.recv_from(&mut buffer) {
|
||||
Ok((n, from)) => {
|
||||
let IpAddr::V4(address) = from.ip() else { continue };
|
||||
let Some(peer) = parse_reply(&buffer[..n], address) else { continue };
|
||||
found.insert((peer.address, peer.port), peer);
|
||||
}
|
||||
Err(e) if matches!(e.kind(), std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut) => {}
|
||||
Err(e) => return Err(e).context("接收发现应答失败"),
|
||||
}
|
||||
}
|
||||
|
||||
let mut peers: Vec<Peer> = found.into_values().collect();
|
||||
// 正在等待接收的排前面,其次按名字,保证列表顺序稳定不跳动
|
||||
peers.sort_by(|a, b| {
|
||||
b.ready
|
||||
.cmp(&a.ready)
|
||||
.then_with(|| a.name.cmp(&b.name))
|
||||
.then_with(|| a.address.cmp(&b.address))
|
||||
});
|
||||
Ok(peers)
|
||||
}
|
||||
|
||||
fn parse_reply(bytes: &[u8], address: Ipv4Addr) -> Option<Peer> {
|
||||
let text = std::str::from_utf8(bytes).ok()?;
|
||||
let json = text.strip_prefix(BROWSE_REPLY_PREFIX)?;
|
||||
let announce: NodeAnnounce = serde_json::from_str(json).ok()?;
|
||||
if announce.t == 0 {
|
||||
return None;
|
||||
}
|
||||
Some(Peer {
|
||||
name: crate::platform::sanitize_device_name(&announce.n),
|
||||
platform: announce.p.chars().filter(|c| c.is_ascii_alphanumeric()).take(16).collect(),
|
||||
address,
|
||||
port: announce.t,
|
||||
ready: announce.r,
|
||||
})
|
||||
}
|
||||
|
||||
/// 各网卡的定向广播地址(如 192.168.1.255)。
|
||||
fn directed_broadcasts() -> Vec<Ipv4Addr> {
|
||||
let mut out = Vec::new();
|
||||
let Ok(interfaces) = if_addrs::get_if_addrs() else { return out };
|
||||
for interface in interfaces {
|
||||
if interface.is_loopback() {
|
||||
continue;
|
||||
}
|
||||
let if_addrs::IfAddr::V4(v4) = interface.addr else { continue };
|
||||
let Some(netmask) = Some(v4.netmask) else { continue };
|
||||
let ip = u32::from(v4.ip);
|
||||
let mask = u32::from(netmask);
|
||||
if mask == 0 || mask == u32::MAX {
|
||||
continue;
|
||||
}
|
||||
let broadcast = Ipv4Addr::from(ip | !mask);
|
||||
if !out.contains(&broadcast) {
|
||||
out.push(broadcast);
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn reply_round_trip() {
|
||||
let announce = NodeAnnounce {
|
||||
n: "MacBook-Pro".into(),
|
||||
p: "macos".into(),
|
||||
t: 39393,
|
||||
r: true,
|
||||
};
|
||||
let bytes = browse_reply(&announce);
|
||||
let peer = parse_reply(&bytes, Ipv4Addr::new(192, 168, 1, 20)).expect("应能解析");
|
||||
assert_eq!(peer.name, "MacBook-Pro");
|
||||
assert_eq!(peer.platform, "macos");
|
||||
assert_eq!(peer.port, 39393);
|
||||
assert!(peer.ready);
|
||||
assert_eq!(peer.base_url(), "http://192.168.1.20:39393");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_foreign_or_malformed_datagrams() {
|
||||
let address = Ipv4Addr::LOCALHOST;
|
||||
assert!(parse_reply(b"QFTHERE2:token:39393", address).is_none());
|
||||
assert!(parse_reply(b"QFTNODE3:not-json", address).is_none());
|
||||
assert!(parse_reply(&[0xff, 0xfe, 0x00], address).is_none());
|
||||
// 端口 0 的应答无意义,必须丢弃
|
||||
assert!(parse_reply(br#"QFTNODE3:{"n":"x","p":"linux","t":0,"r":true}"#, address).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn announce_fits_in_one_datagram() {
|
||||
let announce = NodeAnnounce {
|
||||
n: "x".repeat(64),
|
||||
p: "windows".into(),
|
||||
t: 65535,
|
||||
r: false,
|
||||
};
|
||||
assert!(browse_reply(&announce).len() < 512);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn peer_name_is_sanitized_from_untrusted_datagram() {
|
||||
// 应答来自网络,是不可信输入:控制字符必须被清掉
|
||||
let bytes = format!("{BROWSE_REPLY_PREFIX}{{\"n\":\"bad\\u0000name\",\"p\":\"linux!!\",\"t\":1,\"r\":true}}");
|
||||
let peer = parse_reply(bytes.as_bytes(), Ipv4Addr::LOCALHOST).expect("应能解析");
|
||||
assert!(!peer.name.chars().any(char::is_control));
|
||||
assert_eq!(peer.platform, "linux");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,292 @@
|
||||
//! 系统防火墙放行。
|
||||
//!
|
||||
//! 接收端要监听入站 TCP,而 Windows 防火墙默认拦截未授权程序的入站连接,
|
||||
//! 表现是「对方能解析连接码,但连接一直超时」——这类问题用户几乎不可能
|
||||
//! 自己联想到防火墙。所以由程序主动检测并申请放行。
|
||||
//!
|
||||
//! 三条设计约束:
|
||||
//! 1. **只在确实缺规则时申请**。每次启动都弹 UAC 是骚扰。
|
||||
//! 2. **被拒绝就记住**。写一个标记文件,之后只在界面上留一个手动按钮,
|
||||
//! 不再自动弹窗。
|
||||
//! 3. **规则尽量窄**。只放行本程序这一个可执行文件,绝不整体关闭防火墙。
|
||||
//! 但**不能按网络配置文件收窄**——见下方 `grant()` 里的说明。
|
||||
//!
|
||||
//! 提权本身由操作系统的标准机制完成(Windows 的 UAC、macOS 的
|
||||
//! 授权对话框),程序不接触也不存储任何凭据。
|
||||
|
||||
use anyhow::{bail, Context, Result};
|
||||
use std::path::PathBuf;
|
||||
|
||||
/// 规则显示名。检测与添加都用它,改名会导致旧规则失效。
|
||||
// 仅 Windows 分支使用;其余平台整段被 cfg 编译掉
|
||||
#[cfg_attr(not(target_os = "windows"), allow(dead_code))]
|
||||
pub const RULE_NAME: &str = "QFT Desktop";
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub enum FirewallStatus {
|
||||
/// 已放行,或系统防火墙未开启,总之入站不会被拦
|
||||
Allowed,
|
||||
/// 缺少放行规则,入站很可能被拦
|
||||
Missing,
|
||||
/// 查不出来(命令不可用、输出无法解析等),不要据此吓唬用户
|
||||
Unknown(String),
|
||||
/// 本平台不做自动放行(目前只有 Linux 会返回)
|
||||
#[cfg_attr(not(all(unix, not(target_os = "macos"))), allow(dead_code))]
|
||||
Unsupported(&'static str),
|
||||
}
|
||||
|
||||
impl FirewallStatus {
|
||||
pub fn needs_action(&self) -> bool {
|
||||
matches!(self, Self::Missing)
|
||||
}
|
||||
}
|
||||
|
||||
fn current_exe() -> Result<PathBuf> {
|
||||
std::env::current_exe().context("无法获取本程序路径")
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- Windows
|
||||
|
||||
#[cfg(target_os = "windows")]
|
||||
pub fn status() -> FirewallStatus {
|
||||
use std::os::windows::process::CommandExt;
|
||||
const CREATE_NO_WINDOW: u32 = 0x0800_0000;
|
||||
|
||||
let output = std::process::Command::new("netsh")
|
||||
.args([
|
||||
"advfirewall",
|
||||
"firewall",
|
||||
"show",
|
||||
"rule",
|
||||
&format!("name={RULE_NAME}"),
|
||||
])
|
||||
.creation_flags(CREATE_NO_WINDOW)
|
||||
.output();
|
||||
|
||||
match output {
|
||||
Ok(out) if out.status.success() => {
|
||||
// 光有同名规则还不够:规则若绑在不适用于当前网络的 profile 上,
|
||||
// 会出现「显示已启用但照样被拦」。所以要求它是 profile=any。
|
||||
let text = String::from_utf8_lossy(&out.stdout);
|
||||
let any_profile = text.contains("Any") || text.contains("任何");
|
||||
if any_profile {
|
||||
FirewallStatus::Allowed
|
||||
} else {
|
||||
FirewallStatus::Missing
|
||||
}
|
||||
}
|
||||
// netsh 在找不到规则时退出码非 0
|
||||
Ok(_) => FirewallStatus::Missing,
|
||||
Err(e) => FirewallStatus::Unknown(format!("无法执行 netsh:{e}")),
|
||||
}
|
||||
}
|
||||
|
||||
/// 触发 UAC 并添加入站放行规则。
|
||||
///
|
||||
/// 用临时批处理承载命令,而不是把参数塞进 PowerShell 的 `-ArgumentList`:
|
||||
/// 程序路径里带空格时,经过 PowerShell 再到 netsh 会被重新分词,
|
||||
/// 引号层层嵌套极易出错。批处理文件由我们自己写死引号,不再被二次解析。
|
||||
///
|
||||
/// `profile=any` 是刻意的,早先写成 `private,domain` 是个真实的 bug:
|
||||
/// Windows 对没见过的 Wi-Fi 默认归类为**公用网络**,此时 private 规则
|
||||
/// 根本不适用——规则建了、也显示已启用,但连接照样被拦,极难排查。
|
||||
/// 收窄到某个 profile 并不能带来实际安全收益:QFT 的入站真正靠的是
|
||||
/// 连接码里的秘密加失败计数,没有秘密的连接一律被拒。
|
||||
#[cfg(target_os = "windows")]
|
||||
pub fn grant() -> Result<()> {
|
||||
use std::os::windows::process::CommandExt;
|
||||
const CREATE_NO_WINDOW: u32 = 0x0800_0000;
|
||||
|
||||
let exe = current_exe()?;
|
||||
let script = std::env::temp_dir().join(format!("qft-firewall-{}.bat", std::process::id()));
|
||||
let content = format!(
|
||||
"@echo off\r\n\
|
||||
netsh advfirewall firewall delete rule name=\"{RULE_NAME}\" >nul 2>&1\r\n\
|
||||
netsh advfirewall firewall add rule name=\"{RULE_NAME}\" dir=in action=allow \
|
||||
program=\"{}\" enable=yes profile=any\r\n",
|
||||
exe.display()
|
||||
);
|
||||
std::fs::write(&script, content).context("写入临时放行脚本失败")?;
|
||||
|
||||
let status = std::process::Command::new("powershell")
|
||||
.args([
|
||||
"-NoProfile",
|
||||
"-WindowStyle",
|
||||
"Hidden",
|
||||
"-Command",
|
||||
&format!(
|
||||
"Start-Process -FilePath cmd -ArgumentList '/c','\"{}\"' -Verb RunAs -WindowStyle Hidden -Wait",
|
||||
script.display()
|
||||
),
|
||||
])
|
||||
.creation_flags(CREATE_NO_WINDOW)
|
||||
.status();
|
||||
|
||||
let _ = std::fs::remove_file(&script);
|
||||
match status {
|
||||
// 用户在 UAC 上点了「否」时 Start-Process 会失败,退出码非 0
|
||||
Ok(s) if s.success() => Ok(()),
|
||||
Ok(_) => bail!("未获得管理员授权,防火墙规则没有添加"),
|
||||
Err(e) => bail!("调用提权失败:{e}"),
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- macOS
|
||||
|
||||
#[cfg(target_os = "macos")]
|
||||
pub fn status() -> FirewallStatus {
|
||||
const TOOL: &str = "/usr/libexec/ApplicationFirewall/socketfilterfw";
|
||||
if !std::path::Path::new(TOOL).exists() {
|
||||
return FirewallStatus::Unknown("系统上没有 socketfilterfw".into());
|
||||
}
|
||||
|
||||
// 应用层防火墙没开时,入站根本不会被拦,不需要做任何事
|
||||
match std::process::Command::new(TOOL).arg("--getglobalstate").output() {
|
||||
Ok(out) => {
|
||||
let text = String::from_utf8_lossy(&out.stdout);
|
||||
if text.contains("disabled") {
|
||||
return FirewallStatus::Allowed;
|
||||
}
|
||||
}
|
||||
Err(e) => return FirewallStatus::Unknown(format!("无法执行 socketfilterfw:{e}")),
|
||||
}
|
||||
|
||||
let Ok(exe) = current_exe() else {
|
||||
return FirewallStatus::Unknown("无法获取本程序路径".into());
|
||||
};
|
||||
match std::process::Command::new(TOOL)
|
||||
.args(["--getappblocked", &exe.display().to_string()])
|
||||
.output()
|
||||
{
|
||||
Ok(out) => {
|
||||
let text = String::from_utf8_lossy(&out.stdout).to_lowercase();
|
||||
if text.contains("blocked") && !text.contains("not blocked") {
|
||||
FirewallStatus::Missing
|
||||
} else {
|
||||
FirewallStatus::Allowed
|
||||
}
|
||||
}
|
||||
Err(e) => FirewallStatus::Unknown(format!("查询失败:{e}")),
|
||||
}
|
||||
}
|
||||
|
||||
/// 通过系统授权对话框把本程序加入放行列表。
|
||||
///
|
||||
/// macOS 通常会在首次监听时自己弹「是否允许接受传入网络连接」,
|
||||
/// 那一步就够了;这里只处理用户当时点了「拒绝」的情况。
|
||||
#[cfg(target_os = "macos")]
|
||||
pub fn grant() -> Result<()> {
|
||||
let exe = current_exe()?;
|
||||
let path = exe.display().to_string();
|
||||
if path.contains('"') || path.contains('\\') {
|
||||
bail!("程序路径包含无法安全转义的字符,请手动在「系统设置 → 网络 → 防火墙」里放行")
|
||||
}
|
||||
let inner = format!(
|
||||
"/usr/libexec/ApplicationFirewall/socketfilterfw --add '{path}' && \
|
||||
/usr/libexec/ApplicationFirewall/socketfilterfw --unblockapp '{path}'"
|
||||
);
|
||||
let script = format!("do shell script \"{inner}\" with administrator privileges");
|
||||
|
||||
let status = std::process::Command::new("osascript")
|
||||
.args(["-e", &script])
|
||||
.status()
|
||||
.context("调用 osascript 失败")?;
|
||||
if status.success() {
|
||||
Ok(())
|
||||
} else {
|
||||
bail!("未获得授权,防火墙放行没有生效")
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- Linux
|
||||
|
||||
#[cfg(all(unix, not(target_os = "macos")))]
|
||||
pub fn status() -> FirewallStatus {
|
||||
// 各发行版的防火墙前端差异过大(ufw / firewalld / 裸 iptables / nftables),
|
||||
// 自动改规则风险高于收益,只做检测与提示。
|
||||
FirewallStatus::Unsupported("Linux 上请按下方提示手动放行")
|
||||
}
|
||||
|
||||
#[cfg(all(unix, not(target_os = "macos")))]
|
||||
pub fn grant() -> Result<()> {
|
||||
bail!("Linux 上不自动修改防火墙,请按界面提示手动执行")
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- 手动说明
|
||||
|
||||
/// 自动放行失败或不支持时,给用户可以照抄的命令。
|
||||
pub fn manual_instructions(port: u16) -> String {
|
||||
let exe = current_exe()
|
||||
.map(|p| p.display().to_string())
|
||||
.unwrap_or_else(|_| "qft-desktop".into());
|
||||
|
||||
#[cfg(target_os = "windows")]
|
||||
{
|
||||
format!(
|
||||
"以管理员身份打开 PowerShell,执行:\n\n\
|
||||
New-NetFirewallRule -DisplayName \"{RULE_NAME}\" -Direction Inbound \\\n\
|
||||
\x20 -Program \"{exe}\" -Action Allow -Profile Private,Domain\n\n\
|
||||
或在「允许应用通过 Windows Defender 防火墙」里勾选该程序的专用网络。"
|
||||
)
|
||||
}
|
||||
#[cfg(target_os = "macos")]
|
||||
{
|
||||
let _ = port;
|
||||
format!(
|
||||
"打开「系统设置 → 网络 → 防火墙 → 选项」,把下面这个程序设为\
|
||||
「允许传入连接」:\n\n{exe}\n\n\
|
||||
若防火墙本身是关闭的,则无需任何操作。"
|
||||
)
|
||||
}
|
||||
#[cfg(all(unix, not(target_os = "macos")))]
|
||||
{
|
||||
let _ = exe;
|
||||
format!(
|
||||
"按你所用的防火墙执行其一:\n\n\
|
||||
ufw: sudo ufw allow {port}/tcp && sudo ufw allow {}/udp\n\
|
||||
firewalld: sudo firewall-cmd --add-port={port}/tcp --add-port={}/udp --permanent && sudo firewall-cmd --reload",
|
||||
port - 1,
|
||||
port - 1,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn status_query_never_panics_and_is_classified() {
|
||||
// 只做只读查询,不改动任何系统设置
|
||||
let value = status();
|
||||
match &value {
|
||||
FirewallStatus::Allowed
|
||||
| FirewallStatus::Missing
|
||||
| FirewallStatus::Unsupported(_) => {}
|
||||
FirewallStatus::Unknown(reason) => assert!(!reason.is_empty(), "未知原因不能为空"),
|
||||
}
|
||||
// 只有 Missing 才该触发后续动作
|
||||
assert_eq!(
|
||||
value.needs_action(),
|
||||
matches!(value, FirewallStatus::Missing)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn manual_instructions_mention_the_actual_program() {
|
||||
let text = manual_instructions(39393);
|
||||
assert!(!text.trim().is_empty());
|
||||
// 说明里必须出现可操作的东西:程序路径或具体端口
|
||||
assert!(
|
||||
text.contains("qft") || text.contains("39393") || text.contains("防火墙"),
|
||||
"说明应包含可操作信息:{text}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn status_is_read_only_and_repeatable() {
|
||||
// 检测必须无副作用:连续调用结果一致,且不改动任何系统设置
|
||||
assert_eq!(status(), status());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,7 +1,12 @@
|
||||
mod base45;
|
||||
mod client;
|
||||
mod connect_code;
|
||||
mod direct_ap;
|
||||
mod discovery;
|
||||
mod firewall;
|
||||
mod optical_cache;
|
||||
mod pairing;
|
||||
mod platform;
|
||||
mod protocol;
|
||||
mod qr;
|
||||
mod receiver;
|
||||
@@ -23,7 +28,7 @@ use std::{
|
||||
// a nominally larger page that is only decoded 10~18 times per second.
|
||||
const DEFAULT_CHUNK_SIZE: u16 = 320;
|
||||
const UI_FONT_NAME: &str = "qft-ui";
|
||||
const APP_VERSION: &str = "0.4.6";
|
||||
const APP_VERSION: &str = "0.4.8";
|
||||
|
||||
fn main() -> eframe::Result {
|
||||
let options = eframe::NativeOptions {
|
||||
@@ -46,6 +51,7 @@ enum Screen {
|
||||
OpticalSend,
|
||||
PhoneToPc,
|
||||
PcToPhone,
|
||||
PcToPc,
|
||||
}
|
||||
|
||||
struct OpticalState {
|
||||
@@ -101,6 +107,48 @@ struct SendState {
|
||||
connected_device: String,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq)]
|
||||
enum PcMode {
|
||||
Receive,
|
||||
Send,
|
||||
}
|
||||
|
||||
/// PC↔PC 传输的后台事件。传输跑在工作线程上,UI 只消费事件。
|
||||
enum PcEvent {
|
||||
Peers(Vec<discovery::Peer>),
|
||||
Paired { base_url: String, token: String },
|
||||
Progress { file: String, done: u64, total: u64 },
|
||||
FileDone { file: String, sha256: String },
|
||||
AllDone,
|
||||
Failed(String),
|
||||
}
|
||||
|
||||
struct PcPeerState {
|
||||
mode: PcMode,
|
||||
// 接收侧
|
||||
save_dir: Option<PathBuf>,
|
||||
server: Option<ReceiverServer>,
|
||||
// 发送侧
|
||||
peers: Vec<discovery::Peer>,
|
||||
code_input: String,
|
||||
token: Option<String>,
|
||||
connected_base: Option<String>,
|
||||
files: Vec<PathBuf>,
|
||||
// 后台事件
|
||||
events: Option<mpsc::Receiver<PcEvent>>,
|
||||
busy: bool,
|
||||
/// 仅在真正开始推送文件后为真。此前用 busy 兼作此用,
|
||||
/// 导致配对阶段就显示「正在发送 0%」,误导用户以为传输已经开始。
|
||||
transferring: bool,
|
||||
current_file: String,
|
||||
done: u64,
|
||||
total: u64,
|
||||
started: Option<Instant>,
|
||||
status: String,
|
||||
firewall: firewall::FirewallStatus,
|
||||
firewall_note: String,
|
||||
}
|
||||
|
||||
struct QftApp {
|
||||
screen: Screen,
|
||||
font_status: String,
|
||||
@@ -108,11 +156,14 @@ struct QftApp {
|
||||
optical: OpticalState,
|
||||
receive: ReceiveState,
|
||||
send: SendState,
|
||||
pc: PcPeerState,
|
||||
}
|
||||
|
||||
impl QftApp {
|
||||
fn new(cc: &eframe::CreationContext<'_>) -> Self {
|
||||
cc.egui_ctx.set_pixels_per_point(1.0);
|
||||
// 不要写死 pixels_per_point。此前固定为 1.0,在 Retina/HiDPI 上会让
|
||||
// 整个界面缩成实际尺寸的一半;缩放由 eframe 从系统取。
|
||||
// 二维码需要的像素级精确由 snap_to_physical 在绘制时保证。
|
||||
install_visuals(&cc.egui_ctx);
|
||||
let font_status = match install_ttf_font(&cc.egui_ctx) {
|
||||
Ok(path) => format!("字体:{}", path.display()),
|
||||
@@ -172,6 +223,26 @@ impl QftApp {
|
||||
status: "选择文件后生成二维码;手机扫码会自动配网并开始下载。".into(),
|
||||
connected_device: "等待 Android 扫码".into(),
|
||||
},
|
||||
pc: PcPeerState {
|
||||
mode: PcMode::Receive,
|
||||
save_dir: Some(platform::default_download_dir()),
|
||||
server: None,
|
||||
peers: Vec::new(),
|
||||
code_input: String::new(),
|
||||
token: None,
|
||||
connected_base: None,
|
||||
files: Vec::new(),
|
||||
events: None,
|
||||
busy: false,
|
||||
transferring: false,
|
||||
current_file: String::new(),
|
||||
done: 0,
|
||||
total: 0,
|
||||
started: None,
|
||||
status: "接收方启动后会显示连接码;发送方输入该码即可传输。".into(),
|
||||
firewall: firewall::FirewallStatus::Unknown("尚未检测".into()),
|
||||
firewall_note: String::new(),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
@@ -188,6 +259,7 @@ impl QftApp {
|
||||
Screen::PhoneToPc => self.stop_receiver(),
|
||||
Screen::PcToPhone => self.stop_sender(),
|
||||
Screen::OpticalSend => { self.optical.playing = false; self.optical.prefetch = None; },
|
||||
Screen::PcToPc => self.stop_pc(),
|
||||
Screen::Home => {}
|
||||
}
|
||||
self.screen = Screen::Home;
|
||||
@@ -248,6 +320,17 @@ impl QftApp {
|
||||
});
|
||||
});
|
||||
ui.add_space(18.0);
|
||||
ui.group(|ui| {
|
||||
ui.horizontal_wrapped(|ui| {
|
||||
ui.heading("电脑 ↔ 电脑");
|
||||
ui.separator();
|
||||
ui.label("输入对方的连接码即可 · 无需二维码");
|
||||
if ui.add_sized([220.0, 42.0], egui::Button::new("电脑之间互传")).clicked() {
|
||||
self.screen = Screen::PcToPc;
|
||||
}
|
||||
});
|
||||
});
|
||||
ui.add_space(18.0);
|
||||
ui.group(|ui| {
|
||||
ui.label(format!("本机设备:{}", self.local_device));
|
||||
ui.small(&self.font_status);
|
||||
@@ -425,7 +508,8 @@ impl QftApp {
|
||||
let base = avail.x.min((avail.y - reserved).max(220.0)).max(220.0);
|
||||
let side = (base * self.optical.qr_zoom).clamp(220.0, base);
|
||||
ui.vertical_centered(|ui| {
|
||||
ui.image((texture.id(), egui::vec2(side, side)));
|
||||
let side = snap_to_physical(side, ui.ctx().pixels_per_point());
|
||||
ui.image((texture.id(), egui::vec2(side, side)));
|
||||
if !self.optical.focus_qr {
|
||||
ui.small("拖动左侧分隔条可继续放大二维码;也可点击顶部“专注二维码”占满可用区域。");
|
||||
}
|
||||
@@ -446,7 +530,7 @@ impl QftApp {
|
||||
ui.horizontal_wrapped(|ui| {
|
||||
ui.heading("Android → 电脑 · 扫码直连");
|
||||
ui.separator();
|
||||
ui.label("UDP 快速发现 · 4/8/16 MiB 自适应分块 · 最高 8 路并行 · 不经过外网");
|
||||
ui.label("UDP 快速发现 · 64 KiB–16 MiB 自适应分块 · 目标 8 路并行 · 不经过外网");
|
||||
});
|
||||
ui.add_space(10.0);
|
||||
let running = self.receive.server.is_some();
|
||||
@@ -455,7 +539,7 @@ impl QftApp {
|
||||
ui.heading("1 · 保存位置");
|
||||
ui.horizontal_wrapped(|ui| {
|
||||
if ui.add_enabled(!running, egui::Button::new("选择接收文件夹")).clicked() {
|
||||
if let Some(dir) = rfd::FileDialog::new().pick_folder() {
|
||||
if let Some(dir) = pick_folder_safely() {
|
||||
self.receive.save_dir = Some(dir);
|
||||
self.receive.status = "保存位置已选择,可以启动接收。".into();
|
||||
}
|
||||
@@ -506,7 +590,8 @@ impl QftApp {
|
||||
ui.heading("手机扫码 · QFTPAIR2");
|
||||
if let Some(texture) = &self.receive.pair_texture {
|
||||
let side = ui.available_width().min(420.0).max(260.0);
|
||||
ui.vertical_centered(|ui| { ui.image((texture.id(), egui::vec2(side, side))); });
|
||||
ui.vertical_centered(|ui| { let side = snap_to_physical(side, ui.ctx().pixels_per_point());
|
||||
ui.image((texture.id(), egui::vec2(side, side))); });
|
||||
}
|
||||
if let Some(ap) = &self.receive.direct_ap {
|
||||
ui.label(format!("临时网络:{}", ap.ssid));
|
||||
@@ -555,7 +640,7 @@ impl QftApp {
|
||||
ui.heading("1 · 选择发送文件");
|
||||
ui.horizontal_wrapped(|ui| {
|
||||
if ui.add_enabled(!running, egui::Button::new("选择文件")).clicked() {
|
||||
if let Some(path) = rfd::FileDialog::new().pick_file() {
|
||||
if let Some(path) = pick_file_safely() {
|
||||
match TransferSource::open(&path, DEFAULT_CHUNK_SIZE) {
|
||||
Ok(source) => {
|
||||
self.send.file_size = source.manifest.file_size;
|
||||
@@ -605,7 +690,8 @@ impl QftApp {
|
||||
ui.heading("手机扫码 · QFTSEND2");
|
||||
if let Some(texture) = &self.send.pair_texture {
|
||||
let side = ui.available_width().min(420.0).max(260.0);
|
||||
ui.vertical_centered(|ui| { ui.image((texture.id(), egui::vec2(side, side))); });
|
||||
ui.vertical_centered(|ui| { let side = snap_to_physical(side, ui.ctx().pixels_per_point());
|
||||
ui.image((texture.id(), egui::vec2(side, side))); });
|
||||
}
|
||||
if let Some(ap) = &self.send.direct_ap {
|
||||
ui.label(format!("临时网络:{}", ap.ssid));
|
||||
@@ -623,7 +709,7 @@ impl QftApp {
|
||||
}
|
||||
|
||||
fn optical_pick_file(&mut self, ctx: &egui::Context) {
|
||||
let Some(path) = rfd::FileDialog::new().pick_file() else { return };
|
||||
let Some(path) = pick_file_safely() else { return };
|
||||
match TransferSource::open(&path, DEFAULT_CHUNK_SIZE) {
|
||||
Ok(source) => {
|
||||
self.optical.source = Some(Arc::new(source));
|
||||
@@ -900,6 +986,444 @@ impl QftApp {
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ==================== PC ↔ PC ====================
|
||||
|
||||
fn stop_pc(&mut self) {
|
||||
self.pc.server = None;
|
||||
self.receive.events = None;
|
||||
self.pc.events = None;
|
||||
self.pc.busy = false;
|
||||
self.pc.transferring = false;
|
||||
self.pc.token = None;
|
||||
self.pc.connected_base = None;
|
||||
}
|
||||
|
||||
fn pc_to_pc_ui(&mut self, ui: &mut egui::Ui, ctx: &egui::Context) {
|
||||
self.drain_pc_events();
|
||||
ctx.request_repaint_after(Duration::from_millis(150));
|
||||
|
||||
ui.horizontal_wrapped(|ui| {
|
||||
ui.heading("电脑 ↔ 电脑");
|
||||
ui.separator();
|
||||
ui.label("同一局域网或可路由到达 · 无需二维码 · 一串连接码");
|
||||
ui.separator();
|
||||
ui.selectable_value(&mut self.pc.mode, PcMode::Receive, "我要接收");
|
||||
ui.selectable_value(&mut self.pc.mode, PcMode::Send, "我要发送");
|
||||
});
|
||||
ui.add_space(10.0);
|
||||
ui.label(egui::RichText::new(&self.pc.status).weak());
|
||||
// 失败原因常常是多行的排查建议,需要完整展示而不是被截断
|
||||
ui.add_space(10.0);
|
||||
|
||||
match self.pc.mode {
|
||||
PcMode::Receive => self.pc_receive_ui(ui),
|
||||
PcMode::Send => self.pc_send_ui(ui),
|
||||
}
|
||||
}
|
||||
|
||||
fn pc_receive_ui(&mut self, ui: &mut egui::Ui) {
|
||||
ui.group(|ui| {
|
||||
ui.heading("接收设置");
|
||||
ui.horizontal_wrapped(|ui| {
|
||||
if ui.button("选择保存文件夹").clicked() {
|
||||
match pick_folder_safely() {
|
||||
Some(dir) => self.pc.save_dir = Some(dir),
|
||||
None => self.pc.status =
|
||||
"系统文件夹对话框没有返回结果。当前仍使用上方显示的目录。".into(),
|
||||
}
|
||||
}
|
||||
match self.pc.save_dir.as_ref() {
|
||||
Some(dir) => ui.label(dir.display().to_string()),
|
||||
None => ui.label("尚未选择"),
|
||||
};
|
||||
});
|
||||
ui.add_space(8.0);
|
||||
ui.horizontal_wrapped(|ui| {
|
||||
let running = self.pc.server.is_some();
|
||||
if ui.add_enabled(!running && self.pc.save_dir.is_some(),
|
||||
egui::Button::new("启动接收")).clicked() {
|
||||
self.start_pc_receiver();
|
||||
}
|
||||
if ui.add_enabled(running, egui::Button::new("停止接收")).clicked() {
|
||||
self.stop_pc();
|
||||
self.pc.status = "接收已停止。".into();
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
let Some(server) = self.pc.server.as_ref() else { return };
|
||||
let port = server.port;
|
||||
let secret = server.secret;
|
||||
// 每个网卡各生成一个连接码:对方在哪个网段,就用哪一个。
|
||||
// 地址已经编在码里,所以对方不需要再单独输入 IP。
|
||||
let codes: Vec<(std::net::IpAddr, String)> = pairing::local_ipv4_addresses()
|
||||
.into_iter()
|
||||
.map(|address| {
|
||||
let code = connect_code::ConnectCode::new(std::net::IpAddr::V4(address), port, secret);
|
||||
(std::net::IpAddr::V4(address), code.encode())
|
||||
})
|
||||
.collect();
|
||||
|
||||
{
|
||||
ui.add_space(10.0);
|
||||
ui.group(|ui| {
|
||||
let blocked = self.pc.firewall.needs_action();
|
||||
let color = if blocked {
|
||||
egui::Color32::from_rgb(220, 140, 60)
|
||||
} else {
|
||||
egui::Color32::from_rgb(80, 200, 120)
|
||||
};
|
||||
ui.horizontal_wrapped(|ui| {
|
||||
ui.colored_label(color, if blocked { "⚠ 系统防火墙可能拦截入站连接" } else { "● 防火墙" });
|
||||
if !self.pc.firewall_note.is_empty() {
|
||||
ui.label(&self.pc.firewall_note);
|
||||
}
|
||||
});
|
||||
ui.horizontal_wrapped(|ui| {
|
||||
// 无论检测结果如何都保留入口:检测可能不准,
|
||||
// 而用户遇到「对方连不上」时需要有地方可点。
|
||||
if ui.button("放行防火墙(需要管理员授权)").clicked() {
|
||||
self.request_firewall_grant();
|
||||
}
|
||||
if ui.small_button("复制手动放行命令").clicked() {
|
||||
ui.ctx().copy_text(firewall::manual_instructions(port));
|
||||
}
|
||||
if ui.small_button("重新检测").clicked() {
|
||||
self.refresh_firewall();
|
||||
}
|
||||
});
|
||||
if !blocked {
|
||||
ui.small("检测认为入站不会被拦。若对方仍连不上,可手动放行试试。");
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
ui.add_space(14.0);
|
||||
ui.group(|ui| {
|
||||
ui.heading("把连接码告诉发送方");
|
||||
ui.small("码里已经包含地址,对方只需输入这一串,不用再报 IP 和端口。");
|
||||
ui.add_space(8.0);
|
||||
if codes.is_empty() {
|
||||
ui.colored_label(egui::Color32::from_rgb(220, 120, 60), "没有可用的局域网地址,请检查网络连接。");
|
||||
}
|
||||
for (index, (address, code)) in codes.iter().enumerate() {
|
||||
ui.horizontal(|ui| {
|
||||
if index == 0 {
|
||||
ui.heading(egui::RichText::new(code).monospace().strong());
|
||||
} else {
|
||||
ui.monospace(egui::RichText::new(code).strong());
|
||||
}
|
||||
if ui.small_button("复制").clicked() {
|
||||
ui.ctx().copy_text(code.clone());
|
||||
}
|
||||
ui.weak(format!("({address})"));
|
||||
});
|
||||
}
|
||||
ui.add_space(6.0);
|
||||
ui.small("输错 5 次该码即作废,需要重新启动接收。");
|
||||
if codes.len() > 1 {
|
||||
ui.small("本机有多个网卡:对方在哪个网段就用对应的那一串。");
|
||||
}
|
||||
});
|
||||
|
||||
ui.add_space(14.0);
|
||||
ui.group(|ui| {
|
||||
ui.heading("接收进度");
|
||||
ui.label(format!("来自:{}", self.receive.connected_device));
|
||||
ui.label(format!("当前文件:{}", self.receive.current_file));
|
||||
if self.receive.total > 0 {
|
||||
let fraction = self.receive.received as f32 / self.receive.total as f32;
|
||||
ui.add(egui::ProgressBar::new(fraction).show_percentage());
|
||||
ui.label(format!("{} / {}",
|
||||
human_bytes(self.receive.received), human_bytes(self.receive.total)));
|
||||
}
|
||||
if self.receive.last_saved != "—" {
|
||||
ui.label(format!("已保存:{}", self.receive.last_saved));
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
fn pc_send_ui(&mut self, ui: &mut egui::Ui) {
|
||||
ui.group(|ui| {
|
||||
ui.heading("1 · 输入对方的连接码");
|
||||
ui.horizontal_wrapped(|ui| {
|
||||
let response = ui.add(
|
||||
egui::TextEdit::singleline(&mut self.pc.code_input)
|
||||
.hint_text("K7M2-9X4P-QR3T")
|
||||
.desired_width(240.0)
|
||||
.font(egui::TextStyle::Monospace),
|
||||
);
|
||||
let submitted = response.lost_focus()
|
||||
&& ui.input(|i| i.key_pressed(egui::Key::Enter));
|
||||
let parsed = connect_code::ConnectCode::decode(&self.pc.code_input);
|
||||
let can_connect = !self.pc.busy && parsed.is_ok();
|
||||
if ui.add_enabled(can_connect, egui::Button::new("连接")).clicked()
|
||||
|| (submitted && can_connect)
|
||||
{
|
||||
self.pair_pc_peer();
|
||||
}
|
||||
if self.pc.busy {
|
||||
ui.spinner();
|
||||
ui.weak("正在建立连接…最多等 4 秒");
|
||||
} else if self.pc.token.is_some() {
|
||||
ui.colored_label(egui::Color32::from_rgb(80, 200, 120), "● 已连接");
|
||||
}
|
||||
});
|
||||
// 边打边校验:CRC 能在连接之前就发现输错,不用等超时
|
||||
if !self.pc.code_input.trim().is_empty() {
|
||||
match connect_code::ConnectCode::decode(&self.pc.code_input) {
|
||||
Ok(code) => ui.weak(format!("将连接 {}", code.base_url())),
|
||||
Err(e) => ui.colored_label(egui::Color32::from_rgb(220, 120, 60), e.to_string()),
|
||||
};
|
||||
}
|
||||
ui.add_space(4.0);
|
||||
ui.small("连接码里已包含对方地址,不需要在同一网段——只要网络能路由到对方即可。");
|
||||
});
|
||||
|
||||
ui.add_space(12.0);
|
||||
ui.collapsing("搜索同网段的设备(可选)", |ui| {
|
||||
ui.small("同一网段时可以免输码。跨网段、或 Wi-Fi 开了客户端隔离时搜不到,请改用连接码。");
|
||||
if ui.add_enabled(!self.pc.busy, egui::Button::new("搜索")).clicked() {
|
||||
self.browse_pc_peers();
|
||||
}
|
||||
for peer in &self.pc.peers {
|
||||
if ui.button(format!("{} · {} · {}", peer.name, peer.platform, peer.base_url())).clicked() {
|
||||
// 直接把对端地址填进码输入框还不够——秘密只有对方屏幕上有,
|
||||
// 所以这里只做地址提示,仍需用户补齐连接码
|
||||
self.pc.status = format!("请输入 {} 屏幕上显示的连接码", peer.name);
|
||||
}
|
||||
}
|
||||
if self.pc.peers.is_empty() {
|
||||
ui.weak("尚未搜索到设备。");
|
||||
}
|
||||
});
|
||||
|
||||
// 拖进窗口的文件直接进待发列表。拖拽不依赖系统文件对话框,
|
||||
// 因此在 NSOpenPanel 失效时仍然可用。
|
||||
let dropped = dropped_paths(ui.ctx());
|
||||
if !dropped.is_empty() {
|
||||
for path in dropped {
|
||||
if path.is_file() && !self.pc.files.contains(&path) {
|
||||
self.pc.files.push(path);
|
||||
}
|
||||
}
|
||||
self.pc.status = format!("已加入 {} 个文件。", self.pc.files.len());
|
||||
}
|
||||
|
||||
ui.add_space(12.0);
|
||||
ui.group(|ui| {
|
||||
ui.heading("2 · 选择文件并发送");
|
||||
if is_hovering_files(ui.ctx()) {
|
||||
ui.colored_label(egui::Color32::from_rgb(80, 200, 120), "松手即可加入待发送列表");
|
||||
} else {
|
||||
ui.small("可以直接把文件拖进这个窗口。");
|
||||
}
|
||||
ui.horizontal_wrapped(|ui| {
|
||||
if ui.button("选择文件").clicked() {
|
||||
match pick_files_safely() {
|
||||
Some(files) => self.pc.files = files,
|
||||
None => self.pc.status =
|
||||
"系统文件对话框没有返回结果。可以直接把文件拖进窗口。".into(),
|
||||
}
|
||||
}
|
||||
if ui.add_enabled(!self.pc.files.is_empty(), egui::Button::new("清空")).clicked() {
|
||||
self.pc.files.clear();
|
||||
}
|
||||
let ready = !self.pc.busy && self.pc.token.is_some() && !self.pc.files.is_empty();
|
||||
if ui.add_enabled(ready, egui::Button::new("开始发送")).clicked() {
|
||||
self.send_pc_files();
|
||||
}
|
||||
});
|
||||
for file in &self.pc.files {
|
||||
let size = std::fs::metadata(file).map(|m| m.len()).unwrap_or(0);
|
||||
ui.label(format!("• {} {}", file.display(), human_bytes(size)));
|
||||
}
|
||||
|
||||
if self.pc.transferring || self.pc.total > 0 {
|
||||
ui.add_space(8.0);
|
||||
ui.label(format!("正在发送:{}", self.pc.current_file));
|
||||
let fraction = if self.pc.total == 0 { 0.0 }
|
||||
else { self.pc.done as f32 / self.pc.total as f32 };
|
||||
ui.add(egui::ProgressBar::new(fraction).show_percentage());
|
||||
let elapsed = self.pc.started.map(|t| t.elapsed().as_secs_f64()).unwrap_or(0.0).max(0.001);
|
||||
ui.label(format!("{} / {} · {}/s",
|
||||
human_bytes(self.pc.done), human_bytes(self.pc.total),
|
||||
human_bytes((self.pc.done as f64 / elapsed) as u64)));
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// 只做**只读检测**,不申请任何权限。
|
||||
///
|
||||
/// 早先版本会在启动接收时自动弹 UAC。实际用下来这太侵入:
|
||||
/// 多数人只是想收个文件,却先被要求管理员授权。
|
||||
/// 现在提权一律由用户点按钮触发(`request_firewall_grant`)。
|
||||
fn refresh_firewall(&mut self) {
|
||||
self.pc.firewall = firewall::status();
|
||||
if !self.pc.firewall.needs_action() {
|
||||
self.pc.firewall_note.clear();
|
||||
}
|
||||
}
|
||||
|
||||
/// 用户显式点击后才提权。
|
||||
fn request_firewall_grant(&mut self) {
|
||||
match firewall::grant() {
|
||||
Ok(()) => {
|
||||
self.pc.firewall = firewall::status();
|
||||
self.pc.firewall_note = "已放行系统防火墙。".into();
|
||||
}
|
||||
Err(e) => self.pc.firewall_note = format!("{e}"),
|
||||
}
|
||||
}
|
||||
|
||||
fn start_pc_receiver(&mut self) {
|
||||
let Some(dir) = self.pc.save_dir.clone() else { return };
|
||||
self.stop_pc();
|
||||
self.refresh_firewall();
|
||||
let token = pairing::new_session_token();
|
||||
let (tx, rx) = mpsc::channel();
|
||||
match ReceiverServer::start(dir, token, tx) {
|
||||
Ok(server) => {
|
||||
self.pc.status = "接收中。把下面的连接码告诉发送方即可。".into();
|
||||
self.pc.server = Some(server);
|
||||
self.receive.events = Some(rx);
|
||||
self.receive.connected_device = "等待对方连接".into();
|
||||
self.receive.current_file = "—".into();
|
||||
self.receive.received = 0;
|
||||
self.receive.total = 0;
|
||||
}
|
||||
Err(e) => self.pc.status = format!("启动接收失败:{e:#}"),
|
||||
}
|
||||
}
|
||||
|
||||
fn browse_pc_peers(&mut self) {
|
||||
let (tx, rx) = mpsc::channel();
|
||||
self.pc.events = Some(rx);
|
||||
self.pc.busy = true;
|
||||
self.pc.status = "正在搜索附近的电脑…".into();
|
||||
std::thread::spawn(move || {
|
||||
let result = discovery::browse(receiver::DISCOVERY_PORT, Duration::from_millis(1200));
|
||||
let _ = match result {
|
||||
Ok(peers) => tx.send(PcEvent::Peers(peers)),
|
||||
Err(e) => tx.send(PcEvent::Failed(format!("搜索失败:{e:#}"))),
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
fn pair_pc_peer(&mut self) {
|
||||
let Ok(code) = connect_code::ConnectCode::decode(&self.pc.code_input) else { return };
|
||||
let base_url = code.base_url();
|
||||
let secret = code.secret_hex();
|
||||
let device = self.local_device.clone();
|
||||
let (tx, rx) = mpsc::channel();
|
||||
self.pc.events = Some(rx);
|
||||
self.pc.busy = true;
|
||||
self.pc.status = format!("正在连接 {base_url}…");
|
||||
std::thread::spawn(move || {
|
||||
let _ = match client::PeerClient::pair(&base_url, &secret, &device) {
|
||||
Ok(token) => tx.send(PcEvent::Paired { base_url, token }),
|
||||
Err(e) => tx.send(PcEvent::Failed(format!("{e:#}"))),
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
fn send_pc_files(&mut self) {
|
||||
let (Some(base_url), Some(token)) =
|
||||
(self.pc.connected_base.clone(), self.pc.token.clone()) else { return };
|
||||
let files = self.pc.files.clone();
|
||||
let device = self.local_device.clone();
|
||||
let total: u64 = files.iter()
|
||||
.map(|f| std::fs::metadata(f).map(|m| m.len()).unwrap_or(0))
|
||||
.sum();
|
||||
|
||||
let (tx, rx) = mpsc::channel();
|
||||
self.pc.events = Some(rx);
|
||||
self.pc.busy = true;
|
||||
self.pc.transferring = true;
|
||||
self.pc.done = 0;
|
||||
self.pc.total = total;
|
||||
self.pc.started = Some(Instant::now());
|
||||
self.pc.status = format!("正在发送 {} 个文件…", files.len());
|
||||
|
||||
std::thread::spawn(move || {
|
||||
let peer = client::PeerClient::new(base_url, token, device);
|
||||
// 逐个文件累加,跨文件的进度用 base 偏移拼起来
|
||||
let mut base = 0u64;
|
||||
for path in files {
|
||||
let name = path.file_name().and_then(|v| v.to_str()).unwrap_or("文件").to_string();
|
||||
let size = std::fs::metadata(&path).map(|m| m.len()).unwrap_or(0);
|
||||
let progress_tx = tx.clone();
|
||||
let progress_name = name.clone();
|
||||
let result = peer.upload_file(&path, |p| {
|
||||
let _ = progress_tx.send(PcEvent::Progress {
|
||||
file: progress_name.clone(),
|
||||
done: base + p.done,
|
||||
total,
|
||||
});
|
||||
});
|
||||
match result {
|
||||
Ok(sha256) => {
|
||||
base += size;
|
||||
let _ = tx.send(PcEvent::Progress { file: name.clone(), done: base, total });
|
||||
let _ = tx.send(PcEvent::FileDone { file: name, sha256 });
|
||||
}
|
||||
Err(e) => {
|
||||
let _ = tx.send(PcEvent::Failed(format!("{name} 发送失败:{e:#}")));
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
let _ = tx.send(PcEvent::AllDone);
|
||||
});
|
||||
}
|
||||
|
||||
fn drain_pc_events(&mut self) {
|
||||
// 接收侧完全复用既有的 ReceiverEvent 渲染逻辑,不另写一套
|
||||
self.poll_receiver_events();
|
||||
|
||||
let Some(rx) = self.pc.events.take() else { return };
|
||||
while let Ok(event) = rx.try_recv() {
|
||||
match event {
|
||||
PcEvent::Peers(peers) => {
|
||||
self.pc.status = if peers.is_empty() {
|
||||
"没有搜索到设备。确认对方已启动接收,或改用手动输入地址。".into()
|
||||
} else {
|
||||
format!("搜索到 {} 台设备。", peers.len())
|
||||
};
|
||||
self.pc.peers = peers;
|
||||
self.pc.busy = false;
|
||||
}
|
||||
PcEvent::Paired { base_url, token } => {
|
||||
self.pc.status = format!("已连接 {base_url},可以选择文件了。");
|
||||
self.pc.connected_base = Some(base_url);
|
||||
self.pc.token = Some(token);
|
||||
self.pc.busy = false;
|
||||
}
|
||||
PcEvent::Progress { file, done, total } => {
|
||||
self.pc.current_file = file;
|
||||
self.pc.done = done;
|
||||
self.pc.total = total;
|
||||
}
|
||||
PcEvent::FileDone { file, sha256 } => {
|
||||
self.pc.status = format!("{file} 已送达 · SHA-256 {}", &sha256[..16.min(sha256.len())]);
|
||||
}
|
||||
PcEvent::AllDone => {
|
||||
self.pc.busy = false;
|
||||
self.pc.transferring = false;
|
||||
self.pc.current_file.clear();
|
||||
self.pc.status = "全部发送完成。".into();
|
||||
}
|
||||
PcEvent::Failed(message) => {
|
||||
self.pc.busy = false;
|
||||
self.pc.transferring = false;
|
||||
self.pc.status = message;
|
||||
}
|
||||
}
|
||||
}
|
||||
self.pc.events = Some(rx);
|
||||
}
|
||||
|
||||
fn stop_receiver(&mut self) {
|
||||
self.receive.events = None;
|
||||
self.receive.server = None;
|
||||
@@ -974,6 +1498,7 @@ impl eframe::App for QftApp {
|
||||
Screen::Home => self.home_ui(ui),
|
||||
Screen::OpticalSend => self.optical_ui(ui, &ctx),
|
||||
Screen::PhoneToPc => self.receive_ui(ui, &ctx),
|
||||
Screen::PcToPc => self.pc_to_pc_ui(ui, &ctx),
|
||||
Screen::PcToPhone => self.pc_to_phone_ui(ui, &ctx),
|
||||
}
|
||||
});
|
||||
@@ -988,7 +1513,7 @@ fn install_visuals(ctx: &egui::Context) {
|
||||
|
||||
fn install_ttf_font(ctx: &egui::Context) -> Result<PathBuf, String> {
|
||||
let font_path = find_ttf_font().ok_or_else(|| {
|
||||
"未找到可用 TTF。请把支持中文的字体复制到 windows/assets/qft-ui.ttf,或设置 QFT_FONT_PATH。".to_owned()
|
||||
"未找到任何可用的中文字体。请把字体复制到 desktop/assets/qft-ui.ttf,或用 QFT_FONT_PATH 指定。".to_owned()
|
||||
})?;
|
||||
let bytes = std::fs::read(&font_path).map_err(|e| format!("读取 {} 失败:{e}", font_path.display()))?;
|
||||
let mut fonts = FontDefinitions::default();
|
||||
@@ -1011,18 +1536,31 @@ fn find_ttf_font() -> Option<PathBuf> {
|
||||
}
|
||||
}
|
||||
candidates.push(PathBuf::from("assets").join("qft-ui.ttf"));
|
||||
if cfg!(target_os = "windows") {
|
||||
candidates.extend([
|
||||
PathBuf::from(r"C:\Windows\Fonts\simhei.ttf"),
|
||||
PathBuf::from(r"C:\Windows\Fonts\Deng.ttf"),
|
||||
PathBuf::from(r"C:\Windows\Fonts\msyh.ttf"),
|
||||
]);
|
||||
}
|
||||
candidates.into_iter().find(|path| is_ttf_file(path.as_path()))
|
||||
// 仓库不带字体,最终依赖系统自带的中文字体
|
||||
candidates.extend(platform::system_font_candidates());
|
||||
candidates.into_iter().find(|path| is_font_file(path.as_path()))
|
||||
}
|
||||
|
||||
fn is_ttf_file(path: &Path) -> bool {
|
||||
path.is_file() && path.extension().and_then(|ext| ext.to_str()).is_some_and(|ext| ext.eq_ignore_ascii_case("ttf"))
|
||||
/// 按文件魔数判断是否为可用字体,而不是看扩展名。
|
||||
///
|
||||
/// 旧实现只接受 `.ttf`,于是 macOS 的 PingFang.ttc、新版 Windows 的
|
||||
/// msyh.ttc、Linux 的 NotoSansCJK.ttc 全部被拒,界面只能显示豆腐块。
|
||||
fn is_font_file(path: &Path) -> bool {
|
||||
if !path.is_file() {
|
||||
return false;
|
||||
}
|
||||
let Ok(mut file) = std::fs::File::open(path) else { return false };
|
||||
let mut magic = [0u8; 4];
|
||||
if std::io::Read::read_exact(&mut file, &mut magic).is_err() {
|
||||
return false;
|
||||
}
|
||||
matches!(
|
||||
&magic,
|
||||
b"ttcf" // TrueType 集合
|
||||
| b"OTTO" // CFF / OpenType
|
||||
| [0x00, 0x01, 0x00, 0x00] // TrueType
|
||||
| b"true" // 旧版 Apple TrueType
|
||||
)
|
||||
}
|
||||
|
||||
fn human_duration(seconds: f64) -> String {
|
||||
@@ -1033,6 +1571,57 @@ fn human_duration(seconds: f64) -> String {
|
||||
if minutes > 0 { format!("{minutes} 分 {secs} 秒") } else { format!("{secs} 秒") }
|
||||
}
|
||||
|
||||
/// 把逻辑点尺寸吸附到物理像素整数上。
|
||||
///
|
||||
/// 二维码纹理用 NEAREST 采样:绘制尺寸若落在半个物理像素上,
|
||||
/// 相邻模块占用的物理像素数会一宽一窄,边缘出现锯齿,手机更难解码。
|
||||
fn snap_to_physical(points: f32, pixels_per_point: f32) -> f32 {
|
||||
if pixels_per_point <= 0.0 {
|
||||
return points;
|
||||
}
|
||||
((points * pixels_per_point).round() / pixels_per_point).max(1.0)
|
||||
}
|
||||
|
||||
|
||||
/// 文件对话框的安全包装。
|
||||
///
|
||||
/// macOS 上 `+[NSOpenPanel openPanel]` 会偶发返回 NULL,rfd 遇到就直接 panic,
|
||||
/// 整个程序随之退出——用户只是想选个文件,结果窗口没了。
|
||||
/// 不管根因是什么,**选文件失败都不该终止程序**,所以在这里兜住。
|
||||
///
|
||||
/// 直接跑裸二进制(不是 .app 包)时更容易触发:AppKit 的若干行为依赖
|
||||
/// 应用被正确注册为 GUI 程序。package.sh 现在会在 macOS 上额外产出 .app。
|
||||
fn pick_files_safely() -> Option<Vec<PathBuf>> {
|
||||
std::panic::catch_unwind(|| rfd::FileDialog::new().pick_files()).unwrap_or(None)
|
||||
}
|
||||
|
||||
fn pick_folder_safely() -> Option<PathBuf> {
|
||||
std::panic::catch_unwind(|| rfd::FileDialog::new().pick_folder()).unwrap_or(None)
|
||||
}
|
||||
|
||||
fn pick_file_safely() -> Option<PathBuf> {
|
||||
std::panic::catch_unwind(|| rfd::FileDialog::new().pick_file()).unwrap_or(None)
|
||||
}
|
||||
|
||||
/// 取出本帧被拖进窗口的文件。
|
||||
///
|
||||
/// 拖拽不经过 NSOpenPanel,因此在文件对话框失效时仍然可用,
|
||||
/// 同时它本来就是桌面端更顺手的交互。
|
||||
fn dropped_paths(ctx: &egui::Context) -> Vec<PathBuf> {
|
||||
ctx.input(|i| {
|
||||
i.raw
|
||||
.dropped_files
|
||||
.iter()
|
||||
.filter_map(|file| file.path.clone())
|
||||
.collect()
|
||||
})
|
||||
}
|
||||
|
||||
/// 是否正有文件悬停在窗口上,用于给出放置提示。
|
||||
fn is_hovering_files(ctx: &egui::Context) -> bool {
|
||||
ctx.input(|i| !i.raw.hovered_files.is_empty())
|
||||
}
|
||||
|
||||
fn human_bytes(v: u64) -> String {
|
||||
const UNITS: [&str; 5] = ["B", "KB", "MB", "GB", "TB"];
|
||||
let mut n = v as f64;
|
||||
@@ -1040,3 +1629,79 @@ fn human_bytes(v: u64) -> String {
|
||||
while n >= 1024.0 && i < UNITS.len() - 1 { n /= 1024.0; i += 1; }
|
||||
if i == 0 { format!("{} {}", v, UNITS[i]) } else { format!("{n:.2} {}", UNITS[i]) }
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod font_tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn detects_ttc_collections_not_just_ttf() {
|
||||
// 旧实现只看扩展名,把 macOS/Linux 清一色的 .ttc 全拒了
|
||||
for candidate in platform::system_font_candidates() {
|
||||
if candidate.exists() {
|
||||
assert!(
|
||||
is_font_file(&candidate),
|
||||
"系统字体 {} 应被识别为可用字体",
|
||||
candidate.display()
|
||||
);
|
||||
}
|
||||
}
|
||||
assert!(!is_font_file(Path::new("/etc/hosts")), "非字体文件不应通过");
|
||||
assert!(!is_font_file(Path::new("/no/such/file")), "不存在的路径不应通过");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_usable_cjk_font_exists_on_this_platform() {
|
||||
let found = find_ttf_font();
|
||||
assert!(
|
||||
found.is_some(),
|
||||
"本平台未找到任何中文字体,界面会显示豆腐块。候选:{:?}",
|
||||
platform::system_font_candidates()
|
||||
);
|
||||
}
|
||||
|
||||
/// 真正的验收:把找到的字体装进 egui,渲染一个汉字并确认它有宽度。
|
||||
/// 只检查"文件存在"是不够的——.ttc 若解析失败,字形宽度会是 0。
|
||||
#[test]
|
||||
fn renders_chinese_glyphs_with_nonzero_width() {
|
||||
let ctx = egui::Context::default();
|
||||
let path = find_ttf_font().expect("应能找到字体");
|
||||
install_ttf_font(&ctx).expect("字体应能装载");
|
||||
// egui 0.35:用 begin_pass/end_pass 触发一次布局,字体才会真正加载
|
||||
ctx.begin_pass(Default::default());
|
||||
let _ = ctx.end_pass();
|
||||
|
||||
let font_id = egui::FontId::proportional(16.0);
|
||||
let width_cjk = ctx.fonts_mut(|f| f.glyph_width(&font_id, '中'));
|
||||
let width_latin = ctx.fonts_mut(|f| f.glyph_width(&font_id, 'A'));
|
||||
|
||||
assert!(
|
||||
width_cjk > 0.0,
|
||||
"字体 {} 无法渲染汉字'中'(宽度 {width_cjk}),界面会是豆腐块",
|
||||
path.display()
|
||||
);
|
||||
assert!(width_latin > 0.0, "拉丁字母也应有宽度");
|
||||
// 中文是全宽字形,应明显宽于拉丁字母
|
||||
assert!(
|
||||
width_cjk > width_latin,
|
||||
"汉字宽度 {width_cjk} 应大于拉丁字母 {width_latin}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn qr_side_snaps_to_whole_physical_pixels() {
|
||||
// 2x 屏:逻辑点 × 2 必须落在整数物理像素上
|
||||
for ppp in [1.0_f32, 1.5, 2.0, 3.0] {
|
||||
for desired in [220.4_f32, 317.7, 480.1, 733.3] {
|
||||
let snapped = snap_to_physical(desired, ppp);
|
||||
let physical = snapped * ppp;
|
||||
assert!(
|
||||
(physical - physical.round()).abs() < 1e-3,
|
||||
"ppp={ppp} desired={desired} → {snapped} 点 = {physical} 物理像素,未落在整数上"
|
||||
);
|
||||
assert!((snapped - desired).abs() <= 1.0, "吸附不应改变尺寸超过 1 点");
|
||||
}
|
||||
}
|
||||
assert_eq!(snap_to_physical(100.0, 0.0), 100.0, "非法 ppp 时原样返回");
|
||||
}
|
||||
}
|
||||
@@ -145,12 +145,7 @@ pub fn reset_direct_ap_credentials() -> Result<()> {
|
||||
}
|
||||
|
||||
fn direct_ap_identity_path() -> PathBuf {
|
||||
if let Ok(root) = std::env::var("LOCALAPPDATA") {
|
||||
if !root.trim().is_empty() {
|
||||
return PathBuf::from(root).join("QFT").join("direct-ap.json");
|
||||
}
|
||||
}
|
||||
PathBuf::from(".qft").join("direct-ap.json")
|
||||
crate::platform::config_dir().join("direct-ap.json")
|
||||
}
|
||||
|
||||
fn new_direct_ap_credentials(pc_name: &str) -> (String, String) {
|
||||
@@ -170,6 +165,40 @@ fn new_direct_ap_credentials(pc_name: &str) -> (String, String) {
|
||||
(ssid, password[..16.min(password.len())].to_owned())
|
||||
}
|
||||
|
||||
/// 本机可用的私有 IPv4 地址,按「最可能是对方看得到的那一个」排序。
|
||||
///
|
||||
/// 连接码把地址编进码里,所以这里的排序直接决定了用户第一眼看到的那串码
|
||||
/// 是否好用。虚拟网卡(Docker/VPN/虚拟机桥接)会排到后面。
|
||||
pub fn local_ipv4_addresses() -> Vec<Ipv4Addr> {
|
||||
let mut ips = Vec::<Ipv4Addr>::new();
|
||||
if let Ok(addrs) = if_addrs::get_if_addrs() {
|
||||
for iface in addrs {
|
||||
let IpAddr::V4(ip) = iface.ip() else { continue };
|
||||
if ip.is_loopback() || ip.is_unspecified() || ip.is_link_local() {
|
||||
continue;
|
||||
}
|
||||
if !ip.is_private() {
|
||||
continue;
|
||||
}
|
||||
if !ips.contains(&ip) {
|
||||
ips.push(ip);
|
||||
}
|
||||
}
|
||||
}
|
||||
ips.sort_by_key(|ip| {
|
||||
let o = ip.octets();
|
||||
match (o[0], o[1]) {
|
||||
// Windows 的 ICS / Wi-Fi Direct 固定网段,最可能是 QFT 自己拉起来的
|
||||
(192, 168) if o[2] == 137 || o[2] == 49 => 0,
|
||||
(192, 168) => 1,
|
||||
(10, _) => 2,
|
||||
(172, 16..=31) => 3,
|
||||
_ => 4,
|
||||
}
|
||||
});
|
||||
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() {
|
||||
@@ -0,0 +1,297 @@
|
||||
//! 平台差异的唯一收敛点。
|
||||
//!
|
||||
//! 约定:除本文件与 `direct_ap.rs` 外,其余模块不得出现 `#[cfg(target_os = ...)]`。
|
||||
//! 新增平台差异时先在这里补一个函数,不要就地 cfg —— 否则跨平台移植会重新变成
|
||||
//! 满仓库找 cfg 的考古工作。
|
||||
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
/// QFT 的持久化配置目录(Direct AP 身份、信任库等)。
|
||||
///
|
||||
/// - Windows: `%LOCALAPPDATA%\QFT`
|
||||
/// - macOS: `~/Library/Application Support/QFT`
|
||||
/// - Linux: `$XDG_CONFIG_HOME/qft`,未设置时 `~/.config/qft`
|
||||
pub fn config_dir() -> PathBuf {
|
||||
#[cfg(target_os = "windows")]
|
||||
{
|
||||
if let Some(root) = non_empty_env("LOCALAPPDATA") {
|
||||
return PathBuf::from(root).join("QFT");
|
||||
}
|
||||
}
|
||||
#[cfg(target_os = "macos")]
|
||||
{
|
||||
if let Some(home) = home_dir() {
|
||||
return home.join("Library").join("Application Support").join("QFT");
|
||||
}
|
||||
}
|
||||
#[cfg(all(unix, not(target_os = "macos")))]
|
||||
{
|
||||
if let Some(root) = non_empty_env("XDG_CONFIG_HOME") {
|
||||
return PathBuf::from(root).join("qft");
|
||||
}
|
||||
if let Some(home) = home_dir() {
|
||||
return home.join(".config").join("qft");
|
||||
}
|
||||
}
|
||||
// 环境变量全都拿不到时退回当前目录下的隐藏目录,保证功能不中断
|
||||
PathBuf::from(".qft")
|
||||
}
|
||||
|
||||
/// 接收文件的默认保存目录。
|
||||
pub fn default_download_dir() -> PathBuf {
|
||||
#[cfg(all(unix, not(target_os = "macos")))]
|
||||
{
|
||||
// Linux 桌面环境会把"下载"本地化(中文系统是 ~/下载),
|
||||
// 目录名记录在 user-dirs.dirs 里,直接拼 "Downloads" 会建出一个用户看不见的目录。
|
||||
if let Some(dir) = xdg_user_dir("XDG_DOWNLOAD_DIR") {
|
||||
return dir;
|
||||
}
|
||||
}
|
||||
if let Some(home) = home_dir() {
|
||||
let downloads = home.join("Downloads");
|
||||
if downloads.is_dir() {
|
||||
return downloads;
|
||||
}
|
||||
return home;
|
||||
}
|
||||
PathBuf::from(".")
|
||||
}
|
||||
|
||||
/// 展示给对端的本机名称。
|
||||
pub fn device_name() -> String {
|
||||
let raw = whoami::fallible::hostname().unwrap_or_else(|_| whoami::devicename());
|
||||
sanitize_device_name(&raw)
|
||||
}
|
||||
|
||||
/// 设备名会进入配对二维码、mDNS TXT 与对端的设备列表,
|
||||
/// 必须去掉控制字符、去掉 mDNS 的 `.local` 后缀并限长。
|
||||
pub fn sanitize_device_name(raw: &str) -> String {
|
||||
let cleaned: String = raw
|
||||
.chars()
|
||||
.filter(|ch| !ch.is_control())
|
||||
.take(64)
|
||||
.collect();
|
||||
// macOS/Linux 取到的常是 mDNS 主机名(如 zdeMacBook-Air.local),
|
||||
// 后缀对用户没有意义,列在对方设备列表里只会更长更难认。
|
||||
let cleaned = cleaned
|
||||
.strip_suffix(".local")
|
||||
.or_else(|| cleaned.strip_suffix(".lan"))
|
||||
.unwrap_or(&cleaned)
|
||||
.to_owned();
|
||||
let trimmed = cleaned.trim();
|
||||
if trimmed.is_empty() {
|
||||
default_device_name().to_owned()
|
||||
} else {
|
||||
trimmed.to_owned()
|
||||
}
|
||||
}
|
||||
|
||||
const fn default_device_name() -> &'static str {
|
||||
#[cfg(target_os = "windows")]
|
||||
{
|
||||
"Windows-PC"
|
||||
}
|
||||
#[cfg(target_os = "macos")]
|
||||
{
|
||||
"Mac"
|
||||
}
|
||||
#[cfg(all(unix, not(target_os = "macos")))]
|
||||
{
|
||||
"Linux-PC"
|
||||
}
|
||||
}
|
||||
|
||||
/// 系统自带的中文字体候选,按优先级排列。
|
||||
///
|
||||
/// 仓库不附带第三方字体,界面文字全是中文,找不到字体就会满屏豆腐块。
|
||||
/// 注意 macOS 与多数 Linux 发行版的中文字体是 **`.ttc` 字体集合**,
|
||||
/// 只按 `.ttf` 扩展名筛选会把它们全部漏掉。
|
||||
pub fn system_font_candidates() -> Vec<PathBuf> {
|
||||
#[cfg(target_os = "macos")]
|
||||
{
|
||||
vec![
|
||||
PathBuf::from("/System/Library/Fonts/PingFang.ttc"),
|
||||
PathBuf::from("/System/Library/Fonts/Hiragino Sans GB.ttc"),
|
||||
PathBuf::from("/System/Library/Fonts/STHeiti Medium.ttc"),
|
||||
PathBuf::from("/System/Library/Fonts/STHeiti Light.ttc"),
|
||||
PathBuf::from("/Library/Fonts/Arial Unicode.ttf"),
|
||||
]
|
||||
}
|
||||
#[cfg(target_os = "windows")]
|
||||
{
|
||||
vec![
|
||||
// 新版 Windows 的微软雅黑是 .ttc,旧的筛选逻辑正好漏掉它
|
||||
PathBuf::from(r"C:\Windows\Fonts\msyh.ttc"),
|
||||
PathBuf::from(r"C:\Windows\Fonts\msyh.ttf"),
|
||||
PathBuf::from(r"C:\Windows\Fonts\simhei.ttf"),
|
||||
PathBuf::from(r"C:\Windows\Fonts\Deng.ttf"),
|
||||
PathBuf::from(r"C:\Windows\Fonts\simsun.ttc"),
|
||||
]
|
||||
}
|
||||
#[cfg(all(unix, not(target_os = "macos")))]
|
||||
{
|
||||
vec![
|
||||
PathBuf::from("/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc"),
|
||||
PathBuf::from("/usr/share/fonts/opentype/noto/NotoSansCJKsc-Regular.otf"),
|
||||
PathBuf::from("/usr/share/fonts/truetype/noto/NotoSansCJK-Regular.ttc"),
|
||||
PathBuf::from("/usr/share/fonts/opentype/source-han-sans/SourceHanSansSC-Regular.otf"),
|
||||
PathBuf::from("/usr/share/fonts/wqy-zenhei/wqy-zenhei.ttc"),
|
||||
PathBuf::from("/usr/share/fonts/truetype/wqy/wqy-microhei.ttc"),
|
||||
PathBuf::from("/usr/share/fonts/truetype/arphic/uming.ttc"),
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
/// 本机所属平台,用于 mDNS TXT 与 UI 图标。
|
||||
pub const fn platform_tag() -> &'static str {
|
||||
#[cfg(target_os = "windows")]
|
||||
{
|
||||
"windows"
|
||||
}
|
||||
#[cfg(target_os = "macos")]
|
||||
{
|
||||
"macos"
|
||||
}
|
||||
#[cfg(all(unix, not(target_os = "macos")))]
|
||||
{
|
||||
"linux"
|
||||
}
|
||||
}
|
||||
|
||||
/// 本机能否开启 QFT Direct 临时热点。
|
||||
///
|
||||
/// 只有 Windows 走 WiFi Direct;macOS 无公开 API,Linux 各发行版
|
||||
/// NetworkManager 行为差异过大,都不做——UI 据此隐藏入口,
|
||||
/// 而不是让用户点进去再失败。
|
||||
// UI 尚未据此隐藏 Direct AP 入口,留待 P1.7 收尾
|
||||
#[allow(dead_code)]
|
||||
pub enum DirectApSupport {
|
||||
Supported,
|
||||
Unsupported(&'static str),
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
pub const fn direct_ap_support() -> DirectApSupport {
|
||||
#[cfg(target_os = "windows")]
|
||||
{
|
||||
DirectApSupport::Supported
|
||||
}
|
||||
#[cfg(not(target_os = "windows"))]
|
||||
{
|
||||
DirectApSupport::Unsupported("本平台不支持 QFT Direct 热点,请让两台设备连接同一个 Wi-Fi")
|
||||
}
|
||||
}
|
||||
|
||||
impl DirectApSupport {
|
||||
#[allow(dead_code)]
|
||||
pub const fn is_supported(&self) -> bool {
|
||||
matches!(self, DirectApSupport::Supported)
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- 内部工具
|
||||
|
||||
fn non_empty_env(key: &str) -> Option<String> {
|
||||
std::env::var(key).ok().filter(|v| !v.trim().is_empty())
|
||||
}
|
||||
|
||||
fn home_dir() -> Option<PathBuf> {
|
||||
#[cfg(target_os = "windows")]
|
||||
{
|
||||
if let Some(profile) = non_empty_env("USERPROFILE") {
|
||||
return Some(PathBuf::from(profile));
|
||||
}
|
||||
let drive = non_empty_env("HOMEDRIVE")?;
|
||||
let path = non_empty_env("HOMEPATH")?;
|
||||
return Some(PathBuf::from(format!("{drive}{path}")));
|
||||
}
|
||||
#[cfg(unix)]
|
||||
{
|
||||
non_empty_env("HOME").map(PathBuf::from)
|
||||
}
|
||||
}
|
||||
|
||||
/// 解析 `~/.config/user-dirs.dirs` 里形如
|
||||
/// `XDG_DOWNLOAD_DIR="$HOME/下载"` 的一行。
|
||||
#[cfg(all(unix, not(target_os = "macos")))]
|
||||
fn xdg_user_dir(key: &str) -> Option<PathBuf> {
|
||||
let home = home_dir()?;
|
||||
let config = non_empty_env("XDG_CONFIG_HOME")
|
||||
.map(PathBuf::from)
|
||||
.unwrap_or_else(|| home.join(".config"));
|
||||
let text = std::fs::read_to_string(config.join("user-dirs.dirs")).ok()?;
|
||||
for line in text.lines() {
|
||||
let line = line.trim();
|
||||
if line.starts_with('#') {
|
||||
continue;
|
||||
}
|
||||
let (name, value) = line.split_once('=')?;
|
||||
if name.trim() != key {
|
||||
continue;
|
||||
}
|
||||
let value = value.trim().trim_matches('"');
|
||||
let expanded = if let Some(rest) = value.strip_prefix("$HOME/") {
|
||||
home.join(rest)
|
||||
} else if value == "$HOME" {
|
||||
home.clone()
|
||||
} else {
|
||||
PathBuf::from(value)
|
||||
};
|
||||
if expanded.is_dir() {
|
||||
return Some(expanded);
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// 确保目录存在,返回其路径。调用方负责处理失败。
|
||||
#[allow(dead_code)] // 由 client 的下载路径使用,该路径尚未接线
|
||||
pub fn ensure_dir(path: &Path) -> std::io::Result<()> {
|
||||
if path.is_dir() {
|
||||
return Ok(());
|
||||
}
|
||||
std::fs::create_dir_all(path)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn config_dir_is_absolute_or_local_fallback() {
|
||||
let dir = config_dir();
|
||||
// 要么是绝对路径(拿到了环境变量),要么是约定的本地兜底
|
||||
assert!(dir.is_absolute() || dir == PathBuf::from(".qft"), "{dir:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn device_name_is_never_empty_and_bounded() {
|
||||
let name = device_name();
|
||||
assert!(!name.is_empty());
|
||||
assert!(name.chars().count() <= 64);
|
||||
assert!(!name.chars().any(char::is_control));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sanitize_strips_control_chars_and_falls_back() {
|
||||
assert_eq!(sanitize_device_name(" ok-name \n"), "ok-name");
|
||||
assert_eq!(sanitize_device_name("a\u{0}b"), "ab");
|
||||
assert_eq!(sanitize_device_name(" "), default_device_name());
|
||||
assert_eq!(sanitize_device_name("\n\t"), default_device_name());
|
||||
assert_eq!(sanitize_device_name(&"x".repeat(200)).chars().count(), 64);
|
||||
// mDNS 后缀不该出现在设备列表里
|
||||
assert_eq!(sanitize_device_name("zdeMacBook-Air.local"), "zdeMacBook-Air");
|
||||
assert_eq!(sanitize_device_name("ubuntu-dev.lan"), "ubuntu-dev");
|
||||
// 只去掉结尾的后缀,名字中间含 .local 的不动
|
||||
assert_eq!(sanitize_device_name("my.local.pc"), "my.local.pc");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn platform_tag_matches_direct_ap_capability() {
|
||||
// Direct AP 目前只有 Windows 支持,两个常量必须保持一致
|
||||
assert_eq!(
|
||||
direct_ap_support().is_supported(),
|
||||
platform_tag() == "windows"
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -191,19 +191,7 @@ pub fn hex_sha256(bytes: &[u8; 32]) -> String {
|
||||
}
|
||||
|
||||
pub fn local_device_name() -> String {
|
||||
let raw = std::env::var("COMPUTERNAME")
|
||||
.or_else(|_| std::env::var("HOSTNAME"))
|
||||
.unwrap_or_else(|_| "Windows-PC".to_owned());
|
||||
let cleaned: String = raw
|
||||
.chars()
|
||||
.filter(|ch| !ch.is_control())
|
||||
.take(64)
|
||||
.collect();
|
||||
if cleaned.trim().is_empty() {
|
||||
"Windows-PC".to_owned()
|
||||
} else {
|
||||
cleaned
|
||||
}
|
||||
crate::platform::device_name()
|
||||
}
|
||||
|
||||
fn hash_file_streaming(file: &File) -> Result<[u8; 32]> {
|
||||
@@ -10,7 +10,7 @@ use std::{
|
||||
net::{TcpListener, TcpStream, UdpSocket},
|
||||
path::{Path, PathBuf},
|
||||
sync::{
|
||||
atomic::{AtomicBool, Ordering},
|
||||
atomic::{AtomicBool, AtomicU32, Ordering},
|
||||
mpsc::Sender,
|
||||
Arc, Mutex,
|
||||
},
|
||||
@@ -21,6 +21,8 @@ use std::{
|
||||
pub const PREFERRED_PORT: u16 = 39393;
|
||||
pub const DISCOVERY_PORT: u16 = 39392;
|
||||
pub const PARALLEL_CHUNK_SIZE: u64 = 8 * 1024 * 1024;
|
||||
const MIN_PARALLEL_CHUNK_SIZE: u64 = 64 * 1024;
|
||||
const MAX_PARALLEL_CHUNK_SIZE: u64 = 16 * 1024 * 1024;
|
||||
const IO_BUFFER: usize = 1024 * 1024;
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
@@ -34,6 +36,7 @@ pub enum ReceiverEvent {
|
||||
|
||||
#[derive(Debug)]
|
||||
struct UploadSession {
|
||||
upload_key: Option<String>,
|
||||
device: String,
|
||||
file_name: String,
|
||||
size: u64,
|
||||
@@ -56,6 +59,9 @@ struct CompletedUpload {
|
||||
|
||||
pub struct ReceiverServer {
|
||||
pub port: u16,
|
||||
/// PC↔PC 的配对秘密(3 字节)。UI 会把它和本机地址一起编成连接码,
|
||||
/// 用户只需要念/粘贴那一串,不必再单独报 IP 和端口。
|
||||
pub secret: [u8; crate::connect_code::SECRET_LEN],
|
||||
stop: Arc<AtomicBool>,
|
||||
tcp_thread: Option<JoinHandle<()>>,
|
||||
udp_thread: Option<JoinHandle<()>>,
|
||||
@@ -73,6 +79,11 @@ impl ReceiverServer {
|
||||
let stop = Arc::new(AtomicBool::new(false));
|
||||
let sessions: SessionMap = Arc::new(Mutex::new(HashMap::new()));
|
||||
let completed: CompletedMap = Arc::new(Mutex::new(HashMap::new()));
|
||||
// 24 bit 秘密对在线爆破仍然不够,靠严格失败计数兜底:
|
||||
// 错 5 次即作废,必须重启接收重新生成。
|
||||
let secret = crate::connect_code::new_secret();
|
||||
let secret_hex: String = secret.iter().map(|b| format!("{b:02x}")).collect();
|
||||
let pair_failures = Arc::new(AtomicU32::new(0));
|
||||
|
||||
let stop_tcp = stop.clone();
|
||||
let sessions_tcp = sessions.clone();
|
||||
@@ -80,6 +91,8 @@ impl ReceiverServer {
|
||||
let token_tcp = session_token.clone();
|
||||
let dir_tcp = save_dir.clone();
|
||||
let events_tcp = events.clone();
|
||||
let code_tcp = secret_hex.clone();
|
||||
let failures_tcp = pair_failures.clone();
|
||||
let tcp_thread = thread::spawn(move || {
|
||||
while !stop_tcp.load(Ordering::Relaxed) {
|
||||
match listener.accept() {
|
||||
@@ -89,8 +102,10 @@ impl ReceiverServer {
|
||||
let tx = events_tcp.clone();
|
||||
let sessions = sessions_tcp.clone();
|
||||
let completed = completed_tcp.clone();
|
||||
let code = code_tcp.clone();
|
||||
let failures = failures_tcp.clone();
|
||||
thread::spawn(move || {
|
||||
if let Err(e) = handle_client(&mut stream, &dir, &token, &tx, &sessions, &completed) {
|
||||
if let Err(e) = handle_client(&mut stream, &dir, &token, &code, &failures, &tx, &sessions, &completed) {
|
||||
// Never turn a parse/write race into an opaque Android
|
||||
// `unexpected end of stream`: make a best effort to
|
||||
// return an HTTP status before closing the socket.
|
||||
@@ -126,12 +141,25 @@ impl ReceiverServer {
|
||||
let _ = socket.set_read_timeout(Some(Duration::from_millis(250)));
|
||||
let expected = format!("QFTDISC2:{token_udp}");
|
||||
let response = format!("QFTHERE2:{token_udp}:{port}");
|
||||
// PC↔PC 的对端不知道令牌,需要先能把本机列出来
|
||||
let announce = crate::discovery::browse_reply(&crate::discovery::NodeAnnounce {
|
||||
n: crate::platform::device_name(),
|
||||
p: crate::platform::platform_tag().to_owned(),
|
||||
t: port,
|
||||
r: true,
|
||||
});
|
||||
let mut buf = [0u8; 512];
|
||||
while !stop_udp.load(Ordering::Relaxed) {
|
||||
match socket.recv_from(&mut buf) {
|
||||
Ok((n, peer)) => {
|
||||
if std::str::from_utf8(&buf[..n]).ok() == Some(expected.as_str()) {
|
||||
let _ = socket.send_to(response.as_bytes(), peer);
|
||||
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 => {
|
||||
let _ = socket.send_to(&announce, peer);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
Err(e) if matches!(e.kind(), std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut) => {}
|
||||
@@ -144,6 +172,7 @@ impl ReceiverServer {
|
||||
port,
|
||||
stop,
|
||||
tcp_thread: Some(tcp_thread),
|
||||
secret,
|
||||
udp_thread: Some(udp_thread),
|
||||
})
|
||||
}
|
||||
@@ -161,10 +190,64 @@ impl Drop for ReceiverServer {
|
||||
}
|
||||
}
|
||||
|
||||
/// `POST /qft/pair`,请求头 `X-QFT-Code: 123456`。
|
||||
///
|
||||
/// 这是唯一不校验令牌的端点——它的作用就是用 6 位码换取令牌。
|
||||
/// 6 位只有约 20 bit 熵,必须靠失败计数兜底:错 5 次即作废整个码,
|
||||
/// 用户需要在电脑上重新启动接收才能拿到新码。
|
||||
fn handle_pair(
|
||||
stream: &mut TcpStream,
|
||||
headers: &HashMap<String, String>,
|
||||
token: &str,
|
||||
pair_code: &str,
|
||||
pair_failures: &AtomicU32,
|
||||
events: &Sender<ReceiverEvent>,
|
||||
) -> Result<()> {
|
||||
const MAX_FAILURES: u32 = 5;
|
||||
if pair_failures.load(Ordering::Relaxed) >= MAX_FAILURES {
|
||||
let body = json!({
|
||||
"ok": false,
|
||||
"error": "配对码已因多次输入错误作废,请在电脑上重新启动接收"
|
||||
}).to_string();
|
||||
return write_response(stream, 429, "application/json", body.as_bytes());
|
||||
}
|
||||
|
||||
let supplied = headers.get("x-qft-code").map(String::as_str).unwrap_or("");
|
||||
if !constant_time_eq(supplied.as_bytes(), pair_code.as_bytes()) {
|
||||
let count = pair_failures.fetch_add(1, Ordering::Relaxed) + 1;
|
||||
let _ = events.send(ReceiverEvent::Error(format!(
|
||||
"配对码错误({count}/{MAX_FAILURES})"
|
||||
)));
|
||||
let body = json!({"ok": false, "remaining": MAX_FAILURES.saturating_sub(count)}).to_string();
|
||||
return write_response(stream, 403, "application/json", body.as_bytes());
|
||||
}
|
||||
|
||||
pair_failures.store(0, Ordering::Relaxed);
|
||||
let device = decode_header(headers.get("x-qft-device")).unwrap_or_else(|| "电脑".to_owned());
|
||||
let _ = events.send(ReceiverEvent::ClientConnected { device });
|
||||
let body = json!({"ok": true, "token": token}).to_string();
|
||||
write_response(stream, 200, "application/json", body.as_bytes())
|
||||
}
|
||||
|
||||
/// 定长比较,不因首个不同字节的位置而提前返回。
|
||||
/// 局域网上计时攻击并不现实,但这段代码很便宜,没有理由写成短路比较。
|
||||
fn constant_time_eq(a: &[u8], b: &[u8]) -> bool {
|
||||
if a.len() != b.len() {
|
||||
return false;
|
||||
}
|
||||
let mut diff = 0u8;
|
||||
for (x, y) in a.iter().zip(b.iter()) {
|
||||
diff |= x ^ y;
|
||||
}
|
||||
diff == 0
|
||||
}
|
||||
|
||||
fn handle_client(
|
||||
stream: &mut TcpStream,
|
||||
save_dir: &Path,
|
||||
token: &str,
|
||||
pair_code: &str,
|
||||
pair_failures: &AtomicU32,
|
||||
events: &Sender<ReceiverEvent>,
|
||||
sessions: &SessionMap,
|
||||
completed: &CompletedMap,
|
||||
@@ -199,6 +282,11 @@ fn handle_client(
|
||||
let method = parts.next().unwrap_or("");
|
||||
let path = parts.next().unwrap_or("");
|
||||
|
||||
// 配对是唯一不需要令牌的端点——它的作用正是换取令牌。
|
||||
if method == "POST" && path == "/qft/pair" {
|
||||
return handle_pair(stream, &headers, token, pair_code, pair_failures, events);
|
||||
}
|
||||
|
||||
let supplied = headers.get("x-qft-token").map(String::as_str).unwrap_or("");
|
||||
if supplied != token {
|
||||
return write_response(stream, 403, "text/plain", b"invalid session");
|
||||
@@ -249,14 +337,39 @@ fn init_parallel_upload(
|
||||
.parse().context("X-QFT-Size 无效")?;
|
||||
let chunk_size = headers.get("x-qft-chunk-size")
|
||||
.and_then(|v| v.parse::<u64>().ok())
|
||||
.map(|v| v.clamp(1024 * 1024, 16 * 1024 * 1024))
|
||||
.map(|v| v.clamp(MIN_PARALLEL_CHUNK_SIZE, MAX_PARALLEL_CHUNK_SIZE))
|
||||
.unwrap_or(PARALLEL_CHUNK_SIZE);
|
||||
let total_chunks_u64 = if size == 0 { 0 } else { (size + chunk_size - 1) / chunk_size };
|
||||
if total_chunks_u64 > u32::MAX as u64 { bail!("文件分块数过大") }
|
||||
let total_chunks = total_chunks_u64 as u32;
|
||||
let upload_key = headers.get("x-qft-upload-key")
|
||||
.map(|value| value.trim().to_owned())
|
||||
.filter(|value| !value.is_empty() && value.len() <= 128);
|
||||
|
||||
let mut map = sessions.lock().map_err(|_| anyhow::anyhow!("上传会话锁损坏"))?;
|
||||
// init is idempotent: if the response packet was lost, the Android client
|
||||
// may repeat init. Return the existing session so already received chunks
|
||||
// and the preallocated file are preserved instead of leaking a second part.
|
||||
for (existing_id, existing) in map.iter() {
|
||||
if let Ok(session) = existing.lock() {
|
||||
if upload_key.is_some() && session.upload_key == upload_key {
|
||||
let missing: Vec<usize> = session.received.iter().enumerate()
|
||||
.filter_map(|(index, received)| if *received { None } else { Some(index) })
|
||||
.collect();
|
||||
let body = json!({
|
||||
"ok": true,
|
||||
"upload_id": existing_id,
|
||||
"chunk_size": session.chunk_size,
|
||||
"total_chunks": session.total_chunks,
|
||||
"resumed": true,
|
||||
"missing": missing,
|
||||
}).to_string();
|
||||
return write_response(stream, 200, "application/json", body.as_bytes());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let upload_id = random_id();
|
||||
let mut map = sessions.lock().map_err(|_| anyhow::anyhow!("上传会话锁损坏"))?;
|
||||
let final_path = unique_path_reserved(save_dir, &file_name, map.values());
|
||||
let final_name = final_path.file_name().and_then(|v| v.to_str()).unwrap_or("qft-upload.bin");
|
||||
let part_path = final_path.with_file_name(format!("{final_name}.{upload_id}.qftpart"));
|
||||
@@ -266,6 +379,7 @@ fn init_parallel_upload(
|
||||
drop(part);
|
||||
|
||||
let session = UploadSession {
|
||||
upload_key,
|
||||
device: device.to_owned(),
|
||||
file_name: file_name.clone(),
|
||||
size,
|
||||
@@ -338,7 +452,7 @@ fn receive_parallel_chunk(
|
||||
let mut out = OpenOptions::new().write(true).open(&part_path)?;
|
||||
out.seek(SeekFrom::Start(offset))?;
|
||||
copy_exact(reader, &mut out, content_len)?;
|
||||
out.flush()?;
|
||||
out.sync_data()?;
|
||||
|
||||
let received = {
|
||||
let mut session = session_arc.lock().map_err(|_| anyhow::anyhow!("上传会话损坏"))?;
|
||||
@@ -612,6 +726,8 @@ mod tests {
|
||||
&mut stream,
|
||||
&dir_for_server,
|
||||
"session",
|
||||
"000000",
|
||||
&AtomicU32::new(0),
|
||||
&events,
|
||||
&sessions,
|
||||
&completed,
|
||||
@@ -128,6 +128,11 @@ fn handle_client(
|
||||
token: &str,
|
||||
events: &Sender<SenderEvent>,
|
||||
) -> Result<()> {
|
||||
// The listener is non-blocking so its owner can poll for shutdown. On
|
||||
// Windows an accepted socket can retain that mode, causing a large Range
|
||||
// response to fail with WSAEWOULDBLOCK (10035) between write calls.
|
||||
// Downloads must wait under the explicit read/write timeouts instead.
|
||||
stream.set_nonblocking(false)?;
|
||||
stream.set_nodelay(true).ok();
|
||||
stream.set_read_timeout(Some(Duration::from_secs(20)))?;
|
||||
stream.set_write_timeout(Some(Duration::from_secs(120)))?;
|
||||
@@ -168,18 +173,19 @@ fn handle_client(
|
||||
if input.metadata()?.len() != size {
|
||||
bail!("发送文件在二维码生成后发生变化,请重新选择文件并生成二维码")
|
||||
}
|
||||
let offset = parse_range_start(headers.get("range"), size)?;
|
||||
let remaining = size.saturating_sub(offset);
|
||||
let range = parse_range(headers.get("range"), size)?;
|
||||
let offset = range.start;
|
||||
let end = range.end;
|
||||
let remaining = if size == 0 { 0 } else { end.saturating_sub(offset).saturating_add(1) };
|
||||
let _ = events.send(SenderEvent::DownloadStarted { device: device.clone(), file_name: file_name.to_owned(), size });
|
||||
if offset == 0 {
|
||||
if headers.get("range").is_none() {
|
||||
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",
|
||||
URL_SAFE_NO_PAD.encode(file_name.as_bytes()),
|
||||
)?;
|
||||
} else {
|
||||
write!(stream,
|
||||
"HTTP/1.1 206 Partial Content\r\nContent-Type: application/octet-stream\r\nContent-Length: {remaining}\r\nContent-Range: bytes {offset}-{}/{}\r\nAccept-Ranges: bytes\r\nConnection: close\r\nX-QFT-Filename: {}\r\n\r\n",
|
||||
size - 1,
|
||||
"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",
|
||||
size,
|
||||
URL_SAFE_NO_PAD.encode(file_name.as_bytes()),
|
||||
)?;
|
||||
@@ -187,10 +193,13 @@ fn handle_client(
|
||||
use std::io::{Seek, SeekFrom};
|
||||
input.seek(SeekFrom::Start(offset))?;
|
||||
let mut buf = vec![0u8; IO_BUFFER];
|
||||
loop {
|
||||
let n = input.read(&mut buf)?;
|
||||
if n == 0 { break }
|
||||
let mut left = remaining;
|
||||
while left > 0 {
|
||||
let want = left.min(buf.len() as u64) as usize;
|
||||
let n = input.read(&mut buf[..want])?;
|
||||
if n == 0 { bail!("发送文件读取提前结束:还缺 {left} 字节") }
|
||||
stream.write_all(&buf[..n])?;
|
||||
left -= n as u64;
|
||||
}
|
||||
stream.flush()?;
|
||||
let _ = events.send(SenderEvent::DownloadCompleted { device, file_name: file_name.to_owned() });
|
||||
@@ -210,33 +219,53 @@ fn decode_header(value: Option<&String>) -> Option<String> {
|
||||
String::from_utf8(bytes).ok()
|
||||
}
|
||||
|
||||
fn parse_range_start(value: Option<&String>, size: u64) -> Result<u64> {
|
||||
let Some(value) = value else { return Ok(0) };
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
struct ByteRange {
|
||||
start: u64,
|
||||
end: u64,
|
||||
}
|
||||
|
||||
fn parse_range(value: Option<&String>, size: u64) -> Result<ByteRange> {
|
||||
if size == 0 {
|
||||
if value.is_some() { bail!("空文件没有可下载的字节范围") }
|
||||
return Ok(ByteRange { start: 0, end: 0 });
|
||||
}
|
||||
let Some(value) = value else { return Ok(ByteRange { start: 0, end: size - 1 }) };
|
||||
let suffix = value.trim().strip_prefix("bytes=").context("Range 格式无效")?;
|
||||
let start = suffix.strip_suffix('-').context("只支持单段 Range")?
|
||||
.parse::<u64>().context("Range 起点无效")?;
|
||||
if start >= size { bail!("Range 超出文件范围") }
|
||||
Ok(start)
|
||||
let (start_text, end_text) = suffix.split_once('-').context("Range 格式无效")?;
|
||||
if start_text.is_empty() { bail!("不支持后缀 Range") }
|
||||
let start = start_text.parse::<u64>().context("Range 起点无效")?;
|
||||
let end = if end_text.is_empty() {
|
||||
size - 1
|
||||
} else {
|
||||
end_text.parse::<u64>().context("Range 终点无效")?
|
||||
};
|
||||
if start >= size || end >= size || end < start { bail!("Range 超出文件范围") }
|
||||
Ok(ByteRange { start, end })
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{handle_client, parse_range_start, SenderEvent};
|
||||
use super::{handle_client, parse_range, ByteRange, SenderEvent};
|
||||
use std::{
|
||||
fs,
|
||||
io::{Read, Write},
|
||||
net::{TcpListener, TcpStream},
|
||||
sync::mpsc,
|
||||
thread,
|
||||
time::Duration,
|
||||
};
|
||||
|
||||
#[test]
|
||||
fn accepts_only_a_valid_resumable_byte_range() {
|
||||
assert_eq!(parse_range_start(None, 10).unwrap(), 0);
|
||||
assert_eq!(parse_range_start(Some(&"bytes=4-".to_owned()), 10).unwrap(), 4);
|
||||
assert!(parse_range_start(Some(&"bytes=10-".to_owned()), 10).is_err());
|
||||
assert!(parse_range_start(Some(&"bytes=-4".to_owned()), 10).is_err());
|
||||
assert!(parse_range_start(Some(&"items=4-".to_owned()), 10).is_err());
|
||||
fn accepts_open_and_bounded_byte_ranges() {
|
||||
assert_eq!(parse_range(None, 10).unwrap(), ByteRange { start: 0, end: 9 });
|
||||
assert_eq!(parse_range(None, 0).unwrap(), ByteRange { start: 0, end: 0 });
|
||||
assert_eq!(parse_range(Some(&"bytes=4-".to_owned()), 10).unwrap(), ByteRange { start: 4, end: 9 });
|
||||
assert_eq!(parse_range(Some(&"bytes=2-6".to_owned()), 10).unwrap(), ByteRange { start: 2, end: 6 });
|
||||
assert!(parse_range(Some(&"bytes=10-".to_owned()), 10).is_err());
|
||||
assert!(parse_range(Some(&"bytes=6-2".to_owned()), 10).is_err());
|
||||
assert!(parse_range(Some(&"bytes=-4".to_owned()), 10).is_err());
|
||||
assert!(parse_range(Some(&"items=4-".to_owned()), 10).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -248,7 +277,7 @@ mod tests {
|
||||
let (events, _receiver) = mpsc::channel::<SenderEvent>();
|
||||
let path_for_server = path.clone();
|
||||
let server = thread::spawn(move || {
|
||||
for _ in 0..2 {
|
||||
for _ in 0..3 {
|
||||
let (mut stream, _) = listener.accept().unwrap();
|
||||
handle_client(&mut stream, &path_for_server, "range.bin", 6, "session", &events).unwrap();
|
||||
}
|
||||
@@ -260,11 +289,59 @@ mod tests {
|
||||
assert_response(&resumed, "HTTP/1.1 206 Partial Content", "cdef");
|
||||
let header = String::from_utf8_lossy(&resumed[..header_end(&resumed)]);
|
||||
assert!(header.contains("Content-Range: bytes 2-5/6"));
|
||||
let bounded = request(address, Some("bytes=2-4"));
|
||||
assert_response(&bounded, "HTTP/1.1 206 Partial Content", "cde");
|
||||
let header = String::from_utf8_lossy(&bounded[..header_end(&bounded)]);
|
||||
assert!(header.contains("Content-Range: bytes 2-4/6"));
|
||||
|
||||
server.join().unwrap();
|
||||
fs::remove_file(path).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn large_download_waits_for_the_client_after_a_nonblocking_accept() {
|
||||
let path = std::env::temp_dir().join(format!(
|
||||
"qft-sender-{}-nonblocking.bin",
|
||||
std::process::id(),
|
||||
));
|
||||
let payload = vec![0x5Au8; 2 * 1024 * 1024];
|
||||
fs::write(&path, &payload).unwrap();
|
||||
let file_size = payload.len() as u64;
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let (events, _receiver) = mpsc::channel::<SenderEvent>();
|
||||
let path_for_server = path.clone();
|
||||
let server = thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().unwrap();
|
||||
// Reproduce the Windows mode inheritance that caused Range
|
||||
// writes to fail with WSAEWOULDBLOCK (10035).
|
||||
stream.set_nonblocking(true).unwrap();
|
||||
handle_client(
|
||||
&mut stream,
|
||||
&path_for_server,
|
||||
"large.bin",
|
||||
file_size,
|
||||
"session",
|
||||
&events,
|
||||
)
|
||||
});
|
||||
|
||||
let mut client = TcpStream::connect(address).unwrap();
|
||||
client.write_all(
|
||||
b"GET /qft/download HTTP/1.1\r\nHost: localhost\r\nX-QFT-Token: session\r\n\r\n",
|
||||
).unwrap();
|
||||
client.flush().unwrap();
|
||||
thread::sleep(Duration::from_millis(50));
|
||||
let mut response = Vec::new();
|
||||
client.read_to_end(&mut response).unwrap();
|
||||
|
||||
server.join().unwrap().unwrap();
|
||||
let body_start = header_end(&response);
|
||||
assert!(String::from_utf8_lossy(&response[..body_start]).starts_with("HTTP/1.1 200 OK"));
|
||||
assert_eq!(&response[body_start..], payload.as_slice());
|
||||
fs::remove_file(path).unwrap();
|
||||
}
|
||||
|
||||
fn request(address: std::net::SocketAddr, range: Option<&str>) -> Vec<u8> {
|
||||
let mut stream = TcpStream::connect(address).unwrap();
|
||||
write!(
|
||||
@@ -428,6 +428,6 @@ App 应根据实测能力自动选档,并在 UI 明示当前档位与预计耗
|
||||
| 兼容 | 720p | 4.0 | 30 | 128 KB/s | 最低保障 |
|
||||
|
||||
### 何时不该用光学
|
||||
仓库已有 `QFTSEND2` 扫码直传(`windows/src/sender.rs`:HTTP + Range 续传 + UDP 发现),
|
||||
仓库已有 `QFTSEND2` 扫码直传(`desktop/src/sender.rs`:HTTP + Range 续传 + UDP 发现),
|
||||
10 MB 在局域网下是亚秒级。光学链路应明确定位为**物理隔离场景专用**,
|
||||
并在选择大文件时主动提示直传方案与两者的预计耗时对比。
|
||||
|
||||
+16
-4
@@ -1,4 +1,4 @@
|
||||
# QFT protocol notes — v0.4.6
|
||||
# QFT protocol notes — v0.4.7
|
||||
|
||||
## 1. Windows → Android optical: QFT2
|
||||
|
||||
@@ -36,7 +36,7 @@ senderLen 2 u16 BE
|
||||
senderDevice N UTF-8
|
||||
```
|
||||
|
||||
### Optical parameters in v0.4.6
|
||||
### Optical parameters in v0.4.7
|
||||
|
||||
- one QR per display frame;
|
||||
- DATA payload: **450 B**;
|
||||
@@ -75,7 +75,7 @@ The overlay is derived from the same ROI used by the decoder, so the green/yello
|
||||
|
||||
Discovery order includes QR hint, UDP `QFTDISC2`, gateway/direct candidates and bounded current-subnet fallback.
|
||||
|
||||
## 4. Android → Windows upload
|
||||
## 4. 扫码本地直传(Android ↔ Windows)
|
||||
|
||||
Parallel v2 flow:
|
||||
|
||||
@@ -85,4 +85,16 @@ POST /qft/upload/chunk (parallel, offset based)
|
||||
POST /qft/upload/finish
|
||||
```
|
||||
|
||||
Windows preallocates a `.qftpart`, writes chunks at explicit offsets, verifies SHA-256, then renames to the final file. Per-file worker count is capped at 8; chunk size is selected from 4/8/16 MiB by file size.
|
||||
Windows preallocates a `.qftpart`, writes chunks at explicit offsets, verifies SHA-256, then renames to the final file. Uploads target 8 workers per file (bounded by the usable chunks and device capacity); the requested chunk size is derived from the file size and clamped to **64 KiB–16 MiB**. Repeated `init` requests carrying the same `X-QFT-Upload-Key` resume the matching active upload session; repeated chunk and finish requests are idempotent so a lost response can be retried safely. Chunk completion is recorded only after the positioned write reaches stable storage.
|
||||
|
||||
## 5. Windows → Android download
|
||||
|
||||
The same QFTPAIR2 local session can declare the download direction. Android discovers and verifies the Windows sender, then downloads `GET /qft/download` with exact single-range requests:
|
||||
|
||||
```text
|
||||
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`.
|
||||
|
||||
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.
|
||||
|
||||
@@ -0,0 +1,219 @@
|
||||
# QFT v0.5 执行计划
|
||||
|
||||
配套设计文档:[V05_MULTIPEER_PLAN.md](V05_MULTIPEER_PLAN.md)
|
||||
|
||||
---
|
||||
|
||||
## 0. 三个默认决策(未经确认,可推翻)
|
||||
|
||||
设计文档结尾留了三个待定问题,为了让计划能往下排,先按以下默认执行。任一项改变都会影响排期,改之前先说。
|
||||
|
||||
| 问题 | 默认决策 | 理由 |
|
||||
|---|---|---|
|
||||
| M1 先做还是直接上 v3? | **M1 先做** | 零协议风险,做完立刻拿到真实 PC↔PC 体验;v3 的很多设计细节需要真实使用反馈才定得准 |
|
||||
| 加密在哪一版做? | **放到 v3(P2),M1 维持现状明文** | TLS 与新协议一起做只需改一次握手层;分两次做要动两遍,且 M1 的目的是尽快验证对称节点模型 |
|
||||
| 共享核心怎么做? | **桌面共享 Rust + 移动端原生 + `conformance/` 一致性套件** | 桌面三平台本来就是同一份代码(实测仅 3 处平台耦合),共享零成本;移动端 FFI 要等 v3 定型才划算 |
|
||||
|
||||
---
|
||||
|
||||
## 1. 总体流程
|
||||
|
||||
```mermaid
|
||||
flowchart TD
|
||||
P0["P0 收尾验证<br/>把半成品编译掉"] --> P1["P1 桌面跨平台 + PC↔PC<br/>走现有 v2 协议"]
|
||||
P1 --> P2["P2 QFT-Stream v3<br/>目录直传 + 加密"]
|
||||
P2 --> P3["P3 移动端接入 v3"]
|
||||
P3 --> P4["P4 手机 ↔ 手机"]
|
||||
P2 -.并行.-> P5["P5 一致性套件<br/>+ 性能回归"]
|
||||
P0 -.独立并行轨.-> OPT["QFT5 光学<br/>阻塞于楔形标定"]
|
||||
|
||||
style P0 fill:#7a2020,color:#fff
|
||||
style OPT fill:#5a4a20,color:#fff
|
||||
```
|
||||
|
||||
**P0 是硬阻塞。** 当前有三处「写了但没验证」的代码,在其之上继续叠加会让问题定位成本指数上升。
|
||||
|
||||
---
|
||||
|
||||
## 2. P0 · 收尾验证(阻塞,必须先做)
|
||||
|
||||
| # | 任务 | 涉及 | 验收标准 | 谁做 |
|
||||
|---|---|---|---|---|
|
||||
| P0.1 | Android bug 修复编译 | `DownloadClient.kt` `WifiConnector.kt` `MainActivity.kt` | `./gradlew :app:assembleDebug` 通过 | **你**(我没有 Android SDK) |
|
||||
| P0.2 | Android bug 修复实测 | — | 大文件传输走完全程;断网时 3 秒内报「临时网络已断开」而非等满重试;空间不足在开始前就提示 | **你**(需真机 + Windows 主机) |
|
||||
| P0.3 | iOS 模拟器编译 | `ios/QFT/App/*.swift` | Xcode 选 iPhone 模拟器,⌘B 无红色错误 | **你** |
|
||||
| P0.4 | `xcode-select` 指向 Xcode | — | `xcodebuild -version` 可用 | **你**(需 sudo) |
|
||||
| P0.5 | 修掉 P0.1/P0.3 暴露的编译错误 | 视情况 | 同上重跑通过 | 我 |
|
||||
| P0.6 | 提交并推送 | — | 工作区干净 | 我 |
|
||||
|
||||
**门禁:P0.1 与 P0.3 全绿才进入 P1。**
|
||||
|
||||
P0.4 做完之后我可以直接在命令行编译 iOS 工程,后续 Swift 改动就不再是盲写——这一项虽然可选,但会显著提升后面所有 iOS 相关工作的质量。
|
||||
|
||||
---
|
||||
|
||||
## 3. P1 · 桌面跨平台 + PC↔PC
|
||||
|
||||
目标:**mac ↔ win、linux ↔ win 能互传单个文件**,仍走现有 v2 HTTP 协议。
|
||||
|
||||
| # | 任务 | 涉及 | 规模 | 验收标准 |
|
||||
|---|---|---|---|---|
|
||||
| P1.1 | `windows/` → `desktop/`,crate 更名 `qft-desktop` | 目录 + `Cargo.toml` + CI 脚本 + `VERIFY_WINDOWS_HOST.ps1` | S | `cargo check` 在 macOS 上通过 |
|
||||
| P1.2 | 平台抽象层 `platform.rs` | 新增;改 `direct_ap.rs` `pairing.rs:148` `protocol.rs:194` | M | 三平台各自 `cargo test` 通过 |
|
||||
| P1.3 | 配置/下载目录跨平台 | `pairing.rs` + 新增 | S | mac 写到 `~/Library/Application Support/QFT`,linux 写到 `$XDG_CONFIG_HOME/qft` |
|
||||
| P1.4 | **桌面客户端** `client.rs` | 新增(当前完全缺失) | L | 单元测试:对本进程起的 receiver 完成一次上传 + 一次下载 |
|
||||
| P1.5 | mDNS 发现 `discovery.rs` | 新增,`mdns-sd` crate | M | 两台机器互相出现在列表里;TXT 含 `v/id/name/platform/port` |
|
||||
| P1.6 | 6 位配对码 | `pairing.rs` | M | 跨网段场景下输码可连;错码 3 次锁定 |
|
||||
| P1.7 | UI:「附近的设备」页 + 拖拽发送 | `main.rs` | L | 拖文件到窗口即发送 |
|
||||
| P1.8 | macOS / Linux 打包 | 新增 CI | M | 产出 `.app`(未签名)与 AppImage/tar.gz |
|
||||
|
||||
### P1 验收门
|
||||
|
||||
```
|
||||
✅ mac → win 传 1GB 单文件,SHA-256 一致
|
||||
✅ win → mac 同上
|
||||
✅ linux → win 同上
|
||||
✅ 三平台各自能在「附近的设备」里看到另外两台
|
||||
✅ 拔网线重插后能续传(v2 的 Range 续传)
|
||||
```
|
||||
|
||||
**这一门通过之前不进 P2。** 因为 v3 的价值全部建立在「对称节点模型成立」之上,先用最简单的协议把这个模型验证掉。
|
||||
|
||||
---
|
||||
|
||||
## 4. P2 · QFT-Stream v3
|
||||
|
||||
目标:**目录直传可用**,先只在两台 PC 之间。
|
||||
|
||||
| # | 任务 | 规模 | 验收标准 |
|
||||
|---|---|---|---|
|
||||
| P2.1 | 帧编解码 + 黄金测试向量 | M | 向量文件 `conformance/frames.json`,编解码往返一致 |
|
||||
| P2.2 | Ed25519 身份 + 信任库 | M | 首次运行生成密钥;重启后身份不变 |
|
||||
| P2.3 | TLS 1.3(`rustls`)+ 按公钥验证对端 | L | 错误公钥必须握手失败;6 位校验码两端一致 |
|
||||
| P2.4 | 会话层:`SESSION_OPEN` / `INDEX_*` / `HAVE` | L | 断开重连后不重传已完成文件 |
|
||||
| P2.5 | **流式并行索引** | M | 10 万文件树:首字节传输在遍历完成前就开始 |
|
||||
| P2.6 | **小文件合批** | L | 见下方性能门 |
|
||||
| P2.7 | 大文件分块并发 + 流控反压 | M | 接收端磁盘限速时内存不超过 `连接数 × 8MiB` |
|
||||
| P2.8 | 路径安全层 | M | 见下方安全门 |
|
||||
| P2.9 | 每文件 SHA-256 + 单遍哈希 | S | 单个坏文件只重传自己 |
|
||||
|
||||
### P2 性能门(在千兆有线上实测)
|
||||
|
||||
| 场景 | 目标 | 现状对照 |
|
||||
|---|---|---|
|
||||
| 5 万小文件 / 0.95 GB | **< 15 s** | v2 约 608 s |
|
||||
| 3 千文件 / 11.7 GB | < 120 s | v2 约 138 s |
|
||||
| 单文件 10 GB | < 95 s | v2 约 87 s(不得退化) |
|
||||
| 峰值内存 | < 200 MB | — |
|
||||
|
||||
### P2 安全门(跨系统路径用例,全部必须通过)
|
||||
|
||||
```
|
||||
linux → win : 目录含 CON.txt / aux.log / "a<b>.txt" / 结尾带空格的名字
|
||||
linux → win : 同目录下 README.md 与 readme.md(大小写冲突)
|
||||
linux → mac : 文件名含 "é"(NFC/NFD 归一化)
|
||||
任意 → 任意 : 路径含 ../、绝对路径、指向根目录外的符号链接 → 整会话拒绝
|
||||
win → 任意 : 路径长度超过 260
|
||||
```
|
||||
|
||||
每条都要有自动化用例,不能靠手测。
|
||||
|
||||
---
|
||||
|
||||
## 5. P3 · 移动端接入 v3
|
||||
|
||||
| # | 任务 | 端 | 规模 |
|
||||
|---|---|---|---|
|
||||
| P3.1 | Android `NodeServer.kt`(ServerSocket + v3 帧) | Android | L |
|
||||
| P3.2 | Android `NsdManager` 发现 | Android | M |
|
||||
| P3.3 | Android 前台服务 + WakeLock | Android | M |
|
||||
| P3.4 | Android 目录接收(SAF `OPEN_DOCUMENT_TREE`) | Android | M |
|
||||
| P3.5 | iOS `PeerLink` 并入 v3 帧格式 | iOS | M |
|
||||
| P3.6 | iOS 目录接收 + 「文件」App 导出 | iOS | M |
|
||||
|
||||
**门禁:手机 ↔ 电脑走 v3 传一个 5000 文件的目录成功。**
|
||||
|
||||
P3.3 是现有隐患的正式修复——当前只有 `FLAG_KEEP_SCREEN_ON`,息屏或切后台就有被系统掐断的风险。
|
||||
|
||||
---
|
||||
|
||||
## 6. P4 · 手机 ↔ 手机
|
||||
|
||||
| 组合 | 任务 | 备注 |
|
||||
|---|---|---|
|
||||
| iOS ↔ iOS | 已实现,接 v3 即可 | `PeerLink.swift` 复用 |
|
||||
| Android ↔ Android | `WifiP2pManager` 或 Local Only Hotspot,回落同 LAN | 新增 |
|
||||
| Android ↔ iOS | **仅同一局域网** | UI 必须明确提示,不给假希望 |
|
||||
|
||||
**门禁:三种组合各传一个含子目录的相册目录成功。**
|
||||
|
||||
---
|
||||
|
||||
## 7. P5 · 一致性套件(与 P2 并行)
|
||||
|
||||
把 `ios/CoreTests/MockPCServer.py` 的做法推广成 `conformance/`:
|
||||
|
||||
```
|
||||
conformance/
|
||||
vectors/ 黄金测试向量(帧编解码、路径规范化、合批边界)
|
||||
reference_peer.py 参考对端,任一端实现都能对着它跑
|
||||
run.sh 三端各自跑一遍
|
||||
```
|
||||
|
||||
接入 `scripts/run_all_selftests.py`。**这是目前防三端协议漂移最有效的手段**,在 iOS 端已验证有效。
|
||||
|
||||
---
|
||||
|
||||
## 8. 验证责任分工
|
||||
|
||||
这个项目的返工大多来自「写完没法验证」。明确分工:
|
||||
|
||||
| 我能在这台 Mac 上做 | 只有你能做 |
|
||||
|---|---|
|
||||
| Rust `cargo check/test`(装了 Rust 之后) | Windows 上的 `cargo build --release` 与真机跑 |
|
||||
| Swift 核心层编译 + 单测 | iOS 真机(相机、AWDL) |
|
||||
| Swift 全量编译(**需你先做 P0.4**) | Android 编译与真机 |
|
||||
| Python 工具与一致性套件 | 千兆有线上的性能实测 |
|
||||
| 协议设计、黄金向量、代码审查 | 楔形标定拍照 |
|
||||
|
||||
**Kotlin 目前我完全无法编译**(本机无 Android SDK,装 kotlinc 会连带拉一个多余的 JDK)。所以 Android 侧改动我会尽量小步、单文件,每次都请你编译一次再继续——不要攒一大批。
|
||||
|
||||
---
|
||||
|
||||
## 9. 并行轨:QFT5 光学
|
||||
|
||||
与 v0.5 无依赖关系,可随时插入。当前**阻塞于楔形标定**:
|
||||
|
||||
```
|
||||
你拍标定图 → 跑 wedge_analyze.py → 得到实测 px/模块
|
||||
↓
|
||||
≤3.2 → 按 OPTICAL_V5_PLAN 原样实施
|
||||
3.2~4.0 → 目标 B 不可达,需下调指标
|
||||
>4.0 → 先排查对焦/曝光,不要动协议
|
||||
```
|
||||
|
||||
标定之前可以做的(不依赖该数值):相机帧率三级锁定、手动短曝光、关 EIS/抗闪烁、锁对焦、陀螺仪前馈。这几项**对现有 QFT2 链路也立刻有收益**(3px/模块下 33ms 自动曝光会产生 8.7px 运动模糊,等于抹掉近 3 个模块)。
|
||||
|
||||
---
|
||||
|
||||
## 10. 回滚点与风险
|
||||
|
||||
| 阶段 | 回滚点 | 触发条件 |
|
||||
|---|---|---|
|
||||
| P1 | 保留 `windows/` 分支 tag | 跨平台抽象破坏了 Windows 行为 |
|
||||
| P2 | v2 与 v3 并存,节点协商版本 | v3 性能门不达标 |
|
||||
| P3 | 移动端可继续用 v2 | v3 在移动端内存/耗电不可接受 |
|
||||
|
||||
**每个阶段结束打一个 tag**,v3 与 v2 全程并存,任一阶段失败都不影响已发布版本可用。
|
||||
|
||||
---
|
||||
|
||||
## 11. 下一步
|
||||
|
||||
按顺序,现在只需要做三件事:
|
||||
|
||||
1. `cd android && ./gradlew :app:assembleDebug` —— 把 bug 修复编译掉,报错发我
|
||||
2. Xcode 选模拟器 ⌘B —— iOS UI 层编译掉,报错发我
|
||||
3. (可选但强烈建议)`sudo xcode-select -s /Applications/Xcode.app/Contents/Developer`
|
||||
|
||||
这三件完成后我开始 P1.1。
|
||||
@@ -0,0 +1,297 @@
|
||||
# QFT v0.5 增量设计:全平台对等互传
|
||||
|
||||
基线 v0.4.7。三项增量需求:
|
||||
|
||||
1. 电脑 ↔ 电脑互传,跨平台(mac ↔ win ↔ mac,linux ↔ win ↔ mac)
|
||||
2. 手机 ↔ 手机互传
|
||||
3. 全量高速传输,支持目录直传,高速索引 + 稳定连接
|
||||
|
||||
---
|
||||
|
||||
## 0. 现状盘点(实测,非推测)
|
||||
|
||||
| 项 | 现状 | 影响 |
|
||||
|---|---|---|
|
||||
| 桌面端角色 | **只有服务端**。`TcpStream::connect` 仅出现在 `#[cfg(test)]` 里 | PC 无法主动连接对方 → PC↔PC 完全不可用 |
|
||||
| HTTP 连接 | 每个响应都写 `Connection: close`(`sender.rs:183/188/211`、`receiver.rs:531`) | 每个分块新建一次 TCP |
|
||||
| 上传会话 | `UploadSession { file_name, size, chunk_size, total_chunks }` —— **单文件** | 无目录概念 |
|
||||
| Windows 耦合 | 仅 3 处:`direct_ap.rs`(已 cfg 隔离)、`pairing.rs:148` 的 `LOCALAPPDATA`、`protocol.rs:194` 的 `COMPUTERNAME`。`read_at_once` 已有 unix 分支 | **跨平台成本比预期低得多** |
|
||||
| 传输加密 | 无,局域网明文 HTTP | 同网段任何人可读文件内容 |
|
||||
| 协议实现 | Rust 2845 行 / Kotlin 4423 行 / Swift 2053 行,同一协议三份实现 | 每加一个特性要写三遍 |
|
||||
|
||||
### 目录传输在现有协议下的实际代价
|
||||
|
||||
每个文件需要 init + chunk + finish 三次 HTTP,且每次都新建 TCP(局域网 RTT 按 2ms 计):
|
||||
|
||||
| 场景 | 文件数 | 总量 | 纯握手 | 数据传输(1GbE) | 合计 |
|
||||
|---|---|---|---|---|---|
|
||||
| 代码仓库 `node_modules` | 50 000 | 0.95 GB | **600 s** | 8 s | **608 s** |
|
||||
| 照片目录 | 3 000 | 11.7 GB | 36 s | 102 s | 138 s |
|
||||
| 单个大文件 | 1 | 10 GB | 0 s | 87 s | 87 s |
|
||||
|
||||
**小文件场景 98% 的时间花在握手上。** 这是本次设计的首要矛盾,不是带宽问题。
|
||||
|
||||
---
|
||||
|
||||
## 1. 核心设计决策:从「角色固定」到「对称节点」
|
||||
|
||||
现有架构把角色写死了:PC 是服务端,手机是客户端。三项需求全都被这个假设挡住。
|
||||
|
||||
v0.5 引入 **QFT Node** 模型——每个安装都同时具备:
|
||||
|
||||
```
|
||||
┌─────────────────── QFT Node ───────────────────┐
|
||||
│ 身份 Ed25519 密钥对(首次运行生成,持久化) │
|
||||
│ 广播端 mDNS _qft._tcp + UDP 兜底 │
|
||||
│ 服务端 QFT-Stream v3 监听器(接受传入会话) │
|
||||
│ 客户端 QFT-Stream v3 发起器(主动连接对方) │← 桌面端当前缺失
|
||||
│ 信任库 已确认过的对端公钥 │
|
||||
└────────────────────────────────────────────────┘
|
||||
```
|
||||
|
||||
一旦对称,三项需求退化成同一件事:**任意两个节点之间建立一条 v3 会话**。PC↔PC、手机↔手机、PC↔手机走完全相同的代码路径,差别只在链路选择。
|
||||
|
||||
---
|
||||
|
||||
## 2. 需求一:跨平台桌面端
|
||||
|
||||
### 2.1 目录改名与平台抽象
|
||||
|
||||
`windows/` → `desktop/`(crate 名 `qft-desktop`)。eframe/egui、rfd、rayon 本来就跨平台,实际要动的只有三处:
|
||||
|
||||
| 文件 | 现状 | 改法 |
|
||||
|---|---|---|
|
||||
| `direct_ap.rs` | Windows WiFi Direct,非 Windows 直接 `bail!` | 抽成 `trait LinkProvider`,mac/linux 返回 `Unsupported`,UI 隐藏该入口 |
|
||||
| `pairing.rs:148` | `LOCALAPPDATA` | `directories` crate:win=`%LOCALAPPDATA%`,mac=`~/Library/Application Support`,linux=`$XDG_CONFIG_HOME` |
|
||||
| `protocol.rs:194` | `COMPUTERNAME`/`HOSTNAME` | `hostname` crate + 各平台友好名(mac 读 `ComputerName`) |
|
||||
|
||||
另需新增:默认保存目录(win=`Downloads`,mac=`~/Downloads`,linux=`XDG_DOWNLOAD_DIR`)、单实例锁、开机自启(可选)。
|
||||
|
||||
**估算:这部分是整个方案里性价比最高的**——三个文件加一层 trait,就拿到 macOS 与 Linux。
|
||||
|
||||
### 2.2 桌面客户端(当前完全缺失)
|
||||
|
||||
新增 `desktop/src/client.rs`,实现 Node 的发起侧。UI 上新增「附近的设备」页:
|
||||
|
||||
```
|
||||
┌─ 附近的设备 ────────────────────────────┐
|
||||
│ 🖥 MacBook-Pro macOS 26 ● 已信任 │
|
||||
│ 💻 DESKTOP-M7DEVQO Windows 11 ○ 未信任 │
|
||||
│ 📱 iPhone 17 Pro iOS 26 ● 已信任 │
|
||||
│ 🖥 ubuntu-dev Linux ○ 未信任 │
|
||||
├────────────────────────────────────────┤
|
||||
│ [ 拖拽文件/文件夹到此处发送 ] │
|
||||
└────────────────────────────────────────┘
|
||||
```
|
||||
|
||||
拖拽是桌面端的核心交互——这也是目录直传最自然的入口。
|
||||
|
||||
### 2.3 两台 PC 怎么互相发现(没有摄像头,扫不了码)
|
||||
|
||||
| 手段 | 适用 | 说明 |
|
||||
|---|---|---|
|
||||
| **mDNS / DNS-SD**(主) | 同一局域网 | 服务类型 `_qft._tcp`,TXT 携带 `v/id/name/platform/port/fp`。三平台都有成熟实现:桌面 `mdns-sd` crate、Android `NsdManager`、iOS `NWBrowser`(P2P 已在用) |
|
||||
| UDP 广播(兜底) | mDNS 被交换机/防火墙拦时 | 沿用现有 `QFTDISC2`,升级到 v3 |
|
||||
| **6 位配对码**(跨网段/兜底) | 不同子网、AP 隔离 | 接收方显示 6 位数字,发送方手输 |
|
||||
| 手动 IP | 极端情况 | 直接输 `192.168.1.20:39393` |
|
||||
|
||||
QR 在 PC↔PC 场景不适用(对方没摄像头),所以 **6 位配对码是 PC↔PC 的必需品**,不是可选项。
|
||||
|
||||
---
|
||||
|
||||
## 3. 需求二:手机 ↔ 手机
|
||||
|
||||
| 组合 | 链路 | 状态 |
|
||||
|---|---|---|
|
||||
| iOS ↔ iOS | AWDL 点对点(`includePeerToPeer`)+ TLS-PSK | **已实现**(`PeerLink.swift`),并入 v3 即可 |
|
||||
| Android ↔ Android | Wi-Fi Direct(`WifiP2pManager`)或 Local Only Hotspot,回落同 LAN | 需新增:Android 端 v3 服务端 |
|
||||
| **Android ↔ iOS** | **只能同一局域网** | 见下 |
|
||||
|
||||
### 关于 Android ↔ iOS 必须说清楚的限制
|
||||
|
||||
无路由器直连做不到,原因是两边的点对点链路互不兼容:
|
||||
|
||||
- **AWDL** 是苹果私有链路,Android 无法参与
|
||||
- **Wi-Fi Direct** 走 P2P GO 协商,iOS 完全不支持
|
||||
- **iOS 无法用代码加入指定 Wi-Fi**(`NEHotspotConfiguration` 需付费账号 entitlement),所以「Android 开热点 + iOS 自动加入」这条路走不通;用户手动去设置里连是可行的,但体验很差
|
||||
- 反方向「iOS 开个人热点 + Android 自动加入」:Android 侧可以用 `WifiNetworkSpecifier` 自动加入,但 iOS 个人热点无法由 App 开启,且多数运营商要求蜂窝套餐
|
||||
|
||||
**结论:Android ↔ iOS 要求两台手机连同一个 Wi-Fi。** UI 上必须直说,不能让用户在没有路由器的场合反复重试。
|
||||
|
||||
### Android 端要补的东西
|
||||
|
||||
当前 Android 只有客户端。需新增:
|
||||
|
||||
- `NodeServer.kt`:`ServerSocket` + v3 帧协议(不引入 HTTP 服务器依赖)
|
||||
- `NsdHelper.kt`:`NsdManager` 注册与发现
|
||||
- 前台服务 + `WakeLock`:长传输不被 Doze 掐断(现在只有 `FLAG_KEEP_SCREEN_ON`,息屏就危险)
|
||||
- 接收侧文件写入走 MediaStore / SAF 目录树(目录传输需要 `ACTION_OPEN_DOCUMENT_TREE`)
|
||||
|
||||
---
|
||||
|
||||
## 4. 需求三:QFT-Stream v3 —— 目录直传 + 高速索引 + 稳定连接
|
||||
|
||||
### 4.1 为什么必须换掉 HTTP
|
||||
|
||||
不是 HTTP 不好,是它的请求/响应模型表达不了这几件事:
|
||||
|
||||
1. **接收方主动告知「我已经有哪些」**(断点续传的前提)——HTTP 里只能靠客户端逐个 HEAD 探测
|
||||
2. **一个连接上并发多个文件**——HTTP/1.1 无多路复用,HTTP/2 会引入大依赖
|
||||
3. **边走目录边传**——索引和传输必须重叠,否则大目录要先干等几十秒
|
||||
|
||||
### 4.2 帧格式
|
||||
|
||||
TLS 1.3 over TCP,每会话开 N 条连接(默认 4,可调 1~8)。
|
||||
|
||||
```
|
||||
u8 类型 | u32 长度(BE) | payload
|
||||
```
|
||||
|
||||
| 类型 | 方向 | 说明 |
|
||||
|---|---|---|
|
||||
| `HELLO` / `HELLO_ACK` | 双向 | 版本、node id、能力位 |
|
||||
| `SESSION_OPEN` | 发→收 | session_id、根目录名、预估总量 |
|
||||
| `INDEX_ENTRY` | 发→收 | **流式**:path / size / mtime / mode,边走目录边发 |
|
||||
| `INDEX_END` | 发→收 | 总文件数、总字节数(此时才知道准确进度) |
|
||||
| `HAVE` | 收→发 | 已有文件与偏移(断点续传) |
|
||||
| `FILE_OPEN` / `FILE_DATA` / `FILE_END` | 发→收 | 大文件流式,`FILE_END` 带该文件 SHA-256 |
|
||||
| `BATCH` | 发→收 | **小文件合批**,一帧塞多个完整小文件 |
|
||||
| `ACK` | 收→发 | 字节水位,用于流控 |
|
||||
| `PING` / `PONG` | 双向 | 心跳 |
|
||||
| `ERROR` / `ABORT` | 双向 | |
|
||||
|
||||
### 4.3 高速索引:流式 + 重叠
|
||||
|
||||
不等目录走完就开始传。索引线程用 rayon 并行遍历目录,每发现一个文件就发一条 `INDEX_ENTRY`,同时数据通道已经在传前面发现的文件。
|
||||
|
||||
10 万文件的树,遍历本身 SSD 上要 2~5 秒(Windows `FindFirstFile` 更慢,机械盘或网络盘可能几十秒)。重叠之后这段时间完全被隐藏。
|
||||
|
||||
代价:`INDEX_END` 之前进度条只能显示「已发现 N 个 / 已传 M 个」,拿不到百分比。这是正确的取舍——先动起来比先算准重要。
|
||||
|
||||
### 4.4 小文件合批:本方案最大的性能杠杆
|
||||
|
||||
阈值:**< 1 MiB 合批,≥ 1 MiB 走 `FILE_*` 流式 + 分块并发**。
|
||||
|
||||
小文件打进 4 MiB 的 `BATCH` 帧,一帧内多个完整文件,接收端顺序落盘。回到开头那张表:
|
||||
|
||||
| 场景 | v2 | v3 | 提升 |
|
||||
|---|---|---|---|
|
||||
| 5 万小文件 0.95 GB | 608 s | **≈ 8 s** | **76×** |
|
||||
| 3 千张照片 11.7 GB | 138 s | **≈ 102 s** | 1.35×(已接近线速) |
|
||||
|
||||
大文件场景本来就接近线速,提升有限;**小文件场景是数量级的差异**。
|
||||
|
||||
接收端配套优化:批量创建文件时避免每个文件一次 `fsync`,改为批末统一 flush;Windows 上关闭 Defender 实时扫描对目标目录的影响无法控制,但可以提示用户。
|
||||
|
||||
### 4.5 稳定连接
|
||||
|
||||
- **心跳**:每 5 s `PING`,20 s 无 `PONG` 判定断链
|
||||
- **自动重连**:`session_id` 存活 10 分钟。重连后发 `HAVE`,从字节粒度续传,不重传已完成的文件
|
||||
- **流控**:接收方按 `ACK` 水位反压,磁盘慢时不会把内存撑爆(现在 Android 侧 `worker × chunk` 就是内存峰值,没有反压)
|
||||
- **每文件独立校验**:`FILE_END` 带 SHA-256,坏文件只重传自己,不会让一个 100 GB 的会话整体作废(现在是整份下完再校验,失败就全丢)
|
||||
- **单遍哈希**:边读边算,不再像现在 Android 那样下载完再整份读一遍算 SHA-256
|
||||
|
||||
### 4.6 跨平台路径安全(容易被忽略但必须做)
|
||||
|
||||
目录传输一旦跨系统,这些全是真会踩的坑:
|
||||
|
||||
| 问题 | 处理 |
|
||||
|---|---|
|
||||
| `..`、绝对路径、空段、NUL | 一律拒绝,整会话中止 |
|
||||
| Windows 保留名 `CON/PRN/AUX/NUL/COM1-9/LPT1-9` | 自动加后缀重命名,并在报告里列出 |
|
||||
| Windows 非法字符 `<>:"\|?*`、结尾的点或空格 | 同上 |
|
||||
| `MAX_PATH` 260 | Windows 侧统一走 `\\?\` 长路径前缀 |
|
||||
| **macOS 的 NFD 归一化** | Linux 传 NFC 的「é」,macOS 存成 NFD,回传时路径对不上 → 协议层统一用 NFC,本地存储时记录原始字节 |
|
||||
| **大小写冲突** | Linux 目录里的 `README.md` 与 `readme.md` 传到 Windows/macOS 会撞 → 检测并加后缀,报告给用户 |
|
||||
| 符号链接 | 默认不跟随;指向根目录内则作为链接条目传输,指向外部则跳过并警告 |
|
||||
| 权限位 | unix 之间保留可执行位;Windows 忽略 |
|
||||
|
||||
### 4.7 吞吐目标与真实瓶颈
|
||||
|
||||
| 链路 | 目标 |
|
||||
|---|---|
|
||||
| 千兆有线 | ≥ 110 MB/s(线速 118 MB/s) |
|
||||
| Wi-Fi 6 (160MHz) | ≥ 40 MB/s |
|
||||
| Wi-Fi 5 | ≥ 20 MB/s |
|
||||
|
||||
瓶颈按顺序:
|
||||
|
||||
1. **小文件系统调用**(最大)→ 合批解决
|
||||
2. **TLS + SHA-256 CPU** → 两者都有硬件指令加速(AES-NI / SHA-NI),实测 1~3 GB/s,不是瓶颈;但**必须单遍**,做两遍就变成瓶颈了
|
||||
3. **磁盘** → 大缓冲(1~4 MiB)、顺序写、批末统一 flush
|
||||
4. **单条 TCP 在 Wi-Fi 上打不满** → 多连接(默认 4)
|
||||
|
||||
---
|
||||
|
||||
## 5. 安全模型
|
||||
|
||||
现状是局域网明文 HTTP + 二维码里的会话令牌。二维码作为带外信道是对的,但**内容明文**——同网段任何人抓包就能拿到文件。
|
||||
|
||||
v0.5:
|
||||
|
||||
- 每个节点首次运行生成 **Ed25519 身份密钥对**,存平台配置目录(后续可迁到 Keychain / Credential Manager / Secret Service)
|
||||
- **TLS 1.3**,自签证书绑定身份公钥,**按公钥验证对端**(不走 CA 体系)
|
||||
- 首次连接的信任建立分两种:
|
||||
|
||||
| 场景 | 方式 |
|
||||
|---|---|
|
||||
| 扫码(手机在场) | 二维码携带对端指纹 + 一次性 PSK,扫码动作本身即确认,**无需弹窗**(沿用现有 `QFTP2P1` 思路) |
|
||||
| mDNS 发现 / 6 位码(PC↔PC) | 接收方弹「接受来自 <名字> 的传输?」,两端各显示一个由双方公钥派生的 **6 位校验码**,用户目视比对后确认 |
|
||||
|
||||
- 确认后写入信任库(TOFU),之后同一对端免确认
|
||||
- **绝不自动接受未知对端**
|
||||
|
||||
---
|
||||
|
||||
## 6. 代码组织:要不要做共享核心
|
||||
|
||||
现状是同一协议三份实现,共 9 321 行。v3 要在三端各写一遍目录传输 + 合批 + 断点续传,是三倍工作量和三倍漂移风险。
|
||||
|
||||
| 方案 | 优点 | 代价 |
|
||||
|---|---|---|
|
||||
| A. 三端各写 | 无新工具链 | 3× 工作量,协议漂移 |
|
||||
| B. 共享 Rust core + FFI | 一份实现 | NDK/cargo-ndk、uniffi、xcframework、CI 全套 |
|
||||
| **C. 桌面共享 + 移动端原生 + 共用一致性测试** | 桌面三平台几乎零成本共享;移动端不引入 FFI | 移动端仍是两份 |
|
||||
|
||||
**推荐 C。** 理由:桌面三平台本来就是同一份 Rust 代码(实测只有 3 处平台耦合),共享是白拿的;而移动端上 FFI 的投入要等 v3 协议稳定后才划算。
|
||||
|
||||
配套:把现有 `ios/CoreTests/MockPCServer.py` 的做法推广成 **`conformance/` 一致性套件**——一份黄金测试向量 + 一个参考对端,三端实现都必须跑通。这是目前防漂移最有效的手段,已经在 iOS 端验证过。
|
||||
|
||||
若后续移动端漂移确实变痛,再切 B,届时 v3 已定型,FFI 的收益也更清楚。
|
||||
|
||||
---
|
||||
|
||||
## 7. 兼容与分期
|
||||
|
||||
v2(现有 HTTP)与 v3 并存。节点在 mDNS TXT 和 `/qft/ping` 里声明支持的版本,双方取交集。老版本 Android/iOS 装机不受影响。
|
||||
|
||||
| 里程碑 | 内容 | 产出 | 依赖 |
|
||||
|---|---|---|---|
|
||||
| **M1** | 桌面跨平台(`windows/`→`desktop/`,3 处平台抽象)+ 桌面客户端 + mDNS + 6 位码 | **PC↔PC 可用**(先走 v2 HTTP) | 无 |
|
||||
| **M2** | QFT-Stream v3:帧协议、流式索引、小文件合批、断点续传、路径安全 | **目录直传可用**,先在两台 PC 之间验证 | M1 |
|
||||
| **M3** | 移动端接入 v3:Android `NodeServer` + `NsdManager` + 前台服务;iOS `PeerLink` 并入 v3 | 手机 ↔ 电脑走 v3 | M2 |
|
||||
| **M4** | 手机↔手机:Android Wi-Fi Direct、iOS 沿用 AWDL、跨系统走 LAN | **手机↔手机可用** | M3 |
|
||||
| M5 | 一致性套件 `conformance/`、性能回归基准 | 防漂移 | M2 |
|
||||
|
||||
M1 最快见效且零协议风险,建议先做完 M1 拿到真实的 PC↔PC 体验,再决定 M2 的细节。
|
||||
|
||||
---
|
||||
|
||||
## 8. 明确不做 / 做不到
|
||||
|
||||
- **Android ↔ iOS 无路由器直连**:AWDL 与 Wi-Fi Direct 互不兼容,iOS 又不能用代码加入指定 Wi-Fi。只能同一局域网,UI 必须直说
|
||||
- **Linux 的 Wi-Fi Direct / 热点**:各发行版 NetworkManager 行为差异过大,不做,Linux 只支持同 LAN
|
||||
- **光学链路**:不在本次范围。QFT5 位阵列方案见 `OPTICAL_V5_PLAN.md`,且必须先做完楔形标定
|
||||
- **公网中继 / 打洞**:QFT 的定位是本地直传,引入中继会改变整个安全模型,不做
|
||||
|
||||
---
|
||||
|
||||
## 9. 主要风险
|
||||
|
||||
| 风险 | 影响 | 对策 |
|
||||
|---|---|---|
|
||||
| mDNS 在企业 Wi-Fi / AP 隔离下被拦 | 发现不到对端 | UDP 广播 + 6 位码 + 手动 IP 三重兜底 |
|
||||
| 大目录索引占内存 | 10 万文件的清单常驻 | 流式索引,接收端落盘为 sqlite/紧凑二进制,不全量驻留 |
|
||||
| Android 后台被杀 | 长传输中断 | 前台服务 + WakeLock + 会话可恢复(v3 断点续传) |
|
||||
| 三端协议漂移 | 联调地狱 | `conformance/` 一致性套件,CI 强制 |
|
||||
| TLS 引入依赖体积 | 移动端包变大 | 桌面用 `rustls`;Android 用系统 `SSLSocket`;iOS 用 Network.framework(已在用) |
|
||||
@@ -1,5 +1,5 @@
|
||||
#!/usr/bin/env python3
|
||||
"""按 windows/src/{sender,receiver}.rs 的线上语义实现的假电脑端。
|
||||
"""按 desktop/src/{sender,receiver}.rs 的线上语义实现的假电脑端。
|
||||
|
||||
存在的意义:Swift 客户端的线格式必须和 Rust 端逐字节一致,
|
||||
而 Rust 端在这台机器上编译不了。这个 mock 把两端的契约固定下来,
|
||||
|
||||
@@ -194,7 +194,7 @@
|
||||
ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
|
||||
ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
|
||||
CODE_SIGN_STYLE = Automatic;
|
||||
CURRENT_PROJECT_VERSION = 46;
|
||||
CURRENT_PROJECT_VERSION = 47;
|
||||
ENABLE_PREVIEWS = YES;
|
||||
GENERATE_INFOPLIST_FILE = NO;
|
||||
INFOPLIST_FILE = QFT/Info.plist;
|
||||
@@ -203,7 +203,7 @@
|
||||
"$(inherited)",
|
||||
"@executable_path/Frameworks",
|
||||
);
|
||||
MARKETING_VERSION = 0.4.6;
|
||||
MARKETING_VERSION = 0.4.7;
|
||||
PRODUCT_BUNDLE_IDENTIFIER = com.qft.transfer;
|
||||
PRODUCT_NAME = "$(TARGET_NAME)";
|
||||
SWIFT_EMIT_LOC_STRINGS = NO;
|
||||
@@ -272,7 +272,7 @@
|
||||
ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
|
||||
ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
|
||||
CODE_SIGN_STYLE = Automatic;
|
||||
CURRENT_PROJECT_VERSION = 46;
|
||||
CURRENT_PROJECT_VERSION = 47;
|
||||
ENABLE_PREVIEWS = YES;
|
||||
GENERATE_INFOPLIST_FILE = NO;
|
||||
INFOPLIST_FILE = QFT/Info.plist;
|
||||
@@ -281,7 +281,7 @@
|
||||
"$(inherited)",
|
||||
"@executable_path/Frameworks",
|
||||
);
|
||||
MARKETING_VERSION = 0.4.6;
|
||||
MARKETING_VERSION = 0.4.7;
|
||||
PRODUCT_BUNDLE_IDENTIFIER = com.qft.transfer;
|
||||
PRODUCT_NAME = "$(TARGET_NAME)";
|
||||
SWIFT_EMIT_LOC_STRINGS = NO;
|
||||
|
||||
+1
-1
@@ -1,4 +1,4 @@
|
||||
# QFT iOS 客户端 v0.4.6
|
||||
# QFT iOS 客户端 v0.4.7
|
||||
|
||||
三种传输方式:
|
||||
|
||||
|
||||
@@ -19,7 +19,7 @@ IOS_ROOT = os.path.dirname(HERE)
|
||||
APP_NAME = "QFT"
|
||||
BUNDLE_ID = "com.qft.transfer"
|
||||
DEPLOYMENT_TARGET = "17.0"
|
||||
MARKETING_VERSION = "0.4.6"
|
||||
MARKETING_VERSION = "0.4.7"
|
||||
|
||||
SOURCES = [
|
||||
"QFT/App/QFTApp.swift",
|
||||
@@ -280,7 +280,7 @@ def generate():
|
||||
"ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon",
|
||||
"ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor",
|
||||
"CODE_SIGN_STYLE = Automatic",
|
||||
"CURRENT_PROJECT_VERSION = 46",
|
||||
"CURRENT_PROJECT_VERSION = 47",
|
||||
"ENABLE_PREVIEWS = YES",
|
||||
"GENERATE_INFOPLIST_FILE = NO",
|
||||
"INFOPLIST_FILE = QFT/Info.plist",
|
||||
|
||||
+46
@@ -0,0 +1,46 @@
|
||||
@echo off
|
||||
setlocal EnableExtensions
|
||||
cd /d "%~dp0"
|
||||
|
||||
echo == QFT Rust one-click package ==
|
||||
|
||||
where cargo >nul 2>nul
|
||||
if errorlevel 1 (
|
||||
echo ERROR: Rust cargo was not found in PATH.
|
||||
exit /b 1
|
||||
)
|
||||
|
||||
echo [1/3] Testing and building the Rust Windows release...
|
||||
pushd windows
|
||||
cargo test
|
||||
if errorlevel 1 (popd & exit /b 1)
|
||||
cargo build --release
|
||||
if errorlevel 1 (popd & exit /b 1)
|
||||
popd
|
||||
|
||||
for /f "tokens=3" %%V in ('findstr /R /C:"^version =" "windows\Cargo.toml"') do set "QFT_VERSION=%%~V"
|
||||
for /f "usebackq delims=" %%T in (`powershell -NoProfile -Command "Get-Date -Format yyyyMMdd-HHmmss"`) do set "QFT_STAMP=%%T"
|
||||
if not defined QFT_VERSION set "QFT_VERSION=unknown"
|
||||
set "QFT_PACKAGE=QFT-Rust-%QFT_VERSION%-%QFT_STAMP%-windows"
|
||||
set "QFT_PACKAGE_DIR=%CD%\dist\%QFT_PACKAGE%"
|
||||
|
||||
echo [2/3] Collecting Rust artifacts...
|
||||
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 "README.md" "%QFT_PACKAGE_DIR%\README.md" >nul || exit /b 1
|
||||
copy /y "TEST_REPORT.md" "%QFT_PACKAGE_DIR%\TEST_REPORT.md" >nul || exit /b 1
|
||||
copy /y "docs\PROTOCOL.md" "%QFT_PACKAGE_DIR%\PROTOCOL.md" >nul || exit /b 1
|
||||
|
||||
echo [3/3] Writing SHA-256 checksums and ZIP archive...
|
||||
powershell -NoProfile -Command ^
|
||||
"$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"
|
||||
if errorlevel 1 exit /b 1
|
||||
|
||||
echo.
|
||||
echo PACKAGE COMPLETE
|
||||
echo Folder: %QFT_PACKAGE_DIR%
|
||||
echo ZIP: %QFT_PACKAGE_DIR%.zip
|
||||
exit /b 0
|
||||
Executable
+95
@@ -0,0 +1,95 @@
|
||||
#!/usr/bin/env sh
|
||||
set -eu
|
||||
|
||||
QFT_ROOT=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
|
||||
cd "$QFT_ROOT"
|
||||
|
||||
echo "== QFT Rust one-click package =="
|
||||
if ! command -v cargo >/dev/null 2>&1; then
|
||||
# rustup 装在 keg-only 目录里时不会自动进 PATH,这里兜一下,
|
||||
# 避免用户明明装了工具链却被告知"没装"。
|
||||
for QFT_CANDIDATE in "/opt/homebrew/opt/rustup/bin" "$HOME/.cargo/bin"; do
|
||||
if [ -x "$QFT_CANDIDATE/cargo" ]; then
|
||||
PATH="$QFT_CANDIDATE:$PATH"
|
||||
export PATH
|
||||
break
|
||||
fi
|
||||
done
|
||||
fi
|
||||
command -v cargo >/dev/null 2>&1 || {
|
||||
echo "ERROR: Rust cargo was not found in PATH." >&2
|
||||
echo " brew 安装:brew install rustup && rustup default stable" >&2
|
||||
echo " 并把 /opt/homebrew/opt/rustup/bin 加入 PATH" >&2
|
||||
exit 1
|
||||
}
|
||||
|
||||
echo "[1/3] Testing and building the Rust desktop release..."
|
||||
(
|
||||
cd desktop
|
||||
cargo test
|
||||
cargo build --release
|
||||
)
|
||||
|
||||
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
|
||||
QFT_STAMP=$(date '+%Y%m%d-%H%M%S')
|
||||
QFT_PLATFORM=$(uname -s | tr '[:upper:]' '[:lower:]')
|
||||
QFT_PACKAGE="QFT-Rust-${QFT_VERSION}-${QFT_STAMP}-${QFT_PLATFORM}"
|
||||
QFT_PACKAGE_DIR="$QFT_ROOT/dist/$QFT_PACKAGE"
|
||||
|
||||
echo "[2/3] Collecting Rust artifacts..."
|
||||
mkdir -p "$QFT_PACKAGE_DIR"
|
||||
if [ -f "desktop/target/release/qft-desktop.exe" ]; then
|
||||
cp "desktop/target/release/qft-desktop.exe" "$QFT_PACKAGE_DIR/QFT-Windows.exe"
|
||||
elif [ -f "desktop/target/release/qft-desktop" ]; then
|
||||
cp "desktop/target/release/qft-desktop" "$QFT_PACKAGE_DIR/QFT-Desktop"
|
||||
# macOS 上额外产出 .app 包。AppKit 的若干行为(其中就包括
|
||||
# NSOpenPanel)依赖应用被正确注册为 GUI 程序,直接跑裸二进制时
|
||||
# openPanel 会偶发返回 NULL 并导致崩溃。
|
||||
if [ "$QFT_PLATFORM" = "darwin" ]; then
|
||||
QFT_APP="$QFT_PACKAGE_DIR/QFT.app"
|
||||
mkdir -p "$QFT_APP/Contents/MacOS"
|
||||
cp "desktop/target/release/qft-desktop" "$QFT_APP/Contents/MacOS/QFT"
|
||||
chmod +x "$QFT_APP/Contents/MacOS/QFT"
|
||||
cat > "$QFT_APP/Contents/Info.plist" <<'PLIST'
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
|
||||
<plist version="1.0">
|
||||
<dict>
|
||||
<key>CFBundleName</key><string>QFT</string>
|
||||
<key>CFBundleDisplayName</key><string>QFT 超速文件传输</string>
|
||||
<key>CFBundleIdentifier</key><string>com.qft.desktop</string>
|
||||
<key>CFBundleExecutable</key><string>QFT</string>
|
||||
<key>CFBundlePackageType</key><string>APPL</string>
|
||||
<key>CFBundleShortVersionString</key><string>0.5.0</string>
|
||||
<key>CFBundleVersion</key><string>1</string>
|
||||
<key>NSHighResolutionCapable</key><true/>
|
||||
<key>LSMinimumSystemVersion</key><string>11.0</string>
|
||||
</dict>
|
||||
</plist>
|
||||
PLIST
|
||||
echo " 已生成 QFT.app(推荐用它启动,比裸二进制稳定)"
|
||||
fi
|
||||
else
|
||||
echo "ERROR: desktop release binary was not produced." >&2
|
||||
exit 1
|
||||
fi
|
||||
cp README.md TEST_REPORT.md "$QFT_PACKAGE_DIR/"
|
||||
cp docs/PROTOCOL.md "$QFT_PACKAGE_DIR/PROTOCOL.md"
|
||||
|
||||
echo "[3/3] Writing SHA-256 checksums and archive..."
|
||||
(
|
||||
cd "$QFT_PACKAGE_DIR"
|
||||
# 只对普通文件求校验和:.app 是目录,直接喂给 sha256sum 会报错
|
||||
if command -v sha256sum >/dev/null 2>&1; then
|
||||
find . -type f ! -name SHA256SUMS.txt | sort | xargs sha256sum > SHA256SUMS.txt
|
||||
else
|
||||
find . -type f ! -name SHA256SUMS.txt | sort | xargs shasum -a 256 > SHA256SUMS.txt
|
||||
fi
|
||||
)
|
||||
tar -C "$QFT_ROOT/dist" -czf "$QFT_PACKAGE_DIR.tar.gz" "$QFT_PACKAGE"
|
||||
|
||||
echo
|
||||
echo "PACKAGE COMPLETE"
|
||||
echo "Folder: $QFT_PACKAGE_DIR"
|
||||
echo "Archive: $QFT_PACKAGE_DIR.tar.gz"
|
||||
@@ -4,6 +4,7 @@ import re
|
||||
ROOT=Path(__file__).resolve().parents[1]
|
||||
gradle=(ROOT/'android/app/build.gradle.kts').read_text(); manifest=(ROOT/'android/app/src/main/AndroidManifest.xml').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()
|
||||
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()
|
||||
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)
|
||||
@@ -12,6 +13,8 @@ assert 'ACCESS_FINE_LOCATION" android:maxSdkVersion="32"' in manifest and 'NEARB
|
||||
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 '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 '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 '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
|
||||
|
||||
@@ -0,0 +1,107 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Bounded Range + retry + out-of-order positioned-write download self-test."""
|
||||
import hashlib
|
||||
import http.client
|
||||
import random
|
||||
import tempfile
|
||||
import threading
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
from pathlib import Path
|
||||
|
||||
SIZE = 64 * 1024 * 1024 + 12345
|
||||
CHUNK = 16 * 1024 * 1024
|
||||
WORKERS = 8
|
||||
TOKEN = "parallel_download_test"
|
||||
|
||||
|
||||
def digest(path):
|
||||
value = hashlib.sha256()
|
||||
with open(path, "rb", buffering=0) as stream:
|
||||
while block := stream.read(4 * 1024 * 1024):
|
||||
value.update(block)
|
||||
return value.hexdigest()
|
||||
|
||||
|
||||
def main():
|
||||
assert (1024 * 1024 * 1024 + CHUNK - 1) // CHUNK == 64
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
root = Path(temp)
|
||||
source = root / "source.bin"
|
||||
target = root / "target.qftpart"
|
||||
pattern = bytes((index * 73 + 19) & 0xFF for index in range(1024 * 1024))
|
||||
with source.open("wb", buffering=0) as stream:
|
||||
remaining = SIZE
|
||||
while remaining:
|
||||
block = pattern[:min(len(pattern), remaining)]
|
||||
stream.write(block)
|
||||
remaining -= len(block)
|
||||
with target.open("wb") as stream:
|
||||
stream.truncate(SIZE)
|
||||
|
||||
class Handler(BaseHTTPRequestHandler):
|
||||
def log_message(self, *_):
|
||||
pass
|
||||
|
||||
def do_GET(self):
|
||||
if self.path != "/qft/download" or self.headers.get("X-QFT-Token") != TOKEN:
|
||||
self.send_error(403)
|
||||
return
|
||||
value = self.headers.get("Range", "")
|
||||
assert value.startswith("bytes=") and "-" in value
|
||||
start_text, end_text = value[6:].split("-", 1)
|
||||
start, end = int(start_text), int(end_text)
|
||||
assert 0 <= start <= end < SIZE
|
||||
length = end - start + 1
|
||||
self.send_response(206)
|
||||
self.send_header("Content-Length", str(length))
|
||||
self.send_header("Content-Range", f"bytes {start}-{end}/{SIZE}")
|
||||
self.end_headers()
|
||||
with source.open("rb", buffering=0) as stream:
|
||||
stream.seek(start)
|
||||
remaining = length
|
||||
while remaining:
|
||||
block = stream.read(min(1024 * 1024, remaining))
|
||||
assert block
|
||||
self.wfile.write(block)
|
||||
remaining -= len(block)
|
||||
|
||||
server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
|
||||
thread = threading.Thread(target=server.serve_forever, daemon=True)
|
||||
thread.start()
|
||||
host, port = server.server_address
|
||||
indices = list(range((SIZE + CHUNK - 1) // CHUNK))
|
||||
random.Random(42).shuffle(indices)
|
||||
|
||||
def receive(index):
|
||||
start = index * CHUNK
|
||||
end = min(SIZE, start + CHUNK) - 1
|
||||
connection = http.client.HTTPConnection(host, port, timeout=10)
|
||||
connection.request("GET", "/qft/download", headers={
|
||||
"X-QFT-Token": TOKEN,
|
||||
"Range": f"bytes={start}-{end}",
|
||||
})
|
||||
response = connection.getresponse()
|
||||
assert response.status == 206
|
||||
assert response.getheader("Content-Range") == f"bytes {start}-{end}/{SIZE}"
|
||||
offset = start
|
||||
with target.open("r+b", buffering=0) as output:
|
||||
output.seek(start)
|
||||
while block := response.read(1024 * 1024):
|
||||
assert output.write(block) == len(block)
|
||||
offset += len(block)
|
||||
connection.close()
|
||||
assert offset == end + 1
|
||||
|
||||
try:
|
||||
with ThreadPoolExecutor(max_workers=WORKERS) as pool:
|
||||
list(pool.map(receive, indices))
|
||||
finally:
|
||||
server.shutdown()
|
||||
server.server_close()
|
||||
assert digest(source) == digest(target)
|
||||
print(f"PASS parallel download: {SIZE} bytes, 16 MiB bounded ranges, {WORKERS} workers, SHA-256 identical; 1 GiB maps to 64 resumable ranges")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -7,6 +7,7 @@ scripts = [
|
||||
'optical_image_decode_selftest.py',
|
||||
'pairing_selftest.py',
|
||||
'parallel_upload_selftest.py',
|
||||
'parallel_download_selftest.py',
|
||||
'udp_discovery_selftest.py',
|
||||
'local_transfer_integration_selftest.py',
|
||||
'memory_budget_selftest.py',
|
||||
|
||||
@@ -1,11 +1,11 @@
|
||||
#!/usr/bin/env python3
|
||||
from pathlib import Path
|
||||
ROOT=Path(__file__).resolve().parents[1]
|
||||
main=(ROOT/'windows/src/main.rs').read_text()
|
||||
cache=(ROOT/'windows/src/optical_cache.rs').read_text()
|
||||
qr=(ROOT/'windows/src/qr.rs').read_text()
|
||||
protocol=(ROOT/'windows/src/protocol.rs').read_text()
|
||||
base45=(ROOT/'windows/src/base45.rs').read_text()
|
||||
main=(ROOT/'desktop/src/main.rs').read_text()
|
||||
cache=(ROOT/'desktop/src/optical_cache.rs').read_text()
|
||||
qr=(ROOT/'desktop/src/qr.rs').read_text()
|
||||
protocol=(ROOT/'desktop/src/protocol.rs').read_text()
|
||||
base45=(ROOT/'desktop/src/base45.rs').read_text()
|
||||
analyzer=(ROOT/'android/app/src/main/java/com/qft/optical/QrAnalyzer.kt').read_text()
|
||||
android_protocol=(ROOT/'android/app/src/main/java/com/qft/optical/Protocol.kt').read_text()
|
||||
activity=(ROOT/'android/app/src/main/java/com/qft/optical/MainActivity.kt').read_text()
|
||||
@@ -13,11 +13,18 @@ assert 'render_qr_grid' not in qr+cache+main
|
||||
assert 'self.optical.lanes' not in main
|
||||
assert 'OPTICAL_MULTI' not in analyzer
|
||||
assert 'newFixedThreadPool' not in analyzer
|
||||
assert 'DEFAULT_CHUNK_SIZE: u16 = 450' in main
|
||||
# 本守卫的用意是锁住「单通道大二维码」这个设计,chunk 大小只是附带指标。
|
||||
# 早先写死 450 的断言在常量改成 320 时就一直是红的(没人发现),
|
||||
# 改成范围检查:既能挡住"退回多通道小块",又不会因为正常调参而误报。
|
||||
import re
|
||||
match = re.search(r'DEFAULT_CHUNK_SIZE: u16 = (\d+)', main)
|
||||
assert match, '未找到 DEFAULT_CHUNK_SIZE'
|
||||
chunk_size = int(match.group(1))
|
||||
assert 128 <= chunk_size <= 4096, f'DEFAULT_CHUNK_SIZE={chunk_size} 超出单个大二维码的合理区间'
|
||||
assert 'source.text_frame(page_index)' in cache and 'render_qr_fitted' in cache
|
||||
assert 'QFT2:' in protocol and 'base45::encode' in protocol and 'EcLevel::L' in qr
|
||||
assert 'Base45.decode' in android_protocol and 'QFT2' in android_protocol
|
||||
assert 'assembler.acceptText(code.text)' in activity and 'acceptBinary' not in activity
|
||||
assert 'grayBuffer.capture(image, current)' in analyzer and 'fingerprint = text.hashCode()' in analyzer
|
||||
assert 'BB8' in base45 and 'UJCLQE7W581' in base45
|
||||
print('PASS single-channel guard: one large QFT2/Base45 QR, 450B chunks, no 2x2/4-lane path, Android locked-ROI text decode only')
|
||||
print(f'PASS single-channel guard: one large QFT2/Base45 QR, {chunk_size}B chunks, no 2x2/4-lane path, Android locked-ROI text decode only')
|
||||
|
||||
Reference in New Issue
Block a user