Bibliotecas de clientes

Esta página fornece links para maneiras convenientes de acessar a API Google Health.

Bibliotecas de cliente da API Google Health

A API Google Health foi criada com base em HTTP e JSON. Portanto, qualquer cliente HTTP padrão pode enviar solicitações a essa API e analisar as respostas.

No entanto, em vez de criar solicitações HTTP e analisar respostas manualmente, recomendamos o uso das bibliotecas de clientes das APIs do Google. As bibliotecas de cliente oferecem melhor integração de linguagens, mais segurança e compatibilidade com chamadas que exigem autorização do usuário.

Go

Acesse a biblioteca de cliente da API Google Health mais recente para Go () e leia o guia para desenvolvedores dela.

Java

Esta página contém informações sobre os primeiros passos com a API Google Health usando a biblioteca de cliente de APIs do Google para Java. Para saber mais, consulte a seguinte documentação:

Adicionar a biblioteca de cliente ao projeto

Selecione o ambiente de build (Maven ou Gradle) nas guias abaixo:

JavaScript

Leia o guia do desenvolvedor da biblioteca de cliente.

.NET

Esta página contém informações sobre os primeiros passos com a API Google Health usando a biblioteca de cliente de APIs do Google para .NET. Para mais informações, consulte a seguinte documentação:

Como fazer o download da biblioteca

Instale o pacote NuGet: Google.Apis.

Node.js

Acesse a biblioteca de cliente da API Google Health mais recente para Node.js. Leia o guia para desenvolvedores da biblioteca de cliente.

Obj-C

Acesse a biblioteca de cliente da API Google Health mais recente para Objective-C. Leia o guia para desenvolvedores da biblioteca de cliente.

PHP

Acesse a biblioteca de cliente da API Google Health mais recente para PHP. Leia o guia para desenvolvedores da biblioteca de cliente.

Python

Esta página contém informações sobre os primeiros passos com a API Google Health usando a biblioteca de cliente de APIs do Google para Python (v1/v2). Para saber mais, consulte a seguinte documentação:

Requisitos do sistema

Instalar a biblioteca de cliente

Você pode usar um gerenciador de pacotes ou fazer o download e instalar a biblioteca de cliente do Python manualmente:

Instalação gerenciada

Use pip ou setuptools para gerenciar sua instalação. Talvez seja necessário executar primeiro : Talvez seja necessário executar sudo primeiro.

  • pip (preferencial): 
    pip install --upgrade google-api-python-client
  • Setuptools: 
    easy_install --upgrade google-api-python-client

Instalação manual

  1. Faça o download da biblioteca de cliente mais recente para Python.
  2. Descompacte o código.
  3. Instalar: 
    python setup.py install

App Engine

Como as bibliotecas de cliente do Python não estão instaladas no ambiente de execução do App Engine para Python, é preciso copiá-las no aplicativo da mesma forma que as bibliotecas de terceiros.

Ruby

Esta página contém informações sobre os primeiros passos com a API Google Health usando a biblioteca de cliente de APIs do Google para Ruby. Para saber mais, consulte a seguinte documentação:

Instalar a gem google-api-client

Dependendo do sistema, talvez seja necessário prefixar esses comandos com sudo.

Se você nunca instalou a biblioteca de cliente da API do Google para Ruby, faça isso usando RubyGems: 

gem install google-api-client

Caso você já tenha a gem instalada, atualize para a versão mais recente: 

gem update -y google-api-client

Primeiros passos com a biblioteca de cliente de APIs do Google para Ruby

Para saber como fazer sua primeira solicitação, consulte o guia de iniciação.

gRPC

A API Google Health também oferece suporte a gRPC para recuperação de dados de alta performance. Além de instalar bibliotecas de cliente, o uso do gRPC exige a obtenção das definições de Protocol Buffers da API e a geração de código de stub do lado do cliente antes de fazer solicitações.

  1. Instalar bibliotecas gRPC:
    • Use pip install grpcio grpcio-tools google-auth-oauthlib para instalar dependências.
  2. Gerar código do cliente:
    • Obtenha as definições da API Google Health .proto (por exemplo, data_points.proto).
    • Execute python -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. path/to/your/data_points.proto para gerar código de stub.
  3. Implementar o OAuth 2.0 e fazer solicitações gRPC:
    • Use google-auth-oauthlib para autorização e o stub do cliente gerado para fazer solicitações gRPC, conforme mostrado no exemplo a seguir.
import google.auth
from google.auth.transport.grpc import secure_authorized_channel
from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
import os
import json
import grpc

# Generated gRPC code from data_points.proto
# These imports depend on the output of grpc_tools
try:
    import data_points_pb2
    import data_points_pb2_grpc
except ImportError:
    print("Please generate gRPC code from data_points.proto")
    data_points_pb2 = None
    data_points_pb2_grpc = None

# --- REPLACE WITH YOUR VALUES ---
CLIENT_SECRETS_FILE = 'path/to/your/client_secret.json'
SCOPES = ['https://www.googleapis.com/auth/health']  # Add other scopes as needed
TOKEN_FILE = 'token.json'
GRPC_ENDPOINT = 'health.googleapis.com' # Google Health API gRPC endpoint

def get_credentials():
    """Gets or creates OAuth 2.0 credentials."""
    creds = None
    # The file token.json stores the user's access and refresh tokens, and is
    # created automatically when the authorization flow completes for the first
    # time.
    if os.path.exists(TOKEN_FILE):
        with open(TOKEN_FILE, 'r') as token:
            creds = Credentials.from_authorized_user_info(json.load(token), SCOPES)
    # If there are no (valid) credentials available, let the user log in.
    if creds and creds.expired and creds.refresh_token:
        try:
            creds.refresh(Request())
        except Exception as e:
            creds = None  # Force re-auth if refresh fails
    if not creds or not creds.valid:
        flow = InstalledAppFlow.from_client_secrets_file(
            CLIENT_SECRETS_FILE, SCOPES
        )
        creds = flow.run_local_server(port=0)
        # Save the credentials for the next run
        with open(TOKEN_FILE, 'w') as token:
            token.write(creds.to_json())
    return creds

def fetch_health_data_grpc(creds):
    """Fetches health data using gRPC."""
    if not data_points_pb2_grpc:
        return
    try:
        # Create an authenticated gRPC channel
        channel = secure_authorized_channel(creds, Request(), f'{GRPC_ENDPOINT}:443')
        # Create a stub for the DataPointsService
        stub = data_points_pb2_grpc.DataPointsServiceStub(channel)

        # Example: list steps data points for the authenticated user 'me'
        request = data_points_pb2.ListDataPointsRequest(parent='users/me/dataTypes/steps')
        response = stub.ListDataPoints(request)
        print('Health data via gRPC:', response)
    except grpc.RpcError as e:
        print(f'Error fetching data via gRPC: {e.code()} - {e.details()}')
    except Exception as e:
        print(f'An error occurred during gRPC call: {e}')

if __name__ == '__main__':
    try:
        creds = get_credentials()
        print("Fetching data using gRPC...")
        fetch_health_data_grpc(creds)
    except Exception as e:
        print(f"An error occurred: {e}")
  • Importar bibliotecas:
    • grpc: a biblioteca gRPC Python.
    • google.auth.transport.grpc: para criar canais seguros e autenticados.
    • data_points_pb2, data_points_pb2_grpc: código do cliente gerado a partir de .proto arquivos.
  • Configuração:
    • CLIENT_SECRETS_FILE: caminho para o arquivo client_secret.json.
    • SCOPES: as permissões necessárias.
    • TOKEN_FILE: caminho para armazenar tokens OAuth.
    • GRPC_ENDPOINT: o nome do host do serviço gRPC do Google Health.
  • get_credentials():
    • Carrega segredos do cliente do arquivo, usa InstalledAppFlow de google-auth-oauthlib para gerenciar a autorização, tenta carregar credenciais armazenadas ou inicia o fluxo do OAuth 2.0, se necessário.
  • fetch_health_data_grpc():
    • Cria um canal gRPC seguro e autenticado usando as credenciais do usuário.
    • Inicializa um DataPointsServiceStub com o canal.
    • Cria um ListDataPointsRequest para solicitar dados de etapas para users/me.
    • Chama o método RPC ListDataPoints e imprime a resposta.
  • Tratamento de erros:o código inclui blocos try...except básicos para lidar com erros gRPC e outros.
Anterior
Escopos
Avançar
Limites de taxas