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

Écrire des données médicales
Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Ce guide est compatible avec Santé Connect version 1.1.0-beta02.

Pour écrire des données médicales à l'aide d'un dossier médical personnel (DMP) dans Santé Connect, procédez comme suit:

Vérifier la disponibilité des fonctionnalités
Demander des autorisations d'écriture
Créer une source de données (MedicalDataSource)
Écrire une ressource médicale (MedicalResource)

Disponibilité de la fonctionnalité

Pour déterminer si l'appareil d'un utilisateur est compatible avec le PHR sur Santé Connect, vérifiez la disponibilité de FEATURE_PERSONAL_HEALTH_RECORD sur le client:

if (healthConnectClient
     .features
     .getFeatureStatus(
       HealthConnectFeatures.FEATURE_PERSONAL_HEALTH_RECORD
     ) == HealthConnectFeatures.FEATURE_STATUS_AVAILABLE) {

  // Feature is available
} else {
  // Feature isn't available
}

Pour en savoir plus, consultez Vérifier la disponibilité des fonctionnalités.

Autorisations requises

L'écriture de données médicales est protégée par l'autorisation suivante:

android.permission.health.WRITE_MEDICAL_DATA

Déclarez ces autorisations dans la Play Console pour votre application, ainsi que dans le fichier manifeste de votre application:

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

Vous êtes responsable de déclarer toutes les autorisations appropriées que vous prévoyez d'utiliser dans vos appareils et applications. Vous devez également vérifier que chaque autorisation a été accordée par l'utilisateur avant utilisation.

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
import androidx.health.connect.client.permission.HealthPermission.Companion.PERMISSION_WRITE_MEDICAL_DATA

val PERMISSIONS =
    setOf(
       PERMISSION_WRITE_MEDICAL_DATA
)

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 gérer les cas de perte d'autorisations.

Sources de données

Dans Santé Connect, un MedicalDataSource représente une source de données destinée à l'utilisateur, comme une organisation de santé, un hôpital ou une API.

Les dossiers médicaux stockés dans Santé Connect sont organisés dans un MedicalDataSource. Cela permet de séparer les dossiers médicaux d'une même personne provenant de différentes sources, telles que des API ou des systèmes de santé.

Si tous les enregistrements proviennent de la même source, une application d'écriture n'a besoin de créer qu'un seul MedicalDataSource. Si les enregistrements proviennent de plusieurs sources, une application peut toujours créer un seul MedicalDataSource si ces données sont conciliées et que tous les enregistrements présentent une combinaison unique de type de ressource FHIR et d'ID de ressource FHIR. Sinon, un MedicalDataSource doit être créé pour chaque source de données.

Tous les dossiers médicaux doivent être associés à un MedicalDataSource. Celui-ci doit donc être créé avant d'écrire les ressources.

Propriétés de MedicalDataSource:

Nom à afficher (obligatoire) : nom à afficher pour l'utilisateur de la source de données, identifié de manière unique par application d'écriture.
URI de base FHIR (obligatoire) : pour les données provenant d'un serveur FHIR, il doit s'agir de l'URL de base FHIR (par exemple, https://example.com/fhir/). Plusieurs sources de données peuvent être associées à la même URL de base FHIR.

Si les données sont générées par une application sans URL FHIR, il doit s'agir d'un URI unique et compréhensible défini par l'application (par exemple, myapp://..) qui pointe vers la source des données.

Par exemple, si une application cliente est compatible avec les liens profonds, ces liens peuvent être utilisés comme URI de base FHIR. La longueur maximale de l'URI est de 2 000 caractères.
Nom du package (renseigné automatiquement) : application écrivant les données.
Version FHIR (obligatoire) : version FHIR. Doit être une version compatible.

Créer un enregistrement MedicalDataSource

Créez un enregistrement pour chaque organisation ou entité de santé à laquelle votre application est associée.

// Create a `MedicalDataSource`
// Note that `displayName` must be unique across `MedicalDataSource`s
// Each `MedicalDataSource` is assigned an `id` by the system on creation
val medicalDataSource: MedicalDataSource =
    healthConnectClient.createMedicalDataSource(
        CreateMedicalDataSourceRequest(
            fhirBaseUri = Uri.parse("https://fhir.com/oauth/api/FHIR/R4/"),
            displayName = "Test Data Source",
            fhirVersion = FhirVersion(4, 0, 1)
        )
    )

Supprimer un enregistrement MedicalDataSource

L'exemple précédent renvoie un id par le système lors de la création. Si vous devez supprimer l'enregistrement MedicalDataSource, référencez le même id:

// Delete the `MedicalDataSource` that has the specified `id`
healthConnectClient.deleteMedicalDataSourceWithData(medicalDataSource.id)

Ressources médicales

Un MedicalResource dans Santé Connect représente une ressource FHIR (qui contient un dossier médical), ainsi que des métadonnées.

Propriétés de MedicalResource:

DataSourceId (obligatoire) : source de données telle que décrite pour un MedicalDataSource.
Version FHIR (obligatoire) : version FHIR. Doit s'agir d'une version compatible.
Ressource FHIR (obligatoire) Instance de ressource FHIR encodée au format JSON.
Type de ressource médicale (renseigné automatiquement) : catégorie visible par l'utilisateur de la ressource, mappée sur les autorisations visibles par l'utilisateur.

Préparer des ressources FHIR au format JSON

Avant d'écrire des ressources médicales dans Santé Connect, préparez vos enregistrements de ressources FHIR au format JSON. Stockez chaque fichier JSON dans sa propre variable pour l'insérer en tant que ressource médicale.

Si vous avez besoin d'aide concernant le format JSON FHIR, consultez les exemples de données fournis par l'organisation HL7.

Insérer ou mettre à jour des enregistrements MedicalResource

Utilisez UpsertMedicalResourceRequest pour insérer des enregistrements MedicalResource ou mettre à jour des enregistrements MedicalResource existants pour un MedicalDataSource:

// Insert `MedicalResource`s into the `MedicalDataSource`
val medicalResources: List<MedicalResource> =
    healthConnectClient.upsertMedicalResources(
        listOf(
            UpsertMedicalResourceRequest(
                medicalDataSource.id,
                medicalDataSource.fhirVersion,
                medicationJsonToInsert // a valid FHIR json string
            )
        )
    )

// Update `MedicalResource`s in the `MedicalDataSource`
val updatedMedicalResources: List<MedicalResource> =
    healthConnectClient.upsertMedicalResources(
        listOf(
            UpsertMedicalResourceRequest(
                medicalDataSource.id,
                medicalDataSource.fhirVersion,
                // a valid FHIR json string
                // if this resource has the same type and ID as in `medicationJsonToInsert`,
                // this `upsertMedicalResources()` call will update the previously inserted
                // `MedicalResource`
                updatedMedicationJsonToInsert
            )
        )
    )

Exemple de ressource FHIR

Dans l'exemple précédent, la variable medicationJsonToInsert représentait une chaîne JSON FHIR valide.

Voici un exemple de ce à quoi pourrait ressembler ce JSON, en utilisant AllergyIntolerance comme type de ressource FHIR, qui serait mappé sur le type de ressource médicale FHIR_RESOURCE_TYPE_ALLERGY_INTOLERANCE dans le PHR:

{
  "resourceType": "AllergyIntolerance",
  "id": "allergyintolerance-1",
  "criticality": "high",
  "code": {
    "coding": [
      {
        "system": "http://snomed.info/sct",
        "code": "91936005",
        "display": "Penicillin allergy"
      }
    ],
    "text": "Penicillin allergy"
  },
  "recordedDate": "2020-10-09T14:58:00+00:00",
   "asserter": {
    "reference": "Patient/patient-1"
  },
  "lastOccurrence": "2020-10-09",
  "patient": {
    "reference": "Patient/patient-1",
    "display": "B., Alex"
  }
  ...
}

Supprimer un enregistrement MedicalResource

Les enregistrements MedicalResource peuvent être supprimés par ID:

// Delete `MedicalResource`s matching the specified `dataSourceId`, `type` and `fhirResourceId`
healthConnectClient.deleteMedicalResources(
    medicalResources.map { medicalResource: MedicalResource ->
        MedicalResourceId(
            dataSourceId = medicalDataSource.id,
            fhirResourceType = medicalResource.id.fhirResourceType,
            fhirResourceId = medicalResource.id.fhirResourceId
        )
    }
)

Ils peuvent également être supprimés par medicalResourceType:

// Delete all `MedicalResource`s that are in any pair of provided `dataSourceIds` and
// `medicalResourceTypes`
healthConnectClient.deleteMedicalResources(
    DeleteMedicalResourcesRequest(
        dataSourceIds = setOf(medicalDataSource.id),
        medicalResourceTypes = setOf(MEDICAL_RESOURCE_TYPE_MEDICATIONS)
    )
)