Enregistrer des données de remise en forme à l'aide de l'API Recording

L'API Recording sur mobile permet à votre application d'enregistrer les données de remise en forme d'un appareil mobile de manière économe en batterie. Par exemple, utilisez cette API pour enregistrer des pas, comme un podomètre qui récupère des données sur le nombre de pas. Cette API est sans compte, ce qui signifie qu'elle ne nécessite pas de compte Google pour utiliser le service, et que les données sont stockées sur l'appareil.

Ce guide explique comment utiliser l'API Recording sur mobile dans vos expériences de santé et de remise en forme.

Pour obtenir un exemple, consultez l'exemple d'API Recording sur mobile sur GitHub.

Détails importants

Plusieurs fonctionnalités notables sont propres à l'API Recording sur mobile :

  • Une fois l'abonnement à l'enregistrement commencé ou renouvelé, les données depuis le dernier abonnement (jusqu'à 10 jours) sont accessibles.
  • Les données ne sont disponibles que lorsqu'un abonnement est actif. Si un abonnement est supprimé en appelant unsubscribe, les données collectées ne seront pas accessibles.

Types de données

L'API Recording sur mobile peut enregistrer les types de données suivants :

Commencer

Pour commencer, ajoutez la dépendance suivante dans votre fichier build.gradle :

DSL Kotlin

plugin {
  id("com.android.application")
}

...

dependencies {
  implementation("com.google.android.gms:play-services-fitness:21.2.0")
}

DSL Groovy

apply plugin: 'com.android.application'

...

dependencies {
  implementation 'com.google.android.gms:play-services-fitness:21.2.0'
}

Demander des autorisations

Pour enregistrer des données à l'aide de l'API Recording sur mobile, votre application devra demander l'autorisation suivante :

  • android.permission.ACTIVITY_RECOGNITION

Vérifier la version des services Play

Pour utiliser l'API Recording sur mobile, l'utilisateur doit avoir mis à jour les services Google Play vers la version LOCAL_RECORDING_CLIENT_MIN_VERSION_CODE. Vous pouvez le vérifier à l'aide de la méthode isGooglePlayServicesAvailable :

val hasMinPlayServices = isGooglePlayServicesAvailable(context, LocalRecordingClient.LOCAL_RECORDING_CLIENT_MIN_VERSION_CODE)

if(hasMinPlayServices != ConnectionResult.SUCCESS) {
  // Prompt user to update their device's Google Play services app and return
}

// Continue with Recording API functions

Sinon, si la version des services Google Play de l'utilisateur est trop ancienne, le système génère une exception ConnectionResult.SERVICE_VERSION_UPDATE_REQUIRED.

S'abonner aux données de remise en forme

Pour demander la collecte en arrière-plan des données de pas, utilisez la méthode subscribe, comme indiqué dans l'extrait de code suivant :

val localRecordingClient = FitnessLocal.getLocalRecordingClient(this)
// Subscribe to steps data
localRecordingClient.subscribe(LocalDataType.TYPE_STEP_COUNT_DELTA)
  .addOnSuccessListener {
    Log.i(TAG, "Successfully subscribed!")
  }
  .addOnFailureListener { e ->
    Log.w(TAG, "There was a problem subscribing.", e)
  }

Lire et traiter les données de remise en forme

Une fois l'abonnement souscrit, demandez les données à l'aide de la méthode readData. Vous pouvez ensuite obtenir des LocalDataPoints à partir du LocalDataSet résultant en effectuant un LocalDataReadRequest, comme indiqué dans l'extrait de code suivant :

val endTime = LocalDateTime.now().atZone(ZoneId.systemDefault())
val startTime = endTime.minusWeeks(1)
val readRequest =
  LocalDataReadRequest.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(LocalDataType.TYPE_STEP_COUNT_DELTA)
    // Analogous to a "Group By" in SQL, defines how data should be
    // aggregated. bucketByTime allows bucketing by time span.
    .bucketByTime(1, TimeUnit.DAYS)
    .setTimeRange(startTime.toEpochSecond(), endTime.toEpochSecond(), TimeUnit.SECONDS)
    .build()

  localRecordingClient.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", e)
  }

fun dumpDataSet(dataSet: LocalDataSet) {
  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.getStartTime(TimeUnit.HOURS)}")
    Log.i(TAG,"\tEnd: ${dp.getEndTime(TimeUnit.HOURS)}")
    for (field in dp.dataType.fields) {
      Log.i(TAG,"\tLocalField: ${field.name.toString()} LocalValue: ${dp.getValue(field)}")
    }
  }
}

LocalRecordingClient met à jour en permanence sa collection de données. Vous pouvez utiliser readData pour obtenir les derniers chiffres à tout moment.

Notez que LocalRecordingClient stocke les données pendant 10 jours maximum. Pour réduire le risque de perte de données, vous pouvez utiliser WorkManager pour collecter régulièrement les données en arrière-plan.

Se désabonner des données de remise en forme

Pour libérer des ressources, veillez à vous désabonner de la collecte de données de capteur lorsque votre application n'en a plus besoin. Pour vous désabonner, utilisez la méthode unsubscribe :

val localRecordingClient = FitnessLocal.getLocalRecordingClient(this)
// Unsubscribe from steps data
localRecordingClient.unsubscribe(LocalDataType.TYPE_STEP_COUNT_DELTA)
  .addOnSuccessListener {
    Log.i(TAG, "Successfully unsubscribed!")
  }
  .addOnFailureListener { e ->
    Log.w(TAG, "There was a problem unsubscribing.", e)
  }