Medir a temperatura da pele

Este guia é compatível com a versão 1.1.0-alpha12 do Health Connect.

A Conexão Saúde oferece um tipo de dados de temperatura da pele para medir a temperatura corporal periférica. Essa medição é um indicador particularmente útil para detectar a qualidade do sono, a saúde reprodutiva e o possível início de uma doença.

Disponibilidade do recurso

Para determinar se o dispositivo de um usuário é compatível com a temperatura da pele no Conexão Saúde, verifique a disponibilidade de FEATURE_SKIN_TEMPERATURE no cliente:

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

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

Consulte Verificar a disponibilidade de recursos para saber mais.

Permissões necessárias

O acesso à temperatura da pele é protegido pelas seguintes permissões:

  • android.permission.health.READ_SKIN_TEMPERATURE
  • android.permission.health.WRITE_SKIN_TEMPERATURE

Para adicionar a capability de temperatura da pele ao app, comece solicitando permissões de gravação do tipo de dado SkinTemperature.

Confira a permissão necessária para poder gravar a temperatura da pele:

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

Para ler a temperatura da pele, solicite as seguintes permissões:

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

Solicitar permissões do usuário

Depois de criar uma instância de cliente, seu app precisa solicitar permissões do usuário. Os usuários precisam poder conceder ou negar permissões a qualquer momento.

Para isso, crie um conjunto de permissões para os tipos de dados necessários. Verifique se as permissões no conjunto foram declaradas primeiro no manifesto do Android.

// Create a set of permissions for required data types
val PERMISSIONS =
    setOf(
  HealthPermission.getReadPermission(SkinTemperatureRecord::class),
  HealthPermission.getWritePermission(SkinTemperatureRecord::class)
)

Use getGrantedPermissions para verificar se o app já tem as permissões necessárias concedidas. Caso contrário, use createRequestPermissionResultContract para solicitar essas permissões. Isso mostra a tela de permissões da Conexão Saúde.

// 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 os usuários podem conceder ou revogar permissões a qualquer momento, seu app precisa verificar periodicamente as permissões concedidas e lidar com cenários em que a permissão é perdida.

Informações incluídas em um registro de temperatura da pele

As medições de temperatura da pele são organizadas em registros. Cada registro consiste nas seguintes informações:

  • Temperatura basal, em graus Celsius ou Fahrenheit. Esse é um valor opcional, mais útil para visualização na interface do usuário do app.
  • Uma lista de deltas na temperatura da pele, cada um mostrando a mudança na temperatura da pele desde a última medição. Se a temperatura de referência for fornecida, esses deltas vão usar as mesmas unidades de temperatura.
  • O local no corpo do usuário em que a medição foi feita: dedo da mão, dedo do pé ou pulso.

Agregações compatíveis

Não há agregações compatíveis para esse tipo de dado.

Exemplo de uso

Leia ou grave medições de temperatura da pele usando a biblioteca JetPack.

Ler temperatura da pele

O snippet de código a seguir mostra como ler medições de temperatura da pele usando a biblioteca Jetpack:

suspend fun readSkinTemperatures() {
    // Error handling, permission check, and feature availability check
    // aren't included.

    // Record includes measurements during the past hour.
    val recordEndTime = Instant.now()
    val recordStartTime = recordEndTime.minusSeconds(60 * 60)

    val response = healthConnectClient.readRecords(
        ReadRecordsRequest<SkinTemperatureRecord>(
            timeRangeFilter = TimeRangeFilter.between(
                recordStartTime, recordEndTime
            )
        )
    )

    for (skinTemperatureRecord in response.records) {
        // Process each skin temperature record here.
    }
}

Gravar temperatura da pele

O snippet de código a seguir mostra como gravar medições de temperatura da pele usando a biblioteca Jetpack:


suspend fun writeSkinTemperatures(): InsertRecordsResponse {
    // Error handling, permission check, and feature availability check
    // aren't included.

    // Record includes measurements during the past hour.
    val recordEndTime: ZonedDateTime = now()
    val recordStartTime: ZonedDateTime = recordEndTime.minusHours(1)

    healthConnectClient.insertRecords(
        // For this example, there's only one skin temperature record.
        listOf(
            SkinTemperatureRecord(
                baseline = Temperature.celsius(37.0),
                startTime = recordStartTime.toInstant(),
                startZoneOffset = recordStartTime.offset,
                endTime = recordEndTime.toInstant(),
                endZoneOffset = recordEndTime.offset,
                deltas = listOf(
                    SkinTemperatureRecord.Delta(
                        recordEndTime.minusMinutes(50).toInstant(), celsius(0.5)
                    ), SkinTemperatureRecord.Delta(
                        recordEndTime.minusMinutes(30).toInstant(), celsius(-0.7)
                    )
                ),
                measurementLocation = SkinTemperatureRecord.MEASUREMENT_LOCATION_FINGER,
                metadata = Metadata.autoRecorded(
                    device = Device(type = Device.TYPE_RING)
                ),
            )
        )
    )
}