Mit Sitzungen arbeiten

Sitzungen stellen ein Zeitintervall dar, in dem Nutzer eine Fitnessaktivität durchführen. Mit der Sessions API kann deine App Sitzungen im Fitness-Store erstellen.

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

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

Hinweis :Best Practices beim Verwalten von Nutzerdaten finden Sie in der Google Fit-Richtlinie zu Entwickler- und Nutzerdaten.

Sitzungen in Echtzeit erstellen

Führe die folgenden Schritte aus, um Sitzungen für laufende Fitnessaktivitäten zu erstellen:

1. Abonnieren Sie Fitnessdaten mit der Methode RecordingClient.subscribe.

2. Starten Sie 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. Deaktivieren Sie die Fitnessdaten, die Sie nicht mehr benötigen, mit der Methode RecordingClient.unsubscribe.

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

Verwenden Sie die Methode SessionsClient.stopSession, um eine Sitzung in Ihrer App zu beenden:

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 Anwendung die Methode SessionsClient.startSession aufgerufen hat.

• Endzeit: Die Zeit, zu der Ihre App die Methode SessionsClient.stopSession aufgerufen hat.

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

Trainingseinheiten im Fitness-Store 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 eine SessionInsertRequest mit der Sitzung.

3. Optional können Sie Datasets hinzufügen und Datenpunkte aggregieren.

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

Sitzung einfügen

Um Fitnessdaten mit Sitzungsmetadaten in den Fitnessverlauf des Nutzers einzufügen, 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 zum Einfügen von Daten in den Fitnessverlauf und zum Erstellen einer Sitzung im selben Aufruf an SessionsClient.insertSession. Die Datasets, falls vorhanden, werden so eingefügt, als hätten Sie zuerst die Methode HistoryClient.insertData aufgerufen. Anschließend wird 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 ausführen. Die Daten zu Aktivitätssegmenten 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 Sitzung mit der Methode Session.Builder.setActivity() erstellen, der Nutzer aber eine zehnminütige Pause dazwischen macht, zeigt Ihre Anwendung fälschlicherweise an, dass er 30 Minuten gelaufen ist. Solange Ihre App erkennen kann, ob der Nutzer geht oder gelaufen ist, können Aktivitätssegmentdaten Ihre App anzeigen, dass der Nutzer 10 Minuten, 10 Minuten und dann weitere 10 Minuten gelaufen ist. Auch andere Apps können die Aktivität korrekt melden, indem sie sich die von Ihnen eingefügten Aktivitätssegmentdaten ansehen.

Wenn Sie einer Sitzung Aktivitätssegmentdaten hinzufügen möchten, erstellen Sie ein Dataset mit Punkten vom Typ com.google.activity.segment. Jeder dieser Punkte steht für ein kontinuierliches Zeitintervall, in dem der Nutzer einen einzelnen Aktivitätstyp ausgeführt hat.

Das vorherige Lauf- und Gehbeispiel würden drei Aktivitätssegmentpunkte erfordern: einen für das Laufen während der ersten 10 Minuten, einen für das Gehen in den nächsten 10 Minuten und einen für das Laufen während der 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 der Sitzungen aus dem Fitnessspeicher abrufen, die bestimmten Kriterien entsprechen. Sie können beispielsweise alle in einem Zeitintervall enthaltenen Sitzungen oder eine bestimmte Sitzung anhand des Namens oder der ID abrufen. Sie können auch angeben, ob Sie an Sitzungen interessiert sind, die von Ihrer Anwendung oder einer beliebigen Anwendung erstellt wurden.

Hinweis: Wenn Sie Sitzungen lesen, die von anderen Anwendungen erstellt wurden, sollten Sie Nutzern zeigen, von welchen Anwendungen die Sitzungen stammen, damit sie wissen, woher diese Daten stammen. Sie können den Namen und das Symbol der beitragenden App sowie einen Intent für die Einführung der App abrufen, wie unter Datenattribution beschrieben.

Um eine Liste der Sitzungen zu erhalten, die bestimmten Kriterien entsprechen, müssen Sie zuerst eine SessionReadRequest-Instanz erstellen:

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 anhand von Sitzungen lesen

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

Wenn du Schlafsitzungen einschließen möchtest, verwende beim Erstellen des SessionReadRequest die Methode includeSleepSessions. Wenn du sowohl Aktivitäten als auch Sitzungen erfassen möchtest, verwende sowohl includeSleepSessions als auch includeActivitySessions.

Sitzungen in anderen Apps anzeigen

Damit Nutzern eine detailliertere Ansicht einer bestimmten Sitzung in einer anderen App angezeigt wird, kann Ihre App einen Intent aufrufen, der die Sitzungsinformationen enthält. Sie können eine bestimmte Anwendung angeben, z. B. die Anwendung, mit der die Sitzung erstellt wurde. Wenn die App, mit der die Sitzung erstellt wurde, nicht auf dem Gerät installiert ist, können Sie auch zulassen, dass jede App, die Fitnessaktivitäten zeigen kann, auf den Intent reagiert.

Verwenden Sie die Klasse SessionsApi.ViewIntentBuilder, um einen Intent zum Anzeigen von Sitzungsdaten in einer anderen App 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

Wenn Sie Ihre App für den Empfang von Intents von anderen Gesundheits- und Wellness-Apps registrieren möchten, deklarieren Sie in Ihrem Manifest einen Intent-Filter, 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 Ihren Intent-Filter ein, es sei denn, Ihre App soll Intents für Sitzungen empfangen, die von anderen Apps erstellt wurden.

Für jeden Intent, den deine App von Google Fit erhält, handelt es sich um nur eine Aktivität. Du kannst jedoch in einem einzelnen Intent-Filter nach mehreren MIME-Typen filtern. Der Intent-Filter Ihrer App muss alle Aktivitäten enthalten, die von der App unterstützt werden.

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 von diesen Extras wie folgt erhalten:

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