Clientbibliotheken

Auf dieser Seite finden Sie Links zu praktischen Möglichkeiten für den Zugriff auf die Google Health API.

Google Health API-Clientbibliotheken

Die Google Health API basiert auf HTTP und JSON, sodass jeder Standard-HTTP-Client Anfragen an sie senden und die Antworten parsen kann.

Anstatt jedoch HTTP-Anfragen zu erstellen und Antworten manuell zu analysieren, können Sie die Google APIs-Clientbibliotheken verwenden. Clientbibliotheken bieten eine bessere Sprachintegration sowie eine höhere Sicherheit und unterstützen auch Aufrufe, die eine Nutzerautorisierung erfordern.

Ok

Rufe die aktuelle Google Health API-Clientbibliothek für Go ab. Lies den Entwicklerhandbuch zur Clientbibliothek.

Java

Diese Seite enthält Informationen zu den ersten Schritten mit der Google Health API unter Einsatz der Google API-Clientbibliothek für Java. Weitere Informationen erhalten Sie in dieser Dokumentation:

Clientbibliothek zum Projekt hinzufügen

Wähle über die folgenden Tabs deine Build-Umgebung (Maven oder Gradle) aus:

Gradle

Füge deiner Datei build.gradle Folgendes hinzu:

Im Maven Central Repository findest du alle verfügbaren Versionen.

JavaScript

Sieh dir den Entwicklerleitfaden zur Clientbibliothek an.

.NET

Diese Seite enthält Informationen zur Verwendung der Google Health API mit der Google API-Clientbibliothek für .NET. Weitere Informationen findest du in der folgenden Dokumentation:

Bibliothek herunterladen

Installiere das NuGet-Paket: Google.Apis.

Node.js

Rufen Sie die aktuelle Google Health API-Clientbibliothek für Node.js ab. Sieh dir den Entwicklerleitfaden zur Clientbibliothek an.

Obj-C

Rufen Sie die aktuelle Google Health API-Clientbibliothek für Objective-C ab. Sieh dir den Entwicklerleitfaden zur Clientbibliothek an.

PHP

Rufen Sie die aktuelle Google Health API-Clientbibliothek für PHP ab. Sieh dir den Entwicklerleitfaden zur Clientbibliothek an.

Python

Diese Seite enthält Informationen zur Verwendung der Google Health API mit der Google API-Clientbibliothek für Python (v1/v2). Weitere Informationen erhalten Sie in dieser Dokumentation:

Systemanforderungen

Clientbibliothek installieren

Du kannst entweder einen Paketmanager verwenden oder die Python-Clientbibliothek manuell herunterladen und installieren:

Verwaltete Installation

Verwende „pip“ oder „setuptools“, um die Installation zu verwalten (möglicherweise musst du zuerst sudo ausführen).

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

Manuelle Installation

  1. Lade die aktuelle Clientbibliothek für Python herunter.
  2. Entpacke den Code.
  3. Führe die Installation durch: 
    python setup.py install

App Engine

Da die Python-Clientbibliotheken nicht in der Python-Laufzeitumgebung von App Engine installiert sind, musst du sie wie Drittanbieterbibliotheken in deine Anwendung kopieren.

Ruby

Diese Seite enthält Informationen zu den ersten Schritten mit der Google Health API und der Google API-Clientbibliothek für Ruby. Weitere Informationen erhalten Sie in dieser Dokumentation:

google-api-client-Gem installieren

Je nach System musst du diesen Befehlen den Ausdruck sudo voranstellen.

Wenn du die Google API-Clientbibliothek für Ruby noch nicht installiert hast, installiere sie mit RubyGems: 

gem install google-api-client

Wenn das Gem bereits installiert ist, aktualisiere es auf die neueste Version: 

gem update -y google-api-client

Google API-Clientbibliothek für Ruby verwenden

Informationen zum Erstellen deiner ersten Anfrage findest du im Startleitfaden.

gRPC

Die Google Health API unterstützt auch gRPC für den leistungsstarken Datenabruf. Für die Verwendung von gRPC ist es nicht nur erforderlich, Clientbibliotheken zu installieren, sondern auch die Protocol Buffers-Definitionen der API abzurufen und clientseitigen Stub-Code zu generieren, bevor Anfragen gesendet werden.

  1. gRPC-Bibliotheken installieren:
    • Verwenden Sie pip install grpcio grpcio-tools google-auth-oauthlib, um Abhängigkeiten zu installieren.
  2. Clientcode generieren:
    • Rufen Sie die .proto-Definitionen der Google Health API ab (z. B. data_points.proto).
    • Führen Sie python -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. path/to/your/data_points.proto aus, um Stub-Code zu generieren.
  3. OAuth 2.0 implementieren und gRPC-Anfragen stellen:
    • Verwenden Sie google-auth-oauthlib zur Autorisierung und den generierten Client-Stub, um gRPC-Anfragen zu stellen, wie im folgenden Beispiel gezeigt.
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}")
  • Bibliotheken importieren:
    • grpc: Die gRPC-Python-Bibliothek.
    • google.auth.transport.grpc: Zum Erstellen sicherer, authentifizierter Kanäle.
    • data_points_pb2, data_points_pb2_grpc: Clientcode, der aus .proto-Dateien generiert wird.
  • Konfiguration:
    • CLIENT_SECRETS_FILE: Pfad zur Datei client_secret.json.
    • SCOPES: Die erforderlichen Berechtigungen.
    • TOKEN_FILE: Pfad zum Speichern von OAuth-Tokens.
    • GRPC_ENDPOINT: Der Hostname für den Google Health-gRPC-Dienst.
  • get_credentials():
    • Lädt Clientgeheimnisse aus einer Datei, verwendet InstalledAppFlow aus google-auth-oauthlib, um die Autorisierung zu verwalten, versucht, gespeicherte Anmeldedaten zu laden, oder initiiert bei Bedarf den OAuth 2.0-Vorgang.
  • fetch_health_data_grpc():
    • Erstellt einen sicheren, authentifizierten gRPC-Kanal mit den Anmeldedaten des Nutzers.
    • Initialisiert ein DataPointsServiceStub mit dem Channel.
    • Erstellt ein ListDataPointsRequest, um Schrittdaten für users/me anzufordern.
    • Ruft die RPC-Methode ListDataPoints auf und gibt die Antwort aus.
  • Fehlerbehandlung:Der Code enthält grundlegende try...except-Blöcke zur Behandlung von gRPC- und anderen Fehlern.
Zurück
Bereiche
Weiter
Ratenlimits