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

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

Google Health API की क्लाइंट लाइब्रेरी

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

हालांकि, एचटीटीपी अनुरोध बनाने और जवाबों को मैन्युअल तरीके से पार्स करने के बजाय, Google APIs की क्लाइंट लाइब्रेरी का इस्तेमाल किया जा सकता है. क्लाइंट लाइब्रेरी की मदद से, ऐसे कॉल के लिए भाषा का बेहतर इंटिग्रेशन, बेहतर सुरक्षा, और सहायता मिलती है जिनमें उपयोगकर्ता की अनुमति ज़रूरी होती है.

Go

Go के लिए, Google Health API की क्लाइंट लाइब्रेरी का नया वर्शन डाउनलोड करें. क्लाइंट लाइब्रेरी का इस्तेमाल करने से जुड़ी डेवलपर गाइड पढ़ें.

Java

इस पेज में Java के लिए, Google API की क्लाइंट लाइब्रेरी का इस्तेमाल करके, Google Health API का इस्तेमाल शुरू करने के बारे में जानकारी दी गई है. ज़्यादा जानकारी के लिए, यहां दिए गए दस्तावेज़ देखें:

अपने प्रोजेक्ट में क्लाइंट लाइब्रेरी जोड़ना

इन टैब से अपना बिल्ड एनवायरमेंट (Maven या Gradle) चुनें:

JavaScript

क्लाइंट लाइब्रेरी का इस्तेमाल करने से जुड़ी डेवलपर गाइड पढ़ें.

.NET

इस पेज में .NET के लिए, Google API की क्लाइंट लाइब्रेरी का इस्तेमाल करके, Google Health API का इस्तेमाल शुरू करने के बारे में जानकारी दी गई है. ज़्यादा जानकारी के लिए, यहां दिए गए दस्तावेज़ देखें:

लाइब्रेरी डाउनलोड करना

NuGet पैकेज Google.Apis इंस्टॉल करें.

Node.js

Node.js के लिए, Google Health API की क्लाइंट लाइब्रेरी का नया वर्शन डाउनलोड करें. क्लाइंट लाइब्रेरी का इस्तेमाल करने से जुड़ी डेवलपर गाइड पढ़ें.

Obj-C

Objective-C के लिए, Google Health API की क्लाइंट लाइब्रेरी का नया वर्शन डाउनलोड करें. क्लाइंट लाइब्रेरी का इस्तेमाल करने से जुड़ी डेवलपर गाइड पढ़ें.

PHP

PHP के लिए, Google Health API की क्लाइंट लाइब्रेरी का नया वर्शन डाउनलोड करें. क्लाइंट लाइब्रेरी का इस्तेमाल करने से जुड़ी डेवलपर गाइड पढ़ें.

Python

इस पेज पर, Python (v1/v2) के लिए Google API की क्लाइंट लाइब्रेरी का इस्तेमाल करके, Google Health API का इस्तेमाल शुरू करने के बारे में जानकारी दी गई है. ज़्यादा जानकारी के लिए, यहां दिए गए दस्तावेज़ देखें:

सिस्टम के लिए ज़रूरी शर्तें

क्लाइंट लाइब्रेरी इंस्टॉल करना

पैकेज मैनेजर का इस्तेमाल किया जा सकता है. इसके अलावा, Python की क्लाइंट लाइब्रेरी को मैन्युअल तरीके से डाउनलोड और इंस्टॉल किया जा सकता है:

इंस्टॉल करने के तरीके को मैनेज करना

अपने इंस्टॉल करने के तरीके को मैनेज करने के लिए, पीआईपी या setuptools का इस्तेमाल करें. आपको पहले चलाने की ज़रूरत पड़ सकती है. आपको पहले sudo चलाने की ज़रूरत पड़ सकती है.

  • पीआईपी (इसका इस्तेमाल करना बेहतर होगा): 
    pip install --upgrade google-api-python-client
  • Setuptools: 
    easy_install --upgrade google-api-python-client

मैन्युअल तरीके से इंस्टॉल करना

  1. Python के लिए क्लाइंट लाइब्रेरी का नया वर्शन डाउनलोड करें.
  2. कोड को अनपैक करें.
  3. इंस्टॉल करें: 
    python setup.py install

App Engine

Python की क्लाइंट लाइब्रेरी को App Engine Python रनटाइम एनवायरमेंट में इंस्टॉल नहीं किया गया है. इन्हें तीसरे पक्ष की लाइब्रेरी की तरह आपके ऐप्लिकेशन में कॉपी किया जाना चाहिए.

Ruby

इस पेज पर, Ruby के लिए Google API की क्लाइंट लाइब्रेरी का इस्तेमाल करके, Google Health API का इस्तेमाल शुरू करने के बारे में जानकारी दी गई है. ज़्यादा जानकारी के लिए, यहां दिए गए दस्तावेज़ देखें:

google-api-client जेम को इंस्टॉल करना

अपने सिस्टम के हिसाब से, आपको इन कमांड को sudo के साथ जोड़ना होगा.

अगर आपने Ruby के लिए, Google API क्लाइंट लाइब्रेरी को इंस्टॉल नहीं किया है, तो RubyGems का इस्तेमाल करके इंस्टॉल करें: 

gem install google-api-client

अगर आपने पहले से ही जेम इंस्टॉल किया है, तो इसे नए वर्शन में अपडेट करें: 

gem update -y google-api-client

Ruby के लिए Google API क्लाइंट लाइब्रेरी का इस्तेमाल शुरू करना

अपना पहला अनुरोध कैसे करें. इसके बारे में जानने के लिए, शुरुआती निर्देश देखें.

gRPC

Google Health API, तेज़ी से डेटा पाने के लिए gRPC की सुविधा भी देता है. क्लाइंट लाइब्रेरी इंस्टॉल करने के अलावा, gRPC का इस्तेमाल करने के लिए, अनुरोध करने से पहले, एपीआई के प्रोटोकॉल बफ़र की परिभाषाएं हासिल करनी होंगी और क्लाइंट-साइड स्टब कोड जनरेट करना होगा.

  1. gRPC लाइब्रेरी इंस्टॉल करना:
    • डिपेंडेंसी इंस्टॉल करने के लिए, pip install grpcio grpcio-tools google-auth-oauthlib का इस्तेमाल करें.
  2. क्लाइंट कोड जनरेट करना:
    • Google Health API की .proto परिभाषाएं हासिल करें. जैसे, data_points.proto.
    • स्टब कोड जनरेट करने के लिए, python -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. path/to/your/data_points.proto चलाएं.
  3. OAuth 2.0 लागू करना और gRPC अनुरोध करना:
    • अनुमति के लिए google-auth-oauthlib और gRPC अनुरोध करने के लिए, जनरेट किए गए क्लाइंट स्टब का इस्तेमाल करें. इसका उदाहरण यहां दिया गया है.
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}")
  • लाइब्रेरी इंपोर्ट करना:
    • grpc: gRPC की Python लाइब्रेरी.
    • google.auth.transport.grpc: सुरक्षित, पुष्टि किए गए चैनल बनाने के लिए.
    • data_points_pb2, data_points_pb2_grpc: .proto फ़ाइलों से जनरेट किया गया क्लाइंट कोड.
  • कॉन्फ़िगरेशन:
    • CLIENT_SECRETS_FILE: आपकी client_secret.json फ़ाइल का पाथ.
    • SCOPES: ज़रूरी अनुमतियां.
    • TOKEN_FILE: OAuth टोकन सेव करने का पाथ.
    • GRPC_ENDPOINT: Google Health gRPC सेवा का होस्टनेम.
  • get_credentials():
    • फ़ाइल से क्लाइंट सीक्रेट लोड करता है, अनुमति मैनेज करने के लिए google-auth-oauthlib से InstalledAppFlow का इस्तेमाल करता है, सेव की गई क्रेडेंशियल लोड करने की कोशिश करता है या ज़रूरत पड़ने पर OAuth 2.0 फ़्लो शुरू करता है.
  • fetch_health_data_grpc():
    • उपयोगकर्ता के क्रेडेंशियल का इस्तेमाल करके, सुरक्षित, पुष्टि किया गया gRPC चैनल बनाता है.
    • चैनल के साथ DataPointsServiceStub शुरू करता है.
    • users/me के लिए, चरणों का डेटा अनुरोध करने के लिए ListDataPointsRequest बनाता है.
    • ListDataPoints RPC तरीके को कॉल करता है और जवाब प्रिंट करता है.
  • गड़बड़ी को ठीक करना: कोड में, gRPC और अन्य गड़बड़ियों को ठीक करने के लिए, try...except के बुनियादी ब्लॉक शामिल हैं.
पीछे जाएं
दायरा
आगे बढ़ें
दर की सीमाएं