feat: Add glucose targets & preset targets to Live Activity

Loop Widget Extension/Live Activity/ChartView.swift

@@ -13,8 +13,10 @@ import Charts
 struct ChartView: View {
     private let glucoseSampleData: [ChartValues]
     private let predicatedData: [ChartValues]
+    private let glucoseRanges: [GlucoseRangeValue]
+    private let preset: Preset?
 
-    init(glucoseSamples: [GlucoseSampleAttributes], predicatedGlucose: [Double], predicatedStartDate: Date?, predicatedInterval: TimeInterval?, lowerLimit: Double, upperLimit: Double) {
+    init(glucoseSamples: [GlucoseSampleAttributes], predicatedGlucose: [Double], predicatedStartDate: Date?, predicatedInterval: TimeInterval?, lowerLimit: Double, upperLimit: Double, glucoseRanges: [GlucoseRangeValue], preset: Preset?) {
         self.glucoseSampleData = ChartValues.convert(data: glucoseSamples, lowerLimit: lowerLimit, upperLimit: upperLimit)
         self.predicatedData = ChartValues.convert(
             data: predicatedGlucose,
@@ -23,30 +25,57 @@ struct ChartView: View {
             lowerLimit: lowerLimit,
             upperLimit: upperLimit
         )
+        self.preset = preset
+        self.glucoseRanges = glucoseRanges
     }
 
-    init(glucoseSamples: [GlucoseSampleAttributes], lowerLimit: Double, upperLimit: Double) {
+    init(glucoseSamples: [GlucoseSampleAttributes], lowerLimit: Double, upperLimit: Double, glucoseRanges: [GlucoseRangeValue], preset: Preset?) {
         self.glucoseSampleData = ChartValues.convert(data: glucoseSamples, lowerLimit: lowerLimit, upperLimit: upperLimit)
         self.predicatedData = []
+        self.preset = preset
+        self.glucoseRanges = glucoseRanges
     }
 
     var body: some View {
-        Chart {
-            ForEach(glucoseSampleData) { item in
-                PointMark (x: .value("Date", item.x),
-                          y: .value("Glucose level", item.y)
-                )
-                .symbolSize(20)
-                .foregroundStyle(by: .value("Color", item.color))
-            }
-
-            ForEach(predicatedData) { item in
-                LineMark (x: .value("Date", item.x),
-                          y: .value("Glucose level", item.y)
-                )
-                .lineStyle(StrokeStyle(lineWidth: 3, dash: [2, 3]))
+        ZStack(alignment: Alignment(horizontal: .trailing, vertical: .top)){
+            Chart {
+                if let preset = self.preset, predicatedData.count > 0 {
+                    RectangleMark(
+                        xStart: .value("Start", Date.now),
+                        xEnd: .value("End", preset.endDate),
+                        yStart: .value("Preset override", preset.minValue),
+                        yEnd: .value("Preset override", preset.maxValue)
+                    )
+                    .foregroundStyle(.primary)
+                    .opacity(0.6)
+                }
+
+                ForEach(glucoseRanges) { item in
+                    RectangleMark(
+                        xStart: .value("Start", item.startDate),
+                        xEnd: .value("End", item.endDate),
+                        yStart: .value("Glucose range", item.minValue),
+                        yEnd: .value("Glucose range", item.maxValue)
+                    )
+                    .foregroundStyle(.primary)
+                    .opacity(0.3)
+                }
+
+                ForEach(glucoseSampleData) { item in
+                    PointMark (x: .value("Date", item.x),
+                               y: .value("Glucose level", item.y)
+                    )
+                    .symbolSize(20)
+                    .foregroundStyle(by: .value("Color", item.color))
+                }
+
+                ForEach(predicatedData) { item in
+                    LineMark (x: .value("Date", item.x),
+                              y: .value("Glucose level", item.y)
+                    )
+                    .lineStyle(StrokeStyle(lineWidth: 3, dash: [2, 3]))
+                }
             }
-        }
             .chartForegroundStyleScale([
                 "Good": .green,
                 "High": .orange,
@@ -58,7 +87,7 @@ struct ChartView: View {
             .chartLegend(.hidden)
             .chartYScale(domain: .automatic(includesZero: false))
             .chartYAxis {
-                AxisMarks(position: .trailing) { _ in
+                AxisMarks(position: .leading) { _ in
                     AxisValueLabel().foregroundStyle(Color.primary)
                     AxisGridLine(stroke: .init(lineWidth: 0.1, dash: [2, 3]))
                         .foregroundStyle(Color.primary)
@@ -72,6 +101,14 @@ struct ChartView: View {
                         .foregroundStyle(Color.primary)
                 }
             }
+
+            if let preset = self.preset {
+                Text(preset.title)
+                    .font(.footnote)
+                    .padding(.trailing, 5)
+                    .padding(.top, 5)
+            }
+        }
     }
 }
 

Loop Widget Extension/Live Activity/GlucoseLiveActivityConfiguration.swift

@@ -39,14 +39,18 @@ struct GlucoseLiveActivityConfiguration: Widget {
                                 predicatedStartDate: context.state.predicatedStartDate,
                                 predicatedInterval: context.state.predicatedInterval,
                                 lowerLimit: context.state.isMmol ? context.attributes.lowerLimitChartMmol : context.attributes.lowerLimitChartMg,
-                                upperLimit: context.state.isMmol ? context.attributes.upperLimitChartMmol : context.attributes.upperLimitChartMg
+                                upperLimit: context.state.isMmol ? context.attributes.upperLimitChartMmol : context.attributes.upperLimitChartMg,
+                                glucoseRanges: context.state.glucoseRanges,
+                                preset: context.state.preset
                             )
                             .frame(height: 85)
                         } else {
                             ChartView(
                                 glucoseSamples: context.state.glucoseSamples,
                                 lowerLimit: context.state.isMmol ? context.attributes.lowerLimitChartMmol : context.attributes.lowerLimitChartMg,
-                                upperLimit: context.state.isMmol ? context.attributes.upperLimitChartMmol : context.attributes.upperLimitChartMg
+                                upperLimit: context.state.isMmol ? context.attributes.upperLimitChartMmol : context.attributes.upperLimitChartMg,
+                                glucoseRanges: context.state.glucoseRanges,
+                                preset: context.state.preset
                             )
                             .frame(height: 85)
                         }
@@ -135,14 +139,18 @@ struct GlucoseLiveActivityConfiguration: Widget {
                             predicatedStartDate: context.state.predicatedStartDate,
                             predicatedInterval: context.state.predicatedInterval,
                             lowerLimit: context.state.isMmol ? context.attributes.lowerLimitChartMmol : context.attributes.lowerLimitChartMg,
-                            upperLimit: context.state.isMmol ? context.attributes.upperLimitChartMmol : context.attributes.upperLimitChartMg
+                            upperLimit: context.state.isMmol ? context.attributes.upperLimitChartMmol : context.attributes.upperLimitChartMg,
+                            glucoseRanges: context.state.glucoseRanges,
+                            preset: context.state.preset
                         )
                             .frame(height: 75)
                     } else {
                         ChartView(
                             glucoseSamples: context.state.glucoseSamples,
                             lowerLimit: context.state.isMmol ? context.attributes.lowerLimitChartMmol : context.attributes.lowerLimitChartMg,
-                            upperLimit: context.state.isMmol ? context.attributes.upperLimitChartMmol : context.attributes.upperLimitChartMg
+                            upperLimit: context.state.isMmol ? context.attributes.upperLimitChartMmol : context.attributes.upperLimitChartMg,
+                            glucoseRanges: context.state.glucoseRanges,
+                            preset: context.state.preset
                         )
                             .frame(height: 75)
                     }

Loop/Managers/Live Activity/GlucoseActivityAttributes.swift

@@ -16,6 +16,8 @@ public struct GlucoseActivityAttributes: ActivityAttributes {
         // Meta data
         public let date: Date
         public let ended: Bool
+        public let preset: Preset?
+        public let glucoseRanges: [GlucoseRangeValue]
 
         // Dynamic island data
         public let currentGlucose: Double
@@ -44,6 +46,21 @@ public struct GlucoseActivityAttributes: ActivityAttributes {
     public let lowerLimitChartMg: Double
 }
 
+public struct Preset: Codable, Hashable {
+    public let title: String
+    public let endDate: Date
+    public let minValue: Double
+    public let maxValue: Double
+}
+
+public struct GlucoseRangeValue: Identifiable, Codable, Hashable {
+    public let id: UUID
+    public let minValue: Double
+    public let maxValue: Double
+    public let startDate: Date
+    public let endDate: Date
+}
+
 public struct BottomRowItem: Codable, Hashable {
     public enum BottomRowType: Codable, Hashable {
         case generic

Loop/Managers/Live Activity/GlucoseActivityManager.swift

@@ -25,6 +25,8 @@ class GlucoseActivityManager {
 
     private let glucoseStore: GlucoseStoreProtocol
     private let doseStore: DoseStoreProtocol
+    private let glucoseRangeSchedule: GlucoseRangeSchedule?
+    private var preset: TemporaryScheduleOverride?
 
     private var startDate: Date = Date.now
     private var settings: LiveActivitySettings = UserDefaults.standard.liveActivity ?? LiveActivitySettings()
@@ -49,13 +51,15 @@ class GlucoseActivityManager {
         return dateFormatter
     }()
 
-    init?(glucoseStore: GlucoseStoreProtocol, doseStore: DoseStoreProtocol) {
+    init?(glucoseStore: GlucoseStoreProtocol, doseStore: DoseStoreProtocol, glucoseRangeSchedule: GlucoseRangeSchedule?, preset: TemporaryScheduleOverride?) {
         guard self.activityInfo.areActivitiesEnabled else {
             return nil
         }
 
         self.glucoseStore = glucoseStore
         self.doseStore = doseStore
+        self.glucoseRangeSchedule = glucoseRangeSchedule
+        self.preset = preset
 
         // Ensure settings exist
         if UserDefaults.standard.liveActivity == nil {
@@ -120,10 +124,42 @@ class GlucoseActivityManager {
             if let samples = statusContext?.predictedGlucose?.values, settings.addPredictiveLine {
                 predicatedGlucose = samples
             }
+
+            var endDateChart: Date? = nil
+            if predicatedGlucose.count == 0 {
+                endDateChart = glucoseSamples.last?.startDate
+            } else if let predictedGlucose = statusContext?.predictedGlucose {
+                endDateChart = predictedGlucose.startDate.addingTimeInterval(.hours(4))
+            }
+
+            var presetContext: Preset? = nil
+            if let preset = self.preset, let endDateChart = endDateChart {
+                presetContext = Preset(
+                    title: preset.getTitle(),
+                    endDate: preset.duration.isInfinite ? endDateChart : min(Date.now + preset.duration.timeInterval, endDateChart),
+                    minValue: preset.settings.targetRange?.lowerBound.doubleValue(for: unit) ?? 0,
+                    maxValue: preset.settings.targetRange?.upperBound.doubleValue(for: unit) ?? 0
+                )
+            }
+
+            var glucoseRanges: [GlucoseRangeValue] = []
+            if let glucoseRangeSchedule = self.glucoseRangeSchedule, let start = glucoseSamples.first?.startDate, let end = endDateChart {
+                for item in glucoseRangeSchedule.quantityBetween(start: start, end: end) {
+                    glucoseRanges.append(GlucoseRangeValue(
+                        id: UUID(),
+                        minValue: item.value.lowerBound.doubleValue(for: unit),
+                        maxValue: item.value.upperBound.doubleValue(for: unit),
+                        startDate: max(item.startDate, start),
+                        endDate: min(item.endDate, end)
+                    ))
+                }
+            }
 
             let state = GlucoseActivityAttributes.ContentState(
                 date: currentGlucose.startDate,
                 ended: false,
+                preset: presetContext,
+                glucoseRanges: glucoseRanges,
                 currentGlucose: current,
                 trendType: statusContext?.glucoseDisplay?.trendType,
                 delta: delta,
@@ -226,7 +262,6 @@ class GlucoseActivityManager {
             }
             self.startDate = Date.now
         } catch {}
-
     }
 
     private func needsRecreation() -> Bool {
@@ -339,6 +374,8 @@ class GlucoseActivityManager {
             let dynamicState = GlucoseActivityAttributes.ContentState(
                 date: Date.now,
                 ended: true,
+                preset: nil,
+                glucoseRanges: [],
                 currentGlucose: 0,
                 trendType: nil,
                 delta: "",
@@ -365,4 +402,29 @@ class GlucoseActivityManager {
             )
         } catch {}
     }
+
+    func presetActivated(preset: TemporaryScheduleOverride) {
+        self.preset = preset
+        self.update()
+    }
+
+    func presetDeactivated() {
+        self.preset = nil
+        self.update()
+    }
+}
+
+extension TemporaryScheduleOverride {
+    func getTitle() -> String {
+        switch (self.context) {
+        case .preset(let preset):
+            return "\(preset.symbol) \(preset.name)"
+        case .custom:
+            return NSLocalizedString("Custom preset", comment: "The title of the cell indicating a generic custom preset is enabled")
+        case .preMeal:
+            return NSLocalizedString(" Pre-meal Preset", comment: "Status row title for premeal override enabled (leading space is to separate from symbol)")
+        case .legacyWorkout:
+            return ""
+        }
+    }
 }

Loop/Managers/LoopDataManager.swift

@@ -127,7 +127,12 @@ final class LoopDataManager {
 
         self.trustedTimeOffset = trustedTimeOffset
 
-        self.liveActivityManager = GlucoseActivityManager(glucoseStore: self.glucoseStore, doseStore: self.doseStore)
+        self.liveActivityManager = GlucoseActivityManager(
+            glucoseStore: self.glucoseStore,
+            doseStore: self.doseStore,
+            glucoseRangeSchedule: settings.glucoseTargetRangeSchedule,
+            preset: self.settings.scheduleOverride
+        )
 
         overrideIntentObserver = UserDefaults.appGroup?.observe(\.intentExtensionOverrideToSet, options: [.new], changeHandler: {[weak self] (defaults, change) in
             guard let name = change.newValue??.lowercased(), let appGroup = UserDefaults.appGroup else {
@@ -147,13 +152,17 @@ final class LoopDataManager {
                             observer.presetDeactivated(context: oldPreset.context)
                         }
                     }
+                    self?.liveActivityManager?.presetDeactivated()
                 }
                 settings.scheduleOverride = preset.createOverride(enactTrigger: .remote("Siri"))
                 if let observers = self?.presetActivationObservers {
                     for observer in observers {
                         observer.presetActivated(context: .preset(preset), duration: preset.duration)
                     }
                 }
+                if let override = settings.scheduleOverride {
+                    self?.liveActivityManager?.presetActivated(preset: override)
+                }
             }
             // Remove the override from UserDefaults so we don't set it multiple times
             appGroup.intentExtensionOverrideToSet = nil
@@ -263,12 +272,14 @@ final class LoopDataManager {
                 for observer in self.presetActivationObservers {
                     observer.presetDeactivated(context: oldPreset.context)
                 }
-
+                self.liveActivityManager?.presetDeactivated()
             }
             if let newPreset = newValue.scheduleOverride {
                 for observer in self.presetActivationObservers {
                     observer.presetActivated(context: newPreset.context, duration: newPreset.duration)
                 }
+
+                self.liveActivityManager?.presetActivated(preset: newPreset)
             }
 
             // Invalidate cached effects affected by the override