Śledzenie uważności

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

Health Connect udostępnia typ danych uważność , który umożliwia pomiar różnych aspektów zdrowia psychicznego, takich jak stres i niepokój. Uważność to typ danych, który jest częścią ogólnego samopoczucia w Health Connect.

Sprawdzanie dostępności Health Connect

Zanim spróbujesz użyć Health Connect, Twoja aplikacja powinna sprawdzić, czy Health Connect jest dostępny na urządzeniu użytkownika. Health Connect może nie być wstępnie zainstalowany na wszystkich urządzeniach lub może być wyłączony. Dostępność możesz sprawdzić za pomocą metody HealthConnectClient.getSdkStatus().

Jak sprawdzić dostępność 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
}

W zależności od stanu zwróconego przez getSdkStatus() możesz poprosić użytkownika o zainstalowanie lub zaktualizowanie Health Connect ze Sklepu Google Play.

Dostępność funkcji

Aby sprawdzić, czy urządzenie użytkownika obsługuje zapisy sesji uważności w Health Connect, sprawdź dostępność FEATURE_MINDFULNESS_SESSION na kliencie:

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

  // Feature is available
} else {
  // Feature isn't available
}
Więcej informacji znajdziesz w artykule Sprawdzanie dostępności funkcji.

Wymagane uprawnienia

Dostęp do uważności jest chroniony przez te uprawnienia:

  • android.permission.health.READ_MINDFULNESS
  • android.permission.health.WRITE_MINDFULNESS

Aby dodać do aplikacji funkcję uważności, zacznij od poproszenia o uprawnienia do typu danych MindfulnessSession.

Oto uprawnienie, które musisz zadeklarować, aby móc zapisywać dane o uważności:

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

Aby odczytać dane o uważności, musisz poprosić o te uprawnienia:

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

Prośba o uprawnienia od użytkownika

Po utworzeniu instancji klienta aplikacja musi poprosić użytkownika o uprawnienia. Użytkownicy muszą mieć możliwość przyznawania i odmawiania uprawnień w dowolnym momencie. Aby to zrobić, utwórz zbiór uprawnień dla wymaganych typów danych. Najpierw upewnij się, że uprawnienia w zbiorze są zadeklarowane w manifeście Androida. 

val permissions =
    setOf(
        HealthPermission.getReadPermission(MindfulnessSessionRecord::class),
        HealthPermission.getWritePermission(MindfulnessSessionRecord::class)
    )
 Użyj getGrantedPermissions , aby sprawdzić, czy Twoja aplikacja ma już wymagane uprawnienia. Jeśli nie, użyj createRequestPermissionResultContract aby poprosić o te uprawnienia. Spowoduje to wyświetlenie ekranu uprawnień Health Connect. 
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.") }
    }
}
 Ponieważ użytkownicy mogą przyznawać i cofać uprawnienia w dowolnym momencie, Twoja aplikacja musi sprawdzać uprawnienia za każdym razem przed ich użyciem i obsługiwać sytuacje, w których uprawnienia zostaną utracone.

Informacje zawarte w rekordzie sesji uważności

Każdy rekord sesji uważności rejestruje dowolny typ sesji uważności, np. medytację, oddychanie i ruch. Rekord może też zawierać dodatkowe notatki dotyczące sesji.

W przypadku MindfulnessSessionRecord dostępne są te typy sesji uważności:

  • MINDFULNESS_SESSION_TYPE_UNKNOWN
  • MINDFULNESS_SESSION_TYPE_MEDITATION
  • MINDFULNESS_SESSION_TYPE_BREATHING
  • MINDFULNESS_SESSION_TYPE_MUSIC
  • MINDFULNESS_SESSION_TYPE_MOVEMENT
  • MINDFULNESS_SESSION_TYPE_UNGUIDED

Pełną listę typów sesji uważności znajdziesz w MindfulnessSessionRecord dokumentacji.

Obsługiwane agregacje

W przypadku MindfulnessSessionRecord dostępne są te wartości zagregowane:

Zapisuj sesję uważności

Ten fragment kodu pokazuje, jak zapisać sesję uważności:

val isAvailable = healthConnectClient.features.getFeatureStatus(FEATURE_MINDFULNESS_SESSION)

if (isAvailable == HealthConnectFeatures.FEATURE_STATUS_AVAILABLE) {

    val record = MindfulnessSessionRecord(
        startTime = Instant.now().minus(Duration.ofHours(1)),
        startZoneOffset = ZoneOffset.UTC,
        endTime = Instant.now(),
        endZoneOffset = ZoneOffset.UTC,
        mindfulnessSessionType = MindfulnessSessionRecord.MINDFULNESS_SESSION_TYPE_MEDITATION,
        title = "Lake meditation",
        notes = "Meditation by the lake",
        metadata = Metadata(
            clientRecordId = "myid",
            clientRecordVersion = 1L,
            device = Device(type = Device.TYPE_PHONE)
        )
    )

Odczytuj sesję uważności

Ten fragment kodu pokazuje, jak odczytać sesję uważności w określonym przedziale czasu:

Val now = Instant.now()

val records = healthConnectClient.readRecords(
    ReadRecordsRequest(
        recordType = MindfulnessSessionRecord::class,
        timeRangeFilter = TimeRangeFilter.between(
            startTime = now.minus(Duration.ofHours(5)),
            endTime = now
        )
    )
)

// Process the returned records
records.records.forEach { session ->
    println("Mindfulness session:")
    println("Start: ${session.startTime}")
    println("End: ${session.endTime}")
    println("Title: ${session.title}")
    println("Notes: ${session.notes}")
    println("Type: ${session.mindfulnessSessionType}")
}