feat: Split upload queue in two behind a new service

kDrive/AppDelegate+BGNSURLSession.swift

@@ -27,7 +27,7 @@ extension AppDelegate {
         Log.bgSessionManager("background session relaunched identifier:\(identifier)")
         if identifier == DownloadQueue.backgroundIdentifier {
             backgroundDownloadSessionManager.backgroundCompletionHandler = completionHandler
-        } else if identifier.hasSuffix(UploadQueue.backgroundBaseIdentifier) {
+        } else if identifier.hasSuffix(UploadServiceBackgroundIdentifier.base) {
             backgroundUploadSessionManager.handleEventsForBackgroundURLSession(identifier: identifier,
                                                                                completionHandler: completionHandler)
         } else {

kDrive/AppDelegate.swift

@@ -118,13 +118,13 @@ final class AppDelegate: UIResponder, UIApplicationDelegate {
         downloadQueue.suspendAllOperations()
         downloadQueue.cancelAllOperations()
 
-        @InjectService var uploadQueue: UploadQueueable
-        uploadQueue.suspendAllOperations()
-        uploadQueue.rescheduleRunningOperations()
+        @InjectService var uploadService: UploadServiceable
+        uploadService.suspendAllOperations()
+        uploadService.rescheduleRunningOperations()
 
         // Await on upload queue to terminate gracefully, if time allows for it.
         let group = TolerantDispatchGroup()
-        uploadQueue.waitForCompletion {
+        uploadService.waitForCompletion {
             // Clean temp files once the upload queue is stoped if needed
             @LazyInjectService var freeSpaceService: FreeSpaceService
             freeSpaceService.auditCache()

kDrive/AppRouter.swift

@@ -659,8 +659,8 @@ public struct AppRouter: AppNavigable {
         photoUploader.scheduleNewPicturesForUpload()
 
         // Resolving an upload queue will restart it if this is the first time
-        @InjectService var uploadQueue: UploadQueue
-        uploadQueue.rebuildUploadQueueFromObjectsInRealm()
+        @InjectService var uploadService: UploadServiceable
+        uploadService.rebuildUploadQueueFromObjectsInRealm()
     }
 
     // MARK: RouterFileNavigable

kDrive/SceneDelegate.swift

@@ -33,6 +33,9 @@ final class SceneDelegate: UIResponder, UIWindowSceneDelegate, AccountManagerDel
     @LazyInjectService var appNavigable: AppNavigable
     @LazyInjectService var appRestorationService: AppRestorationServiceable
     @LazyInjectService var deeplinkParser: DeeplinkParsable
+    @LazyInjectService var uploadNotifications: UploadNotifiable
+    @LazyInjectService var uploadDataSource: UploadServiceDataSourceable
+    @LazyInjectService var uploadObservation: UploadObservable
 
     var shortcutItemToProcess: UIApplicationShortcutItem?
 
@@ -116,8 +119,7 @@ final class SceneDelegate: UIResponder, UIWindowSceneDelegate, AccountManagerDel
 
     func sceneWillEnterForeground(_ scene: UIScene) {
         Log.sceneDelegate("sceneWillEnterForeground \(scene) \(window)")
-        @InjectService var uploadQueue: UploadQueue
-        uploadQueue.pausedNotificationSent = false
+        uploadNotifications.setPausedNotificationSent(false)
 
         let currentState = RootViewControllerState.getCurrentState()
         let session = scene.session
@@ -335,9 +337,8 @@ extension SceneDelegate {
                                             shouldRemoveAfterUpload: false)
                 group.enter()
                 shouldCleanFolder = true
-                @InjectService var uploadQueue: UploadQueue
                 var observationToken: ObservationToken?
-                observationToken = uploadQueue
+                observationToken = uploadObservation
                     .observeFileUploaded(self, fileId: uploadFile.id) { [fileId = file.id] uploadFile, _ in
                         observationToken?.cancel()
                         if let error = uploadFile.error {
@@ -354,7 +355,7 @@ extension SceneDelegate {
                         }
                         group.leave()
                     }
-                uploadQueue.saveToRealm(uploadFile, itemIdentifier: nil)
+                uploadDataSource.saveToRealm(uploadFile, itemIdentifier: nil, addToQueue: true)
             }
         }
 

kDrive/UI/Controller/Files/File List/UploadCardViewModel.swift

@@ -26,7 +26,7 @@ class UploadCardViewModel {
     @Published var uploadCount: Int
 
     @LazyInjectService var accountManager: AccountManageable
-    @LazyInjectService var uploadQueue: UploadQueue
+    @LazyInjectService var uploadDataSource: UploadServiceDataSourceable
 
     var driveFileManager: DriveFileManager {
         didSet {
@@ -46,12 +46,12 @@ class UploadCardViewModel {
 
     private func initObservation() {
         let driveId = driveFileManager.driveId
-        uploadCount = uploadQueue.getUploadingFiles(withParent: uploadDirectory.id,
-                                                    userId: accountManager.currentUserId,
-                                                    driveId: driveId).count
-        realmObservationToken = uploadQueue.getUploadingFiles(withParent: uploadDirectory.id,
-                                                              userId: accountManager.currentUserId,
-                                                              driveId: driveId).observe(on: .main) { [weak self] change in
+        uploadCount = uploadDataSource.getUploadingFiles(withParent: uploadDirectory.id,
+                                                         userId: accountManager.currentUserId,
+                                                         driveId: driveId).count
+        realmObservationToken = uploadDataSource.getUploadingFiles(withParent: uploadDirectory.id,
+                                                                   userId: accountManager.currentUserId,
+                                                                   driveId: driveId).observe(on: .main) { [weak self] change in
             switch change {
             case .initial(let results):
                 self?.uploadCount = results.count

kDrive/UI/Controller/Files/Upload/UploadQueueFoldersViewController.swift

@@ -29,7 +29,7 @@ typealias FileDisplayed = CornerCellContainer<File>
 final class UploadQueueFoldersViewController: UITableViewController {
     @LazyInjectService private var accountManager: AccountManageable
     @LazyInjectService private var driveInfosManager: DriveInfosManager
-    @LazyInjectService private var uploadQueue: UploadQueue
+    @LazyInjectService private var uploadDataSource: UploadServiceDataSourceable
 
     private var frozenUploadingFolders = [FileDisplayed]()
     private var notificationToken: NotificationToken?
@@ -62,7 +62,7 @@ final class UploadQueueFoldersViewController: UITableViewController {
         guard driveFileManager != nil else { return }
         let driveIds = [driveFileManager.driveId] + driveInfosManager.getDrives(for: userId, sharedWithMe: true)
             .map(\.id)
-        let uploadingFiles = uploadQueue.getUploadingFiles(userId: userId, driveIds: driveIds)
+        let uploadingFiles = uploadDataSource.getUploadingFiles(userId: userId, driveIds: driveIds)
             .distinct(by: [\.parentDirectoryId])
 
         notificationToken = uploadingFiles.observe(keyPaths: UploadFile.observedProperties, on: .main) { [weak self] change in

kDrive/UI/Controller/Files/Upload/UploadQueueViewController.swift

@@ -33,7 +33,8 @@ final class UploadQueueViewController: UIViewController {
     @IBOutlet var cancelButton: UIBarButtonItem!
 
     @LazyInjectService var accountManager: AccountManageable
-    @LazyInjectService var uploadQueue: UploadQueue
+    @LazyInjectService var uploadService: UploadServiceable
+    @LazyInjectService var uploadDataSource: UploadServiceDataSourceable
 
     var currentDirectory: File!
     private var frozenUploadingFiles = [UploadFileDisplayed]()
@@ -74,9 +75,9 @@ final class UploadQueueViewController: UIViewController {
 
         notificationToken?.invalidate()
 
-        let observedFiles = AnyRealmCollection(uploadQueue.getUploadingFiles(withParent: currentDirectory.id,
-                                                                             userId: accountManager.currentUserId,
-                                                                             driveId: currentDirectory.driveId))
+        let observedFiles = AnyRealmCollection(uploadDataSource.getUploadingFiles(withParent: currentDirectory.id,
+                                                                                  userId: accountManager.currentUserId,
+                                                                                  driveId: currentDirectory.driveId))
         notificationToken = observedFiles.observe(keyPaths: UploadFile.observedProperties, on: .main) { [weak self] change in
             guard let self else {
                 return
@@ -122,15 +123,15 @@ final class UploadQueueViewController: UIViewController {
     }
 
     @IBAction func cancelButtonPressed(_ sender: UIBarButtonItem) {
-        uploadQueue.cancelAllOperations(withParent: currentDirectory.id,
-                                        userId: accountManager.currentUserId,
-                                        driveId: currentDirectory.driveId)
+        uploadService.cancelAllOperations(withParent: currentDirectory.id,
+                                          userId: accountManager.currentUserId,
+                                          driveId: currentDirectory.driveId)
     }
 
     @IBAction func retryButtonPressed(_ sender: UIBarButtonItem) {
-        uploadQueue.retryAllOperations(withParent: currentDirectory.id,
-                                       userId: accountManager.currentUserId,
-                                       driveId: currentDirectory.driveId)
+        uploadService.retryAllOperations(withParent: currentDirectory.id,
+                                         userId: accountManager.currentUserId,
+                                         driveId: currentDirectory.driveId)
     }
 
     static func instantiate() -> UploadQueueViewController {

kDrive/UI/Controller/MainTabViewController.swift

@@ -43,7 +43,7 @@ class MainTabViewController: UITabBarController, Restorable, PlusButtonObserver
     var photoPickerDelegate = PhotoPickerDelegate()
 
     @LazyInjectService var accountManager: AccountManageable
-    @LazyInjectService var uploadQueue: UploadQueue
+    @LazyInjectService var uploadDataSource: UploadServiceDataSourceable
     @LazyInjectService var fileImportHelper: FileImportHelper
     @LazyInjectService var router: AppNavigable
 
@@ -385,15 +385,17 @@ extension MainTabViewController: UIDocumentPickerDelegate {
                     }
 
                     try FileManager.default.moveItem(at: url, to: targetURL)
-                    uploadQueue.saveToRealm(
-                        UploadFile(
-                            parentDirectoryId: documentPicker.importDriveDirectory.id,
-                            userId: accountManager.currentUserId,
-                            driveId: documentPicker.importDriveDirectory.driveId,
-                            url: targetURL,
-                            name: url.lastPathComponent
-                        )
+                    let newFile = UploadFile(
+                        parentDirectoryId: documentPicker.importDriveDirectory.id,
+                        userId: accountManager.currentUserId,
+                        driveId: documentPicker.importDriveDirectory.driveId,
+                        url: targetURL,
+                        name: url.lastPathComponent
                     )
+
+                    uploadDataSource.saveToRealm(newFile,
+                                                 itemIdentifier: nil,
+                                                 addToQueue: true)
                 } catch {
                     UIConstants.showSnackBarIfNeeded(error: DriveError.unknownError)
                 }

kDrive/UI/Controller/Menu/PhotoSyncSettingsViewController.swift

@@ -503,8 +503,8 @@ extension PhotoSyncSettingsViewController: FooterButtonDelegate {
         DispatchQueue.global(qos: .userInitiated).async {
             // Add new pictures to be uploaded and reload upload queue
             self.photoLibraryUploader.scheduleNewPicturesForUpload()
-            @InjectService var uploadQueue: UploadQueue
-            uploadQueue.rebuildUploadQueueFromObjectsInRealm()
+            @InjectService var uploadService: UploadServiceable
+            uploadService.rebuildUploadQueueFromObjectsInRealm()
         }
     }
 }

kDrive/UI/View/Files/Upload/UploadTableViewCell.swift

@@ -32,7 +32,7 @@ final class UploadTableViewCell: InsetTableViewCell {
     private var thumbnailRequest: UploadFile.ThumbnailRequest?
     private var progressObservation: NotificationToken?
     @LazyInjectService(customTypeIdentifier: kDriveDBID.uploads) private var uploadsDatabase: Transactionable
-    @LazyInjectService var uploadQueue: UploadQueue
+    @LazyInjectService var uploadService: UploadServiceable
 
     override func awakeFromNib() {
         super.awakeFromNib()
@@ -157,15 +157,15 @@ final class UploadTableViewCell: InsetTableViewCell {
                 return
             }
 
-            self.uploadQueue.cancel(uploadFile: file)
+            self.uploadService.cancel(uploadFileId: file.id)
         }
         cardContentView.retryButtonPressedHandler = { [weak self] in
             guard let self, !uploadFile.isInvalidated else {
                 return
             }
 
             cardContentView.retryButton?.isHidden = true
-            uploadQueue.retry(uploadFileId)
+            uploadService.retry(uploadFileId)
         }
     }
 

kDrive/Utils/UploadCountManager.swift

@@ -23,7 +23,7 @@ import kDriveCore
 import RealmSwift
 
 final class UploadCountManager {
-    @LazyInjectService var uploadQueue: UploadQueue
+    @LazyInjectService var uploadDataSource: UploadServiceDataSourceable
     @LazyInjectService var driveInfosManager: DriveInfosManager
 
     private let driveFileManager: DriveFileManager
@@ -65,14 +65,14 @@ final class UploadCountManager {
 
     @discardableResult
     func updateUploadCount() -> Int {
-        uploadCount = uploadQueue.getUploadingFiles(userId: userId, driveIds: driveIds).count
+        uploadCount = uploadDataSource.getUploadingFiles(userId: userId, driveIds: driveIds).count
         return uploadCount
     }
 
     private func observeUploads() {
         guard uploadsObserver == nil else { return }
 
-        uploadsObserver = uploadQueue
+        uploadsObserver = uploadDataSource
             .getUploadingFiles(userId: userId, driveIds: driveIds)
             .observe(on: observeQueue) { [weak self] change in
                 guard let self else {

kDriveCore/DI/FactoryService.swift

@@ -36,7 +36,7 @@ private let loginConfig = InfomaniakLogin.Config(clientId: "9473D73C-C20F-4971-9
 /// Something that setups the service factories
 public enum FactoryService {
     public static func setupDependencyInjection(other: [Factory] = []) {
-        let factoriesWithIdentifier = debugServices + transactionableServices
+        let factoriesWithIdentifier = debugServices + transactionableServices + uploadQueues
         SimpleResolver.register(factoriesWithIdentifier)
         let factories = networkingServices + miscServices + other
         SimpleResolver.register(factories)
@@ -97,23 +97,29 @@ public enum FactoryService {
             Factory(type: DownloadQueueable.self) { _, _ in
                 DownloadQueue()
             },
-            Factory(type: UploadQueue.self) { _, _ in
-                UploadQueue()
+            Factory(type: UploadServiceable.self) { _, _ in
+                UploadService()
             },
-            Factory(type: UploadQueueable.self) { _, resolver in
-                try resolver.resolve(type: UploadQueue.self,
+            Factory(type: UploadServiceDataSourceable.self) { _, resolver in
+                try resolver.resolve(type: UploadServiceable.self,
                                      forCustomTypeIdentifier: nil,
                                      factoryParameters: nil,
                                      resolver: resolver)
             },
-            Factory(type: UploadQueueObservable.self) { _, resolver in
-                try resolver.resolve(type: UploadQueue.self,
+            Factory(type: UploadNotifiable.self) { _, resolver in
+                try resolver.resolve(type: UploadServiceable.self,
                                      forCustomTypeIdentifier: nil,
                                      factoryParameters: nil,
                                      resolver: resolver)
             },
-            Factory(type: UploadNotifiable.self) { _, resolver in
-                try resolver.resolve(type: UploadQueue.self,
+            Factory(type: UploadObservable.self) { _, resolver in
+                try resolver.resolve(type: UploadServiceable.self,
+                                     forCustomTypeIdentifier: nil,
+                                     factoryParameters: nil,
+                                     resolver: resolver)
+            },
+            Factory(type: UploadPublishable.self) { _, resolver in
+                try resolver.resolve(type: UploadServiceable.self,
                                      forCustomTypeIdentifier: nil,
                                      factoryParameters: nil,
                                      resolver: resolver)
@@ -224,6 +230,22 @@ public enum FactoryService {
 
         return services
     }
+
+    static var uploadQueues: [FactoryWithIdentifier] {
+        let globalUploadQueue = Factory(type: UploadQueueable.self) { _, _ in
+            UploadQueue()
+        }
+
+        let photoUploadQueue = Factory(type: UploadQueueable.self) { _, _ in
+            PhotoUploadQueue()
+        }
+
+        let services = [
+            (globalUploadQueue, UploadQueueID.global),
+            (photoUploadQueue, UploadQueueID.photo)
+        ]
+        return services
+    }
 }
 
 public extension SimpleResolver {

kDriveCore/Data/UploadQueue/Servicies/BackgroundUploadSessionManager.swift → kDriveCore/Data/Upload/Servicies/BackgroundUploadSessionManager.swift

@@ -28,19 +28,12 @@ public typealias RequestCompletionHandler = (Data?, URLResponse?, Error?) -> Voi
 public typealias BackgroundCompletionHandler = () -> Void
 
 protocol BackgroundUploadSessionManageable: URLSessionTaskDelegate, URLSessionDelegate, URLSessionDataDelegate {
-    /// Returns the background session
     var backgroundSession: URLSession! { get }
 
-    /// Recreate the URLSessions from existing identifiers in base, and set this instance as delegate.
     func reconnectBackgroundTasks()
 
     func scheduled(task: URLSessionDataTask?, fileUrl: URL?)
 
-    /// Cancel a running request, reschedule it on the background session, and returns a dedicated identifier
-    /// - Parameters:
-    ///   - task: The task to reschedule
-    ///   - fileUrl: The url of the file to upload
-    /// - Returns: a dedicated request identifier, or nil if failed
     func rescheduleForBackground(task: URLSessionDataTask, fileUrl: URL) -> String?
 }
 
@@ -69,8 +62,6 @@ extension URLSession: Identifiable {
 public final class BackgroundUploadSessionManager: NSObject,
     BackgroundUploadSessionManageable,
     BackgroundUploadSessionCompletionable {
-    @LazyInjectService var uploadQueue: UploadQueue
-
     private var backgroundCompletionHandlers: [String: BackgroundCompletionHandler] = [:]
 
     var backgroundSession: URLSession!
@@ -97,7 +88,7 @@ public final class BackgroundUploadSessionManager: NSObject,
         Log.bgSessionManager("init")
         super.init()
 
-        backgroundSession = getSessionOrCreate(for: UploadQueue.backgroundIdentifier)
+        backgroundSession = getSessionOrCreate(for: UploadServiceBackgroundIdentifier.app)
     }
 
     public func getSessionOrCreate(for identifier: String) -> URLSession {