Scrivi dati

Questa guida è compatibile con Health Connect versione 1.1.0-alpha12 o successive.

Questa guida illustra la procedura di scrittura o aggiornamento dei dati in Health Connect.

Gestisci i valori zero

Alcuni tipi di dati, come passi, distanza o calorie, potrebbero avere un valore pari a 0. Scrivi valori pari a zero solo quando riflettono una vera inattività mentre l'utente indossava il dispositivo. Non scrivere valori pari a zero se il dispositivo non è stato indossato, se i dati non sono disponibili o se la batteria si è scaricata. In questi casi, ometti il record per evitare dati fuorvianti.

Configura la struttura dei dati

Prima di scrivere i dati, dobbiamo configurare i record. Per oltre 50 tipi di dati, ognuno con le rispettive strutture. Per ulteriori dettagli sui tipi di dati disponibili, consulta la documentazione di riferimento di Jetpack.

Record di base

Il tipo di dati Passi in Health Connect acquisisce il numero di passi che un utente ha compiuto tra le letture. Il conteggio dei passi rappresenta una misurazione comune su piattaforme per la salute, il fitness e il benessere.

Il seguente esempio mostra come impostare i dati del conteggio dei passi:

val zoneOffset = ZoneOffset.systemDefault().rules.getOffset(startTime)
val stepsRecord = StepsRecord(
    count = 120,
    startTime = startTime,
    endTime = endTime,
    startZoneOffset = zoneOffset,
    endZoneOffset = zoneOffset,
    metadata = Metadata.autoRecorded(
        device = Device(type = Device.TYPE_WATCH)
    )
)
healthConnectClient.insertRecords(listOf(stepsRecord))
HealthConnectManager.kt

Record con unità di misura

Health Connect può memorizzare i valori insieme alle relative unità di misura per garantire l'accuratezza. Un esempio è il tipo di dati Nutrizione, che è vasto e completo. Include un'ampia gamma di campi facoltativi relativi ai nutrienti, dai carboidrati totali alle vitamine. Ogni punto dati rappresenta i nutrienti che sono stati potenzialmente consumati nell'ambito di un pasto o di un alimento.

In questo tipo di dati, tutti i nutrienti sono rappresentati in unità di massa, mentre energy è rappresentato in un'unità di energia.

L'esempio seguente mostra come impostare i dati nutrizionali per un utente che ha mangiato una banana:

val endTime = Instant.now()
val startTime = endTime.minus(Duration.ofMinutes(1))

val banana = NutritionRecord(
    name = "banana",
    energy = 105.0.kilocalories,
    dietaryFiber = 3.1.grams,
    potassium = 0.422.grams,
    totalCarbohydrate = 27.0.grams,
    totalFat = 0.4.grams,
    saturatedFat = 0.1.grams,
    sodium = 0.001.grams,
    sugar = 14.0.grams,
    vitaminB6 = 0.0005.grams,
    vitaminC = 0.0103.grams,
    startTime = startTime,
    endTime = endTime,
    startZoneOffset = ZoneOffset.UTC,
    endZoneOffset = ZoneOffset.UTC,
    metadata = Metadata.activelyRecorded(
        device = Device(type = Device.TYPE_PHONE)
    )
)
HealthConnectManager.kt

Record con dati delle serie

Health Connect può memorizzare un elenco di dati di serie. Un esempio è il tipo di dati Frequenza cardiaca, che acquisisce una serie di campioni di battiti cardiaci rilevati tra le letture.

In questo tipo di dati, il parametro samples è rappresentato da un elenco di esempi di battito cardiaco. Ogni campione contiene un valore beatsPerMinute e un valore time.

L'esempio seguente mostra come impostare i dati della serie di frequenza cardiaca:

val endTime = Instant.now()
val startTime = endTime.minus(Duration.ofMinutes(5))

val heartRateRecord = HeartRateRecord(
    startTime = startTime,
    startZoneOffset = ZoneOffset.UTC,
    endTime = endTime,
    endZoneOffset = ZoneOffset.UTC,
    // records 10 arbitrary data, to replace with actual data
    samples = List(10) { index ->
        HeartRateRecord.Sample(
            time = startTime + Duration.ofSeconds(index.toLong()),
            beatsPerMinute = 100 + index.toLong(),
        )
    },
    metadata = Metadata.activelyRecorded(
        device = Device(type = Device.TYPE_WATCH)
    ))
HealthConnectManager.kt

Richiedi le autorizzazioni all'utente

Dopo aver creato un'istanza client, l'app deve richiedere le autorizzazioni all'utente. Gli utenti devono poter concedere o negare le autorizzazioni in qualsiasi momento. A questo scopo, crea un set di autorizzazioni per i tipi di dati richiesti. Assicurati che le autorizzazioni nel set siano dichiarate prima nel manifest di Android.

val permissions =
    setOf(
        HealthPermission.getReadPermission(HeartRateRecord::class),
        HealthPermission.getWritePermission(HeartRateRecord::class),
        HealthPermission.getReadPermission(StepsRecord::class),
        HealthPermission.getWritePermission(StepsRecord::class)
    )
HealthConnectManager.kt

val permissions = setOf(
        HealthPermission.getReadPermission(StepsRecord::class),
        HealthPermission.getWritePermission(StepsRecord::class),
        HealthPermission.getReadPermission(HeartRateRecord::class),
        HealthPermission.getWritePermission(HeartRateRecord::class)
    )

val requestPermissionsLauncher = rememberLauncherForActivityResult(
    contract = PermissionController.createRequestPermissionResultContract()
) { grantedPermissions ->
    if (grantedPermissions.containsAll(permissions)) {
        coroutineScope.launch { snackbarHostState.showSnackbar("Permissions granted!") }
    } else {
        coroutineScope.launch { snackbarHostState.showSnackbar("Permissions denied.") }
    }
}
HealthConnectActivity.kt

Scrivi dati

Uno dei flussi di lavoro comuni in Health Connect è la scrittura dei dati. Per aggiungere record, utilizza insertRecords.

L'esempio seguente mostra come scrivere dati inserendo i conteggi dei passi:

val zoneOffset = ZoneOffset.systemDefault().rules.getOffset(startTime)
val stepsRecord = StepsRecord(
    count = 120,
    startTime = startTime,
    endTime = endTime,
    startZoneOffset = zoneOffset,
    endZoneOffset = zoneOffset,
    metadata = Metadata.autoRecorded(
        device = Device(type = Device.TYPE_WATCH)
    )
)
healthConnectClient.insertRecords(listOf(stepsRecord))
HealthConnectManager.kt

Aggiorna i dati

Se devi modificare uno o più record, soprattutto quando devi sincronizzare il datastore della tua app con i dati di Health Connect, puoi aggiornare i tuoi dati. Esistono due modi per aggiornare i dati esistenti, a seconda dell'identificatore utilizzato per trovare i record.

Metadati

Vale la pena esaminare prima la classe Metadata, poiché è necessaria per l'aggiornamento dei dati. Al momento della creazione, ogni Record in Health Connect ha un campo metadata. Le seguenti proprietà sono pertinenti alla sincronizzazione:

Aggiorna dopo la lettura per intervallo di tempo

Per aggiornare i dati, prepara prima i record necessari. Se necessario, apporta modifiche ai record. Poi, chiama updateRecords per apportare le modifiche.

L'esempio seguente mostra come aggiornare i dati. A questo scopo, i valori di offset del fuso orario di ogni record vengono modificati in PST.

suspend fun updateSteps(
    healthConnectClient: HealthConnectClient,
    prevRecordStartTime: Instant,
    prevRecordEndTime: Instant
) {
    try {
        val request = healthConnectClient.readRecords(
            ReadRecordsRequest(
                recordType = StepsRecord::class, timeRangeFilter = TimeRangeFilter.between(
                    prevRecordStartTime,
                    prevRecordEndTime
                )
            )
        )

        val newStepsRecords = arrayListOf<StepsRecord>()
        for (record in request.records) {
            // Adjusted both offset values to reflect changes
            val sr = StepsRecord(
                count = record.count,
                startTime = record.startTime,
                startZoneOffset = record.startTime.atZone(ZoneId.of("PST")).offset,
                endTime = record.endTime,
                endZoneOffset = record.endTime.atZone(ZoneId.of("PST")).offset,
                metadata = record.metadata
            )
            newStepsRecords.add(sr)
        }

        healthConnectClient.updateRecords(newStepsRecords)
    } catch (e: Exception) {
        // Run error handling here
    }
}
HealthConnectManager.kt

Esegui l'upsert tramite l'ID record cliente

Se utilizzi i valori facoltativi ID record cliente e Versione record cliente, ti consigliamo di utilizzare insertRecords anziché updateRecords.

La funzione insertRecords è in grado di applicare l'upsert ai dati. Se i dati esistono in Health Connect in base all'insieme di ID record client fornito, vengono sovrascritti. In caso contrario, vengono scritti come nuovi dati. Questo scenario è utile ogni volta che devi sincronizzare i dati dal datastore dell'app a Health Connect.

L'esempio seguente mostra come eseguire un upsert sui dati estratti dal datastore dell'app:

 fun pullStepsFromDatastore(startTime: Instant, endTime: Instant) : ArrayList<StepsRecord> {
    val appStepsRecords = arrayListOf<StepsRecord>()
    // Pull data from app datastore
    // ...
    // Make changes to data if necessary
    // ...
    // Store data in appStepsRecords
    // ...
    var sr = StepsRecord(
        metadata = Metadata.activelyRecorded(
            clientRecordId = "Your client record ID",
            clientRecordVersion = 0L,
            device = Device(type = Device.TYPE_WATCH)
        ),
        startTime = startTime,
        startZoneOffset = startTime.atZone(ZoneId.of("PST")).offset,
        endTime = endTime,
        endZoneOffset = endTime.atZone(ZoneId.of("PST")).offset,
        count = 120
    )
    appStepsRecords.add(sr)
    // ...
    return appStepsRecords
}

suspend fun upsertSteps(
    healthConnectClient: HealthConnectClient,
    newStepsRecords: ArrayList<StepsRecord>
) {
    try {
        healthConnectClient.insertRecords(newStepsRecords)
    } catch (e: Exception) {
        // Run error handling here
    }
}
HealthConnectManager.kt

Dopodiché, puoi chiamare queste funzioni nel thread principale.

upsertSteps(healthConnectClient, pullStepsFromDatastore(
    startTime = startTime,
    endTime = endTime
))
HealthConnectManager.kt

Controllo del valore nella versione del record del cliente

Se la procedura di applicazione dell'upsert ai dati include la versione del record del client, Connessione Salute esegue controlli di confronto nei valori clientRecordVersion. Se la versione dei dati inseriti è superiore a quella dei dati esistenti, viene eseguito l'upsert. In caso contrario, il processo ignora la modifica e il valore rimane invariato.

Per includere il controllo delle versioni nei dati, devi fornire a Metadata.clientRecordVersion un valore Long basato sulla logica di controllo delle versioni.

val endTime = Instant.now()
val startTime = endTime.minus(Duration.ofMinutes(15))

val stepsRecord = StepsRecord(
    count = 100L,
    startTime = startTime,
    startZoneOffset = ZoneOffset.UTC,
    endTime = endTime,
    endZoneOffset = ZoneOffset.UTC,
    metadata = Metadata.activelyRecorded(
        clientRecordId = "Your supplied record ID",
        clientRecordVersion = 0L, // Your supplied record version
        device = Device(type = Device.TYPE_WATCH)
    )
)
HealthConnectManager.kt

Le operazioni di upsert non incrementano automaticamente version ogni volta che vengono apportate modifiche, impedendo così eventuali sovrascritture impreviste dei dati. In questo caso, devi fornire manualmente un valore più alto.

Indicazioni generali

La tua app deve scrivere tutti i dati proprietari supportati. Se vuoi, puoi scegliere di fare in modo che la tua app scriva i dati ottenuti da origini di terze parti. Tuttavia, se la tua app ha letto dati da Health Connect, questi dati non devono essere riscritti in Health Connect.

Quando scrivi dati importati o derivati da un'altra origine, devi attribuire correttamente l'origine e i metadati del dispositivo di origine. Per farlo, devi fornire i seguenti metadati per ogni opera scritta:

• recordingMethod: per i dati registrati automaticamente o manualmente, ci aspettiamo che il metodo di registrazione venga aggiornato in modo da riflettere il tipo di attività registrata:
  • RECORDING_METHOD_AUTOMATICALLY_RECORDED: se i dati sono stati registrati automaticamente, ad esempio se un fitness band ha rilevato automaticamente che l'utente è andato a correre.
  • RECORDING_METHOD_ACTIVELY_RECORDED: se l'utente ha iniziato una nuova attività, ad esempio un'uscita in bicicletta, sul suo indossabile.
  • RECORDING_METHOD_MANUAL_ENTRY: se l'utente ha inserito i dati manualmente.
• device.type: devi specificare un tipo di dispositivo tra i tipi Device supportati.
• device.manufacturer: il produttore del dispositivo, ad esempio "Fitbit".
• device.model: il modello del dispositivo, ad esempio "Charge 3".
• device.udi: (facoltativo) la parte dell'identificatore del dispositivo (DI) dell'identificatore univoco del dispositivo (UDI) del dispositivo medico. Per informazioni dettagliate sulle autorizzazioni richieste e sulle indicazioni sulla privacy, consulta la guida ai metadati.

L'impostazione corretta dei metadati è fondamentale per la trasparenza dei dati e aiuta gli utenti a capire da dove provengono le loro informazioni sanitarie. Per informazioni dettagliate, consulta la guida ai metadati di Connessione Salute.

Se i dati della tua app sono stati importati da un'altra app, la responsabilità di scrivere i propri dati in Health Connect ricade sull'altra app.

È inoltre consigliabile implementare una logica che gestisca le eccezioni di scrittura, ad esempio dati al di fuori dei limiti o un errore di sistema interno. Puoi applicare le tue strategie di backoff e ripetizione dei tentativi a un meccanismo di pianificazione dei job. Se la scrittura in Health Connect non va a buon fine, assicurati che l'app possa superare questo punto di esportazione. Non dimenticare di registrare e segnalare gli errori per facilitare la diagnosi.

Quando monitori i dati, puoi seguire un paio di suggerimenti a seconda del modo in cui la tua app scrive i dati.

Gestione del fuso orario

Quando scrivi record basati sul tempo, evita di impostare gli offset su zoneOffset.UTC per impostazione predefinita, perché ciò può portare a timestamp imprecisi quando gli utenti si trovano in altre zone. Calcola invece l'offset in base alla posizione effettiva del dispositivo. Puoi recuperare il fuso orario del dispositivo utilizzando ZoneId.systemDefault().

val endTime = Instant.now()
val startTime = endTime.minus(Duration.ofDays(1))
val stepsRecords = mutableListOf<StepsRecord>()
var sampleTime = startTime
val minutesBetweenSamples = 15L
while (sampleTime < endTime) {
    // Get the default ZoneId then convert it to an offset
    val zoneOffset = ZoneOffset.systemDefault().rules.getOffset(sampleTime)
    stepsRecords += StepsRecord(
        startTime = sampleTime.minus(Duration.ofMinutes(minutesBetweenSamples)),
        startZoneOffset = zoneOffset,
        endTime = sampleTime,
        endZoneOffset = zoneOffset,
        count = Random.nextLong(1, 100),
        metadata = Metadata.activelyRecorded(device = Device(type = Device.TYPE_WATCH)),
    )
    sampleTime = sampleTime.plus(Duration.ofMinutes(minutesBetweenSamples))
}
healthConnectClient.insertRecords(
    stepsRecords
)
HealthConnectManager.kt

Per ulteriori dettagli, consulta la documentazione per ZoneId.

Frequenza e granularità di scrittura

Quando scrivi dati su Health Connect, utilizza la risoluzione appropriata. L'utilizzo della risoluzione appropriata contribuisce a ridurre il carico di archiviazione, mantenendo al contempo dati coerenti e accurati. La risoluzione dei dati comprende due aspetti:

• Frequenza di scrittura: la frequenza con cui l'applicazione scrive nuovi dati in Health Connect.
  • Scrivi i dati il più spesso possibile quando sono disponibili nuovi dati, tenendo conto delle prestazioni del dispositivo.
  • Per evitare di influire negativamente sulla durata della batteria e su altri aspetti delle prestazioni, l'intervallo massimo tra le scritture deve essere di 15 minuti.
• Granularità dei dati scritti: la frequenza con cui i dati sono stati campionati.
  • Ad esempio, scrivi campioni di battito cardiaco ogni 5 secondi.
  • Non tutti i tipi di dati richiedono la stessa frequenza di campionamento. L'aggiornamento dei dati sul conteggio dei passi ogni secondo non offre molti vantaggi rispetto a una cadenza meno frequente, ad esempio ogni 60 secondi.
  • Frequenze di campionamento più elevate possono offrire agli utenti una visione più dettagliata e granulare dei loro dati sul fitness. Le frequenze di campionamento devono trovare un equilibrio tra dettagli e prestazioni.

Linee guida aggiuntive

Segui queste linee guida quando scrivi i dati:

• Durante ogni sincronizzazione, scrivi solo i dati nuovi e quelli aggiornati che sono stati modificati dall'ultima sincronizzazione.
• Suddividi le richieste in blocchi di massimo 1000 record per richiesta di scrittura.
• Limita l'esecuzione delle attività solo quando il dispositivo è inattivo e la batteria non è in esaurimento.
• Per le attività in background, utilizza WorkManager per pianificare attività periodiche con un periodo di tempo massimo di 15 minuti.

Il seguente codice utilizza WorkManager per pianificare attività periodiche in background, con un periodo di tempo massimo di 15 minuti e un intervallo flessibile di 5 minuti. Questa configurazione viene impostata utilizzando la classe PeriodicWorkRequest.Builder.

val constraints = Constraints.Builder()
    .requiresBatteryNotLow()
    .requiresDeviceIdle(true)
    .build()

val writeDataWork = PeriodicWorkRequestBuilder<WriteDataToHealthConnectWorker>(
        15,
        TimeUnit.MINUTES,
        5,
        TimeUnit.MINUTES
    )
    .setConstraints(constraints)
    .build()

Monitoraggio attivo

Sono incluse le app che eseguono il monitoraggio basato su eventi, come l'allenamento e il sonno, o l'inserimento manuale da parte dell'utente, come l'alimentazione. Questi record vengono creati quando l'app è in primo piano o in rari casi in cui viene utilizzata alcune volte al giorno.

Verifica che la tua app non mantenga Health Connect in esecuzione per l'intera durata dell'evento.

I dati devono essere scritti in Health Connect in uno dei due modi seguenti:

• Sincronizza i dati con Health Connect al termine dell'evento. Ad esempio, sincronizza i dati quando l'utente termina una sessione di allenamento monitorata.
• Pianifica un'attività una tantum utilizzando WorkManager per sincronizzare i dati in un secondo momento.

Best practice per la granularità e la frequenza delle scritture

Quando scrivi dati su Health Connect, utilizza la risoluzione appropriata. L'utilizzo della risoluzione appropriata contribuisce a ridurre il carico di archiviazione, mantenendo al contempo dati coerenti e accurati. La risoluzione dei dati comprende due aspetti:

1. Frequenza di scrittura: la frequenza con cui l'applicazione invia nuovi dati a Health Connect. Scrivi i dati il più spesso possibile quando sono disponibili nuovi dati, tenendo conto delle prestazioni del dispositivo. Per evitare di influire negativamente sulla durata della batteria e su altri aspetti delle prestazioni, l'intervallo massimo tra le scritture deve essere di 15 minuti.

2. Granularità dei dati scritti: la frequenza con cui i dati inviati sono stati campionati. Ad esempio, scrivi campioni di frequenza cardiaca ogni 5 secondi. Non tutti i tipi di dati richiedono la stessa frequenza di campionamento. L'aggiornamento dei dati relativi al conteggio dei passi ogni secondo non offre molti vantaggi rispetto a una cadenza meno frequente, ad esempio ogni 60 secondi. Tuttavia, frequenze di campionamento più elevate possono fornire agli utenti una visione più dettagliata e granulare dei loro dati sul fitness. Le frequenze di campionamento devono trovare un equilibrio tra dettagli e prestazioni.

Struttura i record per i dati delle serie

Per i tipi di dati che utilizzano una serie di campioni, come HeartRateRecord, è importante strutturare correttamente i record. Anziché creare un unico record di un giorno che viene aggiornato costantemente, devi creare più record più piccoli, ognuno dei quali rappresenta un intervallo di tempo specifico.

Ad esempio, per i dati sulla frequenza cardiaca, devi creare un nuovo HeartRateRecord per ogni minuto. Ogni record avrà un'ora di inizio e un'ora di fine che coprono quel minuto e conterrà tutti i campioni di frequenza cardiaca acquisiti durante quel minuto.

Durante le sincronizzazioni regolari con Connessione Salute (ad esempio ogni 15 minuti), l'app deve scrivere tutti i record di un minuto creati dalla sincronizzazione precedente. In questo modo, i record rimangono di dimensioni gestibili e le prestazioni di query ed elaborazione dei dati migliorano.

L'esempio seguente mostra come creare un HeartRateRecord per un singolo minuto, contenente più campioni:

val startTime = Instant.now().truncatedTo(ChronoUnit.MINUTES)
val endTime = startTime.plus(Duration.ofMinutes(1))

val heartRateRecord = HeartRateRecord(
    startTime = startTime,
    startZoneOffset = ZoneOffset.UTC,
    endTime = endTime,
    endZoneOffset = ZoneOffset.UTC,
    // Create a new record every minute, containing a list of samples.
    samples = listOf(
        HeartRateRecord.Sample(
            time = startTime + Duration.ofSeconds(15),
            beatsPerMinute = 80,
        ),
        HeartRateRecord.Sample(
            time = startTime + Duration.ofSeconds(30),
            beatsPerMinute = 82,
        ),
        HeartRateRecord.Sample(
            time = startTime + Duration.ofSeconds(45),
            beatsPerMinute = 85,
        )
    ),
    metadata = Metadata.activelyRecorded(
        device = Device(type = Device.TYPE_WATCH)
    ))
HealthConnectManager.kt

Scrivi i dati monitorati durante il giorno

Per i dati raccolti su base continuativa, come i passi, l'applicazione deve scrivere su Connessione Salute il più spesso possibile quando sono disponibili nuovi dati. Per evitare di influire negativamente sulla durata della batteria e su altri aspetti delle prestazioni, l'intervallo massimo tra le scritture deve essere di 15 minuti.

I dati devono essere scritti in Health Connect al termine della sessione di allenamento o di sonno. Per il monitoraggio attivo, ad esempio l'allenamento e il sonno, o l'inserimento manuale da parte dell'utente, come l'alimentazione, questi record vengono creati quando l'app è in primo piano o in rari eventi in cui viene utilizzata alcune volte al giorno.

Verifica che l'app non mantenga Health Connect in esecuzione per l'intera durata dell'evento.

I dati devono essere scritti in Health Connect in uno dei due modi seguenti:

• Sincronizza i dati con Health Connect al termine dell'evento. Ad esempio, sincronizza i dati quando l'utente termina una sessione di allenamento monitorata.
• Pianifica un'attività una tantum utilizzando WorkManager per sincronizzare i dati in un secondo momento.

Sessioni di allenamento e sonno

Come minimo, l'applicazione deve seguire le indicazioni riportate nella colonna Previsto della Tabella 2. Se possibile, segui le indicazioni nella colonna Ottimale.

La tabella seguente mostra come scrivere i dati durante un allenamento:

La Tabella 3 mostra come scrivere i dati durante o dopo una sessione di sonno:

Manifestazioni multisportive

Questo approccio utilizza i tipi di dati e le strutture esistenti e verifica la compatibilità con le implementazioni e i lettori di dati di Health Connect attuali. Questo è un approccio comune adottato dalle piattaforme di fitness.

Inoltre, le singole sessioni, come nuoto, ciclismo e corsa, non sono collegate intrinsecamente in Health Connect e i lettori di dati devono dedurre la relazione tra queste sessioni in base alla loro vicinanza temporale. Le transizioni tra i segmenti, ad esempio dal nuoto alla bicicletta, non sono rappresentate in modo esplicito.

L'esempio seguente mostra come scrivere i dati per un triathlon:

val swimStartTime = Instant.parse("2024-08-22T08:00:00Z")
val swimEndTime = Instant.parse("2024-08-22T08:30:00Z")
val bikeStartTime = Instant.parse("2024-08-22T08:40:00Z")
val bikeEndTime = Instant.parse("2024-08-22T09:40:00Z")
val runStartTime = Instant.parse("2024-08-22T09:50:00Z")
val runEndTime = Instant.parse("2024-08-22T10:20:00Z")

val swimSession = ExerciseSessionRecord(
    startTime = swimStartTime,
    endTime = swimEndTime,
    exerciseType = ExerciseSessionRecord.EXERCISE_TYPE_SWIMMING_OPEN_WATER,
    metadata = Metadata.activelyRecorded(
        device = Device(type = Device.TYPE_WATCH)
    ),
    startZoneOffset = null,
    endZoneOffset = null,
)

val bikeSession = ExerciseSessionRecord(
    startTime = bikeStartTime,
    endTime = bikeEndTime,
    exerciseType = ExerciseSessionRecord.EXERCISE_TYPE_BIKING,
    metadata = Metadata.activelyRecorded(
        device = Device(type = Device.TYPE_WATCH)
    ),
    startZoneOffset = null,
    endZoneOffset = null,
)

val runSession = ExerciseSessionRecord(
    startTime = runStartTime,
    endTime = runEndTime,
    exerciseType = ExerciseSessionRecord.EXERCISE_TYPE_RUNNING,
    metadata = Metadata.activelyRecorded(
        device = Device(type = Device.TYPE_WATCH)
    ),
    startZoneOffset = null,
    endZoneOffset = null,
)

healthConnectClient.insertRecords(listOf(swimSession, bikeSession, runSession))
HealthConnectManager.kt

Gestisci le eccezioni

Connessione Salute genera eccezioni standard per le operazioni CRUD quando si verifica un problema. La tua app deve rilevare e gestire ciascuna di queste eccezioni in modo appropriato.

Ogni metodo su HealthConnectClient elenca le eccezioni che possono essere generate. In generale, l'app deve gestire le seguenti eccezioni: