Utiliser des sessions

Les sessions représentent un intervalle de temps pendant lequel les utilisateurs peuvent pratiquer une activité physique. L'API Sessions permet à votre application de créer des sessions dans le magasin de remise en forme.

Pour les activités de remise en forme en cours, où l'utilisateur informe votre application du début et de la fin d'une activité de remise en forme, vous pouvez créer des sessions en temps réel.

Vous pouvez également insérer une session dans le magasin de remise en forme à la fin d'une activité de remise en forme ou lorsque vous importez des données et des sessions en dehors de Google Fit.

Remarque : Pour connaître les bonnes pratiques en matière de gestion des données utilisateur, consultez les Règles concernant les données utilisateur et les développeurs Google Fit.

Créer des sessions en temps réel

Pour créer des sessions pour vos activités de remise en forme en cours:

1. S'abonner aux données de remise en forme à l'aide de la méthode RecordingClient.subscribe.

2. Démarrez une session à l'aide de la méthode SessionsClient.startSession lorsque l'utilisateur commence l'activité de remise en forme.

3. Arrêtez la session à l'aide de la méthode SessionsClient.stopSession lorsque l'utilisateur met fin à l'activité de remise en forme.

4. Se désabonner des données d'activité qui ne vous intéressent plus à l'aide de la méthode RecordingClient.unsubscribe.

Démarrer une session

Pour démarrer une session dans votre application, utilisez la méthode SessionsClient.startSession:

Kotlin

// 1. Subscribe to fitness data
// 2. Create a session object
// (provide a name, identifier, description, activity and start time)
val session = Session.Builder()
    .setName(sessionName)
    .setIdentifier("UniqueIdentifierHere")
    .setDescription("Morning run")
    .setActivity(FitnessActivities.RUNNING)
    .setStartTime(startTime, TimeUnit.MILLISECONDS)
    .build()

// 3. Use the Sessions client to start a session:
Fitness.getSessionsClient(this, googleSigninAccount)
    .startSession(session)
    .addOnSuccessListener {
        Log.i(TAG, "Session started successfully!")
    }
    .addOnFailureListener { e ->
        Log.w(TAG, "There was an error starting the session", e)
    }

Java

// 1. Subscribe to fitness data
// 2. Create a session object
// (provide a name, identifier, description, activity and start time)
Session session = new Session.Builder()
        .setName(sessionName)
        .setIdentifier("UniqueIdentifierHere")
        .setDescription("Morning run")
        .setActivity(FitnessActivities.RUNNING)
        .setStartTime(startTime, TimeUnit.MILLISECONDS)
        .build();

// 3. Use the Sessions client to start a session:
Fitness.getSessionsClient(this, googleSigninAccount)
        .startSession(session)
        .addOnSuccessListener(unused ->
                Log.i(TAG, "Session started successfully!"))
        .addOnFailureListener(e ->
                Log.w(TAG, "There was an error starting the session", e));

Arrêter une session

Pour arrêter une session dans votre application, utilisez la méthode SessionsClient.stopSession:

Kotlin

// Invoke the SessionsClient with the session identifier
Fitness.getSessionsClient(this, googleSigninAccount)
    .stopSession(session.getIdentifier())
    .addOnSuccessListener {
        Log.i(TAG, "Session stopped successfully!")

        // Now unsubscribe from the fitness data (see
        // Recording Fitness data)
    }
    .addOnFailureListener { e ->
        Log.w(TAG, "There was an error stopping the session", e)
    }

Java

// Invoke the SessionsClient with the session identifier
Fitness.getSessionsClient(this, googleSigninAccount)
        .stopSession(session.getIdentifier())
        .addOnSuccessListener (unused -> {
            Log.i(TAG, "Session stopped successfully!");
            // Now unsubscribe from the fitness data (see
            // Recording Fitness data)
        })
        .addOnFailureListener(e ->
                Log.w(TAG, "There was an error stopping the session", e));

La session obtenue comprend les paramètres suivants:

• Heure de début: heure à laquelle votre application a appelé la méthode SessionsClient.startSession.

• Heure de fin: heure à laquelle votre application a appelé la méthode SessionsClient.stopSession.

• Nom: nom de l'objet Session que vous transmettez à SessionsClient.startSession.

Insérer des sessions dans le magasin de fitness

Pour insérer des sessions avec des données que vous avez précédemment collectées:

1. Créez un objet Session spécifiant un intervalle de temps et d'autres informations requises.

2. Créez un SessionInsertRequest avec la session.

3. Vous pouvez également ajouter des ensembles de données et agréger des points de données.

4. Insérez la session à l'aide de la méthode SessionsClient.insertSession.

Insérer une session

Pour insérer des données de remise en forme contenant des métadonnées de session dans l'historique de remise en forme de l'utilisateur, créez d'abord une instance SessionInsertRequest:

Kotlin

// Create a session with metadata about the activity.
val session = Session.Builder()
    .setName(SAMPLE_SESSION_NAME)
    .setIdentifier("UniqueIdentifierHere")
    .setDescription("Long run around Shoreline Park")

    .setActivity(FitnessActivities.RUNNING)
    .setStartTime(startTime, TimeUnit.MILLISECONDS)
    .setEndTime(endTime, TimeUnit.MILLISECONDS)
    .build()

// Build a session insert request
val insertRequest = SessionInsertRequest.Builder()
    .setSession(session)
    // Optionally add DataSets for this session.
    .addDataSet(dataset)
    .build()

Java

// Create a session with metadata about the activity.
Session session = new Session.Builder()
        .setName(SAMPLE_SESSION_NAME)
        .setIdentifier("UniqueIdentifierHere")
        .setDescription("Long run around Shoreline Park")

        .setActivity(FitnessActivities.RUNNING)
        .setStartTime(startTime, TimeUnit.MILLISECONDS)
        .setEndTime(endTime, TimeUnit.MILLISECONDS)
        .build();

// Build a session insert request
SessionInsertRequest insertRequest = new SessionInsertRequest.Builder()
        .setSession(session)
        // Optionally add DataSets for this session.
        .addDataSet(dataset)
        .build();

La classe SessionInsertRequest fournit des méthodes pratiques pour insérer des données dans l'historique de remise en forme et créer une session dans le même appel à SessionsClient.insertSession. Les ensembles de données, le cas échéant, sont insérés comme si vous aviez d'abord appelé la méthode HistoryClient.insertData, puis la session est créée.

Kotlin

Fitness.getSessionsClient(this, GoogleSignIn.getAccountForExtension(this, fitnessOptions))
    .insertSession(insertRequest)
    .addOnSuccessListener {
        Log.i(TAG, "Session insert was successful!")
    }
    .addOnFailureListener { e ->
        Log.w(TAG, "There was a problem inserting the session: ", e)
    }

Java

Fitness.getSessionsClient(this, GoogleSignIn.getAccountForExtension(this, fitnessOptions))
        .insertSession(insertRequest)
        .addOnSuccessListener (unused ->
                Log.i(TAG, "Session insert was successful!"))
        .addOnFailureListener(e ->
        Log.w(TAG, "There was a problem inserting the session: ", e));

Insérer des segments d'activité

Les données des segments d'activité dans Google Fit indiquent les activités d'activité physique des utilisateurs sur un intervalle de temps donné. Les données relatives aux segments d'activité sont de type com.google.activity.segment (TYPE_ACTIVITY_SEGMENT) et sont particulièrement utiles pour permettre les pauses pendant les entraînements.

Par exemple, si vous créez une session de 30 minutes en cours d'exécution avec la méthode Session.Builder.setActivity(), mais que l'utilisateur fait une pause de 10 minutes entre les deux, votre application affichera à tort que l'utilisateur a été exécuté pendant 30 minutes. Si votre application peut détecter si l'utilisateur a été en train de marcher ou de courir, les données du segment d'activité permettent à votre application d'indiquer que l'utilisateur a exécuté l'application pendant 10 minutes, puis a marché 10 minutes et 10 minutes supplémentaires. D'autres applications peuvent également signaler l'activité correctement en consultant les données du segment d'activité que vous insérez.

Pour ajouter des données de segment d'activité à une session, créez un ensemble de données contenant des points de type com.google.activity.segment. Chacun de ces points représente un intervalle de temps continu pendant lequel l'utilisateur a effectué un seul type d'activité.

L'exemple précédent de marche et de course à pied nécessiterait trois points de segment d'activité: un pour les 10 premières minutes, un pour les 10 prochaines minutes, et un pour les 10 dernières minutes.

Kotlin

// Create a DataSet of ActivitySegments to indicate the runner walked for
// 10 minutes in the middle of a run.
val activitySegmentDataSource = DataSource.Builder()
    .setAppPackageName(this.packageName)
    .setDataType(DataType.TYPE_ACTIVITY_SEGMENT)
    .setStreamName(SAMPLE_SESSION_NAME + "-activity segments")
    .setType(DataSource.TYPE_RAW)
    .build()

val firstRunningDp = DataPoint.builder(activitySegmentDataSource)
    .setActivityField(Field.FIELD_ACTIVITY, FitnessActivities.RUNNING)
    .setTimeInterval(startTime, startWalkTime, TimeUnit.MILLISECONDS)
    .build()

val walkingDp = DataPoint.builder(activitySegmentDataSource)
    .setActivityField(Field.FIELD_ACTIVITY, FitnessActivities.WALKING)
    .setTimeInterval(startWalkTime, endWalkTime, TimeUnit.MILLISECONDS)
    .build()

val secondRunningDp = DataPoint.builder(activitySegmentDataSource)
    .setActivityField(Field.FIELD_ACTIVITY, FitnessActivities.RUNNING)
    .setTimeInterval(endWalkTime, endTime, TimeUnit.MILLISECONDS)
    .build()

val activitySegments = DataSet.builder(activitySegmentDataSource)
    .addAll(listOf(firstRunningDp, walkingDp, secondRunningDp))
    .build()

// Create a session with metadata about the activity.
val session = Session.Builder()
    .setName(SAMPLE_SESSION_NAME)
    .setDescription("Long run around Shoreline Park")
    .setIdentifier("UniqueIdentifierHere")
    .setActivity(FitnessActivities.RUNNING)
    .setStartTime(startTime, TimeUnit.MILLISECONDS)
    .setEndTime(endTime, TimeUnit.MILLISECONDS)
    .build()

// Build a session insert request
val insertRequest = SessionInsertRequest.Builder()
    .setSession(session)
    .addDataSet(activitySegments)
    .build()

Java

// Create a DataSet of ActivitySegments to indicate the runner walked for
// 10 minutes in the middle of a run.
DataSource activitySegmentDataSource = new DataSource.Builder()
        .setAppPackageName(getPackageName())
        .setDataType(DataType.TYPE_ACTIVITY_SEGMENT)
        .setStreamName(SAMPLE_SESSION_NAME + "-activity segments")
        .setType(DataSource.TYPE_RAW)
        .build();

DataPoint firstRunningDp = DataPoint.builder(activitySegmentDataSource)
        .setActivityField(Field.FIELD_ACTIVITY, FitnessActivities.RUNNING)
        .setTimeInterval(startTime, startWalkTime, TimeUnit.MILLISECONDS)
        .build();

DataPoint walkingDp = DataPoint.builder(activitySegmentDataSource)
        .setActivityField(Field.FIELD_ACTIVITY, FitnessActivities.WALKING)
        .setTimeInterval(startWalkTime, endWalkTime, TimeUnit.MILLISECONDS)
        .build();

DataPoint secondRunningDp = DataPoint.builder(activitySegmentDataSource)
        .setActivityField(Field.FIELD_ACTIVITY, FitnessActivities.RUNNING)
        .setTimeInterval(endWalkTime, endTime, TimeUnit.MILLISECONDS)
        .build();

DataSet activitySegments = DataSet.builder(activitySegmentDataSource)
        .addAll(Arrays.asList(firstRunningDp, walkingDp, secondRunningDp))
        .build();

// Create a session with metadata about the activity.
Session session = new Session.Builder()
        .setName(SAMPLE_SESSION_NAME)
        .setDescription("Long run around Shoreline Park")
        .setIdentifier("UniqueIdentifierHere")
        .setActivity(FitnessActivities.RUNNING)
        .setStartTime(startTime, TimeUnit.MILLISECONDS)
        .setEndTime(endTime, TimeUnit.MILLISECONDS)
        .build();

// Build a session insert request
SessionInsertRequest insertRequest = new SessionInsertRequest.Builder()
        .setSession(session)
        .addDataSet(activitySegments)
        .build();

Lire les données d'activité physique via des sessions

L'API Sessions vous permet d'obtenir la liste des sessions du magasin de fitness correspondant à certains critères. Par exemple, vous pouvez obtenir toutes les sessions contenues dans un intervalle de temps, ou obtenir une session particulière par nom ou par ID. Vous pouvez également indiquer si les sessions créées par votre application ou par une autre application vous intéressent.

Remarque:Lorsque vous lisez des sessions créées par d'autres applications, nous vous recommandons d'indiquer aux utilisateurs les applications ayant contribué aux sessions afin que les utilisateurs sachent d'où proviennent ces données. Vous pouvez obtenir le nom et l'icône de l'application, ainsi que l'intention de lancer l'application, comme décrit dans la section Attribution des données.

Pour obtenir la liste des sessions qui correspondent à certains critères, commencez par créer une instance SessionReadRequest:

Kotlin

// Use a start time of 1 week ago and an end time of now.
val endTime = LocalDateTime.now().atZone(ZoneId.systemDefault())
val startTime = endTime.minusWeeks(1)

// Build a session read request
val readRequest = SessionReadRequest.Builder()
    .setTimeInterval(startTime.toEpochSecond(), endTime.toEpochSecond(), TimeUnit.SECONDS)
    .read(DataType.TYPE_SPEED)
    .setSessionName(SAMPLE_SESSION_NAME)
    .build()

Java

// Use a start time of 1 week ago and an end time of now.
ZonedDateTime endTime = LocalDateTime.now().atZone(ZoneId.systemDefault())
ZonedDateTime startTime = endTime.minusWeeks(1)

// Build a session read request
SessionReadRequest readRequest = new SessionReadRequest.Builder()
        .setTimeInterval(startTime.toEpochSecond(), endTime.toEpochSecond(), TimeUnit.SECONDS)
        .read(DataType.TYPE_SPEED)
        .setSessionName(SAMPLE_SESSION_NAME)
        .build();

Utilisez ensuite la méthode SessionsClient.readSession:

Kotlin

Fitness.getSessionsClient(this, GoogleSignIn.getAccountForExtension(this, fitnessOptions))
    .readSession(readRequest)
    .addOnSuccessListener { response ->
        // Get a list of the sessions that match the criteria to check the result.
        val sessions = response.sessions
        Log.i(TAG, "Number of returned sessions is: ${sessions.size}")
        for (session in sessions) {
            // Process the session
            dumpSession(session)

            // Process the data sets for this session
            val dataSets = response.getDataSet(session)
            for (dataSet in dataSets) {
                // ...
            }
        }
    }
    .addOnFailureListener { e ->
        Log.w(TAG,"Failed to read session", e)
    }

Java

Fitness.getSessionsClient(this, GoogleSignIn.getAccountForExtension(this, fitnessOptions))
        .readSession(readRequest)
        .addOnSuccessListener(response -> {
            // Get a list of the sessions that match the criteria to check the
            // result.
            List<Session> sessions = response.getSessions();
            Log.i(TAG, "Number of returned sessions is: ${sessions.size}");
            for (Session session : sessions) {
                // Process the session
                dumpSession(session);

                // Process the data sets for this session
                List<DataSet> dataSets = response.getDataSet(session);
                for (DataSet dataSet : dataSets) {
                    // ...
                }
            }
        })
        .addOnFailureListener(e ->
                Log.w(TAG,"Failed to read session", e));

Lire les données sur votre sommeil à l'aide de sessions

Les sessions de sommeil sont considérées comme distinctes des autres sessions d'activité. Par défaut, les réponses de lecture ne contiennent que des sessions d'activité, et non des sessions de sommeil.

Pour inclure des sessions de sommeil, utilisez la méthode includeSleepSessions lorsque vous créez votre SessionReadRequest. Pour inclure à la fois des activités et des sessions, utilisez includeSleepSessions et includeActivitySessions.

Afficher les sessions dans d'autres applications

Pour présenter aux utilisateurs une vue plus détaillée d'une session particulière dans une autre application, celle-ci peut appeler un intent contenant les informations sur la session. Vous pouvez spécifier une application particulière, telle que celle qui a créé la session. Si l'application qui a créé la session n'est pas installée sur l'appareil, vous pouvez autoriser n'importe quelle application pouvant afficher une activité physique à répondre à l'intent.

Pour créer un intent afin d'afficher les données de session sur une autre application, utilisez la classe SessionsApi.ViewIntentBuilder:

Kotlin

// Pass your activity object to the constructor
val intent = SessionsApi.ViewIntentBuilder(this)
    .setPreferredApplication("com.example.someapp") // optional
    .setSession(session)
    .build()

// Invoke the intent
startActivity(intent)

Java

// Pass your activity object to the constructor
Intent intent = new SessionsApi.ViewIntentBuilder(this)
        .setPreferredApplication("com.example.someapp") // optional
        .setSession(session)
        .build();

// Invoke the intent
startActivity(intent);

Recevoir les intents d'autres applications

Pour enregistrer votre application afin qu'elle reçoive les intents d'autres applications de santé et de bien-être, déclarez dans votre fichier manifeste un filtre d'intent semblable à celui-ci:

<intent-filter>
    <action android:name="vnd.google.fitness.VIEW"/>
    <data android:mimeType="vnd.google.fitness.session/running"/>
</intent-filter>

Remarque : N'incluez pas la catégorie DEFAULT dans votre filtre d'intent, sauf si vous souhaitez que votre application reçoive des intents pour les sessions créées par d'autres applications.

Chaque intent que votre application reçoit de Google Fit n'est associé qu'à une seule activité, mais vous pouvez filtrer plusieurs types MIME dans un seul filtre d'intent. Le filtre d'intent de votre appli doit inclure toutes les activités compatibles avec votre appli.

Les intents de remise en forme incluent les avantages suivants:

• vnd.google.gms.fitness.start_time
• vnd.google.gms.fitness.end_time
• vnd.google.gms.fitness.session

Vous pouvez obtenir des données à partir de ces bonus comme suit:

Kotlin

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    ...
    val supportedType = Session.getMimeType(FitnessActivities.RUNNING)

    if (Intent.ACTION_VIEW == intent.action && supportedType == intent.type) {
        // Get the intent extras
        val startTime = Fitness.getStartTime(intent, TimeUnit.MILLISECONDS);
        val endTime = Fitness.getEndTime(intent, TimeUnit.MILLISECONDS)
        val session = Session.extract(intent)
    }
}

Java

@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    ...

    String supportedType = Session.getMimeType(FitnessActivities.RUNNING);

    if (Intent.ACTION_VIEW.equals(getIntent().getAction()) && supportedType.equals(getIntent().getType())) {
        // Get the intent extras
        long startTime = Fitness.getStartTime(getIntent(), TimeUnit.MILLISECONDS);
        long endTime = Fitness.getEndTime(getIntent(), TimeUnit.MILLISECONDS);
        Session session = Session.extract(getIntent());
    }
}