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

Si vous souhaitez créer une application qui gère les constantes vitales des utilisateurs, vous pouvez utiliser Santé Connect pour effectuer les actions suivantes :

• Lire les données vitales telles que la pression artérielle, la fréquence cardiaque et la température corporelle provenant d'autres applications
• Écrire des données vitales enregistrées par votre application ou vos appareils connectés
• Surveiller les tendances et fournir des informations sur la santé en fonction des données vitales

Ce guide explique comment utiliser les types de données de signes vitaux, y compris les autorisations, les workflows de lecture et d'écriture, et les bonnes pratiques.

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

Vous pouvez créer une expérience complète de suivi des signes vitaux à l'aide de Santé Connect en suivant ces étapes clés :

• Demander les autorisations appropriées pour les types de données de constantes vitales.
• Écrire des données vitales à l'aide d'enregistrements tels que BloodPressureRecord, HeartRateRecord et d'autres enregistrements de données vitales.
• Lecture des données vitales pour l'affichage, l'analyse ou la synchronisation.
• Utiliser le traitement par lot pour lire et écrire des données de manière efficace.

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 les fonctionnalités relatives aux signaux vitaux :

• 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'autorisation d'exécution basés sur les autorisations de santé.

Concepts clés

Dans Santé Connect, les données vitales 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 données vitales sont souvent enregistrées sous forme de données ponctuelles ou basées sur des intervalles.

Types de données Vitals

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

• BloodPressureRecord : représente une seule mesure de la pression 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 mesure unique de la fréquence cardiaque au repos.
• BodyTemperatureRecord : représente une seule mesure de température corporelle, y compris le lieu de la mesure.
• BloodGlucoseRecord : représente une seule lecture de 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 mesure unique 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 vitales peuvent être sensibles. Les applications peuvent avoir besoin d'écrire des données en réponse à des mesures de capteurs ou à des saisies utilisateur, ou de synchroniser des données à partir d'un backend. Les autorisations sont essentielles pour gérer les données de signes vitaux.

Autorisations

Votre application doit demander les autorisations Santé Connect appropriées avant de lire ou d'écrire des données vitales. Les autorisations courantes pour les constantes incluent la pression 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 pression 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 une 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, comme la pression 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 mesure de la pression 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 de signes vitaux

Cette section explique comment écrire des données vitales dans Santé Connect. Les données vitales 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 de rédaction 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 lots

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

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

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 les données de signes vitaux

Les applications peuvent lire les données vitales pour afficher les mesures, analyser les tendances ou synchroniser les données avec un serveur externe. Pour lire les signes vitaux, 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 vitales 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 des 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 à plusieurs reprises. 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 regroupement par lot : pour réduire les frais généraux d'entrée/sortie et préserver l'autonomie de la batterie, regroupez les points de données dans un seul appel insertRecords 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 capteurs de glycémie ou les cardiofréquencemètres continus), écrivez les données par lots à 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, comme 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 lots.

• É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 utilise cette valeur pour identifier les enregistrements uniques. Si vous tentez d'écrire un enregistrement avec un clientRecordId qui existe déjà, Santé Connect ignorera le doublon ou mettra à jour l'enregistrement existant au lieu d'en créer un. Définir 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. Vous pourrez ainsi voir si les données de votre application existent déjà, ce qui vous évitera de créer des doublons ou d'écraser des données plus récentes.

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

• 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 haute 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 de la base de données. C'est le 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, comme la révocation d'autorisations ou les exceptions d'API, sans avoir besoin d'un appareil physique.

Checklist pour la qualité

Architecture typique

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

Dépannage

Étapes de débogage courantes

• Vérifier l'état de l'autorisation : appelez toujours getPermissionStatus() avant de tenter une opération de lecture ou d'écriture. Les utilisateurs peuvent révoquer les autorisations dans les paramètres système à tout moment.