Biblioteki klienta

Ta strona zawiera linki do wygodnych sposobów uzyskiwania dostępu do interfejsu Google Health API.

Biblioteki klienta interfejsu Google Health API

Interfejs Google Health API został zaprojektowany na podstawie protokołu HTTP i JSON, więc każdy standardowy klient HTTP może wysyłać do niego żądania i analizować odpowiedzi.

Zamiast ręcznie tworzyć żądania HTTP i analizować odpowiedzi, możesz użyć bibliotek klienta interfejsów API Google. Biblioteki klienta zapewniają lepszą integrację językową, wyższy poziom bezpieczeństwa i obsługę wywołań, które wymagają autoryzacji użytkownika.

Go

Pobierz najnowszą bibliotekę klienta interfejsu Google Health API dla języka Go. Przeczytaj przewodnik dla deweloperów dotyczący biblioteki klienta.

Java

Ta strona zawiera informacje dla początkujących na temat korzystania z interfejsu Google Health API i biblioteki klienta interfejsu API Google dla języka Java. Więcej informacji znajdziesz w tych zasobach:

Dodawanie biblioteki klienta do projektu

Wybierz swoje środowisko kompilacji (Maven lub Gradle) z następujących kart:

JavaScript

Przeczytaj przewodnik programisty dotyczący biblioteki klienta.

.NET

Ta strona zawiera informacje dla początkujących na temat korzystania z interfejsu Google Health API i biblioteki klienta interfejsu API Google dla języka .NET. Więcej informacji znajdziesz w tych zasobach:

Pobieranie biblioteki

Zainstaluj pakiet NuGet: Google.Apis.

Node.js

Pobierz najnowszą bibliotekę klienta interfejsu Google Health API dla języka Node.js. Przeczytaj przewodnik programisty dotyczący biblioteki klienta.

Obj-C

Pobierz najnowszą bibliotekę klienta interfejsu Google Health API dla języka Objective-C. Przeczytaj przewodnik programisty dotyczący biblioteki klienta.

PHP

Pobierz najnowszą bibliotekę klienta interfejsu Google Health API dla języka PHP. Przeczytaj przewodnik programisty dotyczący biblioteki klienta.

Python

Ta strona zawiera informacje dla początkujących na temat korzystania z interfejsu Google Health API za pomocą biblioteki klienta interfejsu API Google dla języka Python (w wersji 1 lub 2). Więcej informacji znajdziesz w tych zasobach:

Wymagania systemowe

Instalowanie biblioteki klienta

Możesz użyć systemu zarządzania pakietami lub ręcznie pobrać i zainstalować bibliotekę klienta dla języka Python:

Instalacja zarządzana

Użyj pakietu pip lub setuptools do zarządzania instalacją. Najpierw konieczne może być uruchomienie programu . Najpierw konieczne może być uruchomienie programu sudo.

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

Instalacja ręczna

  1. Pobierz najnowszą bibliotekę klienta dla języka Python
  2. Rozpakuj kod.
  3. Zainstaluj: 
    python setup.py install

App Engine

Biblioteki klienta dla języka Python nie są instalowane w środowisku wykonawczym App Engine Python, więc trzeba je skopiować do aplikacji, tak jak biblioteki innych dostawców.

Ruby

Ta strona zawiera informacje dla początkujących na temat korzystania z interfejsu Google Health API i biblioteki klienta interfejsu API Google dla języka Ruby. Więcej informacji znajdziesz w tych zasobach:

Instalowanie gemu google-api-client

Zależnie od systemu konieczne może być poprzedzenie tych poleceń elementem sudo.

Jeśli nie masz jeszcze zainstalowanej biblioteki klienta interfejsu API Google dla języka Ruby, zainstaluj ją, używając elementu RubyGems: 

gem install google-api-client

Jeśli masz już zainstalowany gem, zaktualizuj go do najnowszej wersji: 

gem update -y google-api-client

Rozpoczynanie pracy z biblioteką klienta interfejsu API Google do języka Ruby

Informacje o tym, jak przesłać pierwszą prośbę, znajdziesz w przewodniku dla początkujących.

gRPC

Interfejs Google Health API obsługuje też gRPC, co umożliwia szybkie pobieranie danych. Oprócz zainstalowania bibliotek klienta korzystanie z gRPC wymaga uzyskania definicji Protocol Buffers interfejsu API i wygenerowania kodu stub po stronie klienta przed wysłaniem żądań.

  1. Zainstaluj biblioteki gRPC:
    • Aby zainstalować zależności, użyj polecenia pip install grpcio grpcio-tools google-auth-oauthlib.
  2. Wygeneruj kod klienta:
    • Pobierz definicje .proto interfejsu Google Health API (np. data_points.proto).
    • Aby wygenerować kod stub, uruchom polecenie python -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. path/to/your/data_points.proto.
  3. Zaimplementuj OAuth 2.0 i wysyłaj żądania gRPC:
    • Do autoryzacji użyj biblioteki google-auth-oauthlib, a do wysyłania żądań gRPC – wygenerowanego kodu stub klienta, jak pokazano w tym przykładzie.
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}")
  • Importowanie bibliotek:
    • grpc: biblioteka gRPC dla języka Python.
    • google.auth.transport.grpc: do tworzenia bezpiecznych, uwierzytelnionych kanałów.
    • data_points_pb2, data_points_pb2_grpc: kod klienta wygenerowany z .proto plików.
  • Konfiguracja:
    • CLIENT_SECRETS_FILE: ścieżka do pliku client_secret.json.
    • SCOPES: wymagane uprawnienia.
    • TOKEN_FILE: ścieżka do przechowywania tokenów OAuth.
    • GRPC_ENDPOINT: nazwa hosta usługi gRPC Google Health.
  • get_credentials():
    • Wczytuje tajne dane klienta z pliku, używa InstalledAppFlow z biblioteki google-auth-oauthlib do zarządzania autoryzacją, próbuje wczytać zapisane dane uwierzytelniające lub w razie potrzeby inicjuje przepływ OAuth 2.0.
  • fetch_health_data_grpc():
    • Tworzy bezpieczny, uwierzytelniony kanał gRPC przy użyciu danych uwierzytelniających użytkownika.
    • Inicjuje DataPointsServiceStub z kanałem.
    • Tworzy ListDataPointsRequest, aby poprosić o dane dotyczące kroków dla users/me.
    • Wywołuje metodę RPC ListDataPoints i wyświetla odpowiedź.
  • Obsługa błędów: kod zawiera podstawowe bloki try...except do obsługi błędów gRPC i innych.
Wstecz
Zakresy
Dalej
Ograniczenia liczby żądań