Google Fit pour Android: lecture des données du capteur

introduction

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

Bien qu’il existe de nombreuses API différentes pour Google Fit, comme indiqué dans cet article de présentation d’Envato Tuts +, ce didacticiel se concentre sur la configuration et l’utilisation de Google Fit pour lire les données des capteurs sur un appareil Android. Un exemple de projet pour ce didacticiel est disponible sur GitHub.

1. Configuration de la Developer Console

Pour utiliser Google Fit pour Android, vous devez:

• activer le API de remise en forme dans le Google Developers Console
• créé un ID client OAuth 2.0
• connectez-vous à l’API Fitness dans votre application Android

Cette section vous montre comment configurer votre application Android et l’API Fitness. Vous pouvez commencer par visiter le Google Developers Console. Si vous avez déjà un projet sur lequel travailler, vous pouvez ignorer l’étape suivante. Sinon, suivez et créez un nouveau projet pour votre application Google Fit.

Étape 1: créer un projet

Pour créer un nouveau projet, cliquez sur le bleu Créer un projet bouton dans le coin supérieur gauche de l’écran.

Cela vous présente une boîte de dialogue qui demande un nom de projet. Pour ce tutoriel, j’ai créé un projet et l’ai nommé TutsPlusGoogleFit. Il existe certaines restrictions sur le nom que vous pouvez attribuer à votre projet. Seuls les lettres, les chiffres, les guillemets, les traits d’union, les espaces et les points d’exclamation sont autorisés.

Une fois que vous frappez Créer, une boîte de dialogue apparaît dans le coin inférieur droit de la page, indiquant que le projet est en cours de création.

Étape 2: Activez l’API Google Fit

Une fois le projet mis en place, vous êtes dirigé vers le projet Aperçu page. Le moyen le plus simple de trouver l’API Google Fit consiste à rechercher le mot clé “en forme”. Sélectionner API de remise en forme à partir des résultats qui apparaissent.

Cliquez sur Activer l’API pour permettre à API de remise en forme.

Après avoir activé l’API Fitness, vous recevez un avertissement qui vous informe que vous devez également créer des informations d’identification pour utiliser l’API Fitness. Heureusement, l’avertissement comprend un bouton qui nous amène à la Identifiants page.

Étape 3: créer des informations d’identification

Sur le Identifiants , vous devez fournir des informations générales sur votre application dans la Assistant d’identification. Précisez que vous utilisez le API de remise en forme, que l’API est appelée à partir d’un Android application, et à laquelle l’application doit accéder Données d’utilisateur.

Ensuite, cliquez sur De quelles informations ai-je besoin? en bas pour continuer et créer un ID client OAuth 2.0 pour votre application Android. Vous avez besoin de deux informations importantes pour cette étape:

• empreinte digitale du certificat de signature
• nom du package de l’application

Vous pouvez obtenir l’empreinte digitale du certificat de signature en ouvrant un terminal ou une invite de commande et en accédant à l’emplacement du certificat de signature de votre application. Il s’agit de votre clé de version ou de la valeur par défaut debug.keystore certificat utilisé par Android Studio. Une fois que vous avez accédé à votre keystore, vous pouvez générer le SHA1 nécessaire avec la commande suivante, où debug.keystore est le nom du certificat de signature.

keytool -list -v -keystore debug.keystore

Collez la clé SHA1 dans le champ SHA1 et entrez com.tutsplus.googlefit dans le champ du nom du package.

Enfin, vous devez configurer l’écran de consentement OAuth 2.0. Il s’agit de l’écran qui s’affiche pour l’utilisateur afin qu’il puisse autoriser votre application à utiliser ses données de fitness. Cette étape nécessite votre adresse e-mail et un nom de produit à afficher aux utilisateurs. Pour ce tutoriel, j’ai entré Tuts + Google Fit.

Cliquez sur Continuer et, sur la page suivante, cliquez sur Terminé pour terminer le processus d’installation.

Étape 4: Configuration du projet Android

Une fois votre projet configuré et configuré dans la Google Developer Console, vous pouvez commencer à créer un nouveau projet Android. Assurez-vous que le nom du package correspond à celui que vous avez entré dans le Google Developer Console et paramétrez l’application pour qu’elle utilise Téléphone et tablette plates-formes avec une version SDK minimale de 14. Le niveau d’API minimal pour Google Fit est de 9. Créez un Activité vide pour garder le projet de base propre afin que vous puissiez vous concentrer sur l’API Google Fit dans ce didacticiel.

Après avoir configuré le projet, ouvrez le build.gradle et importez le package fitness à partir des services Google Play en ajoutant la ligne suivante à la dependencies nœud.

compile 'com.google.android.gms:play-services-fitness:8.4.0'

Ensuite, ouvrez MainActivity.java et ajoutez les interfaces suivantes:

• OnDataPointListener
• GoogleApiClient.ConnectionCallback
• GoogleApiClient.OnConnectionFailedListener

Une fois que vous avez ajouté les méthodes requises pour ces interfaces, votre classe devrait ressembler à ceci:

public class MainActivity extends AppCompatActivity implements 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) {

    }
}

Enfin, créez les variables membres que vous utiliserez pour ce didacticiel. Vous pouvez copier les lignes suivantes en haut de la classe:

private static final int REQUEST_OAUTH = 1;
private static final String AUTH_PENDING = "auth_state_pending";
private boolean authInProgress = false;
private GoogleApiClient mApiClient;

À l’étape suivante, vous vous connecterez aux services Google Play et découvrirez comment accéder aux données de fitness de l’utilisateur dans votre application.

2. Utilisation de l’API Fitness

Étape 1: connexion aux services Google Play

Avec le projet mis en place dans Android Studio et la Google Developer Console, il est temps de plonger dans l’API Fitness. dans le onCreate(), méthode, vous vérifiez si votre application tente déjà d’autoriser par rapport à l’API Fitness. Vous initialisez ensuite le GoogleApiClient instance en ajoutant l’API Fitness Sensors, en définissant une portée et en enregistrant les rappels d’application. Si vous ne demandez pas d’étendue, votre application ne pourra pas s’autoriser par rapport à 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();

}

Après avoir initialisé le GoogleApiClient Par exemple, vous devez le connecter au backend de Google. Vous pouvez le faire en onStart().

@Override
protected void onStart() {
    super.onStart();
    mApiClient.connect();
}

La première fois que l’utilisateur exécute l’application, la connexion à l’API Fitness échouera car l’utilisateur doit autoriser votre application à accéder à ses données de fitness. Vous pouvez écouter cet événement dans onConnectionFailed() et réagissez en conséquence en vérifiant si l’autorisation est en cours. Si c’est le cas, appelez startResolutionForResult() afin que les services Google Play puissent gérer correctement l’utilisateur accordant l’autorisation d’utiliser ses informations.

@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" );
    }
}

Si vous exécutez votre application maintenant, il se peut qu’une boîte de dialogue vous demande de sélectionner un compte Google à utiliser si vous avez utilisé plusieurs comptes sur votre appareil.

Lorsque le système d’exploitation sait quel compte utiliser, votre application présente une nouvelle boîte de dialogue qui demande à l’utilisateur d’accorder à l’application l’autorisation de lire les données de fitness.

À ce stade, l’utilisateur accorde à votre application l’autorisation d’utiliser ses données ou ferme la boîte de dialogue, annulant le processus. Vous pouvez écouter les deux événements dans onActivityResult() et gérer le résultat. Si l’utilisateur accorde l’autorisation à votre application, votre application reçoit un RESULT_OK réponse et il peut alors tenter de se connecter au client API Google.

@Override
protected 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");
    }
}

Votre application devrait maintenant pouvoir se connecter avec succès aux services Google Play. Avec cela à l’écart, vous pouvez commencer à vous concentrer sur l’API Fitness.

Étape 2: Accéder aux données d’étape avec l’API Fitness

Quand ton GoogleApiClient l’instance s’est connectée à Google, le onConnected() le rappel est déclenché. Dans ce rappel, vous devez créer un nouveau DataSourcesRequest objet qui définit le type de données qui intéresse votre application. Vous devez également créer un ResultCallback qui gère ce que l’application doit faire si les étapes peuvent être récupérées à partir de l’appareil. Une fois les objets créés, appelez Fitness.SensorsApi.findDataSources() pour commencer à rechercher une source de données d’étape valide.

@Override
public void onConnected(Bundle bundle) {
    DataSourcesRequest dataSourceRequest = new DataSourcesRequest.Builder()
            .setDataTypes( DataType.TYPE_STEP_COUNT_CUMULATIVE )
            .setDataSourceTypes( DataSource.TYPE_RAW )
            .build();

    ResultCallback<DataSourcesResult> dataSourcesResultCallback = new ResultCallback<DataSourcesResult>() {
        @Override
        public void 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);
}

Vous remarquerez peut-être que le registerFitnessDataListener() La méthode n’existe pas réellement. Il s’agit d’une méthode d’assistance qui est appelée lorsque la source de données pour le compteur d’étapes est trouvée, qui crée ensuite un SensorRequest objet pour demander des données au capteur de pas.

Dans l’extrait de code suivant, le SensorRequest l’objet tente de trouver le nombre de pas toutes les trois secondes. le Fitness.SensorApi puis ajoute la demande avec un nouveau OnDataPointListener de sorte que, lorsque de nouvelles données sont disponibles, l’écouteur est déclenché. Si aucune nouvelle donnée n’est trouvée, le OnDataPointListener n’est pas déclenchée et l’API Fitness attend encore trois secondes avant de vérifier à nouveau.

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(new ResultCallback<Status>() {
                @Override
                public void onResult(Status status) {
                    if (status.isSuccess()) {
                        Log.e( "GoogleFit", "SensorApi successfully added" );
                    }
                }
            });
}

Lorsqu’une modification du nombre de pas est détectée, onDataPoint() est invoquée. Dans cette méthode, vous parcourez les champs du DataPoint paramètre et afficher un Toast message avec le nom et la valeur du champ. Dans cet exemple, ce sera le compteur de pas. Dans vos propres applications, vous utiliseriez une logique plus appropriée pour effectuer votre tâche. Vous remarquerez que le Toast la commande est enveloppée dans un Runnable qui est passé à runOnUiThread. Cela est dû au fait que le rappel n’est pas déclenché sur le thread d’interface utilisateur principal.

@Override
public void onDataPoint(DataPoint dataPoint) {
    for( final Field field : dataPoint.getDataType().getFields() ) {
        final Value value = dataPoint.getValue( field );
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                Toast.makeText(getApplicationContext(), "Field: " + field.getName() + " Value: " + value, Toast.LENGTH_SHORT).show();
            }
        });
    }
}

Il y a deux autres choses que vous devez faire pour cet exemple. Le premier consiste à se déconnecter du SensorApi et les services Google Play lorsque vous avez fini de les utiliser. Dans cet exemple, vous faites cela lorsque onStop() est appelé. Le second est de stocker le authInProgress valeur vérifiée par onCreate() dans onSavedInstanceState().

@Override
protected void onStop() {
    super.onStop();

    Fitness.SensorsApi.remove( mApiClient, this )
            .setResultCallback(new ResultCallback<Status>() {
                @Override
                public void onResult(Status status) {
                    if (status.isSuccess()) {
                        mApiClient.disconnect();
                    }
                }
            });
}

@Override
protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    outState.putBoolean(AUTH_PENDING, authInProgress);
}

Conclusion

Dans ce didacticiel, vous avez appris à vous connecter à l’API Google Play Services Fitness et à lire les données du capteur de fitness à partir de l’appareil de l’utilisateur. Même quelque chose d’aussi simple que des données d’étape pour votre utilisateur peut s’avérer extrêmement précieux pour des applications telles que Cadrans Android Wear ou trackers d’objectifs. Il y a des dizaines d’autres types de sources de données vous pouvez utiliser et de nombreuses autres API dans Google Fit pour améliorer encore davantage vos applications.