Acompanhar o mindfulness

Este guia é compatível com a versão 1.1.0-rc01 da Conexão Saúde.

A Conexão Saúde oferece um tipo de dados de mindfulness para medir vários aspectos da saúde mental, como estresse e ansiedade. O mindfulness é um tipo de dados que faz parte do bem-estar geral na Conexão Saúde.

Verificar a disponibilidade da Conexão Saúde

Antes de tentar usar a Conexão Saúde, seu app precisa verificar se ela 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. Você pode verificar a disponibilidade usando o método HealthConnectClient.getSdkStatus().

Como verificar a disponibilidade da Conexão Saúde

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
}

Dependendo do status retornado por getSdkStatus(), você pode orientar o usuário a instalar ou atualizar a 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 os registros de sessão de mindfulness na Conexão Saúde, verifique a disponibilidade de FEATURE_MINDFULNESS_SESSION no cliente:

if (healthConnectClient
     .features
     .getFeatureStatus(
       HealthConnectFeatures.FEATURE_MINDFULNESS_SESSION
     ) == 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 ao mindfulness é protegido pelas seguintes permissões:

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

Para adicionar a capability de mindfulness ao app, comece solicitando permissões para o tipo de dados MindfulnessSession.

Confira a permissão necessária para poder gravar mindfulness:

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

Para ler mindfulness, é necessário solicitar as seguintes permissões:

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

Solicitar permissões do usuário

Depois de criar uma instância de cliente, seu app precisa solicitar permissões aos usuários. Eles 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. 

val permissions =
    setOf(
        HealthPermission.getReadPermission(MindfulnessSessionRecord::class),
        HealthPermission.getWritePermission(MindfulnessSessionRecord::class)
    )
 Use getGrantedPermissions para verificar se o app já tem as permissões necessárias concedidas. Caso contrário, use createRequestPermissionResultContract para solicitar essas permissões. 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 cenários em que elas são perdidas.

Informações incluídas em um registro de sessão de mindfulness

Cada registro de sessão de mindfulness captura qualquer tipo de sessão de mindfulness que um usuário realiza, por exemplo, meditação, respiração e movimento. O registro também pode incluir outras observações sobre a sessão.

Os seguintes tipos de sessão de mindfulness estão disponíveis para MindfulnessSessionRecord:

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

Para uma lista completa de tipos de sessão de mindfulness, consulte a MindfulnessSessionRecord documentação de referência.

Agregações aceitas

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

Gravar sessão de mindfulness

O snippet de código a seguir demonstra como gravar uma sessão de mindfulness:

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

Ler sessão de mindfulness

O snippet de código a seguir demonstra como ler uma sessão de mindfulness em um período:

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