Sitzungen

In Health Connect ist eine Sitzung ein Zeitintervall, in dem ein Nutzer eine Aktivitäten. Die Datentypen SleepSessionRecord und ExerciseSessionRecord sind beides Sitzungen.

Mit Sitzungen können Nutzer die zeitbasierte Leistung über einen bestimmten Zeitraum, wie kontinuierliche Herzfrequenz oder Standortdaten.

ExerciseSessionRecord-Trainingseinheiten umfassen eine Vielzahl von Aktivitäten, von Laufen bis zum Badminton.

SleepSessionRecord-Sitzungen enthalten Daten, die Schlafphasen aufzeichnen, z. B. AWAKE, SLEEPING und DEEP.

Subtyp-Daten sind Daten, die zu und ist nur sinnvoll, wenn er wird mit einer übergeordneten Sitzung gelesen, z.B. Schlafphase, Trainingssegment.

Verknüpfte Daten – Record-Daten können separat oder zusammen mit anderen Sitzungen, z.B. Schritte, Herzfrequenz.

Allgemeine Anleitung

Hier sind einige Best Practices-Richtlinien für die Arbeit mit Sitzungen in der Gesundheitsbranche Verbinden.

  • Sitzungen sollten verwendet werden, um Daten von einem bestimmten Training oder einer bestimmten Aktivität hinzuzufügen, oder für Schlaf:
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
            ),  
        )
    )
}
  • Sitzungen sollten nicht für allgemeine Messungen verwendet werden, zum Beispiel für die täglichen Schritte. zählt.
  • Untertypdaten enthalten keine UID, die zugehörigen Daten haben jedoch unterschiedliche UIDs.
  • Untertypdaten müssen in einer Sitzung mit sequenziellen Zeitstempeln abgestimmt werden die sich nicht überschneiden. Lücken sind jedoch zulässig.
  • Sitzungen sind nützlich, wenn der Nutzer möchte, dass Daten mit ihm verknüpft werden (und als Teil einer Sitzung erfasst werden.

Schlafeinheiten

Du kannst Schlafdaten in Health Connect lesen oder schreiben. Schlafdaten werden als und lassen sich in 8 verschiedene Schlafphasen unterteilen:

  • UNKNOWN: nicht spezifiziert oder unbekannt, wenn der Nutzer schläft.
  • AWAKE: Der Nutzer ist während eines Schlafzyklus wach, nicht tagsüber.
  • SLEEPING: Allgemeine oder nicht detaillierte Schlafbeschreibung.
  • OUT_OF_BED: Der Nutzer steht mitten im Schlaf auf.
  • AWAKE_IN_BED: Der Nutzer ist wach im Bett.
  • LIGHT: Der Nutzer befindet sich in einem leichten Schlafzyklus.
  • DEEP: Der Nutzer befindet sich im Tiefschlafzyklus.
  • REM: Der Nutzer befindet sich im REM-Schlafzyklus.

Diese Werte repräsentieren die Art des Schlafs, den Nutzende innerhalb eines bestimmten Zeitraums erleben. Das Schreiben von Schlafphasen ist optional, wird aber empfohlen, sofern verfügbar.

Schlafeinheiten mit oder ohne Schlafphasen aufzeichnen

Der Datentyp SleepSessionRecord besteht aus zwei Teilen:

  1. Die Einheit insgesamt, die die gesamte Schlafdauer umfasst.
  2. Einzelne Schlafphasen wie Leichtschlaf oder Tiefschlaf Schlaf.

So fügst du eine Schlafeinheit ohne Phasen hinzu:

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

So fügst du Phasen hinzu, die die gesamte Dauer einer Schlafeinheit abdecken:

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

Schlafeinheit lesen

Du solltest für jede zurückgegebene Schlafeinheit überprüfen, ob die Daten der Schlafphasen präsentieren auch:

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

Schlafeinheit löschen

So löschen Sie eine Sitzung. In diesem Beispiel haben wir eine Schlafsitzung verwendet:

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

Trainingseinheiten

Das Training kann von Laufen bis Badminton reichen.

Trainingseinheiten schreiben

So erstellen Sie eine Anzeigenauftragsanfrage, die eine Sitzung enthält:

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

Im vorherigen Beispiel wurde ein Eintrag für Distance hinzugefügt, der sich über die gesamte Dauer der Sitzung ab. Daten können jedoch Detaillierungsgrad.

Hätte die App während des Laufs regelmäßig Strecken gemessen, wäre ein anderer Ansatz viele Distance Datensätze enthalten, die jeweils die Entfernung Teil des Laufs behandelt werden.

Trainingseinheit lesen

Hier ist ein Beispiel für das Lesen einer Trainingseinheit:

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

Untertypdaten schreiben

Sitzungen können auch aus nicht obligatorischen Untertypdaten bestehen, die die mit zusätzlichen Informationen.

Trainingssitzungen können beispielsweise Folgendes umfassen: ExerciseSegment, ExerciseLap und ExerciseRoute:

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
)

Trainingseinheiten löschen

Es gibt zwei Möglichkeiten, eine Trainingssitzung zu löschen:

  1. Nach Zeitraum.
  2. Nach UID.

So löschen Sie Untertypdaten nach Zeitraum:

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

Sie können Untertypdaten auch nach UID löschen. Dadurch wird jedoch nur die Trainingseinheit, nicht die zugehörigen Daten:

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