Votre première appli intégrée à Santé Connect

1. Introduction

Qu'est-ce que Santé Connect ?

Santé Connect est une plate-forme de données de santé pour les développeurs d'applications Android. Elle fournit une interface unique et consolidée pour accéder aux données de santé et de remise en forme des utilisateurs, et assure un fonctionnement cohérent sur tous les appareils. Avec Santé Connect, les utilisateurs disposent d'un espace de stockage sécurisé sur leur appareil pour leurs données de santé et de remise en forme. Ils profitent d'un contrôle total sur l'accès à ces données et d'une entière transparence à ce sujet.

Comment fonctionne Santé Connect ?

Santé Connect prend en charge plus de 50 types et catégories courants de données de santé, y compris l'activité, le sommeil, la nutrition, les données corporelles et les constantes, comme la fréquence cardiaque et la tension artérielle.

Avec l'autorisation de l'utilisateur, les développeurs peuvent lire et écrire des données de manière sécurisée dans Santé Connect à l'aide de schémas et d'un comportement des API standardisés. Les utilisateurs ont un contrôle total sur leurs paramètres de confidentialité, avec des commandes précises pour voir à tout moment quelles applications demandent à accéder aux données. Les données de Santé Connect sont stockées sur l'appareil et chiffrées. Les utilisateurs peuvent désactiver l'accès aux données ou supprimer celles qu'ils ne souhaitent plus stocker sur leur appareil. Ils peuvent également donner la priorité à une source de données plutôt qu'une autre lorsqu'ils utilisent plusieurs applications.

Architecture de Santé Connect

Voici une explication des principaux aspects et composants architecturaux de Santé Connect :

• Application cliente : pour intégrer Santé Connect, l'application cliente associe le SDK à son application de santé et de remise en forme. Cela fournit une surface d'API permettant d'interagir avec l'API Santé Connect.
• Software development kit (kit de développement logiciel) : le SDK permet à l'application cliente de communiquer avec l'APK de Santé Connect.
• APK Santé Connect : il s'agit de l'APK qui implémente Santé Connect. Il contient à la fois ses composants de gestion des autorisations et de gestion des données. L'APK de Santé Connect est disponible directement sur l'appareil de l'utilisateur, ce qui fait de Santé Connect un outil axé sur l'appareil plutôt que sur le compte.
• Gestion des autorisations : Santé Connect comprend une interface utilisateur via laquelle les applications demandent l'autorisation de l'utilisateur pour afficher les données. Elle fournit également une liste des autorisations utilisateur existantes. Les utilisateurs peuvent ainsi gérer l'accès qu'ils ont accordé ou refusé à différentes applications.
• Gestion des données : Santé Connect fournit une interface utilisateur offrant un aperçu des données enregistrées, qu'il s'agisse du nombre de pas, de la vitesse à vélo, de la fréquence cardiaque ou d'autres types de données pris en charge.

Objectifs de l'atelier

Dans cet atelier de programmation, vous allez créer une application de santé et de remise en forme simple intégrée à Santé Connect. Votre application permettra les actions suivantes :

• Obtenir et vérifier les autorisations des utilisateurs concernant l'accès aux données
• Écrire des données dans Santé Connect
• Lire les données globales de Santé Connect

Points abordés

• Comment configurer votre environnement pour intégrer Santé Connect
• Comment obtenir des autorisations et effectuer des vérifications d'autorisation
• Comment contribuer aux données de santé et de remise en forme sur la plate-forme Santé Connect
• Comment bénéficier du stockage des données sur l'appareil
• Comment valider votre application avec les outils Google pour les développeurs

Ce dont vous aurez besoin

• La dernière version stable d'Android Studio
• Un appareil mobile Android équipé du SDK Android 28 (Pie) ou version ultérieure

2. Configuration

Préparer l'application Santé Connect

L'application Santé Connect est responsable de la gestion de toutes les requêtes que votre application envoie via le SDK Santé Connect. Ces requêtes incluent le stockage des données et la gestion de leurs accès en lecture et en écriture.

L'accès à Santé Connect dépend de la version d'Android installée sur le téléphone. Les sections suivantes expliquent comment gérer plusieurs versions récentes d'Android.

Android 14

À partir d'Android 14 (niveau d'API 34), Santé Connect fait partie du framework Android. Étant donné que cette version de Santé Connect est un module de framework, aucune configuration n'est nécessaire.

Android 13 ou version antérieure

Sur Android 13 (niveau d'API 33) et versions antérieures, Santé Connect ne fait pas partie du framework Android. Vous devez donc installer l'application Santé Connect à partir du Google Play Store. Scannez le code QR pour installer Santé Connect.

Obtenir l'exemple de code

Commencez par cloner le code source depuis GitHub :

git clone https://github.com/android/android-health-connect-codelab.git

Le répertoire d'exemples contient le code start et le code finished de cet atelier. Dans la vue Project (Projet) d'Android Studio, vous trouverez deux modules :

• start : code de démarrage du projet, que vous allez modifier tout au long de l'atelier de programmation.
• finished : code final de cet atelier de programmation (pour vérifier ce que vous avez fait).

Se familiariser avec le code "start"

L'application exemple de l'atelier de programmation comporte des interfaces utilisateur de base créées par Jetpack Compose avec les écrans suivants :

• WelcomeScreen : page de destination de l'application, qui affiche différents messages en fonction de la disponibilité de Santé Connect, qu'elle soit installée, non installée ou non compatible.
• PrivacyPolicyScreen : explique comment l'application utilise les autorisations et s'affiche lorsque l'utilisateur clique sur le lien Privacy policy (Règles de confidentialité) dans la boîte de dialogue d'autorisations de Santé Connect.
• InputReadingsScreen : illustre la lecture et l'écriture de données de poids simples.
• ExerciseSessionScreen : permet aux utilisateurs d'insérer et de répertorier des séances d'exercice. Lorsque l'utilisateur clique sur l'enregistrement, il est redirigé vers ExerciseSessionDetailScreen où il peut voir plus de données pour cette séance.
• DifferentialChangesScreen : montre comment générer un jeton de modification et comment recevoir les nouvelles modifications de Santé Connect.

HealthConnectManager stocke toutes les fonctions qui interagissent avec Santé Connect. Dans cet atelier de programmation, nous allons vous guider pas à pas pour utiliser les fonctionnalités essentielles. Les chaînes <!-- TODO: du build start ont des sections correspondantes dans cet atelier de programmation où des exemples de codes sont fournis pour que vous puissiez les insérer dans le projet.

Commençons par ajouter Santé Connect au projet !

Ajouter le SDK client Santé Connect

Pour commencer à utiliser le SDK Santé Connect, vous devez ajouter une dépendance au fichier build.gradle. Pour obtenir la dernière version de Santé Connect, consultez la version de la bibliothèque Jetpack.

dependencies {
    // Add a dependency of Health Connect SDK
    implementation "androidx.health.connect:connect-client:1.1.0-alpha10"
}

Rendre Santé Connect visible

Pour interagir avec Health Connect dans l'application, déclarez le nom du package Santé Connect dans le fichier AndroidManifest.xml :

<!-- TODO: declare Health Connect visibility -->
<queries>
   <package android:name="com.google.android.apps.healthdata" />
</queries>

Exécuter le projet de démarrage

Une fois que vous avez fini, exécutez le projet start. À ce stade, vous devriez voir l'écran de bienvenue indiquant que Santé Connect est installé sur cet appareil, et un menu. Nous ajouterons les fonctionnalités permettant d'interagir avec Santé Connect dans les sections suivantes.

3. Contrôle des autorisations

Santé Connect recommande aux développeurs de limiter les demandes d'autorisation aux types de données utilisés dans l'application. Les demandes d'autorisation globales nuisent à la confiance que vous portent les utilisateurs. Si une autorisation est refusée plus de deux fois, votre application sera verrouillée. Par conséquent, les demandes d'autorisation n'apparaîtront plus.

Pour les besoins de cet atelier de programmation, nous n'avons besoin que des autorisations suivantes :

• Séance d'exercice
• Fréquence cardiaque
• Pas
• Total des calories brûlées
• Poids

Déclarer des autorisations

Chaque type de données que votre application lit ou écrit doit être déclaré à l'aide d'une autorisation dans AndroidManifest.xml. À partir de la version 1.0.0-alpha10, Santé Connect utilise le format de déclaration d'autorisations Android standard.

Pour déclarer les autorisations pour les types de données requis, utilisez les éléments <uses-permission> et attribuez les autorisations à leur nom respectif. Imbriquez-les dans les balises <manifest>. Pour obtenir la liste complète des autorisations et des types de données correspondants, consultez la section Liste des types de données.

<!-- TODO: Required to specify which Health Connect permissions the app can request -->
  <uses-permission android:name="android.permission.health.READ_HEART_RATE"/>
  <uses-permission android:name="android.permission.health.WRITE_HEART_RATE"/>
  <uses-permission android:name="android.permission.health.READ_STEPS"/>
  <uses-permission android:name="android.permission.health.WRITE_STEPS"/>
  <uses-permission android:name="android.permission.health.READ_EXERCISE"/>
  <uses-permission android:name="android.permission.health.WRITE_EXERCISE"/>
  <uses-permission android:name="android.permission.health.READ_TOTAL_CALORIES_BURNED"/>
  <uses-permission android:name="android.permission.health.WRITE_TOTAL_CALORIES_BURNED"/>
  <uses-permission android:name="android.permission.health.READ_WEIGHT"/>
  <uses-permission android:name="android.permission.health.WRITE_WEIGHT"/>

Déclarez un filtre d'intent dans AndroidManifest.xml pour gérer l'intent qui explique comment votre application utilisera ces autorisations. Votre application doit gérer cet intent et afficher des règles de confidentialité décrivant comment les données utilisateur sont utilisées et traitées. Cet intent est envoyé à l'application lorsque l'utilisateur appuie sur le lien Privacy policy (Règles de confidentialité) dans la boîte de dialogue d'autorisations de Santé Connect.

<!-- TODO: Add intent filter to handle permission rationale intent -->
<!-- Permission handling for Android 13 and before -->
<intent-filter>
  <action android:name="androidx.health.ACTION_SHOW_PERMISSIONS_RATIONALE" />
</intent-filter>

<!-- Permission handling for Android 14 and later -->
<intent-filter>
  <action android:name="android.intent.action.VIEW_PERMISSION_USAGE"/>
  <category android:name="android.intent.category.HEALTH_PERMISSIONS"/>
</intent-filter>

Rouvrez l'application pour consulter les autorisations déclarées. Cliquez sur Settings (Paramètres) dans le panneau de menu pour accéder à l'écran des paramètres de Santé Connect. Cliquez ensuite sur App permissions (Autorisations des applications). Santé Connect devrait apparaître dans la liste. Cliquez sur Santé Connect pour afficher la liste des types de données pour l'accès en lecture et en écriture sur cette application.

Demander des autorisations

En plus de rediriger directement les utilisateurs vers les paramètres de Santé Connect pour gérer les autorisations, vous pouvez également faire en sorte que votre application demande des autorisations via les API Santé Connect. Notez que les utilisateurs peuvent modifier les autorisations à tout moment. Assurez-vous donc que votre application vérifie si les autorisations requises sont disponibles. Dans le projet de l'atelier de programmation, nous vérifions et envoyons des demandes d'autorisation avant de lire ou d'écrire des données.

HealthConnectClient est un point d'entrée de l'API Santé Connect. Dans HealthConnectManager.kt, obtenez une instance HealthConnectClient.

private val healthConnectClient by lazy { HealthConnectClient.getOrCreate(context) }

Pour lancer la boîte de dialogue des demandes d'autorisations dans votre application, commencez par créer un ensemble d'autorisations pour les types de données requis. Vous ne devez demander des autorisations que pour les types de données que vous prévoyez d'utiliser.

Par exemple, sur l'écran Record weight (Enregistrer le poids), vous ne devez accorder que les autorisations de lecture et d'écriture pour le poids. Nous avons créé une autorisation dans InputReadingsViewModel.kt, comme indiqué dans le code suivant.

  val permissions = setOf(
    HealthPermission.getReadPermission(WeightRecord::class),
    HealthPermission.getWritePermission(WeightRecord::class),
  )

Vérifiez ensuite si les autorisations ont été accordées avant de lancer la demande d'autorisation. Dans HealthConnectManager.kt, utilisez getGrantedPermissions pour vérifier si l'autorisation des types de données requis est accordée. Pour lancer la demande d'autorisation, vous devez créer un ActivityResultContract à l'aide de PermissionController.createRequestPermissionResultContract(), qui devrait se lancer lorsque les autorisations requises ne sont pas accordées.

  suspend fun hasAllPermissions(permissions: Set<String>): Boolean {
    return healthConnectClient.permissionController.getGrantedPermissions().containsAll(permissions)
  }

  fun requestPermissionsActivityContract(): ActivityResultContract<Set<String>, Set<String>> {
    return PermissionController.createRequestPermissionResultContract()
  }

Dans l'application exemple de l'atelier de programmation, le bouton Request permissions (Demander des autorisations) peut s'afficher à l'écran si vous n'avez pas accordé les autorisations pour les types de données requis. Cliquez sur Request permissions (Demander des autorisations) pour ouvrir la boîte de dialogue d'autorisation de Santé Connect. Autorisez les autorisations requises et revenez à l'application de l'atelier de programmation.

4. Écrire des données

Commençons à écrire les enregistrements dans Santé Connect. Pour écrire un enregistrement de poids, créez un objet WeightRecord avec le poids saisi. Notez que le SDK Santé Connect prend en charge différentes classes d'unités. Par exemple, utilisez Mass.kilograms(weightInput) pour définir le poids des utilisateurs en kilogrammes.

Toutes les données écrites dans Santé Connect doivent préciser des informations de fuseau horaire. Les informations de fuseau horaire précisées lors de l'écriture des données permettent de les avoir à disposition lors de la lecture de données dans Santé Connect.

Après avoir créé l'enregistrement de poids, utilisez healthConnectClient.insertRecords pour écrire les données dans Santé Connect.

/**
* TODO: Writes [WeightRecord] to Health Connect.
*/
suspend fun writeWeightInput(weightInput: Double) {
   val time = ZonedDateTime.now().withNano(0)
   val weightRecord = WeightRecord(
       weight = Mass.kilograms(weightInput),
       time = time.toInstant(),
       zoneOffset = time.offset
   )
   val records = listOf(weightRecord)
   try {
      healthConnectClient.insertRecords(records)
      Toast.makeText(context, "Successfully insert records", Toast.LENGTH_SHORT).show()
   } catch (e: Exception) {
      Toast.makeText(context, e.message.toString(), Toast.LENGTH_SHORT).show()
   }
}

Exécutons à présent l'application. Cliquez sur Record weight (Enregistrer le poids) et saisissez un nouvel enregistrement de poids en kilogrammes. Pour vérifier si l'enregistrement de poids a bien été écrit dans Santé Connect, ouvrez les paramètres de Santé Connect et cliquez sur Data and access (Données et accès) -> Body measurements (Données corporelles) -> Weight (Poids) -> See all entries (Afficher toutes les entrées). Le nouvel enregistrement de poids écrit depuis l'atelier de programmation Santé Connect devrait s'afficher.

Écrire des séances d'exercice

Une séance est un intervalle de temps pendant lequel un utilisateur effectue une activité. Une séance d'exercice dans Santé Connect peut inclure toutes sortes d'activités, par exemple la course à pied ou le badminton. Les séances permettent aux utilisateurs de mesurer leurs performances au fil du temps. Ces données enregistrent un ensemble de relevés instantanés, par exemple une fréquence cardiaque continue ou des relevés de localisation pendant une activité, mesurés sur une période donnée.

L'exemple suivant vous montre comment rédiger une séance d'exercice. Utilisez healthConnectClient.insertRecords pour insérer plusieurs enregistrements de données associés à une séance. Dans cet exemple, la requête d'insertion inclut ExerciseSessionRecord avec ExerciseType, StepsRecord avec le nombre de pas, TotalCaloriesBurnedRecord avec Energy et une série d'exemples de HeartRateRecord.

  /**
   * TODO: Writes an [ExerciseSessionRecord] to Health Connect.
   */
  suspend fun writeExerciseSession(start: ZonedDateTime, end: ZonedDateTime) {
    healthConnectClient.insertRecords(
      listOf(
        ExerciseSessionRecord(
          startTime = start.toInstant(),
          startZoneOffset = start.offset,
          endTime = end.toInstant(),
          endZoneOffset = end.offset,
          exerciseType = ExerciseSessionRecord.EXERCISE_TYPE_RUNNING,
          title = "My Run #${Random.nextInt(0, 60)}"
        ),
        StepsRecord(
          startTime = start.toInstant(),
          startZoneOffset = start.offset,
          endTime = end.toInstant(),
          endZoneOffset = end.offset,
          count = (1000 + 1000 * Random.nextInt(3)).toLong()
        ),
        TotalCaloriesBurnedRecord(
          startTime = start.toInstant(),
          startZoneOffset = start.offset,
          endTime = end.toInstant(),
          endZoneOffset = end.offset,
          energy = Energy.calories((140 + Random.nextInt(20)) * 0.01)
        )
      ) + buildHeartRateSeries(start, end)
    )
  }

  /**
   * TODO: Build [HeartRateRecord].
   */
  private fun buildHeartRateSeries(
    sessionStartTime: ZonedDateTime,
    sessionEndTime: ZonedDateTime,
  ): HeartRateRecord {
    val samples = mutableListOf<HeartRateRecord.Sample>()
    var time = sessionStartTime
    while (time.isBefore(sessionEndTime)) {
      samples.add(
        HeartRateRecord.Sample(
          time = time.toInstant(),
          beatsPerMinute = (80 + Random.nextInt(80)).toLong()
        )
      )
      time = time.plusSeconds(30)
    }
    return HeartRateRecord(
      startTime = sessionStartTime.toInstant(),
      startZoneOffset = sessionStartTime.offset,
      endTime = sessionEndTime.toInstant(),
      endZoneOffset = sessionEndTime.offset,
      samples = samples
    )
  }

5. Lire des données

Vous avez créé des enregistrements de poids et de séances d'exercice dans l'application exemple de l'atelier de programmation et dans la boîte à outils. Utilisons maintenant l'API Santé Connect pour lire ces enregistrements. Commencez par créer un ReadRecordsRequest, puis spécifiez le type d'enregistrement et la période de lecture. ReadRecordsRequest peut également définir un dataOriginFilter pour spécifier l'application source de l'enregistrement à partir duquel vous voulez lire les données.

    /**
     * TODO: Reads in existing [WeightRecord]s.
     */
    suspend fun readWeightInputs(start: Instant, end: Instant): List<WeightRecord> {
        val request = ReadRecordsRequest(
            recordType = WeightRecord::class,
            timeRangeFilter = TimeRangeFilter.between(start, end)
        )
        val response = healthConnectClient.readRecords(request)
        return response.records
    }

  /**
   * TODO: Obtains a list of [ExerciseSessionRecord]s in a specified time frame.
   */
  suspend fun readExerciseSessions(start: Instant, end: Instant): List<ExerciseSessionRecord> {
    val request = ReadRecordsRequest(
      recordType = ExerciseSessionRecord::class,
      timeRangeFilter = TimeRangeFilter.between(start, end)
    )
    val response = healthConnectClient.readRecords(request)
    return response.records
  }

Exécutons à présent l'application pour voir si vous pouvez afficher une liste d'enregistrements de poids et de séances d'exercice.

6. Lire des données en arrière-plan

Déclarer une autorisation

Pour accéder aux données de forme physique en arrière-plan, déclarez l'autorisation READ_HEALTH_DATA_IN_BACKGROUND dans votre fichier AndroidManifest.xml.

<!-- TODO: Required to specify which Health Connect permissions the app can request -->
...
<uses-permission android:name="android.permission.health.READ_HEALTH_DATA_IN_BACKGROUND" />

Vérifier la disponibilité des fonctionnalités

Étant donné que les utilisateurs ne disposent pas toujours de la dernière version de Santé Connect, il est préférable de vérifier d'abord la disponibilité des fonctionnalités. Dans HealthConnectManager.kt, nous utilisons la méthode getFeatureStatus pour ce faire.

fun isFeatureAvailable(feature: Int): Boolean{
    return healthConnectClient
      .features
      .getFeatureStatus(feature) == HealthConnectFeatures.FEATURE_STATUS_AVAILABLE
  }

La fonctionnalité de lecture en arrière-plan dans ExerciseSessionViewModel.kt est vérifiée à l'aide de la constante FEATURE_READ_HEALTH_DATA_IN_BACKGROUND :

backgroundReadAvailable.value = healthConnectManager.isFeatureAvailable(
      HealthConnectFeatures.FEATURE_READ_HEALTH_DATA_IN_BACKGROUND
    )

Demander des autorisations

Après avoir vérifié que la fonctionnalité de lecture en arrière-plan est disponible, vous pouvez demander l'autorisation PERMISSION_READ_HEALTH_DATA_IN_BACKGROUND en cliquant sur Request Background Read (Demander la lecture en arrière-plan) sur l'écran Exercise sessions (Séances d'exercice).

L'invite suivante s'affiche :

Les utilisateurs peuvent également accorder l'accès aux lectures en arrière-plan en accédant à Health Connect > App permissions > Health Connect Codelab > Additional access (Santé Connect > Autorisations de l'application > Atelier de programmation Santé Connect > Accès supplémentaire) dans les paramètres système :

Lire des données en arrière-plan

Utilisez WorkManager pour planifier des tâches en arrière-plan. Lorsque vous appuyez sur le bouton Read Steps In Background (Lire les étapes en arrière-plan), l'application lance ReadStepWorker après un délai de 10 secondes. Ce Worker récupère le nombre total de pas enregistrés par Santé Connect lors des précédentes 24 heures. Une entrée de journal similaire détaillant ces informations, s'affiche ensuite dans Logcat :

There are 4000 steps in Health Connect in the last 24 hours.

7. Lire des données différentielles

L'API Differential Changes de Santé Connect permet de suivre les changements à partir d'un moment précis pour un ensemble de types de données. Cela est utile, par exemple, lorsque vous souhaitez savoir si les utilisateurs ont mis à jour ou supprimé des enregistrements existants en dehors de votre application, afin de mettre à jour votre base de données en conséquence.

La lecture des données avec Santé Connect est limitée aux applications exécutées au premier plan. Cette restriction a pour but de renforcer la confidentialité des données des utilisateurs. Elle avertit et assure les utilisateurs que les données de Santé Connect ne sont pas accessibles en lecture à l'arrière-plan, et que ces données sont seulement lues lorsque l'application est exécutée au premier plan. Lorsque l'application est exécutée au premier plan, l'API Differential Changes permet aux développeurs de récupérer les modifications apportées à Santé Connect en déployant un jeton de modifications.

HealthConnectManager.kt comprend deux fonctions getChangesToken() et getChanges() : nous allons leur ajouter l'API Differential Changes pour obtenir les modifications de données.

Configuration initiale du jeton de modifications

Les modifications de données sont extraites de Santé Connect uniquement lorsque votre application les demande avec un jeton de modifications. Le jeton de modifications représente le point de l'historique des commits à partir duquel les données différentielles seront extraites.

Pour obtenir un jeton de modifications, envoyez une ChangesTokenRequest avec un ensemble de types de données dont vous souhaitez suivre les modifications. Conservez le jeton et utilisez-le lorsque vous souhaitez récupérer des mises à jour de Santé Connect.

  /**
   * TODO: Obtains a Changes token for the specified record types.
   */
  suspend fun getChangesToken(): String {
    return healthConnectClient.getChangesToken(
      ChangesTokenRequest(
        setOf(
          ExerciseSessionRecord::class
        )
      )
    )
  }

Mise à jour des données avec un jeton de modifications

Pour récupérer les modifications de la dernière synchronisation de votre application avec Santé Connect, utilisez le jeton de modifications que vous avez obtenu précédemment et envoyez un appel getChanges avec le jeton. ChangesResponse renvoie une liste des modifications observées de Santé Connect, comme UpsertionChange et DeletionChange.

  /**
   * TODO: Retrieve changes from a Changes token.
   */
  suspend fun getChanges(token: String): Flow<ChangesMessage> = flow {
    var nextChangesToken = token
    do {
      val response = healthConnectClient.getChanges(nextChangesToken)
      if (response.changesTokenExpired) {
        throw IOException("Changes token has expired")
      }
      emit(ChangesMessage.ChangeList(response.changes))
      nextChangesToken = response.nextChangesToken
    } while (response.hasMore)
    emit(ChangesMessage.NoMoreChanges(nextChangesToken))
  }

Exécutez à présent l'application et accédez à l'écran des modifications. Activez d'abord le bouton Track changes (Suivre les modifications) pour obtenir un jeton de modifications. Ensuite, insérez des données de poids ou des séances d'exercice depuis la boîte à outils ou l'application de l'atelier de programmation. Revenez à l'écran de modifications, puis sélectionnez Get new changes (Recevoir les nouvelles modifications). Les modifications devraient maintenant s'afficher.

8. Données globales

Santé Connect fournit également des données globales via des API d'agrégation. Les exemples suivants vous montrent comment obtenir des données cumulées et statistiques à partir de Santé Connect.

Utilisez healthConnectClient.aggregate pour envoyer AggregateRequest. Dans la requête globale, spécifiez un ensemble de métriques agrégées et la période que vous souhaitez obtenir. Par exemple, ExerciseSessionRecord.EXERCISE_DURATION_TOTAL et StepsRecord.COUNT_TOTAL fournissent des données cumulées, tandis que WeightRecord.WEIGHT_AVG, HeartRateRecord.BPM_MAX et HeartRateRecord.BPM_MIN fournissent des données statistiques.

    /**
     * TODO: Returns the weekly average of [WeightRecord]s.
     */
    suspend fun computeWeeklyAverage(start: Instant, end: Instant): Mass? {
        val request = AggregateRequest(
            metrics = setOf(WeightRecord.WEIGHT_AVG),
            timeRangeFilter = TimeRangeFilter.between(start, end)
        )
        val response = healthConnectClient.aggregate(request)
        return response[WeightRecord.WEIGHT_AVG]
    }

Cet exemple montre comment obtenir les données globales associées à une séance d'exercice spécifique. Commencez par lire un enregistrement en utilisant healthConnectClient.readRecord avec un uid. Utilisez ensuite startTime et endTime de la séance d'exercice comme période et dataOrigin comme filtres pour lire les données globales associées.

  /**
   * TODO: Reads aggregated data and raw data for selected data types, for a given [ExerciseSessionRecord].
   */
  suspend fun readAssociatedSessionData(
      uid: String,
  ): ExerciseSessionData {
    val exerciseSession = healthConnectClient.readRecord(ExerciseSessionRecord::class, uid)
    // Use the start time and end time from the session, for reading raw and aggregate data.
    val timeRangeFilter = TimeRangeFilter.between(
      startTime = exerciseSession.record.startTime,
      endTime = exerciseSession.record.endTime
    )
    val aggregateDataTypes = setOf(
      ExerciseSessionRecord.EXERCISE_DURATION_TOTAL,
      StepsRecord.COUNT_TOTAL,
      TotalCaloriesBurnedRecord.ENERGY_TOTAL,
      HeartRateRecord.BPM_AVG,
      HeartRateRecord.BPM_MAX,
      HeartRateRecord.BPM_MIN,
    )
    // Limit the data read to just the application that wrote the session. This may or may not
    // be desirable depending on the use case: In some cases, it may be useful to combine with
    // data written by other apps.
    val dataOriginFilter = setOf(exerciseSession.record.metadata.dataOrigin)
    val aggregateRequest = AggregateRequest(
      metrics = aggregateDataTypes,
      timeRangeFilter = timeRangeFilter,
      dataOriginFilter = dataOriginFilter
    )
    val aggregateData = healthConnectClient.aggregate(aggregateRequest)
    val heartRateData = readData<HeartRateRecord>(timeRangeFilter, dataOriginFilter)

    return ExerciseSessionData(
      uid = uid,
      totalActiveTime = aggregateData[ExerciseSessionRecord.EXERCISE_DURATION_TOTAL],
      totalSteps = aggregateData[StepsRecord.COUNT_TOTAL],
      totalEnergyBurned = aggregateData[TotalCaloriesBurnedRecord.ENERGY_TOTAL],
      minHeartRate = aggregateData[HeartRateRecord.BPM_MIN],
      maxHeartRate = aggregateData[HeartRateRecord.BPM_MAX],
      avgHeartRate = aggregateData[HeartRateRecord.BPM_AVG],
      heartRateSeries = heartRateData,
    )
  }

Exécutons à présent l'application pour vérifier si vous pouvez voir le poids moyen sur l'écran Record weight (Enregistrer le poids). Vous pouvez également consulter les données détaillées d'une séance d'exercice en ouvrant l'écran Exercise séances (Séances d'exercice), puis en sélectionnant l'un des enregistrements de séance.

9. Félicitations

Félicitations, vous venez de créer votre première application de santé et de remise en forme intégrée à Santé Connect.

L'application peut déclarer des autorisations et demander l'autorisation des utilisateurs pour les types de données qu'elle utilise. Elle peut également lire et écrire des données dans le stockage de données Santé Connect. Vous avez également appris à utiliser la boîte à outils Santé Connect pour faciliter le développement de votre application en créant des données fictives dans l'espace de stockage des données Santé Connect.

Vous connaissez maintenant les principales étapes nécessaires pour intégrer votre application de santé et de remise en forme à l'écosystème Santé Connect.

Complément d'informations

• Site pour les développeurs Santé Connect
• Règlement Santé Connect
• Consignes pour les développeurs UX Santé Connect
• Boîte à outils Santé Connect
• Kotlin
• Android Jetpack
• Android Jetpack Compose
• Android Jetpack – ViewModel