Add missed meal notifications to Loop (#1825)

* Add unannounced meal func to CarbStoreProtocol

* V1 of UAM algo

* Add debug logs

* Handle unannounced meal notification & open up controller

* Add mealstart to notification userinfo

* Improve notification description

* Add direct entry to carb flow from notification on watch

* Add auto-setting of carb entry on watch

* carbThreshold -> mealCarbThreshold

* Retract UAM notifications after the carbs have expired

* Improve function naming

* Move notification logic from LoopKit to Loop

* Make current date configurable

* Make current date configurable during unit testing

* Update status enum naming for point-of-use clarity

* Make 'now' time configurable

* Extract loop data manager testing logic into base class

* Extract loop data manager dosing tests into their own file

* Add unannounced meal tests

* Fix concurrency issue

* Pull UAM constants into separate struct

* Fix notifications not being retracted after their expiration date

* Expire using start of meal instead of current time

* Add unannounced meal notifications permission

* Add AlertPermissionsViewModel

* Remove unneeded `AnyView`s

* Removed unused completion block

* Use the counteraction effects passed into the function

* Schedule missed meal notifications to avoid notification during an microbolus (#3)

* Delay missed meal notification if possible to avoid delivering it during an autobolus

* Add tests for notification delay

* Update `estimatedDuration` function headers in response to PR feedback

* Add UAM banner to carb entry screen (#5)

* Add warning banner to remind the user to edit the meal estimate

* Update warning text

* UAM algo updates: only use directly observed carb absorption (#6)

* Add ability to calculate the number of carbs in a missed meal (#4)

* Plumb a customizable carb amount through UAM notification architecture

* Fix merge conflict

* Update tests for changes from the merge

* Make UAM notifications unit testable

* Add carb autofill clamping based on the user's carb threshold & max bolus

* Update target order to group extensions together

* Improve issue report description

* Create `MealDetectionManager` from old UAM functions in `CarbStore`

* Move notification logic into `MealDetectionManager`

* Updates based on feedback for UAM PR (#7)

* Create `MealDetectionManager` from old UAM functions in `CarbStore`

* Move notification logic into `MealDetectionManager`

* Move UAM test fixtures from LoopKit to Loop

* Remove old TODO

* Revert change to Loop signing team

* Fix merge issues

* Make tests runnable

* Lower meal carb threshold to 15 g to reduce false-negatives

* Fix carb entry controller merge issues

* Unannounced meal / UAM -> missed meal

* UAM test fixture -> missed meal test fixture

* Variable naming improvements

* Remove `AlertPermissionsViewModel`

* Move call to check for missed meals to `loop()`-level

* Remove `CarbStore` dependency from `MealDetectionManager`

These changes also remove the requirement that there be no carbs entered after the missed meal was detected - since we're now observing direct absorption, I didn't think this requirement made sense anymore

* Reduce `minRecency` required to detect a meal

* Update counteraction effect math in `MealDetectionManager` to skew towards an earlier meal time instead of a later one

* Fix conflict + move missed meal toggle 1 level higher

Author: novalegra

Loop.xcodeproj/project.pbxproj

@@ -1307,6 +1307,10 @@ extension DeviceDataManager: LoopDataManagerDelegate {
 
         return rounded
     }
+    
+    func loopDataManager(_ manager: LoopDataManager, estimateBolusDuration units: Double) -> TimeInterval? {
+        pumpManager?.estimatedDuration(toBolus: units)
+    }
 
     func loopDataManager(
         _ manager: LoopDataManager,

Loop/Managers/DeviceDataManager.swift

@@ -484,7 +484,8 @@ extension LoopAppManager: UNUserNotificationCenterDelegate {
              LoopNotificationCategory.remoteBolus.rawValue,
              LoopNotificationCategory.remoteBolusFailure.rawValue,
              LoopNotificationCategory.remoteCarbs.rawValue,
-             LoopNotificationCategory.remoteCarbsFailure.rawValue:
+             LoopNotificationCategory.remoteCarbsFailure.rawValue,
+             LoopNotificationCategory.missedMeal.rawValue:
             completionHandler([.badge, .sound, .list, .banner])
         default:
             // For all others, banners are not to be displayed while in the foreground
@@ -516,6 +517,28 @@ extension LoopAppManager: UNUserNotificationCenterDelegate {
                let managerIdentifier = userInfo[LoopNotificationUserInfoKey.managerIDForAlert.rawValue] as? String {
                 alertManager?.acknowledgeAlert(identifier: Alert.Identifier(managerIdentifier: managerIdentifier, alertIdentifier: alertIdentifier))
             }
+        case UNNotificationDefaultActionIdentifier:
+            guard response.notification.request.identifier == LoopNotificationCategory.missedMeal.rawValue else {
+                break
+            }
+
+            let carbActivity = NSUserActivity.forNewCarbEntry()
+            let userInfo = response.notification.request.content.userInfo
+            
+            if
+                let mealTime = userInfo[LoopNotificationUserInfoKey.missedMealTime.rawValue] as? Date,
+                let carbAmount = userInfo[LoopNotificationUserInfoKey.missedMealCarbAmount.rawValue] as? Double
+            {
+                let missedEntry = NewCarbEntry(quantity: HKQuantity(unit: .gram(),
+                                                                         doubleValue: carbAmount),
+                                                    startDate: mealTime,
+                                                    foodType: nil,
+                                                    absorptionTime: nil)
+                carbActivity.update(from: missedEntry, isMissedMeal: true)
+            }
+            
+            rootViewController?.restoreUserActivityState(carbActivity)
+            
         default:
             break
         }

Loop/Managers/LoopAppManager.swift

@@ -30,6 +30,8 @@ final class LoopDataManager {
     static let LoopUpdateContextKey = "com.loudnate.Loop.LoopDataManager.LoopUpdateContext"
 
     private let carbStore: CarbStoreProtocol
+    
+    private let mealDetectionManager: MealDetectionManager
 
     private let doseStore: DoseStoreProtocol
 
@@ -109,6 +111,11 @@ final class LoopDataManager {
         self.now = now
 
         self.latestStoredSettingsProvider = latestStoredSettingsProvider
+        self.mealDetectionManager = MealDetectionManager(
+            carbRatioScheduleApplyingOverrideHistory: carbStore.carbRatioScheduleApplyingOverrideHistory,
+            insulinSensitivityScheduleApplyingOverrideHistory: carbStore.insulinSensitivityScheduleApplyingOverrideHistory,
+            maximumBolus: settings.maximumBolus
+        )
 
         self.lockedPumpInsulinType = Locked(pumpInsulinType)
 
@@ -259,11 +266,16 @@ final class LoopDataManager {
 
             // Invalidate cached effects affected by the override
             invalidateCachedEffects = true
+            
+            // Update the affected schedules
+            mealDetectionManager.carbRatioScheduleApplyingOverrideHistory = carbRatioScheduleApplyingOverrideHistory
+            mealDetectionManager.insulinSensitivityScheduleApplyingOverrideHistory = insulinSensitivityScheduleApplyingOverrideHistory
         }
 
         if newValue.insulinSensitivitySchedule != oldValue.insulinSensitivitySchedule {
             carbStore.insulinSensitivitySchedule = newValue.insulinSensitivitySchedule
             doseStore.insulinSensitivitySchedule = newValue.insulinSensitivitySchedule
+            mealDetectionManager.insulinSensitivityScheduleApplyingOverrideHistory = insulinSensitivityScheduleApplyingOverrideHistory
             invalidateCachedEffects = true
             analyticsServicesManager.didChangeInsulinSensitivitySchedule()
         }
@@ -278,6 +290,7 @@ final class LoopDataManager {
 
         if newValue.carbRatioSchedule != oldValue.carbRatioSchedule {
             carbStore.carbRatioSchedule = newValue.carbRatioSchedule
+            mealDetectionManager.carbRatioScheduleApplyingOverrideHistory = carbRatioScheduleApplyingOverrideHistory
             invalidateCachedEffects = true
             analyticsServicesManager.didChangeCarbRatioSchedule()
         }
@@ -292,6 +305,10 @@ final class LoopDataManager {
             analyticsServicesManager.didChangeInsulinModel()
         }
 
+        if newValue.maximumBolus != oldValue.maximumBolus {
+            mealDetectionManager.maximumBolus = newValue.maximumBolus
+        }
+
         if invalidateCachedEffects {
             dataAccessQueue.async {
                 // Invalidate cached effects based on this schedule
@@ -857,6 +874,28 @@ extension LoopDataManager {
         logger.default("Loop ended")
         notify(forChange: .loopFinished)
 
+        let carbEffectStart = now().addingTimeInterval(-MissedMealSettings.maxRecency)
+        carbStore.getGlucoseEffects(start: carbEffectStart, end: now(), effectVelocities: insulinCounteractionEffects) {[weak self] result in
+            guard
+                let self = self,
+                case .success((_, let carbEffects)) = result
+            else {
+                if case .failure(let error) = result {
+                    self?.logger.error("Failed to fetch glucose effects to check for missed meal: %{public}@", String(describing: error))
+                }
+                return
+            }
+            
+            self.mealDetectionManager.generateMissedMealNotificationIfNeeded(
+                insulinCounteractionEffects: self.insulinCounteractionEffects,
+                carbEffects: carbEffects,
+                pendingAutobolusUnits: self.recommendedAutomaticDose?.recommendation.bolusUnits,
+                bolusDurationEstimator: { [unowned self] bolusAmount in
+                    return self.delegate?.loopDataManager(self, estimateBolusDuration: bolusAmount)
+                }
+            )
+        }
+
         // 5 second delay to allow stores to cache data before it is read by widget
         DispatchQueue.main.asyncAfter(deadline: .now() + 5) {
             self.widgetLog.default("Refreshing widget. Reason: Loop completed")
@@ -1764,7 +1803,6 @@ extension LoopDataManager {
             }
         }
     }
-
 }
 
 /// Describes a view into the loop state
@@ -2104,16 +2142,21 @@ extension LoopDataManager {
                     self.doseStore.generateDiagnosticReport { (report) in
                         entries.append(report)
                         entries.append("")
-
-                        UNUserNotificationCenter.current().generateDiagnosticReport { (report) in
+                        
+                        self.mealDetectionManager.generateDiagnosticReport { report in
                             entries.append(report)
                             entries.append("")
-
-                            UIDevice.current.generateDiagnosticReport { (report) in
+                            
+                            UNUserNotificationCenter.current().generateDiagnosticReport { (report) in
                                 entries.append(report)
                                 entries.append("")
 
-                                completion(entries.joined(separator: "\n"))
+                                UIDevice.current.generateDiagnosticReport { (report) in
+                                    entries.append(report)
+                                    entries.append("")
+
+                                    completion(entries.joined(separator: "\n"))
+                                }
                             }
                         }
                     }
@@ -2147,7 +2190,14 @@ protocol LoopDataManagerDelegate: AnyObject {
     ///   - rate: The recommended rate in U/hr
     /// - Returns: a supported rate of delivery in Units/hr. The rate returned should not be larger than the passed in rate.
     func roundBasalRate(unitsPerHour: Double) -> Double
-
+    
+    /// Asks the delegate to estimate the duration to deliver the bolus.
+    ///
+    /// - Parameters:
+    ///   - bolusUnits: size of the bolus in U
+    /// - Returns: the estimated time it will take to deliver bolus
+    func loopDataManager(_ manager: LoopDataManager, estimateBolusDuration bolusUnits: Double) -> TimeInterval?
+    
     /// Asks the delegate to round a recommended bolus volume to a supported volume
     ///
     /// - Parameters: