कसरत के रूट जोड़ें

यह गाइड, Health Connect के 1.1.0-alpha12 वर्शन के साथ काम करती है.

कसरत के लिए रूट की सुविधा की मदद से, उपयोगकर्ता कसरत से जुड़ी गतिविधियों के लिए जीपीएस रूट ट्रैक कर सकते हैं. साथ ही, अपने वर्कआउट के मैप को अन्य ऐप्लिकेशन के साथ शेयर कर सकते हैं.

इस गाइड में बताया गया है कि ऐप्लिकेशन को कसरत के सेशन के हिस्से के तौर पर, रूट का डेटा लिखने की अनुमति कैसे मिलती है.

यहां कसरत के रूट की जानकारी पढ़ने और उसमें बदलाव करने की सुविधा के बारे में खास जानकारी दी गई है:

1. ऐप्लिकेशन, कसरत के रूट के लिए लिखने की नई अनुमति बनाते हैं.
2. कसरत का सेशन लिखकर, रूट को फ़ील्ड के तौर पर जोड़ें.
3. पढ़ना:
   1. सेशन के मालिक के लिए, सेशन रीड का इस्तेमाल करके डेटा ऐक्सेस किया जाता है.
   2. तीसरे पक्ष के ऐप्लिकेशन से, डायलॉग बॉक्स के ज़रिए. इसकी मदद से, उपयोगकर्ता किसी रूट को एक बार पढ़ने की अनुमति दे सकता है.

अनुमतियां

कसरत के रूट के लिए, रनटाइम में लिखने की अनुमति (android.permission.health.WRITE_EXERCISE_ROUTE) अलग होती है.

अपने ऐप्लिकेशन में कसरत के लिए रास्ते की जानकारी जोड़ने के लिए, किसी खास डेटा टाइप के लिए लिखने की अनुमतियों का अनुरोध करें.

Android 14 के लिए अनुमति का अनुरोध

Android 13 के लिए अनुमति का अनुरोध

आपको कसरत की अनुमति भी देनी होगी, क्योंकि हर रूट किसी कसरत के सेशन से जुड़ा होता है (एक सेशन = एक वर्कआउट).

कसरत के रूट लिखने के लिए, आपको यह अनुमति देनी होगी:

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

कसरत के रूट देखने के लिए, आपको इन अनुमतियों का अनुरोध करना होगा:

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

अनुमतियों का अनुरोध करने के लिए, अपने ऐप्लिकेशन को पहली बार Health Connect से कनेक्ट करते समय, PermissionController.createRequestPermissionResultContract() तरीके का इस्तेमाल करें. आपको इन अनुमतियों का अनुरोध करना पड़ सकता है:

• सेहत की जानकारी से जुड़ा डेटा पढ़ें. इसमें रास्ते की जानकारी भी शामिल है: HealthPermission.getReadPermission(ExerciseSessionRecord::class)
• सेहत से जुड़ा डेटा लिखें. इसमें रास्ते का डेटा भी शामिल है: HealthPermission.getWritePermission(ExerciseSessionRecord::class)
• कसरत के रूट का डेटा लिखें: HealthPermission.PERMISSION_WRITE_EXERCISE_ROUTE

ध्यान दें: अगर उपयोगकर्ता आपके ऐप्लिकेशन के अनुरोध की सभी अनुमतियां नहीं देता है, तो भी आपका ऐप्लिकेशन चलना चाहिए. साथ ही, उपयोगकर्ता की दी गई अनुमतियों के हिसाब से, वह ज़्यादा से ज़्यादा टास्क पूरा कर सकता है.

रास्ते का डेटा पढ़ना और उसमें बदलाव करना

ऐप्लिकेशन, फ़ील्ड के तौर पर रूट के साथ सेशन लिखकर रूट डालते हैं.

अगर उपयोगकर्ता के पास लिखने की अनुमतियां नहीं हैं और रास्ता सेट नहीं किया गया है, तो रास्ता अपडेट नहीं होता.

अगर आपके ऐप्लिकेशन के पास रूट में बदलाव करने की अनुमति है और वह बिना रूट वाले सेशन ऑब्जेक्ट को पास करके सेशन को अपडेट करने की कोशिश करता है, तो मौजूदा रूट मिटा दिया जाता है.

जब भी आपके ऐप्लिकेशन को तीसरे पक्ष के ऐप्लिकेशन से मिले रास्ते का डेटा पढ़ना होता है, तब एक डायलॉग बॉक्स दिखता है. इसमें उपयोगकर्ता से डेटा पढ़ने की अनुमति देने के लिए कहा जाता है.

किसी सेशन से रूट का अनुरोध करना

Health Connect में किसी सेशन को पढ़ने और उस सेशन से रूट का अनुरोध करने का तरीका यहां बताया गया है:

suspend fun readExerciseSessionAndRoute() {
    val endTime = Instant.now()
    val startTime = endTime.minus(Duration.ofHours(1))

    val grantedPermissions =
        healthConnectClient.permissionController.getGrantedPermissions()
    if (!grantedPermissions.contains(
          HealthPermission.getReadPermission(ExerciseSessionRecord::class))) {
        // The user doesn't allow the app to read exercise session data.
        return
    }

    val readResponse =
      healthConnectClient.readRecords(
        ReadRecordsRequest(
          ExerciseSessionRecord::class,
          TimeRangeFilter.between(startTime, endTime)
        )
      )
    val exerciseRecord = readResponse.records.first()
    val recordId = exerciseRecord.metadata.id

    // See https://developer.android.com/training/basics/intents/result#launch
    // for appropriately handling ActivityResultContract.
    val requestExerciseRouteLauncher = fragment.registerForActivityResul
    (ExerciseRouteRequestContract()) { exerciseRoute: ExerciseRoute? ->
            if (exerciseRoute != null) {
                displayExerciseRoute(exerciseRoute)
            } else {
                // Consent was denied
            }
        }

    val exerciseSessionRecord =
      healthConnectClient.readRecord(ExerciseSessionRecord::class, recordId).record

    when (val exerciseRouteResult = exerciseSessionRecord.exerciseRouteResult) {
        is ExerciseRouteResult.Data ->
            displayExerciseRoute(exerciseRouteResult.exerciseRoute)
        is ExerciseRouteResult.ConsentRequired ->
            requestExerciseRouteLauncher.launch(recordId)
        is ExerciseRouteResult.NoData -> Unit // No exercise route to show
        else -> Unit
    }
  }

  fun displayExerciseRoute(route: ExerciseRoute?) {
    val locations = route.route.orEmpty()
    for (location in locations) {
      // Handle location.
    }
  }

किसी सेशन से रूट लिखना

नीचे दिए गए कोड में, ऐसे सेशन को रिकॉर्ड करने का तरीका बताया गया है जिसमें कसरत का रास्ता शामिल है:

suspend fun InsertExerciseRoute(healthConnectClient: HealthConnectClient) {
    val grantedPermissions =
        healthConnectClient.permissionController.getGrantedPermissions()
    if (!grantedPermissions.contains(
          getWritePermission(ExerciseSessionRecord::class))) {
        // The user doesn't allow the app to write exercise session data.
        return
    }

    val sessionStartTime = Instant.now()
    val sessionDuration = Duration.ofMinutes(20)
    val sessionEndTime = sessionStartTime.plus(sessionDuration)

    val exerciseRoute =
        if (grantedPermissions.contains(PERMISSION_WRITE_EXERCISE_ROUTE)) ExerciseRoute(
            listOf(
                ExerciseRoute.Location(
                    // Location times must be on or after the session start time
                    time = sessionStartTime,
                    latitude = 6.5483,
                    longitude = 0.5488,
                    horizontalAccuracy = Length.meters(2.0),
                    verticalAccuracy = Length.meters(2.0),
                    altitude = Length.meters(9.0),
                ), ExerciseRoute.Location(
                    // Location times must be before the session end time
                    time = sessionEndTime.minusSeconds(1),
                    latitude = 6.4578,
                    longitude = 0.6577,
                    horizontalAccuracy = Length.meters(2.0),
                    verticalAccuracy = Length.meters(2.0),
                    altitude = Length.meters(9.2),
                )
            )
        )
        else
        // The user doesn't allow the app to write exercise route data.
            null
    val exerciseSessionRecord = ExerciseSessionRecord(
        startTime = sessionStartTime,
        startZoneOffset = ZoneOffset.UTC,
        endTime = sessionEndTime,
        endZoneOffset = ZoneOffset.UTC,
        exerciseType = ExerciseSessionRecord.EXERCISE_TYPE_BIKING,
        title = "Morning Bike Ride",
        exerciseRoute = exerciseRoute,
        metadata = Metadata.manualEntry(
            device = Device(type = Device.TYPE_PHONE)
        ),
    )
    val response = healthConnectClient.insertRecords(listOf(exerciseSessionRecord))
}