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

Wenn Sie prüfen möchten, ob das Gerät eines Nutzers Gesundheitsdaten in Health Connect unterstützt, sehen Sie nach, ob FEATURE_PERSONAL_HEALTH_RECORD auf dem Client verfügbar ist:

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

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

Weitere Informationen

Erforderliche Berechtigungen

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

  • android.permission.health.WRITE_MEDICAL_DATA

Erklären 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. Achten Sie darauf, dass die Berechtigungen im Set 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. Dadurch wird der Bildschirm mit den Health Connect-Berechtigungen 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

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 medizinische Daten für dieselbe Person, die aus verschiedenen Quellen wie APIs oder Gesundheitssystemen stammen, getrennt werden.

Wenn alle Datensätze aus derselben Quelle stammen, muss eine Schreib-App nur ein MedicalDataSource erstellen. Wenn Datensätze aus mehreren Quellen stammen, kann eine App trotzdem ein einzelnes MedicalDataSource erstellen, wenn die Daten abgeglichen werden und alle Datensätze eine eindeutige Kombination aus FHIR-Ressourcentyp und FHIR-Ressourcen-ID haben. Andernfalls sollte für jede Datenquelle ein MedicalDataSource erstellt werden.

Alle medizinischen Daten müssen mit einem MedicalDataSource verknüpft sein. Dieses muss also vor dem Schreiben der Ressourcen erstellt 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 der 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-Eintrag 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 ein 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 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 jedes JSON in einer eigenen Variablen, um es 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 stellte die Variable medicationJsonToInsert einen gültigen FHIR-JSON-String dar.

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