Scrivi dati

Questa guida è compatibile con la versione 1.1.0-alpha12 di Health Connect.

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

Gestire i valori zero

Alcuni tipi di dati come passi, distanza o calorie potrebbero avere un valore di 0. Scrivi solo valori pari a zero 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 sono mancanti o se la batteria è scarica. In questi casi, ometti il record per evitare dati fuorvianti.

Configurare la struttura dei dati

Prima di scrivere i dati, dobbiamo configurare i record. Per più di 50 tipi di dati, ognuno con le rispettive strutture. Per ulteriori dettagli sui tipi di dati disponibili, consulta le Informazioni di riferimento su Jetpack.

Documenti 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(
        device = Device(type = Device.TYPE_WATCH),
        recordingMethod = Metadata.RECORDING_METHOD_AUTOMATICALLY_RECORDED
    )
)
healthConnectClient.insertRecords(listOf(stepsRecord))
HealthConnectManager.kt

Record con unità di misura

Health Connect può memorizzare i valori insieme alle relative unità di misura per fornire accuratezza. Un esempio è il tipo di dati Nutrizione, che è vasto e completo. Include un'ampia varietà di campi facoltativi per i nutrienti, che vanno dai carboidrati totali alle vitamine. Ogni punto dati rappresenta i nutrienti che sono stati potenzialmente consumati come parte 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.

Il seguente esempio 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(
        device = Device(type = Device.TYPE_PHONE)
    )
)
HealthConnectManager.kt

Record con dati di serie

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

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

L'esempio seguente mostra come impostare i dati delle serie della 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(
        device = Device(type = Device.TYPE_WATCH)
    ))
HealthConnectManager.kt

Richiedi le autorizzazioni all'utente

Dopo aver creato un'istanza client, la tua 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.

// Create a set of permissions for required data types
val PERMISSIONS =
    setOf(
  HealthPermission.getReadPermission(HeartRateRecord::class),
  HealthPermission.getWritePermission(HeartRateRecord::class),
  HealthPermission.getReadPermission(StepsRecord::class),
  HealthPermission.getWritePermission(StepsRecord::class)
)

Utilizza getGrantedPermissions per verificare se alla tua app sono già state concesse le autorizzazioni richieste. In caso contrario, utilizza createRequestPermissionResultContract per richiedere queste autorizzazioni. Viene visualizzata la schermata delle autorizzazioni di Health Connect.

// Create the permissions launcher
val requestPermissionActivityContract = PermissionController.createRequestPermissionResultContract()

val requestPermissions = registerForActivityResult(requestPermissionActivityContract) { granted ->
  if (granted.containsAll(PERMISSIONS)) {
    // Permissions successfully granted
  } else {
    // Lack of required permissions
  }
}

suspend fun checkPermissionsAndRun(healthConnectClient: HealthConnectClient) {
  val granted = healthConnectClient.permissionController.getGrantedPermissions()
  if (granted.containsAll(PERMISSIONS)) {
    // Permissions already granted; proceed with inserting or reading data
  } else {
    requestPermissions.launch(PERMISSIONS)
  }
}

Poiché gli utenti possono concedere o revocare le autorizzazioni in qualsiasi momento, la tua app deve controllare le autorizzazioni ogni volta prima di utilizzarle e gestire gli scenari in cui l'autorizzazione viene revocata.

Scrivi dati

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

Il seguente esempio mostra come scrivere i 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(
        device = Device(type = Device.TYPE_WATCH),
        recordingMethod = Metadata.RECORDING_METHOD_AUTOMATICALLY_RECORDED
    )
)
healthConnectClient.insertRecords(listOf(stepsRecord))
HealthConnectManager.kt

Aggiorna i dati

Se devi modificare uno o più record, soprattutto quando devi sincronizzare l'archivio dati dell'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 quando si aggiornano i dati. Al momento della creazione, ogni Record in Health Connect ha un campo metadata. Le seguenti proprietà sono pertinenti per la sincronizzazione:

Aggiornamento dopo la lettura per intervallo di tempo

Per aggiornare i dati, prepara prima i record necessari. Apporta le modifiche ai record, se necessario. Poi chiama il numero updateRecords per apportare le modifiche.

Il seguente esempio 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

Upsert tramite 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 eseguire l'upsert dei dati. Se i dati esistono in Health Connect in base al set specificato di ID record cliente, vengono sovrascritti. In caso contrario, viene scritto come nuovi dati. Questo scenario è utile ogni volta che devi sincronizzare i dati dal datastore dell'app a Health Connect.

Il seguente esempio mostra come eseguire un'operazione di upsert sui dati estratti dall'archivio dati dell'app:

suspend 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(
            clientRecordId = "Your client record ID",
            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 cliente

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

Per includere il controllo delle versioni nei dati, devi fornire Metadata.clientRecordVersion con un valore Long in base alla 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(
        clientRecordId = "Your supplied record ID",
        clientRecordVersion = 0L, // Your supplied record version
        device = Device(type = Device.TYPE_WATCH)
    )
)
HealthConnectManager.kt

Gli upsert non incrementano automaticamente version ogni volta che vengono apportate modifiche, impedendo qualsiasi istanza imprevista di sovrascrittura dei dati. In questo caso, devi fornire manualmente un valore più alto.

Indicazioni generali

La tua app deve scrivere tutti i dati proprietari supportati. (Facoltativo) Puoi scegliere di fare in modo che la tua app scriva i dati ottenuti da fonti di terze parti. Tuttavia, se la tua app ha letto i dati di Health Connect, questi non devono essere riscritti in Health Connect.

Quando scrivi dati importati o derivati da un'altra origine, devi attribuirne correttamente l'origine e i metadati del dispositivo di origine. A questo scopo, devi fornire i seguenti metadati per ogni registrazione scritta:

• recordingMethod: per i dati registrati automaticamente o manualmente, prevediamo 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 una smartband ha rilevato automaticamente che l'utente è andato a correre.
  • RECORDING_METHOD_ACTIVELY_RECORDED: Se l'utente ha iniziato una nuova attività, ad esempio una corsa in bicicletta sul wearable.
  • RECORDING_METHOD_MANUAL_ENTRY: se l'utente ha inserito i dati manualmente.
• device.type: devi specificare un tipo di dispositivo da uno dei tipi Device supportati.
• device.manufacturer: il produttore del dispositivo, ad esempio "Fitbit".
• device.model: il modello del dispositivo, ad esempio "Charge 3".

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 complete, consulta la guida ai metadati di Health Connect.

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.

È anche consigliabile implementare una logica che gestisca le eccezioni di scrittura, ad esempio i dati al di fuori dei limiti o un errore del sistema interno. Puoi applicare le tue strategie di backoff e ripetizione a un meccanismo di pianificazione dei job. Se la scrittura in Health Connect non va a buon fine, assicurati che la tua 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 alcuni 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 offset su zoneOffset.UTC per impostazione predefinita, perché ciò può comportare 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(),
    )
    sampleTime = sampleTime.plus(Duration.ofMinutes(minutesBetweenSamples))
}
healthConnectClient.insertRecords(
    stepsRecords
)
HealthConnectManager.kt

Per ulteriori dettagli, consulta la documentazione relativa a ZoneId.

Scrittura di frequenza e granularità

Quando scrivi dati su Health Connect, utilizza una 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 sono stati campionati i dati.
  • Ad esempio, scrivi campioni di frequenza cardiaca ogni 5 secondi.
  • Non tutti i tipi di dati richiedono la stessa frequenza di campionamento. Non è molto utile aggiornare i dati del conteggio dei passi ogni secondo, a differenza di una cadenza meno frequente, ad esempio ogni 60 secondi.
  • Frequenze di campionamento più elevate possono fornire agli utenti una visione più dettagliata e granulare dei propri dati sul fitness. Le frequenze di campionamento devono trovare un equilibrio tra dettaglio e prestazioni.

Linee guida aggiuntive

Segui queste linee guida quando scrivi i dati:

• A ogni sincronizzazione, vengono scritti solo i dati nuovi e quelli aggiornati modificati dall'ultima sincronizzazione.
• Dividi 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'esercizio fisico e il sonno o l'inserimento manuale di dati da parte dell'utente, ad esempio l'alimentazione. Questi record vengono creati quando l'app è in primo piano o in rari casi in cui viene utilizzata più 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 una 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 la tua 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 sono stati campionati i dati push. Ad esempio, scrivi campioni di frequenza cardiaca ogni 5 secondi. Non tutti i tipi di dati richiedono la stessa frequenza di campionamento. Non è molto utile aggiornare i dati del conteggio dei passi ogni secondo, 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 propri dati su salute e fitness. Le frequenze di campionamento devono trovare un equilibrio tra dettagli e prestazioni.

Strutturare i record per i dati delle serie

Per i tipi di dati che utilizzano una serie di campioni, ad esempio HeartRateRecord, è importante strutturare correttamente i record. Anziché creare un singolo 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 avrebbe un'ora di inizio e un'ora di fine che copre quel minuto e conterrebbe tutti i campioni di frequenza cardiaca acquisiti durante quel minuto.

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

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(
        device = Device(type = Device.TYPE_WATCH)
    ))
HealthConnectManager.kt

Scrivere i dati monitorati durante il giorno

Per i dati raccolti in modo continuativo, come i passi, l'applicazione deve scrivere su Health Connect 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 dell'allenamento o della sessione di sonno. Per il monitoraggio attivo, ad esempio attività fisica e sonno, o l'inserimento manuale di dati 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.

Sessioni di allenamento e sonno

Come minimo, la tua applicazione deve seguire le indicazioni riportate nella colonna Previsto della Tabella 2. Se possibile, segui le indicazioni riportate nella colonna Best.

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 tipi e strutture di dati esistenti e verifica la compatibilità con le implementazioni e i lettori di dati di Health Connect attuali. Si tratta di un approccio comune adottato dalle piattaforme per il fitness.

Inoltre, le singole sessioni come nuoto, ciclismo e corsa non sono intrinsecamente collegate 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.

Il seguente esempio 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(
        device = Device(type = Device.TYPE_WATCH)
    ),
    startZoneOffset = null,
    endZoneOffset = null,
)

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

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

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

Gestire 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 in HealthConnectClient elenca le eccezioni che possono essere generate. In generale, la tua app deve gestire le seguenti eccezioni: