Google Fit pour Android: API d’enregistrement

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 tutoriel se concentre sur l’utilisation de Google Fit pour créer des abonnements en arrière-plan à faible consommation pour les données de capteur. Nous explorons comment tirer parti des services Google Play pour stocker des données de fitness afin de pouvoir y accéder ultérieurement.

L’API d’enregistrement diffère de l’API Sensors en ce que les données de capteur en direct ne sont pas fournies à l’API d’enregistrement, mais plutôt les données sont enregistrées en ligne afin de sauvegarder un enregistrement de l’activité de l’utilisateur. Ce didacticiel comprend un exemple de projet, que vous pouvez télécharger à partir de GitHub.

1. Configuration du projet

Étape 1: configurer la Developer Console

Pour utiliser Google Fit, vous devez créer un ID client OAuth 2.0 et enregistrer votre application via la Google Developer Console. Vous pouvez trouver une explication détaillée de la configuration de la Google Developer Console dans mon didacticiel sur l’API Google Fit Sensors.

Étape 2: créer le projet Android

Une fois votre application configurée pour l’authentification dans la Google Developer Console, utilisez le nom du package que vous avez enregistré pour créer une nouvelle application Android avec un SDK minimum de 14 et un Activity.

Une fois l’application Android de base créée, ouvrez le build.gradle fichier et incluez les services Google Play sous le nœud des dépendances et synchronisez votre application.

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

Vous devriez maintenant être en mesure d’inclure les classes de services Google Play nécessaires dans votre application. Avant de plonger dans le code Java de ce tutoriel, ouvrez activity_main.xml et modifiez-le pour qu’il comprenne deux Button éléments qui seront utilisés pour démontrer certaines des fonctionnalités de l’API d’enregistrement.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="https://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <Button
        android:id="@+id/btn_show_subscriptions"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Show Subscriptions"/>
    <Button
        android:id="@+id/btn_cancel_subscriptions"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Cancel Subscriptions"/>
</LinearLayout>

Lorsque votre application est exécutée, l’interface utilisateur ressemblera à l’image ci-dessous.

Pour terminer la configuration de votre projet, ouvrez MainActivity.java et implémentez les rappels suivants et leurs méthodes requises:

• GoogleApiClient.ConnectionCallbacks
• GoogleAPiClient.OnConnectionFailedListener
• View.OnClickListener

Vous devez également ajouter les variables membres de votre classe, comme indiqué ci-dessous.

public class MainActivity extends AppCompatActivity implements
    GoogleApiClient.ConnectionCallbacks,
    GoogleApiClient.OnConnectionFailedListener,
    View.OnClickListener {

    private Button mCancelSubscriptionsBtn;
    private Button mShowSubscriptionsBtn;

    private ResultCallback<Status> mSubscribeResultCallback;
    private ResultCallback<Status> mCancelSubscriptionResultCallback;
    private ResultCallback<ListSubscriptionsResult> mListSubscriptionsResultCallback;

    private GoogleApiClient mGoogleApiClient;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    @Override
    public void onConnected(@Nullable Bundle bundle) {
        Log.e("RecordingAPI", "onConnected");
    }

    @Override
    public void onConnectionSuspended(int i) {
        Log.e("RecordingAPI", "onConnectionSuspended");
    }

    @Override
    public void onConnectionFailed(@NonNull ConnectionResult connectionResult) {
        Log.e("RecordingAPI", "onConnectionFailed");
    }

    @Override
    public void onClick(View v) {
    }
}

2. Initialisation

Avant de pouvoir commencer à utiliser les rappels et les vues que vous avez définis ci-dessus, vous devez les initialiser. Nous faisons cela en créant deux méthodes d’assistance, une pour initialiser les vues et une pour initialiser les callbacks qui sont appelés dans onCreate().

le initViews() méthode pointe le Button objets aux éléments définis dans activity.xml et définit un OnClickListener pour chaque bouton.

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    initViews();
    initCallbacks();
}

private void initViews() {
    mCancelSubscriptionsBtn = (Button) findViewById(R.id.btn_cancel_subscriptions);
    mShowSubscriptionsBtn = (Button) findViewById(R.id.btn_show_subscriptions);

    mCancelSubscriptionsBtn.setOnClickListener(this);
    mShowSubscriptionsBtn.setOnClickListener(this);
}

Dans initCallbacks(), les choses deviennent un peu plus intéressantes. Chaque rappel est utilisé pour une opération asynchrone spécifique de l’API d’enregistrement. Comme leur nom l’indique, mSubscribeResultCallback est appelé lorsque vous ajoutez pour la première fois un abonnement pour un capteur, mCancelSubscriptionResultCallback est appelé lorsque vous annulez cet abonnement, et mListSubscriptionResultCallback est utilisé lorsque vous demandez une liste de tous les abonnements.

Dans l’extrait de code suivant, les deux rappels liés au démarrage et à l’arrêt d’un abonnement enregistrent uniquement un succès ou un échec. mListSubscriptionResultCallback reçoit une liste d’abonnements et se déconnecte des informations sur chacun d’eux en obtenant le DataType et puis chacun Field associé à l’abonnement.

private void initCallbacks() {
    mSubscribeResultCallback = new ResultCallback<Status>() {
        @Override
        public void onResult(@NonNull Status status) {
            if (status.isSuccess()) {
                if (status.getStatusCode() == FitnessStatusCodes.SUCCESS_ALREADY_SUBSCRIBED) {
                    Log.e( "RecordingAPI", "Already subscribed to the Recording API");
                } else {
                    Log.e("RecordingAPI", "Subscribed to the Recording API");
                }
            }
        }
    };

    mCancelSubscriptionResultCallback = new ResultCallback<Status>() {
        @Override
        public void onResult(@NonNull Status status) {
            if (status.isSuccess()) {
                Log.e( "RecordingAPI", "Canceled subscriptions!");
            } else {
                // Subscription not removed
                Log.e("RecordingAPI", "Failed to cancel subscriptions");
            }
        }
    };

    mListSubscriptionsResultCallback = new ResultCallback<ListSubscriptionsResult>() {
        @Override
        public void onResult(@NonNull ListSubscriptionsResult listSubscriptionsResult) {
            for (Subscription subscription : listSubscriptionsResult.getSubscriptions()) {
                DataType dataType = subscription.getDataType();
                Log.e( "RecordingAPI", dataType.getName() );
                for (Field field : dataType.getFields() ) {
                    Log.e( "RecordingAPI", field.toString() );
                }
            }
        }
    };
}

3. Connexion et contrôle des abonnements

Maintenant que vous disposez du cadre général de votre exemple d’application, il est temps de tout conclure en vous connectant aux services Google Play et en demandant des abonnements.

Dans onCreate(), vous pouvez initialiser et vous connecter aux services Google Play en déclarant que vous utilisez Fitness.RECORDING_API, en ajoutant une portée pour lire les données d’activité physique et en le configurant pour se connecter / se déconnecter automatiquement tout au long du cycle de vie de l’application.

mGoogleApiClient = new GoogleApiClient.Builder(this)
        .addApi(Fitness.RECORDING_API)
        .addScope(new Scope(Scopes.FITNESS_ACTIVITY_READ))
        .addConnectionCallbacks(this)
        .enableAutoManage(this, 0, this)
        .build();

A tout moment après le GoogleApiClient s’est connecté, vous pouvez demander un abonnement. Pour ce tutoriel, nous nous abonnons à onConnected(). L’extrait suivant montre comment démarrer un abonnement pour les modifications du nombre de pas de l’utilisateur, bien que vous puissiez accéder à tous les capteurs pris en charge par Google Fit.

Si un abonnement est déjà en cours d’exécution en raison d’une action antérieure, le rappel reçoit un code d’état de FitnessStatusCodes.SUCCESS_ALREADY_SUBSCRIBED.

@Override
public void onConnected(@Nullable Bundle bundle) {
    Fitness.RecordingApi.subscribe(mGoogleApiClient, DataType.TYPE_STEP_COUNT_DELTA)
            .setResultCallback(mSubscribeResultCallback);
}

Il peut parfois être utile de demander une liste d’abonnements. Auparavant, vous avez créé deux boutons pour ces opérations. dans le onClick() méthode, vous vérifiez quel bouton a été touché et effectuez l’action correspondante.

@Override
public void onClick(View v) {
    switch(v.getId()) {
        case R.id.btn_cancel_subscriptions: {
            cancelSubscriptions();
            break;
        }
        case R.id.btn_show_subscriptions: {
            showSubscriptions();
            break;
        }
    }
}

Si showSubscriptions() est appelée, puis l’application demande une liste d’abonnements associés à l’API d’enregistrement.

private void showSubscriptions() {
    Fitness.RecordingApi.listSubscriptions(mGoogleApiClient)
            .setResultCallback(mListSubscriptionsResultCallback);
}

Ce qui provoque mListSubscriptionsResultCallback pour déconnecter tous les abonnements connectés. Le résultat ressemble à ceci:

.../com.tutsplus.googlefitrecordingapi E/RecordingAPI: com.google.step_count.delta
.../com.tutsplus.googlefitrecordingapi E/RecordingAPI: steps(i)

L’annulation d’un abonnement est simple comme vous pouvez le voir ci-dessous.

private void cancelSubscriptions() {
    Fitness.RecordingApi.unsubscribe(mGoogleApiClient, DataType.TYPE_STEP_COUNT_DELTA)
            .setResultCallback(mCancelSubscriptionResultCallback);
}

Conclusion

Vous devriez maintenant avoir une compréhension de base de la connexion à Google Fit à partir d’une application Android et de l’utilisation de l’API d’enregistrement. Bien que cela ne semble pas grand-chose pour le moment, cela vous ouvre la voie pour stocker des informations sur les activités physiques de l’utilisateur afin qu’elles soient accessibles par d’autres API Google Fit dans votre application.