Sesje

Sesja w Health Connect to przedział czasu, w którym użytkownik wykonuje działania. Typy danych SleepSessionRecord i ExerciseSessionRecord to zarówno dane, jak i typy danych sesji.

Sesje pozwalają użytkownikom mierzyć skuteczność na przestrzeni czasu w określonym czasie, takich jak stałe tętno czy dane o lokalizacji.

ExerciseSessionRecord sesje obejmują różne aktywności, od biegania uprawiać badmintona.

SleepSessionRecord sesji zawiera dane, które rejestrują fazy snu, takie jak: AWAKE, SLEEPING i DEEP.

Dane podtypu to dane, które „należą do” i ma znaczenie tylko wtedy, jest odczytywany podczas sesji nadrzędnej, np. faza snu, segment ćwiczeń.

powiązane dane – czy dane Record mogą być odczytywane oddzielnie lub razem z innymi; sesji, np. kroki, tętno.

Wskazówki ogólne

Oto kilka sprawdzonych metod korzystania z sesji w Health Połącz.

  • Sesje powinny służyć do dodawania danych z konkretnego treningu lub aktywności. do snu:
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
            ),  
        )
    )
}
  • Sesji nie należy używać do ogólnych pomiarów, takich jak dzienna liczba kroków
  • Dane podtypu nie zawierają identyfikatora UID, ale powiązane dane mają różne identyfikatory UID.
  • Dane podtypu muszą być dopasowane w sesji z sekwencyjnymi sygnaturami czasowymi które nie nakładają się na siebie. Luki są jednak dozwolone.
  • Sesje są przydatne, jeśli użytkownik chce powiązać dane z (oraz śledzone jako część) sesji, a nie w trybie ciągłym.

Sesje snu

Dane dotyczące snu możesz odczytywać i zapisywać w aplikacji Health Connect. Dane dotyczące snu są wyświetlane jako i można ją podzielić na 8 różnych faz snu:

  • UNKNOWN: nie określono lub nie wiadomo, czy użytkownik śpi.
  • AWAKE: użytkownik wybudza się w trakcie cyklu snu, a nie w ciągu dnia.
  • SLEEPING: ogólny lub nieprecyzyjny opis snu.
  • OUT_OF_BED: użytkownik wstaje z łóżka w trakcie sesji snu.
  • AWAKE_IN_BED: użytkownik nie śpi w łóżku.
  • LIGHT: użytkownik jest w fazie snu płytkiego.
  • DEEP: Użytkownik jest w fazie snu głębokiego.
  • REM: użytkownik jest w fazie snu REM.

Wartości reprezentują rodzaj snu, jaki tkwi w danym przedziale czasu. Zapisywanie faz snu jest opcjonalne, ale zalecane, jeśli są dostępne.

Zapisuj sesje snu z fazami snu lub bez nich

Typ danych SleepSessionRecord składa się z 2 części:

  1. Cała sesja obejmująca cały czas trwania snu.
  2. Poszczególne fazy snu, np. sen płytki lub głęboki sen.

Oto jak wstawić sesję snu bez faz:

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

Oto jak dodać fazy obejmujące cały okres snu:

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

Odczytaj dane o sesji snu

Dla każdej zwróconej sesji snu musisz sprawdzić, czy dane dotyczące faz snu również:

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

Usuwanie sesji snu

Tak możesz usunąć sesję. W tym przykładzie zastosowaliśmy sesję snu:

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

Sesje ćwiczeń

Sesje ćwiczeń mogą obejmować wszystko, od biegania po badmintona.

Zapisuj sesje ćwiczeń

Żądanie wstawiania, które obejmuje sesję:

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

Zwróć uwagę, jak w poprzednim przykładzie dodano rekord dla kolumny Distance, która obejmuje przez cały czas trwania sesji, ale dane można dodawać w różny sposób. szczegółowość danych.

Jeśli aplikacja regularnie mierzyła dystans podczas biegu, wybierz inną metodę. można uwzględnić wiele zapisów odległości, każdy z nich pokonany podczas części biegu.

Odczytywanie informacji o sesji ćwiczeń

Oto przykład, jak odczytać informacje o sesji ćwiczenia:

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

Zapisywanie danych podtypu

Sesje mogą też składać się z nieobowiązkowych danych podtypów, które wzbogacają z dodatkowymi informacjami.

Sesje ćwiczeń mogą na przykład obejmować ExerciseSegment, ExerciseLap i ExerciseRoute zajęć:

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
)

Usuń sesję ćwiczeniową

Sesję ćwiczeniową można usunąć na dwa sposoby:

  1. Według zakresu czasu.
  2. Przez identyfikator UID.

Oto jak usunąć dane podtypu według zakresu czasu:

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

Możesz też usuwać dane podtypów według identyfikatora UID. Spowoduje to jednak usunięcie jedynie ćwiczenia, a nie powiązane dane:

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