Cette page a été traduite par l'API Cloud Translation.

API Recording sur mobile

L'API Recording sur mobile permet à votre appli d'enregistrer les pas depuis un appareil mobile de manière économe en énergie. Cette API est sans compte, ce qui signifie qu'elle ne nécessite un compte Google pour utiliser le service et les données sont stockées sur l'appareil.

Ce guide vous explique comment utiliser l'API Recording sur mobile dans vos applications des expériences de fitness.

Détails importants

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

Une fois que l'abonnement à l'enregistrement démarre ou est renouvelé, les données (10 jours maximum) est accessible.
Les données ne sont disponibles que lorsqu'un abonnement est actif. Si un abonnement est supprimé en appelant unsubscribe, les données sur les 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 à 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 un appareil 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 disposer des services Google Play mise à jour vers LOCAL_RECORDING_CLIENT_MIN_VERSION_CODE. Vous pouvez vérifier cela à 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, génère une ConnectionResult.SERVICE_VERSION_UPDATE_REQUIRED une exception.

Pour demander la collecte en arrière-plan des données sur les pas, utilisez le 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 des 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 obtenu en en créant une LocalDataReadRequest, comme indiqué dans le code suivant : snippet:

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 constamment à jour sa collecte de données. Vous pouvez Utilisez readData pour extraire les derniers chiffres à tout moment.

Notez que LocalRecordingClient stocke jusqu'à 10 jours de données. Pour réduire 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

Afin de libérer des ressources, assurez-vous de vous désabonner collecte des données des capteurs lorsque votre application n'en a plus besoin. À désabonnez-vous, 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)
  }