डेटा सेव करने की अनुमति दें

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

इस गाइड में, Health Connect में डेटा सेव करने या अपडेट करने की प्रोसेस के बारे में बताया गया है.

शून्य वैल्यू को मैनेज करना

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

डेटा स्ट्रक्चर सेट अप करना

डेटा लिखने से पहले, हमें रिकॉर्ड सेट अप करने होंगे. 50 से ज़्यादा डेटा टाइप के लिए, हर डेटा टाइप का अपना स्ट्रक्चर होता है. उपलब्ध डेटा टाइप के बारे में ज़्यादा जानने के लिए, Jetpack का रेफ़रंस देखें.

बुनियादी रिकॉर्ड

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

यहां दिए गए उदाहरण में, कदमों की संख्या का डेटा सेट करने का तरीका बताया गया है:

val zoneOffset = ZoneOffset.systemDefault().rules.getOffset(startTime)
val stepsRecord = StepsRecord(
    count = 120,
    startTime = startTime,
    endTime = endTime,
    startZoneOffset = zoneOffset,
    endZoneOffset = zoneOffset,
    metadata = Metadata(
        device = Device(type = Device.TYPE_WATCH),
        recordingMethod = Metadata.RECORDING_METHOD_AUTOMATICALLY_RECORDED
    )
)
healthConnectClient.insertRecords(listOf(stepsRecord))
HealthConnectManager.kt

माप की इकाइयों वाले रिकॉर्ड

Health Connect, वैल्यू को मेज़रमेंट की इकाइयों के साथ सेव कर सकता है, ताकि सटीक जानकारी दी जा सके. इसका एक उदाहरण, पोषण डेटा टाइप है. यह बहुत बड़ा और पूरी जानकारी देने वाला होता है. इसमें पोषक तत्वों के कई वैकल्पिक फ़ील्ड शामिल होते हैं. जैसे, कुल कार्बोहाइड्रेट से लेकर विटामिन तक. हर डेटा पॉइंट, उन पोषक तत्वों को दिखाता है जो किसी भोजन या खाने की चीज़ के हिस्से के तौर पर लिए गए थे.

इस डेटा टाइप में, सभी पोषक तत्वों को मास की इकाइयों में दिखाया जाता है. वहीं, energy को ऊर्जा की इकाई में दिखाया जाता है.

यहां दिए गए उदाहरण में, उस व्यक्ति के लिए पोषण का डेटा सेट करने का तरीका बताया गया है जिसने केला खाया है:

val endTime = Instant.now()
val startTime = endTime.minus(Duration.ofMinutes(1))

val banana = NutritionRecord(
    name = "banana",
    energy = 105.0.kilocalories,
    dietaryFiber = 3.1.grams,
    potassium = 0.422.grams,
    totalCarbohydrate = 27.0.grams,
    totalFat = 0.4.grams,
    saturatedFat = 0.1.grams,
    sodium = 0.001.grams,
    sugar = 14.0.grams,
    vitaminB6 = 0.0005.grams,
    vitaminC = 0.0103.grams,
    startTime = startTime,
    endTime = endTime,
    startZoneOffset = ZoneOffset.UTC,
    endZoneOffset = ZoneOffset.UTC,
    metadata = Metadata(
        device = Device(type = Device.TYPE_PHONE)
    )
)
HealthConnectManager.kt

सीरीज़ के डेटा वाले रिकॉर्ड

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

इस डेटा टाइप में, पैरामीटर samples को हार्ट रेट के सैंपल की सूची के तौर पर दिखाया जाता है. हर सैंपल में एक beatsPerMinute वैल्यू और एक time वैल्यू होती है.

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

val endTime = Instant.now()
val startTime = endTime.minus(Duration.ofMinutes(5))

val heartRateRecord = HeartRateRecord(
    startTime = startTime,
    startZoneOffset = ZoneOffset.UTC,
    endTime = endTime,
    endZoneOffset = ZoneOffset.UTC,
    // records 10 arbitrary data, to replace with actual data
    samples = List(10) { index ->
        HeartRateRecord.Sample(
            time = startTime + Duration.ofSeconds(index.toLong()),
            beatsPerMinute = 100 + index.toLong(),
        )
    },
    metadata = Metadata(
        device = Device(type = Device.TYPE_WATCH)
    ))
HealthConnectManager.kt

उपयोगकर्ता से अनुमतियों का अनुरोध करना

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

val permissions =
    setOf(
        HealthPermission.getReadPermission(HeartRateRecord::class),
        HealthPermission.getWritePermission(HeartRateRecord::class),
        HealthPermission.getReadPermission(StepsRecord::class),
        HealthPermission.getWritePermission(StepsRecord::class)
    )
HealthConnectManager.kt

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.") }
    }
}
HealthConnectActivity.kt

डेटा सेव करने की अनुमति दें

Health Connect में डेटा सेव करना एक सामान्य वर्कफ़्लो है. रिकॉर्ड जोड़ने के लिए, insertRecords का इस्तेमाल करें.

यहां दिए गए उदाहरण में, कदमों की संख्या डालने का तरीका बताया गया है:

val zoneOffset = ZoneOffset.systemDefault().rules.getOffset(startTime)
val stepsRecord = StepsRecord(
    count = 120,
    startTime = startTime,
    endTime = endTime,
    startZoneOffset = zoneOffset,
    endZoneOffset = zoneOffset,
    metadata = Metadata(
        device = Device(type = Device.TYPE_WATCH),
        recordingMethod = Metadata.RECORDING_METHOD_AUTOMATICALLY_RECORDED
    )
)
healthConnectClient.insertRecords(listOf(stepsRecord))
HealthConnectManager.kt

डेटा अपडेट करना

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

मेटाडेटा

सबसे पहले Metadata क्लास की जांच करना ज़रूरी है, क्योंकि डेटा अपडेट करते समय इसकी ज़रूरत पड़ती है. Health Connect में हर Record बनाते समय, उसमें metadata फ़ील्ड होता है. सिंक करने के लिए, यहां दी गई प्रॉपर्टी काम की हैं:

समयसीमा के हिसाब से पढ़े गए लेखों के बाद अपडेट करना

डेटा अपडेट करने के लिए, सबसे पहले ज़रूरी रिकॉर्ड तैयार करें. अगर ज़रूरी हो, तो रिकॉर्ड में बदलाव करें. इसके बाद, बदलाव करने के लिए updateRecords पर कॉल करें.

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

suspend fun updateSteps(
    healthConnectClient: HealthConnectClient,
    prevRecordStartTime: Instant,
    prevRecordEndTime: Instant
) {
    try {
        val request = healthConnectClient.readRecords(
            ReadRecordsRequest(
                recordType = StepsRecord::class, timeRangeFilter = TimeRangeFilter.between(
                    prevRecordStartTime,
                    prevRecordEndTime
                )
            )
        )

        val newStepsRecords = arrayListOf<StepsRecord>()
        for (record in request.records) {
            // Adjusted both offset values to reflect changes
            val sr = StepsRecord(
                count = record.count,
                startTime = record.startTime,
                startZoneOffset = record.startTime.atZone(ZoneId.of("PST")).offset,
                endTime = record.endTime,
                endZoneOffset = record.endTime.atZone(ZoneId.of("PST")).offset,
                metadata = record.metadata
            )
            newStepsRecords.add(sr)
        }

        healthConnectClient.updateRecords(newStepsRecords)
    } catch (e: Exception) {
        // Run error handling here
    }
}
HealthConnectManager.kt

क्लाइंट रिकॉर्ड आईडी के ज़रिए अपसर्ट करना

अगर आपने क्लाइंट रिकॉर्ड आईडी और क्लाइंट रिकॉर्ड वर्शन की वैकल्पिक वैल्यू का इस्तेमाल किया है, तो हमारा सुझाव है कि updateRecords के बजाय insertRecords का इस्तेमाल करें.

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

यहां दिए गए उदाहरण में, ऐप्लिकेशन के डेटास्टोर से पुल किए गए डेटा पर अपसर्ट करने का तरीका बताया गया है:

 fun pullStepsFromDatastore(startTime: Instant, endTime: Instant) : ArrayList<StepsRecord> {
    val appStepsRecords = arrayListOf<StepsRecord>()
    // Pull data from app datastore
    // ...
    // Make changes to data if necessary
    // ...
    // Store data in appStepsRecords
    // ...
    var sr = StepsRecord(
        metadata = Metadata(
            clientRecordId = "Your client record ID",
            device = Device(type = Device.TYPE_WATCH)
        ),
        startTime = startTime,
        startZoneOffset = startTime.atZone(ZoneId.of("PST")).offset,
        endTime = endTime,
        endZoneOffset = endTime.atZone(ZoneId.of("PST")).offset,
        count = 120
    )
    appStepsRecords.add(sr)
    // ...
    return appStepsRecords
}

suspend fun upsertSteps(
    healthConnectClient: HealthConnectClient,
    newStepsRecords: ArrayList<StepsRecord>
) {
    try {
        healthConnectClient.insertRecords(newStepsRecords)
    } catch (e: Exception) {
        // Run error handling here
    }
}
HealthConnectManager.kt

इसके बाद, इन फ़ंक्शन को अपनी मुख्य थ्रेड में कॉल किया जा सकता है.

upsertSteps(healthConnectClient, pullStepsFromDatastore(
    startTime = startTime,
    endTime = endTime
))
HealthConnectManager.kt

क्लाइंट रिकॉर्ड वर्शन में वैल्यू की जांच करना

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

अपने डेटा में वर्शनिंग शामिल करने के लिए, आपको Metadata.clientRecordVersion एट्रिब्यूट की वैल्यू देनी होगी. यह वैल्यू, वर्शनिंग के लॉजिक के आधार पर Long एट्रिब्यूट की वैल्यू से मेल खानी चाहिए.

val endTime = Instant.now()
val startTime = endTime.minus(Duration.ofMinutes(15))

val stepsRecord = StepsRecord(
    count = 100L,
    startTime = startTime,
    startZoneOffset = ZoneOffset.UTC,
    endTime = endTime,
    endZoneOffset = ZoneOffset.UTC,
    metadata = Metadata(
        clientRecordId = "Your supplied record ID",
        clientRecordVersion = 0L, // Your supplied record version
        device = Device(type = Device.TYPE_WATCH)
    )
)
HealthConnectManager.kt

बदलाव होने पर, अपसर्ट अपने-आप version को नहीं बढ़ाता. इससे डेटा को अनचाहे तरीके से ओवरराइट होने से रोका जा सकता है. इसके लिए, आपको मैन्युअल तरीके से ज़्यादा वैल्यू देनी होगी.

सामान्य दिशा-निर्देश

आपके ऐप्लिकेशन को, पहले पक्ष (ग्राहक) का सारा डेटा सेव करना चाहिए. आपके पास यह विकल्प होता है कि आपका ऐप्लिकेशन, तीसरे पक्ष के सोर्स से मिला डेटा सेव करे. हालांकि, अगर आपके ऐप्लिकेशन ने Health Connect से डेटा ऐक्सेस किया है, तो उस डेटा को वापस Health Connect में सेव नहीं किया जाना चाहिए.

किसी दूसरे सोर्स से इंपोर्ट किए गए या उससे लिए गए डेटा को लिखते समय, आपको उसके ओरिजन और सोर्स डिवाइस के मेटाडेटा को सही तरीके से एट्रिब्यूट करना होगा. इसके लिए, आपको हर लिखित रिकॉर्ड के लिए यह मेटाडेटा देना होगा:

• recordingMethod: अपने-आप या मैन्युअल तरीके से रिकॉर्ड किए गए डेटा के लिए, हम चाहते हैं कि रिकॉर्डिंग के तरीके को अपडेट किया जाए, ताकि रिकॉर्ड की गई गतिविधि का टाइप दिखे:
  • RECORDING_METHOD_AUTOMATICALLY_RECORDED: अगर डेटा अपने-आप रिकॉर्ड हुआ है. उदाहरण के लिए, फ़िटनेस बैंड ने अपने-आप पता लगाया कि उपयोगकर्ता दौड़ने गया था.
  • RECORDING_METHOD_ACTIVELY_RECORDED: अगर उपयोगकर्ता ने कोई नई गतिविधि शुरू की है, जैसे कि पहने जाने वाले डिवाइस पर साइकल चलाना.
  • RECORDING_METHOD_MANUAL_ENTRY: अगर उपयोगकर्ता ने डेटा मैन्युअल तरीके से डाला है.
• device.type: आपको Device के साथ काम करने वाले टाइप में से किसी एक टाइप का डिवाइस चुनना होगा.
• device.manufacturer: डिवाइस बनाने वाली कंपनी का नाम. उदाहरण के लिए, "Fitbit".
• device.model: डिवाइस का मॉडल. उदाहरण के लिए, "Charge 3".

मेटाडेटा को सही तरीके से सेट करना, डेटा की पारदर्शिता के लिए ज़रूरी है. इससे लोगों को यह समझने में मदद मिलती है कि उनकी सेहत से जुड़ी जानकारी कहां से ली गई है. पूरी जानकारी के लिए, Health Connect के मेटाडेटा से जुड़ी गाइड देखें.

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

ऐसा लॉजिक लागू करना भी एक अच्छा तरीका है जो लिखने से जुड़ी गड़बड़ियों को ठीक कर सके. जैसे, डेटा का तय सीमा से बाहर होना या सिस्टम में गड़बड़ी होना. जॉब शेड्यूल करने के तरीके पर, बैकऑफ़ और फिर से कोशिश करने की रणनीतियां लागू की जा सकती हैं. अगर Health Connect में डेटा नहीं लिखा जा सका, तो पक्का करें कि आपका ऐप्लिकेशन एक्सपोर्ट के उस पॉइंट से आगे बढ़ सके. गड़बड़ियों का पता लगाने के लिए, उन्हें लॉग और रिपोर्ट करना न भूलें.

डेटा ट्रैक करते समय, यहां कुछ सुझाव दिए गए हैं. इन्हें अपने ऐप्लिकेशन के डेटा लिखने के तरीके के हिसाब से फ़ॉलो किया जा सकता है.

टाइम ज़ोन मैनेज करना

समय के हिसाब से रिकॉर्ड लिखते समय, डिफ़ॉल्ट रूप से zoneOffset.UTC पर ऑफ़सेट सेट न करें. ऐसा इसलिए, क्योंकि जब उपयोगकर्ता अन्य ज़ोन में होते हैं, तो इससे टाइमस्टैंप गलत हो सकते हैं. इसके बजाय, डिवाइस की मौजूदा जगह के हिसाब से ऑफ़सेट का हिसाब लगाएं. ZoneId.systemDefault() का इस्तेमाल करके, डिवाइस का टाइम ज़ोन वापस पाया जा सकता है.

val endTime = Instant.now()
val startTime = endTime.minus(Duration.ofDays(1))
val stepsRecords = mutableListOf<StepsRecord>()
var sampleTime = startTime
val minutesBetweenSamples = 15L
while (sampleTime < endTime) {
    // Get the default ZoneId then convert it to an offset
    val zoneOffset = ZoneOffset.systemDefault().rules.getOffset(sampleTime)
    stepsRecords += StepsRecord(
        startTime = sampleTime.minus(Duration.ofMinutes(minutesBetweenSamples)),
        startZoneOffset = zoneOffset,
        endTime = sampleTime,
        endZoneOffset = zoneOffset,
        count = Random.nextLong(1, 100),
        metadata = Metadata(),
    )
    sampleTime = sampleTime.plus(Duration.ofMinutes(minutesBetweenSamples))
}
healthConnectClient.insertRecords(
    stepsRecords
)
HealthConnectManager.kt

ज़्यादा जानकारी के लिए, ZoneId के लिए दस्तावेज़ देखें.

फ़्रीक्वेंसी और जानकारी का लेवल लिखना

Health Connect में डेटा सेव करते समय, सही रिज़ॉल्यूशन का इस्तेमाल करें. सही रिज़ॉल्यूशन का इस्तेमाल करने से, स्टोरेज पर पड़ने वाला लोड कम हो जाता है. साथ ही, इससे सटीक और एक जैसा डेटा बनाए रखने में मदद मिलती है. डेटा रिज़ॉल्यूशन में दो चीज़ें शामिल होती हैं:

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

दूसरे दिशा-निर्देश

डेटा लिखते समय इन दिशा-निर्देशों का पालन करें:

• हर सिंक पर, सिर्फ़ नया डेटा और अपडेट किया गया वह डेटा लिखें जिसमें पिछले सिंक के बाद से बदलाव किया गया है.
• हर अनुरोध में ज़्यादा से ज़्यादा 1,000 रिकॉर्ड शामिल करें.
• टास्क को सिर्फ़ तब चलने की अनुमति दें, जब डिवाइस कुछ समय से इस्तेमाल में न हो और उसकी बैटरी कम न हो.
• बैकग्राउंड टास्क के लिए, WorkManager का इस्तेमाल करके, समय-समय पर होने वाले टास्क शेड्यूल करें. इसके लिए, ज़्यादा से ज़्यादा 15 मिनट की समयावधि तय करें.

यहां दिए गए कोड में, WorkManager का इस्तेमाल करके बैकग्राउंड में होने वाले टास्क को शेड्यूल किया गया है. इसमें ज़्यादा से ज़्यादा 15 मिनट की समयावधि और पांच मिनट का फ़्लेक्स इंटरवल दिया गया है. इस कॉन्फ़िगरेशन को PeriodicWorkRequest.Builder क्लास का इस्तेमाल करके सेट किया जाता है.

val constraints = Constraints.Builder()
    .requiresBatteryNotLow()
    .requiresDeviceIdle(true)
    .build()

val writeDataWork = PeriodicWorkRequestBuilder<WriteDataToHealthConnectWorker>(
        15,
        TimeUnit.MINUTES,
        5,
        TimeUnit.MINUTES
    )
    .setConstraints(constraints)
    .build()

ऐक्टिव ट्रैकिंग

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

पुष्टि करें कि आपका ऐप्लिकेशन, इवेंट की पूरी अवधि के दौरान Health Connect को चालू नहीं रखता है.

डेटा को Health Connect में दो में से किसी एक तरीके से सेव किया जाना चाहिए:

• इवेंट पूरा होने के बाद, Health Connect के साथ डेटा सिंक करें. उदाहरण के लिए, जब उपयोगकर्ता ट्रैक की गई कसरत का सेशन खत्म करता है, तब डेटा सिंक करें.
• डेटा को बाद में सिंक करने के लिए, WorkManager का इस्तेमाल करके, एक बार होने वाले टास्क को शेड्यूल करें.

डेटा लिखने की फ़्रीक्वेंसी और ग्रेन्यूलैरिटी के लिए सबसे सही तरीके

Health Connect में डेटा सेव करते समय, सही रिज़ॉल्यूशन का इस्तेमाल करें. सही रिज़ॉल्यूशन का इस्तेमाल करने से, स्टोरेज पर पड़ने वाला लोड कम हो जाता है. साथ ही, इससे सटीक और एक जैसा डेटा बनाए रखने में मदद मिलती है. डेटा रिज़ॉल्यूशन में दो चीज़ें शामिल होती हैं:

1. डेटा लिखने की फ़्रीक्वेंसी: आपका ऐप्लिकेशन, Health Connect में कितनी बार नया डेटा भेजता है. नया डेटा उपलब्ध होने पर, डिवाइस की परफ़ॉर्मेंस को ध्यान में रखते हुए, डेटा को ज़्यादा से ज़्यादा बार लिखें. बैटरी लाइफ़ और परफ़ॉर्मेंस से जुड़े अन्य पहलुओं पर बुरा असर न पड़े, इसके लिए राइट के बीच ज़्यादा से ज़्यादा 15 मिनट का अंतराल होना चाहिए.

2. लिखे गए डेटा की बारीकी: पुश किए गए डेटा को कितनी बार सैंपल किया गया. उदाहरण के लिए, हर पांच सेकंड में धड़कन की दर के सैंपल लिखें. हर डेटा टाइप के लिए, सैंपल लेने की दर एक जैसी नहीं होती. हर सेकंड में कदमों की संख्या का डेटा अपडेट करने से ज़्यादा फ़ायदा नहीं होता. इसके बजाय, हर 60 सेकंड में अपडेट करने से ज़्यादा फ़ायदा होता है. हालांकि, सैंपल लेने की दर ज़्यादा होने से, उपयोगकर्ताओं को सेहत और फ़िटनेस से जुड़े डेटा के बारे में ज़्यादा जानकारी मिल सकती है. सैंपल लेने की दर की फ़्रीक्वेंसी, जानकारी और परफ़ॉर्मेंस के बीच संतुलन बनाए रखनी चाहिए.

सीरीज़ के डेटा के लिए रिकॉर्ड स्ट्रक्चर करना

HeartRateRecord जैसे डेटा टाइप के लिए, सैंपल की सीरीज़ का इस्तेमाल किया जाता है. इसलिए, अपने रिकॉर्ड को सही तरीके से स्ट्रक्चर करना ज़रूरी है. पूरे दिन का एक ऐसा रिकॉर्ड बनाने के बजाय जिसे लगातार अपडेट किया जाता है, आपको कई छोटे-छोटे रिकॉर्ड बनाने चाहिए. हर रिकॉर्ड में एक खास समयावधि की जानकारी होनी चाहिए.

उदाहरण के लिए, धड़कन की दर के डेटा के लिए, आपको हर मिनट के लिए एक नया HeartRateRecord बनाना चाहिए. हर रिकॉर्ड में, उस मिनट की शुरुआत और खत्म होने का समय होगा. साथ ही, उस मिनट के दौरान कैप्चर किए गए धड़कन की दर के सभी सैंपल शामिल होंगे.

Health Connect के साथ नियमित तौर पर सिंक करने के दौरान (उदाहरण के लिए, हर 15 मिनट में), आपके ऐप्लिकेशन को एक मिनट के उन सभी रिकॉर्ड को लिखना चाहिए जो पिछली बार सिंक करने के बाद बनाए गए हैं. इससे रिकॉर्ड को मैनेज किया जा सकता है. साथ ही, क्वेरी करने और डेटा को प्रोसेस करने की परफ़ॉर्मेंस को बेहतर बनाया जा सकता है.

यहां दिए गए उदाहरण में, एक मिनट के लिए HeartRateRecord बनाने का तरीका बताया गया है. इसमें कई सैंपल शामिल हैं:

val startTime = Instant.now().truncatedTo(ChronoUnit.MINUTES)
val endTime = startTime.plus(Duration.ofMinutes(1))

val heartRateRecord = HeartRateRecord(
    startTime = startTime,
    startZoneOffset = ZoneOffset.UTC,
    endTime = endTime,
    endZoneOffset = ZoneOffset.UTC,
    // Create a new record every minute, containing a list of samples.
    samples = listOf(
        HeartRateRecord.Sample(
            time = startTime + Duration.ofSeconds(15),
            beatsPerMinute = 80,
        ),
        HeartRateRecord.Sample(
            time = startTime + Duration.ofSeconds(30),
            beatsPerMinute = 82,
        ),
        HeartRateRecord.Sample(
            time = startTime + Duration.ofSeconds(45),
            beatsPerMinute = 85,
        )
    ),
    metadata = Metadata(
        device = Device(type = Device.TYPE_WATCH)
    ))
HealthConnectManager.kt

पूरे दिन मॉनिटर किए गए डेटा को लिखने की अनुमति दें

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

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

पुष्टि करें कि आपका ऐप्लिकेशन, इवेंट की पूरी अवधि के दौरान Health Connect को चालू नहीं रखता है.

डेटा को Health Connect में दो में से किसी एक तरीके से सेव किया जाना चाहिए:

• इवेंट पूरा होने के बाद, Health Connect के साथ डेटा सिंक करें. उदाहरण के लिए, जब उपयोगकर्ता ट्रैक की गई कसरत का सेशन खत्म करता है, तब डेटा सिंक करें.
• डेटा को बाद में सिंक करने के लिए, WorkManager का इस्तेमाल करके एक बार होने वाला टास्क शेड्यूल करें.

कसरत और नींद के सेशन

कम से कम, आपके ऐप्लिकेशन में टेबल 2 के अनुमानित कॉलम में दिए गए दिशा-निर्देशों का पालन किया जाना चाहिए. जहां भी हो सके, सबसे सही कॉलम में दिए गए दिशा-निर्देशों का पालन करें.

यहां दी गई टेबल में बताया गया है कि कसरत के दौरान डेटा कैसे लिखा जाता है:

तीसरी टेबल में, नींद के सेशन के दौरान या उसके बाद डेटा लिखने का तरीका बताया गया है:

मल्टी-स्पोर्ट इवेंट

इस तरीके में, मौजूदा डेटा टाइप और स्ट्रक्चर का इस्तेमाल किया जाता है. साथ ही, यह पुष्टि की जाती है कि यह तरीका, Health Connect के मौजूदा वर्शन और डेटा रीडर के साथ काम करता है या नहीं. फ़िटनेस प्लैटफ़ॉर्म आम तौर पर इसी तरीके का इस्तेमाल करते हैं.

इसके अलावा, तैराकी, साइकल चलाना, और दौड़ने जैसे अलग-अलग सेशन, Health Connect में अपने-आप लिंक नहीं होते. डेटा रीडर को इन सेशन के बीच के संबंध का पता, इनके समय के हिसाब से लगाना होता है. सेगमेंट के बीच ट्रांज़िशन, जैसे कि तैरने से साइकल चलाने तक के ट्रांज़िशन को साफ़ तौर पर नहीं दिखाया गया है.

यहां दिए गए उदाहरण में, ट्रायथलॉन के लिए डेटा लिखने का तरीका बताया गया है:

val swimStartTime = Instant.parse("2024-08-22T08:00:00Z")
val swimEndTime = Instant.parse("2024-08-22T08:30:00Z")
val bikeStartTime = Instant.parse("2024-08-22T08:40:00Z")
val bikeEndTime = Instant.parse("2024-08-22T09:40:00Z")
val runStartTime = Instant.parse("2024-08-22T09:50:00Z")
val runEndTime = Instant.parse("2024-08-22T10:20:00Z")

val swimSession = ExerciseSessionRecord(
    startTime = swimStartTime,
    endTime = swimEndTime,
    exerciseType = ExerciseSessionRecord.EXERCISE_TYPE_SWIMMING_OPEN_WATER,
    metadata = Metadata(
        device = Device(type = Device.TYPE_WATCH)
    ),
    startZoneOffset = null,
    endZoneOffset = null,
)

val bikeSession = ExerciseSessionRecord(
    startTime = bikeStartTime,
    endTime = bikeEndTime,
    exerciseType = ExerciseSessionRecord.EXERCISE_TYPE_BIKING,
    metadata = Metadata(
        device = Device(type = Device.TYPE_WATCH)
    ),
    startZoneOffset = null,
    endZoneOffset = null,
)

val runSession = ExerciseSessionRecord(
    startTime = runStartTime,
    endTime = runEndTime,
    exerciseType = ExerciseSessionRecord.EXERCISE_TYPE_RUNNING,
    metadata = Metadata(
        device = Device(type = Device.TYPE_WATCH)
    ),
    startZoneOffset = null,
    endZoneOffset = null,
)

healthConnectClient.insertRecords(listOf(swimSession, bikeSession, runSession))
HealthConnectManager.kt

गड़बड़ियों को ठीक करना

जब कोई समस्या आती है, तो Health Connect, CRUD ऑपरेशनों के लिए स्टैंडर्ड अपवाद दिखाता है. आपका ऐप्लिकेशन, इनमें से हर अपवाद को सही तरीके से पकड़ना और हैंडल करना चाहिए.

HealthConnectClient पर मौजूद हर तरीके में, थ्रो किए जा सकने वाले अपवादों की सूची होती है. आम तौर पर, आपके ऐप्लिकेशन को इन अपवादों को हैंडल करना चाहिए: