Bibliothèques clientes

Cette page fournit des exemples de bibliothèques clientes pour accéder à l'API Google Health.

L'API Google Health étant basée sur HTTP et JSON, tout client HTTP standard peut lui envoyer des requêtes et analyser les réponses.

Toutefois, au lieu de créer manuellement des requêtes HTTP et d'analyser les réponses, vous pouvez utiliser les exemples et les téléchargements de bibliothèques clientes présentés ici.

Java

  1. Ajoutez la bibliothèque cliente des API Google
    • Incluez la bibliothèque dans votre projet (à l'aide de Maven ou de Gradle).
  2. Mettez en œuvre le flux OAuth 2.0
    • Utilisez google-auth-library-java pour gérer le flux OAuth.
  3. Effectuez des requêtes d'API :
    • Utilisez le client initialisé pour envoyer des requêtes à l'API Google Health.
import com.google.api.client.auth.oauth2.Credential;
import com.google.api.client.googleapis.auth.oauth2.GoogleAuthorizationCodeFlow;
import com.google.api.client.googleapis.auth.oauth2.GoogleClientSecrets;
import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.client.util.store.FileDataStoreFactory;
import com.google.api.services.health.v1.Health; // Assuming a generated Google Health API client
import com.google.api.services.health.v1.model.DataResponse; // Example: Response model
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.security.GeneralSecurityException;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.Scanner;

public class GoogleHealthApiExample {

    private static final String CLIENT_SECRETS_PATH = "path/to/your/client_secret.json";
    private static final String TOKENS_DIRECTORY_PATH = "tokens";
    private static final String API_KEY = "YOUR_API_KEY";
    private static final List<String> SCOPES = Collections.singletonList("https://www.googleapis.com/auth/health");
    private static final String APPLICATION_NAME = "Google Health API Example";
    private static final String DISCOVERY_URL = "https://health.googleapis.com/$discovery/rest"; // Adjust if needed

    private static final JsonFactory JSON_FACTORY = new GsonFactory();
    private static FileDataStoreFactory dataStoreFactory;
    private static HttpTransport httpTransport;

    static {
        try {
            httpTransport = GoogleNetHttpTransport.newTrustedTransport();
            dataStoreFactory = new FileDataStoreFactory(new File(TOKENS_DIRECTORY_PATH));
        } catch (GeneralSecurityException | IOException e) {
            throw new RuntimeException("Error initializing HttpTransport or DataStoreFactory", e);
        }
    }


    public static void main(String[] args) {
        try {
             Health healthService = createHealthService();
             fetchHealthData(healthService);
        } catch (Exception e) {
            System.err.println("Error during execution: " + e.getMessage());
             e.printStackTrace();
        }
    }

    private static Health createHealthService() throws IOException {
        Credential credential = getCredentials();
        return new Health.Builder(httpTransport, JSON_FACTORY, credential)
                .setApplicationName(APPLICATION_NAME)
                .setGoogleClientRequestInitializer(request -> {
                    request.set("key", API_KEY);
                })
                .setRootUrl(DISCOVERY_URL)
                .build();
    }

    private static Credential getCredentials() throws IOException {
        // Load client secrets
        InputStream in = Objects.requireNonNull(GoogleHealthApiExample.class.getClassLoader().getResourceAsStream(CLIENT_SECRETS_PATH),
                "client_secret.json not found");
        GoogleClientSecrets clientSecrets = GoogleClientSecrets.load(JSON_FACTORY, new InputStreamReader(in));

        // Build flow and trigger user authorization request.
        GoogleAuthorizationCodeFlow flow = new GoogleAuthorizationCodeFlow.Builder(
                httpTransport, JSON_FACTORY, clientSecrets, SCOPES)
                .setDataStoreFactory(dataStoreFactory)
                .setAccessType("offline") // Allows for refresh tokens
                .build();

        Credential credential = flow.loadCredential("user"); // "user" is a key for storing/loading credentials.
        if (credential == null || !credential.getAccessToken() != null && credential.getExpiresInSeconds() <= 60) {
            // Prompt user to authorize and get new credentials
            System.out.println("Please open the following URL in your browser and authorize the app:");
            System.out.println(flow.newAuthorizationUrl().setRedirectUri("urn:ietf:wg:oauth:2.0:oob").build());
            System.out.print("Enter the authorization code: ");
            String code = new Scanner(System.in).nextLine();
            credential = flow.createAndStoreCredential(
                    flow.newTokenRequest(code).setRedirectUri("urn:ietf:wg:oauth:2.0:oob").execute(), "user"
            );
        }
        return credential;
    }

    private static void fetchHealthData(Health client) throws IOException {
        try {
            // Example: Replace with actual API method calls
            Health.Users.Data.List request = client.users().data().list();
            DataResponse response = request.execute();
            System.out.println("Health data: " + response);
        } catch (Exception e) {
            System.err.println("Error fetching health data: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

  // Process the response
  if (response.statusCode() == 200) {
      System.out.println("API Response: " + response.body());
  } else {
      System.err.println("Error: " + response.statusCode() + " " + response.body());
}
  • Importez des bibliothèques
    • com.google.api.client.* : bibliothèques de base pour le client des API Google.
    • com.google.api.services.health.*: classes générées pour l'API Google Health. (Vous devrez générer cette classe en fonction du document de découverte de l'API.)
  • Configuration :
    • CLIENT_SECRETS_PATH : chemin d'accès à votre fichier client_secret.json.
    • TOKENS_DIRECTORY_PATH : chemin d'accès pour stocker les jetons.
    • API_KEY : votre clé API.
    • SCOPES : autorisations requises.
    • DISCOVERY_URL : URL permettant d'obtenir la définition de l'API.
  • main Méthode :
    • Initialise le client de l'API Google Health et appelle fetchHealthData.
  • createHealthService():
    • Crée une instance du client de l'API Google Health, en définissant les identifiants, le nom de l'application et la clé API.
  • getCredentials():
    • Charge les secrets client à partir du fichier.
    • Crée un GoogleAuthorizationCodeFlow.
    • Tente de charger les identifiants stockés.
    • Si aucun identifiant n'est trouvé ou si les identifiants ont expiré, invite l'utilisateur à saisir le code d'autorisation et stocke les nouveaux identifiants.
    • Renvoie l'objet d'identifiants.
  • fetchHealthData():
    • Effectue un appel d'API à l'API Google Health (remplacez l'exemple par vos appels de méthode spécifiques).
    • Affiche la réponse.
  • Gestion des erreurs : le code inclut des blocs try...catch de base pour la gestion des erreurs.

JavaScript

  1. Installez la bibliothèque cliente des API Google
    • Incluez la bibliothèque dans votre projet. Vous pouvez utiliser un CDN ou npm.
  2. Mettez en œuvre le flux OAuth 2.0
    • Utilisez la bibliothèque Google Identity Services pour gérer le flux OAuth (résultat 16.1).
  3. Effectuez des requêtes d'API :
    • Utilisez le client initialisé pour envoyer des requêtes à l'API Google Health.
  import { google } from 'https://apis.google.com/js/api.js';
  import { GoogleIdentityServices } from 'https://accounts.google.com/gsi/client';

  const CLIENT_ID = 'YOUR_CLIENT_ID';
  const API_KEY = 'YOUR_API_KEY';
  const DISCOVERY_URL = 'https://health.googleapis.com/$discovery/rest'; // Replace with actual discovery URL if needed
  const SCOPES = 'https://www.googleapis.com/auth/health'; // Add other scopes as needed

  let tokenClient;

  async function initClient() {
    await new Promise((resolve, reject) => {
      google.load('client', { callback: resolve, onerror: reject });
    });

    await google.client.init({
      apiKey: API_KEY,
      discoveryDocs: [DISCOVERY_URL],
    });

    tokenClient = await new Promise((resolve, reject) => {
        const client = GoogleIdentityServices.oauth2.initTokenClient({
            client_id: CLIENT_ID,
            scope: SCOPES,
            callback: (response) => {
              if (response && response.access_token) {
                resolve(response.access_token);
                } else {
                    reject(new Error('Failed to get token'));
                }
            },
            error_callback: (error) => {
                reject(error);
            },
      });
      resolve(client);
    });
   console.log("Client initialized");
   await authorize();
  }

  async function authorize() {
    if (google.client.getToken()) {
        console.log("Already authorized");
        return;
    }
    return await new Promise((resolve, reject) => {
        if(tokenClient){
           tokenClient.requestAccessToken();
           resolve();
        }
        else {
            reject(new Error('Token client not initialized'));
        }
    });
  }

  async function fetchHealthData() {
    try{
        await authorize();
        // Example: Replace with actual API method calls
        const response = await google.client.health.users.data.list();
        console.log('Health data:', response.result);
    } catch (error) {
        console.error('Error fetching data:', error);
    }
  }


  initClient().then(() => {
      fetchHealthData();
  });
  • Importez des bibliothèques
    • https://apis.google.com/js/api.js : charge le client de base des API Google.
    • https://accounts.google.com/gsi/client: charge Google Identity Services pour l'authentification.
  • Configuration :
    • CLIENT_ID, API_KEY : remplacez-les par vos identifiants réels.
    • DISCOVERY_URL : URL permettant d'obtenir la définition de l'API. Vous devrez peut-être l'ajuster en fonction de la configuration finale de l'API Google Health.
    • SCOPES: définissez les autorisations nécessaires à votre application (par exemple, pour lire les données de santé).
  • initClient():
    • Charge le client des API Google.
    • Initialise le client avec votre clé API et le document de découverte.
    • Initialise le client de jeton Google Identity Services.
  • authorize():
    • Vérifie si un jeton est déjà disponible.
    • Si ce n'est pas le cas, il appelle tokenClient.requestAccessToken() pour démarrer le flux OAuth.
  • fetchHealthData():
    • Appelle authorize() pour s'assurer que l'utilisateur est authentifié.
    • Effectue un appel d'API à l'API Google Health (remplacez l'exemple par vos appels spécifiques).
    • Enregistre la réponse.
  • Gestion des erreurs : le code inclut des blocs try...catch de base pour la gestion des erreurs.

Python

  1. Installez la bibliothèque cliente des API Google
    • Utilisez pip pour installer les bibliothèques nécessaires.
  2. Mettez en œuvre le flux OAuth 2.0
    • Utilisez la bibliothèque google-auth-oauthlib pour gérer le flux OAuth.
  3. Effectuez des requêtes d'API :
    • Utilisez le client initialisé pour envoyer des requêtes à l'API Google Health.
import google.auth
from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
import googleapiclient.discovery
import os
import json

# --- REPLACE WITH YOUR VALUES ---
CLIENT_SECRETS_FILE = 'path/to/your/client_secret.json'
API_KEY = 'YOUR_API_KEY'
SCOPES = ['https://www.googleapis.com/auth/health']  # Add other scopes as needed
DISCOVERY_URL = 'https://health.googleapis.com/$discovery/rest'  # Adjust if needed
TOKEN_FILE = 'token.json'

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 not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            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 create_health_client(creds):
    """Creates a Google Health API client."""
    return googleapiclient.discovery.build(
        'health',
        'v1',  # Replace with the actual API version if needed
        credentials=creds,
        discoveryServiceUrl=DISCOVERY_URL,
        developerKey=API_KEY
    )

def fetch_health_data(client):
    """Fetches health data using the API client."""
    try:
        # Example: Replace with actual API method calls
        response = client.users().data().list().execute()
        print('Health data:', response)
    except Exception as e:
        print(f'Error fetching data: {e}')


if __name__ == '__main__':
    try:
        creds = get_credentials()
        health_client = create_health_client(creds)
        fetch_health_data(health_client)
    except Exception as e:
        print(f"An error occurred: {e}")
Précédent
Champs d'application
Suivant
Endpoints