Ta strona została przetłumaczona przez Cloud Translation API.

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

1. Zanim zaczniesz

Co utworzysz

Z tego ćwiczenia w programie dowiesz się, jak utworzyć aplikację na Androida przy użyciu biblioteki zbierania uporządkowanych danych. Aplikacja będzie używać biblioteki przechwytywania uporządkowanych danych do renderowania i przetwarzania kwestionariuszy FHIR oraz odpowiedzi.

Czego się nauczysz

Jak zintegrować bibliotekę zbierania uporządkowanych danych z aplikacją na Androida
Jak wyświetlić kwestionariusz
Jak uzyskiwać odpowiedzi jako QuestionnaireResponse
Jak wyodrębnić zasoby FHIR z QuestionnaireResponse

Czego potrzebujesz

najnowszą wersję Android Studio (4.1.2 lub nowszego),
Emulator Androida lub fizyczne urządzenie z Androidem.
Przykładowy kod
Podstawowa wiedza o programowaniu na Androida w Kotlin

To ćwiczenia w programie skupiają się na bibliotece przechwytywania uporządkowanych danych. Nieistotne koncepcje i bloki kodu zostały zamaskowane. Można je po prostu skopiować i wkleić. Jeśli nie masz jeszcze aplikacji na Androida, możesz zacząć od stworzenia pierwszej aplikacji.

2. Konfiguracja

Pobierz kod

Aby pobrać kod do tego ćwiczenia z programowania, skopiuj repozytorium Android FHIR: git clone https://github.com/google/android-fhir.git

Projekt startowy tego ćwiczenia z programowania znajduje się w regionie codelabs/datacapture.

Importowanie aplikacji do Android Studio

Zacznijmy od zaimportowania aplikacji startowej do Android Studio.

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

$Ekran startowy\nAndroid Studio$

Uruchom aplikację startową

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

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, niewiele jest jeszcze w aplikacji, więc przejdźmy od razu do wyświetlania kwestionariusza w aplikacji.

3. Dodaj bibliotekę zbierania uporządkowanych danych do projektu

Dodawanie zależności do biblioteki przechwytywania uporządkowanych danych

Zależności Biblioteki uporządkowanych danych umożliwiają integrację biblioteki uporządkowanych danych z aplikacją. Dodaj te wiersze na końcu pliku app/build.gradle.kts projektu:

dependencies {
    // ...

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

Synchronizowanie projektu z plikami Gradle

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

Na pasku narzędzi Android Studio wybierz Sync Project with Gradle Files (Synchronizuj projekt z plikami Gradle) ( Przycisk synchronizacji Gradle ). Uruchomisz też aplikację jeszcze raz, aby sprawdzić, czy zależności działają prawidłowo.

4. Wyświetl kwestionariusz

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

W czasie Android Studio wyświetli prośbę o dodanie niezbędnego importu:

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

Krok 1. Dodaj `FragmentContainerView`

Dodaj FragmentContainerView do układu aplikacji. Tutaj będą wyświetlane dane QuestionnaireFragment, które utworzysz później.

Otwórz plik activity_main.xml (res > layout > activity_main.xml).
W prawym górnym rogu Edytora układów znajdziesz opcje widoków Kod, Podział i Projekt.
Wybierz widok kodu.
TextView – nie potrzebujesz, więc je usuń. Usuń wszystko od <TextView do zamykającego />.

Dodaj element FragmentContainerView w elemencie ConstraintLayout. Twój 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. Dodaj `QuestionnaireFragment` do `FragmentContainerView`

Do renderowania QuestionnaireFragment wymaga kwestionariusza FHIR zakodowanego w formacie JSON. Kwestionariusz jest mały (poniżej 512 KB), więc umieścisz go jako String w Bundle argumentach, które zostaną użyte do utworzenia fragmentu. Większe kwestionariusze należy udostępniać jako URI ze względu na wydajność.

Możesz przyjrzeć się plikowi questionnaire.json, ale jedną z zalet biblioteki zbierania uporządkowanych danych jest to, że nie musisz znać struktury kwestionariusza FHIR (lub innej informacji na temat FHIR), aby ją wyrenderować. Później przyjrzysz się temu plikowi bliżej w ramach ćwiczenia w Codelabs.

Utwórz QuestionnaireFragment za pomocą kreatora, a następnie ustaw kwestionariusz za pomocą funkcji ustawiającej. Aby wyświetlić element QuestionnaireFragment w kontenerze układu, użyj elementu FragmentManager do utworzenia obiektu FragmentTransaction.

Otwórz plik MainActivity.kt i dodaj do zajęć MainActivity ten kod:

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

Dowiedz się więcej o tym, jak używać fragmentów.

Wykonajmy ćwiczenia w Codelabs, klikając Uruchom ( Przycisk Uruchom ) na pasku narzędzi Android Studio. Zobaczysz tekst podobny do tego:

Kwestionariusz renderowany w emulatorze

Przejrzyj kwestionariusz i spróbuj wpisać kilka odpowiedzi. Istnieje kilka różnych widżetów odpowiedzi, w tym wartości logiczne, tekst i daty, które zostały wyrenderowane automatycznie na podstawie typu podstawowego w pierwotnym kwestionariuszu FHIR.

To wszystko, co trzeba zrobić, aby wygenerować kwestionariusz. Gratulacje!

Kwestionariusz nie jest zbyt przydatny, jeśli nie widać odpowiedzi udzielanych przez użytkowników. Przejdźmy do kolejnego kroku, w ramach którego otrzymasz odpowiedź w kwestionariuszu.

5. Uzyskaj odpowiedź na kwestionariusz

W poprzednich krokach został przez Ciebie wyrenderowany kwestionariusz FHIR w aplikacji.

W tej sekcji odpowiedzi na pytania kwestionariusza otrzymasz w formie kwestionariusza.

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 otrzymać odpowiedź w kwestionariuszu, pobierzesz utworzony wcześniej fragment kwestionariusza, a następnie użyjesz metody getQuestionnaireResponse(). Spowoduje to zwrócenie listy FHIR QuestionnaireResponse HAPI, której możesz użyć bezpośrednio lub z innymi częściami pakietu Android FHIR. To ćwiczenie w Codelabs wykorzystuje inne biblioteki FHIR HAPI, aby przekonwertować je na ciąg JSON, który będzie widoczny w logu.

Uruchom aplikację ponownie, aby utworzyć ją z najnowszymi zmianami. Po jego wygenerowaniu wpisz informacje w kwestionariuszu i kliknij Prześlij. W dzienniku powinien pojawić się komunikat zawierający QuestionnaireResponse w postaci 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ębnij zasoby FHIR z QuestionnaireResponse

Kwestionariusz dołączony do projektu początkowego służy do prostego procesu rejestracji pacjentów, więc warto użyć odpowiedzi z kwestionariusza do utworzenia na ich podstawie zasobu dla pacjentów z FHIR. Ta konwersja odpowiedzi z kwestionariusza na zasoby FHIR jest nazywana wyodrębnianiem danych. Użyjemy do tego klasy ResourceMapper z biblioteki funkcji przechwytywania danych strukturalnych.

Aby móc wyodrębniać dane, musisz utworzyć kwestionariusz z informacjami o tym, jak to zrobić. 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 wcześniejszy ciąg znaków JSON kwestionariusza, oraz QuestionnaireResponse, który już otrzymaliśmy. Zwraca pakiet HAPI FHIR zawierający co najmniej 1 wyodrębniony zasób – w tym przypadku pojedynczy zasób pacjent.

Uruchom aplikację ponownie, aby utworzyć ją z najnowszymi zmianami. Następnie wpisz informacje i kliknij Prześlij. W logu powinien być teraz widoczny 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!

Udało Ci się przetworzyć kwestionariusze FHIR i odpowiedzi FHIR w aplikacji za pomocą biblioteki zbierania uporządkowanych danych:

Wyświetl kwestionariusz
Uzyskaj odpowiedź na kwestionariusz
Wyodrębnianie zasobów FHIR z QuestionnaireResponse

To wszystko, czego potrzebujesz, aby zacząć korzystać z tej funkcji.

W dalszej kolejności możesz używać zasobów FHIR na więcej sposobów w aplikacji. Zapoznaj się z biblioteką mechanizmu FHIR pakietu SDK FHIR na Androida, aby dowiedzieć się, jak przechowywać zasoby FHIR lokalnie w aplikacji i nimi zarządzać, a także jak synchronizować dane ze zdalnym serwerem FHIR.

Omówione zagadnienia

Dodawanie biblioteki zbierania uporządkowanych danych do aplikacji na Androida
Jak używać narzędzi QuestionnaireFragment i ResourceMapper do pracy z kwestionariuszami FHIR

Następne kroki

Zapoznaj się z dokumentacją biblioteki przechwytywania uporządkowanych danych
Dostosowywanie wyglądu i sposobu działania renderowanych kwestionariuszy
Stosowanie biblioteki uporządkowanych danych w swojej aplikacji na Androida

Więcej informacji

Dokumentacja dla deweloperów korzystających z funkcji przechwytywania uporządkowanych danych