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,65 @@ protocol ProductImageUploaderProtocol {
 
 /// Supports background image upload and product images update after the user leaves the product form.
 final class ProductImageUploader: ProductImageUploaderProtocol {
+
+    let imageStatusStorage: ProductImageStatusStorage
+
     var errors: AnyPublisher<ProductImageUploadErrorInfo, Never> {
-        errorsSubject.eraseToAnyPublisher()
+        if featureFlagService.isFeatureFlagEnabled(.backgroundProductImageUpload) {
+            return imageStatusStorage.errorsPublisher
+                .flatMap { errorItems in
+                    errorItems.publisher
+                        .compactMap { errorItem in
+                            guard let productOrVariationID = errorItem.productOrVariationID,
+                                  let assetType = errorItem.assetType else { return nil }
+
+                            // Create key to check against excluded keys
+                            let key = Key(siteID: errorItem.siteID,
+                                          productOrVariationID: productOrVariationID,
+                                          isLocalID: productOrVariationID.id == 0)
+
+                            // Skip error if it's for a product being edited
+                            guard !self.statusUpdatesExcludedProductKeys.contains(key) else {
+                                return nil
+                            }
+
+                            return ProductImageUploadErrorInfo(
+                                siteID: errorItem.siteID,
+                                productOrVariationID: productOrVariationID,
+                                error: .failedUploadingImage(asset: assetType, error: errorItem.error)
+                            )
+                        }
+                }
+                .eraseToAnyPublisher()
+        } else {
+            return errorsSubject
+                .filter { info in
+                    let key = Key(siteID: info.siteID,
+                                  productOrVariationID: info.productOrVariationID,
+                                  isLocalID: info.productOrVariationID.id == 0)
+                    return !self.statusUpdatesExcludedProductKeys.contains(key)
+                }
+                .eraseToAnyPublisher()
+        }
     }
 
     var activeUploads: AnyPublisher<[ProductImageUploaderKey], Never> {
-        $activeUploadsPublisher.eraseToAnyPublisher()
+        if featureFlagService.isFeatureFlagEnabled(.backgroundProductImageUpload) {
+            return imageStatusStorage.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()
+        } else {
+            return $activeUploadsPublisher.eraseToAnyPublisher()
+        }
     }
 
     typealias Key = ProductImageUploaderKey
@@ -108,12 +163,20 @@ 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,
-         imagesProductIDUpdater: ProductImagesProductIDUpdaterProtocol = ProductImagesProductIDUpdater()) {
+         featureFlagService: FeatureFlagService = ServiceLocator.featureFlagService,
+         imagesProductIDUpdater: ProductImagesProductIDUpdaterProtocol = ProductImagesProductIDUpdater(),
+         imageStatusStorage: ProductImageStatusStorage = ProductImageStatusStorage()) {
         self.stores = stores
+        self.featureFlagService = featureFlagService
         self.imagesProductIDUpdater = imagesProductIDUpdater
+        self.imageStatusStorage = imageStatusStorage
+
         // Observe when the app enters background.
         NotificationCenter.default.addObserver(self,
                                                selector: #selector(appDidEnterBackground),
@@ -170,9 +233,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) {
+            let statuses = imageStatusStorage.getAllStatuses(for: key.siteID, productID: key.productOrVariationID)
+            if 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)
+            }
         }
     }
 
@@ -243,18 +314,34 @@ final class ProductImageUploader: ProductImageUploaderProtocol {
         imageUploadSubscriptions = []
         activeUploadsPublisher = []
 
+        imageStatusStorage.clearAllStatuses()
+
         actionHandlersByProduct = [:]
         imagesSaverByProduct = [:]
     }
 
     private func scheduleUploadInProgressNotificationIfNeeded() {
-        guard !activeUploadsPublisher.isEmpty else { return }
+        if featureFlagService.isFeatureFlagEnabled(.backgroundProductImageUpload) {
+            let statuses = imageStatusStorage.getAllStatuses()
+            let hasUploadingStatuses = statuses.contains { $0.isUploading }
+
+            if hasUploadingStatuses {
+                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)
+                }
+            }
+        } 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)
+            }
         }
     }
 
@@ -282,12 +369,18 @@ private extension ProductImageUploader {
         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.imageStatusStorage.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 +395,29 @@ private extension ProductImageUploader {
                                                             productOrVariationID: key.productOrVariationID,
                                                             error: .failedUploadingImage(asset: asset, error: error))
                 if statusUpdatesExcludedProductKeys.contains(key) == false {
-                    errorsSubject.send(infoError)
+                    if !self.featureFlagService.isFeatureFlagEnabled(.backgroundProductImageUpload) {
+                        // Only send the error directly if `backgroundProductImageUpload` feature flag is disabled
+                        errorsSubject.send(infoError)
+                    }
+                    // To keep in mind
+                    // Do not update storage here as the action handler will update its status
+                    // which will trigger `observeStatusUpdates` to do the storage update
                 }
             }
         }
         imageUploadSubscriptions.insert(observationToken)
     }
 
     func removeProductFromActiveUploads(key: Key) {
-        activeUploadsPublisher.removeAll(where: { $0 == key })
+        if featureFlagService.isFeatureFlagEnabled(.backgroundProductImageUpload) {
+            imageStatusStorage.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

@@ -64,7 +64,6 @@ extension MockProductImageUploader: ProductImageUploaderProtocol {
     }
 
     func sendBackgroundUploadNoticeIfNeeded(key: ProductImageUploaderKey, using noticePresenter: NoticePresenter) {
-        // no-op
     }
 
     func reset() {