Praca z danymi historycznymi

Interfejs History API umożliwia aplikacji wykonywanie operacji zbiorczych w sklepie fitness: odczytywanie, wstawianie, aktualizowanie i usuwanie historycznych danych o zdrowiu i samopoczuciu. Interfejs History API pozwala na:

• Odczytywanie danych o zdrowiu i samopoczuciu, które zostały wstawione lub zarejestrowane za pomocą innych aplikacji.
• Zaimportuj dane zbiorcze do Google Fit.
• Zaktualizuj dane w Google Fit.
• Usuń dane historyczne zapisane wcześniej przez aplikację.

Aby wstawić dane zawierające metadane sesji, użyj interfejsu Sessions API.

Uwaga: sprawdzone metody zarządzania danymi użytkowników znajdziesz w zasadach dotyczących danych użytkownika i deweloperów Google Fit.

Odczytywanie danych

W sekcjach poniżej dowiesz się, jak odczytywać różne rodzaje danych zbiorczych.

Odczytywanie danych szczegółowych i zbiorczych

Aby odczytywać dane historyczne, utwórz instancję DataReadRequest.

Uwaga: aplikacje działające na Androidzie 10 (poziom interfejsu API 29) lub nowszym muszą uzyskać uprawnienia na Androida podczas rejestrowania określonych typów danych dotyczących aktywności fizycznej.

Kotlin

// Read the data that's been collected throughout the past week.
val endTime = LocalDateTime.now().atZone(ZoneId.systemDefault())
val startTime = endTime.minusWeeks(1)
Log.i(TAG, "Range Start: $startTime")
Log.i(TAG, "Range End: $endTime")

val readRequest =
    DataReadRequest.Builder()
        // The data request can specify multiple data types to return,
        // effectively combining multiple data queries into one call.
        // This example demonstrates aggregating only one data type.
        .aggregate(DataType.AGGREGATE_STEP_COUNT_DELTA)
        // Analogous to a "Group By" in SQL, defines how data should be
        // aggregated.
        // bucketByTime allows for a time span, whereas bucketBySession allows
        // bucketing by <a href="/fit/android/using-sessions">sessions</a>.
        .bucketByTime(1, TimeUnit.DAYS)
        .setTimeRange(startTime.toEpochSecond(), endTime.toEpochSecond(), TimeUnit.SECONDS)
        .build()

Java

// Read the data that's been collected throughout the past week.
ZonedDateTime endTime = LocalDateTime.now().atZone(ZoneId.systemDefault());
ZonedDateTime startTime = endTime.minusWeeks(1);
Log.i(TAG, "Range Start: $startTime");
Log.i(TAG, "Range End: $endTime");

DataReadRequest readRequest = new DataReadRequest.Builder()
        // The data request can specify multiple data types to return,
        // effectively combining multiple data queries into one call.
        // This example demonstrates aggregating only one data type.
        .aggregate(DataType.AGGREGATE_STEP_COUNT_DELTA)
        // Analogous to a "Group By" in SQL, defines how data should be
        // aggregated.
        // bucketByTime allows for a time span, while bucketBySession allows
        // bucketing by sessions.
        .bucketByTime(1, TimeUnit.DAYS)
        .setTimeRange(startTime.toEpochSecond(), endTime.toEpochSecond(), TimeUnit.SECONDS)
        .build();

W poprzednim przykładzie używamy zagregowanych punktów danych, gdzie każda DataPoint reprezentuje liczbę kroków pokonanych w ciągu dnia. W tym konkretnym przypadku użycia punkty danych zbiorczych mają 2 zalety:

• Twoja aplikacja i sklep fitness wymieniają się mniejszymi ilościami danych.
• Aplikacja nie musi agregować danych ręcznie.

Zbiorcze dane o różnych typach aktywności

Aplikacja może używać żądań danych do pobierania różnych typów danych. Poniższy przykład pokazuje, jak utworzyć DataReadRequest, aby spalać kalorie podczas każdego działania wykonywanego w określonym przedziale czasu. Otrzymane dane pokrywają liczbę kalorii na aktywność podaną w aplikacji Google Fit, gdzie każda aktywność otrzymuje własny zasobnik kalorii.

Kotlin

val readRequest = DataReadRequest.Builder()
    .aggregate(DataType.AGGREGATE_CALORIES_EXPENDED)
    .bucketByActivityType(1, TimeUnit.SECONDS)
    .setTimeRange(startTime.toEpochSecond(), endTime.toEpochSecond(), TimeUnit.SECONDS)
    .build()

Java

DataReadRequest readRequest = new DataReadRequest.Builder()
        .aggregate(DataType.AGGREGATE_CALORIES_EXPENDED)
        .bucketByActivityType(1, TimeUnit.SECONDS)
        .setTimeRange(startTime.toEpochSecond(), endTime.toEpochSecond(), TimeUnit.SECONDS)
        .build();

Po utworzeniu instancji DataReadRequest użyj metody HistoryClient.readData(), aby asynchronicznie odczytywać dane historyczne.

Ten przykład pokazuje, jak uzyskać instancje DataPoint z DataSet:

Kotlin

Fitness.getHistoryClient(this, GoogleSignIn.getAccountForExtension(this, fitnessOptions))
    .readData(readRequest)
    .addOnSuccessListener { response ->
        // The aggregate query puts datasets into buckets, so flatten into a
        // single list of datasets
        for (dataSet in response.buckets.flatMap { it.dataSets }) {
            dumpDataSet(dataSet)
        }
    }
    .addOnFailureListener { e ->
        Log.w(TAG,"There was an error reading data from Google Fit", e)
    }

fun dumpDataSet(dataSet: DataSet) {
    Log.i(TAG, "Data returned for Data type: ${dataSet.dataType.name}")
    for (dp in dataSet.dataPoints) {
        Log.i(TAG,"Data point:")
        Log.i(TAG,"\tType: ${dp.dataType.name}")
        Log.i(TAG,"\tStart: ${dp.getStartTimeString()}")
        Log.i(TAG,"\tEnd: ${dp.getEndTimeString()}")
        for (field in dp.dataType.fields) {
            Log.i(TAG,"\tField: ${field.name.toString()} Value: ${dp.getValue(field)}")
        }
    }
}

fun DataPoint.getStartTimeString() = Instant.ofEpochSecond(this.getStartTime(TimeUnit.SECONDS))
    .atZone(ZoneId.systemDefault())
    .toLocalDateTime().toString()

fun DataPoint.getEndTimeString() = Instant.ofEpochSecond(this.getEndTime(TimeUnit.SECONDS))
    .atZone(ZoneId.systemDefault())
    .toLocalDateTime().toString()

Java

Fitness.getHistoryClient(this, GoogleSignIn.getAccountForExtension(this, fitnessOptions))
        .readData(readRequest)
        .addOnSuccessListener (response -> {
            // The aggregate query puts datasets into buckets, so convert to a
            // single list of datasets
            for (Bucket bucket : response.getBuckets()) {
                for (DataSet dataSet : bucket.getDataSets()) {
                    dumpDataSet(dataSet);
                }
            }
        })
        .addOnFailureListener(e ->
            Log.w(TAG, "There was an error reading data from Google Fit", e));

}

private void dumpDataSet(DataSet dataSet) {
    Log.i(TAG, "Data returned for Data type: ${dataSet.dataType.name}");
    for (DataPoint dp : dataSet.getDataPoints()) {
        Log.i(TAG,"Data point:");
        Log.i(TAG,"\tType: ${dp.dataType.name}");
        Log.i(TAG,"\tStart: ${dp.getStartTimeString()}");
        Log.i(TAG,"\tEnd: ${dp.getEndTimeString()}");
        for (Field field : dp.getDataType().getFields()) {
            Log.i(TAG,"\tField: ${field.name.toString()} Value: ${dp.getValue(field)}");
        }
    }
}


private String getStartTimeString() {
    return Instant.ofEpochSecond(this.getStartTime(TimeUnit.SECONDS))
        .atZone(ZoneId.systemDefault())
        .toLocalDateTime().toString();
}

private String getEndTimeString() {
    return Instant.ofEpochSecond(this.getEndTime(TimeUnit.SECONDS))
            .atZone(ZoneId.systemDefault())
            .toLocalDateTime().toString();
}

Odczytaj dane łączne dziennie

Google Fit zapewnia też łatwy dostęp do dziennej sumy określonego typu danych. Aby pobrać typ danych określony od północy bieżącego dnia bieżącej strefy czasowej urządzenia, użyj metody HistoryClient.readDailyTotal(). Na przykład przekaż do tej metody typ danych TYPE_STEP_COUNT_DELTA, aby pobrać łączną liczbę dziennych kroków. Możesz przekazywać natychmiastowe typy danych zawierające zagregowaną sumę dzienną. Więcej informacji o obsługiwanych typach danych znajdziesz w sekcji DataType.getAggregateType.

Google Fit nie wymaga autoryzacji do subskrybowania aktualizacji pola TYPE_STEP_COUNT_DELTA z metody HistoryClient.readDailyTotal(), gdy ta metoda jest wywoływana za pomocą konta domyślnego i nie są określone zakresy. Może to być przydatne, gdy wymagasz użycia danych o krokach w obszarach, w których nie można wyświetlić panelu uprawnień, np. na tarczach zegarka na Wear OS.

Użytkownicy wolą widzieć stałą liczbę kroków w aplikacji Google Fit i innych aplikacjach oraz na tarczach zegarka na Wear OS, ponieważ zapewnia to spójne i niezawodne działanie. Aby liczba kroków była spójna, zasubskrybuj kroki na platformie Google Fit w aplikacji lub na tarczy zegarka, a potem zaktualizuj liczbę w onExitAmbient(). Więcej informacji o korzystaniu z tych danych na tarczy zegarka znajdziesz w artykułach o widżetach na tarczy zegarka i przykładowej aplikacji na Androida WatchFace.

Wstaw dane

Aby wstawić dane historyczne, najpierw utwórz DataSetinstancję:

Kotlin

// Declare that the data being inserted was collected during the past hour.
val endTime = LocalDateTime.now().atZone(ZoneId.systemDefault())
val startTime = endTime.minusHours(1)

// Create a data source
val dataSource = DataSource.Builder()
    .setAppPackageName(this)
    .setDataType(DataType.TYPE_STEP_COUNT_DELTA)
    .setStreamName("$TAG - step count")
    .setType(DataSource.TYPE_RAW)
    .build()

// For each data point, specify a start time, end time, and the
// data value -- in this case, 950 new steps.
val stepCountDelta = 950
val dataPoint =
    DataPoint.builder(dataSource)
        .setField(Field.FIELD_STEPS, stepCountDelta)
        .setTimeInterval(startTime.toEpochSecond(), endTime.toEpochSecond(), TimeUnit.SECONDS)
        .build()

val dataSet = DataSet.builder(dataSource)
    .add(dataPoint)
    .build()

Java

// Declare that the data being inserted was collected during the past hour.
ZonedDateTime endTime = LocalDateTime.now().atZone(ZoneId.systemDefault());
ZonedDateTime startTime = endTime.minusHours(1);

// Create a data source
DataSource dataSource = new DataSource.Builder()
        .setAppPackageName(this)
        .setDataType(DataType.TYPE_STEP_COUNT_DELTA)
        .setStreamName("$TAG - step count")
        .setType(DataSource.TYPE_RAW)
        .build();

// For each data point, specify a start time, end time, and the
// data value -- in this case, 950 new steps.
int stepCountDelta = 950;
DataPoint dataPoint = DataPoint.builder(dataSource)
        .setField(Field.FIELD_STEPS, stepCountDelta)
        .setTimeInterval(startTime.toEpochSecond(), endTime.toEpochSecond(), TimeUnit.SECONDS)
        .build();

DataSet dataSet = DataSet.builder(dataSource)
        .add(dataPoint)
        .build();

Ostrzeżenie: pamiętaj,aby w każdym żądaniu ograniczyć je do 1000 punktów danych. Przekroczenie tego limitu może spowodować wyświetlenie błędu.

Po utworzeniu instancji DataSet użyj metody HistoryClient.insertData, aby asynchronicznie dodać te dane historyczne.

Kotlin

Fitness.getHistoryClient(this, GoogleSignIn.getAccountForExtension(this, fitnessOptions))
    .insertData(dataSet)
    .addOnSuccessListener {
        Log.i(TAG, "DataSet added successfully!")
    }
    .addOnFailureListener { e ->
        Log.w(TAG, "There was an error adding the DataSet", e)
    }

Java

Fitness.getHistoryClient(this, GoogleSignIn.getAccountForExtension(this, fitnessOptions))
        .insertData(dataSet)
        .addOnSuccessListener (unused ->
                Log.i(TAG, "DataSet added successfully!"))
        .addOnFailureListener(e ->
                Log.w(TAG, "There was an error adding the DataSet", e));
}

Uwaga: wstawiane instancje DataPoint muszą zawierać taką samą liczbę pól z formatami określonymi przez typ danych. Jeśli np. chcesz wstawić wcześniejsze dane o lokalizacji, każda próbka danych musi mieć 4 komponenty float określone przez typ danych com.google.location.sample. Jeśli użyjesz nieprawidłowego formatu, wystąpi IllegalArgumentException.

Zarządzanie sprzecznymi punktami danych

Każdy element DataPoint w obrębie DataSet Twojej aplikacji musi mieć wartości startTime i endTime, które określają unikalny przedział czasu w obrębie tego elementu DataSet, bez nakładania się między instancjami DataPoint.

Jeśli aplikacja spróbuje wstawić nowy typ DataPoint, który będzie kolidował z dotychczasową instancją DataPoint, zostanie odrzucony.DataPoint Aby wstawić nowy obiekt DataPoint, który może pokrywać się z dotychczasowymi punktami danych, użyj metody HistoryClient.updateData opisanej w sekcji Aktualizowanie danych.

Rysunek 1. Jak metoda insertData() obsługuje nowe punkty danych sprzeczne z dotychczasowymi elementami DataPoint.

Zaktualizuj dane

Google Fit umożliwia aplikacji aktualizowanie historycznych danych o zdrowiu i samopoczuciu, które zostały wcześniej wstawione. Aby dodać dane historyczne do nowego elementu DataSet lub dodać nowe instancje (DataPoint), które nie kolidują z istniejącymi punktami danych, użyj metody HistoryApi.insertData.

Uwaga: aplikacja nie może aktualizować danych wstawionych przez inne aplikacje.

Aby zaktualizować dane historyczne, użyj metody HistoryClient.updateData. Ta metoda usuwa wszystkie istniejące instancje DataPoint, które nakładają się na instancje DataPoint dodane za pomocą tej metody.

Aby zaktualizować historyczne dane o zdrowiu i samopoczuciu, najpierw utwórz wystąpienie DataSet:

Kotlin

// Declare that the historical data was collected during the past 50 minutes.
val endTime = LocalDateTime.now().atZone(ZoneId.systemDefault())
val startTime = endTime.minusMinutes(50)

// Create a data source
val dataSource  = DataSource.Builder()
    .setAppPackageName(this)
    .setDataType(DataType.TYPE_STEP_COUNT_DELTA)
    .setStreamName("$TAG - step count")
    .setType(DataSource.TYPE_RAW)
    .build()

// Create a data set
// For each data point, specify a start time, end time, and the
// data value -- in this case, 1000 new steps.
val stepCountDelta = 1000

val dataPoint = DataPoint.builder(dataSource)
    .setTimeInterval(startTime.toEpochSecond(), endTime.toEpochSecond(), TimeUnit.SECONDS)
    .setField(Field.FIELD_STEPS, stepCountDelta)
    .build()

val dataSet = DataSet.builder(dataSource)
    .add(dataPoint)
    .build()

Java

// Declare that the historical data was collected during the past 50 minutes.
ZonedDateTime endTime = LocalDateTime.now().atZone(ZoneId.systemDefault());
ZonedDateTime startTime = endTime.minusMinutes(50);

// Create a data source
DataSource dataSource = new DataSource.Builder()
        .setAppPackageName(this)
        .setDataType(DataType.TYPE_STEP_COUNT_DELTA)
        .setStreamName("$TAG - step count")
        .setType(DataSource.TYPE_RAW)
        .build();

// Create a data set
// For each data point, specify a start time, end time, and the
// data value -- in this case, 1000 new steps.
int stepCountDelta = 1000;

DataPoint dataPoint = DataPoint.builder(dataSource)
        .setTimeInterval(startTime.toEpochSecond(), endTime.toEpochSecond(), TimeUnit.SECONDS)
        .setField(Field.FIELD_STEPS, stepCountDelta)
        .build();

DataSet dataSet = DataSet.builder(dataSource)
        .add(dataPoint)
        .build();

Następnie za pomocą polecenia DataUpdateRequest.Builder() utwórz nowe żądanie aktualizacji danych i prześlij je za pomocą metody HistoryClient.updateData:

Kotlin

val request = DataUpdateRequest.Builder()
    .setDataSet(dataSet)
    .setTimeInterval(startTime.toEpochSecond(), endTime.toEpochSecond(), TimeUnit.SECONDS)
    .build()

Fitness.getHistoryClient(this, GoogleSignIn.getAccountForExtension(this, fitnessOptions))
    .updateData(request)
    .addOnSuccessListener {
        Log.i(TAG, "DataSet updated successfully!")
    }
    .addOnFailureListener { e ->
        Log.w(TAG, "There was an error updating the DataSet", e)
    }

Java

DataUpdateRequest request = new DataUpdateRequest.Builder()
        .setDataSet(dataSet)
        .setTimeInterval(startTime.toEpochSecond(), endTime.toEpochSecond(), TimeUnit.SECONDS)
        .build();

Fitness.getHistoryClient(this, GoogleSignIn.getAccountForExtension(this, fitnessOptions))
        .updateData(request)
        .addOnSuccessListener(unused ->
                Log.i(TAG, "DataSet updated successfully!"))
        .addOnFailureListener(e ->
                Log.w(TAG, "There was an error updating the DataSet", e));

Usuń dane

Google Fit umożliwia aplikacji usuwanie historycznych danych o zdrowiu i samopoczuciu, które zostały wcześniej wstawione.

Uwaga: aplikacja nie może usuwać danych wstawionych przez inne aplikacje.

Aby usunąć dane historyczne, użyj metody HistoryClient.deleteData:

Kotlin

// Declare that this code deletes step count information that was collected
// throughout the past day.
val endTime = LocalDateTime.now().atZone(ZoneId.systemDefault())
val startTime = endTime.minusDays(1)

// Create a delete request object, providing a data type and a time interval
val request = DataDeleteRequest.Builder()
    .setTimeInterval(startTime.toEpochSecond(), endTime.toEpochSecond(), TimeUnit.SECONDS)
    .addDataType(DataType.TYPE_STEP_COUNT_DELTA)
    .build()

// Invoke the History API with the HistoryClient object and delete request, and
// then specify a callback that will check the result.
Fitness.getHistoryClient(this, GoogleSignIn.getAccountForExtension(this, fitnessOptions))
    .deleteData(request)
    .addOnSuccessListener {
        Log.i(TAG, "Data deleted successfully!")
    }
    .addOnFailureListener { e ->
        Log.w(TAG, "There was an error with the deletion request", e)
    }

Java

// Declare that this code deletes step count information that was collected
// throughout the past day.
ZonedDateTime endTime = LocalDateTime.now().atZone(ZoneId.systemDefault());
ZonedDateTime startTime = endTime.minusDays(1);

// Create a delete request object, providing a data type and a time interval
DataDeleteRequest request = new DataDeleteRequest.Builder()
        .setTimeInterval(startTime.toEpochSecond(), endTime.toEpochSecond(), TimeUnit.SECONDS)
        .addDataType(DataType.TYPE_STEP_COUNT_DELTA)
        .build();

// Invoke the History API with the HistoryClient object and delete request, and
// then specify a callback that will check the result.
Fitness.getHistoryClient(this, GoogleSignIn.getAccountForExtension(this, fitnessOptions))
        .deleteData(request)
        .addOnSuccessListener (unused ->
                Log.i(TAG, "Data deleted successfully!"))
        .addOnFailureListener(e ->
        Log.w(TAG, "There was an error with the deletion request", e));

Aplikacje mogą usuwać dane z konkretnych sesji lub wszystkie dane. Więcej informacji znajdziesz w dokumentacji interfejsu API DataDeleteRequest.

Zarejestruj się, aby otrzymywać aktualizacje danych

Aplikacja może odczytywać nieprzetworzone dane z czujników w czasie rzeczywistym, rejestrując się w SensorsClient.

W przypadku innych rodzajów danych, które są rzadziej uwzględniane i zliczane ręcznie, aplikacja może zarejestrować się, aby otrzymywać aktualizacje po wstawieniu pomiarów do bazy danych Google Fit. Przykładowe typy danych to wzrost, waga czy treningi, takie jak podnoszenie ciężarów. Więcej informacji znajdziesz na pełnej liście obsługiwanych typów danych. Aby zarejestrować się, by otrzymywać aktualizacje, użyj adresu HistoryClient.registerDataUpdateListener.

Ten fragment kodu umożliwia powiadamianie aplikacji, gdy użytkownik wpisze nową wartość swojej wagi:

Kotlin

val intent = Intent(this, MyDataUpdateService::class.java)
val pendingIntent = PendingIntent.getService(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT)

val request = DataUpdateListenerRegistrationRequest.Builder()
    .setDataType(DataType.TYPE_WEIGHT)
    .setPendingIntent(pendingIntent)
    .build()

Fitness.getHistoryClient(this, GoogleSignIn.getAccountForExtension(this, fitnessOptions))
    .registerDataUpdateListener(request)
    .addOnSuccessListener {
        Log.i(TAG, "DataUpdateListener registered")
    }

Java

Intent intent = new Intent(this, MyDataUpdateService.class);
PendingIntent pendingIntent = PendingIntent.getService(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT)

DataUpdateListenerRegistrationRequest request = new DataUpdateListenerRegistrationRequest.Builder()
        .setDataType(DataType.TYPE_WEIGHT)
        .setPendingIntent(pendingIntent)
        .build();

Fitness.getHistoryClient(this, GoogleSignIn.getAccountForExtension(this, fitnessOptions))
        .registerDataUpdateListener(request)
        .addOnSuccessListener(unused ->
                Log.i(TAG, "DataUpdateListener registered"));

IntentService może służyć do otrzymywania powiadomień o aktualizacjach:

Kotlin

class MyDataUpdateService : IntentService("MyDataUpdateService") {
    override fun onHandleIntent(intent: Intent?) {
        val update = DataUpdateNotification.getDataUpdateNotification(intent)
        // Show the time interval over which the data points were collected.
        // To extract specific data values, in this case the user's weight,
        // use DataReadRequest.
        update?.apply {
            val start = getUpdateStartTime(TimeUnit.MILLISECONDS)
            val end = getUpdateEndTime(TimeUnit.MILLISECONDS)

            Log.i(TAG, "Data Update start: $start end: $end DataType: ${dataType.name}")
        }
    }
}

Java

public class MyDataUpdateService extends IntentService {

    public MyDataUpdateService(String name) {
        super("MyDataUpdateService");
    }

    @Override
    protected void onHandleIntent(@Nullable Intent intent) {
        if (intent != null) {
            DataUpdateNotification update = DataUpdateNotification.getDataUpdateNotification(intent);

            // Show the time interval over which the data points
            // were collected.
            // To extract specific data values, in this case the user's weight,
            // use DataReadRequest.
            if (update != null) {
                long start = update.getUpdateStartTime(TimeUnit.MILLISECONDS);
                long end = update.getUpdateEndTime(TimeUnit.MILLISECONDS);
            }

            Log.i(TAG, "Data Update start: $start end: $end DataType: ${dataType.name}");
        }
    }
}

Pole IntentService musi być zadeklarowane w pliku AndroidManifest.xml.