แผนการฝึก

คู่มือนี้ใช้ได้กับ Health Connect เวอร์ชัน 1.1.0-alpha12 ขึ้นไป

Health Connect มีประเภทข้อมูลการออกกำลังกายที่วางแผนไว้เพื่อช่วยให้แอปการฝึกสามารถเขียนแผนการฝึกและช่วยให้แอปการออกกำลังกายอ่านแผนการฝึกได้ การออกกำลังกายที่บันทึกไว้สามารถอ่านย้อนหลังเพื่อวิเคราะห์ประสิทธิภาพที่ปรับเปลี่ยนในแบบของคุณเพื่อช่วยให้ผู้ใช้บรรลุเป้าหมายการฝึกได้

ตรวจสอบความพร้อมใช้งานของ Health Connect

ก่อนพยายามใช้ Health Connect แอปของคุณควรยืนยันว่า Health Connect พร้อมใช้งานในอุปกรณ์ของผู้ใช้ Health Connect อาจไม่ได้ติดตั้งไว้ล่วงหน้าในอุปกรณ์บางเครื่องหรืออาจปิดใช้อยู่ คุณตรวจสอบความพร้อมให้บริการได้โดยใช้เมธอด HealthConnectClient.getSdkStatus()

วิธีตรวจสอบความพร้อมใช้งานของ Health Connect

fun checkHealthConnectAvailability(context: Context) {
    val providerPackageName = "com.google.android.apps.healthdata"
    val availabilityStatus = HealthConnectClient.getSdkStatus(context, providerPackageName)

    if (availabilityStatus == HealthConnectClient.SDK_UNAVAILABLE) {
      // Health Connect is not available. Guide the user to install/enable it.
      // For example, show a dialog.
      return // early return as there is no viable integration
    }
    if (availabilityStatus == HealthConnectClient.SDK_UNAVAILABLE_PROVIDER_UPDATE_REQUIRED) {
      // Health Connect is available but requires an update.
      // Optionally redirect to package installer to find a provider, for example:
      val uriString = "market://details?id=$providerPackageName&url=healthconnect%3A%2F%2Fonboarding"
      context.startActivity(
        Intent(Intent.ACTION_VIEW).apply {
          setPackage("com.android.vending")
          data = Uri.parse(uriString)
          putExtra("overlay", true)
          putExtra("callerId", context.packageName)
        }
      )
      return
    }
    // Health Connect is available, obtain a HealthConnectClient instance
    val healthConnectClient = HealthConnectClient.getOrCreate(context)
    // Issue operations with healthConnectClient
}

คุณสามารถแนะนำให้ผู้ใช้ติดตั้งหรืออัปเดต Health Connect จาก Google Play Store ได้หากจำเป็น ทั้งนี้ขึ้นอยู่กับสถานะที่ getSdkStatus() แสดงผล

ความพร้อมใช้งานของฟีเจอร์

หากต้องการตรวจสอบว่าอุปกรณ์ของผู้ใช้รองรับแผนการฝึกใน Health Connect หรือไม่ ให้ตรวจสอบความพร้อมใช้งานของ FEATURE_PLANNED_EXERCISE ในไคลเอ็นต์ โดยทำดังนี้

if (healthConnectClient
     .features
     .getFeatureStatus(
       HealthConnectFeatures.FEATURE_PLANNED_EXERCISE
     ) == HealthConnectFeatures.FEATURE_STATUS_AVAILABLE) {

  // Feature is available
} else {
  // Feature isn't available
}
ดูข้อมูลเพิ่มเติมได้ที่ตรวจสอบความพร้อมใช้งานของฟีเจอร์

สิทธิ์ที่จำเป็น

การเข้าถึงการออกกำลังกายที่วางแผนไว้ได้รับการปกป้องโดยสิทธิ์ต่อไปนี้

  • android.permission.health.READ_PLANNED_EXERCISE
  • android.permission.health.WRITE_PLANNED_EXERCISE

หากต้องการเพิ่มความสามารถในการออกกำลังกายที่วางแผนไว้ลงในแอป ให้เริ่มด้วยการขอสิทธิ์สำหรับประเภทข้อมูล PlannedExerciseSession

สิทธิ์ที่คุณต้องประกาศเพื่อให้สามารถเขียนการออกกำลังกายที่วางแผนไว้มีดังนี้

<application>
  <uses-permission
android:name="android.permission.health.WRITE_PLANNED_EXERCISE" />
...
</application>

หากต้องการอ่านการออกกำลังกายที่วางแผนไว้ คุณต้องขอสิทธิ์ต่อไปนี้

<application>
  <uses-permission
android:name="android.permission.health.READ_PLANNED_EXERCISE" />
...
</application>

ขอสิทธิ์จากผู้ใช้

หลังจากสร้างอินสแตนซ์ไคลเอ็นต์แล้ว แอปของคุณจะต้องขอสิทธิ์จากผู้ใช้ ผู้ใช้ต้องได้รับอนุญาตให้ให้สิทธิ์หรือปฏิเสธสิทธิ์ได้ทุกเมื่อ โดยสร้างชุดสิทธิ์สำหรับประเภทข้อมูลที่จำเป็น ตรวจสอบว่าได้ประกาศสิทธิ์ในชุดสิทธิ์ในไฟล์ Manifest ของ Android ก่อน

val permissions =
    setOf(
        HealthPermission.getReadPermission(HeartRateRecord::class),
        HealthPermission.getWritePermission(HeartRateRecord::class),
        HealthPermission.getReadPermission(PlannedExerciseSessionRecord::class),
        HealthPermission.getWritePermission(PlannedExerciseSessionRecord::class),
        HealthPermission.getReadPermission(ExerciseSessionRecord::class),
        HealthPermission.getWritePermission(ExerciseSessionRecord::class)
    )
ใช้ getGrantedPermissions เพื่อดูว่าแอปของคุณได้รับสิทธิ์ที่จำเป็นแล้วหรือยัง หากไม่มี ให้ใช้ createRequestPermissionResultContract เพื่อขอสิทธิ์เหล่านั้น หน้าจอแสดงสิทธิ์ของ Health Connect จะปรากฏขึ้น
val permissions = setOf(
        HealthPermission.getReadPermission(StepsRecord::class),
        HealthPermission.getWritePermission(StepsRecord::class),
        HealthPermission.getReadPermission(HeartRateRecord::class),
        HealthPermission.getWritePermission(HeartRateRecord::class)
    )

val requestPermissionsLauncher = rememberLauncherForActivityResult(
    contract = PermissionController.createRequestPermissionResultContract()
) { grantedPermissions ->
    if (grantedPermissions.containsAll(permissions)) {
        coroutineScope.launch { snackbarHostState.showSnackbar("Permissions granted!") }
    } else {
        coroutineScope.launch { snackbarHostState.showSnackbar("Permissions denied.") }
    }
}
เนื่องจากผู้ใช้สามารถให้หรือเพิกถอนสิทธิ์ได้ทุกเมื่อ แอปของคุณจึงต้องตรวจสอบสิทธิ์ทุกครั้งก่อนใช้งานและจัดการสถานการณ์ที่สิทธิ์หายไป

แผนการฝึกจะลิงก์กับเซสชันการออกกำลังกาย ดังนั้น ผู้ใช้ต้องให้สิทธิ์ในการใช้ระเบียนแต่ละประเภทที่เกี่ยวข้องกับแผนการฝึกเพื่อให้ใช้ฟีเจอร์นี้ของ Health Connect ได้อย่างเต็มที่

ตัวอย่างเช่น หากแผนการฝึกวัดอัตราการเต้นของหัวใจของผู้ใช้ระหว่างการวิ่งหลายครั้ง นักพัฒนาแอปอาจต้องประกาศสิทธิ์ต่อไปนี้และผู้ใช้ต้องให้สิทธิ์เพื่อเขียนเซสชันการออกกำลังกายและอ่านผลลัพธ์เพื่อประเมินในภายหลัง

  • android.permission.health.READ_EXERCISE
  • android.permission.health.READ_EXERCISE_ROUTES
  • android.permission.health.READ_HEART_RATE
  • android.permission.health.WRITE_EXERCISE
  • android.permission.health.WRITE_EXERCISE_ROUTE
  • android.permission.health.WRITE_HEART_RATE

อย่างไรก็ตาม บ่อยครั้งที่แอปที่สร้างแผนการฝึกและประเมินประสิทธิภาพเทียบกับแผนไม่ใช่แอปเดียวกับแอปที่ใช้แผนการฝึกและเขียนข้อมูลการออกกำลังกายจริง ทั้งนี้ขึ้นอยู่กับประเภทของแอป อาจไม่จำเป็นต้องใช้สิทธิ์อ่านและเขียนทั้งหมด ตัวอย่างเช่น คุณอาจต้องใช้สิทธิ์เหล่านี้สำหรับแอปแต่ละประเภทเท่านั้น

แอปแผนการฝึก แอปออกกำลังกาย
WRITE_PLANNED_EXERCISE READ_PLANNED_EXERCISE
READ_EXERCISE WRITE_EXERCISE
READ_EXERCISE_ROUTES WRITE_EXERCISE_ROUTE
READ_HEART_RATE WRITE_HEART_RATE

ข้อมูลที่รวมอยู่ในบันทึกเซสชันการออกกำลังกายที่วางแผนไว้

  • ชื่อเซสชัน
  • รายการช่วงเวลาออกกำลังกายที่วางแผนไว้
  • เวลาเริ่มต้นและสิ้นสุดของเซสชัน
  • ประเภทการออกกำลังกาย
  • หมายเหตุสำหรับกิจกรรม
  • ข้อมูลเมตา
  • รหัสเซสชันการออกกำลังกายที่เสร็จสมบูรณ์ — ระบบจะเขียนรหัสนี้โดยอัตโนมัติหลังจากเซสชันการออกกำลังกายที่เกี่ยวข้องกับเซสชันการออกกำลังกายที่วางแผนไว้นี้เสร็จสมบูรณ์

ข้อมูลที่รวมอยู่ในบันทึกบล็อกการออกกำลังกายที่วางแผนไว้

บล็อกการออกกำลังกายที่วางแผนไว้ประกอบด้วยรายการขั้นตอนการออกกำลังกาย เพื่อรองรับการทำซ้ำของกลุ่มขั้นตอนต่างๆ (เช่น ทำท่า Arm Curl, Burpee และ Crunch 5 ครั้งติดต่อกัน)

ข้อมูลที่รวมอยู่ในบันทึกขั้นตอนการออกกำลังกายที่วางแผนไว้

การรวมที่รองรับ

ไม่มีการรวมที่รองรับสำหรับข้อมูลประเภทนี้

ตัวอย่างการใช้

สมมติว่าผู้ใช้วางแผนจะวิ่ง 90 นาทีในอีก 2 วันนับจากนี้ การวิ่งครั้งนี้จะวิ่งรอบทะเลสาบ 3 รอบโดยมีอัตราการเต้นของหัวใจเป้าหมายระหว่าง 90 ถึง 110 bpm

  1. ผู้ใช้กำหนดเซสชันการออกกำลังกายที่วางแผนไว้ซึ่งมีข้อมูลต่อไปนี้ในแอปแผนการฝึก:
    1. เวลาเริ่มต้นและสิ้นสุดที่วางแผนไว้ของการวิ่ง
    2. ประเภทการออกกำลังกาย (วิ่ง)
    3. จำนวนรอบ (การทำซ้ำ)
    4. เป้าหมายด้านประสิทธิภาพสำหรับอัตราการเต้นของหัวใจ (ระหว่าง 90 ถึง 110 bpm)
  2. ระบบจะจัดกลุ่มข้อมูลนี้เป็นบล็อกและขั้นตอนการออกกำลังกาย และแอปแผนการฝึกจะเขียนข้อมูลลงใน Health Connect เป็น PlannedExerciseSessionRecord
  3. ผู้ใช้ทำเซสชันที่วางแผนไว้ (วิ่ง)
  4. ระบบจะบันทึกข้อมูลการออกกำลังกายที่เกี่ยวข้องกับเซสชันด้วยวิธีใดวิธีหนึ่งต่อไปนี้
    1. โดยอุปกรณ์ที่สวมใส่ได้ระหว่างเซสชัน เช่น อัตราการเต้นของหัวใจ ระบบจะเขียนข้อมูลนี้ลงใน Health Connect เป็นประเภทระเบียนสำหรับกิจกรรม ในกรณีนี้ HeartRateRecord
    2. ผู้ใช้ดำเนินการด้วยตนเองหลังจากเซสชัน เช่น การระบุจุดเริ่มต้นและจุดสิ้นสุดของการวิ่งจริง ระบบจะเขียนข้อมูลนี้ลงใน Health Connect เป็นExerciseSessionRecord
  5. ในภายหลัง แอปแผนการฝึกจะอ่านข้อมูลจาก Health Connect เพื่อประเมินประสิทธิภาพจริงเทียบกับเป้าหมายที่ผู้ใช้ตั้งไว้ในเซสชันการออกกำลังกายที่วางแผนไว้

วางแผนการออกกำลังกายและตั้งเป้าหมาย

ผู้ใช้อาจวางแผนการออกกำลังกายในอนาคตและตั้งเป้าหมาย เขียนข้อมูลนี้ลงใน Health Connect เป็นเซสชันการออกกำลังกายที่วางแผนไว้

ในตัวอย่างที่อธิบายไว้ในตัวอย่างการใช้งาน ผู้ใช้วางแผนที่จะวิ่ง 90 นาทีในอีก 2 วันนับจากนี้ การวิ่งครั้งนี้จะวิ่งรอบทะเลสาบ 3 รอบโดยมีอัตราการเต้นของหัวใจเป้าหมายระหว่าง 90 ถึง 110 bpm

คุณอาจพบข้อมูลโค้ดเช่นนี้ในเครื่องมือจัดการแบบฟอร์มสำหรับแอปที่บันทึกเซสชันการออกกำลังกายที่วางแผนไว้ลงใน Health Connect นอกจากนี้ยังอาจพบได้ในจุดนำเข้าสำหรับการผสานรวม เช่น บริการที่เสนอการฝึกอบรม

// Verify the user has granted all necessary permissions for this task
val grantedPermissions =
    healthConnectClient.permissionController.getGrantedPermissions()

if (!grantedPermissions.contains(
        HealthPermission.getWritePermission(PlannedExerciseSessionRecord::class))) {
    // The user hasn't granted the app permission to write planned exercise session data.
    Log.w("HealthConnect", "Write permission for PlannedExerciseSessionRecord not granted.")
    return
}

val plannedExerciseSessionRecord = PlannedExerciseSessionRecord(
    startTime = startTime,
    endTime = endTime,
    exerciseType = ExerciseSessionRecord.EXERCISE_TYPE_RUNNING,
    blocks = listOf(
        PlannedExerciseBlock(
            repetitions = 1, steps = listOf(
                PlannedExerciseStep(
                    exerciseType = ExerciseSegment.EXERCISE_SEGMENT_TYPE_RUNNING,
                    exercisePhase = PlannedExerciseStep.EXERCISE_PHASE_ACTIVE,
                    completionGoal = ExerciseCompletionGoal.RepetitionsGoal(repetitions = 3),
                    performanceTargets = listOf(
                        ExercisePerformanceTarget.HeartRateTarget(
                            minHeartRate = 90.0, maxHeartRate = 110.0
                        )
                    )
                ),
            ), description = "Three laps around the lake"
        )
    ),
    title = "Run at lake",
    notes = null,
    metadata = Metadata.activelyRecorded(
        device = Device(type = Device.Companion.TYPE_PHONE),
    ),
    startZoneOffset = null,
    endZoneOffset = null,
)

try {
    // Attempt to insert the record
    val response = healthConnectClient.insertRecords(listOf(plannedExerciseSessionRecord))

    // If execution reaches here, the insert succeeded.
    // Safely extract the ID using firstOrNull()
    val insertedPlannedExerciseSessionId = response.recordIdsList.firstOrNull()

    if (insertedPlannedExerciseSessionId != null) {
        Log.d("HealthConnect", "Successfully inserted planned exercise session ID: $insertedPlannedExerciseSessionId")
    } else {
        Log.w("HealthConnect", "Insertion succeeded but no record IDs were returned.")
    }

} catch (e: Exception) {
    // Handle API failures, database errors, or system issues safely without crashing
    Log.e("HealthConnect", "Failed to insert planned exercise session record", e)
}

บันทึกข้อมูลการออกกำลังกายและกิจกรรม

2 วันต่อมา ผู้ใช้บันทึกเซสชันการออกกำลังกายจริง เขียนข้อมูลนี้ลงใน Health Connect เป็นเซสชันการออกกำลังกาย

ในตัวอย่างนี้ ระยะเวลาเซสชันของผู้ใช้ตรงกับระยะเวลาที่วางแผนไว้พอดี

คุณอาจพบข้อมูลโค้ดต่อไปนี้ในเครื่องมือจัดการแบบฟอร์มสำหรับแอปที่บันทึกเซสชันการออกกำลังกายลงใน Health Connect นอกจากนี้ยังอาจพบได้ในเครื่องมือจัดการการนำเข้าและส่งออกข้อมูลสำหรับอุปกรณ์ที่สวมใส่ได้ซึ่งสามารถตรวจจับและบันทึกเซสชันการออกกำลังกาย

insertedPlannedExerciseSessionId ที่นี่นำมาใช้ซ้ำจากตัวอย่างก่อนหน้า ในแอปจริง รหัสจะกำหนดโดยผู้ใช้ที่เลือกเซสชันการออกกำลังกายที่วางแผนไว้จากรายการเซสชันที่มีอยู่

// Verify the user has granted all necessary permissions for this task
val grantedPermissions =
    healthConnectClient.permissionController.getGrantedPermissions()
if (!grantedPermissions.contains(
        HealthPermission.getWritePermission(ExerciseSessionRecord::class))) {
    // The user doesn't granted the app permission to write exercise session data.
    return
}

val sessionDuration = Duration.ofMinutes(90)
val sessionEndTime = Instant.now()
val sessionStartTime = sessionEndTime.minus(sessionDuration)

val exerciseSessionRecord = ExerciseSessionRecord(
    startTime = sessionStartTime,
    startZoneOffset = ZoneOffset.UTC,
    endTime = sessionEndTime,
    endZoneOffset = ZoneOffset.UTC,
    exerciseType = ExerciseSessionRecord.EXERCISE_TYPE_RUNNING,
    segments = listOf(
        ExerciseSegment(
            startTime = sessionStartTime,
            endTime = sessionEndTime,
            repetitions = 3,
            segmentType = ExerciseSegment.EXERCISE_SEGMENT_TYPE_RUNNING
        )
    ),
    title = "Run at lake",
    plannedExerciseSessionId = insertedPlannedExerciseSessionId,
    metadata = Metadata.activelyRecorded(
        device = Device(type = Device.Companion.TYPE_PHONE)
    )
)
val insertedExerciseSessions =
    healthConnectClient.insertRecords(listOf(exerciseSessionRecord))

อุปกรณ์ที่สวมใส่ได้ยังบันทึกอัตราการเต้นของหัวใจตลอดการวิ่งด้วย คุณสามารถใช้ข้อมูลโค้ดต่อไปนี้เพื่อสร้างระเบียนภายในช่วงเป้าหมาย

ในแอปจริง ส่วนหลักของข้อมูลโค้ดนี้อาจอยู่ในเครื่องจัดการสำหรับข้อความจากอุปกรณ์ที่สวมใส่ได้ ซึ่งจะเขียนการวัดลงใน Health Connect เมื่อรวบรวมข้อมูล

// Verify the user has granted all necessary permissions for this task
val grantedPermissions =
    healthConnectClient.permissionController.getGrantedPermissions()
if (!grantedPermissions.contains(
        HealthPermission.getWritePermission(HeartRateRecord::class))) {
    // The user doesn't granted the app permission to write heart rate record data.
    return
}

val samples = mutableListOf<HeartRateRecord.Sample>()
var currentTime = sessionStartTime
while (currentTime.isBefore(sessionEndTime)) {
    val bpm = Random.nextInt(21) + 90
    val heartRateRecord = HeartRateRecord.Sample(
        time = currentTime,
        beatsPerMinute = bpm.toLong(),
    )
    samples.add(heartRateRecord)
    currentTime = currentTime.plusSeconds(180)
}

val heartRateRecord = HeartRateRecord(
    startTime = sessionStartTime,
    startZoneOffset = ZoneOffset.UTC,
    endTime = sessionEndTime,
    endZoneOffset = ZoneOffset.UTC,
    samples = samples,
    metadata = Metadata.activelyRecorded(
        device = Device(type = Device.Companion.TYPE_WATCH)
    )
)
val insertedHeartRateRecords = healthConnectClient.insertRecords(listOf(heartRateRecord))

ประเมินเป้าหมายด้านประสิทธิภาพ

ในวันถัดจากการออกกำลังกายของผู้ใช้ คุณสามารถดึงข้อมูลการออกกำลังกายที่บันทึกไว้ ตรวจสอบเป้าหมายการออกกำลังกายที่วางแผนไว้ และประเมินประเภทข้อมูลเพิ่มเติมเพื่อพิจารณาว่าบรรลุเป้าหมายที่ตั้งไว้หรือไม่

ตัวอย่างข้อมูลเช่นนี้มักจะพบในงานที่ทำเป็นระยะเพื่อประเมินเป้าหมายด้านประสิทธิภาพ หรือเมื่อโหลดรายการแบบฝึกหัดและแสดงการแจ้งเตือนเกี่ยวกับเป้าหมายด้านประสิทธิภาพในแอป

    // Verify the user has granted all necessary permissions for this task
    val grantedPermissions =
        healthConnectClient.permissionController.getGrantedPermissions()
    if (!grantedPermissions.containsAll(
            listOf(
                HealthPermission.getReadPermission(ExerciseSessionRecord::class),
                HealthPermission.getReadPermission(PlannedExerciseSessionRecord::class),
                HealthPermission.getReadPermission(HeartRateRecord::class)
            )
        )
    ) {
        // The user doesn't granted the app permission to read exercise session record data.
        return
    }

    val searchDuration = Duration.ofDays(1)
    val searchEndTime = Instant.now()
    val searchStartTime = searchEndTime.minus(searchDuration)

    val response = healthConnectClient.readRecords(
        ReadRecordsRequest<ExerciseSessionRecord>(
            timeRangeFilter = TimeRangeFilter.between(searchStartTime, searchEndTime)
        )
    )
    for (exerciseRecord in response.records) {
        val plannedExerciseRecordId = exerciseRecord.plannedExerciseSessionId
        val plannedExerciseRecord =
            if (plannedExerciseRecordId == null) null else healthConnectClient.readRecord(
                PlannedExerciseSessionRecord::class, plannedExerciseRecordId
            ).record
        if (plannedExerciseRecord != null) {
            val aggregateRequest = AggregateRequest(
                metrics = setOf(HeartRateRecord.BPM_AVG),
                timeRangeFilter = TimeRangeFilter.between(
                    exerciseRecord.startTime, exerciseRecord.endTime
                ),
            )
            val aggregationResult = healthConnectClient.aggregate(aggregateRequest)

            val maxBpm = aggregationResult[HeartRateRecord.BPM_MAX]
            val minBpm = aggregationResult[HeartRateRecord.BPM_MIN]
            if (maxBpm != null && minBpm != null) {
                plannedExerciseRecord.blocks.forEach { block ->
                    block.steps.forEach { step ->
                        step.performanceTargets.forEach { target ->
                            when (target) {
                                is ExercisePerformanceTarget.HeartRateTarget -> {
                                    val minTarget = target.minHeartRate
                                    val maxTarget = target.maxHeartRate
                                    if(
                                        minBpm >= minTarget && maxBpm <= maxTarget
                                    ) {
                                        // Success!
                                    }
                                }
                                // Handle more target types
                            }
                        }
                    }
                }
            }
        }
    }
}

เซสชันการออกกำลังกาย

เซสชันการออกกำลังกายอาจรวมถึงกิจกรรมต่างๆ ตั้งแต่การวิ่งไปจนถึงแบดมินตัน

เขียนข้อมูลเซสชันการออกกำลังกาย

วิธีสร้างคำขอแทรกที่มีเซสชันมีดังนี้

suspend fun writeExerciseSession(healthConnectClient: HealthConnectClient) {
    healthConnectClient.insertRecords(
        listOf(
            ExerciseSessionRecord(
                startTime = START_TIME,
                startZoneOffset = START_ZONE_OFFSET,
                endTime = END_TIME,
                endZoneOffset = END_ZONE_OFFSET,
                exerciseType = ExerciseSessionRecord.ExerciseType.RUNNING,
                title = "My Run",
                metadata = Metadata.manualEntry()
            ),
            // ... other records
        )
    )
}

อ่านเซสชันการออกกำลังกาย

ต่อไปนี้เป็นตัวอย่างวิธีอ่านเซสชันการออกกำลังกาย

suspend fun readExerciseSessions(
    healthConnectClient: HealthConnectClient,
    startTime: Instant,
    endTime: Instant
) {
    val response =
        healthConnectClient.readRecords(
            ReadRecordsRequest(
                ExerciseSessionRecord::class,
                timeRangeFilter = TimeRangeFilter.between(startTime, endTime)
            )
        )
    for (exerciseRecord in response.records) {
        // Process each exercise record
        // Optionally pull in with other data sources of the same time range.
        val distanceRecord =
            healthConnectClient
                .readRecords(
                    ReadRecordsRequest(
                        DistanceRecord::class,
                        timeRangeFilter =
                            TimeRangeFilter.between(
                                exerciseRecord.startTime,
                                exerciseRecord.endTime
                            )
                    )
                )
                .records
    }
}

เขียนข้อมูลประเภทย่อย

นอกจากนี้ เซสชันยังอาจประกอบด้วยข้อมูลประเภทย่อยที่ไม่บังคับ ซึ่งจะช่วยเพิ่มข้อมูลเพิ่มเติมให้กับเซสชัน

ตัวอย่างเช่น เซสชันการออกกำลังกายอาจรวมคลาส ExerciseSegment, ExerciseLap และ ExerciseRoute ดังนี้

val segments = listOf(
  ExerciseSegment(
    startTime = Instant.parse("2022-01-02T10:10:10Z"),
    endTime = Instant.parse("2022-01-02T10:10:13Z"),
    segmentType = ActivitySegmentType.BENCH_PRESS,
    repetitions = 373
  )
)

val laps = listOf(
  ExerciseLap(
    startTime = Instant.parse("2022-01-02T10:10:10Z"),
    endTime = Instant.parse("2022-01-02T10:10:13Z"),
    length = 0.meters
  )
)

ExerciseSessionRecord(
  exerciseType = ExerciseSessionRecord.EXERCISE_TYPE_CALISTHENICS,
    startTime = Instant.parse("2022-01-02T10:10:10Z"),
    endTime = Instant.parse("2022-01-02T10:10:13Z"),
  startZoneOffset = ZoneOffset.UTC,
  endZoneOffset = ZoneOffset.UTC,
  segments = segments,
  laps = laps,
  route = route,
  metadata = Metadata.manualEntry()
)