Medizinische Daten schreiben

Dieser Leitfaden ist mit Health Connect-Version 1.1.0-beta02 oder höher kompatibel.

So schreiben Sie medizinische Daten mit „Krankenakte“ in Health Connect:

1. Verfügbarkeit von Funktionen überprü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 wird durch die folgende Berechtigung geschützt:

• android.permission.health.WRITE_MEDICAL_DATA

Deklariere diese Berechtigungen in der Play Console für deine App sowie im Manifest deiner App:

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

Du bist dafür verantwortlich, alle Berechtigungen anzugeben, die du auf deinen Geräten und in deinen Apps verwenden möchtest. Außerdem sollten Sie vor der Verwendung prüfen, ob die einzelnen Berechtigungen vom Nutzer gewährt wurden.

Berechtigungen vom Nutzer anfordern

Nachdem Sie eine Clientinstanz erstellt haben, muss Ihre App Berechtigungen vom Nutzer anfordern. Nutzer müssen Berechtigungen jederzeit erteilen oder verweigern können.

Erstellen Sie dazu eine Reihe von Berechtigungen für die erforderlichen Datentypen. Achten Sie darauf, dass die Berechtigungen in der Gruppe 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
)

Prüfen Sie mit getGrantedPermissions, ob Ihrer App bereits die erforderlichen Berechtigungen gewährt wurden. Wenn 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 vor jeder Verwendung die Berechtigungen prüfen und Szenarien verarbeiten, in denen die Berechtigung verloren geht.

Datenquellen

Eine 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 werden in einer MedicalDataSource organisiert. So können Krankenakten für dieselbe Person getrennt werden, die aus verschiedenen Quellen wie APIs oder Gesundheitssystemen stammen.

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 Eintrag eines FHIR-Ressourcentyps mit einer beliebigen FHIR-Ressourcen-ID geben.
• Andernfalls sollten Sie für jede Datenquelle eine MedicalDataSource erstellen, um doppelte IDs zu vermeiden.

Alle Krankenakten müssen mit einem MedicalDataSource verknüpft sein. Daher muss dieser vor dem Schreiben der Ressourcen erstellt werden.

Attribute von MedicalDataSource:

• Anzeigename (erforderlich): Für Nutzer sichtbarer Anzeigename für die Datenquelle, der pro schreibender App eindeutig identifiziert wird.

• FHIR-Basis-URI (erforderlich): Für Daten, die von einem FHIR-Server stammen, sollte dies die FHIR-Basis-URL sein (z. B. https://example.com/fhir/). Mehrere Datenquellen können mit derselben FHIR-Basis-URL verknüpft 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 des 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

Erstelle einen Eintrag für jede Gesundheitsorganisation oder -einrichtung, mit der deine 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-Eintrag löschen

Im vorherigen Beispiel wird bei der Erstellung ein 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

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

Attribute von MedicalResource:

• DataSourceId (erforderlich) – Datenquelle, wie für 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 für Nutzer sichtbare Kategorie der Ressource, die den für Nutzer sichtbaren Berechtigungen zugeordnet ist.

FHIR-Ressourcen in JSON vorbereiten

Bevor du medizinische Ressourcen in Health Connect schreibst, bereite deine FHIR-Ressourceneinträge im JSON-Format vor. 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, sehen Sie sich die Beispieldaten der HL7-Organisation an.

MedicalResource-Datensätze einfügen oder aktualisieren

Verwenden Sie UpsertMedicalResourceRequest, um neue MedicalResource-Einträge für eine MedicalDataSource einzufügen oder vorhandene zu 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 stellte die Variable medicationJsonToInsert einen gültigen FHIR-JSON-String dar.

Hier ist ein Beispiel dafür, wie diese JSON-Datei aussehen könnte. Dabei wird AllergyIntolerance als FHIR-Ressourcentyp verwendet, der dem medizinischen Ressourcentyp FHIR_RESOURCE_TYPE_ALLERGY_INTOLERANCE in Krankenakten zugeordnet wird:

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