Files
QFT/ios/QFT/Core/UploadClient.swift
T
zhy200308 4d77ba6c91 feat: 新增 iPhone 客户端,含隔空投送式点对点互传
三条链路:
- 电脑 → iPhone:扫 QFTSEND2 码下载,流式落盘 + 增量 SHA-256,
  支持 Range 断点续传
- iPhone → 电脑:扫 QFTPAIR2 码后 init/chunk/finish 并行分块上传
- iPhone ↔ iPhone:QFTP2P1 扫码握手,Network.framework 开启
  includePeerToPeer(AirDrop 同款 BLE 发现 + AWDL 点对点 Wi-Fi),
  两台设备不需要连同一个 Wi-Fi,也不需要路由器

P2P 用 TLS-PSK 握手:32 字节预共享密钥由发送端随机生成并写进二维码,
扫码这个动作本身完成带外密钥交换与双向认证,无需证书体系与配对弹窗。
未扫到码的第三方连上来过不了握手。

核心层刻意不 import UIKit,可直接以 macOS 为目标编译测试,
不需要 Xcode 也不需要模拟器,已接入主自检套件,72 项全部通过:
- 端点白名单 11 种拒绝用例(域名、公网、172.32 边界、
  非规范八位组、IPv6、带凭据/路径/query)
- CoreTests/MockPCServer.py 严格复刻 receiver.rs / sender.rs 的线上语义
  (路径、header 名、JSON 字段、Range 行为、chunk 长度校验),
  构成 Swift 与 Rust 两端的线格式契约测试,任一端改协议即会失败
- 真实 TLS-PSK 握手下的 P2P 端到端传输,含错误密钥必须被拒

iOS 平台限制(已在 ios/README.md 说明):
NEHotspotConfiguration 需要付费账号 entitlement,故不实现 Direct AP
流程,与电脑互传要求同一局域网;AWDL 是苹果私有链路,Windows 无法参与。
上传块固定 4 MiB 而非 Android 的 4/8/16 MiB,因为 iOS 上
worker 数 × 块大小即内存峰值。

未验证部分:本机只有 Command Line Tools,无 Xcode 与 iOS SDK,
UI 层(SwiftUI/UIKit/AVFoundation)未经编译;.xcodeproj 已通过
plutil 解析与引用完整性校验(42 个对象无悬空引用),
但未在 Xcode 中实际打开过。
2026-08-11 09:08:37 +08:00

190 lines
7.9 KiB
Swift
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import Foundation
/// 手机 → 电脑并行上传(QFTPAIR2)。
///
/// 与 Android 端同一套 v2 流程:init → 并行 chunk → finish。
/// Windows 端 `receiver.rs` 会预分配 `.qftpart`、按 offset 定位写入、
/// 校验 SHA-256 后 rename,因此 chunk 之间没有顺序要求,重复 chunk 也是幂等的。
///
/// 与 Android 的唯一差异是**块大小固定 4 MiB**:Android 会按文件大小选 4/8/16 MiB,
/// 但 iOS 上 `workers × chunkSize` 就是内存峰值,16 MiB × 6 会在旧机型上触发
/// jetsam。4 MiB × 6 = 24 MiB 峰值,在局域网速度下每块的往返开销可以忽略。
struct UploadClient {
let host: QFTHost
let pairing: PairingPayload
let deviceName: String
static let chunkSize: UInt64 = 4 * 1024 * 1024
static let maxWorkers = 6
struct Session {
let uploadID: String
let chunkSize: UInt64
let totalChunks: Int
}
func run(fileURL: URL, onProgress: @escaping (TransferProgress) -> Void) async throws -> String {
let attributes = try FileManager.default.attributesOfItem(atPath: fileURL.path)
let size = UInt64(truncating: (attributes[.size] as? NSNumber) ?? 0)
let name = fileURL.lastPathComponent
let session = try await initUpload(name: name, size: size)
if session.totalChunks == 0 {
return try await finishUpload(session)
}
let counter = ByteCounter(total: size, onProgress: onProgress)
let queue = IndexQueue(count: session.totalChunks)
try await withThrowingTaskGroup(of: Void.self) { group in
let workers = min(session.totalChunks, Self.maxWorkers)
for _ in 0..<workers {
group.addTask {
let handle = try FileHandle(forReadingFrom: fileURL)
defer { try? handle.close() }
while let index = await queue.next() {
try Task.checkCancellation()
let offset = UInt64(index) * session.chunkSize
let length = min(session.chunkSize, size - offset)
try handle.seek(toOffset: offset)
let body = try handle.read(upToCount: Int(length)) ?? Data()
guard UInt64(body.count) == length else {
throw QFTError.integrity("读取本地文件第 \(index) 块失败")
}
try await uploadChunk(session, index: index, body: body)
await counter.add(length)
}
}
}
try await group.waitForAll()
}
return try await finishUpload(session)
}
// MARK: - 三个端点
private func initUpload(name: String, size: UInt64) async throws -> Session {
var request = try makeRequest(path: "/qft/upload/init")
request.setValue(Base64URL.encode(name), forHTTPHeaderField: "X-QFT-Filename")
request.setValue(String(size), forHTTPHeaderField: "X-QFT-Size")
request.setValue(String(Self.chunkSize), forHTTPHeaderField: "X-QFT-Chunk-Size")
request.setValue("0", forHTTPHeaderField: "Content-Length")
let object = try await sendJSON(request, body: Data())
guard let uploadID = object["upload_id"] as? String, !uploadID.isEmpty,
let chunkSize = (object["chunk_size"] as? NSNumber)?.uint64Value, chunkSize > 0,
let totalChunks = (object["total_chunks"] as? NSNumber)?.intValue, totalChunks >= 0 else {
throw QFTError.malformedResponse("init 响应缺少字段")
}
return Session(uploadID: uploadID, chunkSize: chunkSize, totalChunks: totalChunks)
}
private func uploadChunk(_ session: Session, index: Int, body: Data) async throws {
var request = try makeRequest(path: "/qft/upload/chunk/\(session.uploadID)/\(index)")
request.setValue(String(body.count), forHTTPHeaderField: "Content-Length")
// 重复的 chunk 在接收端是幂等的,因此重试是安全的。
// Wi-Fi 漫游或 Windows 防火墙首次放行都可能吃掉第一次请求。
var lastError: Error = QFTError.malformedResponse("未知错误")
for attempt in 0..<3 {
do {
_ = try await sendJSON(request, body: body)
return
} catch {
lastError = error
if case QFTError.httpStatus(let code, _) = error, code == 403 || code == 404 { throw error }
try? await Task.sleep(nanoseconds: UInt64(120_000_000 << attempt))
}
}
throw lastError
}
private func finishUpload(_ session: Session) async throws -> String {
var request = try makeRequest(path: "/qft/upload/finish/\(session.uploadID)")
request.setValue("0", forHTTPHeaderField: "Content-Length")
let object = try await sendJSON(request, body: Data())
guard let sha = object["sha256"] as? String else {
throw QFTError.malformedResponse("finish 响应缺少 sha256")
}
return sha
}
// MARK: - HTTP
private func makeRequest(path: String) throws -> URLRequest {
guard let url = URL(string: host.baseURL + path) else {
throw QFTError.malformedResponse("上传地址无效:\(path)")
}
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.timeoutInterval = 60
request.setValue(pairing.session, forHTTPHeaderField: "X-QFT-Token")
request.setValue(Base64URL.encode(deviceName), forHTTPHeaderField: "X-QFT-Device")
request.setValue("application/octet-stream", forHTTPHeaderField: "Content-Type")
return request
}
private func sendJSON(_ request: URLRequest, body: Data) async throws -> [String: Any] {
let configuration = URLSessionConfiguration.ephemeral
configuration.timeoutIntervalForRequest = request.timeoutInterval
let urlSession = URLSession(configuration: configuration)
defer { urlSession.finishTasksAndInvalidate() }
let (data, response) = try await urlSession.upload(for: request, from: body)
guard let http = response as? HTTPURLResponse else {
throw QFTError.malformedResponse("非 HTTP 响应")
}
guard http.statusCode == 200 else {
let detail = String(data: data.prefix(200), encoding: .utf8) ?? ""
throw QFTError.httpStatus(http.statusCode, detail)
}
guard let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
throw QFTError.malformedResponse("响应不是 JSON")
}
if let ok = object["ok"] as? Bool, ok == false {
throw QFTError.malformedResponse("电脑拒绝了请求:\(object)")
}
return object
}
}
/// 分发块序号。
actor IndexQueue {
private var current = 0
private let count: Int
init(count: Int) { self.count = count }
func next() -> Int? {
guard current < count else { return nil }
defer { current += 1 }
return current
}
}
/// 汇总各 worker 的已传字节并限频回调。
actor ByteCounter {
private var completed: UInt64 = 0
private let total: UInt64
private let startedAt = Date()
private var lastReport = Date.distantPast
private let onProgress: (TransferProgress) -> Void
init(total: UInt64, onProgress: @escaping (TransferProgress) -> Void) {
self.total = total
self.onProgress = onProgress
}
func add(_ bytes: UInt64) {
completed &+= bytes
let now = Date()
guard now.timeIntervalSince(lastReport) > 0.1 || completed >= total else { return }
lastReport = now
let elapsed = max(0.001, now.timeIntervalSince(startedAt))
onProgress(TransferProgress(completed: completed, total: total,
bytesPerSecond: Double(completed) / elapsed))
}
}