fix(apple-watch): correggi unità distanza km→miglia nel workout HealthKit

Il canale iPhone→Watch via WatchConnectivity trasportava un valore con
unità inconsistente: miglia quando l'iPhone era il device primario
(lockscreen::setDistance convertiva km→mi), km quando un altro device
QZ (iPad, "SENDER=PAD") inviava la distanza grezza. Il Watch scriveva
sempre il valore ricevuto come HKUnit.mile(), causando distanze gonfiate
in Apple Health (4.4 mi invece di 2.78 mi per 4.47 km).

Fix: standardizzare il contratto a "sempre km" su quel canale.

- lockscreen.mm: rimuove la conversione * 0.621371, invia km grezzi
- WatchWorkoutTracking stopWorkOut(): moltiplica per 0.621371 prima di
  scrivere su HealthKit, così il Watch fa sempre la conversione finale

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: cagnulein

build-qdomyos-zwift-Qt_5_15_2_for_iOS-Debug/watchkit Extension/WatchWorkoutTracking.swift

@@ -162,29 +162,29 @@ extension WorkoutTracking: WorkoutTrackingProtocol {
 
             var infoToShare: Set<HKSampleType> = []
 
-            if #available(watchOSApplicationExtension 11.0, *) {
-                infoToShare = Set([
-                    HKSampleType.quantityType(forIdentifier: .stepCount)!,
-                    HKSampleType.quantityType(forIdentifier: .heartRate)!,
-                    HKSampleType.quantityType(forIdentifier: .distanceCycling)!,
-                    HKSampleType.quantityType(forIdentifier: .distanceWalkingRunning)!,
-                    HKSampleType.quantityType(forIdentifier: .activeEnergyBurned)!,
-                    HKSampleType.quantityType(forIdentifier: .basalEnergyBurned)!,
-                    HKSampleType.quantityType(forIdentifier: .cyclingPower)!,
-                    HKSampleType.quantityType(forIdentifier: .cyclingSpeed)!,
-                    HKSampleType.quantityType(forIdentifier: .cyclingCadence)!,
-                    HKSampleType.quantityType(forIdentifier: .runningPower)!,
-                    HKSampleType.quantityType(forIdentifier: .runningSpeed)!,
-                    HKSampleType.quantityType(forIdentifier: .runningStrideLength)!,
-                    HKSampleType.quantityType(forIdentifier: .runningVerticalOscillation)!,
-                    HKSampleType.quantityType(forIdentifier: .walkingSpeed)!,
-                    HKSampleType.quantityType(forIdentifier: .walkingStepLength)!,
-                    HKSampleType.quantityType(forIdentifier: .distanceRowing)!,
-                    HKSampleType.quantityType(forIdentifier: .rowingSpeed)!,
-                    HKSampleType.quantityType(forIdentifier: .flightsClimbed)!,
-                    HKSampleType.workoutType()
-                    ])
-            } else if #available(watchOSApplicationExtension 10.0, *) {
+            if #available(watchOSApplicationExtension 11.0, *) {
+                infoToShare = Set([
+                    HKSampleType.quantityType(forIdentifier: .stepCount)!,
+                    HKSampleType.quantityType(forIdentifier: .heartRate)!,
+                    HKSampleType.quantityType(forIdentifier: .distanceCycling)!,
+                    HKSampleType.quantityType(forIdentifier: .distanceWalkingRunning)!,
+                    HKSampleType.quantityType(forIdentifier: .activeEnergyBurned)!,
+                    HKSampleType.quantityType(forIdentifier: .basalEnergyBurned)!,
+                    HKSampleType.quantityType(forIdentifier: .cyclingPower)!,
+                    HKSampleType.quantityType(forIdentifier: .cyclingSpeed)!,
+                    HKSampleType.quantityType(forIdentifier: .cyclingCadence)!,
+                    HKSampleType.quantityType(forIdentifier: .runningPower)!,
+                    HKSampleType.quantityType(forIdentifier: .runningSpeed)!,
+                    HKSampleType.quantityType(forIdentifier: .runningStrideLength)!,
+                    HKSampleType.quantityType(forIdentifier: .runningVerticalOscillation)!,
+                    HKSampleType.quantityType(forIdentifier: .walkingSpeed)!,
+                    HKSampleType.quantityType(forIdentifier: .walkingStepLength)!,
+                    HKSampleType.quantityType(forIdentifier: .distanceRowing)!,
+                    HKSampleType.quantityType(forIdentifier: .rowingSpeed)!,
+                    HKSampleType.quantityType(forIdentifier: .flightsClimbed)!,
+                    HKSampleType.workoutType()
+                    ])
+            } else if #available(watchOSApplicationExtension 10.0, *) {
                 infoToShare = Set([
                     HKSampleType.quantityType(forIdentifier: .stepCount)!,
                     HKSampleType.quantityType(forIdentifier: .heartRate)!,
@@ -235,8 +235,8 @@ extension WorkoutTracking: WorkoutTrackingProtocol {
         // Reset flights climbed and elevation gain for new workout
         WorkoutTracking.flightsClimbed = 0
         WorkoutTracking.elevationGain = 0
-        WorkoutTracking.totalKcal = 0
-        WatchKitConnection.totalKcal = 0
+        WorkoutTracking.totalKcal = 0
+        WatchKitConnection.totalKcal = 0
         print("Start workout")
         configWorkout()
         workoutSession.startActivity(with: Date())
@@ -253,56 +253,56 @@ extension WorkoutTracking: WorkoutTrackingProtocol {
     }
 
     func stopWorkOut() {
-        print("Stop workout")
-        WorkoutTracking.kcal = WatchKitConnection.kcal
-        WorkoutTracking.totalKcal = WatchKitConnection.totalKcal
-        WatchKitConnection.shared.sendDebug("stop pressed local watchKcal=\(WatchKitConnection.kcal) watchTotalKcal=\(WatchKitConnection.totalKcal) trackingKcal=\(WorkoutTracking.kcal) trackingTotalKcal=\(WorkoutTracking.totalKcal)")
-        workoutSession.stopActivity(with: Date())
-        workoutSession.end()
+        print("Stop workout")
+        WorkoutTracking.kcal = WatchKitConnection.kcal
+        WorkoutTracking.totalKcal = WatchKitConnection.totalKcal
+        WatchKitConnection.shared.sendDebug("stop pressed local watchKcal=\(WatchKitConnection.kcal) watchTotalKcal=\(WatchKitConnection.totalKcal) trackingKcal=\(WorkoutTracking.kcal) trackingTotalKcal=\(WorkoutTracking.totalKcal)")
+        workoutSession.stopActivity(with: Date())
+        workoutSession.end()
 
-        // Write active and basal calories
-        guard let activeQuantityType = HKQuantityType.quantityType(
-          forIdentifier: .activeEnergyBurned) else {
-          return
-        }
-
-        let unit = HKUnit.kilocalorie()
-        let activeEnergyBurned = WorkoutTracking.kcal
-        let activeQuantity = HKQuantity(unit: unit,
-                                       doubleValue: activeEnergyBurned)
-        let basalEnergyBurned = max(WorkoutTracking.totalKcal - activeEnergyBurned, 0)
-        WatchKitConnection.shared.sendDebug("stop energy samples active=\(activeEnergyBurned) total=\(WorkoutTracking.totalKcal) basal=\(basalEnergyBurned)")
-
-        let startDate = workoutSession.startDate ?? WorkoutTracking.lastDateMetric
-
-        let activeSample = HKCumulativeQuantitySeriesSample(type: activeQuantityType,
-                                                           quantity: activeQuantity,
-                                                           start: startDate,
-                                                           end: Date())
-        var energySamples = [activeSample]
-
-        if basalEnergyBurned > 0,
-           let basalQuantityType = HKQuantityType.quantityType(forIdentifier: .basalEnergyBurned) {
-            let basalQuantity = HKQuantity(unit: unit,
-                                           doubleValue: basalEnergyBurned)
-            let basalSample = HKCumulativeQuantitySeriesSample(type: basalQuantityType,
-                                                               quantity: basalQuantity,
-                                                               start: startDate,
-                                                               end: Date())
-            energySamples.append(basalSample)
-        }
-
-        workoutBuilder.add(energySamples) {(success, error) in
-            if let error = error {
-                print("WatchWorkoutTracking energy calories: \(error.localizedDescription)")
-                WatchKitConnection.shared.sendDebug("stop energy add error=\(error.localizedDescription) active=\(activeEnergyBurned) total=\(WorkoutTracking.totalKcal) basal=\(basalEnergyBurned)")
-            } else {
-                WatchKitConnection.shared.sendDebug("stop energy add success=\(success) active=\(activeEnergyBurned) total=\(WorkoutTracking.totalKcal) basal=\(basalEnergyBurned)")
-            }
-        }
+        // Write active and basal calories
+        guard let activeQuantityType = HKQuantityType.quantityType(
+          forIdentifier: .activeEnergyBurned) else {
+          return
+        }
+
+        let unit = HKUnit.kilocalorie()
+        let activeEnergyBurned = WorkoutTracking.kcal
+        let activeQuantity = HKQuantity(unit: unit,
+                                       doubleValue: activeEnergyBurned)
+        let basalEnergyBurned = max(WorkoutTracking.totalKcal - activeEnergyBurned, 0)
+        WatchKitConnection.shared.sendDebug("stop energy samples active=\(activeEnergyBurned) total=\(WorkoutTracking.totalKcal) basal=\(basalEnergyBurned)")
+
+        let startDate = workoutSession.startDate ?? WorkoutTracking.lastDateMetric
+
+        let activeSample = HKCumulativeQuantitySeriesSample(type: activeQuantityType,
+                                                           quantity: activeQuantity,
+                                                           start: startDate,
+                                                           end: Date())
+        var energySamples = [activeSample]
+
+        if basalEnergyBurned > 0,
+           let basalQuantityType = HKQuantityType.quantityType(forIdentifier: .basalEnergyBurned) {
+            let basalQuantity = HKQuantity(unit: unit,
+                                           doubleValue: basalEnergyBurned)
+            let basalSample = HKCumulativeQuantitySeriesSample(type: basalQuantityType,
+                                                               quantity: basalQuantity,
+                                                               start: startDate,
+                                                               end: Date())
+            energySamples.append(basalSample)
+        }
+
+        workoutBuilder.add(energySamples) {(success, error) in
+            if let error = error {
+                print("WatchWorkoutTracking energy calories: \(error.localizedDescription)")
+                WatchKitConnection.shared.sendDebug("stop energy add error=\(error.localizedDescription) active=\(activeEnergyBurned) total=\(WorkoutTracking.totalKcal) basal=\(basalEnergyBurned)")
+            } else {
+                WatchKitConnection.shared.sendDebug("stop energy add success=\(success) active=\(activeEnergyBurned) total=\(WorkoutTracking.totalKcal) basal=\(basalEnergyBurned)")
+            }
+        }
 
         let unitDistance = HKUnit.mile()
-        let miles = WorkoutTracking.distance
+        let miles = WorkoutTracking.distance * 0.621371
         let quantityMiles = HKQuantity(unit: unitDistance,
                                   doubleValue: miles)
 
@@ -369,12 +369,12 @@ extension WorkoutTracking: WorkoutTrackingProtocol {
                  }
              }
 
-             let quantityTypeDistance: HKQuantityType?
-             if #available(watchOSApplicationExtension 11.0, *) {
-                 quantityTypeDistance = HKQuantityType.quantityType(forIdentifier: .distanceRowing)
-             } else {
-                 quantityTypeDistance = HKQuantityType.quantityType(forIdentifier: .distanceWalkingRunning)
-             }
+             let quantityTypeDistance: HKQuantityType?
+             if #available(watchOSApplicationExtension 11.0, *) {
+                 quantityTypeDistance = HKQuantityType.quantityType(forIdentifier: .distanceRowing)
+             } else {
+                 quantityTypeDistance = HKQuantityType.quantityType(forIdentifier: .distanceWalkingRunning)
+             }
 
              guard let typeDistance = quantityTypeDistance else {
                  return

src/ios/lockscreen.mm

@@ -153,7 +153,7 @@
 
 void lockscreen::setDistance(double distance)
 {
-    [h setDistanceWithDistance:distance * 0.621371];
+    [h setDistanceWithDistance:distance];
 }
 
 void lockscreen::setSteps(double steps)