优化IOS

This commit is contained in:
zhy200308
2026-08-19 09:31:21 +08:00
parent 7023062b45
commit eae24000e9
29 changed files with 4025 additions and 377 deletions
+206 -109
View File
@@ -5,10 +5,11 @@ import CryptoKit
/// 点对点链路:Bonjour 发现 + TLS-PSK 加密 + 长度前缀分帧。
///
/// `includePeerToPeer = true` 让 Network.framework 在没有路由器时
/// 自动使用 BLE 发现 + AWDL 点对点 Wi-Fi,也就是 AirDrop 用的同一条链路。
/// 自动使用 BLE 发现 + AWDL 点对点 Wi-Fi,也就是隔空投送用的同一条链路。
/// 两台设备在同一个 Wi-Fi 下时它会优先走基础网络,速度同样很快。
///
/// AWDL 是苹果私有链路,Windows 无法参与——PC 方向仍走 HTTP 局域网路径。
/// AWDL 是苹果私有链路,Windows 无法参与——PC 方向仍走 HTTP
/// 局域网/专用网络路径。
enum PeerLink {
static let frameHeaderSize = 5 // 1 字节类型 + 4 字节 BE 长度
@@ -16,10 +17,13 @@ enum PeerLink {
static let maxFrameSize = 4 * 1024 * 1024
enum FrameType: UInt8 {
case manifest = 1
/// 文件清单(JSON)。整个队列只发一次,摘要必须与二维码一致。
case queue = 1
case data = 2
case eof = 3
case result = 4
case fileBegin = 5
case fileEnd = 6
}
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) {
let header = try await receiveExactly(connection, count: frameHeaderSize)
guard let type = FrameType(rawValue: header[header.startIndex]) else {
throw PeerError.protocolViolation("未知帧类型 \(header[header.startIndex])")
}
let length = header[(header.startIndex + 1)...].withUnsafeBytes {
UInt32(bigEndian: $0.loadUnaligned(as: UInt32.self))
}
// 手工拼大端,不用 loadUnaligned:那个 API 要 Swift 5.7 运行时(iOS 16),
// 而这个 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 {
throw PeerError.protocolViolation("帧长度 \(length) 超出上限")
}
@@ -122,7 +134,7 @@ enum PeerLink {
timeout: TimeInterval = 15) async throws {
try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
let resumed = Locked(false)
func finish(_ error: Error?) {
@Sendable func finish(_ error: Error?) {
guard resumed.exchange(true) == false else { return }
if let error { continuation.resume(throwing: error) } else { continuation.resume() }
}
@@ -154,7 +166,7 @@ enum PeerLink {
/// 极简互斥包装。continuation 只能 resume 一次,而 stateUpdateHandler
/// 可能在多个状态里触发,需要一个原子的「是否已 resume」。
final class Locked<Value> {
final class Locked<Value>: @unchecked Sendable {
private var value: Value
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: - 发送端
/// 展示二维码的一方。持有文件,等待对方扫码后连入。
/// 展示二维码的一方。持有一个文件队列,等待对方扫码后连入。
final class PeerSender {
/// 监听器的状态与排队中的连接。stateUpdateHandler / newConnectionHandler
/// 在任意线程触发,而等待方是 async,所以两边都要经过这把锁。
private final class Box {
private final class Box: @unchecked Sendable {
let lock = NSLock()
var readyPort: UInt16?
var failure: Error?
@@ -197,15 +217,17 @@ final class PeerSender {
}
}
private let fileURL: URL
private let fileURLs: [URL]
private let deviceName: String
private let queue = DispatchQueue(label: "qft.peer.sender")
private let box = Box()
private var listener: NWListener?
private var pairing: PeerPairing?
private var files: [PeerFileMeta] = []
private var queuePayload = Data()
init(fileURL: URL, deviceName: String) {
self.fileURL = fileURL
init(fileURLs: [URL], deviceName: String) {
self.fileURLs = fileURLs
self.deviceName = deviceName
}
@@ -225,27 +247,46 @@ final class PeerSender {
}
}
/// 计算文件摘要、启动监听并广播 Bonjour 服务,返回要显示成二维码的配对码。
/// 逐个算摘要、启动监听并广播 Bonjour 服务,返回要显示成二维码的配对码。
/// 会完整读一遍每个文件,调用方应放到后台线程。
func start() throws -> PeerPairing {
let attributes = try FileManager.default.attributesOfItem(atPath: fileURL.path)
let size = UInt64(truncating: (attributes[.size] as? NSNumber) ?? 0)
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)
guard !fileURLs.isEmpty else {
throw PeerLink.PeerError.protocolViolation("没有选择任何文件")
}
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(
version: 1,
version: 2,
key: PeerPairing.newKey(),
instance: PeerPairing.newInstance(),
senderName: deviceName,
fileName: fileURL.lastPathComponent,
fileSize: size,
sha256: digest)
fileCount: metas.count,
totalSize: total,
queueDigest: PeerQueue.digest(of: payload),
previewName: metas[0].name)
let parameters = PeerLink.parameters(key: pairing.key, identity: pairing.instance)
let listener = try NWListener(using: parameters)
@@ -290,11 +331,13 @@ final class PeerSender {
self.listener = listener
self.pairing = pairing
self.files = metas
self.queuePayload = payload
return pairing
}
/// 等待一个连接并把文件推过去。
func waitAndSend(onProgress: @escaping (TransferProgress) -> Void) async throws {
/// 等待一个连接并把整个队列推过去。
func waitAndSend(onProgress: @escaping (PeerTransferUpdate) -> Void) async throws {
guard let listener, let pairing else {
throw PeerLink.PeerError.handshake("尚未调用 start()")
}
@@ -320,34 +363,44 @@ final class PeerSender {
defer { connection.cancel(); listener.cancel() }
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
let startedAt = Date()
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 await PeerLink.send(connection, type: .data, payload: block)
sent &+= UInt64(block.count)
let now = Date()
if now.timeIntervalSince(lastReport) > 0.1 || sent >= pairing.fileSize {
lastReport = now
onProgress(TransferProgress(
completed: sent, total: pairing.fileSize,
bytesPerSecond: Double(sent) / max(0.001, now.timeIntervalSince(startedAt))))
try await PeerLink.sendJSON(connection, type: .fileBegin,
object: ["i": index, "name": meta.name])
let handle = try FileHandle(forReadingFrom: fileURLs[index])
defer { try? handle.close() }
var fileSent: UInt64 = 0
while let block = try handle.read(upToCount: PeerLink.chunkSize), !block.isEmpty {
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())
let (type, payload) = try await PeerLink.receiveFrame(connection)
@@ -368,7 +421,7 @@ final class PeerSender {
// MARK: - 接收端
/// 扫码的一方。按实例名找到对端并接收文件。
/// 扫码的一方。按实例名找到对端并按顺序接收整个队列。
struct PeerReceiver {
let pairing: PeerPairing
@@ -376,7 +429,7 @@ struct PeerReceiver {
/// 测试用:跳过 Bonjour,直接连指定端口。
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 parameters = PeerLink.parameters(key: pairing.key, identity: pairing.instance)
@@ -392,78 +445,122 @@ struct PeerReceiver {
defer { connection.cancel() }
try await PeerLink.waitReady(connection, queue: queue)
// --- 清单 ---
let (manifestType, manifestPayload) = try await PeerLink.receiveFrame(connection)
guard manifestType == .manifest,
let manifest = try? JSONSerialization.jsonObject(with: manifestPayload) as? [String: Any],
let declaredSize = (manifest["size"] as? NSNumber)?.uint64Value,
let declaredHash = manifest["sha256"] as? String else {
throw PeerLink.PeerError.protocolViolation("清单帧无效")
do {
let saved = try await receiveQueue(connection, onProgress: onProgress)
try await PeerLink.sendJSON(connection, type: .result,
object: ["ok": true, "saved": saved.map(\.lastPathComponent)])
return saved
} catch {
// 让发送端知道为什么停了,而不是收到一个无解释的断连
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(
#"{"ok":false,"error":"manifest mismatch"}"#.utf8))
throw PeerLink.PeerError.protocolViolation("对方声明的文件与二维码不符")
}
private func receiveQueue(_ connection: NWConnection,
onProgress: @escaping (PeerTransferUpdate) -> Void) async throws -> [URL] {
// --- 清单 ---
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,
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 received: UInt64 = 0
var saved: [URL] = []
var receivedTotal: UInt64 = 0
let startedAt = Date()
var lastReport = Date.distantPast
// --- 数据 ---
do {
loop: while true {
try Task.checkCancellation()
let (type, payload) = try await PeerLink.receiveFrame(connection)
switch type {
case .data:
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)")
}
for (index, meta) in files.enumerated() {
try Task.checkCancellation()
let (beginType, beginPayload) = try await PeerLink.receiveFrame(connection)
guard beginType == .fileBegin,
let begin = try? JSONSerialization.jsonObject(with: beginPayload) as? [String: Any],
(begin["i"] as? Int) == index else {
throw PeerLink.PeerError.protocolViolation("第 \(index + 1) 个文件的起始帧无效")
}
try handle.close()
} catch {
try? handle.close()
let partURL = destinationDirectory.appendingPathComponent(meta.name + ".qftpart")
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 actual = hasher.finalize().map { String(format: "%02x", $0) }.joined()
guard received == pairing.fileSize, actual == pairing.sha256 else {
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 ? "一致" : "不一致")")
let (eofType, _) = try await PeerLink.receiveFrame(connection)
guard eofType == .eof else {
throw PeerLink.PeerError.protocolViolation("队列结束帧无效")
}
return saved
}
let finalURL = DownloadClient.uniqueURL(in: destinationDirectory, name: pairing.fileName)
try FileManager.default.moveItem(at: partURL, to: finalURL)
try await PeerLink.send(connection, type: .result, payload: Data(#"{"ok":true}"#.utf8))
return finalURL
private func errorText(_ error: Error) -> String {
String(((error as? LocalizedError)?.errorDescription ?? "\(error)").prefix(200))
}
}