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

Zapisywanie danych medycznych
Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Ten przewodnik jest zgodny z Health Connect w wersji 1.1.0-beta02.

Aby zapisywać dane medyczne za pomocą danych o stanie zdrowia w Health Connect, wykonaj te czynności:

Sprawdzanie dostępności funkcji
Poproś o uprawnienia do zapisu
Tworzenie źródła danych (MedicalDataSource)
Napisać materiał medyczny (MedicalResource)

Dostępność funkcji

Aby sprawdzić, czy urządzenie użytkownika obsługuje PHR w Health Connect, sprawdź dostępność FEATURE_PERSONAL_HEALTH_RECORD na kliencie:

if (healthConnectClient
     .features
     .getFeatureStatus(
       HealthConnectFeatures.FEATURE_PERSONAL_HEALTH_RECORD
     ) == HealthConnectFeatures.FEATURE_STATUS_AVAILABLE) {

  // Feature is available
} else {
  // Feature isn't available
}

Więcej informacji znajdziesz w sekcji Sprawdzanie dostępności funkcji.

Wymagane uprawnienia

Zapisywanie danych medycznych jest chronione przez to uprawnienie:

android.permission.health.WRITE_MEDICAL_DATA

Zadeklaruj te uprawnienia w Konsoli Play dla swojej aplikacji, a także w pliku manifestu aplikacji:

<application>
  <uses-permission
android:name="android.permission.health.WRITE_MEDICAL_DATA" />
</application>

Użytkownik jest odpowiedzialny za zadeklarowanie wszystkich odpowiednich uprawnień, których zamierza używać na urządzeniach i w aplikacjach. Przed użyciem musisz też sprawdzić, czy użytkownik przyznał Ci odpowiednie uprawnienia.

Prośba o uprawnienia od użytkownika

Po utworzeniu instancji klienta aplikacja musi poprosić użytkownika o przyznanie uprawnień. Użytkownicy muszą mieć możliwość przyznania lub odmowy przyznania uprawnień w dowolnym momencie.

Aby to zrobić, utwórz zestaw uprawnień dla wymaganych typów danych. Najpierw sprawdź, czy uprawnienia w zestawie są zadeklarowane w pliku manifestu Androida.

// Create a set of permissions for required data types
import androidx.health.connect.client.permission.HealthPermission.Companion.PERMISSION_WRITE_MEDICAL_DATA

val PERMISSIONS =
    setOf(
       PERMISSION_WRITE_MEDICAL_DATA
)

Użyj getGrantedPermissions, aby sprawdzić, czy Twoja aplikacja ma już przyznane wymagane uprawnienia. Jeśli nie, użyj createRequestPermissionResultContract, aby poprosić o te uprawnienia. Wyświetli się ekran uprawnień Health Connect.

// Create the permissions launcher
val requestPermissionActivityContract = PermissionController.createRequestPermissionResultContract()

val requestPermissions = registerForActivityResult(requestPermissionActivityContract) { granted ->
  if (granted.containsAll(PERMISSIONS)) {
    // Permissions successfully granted
  } else {
    // Lack of required permissions
  }
}

suspend fun checkPermissionsAndRun(healthConnectClient: HealthConnectClient) {
  val granted = healthConnectClient.permissionController.getGrantedPermissions()
  if (granted.containsAll(PERMISSIONS)) {
    // Permissions already granted; proceed with inserting or reading data
  } else {
    requestPermissions.launch(PERMISSIONS)
  }
}

Użytkownicy mogą w dowolnym momencie przyznać lub wycofać uprawnienia, dlatego aplikacja musi okresowo sprawdzać, czy zostały one przyznane, oraz obsługiwać scenariusze, w których użytkownik wycofuje uprawnienia.

Źródła danych

Element MedicalDataSource w Health Connect reprezentuje dane pochodzące od użytkownika, np. od organizacji opieki zdrowotnej, szpitala lub interfejsu API.

Dokumentacja medyczna przechowywana w Health Connect jest uporządkowana w MedicalDataSource. Umożliwia to rozdzielenie danych medycznych dotyczących tej samej osoby, które pochodzą z różnych źródeł, takich jak interfejsy API czy systemy opieki zdrowotnej.

Jeśli wszystkie rekordy pochodzą z tego samego źródła, aplikacja do pisania musi utworzyć tylko jeden MedicalDataSource. Jeśli rekordy pochodzą z kilku źródeł, aplikacja może nadal tworzyć pojedynczy MedicalDataSource, jeśli dane zostaną uzgodnione, a wszystkie rekordy mają unikalną kombinację typu zasobu FHIR i identyfikatora zasobu FHIR. W przeciwnym razie dla każdego źródła danych należy utworzyć MedicalDataSource.

Wszystkie dane medyczne muszą być powiązane z poziomem MedicalDataSource, dlatego musisz go utworzyć przed zapisaniem zasobów.

Właściwości MedicalDataSource:

Wyświetlana nazwa (wymagany) – wyświetlana nazwa źródła danych, która jest jednoznacznie identyfikowana w poszczególnych aplikacjach do pisania.
URI podstawowe FHIR (wymagane) – w przypadku danych pochodzących z serwera FHIR powinien to być adres URL podstawowe FHIR (np. https://example.com/fhir/). Z tym samym adresem URL bazowym FHIR można powiązać wiele źródeł danych.

Jeśli dane są generowane przez aplikację bez adresu URL FHIR, powinien to być unikalny i zrozumiały identyfikator URI zdefiniowany przez aplikację (na przykład myapp://..), który wskazuje na źródło danych.

Jeśli na przykład aplikacja klienta obsługuje precyzyjne linki, można użyć takiego linku jako podstawowego identyfikatora URI FHIR. Maksymalna długość adresu URI to 2000 znaków.
Nazwa pakietu (wypełniana automatycznie) – aplikacja zapisująca dane.
Wersja FHIR (wymagane) – wersja FHIR. Musi to być obsługiwana wersja.

Tworzenie rekordu MedicalDataSource

Utwórz rekord dla każdej organizacji lub instytucji opieki zdrowotnej, z którą jest powiązana Twoja aplikacja.

// Create a `MedicalDataSource`
// Note that `displayName` must be unique across `MedicalDataSource`s
// Each `MedicalDataSource` is assigned an `id` by the system on creation
val medicalDataSource: MedicalDataSource =
    healthConnectClient.createMedicalDataSource(
        CreateMedicalDataSourceRequest(
            fhirBaseUri = Uri.parse("https://fhir.com/oauth/api/FHIR/R4/"),
            displayName = "Test Data Source",
            fhirVersion = FhirVersion(4, 0, 1)
        )
    )

Usuwanie rekordu MedicalDataSource

Poprzedni przykład zwraca id utworzone przez system. Jeśli chcesz usunąć rekord MedicalDataSource, odwołuj się do tego samego rekordu id:

// Delete the `MedicalDataSource` that has the specified `id`
healthConnectClient.deleteMedicalDataSourceWithData(medicalDataSource.id)

Zasoby medyczne

Element MedicalResource w Health Connect reprezentuje zasób FHIR (zawierający dane medyczne) wraz z metadanymi.

Właściwości MedicalResource:

DataSourceId (wymagany) – źródło danych opisane w sekcji MedicalDataSource.
Wersja FHIR (wymagane) – wersja FHIR. Musi to być obsługiwana wersja.
Zasób FHIR (wymagany) – instancja zasobu FHIR zakodowana w formacie JSON.
Typ zasobu medycznego (wypełniany automatycznie) – kategoria zasobu, która jest mapowana na uprawnienia użytkownika.

Przygotowywanie zasobów FHIR w formacie JSON

Zanim zapiszesz zasoby medyczne w Health Connect, przygotuj rekordy zasobów FHIR w formacie JSON. Przechowuj każdy plik JSON w osobnej zmiennej, aby wstawiać go jako zasób medyczny.

Jeśli potrzebujesz pomocy w przypadku formatu JSON FHIR, zapoznaj się z przykładowymi danymi udostępnionymi przez organizację HL7.

Wstawianie i aktualizowanie rekordów MedicalResource

Aby wstawić nowe rekordy UpsertMedicalResourceRequest lub zaktualizować istniejące rekordy MedicalResource w MedicalDataSource, użyj elementu UpsertMedicalResourceRequest:

// Insert `MedicalResource`s into the `MedicalDataSource`
val medicalResources: List<MedicalResource> =
    healthConnectClient.upsertMedicalResources(
        listOf(
            UpsertMedicalResourceRequest(
                medicalDataSource.id,
                medicalDataSource.fhirVersion,
                medicationJsonToInsert // a valid FHIR json string
            )
        )
    )

// Update `MedicalResource`s in the `MedicalDataSource`
val updatedMedicalResources: List<MedicalResource> =
    healthConnectClient.upsertMedicalResources(
        listOf(
            UpsertMedicalResourceRequest(
                medicalDataSource.id,
                medicalDataSource.fhirVersion,
                // a valid FHIR json string
                // if this resource has the same type and ID as in `medicationJsonToInsert`,
                // this `upsertMedicalResources()` call will update the previously inserted
                // `MedicalResource`
                updatedMedicationJsonToInsert
            )
        )
    )

Przykład zasobu FHIR

W poprzednim przykładzie zmienna medicationJsonToInsert reprezentowała prawidłowy ciąg JSON FHIR.

Oto przykład tego, jak może wyglądać plik JSON, który używa typu zasobu FHIR AllergyIntolerance jako typu zasobu medycznego FHIR_RESOURCE_TYPE_ALLERGY_INTOLERANCE w PHR:

{
  "resourceType": "AllergyIntolerance",
  "id": "allergyintolerance-1",
  "criticality": "high",
  "code": {
    "coding": [
      {
        "system": "http://snomed.info/sct",
        "code": "91936005",
        "display": "Penicillin allergy"
      }
    ],
    "text": "Penicillin allergy"
  },
  "recordedDate": "2020-10-09T14:58:00+00:00",
   "asserter": {
    "reference": "Patient/patient-1"
  },
  "lastOccurrence": "2020-10-09",
  "patient": {
    "reference": "Patient/patient-1",
    "display": "B., Alex"
  }
  ...
}

Usuwanie rekordu MedicalResource

Rekordy MedicalResource mogą zostać usunięte według identyfikatora:

// Delete `MedicalResource`s matching the specified `dataSourceId`, `type` and `fhirResourceId`
healthConnectClient.deleteMedicalResources(
    medicalResources.map { medicalResource: MedicalResource ->
        MedicalResourceId(
            dataSourceId = medicalDataSource.id,
            fhirResourceType = medicalResource.id.fhirResourceType,
            fhirResourceId = medicalResource.id.fhirResourceId
        )
    }
)

Mogą też zostać usunięte przez medicalResourceType:

// Delete all `MedicalResource`s that are in any pair of provided `dataSourceIds` and
// `medicalResourceTypes`
healthConnectClient.deleteMedicalResources(
    DeleteMedicalResourcesRequest(
        dataSourceIds = setOf(medicalDataSource.id),
        medicalResourceTypes = setOf(MEDICAL_RESOURCE_TYPE_MEDICATIONS)
    )
)