Multi file uploads (#4358)

* Allow MediaPickerScreen users to select the media selection mode (single or multiple) * Fix cancellation * Add support for multiple media URLs on the MediaUploadPreviewScreen. * Support processing more URLs on the `MediaUploadingPreprocessor` and sending more on the `MediaUploadPreviewScreen` * Add feature flag for `multipleAttachmentUploadEnabled` * Add a label showing the current preview item index in the MediaUploadPreviewScreen * Add support for dragging and dropping or pasting multiple items at the same time. * Support sharing more than one file through the share extension. * Limit the number of items that can be shared in one go to 5. * Fix unit tests * Fix incorrect fatal error when dealing with single selection media pickers. * Document the `multipleAttachmentUploadEnabled` usage in the context of the MediaPicker. * Use a task group for processing selected media in the photo library picker. * Use a task group for processing multiple selected media in the MediaUploadingPreprocessor * Switch the maximum number of items that can be shared to 10. * Allow multiple items to be pasted at the same time.
2026-11-03 06:55:59 +00:00 · 2025-07-30 15:44:05 +03:00
parent 01033cf53e
commit df335bd2b1
39 changed files with 466 additions and 266 deletions
@@ -23,7 +23,8 @@ struct CameraPicker: UIViewControllerRepresentable {
    private let userIndicatorController: UserIndicatorControllerProtocol
    private let callback: (CameraPickerAction) -> Void
    
-    init(userIndicatorController: UserIndicatorControllerProtocol, callback: @escaping (CameraPickerAction) -> Void) {
+    init(userIndicatorController: UserIndicatorControllerProtocol,
+         callback: @escaping (CameraPickerAction) -> Void) {
        self.userIndicatorController = userIndicatorController
        self.callback = callback
    }
@@ -8,29 +8,35 @@
 import SwiftUI

 enum DocumentPickerAction {
-    case selectFile(URL)
+    case selectedMediaAtURLs([URL])
    case cancel
    case error(Error)
 }

-enum DocumentPickerError: Error {
-    case unknown
-}
-
 struct DocumentPicker: UIViewControllerRepresentable {
+    private let selectionType: MediaPickerScreenSelectionType
    private let userIndicatorController: UserIndicatorControllerProtocol
    private let callback: (DocumentPickerAction) -> Void
    
-    init(userIndicatorController: UserIndicatorControllerProtocol, callback: @escaping (DocumentPickerAction) -> Void) {
+    init(selectionType: MediaPickerScreenSelectionType,
+         userIndicatorController: UserIndicatorControllerProtocol,
+         callback: @escaping (DocumentPickerAction) -> Void) {
+        self.selectionType = selectionType
        self.userIndicatorController = userIndicatorController
        self.callback = callback
    }

    func makeUIViewController(context: Context) -> UIDocumentPickerViewController {
        let documentPicker = UIDocumentPickerViewController(forOpeningContentTypes: [.data])
-        documentPicker.allowsMultipleSelection = false
        documentPicker.delegate = context.coordinator
        
+        documentPicker.allowsMultipleSelection = switch selectionType {
+        case .single:
+            false
+        case .multiple:
+            true
+        }
+        
        return documentPicker
    }
    
@@ -56,11 +62,6 @@ struct DocumentPicker: UIViewControllerRepresentable {
        private static let loadingIndicatorIdentifier = "\(DocumentPicker.self)-Loading"
        
        func documentPicker(_ picker: UIDocumentPickerViewController, didPickDocumentsAt urls: [URL]) {
-            guard let url = urls.first else {
-                documentPicker.callback(.error(DocumentPickerError.unknown))
-                return
-            }
-            
            picker.delegate = nil
            
            documentPicker.userIndicatorController.submitIndicator(UserIndicator(id: Self.loadingIndicatorIdentifier, type: .modal, title: L10n.commonLoading))
@@ -68,14 +69,19 @@ struct DocumentPicker: UIViewControllerRepresentable {
                documentPicker.userIndicatorController.retractIndicatorWithId(Self.loadingIndicatorIdentifier)
            }
            
-            do {
-                _ = url.startAccessingSecurityScopedResource()
-                let newURL = try FileManager.default.copyFileToTemporaryDirectory(file: url)
-                url.stopAccessingSecurityScopedResource()
-                documentPicker.callback(.selectFile(newURL))
-            } catch {
-                documentPicker.callback(.error(error))
+            var selectedURLs = [URL]()
+            for url in urls.prefix(10) {
+                do {
+                    _ = url.startAccessingSecurityScopedResource()
+                    let newURL = try FileManager.default.copyFileToTemporaryDirectory(file: url)
+                    url.stopAccessingSecurityScopedResource()
+                    selectedURLs.append(newURL)
+                } catch {
+                    documentPicker.callback(.error(error))
+                }
            }
+            
+            documentPicker.callback(.selectedMediaAtURLs(selectedURLs))
        }
    }
 }
@@ -7,31 +7,45 @@

 import SwiftUI

+struct MediaPickerScreenMode: Hashable {
+    let source: MediaPickerScreenSource
+    let selectionType: MediaPickerScreenSelectionType
+}
+
 enum MediaPickerScreenSource {
    case camera
    case photoLibrary
    case documents
 }

+enum MediaPickerScreenSelectionType {
+    case single
+    case multiple
+}
+
 enum MediaPickerScreenCoordinatorAction {
-    case selectMediaAtURL(URL)
+    case selectedMediaAtURLs([URL])
    case cancel
 }

 class MediaPickerScreenCoordinator: CoordinatorProtocol {
    private let orientationManager: OrientationManagerProtocol
    private let userIndicatorController: UserIndicatorControllerProtocol
-    private let source: MediaPickerScreenSource
+    private let mode: MediaPickerScreenMode
    private let callback: (MediaPickerScreenCoordinatorAction) -> Void
    
-    init(userIndicatorController: UserIndicatorControllerProtocol,
-         source: MediaPickerScreenSource,
+    init(mode: MediaPickerScreenMode,
+         appSettings: AppSettings,
+         userIndicatorController: UserIndicatorControllerProtocol,
         orientationManager: OrientationManagerProtocol,
         callback: @escaping (MediaPickerScreenCoordinatorAction) -> Void) {
        self.userIndicatorController = userIndicatorController
-        self.source = source
        self.orientationManager = orientationManager
        self.callback = callback
+        
+        // The users of the media picker chose their ideal selection type leaving
+        // the feature flag to only be checked and enforced on this level.
+        self.mode = appSettings.multipleAttachmentUploadEnabled ? mode : .init(source: mode.source, selectionType: .single)
    }
    
    func toPresentable() -> AnyView {
@@ -39,51 +53,47 @@ class MediaPickerScreenCoordinator: CoordinatorProtocol {
    }
    
    func start() {
-        guard source == .camera else {
-            return
+        if mode.source == .camera {
+            orientationManager.setOrientation(.portrait)
+            orientationManager.lockOrientation(.portrait)
        }
-        
-        orientationManager.setOrientation(.portrait)
-        orientationManager.lockOrientation(.portrait)
    }
    
    func stop() {
-        guard source == .camera else {
-            return
+        if mode.source == .camera {
+            orientationManager.lockOrientation(.all)
        }
-        
-        orientationManager.lockOrientation(.all)
    }
    
    @ViewBuilder
    private var mediaPicker: some View {
-        switch source {
+        switch mode.source {
        case .camera:
            cameraPicker
        case .photoLibrary:
-            PhotoLibraryPicker(userIndicatorController: userIndicatorController) { [weak self] action in
+            PhotoLibraryPicker(selectionType: mode.selectionType, userIndicatorController: userIndicatorController) { [weak self] action in
                switch action {
                case .cancel:
                    self?.callback(.cancel)
                case .error(let error):
                    MXLog.error("Failed selecting media from the photo library with error: \(error)")
                    self?.showError()
-                case .selectFile(let url):
-                    self?.callback(.selectMediaAtURL(url))
+                case .selectedMediaAtURLs(let urls):
+                    self?.callback(.selectedMediaAtURLs(urls))
                }
            }
        case .documents:
            // The document picker automatically dismisses everything on selection
            // Strongly retain self in the callback to forward actions correctly
-            DocumentPicker(userIndicatorController: userIndicatorController) { action in
+            DocumentPicker(selectionType: mode.selectionType, userIndicatorController: userIndicatorController) { action in
                switch action {
                case .cancel:
                    self.callback(.cancel)
                case .error(let error):
                    MXLog.error("Failed selecting media from the document picker with error: \(error)")
                    self.showError()
-                case .selectFile(let url):
-                    self.callback(.selectMediaAtURL(url))
+                case .selectedMediaAtURLs(let urls):
+                    self.callback(.selectedMediaAtURLs(urls))
                }
            }
        }
@@ -98,7 +108,7 @@ class MediaPickerScreenCoordinator: CoordinatorProtocol {
                MXLog.error("Failed selecting media from the camera picker with error: \(error)")
                self?.showError()
            case .selectFile(let url):
-                self?.callback(.selectMediaAtURL(url))
+                self?.callback(.selectedMediaAtURLs([url]))
            }
        }
        .background(.black, ignoresSafeAreaEdges: .bottom)
@@ -9,7 +9,7 @@ import PhotosUI
 import SwiftUI

 enum PhotoLibraryPickerAction {
-    case selectFile(URL)
+    case selectedMediaAtURLs([URL])
    case cancel
    case error(PhotoLibraryPickerError)
 }
@@ -20,17 +20,27 @@ enum PhotoLibraryPickerError: Error {
 }

 struct PhotoLibraryPicker: UIViewControllerRepresentable {
+    private let selectionType: MediaPickerScreenSelectionType
    private let userIndicatorController: UserIndicatorControllerProtocol
    private let callback: (PhotoLibraryPickerAction) -> Void
    
-    init(userIndicatorController: UserIndicatorControllerProtocol, callback: @escaping (PhotoLibraryPickerAction) -> Void) {
+    init(selectionType: MediaPickerScreenSelectionType,
+         userIndicatorController: UserIndicatorControllerProtocol,
+         callback: @escaping (PhotoLibraryPickerAction) -> Void) {
+        self.selectionType = selectionType
        self.userIndicatorController = userIndicatorController
        self.callback = callback
    }

    func makeUIViewController(context: Context) -> PHPickerViewController {
        var configuration = PHPickerConfiguration(photoLibrary: .shared())
-        configuration.selectionLimit = 1
+        
+        configuration.selectionLimit = switch selectionType {
+        case .single:
+            1
+        case .multiple:
+            10
+        }
        
        let pickerViewController = PHPickerViewController(configuration: configuration)
        pickerViewController.delegate = context.coordinator
@@ -56,38 +66,73 @@ struct PhotoLibraryPicker: UIViewControllerRepresentable {
        private static let loadingIndicatorIdentifier = "\(PhotoLibraryPicker.self)-Loading"
        
        func picker(_ picker: PHPickerViewController, didFinishPicking results: [PHPickerResult]) {
-            guard let provider = results.first?.itemProvider,
-                  let contentType = provider.preferredContentType else {
+            guard !results.isEmpty else {
                photoLibraryPicker.callback(.cancel)
                return
            }
            
            picker.delegate = nil
            
-            photoLibraryPicker.userIndicatorController.submitIndicator(UserIndicator(id: Self.loadingIndicatorIdentifier, type: .modal, title: L10n.commonLoading))
+            photoLibraryPicker.userIndicatorController.submitIndicator(UserIndicator(id: Self.loadingIndicatorIdentifier,
+                                                                                     type: .modal,
+                                                                                     title: L10n.commonLoading))
            defer {
                photoLibraryPicker.userIndicatorController.retractIndicatorWithId(Self.loadingIndicatorIdentifier)
            }
            
-            provider.loadFileRepresentation(forTypeIdentifier: contentType.type.identifier) { [weak self] url, error in
-                guard let url else {
-                    Task { @MainActor in
-                        self?.photoLibraryPicker.callback(.error(.failedLoadingFileRepresentation(error)))
+            Task {
+                let selectedURLs = await withTaskGroup { taskGroup in
+                    for result in results {
+                        taskGroup.addTask { await self.processResult(result) }
                    }
-                    return
+                    
+                    var selectedURLs = [URL]()
+                    for await url in taskGroup {
+                        if let url {
+                            selectedURLs.append(url)
+                        }
+                    }
+                    
+                    return selectedURLs
                }
                
-                do {
-                    _ = url.startAccessingSecurityScopedResource()
-                    let newURL = try FileManager.default.copyFileToTemporaryDirectory(file: url)
-                    url.stopAccessingSecurityScopedResource()
-                    
-                    Task { @MainActor in
-                        self?.photoLibraryPicker.callback(.selectFile(newURL))
+                photoLibraryPicker.callback(.selectedMediaAtURLs(selectedURLs))
+            }
+        }
+        
+        // MARK: - Private
+        
+        func processResult(_ result: PHPickerResult) async -> URL? {
+            let provider = result.itemProvider
+            
+            guard let contentType = provider.preferredContentType else {
+                return nil
+            }
+            
+            return await withCheckedContinuation { continuation in
+                provider.loadFileRepresentation(forTypeIdentifier: contentType.type.identifier) { [weak self] url, error in
+                    guard let url else {
+                        Task { @MainActor in
+                            self?.photoLibraryPicker.callback(.error(.failedLoadingFileRepresentation(error)))
+                        }
+                        
+                        continuation.resume(returning: nil)
+                        return
                    }
-                } catch {
-                    Task { @MainActor in
-                        self?.photoLibraryPicker.callback(.error(.failedCopyingFile))
+                    
+                    do {
+                        _ = url.startAccessingSecurityScopedResource()
+                        let newURL = try FileManager.default.copyFileToTemporaryDirectory(file: url)
+                        url.stopAccessingSecurityScopedResource()
+                        
+                        Task { @MainActor in
+                            continuation.resume(returning: newURL)
+                        }
+                    } catch {
+                        Task { @MainActor in
+                            self?.photoLibraryPicker.callback(.error(.failedCopyingFile))
+                            continuation.resume(returning: nil)
+                        }
                    }
                }
            }