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

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

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

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

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

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

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

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

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

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

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

val stepsRecord = StepsRecord(
    count = 120,
    startTime = startTime,
    endTime = endTime,
    startZoneOffset = ZoneOffset.UTC,
    endZoneOffset = ZoneOffset.UTC,
    metadata = Metadata.autoRecorded(
        device = Device(type = Device.TYPE_WATCH)
    )
)

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

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

इस डेटा टाइप में, सभी पोषक तत्वों को Mass की इकाइयों में दिखाया जाता है. वहीं, energy को 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.manualEntry(
        device = Device(type = Device.TYPE_PHONE)
    )
)

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

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.autoRecorded(
        device = Device(type = Device.TYPE_WATCH)
    ))

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

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

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

// Create a set of permissions for required data types
val PERMISSIONS =
    setOf(
  HealthPermission.getReadPermission(HeartRateRecord::class),
  HealthPermission.getWritePermission(HeartRateRecord::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)
  }
}

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

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

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

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

suspend fun insertSteps(healthConnectClient: HealthConnectClient) {
    val endTime = Instant.now()
    val startTime = endTime.minus(Duration.ofMinutes(5))
    try {
        val stepsRecord = StepsRecord(
            count = 120,
            startTime = startTime,
            endTime = endTime,
            startZoneOffset = ZoneOffset.UTC,
            endZoneOffset = ZoneOffset.UTC,
            metadata = Metadata.autoRecorded(
                device = Device(type = Device.TYPE_WATCH)
            )
        )
        healthConnectClient.insertRecords(listOf(stepsRecord))
    } catch (e: Exception) {
        // Run error handling here
    }
}

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

अगर आपको एक या उससे ज़्यादा रिकॉर्ड में बदलाव करना है, तो डेटा अपडेट किया जा सकता है. ऐसा खास तौर पर तब करें, जब आपको अपने ऐप्लिकेशन के डेटा स्टोर को 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
    }
}

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

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

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

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

suspend fun pullStepsFromDatastore() : 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.autoRecorded(
            clientRecordId = "Your client record ID",
            device = Device(type = Device.TYPE_WATCH)
        ),
        // Assign more parameters for this record
    )
    appStepsRecords.add(sr)
    // ...
    return appStepsRecords
}

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

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

upsertSteps(healthConnectClient, pullStepsFromDatastore())

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

अगर डेटा को अपडेट करने की प्रोसेस में क्लाइंट रिकॉर्ड वर्शन शामिल है, तो 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.manualEntry(
        clientRecordId = "Your supplied record ID",
        clientRecordVersion = 0L, // Your supplied record version
        device = Device(type = Device.TYPE_WATCH)
    )
)

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

डेटा लिखने के सबसे सही तरीके

ऐप्लिकेशन को सिर्फ़ अपने सोर्स से मिले डेटा को Health Connect में सेव करना चाहिए.

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

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

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

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

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

val endTime = Instant.now()
val startTime = endTime.minus(java.time.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(java.time.Duration.ofMinutes(minutesBetweenSamples)),
        startZoneOffset = zoneOffset,
        endTime = sampleTime,
        endZoneOffset = zoneOffset,
        count = Random.nextLong(1, 100),
        metadata = Metadata.unknownRecordingMethod(),
    )
    sampleTime = sampleTime.plus(java.time.Duration.ofMinutes(minutesBetweenSamples))
}
healthConnectClient.insertRecords(
    stepsRecords
)

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

पैसिव ट्रैकिंग

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

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

इन दिशा-निर्देशों का पालन करें:

• हर सिंक पर, सिर्फ़ नया डेटा और अपडेट किया गया वह डेटा लिखें जिसमें पिछले सिंक के बाद से बदलाव किया गया है.
• हर अनुरोध में ज़्यादा से ज़्यादा 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.autoRecorded(
        device = Device(type = Device.TYPE_WATCH)
    ))

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

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

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

कसरत या नींद के सेशन के खत्म होने के बाद, 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.autoRecorded(
      device = Device(type = Device.TYPE_WATCH)
    )
)

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

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

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