1. Introduzione
Visual Studio Code (VS Code) e l'estensione Rest Client di Huachao Mao possono consentirti di testare il flusso di consenso OAuth di Google e l'API Google Health. Questo codelab ti mostrerà come configurare l'estensione Rest Client, come avviare il flusso di autorizzazione ed effettuare la prima chiamata a uno degli endpoint dell'API Google Health. Successivamente, puoi leggere la documentazione di Rest Client e quella di Fitbit per creare gli altri endpoint nel tuo progetto HTTP.
Se non vuoi utilizzare VS Code e Rest Client, le chiamate API possono essere effettuate con i comandi curl.
Obiettivi didattici
- Come configurare VS Code con l'estensione Rest client.
- Come configurare un ID client nella console Google Cloud.
- Come eseguire il flusso di autorizzazione OAuth 2.0 di Google per ottenere un token di accesso e un token di aggiornamento.
- Come effettuare chiamate agli endpoint dell'API Google Health utilizzando il client REST.
Che cosa ti serve
- app mobile Fitbit
- Visual Studio Code
- Estensione Rest Client di Huacho Mao.
Per configurare l'app mobile Fitbit:
- Cerca e scarica l'app mobile Fitbit nell'Apple App Store o nel Google Play Store.
- Seleziona l'icona dell'app.
- Fai clic su Accedi con Google.
- Seleziona il tuo Account Google e premi il pulsante Continua.
Per installare gli strumenti di Visual Studio:
- Scarica VS Code. In genere, il download contiene il file eseguibile.
- Avvia VS Code.
- Installa l'estensione Rest Client di Huachao Mao.
- Fai clic sull'icona dell'estensione
sul lato sinistro dell'IDE. - Cerca REST Client di Huachao Mao e premi Installa.
- Fai clic sull'icona dell'estensione
2. Configura il progetto Google Cloud
Utilizzerai la console Google Cloud per creare un ID client e attivare l'utilizzo dell'API Google Health.
- Accedi alla console Google Cloud.
- Per creare un nuovo progetto:
- Fai clic su Seleziona un progetto dal selettore di progetti.
- Nell'angolo in alto a destra, seleziona Nuovo progetto.
- Inserisci il nome del progetto.
- Inserisci la tua sede (ad esempio "Nessuna organizzazione").
- Fai clic su pulsante Crea.
- Seleziona il progetto.
Abilita l'API Google Health
- Nell'angolo in alto a sinistra, fai clic sull'icona del menu:
- Seleziona API e servizi > Libreria.
- Cerca "API Google Health" e attivala.
Configurare le credenziali OAuth
Se non ti trovi nella console Google Cloud, vai alla console Google Cloud.
- Nell'angolo in alto a sinistra, fai clic sull'icona del menu:
- Seleziona API e servizi > Credenziali.
- Nella parte superiore al centro, seleziona + Crea credenziali > ID client OAuth.
- Fai clic sul pulsante Configura schermata per il consenso. Se viene visualizzato il messaggio "Google Auth Platform non ancora configurata", fai clic sul pulsante Inizia.
- Nella sezione 1:
- Inserisci il Nome dell'app.
- Inserisci l'email per l'assistenza utenti.
- Fai clic sul pulsante Avanti.
- Nella sezione 2:
- Seleziona Esterno.
- Fai clic sul pulsante Avanti.
- Nella sezione 3:
- Inserisci il tuo indirizzo email nel campo Informazioni di contatto.
- Fai clic sul pulsante Avanti.
- Nella sezione 4:
- Fai clic sulla casella di controllo per accettare le Norme relative ai dati utente dei servizi API di Google.
- Fai clic su pulsante Crea.
- Nella sezione delle metriche, premi il pulsante Crea client OAuth.
- Scegli il tipo di applicazione Applicazione web.
- Inserisci il nome dell'ID client.
- Lascia vuoto il campo Origini JavaScript autorizzate.
- In URI di reindirizzamento autorizzati, premi il pulsante + Aggiungi URI. Inserisci "https://www.google.com" come URI di reindirizzamento.
- Fai clic su pulsante Crea.
- La console Google mostrerà un messaggio che indica che l'ID client è stato creato. Fai clic sul link Scarica JSON per scaricare l'ID client e il client secret oppure annota i valori. In seguito non potrai recuperare il secret del cliente.
- Fai clic su OK. Tornerai alla pagina "ID client OAuth 2.0".
- L'ID client verrà aggiunto al progetto. Fai clic sull'URL dell'ID cliente per visualizzare i dettagli.
Aggiungere utenti di test
- Nel riquadro a sinistra, seleziona Pubblico. Dovresti visualizzare lo "Stato di pubblicazione" impostato su Test e il "Tipo di utente" impostato su Esterno.
- Nella sezione "Utenti di test", fai clic sul pulsante + Aggiungi utenti. Inserisci l'indirizzo email di tutti gli utenti di cui vuoi recuperare i dati.
- Fai clic sul pulsante Salva.
Aggiungere ambiti all'ID client
- Nel riquadro a sinistra, seleziona Accesso ai dati.
- Fai clic sul pulsante Aggiungi o rimuovi ambiti.
- Nella colonna API, cerca "API Google Health". Per questo codelab utilizziamo l'ambito
.../auth/googlehealth.activity_and_fitness.readonly - Dopo aver selezionato l'ambito, premi il pulsante Aggiorna per tornare alla pagina Accesso ai dati.
- Fai clic sul pulsante Salva.
Hai completato la configurazione dell'ID client.
3. Crea il flusso di autorizzazione
- Apri l'app VS Code sul tuo computer.
- Nella schermata di benvenuto, seleziona Apri.
- Seleziona una cartella in cui creare il progetto e premi Apri. La schermata dovrebbe essere simile a questa, con il nome della cartella o del progetto in Explorer.
- Dal menu principale, scegli File -> Nuovo file di testo.
- Salva il file per assegnargli un nome. Dal menu principale, scegli File -> Salva con nome -> Codelab.http. In questo modo il file dovrebbe essere inserito nel progetto. L'estensione del file deve essere .http o .rest. Per questo codelab, utilizziamo .http.
Nel corso di questo progetto, utilizzeremo più volte diversi valori. Questi valori sono:
| Il valore dell'ID client della console Google. |
| Il valore del client secret della console Google. |
| Un endpoint della tua app che elabora il codice di autorizzazione. Per il codelab, utilizziamo https://www.google.com |
| Il token di accesso creato per l'utente al termine del flusso di consenso. |
| Il token di aggiornamento creato per l'utente al termine del flusso di consenso. |
Aggiungi il seguente codice che definisce le variabili utilizzate con questo progetto. Dovrebbero trovarsi nella parte superiore del file Codelab.http. Compila i valori per client_id e secret.
### 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}}
L'URL di autorizzazione, utilizzato per avviare il flusso di consenso, verrà inviato a ogni utente di cui vuoi accedere ai dati. Per creare l'URL di autorizzazione, dobbiamo sapere qual è l'endpoint Google OAuth e utilizzare i parametri di query per specificare l'ID client, gli ambiti a cui vogliamo accedere e dove reindirizzare l'utente quando acconsente agli ambiti. La documentazione completa per la creazione della stringa di autorizzazione Google è disponibile nella documentazione.
L'endpoint OAuth 2.0 di Google è https://accounts.google.com/o/oauth2/v2/auth. Questo endpoint è accessibile solo tramite HTTPS. Le connessioni HTTP semplici vengono rifiutate.
Il server di autorizzazione Google supporta molti parametri della stringa di query per consentire alle applicazioni server web di personalizzare il flusso di autorizzazione. Utilizzeremo i seguenti parametri di query obbligatori: client_id, redirect_uri, response_type e scope. La documentazione fornisce un elenco di tutti i parametri di query e la relativa descrizione.
I valori dei parametri di query sono
| Il valore dell'ID client della console Google |
| Un endpoint della tua app che elabora il codice di autorizzazione. Per il codelab, utilizza https://www.google.com |
|
|
| Gli ambiti provengono dalla console Google con la sintassi https://www.googleapis.com seguita dal nome dell'ambito. Ad esempio, https://www.googleapis.com/auth/googlehealth.activity_and_fitness. |
Dopo le variabili, scrivi il nostro URL di autorizzazione come mostrato. I parametri definiti nella parte superiore del progetto non possono essere utilizzati nella stringa di autorizzazione. Pertanto, dobbiamo includere i valori per client_id e redirect_uri. Sostituisci la stringa client-id con il tuo ID client.
### 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
Quando un utente concede il consenso, Google fornisce un codice di autorizzazione che scambi con un token di accesso chiamando l'endpoint token di Google. Aggiungi la seguente definizione per chiamare l'endpoint del token a Codelab.http sotto la stringa di autorizzazione. Nel passaggio successivo sostituirai authorization-code con un codice di autorizzazione.
### 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 fa riferimento all'utente attuale di cui stai accedendo ai dati.
4. Autorizzare un account e ottenere token
Ora esamineremo il flusso di autorizzazione per ottenere i token di autorizzazione.
La stringa di autorizzazione in Codelab.http viene utilizzata per avviare il flusso di consenso basato sul browser di Google. L'estensione Rest Client potrebbe mostrare un link Invia richiesta per questo URL. Non utilizzare Invia richiesta per questo URL specifico. In alternativa, copialo e incollalo nel browser oppure utilizza Ctrl+clic (Windows/Linux) o Cmd+clic (Mac) in VS Code per aprirlo nel browser predefinito.
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
- Ti verrà chiesto di accedere al tuo Account Google. Devi accedere utilizzando uno degli account utente di test che hai configurato nella sezione Aggiungi utenti di test.
- Potresti visualizzare un messaggio che indica che l'app non è verificata. Questo perché l'app non è stata pubblicata. Premi "Continua".
- La pagina del consenso elenca gli ambiti richiesti. L'utente ha la possibilità di selezionare gli ambiti che vuole condividere con questa app. Fai clic su "Continua".
Dopo aver acconsentito alla condivisione degli ambiti richiesti, il sistema ti reindirizza all'indirizzo redirect_uri specificato (in questo codelab, https://www.google.com). Google aggiunge un codice di autorizzazione e altri parametri a redirect_uri, quindi l'URL nella barra degli indirizzi del browser dovrebbe avere un aspetto simile a questo:
https://www.google.com/?code=4/0Ab32j93oyGWqaXE112sP1IKmh3kV1fE4tcHIMXYJQYWgNEtAa_0-YsfkS9Ekj3Be89u3fw&scope=https://www.googleapis.com/auth/googlehealth.activity_and_fitness.readonly
Il codice di autorizzazione è il valore alfanumerico compreso tra "code=" e "&scope". Nell'esempio riportato sopra, il valore è:
4/0Ab32j93oyGWqaXE112sP1IKmh3kV1fE4tcHIMXYJQYWgNEtAa_0-YsfkS9Ekj3Be89u3fw
In un'app di produzione, il server analizzerebbe questo valore dai parametri URL. Per questo codelab, copia il codice di autorizzazione dall'URL nel browser.
Ora, scambia questo codice di autorizzazione con un access_token e un refresh_token. In Codelab.http, sostituisci authorization-code nel corpo della richiesta POST /token con il codice di autorizzazione che hai copiato.
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
Fai clic sul link Invia richiesta appena sopra la riga POST https://oauth2.googleapis.com/token.
La risposta dovrebbe essere simile a questa:
{
"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
}
Quando ricevi questa risposta, Rest Client compila automaticamente le variabili @accessToken e @refreshToken definite nella parte superiore di Codelab.http per l'utilizzo nelle richieste successive.
Informazioni sui token di aggiornamento
Quando scambi il codice di autorizzazione, la risposta può includere un refresh_token oltre al access_token. I access_token hanno una durata breve (in genere un'ora). Quando un access_token scade, devi utilizzare il refresh_token per ottenere un nuovo access_token senza richiedere all'utente di accedere o dare nuovamente il consenso. Ciò è possibile perché abbiamo incluso access_type=offline nella nostra richiesta di autorizzazione.
Se nella risposta non ricevi un refresh_token, il motivo potrebbe essere che hai già concesso il consenso per questa app e questi ambiti. I token di aggiornamento vengono in genere emessi solo la prima volta che un utente concede il consenso per la tua app o quando prompt=consent viene aggiunto all'URL di autorizzazione per forzare la visualizzazione della schermata per il consenso anche nelle autorizzazioni successive.
Il refresh_token è di lunga durata, ma può scadere o diventare non valido se non viene utilizzato per 6 mesi, se l'utente revoca l'accesso alla tua app o per altri motivi. Devi archiviare in modo sicuro refresh_token per un utilizzo futuro.
Per maggiori dettagli, vedi Aggiornare un token di accesso (accesso offline).
5. Aggiungere dati all'app mobile Fitbit
Per i nuovi utenti di Fitbit, potresti non avere dati nel tuo account Fitbit da interrogare. Aggiungeremo manualmente un registro degli esercizi che possiamo interrogare tramite uno degli endpoint. Per registrare manualmente un allenamento, segui questi passaggi:
- Apri l'app mobile Fitbit sul tuo dispositivo. Se necessario, accedi al tuo account Fitbit.
- Nell'angolo in basso a destra dello schermo, tocca il pulsante +.
- Nella sezione "Registra manualmente", tocca Attività.
- Cerca il tipo di allenamento Camminata e selezionalo.
- Inserisci un'ora di inizio per oggi.
- Imposta la durata su 15 minuti.
- Lascia la distanza 1,6 km.
- Tocca Aggiungi.
- Sincronizza l'app mobile con i server Fitbit tenendo premuto a lungo sullo schermo e scorrendo verso il basso. Quando sollevi il dito, dovresti vedere la sincronizzazione dell'app mobile.
- Nella sezione "Attività", dovresti visualizzare la voce Camminata registrata manualmente.
6. Recuperare i dati utilizzando il metodo list
Per chiamare il metodo list, aggiungi il seguente codice a Codelab.http, subito sotto l'endpoint /token.
### users.dataTypes.dataPoints
#####################################################
### LIST exercise
GET https://health.googleapis.com/v4/users/me/dataTypes/exercise/dataPoints
Authorization: Bearer {{accessToken}}
Accept: application/json
Questo codice chiama l'endpoint list per visualizzare i passi registrati dall'utente nel suo account Fitbit. Il conteggio dei passi per ogni minuto verrà restituito nella risposta, in modo simile all'endpoint Attività infragiornaliera dell'API Fitbit Web v1.
Per eseguire la chiamata, premi il link Invia richiesta per l'endpoint GET. La risposta dovrebbe essere simile a questa:
{
"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": ""
}
Molti endpoint supportano i parametri di query per il filtraggio o la paginazione. Ad esempio, l'allenamento supporta il filtro interval.civil_start_time. Aggiungi la seguente richiesta a Codelab.http per elencare gli allenamenti in un intervallo di tempo specifico:
### 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. Complimenti
Complimenti!
Hai completato il codelab di base e hai imparato a utilizzare Visual Studio Code e l'estensione Rest Client per testare l'autorizzazione OAuth 2.0 ed effettuare chiamate agli endpoint dell'API Google Health. Da qui, puoi aggiungere gli endpoint aggiuntivi proprio come hai fatto all'inizio della sezione Recuperare i dati utilizzando il metodo List.
Ci auguriamo che ti piaccia creare app che si integrano con l'ecosistema API Google Health. Per saperne di più, esplora altri endpoint dell'API Google Health nella documentazione di riferimento e scopri di più su Google OAuth 2.0 per le applicazioni server web.