Upload parallelism and retries

Tree Tracker/Screens/Upload/UploadViewModel.swift

@@ -22,14 +22,17 @@ final class UploadViewModel: CollectionViewModel {
     var rightNavigationButtonsPublisher: Published<[NavigationBarButtonModel]>.Publisher { $rightNavigationButtons }
     var dataPublisher: Published<[ListSection<CollectionListItem>]>.Publisher { $data }
 
+    let maxConcurrentUploads = 3
+    let maxUploadAttempts = 3
     private var api: Api
     private var database: Database
     private var screenLockManager: ScreenLockManaging
     private var logger: Logging
     private var sites: [Site] = []
     private var species: [Species] = []
     private var supervisors: [Supervisor] = []
-    private var currentUpload: Cancellable?
+    private var currentUploads: [String: Cancellable?] = [:]
+    private var failedUploadCount: [String: Int] = [:]
     private weak var navigation: UploadNavigating?
 
     init(api: Api = CurrentEnvironment.api, database: Database = CurrentEnvironment.database, screenLockManager: ScreenLockManaging = CurrentEnvironment.screenLockManager, logger: Logging = CurrentEnvironment.logger, navigation: UploadNavigating) {
@@ -107,6 +110,8 @@ final class UploadViewModel: CollectionViewModel {
         presentUploadButton(isUploading: true)
         presentNavigationButtons(isUploading: true)
         screenLockManager.disableLocking()
+        self.currentUploads = [:]
+        self.failedUploadCount = [:]
         uploadLocalTreesRecursively()
     }
 
@@ -125,44 +130,58 @@ final class UploadViewModel: CollectionViewModel {
 
     private func cancelUploading() {
         logger.log(.upload, "Uploading cancelled.")
-        currentUpload?.cancel()
+        for ((_, upload)) in currentUploads {
+            upload?.cancel();
+        }
         stopUploading()
     }
 
     private func uploadLocalTreesRecursively() {
         logger.log(.upload, "Uploading images...")
         database.fetchLocalTrees { [weak self] trees in
             self?.logger.log(.upload, "Trees to upload: \(trees.count)")
-
-            guard let tree = trees.sorted(by: \.createDate, order: .descending).first else {
-                self?.logger.log(.upload, "No more items to upload - bailing.")
-                self?.stopUploading()
-                return
-            }
-
-            self?.logger.log(.upload, "Now uploading tree: \(tree)")
-            self?.currentUpload = self?.api.upload(
-                tree: tree,
-                progress: { progress in
-                    self?.logger.log(.upload, "Progress: \(progress)")
-                    self?.update(uploadProgress: progress, for: tree)
-                },
-                completion: { result in
-                    switch result {
-                    case let .success(airtableTree):
-                        self?.logger.log(.upload, "Successfully uploaded tree.")
-                        self?.database.save([airtableTree], sentFromThisDevice: true)
-                        self?.database.remove(tree: tree) {
-                            self?.presentTreesFromDatabase()
+            let sortedTrees = trees.sorted(by: \.createDate, order: .descending)
+            while (self != nil && self!.currentUploads.count < self!.maxConcurrentUploads && self!.currentUploads.count < trees.count) {
+
+                guard let tree = sortedTrees.first(where: { treeEntry in self?.currentUploads[treeEntry.phImageId] == nil && (self?.failedUploadCount[treeEntry.phImageId] ?? 0) < self!.maxUploadAttempts}) else {
+                    self?.logger.log(.upload, "No more items to upload - bailing.")
+                    self?.stopUploading()
+                    return
+                }
+
+                self?.logger.log(.upload, "Now uploading tree: \(tree)")
+                self?.currentUploads[tree.phImageId] = (self?.api.upload(
+                    tree: tree,
+                    progress: { progress in
+                        self?.logger.log(.upload, "Progress: \(progress)")
+                        self?.update(uploadProgress: progress, for: tree)
+                    },
+                    completion: { result in
+                        switch result {
+                        case let .success(airtableTree):
+                            self?.logger.log(.upload, "Successfully uploaded tree.")
+                            self?.database.save([airtableTree], sentFromThisDevice: true)
+                            self?.database.remove(tree: tree) {
+                                self?.currentUploads[tree.phImageId] = nil;
+                                if (self != nil && self!.currentUploads.count == 0) {
+                                    self?.presentUploadButton(isUploading: false)
+                                }
+                                self?.presentTreesFromDatabase()
+                                self?.uploadLocalTreesRecursively()
+                            }
+                        case let .failure(error):
+                            self?.failedUploadCount[tree.phImageId] = (self?.failedUploadCount[tree.phImageId] ?? 0) + 1
+                            self?.currentUploads[tree.phImageId] = nil;
+                            self?.update(uploadProgress: 0.0, for: tree)
+                            self?.logger.log(.upload, "Error when uploading a local tree: \(error)")
                             self?.uploadLocalTreesRecursively()
+                            if (self != nil && self!.currentUploads.count == 0) {
+                                self?.presentUploadButton(isUploading: false)
+                            }
                         }
-                    case let .failure(error):
-                        self?.update(uploadProgress: 0.0, for: tree)
-                        self?.presentUploadButton(isUploading: false)
-                        self?.logger.log(.upload, "Error when uploading a local tree: \(error)")
                     }
-                }
-            )
+                ))
+            }
         }
     }