Se usó la API de Cloud Translation para traducir esta página.

API de grabación en dispositivos móviles

La API de Recording en dispositivos móviles permite que tu app registre los pasos desde un dispositivo móvil. con un consumo eficiente de la batería. Esta API no tiene cuenta, lo que significa que no requiere una Cuenta de Google para usar el servicio, y los datos se almacenan en el dispositivo.

En esta guía, se muestra cómo usar la API de Grabación en dispositivos móviles en tu salud y experiencias físicas.

Detalles destacados

Existen varias funciones notables exclusivas de la API de Grabación en dispositivos móviles:

Una vez que comience o se renueve la suscripción a la grabación, los datos desde la última (por un máximo de 10 días).
Los datos solo están disponibles cuando hay una suscripción activa. Si una suscripción se quita llamando a unsubscribe, no se podrá acceder a los datos de pasos recopilados.

Tipos de datos

La API de Recording en dispositivos móviles puede grabar los siguientes tipos de datos:

TYPE_STEP_COUNT_DELTA

Comenzar

Para comenzar, agrega la siguiente dependencia a tu archivo build.gradle:

DSL de Kotlin

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

...

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

DSL de Groovy

apply plugin: 'com.android.application'

...

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

Solicita permisos

Para registrar datos con la API de Grabación en dispositivos móviles, tu app deberá solicitar una el siguiente permiso:

android.permission.ACTIVITY_RECOGNITION

Cómo realizar una verificación de versión de los Servicios de Play

Para usar la API de Grabación en un dispositivo móvil, el usuario debe tener los Servicios de Google Play. se actualizó a LOCAL_RECORDING_CLIENT_MIN_VERSION_CODE. Puedes comprobarlo Con el método 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

De lo contrario, si la versión de los Servicios de Google Play del usuario es demasiado baja, arroja un ConnectionResult.SERVICE_VERSION_UPDATE_REQUIRED excepción.

Para solicitar la recopilación en segundo plano de datos de pasos, usa el subscribe, como se muestra en el siguiente fragmento de código:

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

Lectura y procesamiento de datos de Fitness

Una vez que te suscribas, solicita los datos con el método readData. Luego, puedes obtén LocalDataPoints del LocalDataSet resultante mediante crear un objeto LocalDataReadRequest, como se muestra en el siguiente código 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 actualiza continuamente su colección de datos. Puedes usa readData para extraer los últimos números en cualquier momento.

Ten en cuenta que LocalRecordingClient almacena hasta 10 días de datos. Para reducir el de perder datos, puedes usar WorkManager para recopilar los datos periódicamente en segundo plano.

Anular la suscripción a los datos de actividad física

Para liberar recursos, debes asegurarte de anular la suscripción al de datos de sensores cuando tu app ya no los necesite. Para anula la suscripción, usa el método 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)
  }