Lavorare con le sessioni

Le sessioni rappresentano un intervallo di tempo durante il quale gli utenti svolgono un'attività fisica. L'API Sessions consente alla tua app di creare sessioni nel store per il fitness.

Per le attività di fitness in corso in cui l'utente invia una notifica all'app quando inizia e terminare un'attività fisica, puoi creare sessioni in tempo reale.

Puoi anche inserire una sessione nel negozio di fitness al termine di un'attività fisica o quando importi dati e sessioni dall'esterno di Google Fit.

Crea sessioni in tempo reale

Per creare sessioni per le attività di fitness in corso, completa i seguenti passaggi:

1. Abbonati ai dati relativi all'attività fisica utilizzando il metodo RecordingClient.subscribe.

2. Avvia una sessione utilizzando SessionsClient.startSession quando l'utente avvia l'attività fisica.

3. Interrompi la sessione utilizzando il comando SessionsClient.stopSession quando l'utente termina l'attività fisica.

4. Annullare l'iscrizione ai dati relativi all'attività fisica che non ti interessa più usare RecordingClient.unsubscribe .

Avvia una sessione

Per avviare una sessione nella tua app, usa il metodo SessionsClient.startSession:

// 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)
    }

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

Interrompere una sessione

Per interrompere una sessione nella tua app, utilizza il metodo SessionsClient.stopSession:

// 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)
    }

// 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 sessione risultante ha i seguenti parametri:

• Ora di inizio: l'ora in cui la tua app ha chiamato SessionsClient.startSession .

• Ora di fine: l'ora in cui la tua app ha chiamato SessionsClient.stopSession .

• Nome: il nome nell'oggetto Session che viene passato a SessionsClient.startSession.

Inserire le sessioni nello Store per il fitness

Per inserire sessioni con i dati raccolti in precedenza:

1. Crea un oggetto Session che specifichi un intervallo di tempo e altri valori obbligatori informazioni.

2. Crea un SessionInsertRequest durante la sessione.

3. Facoltativamente, aggiungi set di dati e aggrega punti dati.

4. Inserisci la sessione utilizzando il metodo SessionsClient.insertSession.

Inserisci una sessione

Per inserire i dati relativi all'attività fisica che contengono i metadati della sessione nella cronologia dell'attività fisica dell'utente, crea prima un'istanza SessionInsertRequest:

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

// 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 offre metodi pratici per inserire i dati nella cronologia di fitness e creare una sessione nella stessa chiamata SessionsClient.insertSession. Gli eventuali set di dati vengono inseriti come aveva chiamato HistoryClient.insertData e poi la sessione.

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

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

Inserisci segmenti di attività

I dati dei segmenti di attività in Google Fit indicano quale attività fisica le prestazioni degli utenti in un determinato intervallo di tempo. I dati dei segmenti di attività sono di tipo com.google.activity.segment (TYPE_ACTIVITY_SEGMENT) ed è particolarmente utile per supportare le pause durante l'allenamento.

Ad esempio, se crei una sessione di corsa di 30 minuti con il metodo Session.Builder.setActivity() ma l'utente fa una pausa di 10 minuti, la tua app mostrerà erroneamente che l'utente ha corso per 30 minuti. A condizione che la tua app possa rilevare se l'utente stava camminando o correndo, i dati del segmento di attività consentono alla tua app di indicare che l'utente ha corso per 10 minuti, camminato per 10 minuti e poi corso per altri 10 minuti. Anche altre app possono registrare correttamente l'attività esaminando i dati del segmento di attività che inserisci.

Per aggiungere dati del segmento di attività a una sessione, crea un set di dati che contenga punti di tipo com.google.activity.segment. Ciascuno di questi punti rappresenta intervallo di tempo continuo durante il quale l'utente ha eseguito un singolo tipo di attività.

L'esempio precedente di corsa e camminata richiedeva tre segmenti di attività punti: uno per la corsa nei primi 10 minuti, uno per la camminata nei prossimi 10 minuti e uno per la corsa nei 10 minuti finali.

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

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

Leggere i dati relativi all'attività fisica utilizzando le sessioni

L'API Sessions ti consente di ottenere un elenco di sessioni dal negozio di fitness che che soddisfano alcuni criteri. Ad esempio, puoi ottenere tutte le sessioni contenute in un di un intervallo di tempo o ottenere una determinata sessione per nome o ID. Puoi anche specificare se ti interessano le sessioni create dalla tua app o da qualsiasi app.

Per ottenere un elenco di sessioni che soddisfano alcuni criteri, crea prima un'istanzaSessionReadRequest:

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

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

Quindi utilizza SessionsClient.readSession :

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

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

Leggere i dati relativi al sonno utilizzando le sessioni

Le sessioni di sonno vengono trattate come distinte dalle altre sessioni di attività. Per impostazione predefinita, le risposte alle letture contengono solo sessioni di attività, non sessioni di sonno.

Per includere le sessioni di sonno, utilizza includeSleepSessions quando crei il tuo SessionReadRequest. Per includere sia attività che sessioni, usa sia includeSleepSessions sia includeActivitySessions

Mostra le sessioni in altre app

Per mostrare agli utenti una visualizzazione più dettagliata di una sessione in un'altra app: la tua app può richiamare un intent contenente le informazioni sulla sessione. Puoi specificare una determinata app, ad esempio quella che ha creato la sessione. Oppure, nel caso in cui che ha creato la sessione non è installata sul dispositivo, puoi consentire app che può mostrare attività fisica per rispondere all'intento.

Per creare un intent per mostrare i dati delle sessioni su un'altra app, utilizza la proprietà SessionsApi.ViewIntentBuilder classe:

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

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

Ricevi intent da altre app

Per registrare la tua app in modo che riceva intent da altre app per la salute e il benessere, dichiara un filtro intent nel file manifest simile al seguente:

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

Ogni intent che la tua app riceve da Google Fit riguarda una sola attività, ma puoi filtrare per più tipi MIME in un unico filtro intent. Il filtro per intent dell'app deve includere tutte le attività che l'app Google Cloud.

Le intenzioni per il fitness includono i seguenti extra:

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

Puoi ottenere i dati da queste funzionalità aggiuntive nel seguente modo:

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

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