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 में अलग रिकॉर्ड के तौर पर नहीं माना जाता. इसके बजाय, ExerciseRoute को डालने या अपडेट करने के दौरान ExerciseRoute डेटा दिया जाता है.ExerciseSessionRecord

डेवलपमेंट से जुड़ी बातें

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

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

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

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

सभी राइट ऑपरेशन के लिए एक ही सेशन आईडी का इस्तेमाल करके, सेशन को जारी रखें.

अनुमतियां

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

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

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

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

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

// Create a set of permissions for required data types
val PERMISSIONS =
    setOf(
  HealthPermission.getReadPermission(ExerciseSessionRecord::class),
  HealthPermission.getWritePermission(ExerciseSessionRecord::class),
  HealthPermission.getReadPermission(ExerciseRoute::class),
  HealthPermission.getWritePermission(ExerciseRoute::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 की अनुमतियों वाली स्क्रीन दिखती है.

// Create the permissions launcher
val requestPermissionActivityContract = PermissionController.createRequestPermissionResultContract()

val requestPermissions = registerForActivityResult(requestPermissionActivityContract) { granted ->
  if (granted.containsAll(PERMISSIONS)) {
    // Permissions successfully granted
  } else {
    // Lack of required permissions
  }
}

suspend fun checkPermissionsAndRun(healthConnectClient: HealthConnectClient) {
  val granted = healthConnectClient.permissionController.getGrantedPermissions()
  if (granted.containsAll(PERMISSIONS)) {
    // Permissions already granted; proceed with inserting or reading data
  } else {
    requestPermissions.launch(PERMISSIONS)
  }
}

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

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

if (!granted.containsAll(PERMISSIONS)) {
    requestPermissions.launch(PERMISSIONS)
    // Check if required permissions are not granted, and return
  }
// 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 sessionId = UUID.randomUUID().toString()
val sessionClientId = UUID.randomUUID().toString()

val session = ExerciseSessionRecord(
    id = sessionId,
    exerciseType = ExerciseType.EXERCISE_TYPE_RUNNING,
    startTime = Instant.now(),
    endTime = null,
    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 का इस्तेमाल करें. रीयल-टाइम डेटा और बैटरी की परफ़ॉर्मेंस के बीच संतुलन बनाए रखने के लिए, 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 फ़्लो का इस्तेमाल करके बताएं कि आपके ऐप्लिकेशन को स्वास्थ्य से जुड़े डेटा का ऐक्सेस क्यों चाहिए. जैसे, "आपकी दौड़ को मैप करने और खर्च हुई कैलोरी का हिसाब लगाने के लिए."

  • रोकने और फिर से शुरू करने की सुविधा: पुष्टि करें कि आपका ऐप्लिकेशन, वीडियो को रोकने और फिर से शुरू करने की सुविधा को सही तरीके से हैंडल करता है. जब कोई उपयोगकर्ता गतिविधि को रोकता है, तो रूट पॉइंट और डेटा टाइप इकट्ठा करना बंद कर दें, ताकि औसत गति और अवधि सटीक बनी रहे.

  • लंबे समय तक चलने वाले सेशन की जांच करें: कई घंटों तक चलने वाले सेशन के दौरान बैटरी की खपत पर नज़र रखें. इससे यह पुष्टि की जा सकेगी कि बैचिंग इंटरवल और सेंसर के इस्तेमाल से, डिवाइस की बैटरी खत्म नहीं होती.

  • टाइमस्टैंप को सेंसर की दरों के साथ अलाइन करें: अपने रिकॉर्ड के टाइमस्टैंप को सेंसर की फ़्रीक्वेंसी (उदाहरण के लिए, जीपीएस के लिए 1 हर्ट्ज़) से मैच करें, ताकि डेटा की क्वालिटी अच्छी बनी रहे.

टेस्ट करना

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

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

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

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

सामान्य आर्किटेक्चर

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

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

समस्या का हल

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

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

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