Google Fit — o que é, arquitetura da plataforma e API

O que é Google Fit?

Google Fit é uma plataforma de gerenciamento de saúde lançada pelo Google em 2014 na conferência I/O. A plataforma fornece uma API unificada para ler e escrever dados de atividade física, permitindo que aplicativos troquem informações através de um repositório central na nuvem do Google.

Ao contrário de soluções proprietárias, o Google Fit funciona no sistema operacional Android e iOS via REST API. Os usuários podem conectar pulseiras de fitness, smartwatches e aplicativos de rastreamento de atividade, e o Google Fit agrega todos os dados em um único perfil de saúde no Google Cloud.

De acordo com o Google I/O 2024, a plataforma é usada em mais de 5000 aplicativos em todo o mundo, com mais de 100 milhões de usuários ativos. A plataforma é integrada ao Wear OS e suporta todos os rastreadores de fitness populares através de aplicativos de terceiros.

Arquitetura do Google Fit

A arquitetura do Google Fit é construída em três camadas: SDK do cliente, armazenamento em nuvem Google Fitness Store e REST API para integração de servidores. O SDK do cliente está disponível para Android (Kotlin, Java) e iOS (Swift, Objective-C), e também há um cliente web via JavaScript.

Os dados são organizados como fontes (DataSource) e pontos de dados (DataPoint). Cada fonte representa um dispositivo ou aplicativo, e cada ponto de dados representa uma única medição com um timestamp. Grupos de pontos de dados são combinados em sessões — períodos contínuos de atividade com um tipo e duração.

val fitnessClient = Fitness.getClient(activity, GoogleSignIn
    .getAccountForExtension(activity, fitnessOptions))

val stepType = DataType.TYPE_STEP_COUNT_DELTA

val request = DataReadRequest.Builder()
    .read(stepType)
    .setTimeRange(
        startTime, endTime, TimeUnit.MILLISECONDS
    )
    .build()

fitnessClient.readData(request)
    .addOnSuccessListener { response ->
        for (bucket in response.buckets) {
            println(bucket.dataSets)
        }
    }

Como funciona o Google Fit

Google Fit usa um modelo de sincronização através do Google Cloud com suporte para modos online e offline. O aplicativo grava dados localmente, e o Google Fit SDK sincroniza automaticamente com o armazenamento em nuvem quando há conexão com a internet. Conflitos são resolvidos pelo princípio da última gravação.

Cada tipo de dado tem um formato padronizado: passos — TYPE_STEP_COUNT_DELTA, calorias — TYPE_CALORIES_EXPENDED, frequência cardíaca — TYPE_HEART_RATE_BPM, distância — TYPE_DISTANCE_DELTA. Para tipos personalizados, você pode criar DataType personalizados através do console Google APIs com um namespace único.

A plataforma suporta dois modos de gravação: ativo — o aplicativo chama explicitamente HistoryClient.insertData(), e passivo — via RecordingClient, que se inscreve na coleta de dados em segundo plano. O modo passivo é conveniente para aplicativos de fitness: o usuário inicia o aplicativo uma vez, e o Google Fit coleta automaticamente passos, calorias e distância enquanto o aplicativo está minimizado, sem uso constante da CPU.

De acordo com o Google, a plataforma processa mais de 2 bilhões de pontos de dados diariamente. A latência média de sincronização é de 5 a 10 segundos com conexão ativa, e no modo de segundo plano a sincronização ocorre a cada 30 minutos para economizar bateria.

Consentimento do usuário e segurança

O Google Fit usa OAuth 2.0 para autorização com escopos de acesso fitness.activity.read, fitness.activity.write, fitness.body.read e fitness.body.write. O aplicativo solicita apenas os escopos necessários, e o usuário confirma o acesso através da caixa de diálogo padrão do Google Sign-In com seleção de conta.

O usuário pode revogar o acesso a qualquer momento através de Google Account Permissions ou do aplicativo Google Fit. O Google proíbe estritamente compartilhar dados de saúde com terceiros sem consentimento explícito, bem como usar dados para fins publicitários de acordo com a política Restricted Scopes.

APIs do Google Fit

Google Fit fornece três APIs principais: Fitness API para ler e escrever dados históricos, Sensors API para transmissão de dados em tempo real dos sensores, e Sessions API para gerenciar sessões de atividade. Cada API está disponível tanto através do SDK Android quanto por requisições REST.

Fitness API é a API principal para trabalhar com dados. Ela suporta operações em lote: gravação de até 1000 pontos de dados em uma única chamada, leitura com filtragem por intervalo de tempo, tipo de dado e origem. Para agregação de dados, é usado DataSet com agrupamento por métricas selecionadas.

Sensors API permite inscrever-se em dados de sensores em tempo real — passos, frequência cardíaca, aceleração. Os dados são recebidos via SensorEventListener com uma frequência determinada pelo tipo de sensor e configurações do aplicativo.

Além das três APIs principais, o Google Fit fornece Recording API para coleta automática de dados sem precisar manter o aplicativo ativo. Esta API é especialmente valiosa para Wear OS: smartwatches podem coletar dados de frequência cardíaca e atividade, e o aplicativo do telefone sincroniza com eles quando conectado. A Recording API usa o Google Fit Background Services, otimizados para consumo mínimo de energia — até 2% de bateria por dia com coleta passiva de passos.

REST API do Google Fit está disponível no endpoint fitness.googleapis.com. A REST API permite que aplicativos de servidor leiam e escrevam dados em nome do usuário após autorização OAuth. Isso é útil para painéis de análise web, programas de fitness corporativos e sistemas médicos que exigem armazenamento centralizado de dados de saúde de funcionários ou pacientes.

val recordingClient = Fitness
    .getRecordingClient(activity, googleSignInAccount)

recordingClient.subscribe(DataType.TYPE_STEP_COUNT_DELTA)
    .addOnSuccessListener {
        println("Assinatura ativa")
    }

// Obtendo dados do histórico
val historyClient = Fitness
    .getHistoryClient(activity, googleSignInAccount)

val endTime = Calendar.getInstance().timeInMillis
val startTime = endTime - TimeUnit
    .DAYS.toMillis(7)

historyClient.readDailyTotal(DataType.TYPE_STEP_COUNT_DELTA)
    .addOnSuccessListener { total ->
        println("Passos hoje: $total")
    }

Integrando o Google Fit em um aplicativo

A integração do Google Fit começa com a adição de dependências do Google Fit SDK via build.gradle: com.google.android.gms:play-services-fitness. Depois, é necessário configurar o console Google APIs — criar um projeto, habilitar a Fitness API e adicionar credenciais OAuth 2.0 com as impressões digitais SHA-1 corretas.

O processo de integração inclui: inicializar o GoogleSignIn com os escopos necessários, criar um FitnessClient via Fitness.getClient(), solicitar autorização do usuário e realizar operações de leitura ou gravação de dados. Para gravação em segundo plano, é usado o RecordingClient, que coleta dados automaticamente mesmo quando o aplicativo está minimizado. O Google Fit gerencia automaticamente a frequência de coleta de dados com base no nível da bateria e na atividade do usuário.

De acordo com o Google, aplicativos com integração Google Fit mostram 35% mais retenção de usuários. As categorias de aplicativos principais são rastreadores de fitness, aplicativos de corrida, ciclismo, ioga e controle de peso.

É importante considerar os requisitos de privacidade: o Google Fit usa Restricted Scopes — escopos de acesso especiais que exigem verificação separada do aplicativo através do OAuth Verification. O desenvolvedor deve descrever quais dados são coletados, como são usados e por quanto tempo são armazenados. O Google também exige uma política de privacidade e conformidade com os API Services Terms of Service.

Exemplo prático de gravação

Para gravar dados, é criado um DataSource especificando o tipo, dispositivo e aplicativo. Em seguida, é formado um DataPoint com um timestamp e valores. Múltiplos DataPoints são combinados em um DataSet, que é passado para HistoryClient.write().

val dataSource = DataSource.Builder()
    .setAppPackageName(activity)
    .setDataType(DataType.TYPE_STEP_COUNT_DELTA)
    .setType(DataSource.TYPE_RAW)
    .build()

val stepCount = DataPoint.builder(dataSource)
    .setTimestamp(now, TimeUnit.MILLISECONDS)
    .setField(Field.FIELD_STEPS, 500)
    .build()

val dataSet = DataSet.builder(dataSource)
    .add(stepCount)
    .build()

historyClient.insertData(dataSet)
    .addOnSuccessListener {
        println("Dados salvos")
    }