Utiliser des données historiques

L'API History permet à votre application d'effectuer des opérations groupées sur le magasin de remise en forme : lire, insérer, mettre à jour et supprimer les données historiques de santé et de bien-être. Utilisez l'API History pour effectuer les opérations suivantes:

• Lire les données de santé et de bien-être qui ont été insérées ou enregistrées à l'aide d'autres applications
• Importer des données par lot dans Google Fit
• Mettre à jour des données dans Google Fit
• Supprimez les données historiques précédemment stockées par votre application.

Pour insérer des données contenant des métadonnées de session, utilisez l'API Sessions.

Remarque :Pour connaître les bonnes pratiques de gestion des données utilisateur, consultez le Règlement sur les données utilisateur et pour les développeurs Google Fit.

Lire des données

Les sections suivantes expliquent comment lire différents types de données agrégées.

Lire des données détaillées et agrégées

Pour lire les données historiques, créez une instance DataReadRequest.

Remarque :Les applications exécutées sur Android 10 (niveau d'API 29) ou version ultérieure doivent obtenir une autorisation Android lorsqu'elles enregistrent certains types de données d'activité physique.

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

L'exemple précédent utilise des points de données agrégées, où chaque DataPoint représente le nombre de pas effectués dans une journée. Pour ce cas d'utilisation particulier, les points de données agrégées présentent deux avantages:

• Votre application et le magasin de fitness échangent de plus petites quantités de données.
• Votre application n'a pas besoin de regrouper les données manuellement.

Données globales pour plusieurs types d'activités

Votre application peut utiliser des requêtes de données pour récupérer de nombreux types de données différents. L'exemple suivant montre comment créer un DataReadRequest pour obtenir les calories brûlées pour chaque activité effectuée au cours de la période spécifiée. Les données obtenues correspondent aux calories par activité indiquées dans l'application Google Fit, où chaque activité reçoit son propre ensemble de données caloriques.

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

Après avoir créé une instance DataReadRequest, utilisez la méthode HistoryClient.readData() pour lire les données historiques de manière asynchrone.

L'exemple suivant montre comment obtenir les instances DataPoint à partir d'un 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();
}

Lire les données quotidiennes totales

Google Fit fournit également un accès simple au total quotidien pour un type de données spécifié. Utilisez la méthode HistoryClient.readDailyTotal() pour récupérer le type de données que vous spécifiez à minuit de la journée en cours dans le fuseau horaire actuel de l'appareil. Par exemple, transmettez le type de données TYPE_STEP_COUNT_DELTA à cette méthode pour récupérer le nombre total de pas quotidiens. Vous pouvez transmettre un type de données instantané qui possède un total quotidien agrégé. Pour en savoir plus sur les types de données acceptés, consultez DataType.getAggregateType.

Google Fit ne nécessite pas l'autorisation de s'abonner aux mises à jour de TYPE_STEP_COUNT_DELTA à partir de la méthode HistoryClient.readDailyTotal() lorsque cette méthode est appelée à l'aide du compte par défaut et qu'aucun champ d'application n'est spécifié. Cela peut être utile si vous avez besoin de données sur les pas dans les zones où vous ne pouvez pas afficher le panneau des autorisations, par exemple sur les cadrans Wear OS.

Les utilisateurs préfèrent que le nombre de pas soit cohérent dans l'application Google Fit, dans d'autres applications et sur les cadrans Wear OS, car cela leur offre une expérience cohérente et fiable. Pour assurer la cohérence du nombre de pas, abonnez-vous aux étapes de la plate-forme Google Fit depuis votre application ou votre cadran, puis mettez à jour le nombre dans onExitAmbient(). Pour savoir comment utiliser ces données dans un cadran, consultez la section Complications du cadran et l'application exemple de cadran Android.

Insérer des données

Pour insérer des données historiques, créez d'abord une instance DataSet:

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

Avertissement :Veillez à limiter chaque requête individuelle à 1 000 points de données. Le dépassement de cette limite peut entraîner une erreur.

Après avoir créé une instance DataSet, utilisez la méthode HistoryClient.insertData pour ajouter ces données historiques de manière asynchrone.

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

Remarque :Les instances DataPoint que vous insérez doivent comporter le même nombre de champs au même format que ceux définis par le type de données. Par exemple, si vous souhaitez insérer d'anciennes données de localisation, chaque échantillon de données doit comporter quatre composants float tels que définis par le type de données com.google.location.sample. Si vous n'utilisez pas le bon format, une IllegalArgumentException se produit.

Gérer les points de données en conflit

Chaque DataPoint dans le DataSet de votre application doit avoir une startTime et une endTime qui définissent un intervalle unique au sein de cette DataSet, sans chevauchement entre les instances DataPoint.

Si votre application tente d'insérer une nouvelle DataPoint qui entre en conflit avec une instance DataPoint existante, la nouvelle DataPoint est supprimée. Pour insérer un nouveau DataPoint susceptible de chevaucher des points de données existants, utilisez la méthode HistoryClient.updateData décrite dans la section Mettre à jour les données.

Figure 1. Comment la méthode insertData() gère les nouveaux points de données en conflit avec un élément DataPoint existant

Mettre à jour des données

Google Fit permet à votre application de mettre à jour l'historique des données de santé et de bien-être précédemment insérées. Pour ajouter des données historiques pour un nouveau DataSet ou pour ajouter de nouvelles instances DataPoint qui n'entrent pas en conflit avec des points de données existants, utilisez la méthode HistoryApi.insertData.

Remarque :Une application ne peut pas mettre à jour les données insérées par d'autres applications.

Pour mettre à jour les données historiques, utilisez la méthode HistoryClient.updateData. Cette méthode supprime toutes les instances DataPoint existantes qui chevauchent les instances DataPoint ajoutées à l'aide de cette méthode.

Pour mettre à jour les données historiques de santé et de bien-être, créez d'abord une instance 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();

Ensuite, utilisez DataUpdateRequest.Builder() pour créer une requête de mise à jour des données, puis utilisez la méthode HistoryClient.updateData pour effectuer la requête:

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

Supprimer des données

Google Fit permet à votre application de supprimer les données de santé et de bien-être historiques qu'elle a précédemment insérées.

Remarque :Une application ne peut pas supprimer les données insérées par d'autres applications.

Pour supprimer des données historiques, utilisez la méthode 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));

Les applications peuvent supprimer les données de sessions spécifiques ou toutes les données. Pour en savoir plus, consultez la documentation de référence de l'API pour DataDeleteRequest.

S'inscrire pour recevoir des mises à jour de données

Votre application peut lire les données brutes des capteurs en temps réel en s'enregistrant auprès de SensorsClient.

Pour les autres types de données moins fréquentes et comptabilisées manuellement, votre application peut s'inscrire pour recevoir des mises à jour lorsque ces mesures sont insérées dans la base de données Google Fit. Ces types de données incluent la taille, le poids et les entraînements tels que l'haltérophilie. Pour en savoir plus, consultez la liste complète des types de données acceptés. Pour vous inscrire aux mises à jour, utilisez HistoryClient.registerDataUpdateListener.

L'extrait de code suivant permet à une application d'être avertie lorsque l'utilisateur saisit une nouvelle valeur pour son poids:

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

Un IntentService peut être utilisé pour recevoir des notifications de mises à jour:

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

Le IntentService doit être déclaré dans votre fichier AndroidManifest.xml.