Medir a temperatura da pele

Este guia é compatível com a versão 1.1.0-alpha12 ou mais recente do app Conexão Saúde.

O 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.

Verificar a disponibilidade do app Conexão Saúde

Antes de tentar usar o Conexão Saúde, seu app precisa verificar se ele está disponível no dispositivo do usuário. A Conexão Saúde pode não estar pré-instalada em todos os dispositivos ou pode estar desativada. É possível verificar a disponibilidade usando o método HealthConnectClient.getSdkStatus().

Como verificar a disponibilidade do Conexão Saúde

fun checkHealthConnectAvailability(context: Context) {
    val providerPackageName = "com.google.android.apps.healthdata"
    val availabilityStatus = HealthConnectClient.getSdkStatus(context, providerPackageName)

    if (availabilityStatus == HealthConnectClient.SDK_UNAVAILABLE) {
      // Health Connect is not available. Guide the user to install/enable it.
      // For example, show a dialog.
      return // early return as there is no viable integration
    }
    if (availabilityStatus == HealthConnectClient.SDK_UNAVAILABLE_PROVIDER_UPDATE_REQUIRED) {
      // Health Connect is available but requires an update.
      // Optionally redirect to package installer to find a provider, for example:
      val uriString = "market://details?id=$providerPackageName&url=healthconnect%3A%2F%2Fonboarding"
      context.startActivity(
        Intent(Intent.ACTION_VIEW).apply {
          setPackage("com.android.vending")
          data = Uri.parse(uriString)
          putExtra("overlay", true)
          putExtra("callerId", context.packageName)
        }
      )
      return
    }
    // Health Connect is available, obtain a HealthConnectClient instance
    val healthConnectClient = HealthConnectClient.getOrCreate(context)
    // Issue operations with healthConnectClient
}

Dependendo do status retornado por getSdkStatus(), você pode orientar o usuário a instalar ou atualizar o Conexão Saúde na Google Play Store, se necessário.

Disponibilidade do recurso

Para determinar se o dispositivo de um usuário é compatível com a temperatura da pele no app 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 o recurso de temperatura da pele ao app, comece solicitando permissões para o tipo de dados 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, é necessário solicitar 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 aos usuários. Os usuários precisam concedê-las ou negá-las a qualquer momento. Para fazer isso, crie um conjunto de permissões para os tipos de dados necessários. Verifique se as permissões no conjunto foram declaradas no manifesto do Android primeiro. 

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 solicitá-las. Isso mostra a tela de permissões da Conexão Saúde. 
val permissions = setOf(
        HealthPermission.getReadPermission(StepsRecord::class),
        HealthPermission.getWritePermission(StepsRecord::class),
        HealthPermission.getReadPermission(HeartRateRecord::class),
        HealthPermission.getWritePermission(HeartRateRecord::class)
    )

val requestPermissionsLauncher = rememberLauncherForActivityResult(
    contract = PermissionController.createRequestPermissionResultContract()
) { grantedPermissions ->
    if (grantedPermissions.containsAll(permissions)) {
        coroutineScope.launch { snackbarHostState.showSnackbar("Permissions granted!") }
    } else {
        coroutineScope.launch { snackbarHostState.showSnackbar("Permissions denied.") }
    }
}
 Como os usuários podem conceder ou revogar permissões a qualquer momento, seu app precisa verificar as permissões sempre antes de usá-las e lidar com situações em que elas são perdidas.

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

Agregações compatíveis

Os seguintes valores agregados estão disponíveis para SkinTemperatureRecord:

Exemplo de uso

Os snippets de código abaixo mostram como ler e gravar medições de temperatura da pele.

Ler registro de temperatura da pele

O snippet de código abaixo demonstra como ler uma medição 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 um registro de temperatura da pele

O snippet de código abaixo mostra como gravar medições de temperatura da pele usando a biblioteca do 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)
                ),
            )
        )
    )
}