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

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

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

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

मूल रिकॉर्ड

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

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

val stepsRecord = StepsRecord(
    count = 120,
    startTime = START_TIME,
    endTime = END_TIME,
    startZoneOffset = START_ZONE_OFFSET,
    endZoneOffset = END_ZONE_OFFSET
)

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

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

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

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

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 = START_TIME,
    endTime = END_TIME,
    startZoneOffset = START_ZONE_OFFSET,
    endZoneOffset = END_ZONE_OFFSET
)

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

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

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

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

val heartRateRecord = HeartRateRecord(
    startTime = START_TIME,
    startZoneOffset = START_ZONE_OFFSET,
    endTime = END_TIME,
    endZoneOffset = END_ZONE_OFFSET,
    // records 10 arbitrary data, to replace with actual data
    samples = List(10) { index ->
        HeartRateRecord.Sample(
            time = START_TIME + Duration.ofSeconds(index.toLong()),
            beatsPerMinute = 100 + index.toLong(),
        )
    }
)

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

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

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

suspend fun insertSteps(healthConnectClient: HealthConnectClient) {
    try {
        val stepsRecord = StepsRecord(
            count = 120,
            startTime = START_TIME,
            endTime = END_TIME,
            startZoneOffset = START_ZONE_OFFSET,
            endZoneOffset = END_ZONE_OFFSET
        )
        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)
        }

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

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

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

insertRecords फ़ंक्शन में डेटा को इकट्ठा करने की सुविधा है. अगर 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(
        // Assign parameters for this record
        metadata = Metadata(
            clientRecordId = cid
        )
    )
    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 कनेक्ट, clientRecordVersion में तुलना की जांच करता है वैल्यू. यदि शामिल किए गए डेटा का वर्शन एक वर्शन है, तो कार्रवाई होगी. अगर ऐसा नहीं है, तो प्रोसेस परिवर्तन को अनदेखा कर देता है और मान वही रहता है.

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

val sr = StepsRecord(
    count = count,
    startTime = startTime,
    startZoneOffset = startZoneOffset,
    endTime = endTime,
    endZoneOffset = endZoneOffset,
    metadata = Metadata(
        clientRecordId = cid,
        clientRecordVersion = version
    )
)

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

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

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

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

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

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

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

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

आपके ऐप्लिकेशन को Health Connect में समय-समय पर डेटा इकट्ठा करना होगा. इन तरीकों से मदद पाएं:

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

• टास्क को सिर्फ़ तब चलाएं, जब डिवाइस कुछ समय से इस्तेमाल में न हो और चालू न हो बैटरी.

  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. लिखे हुए डेटा की पूरी जानकारी: कितनी बार पुश किया गया डेटा सैंपल के तौर पर मौजूद है. उदाहरण के लिए, हर 5 सेकंड में धड़कन की दर के सैंपल लिखें. सभी तरह का डेटा नहीं एक समान सैंपल दर की आवश्यकता है. कदमों की संख्या अपडेट करने से कोई फ़ायदा नहीं होगा कम फ़्रीक्वेंसी के बजाय, हर सेकंड डेटा इकट्ठा होता रहता है. उदाहरण के लिए, हर 60 सेकंड में सेकंड. हालांकि, सैंपल रेट ज़्यादा होने से उपयोगकर्ताओं को ज़्यादा जानकारी मिल सकती है और वे सेहत और फ़िटनेस से जुड़े डेटा को पूरी तरह से देखते हैं. सैंपल रेट फ़्रीक्वेंसी वीडियो की बारीकियों और परफ़ॉर्मेंस के बीच संतुलन होना चाहिए.

पूरे दिन मॉनिटर किया जाने वाला डेटा लिखें

समय-समय पर इकट्ठा किए जाने वाले डेटा, जैसे कि चरणों की जानकारी के लिए, आपके ऐप्लिकेशन में पूरे दिन में कम से कम हर 15 मिनट बाद Health Connect को ईमेल भेजें.

सेशन लिखें

कसरत या स्लीप मोड के खत्म होने के बाद, डेटा Health Connect में लिखा होना चाहिए सत्र.

सबसे सही तरीका यह है कि नींद के किसी भी सेशन या कसरत के सेशन को रिकॉर्डिंग डिवाइस और ज़रूरी मेटाडेटा, जैसे कि RecordingMethod.

आपके आवेदन को कम से कम "उम्मीद के मुताबिक" सेक्शन में दिए गए दिशा-निर्देशों का पालन करना चाहिए जोड़ें. जगह इसलिए, "सबसे बढ़िया" दिशा-निर्देश.

किसी व्यायाम के दौरान ट्रैक किया गया डेटा

नींद के दौरान ट्रैक किया गया डेटा