Développer des expériences de données vitales avec Santé Connect

Si vous souhaitez créer une application qui gère les constantes de l'utilisateur, vous pouvez utiliser Santé Connect pour effectuer les opérations suivantes :

• Lire les données des constantes (tension artérielle, fréquence cardiaque et température corporelle, par exemple) à partir d'autres applications
• Écrire les données des constantes enregistrées par votre application ou vos appareils connectés
• Surveiller les tendances et fournir des insights sur la santé en fonction des données des constantes

Ce guide explique comment utiliser les types de données des constantes, en abordant les autorisations, les workflows de lecture et d'écriture, ainsi que les bonnes pratiques.

Présentation : Créer un outil complet de suivi des constantes

Vous pouvez créer une expérience complète de suivi des constantes à l'aide de Santé Connect en procédant comme suit :

• Demander les autorisations appropriées pour les types de données des constantes.
• Écrire les données des constantes à l'aide d'enregistrements tels que BloodPressureRecord, HeartRateRecord et d'autres enregistrements de constantes.
• Lire les données des constantes pour les afficher, les analyser ou les synchroniser.
• Utiliser le traitement par lot pour une écriture et une lecture efficaces des données.

Ce workflow permet l'interopérabilité avec d'autres applications Santé Connect et vérifie l'accès aux données contrôlé par l'utilisateur.

Avant de commencer

Avant d'implémenter des fonctionnalités liées aux constantes :

• Intégrez Santé Connect à l'aide de la dépendance appropriée.
• Créez une instance HealthConnectClient.
• Vérifiez que votre application implémente des flux d'autorisations d'exécution basés sur les autorisations de santé.

Concepts clés

Les données des constantes dans Santé Connect sont représentées par différents types d'enregistrements, chacun correspondant à une mesure physiologique spécifique. Contrairement aux séances d'entraînement, les constantes sont souvent enregistrées sous forme de données ponctuelles ou basées sur des intervalles.

Types de données des constantes

Les données des constantes sont représentées par des types d'enregistrements individuels. Voici quelques types courants :

• BloodPressureRecord: représente une seule mesure de la tension artérielle, y compris la pression systolique et diastolique, ainsi que la position du corps.
• HeartRateRecord: représente une série de mesures de la fréquence cardiaque.
• RestingHeartRateRecord: représente une seule mesure de la fréquence cardiaque au repos.
• BodyTemperatureRecord: représente une seule mesure de la température corporelle, y compris le lieu de la mesure.
• BloodGlucoseRecord: représente une seule mesure de la glycémie, y compris la relation avec le repas et la source de l'échantillon.
• OxygenSaturationRecord: représente une seule mesure de la saturation en oxygène dans le sang.
• RespiratoryRateRecord: représente une seule mesure de la fréquence respiratoire.

Pour obtenir la liste complète des types de données, consultez Types de données Santé Connect.

Considérations relatives au développement

Les données des constantes peuvent être sensibles, et les applications peuvent avoir besoin d'écrire des données en réponse aux mesures des capteurs ou aux entrées de l'utilisateur, ou de synchroniser des données à partir d'un backend. Les autorisations sont essentielles pour gérer les données des constantes.

Autorisations

Votre application doit demander les autorisations Santé Connect appropriées avant de lire ou d'écrire des données des constantes. Les autorisations courantes pour les constantes incluent la tension artérielle, la fréquence cardiaque, la température corporelle, la glycémie, la saturation en oxygène et la fréquence respiratoire. et vous devriez pouvoir :

• Tension artérielle : autorisations de lecture et d'écriture pour BloodPressureRecord.
• Fréquence cardiaque : autorisations de lecture et d'écriture pour HeartRateRecord.
• Fréquence cardiaque au repos : autorisations de lecture et d'écriture pour RestingHeartRateRecord.
• Température corporelle : autorisations de lecture et d'écriture pour BodyTemperatureRecord.
• Glycémie : autorisations de lecture et d'écriture pour BloodGlucoseRecord.
• Saturation en oxygène : autorisations de lecture et d'écriture pour OxygenSaturationRecord.
• Fréquence respiratoire : autorisations de lecture et d'écriture pour RespiratoryRateRecord.

L'exemple suivant montre comment demander des autorisations pour la tension artérielle, la fréquence cardiaque et la température corporelle :

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(BloodPressureRecord::class),
  HealthPermission.getWritePermission(BloodPressureRecord::class),
  HealthPermission.getReadPermission(HeartRateRecord::class),
  HealthPermission.getWritePermission(HeartRateRecord::class),
  HealthPermission.getReadPermission(BodyTemperatureRecord::class),
  HealthPermission.getWritePermission(BodyTemperatureRecord::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 les autorisations chaque fois avant de les utiliser et gérer les scénarios dans lesquels l'autorisation est perdue.

Pour demander des autorisations, appelez la fonction checkPermissionsAndRun :

if (!granted.containsAll(PERMISSIONS)) {
    requestPermissions.launch(PERMISSIONS)
    // Check if required permissions are not granted, and return
  }
// Permissions already granted; proceed with inserting or reading data

Si vous n'avez besoin de demander des autorisations que pour un seul type de données, tel que la tension artérielle, n'incluez que ce type de données dans votre ensemble d'autorisations :

L'accès à la tension artérielle est protégé par les autorisations suivantes :

• android.permission.health.READ_BLOOD_PRESSURE
• android.permission.health.WRITE_BLOOD_PRESSURE

Pour ajouter la fonctionnalité de tension artérielle à votre application, commencez par demander des autorisations pour le type de données BloodPressureRecord.

Voici l'autorisation que vous devez déclarer pour pouvoir écrire la tension artérielle :

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

Pour lire la tension artérielle, vous devez demander les autorisations suivantes :

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

Écrire des données des constantes

Cette section explique comment écrire des données des constantes dans Santé Connect. Les données des constantes sont généralement écrites sous forme d'enregistrements individuels. Si vous écrivez plusieurs enregistrements à la fois, par exemple lors d'une synchronisation à partir d'un capteur ou d'un backend, utilisez le traitement par lot.

Exemple d'écriture d'un BloodPressureRecord :

suspend fun writeBloodPressureRecord(healthConnectClient: HealthConnectClient) {
    val record = BloodPressureRecord(
        time = Instant.now(),
        zoneOffset = ZoneOffset.UTC,
        systolic = Pressure.millimetersOfMercury(120.0),
        diastolic = Pressure.millimetersOfMercury(80.0),
        bodyPosition = BloodPressureRecord.BODY_POSITION_SITTING_DOWN,
        measurementLocation = BloodPressureRecord.MEASUREMENT_LOCATION_LEFT_WRIST
    )
    healthConnectClient.insertRecords(listOf(record))
}

Écriture par lot

Si votre application doit écrire plusieurs points de données, par exemple lors de la synchronisation de données à partir d'un appareil connecté ou d'un service de backend, vous devez regrouper les écritures par lot pour améliorer l'efficacité et réduire la consommation de batterie. Santé Connect peut gérer jusqu'à 1 000 enregistrements dans une seule requête d'écriture.

Le code suivant montre comment écrire plusieurs enregistrements à la fois par lot :

suspend fun writeBatchRecords(healthConnectClient: HealthConnectClient) {
    val bloodPressureRecord = BloodPressureRecord(
        time = Instant.now(),
        zoneOffset = ZoneOffset.UTC,
        systolic = Pressure.millimetersOfMercury(120.0),
        diastolic = Pressure.millimetersOfMercury(80.0),
        bodyPosition = BloodPressureRecord.BODY_POSITION_SITTING_DOWN,
        measurementLocation = BloodPressureRecord.MEASUREMENT_LOCATION_LEFT_WRIST
    )
    val heartRateRecord = HeartRateRecord(
        startTime = Instant.now().minusSeconds(60),
        startZoneOffset = ZoneOffset.UTC,
        endTime = Instant.now(),
        endZoneOffset = ZoneOffset.UTC,
        samples = listOf(HeartRateRecord.Sample(time = Instant.now().minusSeconds(30), beatsPerMinute = 80))
    )
    healthConnectClient.insertRecords(listOf(bloodPressureRecord, heartRateRecord))
}

Lire des données des constantes

Les applications peuvent lire les données des constantes pour afficher les mesures, analyser les tendances ou synchroniser les données avec un serveur externe. Pour lire les constantes, utilisez un ReadRecordsRequest avec le type d'enregistrement spécifique et filtrez par plage de temps.

Exemple de lecture des données BloodPressureRecord :

suspend fun readBloodPressureRecords(
    healthConnectClient: HealthConnectClient,
    startTime: Instant,
    endTime: Instant
) {
    val response = healthConnectClient.readRecords(
        ReadRecordsRequest(
            recordType = BloodPressureRecord::class,
            timeRangeFilter = TimeRangeFilter.between(startTime, endTime)
        )
    )

    for (record in response.records) {
        // Process each blood pressure record
        val systolic = record.systolic
        val diastolic = record.diastolic
    }
}

Si vous devez synchroniser les données des constantes avec un serveur backend ou maintenir le datastore de votre application à jour avec Santé Connect, utilisez ChangeLogs. Cela vous permet de récupérer une liste d'enregistrements insérés, mis à jour ou supprimés depuis un moment précis, ce qui est plus efficace que de suivre manuellement les modifications ou de lire toutes les données de manière répétée. Pour en savoir plus, consultez Synchroniser des données avec Santé Connect.

Bonnes pratiques

Suivez ces consignes pour améliorer la fiabilité des données et l'expérience utilisateur :

• Fréquence d'écriture et traitement par lot : pour réduire la surcharge d'entrée/sortie et préserver l'autonomie de la batterie, regroupez les points de données dans un seul insertRecords appel avec des lots de 1 000 enregistrements maximum, plutôt que d'écrire chaque point individuellement.
  • Suivi en direct : pour les mises à jour fréquentes des capteurs (comme les moniteurs de glycémie en continu ou les cardiofréquencemètres), écrivez les données par lot à des intervalles allant jusqu'à 15 minutes pour équilibrer les mises à jour en temps réel et l'efficacité de la batterie.
  • Synchronisation en arrière-plan : utilisez WorkManager pour les écritures différées, telles que la synchronisation des données à partir d'un appareil associé ou d'un service de backend. Visez un intervalle de 15 minutes pour les écritures par lot.

• Évitez d'écrire des données en double : utilisez des ID client Lorsque vous créez des enregistrements, définissez un metadata.clientRecordId. Santé Connect l'utilise pour identifier les enregistrements uniques. Si vous tentez d'écrire un enregistrement avec un clientRecordId qui existe déjà, Santé Connect ignore le doublon ou met à jour l'enregistrement existant au lieu d'en créer un. La définition d'un metadata.clientRecordId est le moyen le plus efficace d'éviter les doublons lors des nouvelles tentatives de synchronisation ou des réinstallations d'applications.

  val record = BloodPressureRecord(
      time = Instant.now(),
      zoneOffset = ZoneOffset.UTC,
      systolic = Pressure.millimetersOfMercury(120.0),
      diastolic = Pressure.millimetersOfMercury(80.0),
      bodyPosition = BloodPressureRecord.BODY_POSITION_SITTING_DOWN,
      measurementLocation = BloodPressureRecord.MEASUREMENT_LOCATION_LEFT_WRIST,
      metadata = Metadata(
          // Use a unique ID from your own database
          clientRecordId = "bp_20240101_user123"
      )
  )

• Vérifiez les données existantes : avant de synchroniser les données, interrogez Santé Connect pour obtenir les enregistrements dans la plage de temps de synchronisation afin de voir si les données de votre application existent déjà, afin d'éviter les doublons ou l'écrasement de données plus récentes.

• Fournissez des justifications claires pour l'autorisation : utilisez le flux Permission.createIntent pour expliquer pourquoi votre application a besoin d'accéder aux données de santé, par exemple "Pour surveiller les tendances de votre tension artérielle et fournir des insights".

• Alignez les codes temporels sur les mesures : vérifiez que les codes temporels des enregistrements reflètent précisément le moment où les mesures ont été prises. Pour les données d'intervalle telles que HeartRateRecord, vérifiez que startTime et endTime sont corrects.

Tests

Pour vérifier l'exactitude des données et offrir une expérience utilisateur de qualité, suivez ces stratégies de test et consultez la documentation officielle Tester les principaux cas d'utilisation.

Outils de validation

• Boîte à outils Santé Connect: utilisez cette application associée pour inspecter manuellement les enregistrements, supprimer les données de test et simuler des modifications dans la base de données. Il s'agit du meilleur moyen de vérifier que vos enregistrements sont stockés correctement.
• Tests unitaires avec FakeHealthConnectClient: utilisez la bibliothèque de test pour vérifier comment votre application gère les cas extrêmes, tels que la révocation d'autorisation ou les exceptions d'API sans avoir besoin d'un appareil physique.

Checklist pour la qualité

Architecture type

Une implémentation des constantes inclut généralement les éléments suivants :

Dépannage

Étapes de débogage courantes