Misurare la temperatura cutanea

Questa guida è compatibile con la versione 1.1.0-alpha12 di Health Connect.

Health Connect fornisce un tipo di dati temperatura cutanea per misurare la temperatura corporea periferica. Questa misurazione è un segnale particolarmente utile per rilevare la qualità del sonno, la salute riproduttiva e il potenziale insorgere di malattie.

Controlla la disponibilità di Health Connect

Prima di tentare di utilizzare Health Connect, la tua app deve verificare che Health Connect sia disponibile sul dispositivo dell'utente. Health Connect potrebbe non essere preinstallato su tutti i dispositivi o potrebbe essere disattivato. Puoi verificare la disponibilità utilizzando il metodo HealthConnectClient.getSdkStatus().

Come verificare la disponibilità di Health Connect

fun checkHealthConnectAvailability(context: Context) {
    val providerPackageName = "com.google.android.apps.healthdata" // Or get from HealthConnectClient.DEFAULT_PROVIDER_PACKAGE_NAME
    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
}

A seconda dello stato restituito da getSdkStatus(), puoi guidare l'utente all'installazione o all'aggiornamento di Connessione Salute dal Google Play Store, se necessario.

Disponibilità della funzionalità

Per determinare se il dispositivo di un utente supporta la temperatura cutanea su Connessione Salute, controlla la disponibilità di FEATURE_SKIN_TEMPERATURE sul client:

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

  // Feature is available
} else {
  // Feature isn't available
}
Per saperne di più, consulta Verifica la disponibilità delle funzionalità.

Autorizzazioni obbligatorie

L'accesso alla temperatura cutanea è protetto dalle seguenti autorizzazioni:

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

Per aggiungere la funzionalità di temperatura cutanea alla tua app, inizia richiedendo le autorizzazioni per il tipo di dati SkinTemperature.

Ecco l'autorizzazione che devi dichiarare per poter scrivere la temperatura cutanea:

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

Per leggere la temperatura cutanea, devi richiedere le seguenti autorizzazioni:

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

Richiedi le autorizzazioni all'utente

Dopo aver creato un'istanza client, la tua app deve richiedere le autorizzazioni all'utente. Gli utenti devono poter concedere o negare le autorizzazioni in qualsiasi momento. A questo scopo, crea un set di autorizzazioni per i tipi di dati richiesti. Assicurati che le autorizzazioni nel set siano dichiarate prima nel manifest di Android. 

val permissions =
    setOf(
        HealthPermission.getReadPermission(SkinTemperatureRecord::class),
        HealthPermission.getWritePermission(SkinTemperatureRecord::class)
    )
 Utilizza getGrantedPermissions per verificare se la tua app ha già le autorizzazioni richieste. In caso contrario, utilizza createRequestPermissionResultContract per richiedere queste autorizzazioni. Viene visualizzata la schermata delle autorizzazioni di Connessione Salute. 
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.") }
    }
}
 Poiché gli utenti possono concedere o revocare le autorizzazioni in qualsiasi momento, la tua app deve controllare le autorizzazioni ogni volta prima di utilizzarle e gestire gli scenari in cui l'autorizzazione viene revocata.

Informazioni incluse in un record di temperatura cutanea

Le misurazioni della temperatura cutanea sono organizzate in record. Ogni record è composto dalle seguenti informazioni:

  • Temperatura basale, in gradi Celsius o Fahrenheit. Si tratta di un valore facoltativo particolarmente utile per la visualizzazione nella UI della tua app.
  • Un elenco di variazioni della temperatura cutanea, ognuna delle quali mostra la variazione della temperatura cutanea rispetto all'ultima misurazione. Se viene fornita la temperatura basale, queste variazioni devono utilizzare le stesse unità di temperatura.
  • La posizione sul corpo dell'utente in cui è stata eseguita la misurazione: dito della mano, dito del piede o polso.

Aggregazioni supportate

I seguenti valori aggregati sono disponibili per SkinTemperatureRecord:

Esempio di utilizzo

Gli snippet di codice seguenti mostrano come leggere e scrivere le misurazioni della temperatura cutanea.

Leggi il record della temperatura cutanea

Lo snippet di codice seguente mostra come leggere le misurazioni della temperatura cutanea utilizzando la libreria 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.
    }
}

Scrivi un record della temperatura cutanea

Lo snippet di codice seguente mostra come scrivere le misurazioni della temperatura cutanea utilizzando la libreria 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)
                ),
            )
        )
    )
}