Se usó la API de Cloud Translation para traducir esta página.

Cómo escribir datos médicos
Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Esta guía es compatible con la versión 1.1.0-beta02 de Health Connect.

Para escribir datos médicos con registros de salud personales (PHR) en Health Connect, sigue estos pasos:

Cómo comprobar la disponibilidad de las funciones
Cómo solicitar permisos de escritura
Crea una fuente de datos (MedicalDataSource).
Escribe un recurso médico (MedicalResource)

Disponibilidad de funciones

Para determinar si el dispositivo de un usuario admite la PHR en Health Connect, verifica la disponibilidad de FEATURE_PERSONAL_HEALTH_RECORD en el cliente:

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

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

Consulta Cómo verificar la disponibilidad de las funciones para obtener más información.

Permisos necesarios

La escritura de datos médicos está protegida por el siguiente permiso:

android.permission.health.WRITE_MEDICAL_DATA

Declara estos permisos en Play Console para tu app, así como en el manifiesto de tu app:

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

Eres responsable de declarar todos los permisos adecuados que deseas usar en tus dispositivos y apps. También debes verificar que el usuario haya otorgado cada permiso antes de usarlo.

Cómo solicitar permisos al usuario

Después de crear una instancia de cliente, tu app debe solicitarle permisos al usuario. Los usuarios deben poder otorgar o rechazar permisos en cualquier momento.

Para hacerlo, crea un conjunto de permisos para los tipos de datos necesarios. Primero, asegúrate de que los permisos del conjunto se declaren en tu manifiesto de Android.

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

Usa getGrantedPermissions para ver si tu app ya tiene otorgados los permisos necesarios. De lo contrario, usa createRequestPermissionResultContract para solicitarlos. Se mostrará la pantalla de permisos de 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)
  }
}

Como los usuarios pueden otorgar o revocar permisos en cualquier momento, tu app necesita verificar en forma periódica los permisos otorgados y controlar situaciones en las que se pierde el permiso.

Fuentes de datos

Un MedicalDataSource en Health Connect representa una fuente de datos para el usuario, como una organización de atención médica, un hospital o una API.

Los registros médicos almacenados en Health Connect se organizan en un MedicalDataSource. Esto permite separar los registros médicos de la misma persona que provienen de diferentes fuentes, como APIs o sistemas de atención médica.

Si todos los registros provienen de la misma fuente, una app de escritura solo necesita crear un MedicalDataSource. Si los registros provienen de varias fuentes, una app puede crear un solo MedicalDataSource si se concilian esos datos y todos los registros tienen una combinación única de tipo de recurso y ID de recurso de FHIR. De lo contrario, se debe crear un MedicalDataSource para cada fuente de datos.

Todos los registros médicos deben estar asociados con un MedicalDataSource, por lo que se debe crear antes de escribir los recursos.

Propiedades de MedicalDataSource:

Nombre visible (obligatorio): Es el nombre visible para el usuario de la fuente de datos, que se identifica de forma única por app de escritura.
URI base de FHIR (obligatorio): Para los datos que provienen de un servidor de FHIR, esta debe ser la URL base de FHIR (por ejemplo, https://example.com/fhir/). Se pueden asociar varias fuentes de datos con la misma URL base de FHIR.

Si una app genera los datos sin una URL de FHIR, este debe ser un URI único y comprensible que defina la app (por ejemplo, myapp://..) que apunte a la fuente de los datos.

A modo de ejemplo, si una app cliente admite vínculos directos, este vínculo directo se puede usar como el URI base de FHIR. La longitud máxima del URI es de 2,000 caracteres.
Nombre del paquete (se propaga automáticamente): Es la app que escribe los datos.
Versión de FHIR (obligatoria): Es la versión de FHIR. Debe ser una versión compatible.

Crea un registro de MedicalDataSource

Crea un registro para cada organización o entidad de atención médica con la que esté vinculada tu app.

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

Cómo borrar un registro de MedicalDataSource

En el ejemplo anterior, el sistema muestra un id cuando se crea. Si necesitas borrar el registro MedicalDataSource, haz referencia a ese mismo id:

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

Recursos médicos

Un MedicalResource en Health Connect representa un recurso FHIR (que contiene un registro médico), junto con metadatos.

Propiedades de MedicalResource:

DataSourceId (obligatorio): Es la fuente de datos como se describe para un MedicalDataSource.
Versión de FHIR (obligatoria): Es la versión de FHIR. Debe ser una versión compatible.
Recurso de FHIR (obligatorio): Es la instancia del recurso de FHIR codificada en JSON.
Tipo de recurso médico (se completa automáticamente): Es la categoría para el usuario del recurso, que se asigna a los permisos para el usuario.

Prepara recursos de FHIR en JSON

Antes de escribir recursos médicos en Health Connect, prepara tus registros de recursos de FHIR en JSON. Almacena cada JSON en su propia variable para insertarlo como recurso médico.

Si necesitas ayuda con el formato JSON de FHIR, consulta los datos de ejemplo que proporciona la organización HL7.

Cómo insertar o actualizar registros de MedicalResource

Usa UpsertMedicalResourceRequest para insertar registros MedicalResource nuevos o actualizar los existentes de un 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
            )
        )
    )

Ejemplo de recurso de FHIR

En el ejemplo anterior, la variable medicationJsonToInsert representaba una cadena JSON de FHIR válida.

Este es un ejemplo de cómo se vería ese JSON, usando AllergyIntolerance como el tipo de recurso de FHIR, que se asignaría al tipo de recurso médico de FHIR_RESOURCE_TYPE_ALLERGY_INTOLERANCE en PHR:

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

Borra un registro de MedicalResource

Los registros de MedicalResource se pueden borrar por ID:

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

O bien, medicalResourceType puede borrarlos:

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