Remote Action Models

Author: gestrich

Loop/Managers/DeviceDataManager.swift

@@ -812,6 +812,18 @@ extension DeviceDataManager {
             self.loopManager.updateRemoteRecommendation()
         }
     }
+    
+    func enactBolus(units: Double, activationType: BolusActivationType) async throws {
+        return try await withCheckedThrowingContinuation { continuation in
+            enactBolus(units: units, activationType: activationType) { error in
+                if let error = error {
+                    continuation.resume(throwing: error)
+                    return
+                }
+                continuation.resume()
+            }
+        }
+    }
 
     var pumpManagerStatus: PumpManagerStatus? {
         return pumpManager?.status
@@ -1341,8 +1353,15 @@ extension Notification.Name {
 
 // MARK: - Remote Notification Handling
 extension DeviceDataManager {
+    
     func handleRemoteNotification(_ notification: [String: AnyObject]) {
-
+        Task {
+            await handleRemoteNotification(notification)
+        }
+    }
+    
+    func handleRemoteNotification(_ notification: [String: AnyObject]) async {
+        
         defer {
             log.default("Remote Notification: Finished handling")
         }
@@ -1351,9 +1370,6 @@ extension DeviceDataManager {
             log.error("Remote Notification: Overrides not enabled.")
             return
         }
-        
-        let defaultServiceIdentifier = "NightscoutService"
-        let serviceIdentifer = notification["serviceIdentifier"] as? String ?? defaultServiceIdentifier
 
         if let expirationStr = notification["expiration"] as? String {
             let formatter = ISO8601DateFormatter()
@@ -1362,7 +1378,7 @@ extension DeviceDataManager {
                 let nowDate = Date()
                 guard nowDate < expiration else {
                     let expiredInterval = nowDate.timeIntervalSince(expiration)
-                    NotificationManager.sendRemoteCommandExpiredNotification(timeExpired: expiredInterval)
+                    await NotificationManager.sendRemoteCommandExpiredNotification(timeExpired: expiredInterval)
                     log.error("Remote Notification: Expired: %{public}@", String(describing: notification))
                     return
                 }
@@ -1372,156 +1388,175 @@ extension DeviceDataManager {
             }
         }
 
-        let command: RemoteCommand
+        let action: RemoteAction
 
         do {
-            command = try RemoteCommand.createRemoteCommand(notification: notification, allowedPresets: loopManager.settings.overridePresets, defaultAbsorptionTime: carbStore.defaultAbsorptionTimes.medium).get()
+            action = try RemoteAction.createRemoteAction(notification: notification).get()
         } catch {
             log.error("Remote Notification: Parse Error: %{public}@", String(describing: error))
             return
         }
-
-        switch command {
-            
-        case .temporaryScheduleOverride(let remoteOverride):
-            log.default("Remote Notification: Enacting temporary override: %{public}@", String(describing: remoteOverride))
-            activateRemoteOverride(remoteOverride)
-        case .cancelTemporaryOverride:
-            log.default("Remote Notification: Canceling temporary override")
-            activateRemoteOverride(nil)
-        case .bolusEntry(let bolusAmount):
-            log.default("Remote Notification: Enacting bolus entry: %{public}@", String(describing: bolusAmount))
-            
-            //Remote bolus requires validation from its remote source
-            
-            let validationResult = remoteDataServicesManager.validatePushNotificationSource(notification, serviceIdentifier: serviceIdentifer)
-
-            switch validationResult {
-            case .success():
-                log.info("Remote Notification: Validation successful")
-            case .failure(let error):
-                NotificationManager.sendRemoteBolusFailureNotification(for: error, amount: bolusAmount)
-                log.error("Remote Notification: Could not validate notification: %{public}@", String(describing: notification))
-                return
-            }
-            
-            guard let maxBolusAmount = loopManager.settings.maximumBolus else {
-                NotificationManager.sendRemoteBolusFailureNotification(for: RemoteCommandError.missingMaxBolus, amount: bolusAmount)
-                log.error("Remote Notification: No max bolus detected. Aborting...")
-                return
-            }
-            
-            guard bolusAmount.isLessThanOrEqualTo(maxBolusAmount) else {
-                NotificationManager.sendRemoteBolusFailureNotification(for: RemoteCommandError.exceedsMaxBolus, amount: bolusAmount)
-                log.error("Remote Notification: Bolus exceeds maximum allowed. Aborting...")
-                return
-            }
-            
-            self.enactRemoteBolus(units: bolusAmount) { error in
-                if let error = error {
-                    self.log.error("Remote Notification: Error adding bolus: %{public}@", String(describing: error))
-                    NotificationManager.sendRemoteBolusFailureNotification(for: error, amount: bolusAmount)
-                } else {
-                    NotificationManager.sendRemoteBolusNotification(amount: bolusAmount)
-                }
-            }
-        case .carbsEntry(let candidateCarbEntry):
-            log.default("Remote Notification: Adding carbs entry: %{public}@", String(describing: candidateCarbEntry))
-            
-            let candidateCarbsInGrams = candidateCarbEntry.quantity.doubleValue(for: .gram())
-            
-            //Remote carb entry requires validation from its remote source
-            let validationResult = remoteDataServicesManager.validatePushNotificationSource(notification, serviceIdentifier: serviceIdentifer)
-            switch validationResult {
-            case .success():
-                log.info("Remote Notification: Validation successful")
-            case .failure(let error):
-                NotificationManager.sendRemoteCarbEntryFailureNotification(for: error, amountInGrams: candidateCarbsInGrams)
-                log.error("Remote Notification: Could not validate notification: %{public}@", String(describing: notification))
-                return
+        
+        log.default("Remote Notification: Handling action %{public}@", String(describing: action))
+        
+        switch action {
+        case .temporaryScheduleOverride(let overrideAction):
+            do {
+                try await handleRemoteOverrideAction(overrideAction)
+            } catch {
+                log.error("Remote Notification: Override Action Error: %{public}@", String(describing: error))
             }
-            
-            guard candidateCarbsInGrams > 0.0 else {
-                NotificationManager.sendRemoteCarbEntryFailureNotification(for: RemoteCommandError.invalidCarbs, amountInGrams: candidateCarbsInGrams)
-                log.error("Remote Notification: Invalid carb entry amount. Aborting...")
-                return
+        case .cancelTemporaryOverride(let overrideCancelAction):
+            do {
+                try await handleRemoteOverrideCancelAction(overrideCancelAction)
+            } catch {
+                log.error("Remote Notification: Override Action Cancel Error: %{public}@", String(describing: error))
             }
-            
-            guard candidateCarbsInGrams <= LoopConstants.maxCarbEntryQuantity.doubleValue(for: .gram()) else {
-                NotificationManager.sendRemoteCarbEntryFailureNotification(for: RemoteCommandError.exceedsMaxCarbs, amountInGrams: candidateCarbsInGrams)
-                log.error("Remote Notification: Carbs higher than maximum. Aborting...")
-                return
+        case .bolusEntry(let bolusAction):
+            do {
+                try validatePushNotificationSource(notification: notification)
+                try await handleRemoteBolusAction(bolusAction)
+            } catch {
+                await NotificationManager.sendRemoteBolusFailureNotification(for: error, amount: bolusAction.amountInUnits)
+                log.error("Remote Notification: Bolus Action Error: %{public}@", String(describing: notification))
             }
-
-            addRemoteCarbEntry(candidateCarbEntry) { carbEntryAddResult in
-                switch carbEntryAddResult {
-                case .success(let completedCarbEntry):
-                    NotificationManager.sendRemoteCarbEntryNotification(amountInGrams: completedCarbEntry.quantity.doubleValue(for: .gram()))
-                case .failure(let error):
-                    self.log.error("Remote Notification: Error adding carb entry: %{public}@", String(describing: error))
-                    NotificationManager.sendRemoteCarbEntryFailureNotification(for: error, amountInGrams: candidateCarbsInGrams)
-                }
+        case .carbsEntry(let carbAction):
+            do {
+                try validatePushNotificationSource(notification: notification)
+                try await handleRemoteCarbAction(carbAction)
+            } catch {
+                await NotificationManager.sendRemoteCarbEntryFailureNotification(for: error, amountInGrams: carbAction.amountInGrams)
+                log.error("Remote Notification: Carb Action Error: %{public}@", String(describing: notification))
             }
         }
     }
 
-    func activateRemoteOverride(_ remoteOverride: TemporaryScheduleOverride?) {
+    func validatePushNotificationSource(notification: [String: AnyObject]) throws {
+        
+        let defaultServiceIdentifier = "NightscoutService"
+        let serviceIdentifer = notification["serviceIdentifier"] as? String ?? defaultServiceIdentifier
+        
+        let validationResult = remoteDataServicesManager.validatePushNotificationSource(notification, serviceIdentifier: serviceIdentifer)
+        switch validationResult {
+        case .success():
+            log.info("Remote Notification: Validation successful")
+        case .failure(let error):
+            throw error
+        }
+    }
+    
+    //Remote Overrides
+    
+    func handleRemoteOverrideAction(_ action: RemoteOverrideAction) async throws {
+        let remoteOverride = try action.toValidOverride(allowedPresets: loopManager.settings.overridePresets)
+        await activateRemoteOverride(remoteOverride)
+    }
+    
+    func handleRemoteOverrideCancelAction(_ cancelAction: RemoteOverrideCancelAction) async throws {
+        await activateRemoteOverride(nil)
+    }
+    
+    func activateRemoteOverride(_ remoteOverride: TemporaryScheduleOverride?) async {
         loopManager.mutateSettings { settings in settings.scheduleOverride = remoteOverride }
-        self.triggerBackgroundUpload(for: .overrides)
+        await remoteDataServicesManager.triggerUpload(for: .overrides)
     }
 
-    func addRemoteCarbEntry(_ carbEntry: NewCarbEntry, completion: @escaping (_ result: CarbStoreResult<StoredCarbEntry>) -> Void) {
-
-        var backgroundTask: UIBackgroundTaskIdentifier?
-        backgroundTask = UIApplication.shared.beginBackgroundTask(withName: "Add Remote Carb Entry") {
-            guard let backgroundTask = backgroundTask else {return}
-            UIApplication.shared.endBackgroundTask(backgroundTask)
-            self.log.error("Add Remote Carb Entry background task expired")
+    //Remote Bolus
+    
+    func handleRemoteBolusAction(_ bolusCommand: RemoteBolusAction) async throws {
+        let validBolusAmount = try bolusCommand.toValidBolusAmount(maximumBolus: loopManager.settings.maximumBolus)
+        try await self.enactBolus(units: validBolusAmount, activationType: .manualNoRecommendation)
+        await triggerBackgroundUpload(for: .dose)
+        self.analyticsServicesManager.didBolus(source: "Remote", units: validBolusAmount)
+    }
+    
+    //Remote Carb Entry
+    
+    func handleRemoteCarbAction(_ carbCommand: RemoteCarbAction) async throws {
+        let candidateCarbEntry = try carbCommand.toValidCarbEntry(
+            defaultAbsorptionTime: carbStore.defaultAbsorptionTimes.medium,
+            minAbsorptionTime: LoopConstants.minCarbAbsorptionTime,
+            maxAbsorptionTime: LoopConstants.maxCarbAbsorptionTime,
+            maxCarbEntryQuantity: LoopConstants.maxCarbEntryQuantity.doubleValue(for: .gram()),
+            maxCarbEntryPastTime: LoopConstants.maxCarbEntryPastTime,
+            maxCarbEntryFutureTime: LoopConstants.maxCarbEntryFutureTime
+        )
+        
+        let _ = try await addRemoteCarbEntry(candidateCarbEntry)
+        await triggerBackgroundUpload(for: .carb)
+    }
+    
+    //Can't add this concurrency wrapper method to Loopkit due to the minimum iOS version
+    func addRemoteCarbEntry(_ carbEntry: NewCarbEntry) async throws -> StoredCarbEntry {
+        return try await withCheckedThrowingContinuation { continuation in
+            carbStore.addCarbEntry(carbEntry) { result in
+                switch result {
+                case .success(let storedCarbEntry):
+                    self.analyticsServicesManager.didAddCarbs(source: "Remote", amount: carbEntry.quantity.doubleValue(for: .gram()))
+                    continuation.resume(returning: storedCarbEntry)
+                case .failure(let error):
+                    continuation.resume(throwing: error)
+                }
+            }
         }
-
-        carbStore.addCarbEntry(carbEntry) { result in
-            self.triggerBackgroundUpload(for: .carb)
-            if let backgroundTask = backgroundTask {
-                UIApplication.shared.endBackgroundTask(backgroundTask)
+    }
+    
+    //Background Uploads
+    
+    func triggerBackgroundUpload(for triggeringType: RemoteDataType) async {
+        Task {
+            return try await withCheckedThrowingContinuation { continuation in
+                triggerBackgroundUpload(for: triggeringType) {
+                    continuation.resume()
+                }
             }
-            completion(result)
-            self.analyticsServicesManager.didAddCarbs(source: "Remote", amount: carbEntry.quantity.doubleValue(for: .gram()))
         }
     }
 
-    func enactRemoteBolus(units: Double, completion: @escaping (_ error: Error?) -> Void = { _ in }) {
+    func triggerBackgroundUpload(for triggeringType: RemoteDataType, completion: (() -> Void)? = nil) {
 
         var backgroundTask: UIBackgroundTaskIdentifier?
-        backgroundTask = UIApplication.shared.beginBackgroundTask(withName: "Enact Remote Bolus") {
-            guard let backgroundTask = backgroundTask else {return}
-            UIApplication.shared.endBackgroundTask(backgroundTask)
-            self.log.error("Enact Remote Bolus background task expired")
-        }
+        backgroundTask = beginBackgroundTask(name: "Remote Data Upload")
 
-        self.enactBolus(units: units, activationType: .manualNoRecommendation) { error in
-            self.triggerBackgroundUpload(for: .dose)
-            if let backgroundTask = backgroundTask {
-                UIApplication.shared.endBackgroundTask(backgroundTask)
-            }
-            completion(error)
-            self.analyticsServicesManager.didBolus(source: "Remote", units: units)
+        self.remoteDataServicesManager.triggerUpload(for: triggeringType) {
+            self.endBackgroundTask(backgroundTask)
+            completion?()
         }
     }
 
-    func triggerBackgroundUpload(for triggeringType: RemoteDataType) {
-        
+    func beginBackgroundTask(name: String) -> UIBackgroundTaskIdentifier? {
         var backgroundTask: UIBackgroundTaskIdentifier?
-        backgroundTask = UIApplication.shared.beginBackgroundTask(withName: "Remote Data Upload") {
+        backgroundTask = UIApplication.shared.beginBackgroundTask(withName: name) {
             guard let backgroundTask = backgroundTask else {return}
             UIApplication.shared.endBackgroundTask(backgroundTask)
-            self.log.error("Remote Data Upload background task expired")
+            self.log.error("Background Task Expired: %{public}@", name)
         }
 
-        self.remoteDataServicesManager.triggerUpload(for: triggeringType) {
-            if let backgroundTask = backgroundTask {
-                UIApplication.shared.endBackgroundTask(backgroundTask)
+        return backgroundTask
+    }
+    
+    func beginBackgroundTask(name: String) async -> UIBackgroundTaskIdentifier? {
+        var backgroundTask: UIBackgroundTaskIdentifier?
+        backgroundTask = await UIApplication.shared.beginBackgroundTask(withName: name) {
+            guard let backgroundTask = backgroundTask else {return}
+            Task {
+                await UIApplication.shared.endBackgroundTask(backgroundTask)
             }
+            
+            self.log.error("Background Task Expired: %{public}@", name)
         }
+        
+        return backgroundTask
+    }
+    
+    func endBackgroundTask(_ backgroundTask: UIBackgroundTaskIdentifier?) async {
+        guard let backgroundTask else {return}
+        await UIApplication.shared.endBackgroundTask(backgroundTask)
+    }
+    
+    func endBackgroundTask(_ backgroundTask: UIBackgroundTaskIdentifier?) {
+        guard let backgroundTask else {return}
+        UIApplication.shared.endBackgroundTask(backgroundTask)
     }
 }
 

Loop/Managers/NotificationManager.swift

@@ -78,6 +78,7 @@ extension NotificationManager {
 
     // MARK: - Notifications
 
+    @MainActor
     static func sendRemoteCommandExpiredNotification(timeExpired: TimeInterval) {
         let notification = UNMutableNotificationContent()
 
@@ -134,6 +135,7 @@ extension NotificationManager {
         UNUserNotificationCenter.current().add(request)
     }
 
+    @MainActor
     static func sendRemoteBolusNotification(amount: Double) {
         let notification = UNMutableNotificationContent()
         let quantityFormatter = QuantityFormatter()
@@ -157,6 +159,7 @@ extension NotificationManager {
         UNUserNotificationCenter.current().add(request)
     }
 
+    @MainActor
     static func sendRemoteBolusFailureNotification(for error: Error, amount: Double) {
         let notification = UNMutableNotificationContent()
         let quantityFormatter = QuantityFormatter()
@@ -178,6 +181,7 @@ extension NotificationManager {
         UNUserNotificationCenter.current().add(request)
     }
 
+    @MainActor
     static func sendRemoteCarbEntryNotification(amountInGrams: Double) {
         let notification = UNMutableNotificationContent()
 
@@ -198,6 +202,7 @@ extension NotificationManager {
         UNUserNotificationCenter.current().add(request)
     }
 
+    @MainActor
     static func sendRemoteCarbEntryFailureNotification(for error: Error, amountInGrams: Double) {
         let notification = UNMutableNotificationContent()