Structure POSServiceLocatorAdaptor to always use ServiceLocator when services are accessed

staskus · staskus · commit 04fd03604c2b · 2025-07-31T11:25:12.000+02:00
diff --git a/Modules/Sources/PointOfSale/DependencyProviders/POSDependencyProviding.swift b/Modules/Sources/PointOfSale/DependencyProviders/POSDependencyProviding.swift
@@ -8,26 +8,31 @@ import struct Yosemite.Site
 /// This abstracts away direct ServiceLocator access
 public protocol POSDependencyProviding {
     var analytics: POSAnalyticsProviding { get }
-    var currency: CurrencySettings { get }
+    var currency: POSCurrencySettingsProviding { get }
     var featureFlags: POSFeatureFlagProviding { get }
     var session: POSSessionManagerProviding { get }
-    var connectivity: ConnectivityObserver { get }
+    var connectivity: POSConnectivityProviding { get }
 }
 
-/// Analytics service abstraction
 public protocol POSAnalyticsProviding {
     func track(event: WooAnalyticsEvent)
     func track(_ stat: WooAnalyticsStat, parameters: [String: WooAnalyticsEventPropertyType], error: Error)
     func track(_ stat: WooAnalyticsStat, parameters: [String: WooAnalyticsEventPropertyType])
     func track(_ stat: WooAnalyticsStat)
 }
 
-/// Session manager abstraction
 public protocol POSSessionManagerProviding {
     var defaultSite: Site? { get }
 }
 
-/// Feature flag service abstraction
 public protocol POSFeatureFlagProviding {
     func isFeatureFlagEnabled(_ flag: FeatureFlag) -> Bool
 }
+
+public protocol POSCurrencySettingsProviding {
+    var currencySettings: CurrencySettings { get }
+}
+
+public protocol POSConnectivityProviding {
+    var connectivityObserver: ConnectivityObserver { get }
+}
diff --git a/WooCommerce/Classes/POS/Adaptors/POSServiceLocatorAdaptor.swift b/WooCommerce/Classes/POS/Adaptors/POSServiceLocatorAdaptor.swift
@@ -9,91 +9,68 @@ import protocol Storage.StorageManagerType
 import protocol Yosemite.Action
 
 /// Adaptor that bridges main app ServiceLocator to POS dependency abstraction to support POS modularization
+/// ServiceLocator is used directly in getters to always get the latest version of services at the moment they are used
+///
 final class POSServiceLocatorAdaptor: POSDependencyProviding {
-    private let featureFlagService: FeatureFlagService
-    private let storesManager: StoresManager
-    private let connectivityObserver: ConnectivityObserver
-    private let currencySettings: CurrencySettings
-    private let serviceAnalytics: Analytics
-
-    init(featureFlagService: FeatureFlagService = ServiceLocator.featureFlagService,
-         storesManager: StoresManager = ServiceLocator.stores,
-         connectivityObserver: ConnectivityObserver = ServiceLocator.connectivityObserver,
-         currencySettings: CurrencySettings = ServiceLocator.currencySettings,
-         analytics: Analytics = ServiceLocator.analytics
-    ) {
-        self.featureFlagService = featureFlagService
-        self.storesManager = storesManager
-        self.connectivityObserver = connectivityObserver
-        self.currencySettings = currencySettings
-        self.serviceAnalytics = analytics
-    }
-
     var analytics: POSAnalyticsProviding {
-        POSAnalyticsAdaptor(analytics: serviceAnalytics)
+        POSAnalyticsAdaptor()
     }
 
-    var currency: CurrencySettings {
-        currencySettings
+    var currency: POSCurrencySettingsProviding {
+        POSCurrencySettingsAdaptor()
     }
 
     var featureFlags: POSFeatureFlagProviding {
-        POSFeatureFlagAdaptor(featureFlagService: featureFlagService)
+        POSFeatureFlagAdaptor()
     }
 
     var session: POSSessionManagerProviding {
-        POSSessionManagerAdaptor(sessionManager: storesManager.sessionManager)
+        POSSessionManagerAdaptor()
     }
 
-    var connectivity: ConnectivityObserver {
-        connectivityObserver
+    var connectivity: POSConnectivityProviding {
+        POSConnectivityAdaptor()
     }
 }
 
 private struct POSSessionManagerAdaptor: POSSessionManagerProviding {
-    private let sessionManager: SessionManagerProtocol
-
-    init(sessionManager: SessionManagerProtocol) {
-        self.sessionManager = sessionManager
-    }
-
     var defaultSite: Site? {
-        return sessionManager.defaultSite
+        return ServiceLocator.stores.sessionManager.defaultSite
     }
 }
 
-private struct POSFeatureFlagAdaptor: POSFeatureFlagProviding {
-    private let featureFlagService: FeatureFlagService
-
-    init(featureFlagService: FeatureFlagService) {
-        self.featureFlagService = featureFlagService
+private struct POSCurrencySettingsAdaptor: POSCurrencySettingsProviding {
+    var currencySettings: CurrencySettings {
+        ServiceLocator.currencySettings
     }
+}
 
+private struct POSFeatureFlagAdaptor: POSFeatureFlagProviding {
     func isFeatureFlagEnabled(_ flag: FeatureFlag) -> Bool {
-        return featureFlagService.isFeatureFlagEnabled(flag)
+        return ServiceLocator.featureFlagService.isFeatureFlagEnabled(flag)
     }
 }
 
 private struct POSAnalyticsAdaptor: POSAnalyticsProviding {
-    private let analytics: Analytics
-
-    init(analytics: Analytics = ServiceLocator.analytics) {
-        self.analytics = analytics
-    }
-
     func track(event: WooAnalyticsEvent) {
-        analytics.track(event: event)
+        ServiceLocator.analytics.track(event: event)
     }
 
     func track(_ stat: WooAnalyticsStat) {
         track(stat, parameters: [:])
     }
 
     func track(_ stat: WooAnalyticsStat, parameters: [String: WooAnalyticsEventPropertyType] = [:]) {
-        analytics.track(stat, withProperties: parameters)
+        ServiceLocator.analytics.track(stat, withProperties: parameters)
     }
 
     func track(_ stat: WooAnalyticsStat, parameters: [String: WooAnalyticsEventPropertyType] = [:], error: Error) {
-        analytics.track(stat, properties: parameters, error: error)
+        ServiceLocator.analytics.track(stat, properties: parameters, error: error)
+    }
+}
+
+private struct POSConnectivityAdaptor: POSConnectivityProviding {
+    var connectivityObserver: ConnectivityObserver {
+        ServiceLocator.connectivityObserver
     }
 }
diff --git a/WooCommerce/Classes/POS/Controllers/PointOfSaleOrderController.swift b/WooCommerce/Classes/POS/Controllers/PointOfSaleOrderController.swift
@@ -42,15 +42,14 @@ protocol PointOfSaleOrderControllerProtocol {
 @Observable final class PointOfSaleOrderController: PointOfSaleOrderControllerProtocol {
     init(orderService: POSOrderServiceProtocol,
          receiptService: POSReceiptServiceProtocol,
-         currencySettings: CurrencySettings,
+         currencySettingsProvider: POSCurrencySettingsProviding,
          analytics: POSAnalyticsProviding,
          featureFlagService: POSFeatureFlagProviding,
          pluginsService: PluginsServiceProtocol,
          celebration: PaymentCaptureCelebrationProtocol = PaymentCaptureCelebration()) {
         self.orderService = orderService
         self.receiptService = receiptService
-        self.storeCurrency = currencySettings.currencyCode
-        self.currencyFormatter = CurrencyFormatter(currencySettings: currencySettings)
+        self.currencySettingsProvider = currencySettingsProvider
         self.analytics = analytics
         self.featureFlagService = featureFlagService
         self.pluginsService = pluginsService
@@ -59,17 +58,23 @@ protocol PointOfSaleOrderControllerProtocol {
 
     private let orderService: POSOrderServiceProtocol
     private let receiptService: POSReceiptServiceProtocol
-
-    private let currencyFormatter: CurrencyFormatter
+    private let currencySettingsProvider: POSCurrencySettingsProviding
     private let celebration: PaymentCaptureCelebrationProtocol
-    private let storeCurrency: CurrencyCode
     private let analytics: POSAnalyticsProviding
     private let featureFlagService: POSFeatureFlagProviding
     private let pluginsService: PluginsServiceProtocol
 
     private(set) var orderState: PointOfSaleInternalOrderState = .idle
     private var order: Order? = nil
 
+    private var currencyFormatter: CurrencyFormatter {
+        CurrencyFormatter(currencySettings: currencySettingsProvider.currencySettings)
+    }
+
+    private var storeCurrency: CurrencyCode {
+        currencySettingsProvider.currencySettings.currencyCode
+    }
+
     @MainActor @discardableResult
     func syncOrder(for cart: Cart,
                    retryHandler: @escaping () async -> Void) async -> Result<SyncOrderState, Error> {
diff --git a/WooCommerce/Classes/POS/Presentation/PointOfSaleEntryPointView.swift b/WooCommerce/Classes/POS/Presentation/PointOfSaleEntryPointView.swift
@@ -81,10 +81,10 @@ struct PointOfSaleEntryPointView: View {
         }
         .environmentObject(posModalManager)
         .environment(\.posAnalytics, services.analytics)
-        .environment(\.posCurrencySettings, services.currency)
+        .environment(\.posCurrencyProvider, services.currency)
         .environment(\.posFeatureFlags, services.featureFlags)
         .environment(\.posSession, services.session)
-        .environment(\.posConnectivity, services.connectivity)
+        .environment(\.posConnectivityProvider, services.connectivity)
         .injectKeyboardObserver()
         .onAppear {
             onPointOfSaleModeActiveStateChange(true)
diff --git a/WooCommerce/Classes/POS/Presentation/Reusable Views/POSConnectivityView.swift b/WooCommerce/Classes/POS/Presentation/Reusable Views/POSConnectivityView.swift
@@ -5,7 +5,7 @@ import enum WooFoundation.ConnectivityStatus
 struct POSConnectivityView: View {
     @State private var isVisible = false
     @State private var cancellable: AnyCancellable?
-    @Environment(\.posConnectivity) private var connectivityObserver
+    @Environment(\.posConnectivityProvider) private var provider
 
     var body: some View {
         ZStack(alignment: .top) {
@@ -17,8 +17,8 @@ struct POSConnectivityView: View {
         .animation(.easeInOut(duration: Constants.connectivityAnimationDuration),
                    value: isVisible)
         .onAppear {
-            updateVisibility(connectivityObserver.currentStatus)
-            cancellable = connectivityObserver.statusPublisher
+            updateVisibility(provider.connectivityObserver.currentStatus)
+            cancellable = provider.connectivityObserver.statusPublisher
                 .receive(on: DispatchQueue.main)
                 .sink { status in
                     updateVisibility(status)
diff --git a/WooCommerce/Classes/POS/Presentation/TotalsView.swift b/WooCommerce/Classes/POS/Presentation/TotalsView.swift
@@ -494,13 +494,13 @@ private struct PaymentViewContent: View {
 private struct CashPaymentView: View {
     let cashPaymentState: PointOfSaleCashPaymentState
     let orderState: PointOfSaleOrderState
-    @Environment(\.posCurrencySettings) private var currencySettings
+    @Environment(\.posCurrencyProvider) private var currencyProvider
 
     var body: some View {
         switch cashPaymentState {
         case .collectingCash:
             if case .loaded(let total) = orderState {
-                PointOfSaleCollectCashView(orderTotal: total.orderTotal, currencySettings: currencySettings)
+                PointOfSaleCollectCashView(orderTotal: total.orderTotal, currencySettings: currencyProvider.currencySettings)
                     .transition(.move(edge: .trailing))
             }
         case .paymentSuccess:
diff --git a/WooCommerce/Classes/POS/TabBar/POSTabCoordinator.swift b/WooCommerce/Classes/POS/TabBar/POSTabCoordinator.swift
@@ -128,7 +128,7 @@ private extension POSTabCoordinator {
                     cardPresentPaymentService: cardPresentPaymentService,
                     orderController: PointOfSaleOrderController(orderService: orderService,
                                                                 receiptService: receiptService,
-                                                                currencySettings: serviceAdaptor.currency,
+                                                                currencySettingsProvider: serviceAdaptor.currency,
                                                                 analytics: serviceAdaptor.analytics,
                                                                 featureFlagService: serviceAdaptor.featureFlags,
                                                                 pluginsService: PluginsService(storageManager: storageManager)),
diff --git a/WooCommerce/WooCommerceTests/POS/Controllers/PointOfSaleOrderControllerTests.swift b/WooCommerce/WooCommerceTests/POS/Controllers/PointOfSaleOrderControllerTests.swift
