Administra recursos de FHIR con la biblioteca de FHIR Engine

1. Antes de comenzar

Qué compilarás

En este codelab, compilarás una app para Android con la biblioteca de FHIR Engine. Tu app usará la biblioteca de FHIR Engine para descargar recursos de FHIR desde un servidor de FHIR y subir los cambios locales al servidor.

Qué aprenderás

Cómo crear un servidor local de HAPI FHIR con Docker
Cómo integrar la biblioteca de FHIR Engine en tu aplicación para Android
Cómo usar la API de Sync para configurar un trabajo único o periódico para descargar y subir recursos de FHIR
Cómo usar la API de Search
Cómo usar las APIs de Data Access para crear, leer, actualizar y borrar recursos de FHIR de forma local

Requisitos

Docker (obtener Docker)
Una versión reciente de Android Studio (v4.1.2 o posterior)
Android Emulator o un dispositivo Android físico que ejecute Android 7.0 Nougat o versiones posteriores
El código de muestra
Conocimientos básicos sobre el desarrollo de Android en Kotlin

Si nunca creaste apps para Android, puedes comenzar por crear tu primera app.

2. Configura un servidor local de HAPI FHIR con datos de prueba

HAPI FHIR es un servidor de FHIR de código abierto popular. Usamos un servidor local de HAPI FHIR en nuestro codelab para que se conecte la app para Android.

Configura el servidor local de HAPI FHIR

Ejecuta el siguiente comando en una terminal para obtener la imagen más reciente de HAPI FHIR.
```
docker pull hapiproject/hapi:latest
```
Crea un contenedor de HAPI FHIR con Docker Desktop para ejecutar la imagen hapiproject/hapi que descargaste anteriormente o ejecuta el siguiente comando:
```
docker run -p 8080:8080 hapiproject/hapi:latest
```
Obtén más información.
Para inspeccionar el servidor, abre la URL http://localhost:8080/ en un navegador. Deberías ver la interfaz web de HAPI FHIR.

Propaga el servidor local de HAPI FHIR con datos de prueba

Para probar nuestra aplicación, necesitaremos algunos datos de prueba en el servidor. Usaremos datos sintéticos generados por Synthea.

Primero, debemos descargar datos de muestra de synthea-samples. Descarga y extrae synthea_sample_data_fhir_r4_sep2019.zip. Los datos de muestra descomprimidos tienen numerosos archivos .json, cada uno de los cuales es un paquete de transacciones para un paciente individual.

Subiremos datos de prueba para tres pacientes al servidor local de HAPI FHIR. Ejecuta el siguiente comando en el directorio que contiene los archivos 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/

Para subir datos de prueba de todos los pacientes al servidor, ejecuta el siguiente comando:
```
for f in *.json; do curl -X POST -H "Content-Type: application/json" -d @$f http://localhost:8080/fhir/ ; done
```
Sin embargo, este proceso puede tardar mucho en completarse y no es necesario para el codelab.
Para verificar que los datos de prueba estén disponibles en el servidor, abre la URL http://localhost:8080/fhir/Patient/ en un navegador. Deberías ver el texto HTTP 200 OK y la sección Response Body de la página que contiene datos del paciente en un paquete FHIR como el resultado de la búsqueda con un recuento de total.

3. Configura la app para Android

Descarga el código

Para descargar el código de este codelab, clona el repositorio del SDK de FHIR para Android: git clone https://github.com/google/android-fhir.git

El proyecto inicial para este codelab se encuentra en codelabs/engine.

Importa la app a Android Studio

Comenzaremos por importar la app de inicio a Android Studio.

Abre Android Studio, selecciona Import Project (Gradle, Eclipse ADT, etc.) y elige la carpeta codelabs/engine/ del código fuente que descargaste antes.

Pantalla de inicio de Android Studio

Sincroniza tu proyecto con archivos de Gradle

Para tu comodidad, las dependencias de la biblioteca de FHIR Engine ya se agregaron al proyecto. Esto te permite integrar la biblioteca de FHIR Engine en tu app. Observa las siguientes líneas hasta el final del archivo app/build.gradle.kts de tu proyecto:

dependencies {
    // ...

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

Para asegurarte de que todas las dependencias estén disponibles para tu app, debes sincronizar tu proyecto con los archivos de Gradle en este punto.

Selecciona Sync Project with Gradle Files ( Botón de sincronización de Gradle ) en la barra de herramientas de Android Studio. También puedes volver a ejecutar la app para verificar que las dependencias funcionen correctamente.

Ejecuta la app de partida

Ahora que importaste el proyecto a Android Studio, puedes ejecutar la app por primera vez.

Inicia el emulador de Android Studio y haz clic en Run ( Botón Ejecutar ) en la barra de herramientas de Android Studio.

App de Hello World

4. Crea una instancia de FHIR Engine

Para incorporar FHIR Engine en tu app para Android, deberás usar la biblioteca de FHIR Engine y, luego, iniciar una instancia de FHIR Engine. Los pasos que se describen a continuación te guiarán a través del proceso.

Navega a tu clase Application, que en este ejemplo es FhirApplication.kt y se encuentra en app/src/main/java/com/google/android/fhir/codelabs/engine.
Dentro del método onCreate(), agrega el siguiente código para inicializar 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)
            },
        ),
      ),
  )
```
Notas:
- enableEncryptionIfSupported: Habilita la encriptación de datos si el dispositivo la admite.
- RECREATE_AT_OPEN: Determina la estrategia de errores de la base de datos. En este caso, se vuelve a crear la base de datos si se produce un error al abrirla.
- baseUrl en ServerConfiguration: Es la URL base del servidor de FHIR. La dirección IP proporcionada 10.0.2.2 está reservada especialmente para localhost, al que se puede acceder desde el emulador de Android. Más información
En la clase FhirApplication, agrega la siguiente línea para crear una instancia de FHIR Engine de forma diferida:
```
  private val fhirEngine: FhirEngine by
      lazy { FhirEngineProvider.getInstance(this) }
```
Esto garantiza que la instancia de FhirEngine solo se cree cuando se acceda a ella por primera vez, no inmediatamente cuando se inicie la app.
Agrega el siguiente método de conveniencia en la clase FhirApplication para facilitar el acceso en toda la aplicación:
```
companion object {
    fun fhirEngine(context: Context) =
        (context.applicationContext as FhirApplication).fhirEngine
}
```
Este método estático te permite recuperar la instancia de FHIR Engine desde cualquier lugar de la app con el contexto.

5. Sincroniza datos con el servidor de FHIR

Crea una clase nueva DownloadWorkManagerImpl.kt. En esta clase, definirás cómo la aplicación recupera el siguiente recurso de la lista para descargarlo:

  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
    }
  }

Esta clase tiene una cola de tipos de recursos que desea descargar. Procesa las respuestas y extrae los recursos del paquete devuelto, que se guardan en la base de datos local.

Crea una nueva clase AppFhirSyncWorker.kt. Esta clase define cómo se sincronizará la app con el servidor FHIR remoto a través de un trabajador en segundo plano.

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,
    )
}

Aquí, definimos qué administrador de descargas, qué solucionador de conflictos y qué instancia de FHIR Engine se usarán para la sincronización.

En tu ViewModel, PatientListViewModel.kt, configurarás un mecanismo de sincronización único. Ubica y agrega este código a la función triggerOneTimeSync():
```
viewModelScope.launch {
      Sync.oneTimeSync<AppFhirSyncWorker>(getApplication())
        .shareIn(this, SharingStarted.Eagerly, 10)
        .collect { _pollState.emit(it) }
    }
```
Esta corrutina inicia una sincronización única con el servidor de FHIR usando el AppFhirSyncWorker que definimos antes. Luego, actualizará la IU según el estado del proceso de sincronización.
En el archivo PatientListFragment.kt, actualiza el cuerpo de la función handleSyncJobStatus:
```
when (syncJobStatus) {
    is SyncJobStatus.Finished -> {
        Toast.makeText(requireContext(), "Sync Finished", Toast.LENGTH_SHORT).show()
        viewModel.searchPatientsByName("")
    }
    else -> {}
}
```
Aquí, cuando finalice el proceso de sincronización, se mostrará un mensaje Toast para notificar al usuario, y la app mostrará a todos los pacientes invocando una búsqueda con un nombre vacío.

Ahora que todo está configurado, ejecuta tu app. Haz clic en el botón Sync en el menú. Si todo funciona correctamente, deberías ver que los pacientes de tu servidor FHIR local se descargan y se muestran en la aplicación.

Lista de pacientes

6. Modifica y sube datos de pacientes

En esta sección, te guiaremos por el proceso de modificación de los datos de los pacientes según criterios específicos y la carga de los datos actualizados en tu servidor de FHIR. Específicamente, intercambiaremos las ciudades de las direcciones de los pacientes que residen en Wakefield y Taunton.

Paso 1: Configura la lógica de modificación en PatientListViewModel

El código de esta sección se agrega a la función triggerUpdate en PatientListViewModel.

Accede a FHIR Engine:Comienza por obtener una referencia al motor de FHIR en PatientListViewModel.kt.
```
viewModelScope.launch {
   val fhirEngine = FhirApplication.fhirEngine(getApplication())
```
Este código inicia una corrutina dentro del alcance de ViewModel y, luego, inicializa el motor de FHIR.
Search for Patients from Wakefield:Usa el motor de FHIR para buscar pacientes con la ciudad de dirección Wakefield.
```
val patientsFromWakefield =
     fhirEngine.search<Patient> {
       filter(
         Patient.ADDRESS_CITY,
         {
           modifier =  StringFilterModifier.MATCHES_EXACTLY
           value = "Wakefield"
         }
       )
     }
```
Aquí, usamos el método search del motor de FHIR para filtrar pacientes según la ciudad de su dirección. El resultado será una lista de pacientes de Wakefield.

Search for Patients from Taunton:De manera similar, busca pacientes con la ciudad de la dirección Taunton.

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

Ahora tenemos dos listas de pacientes: una de Wakefield y otra de Taunton.

Modificar direcciones de pacientes:Revisa cada paciente de la lista patientsFromWakefield, cambia su ciudad a Taunton y actualízalo en el motor de FHIR.

patientsFromWakefield.forEach {
     it.resource.address.first().city = "Taunton"
     fhirEngine.update(it.resource)
}

De manera similar, actualiza cada paciente de la lista patientsFromTaunton para que su ciudad cambie a Wakefield.

patientsFromTaunton.forEach {
     it.resource.address.first().city = "Wakefield"
     fhirEngine.update(it.resource)
}

Iniciar sincronización:Después de modificar los datos de forma local, activa una sincronización única para asegurarte de que los datos se actualicen en el servidor de FHIR.
```
triggerOneTimeSync()
}
```
La llave de cierre } indica el final de la corrutina que se inició al principio.

Paso 2: Prueba la funcionalidad

UI Testing:Ejecuta tu app. Haz clic en el botón Update en el menú. Deberías ver que se intercambiaron las ciudades de las direcciones de los pacientes Aaron697 y Abby752.
Verificación del servidor:Abre un navegador y navega a http://localhost:8080/fhir/Patient/. Verifica que la ciudad de la dirección de los pacientes Aaron697 y Abby752 se haya actualizado en el servidor FHIR local.

Si seguiste estos pasos, implementaste correctamente un mecanismo para modificar los datos del paciente y sincronizar los cambios con tu servidor FHIR.

7. Cómo buscar pacientes por nombre

Buscar pacientes por su nombre puede ser una forma fácil de usar para recuperar información. Aquí, te guiaremos por el proceso de implementación de esta función en tu aplicación.

Paso 1: Actualiza la firma de la función

Navega a tu archivo PatientListViewModel.kt y busca la función llamada searchPatientsByName. Agregaremos código a esta función.

Para filtrar los resultados según la consulta de nombre proporcionada y emitir los resultados para que se actualice la IU, incorpora el siguiente bloque de código condicional:

    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 }
      }
    }

Aquí, si nameQuery no está vacío, la función de búsqueda filtrará los resultados para incluir solo a los pacientes cuyos nombres contengan la búsqueda especificada.

Paso 2: Prueba la nueva función de búsqueda

Reinicia la app:Después de realizar estos cambios, vuelve a compilar y ejecutar tu app.
Buscar pacientes: En la pantalla de la lista de pacientes, usa la función de búsqueda. Ahora deberías poder ingresar un nombre (o parte de un nombre) para filtrar la lista de pacientes según corresponda.

Una vez que completes estos pasos, habrás mejorado tu aplicación, ya que les brindarás a los usuarios la capacidad de buscar pacientes de manera eficiente por su nombre. Esto puede mejorar significativamente la experiencia del usuario y la eficiencia en la recuperación de datos.

8. ¡Felicitaciones!

Usaste la biblioteca de FHIR Engine para administrar recursos de FHIR en tu app:

Usa la API de Sync para sincronizar recursos de FHIR con un servidor de FHIR
Usa la API de Data Access para crear, leer, actualizar y borrar recursos FHIR locales
Usa la API de Search para buscar recursos locales de FHIR

Temas abordados

Cómo configurar un servidor local de HAPI FHIR
Cómo subir datos de prueba al servidor local de HAPI FHIR
Cómo compilar una app para Android con la biblioteca de FHIR Engine
Cómo usar las APIs de Sync, Data Access y Search en la biblioteca de FHIR Engine

Próximos pasos

Explora la documentación de la biblioteca de FHIR Engine
Explora las funciones avanzadas de la API de Búsqueda
Aplica la biblioteca de FHIR Engine en tu propia app para Android

Más información

Documentación para desarrolladores de FHIR Engine

Administra recursos de FHIR con la biblioteca de FHIR Engine Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.