Diese Seite wurde von der Cloud Translation API übersetzt.

Medizinische Daten schreiben
Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Dieser Leitfaden ist mit der Health Connect-Version 1.1.0-beta02 kompatibel.

So schreiben Sie medizinische Daten mithilfe von persönlichen Gesundheitsakten (Personal Health Records, PHR) in Health Connect:

Verfügbarkeit von Funktionen prüfen
Schreibberechtigungen anfordern
Datenquelle erstellen (MedicalDataSource)
Medizinische Ressource verfassen (MedicalResource)

Verfügbarkeit der Funktion

Prüfe, ob das Gerät eines Nutzers PHR in Health Connect unterstützt. Dazu musst du die Verfügbarkeit von FEATURE_PERSONAL_HEALTH_RECORD auf dem Client prüfen:

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

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

Weitere Informationen finden Sie unter Verfügbarkeit von Funktionen prüfen.

Erforderliche Berechtigungen

Das Schreiben von medizinischen 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 und 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 außerdem prüfen, ob jede Berechtigung vor der Verwendung vom Nutzer erteilt wurde.

Berechtigungen vom Nutzer anfordern

Nachdem Sie eine Clientinstanz erstellt haben, muss Ihre App vom Nutzer Berechtigungen anfordern. Nutzer müssen jederzeit Berechtigungen 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
)

Mit getGrantedPermissions können Sie prüfen, ob Ihrer App bereits die erforderlichen Berechtigungen erteilt wurden. Andernfalls kannst du sie mit createRequestPermissionResultContract anfordern. Daraufhin 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 gewähren oder widerrufen können, muss Ihre App regelmäßig nach erteilten Berechtigungen suchen und mit Szenarien umgehen, in denen die Berechtigung verloren geht.

Datenquellen

Ein MedicalDataSource in Health Connect steht für eine nutzerorientierte Datenquelle, z. B. eine Gesundheitsorganisation, ein Krankenhaus oder eine API.

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

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

Alle Patientenakten müssen mit einer MedicalDataSource verknüpft sein. Diese muss also erstellt werden, bevor die Ressourcen geschrieben werden.

Eigenschaften von MedicalDataSource:

Anzeigename (erforderlich): Der für Nutzer sichtbare Anzeigename der Datenquelle, der für jede Schreib-App eindeutig ist.
FHIR-Basis-URI (erforderlich): Bei Daten, die von einem FHIR-Server stammen, 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, muss dies ein eindeutiger und verständlicher URI sein, der von der App definiert wurde (z. B. myapp://..), der 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 ausgefüllt): Die App, die die Daten schreibt.
FHIR-Version (erforderlich): Die FHIR-Version. Es muss sich um eine unterstützte Version handeln.

MedicalDataSource-Eintrag erstellen

Erstellen Sie einen Eintrag für jede Gesundheitsorganisation oder Entität, 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)
        )
    )

Datensatz „MedicalDataSource“ löschen

Im vorherigen Beispiel gibt das System beim Erstellen eine id zurück. Wenn Sie den MedicalDataSource-Eintrag löschen möchten, 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 (mit einem Patientendatensatz) zusammen mit Metadaten dar.

Eigenschaften von MedicalResource:

DataSourceId (erforderlich): Datenquelle wie für eine MedicalDataSource beschrieben.
FHIR-Version (erforderlich): Die FHIR-Version. Es muss sich um eine unterstützte Version handeln.
FHIR-Ressource (erforderlich): Die JSON-codierte Instanz der FHIR-Ressource.
Art der medizinischen Ressource (wird automatisch ausgefüllt): Die für Nutzer sichtbare Kategorie der Ressource, die Nutzerberechtigungen zugeordnet ist.

FHIR-Ressourcen in JSON vorbereiten

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

Wenn Sie Hilfe mit dem FHIR-JSON-Format benötigen, sehen Sie sich die Beispieldaten der HL7-Organisation an.

Einträge für „MedicalResource“ 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, wenn „AllergyIntolerance“ als FHIR-Ressourcentyp verwendet wird, der dem medizinischen Ressourcentyp FHIR_RESOURCE_TYPE_ALLERGY_INTOLERANCE in der Patientenakte zugeordnet ist:

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

Eintrag „MedicalResource“ löschen

MedicalResource-Einträge können anhand der 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
        )
    }
)

Sie können auch mit 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)
    )
)