Mit Sitzungen arbeiten

Sitzungen stellen ein Zeitintervall dar, in dem Nutzer eine Fitnessaktivität ausführen. Mit der Sessions API kann Ihre App Sitzungen im Fitnessspeicher erstellen.

Für laufende Fitnessaktivitäten, bei denen der Nutzer deine App benachrichtigt, wenn er eine Fitnessaktivität startet und beendet, kannst du Sitzungen in Echtzeit erstellen.

Sie können auch eine Sitzung in den Fitnessspeicher einfügen, wenn eine Fitnessaktivität abgeschlossen ist oder wenn Sie Daten und Sitzungen von außerhalb von Google Fit importieren.

Hinweis:Best Practices für die Verwaltung von Nutzerdaten finden Sie in der Google Fit-Richtlinie für Entwickler und Nutzerdaten.

Sitzungen in Echtzeit erstellen

So erstellen Sie Sitzungen für fortlaufende Fitnessaktivitäten:

1. Abonniere Fitnessdaten mit der Methode RecordingClient.subscribe.

2. Starte eine Sitzung mit der Methode SessionsClient.startSession, wenn der Nutzer die Fitnessaktivität initiiert.

3. Beenden Sie die Sitzung mit der Methode SessionsClient.stopSession, wenn der Nutzer die Fitnessaktivität beendet.

4. Keine Fitnessdaten mehr erhalten, für die Sie die Methode RecordingClient.unsubscribe nicht mehr nutzen möchten

Sitzung starten

Verwenden Sie die Methode SessionsClient.startSession, um eine Sitzung in Ihrer App zu starten:

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));

Sitzung beenden

Wenn Sie eine Sitzung in Ihrer App beenden möchten, verwenden Sie die Methode 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));

Die resultierende Sitzung hat die folgenden Parameter:

• Startzeit: Die Zeit, zu der Ihre App die Methode SessionsClient.startSession aufgerufen hat.

• Ende: Zeitpunkt, zu dem Ihre App die Methode SessionsClient.stopSession aufgerufen hat.

• Name: Der Name im Session-Objekt, das Sie an SessionsClient.startSession übergeben.

Trainingseinheiten in den Shop einfügen

So fügen Sie Sitzungen mit zuvor erfassten Daten ein:

1. Erstellen Sie ein Session-Objekt, das ein Zeitintervall und andere erforderliche Informationen angibt.

2. Erstellen Sie einen SessionInsertRequest mit der Sitzung.

3. Fügen Sie optional Datasets hinzu und aggregieren Sie Datenpunkte.

4. Fügen Sie die Sitzung mit der Methode SessionsClient.insertSession ein.

Sitzung einfügen

Wenn Sie Fitnessdaten mit Sitzungsmetadaten in den Fitnessverlauf des Nutzers einfügen möchten, erstellen Sie zuerst eine SessionInsertRequest-Instanz:

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();

Die Klasse SessionInsertRequest bietet praktische Methoden, um Daten in den Fitnessverlauf einzufügen und im selben SessionsClient.insertSession-Aufruf eine Sitzung zu erstellen. Die Datasets werden, sofern vorhanden, so eingefügt, als hätten Sie zuerst die Methode HistoryClient.insertData aufgerufen und dann die Sitzung erstellt.

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));

Aktivitätssegmente einfügen

Aktivitätssegmentdaten in Google Fit geben an, welche Fitnessaktivitäten Nutzer in einem bestimmten Zeitintervall durchführen. Aktivitätssegmentdaten haben den Typ com.google.activity.segment (TYPE_ACTIVITY_SEGMENT) und sind besonders nützlich, um Pausen während des Trainings zu unterstützen.

Wenn Sie beispielsweise eine 30-minütige Laufsitzung mit der Methode Session.Builder.setActivity() erstellen, der Nutzer jedoch eine Pause von 10 Minuten dazwischen hat, zeigt Ihre App fälschlicherweise an, dass der Nutzer 30 Minuten gelaufen ist. Vorausgesetzt, deine App kann erkennen, ob der Nutzer gegangen oder gelaufen ist, kannst du anhand der Daten zu Aktivitätssegmenten in deiner App angeben, dass der Nutzer 10 Minuten gelaufen, 10 Minuten läuft und dann weitere 10 Minuten. Andere Apps können die Aktivität auch korrekt erfassen, indem sie sich die von Ihnen eingefügten Aktivitätssegmentdaten ansehen.

Wenn Sie einer Sitzung Daten aus Aktivitätssegmenten hinzufügen möchten, erstellen Sie ein Dataset, das Punkte vom Typ com.google.activity.segment enthält. Jeder dieser Punkte steht für ein fortlaufendes Zeitintervall, in dem der Nutzer einen einzelnen Aktivitätstyp ausgeführt hat.

Das vorherige Lauf- und Walking-Beispiel erfordert drei Aktivitätssegmentpunkte: einen für Lauf in den ersten 10 Minuten, einen für Laufen in den nächsten 10 Minuten und einen für Laufen in den letzten 10 Minuten.

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();

Fitnessdaten mithilfe von Sitzungen lesen

Mit der Sessions API können Sie eine Liste von Sitzungen aus dem Fitnessspeicher abrufen, die bestimmte Kriterien erfüllen. Sie haben beispielsweise die Möglichkeit, alle in einem Zeitintervall enthaltenen Sitzungen oder eine bestimmte Sitzung anhand ihres Namens oder ihrer ID abzurufen. Sie können auch angeben, ob Sie an Sitzungen interessiert sind, die von Ihrer App oder einer anderen App erstellt wurden.

Hinweis: Wenn Sie Sitzungen lesen, die von anderen Apps erstellt wurden, sollten Sie Nutzern anzeigen, von welchen Apps die Sitzungen beigetragen haben. So können Nutzer sehen, woher diese Daten stammen. Sie können den Namen und das Symbol der beitragenden Anwendung sowie einen Intent zum Starten der Anwendung abrufen, wie unter Datenattribution beschrieben.

Wenn Sie eine Liste der Sitzungen abrufen möchten, die einige Kriterien erfüllen, erstellen Sie zuerst eine SessionReadRequest-Instanz:

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();

Verwenden Sie dann die Methode 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));

Schlafdaten mithilfe von Sitzungen lesen

Schlafsitzungen werden von anderen Aktivitätssitzungen getrennt behandelt. Standardmäßig enthalten Leseantworten nur Aktivitätssitzungen, keine Schlafsitzungen.

Wenn Sie Schlafsitzungen einbeziehen möchten, verwenden Sie beim Erstellen von SessionReadRequest die Methode includeSleepSessions. Wenn Sie sowohl Aktivitäten als auch Sitzungen einbeziehen möchten, verwenden Sie includeSleepSessions und includeActivitySessions.

Sitzungen in anderen Apps anzeigen

Ihre Nutzer können einen Intent mit Sitzungsinformationen aufrufen, um Nutzern eine detailliertere Ansicht einer bestimmten Sitzung in einer anderen App anzuzeigen. Sie können eine bestimmte Anwendung angeben, z. B. die Anwendung, die die Sitzung erstellt hat. Für den Fall, dass die App, die die Sitzung erstellt hat, nicht auf dem Gerät installiert ist, können Sie jeder App, die Fitnessaktivitäten anzeigen kann, die Beantwortung des Intents erlauben.

Verwenden Sie die Klasse SessionsApi.ViewIntentBuilder, um einen Intent für die Anzeige von Sitzungsdaten in einer anderen Anwendung zu erstellen:

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);

Intents von anderen Apps empfangen

Damit Ihre App Intents von anderen Gesundheits- und Wellness-Apps erhalten soll, müssen Sie in Ihrem Manifest einen Intent-Filter angeben, der in etwa so aussieht:

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

Hinweis: Fügen Sie die Kategorie DEFAULT nicht in den Intent-Filter ein, es sei denn, Sie möchten, dass Ihre App Intents für Sitzungen empfängt, die von anderen Apps erstellt wurden.

Jeder Intent, den Ihre App von Google Fit empfängt, hat nur eine Aktivität. Sie können aber in einem einzigen Intent-Filter nach mehreren MIME-Typen filtern. Der Intent-Filter deiner App muss alle von deiner App unterstützten Aktivitäten enthalten.

Die Fitness-Intents umfassen die folgenden Extras:

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

Sie können Daten aus diesen Extras wie folgt abrufen:

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());
    }
}