Google Fit per Android API Sessioni

Google Fit è una piattaforma che consente agli sviluppatori di creare applicazioni incentrate sui dati di idoneità dell'utente. Uno degli strumenti che Google ha fornito è Google Fit per Android, disponibile come pacchetto in Google Play Services.

In precedenza in questa serie, abbiamo esplorato come memorizzare i dati di fitness tramite Google Play Services utilizzando l'API di registrazione e come accedere e aggiornare i dati tramite l'API Cronologia. In questo tutorial, espandiamo queste idee con l'API Sessions, che consente di organizzare i dati dell'attività in base a intervalli di tempo.

Questo tutorial ti guida attraverso un progetto di esempio che dimostra come utilizzare l'API Sessions. Il progetto finito può essere scaricato da GitHub.

1. Impostazione del progetto

Passaggio 1: impostare la Console per gli sviluppatori

Per utilizzare Google Fit, devi creare un ID cliente OAuth 2.0 e registrare la tua applicazione tramite la Google Developer Console. Puoi trovare una spiegazione dettagliata su come impostare un progetto nella Google Developer Console nel mio tutorial sull'API di Google Fit Sensors.

Passaggio 2: impostare il progetto Android

Dopo aver configurato l'applicazione per l'autenticazione nella Google Developer Console, utilizza il nome del pacchetto registrato per creare una nuova applicazione Android con un numero vuoto Attività.

Con il progetto Android creato, apri build.gradle e includi Google Play Services sotto il nodo delle dipendenze e sincronizza la tua app. In questo esempio, sto anche utilizzando la libreria Butter Knife per ridurre il codice della piastra della caldaia per gli ascoltatori e la ricerca dei clic vista elementi.

compila 'com.google.android.gms: play-services-fitness: 8.4.0' compila 'com.jakewharton: butterknife: 7.0.1'

Dopo aver sincronizzato le dipendenze, apri AndroidManifest.xml e includere il ACCESS_FINE_LOCATION autorizzazione. Questa autorizzazione è necessaria per leggere i dati di sessione da Google Fit. Anche se non vado nei dettagli in questo tutorial, vale la pena notare che, se stai puntando all'API 23 o superiore, devi richiedere l'autorizzazione alla posizione da parte dell'utente.

Avanti, aperto activity_main.xml e aggiornarlo in modo che includa cinque Pulsante elementi che verranno utilizzati per dimostrare alcune delle funzionalità dell'API Sessioni. Il risultato finale dovrebbe essere simile al seguente:

Una volta creato il layout, apri MainActivity.java e connettersi a Google Play Services.

public class MainActivity estende AppCompatActivity implementa GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener String finale privata SESSION_NAME = "nome sessione"; private GoogleApiClient mGoogleApiClient = null; sessione privata mSession; @Override protected void onCreate (Bundle savedInstanceState) super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); ButterKnife.bind (questo); mGoogleApiClient = new GoogleApiClient.Builder (this) .addApi (Fitness.SESSIONS_API) .addApi (Fitness.HISTORY_API) .addScope (new Scope (Scopes.FITNESS_LOCATION_READ_WRITE)) .addScope (new Scope (Scopes.FITNESS_ACTIVITY_READ_WRITE)) .addConnectionCallbacks (this) .enableAutoManage (this, 0, this) .build ();  @Override protected void onDestroy () super.onDestroy (); ButterKnife.unbind (questo);  @Override public void onConnected (Bundle bundle)  @Override public void onConnectionSuspended (int i)  @Override public void onConnectionFailed (@NonNull ConnectionResult connectionResult) 

Potresti aver notato che stai includendo l'API Storia insieme all'API Sessioni. Ciò è necessario perché l'API History viene utilizzata per l'eliminazione dei dati di sessione, di cui parleremo più avanti in questo tutorial. È inoltre necessario utilizzare entrambi FITNESS_LOCATION_READ_WRITE e FITNESS_ACTIVITY_READ_WRITE proprietà dell'ambito per le funzionalità dell'API Sessioni di cui parleremo.

Dopo aver impostato la tua app per la connessione a Google Play Services e Google Fit, è il momento di iniziare a provare l'API Sessions.

2. Utilizzo dell'API Sessioni

L'API Sessioni è un altro strumento di Google Fit per l'archiviazione dei dati di fitness per l'utente. In quanto tale, non è destinato a sostituire le API di registrazione o cronologia, ma rappresenta un ulteriore modo per migliorare le tue app per una migliore esperienza utente.

In questa sezione, viene illustrato come avviare e interrompere la raccolta di dati di sessione in tempo reale, come inserire una sessione nell'archivio dati di Google Fit, come leggere i dati di sessione memorizzati in precedenza e come eliminare sessioni non necessarie o non corrette. Analogamente all'API di cronologia, le chiamate all'API delle sessioni devono essere effettuate fuori dal thread principale. Mentre il tutorial per l'API della cronologia avvolge le operazioni in AsyncTask chiama, questo tutorial si concentrerà sull'uso PendingResult callback per tenere traccia delle attività.

Avvio e interruzione di una sessione

Lo scenario più comune per l'API Sessioni è la registrazione delle informazioni dopo che un utente ha avviato un'attività di fitness. Questo viene spesso avviato in concomitanza con l'API di registrazione in modo che i dati del sensore possano essere associati al periodo di tempo della sessione. Per iniziare a registrare una sessione, è necessario creare un oggetto di sessione con un nome, un identificatore univoco, una descrizione, un'ora di inizio e il tipo di attività che l'utente sta eseguendo.

mSession = new Session.Builder () .setName (SESSION_NAME) .setIdentifier (getString (R.string.app_name) + "" + System.currentTimeMillis ()) .setDescription ("Descrizione sessione yoga") .setStartTime (Calendar.getInstance ( ) .getTimeInMillis (), TimeUnit.MILLISECONDS) .setActivity (FitnessActivities.YOGA) .build ();

Una volta il tuo Sessione l'oggetto è creato, puoi chiamare startSession sull'API Sessioni per iniziare a registrare l'attività dell'utente.

PendingResult pendingResult = Fitness.SessionsApi.startSession (mGoogleApiClient, mSession); pendingResult.setResultCallback (nuovo ResultCallback() @Override public void onResult (stato di stato) if (status.isSuccess ()) Log.i ("Tuts +", "Sessione avviata con successo");  else Log.i ("Tuts +", "Impossibile avviare la sessione:" + status.getStatusMessage ()); );

Quando l'utente ha terminato la propria attività, è possibile terminare la sessione chiamando stopSession con l'identificativo univoco per il Sessione.

PendingResult pendingResult = Fitness.SessionsApi.stopSession (mGoogleApiClient, mSession.getIdentifier ()); pendingResult.setResultCallback (nuovo ResultCallback() @ Override pubblico onResult (SessionStopResult sessionStopResult) if (sessionStopResult.getStatus (). IsSuccess ()) Log.i ("Tuts +", "Sessione terminata con successo");  else Log.i ("Tuts +", "Impossibile arrestare la sessione:" + sessionStopResult.getStatus (). getStatusMessage ()); );

Qualcosa degno di nota qui è che il Sessione oggetto implementa il Parcelable interfaccia, quindi può essere memorizzato in a impacchettare nel caso sia necessario archiviarlo o trasferirlo su un altro componente all'interno della propria applicazione. Questo può essere utile se l'utente inizia un'attività e poi chiude l'app, in quanto potrebbe essere necessario successivamente i dati della sessione per interrompere la registrazione della sessione.

Inserimento in Google Fit

Ora che sai come registrare le informazioni sulla sessione in tempo reale, il passo successivo è riuscire a inserire le sessioni dopo il loro verificarsi. Mentre è possibile inserire un blocco di tempo come sessione, l'API delle sessioni consente inoltre di associare le attività ai segmenti di una sessione. Questo è utile per situazioni in cui l'utente non può fare continuamente la stessa attività durante l'intera routine di fitness.

Un esempio di ciò potrebbe essere quando la tua app ha rilevato che l'utente è stato in esecuzione, riposato per un breve periodo camminando e quindi eseguito di nuovo. Nell'esempio seguente, si inserisce a Sessione dove l'utente correva per 15 minuti, camminava per cinque, e poi correva per altri 15 minuti tenendo traccia di quando l'utente ha iniziato e interrotto ogni attività. Registri anche la loro velocità media per ciascuna di queste attività.

Calendario calendar = Calendar.getInstance (); Data ora = nuova Data (); calendar.setTime (ora); long endTime = calendar.getTimeInMillis (); calendar.add (Calendar.MINUTE, -15); long walkEndTime = calendar.getTimeInMillis (); calendar.add (Calendar.MINUTE, -5); long walkStartTime = calendar.getTimeInMillis (); calendar.add (Calendar.MINUTE, -15); long startTime = calendar.getTimeInMillis (); float firstRunSpeed ​​= 15; float walkSpeed ​​= 5; float secondRunSpeed ​​= 13;

Una volta che hai i valori chiave di tempo e velocità, devi crearne due DataSet gruppi per la memorizzazione di informazioni su attività e velocità. Questi possono essere creati da un insieme di Fonte di dati oggetti con l'appropriato Tipo di dati proprietà impostate.

DataSource speedSegmentDataSource = new DataSource.Builder () .setAppPackageName (this.getPackageName ()) .setDataType (DataType.TYPE_SPEED) .setName ("Set di dati tuts + speed") .setType (DataSource.TYPE_RAW) .build (); DataSource activitySegmentDataSource = new DataSource.Builder () .setAppPackageName (this.getPackageName ()) .setDataType (DataType.TYPE_ACTIVITY_SEGMENT) .setName ("Set di dati segmenti di attività + Tut"). SetType (DataSource.TYPE_RAW) .build (); DataSet speedDataSet = DataSet.create (speedSegmentDataSource); DataSet activityDataSet = DataSet.create (activitySegmentDataSource);

Successivamente, è necessario creare il DataPoint oggetti che verranno inseriti nell'archivio dati di Google Fit. Ogni DataPoint ha un intervallo di tempo e un insieme di Campo proprietà che memorizzano i dati correlati. Una volta ciascuno DataPoint è configurato, è necessario inserirlo nella corretta DataSet. Per brevità, mostro solo lo snippet di codice per la creazione DataPoint oggetti per il primo segmento di esecuzione in basso, tuttavia, gli altri oggetti del punto di dati sono mostrati nel codice sorgente per questo tutorial su GitHub.

// Crea il punto di dati di velocità per il primo segmento di esecuzione DataPoint firstRunSpeedDataPoint = speedDataSet.createDataPoint () .setTimeInterval (startTime, walkStartTime, TimeUnit.MILLISECONDS); firstRunSpeedDataPoint.getValue (Field.FIELD_SPEED) .setFloat (firstRunSpeed); speedDataSet.add (firstRunSpeedDataPoint); // Crea punto dati attività per il segmento second run DataPoint secondRunActivityDataPoint = activityDataSet.createDataPoint () .setTimeInterval (walkEndTime, endTime, TimeUnit.MILLISECONDS); secondRunActivityDataPoint.getValue (Field.FIELD_ACTIVITY) .setActivity (FitnessActivities.RUNNING); activityDataSet.add (secondRunActivityDataPoint);

Una volta che hai popolato i due DataSet gruppi, è il momento di creare il Sessione che inserirai. Questo Sessione sarà necessario impostare il nome, l'identificativo univoco, la descrizione, le ore di inizio e di fine e le proprietà dell'attività. Una cosa importante da tenere presente è che il nome che usi quando inserisci un Sessione è il nome che devi usare quando tenti di leggere questa sessione in seguito.

Sessione sessione = new Session.Builder () .setName (SESSION_NAME) .setIdentifier (getString (R.string.app_name) + "" + System.currentTimeMillis ()) .setDescription ("Esecuzione in segmenti") .setStartTime (startTime, TimeUnit .MILLISECONDS) .setEndTime (endTime, TimeUnit.MILLISECONDS) .setActivity (FitnessActivities.RUNNING) .build ();

Ora che sei tuo Sessione viene creato, è necessario creare un SessionInsertRequest, aggiungi il tuo DataSet oggetti ad esso, e quindi inserire quello Sessione in Google Fit.

SessionInsertRequest insertRequest = new SessionInsertRequest.Builder () .setSession (session) .addDataSet (speedDataSet) .addDataSet (activityDataSet) .build (); PendingResult pendingResult = Fitness.SessionsApi.insertSession (mGoogleApiClient, insertRequest); pendingResult.setResultCallback (nuovo ResultCallback() @Override public void onResult (stato stato) if (status.isSuccess ()) Log.i ("Tuts +", "sessione inserita correttamente inserita");  else Log.i ("Tuts +", "Impossibile inserire la sessione in esecuzione:" + status.getStatusMessage ()); );

Lettura dei dati della sessione

Indipendentemente dalla quantità di dati di sessione archiviati con la tua app, non ti farà molto bene a meno che tu non sia in grado di leggere quei dati e utilizzarli per rendere la tua app migliore per i tuoi utenti. Fortunatamente, Google Fit rende incredibilmente facile ricevere i dati di sessione entro un determinato periodo di tempo.

Innanzitutto, è necessario selezionare l'ora di inizio e di fine per i dati che si desidera ricevere. In questo esempio, richiediamo i dati di sessione per l'ultimo mese.

Calendar cal = Calendar.getInstance (); Data ora = nuova Data (); cal.setTime (ora); long endTime = cal.getTimeInMillis (); cal.add (Calendar.MONTH, -1); long startTime = cal.getTimeInMillis ();

Una volta selezionata la finestra temporale, è necessario creare un SessionReadRequest. Questa richiesta include l'intervallo di tempo per i dati di sessione desiderati, il tipo di dati di sessione che stai cercando (questo tutorial cercherà solo i dati di velocità), e il nome delle sessioni che stai richiedendo, tuttavia, l'intervallo di tempo è il solo la proprietà richiesta.

SessionReadRequest readRequest = new SessionReadRequest.Builder () .setTimeInterval (startTime, endTime, TimeUnit.MILLISECONDS) .read (DataType.TYPE_SPEED) .setSessionName (SESSION_NAME) .build (); PendingResult sessionReadResult = Fitness.SessionsApi.readSession (mGoogleApiClient, readRequest);

Dopo aver chiamato SessionsApi.readSession, tu ricevi un SessionReadResult oggetto che contiene elenchi di Sessione e DataSet oggetti che puoi utilizzare all'interno della tua app. Per questo tutorial, registriamo semplicemente i dati.

sessionReadResult.setResultCallback (nuovo ResultCallback() @ Override public onResult (SessionReadResult sessionReadResult) if (sessionReadResult.getStatus (). IsSuccess ()) Log.i ("Tuts +", "Leggere con successo i dati della sessione"); for (Session session: sessionReadResult.getSessions ()) Log.i ("Tuts +", "Nome sessione:" + session.getName ()); for (DataSet dataSet: sessionReadResult.getDataSet (session)) for (DataPoint dataPoint: dataSet.getDataPoints ()) Log.i ("Tuts +", "Velocità:" + dataPoint.getValue (Field.FIELD_SPEED));  else Log.i ("Tuts +", "Impossibile leggere i dati della sessione"); );

Se esegui la tua applicazione ora e utilizzi le operazioni di inserimento e lettura, dovresti ricevere le tre velocità DataPoint oggetti che hai creato nella sezione precedente.

I / Tuts +: Velocità: 15.0 I / Tuts +: Velocità: 5.0 I / Tuts +: Velocità: 13.0

Eliminazione dei dati della sessione

Ci possono essere momenti in cui è necessario eliminare alcune informazioni di sessione che sono errate o non necessarie. È possibile farlo utilizzando l'API Cronologia per eliminare le sessioni che sono state salvate nell'archivio dati di Google Fit.

Innanzitutto, è necessario determinare un intervallo di tempo per l'operazione di cancellazione. È quindi possibile aggiungere ulteriori informazioni, come a Tipo di dati o altro Sessione proprietà da eliminare o semplicemente cancellare tutti i dati della sessione nell'intervallo di tempo.

Calendario calendar = Calendar.getInstance (); Data ora = nuova Data (); calendar.setTime (ora); long endTime = calendar.getTimeInMillis (); calendar.add (Calendar.DAY_OF_YEAR, -1); long startTime = calendar.getTimeInMillis (); DataDeleteRequest request = new DataDeleteRequest.Builder () .setTimeInterval (startTime, endTime, TimeUnit.MILLISECONDS) .addDataType (DataType.TYPE_SPEED) .deleteAllSessions () .build (); PendingResult deleteRequest = Fitness.HistoryApi.deleteData (mGoogleApiClient, request); deleteRequest.setResultCallback (nuovo ResultCallback() @Override public void onResult (stato di stato @NonNull) if (status.isSuccess ()) Log.i ("Tuts +", "Sessioni eliminate con successo");  else Log.i ("Tuts +", "Impossibile eliminare le sessioni"); );

Conclusione

Come hai imparato in questo tutorial, l'API Sessions è un potente strumento per organizzare i dati raccolti in blocchi di tempo. È un grande complimento per le altre API di Google Fit. Se utilizzato insieme alle API di cronologia e registrazione, puoi fare molto per capire l'attività degli utenti della tua app e offrire loro un'esperienza eccellente con le tue app di fitness.