Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

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

1. Avant de commencer

Objectifs de l'atelier

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 des 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 unique ou périodique afin 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 localement

Ce dont vous avez besoin

Docker (obtenir Docker)
Une version récente de Android Studio (4.1.2 ou version ultérieure)
Android Emulator 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. Nous utilisons un serveur HAPI FHIR local dans notre atelier de programmation pour que l'application Android puisse s'y 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 téléchargée précédemment hapiproject/hapi 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 allons utiliser des données synthétiques générées par Synthea.

Nous devons d'abord télécharger des exemples de données à partir de synthea-samples. Téléchargez et extrayez synthea_sample_data_fhir_r4_sep2019.zip. Les exemples de données décompressées contiennent 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 du patient dans un bundle FHIR doivent s'afficher comme résultat de la 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/ohs-foundation/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émarrage dans Android Studio.

Ouvrez Android Studio, sélectionnez Import Project (Gradle, Eclipse ADT, etc.) (Importer un projet (Gradle, Eclipse ADT, etc.)) et 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 plus de commodité, 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 à votre application. Observez les lignes suivantes à 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 ( 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 Run ( 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)
            },
        ),
      ),
  )
```
Notes:
- 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 la 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 fournie 10.0.2.2 est spécialement réservée à l'hôte local, accessible depuis l'émulateur Android. En savoir plus
Dans la classe FhirApplication, ajoutez la ligne suivante pour instancier 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 lors de son premier accès, 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 où dans l'application à l'aide du contexte.

5. Synchroniser les données avec le serveur FHIR

Créez une classe DownloadWorkManagerImpl.kt. Dans cette classe, vous définirez comment l'application récupère la ressource suivante dans 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 comporte une file d'attente de types de ressources qu'elle souhaite télécharger. Elle 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 comment 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 FHIR Engine à utiliser pour la synchronisation.

Dans votre ViewModel, PatientListViewModel.kt, vous allez configurer un mécanisme de synchronisation unique. Recherchez 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 d'AppFhirSyncWorker que nous avons défini précédemment. Elle met ensuite à jour l'interface utilisateur 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 informer l'utilisateur, puis l'application affiche 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 (Synchroniser) 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 allons vous guider tout au long du processus de modification des données patient 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 échanger les villes d'adresse des patients résidant à 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 à FHIR Engine : commencez par obtenir une référence à 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 FHIR Engine.
Rechercher des patients de Wakefield : utilisez FHIR Engine pour rechercher les patients dont la ville d'adresse est Wakefield.
```
val patientsFromWakefield =
     fhirEngine.search<Patient> {
       filter(
         Patient.ADDRESS_CITY,
         {
           modifier =  StringFilterModifier.MATCHES_EXACTLY
           value = "Wakefield"
         }
       )
     }
```
Ici, nous utilisons la méthode search de FHIR Engine pour filtrer les patients en fonction de leur ville d'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 d'adresse est Taunton.

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

Nous disposons maintenant de 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-le à jour dans FHIR Engine.
```
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 soit remplacée par 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 unique pour vous assurer que les données sont mises à jour sur le serveur FHIR.
```
triggerOneTimeSync()
}
```
L'accolade fermante } signifie la fin de la coroutine lancée au début.

Étape 2 : Tester la fonctionnalité

Test de l'interface utilisateur : exécutez votre application. Cliquez sur le bouton Update dans le menu. Les villes d'adresse des patients Aaron697 et Abby752 devraient être inversées.
Vérification du serveur : ouvrez un navigateur et accédez à http://localhost:8080/fhir/Patient/. Vérifiez que la ville d'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 patient et de synchroniser les modifications avec votre serveur FHIR.

7. Rechercher des patients par nom

La recherche de patients par leur nom peut être un moyen convivial de récupérer des informations. Nous allons vous guider tout au long du processus d'implémentation de cette fonctionnalité dans votre application.

Étape 1 : Mettre à 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'interface utilisateur soit mise à jour, intégrez 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 filtre 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

Relancer l'application : après avoir apporté ces modifications, recréez 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.

Une fois ces étapes terminées, vous avez 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 d'accès aux données 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 l'API Sync, l'API d'accès aux données et l'API Search dans la bibliothèque FHIR Engine

Étapes suivantes

Consulter 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

Objectifs de l'atelier

Points abordés

Ce dont vous avez besoin

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 les données avec le 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 : Mettre à 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