Odczytywanie danych zbiorczych

Agregowanie danych w Health Connect obejmuje agregację podstawową lub agregację danych w zasobnikach. Poniższe przepływy pracy pokazują, jak wykonać obie te czynności.

Agregacja podstawowa

Aby zastosować podstawową agregację danych, użyj funkcji aggregate w obiekcie HealthConnectClient. Akceptuje on obiekt AggregateRequest, do którego dodajesz typy danych i zakres czasu jako parametry. Sposób wywoływania podstawowych danych agregacji zależy od używanych typów wskaźników.

Agregacja skumulowana

Agregacja skumulowana oblicza łączną wartość.

Z przykładu poniżej dowiesz się, jak agregować dane określonego typu:

suspend fun aggregateDistance(
    healthConnectClient: HealthConnectClient,
    startTime: Instant,
    endTime: Instant
) {
    try {
        val response = healthConnectClient.aggregate(
            AggregateRequest(
                metrics = setOf(DistanceRecord.DISTANCE_TOTAL),
                timeRangeFilter = TimeRangeFilter.between(startTime, endTime)
            )
        )
        // The result may be null if no data is available in the time range
        val distanceTotalInMeters = response[DistanceRecord.DISTANCE_TOTAL]?.inMeters ?: 0L
    } catch (e: Exception) {
        // Run error handling here
    }
}

Agregacja statystyczna

Agregacja statystyczna oblicza minimalne, maksymalne i średnie wartości rekordów z próbkami.

Z przykładu poniżej dowiesz się, jak używać agregacji statystycznej:

suspend fun aggregateHeartRate(
    healthConnectClient: HealthConnectClient,
    startTime: Instant,
    endTime: Instant
) {
    try {
        val response =
            healthConnectClient.aggregate(
                AggregateRequest(
                    setOf(HeartRateRecord.BPM_MAX, HeartRateRecord.BPM_MIN),
                    timeRangeFilter = TimeRangeFilter.between(startTime, endTime)
                )
            )
        // The result may be null if no data is available in the time range
        val minimumHeartRate = response[HeartRateRecord.BPM_MIN]
        val maximumHeartRate = response[HeartRateRecord.BPM_MAX]
    } catch (e: Exception) {
        // Run error handling here
    }
}

Zasobniki

Health Connect pozwala też łączyć dane w zasobniki. Dwa typy zasobników, których możesz używać, to duration i period.

Po wywołaniu zwraca listę zasobników. Pamiętaj, że lista może być rozproszona, więc zasobnik nie będzie na niej widoczny, jeśli nie zawiera żadnych danych.

Czas działania

W tym przypadku dane zbiorcze są dzielone na zasobniki o stałej długości, np. minuty lub godzinę. Aby agregować dane w zasobnikach, użyj metody aggregateGroupByDuration. Akceptuje on obiekt AggregateGroupByDurationRequest, do którego dodajesz typy danych, zakres czasowy i parametry Duration.

Poniżej znajduje się przykład łączenia kroków w zasobniki trwające przez minutę:

suspend fun aggregateStepsIntoMinutes(
    healthConnectClient: HealthConnectClient,
    startTime: LocalDateTime,
    endTime: LocalDateTime
) {
    try {
        val response =
            healthConnectClient.aggregateGroupByDuration(
                AggregateGroupByDurationRequest(
                    metrics = setOf(StepsRecord.COUNT_TOTAL),
                    timeRangeFilter = TimeRangeFilter.between(startTime, endTime),
                    timeRangeSlicer = Duration.ofMinutes(1L)
                )
            )
        for (durationResult in response) {
            // The result may be null if no data is available in the time range
            val totalSteps = durationResult.result[StepsRecord.COUNT_TOTAL]
        }
    } catch (e: Exception) {
        // Run error handling here
    }
}

Przedział

W tym przypadku dane zbiorcze są dzielone na zasobniki w przedziale czasu określonym na podstawie daty, np. tydzień lub miesiąc. Aby agregować dane w zasobnikach, użyj metody aggregateGroupByPeriod. Akceptuje on obiekt AggregateGroupByPeriodRequest, do którego dodajesz typy danych, zakres czasowy i parametry Period.

Poniżej znajduje się przykład agregacji kroków w zasobnikach miesięcznych:

suspend fun aggregateStepsIntoMonths(
    healthConnectClient: HealthConnectClient,
    startTime: LocalDateTime,
    endTime: LocalDateTime
) {
    try {
        val response =
            healthConnectClient.aggregateGroupByPeriod(
                AggregateGroupByPeriodRequest(
                    metrics = setOf(StepsRecord.COUNT_TOTAL),
                    timeRangeFilter = TimeRangeFilter.between(startTime, endTime),
                    timeRangeSlicer = Period.ofMonths(1)
                )
            )
        for (monthlyResult in response) {
            // The result may be null if no data is available in the time range
            val totalSteps = monthlyResult.result[StepsRecord.COUNT_TOTAL]
        }
    } catch (e: Exception) {
        // Run error handling here
    }
}

Ograniczenie odczytu w ciągu 30 dni

Aplikacje mogą odczytywać dane z Health Connect przez maksymalnie 30 dni przed przyznaniem pierwszego uprawnienia.

Jeśli jednak użytkownik usunie aplikację, historia uprawnień zostanie utracona. Jeśli użytkownik ponownie zainstaluje aplikację i ponownie przyzna jej uprawnienia, będzie mogła odczytywać dane z Health Connect na maksymalnie 30 dni przed tą nową datą.

Przykład

Jeśli 30 marca 2023 r. użytkownik po raz pierwszy przyznał Twojej aplikacji uprawnienia do odczytu, najwcześniejsze dane, jakie może ona odczytać, będą miały miejsce od 28 lutego 2023 r.

10 maja 2023 r. użytkownik usunie Twoją aplikację. Użytkownik postanawia ponownie zainstalować ją 15 maja 2023 r. i przyznać uprawnienia do odczytu. Najwcześniejsza data, od której aplikacja może odczytywać dane, to 15 kwietnia 2023 r.