Share
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.
Sebbene ci siano molte API diverse disponibili per Google Fit, come discusso in questo articolo di Enunti Tuts +, questo tutorial si concentra su come impostare e utilizzare Google Fit per leggere i dati dei sensori su un dispositivo Android. Un progetto di esempio per questo tutorial può essere trovato su GitHub.
Per utilizzare Google Fit per Android, devi:
Questa sezione mostra come configurare la tua applicazione Android e l'API Fitness. Puoi iniziare visitando il Google Developers Console. Se hai già un progetto con cui lavorare, puoi saltare il passaggio successivo. In caso contrario, segui e crea un nuovo progetto per la tua applicazione Google Fit.
Per creare un nuovo progetto, fai clic sul blu Crea progetto pulsante nell'angolo in alto a sinistra dello schermo.
Questo ti presenta una finestra di dialogo che richiede il nome di un progetto. Per questo tutorial, ho creato un progetto e lo ho chiamato TutsPlusGoogleFit. Ci sono alcune restrizioni su cosa puoi chiamare il tuo progetto. Sono consentiti solo lettere, numeri, virgolette, trattini, spazi e punti esclamativi.
Una volta colpito Creare, una finestra di dialogo appare nell'angolo in basso a destra della pagina, ad indicare che il progetto è in fase di creazione.
Con il progetto impostato, sei portato al progetto Panoramica pagina. Il modo più semplice per trovare l'API di Google Fit è cercare la parola chiave "in forma". Selezionare API di fitness dai risultati che appaiono.
Clic Abilita API abilitare a API di fitness.
Dopo aver attivato l'API Fitness, riceverai un avviso che ti informa che devi anche creare credenziali per utilizzare l'API Fitness. Fortunatamente, l'avviso include un pulsante che ci porta al Credenziali pagina.
Sul Credenziali pagina, è necessario fornire alcune informazioni generali sulla propria applicazione in Procedura guidata credenziali. Specificare che si sta utilizzando il API di fitness, che l'API è chiamata da un androide applicazione e a cui l'applicazione deve accedere Dati utente.
Quindi, fare clic Di quali credenziali ho bisogno? in basso per continuare e creare un ID client OAuth 2.0 per la tua applicazione Android. Hai bisogno di due informazioni importanti per questo passaggio:
È possibile ottenere l'impronta digitale del certificato di firma aprendo un terminale o un prompt dei comandi e andando alla posizione del certificato di firma dell'applicazione. Questa è la chiave di rilascio o l'impostazione predefinita debug.keystore certificato utilizzato da Android Studio. Una volta che hai navigato nel tuo keystore, puoi generare lo SHA1 necessario con il seguente comando, dove debug.keystore è il nome del certificato di firma.
keytool -list -v -keystore debug.keystore
Incolla la chiave SHA1 nel campo SHA1 e inserisci com.tutsplus.googlefit nel campo del nome del pacchetto.
Infine, è necessario configurare la schermata di consenso di OAuth 2.0. Questa è la schermata che viene visualizzata all'utente in modo che possano concedere all'app l'autorizzazione a utilizzare i propri dati di fitness. Questo passaggio richiede la tua e-mail e il nome di un prodotto da mostrare agli utenti. Per questo tutorial, sono entrato Tuts + Google Fit.
Clic Continua e, nella pagina successiva, fare clic Fatto per finire il processo di installazione.
Con il tuo progetto configurato e configurato nella Google Developer Console, puoi iniziare a creare un nuovo progetto Android. Assicurati che il nome del pacchetto corrisponda a quello inserito nel file Google Developer Console e impostare l'applicazione per utilizzare il Telefono e tablet piattaforme con una versione minima dell'SDK di 14. Il livello API minimo per Google Fit è 9. Crea Attività vuota per mantenere pulito il progetto di base in modo che tu possa concentrarti sull'API di Google Fit in questo tutorial.
Dopo aver impostato il progetto, apri il progetto build.gradle file e importa il pacchetto fitness da Google Play Services aggiungendo la seguente riga al dipendenze nodo.
compila "com.google.android.gms: play-services-fitness: 8.4.0"
Avanti, aperto MainActivity.java e aggiungere le seguenti interfacce:
Accentsconagua
OnDataPointListenerGoogleApiClient.ConnectionCallbackGoogleApiClient.OnConnectionFailedListenerDopo aver aggiunto i metodi richiesti per queste interfacce, la classe dovrebbe essere simile alla seguente:
public class MainActivity estende AppCompatActivity implementa OnDataPointListener, GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener @Override protected void onCreate (Bundle savedInstanceState) super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); @Override public void onConnected (Bundle bundle) @Override public void onConnectionSuspended (int i) @Override public void onConnectionFailed (ConnectionResult connectionResult) @Override public void onDataPoint (DataPoint dataPoint)
Ultimo ma non meno importante, crea le variabili membro che userai per questo tutorial. Puoi copiare le seguenti righe all'inizio della classe:
private static final int REQUEST_OAUTH = 1; stringa finale statica privata AUTH_PENDING = "auth_state_pending"; private boolean authInProgress = false; private GoogleApiClient mApiClient;
Nel passaggio successivo, ti connetteresti ai servizi di Google Play e imparerai come accedere ai dati di idoneità dell'utente all'interno della tua app.
Con il progetto impostato in Android Studio e la Google Developer Console, è tempo di immergersi nell'API Fitness. Nel onCreate (), metodo, verifichi se la tua app sta già tentando di autorizzare contro l'API Fitness. Quindi inizializzare il GoogleApiClient istanza aggiungendo l'API Fitness Sensors, definendo un ambito e registrando le callback dell'applicazione. Se non si richiede un ambito, la propria app non autorizzerà l'API Fitness Sensors.
@Override protected void onCreate (Bundle savedInstanceState) super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); if (savedInstanceState! = null) authInProgress = savedInstanceState.getBoolean (AUTH_PENDING); mApiClient = new GoogleApiClient.Builder (this) .addApi (Fitness.SENSORS_API) .addScope (new Scope (Scopes.FITNESS_ACTIVITY_READ_WRITE)) .addConnectionCallbacks (this) .addOnConnectionFailedListener (this) .build ();
Dopo aver inizializzato il GoogleApiClient per esempio, devi collegarlo al backend di Google. Puoi farlo in onStart ().
@Override protected void onStart () super.onStart (); mApiClient.connect ();
La prima volta che l'utente esegue l'applicazione, la connessione all'API Fitness fallirà perché l'utente deve autorizzare la tua app ad accedere ai propri dati di fitness. Puoi ascoltare questo evento a onConnectionFailed () e reagire di conseguenza controllando per vedere se l'autorizzazione è in corso. Se lo è, chiama startResolutionForResult () in modo che Google Play Services possa gestire correttamente l'utente che concede l'autorizzazione a utilizzare le proprie informazioni.
@Override public void onConnectionFailed (ConnectionResult connectionResult) if (! AuthInProgress) try authInProgress = true; connectionResult.startResolutionForResult (MainActivity.this, REQUEST_OAUTH); catch (IntentSender.SendIntentException e) else Log.e ("GoogleFit", "authInProgress"); Se esegui la tua applicazione ora, potresti visualizzare una finestra di dialogo che ti chiede di selezionare un account Google da utilizzare se hai utilizzato più account sul tuo dispositivo.
Quando il sistema operativo sa quale account utilizzare, l'applicazione presenta una nuova finestra di dialogo che chiede all'utente di concedere l'autorizzazione all'app per leggere i dati di fitness.
In questa fase, l'utente concede l'autorizzazione dell'applicazione per utilizzare i propri dati o chiude la finestra di dialogo, annullando il processo. Puoi ascoltare entrambi gli eventi in onActivityResult () e gestire il risultato. Se l'utente concede il permesso dell'applicazione, la tua app riceve un RESULT_OK risposta e può quindi tentare di connettersi al client dell'API di Google.
@Override protetto void onActivityResult (int requestCode, int resultCode, Intent data) if (requestCode == REQUEST_OAUTH) authInProgress = false; if (resultCode == RESULT_OK) if (! mApiClient.isConnecting () &&! mApiClient.isConnected ()) mApiClient.connect (); else if (resultCode == RESULT_CANCELED) Log.e ("GoogleFit", "RESULT_CANCELED"); else Log.e ("GoogleFit", "requestCode NOT request_oauth"); La tua applicazione dovrebbe ora essere in grado di connettersi correttamente a Google Play Services. Con quello fuori mano, puoi iniziare a concentrarti sull'API Fitness.
Quando il tuo GoogleApiClient l'istanza si è connessa a Google, il onConnected () la richiamata è attivata. In questo callback, è necessario creare un nuovo DataSourcesRequest oggetto che definisce il tipo di dati a cui è interessata l'applicazione. È inoltre necessario creare un ResultCallback che gestisce ciò che l'app dovrebbe fare se i passaggi possono essere recuperati dal dispositivo. Con gli oggetti creati, chiama Fitness.SensorsApi.findDataSources () per iniziare a cercare un'origine dati passo valida.
@Override public void onConnected (Bundle bundle) DataSourcesRequest dataSourceRequest = new DataSourceRequest.Builder () .setDataTypes (DataType.TYPE_STEP_COUNT_CUMULATIVE) .setDataSourceTypes (DataSource.TYPE_RAW) .build (); ResultCallbackdataSourcesResultCallback = new ResultCallback () @ Override pubblico onResult (DataSourcesResult dataSourcesResult) for (DataSource dataSource: dataSourcesResult.getDataSources ()) if (DataType.TYPE_STEP_COUNT_CUMULATIVE.equals (dataSource.getDataType ())) registerFitnessDataListener (dataSource, DataType.TYPE_STEP_COUNT_CUMULATIVE); ; Fitness.SensorsApi.findDataSources (mApiClient, dataSourceRequest) .setResultCallback (dataSourcesResultCallback);
Potresti notare che il registerFitnessDataListener () il metodo in realtà non esiste. Questo è un metodo di supporto che viene chiamato quando viene trovata l'origine dati per il contatore di passi, che quindi crea un SensorRequest oggetto per richiedere dati dal sensore del conteggio dei passi.
Nel seguente snippet di codice, il SensorRequest l'oggetto tenta di trovare il conteggio dei passi ogni tre secondi. Il Fitness.SensorApi quindi aggiunge la richiesta con una nuova OnDataPointListener in modo che, quando sono disponibili nuovi dati, il listener venga attivato. Se non vengono trovati nuovi dati, il OnDataPointListener non viene attivato e l'API Fitness attende altri tre secondi prima di riprovare.
private void registerFitnessDataListener (DataSource dataSource, DataType dataType) SensorRequest request = new SensorRequest.Builder () .setDataSource (dataSource) .setDataType (dataType) .setSamplingRate (3, TimeUnit.SECONDS) .build (); Fitness.SensorsApi.add (mApiClient, request, this) .setResultCallback (nuovo ResultCallback() @Override public void onResult (stato stato) if (status.isSuccess ()) Log.e ("GoogleFit", "SensorApi aggiunto con successo"); );
Quando viene rilevato un cambiamento nel conteggio dei passi, onDataPoint () è invocato. In questo metodo, esegui un ciclo attraverso i campi nel DataPoint parametro e visualizza a Crostini messaggio con il nome e il valore del campo. In questo esempio, questo sarà il contatore dei passi. Nelle tue app userai una logica più appropriata per eseguire il tuo compito. Noterai che il Crostini il comando è avvolto in a Runnable quello è passato a runOnUiThread. Questo perché la richiamata non viene attivata sul thread principale dell'interfaccia utente.
@Override public void onDataPoint (DataPoint dataPoint) for (final Campo field: dataPoint.getDataType (). GetFields ()) final Valore valore = dataPoint.getValue (campo); runOnUiThread (new Runnable () @Override public void run () Toast.makeText (getApplicationContext (), "Field:" + field.getName () + "Value:" + value, Toast.LENGTH_SHORT) .show (); );
Ci sono altre due cose che devi fare per questo campione. Il primo è disconnettersi dal SensorApi e Google Play Services quando hai finito di usarli. In questo esempio, lo fai quando onStop () è chiamato. Il secondo sta memorizzando il authInProgress valore controllato da onCreate () nel onSavedInstanceState ().
@Override protected void onStop () super.onStop (); Fitness.SensorsApi.remove (mApiClient, this) .setResultCallback (nuovo ResultCallback() @Override public void onResult (stato di stato) if (status.isSuccess ()) mApiClient.disconnect (); ); @Override protected void onSaveInstanceState (Bundle outState) super.onSaveInstanceState (outState); outState.putBoolean (AUTH_PENDING, authInProgress);
In questo tutorial, hai imparato come collegarti all'API Fitness di Google Play Services e leggere i dati del sensore di fitness dal dispositivo dell'utente. Anche qualcosa di semplice come i dati dei passaggi per il tuo utente può rivelarsi estremamente utile per applicazioni come i quadranti di Android Wear o i tracker degli obiettivi. Esistono dozzine di altri tipi di origini dati che puoi utilizzare e molte altre API in Google Fit per rendere le tue app ancora migliori.
