Tidepool Merge

Common/Extensions/NSBundle.swift

@@ -60,5 +60,27 @@ extension Bundle {
         }
         return .days(localCacheDurationDays)
     }
+
+    var hostIdentifier: String {
+        var identifier = bundleIdentifier ?? "com.loopkit.Loop"
+        let components = identifier.components(separatedBy: ".")
+        // DIY Loop has bundle identifiers like com.UY653SP37Q.loopkit.Loop
+        if components[2] == "loopkit" && components[3] == "Loop" {
+            identifier = "com.loopkit.Loop"
+        }
+        return identifier
+    }
+
+    var hostVersion: String {
+        var semanticVersion = shortVersionString
+
+        while semanticVersion.split(separator: ".").count < 3 {
+            semanticVersion += ".0"
+        }
+
+        semanticVersion += "+\(Bundle.main.version)"
+
+        return semanticVersion
+    }
 }
 

Loop Widget Extension/Timeline/StatusWidgetTimelineProvider.swift

@@ -30,10 +30,16 @@ class StatusWidgetTimelineProvider: TimelineProvider {
         store: cacheStore,
         expireAfter: localCacheDuration)
 
-    lazy var glucoseStore = GlucoseStore(
-        cacheStore: cacheStore,
-        provenanceIdentifier: HKSource.default().bundleIdentifier
-    )
+    var glucoseStore: GlucoseStore!
+
+    init() {
+        Task {
+            glucoseStore = await GlucoseStore(
+                cacheStore: cacheStore,
+                provenanceIdentifier: HKSource.default().bundleIdentifier
+            )
+        }
+    }
 
     func placeholder(in context: Context) -> StatusWidgetTimelimeEntry {
         log.default("%{public}@: context=%{public}@", #function, String(describing: context))
@@ -90,29 +96,22 @@ class StatusWidgetTimelineProvider: TimelineProvider {
     }
 
     func update(completion: @escaping (StatusWidgetTimelimeEntry) -> Void) {
-        let group = DispatchGroup()
-
-        var glucose: [StoredGlucoseSample] = []
 
         let startDate = Date(timeIntervalSinceNow: -LoopAlgorithm.inputDataRecencyInterval)
 
-        group.enter()
-        glucoseStore.getGlucoseSamples(start: startDate) { (result) in
-            switch result {
-            case .failure:
+        Task {
+
+            var glucose: [StoredGlucoseSample] = []
+
+            do {
+                glucose = try await glucoseStore.getGlucoseSamples(start: startDate)
+                self.log.default("Fetched glucose: last = %{public}@, %{public}@", String(describing: glucose.last?.startDate), String(describing: glucose.last?.quantity))
+            } catch {
                 self.log.error("Failed to fetch glucose after %{public}@", String(describing: startDate))
-                glucose = []
-            case .success(let samples):
-                self.log.default("Fetched glucose: last = %{public}@, %{public}@", String(describing: samples.last?.startDate), String(describing: samples.last?.quantity))
-                glucose = samples
             }
-            group.leave()
-        }
-        group.wait()
 
-        let finalGlucose = glucose
+            let finalGlucose = glucose
 
-        Task { @MainActor in
             guard let defaults = self.defaults,
                   let context = defaults.statusExtensionContext,
                   let contextUpdatedAt = context.createdAt,

Loop/Extensions/GlucoseStore+SimulatedCoreData.swift

@@ -82,8 +82,8 @@ extension GlucoseStore {
         return addError
     }
 
-    func purgeHistoricalGlucoseObjects(completion: @escaping (Error?) -> Void) {
-        purgeCachedGlucoseObjects(before: historicalEndDate, completion: completion)
+    func purgeHistoricalGlucoseObjects() async throws {
+        try await purgeCachedGlucoseObjects(before: historicalEndDate)
     }
 }
 

Loop/Managers/CGMStalenessMonitor.swift

@@ -12,7 +12,7 @@ import LoopCore
 import LoopAlgorithm
 
 protocol CGMStalenessMonitorDelegate: AnyObject {
-    func getLatestCGMGlucose(since: Date, completion: @escaping (_ result: Swift.Result<StoredGlucoseSample?, Error>) -> Void)
+    func getLatestCGMGlucose(since: Date) async throws -> StoredGlucoseSample?
 }
 
 class CGMStalenessMonitor {
@@ -21,13 +21,7 @@ class CGMStalenessMonitor {
 
     private var cgmStalenessTimer: Timer?
 
-    weak var delegate: CGMStalenessMonitorDelegate? = nil {
-        didSet {
-            if delegate != nil {
-                checkCGMStaleness()
-            }
-        }
-    }
+    weak var delegate: CGMStalenessMonitorDelegate?
 
     @Published var cgmDataIsStale: Bool = true {
         didSet {
@@ -57,29 +51,27 @@ class CGMStalenessMonitor {
         cgmStalenessTimer?.invalidate()
         cgmStalenessTimer = Timer.scheduledTimer(withTimeInterval: expiration.timeIntervalSinceNow, repeats: false) { [weak self] _ in
             self?.log.debug("cgmStalenessTimer fired")
-            self?.checkCGMStaleness()
+            Task {
+                await self?.checkCGMStaleness()
+            }
         }
         cgmStalenessTimer?.tolerance = CGMStalenessMonitor.cgmStalenessTimerTolerance
     }
 
-    private func checkCGMStaleness() {
-        delegate?.getLatestCGMGlucose(since: Date(timeIntervalSinceNow: -LoopAlgorithm.inputDataRecencyInterval)) { (result) in
-            DispatchQueue.main.async {
-                self.log.debug("Fetched latest CGM Glucose for checkCGMStaleness: %{public}@", String(describing: result))
-                switch result {
-                case .success(let sample):
-                    if let sample = sample {
-                        self.cgmDataIsStale = false
-                        self.updateCGMStalenessTimer(expiration: sample.startDate.addingTimeInterval(LoopAlgorithm.inputDataRecencyInterval + CGMStalenessMonitor.cgmStalenessTimerTolerance))
-                    } else {
-                        self.cgmDataIsStale = true
-                    }
-                case .failure(let error):
-                    self.log.error("Unable to get latest CGM clucose: %{public}@ ", String(describing: error))
-                    // Some kind of system error; check again in 5 minutes
-                    self.updateCGMStalenessTimer(expiration: Date(timeIntervalSinceNow: .minutes(5)))
-                }
+    func checkCGMStaleness() async {
+        do {
+            let sample = try await delegate?.getLatestCGMGlucose(since: Date(timeIntervalSinceNow: -LoopAlgorithm.inputDataRecencyInterval))
+            self.log.debug("Fetched latest CGM Glucose for checkCGMStaleness: %{public}@", String(describing: sample))
+            if let sample = sample {
+                self.cgmDataIsStale = false
+                self.updateCGMStalenessTimer(expiration: sample.startDate.addingTimeInterval(LoopAlgorithm.inputDataRecencyInterval + CGMStalenessMonitor.cgmStalenessTimerTolerance))
+            } else {
+                self.cgmDataIsStale = true
             }
+        } catch {
+            self.log.error("Unable to get latest CGM clucose: %{public}@ ", String(describing: error))
+            // Some kind of system error; check again in 5 minutes
+            self.updateCGMStalenessTimer(expiration: Date(timeIntervalSinceNow: .minutes(5)))
         }
     }
 }

Loop/Managers/CriticalEventLogExportManager.swift

@@ -199,16 +199,6 @@ public class CriticalEventLogExportManager {
         calendar.timeZone = TimeZone(identifier: "UTC")!
         return calendar
     }()
-
-    // MARK: - Background Tasks
-
-    func registerBackgroundTasks() {
-        if Self.registerCriticalEventLogHistoricalExportBackgroundTask({ self.handleCriticalEventLogHistoricalExportBackgroundTask($0) }) {
-            log.debug("Critical event log export background task registered")
-        } else {
-            log.error("Critical event log export background task not registered")
-        }
-    }
 }
 
 // MARK: - CriticalEventLogBaseExporter
@@ -567,11 +557,7 @@ fileprivate extension FileManager {
 // MARK: - Critical Event Log Export
 
 extension CriticalEventLogExportManager {
-    private static var criticalEventLogHistoricalExportBackgroundTaskIdentifier: String { "com.loopkit.background-task.critical-event-log.historical-export" }
-
-    public static func registerCriticalEventLogHistoricalExportBackgroundTask(_ handler: @escaping (BGProcessingTask) -> Void) -> Bool {
-        return BGTaskScheduler.shared.register(forTaskWithIdentifier: criticalEventLogHistoricalExportBackgroundTaskIdentifier, using: nil) { handler($0 as! BGProcessingTask) }
-    }
+    static var historicalExportBackgroundTaskIdentifier: String { "com.loopkit.background-task.critical-event-log.historical-export" }
 
     public func handleCriticalEventLogHistoricalExportBackgroundTask(_ task: BGProcessingTask) {
         dispatchPrecondition(condition: .notOnQueue(.main))
@@ -602,7 +588,7 @@ extension CriticalEventLogExportManager {
     public func scheduleCriticalEventLogHistoricalExportBackgroundTask(isRetry: Bool = false) {
         do {
             let earliestBeginDate = isRetry ? retryExportHistoricalDate() : nextExportHistoricalDate()
-            let request = BGProcessingTaskRequest(identifier: Self.criticalEventLogHistoricalExportBackgroundTaskIdentifier)
+            let request = BGProcessingTaskRequest(identifier: Self.historicalExportBackgroundTaskIdentifier)
             request.earliestBeginDate = earliestBeginDate
             request.requiresExternalPower = true
 

Loop/Managers/DeviceDataManager.swift

@@ -288,7 +288,11 @@ final class DeviceDataManager {
         glucoseStore.delegate = self
         cgmEventStore.delegate = self
         doseStore.insulinDeliveryStore.delegate = self
-
+
+        Task {
+            await cgmStalenessMonitor.checkCGMStaleness()
+        }
+
         setupPump()
         setupCGM()
 
@@ -855,14 +859,17 @@ extension DeviceDataManager: PersistedAlertStore {
 // MARK: - CGMManagerDelegate
 extension DeviceDataManager: CGMManagerDelegate {
     nonisolated
-    func cgmManagerWantsDeletion(_ manager: CGMManager) {
-        DispatchQueue.main.async {
-            self.log.default("CGM manager with identifier '%{public}@' wants deletion", manager.pluginIdentifier)
-            if let cgmManagerUI = self.cgmManager as? CGMManagerUI {
-                self.displayGlucoseUnitBroadcaster?.removeDisplayGlucoseUnitObserver(cgmManagerUI)
+    func cgmManagerWantsDeletion(_ manager: CGMManager) async {
+        await withCheckedContinuation { continuation in
+            DispatchQueue.main.async {
+                self.log.default("CGM manager with identifier '%{public}@' wants deletion", manager.pluginIdentifier)
+                if let cgmManagerUI = self.cgmManager as? CGMManagerUI {
+                    self.displayGlucoseUnitBroadcaster?.removeDisplayGlucoseUnitObserver(cgmManagerUI)
+                }
+                self.cgmManager = nil
+                self.settingsManager.storeSettings()
+                continuation.resume()
             }
-            self.cgmManager = nil
-            self.settingsManager.storeSettings()
         }
     }
 
@@ -1175,57 +1182,38 @@ extension DeviceDataManager: CgmEventStoreDelegate {
 
 // MARK: - TestingPumpManager
 extension DeviceDataManager {
-    func deleteTestingPumpData(completion: ((Error?) -> Void)? = nil) {
+    func deleteTestingPumpData() async throws {
         guard let testingPumpManager = pumpManager as? TestingPumpManager else {
-            completion?(nil)
             return
         }
 
-        let devicePredicate = HKQuery.predicateForObjects(from: [testingPumpManager.testingDevice])
         let insulinDeliveryStore = doseStore.insulinDeliveryStore
 
-        Task {
-            do {
-                try await doseStore.resetPumpData()
-            } catch {
-                completion?(error)
-                return
-            }
+        try await doseStore.resetPumpData()
 
-            let insulinSharingDenied = self.healthStore.authorizationStatus(for: HealthKitSampleStore.insulinQuantityType) == .sharingDenied
-            guard !insulinSharingDenied else {
-                // only clear cache since access to health kit is denied
-                insulinDeliveryStore.purgeCachedInsulinDeliveryObjects() { error in
-                    completion?(error)
-                }
-                return
-            }
-
-            insulinDeliveryStore.purgeAllDoseEntries(healthKitPredicate: devicePredicate) { error in
-                completion?(error)
-            }
+        let insulinSharingDenied = self.healthStore.authorizationStatus(for: HealthKitSampleStore.insulinQuantityType) == .sharingDenied
+        guard !insulinSharingDenied else {
+            // only clear cache since access to health kit is denied
+            await insulinDeliveryStore.purgeCachedInsulinDeliveryObjects()
+            return
         }
+
+        try await insulinDeliveryStore.purgeDoseEntriesForDevice(testingPumpManager.testingDevice)
     }
 
-    func deleteTestingCGMData(completion: ((Error?) -> Void)? = nil) {
+    func deleteTestingCGMData() async throws {
         guard let testingCGMManager = cgmManager as? TestingCGMManager else {
-            completion?(nil)
             return
         }
-        
+
         let glucoseSharingDenied = self.healthStore.authorizationStatus(for: HealthKitSampleStore.glucoseType) == .sharingDenied
         guard !glucoseSharingDenied else {
             // only clear cache since access to health kit is denied
-            glucoseStore.purgeCachedGlucoseObjects() { error in
-                completion?(error)
-            }
+            try await glucoseStore.purgeCachedGlucoseObjects()
             return
         }
 
-        let predicate = HKQuery.predicateForObjects(from: [testingCGMManager.testingDevice])
-        glucoseStore.purgeAllGlucoseSamples(healthKitPredicate: predicate) { error in
-            completion?(error)
-        }
+        try await glucoseStore.purgeAllGlucose(for: testingCGMManager.testingDevice)
     }
 }
 

Loop/Managers/LoopAppManager.swift

@@ -8,6 +8,7 @@
 
 import UIKit
 import Intents
+import BackgroundTasks
 import Combine
 import LoopKit
 import LoopKitUI
@@ -133,9 +134,27 @@ class LoopAppManager: NSObject {
         self.state = state.next
     }
 
+    func registerBackgroundTasks() {
+        let taskIdentifier = CriticalEventLogExportManager.historicalExportBackgroundTaskIdentifier
+        let registered = BGTaskScheduler.shared.register(forTaskWithIdentifier: taskIdentifier, using: nil) { task in
+            guard let criticalEventLogExportManager = self.criticalEventLogExportManager else {
+                self.log.error("Critical event log export launch handler called before initialization complete!")
+                return
+            }
+            criticalEventLogExportManager.handleCriticalEventLogHistoricalExportBackgroundTask(task as! BGProcessingTask)
+        }
+        if registered {
+            log.debug("Critical event log export background task registered")
+        } else {
+            log.error("Critical event log export background task not registered")
+        }
+    }
+
     func launch() {
         precondition(isLaunchPending)
 
+        registerBackgroundTasks()
+
         Task {
             await resumeLaunch()
         }
@@ -248,7 +267,7 @@ class LoopAppManager: NSObject {
             observationStart: Date().addingTimeInterval(-CarbMath.maximumAbsorptionTimeInterval)
         )
 
-        self.doseStore = DoseStore(
+        self.doseStore = await DoseStore(
             healthKitSampleStore: insulinHealthStore,
             cacheStore: cacheStore,
             cacheLength: localCacheDuration,
@@ -263,7 +282,7 @@ class LoopAppManager: NSObject {
             observationStart: Date().addingTimeInterval(-.hours(24))
         )
 
-        self.glucoseStore = GlucoseStore(
+        self.glucoseStore = await GlucoseStore(
             healthKitSampleStore: glucoseHealthStore,
             cacheStore: cacheStore,
             cacheLength: localCacheDuration,
@@ -390,9 +409,6 @@ class LoopAppManager: NSObject {
                                                                       directory: FileManager.default.exportsDirectoryURL,
                                                                       historicalDuration: localCacheDuration)
 
-        criticalEventLogExportManager.registerBackgroundTasks()
-
-
         statusExtensionManager = ExtensionDataManager(
             deviceDataManager: deviceDataManager,
             loopDataManager: loopDataManager,
@@ -892,8 +908,16 @@ extension LoopAppManager: ResetLoopManagerDelegate {
     }
 
     func resetTestingData(completion: @escaping () -> Void) {
-        deviceDataManager.deleteTestingCGMData { [weak deviceDataManager] _ in
-            deviceDataManager?.deleteTestingPumpData { _ in
+        Task { [weak self] in
+            await withTaskGroup(of: Void.self) { group in
+                group.addTask {
+                    try? await self?.deviceDataManager.deleteTestingCGMData()
+                }
+                group.addTask {
+                    try? await self?.deviceDataManager?.deleteTestingPumpData()
+                }
+
+                await group.waitForAll()
                 completion()
             }
         }
@@ -1045,6 +1069,7 @@ extension LoopAppManager: SimulatedData {
                 Task { @MainActor in
                     do {
                         try await self.doseStore.purgeHistoricalPumpEvents()
+                        try await self.glucoseStore.purgeHistoricalGlucoseObjects()
                     } catch {
                         completion(error)
                         return
@@ -1059,13 +1084,7 @@ extension LoopAppManager: SimulatedData {
                                 completion(error)
                                 return
                             }
-                            self.glucoseStore.purgeHistoricalGlucoseObjects() { error in
-                                guard error == nil else {
-                                    completion(error)
-                                    return
-                                }
-                                self.settingsManager.purgeHistoricalSettingsObjects(completion: completion)
-                            }
+                            self.settingsManager.purgeHistoricalSettingsObjects(completion: completion)
                         }
                     }
                 }

Loop/Managers/LoopDataManager.swift

@@ -225,6 +225,19 @@ final class LoopDataManager: ObservableObject {
                     await self.updateDisplayState()
                     self.notify(forChange: .insulin)
                 }
+            },
+            NotificationCenter.default.addObserver(
+                forName: .LoopDataUpdated,
+                object: nil,
+                queue: nil
+            ) { (note) in
+                let context = note.userInfo?[LoopDataManager.LoopUpdateContextKey] as! LoopUpdateContext.RawValue
+                if case .preferences = LoopUpdateContext(rawValue: context) {
+                    Task { @MainActor in
+                        self.logger.default("Received notification of settings changing")
+                        await self.updateDisplayState()
+                    }
+                }
             }
         ]
 
@@ -330,7 +343,7 @@ final class LoopDataManager: ObservableObject {
             throw LoopError.configurationError(.basalRateSchedule)
         }
 
-        let forecastEndTime = baseTime.addingTimeInterval(InsulinMath.defaultInsulinActivityDuration).dateCeiledToTimeInterval(.minutes(GlucoseMath.defaultDelta))
+        let forecastEndTime = baseTime.addingTimeInterval(InsulinMath.defaultInsulinActivityDuration).dateCeiledToTimeInterval(GlucoseMath.defaultDelta)
 
         let carbsStart = baseTime.addingTimeInterval(CarbMath.dateAdjustmentPast + .minutes(-1)) // additional minute to handle difference in seconds between carb entry and carb ratio
 
@@ -353,9 +366,24 @@ final class LoopDataManager: ObservableObject {
 
         let glucose = try await glucoseStore.getGlucoseSamples(start: carbsStart, end: baseTime)
 
-        let sensitivityStart = min(carbsStart, dosesStart)
+        let dosesWithModel = doses.map { $0.simpleDose(with: insulinModel(for: $0.insulinType)) }
+
+        let recommendationInsulinModel = insulinModel(for: deliveryDelegate?.pumpInsulinType ?? .novolog)
+
+        let recommendationEffectInterval = DateInterval(
+            start: baseTime,
+            duration: recommendationInsulinModel.effectDuration
+        )
+        let neededSensitivityTimeline = LoopAlgorithm.timelineIntervalForSensitivity(
+            doses: dosesWithModel,
+            glucoseHistoryStart: glucose.first?.startDate ?? baseTime,
+            recommendationEffectInterval: recommendationEffectInterval
+        )
 
-        let sensitivity = try await settingsProvider.getInsulinSensitivityHistory(startDate: sensitivityStart, endDate: forecastEndTime)
+        let sensitivity = try await settingsProvider.getInsulinSensitivityHistory(
+            startDate: neededSensitivityTimeline.start,
+            endDate: neededSensitivityTimeline.end
+        )
 
         let target = try await settingsProvider.getTargetRangeHistory(startDate: baseTime, endDate: forecastEndTime)
 
@@ -369,7 +397,7 @@ final class LoopDataManager: ObservableObject {
             throw LoopError.configurationError(.maximumBasalRatePerHour)
         }
 
-        var overrides = temporaryPresetsManager.overrideHistory.getOverrideHistory(startDate: sensitivityStart, endDate: forecastEndTime)
+        var overrides = temporaryPresetsManager.overrideHistory.getOverrideHistory(startDate: neededSensitivityTimeline.start, endDate: forecastEndTime)
 
         // Bug (https://tidepool.atlassian.net/browse/LOOP-4759) pre-meal is not recorded in override history
         // So currently we handle automatic forecast by manually adding it in, and when meal bolusing, we do not do this.
@@ -420,7 +448,7 @@ final class LoopDataManager: ObservableObject {
 
         return StoredDataAlgorithmInput(
             glucoseHistory: glucose,
-            doses: doses.map { $0.simpleDose(with: insulinModel(for: $0.insulinType)) },
+            doses: dosesWithModel,
             carbEntries: carbEntries,
             predictionStart: baseTime,
             basal: basalWithOverrides,
@@ -433,7 +461,7 @@ final class LoopDataManager: ObservableObject {
             useIntegralRetrospectiveCorrection: UserDefaults.standard.integralRetrospectiveCorrectionEnabled,
             includePositiveVelocityAndRC: true,
             carbAbsorptionModel: carbAbsorptionModel,
-            recommendationInsulinModel: insulinModel(for: deliveryDelegate?.pumpInsulinType ?? .novolog),
+            recommendationInsulinModel: recommendationInsulinModel,
             recommendationType: .manualBolus,
             automaticBolusApplicationFactor: effectiveBolusApplicationFactor)
     }
@@ -1012,6 +1040,7 @@ extension StoredDataAlgorithmInput {
             carbRatio: carbRatio,
             algorithmEffectsOptions: effectsOptions,
             useIntegralRetrospectiveCorrection: self.useIntegralRetrospectiveCorrection,
+            useMidAbsorptionISF: true,
             carbAbsorptionModel: self.carbAbsorptionModel.model
         )
         return prediction.glucose

Loop/Managers/OnboardingManager.swift

@@ -429,22 +429,6 @@ extension OnboardingManager: ServiceProvider {
     var activeServices: [Service] { servicesManager.activeServices }
 
     var availableServices: [ServiceDescriptor] { servicesManager.availableServices }
-
-    func onboardService(withIdentifier identifier: String) -> Swift.Result<OnboardingResult<ServiceViewController, Service>, Error> {
-        guard let service = activeServices.first(where: { $0.pluginIdentifier == identifier }) else {
-            return servicesManager.setupService(withIdentifier: identifier)
-        }
-
-        if service.isOnboarded {
-            return .success(.createdAndOnboarded(service))
-        }
-
-        guard let serviceUI = service as? ServiceUI else {
-            return .failure(OnboardingError.invalidState)
-        }
-
-        return .success(.userInteractionRequired(serviceUI.settingsViewController(colorPalette: .default)))
-    }
 }
 
 // MARK: - TherapySettingsProvider
@@ -455,10 +439,22 @@ extension OnboardingManager: TherapySettingsProvider {
     }
 }
 
+// MARK: - PluginHost
+
+extension OnboardingManager: PluginHost {
+    nonisolated var hostIdentifier: String {
+        return Bundle.main.hostIdentifier
+    }
+
+    nonisolated var hostVersion: String {
+        return Bundle.main.hostVersion
+    }
+}
+
 // MARK: - OnboardingProvider
 
 extension OnboardingManager: OnboardingProvider {
-    var allowDebugFeatures: Bool { FeatureFlags.allowDebugFeatures }   // NOTE: DEBUG FEATURES - DEBUG AND TEST ONLY
+    nonisolated var allowDebugFeatures: Bool { FeatureFlags.allowDebugFeatures }   // NOTE: DEBUG FEATURES - DEBUG AND TEST ONLY
 }
 
 // MARK: - SupportProvider

Loop/Managers/RemoteDataServicesManager.swift

@@ -431,24 +431,22 @@ extension RemoteDataServicesManager {
             let previousQueryAnchor = UserDefaults.appGroup?.getQueryAnchor(for: remoteDataService, withRemoteDataType: .glucose) ?? GlucoseStore.QueryAnchor()
             var continueUpload = false
 
-            self.glucoseStore.executeGlucoseQuery(fromQueryAnchor: previousQueryAnchor, limit: remoteDataService.glucoseDataLimit ?? Int.max) { result in
-                switch result {
-                case .failure(let error):
+            Task {
+                do {
+                    let (queryAnchor, data) = try await self.glucoseStore.executeGlucoseQuery(fromQueryAnchor: previousQueryAnchor, limit: remoteDataService.glucoseDataLimit ?? Int.max)
+                    do {
+                        try await remoteDataService.uploadGlucoseData(data)
+                        UserDefaults.appGroup?.setQueryAnchor(for: remoteDataService, withRemoteDataType: .glucose, queryAnchor)
+                        continueUpload = queryAnchor != previousQueryAnchor
+                        await self.uploadSucceeded(key)
+                    } catch {
+                        self.log.error("Error synchronizing glucose data: %{public}@", String(describing: error))
+                        await self.uploadFailed(key)
+                    }
+                    semaphore.signal()
+                } catch {
                     self.log.error("Error querying glucose data: %{public}@", String(describing: error))
                     semaphore.signal()
-                case .success(let queryAnchor, let data):
-                    Task {
-                        do {
-                            try await remoteDataService.uploadGlucoseData(data)
-                            UserDefaults.appGroup?.setQueryAnchor(for: remoteDataService, withRemoteDataType: .glucose, queryAnchor)
-                            continueUpload = queryAnchor != previousQueryAnchor
-                            self.uploadSucceeded(key)
-                        } catch {
-                            self.log.error("Error synchronizing glucose data: %{public}@", String(describing: error))
-                            self.uploadFailed(key)
-                        }
-                        semaphore.signal()
-                    }
                 }
             }
 
@@ -472,25 +470,22 @@ extension RemoteDataServicesManager {
             let semaphore = DispatchSemaphore(value: 0)
             let previousQueryAnchor = UserDefaults.appGroup?.getQueryAnchor(for: remoteDataService, withRemoteDataType: .pumpEvent) ?? DoseStore.QueryAnchor()
             var continueUpload = false
-
-            self.doseStore.executePumpEventQuery(fromQueryAnchor: previousQueryAnchor, limit: remoteDataService.pumpEventDataLimit ?? Int.max) { result in
-                switch result {
-                case .failure(let error):
+            Task {
+                do {
+                    let (queryAnchor, data) = try await self.doseStore.executePumpEventQuery(fromQueryAnchor: previousQueryAnchor, limit: remoteDataService.pumpEventDataLimit ?? Int.max)
+                    do {
+                        try await remoteDataService.uploadPumpEventData(data)
+                        UserDefaults.appGroup?.setQueryAnchor(for: remoteDataService, withRemoteDataType: .pumpEvent, queryAnchor)
+                        continueUpload = queryAnchor != previousQueryAnchor
+                        self.uploadSucceeded(key)
+                    } catch {
+                        self.log.error("Error synchronizing pump event data: %{public}@", String(describing: error))
+                        self.uploadFailed(key)
+                    }
+                    semaphore.signal()
+                } catch {
                     self.log.error("Error querying pump event data: %{public}@", String(describing: error))
                     semaphore.signal()
-                case .success(let queryAnchor, let data):
-                    Task {
-                        do {
-                            try await remoteDataService.uploadPumpEventData(data)
-                            UserDefaults.appGroup?.setQueryAnchor(for: remoteDataService, withRemoteDataType: .pumpEvent, queryAnchor)
-                            continueUpload = queryAnchor != previousQueryAnchor
-                            self.uploadSucceeded(key)
-                        } catch {
-                            self.log.error("Error synchronizing pump event data: %{public}@", String(describing: error))
-                            self.uploadFailed(key)
-                        }
-                        semaphore.signal()
-                    }
                 }
             }
 

Loop/Managers/ServicesManager.swift

@@ -259,31 +259,20 @@ extension ServicesManager: StatefulPluggableDelegate {
     }
 }
 
-// MARK: - ServiceDelegate
-
-extension ServicesManager: ServiceDelegate {
-    var hostIdentifier: String {
-        var identifier = Bundle.main.bundleIdentifier ?? "com.loopkit.Loop"
-        let components = identifier.components(separatedBy: ".")
-        // DIY Loop has bundle identifiers like com.UY653SP37Q.loopkit.Loop
-        if components[2] == "loopkit" && components[3] == "Loop" {
-            identifier = "com.loopkit.Looo"
-        }
-        return identifier
+// MARK: - PluginHost
+extension ServicesManager: PluginHost {
+    nonisolated var hostIdentifier: String {
+        return Bundle.main.hostIdentifier
     }
 
-    var hostVersion: String {
-        var semanticVersion = Bundle.main.shortVersionString
-
-        while semanticVersion.split(separator: ".").count < 3 {
-            semanticVersion += ".0"
-        }
+    nonisolated var hostVersion: String {
+        return Bundle.main.hostVersion
+    }
+}
 
-        semanticVersion += "+\(Bundle.main.version)"
+// MARK: - ServiceDelegate
 
-        return semanticVersion
-    }
-
+extension ServicesManager: ServiceDelegate {
     func enactRemoteOverride(name: String, durationTime: TimeInterval?, remoteAddress: String) async throws {
 
         var duration: TemporaryScheduleOverride.Duration? = nil

Loop/Managers/TestingScenariosManager.swift

@@ -230,67 +230,68 @@ extension TestingScenariosManager {
             completion(error)
         }
 
-        Task {
-            guard FeatureFlags.scenariosEnabled else {
-                fatalError("\(#function) should be invoked only when scenarios are enabled")
-            }
-
-            let instance = scenario.instantiate()
-
-            var testingCGMManager: TestingCGMManager?
-            var testingPumpManager: TestingPumpManager?
-
-            if instance.hasCGMData {
-                if let cgmManager = deviceManager.cgmManager as? TestingCGMManager {
-                    if instance.shouldReloadManager?.cgm == true {
-                            testingCGMManager = await reloadCGMManager(withIdentifier: cgmManager.pluginIdentifier)
-                    } else {
-                        testingCGMManager = cgmManager
-                    }
-                } else {
-                    bail(with: ScenarioLoadingError.noTestingCGMManagerEnabled)
-                    return
+        guard FeatureFlags.scenariosEnabled else {
+            fatalError("\(#function) should be invoked only when scenarios are enabled")
+        }
+
+        Task { [weak self] in
+            do {
+                try await self?.wipeExistingData()
+                let instance = scenario.instantiate()
+
+                let _: Void = try await withCheckedThrowingContinuation { continuation in
+                    self?.carbStore.addNewCarbEntries(entries: instance.carbEntries, completion: { error in
+                        if let error {
+                            continuation.resume(throwing: error)
+                        } else {
+                            continuation.resume()
+                        }
+                    })
                 }
-            }
-
-            if instance.hasPumpData {
-                if let pumpManager = deviceManager.pumpManager as? TestingPumpManager {
-                    if instance.shouldReloadManager?.pump == true {
-                        testingPumpManager = reloadPumpManager(withIdentifier: pumpManager.pluginIdentifier)
+
+                var testingCGMManager: TestingCGMManager?
+                var testingPumpManager: TestingPumpManager?
+
+                if instance.hasCGMData {
+                    if let cgmManager = self?.deviceManager.cgmManager as? TestingCGMManager {
+                        if instance.shouldReloadManager?.cgm == true {
+                            testingCGMManager = await self?.reloadCGMManager(withIdentifier: cgmManager.pluginIdentifier)
+                        } else {
+                            testingCGMManager = cgmManager
+                        }
                     } else {
-                        testingPumpManager = pumpManager
+                        bail(with: ScenarioLoadingError.noTestingCGMManagerEnabled)
+                        return
                     }
-                } else {
-                    bail(with: ScenarioLoadingError.noTestingPumpManagerEnabled)
-                    return
-                }
-            }
-
-            wipeExistingData { error in
-                guard error == nil else {
-                    bail(with: error!)
-                    return
                 }
-
-                self.carbStore.addNewCarbEntries(entries: instance.carbEntries) { error in
-                    if let error {
-                        bail(with: error)
+
+                if instance.hasPumpData {
+                    if let pumpManager = self?.deviceManager.pumpManager as? TestingPumpManager {
+                        if instance.shouldReloadManager?.pump == true {
+                            testingPumpManager = self?.reloadPumpManager(withIdentifier: pumpManager.pluginIdentifier)
+                        } else {
+                            testingPumpManager = pumpManager
+                        }
                     } else {
-                        testingPumpManager?.reservoirFillFraction = 1.0
-                        testingPumpManager?.injectPumpEvents(instance.pumpEvents)
-                        testingCGMManager?.injectGlucoseSamples(instance.pastGlucoseSamples, futureSamples: instance.futureGlucoseSamples)
-                        self.activeScenario = scenario
-                        completion(nil)
+                        bail(with: ScenarioLoadingError.noTestingPumpManagerEnabled)
+                        return
                     }
                 }
-            }
-
-            instance.deviceActions.forEach { [testingCGMManager, testingPumpManager] action in
-                if testingCGMManager?.pluginIdentifier == action.managerIdentifier {
+
+                testingPumpManager?.reservoirFillFraction = 1.0
+                testingPumpManager?.injectPumpEvents(instance.pumpEvents)
+                testingCGMManager?.injectGlucoseSamples(instance.pastGlucoseSamples, futureSamples: instance.futureGlucoseSamples)
+
+                self?.activeScenario = scenario
+
+                instance.deviceActions.forEach { [testingCGMManager, testingPumpManager] action in
                     testingCGMManager?.trigger(action: action)
-                } else if testingPumpManager?.pluginIdentifier == action.managerIdentifier {
                     testingPumpManager?.trigger(action: action)
                 }
+
+                completion(nil)
+            } catch {
+                bail(with: error)
             }
         }
     }
@@ -343,32 +344,21 @@ extension TestingScenariosManager {
         }
     }
 
-    private func wipeExistingData(completion: @escaping (Error?) -> Void) {
+    private func wipeExistingData() async throws {
         guard FeatureFlags.scenariosEnabled else {
             fatalError("\(#function) should be invoked only when scenarios are enabled")
         }
 
-        deviceManager.deleteTestingPumpData { error in
-            guard error == nil else {
-                completion(error!)
-                return
-            }
-
-            self.deviceManager.deleteTestingCGMData { error in
-                guard error == nil else {
-                    completion(error!)
-                    return
-                }
-
-                self.carbStore.deleteAllCarbEntries() { error in
-                    guard error == nil else {
-                        completion(error!)
-                        return
-                    }
-
-                    self.deviceManager.alertManager.alertStore.purge(before: Date(), completion: completion)
-                }
-            }
+        try await deviceManager.deleteTestingPumpData()
+
+        try await deviceManager.deleteTestingCGMData()
+
+        try await carbStore.deleteAllCarbEntries()
+
+        await withCheckedContinuation { [weak alertStore = deviceManager.alertManager.alertStore] continuation in
+            alertStore?.purge(before: Date(), completion: { _ in
+                continuation.resume()
+            })
         }
     }
 }
@@ -377,13 +367,17 @@ extension TestingScenariosManager {
 private extension CarbStore {
 
     /// Errors if getting carb entries errors, or if deleting any individual entry errors.
-    func deleteAllCarbEntries(completion: @escaping (Error?) -> Void) {
-        getCarbEntries() { result in
-            switch result {
-            case .success(let entries):
-                self.deleteCarbEntries(entries[...], completion: completion)
-            case .failure(let error):
-                completion(error)
+    func deleteAllCarbEntries() async throws {
+        try await withCheckedThrowingContinuation { continuation in
+            getCarbEntries() { result in
+                switch result {
+                case .success(let entries):
+                    self.deleteCarbEntries(entries[...], completion: { _ in
+                        continuation.resume()
+                    })
+                case .failure(let error):
+                    continuation.resume(throwing: error)
+                }
             }
         }
     }

Loop/Managers/WatchDataManager.swift

@@ -205,12 +205,14 @@ final class WatchDataManager: NSObject {
             return
         }
 
+        log.default("*** sendWatchContextIfNeeded")
+
         guard case .activated = session.activationState else {
             session.activate()
             return
         }
 
-        Task { @MainActor in
+        Task {
             let context = await createWatchContext()
             self.sendWatchContext(context)
         }
@@ -464,13 +466,13 @@ extension WatchDataManager: WCSessionDelegate {
             }
         case GlucoseBackfillRequestUserInfo.name?:
             if let userInfo = GlucoseBackfillRequestUserInfo(rawValue: message) {
-                glucoseStore.getSyncGlucoseSamples(start: userInfo.startDate.addingTimeInterval(1)) { (result) in
-                    switch result {
-                    case .failure(let error):
+                Task {
+                    do {
+                        let samples = try await glucoseStore.getSyncGlucoseSamples(start: userInfo.startDate.addingTimeInterval(1))
+                        replyHandler(WatchHistoricalGlucose(samples: samples).rawValue)
+                    } catch {
                         self.log.error("Failure getting sync glucose objects: %{public}@", String(describing: error))
                         replyHandler([:])
-                    case .success(let samples):
-                        replyHandler(WatchHistoricalGlucose(samples: samples).rawValue)
                     }
                 }
             } else {

Loop/Models/StoredDataAlgorithmInput.swift

@@ -51,4 +51,6 @@ struct StoredDataAlgorithmInput: AlgorithmInput {
     var recommendationType: DoseRecommendationType
 
     var automaticBolusApplicationFactor: Double?
+
+    let useMidAbsorptionISF: Bool = true
 }

Loop/View Controllers/InsulinDeliveryTableViewController.swift

@@ -201,7 +201,7 @@ public final class InsulinDeliveryTableViewController: UITableViewController {
         case manualEntryDoses([DoseEntry])
     }
 
-    private enum HistorySection: Int {
+    fileprivate enum HistorySection: Int {
         case today
         case yesterday
     }
@@ -401,7 +401,7 @@ public final class InsulinDeliveryTableViewController: UITableViewController {
             return 0
         case .display:
             switch self.values {
-            case .history(let values): return values.valuesBeforeToday.isEmpty ? 1 : 2
+            case .history(let pumpEvents): return pumpEvents.pumpEventsBeforeToday.isEmpty ? 1 : 2
             default: return 1
             }
         }
@@ -411,10 +411,10 @@ public final class InsulinDeliveryTableViewController: UITableViewController {
         switch values {
         case .reservoir(let values):
             return values.count
-        case .history(let values):
+        case .history(let pumpEvents):
             switch HistorySection(rawValue: section) {
-            case .today: return values.valuesFromToday.count
-            case .yesterday: return values.valuesBeforeToday.count
+            case .today: return pumpEvents.pumpEventsFromToday.count
+            case .yesterday: return pumpEvents.pumpEventsBeforeToday.count
             case .none: return 0
             }
         case .manualEntryDoses(let values):
@@ -426,13 +426,13 @@ public final class InsulinDeliveryTableViewController: UITableViewController {
         switch state {
         case .display:
             switch self.values {
-            case .history(let values):
+            case .history(let pumpEvents):
                 switch HistorySection(rawValue: section) {
                 case .today:
-                    guard let firstValue = values.valuesFromToday.first else { return nil }
+                    guard let firstValue = pumpEvents.pumpEventsFromToday.first else { return nil }
                     return dateFormatter.string(from: firstValue.date).uppercased()
                 case .yesterday:
-                    guard let firstValue = values.valuesBeforeToday.first else { return nil }
+                    guard let firstValue = pumpEvents.pumpEventsBeforeToday.first else { return nil }
                     return dateFormatter.string(from: firstValue.date).uppercased()
                 case .none: return nil
                 }
@@ -457,24 +457,18 @@ public final class InsulinDeliveryTableViewController: UITableViewController {
                 cell.detailTextLabel?.text = time
                 cell.accessoryType = .none
                 cell.selectionStyle = .none
-            case .history(let values):
-                let filterValues: [PersistedPumpEvent]
-                if HistorySection(rawValue: indexPath.section) == .today {
-                    filterValues = values.valuesFromToday
-                } else {
-                    filterValues = values.valuesBeforeToday
-                }
-                let entry = filterValues[indexPath.row]
-                let time = timeFormatter.string(from: entry.date)
+            case .history(let pumpEvents):
+                let pumpEvent = pumpEvents.pumpEventForIndexPath(indexPath)
+                let time = timeFormatter.string(from: pumpEvent.date)
 
-                if let attributedText = entry.localizedAttributedDescription {
+                if let attributedText = pumpEvent.localizedAttributedDescription {
                     cell.textLabel?.attributedText = attributedText
                 } else {
                     cell.textLabel?.text = NSLocalizedString("Unknown", comment: "The default description to use when an entry has no dose description")
                 }
 
                 cell.detailTextLabel?.text = time
-                cell.accessoryType = entry.isUploaded ? .checkmark : .none
+                cell.accessoryType = pumpEvent.isUploaded ? .checkmark : .none
                 cell.selectionStyle = .default
             case .manualEntryDoses(let values):
                 let entry = values[indexPath.row]
@@ -517,14 +511,13 @@ public final class InsulinDeliveryTableViewController: UITableViewController {
                         }
                     }
                 }
-            case .history(let historyValues):
-                var historyValues = historyValues
-                let value = historyValues.remove(at: indexPath.row)
-                self.values = .history(historyValues)
+            case .history(let pumpEvents):
+                let pumpEvent = pumpEvents.pumpEventForIndexPath(indexPath)
+                self.values = .history(pumpEvents.filter { $0.dose != pumpEvent.dose })
 
                 tableView.deleteRows(at: [indexPath], with: .automatic)
 
-                doseStore?.deletePumpEvent(value) { (error) -> Void in
+                doseStore?.deletePumpEvent(pumpEvent) { (error) -> Void in
                     if let error = error {
                         DispatchQueue.main.async {
                             self.present(UIAlertController(with: error), animated: true)
@@ -555,23 +548,23 @@ public final class InsulinDeliveryTableViewController: UITableViewController {
     }
 
     public override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
-        if case .display = state, case .history(let history) = values {
-            let entry = history[indexPath.row]
+        if case .display = state, case .history(let pumpEvents) = values {
+            let pumpEvent = pumpEvents.pumpEventForIndexPath(indexPath)
 
             let vc = CommandResponseViewController(command: { (completionHandler) -> String in
                 var description = [String]()
 
-                description.append(self.timeFormatter.string(from: entry.date))
+                description.append(self.timeFormatter.string(from: pumpEvent.date))
 
-                if let title = entry.title {
+                if let title = pumpEvent.title {
                     description.append(title)
                 }
 
-                if let dose = entry.dose {
+                if let dose = pumpEvent.dose {
                     description.append(String(describing: dose))
                 }
 
-                if let raw = entry.raw {
+                if let raw = pumpEvent.raw {
                     description.append(raw.hexadecimalString)
                 }
 
@@ -688,13 +681,23 @@ extension PersistedPumpEvent {
 extension InsulinDeliveryTableViewController: IdentifiableClass { }
 
 fileprivate extension Array where Element == PersistedPumpEvent {
-    var valuesFromToday: [PersistedPumpEvent] {
+    var pumpEventsFromToday: [PersistedPumpEvent] {
         let startOfDay = Calendar.current.startOfDay(for: Date())
         return self.filter({ $0.date >= startOfDay})
     }
 
-    var valuesBeforeToday: [PersistedPumpEvent] {
+    var pumpEventsBeforeToday: [PersistedPumpEvent] {
         let startOfDay = Calendar.current.startOfDay(for: Date())
         return self.filter({ $0.date < startOfDay})
     }
+
+    func pumpEventForIndexPath(_ indexPath: IndexPath) -> PersistedPumpEvent {
+        let filterPumpEvents: [PersistedPumpEvent]
+        if InsulinDeliveryTableViewController.HistorySection(rawValue: indexPath.section) == .today {
+            filterPumpEvents = self.pumpEventsFromToday
+        } else {
+            filterPumpEvents = self.pumpEventsBeforeToday
+        }
+        return filterPumpEvents[indexPath.row]
+    }
 }

Loop/View Controllers/StatusTableViewController.swift

@@ -1599,13 +1599,13 @@ final class StatusTableViewController: LoopChartsTableViewController {
     private func presentSettings() {
         let deletePumpDataFunc: () -> PumpManagerViewModel.DeleteTestingDataFunc? = { [weak self] in
             (self?.deviceManager.pumpManager is TestingPumpManager) ? {
-                [weak self] in self?.deviceManager.deleteTestingPumpData()
-                } : nil
+                Task { [weak self] in try? await self?.deviceManager.deleteTestingPumpData()
+                }} : nil
         }
         let deleteCGMDataFunc: () -> CGMManagerViewModel.DeleteTestingDataFunc? = { [weak self] in
             (self?.deviceManager.cgmManager is TestingCGMManager) ? {
-                [weak self] in self?.deviceManager.deleteTestingCGMData()
-                } : nil
+                Task { [weak self] in try? await self?.deviceManager.deleteTestingCGMData()
+                }} : nil
         }
         let pumpViewModel = PumpManagerViewModel(
             image: { [weak self] in (self?.deviceManager.pumpManager as? PumpManagerUI)?.smallImage },

LoopTests/Managers/CGMStalenessMonitorTests.swift

@@ -30,7 +30,7 @@ class CGMStalenessMonitorTests: XCTestCase {
         XCTAssert(monitor.cgmDataIsStale)
     }
 
-    func testStalenessWithRecentCMGSample() {
+    func testStalenessWithRecentCMGSample() async throws {
         let monitor = CGMStalenessMonitor()
         fetchExpectation = expectation(description: "Fetch latest cgm glucose")
         latestCGMGlucose = storedGlucoseSample
@@ -46,13 +46,16 @@ class CGMStalenessMonitorTests: XCTestCase {
         }
 
         monitor.delegate = self
-        waitForExpectations(timeout: 2)
-
+
+        await monitor.checkCGMStaleness()
+
+        await fulfillment(of: [fetchExpectation!, exp], timeout: 2)
+
         XCTAssertNotNil(cancelable)
         XCTAssertEqual(receivedValues, [true, false])
     }
 
-    func testStalenessWithNoRecentCGMData() {
+    func testStalenessWithNoRecentCGMData() async throws {
         let monitor = CGMStalenessMonitor()
         fetchExpectation = expectation(description: "Fetch latest cgm glucose")
         latestCGMGlucose = nil
@@ -68,13 +71,16 @@ class CGMStalenessMonitorTests: XCTestCase {
         }
 
         monitor.delegate = self
-        waitForExpectations(timeout: 2)
-
+
+        await monitor.checkCGMStaleness()
+
+        await fulfillment(of: [fetchExpectation!, exp], timeout: 2)
+
         XCTAssertNotNil(cancelable)
         XCTAssertEqual(receivedValues, [true, true])
     }
 
-    func testStalenessNewReadingsArriving() {
+    func testStalenessNewReadingsArriving() async throws {
         let monitor = CGMStalenessMonitor()
         fetchExpectation = expectation(description: "Fetch latest cgm glucose")
         latestCGMGlucose = nil
@@ -90,19 +96,21 @@ class CGMStalenessMonitorTests: XCTestCase {
         }
 
         monitor.delegate = self
-
+
+        await monitor.checkCGMStaleness()
+
         monitor.cgmGlucoseSamplesAvailable([newGlucoseSample])
-        
-        waitForExpectations(timeout: 2)
-        
+
+        await fulfillment(of: [fetchExpectation!, exp], timeout: 2)
+
         XCTAssertNotNil(cancelable)
-        XCTAssertEqual(receivedValues, [true, false])
+        XCTAssertEqual(receivedValues, [true, true, false])
     }
 }
 
 extension CGMStalenessMonitorTests: CGMStalenessMonitorDelegate {
-    func getLatestCGMGlucose(since: Date, completion: @escaping (Result<StoredGlucoseSample?, Error>) -> Void) {
-        completion(.success(latestCGMGlucose))
+    public func getLatestCGMGlucose(since: Date) async throws -> StoredGlucoseSample? {
         fetchExpectation?.fulfill()
+        return latestCGMGlucose
     }
 }

LoopTests/Managers/DeviceDataManagerTests.swift

@@ -34,7 +34,7 @@ final class DeviceDataManagerTests: XCTestCase {
         }
     }
 
-    override func setUpWithError() throws {
+    override func setUp() async throws {
         let mockUserNotificationCenter = MockUserNotificationCenter()
         let mockBluetoothProvider = MockBluetoothProvider()
         let alertPresenter = MockPresenter()
@@ -56,7 +56,7 @@ final class DeviceDataManagerTests: XCTestCase {
             cacheLength: .days(1)
         )
 
-        let doseStore = DoseStore(
+        let doseStore = await DoseStore(
             cacheStore: persistenceController
         )
 
@@ -72,8 +72,7 @@ final class DeviceDataManagerTests: XCTestCase {
         }
         let deviceLog = PersistentDeviceLog(storageFile: deviceLogDirectory.appendingPathComponent("Storage.sqlite"))
 
-
-        let glucoseStore = GlucoseStore(cacheStore: persistenceController)
+        let glucoseStore = await GlucoseStore(cacheStore: persistenceController)
 
         let cgmEventStore = CgmEventStore(cacheStore: persistenceController)
 

LoopTests/Managers/MealDetectionManagerTests.swift

@@ -234,8 +234,7 @@ class MealDetectionManagerTests: XCTestCase {
             includePositiveVelocityAndRC: true,
             carbAbsorptionModel: .piecewiseLinear,
             recommendationInsulinModel: ExponentialInsulinModelPreset.rapidActingAdult.model,
-            recommendationType: .automaticBolus
-        )
+            recommendationType: .automaticBolus)
 
         // These tests don't actually run the loop algorithm directly; they were written to take ICE from fixtures, compute carb effects, and subtract them.
         let counteractionEffects = counteractionEffects(for: testType)

WatchApp Extension/Managers/LoopDataManager.swift

@@ -18,7 +18,7 @@ import LoopAlgorithm
 class LoopDataManager {
     let carbStore: CarbStore
 
-    let glucoseStore: GlucoseStore
+    var glucoseStore: GlucoseStore!
 
     @PersistedProperty(key: "Settings")
     private var rawWatchInfo: LoopSettingsUserInfo.RawValue?
@@ -69,16 +69,19 @@ class LoopDataManager {
             cacheLength: .hours(24),    // Require 24 hours to store recent carbs "since midnight" for CarbEntryListController
             syncVersion: 0
         )
-        glucoseStore = GlucoseStore(
-            cacheStore: cacheStore,
-            cacheLength: .hours(4)
-        )
 
         self.watchInfo = LoopSettingsUserInfo(
             loopSettings: LoopSettings(),
             scheduleOverride: nil,
             preMealOverride: nil
         )
+
+        Task {
+            glucoseStore = await GlucoseStore(
+                cacheStore: cacheStore,
+                cacheLength: .hours(4)
+            )
+        }
 
         if let rawWatchInfo = rawWatchInfo, let watchInfo = LoopSettingsUserInfo(rawValue: rawWatchInfo) {
             self.watchInfo = watchInfo
@@ -96,7 +99,9 @@ extension LoopDataManager {
 
         if activeContext == nil || context.shouldReplace(activeContext!) {
             if let newGlucoseSample = context.newGlucoseSample {
-                self.glucoseStore.addGlucoseSamples([newGlucoseSample]) { (_) in }
+                Task {
+                    try? await self.glucoseStore.addGlucoseSamples([newGlucoseSample])
+                }
             }
             activeContext = context
         }
@@ -153,8 +158,10 @@ extension LoopDataManager {
         WCSession.default.sendGlucoseBackfillRequestMessage(userInfo) { (result) in
             switch result {
             case .success(let context):
-                self.glucoseStore.setSyncGlucoseSamples(context.samples) { (error) in
-                    if let error = error {
+                Task {
+                    do {
+                        try await self.glucoseStore.setSyncGlucoseSamples(context.samples)
+                    } catch {
                         self.log.error("Failure setting sync glucose samples: %{public}@", String(describing: error))
                     }
                 }
@@ -198,14 +205,12 @@ extension LoopDataManager {
             return
         }
 
-        glucoseStore.getGlucoseSamples(start: .earliestGlucoseCutoff) { result in
+        Task {
             var historicalGlucose: [StoredGlucoseSample]?
-            switch result {
-            case .failure(let error):
+            do {
+                historicalGlucose = try await glucoseStore.getGlucoseSamples(start: .earliestGlucoseCutoff)
+            } catch {
                 self.log.error("Failure getting glucose samples: %{public}@", String(describing: error))
-                historicalGlucose = nil
-            case .success(let samples):
-                historicalGlucose = samples
             }
             let chartData = GlucoseChartData(
                 unit: activeContext.displayGlucoseUnit,