Hauttemperatur messen

Diese Anleitung ist mit Health Connect-Version 1.1.0-alpha12 oder höher kompatibel.

Health Connect bietet den Datentyp Hauttemperatur, mit dem die periphere Körpertemperatur gemessen werden kann. Dieser Messwert ist besonders nützlich, um die Schlafqualität, den Zyklus und die mögliche Entstehung von Krankheiten zu erkennen.

Verfügbarkeit von Health Connect prüfen

Bevor du versuchst, Health Connect zu verwenden, sollte deine App prüfen, ob Health Connect auf dem Gerät des Nutzers verfügbar ist. Health Connect ist möglicherweise nicht auf allen Geräten vorinstalliert oder deaktiviert. Sie können die Verfügbarkeit mit der Methode HealthConnectClient.getSdkStatus() prüfen.

Verfügbarkeit von Health Connect prüfen

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
}

Je nach dem von getSdkStatus() zurückgegebenen Status kannst du den Nutzer bei Bedarf anleiten, Health Connect aus dem Google Play Store zu installieren oder zu aktualisieren.

Verfügbarkeit der Funktion

Um herauszufinden, ob das Gerät eines Nutzers die Hauttemperatur in Health Connect unterstützt, prüfen Sie, ob FEATURE_SKIN_TEMPERATURE auf dem Client verfügbar ist:

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

  // Feature is available
} else {
  // Feature isn't available
}
Weitere Informationen finden Sie unter Verfügbarkeit von Funktionen prüfen.

Erforderliche Berechtigungen

Der Zugriff auf die Hauttemperatur wird durch die folgenden Berechtigungen geschützt:

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

Wenn du deiner App die Funktion „Hauttemperatur“ hinzufügen möchtest, musst du zuerst Berechtigungen für den Datentyp SkinTemperature anfordern.

Hier ist die Berechtigung, die Sie deklarieren müssen, um „Hauttemperatur” schreiben zu können:

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

Wenn du die Hauttemperatur auslesen möchtest, musst du die folgenden Berechtigungen anfordern:

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

Berechtigungen vom Nutzer anfordern

Nachdem Sie eine Clientinstanz erstellt haben, muss Ihre App Berechtigungen vom Nutzer anfordern. Nutzer müssen Berechtigungen jederzeit erteilen oder verweigern können. Erstellen Sie dazu eine Reihe von Berechtigungen für die erforderlichen Datentypen. Achte darauf, dass die Berechtigungen in der Gruppe zuerst in deinem Android-Manifest deklariert werden. 

val permissions =
    setOf(
        HealthPermission.getReadPermission(SkinTemperatureRecord::class),
        HealthPermission.getWritePermission(SkinTemperatureRecord::class)
    )
 Mit getGrantedPermissions kannst du prüfen, ob deiner App bereits die erforderlichen Berechtigungen gewährt wurden. Falls nicht, verwenden Sie createRequestPermissionResultContract, um diese Berechtigungen anzufordern. Der Bildschirm mit den Health Connect-Berechtigungen wird angezeigt. 
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.") }
    }
}
 Da Nutzer Berechtigungen jederzeit erteilen oder widerrufen können, muss deine App vor jeder Verwendung prüfen, ob die Berechtigungen vorhanden sind, und Szenarien verarbeiten, in denen die Berechtigung verloren geht.

In einem Hauttemperatur-Eintrag enthaltene Informationen

Messungen der Hauttemperatur werden in Datensätzen organisiert. Jeder Eintrag besteht aus den folgenden Informationen:

  • Referenztemperatur in Grad Celsius oder Grad Fahrenheit. Dies ist ein optionaler Wert, der sich am besten für die Visualisierung auf der Benutzeroberfläche deiner App eignet.
  • Eine Liste der Deltas der Hauttemperatur, die jeweils die Änderung der Hauttemperatur seit der letzten Messung zeigen. Wenn die Referenztemperatur angegeben ist, sollten diese Deltas dieselben Temperatureinheiten verwenden.
  • Die Stelle am Körper des Nutzers, an der die Messung vorgenommen wurde: Finger, Zeh oder Handgelenk.

Unterstützte Aggregationen

Die folgenden aggregierten Werte sind für SkinTemperatureRecord verfügbar:

Nutzungsbeispiel

Die folgenden Code-Snippets zeigen, wie Messwerte zur Hauttemperatur gelesen und geschrieben werden.

Hauttemperaturaufzeichnung lesen

Das folgende Code-Snippet zeigt, wie Sie mit der Jetpack-Bibliothek Messwerte der Hauttemperatur lesen:

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

Hauttemperaturdatensatz schreiben

Das folgende Code-Snippet zeigt, wie Sie mit der Jetpack-Bibliothek Messwerte zur Hauttemperatur schreiben:


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