refactor(UploadService): Dedicated queues for events and rebuilding the upload queues

Author: adrien-coye

kDriveCore/Data/Upload/Servicies/UploadService/UploadService+Notifications.swift

@@ -48,7 +48,7 @@ extension UploadService: UploadNotifiable {
 
     public func sendFileUploadStateNotificationIfNeeded(with result: UploadCompletionResult) {
         Log.uploadQueue("sendFileUploadStateNotificationIfNeeded")
-        serialQueue.async { [weak self] in
+        serialEventQueue.async { [weak self] in
             guard let self else { return }
             guard let uploadFile = result.uploadFile,
                   uploadFile.error != .taskRescheduled,

kDriveCore/Data/Upload/Servicies/UploadService/UploadService+Observation.swift

@@ -49,7 +49,7 @@ extension UploadService: UploadObservable {
                                                   fileId: String? = nil,
                                                   using closure: @escaping (UploadFile, File?) -> Void) -> ObservationToken {
         var token: ObservationToken!
-        serialQueue.sync { [weak self] in
+        serialEventQueue.sync { [weak self] in
             guard let self else { return }
             let key = UUID()
             observations.didUploadFile[key] = { [weak self, weak observer] uploadFile, driveFile in
@@ -81,7 +81,7 @@ extension UploadService: UploadObservable {
                                                  parentId: Int,
                                                  using closure: @escaping (Int, Int) -> Void) -> ObservationToken {
         var token: ObservationToken!
-        serialQueue.sync { [weak self] in
+        serialEventQueue.sync { [weak self] in
             guard let self else { return }
             let key = UUID()
             observations.didChangeUploadCountInParent[key] = { [weak self, weak observer] updatedParentId, count in
@@ -111,7 +111,7 @@ extension UploadService: UploadObservable {
                                                  driveId: Int,
                                                  using closure: @escaping (Int, Int) -> Void) -> ObservationToken {
         var token: ObservationToken!
-        serialQueue.sync { [weak self] in
+        serialEventQueue.sync { [weak self] in
             guard let self else { return }
             let key = UUID()
             observations.didChangeUploadCountInDrive[key] = { [weak self, weak observer] updatedDriveId, count in

kDriveCore/Data/Upload/Servicies/UploadService/UploadService+Publish.swift

@@ -43,7 +43,7 @@ extension UploadService: UploadPublishable {
                                    userId: Int,
                                    driveId: Int) {
         Log.uploadQueue("publishUploadCount")
-        serialQueue.async { [weak self] in
+        serialEventQueue.async { [weak self] in
             guard let self else { return }
             publishUploadCountInParent(parentId: parentId, userId: userId, driveId: driveId)
             publishUploadCountInDrive(userId: userId, driveId: driveId)
@@ -54,7 +54,7 @@ extension UploadService: UploadPublishable {
                                            userId: Int,
                                            driveId: Int) {
         Log.uploadQueue("publishUploadCountInParent")
-        serialQueue.async { [weak self] in
+        serialEventQueue.async { [weak self] in
             guard let self else { return }
 
             let uploadCount = getUploadingFiles(withParent: parentId, userId: userId, driveId: driveId).count
@@ -69,7 +69,7 @@ extension UploadService: UploadPublishable {
     public func publishUploadCountInDrive(userId: Int,
                                           driveId: Int) {
         Log.uploadQueue("publishUploadCountInDrive")
-        serialQueue.async { [weak self] in
+        serialEventQueue.async { [weak self] in
             guard let self else { return }
             let uploadCount = getUploadingFiles(userId: userId, driveId: driveId).count
             for closure in observations.didChangeUploadCountInDrive.values {
@@ -84,7 +84,7 @@ extension UploadService: UploadPublishable {
         Log.uploadQueue("publishFileUploaded")
         logFileUploadedWithSuccess(for: result.uploadFile)
         sendFileUploadStateNotificationIfNeeded(with: result)
-        serialQueue.async { [weak self] in
+        serialEventQueue.async { [weak self] in
             guard let self else { return }
             for closure in observations.didUploadFile.values {
                 guard let uploadFile = result.uploadFile, !uploadFile.isInvalidated else {

kDriveCore/Data/Upload/Servicies/UploadService/UploadService.swift

@@ -32,13 +32,24 @@ public final class UploadService {
     @LazyInjectService var notificationHelper: NotificationsHelpable
     @LazyInjectService var appContextService: AppContextServiceable
 
-    let serialQueue: DispatchQueue = {
+    private let serialRebuildUploadsQueue: DispatchQueue = {
         @LazyInjectService var appContextService: AppContextServiceable
         let autoreleaseFrequency: DispatchQueue.AutoreleaseFrequency = appContextService.isExtension ? .workItem : .inherit
 
         return DispatchQueue(
-            label: "com.infomaniak.drive.upload-service",
-            qos: .userInitiated,
+            label: "com.infomaniak.drive.upload-service.rebuild-uploads",
+            qos: .default,
+            autoreleaseFrequency: autoreleaseFrequency
+        )
+    }()
+
+    let serialEventQueue: DispatchQueue = {
+        @LazyInjectService var appContextService: AppContextServiceable
+        let autoreleaseFrequency: DispatchQueue.AutoreleaseFrequency = appContextService.isExtension ? .workItem : .inherit
+
+        return DispatchQueue(
+            label: "com.infomaniak.drive.upload-service.event",
+            qos: .default,
             autoreleaseFrequency: autoreleaseFrequency
         )
     }()
@@ -87,7 +98,7 @@ extension UploadService: UploadServiceable {
 
     public func rebuildUploadQueueFromObjectsInRealm() {
         Log.uploadQueue("rebuildUploadQueueFromObjectsInRealm")
-        serialQueue.sync {
+        serialRebuildUploadsQueue.sync {
             // Clean cache if necessary before we try to restart the uploads.
             @InjectService var freeSpaceService: FreeSpaceService
             freeSpaceService.cleanCacheIfAlmostFull()