diff --git a/Nextcloud.xcodeproj/project.pbxproj b/Nextcloud.xcodeproj/project.pbxproj index c417bfcbcf..cf31d08699 100644 --- a/Nextcloud.xcodeproj/project.pbxproj +++ b/Nextcloud.xcodeproj/project.pbxproj @@ -110,6 +110,9 @@ AB7000042F70000100FE2776 /* NCShareDetailsGovernanceModel.swift in Sources */ = {isa = PBXBuildFile; fileRef = AB7000032F70000100FE2776 /* NCShareDetailsGovernanceModel.swift */; }; AB7000062F70000100FE2776 /* NCGovernanceLabelSelectorView.swift in Sources */ = {isa = PBXBuildFile; fileRef = AB7000052F70000100FE2776 /* NCGovernanceLabelSelectorView.swift */; }; AC13ADAF2026101300000002 /* NCMediaAdaptiveLayoutViewTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = AC13ADAF2026101300000001 /* NCMediaAdaptiveLayoutViewTests.swift */; }; + B1E071012026102100000002 /* NCContextMenuViewerTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = B1E071012026102100000001 /* NCContextMenuViewerTests.swift */; }; + B1E071012026111000000002 /* NCViewerPhotoEditTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = B1E071012026111000000001 /* NCViewerPhotoEditTests.swift */; }; + B1E071012026111000000004 /* MockViewerPhotoEditSource.swift in Sources */ = {isa = PBXBuildFile; fileRef = B1E071012026111000000003 /* MockViewerPhotoEditSource.swift */; }; AC14ADAF2026101400000002 /* NCMediaAdaptiveControlsLayout.swift in Sources */ = {isa = PBXBuildFile; fileRef = AC14ADAF2026101400000001 /* NCMediaAdaptiveControlsLayout.swift */; }; AC14ADAF2026101400000012 /* NCMediaViewerPreviewLoader.swift in Sources */ = {isa = PBXBuildFile; fileRef = AC14ADAF2026101400000011 /* NCMediaViewerPreviewLoader.swift */; }; AF1A9B6427D0CA1E00F17A9E /* UIAlertController+Extension.swift in Sources */ = {isa = PBXBuildFile; fileRef = AF1A9B6327D0CA1E00F17A9E /* UIAlertController+Extension.swift */; }; @@ -1411,6 +1414,9 @@ AB7000032F70000100FE2776 /* NCShareDetailsGovernanceModel.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = NCShareDetailsGovernanceModel.swift; sourceTree = ""; }; AB7000052F70000100FE2776 /* NCGovernanceLabelSelectorView.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = NCGovernanceLabelSelectorView.swift; sourceTree = ""; }; AC13ADAF2026101300000001 /* NCMediaAdaptiveLayoutViewTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = NCMediaAdaptiveLayoutViewTests.swift; sourceTree = ""; }; + B1E071012026102100000001 /* NCContextMenuViewerTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = NCContextMenuViewerTests.swift; sourceTree = ""; }; + B1E071012026111000000001 /* NCViewerPhotoEditTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = NCViewerPhotoEditTests.swift; sourceTree = ""; }; + B1E071012026111000000003 /* MockViewerPhotoEditSource.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MockViewerPhotoEditSource.swift; sourceTree = ""; }; AC14ADAF2026101400000001 /* NCMediaAdaptiveControlsLayout.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = NCMediaAdaptiveControlsLayout.swift; sourceTree = ""; }; AC14ADAF2026101400000011 /* NCMediaViewerPreviewLoader.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = NCMediaViewerPreviewLoader.swift; sourceTree = ""; }; AF1A9B6327D0CA1E00F17A9E /* UIAlertController+Extension.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "UIAlertController+Extension.swift"; sourceTree = ""; }; @@ -2321,6 +2327,9 @@ AB1028260000000000050300 /* NCShareUploadNamePlannerTests.swift */, AB1028260000000000040000 /* NCShareLoaderItemProviderTests.swift */, 4B74B947E07444CC9CFE0A6C /* NCDocumentEditorSupportTests.swift */, + B1E071012026102100000001 /* NCContextMenuViewerTests.swift */, + B1E071012026111000000001 /* NCViewerPhotoEditTests.swift */, + B1E071012026111000000003 /* MockViewerPhotoEditSource.swift */, ); path = NextcloudUnitTests; sourceTree = ""; @@ -4703,6 +4712,9 @@ AB1028260000000000040001 /* NCShareLoaderItemProviderTests.swift in Sources */, AB1028260000000000040002 /* NCShareLoaderItemProvider.swift in Sources */, 22BA14432CF44BDBA2E6C291 /* NCDocumentEditorSupportTests.swift in Sources */, + B1E071012026102100000002 /* NCContextMenuViewerTests.swift in Sources */, + B1E071012026111000000002 /* NCViewerPhotoEditTests.swift in Sources */, + B1E071012026111000000004 /* MockViewerPhotoEditSource.swift in Sources */, F372087D2BAB4C0F006B5430 /* TestConstants.swift in Sources */, F78E2D6C29AF02DB0024D4F3 /* Database.swift in Sources */, ); diff --git a/Tests/NextcloudUnitTests/MockViewerPhotoEditSource.swift b/Tests/NextcloudUnitTests/MockViewerPhotoEditSource.swift new file mode 100644 index 0000000000..0895d3c329 --- /dev/null +++ b/Tests/NextcloudUnitTests/MockViewerPhotoEditSource.swift @@ -0,0 +1,54 @@ +// SPDX-FileCopyrightText: Nextcloud GmbH +// SPDX-FileCopyrightText: 2026 Matt Van Horn +// SPDX-License-Identifier: GPL-3.0-or-later + +import Foundation +@testable import Nextcloud + +/// A viewer stand-in for photo editing tests. The download stays pending +/// until the test calls `finishDownload(error:)`, and the shown photo can be +/// changed while it waits. `present(_:)` records each editor it would open. +@MainActor +final class MockViewerPhotoEditSource: NCViewerPhotoEditSource { + var shownOcId: String? + var isOnScreen = true + private(set) var downloadRequests: [String] = [] + private(set) var presentedOcIds: [String] = [] + private var pendingDownloads: [CheckedContinuation] = [] + + init(shownOcId: String?) { + self.shownOcId = shownOcId + } + + var hasPendingDownload: Bool { + !pendingDownloads.isEmpty + } + + func downloadOriginalForEditing(_ metadata: tableMetadata) async throws { + downloadRequests.append(metadata.ocId) + try await withCheckedThrowingContinuation { continuation in + pendingDownloads.append(continuation) + } + } + + func finishDownload(error: Error? = nil) { + let continuations = pendingDownloads + pendingDownloads.removeAll() + for continuation in continuations { + if let error { + continuation.resume(throwing: error) + } else { + continuation.resume() + } + } + } + + /// Records that the editor was opened for this photo. + func present(_ metadata: tableMetadata) { + presentedOcIds.append(metadata.ocId) + } + + func isShowingMedia(ocId: String) -> Bool { + isOnScreen && shownOcId == ocId + } +} diff --git a/Tests/NextcloudUnitTests/NCContextMenuViewerTests.swift b/Tests/NextcloudUnitTests/NCContextMenuViewerTests.swift new file mode 100644 index 0000000000..20404cb0c0 --- /dev/null +++ b/Tests/NextcloudUnitTests/NCContextMenuViewerTests.swift @@ -0,0 +1,131 @@ +// SPDX-FileCopyrightText: Nextcloud GmbH +// SPDX-FileCopyrightText: 2026 Marino Faggiana +// SPDX-License-Identifier: GPL-3.0-or-later + +import Testing +import UIKit +import NextcloudKit +@testable import Nextcloud + +@Suite("Photo viewer edit menu", .serialized) +@MainActor +struct NCContextMenuViewerTests { + private let account = "viewer-edit-menu" + + @Test("An online preview-only image offers one Edit action without downloading") + func previewOnlyImageOffersEdit() async throws { + try await performOnline { + let metadata = makeImage(fileName: "photo.jpg") + #expect(metadata.isImage) + #expect(metadata.isModifiableWithQuickLook) + #expect(metadata.session.isEmpty) + #expect(metadata.status == NCGlobal.shared.metadataStatusNormal) + + let menu = try #require(viewMenu(for: metadata, webView: false)) + + #expect(editActions(in: menu).count == 1) + #expect(metadata.session.isEmpty) + #expect(metadata.status == NCGlobal.shared.metadataStatusNormal) + let stored = await NCManageDatabase.shared.getMetadataFromOcIdAsync(metadata.ocId) + #expect(stored?.ocId == nil) + } + } + + @Test("Web view, non-images, and encrypted photos omit Edit") + func ineligibleItemsOmitEdit() async throws { + try await performOnline { + let webPhoto = makeImage(fileName: "web.jpg") + let webMenu = try #require(viewMenu(for: webPhoto, webView: true)) + #expect(editActions(in: webMenu).isEmpty) + + let video = makeImage(fileName: "clip.mov") + video.classFile = NKTypeClassFile.video.rawValue + video.contentType = "video/mp4" + let videoMenu = try #require(viewMenu(for: video, webView: false)) + #expect(editActions(in: videoMenu).isEmpty) + + let folder = encryptedFolder() + await NCManageDatabase.shared.addMetadataAsync(folder) + let photo = makeImage(fileName: "secret.jpg", serverUrl: folder.serverUrlFileName) + photo.e2eEncrypted = true + let isImage = photo.isImage + let quickLookEligible = photo.isModifiableWithQuickLook + let encryptedMenu = viewMenu(for: photo, webView: false) + await NCManageDatabase.shared.deleteMetadataAsync(ocId: folder.ocId) + + #expect(isImage) + #expect(!quickLookEligible) + #expect(editActions(in: try #require(encryptedMenu)).isEmpty) + } + } + + private func performOnline(_ body: () async throws -> Void) async throws { + let networking = NCNetworking.shared + let previousReachability = networking.networkReachability + let previousCapabilities = networking.capabilities[account] + networking.networkReachability = NKTypeReachability.reachableEthernetOrWiFi + networking.capabilities[account] = NKCapabilities.Capabilities() + defer { + networking.networkReachability = previousReachability + networking.capabilities[account] = previousCapabilities + } + try await body() + } + + private func viewMenu(for metadata: tableMetadata, webView: Bool) -> UIMenu? { + NCContextMenuViewer( + metadata: metadata, + controller: NCMainTabBarController(), + viewController: nil, + webView: webView, + sender: nil + ).viewMenu() + } + + private func editActions(in menu: UIMenu) -> [UIAction] { + let title = NSLocalizedString("_edit_", comment: "") + return actions(in: menu).filter { $0.title == title } + } + + private func actions(in element: UIMenuElement) -> [UIAction] { + if let action = element as? UIAction { + return [action] + } + guard let menu = element as? UIMenu else { + return [] + } + return menu.children.flatMap(actions(in:)) + } + + private func makeImage(fileName: String, serverUrl: String? = nil) -> tableMetadata { + let metadata = tableMetadata() + metadata.account = account + metadata.ocId = "viewer-edit-\(fileName)" + metadata.fileName = fileName + metadata.fileNameView = fileName + metadata.classFile = NKTypeClassFile.image.rawValue + metadata.contentType = "image/jpeg" + metadata.size = 2048 + metadata.urlBase = "https://example.com" + metadata.userId = "user" + metadata.serverUrl = serverUrl ?? "https://example.com/remote.php/dav/files/user/Photos" + metadata.serverUrlFileName = metadata.serverUrl + "/" + fileName + return metadata + } + + private func encryptedFolder() -> tableMetadata { + let folder = tableMetadata() + folder.account = account + folder.ocId = "viewer-edit-e2ee-folder" + folder.fileName = "Secret" + folder.fileNameView = folder.fileName + folder.directory = true + folder.e2eEncrypted = true + folder.classFile = NKTypeClassFile.directory.rawValue + folder.urlBase = "https://example.com" + folder.userId = "user" + folder.serverUrl = "https://example.com/remote.php/dav/files/user" + folder.serverUrlFileName = folder.serverUrl + "/" + folder.fileName + return folder + } +} diff --git a/Tests/NextcloudUnitTests/NCViewerPhotoEditTests.swift b/Tests/NextcloudUnitTests/NCViewerPhotoEditTests.swift new file mode 100644 index 0000000000..7bf9813c37 --- /dev/null +++ b/Tests/NextcloudUnitTests/NCViewerPhotoEditTests.swift @@ -0,0 +1,257 @@ +// SPDX-FileCopyrightText: Nextcloud GmbH +// SPDX-FileCopyrightText: 2026 Matt Van Horn +// SPDX-License-Identifier: GPL-3.0-or-later + +import Testing +import UIKit +import QuickLook +import NextcloudKit +@testable import Nextcloud + +@Suite("Photo viewer edit session", .serialized) +@MainActor +struct NCViewerPhotoEditTests { + + // MARK: - Quick Look session isolation + + @Test("A second editor does not clear the first editor's changes") + func editorsKeepSeparateChangeFlags() throws { + let firstURL = try #require(NCViewerQuickLook.makeEditingFileURL(fileName: "photo.jpg")) + try Data("original".utf8).write(to: firstURL) + let first = NCViewerQuickLook(with: firstURL, isEditingEnabled: true, metadata: makeImage(ocId: "edit-first")) + + let editedURL = try #require(NCViewerQuickLook.makeEditingFileURL(fileName: "edited.jpg")) + try Data("edited".utf8).write(to: editedURL) + let item = PreviewItem() + item.previewItemURL = firstURL + first.previewController(first, didSaveEditedCopyOf: item, at: editedURL) + #expect(first.hasChangesQuickLook) + + let secondURL = try #require(NCViewerQuickLook.makeEditingFileURL(fileName: "photo.jpg")) + let second = NCViewerQuickLook(with: secondURL, isEditingEnabled: true, metadata: makeImage(ocId: "edit-second")) + + #expect(first.hasChangesQuickLook) + #expect(!second.hasChangesQuickLook) + } + + @Test("Editors of files with the same name get separate temporary files") + func sameNameEditorsDoNotShareTheTemporaryFile() throws { + let first = try #require(NCViewerQuickLook.makeEditingFileURL(fileName: "photo.jpg")) + let second = try #require(NCViewerQuickLook.makeEditingFileURL(fileName: "photo.jpg")) + + #expect(first != second) + #expect(first.lastPathComponent == "photo.jpg") + #expect(second.lastPathComponent == "photo.jpg") + + try Data("first edit".utf8).write(to: first) + try Data("second edit".utf8).write(to: second) + + #expect(try Data(contentsOf: first) == Data("first edit".utf8)) + #expect(try Data(contentsOf: second) == Data("second edit".utf8)) + } + + // MARK: - Shared download + + @Test("A request for a download already running joins it") + func inFlightDownloadIsReused() async throws { + let registry = NCInFlightTaskRegistry() + let counter = Counter() + let gate = Gate() + + async let first = registry.value(for: "photo") { + await counter.increment() + await gate.wait() + return 1 + } + await counter.waitUntil(1) + async let second = registry.value(for: "photo") { + await counter.increment() + return 2 + } + while await registry.joinedCount < 1 { + await Task.yield() + } + await gate.open() + + let results = try await [first, second] + #expect(results == [1, 1]) + #expect(await counter.value == 1) + + let next = try await registry.value(for: "photo") { + await counter.increment() + return 3 + } + #expect(next == 3) + #expect(await counter.value == 2) + } + + @Test("Cancelling the only caller cancels the shared operation") + func cancellingLastCallerCancelsOperation() async { + let registry = NCInFlightTaskRegistry() + let counter = Counter() + + let caller = Task { + try await registry.value(for: "photo") { + await counter.increment() + try await Task.sleep(nanoseconds: 60_000_000_000) + return 1 + } + } + await counter.waitUntil(1) + caller.cancel() + + let result = await caller.result + #expect(throws: CancellationError.self) { try result.get() } + } + + @Test("Cancelling one caller keeps the shared operation for the others") + func cancellingOneCallerKeepsOperation() async throws { + let registry = NCInFlightTaskRegistry() + let counter = Counter() + let gate = Gate() + + let first = Task { + try await registry.value(for: "photo") { + await counter.increment() + await gate.wait() + try Task.checkCancellation() + return 1 + } + } + await counter.waitUntil(1) + let second = Task { + try await registry.value(for: "photo") { + await counter.increment() + return 2 + } + } + while await registry.joinedCount < 1 { + await Task.yield() + } + first.cancel() + try await Task.sleep(nanoseconds: 100_000_000) + await gate.open() + + #expect(try await second.value == 1) + #expect(await counter.value == 1) + } + + // MARK: - Edit tied to the originating viewer + + @Test("Edit opens Quick Look when the viewer still shows the photo") + func editOpensWhenPhotoIsStillShown() async { + let metadata = makeImage(ocId: "edit-shown") + let source = MockViewerPhotoEditSource(shownOcId: metadata.ocId) + + let edit = Task { @MainActor in + await NCViewerPhotoEdit.edit(metadata: metadata, source: source) { source.present($0) } + } + await waitForDownload(source) + source.finishDownload() + + #expect(await edit.value) + #expect(source.presentedOcIds == [metadata.ocId]) + #expect(source.downloadRequests == [metadata.ocId]) + } + + @Test("Edit does not open Quick Look after the viewer moved to another photo") + func editSkipsWhenViewerShowsAnotherPhoto() async { + let metadata = makeImage(ocId: "edit-swiped") + let source = MockViewerPhotoEditSource(shownOcId: metadata.ocId) + + let edit = Task { @MainActor in + await NCViewerPhotoEdit.edit(metadata: metadata, source: source) { source.present($0) } + } + await waitForDownload(source) + source.shownOcId = "edit-other" + source.finishDownload() + + #expect(await edit.value == false) + #expect(source.presentedOcIds.isEmpty) + } + + @Test("Edit does not open Quick Look after the viewer closed") + func editSkipsWhenViewerClosed() async { + let metadata = makeImage(ocId: "edit-closed") + let source = MockViewerPhotoEditSource(shownOcId: metadata.ocId) + + let edit = Task { @MainActor in + await NCViewerPhotoEdit.edit(metadata: metadata, source: source) { source.present($0) } + } + await waitForDownload(source) + source.isOnScreen = false + source.finishDownload() + + #expect(await edit.value == false) + #expect(source.presentedOcIds.isEmpty) + } + + @Test("Edit does not open Quick Look when the download fails") + func editSkipsWhenDownloadFails() async { + let metadata = makeImage(ocId: "edit-failed") + let source = MockViewerPhotoEditSource(shownOcId: metadata.ocId) + + let edit = Task { @MainActor in + await NCViewerPhotoEdit.edit(metadata: metadata, source: source) { source.present($0) } + } + await waitForDownload(source) + source.finishDownload(error: URLError(.notConnectedToInternet)) + + #expect(await edit.value == false) + #expect(source.presentedOcIds.isEmpty) + } + + // MARK: - Helpers + + private func waitForDownload(_ source: MockViewerPhotoEditSource) async { + while !source.hasPendingDownload { + await Task.yield() + } + } + + private func makeImage(ocId: String) -> tableMetadata { + let metadata = tableMetadata() + metadata.account = "viewer-edit-session" + metadata.ocId = ocId + metadata.fileName = "photo.jpg" + metadata.fileNameView = "photo.jpg" + metadata.classFile = NKTypeClassFile.image.rawValue + metadata.contentType = "image/jpeg" + metadata.urlBase = "https://example.com" + metadata.userId = "user" + metadata.serverUrl = "https://example.com/remote.php/dav/files/user/Photos" + return metadata + } +} + +private actor Counter { + private(set) var value = 0 + + func increment() { + value += 1 + } + + func waitUntil(_ target: Int) async { + while value < target { + await Task.yield() + } + } +} + +private actor Gate { + private var isOpen = false + private var waiters: [CheckedContinuation] = [] + + func wait() async { + if isOpen { + return + } + await withCheckedContinuation { waiters.append($0) } + } + + func open() { + isOpen = true + waiters.forEach { $0.resume() } + waiters.removeAll() + } +} diff --git a/iOSClient/Menu/NCContextMenuMain.swift b/iOSClient/Menu/NCContextMenuMain.swift index 0caf019830..26cccd1114 100644 --- a/iOSClient/Menu/NCContextMenuMain.swift +++ b/iOSClient/Menu/NCContextMenuMain.swift @@ -270,7 +270,7 @@ class NCContextMenuMain: NSObject { private func makeModifyWithQuickLookAction(metadata: tableMetadata) -> UIAction { return UIAction( - title: NSLocalizedString("_modify_", comment: ""), + title: NSLocalizedString("_edit_", comment: ""), image: utility.loadImage(named: "pencil.tip.crop.circle", colors: [NCBrandColor.shared.iconImageColor]) ) { _ in Task { diff --git a/iOSClient/Menu/NCContextMenuViewer.swift b/iOSClient/Menu/NCContextMenuViewer.swift index 7ea960e4f1..689defdb40 100644 --- a/iOSClient/Menu/NCContextMenuViewer.swift +++ b/iOSClient/Menu/NCContextMenuViewer.swift @@ -103,7 +103,7 @@ class NCContextMenuViewer: NSObject { if !webView, metadata.isImage, metadata.isModifiableWithQuickLook, - utilityFileSystem.fileSizeIfExists(metadata) { + NCNetworking.shared.isOnline || utilityFileSystem.fileProviderStorageExists(metadata) { editingActions.append(makeModifyPhoto()) } @@ -290,24 +290,79 @@ class NCContextMenuViewer: NSObject { } private func makeModifyPhoto() -> UIAction { + let metadata = self.metadata return UIAction( - title: NSLocalizedString("_modify_", comment: ""), + title: NSLocalizedString("_edit_", comment: ""), image: utility.loadImage(named: "pencil.tip.crop.circle", colors: [NCBrandColor.shared.iconImageColor]) - ) { _ in - Task { - await NCNetworking.shared.transferDispatcher.notifyAllDelegates { delegate in - delegate.transferChange( - networkingStatus: NCGlobal.shared.networkingStatusDownloaded, - account: self.metadata.account, - fileName: self.metadata.fileName, - serverUrl: self.metadata.serverUrl, - selector: NCGlobal.shared.selectorLoadFileQuickLook, - ocId: self.metadata.ocId, - destination: nil, - error: .success - ) + ) { [weak viewController = self.viewController, weak controller = self.controller] _ in + Task { @MainActor in + if let source = viewController as? NCViewerPhotoEditSource { + await NCViewerPhotoEdit.edit(metadata: metadata, source: source) { metadata in + guard let controller else { + return + } + let current = await NCManageDatabase.shared.getMetadataFromOcIdAsync(metadata.ocId) ?? metadata + NCViewerQuickLook.presentEditor(metadata: current, from: controller) + } + } else if self.utilityFileSystem.fileProviderStorageExists(metadata) { + await NCNetworking.shared.transferDispatcher.notifyAllDelegates { delegate in + delegate.transferChange( + networkingStatus: NCGlobal.shared.networkingStatusDownloaded, + account: metadata.account, + fileName: metadata.fileName, + serverUrl: metadata.serverUrl, + selector: NCGlobal.shared.selectorLoadFileQuickLook, + ocId: metadata.ocId, + destination: nil, + error: .success + ) + } + } else if NCNetworking.shared.isOnline, + let metadata = await NCManageDatabase.shared.setMetadataSessionInWaitDownloadAsync( + ocId: metadata.ocId, + session: NCNetworking.shared.sessionDownload, + selector: NCGlobal.shared.selectorLoadFileQuickLook, + sceneIdentifier: controller?.sceneIdentifier + ) { + await NCNetworking.shared.downloadFile(metadata: metadata) } } } } } + +/// A viewer that can provide the original of the photo it shows for editing. +@MainActor +protocol NCViewerPhotoEditSource: AnyObject { + /// Returns once the original is stored on the device. Joins a download + /// already running for the same photo instead of starting another one. + func downloadOriginalForEditing(_ metadata: tableMetadata) async throws + + /// Whether the viewer is still on screen and showing this photo. + func isShowingMedia(ocId: String) -> Bool +} + +/// Ties an Edit request to the viewer it came from. +@MainActor +enum NCViewerPhotoEdit { + /// Downloads the original if needed, then opens the editor only if the + /// originating viewer still shows the same photo. + /// - Returns: `true` when the editor was opened. + @discardableResult + static func edit(metadata: tableMetadata, + source: NCViewerPhotoEditSource, + present: @MainActor (tableMetadata) async -> Void) async -> Bool { + let ocId = metadata.ocId + do { + try await source.downloadOriginalForEditing(metadata) + } catch { + return false + } + guard !Task.isCancelled, + source.isShowingMedia(ocId: ocId) else { + return false + } + await present(metadata) + return true + } +} diff --git a/iOSClient/Networking/NCNetworking+TransferDelegate.swift b/iOSClient/Networking/NCNetworking+TransferDelegate.swift index f3f952468c..e4357123ec 100644 --- a/iOSClient/Networking/NCNetworking+TransferDelegate.swift +++ b/iOSClient/Networking/NCNetworking+TransferDelegate.swift @@ -60,27 +60,7 @@ extension NCNetworking: NCTransferDelegate { case NCGlobal.shared.selectorLoadFileQuickLook: guard metadata.isModifiableWithQuickLook else { return } - let fileNamePath = self.utilityFileSystem.getDirectoryProviderStorageOcId(metadata.ocId, - fileName: metadata.fileNameView, - userId: metadata.userId, - urlBase: metadata.urlBase) - let fileNameTemp = NSTemporaryDirectory() + metadata.fileNameView - let viewerQuickLook = NCViewerQuickLook(with: URL(fileURLWithPath: fileNameTemp), isEditingEnabled: true, metadata: metadata) - if let image = UIImage(contentsOfFile: fileNamePath) { - if let data = image.jpegData(compressionQuality: 1) { - do { - try data.write(to: URL(fileURLWithPath: fileNameTemp)) - } catch { - return - } - } - let navigationController = UINavigationController(rootViewController: viewerQuickLook) - navigationController.modalPresentationStyle = .fullScreen - controller.present(navigationController, animated: true) - } else { - self.utilityFileSystem.copyFile(atPath: fileNamePath, toPath: fileNameTemp) - controller.present(viewerQuickLook, animated: true) - } + NCViewerQuickLook.presentEditor(metadata: metadata, from: controller) case NCGlobal.shared.selectorLoadFileView: guard !isAppInBackground diff --git a/iOSClient/Viewer/NCViewerMedia/NCMediaViewerHostingController.swift b/iOSClient/Viewer/NCViewerMedia/NCMediaViewerHostingController.swift index 5da48c36ef..6d901438e0 100644 --- a/iOSClient/Viewer/NCViewerMedia/NCMediaViewerHostingController.swift +++ b/iOSClient/Viewer/NCViewerMedia/NCMediaViewerHostingController.swift @@ -560,3 +560,15 @@ final class NCMediaViewerTransferDelegate: NSObject, NCTransferDelegate { } } } + +// MARK: - Photo Editing + +extension NCMediaViewerHostingController: NCViewerPhotoEditSource { + func downloadOriginalForEditing(_ metadata: tableMetadata) async throws { + try await model.downloadOriginalImage(for: metadata) + } + + func isShowingMedia(ocId: String) -> Bool { + viewIfLoaded?.window != nil && model.selectedMetadata?.ocId == ocId + } +} diff --git a/iOSClient/Viewer/NCViewerMedia/NCNextcloudMediaViewerLoader.swift b/iOSClient/Viewer/NCViewerMedia/NCNextcloudMediaViewerLoader.swift index 9c45931160..a6b988f8f2 100644 --- a/iOSClient/Viewer/NCViewerMedia/NCNextcloudMediaViewerLoader.swift +++ b/iOSClient/Viewer/NCViewerMedia/NCNextcloudMediaViewerLoader.swift @@ -37,12 +37,90 @@ private actor NCMediaViewerDownloadTaskRegistry { } } +/// Runs at most one operation per key at a time. A caller that asks for a key +/// while its operation is still running awaits that same operation instead of +/// starting a second one. The shared operation is cancelled only when every +/// caller waiting on it has been cancelled, or when it is cancelled by key. +actor NCInFlightTaskRegistry { + private struct Entry { + let id: UUID + let task: Task + var consumers: Int + } + + private var entries: [Key: Entry] = [:] + /// How many callers joined an operation that was already running. + private(set) var joinedCount = 0 + + func value(for key: Key, operation: @escaping @Sendable () async throws -> Value) async throws -> Value { + let id: UUID + let task: Task + + if var running = entries[key] { + joinedCount += 1 + running.consumers += 1 + entries[key] = running + id = running.id + task = running.task + } else { + id = UUID() + task = Task { try await operation() } + entries[key] = Entry(id: id, task: task, consumers: 1) + } + + defer { + if entries[key]?.id == id { + entries[key] = nil + } + } + + return try await withTaskCancellationHandler { + try await task.value + } onCancel: { + Task { + await self.consumerCancelled(for: key, id: id) + } + } + } + + /// Cancels the operation running for the key, whoever is waiting on it. + func cancel(for key: Key) { + entries.removeValue(forKey: key)?.task.cancel() + } + + /// Cancels every running operation. + func cancelAll() { + let running = entries.values + entries.removeAll() + + running.forEach { $0.task.cancel() } + } + + /// A waiting caller was cancelled: drop it, and cancel the shared + /// operation once no other caller is waiting on it. + private func consumerCancelled(for key: Key, id: UUID) { + guard var entry = entries[key], entry.id == id else { + return + } + + entry.consumers -= 1 + + if entry.consumers <= 0 { + entries[key] = nil + entry.task.cancel() + } else { + entries[key] = entry + } + } +} + // MARK: - Media Viewer Loader final class NCMediaViewerLoader: NCMediaViewerLoading, @unchecked Sendable { private let database = NCManageDatabase.shared private let utilityFileSystem = NCUtilityFileSystem() private let fileManager = FileManager.default private let downloadTaskRegistry = NCMediaViewerDownloadTaskRegistry() + private let inFlightDownloads = NCInFlightTaskRegistry() // MARK: - NCMediaViewerLoading func metadata(for ocId: String, account: String) async -> tableMetadata? { @@ -118,6 +196,15 @@ final class NCMediaViewerLoader: NCMediaViewerLoading, @unchecked Sendable { await onDownloadStarted?() + // Info and Edit can ask for the same original while it is downloading. + // Share the running download so its transfer state is not reset and + // a second download to the same path is never started. + return try await inFlightDownloads.value(for: metadata.ocId) { [self] in + try await self.performMediaDownload(for: metadata) + } + } + + private func performMediaDownload(for metadata: tableMetadata) async throws -> URL { guard let downloadMetadata = await database.setMetadataSessionInWaitDownloadAsync( ocId: metadata.ocId, session: NCNetworking.shared.sessionDownload, @@ -224,6 +311,7 @@ final class NCMediaViewerLoader: NCMediaViewerLoading, @unchecked Sendable { } func cancelDownload(for ocId: String) async { + await inFlightDownloads.cancel(for: ocId) await downloadTaskRegistry.cancelTask(for: ocId) } @@ -236,6 +324,7 @@ final class NCMediaViewerLoader: NCMediaViewerLoading, @unchecked Sendable { } func cancelAllDownloads() async { + await inFlightDownloads.cancelAll() await downloadTaskRegistry.cancelAllTasks() } diff --git a/iOSClient/Viewer/NCViewerQuickLook/NCViewerQuickLook.swift b/iOSClient/Viewer/NCViewerQuickLook/NCViewerQuickLook.swift index 43d843e6ed..bf7e7e1667 100644 --- a/iOSClient/Viewer/NCViewerQuickLook/NCViewerQuickLook.swift +++ b/iOSClient/Viewer/NCViewerQuickLook/NCViewerQuickLook.swift @@ -19,11 +19,10 @@ public extension NCViewerQuickLookDelegate { func dismissQuickLook(fileNameSource: String, hasChangesQuickLook: Bool) {} } -/// Flag indicating If the document has any changes -private var hasChangesQuickLook: Bool = false - @objc class NCViewerQuickLook: QLPreviewController { private let url: URL + /// Whether this editor's document has unsaved changes. Each editor owns its flag. + private(set) var hasChangesQuickLook: Bool = false private let fileNameSource: String private var previewItems: [PreviewItem] = [] private let allowsEditing: Bool @@ -61,7 +60,6 @@ private var hasChangesQuickLook: Bool = false self.dataSource = self self.delegate = self self.currentPreviewItemIndex = 0 - hasChangesQuickLook = false } override func viewDidLoad() { @@ -133,7 +131,7 @@ private var hasChangesQuickLook: Bool = false } else { alertController.addAction(UIAlertAction(title: NSLocalizedString("_overwrite_original_", comment: ""), style: .default) { _ in self.saveModifiedFile(override: true) - self.delegateQuickLook?.dismissQuickLook(fileNameSource: self.fileNameSource, hasChangesQuickLook: hasChangesQuickLook) + self.delegateQuickLook?.dismissQuickLook(fileNameSource: self.fileNameSource, hasChangesQuickLook: self.hasChangesQuickLook) }) } @@ -142,7 +140,7 @@ private var hasChangesQuickLook: Bool = false if saveAsCopyAlert { alertController.addAction(UIAlertAction(title: NSLocalizedString("_save_as_copy_", comment: ""), style: .default) { _ in self.saveModifiedFile(override: false) - self.delegateQuickLook?.dismissQuickLook(fileNameSource: self.fileNameSource, hasChangesQuickLook: hasChangesQuickLook) + self.delegateQuickLook?.dismissQuickLook(fileNameSource: self.fileNameSource, hasChangesQuickLook: self.hasChangesQuickLook) }) } alertController.addAction(UIAlertAction(title: NSLocalizedString("_cancel_", comment: ""), style: .cancel) { _ in @@ -156,7 +154,7 @@ private var hasChangesQuickLook: Bool = false @objc private func dismissView(_ sender: Any?) { dismiss(animated: true) { - if hasChangesQuickLook { + if self.hasChangesQuickLook { self.showSaveAlert() } } @@ -295,7 +293,7 @@ extension NCViewerQuickLook: QLPreviewControllerDataSource, QLPreviewControllerD func previewController(_ controller: QLPreviewController, didSaveEditedCopyOf previewItem: QLPreviewItem, at modifiedContentsURL: URL) { guard isEditingEnabled, utilityFileSystem.copyFile(atPath: modifiedContentsURL.path, toPath: url.path) else { return } - hasChangesQuickLook = true + self.hasChangesQuickLook = true } } @@ -305,7 +303,7 @@ extension NCViewerQuickLook: CropViewControllerDelegate { guard isEditingEnabled, let data = cropped.jpegData(compressionQuality: 0.9) else { return } do { try data.write(to: self.url) - hasChangesQuickLook = true + self.hasChangesQuickLook = true reloadData() } catch { print(error) @@ -317,6 +315,53 @@ extension NCViewerQuickLook: CropViewControllerDelegate { } } +extension NCViewerQuickLook { + /// Returns a temporary file URL that belongs to one editing session only. + /// The file keeps its original name inside a directory created for the session, + /// so two editors of files with the same name never share the copy they upload. + static func makeEditingFileURL(fileName: String, temporaryDirectory: URL = FileManager.default.temporaryDirectory) -> URL? { + let directory = temporaryDirectory.appendingPathComponent("QuickLookEdit-" + UUID().uuidString, isDirectory: true) + do { + try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true) + } catch { + return nil + } + return directory.appendingPathComponent(fileName, isDirectory: false) + } + + /// Opens an editing session for a file already stored on the device. + @MainActor + @discardableResult + static func presentEditor(metadata: tableMetadata, from controller: UIViewController) -> NCViewerQuickLook? { + let fileNamePath = NCUtilityFileSystem().getDirectoryProviderStorageOcId(metadata.ocId, + fileName: metadata.fileNameView, + userId: metadata.userId, + urlBase: metadata.urlBase) + guard let fileURL = makeEditingFileURL(fileName: metadata.fileNameView) else { + return nil + } + let viewerQuickLook = NCViewerQuickLook(with: fileURL, isEditingEnabled: true, metadata: metadata) + + if let image = UIImage(contentsOfFile: fileNamePath) { + if let data = image.jpegData(compressionQuality: 1) { + do { + try data.write(to: fileURL) + } catch { + return nil + } + } + let navigationController = UINavigationController(rootViewController: viewerQuickLook) + navigationController.modalPresentationStyle = .fullScreen + controller.present(navigationController, animated: true) + } else { + NCUtilityFileSystem().copyFile(atPath: fileNamePath, toPath: fileURL.path) + controller.present(viewerQuickLook, animated: true) + } + + return viewerQuickLook + } +} + class PreviewItem: NSObject, QLPreviewItem { var previewItemURL: URL? }