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

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

• नींद के सेशन का डेटा सेव करने की अनुमति दें
• नींद की स्थिति का डेटा सेव करने की अनुमति दें
• नींद का डेटा सेव करने की अनुमति दें, जैसे कि धड़कन की दर, ऑक्सीजन सैचुरेशन, और सांस की दर
• अन्य ऐप्लिकेशन से नींद का डेटा पढ़ना

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

खास जानकारी: नींद को ट्रैक करने वाला एक बेहतर ऐप्लिकेशन बनाना

Health Connect का इस्तेमाल करके, नींद को ट्रैक करने की बेहतर सुविधा बनाई जा सकती है. इसके लिए, यह तरीका अपनाएं:

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

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

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

नींद से जुड़ी सुविधाएं लागू करने से पहले:

• सही डिपेंडेंसी का इस्तेमाल करके, Health Connect को इंटिग्रेट करें.
• HealthConnectClient इंस्टेंस बनाएं.
• पुष्टि करें कि आपका ऐप्लिकेशन, रनटाइम के दौरान Health Permissions के आधार पर अनुमति के फ़्लो लागू करता है.

वीडियो के विषय से जुड़े मुख्य कॉन्सेप्ट

Health Connect, नींद के डेटा को कुछ मुख्य कॉम्पोनेंट का इस्तेमाल करके दिखाता है. SleepSessionRecord नींद का मुख्य रिकॉर्ड होता है. इसमें नींद के शुरू या खत्म होने का समय और नींद के चरण जैसी जानकारी होती है. सेशन के दौरान, अलग-अलग तरह का डेटा रिकॉर्ड किया जा सकता है. जैसे, HeartRateRecord या OxygenSaturationRecord.

नींद के सेशन

नींद से जुड़े डेटा को SleepSessionRecord से दिखाया गया है. हर रिकॉर्ड में यह जानकारी सेव होती है:

• startTime
• endTime
• stages: SleepSessionRecord.Stage की सूची. इसमें गहरी नींद, हल्की नींद, आरईएम, और नींद खुली होने की अवधि शामिल है.
• सेशन का वैकल्पिक मेटाडेटा (टाइटल, नोट)

ऐप्लिकेशन, सेशन से जुड़े कई तरह के डेटा में बदलाव कर सकते हैं.

डेटा टाइप

नींद के सेशन के दौरान रिकॉर्ड किए जाने वाले सामान्य डेटा टाइप में ये शामिल हैं:

• SleepSessionRecord: यह नींद की अवधि और उसके चरणों को रिकॉर्ड करता है. जैसे, गहरी नींद, हल्की नींद, आरईएम (रैपिड आई मूवमेंट) नींद, और नींद खुली होना.
• HeartRateRecord: इससे सोते समय धड़कन की दर रिकॉर्ड की जाती है.
• OxygenSaturationRecord: यह कुकी, नींद के दौरान ऑक्सीजन की मात्रा (SpO2) रिकॉर्ड करती है.
• RespiratoryRateRecord: यह सुविधा, नींद के दौरान सांस की दर रिकॉर्ड करती है.

हर डेटा टाइप को अलग-अलग रिकॉर्ड के तौर पर सेव किया जाता है.

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

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

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

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

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

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

अनुमतियां

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

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

• android.permission.health.READ_SLEEP
• android.permission.health.WRITE_SLEEP

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

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

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

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

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

यहां नींद के सेशन के लिए अनुमतियां मांगने का एक उदाहरण दिया गया है. इसमें धड़कन की दर, ऑक्सीजन सैचुरेशन, और सांस की दर का डेटा शामिल है:

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

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

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

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

नींद का सेशन लागू करना

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

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

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

नींद के पूरे सेशन के दौरान, हार्ट रेट जैसे ज़्यादा जानकारी वाले डेटा को रिकॉर्ड किया जा सकता है. हालांकि, SleepSessionRecord को सिर्फ़ तब Health Connect में लिखा जाना चाहिए, जब सेशन खत्म हो गया हो. उदाहरण के लिए, जब उपयोगकर्ता जाग जाता है. रिकॉर्ड में सेशन startTime, endTime, और सेशन के दौरान रिकॉर्ड किए गए SleepSessionRecord.Stage ऑब्जेक्ट की सूची शामिल होनी चाहिए. ऐसा इसलिए, क्योंकि SleepSessionRecord के लिए endTime को startTime के बाद होना ज़रूरी है.

नींद के सेशन का डेटा सेव करने के लिए:

1. क्लाइंट के रिकॉर्ड का यूनीक आईडी जनरेट करें.
2. जब उपयोगकर्ता उठता है या नींद को ट्रैक करना बंद कर दिया जाता है, तो नींद की सभी स्टेज का डेटा इकट्ठा करें और SleepSessionRecord बनाएं.
3. insertRecords का इस्तेमाल करके रिकॉर्ड डालें.

उदाहरण:

val clientRecordId = UUID.randomUUID().toString()
val sessionStartTime = LocalDateTime.of(2023, 10, 30, 22, 0).toInstant(ZoneOffset.UTC)
val sessionEndTime = LocalDateTime.of(2023, 10, 31, 7, 0).toInstant(ZoneOffset.UTC)

val stages = mutableListOf<SleepSessionRecord.Stage>()
// Add recorded stages, for example:
stages.add(SleepSessionRecord.Stage(
    startTime = sessionStartTime.plusSeconds(3600),
    endTime = sessionStartTime.plusSeconds(7200),
    stage = SleepSessionRecord.STAGE_TYPE_LIGHT)
)
stages.add(SleepSessionRecord.Stage(
    startTime = sessionStartTime.plusSeconds(7200),
    endTime = sessionStartTime.plusSeconds(10800),
    stage = SleepSessionRecord.STAGE_TYPE_DEEP)
)
// ... other stages

val session = SleepSessionRecord(
    startTime = sessionStartTime,
    startZoneOffset = ZoneOffset.UTC,
    endTime = sessionEndTime,
    endZoneOffset = ZoneOffset.UTC,
    stages = stages,
    metadata = Metadata(clientRecordId = clientRecordId)
)

healthConnectClient.insertRecords(listOf(session))

नींद का डेटा पढ़ना

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

सत्र और उससे जुड़ा डेटा पढ़ना

ReadRecordsRequest का इस्तेमाल करके, नींद के सेशन पढ़े जा सकते हैं. इसके लिए, रिकॉर्ड टाइप के तौर पर SleepSessionRecord का इस्तेमाल करें. साथ ही, इसे किसी समयावधि के हिसाब से फ़िल्टर करें. किसी सेशन से जुड़े डेटा को पढ़ने के लिए, चुने गए डेटा टाइप के लिए दूसरा अनुरोध करें. जैसे, HeartRateRecord—नींद के सेशन के startTime और endTime के हिसाब से फ़िल्टर करना.

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

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

    for (sleepRecord in response.records) {
        // Process each session
        val stages = sleepRecord.stages
        val notes = sleepRecord.notes

        // To read specific granular data (like heart rate) that occurred during
        // this session, use the session's startTime and endTime to filter
        // the request for that data type.
        val hrResponse = healthConnectClient.readRecords(
            ReadRecordsRequest(
                recordType = HeartRateRecord::class,
                timeRangeFilter = TimeRangeFilter.between(
                    sleepRecord.startTime,
                    sleepRecord.endTime
                )
            )
        )
        for (heartRateRecord in hrResponse.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 = RespiratoryRateRecord(
      rate = 16.0,
      time = time,
      zoneOffset = ZoneOffset.UTC,
      metadata = Metadata(
          // Use a unique ID from your own database
          clientRecordId = "respiratory_rate_20231030_1"
      )
  )
  

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

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

• अनुमति मांगने की वजह साफ़ तौर पर बताएं: Permission.createIntent फ़्लो का इस्तेमाल करके बताएं कि आपके ऐप्लिकेशन को स्वास्थ्य से जुड़े डेटा का ऐक्सेस क्यों चाहिए. जैसे, "आपकी नींद के पैटर्न का विश्लेषण करने के लिए."

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

• टाइमस्टैंप को सेंसर की दरों के साथ अलाइन करें: डेटा को सटीक बनाए रखने के लिए, अपने रिकॉर्ड के टाइमस्टैंप को सेंसर की फ़्रीक्वेंसी से मैच करें.

टेस्ट करना

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

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

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

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

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

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

समस्या का हल

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

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