Desarrolla experiencias de signos vitales con Health Connect

Si deseas compilar una app que administre los datos vitales del usuario, puedes usar Health Connect para hacer lo siguiente:

• Leer datos vitales, como la presión arterial, la frecuencia cardíaca y la temperatura corporal, de otras apps
• Escribir datos vitales registrados por tu app o dispositivos conectados
• Supervisar tendencias y proporcionar estadísticas de salud basadas en datos vitales

En esta guía, se describe cómo trabajar con tipos de datos vitales, incluidos los permisos, los flujos de trabajo de lectura y escritura, y las prácticas recomendadas.

Descripción general: Cómo compilar un monitor integral de datos vitales

Para compilar una experiencia integral de seguimiento de datos vitales con Health Connect, sigue estos pasos principales:

• Solicita los permisos adecuados para los tipos de datos vitales.
• Escribe datos vitales con registros como BloodPressureRecord, HeartRateRecord y otros registros de datos vitales.
• Lee datos vitales para mostrarlos, analizarlos o sincronizarlos.
• Usa el procesamiento por lotes para escribir y leer datos de manera eficiente.

Este flujo de trabajo permite la interoperabilidad con otras apps de Health Connect y verifica el acceso a los datos controlados por el usuario.

Antes de comenzar

Antes de implementar funciones de datos vitales, haz lo siguiente:

• Integra Health Connect con la dependencia adecuada.
• Crea una instancia de HealthConnectClient.
• Verifica que tu app implemente flujos de permisos de tiempo de ejecución basados en Health Permissions.

Conceptos clave

Los datos vitales en Health Connect se representan con varios tipos de registros, cada uno correspondiente a una medición fisiológica específica. A diferencia de las sesiones de entrenamiento, los datos vitales suelen registrarse como datos de un momento determinado o basados en intervalos.

Tipos de datos vitales

Los datos vitales se representan con tipos de registros individuales. Entre los tipos comunes, se incluyen los siguientes:

• BloodPressureRecord: Representa una sola lectura de presión arterial, incluida la presión sistólica y diastólica, y la posición del cuerpo.
• HeartRateRecord: Representa una serie de mediciones de frecuencia cardíaca.
• RestingHeartRateRecord: Representa una sola medición de la frecuencia cardíaca en reposo.
• BodyTemperatureRecord: Representa una sola lectura de temperatura corporal, incluida la ubicación de la medición.
• BloodGlucoseRecord: Representa una sola lectura de glucemia, incluida la relación con la comida y la fuente de la muestra.
• OxygenSaturationRecord: Representa una sola lectura de saturación de oxígeno en sangre.
• RespiratoryRateRecord: Representa una sola medición de la frecuencia respiratoria.

Para obtener una lista completa de los tipos de datos, consulta Tipos de datos de Health Connect.

Consideraciones de desarrollo

Los datos vitales pueden ser sensibles, y es posible que las apps necesiten escribir datos en respuesta a las mediciones de los sensores o a la entrada del usuario, o sincronizar datos desde un backend. Los permisos son fundamentales para controlar los datos vitales.

Permisos

Tu app debe solicitar los permisos pertinentes de Health Connect antes de leer o escribir datos vitales. Entre los permisos comunes para los datos vitales, se incluyen la presión arterial, la frecuencia cardíaca, la temperatura corporal, la glucemia, la saturación de oxígeno y la frecuencia respiratoria. Se incluye lo siguiente:

• Presión arterial: Permisos de lectura y escritura para BloodPressureRecord.
• Frecuencia cardíaca: Permisos de lectura y escritura para HeartRateRecord.
• Frecuencia cardíaca en reposo: Permisos de lectura y escritura para RestingHeartRateRecord.
• Temperatura corporal: Permisos de lectura y escritura para BodyTemperatureRecord.
• Glucemia: Permisos de lectura y escritura para BloodGlucoseRecord.
• Saturación de oxígeno: Permisos de lectura y escritura para OxygenSaturationRecord.
• Frecuencia respiratoria: Permisos de lectura y escritura para RespiratoryRateRecord.

A continuación, se muestra un ejemplo de cómo solicitar permisos para la presión arterial, la frecuencia cardíaca y la temperatura corporal:

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
val PERMISSIONS =
    setOf(
  HealthPermission.getReadPermission(BloodPressureRecord::class),
  HealthPermission.getWritePermission(BloodPressureRecord::class),
  HealthPermission.getReadPermission(HeartRateRecord::class),
  HealthPermission.getWritePermission(HeartRateRecord::class),
  HealthPermission.getReadPermission(BodyTemperatureRecord::class),
  HealthPermission.getWritePermission(BodyTemperatureRecord::class)
)

Usa getGrantedPermissions para ver si tu app ya tiene otorgados los permisos necesarios. De lo contrario, usa createRequestPermissionResultContract para solicitar esos permisos. 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)
  }
}

Debido a que los usuarios pueden otorgar o revocar permisos en cualquier momento, tu app debe verificar los permisos cada vez antes de usarlos y controlar las situaciones en las que se pierden los permisos.

Para solicitar permisos, llama a la función checkPermissionsAndRun:

if (!granted.containsAll(PERMISSIONS)) {
    requestPermissions.launch(PERMISSIONS)
    // Check if required permissions are not granted, and return
  }
// Permissions already granted; proceed with inserting or reading data

Si solo necesitas solicitar permisos para un solo tipo de datos, como la presión arterial, incluye solo ese tipo de datos en tu conjunto de permisos:

El acceso a la presión arterial está protegido por los siguientes permisos:

• android.permission.health.READ_BLOOD_PRESSURE
• android.permission.health.WRITE_BLOOD_PRESSURE

Si deseas agregar la función de presión arterial a tu app, comienza por solicitar permisos para el tipo de datos BloodPressureRecord.

Este es el permiso que debes declarar para poder escribir la presión arterial:

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

Para leer la presión arterial, debes solicitar los siguientes permisos:

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

Escribe datos vitales

En esta sección, se describe cómo escribir datos vitales en Health Connect. Por lo general, los datos vitales se escriben como registros individuales. Si escribes varios registros a la vez, como la sincronización desde un sensor o backend, usa el procesamiento por lotes.

Ejemplo de escritura de un BloodPressureRecord:

suspend fun writeBloodPressureRecord(healthConnectClient: HealthConnectClient) {
    val record = BloodPressureRecord(
        time = Instant.now(),
        zoneOffset = ZoneOffset.UTC,
        systolic = Pressure.millimetersOfMercury(120.0),
        diastolic = Pressure.millimetersOfMercury(80.0),
        bodyPosition = BloodPressureRecord.BODY_POSITION_SITTING_DOWN,
        measurementLocation = BloodPressureRecord.MEASUREMENT_LOCATION_LEFT_WRIST
    )
    healthConnectClient.insertRecords(listOf(record))
}

Escritura por lotes

Si tu app necesita escribir varios datos, como sincronizar datos desde un dispositivo conectado o un servicio de backend, debes escribir por lotes para mejorar la eficiencia y reducir el consumo de batería. Health Connect puede controlar hasta 1,000 registros en una sola solicitud de escritura.

En el siguiente código, se muestra cómo escribir por lotes varios registros a la vez:

suspend fun writeBatchRecords(healthConnectClient: HealthConnectClient) {
    val bloodPressureRecord = BloodPressureRecord(
        time = Instant.now(),
        zoneOffset = ZoneOffset.UTC,
        systolic = Pressure.millimetersOfMercury(120.0),
        diastolic = Pressure.millimetersOfMercury(80.0),
        bodyPosition = BloodPressureRecord.BODY_POSITION_SITTING_DOWN,
        measurementLocation = BloodPressureRecord.MEASUREMENT_LOCATION_LEFT_WRIST
    )
    val heartRateRecord = HeartRateRecord(
        startTime = Instant.now().minusSeconds(60),
        startZoneOffset = ZoneOffset.UTC,
        endTime = Instant.now(),
        endZoneOffset = ZoneOffset.UTC,
        samples = listOf(HeartRateRecord.Sample(time = Instant.now().minusSeconds(30), beatsPerMinute = 80))
    )
    healthConnectClient.insertRecords(listOf(bloodPressureRecord, heartRateRecord))
}

Lee datos vitales

Las apps pueden leer datos vitales para mostrar mediciones, analizar tendencias o sincronizar datos con un servidor externo. Para leer datos vitales, usa un ReadRecordsRequest con el tipo de registro específico y filtra por un período.

Ejemplo de lectura de BloodPressureRecord datos:

suspend fun readBloodPressureRecords(
    healthConnectClient: HealthConnectClient,
    startTime: Instant,
    endTime: Instant
) {
    val response = healthConnectClient.readRecords(
        ReadRecordsRequest(
            recordType = BloodPressureRecord::class,
            timeRangeFilter = TimeRangeFilter.between(startTime, endTime)
        )
    )

    for (record in response.records) {
        // Process each blood pressure record
        val systolic = record.systolic
        val diastolic = record.diastolic
    }
}

Si necesitas sincronizar datos vitales con un servidor de backend o mantener actualizado el almacén de datos de tu app con Health Connect, usa ChangeLogs. Esto te permite recuperar una lista de registros insertados, actualizados o borrados desde un momento específico, lo que es más eficiente que hacer un seguimiento manual de los cambios o leer todos los datos de forma repetida. Para obtener más información, consulta Sincroniza datos con Health Connect.

Prácticas recomendadas

Sigue estos lineamientos para mejorar la confiabilidad de los datos y la experiencia del usuario:

• Frecuencia de escritura y procesamiento por lotes: Para reducir la sobrecarga de entrada/salida y preservar la duración de la batería, agrupa los datos en una sola insertRecords llamada con lotes de hasta 1,000 registros, en lugar de escribir cada punto de forma individual.
  • Seguimiento en vivo: Para obtener actualizaciones frecuentes de los sensores (como monitores continuos de glucosa o monitores cardíacos), escribe datos en lotes en intervalos de hasta 15 minutos para equilibrar las actualizaciones en tiempo real con la eficiencia de la batería.
  • Sincronización en segundo plano: Usa WorkManager para escrituras diferidas, como sincronizar datos desde un dispositivo complementario o un servicio de backend. Intenta usar un intervalo de 15 minutos para las escrituras por lotes.

• Evita escribir datos duplicados: Usa IDs de cliente. Cuando crees registros, establece un metadata.clientRecordId. Health Connect lo usa para identificar registros únicos. Si intentas escribir un registro con un clientRecordId que ya existe, Health Connect ignorará el duplicado o actualizará el registro existente en lugar de crear uno nuevo. Establecer un metadata.clientRecordId es la forma más eficaz de evitar duplicados durante los reintentos de sincronización o las reinstalaciones de apps.

  val record = BloodPressureRecord(
      time = Instant.now(),
      zoneOffset = ZoneOffset.UTC,
      systolic = Pressure.millimetersOfMercury(120.0),
      diastolic = Pressure.millimetersOfMercury(80.0),
      bodyPosition = BloodPressureRecord.BODY_POSITION_SITTING_DOWN,
      measurementLocation = BloodPressureRecord.MEASUREMENT_LOCATION_LEFT_WRIST,
      metadata = Metadata(
          // Use a unique ID from your own database
          clientRecordId = "bp_20240101_user123"
      )
  )

• Verifica los datos existentes: Antes de sincronizar los datos, consulta Health Connect para obtener registros dentro del período de sincronización y ver si ya existen datos de tu app para evitar duplicados o sobrescribir datos más recientes.

• Proporciona justificaciones claras para el permiso: Usa el flujo Permission.createIntent para explicar por qué tu app necesita acceder a datos de salud, como "Para supervisar las tendencias de tu presión arterial y proporcionar estadísticas".

• Alinea las marcas de tiempo con las mediciones: Verifica que las marcas de tiempo de los registros reflejen con precisión cuándo se tomaron las mediciones. Para los datos de intervalos como HeartRateRecord, verifica que startTime y endTime sean correctos.

Prueba

Para verificar la exactitud de los datos y una experiencia del usuario de alta calidad, sigue estas estrategias de prueba y consulta la documentación oficial de Test top use cases.

Herramientas de verificación

• Health Connect Toolbox: Usa esta app complementaria para inspeccionar registros de forma manual, borrar datos de prueba y simular cambios en la base de datos. Es la mejor manera de verificar que tus registros se almacenen correctamente.
• Pruebas unitarias con FakeHealthConnectClient: Usa la biblioteca de pruebas para verificar cómo controla tu app los casos extremos, como la revocación de permisos o las excepciones de la API sin necesidad de un dispositivo físico.

Lista de verificación de calidad

Arquitectura típica

Por lo general, una implementación de datos vitales incluye lo siguiente:

Solución de problemas

Pasos comunes de depuración