Wykonywanie pierwszego wywołania interfejsu Google Health API

1. Wprowadzenie

Visual Studio Code (VS Code) i rozszerzenie Rest Client autorstwa Huachao Mao umożliwiają testowanie procesu akceptacji OAuth Google i interfejsu Google Health API. W tym ćwiczeniu pokażemy, jak skonfigurować rozszerzenie Rest Client, jak rozpocząć proces autoryzacji i jak wykonać pierwsze wywołanie jednego z punktów końcowych interfejsu Google Health API. Następnie możesz zapoznać się z dokumentacją klienta REST i dokumentacją Fitbita, aby utworzyć pozostałe punkty końcowe w projekcie HTTP.

Jeśli nie chcesz używać VS Code i Rest Client, wywołania interfejsu API możesz wykonywać za pomocą poleceń curl.

Czego się nauczysz

  • Jak skonfigurować VS Code z rozszerzeniem Rest client.
  • Jak skonfigurować identyfikator klienta w konsoli Google Cloud.
  • Jak przejść proces autoryzacji Google OAuth 2.0, aby uzyskać token dostępu i token odświeżania.
  • Jak wykonywać wywołania punktów końcowych interfejsu Google Health API za pomocą klienta REST.

Czego potrzebujesz

Aby skonfigurować aplikację mobilną Fitbit:

  1. W Apple App Store lub Sklepie Google Play wyszukaj aplikację mobilną Fitbit i pobierz ją.
  2. Kliknij ikonę aplikacji.
  3. Kliknij Zaloguj się przez Google.
  4. Wybierz konto Google i kliknij przycisk Dalej.

Aby zainstalować narzędzia Visual Studio:

  1. Pobierz VS Code. Zwykle pobrany plik zawiera plik wykonywalny.
  2. Uruchom VS Code.
  3. Zainstaluj rozszerzenie Rest Client autorstwa Huachao Mao.
    • Po lewej stronie IDE kliknij ikonę rozszerzenia rozszerzenie.
    • Wyszukaj REST Client by Huachao Mao i kliknij Install (Zainstaluj).

2. Konfigurowanie projektu w chmurze Google

W konsoli Google Cloud utworzysz identyfikator klienta i włączysz korzystanie z interfejsu Google Health API.

  1. Zaloguj się w konsoli Google Cloud.
  2. Aby utworzyć nowy projekt:
    1. W selektorze projektów kliknij Wybierz projekt.
    2. W prawym górnym rogu kliknij Nowy projekt.
    3. Wpisz nazwę projektu.
    4. Wpisz lokalizację (np. „Brak organizacji”).
    5. Kliknij przycisk Utwórz.
    6. Wybierz projekt.

Włączanie interfejsu Google Health API

  1. W lewym górnym rogu kliknij ikonę menu:menu
  2. Kliknij Interfejsy API i usługi > Biblioteka.
  3. Wyszukaj „Google Health API” i włącz go.

Konfigurowanie danych logowania OAuth

Jeśli nie jesteś w konsoli Google Cloud, otwórz konsolę Google Cloud.

  1. W lewym górnym rogu kliknij ikonę menu:menu
  2. Kliknij Interfejsy API i usługi > Dane logowania.
  3. U góry pośrodku kliknij + Utwórz dane logowania > Identyfikator klienta OAuth.
  4. Kliknij przycisk Skonfiguruj ekran zgody. Jeśli pojawi się komunikat „Platforma uwierzytelniania Google nie została jeszcze skonfigurowana”, kliknij przycisk Rozpocznij.
  5. W sekcji 1:
    1. Wpisz nazwę aplikacji.
    2. Wpisz adres e-mail dla użytkowników potrzebujących pomocy.
    3. Kliknij przycisk Dalej.
  6. W sekcji 2:
    1. Kliknij Zewnętrzne.
    2. Kliknij przycisk Dalej.
  7. W sekcji 3:
    1. Wpisz swój adres e-mail w polu Informacje kontaktowe.
    2. Kliknij przycisk Dalej.
  8. W sekcji 4:
    1. Kliknij pole wyboru, aby zaakceptować zasady dotyczące danych użytkownika w usługach interfejsów API Google.
    2. Kliknij przycisk Utwórz.
  9. W sekcji danych naciśnij przycisk Utwórz klienta OAuth.
  10. Wybierz typ aplikacji Aplikacja internetowa.
  11. Wpisz nazwę identyfikatora klienta.
  12. Pozostaw pole Autoryzowane źródła JavaScriptu puste.
  13. W sekcji Autoryzowane identyfikatory URI przekierowania kliknij przycisk + Dodaj URI. Jako identyfikator URI przekierowania wpisz „https://www.google.com”.
  14. Kliknij przycisk Utwórz.
  15. W konsoli Google pojawi się komunikat o utworzeniu identyfikatora klienta. Kliknij link Pobierz plik JSON, aby pobrać identyfikator klienta i tajny klucz klienta, lub zapisz te wartości. Nie będzie można później odzyskać tajnego klucza klienta.
  16. Kliknij OK. Wrócisz na stronę „Identyfikatory klienta OAuth 2.0”.
  17. Identyfikator klienta zostanie dodany do projektu. Kliknij adres URL identyfikatora klienta, aby wyświetlić szczegóły.

Dodawanie użytkowników testowych

  1. W panelu po lewej stronie kliknij Odbiorcy. Powinien wyświetlić się „Stan publikacji” ustawiony na Testowanie i „Typ użytkownika” ustawiony na Zewnętrzny.
  2. W sekcji „Użytkownicy testowi” kliknij przycisk + Dodaj użytkowników. Wpisz adres e-mail użytkownika, którego dane chcesz pobrać.
  3. Kliknij przycisk Zapisz.

Dodawanie zakresów do identyfikatora klienta

  1. W panelu po lewej stronie kliknij Dostęp do danych.
  2. Kliknij przycisk Dodaj lub usuń zakresy.
  3. W kolumnie API wyszukaj „Google Health API”. W tym ćwiczeniu używamy zakresu .../auth/googlehealth.activity_and_fitness.readonly.
  4. Po wybraniu zakresu kliknij przycisk Aktualizuj, aby wrócić na stronę Dostęp do danych.
  5. Kliknij przycisk Zapisz.

Identyfikator klienta został skonfigurowany.

3. Tworzenie przepływu autoryzacji

  1. Otwórz aplikację VS Code na komputerze.
  2. Na ekranie powitalnym kliknij Otwórz.
  3. Wybierz folder, w którym chcesz utworzyć ten projekt, i kliknij Otwórz. Ekran powinien wyglądać podobnie do tego, który widzisz poniżej. W Eksploratorze powinna być widoczna nazwa folderu lub projektu.VSC
  4. W menu głównym wybierz Plik –> Nowy plik tekstowy.
  5. Zapisz plik, aby nadać mu nazwę. W menu głównym wybierz File -> Save As -> Codelab.http (Plik –> Zapisz jako –> Codelab.http). Plik powinien zostać umieszczony w projekcie. Rozszerzenie pliku musi mieć postać .http lub .rest. W tym ćwiczeniu używamy formatu .http.

W tym projekcie będziemy wielokrotnie używać kilku wartości. Wartości te to:

client_id

Wartość identyfikatora klienta z konsoli Google.

secret

Wartość tajnego klucza klienta z konsoli Google.

redirect_uri

Punkt końcowy w aplikacji, który przetwarza kod autoryzacji. W tym ćwiczeniu z programowania używamy adresu https://www.google.com

access_token

Token dostępu utworzony dla użytkownika po zakończeniu procesu uzyskiwania zgody.

refresh_token

Token odświeżania utworzony dla użytkownika po zakończeniu procesu uzyskiwania zgody.

Dodaj ten kod, który definiuje zmienne używane w tym projekcie. Powinny znajdować się u góry pliku Codelab.http. Wpisz wartości identyfikatora klienta i klucza tajnego.

### File Variables for the Codelab
@client_id =
@secret =
@redirect_uri = https://www.google.com
@accessToken={{user.response.body.access_token}}
@refreshToken={{user.response.body.refresh_token}}

Adres URL autoryzacji, który służy do inicjowania procesu uzyskiwania zgody, zostanie wysłany do każdego użytkownika, do którego danych chcesz uzyskać dostęp. Aby utworzyć adres URL autoryzacji, musimy znać punkt końcowy protokołu OAuth Google i użyć parametrów zapytania, aby określić identyfikator klienta, zakresy, do których chcemy uzyskać dostęp, oraz miejsce, do którego użytkownik ma zostać przekierowany po wyrażeniu zgody na zakresy. Pełną dokumentację dotyczącą tworzenia ciągu autoryzacji Google znajdziesz w dokumentacji.

Punkt końcowy OAuth 2.0 Google znajduje się pod adresem https://accounts.google.com/o/oauth2/v2/auth. Ten punkt końcowy jest dostępny tylko przez HTTPS. Zwykłe połączenia HTTP są odrzucane.

Serwer autoryzacji Google obsługuje wiele parametrów ciągu zapytania, które aplikacje serwera WWW mogą wykorzystywać do dostosowywania procesu autoryzacji. Będziemy używać tych wymaganych parametrów zapytania: client_id, redirect_uri, response_type i scope. Dokumentacja zawiera listę wszystkich parametrów zapytania i ich opis.

Wartości parametrów zapytania to:

client_id

Wartość identyfikatora klienta z konsoli Google.

redirect_uri

Punkt końcowy w aplikacji, który przetwarza kod autoryzacji. W przypadku ćwiczeń z programowania użyj adresu https://www.google.com

response_type

code (obsługiwana wartość w przypadku aplikacji internetowych)

scope

Zakresy pochodzą z konsoli Google i mają składnię https://www.googleapis.com, po której następuje nazwa zakresu. Na przykład https://www.googleapis.com/auth/googlehealth.activity_and_fitness.

Aby poprosić o kilka zakresów, uwzględnij wszystkie zakresy w parametrze scope, oddzielając je spacjami (np. scope1 scope2 scope3). Gdy spacje są częścią adresu URL, muszą być zakodowane na potrzeby adresu URL (np. %20).

Po zmiennych wpisz adres URL autoryzacji, jak pokazano poniżej. Parametrów zdefiniowanych u góry projektu nie można używać w ciągu autoryzacji. Dlatego musimy uwzględnić wartości client_id i redirect_uri. Zastąp ciąg client-id identyfikatorem klienta.

### Google Health API Rest Client Example

### Authorization String
https://accounts.google.com/o/oauth2/v2/auth?client_id=client-id&redirect_uri=https://www.google.com&response_type=code&access_type=offline&scope=https://www.googleapis.com/auth/googlehealth.activity_and_fitness.readonly

Gdy użytkownik udzieli zgody, Google udostępni kod autoryzacji, który możesz wymienić na token dostępu, wywołując punkt końcowy tokena Google. Dodaj poniżej ciągu autoryzacji tę definicję wywołania punktu końcowego tokena: Codelab.http W następnym kroku zastąpisz symbol authorization-code kodem autoryzacji.

### AUTHORIZATION ENDPOINTS
######################################################################
# @name user
POST https://oauth2.googleapis.com/token
Content-Type: application/x-www-form-urlencoded

code=authorization-code&client_id={{clientId}}&client_secret={{secret}}&redirect_uri={{redirect_uri}}&grant_type=authorization_code

@name user odnosi się do bieżącego użytkownika, którego dane są dostępne.

4. Autoryzowanie konta i uzyskiwanie tokenów

Teraz omówimy proces autoryzacji, aby uzyskać tokeny autoryzacji.

Ciąg autoryzacji w Codelab.http służy do inicjowania procesu uzyskiwania zgody w przeglądarce Google. Rozszerzenie Rest Client może wyświetlać link Wyślij żądanie dla tego adresu URL. Nie używaj opcji Wyślij prośbę w przypadku tego konkretnego adresu URL. Zamiast tego skopiuj go i wklej do przeglądarki lub użyj kombinacji Ctrl+kliknięcie (Windows/Linux) lub Cmd+kliknięcie (Mac) w VS Code, aby otworzyć go w domyślnej przeglądarce.

https://accounts.google.com/o/oauth2/v2/auth?client_id=client-id&redirect_uri=https://www.google.com&response_type=code&access_type=offline&scope=https://www.googleapis.com/auth/googlehealth.activity_and_fitness.readonly
  1. Poprosimy Cię o zalogowanie się na konto Google. Musisz zalogować się na jedno z kont użytkowników testowych skonfigurowanych w sekcji Dodawanie użytkowników testowych.
  2. Może pojawić się komunikat z informacją, że aplikacja nie została zweryfikowana. Dzieje się tak, ponieważ aplikacja nie została opublikowana. Kliknij „Dalej”.

Zrzut ekranu przedstawiający ostrzeżenie dotyczące niezweryfikowanej aplikacji.

  1. Na stronie zgody wyświetlają się zakresy, o które prosisz. Użytkownik może wybrać zakresy, które chce udostępnić tej aplikacji. Kliknij „Dalej”.

Po wyrażeniu zgody na udostępnianie żądanych zakresów nastąpi przekierowanie na podaną przez Ciebie stronę redirect_uri (w tym ćwiczeniu jest to https://www.google.com). Google dołącza do znaku redirect_uri kod autoryzacji i inne parametry, więc adres URL na pasku adresu przeglądarki powinien wyglądać mniej więcej tak:

https://www.google.com/?code=4/0Ab32j93oyGWqaXE112sP1IKmh3kV1fE4tcHIMXYJQYWgNEtAa_0-YsfkS9Ekj3Be89u3fw&scope=https://www.googleapis.com/auth/googlehealth.activity_and_fitness.readonly

Kod autoryzacji to wartość alfanumeryczna między „code=” a „&scope”. W powyższym przykładzie wartość to:

4/0Ab32j93oyGWqaXE112sP1IKmh3kV1fE4tcHIMXYJQYWgNEtAa_0-YsfkS9Ekj3Be89u3fw

W aplikacji produkcyjnej serwer analizuje te dane z parametrów adresu URL. W tym ćwiczeniu skopiuj kod autoryzacji z adresu URL w przeglądarce.

Teraz wymień ten kod autoryzacji na access_token i refresh_token. W Codelab.http zastąp authorization-code w treści żądania POST /token skopiowanym kodem autoryzacji.

POST https://oauth2.googleapis.com/token
Content-Type: application/x-www-form-urlencoded

code=authorization-code&client_id={{client_id}}&client_secret={{secret}}&redirect_uri={{redirect_uri}}&grant_type=authorization_code

Kliknij link Wyślij prośbę tuż nad linią POST https://oauth2.googleapis.com/token.

Odpowiedź powinna wyglądać podobnie do tej:

{
  "access_token": "ya29.a0ATi6K2uasci7FyyIClNLtQou6z...",
  "expires_in": 3599,
  "refresh_token": "1//05EuqYpEXjJCHCgYIA...",
  "scope": "https://www.googleapis.com/auth/googlehealth.activity_and_fitness",
  "token_type": "Bearer",
  "refresh_token_expires_in": 604799
}

Gdy otrzymasz tę odpowiedź, Rest Client automatycznie wypełni zmienne @accessToken i @refreshToken zdefiniowane u góry Codelab.http, aby można było ich używać w kolejnych żądaniach.

Tokeny odświeżania

Gdy wymieniasz kod autoryzacji, w odpowiedzi może się pojawić refresh_token oprócz access_token. access_token są krótkotrwałe (zwykle 1 godzina). Gdy access_token wygaśnie, musisz użyć refresh_token, aby uzyskać nowy access_token bez konieczności ponownego logowania się użytkownika lub wyrażania przez niego zgody. Jest to możliwe, ponieważ w prośbie o autoryzację uwzględniliśmy parametr access_type=offline.

Jeśli w odpowiedzi nie otrzymasz refresh_token, może to oznaczać, że aplikacja i zakresy mają już Twoją zgodę. Tokeny odświeżania są zwykle wydawane tylko wtedy, gdy użytkownik po raz pierwszy wyrazi zgodę na dostęp do Twojej aplikacji lub gdy do adresu URL autoryzacji zostanie dodany parametr prompt=consent, aby wymusić wyświetlenie ekranu zgody nawet w przypadku kolejnych autoryzacji.

refresh_token jest ważny przez długi czas, ale może wygasnąć lub stać się nieważny, jeśli nie będzie używany przez 6 miesięcy, jeśli użytkownik cofnie dostęp do Twojej aplikacji lub z innych powodów. refresh_token należy bezpiecznie przechowywać do wykorzystania w przyszłości.

Więcej informacji znajdziesz w artykule Odświeżanie tokena dostępu (dostęp offline).

5. Dodawanie danych w aplikacji mobilnej Fitbit

Nowi użytkownicy Fitbita mogą nie mieć na koncie Fitbit danych, o które można wysłać zapytanie. Ręcznie dodamy dziennik ćwiczeń, o który będziemy mogli wysyłać zapytania za pomocą jednego z punktów końcowych. Aby ręcznie zarejestrować ćwiczenie:

  1. Otwórz aplikację mobilną Fitbit na urządzeniu. W razie potrzeby zaloguj się na konto Fitbit.
  2. W prawym dolnym rogu ekranu kliknij przycisk +.
  3. W sekcji „Ręczne rejestrowanie” kliknij Aktywność.
  4. Wyszukaj rodzaj ćwiczenia Chód i wybierz go.
  5. Wpisz godzinę rozpoczęcia na dziś.
  6. Zmień czas trwania na 15 minut.
  7. Pozostaw odległość 1,6 km.
  8. Kliknij Dodaj.
  9. Zsynchronizuj aplikację mobilną z serwerami Fitbit, naciskając i przytrzymując ekran, a następnie przesuwając palcem w dół. Gdy puścisz palec, aplikacja mobilna powinna się zsynchronizować.
  10. W sekcji „Aktywność” powinna być widoczna ręcznie zarejestrowana aktywność „Spacer”.Zrzut ekranu przedstawiający aktywność związaną z chodzeniem.

6. Pobieranie danych za pomocą metody list

Aby wywołać metodę list, dodaj ten kod do pliku Codelab.http tuż pod punktem końcowym /token.

### users.dataTypes.dataPoints
#####################################################

### LIST exercise
GET https://health.googleapis.com/v4/users/me/dataTypes/exercise/dataPoints
Authorization: Bearer {{accessToken}}
Accept: application/json

Ten kod wywołuje punkt końcowy list, aby wyświetlić kroki zarejestrowane przez użytkownika na koncie Fitbit. W odpowiedzi zostanie zwrócona liczba kroków z każdej minuty, podobnie jak w przypadku punktu końcowego Activity Intraday interfejsu Fitbit Web API w wersji 1.

Aby wykonać wywołanie, kliknij link Wyślij prośbę dla punktu końcowego GET. Odpowiedź powinna wyglądać podobnie do tej:

{
  "dataPoints": [
    {
      "name": "users/2515055256096816351/dataTypes/exercise/dataPoints/8896720705097069096",
      "dataSource": {
        "recordingMethod": "MANUAL",
        "platform": "FITBIT"
      },
      "exercise": {
        "interval": {
          "startTime": "2026-02-23T13:10:00Z",
          "startUtcOffset": "-18000s",
          "endTime": "2026-02-23T13:25:00Z",
          "endUtcOffset": "-18000s"
        },
        "exerciseType": "WALKING",
        "metricsSummary": {
          "caloriesKcal": 16,
          "distanceMillimiters": 1609344,
          "steps": "2038",
          "averagePaceSecondsPerMeter": 0.55923407301360051,
          "activeZoneMinutes": "0"
        },
        "exerciseMetadata": {},
        "displayName": "Walk",
        "activeDuration": "900s",
        "exerciseEvents": [
          {
            "eventTime": "2026-02-23T13:10:00Z",
            "eventUtcOffset": "-18000s",
            "exerciseEventType": "START"
          },
          {
            "eventTime": "2026-02-23T13:25:00Z",
            "eventUtcOffset": "-18000s",
            "exerciseEventType": "STOP"
          }
        ],
        "updateTime": "2026-02-24T01:19:22.450466Z"
      }
    },
    {
      "name": "users/2515055256096816351/dataTypes/exercise/dataPoints/5870930690409355408",
      "dataSource": {
        "recordingMethod": "MANUAL",
        "platform": "FITBIT"
      },
      "exercise": {
        "interval": {
          "startTime": "2026-02-23T06:00:00Z",
          "startUtcOffset": "-18000s",
          "endTime": "2026-02-23T06:15:00Z",
          "endUtcOffset": "-18000s"
        },
        "exerciseType": "WALKING",
        "metricsSummary": {
          "caloriesKcal": 17,
          "distanceMillimiters": 1609344,
          "steps": "2038",
          "averagePaceSecondsPerMeter": 0.55923407301360051,
          "averageHeartRateBeatsPerMinute": "81",
          "activeZoneMinutes": "0",
          "heartRateZoneDurations": {
            "lightTime": "900s"
          }
        },
        "exerciseMetadata": {},
        "displayName": "Walk",
        "activeDuration": "900s",
        "exerciseEvents": [
          {
            "eventTime": "2026-02-23T06:00:00Z",
            "eventUtcOffset": "-18000s",
            "exerciseEventType": "START"
          },
          {
            "eventTime": "2026-02-23T06:15:00Z",
            "eventUtcOffset": "-18000s",
            "exerciseEventType": "STOP"
          }
        ],
        "updateTime": "2026-02-23T08:29:39.480437Z"
      }
    }
  ],
  "nextPageToken": ""
}

Wiele punktów końcowych obsługuje parametry zapytania do filtrowania lub stronicowania. Na przykład ćwiczenia obsługują filtr interval.civil_start_time. Dodaj do żądania Codelab.http to zapytanie, aby wyświetlić listę ćwiczeń w określonym przedziale czasu:

### LIST exercise >= civil start time
GET https://health.googleapis.com/v4/users/me/dataTypes/exercise/dataPoints?filter=exercise.interval.civil_start_time >= "2026-02-22T00:00:00"
Authorization: Bearer {{accessToken}}
Accept: application/json

7. Gratulacje

Gratulacje!

Udało Ci się ukończyć podstawowe ćwiczenie z programowania i nauczyć się, jak używać Visual Studio Code i rozszerzenia Rest Client do testowania autoryzacji OAuth 2.0 i wykonywania wywołań punktów końcowych interfejsu Google Health API. Możesz tu dodać dodatkowe punkty końcowe, tak jak na początku sekcji Pobieranie danych za pomocą metody List.

Mamy nadzieję, że tworzenie aplikacji zintegrowanych z ekosystemem interfejsów API Google Health będzie dla Ciebie przyjemnością. Więcej informacji o innych punktach końcowych interfejsu Google Health API znajdziesz w dokumentacji referencyjnej. Dowiedz się też więcej o protokole Google OAuth 2.0 w internetowych aplikacjach serwerowych.