1. Antes de comenzar
Qué compilarás
En este codelab, aprenderás a compilar una app para Android con la biblioteca de captura de datos estructurados. Tu app usará la biblioteca de captura de datos estructurados para renderizar y procesar cuestionarios y respuestas de FHIR.
Qué aprenderás
- Cómo integrar la biblioteca de captura de datos estructurados en tu aplicación para Android
- Cómo mostrar un cuestionario
- Cómo obtener respuestas como
QuestionnaireResponse
- Cómo extraer recursos de FHIR de un
QuestionnaireResponse
Requisitos
- Una versión reciente de Android Studio (v4.1.2 y versiones posteriores)
- Android Emulator o un dispositivo Android físico.
- El código de muestra
- Conocimientos básicos sobre el desarrollo de Android en Kotlin
Este codelab se enfoca en la biblioteca de captura de datos estructurados. Los conceptos y los bloques de código no relevantes se pasan por alto y se proporcionan para que simplemente los copies y pegues. Si es la primera vez que creas apps para Android, puedes comenzar por compilar tu primera app.
2. Prepárate
Cómo descargar el código
Para descargar el código de este codelab, clona el repositorio del SDK de FHIR de Android: git clone https://github.com/google/android-fhir.git
El proyecto inicial de este codelab se encuentra en codelabs/datacapture
.
Importa la app a Android Studio
Comencemos por importar la app de partida a Android Studio.
Abre Android Studio, selecciona Import Project (Gradle, Eclipse ADT, etc.) y elige la carpeta codelabs/datacapture
del código fuente que descargaste antes.
Ejecuta la app de partida
Ahora que importaste el proyecto a Android Studio, podrás ejecutar la app por primera vez.
Conecta tu dispositivo Android mediante USB a tu host o inicia el emulador de Android Studio, y haz clic en Run () en la barra de herramientas de Android Studio.
Como puedes ver, todavía no hay mucho aquí, así que veamos de inmediato un cuestionario en tu app.
3. Agrega la biblioteca de captura de datos estructurados al proyecto
Agrega las dependencias para la biblioteca de captura de datos estructurados
Las dependencias de la biblioteca de captura de datos estructurados te permiten integrarla en tu app. Agrega las siguientes líneas al final del archivo app/build.gradle.kts
de tu proyecto:
dependencies {
// ...
implementation("com.google.android.fhir:data-capture:1.0.0")
implementation("androidx.fragment:fragment-ktx:1.5.5")
}
Sincroniza tu proyecto con archivos Gradle
A fin de asegurarte de que todas las dependencias estén disponibles para tu app, debes sincronizar tu proyecto con archivos de Gradle en este momento.
Selecciona Sync Project with Gradle Files () en la barra de herramientas de Android Studio. También puedes volver a ejecutar la app para comprobar que las dependencias funcionen correctamente.
4. Muestra un cuestionario
En este paso, agregarás la funcionalidad a la app de partida para renderizar un cuestionario en una FragmentContainerView
.
Durante el proceso, Android Studio te solicitará que agregues las importaciones necesarias:
androidx.core.os.bundleOf
androidx.fragment.app.add
androidx.fragment.app.commit
android.util.Log
com.google.android.fhir.datacapture.QuestionnaireFragment
Paso 1: Agrega un FragmentContainerView
Agrega un elemento FragmentContainerView
al diseño de la aplicación. Aquí es donde se mostrará el QuestionnaireFragment
que crearás más adelante.
- Abre
activity_main.xml
(res > layout > activity_main.xml). - Encuentra las opciones para las vistas Code, Split y Design en la parte superior derecha del editor de diseño.
- Selecciona Vista de código (Code view).
- No necesitas
TextView
, así que bórralo. Asegúrate de borrar todo desde<TextView
hasta el/>
de cierre. - Agrega un
FragmentContainerView
dentro deConstraintLayout
. Tu archivoactivity_main.xml
debería ser similar al siguiente:<?xml version="1.0" encoding="utf-8" ?> <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" tools:context=".MainActivity" > <androidx.fragment.app.FragmentContainerView android:id="@+id/fragment_container_view" android:layout_width="match_parent" android:layout_height="match_parent" app:layout_constraintTop_toTopOf="parent" /> </androidx.constraintlayout.widget.ConstraintLayout>
Paso 2: Agrega un elemento QuestionnaireFragment
a FragmentContainerView
QuestionnaireFragment
requiere un cuestionario FHIR codificado en JSON para que se renderice. Como el cuestionario es pequeño (menos de 512 KB), lo incluirás como String
en una Bundle
de argumentos que se usarán para crear el fragmento. Los cuestionarios más grandes se deben proporcionar como URI
por motivos de rendimiento.
Puedes consultar el archivo questionnaire.json
si lo deseas, pero uno de los beneficios de la biblioteca de captura de datos estructurados es que no necesitas conocer la estructura del cuestionario de FHIR (ni nada sobre FHIR) para obtenerlo y renderizarlo. Más adelante en el codelab, analizarás este archivo con más detalle.
Crea un QuestionnaireFragment
con su compilador y establece el cuestionario con la función set. Para mostrar el QuestionnaireFragment
dentro del contenedor de diseño, usa FragmentManager
para crear un FragmentTransaction
.
Abre MainActivity.kt
y agrega el siguiente código a la clase MainActivity
:
// Step 2: Configure a QuestionnaireFragment
questionnaireJsonString = getStringFromAssets("questionnaire.json")
if (savedInstanceState == null) {
supportFragmentManager.commit {
setReorderingAllowed(true)
add(
R.id.fragment_container_view,
QuestionnaireFragment.builder().setQuestionnaire(questionnaireJsonString!!).build()
)
}
}
Obtén más información para usar fragmentos.
Para ejecutar el codelab, haz clic en Run (), en la barra de herramientas de Android Studio. Deberías ver un resultado similar a este:
Lee el cuestionario y escribe algunas respuestas. Se usaron algunos widgets de respuesta diferentes, incluidos booleanos, texto y fechas, que se procesaron automáticamente según el tipo subyacente en el cuestionario original de FHIR.
Técnicamente, eso es todo lo que necesitas hacer para procesar un cuestionario. ¡Felicitaciones!
Sin embargo, un cuestionario no es muy útil si no puedes ver las respuestas que ingresan los usuarios. Pasemos al siguiente paso para obtener una respuesta al cuestionario.
5. Obtener una respuesta al cuestionario
En los pasos anteriores, renderizaste un cuestionario FHIR en tu app.
En esta sección, obtendrás las respuestas del cuestionario en forma de QuestionnaireResponse.
Busca el método submitQuestionnaire()
y agrega el siguiente código:
// Get a questionnaire response
val fragment = supportFragmentManager.findFragmentById(R.id.fragment_container_view)
as QuestionnaireFragment
val questionnaireResponse = fragment.getQuestionnaireResponse()
// Print the response to the log
val jsonParser = FhirContext.forCached(FhirVersionEnum.R4).newJsonParser()
val questionnaireResponseString =
jsonParser.encodeResourceToString(questionnaireResponse)
Log.d("response", questionnaireResponseString)
Para obtener la respuesta del cuestionario, debes recuperar el fragmento que creaste anteriormente y, luego, usar el método getQuestionnaireResponse()
. Esto muestra un FHIR QuestionnaireResponse
de HAPI que puedes usar directamente o con otras partes del SDK de FHIR de Android. En este codelab, se usan otras bibliotecas de FHIR HAPI para convertirla en una string JSON y verla en el registro.
Vuelve a ejecutar la app para volver a compilarla con los cambios más recientes. Una vez que se ejecute, ingresa información en el cuestionario y presiona Enviar. En el registro, deberías ver un mensaje que contenga QuestionnaireResponse
como JSON.
D/response: {"resourceType":"QuestionnaireResponse","item":[{"linkId":"PR","text":"Patient information","item":[{"linkId":"PR-name","text":"Name","item":[{"linkId":"PR-name-given","text":"First Name","answer":[{"valueString":"Dani"}]},{"linkId":"PR-name-family","text":"Family Name","answer":[{"valueString":"Lee"}]}]},{"linkId":"PR-birthdate","text":"Date of Birth","answer":[{"valueDate":"1990-02-14"}]},{"linkId":"PR-id","text":"Identifying information","item":[{"linkId":"PR-name-id-url"},{"linkId":"PR-name-id","text":"Patient Id","answer":[{"valueString":"12345"}]}]}]}]}
6. Extraer recursos de FHIR de un QuestionnaireResponse
El cuestionario incluido con el proyecto inicial es para un flujo simple de registro de pacientes, por lo que, en última instancia, es posible que desees usar las respuestas del cuestionario para crear un recurso para pacientes de FHIR basado en ellas. Esta conversión de una respuesta de cuestionario a recursos de FHIR se llama extracción de datos. Podemos hacerlo con la clase ResourceMapper
de la biblioteca de captura de datos estructurados.
Para realizar la extracción de datos, se debe redactar un cuestionario que incluya información sobre cómo realizar la extracción de datos. Por suerte, el cuestionario de muestra ya está configurado para la extracción basada en definiciones.
Busca el método submitQuestionnaire()
y agrega el siguiente código:
lifecycleScope.launch {
val questionnaire =
jsonParser.parseResource(questionnaireJsonString) as Questionnaire
val bundle = ResourceMapper.extract(questionnaire, questionnaireResponse)
Log.d("extraction result", jsonParser.encodeResourceToString(bundle))
}
ResourceMapper.extract()
requiere un cuestionario HAPI FHIR, que puedes crear analizando la cadena JSON del cuestionario que mencionamos antes y un QuestionnaireResponse
, que ya obtuvimos antes. Muestra un Bundle de transacción de FHIR HAPI que contiene uno o más recursos extraídos; en este caso, un solo recurso Paciente.
Vuelve a ejecutar la app para volver a compilarla con los cambios más recientes. Cuando se esté ejecutando, ingresa información y presiona Enviar. En el registro, deberías ver un mensaje extraction result
que contiene la representación JSON del paquete de FHIR extraído.
D/extraction result: {"resourceType":"Bundle","type":"transaction","entry":[{"resource":{"resourceType":"Patient","identifier":[{"value":"12345"}],"name":[{"family":"Lee","given":["Dani"]}],"birthDate":"1990-02-14"}}]}
7. ¡Felicitaciones!
Usaste la biblioteca de captura de datos estructurados para procesar cuestionarios de FHIR y respuestas en tu app:
- Muestra un cuestionario
- Obtener una respuesta al cuestionario
- Extrae recursos de FHIR de un
QuestionnaireResponse
Eso es todo lo que necesitas para empezar a usarlo.
A medida que avanzas, es posible que desees trabajar con recursos FHIR de más formas en toda tu aplicación. Consulta la biblioteca del motor de FHIR del SDK de FHIR de Android para aprender a almacenar y administrar recursos FHIR de forma local en tu aplicación y sincronizar datos con un servidor de FHIR remoto.
Temas abordados
- Cómo agregar la biblioteca de captura de datos estructurados a tu app para Android
- Cómo usar
QuestionnaireFragment
yResourceMapper
para trabajar con cuestionarios de FHIR
Próximos pasos
- Explora la documentación de la biblioteca de captura de datos estructurados
- Personaliza el aspecto de los cuestionarios renderizados
- Aplica la biblioteca de captura de datos estructurados en tu propia app para Android