7 Commits

Author SHA1 Message Date
zhy200308 eae24000e9 优化IOS 2026-08-19 09:31:21 +08:00
zhy200308 7023062b45 docs: describe adaptive Android phone bands 2026-08-13 09:16:23 +08:00
zhy200308 b5014aea5b fix: keep modern Android phone links on fast bands 2026-08-13 09:15:11 +08:00
zhy200308 ccaaab7002 fix: add legacy-compatible Android phone link 2026-08-12 16:40:43 +08:00
zhy200308 2ff0741fff fix: connect older Android receivers to phone hotspots 2026-08-12 16:27:02 +08:00
zhy200308 04a2d7fb10 fix: adapt phone share QR to window size 2026-08-12 16:12:26 +08:00
zhy200308 d3e840ff0a feat: add Android to Android phone sharing 2026-08-12 15:17:34 +08:00
46 changed files with 5535 additions and 462 deletions
+48
View File
@@ -78,4 +78,52 @@
- [ ] real Android Gradle APK build in this container (SDK unavailable here) - [ ] real Android Gradle APK build in this container (SDK unavailable here)
- [ ] install/runtime matrix on physical Android 7→latest devices - [ ] install/runtime matrix on physical Android 7→latest devices
## iOS (v0.5.0)
Optical receive (PC screen → iPhone camera)
- [x] Swift QFT2 + Base45 + CRC32 frame decode, QFT1 legacy read
- [x] session assembler: dedupe, positioned writes, whole-file SHA-256, discard on mismatch
- [x] AVCaptureVideoDataOutput + Vision `VNDetectBarcodesRequest`
- [x] format picked for highest resolution among ≥60 FPS formats; fixed frame rate, HDR/stabilisation off
- [x] `alwaysDiscardsLateVideoFrames` (no stale camera frames)
- [x] centered search → ROI lock → progressive expansion → reacquire
- [x] periodic AF/AE at ROI center after lock
- [x] separate decoded/s and distinct-new-frame/s counters
- [ ] physical throughput matrix (30/45/60 FPS × device)
iPhone ↔ Windows dedicated network
- [x] accept Wi-Fi-only QFTPAIR2/QFTSEND2 (no endpoints, by design)
- [x] `NEHotspotConfiguration` join with `joinOnce`
- [x] honest fallback to guided manual join when the entitlement is unavailable
- [x] default gateway from `sysctl` route table; gateway-first host candidates
- [x] join verified by authenticated `/qft/ping`, not by the system callback
- [ ] physical Windows Wi-Fi Direct AP join (both entitlement paths)
iPhone ↔ Mac / Linux LAN
- [x] `QFTBROWSE3` node browse client
- [x] desktop connect code (Crockford Base32 + CRC-8), cross-verified against Rust vectors
- [x] `POST /qft/pair` code → token, no retry on failure
- [x] eight-way parallel Range download, 64 KiB–16 MiB adaptive chunks
- [x] `.qftpart` + completion ledger resume (parallel chunks land out of order)
- [x] explicit failure + single-stream fallback when the peer ignores Range
- [x] parallel upload (init/chunk/finish), fixed 4 MiB chunks × 6 workers
iPhone ↔ iPhone (AirDrop-style)
- [x] AWDL `includePeerToPeer` + TLS-PSK, key carried by the QR
- [x] multi-file queue (QFTP2P2); manifest digest in the QR, manifest itself on the wire
- [x] per-file SHA-256, partial files removed on any failure
- [ ] physical AWDL run with the router switched off
Compatibility
- [x] deployment target iOS 15.0 (iPhone 6s and later)
- [x] iOS 16/17 APIs behind `App/Compatibility.swift` forks
- [x] no `loadUnaligned` (Swift 5.7 runtime) in the core layer
- [x] 180 core-layer checks green via `swiftc` on macOS, no Xcode required
- [ ] Xcode build of the App layer (no Xcode on the authoring machine)
See `TEST_REPORT.md` and `TEST_RESULTS.txt` for executed evidence and limitations. See `TEST_REPORT.md` and `TEST_RESULTS.txt` for executed evidence and limitations.
+46
View File
@@ -16,6 +16,52 @@ v0.4.16 提供两套互不依赖的传输方式:
> v0.4.16 已完成协议、图像合成解码、ROI、双向并发传输、专用 Wi-Fi 快速发现、队列拖动稳定性和关键 Kotlin 源码测试。当前生成环境没有真实 Windows 显示器、Android 相机或 Wi‑Fi Direct 适配器,因此物理 30/45/60 FPS 和真实扫码配网仍需在你的设备上跑 `VERIFY_WINDOWS_HOST.ps1` 后做最终验收;详见 `TEST_REPORT.md`。 > v0.4.16 已完成协议、图像合成解码、ROI、双向并发传输、专用 Wi-Fi 快速发现、队列拖动稳定性和关键 Kotlin 源码测试。当前生成环境没有真实 Windows 显示器、Android 相机或 Wi‑Fi Direct 适配器,因此物理 30/45/60 FPS 和真实扫码配网仍需在你的设备上跑 `VERIFY_WINDOWS_HOST.ps1` 后做最终验收;详见 `TEST_REPORT.md`。
## v0.5.0-dev5:Android → Android 手机互传
当前开发版新增 Android 手机之间的扫码直传闭环:
- 发送手机选择多个文件、删除或拖动调整顺序,然后生成 `QFTPHONE2` 二维码;
- Android 8+ 优先创建系统 LocalOnlyHotspot,接收手机扫码后自动加入;
- Android 7 或临时热点不可用时,自动回落到两台手机当前同一 Wi-Fi;
- 二维码只携带一次性会话和网络身份,文件队列通过会话认证后读取,避免多文件让二维码过密;
- 每个文件复用现有最高 8 路 HTTP Range、断点位图和 SHA-256 校验,按发送队列顺序保存到 `Downloads/QFT`;
- 发送页面必须保持打开,返回首页会立即关闭发送服务和临时热点。
- 发送二维码按当前应用窗口的实际可用宽高动态生成并居中,手机、平板和分屏窗口都不会再被 `match_parent` 放大溢出。
- Android 7–9 接收端每次扫码都会用二维码中的新密码刷新临时 Wi-Fi 配置,不再复用同名热点的旧密码;Android 10+ 也只复用完整凭据一致的系统配网请求。
- 当高版本发送机只能创建旧设备不支持的纯 WPA3 热点时,接收端会跳过无效的系统搜索,并自动尝试二维码内经过认证的原局域网地址。
- 手机发送端建立自适应 Wi‑Fi Direct 接入点:Android 10+ 先使用自动频段争取 5 GHz 高速链路;12 秒未收到认证连接时,才以同一 SSID/密码切换至 2.4 GHz 兼容旧机,无需重新扫码。
- 手机互传使用顺序 Range 接收以规避部分 Android 7–9 文件提供器并发读取损坏,并在生成二维码前校验文件选择器报告的大小与实际内容一致。
此阶段只实现 Android → Android;Android ↔ iOS 尚未接入。
## v0.5.0:iOS 客户端全面接入
iOS 端补齐到与 Windows / macOS / Android 对齐的四条链路,**改动只在 `ios/` 目录内,
未触碰 `desktop/` 与 `android/` 的任何实现**:
- **光学接收(电脑 → iPhone)**:Swift 实现的 QFT2 + Base45 + CRC32 解码链路,
AVFoundation 取帧、Vision 解码、与 Android 同一套「居中搜索 → ROI 锁定 →
丢失逐级放大 → 重新搜索」状态机。文件数据只经过屏幕和摄像头,不碰任何网络。
- **iPhone ↔ Windows(专用网络)**:接受只带 Wi-Fi 凭据、不带地址的 QFT Direct 二维码;
有 HotspotConfiguration entitlement 时用 `NEHotspotConfiguration` 自动加入,
没有时显示 SSID/密码引导手动连接——不会假装成功。加入后从 `sysctl` 路由表
认出网关即电脑,判据是协议层 `/qft/ping` 握手成功而非系统回调。
- **iPhone ↔ Mac / Linux(局域网)**:既可扫二维码,也可直接输电脑上的连接码
(`QFTBROWSE3` 广播列出附近的电脑,`POST /qft/pair` 换令牌)。电脑下发改成
**8 路并行 Range + 断点账本**,对端不支持分段时自动回落单流。
- **iPhone ↔ iPhone(隔空)**:沿用 AWDL 点对点 + TLS-PSK,升级为
**多文件队列**(QFTP2P2)。清单不进二维码,只放摘要,扫码依然锁定
「你看到的就是你收到的」。
最低系统 **iOS 15.0**(iPhone 6s 及以后),与 Android 端 minSdk 24 覆盖的机型年代相当;
iOS 16/17 才有的 API 全部走 `ios/QFT/App/Compatibility.swift` 分叉。
详见 [`ios/README.md`](ios/README.md)。核心层 180 项检查可在没有 Xcode 的机器上直接跑:
```bash
./ios/CoreTests/run.sh
```
## v0.4.8:跨平台桌面端 + 电脑 ↔ 电脑互传 ## v0.4.8:跨平台桌面端 + 电脑 ↔ 电脑互传
### macOS:请用 QFT超速文件传输.app 启动,不要直接跑裸二进制 ### macOS:请用 QFT超速文件传输.app 启动,不要直接跑裸二进制
+2 -2
View File
@@ -12,8 +12,8 @@ android {
applicationId = "com.qft.optical" applicationId = "com.qft.optical"
minSdk = 24 minSdk = 24
targetSdk = 35 targetSdk = 35
versionCode = 23 versionCode = 28
versionName = "0.4.16" versionName = "0.5.0-dev5"
testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
} }
+1
View File
@@ -13,6 +13,7 @@
<uses-permission android:name="android.permission.NEARBY_WIFI_DEVICES" android:usesPermissionFlags="neverForLocation" /> <uses-permission android:name="android.permission.NEARBY_WIFI_DEVICES" android:usesPermissionFlags="neverForLocation" />
<uses-feature android:name="android.hardware.camera.any" android:required="true" /> <uses-feature android:name="android.hardware.camera.any" android:required="true" />
<uses-feature android:name="android.hardware.wifi" android:required="false" /> <uses-feature android:name="android.hardware.wifi" android:required="false" />
<uses-feature android:name="android.hardware.wifi.direct" android:required="false" />
<application <application
android:allowBackup="false" android:allowBackup="false"
@@ -150,7 +150,7 @@ object DownloadClient {
val expectedName = requireNotNull(pairing.fileName) val expectedName = requireNotNull(pairing.fileName)
val expectedSize = requireNotNull(pairing.fileSize) val expectedSize = requireNotNull(pairing.fileSize)
val expectedSha = requireNotNull(pairing.sha256) val expectedSha = requireNotNull(pairing.sha256)
val partial = partialFile(context, pairing.session) val partial = partialFile(context, pairing.session, pairing.downloadPath)
partial.parentFile?.let { if (!it.exists() && !it.mkdirs()) error("无法创建接收缓存目录") } partial.parentFile?.let { if (!it.exists() && !it.mkdirs()) error("无法创建接收缓存目录") }
if (partial.length() > expectedSize) discardTransferState(partial) if (partial.length() > expectedSize) discardTransferState(partial)
@@ -181,7 +181,7 @@ object DownloadClient {
Log.w(TAG, "sha mismatch round=${round + 1}/$VERIFY_ROUNDS expected=$expectedSha actual=$actual") Log.w(TAG, "sha mismatch round=${round + 1}/$VERIFY_ROUNDS expected=$expectedSha actual=$actual")
discardTransferState(partial) discardTransferState(partial)
if (round + 1 >= VERIFY_ROUNDS) { if (round + 1 >= VERIFY_ROUNDS) {
error("文件校验失败:重新完整下载后 SHA-256 仍不匹配,请让电脑重新生成二维码") error("文件校验失败:重新完整下载后 SHA-256 仍不匹配,请让发送端重新创建传输")
} }
onPhase("校验未通过,正在重新完整下载…") onPhase("校验未通过,正在重新完整下载…")
} }
@@ -379,7 +379,7 @@ object DownloadClient {
abortReason: () -> String?, abortReason: () -> String?,
) { ) {
val end = start + length - 1L val end = start + length - 1L
val conn = open(network, URL("$baseUrl/qft/download")) val conn = open(network, URL(baseUrl + pairing.downloadPath))
try { try {
conn.requestMethod = "GET" conn.requestMethod = "GET"
conn.connectTimeout = 8_000 conn.connectTimeout = 8_000
@@ -466,7 +466,7 @@ object DownloadClient {
onProgress: (received: Long, total: Long) -> Unit, onProgress: (received: Long, total: Long) -> Unit,
) { ) {
val requestedOffset = partial.length().coerceIn(0L, expectedSize) val requestedOffset = partial.length().coerceIn(0L, expectedSize)
val conn = open(network, URL("$baseUrl/qft/download")) val conn = open(network, URL(baseUrl + pairing.downloadPath))
try { try {
conn.requestMethod = "GET" conn.requestMethod = "GET"
conn.connectTimeout = 5_000 conn.connectTimeout = 5_000
@@ -482,7 +482,7 @@ object DownloadClient {
val resumed = code == HttpURLConnection.HTTP_PARTIAL val resumed = code == HttpURLConnection.HTTP_PARTIAL
if (code != HttpURLConnection.HTTP_OK && !resumed) { if (code != HttpURLConnection.HTTP_OK && !resumed) {
val message = try { conn.errorStream?.bufferedReader()?.use { it.readText().take(300) } } catch (_: Exception) { null } val message = try { conn.errorStream?.bufferedReader()?.use { it.readText().take(300) } } catch (_: Exception) { null }
error("电脑下载服务返回 HTTP $code${message?.let { ": $it" } ?: ""}") error("发送端下载服务返回 HTTP $code${message?.let { ": $it" } ?: ""}")
} }
// Older desktop binaries return 200 even with Range. Restart only // Older desktop binaries return 200 even with Range. Restart only
@@ -550,7 +550,12 @@ object DownloadClient {
onProgress(initial, expectedSize) onProgress(initial, expectedSize)
if (ledger.allComplete()) return if (ledger.allComplete()) return
val workers = ledger.totalChunks.coerceAtMost(RANGE_WORKERS).coerceAtLeast(1) // Some Android 7–9 DocumentsProvider implementations expose a stream
// that is individually seekable but corrupts data when the same URI is
// opened concurrently. Phone → phone therefore downloads its ranges in
// deterministic order on one worker. PC senders keep the 8-way path.
val workerLimit = if (pairing.downloadPath.startsWith("/qft/phone/download/")) 1 else RANGE_WORKERS
val workers = ledger.totalChunks.coerceAtMost(workerLimit).coerceAtLeast(1)
Log.i(TAG, "parallel start: chunks=${ledger.totalChunks}, workers=$workers, completed=$initial/$expectedSize") Log.i(TAG, "parallel start: chunks=${ledger.totalChunks}, workers=$workers, completed=$initial/$expectedSize")
val pool = Executors.newFixedThreadPool(workers) val pool = Executors.newFixedThreadPool(workers)
val next = AtomicInteger(0) val next = AtomicInteger(0)
@@ -658,7 +663,7 @@ object DownloadClient {
val offset = ledger.chunkOffset(index) val offset = ledger.chunkOffset(index)
val length = ledger.chunkLength(index) val length = ledger.chunkLength(index)
val end = offset + length - 1L val end = offset + length - 1L
val conn = open(network, URL("$baseUrl/qft/download")) val conn = open(network, URL(baseUrl + pairing.downloadPath))
try { try {
conn.requestMethod = "GET" conn.requestMethod = "GET"
conn.connectTimeout = 5_000 conn.connectTimeout = 5_000
@@ -672,7 +677,7 @@ object DownloadClient {
val code = conn.responseCode val code = conn.responseCode
if (code != HttpURLConnection.HTTP_PARTIAL) { if (code != HttpURLConnection.HTTP_PARTIAL) {
val message = try { conn.errorStream?.bufferedReader()?.use { it.readText().take(300) } } catch (_: Exception) { null } val message = try { conn.errorStream?.bufferedReader()?.use { it.readText().take(300) } } catch (_: Exception) { null }
error("电脑下载服务未返回并行 Range(HTTP $code)${message?.let { ": $it" } ?: ""}") error("发送端下载服务未返回 Range(HTTP $code)${message?.let { ": $it" } ?: ""}")
} }
val expectedRange = "bytes $offset-$end/$expectedSize" val expectedRange = "bytes $offset-$end/$expectedSize"
if (conn.getHeaderField("Content-Range") != expectedRange) { if (conn.getHeaderField("Content-Range") != expectedRange) {
@@ -783,9 +788,13 @@ object DownloadClient {
} }
} }
private fun partialFile(context: Context, session: String): File { private fun partialFile(context: Context, session: String, downloadPath: String): File {
val root = context.getExternalFilesDir("qft") ?: context.cacheDir val root = context.getExternalFilesDir("qft") ?: context.cacheDir
return File(root, "$session.qftpart") val suffix = MessageDigest.getInstance("SHA-256")
.digest(downloadPath.toByteArray(Charsets.UTF_8))
.take(6)
.joinToString("") { byte -> "%02x".format(byte.toInt() and 0xFF) }
return File(root, "$session-$suffix.qftpart")
} }
private fun createTarget(resolver: ContentResolver, name: String): DownloadTarget { private fun createTarget(resolver: ContentResolver, name: String): DownloadTarget {
@@ -21,6 +21,7 @@ import android.view.View
import android.view.ViewGroup import android.view.ViewGroup
import android.widget.Button import android.widget.Button
import android.widget.FrameLayout import android.widget.FrameLayout
import android.widget.ImageView
import android.widget.LinearLayout import android.widget.LinearLayout
import android.widget.ProgressBar import android.widget.ProgressBar
import android.widget.ScrollView import android.widget.ScrollView
@@ -48,6 +49,7 @@ class MainActivity : ComponentActivity() {
private val cameraExecutor = Executors.newSingleThreadExecutor() private val cameraExecutor = Executors.newSingleThreadExecutor()
private val transferExecutor = Executors.newSingleThreadExecutor() private val transferExecutor = Executors.newSingleThreadExecutor()
private val wifiConnector by lazy { WifiConnector(this) } private val wifiConnector by lazy { WifiConnector(this) }
private val phoneHotspot by lazy { PhoneHotspotController(this) }
private lateinit var assembler: SessionAssembler private lateinit var assembler: SessionAssembler
private var cameraProvider: ProcessCameraProvider? = null private var cameraProvider: ProcessCameraProvider? = null
@@ -91,6 +93,9 @@ class MainActivity : ComponentActivity() {
private var downloadStatusText: TextView? = null private var downloadStatusText: TextView? = null
@Volatile private var downloadRunning = false @Volatile private var downloadRunning = false
@Volatile private var uploadRunning = false @Volatile private var uploadRunning = false
@Volatile private var phoneShareRunning = false
private var phoneShareServer: PhoneShareServer? = null
private var phoneShareStatusText: TextView? = null
/** 非 null 表示当前传输应立刻中止(QFT 临时网络断开等)。 /** 非 null 表示当前传输应立刻中止(QFT 临时网络断开等)。
* 下载线程每读一个缓冲区就检查一次,避免在 readTimeout 上白等。 */ * 下载线程每读一个缓冲区就检查一次,避免在 readTimeout 上白等。 */
@Volatile private var transferAbortReason: String? = null @Volatile private var transferAbortReason: String? = null
@@ -102,8 +107,10 @@ class MainActivity : ComponentActivity() {
private val requestLegacyStorage = registerForActivityResult(ActivityResultContracts.RequestPermission()) { granted -> private val requestLegacyStorage = registerForActivityResult(ActivityResultContracts.RequestPermission()) { granted ->
val pair = pendingPair val pair = pendingPair
if (granted && pair?.direction == TransferDirection.DOWNLOAD_TO_PHONE) { val receivingFromNetwork = pair?.direction == TransferDirection.DOWNLOAD_TO_PHONE ||
connectPair(pair) pair?.direction == TransferDirection.PHONE_TO_PHONE
if (granted && receivingFromNetwork && pair != null) {
ensureWifiPermissionThenConnect(pair)
return@registerForActivityResult return@registerForActivityResult
} }
if (granted) requestScanner(pendingScannerMode) else showHome("Android 7~9 需要存储权限才能把光学接收文件保存到 Downloads/QFT") if (granted) requestScanner(pendingScannerMode) else showHome("Android 7~9 需要存储权限才能把光学接收文件保存到 Downloads/QFT")
@@ -119,6 +126,12 @@ class MainActivity : ComponentActivity() {
} }
} }
private val requestPhoneHotspotPermissions = registerForActivityResult(ActivityResultContracts.RequestMultiplePermissions()) { result ->
if (result.values.all { it }) startPhoneShare() else {
phoneShareStatusText?.text = "需要附近 Wi-Fi/位置权限才能自动创建手机直连网络"
}
}
private val pickFiles = registerForActivityResult(ActivityResultContracts.OpenMultipleDocuments()) { uris -> private val pickFiles = registerForActivityResult(ActivityResultContracts.OpenMultipleDocuments()) { uris ->
if (uploadRunning) { if (uploadRunning) {
sendStatusText?.text = "传输已经开始,当前队列已锁定" sendStatusText?.text = "传输已经开始,当前队列已锁定"
@@ -134,6 +147,7 @@ class MainActivity : ComponentActivity() {
sendStatusText?.text = "有 $unknown 个文件无法确定大小,已跳过" sendStatusText?.text = "有 $unknown 个文件无法确定大小,已跳过"
} else if (selectedFiles.isNotEmpty()) { } else if (selectedFiles.isNotEmpty()) {
sendStatusText?.text = "已选择 ${selectedFiles.size} 个文件,点击“开始传输”" sendStatusText?.text = "已选择 ${selectedFiles.size} 个文件,点击“开始传输”"
phoneShareStatusText?.text = "已选择 ${selectedFiles.size} 个文件,可以创建发送二维码"
} }
} }
@@ -154,6 +168,9 @@ class MainActivity : ComponentActivity() {
pairConsumed.set(false) pairConsumed.set(false)
wifiConnector.releaseHighPerfLock() wifiConnector.releaseHighPerfLock()
wifiConnector.release() wifiConnector.release()
phoneShareServer?.close()
phoneShareServer = null
phoneHotspot.close()
pendingPair = null pendingPair = null
connectedNetwork = null connectedNetwork = null
connectedBaseUrl = null connectedBaseUrl = null
@@ -161,6 +178,8 @@ class MainActivity : ComponentActivity() {
downloadStatusText = null downloadStatusText = null
selectedFiles.clear() selectedFiles.clear()
uploadRunning = false uploadRunning = false
phoneShareRunning = false
phoneShareStatusText = null
sendFilesContainer = null sendFilesContainer = null
sendAddButton = null sendAddButton = null
sendClearButton = null sendClearButton = null
@@ -189,11 +208,18 @@ class MainActivity : ComponentActivity() {
root.addView(space(16)) root.addView(space(16))
root.addView(modeCard( root.addView(modeCard(
title = "扫码直传", title = "扫码直传",
badge = "手机上传 / 电脑下发 · 自动配网 · 快速发现", badge = "电脑互传 / 手机互传 · 自动配网 · 快速发现",
body = "扫描电脑二维码后自动连接 QFT 本地网络:接收二维码会进入手机选文件上传;下发二维码会自动下载并保存到 Downloads/QFT。", body = "扫描电脑或另一台 Android 手机的二维码后自动连接 QFT 本地网络。电脑接收码会进入选文件上传;电脑/手机发送码会自动下载到 Downloads/QFT。",
buttonLabel = "扫描电脑二维码", buttonLabel = "扫描接收二维码",
) { requestScanner(ScannerMode.PAIR) }) ) { requestScanner(ScannerMode.PAIR) })
root.addView(space(16)) root.addView(space(16))
root.addView(modeCard(
title = "手机 → 手机",
badge = "Android 互传 · 临时热点 · 多文件队列",
body = "本机选择文件并创建二维码;另一台 Android 扫码后自动连接临时网络,按队列顺序并行接收。Android 7 或热点不可用时自动回落到当前同一 Wi-Fi。",
buttonLabel = "选择文件并发送",
) { showPhoneShareSetup() })
root.addView(space(16))
root.addView(modeCard( root.addView(modeCard(
title = "接收文件柜", title = "接收文件柜",
badge = "Downloads/QFT · 图片/视频/PDF/Office/压缩包等", badge = "Downloads/QFT · 图片/视频/PDF/Office/压缩包等",
@@ -202,7 +228,7 @@ class MainActivity : ComponentActivity() {
) { showReceivedFiles() }) ) { showReceivedFiles() })
root.addView(space(22)) root.addView(space(22))
root.addView(text("本机设备:$receiverDeviceLabel", 13f, MUTED)) root.addView(text("本机设备:$receiverDeviceLabel", 13f, MUTED))
root.addView(text("QFT v0.4.16 · Android 7+ 到最新", 12f, MUTED)) root.addView(text("QFT v0.5.0-dev5 · Android 7+ 到最新", 12f, MUTED))
setContentView(ScrollView(this).apply { setBackgroundColor(BG); addView(root) }) setContentView(ScrollView(this).apply { setBackgroundColor(BG); addView(root) })
} }
@@ -529,7 +555,7 @@ class MainActivity : ComponentActivity() {
} }
val back = button("‹ 返回").apply { setOnClickListener { showHome() } } val back = button("‹ 返回").apply { setOnClickListener { showHome() } }
top.addView(back) top.addView(back)
titleText = text(if (mode == ScannerMode.OPTICAL) "电脑 → 手机" else "扫码连接电脑", 19f, Color.WHITE, true) titleText = text(if (mode == ScannerMode.OPTICAL) "电脑 → 手机" else "扫码连接设备", 19f, Color.WHITE, true)
top.addView(titleText, LinearLayout.LayoutParams(0, -2, 1f).apply { marginStart = dp(10) }) top.addView(titleText, LinearLayout.LayoutParams(0, -2, 1f).apply { marginStart = dp(10) })
root.addView(top, FrameLayout.LayoutParams(-1, -2, Gravity.TOP)) root.addView(top, FrameLayout.LayoutParams(-1, -2, Gravity.TOP))
@@ -540,12 +566,12 @@ class MainActivity : ComponentActivity() {
} }
deviceText = text( deviceText = text(
if (mode == ScannerMode.OPTICAL) "接收设备:$receiverDeviceLabel\n发送设备:等待 QFT2 MANIFEST…" if (mode == ScannerMode.OPTICAL) "接收设备:$receiverDeviceLabel\n发送设备:等待 QFT2 MANIFEST…"
else "目标:等待 QFTPAIR2 配对二维码", else "目标:等待电脑或 Android 配对二维码",
14f, Color.WHITE 14f, Color.WHITE
) )
statusText = text( statusText = text(
if (mode == ScannerMode.OPTICAL) "让电脑的单个大二维码占取景框 50% 以上,识别后会自动锁定区域" if (mode == ScannerMode.OPTICAL) "让电脑的单个大二维码占取景框 50% 以上,识别后会自动锁定区域"
else "扫描 Windows“手机传电脑”页面上的二维码", else "扫描电脑或另一台 Android 显示的 QFT 配对二维码",
14f, MUTED 14f, MUTED
) )
progress = ProgressBar(this, null, android.R.attr.progressBarStyleHorizontal).apply { max = 1000; progress = 0 } progress = ProgressBar(this, null, android.R.attr.progressBarStyleHorizontal).apply { max = 1000; progress = 0 }
@@ -586,7 +612,7 @@ class MainActivity : ComponentActivity() {
runOnUiThread { runOnUiThread {
stopCamera() stopCamera()
showConnecting(pair, "二维码已识别,正在准备本地连接…") showConnecting(pair, "二维码已识别,正在准备本地连接…")
if (pair.direction == TransferDirection.DOWNLOAD_TO_PHONE && Build.VERSION.SDK_INT <= 28 && if (pair.direction in setOf(TransferDirection.DOWNLOAD_TO_PHONE, TransferDirection.PHONE_TO_PHONE) && Build.VERSION.SDK_INT <= 28 &&
checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED
) { ) {
requestLegacyStorage.launch(Manifest.permission.WRITE_EXTERNAL_STORAGE) requestLegacyStorage.launch(Manifest.permission.WRITE_EXTERNAL_STORAGE)
@@ -613,14 +639,33 @@ class MainActivity : ComponentActivity() {
val attempt = ++pairConnectionAttempt val attempt = ++pairConnectionAttempt
transferAbortReason = null transferAbortReason = null
connectedBaseUrl = null connectedBaseUrl = null
// 携带 Wi-Fi 身份的 QFT Direct 会无条件先连接那张专用网络。 val unsupportedHotspot = pair.direction == TransferDirection.PHONE_TO_PHONE &&
// 不再尝试二维码/电脑当前 LAN 地址;“当前局域网”仍是桌面端用户 pair.wifi?.let { !wifiConnector.canJoinAutomatically(it) } == true
// 明确选择的独立备用模式(wifi == null)。 val effectivePair = if (unsupportedHotspot && pair.endpoints.isNotEmpty()) {
connectViaWifi(pair, attempt) // A high-version sender/OEM may create a pure WPA3 LocalOnlyHotspot,
// which an old receiver physically cannot join. The QR also carries
// authenticated private LAN endpoints, so try those automatically
// instead of leaving the system Wi-Fi sheet searching forever.
pair.copy(wifi = null)
} else pair
// 携带可兼容 Wi-Fi 身份的 QFT Direct 会先连接专用网络;唯一例外是
// 接收硬件不支持二维码声明的纯 WPA3,此时才自动回落到经过同网段
// 过滤和会话认证的原局域网地址。
connectViaWifi(
effectivePair,
attempt,
if (unsupportedHotspot && effectivePair.wifi == null) {
"发送热点为 WPA3,当前旧设备不支持;正在自动尝试两机原有局域网…"
} else null,
)
} }
private fun connectViaWifi(pair: PairingPayload, attempt: Long) { private fun connectViaWifi(pair: PairingPayload, attempt: Long, initialMessage: String? = null) {
showConnecting(pair, pair.wifi?.let { "正在请求连接 ${it.ssid}…" } ?: "正在使用当前局域网探测电脑…") showConnecting(
pair,
initialMessage ?: pair.wifi?.let { "正在请求连接 ${it.ssid}…" }
?: "正在使用当前局域网探测发送设备…",
)
wifiConnector.connect( wifiConnector.connect(
pairing = pair, pairing = pair,
onStatus = { message -> runOnUiThread { onStatus = { message -> runOnUiThread {
@@ -655,8 +700,8 @@ class MainActivity : ComponentActivity() {
// 不使用二维码地址,也不猜测 192.168.137/49 网段。 // 不使用二维码地址,也不猜测 192.168.137/49 网段。
runOnUiThread { runOnUiThread {
updateConnectingStatus( updateConnectingStatus(
if (dedicatedWifi) "专用 Wi-Fi 已连接 · 正在并行认证网关和电脑…" if (dedicatedWifi) "专用 Wi-Fi 已连接 · 正在并行认证发送设备…"
else "网络已就绪 · 正在连接同网段电脑…" else "网络已就绪 · 正在连接同网段发送设备…"
) )
} }
val direct = if (dedicatedWifi) { val direct = if (dedicatedWifi) {
@@ -683,7 +728,7 @@ class MainActivity : ComponentActivity() {
runOnUiThread { runOnUiThread {
updateConnectingStatus( updateConnectingStatus(
if (dedicatedWifi) "专用网关正在初始化 · 仅在 QFT 子网内自动发现…" if (dedicatedWifi) "专用网关正在初始化 · 仅在 QFT 子网内自动发现…"
else "同网段地址未应答 · 正在 UDP 快速发现电脑…" else "同网段地址未应答 · 正在 UDP 快速发现发送设备…"
) )
} }
discovered = UploadClient.discoverUdp( discovered = UploadClient.discoverUdp(
@@ -699,8 +744,8 @@ class MainActivity : ComponentActivity() {
} }
runOnUiThread { runOnUiThread {
updateConnectingStatus( updateConnectingStatus(
if (discovered != null) "已通过 UDP 找到电脑 · 正在验证接收服务…" if (discovered != null) "已通过 UDP 找到发送设备 · 正在验证服务…"
else "仅在当前连接的 QFT 子网内并行查找电脑…" else "仅在当前连接的 QFT 子网内并行查找发送设备…"
) )
} }
} }
@@ -724,26 +769,34 @@ class MainActivity : ComponentActivity() {
val diagnosis = buildString { val diagnosis = buildString {
append( append(
if (dedicatedWifi) { if (dedicatedWifi) {
"QFT 专用 Wi-Fi 已连接,但在该专用网络的实际网关和子网内未找到服务。\n\n" "QFT 专用 Wi-Fi 已连接,但在该专用网络的实际网关和子网内未找到发送服务。\n\n"
} else { } else {
"Wi-Fi 已连接,但在当前局域网内未找到 QFT 服务。\n\n" "Wi-Fi 已连接,但在当前局域网内未找到 QFT 服务。\n\n"
} }
) )
append("手机侧:").append(wifiConnector.describeNetwork(network)).append("\n") append("手机侧:").append(wifiConnector.describeNetwork(network)).append("\n")
append("连接模式:") append("连接模式:")
append(if (dedicatedWifi) "QFT 专用 Wi-Fi(不使用二维码/电脑本地网卡地址)" else "当前局域网备用模式") append(if (dedicatedWifi) "QFT 专用 Wi-Fi(不使用二维码内的旧网卡地址)" else "当前局域网备用模式")
append("\n探测过的网关地址:") append("\n探测过的网关地址:")
append(gateways.joinToString("、").ifEmpty { "(无)" }) append(gateways.joinToString("、").ifEmpty { "(无)" })
append("\n子网扫描范围:").append(subnet.size).append(" 个地址\n\n") append("\n子网扫描范围:").append(subnet.size).append(" 个地址\n\n")
append("请对照检查:① Windows 上 QFT Direct 是否仍显示已就绪;") if (pair.direction == TransferDirection.PHONE_TO_PHONE) {
append("② 防火墙是否放行 qft-desktop.exe 的当前专用网络类型;") append("请对照检查:① 发送手机是否仍停留在二维码页面;")
append("③ 手机是否仍连接二维码内的 QFT 专用网络。") append("② 两台手机是否仍连接二维码内的 QFT 临时网络;")
append("③ 发送手机是否关闭了省电/热点。")
} else {
append("请对照检查:① Windows 上 QFT Direct 是否仍显示已就绪;")
append("② 防火墙是否放行 qft-desktop.exe 的当前专用网络类型;")
append("③ 手机是否仍连接二维码内的 QFT 专用网络。")
}
} }
showPairError(pair, diagnosis) showPairError(pair, diagnosis)
} else { } else {
connectedBaseUrl = base connectedBaseUrl = base
if (pair.direction == TransferDirection.DOWNLOAD_TO_PHONE) { if (pair.direction == TransferDirection.DOWNLOAD_TO_PHONE) {
startDownloadFromPc(pair, base) startDownloadFromPc(pair, base)
} else if (pair.direction == TransferDirection.PHONE_TO_PHONE) {
startDownloadsFromPhone(pair, base)
} else { } else {
showSendReady(pair, base) showSendReady(pair, base)
} }
@@ -756,7 +809,7 @@ class MainActivity : ComponentActivity() {
// onLost is recovered inside WifiConnector. onUnavailable is // onLost is recovered inside WifiConnector. onUnavailable is
// terminal (system/user rejected the retained request), so it // terminal (system/user rejected the retained request), so it
// is the only network callback that aborts an active transfer. // is the only network callback that aborts an active transfer.
if (pair.direction == TransferDirection.DOWNLOAD_TO_PHONE && downloadRunning) { if (pair.direction != TransferDirection.UPLOAD_TO_PC && downloadRunning) {
transferAbortReason = message transferAbortReason = message
downloadStatusText?.apply { downloadStatusText?.apply {
text = "QFT 本地网络已断开,正在结束当前下载请求…" text = "QFT 本地网络已断开,正在结束当前下载请求…"
@@ -771,12 +824,13 @@ class MainActivity : ComponentActivity() {
private fun showConnecting(pair: PairingPayload, message: String) { private fun showConnecting(pair: PairingPayload, message: String) {
val root = pageColumn() val root = pageColumn()
root.addView(text("正在连接电脑", 28f, Color.WHITE, true)) val peerKind = if (pair.direction == TransferDirection.PHONE_TO_PHONE) "发送手机" else "电脑"
root.addView(text("正在连接$peerKind", 28f, Color.WHITE, true))
root.addView(text(pair.pcName, 18f, ACCENT)) root.addView(text(pair.pcName, 18f, ACCENT))
root.addView(space(22)) root.addView(space(22))
root.addView(card().apply { root.addView(card().apply {
addView(text("配对信息", 15f, MUTED)) addView(text("配对信息", 15f, MUTED))
addView(text("电脑:${pair.pcName}", 16f, Color.WHITE), matchWrap(top = 8)) addView(text("设备:${pair.pcName}", 16f, Color.WHITE), matchWrap(top = 8))
addView(text("网络:${pair.wifi?.ssid ?: "当前局域网"}", 14f, Color.WHITE), matchWrap(top = 5)) addView(text("网络:${pair.wifi?.ssid ?: "当前局域网"}", 14f, Color.WHITE), matchWrap(top = 5))
addView(text("会话:${pair.session.take(10)}…", 12f, MUTED), matchWrap(top = 5)) addView(text("会话:${pair.session.take(10)}…", 12f, MUTED), matchWrap(top = 5))
}) })
@@ -816,6 +870,255 @@ class MainActivity : ComponentActivity() {
setContentView(ScrollView(this).apply { setBackgroundColor(BG); addView(root) }) setContentView(ScrollView(this).apply { setBackgroundColor(BG); addView(root) })
} }
private fun showPhoneShareSetup() {
phoneShareServer?.close()
phoneShareServer = null
phoneHotspot.close()
selectedFiles.clear()
phoneShareRunning = false
uploadRunning = false
val root = pageColumn()
root.addView(text("Android → Android", 28f, Color.WHITE, true))
root.addView(text("选择文件后创建一次性配对二维码", 15f, ACCENT))
root.addView(space(16))
root.addView(card().apply {
addView(text("发送队列", 17f, Color.WHITE, true))
sendFilesText = text("尚未选择文件", 14f, WARNING)
addView(sendFilesText, matchWrap(top = 8))
sendFilesContainer = LinearLayout(this@MainActivity).apply { orientation = LinearLayout.VERTICAL }
addView(sendFilesContainer, matchWrap(top = 6))
val actions = LinearLayout(this@MainActivity).apply { orientation = LinearLayout.HORIZONTAL }
sendAddButton = button("添加文件").apply { setOnClickListener { pickFiles.launch(arrayOf("*/*")) } }
sendClearButton = button("清空").apply {
setOnClickListener {
if (!phoneShareRunning) {
selectedFiles.clear()
renderSelectedFiles()
}
}
}
actions.addView(sendAddButton, LinearLayout.LayoutParams(0, dp(48), 1f).apply { marginEnd = dp(8) })
actions.addView(sendClearButton, LinearLayout.LayoutParams(dp(96), dp(48)))
addView(actions, matchWrap(top = 12))
addView(text("传输开始前可以删除或拖动排序;二维码创建后队列锁定。", 12f, MUTED), matchWrap(top = 8))
})
root.addView(space(14))
root.addView(card().apply {
phoneShareStatusText = text("先添加需要发送的文件", 14f, MUTED)
addView(phoneShareStatusText)
sendProgress = ProgressBar(this@MainActivity, null, android.R.attr.progressBarStyleHorizontal).apply {
max = 1000
progress = 0
}
addView(sendProgress, LinearLayout.LayoutParams(-1, dp(9)).apply { topMargin = dp(12) })
sendButton = button("创建发送二维码").apply {
isEnabled = false
setOnClickListener { ensurePhoneHotspotPermissionThenStart() }
}
addView(sendButton, matchWrap(top = 12))
})
root.addView(space(14))
root.addView(button("返回首页").apply { setOnClickListener { showHome() } })
setContentView(ScrollView(this).apply { setBackgroundColor(BG); addView(root) })
renderSelectedFiles()
}
private fun ensurePhoneHotspotPermissionThenStart() {
val required = if (Build.VERSION.SDK_INT >= 33) {
arrayOf(Manifest.permission.NEARBY_WIFI_DEVICES)
} else {
arrayOf(Manifest.permission.ACCESS_FINE_LOCATION)
}
val missing = required.filter { checkSelfPermission(it) != PackageManager.PERMISSION_GRANTED }
if (missing.isEmpty()) startPhoneShare() else requestPhoneHotspotPermissions.launch(missing.toTypedArray())
}
private fun startPhoneShare() {
if (phoneShareRunning || selectedFiles.isEmpty()) return
phoneShareRunning = true
uploadRunning = true // Reuse the queue lock and drag/remove guards.
sendButton?.isEnabled = false
sendAddButton?.isEnabled = false
sendClearButton?.isEnabled = false
phoneShareStatusText?.text = "正在读取文件并计算完整性校验…"
val files = selectedFiles.toList()
val sessionBytes = ByteArray(24).also { java.security.SecureRandom().nextBytes(it) }
val session = Base64Url.encode(sessionBytes)
transferExecutor.execute {
try {
val server = PhoneShareServer.create(
resolver = contentResolver,
session = session,
deviceName = receiverDeviceLabel,
selected = files,
onHashProgress = { done, total, name -> runOnUiThread {
sendProgress?.progress = if (total == 0) 0 else done * 1000 / total
phoneShareStatusText?.text = if (done >= total) "文件清单已就绪,正在创建手机直连网络…"
else "正在校验 ${done + 1}/$total:$name"
} },
onPeer = { peer -> runOnUiThread {
phoneHotspot.markPeerAuthenticated()
phoneShareStatusText?.text = "$peer 已连接,正在接收队列文件…"
} },
)
phoneShareServer = server
runOnUiThread {
phoneHotspot.start(
onStarted = { wifi -> showPhoneShareQr(server, wifi, null) },
onStatus = { message ->
if (phoneShareServer === server) phoneShareStatusText?.text = message
},
onFailed = { reason ->
val endpoints = PhoneShareServer.localEndpoints(server.port)
if (endpoints.isEmpty()) {
phoneShareServer?.close()
phoneShareServer = null
phoneShareRunning = false
uploadRunning = false
phoneShareStatusText?.apply {
text = "$reason;当前也没有可用的局域网地址"
setTextColor(WARNING)
}
sendAddButton?.isEnabled = true
sendClearButton?.isEnabled = true
renderSelectedFiles()
} else {
showPhoneShareQr(server, null, "$reason,已回落到当前同一 Wi-Fi")
}
},
)
}
} catch (e: Exception) {
runOnUiThread {
phoneShareRunning = false
uploadRunning = false
phoneShareStatusText?.apply {
text = "创建发送会话失败:${e.message ?: e.javaClass.simpleName}"
setTextColor(WARNING)
}
sendAddButton?.isEnabled = true
sendClearButton?.isEnabled = true
renderSelectedFiles()
}
}
}
}
private fun showPhoneShareQr(server: PhoneShareServer, wifi: WifiCredentials?, note: String?) {
if (phoneShareServer !== server) return
val endpoints = PhoneShareServer.localEndpoints(server.port)
val encoded = try { server.pairingText(wifi, endpoints) } catch (e: Exception) {
phoneShareStatusText?.text = "无法生成配对二维码:${e.message}"
return
}
// Use the measured app content area. `resources.displayMetrics` is only
// a fallback for the short interval before the decor has completed a
// layout pass; using the physical display alone breaks tablets and
// split-screen windows because it ignores the actual app bounds.
val content = findViewById<View>(android.R.id.content)
val windowWidth = content?.width?.takeIf { it > 0 } ?: resources.displayMetrics.widthPixels
val windowHeight = content?.height?.takeIf { it > 0 } ?: resources.displayMetrics.heightPixels
val qrSide = phoneQrSidePx(windowWidth, windowHeight, resources.displayMetrics.density)
val qr = PhoneQr.render(encoded, qrSide)
val root = pageColumn()
root.addView(text("等待另一台 Android 扫码", 27f, Color.WHITE, true))
root.addView(text("$receiverDeviceLabel · ${selectedFiles.size} 个文件", 15f, ACCENT))
root.addView(space(12))
root.addView(ImageView(this).apply {
setImageBitmap(qr)
adjustViewBounds = false
scaleType = ImageView.ScaleType.CENTER
setBackgroundColor(Color.WHITE)
}, LinearLayout.LayoutParams(qrSide, qrSide).apply {
gravity = Gravity.CENTER_HORIZONTAL
})
root.addView(space(12))
phoneShareStatusText = text(
note ?: "QFT 临时网络已就绪;另一台手机扫码后会自动连接并开始接收。",
14f,
if (note == null) SUCCESS else WARNING,
)
root.addView(phoneShareStatusText)
root.addView(text(
if (wifi != null) {
val link = if (wifi.ssid.startsWith("DIRECT-")) "自适应专用网络(优先高速 / 自动兼容)" else "备用临时网络"
"$link:${wifi.ssid}\n发送服务端口:${server.port}"
}
else "连接方式:两台手机当前同一 Wi-Fi\n发送服务端口:${server.port}",
12f, MUTED,
), matchWrap(top = 8))
root.addView(space(16))
root.addView(button("停止发送并返回首页").apply { setOnClickListener { showHome() } })
setContentView(ScrollView(this).apply { setBackgroundColor(BG); addView(root) })
}
private fun startDownloadsFromPhone(pair: PairingPayload, baseUrl: String) {
val root = pageColumn()
root.addView(text("正在接收手机文件", 28f, Color.WHITE, true))
root.addView(text("${pair.pcName} → $receiverDeviceLabel", 16f, ACCENT))
root.addView(space(16))
val status = text("正在读取发送队列…", 14f, MUTED)
val bar = ProgressBar(this, null, android.R.attr.progressBarStyleHorizontal).apply { max = 1000 }
downloadStatusText = status
root.addView(status)
root.addView(bar, LinearLayout.LayoutParams(-1, dp(9)).apply { topMargin = dp(12) })
root.addView(space(18))
root.addView(button("取消并返回首页").apply { setOnClickListener { showHome() } })
setContentView(ScrollView(this).apply { setBackgroundColor(BG); addView(root) })
downloadRunning = true
transferAbortReason = null
wifiConnector.acquireHighPerfLock()
transferExecutor.execute {
try {
val manifest = PhoneShareServer.fetchManifest(connectedNetwork, baseUrl, pair, receiverDeviceLabel)
val totalBytes = manifest.sumOf { it.size }
var completedBytes = 0L
val savedNames = mutableListOf<String>()
manifest.forEachIndexed { index, item ->
val filePair = pair.copy(
direction = TransferDirection.DOWNLOAD_TO_PHONE,
fileName = item.name,
fileSize = item.size,
sha256 = item.sha256,
downloadPath = item.path,
)
runOnUiThread { status.text = "正在接收 ${index + 1}/${manifest.size}:${item.name}" }
val before = completedBytes
val saved = DownloadClient.download(
context = this@MainActivity,
resolver = contentResolver,
networkProvider = { connectedNetwork },
baseUrl = baseUrl,
pairing = filePair,
deviceName = receiverDeviceLabel,
abortReason = { transferAbortReason },
onPhase = { phase -> runOnUiThread {
status.text = "${index + 1}/${manifest.size} ${item.name} · $phase"
} },
) { received, _ -> runOnUiThread {
val all = before + received
bar.progress = if (totalBytes <= 0) 0 else ((all * 1000L) / totalBytes).toInt().coerceIn(0, 1000)
status.text = "正在接收 ${index + 1}/${manifest.size}:${item.name}\n${humanBytes(all)} / ${humanBytes(totalBytes)}"
} }
completedBytes += item.size
savedNames += saved.name
}
runOnUiThread {
bar.progress = 1000
status.setTextColor(SUCCESS)
status.text = "手机互传完成:${savedNames.size} 个文件已保存到 Downloads/QFT"
}
} catch (e: Exception) {
runOnUiThread { showPairError(pair, "从手机接收失败:${e.message ?: e.javaClass.simpleName}") }
} finally {
downloadRunning = false
wifiConnector.releaseHighPerfLock()
}
}
}
private fun showSendReady(pair: PairingPayload, baseUrl: String) { private fun showSendReady(pair: PairingPayload, baseUrl: String) {
val root = pageColumn() val root = pageColumn()
root.addView(text("已连接电脑", 28f, Color.WHITE, true)) root.addView(text("已连接电脑", 28f, Color.WHITE, true))
@@ -1049,6 +1352,7 @@ class MainActivity : ComponentActivity() {
} }
private fun renderSelectedFiles() { private fun renderSelectedFiles() {
val phoneMode = phoneShareStatusText != null
val total = selectedFiles.sumOf { it.size } val total = selectedFiles.sumOf { it.size }
sendFilesText?.text = if (selectedFiles.isEmpty()) { sendFilesText?.text = if (selectedFiles.isEmpty()) {
"请先选择需要传输的文件" "请先选择需要传输的文件"
@@ -1097,9 +1401,10 @@ class MainActivity : ComponentActivity() {
sendButton?.text = when { sendButton?.text = when {
uploadRunning -> "传输中 · 队列已锁定" uploadRunning -> "传输中 · 队列已锁定"
selectedFiles.isEmpty() -> "请先添加文件" selectedFiles.isEmpty() -> "请先添加文件"
phoneMode -> "创建 ${selectedFiles.size} 个文件的发送二维码"
else -> "开始传输 ${selectedFiles.size} 个文件" else -> "开始传输 ${selectedFiles.size} 个文件"
} }
sendButton?.isEnabled = connectedBaseUrl != null && selectedFiles.isNotEmpty() && !uploadRunning sendButton?.isEnabled = (phoneMode || connectedBaseUrl != null) && selectedFiles.isNotEmpty() && !uploadRunning
} }
private fun installFileQueueDrag( private fun installFileQueueDrag(
@@ -1341,6 +1646,8 @@ class MainActivity : ComponentActivity() {
override fun onDestroy() { override fun onDestroy() {
assembler.reset() assembler.reset()
wifiConnector.release() wifiConnector.release()
phoneShareServer?.close()
phoneHotspot.close()
stopCamera() stopCamera()
cameraExecutor.shutdownNow() cameraExecutor.shutdownNow()
transferExecutor.shutdownNow() transferExecutor.shutdownNow()
@@ -21,23 +21,29 @@ data class PairingPayload(
val fileName: String? = null, val fileName: String? = null,
val fileSize: Long? = null, val fileSize: Long? = null,
val sha256: String? = null, val sha256: String? = null,
/** Internal per-file route used by Android → Android manifests. QR input
* never controls this value; parsed pairing codes always use the default. */
val downloadPath: String = "/qft/download",
) )
enum class TransferDirection { UPLOAD_TO_PC, DOWNLOAD_TO_PHONE } enum class TransferDirection { UPLOAD_TO_PC, DOWNLOAD_TO_PHONE, PHONE_TO_PHONE }
object PairingProtocol { object PairingProtocol {
const val PREFIX_V2 = "QFTPAIR2:" const val PREFIX_V2 = "QFTPAIR2:"
const val PREFIX_SEND_V2 = "QFTSEND2:" const val PREFIX_SEND_V2 = "QFTSEND2:"
const val PREFIX_PHONE_V2 = "QFTPHONE2:"
const val PREFIX_V1 = "QFTPAIR1:" const val PREFIX_V1 = "QFTPAIR1:"
fun isPairingText(text: String): Boolean = fun isPairingText(text: String): Boolean =
text.startsWith(PREFIX_V2) || text.startsWith(PREFIX_SEND_V2) || text.startsWith(PREFIX_V1) text.startsWith(PREFIX_V2) || text.startsWith(PREFIX_SEND_V2) ||
text.startsWith(PREFIX_PHONE_V2) || text.startsWith(PREFIX_V1)
fun parse(text: String): PairingPayload? { fun parse(text: String): PairingPayload? {
if (text.length > 4096) return null if (text.length > 4096) return null
return when { return when {
text.startsWith(PREFIX_V2) -> parseV2(text.substring(PREFIX_V2.length), TransferDirection.UPLOAD_TO_PC) text.startsWith(PREFIX_V2) -> parseV2(text.substring(PREFIX_V2.length), TransferDirection.UPLOAD_TO_PC)
text.startsWith(PREFIX_SEND_V2) -> parseV2(text.substring(PREFIX_SEND_V2.length), TransferDirection.DOWNLOAD_TO_PHONE) text.startsWith(PREFIX_SEND_V2) -> parseV2(text.substring(PREFIX_SEND_V2.length), TransferDirection.DOWNLOAD_TO_PHONE)
text.startsWith(PREFIX_PHONE_V2) -> parseV2(text.substring(PREFIX_PHONE_V2.length), TransferDirection.PHONE_TO_PHONE)
text.startsWith(PREFIX_V1) -> parseV1(text.substring(PREFIX_V1.length)) text.startsWith(PREFIX_V1) -> parseV1(text.substring(PREFIX_V1.length))
else -> null else -> null
} }
@@ -53,6 +59,7 @@ object PairingProtocol {
val direction = when (encodedDirection) { val direction = when (encodedDirection) {
"u" -> TransferDirection.UPLOAD_TO_PC "u" -> TransferDirection.UPLOAD_TO_PC
"d" -> TransferDirection.DOWNLOAD_TO_PHONE "d" -> TransferDirection.DOWNLOAD_TO_PHONE
"m" -> TransferDirection.PHONE_TO_PHONE
else -> return null else -> return null
} }
if (direction != expectedDirection) return null if (direction != expectedDirection) return null
@@ -67,7 +74,9 @@ object PairingProtocol {
val ssid = wifiArray.optString(0) val ssid = wifiArray.optString(0)
val passphrase = wifiArray.optString(1) val passphrase = wifiArray.optString(1)
if (!validWifi(ssid, passphrase)) return null if (!validWifi(ssid, passphrase)) return null
WifiCredentials(ssid, passphrase, "WPA2") val security = wifiArray.optString(2, "WPA2")
if (security !in setOf("WPA2", "WPA3")) return null
WifiCredentials(ssid, passphrase, security)
} else null } else null
val endpoints = mutableListOf<String>() val endpoints = mutableListOf<String>()
@@ -157,6 +166,34 @@ object PairingProtocol {
private fun decodeUrlBase64(encoded: String): ByteArray? = Base64Url.decode(encoded) private fun decodeUrlBase64(encoded: String): ByteArray? = Base64Url.decode(encoded)
/** Build a compact Android-sender QR. File names and hashes stay in the
* authenticated local manifest so a large queue does not make the QR dense. */
fun encodePhoneShare(
session: String,
senderName: String,
port: Int,
endpoints: List<String>,
wifi: WifiCredentials?,
): String {
require(validSession(session))
require(port in 1..65535)
val safeEndpoints = endpoints
.map { it.trim().removeSuffix("/") }
.filter { isAllowedLocalHttpEndpoint(it, port) }
.distinct()
require(wifi != null || safeEndpoints.isNotEmpty())
val obj = JSONObject().apply {
put("v", 2)
put("s", session)
put("n", senderName.take(80))
put("p", port)
put("d", "m")
if (safeEndpoints.isNotEmpty()) put("e", org.json.JSONArray(safeEndpoints))
wifi?.let { put("w", org.json.JSONArray(listOf(it.ssid, it.passphrase, it.security))) }
}
return PREFIX_PHONE_V2 + Base64Url.encode(obj.toString().toByteArray(Charsets.UTF_8))
}
private fun validSession(session: String): Boolean = session.matches(Regex("^[A-Za-z0-9_-]{20,64}$")) private fun validSession(session: String): Boolean = session.matches(Regex("^[A-Za-z0-9_-]{20,64}$"))
private fun validWifi(ssid: String, passphrase: String): Boolean { private fun validWifi(ssid: String, passphrase: String): Boolean {
@@ -0,0 +1,375 @@
package com.qft.optical
import android.content.Context
import android.net.wifi.WifiManager
import android.net.wifi.p2p.WifiP2pConfig
import android.net.wifi.p2p.WifiP2pManager
import android.os.Build
import android.os.Handler
import android.os.Looper
import android.os.SystemClock
import androidx.annotation.RequiresApi
import java.security.SecureRandom
import java.util.concurrent.atomic.AtomicBoolean
/**
* Owns the phone-share access point.
*
* Android only exposes one underlying local hotspot, so QFT uses one adaptive
* Wi-Fi Direct group instead of pretending that two independent SSIDs can run
* concurrently. Android 10+ starts on AUTO (normally 5 GHz when available). If
* no authenticated peer appears, the exact same SSID/password is recreated on
* 2.4 GHz so an old receiver's already-running Wi-Fi search can join without
* rescanning the QR. LocalOnlyHotspot remains the final OEM fallback.
*/
class PhoneHotspotController(context: Context) {
private companion object {
const val LEGACY_BAND_FALLBACK_MS = 12_000L
const val GROUP_READY_TIMEOUT_MS = 12_000L
}
private val appContext = context.applicationContext
private val wifiManager = appContext.getSystemService(WifiManager::class.java)
private val p2pManager = appContext.getSystemService(Context.WIFI_P2P_SERVICE) as? WifiP2pManager
private val handler = Handler(Looper.getMainLooper())
private var reservation: AutoCloseable? = null
private var p2pChannel: WifiP2pManager.Channel? = null
private var adaptiveFallback: Runnable? = null
private var generation = 0
@Volatile private var peerAuthenticated = false
fun start(
onStarted: (WifiCredentials) -> Unit,
onStatus: (String) -> Unit = {},
onFailed: (String) -> Unit,
) {
close()
val run = ++generation
peerAuthenticated = false
val finalFallbackStarted = AtomicBoolean(false)
fun fallBackToLocalOnly(reason: String) {
if (run != generation || !finalFallbackStarted.compareAndSet(false, true)) return
adaptiveFallback?.let(handler::removeCallbacks)
adaptiveFallback = null
removeP2pGroup {
if (run == generation) {
if (Build.VERSION.SDK_INT >= 26) {
onStatus("$reason;正在启动系统备用热点…")
startLocalOnlyHotspot(run, onStarted) { localReason ->
onFailed("$reason;$localReason")
}
} else {
onFailed("$reason;Android 7 无法创建备用临时热点,将使用当前局域网")
}
}
}
}
val manager = p2pManager ?: run {
fallBackToLocalOnly("设备没有 Wi-Fi Direct 服务")
return
}
val channel = try {
manager.initialize(appContext, Looper.getMainLooper()) {
fallBackToLocalOnly("Wi-Fi Direct 通道已断开")
}
} catch (e: Exception) {
fallBackToLocalOnly("初始化专用网络失败:${e.message ?: e.javaClass.simpleName}")
return
}
p2pChannel = channel
if (Build.VERSION.SDK_INT >= 29) {
val wifi = newSessionCredentials()
onStatus("正在创建高速专用网络(自动选择 5GHz/2.4GHz)…")
replaceConfiguredGroup(
run = run,
channel = channel,
wifi = wifi,
band = WifiP2pConfig.GROUP_OWNER_BAND_AUTO,
onReady = {
onStarted(wifi)
onStatus("高速专用网络已就绪;12 秒未配对将自动切换旧机兼容频段")
scheduleLegacyBandFallback(
run = run,
channel = channel,
wifi = wifi,
onStarted = onStarted,
onStatus = onStatus,
onFailed = ::fallBackToLocalOnly,
)
},
onFailed = ::fallBackToLocalOnly,
)
} else {
onStatus("正在创建系统兼容专用网络…")
replaceLegacyGroup(
run = run,
channel = channel,
onReady = { wifi ->
onStarted(wifi)
onStatus("WPA2 兼容专用网络已就绪")
},
onFailed = ::fallBackToLocalOnly,
)
}
}
/** Called after the HTTP session token has been authenticated. */
fun markPeerAuthenticated() {
peerAuthenticated = true
adaptiveFallback?.let(handler::removeCallbacks)
adaptiveFallback = null
}
@RequiresApi(29)
private fun scheduleLegacyBandFallback(
run: Int,
channel: WifiP2pManager.Channel,
wifi: WifiCredentials,
onStarted: (WifiCredentials) -> Unit,
onStatus: (String) -> Unit,
onFailed: (String) -> Unit,
) {
val task = Runnable {
adaptiveFallback = null
if (run != generation || peerAuthenticated) return@Runnable
onStatus("尚未检测到接收端,正在用相同二维码切换到 2.4GHz 旧机兼容频段…")
replaceConfiguredGroup(
run = run,
channel = channel,
wifi = wifi,
band = WifiP2pConfig.GROUP_OWNER_BAND_2GHZ,
onReady = {
onStarted(wifi) // Same credentials: QR contents do not change.
onStatus("已切换 2.4GHz 兼容频段;旧版 Android 可继续自动搜索并连接")
},
onFailed = onFailed,
)
}
adaptiveFallback = task
handler.postDelayed(task, LEGACY_BAND_FALLBACK_MS)
}
@RequiresApi(29)
@Suppress("MissingPermission")
private fun replaceConfiguredGroup(
run: Int,
channel: WifiP2pManager.Channel,
wifi: WifiCredentials,
band: Int,
onReady: () -> Unit,
onFailed: (String) -> Unit,
) {
replaceGroup(
run = run,
channel = channel,
create = { listener ->
val config = WifiP2pConfig.Builder()
.setNetworkName(wifi.ssid)
.setPassphrase(wifi.passphrase)
.setGroupOperatingBand(band)
.build()
p2pManager?.createGroup(channel, config, listener)
?: onFailed("Wi-Fi Direct 服务不可用")
},
onReady = { actual ->
if (actual.ssid != wifi.ssid || actual.passphrase != wifi.passphrase) {
onFailed("系统创建的专用网络凭据与会话不一致")
} else {
onReady()
}
},
onFailed = onFailed,
)
}
@Suppress("MissingPermission")
private fun replaceLegacyGroup(
run: Int,
channel: WifiP2pManager.Channel,
onReady: (WifiCredentials) -> Unit,
onFailed: (String) -> Unit,
) {
replaceGroup(
run = run,
channel = channel,
create = { listener ->
p2pManager?.createGroup(channel, listener)
?: onFailed("Wi-Fi Direct 服务不可用")
},
onReady = onReady,
onFailed = onFailed,
)
}
@Suppress("MissingPermission")
private fun replaceGroup(
run: Int,
channel: WifiP2pManager.Channel,
create: (WifiP2pManager.ActionListener) -> Unit,
onReady: (WifiCredentials) -> Unit,
onFailed: (String) -> Unit,
) {
val terminal = AtomicBoolean(false)
fun fail(reason: String) {
if (run == generation && terminal.compareAndSet(false, true)) onFailed(reason)
}
fun waitForGroup() {
val deadline = SystemClock.elapsedRealtime() + GROUP_READY_TIMEOUT_MS
fun poll() {
if (run != generation || terminal.get()) return
try {
p2pManager?.requestGroupInfo(channel) { group ->
if (run != generation || terminal.get()) return@requestGroupInfo
val ssid = group?.networkName.orEmpty()
val passphrase = group?.passphrase.orEmpty()
if (group?.isGroupOwner == true && ssid.isNotBlank() && passphrase.length in 8..63) {
if (terminal.compareAndSet(false, true)) {
onReady(WifiCredentials(ssid, passphrase, "WPA2"))
}
} else if (SystemClock.elapsedRealtime() >= deadline) {
fail("创建专用网络超时")
} else {
handler.postDelayed({ poll() }, 180L)
}
} ?: fail("Wi-Fi Direct 服务不可用")
} catch (e: Exception) {
fail("读取专用网络信息失败:${e.message ?: e.javaClass.simpleName}")
}
}
poll()
}
val listener = object : WifiP2pManager.ActionListener {
override fun onSuccess() = waitForGroup()
override fun onFailure(reason: Int) = fail("系统拒绝创建专用网络(错误 $reason)")
}
val startCreate = {
if (run == generation && !terminal.get()) {
try {
create(listener)
} catch (e: Exception) {
fail("启动专用网络失败:${e.message ?: e.javaClass.simpleName}")
}
}
}
// Remove stale/present group before both initial creation and adaptive
// band switching. Credentials supplied to `create` stay unchanged.
try {
p2pManager?.removeGroup(channel, object : WifiP2pManager.ActionListener {
override fun onSuccess() = startCreate()
override fun onFailure(reason: Int) = startCreate()
}) ?: fail("Wi-Fi Direct 服务不可用")
} catch (_: Exception) {
startCreate()
}
}
@RequiresApi(29)
private fun newSessionCredentials(): WifiCredentials {
val random = ByteArray(12).also { SecureRandom().nextBytes(it) }
val token = random.joinToString("") { "%02x".format(it.toInt() and 0xff) }
return WifiCredentials(
ssid = "DIRECT-QF-QFT${token.take(6)}",
passphrase = token.take(16),
security = "WPA2",
)
}
@RequiresApi(26)
@Suppress("MissingPermission", "DEPRECATION")
private fun startLocalOnlyHotspot(
run: Int,
onStarted: (WifiCredentials) -> Unit,
onFailed: (String) -> Unit,
) {
try {
wifiManager.startLocalOnlyHotspot(
object : WifiManager.LocalOnlyHotspotCallback() {
override fun onStarted(value: WifiManager.LocalOnlyHotspotReservation) {
if (run != generation) {
value.close()
return
}
reservation = value
val identity = if (Build.VERSION.SDK_INT >= 30) {
val config = value.softApConfiguration
Triple(
config.ssid,
config.passphrase,
if (config.securityType == android.net.wifi.SoftApConfiguration.SECURITY_TYPE_WPA3_SAE) "WPA3" else "WPA2",
)
} else {
val config = value.wifiConfiguration
Triple(config?.SSID?.trim('"'), config?.preSharedKey?.trim('"'), "WPA2")
}
val ssid = identity.first.orEmpty()
val passphrase = identity.second.orEmpty()
if (ssid.isBlank() || passphrase.length !in 8..63) {
close()
onFailed("系统备用热点没有返回有效的名称或密码")
return
}
onStarted(WifiCredentials(ssid, passphrase, identity.third))
}
override fun onStopped() {
if (run == generation) {
reservation = null
onFailed("系统已停止 QFT 备用临时热点")
}
}
override fun onFailed(reason: Int) {
if (run == generation) onFailed("系统无法创建备用临时热点(错误 $reason)")
}
},
handler,
)
} catch (e: Exception) {
onFailed("启动备用临时热点失败:${e.message ?: e.javaClass.simpleName}")
}
}
@Suppress("MissingPermission")
private fun removeP2pGroup(done: () -> Unit) {
val channel = p2pChannel
p2pChannel = null
if (channel == null) {
done()
return
}
val once = AtomicBoolean(false)
fun finish() {
if (once.compareAndSet(false, true)) done()
}
try {
p2pManager?.removeGroup(channel, object : WifiP2pManager.ActionListener {
override fun onSuccess() = finish()
override fun onFailure(reason: Int) = finish()
}) ?: finish()
} catch (_: Exception) {
finish()
}
}
@Suppress("MissingPermission")
fun close() {
generation++
handler.removeCallbacksAndMessages(null)
adaptiveFallback = null
peerAuthenticated = false
try { reservation?.close() } catch (_: Exception) {}
reservation = null
val channel = p2pChannel
p2pChannel = null
if (channel != null) {
try { p2pManager?.removeGroup(channel, null) } catch (_: Exception) {}
}
}
}
@@ -0,0 +1,26 @@
package com.qft.optical
import android.graphics.Bitmap
import android.graphics.Color
import com.google.zxing.BarcodeFormat
import com.google.zxing.EncodeHintType
import com.google.zxing.qrcode.QRCodeWriter
import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel
object PhoneQr {
fun render(text: String, pixels: Int): Bitmap {
val hints = mapOf(
EncodeHintType.CHARACTER_SET to "UTF-8",
EncodeHintType.ERROR_CORRECTION to ErrorCorrectionLevel.M,
EncodeHintType.MARGIN to 3,
)
val matrix = QRCodeWriter().encode(text, BarcodeFormat.QR_CODE, pixels, pixels, hints)
val bitmap = Bitmap.createBitmap(matrix.width, matrix.height, Bitmap.Config.ARGB_8888)
val row = IntArray(matrix.width)
for (y in 0 until matrix.height) {
for (x in 0 until matrix.width) row[x] = if (matrix[x, y]) Color.BLACK else Color.WHITE
bitmap.setPixels(row, 0, matrix.width, 0, y, matrix.width, 1)
}
return bitmap
}
}
@@ -0,0 +1,19 @@
package com.qft.optical
import kotlin.math.min
import kotlin.math.roundToInt
/**
* Size a square pairing QR against the *current app window*, not a fixed phone
* resolution. The vertical reserve covers page padding, titles, connection
* details and the stop button, keeping the whole sender page visible on phones,
* tablets and split-window layouts.
*/
internal fun phoneQrSidePx(windowWidthPx: Int, windowHeightPx: Int, density: Float): Int {
val safeDensity = density.takeIf { it.isFinite() && it > 0f } ?: 1f
val horizontalPagePadding = (40f * safeDensity).roundToInt()
val nonQrVerticalUi = (300f * safeDensity).roundToInt()
val widthLimit = (windowWidthPx - horizontalPagePadding).coerceAtLeast(1)
val heightLimit = (windowHeightPx - nonQrVerticalUi).coerceAtLeast(1)
return min(widthLimit, heightLimit)
}
@@ -0,0 +1,329 @@
package com.qft.optical
import android.content.ContentResolver
import org.json.JSONArray
import org.json.JSONObject
import java.io.BufferedInputStream
import java.io.BufferedOutputStream
import java.io.FileInputStream
import java.io.InputStream
import java.net.DatagramPacket
import java.net.DatagramSocket
import java.net.InetAddress
import java.net.NetworkInterface
import java.net.ServerSocket
import java.net.Socket
import java.net.SocketTimeoutException
import java.nio.charset.StandardCharsets
import java.security.MessageDigest
import java.util.concurrent.Executors
import java.util.concurrent.atomic.AtomicBoolean
data class PhoneShareItem(
val selected: SelectedFile,
val sha256: String,
)
data class PhoneShareManifestItem(
val name: String,
val size: Long,
val sha256: String,
val path: String,
)
/** Hash exactly the advertised number of bytes and reject stale provider size
* metadata. The manifest and Range server must describe the identical snapshot. */
internal fun phoneShareSha256Exact(input: InputStream, expectedSize: Long): String {
require(expectedSize >= 0L)
val digest = MessageDigest.getInstance("SHA-256")
val buffer = ByteArray(1024 * 1024)
var remaining = expectedSize
while (remaining > 0L) {
val count = input.read(buffer, 0, minOf(buffer.size.toLong(), remaining).toInt())
require(count >= 0) { "实际内容小于文件选择器报告的大小" }
if (count == 0) continue
digest.update(buffer, 0, count)
remaining -= count.toLong()
}
require(input.read() < 0) { "实际内容大于文件选择器报告的大小" }
return digest.digest().joinToString("") { "%02x".format(it.toInt() and 0xFF) }
}
internal fun phoneShareRange(value: String?, size: Long): Pair<Long, Long>? {
if (size == 0L) return if (value == null) 0L to 0L else null
if (value == null) return 0L to (size - 1L)
val body = value.removePrefix("bytes=")
if (body == value) return null
val split = body.split('-', limit = 2)
if (split.size != 2 || split[0].isBlank()) return null
val start = split[0].toLongOrNull() ?: return null
val end = if (split[1].isBlank()) size - 1L else split[1].toLongOrNull() ?: return null
return if (start in 0 until size && end in start until size) start to end else null
}
/** Minimal authenticated HTTP/Range sender used by Android → Android v2. */
class PhoneShareServer private constructor(
private val resolver: ContentResolver,
private val session: String,
private val deviceName: String,
private val items: List<PhoneShareItem>,
private val server: ServerSocket,
private val onPeer: (String) -> Unit,
) : AutoCloseable {
val port: Int get() = server.localPort
private val stopped = AtomicBoolean(false)
private val clients = Executors.newFixedThreadPool(10)
private val tcpThread: Thread
private val udpThread: Thread
init {
server.soTimeout = 250
tcpThread = Thread({ acceptLoop() }, "qft-phone-http").apply { start() }
udpThread = Thread({ discoveryLoop() }, "qft-phone-discovery").apply { start() }
}
fun pairingText(wifi: WifiCredentials?, endpoints: List<String>): String =
PairingProtocol.encodePhoneShare(session, deviceName, port, endpoints, wifi)
private fun acceptLoop() {
while (!stopped.get()) {
try {
val socket = server.accept()
clients.execute { socket.use { handle(it) } }
} catch (_: SocketTimeoutException) {
} catch (_: Exception) {
if (!stopped.get()) Thread.sleep(30)
}
}
}
private fun handle(socket: Socket) {
socket.tcpNoDelay = true
socket.soTimeout = 20_000
val input = BufferedInputStream(socket.getInputStream(), 32 * 1024)
val output = BufferedOutputStream(socket.getOutputStream(), 1024 * 1024)
val request = readLine(input) ?: return
val parts = request.split(' ')
if (parts.size < 2) return
val headers = linkedMapOf<String, String>()
while (true) {
val line = readLine(input) ?: return
if (line.isEmpty()) break
val split = line.indexOf(':')
if (split > 0) headers[line.substring(0, split).trim().lowercase()] = line.substring(split + 1).trim()
}
if (headers["x-qft-token"] != session) {
response(output, 403, "text/plain", "invalid session".toByteArray())
return
}
headers["x-qft-device"]?.let { encoded ->
Base64Url.decode(encoded)?.toString(Charsets.UTF_8)?.take(80)?.let(onPeer)
}
val method = parts[0]
val path = parts[1].substringBefore('?')
when {
method == "GET" && path == "/qft/ping" -> response(
output, 200, "application/json",
"{\"ok\":true,\"protocol\":2,\"direction\":\"phone-download\"}".toByteArray(),
)
method == "GET" && path == "/qft/phone/manifest" -> response(
output, 200, "application/json", manifestJson().toByteArray(Charsets.UTF_8),
)
method == "GET" && path.startsWith("/qft/phone/download/") -> {
val index = path.substringAfterLast('/').toIntOrNull()
if (index == null || index !in items.indices) {
response(output, 404, "text/plain", "not found".toByteArray())
} else {
serveFile(output, headers["range"], items[index])
}
}
else -> response(output, 404, "text/plain", "not found".toByteArray())
}
}
private fun manifestJson(): String = JSONObject().apply {
put("v", 2)
put("sender", deviceName)
put("files", JSONArray().apply {
items.forEachIndexed { index, item ->
put(JSONObject().apply {
put("name", item.selected.name)
put("size", item.selected.size)
put("sha256", item.sha256)
put("path", "/qft/phone/download/$index")
})
}
})
}.toString()
private fun serveFile(output: BufferedOutputStream, rangeText: String?, item: PhoneShareItem) {
val size = item.selected.size
val range = phoneShareRange(rangeText, size) ?: run {
response(output, 416, "text/plain", "invalid range".toByteArray())
return
}
val (start, end) = range
val length = if (size == 0L) 0L else end - start + 1L
val status = if (rangeText == null) "200 OK" else "206 Partial Content"
val header = buildString {
append("HTTP/1.1 $status\r\n")
append("Content-Type: application/octet-stream\r\n")
append("Content-Length: $length\r\n")
append("Accept-Ranges: bytes\r\n")
if (rangeText != null) append("Content-Range: bytes $start-$end/$size\r\n")
append("Connection: close\r\n\r\n")
}
output.write(header.toByteArray(StandardCharsets.US_ASCII))
if (length > 0L) {
resolver.openFileDescriptor(item.selected.uri, "r")?.use { descriptor ->
FileInputStream(descriptor.fileDescriptor).use { source ->
source.channel.position(start)
val buffer = ByteArray(1024 * 1024)
var remaining = length
while (remaining > 0 && !stopped.get()) {
val count = source.read(buffer, 0, minOf(buffer.size.toLong(), remaining).toInt())
if (count < 0) error("source ended early")
output.write(buffer, 0, count)
remaining -= count
}
}
} ?: error("cannot open shared file")
}
output.flush()
}
private fun discoveryLoop() {
val socket = try {
DatagramSocket(39392).apply { soTimeout = 250; broadcast = true }
} catch (_: Exception) { return }
socket.use {
val buffer = ByteArray(512)
while (!stopped.get()) {
try {
val request = DatagramPacket(buffer, buffer.size)
socket.receive(request)
val text = String(request.data, 0, request.length, Charsets.US_ASCII)
if (!text.startsWith("QFTDISC2:$session:")) continue
val encodedName = text.substringAfter("QFTDISC2:$session:")
Base64Url.decode(encodedName)?.toString(Charsets.UTF_8)?.take(80)?.let(onPeer)
val reply = "QFTHERE2:$session:$port".toByteArray(Charsets.US_ASCII)
socket.send(DatagramPacket(reply, reply.size, request.address, request.port))
} catch (_: SocketTimeoutException) {
} catch (_: Exception) {
if (!stopped.get()) Thread.sleep(30)
}
}
}
}
override fun close() {
if (!stopped.compareAndSet(false, true)) return
try { server.close() } catch (_: Exception) {}
clients.shutdownNow()
tcpThread.interrupt()
udpThread.interrupt()
}
companion object {
fun create(
resolver: ContentResolver,
session: String,
deviceName: String,
selected: List<SelectedFile>,
onHashProgress: (Int, Int, String) -> Unit = { _, _, _ -> },
onPeer: (String) -> Unit = {},
): PhoneShareServer {
require(selected.isNotEmpty())
val items = selected.mapIndexed { index, file ->
onHashProgress(index, selected.size, file.name)
PhoneShareItem(file, sha256(resolver, file))
}
onHashProgress(selected.size, selected.size, "")
return PhoneShareServer(
resolver, session, deviceName, items,
ServerSocket(0, 32, InetAddress.getByName("0.0.0.0")), onPeer,
)
}
fun localEndpoints(port: Int): List<String> {
val result = mutableListOf<String>()
val interfaces = try { NetworkInterface.getNetworkInterfaces()?.toList().orEmpty() } catch (_: Exception) { emptyList() }
for (networkInterface in interfaces) {
if (!runCatching { networkInterface.isUp && !networkInterface.isLoopback }.getOrDefault(false)) continue
for (address in networkInterface.inetAddresses.toList()) {
val host = address.hostAddress?.substringBefore('%') ?: continue
val endpoint = "http://$host:$port"
if (PairingProtocol.isAllowedLocalHttpEndpoint(endpoint, port) && endpoint !in result) result += endpoint
}
}
return result
}
fun fetchManifest(
network: android.net.Network?,
baseUrl: String,
pairing: PairingPayload,
deviceName: String,
): List<PhoneShareManifestItem> {
val url = java.net.URL("$baseUrl/qft/phone/manifest")
val connection = (network?.openConnection(url) ?: url.openConnection()) as java.net.HttpURLConnection
try {
connection.connectTimeout = 4_000
connection.readTimeout = 8_000
connection.setRequestProperty("X-QFT-Token", pairing.session)
connection.setRequestProperty("X-QFT-Device", Base64Url.encode(deviceName.toByteArray()))
if (connection.responseCode != 200) error("文件清单返回 HTTP ${connection.responseCode}")
val root = JSONObject(connection.inputStream.bufferedReader().use { it.readText() })
val files = root.getJSONArray("files")
require(files.length() in 1..10_000) { "文件清单数量无效" }
return (0 until files.length()).map { index ->
val item = files.getJSONObject(index)
val name = item.getString("name").takeIf { validName(it) } ?: error("文件名无效")
val size = item.getLong("size").takeIf { it >= 0L } ?: error("文件大小无效")
val sha = item.getString("sha256").lowercase()
.takeIf { it.matches(Regex("^[0-9a-f]{64}$")) } ?: error("文件校验值无效")
val expectedPath = "/qft/phone/download/$index"
require(item.getString("path") == expectedPath) { "文件路径无效" }
PhoneShareManifestItem(name, size, sha, expectedPath)
}
} finally {
connection.disconnect()
}
}
private fun validName(value: String): Boolean = value.isNotBlank() && value.length <= 180 &&
value.none { it.code <= 31 || it.code == 127 || it in "\\/:*?\"<>|" }
private fun sha256(resolver: ContentResolver, file: SelectedFile): String {
val source = resolver.openInputStream(file.uri) ?: error("无法读取 ${file.name}")
return source.use { input ->
// Hash exactly the bytes that the Range server will expose.
// Reject mutable/stale provider metadata instead of producing a
// QR whose manifest hash can never match the advertised size.
try {
phoneShareSha256Exact(input, file.size)
} catch (e: IllegalArgumentException) {
error("${file.name}:${e.message},请重新选择")
}
}
}
private fun readLine(input: BufferedInputStream): String? {
val bytes = ArrayList<Byte>(128)
while (bytes.size <= 16 * 1024) {
val value = input.read()
if (value < 0) return if (bytes.isEmpty()) null else bytes.toByteArray().toString(Charsets.US_ASCII)
if (value == '\n'.code) break
if (value != '\r'.code) bytes += value.toByte()
}
return bytes.toByteArray().toString(Charsets.US_ASCII)
}
private fun response(output: BufferedOutputStream, code: Int, type: String, body: ByteArray) {
val reason = when (code) { 200 -> "OK"; 403 -> "Forbidden"; 404 -> "Not Found"; 416 -> "Range Not Satisfiable"; else -> "Error" }
output.write("HTTP/1.1 $code $reason\r\nContent-Type: $type\r\nContent-Length: ${body.size}\r\nConnection: close\r\n\r\n".toByteArray())
output.write(body)
output.flush()
}
}
}
@@ -48,7 +48,9 @@ class WifiConnector(context: Context) {
) )
private var listener: Listener? = null private var listener: Listener? = null
private var pendingSsid: String? = null /** The whole credential tuple owns a modern request. LocalOnlyHotspot may
* reuse its SSID while rotating the passphrase between reservations. */
private var pendingWifi: WifiCredentials? = null
private var pendingDelivered: AtomicBoolean? = null private var pendingDelivered: AtomicBoolean? = null
private var pendingTerminal: AtomicBoolean? = null private var pendingTerminal: AtomicBoolean? = null
private var pendingStartedAt = 0L private var pendingStartedAt = 0L
@@ -59,6 +61,12 @@ class WifiConnector(context: Context) {
private fun notifyAvailable(network: Network?) { listener?.onAvailable?.invoke(network) } private fun notifyAvailable(network: Network?) { listener?.onAvailable?.invoke(network) }
private fun notifyUnavailable(message: String) { listener?.onUnavailable?.invoke(message) } private fun notifyUnavailable(message: String) { listener?.onUnavailable?.invoke(message) }
/** Pure WPA3 hotspots cannot be joined by Android 7–9, or by Android 10+
* devices whose Wi-Fi chipset does not expose SAE support. */
fun canJoinAutomatically(wifi: WifiCredentials): Boolean =
wifi.security != "WPA3" ||
(Build.VERSION.SDK_INT >= 29 && wifiManager.isWpa3SaeSupported)
fun connect( fun connect(
pairing: PairingPayload, pairing: PairingPayload,
onStatus: (String) -> Unit, onStatus: (String) -> Unit,
@@ -75,7 +83,7 @@ class WifiConnector(context: Context) {
// 「配网越来越慢、几分钟都没反应」。超窗就推倒重来。 // 「配网越来越慢、几分钟都没反应」。超窗就推倒重来。
val reusable = pendingStartedAt > 0L && val reusable = pendingStartedAt > 0L &&
SystemClock.elapsedRealtime() - pendingStartedAt < REUSE_WINDOW_MS SystemClock.elapsedRealtime() - pendingStartedAt < REUSE_WINDOW_MS
if (wifi != null && callback != null && pendingSsid == wifi.ssid && reusable && if (wifi != null && callback != null && pendingWifi == wifi && reusable &&
pendingTerminal?.get() == false) { pendingTerminal?.get() == false) {
Log.i(TAG, "reuse outstanding request SSID=${wifi.ssid}") Log.i(TAG, "reuse outstanding request SSID=${wifi.ssid}")
listener = Listener(onStatus, onAvailable, onUnavailable) listener = Listener(onStatus, onAvailable, onUnavailable)
@@ -85,7 +93,7 @@ class WifiConnector(context: Context) {
notifyAvailable(active) notifyAvailable(active)
} else { } else {
notifyStatus("系统配网请求仍在进行中,正在自动恢复连接…") notifyStatus("系统配网请求仍在进行中,正在自动恢复连接…")
scheduleWaitHints(generation, wifi.ssid) scheduleWaitHints(generation, wifi.ssid, pairing.direction)
} }
return return
} }
@@ -95,7 +103,7 @@ class WifiConnector(context: Context) {
val run = generation val run = generation
listener = Listener(onStatus, onAvailable, onUnavailable) listener = Listener(onStatus, onAvailable, onUnavailable)
if (wifi == null) { if (wifi == null) {
notifyStatus("正在使用当前局域网发现电脑…") notifyStatus("正在使用当前局域网发现发送设备…")
val wifiNetwork = bestWifiNetwork() val wifiNetwork = bestWifiNetwork()
currentNetwork = wifiNetwork ?: connectivity.activeNetwork currentNetwork = wifiNetwork ?: connectivity.activeNetwork
notifyAvailable(currentNetwork) notifyAvailable(currentNetwork)
@@ -103,7 +111,7 @@ class WifiConnector(context: Context) {
} }
if (Build.VERSION.SDK_INT >= 29) { if (Build.VERSION.SDK_INT >= 29) {
connectModern(run, wifi) connectModern(run, wifi, pairing.direction)
} else { } else {
connectLegacy(run, wifi) connectLegacy(run, wifi)
} }
@@ -111,7 +119,7 @@ class WifiConnector(context: Context) {
@RequiresApi(29) @RequiresApi(29)
@Suppress("MissingPermission") @Suppress("MissingPermission")
private fun connectModern(run: Int, wifi: WifiCredentials) { private fun connectModern(run: Int, wifi: WifiCredentials, direction: TransferDirection) {
Log.i(TAG, "attempt=$run request SSID=${wifi.ssid}") Log.i(TAG, "attempt=$run request SSID=${wifi.ssid}")
// Ask the radio for a fresh scan immediately before presenting the // Ask the radio for a fresh scan immediately before presenting the
// NetworkSpecifier chooser. Some OEMs otherwise reuse an old scan cache // NetworkSpecifier chooser. Some OEMs otherwise reuse an old scan cache
@@ -125,11 +133,15 @@ class WifiConnector(context: Context) {
} }
notifyStatus("正在刷新 Wi-Fi 列表并连接 ${wifi.ssid}…") notifyStatus("正在刷新 Wi-Fi 列表并连接 ${wifi.ssid}…")
val specifier = try { val specifier = try {
WifiNetworkSpecifier.Builder() val builder = WifiNetworkSpecifier.Builder()
.setSsid(wifi.ssid) .setSsid(wifi.ssid)
.setWpa2Passphrase(wifi.passphrase)
.setIsHiddenSsid(false) .setIsHiddenSsid(false)
.build() if (wifi.security == "WPA3" && Build.VERSION.SDK_INT >= 29) {
builder.setWpa3Passphrase(wifi.passphrase)
} else {
builder.setWpa2Passphrase(wifi.passphrase)
}
builder.build()
} catch (e: Exception) { } catch (e: Exception) {
notifyUnavailable("配网参数无效:${e.message}") notifyUnavailable("配网参数无效:${e.message}")
return return
@@ -145,7 +157,7 @@ class WifiConnector(context: Context) {
// launching a duplicate probe/download for the same Wi-Fi connection. // launching a duplicate probe/download for the same Wi-Fi connection.
val delivered = AtomicBoolean(false) val delivered = AtomicBoolean(false)
val terminal = AtomicBoolean(false) val terminal = AtomicBoolean(false)
pendingSsid = wifi.ssid pendingWifi = wifi
pendingDelivered = delivered pendingDelivered = delivered
pendingTerminal = terminal pendingTerminal = terminal
pendingStartedAt = SystemClock.elapsedRealtime() pendingStartedAt = SystemClock.elapsedRealtime()
@@ -188,10 +200,17 @@ class WifiConnector(context: Context) {
if (waited < 4_000L) { if (waited < 4_000L) {
"已取消系统配网。请重新点击「重试连接」,并在系统弹窗里选择 ${wifi.ssid} 后点连接。" "已取消系统配网。请重新点击「重试连接」,并在系统弹窗里选择 ${wifi.ssid} 后点连接。"
} else { } else {
"系统始终没有搜索到热点 ${wifi.ssid}。请确认:" + if (direction == TransferDirection.PHONE_TO_PHONE) {
"① 电脑上 QFT 接收页仍开着且显示 Direct 已启动;" + "系统始终没有搜索到热点 ${wifi.ssid}。请确认:" +
"② 手机 Wi-Fi 列表里能看到这个名字;" + "① 发送手机仍停留在二维码页面;" +
"③ 电脑与手机距离不要太远。" "② 两台手机距离不要太远;" +
"③ 发送手机没有关闭临时热点或进入省电状态。"
} else {
"系统始终没有搜索到热点 ${wifi.ssid}。请确认:" +
"① 电脑上 QFT 接收页仍开着且显示 Direct 已启动;" +
"② 手机 Wi-Fi 列表里能看到这个名字;" +
"③ 电脑与手机距离不要太远。"
}
} }
) )
} }
@@ -216,10 +235,10 @@ class WifiConnector(context: Context) {
// system sheet; otherwise keep this request alive while our page // system sheet; otherwise keep this request alive while our page
// continues to show connection progress. // continues to show connection progress.
connectivity.requestNetwork(request, cb) connectivity.requestNetwork(request, cb)
scheduleWaitHints(run, wifi.ssid) scheduleWaitHints(run, wifi.ssid, direction)
} catch (e: Exception) { } catch (e: Exception) {
callback = null callback = null
pendingSsid = null pendingWifi = null
notifyUnavailable("系统配网请求失败:${e.message}") notifyUnavailable("系统配网请求失败:${e.message}")
} }
} }
@@ -229,7 +248,7 @@ class WifiConnector(context: Context) {
* 截图里那种「弹窗一直转圈」的情况,光说「仍在等待系统完成配网」 * 截图里那种「弹窗一直转圈」的情况,光说「仍在等待系统完成配网」
* 完全没有指导意义——真正的原因通常是电脑侧热点没起来。 * 完全没有指导意义——真正的原因通常是电脑侧热点没起来。
*/ */
private fun scheduleWaitHints(run: Int, ssid: String) { private fun scheduleWaitHints(run: Int, ssid: String, direction: TransferDirection) {
fun pending(): Boolean = fun pending(): Boolean =
run == generation && pendingTerminal?.get() == false && pendingDelivered?.get() == false run == generation && pendingTerminal?.get() == false && pendingDelivered?.get() == false
@@ -237,15 +256,23 @@ class WifiConnector(context: Context) {
if (pending()) listener?.onStatus?.invoke("仍在等待系统完成配网…") if (pending()) listener?.onStatus?.invoke("仍在等待系统完成配网…")
}, 4_000) }, 4_000)
handler.postDelayed({ handler.postDelayed({
if (pending()) listener?.onStatus?.invoke( if (pending()) {
"系统仍在搜索 $ssid。若弹窗里一直没出现这个名字," + val peerHint = if (direction == TransferDirection.PHONE_TO_PHONE) {
"多半是电脑侧热点没启动——请检查 Windows 上 QFT 接收页是否显示 Direct 已就绪。" "请确认发送手机仍停留在二维码页面,且临时热点没有被省电模式关闭。"
) } else {
"请检查 Windows 上 QFT 接收页是否显示 Direct 已就绪。"
}
listener?.onStatus?.invoke("系统仍在搜索 $ssid。若弹窗里没有这个名字,$peerHint")
}
}, 20_000) }, 20_000)
} }
@Suppress("DEPRECATION", "MissingPermission") @Suppress("DEPRECATION", "MissingPermission")
private fun connectLegacy(run: Int, wifi: WifiCredentials) { private fun connectLegacy(run: Int, wifi: WifiCredentials) {
if (wifi.security == "WPA3") {
notifyUnavailable("当前 Android 版本不支持自动加入 WPA3 临时热点;请让两台手机先连接同一个普通 Wi-Fi 后重试。")
return
}
notifyStatus("Android ${Build.VERSION.RELEASE} 兼容配网:正在连接 ${wifi.ssid}…") notifyStatus("Android ${Build.VERSION.RELEASE} 兼容配网:正在连接 ${wifi.ssid}…")
try { try {
if (!wifiManager.isWifiEnabled) { if (!wifiManager.isWifiEnabled) {
@@ -253,22 +280,41 @@ class WifiConnector(context: Context) {
} }
legacyPreviousNetworkId = wifiManager.connectionInfo?.networkId?.takeIf { it >= 0 } legacyPreviousNetworkId = wifiManager.connectionInfo?.networkId?.takeIf { it >= 0 }
val quoted = "\"${wifi.ssid}\"" val quoted = "\"${wifi.ssid}\""
val existing = try { wifiManager.configuredNetworks?.firstOrNull { it.SSID == quoted } } catch (_: Exception) { null } val existing = try {
val targetId = if (existing != null) { wifiManager.configuredNetworks?.firstOrNull { normalizeSsid(it.SSID) == wifi.ssid }
existing.networkId } catch (_: Exception) { null }
} else { val config = WifiConfiguration().apply {
val config = WifiConfiguration().apply { SSID = quoted
SSID = quoted preSharedKey = "\"${wifi.passphrase}\""
preSharedKey = "\"${wifi.passphrase}\"" hiddenSSID = false
allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK) status = WifiConfiguration.Status.ENABLED
} allowedKeyManagement.clear()
wifiManager.addNetwork(config) allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK)
} }
// A LocalOnlyHotspot reservation may keep the same generated SSID
// but rotate its password. Reusing an old WifiConfiguration without
// replacing the PSK leaves Android 7–9 in an endless association
// loop. Always update the saved entry from the freshly scanned QR.
var targetId = if (existing != null) {
config.networkId = existing.networkId
wifiManager.updateNetwork(config)
} else -1
if (targetId < 0) { if (targetId < 0) {
notifyUnavailable("Android 7~9 无法写入 QFT Wi-Fi 配置;请确认已授予位置权限。") existing?.let { wifiManager.removeNetwork(it.networkId) }
config.networkId = -1
targetId = wifiManager.addNetwork(config)
}
try { wifiManager.saveConfiguration() } catch (_: Exception) {}
if (targetId < 0) {
notifyUnavailable("Android 7~9 无法刷新 QFT Wi-Fi 配置;请确认已授予位置权限并开启系统定位。")
return return
} }
legacyTargetNetworkId = targetId legacyTargetNetworkId = targetId
try {
Log.i(TAG, "attempt=$run legacy active scan requested=${wifiManager.startScan()}")
} catch (e: Exception) {
Log.w(TAG, "attempt=$run legacy active scan unavailable: ${e.message}")
}
wifiManager.disconnect() wifiManager.disconnect()
if (!wifiManager.enableNetwork(targetId, true)) { if (!wifiManager.enableNetwork(targetId, true)) {
notifyUnavailable("系统拒绝启用 QFT Wi-Fi 网络") notifyUnavailable("系统拒绝启用 QFT Wi-Fi 网络")
@@ -276,6 +322,7 @@ class WifiConnector(context: Context) {
} }
wifiManager.reconnect() wifiManager.reconnect()
val started = SystemClock.elapsedRealtime() val started = SystemClock.elapsedRealtime()
var associationRetried = false
fun poll() { fun poll() {
if (run != generation) return if (run != generation) return
val info = wifiManager.connectionInfo val info = wifiManager.connectionInfo
@@ -283,14 +330,28 @@ class WifiConnector(context: Context) {
if (matches) { if (matches) {
val network = bestWifiNetwork() val network = bestWifiNetwork()
if (network != null && hasIpv4(connectivity.getLinkProperties(network))) { if (network != null && hasIpv4(connectivity.getLinkProperties(network))) {
notifyStatus("QFT Wi-Fi 已连接,正在快速发现电脑…") notifyStatus("QFT Wi-Fi 已连接,正在快速发现发送设备…")
currentNetwork = network currentNetwork = network
notifyAvailable(network) notifyAvailable(network)
return return
} }
} }
if (SystemClock.elapsedRealtime() - started > 15_000) { val elapsed = SystemClock.elapsedRealtime() - started
notifyUnavailable("连接 QFT Wi-Fi 超时。请确认电脑热点仍在运行。") if (!associationRetried && elapsed > 8_000) {
associationRetried = true
notifyStatus("旧版 Android 首次关联未完成,正在刷新热点并重试…")
try { wifiManager.startScan() } catch (_: Exception) {}
try {
wifiManager.disconnect()
wifiManager.enableNetwork(targetId, true)
wifiManager.reconnect()
} catch (_: Exception) {}
}
if (elapsed > 30_000) {
notifyUnavailable(
"连接 QFT Wi-Fi 超时。已使用二维码中的最新密码重建网络;" +
"请确认发送手机仍停留在二维码页面,并检查旧手机的系统定位是否开启。"
)
} else { } else {
handler.postDelayed({ poll() }, 250) handler.postDelayed({ poll() }, 250)
} }
@@ -310,7 +371,7 @@ class WifiConnector(context: Context) {
return return
} }
if (SystemClock.elapsedRealtime() - started > 6_000) { if (SystemClock.elapsedRealtime() - started > 6_000) {
onStatus("网络已连接但路由仍未就绪,继续尝试电脑发现…") onStatus("网络已连接但路由仍未就绪,继续尝试发送设备发现…")
done() done()
} else { } else {
handler.postDelayed({ poll() }, 120) handler.postDelayed({ poll() }, 120)
@@ -532,18 +593,28 @@ class WifiConnector(context: Context) {
callback = null callback = null
currentNetwork = null currentNetwork = null
listener = null listener = null
pendingSsid = null pendingWifi = null
pendingDelivered = null pendingDelivered = null
pendingTerminal = null pendingTerminal = null
handler.removeCallbacksAndMessages(null) handler.removeCallbacksAndMessages(null)
if (restoreLegacy && Build.VERSION.SDK_INT < 29) { if (Build.VERSION.SDK_INT < 29) {
val target = legacyTargetNetworkId
val previous = legacyPreviousNetworkId val previous = legacyPreviousNetworkId
if (previous != null && previous >= 0) { if (restoreLegacy && previous != null && previous >= 0 && previous != target) {
try { try {
wifiManager.enableNetwork(previous, true) wifiManager.enableNetwork(previous, true)
wifiManager.reconnect() wifiManager.reconnect()
} catch (_: Exception) {} } catch (_: Exception) {}
} }
// A QFT hotspot is session-scoped. Keeping its generated SSID/PSK
// in the legacy saved-network list is what made a later reservation
// with the same SSID silently reuse stale credentials.
if (target != null && target >= 0) {
try {
wifiManager.removeNetwork(target)
wifiManager.saveConfiguration()
} catch (_: Exception) {}
}
} }
legacyPreviousNetworkId = null legacyPreviousNetworkId = null
legacyTargetNetworkId = null legacyTargetNetworkId = null
@@ -0,0 +1,35 @@
package com.qft.optical
import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue
import org.junit.Test
class PhoneQrLayoutTest {
@Test
fun phoneUsesWidthWithoutOverflowingTheRemainingHeight() {
// 360 × 800 dp at 3× density: width is the limiting dimension.
assertEquals(960, phoneQrSidePx(1080, 2400, 3f))
}
@Test
fun tabletQrDoesNotExpandToTheFullContentWidth() {
// 800 × 1280 dp portrait tablet at 2×: width limits the QR before overflow.
val side = phoneQrSidePx(1600, 2560, 2f)
assertEquals(1520, side)
assertTrue(side + 600 <= 2560)
}
@Test
fun shortOrSplitWindowPrioritizesNoOverflow() {
// 320 × 480 dp at 2×: height becomes the limiting dimension.
val side = phoneQrSidePx(640, 960, 2f)
assertEquals(360, side)
assertTrue(side <= 640)
assertTrue(side + 600 <= 960)
}
@Test
fun invalidMetricsStillReturnASafePositiveSize() {
assertEquals(1, phoneQrSidePx(0, 0, Float.NaN))
}
}
@@ -4,12 +4,28 @@ import org.junit.Assert.*
import org.junit.Test import org.junit.Test
import java.nio.ByteBuffer import java.nio.ByteBuffer
import java.nio.ByteOrder import java.nio.ByteOrder
import java.io.ByteArrayInputStream
import java.util.concurrent.Callable import java.util.concurrent.Callable
import java.util.concurrent.ExecutorCompletionService import java.util.concurrent.ExecutorCompletionService
import java.util.concurrent.Executors import java.util.concurrent.Executors
import java.util.zip.CRC32 import java.util.zip.CRC32
class ProtocolTest { class ProtocolTest {
@Test
fun phoneShareHashRequiresTheAdvertisedExactSize() {
val bytes = "phone-share-stable-snapshot".toByteArray()
assertEquals(
"83511688f11a9cb98da9339966f6a0b97e48913102aaad39ae395d2e88f3f65f",
phoneShareSha256Exact(ByteArrayInputStream(bytes), bytes.size.toLong()),
)
assertThrows(IllegalArgumentException::class.java) {
phoneShareSha256Exact(ByteArrayInputStream(bytes), bytes.size.toLong() + 1L)
}
assertThrows(IllegalArgumentException::class.java) {
phoneShareSha256Exact(ByteArrayInputStream(bytes), bytes.size.toLong() - 1L)
}
}
@Test @Test
fun directDiscoveryCarriesTheAndroidDeviceName() { fun directDiscoveryCarriesTheAndroidDeviceName() {
val request = directDiscoveryRequest( val request = directDiscoveryRequest(
@@ -158,6 +174,36 @@ class ProtocolTest {
assertTrue(payload.endpoints.isEmpty()) assertTrue(payload.endpoints.isEmpty())
} }
@Test
fun androidPhoneShareQrRoundTripsWithoutEmbeddingTheFileQueue() {
val text = PairingProtocol.encodePhoneShare(
session = "abcdefghijklmnopqrstuvwxyz012345",
senderName = "HUAWEI Mate",
port = 41888,
endpoints = emptyList(),
wifi = WifiCredentials("QFT-Android", "0123456789abcdef", "WPA3"),
)
val payload = PairingProtocol.parse(text)!!
assertTrue(text.startsWith(PairingProtocol.PREFIX_PHONE_V2))
assertEquals(TransferDirection.PHONE_TO_PHONE, payload.direction)
assertEquals("HUAWEI Mate", payload.pcName)
assertEquals("WPA3", payload.wifi?.security)
assertNull(payload.fileName)
assertEquals("/qft/download", payload.downloadPath)
}
@Test
fun androidPhoneShareAcceptsOnlyBoundedByteRanges() {
assertEquals(0L to 9L, phoneShareRange(null, 10))
assertEquals(2L to 9L, phoneShareRange("bytes=2-", 10))
assertEquals(2L to 6L, phoneShareRange("bytes=2-6", 10))
assertNull(phoneShareRange("bytes=-3", 10))
assertNull(phoneShareRange("bytes=8-3", 10))
assertNull(phoneShareRange("bytes=10-", 10))
assertNull(phoneShareRange("items=0-2", 10))
}
@Test @Test
fun base45KnownVectors() { fun base45KnownVectors() {
assertArrayEquals("AB".toByteArray(), Base45.decode("BB8")) assertArrayEquals("AB".toByteArray(), Base45.decode("BB8"))
+45
View File
@@ -0,0 +1,45 @@
# Android → Android 真机验收(v0.5.0-dev5)
## 构建约束
在 Windows 的 Android 开发环境构建。本仓库的 macOS 封版流程不会安装或调用 Android SDK。
```powershell
cd android
.\gradlew.bat :app:testDebugUnitTest :app:assembleDebug
```
## 首轮验收
1. 两台 Android 安装同一个 `v0.5.0-dev5` APK。
2. 发送手机进入“手机 → 手机”,选择至少两个文件并调整一次顺序。
3. 点击“创建发送二维码”,允许附近 Wi-Fi/位置权限。
4. 接收手机进入“扫码直传”,扫描发送手机二维码并确认系统连接提示。
5. 核对接收顺序与发送队列一致,文件位于 `Downloads/QFT`,大小与 SHA-256 一致。
建议首轮文件组合:空文件、100 KiB 文档、20 MiB 视频、100 MiB 压缩包。
## 必测网络组合
- Android 13+ → Android 13+:`NEARBY_WIFI_DEVICES` 权限;专用网络先用自动频段,支持时应协商到 5 GHz,不得固定在 2.4 GHz。
- Android 13+ 发送 → Android 7–9 接收:旧机扫码后持续搜索同一个 `DIRECT-*`;发送端 12 秒未收到认证请求时,以相同 SSID/密码切换到 2.4 GHz,旧机无需重新扫码即可连接。
- Android 13+ 发送 → Android 10–12 接收:新会话即使复用了热点名称,只要密码变化就必须创建新的系统配网请求。
- Wi-Fi Direct 被 OEM 禁用:发送端自动回落 LocalOnlyHotspot;纯 WPA3 且接收机不支持 SAE 时自动尝试原局域网,不应无限搜索。
- Android 7–9 发送 → Android 13+ 接收:至少传输一个 100 MiB 文件两次,均通过 SHA-256,不得再出现整文件重下后仍校验失败。
- Android 10+ 高速链路:接收端在 12 秒内完成认证后,发送端不得切换频段或中断现有 5 GHz 连接。
- Android 7 发送端:验证系统生成的 `DIRECT-*` WPA2 组可被高版本接收端自动加入;P2P 创建失败时再验证同局域网回落。
- 手动停止发送端热点:接收端应报连接中断,而不是无限等待。
- 传输中返回发送端首页:服务和临时热点应立即关闭。
## 二维码布局组合
- 普通手机:二维码、状态、网络信息和停止按钮应在首屏完整显示。
- 10–14 英寸平板:二维码按窗口宽高取较小限制,不应拉伸到全宽后挤出下方按钮。
- 分屏/小窗:重新进入发送二维码页后,应按当前应用窗口而非物理屏幕分辨率计算尺寸。
## 当前边界
- 仅文件,不包含文件夹。
- 发送与接收页面需保持前台;尚未引入前台服务。
- Wi-Fi Direct/LocalOnlyHotspot 没有互联网是预期行为,文件只在本地链路传输。
- Android ↔ iOS 不在本开发版本范围内。
+30
View File
@@ -98,3 +98,33 @@ Range: bytes=<start>-<end>
The sender returns `206 Partial Content`, the matching `Content-Range`, and the exact requested body length. Android splits the file toward 8 workers with **64 KiB–16 MiB** chunks, stores each completed chunk in a `.qftpart.map` ledger, and resumes only missing chunks after a reconnect. Each range retries with the currently available `Network`; the complete partial file must pass SHA-256 before it is published to `Downloads/QFT`. The sender returns `206 Partial Content`, the matching `Content-Range`, and the exact requested body length. Android splits the file toward 8 workers with **64 KiB–16 MiB** chunks, stores each completed chunk in a `.qftpart.map` ledger, and resumes only missing chunks after a reconnect. Each range retries with the currently available `Network`; the complete partial file must pass SHA-256 before it is published to `Downloads/QFT`.
For both direct-transfer directions, the Windows listener may accept connections non-blockingly for shutdown responsiveness, but each accepted file socket is switched to blocking I/O with explicit timeouts before reading or writing request bodies. This prevents `WSAEWOULDBLOCK (10035)` from turning an in-progress parallel transfer into an HTTP 500 failure. For both direct-transfer directions, the Windows listener may accept connections non-blockingly for shutdown responsiveness, but each accepted file socket is switched to blocking I/O with explicit timeouts before reading or writing request bodies. This prevents `WSAEWOULDBLOCK (10035)` from turning an in-progress parallel transfer into an HTTP 500 failure.
## 6. Android → Android (`QFTPHONE2`, v0.5.0-dev5)
The sender starts an authenticated local HTTP service and encodes only session,
port, sender identity and optional dedicated-network credentials in the QR. The
file queue is fetched after pairing so QR density is independent of queue size:
```text
GET /qft/ping
GET /qft/phone/manifest
GET /qft/phone/download/<queue-index>
Range: bytes=<start>-<end>
X-QFT-Token: <one-time session>
```
The manifest contains a bounded ordered list of `name`, `size`, `sha256` and a
server-generated fixed download path. The receiver does not accept arbitrary
paths from the QR or manifest: entry `N` must use `/qft/phone/download/N`.
Android 10+ first creates a WPA2 Wi-Fi Direct group-owner AP with automatic band
selection, normally allowing a 5 GHz link. If no authenticated peer arrives in
12 seconds, the sender recreates the group on 2.4 GHz with the exact same SSID
and passphrase, so an older receiver's pending scan continues without a new QR.
An OEM P2P failure falls back to LocalOnlyHotspot, then literal private IPv4
endpoints on the current LAN. WPA2/WPA3
credentials are distinguished in `w[2]`. The receiver reuses the existing Range
ledger, retries and SHA-256-before-publish behavior for every file, processing
items in manifest order. Phone senders use one deterministic Range worker to
avoid concurrent-read corruption in older Android document providers; desktop
senders retain up to eight workers.
BIN
View File
Binary file not shown.
+17
View File
@@ -5,6 +5,23 @@ func sha256Hex(_ data: Data) -> String {
SHA256.hash(data: data).map { String(format: "%02x", $0) }.joined() SHA256.hash(data: data).map { String(format: "%02x", $0) }.joined()
} }
extension Data {
/// 十六进制字符串转字节。只在测试里造光学清单时用。
init?(hexString: String) {
guard hexString.count % 2 == 0 else { return nil }
var bytes = [UInt8]()
bytes.reserveCapacity(hexString.count / 2)
var index = hexString.startIndex
while index < hexString.endIndex {
let next = hexString.index(index, offsetBy: 2)
guard let byte = UInt8(hexString[index..<next], radix: 16) else { return nil }
bytes.append(byte)
index = next
}
self.init(bytes)
}
}
/// 从管道里读一行,带超时。用来等 MockPCServer 打印 `READY <port>`。 /// 从管道里读一行,带超时。用来等 MockPCServer 打印 `READY <port>`。
func readReadyLine(from handle: FileHandle, timeout: TimeInterval) -> String? { func readReadyLine(from handle: FileHandle, timeout: TimeInterval) -> String? {
let deadline = Date().addingTimeInterval(timeout) let deadline = Date().addingTimeInterval(timeout)
+52 -14
View File
@@ -76,35 +76,50 @@ class Handler(BaseHTTPRequestHandler):
def _download(self): def _download(self):
path = STATE["serve"] path = STATE["serve"]
size = os.path.getsize(path) size = os.path.getsize(path)
offset = 0
header = self.headers.get("Range") header = self.headers.get("Range")
# 老版本/别的实现可能整个忽略 Range,直接把整份文件送过来。
# 客户端必须能识别这种服务端并回落单流下载。
if STATE.get("ignore_range"):
header = None
# 与 sender.rs::parse_range 同一套语义:开区间与闭区间都接受,
# 不支持后缀 Range,越界一律拒绝。
offset, end = 0, max(size - 1, 0)
if header: if header:
assert header.startswith("bytes="), "只支持 bytes= 形式的 Range" assert header.startswith("bytes="), "只支持 bytes= 形式的 Range"
assert header.endswith("-"), "sender.rs 只支持单段开区间 Range" start_text, _, end_text = header[len("bytes="):].partition("-")
offset = int(header[len("bytes="):-1]) assert start_text, "不支持后缀 Range"
assert 0 <= offset < size, "Range 越界" offset = int(start_text)
remaining = size - offset end = int(end_text) if end_text else size - 1
assert 0 <= offset < size and offset <= end < size, "Range 越界"
remaining = 0 if size == 0 else end - offset + 1
self.send_response(206 if offset else 200) self.send_response(206 if header else 200)
self.send_header("Content-Type", "application/octet-stream") self.send_header("Content-Type", "application/octet-stream")
self.send_header("Content-Length", str(remaining)) self.send_header("Content-Length", str(remaining))
self.send_header("Accept-Ranges", "bytes") self.send_header("Accept-Ranges", "bytes")
if offset: if header:
self.send_header("Content-Range", "bytes %d-%d/%d" % (offset, size - 1, size)) self.send_header("Content-Range", "bytes %d-%d/%d" % (offset, end, size))
self.send_header("X-QFT-Filename", b64url_encode(os.path.basename(path).encode("utf-8"))) self.send_header("X-QFT-Filename", b64url_encode(os.path.basename(path).encode("utf-8")))
self.send_header("Connection", "close") # 并行下载会在一条连接上连续发多个 Range 请求,
# sender.rs 对这种请求保持 keep-alive
self.send_header("Connection", "keep-alive")
self.end_headers() self.end_headers()
with open(path, "rb") as fh: with open(path, "rb") as fh:
fh.seek(offset) fh.seek(offset)
while True: left = remaining
block = fh.read(256 * 1024) while left > 0:
block = fh.read(min(256 * 1024, left))
if not block: if not block:
break break
self.wfile.write(block) self.wfile.write(block)
left -= len(block)
# -------------------------------------------------- POST # -------------------------------------------------- POST
def do_POST(self): def do_POST(self):
# 配对是唯一不校验令牌的端点——它的作用正是换取令牌
if self.path == "/qft/pair":
return self._pair()
if not self._authorized(): if not self._authorized():
return return
if self.path == "/qft/upload/init": if self.path == "/qft/upload/init":
@@ -115,6 +130,20 @@ class Handler(BaseHTTPRequestHandler):
return self._upload_finish() return self._upload_finish()
return self._json(404, {"ok": False}) return self._json(404, {"ok": False})
def _pair(self):
"""receiver.rs::handle_pair:6 位十六进制秘密换会话令牌,错 5 次作废。"""
max_failures = 5
if STATE["pair_failures"] >= max_failures:
return self._json(429, {"ok": False, "error": "配对码已因多次输入错误作废"})
if self.headers.get("X-QFT-Code") != STATE["code"]:
STATE["pair_failures"] += 1
return self._json(403, {
"ok": False,
"remaining": max_failures - STATE["pair_failures"],
})
STATE["pair_failures"] = 0
return self._json(200, {"ok": True, "token": STATE["token"]})
def _upload_init(self): def _upload_init(self):
name = b64url_decode(self.headers["X-QFT-Filename"]).decode("utf-8") name = b64url_decode(self.headers["X-QFT-Filename"]).decode("utf-8")
size = int(self.headers["X-QFT-Size"]) size = int(self.headers["X-QFT-Size"])
@@ -187,7 +216,7 @@ class Handler(BaseHTTPRequestHandler):
def udp_responder(token, http_port, stop): def udp_responder(token, http_port, stop):
"""QFTDISC2:<token> → QFTHERE2:<token>:<port>,对应 sender.rs 的发现线程。""" """receiver.rs 的 UDP 线程:既回 QFTDISC2,也回不带令牌的 QFTBROWSE3。"""
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
try: try:
@@ -197,6 +226,9 @@ def udp_responder(token, http_port, stop):
sock.settimeout(0.25) sock.settimeout(0.25)
expected = ("QFTDISC2:%s" % token).encode("ascii") expected = ("QFTDISC2:%s" % token).encode("ascii")
reply = ("QFTHERE2:%s:%d" % (token, http_port)).encode("ascii") reply = ("QFTHERE2:%s:%d" % (token, http_port)).encode("ascii")
announce = ("QFTNODE3:" + json.dumps(
{"n": "MOCK-PC", "p": "macos", "t": http_port, "r": True},
separators=(",", ":"))).encode("utf-8")
while not stop.is_set(): while not stop.is_set():
try: try:
data, peer = sock.recvfrom(512) data, peer = sock.recvfrom(512)
@@ -204,7 +236,9 @@ def udp_responder(token, http_port, stop):
continue continue
except OSError: except OSError:
break break
if data == expected: if data == b"QFTBROWSE3":
sock.sendto(announce, peer)
elif data == expected:
sock.sendto(reply, peer) sock.sendto(reply, peer)
sock.close() sock.close()
@@ -216,9 +250,13 @@ def main():
parser.add_argument("--save-dir", required=True, help="接收上传的目录") parser.add_argument("--save-dir", required=True, help="接收上传的目录")
parser.add_argument("--port", type=int, default=0) parser.add_argument("--port", type=int, default=0)
parser.add_argument("--udp", action="store_true", help="同时启动 UDP 发现应答") parser.add_argument("--udp", action="store_true", help="同时启动 UDP 发现应答")
parser.add_argument("--code", default="a1b2c3", help="/qft/pair 使用的 6 位十六进制秘密")
parser.add_argument("--ignore-range", action="store_true",
help="模拟不支持分段下载的电脑端,永远返回 200 整份文件")
args = parser.parse_args() args = parser.parse_args()
STATE.update(token=args.token, serve=args.serve, save_dir=args.save_dir, uploads={}) STATE.update(token=args.token, serve=args.serve, save_dir=args.save_dir, uploads={},
code=args.code, pair_failures=0, ignore_range=args.ignore_range)
os.makedirs(args.save_dir, exist_ok=True) os.makedirs(args.save_dir, exist_ok=True)
server = ThreadingHTTPServer(("127.0.0.1", args.port), Handler) server = ThreadingHTTPServer(("127.0.0.1", args.port), Handler)
+486 -25
View File
@@ -6,6 +6,10 @@ import Foundation
// 集成测试跑在 MockPCServer.py 上,该 mock 严格复刻 receiver.rs / sender.rs // 集成测试跑在 MockPCServer.py 上,该 mock 严格复刻 receiver.rs / sender.rs
// 的线上语义,因此这里通过 == 线格式与 Windows 端兼容。 // 的线上语义,因此这里通过 == 线格式与 Windows 端兼容。
// 输出重定向到文件/管道时 stdout 默认是块缓冲的,一旦中途 trap 就什么都看不到,
// 排查成本极高。改成行缓冲。
setvbuf(stdout, nil, _IOLBF, 0)
var failures = 0 var failures = 0
var checks = 0 var checks = 0
@@ -129,6 +133,284 @@ checkEqual(LocalNetwork.ipv4("192.168.1.20"), 0xC0A80114, "IPv4 转整数")
checkEqual(LocalNetwork.format(0xC0A80114), "192.168.1.20", "整数转 IPv4") checkEqual(LocalNetwork.format(0xC0A80114), "192.168.1.20", "整数转 IPv4")
check(LocalNetwork.ipv4("192.168.1.256") == nil, "拒绝越界八位组") check(LocalNetwork.ipv4("192.168.1.256") == nil, "拒绝越界八位组")
// iOS SDK 不导出 net/route.h,路由表报文只能按手写偏移解析。
// macOS SDK 有真类型,在这里逐字段交叉校验——布局一旦变了立刻红。
typealias RM = LocalNetwork.RouteMessage
checkEqual(RM.headerSize, MemoryLayout<rt_msghdr>.size, "rt_msghdr 大小")
checkEqual(RM.messageLengthOffset, MemoryLayout<rt_msghdr>.offset(of: \.rtm_msglen), "rtm_msglen 偏移")
checkEqual(RM.versionOffset, MemoryLayout<rt_msghdr>.offset(of: \.rtm_version), "rtm_version 偏移")
checkEqual(RM.interfaceIndexOffset, MemoryLayout<rt_msghdr>.offset(of: \.rtm_index), "rtm_index 偏移")
checkEqual(RM.addressMaskOffset, MemoryLayout<rt_msghdr>.offset(of: \.rtm_addrs), "rtm_addrs 偏移")
checkEqual(Int32(RM.version), Int32(RTM_VERSION), "RTM_VERSION")
checkEqual(RM.gatewayFlag, Int32(RTF_GATEWAY), "RTF_GATEWAY")
checkEqual(RM.addressSlots, Int(RTAX_MAX), "RTAX_MAX")
checkEqual(RM.destinationSlot, Int(RTAX_DST), "RTAX_DST")
checkEqual(RM.gatewaySlot, Int(RTAX_GATEWAY), "RTAX_GATEWAY")
// 路由表读的是本机真实状态,不能断言具体内容,但**必须**保证:
// 不崩、且返回的东西全部是私有 IPv4——它会被直接当成电脑地址去连。
let gateways = LocalNetwork.defaultGateways()
check(gateways.allSatisfy(PairingProtocol.isPrivateIPv4), "默认网关全部是私有 IPv4(读到 \(gateways.count) 个)")
check(LocalNetwork.directedBroadcastAddresses().allSatisfy { $0.split(separator: ".").count == 4 },
"定向广播地址格式正确")
let candidates = LocalNetwork.hostCandidates(port: 39393, limit: 8)
check(candidates.allSatisfy { PairingProtocol.isAllowedLocalHTTPEndpoint($0, expectedPort: 39393) },
"候选地址全部过端点白名单")
check(Set(candidates).count == candidates.count, "候选地址无重复")
// ---------------------------------------------------------------- 专用网络
section("专用网络(Windows QFT Direct)")
let directText = makePairingText(prefix: "QFTPAIR2:", [
"v": 2, "s": session, "n": "DESKTOP-QFT", "p": 39393,
"e": [], "w": ["QFT-PC-abc123", "0123456789abcdef"],
])
let direct = PairingProtocol.parse(directText)
check(direct != nil, "接受只带 Wi-Fi 凭据、不带地址的专用网络二维码")
checkEqual(direct?.wifi, WifiCredentials(ssid: "QFT-PC-abc123", passphrase: "0123456789abcdef"), "Wi-Fi 凭据")
check(direct?.endpoints.isEmpty == true, "专用网络二维码不带任何电脑地址")
check(PairingProtocol.parse(makePairingText(prefix: "QFTPAIR2:", [
"v": 2, "s": session, "p": 39393, "e": [],
])) == nil, "既无地址又无 Wi-Fi 时拒绝")
check(PairingProtocol.parse(makePairingText(prefix: "QFTPAIR2:", [
"v": 2, "s": session, "p": 39393, "e": [], "w": ["QFT-PC", "short"],
])) == nil, "Wi-Fi 密码过短时拒绝")
let lanPairing = PairingPayload(version: 2, session: session, pcName: "MAC", port: 39393,
endpoints: ["http://192.168.1.9:39393"], wifi: nil,
direction: .uploadToPC, fileName: nil, fileSize: nil, sha256: nil)
checkEqual(DedicatedNetworkPlan.plan(for: lanPairing, canJoinProgrammatically: true),
.useEndpoints(["http://192.168.1.9:39393"]), "有地址时直接连,不去动 Wi-Fi")
checkEqual(DedicatedNetworkPlan.plan(for: direct!, canJoinProgrammatically: true),
.joinWifi(direct!.wifi!), "有能力时自动加入专用 Wi-Fi")
checkEqual(DedicatedNetworkPlan.plan(for: direct!, canJoinProgrammatically: false),
.manualJoin(direct!.wifi!), "没有 entitlement 时转为手动加入引导,而不是假装成功")
// ---------------------------------------------------------------- Base45
section("Base45(与 desktop/src/base45.rs 同一组向量)")
checkEqual(Base45.encode(Data("AB".utf8)), "BB8", "编码 AB")
checkEqual(Base45.encode(Data("Hello!!".utf8)), "%69 VD92EX0", "编码 Hello!!")
checkEqual(Base45.encode(Data("base-45".utf8)), "UJCLQE7W581", "编码 base-45")
checkEqual(Base45.decode("BB8"), Data("AB".utf8), "解码 BB8")
checkEqual(Base45.decode("%69 VD92EX0"), Data("Hello!!".utf8), "解码 Hello!!")
checkEqual(Base45.decode("K1"), Data([0x41]), "两字符尾块解出单字节")
check(Base45.decode("AB") == nil, "两字符尾块超过 0xFF 时拒绝(A+B*45=505)")
check(Base45.decode("A") == nil, "长度 %3==1 时拒绝")
check(Base45.decode("ab") == nil, "小写不在字母表内,拒绝")
check(Base45.decode("::::::") == nil, "超过 0xFFFF 的三元组拒绝")
var base45RoundTripOK = true
for _ in 0..<200 {
let raw = Data((0..<Int.random(in: 0...600)).map { _ in UInt8.random(in: 0...255) })
if Base45.decode(Base45.encode(raw)) != raw { base45RoundTripOK = false; break }
}
check(base45RoundTripOK, "200 组随机字节 Base45 往返一致")
// ---------------------------------------------------------------- 光学协议
section("光学 QFT2 帧")
func opticalPlaylist(payload: Data, chunkSize: Int, name: String,
sessionID: UInt64 = 0x0123_4567_89ab_cdef) -> (OpticalManifest, [String]) {
let total = payload.isEmpty ? 0 : UInt32((payload.count + chunkSize - 1) / chunkSize)
let manifest = OpticalManifest(
sessionID: sessionID, senderDevice: "DESKTOP-QFT", fileName: name,
fileSize: UInt64(payload.count), chunkSize: chunkSize, totalChunks: total,
sha256: Data(hexString: sha256Hex(payload))!)
var frames = [OpticalProtocol.text(for: OpticalProtocol.encodeManifest(manifest))]
for index in 0..<Int(total) {
let start = index * chunkSize
let end = min(start + chunkSize, payload.count)
frames.append(OpticalProtocol.text(for: OpticalProtocol.encodeFrame(
kind: .data, sessionID: sessionID, seq: UInt32(index),
totalChunks: total, payload: payload.subdata(in: start..<end))))
}
frames.append(OpticalProtocol.text(for: OpticalProtocol.encodeFrame(
kind: .end, sessionID: sessionID, seq: 0, totalChunks: total, payload: Data())))
return (manifest, frames)
}
let opticalPayload = Data((0..<4321).map { UInt8($0 % 251) })
let (opticalManifest, opticalFrames) = opticalPlaylist(payload: opticalPayload,
chunkSize: 450, name: "报告.pdf")
check(opticalFrames.allSatisfy { $0.hasPrefix("QFT2:") }, "帧文本前缀为 QFT2:")
check(opticalFrames.allSatisfy(OpticalProtocol.isOpticalText), "全部被识别为光学帧")
let parsedManifest = OpticalProtocol.parseText(opticalFrames[0]).flatMap(OpticalProtocol.parseManifest)
checkEqual(parsedManifest, opticalManifest, "清单帧编解码往返一致")
checkEqual(parsedManifest?.fileName, "报告.pdf", "文件名支持中文")
checkEqual(parsedManifest?.sha256Hex, sha256Hex(opticalPayload), "清单里的 SHA-256")
// CRC 是唯一能挡住「语法合法但内容错误」的相机误识别的手段
var corrupted = OpticalProtocol.encodeFrame(kind: .data, sessionID: 1, seq: 0,
totalChunks: 1, payload: Data([1, 2, 3]))
corrupted[OpticalProtocol.headerSize] ^= 0x40
check(OpticalProtocol.parseBinary(corrupted, magic: "QFT2", version: 2) == nil, "CRC 不符时整帧丢弃")
check(OpticalProtocol.parseText("QFT2:" + String(repeating: "0", count: 60)) == nil, "噪声文本不会被当成帧")
check(OpticalProtocol.parseText("QFT2:") == nil, "空帧被拒绝")
check(OpticalProtocol.parseText("hello") == nil, "非 QFT 文本被忽略")
checkEqual(OpticalProtocol.sanitizeFileName("../../etc/passwd"), "etc_passwd", "文件名里的路径分隔符被清掉")
checkEqual(OpticalProtocol.sanitizeFileName(" "), "qft.bin", "空文件名有兜底")
// ---------------------------------------------------------------- 光学装配
section("光学会话装配")
let opticalRoot = URL(fileURLWithPath: NSTemporaryDirectory())
.appendingPathComponent("qft-optical-\(UUID().uuidString)", isDirectory: true)
try! FileManager.default.createDirectory(at: opticalRoot, withIntermediateDirectories: true)
var opticalSaved: URL?
var opticalErrors: [String] = []
var opticalProgressSeen = 0
let assembler = OpticalAssembler(destinationDirectory: opticalRoot,
workDirectory: opticalRoot.appendingPathComponent("work")) { event in
switch event {
case .completed(_, let url): opticalSaved = url
case .failed(let message): opticalErrors.append(message)
case .progress(_, let received, _): opticalProgressSeen = received
case .started: break
}
}
// 真实场景是循环重播:乱序 + 大量重复
var duplicates = 0
var accepted = 0
for text in opticalFrames.shuffled() + opticalFrames {
switch assembler.accept(text: text) {
case .accepted: accepted += 1
case .duplicate: duplicates += 1
case .ignored: break
}
}
check(opticalErrors.isEmpty, "乱序重播过程中没有错误:\(opticalErrors)")
check(opticalSaved != nil, "收齐后自动落盘")
check(duplicates > 0, "重复帧被识别为 duplicate(\(duplicates) 帧),不会重复计入吞吐")
checkEqual(accepted, Int(opticalManifest.totalChunks) + 1, "有效新帧数 = 数据片数 + 清单")
check(opticalProgressSeen == Int(opticalManifest.totalChunks), "进度回调走到最后一片")
if let opticalSaved {
let data = try! Data(contentsOf: opticalSaved)
checkEqual(sha256Hex(data), sha256Hex(opticalPayload), "落盘内容 SHA-256 一致")
checkEqual(opticalSaved.lastPathComponent, "报告.pdf", "落盘文件名正确")
}
// 摘要对不上时必须整份丢弃,绝不把半份文件交给用户
var tamperedError: String?
let tamperedAssembler = OpticalAssembler(
destinationDirectory: opticalRoot.appendingPathComponent("bad"),
workDirectory: opticalRoot.appendingPathComponent("work")) { event in
if case .failed(let message) = event { tamperedError = message }
}
let liar = OpticalManifest(sessionID: 42, senderDevice: "PC", fileName: "x.bin",
fileSize: UInt64(opticalPayload.count), chunkSize: 450,
totalChunks: UInt32((opticalPayload.count + 449) / 450),
sha256: Data(repeating: 0xAB, count: 32))
tamperedAssembler.accept(text: OpticalProtocol.text(for: OpticalProtocol.encodeManifest(liar)))
for index in 0..<Int(liar.totalChunks) {
let start = index * 450
let end = min(start + 450, opticalPayload.count)
tamperedAssembler.accept(text: OpticalProtocol.text(for: OpticalProtocol.encodeFrame(
kind: .data, sessionID: 42, seq: UInt32(index), totalChunks: liar.totalChunks,
payload: opticalPayload.subdata(in: start..<end))))
}
check(tamperedError?.contains("SHA-256") == true, "整份校验失败时报错并丢弃")
check(!FileManager.default.fileExists(
atPath: opticalRoot.appendingPathComponent("bad/x.bin").path), "校验失败的文件不会落到目标目录")
// 空文件是合法的边界:清单里 0 片,收到清单即完成
var emptySaved: URL?
let emptyAssembler = OpticalAssembler(
destinationDirectory: opticalRoot.appendingPathComponent("empty"),
workDirectory: opticalRoot.appendingPathComponent("work")) { event in
if case .completed(_, let url) = event { emptySaved = url }
}
let (_, emptyFrames) = opticalPlaylist(payload: Data(), chunkSize: 450, name: "empty.bin",
sessionID: 7)
emptyAssembler.accept(text: emptyFrames[0])
check(emptySaved != nil, "0 字节文件也能正常收完")
try? FileManager.default.removeItem(at: opticalRoot)
// ---------------------------------------------------------------- ROI
section("光学 ROI 状态机")
var roi = OpticalROI(aspect: 0.5625) // 竖屏 720×1280
check(!roi.isLocked, "初始为搜索态")
check(roi.decodeRegion.width > 0.8, "搜索态覆盖大半个画面")
roi.hit(boundingBox: CGRect(x: 0.30, y: 0.40, width: 0.20, height: 0.12))
check(roi.isLocked, "解出一帧后进入锁定")
let locked = roi.decodeRegion
check(locked.width < 0.6, "锁定后只解一小块(宽 \(String(format: "%.2f", locked.width)))")
// 归一化坐标在 9:16 画面上会把方码拉扁,ROI 必须按像素比例修方
check(abs(locked.width * 0.5625 - locked.height) < 0.02, "锁定框在像素意义上是正方形")
for _ in 0..<(OpticalROI.missesBeforeExpand + 1) { roi.miss() }
check(roi.decodeRegion.width > locked.width, "连续丢失后逐级放大 ROI")
for _ in 0..<OpticalROI.missesBeforeReacquire { roi.miss() }
check(!roi.isLocked && roi.decodeRegion.width > 0.8, "持续丢失后回到全画面重新搜索")
var edge = OpticalROI(aspect: 1)
edge.hit(boundingBox: CGRect(x: 0.95, y: 0.95, width: 0.2, height: 0.2))
let clamped = edge.decodeRegion
check(clamped.minX >= 0 && clamped.minY >= 0
&& clamped.maxX <= 1.0001 && clamped.maxY <= 1.0001, "越界的 ROI 被夹回画面内")
// ---------------------------------------------------------------- 连接码
section("桌面端连接码(与 desktop/src/connect_code.rs 交叉验证)")
// 这四组由 Rust 端实现直接产出,任何一边改了编码都会红
let codeVectors: [(String, Int, String, String)] = [
("192.168.1.20", 39393, "a1b2c3", "480H-98DJ-RCTG"),
("10.0.0.5", 39393, "010203", "4R00-0181-081P-P"),
("172.20.10.3", 40000, "ff007f", "5020-M0WW-83ZG-0ZTH"),
("127.0.0.1", 8080, "deadbe", "5HZG-0001-3Y8D-XBDY-98"),
]
for (address, port, secret, text) in codeVectors {
guard let decoded = try? ConnectCode.decode(text) else {
check(false, "解析 \(text) 失败"); continue
}
checkEqual(decoded.address, address, "\(text) 的地址")
checkEqual(decoded.port, port, "\(text) 的端口")
checkEqual(decoded.secretHex, secret, "\(text) 的秘密")
checkEqual(decoded.encode(), text, "\(text) 重新编码一致")
}
check((try? ConnectCode.decode("480h 98dj rctg")) != nil, "小写与空格分隔都接受")
check((try? ConnectCode.decode("48OH-98DJ-RCTG")) != nil, "Crockford 容错:O 当成 0")
check((try? ConnectCode.decode("480H-98DJ-RCTU")) == nil, "字母表外的字符被拒绝")
check((try? ConnectCode.decode("480H-98DJ-RCTF")) == nil, "改一位后校验失败")
check((try? ConnectCode.decode("480H")) == nil, "长度不足时拒绝")
check(try! ConnectCode.decode("480H-98DJ-RCTG").isUsable, "私有地址的连接码可用")
// 连接码同样是不可信输入:公网地址不能因为「码是对的」就放行
let publicCode = ConnectCode(address: "8.8.8.8", port: 39393, secret: [1, 2, 3])
check(!publicCode.isUsable, "公网地址的连接码被端点白名单拒绝")
// ---------------------------------------------------------------- 节点浏览
section("QFTBROWSE3 节点应答(不可信输入)")
let announce = #"QFTNODE3:{"n":"MacBook-Pro","p":"macos","t":39393,"r":true}"#
let peer = PeerBrowser.parseReply(announce, source: "192.168.1.20")
checkEqual(peer?.name, "MacBook-Pro", "节点名")
checkEqual(peer?.platform, "macos", "平台标识")
checkEqual(peer?.port, 39393, "端口")
checkEqual(peer?.baseURL, "http://192.168.1.20:39393", "base URL")
check(peer?.ready == true, "等待接收标志")
check(PeerBrowser.parseReply(announce, source: "8.8.8.8") == nil, "来源不是私有地址时丢弃")
check(PeerBrowser.parseReply(#"QFTNODE3:{"n":"x","p":"linux","t":0,"r":true}"#,
source: "10.0.0.2") == nil, "端口 0 的应答无意义")
check(PeerBrowser.parseReply("QFTHERE2:token:39393", source: "10.0.0.2") == nil, "前缀不符时丢弃")
check(PeerBrowser.parseReply("QFTNODE3:not-json", source: "10.0.0.2") == nil, "非 JSON 丢弃")
let dirty = PeerBrowser.parseReply(
"QFTNODE3:{\"n\":\"bad\\u0000name\",\"p\":\"linux!!\",\"t\":1,\"r\":false}", source: "10.0.0.2")
check(dirty?.name.contains("\0") == false, "节点名里的控制字符被清掉")
checkEqual(dirty?.platform, "linux", "平台标识只保留字母数字")
// ---------------------------------------------------------------- 集成测试 // ---------------------------------------------------------------- 集成测试
section("集成:与 MockPCServer 的完整传输") section("集成:与 MockPCServer 的完整传输")
@@ -226,6 +508,119 @@ if port > 0 {
check(false, "续传失败:\(error.localizedDescription)") check(false, "续传失败:\(error.localizedDescription)")
} }
// --- 并行 Range 下载 ---
do {
let parallelDir = root.appendingPathComponent("parallel", isDirectory: true)
let client = RangeDownloadClient(host: host, token: token, deviceName: "iPhone 测试机",
destinationDirectory: parallelDir)
// 没有二维码时靠 Range: bytes=0-0 问出文件名与总长度
let probed = try await client.probe()
checkEqual(probed.fileName, "payload.bin", "探测拿到文件名")
checkEqual(probed.fileSize, UInt64(payloadSize), "探测拿到总长度")
let target = RangeDownloadClient.Target(fileName: "payload.bin",
fileSize: UInt64(payloadSize),
sha256: payloadHash)
var parallelFraction = 0.0
let saved = try await client.run(target) { parallelFraction = $0.fraction }
let received = try Data(contentsOf: saved)
checkEqual(sha256Hex(received), payloadHash, "并行下载内容 SHA-256 一致")
check(parallelFraction > 0.99, "并行下载进度回调抵达 100%")
check(!FileManager.default.fileExists(atPath: saved.path + ".qftpart"), "分块临时文件已清理")
check(!FileManager.default.fileExists(
atPath: parallelDir.appendingPathComponent("payload.bin.qftpart.ledger").path),
"断点账本已清理")
try? FileManager.default.removeItem(at: saved)
// 并行分块是乱序落盘的,续传只能靠账本,不能靠「已落盘长度」
let partURL = parallelDir.appendingPathComponent("payload.bin.qftpart")
let ledgerURL = parallelDir.appendingPathComponent("payload.bin.qftpart.ledger")
let chunk = RangeDownloadClient.chunkSize(for: UInt64(payloadSize))
let totalChunks = Int((UInt64(payloadSize) + chunk - 1) / chunk)
var half = [Bool](repeating: false, count: totalChunks)
var scratch = Data(count: payloadSize)
for index in stride(from: 0, to: totalChunks, by: 2) {
half[index] = true
let start = Int(UInt64(index) * chunk)
let end = min(start + Int(chunk), payloadSize)
scratch.replaceSubrange(start..<end, with: payload[start..<end])
}
try scratch.write(to: partURL)
try DownloadLedger(size: UInt64(payloadSize), chunkSize: chunk,
sha256: payloadHash, completed: half).encode().write(to: ledgerURL)
let resumed = try await client.run(target) { _ in }
checkEqual(sha256Hex(try Data(contentsOf: resumed)), payloadHash,
"按账本只补缺失块后内容仍正确")
try? FileManager.default.removeItem(at: resumed)
} catch {
check(false, "并行下载失败:\(error.localizedDescription)")
}
// --- 不支持分段下载的电脑端:必须能被识别出来,交给上层回落单流 ---
do {
let legacyProcess = Process()
legacyProcess.executableURL = URL(fileURLWithPath: "/usr/bin/env")
legacyProcess.arguments = ["python3", mockScript.path, "--token", token,
"--serve", sourceURL.path, "--save-dir", saveDir.path,
"--port", "0", "--ignore-range"]
let legacyPipe = Pipe()
legacyProcess.standardOutput = legacyPipe
try legacyProcess.run()
defer { legacyProcess.terminate() }
let line = readReadyLine(from: legacyPipe.fileHandleForReading, timeout: 10) ?? ""
let legacyPort = Int(line.dropFirst("READY ".count).trimmingCharacters(in: .whitespaces)) ?? 0
check(legacyPort > 0, "不支持分段的 mock 已启动(端口 \(legacyPort))")
if legacyPort > 0 {
let legacyHost = QFTHost(baseURL: "http://127.0.0.1:\(legacyPort)")
let client = RangeDownloadClient(host: legacyHost, token: token,
deviceName: "iPhone 测试机",
destinationDirectory: root.appendingPathComponent("legacy"))
do {
_ = try await client.run(RangeDownloadClient.Target(
fileName: "payload.bin", fileSize: UInt64(payloadSize),
sha256: payloadHash)) { _ in }
check(false, "对端忽略 Range 时本应显式失败")
} catch QFTError.rangeUnsupported {
check(true, "对端忽略 Range 时抛出 rangeUnsupported,上层据此回落单流")
} catch {
check(false, "应抛 rangeUnsupported,实得 \(error)")
}
// 回落路径本身必须还能把文件收完整
let fallbackDir = root.appendingPathComponent("legacy-fallback")
try FileManager.default.createDirectory(at: fallbackDir, withIntermediateDirectories: true)
let fallbackPairing = PairingPayload(
version: 2, session: token, pcName: "OLD-PC", port: legacyPort,
endpoints: [legacyHost.baseURL], wifi: nil, direction: .downloadToPhone,
fileName: "payload.bin", fileSize: UInt64(payloadSize), sha256: payloadHash)
let saved = try await DownloadClient(host: legacyHost, pairing: fallbackPairing,
deviceName: "iPhone 测试机",
destinationDirectory: fallbackDir).run { _ in }
checkEqual(sha256Hex(try Data(contentsOf: saved)), payloadHash, "单流回落后内容仍正确")
}
} catch {
check(false, "分段回落用例失败:\(error.localizedDescription)")
}
// --- 连接码配对 ---
do {
let paired = try await DesktopPairing.pair(baseURL: base, code: "a1b2c3",
deviceName: "iPhone 测试机")
checkEqual(paired, token, "连接码换到会话令牌")
} catch {
check(false, "连接码配对失败:\(error.localizedDescription)")
}
do {
_ = try await DesktopPairing.pair(baseURL: base, code: "000000",
deviceName: "iPhone 测试机")
check(false, "错误连接码本应失败")
} catch {
check(true, "错误连接码被拒绝:\(error.localizedDescription)")
}
// --- 上传 --- // --- 上传 ---
let uploadPairing = PairingPayload( let uploadPairing = PairingPayload(
version: 2, session: token, pcName: "MOCK-PC", port: port, version: 2, session: token, pcName: "MOCK-PC", port: port,
@@ -267,49 +662,76 @@ process.terminate()
section("隔空投送式配对码") section("隔空投送式配对码")
let sampleQueue = try! PeerQueue.encode(sender: "我的 iPhone", files: [
PeerFileMeta(name: "视频.mov", size: 987_654_321, sha256: String(repeating: "cd", count: 32)),
PeerFileMeta(name: "笔记.txt", size: 12, sha256: String(repeating: "ef", count: 32)),
])
let peerSample = PeerPairing( let peerSample = PeerPairing(
version: 1, key: Data((0..<32).map { UInt8($0) }), instance: "qft-abcdefghijkl", version: 2, key: Data((0..<32).map { UInt8($0) }), instance: "qft-abcdefghijkl",
senderName: "我的 iPhone", fileName: "视频.mov", fileSize: 987_654_321, senderName: "我的 iPhone", fileCount: 2, totalSize: 987_654_333,
sha256: String(repeating: "cd", count: 32)) queueDigest: PeerQueue.digest(of: sampleQueue), previewName: "视频.mov")
let peerRoundTrip = PeerPairing.parse(peerSample.encode()) let peerRoundTrip = PeerPairing.parse(peerSample.encode())
checkEqual(peerRoundTrip, peerSample, "QFTP2P1 编解码往返一致") checkEqual(peerRoundTrip, peerSample, "QFTP2P2 编解码往返一致")
check(PeerPairing.isPeerText(peerSample.encode()), "前缀识别") check(PeerPairing.isPeerText(peerSample.encode()), "前缀识别")
check(PairingProtocol.parse(peerSample.encode()) == nil, "P2P 码不会被误判为 QFTPAIR2") check(PairingProtocol.parse(peerSample.encode()) == nil, "P2P 码不会被误判为 QFTPAIR2")
// 多文件的元数据留在链路上,二维码只带摘要——十几个文件的清单会让码密到扫不动
check(peerSample.encode().count < 400, "二维码内容不随文件数增长(\(peerSample.encode().count) 字符)")
func mutatedPeer(_ change: (inout [String: Any]) -> Void) -> String? { let queueRoundTrip = PeerQueue.decode(sampleQueue)
checkEqual(queueRoundTrip?.files.count, 2, "清单解析出两个文件")
checkEqual(queueRoundTrip?.files.first?.name, "视频.mov", "清单里的文件名")
check(PeerQueue.decode(Data("{}".utf8)) == nil, "空清单被拒绝")
check(PeerQueue.decode(Data(#"{"v":2,"files":[{"name":"../x","size":1,"sha256":"aa"}]}"#.utf8)) == nil,
"清单里的路径分隔符被拒绝")
func mutatedPeer(_ change: (inout [String: Any]) -> Void) -> String {
var object: [String: Any] = [ var object: [String: Any] = [
"v": 1, "k": Base64URL.encode(Data(repeating: 7, count: 32)), "v": 2, "k": Base64URL.encode(Data(repeating: 7, count: 32)),
"i": "qft-abcdefghijkl", "n": "iPhone", "f": "a.bin", "i": "qft-abcdefghijkl", "n": "iPhone", "c": 1, "z": 10,
"z": 10, "h": String(repeating: "ab", count: 32), "d": String(repeating: "ab", count: 32), "f": "a.bin",
] ]
change(&object) change(&object)
let data = try! JSONSerialization.data(withJSONObject: object) let data = try! JSONSerialization.data(withJSONObject: object)
return PeerPairing.prefix + Base64URL.encode(data) return PeerPairing.prefix + Base64URL.encode(data)
} }
check(PeerPairing.parse(mutatedPeer { $0["k"] = Base64URL.encode(Data(repeating: 7, count: 16)) }!) == nil, check(PeerPairing.parse(mutatedPeer { $0["k"] = Base64URL.encode(Data(repeating: 7, count: 16)) }) == nil,
"密钥不足 32 字节时拒绝") "密钥不足 32 字节时拒绝")
check(PeerPairing.parse(mutatedPeer { $0["i"] = "bad instance!" }!) == nil, "非法实例名时拒绝") check(PeerPairing.parse(mutatedPeer { $0["i"] = "bad instance!" }) == nil, "非法实例名时拒绝")
check(PeerPairing.parse(mutatedPeer { $0["f"] = "../../etc/passwd" }!) == nil, "文件名含路径分隔符时拒绝") check(PeerPairing.parse(mutatedPeer { $0["f"] = "../../etc/passwd" }) == nil, "预览文件名含路径分隔符时拒绝")
check(PeerPairing.parse(mutatedPeer { $0["h"] = "zz" }!) == nil, "摘要格式错误时拒绝") check(PeerPairing.parse(mutatedPeer { $0["d"] = "zz" }) == nil, "摘要格式错误时拒绝")
check(PeerPairing.parse(mutatedPeer { $0["c"] = 0 }) == nil, "文件数为 0 时拒绝")
check(PeerPairing.newKey().count == 32, "新密钥为 32 字节") check(PeerPairing.newKey().count == 32, "新密钥为 32 字节")
check(PeerPairing.isValidInstance(PeerPairing.newInstance()), "新实例名合法") check(PeerPairing.isValidInstance(PeerPairing.newInstance()), "新实例名合法")
check(PeerPairing.newKey() != PeerPairing.newKey(), "密钥每次不同") check(PeerPairing.newKey() != PeerPairing.newKey(), "密钥每次不同")
// ---------------------------------------------------------------- P2P 传输 // ---------------------------------------------------------------- P2P 传输
section("隔空投送式点对点传输(TLS-PSK 真实握手)") section("隔空投送式点对点传输(TLS-PSK 真实握手,多文件)")
let peerDir = root.appendingPathComponent("peer", isDirectory: true) let peerDir = root.appendingPathComponent("peer", isDirectory: true)
try! FileManager.default.createDirectory(at: peerDir, withIntermediateDirectories: true) try! FileManager.default.createDirectory(at: peerDir, withIntermediateDirectories: true)
// 三个大小各异的文件:大文件跨多个数据帧,空文件是最容易写错的边界
let peerSources: [(String, Data)] = [
("大文件.bin", payload),
("小文件.txt", Data("QFT 隔空多文件".utf8)),
("空文件.dat", Data()),
]
let peerURLs = peerSources.map { name, data -> URL in
let url = root.appendingPathComponent(name)
try! data.write(to: url)
return url
}
let peerTotal = peerSources.reduce(UInt64(0)) { $0 + UInt64($1.1.count) }
let peerSemaphore = DispatchSemaphore(value: 0) let peerSemaphore = DispatchSemaphore(value: 0)
Task { Task {
defer { peerSemaphore.signal() } defer { peerSemaphore.signal() }
let sender = PeerSender(fileURL: sourceURL, deviceName: "发送端 iPhone") let sender = PeerSender(fileURLs: peerURLs, deviceName: "发送端 iPhone")
do { do {
let pairing = try sender.start() let pairing = try sender.start()
checkEqual(pairing.fileSize, UInt64(payloadSize), "配对码里的文件大小") checkEqual(pairing.fileCount, 3, "配对码里的文件数")
checkEqual(pairing.sha256, payloadHash, "配对码里的 SHA-256 由发送端实算") checkEqual(pairing.totalSize, peerTotal, "配对码里的总字节数由发送端实读")
let port = try await sender.listeningPort() let port = try await sender.listeningPort()
check(port > 0, "监听器就绪(端口 \(port))") check(port > 0, "监听器就绪(端口 \(port))")
@@ -324,14 +746,23 @@ Task {
async let sendSide: Void = sender.waitAndSend { _ in } async let sendSide: Void = sender.waitAndSend { _ in }
var peerFraction = 0.0 var peerFraction = 0.0
let saved = try await receiver.run { peerFraction = $0.fraction } var seenNames: [String] = []
let saved = try await receiver.run {
peerFraction = $0.progress.fraction
if seenNames.last != $0.fileName { seenNames.append($0.fileName) }
}
try await sendSide try await sendSide
let data = try Data(contentsOf: saved) checkEqual(saved.count, 3, "三个文件全部落盘")
checkEqual(data.count, payloadSize, "P2P 收到字节数一致") for (index, source) in peerSources.enumerated() where index < saved.count {
checkEqual(sha256Hex(data), payloadHash, "P2P 收到内容 SHA-256 一致") let data = try Data(contentsOf: saved[index])
checkEqual(sha256Hex(data), sha256Hex(source.1), "\(source.0) 内容一致")
checkEqual(saved[index].lastPathComponent, source.0, "\(source.0) 文件名一致")
}
check(peerFraction > 0.99, "P2P 进度回调抵达 100%") check(peerFraction > 0.99, "P2P 进度回调抵达 100%")
check(!FileManager.default.fileExists(atPath: saved.path + ".qftpart"), "P2P 临时文件已清理") check(seenNames.count >= 2, "进度回调报告了当前文件名(\(seenNames))")
check(!FileManager.default.fileExists(atPath: peerDir.appendingPathComponent("大文件.bin.qftpart").path),
"P2P 临时文件已清理")
} catch { } catch {
check(false, "P2P 传输失败:\(error.localizedDescription)") check(false, "P2P 传输失败:\(error.localizedDescription)")
} }
@@ -341,18 +772,48 @@ if peerSemaphore.wait(timeout: .now() + 60) == .timedOut {
check(false, "P2P 传输超时") check(false, "P2P 传输超时")
} }
// 清单摘要必须锁死「扫到的就是收到的」
let digestSemaphore = DispatchSemaphore(value: 0)
Task {
defer { digestSemaphore.signal() }
let sender = PeerSender(fileURLs: [peerURLs[1]], deviceName: "发送端")
do {
let pairing = try sender.start()
let port = try await sender.listeningPort()
let tampered = PeerPairing(version: 2, key: pairing.key, instance: pairing.instance,
senderName: pairing.senderName, fileCount: pairing.fileCount,
totalSize: pairing.totalSize,
queueDigest: String(repeating: "ab", count: 32),
previewName: pairing.previewName)
var receiver = PeerReceiver(pairing: tampered,
destinationDirectory: peerDir.appendingPathComponent("bad"))
receiver.directPort = port
async let sendSide: Void = sender.waitAndSend { _ in }
_ = try await receiver.run { _ in }
_ = try? await sendSide
check(false, "清单摘要不符本应被拒绝")
} catch {
check(true, "清单摘要不符时接收端拒绝:\(error.localizedDescription)")
}
sender.stop()
}
if digestSemaphore.wait(timeout: .now() + 30) == .timedOut {
check(false, "清单摘要用例超时")
}
// 错误密钥必须握手失败 // 错误密钥必须握手失败
let wrongKeySemaphore = DispatchSemaphore(value: 0) let wrongKeySemaphore = DispatchSemaphore(value: 0)
Task { Task {
defer { wrongKeySemaphore.signal() } defer { wrongKeySemaphore.signal() }
let sender = PeerSender(fileURL: sourceURL, deviceName: "发送端") let sender = PeerSender(fileURLs: [peerURLs[1]], deviceName: "发送端")
do { do {
let pairing = try sender.start() let pairing = try sender.start()
let port = try await sender.listeningPort() let port = try await sender.listeningPort()
let tampered = PeerPairing(version: 1, key: PeerPairing.newKey(), let tampered = PeerPairing(version: 2, key: PeerPairing.newKey(),
instance: pairing.instance, senderName: pairing.senderName, instance: pairing.instance, senderName: pairing.senderName,
fileName: pairing.fileName, fileSize: pairing.fileSize, fileCount: pairing.fileCount, totalSize: pairing.totalSize,
sha256: pairing.sha256) queueDigest: pairing.queueDigest,
previewName: pairing.previewName)
var receiver = PeerReceiver(pairing: tampered, destinationDirectory: peerDir) var receiver = PeerReceiver(pairing: tampered, destinationDirectory: peerDir)
receiver.directPort = port receiver.directPort = port
_ = try await receiver.run { _ in } _ = try await receiver.run { _ in }
+122 -76
View File
@@ -7,35 +7,62 @@
objects = { objects = {
/* Begin PBXBuildFile section */ /* Begin PBXBuildFile section */
0469B1106E6746B3BE56007D /* UploadClient.swift in Sources */ = {isa = PBXBuildFile; fileRef = B8FB8A4A9482DB8F1234AE39 /* UploadClient.swift */; };
38E462342111ACFA8775D17B /* PairingProtocol.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5459D124A555B0E4121361E5 /* PairingProtocol.swift */; };
4D2B05655C76F69F32349834 /* PeerPairing.swift in Sources */ = {isa = PBXBuildFile; fileRef = 06E1A38EC22BBFED928C8EB6 /* PeerPairing.swift */; };
554512A1FC8A6F66E2784787 /* QFTApp.swift in Sources */ = {isa = PBXBuildFile; fileRef = 453B172D654B3AEDE4E36D1E /* QFTApp.swift */; }; 554512A1FC8A6F66E2784787 /* QFTApp.swift in Sources */ = {isa = PBXBuildFile; fileRef = 453B172D654B3AEDE4E36D1E /* QFTApp.swift */; };
6B2EB3BCEDA4855168DB4ACE /* HostDiscovery.swift in Sources */ = {isa = PBXBuildFile; fileRef = 3776FFCC2817EF6BF3EEC4FD /* HostDiscovery.swift */; }; B4E05D8969A872E7A590A365 /* Compatibility.swift in Sources */ = {isa = PBXBuildFile; fileRef = F25DE43C8C35FBBC39CFAE7C /* Compatibility.swift */; };
78FD5CF5E04D7E2483B90BAA /* HomeView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0B6863D13BC7270D7FCE21E7 /* HomeView.swift */; }; 78FD5CF5E04D7E2483B90BAA /* HomeView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0B6863D13BC7270D7FCE21E7 /* HomeView.swift */; };
978F01FFFFF69591E44C8528 /* DownloadClient.swift in Sources */ = {isa = PBXBuildFile; fileRef = EAA81C375609633BD8DB42F3 /* DownloadClient.swift */; };
A80B2E7BF8035E27D115EF59 /* PeerLink.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8DD16686BB19417EDC0B611A /* PeerLink.swift */; };
BDCF0D82F0BD0328770A8ABD /* ScannerView.swift in Sources */ = {isa = PBXBuildFile; fileRef = F3B15455554D7647B44D5038 /* ScannerView.swift */; }; BDCF0D82F0BD0328770A8ABD /* ScannerView.swift in Sources */ = {isa = PBXBuildFile; fileRef = F3B15455554D7647B44D5038 /* ScannerView.swift */; };
C0C0B5440A627CE758643A9F /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = C628A05E9C83375781E165EB /* Assets.xcassets */; }; ECB8CA83A58D87B09DBD8456 /* OpticalReceiveView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 379C5E1471447756788B3DCB /* OpticalReceiveView.swift */; };
B6EE345C070779A6FA9E05BD /* DesktopConnectView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 17377DDB45B13CFF24D9DE86 /* DesktopConnectView.swift */; };
E26487D1146FDF6DD5F92D80 /* TransferModel.swift in Sources */ = {isa = PBXBuildFile; fileRef = 3017489412A6FCAE8995B32E /* TransferModel.swift */; }; E26487D1146FDF6DD5F92D80 /* TransferModel.swift in Sources */ = {isa = PBXBuildFile; fileRef = 3017489412A6FCAE8995B32E /* TransferModel.swift */; };
EE5510DAC5BBB7F9D41A8F26 /* Base64URL.swift in Sources */ = {isa = PBXBuildFile; fileRef = 848334DC6B2D30622C7E2A45 /* Base64URL.swift */; }; EE5510DAC5BBB7F9D41A8F26 /* Base64URL.swift in Sources */ = {isa = PBXBuildFile; fileRef = 848334DC6B2D30622C7E2A45 /* Base64URL.swift */; };
05D0F5A979043CC15FDB92A1 /* Base45.swift in Sources */ = {isa = PBXBuildFile; fileRef = C82077A38D3267866B46D57F /* Base45.swift */; };
E16607BF05B3D489F8160F53 /* Checksums.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0B95B8F711B9A81C40F6EA5A /* Checksums.swift */; };
38E462342111ACFA8775D17B /* PairingProtocol.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5459D124A555B0E4121361E5 /* PairingProtocol.swift */; };
D203744CF39C3E960AA3D110 /* ConnectCode.swift in Sources */ = {isa = PBXBuildFile; fileRef = 85FAE5724447E402C3FA71FE /* ConnectCode.swift */; };
6B2EB3BCEDA4855168DB4ACE /* HostDiscovery.swift in Sources */ = {isa = PBXBuildFile; fileRef = 3776FFCC2817EF6BF3EEC4FD /* HostDiscovery.swift */; };
9084065AA71609218458E3D2 /* RouteTable.swift in Sources */ = {isa = PBXBuildFile; fileRef = B207643EAE71F9AA0362E7A5 /* RouteTable.swift */; };
C159979E9327D8DA41698DDF /* PeerBrowser.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0F9B686A883A173DE95F4453 /* PeerBrowser.swift */; };
EDD8ED380FEC0D6DB51EB92D /* DedicatedNetwork.swift in Sources */ = {isa = PBXBuildFile; fileRef = 3FA6BAA6C4DC6219D1D3E19E /* DedicatedNetwork.swift */; };
978F01FFFFF69591E44C8528 /* DownloadClient.swift in Sources */ = {isa = PBXBuildFile; fileRef = EAA81C375609633BD8DB42F3 /* DownloadClient.swift */; };
63D746131835097DC3266B1F /* RangeDownloadClient.swift in Sources */ = {isa = PBXBuildFile; fileRef = F6EC40DBDBCC0770CECF2418 /* RangeDownloadClient.swift */; };
0469B1106E6746B3BE56007D /* UploadClient.swift in Sources */ = {isa = PBXBuildFile; fileRef = B8FB8A4A9482DB8F1234AE39 /* UploadClient.swift */; };
C3458DA9C8C1B3D9725058E3 /* OpticalProtocol.swift in Sources */ = {isa = PBXBuildFile; fileRef = FB34C3FAD2E55EC4567C6575 /* OpticalProtocol.swift */; };
BED5F82537793225773795D3 /* OpticalROI.swift in Sources */ = {isa = PBXBuildFile; fileRef = C916198C3640D3089E62DF79 /* OpticalROI.swift */; };
1171444EB6F281BEE7775354 /* OpticalAssembler.swift in Sources */ = {isa = PBXBuildFile; fileRef = 602872024DBA9B394B5574C6 /* OpticalAssembler.swift */; };
4D2B05655C76F69F32349834 /* PeerPairing.swift in Sources */ = {isa = PBXBuildFile; fileRef = 06E1A38EC22BBFED928C8EB6 /* PeerPairing.swift */; };
A80B2E7BF8035E27D115EF59 /* PeerLink.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8DD16686BB19417EDC0B611A /* PeerLink.swift */; };
C0C0B5440A627CE758643A9F /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = C628A05E9C83375781E165EB /* Assets.xcassets */; };
/* End PBXBuildFile section */ /* End PBXBuildFile section */
/* Begin PBXFileReference section */ /* Begin PBXFileReference section */
06E1A38EC22BBFED928C8EB6 /* PeerPairing.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PeerPairing.swift; sourceTree = "<group>"; };
0B6863D13BC7270D7FCE21E7 /* HomeView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = HomeView.swift; sourceTree = "<group>"; };
3017489412A6FCAE8995B32E /* TransferModel.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = TransferModel.swift; sourceTree = "<group>"; };
3776FFCC2817EF6BF3EEC4FD /* HostDiscovery.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = HostDiscovery.swift; sourceTree = "<group>"; };
453B172D654B3AEDE4E36D1E /* QFTApp.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = QFTApp.swift; sourceTree = "<group>"; };
5459D124A555B0E4121361E5 /* PairingProtocol.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PairingProtocol.swift; sourceTree = "<group>"; };
7E4A60F8CA5D515103446ED3 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
848334DC6B2D30622C7E2A45 /* Base64URL.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Base64URL.swift; sourceTree = "<group>"; };
8DD16686BB19417EDC0B611A /* PeerLink.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PeerLink.swift; sourceTree = "<group>"; };
928818DCDA72C62B2D8288D5 /* QFT.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = QFT.app; sourceTree = BUILT_PRODUCTS_DIR; }; 928818DCDA72C62B2D8288D5 /* QFT.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = QFT.app; sourceTree = BUILT_PRODUCTS_DIR; };
B8FB8A4A9482DB8F1234AE39 /* UploadClient.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = UploadClient.swift; sourceTree = "<group>"; }; 453B172D654B3AEDE4E36D1E /* QFTApp.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = QFTApp.swift; sourceTree = "<group>"; };
C628A05E9C83375781E165EB /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = "<group>"; }; F25DE43C8C35FBBC39CFAE7C /* Compatibility.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Compatibility.swift; sourceTree = "<group>"; };
EAA81C375609633BD8DB42F3 /* DownloadClient.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = DownloadClient.swift; sourceTree = "<group>"; }; 0B6863D13BC7270D7FCE21E7 /* HomeView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = HomeView.swift; sourceTree = "<group>"; };
F3B15455554D7647B44D5038 /* ScannerView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ScannerView.swift; sourceTree = "<group>"; }; F3B15455554D7647B44D5038 /* ScannerView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ScannerView.swift; sourceTree = "<group>"; };
379C5E1471447756788B3DCB /* OpticalReceiveView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = OpticalReceiveView.swift; sourceTree = "<group>"; };
17377DDB45B13CFF24D9DE86 /* DesktopConnectView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = DesktopConnectView.swift; sourceTree = "<group>"; };
3017489412A6FCAE8995B32E /* TransferModel.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = TransferModel.swift; sourceTree = "<group>"; };
848334DC6B2D30622C7E2A45 /* Base64URL.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Base64URL.swift; sourceTree = "<group>"; };
C82077A38D3267866B46D57F /* Base45.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Base45.swift; sourceTree = "<group>"; };
0B95B8F711B9A81C40F6EA5A /* Checksums.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Checksums.swift; sourceTree = "<group>"; };
5459D124A555B0E4121361E5 /* PairingProtocol.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PairingProtocol.swift; sourceTree = "<group>"; };
85FAE5724447E402C3FA71FE /* ConnectCode.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ConnectCode.swift; sourceTree = "<group>"; };
3776FFCC2817EF6BF3EEC4FD /* HostDiscovery.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = HostDiscovery.swift; sourceTree = "<group>"; };
B207643EAE71F9AA0362E7A5 /* RouteTable.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RouteTable.swift; sourceTree = "<group>"; };
0F9B686A883A173DE95F4453 /* PeerBrowser.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PeerBrowser.swift; sourceTree = "<group>"; };
3FA6BAA6C4DC6219D1D3E19E /* DedicatedNetwork.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = DedicatedNetwork.swift; sourceTree = "<group>"; };
EAA81C375609633BD8DB42F3 /* DownloadClient.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = DownloadClient.swift; sourceTree = "<group>"; };
F6EC40DBDBCC0770CECF2418 /* RangeDownloadClient.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RangeDownloadClient.swift; sourceTree = "<group>"; };
B8FB8A4A9482DB8F1234AE39 /* UploadClient.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = UploadClient.swift; sourceTree = "<group>"; };
FB34C3FAD2E55EC4567C6575 /* OpticalProtocol.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = OpticalProtocol.swift; sourceTree = "<group>"; };
C916198C3640D3089E62DF79 /* OpticalROI.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = OpticalROI.swift; sourceTree = "<group>"; };
602872024DBA9B394B5574C6 /* OpticalAssembler.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = OpticalAssembler.swift; sourceTree = "<group>"; };
06E1A38EC22BBFED928C8EB6 /* PeerPairing.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PeerPairing.swift; sourceTree = "<group>"; };
8DD16686BB19417EDC0B611A /* PeerLink.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PeerLink.swift; sourceTree = "<group>"; };
C628A05E9C83375781E165EB /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = "<group>"; };
7E4A60F8CA5D515103446ED3 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
478AB8DB09485855EA9372E3 /* QFT.entitlements */ = {isa = PBXFileReference; lastKnownFileType = text; path = QFT.entitlements; sourceTree = "<group>"; };
/* End PBXFileReference section */ /* End PBXFileReference section */
/* Begin PBXFrameworksBuildPhase section */ /* Begin PBXFrameworksBuildPhase section */
@@ -52,7 +79,10 @@
32AAB6DFB51CD1888CC4883B /* App */ = { 32AAB6DFB51CD1888CC4883B /* App */ = {
isa = PBXGroup; isa = PBXGroup;
children = ( children = (
F25DE43C8C35FBBC39CFAE7C /* Compatibility.swift */,
17377DDB45B13CFF24D9DE86 /* DesktopConnectView.swift */,
0B6863D13BC7270D7FCE21E7 /* HomeView.swift */, 0B6863D13BC7270D7FCE21E7 /* HomeView.swift */,
379C5E1471447756788B3DCB /* OpticalReceiveView.swift */,
453B172D654B3AEDE4E36D1E /* QFTApp.swift */, 453B172D654B3AEDE4E36D1E /* QFTApp.swift */,
F3B15455554D7647B44D5038 /* ScannerView.swift */, F3B15455554D7647B44D5038 /* ScannerView.swift */,
3017489412A6FCAE8995B32E /* TransferModel.swift */, 3017489412A6FCAE8995B32E /* TransferModel.swift */,
@@ -60,6 +90,30 @@
path = App; path = App;
sourceTree = "<group>"; sourceTree = "<group>";
}; };
EC599E8CF455428A5E3179CE /* Core */ = {
isa = PBXGroup;
children = (
C82077A38D3267866B46D57F /* Base45.swift */,
848334DC6B2D30622C7E2A45 /* Base64URL.swift */,
0B95B8F711B9A81C40F6EA5A /* Checksums.swift */,
85FAE5724447E402C3FA71FE /* ConnectCode.swift */,
3FA6BAA6C4DC6219D1D3E19E /* DedicatedNetwork.swift */,
EAA81C375609633BD8DB42F3 /* DownloadClient.swift */,
3776FFCC2817EF6BF3EEC4FD /* HostDiscovery.swift */,
602872024DBA9B394B5574C6 /* OpticalAssembler.swift */,
FB34C3FAD2E55EC4567C6575 /* OpticalProtocol.swift */,
C916198C3640D3089E62DF79 /* OpticalROI.swift */,
5459D124A555B0E4121361E5 /* PairingProtocol.swift */,
0F9B686A883A173DE95F4453 /* PeerBrowser.swift */,
8DD16686BB19417EDC0B611A /* PeerLink.swift */,
06E1A38EC22BBFED928C8EB6 /* PeerPairing.swift */,
F6EC40DBDBCC0770CECF2418 /* RangeDownloadClient.swift */,
B207643EAE71F9AA0362E7A5 /* RouteTable.swift */,
B8FB8A4A9482DB8F1234AE39 /* UploadClient.swift */,
);
path = Core;
sourceTree = "<group>";
};
36EDFB66685EBD501D3910CE /* QFT */ = { 36EDFB66685EBD501D3910CE /* QFT */ = {
isa = PBXGroup; isa = PBXGroup;
children = ( children = (
@@ -67,6 +121,7 @@
C628A05E9C83375781E165EB /* Assets.xcassets */, C628A05E9C83375781E165EB /* Assets.xcassets */,
EC599E8CF455428A5E3179CE /* Core */, EC599E8CF455428A5E3179CE /* Core */,
7E4A60F8CA5D515103446ED3 /* Info.plist */, 7E4A60F8CA5D515103446ED3 /* Info.plist */,
478AB8DB09485855EA9372E3 /* QFT.entitlements */,
); );
path = QFT; path = QFT;
sourceTree = "<group>"; sourceTree = "<group>";
@@ -87,26 +142,12 @@
name = Products; name = Products;
sourceTree = "<group>"; sourceTree = "<group>";
}; };
EC599E8CF455428A5E3179CE /* Core */ = {
isa = PBXGroup;
children = (
848334DC6B2D30622C7E2A45 /* Base64URL.swift */,
EAA81C375609633BD8DB42F3 /* DownloadClient.swift */,
3776FFCC2817EF6BF3EEC4FD /* HostDiscovery.swift */,
5459D124A555B0E4121361E5 /* PairingProtocol.swift */,
8DD16686BB19417EDC0B611A /* PeerLink.swift */,
06E1A38EC22BBFED928C8EB6 /* PeerPairing.swift */,
B8FB8A4A9482DB8F1234AE39 /* UploadClient.swift */,
);
path = Core;
sourceTree = "<group>";
};
/* End PBXGroup section */ /* End PBXGroup section */
/* Begin PBXNativeTarget section */ /* Begin PBXNativeTarget section */
497CBF7ECF21FFA362230876 /* QFT */ = { 497CBF7ECF21FFA362230876 /* QFT */ = {
isa = PBXNativeTarget; isa = PBXNativeTarget;
buildConfigurationList = A886B50DF087AEF7B87CDC65 /* Build configuration list for PBXNativeTarget "QFT" */; buildConfigurationList = A886B50DF087AEF7B87CDC65;
buildPhases = ( buildPhases = (
C2511B36F0F0E810A9E46328 /* Sources */, C2511B36F0F0E810A9E46328 /* Sources */,
019BAB185F97B56993A7087D /* Frameworks */, 019BAB185F97B56993A7087D /* Frameworks */,
@@ -136,7 +177,7 @@
}; };
}; };
}; };
buildConfigurationList = 26E84C2B3712F7DFAC8AD93F /* Build configuration list for PBXProject "QFT" */; buildConfigurationList = 26E84C2B3712F7DFAC8AD93F;
compatibilityVersion = "Xcode 14.0"; compatibilityVersion = "Xcode 14.0";
developmentRegion = en; developmentRegion = en;
hasScannedForEncodings = 0; hasScannedForEncodings = 0;
@@ -172,14 +213,27 @@
buildActionMask = 2147483647; buildActionMask = 2147483647;
files = ( files = (
554512A1FC8A6F66E2784787 /* QFTApp.swift in Sources */, 554512A1FC8A6F66E2784787 /* QFTApp.swift in Sources */,
B4E05D8969A872E7A590A365 /* Compatibility.swift in Sources */,
78FD5CF5E04D7E2483B90BAA /* HomeView.swift in Sources */, 78FD5CF5E04D7E2483B90BAA /* HomeView.swift in Sources */,
BDCF0D82F0BD0328770A8ABD /* ScannerView.swift in Sources */, BDCF0D82F0BD0328770A8ABD /* ScannerView.swift in Sources */,
ECB8CA83A58D87B09DBD8456 /* OpticalReceiveView.swift in Sources */,
B6EE345C070779A6FA9E05BD /* DesktopConnectView.swift in Sources */,
E26487D1146FDF6DD5F92D80 /* TransferModel.swift in Sources */, E26487D1146FDF6DD5F92D80 /* TransferModel.swift in Sources */,
EE5510DAC5BBB7F9D41A8F26 /* Base64URL.swift in Sources */, EE5510DAC5BBB7F9D41A8F26 /* Base64URL.swift in Sources */,
05D0F5A979043CC15FDB92A1 /* Base45.swift in Sources */,
E16607BF05B3D489F8160F53 /* Checksums.swift in Sources */,
38E462342111ACFA8775D17B /* PairingProtocol.swift in Sources */, 38E462342111ACFA8775D17B /* PairingProtocol.swift in Sources */,
D203744CF39C3E960AA3D110 /* ConnectCode.swift in Sources */,
6B2EB3BCEDA4855168DB4ACE /* HostDiscovery.swift in Sources */, 6B2EB3BCEDA4855168DB4ACE /* HostDiscovery.swift in Sources */,
9084065AA71609218458E3D2 /* RouteTable.swift in Sources */,
C159979E9327D8DA41698DDF /* PeerBrowser.swift in Sources */,
EDD8ED380FEC0D6DB51EB92D /* DedicatedNetwork.swift in Sources */,
978F01FFFFF69591E44C8528 /* DownloadClient.swift in Sources */, 978F01FFFFF69591E44C8528 /* DownloadClient.swift in Sources */,
63D746131835097DC3266B1F /* RangeDownloadClient.swift in Sources */,
0469B1106E6746B3BE56007D /* UploadClient.swift in Sources */, 0469B1106E6746B3BE56007D /* UploadClient.swift in Sources */,
C3458DA9C8C1B3D9725058E3 /* OpticalProtocol.swift in Sources */,
BED5F82537793225773795D3 /* OpticalROI.swift in Sources */,
1171444EB6F281BEE7775354 /* OpticalAssembler.swift in Sources */,
4D2B05655C76F69F32349834 /* PeerPairing.swift in Sources */, 4D2B05655C76F69F32349834 /* PeerPairing.swift in Sources */,
A80B2E7BF8035E27D115EF59 /* PeerLink.swift in Sources */, A80B2E7BF8035E27D115EF59 /* PeerLink.swift in Sources */,
); );
@@ -188,29 +242,6 @@
/* End PBXSourcesBuildPhase section */ /* End PBXSourcesBuildPhase section */
/* Begin XCBuildConfiguration section */ /* Begin XCBuildConfiguration section */
032222C0BAA33BC7119DFAF1 /* Release */ = {
isa = XCBuildConfiguration;
buildSettings = {
ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
CODE_SIGN_STYLE = Automatic;
CURRENT_PROJECT_VERSION = 47;
ENABLE_PREVIEWS = YES;
GENERATE_INFOPLIST_FILE = NO;
INFOPLIST_FILE = QFT/Info.plist;
IPHONEOS_DEPLOYMENT_TARGET = 18.6;
LD_RUNPATH_SEARCH_PATHS = (
"$(inherited)",
"@executable_path/Frameworks",
);
MARKETING_VERSION = 0.4.7;
PRODUCT_BUNDLE_IDENTIFIER = com.qft.transfer;
PRODUCT_NAME = "$(TARGET_NAME)";
SWIFT_EMIT_LOC_STRINGS = NO;
TARGETED_DEVICE_FAMILY = "1,2";
};
name = Release;
};
70DCC1EB255A5F3C8D9ED349 /* Debug */ = { 70DCC1EB255A5F3C8D9ED349 /* Debug */ = {
isa = XCBuildConfiguration; isa = XCBuildConfiguration;
buildSettings = { buildSettings = {
@@ -226,11 +257,8 @@
ENABLE_TESTABILITY = YES; ENABLE_TESTABILITY = YES;
GCC_NO_COMMON_BLOCKS = YES; GCC_NO_COMMON_BLOCKS = YES;
GCC_OPTIMIZATION_LEVEL = 0; GCC_OPTIMIZATION_LEVEL = 0;
GCC_PREPROCESSOR_DEFINITIONS = ( GCC_PREPROCESSOR_DEFINITIONS = "DEBUG=1 $(inherited)";
"DEBUG=1", IPHONEOS_DEPLOYMENT_TARGET = 15.0;
"$(inherited)",
);
IPHONEOS_DEPLOYMENT_TARGET = 18.6;
MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE; MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
MTL_FAST_MATH = YES; MTL_FAST_MATH = YES;
ONLY_ACTIVE_ARCH = YES; ONLY_ACTIVE_ARCH = YES;
@@ -241,6 +269,27 @@
}; };
name = Debug; name = Debug;
}; };
DB189EBE9D4E38495C3C7EF5 /* Debug */ = {
isa = XCBuildConfiguration;
buildSettings = {
ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
CODE_SIGN_ENTITLEMENTS = "$(QFT_ENTITLEMENTS)";
CODE_SIGN_STYLE = Automatic;
CURRENT_PROJECT_VERSION = 50;
ENABLE_PREVIEWS = YES;
GENERATE_INFOPLIST_FILE = NO;
INFOPLIST_FILE = QFT/Info.plist;
LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
MARKETING_VERSION = 0.5.0;
PRODUCT_BUNDLE_IDENTIFIER = com.qft.transfer;
PRODUCT_NAME = "$(TARGET_NAME)";
QFT_ENTITLEMENTS = "";
SWIFT_EMIT_LOC_STRINGS = NO;
TARGETED_DEVICE_FAMILY = "1,2";
};
name = Debug;
};
C3DCEEC1E0EB17A5583B8E94 /* Release */ = { C3DCEEC1E0EB17A5583B8E94 /* Release */ = {
isa = XCBuildConfiguration; isa = XCBuildConfiguration;
buildSettings = { buildSettings = {
@@ -255,10 +304,9 @@
ENABLE_NS_ASSERTIONS = NO; ENABLE_NS_ASSERTIONS = NO;
ENABLE_STRICT_OBJC_MSGSEND = YES; ENABLE_STRICT_OBJC_MSGSEND = YES;
GCC_NO_COMMON_BLOCKS = YES; GCC_NO_COMMON_BLOCKS = YES;
IPHONEOS_DEPLOYMENT_TARGET = 18.6; IPHONEOS_DEPLOYMENT_TARGET = 15.0;
MTL_ENABLE_DEBUG_INFO = NO; MTL_ENABLE_DEBUG_INFO = NO;
MTL_FAST_MATH = YES; MTL_FAST_MATH = YES;
ONLY_ACTIVE_ARCH = YES;
SDKROOT = iphoneos; SDKROOT = iphoneos;
SWIFT_COMPILATION_MODE = wholemodule; SWIFT_COMPILATION_MODE = wholemodule;
SWIFT_VERSION = 5.0; SWIFT_VERSION = 5.0;
@@ -266,33 +314,31 @@
}; };
name = Release; name = Release;
}; };
DB189EBE9D4E38495C3C7EF5 /* Debug */ = { 032222C0BAA33BC7119DFAF1 /* Release */ = {
isa = XCBuildConfiguration; isa = XCBuildConfiguration;
buildSettings = { buildSettings = {
ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor; ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
CODE_SIGN_ENTITLEMENTS = "$(QFT_ENTITLEMENTS)";
CODE_SIGN_STYLE = Automatic; CODE_SIGN_STYLE = Automatic;
CURRENT_PROJECT_VERSION = 47; CURRENT_PROJECT_VERSION = 50;
ENABLE_PREVIEWS = YES; ENABLE_PREVIEWS = YES;
GENERATE_INFOPLIST_FILE = NO; GENERATE_INFOPLIST_FILE = NO;
INFOPLIST_FILE = QFT/Info.plist; INFOPLIST_FILE = QFT/Info.plist;
IPHONEOS_DEPLOYMENT_TARGET = 18.6; LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
LD_RUNPATH_SEARCH_PATHS = ( MARKETING_VERSION = 0.5.0;
"$(inherited)",
"@executable_path/Frameworks",
);
MARKETING_VERSION = 0.4.7;
PRODUCT_BUNDLE_IDENTIFIER = com.qft.transfer; PRODUCT_BUNDLE_IDENTIFIER = com.qft.transfer;
PRODUCT_NAME = "$(TARGET_NAME)"; PRODUCT_NAME = "$(TARGET_NAME)";
QFT_ENTITLEMENTS = "";
SWIFT_EMIT_LOC_STRINGS = NO; SWIFT_EMIT_LOC_STRINGS = NO;
TARGETED_DEVICE_FAMILY = "1,2"; TARGETED_DEVICE_FAMILY = "1,2";
}; };
name = Debug; name = Release;
}; };
/* End XCBuildConfiguration section */ /* End XCBuildConfiguration section */
/* Begin XCConfigurationList section */ /* Begin XCConfigurationList section */
26E84C2B3712F7DFAC8AD93F /* Build configuration list for PBXProject "QFT" */ = { 26E84C2B3712F7DFAC8AD93F = {
isa = XCConfigurationList; isa = XCConfigurationList;
buildConfigurations = ( buildConfigurations = (
70DCC1EB255A5F3C8D9ED349 /* Debug */, 70DCC1EB255A5F3C8D9ED349 /* Debug */,
@@ -301,7 +347,7 @@
defaultConfigurationIsVisible = 0; defaultConfigurationIsVisible = 0;
defaultConfigurationName = Release; defaultConfigurationName = Release;
}; };
A886B50DF087AEF7B87CDC65 /* Build configuration list for PBXNativeTarget "QFT" */ = { A886B50DF087AEF7B87CDC65 = {
isa = XCConfigurationList; isa = XCConfigurationList;
buildConfigurations = ( buildConfigurations = (
DB189EBE9D4E38495C3C7EF5 /* Debug */, DB189EBE9D4E38495C3C7EF5 /* Debug */,
+69
View File
@@ -0,0 +1,69 @@
import SwiftUI
import UIKit
/// iOS 版本兼容层。
///
/// 部署目标是 **iOS 15.0**——对应 iPhone 6s(2015)及以后,和 Android 端
/// `minSdk 24`(Android 7.0,2016)覆盖的机型年代大致相当。再往下走不动了:
/// `URLSession` 的 async 接口是 iOS 15 才有的,低于 15 就要把所有网络代码
/// 改回 completion handler,代价与收益不成比例。
///
/// 新系统上的更好实现照样用,只是要在这里分叉,而不是把整个 App 的
/// 部署目标顶上去。
/// `NavigationStack` 是 iOS 16 才有的。
struct QFTNavigationContainer<Content: View>: View {
@ViewBuilder let content: Content
var body: some View {
if #available(iOS 16.0, *) {
NavigationStack { content }
} else {
// iOS 15 上 NavigationView 默认在 iPad 会变成分栏,强制单栏
NavigationView { content }
.navigationViewStyle(.stack)
}
}
}
/// `ShareLink` 是 iOS 16 才有的;iOS 15 上退回 `UIActivityViewController`。
struct QFTShareButton<Label: View>: View {
let url: URL
@ViewBuilder let label: Label
@State private var presenting = false
var body: some View {
if #available(iOS 16.0, *) {
ShareLink(item: url) { label }
} else {
Button { presenting = true } label: { label }
.buttonStyle(.plain)
.sheet(isPresented: $presenting) { ActivitySheet(items: [url]) }
}
}
}
private struct ActivitySheet: UIViewControllerRepresentable {
let items: [Any]
func makeUIViewController(context: Context) -> UIActivityViewController {
UIActivityViewController(activityItems: items, applicationActivities: nil)
}
func updateUIViewController(_ controller: UIActivityViewController, context: Context) {}
}
/// `LabeledContent` 是 iOS 16 才有的。
struct QFTLabeledRow<Value: View>: View {
let title: String
@ViewBuilder let value: Value
var body: some View {
HStack(alignment: .firstTextBaseline) {
Text(title)
Spacer(minLength: 12)
value.multilineTextAlignment(.trailing)
}
}
}
+136
View File
@@ -0,0 +1,136 @@
import SwiftUI
/// 「连接附近的电脑」。
///
/// 电脑之间没有摄像头,所以桌面端进入「我要接收」后显示的是**连接码**,
/// 地址和配对秘密都编在那串码里。iPhone 走同一条路:广播列出附近的电脑
/// (只是为了让用户确认「就是这台」),真正建立会话靠输入那串码。
///
/// 明确的边界:连接码换来的是**接收端**的会话,因此这条路径只能
/// 「把文件发到电脑」。要让电脑下发文件,请在电脑上选好文件后扫它的二维码。
struct NearbyComputersView: View {
let onConnect: (String, DesktopPeer?) -> Void
let onCancel: () -> Void
@State private var peers: [DesktopPeer] = []
@State private var selected: DesktopPeer?
@State private var code = ""
@State private var searching = false
var body: some View {
List {
Section {
if peers.isEmpty {
HStack {
Text(searching ? "正在搜索…" : "没有搜索到电脑")
.foregroundStyle(.secondary)
Spacer()
if searching { ProgressView() }
}
} else {
ForEach(peers) { peer in
Button {
selected = (selected == peer) ? nil : peer
} label: {
HStack {
Image(systemName: peer.platform == "macos"
? "laptopcomputer" : "desktopcomputer")
VStack(alignment: .leading, spacing: 2) {
Text(peer.name).font(.body)
Text("\(peer.platformLabel) · \(peer.address)")
.font(.caption).foregroundStyle(.secondary)
}
Spacer()
if selected == peer {
Image(systemName: "checkmark").foregroundStyle(.tint)
} else if peer.ready {
Text("等待接收").font(.caption2).foregroundStyle(.green)
}
}
}
.buttonStyle(.plain)
}
}
} header: {
Text("附近的电脑")
} footer: {
Text("广播只覆盖同一个网段。跨网段或开了 AP 隔离的 Wi-Fi 上搜不到对方,直接输连接码即可——地址就在码里。")
}
Section {
TextField("例如 K7M2-9X4P-QR3T", text: $code)
.textInputAutocapitalization(.characters)
.autocorrectionDisabled()
.font(.body.monospaced())
Button("连接并选择文件") {
onConnect(code, selected)
}
.disabled(code.trimmingCharacters(in: .whitespaces).count < 8)
} header: {
Text("连接码")
} footer: {
Text("在电脑上打开 QFT →「电脑 ↔ 电脑」→「我要接收」,屏幕上那串码就是它。输错 5 次电脑会作废该码,需要重新启动接收。")
}
Section {
Button("返回", role: .cancel) { onCancel() }
}
}
.refreshable { await search() }
.task { await search() }
}
private func search() async {
searching = true
peers = await PeerBrowser.browse()
searching = false
}
}
/// 专用网络的手动加入引导。
///
/// `NEHotspotConfiguration` 需要 HotspotConfiguration entitlement;拿不到时
/// **不假装成功**,而是把 SSID/密码摆出来让用户自己连——这一步在
/// Windows 的 QFT Direct 上是必需的,因为那张网上电脑才是网关。
struct ManualJoinView: View {
let wifi: WifiCredentials
let onContinue: () -> Void
let onCancel: () -> Void
var body: some View {
List {
Section {
QFTLabeledRow(title: "网络名称") {
Text(wifi.ssid).font(.body.monospaced()).textSelection(.enabled)
}
QFTLabeledRow(title: "密码") {
Text(wifi.passphrase).font(.body.monospaced()).textSelection(.enabled)
}
Button {
UIPasteboard.general.string = wifi.passphrase
} label: {
Label("复制密码", systemImage: "doc.on.doc")
}
Button {
guard let url = URL(string: UIApplication.openSettingsURLString) else { return }
UIApplication.shared.open(url)
} label: {
Label("打开「设置」", systemImage: "gear")
}
} header: {
Text("请先加入电脑的专用 Wi-Fi")
} footer: {
Text("这台 iPhone 上的 QFT 没有自动加入 Wi-Fi 的能力(需要 Hotspot Configuration entitlement),"
+ "所以要手动连一次。这张网没有互联网,系统可能提示「未连接到互联网」,是正常的。")
}
Section {
Button("我已连上,继续") { onContinue() }
.buttonStyle(.borderedProminent)
Button("取消", role: .cancel) { onCancel() }
}
}
}
}
+77 -24
View File
@@ -1,4 +1,5 @@
import SwiftUI import SwiftUI
import Combine
import UniformTypeIdentifiers import UniformTypeIdentifiers
struct HomeView: View { struct HomeView: View {
@@ -8,13 +9,14 @@ struct HomeView: View {
private enum PickPurpose: Equatable { private enum PickPurpose: Equatable {
case peerSend case peerSend
case uploadToPC(PairingPayload) case uploadToPC(PairingPayload)
case uploadToDesktop(DesktopSession)
} }
@StateObject private var model = TransferModel() @StateObject private var model = TransferModel()
@State private var pickPurpose: PickPurpose? @State private var pickPurpose: PickPurpose?
var body: some View { var body: some View {
NavigationStack { QFTNavigationContainer {
content content
.navigationTitle("QFT 快传") .navigationTitle("QFT 快传")
.navigationBarTitleDisplayMode(.inline) .navigationBarTitleDisplayMode(.inline)
@@ -23,25 +25,37 @@ struct HomeView: View {
ScannerView(onFound: { model.handleScanned($0) }, onCancel: { model.cancel() }) ScannerView(onFound: { model.handleScanned($0) }, onCancel: { model.cancel() })
.ignoresSafeArea() .ignoresSafeArea()
} }
.fullScreenCover(isPresented: isOptical) {
OpticalReceiveScreen(
destinationDirectory: (try? DownloadClient.defaultDestinationDirectory())
?? FileManager.default.temporaryDirectory,
onFinished: { model.finishOptical($0) },
onCancel: { model.cancel() })
}
.fileImporter(isPresented: isPicking, .fileImporter(isPresented: isPicking,
allowedContentTypes: [UTType.item], allowsMultipleSelection: false) { result in allowedContentTypes: [UTType.item], allowsMultipleSelection: true) { result in
let purpose = pickPurpose let purpose = pickPurpose
pickPurpose = nil pickPurpose = nil
guard case .success(let urls) = result, let url = urls.first else { guard case .success(let urls) = result, !urls.isEmpty else {
model.reset() model.reset()
return return
} }
switch purpose { switch purpose {
case .peerSend: model.startPeerSend(fileURL: url) case .peerSend: model.startPeerSend(fileURLs: urls)
case .uploadToPC(let pairing): model.startUpload(pairing, fileURL: url) case .uploadToPC(let pairing): model.startUpload(pairing, fileURLs: urls)
case .uploadToDesktop(let session): model.startUpload(to: session, fileURLs: urls)
case nil: break case nil: break
} }
} }
.onAppear { model.refreshReceivedFiles() } .onAppear { model.refreshReceivedFiles() }
.onChange(of: model.stage) { _, stage in // 用 onReceive 而不是 onChange:两参数的 onChange 是 iOS 17 才有的,
// 扫到 QFTPAIR2 之后才知道要选文件,所以选择器由 stage 驱动 // 单参数版本在 iOS 17 上又被标了废弃
if case .pickFileForUpload(let pairing) = stage { .onReceive(model.$stage) { stage in
pickPurpose = .uploadToPC(pairing) // 扫到码/配对成功之后才知道要选文件,所以选择器由 stage 驱动
switch stage {
case .pickFilesForUpload(let pairing): pickPurpose = .uploadToPC(pairing)
case .pickFilesForDesktop(let session): pickPurpose = .uploadToDesktop(session)
default: break
} }
} }
} }
@@ -50,6 +64,10 @@ struct HomeView: View {
Binding(get: { model.stage == .scanning }, set: { if !$0 { model.cancel() } }) Binding(get: { model.stage == .scanning }, set: { if !$0 { model.cancel() } })
} }
private var isOptical: Binding<Bool> {
Binding(get: { model.stage == .optical }, set: { if !$0 { model.cancel() } })
}
private var isPicking: Binding<Bool> { private var isPicking: Binding<Bool> {
Binding(get: { pickPurpose != nil }, set: { if !$0 { pickPurpose = nil } }) Binding(get: { pickPurpose != nil }, set: { if !$0 { pickPurpose = nil } })
} }
@@ -57,11 +75,22 @@ struct HomeView: View {
@ViewBuilder @ViewBuilder
private var content: some View { private var content: some View {
switch model.stage { switch model.stage {
case .idle, .scanning, .pickFileForUpload: case .idle, .scanning, .optical, .pickFilesForUpload, .pickFilesForDesktop:
landing landing
case .nearby:
NearbyComputersView(
onConnect: { code, peer in model.connect(code: code, peer: peer) },
onCancel: { model.reset() })
case .manualJoin(let wifi, let pairing):
ManualJoinView(wifi: wifi,
onContinue: { model.manualJoinCompleted(pairing) },
onCancel: { model.cancel() })
case .connecting(let message): case .connecting(let message):
StatusCard(icon: "antenna.radiowaves.left.and.right", title: message) { StatusCard(icon: "antenna.radiowaves.left.and.right", title: message) {
ProgressView() ProgressView()
if let detail = model.detail {
Text(detail).font(.footnote).foregroundStyle(.secondary)
}
Button("取消", role: .cancel) { model.cancel() } Button("取消", role: .cancel) { model.cancel() }
} }
case .running(let message): case .running(let message):
@@ -74,15 +103,20 @@ struct HomeView: View {
} else { } else {
ProgressView() ProgressView()
} }
if let detail = model.detail {
Text(detail).font(.footnote).foregroundStyle(.secondary).lineLimit(1)
}
Button("取消", role: .cancel) { model.cancel() } Button("取消", role: .cancel) { model.cancel() }
} }
case .showingPeerCode(let pairing): case .showingPeerCode(let pairing):
peerCode(pairing) peerCode(pairing)
case .finished(let message, let url): case .finished(let message, let urls):
StatusCard(icon: "checkmark.circle.fill", title: message) { StatusCard(icon: "checkmark.circle.fill", title: message) {
if let url { ForEach(Array(urls.prefix(5)), id: \.self) { url in
Text(url.lastPathComponent).font(.footnote).foregroundStyle(.secondary) QFTShareButton(url: url) {
ShareLink(item: url) { Label("分享", systemImage: "square.and.arrow.up") } Label(url.lastPathComponent, systemImage: "square.and.arrow.up")
.font(.footnote).lineLimit(1)
}
} }
Button("完成") { model.reset() }.buttonStyle(.borderedProminent) Button("完成") { model.reset() }.buttonStyle(.borderedProminent)
} }
@@ -97,23 +131,36 @@ struct HomeView: View {
private var landing: some View { private var landing: some View {
List { List {
Section { Section("和电脑互传") {
ActionRow(icon: "qrcode.viewfinder", title: "扫码", ActionRow(icon: "qrcode.viewfinder", title: "扫电脑上的二维码",
detail: "扫电脑上的二维码收发文件,或扫另一台 iPhone 的码接收") { detail: "局域网直传;Windows 的专用网络(QFT Direct)也走这里") {
model.beginScan() model.beginScan()
} }
ActionRow(icon: "iphone.gen3.radiowaves.left.and.right", title: "发给附近的 iPhone", ActionRow(icon: "desktopcomputer", title: "连接附近的电脑",
detail: "选文件后显示二维码,对方扫一下即可,无需连同一个 Wi-Fi") { detail: "Mac / Windows 进入「我要接收」后,输入屏幕上的连接码即可发送文件") {
model.beginNearby()
}
ActionRow(icon: "camera.viewfinder", title: "光学接收(不用网络)",
detail: "对准电脑的「光学传输」页,文件只经过屏幕和摄像头") {
model.beginOptical()
}
}
Section("和 iPhone 互传") {
ActionRow(icon: "iphone.radiowaves.left.and.right", title: "发给附近的 iPhone",
detail: "可多选文件;显示二维码,对方扫一下即可,无需连同一个 Wi-Fi") {
pickPurpose = .peerSend pickPurpose = .peerSend
} }
} footer: { ActionRow(icon: "qrcode.viewfinder", title: "接收 iPhone 发来的文件",
Text("与电脑互传需要手机和电脑连在同一个 Wi-Fi。iPhone 之间使用点对点直连,不经过路由器。") detail: "扫对方屏幕上的二维码") {
model.beginScan()
}
} }
if !model.receivedFiles.isEmpty { if !model.receivedFiles.isEmpty {
Section("已接收") { Section("已接收") {
ForEach(model.receivedFiles, id: \.self) { url in ForEach(model.receivedFiles, id: \.self) { url in
ShareLink(item: url) { QFTShareButton(url: url) {
Label(url.lastPathComponent, systemImage: "doc") Label(url.lastPathComponent, systemImage: "doc")
.lineLimit(1) .lineLimit(1)
} }
@@ -138,8 +185,11 @@ struct HomeView: View {
.clipShape(RoundedRectangle(cornerRadius: 16)) .clipShape(RoundedRectangle(cornerRadius: 16))
} }
VStack(spacing: 4) { VStack(spacing: 4) {
Text(pairing.fileName).font(.subheadline).lineLimit(1) Text(pairing.fileCount == 1
Text(TransferProgress.readable(pairing.fileSize)) ? pairing.previewName
: "\(pairing.previewName) 等 \(pairing.fileCount) 个文件")
.font(.subheadline).lineLimit(1)
Text(TransferProgress.readable(pairing.totalSize))
.font(.footnote).foregroundStyle(.secondary) .font(.footnote).foregroundStyle(.secondary)
} }
if let progress = model.progress { if let progress = model.progress {
@@ -147,6 +197,9 @@ struct HomeView: View {
.padding(.horizontal, 40) .padding(.horizontal, 40)
Text("\(progress.readableSize) · \(progress.readableRate)") Text("\(progress.readableSize) · \(progress.readableRate)")
.font(.footnote.monospacedDigit()).foregroundStyle(.secondary) .font(.footnote.monospacedDigit()).foregroundStyle(.secondary)
if let detail = model.detail {
Text(detail).font(.caption).foregroundStyle(.secondary).lineLimit(1)
}
} else { } else {
Label("等待对方扫码…", systemImage: "hourglass") Label("等待对方扫码…", systemImage: "hourglass")
.font(.footnote).foregroundStyle(.secondary) .font(.footnote).foregroundStyle(.secondary)
+460
View File
@@ -0,0 +1,460 @@
import SwiftUI
import Combine
import AVFoundation
import Vision
/// 光学接收:电脑屏幕 → iPhone 摄像头。
///
/// 这条链路上**文件数据完全不经过网络**——没有 Wi-Fi、没有蓝牙、没有局域网,
/// 只有屏幕上的二维码和这台 iPhone 的摄像头。因此它也是唯一一条在
/// 「电脑不能联网、也不允许接任何网络」的场合仍然可用的路径。
///
/// 与 Android 端同一套状态机:居中搜索 → 锁定 ROI → 丢失逐级放大 → 重新搜索。
struct OpticalReceiveScreen: View {
@StateObject private var model: OpticalReceiveModel
let onFinished: ([URL]) -> Void
let onCancel: () -> Void
init(destinationDirectory: URL,
onFinished: @escaping ([URL]) -> Void,
onCancel: @escaping () -> Void) {
_model = StateObject(wrappedValue: OpticalReceiveModel(destinationDirectory: destinationDirectory))
self.onFinished = onFinished
self.onCancel = onCancel
}
var body: some View {
ZStack {
OpticalCameraView(
onFrame: { text, decodeMS in model.accept(text: text, decodeMilliseconds: decodeMS) },
onMiss: { decodeMS in model.recordMiss(decodeMilliseconds: decodeMS) })
.ignoresSafeArea()
VStack {
header
Spacer()
footer
}
.padding()
}
.background(.black)
.onReceive(model.$savedFiles) { files in
guard !files.isEmpty else { return }
UINotificationFeedbackGenerator().notificationOccurred(.success)
}
}
private var header: some View {
VStack(spacing: 6) {
if let manifest = model.manifest {
Text(manifest.fileName)
.font(.headline).lineLimit(1)
Text("来自 \(manifest.senderDevice) · \(TransferProgress.readable(manifest.fileSize))")
.font(.caption)
ProgressView(value: model.fraction)
.tint(.green)
Text("已收 \(model.receivedChunks)/\(model.totalChunks) 片")
.font(.caption.monospacedDigit())
} else {
Text("把 iPhone 对准电脑上的二维码")
.font(.headline)
Text("电脑端「光学传输」页会循环播放整份文件,收齐即自动保存")
.font(.caption).multilineTextAlignment(.center)
}
if let message = model.message {
Text(message).font(.caption).foregroundStyle(.orange)
.multilineTextAlignment(.center)
}
}
.foregroundStyle(.white)
.padding()
.background(.black.opacity(0.55), in: RoundedRectangle(cornerRadius: 14))
}
private var footer: some View {
VStack(spacing: 10) {
// 决定传输时间的是「新帧/s」,不是「解码/s」:屏幕上同一帧会被
// 连续拍到很多次。用户据此在电脑端选 30 / 45 / 60 FPS。
Text(model.statsLine)
.font(.caption2.monospacedDigit())
.foregroundStyle(.white.opacity(0.85))
HStack(spacing: 16) {
Button("重新开始") { model.reset() }
.buttonStyle(.bordered)
if model.savedFiles.isEmpty {
Button("退出", role: .cancel) { onCancel() }
.buttonStyle(.borderedProminent)
} else {
Button("完成(\(model.savedFiles.count) 个文件)") { onFinished(model.savedFiles) }
.buttonStyle(.borderedProminent)
}
}
}
.padding()
.background(.black.opacity(0.55), in: RoundedRectangle(cornerRadius: 14))
}
}
// MARK: - 模型
@MainActor
final class OpticalReceiveModel: ObservableObject {
@Published private(set) var manifest: OpticalManifest?
@Published private(set) var receivedChunks = 0
@Published private(set) var totalChunks = 0
@Published private(set) var message: String?
@Published private(set) var savedFiles: [URL] = []
@Published private(set) var statsLine = "相机 -- FPS · 解码 --/s · 新帧 --/s"
/// 装配器和统计都是自带锁的,可以直接被相机队列调用;
/// 声明成 `nonisolated let` 就不必为了拿它们跳一次主线程——
/// 60 FPS 下每帧多一次线程切换是实打实的开销。
private nonisolated let assembler: OpticalAssembler
private nonisolated let stats = OpticalStats()
private nonisolated let relay: EventRelay
private var lastStatsRefresh = Date.distantPast
/// 装配器要在 init 里就拿到回调,而那时 self 还不完整,
/// 用一个中转对象把两者接起来。
private final class EventRelay: @unchecked Sendable {
private let lock = NSLock()
private var handler: ((OpticalReceiveEvent) -> Void)?
func setHandler(_ handler: @escaping (OpticalReceiveEvent) -> Void) {
lock.lock(); defer { lock.unlock() }
self.handler = handler
}
func emit(_ event: OpticalReceiveEvent) {
lock.lock()
let handler = self.handler
lock.unlock()
handler?(event)
}
}
init(destinationDirectory: URL) {
let relay = EventRelay()
self.relay = relay
self.assembler = OpticalAssembler(destinationDirectory: destinationDirectory) { event in
relay.emit(event)
}
relay.setHandler { [weak self] event in
Task { @MainActor in self?.handle(event) }
}
}
var fraction: Double {
totalChunks == 0 ? 0 : Double(receivedChunks) / Double(totalChunks)
}
nonisolated func accept(text: String, decodeMilliseconds: Double) {
let acceptance = assembler.accept(text: text)
stats.recordFrame(decodeMilliseconds: decodeMilliseconds, acceptance: acceptance)
Task { @MainActor in self.refreshStats() }
}
nonisolated func recordMiss(decodeMilliseconds: Double) {
stats.recordFrame(decodeMilliseconds: decodeMilliseconds, acceptance: nil)
Task { @MainActor in self.refreshStats() }
}
func reset() {
assembler.reset()
manifest = nil
receivedChunks = 0
totalChunks = 0
message = nil
}
private func refreshStats() {
guard Date().timeIntervalSince(lastStatsRefresh) > 0.3 else { return }
lastStatsRefresh = Date()
let snapshot = stats.snapshot()
statsLine = String(format: "相机 %.0f FPS · 解码 %.1f/s · 新帧 %.1f/s · %.1f ms",
snapshot.camera, snapshot.decoded, snapshot.fresh, snapshot.decodeMS)
}
private func handle(_ event: OpticalReceiveEvent) {
switch event {
case .started(let manifest):
self.manifest = manifest
self.receivedChunks = 0
self.totalChunks = Int(manifest.totalChunks)
self.message = nil
case .progress(let manifest, let received, let total):
self.manifest = manifest
self.receivedChunks = received
self.totalChunks = total
case .completed(_, let url):
self.savedFiles.append(url)
self.manifest = nil
self.receivedChunks = 0
self.totalChunks = 0
self.message = "已保存 \(url.lastPathComponent),可以继续接收下一个文件"
case .failed(let text):
self.message = text
}
}
}
// MARK: - 相机
/// 高频解码相机。
///
/// 与配对码扫描(`ScannerView`)的区别:那个只需要认一张静止的码,用
/// `AVCaptureMetadataOutput` 就够;这里要在 30~60 FPS 的动态码上尽可能多地
/// 解出**不同**的帧,必须自己拿到像素、锁 ROI、并把解码限制在那一小块上。
struct OpticalCameraView: UIViewControllerRepresentable {
let onFrame: (String, Double) -> Void
let onMiss: (Double) -> Void
func makeUIViewController(context: Context) -> OpticalCameraController {
let controller = OpticalCameraController()
controller.onFrame = onFrame
controller.onMiss = onMiss
return controller
}
func updateUIViewController(_ controller: OpticalCameraController, context: Context) {}
}
final class OpticalCameraController: UIViewController, AVCaptureVideoDataOutputSampleBufferDelegate {
var onFrame: ((String, Double) -> Void)?
var onMiss: ((Double) -> Void)?
private let session = AVCaptureSession()
private let sampleQueue = DispatchQueue(label: "qft.optical.capture", qos: .userInitiated)
private var preview: AVCaptureVideoPreviewLayer?
private let lockLayer = CAShapeLayer()
private var device: AVCaptureDevice?
private var roi = OpticalROI()
private lazy var request: VNDetectBarcodesRequest = {
let request = VNDetectBarcodesRequest()
request.symbologies = [.qr]
return request
}()
private var lastFocusAt = Date.distantPast
override func viewDidLoad() {
super.viewDidLoad()
view.backgroundColor = .black
configureSession()
configureOverlay()
}
private func configureSession() {
session.beginConfiguration()
session.sessionPreset = .inputPriority // 帧率与格式由下面显式挑选
guard let device = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .back),
let input = try? AVCaptureDeviceInput(device: device),
session.canAddInput(input) else {
session.commitConfiguration()
return
}
session.addInput(input)
self.device = device
let output = AVCaptureVideoDataOutput()
// 追不上就丢,不要排队播放过时的相机帧——屏幕上的码早就换过了
output.alwaysDiscardsLateVideoFrames = true
output.videoSettings = [
kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_420YpCbCr8BiPlanarFullRange,
]
output.setSampleBufferDelegate(self, queue: sampleQueue)
if session.canAddOutput(output) { session.addOutput(output) }
if let connection = output.connection(with: .video) {
// 刻意**不**在采集连接上旋转:旋转会在管线里多做一次整帧拷贝。
// 竖屏的方向修正交给 Vision 的 .right,预览层单独转。
if connection.isVideoStabilizationSupported {
// 防抖会引入额外延迟与形变,对静止拍屏毫无价值
connection.preferredVideoStabilizationMode = .off
}
}
configureFormat(device)
session.commitConfiguration()
let layer = AVCaptureVideoPreviewLayer(session: session)
layer.videoGravity = .resizeAspectFill
layer.frame = view.bounds
if let connection = layer.connection {
// iOS 17 换了 API,但这个 App 要一直支持到 iOS 15
if #available(iOS 17.0, *) {
if connection.isVideoRotationAngleSupported(90) { connection.videoRotationAngle = 90 }
} else if connection.isVideoOrientationSupported {
connection.videoOrientation = .portrait
}
}
view.layer.insertSublayer(layer, at: 0)
preview = layer
}
/// 挑一个「分辨率够、帧率够」的格式。
///
/// 二维码识别的真正约束是**每模块像素数**,所以不能一味降分辨率;
/// 但帧率上不去,「有效新帧/s」就封顶了。折中:在支持 ≥60 FPS 的格式里
/// 取分辨率最高的;没有这种格式时,退而求其次取帧率最高的。
private func configureFormat(_ device: AVCaptureDevice) {
var best: (format: AVCaptureDevice.Format, fps: Double)?
for format in device.formats {
let dimensions = CMVideoFormatDescriptionGetDimensions(format.formatDescription)
guard dimensions.width <= 1920 else { continue }
let maxRate = format.videoSupportedFrameRateRanges.map(\.maxFrameRate).max() ?? 0
guard maxRate >= 30 else { continue }
if let current = best {
let currentDimensions = CMVideoFormatDescriptionGetDimensions(current.format.formatDescription)
let currentFast = current.fps >= 60
let candidateFast = maxRate >= 60
if candidateFast != currentFast {
if candidateFast { best = (format, maxRate) }
} else if dimensions.width > currentDimensions.width {
best = (format, maxRate)
}
} else {
best = (format, maxRate)
}
}
guard let chosen = best, (try? device.lockForConfiguration()) != nil else { return }
defer { device.unlockForConfiguration() }
device.activeFormat = chosen.format
let target = min(chosen.fps, 60)
let duration = CMTime(value: 1, timescale: CMTimeScale(target.rounded()))
device.activeVideoMinFrameDuration = duration
device.activeVideoMaxFrameDuration = duration
if device.isFocusModeSupported(.continuousAutoFocus) {
device.focusMode = .continuousAutoFocus
}
if device.isExposureModeSupported(.continuousAutoExposure) {
device.exposureMode = .continuousAutoExposure
}
// HDR 会在部分机型上把帧率对半砍,而拍屏幕根本用不到宽动态
if device.activeFormat.isVideoHDRSupported {
device.automaticallyAdjustsVideoHDREnabled = false
device.isVideoHDREnabled = false
}
}
private func configureOverlay() {
lockLayer.fillColor = UIColor.clear.cgColor
lockLayer.lineWidth = 2
lockLayer.strokeColor = UIColor.white.withAlphaComponent(0.6).cgColor
view.layer.addSublayer(lockLayer)
}
// MARK: - 每帧
func captureOutput(_ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer,
from connection: AVCaptureConnection) {
guard let buffer = CMSampleBufferGetImageBuffer(sampleBuffer) else { return }
let width = CVPixelBufferGetWidth(buffer)
let height = CVPixelBufferGetHeight(buffer)
// 竖屏 + 后摄:Vision 按 .right 旋转后画面的宽高互换,
// 归一化 ROI 要按旋转**之后**的宽高比才能修成像素正方形
let orientedAspect = width > 0 ? CGFloat(height) / CGFloat(width) : 1
if abs(roi.aspect - orientedAspect) > 0.001 {
roi = OpticalROI(aspect: orientedAspect)
}
request.regionOfInterest = roi.decodeRegion
let handler = VNImageRequestHandler(cvPixelBuffer: buffer, orientation: .right, options: [:])
let startedAt = CFAbsoluteTimeGetCurrent()
try? handler.perform([request])
let elapsed = (CFAbsoluteTimeGetCurrent() - startedAt) * 1000
let observation = request.results?
.first { OpticalProtocol.isOpticalText($0.payloadStringValue ?? "") }
if let observation, let text = observation.payloadStringValue {
roi.hit(boundingBox: observation.boundingBox)
onFrame?(text, elapsed)
refocusIfNeeded()
} else {
roi.miss()
onMiss?(elapsed)
}
let region = roi.decodeRegion
let locked = roi.isLocked
DispatchQueue.main.async { [weak self] in self?.drawLock(region: region, locked: locked) }
}
/// 锁定之后周期性在 ROI 中心重新对焦/测光。屏幕是个平面光源,
/// 连续自动对焦经常在背景上来回拉风箱。
private func refocusIfNeeded() {
guard Date().timeIntervalSince(lastFocusAt) > 2.5, let device else { return }
lastFocusAt = Date()
let center = CGPoint(x: roi.decodeRegion.midX, y: 1 - roi.decodeRegion.midY)
guard (try? device.lockForConfiguration()) != nil else { return }
defer { device.unlockForConfiguration() }
if device.isFocusPointOfInterestSupported, device.isFocusModeSupported(.autoFocus) {
device.focusPointOfInterest = center
device.focusMode = .autoFocus
}
if device.isExposurePointOfInterestSupported,
device.isExposureModeSupported(.continuousAutoExposure) {
device.exposurePointOfInterest = center
device.exposureMode = .continuousAutoExposure
}
}
private func drawLock(region: CGRect, locked: Bool) {
guard let preview else { return }
// Vision 原点在左下,metadataOutputRect 原点在左上
let metadataRect = CGRect(x: region.minX, y: 1 - region.minY - region.height,
width: region.width, height: region.height)
let rect = preview.layerRectConverted(fromMetadataOutputRect: metadataRect)
lockLayer.path = UIBezierPath(roundedRect: rect, cornerRadius: 8).cgPath
lockLayer.strokeColor = locked
? UIColor.systemGreen.cgColor
: UIColor.white.withAlphaComponent(0.6).cgColor
}
// MARK: - 生命周期
override func viewWillAppear(_ animated: Bool) {
super.viewWillAppear(animated)
// 长时间盯着屏幕解码,别让手机自己锁屏
UIApplication.shared.isIdleTimerDisabled = true
start()
}
/// 相机权限没批下来就不要启动会话:那样只会得到一个永远漆黑的画面,
/// 用户不知道该去哪儿改。
private func start() {
guard !session.isRunning else { return }
switch AVCaptureDevice.authorizationStatus(for: .video) {
case .authorized:
sampleQueue.async { [session] in session.startRunning() }
case .notDetermined:
AVCaptureDevice.requestAccess(for: .video) { [weak self] granted in
guard granted, let self else { return }
self.sampleQueue.async { [session = self.session] in session.startRunning() }
}
default:
break
}
}
override func viewWillDisappear(_ animated: Bool) {
super.viewWillDisappear(animated)
UIApplication.shared.isIdleTimerDisabled = false
guard session.isRunning else { return }
sampleQueue.async { [session] in session.stopRunning() }
}
override func viewDidLayoutSubviews() {
super.viewDidLayoutSubviews()
preview?.frame = view.bounds
}
}
+241 -48
View File
@@ -1,51 +1,78 @@
import SwiftUI import SwiftUI
import CoreImage.CIFilterBuiltins import CoreImage.CIFilterBuiltins
/// 已经配对成功的一台电脑。
struct DesktopSession: Equatable {
let host: QFTHost
let token: String
let name: String
}
@MainActor @MainActor
final class TransferModel: ObservableObject { final class TransferModel: ObservableObject {
enum Stage: Equatable { enum Stage: Equatable {
case idle case idle
/// 扫配对二维码
case scanning case scanning
/// 扫到 QFTPAIR2:需要用户挑一个文件传给电脑 /// 光学接收:只用摄像头,不碰任何网络
case pickFileForUpload(PairingPayload) case optical
/// 扫到 QFTPAIR2:需要用户挑文件传给电脑
case pickFilesForUpload(PairingPayload)
/// 专用网络(Windows QFT Direct),但本机签名不能自动加入 Wi-Fi
case manualJoin(WifiCredentials, PairingPayload)
/// 「连接电脑」页:附近的电脑 + 连接码
case nearby
/// 已配对,等待挑文件
case pickFilesForDesktop(DesktopSession)
case connecting(String) case connecting(String)
case running(String) case running(String)
case showingPeerCode(PeerPairing) case showingPeerCode(PeerPairing)
case finished(String, URL?) case finished(String, [URL])
case failed(String) case failed(String)
} }
@Published private(set) var stage: Stage = .idle @Published private(set) var stage: Stage = .idle
@Published private(set) var progress: TransferProgress? @Published private(set) var progress: TransferProgress?
@Published private(set) var detail: String?
@Published private(set) var receivedFiles: [URL] = [] @Published private(set) var receivedFiles: [URL] = []
private var task: Task<Void, Never>? private var task: Task<Void, Never>?
private var sender: PeerSender? private var sender: PeerSender?
private var scopedURL: URL? private var scopedURLs: [URL] = []
private var joinedSSID: String?
private let deviceName = DeviceInfo.name private let deviceName = DeviceInfo.name
// MARK: - 入口 // MARK: - 入口
func beginScan() { stage = .scanning } func beginScan() { stage = .scanning }
func beginOptical() { stage = .optical }
func beginNearby() { stage = .nearby }
func cancel() { func cancel() {
task?.cancel() task?.cancel()
task = nil task = nil
sender?.stop() sender?.stop()
sender = nil sender = nil
releaseScope() releaseScopes()
leaveDedicatedNetwork()
progress = nil progress = nil
detail = nil
stage = .idle stage = .idle
} }
func reset() { func reset() {
progress = nil progress = nil
detail = nil
stage = .idle stage = .idle
refreshReceivedFiles() refreshReceivedFiles()
} }
func finishOptical(_ urls: [URL]) {
finish(urls.isEmpty ? "已退出光学接收" : "已保存 \(urls.count) 个文件", urls)
}
/// 扫到码之后的统一分发 /// 扫到码之后的统一分发
func handleScanned(_ text: String) { func handleScanned(_ text: String) {
if let peer = PeerPairing.parse(text) { if let peer = PeerPairing.parse(text) {
@@ -56,12 +83,70 @@ final class TransferModel: ObservableObject {
stage = .failed("这不是 QFT 的二维码,或二维码里的地址不是局域网地址。") stage = .failed("这不是 QFT 的二维码,或二维码里的地址不是局域网地址。")
return return
} }
switch DedicatedNetworkPlan.plan(for: pairing) {
case .useEndpoints:
proceed(pairing)
case .joinWifi(let wifi):
joinAndProceed(pairing, wifi: wifi)
case .manualJoin(let wifi):
stage = .manualJoin(wifi, pairing)
case .unusable:
stage = .failed("这张二维码既没有可用地址,也没有专用 Wi-Fi 凭据。")
}
}
/// 用户在「设置」里手动连好专用 Wi-Fi 之后回到 App
func manualJoinCompleted(_ pairing: PairingPayload) {
proceed(pairing)
}
private func proceed(_ pairing: PairingPayload) {
switch pairing.direction { switch pairing.direction {
case .downloadToPhone: startDownload(pairing) case .downloadToPhone: startDownload(pairing)
case .uploadToPC: stage = .pickFileForUpload(pairing) case .uploadToPC: stage = .pickFilesForUpload(pairing)
} }
} }
// MARK: - 专用网络(iPhone ↔ Windows)
/// Windows 端的 QFT Direct 是一张**专用 Wi-Fi**:二维码按设计不带任何
/// 电脑地址,手机必须先加入那张网,再从路由表把网关认出来。
private func joinAndProceed(_ pairing: PairingPayload, wifi: WifiCredentials) {
stage = .connecting("正在加入专用网络「\(wifi.ssid)」…")
task = Task {
do {
try await DedicatedNetwork.join(wifi)
joinedSSID = wifi.ssid
detail = "已加入,正在等待电脑响应…"
// 「加入成功」不等于「电脑可达」,判据只能是协议层握手成功
_ = try await DedicatedNetwork.waitForHost(
session: pairing.session, port: pairing.port,
deviceName: deviceName, ssid: wifi.ssid)
detail = nil
guard !Task.isCancelled else { return }
proceed(pairing)
} catch let error as DedicatedNetworkError {
detail = nil
if case .entitlementMissing = error {
// 拿不到 HotspotConfiguration 能力时不假装成功,
// 直接转成「手动连」的引导页
stage = .manualJoin(wifi, pairing)
} else {
stage = .failed(error.localizedDescription)
}
} catch {
detail = nil
fail(error)
}
}
}
private func leaveDedicatedNetwork() {
guard let joinedSSID else { return }
DedicatedNetwork.leave(ssid: joinedSSID)
self.joinedSSID = nil
}
// MARK: - 电脑 → 手机 // MARK: - 电脑 → 手机
private func startDownload(_ pairing: PairingPayload) { private func startDownload(_ pairing: PairingPayload) {
@@ -70,64 +155,156 @@ final class TransferModel: ObservableObject {
do { do {
let host = try await HostDiscovery(pairing: pairing, deviceName: deviceName).locate() let host = try await HostDiscovery(pairing: pairing, deviceName: deviceName).locate()
guard !Task.isCancelled else { return } guard !Task.isCancelled else { return }
stage = .running("正在从 \(pairing.pcName) 接收 \(pairing.fileName ?? "文件")") let name = pairing.fileName ?? "文件"
let client = DownloadClient(host: host, pairing: pairing, deviceName: deviceName) stage = .running("正在从 \(pairing.pcName) 接收 \(name)")
let saved = try await client.run { [weak self] value in
Task { @MainActor in self?.progress = value } let directory = try DownloadClient.defaultDestinationDirectory()
} let saved = try await download(
finish("已保存到「文件」App 的 QFT 文件夹", saved) host: host, token: pairing.session, directory: directory,
target: RangeDownloadClient.Target(fileName: name,
fileSize: pairing.fileSize ?? 0,
sha256: pairing.sha256),
legacy: { try await DownloadClient(host: host, pairing: pairing,
deviceName: self.deviceName,
destinationDirectory: directory)
.run { [weak self] value in
Task { @MainActor in self?.progress = value }
} })
finish("已保存到「文件」App 的 QFT 文件夹", [saved])
} catch { } catch {
fail(error) fail(error)
} }
} }
} }
/// 优先并行 Range,桌面端不支持分段时回落单流。
///
/// 单条 TCP 在 Wi-Fi 上打不满链路,8 路并行才是 iPhone ↔ Mac 场景下
/// 「局域网也要更快」的落点;而回落分支保证遇到老版本电脑端不会直接失败。
private func download(host: QFTHost, token: String, directory: URL,
target: RangeDownloadClient.Target,
legacy: () async throws -> URL) async throws -> URL {
let client = RangeDownloadClient(host: host, token: token, deviceName: deviceName,
destinationDirectory: directory)
var resolved = target
if resolved.fileSize == 0 {
let probed = try await client.probe()
resolved = RangeDownloadClient.Target(fileName: resolved.fileName.isEmpty
? probed.fileName : resolved.fileName,
fileSize: probed.fileSize,
sha256: resolved.sha256)
}
do {
return try await client.run(resolved) { [weak self] value in
Task { @MainActor in self?.progress = value }
}
} catch QFTError.rangeUnsupported {
detail = "电脑端不支持分段下载,已回落为单流传输"
progress = nil
return try await legacy()
}
}
// MARK: - 手机 → 电脑 // MARK: - 手机 → 电脑
func startUpload(_ pairing: PairingPayload, fileURL: URL) { func startUpload(_ pairing: PairingPayload, fileURLs: [URL]) {
guard claimScope(fileURL) else { guard claimScopes(fileURLs) else {
stage = .failed("没有权限读取这个文件,请换一个位置再试。") stage = .failed("没有权限读取这些文件,请换一个位置再试。")
return return
} }
stage = .connecting("正在找 \(pairing.pcName)…") stage = .connecting("正在找 \(pairing.pcName)…")
task = Task { task = Task {
defer { releaseScope() } defer { releaseScopes() }
do { do {
let host = try await HostDiscovery(pairing: pairing, deviceName: deviceName).locate() let host = try await HostDiscovery(pairing: pairing, deviceName: deviceName).locate()
guard !Task.isCancelled else { return } guard !Task.isCancelled else { return }
stage = .running("正在发送 \(fileURL.lastPathComponent) 到 \(pairing.pcName)") try await upload(fileURLs, host: host, token: pairing.session, target: pairing.pcName)
let client = UploadClient(host: host, pairing: pairing, deviceName: deviceName) finish("已发送 \(fileURLs.count) 个文件到 \(pairing.pcName)", [])
_ = try await client.run(fileURL: fileURL) { [weak self] value in
Task { @MainActor in self?.progress = value }
}
finish("已发送到 \(pairing.pcName)", nil)
} catch { } catch {
fail(error) fail(error)
} }
} }
} }
// MARK: - iPhone ↔ iPhone(隔空投送式) func startUpload(to session: DesktopSession, fileURLs: [URL]) {
guard claimScopes(fileURLs) else {
func startPeerSend(fileURL: URL) { stage = .failed("没有权限读取这些文件,请换一个位置再试。")
guard claimScope(fileURL) else {
stage = .failed("没有权限读取这个文件,请换一个位置再试。")
return return
} }
stage = .connecting("正在准备…")
task = Task { task = Task {
defer { releaseScope() } defer { releaseScopes() }
do { do {
let sender = PeerSender(fileURL: fileURL, deviceName: deviceName) try await upload(fileURLs, host: session.host, token: session.token,
// start() 里要完整读一遍文件算摘要,别卡住主线程 target: session.name)
finish("已发送 \(fileURLs.count) 个文件到 \(session.name)", [])
} catch {
fail(error)
}
}
}
private func upload(_ fileURLs: [URL], host: QFTHost, token: String, target: String) async throws {
let pairing = PairingPayload(version: 2, session: token, pcName: target,
port: 0, endpoints: [host.baseURL], wifi: nil,
direction: .uploadToPC, fileName: nil,
fileSize: nil, sha256: nil)
let client = UploadClient(host: host, pairing: pairing, deviceName: deviceName)
for (index, url) in fileURLs.enumerated() {
try Task.checkCancellation()
stage = .running("正在发送 \(url.lastPathComponent) 到 \(target)")
detail = fileURLs.count > 1 ? "第 \(index + 1)/\(fileURLs.count) 个文件" : nil
_ = try await client.run(fileURL: url) { [weak self] value in
Task { @MainActor in self?.progress = value }
}
}
detail = nil
}
// MARK: - 连接电脑(附近的电脑 / 连接码)
/// 用连接码换取会话令牌。电脑端错 5 次就作废整个码,所以绝不重试。
func connect(code text: String, peer: DesktopPeer?) {
stage = .connecting("正在连接电脑…")
task = Task {
do {
let code = try ConnectCode.decode(text)
guard code.isUsable else {
throw QFTError.malformedResponse("连接码里的地址不是局域网地址")
}
let token = try await DesktopPairing.pair(baseURL: code.baseURL,
code: code.secretHex,
deviceName: deviceName)
guard !Task.isCancelled else { return }
let name = peer?.name ?? code.address
stage = .pickFilesForDesktop(DesktopSession(host: QFTHost(baseURL: code.baseURL),
token: token, name: name))
} catch {
fail(error)
}
}
}
// MARK: - iPhone ↔ iPhone(隔空)
func startPeerSend(fileURLs: [URL]) {
guard claimScopes(fileURLs) else {
stage = .failed("没有权限读取这些文件,请换一个位置再试。")
return
}
stage = .connecting("正在计算校验值…")
task = Task {
defer { releaseScopes() }
do {
let sender = PeerSender(fileURLs: fileURLs, deviceName: deviceName)
// start() 里要完整读一遍每个文件算摘要,别卡住主线程
let pairing = try await Task.detached { try sender.start() }.value let pairing = try await Task.detached { try sender.start() }.value
guard !Task.isCancelled else { sender.stop(); return } guard !Task.isCancelled else { sender.stop(); return }
self.sender = sender self.sender = sender
stage = .showingPeerCode(pairing) stage = .showingPeerCode(pairing)
try await sender.waitAndSend { [weak self] value in try await sender.waitAndSend { [weak self] update in
Task { @MainActor in self?.progress = value } Task { @MainActor in self?.apply(update) }
} }
finish("已发送给对方", nil) finish("已发送给对方", [])
} catch { } catch {
fail(error) fail(error)
} }
@@ -142,9 +319,9 @@ final class TransferModel: ObservableObject {
do { do {
let directory = try DownloadClient.defaultDestinationDirectory() let directory = try DownloadClient.defaultDestinationDirectory()
let receiver = PeerReceiver(pairing: pairing, destinationDirectory: directory) let receiver = PeerReceiver(pairing: pairing, destinationDirectory: directory)
stage = .running("正在接收 \(pairing.fileName)") stage = .running("正在接收 \(pairing.fileCount) 个文件")
let saved = try await receiver.run { [weak self] value in let saved = try await receiver.run { [weak self] update in
Task { @MainActor in self?.progress = value } Task { @MainActor in self?.apply(update) }
} }
finish("已保存到「文件」App 的 QFT 文件夹", saved) finish("已保存到「文件」App 的 QFT 文件夹", saved)
} catch { } catch {
@@ -153,17 +330,28 @@ final class TransferModel: ObservableObject {
} }
} }
private func apply(_ update: PeerTransferUpdate) {
progress = update.progress
detail = update.fileCount > 1
? "第 \(update.fileIndex + 1)/\(update.fileCount) 个 · \(update.fileName)"
: update.fileName
}
// MARK: - 收尾 // MARK: - 收尾
private func finish(_ message: String, _ url: URL?) { private func finish(_ message: String, _ urls: [URL]) {
progress = nil progress = nil
stage = .finished(message, url) detail = nil
leaveDedicatedNetwork()
stage = .finished(message, urls)
refreshReceivedFiles() refreshReceivedFiles()
} }
private func fail(_ error: Error) { private func fail(_ error: Error) {
guard !(error is CancellationError) else { return } guard !(error is CancellationError) else { return }
progress = nil progress = nil
detail = nil
leaveDedicatedNetwork()
stage = .failed(error.localizedDescription) stage = .failed(error.localizedDescription)
} }
@@ -175,7 +363,7 @@ final class TransferModel: ObservableObject {
return return
} }
receivedFiles = entries receivedFiles = entries
.filter { $0.pathExtension != "qftpart" } .filter { $0.pathExtension != "qftpart" && !$0.lastPathComponent.hasSuffix(".ledger") }
.sorted { lhs, rhs in .sorted { lhs, rhs in
let l = (try? lhs.resourceValues(forKeys: [.contentModificationDateKey]))? let l = (try? lhs.resourceValues(forKeys: [.contentModificationDateKey]))?
.contentModificationDate ?? .distantPast .contentModificationDate ?? .distantPast
@@ -189,16 +377,21 @@ final class TransferModel: ObservableObject {
/// 文件选择器给的 URL 属于其他进程的沙盒,读之前必须声明作用域, /// 文件选择器给的 URL 属于其他进程的沙盒,读之前必须声明作用域,
/// 而且整个传输期间都要持有。 /// 而且整个传输期间都要持有。
private func claimScope(_ url: URL) -> Bool { private func claimScopes(_ urls: [URL]) -> Bool {
releaseScope() releaseScopes()
guard url.startAccessingSecurityScopedResource() else { return false } for url in urls {
scopedURL = url guard url.startAccessingSecurityScopedResource() else {
return true releaseScopes()
return false
}
scopedURLs.append(url)
}
return !scopedURLs.isEmpty
} }
private func releaseScope() { private func releaseScopes() {
scopedURL?.stopAccessingSecurityScopedResource() scopedURLs.forEach { $0.stopAccessingSecurityScopedResource() }
scopedURL = nil scopedURLs = []
} }
} }
+79
View File
@@ -0,0 +1,79 @@
import Foundation
/// RFC 9285 Base45。
///
/// 光学链路选它而不是 Base64:这 45 个字符全部落在 QR 的**字母数字模式**里,
/// 同样一帧二进制数据能少用不少模块(实测 450 B DATA 帧为 QR-L v15,
/// 旧的 Base64 480 B 对照是 v18)。
///
/// 这里同时保留 encode:Windows 端只编码不解码、Android 端只解码不编码,
/// 而 iOS 侧的合成测试需要自己造帧,两个方向都必须与 `desktop/src/base45.rs`
/// 和 `android/.../Base45.kt` 逐字符一致。
enum Base45 {
static let alphabet = Array("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:")
private static let reverse: [Int8] = {
var table = [Int8](repeating: -1, count: 128)
for (index, character) in alphabet.enumerated() {
table[Int(character.asciiValue!)] = Int8(index)
}
return table
}()
static func encode(_ input: Data) -> String {
guard !input.isEmpty else { return "" }
var out = String()
out.reserveCapacity((input.count * 3 + 1) / 2)
let bytes = [UInt8](input)
var index = 0
while index + 1 < bytes.count {
let value = Int(bytes[index]) * 256 + Int(bytes[index + 1])
out.append(alphabet[value % 45])
out.append(alphabet[(value / 45) % 45])
out.append(alphabet[value / (45 * 45)])
index += 2
}
if index < bytes.count {
let value = Int(bytes[index])
out.append(alphabet[value % 45])
out.append(alphabet[value / 45])
}
return out
}
/// 解码失败一律返回 nil:光学帧是从相机噪声里解出来的,
/// 半个字符错位就应该整帧丢弃,交给下一次重播。
static func decode(_ text: String) -> Data? {
if text.isEmpty { return Data() }
let characters = Array(text.utf8)
if characters.count % 3 == 1 { return nil }
var out = Data()
out.reserveCapacity((characters.count / 3) * 2 + 1)
var index = 0
while index + 2 < characters.count {
guard let a = value(characters[index]),
let b = value(characters[index + 1]),
let c = value(characters[index + 2]) else { return nil }
let n = a + b * 45 + c * 45 * 45
if n > 0xFFFF { return nil }
out.append(UInt8(n / 256))
out.append(UInt8(n % 256))
index += 3
}
if index < characters.count {
guard let a = value(characters[index]), let b = value(characters[index + 1]) else { return nil }
let n = a + b * 45
if n > 0xFF { return nil }
out.append(UInt8(n))
}
return out
}
private static func value(_ byte: UInt8) -> Int? {
guard byte < 128 else { return nil }
let mapped = reverse[Int(byte)]
return mapped >= 0 ? Int(mapped) : nil
}
}
+42
View File
@@ -0,0 +1,42 @@
import Foundation
/// CRC-32(IEEE 802.3,反射多项式 0xEDB88320)。
///
/// 光学帧每帧自带 CRC32,这是**唯一**能把相机误识别挡在文件之外的手段:
/// ZXing/Vision 会偶尔把一帧解成语法合法但内容错误的字符串,长度和结构
/// 都对得上,只有 CRC 能发现。
enum CRC32 {
private static let table: [UInt32] = {
(0..<256).map { index -> UInt32 in
var value = UInt32(index)
for _ in 0..<8 {
value = (value & 1) != 0 ? (value >> 1) ^ 0xEDB8_8320 : value >> 1
}
return value
}
}()
static func compute<Bytes: Sequence>(_ bytes: Bytes) -> UInt32 where Bytes.Element == UInt8 {
var crc: UInt32 = 0xFFFF_FFFF
for byte in bytes {
crc = (crc >> 8) ^ table[Int((crc ^ UInt32(byte)) & 0xFF)]
}
return crc ^ 0xFFFF_FFFF
}
}
/// CRC-8(多项式 0x07,初值 0),用于桌面端连接码的校验位。
/// 与 `desktop/src/connect_code.rs::crc8` 必须逐位一致。
enum CRC8 {
static func compute<Bytes: Sequence>(_ bytes: Bytes) -> UInt8 where Bytes.Element == UInt8 {
var crc: UInt8 = 0
for byte in bytes {
crc ^= byte
for _ in 0..<8 {
crc = (crc & 0x80) != 0 ? (crc << 1) ^ 0x07 : crc << 1
}
}
return crc
}
}
+213
View File
@@ -0,0 +1,213 @@
import Foundation
/// 桌面端连接码(`desktop/src/connect_code.rs` 的客户端实现)。
///
/// 电脑之间没有摄像头,所以桌面端进入「我要接收」后显示的是一串
/// `K7M2-9X4P-QR3T` 形式的连接码:**地址、端口和配对秘密都编在码里**。
/// iPhone 直接照着屏幕输入这串码,就能连上 Mac 或 Windows,
/// 既不用扫码,也不需要广播能通——只要 IP 层路由可达即可。
///
/// 编码(全部与 Rust 端逐位一致):
/// ```text
/// byte0 version(3) | kind(3) | default_port(1) | reserved(1)
/// addr 2~4 字节(按私有网段压缩)或 16 字节(IPv6)
/// port 2 字节,仅当端口非 39393 时存在
/// secret 3 字节
/// crc 1 字节 CRC-8
/// ```
struct ConnectCode: Equatable {
/// Crockford Base32:去掉了容易混淆的 I、L、O、U
static let alphabet = Array("0123456789ABCDEFGHJKMNPQRSTVWXYZ")
static let version: UInt8 = 1
static let defaultPort = 39393
static let secretLength = 3
enum Kind: UInt8 {
case private192 = 0
case private10 = 1
case private172 = 2
case fullV4 = 3
case v6 = 4
var addressLength: Int {
switch self {
case .private192: return 2
case .private10, .private172: return 3
case .fullV4: return 4
case .v6: return 16
}
}
}
enum CodeError: LocalizedError, Equatable {
case length
case alphabet(Character)
case checksum
case unsupported
var errorDescription: String? {
switch self {
case .length: return "连接码长度不对,请检查是否漏敲或多敲了字符"
case .alphabet(let ch): return "连接码里有无效字符「\(ch)」"
case .checksum: return "连接码校验失败,请核对后重新输入"
case .unsupported: return "无法识别的连接码版本"
}
}
}
/// 点分十进制的 IPv4。iOS 端只接受 IPv4:这条路径最终要落到
/// `http://<私有 IPv4>:<port>` 的白名单上,IPv6 直连不在本端支持范围内。
let address: String
let port: Int
let secret: [UInt8]
/// 线上表示:6 个小写十六进制字符,放进 `X-QFT-Code` 头
var secretHex: String { secret.map { String(format: "%02x", $0) }.joined() }
var baseURL: String { "http://\(address):\(port)" }
/// 连接码同样是不可信输入:它决定了 App 接下来连哪个地址,
/// 所以必须过与二维码端点同一套私有地址白名单。
var isUsable: Bool {
PairingProtocol.isAllowedLocalHTTPEndpoint(baseURL, expectedPort: port)
}
// MARK: - 解析
static func decode(_ text: String) throws -> ConnectCode {
let (bytes, paddingOK) = try base32Decode(text)
let code = try fromBytes(bytes)
// 先判长度/CRC 再判填充位:长度不对时「长度不对」比「校验失败」更能指导用户
guard paddingOK else { throw CodeError.checksum }
return code
}
private static func fromBytes(_ bytes: [UInt8]) throws -> ConnectCode {
guard bytes.count >= 1 + 2 + secretLength + 1 else { throw CodeError.length }
let payload = Array(bytes[0..<(bytes.count - 1)])
guard CRC8.compute(payload) == bytes[bytes.count - 1] else { throw CodeError.checksum }
let header = payload[0]
guard header >> 5 == version else { throw CodeError.unsupported }
guard let kind = Kind(rawValue: (header >> 2) & 0b111) else { throw CodeError.unsupported }
let defaultPortFlag = (header >> 1) & 1 == 1
let addressLength = kind.addressLength
let portLength = defaultPortFlag ? 0 : 2
guard payload.count == 1 + addressLength + portLength + secretLength else {
throw CodeError.length
}
let slice = Array(payload[1..<(1 + addressLength)])
let address: String
switch kind {
case .private192: address = "192.168.\(slice[0]).\(slice[1])"
case .private10: address = "10.\(slice[0]).\(slice[1]).\(slice[2])"
case .private172:
guard slice[0] <= 15 else { throw CodeError.unsupported }
address = "172.\(Int(slice[0]) + 16).\(slice[1]).\(slice[2])"
case .fullV4: address = "\(slice[0]).\(slice[1]).\(slice[2]).\(slice[3])"
case .v6: throw CodeError.unsupported // iPhone 端只走私有 IPv4
}
var cursor = 1 + addressLength
var port = defaultPort
if !defaultPortFlag {
port = Int(payload[cursor]) << 8 | Int(payload[cursor + 1])
cursor += 2
}
let secret = Array(payload[cursor..<(cursor + secretLength)])
return ConnectCode(address: address, port: port, secret: secret)
}
// MARK: - 编码(自检用;真实场景由桌面端生成)
func encode() -> String {
let octets = address.split(separator: ".").compactMap { UInt8($0) }
var kind = Kind.fullV4
var addressBytes = octets
if octets.count == 4 {
switch (octets[0], octets[1]) {
case (192, 168): kind = .private192; addressBytes = [octets[2], octets[3]]
case (10, _): kind = .private10; addressBytes = [octets[1], octets[2], octets[3]]
case (172, 16...31): kind = .private172
addressBytes = [octets[1] - 16, octets[2], octets[3]]
default: kind = .fullV4
}
}
let usesDefaultPort = port == Self.defaultPort
var out: [UInt8] = [(Self.version << 5) | (kind.rawValue << 2) | ((usesDefaultPort ? 1 : 0) << 1)]
out.append(contentsOf: addressBytes)
if !usesDefaultPort {
out.append(UInt8(truncatingIfNeeded: port >> 8))
out.append(UInt8(truncatingIfNeeded: port))
}
out.append(contentsOf: secret)
out.append(CRC8.compute(out))
let raw = Self.base32Encode(out)
return stride(from: 0, to: raw.count, by: 4).map { start -> String in
let from = raw.index(raw.startIndex, offsetBy: start)
let to = raw.index(from, offsetBy: min(4, raw.count - start))
return String(raw[from..<to])
}.joined(separator: "-")
}
// MARK: - Base32
static func base32Encode(_ bytes: [UInt8]) -> String {
var out = ""
var buffer: UInt32 = 0
var bits: UInt32 = 0
for byte in bytes {
buffer = (buffer << 8) | UInt32(byte)
bits += 8
while bits >= 5 {
bits -= 5
out.append(alphabet[Int((buffer >> bits) & 0x1f)])
}
}
if bits > 0 {
out.append(alphabet[Int((buffer << (5 - bits)) & 0x1f)])
}
return out
}
/// 返回(字节, 末尾填充位是否为 0)。
/// 填充位必须校验:否则改动最后一个字符有相当概率解出完全相同的字节序列,
/// CRC 根本没有机会发现——这一点 Rust 端有实测记录。
static func base32Decode(_ text: String) throws -> ([UInt8], Bool) {
var buffer: UInt32 = 0
var bits: UInt32 = 0
var out: [UInt8] = []
var symbols = 0
for character in text {
if character == "-" || character == " " || character == "_" || character == "\t" {
continue
}
let upper = Character(String(character).uppercased())
// Crockford 容错:手写/口述时 I、L 常被当成 1,O 被当成 0
let normalized: Character
switch upper {
case "I", "L": normalized = "1"
case "O": normalized = "0"
default: normalized = upper
}
guard let value = alphabet.firstIndex(of: normalized) else {
throw CodeError.alphabet(character)
}
symbols += 1
buffer = (buffer << 5) | UInt32(value)
bits += 5
if bits >= 8 {
bits -= 8
out.append(UInt8((buffer >> bits) & 0xff))
}
}
guard symbols > 0 else { throw CodeError.length }
let paddingOK = bits == 0 || (buffer & ((1 << bits) - 1)) == 0
return (out, paddingOK)
}
}
+148
View File
@@ -0,0 +1,148 @@
import Foundation
#if os(iOS)
import NetworkExtension
#endif
/// 连接「QFT Direct」这类专用网络时,App 该走哪条路。
///
/// Windows 端进入接收后会用 Wi-Fi Direct Legacy AP 开一张**专用网**,
/// 二维码里只放 SSID/密码,按设计**不携带任何电脑地址**
/// (`desktop/src/pairing.rs::qr_endpoints`)——手机必须先加入那张网,
/// 再从路由表里读网关。iOS 上「加入指定 Wi-Fi」有两条路,能力取决于签名,
/// 因此把决策单独拎出来,方便在没有真机的情况下测试。
enum DedicatedNetworkPlan: Equatable {
/// 二维码自带可用的局域网地址,直接连(Mac/Linux 端与 Windows 的 LAN 模式)
case useEndpoints([String])
/// 需要先加入专用 Wi-Fi,App 可以自己发起加入
case joinWifi(WifiCredentials)
/// 需要加入专用 Wi-Fi,但本次签名拿不到 HotspotConfiguration 能力,
/// 只能把 SSID/密码显示给用户,由用户去「设置」里连
case manualJoin(WifiCredentials)
/// 既没有地址也没有 Wi-Fi 凭据——这种二维码没法用
case unusable
static func plan(for pairing: PairingPayload,
canJoinProgrammatically: Bool = DedicatedNetwork.canJoinProgrammatically)
-> DedicatedNetworkPlan {
if !pairing.endpoints.isEmpty { return .useEndpoints(pairing.endpoints) }
guard let wifi = pairing.wifi else { return .unusable }
return canJoinProgrammatically ? .joinWifi(wifi) : .manualJoin(wifi)
}
}
enum DedicatedNetworkError: LocalizedError {
case unsupportedPlatform
case entitlementMissing
case userDenied
case invalidCredentials
case joinTimedOut(String)
case system(String)
var errorDescription: String? {
switch self {
case .unsupportedPlatform:
return "本设备无法由 App 加入指定 Wi-Fi。"
case .entitlementMissing:
return """
这台 iPhone 上的 QFT 没有「Hotspot Configuration」能力,无法自动加入电脑的专用 Wi-Fi。
请手动到「设置 → 无线局域网」里连接屏幕上显示的网络,连上后回到 QFT 继续。
"""
case .userDenied:
return "你取消了加入专用 Wi-Fi。"
case .invalidCredentials:
return "二维码里的 Wi-Fi 名称或密码不合法。"
case .joinTimedOut(let ssid):
return "已请求加入「\(ssid)」,但一直没拿到该网络的地址。请确认电脑上的 QFT 仍在接收状态。"
case .system(let detail):
return "加入专用 Wi-Fi 失败:\(detail)"
}
}
}
/// 专用 Wi-Fi 的加入与退出。
///
/// iOS 侧用 `NEHotspotConfiguration`,它需要 `HotspotConfiguration` entitlement。
/// 拿不到能力时**不假装成功**:直接报错并把凭据交给 UI 引导用户手动连接,
/// 而不是让用户对着一个永远连不上的进度条等下去。
enum DedicatedNetwork {
static var canJoinProgrammatically: Bool {
#if os(iOS)
return true
#else
return false
#endif
}
/// 加入专用 Wi-Fi。已经连在这张网上时按成功处理。
static func join(_ wifi: WifiCredentials) async throws {
guard PairingProtocol.isValidWifi(ssid: wifi.ssid, passphrase: wifi.passphrase) else {
throw DedicatedNetworkError.invalidCredentials
}
#if os(iOS)
let configuration = NEHotspotConfiguration(ssid: wifi.ssid,
passphrase: wifi.passphrase,
isWEP: false)
// 专用网没有互联网出口,会话结束后不该留在系统 Wi-Fi 列表里
configuration.joinOnce = true
try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
NEHotspotConfigurationManager.shared.apply(configuration) { error in
guard let error = error as NSError? else { return continuation.resume() }
guard error.domain == NEHotspotConfigurationErrorDomain,
let code = NEHotspotConfigurationError(rawValue: error.code) else {
continuation.resume(throwing: DedicatedNetworkError.system(error.localizedDescription))
return
}
switch code {
case .alreadyAssociated:
continuation.resume()
case .userDenied:
continuation.resume(throwing: DedicatedNetworkError.userDenied)
case .invalid, .invalidSSID, .invalidWPAPassphrase, .invalidSSIDPrefix:
continuation.resume(throwing: DedicatedNetworkError.invalidCredentials)
case .systemConfiguration, .unknown, .applicationIsNotInForeground:
// 没有 entitlement 时系统正是从这几个码里返回,
// 提示必须给出「手动连」这条可行的出路
continuation.resume(throwing: DedicatedNetworkError.entitlementMissing)
default:
continuation.resume(throwing: DedicatedNetworkError.system(error.localizedDescription))
}
}
}
#else
throw DedicatedNetworkError.unsupportedPlatform
#endif
}
static func leave(ssid: String) {
#if os(iOS)
NEHotspotConfigurationManager.shared.removeConfiguration(forSSID: ssid)
#endif
}
/// 等待专用网真正可用。
///
/// 「apply 成功」只代表系统接受了配置,不代表已经拿到 IPv4 地址、
/// 更不代表电脑那一侧的 Wi-Fi Direct 数据通道已经建立。判据只能是
/// **协议层握手成功**:能 ping 通带着正确令牌的 `/qft/ping`。
static func waitForHost(session: String, port: Int, deviceName: String,
ssid: String, timeout: TimeInterval = 20) async throws -> QFTHost {
let deadline = Date().addingTimeInterval(timeout)
while Date() < deadline {
try Task.checkCancellation()
let candidates = LocalNetwork.hostCandidates(port: port, limit: 64)
if !candidates.isEmpty {
let discovery = HostDiscovery(
pairing: PairingPayload(version: 2, session: session, pcName: ssid, port: port,
endpoints: [], wifi: nil, direction: .uploadToPC,
fileName: nil, fileSize: nil, sha256: nil),
deviceName: deviceName)
if let host = await discovery.probe(candidates, timeout: 1.0) { return host }
}
try? await Task.sleep(nanoseconds: 400_000_000)
}
throw DedicatedNetworkError.joinTimedOut(ssid)
}
}
+15 -4
View File
@@ -25,10 +25,15 @@ enum QFTError: LocalizedError {
case httpStatus(Int, String) case httpStatus(Int, String)
case malformedResponse(String) case malformedResponse(String)
case integrity(String) case integrity(String)
/// 对端忽略了 `Range`,把整份文件送了过来。并行下载在这种服务端上不成立,
/// 调用方据此回落单流——所以它必须是一个可判定的 case,而不是一句错误文案。
case rangeUnsupported(Int)
case cancelled case cancelled
var errorDescription: String? { var errorDescription: String? {
switch self { switch self {
case .rangeUnsupported(let code):
return "电脑端不支持分段下载(HTTP \(code)),已回落为单流传输"
case .hostNotFound: case .hostNotFound:
return "找不到电脑。请确认手机和电脑连在同一个 Wi-Fi,并且电脑上的 QFT 正在等待连接。" return "找不到电脑。请确认手机和电脑连在同一个 Wi-Fi,并且电脑上的 QFT 正在等待连接。"
case .httpStatus(let code, let detail): case .httpStatus(let code, let detail):
@@ -43,10 +48,11 @@ enum QFTError: LocalizedError {
} }
} }
/// 在局域网里定位 Windows 端。 /// 在局域网或专用网络里定位电脑。
/// ///
/// 顺序:二维码自带的 endpoint → UDP QFTDISC2 广播 → 当前子网有界扫描。 /// 顺序:二维码自带的 endpoint → 默认网关 → UDP QFTDISC2 广播 → 当前子网有界扫描。
/// 与 Android 端同一套策略,但去掉了 Direct-AP 相关的分支:iOS 连不上指定 AP。 /// 与 Android 端同一套策略。**网关这一步是专用网络的关键**:QFT Direct 的
/// 二维码按设计不带任何电脑地址,加入那张 Wi-Fi 之后,电脑就是网关本身。
struct HostDiscovery { struct HostDiscovery {
let pairing: PairingPayload let pairing: PairingPayload
@@ -58,11 +64,16 @@ struct HostDiscovery {
if let host = await probe(pairing.endpoints, timeout: 1.2) { if let host = await probe(pairing.endpoints, timeout: 1.2) {
return host return host
} }
// 专用网络下网关就是电脑,先打这一枪,命中率最高也最省时间
let gateways = LocalNetwork.defaultGateways().map { "http://\($0):\(pairing.port)" }
if !gateways.isEmpty, let host = await probe(gateways, timeout: 1.2) {
return host
}
if let hinted = await udpDiscover(timeout: 1.5), if let hinted = await udpDiscover(timeout: 1.5),
let host = await probe([hinted], timeout: 1.5) { let host = await probe([hinted], timeout: 1.5) {
return host return host
} }
let candidates = LocalNetwork.subnetCandidates(port: pairing.port, limit: 254) let candidates = LocalNetwork.hostCandidates(port: pairing.port, limit: 254)
if !candidates.isEmpty, let host = await probe(candidates, timeout: 0.7) { if !candidates.isEmpty, let host = await probe(candidates, timeout: 0.7) {
return host return host
} }
+262
View File
@@ -0,0 +1,262 @@
import Foundation
import CryptoKit
enum OpticalReceiveEvent {
case started(OpticalManifest)
case progress(manifest: OpticalManifest, received: Int, total: Int)
case completed(manifest: OpticalManifest, url: URL)
case failed(String)
}
/// 光学会话装配器。
///
/// 电脑端把整份文件切成若干 DATA 帧循环播放,没有任何反向通道,所以这里的
/// 职责是:**去重、定位落盘、数满、校验**。收齐并且 SHA-256 一致才算成功;
/// 校验失败就整份丢弃等下一轮重播,绝不把半份文件交给用户。
///
/// 与 Android `SessionAssembler.kt` 行为一致,差别只在落盘位置:iOS 没有
/// 公共「下载」目录,文件写进 App 的 Documents/QFT,由「文件」App 暴露出去。
final class OpticalAssembler: @unchecked Sendable {
/// 一次 accept 的结果。UI 用它区分「解码/s」和「有效新帧/s」——
/// 屏幕上同一帧会被连续拍到很多次,只有 isNew 才代表真正的吞吐。
enum Acceptance {
case ignored // 不是 QFT 帧、CRC 不过、或不属于当前会话
case duplicate // 解出来了,但这一块早就收过
case accepted // 有效新帧
}
private let destinationDirectory: URL
private let workDirectory: URL
private let onEvent: (OpticalReceiveEvent) -> Void
private let lock = NSLock()
private var manifest: OpticalManifest?
private var received: [Bool] = []
private var receivedCount = 0
private var handle: FileHandle?
private var partURL: URL?
private var completedSession: UInt64?
init(destinationDirectory: URL,
workDirectory: URL = FileManager.default.temporaryDirectory,
onEvent: @escaping (OpticalReceiveEvent) -> Void) {
self.destinationDirectory = destinationDirectory
self.workDirectory = workDirectory
self.onEvent = onEvent
}
deinit { try? handle?.close() }
@discardableResult
func accept(text: String) -> Acceptance {
guard let frame = OpticalProtocol.parseText(text) else { return .ignored }
return accept(frame: frame)
}
@discardableResult
func accept(frame: OpticalFrame) -> Acceptance {
lock.lock()
defer { lock.unlock() }
if completedSession == frame.sessionID { return .duplicate }
switch frame.kind {
case .manifest: return acceptManifest(frame)
case .data: return acceptData(frame)
case .end: return .duplicate
}
}
// MARK: - 帧处理
private func acceptManifest(_ frame: OpticalFrame) -> Acceptance {
guard let incoming = OpticalProtocol.parseManifest(frame) else { return .ignored }
if manifest?.sessionID == incoming.sessionID { return .duplicate }
resetLocked()
// 完成位图是每片一个 Bool,片数由**相机解出来的字节**决定,
// 不设上限的话一帧噪声就能让 App 申请几 GB 内存。
// 800 万片在 450 B 分片下约 3.4 GB,远超光学链路的现实上限。
guard incoming.totalChunks <= 8_000_000 else {
onEvent(.failed("文件分片数过大(\(incoming.totalChunks) 片)"))
return .ignored
}
// 声明的大小必须和分片数自洽,否则这份清单本身就是坏的
let expectedChunks = incoming.chunkSize == 0 ? 0
: (incoming.fileSize + UInt64(incoming.chunkSize) - 1) / UInt64(incoming.chunkSize)
guard expectedChunks == UInt64(incoming.totalChunks) else {
onEvent(.failed("清单自相矛盾:\(incoming.fileSize) 字节 / \(incoming.totalChunks) 片"))
return .ignored
}
let part = workDirectory.appendingPathComponent("qft-optical-\(incoming.sessionID).part")
do {
try FileManager.default.createDirectory(at: workDirectory, withIntermediateDirectories: true)
try? FileManager.default.removeItem(at: part)
guard FileManager.default.createFile(atPath: part.path, contents: nil) else {
throw QFTError.malformedResponse("无法创建临时文件")
}
let handle = try FileHandle(forWritingTo: part)
try handle.truncate(atOffset: incoming.fileSize)
self.handle = handle
} catch {
onEvent(.failed("准备接收失败:\(error.localizedDescription)"))
return .ignored
}
manifest = incoming
partURL = part
received = [Bool](repeating: false, count: Int(incoming.totalChunks))
receivedCount = 0
onEvent(.started(incoming))
if incoming.totalChunks == 0 { finalizeIfComplete() }
return .accepted
}
private func acceptData(_ frame: OpticalFrame) -> Acceptance {
guard let manifest else { return .ignored }
guard frame.sessionID == manifest.sessionID,
frame.totalChunks == manifest.totalChunks,
frame.seq < manifest.totalChunks else { return .ignored }
let offset = UInt64(frame.seq) * UInt64(manifest.chunkSize)
guard offset <= manifest.fileSize else { return .ignored }
let expectedLength = Int(min(UInt64(manifest.chunkSize), manifest.fileSize - offset))
guard frame.payload.count == expectedLength else { return .ignored }
let index = Int(frame.seq)
guard index < received.count else { return .ignored }
if received[index] { return .duplicate }
do {
try handle?.seek(toOffset: offset)
try handle?.write(contentsOf: frame.payload)
} catch {
onEvent(.failed("写入失败:\(error.localizedDescription)"))
return .ignored
}
received[index] = true
receivedCount += 1
onEvent(.progress(manifest: manifest, received: receivedCount, total: received.count))
finalizeIfComplete()
return .accepted
}
private func finalizeIfComplete() {
guard let manifest, receivedCount == received.count, let part = partURL else { return }
do {
try handle?.synchronize()
try handle?.close()
} catch {
onEvent(.failed("落盘失败:\(error.localizedDescription)"))
resetLocked()
return
}
handle = nil
guard let actual = try? Self.sha256(of: part) else {
onEvent(.failed("无法读取临时文件"))
resetLocked()
return
}
guard actual == manifest.sha256 else {
onEvent(.failed("SHA-256 校验失败,保持接收等待下一轮重播"))
resetLocked()
return
}
do {
try FileManager.default.createDirectory(at: destinationDirectory,
withIntermediateDirectories: true)
let finalURL = DownloadClient.uniqueURL(in: destinationDirectory, name: manifest.fileName)
try FileManager.default.moveItem(at: part, to: finalURL)
completedSession = manifest.sessionID
onEvent(.completed(manifest: manifest, url: finalURL))
resetLocked(keepCompleted: true)
} catch {
onEvent(.failed("保存失败:\(error.localizedDescription)"))
}
}
// MARK: - 状态
func reset() {
lock.lock()
defer { lock.unlock() }
resetLocked()
}
private func resetLocked(keepCompleted: Bool = false) {
try? handle?.close()
handle = nil
if let partURL { try? FileManager.default.removeItem(at: partURL) }
partURL = nil
manifest = nil
received = []
receivedCount = 0
if !keepCompleted { completedSession = nil }
}
var currentManifest: OpticalManifest? {
lock.lock(); defer { lock.unlock() }
return manifest
}
static func sha256(of url: URL) throws -> Data {
var hasher = SHA256()
let handle = try FileHandle(forReadingFrom: url)
defer { try? handle.close() }
while let block = try handle.read(upToCount: 4 * 1024 * 1024), !block.isEmpty {
hasher.update(data: block)
}
return Data(hasher.finalize())
}
}
/// 光学链路的实时速率统计。
///
/// 屏幕上同一帧会被相机连续拍到多次,「解码/s」很容易好看但没有意义,
/// 真正决定传输时间的是**有效新帧/s**。两个数字都要给出来,
/// 用户才能据此在电脑端选 30 / 45 / 60 FPS。
final class OpticalStats: @unchecked Sendable {
private let lock = NSLock()
private var windowStart = Date()
private var analyzed = 0
private var decoded = 0
private var fresh = 0
private(set) var cameraFPS: Double = 0
private(set) var decodedPerSecond: Double = 0
private(set) var freshPerSecond: Double = 0
private(set) var lastDecodeMilliseconds: Double = 0
func recordFrame(decodeMilliseconds: Double, acceptance: OpticalAssembler.Acceptance?) {
lock.lock()
defer { lock.unlock() }
analyzed += 1
lastDecodeMilliseconds = decodeMilliseconds
switch acceptance {
case .accepted: decoded += 1; fresh += 1
case .duplicate: decoded += 1
case .ignored, nil: break
}
let elapsed = Date().timeIntervalSince(windowStart)
guard elapsed >= 1 else { return }
cameraFPS = Double(analyzed) / elapsed
decodedPerSecond = Double(decoded) / elapsed
freshPerSecond = Double(fresh) / elapsed
analyzed = 0
decoded = 0
fresh = 0
windowStart = Date()
}
func snapshot() -> (camera: Double, decoded: Double, fresh: Double, decodeMS: Double) {
lock.lock(); defer { lock.unlock() }
return (cameraFPS, decodedPerSecond, freshPerSecond, lastDecodeMilliseconds)
}
}
+210
View File
@@ -0,0 +1,210 @@
import Foundation
/// 光学帧类型。与 `desktop/src/protocol.rs::FrameKind` 一致。
enum OpticalFrameKind: UInt8 {
case manifest = 1
case data = 2
case end = 3
}
struct OpticalFrame: Equatable {
let kind: OpticalFrameKind
let sessionID: UInt64
let seq: UInt32
let totalChunks: UInt32
let payload: Data
}
struct OpticalManifest: Equatable {
let sessionID: UInt64
let senderDevice: String
let fileName: String
let fileSize: UInt64
let chunkSize: Int
let totalChunks: UInt32
let sha256: Data
var sha256Hex: String { sha256.map { String(format: "%02x", $0) }.joined() }
}
/// QFT2 光学协议(单向:电脑屏幕 → iPhone 摄像头)。
///
/// ```text
/// "QFT2" | version u8 | kind u8 | session u64 | seq u32 | total u32 | len u16 | payload | crc32 u32
/// ```
/// 全部大端。文本层是 `QFT2:` + Base45。
///
/// 相机解出来的字符串是**彻底不可信的输入**:ZXing/Vision 偶尔会给出语法
/// 合法但内容错误的结果,因此这里除了 CRC32 之外,长度、类型、payload 长度
/// 字段都要与实际缓冲区严格对齐,任何一项不符就整帧丢弃。
enum OpticalProtocol {
static let prefix = "QFT2:"
static let legacyPrefix = "QFT1:"
/// 4 magic + 1 version + 1 kind + 8 session + 4 seq + 4 total + 2 len
static let headerSize = 24
static let trailerSize = 4
static func isOpticalText(_ text: String) -> Bool {
text.hasPrefix(prefix) || text.hasPrefix(legacyPrefix)
}
static func parseText(_ text: String) -> OpticalFrame? {
if text.hasPrefix(prefix) {
guard let binary = Base45.decode(String(text.dropFirst(prefix.count))) else { return nil }
return parseBinary(binary, magic: "QFT2", version: 2)
}
if text.hasPrefix(legacyPrefix) {
// 旧发送端仍在用 QFT1 + Base64URL,保留只读兼容
guard let binary = Base64URL.decode(String(text.dropFirst(legacyPrefix.count))) else { return nil }
return parseBinary(binary, magic: "QFT1", version: 1)
}
return nil
}
static func parseBinary(_ binary: Data, magic: String, version: UInt8) -> OpticalFrame? {
guard binary.count >= headerSize + trailerSize else { return nil }
let bytes = [UInt8](binary)
let bodySize = bytes.count - trailerSize
let expectedCRC = readU32(bytes, at: bodySize)
guard CRC32.compute(bytes[0..<bodySize]) == expectedCRC else { return nil }
guard String(bytes: bytes[0..<4], encoding: .ascii) == magic else { return nil }
guard bytes[4] == version else { return nil }
guard let kind = OpticalFrameKind(rawValue: bytes[5]) else { return nil }
let sessionID = readU64(bytes, at: 6)
let seq = readU32(bytes, at: 14)
let totalChunks = readU32(bytes, at: 18)
let payloadLength = Int(readU16(bytes, at: 22))
guard payloadLength == bodySize - headerSize else { return nil }
return OpticalFrame(kind: kind, sessionID: sessionID, seq: seq, totalChunks: totalChunks,
payload: Data(bytes[headerSize..<bodySize]))
}
static func parseManifest(_ frame: OpticalFrame) -> OpticalManifest? {
guard frame.kind == .manifest else { return nil }
let bytes = [UInt8](frame.payload)
// 8 size + 2 chunk + 32 sha + 2 nameLen = 44
guard bytes.count >= 44 else { return nil }
let fileSize = readU64(bytes, at: 0)
let chunkSize = Int(readU16(bytes, at: 8))
guard chunkSize > 0 else { return nil }
let sha256 = Data(bytes[10..<42])
let nameLength = Int(readU16(bytes, at: 42))
var cursor = 44
guard cursor + nameLength <= bytes.count else { return nil }
let rawName = String(bytes: bytes[cursor..<(cursor + nameLength)], encoding: .utf8) ?? ""
cursor += nameLength
var device = "Windows-PC"
if cursor + 2 <= bytes.count {
let deviceLength = Int(readU16(bytes, at: cursor))
cursor += 2
guard cursor + deviceLength <= bytes.count else { return nil }
if let raw = String(bytes: bytes[cursor..<(cursor + deviceLength)], encoding: .utf8) {
let cleaned = raw.unicodeScalars.filter { $0.value > 31 && $0.value != 127 }
let text = String(String.UnicodeScalarView(cleaned))
.trimmingCharacters(in: .whitespaces)
if !text.isEmpty { device = String(text.prefix(80)) }
}
}
return OpticalManifest(sessionID: frame.sessionID,
senderDevice: device,
fileName: sanitizeFileName(rawName),
fileSize: fileSize,
chunkSize: chunkSize,
totalChunks: frame.totalChunks,
sha256: sha256)
}
/// 文件名同样来自相机,绝不能直接当路径用。
///
/// 与 Android 端同一套替换规则(分隔符换成 `_`),另外把开头的 `.` 和 `_`
/// 一并去掉:`../../etc/passwd` 替换后是 `.._.._etc_passwd`,虽然已经不含
/// 分隔符,但留着这一串前缀既难看也没有意义。
static func sanitizeFileName(_ raw: String) -> String {
let forbidden: Set<Character> = ["\\", "/", ":", "*", "?", "\"", "<", ">", "|"]
var cleaned = String(raw.unicodeScalars
.filter { $0.value > 31 && $0.value != 127 }
.map { Character($0) }
.map { forbidden.contains($0) ? "_" : $0 })
cleaned = cleaned.trimmingCharacters(in: .whitespaces)
while let first = cleaned.first, first == "." || first == "_" { cleaned.removeFirst() }
cleaned = String(cleaned.prefix(180))
return cleaned.isEmpty ? "qft.bin" : cleaned
}
// MARK: - 编码(仅测试与自检使用)
static func encodeFrame(kind: OpticalFrameKind, sessionID: UInt64, seq: UInt32,
totalChunks: UInt32, payload: Data) -> Data {
var binary = Data("QFT2".utf8)
binary.append(2)
binary.append(kind.rawValue)
appendBE(&binary, sessionID)
appendBE(&binary, seq)
appendBE(&binary, totalChunks)
appendBE(&binary, UInt16(payload.count))
binary.append(payload)
appendBE(&binary, CRC32.compute(binary))
return binary
}
static func encodeManifest(_ manifest: OpticalManifest) -> Data {
var payload = Data()
appendBE(&payload, manifest.fileSize)
appendBE(&payload, UInt16(manifest.chunkSize))
payload.append(manifest.sha256)
let name = Data(manifest.fileName.utf8)
appendBE(&payload, UInt16(name.count))
payload.append(name)
let device = Data(manifest.senderDevice.utf8)
appendBE(&payload, UInt16(device.count))
payload.append(device)
return encodeFrame(kind: .manifest, sessionID: manifest.sessionID, seq: 0,
totalChunks: manifest.totalChunks, payload: payload)
}
static func text(for binary: Data) -> String { prefix + Base45.encode(binary) }
// MARK: - 大端读写
private static func readU16(_ bytes: [UInt8], at offset: Int) -> UInt16 {
UInt16(bytes[offset]) << 8 | UInt16(bytes[offset + 1])
}
private static func readU32(_ bytes: [UInt8], at offset: Int) -> UInt32 {
var value: UInt32 = 0
for index in 0..<4 { value = value << 8 | UInt32(bytes[offset + index]) }
return value
}
private static func readU64(_ bytes: [UInt8], at offset: Int) -> UInt64 {
var value: UInt64 = 0
for index in 0..<8 { value = value << 8 | UInt64(bytes[offset + index]) }
return value
}
private static func appendBE(_ data: inout Data, _ value: UInt16) {
data.append(UInt8(truncatingIfNeeded: value >> 8))
data.append(UInt8(truncatingIfNeeded: value))
}
private static func appendBE(_ data: inout Data, _ value: UInt32) {
for shift in stride(from: 24, through: 0, by: -8) {
data.append(UInt8(truncatingIfNeeded: value >> UInt32(shift)))
}
}
private static func appendBE(_ data: inout Data, _ value: UInt64) {
for shift in stride(from: 56, through: 0, by: -8) {
data.append(UInt8(truncatingIfNeeded: value >> UInt64(shift)))
}
}
}
+136
View File
@@ -0,0 +1,136 @@
import Foundation
import CoreGraphics
/// 光学扫描的 ROI 状态机(纯几何,不依赖 AVFoundation/Vision,可在 macOS 上单测)。
///
/// 为什么要锁 ROI:电脑屏幕上是**一个大二维码**在按 30~60 FPS 换帧,
/// 相机每帧都做全画面 finder 搜索既慢又抖。锁定之后只把候选区域交给解码器,
/// 单帧解码时间显著下降,真正决定传输速度的「有效新帧/s」才提得上去。
///
/// 坐标系与 Vision 的 `regionOfInterest` 一致:归一化到 [0,1],**原点在左下**。
struct OpticalROI: Equatable {
/// 全画面搜索时使用的居中比例。留一点边,避免把屏幕边框也算进来。
static let searchFraction: CGFloat = 0.92
/// 从条码 boundingBox 放大到含静区的锁定框
static let lockPadding: CGFloat = 1.22
/// 平滑跟随系数:太大跟着噪声抖,太小跟不上手抖
static let smoothing: CGFloat = 0.35
/// 连续丢失多少帧后开始逐级放大
static let missesBeforeExpand = 3
/// 连续丢失多少帧后彻底放弃锁定,回到全画面搜索
static let missesBeforeReacquire = 12
enum State: Equatable {
case searching
case locked
case missing(Int) // 已连续丢失的帧数
}
/// 画面宽高比(宽 / 高)。用来把归一化矩形按像素比例修成正方形。
let aspect: CGFloat
private(set) var state: State = .searching
private(set) var region: CGRect
init(aspect: CGFloat = 4.0 / 3.0) {
self.aspect = aspect > 0 ? aspect : 1
self.region = Self.centeredSearch(fraction: Self.searchFraction)
}
/// 本帧实际应该交给解码器的区域。
var decodeRegion: CGRect { region }
var isLocked: Bool {
if case .locked = state { return true }
return false
}
/// 一帧解码成功,`boundingBox` 是 Vision 给出的条码归一化外接框。
mutating func hit(boundingBox: CGRect) {
let target = Self.squared(Self.padded(boundingBox, by: Self.lockPadding), aspect: aspect)
.clampedToUnitSquare()
guard target.width > 0.02, target.height > 0.02 else { return }
switch state {
case .searching:
region = target
case .locked, .missing:
region = Self.smooth(region, toward: target, alpha: Self.smoothing)
}
state = .locked
}
/// 一帧没解出来。连续丢失会先放大 ROI,再彻底重新搜索。
mutating func miss() {
switch state {
case .searching:
return
case .locked:
state = .missing(1)
case .missing(let count):
let next = count + 1
if next >= Self.missesBeforeReacquire {
state = .searching
region = Self.centeredSearch(fraction: Self.searchFraction)
return
}
state = .missing(next)
if next >= Self.missesBeforeExpand {
region = Self.expand(region, by: 1.25).clampedToUnitSquare()
}
}
}
mutating func reset() {
state = .searching
region = Self.centeredSearch(fraction: Self.searchFraction)
}
// MARK: - 几何
static func centeredSearch(fraction: CGFloat) -> CGRect {
let f = min(max(fraction, 0.5), 1)
return CGRect(x: (1 - f) / 2, y: (1 - f) / 2, width: f, height: f)
}
static func padded(_ rect: CGRect, by factor: CGFloat) -> CGRect {
expand(rect, by: factor)
}
static func expand(_ rect: CGRect, by factor: CGFloat) -> CGRect {
let f = max(factor, 1)
let width = rect.width * f
let height = rect.height * f
return CGRect(x: rect.midX - width / 2, y: rect.midY - height / 2,
width: width, height: height)
}
/// 把归一化矩形修成**像素意义上的正方形**:二维码是方的,
/// 而归一化坐标在非 1:1 的画面上会把它拉扁。
static func squared(_ rect: CGRect, aspect: CGFloat) -> CGRect {
// 像素边长:宽方向乘以 aspect 才能与高方向比较
let pixelSide = max(rect.width * aspect, rect.height)
let width = pixelSide / aspect
let height = pixelSide
return CGRect(x: rect.midX - width / 2, y: rect.midY - height / 2,
width: width, height: height)
}
static func smooth(_ current: CGRect, toward target: CGRect, alpha: CGFloat) -> CGRect {
let a = min(max(alpha, 0), 1)
func mix(_ x: CGFloat, _ y: CGFloat) -> CGFloat { x + (y - x) * a }
return CGRect(x: mix(current.minX, target.minX), y: mix(current.minY, target.minY),
width: mix(current.width, target.width), height: mix(current.height, target.height))
}
}
extension CGRect {
/// 夹到 [0,1]×[0,1],并保证仍是非空矩形。Vision 对越界的
/// `regionOfInterest` 会直接报错,不能让噪声把它推出画面。
func clampedToUnitSquare() -> CGRect {
let width = Swift.min(Swift.max(self.width, 0.02), 1)
let height = Swift.min(Swift.max(self.height, 0.02), 1)
let x = Swift.min(Swift.max(minX, 0), 1 - width)
let y = Swift.min(Swift.max(minY, 0), 1 - height)
return CGRect(x: x, y: y, width: width, height: height)
}
}
+9 -3
View File
@@ -28,6 +28,11 @@ struct PairingPayload: Equatable {
/// 二维码是**不可信输入**:它决定了 App 接下来去连哪个地址。因此这里只接受 /// 二维码是**不可信输入**:它决定了 App 接下来去连哪个地址。因此这里只接受
/// 字面量私有 IPv4 + 二维码自称的端口,任何域名、公网地址、带 query/fragment /// 字面量私有 IPv4 + 二维码自称的端口,任何域名、公网地址、带 query/fragment
/// 的 URL 一律拒绝——与 Windows/Android 两端的校验保持一致。 /// 的 URL 一律拒绝——与 Windows/Android 两端的校验保持一致。
///
/// 两种形态都要支持:
/// - **局域网**:`e` 里带一到多个 `http://<私有 IPv4>:<port>`,`w` 为空;
/// - **专用网络**:`e` 为空、`w` 带 SSID/密码,手机加入那张 Wi-Fi 后
/// 从路由表读网关(Windows 的 QFT Direct 走这条)。
enum PairingProtocol { enum PairingProtocol {
static let prefixUpload = "QFTPAIR2:" static let prefixUpload = "QFTPAIR2:"
@@ -80,9 +85,10 @@ enum PairingProtocol {
} }
} }
} }
// iOS 无法用代码加入指定 Wi-Fi(NEHotspotConfiguration 需要付费账号的 // 专用网络(Windows 的 QFT Direct)二维码按设计不携带任何电脑地址:
// entitlement),所以 Direct-AP 二维码在本端必须自带可用 endpoint。 // 手机必须先加入 `w` 里的那张 Wi-Fi,再从路由表读网关。因此
if endpoints.isEmpty { return nil } // 「没有 endpoint」只有在带 Wi-Fi 凭据时才是合法的。
if endpoints.isEmpty && wifi == nil { return nil }
var fileName: String? var fileName: String?
var fileSize: UInt64? var fileSize: UInt64?
+181
View File
@@ -0,0 +1,181 @@
import Foundation
/// 局域网里发现的一台电脑。
struct DesktopPeer: Equatable, Identifiable {
let name: String
let platform: String // windows / macos / linux
let address: String // 私有 IPv4 字面量
let port: Int
let ready: Bool // 对方是否正在「等待接收」
var id: String { "\(address):\(port)" }
var baseURL: String { "http://\(address):\(port)" }
var platformLabel: String {
switch platform {
case "macos": return "macOS"
case "windows": return "Windows"
case "linux": return "Linux"
default: return platform.isEmpty ? "电脑" : platform
}
}
}
/// `QFTBROWSE3` 节点浏览(`desktop/src/discovery.rs` 的客户端实现)。
///
/// 与 `QFTDISC2` 的区别:那个是「我已经有令牌了,帮我找到那台机器」,
/// 用在扫码之后;这个不带令牌,用来先**列出附近有哪些电脑**——
/// iPhone 与 Mac 互传时没有二维码可扫,必须先能看见对方。
///
/// 局限与桌面端相同:UDP 广播只覆盖同一广播域。跨网段或开了 AP 隔离的
/// Wi-Fi 上发现不到对方,此时改用连接码(地址就编在码里)。
enum PeerBrowser {
static let query = "QFTBROWSE3"
static let replyPrefix = "QFTNODE3:"
static let port: UInt16 = 39392
/// 广播一次并收集应答。iOS 首次调用会触发「本地网络」权限弹窗。
static func browse(timeout: TimeInterval = 1.5) async -> [DesktopPeer] {
await withCheckedContinuation { continuation in
DispatchQueue.global(qos: .userInitiated).async {
continuation.resume(returning: blockingBrowse(timeout: timeout))
}
}
}
static func blockingBrowse(timeout: TimeInterval) -> [DesktopPeer] {
let fd = socket(AF_INET, SOCK_DGRAM, 0)
guard fd >= 0 else { return [] }
defer { close(fd) }
var enable: Int32 = 1
setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &enable, socklen_t(MemoryLayout<Int32>.size))
// 单次 recv 的超时要远小于总时长,否则一台都没有时会干等满
var tv = timeval(tv_sec: 0, tv_usec: 200_000)
setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, socklen_t(MemoryLayout<timeval>.size))
var targets = ["255.255.255.255"]
// 部分 Wi-Fi 驱动会丢弃受限广播,定向广播能过——与桌面端同样的兜底
for broadcast in LocalNetwork.directedBroadcastAddresses() where !targets.contains(broadcast) {
targets.insert(broadcast, at: 0)
}
let payload = Data(query.utf8)
for target in targets {
var address = sockaddr_in()
address.sin_family = sa_family_t(AF_INET)
address.sin_port = port.bigEndian
address.sin_addr.s_addr = inet_addr(target)
_ = payload.withUnsafeBytes { buffer -> Int in
withUnsafePointer(to: &address) { pointer in
pointer.withMemoryRebound(to: sockaddr.self, capacity: 1) { sockPointer in
sendto(fd, buffer.baseAddress, buffer.count, 0,
sockPointer, socklen_t(MemoryLayout<sockaddr_in>.size))
}
}
}
}
var found: [String: DesktopPeer] = [:]
let deadline = Date().addingTimeInterval(timeout)
var buffer = [UInt8](repeating: 0, count: 1024)
while Date() < deadline {
var from = sockaddr_in()
var fromLength = socklen_t(MemoryLayout<sockaddr_in>.size)
let received = withUnsafeMutablePointer(to: &from) { pointer -> Int in
pointer.withMemoryRebound(to: sockaddr.self, capacity: 1) { sockPointer in
recvfrom(fd, &buffer, buffer.count, 0, sockPointer, &fromLength)
}
}
if received <= 0 { continue }
var raw = from.sin_addr
var host = [CChar](repeating: 0, count: Int(INET_ADDRSTRLEN))
guard inet_ntop(AF_INET, &raw, &host, socklen_t(INET_ADDRSTRLEN)) != nil else { continue }
let source = String(cString: host)
guard let text = String(bytes: buffer[0..<received], encoding: .utf8),
let peer = parseReply(text, source: source) else { continue }
found[peer.id] = peer
}
// 正在等待接收的排前面,其次按名字,保证列表顺序稳定不跳动
return found.values.sorted { lhs, rhs in
if lhs.ready != rhs.ready { return lhs.ready }
if lhs.name != rhs.name { return lhs.name < rhs.name }
return lhs.address < rhs.address
}
}
/// 应答来自网络,是不可信输入:地址只认私有 IPv4,名字要去掉控制字符。
static func parseReply(_ text: String, source: String) -> DesktopPeer? {
guard text.hasPrefix(replyPrefix), text.count <= 1024 else { return nil }
guard PairingProtocol.isPrivateIPv4(source) else { return nil }
let json = String(text.dropFirst(replyPrefix.count))
guard let object = try? JSONSerialization.jsonObject(with: Data(json.utf8)) as? [String: Any],
let rawPort = object["t"] as? NSNumber else { return nil }
let port = rawPort.intValue
guard (1...65535).contains(port) else { return nil }
let rawName = (object["n"] as? String) ?? "电脑"
let name = String(String(String.UnicodeScalarView(
rawName.unicodeScalars.filter { $0.value > 31 && $0.value != 127 }
)).trimmingCharacters(in: .whitespaces).prefix(64))
let platform = String((object["p"] as? String ?? "")
.filter { $0.isASCII && $0.isLetter || $0.isNumber }.prefix(16))
return DesktopPeer(name: name.isEmpty ? "电脑" : name,
platform: platform,
address: source,
port: port,
ready: (object["r"] as? Bool) ?? false)
}
}
/// 用连接码里的 6 位十六进制秘密换取会话令牌(`POST /qft/pair`)。
///
/// 这是桌面端唯一不校验令牌的端点——它的作用正是换取令牌。
/// 桌面端错 5 次就作废整个码,所以这里绝不重试。
enum DesktopPairing {
static func pair(baseURL: String, code: String, deviceName: String,
timeout: TimeInterval = 6) async throws -> String {
guard let url = URL(string: baseURL + "/qft/pair") else {
throw QFTError.malformedResponse("配对地址无效")
}
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.timeoutInterval = timeout
request.setValue(code, forHTTPHeaderField: "X-QFT-Code")
request.setValue(Base64URL.encode(deviceName), forHTTPHeaderField: "X-QFT-Device")
request.setValue("0", forHTTPHeaderField: "Content-Length")
let configuration = URLSessionConfiguration.ephemeral
configuration.timeoutIntervalForRequest = timeout
configuration.waitsForConnectivity = false
let session = URLSession(configuration: configuration)
defer { session.finishTasksAndInvalidate() }
let (data, response) = try await session.upload(for: request, from: Data())
guard let http = response as? HTTPURLResponse else {
throw QFTError.malformedResponse("非 HTTP 响应")
}
let object = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any] ?? [:]
switch http.statusCode {
case 200:
guard let token = object["token"] as? String,
PairingProtocol.isValidSession(token) else {
throw QFTError.malformedResponse("配对响应缺少可用令牌")
}
return token
case 403:
let remaining = (object["remaining"] as? NSNumber)?.intValue ?? 0
throw QFTError.httpStatus(403, "连接码不对,还可尝试 \(remaining) 次")
case 429:
throw QFTError.httpStatus(429, "连接码已作废,请让电脑重新启动接收")
default:
throw QFTError.httpStatus(http.statusCode, "")
}
}
}
+206 -109
View File
@@ -5,10 +5,11 @@ import CryptoKit
/// 点对点链路:Bonjour 发现 + TLS-PSK 加密 + 长度前缀分帧。 /// 点对点链路:Bonjour 发现 + TLS-PSK 加密 + 长度前缀分帧。
/// ///
/// `includePeerToPeer = true` 让 Network.framework 在没有路由器时 /// `includePeerToPeer = true` 让 Network.framework 在没有路由器时
/// 自动使用 BLE 发现 + AWDL 点对点 Wi-Fi,也就是 AirDrop 用的同一条链路。 /// 自动使用 BLE 发现 + AWDL 点对点 Wi-Fi,也就是隔空投送用的同一条链路。
/// 两台设备在同一个 Wi-Fi 下时它会优先走基础网络,速度同样很快。 /// 两台设备在同一个 Wi-Fi 下时它会优先走基础网络,速度同样很快。
/// ///
/// AWDL 是苹果私有链路,Windows 无法参与——PC 方向仍走 HTTP 局域网路径。 /// AWDL 是苹果私有链路,Windows 无法参与——PC 方向仍走 HTTP
/// 局域网/专用网络路径。
enum PeerLink { enum PeerLink {
static let frameHeaderSize = 5 // 1 字节类型 + 4 字节 BE 长度 static let frameHeaderSize = 5 // 1 字节类型 + 4 字节 BE 长度
@@ -16,10 +17,13 @@ enum PeerLink {
static let maxFrameSize = 4 * 1024 * 1024 static let maxFrameSize = 4 * 1024 * 1024
enum FrameType: UInt8 { enum FrameType: UInt8 {
case manifest = 1 /// 文件清单(JSON)。整个队列只发一次,摘要必须与二维码一致。
case queue = 1
case data = 2 case data = 2
case eof = 3 case eof = 3
case result = 4 case result = 4
case fileBegin = 5
case fileEnd = 6
} }
enum PeerError: LocalizedError { enum PeerError: LocalizedError {
@@ -80,14 +84,22 @@ enum PeerLink {
} }
} }
static func sendJSON(_ connection: NWConnection, type: FrameType,
object: [String: Any]) async throws {
let data = try JSONSerialization.data(withJSONObject: object)
try await send(connection, type: type, payload: data)
}
static func receiveFrame(_ connection: NWConnection) async throws -> (FrameType, Data) { static func receiveFrame(_ connection: NWConnection) async throws -> (FrameType, Data) {
let header = try await receiveExactly(connection, count: frameHeaderSize) let header = try await receiveExactly(connection, count: frameHeaderSize)
guard let type = FrameType(rawValue: header[header.startIndex]) else { guard let type = FrameType(rawValue: header[header.startIndex]) else {
throw PeerError.protocolViolation("未知帧类型 \(header[header.startIndex])") throw PeerError.protocolViolation("未知帧类型 \(header[header.startIndex])")
} }
let length = header[(header.startIndex + 1)...].withUnsafeBytes { // 手工拼大端,不用 loadUnaligned:那个 API 要 Swift 5.7 运行时(iOS 16),
UInt32(bigEndian: $0.loadUnaligned(as: UInt32.self)) // 而这个 App 要一直支持到 iOS 15
} let bytes = [UInt8](header)
let length = (UInt32(bytes[1]) << 24) | (UInt32(bytes[2]) << 16)
| (UInt32(bytes[3]) << 8) | UInt32(bytes[4])
guard length <= UInt32(maxFrameSize) else { guard length <= UInt32(maxFrameSize) else {
throw PeerError.protocolViolation("帧长度 \(length) 超出上限") throw PeerError.protocolViolation("帧长度 \(length) 超出上限")
} }
@@ -122,7 +134,7 @@ enum PeerLink {
timeout: TimeInterval = 15) async throws { timeout: TimeInterval = 15) async throws {
try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
let resumed = Locked(false) let resumed = Locked(false)
func finish(_ error: Error?) { @Sendable func finish(_ error: Error?) {
guard resumed.exchange(true) == false else { return } guard resumed.exchange(true) == false else { return }
if let error { continuation.resume(throwing: error) } else { continuation.resume() } if let error { continuation.resume(throwing: error) } else { continuation.resume() }
} }
@@ -154,7 +166,7 @@ enum PeerLink {
/// 极简互斥包装。continuation 只能 resume 一次,而 stateUpdateHandler /// 极简互斥包装。continuation 只能 resume 一次,而 stateUpdateHandler
/// 可能在多个状态里触发,需要一个原子的「是否已 resume」。 /// 可能在多个状态里触发,需要一个原子的「是否已 resume」。
final class Locked<Value> { final class Locked<Value>: @unchecked Sendable {
private var value: Value private var value: Value
private let lock = NSLock() private let lock = NSLock()
@@ -173,14 +185,22 @@ final class Locked<Value> {
} }
} }
/// 队列传输的进度:既要有总进度,也要说明当前在传第几个文件。
struct PeerTransferUpdate {
let progress: TransferProgress
let fileIndex: Int
let fileCount: Int
let fileName: String
}
// MARK: - 发送端 // MARK: - 发送端
/// 展示二维码的一方。持有文件,等待对方扫码后连入。 /// 展示二维码的一方。持有一个文件队列,等待对方扫码后连入。
final class PeerSender { final class PeerSender {
/// 监听器的状态与排队中的连接。stateUpdateHandler / newConnectionHandler /// 监听器的状态与排队中的连接。stateUpdateHandler / newConnectionHandler
/// 在任意线程触发,而等待方是 async,所以两边都要经过这把锁。 /// 在任意线程触发,而等待方是 async,所以两边都要经过这把锁。
private final class Box { private final class Box: @unchecked Sendable {
let lock = NSLock() let lock = NSLock()
var readyPort: UInt16? var readyPort: UInt16?
var failure: Error? var failure: Error?
@@ -197,15 +217,17 @@ final class PeerSender {
} }
} }
private let fileURL: URL private let fileURLs: [URL]
private let deviceName: String private let deviceName: String
private let queue = DispatchQueue(label: "qft.peer.sender") private let queue = DispatchQueue(label: "qft.peer.sender")
private let box = Box() private let box = Box()
private var listener: NWListener? private var listener: NWListener?
private var pairing: PeerPairing? private var pairing: PeerPairing?
private var files: [PeerFileMeta] = []
private var queuePayload = Data()
init(fileURL: URL, deviceName: String) { init(fileURLs: [URL], deviceName: String) {
self.fileURL = fileURL self.fileURLs = fileURLs
self.deviceName = deviceName self.deviceName = deviceName
} }
@@ -225,27 +247,46 @@ final class PeerSender {
} }
} }
/// 计算文件摘要、启动监听并广播 Bonjour 服务,返回要显示成二维码的配对码。 /// 逐个算摘要、启动监听并广播 Bonjour 服务,返回要显示成二维码的配对码。
/// 会完整读一遍每个文件,调用方应放到后台线程。
func start() throws -> PeerPairing { func start() throws -> PeerPairing {
let attributes = try FileManager.default.attributesOfItem(atPath: fileURL.path) guard !fileURLs.isEmpty else {
let size = UInt64(truncating: (attributes[.size] as? NSNumber) ?? 0) throw PeerLink.PeerError.protocolViolation("没有选择任何文件")
var hasher = SHA256()
let handle = try FileHandle(forReadingFrom: fileURL)
while let block = try handle.read(upToCount: 4 * 1024 * 1024), !block.isEmpty {
hasher.update(data: block)
} }
try handle.close()
let digest = hasher.finalize().map { String(format: "%02x", $0) }.joined()
var metas: [PeerFileMeta] = []
var total: UInt64 = 0
for url in fileURLs {
let attributes = try FileManager.default.attributesOfItem(atPath: url.path)
let size = UInt64(truncating: (attributes[.size] as? NSNumber) ?? 0)
var hasher = SHA256()
let handle = try FileHandle(forReadingFrom: url)
var read: UInt64 = 0
while let block = try handle.read(upToCount: 4 * 1024 * 1024), !block.isEmpty {
hasher.update(data: block)
read &+= UInt64(block.count)
}
try handle.close()
// 文件选择器报告的大小偶尔会和实际内容对不上(iCloud 占位文件、
// 正在被其他 App 写入)。以实读为准,否则二维码里的总量是假的。
let digest = hasher.finalize().map { String(format: "%02x", $0) }.joined()
let name = OpticalProtocol.sanitizeFileName(url.lastPathComponent)
metas.append(PeerFileMeta(name: name, size: read, sha256: digest))
total &+= read
_ = size
}
let payload = try PeerQueue.encode(sender: deviceName, files: metas)
let pairing = PeerPairing( let pairing = PeerPairing(
version: 1, version: 2,
key: PeerPairing.newKey(), key: PeerPairing.newKey(),
instance: PeerPairing.newInstance(), instance: PeerPairing.newInstance(),
senderName: deviceName, senderName: deviceName,
fileName: fileURL.lastPathComponent, fileCount: metas.count,
fileSize: size, totalSize: total,
sha256: digest) queueDigest: PeerQueue.digest(of: payload),
previewName: metas[0].name)
let parameters = PeerLink.parameters(key: pairing.key, identity: pairing.instance) let parameters = PeerLink.parameters(key: pairing.key, identity: pairing.instance)
let listener = try NWListener(using: parameters) let listener = try NWListener(using: parameters)
@@ -290,11 +331,13 @@ final class PeerSender {
self.listener = listener self.listener = listener
self.pairing = pairing self.pairing = pairing
self.files = metas
self.queuePayload = payload
return pairing return pairing
} }
/// 等待一个连接并把文件推过去。 /// 等待一个连接并把整个队列推过去。
func waitAndSend(onProgress: @escaping (TransferProgress) -> Void) async throws { func waitAndSend(onProgress: @escaping (PeerTransferUpdate) -> Void) async throws {
guard let listener, let pairing else { guard let listener, let pairing else {
throw PeerLink.PeerError.handshake("尚未调用 start()") throw PeerLink.PeerError.handshake("尚未调用 start()")
} }
@@ -320,34 +363,44 @@ final class PeerSender {
defer { connection.cancel(); listener.cancel() } defer { connection.cancel(); listener.cancel() }
try await PeerLink.waitReady(connection, queue: queue) try await PeerLink.waitReady(connection, queue: queue)
try await PeerLink.send(connection, type: .queue, payload: queuePayload)
let manifest: [String: Any] = [
"name": pairing.fileName,
"size": NSNumber(value: pairing.fileSize),
"sha256": pairing.sha256,
"sender": pairing.senderName,
]
try await PeerLink.send(connection, type: .manifest,
payload: try JSONSerialization.data(withJSONObject: manifest))
let handle = try FileHandle(forReadingFrom: fileURL)
defer { try? handle.close() }
var sent: UInt64 = 0 var sent: UInt64 = 0
let startedAt = Date() let startedAt = Date()
var lastReport = Date.distantPast var lastReport = Date.distantPast
while let block = try handle.read(upToCount: PeerLink.chunkSize), !block.isEmpty { for (index, meta) in files.enumerated() {
try Task.checkCancellation() try Task.checkCancellation()
try await PeerLink.send(connection, type: .data, payload: block) try await PeerLink.sendJSON(connection, type: .fileBegin,
sent &+= UInt64(block.count) object: ["i": index, "name": meta.name])
let now = Date()
if now.timeIntervalSince(lastReport) > 0.1 || sent >= pairing.fileSize { let handle = try FileHandle(forReadingFrom: fileURLs[index])
lastReport = now defer { try? handle.close() }
onProgress(TransferProgress( var fileSent: UInt64 = 0
completed: sent, total: pairing.fileSize, while let block = try handle.read(upToCount: PeerLink.chunkSize), !block.isEmpty {
bytesPerSecond: Double(sent) / max(0.001, now.timeIntervalSince(startedAt)))) try Task.checkCancellation()
guard fileSent &+ UInt64(block.count) <= meta.size else {
throw PeerLink.PeerError.protocolViolation("本地文件 \(meta.name) 在传输中变大了")
}
try await PeerLink.send(connection, type: .data, payload: block)
fileSent &+= UInt64(block.count)
sent &+= UInt64(block.count)
let now = Date()
if now.timeIntervalSince(lastReport) > 0.1 || sent >= pairing.totalSize {
lastReport = now
onProgress(PeerTransferUpdate(
progress: TransferProgress(
completed: sent, total: pairing.totalSize,
bytesPerSecond: Double(sent) / max(0.001, now.timeIntervalSince(startedAt))),
fileIndex: index, fileCount: files.count, fileName: meta.name))
}
} }
guard fileSent == meta.size else {
throw PeerLink.PeerError.protocolViolation("本地文件 \(meta.name) 只读到 \(fileSent)/\(meta.size) 字节")
}
try await PeerLink.sendJSON(connection, type: .fileEnd, object: ["i": index])
} }
try await PeerLink.send(connection, type: .eof, payload: Data()) try await PeerLink.send(connection, type: .eof, payload: Data())
let (type, payload) = try await PeerLink.receiveFrame(connection) let (type, payload) = try await PeerLink.receiveFrame(connection)
@@ -368,7 +421,7 @@ final class PeerSender {
// MARK: - 接收端 // MARK: - 接收端
/// 扫码的一方。按实例名找到对端并接收文件。 /// 扫码的一方。按实例名找到对端并按顺序接收整个队列。
struct PeerReceiver { struct PeerReceiver {
let pairing: PeerPairing let pairing: PeerPairing
@@ -376,7 +429,7 @@ struct PeerReceiver {
/// 测试用:跳过 Bonjour,直接连指定端口。 /// 测试用:跳过 Bonjour,直接连指定端口。
var directPort: UInt16? var directPort: UInt16?
func run(onProgress: @escaping (TransferProgress) -> Void) async throws -> URL { func run(onProgress: @escaping (PeerTransferUpdate) -> Void) async throws -> [URL] {
let queue = DispatchQueue(label: "qft.peer.receiver") let queue = DispatchQueue(label: "qft.peer.receiver")
let parameters = PeerLink.parameters(key: pairing.key, identity: pairing.instance) let parameters = PeerLink.parameters(key: pairing.key, identity: pairing.instance)
@@ -392,78 +445,122 @@ struct PeerReceiver {
defer { connection.cancel() } defer { connection.cancel() }
try await PeerLink.waitReady(connection, queue: queue) try await PeerLink.waitReady(connection, queue: queue)
// --- 清单 --- do {
let (manifestType, manifestPayload) = try await PeerLink.receiveFrame(connection) let saved = try await receiveQueue(connection, onProgress: onProgress)
guard manifestType == .manifest, try await PeerLink.sendJSON(connection, type: .result,
let manifest = try? JSONSerialization.jsonObject(with: manifestPayload) as? [String: Any], object: ["ok": true, "saved": saved.map(\.lastPathComponent)])
let declaredSize = (manifest["size"] as? NSNumber)?.uint64Value, return saved
let declaredHash = manifest["sha256"] as? String else { } catch {
throw PeerLink.PeerError.protocolViolation("清单帧无效") // 让发送端知道为什么停了,而不是收到一个无解释的断连
try? await PeerLink.sendJSON(connection, type: .result,
object: ["ok": false, "error": errorText(error)])
throw error
} }
// 清单必须与二维码一致,否则说明连到的不是扫码时看到的那个文件 }
guard declaredSize == pairing.fileSize, declaredHash == pairing.sha256 else {
try? await PeerLink.send(connection, type: .result, payload: Data( private func receiveQueue(_ connection: NWConnection,
#"{"ok":false,"error":"manifest mismatch"}"#.utf8)) onProgress: @escaping (PeerTransferUpdate) -> Void) async throws -> [URL] {
throw PeerLink.PeerError.protocolViolation("对方声明的文件与二维码不符") // --- 清单 ---
let (queueType, queuePayload) = try await PeerLink.receiveFrame(connection)
guard queueType == .queue else {
throw PeerLink.PeerError.protocolViolation("首帧不是文件清单")
}
// 摘要对着二维码算:扫码看到的是几个文件、多大,收到的就必须是那些
guard PeerQueue.digest(of: queuePayload) == pairing.queueDigest else {
throw PeerLink.PeerError.protocolViolation("文件清单与二维码不符")
}
guard let (_, files) = PeerQueue.decode(queuePayload) else {
throw PeerLink.PeerError.protocolViolation("文件清单无法解析")
}
guard files.count == pairing.fileCount,
files.reduce(UInt64(0), { $0 &+ $1.size }) == pairing.totalSize else {
throw PeerLink.PeerError.protocolViolation("文件清单的数量或总量与二维码不符")
} }
try FileManager.default.createDirectory(at: destinationDirectory, try FileManager.default.createDirectory(at: destinationDirectory,
withIntermediateDirectories: true) withIntermediateDirectories: true)
let partURL = destinationDirectory.appendingPathComponent(pairing.fileName + ".qftpart")
try? FileManager.default.removeItem(at: partURL)
FileManager.default.createFile(atPath: partURL.path, contents: nil)
let handle = try FileHandle(forWritingTo: partURL)
var hasher = SHA256() var saved: [URL] = []
var received: UInt64 = 0 var receivedTotal: UInt64 = 0
let startedAt = Date() let startedAt = Date()
var lastReport = Date.distantPast var lastReport = Date.distantPast
// --- 数据 --- for (index, meta) in files.enumerated() {
do { try Task.checkCancellation()
loop: while true { let (beginType, beginPayload) = try await PeerLink.receiveFrame(connection)
try Task.checkCancellation() guard beginType == .fileBegin,
let (type, payload) = try await PeerLink.receiveFrame(connection) let begin = try? JSONSerialization.jsonObject(with: beginPayload) as? [String: Any],
switch type { (begin["i"] as? Int) == index else {
case .data: throw PeerLink.PeerError.protocolViolation("第 \(index + 1) 个文件的起始帧无效")
guard received &+ UInt64(payload.count) <= pairing.fileSize else {
throw PeerLink.PeerError.protocolViolation("收到的数据超出声明大小")
}
try handle.write(contentsOf: payload)
hasher.update(data: payload)
received &+= UInt64(payload.count)
let now = Date()
if now.timeIntervalSince(lastReport) > 0.1 || received >= pairing.fileSize {
lastReport = now
onProgress(TransferProgress(
completed: received, total: pairing.fileSize,
bytesPerSecond: Double(received) / max(0.001, now.timeIntervalSince(startedAt))))
}
case .eof:
break loop
default:
throw PeerLink.PeerError.protocolViolation("数据阶段收到 \(type)")
}
} }
try handle.close()
} catch { let partURL = destinationDirectory.appendingPathComponent(meta.name + ".qftpart")
try? handle.close()
try? FileManager.default.removeItem(at: partURL) try? FileManager.default.removeItem(at: partURL)
throw error guard FileManager.default.createFile(atPath: partURL.path, contents: nil) else {
throw QFTError.malformedResponse("无法创建临时文件")
}
let handle = try FileHandle(forWritingTo: partURL)
var hasher = SHA256()
var received: UInt64 = 0
do {
loop: while true {
try Task.checkCancellation()
let (type, payload) = try await PeerLink.receiveFrame(connection)
switch type {
case .data:
guard received &+ UInt64(payload.count) <= meta.size else {
throw PeerLink.PeerError.protocolViolation("\(meta.name) 的数据超出声明大小")
}
try handle.write(contentsOf: payload)
hasher.update(data: payload)
received &+= UInt64(payload.count)
receivedTotal &+= UInt64(payload.count)
let now = Date()
if now.timeIntervalSince(lastReport) > 0.1 || receivedTotal >= pairing.totalSize {
lastReport = now
onProgress(PeerTransferUpdate(
progress: TransferProgress(
completed: receivedTotal, total: pairing.totalSize,
bytesPerSecond: Double(receivedTotal)
/ max(0.001, now.timeIntervalSince(startedAt))),
fileIndex: index, fileCount: files.count, fileName: meta.name))
}
case .fileEnd:
break loop
default:
throw PeerLink.PeerError.protocolViolation("数据阶段收到 \(type)")
}
}
try handle.close()
} catch {
try? handle.close()
try? FileManager.default.removeItem(at: partURL)
saved.forEach { try? FileManager.default.removeItem(at: $0) }
throw error
}
let actual = hasher.finalize().map { String(format: "%02x", $0) }.joined()
guard received == meta.size, actual == meta.sha256 else {
try? FileManager.default.removeItem(at: partURL)
saved.forEach { try? FileManager.default.removeItem(at: $0) }
throw QFTError.integrity(
"\(meta.name):收到 \(received)/\(meta.size) 字节,SHA-256 \(actual == meta.sha256 ? "一致" : "不一致")")
}
let finalURL = DownloadClient.uniqueURL(in: destinationDirectory, name: meta.name)
try FileManager.default.moveItem(at: partURL, to: finalURL)
saved.append(finalURL)
} }
// --- 校验 --- let (eofType, _) = try await PeerLink.receiveFrame(connection)
let actual = hasher.finalize().map { String(format: "%02x", $0) }.joined() guard eofType == .eof else {
guard received == pairing.fileSize, actual == pairing.sha256 else { throw PeerLink.PeerError.protocolViolation("队列结束帧无效")
try? FileManager.default.removeItem(at: partURL)
try? await PeerLink.send(connection, type: .result, payload: Data(
#"{"ok":false,"error":"integrity"}"#.utf8))
throw QFTError.integrity("收到 \(received)/\(pairing.fileSize) 字节,SHA-256 \(actual == pairing.sha256 ? "一致" : "不一致")")
} }
return saved
}
let finalURL = DownloadClient.uniqueURL(in: destinationDirectory, name: pairing.fileName) private func errorText(_ error: Error) -> String {
try FileManager.default.moveItem(at: partURL, to: finalURL) String(((error as? LocalizedError)?.errorDescription ?? "\(error)").prefix(200))
try await PeerLink.send(connection, type: .result, payload: Data(#"{"ok":true}"#.utf8))
return finalURL
} }
} }
+84 -21
View File
@@ -1,14 +1,41 @@
import Foundation import Foundation
import CryptoKit
import Security import Security
/// 隔空投送式点对点配对码。 /// 队列里的一个文件。
struct PeerFileMeta: Equatable {
let name: String
let size: UInt64
let sha256: String
var json: [String: Any] {
["name": name, "size": NSNumber(value: size), "sha256": sha256]
}
static func parse(_ object: [String: Any]) -> PeerFileMeta? {
guard let rawName = (object["name"] as? String)?.trimmingCharacters(in: .whitespaces),
PairingProtocol.isValidFileName(rawName),
!rawName.hasPrefix("."),
let size = (object["size"] as? NSNumber)?.uint64Value,
let hash = (object["sha256"] as? String)?.lowercased(),
PairingProtocol.isValidSHA256(hash) else { return nil }
return PeerFileMeta(name: rawName, size: size, sha256: hash)
}
}
/// 隔空投送式点对点配对码(QFTP2P2)。
/// ///
/// 与 QFTPAIR2/QFTSEND2 的关键区别:那两个是「连到某个 IP」, /// 与 QFTPAIR2/QFTSEND2 的关键区别:那两个是「连到某个 IP」,
/// 这个是「连到某个 Bonjour 服务实例,并用二维码里的预共享密钥做 TLS 认证」。 /// 这个是「连到某个 Bonjour 服务实例,并用二维码里的预共享密钥做 TLS 认证」。
/// 二维码在这里充当带外信道——和 AirDrop 用 BLE 交换身份是同一个作用, /// 二维码在这里充当带外信道——和隔空投送用 BLE 交换身份是同一个作用,
/// 只是我们把身份交换搬到了用户可见的扫码动作上,不需要任何配对弹窗。 /// 只是我们把身份交换搬到了用户可见的扫码动作上,不需要任何配对弹窗。
///
/// 多文件时**文件清单不进二维码**,只放一个 SHA-256 摘要:
/// 十几个文件的元数据会让二维码密到扫不动。清单在 TLS 建立之后才传,
/// 接收端拿摘要比对——扫码这一下依然锁定了「你看到的就是你收到的」。
struct PeerPairing: Equatable { struct PeerPairing: Equatable {
static let prefix = "QFTP2P1:" static let prefix = "QFTP2P2:"
static let serviceType = "_qft-p2p._tcp"
let version: Int let version: Int
/// 32 字节预共享密钥。既是 TLS-PSK,也是服务实例的唯一凭据。 /// 32 字节预共享密钥。既是 TLS-PSK,也是服务实例的唯一凭据。
@@ -16,11 +43,13 @@ struct PeerPairing: Equatable {
/// Bonjour 服务实例名,由发送端随机生成 /// Bonjour 服务实例名,由发送端随机生成
let instance: String let instance: String
let senderName: String let senderName: String
let fileName: String /// 文件数与总字节数,用于扫码后立刻显示「3 个文件 · 1.2 GB」
let fileSize: UInt64 let fileCount: Int
let sha256: String let totalSize: UInt64
/// 清单帧原始字节的 SHA-256(十六进制小写)
static let serviceType = "_qft-p2p._tcp" let queueDigest: String
/// 第一个文件名,纯展示用
let previewName: String
func encode() -> String { func encode() -> String {
let object: [String: Any] = [ let object: [String: Any] = [
@@ -28,9 +57,10 @@ struct PeerPairing: Equatable {
"k": Base64URL.encode(key), "k": Base64URL.encode(key),
"i": instance, "i": instance,
"n": senderName, "n": senderName,
"f": fileName, "c": fileCount,
"z": NSNumber(value: fileSize), "z": NSNumber(value: totalSize),
"h": sha256, "d": queueDigest,
"f": previewName,
] ]
let data = (try? JSONSerialization.data(withJSONObject: object)) ?? Data() let data = (try? JSONSerialization.data(withJSONObject: object)) ?? Data()
return Self.prefix + Base64URL.encode(data) return Self.prefix + Base64URL.encode(data)
@@ -45,24 +75,27 @@ struct PeerPairing: Equatable {
let object = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any] else { let object = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any] else {
return nil return nil
} }
guard (object["v"] as? Int) == 1 else { return nil } guard (object["v"] as? Int) == 2 else { return nil }
guard let keyText = object["k"] as? String, guard let keyText = object["k"] as? String,
let key = Base64URL.decode(keyText), key.count == 32 else { return nil } let key = Base64URL.decode(keyText), key.count == 32 else { return nil }
guard let instance = object["i"] as? String, isValidInstance(instance) else { return nil } guard let instance = object["i"] as? String, isValidInstance(instance) else { return nil }
guard let fileName = (object["f"] as? String)?.trimmingCharacters(in: .whitespaces), guard let count = object["c"] as? Int, (1...512).contains(count) else { return nil }
PairingProtocol.isValidFileName(fileName) else { return nil } guard let total = (object["z"] as? NSNumber)?.uint64Value else { return nil }
guard let size = object["z"] as? NSNumber, size.int64Value >= 0 else { return nil } guard let digest = (object["d"] as? String)?.lowercased(),
guard let hash = (object["h"] as? String)?.lowercased(), PairingProtocol.isValidSHA256(digest) else { return nil }
PairingProtocol.isValidSHA256(hash) else { return nil }
let preview = (object["f"] as? String)?.trimmingCharacters(in: .whitespaces) ?? ""
guard preview.isEmpty || PairingProtocol.isValidFileName(preview) else { return nil }
return PeerPairing( return PeerPairing(
version: 1, version: 2,
key: key, key: key,
instance: instance, instance: instance,
senderName: String(((object["n"] as? String) ?? "iPhone").prefix(80)), senderName: String(((object["n"] as? String) ?? "iPhone").prefix(80)),
fileName: fileName, fileCount: count,
fileSize: UInt64(size.int64Value), totalSize: total,
sha256: hash queueDigest: digest,
previewName: String(preview.prefix(180))
) )
} }
@@ -92,3 +125,33 @@ struct PeerPairing: Equatable {
return "qft-" + String(bytes.map { alphabet[Int($0) % alphabet.count] }) return "qft-" + String(bytes.map { alphabet[Int($0) % alphabet.count] })
} }
} }
/// 清单帧的编解码。
///
/// 摘要是对**帧的原始字节**取的,不是对重新序列化的结果——重新序列化
/// 会因为键顺序或数字格式的差异而算出不同的摘要,那种「几乎总是对」的
/// 校验在真机上迟早会咬人。
enum PeerQueue {
static func encode(sender: String, files: [PeerFileMeta]) throws -> Data {
let object: [String: Any] = ["v": 2, "sender": sender, "files": files.map(\.json)]
return try JSONSerialization.data(withJSONObject: object, options: [.sortedKeys])
}
static func decode(_ data: Data) -> (sender: String, files: [PeerFileMeta])? {
guard let object = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any],
(object["v"] as? Int) == 2,
let rawFiles = object["files"] as? [[String: Any]], !rawFiles.isEmpty else { return nil }
var files: [PeerFileMeta] = []
for raw in rawFiles {
guard let file = PeerFileMeta.parse(raw) else { return nil }
files.append(file)
}
let sender = String(((object["sender"] as? String) ?? "iPhone").prefix(80))
return (sender, files)
}
static func digest(of data: Data) -> String {
SHA256.hash(data: data).map { String(format: "%02x", $0) }.joined()
}
}
+300
View File
@@ -0,0 +1,300 @@
import Foundation
import CryptoKit
/// 电脑 → iPhone 的**并行 Range 下载**。
///
/// 与旧的单流下载相比:把文件切成自适应大小的块,最多 8 路并发请求,
/// 每块独立重试,完成情况写进 `.qftpart` 旁边的账本,中断后只补没收到的块。
/// 这与 Android 端的策略一致,也是「iPhone ↔ Mac 走局域网但要更高效」的落点:
/// 单条 TCP 在 Wi-Fi 上打不满,多路才能吃满链路。
///
/// 桌面端 `sender.rs` 支持精确的 `Range`(`206` + `Content-Range`),并且能在
/// 一条连接上连续服务多个 Range 请求,所以这里不需要任何桌面端改动。
struct RangeDownloadClient {
struct Target {
var fileName: String
var fileSize: UInt64
/// 二维码里带 SHA-256 时才做整份校验;浏览发现的下载没有这个值
var sha256: String?
}
let host: QFTHost
let token: String
let deviceName: String
let destinationDirectory: URL
static let maxWorkers = 8
static let minChunkSize: UInt64 = 64 * 1024
static let maxChunkSize: UInt64 = 16 * 1024 * 1024
static let retriesPerChunk = 5
/// 目标 8 路并发,块大小落在 64 KiB–16 MiB。
/// 小文件自然只会有一个请求,不会为了并发而把块切碎。
static func chunkSize(for size: UInt64) -> UInt64 {
guard size > 0 else { return minChunkSize }
let ideal = (size + UInt64(maxWorkers) - 1) / UInt64(maxWorkers)
return min(maxChunkSize, max(minChunkSize, ideal))
}
// MARK: - 探测
/// 用 `Range: bytes=0-0` 问出文件名与总长度。
/// 没有二维码的场景(浏览发现的电脑)靠它拿到元数据。
func probe(timeout: TimeInterval = 8) async throws -> Target {
var request = try makeRequest()
request.setValue("bytes=0-0", forHTTPHeaderField: "Range")
request.timeoutInterval = timeout
let configuration = URLSessionConfiguration.ephemeral
configuration.timeoutIntervalForRequest = timeout
let session = URLSession(configuration: configuration)
defer { session.finishTasksAndInvalidate() }
let (_, response) = try await session.data(for: request)
guard let http = response as? HTTPURLResponse else {
throw QFTError.malformedResponse("非 HTTP 响应")
}
guard http.statusCode == 206 || http.statusCode == 200 else {
throw QFTError.httpStatus(http.statusCode,
http.statusCode == 403 ? "会话已失效" : "")
}
var size: UInt64 = 0
if let range = http.value(forHTTPHeaderField: "Content-Range"),
let total = range.split(separator: "/").last, let value = UInt64(total) {
size = value
} else if http.expectedContentLength > 0 {
size = UInt64(http.expectedContentLength)
}
var name = "qft-download.bin"
if let encoded = http.value(forHTTPHeaderField: "X-QFT-Filename"),
let decoded = Base64URL.decodeString(encoded) {
name = OpticalProtocol.sanitizeFileName(decoded)
}
return Target(fileName: name, fileSize: size, sha256: nil)
}
// MARK: - 下载
func run(_ target: Target, onProgress: @escaping (TransferProgress) -> Void) async throws -> URL {
try FileManager.default.createDirectory(at: destinationDirectory,
withIntermediateDirectories: true)
let partURL = destinationDirectory.appendingPathComponent(target.fileName + ".qftpart")
let ledgerURL = destinationDirectory.appendingPathComponent(target.fileName + ".qftpart.ledger")
let chunk = Self.chunkSize(for: target.fileSize)
let totalChunks = target.fileSize == 0 ? 0
: Int((target.fileSize + chunk - 1) / chunk)
var completed = [Bool](repeating: false, count: totalChunks)
if let ledger = DownloadLedger.load(from: ledgerURL),
ledger.matches(size: target.fileSize, chunkSize: chunk, sha256: target.sha256),
ledger.completed.count == totalChunks,
(try? FileManager.default.attributesOfItem(atPath: partURL.path)[.size] as? NSNumber)?
.uint64Value == target.fileSize {
completed = ledger.completed
} else {
try? FileManager.default.removeItem(at: partURL)
try? FileManager.default.removeItem(at: ledgerURL)
guard FileManager.default.createFile(atPath: partURL.path, contents: nil) else {
throw QFTError.malformedResponse("无法创建临时文件")
}
let handle = try FileHandle(forWritingTo: partURL)
try handle.truncate(atOffset: target.fileSize)
try handle.close()
}
if totalChunks > 0 {
let ledger = DownloadLedgerActor(url: ledgerURL, size: target.fileSize,
chunkSize: chunk, sha256: target.sha256,
completed: completed)
let alreadyDone = UInt64(completed.filter { $0 }.count) * chunk
let counter = ByteCounter(total: target.fileSize, onProgress: onProgress)
await counter.add(min(alreadyDone, target.fileSize))
let pending = (0..<totalChunks).filter { !completed[$0] }
let queue = ValueQueue(pending)
try await withThrowingTaskGroup(of: Void.self) { group in
let workers = min(pending.count, Self.maxWorkers)
for _ in 0..<workers {
group.addTask {
let handle = try FileHandle(forWritingTo: partURL)
defer { try? handle.close() }
while let index = await queue.next() {
try Task.checkCancellation()
let offset = UInt64(index) * chunk
let length = min(chunk, target.fileSize - offset)
let body = try await fetchChunk(offset: offset, length: length)
try handle.seek(toOffset: offset)
try handle.write(contentsOf: body)
await ledger.markCompleted(index)
await counter.add(length)
}
try handle.synchronize()
}
}
try await group.waitForAll()
}
await ledger.flush()
}
// --- 校验 ---
let actualSize = (try FileManager.default.attributesOfItem(atPath: partURL.path)[.size]
as? NSNumber)?.uint64Value ?? 0
guard actualSize == target.fileSize else {
throw QFTError.integrity("落盘 \(actualSize) 字节,电脑声明 \(target.fileSize) 字节")
}
if let expected = target.sha256 {
let actual = try OpticalAssembler.sha256(of: partURL)
.map { String(format: "%02x", $0) }.joined()
guard actual == expected else {
try? FileManager.default.removeItem(at: partURL)
try? FileManager.default.removeItem(at: ledgerURL)
throw QFTError.integrity("SHA-256 不匹配,文件已丢弃")
}
}
let finalURL = DownloadClient.uniqueURL(in: destinationDirectory, name: target.fileName)
try FileManager.default.moveItem(at: partURL, to: finalURL)
try? FileManager.default.removeItem(at: ledgerURL)
return finalURL
}
// MARK: - 单块
private func fetchChunk(offset: UInt64, length: UInt64) async throws -> Data {
var lastError: Error = QFTError.malformedResponse("未知错误")
for attempt in 0..<Self.retriesPerChunk {
do {
var request = try makeRequest()
request.setValue("bytes=\(offset)-\(offset + length - 1)",
forHTTPHeaderField: "Range")
let configuration = URLSessionConfiguration.ephemeral
configuration.timeoutIntervalForRequest = 60
configuration.timeoutIntervalForResource = 300
let session = URLSession(configuration: configuration)
defer { session.finishTasksAndInvalidate() }
let (data, response) = try await session.data(for: request)
guard let http = response as? HTTPURLResponse else {
throw QFTError.malformedResponse("非 HTTP 响应")
}
if http.statusCode == 403 {
throw QFTError.httpStatus(403, "会话已失效,请让电脑重新生成二维码或连接码")
}
// 200 表示对端忽略了 Range,整份文件都会被送过来——
// 并行下载在这种服务端上不成立,必须显式失败让上层回落单流。
// 这种失败重试多少次都不会变,所以下面的 catch 里直接抛出。
guard http.statusCode == 206 else {
throw QFTError.rangeUnsupported(http.statusCode)
}
guard UInt64(data.count) == length else {
throw QFTError.integrity("第 \(offset / max(1, length)) 块收到 \(data.count) 字节,应为 \(length)")
}
return data
} catch {
lastError = error
if case QFTError.httpStatus(let code, _) = error, code == 403 { throw error }
// 重试改变不了的错误立刻上抛,别白白烧掉 5 轮退避
if case QFTError.rangeUnsupported = error { throw error }
if error is CancellationError { throw error }
try? await Task.sleep(nanoseconds: UInt64(150_000_000) << UInt64(min(attempt, 4)))
}
}
throw lastError
}
private func makeRequest() throws -> URLRequest {
guard let url = URL(string: host.baseURL + "/qft/download") else {
throw QFTError.malformedResponse("下载地址无效")
}
var request = URLRequest(url: url)
request.httpMethod = "GET"
request.timeoutInterval = 60
request.setValue(token, forHTTPHeaderField: "X-QFT-Token")
request.setValue(Base64URL.encode(deviceName), forHTTPHeaderField: "X-QFT-Device")
return request
}
}
// MARK: - 断点账本
/// `.qftpart` 只说明「文件占了多大」,不说明「哪些块是好的」。
/// 并行下载的块是乱序落盘的,没有账本就无法安全续传——这也是不能沿用
/// 单流下载那套「已落盘长度即断点」的原因。
struct DownloadLedger {
let size: UInt64
let chunkSize: UInt64
let sha256: String?
var completed: [Bool]
func matches(size: UInt64, chunkSize: UInt64, sha256: String?) -> Bool {
self.size == size && self.chunkSize == chunkSize && self.sha256 == sha256
}
func encode() -> Data {
let object: [String: Any] = [
"v": 1,
"size": NSNumber(value: size),
"chunk": NSNumber(value: chunkSize),
"sha256": sha256 ?? "",
"bits": completed.map { $0 ? 1 : 0 },
]
return (try? JSONSerialization.data(withJSONObject: object)) ?? Data()
}
static func load(from url: URL) -> DownloadLedger? {
guard let data = try? Data(contentsOf: url),
let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
(object["v"] as? Int) == 1,
let size = (object["size"] as? NSNumber)?.uint64Value,
let chunk = (object["chunk"] as? NSNumber)?.uint64Value, chunk > 0,
let bits = object["bits"] as? [Int] else { return nil }
let sha = object["sha256"] as? String
return DownloadLedger(size: size, chunkSize: chunk,
sha256: (sha?.isEmpty ?? true) ? nil : sha,
completed: bits.map { $0 != 0 })
}
}
/// 账本的串行写入端。落盘限频,避免每块都写一次小文件。
actor DownloadLedgerActor {
private let url: URL
private var ledger: DownloadLedger
private var lastFlush = Date.distantPast
init(url: URL, size: UInt64, chunkSize: UInt64, sha256: String?, completed: [Bool]) {
self.url = url
self.ledger = DownloadLedger(size: size, chunkSize: chunkSize,
sha256: sha256, completed: completed)
}
func markCompleted(_ index: Int) {
guard index < ledger.completed.count else { return }
ledger.completed[index] = true
if Date().timeIntervalSince(lastFlush) > 1 { flush() }
}
func flush() {
lastFlush = Date()
try? ledger.encode().write(to: url, options: .atomic)
}
}
/// 分发待下载块序号。
actor ValueQueue {
private var values: [Int]
private var cursor = 0
init(_ values: [Int]) { self.values = values }
func next() -> Int? {
guard cursor < values.count else { return nil }
defer { cursor += 1 }
return values[cursor]
}
}
+176
View File
@@ -0,0 +1,176 @@
import Foundation
/// 路由表与广播地址推导。
///
/// 加入「QFT Direct」这类专用 Wi-Fi 之后,电脑就是这条链路上的**网关**——
/// Android 端正是从系统给该连接的路由表里读网关,iOS 这边只能自己读
/// `sysctl(CTL_NET, PF_ROUTE, …)`。这一步不是可有可无的优化:专用网络的
/// 二维码按设计不携带任何电脑地址(见 `desktop/src/pairing.rs::qr_endpoints`),
/// 不读路由表就只剩下全子网扫描。
extension LocalNetwork {
/// 各网卡的定向广播地址(如 192.168.1.255)。
static func directedBroadcastAddresses() -> [String] {
var result: [String] = []
for interface in activeInterfaces() {
guard let ip = ipv4(interface.address), let mask = ipv4(interface.netmask),
mask != 0, mask != UInt32.max else { continue }
let broadcast = format(ip | ~mask)
if !result.contains(broadcast) { result.append(broadcast) }
}
return result
}
/// 默认路由的网关地址,按 en0(Wi-Fi)优先排序。
static func defaultGateways() -> [String] {
var gateways: [(interface: String, address: String)] = []
for entry in routeEntries() where entry.isDefault {
guard PairingProtocol.isPrivateIPv4(entry.gateway) else { continue }
if gateways.contains(where: { $0.address == entry.gateway }) { continue }
gateways.append((entry.interface, entry.gateway))
}
return gateways
.sorted { lhs, _ in lhs.interface == "en0" }
.map(\.address)
}
/// 定位电脑时的候选地址,按「最可能是那台电脑」排序:
/// 默认网关(专用网络下必然是电脑)→ 本子网的 .1 → 其余子网地址。
static func hostCandidates(port: Int, limit: Int = 254) -> [String] {
var result: [String] = []
func push(_ address: String) {
let endpoint = "http://\(address):\(port)"
if !result.contains(endpoint) { result.append(endpoint) }
}
for gateway in defaultGateways() { push(gateway) }
for interface in activeInterfaces() {
guard let ip = ipv4(interface.address), let mask = ipv4(interface.netmask) else { continue }
push(format((ip & mask) &+ 1))
}
for endpoint in subnetCandidates(port: port, limit: limit) where !result.contains(endpoint) {
result.append(endpoint)
}
return result
}
// MARK: - sysctl 路由表
struct RouteEntry {
let interface: String
let gateway: String
/// 目的地址为 0.0.0.0 即默认路由
let isDefault: Bool
}
/// `net/route.h` 里的常量。
///
/// **iOS SDK 不导出 `net/route.h`**(macOS SDK 才有),连桥接头文件都救不了——
/// 那个头文件根本不在 iPhoneOS.sdk 里。内核 ABI 两边是同一套,所以这里按
/// 已公开的报文布局手写。`CoreTests` 会在 macOS 上拿真类型逐个字段做交叉校验,
/// 一旦布局变了测试立刻红。
enum RouteMessage {
static let version: UInt8 = 5 // RTM_VERSION
static let gatewayFlag: Int32 = 0x2 // RTF_GATEWAY
static let addressSlots = 8 // RTAX_MAX
static let destinationSlot = 0 // RTAX_DST
static let gatewaySlot = 1 // RTAX_GATEWAY
/// `struct rt_msghdr` 的字段偏移与整体大小。
/// ```c
/// u_short rtm_msglen; u_char rtm_version; u_char rtm_type;
/// u_short rtm_index; /* 2 字节填充 */ int rtm_flags;
/// int rtm_addrs; pid_t rtm_pid; int rtm_seq;
/// int rtm_errno; int rtm_use; u_int32_t rtm_inits;
/// struct rt_metrics rtm_rmx; /* 14 × u_int32_t */
/// ```
static let messageLengthOffset = 0
static let versionOffset = 2
static let interfaceIndexOffset = 4
static let addressMaskOffset = 12
static let headerSize = 92
}
static func routeEntries() -> [RouteEntry] {
var mib: [Int32] = [CTL_NET, PF_ROUTE, 0, AF_INET,
NET_RT_FLAGS, RouteMessage.gatewayFlag]
var length = 0
guard sysctl(&mib, u_int(mib.count), nil, &length, nil, 0) == 0, length > 0 else { return [] }
var buffer = [UInt8](repeating: 0, count: length)
// 两次 sysctl 之间路由表可能变长,第二次会写回实际长度
guard sysctl(&mib, u_int(mib.count), &buffer, &length, nil, 0) == 0,
length <= buffer.count else { return [] }
var entries: [RouteEntry] = []
var offset = 0
let headerSize = RouteMessage.headerSize
while offset + headerSize <= length {
let messageLength = Int(readU16(buffer, offset + RouteMessage.messageLengthOffset))
guard messageLength >= headerSize, offset + messageLength <= length else { break }
defer { offset += messageLength }
// 版本不认识就整条跳过,而不是硬着头皮按旧布局读
guard buffer[offset + RouteMessage.versionOffset] == RouteMessage.version else { continue }
let interfaceIndex = readU16(buffer, offset + RouteMessage.interfaceIndexOffset)
let addressMask = Int32(bitPattern: readU32(buffer, offset + RouteMessage.addressMaskOffset))
var cursor = offset + headerSize
var destination: String?
var gateway: String?
// sockaddr 按 RTAX_* 顺序紧跟在头之后,由 rtm_addrs 位图指明哪些存在
for slot in 0..<RouteMessage.addressSlots {
guard addressMask & (1 << Int32(slot)) != 0 else { continue }
guard cursor + 2 <= offset + messageLength else { break }
let saLength = Int(buffer[cursor]) // sockaddr.sa_len
let family = buffer[cursor + 1] // sockaddr.sa_family
if family == UInt8(AF_INET), saLength >= MemoryLayout<sockaddr_in>.size,
cursor + MemoryLayout<sockaddr_in>.size <= offset + messageLength {
var inet = sockaddr_in()
// memcpy 而不是 loadUnaligned:既解决对齐,
// 也不依赖只在 iOS 16+ 才有的 Swift 5.7 运行时
buffer.withUnsafeBytes { raw in
guard let base = raw.baseAddress else { return }
memcpy(&inet, base + cursor, MemoryLayout<sockaddr_in>.size)
}
var address = inet.sin_addr
var text = [CChar](repeating: 0, count: Int(INET_ADDRSTRLEN))
if inet_ntop(AF_INET, &address, &text, socklen_t(INET_ADDRSTRLEN)) != nil {
let value = String(cString: text)
if slot == RouteMessage.destinationSlot { destination = value }
if slot == RouteMessage.gatewaySlot { gateway = value }
}
}
// 每个 sockaddr 按 4 字节对齐,长度为 0 时仍占 4 字节
cursor += saLength > 0 ? (1 + ((saLength - 1) | 3)) : 4
}
guard let gateway else { continue }
var name = [CChar](repeating: 0, count: Int(IFNAMSIZ) + 1)
let interface = if_indextoname(UInt32(interfaceIndex), &name) != nil
? String(cString: name) : ""
entries.append(RouteEntry(interface: interface, gateway: gateway,
isDefault: destination == "0.0.0.0"))
}
return entries
}
/// 报文里的整数是**主机序**,用 memcpy 拷进原生类型,
/// 这样既不假设字节序,也不要求对齐。
private static func readU16(_ bytes: [UInt8], _ offset: Int) -> UInt16 {
var value: UInt16 = 0
bytes.withUnsafeBytes { raw in
guard let base = raw.baseAddress else { return }
memcpy(&value, base + offset, 2)
}
return value
}
private static func readU32(_ bytes: [UInt8], _ offset: Int) -> UInt32 {
var value: UInt32 = 0
bytes.withUnsafeBytes { raw in
guard let base = raw.baseAddress else { return }
memcpy(&value, base + offset, 4)
}
return value
}
}
+17
View File
@@ -0,0 +1,17 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<!--
自动加入电脑的专用 Wi-Fi(Windows 的 QFT Direct)所需的能力。
这个 entitlement 只有**付费开发者账号**能签出来;免费账号带上它会
直接签名失败,所以工程默认**不引用**本文件:
Build Settings → QFT_ENTITLEMENTS = QFT/QFT.entitlements
设置之后重新签名即可。没有它时 App 不会假装成功,而是显示 SSID/密码
引导用户去「设置」里手动连一次,后续流程完全相同。
-->
<key>com.apple.developer.networking.HotspotConfiguration</key>
<true/>
</dict>
</plist>
+189 -49
View File
@@ -1,12 +1,30 @@
# QFT iOS 客户端 v0.4.7 # QFT iOS 客户端 v0.5.0
三种传输方式: 对齐当前 Windows / macOS / Android 三端的能力,四条链路:
| 方向 | 链路 | 说明 | | 方向 | 链路 | 说明 |
|---|---|---| |---|---|---|
| 电脑 → iPhone | 局域网 HTTP | 扫 Windows 端的 `QFTSEND2` 码,自动下载,支持断点续传 | | 电脑 → iPhone(光学) | **屏幕 → 摄像头** | 扫电脑「光学传输」页循环播放的 QFT2 二维码,文件数据完全不经过网络 |
| iPhone → 电脑 | 局域网 HTTP | 扫 `QFTPAIR2` 码,选文件后并行分块上传 | | iPhone ↔ Windows | **专用网络(QFT Direct)** | 扫码后加入电脑开的专用 Wi-Fi,从路由表认出网关即电脑 |
| **iPhone ↔ iPhone** | **点对点直连** | 发送方显示二维码,接收方扫码,**不需要连同一个 Wi-Fi** | | iPhone ↔ Mac / Linux | **局域网** | 扫二维码,或直接输电脑上的连接码;下发走 8 路并行 Range |
| iPhone ↔ iPhone | **隔空(AWDL 点对点)** | 多选文件后显示二维码,对方扫一下即可,**不需要连同一个 Wi-Fi** |
本次改动只在 `ios/` 目录内,未改动 `desktop/`(Windows/macOS/Linux)与 `android/` 的任何实现。
## 系统版本与向下兼容
- **最低系统:iOS 15.0**,覆盖 iPhone 6s(2015)及以后,与 Android 端 `minSdk 24`
(Android 7.0,2016)覆盖的机型年代大致相当。
- 再往下走不动了:`URLSession` 的 async 接口是 iOS 15 才有的,低于 15 就要把
全部网络代码改回 completion handler,代价与收益不成比例。
- 新系统上更好的实现照样用,但一律走 `App/Compatibility.swift` 分叉,不把整个
App 的部署目标顶上去:
- `NavigationStack` / `ShareLink` / `LabeledContent`(iOS 16)→ iOS 15 上分别回落
`NavigationView` / `UIActivityViewController` / 手写 `HStack`;
- 两参数 `onChange`(iOS 17)→ 统一用 `onReceive`;
- `videoRotationAngle`(iOS 17)→ iOS 15/16 上用 `videoOrientation`;
- `UnsafeRawPointer.loadUnaligned`(Swift 5.7 运行时 / iOS 16)→ 改成手工拼大端
与 `memcpy`。
## 打开工程 ## 打开工程
@@ -24,74 +42,179 @@ Target → Signing & Capabilities 里选一下你自己的开发者账号(免
python3 ios/tools/generate_xcodeproj.py python3 ios/tools/generate_xcodeproj.py
``` ```
- 最低系统:iOS 17.0 Bundle ID:`com.qft.transfer`(按需改 `generate_xcodeproj.py` 里的常量)。
- Bundle ID:`com.qft.transfer`(按需改 `generate_xcodeproj.py` 里的常量)
## 隔空投送式点对点传输 ## 光学接收(不用网络的那条)
`PeerLink` 用 `Network.framework` 并打开 `includePeerToPeer`。底层就是 首页「光学接收」对准电脑的「光学传输」页即可。这条链路上文件数据**只经过屏幕和
AirDrop 用的那条链路——BLE 发现 + AWDL 点对点 Wi-Fi,两台设备不需要路由器, 摄像头**——Wi-Fi、蓝牙、局域网、互联网都不参与,因此也是「电脑不允许接任何网络」
也不需要连同一个 Wi-Fi。两端在同一个 Wi-Fi 下时它会自动优先走基础网络。 场合下唯一可用的路径。
握手用 **TLS-PSK**:预共享密钥(32 字节)由发送端随机生成并写进二维码, 实现与 Android 端同一套状态机,只是解码器换成 Vision:
扫码这个动作本身就完成了带外密钥交换与双向认证。没扫到码的第三方
连上来也过不了 TLS 握手,因此不需要任何证书体系,也不需要配对弹窗。 ```text
居中搜索(92% 画面)
↓ 解出一帧
按条码外接框建立 ROI(放大 1.22 倍、按像素修成正方形)
↓
后续只把 ROI 交给 Vision
↓ 轻微移动:平滑跟随(alpha 0.35)
↓ 连续 3 帧丢失:逐级放大 ROI
↓ 连续 12 帧丢失:回到全画面重新搜索
```
其它与 Android 对齐的点:
- 相机格式在「支持 ≥60 FPS 的格式里取分辨率最高的」,锁定固定帧率,关 HDR 与防抖;
- `alwaysDiscardsLateVideoFrames`,追不上就丢,不播放过时的相机帧;
- 锁定后每 2.5 秒在 ROI 中心重新对焦/测光(屏幕是平面光源,连续自动对焦会拉风箱);
- 屏幕上同一帧会被连续拍到多次,重复帧不会重复送进装配器;UI 同时显示
**解码/s** 和**有效新帧/s**——决定传输时间的是后者,据此在电脑端选 30 / 45 / 60 FPS;
- 每帧 CRC32 + 整份 SHA-256,校验不过就整份丢弃等下一轮重播,绝不把半份文件交给用户。
## 专用网络(iPhone ↔ Windows)
Windows 进入接收后会用 Wi-Fi Direct Legacy AP 开一张专用网,二维码里**按设计不带
任何电脑地址**(见 `desktop/src/pairing.rs::qr_endpoints`):手机必须先加入那张
Wi-Fi,再从路由表里把网关认出来——那就是电脑。
iOS 侧两条路径,取决于**签名能力**:
| 情况 | 行为 |
|---|---|
| 有 `HotspotConfiguration` entitlement | `NEHotspotConfiguration` 自动加入(`joinOnce`,会话结束不留在系统 Wi-Fi 列表里) |
| 没有(免费账号) | 显示 SSID / 密码 + 「打开设置」,用户手动连一次,回 App 点「我已连上」继续 |
**不会假装成功**:拿不到能力时直接转手动引导,而不是让用户对着一个永远连不上的
进度条等下去。
entitlement 只有付费账号签得出来,带上它免费账号会直接签名失败,因此工程默认
**不引用** `QFT/QFT.entitlements`。要开启:
``` ```
发送方 接收方 Target → Build Settings → QFT_ENTITLEMENTS = QFT/QFT.entitlements
选文件 → 算 SHA-256 ```
加入之后判据不是「系统说加好了」,而是**协议层握手成功**——能用正确令牌 ping 通
`/qft/ping` 才算数。系统接受配置 ≠ 拿到 IPv4 ≠ 电脑那侧的 Wi-Fi Direct 数据通道已建立。
## 局域网(iPhone ↔ Mac / Linux)
两种入口:
1. **扫二维码**:和 Windows 的 LAN 模式完全一样。
2. **连接码**:电脑上打开 QFT →「电脑 ↔ 电脑」→「我要接收」,屏幕上会显示
`K7M2-9X4P-QR3T` 这样一串码,**地址、端口和配对秘密都编在码里**。iPhone 在
「连接附近的电脑」页输入即可,不用扫码、不要求同网段可广播。
「附近的电脑」列表用 `QFTBROWSE3` 广播(`desktop/src/discovery.rs` 的客户端实现),
只是帮用户确认「就是这台」;真正建立会话仍然靠连接码换令牌(`POST /qft/pair`)。
电脑端输错 5 次即作废整个码,所以 App 绝不重试。
**边界说清楚**:连接码换来的是电脑**接收端**的会话,因此这条路径只能「把文件发到
电脑」。要让电脑下发文件,请在电脑上选好文件后扫它生成的二维码。
### 更高效在哪
电脑下发改成 **8 路并行 Range 下载**:
- 块大小按文件自适应,落在 64 KiB–16 MiB,目标 8 路并发;
- 每块最多重试 5 次,403 立即失败不重试;
- 完成情况写进 `.qftpart` 旁边的账本(并行块是乱序落盘的,「已落盘长度即断点」
那套在这里不成立),中断后只补没收到的块;
- 全部收齐后单遍 SHA-256,通过才 rename;
- 对端返回 200(忽略了 Range)时显式失败并**回落单流下载**,不会因为遇到老版本
电脑端就直接报错。
## 隔空(iPhone ↔ iPhone)
`PeerLink` 用 `Network.framework` 并打开 `includePeerToPeer`。底层就是隔空投送用的
那条链路——BLE 发现 + AWDL 点对点 Wi-Fi,两台设备不需要路由器,也不需要连同一个
Wi-Fi。两端在同一个 Wi-Fi 下时它会自动优先走基础网络。
握手用 **TLS-PSK**:预共享密钥(32 字节)由发送端随机生成并写进二维码,扫码这个
动作本身就完成了带外密钥交换与双向认证。没扫到码的第三方连上来也过不了 TLS 握手,
因此不需要任何证书体系,也不需要配对弹窗。
v0.5.0 起支持**多文件队列**(对齐 Android → Android 的手机互传):
```
发送方 接收方
多选文件 → 逐个算 SHA-256
启动 NWListener(Bonjour: _qft-p2p._tcp) 启动 NWListener(Bonjour: _qft-p2p._tcp)
生成 32 字节 PSK 生成 32 字节 PSK
显示 QFTP2P1 二维码 ──────扫码────→ 解析出 PSK + 服务实例名 显示 QFTP2P2 二维码 ──────扫码────→ 解析出 PSK + 服务实例名 + 清单摘要
NWBrowser 找到实例 NWBrowser 找到实例
←──────── TLS-PSK 握手 ────────→ ←──────── TLS-PSK 握手 ────────→
MANIFEST(JSON) ─────────────────────→ 校验与二维码是否一致 QUEUE(JSON 清单) ───────────────────→ 摘要必须与二维码一致
DATA × N ─────────────────────→ 落盘 + 增量 SHA-256 FILE_BEGIN / DATA×N / FILE_END ─────→ 逐个落盘 + 单文件 SHA-256
EOF ─────────────────────→ (对队列里每个文件重复)
←──────── RESULT(JSON) ──────── 校验通过才 rename EOF ────────────────────→
←──────── RESULT(JSON) ──────── 全部通过才算成功
``` ```
**AWDL 是苹果私有链路,Windows 无法参与**,所以与电脑互传仍走局域网 HTTP。 **文件清单不进二维码**,只放一个 SHA-256 摘要:十几个文件的元数据会让二维码密到
如果现场没有路由器,可行的替代是让 iPhone 开个人热点、电脑连上来。 扫不动。清单在 TLS 建立之后才传,接收端拿摘要比对——扫码这一下依然锁定了
「你看到的就是你收到的」。摘要对的是**清单帧的原始字节**,不是重新序列化的结果。
## 已知的 iOS 平台限制 > QFTP2P1(单文件)已移除。iOS 端从未发布过,保留一个没有用户的线格式只会腐坏。
1. **无法用代码连接指定 Wi-Fi。** Android 端用 `WifiNetworkSpecifier` 自动加入 **AWDL 是苹果私有链路,Windows/Android 无法参与**,所以与电脑互传仍走局域网/专用网络
Windows 的 QFT Direct AP,iOS 对应的 `NEHotspotConfiguration` 需要 HTTP,与 Android 手机互传只能同一个局域网。
HotspotConfiguration entitlement,免费开发者账号拿不到。因此 iOS 端
**不实现 Direct AP 流程**,`PairingProtocol` 在二维码不带可用 endpoint 时 ## 已知的平台限制
会直接拒绝,而不是给用户一个连不上的假成功。
2. **首次访问局域网会弹权限窗。** 已在 `Info.plist` 声明 1. **没有「下载」文件夹。** 收到的文件存在 App 的 Documents/QFT 下,通过
`NSLocalNetworkUsageDescription` 与 `NSBonjourServices`。 `UIFileSharingEnabled` + `LSSupportsOpeningDocumentsInPlace` 暴露到「文件」App,
若用户误点了拒绝,需要去 设置 → 隐私与安全性 → 本地网络 里重新打开。 也可以在 App 内直接分享出去。
3. **没有「下载」文件夹。** 收到的文件存在 App 的 Documents/QFT 下, 2. **首次访问局域网会弹权限窗。** 已在 `Info.plist` 声明 `NSLocalNetworkUsageDescription`
通过 `UIFileSharingEnabled` + `LSSupportsOpeningDocumentsInPlace` 与 `NSBonjourServices`。若用户误点了拒绝,需要去 设置 → 隐私与安全性 → 本地网络 里重新打开。
暴露到「文件」App,也可以在 App 内直接分享出去。 3. **上传块固定 4 MiB。** Android 端按文件大小选 4/8/16 MiB,但 iOS 上
4. **上传块固定 4 MiB。** Android 端按文件大小选 4/8/16 MiB,但 iOS 上
`worker 数 × 块大小` 就是内存峰值,16 MiB × 6 会在旧机型触发 jetsam。 `worker 数 × 块大小` 就是内存峰值,16 MiB × 6 会在旧机型触发 jetsam。
4 MiB × 6 = 24 MiB 峰值,局域网速度下每块的往返开销可以忽略。 4 MiB × 6 = 24 MiB 峰值,局域网速度下每块的往返开销可以忽略。
4. **光学链路是单向的**,只有「电脑 → iPhone」。iPhone 屏幕小、电脑普遍没有摄像头,
反方向没有意义。
## 测试 ## 测试
核心层(协议、发现、上传、下载、P2P 链路)不依赖 UIKit, 核心层(协议、发现、上传/下载、光学解码、P2P 链路)不依赖 UIKit/AVFoundation,
可以直接以 macOS 为目标编译运行,**不需要 Xcode,也不需要模拟器**: 可以直接以 macOS 为目标编译运行,**不需要 Xcode,也不需要模拟器**:
```bash ```bash
./ios/CoreTests/run.sh ./ios/CoreTests/run.sh
``` ```
也已接入主自检套件(`python scripts/run_all_selftests.py`)。 也已接入主自检套件(`python scripts/run_all_selftests.py`)。当前 180 项检查全绿。
测试内容: 测试内容:
- `Base64URL` 与三端一致性(含 200 组随机字节往返) - `Base64URL`、`Base45` 与三端一致性(Base45 用的是 `desktop/src/base45.rs` 里的同一组向量)
- `QFTPAIR2` / `QFTSEND2` / `QFTP2P1` 解析,含各类畸形输入 - `QFTPAIR2` / `QFTSEND2` / `QFTP2P2` 解析,含各类畸形输入
- **端点白名单**:二维码是不可信输入,只接受字面量私有 IPv4 + 声明端口。 - **端点白名单**:二维码是不可信输入,只接受字面量私有 IPv4 + 声明端口。
已覆盖域名、公网地址、`172.32` 边界、非规范八位组、IPv6、带凭据/路径/query 等 11 种拒绝用例 已覆盖域名、公网地址、`172.32` 边界、非规范八位组、IPv6、带凭据/路径/query 等 11 种拒绝用例
- **专用网络**:只带 Wi-Fi 凭据的二维码被接受,既无地址又无凭据的被拒;
有/无 entitlement 时的决策分支
- **光学链路**:合成 QFT2 播放列表 →「乱序 + 重复」重播 → 落盘校验;
CRC 篡改整帧丢弃;清单摘要不符整份丢弃;0 字节文件边界;ROI 状态机的
锁定 / 放大 / 重新搜索 / 越界夹取
- **连接码**:四组向量由 Rust 实现直接产出,任何一边改了编码都会红;
Crockford 容错、改一位必须失败、公网地址必须被白名单拒绝
- **与 `MockPCServer.py` 的完整传输**:该 mock 严格复刻 `receiver.rs` / `sender.rs` - **与 `MockPCServer.py` 的完整传输**:该 mock 严格复刻 `receiver.rs` / `sender.rs`
的线上语义(路径、header 名、JSON 字段、Range 行为、chunk 长度校验), 的线上语义(路径、header 名、JSON 字段、Range 行为、chunk 长度校验、
因此这组测试就是 Swift 端与 Rust 端的**线格式契约测试**——任何一边改了协议都会红 `/qft/pair` 的错 5 次作废),因此这组测试就是 Swift 端与 Rust 端的**线格式契约测试**
- **真实 TLS-PSK 握手**下的 P2P 端到端传输,含错误密钥必须被拒 - **8 路并行 Range 下载**与按账本续传
- **真实 TLS-PSK 握手**下的 P2P 多文件端到端传输,含错误密钥与清单摘要不符必须被拒
### 只有真机能验的部分
以下需要你在设备上跑,这台机器上没有 Xcode(只有 Command Line Tools),
App 层(SwiftUI + AVFoundation + Vision + NetworkExtension)无法在此编译:
- [ ] Xcode 打开工程,选模拟器 ⌘B 通过
- [ ] 光学接收的真机吞吐矩阵(电脑 30 / 45 / 60 FPS × 机型),记录有效新帧/s
- [ ] 加入 Windows QFT Direct 专用网(分别验证有/无 entitlement 两条路径)
- [ ] iPhone ↔ iPhone 在**关掉 Wi-Fi 路由器**的场合走 AWDL
- [ ] iOS 15 / 16 / 17+ 各跑一遍(兼容层分叉都要走到)
## 目录 ## 目录
@@ -100,19 +223,36 @@ ios/
QFT.xcodeproj/ 生成的工程(已提交) QFT.xcodeproj/ 生成的工程(已提交)
QFT/ QFT/
Info.plist 权限声明、Bonjour 服务、ATS 本地网络例外 Info.plist 权限声明、Bonjour 服务、ATS 本地网络例外
App/ SwiftUI 界面 + 相机扫码(需要 Xcode 才能构建) QFT.entitlements HotspotConfiguration(默认不引用,见上文)
Core/ 纯 Foundation,可在 macOS 上编译测试 App/ SwiftUI 界面(需要 Xcode 才能构建)
Compatibility.swift iOS 15/16/17 分叉
HomeView.swift
ScannerView.swift 配对码扫描(AVCaptureMetadataOutput)
OpticalReceiveView.swift 光学接收(AVCaptureVideoDataOutput + Vision + ROI)
DesktopConnectView.swift 附近的电脑 / 连接码 / 手动加入专用 Wi-Fi
TransferModel.swift
Core/ 纯 Foundation/Network,可在 macOS 上编译测试
Base64URL.swift Base64URL.swift
Base45.swift RFC 9285,光学帧文本层
Checksums.swift CRC-32(光学帧)/ CRC-8(连接码)
PairingProtocol.swift QFTPAIR2 / QFTSEND2 + 端点白名单 PairingProtocol.swift QFTPAIR2 / QFTSEND2 + 端点白名单
HostDiscovery.swift endpoint 探测 → UDP 广播 → 子网扫描 ConnectCode.swift 桌面端连接码
DownloadClient.swift 流式落盘 + 增量 SHA-256 + Range 续传 HostDiscovery.swift endpoint → 网关 → UDP 广播 → 子网扫描
RouteTable.swift sysctl 路由表 / 定向广播 / 候选地址
PeerBrowser.swift QFTBROWSE3 节点浏览 + POST /qft/pair
DedicatedNetwork.swift 专用 Wi-Fi 加入策略与 NEHotspotConfiguration
DownloadClient.swift 单流下载(回落路径)
RangeDownloadClient.swift 8 路并行 Range + 断点账本
UploadClient.swift init/chunk/finish 并行上传 UploadClient.swift init/chunk/finish 并行上传
PeerPairing.swift QFTP2P1 配对码 OpticalProtocol.swift QFT2 / QFT1 帧与清单
OpticalROI.swift ROI 状态机(纯几何)
OpticalAssembler.swift 会话装配、校验、落盘、速率统计
PeerPairing.swift QFTP2P2 配对码 + 文件清单
PeerLink.swift TLS-PSK + 分帧的点对点链路 PeerLink.swift TLS-PSK + 分帧的点对点链路
CoreTests/ CoreTests/
run.sh 编译并运行(swiftc,无需 Xcode) run.sh 编译并运行(swiftc,无需 Xcode)
main.swift 测试用例 main.swift 测试用例
MockPCServer.py 复刻 Windows 端线上语义的假电脑 MockPCServer.py 复刻 Windows/macOS 端线上语义的假电脑
tools/ tools/
generate_xcodeproj.py 工程生成器 generate_xcodeproj.py 工程生成器
``` ```
+22 -4
View File
@@ -18,24 +18,37 @@ IOS_ROOT = os.path.dirname(HERE)
APP_NAME = "QFT" APP_NAME = "QFT"
BUNDLE_ID = "com.qft.transfer" BUNDLE_ID = "com.qft.transfer"
DEPLOYMENT_TARGET = "17.0" DEPLOYMENT_TARGET = "15.0"
MARKETING_VERSION = "0.4.7" MARKETING_VERSION = "0.5.0"
SOURCES = [ SOURCES = [
"QFT/App/QFTApp.swift", "QFT/App/QFTApp.swift",
"QFT/App/Compatibility.swift",
"QFT/App/HomeView.swift", "QFT/App/HomeView.swift",
"QFT/App/ScannerView.swift", "QFT/App/ScannerView.swift",
"QFT/App/OpticalReceiveView.swift",
"QFT/App/DesktopConnectView.swift",
"QFT/App/TransferModel.swift", "QFT/App/TransferModel.swift",
"QFT/Core/Base64URL.swift", "QFT/Core/Base64URL.swift",
"QFT/Core/Base45.swift",
"QFT/Core/Checksums.swift",
"QFT/Core/PairingProtocol.swift", "QFT/Core/PairingProtocol.swift",
"QFT/Core/ConnectCode.swift",
"QFT/Core/HostDiscovery.swift", "QFT/Core/HostDiscovery.swift",
"QFT/Core/RouteTable.swift",
"QFT/Core/PeerBrowser.swift",
"QFT/Core/DedicatedNetwork.swift",
"QFT/Core/DownloadClient.swift", "QFT/Core/DownloadClient.swift",
"QFT/Core/RangeDownloadClient.swift",
"QFT/Core/UploadClient.swift", "QFT/Core/UploadClient.swift",
"QFT/Core/OpticalProtocol.swift",
"QFT/Core/OpticalROI.swift",
"QFT/Core/OpticalAssembler.swift",
"QFT/Core/PeerPairing.swift", "QFT/Core/PeerPairing.swift",
"QFT/Core/PeerLink.swift", "QFT/Core/PeerLink.swift",
] ]
RESOURCES = ["QFT/Assets.xcassets"] RESOURCES = ["QFT/Assets.xcassets"]
OTHER_FILES = ["QFT/Info.plist"] OTHER_FILES = ["QFT/Info.plist", "QFT/QFT.entitlements"]
def oid(*parts): def oid(*parts):
@@ -279,8 +292,13 @@ def generate():
shared_target = [ shared_target = [
"ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon", "ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon",
"ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor", "ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor",
# 自动加入专用 Wi-Fi 需要 HotspotConfiguration entitlement,而它只有
# 付费账号签得出来。默认留空,免费账号照样能编译签名;要开的话把
# QFT_ENTITLEMENTS 设成 QFT/QFT.entitlements 即可。
"CODE_SIGN_ENTITLEMENTS = \"$(QFT_ENTITLEMENTS)\"",
"QFT_ENTITLEMENTS = \"\"",
"CODE_SIGN_STYLE = Automatic", "CODE_SIGN_STYLE = Automatic",
"CURRENT_PROJECT_VERSION = 47", "CURRENT_PROJECT_VERSION = 50",
"ENABLE_PREVIEWS = YES", "ENABLE_PREVIEWS = YES",
"GENERATE_INFOPLIST_FILE = NO", "GENERATE_INFOPLIST_FILE = NO",
"INFOPLIST_FILE = QFT/Info.plist", "INFOPLIST_FILE = QFT/Info.plist",
+22 -1
View File
@@ -7,18 +7,39 @@ wifi=(ROOT/'android/app/src/main/java/com/qft/optical/WifiConnector.kt').read_te
download=(ROOT/'android/app/src/main/java/com/qft/optical/DownloadClient.kt').read_text() download=(ROOT/'android/app/src/main/java/com/qft/optical/DownloadClient.kt').read_text()
main=(ROOT/'android/app/src/main/java/com/qft/optical/MainActivity.kt').read_text(); analyzer=(ROOT/'android/app/src/main/java/com/qft/optical/QrAnalyzer.kt').read_text() main=(ROOT/'android/app/src/main/java/com/qft/optical/MainActivity.kt').read_text(); analyzer=(ROOT/'android/app/src/main/java/com/qft/optical/QrAnalyzer.kt').read_text()
queue=(ROOT/'android/app/src/main/java/com/qft/optical/TransferQueue.kt').read_text() queue=(ROOT/'android/app/src/main/java/com/qft/optical/TransferQueue.kt').read_text()
phone_server=(ROOT/'android/app/src/main/java/com/qft/optical/PhoneShareServer.kt').read_text()
phone_hotspot=(ROOT/'android/app/src/main/java/com/qft/optical/PhoneHotspotController.kt').read_text()
gray=(ROOT/'android/app/src/main/java/com/qft/optical/GrayFrame.kt').read_text(); protocol=(ROOT/'android/app/src/main/java/com/qft/optical/Protocol.kt').read_text(); base45=(ROOT/'android/app/src/main/java/com/qft/optical/Base45.kt').read_text(); overlay=(ROOT/'android/app/src/main/java/com/qft/optical/QrLockOverlay.kt').read_text(); security=(ROOT/'android/app/src/main/res/xml/network_security_config.xml').read_text() gray=(ROOT/'android/app/src/main/java/com/qft/optical/GrayFrame.kt').read_text(); protocol=(ROOT/'android/app/src/main/java/com/qft/optical/Protocol.kt').read_text(); base45=(ROOT/'android/app/src/main/java/com/qft/optical/Base45.kt').read_text(); overlay=(ROOT/'android/app/src/main/java/com/qft/optical/QrLockOverlay.kt').read_text(); security=(ROOT/'android/app/src/main/res/xml/network_security_config.xml').read_text()
assert re.search(r'minSdk\s*=\s*24',gradle) assert re.search(r'minSdk\s*=\s*24',gradle)
assert 'WRITE_EXTERNAL_STORAGE" android:maxSdkVersion="28"' in manifest assert 'WRITE_EXTERNAL_STORAGE" android:maxSdkVersion="28"' in manifest
assert 'ACCESS_FINE_LOCATION" android:maxSdkVersion="32"' in manifest and 'NEARBY_WIFI_DEVICES' in manifest assert 'ACCESS_FINE_LOCATION" android:maxSdkVersion="32"' in manifest and 'NEARBY_WIFI_DEVICES' in manifest
assert 'android.hardware.wifi.direct' in manifest
assert 'networkSecurityConfig="@xml/network_security_config"' in manifest and 'cleartextTrafficPermitted="true"' in security assert 'networkSecurityConfig="@xml/network_security_config"' in manifest and 'cleartextTrafficPermitted="true"' in security
assert 'Build.VERSION.SDK_INT >= 29' in wifi and 'connectLegacy' in wifi and 'subnetEndpoints' in wifi and 'directedBroadcast' in wifi assert 'Build.VERSION.SDK_INT >= 29' in wifi and 'connectLegacy' in wifi and 'subnetEndpoints' in wifi and 'directedBroadcast' in wifi
assert 'MAX_WORKERS = 8' in upload and 'QFTDISC2:' in upload assert 'MAX_WORKERS = 8' in upload and 'QFTDISC2:' in upload
assert 'MAX_WORKERS = 8' in download and 'bytes=$start-$end' in download and 'completionMapFile' in download assert 'MAX_WORKERS = 8' in download and 'bytes=$start-$end' in download and 'completionMapFile' in download
assert 'requestNetwork(request, cb)' in wifi and 'delivered.set(false)' in wifi assert 'requestNetwork(request, cb)' in wifi and 'delivered.set(false)' in wifi
assert 'wifiManager.startScan()' in wifi and '.setIsHiddenSsid(false)' in wifi assert 'wifiManager.startScan()' in wifi and '.setIsHiddenSsid(false)' in wifi
assert 'pendingWifi == wifi' in wifi and 'pendingSsid == wifi.ssid' not in wifi
assert 'wifiManager.updateNetwork(config)' in wifi and 'wifiManager.removeNetwork(target)' in wifi
assert 'elapsed > 30_000' in wifi and '旧版 Android 首次关联未完成' in wifi
assert 'canJoinAutomatically' in wifi and 'wifiManager.isWpa3SaeSupported' in wifi
assert 'unsupportedHotspot' in main and 'pair.copy(wifi = null)' in main
assert 'probeConnectedNetwork' in upload and 'workers = 48' in upload assert 'probeConnectedNetwork' in upload and 'workers = 48' in upload
assert 'awaitGatewayEndpoints' not in main assert 'awaitGatewayEndpoints' not in main
assert 'QFTPHONE2:' in (ROOT/'android/app/src/main/java/com/qft/optical/PairingProtocol.kt').read_text()
assert 'WifiP2pManager' in phone_hotspot and 'createGroup' in phone_hotspot
assert 'GROUP_OWNER_BAND_AUTO' in phone_hotspot and 'GROUP_OWNER_BAND_2GHZ' in phone_hotspot
assert 'LEGACY_BAND_FALLBACK_MS = 12_000L' in phone_hotspot and 'onStarted(wifi) // Same credentials' in phone_hotspot
assert 'markPeerAuthenticated' in phone_hotspot and 'phoneHotspot.markPeerAuthenticated()' in main
assert 'setNetworkName(wifi.ssid)' in phone_hotspot and 'setPassphrase(wifi.passphrase)' in phone_hotspot
assert 'startLocalOnlyHotspot' in phone_hotspot and 'Build.VERSION.SDK_INT < 26' not in main
assert '/qft/phone/manifest' in phone_server and '/qft/phone/download/' in phone_server
assert 'startDownloadsFromPhone' in main and 'downloadPath = item.path' in main
assert 'downloadPath.startsWith("/qft/phone/download/")' in download and 'else RANGE_WORKERS' in download
assert 'phoneQrSidePx(windowWidth, windowHeight' in main
assert 'LinearLayout.LayoutParams(qrSide, qrSide)' in main
assert 'PhoneQr.render(encoded, 720)' not in main
assert 'if (mode == ScannerMode.PAIR) Size(960, 720) else Size(640, 480)' in main and 'Size(960, 540)' not in main assert 'if (mode == ScannerMode.PAIR) Size(960, 720) else Size(640, 480)' in main and 'Size(960, 540)' not in main
assert 'Camera2Interop.Extender' in main and 'CONTROL_AE_TARGET_FPS_RANGE' in main and 'STRATEGY_KEEP_ONLY_LATEST' in main assert 'Camera2Interop.Extender' in main and 'CONTROL_AE_TARGET_FPS_RANGE' in main and 'STRATEGY_KEEP_ONLY_LATEST' in main
assert '设备拒绝显式高帧率请求' in main and 'fallbackAnalysis' in main assert '设备拒绝显式高帧率请求' in main and 'fallbackAnalysis' in main
@@ -34,4 +55,4 @@ assert 'row.translationY' in main and 'container.removeView(row)' not in main
assert 'BB8' in base45 or 'ALPHABET' in base45 assert 'BB8' in base45 or 'ALPHABET' in base45
all_kotlin='\n'.join(path.read_text() for path in (ROOT/'android/app/src/main/java/com/qft/optical').glob('*.kt')) all_kotlin='\n'.join(path.read_text() for path in (ROOT/'android/app/src/main/java/com/qft/optical').glob('*.kt'))
assert 'java.util.Base64' not in all_kotlin assert 'java.util.Base64' not in all_kotlin
print('PASS Android static guards: API24+, fast-pair/subnet discovery, crash-safe sortable upload queue, QFT2/Base45, dynamic lock/refocus, legacy/new Wi-Fi compatibility') print('PASS Android static guards: API24+, Android-to-Android hotspot/LAN queue transfer, fast-pair/subnet discovery, crash-safe sortable queue, QFT2/Base45, legacy/new Wi-Fi compatibility')
+55
View File
@@ -0,0 +1,55 @@
#!/usr/bin/env python3
"""Protocol/security guards for Android → Android v0.5 phone sharing."""
from pathlib import Path
import base64
import hashlib
import json
ROOT = Path(__file__).resolve().parents[1]
pairing = (ROOT / "android/app/src/main/java/com/qft/optical/PairingProtocol.kt").read_text()
server = (ROOT / "android/app/src/main/java/com/qft/optical/PhoneShareServer.kt").read_text()
download = (ROOT / "android/app/src/main/java/com/qft/optical/DownloadClient.kt").read_text()
layout = (ROOT / "android/app/src/main/java/com/qft/optical/PhoneQrLayout.kt").read_text()
session = base64.urlsafe_b64encode(bytes(range(24))).decode().rstrip("=")
payload = {
"v": 2,
"s": session,
"n": "Android Sender",
"p": 41888,
"d": "m",
"w": ["QFT-Android", "0123456789abcdef", "WPA2"],
}
qr = "QFTPHONE2:" + base64.urlsafe_b64encode(
json.dumps(payload, separators=(",", ":")).encode()
).decode().rstrip("=")
assert len(qr) < 300, len(qr)
blob = b"android-to-android-range-test" * 1000
sha = hashlib.sha256(blob).hexdigest()
manifest = {
"v": 2,
"files": [
{"name": "sample.bin", "size": len(blob), "sha256": sha, "path": "/qft/phone/download/0"}
],
}
assert manifest["files"][0]["path"] == "/qft/phone/download/0"
rebuilt = bytearray(len(blob))
ranges = [(len(blob) // 2, len(blob)), (0, len(blob) // 3), (len(blob) // 3, len(blob) // 2)]
for start, end in ranges:
rebuilt[start:end] = blob[start:end]
assert bytes(rebuilt) == blob
assert hashlib.sha256(rebuilt).hexdigest() == sha
assert 'const val PREFIX_PHONE_V2 = "QFTPHONE2:"' in pairing
assert '"m" -> TransferDirection.PHONE_TO_PHONE' in pairing
assert 'require(item.getString("path") == expectedPath)' in server
assert 'headers["x-qft-token"] != session' in server
assert 'phoneShareSha256Exact' in server and 'require(input.read() < 0)' in server
assert 'Range: bytes=<start>-<end>' not in server # implementation, not documentation placeholder
assert 'baseUrl + pairing.downloadPath' in download
assert 'digest(downloadPath.toByteArray' in download
assert 'windowWidthPx - horizontalPagePadding' in layout
assert 'windowHeightPx - nonQrVerticalUi' in layout
assert 'min(widthLimit, heightLimit)' in layout
print(f"PASS Android phone share: compact QR={len(qr)} chars, authenticated fixed manifest paths, per-file partial isolation, SHA-256={sha[:12]}…")
+1
View File
@@ -8,6 +8,7 @@ scripts = [
'pairing_selftest.py', 'pairing_selftest.py',
'parallel_upload_selftest.py', 'parallel_upload_selftest.py',
'parallel_download_selftest.py', 'parallel_download_selftest.py',
'phone_share_selftest.py',
'udp_discovery_selftest.py', 'udp_discovery_selftest.py',
'local_transfer_integration_selftest.py', 'local_transfer_integration_selftest.py',
'memory_budget_selftest.py', 'memory_budget_selftest.py',