ไลบรารีของไคลเอ็นต์

หน้านี้มีลิงก์ไปยังวิธีที่สะดวกในการเข้าถึง Google Health API

ไลบรารีของไคลเอ็นต์ Google Health API

Google Health API สร้างขึ้นในรูปแบบ HTTP และ JSON ไคลเอ็นต์ HTTP มาตรฐานต่างๆ จึงส่งคำขอไปยัง API นี้และแยกวิเคราะห์การตอบกลับได้

อย่างไรก็ตาม คุณอาจต้องการใช้ไลบรารีของไคลเอ็นต์ Google APIs แทนการสร้างคำขอ HTTP และการแยกวิเคราะห์การตอบกลับด้วยตนเอง ไลบรารีของไคลเอ็นต์มีการผสานรวมภาษาที่ดีกว่า ความปลอดภัยที่ดียิ่งขึ้น และการรองรับการเรียกที่ต้องมีการให้สิทธิ์ผู้ใช้

Go

ดูไลบรารีของไคลเอ็นต์ Google Health API ล่าสุดสำหรับ Go อ่านคู่มือสำหรับนักพัฒนาซอฟต์แวร์เกี่ยวกับไลบรารีของไคลเอ็นต์

Java

หน้านี้มีข้อมูลเกี่ยวกับการเริ่มต้นใช้งาน Google Health API โดยใช้ไลบรารีของไคลเอ็นต์ Google API สำหรับ Java สําหรับข้อมูลเพิ่มเติม โปรดดูเอกสารประกอบต่อไปนี้

เพิ่มไลบรารีของไคลเอ็นต์ลงในโปรเจ็กต์

เลือกสภาพแวดล้อมของบิลด์ (Maven หรือ Gradle) จากแท็บต่อไปนี้

JavaScript

อ่านคู่มือสำหรับนักพัฒนาซอฟต์แวร์เกี่ยวกับไลบรารีของไคลเอ็นต์

.NET

หน้านี้มีข้อมูลเกี่ยวกับการเริ่มต้นใช้งาน Google Health API โดยใช้ไลบรารีของไคลเอ็นต์ Google API สำหรับ .NET สําหรับข้อมูลเพิ่มเติม โปรดดูเอกสารประกอบต่อไปนี้

การดาวน์โหลดไลบรารี

ติดตั้งแพ็กเกจ NuGet นี้ Google.Apis

Node.js

ดูไลบรารีของไคลเอ็นต์ Google Health API ล่าสุดสำหรับ Node.js อ่านคู่มือสำหรับนักพัฒนาซอฟต์แวร์เกี่ยวกับไลบรารีของไคลเอ็นต์

Obj-C

ดูไลบรารีของไคลเอ็นต์ Google Health API ล่าสุดสำหรับ Objective-C อ่านคู่มือสำหรับนักพัฒนาซอฟต์แวร์เกี่ยวกับไลบรารีของไคลเอ็นต์

PHP

ดูไลบรารีของไคลเอ็นต์ Google Health API ล่าสุดสำหรับ PHP อ่านคู่มือสำหรับนักพัฒนาซอฟต์แวร์เกี่ยวกับไลบรารีของไคลเอ็นต์

Python

หน้านี้มีข้อมูลเกี่ยวกับการเริ่มต้นใช้งาน Google Health API โดยใช้ไลบรารีของไคลเอ็นต์ Google API สำหรับ Python (v1/v2) สําหรับข้อมูลเพิ่มเติม โปรดดูเอกสารประกอบต่อไปนี้

ข้อกำหนดของระบบ

ติดตั้งไลบรารีของไคลเอ็นต์

คุณจะใช้เครื่องมือจัดการแพ็กเกจหรือดาวน์โหลดและติดตั้งไลบรารีของไคลเอ็นต์ Python ด้วยตนเองก็ได้โดยทำดังนี้

การติดตั้งที่มีการจัดการ

ใช้ pip หรือ setuptools เพื่อจัดการการติดตั้ง (คุณอาจต้องเรียกใช้ sudo ก่อน) ดังนี้

  • pip (แนะนำ) 
    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 ในสภาพแวดล้อมรันไทม์ของ Python สําหรับ App Engine คุณจึงต้องคัดลอกไลบรารีเหล่านี้ลงในแอปพลิเคชันเช่นเดียวกับไลบรารีของบุคคลที่สาม

Ruby

หน้านี้มีข้อมูลเกี่ยวกับการเริ่มต้นใช้งาน Google Health API โดยใช้ไลบรารีของไคลเอ็นต์ Google API สำหรับ Ruby สําหรับข้อมูลเพิ่มเติม โปรดดูเอกสารประกอบต่อไปนี้

ติดตั้ง Gem google-api-client

อาจต้องเพิ่ม sudo ไว้หน้าคำสั่งเหล่านี้ ทั้งนี้ขึ้นอยู่กับระบบของคุณ

หากคุณยังไม่เคยติดตั้งไลบรารีของไคลเอ็นต์ Google API สำหรับ Ruby มาก่อน ให้ติดตั้งโดยใช้ RubyGems ดังนี้ 

gem install google-api-client

หากติดตั้ง Gem แล้ว ให้อัปเดตเป็นเวอร์ชันล่าสุด 

gem update -y google-api-client

การเริ่มต้นใช้งานไลบรารีของไคลเอ็นต์ Google API สำหรับ Ruby

ดูวิธีส่งคำขอแรกได้ที่คู่มือเริ่มต้นใช้งาน

gRPC

นอกจากนี้ Google Health API ยังรองรับ gRPC สำหรับการดึงข้อมูลประสิทธิภาพสูงด้วย นอกเหนือจากการติดตั้งไลบรารีของไคลเอ็นต์แล้ว การใช้ gRPC ยังต้องมีการขอรับ คำจำกัดความ Protocol Buffers ของ API และการสร้างโค้ด Stub ฝั่งไคลเอ็นต์ ก่อนที่จะส่งคำขอ

  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 เพื่อสร้าง โค้ด Stub
  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: ชื่อโฮสต์สำหรับบริการ gRPC ของ Google Health
  • get_credentials():
    • โหลดข้อมูลลับไคลเอ็นต์จากไฟล์ ใช้ InstalledAppFlow from google-auth-oauthlib เพื่อจัดการการให้สิทธิ์ พยายามโหลดข้อมูลเข้าสู่ระบบที่จัดเก็บไว้ หรือเริ่มขั้นตอน OAuth 2.0 หากจำเป็น
  • fetch_health_data_grpc():
    • สร้างช่อง gRPC ที่ปลอดภัยและมีการตรวจสอบสิทธิ์โดยใช้ข้อมูลเข้าสู่ระบบของผู้ใช้
    • เริ่มต้น DataPointsServiceStub ด้วยช่อง
    • สร้าง ListDataPointsRequest เพื่อขอข้อมูลจำนวนก้าวสำหรับ users/me
    • เรียกใช้ListDataPointsเมธอด RPC และพิมพ์การตอบกลับ
  • การจัดการข้อผิดพลาด: โค้ดมีบล็อก try...except พื้นฐานสำหรับ การจัดการข้อผิดพลาดของ gRPC และข้อผิดพลาดอื่นๆ
ก่อนหน้า
ขอบเขต
ถัดไป
ขีดจำกัดอัตรา