Se usó la API de Cloud Translation para traducir esta página.

Captura y procesa datos de salud con la biblioteca de captura de datos estructurados

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.

$Pantalla de inicio\nde Android Studio$

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 ( Botón Ejecutar ) en la barra de herramientas de Android Studio.

App de Hello World

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 ( Botón de sincronización de Gradle ) 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 de ConstraintLayout. Tu archivo activity_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 ( Botón Ejecutar ), en la barra de herramientas de Android Studio. Deberías ver un resultado similar a este:

Cuestionario renderizado en el emulador

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 y ResourceMapper 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

Más información

Documentación para desarrolladores de Captura de datos estructurados