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

Zapisywanie danych medycznych

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

Aby zapisać dane medyczne za pomocą funkcji Dokumentacja medyczna w Health Connect:

Sprawdzanie dostępności funkcji
Prośba o uprawnienia do zapisu
Tworzenie źródła danych (MedicalDataSource)
Napisz artykuł medyczny (MedicalResource)

Dostępność funkcji

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

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 tym uprawnieniem:

android.permission.health.WRITE_MEDICAL_DATA

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

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

Odpowiadasz za zadeklarowanie wszystkich odpowiednich uprawnień, których zamierzasz używać na urządzeniach i w aplikacjach. Przed użyciem sprawdź też, czy użytkownik przyznał każde uprawnienie.

Prośba użytkownika o uprawnienia

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. Sprawdź, czy uprawnienia w zestawie są najpierw 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 przyznawać i wycofywać uprawnienia, dlatego aplikacja musi okresowo sprawdzać, czy uprawnienia zostały przyznane, i obsługiwać sytuacje, w których uprawnienia zostaną utracone.

Źródła danych

MedicalDataSource w Health Connect to źródło danych widoczne dla użytkownika, np. organizacja opieki zdrowotnej, szpital lub interfejs API.

Dokumentacja medyczna przechowywana w Health Connect jest uporządkowana w MedicalDataSource. Umożliwia to rozdzielenie dokumentacji medycznej tej samej osoby pochodzącej 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 element MedicalDataSource. Jeśli rekordy pochodzą z wielu źródeł, aplikacja może utworzyć pojedynczy MedicalDataSource, jeśli dane są 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 dokumenty medyczne muszą być powiązane z MedicalDataSource, dlatego przed zapisaniem zasobów należy go utworzyć.

Właściwości MedicalDataSource:

Wyświetlana nazwa (wymagana) – wyświetlana nazwa źródła danych widoczna dla użytkownika, niepowtarzalna w przypadku każdej aplikacji do pisania.
Podstawowy identyfikator URI FHIR (wymagany) – w przypadku danych pochodzących z serwera FHIR powinien to być podstawowy adres URL FHIR (np. https://example.com/fhir/). Z tym samym podstawowym adresem URL 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ę (np. myapp://..), który wskazuje źródło danych.

Jeśli na przykład aplikacja kliencka obsługuje precyzyjne linki, ten precyzyjny link może być używany jako podstawowy identyfikator URI FHIR. Maksymalna długość identyfikatora URI to 2000 znaków.
Nazwa pakietu (wypełniana automatycznie) – aplikacja zapisująca dane.
Wersja FHIR (wymagana) – wersja FHIR. Musi to być obsługiwana wersja.

Tworzenie rekordu MedicalDataSource

Utwórz rekord dla każdej organizacji lub podmiotu medycznego, z którym połączona jest 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

W poprzednim przykładzie system zwraca wartość id podczas tworzenia. Jeśli chcesz usunąć rekord MedicalDataSource, odwołaj się do tego samego rekordu id:

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

Materiały medyczne

MedicalResource w Health Connect reprezentuje zasób FHIR (który zawiera dokumentację medyczną) wraz z metadanymi.

Właściwości MedicalResource:

DataSourceId (wymagane) – źródło danych opisane w przypadku MedicalDataSource.
Wersja FHIR (wymagana) – 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 widoczna dla użytkownika zasobu, która jest mapowana na uprawnienia widoczne dla użytkownika.

Przygotowywanie zasobów FHIR w formacie JSON

Przed zapisaniem zasobów medycznych w Health Connect przygotuj rekordy zasobów FHIR w formacie JSON. Każdy plik JSON przechowuj w osobnej zmiennej, aby wstawić go jako zasób medyczny.

Jeśli potrzebujesz pomocy z formatem JSON FHIR, zapoznaj się z przykładami danych udostępnionymi przez organizację HL7.

Wstawianie lub aktualizowanie rekordów MedicalResource

Użyj ikony UpsertMedicalResourceRequest, aby wstawić nowe lub zaktualizować istniejące rekordy MedicalResource w przypadku MedicalDataSource:

// 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ładowy zasób FHIR

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

Oto przykład, jak może wyglądać taki plik JSON. Jako typ zasobu FHIR użyto AllergyIntolerance, który w dokumentacji medycznej jest mapowany na typ zasobu medycznego FHIR_RESOURCE_TYPE_ALLERGY_INTOLERANCE:

{
  "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

MedicalResource rekordy 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
        )
    }
)

Może je też usunąć 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)
    )
)