API Recording sur mobile

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

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

Pour en savoir plus, consultez l'exemple de l'API Recording sur mobile sur GitHub.

Informations notables

L'API Recording sur mobile offre plusieurs fonctionnalités notables:

• Une fois l'abonnement d'enregistrement lancé 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 de pas collectées ne seront pas accessibles.

Types de données

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

• TYPE_STEP_COUNT_DELTA

Commencer

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

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

...

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

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 doit 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 basse, le système génère une exception ConnectionResult.SERVICE_VERSION_UPDATE_REQUIRED.

S'abonner aux données de fitness

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 fitness

Une fois abonné, demandez les données à l'aide de la méthode readData. Vous pouvez ensuite obtenir des LocalDataPoints à partir du LocalDataSet généré en créant 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 continu sa collecte de données. Vous pouvez utiliser readData pour extraire les derniers chiffres à tout moment.

Notez que LocalRecordingClient stocke jusqu'à 10 jours de données. Pour réduire le risque de perte de données, vous pouvez utiliser WorkManager pour collecter périodiquement les données en arrière-plan.

Se désabonner des données de fitness

Pour libérer des ressources, vous devez vous désabonner de la collecte des données des capteurs 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)
  }