Google Fit pour Android API de sessions

Google Fit est une plateforme qui permet aux développeurs de créer des applications axées sur les données de condition physique des utilisateurs. L'un des outils fournis par Google est Google Fit pour Android, disponible sous forme de package dans les services Google Play..

Plus tôt dans cette série, nous avons exploré comment stocker des données de condition physique via les services Google Play à l'aide de l'API d'enregistrement et comment accéder aux données et les mettre à jour via l'API History. Dans ce tutoriel, nous développons ces idées avec l’API Sessions, qui vous permet d’organiser les données d’activité par intervalles de temps..

Ce tutoriel vous guide dans un exemple de projet qui montre comment utiliser l'API Sessions. Le projet fini peut être téléchargé à partir de GitHub.

1. Configuration du projet

Étape 1: Configuration de la console du développeur

Pour utiliser Google Fit, vous devez créer un ID client OAuth 2.0 et enregistrer votre application via la console Google Developer. Vous trouverez une explication détaillée sur la configuration d'un projet dans la console développeur de Google dans mon tutoriel sur l'API Google Fit Sensors..

Étape 2: Configurer le projet Android

Une fois que votre application est configurée pour l'authentification dans la console pour les développeurs Google, utilisez le nom du package que vous avez enregistré pour créer une nouvelle application Android avec un nom vide. Activité.

Avec le projet Android créé, ouvrez build.gradle et incluez les services Google Play sous le nœud des dépendances et synchronisez votre application. Dans cet exemple, j'utilise également la bibliothèque Butter Knife pour réduire le code de la plaque de la chaudière pour les écouteurs de clic et la recherche Vue articles.

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

Une fois que vous avez synchronisé vos dépendances, ouvrez AndroidManifest.xml et inclure le ACCESS_FINE_LOCATION autorisation. Cette autorisation est nécessaire pour lire les données de session à partir de Google Fit. Bien que je n'entre pas dans les détails de ce tutoriel, il convient de noter que, si vous ciblez l'API 23 ou supérieure, vous devez demander l'autorisation de l'emplacement à l'utilisateur..

Ensuite, ouvrez activity_main.xml et le mettre à jour de sorte qu'il comprend cinq Bouton éléments qui seront utilisés pour démontrer certaines des fonctionnalités de l’API Sessions. Le résultat final devrait ressembler à ceci:

Une fois la mise en page créée, ouvrez MainActivity.java et vous connecter aux services Google Play.

Classe publique MainActivity, AppCompatActivity implémente GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener chaîne privée privée SESSION_NAME = "nom de session"; private GoogleApiClient mGoogleApiClient = null; Session privée mSession; @Override protected void onCreate (Bundle savedInstanceState) super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); ButterKnife.bind (this); mGoogleApiClient = new GoogleApiClient.Builder (this) .addApi (Fitness.SESSIONS_API) .addApi (Fitness.HISTORY_API) .addScope (nouveau Scope.FITNESS_LOCATION_READ_WRITE). .enableAutoManage (this, 0, this) .build ();  @Override protected void onDestroy () super.onDestroy (); ButterKnife.unbind (this);  @Override public onConnected (ensemble)  @Override public onConnectionSuspended (int i)  @Override public onConnectionFailed (@NonNull ConnectionResult connectionResult) 

Vous avez peut-être remarqué que vous incluez l'API History avec l'API Sessions. Cela est nécessaire car l'API d'historique est utilisée pour supprimer des données de session, ce dont nous parlerons plus loin dans ce tutoriel. Vous devez également utiliser les deux FITNESS_LOCATION_READ_WRITE et FITNESS_ACTIVITY_READ_WRITE propriétés de portée pour les fonctionnalités de l'API Sessions dont nous discuterons.

Une fois que vous avez configuré votre application pour la connexion aux services Google Play et à Google Fit, il est temps d'essayer l'API Sessions..

2. Utilisation de l'API Sessions

L'API Sessions est un autre outil de Google Fit permettant de stocker des données de condition physique pour l'utilisateur. En tant que tel, il n'est pas destiné à remplacer les API d'enregistrement ou d'historique, mais constitue un moyen supplémentaire d'améliorer vos applications pour une meilleure expérience utilisateur..

Dans cette section, vous apprendrez à démarrer et à arrêter la collecte de données de session en temps réel, à insérer une session dans le magasin de données Google Fit, à lire des données de session précédemment stockées et à supprimer des sessions inutiles ou incorrectes. Semblable à l'API d'historique, les appels d'API de sessions doivent être effectués à partir du thread principal. Alors que le didacticiel de l’API Historique encapsulait des opérations dans AsyncTask appels, ce tutoriel se concentrera sur l’utilisation de En attente de résultat callbacks pour garder une trace des tâches.

Démarrer et arrêter une session

Le scénario le plus courant pour l'API Sessions consiste à enregistrer des informations après qu'un utilisateur a lancé une activité de mise en forme. Cette opération est souvent lancée simultanément avec l'API d'enregistrement afin que les données du capteur puissent être associées à la période de la session. Pour commencer à enregistrer une session, vous devez créer un objet de session avec un nom, un identifiant unique, une description, une heure de début et le type d'activité réalisée par l'utilisateur..

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

Une fois votre Session l'objet est créé, vous pouvez appeler startSession sur l'API Sessions pour commencer à enregistrer l'activité de votre utilisateur.

En attente de résultat waitingResult = Fitness.SessionsApi.startSession (mGoogleApiClient, mSession); waitingResult.setResultCallback (nouveau ResultCallback() @Override public void onResult (Status status) if (status.isSuccess ()) Log.i ("Tuts +", "Session démarrée avec succès");  else Log.i ("Tuts +", "Impossible de démarrer la session:" + status.getStatusMessage ()); );

Lorsque votre utilisateur a terminé son activité, vous pouvez mettre fin à la session en appelant stopSession avec l'identifiant unique pour le Session.

En attente de résultat waitingResult = Fitness.SessionsApi.stopSession (mGoogleApiClient, mSession.getIdentifier ()); waitingResult.setResultCallback (nouveau ResultCallback() @Override public void onResult (SessionStopResult sessionStopResult) if (sessionStopResult.getStatus (). IsSuccess ()) Log.i ("Tuts +", "Session arrêtée avec succès");  else Log.i ("Tuts +", "Impossible d'arrêter la session:" + sessionStopResult.getStatus (). getStatusMessage ()); );

Quelque chose à noter ici est que le Session objet implémente le Colis interface, donc il peut être stocké dans un Paquet au cas où vous auriez besoin de le stocker ou de le transmettre à un autre composant de votre application. Cela peut être utile si l'utilisateur démarre une activité puis ferme l'application, car vous aurez peut-être besoin de ces données de session pour arrêter l'enregistrement de la session..

Insertion dans Google Fit

Maintenant que vous savez comment enregistrer des informations de session en temps réel, l'étape suivante consiste à pouvoir insérer des sessions a posteriori. Bien que vous puissiez insérer un bloc de temps en tant que session, l'API Sessions vous permet également d'associer des activités à des segments d'une session. Ceci est utile pour les situations dans lesquelles l'utilisateur ne peut pas toujours faire la même activité tout au long de son entraînement physique.

Un exemple de cela peut être lorsque votre application a détecté que l'utilisateur a couru, s'est reposé pendant une courte période en marchant, puis a couru à nouveau. Dans l'exemple suivant, vous insérez un Session où l'utilisateur a couru pendant 15 minutes, a marché pendant cinq minutes, puis 15 minutes supplémentaires en indiquant l'heure à laquelle l'utilisateur a commencé et arrêté chaque activité. Vous enregistrez également leur vitesse moyenne pour chacune de ces activités.

Calendrier calendrier = Calendar.getInstance (); Date now = new Date (); calendar.setTime (maintenant); 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;

Une fois que vous avez les valeurs de temps et de vitesse clés, vous devez créer deux DataSet groupes pour stocker des informations sur les activités et la vitesse. Ceux-ci peuvent être créés à partir d'un ensemble de La source de données objets avec le approprié Type de données ensemble de propriétés.

DataSource speedSegmentDataSource = new DataSource.Builder () .setAppPackageName (this.getPackageName ()) .setDataType (DataType.TYPE_SPEED) .setName ("Tuts + speed dataset") .setType (DataSource.TYPE_RAW) .build (); DataSource activitySegmentDataSource = new DataSource.Builder () .setAppPackageName (this.getPackageName ()) .setDataType (DataType.TYPE_ACTIVITY_SEGMENT) .setName ("Tuts + segment de données d'activité") .setType (DataSource.TYPE_RAW); DataSet speedDataSet = DataSet.create (speedSegmentDataSource); DataSet activityDataSet = DataSet.create (activitySegmentDataSource);

Ensuite, vous devez créer le Point de données objets qui seront insérés dans le magasin de données Google Fit. Chaque Point de données a un intervalle de temps et un ensemble de Champ propriétés qui stockent des données connexes. Une fois chaque Point de données est configuré, vous devez l'insérer dans le bon DataSet. Par souci de concision, je ne montre que l'extrait de code pour la création Point de données les objets du premier segment ci-dessous, cependant, les autres objets de point de données sont présentés dans le code source de ce tutoriel sur GitHub.

// Créer un point de données de vitesse pour le segment de première exécution DataPoint firstRunSpeedDataPoint = speedDataSet.createDataPoint () .setTimeInterval (startTime, walkStartTime, TimeUnit.MILLISECONDS); firstRunSpeedDataPoint.getValue (Field.FIELD_SPEED) .setFloat (firstRunSpeed); speedDataSet.add (firstRunSpeedDataPoint); // Création du point de données d'activité pour le segment d'exécution deuxième DataPoint secondRunActivityDataPoint = activityDataSet.createDataPoint () .setTimeInterval (walkEndTime, endTime, TimeUnit.MILLISECONDS); secondRunActivityDataPoint.getValue (Field.FIELD_ACTIVITY) .setActivity (FitnessActivities.RUNNING); activityDataSet.add (secondRunActivityDataPoint);

Une fois que vous avez rempli les deux DataSet groupes, il est temps de créer le Session que vous allez insérer. Ce Session vous devrez définir le nom, l'identificateur unique, la description, les heures de début et de fin et les propriétés de l'activité. Une chose importante à savoir est que le nom que vous utilisez lors de l'insertion d'un Session est le nom que vous devez utiliser lorsque vous essayez de lire cette session ultérieurement.

Session session = new Session.Builder () .setName (SESSION_NAME) .setIdentifier (getString (R.string.app_name) + "" + System.currentTimeMillis ()) .setDescription ("Exécution en segments") .setStartTime (startTime, TimeUnit .MILLISECONDS) .setEndTime (endTime, TimeUnit.MILLISECONDS) .setActivity (FitnessActivities.RUNNING) .build ();

Maintenant que votre Session est créé, vous devez créer un SessionInsertRequest, Ajoutez votre DataSet les objets, puis insérez cette Session dans Google Fit.

SessionInsertRequest insertRequest = new SessionInsertRequest.Builder () .setSession (session) .addDataSet (speedDataSet) .addDataSet (activityDataSet) .build (); En attente de résultat waitingResult = Fitness.SessionsApi.insertSession (mGoogleApiClient, insertRequest); waitingResult.setResultCallback (nouveau ResultCallback() @Override public void onResult (Status status) if (status.isSuccess ()) Log.i ("Tuts +", "session en cours insérée avec succès");  else Log.i ("Tuts +", "Impossible d'insérer la session en cours:" + status.getStatusMessage ()); );

Lecture des données de session

Peu importe la quantité de données de session que vous stockez avec votre application, cela ne vous sera pas très utile si vous ne pouvez pas lire ces données et les utiliser pour améliorer votre application pour vos utilisateurs. Heureusement, Google Fit simplifie incroyablement la réception des données de session dans un délai déterminé..

Tout d'abord, vous devez sélectionner l'heure de début et de fin des données que vous souhaitez recevoir. Dans cet exemple, nous demandons des données de session pour le dernier mois.

Calendrier cal = Calendar.getInstance (); Date now = new Date (); cal.setTime (maintenant); long endTime = cal.getTimeInMillis (); cal.add (Calendar.MONTH, -1); long startTime = cal.getTimeInMillis ();

Une fois que vous avez sélectionné votre fenêtre de temps, vous devez créer un SessionReadRequest. Cette demande inclut l'intervalle de temps pour les données de session souhaitées, le type de données de session que vous recherchez (ce didacticiel ne cherchera que des données de vitesse) et le nom des sessions que vous demandez, bien que l'intervalle de temps soit le même. seule propriété requise.

SessionReadRequest readRequest = new SessionReadRequest.Builder () .setTimeInterval (startTime, endTime, TimeUnit.MILLISECONDS) .rr (DataType.TYPE_SPEED) .setSessionName (SESSION_NAME) .build (); En attente de résultat sessionReadResult = Fitness.SessionsApi.readSession (mGoogleApiClient, readRequest);

Après avoir appelé SessionsApi.readSession, vous recevez un SessionReadResult objet qui contient des listes de Session et DataSet objets que vous pouvez utiliser dans votre application. Pour ce tutoriel, nous enregistrons simplement les données.

sessionReadResult.setResultCallback (nouveau ResultCallback() @Override public void onResult (SessionReadResult sessionReadResult) if (sessionReadResult.getStatus (). IsSuccess ()) Log.i ("Tuts +", "Lecture réussie des données de session"); for (session session: sessionReadResult.getSessions ()) Log.i ("Tuts +", "Nom de la session:" + session.getName ()); for (DataSet dataSet: sessionReadResult.getDataSet (session)) pour (DataPoint dataPoint: dataSet.getDataPoints ()) Log.i ("Tuts +", "Vitesse:" + dataPoint.getValue (Field.FIELD_SPEED));  else Log.i ("Tuts +", "Impossible de lire les données de la session"); );

Si vous exécutez votre application maintenant et utilisez les opérations d'insertion et de lecture, vous devriez recevoir le message à trois vitesses. Point de données objets que vous avez créés dans la section précédente.

I / Tuts +: Vitesse: 15.0 I / Tuts +: Vitesse: 5.0 I / Tuts +: Vitesse: 13.0

Suppression de données de session

Il peut arriver que vous deviez supprimer des informations de session incorrectes ou inutiles. Pour ce faire, utilisez l'historique API pour supprimer les sessions enregistrées dans le magasin de données Google Fit..

Tout d'abord, vous devez déterminer un intervalle de temps pour l'opération de suppression. Vous pouvez ensuite ajouter des informations supplémentaires, telles qu'un Type de données ou autre Session propriétés à supprimer, ou vous pouvez simplement supprimer toutes les données de session dans l'intervalle de temps.

Calendrier calendrier = Calendar.getInstance (); Date now = new Date (); calendar.setTime (maintenant); long endTime = calendar.getTimeInMillis (); calendar.add (Calendar.DAY_OF_YEAR, -1); long startTime = calendar.getTimeInMillis (); Demande DataDeleteRequest = new DataDeleteRequest.Builder () .setTimeInterval (startTime, endTime, TimeUnit.MILLISECONDS) .addDataType (DataType.TYPE_SPEED) .deleteAllSessions () .build (); En attente de résultat deleteRequest = Fitness.HistoryApi.deleteData (mGoogleApiClient, demande); deleteRequest.setResultCallback (nouveau ResultCallback() @Override public void onResult (@NonNull Status status) if (status.isSuccess ()) Log.i ("Tuts +", "Sessions supprimées avec succès");  else Log.i ("Tuts +", "Echec de la suppression des sessions"); );

Conclusion

Comme vous l'avez appris dans ce didacticiel, l'API Sessions est un outil puissant pour organiser les données collectées par blocs de temps. C'est un excellent compliment pour les autres API Google Fit. Utilisé conjointement avec les API History et Recording, vous pouvez faire beaucoup pour comprendre l'activité des utilisateurs de votre application et leur fournir une excellente expérience avec vos applications de fitness.