mirror of
https://github.com/sudosylabs/vnidrop.git
synced 2026-08-14 14:19:57 +02:00
cdricms
6b6d5f158d
Creating a targeted transfer contacts the peer and only returns once the offer is answered or its timeouts expire — connection_timeout plus offer_wait_timeout, so minutes against a device that never answers. The composer disabled every control for that whole window, including Close, leaving no way out. Worse, the core records the row before it reaches out and leaves it in `failed` when the peer never replies, so giving up still produced a failure notification and a history entry for a send the user had already called off. Cancelling now reaches the core while that create is still running. The `created` lifecycle event carries the transfer id and is emitted before the peer is contacted, so the id is known in time; the cancel goes out through the interrupt lane, which exists precisely to reach a core busy inside another call. The transfer is then deleted, and its id is filtered out of the published list so a refresh racing the delete cannot leak it into history or into a notification. If the id has not arrived yet, the result carries it and the same cleanup runs on return. Picked sources are released only once the call lands, because the import owns them until then, and a generation counter keeps a late result from disturbing a newer send. Close and Cancel were also the same action under two labels. There is now one control: the sheet's cancellation item, reading Cancel while a send is waiting and Close otherwise, never disabled. Two further fixes from device testing: - Receive and Resume were gated on transfer state alone, so an approved outgoing transfer offered the sender a Receive button — an invitation to download the files it was uploading. Both pull into a local folder and are now receiver-only. - Renamed the deprecated `laptopcomputerAndIphone` symbol to `macbookAndIphone`; the deployment targets are well past where it was introduced, so no availability guard is needed. Adds a typed `targetedTransferId` accessor on CoreEventModel. This is a narrow, deliberate exception to the wake-up-only event rule in DESIGN-DEVICE-HISTORY.md §13: it takes the subject id and never state, and it exists because no query can answer while the create holds the serial lane — which is exactly when the user wants to cancel. Known gap: direction is inferred by comparing endpoint ids, because the binding does not expose the row's role. After an identity reset, rows predating it match neither endpoint, so past sends read as incoming from the device's own retired identity. Fixing that needs `role` on the core's TargetedTransfer.
88 lines
2.9 KiB
Swift
88 lines
2.9 KiB
Swift
import Foundation
|
|
|
|
/// Presentation-level saved-device models, ported from
|
|
/// `feature/saveddevices/SavedDeviceExperienceModels.kt`.
|
|
|
|
/// The one consent question currently worth asking. Only one is shown at a time:
|
|
/// an incoming request always outranks an eligibility we could act on ourselves.
|
|
enum PairingPrompt: Equatable, Identifiable {
|
|
/// We completed a qualifying transfer and may ask this peer to pair.
|
|
case eligibility(peerEndpointId: String, remoteDisplayName: String?)
|
|
/// This peer asked us; we approve or decline.
|
|
case incomingRequest(peerEndpointId: String, remoteDisplayName: String?)
|
|
|
|
var peerEndpointId: String {
|
|
switch self {
|
|
case .eligibility(let id, _), .incomingRequest(let id, _): return id
|
|
}
|
|
}
|
|
|
|
var remoteDisplayName: String? {
|
|
switch self {
|
|
case .eligibility(_, let name), .incomingRequest(_, let name): return name
|
|
}
|
|
}
|
|
|
|
var id: String {
|
|
switch self {
|
|
case .eligibility(let id, _): return "eligibility-\(id)"
|
|
case .incomingRequest(let id, _): return "incoming-\(id)"
|
|
}
|
|
}
|
|
}
|
|
|
|
struct PairingPromptState: Equatable {
|
|
var prompt: PairingPrompt?
|
|
var busy = false
|
|
}
|
|
|
|
struct TargetedOfferState: Equatable {
|
|
var pending: [PendingTargetedOfferModel] = []
|
|
/// Display names for senders we already have saved. A sender we have not
|
|
/// saved has no trustworthy name, so the UI falls back to a generic label
|
|
/// rather than rendering a peer-supplied string as if it were verified.
|
|
var senderDisplayNames: [String: String] = [:]
|
|
var respondingIds: Set<String> = []
|
|
|
|
var current: PendingTargetedOfferModel? { pending.first }
|
|
|
|
var currentSenderDisplayName: String? {
|
|
guard let current else { return nil }
|
|
return senderDisplayNames[current.senderEndpointId]
|
|
}
|
|
}
|
|
|
|
enum SavedDeviceTransferDirection: Equatable, Sendable {
|
|
case outgoing
|
|
case incoming
|
|
}
|
|
|
|
/// One targeted transfer as the details surface renders it: resolved against the
|
|
/// local endpoint so "peer" means the *other* device, whichever side we are on.
|
|
struct SavedDeviceTransferItem: Equatable, Identifiable, Sendable {
|
|
let id: String
|
|
let peerEndpointId: String
|
|
let peerDisplayName: String?
|
|
let direction: SavedDeviceTransferDirection
|
|
let transferName: String
|
|
let fileCount: UInt64
|
|
let totalSize: UInt64
|
|
let verifiedBytes: UInt64
|
|
let state: TargetedTransferStateModel
|
|
let createdAt: Int64
|
|
let updatedAt: Int64
|
|
|
|
var progressFraction: Double? {
|
|
guard totalSize > 0, state.isActive || state == .interrupted else { return nil }
|
|
return min(1, Double(verifiedBytes) / Double(totalSize))
|
|
}
|
|
|
|
/// Pulling content is the receiving side's move. Gating on state alone put a
|
|
/// "Receive" button on the sender's own outgoing transfer, offering to
|
|
/// download the files it was in the middle of sending.
|
|
var canReceive: Bool { direction == .incoming && state.canReceive }
|
|
|
|
/// Resuming likewise pulls into a local folder, so it is receiver-only.
|
|
var canResume: Bool { direction == .incoming && state.canResume }
|
|
}
|