@tryterra/react-native 0.0.0-stage → 2.2.1

package/ios/TerraBridgeCore/BridgeBootstrap.swift

@@ -0,0 +1,89 @@
+import Foundation
+import TerraSDK
+
+public enum BridgeBootstrap {
+    /// The Info.plist key carrying the developer id.
+    public static let devIDKey = "TerraDevID"
+
+    public struct Configuration: Sendable, Equatable {
+        public let devID: String
+
+        public init(devID: String) {
+            self.devID = devID
+        }
+
+        /// The configuration in `bundle`'s Info.plist, or nil when it names no dev id.
+        public init?(bundle: Bundle) {
+            guard let devID = (bundle.object(forInfoDictionaryKey: BridgeBootstrap.devIDKey) as? String)?
+                .trimmingCharacters(in: .whitespacesAndNewlines), !devID.isEmpty
+            else { return nil }
+            self.init(devID: devID)
+        }
+    }
+
+    private static let parked = Locked<TerraBridge?>(nil)
+
+    /// The bridge bootstrap parked, or nil when it has not run.
+    public static var current: TerraBridge? { parked.withLock { $0 } }
+
+    @discardableResult
+    public static func bootstrap(bundle: Bundle = .main) -> TerraBridge? {
+        guard let configuration = Configuration(bundle: bundle) else { return nil }
+        return bootstrap(configuration)
+    }
+
+    @discardableResult
+    public static func bootstrap(_ configuration: Configuration) -> TerraBridge {
+        bootstrap(configuration, register: registerBackgroundSync) { provider in
+            Terra(devID: configuration.devID, tokenProvider: provider)
+        }
+    }
+
+    static func bootstrap(
+        _ configuration: Configuration,
+        register: (Terra) -> Bool,
+        client: (_ tokenProvider: @escaping TerraBridge.TokenProvider) -> Terra
+    ) -> TerraBridge {
+        parked.withLock { parked in
+            if let existing = parked { return existing }
+            let host = LaunchHost(devID: configuration.devID)
+            let bridge = TerraBridge(host: host, client: client)
+            host.registered.withLock { $0 = register(bridge.terra) }
+            parked = bridge
+            return bridge
+        }
+    }
+
+    public static func attach(
+        missingLine: String,
+        emit: @escaping @Sendable (_ subscriptionId: String, _ message: String) -> Void
+    ) throws(BridgeRejection) -> BridgeSession {
+        guard let bridge = current else {
+            throw BridgeRejection(payload: Rejections.payload(for: BridgeError.notBootstrapped(line: missingLine)))
+        }
+        return bridge.attach(emit: emit)
+    }
+
+    static func reset() {
+        parked.withLock { $0 = nil }
+    }
+
+    private static func registerBackgroundSync(_ terra: Terra) -> Bool {
+        #if os(iOS)
+        return BackgroundSync.register(terra: terra)
+        #else
+        return false
+        #endif
+    }
+}
+
+final class LaunchHost: BridgeHost {
+    let devID: String?
+    let registered = Locked(false)
+
+    init(devID: String) {
+        self.devID = devID
+    }
+
+    func backgroundRegistered() async -> Bool { registered.withLock { $0 } }
+}

package/ios/TerraBridgeCore/BridgeHost.swift

@@ -0,0 +1,13 @@
+import Foundation
+
+/// The parts of an op that are not the SDK: the bootstrap's own record of what it set up.
+///
+/// A seam so that everything in front of it runs on a macOS host with no simulator. The production
+/// conformance belongs to bootstrap (P5), which is the code that registered the task.
+public protocol BridgeHost: Sendable {
+    /// The dev id the native bootstrap was configured with.
+    var devID: String? { get }
+
+    /// Whether bootstrap registered background sync at launch. False is a host setup bug.
+    func backgroundRegistered() async -> Bool
+}

package/ios/TerraBridgeCore/Conversions+Reads.swift

@@ -0,0 +1,259 @@
+import Foundation
+import TerraSDK
+
+extension Conversions {
+
+    static func dayTotalMetric(_ metric: TerraSDK.DayTotal.Metric) -> DayTotalMetric? {
+        switch metric {
+        case .distanceWalkingRunning: return .distanceWalkingRunning
+        case .distanceCycling: return .distanceCycling
+        case .distanceSwimming: return .distanceSwimming
+        case .distanceWheelchair: return .distanceWheelchair
+        case .activeEnergyBurned: return .activeEnergyBurned
+        case .basalEnergyBurned: return .basalEnergyBurned
+        case .flightsClimbed: return .flightsClimbed
+        case .appleExerciseTime: return .appleExerciseTime
+        case .steps, .swimmingStrokeCount, .appleMoveTime, .appleStandTime, .appleStandHours: return nil
+        @unknown default: return nil
+        }
+    }
+
+    static func dayTotal(_ total: TerraSDK.DayTotal) -> DayTotal? {
+        dayTotalMetric(total.metric).map {
+            DayTotal(
+                metric: $0,
+                start: BridgeInstant.format(total.interval.start),
+                end: BridgeInstant.format(total.interval.end),
+                value: total.value,
+                unit: total.unit,
+                timeZone: total.timeZone?.identifier)
+        }
+    }
+
+    static func intradayMetric(_ kind: TerraSDK.IntradaySample.Kind) -> IntradayMetric? {
+        switch kind {
+        case .activeEnergy: return .activeEnergy
+        case .basalEnergy: return .basalEnergy
+        case .distance: return .distance
+        case .floorsClimbed: return .floorsClimbed
+        @unknown default: return nil
+        }
+    }
+
+    static func intraday(_ sample: TerraSDK.IntradaySample) -> IntradaySample? {
+        intradayMetric(sample.kind).map {
+            IntradaySample(
+                id: sample.id.uuidString,
+                metric: $0,
+                start: BridgeInstant.format(sample.interval.start),
+                end: BridgeInstant.format(sample.interval.end),
+                value: sample.value,
+                source: sampleSource(sample.source),
+                userEntered: sample.userEntered,
+                timeZone: sample.timeZone?.identifier)
+        }
+    }
+
+    static func restingHeartRate(_ sample: TerraSDK.RestingHeartRateSample) -> RestingHeartRateSample {
+        RestingHeartRateSample(
+            id: sample.id.uuidString,
+            start: BridgeInstant.format(sample.interval.start),
+            end: BridgeInstant.format(sample.interval.end),
+            beatsPerMinute: sample.beatsPerMinute,
+            source: sampleSource(sample.source),
+            userEntered: sample.userEntered,
+            timeZone: sample.timeZone?.identifier)
+    }
+
+    static func bodyMetric(_ metric: TerraSDK.BodyMetric) -> BodyMetric? {
+        switch metric {
+        case .weight: return .weight
+        case .height: return .height
+        case .bodyFatPercentage: return .bodyFatPercentage
+        case .leanBodyMass: return .leanBodyMass
+        case .bmi: return .bmi
+        case .waistCircumference: return nil
+        @unknown default: return nil
+        }
+    }
+
+    static func glucoseUnit(_ unit: TerraSDK.BloodGlucoseUnit) -> BloodGlucoseUnit {
+        switch unit {
+        case .milligramsPerDecilitre: return .milligramsPerDecilitre
+        case .millimolesPerLitre: return .millimolesPerLitre
+        @unknown default: return .milligramsPerDecilitre
+        }
+    }
+
+    static func mealTime(_ time: TerraSDK.GlucoseMealTime) -> GlucoseMealTime {
+        switch time {
+        case .preprandial: return .preprandial
+        case .postprandial: return .postprandial
+        case .unknown: return .unknown
+        @unknown default: return .unknown
+        }
+    }
+
+    static func specimen(_ specimen: TerraSDK.GlucoseSpecimen) -> GlucoseSpecimen {
+        switch specimen {
+        case .capillary: return .capillary
+        case .interstitial: return .interstitial
+        case .plasma: return .plasma
+        case .serum: return .serum
+        case .tears: return .tears
+        case .wholeBlood: return .wholeBlood
+        case .unknown: return .unknown
+        @unknown default: return .unknown
+        }
+    }
+
+    static func temperatureMetric(_ metric: TerraSDK.BodyTemperatureMetric) -> BodyTemperatureMetric? {
+        switch metric {
+        case .body: return .body
+        case .basal: return .basal
+        case .wrist: return .wrist
+        case .skin: return .skin
+        @unknown default: return nil
+        }
+    }
+
+    static func variabilityMetric(_ metric: TerraSDK.HeartRateVariabilityMetric) -> HeartRateVariabilityMetric? {
+        switch metric {
+        case .sdnn: return .sdnn
+        case .rmssd: return .rmssd
+        @unknown default: return nil
+        }
+    }
+
+    static func testType(_ type: TerraSDK.VO2MaxTestType) -> VO2MaxTestType? {
+        switch type {
+        case .maxExercise: return .maxExercise
+        case .predictedSubMaxExercise: return .predictedSubMaxExercise
+        case .predictedNonExercise: return .predictedNonExercise
+        @unknown default: return nil
+        }
+    }
+
+    static func bodyReadingKind(_ kind: TerraSDK.BodyReading.Kind) -> BodyReadingKind? {
+        switch kind {
+        case .measurement(let metric, let value):
+            return bodyMetric(metric).map { .measurement(metric: $0, value: value) }
+        case .bloodPressure(let systolic, let diastolic):
+            return .bloodPressure(systolic: systolic, diastolic: diastolic)
+        case .bloodGlucose(let value, let unit, let mealTime, let specimen):
+            return .bloodGlucose(
+                value: value, unit: glucoseUnit(unit), mealTime: mealTime.map(Self.mealTime),
+                specimen: specimen.map(Self.specimen))
+        case .oxygenSaturation(let fraction):
+            return .oxygenSaturation(fraction: fraction)
+        case .temperature(let metric, let celsius):
+            return temperatureMetric(metric).map { .temperature(metric: $0, celsius: celsius) }
+        case .heartRateVariability(let metric, let milliseconds):
+            return variabilityMetric(metric).map { .heartRateVariability(metric: $0, milliseconds: milliseconds) }
+        case .respiratoryRate(let breathsPerMinute):
+            return .respiratoryRate(breathsPerMinute: breathsPerMinute)
+        case .vo2Max(let value, let type):
+            return .vo2Max(millilitresPerKilogramMinute: value, testType: type.flatMap(testType))
+        case .insulinDelivery, .electrocardiogram, .heartbeatSeries:
+            return nil
+        @unknown default:
+            return nil
+        }
+    }
+
+    static func bodyReading(_ reading: TerraSDK.BodyReading) -> BodyReading? {
+        bodyReadingKind(reading.kind).map {
+            BodyReading(
+                id: reading.id.uuidString,
+                kind: $0,
+                start: BridgeInstant.format(reading.interval.start),
+                end: BridgeInstant.format(reading.interval.end),
+                source: sampleSource(reading.source),
+                userEntered: reading.userEntered,
+                timeZone: reading.timeZone?.identifier)
+        }
+    }
+
+    static func route(_ route: TerraSDK.WorkoutRoute) -> WorkoutRoute {
+        WorkoutRoute(
+            id: route.id.uuidString,
+            workoutId: route.workoutId.uuidString,
+            start: BridgeInstant.format(route.interval.start),
+            end: BridgeInstant.format(route.interval.end),
+            points: route.points.map {
+                RoutePoint(time: BridgeInstant.format($0.time), latitude: $0.latitude, longitude: $0.longitude)
+            },
+            source: sampleSource(route.source),
+            timeZone: route.timeZone?.identifier)
+    }
+
+    static func intensityMetric(_ kind: TerraSDK.WorkoutIntensitySample.Kind) -> WorkoutIntensityMetric? {
+        switch kind {
+        case .speed: return .speed
+        case .power: return .power
+        case .cadence: return .cadence
+        @unknown default: return nil
+        }
+    }
+
+    static func intensity(_ sample: TerraSDK.WorkoutIntensitySample) -> WorkoutIntensitySample? {
+        intensityMetric(sample.kind).map {
+            WorkoutIntensitySample(
+                id: sample.id.uuidString,
+                metric: $0,
+                workoutId: sample.workoutId.uuidString,
+                start: BridgeInstant.format(sample.interval.start),
+                end: BridgeInstant.format(sample.interval.end),
+                value: sample.value,
+                source: sampleSource(sample.source),
+                userEntered: sample.userEntered,
+                timeZone: sample.timeZone?.identifier)
+        }
+    }
+
+    static func hydration(_ sample: TerraSDK.HydrationSample) -> HydrationSample {
+        HydrationSample(
+            id: sample.id.uuidString,
+            start: BridgeInstant.format(sample.interval.start),
+            end: BridgeInstant.format(sample.interval.end),
+            millilitres: sample.millilitres,
+            source: sampleSource(sample.source),
+            userEntered: sample.userEntered,
+            timeZone: sample.timeZone?.identifier)
+    }
+
+    static func availability(_ availability: TerraSDK.StoreAvailability) -> StoreAvailability {
+        switch availability {
+        case .available: return .available
+        case .unsupportedDevice: return .unsupportedDevice
+        @unknown default: return .unsupportedDevice
+        }
+    }
+
+    static func eventKind(_ kind: TerraSDK.MenstrualEvent.Kind) -> MenstrualEventKind? {
+        switch kind {
+        case .intermenstrualBleeding: return .intermenstrualBleeding
+        case .ovulationTest: return .ovulationTest
+        case .cervicalMucus: return .cervicalMucus
+        case .sexualActivity, .pregnancyTest, .progesteroneTest, .pregnancy, .lactation, .contraceptive,
+             .persistentIntermenstrualBleeding, .infrequentCycles, .irregularCycles, .prolongedPeriods,
+             .bleedingDuringPregnancy, .bleedingAfterPregnancy:
+            return nil
+        @unknown default: return nil
+        }
+    }
+
+    static func menstrualEvent(_ event: TerraSDK.MenstrualEvent) -> MenstrualEvent? {
+        eventKind(event.kind).map {
+            MenstrualEvent(
+                id: event.id.uuidString,
+                kind: $0,
+                time: BridgeInstant.format(event.instant),
+                value: event.value,
+                storeIdentifier: event.storeIdentifier,
+                source: sampleSource(event.source),
+                userEntered: event.userEntered,
+                timeZone: event.timeZone?.identifier)
+        }
+    }
+}