1. Encapsulate core data calls within context.performAndWait

Author: tapashmajumder

swift-sdk/Internal/CoreDataUtil.swift

@@ -72,3 +72,13 @@ struct CoreDataUtil {
         }
     }
 }
+
+extension NSManagedObjectContext {
+    func performAndWait<T>(_ block: () throws -> T) throws -> T {
+        var result: Result<T, Error>?
+        performAndWait {
+            result = Result { try block() }
+        }
+        return try result!.get()
+    }
+}

swift-sdk/Internal/HealthMonitor.swift

@@ -19,7 +19,10 @@ struct HealthMonitorDataProvider: HealthMonitorDataProviderProtocol {
     let maxTasks: Int
 
     func countTasks() throws -> Int {
-        return try persistenceContextProvider.newBackgroundContext().countTasks()
+        let context = persistenceContextProvider.newBackgroundContext()
+        return try context.performAndWait {
+            try context.countTasks()
+        }
     }
 
     private let persistenceContextProvider: IterablePersistenceContextProvider

swift-sdk/Internal/IterableCoreDataPersistence.swift

@@ -130,11 +130,13 @@ struct CoreDataPersistenceContext: IterablePersistenceContext {
     }
 
     func nextTask() throws -> IterableTask? {
-        let taskManagedObjects: [IterableTaskManagedObject] = try CoreDataUtil.findSortedEntities(context: managedObjectContext,
-                                                                                                  entity: PersistenceConst.Entity.Task.name,
-                                                                                                  column: PersistenceConst.Entity.Task.Column.scheduledAt,
-                                                                                                  ascending: true,
-                                                                                                  limit: 1)
+        let taskManagedObjects: [IterableTaskManagedObject] = try performAndWait {
+            try CoreDataUtil.findSortedEntities(context: managedObjectContext,
+                                                entity: PersistenceConst.Entity.Task.name,
+                                                column: PersistenceConst.Entity.Task.Column.scheduledAt,
+                                                ascending: true,
+                                                limit: 1)
+        }
         return taskManagedObjects.first.map(PersistenceHelper.task(from:))
     }
 
@@ -179,6 +181,10 @@ struct CoreDataPersistenceContext: IterablePersistenceContext {
         managedObjectContext.performAndWait(block)
     }
 
+    func performAndWait<T>(_ block: () throws -> T) throws -> T {
+        try managedObjectContext.performAndWait(block)
+    }
+    
     private let managedObjectContext: NSManagedObjectContext
     private let dateProvider: DateProviderProtocol
 

swift-sdk/Internal/IterablePersistence.swift

@@ -46,6 +46,8 @@ protocol IterablePersistenceContext {
     func perform(_ block: @escaping () -> Void)
 
     func performAndWait(_ block: () -> Void)
+    
+    func performAndWait<T>(_ block: () throws -> T) throws -> T
 }
 
 protocol IterablePersistenceContextProvider {

swift-sdk/Internal/IterableTaskRunner.swift

@@ -244,8 +244,10 @@ class IterableTaskRunner: NSObject {
 
     private func deleteTask(task: IterableTask) {
         do {
-            try persistenceContext.delete(task: task)
-            try persistenceContext.save()
+            try persistenceContext.performAndWait {
+                try persistenceContext.delete(task: task)
+                try persistenceContext.save()
+            }
         } catch let error {
             ITBError(error.localizedDescription)
             healthMonitor.onDeleteError(task: task)

swift-sdk/Internal/IterableTaskScheduler.swift

@@ -23,14 +23,16 @@ class IterableTaskScheduler {
         do {
             let data = try JSONEncoder().encode(apiCallRequest)
 
-            try persistenceContext.create(task: IterableTask(id: taskId,
-                                                             name: apiCallRequest.getPath(),
-                                                             type: .apiCall,
-                                                             scheduledAt: scheduledAt ?? dateProvider.currentDate,
-                                                             data: data,
-                                                             requestedAt: dateProvider.currentDate))
-            try persistenceContext.save()
-            
+            try persistenceContext.performAndWait {
+                try persistenceContext.create(task: IterableTask(id: taskId,
+                                                                 name: apiCallRequest.getPath(),
+                                                                 type: .apiCall,
+                                                                 scheduledAt: scheduledAt ?? dateProvider.currentDate,
+                                                                 data: data,
+                                                                 requestedAt: dateProvider.currentDate))
+                try persistenceContext.save()
+                
+            }
             notificationCenter.post(name: .iterableTaskScheduled, object: self, userInfo: nil)
         } catch let error {
             healthMonitor.onScheduleError(apiCallRequest: apiCallRequest)

swift-sdk/Internal/Pending.swift

@@ -165,6 +165,19 @@ 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: ())
+        }
+            
+        return fulfill.flatMap { _ in
+            block()
+        }
+    }
+}
+
 // This class takes the responsibility of setting value for Pending
 class Fulfill<Value, Failure>: Pending<Value, Failure> where Failure: Error {
     public init(value: Value? = nil) {

swift-sdk/Internal/RequestHandler.swift

@@ -197,11 +197,13 @@ class RequestHandler: RequestHandlerProtocol {
     func track(inboxSession: IterableInboxSession,
                onSuccess: OnSuccessHandler?,
                onFailure: OnFailureHandler?) -> Pending<SendRequestValue, SendRequestError> {
-        chooseRequestProcessor().track(inboxSession: inboxSession,
-                                       onSuccess: onSuccess,
-                                       onFailure: onFailure)
+        Pending<SendRequestValue, SendRequestError>.inBackgroundThread {
+            self.chooseRequestProcessor().track(inboxSession: inboxSession,
+                                                onSuccess: onSuccess,
+                                                onFailure: onFailure)
+        }
     }
-    
+
     @discardableResult
     func track(inAppDelivery message: IterableInAppMessage,
                onSuccess: OnSuccessHandler?,

tests/offline-events-tests/MockPersistence.swift

@@ -20,6 +20,7 @@ class MockPersistenceContext: IterablePersistenceContext {
         var saveCallback: (() throws -> Void)? = nil
         var performCallback: (() -> Void)? = nil
         var performAndWaitCallback: (() -> Void)? = nil
+        var performAndWaitCallbackWithResult: (() -> Void)? = nil
     }
 
     init(input: Input = Input()) {
@@ -105,6 +106,12 @@ class MockPersistenceContext: IterablePersistenceContext {
         block()
     }
 
+    func performAndWait<T>(_ block: () throws -> T) throws -> T {
+        ITBInfo()
+        input.performAndWaitCallbackWithResult?()
+        return try block()
+    }
+    
     private let input: Input
     private var tasks = [IterableTask]()
 }