LOOP-1057: Support for in-app and user notification alerts (#64)

* checkpoint

* checkpoint - kind of working

* checkpoint

* checkpoint

* tweak

* unused import

* Fix a bug introduced when I cleaned up the code

* PR Feedback

* PR Feedback

* Wrap up the `managerIdentifier` and `typeIdentifier` into a single type, `Identifier`

* PR Feedback: renaming:

UserAlert* -> DeviceAlert*
scheduleAlert -> issueAlert
unscheduleAlert -> removePendingAlerts
cancelAlert -> removeDeliveredAlerts

* More renaming, move acknowledgeDeviceAlert to DeviceAlertManager (where it really should've been)

* Project file, removeAlertResponder

* More PR Feedback: get rid of AcknowledgeCompletion

* added a comment

* PR feedback: renaming only

deviceManagerInstanceIdentifier -> deviceManagerIdentifier
removePendingAlerts -> removePendingAlert
removeDeliveredAlerts -> removeDeliveredAlert

* More PR Feedback:

- Made `alertsShowing` and `alertsPending` a dictionary, by request.  Also took the opportunity to add some bulletproofing "preconditions".
- Also, a bonus: I didn't like the asymmetry of the `DeviceAlertManagerResponder` protocol, and it was unnecessary.  So a small change there.

* PR feedback: one more rename: deviceManagerIdentifier -> managerIdentifier

Author: rickpasetto

Loop.xcodeproj/project.pbxproj

@@ -22,6 +22,9 @@
 /* End PBXAggregateTarget section */
 
 /* Begin PBXBuildFile section */
+		1DA649A7244126CD00F61E75 /* UserNotificationDeviceAlertHandler.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1DA649A6244126CD00F61E75 /* UserNotificationDeviceAlertHandler.swift */; };
+		1DA649A9244126DA00F61E75 /* InAppModalDeviceAlertHandler.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1DA649A8244126DA00F61E75 /* InAppModalDeviceAlertHandler.swift */; };
+		1DB1065124467E18005542BD /* DeviceAlertManager.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1DB1065024467E18005542BD /* DeviceAlertManager.swift */; };
 		43027F0F1DFE0EC900C51989 /* HKUnit.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4F526D5E1DF2459000A04910 /* HKUnit.swift */; };
 		4302F4E11D4E9C8900F0FCAF /* TextFieldTableViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4302F4E01D4E9C8900F0FCAF /* TextFieldTableViewController.swift */; };
 		4302F4E31D4EA54200F0FCAF /* InsulinDeliveryTableViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4302F4E21D4EA54200F0FCAF /* InsulinDeliveryTableViewController.swift */; };
@@ -561,6 +564,9 @@
 /* End PBXCopyFilesBuildPhase section */
 
 /* Begin PBXFileReference section */
+		1DA649A6244126CD00F61E75 /* UserNotificationDeviceAlertHandler.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = UserNotificationDeviceAlertHandler.swift; sourceTree = "<group>"; };
+		1DA649A8244126DA00F61E75 /* InAppModalDeviceAlertHandler.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = InAppModalDeviceAlertHandler.swift; sourceTree = "<group>"; };
+		1DB1065024467E18005542BD /* DeviceAlertManager.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = DeviceAlertManager.swift; sourceTree = "<group>"; };
 		4302F4E01D4E9C8900F0FCAF /* TextFieldTableViewController.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TextFieldTableViewController.swift; sourceTree = "<group>"; };
 		4302F4E21D4EA54200F0FCAF /* InsulinDeliveryTableViewController.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = InsulinDeliveryTableViewController.swift; sourceTree = "<group>"; };
 		430B29892041F54A00BA9F93 /* NSUserDefaults.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = NSUserDefaults.swift; sourceTree = "<group>"; };
@@ -1145,6 +1151,16 @@
 /* End PBXFrameworksBuildPhase section */
 
 /* Begin PBXGroup section */
+		1DA6499D2441266400F61E75 /* DeviceAlert */ = {
+			isa = PBXGroup;
+			children = (
+				1DB1065024467E18005542BD /* DeviceAlertManager.swift */,
+				1DA649A8244126DA00F61E75 /* InAppModalDeviceAlertHandler.swift */,
+				1DA649A6244126CD00F61E75 /* UserNotificationDeviceAlertHandler.swift */,
+			);
+			path = DeviceAlert;
+			sourceTree = "<group>";
+		};
 		4328E0121CFBE1B700E199AA /* Controllers */ = {
 			isa = PBXGroup;
 			children = (
@@ -1541,6 +1557,7 @@
 		43F5C2E41B93C5D4003EB13D /* Managers */ = {
 			isa = PBXGroup;
 			children = (
+				1DA6499D2441266400F61E75 /* DeviceAlert */,
 				439897361CD2F80600223065 /* AnalyticsServicesManager.swift */,
 				439BED291E76093C00B0AED5 /* CGMManager.swift */,
 				43DBF0521C93EC8200B3C386 /* DeviceDataManager.swift */,
@@ -2515,11 +2532,13 @@
 				C1F8B243223E73FD00DD66CF /* BolusProgressTableViewCell.swift in Sources */,
 				89D6953E23B6DF8A002B3066 /* PotentialCarbEntryTableViewCell.swift in Sources */,
 				89CA2B30226C0161004D9350 /* DirectoryObserver.swift in Sources */,
+				1DA649A7244126CD00F61E75 /* UserNotificationDeviceAlertHandler.swift in Sources */,
 				439A7942211F631C0041B75F /* RootNavigationController.swift in Sources */,
 				4F11D3C020DCBEEC006E072C /* GlucoseBackfillRequestUserInfo.swift in Sources */,
 				43F5C2DB1B92A5E1003EB13D /* SettingsTableViewController.swift in Sources */,
 				89E267FC2292456700A3F2AF /* FeatureFlags.swift in Sources */,
 				43A567691C94880B00334FAC /* LoopDataManager.swift in Sources */,
+				1DA649A9244126DA00F61E75 /* InAppModalDeviceAlertHandler.swift in Sources */,
 				43B260491ED248FB008CAA77 /* CarbEntryTableViewCell.swift in Sources */,
 				4302F4E11D4E9C8900F0FCAF /* TextFieldTableViewController.swift in Sources */,
 				43F64DD91D9C92C900D24DC6 /* TitleSubtitleTableViewCell.swift in Sources */,
@@ -2538,6 +2557,7 @@
 				89CA2B32226C18B8004D9350 /* TestingScenariosTableViewController.swift in Sources */,
 				43E93FB71E469A5100EAB8DB /* HKUnit.swift in Sources */,
 				43C05CAF21EB2C24006FB252 /* NSBundle.swift in Sources */,
+				1DB1065124467E18005542BD /* DeviceAlertManager.swift in Sources */,
 				43BFF0BC1E45C80600FF19A9 /* UIColor+Loop.swift in Sources */,
 				43C0944A1CACCC73001F6403 /* NotificationManager.swift in Sources */,
 				43D9003321EB258C00AF44BF /* InsulinModelSettings+Loop.swift in Sources */,

Loop/AppDelegate.swift

@@ -19,31 +19,36 @@ final class AppDelegate: UIResponder, UIApplicationDelegate {
 
     private lazy var pluginManager = PluginManager()
 
-    private lazy var deviceManager = DeviceDataManager(pluginManager: pluginManager)
-
+    private var deviceDataManager: DeviceDataManager!
+    private var deviceAlertManager: DeviceAlertManager!
+    
     var window: UIWindow?
 
     private var rootViewController: RootNavigationController! {
         return window?.rootViewController as? RootNavigationController
     }
 
     func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
-        SharedLogging.instance = deviceManager.loggingServicesManager
+        deviceAlertManager = DeviceAlertManager(rootViewController: rootViewController,
+                                                isAppInBackgroundFunc: isInBackground)
+        deviceDataManager = DeviceDataManager(pluginManager: pluginManager, deviceAlertManager: deviceAlertManager)
+
+        SharedLogging.instance = deviceDataManager.loggingServicesManager
 
         NotificationManager.authorize(delegate: self)
 
         log.info(#function)
 
-        deviceManager.analyticsServicesManager.application(application, didFinishLaunchingWithOptions: launchOptions)
+        deviceDataManager.analyticsServicesManager.application(application, didFinishLaunchingWithOptions: launchOptions)
 
-        rootViewController.rootViewController.deviceManager = deviceManager
+        rootViewController.rootViewController.deviceManager = deviceDataManager
 
         let notificationOption = launchOptions?[.remoteNotification]
 
         if let notification = notificationOption as? [String: AnyObject] {
-            deviceManager.handleRemoteNotification(notification)
+            deviceDataManager.handleRemoteNotification(notification)
         }
-
+                
         return true
     }
 
@@ -57,7 +62,7 @@ final class AppDelegate: UIResponder, UIApplicationDelegate {
     }
 
     func applicationDidBecomeActive(_ application: UIApplication) {
-        deviceManager.updatePumpManagerBLEHeartbeatPreference()
+        deviceDataManager.updatePumpManagerBLEHeartbeatPreference()
     }
 
     func applicationWillTerminate(_ application: UIApplication) {
@@ -91,7 +96,7 @@ final class AppDelegate: UIResponder, UIApplicationDelegate {
         let tokenParts = deviceToken.map { data in String(format: "%02.2hhx", data) }
         let token = tokenParts.joined()
         log.default("RemoteNotifications device token: %{public}@", token)
-        deviceManager.loopManager.settings.deviceToken = deviceToken
+        deviceDataManager.loopManager.settings.deviceToken = deviceToken
     }
 
     func application(_ application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: Error) {
@@ -107,10 +112,13 @@ final class AppDelegate: UIResponder, UIApplicationDelegate {
             return
         }
 
-        deviceManager.handleRemoteNotification(notification)
+        deviceDataManager.handleRemoteNotification(notification)
         completionHandler(.noData)
     }
 
+    private func isInBackground() -> Bool {
+        return UIApplication.shared.applicationState == .background
+    }
 }
 
 
@@ -122,16 +130,19 @@ extension AppDelegate: UNUserNotificationCenterDelegate {
                 let startDate = response.notification.request.content.userInfo[LoopNotificationUserInfoKey.bolusStartDate.rawValue] as? Date,
                 startDate.timeIntervalSinceNow >= TimeInterval(minutes: -5)
             {
-                deviceManager.analyticsServicesManager.didRetryBolus()
+                deviceDataManager.analyticsServicesManager.didRetryBolus()
 
-                deviceManager.enactBolus(units: units, at: startDate) { (_) in
+                deviceDataManager.enactBolus(units: units, at: startDate) { (_) in
                     completionHandler()
                 }
                 return
             }
-        case NotificationManager.Action.acknowledgeCGMAlert.rawValue:
-            if let alertID = response.notification.request.content.userInfo[LoopNotificationUserInfoKey.cgmAlertID.rawValue] as? Int {
-                deviceManager.acknowledgeCGMAlert(alertID: alertID)
+        case NotificationManager.Action.acknowledgeAlert.rawValue:
+            let userInfo = response.notification.request.content.userInfo
+            if let alertTypeIdentifier = userInfo[LoopNotificationUserInfoKey.alertTypeId.rawValue] as? DeviceAlert.TypeIdentifier,
+                let managerIdentifier = userInfo[LoopNotificationUserInfoKey.managerIDForAlert.rawValue] as? String {
+                deviceAlertManager.acknowledgeDeviceAlert(identifier:
+                    DeviceAlert.Identifier(managerIdentifier: managerIdentifier, typeIdentifier: alertTypeIdentifier))
             }
         default:
             break

Loop/Managers/DeviceAlert/DeviceAlertManager.swift

@@ -0,0 +1,62 @@
+//
+//  DeviceAlertManager.swift
+//  Loop
+//
+//  Created by Rick Pasetto on 4/9/20.
+//  Copyright © 2020 LoopKit Authors. All rights reserved.
+//
+
+import LoopKit
+
+protocol DeviceAlertManagerResponder: class {
+    /// Method for our Handlers to call to kick off alert response.  Differs from DeviceAlertResponder because here we need the whole `Identifier`.
+    func acknowledgeDeviceAlert(identifier: DeviceAlert.Identifier)
+}
+
+/// Main (singleton-ish) class that is responsible for:
+/// - managing the different targets (handlers) that will post alerts
+/// - managing the different responders that might acknowledge the alert
+/// - serializing alerts to storage
+/// - etc.
+public final class DeviceAlertManager {
+
+    var handlers: [DeviceAlertHandler] = []
+    var responders: [String: Weak<DeviceAlertResponder>] = [:]
+    
+    public init(rootViewController: UIViewController,
+                isAppInBackgroundFunc: @escaping () -> Bool) {
+        handlers = [UserNotificationDeviceAlertHandler(isAppInBackgroundFunc: isAppInBackgroundFunc),
+                    InAppModalDeviceAlertHandler(rootViewController: rootViewController, deviceAlertManagerResponder: self)]
+    }
+    
+    public func addAlertResponder(key: String, alertResponder: DeviceAlertResponder) {
+        responders[key] = Weak(alertResponder)
+    }
+    
+    public func removeAlertResponder(key: String) {
+        responders.removeValue(forKey: key)
+    }
+}
+
+extension DeviceAlertManager: DeviceAlertManagerResponder {
+    func acknowledgeDeviceAlert(identifier: DeviceAlert.Identifier) {
+        if let responder = responders[identifier.managerIdentifier]?.value {
+            responder.acknowledgeAlert(typeIdentifier: identifier.typeIdentifier)
+        }
+    }
+}
+
+extension DeviceAlertManager: DeviceAlertHandler {
+
+    public func issueAlert(_ alert: DeviceAlert) {
+        handlers.forEach { $0.issueAlert(alert) }
+    }
+    public func removePendingAlert(identifier: DeviceAlert.Identifier) {
+        handlers.forEach { $0.removePendingAlert(identifier: identifier) }
+    }
+    public func removeDeliveredAlert(identifier: DeviceAlert.Identifier) {
+        handlers.forEach { $0.removeDeliveredAlert(identifier: identifier) }
+    }
+}
+
+

Loop/Managers/DeviceAlert/InAppModalDeviceAlertHandler.swift

@@ -0,0 +1,141 @@
+//
+//  InAppUserAlertHandler.swift
+//  LoopKit
+//
+//  Created by Rick Pasetto on 4/9/20.
+//  Copyright © 2020 LoopKit Authors. All rights reserved.
+//
+
+import Foundation
+import LoopKit
+
+public class InAppModalDeviceAlertHandler: DeviceAlertHandler {
+    
+    private weak var rootViewController: UIViewController?
+    private weak var deviceAlertManagerResponder: DeviceAlertManagerResponder?
+    
+    private var alertsShowing: [DeviceAlert.Identifier: (UIAlertController, DeviceAlert)] = [:]
+    private var alertsPending: [DeviceAlert.Identifier: (Timer, DeviceAlert)] = [:]
+    
+    init(rootViewController: UIViewController, deviceAlertManagerResponder: DeviceAlertManagerResponder) {
+        self.rootViewController = rootViewController
+        self.deviceAlertManagerResponder = deviceAlertManagerResponder
+    }
+        
+    public func issueAlert(_ alert: DeviceAlert) {
+        switch alert.trigger {
+        case .immediate:
+            show(alert: alert)
+        case .delayed(let interval):
+            schedule(alert: alert, interval: interval, repeats: false)
+        case .repeating(let interval):
+            schedule(alert: alert, interval: interval, repeats: true)
+        }
+    }
+    
+    public func removePendingAlert(identifier: DeviceAlert.Identifier) {
+        DispatchQueue.main.async {
+            self.alertsPending[identifier]?.0.invalidate()
+            self.clearPendingAlert(identifier: identifier)
+        }
+    }
+    
+    public func removeDeliveredAlert(identifier: DeviceAlert.Identifier) {
+        DispatchQueue.main.async {
+            self.alertsShowing[identifier]?.0.dismiss(animated: true)
+            self.clearDeliveredAlert(identifier: identifier)
+        }
+    }
+}
+
+/// Private functions
+extension InAppModalDeviceAlertHandler {
+        
+    private func schedule(alert: DeviceAlert, interval: TimeInterval, repeats: Bool) {
+        guard alert.foregroundContent != nil else {
+            return
+        }
+        DispatchQueue.main.async {
+            if self.isAlertPending(identifier: alert.identifier) {
+                return
+            }
+            let timer = Timer.scheduledTimer(withTimeInterval: interval, repeats: repeats) { [weak self] timer in
+                self?.show(alert: alert)
+                if !repeats {
+                    self?.clearPendingAlert(identifier: alert.identifier)
+                }
+            }
+            self.addPendingAlert(alert: alert, timer: timer)
+        }
+    }
+    
+    private func show(alert: DeviceAlert) {
+        guard let content = alert.foregroundContent else {
+            return
+        }
+        DispatchQueue.main.async {
+            if self.isAlertShowing(identifier: alert.identifier) {
+                return
+            }
+            let alertController = self.presentAlert(title: content.title, message: content.body, action: content.acknowledgeActionButtonLabel) { [weak self] in
+                self?.clearDeliveredAlert(identifier: alert.identifier)
+                self?.deviceAlertManagerResponder?.acknowledgeDeviceAlert(identifier: alert.identifier)
+            }
+            self.addDeliveredAlert(alert: alert, controller: alertController)
+        }
+    }
+    
+    private func addPendingAlert(alert: DeviceAlert, timer: Timer) {
+        dispatchPrecondition(condition: .onQueue(.main))
+        self.alertsPending[alert.identifier] = (timer, alert)
+    }
+
+    private func addDeliveredAlert(alert: DeviceAlert, controller: UIAlertController) {
+        dispatchPrecondition(condition: .onQueue(.main))
+        self.alertsShowing[alert.identifier] = (controller, alert)
+    }
+    
+    private func clearPendingAlert(identifier: DeviceAlert.Identifier) {
+        dispatchPrecondition(condition: .onQueue(.main))
+        alertsPending[identifier] = nil
+    }
+
+    private func clearDeliveredAlert(identifier: DeviceAlert.Identifier) {
+        dispatchPrecondition(condition: .onQueue(.main))
+        alertsShowing[identifier] = nil
+    }
+    
+    private func isAlertPending(identifier: DeviceAlert.Identifier) -> Bool {
+        dispatchPrecondition(condition: .onQueue(.main))
+        return alertsPending.index(forKey: identifier) != nil
+    }
+    
+    private func isAlertShowing(identifier: DeviceAlert.Identifier) -> Bool {
+        dispatchPrecondition(condition: .onQueue(.main))
+        return alertsShowing.index(forKey: identifier) != nil
+    }
+
+    private func presentAlert(title: String, message: String, action: String, completion: @escaping () -> Void) -> UIAlertController {
+        dispatchPrecondition(condition: .onQueue(.main))
+        // For now, this is a simple alert with an "OK" button
+        let alertController = UIAlertController(title: title, message: message, preferredStyle: .alert)
+        alertController.addAction(UIAlertAction(title: action, style: .default, handler: { _ in completion() }))
+        topViewController(controller: rootViewController)?.present(alertController, animated: true)
+        return alertController
+    }
+    
+    // Helper function pulled from SO...may be outdated, especially in the SwiftUI world
+    private func topViewController(controller: UIViewController?) -> UIViewController? {
+        if let tabController = controller as? UITabBarController {
+            return topViewController(controller: tabController.selectedViewController)
+        }
+        if let navController = controller as? UINavigationController {
+            return topViewController(controller: navController.visibleViewController)
+        }
+        if let presented = controller?.presentedViewController {
+            return topViewController(controller: presented)
+        }
+        return controller
+    }
+    
+}