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

Zbieranie i przetwarzanie danych dotyczących zdrowia za pomocą biblioteki zbierania uporządkowanych danych

1. Zanim zaczniesz

Co utworzysz

Z tego ćwiczenia dowiesz się, jak utworzyć aplikację na Androida za pomocą biblioteki Structured Data Capture. Twoja aplikacja będzie używać biblioteki Structured Data Capture do renderowania i przetwarzania kwestionariuszy i odpowiedzi FHIR.

Czego się nauczysz

Jak zintegrować bibliotekę Structured Data Capture z aplikacją na Androida
Jak wyświetlić kwestionariusz
Jak uzyskać odpowiedzi jako QuestionnaireResponse
Jak wyodrębnić zasoby FHIR z QuestionnaireResponse

Czego potrzebujesz

Najnowsza wersja Android Studio (4.1.2 lub nowsza)
Android Emulator lub fizyczne urządzenie z Androidem
Przykładowy kod
Podstawowa wiedza na temat tworzenia aplikacji na Androida w języku Kotlin

To ćwiczenie koncentruje się na bibliotece Structured Data Capture. Nieistotne koncepcje i bloki kodu zostały pominięte. Można je po prostu skopiować i wkleić. Jeśli nie masz doświadczenia w tworzeniu aplikacji na Androida, zacznij od utworzenia pierwszej aplikacji.

2. Konfiguracja

Pobieranie kodu

Aby pobrać kod do tego ćwiczenia, sklonuj repozytorium Android FHIR SDK: git clone https://github.com/ohs-foundation/android-fhir.git

Projekt początkowy do tego ćwiczenia znajduje się w codelabs/datacapture.

Importowanie aplikacji do Android Studio

Zacznijmy od zaimportowania aplikacji startowej do Android Studio.

Otwórz Android Studio, kliknij Importuj projekt (Gradle, Eclipse ADT itp.) i wybierz folder codelabs/datacapture z pobranego wcześniej kodu źródłowego.

Ekran startowy Android Studio

Uruchamianie aplikacji startowej

Po zaimportowaniu projektu do Android Studio możesz po raz pierwszy uruchomić aplikację.

Podłącz urządzenie z Androidem do hosta przez USB lub uruchom emulator Android Studio, i kliknij Uruchom ( Przycisk Uruchom ) na pasku narzędzi Android Studio.

Aplikacja Hello World

Jak widzisz, nie ma tu jeszcze zbyt wiele, więc od razu przejdźmy do wyświetlania kwestionariusza w aplikacji.

3. Dodawanie biblioteki Structured Data Capture do projektu

Dodawanie zależności biblioteki Structured Data Capture

Zależności biblioteki Structured Data Capture umożliwiają zintegrowanie tej biblioteki z aplikacją. Dodaj te wiersze na końcu pliku app/build.gradle.kts w projekcie:

dependencies {
    // ...

    implementation("com.google.android.fhir:data-capture:1.2.0")
    implementation("androidx.fragment:fragment-ktx:1.6.0")
}

Synchronizowanie projektu z plikami Gradle

Aby mieć pewność, że wszystkie zależności są dostępne w aplikacji, zsynchronizuj projekt z plikami Gradle.

Na pasku narzędzi Android Studio kliknij Synchronizuj projekt z plikami Gradle ( Przycisk synchronizacji Gradle ). Możesz też ponownie uruchomić aplikację, aby sprawdzić, czy zależności działają prawidłowo.

4. Wyświetlanie kwestionariusza

W tym kroku dodasz do aplikacji startowej funkcję renderowania kwestionariusza w FragmentContainerView.

Android Studio wyświetli prośbę o dodanie niezbędnych importów:

androidx.core.os.bundleOf
androidx.fragment.app.add
androidx.fragment.app.commit
android.util.Log
com.google.android.fhir.datacapture.QuestionnaireFragment

Krok 1. Dodawanie `FragmentContainerView`

Dodaj FragmentContainerView do układu aplikacji. To tutaj będzie wyświetlany utworzony później QuestionnaireFragment.

Otwórz activity_main.xml (res > layout > activity_main.xml).
W prawym górnym rogu narzędzia Layout Editor znajdź opcje widoków Kod, Podział i Projekt.
Wybierz widok kodu.
Nie potrzebujesz TextView, więc go usuń. Pamiętaj, aby usunąć wszystko od <TextView do zamykającego />.

Dodaj FragmentContainerView w ConstraintLayout. Plik activity_main.xml powinien wyglądać podobnie do tego:

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

Krok 2. Konfigurowanie `QuestionnaireFragment`

QuestionnaireFragment wymaga do renderowania kwestionariusza FHIR zakodowanego w formacie JSON. Ponieważ kwestionariusz jest mały (< 512 KB), dołączysz go jako String w Bundle argumentów, które będą używane do utworzenia fragmentu. W przypadku większych kwestionariuszy ze względów wydajnościowych należy podać URI.

Jeśli chcesz, możesz przejrzeć plik questionnaire.json, ale jedną z zalet biblioteki Structured Data Capture jest to, że aby go renderować, nie musisz znać struktury kwestionariusza FHIR (ani niczego o FHIR). Ten plik omówimy dokładniej w dalszej części ćwiczenia.

Utwórz QuestionnaireFragment za pomocą jego konstruktora i ustaw kwestionariusz za pomocą funkcji ustawiającej. Aby wyświetlić QuestionnaireFragment w kontenerze układu, użyj FragmentManager, aby utworzyć FragmentTransaction.

Otwórz MainActivity.kt i dodaj ten kod do klasy MainActivity:

// Step 2: Configure a QuestionnaireFragment
questionnaireJsonString = getStringFromAssets("questionnaire.json")

val questionnaireFragment =
  QuestionnaireFragment.builder().setQuestionnaire(questionnaireJsonString!!).build()

Krok 3. Dodawanie QuestionnaireFragment do FragmentContainerView

Aby wyświetlić QuestionnaireFragment w kontenerze układu, użyj FragmentManager, aby utworzyć FragmentTransaction. FragmentManager obsługuje tworzenie instancji za pomocą utworzonych wcześniej questionnaireParams.

Dodaj ten kod do klasy MainActivity:

// Step 3: Add the QuestionnaireFragment to the FragmentContainerView
if (savedInstanceState == null) {
  supportFragmentManager.commit {
    setReorderingAllowed(true)
    add(R.id.fragment_container_view, questionnaireFragment)
  }
}
// Submit button callback
supportFragmentManager.setFragmentResultListener(
  QuestionnaireFragment.SUBMIT_REQUEST_KEY,
  this,
) { _, _ ->
  submitQuestionnaire()
}

Więcej informacji o korzystaniu z fragmentów .

Uruchom ćwiczenie, klikając Uruchom ( Przycisk Uruchom ) na pasku narzędzi Android Studio. Powinno się wyświetlić coś takiego:

Kwestionariusz wyrenderowany w emulatorze

Przejdź przez kwestionariusz i spróbuj wpisać odpowiedzi. Użyto kilku różnych widżetów odpowiedzi, w tym wartości logicznych, tekstu i dat, które zostały automatycznie wyrenderowane na podstawie podstawowego typu w oryginalnym kwestionariuszu FHIR.

Technicznie rzecz biorąc, to wszystko, co musisz zrobić, aby wyrenderować kwestionariusz. Gratulacje!

Kwestionariusz nie jest zbyt przydatny, jeśli nie możesz zobaczyć odpowiedzi wprowadzonych przez użytkowników. Przejdźmy do następnego kroku, czyli uzyskiwania odpowiedzi na kwestionariusz.

5. Uzyskiwanie odpowiedzi na kwestionariusz

W poprzednich krokach wyrenderowano w aplikacji kwestionariusz FHIR.

W tej sekcji uzyskasz odpowiedzi z kwestionariusza jako QuestionnaireResponse.

Znajdź metodę submitQuestionnaire() i dodaj ten kod:

// 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)

Aby uzyskać odpowiedź na kwestionariusz, pobierz utworzony wcześniej fragment kwestionariusza, a następnie użyj metody getQuestionnaireResponse(). Zwraca ona HAPI FHIR QuestionnaireResponse, którego możesz używać bezpośrednio lub z innymi częściami Android FHIR SDK. To ćwiczenie korzysta z innych bibliotek HAPI FHIR, aby przekonwertować go na ciąg JSON, który można wyświetlić w logu.

Ponownie uruchom aplikację, aby ją przebudować z najnowszymi zmianami. Gdy aplikacja będzie działać, wpisz informacje w kwestionariuszu i kliknij Prześlij. W logu powinien pojawić się komunikat zawierający QuestionnaireResponse w formacie 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. Wyodrębnianie zasobów FHIR z QuestionnaireResponse

Kwestionariusz dołączony do projektu początkowego służy do prostego procesu rejestracji pacjenta, więc ostatecznie możesz użyć odpowiedzi na kwestionariusz, aby na ich podstawie utworzyć zasób FHIR Patient. Ta konwersja odpowiedzi na kwestionariusz na zasoby FHIR jest nazywana wyodrębnianiem danych. Możemy to zrobić za pomocą klasy ResourceMapper biblioteki Structured Data Capture.

Aby przeprowadzić wyodrębnianie danych, kwestionariusz musi być utworzony tak, aby zawierał informacje o tym, jak przeprowadzić wyodrębnianie danych. Na szczęście przykładowy kwestionariusz jest już skonfigurowany do wyodrębniania na podstawie definicji.

Znajdź metodę submitQuestionnaire() i dodaj ten kod:

lifecycleScope.launch {
  val questionnaire =
    jsonParser.parseResource(questionnaireJsonString) as Questionnaire
  val bundle = ResourceMapper.extract(questionnaire, questionnaireResponse)
  Log.d("extraction result", jsonParser.encodeResourceToString(bundle))
}

ResourceMapper.extract() wymaga kwestionariusza HAPI FHIR, który możesz utworzyć, analizując ciąg JSON kwestionariusza z poprzedniego kroku, oraz QuestionnaireResponse, który już uzyskaliśmy. Zwraca on pakiet transakcji HAPI FHIR zawierający co najmniej 1 wyodrębniony zasób – w tym przypadku 1 zasób Patient.

Ponownie uruchom aplikację, aby ją przebudować z najnowszymi zmianami. Gdy aplikacja będzie działać, wpisz informacje i kliknij Prześlij. W logu powinien teraz pojawić się komunikat extraction result zawierający reprezentację JSON wyodrębnionego pakietu FHIR.

D/extraction result: {"resourceType":"Bundle","type":"transaction","entry":[{"resource":{"resourceType":"Patient","identifier":[{"value":"12345"}],"name":[{"family":"Lee","given":["Dani"]}],"birthDate":"1990-02-14"}}]}

7. Gratulacje!

Biblioteka Structured Data Capture została użyta do przetwarzania kwestionariuszy i odpowiedzi FHIR w aplikacji:

Wyświetlanie kwestionariusza
Uzyskiwanie odpowiedzi na kwestionariusz
Wyodrębnianie zasobów FHIR z QuestionnaireResponse

To wszystko, co musisz zrobić, aby uruchomić aplikację.

W miarę postępów możesz chcieć pracować z zasobami FHIR na więcej sposobów w całej aplikacji. Zapoznaj się z biblioteką FHIR Engine w Android FHIR SDK, aby dowiedzieć się, jak przechowywać zasoby FHIR i zarządzać nimi lokalnie w aplikacji oraz jak synchronizować dane ze zdalnym serwerem FHIR.

Omówione zagadnienia

Jak dodać bibliotekę Structured Data Capture do aplikacji na Androida
Jak używać QuestionnaireFragment i ResourceMapper do pracy z kwestionariuszami FHIR

Następne kroki

Zapoznaj się z dokumentacją biblioteki Structured Data Capture.
Dostosuj wygląd i działanie renderowanych kwestionariuszy.
Zastosuj bibliotekę Structured Data Capture w swojej aplikacji na Androida.

Więcej informacji

Dokumentacja dla deweloperów biblioteki Structured Data Capture

Zbieranie i przetwarzanie danych dotyczących zdrowia za pomocą biblioteki zbierania uporządkowanych danych Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.