Health monitor is also asynchronous now

tapashmajumder · tapashmajumder · commit d9e6d6cb8c47 · 2022-06-08T23:41:39.000+05:30
diff --git a/swift-sdk/Internal/HealthMonitor.swift b/swift-sdk/Internal/HealthMonitor.swift
@@ -6,7 +6,7 @@ import Foundation
 
 protocol HealthMonitorDataProviderProtocol {
     var maxTasks: Int { get }
-    func countTasks() throws -> Int
+    func countTasks() throws -> Pending<Int, IterableTaskError>
 }
 
 struct HealthMonitorDataProvider: HealthMonitorDataProviderProtocol {
@@ -18,11 +18,18 @@ struct HealthMonitorDataProvider: HealthMonitorDataProviderProtocol {
     
     let maxTasks: Int
 
-    func countTasks() throws -> Int {
+    func countTasks() throws -> Pending<Int, IterableTaskError> {
+        let result = Fulfill<Int, IterableTaskError>()
         let context = persistenceContextProvider.newBackgroundContext()
-        return try context.performAndWait {
-            try context.countTasks()
+        context.perform {
+            do {
+                let count = try context.countTasks()
+                result.resolve(with: count)
+            } catch let error {
+                result.reject(with: IterableTaskError.general(error.localizedDescription))
+            }
         }
+        return result
     }
     
     private let persistenceContextProvider: IterablePersistenceContextProvider
@@ -48,23 +55,35 @@ class HealthMonitor {
     
     weak var delegate: HealthMonitorDelegate?
     
-    func canSchedule() -> Bool {
+    func canSchedule() -> Pending<Bool, Never> {
         ITBInfo()
         // do not schedule further on error
         guard errored == false else {
-            return false
+            return Fulfill<Bool, Never>(value: false)
         }
 
+        let fulfill = Fulfill<Bool, Never>()
         do {
-            let count = try dataProvider.countTasks()
-            return count < dataProvider.maxTasks
+            try dataProvider.countTasks().onCompletion { count in
+                if count < self.dataProvider.maxTasks {
+                    fulfill.resolve(with: true)
+                } else {
+                    fulfill.resolve(with: false)
+                }
+            } receiveError: { error in
+                ITBError("DBError: " + error.localizedDescription)
+                self.onError()
+                fulfill.resolve(with: false)
+            }
         } catch let error {
             ITBError("DBError: " + error.localizedDescription)
             onError()
-            return false
+            fulfill.resolve(with: false)
         }
+
+        return fulfill
     }
-    
+
     func canProcess() -> Bool {
         ITBInfo()
         return !errored
diff --git a/swift-sdk/Internal/IterableTaskRunner.swift b/swift-sdk/Internal/IterableTaskRunner.swift
@@ -15,12 +15,12 @@ class IterableTaskRunner: NSObject {
          dateProvider: DateProviderProtocol = SystemDateProvider()) {
         ITBInfo()
         self.networkSession = networkSession
-        self.persistenceContextProvider = persistenceContextProvider
         self.healthMonitor = healthMonitor
         self.notificationCenter = notificationCenter
         self.timeInterval = timeInterval
         self.dateProvider = dateProvider
         self.connectivityManager = connectivityManager
+        self.persistenceContext = persistenceContextProvider.newBackgroundContext()
         
         super.init()
 
@@ -299,15 +299,12 @@ class IterableTaskRunner: NSObject {
     private var workItem: DispatchWorkItem?
     private var paused = false
     private let networkSession: NetworkSessionProtocol
-    private let persistenceContextProvider: IterablePersistenceContextProvider
     private let healthMonitor: HealthMonitor
     private let notificationCenter: NotificationCenterProtocol
     private let timeInterval: TimeInterval
     private let dateProvider: DateProviderProtocol
     private let connectivityManager: NetworkConnectivityManager
     private var running = false
-    
-    private lazy var persistenceContext: IterablePersistenceContext = {
-        return persistenceContextProvider.newBackgroundContext()
-    }()
+
+    private let persistenceContext: IterablePersistenceContext
 }
diff --git a/swift-sdk/Internal/Pending.swift b/swift-sdk/Internal/Pending.swift
@@ -165,16 +165,23 @@ extension Pending {
     }
 }
 
-extension Pending {
-    static func inBackgroundThread<Value, Failure>(_ block: @escaping () -> Pending<Value, Failure>) -> Pending<Value, Failure> {
-        let fulfill = Fulfill<Void, Failure>()
-        DispatchQueue.global(qos: .background).async {
-            fulfill.resolve(with: ())
-        }
+extension Pending where Failure == Never {
+    func flatMap<NewValue, NewFailure>(_ closure: @escaping (Value) -> Pending<NewValue, NewFailure>) -> Pending<NewValue, NewFailure> {
+        let fulfill = Fulfill<NewValue, NewFailure>()
+        
+        onSuccess { value in
+            let pending = closure(value)
+            
+            pending.onSuccess { futureValue in
+                fulfill.resolve(with: futureValue)
+            }
             
-        return fulfill.flatMap { _ in
-            block()
+            pending.onError { futureError in
+                fulfill.reject(with: futureError)
+            }
         }
+        
+        return fulfill
     }
 }
 
diff --git a/swift-sdk/Internal/RequestHandler.swift b/swift-sdk/Internal/RequestHandler.swift
@@ -89,10 +89,10 @@ class RequestHandler: RequestHandlerProtocol {
     func updateCart(items: [CommerceItem],
                     onSuccess: OnSuccessHandler?,
                     onFailure: OnFailureHandler?) -> Pending<SendRequestValue, SendRequestError> {
-        Pending<SendRequestValue, SendRequestError>.inBackgroundThread {
-            self.chooseRequestProcessor().updateCart(items: items,
-                                                     onSuccess: onSuccess,
-                                                     onFailure: onFailure)
+        sendUsingRequestProcessor { processor in
+            processor.updateCart(items: items,
+                                 onSuccess: onSuccess,
+                                 onFailure: onFailure)
         }
     }
     
@@ -104,14 +104,14 @@ class RequestHandler: RequestHandlerProtocol {
                        templateId: NSNumber?,
                        onSuccess: OnSuccessHandler?,
                        onFailure: OnFailureHandler?) -> Pending<SendRequestValue, SendRequestError> {
-        Pending<SendRequestValue, SendRequestError>.inBackgroundThread {
-            self.chooseRequestProcessor().trackPurchase(total,
-                                                        items: items,
-                                                        dataFields: dataFields,
-                                                        campaignId: campaignId,
-                                                        templateId: templateId,
-                                                        onSuccess: onSuccess,
-                                                        onFailure: onFailure)
+        sendUsingRequestProcessor { processor in
+            processor.trackPurchase(total,
+                                    items: items,
+                                    dataFields: dataFields,
+                                    campaignId: campaignId,
+                                    templateId: templateId,
+                                    onSuccess: onSuccess,
+                                    onFailure: onFailure)
         }
     }
     
@@ -123,14 +123,14 @@ class RequestHandler: RequestHandlerProtocol {
                        dataFields: [AnyHashable: Any]?,
                        onSuccess: OnSuccessHandler?,
                        onFailure: OnFailureHandler?) -> Pending<SendRequestValue, SendRequestError> {
-        Pending<SendRequestValue, SendRequestError>.inBackgroundThread {
-            self.chooseRequestProcessor().trackPushOpen(campaignId,
-                                                        templateId: templateId,
-                                                        messageId: messageId,
-                                                        appAlreadyRunning: appAlreadyRunning,
-                                                        dataFields: dataFields,
-                                                        onSuccess: onSuccess,
-                                                        onFailure: onFailure)
+        sendUsingRequestProcessor { processor in
+            processor.trackPushOpen(campaignId,
+                                    templateId: templateId,
+                                    messageId: messageId,
+                                    appAlreadyRunning: appAlreadyRunning,
+                                    dataFields: dataFields,
+                                    onSuccess: onSuccess,
+                                    onFailure: onFailure)
         }
     }
     
@@ -139,11 +139,11 @@ class RequestHandler: RequestHandlerProtocol {
                dataFields: [AnyHashable: Any]?,
                onSuccess: OnSuccessHandler?,
                onFailure: OnFailureHandler?) -> Pending<SendRequestValue, SendRequestError> {
-        Pending<SendRequestValue, SendRequestError>.inBackgroundThread {
-            self.chooseRequestProcessor().track(event: event,
-                                                dataFields: dataFields,
-                                                onSuccess: onSuccess,
-                                                onFailure: onFailure)
+        sendUsingRequestProcessor { processor in
+            processor.track(event: event,
+                            dataFields: dataFields,
+                            onSuccess: onSuccess,
+                            onFailure: onFailure)
         }
     }
     
@@ -162,12 +162,12 @@ class RequestHandler: RequestHandlerProtocol {
                         inboxSessionId: String?,
                         onSuccess: OnSuccessHandler?,
                         onFailure: OnFailureHandler?) -> Pending<SendRequestValue, SendRequestError> {
-        Pending<SendRequestValue, SendRequestError>.inBackgroundThread {
-            self.chooseRequestProcessor().trackInAppOpen(message,
-                                                         location: location,
-                                                         inboxSessionId: inboxSessionId,
-                                                         onSuccess: onSuccess,
-                                                         onFailure: onFailure)
+        sendUsingRequestProcessor { processor in
+            processor.trackInAppOpen(message,
+                                     location: location,
+                                     inboxSessionId: inboxSessionId,
+                                     onSuccess: onSuccess,
+                                     onFailure: onFailure)
         }
     }
     
@@ -178,13 +178,13 @@ class RequestHandler: RequestHandlerProtocol {
                          clickedUrl: String,
                          onSuccess: OnSuccessHandler?,
                          onFailure: OnFailureHandler?) -> Pending<SendRequestValue, SendRequestError> {
-        Pending<SendRequestValue, SendRequestError>.inBackgroundThread {
-            self.chooseRequestProcessor().trackInAppClick(message,
-                                                          location: location,
-                                                          inboxSessionId: inboxSessionId,
-                                                          clickedUrl: clickedUrl,
-                                                          onSuccess: onSuccess,
-                                                          onFailure: onFailure)
+        sendUsingRequestProcessor { processor in
+            processor.trackInAppClick(message,
+                                      location: location,
+                                      inboxSessionId: inboxSessionId,
+                                      clickedUrl: clickedUrl,
+                                      onSuccess: onSuccess,
+                                      onFailure: onFailure)
         }
     }
     
@@ -196,47 +196,47 @@ class RequestHandler: RequestHandlerProtocol {
                          clickedUrl: String?,
                          onSuccess: OnSuccessHandler?,
                          onFailure: OnFailureHandler?) -> Pending<SendRequestValue, SendRequestError> {
-        Pending<SendRequestValue, SendRequestError>.inBackgroundThread {
-            self.chooseRequestProcessor().trackInAppClose(message,
-                                                          location: location,
-                                                          inboxSessionId: inboxSessionId,
-                                                          source: source,
-                                                          clickedUrl: clickedUrl,
-                                                          onSuccess: onSuccess,
-                                                          onFailure: onFailure)
+        sendUsingRequestProcessor { processor in
+            processor.trackInAppClose(message,
+                                      location: location,
+                                      inboxSessionId: inboxSessionId,
+                                      source: source,
+                                      clickedUrl: clickedUrl,
+                                      onSuccess: onSuccess,
+                                      onFailure: onFailure)
         }
     }
     
     @discardableResult
     func track(inboxSession: IterableInboxSession,
                onSuccess: OnSuccessHandler?,
                onFailure: OnFailureHandler?) -> Pending<SendRequestValue, SendRequestError> {
-        Pending<SendRequestValue, SendRequestError>.inBackgroundThread {
-            self.chooseRequestProcessor().track(inboxSession: inboxSession,
-                                                onSuccess: onSuccess,
-                                                onFailure: onFailure)
+        sendUsingRequestProcessor { processor in
+            processor.track(inboxSession: inboxSession,
+                            onSuccess: onSuccess,
+                            onFailure: onFailure)
         }
     }
 
     @discardableResult
     func track(inAppDelivery message: IterableInAppMessage,
                onSuccess: OnSuccessHandler?,
                onFailure: OnFailureHandler?) -> Pending<SendRequestValue, SendRequestError> {
-        Pending<SendRequestValue, SendRequestError>.inBackgroundThread {
-            self.chooseRequestProcessor().track(inAppDelivery: message,
-                                                onSuccess: onSuccess,
-                                                onFailure: onFailure)
+        sendUsingRequestProcessor { processor in
+            processor.track(inAppDelivery: message,
+                            onSuccess: onSuccess,
+                            onFailure: onFailure)
         }
     }
     
     @discardableResult
     func inAppConsume(_ messageId: String,
                       onSuccess: OnSuccessHandler?,
                       onFailure: OnFailureHandler?) -> Pending<SendRequestValue, SendRequestError> {
-        Pending<SendRequestValue, SendRequestError>.inBackgroundThread {
-            self.chooseRequestProcessor().inAppConsume(messageId,
-                                                       onSuccess: onSuccess,
-                                                       onFailure: onFailure)
+        sendUsingRequestProcessor { processor in
+            processor.inAppConsume(messageId,
+                                   onSuccess: onSuccess,
+                                   onFailure: onFailure)
         }
     }
     
@@ -247,13 +247,13 @@ class RequestHandler: RequestHandlerProtocol {
                       inboxSessionId: String?,
                       onSuccess: OnSuccessHandler?,
                       onFailure: OnFailureHandler?) -> Pending<SendRequestValue, SendRequestError> {
-        Pending<SendRequestValue, SendRequestError>.inBackgroundThread {
-            self.chooseRequestProcessor().inAppConsume(message: message,
-                                                       location: location,
-                                                       source: source,
-                                                       inboxSessionId: inboxSessionId,
-                                                       onSuccess: onSuccess,
-                                                       onFailure: onFailure)
+        sendUsingRequestProcessor { processor in
+            processor.inAppConsume(message: message,
+                                   location: location,
+                                   source: source,
+                                   inboxSessionId: inboxSessionId,
+                                   onSuccess: onSuccess,
+                                   onFailure: onFailure)
         }
     }
     
@@ -272,19 +272,27 @@ class RequestHandler: RequestHandlerProtocol {
     private let offlineProcessor: OfflineRequestProcessor?
     private let healthMonitor: HealthMonitor?
     private let onlineProcessor: OnlineRequestProcessor
-    
-    private func chooseRequestProcessor() -> RequestProcessorProtocol {
+
+    private func sendUsingRequestProcessor(closure: @escaping (RequestProcessorProtocol) -> Pending<SendRequestValue, SendRequestError>) -> Pending<SendRequestValue, SendRequestError> {
+        chooseRequestProcessor().flatMap { processor in
+            closure(processor)
+        }
+    }
+
+    private func chooseRequestProcessor() -> Pending<RequestProcessorProtocol, Never> {
         guard offlineMode else {
-            return onlineProcessor
+            return Fulfill<RequestProcessorProtocol, Never>(value: onlineProcessor)
         }
         guard
             let offlineProcessor = offlineProcessor,
             let healthMonitor = healthMonitor
         else {
-            return onlineProcessor
+            return Fulfill<RequestProcessorProtocol, Never>(value: onlineProcessor)
+        }
+        
+        return healthMonitor.canSchedule().map { value -> RequestProcessorProtocol in
+            value ? offlineProcessor : self.onlineProcessor
         }
-
-        return healthMonitor.canSchedule() ? offlineProcessor : onlineProcessor
     }
 }
 
diff --git a/tests/offline-events-tests/RequestHandlerTests.swift b/tests/offline-events-tests/RequestHandlerTests.swift
@@ -1012,10 +1012,10 @@ class RequestHandlerTests: XCTestCase {
         let request = { requestGenerator(requestHandler) }
         let expectation1 = expectation(description: #function)
         handleRequestWithSuccess(request: request,
-                                  networkSession: networkSession,
-                                  path: path,
-                                  bodyDict: bodyDict,
-                                  expectation: expectation1)
+                                 networkSession: networkSession,
+                                 path: path,
+                                 bodyDict: bodyDict,
+                                 expectation: expectation1)
         waitForTaskRunner(requestHandler: requestHandler,
                           expectation: expectation1)
     }

Original file line number	Diff line number	Diff line change
`@@ -165,16 +165,23 @@ extension Pending {`
`165`	`165`	`}`
`166`	`166`	`}`
`167`	`167`
`168`		`-extension Pending {`
`169`		`- static func inBackgroundThread<Value, Failure>(_ block: @escaping () -> Pending<Value, Failure>) -> Pending<Value, Failure> {`
`170`		`- let fulfill = Fulfill<Void, Failure>()`
`171`		`- DispatchQueue.global(qos: .background).async {`
`172`		`- fulfill.resolve(with: ())`
`173`		`- }`
	`168`	`+extension Pending where Failure == Never {`
	`169`	`+ func flatMap<NewValue, NewFailure>(_ closure: @escaping (Value) -> Pending<NewValue, NewFailure>) -> Pending<NewValue, NewFailure> {`
	`170`	`+ let fulfill = Fulfill<NewValue, NewFailure>()`
	`171`	`+`
	`172`	`+ onSuccess { value in`
	`173`	`+ let pending = closure(value)`
	`174`	`+`
	`175`	`+ pending.onSuccess { futureValue in`
	`176`	`+ fulfill.resolve(with: futureValue)`
	`177`	`+ }`
`174`	`178`
`175`		`- return fulfill.flatMap { _ in`
`176`		`- block()`
	`179`	`+ pending.onError { futureError in`
	`180`	`+ fulfill.reject(with: futureError)`
	`181`	`+ }`
`177`	`182`	`}`
	`183`	`+`
	`184`	`+ return fulfill`
`178`	`185`	`}`
`179`	`186`	`}`
`180`	`187`