Temp Target notifications

LoopFollow/Controllers/Alarms.swift

@@ -578,7 +578,63 @@ extension MainViewController {
                 lastOverrideAlarm = now
         }
     }
-    
+
+    func checkTempTargetAlarms() {
+        if UserDefaultsRepository.alertSnoozeAllIsSnoozed.value { return }
+
+        let recentTempTarget = tempTargetGraphData.last
+        let recentStart: TimeInterval = recentTempTarget?.date ?? 0
+        let recentEnd: TimeInterval = recentTempTarget?.endDate ?? 0
+        let now = dateTimeUtils.getNowTimeIntervalUTC()
+
+        var triggerStart = false
+        var triggerEnd = false
+
+        // Trigger newly started temp target
+        if now - recentStart > 0 && now - recentStart <= (15 * 60) && recentStart > lastTempTargetAlarm {
+            triggerStart = true
+        } else if now - recentEnd > 0 && now - recentEnd <= (15 * 60) && recentEnd > lastTempTargetAlarm {
+            triggerEnd = true
+        } else {
+            return
+        }
+
+        var numLoops = 0
+        var playSound = true
+
+        // Check Temp Target Start Alarm
+        if UserDefaultsRepository.alertTempTargetStart.value && !UserDefaultsRepository.alertTempTargetStartIsSnoozed.value && triggerStart {
+            AlarmSound.whichAlarm = "Temp Target Started"
+            // Determine if it is day or night and what should happen
+            if UserDefaultsRepository.nightTime.value {
+                if UserDefaultsRepository.alertTempTargetStartNightTime.value { numLoops = -1 }
+                if !UserDefaultsRepository.alertTempTargetStartNightTimeAudible.value { playSound = false }
+            } else {
+                if UserDefaultsRepository.alertTempTargetStartDayTime.value { numLoops = -1 }
+                if !UserDefaultsRepository.alertTempTargetStartDayTimeAudible.value { playSound = false }
+            }
+            triggerOneTimeAlarm(sound: UserDefaultsRepository.alertTempTargetStartSound.value, overrideVolume: UserDefaultsRepository.overrideSystemOutputVolume.value, numLoops: numLoops, audio: playSound)
+            lastTempTargetStartTime = recentStart
+            lastTempTargetAlarm = now
+        }
+
+        // Check Temp Target End Alarm
+        else if UserDefaultsRepository.alertTempTargetEnd.value && !UserDefaultsRepository.alertTempTargetEndIsSnoozed.value && triggerEnd {
+            AlarmSound.whichAlarm = "Temp Target Ended"
+            // Determine if it is day or night and what should happen
+            if UserDefaultsRepository.nightTime.value {
+                if UserDefaultsRepository.alertTempTargetEndNightTime.value { numLoops = -1 }
+                if !UserDefaultsRepository.alertTempTargetEndNightTimeAudible.value { playSound = false }
+            } else {
+                if UserDefaultsRepository.alertTempTargetEndDayTime.value { numLoops = -1 }
+                if !UserDefaultsRepository.alertTempTargetEndDayTimeAudible.value { playSound = false }
+            }
+            triggerOneTimeAlarm(sound: UserDefaultsRepository.alertTempTargetEndSound.value, overrideVolume: UserDefaultsRepository.overrideSystemOutputVolume.value, numLoops: numLoops, audio: playSound)
+            lastTempTargetEndTime = recentEnd
+            lastTempTargetAlarm = now
+        }
+    }
+
     func triggerOneTimeAlarm(sound: String, overrideVolume: Bool, numLoops: Int, audio: Bool = true)
     {
         var audioDuringCall = true
@@ -788,6 +844,18 @@ extension MainViewController {
             alarms.reloadSnoozeTime(key: "alertRecBolusSnoozedTime", setNil: true)
             alarms.reloadIsSnoozed(key: "alertRecBolusIsSnoozed", value: false)
         }
+        if date > UserDefaultsRepository.alertTempTargetStartSnoozedTime.value ?? date {
+            UserDefaultsRepository.alertTempTargetStartSnoozedTime.setNil(key: "alertTempTargetStartSnoozedTime")
+            UserDefaultsRepository.alertTempTargetStartIsSnoozed.value = false
+            alarms.reloadSnoozeTime(key: "alertTempTargetStartSnoozedTime", setNil: true)
+            alarms.reloadIsSnoozed(key: "alertTempTargetStartIsSnoozed", value: false)
+        }
+        if date > UserDefaultsRepository.alertTempTargetEndSnoozedTime.value ?? date {
+            UserDefaultsRepository.alertTempTargetEndSnoozedTime.setNil(key: "alertTempTargetEndSnoozedTime")
+            UserDefaultsRepository.alertTempTargetEndIsSnoozed.value = false
+            alarms.reloadSnoozeTime(key: "alertTempTargetEndSnoozedTime", setNil: true)
+            alarms.reloadIsSnoozed(key: "alertTempTargetEndIsSnoozed", value: false)
+        }
     }
 
     func checkQuietHours() {

LoopFollow/Controllers/Timers.swift

@@ -265,6 +265,9 @@ extension MainViewController {
         if overrideGraphData.count > 0 {
             self.checkOverrideAlarms()
         }
+        if tempTargetGraphData.count > 0 {
+            self.checkTempTargetAlarms()
+        }
     }
     
     // Calendar Timer

LoopFollow/Storage/UserDefaults.swift

@@ -423,6 +423,36 @@ class UserDefaultsRepository {
     static let alertOverrideEndAutosnoozeDay = UserDefaultsValue<Bool>(key: "alertOverrideEndAutosnoozeDay", default: false)
     static let alertOverrideEndAutosnoozeNight = UserDefaultsValue<Bool>(key: "alertOverrideEndAutosnoozeNight", default: false)
 
+    static let alertTempTargetStart = UserDefaultsValue<Bool>(key: "alertTempTargetStart", default: false)
+    static let alertTempTargetStartQuiet = UserDefaultsValue<Bool>(key: "alertTempTargetStartQuiet", default: false)
+    static let alertTempTargetStartRepeat = UserDefaultsValue<String>(key: "alertTempTargetStartRepeat", default: "Never")
+    static let alertTempTargetStartDayTime = UserDefaultsValue<Bool>(key: "alertTempTargetStartDayTime", default: false)
+    static let alertTempTargetStartNightTime = UserDefaultsValue<Bool>(key: "alertTempTargetStartNightTime", default: false)
+    static let alertTempTargetStartAudible = UserDefaultsValue<String>(key: "alertTempTargetStartRepeatAudible", default: "Always")
+    static let alertTempTargetStartDayTimeAudible = UserDefaultsValue<Bool>(key: "alertTempTargetStartDayTimeAudible", default: true)
+    static let alertTempTargetStartNightTimeAudible = UserDefaultsValue<Bool>(key: "alertTempTargetStartNightTimeAudible", default: true)
+    static let alertTempTargetStartSound = UserDefaultsValue<String>(key: "alertTempTargetStartSound", default: "Ending_Reached")
+    static let alertTempTargetStartSnoozedTime = UserDefaultsValue<Date?>(key: "alertTempTargetStartSnoozedTime", default: nil)
+    static let alertTempTargetStartIsSnoozed = UserDefaultsValue<Bool>(key: "alertTempTargetStartIsSnoozed", default: false)
+    static let alertTempTargetStartAutosnooze = UserDefaultsValue<String>(key: "alertTempTargetStartAutosnooze", default: "Never")
+    static let alertTempTargetStartAutosnoozeDay = UserDefaultsValue<Bool>(key: "alertTempTargetStartAutosnoozeDay", default: false)
+    static let alertTempTargetStartAutosnoozeNight = UserDefaultsValue<Bool>(key: "alertTempTargetStartAutosnoozeNight", default: false)
+
+    static let alertTempTargetEnd = UserDefaultsValue<Bool>(key: "alertTempTargetEnd", default: false)
+    static let alertTempTargetEndQuiet = UserDefaultsValue<Bool>(key: "alertTempTargetEndQuiet", default: false)
+    static let alertTempTargetEndRepeat = UserDefaultsValue<String>(key: "alertTempTargetEndRepeat", default: "Never")
+    static let alertTempTargetEndDayTime = UserDefaultsValue<Bool>(key: "alertTempTargetEndDayTime", default: false)
+    static let alertTempTargetEndNightTime = UserDefaultsValue<Bool>(key: "alertTempTargetEndNightTime", default: false)
+    static let alertTempTargetEndAudible = UserDefaultsValue<String>(key: "alertTempTargetEndRepeatAudible", default: "Always")
+    static let alertTempTargetEndDayTimeAudible = UserDefaultsValue<Bool>(key: "alertTempTargetEndDayTimeAudible", default: true)
+    static let alertTempTargetEndNightTimeAudible = UserDefaultsValue<Bool>(key: "alertTempTargetEndNightTimeAudible", default: true)
+    static let alertTempTargetEndSound = UserDefaultsValue<String>(key: "alertTempTargetEndSound", default: "Alert_Tone_Busy")
+    static let alertTempTargetEndSnoozedTime = UserDefaultsValue<Date?>(key: "alertTempTargetEndSnoozedTime", default: nil)
+    static let alertTempTargetEndIsSnoozed = UserDefaultsValue<Bool>(key: "alertTempTargetEndIsSnoozed", default: false)
+    static let alertTempTargetEndAutosnooze = UserDefaultsValue<String>(key: "alertTempTargetEndAutosnooze", default: "Never")
+    static let alertTempTargetEndAutosnoozeDay = UserDefaultsValue<Bool>(key: "alertTempTargetEndAutosnoozeDay", default: false)
+    static let alertTempTargetEndAutosnoozeNight = UserDefaultsValue<Bool>(key: "alertTempTargetEndAutosnoozeNight", default: false)
+    
     static let alertPump = UserDefaultsValue<Bool>(key: "alertPump", default: false)
     static let alertPumpAt = UserDefaultsValue<Int>(key: "alertPumpAt", default: 10) //Units
     static let alertPumpQuiet = UserDefaultsValue<Bool>(key: "alertPumpQuiet", default: false)

LoopFollow/ViewControllers/MainViewController.swift

@@ -130,7 +130,11 @@ class MainViewController: UIViewController, UITableViewDataSource, ChartViewDele
     var topPredictionBG: Float = UserDefaultsRepository.minBGScale.value
 
     var lastOverrideAlarm: TimeInterval = 0
-    
+
+    var lastTempTargetAlarm: TimeInterval = 0
+    var lastTempTargetStartTime: TimeInterval = 0
+    var lastTempTargetEndTime: TimeInterval = 0
+
     // share
     var bgDataShare: [ShareGlucoseData] = []
     var dexShare: ShareClient?;

LoopFollow/ViewControllers/SnoozeViewController.swift

@@ -233,6 +233,18 @@ class SnoozeViewController: UIViewController, UNUserNotificationCenterDelegate {
             alarms.reloadIsSnoozed(key: "alertRecBolusIsSnoozed", value: true)
             alarms.reloadSnoozeTime(key: "alertRecBolusSnoozedTime", setNil: false, value: currentDate.addingTimeInterval(snoozeDuration))
 
+        case "Temp Target Start":
+            UserDefaultsRepository.alertTempTargetStartIsSnoozed.value = true
+            UserDefaultsRepository.alertTempTargetStartSnoozedTime.value = currentDate.addingTimeInterval(snoozeDuration)
+            alarms.reloadIsSnoozed(key: "alertTempTargetStartIsSnoozed", value: true)
+            alarms.reloadSnoozeTime(key: "alertTempTargetStartSnoozedTime", setNil: false, value: currentDate.addingTimeInterval(snoozeDuration))
+
+        case "Temp Target End":
+            UserDefaultsRepository.alertTempTargetEndIsSnoozed.value = true
+            UserDefaultsRepository.alertTempTargetEndSnoozedTime.value = currentDate.addingTimeInterval(snoozeDuration)
+            alarms.reloadIsSnoozed(key: "alertTempTargetEndIsSnoozed", value: true)
+            alarms.reloadSnoozeTime(key: "alertTempTargetEndSnoozedTime", setNil: false, value: currentDate.addingTimeInterval(snoozeDuration))
+
         default:
             print("Unhandled alarm: \(AlarmSound.whichAlarm)")
         }
@@ -337,6 +349,18 @@ class SnoozeViewController: UIViewController, UNUserNotificationCenterDelegate {
             alarms.reloadIsSnoozed(key: "alertCOBIsSnoozed", value: true)
             alarms.reloadSnoozeTime(key: "alertCOBSnoozedTime", setNil: false, value: snoozeTime)
         }
+        if UserDefaultsRepository.alertTempTargetStartAutosnoozeNight.value {
+            UserDefaultsRepository.alertTempTargetStartIsSnoozed.value = true
+            UserDefaultsRepository.alertTempTargetStartSnoozedTime.value = snoozeTime
+            alarms.reloadIsSnoozed(key: "alertTempTargetStartIsSnoozed", value: true)
+            alarms.reloadSnoozeTime(key: "alertTempTargetStartSnoozedTime", setNil: false, value: snoozeTime)
+        }
+        if UserDefaultsRepository.alertTempTargetEndAutosnoozeNight.value {
+            UserDefaultsRepository.alertTempTargetEndIsSnoozed.value = true
+            UserDefaultsRepository.alertTempTargetEndSnoozedTime.value = snoozeTime
+            alarms.reloadIsSnoozed(key: "alertTempTargetEndIsSnoozed", value: true)
+            alarms.reloadSnoozeTime(key: "alertTempTargetEndSnoozedTime", setNil: false, value: snoozeTime)
+        }
     }
 
     func setPreSnoozeDay(snoozeTime: Date) {
@@ -438,6 +462,18 @@ class SnoozeViewController: UIViewController, UNUserNotificationCenterDelegate {
             alarms.reloadIsSnoozed(key: "alertCOBIsSnoozed", value: true)
             alarms.reloadSnoozeTime(key: "alertCOBSnoozedTime", setNil: false, value: snoozeTime)
         }
+        if UserDefaultsRepository.alertTempTargetStartAutosnoozeDay.value {
+            UserDefaultsRepository.alertTempTargetStartIsSnoozed.value = true
+            UserDefaultsRepository.alertTempTargetStartSnoozedTime.value = snoozeTime
+            alarms.reloadIsSnoozed(key: "alertTempTargetStartIsSnoozed", value: true)
+            alarms.reloadSnoozeTime(key: "alertTempTargetStartSnoozedTime", setNil: false, value: snoozeTime)
+        }
+        if UserDefaultsRepository.alertTempTargetEndAutosnoozeDay.value {
+            UserDefaultsRepository.alertTempTargetEndIsSnoozed.value = true
+            UserDefaultsRepository.alertTempTargetEndSnoozedTime.value = snoozeTime
+            alarms.reloadIsSnoozed(key: "alertTempTargetEndIsSnoozed", value: true)
+            alarms.reloadSnoozeTime(key: "alertTempTargetEndSnoozedTime", setNil: false, value: snoozeTime)
+        }
     }
 
     override func viewDidLoad() {