Tidepool merge (#1667)

* Reorder build phases for Xcode 13

* LOOP-3980 Avoid cancelling temp basal on launch. (#499)

* Avoid cancelling temp basal on launch

* Add test for ignoring initial value of isClosedLoop

* COASTAL-651: Adds PersistedAlertStore for looking up outstanding alerts (#501)

* Checkpoint: AlertSearcher

* checkpoint

* COASTAL-651: Adds PersistedAlertStore for looking up outstanding alerts

Adds ability to query CoreData for all outstanding (i.e. "unretracted") alerts from a given `managerIdentifier`.

https://tidepool.atlassian.net/browse/COASTAL-651

* unit tests

* This makes issuing and retracting alerts synchronous, so when the functions return CoreData may be queried

(This is not ideal, but in practice the performance hit will be minimal)

* Better version of previous commit: make writes to AlertStore synchronous so subsequent reads get latest data.
(Again, performance hit should be minimal)

* PR Feedback

* COASTAL-668: Fix crash when alert acknowledgement fails (#502)

If alert acknowledgement fails, we display another in-app modal alert but need to do so on the main queue.

https://tidepool.atlassian.net/browse/COASTAL-668

* COASTAL-625: Relax requirement that HUDProvider needs to provide LevelHUDView (#503)

LevelHUDView is for providing a view that displays a thermometer level, which not all Pumps may provide (e.g. Coastal).  This relaxes the requirement and just requires returning a BaseHUDView.

https://tidepool.atlassian.net/browse/COASTAL-625

* [COASTAL-674] record already retracted alert and look up all alerts matching identifier (#504)

* record already retracted alert and look up all alerts matching identifier

* response to PR comments

* Fix merge issues

Co-authored-by: Rick Pasetto <[email protected]>
Co-authored-by: Nathaniel Hamming <[email protected]>

Author: 3 people

Common/Models/PumpManagerUI.swift

@@ -12,7 +12,7 @@ import LoopKitUI
 
 typealias PumpManagerHUDViewRawValue = [String: Any]
 
-func PumpManagerHUDViewFromRawValue(_ rawValue: PumpManagerHUDViewRawValue, pluginManager: PluginManager) -> LevelHUDView? {
+func PumpManagerHUDViewFromRawValue(_ rawValue: PumpManagerHUDViewRawValue, pluginManager: PluginManager) -> BaseHUDView? {
     guard
         let identifier = rawValue["managerIdentifier"] as? String,
         let rawState = rawValue["hudProviderView"] as? HUDProvider.HUDViewRawState,

Loop Status Extension/StatusViewController.swift

@@ -223,7 +223,7 @@ class StatusViewController: UIViewController, NCWidgetProviding {
             }
 
             // Pump Status
-            let pumpManagerHUDView: LevelHUDView
+            let pumpManagerHUDView: BaseHUDView
             if let hudViewContext = context.pumpManagerHUDViewContext,
                 let contextHUDView = PumpManagerHUDViewFromRawValue(hudViewContext.pumpManagerHUDViewRawValue, pluginManager: self.pluginManager)
             {

Loop/Managers/Alerts/AlertManager.swift

@@ -106,19 +106,23 @@ extension AlertManager: AlertManagerResponder {
     }
 
     func presentAcknowledgementFailedAlert(error: Error) {
-        let message: String
-        if let localizedError = error as? LocalizedError {
-            message = [localizedError.localizedDescription, localizedError.recoverySuggestion].compactMap({$0}).joined(separator: "\n\n")
-        } else {
-            message = String(format: NSLocalizedString("%1$@ is unable to clear the alert from your device", comment: "Message for alert shown when alert acknowledgement fails for a device, and the device does not provide a LocalizedError. (1: app name)"), Bundle.main.bundleDisplayName)
+        DispatchQueue.main.async {
+            let message: String
+            if let localizedError = error as? LocalizedError {
+                message = [localizedError.localizedDescription, localizedError.recoverySuggestion].compactMap({$0}).joined(separator: "\n\n")
+            } else {
+                message = String(format: NSLocalizedString("%1$@ is unable to clear the alert from your device", comment: "Message for alert shown when alert acknowledgement fails for a device, and the device does not provide a LocalizedError. (1: app name)"), Bundle.main.bundleDisplayName)
+            }
+            self.log.info("Alert acknowledgement failed: %{public}@", message)
+
+            let alert = UIAlertController(
+                title: NSLocalizedString("Unable To Clear Alert", comment: "Title for alert shown when alert acknowledgement fails"),
+                message: message,
+                preferredStyle: .alert)
+            alert.addAction(UIAlertAction(title: NSLocalizedString("OK", comment: "Default action for alert when alert acknowledgment fails"), style: .default))
+            
+            self.alertPresenter.present(alert, animated: true)
         }
-        let alert = UIAlertController(
-            title: NSLocalizedString("Unable To Clear Alert", comment: "Title for alert shown when alert acknowledgement fails"),
-            message: message,
-            preferredStyle: .alert)
-        alert.addAction(UIAlertAction(title: NSLocalizedString("OK", comment: "Default action for alert when alert acknowledgment fails"), style: .default))
-        
-        self.alertPresenter.present(alert, animated: true)
     }
 }
 
@@ -186,7 +190,7 @@ extension AlertManager {
     }
 
     private func playbackAlertsFromAlertStore() {
-        alertStore.lookupAllUnacknowledged {
+        alertStore.lookupAllUnacknowledgedUnretracted {
             switch $0 {
             case .failure(let error):
                 self.log.error("Could not fetch unacknowledged alerts: %@", error.localizedDescription)
@@ -251,6 +255,70 @@ extension AlertManager {
     }
 }
 
+// MARK: PersistedAlertStore
+extension AlertManager: PersistedAlertStore {
+    public func doesIssuedAlertExist(identifier: Alert.Identifier, completion: @escaping (Result<Bool, Error>) -> Void) {
+        alertStore.lookupAllMatching(identifier: identifier) { result in
+            switch result {
+            case .success(let storedAlerts):
+                completion(.success(!storedAlerts.isEmpty))
+            case .failure(let error):
+                completion(.failure(error))
+            }
+        }
+    }
+
+    public func lookupAllUnretracted(managerIdentifier: String, completion: @escaping (Result<[PersistedAlert], Error>) -> Void) {
+        alertStore.lookupAllUnretracted(managerIdentifier: managerIdentifier) {
+            switch $0 {
+            case .success(let alerts):
+                do {
+                    let result = try alerts.map {
+                        PersistedAlert(
+                            alert: try Alert(from: $0, adjustedForStorageTime: false),
+                            issuedDate: $0.issuedDate,
+                            retractedDate: $0.retractedDate,
+                            acknowledgedDate: $0.acknowledgedDate
+                        )
+                    }
+                    completion(.success(result))
+                } catch {
+                    completion(.failure(error))
+                }
+            case .failure(let error):
+                completion(.failure(error))
+            }
+        }
+    }
+
+    public func lookupAllUnacknowledgedUnretracted(managerIdentifier: String, completion: @escaping (Result<[PersistedAlert], Error>) -> Void) {
+        alertStore.lookupAllUnacknowledgedUnretracted(managerIdentifier: managerIdentifier) {
+            switch $0 {
+            case .success(let alerts):
+                do {
+                    let result = try alerts.map {
+                        PersistedAlert(
+                            alert: try Alert(from: $0, adjustedForStorageTime: false),
+                            issuedDate: $0.issuedDate,
+                            retractedDate: $0.retractedDate,
+                            acknowledgedDate: $0.acknowledgedDate
+                        )
+                    }
+                    completion(.success(result))
+                } catch {
+                    completion(.failure(error))
+                }
+            case .failure(let error):
+                completion(.failure(error))
+            }
+        }
+    }
+
+    public func recordRetractedAlert(_ alert: Alert, at date: Date) {
+        alertStore.recordRetractedAlert(alert, at: date)
+    }
+}
+
 // MARK: Extensions
 
 fileprivate extension SyncAlertObject {

Loop/Managers/Alerts/AlertStore.swift

@@ -83,7 +83,7 @@ public class AlertStore {
     }
 
     public func recordIssued(alert: Alert, at date: Date = Date(), completion: ((Result<Void, Error>) -> Void)? = nil) {
-        self.managedObjectContext.perform {
+        self.managedObjectContext.performAndWait {
             _ = StoredAlert(from: alert, context: self.managedObjectContext, issuedDate: date)
             do {
                 try self.managedObjectContext.save()
@@ -97,6 +97,23 @@ public class AlertStore {
             }
         }
     }
+
+    public func recordRetractedAlert(_ alert: Alert, at date: Date, completion: ((Result<Void, Error>) -> Void)? = nil) {
+        self.managedObjectContext.performAndWait {
+            let storedAlert = StoredAlert(from: alert, context: self.managedObjectContext, issuedDate: date)
+            storedAlert.retractedDate = date
+            do {
+                try self.managedObjectContext.save()
+                self.log.default("Recorded retracted alert: %{public}@", alert.identifier.value)
+                self.purgeExpired()
+                self.delegate?.alertStoreHasUpdatedAlertData(self)
+                completion?(.success)
+            } catch {
+                self.log.error("Could not store retracted alert: %{public}@, %{public}@", alert.identifier.value, String(describing: error))
+                completion?(.failure(error))
+            }
+        }
+    }
 
     public func recordAcknowledgement(of identifier: Alert.Identifier, at date: Date = Date(),
                                       completion: ((Result<Void, Error>) -> Void)? = nil) {
@@ -125,15 +142,57 @@ public class AlertStore {
                              },
                              completion: completion)
     }
-    
-    public func lookupAllUnacknowledged(completion: @escaping (Result<[StoredAlert], Error>) -> Void) {
+
+    public func lookupAllMatching(identifier: Alert.Identifier, completion: @escaping (Result<[StoredAlert], Error>) -> Void) {
         managedObjectContext.perform {
             do {
                 let fetchRequest: NSFetchRequest<StoredAlert> = StoredAlert.fetchRequest()
-                fetchRequest.predicate =  NSCompoundPredicate(andPredicateWithSubpredicates: [
+                let predicates = [
+                    NSPredicate(format: "managerIdentifier = %@", identifier.managerIdentifier),
+                    NSPredicate(format: "alertIdentifier = %@", identifier.alertIdentifier),
+                ]
+                fetchRequest.predicate = NSCompoundPredicate(andPredicateWithSubpredicates: predicates)
+                fetchRequest.sortDescriptors = [ NSSortDescriptor(key: "modificationCounter", ascending: true) ]
+                let result = try self.managedObjectContext.fetch(fetchRequest)
+                completion(.success(result))
+            } catch {
+                completion(.failure(error))
+            }
+        }
+    }
+
+    public func lookupAllUnretracted(managerIdentifier: String? = nil, completion: @escaping (Result<[StoredAlert], Error>) -> Void) {
+        managedObjectContext.perform {
+            do {
+                let fetchRequest: NSFetchRequest<StoredAlert> = StoredAlert.fetchRequest()
+                var predicates = [
+                    NSPredicate(format: "retractedDate == nil"),
+                ]
+                if let managerIdentifier = managerIdentifier {
+                    predicates.insert(NSPredicate(format: "managerIdentifier = %@", managerIdentifier), at: 0)
+                }
+                fetchRequest.predicate = NSCompoundPredicate(andPredicateWithSubpredicates: predicates)
+                fetchRequest.sortDescriptors = [ NSSortDescriptor(key: "modificationCounter", ascending: true) ]
+                let result = try self.managedObjectContext.fetch(fetchRequest)
+                completion(.success(result))
+            } catch {
+                completion(.failure(error))
+            }
+        }
+    }
+
+    public func lookupAllUnacknowledgedUnretracted(managerIdentifier: String? = nil, completion: @escaping (Result<[StoredAlert], Error>) -> Void) {
+        managedObjectContext.perform {
+            do {
+                let fetchRequest: NSFetchRequest<StoredAlert> = StoredAlert.fetchRequest()
+                var predicates = [
                     NSPredicate(format: "acknowledgedDate == nil"),
                     NSPredicate(format: "retractedDate == nil"),
-                ])
+                ]
+                if let managerIdentifier = managerIdentifier {
+                    predicates.insert(NSPredicate(format: "managerIdentifier = %@", managerIdentifier), at: 0)
+                }
+                fetchRequest.predicate = NSCompoundPredicate(andPredicateWithSubpredicates: predicates)
                 fetchRequest.sortDescriptors = [ NSSortDescriptor(key: "modificationCounter", ascending: true) ]
                 let result = try self.managedObjectContext.fetch(fetchRequest)
                 completion(.success(result))
@@ -172,7 +231,7 @@ extension AlertStore {
                                    addingPredicate predicate: NSPredicate,
                                    with updateBlock: @escaping ManagedObjectUpdateBlock,
                                    completion: ((Result<Void, Error>) -> Void)?) {
-        managedObjectContext.perform {
+        managedObjectContext.performAndWait {
             self.lookupAll(identifier: identifier, predicate: predicate) {
                 switch $0 {
                 case .success(let objects):
@@ -194,7 +253,7 @@ extension AlertStore {
                                       addingPredicate predicate: NSPredicate,
                                       with updateBlock: @escaping ManagedObjectUpdateBlock,
                                       completion: ((Result<Void, Error>) -> Void)?) {
-        managedObjectContext.perform {
+        managedObjectContext.performAndWait {
             self.lookupLatest(identifier: identifier, predicate: predicate) {
                 switch $0 {
                 case .success(let object):

Loop/Managers/DeviceDataManager.swift

@@ -807,6 +807,28 @@ extension DeviceDataManager: AlertIssuer {
     }
 }
 
+// MARK: - PersistedAlertStore
+extension DeviceDataManager: PersistedAlertStore {
+    func doesIssuedAlertExist(identifier: Alert.Identifier, completion: @escaping (Swift.Result<Bool, Error>) -> Void) {
+        precondition(alertManager != nil)
+        alertManager.doesIssuedAlertExist(identifier: identifier, completion: completion)
+    }
+    func lookupAllUnretracted(managerIdentifier: String, completion: @escaping (Swift.Result<[PersistedAlert], Error>) -> Void) {
+        precondition(alertManager != nil)
+        alertManager.lookupAllUnretracted(managerIdentifier: managerIdentifier, completion: completion)
+    }
+    
+    func lookupAllUnacknowledgedUnretracted(managerIdentifier: String, completion: @escaping (Swift.Result<[PersistedAlert], Error>) -> Void) {
+        precondition(alertManager != nil)
+        alertManager.lookupAllUnacknowledgedUnretracted(managerIdentifier: managerIdentifier, completion: completion)
+    }
+
+    func recordRetractedAlert(_ alert: Alert, at date: Date) {
+        precondition(alertManager != nil)
+        alertManager.recordRetractedAlert(alert, at: date)
+    }
+}
+
 // MARK: - CGMManagerDelegate
 extension DeviceDataManager: CGMManagerDelegate {
     func cgmManagerWantsDeletion(_ manager: CGMManager) {

Loop/Managers/LoopDataManager.swift

@@ -178,8 +178,8 @@ final class LoopDataManager: LoopSettingsAlerterDelegate {
         // Cancel any active temp basal when going into closed loop off mode
         // The dispatch is necessary in case this is coming from a didSet already on the settings struct.
         self.automaticDosingStatus.$isClosedLoop
-            .removeDuplicates()
             .dropFirst()
+            .removeDuplicates()
             .receive(on: DispatchQueue.main)
             .sink { if !$0 {
                 self.mutateSettings { settings in

Loop/View Controllers/StatusTableViewController.swift

@@ -1511,7 +1511,7 @@ final class StatusTableViewController: LoopChartsTableViewController {
         }
     }
 
-    private func addPumpManagerViewToHUD(_ view: LevelHUDView) {
+    private func addPumpManagerViewToHUD(_ view: BaseHUDView) {
         if let hudView = hudView {
             view.stateColors = .pumpStatus
             hudView.addPumpManagerProvidedHUDView(view)