כדאי להתחיל לבצע את המיגרציה או לפתח אפליקציה חדשה כבר היום. אפליקציות עם יותר מ-100 משתמשים יוכלו לשלוח בקשה לאימות החל מ-30 במרץ.

כדי להבטיח חוויה חלקה למשתמשים, מומלץ להמתין עד סוף מאי 2026 כדי להשיק רשמית את השילוב, בהתאם להוצאה משימוש של חשבונות Fitbit מדור קודם. לתשומת ליבך, מעכשיו ועד סוף מאי, יכולים להתרחש שינויים משמעותיים כתוצאה מהמשוב של המפתחים.

ספריות לקוח

בדף הזה מופיעות דוגמאות לספריות לקוח לגישה אל Google Health API.

ממשק Google Health API מבוסס על HTTP ועל JSON, כך שכל לקוח HTTP סטנדרטי יכול לשלוח אליו בקשות ולנתח את התשובות.

עם זאת, במקום ליצור בקשות HTTP ולנתח את התגובות באופן ידני, אפשר להשתמש בדוגמאות ובקבצים להורדה של ספריית הלקוח שמופיעים כאן.

Java

מוסיפים את ספריית הלקוח של Google API:
- כוללים את הספרייה בפרויקט (באמצעות Maven או Gradle).
הטמעת הרשאה באמצעות OAuth 2.0:
- משתמשים ב-google-auth-library-java כדי לטפל בתהליך OAuth.
שליחת בקשות API:
- משתמשים בלקוח המאותחל כדי לשלוח בקשות ל-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. (תצטרכו ליצור את המפתח הזה על סמך מסמך הגילוי של ה-API).
הגדרה:
- ‫CLIENT_SECRETS_PATH: הנתיב לקובץ client_secret.json.
- ‫TOKENS_DIRECTORY_PATH: הנתיב לשמירת האסימונים.
- ‫API_KEY: מפתח ה-API.
- ‫SCOPES: ההרשאות הנדרשות.
- ‫DISCOVERY_URL: כתובת ה-URL לקבלת הגדרת ה-API.
main Method:
- מאתחל את הלקוח של Google Health API וקורא ל-fetchHealthData.
createHealthService():
- יוצר מופע של לקוח Google Health API, ומגדיר פרטי כניסה, שם אפליקציה ומפתח API.
getCredentials():
- טוען סודות לקוח מקובץ.
- יצירת GoogleAuthorizationCodeFlow.
- ניסיונות לטעון פרטי כניסה מאוחסנים.
- אם לא נמצאו פרטי כניסה או שנמצאו פרטי כניסה שתוקפם פג, המערכת תבקש מהמשתמש קוד הרשאה ותשמור את פרטי הכניסה החדשים.
- הפונקציה מחזירה את אובייקט פרטי הכניסה.
fetchHealthData():
- שליחת קריאה ל-Google Health API (צריך להחליף את הדוגמה בקריאות ספציפיות לשיטות).
- הדפסת התשובה.
טיפול בשגיאות: הקוד כולל בלוקים בסיסיים של try...catch לטיפול בשגיאות.

JavaScript

מתקינים את ספריית הלקוח של Google API:
- כוללים את הספרייה בפרויקט. אפשר להשתמש ב-CDN או ב-npm.
הטמעת הרשאה באמצעות OAuth 2.0:
- משתמשים בספריית Google Identity Services כדי לטפל בתהליך OAuth (תוצאה 16.1).
שליחת בקשות API:
- משתמשים בלקוח המאותחל כדי לשלוח בקשות ל-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: כתובת ה-URL לקבלת הגדרת ה-API. יכול להיות שתצטרכו לבצע שינויים בהתאם להגדרה הסופית של Google Health API.
- ‫SCOPES: מגדירים את ההרשאות הנדרשות לאפליקציה (למשל, הרשאה לקריאת נתוני בריאות).
initClient():
- טוען את לקוח Google API.
- הפונקציה מאתחלת את הלקוח באמצעות מפתח ה-API ומסמך הגילוי.
- הפעלת לקוח האסימונים של Google Identity Services.
authorize():
- בודק אם טוקן כבר זמין.
- אם לא, המערכת מתקשרת אל tokenClient.requestAccessToken() כדי להתחיל את תהליך OAuth.
fetchHealthData():
- מתבצעת קריאה ל-authorize() כדי לוודא שהמשתמש מאומת.
- שליחת קריאה ל-Google Health API (צריך להחליף את הדוגמה בקריאות הספציפיות שלכם).
- התשובה נרשמת ביומן.
טיפול בשגיאות: הקוד כולל בלוקים בסיסיים של try...catch לטיפול בשגיאות.

Python

מתקינים את ספריית הלקוח של Google API:
- משתמשים ב-pip כדי להתקין את הספריות הנדרשות.
הטמעת הרשאה באמצעות OAuth 2.0:
- אפשר להשתמש בספרייה google-auth-oauthlib כדי לטפל בתהליך OAuth.
שליחת בקשות API:
- משתמשים בלקוח המאותחל כדי לשלוח בקשות ל-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}")

היקפים

נקודות קצה

ספריות לקוח קל לארגן דפים בעזרת אוספים אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.

Java

JavaScript

Python

ספריות לקוח