Librerie client

Questa pagina fornisce link a modi pratici per accedere all'API Google Health.

Librerie client dell'API Google Health

L'API Google Health si basa su HTTP e JSON, pertanto qualsiasi client HTTP standard può inviare richieste e analizzare le risposte.

Tuttavia, anziché creare richieste HTTP e analizzare le risposte manualmente, ti consigliamo di utilizzare le librerie client delle API di Google. Le librerie client offrono una migliore integrazione del linguaggio, una maggiore sicurezza e supporto per effettuare chiamate che richiedono l'autorizzazione dell'utente.

Go

Scarica la più recente libreria client dell'API Google Health per Go. Leggi la guida per gli sviluppatori della libreria client.

Java

Questa pagina contiene informazioni relative a come iniziare a utilizzare l'API Google Health mediante la libreria client delle API di Google per Java. Per ulteriori informazioni, leggi la seguenti documentazione:

Aggiungi la libreria client al tuo progetto

Seleziona il tuo ambiente di build (Maven o Gradle) dalle seguenti schede:

JavaScript

Leggi la guida per gli sviluppatori della libreria client.

.NET

Questa pagina contiene informazioni relative a come iniziare a utilizzare l'API Google Health mediante la libreria client delle API di Google per .NET. Per scoprire di più, consulta la seguente documentazione:

Scarica la libreria

Installa il pacchetto NuGet: Google.Apis.

Node.js

Scarica la più recente libreria client dell'API Google Health per Node.js. Leggi la guida per gli sviluppatori della libreria client.

Obj-C

Scarica la più recente libreria client dell'API Google Health per Objective-C. Leggi la guida per gli sviluppatori della libreria client.

PHP

Scarica la più recente libreria client dell'API Google Health per PHP. Leggi la guida per gli sviluppatori della libreria client.

Python

Questa pagina contiene informazioni relative a come iniziare a utilizzare l'API Google Health mediante la libreria client delle API di Google per Python (v1/v2). Per ulteriori informazioni, leggi la seguenti documentazione:

Requisiti di sistema

Installare la libreria client

Puoi utilizzare un gestore di pacchetti o scaricare e installare manualmente la libreria client Python:

Installazione gestita

Utilizza pip o setuptools per gestire l'installazione (potrebbe essere necessario eseguire prima sudo):

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

Installazione manuale

  1. Scarica la libreria client più recente per Python.
  2. Estrai il codice dal pacchetto.
  3. Installa: 
    python setup.py install

App Engine

Poiché le librerie client per Python non sono installate nell'ambiente runtime Python di App Engine, devi copiarle nella tua applicazione proprio come le librerie di terze parti.

Ruby

Questa pagina contiene informazioni relative a come iniziare a utilizzare l'API Google Health mediante la libreria client delle API di Google per Ruby. Per ulteriori informazioni, leggi la seguenti documentazione:

Installa il gem google-api-client

A seconda del sistema, potrebbe essere necessario anteporre sudo a questi comandi.

Se non hai ancora installato la libreria client delle API di Google per Ruby, esegui l'installazione utilizzando RubyGems: 

gem install google-api-client

Se hai già installato il gem, esegui l'aggiornamento all'ultima versione: 

gem update -y google-api-client

Iniziare a utilizzare la libreria client delle API di Google per Ruby

Per scoprire come effettuare la tua prima richiesta, consulta la Guida introduttiva.

gRPC

L'API Google Health supporta anche gRPC per il recupero di dati ad alte prestazioni. Oltre a installare le librerie client, l'utilizzo di gRPC richiede l'ottenimento delle definizioni di Protocol Buffers dell'API e la generazione di codice stub lato client prima di effettuare le richieste.

  1. Installa le librerie gRPC:
    • Usa pip install grpcio grpcio-tools google-auth-oauthlib per installare le dipendenze.
  2. Genera codice client:
    • Ottieni le definizioni .proto dell'API Google Health (ad esempio, data_points.proto).
    • Esegui python -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. path/to/your/data_points.proto per generare il codice stub.
  3. Implementa OAuth 2.0 ed effettua richieste gRPC:
    • Utilizza google-auth-oauthlib per l'autorizzazione e lo stub client generato per effettuare richieste gRPC, come mostrato nell'esempio seguente.
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}")
  • Importa librerie:
    • grpc: la libreria gRPC Python.
    • google.auth.transport.grpc: per creare canali sicuri e autenticati.
    • data_points_pb2, data_points_pb2_grpc: codice cliente generato dai file .proto.
  • Configurazione:
    • CLIENT_SECRETS_FILE: il percorso del file client_secret.json.
    • SCOPES: le autorizzazioni obbligatorie.
    • TOKEN_FILE: percorso in cui archiviare i token OAuth.
    • GRPC_ENDPOINT: il nome host del servizio gRPC di Google Health.
  • get_credentials():
    • Carica i client secret dal file, utilizza InstalledAppFlow da google-auth-oauthlib per gestire l'autorizzazione, tenta di caricare le credenziali memorizzate o avvia il flusso OAuth 2.0, se necessario.
  • fetch_health_data_grpc():
    • Crea un canale gRPC sicuro e autenticato utilizzando le credenziali dell'utente.
    • Inizializza un DataPointsServiceStub con il canale.
    • Crea un ListDataPointsRequest per richiedere i dati sui passi per users/me.
    • Chiama il metodo RPC ListDataPoints e stampa la risposta.
  • Gestione degli errori:il codice include blocchi try...except di base per la gestione di gRPC e di altri errori.
Indietro
Ambiti
Avanti
Limiti di frequenza