HealthKit integration uses own contexts for CoreData (#470)

We want to make sure HealthKit integration with CoreData is thread safe
and also doesn't risk using contexts which are no longer valid. Do this
by making HealthKit related code use its own contexts, and minimize how
much code it holds onto.

Testing:
Ran on device
Note: Current build is known to be quite crashy

Author: theospears

BeeKit/HeathKit/GoalHealthKitConnection.swift

@@ -0,0 +1,77 @@
+import Foundation
+import SwiftyJSON
+import HealthKit
+import OSLog
+
+/// Monitor a specific HealthKit metric and report when it changes
+class HealthKitMetricMonitor {
+    static let minimumIntervalBetweenObserverUpdates : TimeInterval = 5 // Seconds
+
+    private let logger = Logger(subsystem: "com.beeminder.beeminder", category: "HealthKitMetricMonitor")
+
+    private let healthStore: HKHealthStore
+    public let metric : HealthKitMetric
+    private let onUpdate: (HealthKitMetric) async -> Void
+
+    private var observerQuery : HKObserverQuery? = nil
+    private var lastObserverUpdate : Date? = nil
+
+    init(healthStore: HKHealthStore, metric: HealthKitMetric, onUpdate: @escaping (HealthKitMetric) async -> Void) {
+        self.healthStore = healthStore
+        self.metric = metric
+        self.onUpdate = onUpdate
+    }
+
+    /// Perform an initial sync and register for changes to the relevant metric so the goal can be kept up to date
+    public func setupHealthKit() async throws {
+        try await healthStore.enableBackgroundDelivery(for: metric.sampleType(), frequency: HKUpdateFrequency.immediate)
+        registerObserverQuery()
+    }
+
+    /// Register for changes to the relevant metric. Assumes permission and background delivery already enabled
+    public func registerObserverQuery() {
+        guard observerQuery == nil else {
+            return
+        }
+        logger.notice("Registering observer query for \(self.metric.databaseString, privacy: .public)")
+
+        let query = HKObserverQuery(sampleType: metric.sampleType(), predicate: nil, updateHandler: { (query, completionHandler, error) in
+            self.logger.notice("ObserverQuery response for \(self.metric.databaseString, privacy: .public)")
+
+            guard error == nil else {
+                self.logger.error("ObserverQuery for \(self.metric.databaseString, privacy: .public) was error: \(error, privacy: .public)")
+                return
+            }
+
+            if let lastUpdate = self.lastObserverUpdate {
+                if Date().timeIntervalSince(lastUpdate) < HealthKitMetricMonitor.minimumIntervalBetweenObserverUpdates {
+                    self.logger.notice("Ignoring update to \(self.metric.databaseString, privacy: .public) due to recent previous update")
+                    completionHandler()
+                    return
+                }
+            }
+            self.lastObserverUpdate = Date()
+
+            Task {
+                await self.onUpdate(self.metric)
+                completionHandler()
+            }
+        })
+        healthStore.execute(query)
+
+        // Once we have successfully executed the query then keep track of it to stop later
+        self.observerQuery = query
+    }
+
+    /// Remove any registered queries to prevent further updates
+    public func unregisterObserverQuery() {
+        guard let query = self.observerQuery else {
+            logger.warning("unregisterObserverQuery(\(self.metric.databaseString, privacy: .public)): Attempted to unregister query when not registered")
+            return
+        }
+        logger.notice("Unregistering observer query for \(self.metric.databaseString, privacy: .public)")
+
+        healthStore.stop(query)
+    }
+}
+

BeeKit/HeathKit/HealthKitMetricMonitor.swift

@@ -64,19 +64,14 @@ public actor GoalManager {
         await performPostGoalUpdateBookkeeping()
     }
 
-    public func refreshGoal(_ goal: Goal) async throws {
+    public func refreshGoal(_ goalID: NSManagedObjectID) async throws {
+        let context = container.newBackgroundContext()
+        let goal = try context.existingObject(with: goalID) as! Goal
+
         let responseObject = try await requestManager.get(url: "/api/v1/users/\(currentUserManager.username!)/goals/\(goal.slug)?datapoints_count=5", parameters: nil)
         let goalJSON = JSON(responseObject!)
-        let goalId = goalJSON["id"].stringValue
 
-        let context = container.newBackgroundContext()
-        let request = NSFetchRequest<Goal>(entityName: "Goal")
-        request.predicate = NSPredicate(format: "id == %@", goalId)
-        if let existingGoal = try context.fetch(request).first {
-            existingGoal.updateToMatch(json: goalJSON)
-        } else {
-            logger.warning("Found no existing goal in CoreData store when refreshing \(goal.slug) with id \(goal.id)")
-        }
+        goal.updateToMatch(json: goalJSON)
         try context.save()
 
         await performPostGoalUpdateBookkeeping()
@@ -150,7 +145,8 @@ public actor GoalManager {
         do {
             while true {
                 // If there are no queued goals then we are complete and can stop checking
-                guard let user = currentUserManager.user() else { break }
+                let context = container.newBackgroundContext()
+                guard let user = currentUserManager.user(context: context) else { break }
                 let queuedGoals = user.goals.filter { $0.queued }
                 if queuedGoals.isEmpty {
                     break
@@ -160,7 +156,8 @@ public actor GoalManager {
                 try await withThrowingTaskGroup(of: Void.self) { group in
                     for goal in queuedGoals {
                         group.addTask {
-                            try await self.refreshGoal(goal)
+                            // TODO: We don't really need to reload the goal in a new context here
+                            try await self.refreshGoal(goal.objectID)
                         }
                     }
                     try await group.waitForAll()