Mit Verlaufsdaten arbeiten

Mit der History API kann deine App Bulk-Vorgänge im Fitnessspeicher ausführen: bisherige Gesundheits- und Fitnessdaten lesen, einfügen, aktualisieren und löschen. Mit der History API können Sie Folgendes tun:

• Gesundheits- und Fitnessdaten lesen, die mit anderen Apps eingefügt oder aufgezeichnet wurden.
• Batch-Daten in Google Fit importieren
• Daten in Google Fit aktualisieren.
• In Ihrer App gespeicherte Verlaufsdaten löschen

Verwenden Sie die Sessions API, um Daten einzufügen, die Sitzungsmetadaten enthalten.

Hinweis :Best Practices beim Verwalten von Nutzerdaten finden Sie in der Google Fit-Richtlinie zu Entwickler- und Nutzerdaten.

Daten lesen

In den folgenden Abschnitten wird beschrieben, wie verschiedene Arten von aggregierten Daten gelesen werden.

Detaillierte und aggregierte Daten lesen

Erstellen Sie eine DataReadRequest-Instanz, um Verlaufsdaten zu lesen.

Hinweis :Apps, die unter Android 10 (API-Level 29) oder höher ausgeführt werden, müssen eine Android-Berechtigung erhalten, wenn sie bestimmte Datentypen für körperliche Aktivitäten aufzeichnen.

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();

Im vorherigen Beispiel werden aggregierte Datenpunkte verwendet, wobei jeder DataPoint die Anzahl der an einem Tag zurückgelegten Schritte darstellt. In diesem speziellen Anwendungsfall haben aggregierte Datenpunkte zwei Vorteile:

• Deine App und der Fitness-Store tauschen kleinere Datenmengen aus.
• Ihre App muss die Daten nicht manuell aggregieren.

Daten für mehrere Aktivitätstypen aggregieren

Ihre App kann Datenanfragen verwenden, um viele verschiedene Datentypen abzurufen. Das folgende Beispiel zeigt, wie du eine DataReadRequest erstellst, um die verbrannten Kalorien für jede Aktivität zu erhalten, die innerhalb des angegebenen Zeitraums ausgeführt wurde. Die daraus resultierenden Daten stimmen mit den Kalorien pro Aktivität überein, wie in der Google Fit App gemeldet. Dabei erhält jede Aktivität einen eigenen Bucket mit Kaloriendaten.

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();

Nachdem Sie eine DataReadRequest-Instanz erstellt haben, können Sie die Methode HistoryClient.readData() verwenden, um Verlaufsdaten asynchron zu lesen.

Das folgende Beispiel zeigt, wie die DataPoint-Instanzen aus einem DataSet abgerufen werden:

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

Tägliche Gesamtdaten lesen

Google Fit bietet außerdem einfachen Zugriff auf die Tagessumme eines angegebenen Datentyps. Verwenden Sie die Methode HistoryClient.readDailyTotal(), um den Datentyp abzurufen, den Sie ab Mitternacht des aktuellen Tages in der aktuellen Zeitzone des Geräts angeben. Übergeben Sie beispielsweise den Datentyp TYPE_STEP_COUNT_DELTA an diese Methode, um die Gesamtzahl der Schritte pro Tag abzurufen. Sie können einen sofortigen Datentyp übergeben, der eine Tagesgesamtsumme hat. Weitere Informationen zu den unterstützten Datentypen findest du unter DataType.getAggregateType.

Google Fit benötigt keine Autorisierung, um TYPE_STEP_COUNT_DELTA-Updates mit der Methode HistoryClient.readDailyTotal() zu abonnieren, wenn diese Methode über das Standardkonto aufgerufen wird und keine Bereiche angegeben sind. Das kann nützlich sein, wenn du Schrittdaten für Bereiche benötigst, in denen der Berechtigungsbereich nicht angezeigt werden kann, z. B. auf Wear OS-Zifferblättern.

Nutzer bevorzugen eine einheitliche Schrittzahl in der Google Fit App, anderen Apps und Wear OS-Zifferblätter, da sie so eine einheitliche und zuverlässige Nutzung ermöglichen. Damit die Schrittzahl einheitlich bleibt, abonnieren Sie über die App oder das Zifferblatt die Schritte auf der Google Fit-Plattform und aktualisieren Sie die Anzahl dann in onExitAmbient(). Weitere Informationen zur Verwendung dieser Daten auf einem Zifferblatt findest du unter Zusatzfunktionen für Zifferblatt und in der Beispiel-App „Android Watch Face“.

Daten einfügen

Um Verlaufsdaten einzufügen, erstellen Sie zuerst eine DataSet-Instanz:

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();

Warnung: Beschränken Sie jede einzelne Anfrage auf 1.000 Datenpunkte. Das Überschreiten dieses Limits kann zu einem Fehler führen.

Nachdem Sie eine DataSet-Instanz erstellt haben, können Sie diese Verlaufsdaten mit der Methode HistoryClient.insertData asynchron hinzufügen.

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

Hinweis: Die DataPoint-Instanzen, die Sie einfügen, müssen dieselbe Anzahl von Feldern mit denselben Formaten haben, die durch den Datentyp definiert sind. Wenn Sie beispielsweise frühere Standortdaten einfügen möchten, muss jede Stichprobe der Daten vier float-Komponenten haben, wie durch den Datentyp com.google.location.sample definiert. Wenn Sie das falsche Format verwenden, wird ein IllegalArgumentException ausgegeben.

In Konflikt stehende Datenpunkte verwalten

Jedes DataPoint im DataSet Ihrer Anwendung muss einen startTime und einen endTime haben, der ein eindeutiges Intervall innerhalb dieser DataSet ohne Überschneidung zwischen DataPoint-Instanzen definiert.

Wenn die Anwendung versucht, eine neue DataPoint einzufügen, die mit einer vorhandenen DataPoint-Instanz in Konflikt steht, wird die neue DataPoint-Instanz verworfen. Um eine neue DataPoint einzufügen, die sich mit vorhandenen Datenpunkten überschneiden könnte, verwenden Sie die Methode HistoryClient.updateData, die unter Daten aktualisieren beschrieben wird.

Abbildung 1: Wie die Methode insertData() neue Datenpunkte verarbeitet, die mit einem vorhandenen DataPoint in Konflikt stehen.

Daten aktualisieren

Mit Google Fit kann deine App frühere Gesundheits- und Fitnessdaten aktualisieren, die sie zuvor eingefügt haben. Wenn Sie Verlaufsdaten für eine neue DataSet hinzufügen oder neue DataPoint-Instanzen hinzufügen möchten, die nicht mit vorhandenen Datenpunkten in Konflikt stehen, verwenden Sie die Methode HistoryApi.insertData.

Hinweis :Daten, die von anderen Apps eingefügt wurden, können von einer App nicht aktualisiert werden.

Verwenden Sie die Methode HistoryClient.updateData, um Verlaufsdaten zu aktualisieren. Bei dieser Methode werden alle vorhandenen DataPoint-Instanzen gelöscht, die sich mit DataPoint-Instanzen überschneiden, die mit dieser Methode hinzugefügt wurden.

Um frühere Gesundheits- und Fitnessdaten zu aktualisieren, musst du zuerst eine DataSet-Instanz erstellen:

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();

Verwenden Sie dann DataUpdateRequest.Builder(), um eine neue Anfrage zur Datenaktualisierung zu erstellen, und die Methode HistoryClient.updateData, um die Anfrage zu stellen:

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

Daten löschen

Mit Google Fit kann deine App frühere Gesundheits- und Fitnessdaten löschen, die sie zuvor eingefügt hat.

Hinweis :Eine App kann keine Daten löschen, die von anderen Apps eingefügt wurden.

Verwenden Sie die Methode HistoryClient.deleteData, um Verlaufsdaten zu löschen:

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

Apps können Daten aus bestimmten Sitzungen oder alle Daten löschen. Weitere Informationen finden Sie in der API-Referenz zu DataDeleteRequest.

Registrieren, um Daten-Updates zu erhalten

Ihre App kann Sensor-Rohdaten in Echtzeit lesen, indem sie sich bei SensorsClient registriert.

Bei anderen Arten von Daten, die weniger häufig sind und manuell gezählt werden, kann sich deine App so registrieren, dass sie Updates erhält, wenn diese Messungen in die Google Fit-Datenbank eingefügt werden. Beispiele für diese Datentypen sind Größe, Gewicht und Trainingseinheiten wie Gewichtheben. Weitere Informationen findest du in der vollständigen Liste der unterstützten Datentypen. Verwenden Sie HistoryClient.registerDataUpdateListener, um sich für Updates zu registrieren.

Mit dem folgenden Code-Snippet kann eine App benachrichtigt werden, wenn der Nutzer einen neuen Wert für sein Gewicht eingibt:

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 kann verwendet werden, um Benachrichtigungen über Updates zu erhalten:

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

IntentService muss in der Datei AndroidManifest.xml deklariert werden.