Utiliser des sessions

Les sessions représentent l'intervalle de temps pendant lequel les utilisateurs faire une activité physique. L'API Sessions permet à votre application de créer des sessions dans le magasin de fitness.

Pour les activités de fitness en cours, où l'utilisateur avertit votre application lorsqu'il commence et de terminer une activité physique, vous pouvez créer des sessions en temps réel.

Vous pouvez également insérer une session dans la boutique de remise en forme après une activité physique ou lorsque vous importez des données et des sessions en dehors de Google Fit.

Créer des sessions en temps réel

Pour créer des sessions pour des activités de fitness en cours, procédez comme suit:

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

  2. Démarrez une session à l'aide du SessionsClient.startSession lorsque l'utilisateur lance l'activité de remise en forme.

  3. Arrêtez la session à l'aide du SessionsClient.stopSession lorsque l'utilisateur met fin à l'activité physique.

  4. Se désabonner des données de remise en forme que vous ne souhaitez plus utiliser 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 comporte les paramètres suivants:

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

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

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

Insérer les sessions dans le magasin de remise en forme

Pour insérer des sessions contenant des données que vous avez collectées précédemment, procédez comme suit:

  1. Créez un objet Session qui spécifie un intervalle de temps et d'autres des informations.

  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

Insérer des données de remise en forme contenant les métadonnées de session dans l'activité 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 votre activité physique 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 avait appelé 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é

Dans Google Fit, les données sur les segments d'activité indiquent quelle activité physique les performances des utilisateurs au cours d'un intervalle de temps donné. Les données sur les segments d'activité sont de type com.google.activity.segment (TYPE_ACTIVITY_SEGMENT) Il est particulièrement utile pour faire des pauses pendant les entraînements.

Par exemple, si vous créez une session de course de 30 minutes avec Session.Builder.setActivity() , mais l'utilisateur fait une pause de 10 minutes entre-temps, votre application indiquer à tort que l’utilisateur a fonctionné pendant 30 minutes. Si votre application peut détecter si l'utilisateur marche ou court, les données sur les segments d'activité permettent application indiquent que l'utilisateur a couru 10 minutes, marchait pendant 10 minutes, puis a couru pendant 10 minutes supplémentaires. D'autres applications peuvent également signaler l'activité correctement en examinant les données sur les segments d'activité que vous insérez.

Pour ajouter des données sur des segments 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 intervalle de temps continu pendant lequel l'utilisateur a effectué un seul type d'activité.

Dans l'exemple précédent, la course et la marche nécessiteraient trois segments d'activité. points: un pour la course à pied pendant les 10 premières minutes, un pour la marche au cours des 10 prochaines minutes et l'autre pendant 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 à l'aide des sessions

L'API Sessions vous permet d'obtenir la liste des sessions du magasin de fitness qui correspondent à certains critères. Par exemple, vous pouvez obtenir toutes les sessions d'un un intervalle de temps spécifique, ou obtenir une session spécifique par son nom ou son identifiant. Vous pouvez également spécifier que vous soyez intéressé par les sessions créées par votre application ou par n'importe quelle application.

Pour obtenir la liste des sessions qui correspondent à certains critères, créez d'abord 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 méthode:

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 le sommeil à l'aide des sessions

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

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

Afficher les sessions dans d'autres applis

Pour afficher une vue plus détaillée d'une session spécifique dans une autre application, votre application peut appeler un intent contenant les informations de session. Vous pouvez spécifier une application spécifique, comme celle qui a créé la session. Ou, si le l'application qui a créé la session n'est pas installée sur l'appareil, vous pouvez autoriser une application capable d'afficher une activité physique pour répondre à l'intent.

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

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 des intents provenant d'autres applications

Pour enregistrer votre application afin de recevoir des 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>

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

Les intents de fitness incluent les extras 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 extras 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());
    }
}