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

Suivre vos pas

Santé Connect fournit un type de données Pas pour enregistrer le nombre de pas à l'aide de StepsRecord. Le nombre de pas est une mesure fondamentale pour le suivi de la santé et de la forme physique.

Lire les étapes mobiles

Avec Android 14 (niveau d'API 34) et la version 20 ou ultérieure de SDK Extension, Santé Connect fournit un compteur de pas sur l'appareil. Si une application a reçu l'autorisation READ_STEPS, Santé Connect commence à enregistrer les pas effectués sur l'appareil Android. Les utilisateurs voient alors les données de pas ajoutées automatiquement aux entrées Pas de Santé Connect.

Pour vérifier si le comptage de pas sur l'appareil est disponible, vous devez vous assurer que l'appareil exécute Android 14 (niveau d'API 34) et dispose au moins de la version 20 de l'extension SDK. Vous pouvez utiliser le code suivant :

val isStepTrackingAvailable =
    Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE &&
        SdkExtensions.getExtensionVersion(Build.VERSION_CODES.UPSIDE_DOWN_CAKE) >= 20

La valeur DataOrigin des pas enregistrés par Santé Connect est définie sur le nom du package android. Si votre application lit simplement le nombre de pas agrégé à l'aide de aggregate et ne filtre pas par DataOrigin, les pas enregistrés sur l'appareil sont automatiquement inclus dans le total.

Si votre application doit lire les pas effectués sur l'appareil ou afficher des données de pas ventilées par application ou appareil source, vous pouvez interroger les enregistrements où DataOrigin est android. Si votre application affiche l'attribution des données de pas, vous devez attribuer les données du package Android à l'appareil actuel. Pour ce faire, vous pouvez utiliser un libellé tel que "Votre téléphone", récupérer le nom de l'appareil avec Settings.Global.getString(resolver, Settings.Global.DEVICE_NAME) ou inspecter le champ Device dans les métadonnées de l'enregistrement.

L'exemple suivant montre comment lire les données agrégées sur le nombre de pas sur mobile en filtrant sur l'origine des données android :

suspend fun readStepsByTimeRange(
    healthConnectClient: HealthConnectClient,
    startTime: Instant,
    endTime: Instant
) {
    try {
        val response = healthConnectClient.aggregate(
            AggregateRequest(
                metrics = setOf(StepsRecord.COUNT_TOTAL),
                timeRangeFilter = TimeRangeFilter.between(startTime, endTime),
                dataOriginFilter = setOf(DataOrigin("android"))
            )
        )
        // The result may be null if no data is available in the time range
        val stepCount = response[StepsRecord.COUNT_TOTAL]
    } catch (e: Exception) {
        // Run error handling here
    }
}

Comptage des pas sur l'appareil

En savoir plus sur la fonctionnalité de comptage des pas sur l'appareil :

Utilisation des capteurs : Santé Connect utilise le capteur TYPE_STEP_COUNTER de SensorManager. Ce capteur est optimisé pour une faible consommation d'énergie, ce qui le rend idéal pour le suivi continu des pas en arrière-plan.
Précision des données : pour préserver l'autonomie de la batterie, les données sur les pas sont généralement regroupées et écrites dans la base de données Santé Connect au maximum une fois par minute.
Attribution : comme mentionné précédemment, toutes les étapes enregistrées par cette fonctionnalité sur l'appareil sont attribuées au nom de package android dans DataOrigin.
Activation : le mécanisme de comptage des pas sur l'appareil n'est actif que lorsqu'au moins une application sur l'appareil a reçu l'autorisation READ_STEPS dans Santé Connect.

Vérifier la disponibilité de Santé Connect

Avant de tenter d'utiliser Santé Connect, votre application doit vérifier que Santé Connect est disponible sur l'appareil de l'utilisateur. Il est possible que Santé Connect ne soit pas préinstallé sur tous les appareils ou qu'il soit désactivé. Vous pouvez vérifier la disponibilité à l'aide de la méthode HealthConnectClient.getSdkStatus().

Vérifier la disponibilité de Santé Connect

fun checkHealthConnectAvailability(context: Context) {
    val providerPackageName = "com.google.android.apps.healthdata" // Or get from HealthConnectClient.DEFAULT_PROVIDER_PACKAGE_NAME
    val availabilityStatus = HealthConnectClient.getSdkStatus(context, providerPackageName)

    if (availabilityStatus == HealthConnectClient.SDK_UNAVAILABLE) {
      // Health Connect is not available. Guide the user to install/enable it.
      // For example, show a dialog.
      return // early return as there is no viable integration
    }
    if (availabilityStatus == HealthConnectClient.SDK_UNAVAILABLE_PROVIDER_UPDATE_REQUIRED) {
      // Health Connect is available but requires an update.
      // Optionally redirect to package installer to find a provider, for example:
      val uriString = "market://details?id=$providerPackageName&url=healthconnect%3A%2F%2Fonboarding"
      context.startActivity(
        Intent(Intent.ACTION_VIEW).apply {
          setPackage("com.android.vending")
          data = Uri.parse(uriString)
          putExtra("overlay", true)
          putExtra("callerId", context.packageName)
        }
      )
      return
    }
    // Health Connect is available, obtain a HealthConnectClient instance
    val healthConnectClient = HealthConnectClient.getOrCreate(context)
    // Issue operations with healthConnectClient
}

En fonction de l'état renvoyé par getSdkStatus(), vous pouvez inviter l'utilisateur à installer ou à mettre à jour Santé Connect depuis le Google Play Store, si nécessaire.

Autorisations requises

L'accès aux pas est protégé par les autorisations suivantes :

android.permission.health.READ_STEPS
android.permission.health.WRITE_STEPS

Pour ajouter la fonctionnalité de pas à votre application, commencez par demander des autorisations d'écriture pour le type de données Steps.

Voici l'autorisation que vous devez déclarer pour pouvoir écrire des étapes :

<application>
  <uses-permission
android:name="android.permission.health.WRITE_STEPS" />
...
</application>

Pour lire les pas, vous devez demander les autorisations suivantes :

<application>
  <uses-permission
android:name="android.permission.health.READ_STEPS" />
...
</application>

Demander des autorisations à l'utilisateur

Après avoir créé une instance de client, votre application doit demander des autorisations à l'utilisateur. Les utilisateurs doivent être autorisés à accorder ou à refuser des autorisations à tout moment.

Pour ce faire, créez un ensemble d'autorisations pour les types de données requis. Assurez-vous d'abord que les autorisations de l'ensemble sont déclarées dans votre fichier manifeste Android.

// Create a set of permissions for required data types
val PERMISSIONS =
    setOf(
  HealthPermission.getReadPermission(StepsRecord::class),
  HealthPermission.getWritePermission(StepsRecord::class)
)

Utilisez getGrantedPermissions pour voir si votre application dispose déjà des autorisations requises accordées. Si ce n'est pas le cas, utilisez createRequestPermissionResultContract pour demander ces autorisations. L'écran des autorisations de Santé Connect s'affiche.

// Create the permissions launcher
val requestPermissionActivityContract = PermissionController.createRequestPermissionResultContract()

val requestPermissions = registerForActivityResult(requestPermissionActivityContract) { granted ->
  if (granted.containsAll(PERMISSIONS)) {
    // Permissions successfully granted
  } else {
    // Lack of required permissions
  }
}

suspend fun checkPermissionsAndRun(healthConnectClient: HealthConnectClient) {
  val granted = healthConnectClient.permissionController.getGrantedPermissions()
  if (granted.containsAll(PERMISSIONS)) {
    // Permissions already granted; proceed with inserting or reading data
  } else {
    requestPermissions.launch(PERMISSIONS)
  }
}

Étant donné que les utilisateurs peuvent accorder ou révoquer des autorisations à tout moment, votre application doit vérifier régulièrement les autorisations accordées et être capable de gérer les cas de perte d'autorisations.

Informations incluses dans un enregistrement Pas

Chaque StepsRecord contient les informations suivantes :

count : nombre de pas effectués dans l'intervalle de temps, sous la forme d'un Long.
startTime : heure de début de l'intervalle de mesure.
endTime : heure de fin de l'intervalle de mesure.
startZoneOffset : décalage de fuseau horaire pour l'heure de début.
endZoneOffset : décalage de fuseau horaire pour l'heure de fin.

Agrégations acceptées

Les valeurs agrégées suivantes sont disponibles pour StepsRecord :

COUNT_TOTAL

Les valeurs agrégées suivantes sont disponibles pour StepsCadenceRecord :

Exemples d'utilisation

Les sections suivantes expliquent comment lire et écrire des données StepsRecord.

Écrire des données sur les pas

Votre application peut écrire des données sur le nombre de pas en insérant des instances StepsRecord. L'exemple suivant montre comment enregistrer 1 000 pas effectués par un utilisateur :

suspend fun writeStepsData(
    healthConnectClient: HealthConnectClient,
    startTime: Instant,
    endTime: Instant,
    startZoneOffset: ZoneOffset,
    endZoneOffset: ZoneOffset
) {
    try {
        val stepsRecord = StepsRecord(
            startTime = startTime,
            startZoneOffset = startZoneOffset,
            endTime = endTime,
            endZoneOffset = endZoneOffset,
            count = 1000
        )
        healthConnectClient.insertRecords(listOf(stepsRecord))
    } catch (e: Exception) {
        // Run error handling
    }
}

Lire les données agrégées

La méthode la plus courante pour lire les données de pas consiste à agréger le nombre total de pas sur une période donnée. L'exemple suivant montre comment lire le nombre total de pas d'un utilisateur au cours d'une certaine période :

suspend fun readStepsAggregate(
    healthConnectClient: HealthConnectClient,
    startTime: Instant,
    endTime: Instant
) {
    try {
        val response = healthConnectClient.aggregate(
            AggregateRequest(
                metrics = setOf(StepsRecord.COUNT_TOTAL),
                timeRangeFilter = TimeRangeFilter.between(startTime, endTime)
            )
        )
        // The result may be null if no data is available in the time range
        val stepCount = response[StepsRecord.COUNT_TOTAL]
    } catch (e: Exception) {
        // Run error handling here
    }
}

Lire des données brutes

L'exemple suivant montre comment lire les données StepsRecord brutes entre une heure de début et une heure de fin :

suspend fun readStepsRaw(
    healthConnectClient: HealthConnectClient,
    startTime: Instant,
    endTime: Instant
) {
    try {
        val response = healthConnectClient.readRecords(
            ReadRecordsRequest(
                recordType = StepsRecord::class,
                timeRangeFilter = TimeRangeFilter.between(startTime, endTime)
            )
        )
        for (record in response.records) {
            // Process each record
        }
    } catch (e: Exception) {
        // Run error handling here
    }
}

Suivre vos pas Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Lire les étapes mobiles

Comptage des pas sur l'appareil

Vérifier la disponibilité de Santé Connect

Vérifier la disponibilité de Santé Connect

Autorisations requises

Demander des autorisations à l'utilisateur

Informations incluses dans un enregistrement Pas

Agrégations acceptées

Exemples d'utilisation

Écrire des données sur les pas

Lire les données agrégées

Lire des données brutes

Suivre vos pas