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.
Fazer o download do exemplo de código
O diretório de exemplo contém os códigos "start" e "finished" para este codelab. Na visualização Project do Android Studio, você 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 aExerciseSessionDetailScreenpara 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.0.0-alpha11"
}
Declarar a visibilidade do app Conexão Saúde
Para interagir com a Conexão Saúde 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 ele 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 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: declare Health Connect permissions -->
<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 -->
<intent-filter>
<action android:name="androidx.health.ACTION_SHOW_PERMISSIONS_RATIONALE" />
</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. Caixa de ferramentas do app Conexão Saúde
Introdução à caixa de ferramentas do app Conexão Saúde
A caixa de ferramentas do app Conexão Saúde é uma ferramenta para desenvolvedores complementar que permite testar a integração do seu app. Ela pode ler e gravar dados diretamente no app Conexão Saúde, permitindo que você teste as operações CRUD do seu app.
Neste codelab, vamos usar a caixa de ferramentas do app Conexão Saúde para testar as funcionalidades de leitura e gravação que você acabou de implementar.
Configurar a caixa de ferramentas do app Conexão Saúde
Extraia a pasta ZIP para acessar os arquivos APK. Em seguida, para instalar o APK da caixa de ferramentas em um dispositivo conectado, use adb. Navegue até a pasta em que o APK está localizado e execute o seguinte comando:
$ adb install HealthConnectToolbox-{Version Number}.apk
Na primeira vez que você abrir a caixa de ferramentas do app Conexão Saúde, vai acessar as configurações de permissão em Apps > Acesso especial para apps > Sobrepor a outros apps. Com essa permissão, a caixa de ferramentas pode mostrar uma sobreposição para que você teste a leitura e a gravação de dados sem sair do app em desenvolvimento.
Para gerenciar as permissões de leitura e gravação para testes, abra o app Conexão Saúde na tela principal do app da caixa de ferramentas ou acesse diretamente o fluxo de permissão.
Ler e gravar históricos de saúde
A caixa de ferramentas oferece suporte à leitura e gravação de todos os tipos de dados da Conexão Saúde. Na última sessão do codelab, você gravou registros de peso e da sessão de exercícios no app Conexão Saúde. Confira se você consegue ler os dados na caixa de ferramentas.
Antes de ler e gravar no app Conexão Saúde, é preciso receber a permissão do usuário. O mesmo acontece com a caixa de ferramentas. Primeiro, aceite a solicitação de permissão na caixa de ferramentas da Conexão Saúde. Em seguida, clique no ícone de pesquisa 
no menu de sobreposição para abrir a caixa de diálogo, selecione o tipo de dados, por exemplo, Peso, e clique em LER HISTÓRICO DE SAÚDE. Os registros adicionados à Conexão Saúde podem ser encontrados no app de exemplo do codelab.
Para inserir um registro na Conexão Saúde, clique no ícone de edição 
no menu de sobreposição para abrir a caixa de diálogo. Em seguida, selecione o tipo de dados. Vamos inserir um registro de peso usando a caixa de ferramentas. Na próxima sessão, vamos mostrar como ler o registro usando a API Health Connect e conferir os dados no app.
6. 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.
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.