feat(apple): native SwiftUI app for iOS and macOS

Add a native SwiftUI VniDrop app (Send/Receive/Settings) talking to the Rust core via generated UniFFI Swift bindings, plus the uniffi-bindgen helper crate. iOS uses a TabView, macOS a NavigationSplitView sidebar.
2026-08-05 10:29:58 +02:00 · 2026-07-18 22:06:30 +02:00
parent 601cbc486e
commit ea376a382b
68 changed files with 8650 additions and 1 deletions
--- a/apple/VniDrop/Features/Send/FilePreviewRepository.swift
+++ b/apple/VniDrop/Features/Send/FilePreviewRepository.swift
@@ -0,0 +1,142 @@
+import Foundation
+import Combine
+
+/// Persisted per-transfer thumbnail store, ported from
+/// `feature/send/FilePreviewRepository.kt` + `PlatformPreviewStore.ios.kt`.
+/// Only small PNG/JPEG/WEBP previews are retained, under a total quota.
+struct PreviewStoragePolicy {
+	var maxEntryBytes: Int = 512 * 1024
+	var maxTotalBytes: Int64 = 20 * 1024 * 1024
+}
+
+private struct PreviewFileInfo {
+	let transferId: UInt64
+	let byteSize: Int64
+	let modifiedAtMillis: Int64
+}
+
+@MainActor
+final class FilePreviewRepository: ObservableObject {
+	@Published private(set) var previews: [UInt64: Data] = [:]
+
+	private let directory: String
+	private let policy: PreviewStoragePolicy
+	private let fm = FileManager.default
+
+	init(appDataDir: String, policy: PreviewStoragePolicy = PreviewStoragePolicy()) {
+		self.directory = (appDataDir as NSString).appendingPathComponent("ui/previews")
+		self.policy = policy
+	}
+
+	func restore(activeTransferIds: Set<UInt64>) {
+		let files = listFiles()
+		for file in files where !(activeTransferIds.contains(file.transferId)
+			&& (1...Int64(policy.maxEntryBytes)).contains(file.byteSize)) {
+			deleteFile(file.transferId)
+		}
+		enforceQuota()
+		var result: [UInt64: Data] = [:]
+		for file in listFiles() where activeTransferIds.contains(file.transferId) {
+			if let data = readFile(file.transferId), data.isSupportedPreview, data.count <= policy.maxEntryBytes {
+				result[file.transferId] = data
+			} else {
+				deleteFile(file.transferId)
+			}
+		}
+		previews = result
+	}
+
+	func save(transferId: UInt64, bytes: Data) {
+		guard (1...policy.maxEntryBytes).contains(bytes.count), bytes.isSupportedPreview else { return }
+		guard writeAtomically(transferId: transferId, bytes: bytes) else { return }
+		enforceQuota(protectedTransferId: transferId)
+		if readFile(transferId) != nil {
+			previews[transferId] = bytes
+		}
+	}
+
+	func remove(transferId: UInt64) {
+		deleteFile(transferId)
+		previews.removeValue(forKey: transferId)
+	}
+
+	// MARK: - Store (ported from IosPreviewStore)
+
+	private func enforceQuota(protectedTransferId: UInt64? = nil) {
+		let files = listFiles().sorted { $0.modifiedAtMillis < $1.modifiedAtMillis }
+		var total = files.reduce(Int64(0)) { $0 + $1.byteSize }
+		for file in files {
+			if total <= policy.maxTotalBytes { break }
+			if file.transferId == protectedTransferId { continue }
+			deleteFile(file.transferId)
+			total -= file.byteSize
+			previews.removeValue(forKey: file.transferId)
+		}
+	}
+
+	private func ensureDirectory() {
+		try? fm.createDirectory(atPath: directory, withIntermediateDirectories: true)
+	}
+
+	private func path(_ transferId: UInt64) -> String {
+		(directory as NSString).appendingPathComponent("\(transferId).preview")
+	}
+
+	private func listFiles() -> [PreviewFileInfo] {
+		ensureDirectory()
+		guard let names = try? fm.contentsOfDirectory(atPath: directory) else { return [] }
+		return names.compactMap { name in
+			guard name.hasSuffix(".preview"),
+				let id = UInt64(name.replacingOccurrences(of: ".preview", with: "")) else { return nil }
+			let full = (directory as NSString).appendingPathComponent(name)
+			guard let attrs = try? fm.attributesOfItem(atPath: full) else { return nil }
+			let size = (attrs[.size] as? NSNumber)?.int64Value ?? 0
+			let modified = ((attrs[.modificationDate] as? Date)?.timeIntervalSince1970 ?? 0) * 1000
+			return PreviewFileInfo(transferId: id, byteSize: size, modifiedAtMillis: Int64(modified))
+		}
+	}
+
+	private func readFile(_ transferId: UInt64) -> Data? {
+		try? Data(contentsOf: URL(fileURLWithPath: path(transferId)))
+	}
+
+	private func writeAtomically(transferId: UInt64, bytes: Data) -> Bool {
+		ensureDirectory()
+		if fm.fileExists(atPath: path(transferId)) { return true }
+		let temporary = (directory as NSString).appendingPathComponent(".\(transferId).tmp")
+		do {
+			try bytes.write(to: URL(fileURLWithPath: temporary), options: .atomic)
+		} catch {
+			return false
+		}
+		do {
+			if fm.fileExists(atPath: path(transferId)) {
+				try? fm.removeItem(atPath: temporary)
+				return true
+			}
+			try fm.moveItem(atPath: temporary, toPath: path(transferId))
+			return true
+		} catch {
+			try? fm.removeItem(atPath: temporary)
+			return false
+		}
+	}
+
+	private func deleteFile(_ transferId: UInt64) {
+		try? fm.removeItem(atPath: path(transferId))
+	}
+}
+
+extension Data {
+	/// Matches `isSupportedPreview()`: PNG / JPEG / WEBP magic bytes.
+	var isSupportedPreview: Bool {
+		let bytes = [UInt8](self)
+		let png = bytes.count >= 8 && bytes[0] == 0x89
+			&& bytes[1] == 0x50 && bytes[2] == 0x4E && bytes[3] == 0x47   // "PNG"
+		let jpeg = bytes.count >= 3 && bytes[0] == 0xFF && bytes[1] == 0xD8 && bytes[2] == 0xFF
+		let webp = bytes.count >= 12
+			&& bytes[0] == 0x52 && bytes[1] == 0x49 && bytes[2] == 0x46 && bytes[3] == 0x46   // "RIFF"
+			&& bytes[8] == 0x57 && bytes[9] == 0x45 && bytes[10] == 0x42 && bytes[11] == 0x50 // "WEBP"
+		return png || jpeg || webp
+	}
+}
--- a/apple/VniDrop/Features/Send/SendModel.swift
+++ b/apple/VniDrop/Features/Send/SendModel.swift
@@ -0,0 +1,285 @@
+import Foundation
+import Combine
+
+enum TransferDetailPanel: Equatable {
+	case activity
+	case receivers
+	case share
+}
+
+/// Which invitation delivery action produced a result (for success copy).
+enum InvitationAction {
+	case export
+	case share
+	case nfc
+}
+
+/// Send feature state, ported from `feature/send/SendViewModel.kt` (`SendState`).
+struct SendState: Equatable {
+	var isComposerOpen = false
+	var selectedFiles: [PickedShareFile] = []
+	var transferName = ""
+	var senderName = ""
+	var accessPolicy: ShareAccessPolicy = .requireApproval
+	var isSharing = false
+	var selectedTransferId: UInt64?
+	var transferThumbnails: [UInt64: Data] = [:]
+	var detailPanel: TransferDetailPanel?
+	var receiverHistory: [ReceiverRequestModel] = []
+	var isLoadingReceivers = false
+	var isDeleteConfirmationOpen = false
+	var isDeleting = false
+
+	func canCreateShare(coreInitialized: Bool) -> Bool {
+		coreInitialized && !selectedFiles.isEmpty && !transferName.isEmpty && !isSharing
+	}
+}
+
+@MainActor
+final class SendModel: ObservableObject {
+	@Published private(set) var state = SendState()
+	@Published private(set) var coreState = CoreState()
+
+	/// Requests a file/folder pick or clipboard copy, consumed by the view layer.
+	@Published var pendingFilePick = false
+	@Published var pendingFolderPick = false
+
+	private let repository: CoreRepository
+	private let fileSystemService: FileSystemService
+	private let filePreviewRepository: FilePreviewRepository
+	private let messages: UiMessageController
+	private var cancellables = Set<AnyCancellable>()
+
+	init(
+		repository: CoreRepository,
+		fileSystemService: FileSystemService,
+		preferences: AppPreferencesRepository,
+		filePreviewRepository: FilePreviewRepository,
+		messages: UiMessageController
+	) {
+		self.repository = repository
+		self.fileSystemService = fileSystemService
+		self.filePreviewRepository = filePreviewRepository
+		self.messages = messages
+
+		repository.$state.sink { [weak self] in self?.coreState = $0 }.store(in: &cancellables)
+
+		repository.signals
+			.sink { [weak self] signal in
+				guard let self else { return }
+				switch signal {
+				case .transfersChanged:
+					Task { _ = await self.repository.refresh() }
+				case .receiverHistoryChanged(let id), .approvalChanged(let id):
+					if id == self.state.selectedTransferId { self.refreshReceivers(id) }
+				}
+			}
+			.store(in: &cancellables)
+
+		filePreviewRepository.$previews
+			.sink { [weak self] previews in self?.state.transferThumbnails = previews }
+			.store(in: &cancellables)
+
+		repository.$state
+			.map { core -> Set<UInt64>? in
+				core.isInitialized ? Set(core.transfers.map(\.transferId)) : nil
+			}
+			.removeDuplicates()
+			.sink { [weak self] ids in
+				if let ids { self?.filePreviewRepository.restore(activeTransferIds: ids) }
+			}
+			.store(in: &cancellables)
+
+		preferences.$preferences
+			.sink { [weak self] prefs in
+				guard let self else { return }
+				if self.state.senderName.isEmpty { self.state.senderName = prefs.username }
+			}
+			.store(in: &cancellables)
+	}
+
+	// MARK: - Composer
+
+	func openComposer() {
+		if state.isSharing { return }
+		let discarded = state.selectedFiles
+		state.isComposerOpen = true
+		state.selectedFiles = []
+		state.transferName = ""
+		state.accessPolicy = .requireApproval
+		discardPickedFiles(discarded)
+	}
+
+	func dismissComposer() {
+		if state.isSharing { return }
+		let discarded = state.selectedFiles
+		state.isComposerOpen = false
+		state.selectedFiles = []
+		state.transferName = ""
+		state.accessPolicy = .requireApproval
+		discardPickedFiles(discarded)
+	}
+
+	func selectFile() { pendingFilePick = true }
+	func selectFolder() { pendingFolderPick = true }
+
+	func onFilesPicked(_ files: [PickedShareFile]) {
+		if files.isEmpty { return }
+		let selectedValues = Set(files.map(\.value))
+		let discarded = state.selectedFiles.filter { !selectedValues.contains($0.value) }
+		state.isComposerOpen = true
+		state.selectedFiles = files
+		state.transferName = defaultTransferName(files)
+		discardPickedFiles(discarded)
+	}
+
+	func onFilePickFailed(_ reason: String) {
+		messages.error(InvitationError.message(reason.isEmpty ? "selection failed" : reason))
+	}
+
+	func clearSelectedSource() {
+		let discarded = state.selectedFiles
+		state.selectedFiles = []
+		state.transferName = ""
+		discardPickedFiles(discarded)
+	}
+
+	func removeSelectedFile(_ value: String) {
+		let discarded = state.selectedFiles.filter { $0.value == value }
+		let remaining = state.selectedFiles.filter { $0.value != value }
+		let wasDefault = state.transferName == defaultTransferName(state.selectedFiles)
+		state.selectedFiles = remaining
+		state.transferName = remaining.isEmpty ? "" : (wasDefault ? defaultTransferName(remaining) : state.transferName)
+		discardPickedFiles(discarded)
+	}
+
+	func setTransferName(_ value: String) { state.transferName = value }
+	func setSenderName(_ value: String) { state.senderName = value }
+	func setAccessPolicy(_ value: ShareAccessPolicy) { state.accessPolicy = value }
+
+	// MARK: - Transfer detail
+
+	func openTransfer(_ transferId: UInt64) {
+		state.selectedTransferId = transferId
+		state.detailPanel = nil
+		refreshReceivers(transferId)
+	}
+
+	func closeTransferDetails() {
+		state.selectedTransferId = nil
+		state.detailPanel = nil
+		state.receiverHistory = []
+		state.isDeleteConfirmationOpen = false
+	}
+
+	func openActivity() { state.detailPanel = .activity }
+	func openShare() { state.detailPanel = .share }
+	func openReceivers() {
+		guard let id = state.selectedTransferId else { return }
+		state.detailPanel = .receivers
+		refreshReceivers(id)
+	}
+	func closeDetailPanel() { state.detailPanel = nil }
+
+	func requestDeleteTransfer() { state.isDeleteConfirmationOpen = true }
+	func dismissDeleteTransfer() { if !state.isDeleting { state.isDeleteConfirmationOpen = false } }
+
+	func confirmDeleteTransfer() {
+		guard let transferId = state.selectedTransferId, !state.isDeleting else { return }
+		state.isDeleting = true
+		Task {
+			let result = await repository.delete(transferId: transferId)
+			switch result {
+			case .success:
+				filePreviewRepository.remove(transferId: transferId)
+				state.selectedTransferId = nil
+				state.detailPanel = nil
+				state.receiverHistory = []
+				state.isDeleteConfirmationOpen = false
+				state.isDeleting = false
+				messages.tryShow(UiMessage(text: .resource("transfer_deleted"), tone: .success))
+			case .failure(let error):
+				state.isDeleting = false
+				messages.error(error)
+			}
+		}
+	}
+
+	// MARK: - Invitation results / share
+
+	func onInvitationResult(_ action: InvitationAction, _ result: Result<Void, Error>) {
+		switch result {
+		case .success:
+			let key: String?
+			switch action {
+			case .export: key = "transfer_invitation_saved"
+			case .nfc: key = "transfer_nfc_written"
+			case .share: key = nil  // system share sheet already confirms
+			}
+			if let key { messages.tryShow(UiMessage(text: .resource(key), tone: .success)) }
+		case .failure(let error):
+			messages.error(error)
+		}
+	}
+
+	func createShare() {
+		let current = state
+		if current.selectedFiles.isEmpty { return }
+		if !current.canCreateShare(coreInitialized: coreState.isInitialized) { return }
+		state.isSharing = true
+		Task {
+			let result = await fileSystemService.sharePickedFiles(
+				repository: repository,
+				files: current.selectedFiles,
+				transferName: current.transferName.trimmingCharacters(in: .whitespacesAndNewlines),
+				senderName: current.senderName.trimmingCharacters(in: .whitespacesAndNewlines),
+				accessPolicy: current.accessPolicy
+			)
+			switch result {
+			case .success(let share):
+				await fileSystemService.discardPickedFiles(current.selectedFiles)
+				if let thumb = current.selectedFiles.compactMap(\.thumbnailData).first {
+					filePreviewRepository.save(transferId: share.transferId, bytes: thumb)
+				}
+				state.isComposerOpen = false
+				state.selectedFiles = []
+				state.transferName = ""
+				state.accessPolicy = .requireApproval
+				state.isSharing = false
+				messages.show(UiMessage(text: .resource("send_transfer_created"), tone: .success))
+			case .failure(let error):
+				state.isSharing = false
+				messages.error(error)
+			}
+		}
+	}
+
+	// MARK: - Internals
+
+	private func defaultTransferName(_ files: [PickedShareFile]) -> String {
+		if files.isEmpty { return "" }
+		if files.count == 1 { return files[0].displayName }
+		if files.allSatisfy(\.isDirectory) { return "\(files.count) folders" }
+		return "\(files.count) files"
+	}
+
+	private func discardPickedFiles(_ files: [PickedShareFile]) {
+		if files.isEmpty { return }
+		Task { await fileSystemService.discardPickedFiles(files) }
+	}
+
+	private func refreshReceivers(_ transferId: UInt64) {
+		state.isLoadingReceivers = true
+		Task {
+			let result = await repository.receiverRequests(transferId: transferId)
+			switch result {
+			case .success(let requests):
+				state.receiverHistory = requests
+				state.isLoadingReceivers = false
+			case .failure(let error):
+				state.isLoadingReceivers = false
+				messages.error(error)
+			}
+		}
+	}
+}
--- a/apple/VniDrop/Features/Send/SendScreen.swift
+++ b/apple/VniDrop/Features/Send/SendScreen.swift
@@ -0,0 +1,191 @@
+import SwiftUI
+
+/// Send screen, rebuilt on native SwiftUI. A grouped `List` of outgoing transfers,
+/// with the composer and detail panels as native sheets and delete as an alert.
+struct SendScreen: View {
+	@ObservedObject var model: SendModel
+	let windowClass: WindowClass
+
+	private var outgoing: [Transfer] {
+		model.coreState.transfers.filter { $0.direction == .send }
+	}
+	private var selectedTransfer: Transfer? {
+		guard let id = model.state.selectedTransferId else { return nil }
+		return outgoing.first { $0.transferId == id }
+	}
+
+	private var detailsBinding: Binding<Bool> {
+		Binding(get: { model.state.selectedTransferId != nil }, set: { if !$0 { model.closeTransferDetails() } })
+	}
+
+	var body: some View {
+		NavigationStack {
+			Group {
+				if outgoing.isEmpty {
+					ScrollView { emptyState }
+				} else {
+					catalog
+				}
+			}
+			.navigationTitle(Text(LocalizedStringKey("send_title")))
+			.toolbar {
+				ToolbarItem(placement: .primaryAction) {
+					Button(action: model.openComposer) {
+						Label(String(localized: "button_create_new_transfer"), systemImage: "plus")
+					}
+				}
+			}
+			.navigationDestination(isPresented: detailsBinding) {
+				if let transfer = selectedTransfer {
+					detailView(for: transfer)
+				}
+			}
+		}
+		.adaptiveDrawer(
+			isPresented: Binding(get: { model.state.isComposerOpen }, set: { _ in }),
+			windowClass: windowClass,
+			onDismiss: model.dismissComposer
+		) {
+			TransferComposer(model: model, windowClass: windowClass)
+		}
+	}
+
+	/// The pushed transfer details view, with its detail-panel sheet and delete
+	/// alert attached here so they present from the detail's own context (presenting
+	/// modals from the parent stack while a detail is pushed is unreliable on macOS).
+	private func detailView(for transfer: Transfer) -> some View {
+		TransferDetailsView(model: model, transfer: transfer, events: model.coreState.events)
+			.adaptiveDrawer(
+				isPresented: Binding(get: { model.state.detailPanel != nil }, set: { _ in }),
+				windowClass: windowClass,
+				onDismiss: model.closeDetailPanel
+			) {
+				if let panel = model.state.detailPanel {
+					DetailPanelContent(model: model, transfer: transfer, panel: panel)
+				}
+			}
+			.alert(
+				Text(LocalizedStringKey("transfer_delete_title")),
+				isPresented: Binding(get: { model.state.isDeleteConfirmationOpen }, set: { if !$0 { Task { @MainActor in model.dismissDeleteTransfer() } } })
+			) {
+				Button(String(localized: "button_cancel"), role: .cancel, action: model.dismissDeleteTransfer)
+				Button(String(localized: "button_delete_transfer"), role: .destructive, action: model.confirmDeleteTransfer)
+			} message: {
+				Text(String(format: String(localized: "transfer_delete_description"),
+							 transfer.transferName ?? String(localized: "send_new_transfer_title")))
+			}
+	}
+
+	private var catalog: some View {
+		List {
+			Section {
+				ForEach(outgoing) { transfer in
+					Button {
+						model.openTransfer(transfer.transferId)
+					} label: {
+						TransferListItem(
+							transfer: transfer,
+							thumbnail: model.state.transferThumbnails[transfer.transferId],
+							progress: progress(for: transfer)
+						)
+					}
+					.buttonStyle(.plain)
+				}
+			} header: {
+				Text(LocalizedStringKey("send_transfers_title"))
+			} footer: {
+				Text(LocalizedStringKey("send_subtitle"))
+			}
+		}
+	}
+
+	private var emptyState: some View {
+		EmptyStateView(
+			systemImage: "paperplane",
+			title: String(localized: "send_empty_title"),
+			message: String(localized: "send_empty_body")
+		) {
+			Button(action: model.openComposer) {
+				Label(String(localized: "button_create_new_transfer"), systemImage: "plus")
+			}
+			.buttonStyle(.borderedProminent)
+			.controlSize(.large)
+		}
+	}
+
+	private func progress(for transfer: Transfer) -> TransferProgress? {
+		switch transfer.status {
+		case .importing: return progressForTransfer(events: model.coreState.events, transferId: transfer.transferId)
+		case .sharing: return activeSendProgress(events: model.coreState.events, transferId: transfer.transferId, totalSizeHint: transfer.totalSize)
+		default: return nil
+		}
+	}
+}
+
+private struct TransferListItem: View {
+	let transfer: Transfer
+	let thumbnail: Data?
+	let progress: TransferProgress?
+
+	var body: some View {
+		HStack(spacing: 12) {
+			FileArtwork(thumbnail: thumbnail)
+				.frame(width: 40, height: 40)
+				.background(.quaternary, in: RoundedRectangle(cornerRadius: 9))
+			VStack(alignment: .leading, spacing: 3) {
+				HStack {
+					Text(transfer.transferName ?? String(localized: "send_new_transfer_title"))
+						.font(.body).lineLimit(1)
+					Spacer()
+					StatusPill(label: statusLabel(transfer.status), tone: transfer.status.pillTone)
+				}
+				Text("\(formatBytes(transfer.totalSize)) · \(accessPolicyLabel(transfer.accessPolicy))")
+					.font(.caption).foregroundStyle(.secondary).lineLimit(1)
+				if let progress, transfer.status == .importing || transfer.status == .sharing {
+					ProgressRow(labelKey: progress.labelKey, progress: progress.progress, detail: progress.detail)
+						.padding(.top, 2)
+				}
+			}
+			Image(systemName: "chevron.forward")
+				.font(.footnote.weight(.semibold)).foregroundStyle(.tertiary)
+		}
+		.contentShape(Rectangle())
+	}
+}
+
+struct FileArtwork: View {
+	let thumbnail: Data?
+
+	var body: some View {
+		if let thumbnail, let image = PlatformImage.from(data: thumbnail) {
+			image.resizable().aspectRatio(contentMode: .fill)
+				.clipShape(RoundedRectangle(cornerRadius: 8))
+		} else {
+			Image(systemName: "doc")
+				.font(.system(size: 18))
+				.foregroundStyle(.secondary)
+		}
+	}
+}
+
+func statusLabel(_ status: TransferStatus) -> String {
+	String(localized: String.LocalizationValue(statusLabelKey(status)))
+}
+
+func accessPolicyLabel(_ policy: ShareAccessPolicy) -> String {
+	switch policy {
+	case .requireApproval: return String(localized: "send_access_approval")
+	case .anyoneWithTransfer: return String(localized: "send_access_anyone")
+	}
+}
+
+extension TransferStatus {
+	var pillTone: PillTone {
+		switch self {
+		case .sharing, .done: return .brand
+		case .importing, .receiving: return .warning
+		case .failed, .cancelled: return .destructive
+		case .stopped: return .neutral
+		}
+	}
+}
--- a/apple/VniDrop/Features/Send/TransferComposer.swift
+++ b/apple/VniDrop/Features/Send/TransferComposer.swift
@@ -0,0 +1,169 @@
+import SwiftUI
+
+/// Transfer composer drawer, ported from `feature/send/TransferComposer.kt`.
+/// Two steps: choose files/folder, then review + name + access policy + share.
+struct TransferComposer: View {
+	@ObservedObject var model: SendModel
+	let windowClass: WindowClass
+
+	private var state: SendState { model.state }
+
+	var body: some View {
+		VStack(alignment: .leading, spacing: 16) {
+			if state.selectedFiles.isEmpty {
+				chooseStep
+			} else {
+				reviewStep
+			}
+		}
+		.padding(.horizontal, 20).padding(.vertical, 12)
+		.frame(maxWidth: .infinity, alignment: .leading)
+		.sendPickers(model: model)
+	}
+
+	private var chooseStep: some View {
+		VStack(alignment: .leading, spacing: 16) {
+			Text(LocalizedStringKey("send_choose_file_title")).font(.title2).fontWeight(.semibold)
+			Text(LocalizedStringKey("send_choose_file_body"))
+				.font(.subheadline).foregroundStyle(.secondary)
+			VStack(spacing: 14) {
+				Image(systemName: "doc").font(.system(size: 30)).foregroundStyle(.tint)
+				PrimaryButton(title: String(localized: "button_choose_files"), action: model.selectFile).fixedSize()
+				QuietButton(title: String(localized: "button_choose_folder"), action: model.selectFolder)
+			}
+			.frame(maxWidth: .infinity)
+			.padding(28)
+			.background(.quaternary.opacity(0.5), in: RoundedRectangle(cornerRadius: 16))
+		}
+	}
+
+	private var reviewStep: some View {
+		VStack(alignment: .leading, spacing: 16) {
+			Text(LocalizedStringKey("send_review_title")).font(.title2).fontWeight(.semibold)
+			if state.selectedFiles.count > 1 {
+				Text(String(format: String(localized: "send_selected_files_count"), state.selectedFiles.count))
+					.font(.subheadline).foregroundStyle(.secondary)
+			}
+			ForEach(state.selectedFiles) { file in
+				SelectedFileCard(
+					file: file,
+					canRemove: state.selectedFiles.count > 1 && !state.isSharing,
+					onRemove: { model.removeSelectedFile(file.value) }
+				)
+			}
+			Field(label: String(localized: "field_transfer_name"),
+				  value: Binding(get: { state.transferName }, set: model.setTransferName))
+			Field(label: String(localized: "field_sender_name"),
+				  value: Binding(get: { state.senderName }, set: model.setSenderName))
+			Text(LocalizedStringKey("send_access_title")).font(.headline)
+			PolicyOption(
+				icon: "checkmark.shield", titleKey: "send_access_approval", descKey: "send_access_approval_description",
+				selected: state.accessPolicy == .requireApproval,
+				onTap: { model.setAccessPolicy(.requireApproval) }
+			)
+			PolicyOption(
+				icon: "globe", titleKey: "send_access_anyone", descKey: "send_access_anyone_description",
+				selected: state.accessPolicy == .anyoneWithTransfer,
+				onTap: { model.setAccessPolicy(.anyoneWithTransfer) }
+			)
+			if state.accessPolicy == .anyoneWithTransfer {
+				Label(String(localized: "send_access_anyone_warning"), systemImage: "exclamationmark.triangle.fill")
+					.font(.caption).foregroundStyle(.orange)
+			}
+			actions
+		}
+	}
+
+	@ViewBuilder
+	private var actions: some View {
+		let shareTitle = state.isSharing
+			? String(localized: "button_sharing_file") : String(localized: "button_share_file")
+		let shareButton = PrimaryButton(
+			title: shareTitle, action: model.createShare,
+			enabled: state.canCreateShare(coreInitialized: model.coreState.isInitialized)
+		)
+		if windowClass == .phone {
+			VStack(spacing: 8) {
+				shareButton
+				QuietButton(title: String(localized: "button_change_files"), action: model.selectFile, enabled: !state.isSharing)
+				QuietButton(title: String(localized: "button_choose_folder"), action: model.selectFolder, enabled: !state.isSharing)
+			}
+		} else {
+			HStack(spacing: 8) {
+				shareButton.fixedSize()
+				QuietButton(title: String(localized: "button_change_files"), action: model.selectFile, enabled: !state.isSharing)
+				QuietButton(title: String(localized: "button_choose_folder"), action: model.selectFolder, enabled: !state.isSharing)
+				QuietButton(title: String(localized: "button_clear"), action: model.clearSelectedSource, enabled: !state.isSharing)
+			}
+		}
+	}
+}
+
+private struct SelectedFileCard: View {
+	let file: PickedShareFile
+	let canRemove: Bool
+	let onRemove: () -> Void
+
+	var body: some View {
+		HStack(spacing: 12) {
+			FileArtwork(thumbnail: file.thumbnailData)
+				.frame(width: 44, height: 44)
+				.background(.quaternary, in: RoundedRectangle(cornerRadius: 10))
+			VStack(alignment: .leading, spacing: 3) {
+				Text(file.displayName).lineLimit(1)
+				Text(subtitle).font(.caption).foregroundStyle(.secondary)
+			}
+			Spacer()
+			if canRemove {
+				Button(role: .destructive, action: onRemove) {
+					Image(systemName: "trash")
+				}
+				.buttonStyle(.borderless)
+				.tint(.red)
+			}
+		}
+		.padding(14)
+		.frame(maxWidth: .infinity)
+		.background(.quaternary.opacity(0.5), in: RoundedRectangle(cornerRadius: 14))
+	}
+
+	private var subtitle: String {
+		if file.isDirectory { return String(localized: "send_folder_label") }
+		if let size = file.sizeBytes { return formatBytes(size) }
+		return String(localized: "send_file_size_unknown")
+	}
+}
+
+private struct PolicyOption: View {
+	let icon: String
+	let titleKey: String
+	let descKey: String
+	let selected: Bool
+	let onTap: () -> Void
+
+	var body: some View {
+		Button(action: onTap) {
+			HStack(spacing: 12) {
+				Image(systemName: icon)
+					.font(.system(size: 20))
+					.foregroundStyle(selected ? AnyShapeStyle(.tint) : AnyShapeStyle(.secondary))
+					.frame(width: 22)
+				VStack(alignment: .leading, spacing: 3) {
+					Text(LocalizedStringKey(titleKey))
+					Text(LocalizedStringKey(descKey)).font(.caption).foregroundStyle(.secondary)
+				}
+				Spacer()
+				Image(systemName: selected ? "checkmark.circle.fill" : "circle")
+					.foregroundStyle(selected ? AnyShapeStyle(.tint) : AnyShapeStyle(.tertiary))
+			}
+			.padding(14)
+			.frame(maxWidth: .infinity)
+			.background(.quaternary.opacity(selected ? 0.8 : 0.4), in: RoundedRectangle(cornerRadius: 14))
+			.overlay(
+				RoundedRectangle(cornerRadius: 14)
+					.stroke(selected ? AnyShapeStyle(.tint) : AnyShapeStyle(.clear), lineWidth: 1.5)
+			)
+		}
+		.buttonStyle(.plain)
+	}
+}
--- a/apple/VniDrop/Features/Send/TransferDetailsView.swift
+++ b/apple/VniDrop/Features/Send/TransferDetailsView.swift
@@ -0,0 +1,328 @@
+import SwiftUI
+import CoreImage.CIFilterBuiltins
+
+/// Transfer details + drawer panels, ported from `feature/send/TransferDetails.kt`.
+
+struct TransferDetailsView: View {
+	@ObservedObject var model: SendModel
+	let transfer: Transfer
+	let events: [CoreEventModel]
+
+	private var pendingReceivers: Int {
+		model.state.receiverHistory.filter { $0.status == .requested || $0.status == .accepted }.count
+	}
+	private var completedReceivers: Int {
+		model.state.receiverHistory.filter { $0.status == .completed }.count
+	}
+
+	var body: some View {
+		Form {
+			Section {
+				LabeledContent(String(localized: "metadata_status"), value: statusLabel(transfer.status))
+				LabeledContent(String(localized: "metadata_size"), value: formatBytes(transfer.totalSize))
+				LabeledContent(String(localized: "send_access_title"), value: accessPolicyLabel(transfer.accessPolicy))
+			} header: {
+				Text(transfer.transferName ?? String(localized: "send_new_transfer_title"))
+			}
+
+			Section {
+				DetailDestination(
+					title: String(localized: "transfer_activity_title"),
+					description: String(localized: "transfer_activity_description"),
+					count: events.filter { $0.transferId == transfer.transferId && $0.isMeaningfulActivity }.count,
+					onTap: model.openActivity
+				)
+				DetailDestination(
+					title: String(localized: "transfer_receivers_title"),
+					description: receiversDescription(pendingReceivers, completedReceivers),
+					count: pendingReceivers + completedReceivers,
+					onTap: model.openReceivers
+				)
+				DetailDestination(
+					title: String(localized: "transfer_share_title"),
+					description: String(localized: "transfer_share_description"),
+					count: 0,
+					onTap: model.openShare
+				)
+			}
+		}
+		.formStyle(.grouped)
+		.navigationTitle(Text(LocalizedStringKey("send_transfer_details_title")))
+		#if os(iOS)
+		.navigationBarTitleDisplayMode(.inline)
+		#endif
+		.toolbar {
+			ToolbarItem(placement: .primaryAction) {
+				Button(role: .destructive, action: model.requestDeleteTransfer) {
+					Image(systemName: "trash")
+				}
+			}
+		}
+	}
+}
+
+private func receiversDescription(_ pending: Int, _ completed: Int) -> String {
+	if pending > 0 && completed > 0 {
+		return "\(String(format: String(localized: "transfer_receivers_pending"), pending)) · \(String(format: String(localized: "transfer_receivers_completed_count"), completed))"
+	}
+	if pending > 0 { return String(format: String(localized: "transfer_receivers_pending"), pending) }
+	if completed > 0 { return String(format: String(localized: "transfer_receivers_completed_count"), completed) }
+	return String(localized: "transfer_receivers_description")
+}
+
+private struct DetailDestination: View {
+	let title: String
+	let description: String
+	let count: Int
+	let onTap: () -> Void
+	var body: some View {
+		Button(action: onTap) {
+			HStack {
+				VStack(alignment: .leading, spacing: 3) {
+					Text(title).foregroundStyle(.primary)
+					Text(description).font(.caption).foregroundStyle(.secondary)
+				}
+				Spacer()
+				if count > 0 {
+					Text("\(count)")
+						.font(.footnote)
+						.foregroundStyle(.secondary)
+				}
+				Image(systemName: "chevron.forward")
+					.font(.footnote.weight(.semibold)).foregroundStyle(.tertiary)
+			}
+			.contentShape(Rectangle())
+		}
+		.buttonStyle(.plain)
+	}
+}
+
+// MARK: - Detail panels
+
+struct DetailPanelContent: View {
+	@ObservedObject var model: SendModel
+	let transfer: Transfer
+	let panel: TransferDetailPanel
+
+	var body: some View {
+		switch panel {
+		case .activity:
+			TransferActivityPanel(events: model.coreState.events, transferId: transfer.transferId)
+		case .receivers:
+			ReceiverHistoryPanel(
+				receivers: model.state.receiverHistory,
+				loading: model.state.isLoadingReceivers,
+				events: model.coreState.events,
+				transferTotalSize: transfer.totalSize
+			)
+		case .share:
+			TransferSharePanel(model: model, transfer: transfer)
+		}
+	}
+}
+
+private struct PanelContainer<Content: View>: View {
+	let title: String
+	@ViewBuilder let content: () -> Content
+	var body: some View {
+		VStack(alignment: .leading, spacing: 14) {
+			Text(title).font(VniType.titleLarge)
+			content()
+		}
+		.padding(.horizontal, 20).padding(.vertical, 14)
+		.frame(maxWidth: .infinity, alignment: .leading)
+	}
+}
+
+struct TransferActivityPanel: View {
+	@Environment(\.vniColors) private var colors
+	let events: [CoreEventModel]
+	let transferId: UInt64
+
+	var body: some View {
+		let visible = events
+			.filter { $0.transferId == transferId && $0.isMeaningfulActivity }
+			.sorted { $0.timestamp > $1.timestamp }
+		PanelContainer(title: String(localized: "transfer_activity_title")) {
+			if visible.isEmpty {
+				Text(LocalizedStringKey("transfer_no_activity")).foregroundStyle(colors.foregroundLighter)
+			} else {
+				ForEach(Array(visible.enumerated()), id: \.offset) { index, event in
+					if index > 0 { Divider().overlay(colors.borderDefault) }
+					Text(LocalizedStringKey(event.activityTitleKey))
+						.fontWeight(.medium).padding(.vertical, 14)
+				}
+			}
+		}
+	}
+}
+
+struct ReceiverHistoryPanel: View {
+	@Environment(\.vniColors) private var colors
+	let receivers: [ReceiverRequestModel]
+	let loading: Bool
+	let events: [CoreEventModel]
+	let transferTotalSize: UInt64
+
+	var body: some View {
+		PanelContainer(title: String(localized: "transfer_receivers_title")) {
+			if loading {
+				ProgressView().frame(maxWidth: .infinity).padding(40)
+			} else if receivers.isEmpty {
+				Text(LocalizedStringKey("transfer_no_receivers")).foregroundStyle(colors.foregroundLighter)
+			} else {
+				ForEach(Array(receivers.enumerated()), id: \.element.id) { index, receiver in
+					if index > 0 { Divider().overlay(colors.borderDefault) }
+					ReceiverRow(receiver: receiver, sendProgress: sendProgress(for: receiver))
+				}
+			}
+		}
+	}
+
+	private func sendProgress(for receiver: ReceiverRequestModel) -> TransferProgress? {
+		switch receiver.status {
+		case .accepted, .requested:
+			return progressForReceiver(events: events, transferId: receiver.transferId,
+									   remoteEndpointId: receiver.remoteEndpointId, totalSizeHint: transferTotalSize)
+		default: return nil
+		}
+	}
+}
+
+private struct ReceiverRow: View {
+	@Environment(\.vniColors) private var colors
+	let receiver: ReceiverRequestModel
+	let sendProgress: TransferProgress?
+
+	var body: some View {
+		let name = receiver.receiverName ?? receiver.receiverDeviceName ?? String(localized: "transfer_nearby_device")
+		let showLive = sendProgress != nil && receiver.status != .completed
+			&& receiver.status != .refused && receiver.status != .expired
+		VStack(alignment: .leading, spacing: 6) {
+			Text(name).font(VniType.bodyLarge).lineLimit(1)
+			if let deviceName = receiver.receiverDeviceName, deviceName != name {
+				Text(deviceName).font(VniType.bodySmall).foregroundStyle(colors.foregroundLighter)
+			}
+			if showLive, let sendProgress {
+				ProgressRow(labelKey: sendProgress.labelKey, progress: sendProgress.progress, detail: sendProgress.detail)
+			} else {
+				Text(LocalizedStringKey(receiver.status.statusTextKey))
+					.font(VniType.bodySmall).fontWeight(.medium)
+					.foregroundStyle(receiver.status.statusColor(colors))
+			}
+			if let reason = receiver.reason, !reason.isEmpty {
+				Text(reason).font(VniType.bodySmall).foregroundStyle(colors.foregroundLighter)
+			}
+		}
+		.frame(maxWidth: .infinity, alignment: .leading)
+		.padding(.vertical, 13)
+	}
+}
+
+struct TransferSharePanel: View {
+	@Environment(\.vniColors) private var colors
+	@ObservedObject var model: SendModel
+	let transfer: Transfer
+
+	var body: some View {
+		PanelContainer(title: String(localized: "transfer_share_title")) {
+			if let ticket = transfer.ticket {
+				qrCard(ticket: ticket)
+				Text(LocalizedStringKey("transfer_scan_qr"))
+					.font(VniType.bodySmall).foregroundStyle(colors.foregroundLighter)
+					.frame(maxWidth: .infinity)
+				ShareActionsView(model: model, transfer: transfer, ticket: ticket)
+			} else {
+				Text(LocalizedStringKey("transfer_event_preparing")).foregroundStyle(colors.foregroundLighter)
+			}
+		}
+	}
+
+	private func qrCard(ticket: String) -> some View {
+		ZStack {
+			if let qr = QRCode.generate(from: ticket) {
+				qr.interpolation(.none).resizable().scaledToFit().padding(14)
+			} else {
+				ProgressView()
+			}
+		}
+		.frame(width: 268, height: 268)
+		.background(Color.white, in: RoundedRectangle(cornerRadius: 18))
+		.frame(maxWidth: .infinity)
+	}
+}
+
+// MARK: - QR generation (CoreImage)
+
+enum QRCode {
+	static func generate(from string: String) -> Image? {
+		let context = CIContext()
+		let filter = CIFilter.qrCodeGenerator()
+		filter.message = Data(string.utf8)
+		filter.correctionLevel = "M"
+		guard let output = filter.outputImage else { return nil }
+		let scaled = output.transformed(by: CGAffineTransform(scaleX: 10, y: 10))
+		guard let cgImage = context.createCGImage(scaled, from: scaled.extent) else { return nil }
+		#if os(iOS)
+		return Image(uiImage: UIImage(cgImage: cgImage))
+		#else
+		return Image(nsImage: NSImage(cgImage: cgImage, size: .zero))
+		#endif
+	}
+}
+
+// MARK: - Event helpers (ported from TransferDetails.kt)
+
+extension CoreEventModel {
+	var isMeaningfulActivity: Bool {
+		(phase == "import" && kind == "started")
+			|| (phase == "ticket" && kind == "created")
+			|| (phase == "network" && (kind == "connecting" || kind == "connected"))
+			|| (phase == "download" && kind == "found-collection")
+			|| (phase == "lifecycle" && ["done", "cancelled", "share-stopped"].contains(kind))
+			|| ["receiver-requested", "receiver-accepted", "receiver-auto-approved",
+				"receiver-refused", "receiver-completed", "share-stopped", "failed"].contains(kind)
+	}
+
+	var activityTitleKey: String {
+		if phase == "import" && kind == "started" { return "transfer_event_preparing" }
+		if phase == "ticket" && kind == "created" { return "transfer_event_ready" }
+		if phase == "network" { return "transfer_event_connecting" }
+		if phase == "download" { return "transfer_event_downloading" }
+		if phase == "export" { return "transfer_event_saving" }
+		if kind == "receiver-requested" { return "transfer_event_requested" }
+		if kind == "receiver-accepted" || kind == "receiver-auto-approved" { return "transfer_event_approved" }
+		if kind == "receiver-refused" { return "transfer_event_refused" }
+		if kind == "receiver-completed" { return "transfer_event_completed" }
+		if kind == "share-stopped" || (phase == "lifecycle" && kind == "cancelled") { return "transfer_event_stopped" }
+		if kind == "failed" { return "transfer_event_failed" }
+		return "transfer_event_updated"
+	}
+}
+
+extension ReceiverDeliveryStatus {
+	var statusTextKey: String {
+		switch self {
+		case .requested: return "transfer_receiver_requested"
+		case .accepted: return "transfer_receiver_accepted"
+		case .refused: return "transfer_receiver_refused"
+		case .expired: return "transfer_receiver_expired"
+		case .completed: return "transfer_receiver_completed"
+		case .unknown: return "transfer_receiver_unknown"
+		}
+	}
+
+	func statusColor(_ colors: VniDropColors) -> Color {
+		switch self {
+		case .completed: return colors.brandDefault
+		case .refused, .expired: return colors.destructiveDefault
+		default: return colors.foregroundLighter
+		}
+	}
+}
+
+#if os(iOS)
+import UIKit
+#else
+import AppKit
+#endif
--- a/apple/VniDrop/Features/Send/TransferShareActions.swift
+++ b/apple/VniDrop/Features/Send/TransferShareActions.swift
@@ -0,0 +1,61 @@
+import SwiftUI
+
+enum NfcShareAvailability { case available, unavailable, hidden }
+
+/// Invitation delivery actions, ported from `TransferShareActions` (iosMain).
+/// Platform implementations perform export, native share, and NFC write.
+@MainActor
+protocol TransferShareActions: AnyObject {
+	var canUseNativeShare: Bool { get }
+	var nfcAvailability: NfcShareAvailability { get }
+
+	func exportInvitation(ticket: String, transferName: String, onResult: @escaping (Result<Void, Error>) -> Void)
+	func shareInvitation(ticket: String, transferName: String, onResult: @escaping (Result<Void, Error>) -> Void)
+	func writeInvitationToNfc(ticket: String, onResult: @escaping (Result<Void, Error>) -> Void)
+	func cancelNfcWrite()
+}
+
+/// The QR + delivery buttons for a transfer's share panel, ported from the button
+/// stack in `TransferSharePanel` (`TransferDetails.kt`).
+struct ShareActionsView: View {
+	@Environment(\.vniColors) private var colors
+	@ObservedObject var model: SendModel
+	let transfer: Transfer
+	let ticket: String
+
+	@State private var actions: TransferShareActions = makePlatformShareActions()
+	@State private var writingNfc = false
+
+	var body: some View {
+		VStack(spacing: 12) {
+			if actions.nfcAvailability != .hidden {
+				SecondaryButton(
+					title: writingNfc ? String(localized: "transfer_nfc_waiting") : String(localized: "button_write_nfc"),
+					action: {
+						writingNfc = true
+						actions.writeInvitationToNfc(ticket: ticket) { result in
+							writingNfc = false
+							model.onInvitationResult(.nfc, result)
+						}
+					},
+					enabled: actions.nfcAvailability == .available && !writingNfc
+				)
+				if actions.nfcAvailability == .unavailable {
+					Text(LocalizedStringKey("transfer_nfc_unavailable"))
+						.font(VniType.bodySmall).foregroundStyle(colors.foregroundLighter)
+				}
+			}
+			SecondaryButton(title: String(localized: "button_download_invitation"), action: {
+				actions.exportInvitation(ticket: ticket, transferName: transfer.transferName ?? "") {
+					model.onInvitationResult(.export, $0)
+				}
+			})
+			PrimaryButton(title: String(localized: "button_native_share"), action: {
+				actions.shareInvitation(ticket: ticket, transferName: transfer.transferName ?? "") {
+					model.onInvitationResult(.share, $0)
+				}
+			}, enabled: actions.canUseNativeShare)
+		}
+		.onDisappear { actions.cancelNfcWrite() }
+	}
+}