Android SDK erabilera

Hasieratzea

Erabili builder eredua SDK instantzia bat sortzeko. build() funtzioa suspend funtzio bat da, DPoP gako-bikoteen sorrera, tokenen aktibazioa eta eskubideen egiaztapena egiten dituena.

import com.vitalera.sdk.VitaleraSdk

val sdk = VitaleraSdk.builder()
    .context(applicationContext)           // Required on Android
    .clientId("your-org-license-key")      // Required -- obtain from sdk@vitalera.com
    .addProvider("omron")                  // Declare which providers to use
    .addProvider("polar")
    .addProvider("standard-ble")
    .connectedMode(true)                   // Optional: enable patient/observation API
    .build()                               // suspend: performs DPoP auth + entitlement check

Kudeatu autentifikazio-erroreak hasieratzean:

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

Gailuen aurkikuntza

Erabili DiscoveryFilter gailu-mota zehatzak bilatzeko. Aurkikuntzak Kotlin Flow<DeviceDescriptor> itzultzen du, aurkitutako gailuak igortzen dituena eta denbora-mugaren ondoren osatzen dena.

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

// Scan for blood pressure monitors across all registered providers
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)")
}

Iragazki-aukerak

// Only Omron devices
val omronFilter = DiscoveryFilter(providers = setOf("omron"))

// Only devices whose name starts with "Polar"
val polarFilter = DiscoveryFilter(namePrefix = "Polar")

// Combine: Polar heart rate monitors only
val combinedFilter = DiscoveryFilter(
    providers = setOf("polar"),
    capabilities = setOf(DeviceCapability.HEART_RATE),
)

Gailuaren konexioa

Sortu gailu bat DeviceDescriptor batetik eta konektatu. connect() funtzioa suspend funtzio bat da denbora-muga konfiguragarriarekin.

val device = sdk.devices.createDevice(descriptor)

// Connect (suspends until connected or timeout)
device.connect(timeoutMs = 10_000L)

// Observe connection state reactively
launch {
    device.connectionState.collect { state ->
        when (state) {
            is ConnectionState.Disconnected -> showStatus("Disconnected")
            is ConnectionState.Connecting -> showStatus("Connecting...")
            is ConnectionState.Connected -> showStatus("Connected")
            is ConnectionState.Disconnecting -> showStatus("Disconnecting: ${state.reason}")
            is ConnectionState.Error -> showError(state.cause)
        }
    }
}

Datu-bilketa

collect() metodoak behaketa tipatu klaseen Flow<BaseObservation> bat itzultzen du. Irakurketa bakarreko gailuetarako (adib., odol-presioa), Flowak behaketa bat igortzen du eta osatzen da. Streaming gailuetarako (adib., bihotz-maiztasuna), etengabe igortzen du.

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+ typed observation classes available
    }
}

// Disconnect when done
device.disconnect()

Konektatutako modua

Hasieratzean connectedMode(true) ezartzen denean, ebatzi pazienteak eta bidali behaketak Vitalera backend-era:

// Resolve a patient by external identifier
val patient = sdk.connected().resolveMonitored("patient-ext-id")

// Post an observation
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"),
        ),
    ),
)

Erroreen kudeaketa

SDK errore guztiek SdkError klase itxia hedatzen dute:

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

Gailu anitzak

Konektatu gailu anitzetara aldi berean korutinen bidez:

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

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

Health Connect

Irakurri Google Health Connect-etik (BLE eskaneatzerik gabe):

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

Baliabideen garbitzea

Beti deitu close() SDK jada behar ez denean:

sdk.close()  // Cancels heartbeat, closes HTTP client, disposes providers