Ús del SDK iOS

Inicialització

El SDK es consumeix com un framework KMP a iOS. Utilitzeu el patró builder per crear una instància. La funció build() és async i realitza la generació del parell de claus DPoP (Secure Enclave), l'activació del token i la verificació de drets.

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()

Gestioneu errors d'autenticació:

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)
    }
}

Permisos

Afegiu els permisos necessaris al vostre Info.plist:

<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>

Per a HealthKit:

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

Descobriment de dispositius

El descobriment utilitza Swift AsyncSequence. Cada dispositiu descobert es retorna com un DeviceDescriptor.

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))")
}

Opcions de filtre

// Only Polar devices
let polarFilter = DiscoveryFilter(
    providers: ["polar"],
    capabilities: nil,
    namePrefix: nil
)

// Only heart rate monitors
let hrFilter = DiscoveryFilter(
    providers: nil,
    capabilities: [DeviceCapability.heartRate],
    namePrefix: nil
)

Connexió de dispositius

Creeu un dispositiu a partir d'un descriptor i connecteu-vos-hi. La funció connect() és async amb un temps d'espera configurable.

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

// Connect (async, with timeout)
try await device.connect(timeoutMs: 10_000)

Recollida de dades

El mètode collect() retorna un AsyncSequence de classes d'observació tipades.

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)%")
    }
}

// Disconnect when done
try await device.disconnect()

Mode connectat

Quan el mode connectat està habilitat, resolveu pacients i envieu observacions:

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"),
        ]
    )
)

Gestió d'errors

do {
    try await device.connect(timeoutMs: 10_000)
    for try await obs in device.collect() {
        // process observation
    }
} 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

Llegiu d'Apple HealthKit (no es requereix escaneig BLE):

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() {
    // Process HealthKit observations
}
try await store.disconnect()

Neteja de recursos

Crideu sempre close() quan el SDK ja no sigui necessari:

sdk.close()