Odczytywanie danych zbiorczych

Aggregating data in Health Connect includes basic aggregations or aggregating data into buckets. Z poniższych procesów dowiesz się, jak to zrobić.

.

Podstawowa agregacja

Aby zastosować podstawowe agregacje danych, użyj funkcji aggregate w obiekcie HealthConnectClient. Akceptuje on obiekt AggregateRequest, w którego parametrach dodajesz typy danych i zakres czasu. Nazwa podstawowej wartości agregacji zależy od użytych typów danych.

Agregacja kumulacyjna

Skumulowane zliczanie oblicza łączną wartość.

Z tego przykładu dowiesz się, jak agregować dane dla danego typu danych:

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

Statystyczne agregacje obliczają minimalne, maksymalne lub średnie wartości rekordów z próbkami.

Ten przykład pokazuje, 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 umożliwia też agregowanie danych w grupach. Dostępne są 2 rodzaje zbiorników: czas trwaniaokres.

Po wywołaniu zwracają listę zasobników. Pamiętaj, że lista może być rzadka, więc grupa nie jest uwzględniana na liście, jeśli nie zawiera żadnych danych.

Czas działania

W takim przypadku dane zbiorcze są dzielone na zbiory w określonym przedziale czasu, np. minutę lub godzinę. Aby agregować dane w zasośnikach, użyj aggregateGroupByDuration. Akceptuje obiekt AggregateGroupByDurationRequest, w którym jako parametry dodajesz typy danych, zakres czasowy i wartość Duration.

Poniżej przedstawiamy przykład agregacji kroków w przedziały czasowe trwające 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
    }
}

Kropka

W takim przypadku dane zbiorcze są dzielone na zbiory w określonym przedziale czasu, np. tydzień lub miesiąc. Aby agregować dane w zasobnikach, użyj aggregateGroupByPeriod. Akceptuje obiekt AggregateGroupByPeriodRequest, w którym jako parametry podajesz typy danych, zakres czasowy i wartość Period.

Poniżej znajdziesz przykład agregacji kroków w grupy miesięczne:

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

Ograniczenia odczytu

Domyślnie aplikacja może odczytywać dane z 30 dni, jeśli przyznano jej odpowiednie uprawnienia. Dzięki uprawnieniu PERMISSION_READ_HEALTH_DATA_HISTORY aplikacja może odczytywać dane starsze niż 30 dni.

30-dniowe ograniczenie

Aplikacje mogą odczytywać dane z Health Connect przez okres do 30 dni przed przyznaniem uprawnień.

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

Przykład 30-dni

Jeśli użytkownik po raz pierwszy przyznał Twojej aplikacji uprawnienia do odczytu 30 marca 2023 r., najstarsze dane, które Twoja aplikacja może odczytać, pochodzą z 28 lutego 2023 r.

Użytkownik usuwa Twoją aplikację 10 maja 2023 r. Użytkownik decyduje się na ponowne zainstalowanie aplikacji 15 maja 2023 r. i przyznaje uprawnienia do odczytu. Najwcześniejsza data, z której aplikacja może odczytać dane, to 15 kwietnia 2023 r.

odczytywać dane starsze niż 30 dni;

Jeśli chcesz odczytać dane starsze niż 30 dni, musisz użyć uprawnienia PERMISSION_READ_HEALTH_DATA_HISTORY. Bez tego uprawnienia próba odczytu pojedynczego rekordu starszego niż 30 dni spowoduje błąd. Nie możesz też odczytać żadnych danych starszych niż 30 dni za pomocą żadnego z tych zapytań dotyczących zakresu czasowego.