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 中实际打开过。
This commit is contained in:
zhy200308
2026-08-11 09:08:37 +08:00
parent ea7b678b37
commit 4d77ba6c91
25 changed files with 3633 additions and 0 deletions
+197
View File
@@ -0,0 +1,197 @@
import SwiftUI
import UniformTypeIdentifiers
struct HomeView: View {
/// 同一个 view 上挂多个 .fileImporter 会互相覆盖,只能有一个,
/// 所以用这个枚举区分「选完文件之后要干什么」。
private enum PickPurpose: Equatable {
case peerSend
case uploadToPC(PairingPayload)
}
@StateObject private var model = TransferModel()
@State private var pickPurpose: PickPurpose?
var body: some View {
NavigationStack {
content
.navigationTitle("QFT 快传")
.navigationBarTitleDisplayMode(.inline)
}
.fullScreenCover(isPresented: isScanning) {
ScannerView(onFound: { model.handleScanned($0) }, onCancel: { model.cancel() })
.ignoresSafeArea()
}
.fileImporter(isPresented: isPicking,
allowedContentTypes: [UTType.item], allowsMultipleSelection: false) { result in
let purpose = pickPurpose
pickPurpose = nil
guard case .success(let urls) = result, let url = urls.first else {
model.reset()
return
}
switch purpose {
case .peerSend: model.startPeerSend(fileURL: url)
case .uploadToPC(let pairing): model.startUpload(pairing, fileURL: url)
case nil: break
}
}
.onAppear { model.refreshReceivedFiles() }
.onChange(of: model.stage) { _, stage in
// 扫到 QFTPAIR2 之后才知道要选文件,所以选择器由 stage 驱动
if case .pickFileForUpload(let pairing) = stage {
pickPurpose = .uploadToPC(pairing)
}
}
}
private var isScanning: Binding<Bool> {
Binding(get: { model.stage == .scanning }, set: { if !$0 { model.cancel() } })
}
private var isPicking: Binding<Bool> {
Binding(get: { pickPurpose != nil }, set: { if !$0 { pickPurpose = nil } })
}
@ViewBuilder
private var content: some View {
switch model.stage {
case .idle, .scanning, .pickFileForUpload:
landing
case .connecting(let message):
StatusCard(icon: "antenna.radiowaves.left.and.right", title: message) {
ProgressView()
Button("取消", role: .cancel) { model.cancel() }
}
case .running(let message):
StatusCard(icon: "arrow.left.arrow.right", title: message) {
if let progress = model.progress {
ProgressView(value: progress.fraction)
Text("\(progress.readableSize) · \(progress.readableRate)")
.font(.footnote.monospacedDigit())
.foregroundStyle(.secondary)
} else {
ProgressView()
}
Button("取消", role: .cancel) { model.cancel() }
}
case .showingPeerCode(let pairing):
peerCode(pairing)
case .finished(let message, let url):
StatusCard(icon: "checkmark.circle.fill", title: message) {
if let url {
Text(url.lastPathComponent).font(.footnote).foregroundStyle(.secondary)
ShareLink(item: url) { Label("分享", systemImage: "square.and.arrow.up") }
}
Button("完成") { model.reset() }.buttonStyle(.borderedProminent)
}
case .failed(let message):
StatusCard(icon: "exclamationmark.triangle.fill", title: "传输失败") {
Text(message).font(.footnote).multilineTextAlignment(.center)
.foregroundStyle(.secondary)
Button("返回") { model.reset() }.buttonStyle(.borderedProminent)
}
}
}
private var landing: some View {
List {
Section {
ActionRow(icon: "qrcode.viewfinder", title: "扫码",
detail: "扫电脑上的二维码收发文件,或扫另一台 iPhone 的码接收") {
model.beginScan()
}
ActionRow(icon: "iphone.gen3.radiowaves.left.and.right", title: "发给附近的 iPhone",
detail: "选文件后显示二维码,对方扫一下即可,无需连同一个 Wi-Fi") {
pickPurpose = .peerSend
}
} footer: {
Text("与电脑互传需要手机和电脑连在同一个 Wi-Fi。iPhone 之间使用点对点直连,不经过路由器。")
}
if !model.receivedFiles.isEmpty {
Section("已接收") {
ForEach(model.receivedFiles, id: \.self) { url in
ShareLink(item: url) {
Label(url.lastPathComponent, systemImage: "doc")
.lineLimit(1)
}
}
}
}
}
}
private func peerCode(_ pairing: PeerPairing) -> some View {
VStack(spacing: 20) {
Text("让对方用 QFT 扫这个码")
.font(.headline)
if let image = QRRenderer.image(from: pairing.encode()) {
Image(uiImage: image)
.interpolation(.none)
.resizable()
.scaledToFit()
.frame(maxWidth: 300)
.padding()
.background(.white)
.clipShape(RoundedRectangle(cornerRadius: 16))
}
VStack(spacing: 4) {
Text(pairing.fileName).font(.subheadline).lineLimit(1)
Text(TransferProgress.readable(pairing.fileSize))
.font(.footnote).foregroundStyle(.secondary)
}
if let progress = model.progress {
ProgressView(value: progress.fraction)
.padding(.horizontal, 40)
Text("\(progress.readableSize) · \(progress.readableRate)")
.font(.footnote.monospacedDigit()).foregroundStyle(.secondary)
} else {
Label("等待对方扫码…", systemImage: "hourglass")
.font(.footnote).foregroundStyle(.secondary)
}
Button("取消", role: .cancel) { model.cancel() }
}
.padding()
}
}
private struct ActionRow: View {
let icon: String
let title: String
let detail: String
let action: () -> Void
var body: some View {
Button(action: action) {
HStack(spacing: 14) {
Image(systemName: icon)
.font(.title2)
.frame(width: 34)
VStack(alignment: .leading, spacing: 3) {
Text(title).font(.body.weight(.medium))
Text(detail).font(.caption).foregroundStyle(.secondary)
}
}
.padding(.vertical, 4)
}
.buttonStyle(.plain)
}
}
private struct StatusCard<Content: View>: View {
let icon: String
let title: String
@ViewBuilder let content: Content
var body: some View {
VStack(spacing: 18) {
Image(systemName: icon).font(.system(size: 44))
Text(title).font(.headline).multilineTextAlignment(.center)
content
}
.padding(32)
.frame(maxWidth: .infinity, maxHeight: .infinity)
}
}
+10
View File
@@ -0,0 +1,10 @@
import SwiftUI
@main
struct QFTApp: App {
var body: some Scene {
WindowGroup {
HomeView()
}
}
}
+137
View File
@@ -0,0 +1,137 @@
import SwiftUI
import AVFoundation
/// 二维码扫描。用 AVCaptureMetadataOutput 而不是 Vision:
/// 硬件解码路径延迟更低,而且这里只需要识别静态配对码,
/// 不需要 QFT2 光学链路那套 ROI 锁定与高频解码。
struct ScannerView: UIViewControllerRepresentable {
/// 只在识别到我们认识的前缀时回调,且只回调一次。
let onFound: (String) -> Void
let onCancel: () -> Void
func makeCoordinator() -> Coordinator { Coordinator(onFound: onFound) }
func makeUIViewController(context: Context) -> ScannerController {
let controller = ScannerController()
controller.coordinator = context.coordinator
controller.onCancel = onCancel
return controller
}
func updateUIViewController(_ controller: ScannerController, context: Context) {}
final class Coordinator: NSObject, AVCaptureMetadataOutputObjectsDelegate {
private let onFound: (String) -> Void
private var consumed = false
init(onFound: @escaping (String) -> Void) { self.onFound = onFound }
func metadataOutput(_ output: AVCaptureMetadataOutput,
didOutput objects: [AVMetadataObject],
from connection: AVCaptureConnection) {
guard !consumed else { return }
for object in objects {
guard let readable = object as? AVMetadataMachineReadableCodeObject,
readable.type == .qr, let text = readable.stringValue else { continue }
guard PairingProtocol.isPairingText(text) || PeerPairing.isPeerText(text) else { continue }
consumed = true
UINotificationFeedbackGenerator().notificationOccurred(.success)
DispatchQueue.main.async { self.onFound(text) }
return
}
}
}
}
final class ScannerController: UIViewController {
var coordinator: ScannerView.Coordinator?
var onCancel: (() -> Void)?
private let session = AVCaptureSession()
private var preview: AVCaptureVideoPreviewLayer?
private let hintLabel = UILabel()
override func viewDidLoad() {
super.viewDidLoad()
view.backgroundColor = .black
configureSession()
configureOverlay()
}
private func configureSession() {
guard let device = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .back),
let input = try? AVCaptureDeviceInput(device: device),
session.canAddInput(input) else {
showFailure("无法打开相机")
return
}
session.addInput(input)
let output = AVCaptureMetadataOutput()
guard session.canAddOutput(output) else {
showFailure("无法启动二维码识别")
return
}
session.addOutput(output)
output.setMetadataObjectsDelegate(coordinator, queue: .main)
output.metadataObjectTypes = [.qr]
let layer = AVCaptureVideoPreviewLayer(session: session)
layer.videoGravity = .resizeAspectFill
layer.frame = view.bounds
view.layer.insertSublayer(layer, at: 0)
preview = layer
}
private func configureOverlay() {
hintLabel.text = "对准电脑或另一台 iPhone 上的二维码"
hintLabel.textColor = .white
hintLabel.font = .systemFont(ofSize: 15, weight: .medium)
hintLabel.textAlignment = .center
hintLabel.numberOfLines = 0
hintLabel.translatesAutoresizingMaskIntoConstraints = false
view.addSubview(hintLabel)
let cancel = UIButton(type: .system)
cancel.setTitle("取消", for: .normal)
cancel.setTitleColor(.white, for: .normal)
cancel.titleLabel?.font = .systemFont(ofSize: 17, weight: .semibold)
cancel.addTarget(self, action: #selector(cancelTapped), for: .touchUpInside)
cancel.translatesAutoresizingMaskIntoConstraints = false
view.addSubview(cancel)
NSLayoutConstraint.activate([
hintLabel.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 32),
hintLabel.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -32),
hintLabel.bottomAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor, constant: -96),
cancel.centerXAnchor.constraint(equalTo: view.centerXAnchor),
cancel.bottomAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor, constant: -32),
])
}
@objc private func cancelTapped() { onCancel?() }
private func showFailure(_ message: String) {
hintLabel.text = message
}
override func viewWillAppear(_ animated: Bool) {
super.viewWillAppear(animated)
guard !session.isRunning else { return }
// startRunning 会阻塞,必须离开主线程
DispatchQueue.global(qos: .userInitiated).async { [session] in session.startRunning() }
}
override func viewWillDisappear(_ animated: Bool) {
super.viewWillDisappear(animated)
guard session.isRunning else { return }
DispatchQueue.global(qos: .userInitiated).async { [session] in session.stopRunning() }
}
override func viewDidLayoutSubviews() {
super.viewDidLayoutSubviews()
preview?.frame = view.bounds
}
}
+242
View File
@@ -0,0 +1,242 @@
import SwiftUI
import CoreImage.CIFilterBuiltins
@MainActor
final class TransferModel: ObservableObject {
enum Stage: Equatable {
case idle
case scanning
/// 扫到 QFTPAIR2:需要用户挑一个文件传给电脑
case pickFileForUpload(PairingPayload)
case connecting(String)
case running(String)
case showingPeerCode(PeerPairing)
case finished(String, URL?)
case failed(String)
}
@Published private(set) var stage: Stage = .idle
@Published private(set) var progress: TransferProgress?
@Published private(set) var receivedFiles: [URL] = []
private var task: Task<Void, Never>?
private var sender: PeerSender?
private var scopedURL: URL?
private let deviceName = DeviceInfo.name
// MARK: - 入口
func beginScan() { stage = .scanning }
func cancel() {
task?.cancel()
task = nil
sender?.stop()
sender = nil
releaseScope()
progress = nil
stage = .idle
}
func reset() {
progress = nil
stage = .idle
refreshReceivedFiles()
}
/// 扫到码之后的统一分发
func handleScanned(_ text: String) {
if let peer = PeerPairing.parse(text) {
startPeerReceive(peer)
return
}
guard let pairing = PairingProtocol.parse(text) else {
stage = .failed("这不是 QFT 的二维码,或二维码里的地址不是局域网地址。")
return
}
switch pairing.direction {
case .downloadToPhone: startDownload(pairing)
case .uploadToPC: stage = .pickFileForUpload(pairing)
}
}
// MARK: - 电脑 → 手机
private func startDownload(_ pairing: PairingPayload) {
stage = .connecting("正在找 \(pairing.pcName)…")
task = Task {
do {
let host = try await HostDiscovery(pairing: pairing, deviceName: deviceName).locate()
guard !Task.isCancelled else { return }
stage = .running("正在从 \(pairing.pcName) 接收 \(pairing.fileName ?? "文件")")
let client = DownloadClient(host: host, pairing: pairing, deviceName: deviceName)
let saved = try await client.run { [weak self] value in
Task { @MainActor in self?.progress = value }
}
finish("已保存到「文件」App 的 QFT 文件夹", saved)
} catch {
fail(error)
}
}
}
// MARK: - 手机 → 电脑
func startUpload(_ pairing: PairingPayload, fileURL: URL) {
guard claimScope(fileURL) else {
stage = .failed("没有权限读取这个文件,请换一个位置再试。")
return
}
stage = .connecting("正在找 \(pairing.pcName)…")
task = Task {
defer { releaseScope() }
do {
let host = try await HostDiscovery(pairing: pairing, deviceName: deviceName).locate()
guard !Task.isCancelled else { return }
stage = .running("正在发送 \(fileURL.lastPathComponent) 到 \(pairing.pcName)")
let client = UploadClient(host: host, pairing: pairing, deviceName: deviceName)
_ = try await client.run(fileURL: fileURL) { [weak self] value in
Task { @MainActor in self?.progress = value }
}
finish("已发送到 \(pairing.pcName)", nil)
} catch {
fail(error)
}
}
}
// MARK: - iPhone ↔ iPhone(隔空投送式)
func startPeerSend(fileURL: URL) {
guard claimScope(fileURL) else {
stage = .failed("没有权限读取这个文件,请换一个位置再试。")
return
}
stage = .connecting("正在准备…")
task = Task {
defer { releaseScope() }
do {
let sender = PeerSender(fileURL: fileURL, deviceName: deviceName)
// start() 里要完整读一遍文件算摘要,别卡住主线程
let pairing = try await Task.detached { try sender.start() }.value
guard !Task.isCancelled else { sender.stop(); return }
self.sender = sender
stage = .showingPeerCode(pairing)
try await sender.waitAndSend { [weak self] value in
Task { @MainActor in self?.progress = value }
}
finish("已发送给对方", nil)
} catch {
fail(error)
}
sender?.stop()
sender = nil
}
}
private func startPeerReceive(_ pairing: PeerPairing) {
stage = .connecting("正在连接 \(pairing.senderName)…")
task = Task {
do {
let directory = try DownloadClient.defaultDestinationDirectory()
let receiver = PeerReceiver(pairing: pairing, destinationDirectory: directory)
stage = .running("正在接收 \(pairing.fileName)")
let saved = try await receiver.run { [weak self] value in
Task { @MainActor in self?.progress = value }
}
finish("已保存到「文件」App 的 QFT 文件夹", saved)
} catch {
fail(error)
}
}
}
// MARK: - 收尾
private func finish(_ message: String, _ url: URL?) {
progress = nil
stage = .finished(message, url)
refreshReceivedFiles()
}
private func fail(_ error: Error) {
guard !(error is CancellationError) else { return }
progress = nil
stage = .failed(error.localizedDescription)
}
func refreshReceivedFiles() {
guard let directory = try? DownloadClient.defaultDestinationDirectory(),
let entries = try? FileManager.default.contentsOfDirectory(
at: directory, includingPropertiesForKeys: [.contentModificationDateKey]) else {
receivedFiles = []
return
}
receivedFiles = entries
.filter { $0.pathExtension != "qftpart" }
.sorted { lhs, rhs in
let l = (try? lhs.resourceValues(forKeys: [.contentModificationDateKey]))?
.contentModificationDate ?? .distantPast
let r = (try? rhs.resourceValues(forKeys: [.contentModificationDateKey]))?
.contentModificationDate ?? .distantPast
return l > r
}
}
// MARK: - 安全作用域
/// 文件选择器给的 URL 属于其他进程的沙盒,读之前必须声明作用域,
/// 而且整个传输期间都要持有。
private func claimScope(_ url: URL) -> Bool {
releaseScope()
guard url.startAccessingSecurityScopedResource() else { return false }
scopedURL = url
return true
}
private func releaseScope() {
scopedURL?.stopAccessingSecurityScopedResource()
scopedURL = nil
}
}
// MARK: - 二维码渲染
enum QRRenderer {
/// 配对码只有几百字节,用 M 级纠错换取更好的首次识别率。
static func image(from text: String) -> UIImage? {
let filter = CIFilter.qrCodeGenerator()
filter.message = Data(text.utf8)
filter.correctionLevel = "M"
guard let output = filter.outputImage else { return nil }
// 放大用最近邻,避免插值把模块边缘糊掉
let scaled = output.transformed(by: CGAffineTransform(scaleX: 12, y: 12))
let context = CIContext()
guard let cgImage = context.createCGImage(scaled, from: scaled.extent) else { return nil }
return UIImage(cgImage: cgImage)
}
}
extension TransferProgress {
var readableRate: String {
let units = ["B/s", "KB/s", "MB/s", "GB/s"]
var value = bytesPerSecond
var index = 0
while value >= 1024, index < units.count - 1 { value /= 1024; index += 1 }
return String(format: "%.1f %@", value, units[index])
}
var readableSize: String {
Self.readable(completed) + " / " + Self.readable(total)
}
static func readable(_ bytes: UInt64) -> String {
let units = ["B", "KB", "MB", "GB"]
var value = Double(bytes)
var index = 0
while value >= 1024, index < units.count - 1 { value /= 1024; index += 1 }
return String(format: index == 0 ? "%.0f %@" : "%.1f %@", value, units[index])
}
}
@@ -0,0 +1,4 @@
{
"colors" : [ { "idiom" : "universal" } ],
"info" : { "author" : "xcode", "version" : 1 }
}
@@ -0,0 +1,6 @@
{
"images" : [
{ "idiom" : "universal", "platform" : "ios", "size" : "1024x1024" }
],
"info" : { "author" : "xcode", "version" : 1 }
}
+3
View File
@@ -0,0 +1,3 @@
{
"info" : { "author" : "xcode", "version" : 1 }
}
+46
View File
@@ -0,0 +1,46 @@
import Foundation
/// RFC 4648 §5 的 URL-safe Base64,无填充。
/// Windows 端用 `URL_SAFE_NO_PAD` 编码设备名、文件名与配对载荷,
/// Android 端对应 `Base64Url`,三端必须逐字节一致。
enum Base64URL {
static func encode(_ data: Data) -> String {
var text = data.base64EncodedString()
text = text.replacingOccurrences(of: "+", with: "-")
text = text.replacingOccurrences(of: "/", with: "_")
while text.hasSuffix("=") { text.removeLast() }
return text
}
static func encode(_ text: String) -> String {
encode(Data(text.utf8))
}
static func decode(_ text: String) -> Data? {
// 只接受合法字母表,避免把任意输入喂给 Data(base64Encoded:)
// 后得到一个「解出来了但不是原意」的结果。
guard !text.isEmpty else { return Data() }
for scalar in text.unicodeScalars {
switch scalar {
case "A"..."Z", "a"..."z", "0"..."9", "-", "_":
continue
default:
return nil
}
}
var padded = text.replacingOccurrences(of: "-", with: "+")
padded = padded.replacingOccurrences(of: "_", with: "/")
let remainder = padded.count % 4
if remainder == 1 { return nil } // 不可能出现的长度
if remainder != 0 {
padded.append(String(repeating: "=", count: 4 - remainder))
}
return Data(base64Encoded: padded)
}
static func decodeString(_ text: String) -> String? {
guard let data = decode(text) else { return nil }
return String(data: data, encoding: .utf8)
}
}
+210
View File
@@ -0,0 +1,210 @@
import Foundation
import CryptoKit
struct TransferProgress {
let completed: UInt64
let total: UInt64
let bytesPerSecond: Double
var fraction: Double {
total == 0 ? 1 : min(1, Double(completed) / Double(total))
}
}
/// 电脑 → 手机下载(QFTSEND2)。
///
/// 边收边写盘、边算 SHA-256,中断后用 `Range: bytes=N-` 续传。
/// Windows 端 `sender.rs` 只支持单段 Range,这里也只发单段。
final class DownloadClient: NSObject {
private let host: QFTHost
private let pairing: PairingPayload
private let deviceName: String
/// 落盘目录。默认 Documents/QFT(会出现在「文件」App 里);
/// 测试注入临时目录,避免碰到用户真实的文档目录。
private let destinationDirectory: URL?
private var fileHandle: FileHandle?
private var hasher = SHA256()
private var written: UInt64 = 0
private var expectedTotal: UInt64 = 0
private var startedAt = Date()
private var lastReport = Date.distantPast
private var onProgress: ((TransferProgress) -> Void)?
private var continuation: CheckedContinuation<Void, Error>?
private var session: URLSession?
init(host: QFTHost, pairing: PairingPayload, deviceName: String,
destinationDirectory: URL? = nil) {
self.host = host
self.pairing = pairing
self.deviceName = deviceName
self.destinationDirectory = destinationDirectory
super.init()
}
/// 下载到目标目录,返回最终文件 URL。
func run(onProgress: @escaping (TransferProgress) -> Void) async throws -> URL {
let name = pairing.fileName ?? "qft-download.bin"
let directory = try destinationDirectory ?? Self.defaultDestinationDirectory()
let partURL = directory.appendingPathComponent(name + ".qftpart")
// 续传:已经落盘多少就从多少开始要
var resumeFrom: UInt64 = 0
if let attributes = try? FileManager.default.attributesOfItem(atPath: partURL.path),
let size = attributes[.size] as? NSNumber {
resumeFrom = UInt64(truncating: size)
}
if resumeFrom > 0, let declared = pairing.fileSize, resumeFrom >= declared {
// 断点比声明的文件还大,说明这个 .qftpart 不是本次会话的,丢弃重来
try? FileManager.default.removeItem(at: partURL)
resumeFrom = 0
}
if resumeFrom > 0 {
// 续传时无法复用之前的哈希中间态,重新扫一遍已落盘的部分
hasher = SHA256()
let handle = try FileHandle(forReadingFrom: partURL)
defer { try? handle.close() }
while let block = try handle.read(upToCount: 4 * 1024 * 1024), !block.isEmpty {
hasher.update(data: block)
}
} else {
FileManager.default.createFile(atPath: partURL.path, contents: nil)
}
self.written = resumeFrom
self.expectedTotal = pairing.fileSize ?? 0
self.onProgress = onProgress
self.startedAt = Date()
self.fileHandle = try FileHandle(forWritingTo: partURL)
try fileHandle?.seekToEnd()
guard let url = URL(string: host.baseURL + "/qft/download") else {
throw QFTError.malformedResponse("下载地址无效")
}
var request = URLRequest(url: url)
request.httpMethod = "GET"
request.timeoutInterval = 30
request.setValue(pairing.session, forHTTPHeaderField: "X-QFT-Token")
request.setValue(Base64URL.encode(deviceName), forHTTPHeaderField: "X-QFT-Device")
if resumeFrom > 0 {
request.setValue("bytes=\(resumeFrom)-", forHTTPHeaderField: "Range")
}
let configuration = URLSessionConfiguration.ephemeral
configuration.timeoutIntervalForRequest = 30
configuration.timeoutIntervalForResource = 3600
let urlSession = URLSession(configuration: configuration, delegate: self, delegateQueue: nil)
self.session = urlSession
defer {
try? fileHandle?.close()
fileHandle = nil
urlSession.invalidateAndCancel()
session = nil
}
try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
self.continuation = continuation
urlSession.dataTask(with: request).resume()
}
if let declared = pairing.fileSize, written != declared {
throw QFTError.integrity("收到 \(written) 字节,电脑声明 \(declared) 字节")
}
if let expected = pairing.sha256 {
let actual = hasher.finalize().map { String(format: "%02x", $0) }.joined()
guard actual == expected else {
try? FileManager.default.removeItem(at: partURL)
throw QFTError.integrity("SHA-256 不匹配,文件已丢弃")
}
}
let finalURL = Self.uniqueURL(in: directory, name: name)
try FileManager.default.moveItem(at: partURL, to: finalURL)
return finalURL
}
// MARK: - 落盘目录
static func defaultDestinationDirectory() throws -> URL {
let documents = try FileManager.default.url(for: .documentDirectory, in: .userDomainMask,
appropriateFor: nil, create: true)
let directory = documents.appendingPathComponent("QFT", isDirectory: true)
try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
return directory
}
static func uniqueURL(in directory: URL, name: String) -> URL {
var candidate = directory.appendingPathComponent(name)
guard FileManager.default.fileExists(atPath: candidate.path) else { return candidate }
let stem = (name as NSString).deletingPathExtension
let ext = (name as NSString).pathExtension
var index = 1
while FileManager.default.fileExists(atPath: candidate.path) {
let suffix = ext.isEmpty ? "\(stem) (\(index))" : "\(stem) (\(index)).\(ext)"
candidate = directory.appendingPathComponent(suffix)
index += 1
}
return candidate
}
}
extension DownloadClient: URLSessionDataDelegate {
func urlSession(_ session: URLSession, dataTask: URLSessionDataTask,
didReceive response: URLResponse,
completionHandler: @escaping (URLSession.ResponseDisposition) -> Void) {
guard let http = response as? HTTPURLResponse else {
finish(with: QFTError.malformedResponse("非 HTTP 响应"))
completionHandler(.cancel)
return
}
guard http.statusCode == 200 || http.statusCode == 206 else {
finish(with: QFTError.httpStatus(http.statusCode, http.statusCode == 403 ? "会话已失效,请让电脑重新生成二维码" : ""))
completionHandler(.cancel)
return
}
if expectedTotal == 0 {
let length = http.expectedContentLength
if length > 0 { expectedTotal = written + UInt64(length) }
}
completionHandler(.allow)
}
func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
do {
try fileHandle?.write(contentsOf: data)
} catch {
finish(with: error)
dataTask.cancel()
return
}
hasher.update(data: data)
written &+= UInt64(data.count)
report()
}
func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
if let error, (error as NSError).code != NSURLErrorCancelled {
finish(with: error)
} else {
report(force: true)
finish(with: nil)
}
}
private func report(force: Bool = false) {
let now = Date()
guard force || now.timeIntervalSince(lastReport) > 0.1 else { return }
lastReport = now
let elapsed = max(0.001, now.timeIntervalSince(startedAt))
onProgress?(TransferProgress(completed: written, total: expectedTotal,
bytesPerSecond: Double(written) / elapsed))
}
private func finish(with error: Error?) {
guard let continuation else { return }
self.continuation = nil
if let error { continuation.resume(throwing: error) } else { continuation.resume() }
}
}
+271
View File
@@ -0,0 +1,271 @@
import Foundation
#if canImport(UIKit)
import UIKit
#endif
enum DeviceInfo {
static var name: String {
#if canImport(UIKit)
let raw = UIDevice.current.name
#else
let raw = Host.current().localizedName ?? "iPhone"
#endif
let cleaned = raw.filter { !$0.isNewline }
return cleaned.isEmpty ? "iPhone" : String(cleaned.prefix(64))
}
}
struct QFTHost: Equatable {
let baseURL: String // 形如 http://192.168.1.20:39393
}
enum QFTError: LocalizedError {
case hostNotFound
case httpStatus(Int, String)
case malformedResponse(String)
case integrity(String)
case cancelled
var errorDescription: String? {
switch self {
case .hostNotFound:
return "找不到电脑。请确认手机和电脑连在同一个 Wi-Fi,并且电脑上的 QFT 正在等待连接。"
case .httpStatus(let code, let detail):
return "电脑返回 HTTP \(code)\(detail.isEmpty ? "" : ":\(detail)")"
case .malformedResponse(let detail):
return "电脑返回的数据无法解析:\(detail)"
case .integrity(let detail):
return "校验失败:\(detail)"
case .cancelled:
return "已取消"
}
}
}
/// 在局域网里定位 Windows 端。
///
/// 顺序:二维码自带的 endpoint → UDP QFTDISC2 广播 → 当前子网有界扫描。
/// 与 Android 端同一套策略,但去掉了 Direct-AP 相关的分支:iOS 连不上指定 AP。
struct HostDiscovery {
let pairing: PairingPayload
let deviceName: String
static let discoveryPort: UInt16 = 39392
func locate() async throws -> QFTHost {
if let host = await probe(pairing.endpoints, timeout: 1.2) {
return host
}
if let hinted = await udpDiscover(timeout: 1.5),
let host = await probe([hinted], timeout: 1.5) {
return host
}
let candidates = LocalNetwork.subnetCandidates(port: pairing.port, limit: 254)
if !candidates.isEmpty, let host = await probe(candidates, timeout: 0.7) {
return host
}
throw QFTError.hostNotFound
}
/// 并发 ping 全部候选,返回第一个应答的。
func probe(_ endpoints: [String], timeout: TimeInterval) async -> QFTHost? {
guard !endpoints.isEmpty else { return nil }
return await withTaskGroup(of: QFTHost?.self) { group in
for endpoint in endpoints {
group.addTask { await Self.ping(endpoint, session: pairing.session,
deviceName: deviceName, timeout: timeout) }
}
for await result in group {
if let result {
group.cancelAll()
return result
}
}
return nil
}
}
static func ping(_ baseURL: String, session: String,
deviceName: String, timeout: TimeInterval) async -> QFTHost? {
guard let url = URL(string: baseURL + "/qft/ping") else { return nil }
var request = URLRequest(url: url)
request.httpMethod = "GET"
request.timeoutInterval = timeout
request.setValue(session, forHTTPHeaderField: "X-QFT-Token")
request.setValue(Base64URL.encode(deviceName), forHTTPHeaderField: "X-QFT-Device")
let configuration = URLSessionConfiguration.ephemeral
configuration.timeoutIntervalForRequest = timeout
configuration.waitsForConnectivity = false
let urlSession = URLSession(configuration: configuration)
defer { urlSession.finishTasksAndInvalidate() }
guard let (data, response) = try? await urlSession.data(for: request),
let http = response as? HTTPURLResponse, http.statusCode == 200,
let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
(object["ok"] as? Bool) == true else { return nil }
return QFTHost(baseURL: baseURL)
}
/// 向广播地址发 `QFTDISC2:<session>`,等待 `QFTHERE2:<session>:<port>`。
/// 返回可用的 base URL;iOS 首次调用会触发「本地网络」权限弹窗。
func udpDiscover(timeout: TimeInterval) async -> String? {
let expected = "QFTHERE2:\(pairing.session):"
let request = Data("QFTDISC2:\(pairing.session)".utf8)
return await withCheckedContinuation { continuation in
DispatchQueue.global(qos: .userInitiated).async {
let result = Self.udpRoundTrip(request: request,
expectedPrefix: expected,
timeout: timeout)
continuation.resume(returning: result)
}
}
}
private static func udpRoundTrip(request: Data, expectedPrefix: String,
timeout: TimeInterval) -> String? {
let fd = socket(AF_INET, SOCK_DGRAM, 0)
guard fd >= 0 else { return nil }
defer { close(fd) }
var enable: Int32 = 1
setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &enable, socklen_t(MemoryLayout<Int32>.size))
var tv = timeval(tv_sec: Int(timeout), tv_usec: Int32((timeout - floor(timeout)) * 1_000_000))
setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, socklen_t(MemoryLayout<timeval>.size))
var targets = ["255.255.255.255"]
if let broadcast = LocalNetwork.subnetBroadcastAddress() { targets.insert(broadcast, at: 0) }
for target in targets {
var address = sockaddr_in()
address.sin_family = sa_family_t(AF_INET)
address.sin_port = discoveryPort.bigEndian
address.sin_addr.s_addr = inet_addr(target)
let sent = request.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))
}
}
}
if sent < 0 { continue }
}
let deadline = Date().addingTimeInterval(timeout)
var buffer = [UInt8](repeating: 0, count: 512)
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 { break }
guard let text = String(bytes: buffer[0..<received], encoding: .utf8),
text.hasPrefix(expectedPrefix),
let port = Int(text.dropFirst(expectedPrefix.count)),
(1...65535).contains(port) else { 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 ip = String(cString: host)
// 应答来源同样必须是私有地址:广播回包也属于不可信输入
guard PairingProtocol.isPrivateIPv4(ip) else { continue }
return "http://\(ip):\(port)"
}
return nil
}
}
/// 本机 IPv4 与子网推导(getifaddrs)。
enum LocalNetwork {
struct Interface {
let name: String
let address: String
let netmask: String
}
static func activeInterfaces() -> [Interface] {
var head: UnsafeMutablePointer<ifaddrs>?
guard getifaddrs(&head) == 0, let first = head else { return [] }
defer { freeifaddrs(head) }
var result: [Interface] = []
var cursor: UnsafeMutablePointer<ifaddrs>? = first
while let entry = cursor {
defer { cursor = entry.pointee.ifa_next }
guard let rawAddress = entry.pointee.ifa_addr,
rawAddress.pointee.sa_family == UInt8(AF_INET) else { continue }
let flags = Int32(entry.pointee.ifa_flags)
guard flags & IFF_UP != 0, flags & IFF_LOOPBACK == 0 else { continue }
guard let address = describe(rawAddress),
let maskPointer = entry.pointee.ifa_netmask,
let netmask = describe(maskPointer) else { continue }
guard PairingProtocol.isPrivateIPv4(address) else { continue }
result.append(Interface(name: String(cString: entry.pointee.ifa_name),
address: address, netmask: netmask))
}
// en0 是 iPhone 的 Wi-Fi 接口,优先于蜂窝/热点接口
return result.sorted { lhs, _ in lhs.name == "en0" }
}
private static func describe(_ address: UnsafeMutablePointer<sockaddr>) -> String? {
var host = [CChar](repeating: 0, count: Int(NI_MAXHOST))
let length = socklen_t(MemoryLayout<sockaddr_in>.size)
guard getnameinfo(address, length, &host, socklen_t(host.count),
nil, 0, NI_NUMERICHOST) == 0 else { return nil }
return String(cString: host)
}
static func subnetBroadcastAddress() -> String? {
guard let iface = activeInterfaces().first,
let ip = ipv4(iface.address), let mask = ipv4(iface.netmask) else { return nil }
return format(ip | ~mask)
}
/// 当前子网内的候选地址。仅在 /24 或更小的子网上启用,
/// 避免在大网段里做无意义的上千次探测。
static func subnetCandidates(port: Int, limit: Int) -> [String] {
guard let iface = activeInterfaces().first,
let ip = ipv4(iface.address), let mask = ipv4(iface.netmask) else { return [] }
let hostBits = (~mask).nonzeroBitCount
guard hostBits > 0, hostBits <= 8 else { return [] }
let network = ip & mask
let broadcast = ip | ~mask
var result: [String] = []
var candidate = network &+ 1
while candidate < broadcast && result.count < limit {
if candidate != ip { result.append("http://\(format(candidate)):\(port)") }
candidate &+= 1
}
// 网关通常是 .1,多半就是那台开热点/路由的机器,放最前面
if let gatewayIndex = result.firstIndex(of: "http://\(format(network &+ 1)):\(port)") {
result.swapAt(0, gatewayIndex)
}
return result
}
static func ipv4(_ text: String) -> UInt32? {
let parts = text.split(separator: ".", omittingEmptySubsequences: false)
guard parts.count == 4 else { return nil }
var value: UInt32 = 0
for part in parts {
guard let octet = UInt32(part), octet <= 255 else { return nil }
value = (value << 8) | octet
}
return value
}
static func format(_ value: UInt32) -> String {
"\((value >> 24) & 0xff).\((value >> 16) & 0xff).\((value >> 8) & 0xff).\(value & 0xff)"
}
}
+188
View File
@@ -0,0 +1,188 @@
import Foundation
enum TransferDirection: String {
case uploadToPC = "u" // QFTPAIR2:手机把文件传给电脑
case downloadToPhone = "d" // QFTSEND2:电脑已选好文件,手机扫码后下载
}
struct WifiCredentials: Equatable {
let ssid: String
let passphrase: String
}
struct PairingPayload: Equatable {
let version: Int
let session: String
let pcName: String
let port: Int
let endpoints: [String]
let wifi: WifiCredentials?
let direction: TransferDirection
let fileName: String?
let fileSize: UInt64?
let sha256: String?
}
/// QFTPAIR2 / QFTSEND2 配对二维码解析。
///
/// 二维码是**不可信输入**:它决定了 App 接下来去连哪个地址。因此这里只接受
/// 字面量私有 IPv4 + 二维码自称的端口,任何域名、公网地址、带 query/fragment
/// 的 URL 一律拒绝——与 Windows/Android 两端的校验保持一致。
enum PairingProtocol {
static let prefixUpload = "QFTPAIR2:"
static let prefixDownload = "QFTSEND2:"
static func isPairingText(_ text: String) -> Bool {
text.hasPrefix(prefixUpload) || text.hasPrefix(prefixDownload)
}
static func parse(_ text: String) -> PairingPayload? {
guard text.count <= 4096 else { return nil }
if text.hasPrefix(prefixUpload) {
return parseV2(String(text.dropFirst(prefixUpload.count)), expected: .uploadToPC)
}
if text.hasPrefix(prefixDownload) {
return parseV2(String(text.dropFirst(prefixDownload.count)), expected: .downloadToPhone)
}
return nil
}
private static func parseV2(_ encoded: String, expected: TransferDirection) -> PairingPayload? {
guard let data = Base64URL.decode(encoded), data.count <= 2048 else { return nil }
guard let root = try? JSONSerialization.jsonObject(with: data),
let object = root as? [String: Any] else { return nil }
guard (object["v"] as? Int) == 2 else { return nil }
// 缺省为 "u",与 Windows 端「上传 QR 不写 d 字段」的编码方式对应
let rawDirection = (object["d"] as? String) ?? "u"
guard let direction = TransferDirection(rawValue: rawDirection),
direction == expected else { return nil }
guard let session = object["s"] as? String, isValidSession(session) else { return nil }
guard let port = object["p"] as? Int, (1...65535).contains(port) else { return nil }
var wifi: WifiCredentials?
if let array = object["w"] as? [Any], array.count >= 2,
let ssid = array[0] as? String, let passphrase = array[1] as? String {
guard isValidWifi(ssid: ssid, passphrase: passphrase) else { return nil }
wifi = WifiCredentials(ssid: ssid, passphrase: passphrase)
}
var endpoints: [String] = []
if let array = object["e"] as? [Any] {
for item in array {
guard let raw = item as? String else { continue }
var value = raw.trimmingCharacters(in: .whitespaces)
while value.hasSuffix("/") { value.removeLast() }
if isAllowedLocalHTTPEndpoint(value, expectedPort: port), !endpoints.contains(value) {
endpoints.append(value)
}
}
}
// iOS 无法用代码加入指定 Wi-Fi(NEHotspotConfiguration 需要付费账号的
// entitlement),所以 Direct-AP 二维码在本端必须自带可用 endpoint。
if endpoints.isEmpty { return nil }
var fileName: String?
var fileSize: UInt64?
var sha256: String?
if direction == .downloadToPhone {
guard let name = (object["f"] as? String)?.trimmingCharacters(in: .whitespaces),
isValidFileName(name) else { return nil }
guard let size = object["z"] as? NSNumber, size.int64Value >= 0 else { return nil }
guard let hash = (object["h"] as? String)?.lowercased(), isValidSHA256(hash) else { return nil }
fileName = name
fileSize = UInt64(size.int64Value)
sha256 = hash
}
let pcName = String(((object["n"] as? String) ?? "Windows-PC").prefix(80))
return PairingPayload(
version: 2,
session: session,
pcName: pcName,
port: port,
endpoints: endpoints,
wifi: wifi,
direction: direction,
fileName: fileName,
fileSize: fileSize,
sha256: sha256
)
}
// MARK: - 校验
static func isValidSession(_ value: String) -> Bool {
guard (20...64).contains(value.count) else { return false }
for scalar in value.unicodeScalars {
switch scalar {
case "A"..."Z", "a"..."z", "0"..."9", "-", "_": continue
default: return false
}
}
return true
}
static func isValidWifi(ssid: String, passphrase: String) -> Bool {
!ssid.trimmingCharacters(in: .whitespaces).isEmpty
&& Data(ssid.utf8).count <= 32
&& (8...63).contains(passphrase.count)
}
static func isValidFileName(_ value: String) -> Bool {
guard !value.isEmpty, value.count <= 180 else { return false }
let forbidden: Set<Unicode.Scalar> = ["\\", "/", ":", "*", "?", "\"", "<", ">", "|"]
for scalar in value.unicodeScalars {
if scalar.value <= 31 || scalar.value == 127 { return false }
if forbidden.contains(scalar) { return false }
}
return true
}
static func isValidSHA256(_ value: String) -> Bool {
guard value.count == 64 else { return false }
for scalar in value.unicodeScalars {
switch scalar {
case "0"..."9", "a"..."f": continue
default: return false
}
}
return true
}
/// 只允许 `http://<私有 IPv4 字面量>:<期望端口>`。
/// 故意不使用 URL/URLComponents 的宽松解析:它会接受域名、IPv6、
/// 带凭据的 URL 等本协议不该出现的形态。
static func isAllowedLocalHTTPEndpoint(_ value: String, expectedPort: Int) -> Bool {
guard value.hasPrefix("http://") else { return false }
let rest = String(value.dropFirst("http://".count))
guard !rest.contains("@"), !rest.contains("?"), !rest.contains("#"),
!rest.contains("/") else { return false }
let parts = rest.split(separator: ":", omittingEmptySubsequences: false)
guard parts.count == 2, let port = Int(parts[1]), port == expectedPort else { return false }
return isPrivateIPv4(String(parts[0]))
}
static func isPrivateIPv4(_ host: String) -> Bool {
let octets = host.split(separator: ".", omittingEmptySubsequences: false)
guard octets.count == 4 else { return false }
var values: [Int] = []
for octet in octets {
// 拒绝 "01"、"+1"、空段这类非规范写法
guard !octet.isEmpty, octet.count <= 3, octet.allSatisfy({ $0.isASCII && $0.isNumber }),
let value = Int(octet), (0...255).contains(value),
octet.count == 1 || !octet.hasPrefix("0") else { return false }
values.append(value)
}
switch (values[0], values[1]) {
case (10, _): return true
case (127, _): return true
case (169, 254): return true
case (172, 16...31): return true
case (192, 168): return true
default: return false
}
}
}
+469
View File
@@ -0,0 +1,469 @@
import Foundation
import Network
import CryptoKit
/// 点对点链路:Bonjour 发现 + TLS-PSK 加密 + 长度前缀分帧。
///
/// `includePeerToPeer = true` 让 Network.framework 在没有路由器时
/// 自动使用 BLE 发现 + AWDL 点对点 Wi-Fi,也就是 AirDrop 用的同一条链路。
/// 两台设备在同一个 Wi-Fi 下时它会优先走基础网络,速度同样很快。
///
/// AWDL 是苹果私有链路,Windows 无法参与——PC 方向仍走 HTTP 局域网路径。
enum PeerLink {
static let frameHeaderSize = 5 // 1 字节类型 + 4 字节 BE 长度
static let chunkSize = 256 * 1024
static let maxFrameSize = 4 * 1024 * 1024
enum FrameType: UInt8 {
case manifest = 1
case data = 2
case eof = 3
case result = 4
}
enum PeerError: LocalizedError {
case handshake(String)
case protocolViolation(String)
case rejected(String)
case timeout
var errorDescription: String? {
switch self {
case .handshake(let detail): return "建立加密连接失败:\(detail)"
case .protocolViolation(let detail): return "对方发来的数据不符合协议:\(detail)"
case .rejected(let detail): return "对方拒绝了传输:\(detail)"
case .timeout: return "等待对方超时"
}
}
}
/// TLS-PSK 参数。密钥来自二维码,因此不需要任何证书体系,
/// 且扫码这个动作本身就完成了双向认证——中间人拿不到密钥就握不了手。
static func parameters(key: Data, identity: String) -> NWParameters {
let tls = NWProtocolTLS.Options()
let keyData = key.withUnsafeBytes { DispatchData(bytes: $0) }
let identityData = Data(identity.utf8).withUnsafeBytes { DispatchData(bytes: $0) }
sec_protocol_options_add_pre_shared_key(
tls.securityProtocolOptions,
keyData as __DispatchData,
identityData as __DispatchData)
if let suite = tls_ciphersuite_t(rawValue: UInt16(TLS_PSK_WITH_AES_128_GCM_SHA256)) {
sec_protocol_options_append_tls_ciphersuite(tls.securityProtocolOptions, suite)
}
let tcp = NWProtocolTCP.Options()
tcp.noDelay = true
// 传输是一次性的,对端消失时不要长时间挂着
tcp.connectionTimeout = 10
tcp.enableKeepalive = true
tcp.keepaliveIdle = 5
let parameters = NWParameters(tls: tls, tcp: tcp)
parameters.includePeerToPeer = true
return parameters
}
// MARK: - 分帧收发
static func send(_ connection: NWConnection, type: FrameType, payload: Data) async throws {
var header = Data([type.rawValue])
var length = UInt32(payload.count).bigEndian
withUnsafeBytes(of: &length) { header.append(contentsOf: $0) }
try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
connection.send(content: header + payload,
completion: .contentProcessed { error in
if let error { continuation.resume(throwing: error) } else { continuation.resume() }
})
}
}
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))
}
guard length <= UInt32(maxFrameSize) else {
throw PeerError.protocolViolation("帧长度 \(length) 超出上限")
}
if length == 0 { return (type, Data()) }
return (type, try await receiveExactly(connection, count: Int(length)))
}
static func receiveExactly(_ connection: NWConnection, count: Int) async throws -> Data {
var buffer = Data()
buffer.reserveCapacity(count)
while buffer.count < count {
let remaining = count - buffer.count
let block = try await withCheckedThrowingContinuation {
(continuation: CheckedContinuation<Data, Error>) in
connection.receive(minimumIncompleteLength: 1, maximumLength: remaining) {
content, _, isComplete, error in
if let error { continuation.resume(throwing: error); return }
if let content, !content.isEmpty { continuation.resume(returning: content); return }
if isComplete {
continuation.resume(throwing: PeerError.protocolViolation("连接提前关闭"))
} else {
continuation.resume(returning: Data())
}
}
}
buffer.append(block)
}
return buffer
}
static func waitReady(_ connection: NWConnection, queue: DispatchQueue,
timeout: TimeInterval = 15) async throws {
try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
let resumed = Locked(false)
func finish(_ error: Error?) {
guard resumed.exchange(true) == false else { return }
if let error { continuation.resume(throwing: error) } else { continuation.resume() }
}
connection.stateUpdateHandler = { state in
switch state {
case .ready:
finish(nil)
case .failed(let error):
finish(error)
case .waiting(let error):
// NWConnection 默认会在 .waiting 里无限重试。对一次性传输来说:
// TLS 类错误(密钥不匹配、对端拒绝)不可能自愈,立刻失败;
// 而链路层的暂时不可达在 AWDL/Bonjour 起来之前是正常现象,继续等。
if case .tls = error {
finish(PeerError.handshake("预共享密钥不匹配,或对方已结束这次会话"))
}
case .cancelled:
finish(PeerError.handshake("连接被取消"))
default:
break
}
}
queue.asyncAfter(deadline: .now() + timeout) { finish(PeerError.timeout) }
connection.start(queue: queue)
}
}
}
/// 极简互斥包装。continuation 只能 resume 一次,而 stateUpdateHandler
/// 可能在多个状态里触发,需要一个原子的「是否已 resume」。
final class Locked<Value> {
private var value: Value
private let lock = NSLock()
init(_ value: Value) { self.value = value }
func exchange(_ newValue: Value) -> Value {
lock.lock(); defer { lock.unlock() }
let old = value
value = newValue
return old
}
var current: Value {
lock.lock(); defer { lock.unlock() }
return value
}
}
// MARK: - 发送端
/// 展示二维码的一方。持有文件,等待对方扫码后连入。
final class PeerSender {
/// 监听器的状态与排队中的连接。stateUpdateHandler / newConnectionHandler
/// 在任意线程触发,而等待方是 async,所以两边都要经过这把锁。
private final class Box {
let lock = NSLock()
var readyPort: UInt16?
var failure: Error?
var pending: [NWConnection] = []
var portWaiter: CheckedContinuation<UInt16, Error>?
var connectionWaiter: CheckedContinuation<NWConnection, Error>?
/// 同步方法:async 上下文里不允许直接调用 NSLock.lock()
func drainPending() -> [NWConnection] {
lock.lock(); defer { lock.unlock() }
let extras = pending
pending = []
return extras
}
}
private let fileURL: 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?
init(fileURL: URL, deviceName: String) {
self.fileURL = fileURL
self.deviceName = deviceName
}
/// 等待监听就绪并返回实际端口。P2P 场景下对端靠 Bonjour 实例名找过来,
/// 端口只在测试直连时才需要。
func listeningPort() async throws -> UInt16 {
try await withCheckedThrowingContinuation { continuation in
box.lock.lock()
if let port = box.readyPort {
box.lock.unlock(); continuation.resume(returning: port)
} else if let failure = box.failure {
box.lock.unlock(); continuation.resume(throwing: failure)
} else {
box.portWaiter = continuation
box.lock.unlock()
}
}
}
/// 计算文件摘要、启动监听并广播 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)
}
try handle.close()
let digest = hasher.finalize().map { String(format: "%02x", $0) }.joined()
let pairing = PeerPairing(
version: 1,
key: PeerPairing.newKey(),
instance: PeerPairing.newInstance(),
senderName: deviceName,
fileName: fileURL.lastPathComponent,
fileSize: size,
sha256: digest)
let parameters = PeerLink.parameters(key: pairing.key, identity: pairing.instance)
let listener = try NWListener(using: parameters)
listener.service = NWListener.Service(name: pairing.instance,
type: PeerPairing.serviceType)
listener.stateUpdateHandler = { [box] state in
switch state {
case .ready:
box.lock.lock()
box.readyPort = listener.port?.rawValue
let waiter = box.portWaiter
box.portWaiter = nil
box.lock.unlock()
if let port = listener.port?.rawValue { waiter?.resume(returning: port) }
case .failed(let error):
box.lock.lock()
box.failure = error
let portWaiter = box.portWaiter
let connectionWaiter = box.connectionWaiter
box.portWaiter = nil
box.connectionWaiter = nil
box.lock.unlock()
portWaiter?.resume(throwing: error)
connectionWaiter?.resume(throwing: error)
default:
break
}
}
listener.newConnectionHandler = { [box] connection in
box.lock.lock()
if let waiter = box.connectionWaiter {
box.connectionWaiter = nil
box.lock.unlock()
waiter.resume(returning: connection)
} else {
box.pending.append(connection)
box.lock.unlock()
}
}
listener.start(queue: queue)
self.listener = listener
self.pairing = pairing
return pairing
}
/// 等待一个连接并把文件推过去。
func waitAndSend(onProgress: @escaping (TransferProgress) -> Void) async throws {
guard let listener, let pairing else {
throw PeerLink.PeerError.handshake("尚未调用 start()")
}
let connection = try await withCheckedThrowingContinuation {
(continuation: CheckedContinuation<NWConnection, Error>) in
box.lock.lock()
if !box.pending.isEmpty {
let first = box.pending.removeFirst()
box.lock.unlock()
continuation.resume(returning: first)
} else if let failure = box.failure {
box.lock.unlock()
continuation.resume(throwing: failure)
} else {
box.connectionWaiter = continuation
box.lock.unlock()
}
}
// 一次会话只服务一个对端,其余排队的连接直接断开
box.drainPending().forEach { $0.cancel() }
defer { connection.cancel(); listener.cancel() }
try await PeerLink.waitReady(connection, queue: queue)
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 {
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.send(connection, type: .eof, payload: Data())
let (type, payload) = try await PeerLink.receiveFrame(connection)
guard type == .result,
let object = try? JSONSerialization.jsonObject(with: payload) as? [String: Any] else {
throw PeerLink.PeerError.protocolViolation("收尾帧无效")
}
if (object["ok"] as? Bool) != true {
throw PeerLink.PeerError.rejected((object["error"] as? String) ?? "对方未说明原因")
}
}
func stop() {
listener?.cancel()
listener = nil
}
}
// MARK: - 接收端
/// 扫码的一方。按实例名找到对端并接收文件。
struct PeerReceiver {
let pairing: PeerPairing
let destinationDirectory: URL
/// 测试用:跳过 Bonjour,直接连指定端口。
var directPort: UInt16?
func run(onProgress: @escaping (TransferProgress) -> Void) async throws -> URL {
let queue = DispatchQueue(label: "qft.peer.receiver")
let parameters = PeerLink.parameters(key: pairing.key, identity: pairing.instance)
let endpoint: NWEndpoint
if let directPort {
endpoint = .hostPort(host: .ipv4(.loopback), port: .init(rawValue: directPort)!)
} else {
endpoint = .service(name: pairing.instance, type: PeerPairing.serviceType,
domain: "local", interface: nil)
}
let connection = NWConnection(to: endpoint, using: parameters)
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("清单帧无效")
}
// 清单必须与二维码一致,否则说明连到的不是扫码时看到的那个文件
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("对方声明的文件与二维码不符")
}
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
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)")
}
}
try handle.close()
} catch {
try? handle.close()
try? FileManager.default.removeItem(at: partURL)
throw error
}
// --- 校验 ---
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 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
}
}
+94
View File
@@ -0,0 +1,94 @@
import Foundation
import Security
/// 隔空投送式点对点配对码。
///
/// 与 QFTPAIR2/QFTSEND2 的关键区别:那两个是「连到某个 IP」,
/// 这个是「连到某个 Bonjour 服务实例,并用二维码里的预共享密钥做 TLS 认证」。
/// 二维码在这里充当带外信道——和 AirDrop 用 BLE 交换身份是同一个作用,
/// 只是我们把身份交换搬到了用户可见的扫码动作上,不需要任何配对弹窗。
struct PeerPairing: Equatable {
static let prefix = "QFTP2P1:"
let version: Int
/// 32 字节预共享密钥。既是 TLS-PSK,也是服务实例的唯一凭据。
let key: Data
/// Bonjour 服务实例名,由发送端随机生成
let instance: String
let senderName: String
let fileName: String
let fileSize: UInt64
let sha256: String
static let serviceType = "_qft-p2p._tcp"
func encode() -> String {
let object: [String: Any] = [
"v": version,
"k": Base64URL.encode(key),
"i": instance,
"n": senderName,
"f": fileName,
"z": NSNumber(value: fileSize),
"h": sha256,
]
let data = (try? JSONSerialization.data(withJSONObject: object)) ?? Data()
return Self.prefix + Base64URL.encode(data)
}
static func isPeerText(_ text: String) -> Bool { text.hasPrefix(prefix) }
static func parse(_ text: String) -> PeerPairing? {
guard text.hasPrefix(prefix), text.count <= 4096 else { return nil }
guard let data = Base64URL.decode(String(text.dropFirst(prefix.count))),
data.count <= 2048,
let object = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any] else {
return nil
}
guard (object["v"] as? Int) == 1 else { return nil }
guard let keyText = object["k"] as? String,
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 fileName = (object["f"] as? String)?.trimmingCharacters(in: .whitespaces),
PairingProtocol.isValidFileName(fileName) else { return nil }
guard let size = object["z"] as? NSNumber, size.int64Value >= 0 else { return nil }
guard let hash = (object["h"] as? String)?.lowercased(),
PairingProtocol.isValidSHA256(hash) else { return nil }
return PeerPairing(
version: 1,
key: key,
instance: instance,
senderName: String(((object["n"] as? String) ?? "iPhone").prefix(80)),
fileName: fileName,
fileSize: UInt64(size.int64Value),
sha256: hash
)
}
/// Bonjour 实例名:只允许我们自己生成的字符集,避免把任意字符串
/// 交给 mDNS 解析。
static func isValidInstance(_ value: String) -> Bool {
guard (8...48).contains(value.count) else { return false }
for scalar in value.unicodeScalars {
switch scalar {
case "A"..."Z", "a"..."z", "0"..."9", "-": continue
default: return false
}
}
return true
}
static func newKey() -> Data {
var bytes = [UInt8](repeating: 0, count: 32)
_ = SecRandomCopyBytes(kSecRandomDefault, bytes.count, &bytes)
return Data(bytes)
}
static func newInstance() -> String {
let alphabet = Array("abcdefghijklmnopqrstuvwxyz0123456789")
var bytes = [UInt8](repeating: 0, count: 16)
_ = SecRandomCopyBytes(kSecRandomDefault, bytes.count, &bytes)
return "qft-" + String(bytes.map { alphabet[Int($0) % alphabet.count] })
}
}
+189
View File
@@ -0,0 +1,189 @@
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))
}
}
+68
View File
@@ -0,0 +1,68 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>CFBundleDevelopmentRegion</key>
<string>zh_CN</string>
<key>CFBundleDisplayName</key>
<string>QFT 快传</string>
<key>CFBundleExecutable</key>
<string>$(EXECUTABLE_NAME)</string>
<key>CFBundleIdentifier</key>
<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
<key>CFBundleInfoDictionaryVersion</key>
<string>6.0</string>
<key>CFBundleName</key>
<string>$(PRODUCT_NAME)</string>
<key>CFBundlePackageType</key>
<string>APPL</string>
<key>CFBundleShortVersionString</key>
<string>$(MARKETING_VERSION)</string>
<key>CFBundleVersion</key>
<string>$(CURRENT_PROJECT_VERSION)</string>
<!-- 扫描配对二维码 -->
<key>NSCameraUsageDescription</key>
<string>QFT 需要使用相机扫描电脑或另一台 iPhone 上的配对二维码。相机画面不会离开本机。</string>
<!-- iOS 14+ 访问局域网设备必须声明;首次连接时系统会弹窗询问 -->
<key>NSLocalNetworkUsageDescription</key>
<string>QFT 需要在本地网络里找到你的电脑,才能直接传输文件。所有数据只在本地网络内传输,不经过互联网。</string>
<!-- 隔空投送式点对点传输所用的 Bonjour 服务,未声明则 NWBrowser 无法发现对端 -->
<key>NSBonjourServices</key>
<array>
<string>_qft-p2p._tcp</string>
</array>
<!-- Windows 端是局域网内的明文 HTTP。仅放开本地网络,不全局关闭 ATS。 -->
<key>NSAppTransportSecurity</key>
<dict>
<key>NSAllowsLocalNetworking</key>
<true/>
</dict>
<!-- 让接收到的文件出现在「文件」App 里,用户可以自行导出 -->
<key>UIFileSharingEnabled</key>
<true/>
<key>LSSupportsOpeningDocumentsInPlace</key>
<true/>
<key>UILaunchScreen</key>
<dict>
<key>UIColorName</key>
<string></string>
</dict>
<key>UISupportedInterfaceOrientations</key>
<array>
<string>UIInterfaceOrientationPortrait</string>
</array>
<key>UISupportedInterfaceOrientations~ipad</key>
<array>
<string>UIInterfaceOrientationPortrait</string>
<string>UIInterfaceOrientationPortraitUpsideDown</string>
<string>UIInterfaceOrientationLandscapeLeft</string>
<string>UIInterfaceOrientationLandscapeRight</string>
</array>
</dict>
</plist>