Android SDK használat

Inicializálás

Használja a builder mintát egy SDK-példány létrehozásához. A build() függvény egy suspend függvény, amely DPoP kulcspár-generálást, token-aktiválást és jogosultság-ellenőrzést végez.

import com.vitalera.sdk.VitaleraSdk

val sdk = VitaleraSdk.builder()
    .context(applicationContext)           // Androidon kötelező
    .clientId("your-org-license-key")      // Kötelező -- a sdk@vitalera.com címen szerezhető be
    .addProvider("omron")                  // A használandó providerek deklarálása
    .addProvider("polar")
    .addProvider("standard-ble")
    .connectedMode(true)                   // Opcionális: beteg/megfigyelés API engedélyezése
    .build()                               // suspend: DPoP hitelesítés + jogosultság ellenőrzés

Hitelesítési hibák kezelése az inicializálás során:

try {
    val sdk = VitaleraSdk.builder()
        .context(applicationContext)
        .clientId("your-org-license-key")
        .build()
} catch (e: SdkAuthException) {
    when (e.errorCode) {
        "activation_failed" -> showInvalidLicenseError()
        "entitlements_expired" -> showConnectToInternetPrompt()
        "no_cache" -> showFirstLaunchOfflineError()
        else -> showGenericError(e.message)
    }
}

Eszközfelfedezés

Használja a DiscoveryFilter-t adott eszköztípusok kereséséhez. A felfedezés egy Kotlin Flow<DeviceDescriptor>-t ad vissza, amely a felfedezett eszközöket emittálja és az időtúllépés után befejeződik.

import com.vitalera.sdk.discovery.DiscoveryFilter
import com.vitalera.sdk.device.DeviceCapability

// Vérnyomásmérők keresése az összes regisztrált providerben
val filter = DiscoveryFilter(
    capabilities = setOf(DeviceCapability.BLOOD_PRESSURE)
)

sdk.devices.discover(filter, timeoutMs = 15_000L).collect { descriptor ->
    // descriptor: DeviceDescriptor(id, name, provider, modelId, rssi, capabilities)
    println("Found: ${descriptor.name} (${descriptor.provider}, ${descriptor.rssi} dBm)")
}

Szűrési lehetőségek

// Csak Omron eszközök
val omronFilter = DiscoveryFilter(providers = setOf("omron"))

// Csak "Polar" névkezdetű eszközök
val polarFilter = DiscoveryFilter(namePrefix = "Polar")

// Kombinált: csak Polar pulzusmérők
val combinedFilter = DiscoveryFilter(
    providers = setOf("polar"),
    capabilities = setOf(DeviceCapability.HEART_RATE),
)

Eszközcsatlakozás

Hozzon létre eszközt egy DeviceDescriptor-ból és csatlakozzon hozzá. A connect() függvény egy suspend függvény konfigurálható időtúllépéssel.

val device = sdk.devices.createDevice(descriptor)

// Csatlakozás (felfüggesztődik a csatlakozásig vagy időtúllépésig)
device.connect(timeoutMs = 10_000L)

// Kapcsolatállapot reaktív figyelése
launch {
    device.connectionState.collect { state ->
        when (state) {
            is ConnectionState.Disconnected -> showStatus("Leválasztva")
            is ConnectionState.Connecting -> showStatus("Csatlakozás...")
            is ConnectionState.Connected -> showStatus("Csatlakoztatva")
            is ConnectionState.Disconnecting -> showStatus("Leválasztás: ${state.reason}")
            is ConnectionState.Error -> showError(state.cause)
        }
    }
}

Adatgyűjtés

A collect() metódus egy Flow<BaseObservation> típusos megfigyelési osztályokat ad vissza. Egyszeri mérésű eszközöknél (pl. vérnyomásmérő) a Flow egy megfigyelést emittál és befejeződik. Streaming eszközöknél (pl. pulzusmérő) folyamatosan emittál.

device.collect().collect { observation ->
    when (observation) {
        is BloodPressureObservation -> {
            val systolic = observation.systolic
            val diastolic = observation.diastolic
            val pulseRate = observation.pulseRate
            val irregular = observation.irregularPulseDetected
        }
        is HeartRateObservation -> {
            val bpm = observation.heartRate
        }
        is WeightObservation -> {
            val kg = observation.weight
        }
        is TemperatureObservation -> {
            val celsius = observation.temperature
        }
        is OxygenSaturationObservation -> {
            val spo2 = observation.spo2
        }
        is BloodGlucoseObservation -> {
            val glucose = observation.glucose
        }
        // 30+ típusos megfigyelési osztály elérhető
    }
}

// Csatlakozás bontása befejezéskor
device.disconnect()

Csatlakoztatott mód

Amikor a connectedMode(true) be van állítva az inicializálás során, betegek feloldása és megfigyelések küldése a Vitalera háttérrendszerbe:

// Beteg feloldása külső azonosítóval
val patient = sdk.connected().resolveMonitored("patient-ext-id")

// Megfigyelés küldése
sdk.connected().postObservation(
    monitoredId = patient.id,
    observation = BaseObservation(
        observationType = "blood-pressure",
        issued = Clock.System.now().toString(),
        components = listOf(
            ObservationComponent(name = "systolic", value = "120", valueUnit = "mmHg"),
            ObservationComponent(name = "diastolic", value = "80", valueUnit = "mmHg"),
        ),
    ),
)

Hibakezelés

Az összes SDK-hiba a lezárt SdkError osztályt terjeszti ki:

try {
    device.connect()
    val obs = device.collect().first()
} catch (e: SdkError.ConnectionTimeout) {
    showError("Connection timed out. Move closer to the device.")
} catch (e: SdkError.BluetoothDisabled) {
    showError("Please enable Bluetooth.")
} catch (e: SdkError.BluetoothPermissionDenied) {
    showError("Bluetooth permissions required.")
} catch (e: SdkError) {
    showError("Device error: ${e.message}")
}

Több eszköz

Párhuzamos csatlakozás több eszközhöz korutinok segítségével:

val bpMonitor = sdk.devices.createDevice(bpDescriptor)
val hrMonitor = sdk.devices.createDevice(hrDescriptor)

coroutineScope {
    launch { bpMonitor.connect() }
    launch { hrMonitor.connect() }
}

Health Connect

Olvasás a Google Health Connectből (nem szükséges BLE keresés):

val descriptor = sdk.devices.discover(
    DiscoveryFilter(providers = setOf("health-connect")),
    timeoutMs = 5_000L,
).first()

val store = sdk.devices.createDevice(descriptor)
store.connect()
val observations = store.collect().toList()
store.disconnect()

Erőforrások felszabadítása

Mindig hívja meg a close() metódust, ha az SDK-ra már nincs szükség:

sdk.close()  // Heartbeat megszakítása, HTTP kliens bezárása, providerek felszabadítása