Pomiar temperatury skóry

Ten przewodnik jest zgodny z Health Connect w wersji 1.1.0-alpha12.

Health Connect udostępnia typ danych temperatura skóry do pomiaru temperatury ciała na obwodzie. Ten pomiar jest szczególnie przydatny do wykrywania jakości snu, zdrowia reprodukcyjnego i potencjalnego początku choroby.

Dostępność funkcji

Aby sprawdzić, czy urządzenie użytkownika obsługuje pomiar temperatury skóry w Health Connect, sprawdź dostępność FEATURE_SKIN_TEMPERATURE na urządzeniu:

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

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

Więcej informacji znajdziesz w sekcji Sprawdzanie dostępności funkcji.

Wymagane uprawnienia

Dostęp do temperatury skóry jest chroniony przez te uprawnienia:

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

Aby dodać do aplikacji funkcję pomiaru temperatury skóry, zacznij od poproszenia o uprawnienia do zapisu w przypadku typu danych SkinTemperature.

Aby móc zapisywać temperaturę skóry, musisz zadeklarować to uprawnienie:

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

Aby odczytywać temperaturę skóry, musisz poprosić o te uprawnienia:

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

Prośba użytkownika o uprawnienia

Po utworzeniu instancji klienta aplikacja musi poprosić użytkownika o przyznanie uprawnień. Użytkownicy muszą mieć możliwość przyznania lub odmowy przyznania uprawnień w dowolnym momencie.

Aby to zrobić, utwórz zestaw uprawnień dla wymaganych typów danych. Sprawdź, czy uprawnienia w zestawie są najpierw zadeklarowane w pliku manifestu Androida.

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

Użyj getGrantedPermissions, aby sprawdzić, czy Twoja aplikacja ma już przyznane wymagane uprawnienia. Jeśli nie, użyj createRequestPermissionResultContract, aby poprosić o te uprawnienia. Wyświetli się ekran uprawnień 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)
  }
}

Użytkownicy mogą w dowolnym momencie przyznawać i wycofywać uprawnienia, dlatego aplikacja musi okresowo sprawdzać, czy uprawnienia zostały przyznane, i obsługiwać sytuacje, w których uprawnienia zostaną utracone.

Informacje zawarte w rekordzie temperatury skóry

Pomiary temperatury skóry są podzielone na rekordy. Każdy rekord zawiera te informacje:

  • Temperatura bazowa w stopniach Celsjusza lub Fahrenheita. Jest to wartość opcjonalna, która jest najbardziej przydatna do wizualizacji w interfejsie aplikacji.
  • Lista różnic w temperaturze skóry, z których każda pokazuje zmianę temperatury skóry od ostatniego pomiaru. Jeśli podano temperaturę bazową, te różnice powinny być wyrażone w tych samych jednostkach temperatury.
  • Lokalizacja na ciele użytkownika, w której dokonano pomiaru: palec u ręki, palec u nogi lub nadgarstek.

Obsługiwane agregacje

W przypadku tego typu danych nie ma obsługiwanych agregacji.

Przykład użycia

Odczytuj i zapisuj pomiary temperatury skóry za pomocą biblioteki Jetpack.

Odczytuj temperaturę skóry

Poniższy fragment kodu pokazuje, jak odczytywać pomiary temperatury skóry za pomocą biblioteki 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.
    }
}

Zapisuj temperaturę skóry

Poniższy fragment kodu pokazuje, jak zapisywać pomiary temperatury ciała za pomocą biblioteki 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)
                ),
            )
        )
    )
}