Merge pull request #451 from tidepool-org/release/v1.1.0

Merge Release/v1.1.0 into dev

Author: nhamming

Loop/Managers/Alerts/InAppModalAlertIssuer.swift

@@ -14,7 +14,7 @@ public class InAppModalAlertIssuer: AlertIssuer {
     private weak var alertPresenter: AlertPresenter?
     private weak var alertManagerResponder: AlertManagerResponder?
 
-    private var alertsShowing: [Alert.Identifier: (UIAlertController, Alert)] = [:]
+    private var alertsPresented: [Alert.Identifier: (UIAlertController, Alert)] = [:]
     private var alertsPending: [Alert.Identifier: (Timer, Alert)] = [:]
 
     typealias ActionFactoryFunction = (String?, UIAlertAction.Style, ((UIAlertAction) -> Void)?) -> UIAlertAction
@@ -29,7 +29,8 @@ public class InAppModalAlertIssuer: AlertIssuer {
          alertManagerResponder: AlertManagerResponder,
          soundPlayer: AlertSoundPlayer = DeviceAVSoundPlayer(),
          newActionFunc: @escaping ActionFactoryFunction = UIAlertAction.init,
-         newTimerFunc: TimerFactoryFunction? = nil) {
+         newTimerFunc: TimerFactoryFunction? = nil)
+    {
         self.alertPresenter = alertPresenter
         self.alertManagerResponder = alertManagerResponder
         self.soundPlayer = soundPlayer
@@ -38,7 +39,7 @@ public class InAppModalAlertIssuer: AlertIssuer {
             return Timer.scheduledTimer(withTimeInterval: timeInterval, repeats: repeats) { _ in block?() }
         }
     }
-        
+
     public func issueAlert(_ alert: Alert) {
         switch alert.trigger {
         case .immediate:
@@ -52,21 +53,30 @@ public class InAppModalAlertIssuer: AlertIssuer {
 
     public func retractAlert(identifier: Alert.Identifier) {
         DispatchQueue.main.async {
-            self.alertsPending[identifier]?.0.invalidate()
-            self.clearPendingAlert(identifier: identifier)
-            self.removeDeliveredAlert(identifier: identifier, completion: nil)
+            self.removePendingAlert(identifier: identifier)
+            self.removePresentedAlert(identifier: identifier)
         }
     }
-        
-    func removeDeliveredAlert(identifier: Alert.Identifier, completion: (() -> Void)?) {
-        self.alertsShowing[identifier]?.0.dismiss(animated: true, completion: completion)
-        self.clearDeliveredAlert(identifier: identifier)
+
+    func removePresentedAlert(identifier: Alert.Identifier, completion: (() -> Void)? = nil) {
+        guard let alertPresented = alertsPresented[identifier] else {
+            completion?()
+            return
+        }
+        alertPresenter?.dismissAlert(alertPresented.0, animated: true, completion: completion)
+        clearPresentedAlert(identifier: identifier)
+    }
+
+    func removePendingAlert(identifier: Alert.Identifier) {
+        guard let alertPending = alertsPending[identifier] else { return }
+        alertPending.0.invalidate()
+        clearPendingAlert(identifier: identifier)
     }
 }
 
 /// Private functions
 extension InAppModalAlertIssuer {
-        
+
     private func schedule(alert: Alert, interval: TimeInterval, repeats: Bool) {
         guard alert.foregroundContent != nil else {
             return
@@ -90,59 +100,60 @@ extension InAppModalAlertIssuer {
             return
         }
         DispatchQueue.main.async {
-            if self.isAlertShowing(identifier: alert.identifier) {
+            if self.isAlertPresented(identifier: alert.identifier) {
                 return
             }
             let alertController = self.constructAlert(title: content.title,
                                                       message: content.body,
                                                       action: content.acknowledgeActionButtonLabel,
                                                       isCritical: content.isCritical) { [weak self] in
-                  self?.clearDeliveredAlert(identifier: alert.identifier)
-                  self?.alertManagerResponder?.acknowledgeAlert(identifier: alert.identifier)
+                // the completion is called after the alert is acknowledged
+                self?.clearPresentedAlert(identifier: alert.identifier)
+                self?.alertManagerResponder?.acknowledgeAlert(identifier: alert.identifier)
             }
             self.alertPresenter?.present(alertController, animated: true) { [weak self] in
-                // the completion is called after the alert is displayed
+                // the completion is called after the alert is presented
                 self?.playSound(for: alert)
-                self?.addDeliveredAlert(alert: alert, controller: alertController)
+                self?.addPresentedAlert(alert: alert, controller: alertController)
             }
         }
     }
 
     private func addPendingAlert(alert: Alert, timer: Timer) {
         dispatchPrecondition(condition: .onQueue(.main))
-        self.alertsPending[alert.identifier] = (timer, alert)
+        alertsPending[alert.identifier] = (timer, alert)
     }
 
-    private func addDeliveredAlert(alert: Alert, controller: UIAlertController) {
+    private func addPresentedAlert(alert: Alert, controller: UIAlertController) {
         dispatchPrecondition(condition: .onQueue(.main))
-        self.alertsShowing[alert.identifier] = (controller, alert)
+        alertsPresented[alert.identifier] = (controller, alert)
     }
 
     private func clearPendingAlert(identifier: Alert.Identifier) {
         dispatchPrecondition(condition: .onQueue(.main))
         alertsPending[identifier] = nil
     }
 
-    private func clearDeliveredAlert(identifier: Alert.Identifier) {
+    private func clearPresentedAlert(identifier: Alert.Identifier) {
         dispatchPrecondition(condition: .onQueue(.main))
-        alertsShowing[identifier] = nil
+        alertsPresented[identifier] = nil
     }
-    
+
     private func isAlertPending(identifier: Alert.Identifier) -> Bool {
         dispatchPrecondition(condition: .onQueue(.main))
         return alertsPending.index(forKey: identifier) != nil
     }
 
-    private func isAlertShowing(identifier: Alert.Identifier) -> Bool {
+    private func isAlertPresented(identifier: Alert.Identifier) -> Bool {
         dispatchPrecondition(condition: .onQueue(.main))
-        return alertsShowing.index(forKey: identifier) != nil
+        return alertsPresented.index(forKey: identifier) != nil
     }
 
-    private func constructAlert(title: String, message: String, action: String, isCritical: Bool, completion: @escaping () -> Void) -> UIAlertController {
+    private func constructAlert(title: String, message: String, action: String, isCritical: Bool, acknowledgeCompletion: @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(newActionFunc(action, .default, { _ in completion() }))
+        alertController.addAction(newActionFunc(action, .default, { _ in acknowledgeCompletion() }))
         return alertController
     }
 

Loop/Managers/DeliveryUncertaintyAlertManager.swift

@@ -39,7 +39,7 @@ class DeliveryUncertaintyAlertManager {
                 self.showUncertainDeliveryRecoveryView()
             }
             alert.addAction(action)
-            self.alertPresenter.dismiss(animated: false) {
+            self.alertPresenter.dismissTopMost(animated: false) {
                 self.alertPresenter.present(alert, animated: animated)
             }
             self.uncertainDeliveryAlert = alert

Loop/Managers/LoopAppManager.swift

@@ -26,12 +26,20 @@ public protocol AlertPresenter: AnyObject {
     /// - Parameters:
     ///   - animated: Animate the alert view controller dismissal or not.
     ///   - completion: Completion to call once view controller is dismissed.
-    func dismiss(animated: Bool, completion: (() -> Void)?)
+    func dismissTopMost(animated: Bool, completion: (() -> Void)?)
+
+    /// Dismiss an alert, even if it is not the top most alert.
+    /// - Parameters:
+    ///   - alertToDismiss: The alert to dismiss
+    ///   - animated: Animate the alert view controller dismissal or not.
+    ///   - completion: Completion to call once view controller is dismissed.
+    func dismissAlert(_ alertToDismiss: UIAlertController, animated: Bool, completion: (() -> Void)?)
 }
 
 public extension AlertPresenter {
     func present(_ viewController: UIViewController, animated: Bool) { present(viewController, animated: animated, completion: nil) }
-    func dismiss(animated: Bool) { dismiss(animated: animated, completion: nil) }
+    func dismissTopMost(animated: Bool) { dismissTopMost(animated: animated, completion: nil) }
+    func dismissAlert(_ alertToDismiss: UIAlertController, animated: Bool) { dismissAlert(alertToDismiss, animated: animated, completion: nil) }
 }
 
 protocol WindowProvider: AnyObject {
@@ -322,9 +330,56 @@ extension LoopAppManager: AlertPresenter {
         rootViewController?.topmostViewController.present(viewControllerToPresent, animated: animated, completion: completion)
     }
 
-    func dismiss(animated: Bool, completion: (() -> Void)?) {
+    func dismissTopMost(animated: Bool, completion: (() -> Void)?) {
         rootViewController?.topmostViewController.dismiss(animated: animated, completion: completion)
     }
+
+    func dismissAlert(_ alertToDismiss: UIAlertController, animated: Bool, completion: (() -> Void)?) {
+        if rootViewController?.topmostViewController == alertToDismiss {
+            dismissTopMost(animated: animated, completion: completion)
+        } else {
+            // check if the alert to dismiss is presenting another alert (and so on)
+            // calling dismiss() on an alert presenting another alert will only dismiss the presented alert
+            // (and any other alerts presented by the presented alert)
+
+            // get the stack of presented alerts that would be undesirably dismissed
+            var presentedAlerts: [UIAlertController] = []
+            var currentAlert = alertToDismiss
+            while let presentedAlert = currentAlert.presentedViewController as? UIAlertController {
+                presentedAlerts.append(presentedAlert)
+                currentAlert = presentedAlert
+            }
+
+            if presentedAlerts.isEmpty {
+                alertToDismiss.dismiss(animated: animated, completion: completion)
+            } else {
+                // Do not animate any of these view transitions, since the alert to dismiss is not at the top of the stack
+
+                // dismiss all the child presented alerts.
+                // Calling dismiss() on a VC that is presenting an other VC will dismiss the presented VC and all of its child presented VCs
+                alertToDismiss.dismiss(animated: false) {
+                    // dismiss the desired alert
+                    // Calling dismiss() on a VC that is NOT presenting any other VCs will dismiss said VC
+                    alertToDismiss.dismiss(animated: false) {
+                        // present the child alerts that were undesirably dismissed
+                        var orderedPresentationBlock: (() -> Void)? = nil
+                        for alert in presentedAlerts.reversed() {
+                            if alert == presentedAlerts.last {
+                                orderedPresentationBlock = {
+                                    self.present(alert, animated: false, completion: completion)
+                                }
+                            } else {
+                                orderedPresentationBlock = {
+                                    self.present(alert, animated: false, completion: orderedPresentationBlock)
+                                }
+                            }
+                        }
+                        orderedPresentationBlock?()
+                    }
+                }
+            }
+        }
+    }
 }
 
 // MARK: - DeviceOrientationController

Loop/Models/LoopConstants.swift

@@ -61,4 +61,9 @@ enum LoopConstants {
     static let missedMealWarningGlucoseRiseThreshold = 3.0 // mg/dL/m
     static let missedMealWarningGlucoseRecencyWindow = TimeInterval(minutes: 20)
     static let missedMealWarningVelocitySampleMinDuration = TimeInterval(minutes: 12)
+    
+    // Bolus calculator warning thresholds
+    static let simpleBolusCalculatorMinGlucoseBolusRecommendation = HKQuantity(unit: .milligramsPerDeciliter, doubleValue: 70)
+    static let simpleBolusCalculatorMinGlucoseMealBolusRecommendation = HKQuantity(unit: .milligramsPerDeciliter, doubleValue: 55)
+    static let simpleBolusCalculatorGlucoseWarningLimit = HKQuantity(unit: .milligramsPerDeciliter, doubleValue: 70)
 }

Loop/Models/SimpleBolusCalculator.swift

@@ -35,6 +35,12 @@ struct SimpleBolusCalculator {
                     recommendedBolus += correctionBolus
                 }
             }
+            
+            let recommendationLimit = mealCarbs != nil ? LoopConstants.simpleBolusCalculatorMinGlucoseMealBolusRecommendation : LoopConstants.simpleBolusCalculatorMinGlucoseBolusRecommendation
+            
+            if manualGlucose < recommendationLimit {
+                recommendedBolus = 0
+            }
         }
 
         // No negative recommendation

Loop/View Controllers/CarbAbsorptionViewController.swift

@@ -512,8 +512,8 @@ final class CarbAbsorptionViewController: LoopChartsTableViewController, Identif
             carbEntryViewController.preferredCarbUnit = deviceManager.carbStore.preferredUnit
             navigationWrapper = UINavigationController(rootViewController: carbEntryViewController)
         } else {
-            let viewModel = SimpleBolusViewModel(delegate: deviceManager)
-            let bolusEntryView = SimpleBolusView(displayMealEntry: true, viewModel: viewModel)
+            let viewModel = SimpleBolusViewModel(delegate: deviceManager, displayMealEntry: true)
+            let bolusEntryView = SimpleBolusView(viewModel: viewModel)
             let hostingController = DismissibleHostingController(rootView: bolusEntryView, isModalInPresentation: false)
             navigationWrapper = UINavigationController(rootViewController: hostingController)
             hostingController.navigationItem.leftBarButtonItem = UIBarButtonItem(barButtonSystemItem: .cancel, target: navigationWrapper, action: #selector(dismissWithAnimation))

Loop/View Controllers/StatusTableViewController.swift

@@ -1212,11 +1212,11 @@ final class StatusTableViewController: LoopChartsTableViewController {
             }
             navigationWrapper = UINavigationController(rootViewController: carbEntryViewController)
         } else {
-            let viewModel = SimpleBolusViewModel(delegate: deviceManager)
+            let viewModel = SimpleBolusViewModel(delegate: deviceManager, displayMealEntry: true)
             if let activity = activity {
                 viewModel.restoreUserActivityState(activity)
             }
-            let bolusEntryView = SimpleBolusView(displayMealEntry: true, viewModel: viewModel).environmentObject(deviceManager.displayGlucoseUnitObservable)
+            let bolusEntryView = SimpleBolusView(viewModel: viewModel).environmentObject(deviceManager.displayGlucoseUnitObservable)
             let hostingController = DismissibleHostingController(rootView: bolusEntryView, isModalInPresentation: false)
             navigationWrapper = UINavigationController(rootViewController: hostingController)
             hostingController.navigationItem.leftBarButtonItem = UIBarButtonItem(barButtonSystemItem: .cancel, target: navigationWrapper, action: #selector(dismissWithAnimation))
@@ -1235,8 +1235,8 @@ final class StatusTableViewController: LoopChartsTableViewController {
             let bolusEntryView = BolusEntryView(viewModel: viewModel).environmentObject(deviceManager.displayGlucoseUnitObservable)
             hostingController = DismissibleHostingController(rootView: bolusEntryView, isModalInPresentation: false)
         } else {
-            let viewModel = SimpleBolusViewModel(delegate: deviceManager)
-            let bolusEntryView = SimpleBolusView(displayMealEntry: false, viewModel: viewModel).environmentObject(deviceManager.displayGlucoseUnitObservable)
+            let viewModel = SimpleBolusViewModel(delegate: deviceManager, displayMealEntry: false)
+            let bolusEntryView = SimpleBolusView(viewModel: viewModel).environmentObject(deviceManager.displayGlucoseUnitObservable)
             hostingController = DismissibleHostingController(rootView: bolusEntryView, isModalInPresentation: false)
         }
         let navigationWrapper = UINavigationController(rootViewController: hostingController)