Synheart Core - iOS/Swift SDK

dependencies: [
    .package(url: "https://github.com/synheart-ai/synheart-core-swift.git", from: "0.0.4")
]

<key>NSHealthShareUsageDescription</key>
<string>This app needs access to your health data to provide insights.</string>

<key>NSMotionUsageDescription</key>
<string>This app uses motion data to understand your activity patterns.</string>

import SynheartCore

// Initialize in AppDelegate or App struct
func application(_ application: UIApplication,
                 didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {

    Synheart.initialize(
        userId: "anon_user_123",
        config: SynheartConfig(
            allowUnsignedCapabilities: true  // Use capabilityToken in production
        )
    )

    return true
}

import Combine

class HumanStateViewModel: ObservableObject {
    @Published var currentHSI: String?
    private var cancellables = Set<AnyCancellable>()

    init() {
        Synheart.onHSIUpdate
            .sink { hsiJson in
                print("HSI JSON: \(hsiJson)")
                self.currentHSI = hsiJson
            }
            .store(in: &cancellables)
    }
}

// Available cases:
//   .wear         — biosignals from wearables
//   .behavior     — interaction telemetry
//   .phoneContext — motion / screen / app context
//   .cloud        — HSI upload connector

Synheart.activate(.wear)
Synheart.activate(.cloud)

// Stop a feature without uninitializing the SDK.
Synheart.deactivate(.cloud)

import SwiftUI
import SynheartCore
import Combine

struct HumanStateMonitorView: View {
    @StateObject private var viewModel = HumanStateViewModel()

    var body: some View {
        NavigationView {
            ScrollView {
                GroupBox(label: Text("HSI State").font(.headline)) {
                    if let hsiJson = viewModel.currentHSI {
                        Text("HSI: \(String(hsiJson.prefix(100)))")
                            .frame(maxWidth: .infinity, alignment: .leading)
                    } else {
                        Text("Waiting for data…").foregroundColor(.secondary)
                    }
                }
                .padding()
            }
            .navigationTitle("Human State")
        }
    }
}

class HumanStateViewModel: ObservableObject {
    @Published var currentHSI: String?
    private var cancellables = Set<AnyCancellable>()

    init() {
        Task { await bootstrap() }
    }

    @MainActor
    private func bootstrap() async {
        try? await Synheart.initialize(
            userId: "user_123",
            config: SynheartConfig(allowUnsignedCapabilities: true)
        )
        Synheart.activate(.wear)
        Synheart.activate(.behavior)

        Synheart.onHSIUpdate
            .receive(on: DispatchQueue.main)
            .sink { [weak self] hsiJson in self?.currentHSI = hsiJson }
            .store(in: &cancellables)
    }

    deinit { Synheart.dispose() }
}

// Enable cloud sync (requires cloudConfig in SynheartConfig)
Synheart.activate(.cloud)

// Disable cloud sync
Synheart.deactivate(.cloud)

let config = SynheartConfig(
    allowUnsignedCapabilities: true,  // use capabilityToken in production

    // Cloud configuration (optional).
    cloudConfig: CloudConfig(
        appId: "your_app_id",
        subjectId: "user_123",
        instanceId: "device_abc",
        baseUrl: "https://api.synheart.ai"
    ),

    // Capability JWT (optional, for extended/research access).
    capabilityToken: nil
)

try await Synheart.initialize(
    userId: "user_123",
    config: config
)

// Live counters / last-error strings.
let diag = Synheart.runtimeDiagnostics()
print(diag)

// Synchronous getters — safe to read from UI code.
let depth = Synheart.uploadQueueLength
let lastMs = Synheart.lastIngestSuccessAtMs

// Manually flush queued snapshots when eligible.
let result = try await Synheart.ingestion.flushIfEligible()

do {
    try await Synheart.initialize(userId: userId, config: config)
} catch let error as PermissionDeniedError {
    print("Permission denied: \(error.message)")
} catch let error as InitializationError {
    print("Initialization failed: \(error.message)")
} catch let error as SynheartError {
    print("SDK error: \(error.message)")
} catch {
    print("Unexpected error: \(error)")
}

// Coarse status — granted | pending | expired | denied
let status = await Synheart.consentStatus()

// Per-type check (wire strings: biosignals, phoneContext, behavior,
// cloudUpload, vendorSync, research)
let canUpload = try await Synheart.hasConsent("cloudUpload")
let canRead   = try await Synheart.hasConsent("biosignals")

// Request consent — opens the cloud consent flow when configured.
let token = try await Synheart.requestConsent()

// Revoke a single type or everything.
try await Synheart.revokeConsentType("cloudUpload")
try await Synheart.revokeConsent()

class StateManager {
    func bootstrap() async throws {
        try await Synheart.initialize(userId: "user_123", config: config)
        Synheart.activate(.wear)
    }

    func monitorState() async {
        for await hsiJson in Synheart.onHSIUpdate.values {
            print("HSI JSON: \(hsiJson)")
        }
    }
}