iOS SDK Verwendung

Initialisierung

Das SDK wird als KMP-Framework unter iOS genutzt. Verwenden Sie das Builder-Muster, um eine Instanz zu erstellen. Die Funktion build() ist asynchron und fuehrt die DPoP-Schluesselpaargenerierung (Secure Enclave), Token-Aktivierung und Berechtigungsueberpruefung durch.

import VitaleraSdkCore

let sdk = try await VitaleraSdk.companion.builder()
    .clientId(clientId: "your-org-license-key")
    .addProvider(providerName: "omron")
    .addProvider(providerName: "polar")
    .addProvider(providerName: "standard-ble")
    .connectedMode(enabled: true)
    .build()

Behandlung von Authentifizierungsfehlern:

do {
    let sdk = try await VitaleraSdk.companion.builder()
        .clientId(clientId: "your-org-license-key")
        .build()
} catch let error as SdkAuthException {
    switch error.errorCode {
    case "activation_failed":
        showInvalidLicenseError()
    case "entitlements_expired":
        showConnectToInternetPrompt()
    case "no_cache":
        showFirstLaunchOfflineError()
    default:
        showGenericError(error.message)
    }
}

Berechtigungen

Fuegen Sie die erforderlichen Berechtigungen zu Ihrer Info.plist hinzu:

<key>NSBluetoothAlwaysUsageDescription</key>
<string>This app uses Bluetooth to connect with medical devices.</string>
<key>NSBluetoothPeripheralUsageDescription</key>
<string>This app uses Bluetooth to communicate with devices.</string>

Fuer HealthKit:

<key>NSHealthShareUsageDescription</key>
<string>This app reads health data for monitoring.</string>

Geraeteerkennung

Die Erkennung verwendet Swift AsyncSequence. Jedes erkannte Geraet wird als DeviceDescriptor zurueckgegeben.

let filter = DiscoveryFilter(
    providers: nil,
    capabilities: [DeviceCapability.bloodPressure],
    namePrefix: nil
)

for try await descriptor in sdk.devices.discover(filter: filter, timeoutMs: 15_000) {
    print("Found: \(descriptor.name) (\(descriptor.provider))")
}

Filteroptionen

// Nur Polar-Geraete
let polarFilter = DiscoveryFilter(
    providers: ["polar"],
    capabilities: nil,
    namePrefix: nil
)

// Nur Herzfrequenzmessgeraete
let hrFilter = DiscoveryFilter(
    providers: nil,
    capabilities: [DeviceCapability.heartRate],
    namePrefix: nil
)

Geraeteverbindung

Erstellen Sie ein Geraet aus einem Deskriptor und verbinden Sie sich. Die Funktion connect() ist asynchron mit einem konfigurierbaren Timeout.

let device = sdk.devices.createDevice(descriptor: descriptor)

// Verbinden (asynchron, mit Timeout)
try await device.connect(timeoutMs: 10_000)

Datenerfassung

Die Methode collect() gibt eine AsyncSequence typisierter Beobachtungsklassen zurueck.

for try await observation in device.collect() {
    if let bp = observation as? BloodPressureObservation {
        print("BP: \(bp.systolic)/\(bp.diastolic) mmHg")
        if let pulse = bp.pulseRate {
            print("Pulse: \(pulse) bpm")
        }
    } else if let hr = observation as? HeartRateObservation {
        print("HR: \(hr.heartRate) bpm")
    } else if let temp = observation as? TemperatureObservation {
        print("Temp: \(temp.temperature) C")
    } else if let weight = observation as? WeightObservation {
        print("Weight: \(weight.weight) kg")
    } else if let spo2 = observation as? OxygenSaturationObservation {
        print("SpO2: \(spo2.spo2)%")
    }
}

// Nach Abschluss trennen
try await device.disconnect()

Verbundener Modus

Wenn der verbundene Modus aktiviert ist, koennen Sie Patienten aufloesen und Beobachtungen senden:

let patient = try await sdk.connected().resolveMonitored(externalId: "patient-ext-id")

try await sdk.connected().postObservation(
    monitoredId: patient.id,
    observation: BaseObservation(
        observationType: "blood-pressure",
        issued: ISO8601DateFormatter().string(from: Date()),
        components: [
            ObservationComponent(name: "systolic", value: "120", valueUnit: "mmHg"),
            ObservationComponent(name: "diastolic", value: "80", valueUnit: "mmHg"),
        ]
    )
)

Fehlerbehandlung

do {
    try await device.connect(timeoutMs: 10_000)
    for try await obs in device.collect() {
        // Beobachtung verarbeiten
    }
} catch let error as SdkError {
    switch error {
    case is SdkError.ConnectionTimeout:
        showError("Connection timed out. Move closer to the device.")
    case is SdkError.BluetoothDisabled:
        showError("Please enable Bluetooth.")
    case is SdkError.BluetoothPermissionDenied:
        showError("Bluetooth permissions required.")
    default:
        showError("Device error: \(error.localizedDescription)")
    }
}

HealthKit

Lesen von Apple HealthKit (kein BLE-Scan erforderlich):

let descriptor = try await sdk.devices.discover(
    filter: DiscoveryFilter(providers: ["apple-healthkit"], capabilities: nil, namePrefix: nil),
    timeoutMs: 5_000
).first { _ in true }!

let store = sdk.devices.createDevice(descriptor: descriptor)
try await store.connect()
for try await observation in store.collect() {
    // HealthKit-Beobachtungen verarbeiten
}
try await store.disconnect()

Ressourcenbereinigung

Rufen Sie immer close() auf, wenn das SDK nicht mehr benoetigt wird:

sdk.close()