Praca z sesjami

Sesje to przedział czasu, w którym użytkownicy wykonywać ćwiczenia. Interfejs Sessions API umożliwia aplikacji tworzenie sesji w sklepie fitness.

W przypadku trwających ćwiczeń fitness, w przypadku których użytkownik powiadamia aplikację o rozpoczęciu i dokończyć aktywność fizyczną, możesz tworzyć sesje w czasie rzeczywistym.

Sesję możesz też wstawić do sklepu fitness po zakończeniu aktywności lub gdy zaimportujesz dane i sesje spoza Google Fit.

Tworzenie sesji w czasie rzeczywistym

Aby utworzyć sesje dla trwających ćwiczeń fitness, wykonaj te czynności:

  1. Subskrybowanie danych o aktywności fizycznej za pomocą RecordingClient.subscribe .

  2. Rozpocznij sesję, korzystając z SessionsClient.startSession. gdy użytkownik inicjuje aktywność fizyczną.

  3. Zatrzymaj sesję przy użyciu SessionsClient.stopSession. Gdy użytkownik zakończy aktywność fizyczną.

  4. Anulowanie subskrypcji danych o aktywności fizycznej w przypadku których nie chcesz już korzystać RecordingClient.unsubscribe. .

Rozpocznij sesję

Aby rozpocząć sesję w aplikacji, użyj metody 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));

Kończenie sesji

Aby zatrzymać sesję w aplikacji, użyj metody 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));

Powstała sesja ma następujące parametry:

  • Godzina rozpoczęcia: godzina wywołania aplikacji SessionsClient.startSession przez aplikację. .

  • Godzina zakończenia: godzina wywołania aplikacji SessionsClient.stopSession przez aplikację. .

  • Nazwa: nazwa w obiekcie Session, do którego przekazujesz plik SessionsClient.startSession

Wstaw sesje w sklepie fitness

Aby wstawić sesje z wcześniej zebranymi danymi:

  1. Utwórz obiekt Session, który określa przedział czasu i inne wymagane elementy i informacjami o nich.

  2. Utwórz SessionInsertRequest wraz z sesją.

  3. Opcjonalnie możesz dodać zbiory danych i punkty danych zbiorczych.

  4. Wstaw sesję za pomocą SessionsClient.insertSession .

Wstaw sesję

Aby wstawić dane o aktywności fizycznej zawierające metadane sesji do informacji o aktywności użytkownika w historii, najpierw utwórz instancję 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();

Klasa SessionInsertRequest udostępnia wygodne metody wstawiania danych do historii fitnessu i utworzyć sesję w ramach tego samego połączenia, SessionsClient.insertSession Zbiory danych (jeśli istnieją) są wstawiane tak, jakby nazwał HistoryClient.insertData a dopiero potem sesja jest tworzona.

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

Wstaw segmenty aktywności

Dane o segmentach aktywności w Google Fit wskazują, jaka aktywność fizyczna na jaką aktywność użytkowników w danym przedziale czasu. Dane segmentu aktywności to typu com.google.activity.segment (TYPE_ACTIVITY_SEGMENT) i szczególnie przydaje się podczas pauz podczas treningów.

Na przykład, jeśli utworzysz 30-minutową sesję biegową z Session.Builder.setActivity() ale użytkownik ma 10-minutową przerwę, nieprawidłowo wskazują, że użytkownik pracował przez 30 minut. Jeśli aplikacja może określić, czy użytkownik chodził czy biegał. Dane segmentu aktywności pozwalają wskazuje, że użytkownik biegał przez 10 minut, chodził przez 10 minut, a następnie biegł przez dodatkowe 10 minut. Inne aplikacje też mogą prawidłowo zgłaszać aktywność. analizując wpisane dane segmentu aktywności.

Aby dodać do sesji dane o segmentach aktywności, utwórz zbiór danych zawierający punkty typu com.google.activity.segment. Każdy z tych punktów oznacza ciągły przedział czasu, w którym użytkownik wykonał 1 typ aktywności.

Poprzedni przykład biegu i chodzenia wymagałby 3 segmentów aktywności punkty: jeden za bieg w ciągu pierwszych 10 minut, drugi za marsz w ciągu następnych 10 minut. i drugą na bieg w ciągu ostatnich 10 minut.

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

Odczytuj dane o aktywności fizycznej za pomocą sesji

Interfejs Sessions API pozwala uzyskać listę sesji ze sklepu fitness, na których spełniają określone kryteria. Możesz na przykład uzyskać wszystkie sesje zawarte w sekcji w przedziale czasu albo pobrać konkretną sesję na podstawie nazwy lub identyfikatora. Możesz też określić niezależnie od tego, czy interesują Cię sesje utworzone przez Twoją aplikację, czy przez inną aplikację.

Aby uzyskać listę sesji spełniających określone kryteria, najpierw utwórz Instancja 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();

Następnie użyj 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));

Odczytuj dane dotyczące snu na podstawie sesji

Sesje snu są traktowane jako odrębne od innych sesji aktywności. Domyślnie odpowiedzi odczytu zawierają tylko sesje aktywności, nie sesje snu.

Aby uwzględnić sesje snu, użyj funkcji includeSleepSessions podczas tworzenia SessionReadRequest. Aby uwzględnić zarówno aktywności, jak i sesji, użyj zarówno wartości includeSleepSessions, jak i includeActivitySessions

Pokaż sesje w innych aplikacjach

Aby wyświetlić użytkownikom bardziej szczegółowy widok konkretnej sesji w innej aplikacji, aplikacja może wywołać intencję zawierającą informacje o sesji; Dostępne opcje wskazać konkretną aplikację, na przykład aplikację, która ją utworzyła. Lub, w przypadku, gdy aplikacji, w której została utworzona sesja, nie jest zainstalowana na urządzeniu, możesz zezwolić na dowolną które mogą wyświetlać aktywność fizyczną i odpowiedzieć na intencję.

Aby utworzyć intencję wyświetlania danych sesji w innej aplikacji, użyj funkcji SessionsApi.ViewIntentBuilder zajęcia:

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

Otrzymywanie intencji z innych aplikacji

Aby zarejestrować aplikację, aby otrzymywać intencje z innych aplikacji związanych ze zdrowiem i samopoczuciem: zadeklaruj w pliku manifestu filtr intencji podobny do tego:

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

Każda intencja, którą aplikacja otrzymuje z Google Fit oznacza tylko jedną aktywności, ale w jednym filtrze intencji możesz wyświetlić wiele typów MIME. Filtr intencji aplikacji musi obejmować wszystkie działania, które aplikacja obsługuje.

Cele związane z fitnessem obejmują te dodatki:

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

Dane z tych dodatków można uzyskać w ten sposób:

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