W 2026 r. zaczniemy wycofywać interfejsy Google Fit API. Więcej informacji o migracji z Google Fit znajdziesz w przewodniku po migracji.

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

Zapisywanie danych medycznych

Aby zapisywać dane medyczne za pomocą funkcji Dokumentacja medyczna w Health Connect, wykonaj te czynności:

Sprawdzanie dostępności funkcji
Wysyłanie prośby o uprawnienia do zapisu
Tworzenie źródła danych (MedicalDataSource)
Tworzenie zasobu medycznego (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 artykule 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 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 uprawnienia. 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.

Podczas tworzenia rekordów MedicalDataSource pamiętaj o tych kwestiach:

Jeśli wszystkie rekordy pochodzą z tego samego źródła, utwórz jeden MedicalDataSource.
Jeśli rekordy pochodzą z wielu źródeł, możesz utworzyć pojedynczy rekord MedicalDataSource, jeśli:
- Dane są uzgadniane.
- Wszystkie rekordy mają unikalną kombinację typu zasobu FHIR i identyfikatora zasobu FHIR. W MedicalDataSource może znajdować się tylko 1 rekord typu zasobu FHIR z dowolnym identyfikatorem zasobu FHIR.
W przeciwnym razie, aby zapobiec powielaniu identyfikatorów, utwórz MedicalDataSource dla każdego źródła danych.

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 musisz 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 powiązana z uprawnieniami widocznymi 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. Zapisz każdy plik JSON 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 UpsertMedicalResourceRequest, aby wstawić nowe lub zaktualizować istniejąceMedicalResource rekordy dla 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ć ten plik JSON. Użyto w nim typu zasobu FHIR AllergyIntolerance, który w dokumentacji medycznej odpowiada typowi 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 można usunąć 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)
    )
)