Seu primeiro app integrado ao app Conexão Saúde

1. Introdução

O que é o app Conexão Saúde?

O Conexão Saúde é uma plataforma de dados de saúde para desenvolvedores de apps Android. Ele oferece uma interface unificada e consolidada para acesso aos dados de saúde e condicionamento físico dos usuários, bem como um comportamento funcional consistente em todos os dispositivos. Com o app Conexão Saúde, os usuários têm um armazenamento seguro de dados de saúde e condicionamento físico no dispositivo, com controle total e transparência sobre o acesso.

Como o app Conexão Saúde funciona?

O Conexão Saúde oferece suporte a mais de 50 tipos e categorias de dados comuns de saúde e condicionamento físico, incluindo atividade, sono, nutrição, medidas corporais e sinais vitais, como frequência cardíaca e pressão arterial.

Com a permissão do usuário, os desenvolvedores podem ler e gravar no app Conexão Saúde com segurança usando esquemas padronizados e comportamento de API. Os usuários têm controle total sobre as próprias configurações de privacidade, com controles granulares para conferir quais apps solicitam acesso a dados a qualquer momento. Os dados no app Conexão Saúde são criptografados e ficam armazenados no dispositivo. Os usuários também podem desativar o acesso ou excluir os dados que não querem no dispositivo, além de priorizar uma única fonte de dados quando usam vários apps.

Arquitetura da Conexão Saúde

Confira a seguir uma explicação dos principais aspectos e componentes arquitetônicos do app Conexão Saúde:

• App cliente: para fazer a integração com a Conexão Saúde, o app cliente vincula o SDK ao app de saúde e fitness. Isso fornece uma superfície de API para interagir com a API Health Connect.
• Kit de desenvolvimento de software: o SDK permite que o app cliente se comunique com o APK da Conexão Saúde.
• APK da Conexão Saúde: é o APK que implementa a Conexão Saúde. Ele contém os componentes de gerenciamento de permissões e de dados. O APK do app Conexão Saúde é disponibilizado diretamente no dispositivo do usuário, com foco no dispositivo, e não na conta.
• Gerenciamento de permissões: o app Conexão Saúde inclui uma interface do usuário que outros apps podem usar para solicitar a permissão para mostrar dados. Ele também fornece uma lista das permissões existentes. Isso permite que os usuários gerenciem os acessos que concederam ou negaram a vários aplicativos.
• Gerenciamento de dados: o app Conexão Saúde oferece uma interface do usuário com uma visão geral dos dados gravados, sejam eles contagens de passos, velocidades de ciclismo, frequência cardíaca ou outros tipos de dados com suporte.

O que você vai criar

Neste codelab, você vai criar um app simples de saúde e condicionamento físico integrado ao Conexão Saúde. Seu app fará o seguinte:

• Conseguir e conferir as permissões do usuário para acessar os dados.
• Gravar dados no app Conexão Saúde.
• Ler dados agregados do app Conexão Saúde.

O que você vai aprender

• Como configurar seu ambiente para oferecer suporte ao desenvolvimento de integração do app Conexão Saúde.
• Como receber permissões e executar verificações de permissão.
• Como contribuir com dados de saúde e condicionamento físico para a plataforma Conexão Saúde.
• Como aproveitar o armazenamento de dados no dispositivo.
• Como validar seu app com as ferramentas para desenvolvedores fornecidas pelo Google.

O que é necessário

• Versão estável mais recente do Android Studio.
• Dispositivo móvel Android com o SDK do Android versão 28 (Pie) ou mais recente.

2. Etapas da configuração

Preparar a Conexão Saúde

O app Conexão Saúde é responsável por processar todas as solicitações enviadas pelo seu aplicativo usando o SDK. Essas solicitações incluem o armazenamento de dados e o gerenciamento do acesso de leitura e gravação.

O acesso à Conexão Saúde depende da versão do Android instalada no smartphone. As seções abaixo descrevem como lidar com várias versões recentes do Android.

Android 14

No Android 14 (nível 34 da API) e versões mais recentes, a Conexão Saúde faz parte do framework do Android. Como essa versão da Conexão Saúde é um módulo de framework, não é necessário fazer nenhuma configuração.

Android 13 e versões anteriores

No Android 13 (nível 33 da API) e versões anteriores, o app Conexão Saúde não faz parte do framework do Android. Você precisa instalar o app Conexão Saúde pela Google Play Store. Leia o QR code para instalar a Conexão Saúde.

Baixar o exemplo de código

Comece clonando o código-fonte no GitHub:

git clone https://github.com/android/android-health-connect-codelab.git

O diretório de exemplo contém os códigos start e finished deste codelab. Na visualização Project do Android Studio, você vai encontrar dois módulos:

• start: o código inicial deste projeto, em que você fará mudanças para concluir o codelab.
• finished: o código concluído deste codelab, que será usado para conferir seu trabalho.

Conhecer o código "inicial"

O app de exemplo do codelab tem interfaces básicas criadas pelo Jetpack Compose com as seguintes telas:

• WelcomeScreen: é a página de destino do app, que mostra mensagens diferentes dependendo da disponibilidade do app Conexão Saúde, esteja ele instalado, não instalado ou indisponível.
• PrivacyPolicyScreen: explica o uso de permissões do app que é mostrado quando o usuário clica no link Política de Privacidade na caixa de diálogo de permissões do app Conexão Saúde.
• InputReadingsScreen: demonstra a leitura e gravação de registros de peso simples.
• ExerciseSessionScreen: é onde os usuários inserem e listam as sessões de exercícios. Ao clicar na gravação, o usuário é direcionado a ExerciseSessionDetailScreen para conferir mais dados associados à sessão.
• DifferentialChangesScreen: demonstra como receber um token de mudanças e novas mudanças do app Conexão Saúde.

HealthConnectManager armazena todas as funções que interagem com o app Conexão Saúde. Neste codelab, vamos orientar você em todas as funcionalidades essenciais. As strings <!-- TODO: no build start têm seções correspondentes neste codelab em que os códigos de exemplo são fornecidos para você inserir no projeto.

Para começar, adicione o Conexão Saúde ao projeto.

Adicionar o SDK de cliente do app Conexão Saúde

Para começar a usar o SDK do app Conexão Saúde, é necessário adicionar uma dependência ao arquivo build.gradle. Para conferir a versão mais recente da Conexão Saúde, consulte a versão da biblioteca Jetpack.

dependencies {
    // Add a dependency of Health Connect SDK
    implementation "androidx.health.connect:connect-client:1.1.0-alpha10"
}

Declarar a visibilidade do app Conexão Saúde

Para interagir com Health Connect no app, declare o nome do pacote da Conexão Saúde no AndroidManifest.xml:

<!-- TODO: declare Health Connect visibility -->
<queries>
   <package android:name="com.google.android.apps.healthdata" />
</queries>

Executar o projeto inicial

Depois que tudo estiver definido, execute o projeto start. Agora, a tela de boas-vindas mostra a mensagem "O app Conexão Saúde está instalado neste dispositivo" e uma gaveta de menus. Vamos adicionar as funcionalidades para interagir com o app nas próximas seções.

3. Controle de permissões

O app Conexão Saúde recomenda que os desenvolvedores restrinjam as solicitações de permissão aos tipos de dados usados no app. Solicitações gerais reduzem a confiança do usuário. Se uma permissão for negada mais de duas vezes, o app será bloqueado. Como resultado, as solicitações de permissão não serão mais mostradas.

Para os fins deste codelab, vamos precisar apenas das seguintes permissões:

• Sessão de exercícios
• Frequência cardíaca
• Passos
• Calorias totais queimadas
• Peso

Declarar permissões

Todos os tipos de dados lidos ou gravados pelo app precisam ser declarados usando uma permissão no arquivo AndroidManifest.xml. A partir da versão 1.0.0-alpha10, a Conexão Saúde usa o formato de Declaração de permissões padrão do Android.

Para declarar as permissões dos tipos de dados obrigatórios, use os elementos <uses-permission> e atribua os respectivos nomes com as permissões. Aninhe as permissões nas tags <manifest>. Para a lista completa de permissões e os tipos de dados correspondentes, consulte a Lista de tipos de dados.

<!-- TODO: Required to specify which Health Connect permissions the app can request -->
  <uses-permission android:name="android.permission.health.READ_HEART_RATE"/>
  <uses-permission android:name="android.permission.health.WRITE_HEART_RATE"/>
  <uses-permission android:name="android.permission.health.READ_STEPS"/>
  <uses-permission android:name="android.permission.health.WRITE_STEPS"/>
  <uses-permission android:name="android.permission.health.READ_EXERCISE"/>
  <uses-permission android:name="android.permission.health.WRITE_EXERCISE"/>
  <uses-permission android:name="android.permission.health.READ_TOTAL_CALORIES_BURNED"/>
  <uses-permission android:name="android.permission.health.WRITE_TOTAL_CALORIES_BURNED"/>
  <uses-permission android:name="android.permission.health.READ_WEIGHT"/>
  <uses-permission android:name="android.permission.health.WRITE_WEIGHT"/>

Declare um filtro de intent em AndroidManifest.xml para processar a intent que explica como o app usa essas permissões. Seu app precisa processar essa intent e mostrar uma Política de Privacidade que descreva como os dados do usuário são usados e processados. Essa intent é enviada ao app quando o usuário toca no link Política de Privacidade na caixa de diálogo de permissões do app Conexão Saúde.

<!-- TODO: Add intent filter to handle permission rationale intent -->
<!-- Permission handling for Android 13 and before -->
<intent-filter>
  <action android:name="androidx.health.ACTION_SHOW_PERMISSIONS_RATIONALE" />
</intent-filter>

<!-- Permission handling for Android 14 and later -->
<intent-filter>
  <action android:name="android.intent.action.VIEW_PERMISSION_USAGE"/>
  <category android:name="android.intent.category.HEALTH_PERMISSIONS"/>
</intent-filter>

Agora, abra o app de novo para conferir as permissões declaradas. Clique em Configurações na gaveta de menus para acessar a tela de configurações do app Conexão Saúde. Em seguida, clique em Permissões do app e confira Codelab do Conexão Saúde na lista. Clique em Codelab do Conexão Saúde para abrir uma lista de tipos de dados para acesso de leitura e gravação nesse app.

Solicitar permissões

Além de direcionar os usuários para as configurações do app Conexão Saúde para gerenciar permissões, também é possível solicitar as permissões no seu app usando as APIs Health Connect. Os usuários podem mudar as permissões quando quiserem. Por isso, confira se o app verifica se as permissões necessárias estão disponíveis. No projeto do codelab, conferimos e enviamos solicitações de permissão antes de ler ou gravar dados.

HealthConnectClient é um ponto de entrada para a API Health Connect. No HealthConnectManager.kt, receba uma instância HealthConnectClient.

private val healthConnectClient by lazy { HealthConnectClient.getOrCreate(context) }

Para abrir a caixa de diálogo de pedido de permissões no aplicativo, crie um conjunto de permissões para os tipos de dados necessários. Solicite apenas o acesso aos tipos de dados que você vai usar.

Por exemplo, na tela Registrar peso, você só precisa de permissões de leitura e gravação de peso. Criamos um conjunto de permissões em InputReadingsViewModel.kt, conforme mostrado no código a seguir.

  val permissions = setOf(
    HealthPermission.getReadPermission(WeightRecord::class),
    HealthPermission.getWritePermission(WeightRecord::class),
  )

Em seguida, confira se as permissões foram concedidas antes de iniciar a solicitação de permissão. Em HealthConnectManager.kt, use getGrantedPermissions para conferir se a permissão do tipo de dado necessário foi concedida. Para iniciar a solicitação de permissão, é necessário criar um ActivityResultContract usando PermissionController.createRequestPermissionResultContract(), que será iniciado quando as permissões necessárias não forem concedidas.

  suspend fun hasAllPermissions(permissions: Set<String>): Boolean {
    return healthConnectClient.permissionController.getGrantedPermissions().containsAll(permissions)
  }

  fun requestPermissionsActivityContract(): ActivityResultContract<Set<String>, Set<String>> {
    return PermissionController.createRequestPermissionResultContract()
  }

No app de exemplo do codelab, o botão Solicitar permissões vai ser mostrado na tela caso o usuário não tenha concedido acesso aos tipos de dados necessários. Clique em Solicitar permissões para abrir a caixa de diálogo de permissão do app Conexão Saúde. Conceda as permissões necessárias e volte ao app do codelab.

4. Gravar dados

Vamos começar a gravar registros no app Conexão Saúde. Para gravar um registro de peso, crie um objeto WeightRecord com o valor de entrada de peso. O SDK do app Conexão Saúde oferece suporte a várias classes de unidades. Por exemplo, use Mass.kilograms(weightInput) para definir o peso dos usuários em quilogramas.

Todos os dados gravados no Conexão Saúde precisam especificar informações de deslocamento da zona. A especificação das informações de deslocamento da zona durante a gravação de dados fornece informações de fuso horário ao ler dados no Conexão Saúde.

Depois de criar o registro de peso, use healthConnectClient.insertRecords para gravar os dados.

/**
* TODO: Writes [WeightRecord] to Health Connect.
*/
suspend fun writeWeightInput(weightInput: Double) {
   val time = ZonedDateTime.now().withNano(0)
   val weightRecord = WeightRecord(
       weight = Mass.kilograms(weightInput),
       time = time.toInstant(),
       zoneOffset = time.offset
   )
   val records = listOf(weightRecord)
   try {
      healthConnectClient.insertRecords(records)
      Toast.makeText(context, "Successfully insert records", Toast.LENGTH_SHORT).show()
   } catch (e: Exception) {
      Toast.makeText(context, e.message.toString(), Toast.LENGTH_SHORT).show()
   }
}

Agora, execute o app. Clique em Registrar peso e insira um novo registro de peso em quilogramas. Para conferir se o registro de peso foi gravado, abra as configurações da Conexão Saúde e acesse Dados e acesso -> Medidas corporais -> Peso -> Todas as entradas. O novo registro de peso no codelab do app Conexão Saúde vai aparecer.

Gravar sessões de exercícios

Uma sessão é um intervalo de tempo em que um usuário realiza uma atividade. Uma sessão de exercícios no app Conexão Saúde pode incluir qualquer coisa, de corrida a badminton. As sessões permitem que os usuários meçam o desempenho com base no tempo. Esses dados registram uma matriz de amostras instantâneas medidas durante um período, como uma frequência cardíaca contínua ou amostras de localização durante uma atividade.

O exemplo a seguir mostra como criar uma sessão de exercícios. Use healthConnectClient.insertRecords para inserir vários registros de dados associados a uma sessão. A solicitação de inserção neste exemplo inclui ExerciseSessionRecord com ExerciseType, StepsRecord com contagem de passos, TotalCaloriesBurnedRecord com Energy e uma série de exemplos de HeartRateRecord.

  /**
   * TODO: Writes an [ExerciseSessionRecord] to Health Connect.
   */
  suspend fun writeExerciseSession(start: ZonedDateTime, end: ZonedDateTime) {
    healthConnectClient.insertRecords(
      listOf(
        ExerciseSessionRecord(
          startTime = start.toInstant(),
          startZoneOffset = start.offset,
          endTime = end.toInstant(),
          endZoneOffset = end.offset,
          exerciseType = ExerciseSessionRecord.EXERCISE_TYPE_RUNNING,
          title = "My Run #${Random.nextInt(0, 60)}"
        ),
        StepsRecord(
          startTime = start.toInstant(),
          startZoneOffset = start.offset,
          endTime = end.toInstant(),
          endZoneOffset = end.offset,
          count = (1000 + 1000 * Random.nextInt(3)).toLong()
        ),
        TotalCaloriesBurnedRecord(
          startTime = start.toInstant(),
          startZoneOffset = start.offset,
          endTime = end.toInstant(),
          endZoneOffset = end.offset,
          energy = Energy.calories((140 + Random.nextInt(20)) * 0.01)
        )
      ) + buildHeartRateSeries(start, end)
    )
  }

  /**
   * TODO: Build [HeartRateRecord].
   */
  private fun buildHeartRateSeries(
    sessionStartTime: ZonedDateTime,
    sessionEndTime: ZonedDateTime,
  ): HeartRateRecord {
    val samples = mutableListOf<HeartRateRecord.Sample>()
    var time = sessionStartTime
    while (time.isBefore(sessionEndTime)) {
      samples.add(
        HeartRateRecord.Sample(
          time = time.toInstant(),
          beatsPerMinute = (80 + Random.nextInt(80)).toLong()
        )
      )
      time = time.plusSeconds(30)
    }
    return HeartRateRecord(
      startTime = sessionStartTime.toInstant(),
      startZoneOffset = sessionStartTime.offset,
      endTime = sessionEndTime.toInstant(),
      endZoneOffset = sessionEndTime.offset,
      samples = samples
    )
  }

5. Ler dados

Agora que você já gravou registros de peso e sessão de exercícios com o app de exemplo do codelab e a caixa de ferramentas, vamos usar a API Health Connect para ler esses registros. Primeiro, crie uma ReadRecordsRequest e especifique o tipo de registro e o período de leitura. A ReadRecordsRequest também pode definir um dataOriginFilter para especificar o app de origem do registro que você quer ler.

    /**
     * TODO: Reads in existing [WeightRecord]s.
     */
    suspend fun readWeightInputs(start: Instant, end: Instant): List<WeightRecord> {
        val request = ReadRecordsRequest(
            recordType = WeightRecord::class,
            timeRangeFilter = TimeRangeFilter.between(start, end)
        )
        val response = healthConnectClient.readRecords(request)
        return response.records
    }

  /**
   * TODO: Obtains a list of [ExerciseSessionRecord]s in a specified time frame.
   */
  suspend fun readExerciseSessions(start: Instant, end: Instant): List<ExerciseSessionRecord> {
    val request = ReadRecordsRequest(
      recordType = ExerciseSessionRecord::class,
      timeRangeFilter = TimeRangeFilter.between(start, end)
    )
    val response = healthConnectClient.readRecords(request)
    return response.records
  }

Agora, execute o app e confira se você consegue encontrar uma lista de registros de peso e sessões de atividade física.

6. Ler dados em segundo plano

Declarar permissão

Para acessar dados de saúde em segundo plano, declare a permissão READ_HEALTH_DATA_IN_BACKGROUND no arquivo AndroidManifest.xml.

<!-- TODO: Required to specify which Health Connect permissions the app can request -->
...
<uses-permission android:name="android.permission.health.READ_HEALTH_DATA_IN_BACKGROUND" />

Verificar a disponibilidade dos recursos

Como os usuários nem sempre têm a versão mais recente do app Conexão Saúde, é melhor verificar primeiro a disponibilidade do recurso. No HealthConnectManager.kt, usamos o método getFeatureStatus para fazer isso.

fun isFeatureAvailable(feature: Int): Boolean{
    return healthConnectClient
      .features
      .getFeatureStatus(feature) == HealthConnectFeatures.FEATURE_STATUS_AVAILABLE
  }

A funcionalidade de leitura em segundo plano em ExerciseSessionViewModel.kt é verificada usando a constante FEATURE_READ_HEALTH_DATA_IN_BACKGROUND:

backgroundReadAvailable.value = healthConnectManager.isFeatureAvailable(
      HealthConnectFeatures.FEATURE_READ_HEALTH_DATA_IN_BACKGROUND
    )

Solicitar permissões

Depois de verificar se o recurso de leitura em segundo plano está disponível, solicite a permissão PERMISSION_READ_HEALTH_DATA_IN_BACKGROUND clicando em Solicitar leitura em segundo plano na tela Sessões de exercícios.

Os usuários vão receber a seguinte solicitação:

Os usuários também podem conceder acesso a leituras em segundo plano em Conexão Saúde > Permissões do app > Codelab do Conexão Saúde > Acesso adicional nas configurações do sistema:

Ler dados em segundo plano

Use WorkManager para programar tarefas em segundo plano. Ao tocar no botão Ler passos em segundo plano, o app vai iniciar o ReadStepWorker após um atraso de 10 segundos. Esse worker vai extrair a contagem total de passos do app Conexão Saúde nas últimas 24 horas. Em seguida, uma entrada de registro semelhante detalhando essas informações vai aparecer no Logcat:

There are 4000 steps in Health Connect in the last 24 hours.

7. Ler dados diferenciais

A API Differential Changes do app Conexão Saúde ajuda a monitorar mudanças de um conjunto de tipos de dados em um momento específico. Por exemplo, é possível saber se os usuários atualizaram ou excluíram algum registro atual fora do app para atualizar o banco de dados conforme necessário.

A leitura de dados com o Conexão Saúde é restrita a apps em execução em primeiro plano. Essa restrição está em vigor para proteger ainda mais a privacidade do usuário. Ela notifica e garante aos usuários que o app Conexão Saúde não tem acesso em segundo plano à leitura dos dados e que os dados são lidos e acessados apenas em primeiro plano. Quando o app está em primeiro plano, a API Differential Changes permite que os desenvolvedores extraiam as mudanças feitas no app Conexão Saúde implantando um token de mudanças.

Em HealthConnectManager.kt, há duas funções getChangesToken() e getChanges(). Vamos adicionar APIs Differential Changes a essas funções para receber mudanças de dados.

Configuração inicial do token de mudanças

As mudanças de dados são recuperadas do app Conexão Saúde somente quando o app as solicita com um token de mudanças. O token representa o ponto no histórico de confirmações em que dados diferenciais vão ser conseguidos.

Para receber um token de mudanças, envie uma ChangesTokenRequest com um conjunto de tipos de dados em que você quer acompanhar as mudanças. Guarde o token e use-o quando quiser extrair atualizações da Conexão Saúde.

  /**
   * TODO: Obtains a Changes token for the specified record types.
   */
  suspend fun getChangesToken(): String {
    return healthConnectClient.getChangesToken(
      ChangesTokenRequest(
        setOf(
          ExerciseSessionRecord::class
        )
      )
    )
  }

Atualização de dados com o token de mudanças

Quando você quiser conferir as mudanças desde a última vez que seu app foi sincronizado com a Conexão Saúde, use o token que você recebeu e envie em uma chamada getChanges. A ChangesResponse retorna uma lista de mudanças observadas na Conexão Saúde, como UpsertionChange e DeletionChange.

  /**
   * TODO: Retrieve changes from a Changes token.
   */
  suspend fun getChanges(token: String): Flow<ChangesMessage> = flow {
    var nextChangesToken = token
    do {
      val response = healthConnectClient.getChanges(nextChangesToken)
      if (response.changesTokenExpired) {
        throw IOException("Changes token has expired")
      }
      emit(ChangesMessage.ChangeList(response.changes))
      nextChangesToken = response.nextChangesToken
    } while (response.hasMore)
    emit(ChangesMessage.NoMoreChanges(nextChangesToken))
  }

Agora, execute o app e acesse a tela Mudanças. Primeiro, ative Acompanhar mudanças para receber um token de mudanças. Em seguida, insira os pesos ou as sessões de exercícios na caixa de ferramentas ou no app do codelab. Volte para a tela Mudanças e selecione Gerar novas mudanças. Agora, você verá as mudanças de inserção.

8. Dados agregados

o app Conexão Saúde também fornece dados usando APIs agregadas. Os exemplos a seguir mostram como receber dados cumulativos e estatísticos do app Conexão Saúde.

Use healthConnectClient.aggregate para enviar AggregateRequest. Na solicitação, especifique um conjunto de métricas agregadas e o período desejado. Por exemplo, ExerciseSessionRecord.EXERCISE_DURATION_TOTAL e StepsRecord.COUNT_TOTAL fornecem dados cumulativos, enquanto WeightRecord.WEIGHT_AVG, HeartRateRecord.BPM_MAX e HeartRateRecord.BPM_MIN fornecem dados estatísticos.

    /**
     * TODO: Returns the weekly average of [WeightRecord]s.
     */
    suspend fun computeWeeklyAverage(start: Instant, end: Instant): Mass? {
        val request = AggregateRequest(
            metrics = setOf(WeightRecord.WEIGHT_AVG),
            timeRangeFilter = TimeRangeFilter.between(start, end)
        )
        val response = healthConnectClient.aggregate(request)
        return response[WeightRecord.WEIGHT_AVG]
    }

Este exemplo mostra como conseguir os dados de agregação associados a uma sessão de exercícios específica. Primeiro, leia um registro usando healthConnectClient.readRecord com um uid. Em seguida, use o startTime e o endTime da sessão de exercícios como período e a dataOrigin como filtros para ler as agregações associadas.

  /**
   * TODO: Reads aggregated data and raw data for selected data types, for a given [ExerciseSessionRecord].
   */
  suspend fun readAssociatedSessionData(
      uid: String,
  ): ExerciseSessionData {
    val exerciseSession = healthConnectClient.readRecord(ExerciseSessionRecord::class, uid)
    // Use the start time and end time from the session, for reading raw and aggregate data.
    val timeRangeFilter = TimeRangeFilter.between(
      startTime = exerciseSession.record.startTime,
      endTime = exerciseSession.record.endTime
    )
    val aggregateDataTypes = setOf(
      ExerciseSessionRecord.EXERCISE_DURATION_TOTAL,
      StepsRecord.COUNT_TOTAL,
      TotalCaloriesBurnedRecord.ENERGY_TOTAL,
      HeartRateRecord.BPM_AVG,
      HeartRateRecord.BPM_MAX,
      HeartRateRecord.BPM_MIN,
    )
    // Limit the data read to just the application that wrote the session. This may or may not
    // be desirable depending on the use case: In some cases, it may be useful to combine with
    // data written by other apps.
    val dataOriginFilter = setOf(exerciseSession.record.metadata.dataOrigin)
    val aggregateRequest = AggregateRequest(
      metrics = aggregateDataTypes,
      timeRangeFilter = timeRangeFilter,
      dataOriginFilter = dataOriginFilter
    )
    val aggregateData = healthConnectClient.aggregate(aggregateRequest)
    val heartRateData = readData<HeartRateRecord>(timeRangeFilter, dataOriginFilter)

    return ExerciseSessionData(
      uid = uid,
      totalActiveTime = aggregateData[ExerciseSessionRecord.EXERCISE_DURATION_TOTAL],
      totalSteps = aggregateData[StepsRecord.COUNT_TOTAL],
      totalEnergyBurned = aggregateData[TotalCaloriesBurnedRecord.ENERGY_TOTAL],
      minHeartRate = aggregateData[HeartRateRecord.BPM_MIN],
      maxHeartRate = aggregateData[HeartRateRecord.BPM_MAX],
      avgHeartRate = aggregateData[HeartRateRecord.BPM_AVG],
      heartRateSeries = heartRateData,
    )
  }

Agora, execute o app e confira se você consegue ver o peso médio na tela Registrar peso. Você também pode ver os dados detalhados de uma sessão de exercícios abrindo a tela Sessões de exercícios e escolhendo um dos registros.

9. Parabéns

Parabéns! Você criou seu primeiro app de saúde e condicionamento físico integrado ao app Conexão Saúde.

Ele pode declarar e solicitar permissões do usuário em tipos de dados, além de ler e gravar dados no armazenamento do app Conexão Saúde. Você também aprendeu a usar a caixa de ferramentas do app Conexão Saúde para dar suporte ao desenvolvimento de apps criando dados simulados.

Agora você sabe as principais etapas necessárias para tornar seu app de saúde e condicionamento físico parte do ecossistema do app Conexão Saúde.

Leia mais

• Site para desenvolvedores do app Conexão Saúde
• Requisito da política do app Conexão Saúde
• Diretrizes para desenvolvedores de UX do app Conexão Saúde
• Caixa de ferramentas do app Conexão Saúde
• Kotlin
• Android Jetpack
• Android Jetpack Compose
• Android Jetpack: ViewModel