Mengerjakan sesi

Sesi menunjukkan interval waktu saat pengguna melakukan aktivitas kebugaran. Sessions API memungkinkan aplikasi Anda membuat sesi di penyimpanan kebugaran.

Untuk aktivitas kebugaran yang sedang berlangsung, yaitu ketika pengguna memberi tahu aplikasi Anda saat mereka memulai dan menyelesaikan aktivitas kebugaran, Anda dapat membuat sesi secara real time.

Anda juga dapat menyisipkan sesi ke penyimpanan kebugaran setelah aktivitas kebugaran selesai atau saat mengimpor data dan sesi dari luar Google Fit.

Membuat sesi secara real time

Untuk membuat sesi bagi aktivitas kebugaran yang sedang berlangsung, selesaikan langkah-langkah berikut:

1. Berlangganan data kebugaran menggunakan metode RecordingClient.subscribe.

2. Mulai sesi menggunakan metode SessionsClient.startSession saat pengguna memulai aktivitas kebugaran.

3. Hentikan sesi menggunakan metode SessionsClient.stopSession saat pengguna mengakhiri aktivitas kebugaran.

4. Berhenti berlangganan dari data kebugaran yang sudah tidak Anda minati menggunakan metode RecordingClient.unsubscribe.

Mulai sesi

Untuk memulai sesi di aplikasi Anda, gunakan metode 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));

Menghentikan sesi

Untuk menghentikan sesi di aplikasi Anda, gunakan metode 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));

Sesi yang dihasilkan memiliki parameter berikut:

• Waktu mulai: Waktu saat aplikasi Anda memanggil metode SessionsClient.startSession.

• Waktu berakhir: Waktu saat aplikasi memanggil metode SessionsClient.stopSession.

• Name: Nama di objek Session yang Anda teruskan ke SessionsClient.startSession.

Menyisipkan sesi di penyimpanan kebugaran

Untuk menyisipkan sesi dengan data yang sebelumnya Anda kumpulkan, lakukan hal berikut:

1. Buat objek Session yang menentukan interval waktu dan informasi lainnya yang diperlukan.

2. Buat SessionInsertRequest dengan sesi tersebut.

3. Secara opsional, tambahkan set data dan menggabungkan titik data.

4. Sisipkan sesi menggunakan metode SessionsClient.insertSession.

Sisipkan sesi

Untuk memasukkan data kebugaran yang berisi metadata sesi ke dalam histori kebugaran pengguna, buat instance SessionInsertRequest terlebih dahulu:

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

Class SessionInsertRequest menyediakan metode praktis untuk menyisipkan data ke dalam histori kebugaran dan membuat sesi dalam panggilan yang sama ke SessionsClient.insertSession. Set data, jika ada, disisipkan seolah-olah Anda telah memanggil metode HistoryClient.insertData terlebih dahulu, lalu sesi dibuat.

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

Sisipkan segmen aktivitas

Data segmen aktivitas di Google Fit menunjukkan aktivitas kebugaran yang dilakukan pengguna selama interval waktu tertentu. Data segmen aktivitas adalah jenis com.google.activity.segment (TYPE_ACTIVITY_SEGMENT) dan sangat berguna untuk mendukung jeda selama olahraga.

Misalnya, jika Anda membuat sesi lari 30 menit dengan metode Session.Builder.setActivity(), tetapi pengguna mengambil jeda 10 menit di antaranya, aplikasi Anda akan salah menunjukkan bahwa pengguna berjalan selama 30 menit. Asalkan aplikasi Anda dapat mendeteksi apakah pengguna sedang berjalan atau berlari, data segmen aktivitas memungkinkan aplikasi Anda menunjukkan bahwa pengguna berlari selama 10 menit, berjalan selama 10 menit, lalu berlari selama 10 menit lagi. Aplikasi lain juga dapat melaporkan aktivitas dengan benar dengan melihat data segmen aktivitas yang Anda sisipkan.

Untuk menambahkan data segmen aktivitas ke sesi, buat set data yang berisi titik jenis com.google.activity.segment. Masing-masing titik ini mewakili interval waktu berkelanjutan saat pengguna melakukan satu jenis aktivitas.

Contoh berlari dan berjalan sebelumnya akan memerlukan tiga titik segmen aktivitas: satu untuk berlari selama 10 menit pertama, satu untuk berjalan selama 10 menit berikutnya, dan satu untuk berlari selama 10 menit terakhir.

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

Membaca data kebugaran menggunakan sesi

Sessions API memungkinkan Anda mendapatkan daftar sesi dari penyimpanan kebugaran yang cocok dengan beberapa kriteria. Misalnya, Anda bisa mendapatkan semua sesi yang terdapat dalam interval waktu, atau mendapatkan sesi tertentu berdasarkan nama atau ID. Anda juga dapat menentukan apakah tertarik dengan sesi yang dibuat oleh aplikasi Anda atau aplikasi apa pun.

Untuk mendapatkan daftar sesi yang cocok dengan beberapa kriteria, buat instance SessionReadRequest terlebih dahulu:

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

Lalu gunakan metode 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));

Membaca data tidur menggunakan sesi

Sesi tidur diperlakukan berbeda dari sesi aktivitas lainnya. Secara default, respons baca hanya berisi sesi aktivitas, bukan sesi tidur.

Untuk menyertakan sesi tidur, gunakan metode includeSleepSessions saat Anda membuat SessionReadRequest. Untuk menyertakan aktivitas dan sesi, gunakan includeSleepSessions dan includeActivitySessions.

Tampilkan sesi di aplikasi lain

Untuk menampilkan tampilan sesi tertentu yang lebih mendetail di aplikasi lain kepada pengguna, aplikasi Anda dapat memanggil intent yang berisi informasi sesi. Anda dapat menentukan aplikasi tertentu, seperti aplikasi yang membuat sesi. Atau, jika aplikasi yang membuat sesi tidak diinstal di perangkat, Anda dapat mengizinkan aplikasi apa pun yang dapat menampilkan aktivitas kebugaran untuk merespons intent.

Untuk membuat intent guna menampilkan data sesi pada aplikasi lain, gunakan class SessionsApi.ViewIntentBuilder:

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

Menerima intent dari aplikasi lain

Untuk mendaftarkan aplikasi Anda agar menerima intent dari aplikasi kesehatan dan kebugaran lainnya, deklarasikan filter intent dalam manifes yang mirip dengan yang berikut ini:

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

Setiap intent yang diterima aplikasi Anda dari Google Fit hanya terdiri dari satu aktivitas, namun Anda dapat memfilter beberapa jenis MIME dalam satu filter intent. Filter intent aplikasi Anda harus menyertakan semua aktivitas yang didukung aplikasi.

Intent kebugaran menyertakan tambahan berikut:

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

Anda bisa mendapatkan data dari tambahan ini sebagai berikut:

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