Gérer les ressources FHIR à l'aide de la bibliothèque de moteurs FHIR

1. Avant de commencer

Ce que vous allez faire

Dans cet atelier de programmation, vous allez créer une application Android à l'aide de la bibliothèque FHIR Engine. Votre application utilisera la bibliothèque FHIR Engine pour télécharger les ressources FHIR à partir d'un serveur FHIR et importer toutes les modifications locales sur le serveur.

Points abordés

Créer un serveur HAPI FHIR local à l'aide de Docker
Intégrer la bibliothèque FHIR Engine à votre application Android
Utiliser l'API Sync pour configurer une tâche ponctuelle ou périodique permettant de télécharger et d'importer des ressources FHIR
Utiliser l'API Search
Utiliser les API d'accès aux données pour créer, lire, mettre à jour et supprimer des ressources FHIR en local

Prérequis

Docker (obtenir Docker)
Une version récente d'Android Studio (version 4.1.2 ou ultérieure)
Un émulateur Android ou un appareil Android physique équipé d'Android 7.0 Nougat ou version ultérieure
Exemple de code
Connaissances de base du développement Android en Kotlin

Si vous n'avez jamais créé d'applications Android, vous pouvez commencer par créer votre première application.

2. Configurer un serveur HAPI FHIR local avec des données de test

HAPI FHIR est un serveur FHIR Open Source populaire. Dans notre atelier de programmation, nous utilisons un serveur HAPI FHIR local auquel l'application Android peut se connecter.

Configurer le serveur HAPI FHIR local

Exécutez la commande suivante dans un terminal pour obtenir la dernière image de HAPI FHIR.
```
docker pull hapiproject/hapi:latest
```
Créez un conteneur HAPI FHIR en utilisant Docker Desktop pour exécuter l'image hapiproject/hapi précédemment téléchargée ou en exécutant la commande suivante :
```
docker run -p 8080:8080 hapiproject/hapi:latest
```
En savoir plus
Inspectez le serveur en ouvrant l'URL http://localhost:8080/ dans un navigateur. L'interface Web HAPI FHIR devrait s'afficher.

Remplir le serveur HAPI FHIR local avec des données de test

Pour tester notre application, nous avons besoin de données de test sur le serveur. Nous utiliserons des données synthétiques générées par Synthea.

Nous devons d'abord télécharger des exemples de données depuis synthea-samples. Téléchargez et extrayez synthea_sample_data_fhir_r4_sep2019.zip. L'exemple de données décompressé comporte de nombreux fichiers .json, chacun étant un bundle de transactions pour un patient individuel.

Nous allons importer des données de test pour trois patients sur le serveur HAPI FHIR local. Exécutez la commande suivante dans le répertoire contenant les fichiers JSON.

curl -X POST -H "Content-Type: application/json" -d @./Aaron697_Brekke496_2fa15bc7-8866-461a-9000-f739e425860a.json http://localhost:8080/fhir/
curl -X POST -H "Content-Type: application/json" -d @./Aaron697_Stiedemann542_41166989-975d-4d17-b9de-17f94cb3eec1.json http://localhost:8080/fhir/
curl -X POST -H "Content-Type: application/json" -d @./Abby752_Kuvalis369_2b083021-e93f-4991-bf49-fd4f20060ef8.json http://localhost:8080/fhir/

Pour importer des données de test pour tous les patients sur le serveur, exécutez
```
for f in *.json; do curl -X POST -H "Content-Type: application/json" -d @$f http://localhost:8080/fhir/ ; done
```
Toutefois, cette opération peut prendre beaucoup de temps et n'est pas nécessaire pour l'atelier de programmation.
Vérifiez que les données de test sont disponibles sur le serveur en ouvrant l'URL http://localhost:8080/fhir/Patient/ dans un navigateur. Le texte HTTP 200 OK et la section Response Body de la page contenant les données patient dans un bundle FHIR devraient s'afficher dans les résultats de recherche avec un nombre total.

3. Configurer l'application Android

Télécharger le code

Pour télécharger le code de cet atelier de programmation, clonez le dépôt Android FHIR SDK : git clone https://github.com/google/android-fhir.git

Le projet de démarrage de cet atelier de programmation se trouve dans codelabs/engine.

Importer l'application dans Android Studio

Nous allons commencer par importer l'application de départ dans Android Studio.

Ouvrez Android Studio, sélectionnez Import Project (Gradle, Eclipse ADT, etc.) (Importer un projet (Gradle, Eclipse ADT, etc.)), puis choisissez le dossier codelabs/engine/ dans le code source que vous avez téléchargé précédemment.

Écran de démarrage d'Android Studio

Synchroniser votre projet avec les fichiers Gradle

Pour votre confort, les dépendances de la bibliothèque FHIR Engine ont déjà été ajoutées au projet. Cela vous permet d'intégrer la bibliothèque FHIR Engine dans votre application. Observez les lignes suivantes jusqu'à la fin du fichier app/build.gradle.kts de votre projet :

dependencies {
    // ...

    implementation("com.google.android.fhir:engine:1.1.0")
}

Pour vous assurer que toutes les dépendances sont disponibles pour votre application, vous devez synchroniser votre projet avec les fichiers Gradle à ce stade.

Sélectionnez Sync Project with Gradle Files (Synchroniser le projet avec les fichiers Gradle) Bouton de synchronisation Gradle dans la barre d'outils Android Studio. Vous pouvez également exécuter à nouveau l'application pour vérifier que les dépendances fonctionnent correctement.

Exécuter l'application de démarrage

Maintenant que vous avez importé le projet dans Android Studio, vous êtes prêt à exécuter l'application pour la première fois.

Démarrez l'émulateur Android Studio, puis cliquez sur Exécuter ( Bouton d'exécution ) dans la barre d'outils Android Studio.

Application Hello World

4. Créer une instance FHIR Engine

Pour intégrer FHIR Engine à votre application Android, vous devez utiliser la bibliothèque FHIR Engine et lancer une instance de FHIR Engine. Les étapes décrites ci-dessous vous guideront tout au long du processus.

Accédez à votre classe Application, qui dans cet exemple est FhirApplication.kt, située dans app/src/main/java/com/google/android/fhir/codelabs/engine.
Dans la méthode onCreate(), ajoutez le code suivant pour initialiser FHIR Engine :
```
  FhirEngineProvider.init(
      FhirEngineConfiguration(
        enableEncryptionIfSupported = true,
        RECREATE_AT_OPEN,
        ServerConfiguration(
          baseUrl = "http://10.0.2.2:8080/fhir/",
          httpLogger =
            HttpLogger(
              HttpLogger.Configuration(
                if (BuildConfig.DEBUG) HttpLogger.Level.BODY else HttpLogger.Level.BASIC,
              ),
            ) {
              Log.d("App-HttpLog", it)
            },
        ),
      ),
  )
```
Remarques :
- enableEncryptionIfSupported : active le chiffrement des données si l'appareil le prend en charge.
- RECREATE_AT_OPEN : détermine la stratégie d'erreur de base de données. Dans ce cas, elle recrée la base de données si une erreur se produit lors de l'ouverture.
- baseUrl dans ServerConfiguration : il s'agit de l'URL de base du serveur FHIR. L'adresse IP 10.0.2.2 fournie est spécialement réservée à localhost, accessible depuis l'émulateur Android. En savoir plus
Dans la classe FhirApplication, ajoutez la ligne suivante pour instancier le FHIR Engine de manière différée :
```
  private val fhirEngine: FhirEngine by
      lazy { FhirEngineProvider.getInstance(this) }
```
Cela garantit que l'instance FhirEngine n'est créée que lorsqu'elle est consultée pour la première fois, et non immédiatement au démarrage de l'application.
Ajoutez la méthode pratique suivante dans la classe FhirApplication pour faciliter l'accès dans toute votre application :
```
companion object {
    fun fhirEngine(context: Context) =
        (context.applicationContext as FhirApplication).fhirEngine
}
```
Cette méthode statique vous permet de récupérer l'instance FHIR Engine depuis n'importe quel endroit de l'application à l'aide du contexte.

5. Synchroniser des données avec un serveur FHIR

Créez un cours DownloadWorkManagerImpl.kt. Dans cette classe, vous allez définir la façon dont l'application récupère la ressource suivante de la liste à télécharger :

  class DownloadWorkManagerImpl : DownloadWorkManager {
    private val urls = LinkedList(listOf("Patient"))

    override suspend fun getNextRequest(): DownloadRequest? {
      val url = urls.poll() ?: return null
      return DownloadRequest.of(url)
    }

    override suspend fun getSummaryRequestUrls() = mapOf<ResourceType, String>()

    override suspend fun processResponse(response: Resource): Collection<Resource> {
      var bundleCollection: Collection<Resource> = mutableListOf()
      if (response is Bundle && response.type == Bundle.BundleType.SEARCHSET) {
        bundleCollection = response.entry.map { it.resource }
      }
      return bundleCollection
    }
  }

Cette classe dispose d'une file d'attente des types de ressources qu'elle souhaite télécharger. Il traite les réponses et extrait les ressources du bundle renvoyé, qui sont enregistrées dans la base de données locale.

Créez une classe AppFhirSyncWorker.kt. Cette classe définit la façon dont l'application se synchronise avec le serveur FHIR distant à l'aide d'un worker en arrière-plan.

class AppFhirSyncWorker(appContext: Context, workerParams: WorkerParameters) :
  FhirSyncWorker(appContext, workerParams) {

  override fun getDownloadWorkManager() = DownloadWorkManagerImpl()

  override fun getConflictResolver() = AcceptLocalConflictResolver

  override fun getFhirEngine() = FhirApplication.fhirEngine(applicationContext)

  override fun getUploadStrategy() =
    UploadStrategy.forBundleRequest(
      methodForCreate = HttpCreateMethod.PUT,
      methodForUpdate = HttpUpdateMethod.PATCH,
      squash = true,
      bundleSize = 500,
    )
}

Ici, nous avons défini le gestionnaire de téléchargement, le résolveur de conflits et l'instance de moteur FHIR à utiliser pour la synchronisation.

Dans votre ViewModel, PatientListViewModel.kt, vous allez configurer un mécanisme de synchronisation unique. Localisez et ajoutez ce code à la fonction triggerOneTimeSync() :
```
viewModelScope.launch {
      Sync.oneTimeSync<AppFhirSyncWorker>(getApplication())
        .shareIn(this, SharingStarted.Eagerly, 10)
        .collect { _pollState.emit(it) }
    }
```
Cette coroutine lance une synchronisation unique avec le serveur FHIR à l'aide de AppFhirSyncWorker que nous avons défini précédemment. Elle met ensuite à jour l'UI en fonction de l'état du processus de synchronisation.
Dans le fichier PatientListFragment.kt, mettez à jour le corps de la fonction handleSyncJobStatus :
```
when (syncJobStatus) {
    is SyncJobStatus.Finished -> {
        Toast.makeText(requireContext(), "Sync Finished", Toast.LENGTH_SHORT).show()
        viewModel.searchPatientsByName("")
    }
    else -> {}
}
```
Ici, une fois le processus de synchronisation terminé, un message toast s'affiche pour en informer l'utilisateur. L'application affiche ensuite tous les patients en appelant une recherche avec un nom vide.

Maintenant que tout est configuré, exécutez votre application. Cliquez sur le bouton Sync dans le menu. Si tout fonctionne correctement, les patients de votre serveur FHIR local devraient être téléchargés et affichés dans l'application.

Liste des patients

6. Modifier et importer des données patient

Dans cette section, nous vous guiderons tout au long du processus de modification des données des patients en fonction de critères spécifiques et d'importation des données mises à jour sur votre serveur FHIR. Plus précisément, nous allons inverser les villes des adresses des patients résidant dans Wakefield et Taunton.

Étape 1 : Configurer la logique de modification dans PatientListViewModel

Le code de cette section est ajouté à la fonction triggerUpdate dans PatientListViewModel.

Accéder au FHIR Engine : commencez par obtenir une référence au FHIR Engine dans PatientListViewModel.kt.
```
viewModelScope.launch {
   val fhirEngine = FhirApplication.fhirEngine(getApplication())
```
Ce code lance une coroutine dans le champ d'application du ViewModel et initialise le moteur FHIR.
Rechercher des patients de Wakefield : utilisez le moteur FHIR pour rechercher les patients dont la ville de résidence est Wakefield.
```
val patientsFromWakefield =
     fhirEngine.search<Patient> {
       filter(
         Patient.ADDRESS_CITY,
         {
           modifier =  StringFilterModifier.MATCHES_EXACTLY
           value = "Wakefield"
         }
       )
     }
```
Ici, nous utilisons la méthode search du moteur FHIR pour filtrer les patients en fonction de la ville de leur adresse. Le résultat sera une liste de patients de Wakefield.

Rechercher des patients de Taunton : de même, recherchez les patients dont la ville de résidence est Taunton.

val patientsFromTaunton =
     fhirEngine.search<Patient> {
       filter(
         Patient.ADDRESS_CITY,
         {
           modifier =  StringFilterModifier.MATCHES_EXACTLY
           value = "Taunton"
         }
       )
     }

Nous avons maintenant deux listes de patients : l'une de Wakefield et l'autre de Taunton.

Modifier les adresses des patients : parcourez chaque patient de la liste patientsFromWakefield, remplacez sa ville par Taunton et mettez à jour les informations dans le moteur FHIR.
```
patientsFromWakefield.forEach {
     it.resource.address.first().city = "Taunton"
     fhirEngine.update(it.resource)
}
```
De même, mettez à jour chaque patient de la liste patientsFromTaunton pour que sa ville devienne Wakefield.
```
patientsFromTaunton.forEach {
     it.resource.address.first().city = "Wakefield"
     fhirEngine.update(it.resource)
}
```
Lancer la synchronisation : après avoir modifié les données localement, déclenchez une synchronisation ponctuelle pour vous assurer que les données sont mises à jour sur le serveur FHIR.
```
triggerOneTimeSync()
}
```
L'accolade fermante } indique la fin de la coroutine lancée au début.

Étape 2 : Tester la fonctionnalité

Test de l'UI : exécutez votre application. Cliquez sur le bouton Update dans le menu. Vous devriez voir les villes des adresses des patients Aaron697 et Abby752 inversées.
Validation du serveur : ouvrez un navigateur et accédez à http://localhost:8080/fhir/Patient/. Vérifiez que la ville de l'adresse des patients Aaron697 et Abby752 est mise à jour sur le serveur FHIR local.

En suivant ces étapes, vous avez implémenté un mécanisme permettant de modifier les données des patients et de synchroniser les modifications avec votre serveur FHIR.

7. Rechercher des patients par nom

La recherche de patients par leur nom peut permettre de récupérer des informations de manière conviviale. Nous allons vous guider dans l'implémentation de cette fonctionnalité dans votre application.

Étape 1 : Mettez à jour la signature de la fonction

Accédez à votre fichier PatientListViewModel.kt et recherchez la fonction nommée searchPatientsByName. Nous allons ajouter du code à cette fonction.

Pour filtrer les résultats en fonction de la requête de nom fournie et émettre les résultats pour que l'UI se mette à jour, incorporez le bloc de code conditionnel suivant :

    viewModelScope.launch {
      val fhirEngine = FhirApplication.fhirEngine(getApplication())
      if (nameQuery.isNotEmpty()) {
        val searchResult = fhirEngine.search<Patient> {
          filter(
            Patient.NAME,
            {
              modifier = StringFilterModifier.CONTAINS
              value = nameQuery
            },
          )
        }
        liveSearchedPatients.value  =  searchResult.map { it.resource }
      }
    }

Ici, si nameQuery n'est pas vide, la fonction de recherche filtrera les résultats pour n'inclure que les patients dont le nom contient la requête spécifiée.

Étape 2 : Tester la nouvelle fonctionnalité de recherche

Relancez l'application : après avoir apporté ces modifications, recompilez et exécutez votre application.
Rechercher des patients : sur l'écran de la liste des patients, utilisez la fonctionnalité de recherche. Vous devriez maintenant pouvoir saisir un nom (ou une partie d'un nom) pour filtrer la liste des patients en conséquence.

Vous avez ainsi amélioré votre application en permettant aux utilisateurs de rechercher efficacement des patients par leur nom. Cela peut améliorer considérablement l'expérience utilisateur et l'efficacité de la récupération des données.

8. Félicitations !

Vous avez utilisé la bibliothèque FHIR Engine pour gérer les ressources FHIR dans votre application :

Utiliser l'API Sync pour synchroniser les ressources FHIR avec un serveur FHIR
Utiliser l'API Data Access pour créer, lire, mettre à jour et supprimer des ressources FHIR locales
Utiliser l'API Search pour rechercher des ressources FHIR locales

Points abordés

Configurer un serveur HAPI FHIR local
Importer des données de test sur le serveur HAPI FHIR local
Créer une application Android à l'aide de la bibliothèque FHIR Engine
Utiliser les API Sync, Data Access et Search dans la bibliothèque FHIR Engine

Étapes suivantes

Explorer la documentation de la bibliothèque FHIR Engine
Découvrir les fonctionnalités avancées de l'API Search
Appliquer la bibliothèque FHIR Engine dans votre propre application Android

En savoir plus

Documentation pour les développeurs FHIR Engine

Gérer les ressources FHIR à l'aide de la bibliothèque de moteurs FHIR Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

1. Avant de commencer

Ce que vous allez faire

Points abordés

Prérequis

2. Configurer un serveur HAPI FHIR local avec des données de test

Configurer le serveur HAPI FHIR local

Remplir le serveur HAPI FHIR local avec des données de test

3. Configurer l'application Android

Télécharger le code

Importer l'application dans Android Studio

Synchroniser votre projet avec les fichiers Gradle

Exécuter l'application de démarrage

4. Créer une instance FHIR Engine

5. Synchroniser des données avec un serveur FHIR

6. Modifier et importer des données patient

Étape 1 : Configurer la logique de modification dans PatientListViewModel

Étape 2 : Tester la fonctionnalité

7. Rechercher des patients par nom

Étape 1 : Mettez à jour la signature de la fonction

Étape 2 : Tester la nouvelle fonctionnalité de recherche

8. Félicitations !

Points abordés

Étapes suivantes

En savoir plus

Gérer les ressources FHIR à l'aide de la bibliothèque de moteurs FHIR