Store Product Image Upload statuses in UserDefaults

Networking/Networking/Model/Product/ProductImage.swift

@@ -3,7 +3,7 @@ import Codegen
 
 /// Represents a ProductImage entity.
 ///
-public struct ProductImage: Codable, Equatable, Sendable, GeneratedCopiable, GeneratedFakeable {
+public struct ProductImage: Codable, Sendable, GeneratedCopiable, GeneratedFakeable {
     public let imageID: Int64
     public let dateCreated: Date    // gmt
     public let dateModified: Date?  // gmt
@@ -55,6 +55,20 @@ public struct ProductImage: Codable, Equatable, Sendable, GeneratedCopiable, Gen
     }
 }
 
+extension ProductImage: Equatable {
+    public static func == (lhs: ProductImage, rhs: ProductImage) -> Bool {
+        // Convert timestamps to integers to ignore fractional seconds, ensuring date comparisons
+        // are accurate to the nearest second and avoiding test discrepancies from millisecond differences.
+        let lhsTimestamp = Int(lhs.dateCreated.timeIntervalSince1970)
+        let rhsTimestamp = Int(rhs.dateCreated.timeIntervalSince1970)
+
+        return lhs.imageID == rhs.imageID &&
+               lhsTimestamp == rhsTimestamp &&
+               lhs.src == rhs.src &&
+               lhs.name == rhs.name &&
+               lhs.alt == rhs.alt
+    }
+}
 
 /// Defines all the ProductImage CodingKeys.
 ///

WooCommerce/Classes/ServiceLocator/ProductImageUploader.swift

@@ -7,6 +7,8 @@ import protocol Yosemite.StoresManager
 import enum Yosemite.ProductImageStatus
 import enum Yosemite.ProductImageAssetType
 import enum Yosemite.ProductOrVariationID
+import class Networking.ProductImageStatusStorage
+import protocol Experiments.FeatureFlagService
 
 /// Information about a background product image upload error.
 struct ProductImageUploadErrorInfo {
@@ -87,12 +89,52 @@ protocol ProductImageUploaderProtocol {
 
 /// Supports background image upload and product images update after the user leaves the product form.
 final class ProductImageUploader: ProductImageUploaderProtocol {
+
+    let userDefaultsStatuses: ProductImageStatusStorage?
+
     var errors: AnyPublisher<ProductImageUploadErrorInfo, Never> {
-        errorsSubject.eraseToAnyPublisher()
+        if featureFlagService.isFeatureFlagEnabled(.backgroundProductImageUpload) {
+            let upstream = userDefaultsStatuses?.errorsPublisher
+                ?? Empty<[(siteID: Int64,
+                           productOrVariationID: ProductOrVariationID?,
+                           assetType: ProductImageAssetType?,
+                           error: Error)], Never>().eraseToAnyPublisher()
+            return upstream
+                .flatMap { errorItems in
+                    errorItems.publisher
+                        .compactMap { errorItem in
+                            guard let productOrVariationID = errorItem.productOrVariationID,
+                                  let assetType = errorItem.assetType else { return nil }
+                            return ProductImageUploadErrorInfo(
+                                siteID: errorItem.siteID,
+                                productOrVariationID: productOrVariationID,
+                                error: .failedUploadingImage(asset: assetType, error: errorItem.error)
+                            )
+                        }
+                }
+                .eraseToAnyPublisher()
+        } else {
+            return errorsSubject.eraseToAnyPublisher()
+        }
     }
 
     var activeUploads: AnyPublisher<[ProductImageUploaderKey], Never> {
-        $activeUploadsPublisher.eraseToAnyPublisher()
+        if featureFlagService.isFeatureFlagEnabled(.backgroundProductImageUpload) {
+            return userDefaultsStatuses?.statusesPublisher
+                .map { statuses in
+                    statuses.compactMap { status -> ProductImageUploaderKey? in
+                        if status.isUploading {
+                            return ProductImageUploaderKey(siteID: status.siteID,
+                                                           productOrVariationID: status.productOrVariationID,
+                                                           isLocalID: status.isLocalID)
+                        }
+                        return nil
+                    }
+                }
+                .eraseToAnyPublisher() ?? Empty().eraseToAnyPublisher()
+        } else {
+            return $activeUploadsPublisher.eraseToAnyPublisher()
+        }
     }
 
     typealias Key = ProductImageUploaderKey
@@ -108,12 +150,25 @@ final class ProductImageUploader: ProductImageUploaderProtocol {
     @Published private var activeUploadsPublisher: [ProductImageUploaderKey] = []
 
     private let stores: StoresManager
+    private let featureFlagService: FeatureFlagService
     private let imagesProductIDUpdater: ProductImagesProductIDUpdaterProtocol
 
+    private var cancellables = Set<AnyCancellable>()
+
     init(stores: StoresManager = ServiceLocator.stores,
+         featureFlagService: FeatureFlagService = ServiceLocator.featureFlagService,
          imagesProductIDUpdater: ProductImagesProductIDUpdaterProtocol = ProductImagesProductIDUpdater()) {
         self.stores = stores
+        self.featureFlagService = featureFlagService
         self.imagesProductIDUpdater = imagesProductIDUpdater
+
+        if featureFlagService.isFeatureFlagEnabled(.backgroundProductImageUpload) {
+            self.userDefaultsStatuses = ProductImageStatusStorage()
+            observeStatuses()
+        } else {
+            self.userDefaultsStatuses = nil
+        }
+
         // Observe when the app enters background.
         NotificationCenter.default.addObserver(self,
                                                selector: #selector(appDidEnterBackground),
@@ -170,9 +225,17 @@ final class ProductImageUploader: ProductImageUploaderProtocol {
     }
 
     func sendBackgroundUploadNoticeIfNeeded(key: ProductImageUploaderKey, using noticePresenter: NoticePresenter) {
-        if activeUploadsPublisher.contains(key) {
-            let notice = Notice(title: Localization.backgroundUploadNoticeTitle)
-            noticePresenter.enqueue(notice: notice)
+        if featureFlagService.isFeatureFlagEnabled(.backgroundProductImageUpload) {
+            if let statuses = userDefaultsStatuses?.getAllStatuses(for: key.siteID, productID: key.productOrVariationID),
+               statuses.contains(where: { $0.isUploading }) {
+                let notice = Notice(title: Localization.backgroundUploadNoticeTitle)
+                noticePresenter.enqueue(notice: notice)
+            }
+        } else {
+            if activeUploadsPublisher.contains(key) {
+                let notice = Notice(title: Localization.backgroundUploadNoticeTitle)
+                noticePresenter.enqueue(notice: notice)
+            }
         }
     }
 
@@ -248,13 +311,31 @@ final class ProductImageUploader: ProductImageUploaderProtocol {
     }
 
     private func scheduleUploadInProgressNotificationIfNeeded() {
-        guard !activeUploadsPublisher.isEmpty else { return }
+        if featureFlagService.isFeatureFlagEnabled(.backgroundProductImageUpload) {
+            userDefaultsStatuses?.statusesPublisher
+                .map { statuses in
+                    statuses.filter { $0.isUploading }
+                }
+                .sink { uploadingStatuses in
+                    if !uploadingStatuses.isEmpty {
+                        let notification = LocalNotification(scenario: .productImageBackgroundUpload)
+                        let trigger = UNTimeIntervalNotificationTrigger(timeInterval: 1, repeats: false)
+                        Task {
+                            await LocalNotificationScheduler(pushNotesManager: ServiceLocator.pushNotesManager).schedule(notification: notification,
+                                                                                                                         trigger: trigger, remoteFeatureFlag: nil)
+                        }
+                    }
+                }
+                .store(in: &cancellables)
+        } else {
+            guard !activeUploadsPublisher.isEmpty else { return }
 
-        let notification = LocalNotification(scenario: .productImageBackgroundUpload)
-        let trigger = UNTimeIntervalNotificationTrigger(timeInterval: 1, repeats: false)
-        Task {
-            await LocalNotificationScheduler(pushNotesManager: ServiceLocator.pushNotesManager).schedule(notification: notification,
-                                                                                                         trigger: trigger, remoteFeatureFlag: nil)
+            let notification = LocalNotification(scenario: .productImageBackgroundUpload)
+            let trigger = UNTimeIntervalNotificationTrigger(timeInterval: 1, repeats: false)
+            Task {
+                await LocalNotificationScheduler(pushNotesManager: ServiceLocator.pushNotesManager).schedule(notification: notification,
+                                                                                                             trigger: trigger, remoteFeatureFlag: nil)
+            }
         }
     }
 
@@ -278,16 +359,43 @@ private extension ProductImageUploader {
         }
     }
 
+    private func observeStatuses() {
+        userDefaultsStatuses?.statusesPublisher
+            .sink { [weak self] statuses in
+                guard let self = self else { return }
+
+                // Handle all the errors
+                let failureStatuses = statuses.filter({ $0.isUploadFailure })
+                for failureStatus in failureStatuses {
+                    if let error = failureStatus.error, let asset = failureStatus.asset {
+                        let errorInfo = ProductImageUploadErrorInfo(
+                            siteID: failureStatus.siteID,
+                            productOrVariationID: failureStatus.productOrVariationID,
+                            error: .failedUploadingImage(asset: asset, error: error)
+                        )
+                        self.errorsSubject.send(errorInfo)
+                    }
+                }
+            }
+            .store(in: &cancellables)
+    }
+
     func observeStatusUpdates(key: Key, actionHandler: ProductImageActionHandler) {
         let observationToken = actionHandler.addUpdateObserver(self) { [weak self] productImageStatuses in
             guard let self = self else { return }
 
-            if !activeUploadsPublisher.contains(key), productImageStatuses.hasPendingUpload {
-                activeUploadsPublisher.append(key)
-            } else if activeUploadsPublisher.contains(key), !productImageStatuses.hasPendingUpload {
-                /// When all pending uploads are completed or removed,
-                /// remove the key from active uploads
-                removeProductFromActiveUploads(key: key)
+            if featureFlagService.isFeatureFlagEnabled(.backgroundProductImageUpload) {
+                // Update the states in userDefaultsStatuses
+                self.userDefaultsStatuses?.appendStatuses(productImageStatuses, for: key.siteID, productID: key.productOrVariationID)
+            }
+            else {
+                if !activeUploadsPublisher.contains(key), productImageStatuses.hasPendingUpload {
+                    activeUploadsPublisher.append(key)
+                } else if activeUploadsPublisher.contains(key), !productImageStatuses.hasPendingUpload {
+                    /// When all pending uploads are completed or removed,
+                    /// remove the key from active uploads
+                    removeProductFromActiveUploads(key: key)
+                }
             }
         }
         statusUpdatesSubscriptions.insert(observationToken)
@@ -302,15 +410,31 @@ private extension ProductImageUploader {
                                                             productOrVariationID: key.productOrVariationID,
                                                             error: .failedUploadingImage(asset: asset, error: error))
                 if statusUpdatesExcludedProductKeys.contains(key) == false {
-                    errorsSubject.send(infoError)
+                    if featureFlagService.isFeatureFlagEnabled(.backgroundProductImageUpload) {
+                        let failedStatus = ProductImageStatus.uploadFailure(asset: asset,
+                                                                            error: error,
+                                                                            siteID: key.siteID,
+                                                                            productID: key.productOrVariationID)
+                        self.userDefaultsStatuses?.updateStatus(failedStatus)
+                    } else {
+                        errorsSubject.send(infoError)
+                    }
                 }
             }
         }
         imageUploadSubscriptions.insert(observationToken)
     }
 
     func removeProductFromActiveUploads(key: Key) {
-        activeUploadsPublisher.removeAll(where: { $0 == key })
+        if featureFlagService.isFeatureFlagEnabled(.backgroundProductImageUpload) {
+            userDefaultsStatuses?.removeStatus(where: { status in
+                status.siteID == key.siteID &&
+                status.productOrVariationID == key.productOrVariationID &&
+                status.isUploading
+            })
+        } else {
+            activeUploadsPublisher.removeAll(where: { $0 == key })
+        }
     }
 }
 

WooCommerce/WooCommerceTests/Mocks/MockFeatureFlagService.swift

@@ -23,6 +23,7 @@ final class MockFeatureFlagService: FeatureFlagService {
     var favoriteProducts: Bool
     var isProductGlobalUniqueIdentifierSupported: Bool
     var hideSitesInStorePicker: Bool
+    var backgroundProductImageUpload: Bool
 
     init(isInboxOn: Bool = false,
          isShowInboxCTAEnabled: Bool = false,
@@ -44,7 +45,8 @@ final class MockFeatureFlagService: FeatureFlagService {
          viewEditCustomFieldsInProductsAndOrders: Bool = false,
          favoriteProducts: Bool = false,
          isProductGlobalUniqueIdentifierSupported: Bool = false,
-         hideSitesInStorePicker: Bool = false) {
+         hideSitesInStorePicker: Bool = false,
+         backgroundProductImageUpload: Bool = false) {
         self.isInboxOn = isInboxOn
         self.isShowInboxCTAEnabled = isShowInboxCTAEnabled
         self.isUpdateOrderOptimisticallyOn = isUpdateOrderOptimisticallyOn
@@ -66,6 +68,7 @@ final class MockFeatureFlagService: FeatureFlagService {
         self.favoriteProducts = favoriteProducts
         self.isProductGlobalUniqueIdentifierSupported = isProductGlobalUniqueIdentifierSupported
         self.hideSitesInStorePicker = hideSitesInStorePicker
+        self.backgroundProductImageUpload = backgroundProductImageUpload
     }
 
     func isFeatureFlagEnabled(_ featureFlag: FeatureFlag) -> Bool {
@@ -112,6 +115,8 @@ final class MockFeatureFlagService: FeatureFlagService {
             return isProductGlobalUniqueIdentifierSupported
         case .hideSitesInStorePicker:
             return hideSitesInStorePicker
+        case .backgroundProductImageUpload:
+            return backgroundProductImageUpload
         default:
             return false
         }

WooCommerce/WooCommerceTests/Mocks/MockProductImageUploader.swift

@@ -15,6 +15,7 @@ final class MockProductImageUploader {
     var startEmittingErrorsWasCalled = false
     var stopEmittingErrorsWasCalled = false
     var resetWasCalled = false
+    var sendBackgroundUploadNoticeIfNeededWasCalled = false
 
     private var onProductSaveResult: Result<[ProductImage], Error>?
     private var hasUnsavedChangesOnImages = false
@@ -64,7 +65,12 @@ extension MockProductImageUploader: ProductImageUploaderProtocol {
     }
 
     func sendBackgroundUploadNoticeIfNeeded(key: ProductImageUploaderKey, using noticePresenter: NoticePresenter) {
-        // no-op
+        sendBackgroundUploadNoticeIfNeededWasCalled = true
+
+        // It actually sends a notification if there are active uploads for this key.
+        if activeUploadsKeys.contains(where: { $0 == key }) {
+            noticePresenter.enqueue(notice: Notice(title: "Test Notice"))
+        }
     }
 
     func reset() {