Health Connect की मदद से, कसरत से जुड़े अनुभव डेवलप करना

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

  • कसरत के सेशन का डेटा सेव करने की अनुमति
  • वर्कआउट के रूट का डेटा सेव करने की अनुमति
  • वर्कआउट की मेट्रिक का डेटा सेव करने की अनुमति. जैसे, धड़कन की दर, रफ़्तार, और दूरी
  • अन्य ऐप्लिकेशन से वर्कआउट का डेटा देखने की अनुमति

इस गाइड में, कसरत की ये सुविधाएं जोड़ने का तरीका बताया गया है. इसमें डेटा टाइप, बैकग्राउंड में कोड एक्ज़ीक्यूट होने की सुविधा, अनुमतियां, सुझाए गए वर्कफ़्लो, और सबसे सही तरीकों के बारे में बताया गया है.

खास जानकारी: वर्कआउट को ट्रैक करने की पूरी सुविधा जोड़ना

Health Connect का इस्तेमाल करके, वर्कआउट को ट्रैक करने की पूरी सुविधा जोड़ी जा सकती है. इसके लिए, ये मुख्य चरण पूरे करें:

  • सेहत से जुड़ी अनुमतियों के आधार पर, अनुमतियों को सही तरीके से लागू करना.
  • ExerciseSessionRecord का इस्तेमाल करके, सेशन रिकॉर्ड करना.
  • सेशन के दौरान, वर्कआउट का डेटा लगातार सेव करना.
  • डेटा को लगातार कैप्चर करने की पुष्टि करने के लिए, बैकग्राउंड में कोड एक्ज़ीक्यूट होने की सुविधा को सही तरीके से मैनेज करना.
  • वर्कआउट के बाद की खास जानकारी और विश्लेषण के लिए, सेशन का डेटा पढ़ना.

इस वर्कफ़्लो की मदद से, Health Connect के अन्य ऐप्लिकेशन के साथ इंटरऑपरेबिलिटी की जा सकती है. साथ ही, उपयोगकर्ता के कंट्रोल में मौजूद डेटा का ऐक्सेस की पुष्टि की जा सकती है.

शुरू करने से पहले

वर्कआउट की सुविधाएं लागू करने से पहले:

मुख्य सिद्धांत

Health Connect, वर्कआउट के डेटा को कुछ मुख्य कॉम्पोनेंट का इस्तेमाल करके दिखाता है. ExerciseSessionRecord, वर्कआउट के लिए मुख्य रिकॉर्ड के तौर पर काम करता है. इसमें शुरू या खत्म होने का समय और कसरत का टाइप जैसी जानकारी शामिल होती है. किसी सेशन के दौरान, HeartRateRecord या SpeedRecord जैसे अलग-अलग डेटा टाइप रिकॉर्ड किए जा सकते हैं. आउटडोर गतिविधियों के लिए, ExerciseRoute में जीपीएस डेटा सेव किया जाता है. यह डेटा, इससे जुड़े सेशन से लिंक होता है.

कसरत के सेशन

ExerciseSessionRecord, वर्कआउट के डेटा के लिए मुख्य रिकॉर्ड होता है. यह वर्कआउट के एक सेशन को दिखाता है. हर रिकॉर्ड में यह जानकारी सेव होती है:

  • startTime
  • endTime
  • exerciseType
  • सेशन का वैकल्पिक मेटाडेटा (टाइटल, नोट)

ExerciseSessionRecord में, कसरत के रूट, लैप, और सेगमेंट भी शामिल हो सकते हैं. इसके अलावा, HeartRateRecord या SpeedRecord जैसे अन्य डेटा टाइप, किसी सेशन के दौरान रिकॉर्ड किए जा सकते हैं और उससे जोड़े जा सकते हैं.

जुड़े हुए डेटा टाइप

वर्कआउट के सेशन से जुड़े डेटा को, अलग-अलग रिकॉर्ड टाइप से दिखाया जाता है. आम तौर पर इस्तेमाल होने वाले टाइप में ये शामिल हैं:

  • HeartRateRecord: धड़कन की दर के मेज़रमेंट की सीरीज़ दिखाता है.
  • SpeedRecord: रफ़्तार के मेज़रमेंट की सीरीज़ दिखाता है.
  • DistanceRecord: रीडिंग के बीच तय की गई दूरी दिखाता है.
  • TotalCaloriesBurnedRecord: रीडिंग के बीच खर्च की गई कुल कैलोरी दिखाता है.
  • ElevationGainedRecord: रीडिंग के बीच तय की गई ऊंचाई दिखाता है.
  • StepsCadenceRecord: रीडिंग के बीच चलने की रफ़्तार का डेटा दिखाता है.
  • PowerRecord: रीडिंग के बीच पावर आउटपुट दिखाता है. यह साइकल चलाने जैसी गतिविधियों में आम तौर पर इस्तेमाल होता है.

डेटा टाइप की पूरी सूची देखने के लिए, Health Connect के डेटा टाइप देखें.

कसरत के रूट

ExerciseRoute का इस्तेमाल करके, आउटडोर वर्कआउट के साथ रूट जोड़ा जा सकता है. रूट में, क्रम से लगाए गए ExerciseRoute.Location ऑब्जेक्ट शामिल होते हैं. हर ऑब्जेक्ट में यह जानकारी होती है:

  • अक्षांश और देशांतर
  • वैकल्पिक ऊंचाई
  • वैकल्पिक बेयरिंग
  • सटीक होने की जानकारी
  • टाइमस्टैंप

सेशन के रूट लिंक करना

ExerciseRoute में, कसरत के सेशन के लिए क्रम से लगाया गया जगह की जानकारी का डेटा होता है. इसे Health Connect में, अलग रिकॉर्ड के तौर पर नहीं माना जाता. इसके बजाय, ExerciseSessionRecord को इंसर्ट या अपडेट करते समय, ExerciseRoute का डेटा दिया जाता है.

डेवलपमेंट के दौरान ध्यान देने वाली बातें

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

बैकग्राउंड में कोड एक्ज़ीक्यूट होने की सुविधा

वर्कआउट वाले ऐप्लिकेशन, आम तौर पर स्क्रीन बंद होने पर भी चलते रहते हैं. इस स्थिति में, आपको इनका इस्तेमाल करना चाहिए:

  • जगह की जानकारी और सेंसर सैंपलिंग के लिए, फ़ोरग्राउंड सेवाएं
  • WorkManager डेटा सेव करने या सिंक करने में देरी के लिए
  • रिकॉर्ड को नियमित तौर पर सेव करने के लिए, बैचिंग की रणनीतियां

सभी सेव किए गए डेटा के लिए, सेशन आईडी एक जैसा रखकर, डेटा को लगातार सेव करें.

अनुमतियां

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

  • कसरत के सेशन: ExerciseSessionRecord के लिए, पढ़ने और सेव करने की अनुमतियां.
  • कसरत के रूट: ExerciseRoute के लिए, पढ़ने और सेव करने की अनुमतियां.
  • धड़कन की दर: HeartRateRecord के लिए, पढ़ने और सेव करने की अनुमतियां.
  • रफ़्तार: SpeedRecord के लिए, पढ़ने और सेव करने की अनुमतियां.
  • दूरी: DistanceRecord के लिए, पढ़ने और सेव करने की अनुमतियां.
  • कैलोरी: TotalCaloriesBurnedRecord के लिए, पढ़ने और सेव करने की अनुमतियां.
  • तय की गई ऊंचाई: ElevationGainedRecord के लिए, पढ़ने और सेव करने की अनुमतियां.
  • चलने की रफ़्तार का डेटा: StepsCadenceRecord के लिए, पढ़ने और सेव करने की अनुमतियां.
  • पावर: PowerRecord के लिए, पढ़ने और सेव करने की अनुमतियां.
  • कदम: StepsRecord के लिए, पढ़ने और सेव करने की अनुमतियां.

यहां एक उदाहरण दिया गया है, जिसमें वर्कआउट के एक सेशन के लिए कई अनुमतियों का अनुरोध करने का तरीका दिखाया गया है. इस सेशन में रूट, धड़कन की दर, दूरी, कैलोरी, रफ़्तार, और कदमों का डेटा शामिल है:

क्लाइंट इंस्टेंस बनाने के बाद, आपके ऐप्लिकेशन को उपयोगकर्ता से अनुमतियों का अनुरोध करना होगा. उपयोगकर्ताओं के पास किसी भी समय अनुमतियां देने या अस्वीकार करने का विकल्प ज़रूर होना चाहिए. इसके लिए, ज़रूरी डेटा टाइप के लिए अनुमतियों का सेट बनाएं. पक्का करें कि सेट में मौजूद अनुमतियों का एलान, सबसे पहले आपके Android मेनिफ़ेस्ट में किया गया हो. 

val permissions =
    setOf(
        HealthPermission.getReadPermission(ExerciseSessionRecord::class),
        HealthPermission.getWritePermission(ExerciseSessionRecord::class),
        HealthPermission.getReadPermission(HeartRateRecord::class),
        HealthPermission.getWritePermission(HeartRateRecord::class),
        HealthPermission.getReadPermission(SpeedRecord::class),
        HealthPermission.getWritePermission(SpeedRecord::class),
        HealthPermission.getReadPermission(DistanceRecord::class),
        HealthPermission.getWritePermission(DistanceRecord::class),
        HealthPermission.getReadPermission(TotalCaloriesBurnedRecord::class),
        HealthPermission.getWritePermission(TotalCaloriesBurnedRecord::class),
        HealthPermission.getReadPermission(StepsRecord::class),
        HealthPermission.getWritePermission(StepsRecord::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.") }
    }
}
 उपयोगकर्ता किसी भी समय अनुमतियां दे सकते हैं या रद्द कर सकते हैं. इसलिए, आपके ऐप्लिकेशन को हर बार अनुमतियों का इस्तेमाल करने से पहले, उनकी जांच करनी होगी. साथ ही, अनुमति रद्द होने की स्थितियों को मैनेज करना होगा.

अनुमतियों का अनुरोध करने के लिए, checkPermissionsAndRun फ़ंक्शन को कॉल करें:

if (!granted.containsAll(permissions)) {
    // Check if required permissions are not granted, and return
    return emptySet()
}
// Permissions already granted; proceed with inserting or reading data

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

धड़कन की दर को ऐक्सेस करने के लिए, इन अनुमतियों का इस्तेमाल किया जाता है:

  • android.permission.health.READ_HEART_RATE
  • android.permission.health.WRITE_HEART_RATE

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

यहां उस अनुमति के बारे में बताया गया है जिसके बारे में आपको एलान करना होगा, ताकि धड़कन की दर से जुड़े डेटा में बदलाव किया जा सके:

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

धड़कन की दर की जानकारी ऐक्सेस करने के लिए, आपको ये अनुमतियां मांगनी होंगी:

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

वर्कआउट का सेशन लागू करना

इस सेक्शन में, वर्कआउट का डेटा रिकॉर्ड करने के लिए सुझाए गए वर्कफ़्लो के बारे में बताया गया है.

सेशन शुरू करना

नया वर्कआउट बनाने के लिए:

  1. सेशन का यूनीक आईडी जनरेट करें: पुष्टि करें कि यह आईडी स्थिर है. अगर आपके ऐप्लिकेशन की प्रोसेस बंद हो जाती है और फिर से शुरू होती है, तो आपको उसी आईडी का इस्तेमाल करके, सेशन को फिर से शुरू करना होगा. इससे सेशन के टुकड़े नहीं होंगे.
  2. सिंक करने की कोशिशों के दौरान डुप्लीकेट एंट्री से बचने के लिए, metadata.clientRecordId सेट करें.
  3. ExerciseSessionRecord सेव करें: इसमें शुरू होने का समय शामिल करें.
  4. डेटा टाइप और जीपीएस डेटा इकट्ठा करना शुरू करें: इन्हें सिर्फ़ तब शुरू करें, जब सेशन रिकॉर्ड को सफलतापूर्वक शुरू कर लिया गया हो.

उदाहरण:

val sessionClientId = UUID.randomUUID().toString()
val zoneOffset = ZoneOffset.systemDefault().rules.getOffset(startTime)

val session =   ExerciseSessionRecord(
    startTime = startTime,
    startZoneOffset = zoneOffset,
    endTime = startTime.plusSeconds(3600),
    endZoneOffset = zoneOffset,
    exerciseType = ExerciseSessionRecord.EXERCISE_TYPE_RUNNING,
    metadata = Metadata(clientRecordId = sessionClientId),
)

healthConnectClient.insertRecords(listOf(session))

कसरत के रूट रिकॉर्ड करना

रॉ डेटा पढ़ने के बारे में ज़्यादा जानने के लिए, रॉ डेटा पढ़ना लेख देखें.

कसरत का रूट रिकॉर्ड करते समय, आपको अपने डेटा को बैच में सेव करना चाहिए. इसका मतलब है कि जीपीएस के हर पॉइंट को सेव करने के बजाय, आपको पॉइंट का ग्रुप इकट्ठा करना चाहिए और उन्हें एक ही बार में सेव करना चाहिए.

यह ज़रूरी है, क्योंकि हर बार जब आपका ऐप्लिकेशन, Health Connect से डेटा पढ़ता है या उसमें डेटा सेव करता है, तो वह थोड़ी बैटरी और प्रोसेसिंग पावर का इस्तेमाल करता है.

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

// 1. Create a list to hold your route locations
val routeLocations = mutableListOf<ExerciseRoute.Location>()

// 2. Add points to your list as the exercise happens
routeLocations.add(
    ExerciseRoute.Location(
        time = Instant.now(),
        latitude = 37.7749,
        longitude = -122.4194
    )
)

// ... keep adding points over a period of time ...

// 3. Save the whole list at once (Batching)
val session = ExerciseSessionRecord(
    startTime = startTime,
    endTime = endTime,
    exerciseType = ExerciseSessionRecord.EXERCISE_TYPE_RUNNING,
    // We pass the whole list here
    exerciseRoute = ExerciseRoute(routeLocations)
)

healthConnectClient.insertRecords(listOf(session))

सेशन खत्म करना

डेटा कलेक्शन रोकने के बाद:

  • रिकॉर्ड अपडेट करें: आपका ऐप्लिकेशन, ExerciseSessionRecord को endTime के साथ अपडेट करता है.
  • डेटा को फ़ाइनल करें: आपके पास, खास जानकारी वाली वैल्यू (जैसे, कुल दूरी या औसत रफ़्तार) की गणना करने और उन्हें अतिरिक्त रिकॉर्ड के तौर पर सेव करने का विकल्प होता है.
val finishedSession = session.copy(endTime = Instant.now())
healthConnectClient.updateRecords(listOf(finishedSession))

वर्कआउट का डेटा पढ़ना

ऐप्लिकेशन, कसरत के सेशन और उनसे जुड़े डेटा को पढ़कर, गतिविधि की खास जानकारी दे सकते हैं, सेहत से जुड़ी जानकारी दे सकते हैं या किसी बाहरी सर्वर के साथ डेटा सिंक कर सकते हैं. उदाहरण के लिए, ExerciseSessionRecord को पढ़ा जा सकता है. इसके बाद, उसी समयावधि के दौरान हुए HeartRateRecord या DistanceRecord के बारे में क्वेरी की जा सकती है.

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

सेशन पढ़ना

कसरत के सेशन पढ़ने के लिए, ReadRecordsRequest का इस्तेमाल करें. इसमें, टाइप के तौर पर ExerciseSessionRecord का इस्तेमाल करें. आम तौर पर, इसे किसी खास समयावधि के हिसाब से फ़िल्टर किया जाता है.

suspend fun readExerciseSessions(
    healthConnectClient: HealthConnectClient,
    startTime: Instant,
    endTime: Instant
) {
    val response = healthConnectClient.readRecords(
        ReadRecordsRequest(
            recordType = ExerciseSessionRecord::class,
            timeRangeFilter = TimeRangeFilter.between(startTime, endTime)
        )
    )

    for (exerciseRecord in response.records) {
        // Process each session
        val exerciseType = exerciseRecord.exerciseType
        val notes = exerciseRecord.notes
    }
}

रूट पढ़ना

ExerciseRoute का डेटा, कसरत के सेशन के हिस्से के तौर पर सेव किया जाता है. हालांकि, इसे अलग से पढ़ना होगा. रूट का डेटा पढ़ने के लिए, सेशन के आईडी के साथ getExerciseRoute() तरीके का इस्तेमाल करें:

suspend fun readExerciseRoute(
    healthConnectClient: HealthConnectClient,
    exerciseSessionRecord: ExerciseSessionRecord
) {
    // Check if the session has a route
    val route = healthConnectClient.getExerciseRoute(
        exerciseSessionRecordId = exerciseSessionRecord.metadata.id
    )

    when (route) {
        is ExerciseRouteResponse.Success -> {
            val locations = route.exerciseRoute.locations
            for (location in locations) {
                // Use latitude, longitude, and altitude
            }
        }
        is ExerciseRouteResponse.NoData -> {
            // Handle case where no route exists
        }
        is ExerciseRouteResponse.ConsentRequired -> {
            // Handle case where permissions are missing
        }
    }
}

डेटा टाइप पढ़ना

किसी सेशन के दौरान हुए खास डेटा (जैसे, धड़कन की दर) को पढ़ने के लिए, उस डेटा टाइप के अनुरोध को फ़िल्टर करने के लिए, सेशन के startTime और endTime का इस्तेमाल करें.

suspend fun readHeartRateData(
    healthConnectClient: HealthConnectClient,
    exerciseSession: ExerciseSessionRecord
) {
    val response = healthConnectClient.readRecords(
        ReadRecordsRequest(
            recordType = HeartRateRecord::class,
            timeRangeFilter = TimeRangeFilter.between(
                exerciseSession.startTime,
                exerciseSession.endTime
            )
        )
    )

    for (heartRateRecord in response.records) {
        for (sample in heartRateRecord.samples) {
            val bpm = sample.beatsPerMinute
        }
    }
}

सबसे सही तरीके

डेटा की विश्वसनीयता और उपयोगकर्ता अनुभव को बेहतर बनाने के लिए, इन दिशा-निर्देशों का पालन करें:

  • ऐक्टिव ट्रैकिंग के दौरान, बार-बार डेटा सेव करें: ऐक्टिव ट्रैकिंग के लिए, डेटा उपलब्ध होने पर या ज़्यादा से ज़्यादा 15 मिनट के अंतराल पर डेटा सेव करें.
  • बैकग्राउंड में सिंक करने के लिए, WorkManager का इस्तेमाल करें: डेटा सेव करने में देरी के लिए, WorkManager का इस्तेमाल करें. रीयल-टाइम डेटा और बैटरी की बचत के बीच बैलेंस बनाए रखने के लिए, 15 मिनट का अंतराल रखें.
  • डेटा सेव करने के अनुरोधों को बैच में सेव करें: सेंसर के हर इवेंट को अलग-अलग सेव न करें. अपने अनुरोधों को हिस्सों में बांटें. Health Connect, डेटा सेव करने के हर अनुरोध के लिए, ज़्यादा से ज़्यादा 1,000 रिकॉर्ड मैनेज करता है.
  • सेशन आईडी को स्थिर और यूनीक रखें: अपने सेशन के लिए, एक जैसे आइडेंटिफ़ायर का इस्तेमाल करें. अगर किसी सेशन में बदलाव किया जाता है या उसे अपडेट किया जाता है, तो उसी आईडी का इस्तेमाल करने से, उसे नया और अलग सेशन नहीं माना जाएगा.
  • डेटा टाइप और रूट पॉइंट, दोनों के लिए बैचिंग का इस्तेमाल करें: इनपुट/आउटपुट ओवरहेड को कम करने और बैटरी लाइफ़ को बनाए रखने के लिए, अपने डेटा पॉइंट को अलग-अलग सेव करने के बजाय, उन्हें insertRecords कॉल में ग्रुप करें.
  • डुप्लीकेट डेटा सेव करने से बचें: क्लाइंट आईडी का इस्तेमाल करें: रिकॉर्ड बनाते समय, metadata.clientRecordId सेट करें. Health Connect, यूनीक रिकॉर्ड की पहचान करने के लिए इसका इस्तेमाल करता है. अगर clientRecordId वाला कोई रिकॉर्ड सेव करने की कोशिश की जाती है, तो Health Connect, डुप्लीकेट रिकॉर्ड को अनदेखा कर देगा या नया रिकॉर्ड बनाने के बजाय, मौजूदा रिकॉर्ड को अपडेट कर देगा. सिंक करने की कोशिशों या ऐप्लिकेशन को फिर से इंस्टॉल करने के दौरान, डुप्लीकेट एंट्री से बचने का सबसे असरदार तरीका है कि metadata.clientRecordId सेट किया जाए.
    val record = StepsRecord(
    count = 100,
    startTime = startTime,
    endTime = endTime,
    startZoneOffset = ZoneOffset.UTC,
    endZoneOffset = ZoneOffset.UTC,
    metadata = Metadata(
        // Use a unique ID from your own database
        clientRecordId = "daily_steps_2023_10_27_user_123"
    )
)
  • मौजूदा डेटा की जांच करें: सिंक करने से पहले, समयावधि के बारे में क्वेरी करें. इससे यह पता चलेगा कि आपके ऐप्लिकेशन के रिकॉर्ड पहले से मौजूद हैं या नहीं.
  • जीपीएस की सटीक होने की पुष्टि करें: ExerciseRoute में डेटा सेव करने से पहले, कम सटीक होने वाले जीपीएस सैंपल को फ़िल्टर करें. उदाहरण के लिए, ज़्यादा हॉरिज़ॉन्टल ऐक्युरेसी रेडियस वाले पॉइंट. इससे यह पुष्टि की जा सकेगी कि मैप साफ़ और बेहतर दिख रहा है.
  • पक्का करें कि टाइमस्टैंप ओवरलैप न हों: पुष्टि करें कि नया सेशन, पिछले सेशन के खत्म होने से पहले शुरू न हो. सेशन के ओवरलैप होने से, फ़िटनेस डैशबोर्ड और खास जानकारी की गणना में समस्याएं आ सकती हैं.
  • अनुमति के लिए, साफ़ तौर पर वजहें बताएं: Permission.createIntent फ़्लो का इस्तेमाल करके, यह बताएं कि आपके ऐप्लिकेशन को सेहत से जुड़े डेटा को ऐक्सेस करने की अनुमति क्यों चाहिए. उदाहरण के लिए, 'रक्तचाप के रुझानों पर नज़र रखने और अहम जानकारी देने के लिए.'
  • रोकने और फिर से शुरू करने की सुविधा उपलब्ध कराएं: पुष्टि करें कि आपका ऐप्लिकेशन, रोकने की प्रोसेस को सही तरीके से मैनेज करता है. जब कोई उपयोगकर्ता, सेशन को रोकता है, तो रूट पॉइंट और डेटा टाइप इकट्ठा करना बंद कर दें. इससे औसत रफ़्तार और अवधि सटीक बनी रहेगी.
  • लंबे समय तक चलने वाले सेशन की जांच करें: कई घंटों तक चलने वाले सेशन के दौरान, बैटरी की खपत पर नज़र रखें. इससे यह पुष्टि की जा सकेगी कि बैचिंग का अंतराल और सेंसर के इस्तेमाल से, डिवाइस की बैटरी खत्म नहीं होती.
  • टाइमस्टैंप को सेंसर की दरों के साथ अलाइन करें: डेटा की हाई-फ़िडेलिटी बनाए रखने के लिए, अपने रिकॉर्ड के टाइमस्टैंप को सेंसर की असली फ़्रीक्वेंसी से मैच करें.

जांच करना

डेटा की सटीकता और बेहतर उपयोगकर्ता अनुभव की पुष्टि करने के लिए, जांच की इन रणनीतियों का पालन करें. साथ ही, टेस्ट के सबसे अहम इस्तेमाल के उदाहरणों से जुड़ा आधिकारिक दस्तावेज़ देखें.

पुष्टि करने वाले टूल

  • Health Connect टूलबॉक्स: रिकॉर्ड की मैन्युअल तरीके से जांच करने , टेस्ट डेटा मिटाने, और डेटाबेस में बदलावों को सिम्युलेट करने के लिए, इस साथी ऐप्लिकेशन का इस्तेमाल करें. यह पुष्टि करने का सबसे अच्छा तरीका है कि आपके रिकॉर्ड सही तरीके से सेव किए जा रहे हैं.
  • FakeHealthConnectClient के साथ यूनिट टेस्टिंग: टेस्टिंग लाइब्रेरी का इस्तेमाल करके, यह पुष्टि करें कि आपका ऐप्लिकेशन, मुश्किल स्थितियों को कैसे मैनेज करता है. जैसे, अनुमति रद्द करना या एपीआई से जुड़ी गड़बड़ियां. इसके लिए, किसी फ़िज़िकल डिवाइस की ज़रूरत नहीं होती.

क्वालिटी चेकलिस्ट

आम तौर पर इस्तेमाल होने वाला आर्किटेक्चर

वर्कआउट की सुविधा को लागू करने में, आम तौर पर ये चीज़ें शामिल होती हैं:

कॉम्पोनेंट मैनेज करता है
सेशन कंट्रोलर सेशन की स्थिति
टाइमर
बैचिंग लॉजिक
डेटा टाइप कंट्रोलर
जगह की जानकारी की सैंपलिंग
रिपॉज़िटरी लेयर (Health Connect के ऑपरेशन रैप करती है:) सेशन इंसर्ट करना
डेटा टाइप इंसर्ट करना
रूट पॉइंट इंसर्ट करना
सेशन की खास जानकारी पढ़ना
यूज़र इंटरफ़ेस (यूआई) लेयर (दिखाता है): अवधि
लाइव डेटा टाइप
मैप की झलक
स्प्लिट कैलकुलेशन
लाइव जीपीएस ट्रेस

समस्या हल करना

समस्या का ब्यौरा संभावित कारण रिज़ॉल्यूशन
रूट, सेशन से जुड़ा नहीं है सेशन आईडी या समयावधि में अंतर. पुष्टि करें कि ExerciseRoute को ऐसी समयावधि के साथ सेव किया गया है जो पूरी तरह से ExerciseSessionRecord की अवधि के अंदर आती है. पुष्टि करें कि बाद में सेशन का रेफ़रंस देते समय, एक जैसे आईडी का इस्तेमाल किया जा रहा है. कसरत के रूट रिकॉर्ड करना देखें.
डेटा टाइप मौजूद नहीं हैं. उदाहरण के लिए, धड़कन की दर डेटा सेव करने की अनुमतियां मौजूद नहीं हैं या टाइम फ़िल्टर गलत हैं. पुष्टि करें कि आपने खास डेटा टाइप की अनुमति का अनुरोध किया है और उपयोगकर्ता ने अनुमति दी है. पुष्टि करें कि आपके ReadRecordsRequest में, TimeRangeFilter का इस्तेमाल किया गया है जो सेशन से मेल खाता है. अनुमतियां देखें.
सेशन सेव नहीं हो रहा है टाइमस्टैंप ओवरलैप हो रहे हैं. Health Connect, एक ही ऐप्लिकेशन के मौजूदा डेटा से ओवरलैप होने वाले रिकॉर्ड को अस्वीकार कर सकता है. पुष्टि करें कि नए सेशन का startTime, पिछले सेशन के endTime के बाद का है.
जीपीएस डेटा रिकॉर्ड नहीं किया गया फ़ोरग्राउंड सेवा बंद हो गई है या ऐक्टिव नहीं है. स्क्रीन बंद होने पर डेटा इकट्ठा करने के लिए, आपको फ़ोरग्राउंड सेवा का इस्तेमाल करना होगा. इसमें foregroundServiceType="health" या जगह की जानकारी वाला एट्रिब्यूट होना चाहिए.
डुप्लीकेट रिकॉर्ड दिख रहे हैं clientRecordId मौजूद नहीं है. हर रिकॉर्ड के Metadata में, एक यूनीक clientRecordId असाइन करें. इससे, Health Connect, सिंक करने की कोशिश के दौरान, एक ही डेटा को दो बार सेव किए जाने पर, डुप्लीकेट एंट्री को हटा सकता है. सबसे सही तरीके देखें.

डीबग करने के सामान्य चरण

अनुमति की स्थिति की जांच करें. डेटा पढ़ने या सेव करने की कोशिश करने से पहले, हमेशा getPermissionStatus() को कॉल करें. उपयोगकर्ता, सिस्टम की सेटिंग में जाकर, किसी भी समय अनुमतियां रद्द कर सकते हैं.
एक्ज़ीक्यूशन मोड की पुष्टि करें. अगर आपका ऐप्लिकेशन, बैकग्राउंड में डेटा इकट्ठा नहीं कर रहा है, तो पुष्टि करें कि आपने अपनी AndroidManifest.xml फ़ाइल में सही अनुमतियों का एलान किया है और उपयोगकर्ता ने ऐप्लिकेशन को "बैटरी के इस्तेमाल पर पाबंदी" मोड में नहीं रखा है.