Medizinische Daten schreiben

Diese Anleitung ist mit Health Connect-Version 1.1.0-beta02 kompatibel.

So schreiben Sie medizinische Daten mit Medical Records in Health Connect:

1. Verfügbarkeit von Funktionen prüfen
2. Schreibberechtigungen anfordern
3. Datenquelle erstellen (MedicalDataSource)
4. Medizinische Ressource schreiben (MedicalResource)

Verfügbarkeit der Funktion

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

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

Erforderliche Berechtigungen

Das Schreiben medizinischer Daten ist durch die folgende Berechtigung geschützt:

• android.permission.health.WRITE_MEDICAL_DATA

Deklarieren Sie diese Berechtigungen in der Play Console für Ihre App sowie im Manifest Ihrer App:

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

Sie sind dafür verantwortlich, alle erforderlichen Berechtigungen anzugeben, die Sie auf Ihren Geräten und in Ihren Apps verwenden möchten. Sie sollten auch prüfen, ob jede Berechtigung vor der Verwendung vom Nutzer erteilt wurde.

Berechtigungen vom Nutzer anfordern

Nachdem Sie eine Client-Instanz erstellt haben, muss Ihre App Berechtigungen vom Nutzer anfordern. Nutzer müssen jederzeit die Möglichkeit haben, Berechtigungen zu erteilen oder zu verweigern.

Erstellen Sie dazu eine Reihe von Berechtigungen für die erforderlichen Datentypen. Die Berechtigungen im Set müssen zuerst in Ihrem Android-Manifest deklariert werden.

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

Mit getGrantedPermissions können Sie prüfen, ob Ihrer App bereits die erforderlichen Berechtigungen erteilt wurden. Falls nicht, verwenden Sie createRequestPermissionResultContract, um diese Berechtigungen anzufordern. Der Bildschirm mit den Health Connect-Berechtigungen wird angezeigt.

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

Da Nutzer Berechtigungen jederzeit erteilen oder widerrufen können, muss Ihre App regelmäßig prüfen, welche Berechtigungen erteilt wurden, und Szenarien berücksichtigen, in denen Berechtigungen verloren gehen.

Datenquellen

Ein MedicalDataSource in Health Connect stellt eine für Nutzer sichtbare Datenquelle dar, z. B. eine Gesundheitsorganisation, ein Krankenhaus oder eine API.

In Health Connect gespeicherte medizinische Daten sind in einer MedicalDataSource organisiert. So können Krankenakten für dieselbe Person, die aus verschiedenen Quellen wie APIs oder Gesundheitssystemen stammen, getrennt werden.

Beachten Sie beim Erstellen von MedicalDataSource-Einträgen Folgendes:

• Wenn alle Datensätze aus derselben Quelle stammen, erstellen Sie eine MedicalDataSource.
• Wenn Datensätze aus mehreren Quellen stammen, können Sie eine einzelne MedicalDataSource erstellen, wenn:
  • Die Daten werden abgeglichen.
  • Alle Datensätze haben eine eindeutige Kombination aus FHIR-Ressourcentyp und FHIR-Ressourcen-ID. In einem MedicalDataSource kann es nur einen Datensatz eines FHIR-Ressourcentyps mit einer beliebigen FHIR-Ressourcen-ID geben.
• Andernfalls müssen Sie für jede Datenquelle eine MedicalDataSource erstellen, um doppelte IDs zu vermeiden.

Alle Krankenakten müssen mit einem MedicalDataSource verknüpft sein. Dieses muss also erstellt werden, bevor die Ressourcen geschrieben werden.

Eigenschaften von MedicalDataSource:

• Anzeigename (erforderlich): Der für Nutzer sichtbare Anzeigename für die Datenquelle, der pro Schreib-App eindeutig ist.

• FHIR-Basis-URI (erforderlich): Bei Daten von einem FHIR-Server sollte dies die FHIR-Basis-URL sein (z. B. https://example.com/fhir/). Mehrere Datenquellen können derselben FHIR-Basis-URL zugeordnet werden.

  Wenn die Daten von einer App ohne FHIR-URL generiert werden, sollte dies ein eindeutiger und verständlicher URI sein, der von der App definiert wird (z. B. myapp://..) und auf die Quelle der Daten verweist.

  Wenn eine Client-App beispielsweise Deeplinks unterstützt, kann dieser Deeplink als FHIR-Basis-URI verwendet werden. Die maximale Länge für den URI beträgt 2.000 Zeichen.

• Paketname (wird automatisch eingefügt): Die App, die die Daten schreibt.

• FHIR-Version (erforderlich): Die FHIR-Version. Muss eine unterstützte Version sein.

MedicalDataSource-Eintrag erstellen

Erstellen Sie einen Datensatz für jede Gesundheitsorganisation oder ‑einrichtung, mit der Ihre App verknüpft ist.

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

MedicalDataSource-Datensatz löschen

Im vorherigen Beispiel wird beim Erstellen eine id vom System zurückgegeben. Wenn Sie den MedicalDataSource-Eintrag löschen müssen, verweisen Sie auf dieselbe id:

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

Medizinische Ressourcen

Ein MedicalResource in Health Connect stellt eine FHIR-Ressource (die eine medizinische Aufzeichnung enthält) zusammen mit Metadaten dar.

Eigenschaften von MedicalResource:

• DataSourceId (erforderlich): Datenquelle wie für eine MedicalDataSource beschrieben.
• FHIR-Version (erforderlich): Die FHIR-Version. Muss eine unterstützte Version sein.
• FHIR-Ressource (erforderlich): Die JSON-codierte FHIR-Ressourceninstanz.
• Typ der medizinischen Ressource (wird automatisch ausgefüllt): Die nutzerorientierte Kategorie der Ressource, die den nutzerorientierten Berechtigungen zugeordnet ist.

FHIR-Ressourcen in JSON vorbereiten

Bevor Sie medizinische Ressourcen in Health Connect schreiben, müssen Sie Ihre FHIR-Ressourcendatensätze in JSON vorbereiten. Speichern Sie jede JSON-Datei in einer eigenen Variablen, um sie als medizinische Ressource einzufügen.

Wenn Sie Hilfe zum FHIR-JSON-Format benötigen, finden Sie hier Beispieldaten der HL7-Organisation.

MedicalResource-Einträge einfügen oder aktualisieren

Mit UpsertMedicalResourceRequest können Sie neue MedicalResource-Datensätze für eine MedicalDataSource einfügen oder vorhandene aktualisieren:

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

Beispiel für eine FHIR-Ressource

Im vorherigen Beispiel war die Variable medicationJsonToInsert ein gültiger FHIR-JSON-String.

Hier sehen Sie ein Beispiel dafür, wie dieses JSON aussehen könnte. Als FHIR-Ressourcentyp wird „AllergyIntolerance“ verwendet, der dem medizinischen Ressourcentyp FHIR_RESOURCE_TYPE_ALLERGY_INTOLERANCE in Patientenakten entspricht:

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

MedicalResource-Datensatz löschen

MedicalResource-Einträge können nach ID gelöscht werden:

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

Oder sie können von medicalResourceType gelöscht werden:

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