LOOP-1167: play back delivered and pending alerts on re-launch (#77)

* checkpoint

* checkpoint: seems to be working!

* Unit tests

Author: rickpasetto

Loop/Managers/DeviceAlert/DeviceAlertManager.swift

@@ -13,6 +13,19 @@ protocol DeviceAlertManagerResponder: class {
     func acknowledgeDeviceAlert(identifier: DeviceAlert.Identifier)
 }
 
+public protocol UserNotificationCenter {
+    func add(_ request: UNNotificationRequest, withCompletionHandler: ((Error?) -> Void)?)
+    func removePendingNotificationRequests(withIdentifiers: [String])
+    func removeDeliveredNotifications(withIdentifiers: [String])
+    func getDeliveredNotifications(completionHandler: @escaping ([UNNotification]) -> Void)
+    func getPendingNotificationRequests(completionHandler: @escaping ([UNNotificationRequest]) -> Void)
+}
+extension UNUserNotificationCenter: UserNotificationCenter {}
+
+public enum DeviceAlertUserNotificationUserInfoKey: String {
+    case deviceAlert, deviceAlertTimestamp
+}
+
 /// 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
@@ -21,17 +34,28 @@ protocol DeviceAlertManagerResponder: class {
 public final class DeviceAlertManager {
     static let soundsDirectoryURL = FileManager.default.urls(for: .libraryDirectory, in: .userDomainMask).last!.appendingPathComponent("Sounds")
 
+    static let timestampFormatter = ISO8601DateFormatter()
+    
     private let log = DiagnosticLog(category: "DeviceAlertManager")
 
     var handlers: [DeviceAlertPresenter] = []
     var responders: [String: Weak<DeviceAlertResponder>] = [:]
     var soundVendors: [String: Weak<DeviceAlertSoundVendor>] = [:]
+    
+    let userNotificationCenter: UserNotificationCenter
+    let fileManager: FileManager
 
     public init(rootViewController: UIViewController,
-                handlers: [DeviceAlertPresenter]? = nil) {
+                handlers: [DeviceAlertPresenter]? = nil,
+                userNotificationCenter: UserNotificationCenter = UNUserNotificationCenter.current(),
+                fileManager: FileManager = FileManager.default) {
+        self.userNotificationCenter = userNotificationCenter
+        self.fileManager = fileManager
         self.handlers = handlers ??
-            [UserNotificationDeviceAlertPresenter(),
+            [UserNotificationDeviceAlertPresenter(userNotificationCenter: userNotificationCenter),
             InAppModalDeviceAlertPresenter(rootViewController: rootViewController, deviceAlertManagerResponder: self)]
+            
+        playbackPersistedAlerts()
     }
 
     public func addAlertResponder(managerIdentifier: String, alertResponder: DeviceAlertResponder) {
@@ -57,6 +81,10 @@ extension DeviceAlertManager: DeviceAlertManagerResponder {
         if let responder = responders[identifier.managerIdentifier]?.value {
             responder.acknowledgeAlert(alertIdentifier: identifier.alertIdentifier)
         }
+        // Also clear the alert from the NotificationCenter
+        log.debug("Removing notification %@ from delivered & pending notifications", identifier.value)
+        userNotificationCenter.removeDeliveredNotifications(withIdentifiers: [identifier.value])
+        userNotificationCenter.removePendingNotificationRequests(withIdentifiers: [identifier.value])
     }
 }
 
@@ -93,8 +121,7 @@ extension DeviceAlertManager {
             return
         }
         do {
-            let fileManager = FileManager.default
-            try fileManager.createDirectory(atPath: DeviceAlertManager.soundsDirectoryURL.path, withIntermediateDirectories: true, attributes: nil)
+            try fileManager.createDirectory(at: DeviceAlertManager.soundsDirectoryURL, withIntermediateDirectories: true, attributes: nil)
             for sound in sounds {
                 if let fromFilename = sound.filename,
                     let toURL = DeviceAlertManager.soundURL(managerIdentifier: managerIdentifier, sound: sound) {
@@ -112,8 +139,8 @@ extension FileManager {
     func copyIfNewer(from fromURL: URL, to toURL: URL) throws {
         if fileExists(atPath: toURL.path) {
             // If the source file is newer, remove the old one, otherwise skip it.
-            let toCreationDate = try toURL.fileCreationDate()
-            let fromCreationDate = try fromURL.fileCreationDate()
+            let toCreationDate = try toURL.fileCreationDate(self)
+            let fromCreationDate = try fromURL.fileCreationDate(self)
             if fromCreationDate > toCreationDate {
                 try removeItem(at: toURL)
             } else {
@@ -126,7 +153,159 @@ extension FileManager {
 
 extension URL {
 
-    func fileCreationDate() throws -> Date {
-        return try FileManager.default.attributesOfItem(atPath: self.path)[.creationDate] as! Date
+    func fileCreationDate(_ fileManager: FileManager) throws -> Date {
+        return try fileManager.attributesOfItem(atPath: self.path)[.creationDate] as! Date
+    }
+}
+
+
+extension DeviceAlertManager {
+    
+    private func playbackPersistedAlerts() {
+    
+        userNotificationCenter.getDeliveredNotifications {
+            $0.forEach { notification in
+                self.log.debug("Delivered alert: %@", "\(notification)")
+                self.playbackDeliveredNotification(notification)
+            }
+        }
+        
+        userNotificationCenter.getPendingNotificationRequests {
+            $0.forEach { request in
+                self.log.debug("Pending alert: %@", "\(request)")
+                self.playbackPendingNotificationRequest(request)
+            }
+        }
+    }
+
+    private func playbackDeliveredNotification(_ notification: UNNotification) {
+        // Assume if it was delivered, the trigger should be .immediate.
+        playbackAnyNotificationRequest(notification.request, usingTrigger: .immediate)
+    }
+
+    private func playbackPendingNotificationRequest(_ request: UNNotificationRequest) {
+        playbackAnyNotificationRequest(request)
+    }
+    
+    private func playbackAnyNotificationRequest(_ request: UNNotificationRequest, usingTrigger trigger: DeviceAlert.Trigger? = nil) {
+        guard let savedAlertString = request.content.userInfo[DeviceAlertUserNotificationUserInfoKey.deviceAlert.rawValue] as? String,
+            let savedAlertTimestampString = request.content.userInfo[DeviceAlertUserNotificationUserInfoKey.deviceAlertTimestamp.rawValue] as? String,
+            let savedAlertTimestamp = DeviceAlertManager.timestampFormatter.date(from: savedAlertTimestampString) else  {
+            self.log.error("Could not find persistent alert in notification")
+            return
+        }
+        do {
+            let savedAlert = try DeviceAlert.decode(from: savedAlertString)
+            let newTrigger = trigger ?? determineNewTrigger(from: savedAlert, timestamp: savedAlertTimestamp)
+            let newAlert = DeviceAlert(identifier: savedAlert.identifier,
+                                       foregroundContent: savedAlert.foregroundContent,
+                                       backgroundContent: savedAlert.backgroundContent,
+                                       trigger: newTrigger,
+                                       sound: savedAlert.sound)
+            self.log.debug("Replaying %@Alert: %@ with %@trigger %@",
+                           trigger != nil ? "" : "Pending ",
+                           trigger != nil ? "" : "new ",
+                           savedAlertString, "\(newTrigger)")
+            self.issueAlert(newAlert)
+        } catch {
+            self.log.error("Could not decode alert: error %@, from %@", error.localizedDescription, savedAlertString)
+        }
+    }
+    
+    private func determineNewTrigger(from alert: DeviceAlert, timestamp: Date) -> DeviceAlert.Trigger {
+        switch alert.trigger {
+        case .immediate:
+            return alert.trigger
+        case .delayed(let interval):
+            let triggerTime = timestamp.addingTimeInterval(interval)
+            let timeIntervalSinceNow = triggerTime.timeIntervalSinceNow
+            if timeIntervalSinceNow < 0 {
+                // Trigger time has passed...trigger immediately
+                return .immediate
+            } else {
+                return .delayed(interval: timeIntervalSinceNow)
+            }
+        case .repeating:
+            // Strange case here: if it is a repeating trigger, we can't really play back exactly
+            // at the right "remaining time" and then repeat at the original period.  So, I think
+            // the best we can do is just use the original trigger
+            return alert.trigger
+        }
+    }
+
+}
+
+public extension DeviceAlert {
+    
+    enum Error: String, Swift.Error {
+        case noBackgroundContent
+    }
+        
+    fileprivate func getUserNotificationContent(timestamp: Date) throws -> UNNotificationContent {
+        guard let content = backgroundContent else {
+            throw Error.noBackgroundContent
+        }
+        let userNotificationContent = UNMutableNotificationContent()
+        userNotificationContent.title = content.title
+        userNotificationContent.body = content.body
+        userNotificationContent.sound = getUserNotificationSound()
+        // TODO: Once we have a final design and approval for custom UserNotification buttons, we'll need to set categoryIdentifier
+//        userNotificationContent.categoryIdentifier = LoopNotificationCategory.alert.rawValue
+        userNotificationContent.threadIdentifier = identifier.value // Used to match categoryIdentifier, but I /think/ we want multiple threads for multiple alert types, no?
+        userNotificationContent.userInfo = [
+            LoopNotificationUserInfoKey.managerIDForAlert.rawValue: identifier.managerIdentifier,
+            LoopNotificationUserInfoKey.alertTypeID.rawValue: identifier.alertIdentifier,
+        ]
+        let encodedAlert = try encodeToString()
+        userNotificationContent.userInfo[DeviceAlertUserNotificationUserInfoKey.deviceAlert.rawValue] = encodedAlert
+        userNotificationContent.userInfo[DeviceAlertUserNotificationUserInfoKey.deviceAlertTimestamp.rawValue] =
+            DeviceAlertManager.timestampFormatter.string(from: timestamp)
+        print("Alert: \(encodedAlert)")
+        return userNotificationContent
+    }
+    
+    private func getUserNotificationSound() -> UNNotificationSound? {
+        guard let content = backgroundContent else {
+            return nil
+        }
+        if let sound = sound {
+            switch sound {
+            case .vibrate:
+                // TODO: Not sure how to "force" UNNotificationSound to "vibrate only"...so for now we just do the default
+                break
+            case .silence:
+                // TODO: Not sure how to "force" UNNotificationSound to "silence"...so for now we just do the default
+                break
+            default:
+                if let actualFileName = DeviceAlertManager.soundURL(for: self)?.lastPathComponent {
+                    let unname = UNNotificationSoundName(rawValue: actualFileName)
+                    return content.isCritical ? UNNotificationSound.criticalSoundNamed(unname) : UNNotificationSound(named: unname)
+                }
+            }
+        }
+        
+        return content.isCritical ? .defaultCritical : .default
+    }
+}
+
+public extension UNNotificationRequest {
+    convenience init(from deviceAlert: DeviceAlert, timestamp: Date) throws {
+        let uncontent = try deviceAlert.getUserNotificationContent(timestamp: timestamp)
+        self.init(identifier: deviceAlert.identifier.value,
+                  content: uncontent,
+                  trigger: UNTimeIntervalNotificationTrigger(from: deviceAlert.trigger))
+    }
+}
+
+fileprivate extension UNTimeIntervalNotificationTrigger {
+    convenience init?(from deviceAlertTrigger: DeviceAlert.Trigger) {
+        switch deviceAlertTrigger {
+        case .immediate:
+            return nil
+        case .delayed(let timeInterval):
+            self.init(timeInterval: timeInterval, repeats: false)
+        case .repeating(let repeatInterval):
+            self.init(timeInterval: repeatInterval, repeats: true)
+        }
     }
 }

Loop/Managers/DeviceAlert/UserNotificationDeviceAlertPresenter.swift

@@ -7,34 +7,32 @@
 //
 
 import LoopKit
-import UserNotifications
-
-protocol UserNotificationCenter {
-    func add(_ request: UNNotificationRequest, withCompletionHandler: ((Error?) -> Void)?)
-    func removePendingNotificationRequests(withIdentifiers: [String])
-    func removeDeliveredNotifications(withIdentifiers: [String])
-}
-
-extension UNUserNotificationCenter: UserNotificationCenter {}
 
 class UserNotificationDeviceAlertPresenter: DeviceAlertPresenter {
 
     let userNotificationCenter: UserNotificationCenter
     let log = DiagnosticLog(category: "UserNotificationDeviceAlertPresenter")
 
-    init(userNotificationCenter: UserNotificationCenter = UNUserNotificationCenter.current()) {
+    init(userNotificationCenter: UserNotificationCenter) {
         self.userNotificationCenter = userNotificationCenter
     }
-        
+    
     func issueAlert(_ alert: DeviceAlert) {
+        issueAlert(alert, timestamp: Date())
+    }
+
+    func issueAlert(_ alert: DeviceAlert, timestamp: Date) {
         DispatchQueue.main.async {
-            if let request = alert.asUserNotificationRequest() {
+            do {
+                let request = try UNNotificationRequest(from: alert, timestamp: timestamp)
                 self.userNotificationCenter.add(request) { error in
                     if let error = error {
                         self.log.error("Something went wrong posting the user notification: %@", error.localizedDescription)
                     }
                 }
                 // For now, UserNotifications do not not acknowledge...not yet at least
+            } catch {
+                self.log.error("Error issuing alert: %@", error.localizedDescription)
             }
         }
     }
@@ -51,69 +49,3 @@ class UserNotificationDeviceAlertPresenter: DeviceAlertPresenter {
         }
     }
 }
-
-public extension DeviceAlert {
-    
-    fileprivate func asUserNotificationRequest() -> UNNotificationRequest? {
-        guard let uncontent = getUserNotificationContent() else {
-            return nil
-        }
-        return UNNotificationRequest(identifier: identifier.value,
-                                     content: uncontent,
-                                     trigger: trigger.asUserNotificationTrigger())
-    }
-    
-    private func getUserNotificationContent() -> UNNotificationContent? {
-        guard let content = backgroundContent else {
-            return nil
-        }
-        let userNotificationContent = UNMutableNotificationContent()
-        userNotificationContent.title = content.title
-        userNotificationContent.body = content.body
-        userNotificationContent.sound = getUserNotificationSound()
-        // TODO: Once we have a final design and approval for custom UserNotification buttons, we'll need to set categoryIdentifier
-//        userNotificationContent.categoryIdentifier = LoopNotificationCategory.alert.rawValue
-        userNotificationContent.threadIdentifier = identifier.value // Used to match categoryIdentifier, but I /think/ we want multiple threads for multiple alert types, no?
-        userNotificationContent.userInfo = [
-            LoopNotificationUserInfoKey.managerIDForAlert.rawValue: identifier.managerIdentifier,
-            LoopNotificationUserInfoKey.alertTypeID.rawValue: identifier.alertIdentifier
-        ]
-        return userNotificationContent
-    }
-    
-    private func getUserNotificationSound() -> UNNotificationSound? {
-        guard let content = backgroundContent else {
-            return nil
-        }
-        if let sound = sound {
-            switch sound {
-            case .vibrate:
-                // TODO: Not sure how to "force" UNNotificationSound to "vibrate only"...so for now we just do the default
-                break
-            case .silence:
-                // TODO: Not sure how to "force" UNNotificationSound to "silence"...so for now we just do the default
-                break
-            default:
-                if let actualFileName = DeviceAlertManager.soundURL(for: self)?.lastPathComponent {
-                    let unname = UNNotificationSoundName(rawValue: actualFileName)
-                    return content.isCritical ? UNNotificationSound.criticalSoundNamed(unname) : UNNotificationSound(named: unname)
-                }
-            }
-        }
-        
-        return content.isCritical ? .defaultCritical : .default
-    }
-}
-
-public extension DeviceAlert.Trigger {
-    func asUserNotificationTrigger() -> UNNotificationTrigger? {
-        switch self {
-        case .immediate:
-            return nil
-        case .delayed(let timeInterval):
-            return UNTimeIntervalNotificationTrigger(timeInterval: timeInterval, repeats: false)
-        case .repeating(let repeatInterval):
-            return UNTimeIntervalNotificationTrigger(timeInterval: repeatInterval, repeats: true)
-        }
-    }
-}