Library klien

Halaman ini memberikan contoh library klien untuk mengakses Google Health API.

Google Health API dibuat berdasarkan HTTP dan JSON, sehingga semua klien HTTP standar dapat mengirim permintaan ke API ini dan mengurai responsnya.

Namun, daripada membuat permintaan HTTP dan mengurai respons secara manual, Anda dapat menggunakan contoh dan download library klien yang ditampilkan di sini.

Java

  1. Tambahkan Library Klien Google API:
    • Sertakan library dalam project Anda (menggunakan Maven atau Gradle).
  2. Terapkan Alur OAuth 2.0:
    • Gunakan google-auth-library-java untuk menangani alur OAuth.
  3. Membuat Permintaan API:
    • Gunakan klien yang telah diinisialisasi untuk membuat permintaan ke Google Health API.
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());
}
  • Mengimpor Library:
    • com.google.api.client.*: Library inti untuk klien Google API.
    • com.google.api.services.health.*: Class yang dihasilkan untuk Google Health API. (Anda harus membuatnya berdasarkan dokumen penemuan API).
  • Konfigurasi:
    • CLIENT_SECRETS_PATH: Jalur ke file client_secret.json Anda.
    • TOKENS_DIRECTORY_PATH: Jalur untuk menyimpan token.
    • API_KEY: Kunci API Anda.
    • SCOPES: Izin yang diperlukan.
    • DISCOVERY_URL: URL untuk mendapatkan definisi API.
  • Metode main:
    • Melakukan inisialisasi klien Google Health API dan memanggil fetchHealthData.
  • createHealthService():
    • Membuat instance klien Google Health API, menetapkan kredensial, nama aplikasi, dan kunci API.
  • getCredentials():
    • Memuat rahasia klien dari file.
    • Membuat GoogleAuthorizationCodeFlow.
    • Mencoba memuat kredensial yang disimpan.
    • Jika tidak ada kredensial atau kredensial yang sudah habis masa berlakunya ditemukan, meminta kode otorisasi pengguna, dan menyimpan kredensial baru.
    • Menampilkan objek kredensial.
  • fetchHealthData():
    • Melakukan panggilan API ke Google Health API (ganti contoh dengan panggilan metode spesifik Anda).
    • Mencetak respons.
  • Penanganan Error: Kode menyertakan blok try...catch dasar untuk penanganan error.

JavaScript

  1. Instal Library Klien Google API:
    • Sertakan library dalam project Anda. Anda dapat menggunakan CDN atau npm.
  2. Terapkan Alur OAuth 2.0:
    • Gunakan library Google Identity Services untuk menangani alur OAuth (hasil 16.1).
  3. Membuat Permintaan API:
    • Gunakan klien yang telah diinisialisasi untuk membuat permintaan ke Google Health API.
  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();
  });
  • Mengimpor Library:
    • https://apis.google.com/js/api.js: Memuat klien Google API inti.
    • https://accounts.google.com/gsi/client: Memuat Google Identity Services untuk autentikasi.
  • Konfigurasi:
    • CLIENT_ID, API_KEY: Ganti dengan kredensial Anda yang sebenarnya.
    • DISCOVERY_URL: URL untuk mendapatkan definisi API. Anda mungkin perlu menyesuaikan ini berdasarkan penyiapan akhir Google Health API.
    • SCOPES: Tentukan izin yang diperlukan aplikasi Anda (misalnya, untuk membaca data kesehatan).
  • initClient():
    • Memuat klien Google API.
    • Menginisialisasi klien dengan kunci API dan dokumen penemuan Anda.
    • Melakukan inisialisasi klien token Layanan Identitas Google.
  • authorize():
    • Memeriksa apakah token sudah tersedia.
    • Jika tidak, metode ini akan memanggil tokenClient.requestAccessToken() untuk memulai alur OAuth.
  • fetchHealthData():
    • Memanggil authorize() untuk memastikan pengguna diautentikasi.
    • Melakukan panggilan API ke Google Health API (ganti contoh dengan panggilan spesifik Anda).
    • Mencatat respons.
  • Penanganan Error: Kode menyertakan blok try...catch dasar untuk penanganan error.

Python

  1. Instal Library Klien Google API:
    • Gunakan pip untuk menginstal library yang diperlukan.
  2. Terapkan Alur OAuth 2.0:
    • Gunakan library google-auth-oauthlib untuk menangani alur OAuth.
  3. Membuat Permintaan API:
    • Gunakan klien yang telah diinisialisasi untuk membuat permintaan ke Google Health API.
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}")
Sebelumnya
Cakupan
Berikutnya
Endpoint