Sessioni

In Connessione Salute una sessione è un intervallo di tempo durante il quale un utente esegue un attività. I tipi di dati SleepSessionRecord e ExerciseSessionRecord sono entrambi sessioni.

Le sessioni consentono agli utenti di misurare le prestazioni in base al tempo in un arco di tempo, come dati del battito cardiaco continuo o dati sulla posizione.

Le sessioni di ExerciseSessionRecord includono una serie di attività, dalla corsa al badminton.

Le sessioni di SleepSessionRecord contengono dati che registrano le fasi del sonno, come AWAKE, SLEEPING e DEEP.

I dati di sottotipo sono dati che "appartengono" a una sessione ed è significativa solo quando viene letto con una sessione per i genitori, ad esempio fase del sonno, segmento di allenamento.

I dati associati, ovvero Record, possono essere letti separatamente o insieme ad altri sessioni, ad esempio passi, battito cardiaco.

Indicazioni generali

Ecco alcune linee guida di best practice su come lavorare con le sessioni in Salute Connettiti.

  • Le sessioni dovrebbero essere usate per aggiungere dati da un'attività o un esercizio specifico oppure per il sonno:
suspend fun writeExerciseSession(healthConnectClient: HealthConnectClient) {
    healthConnectClient.insertRecords(
        listOf(
            ExerciseSessionRecord(
                startTime = Instant.parse("2022-05-10T10:00:00.000Z"),
                startZoneOffset = ZoneOffset.of("-08:00"),
                endTime = Instant.parse("2022-05-10T11:00:00.000Z"),
                endZoneOffset = ZoneOffset.of("-08:00"),
                exerciseType = ExerciseSessionRecord.ExerciseType.WALKING,
                title = "My Walk"
            ),
            StepsRecord(
                startTime = Instant.parse("2022-05-10T10:00:00.000Z"),
                startZoneOffset = ZoneOffset.of("-08:00"),
                endTime = Instant.parse("2022-05-10T10:30:00.000Z"),
                endZoneOffset = ZoneOffset.of("-08:00"),
                count = 2800
            ),
StepsRecord(
                startTime = Instant.parse("2022-05-10T10:30:00.000Z"),
                startZoneOffset = ZoneOffset.of("-08:00"),
                endTime = Instant.parse("2022-05-10T11:00:00.000Z"),
                endZoneOffset = ZoneOffset.of("-08:00"),
                count = 3200
            ),  
        )
    )
}
  • Le sessioni non devono essere utilizzate per misurazioni generali, come il numero di passi giornalieri conteggi.
  • I dati del sottotipo non contengono un UID, ma i dati associati hanno UID distinti.
  • I dati del sottotipo devono essere allineati in una sessione con timestamp sequenziali che non si sovrappongano. Tuttavia, sono consentiti intervalli vuoti.
  • Le sessioni sono utili se l'utente desidera che i dati vengano associati (e tracciati come parte di) una sessione, anziché essere registrati continuamente.

Sessioni di sonno

Puoi leggere o scrivere dati relativi al sonno in Connessione Salute. I dati relativi al sonno vengono visualizzati come e può essere suddivisa in 8 fasi del sonno distinte:

  • UNKNOWN: non specificato o sconosciuto se l'utente dorme.
  • AWAKE: l'utente è sveglio durante un ciclo del sonno, non durante il giorno.
  • SLEEPING: descrizione del sonno generica o non granulare.
  • OUT_OF_BED: l'utente si alza dal letto nel bel mezzo di una sessione di sonno.
  • AWAKE_IN_BED: l'utente è sveglio nel letto.
  • LIGHT: l'utente ha un ciclo di sonno leggero.
  • DEEP: l'utente è in un ciclo di sonno profondo.
  • REM: l'utente sta vivendo un ciclo del sonno REM.

Questi valori rappresentano il tipo di sonno sperimentato da un utente in un intervallo di tempo. Scrivere le fasi del sonno è facoltativo, ma consigliato se disponibile.

Scrivere sessioni di sonno con o senza fasi del sonno

Il tipo di dati SleepSessionRecord è composto da due parti:

  1. La sessione complessiva, che comprende l'intera durata del sonno.
  2. Fasi individuali durante la sessione di sonno, come sonno leggero o profondo dormire meglio.

Ecco come inserire una sessione di sonno senza fasi:

      SleepSessionRecord(
        title = "weekend sleep",
        startTime = startTime,
        endTime = endTime,
        startZoneOffset = ZoneOffset.UTC,
        endZoneOffset = ZoneOffset.UTC,
      )

Di seguito viene indicato come aggiungere fasi che coprono l'intero periodo di una sessione di sonno:

val stages = listOf(
    SleepSessionRecord.Stage(
        startTime = START_TIME
        endTime = END_TIME,
        stage = SleepSessionRecord.STAGE_TYPE_SLEEPING,
    )
)

SleepSessionRecord(
        title = "weekend sleep",
        startTime = START_TIME,
        endTime = END_TIME,
        startZoneOffset = START_ZONE_OFFSET,
        endZoneOffset = END_ZONE_OFFSET,
        stages = stages,
      )
  }

Leggere una sessione di sonno

Per ogni sessione di sonno restituita, devi controllare se i dati delle fasi del sonno sono sono presenti anche:

suspend fun readSleepSessions(
    healthConnectClient: HealthConnectClient,
    startTime: Instant,
    endTime: Instant
) {
    val response =
        healthConnectClient.readRecords(
            ReadRecordsRequest(
                SleepSessionRecord::class,
                timeRangeFilter = TimeRangeFilter.between(startTime, endTime)
            )
        )
    for (sleepRecord in response.records) {
        // Retrieve relevant sleep stages from each sleep record
        val sleepStages = sleepRecord.stages
    }
}

Eliminare una sessione di sonno

Ecco come eliminare una sessione. Per questo esempio, abbiamo utilizzato una sessione di sonno:

suspend fun deleteSleepSession(
    healthConnectClient: HealthConnectClient,
    sleepRecord: SleepSessionRecord,
) {
    val timeRangeFilter = TimeRangeFilter.between(sleepRecord.startTime, sleepRecord.endTime)
    healthConnectClient.deleteRecords(SleepSessionRecord::class, timeRangeFilter)
}

Sessioni di allenamento

Le sessioni di allenamento possono includere qualsiasi cosa, dalla corsa al badminton.

Scrittura delle sessioni di allenamento

Per creare una richiesta di inserimento che include una sessione, procedi nel seguente modo:

suspend fun writeExerciseSession(healthConnectClient: HealthConnectClient) {
    healthConnectClient.insertRecords(
        listOf(
            ExerciseSessionRecord(
                startTime = START_TIME,
                startZoneOffset = START_ZONE_OFFSET,
                endTime = END_TIME,
                endZoneOffset = END_ZONE_OFFSET,
                exerciseType = ExerciseSessionRecord.ExerciseType.RUNNING,
                title = "My Run"
            ),
            DistanceRecord(
                startTime = START_TIME,
                startZoneOffset = START_ZONE_OFFSET,
                endTime = END_TIME,
                endZoneOffset = END_ZONE_OFFSET,
                distance = 5000.meters
            ),
            // ... other records
        )
    )
}

Nota come nell'esempio precedente viene aggiunto un record per Distance, che si estende l'intera durata della sessione, ma i dati possono essere aggiunti con granularità.

Se l'app aveva misurato regolarmente la distanza durante la corsa, si avvicina di nuovo includerebbe molti record di Distanza, ognuno dei quali rappresenta la distanza in una parte dell'esecuzione.

Lettura di una sessione di allenamento

Ecco un esempio di come leggere una sessione di allenamento:

suspend fun readExerciseSessions(
    healthConnectClient: HealthConnectClient,
    startTime: Instant,
    endTime: Instant
) {
    val response =
        healthConnectClient.readRecords(
            ReadRecordsRequest(
                ExerciseSessionRecord::class,
                timeRangeFilter = TimeRangeFilter.between(startTime, endTime)
            )
        )
    for (exerciseRecord in response.records) {
        // Process each exercise record
        // Optionally pull in with other data sources of the same time range.
        val distanceRecord =
            healthConnectClient
                .readRecords(
                    ReadRecordsRequest(
                        DistanceRecord::class,
                        timeRangeFilter =
                            TimeRangeFilter.between(
                                exerciseRecord.startTime,
                                exerciseRecord.endTime
                            )
                    )
                )
                .records
    }
}

Scrivi dati di sottotipo

Le sessioni possono anche essere costituite da dati di sottotipo non obbligatori, che arricchiscono sessione con informazioni aggiuntive.

Ad esempio, le sessioni di allenamento possono includere ExerciseSegment, ExerciseLap e ExerciseRoute corsi:

val segments = listOf(
  ExerciseSegment(
    startTime = Instant.parse("2022-01-02T10:10:10Z"),
    endTime = Instant.parse("2022-01-02T10:10:13Z"),
    segmentType = ActivitySegmentType.BENCH_PRESS,
    repetitions = 373
  )
)

val laps = listOf(
  ExerciseLap(
    startTime = Instant.parse("2022-01-02T10:10:10Z"),
    endTime = Instant.parse("2022-01-02T10:10:13Z"),
    length = 0.meters
  )
)

ExerciseSessionRecord(
  exerciseType = ExerciseSessionRecord.EXERCISE_TYPE_CALISTHENICS,
    startTime = Instant.parse("2022-01-02T10:10:10Z"),
    endTime = Instant.parse("2022-01-02T10:10:13Z"),
  startZoneOffset = ZoneOffset.UTC,
  endZoneOffset = ZoneOffset.UTC,
  segments = segments,
  laps = laps,
  route = route
)

Eliminare una sessione di allenamento

Esistono due modi per eliminare una sessione di allenamento:

  1. Per intervallo di tempo.
  2. Per UID.

Ecco come eliminare i dati del sottotipo in base all'intervallo di tempo:

suspend fun deleteExerciseSession(
    healthConnectClient: HealthConnectClient,
    exerciseRecord: ExerciseSessionRecord,
) {
    val timeRangeFilter = TimeRangeFilter.between(sleepRecord.startTime, sleepRecord.endTime)
    healthConnectClient.deleteRecords(SleepSessionRecord::class, timeRangeFilter)
    // delete the associated distance record
    healthConnectClient.deleteRecords(DistanceRecord::class, timeRangeFilter)
}

Puoi anche eliminare i dati di sottotipo in base all'UID. In questo modo, però, eliminerai solo sessione di allenamento, non i dati associati:

suspend fun deleteExerciseSession(
    healthConnectClient: HealthConnectClient,
    exerciseRecord: ExerciseSessionRecord,
) {
    healthConnectClient.deleteRecords(
        ExerciseSessionRecord::class,
        recordIdsList = listOf(exerciseRecord.metadata.id),
        clientRecordIdsList = emptyList()
    )
}