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

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

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

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

खास जानकारी: नींद के पैटर्न पर नज़र रखने की पूरी सुविधा जोड़ना

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

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

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

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

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

मुख्य सिद्धांत

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 मेनिफ़ेस्ट में किया गया हो. 

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 की अनुमतियों वाली स्क्रीन दिखती है. 
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.") }
    }
}
 उपयोगकर्ता किसी भी समय अनुमतियां दे या वापस ले सकते हैं. इसलिए, आपके ऐप्लिकेशन को हर बार अनुमतियों का इस्तेमाल करने से पहले, उनकी जांच करनी होगी. साथ ही, अनुमति वापस लिए जाने की स्थितियों को मैनेज करना होगा.

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

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

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 का इस्तेमाल करें: डेटा को बाद में सेव करने के लिए, 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"
    )
)
  • मौजूदा डेटा की जांच करें: सिंक करने से पहले, टाइम रेंज के लिए क्वेरी करें, ताकि यह देखा जा सके कि आपके ऐप्लिकेशन के रिकॉर्ड पहले से मौजूद हैं या नहीं.
  • पक्का करें कि टाइमस्टैंप ओवरलैप न हों: पुष्टि करें कि नया सेशन, पिछले सेशन के खत्म होने से पहले शुरू न हो. सेशन ओवरलैप होने से, फ़िटनेस डैशबोर्ड और सारांश की कैलकुलेशन में गड़बड़ियां हो सकती हैं.
  • अनुमति के लिए, साफ़ तौर पर वजहें बताएं: Permission.createIntent फ़्लो का इस्तेमाल करके, यह बताएं कि आपके ऐप्लिकेशन को सेहत से जुड़े डेटा को ऐक्सेस करने की अनुमति क्यों चाहिए. उदाहरण के लिए, 'रक्तचाप के ट्रेंड पर नज़र रखने और अहम जानकारी देने के लिए.'
  • लंबे समय तक चलने वाले सेशन की जांच करें: कई घंटों तक चलने वाले सेशन के दौरान, बैटरी की खपत पर नज़र रखें, ताकि यह पुष्टि की जा सके कि बैचिंग इंटरवल और सेंसर के इस्तेमाल से डिवाइस की बैटरी खत्म नहीं होती.
  • सेंसर की दरों के साथ टाइमस्टैंप अलाइन करें: डेटा की हाई-फ़िडेलिटी बनाए रखने के लिए, अपने रिकॉर्ड के टाइमस्टैंप को सेंसर की असली फ़्रीक्वेंसी से मैच करें.

जांच करना

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

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

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

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

आम तौर पर इस्तेमाल किया जाने वाला आर्किटेक्चर

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

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

समस्या का हल

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

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

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