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 z programowania dowiesz się, jak stworzyć aplikację na Androida przy użyciu biblioteki przechwytywania uporządkowanych danych. Twoja aplikacja będzie używać biblioteki przechwytywania uporządkowanych danych do renderowania i przetwarzania kwestionariuszy i odpowiedzi FHIR.

Czego się nauczysz

Jak zintegrować Bibliotekę przechwytywania danych strukturalnych z aplikacją na Androida
Jak wyświetlać kwestionariusz
Jak uzyskiwać odpowiedzi jako QuestionnaireResponse
Jak wyodrębnić zasoby FHIR z QuestionnaireResponse

Czego potrzebujesz

Nowa wersja Android Studio (4.1.2 lub nowsza).
Emulator Androida lub fizyczne urządzenie z Androidem
Przykładowy kod
podstawowa wiedza o programowaniu Androida w Kotlin;

To ćwiczenie z programowania dotyczy biblioteki 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, zacznij od stworzenia jej pierwszej aplikacji.

2. Konfiguracja

Pobierz kod

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

Projekt startowy tych ćwiczeń z programowania znajduje się w regionie codelabs/datacapture.

Zaimportuj aplikację 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$

Uruchamianie aplikacji startowej

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

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

Aplikacja Hello World

Widzę, że nie ma jeszcze zbyt wielu opcji, więc przejdźmy od razu do wyświetlenia kwestionariusza w aplikacji.

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

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

Zależności dotyczące biblioteki przechwytywania uporządkowanych danych umożliwiają integrację biblioteki przechwytywania uporządkowanych danych z aplikacją. Na końcu pliku app/build.gradle.kts projektu dodaj te wiersze:

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 wszystkie zależności są dostępne dla aplikacji, zsynchronizuj projekt z plikami Gradle.

Na pasku narzędzi Android Studio wybierz Synchronizuj projekt z plikami Gradle ( Przycisk synchronizacji Gradle ). Uruchom aplikację ponownie, 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 trakcie tego procesu Android Studio poprosi Cię 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. Dodaj `FragmentContainerView`

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

Otwórz plik activity_main.xml (res > układ > activity_main.xml).
Opcje widoków Kod, Podział i Projekt znajdują się w prawym górnym rogu Edytora układu.
Wybierz widok kodu
TextView nie jest Ci potrzebny, więc usuń go. Pamiętaj, aby usunąć wszystko od <TextView do zamykającego />.

Dodaj FragmentContainerView w: ConstraintLayout. Twój plik activity_main.xml powinien wyglądać mniej więcej tak:

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

Aby interfejs QuestionnaireFragment mógł się renderować, wymaga kwestionariusza FHIR zakodowanego w formacie JSON. Kwestionariusz jest mały (<512 KB), więc umieścisz go jako String w Bundle argumentów, które zostaną użyte do utworzenia fragmentu. Ze względu na wydajność większe kwestionariusze należy podawać jako URI.

Jeśli chcesz, możesz przejrzeć plik questionnaire.json, ale jedną z zalet biblioteki zbierania uporządkowanych danych jest to, że nie musisz znać struktury kwestionariusza FHIR (ani innych informacji na temat FHIR), aby go wyrenderować. Dokładniej przyjrzysz się temu plikowi w dalszej części ćwiczeń z programowania.

Utwórz QuestionnaireFragment, korzystając z jego kreatora, i ustaw kwestionariusz za pomocą funkcji setera. Aby wyświetlić QuestionnaireFragment w kontenerze układu, użyj FragmentManager do utworzenia FragmentTransaction.

Otwórz MainActivity.kt i dodaj ten kod do zajęć 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()
    )
  }
}

Dowiedz się więcej o używaniu fragmentów.

Przeprowadźmy ćwiczenie z programowania, klikając Uruchom ( Przycisk Uruchom ) na pasku narzędzi w Android Studio. Zobaczysz tekst podobny do tego:

Renderowanie kwestionariusza w emulatorze

Przejrzyj kwestionariusz i spróbuj wpisać jakieś odpowiedzi. Korzystamy z kilku różnych widżetów odpowiedzi, w tym wartości logicznych, tekstu i dat, które były automatycznie renderowane na podstawie typu podstawowego w pierwotnym kwestionariuszu FHIR.

technicznie rzecz biorąc, to wszystko, co trzeba zrobić, aby wygenerować kwestionariusz. Gratulacje!

Jeśli jednak nie widzisz odpowiedzi podanych przez użytkowników, kwestionariusz nie jest zbyt przydatny. Przejdźmy do kolejnego etapu, czyli uzyskania odpowiedzi na kwestionariusz.

5. Uzyskaj odpowiedź w kwestionariuszu

W poprzednich krokach w aplikacji został wyrenderowany kwestionariusz FHIR.

W tej sekcji otrzymasz odpowiedzi z kwestionariusza 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 uzyskać odpowiedź na pytanie, pobierz fragment kwestionariusza, który został utworzony wcześniej, i użyj metody getQuestionnaireResponse(). Zwraca wartość HAPI FHIR QuestionnaireResponse, której możesz używać bezpośrednio lub z innymi częściami pakietu Android FHIR SDK. W tym ćwiczeniu z programowania użyto innych bibliotek HAPI FHIR do przekonwertowania go na ciąg znaków w formacie JSON, który będzie można wyświetlić w logu.

Uruchom aplikację jeszcze raz, aby odbudować ją z zastosowaniem najnowszych zmian. Po wygenerowaniu wpisz w nim pewne informacje i kliknij Prześlij. W dzienniku 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 odpowiedzi na kwestionariusz

Kwestionariusz dołączony do projektu startowego ma na celu uproszczenie procedury rejestracji pacjentów, więc ostatecznie możesz skorzystać z odpowiedzi w kwestionariuszu, aby utworzyć na ich podstawie zasoby dla pacjentów FHIR. Konwersja z odpowiedzi z kwestionariusza na zasoby FHIR jest nazywana wyodrębnianiem danych. Służą do tego klasa ResourceMapper biblioteki przechwytywania uporządkowanych danych.

Aby można było przeprowadzić wyodrębnianie danych, kwestionariusz musi zawierać informacje o jego sposobie. 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 znaków JSON kwestionariusza z wcześniejszego formularza, oraz QuestionnaireResponse, który już uzyskaliśmy. Zwraca transakcję HAPI FHIR Bundle zawierającą co najmniej 1 wyodrębniony zasób, w tym przypadku jeden zasób Patient.

Uruchom aplikację jeszcze raz, aby odbudować ją z zastosowaniem najnowszych zmian. Następnie wpisz informacje i kliknij Prześlij. W dzienniku powinien pojawić się komunikat extraction result zawierający reprezentację w formacie 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 zbierania danych strukturalnych służy do przetwarzania kwestionariuszy FHIR i odpowiedzi w aplikacji:

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

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

Być może zechcesz korzystać z zasobów FHIR na więcej sposobów w całej aplikacji. Zapoznaj się z biblioteką silnika FHIR pakietu SDK FHIR Androida, aby dowiedzieć się, jak przechowywać zasoby FHIR lokalnie w aplikacji i nimi zarządzać oraz synchronizować dane ze zdalnym serwerem FHIR.

Omówione zagadnienia

Jak dodać bibliotekę przechwytywania uporządkowanych danych do aplikacji na Androida
Jak korzystać z narzędzi QuestionnaireFragment i ResourceMapper podczas pracy z kwestionariuszami FHIR

Dalsze kroki

Zapoznaj się z dokumentacją biblioteki przechwytywania uporządkowanych danych
Dostosuj wygląd i styl renderowanych kwestionariuszy
Stosowanie biblioteki przechwytywania uporządkowanych danych we własnej aplikacji na Androida

Więcej informacji

Dokumentacja dla deweloperów dotycząca funkcji przechwytywania uporządkowanych danych