当设备锁定在模拟器中时，为什么使用HealthKit的watchOS应用程序会继续更新，而锁定时却不在实际设备上

如何解决当设备锁定在模拟器中时，为什么使用HealthKit的watchOS应用程序会继续更新，而锁定时却不在实际设备上

当我在模拟器上运行该设备时，它会在设备锁定时保持更新（打印时间），但是在我的Apple Watch上，当我运行它时，它在设备锁定时不会保持更新（实际上只是屏幕关闭）。

我不完全知道调用HealthKit时发生了什么，我从Apple示例Speedy Sloth中提取了大部分代码。

import SwiftUI
import Foundation
import HealthKit
import Combine


struct ContentView: View {
    
    @StateObject var workoutStuff = WorkoutStuff()

    
    var body: some View {
        Text("Time is: \(workoutStuff.elapsedTime)")
            .onAppear(perform: {
                workoutStuff.startTimer()
            })
    }
}
    
    class WorkoutStuff: NSObject,ObservableObject {
        @Published var heartrate: Double = 0
        @Published var activeCalories: Double = 0
        @Published var distance: Double = 0

        /// - Tag: DeclareSessionBuilder
        let healthStore = HKHealthStore()
        var session: HKWorkoutSession!
        var builder: HKLiveWorkoutBuilder!
        
        var start = Date()
        var cancellable: Cancellable?
        @Published var elapsedTime = 0.0
        
        func startTimer() {
            start = Date()
            //        setUpTimer()
            cancellable = Timer.publish(every: 0.1,on: .main,in: .default)
                .autoconnect()
                .sink { [weak self] _ in
                    guard let self = self else { return }
                    //                self.firingFunction(firingOver: timerEnded)
                    self.firingFunction()
                }
        }
        
        func firingFunction() {
            elapsedTime += 0.1
            print(elapsedTime)
        }
        
        /// - TAG: Workout Stuff
        // Request authorization to access HealthKit.
        func requestAuthorization() {
            // Requesting authorization.
            /// - Tag: RequestAuthorization
            // The quantity type to write to the health store.
            let typesToShare: Set = [
                HKQuantityType.workoutType()
            ]
            
            // The quantity types to read from the health store.
            let typesToRead: Set = [
                HKQuantityType.quantityType(forIdentifier: .heartRate)!,HKQuantityType.quantityType(forIdentifier: .activeEnergyBurned)!,HKQuantityType.quantityType(forIdentifier: .distanceWalkingRunning)!
            ]
            
            // Request authorization for those quantity types.
            healthStore.requestAuthorization(toShare: typesToShare,read: typesToRead) { (success,error) in
                // Handle error.
            }
        }
        
        // Provide the workout configuration.
        func workoutConfiguration() -> HKWorkoutConfiguration {
            /// - Tag: WorkoutConfiguration
            let configuration = HKWorkoutConfiguration()
            configuration.activityType = .running
            configuration.locationType = .outdoor

            return configuration
        }

        func updateForStatistics(_ statistics: HKStatistics?) {
            guard let statistics = statistics else { return }
            
            DispatchQueue.main.async {
                switch statistics.quantityType {
                case HKQuantityType.quantityType(forIdentifier: .heartRate):
                    /// - Tag: SetLabel
                    let heartRateUnit = HKUnit.count().unitDivided(by: HKUnit.minute())
                    let value = statistics.mostRecentQuantity()?.doubleValue(for: heartRateUnit)
                    let roundedValue = Double( round( 1 * value! ) / 1 )
                    self.heartrate = roundedValue
                case HKQuantityType.quantityType(forIdentifier: .activeEnergyBurned):
                    let energyUnit = HKUnit.kilocalorie()
                    let value = statistics.sumQuantity()?.doubleValue(for: energyUnit)
                    self.activeCalories = Double( round( 1 * value! ) / 1 )
                    return
                case HKQuantityType.quantityType(forIdentifier: .distanceWalkingRunning):
                    let meterUnit = HKUnit.meter()
                    let value = statistics.sumQuantity()?.doubleValue(for: meterUnit)
                    let roundedValue = Double( round( 1 * value! ) / 1 )
                    self.distance = roundedValue
                    return
                default:
                    return
                }
            }
        }
        
        func startWorkout() {
            
            //        self.running = true
            
            // Create the session and obtain the workout builder.
            /// - Tag: CreateWorkout
            do {
                session = try HKWorkoutSession(healthStore: healthStore,configuration: self.workoutConfiguration())
                builder = session.associatedWorkoutBuilder()
            } catch {
                // Handle any exceptions.
                return
            }
            
            // Setup session and builder.
            session.delegate = self
            builder.delegate = self
            
            // Set the workout builder's data source.
            /// - Tag: SetDataSource
            builder.dataSource = HKLiveWorkoutDataSource(healthStore: healthStore,workoutConfiguration: workoutConfiguration())
            
            // Start the workout session and begin data collection.
            /// - Tag: StartSession
            session.startActivity(with: Date())
            builder.beginCollection(withStart: Date()) { (success,error) in
                // The workout has started.
            }
        }
        
    }
    
    struct ContentView_Previews: PreviewProvider {
        static var previews: some View {
            ContentView()
        }
    }

// MARK: - HKWorkoutSessionDelegate
extension WorkoutStuff: HKWorkoutSessionDelegate {
    func workoutSession(_ workoutSession: HKWorkoutSession,didChangeTo toState: HKWorkoutSessionState,from fromState: HKWorkoutSessionState,date: Date) {
        // Wait for the session to transition states before ending the builder.
        /// - Tag: SaveWorkout
        if toState == .ended {
            print("The workout has now ended.")
            builder.endCollection(withEnd: Date()) { (success,error) in
                self.builder.finishWorkout { (workout,error) in
                    // Optionally display a workout summary to the user.
//                    self.resetWorkout()
                }
            }
        }
    }
    
    func workoutSession(_ workoutSession: HKWorkoutSession,didFailWithError error: Error) {
        
    }
}

// MARK: - HKLiveWorkoutBuilderDelegate
extension WorkoutStuff: HKLiveWorkoutBuilderDelegate {
    func workoutBuilderDidCollectEvent(_ workoutBuilder: HKLiveWorkoutBuilder) {
        
    }
    
    func workoutBuilder(_ workoutBuilder: HKLiveWorkoutBuilder,didCollectDataOf collectedTypes: Set<HKSampleType>) {
        for type in collectedTypes {
            guard let quantityType = type as? HKQuantityType else {
                return // Nothing to do.
            }
            
            /// - Tag: GetStatistics
            let statistics = workoutBuilder.statistics(for: quantityType)
            
            // Update the published values.
            updateForStatistics(statistics)
        }
    }
}