Bibliotecas cliente

En esta página, se proporcionan vínculos a formas convenientes de acceder a la API de Google Health.

Bibliotecas cliente de la API de Google Health

La API de Google Health está creada en HTTP o JSON, por lo que cualquier cliente HTTP estándar puede enviar solicitudes a ella y analizar las respuestas.

Sin embargo, en lugar de crear solicitudes HTTP y analizar las respuestas de forma manual, es posible que desees usar las bibliotecas cliente de las APIs de Google. Las bibliotecas cliente proporcionan una mejor integración del lenguaje, mayor seguridad y compatibilidad para realizar llamadas que requieren la autorización del usuario.

Go

Obtén la biblioteca cliente de la API de Google Health para Go más reciente. Lee la guía para desarrolladores de la biblioteca cliente.

Java

En esta página, se incluye información para comenzar a usar la API de Google Health con la biblioteca cliente de la API de Google para Java. Para obtener más información, consulta la siguiente documentación:

Agrega la biblioteca cliente a tu proyecto

Selecciona tu entorno de compilación (Maven o Gradle) en las siguientes pestañas:

JavaScript

Lee la guía para desarrolladores de la biblioteca cliente.

.NET

En esta página, se incluye información para comenzar a usar la API de Google Health con la biblioteca cliente de la API de Google para .NET. Para obtener más información, consulta la siguiente documentación:

Descarga la biblioteca

Instala el paquete de NuGet: Google.Apis.

Node.js

Obtén la última biblioteca cliente de la API de Google Health para Node.js. Lee la guía para desarrolladores de la biblioteca cliente.

Obj-C

Obtén la última biblioteca cliente de la API de Google Health para Objective-C. Lee la guía para desarrolladores de la biblioteca cliente.

PHP

Obtén la última biblioteca cliente de la API de Google Health para PHP. Lee la guía para desarrolladores de la biblioteca cliente.

Python

En esta página, se incluye información para comenzar a usar la API de Google Health con la biblioteca cliente de la API de Google para Python (v1/v2). Para obtener más información, consulta la siguiente documentación:

Requisitos del sistema

Instala la biblioteca cliente

Puedes usar un administrador de paquetes o descargar e instalar de forma manual la biblioteca cliente de Python:

Instalación administrada

Usa pip o setuptools para administrar la instalación (es posible que primero debas ejecutar ). Es posible que debas ejecutar sudo primero.

  • pip (opción preferida): 
    pip install --upgrade google-api-python-client
  • setuptools: 
    easy_install --upgrade google-api-python-client

Instalación manual

  1. Descarga la biblioteca cliente más reciente para Python.
  2. Descomprime el código.
  3. Instala: 
    python setup.py install

App Engine

Como las bibliotecas cliente de Python no están instaladas en el entorno de ejecución de App Engine para Python, debes copiarlas en tu aplicación al igual que las bibliotecas de terceros.

Ruby

En esta página, se incluye información para comenzar a usar la API de Google Health con la biblioteca cliente de la API de Google para Ruby. Para obtener más información, consulta la siguiente documentación:

Instala la gema google-api-client

Según el sistema, es posible que debas anteponer estos comandos con sudo.

Si nunca instalaste la biblioteca cliente de la API de Google para Ruby, instálala con RubyGems: 

gem install google-api-client

Si ya instalaste la gema, actualiza a la versión más reciente: 

gem update -y google-api-client

Cómo comenzar a usar la biblioteca cliente de la API de Google para Ruby

Para obtener información sobre cómo realizar tu primera solicitud, consulta la Guía de introducción.

gRPC

La API de Google Health también admite gRPC para la recuperación de datos de alto rendimiento. Además de instalar bibliotecas cliente, el uso de gRPC requiere obtener las definiciones de Protocol Buffers de la API y generar código de stub del cliente antes de realizar solicitudes.

  1. Instala las bibliotecas de gRPC:
    • Usa pip install grpcio grpcio-tools google-auth-oauthlib para instalar dependencias.
  2. Genera código de cliente:
    • Obtén las definiciones .proto de la API de Google Health (por ejemplo, data_points.proto).
    • Ejecuta python -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. path/to/your/data_points.proto para generar código de stub.
  3. Implementa OAuth 2.0 y realiza solicitudes de gRPC:
    • Usa google-auth-oauthlib para la autorización y el stub del cliente generado para realizar solicitudes de gRPC, como se muestra en el siguiente ejemplo.
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 bibliotecas:
    • grpc: La biblioteca de gRPC para Python.
    • google.auth.transport.grpc: Para crear canales seguros y autenticados.
    • data_points_pb2, data_points_pb2_grpc: Código de cliente generado a partir de .proto archivos.
  • Configuración:
    • CLIENT_SECRETS_FILE: Ruta de acceso a tu archivo client_secret.json.
    • SCOPES: Los permisos necesarios.
    • TOKEN_FILE: Ruta de acceso para almacenar tokens de OAuth.
    • GRPC_ENDPOINT: El nombre de host del servicio de gRPC de Google Health.
  • get_credentials():
    • Carga secretos de cliente desde el archivo, usa InstalledAppFlow de google-auth-oauthlib para administrar la autorización, intenta cargar las credenciales almacenadas o inicia el flujo de OAuth 2.0 si es necesario.
  • fetch_health_data_grpc():
    • Crea un canal de gRPC seguro y autenticado con las credenciales del usuario.
    • Inicializa un DataPointsServiceStub con el canal.
    • Crea un ListDataPointsRequest para solicitar datos de pasos para users/me.
    • Llama al método RPC ListDataPoints y muestra la respuesta.
  • Manejo de errores: El código incluye bloques try...except básicos para controlar gRPC y otros errores.
Anterior
Permisos
Siguiente
Límites de frecuencia