[LOOP-4289-4348] Critical alert modal and banner update (#525)

* initial pass at adding go to settings button in the critical alert modal

* remove foreground content from the riskMitigationAlert, since it is handle by the AlertManager

* added placeholder text for the alert premissions disabled banner

* add dismiss button to alert permissions disabled warning

* acknowledge alert with close option

* response to PR comments

* clean up

* more cleanup

* updated notification permissions banner

* updated style of alert permission disabled alert

* copy update

Author: nhamming

Loop/DefaultAssets.xcassets/Contents.json

@@ -1,6 +1,6 @@
 {
   "info" : {
-    "version" : 1,
-    "author" : "xcode"
+    "author" : "xcode",
+    "version" : 1
   }
-}
+}

Loop/DefaultAssets.xcassets/notification-permissions-on.imageset/Contents.json

@@ -0,0 +1,12 @@
+{
+  "images" : [
+    {
+      "filename" : "notification-permissions-on.png",
+      "idiom" : "universal"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

Loop/DefaultAssets.xcassets/notification-permissions-on.imageset/notification-permissions-on.png

@@ -11,26 +11,28 @@ import Combine
 import LoopKit
 import SwiftUI
 
+protocol AlertPermissionsCheckerDelegate: AnyObject {
+    func notificationsPermissions(requiresRiskMitigation: Bool, scheduledDeliveryEnabled: Bool)
+}
+
 public class AlertPermissionsChecker: ObservableObject {
 
-    private weak var alertManager: AlertManager?
-    
     private var isAppInBackground: Bool {
         return UIApplication.shared.applicationState == UIApplication.State.background
     }
-    
+
     private lazy var cancellables = Set<AnyCancellable>()
     private var listeningToNotificationCenter = false
 
     @Published var notificationCenterSettings: NotificationCenterSettingsFlags = .none
-    
+
     var showWarning: Bool {
         notificationCenterSettings.requiresRiskMitigation
     }
-    
-    init(alertManager: AlertManager? = nil) {
-        self.alertManager = alertManager
-        
+
+    weak var delegate: AlertPermissionsCheckerDelegate?
+
+    init() {
         // Check on loop complete, but only while in the background.
         NotificationCenter.default.publisher(for: .LoopCompleted)
             .receive(on: RunLoop.main)
@@ -41,7 +43,7 @@ public class AlertPermissionsChecker: ObservableObject {
                 }
             }
             .store(in: &cancellables)
-        
+
         NotificationCenter.default.publisher(for: UIApplication.willEnterForegroundNotification)
             .sink { [weak self] _ in
                 self?.check()
@@ -54,15 +56,15 @@ public class AlertPermissionsChecker: ObservableObject {
             }
             .store(in: &cancellables)
     }
- 
+
     func checkNow() {
         check {
             // Note: we do this, instead of calling notificationCenterSettingsChanged directly, so that we only
             // get called when it _changes_.
             self.listenToNotificationCenter()
         }
     }
-    
+
     private func check(then completion: (() -> Void)? = nil) {
         UNUserNotificationCenter.current().getNotificationSettings { settings in
             DispatchQueue.main.async {
@@ -81,13 +83,17 @@ public class AlertPermissionsChecker: ObservableObject {
         }
     }
 
-    func gotoSettings() {
-        UIApplication.shared.open(URL(string: UIApplication.openSettingsURLString)!)
+    static func gotoSettings() {
+        // TODO with iOS 16 this API changes to UIApplication.openNotificationSettingsURLString
+        if #available(iOS 15.4, *) {
+            UIApplication.shared.open(URL(string: UIApplicationOpenNotificationSettingsURLString)!)
+        } else {
+            UIApplication.shared.open(URL(string: UIApplication.openSettingsURLString)!)
+        }
     }
 }
 
-fileprivate extension AlertPermissionsChecker {
-
+extension AlertPermissionsChecker {
     private func listenToNotificationCenter() {
         if !listeningToNotificationCenter {
             $notificationCenterSettings
@@ -98,97 +104,81 @@ fileprivate extension AlertPermissionsChecker {
             listeningToNotificationCenter = true
         }
     }
-    
-    private func notificationCenterSettingsChanged(_ newValue: NotificationCenterSettingsFlags) {
-        if !issueOrRetract(alert: Self.riskMitigatingAlert,
-                           condition: newValue.requiresRiskMitigation,
-                           alreadyIssued: UserDefaults.standard.hasIssuedRiskMitigatingAlert,
-                           setAlreadyIssued: {UserDefaults.standard.hasIssuedRiskMitigatingAlert = $0}) {
-            _ = issueOrRetract(alert: Self.scheduledDeliveryEnabledAlert,
-                               condition: newValue.scheduledDeliveryEnabled,
-                               alreadyIssued: UserDefaults.standard.hasIssuedScheduledDeliveryEnabledAlert,
-                               setAlreadyIssued: {UserDefaults.standard.hasIssuedScheduledDeliveryEnabledAlert = $0})
-        }
-    }
-    
-    private func issueOrRetract(alert: LoopKit.Alert, condition: Bool, alreadyIssued: Bool, setAlreadyIssued: (Bool) -> Void) -> Bool {
-        if condition {
-            if !alreadyIssued {
-                alertManager?.issueAlert(alert)
-                setAlreadyIssued(true)
-            }
-            return true
-        } else {
-            if alreadyIssued {
-                setAlreadyIssued(false)
-                alertManager?.retractAlert(identifier: alert.identifier)
-            }
-            return false
-        }
-    }
-}
 
-fileprivate extension AlertPermissionsChecker {
-    
     // MARK: Risk Mitigating Alert
-    private static let riskMitigatingAlertIdentifier = Alert.Identifier(managerIdentifier: "LoopAppManager", alertIdentifier: "riskMitigatingAlert")
-    private static let riskMitigatingAlertContent = Alert.Content(
-        title: NSLocalizedString("Alert Permissions Need Attention",
+    static let unsafeNotificationPermissionsAlertIdentifier = Alert.Identifier(managerIdentifier: "LoopAppManager", alertIdentifier: "unsafeNotificationPermissionsAlert")
+
+    private static let unsafeNotificationPermissionsAlertContent = Alert.Content(
+        title: NSLocalizedString("Warning! Safety notifications are turned OFF",
                                  comment: "Alert Permissions Need Attention alert title"),
-        body: String(format: NSLocalizedString("It is important that you always keep %1$@ Notifications, Critical Alerts, and Time Sensitive Notifications turned ON in your phone’s settings to ensure that you get notified by the app.",
+        body: String(format: NSLocalizedString("You may not get sound, visual or vibration alerts regarding critical safety information.\n\nTo fix the issue, tap ‘Settings’ and make sure Notifications, Critical Alerts and Time Sensitive Notifications are turned ON.",
                                                comment: "Format for Notifications permissions disabled alert body. (1: app name)"),
                      Bundle.main.bundleDisplayName),
         acknowledgeActionButtonLabel: NSLocalizedString("OK", comment: "Notifications permissions disabled alert button")
     )
-    private static let riskMitigatingAlert = Alert(identifier: riskMitigatingAlertIdentifier,
-                                                   foregroundContent: riskMitigatingAlertContent,
-                                                   backgroundContent: riskMitigatingAlertContent,
-                                                   trigger: .immediate)
-    
+
+    static let unsafeNotificationPermissionsAlert = Alert(identifier: unsafeNotificationPermissionsAlertIdentifier,
+                                                          foregroundContent: nil,
+                                                          backgroundContent: unsafeNotificationPermissionsAlertContent,
+                                                          trigger: .immediate)
+
+    static func constructUnsafeNotificationPermissionsInAppAlert(acknowledgementCompletion: @escaping () -> Void ) -> UIAlertController {
+        dispatchPrecondition(condition: .onQueue(.main))
+        let alertController = UIAlertController(title: Self.unsafeNotificationPermissionsAlertContent.title,
+                                                message: Self.unsafeNotificationPermissionsAlertContent.body,
+                                                preferredStyle: .alert)
+        let titleImageAttachment = NSTextAttachment()
+        titleImageAttachment.image = UIImage(systemName: "exclamationmark.triangle.fill")?.withTintColor(.critical)
+        titleImageAttachment.bounds = CGRect(x: titleImageAttachment.bounds.origin.x, y: -10, width: 40, height: 35)
+        let titleWithImage = NSMutableAttributedString(attachment: titleImageAttachment)
+        titleWithImage.append(NSMutableAttributedString(string: "\n\n", attributes: [.font: UIFont.systemFont(ofSize: 8)]))
+        titleWithImage.append(NSMutableAttributedString(string: Self.unsafeNotificationPermissionsAlertContent.title, attributes: [.font: UIFont.preferredFont(forTextStyle: .headline)]))
+        alertController.setValue(titleWithImage, forKey: "attributedTitle")
+
+        let messageImageAttachment = NSTextAttachment()
+        messageImageAttachment.image = UIImage(named: "notification-permissions-on")
+        messageImageAttachment.bounds = CGRect(x: 0, y: -12, width: 228, height: 126)
+        let messageWithImageAttributed = NSMutableAttributedString(string: "\n", attributes: [.font: UIFont.systemFont(ofSize: 8)])
+        messageWithImageAttributed.append(NSMutableAttributedString(string: Self.unsafeNotificationPermissionsAlertContent.body, attributes: [.font: UIFont.preferredFont(forTextStyle: .footnote)]))
+        messageWithImageAttributed.append(NSMutableAttributedString(string: "\n\n", attributes: [.font: UIFont.systemFont(ofSize: 12)]))
+        messageWithImageAttributed.append(NSMutableAttributedString(attachment: messageImageAttachment))
+        alertController.setValue(messageWithImageAttributed, forKey: "attributedMessage")
+
+        alertController.addAction(UIAlertAction(title: NSLocalizedString("Settings", comment: "Label of button that navigation user to iOS Settings"),
+                                                style: .default,
+                                                handler: { _ in
+            AlertPermissionsChecker.gotoSettings()
+            acknowledgementCompletion()
+        }))
+        alertController.addAction(UIAlertAction(title: NSLocalizedString("Close", comment: "The button label of the action used to dismiss the risk mitigation alert"),
+                                                style: .cancel,
+                                                handler: { _ in acknowledgementCompletion()
+        }))
+        return alertController
+    }
+
     // MARK: Scheduled Delivery Enabled Alert
     private static let scheduledDeliveryEnabledAlertIdentifier = Alert.Identifier(managerIdentifier: "LoopAppManager",
                                                                                   alertIdentifier: "scheduledDeliveryEnabledAlert")
     private static let scheduledDeliveryEnabledAlertContent = Alert.Content(
         title: NSLocalizedString("Notifications Delayed",
                                  comment: "Scheduled Delivery Enabled alert title"),
         body: String(format: NSLocalizedString("""
-            Notification delivery is set to Scheduled Summary in your phone’s settings.
-            
-            To avoid delay in receiving notifications from %1$@, we recommend notification delivery be set to Immediate Delivery.
-            """,
+                Notification delivery is set to Scheduled Summary in your phone’s settings.
+
+                To avoid delay in receiving notifications from %1$@, we recommend notification delivery be set to Immediate Delivery.
+                """,
                                                comment: "Format for Critical Alerts permissions disabled alert body. (1: app name)"),
                      Bundle.main.bundleDisplayName),
         acknowledgeActionButtonLabel: NSLocalizedString("OK", comment: "Critical Alert permissions disabled alert button")
     )
-    private static let scheduledDeliveryEnabledAlert = Alert(identifier: scheduledDeliveryEnabledAlertIdentifier,
-                                                             foregroundContent: scheduledDeliveryEnabledAlertContent,
-                                                             backgroundContent: scheduledDeliveryEnabledAlertContent,
-                                                             trigger: .immediate)
-}
-
-fileprivate extension UserDefaults {
-    
-    private enum Key: String {
-        case hasIssuedRiskMitigatingAlert = "com.loopkit.Loop.HasIssuedRiskMitigatingAlert"
-        case hasIssuedScheduledDeliveryEnabledAlert = "com.loopkit.Loop.HasIssuedScheduledDeliveryEnabledAlert"
-    }
-    
-    var hasIssuedRiskMitigatingAlert: Bool {
-        get {
-            return object(forKey: Key.hasIssuedRiskMitigatingAlert.rawValue) as? Bool ?? false
-        }
-        set {
-            set(newValue, forKey: Key.hasIssuedRiskMitigatingAlert.rawValue)
-        }
-    }
+    static let scheduledDeliveryEnabledAlert = Alert(identifier: scheduledDeliveryEnabledAlertIdentifier,
+                                                     foregroundContent: scheduledDeliveryEnabledAlertContent,
+                                                     backgroundContent: scheduledDeliveryEnabledAlertContent,
+                                                     trigger: .immediate)
 
-    var hasIssuedScheduledDeliveryEnabledAlert: Bool {
-        get {
-            return object(forKey: Key.hasIssuedScheduledDeliveryEnabledAlert.rawValue) as? Bool ?? false
-        }
-        set {
-            set(newValue, forKey: Key.hasIssuedScheduledDeliveryEnabledAlert.rawValue)
-        }
+    private func notificationCenterSettingsChanged(_ newValue: NotificationCenterSettingsFlags) {
+        delegate?.notificationsPermissions(requiresRiskMitigation: newValue.requiresRiskMitigation, scheduledDeliveryEnabled: newValue.scheduledDeliveryEnabled)
     }
 }
 
@@ -251,4 +241,3 @@ fileprivate extension OptionSet {
         }
     }
 }
-

Loop/Managers/AlertPermissionsChecker.swift

@@ -82,7 +82,6 @@ public final class AlertManager {
                 self?.loopDidComplete()
             }
             .store(in: &cancellables)
-
     }
 
     public func addAlertResponder(managerIdentifier: String, alertResponder: AlertResponder) {
@@ -131,10 +130,10 @@ public final class AlertManager {
                                       body: fgBody,
                                       acknowledgeActionButtonLabel: NSLocalizedString("Dismiss", comment: "Default alert dismissal"))
         issueAlert(Alert(identifier: bluetoothPoweredOffIdentifier,
-                                       foregroundContent: fgcontent,
-                                       backgroundContent: bgcontent,
-                                       trigger: .immediate,
-                                       interruptionLevel: .critical))
+                         foregroundContent: fgcontent,
+                         backgroundContent: bgcontent,
+                         trigger: .immediate,
+                         interruptionLevel: .critical))
     }
 
     // MARK: - Loop Not Running alerts
@@ -584,3 +583,77 @@ extension AlertManager: PresetActivationObserver {
         }
     }
 }
+
+// MARK: - Issue/Retract Alert Permissions Warning
+extension AlertManager: AlertPermissionsCheckerDelegate {
+    func notificationsPermissions(requiresRiskMitigation: Bool, scheduledDeliveryEnabled: Bool) {
+        if !issueOrRetract(alert: AlertPermissionsChecker.unsafeNotificationPermissionsAlert,
+                           condition: requiresRiskMitigation,
+                           alreadyIssued: UserDefaults.standard.hasIssuedNotificationPermissionsAlert,
+                           setAlreadyIssued: { UserDefaults.standard.hasIssuedNotificationPermissionsAlert = $0 },
+                           issueHandler: { alert in
+            // the risk mitigation in-app alert is presented with a button to navigate to settings
+            self.recordIssued(alert: alert)
+            let alertController = AlertPermissionsChecker.constructUnsafeNotificationPermissionsInAppAlert() { [weak self] in
+                self?.acknowledgeAlert(identifier: AlertPermissionsChecker.unsafeNotificationPermissionsAlertIdentifier)
+            }
+            self.alertPresenter.present(alertController, animated: true)
+        }) {
+            _ = issueOrRetract(alert: AlertPermissionsChecker.scheduledDeliveryEnabledAlert,
+                               condition: scheduledDeliveryEnabled,
+                               alreadyIssued: UserDefaults.standard.hasIssuedScheduledDeliveryEnabledAlert,
+                               setAlreadyIssued: { UserDefaults.standard.hasIssuedScheduledDeliveryEnabledAlert = $0 }, issueHandler: { alert in self.issueAlert(alert) })
+        }
+    }
+
+    private func issueOrRetract(alert: LoopKit.Alert,
+                                condition: Bool,
+                                alreadyIssued: Bool,
+                                setAlreadyIssued: (Bool) -> Void,
+                                issueHandler: @escaping (LoopKit.Alert) -> Void) -> Bool {
+        if condition {
+            if !alreadyIssued {
+                issueHandler(alert)
+                setAlreadyIssued(true)
+            }
+            return true
+        } else {
+            if alreadyIssued {
+                setAlreadyIssued(false)
+                retractAlert(identifier: alert.identifier)
+            }
+            return false
+        }
+    }
+}
+
+fileprivate extension AlertManager {
+    private var isAppInBackground: Bool {
+        return UIApplication.shared.applicationState == UIApplication.State.background
+    }
+}
+
+fileprivate extension UserDefaults {
+    private enum Key: String {
+        case hasIssuedNotificationPermissionsAlert = "com.loopkit.Loop.HasIssuedNotificationPermissionsAlert"
+        case hasIssuedScheduledDeliveryEnabledAlert = "com.loopkit.Loop.HasIssuedScheduledDeliveryEnabledAlert"
+    }
+
+    var hasIssuedNotificationPermissionsAlert: Bool {
+        get {
+            return object(forKey: Key.hasIssuedNotificationPermissionsAlert.rawValue) as? Bool ?? false
+        }
+        set {
+            set(newValue, forKey: Key.hasIssuedNotificationPermissionsAlert.rawValue)
+        }
+    }
+
+    var hasIssuedScheduledDeliveryEnabledAlert: Bool {
+        get {
+            return object(forKey: Key.hasIssuedScheduledDeliveryEnabledAlert.rawValue) as? Bool ?? false
+        }
+        set {
+            set(newValue, forKey: Key.hasIssuedScheduledDeliveryEnabledAlert.rawValue)
+        }
+    }
+}

Loop/Managers/Alerts/AlertManager.swift

@@ -160,7 +160,9 @@ class LoopAppManager: NSObject {
                                          expireAfter: Bundle.main.localCacheDuration,
                                          bluetoothProvider: bluetoothStateManager)
 
-        self.alertPermissionsChecker = AlertPermissionsChecker(alertManager: alertManager)
+        self.alertPermissionsChecker = AlertPermissionsChecker()
+        self.alertPermissionsChecker.delegate = alertManager
+        
         self.trustedTimeChecker = TrustedTimeChecker(alertManager: alertManager)
 
         self.settingsManager = SettingsManager(cacheStore: cacheStore,