Mit Sitzungen arbeiten

Sitzungen stellen ein Zeitintervall dar, in dem Nutzer um eine Fitnessaktivität durchzuführen. Mit der Sessions API kann Ihre App Sitzungen in aus dem Fitness-Shop.

Bei laufenden Fitnessaktivitäten, bei denen der Nutzer deine App benachrichtigt, wenn er beginnt und eine Fitnessaktivität beenden, kannst du Sitzungen in Echtzeit erstellen.

Du kannst auch nach einer Fitnessaktivität eine Sitzung in den Fitness-Store einfügen. abgeschlossen ist oder wenn Sie Daten und Sitzungen außerhalb von Google Fit importieren.

Hinweis :Best Practices für die Verwaltung von Nutzerdaten finden Sie unter 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. Fitnessdaten abonnieren mit der RecordingClient.subscribe .

2. Starten Sie eine Sitzung mithilfe der SessionsClient.startSession wenn der Nutzer die Fitnessaktivität startet.

3. Beenden Sie die Sitzung mithilfe der SessionsClient.stopSession wenn der Nutzer die Fitnessaktivität beendet.

4. Fitnessdaten abbestellen die Sie nicht mehr nutzen möchten, 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: Der Zeitpunkt, zu dem die App SessionsClient.startSession aufgerufen hat .

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

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

Sitzungen 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.

2. Erstellen: SessionInsertRequest mit der Sitzung.

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

4. Fügen Sie die Sitzung mithilfe der SessionsClient.insertSession .

Sitzung einfügen

Um Fitnessdaten, die Sitzungsmetadaten enthalten, in die Fitness 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 Fitnessverlauf speichern und eine Sitzung im selben Aufruf an SessionsClient.insertSession. Die Datasets, falls vorhanden, werden so eingefügt, hatte den Namen HistoryClient.insertData und dann 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

Daten zu Aktivitätssegmenten in Google Fit geben an, welche Fitnessaktivitäten die Leistung der Nutzer in einem bestimmten Zeitintervall. Aktivitätssegmentdaten sind vom Typ com.google.activity.segment (TYPE_ACTIVITY_SEGMENT) und ist besonders nützlich, um Pausen während des Trainings zu unterstützen.

Wenn du zum Beispiel eine 30-minütige Laufsitzung mit der Session.Builder.setActivity() aber der Nutzer dazwischen 10 Minuten Pause macht, wird Ihre App dass der Nutzer 30 Minuten lang gelaufen ist. Voraussetzung ist, dass Ihre App erkennen, ob der Nutzer gegangen oder gelaufen ist, können anhand der Aktivitätssegmentdaten App angezeigt, dass der Nutzer 10 Minuten gelaufen, 10 Minuten gegangen und dann gelaufen ist. für weitere 10 Minuten. Andere Apps können die Aktivität ebenfalls 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 Kontinuierliches Zeitintervall, in dem der Nutzer einen einzelnen Aktivitätstyp ausgeführt hat.

Das vorherige Beispiel für Laufen und Gehen würde drei Aktivitätssegmente benötigen. Punkte: einer für das Laufen in den ersten 10 Minuten, einer für das Gehen in den nächsten 10 Minuten und eine für die 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 anhand von Sitzungen lesen

Mit der Sessions API können Sie eine Liste der Sitzungen aus dem Fitness-Store abrufen, die Kriterien entsprechen. Sie können beispielsweise alle Sitzungen abrufen, die in einem Zeitintervall bestimmen oder eine bestimmte Sitzung anhand des Namens oder der ID abrufen. Sie können auch angeben, egal, ob Sie an Sitzungen interessiert sind, die von Ihrer App oder einer beliebigen App erstellt wurden.

Hinweis :Wenn Sie Sitzungen lesen, die von anderen Apps erstellt wurden, sollten Sie Nutzer, aus welchen Apps die Sitzungen stammen, damit die Nutzer wissen, woher diese Daten stammen aus. Sie können den Namen und das Symbol der beitragenden App zusammen mit der Absicht abrufen, die App wie in den Datenattribution:

Um eine Liste der Sitzungen zu erhalten, die bestimmten Kriterien entsprechen, 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 das 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 unterscheiden sich von anderen Aktivitätseinheiten. Standardmäßig Leseantworten enthalten nur Aktivitätssitzungen, keine Schlafeinheiten.

Wenn du Schlafeinheiten mit aufnehmen möchtest, verwende die includeSleepSessions , wenn Sie Ihre SessionReadRequest erstellen. Um sowohl Aktivitäten als auch Sitzungen werden sowohl includeSleepSessions als auch includeActivitySessions

Sitzungen in anderen Apps anzeigen

Wenn Sie Nutzern eine detailliertere Ansicht einer bestimmten Sitzung in einer anderen App zeigen möchten, kann Ihre Anwendung einen Intent aufrufen, der die Sitzungsinformationen enthält. Sie können eine bestimmte App angeben, z. B. die App, die die Sitzung erstellt hat. Oder falls der die die Sitzung erstellt hat, nicht auf dem Gerät installiert ist, können Sie die Fitnessaktivitäten anzeigen kann, um auf die Absicht zu reagieren.

Um einen Intent zum Anzeigen von Sitzungsdaten in einer anderen App zu erstellen, verwenden Sie den SessionsApi.ViewIntentBuilder Klasse:

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

So registrierst du deine App für den Empfang von Intents von anderen Gesundheits- und Wellness-Apps: 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: Nehmen Sie die Kategorie DEFAULT nur dann in den Intent-Filter auf, wenn Sie Ihre App soll Intents für Sitzungen empfangen, die von anderen Apps erstellt wurden.

Jedes Intent, das deine App von Google Fit erhält, ist nur eine Aktivität, aber Sie können in einem einzigen Intent-Filter nach mehreren MIME-Typen filtern. Der Intent-Filter Ihrer App muss alle Aktivitäten enthalten, die Ihre App unterstützt.

Die Fitness-Intents umfassen die folgenden Extras:

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

So können Sie Daten aus diesen Extras 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());
    }
}