क्लाइंट लाइब्रेरी

इस पेज पर, Google Health API को ऐक्सेस करने के लिए, क्लाइंट लाइब्रेरी के उदाहरण दिए गए हैं.

Google Health API को एचटीटीपी और JSON पर बनाया गया है. इसलिए, कोई भी स्टैंडर्ड एचटीटीपी क्लाइंट इसके लिए अनुरोध भेज सकता है और जवाबों को पार्स कर सकता है.

हालांकि, एचटीटीपी अनुरोधों को मैन्युअल तरीके से बनाने और जवाबों को पार्स करने के बजाय, यहां दिए गए क्लाइंट लाइब्रेरी के उदाहरणों और डाउनलोड का इस्तेमाल किया जा सकता है.

Java

  1. Google API क्लाइंट लाइब्रेरी जोड़ना:
    • Maven या Gradle का इस्तेमाल करके, लाइब्रेरी को अपने प्रोजेक्ट में शामिल करें.
  2. OAuth 2.0 फ़्लो लागू करना:
    • OAuth फ़्लो को मैनेज करने के लिए, google-auth-library-java का इस्तेमाल करें.
  3. एपीआई अनुरोध करना:
    • 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());
}
  • लाइब्रेरी इंपोर्ट करना:
    • com.google.api.client.*: Google API क्लाइंट के लिए कोर लाइब्रेरी.
    • com.google.api.services.health.*: Google Health API के लिए जनरेट की गई क्लास. (आपको यह क्लास, एपीआई की खोज से जुड़े दस्तावेज़ के आधार पर जनरेट करनी होगी).
  • कॉन्फ़िगरेशन:
    • CLIENT_SECRETS_PATH: आपकी client_secret.json फ़ाइल का पाथ.
    • TOKENS_DIRECTORY_PATH: टोकन सेव करने का पाथ.
    • API_KEY: आपका एपीआई पासकोड.
    • SCOPES: ज़रूरी अनुमतियां.
    • DISCOVERY_URL: एपीआई की परिभाषा पाने का यूआरएल.
  • main तरीका:
    • Google Health API क्लाइंट को शुरू करता है और fetchHealthData को कॉल करता है.
  • createHealthService():
    • Google Health API क्लाइंट का इंस्टेंस बनाता है. साथ ही, क्रेडेंशियल, ऐप्लिकेशन का नाम, और एपीआई पासकोड सेट करता है.
  • getCredentials():
    • फ़ाइल से क्लाइंट सीक्रेट लोड करता है.
    • GoogleAuthorizationCodeFlow बनाता है.
    • सेव किए गए क्रेडेंशियल लोड करने की कोशिश करता है.
    • अगर कोई क्रेडेंशियल नहीं मिलता है या क्रेडेंशियल की समयसीमा खत्म हो गई है, तो उपयोगकर्ता से अनुमति कोड के लिए कहा जाता है. साथ ही, नए क्रेडेंशियल सेव किए जाते हैं.
    • क्रेडेंशियल ऑब्जेक्ट दिखाता है.
  • fetchHealthData():
    • Google Health API को एपीआई कॉल करता है. उदाहरण के तौर पर दिए गए कोड को, अपने खास तरीके के कॉल से बदलें.
    • जवाब प्रिंट करता है.
  • गड़बड़ी को ठीक करना: कोड में, गड़बड़ी को ठीक करने के लिए, try...catch ब्लॉक शामिल हैं.

JavaScript

  1. Google API क्लाइंट लाइब्रेरी इंस्टॉल करना:
    • लाइब्रेरी को अपने प्रोजेक्ट में शामिल करें. इसके लिए, सीडीएन या एनपीएम का इस्तेमाल किया जा सकता है.
  2. OAuth 2.0 फ़्लो लागू करना:
    • OAuth फ़्लो को मैनेज करने के लिए, Google Identity Services लाइब्रेरी का इस्तेमाल करें (नतीजा 16.1).
  3. एपीआई अनुरोध करना:
    • 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();
  });
  • लाइब्रेरी इंपोर्ट करना:
    • https://apis.google.com/js/api.js: Google API क्लाइंट का कोर लोड करता है.
    • https://accounts.google.com/gsi/client: पुष्टि करने के लिए, Google Identity Services लोड करता है.
  • कॉन्फ़िगरेशन:
    • CLIENT_ID, API_KEY: इन्हें अपने असली क्रेडेंशियल से बदलें.
    • DISCOVERY_URL: एपीआई की परिभाषा पाने का यूआरएल. Google Health API के फ़ाइनल सेटअप के आधार पर, आपको इसमें बदलाव करना पड़ सकता है.
    • SCOPES: ज़रूरी अनुमतियां तय करें. जैसे, हेल्थ डेटा पढ़ने के लिए.
  • initClient():
    • Google API क्लाइंट लोड करता है.
    • आपके एपीआई पासकोड और खोज से जुड़े दस्तावेज़ की मदद से, क्लाइंट को शुरू करता है.
    • Google Identity Services टोकन क्लाइंट को शुरू करता है.
  • authorize():
    • देखता है कि कोई टोकन पहले से उपलब्ध है या नहीं.
    • अगर नहीं, तो OAuth फ़्लो शुरू करने के लिए, tokenClient.requestAccessToken() को कॉल करता है.
  • fetchHealthData():
    • authorize() को कॉल करके यह पक्का करता है कि उपयोगकर्ता की पुष्टि हो गई हो.
    • Google Health API को एपीआई कॉल करता है. उदाहरण के तौर पर दिए गए कोड को, अपने खास कॉल से बदलें.
    • जवाब लॉग करता है.
  • गड़बड़ी को ठीक करना: कोड में, गड़बड़ी को ठीक करने के लिए, try...catch ब्लॉक शामिल हैं.

Python

  1. Google API क्लाइंट लाइब्रेरी इंस्टॉल करना:
    • ज़रूरी लाइब्रेरी इंस्टॉल करने के लिए, pip का इस्तेमाल करें.
  2. OAuth 2.0 फ़्लो लागू करना:
    • OAuth फ़्लो को मैनेज करने के लिए, google-auth-oauthlib लाइब्रेरी का इस्तेमाल करें.
  3. एपीआई अनुरोध करना:
    • 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}")
पीछे जाएं
दायरा
आगे बढ़ें
एंडपॉइंट