Começar a usar o app Conexão Saúde

Este guia mostra como você pode começar a usar o Conexão Saúde no seu app.

Etapa 1: preparar o app Conexão Saúde

O app Conexão Saúde é responsável por processar todas as solicitações que seu e apps enviados pelo SDK do app Conexão Saúde. 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

A partir do Android 14 (nível 34 da API), a Conexão Saúde faz parte do framework do Android. Essa versão da Conexão Saúde é um módulo de framework. Com não é necessário configurar.

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. Para isso, você precisa instalar o app Conexão Saúde na Google Play Store.

Se você integrou seu app à Conexão Saúde no Android 13 e versões anteriores e quer migrar para o Android 14, consulte Migrar do Android 13 para o 14.

Abra o app Conexão Saúde

O app Conexão Saúde não aparece mais na tela inicial por padrão. Para abrir a Conexão Saúde, acesse Configurações > Apps > Conexão Saúde ou adicione a Conexão Saúde ao menu Configurações rápidas.

Além disso, a Conexão Saúde exige que o usuário ative o bloqueio de tela com um PIN, padrão ou senha para que os dados de saúde armazenados na plataforma fiquem protegidos contra partes mal-intencionadas enquanto o dispositivo estiver bloqueado. Para definir um bloqueio de tela, vá para Configurações > Segurança > Bloqueio de tela.

Etapa 2: adicionar o SDK do app Conexão Saúde ao seu app

O SDK do app Conexão Saúde é responsável por usar a API para enviar solicitações ao realizar operações no repositório de dados nos Conectar.

Adicione a dependência do SDK do app Conexão Saúde ao arquivo build.gradle do módulo:

dependencies {
  ...
  implementation "androidx.health.connect:connect-client:1.1.0-alpha02"
  ...
}

Consulte as versões mais recentes do app Conexão Saúde.

Etapa 3: configurar o app

As seções a seguir explicam como configurar seu aplicativo para integração com o Conexão Saúde.

Declarar permissões

O acesso a dados de saúde e condicionamento físico é confidencial. O app Conexão Saúde implementa uma camada de segurança para operações de leitura e gravação, mantendo a confiança do usuário.

Declare permissões de leitura e gravação no arquivo AndroidManifest.xml com base em os tipos de dados necessários. Use o conjunto de permissões que você solicitou acesso depois de preencher o [formulário]{:.external}.

A Conexão Saúde usa o formato de declaração de permissão padrão do Android. Atribua permissões com as tags <uses-permission>. Aninhe as permissões nas tags <manifest>.

<manifest>
  <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"/>

  <application>
  ...
  </application>
</manifest>

Para conferir a lista completa de permissões e os tipos de dados correspondentes, consulte Lista de tipos de dados.

Mostrar a caixa de diálogo da Política de Privacidade do app

O manifesto do Android precisa ter uma atividade que mostre o Política de Privacidade, que é a justificativa do seu app para as permissões solicitadas, descrevendo como os dados do usuário são usados e tratados.

Declare essa atividade para processar o ACTION_SHOW_PERMISSIONS_RATIONALE. em que ele é enviado para o aplicativo quando o usuário clica Política de Privacidade na tela de permissões do app Conexão Saúde.

...
<application>
  ...
  <!-- For supported versions through Android 13, create an activity to show the rationale
       of Health Connect permissions once users click the privacy policy link. -->
  <activity
      android:name=".PermissionsRationaleActivity"
      android:exported="true">
    <intent-filter>
      <action android:name="androidx.health.ACTION_SHOW_PERMISSIONS_RATIONALE" />
    </intent-filter>
  </activity>

  <!-- For versions starting Android 14, create an activity alias to show the rationale
       of Health Connect permissions once users click the privacy policy link. -->
  <activity-alias
      android:name="ViewPermissionUsageActivity"
      android:exported="true"
      android:targetActivity=".PermissionsRationaleActivity"
      android:permission="android.permission.START_VIEW_PERMISSION_USAGE">
    <intent-filter>
      <action android:name="android.intent.action.VIEW_PERMISSION_USAGE" />
      <category android:name="android.intent.category.HEALTH_PERMISSIONS" />
    </intent-filter>
  </activity-alias>
  ...
</application>
...

Acessar um cliente da Conexão Saúde

O HealthConnectClient é um ponto de entrada para a API Health Connect. Ela permite que o app use o repositório de dados no app Conexão Saúde. Ela gerencia automaticamente a conexão com a camada de armazenamento subjacente e processa toda a IPC e a serialização das solicitações enviadas e das respostas recebidas.

Para acessar uma instância de cliente, declare o nome do pacote do app Conexão Saúde no seu o manifesto do Android primeiro.

<application> ... </application>
...
<!-- Check if Health Connect is installed -->
<queries>
    <package android:name="com.google.android.apps.healthdata" />
</queries>

Em seguida, na sua atividade, verifique se o Conexão Saúde está instalado usando getSdkStatus. Se estiver, acesse uma instância HealthConnectClient.

val availabilityStatus = HealthConnectClient.getSdkStatus(context, providerPackageName)
if (availabilityStatus == HealthConnectClient.SDK_UNAVAILABLE) {
  return // early return as there is no viable integration
}
if (availabilityStatus == HealthConnectClient.SDK_UNAVAILABLE_PROVIDER_UPDATE_REQUIRED) {
  // 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
}
val healthConnectClient = HealthConnectClient.getOrCreate(context)
// Issue operations with healthConnectClient

Etapa 4: solicitar permissões do usuário

Depois de criar uma instância cliente, seu aplicativo precisa solicitar permissões do usuário. Os usuários precisam ter permissão para conceder ou negar permissões a qualquer momento.

Para fazer isso, crie um conjunto de permissões para os tipos de dados necessários. Confirme se que as permissões no conjunto sejam declaradas no manifesto do Android primeiro.

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

Use getGrantedPermissions para ver se o app já tem o as permissões necessárias foram concedidas. Caso contrário, use createRequestPermissionResultContract para solicitar essas permissões. A tela de permissões do app Conexão Saúde aparece.

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

Não presuma que as permissões são constantes, porque os usuários podem conceder ou revogar a qualquer momento. O app precisa verificar periodicamente as permissões concedidas e processar cenários em que a permissão é perdida.

Etapa 5: realizar operações

Agora que tudo está pronto, realize operações de leitura e gravação no app.

Gravar dados

Estruture seus dados em um registro. Confira a lista de tipos de dados disponíveis no app Conexão Saúde.

val stepsRecord = StepsRecord(
    count = 120,
    startTime = START_TIME,
    endTime = END_TIME,
    startZoneOffset = START_ZONE_OFFSET,
    endZoneOffset = END_ZONE_OFFSET,
)

Em seguida, grave o registro usando insertRecords.

suspend fun insertSteps(healthConnectClient: HealthConnectClient) {
    try {
        val stepsRecord = StepsRecord(
            count = 120,
            startTime = START_TIME,
            endTime = END_TIME,
            startZoneOffset = START_ZONE_OFFSET,
            endZoneOffset = END_ZONE_OFFSET,
        )
        healthConnectClient.insertRecords(listOf(stepsRecord))
    } catch (e: Exception) {
        // Run error handling here
    }
}

Ler dados

É possível ler seus dados individualmente usando o readRecords.

suspend fun readStepsByTimeRange(
    healthConnectClient: HealthConnectClient,
    startTime: Instant,
    endTime: Instant
) {
    try {
        val response =
            healthConnectClient.readRecords(
                ReadRecordsRequest(
                    StepsRecord::class,
                    timeRangeFilter = TimeRangeFilter.between(startTime, endTime)
                )
            )
        for (stepRecord in response.records) {
            // Process each step record
        }
    } catch (e: Exception) {
        // Run error handling here.
    }
}

Você também pode ler seus dados de maneira agregada usando aggregate

suspend fun aggregateSteps(
    healthConnectClient: HealthConnectClient,
    startTime: Instant,
    endTime: Instant
) {
    try {
        val response = healthConnectClient.aggregate(
            AggregateRequest(
                metrics = setOf(StepsRecord.COUNT_TOTAL),
                timeRangeFilter = TimeRangeFilter.between(startTime, endTime)
            )
        )
        // The result may be null if no data is available in the time range
        val stepCount = response[StepsRecord.COUNT_TOTAL]
    } catch (e: Exception) {
        // Run error handling here
    }
}

Tutoriais em vídeo

Assista estes vídeos que explicam mais sobre os recursos do app Conexão Saúde. como diretrizes de práticas recomendadas para obter uma integração tranquila:

Recursos

Confira os recursos a seguir que ajudam no desenvolvimento mais tarde.

Próximas etapas

Confira os Fluxos de trabalho comuns para aprender a realizar operações na Conexão Saúde, como: