रॉ डेटा पढ़ें

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

डेटा पढ़ने की अनुमति दें

Health Connect की मदद से ऐप्लिकेशन, डेटास्टोर में मौजूद डेटा को पढ़ सकते हैं. ऐसा तब किया जाता है, जब ऐप्लिकेशन फ़ोरग्राउंड और बैकग्राउंड में चल रहा हो:

• फ़ोरग्राउंड में डेटा पढ़ना: आम तौर पर, जब आपका ऐप्लिकेशन फ़ोरग्राउंड में होता है, तब Health Connect से डेटा पढ़ा जा सकता है. ऐसे मामलों में, इस कार्रवाई को चलाने के लिए फ़ोरग्राउंड सेवा का इस्तेमाल किया जा सकता है. ऐसा तब करना चाहिए, जब उपयोगकर्ता या सिस्टम, पढ़ने की कार्रवाई के दौरान आपके ऐप्लिकेशन को बैकग्राउंड में डाल दे.

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

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

रिकॉर्ड पढ़ने के लिए, ReadRecordsRequest बनाएं और readRecords को कॉल करते समय उसे दें.

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

suspend fun readStepsByTimeRange(
    healthConnectClient: HealthConnectClient,
    startTime: Instant,
    endTime: Instant
) {
    try {
        val response = healthConnectClient.readRecords(
            ReadRecordsRequest(
                StepsRecord::class,
                timeRangeFilter = TimeRangeFilter.between(startTime, endTime)
            )
        )
        for (stepRecord in response.records) {
            // Process each step record
        }
    } catch (e: Exception) {
        // Run error handling here
    }
}

बैकग्राउंड में पढ़ने का उदाहरण

बैकग्राउंड में डेटा पढ़ने के लिए, अपनी मेनिफ़ेस्ट फ़ाइल में यह अनुमति दें:

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

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

class ScheduleWorker(private val appContext: Context, workerParams: WorkerParameters):
    CoroutineWorker(appContext, workerParams) {

    override suspend fun doWork(): Result {
        // Read data and process it.
        ...

        // Return success indicating successful data retrieval
        return Result.success()
    }
}

if (healthConnectClient
    .features
    .getFeatureStatus(
    HealthConnectFeatures.FEATURE_READ_HEALTH_DATA_IN_BACKGROUND
    ) == HealthConnectFeatures.FEATURE_STATUS_AVAILABLE) {

    // Check if necessary permission is granted
    val grantedPermissions = healthConnectClient.permissionController.getGrantedPermissions()

    if (PERMISSION_READ_HEALTH_DATA_IN_BACKGROUND !in grantedPermissions) {
        // Perform read in foreground
        ...
    } else {
        // Schedule the periodic work request in background
        val periodicWorkRequest = PeriodicWorkRequestBuilder<ScheduleWorker>(1, TimeUnit.HOURS)
            .build()

        WorkManager.getInstance(context).enqueueUniquePeriodicWork(
            "read_health_connect",
            ExistingPeriodicWorkPolicy.KEEP,
            periodicWorkRequest
        )
    }
} else {
  // Background reading is not available, perform read in foreground
  ...
}

पहले लिखा गया डेटा पढ़ना

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

इस स्थिति में डेटा पढ़ने के लिए, आपको अपने ReadRecordsRequest के dataOriginFilter पैरामीटर में पैकेज के नाम को DataOrigin ऑब्जेक्ट के तौर पर दिखाना होगा.

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

try {
    val response =  healthConnectClient.readRecords(
        ReadRecordsRequest(
            recordType = StepsRecord::class,
            timeRangeFilter = TimeRangeFilter.between(startTime, endTime),
            dataOriginFilter = setOf(DataOrigin("com.my.package.name"))
        )
    )
    for (record in response.records) {
        // Process each record
    }
} catch (e: Exception) {
    // Run error handling here
}

पाबंदियां पढ़ना

डिफ़ॉल्ट रूप से, आपका ऐप्लिकेशन किसी भी अनुमति के साथ 30 दिनों तक का डेटा पढ़ सकता है. PERMISSION_READ_HEALTH_DATA_HISTORY अनुमति मिलने पर, आपका ऐप्लिकेशन 30 दिनों से ज़्यादा पुराना डेटा पढ़ सकता है.

30 दिनों के लिए पाबंदी

Health Connect, पहली बार अनुमति मिलने से पहले के 30 दिनों तक का डेटा पढ़ सकता है.

हालांकि, अगर कोई उपयोगकर्ता आपका ऐप्लिकेशन मिटा देता है, तो अनुमति का इतिहास मिट जाता है. अगर उपयोगकर्ता आपके ऐप्लिकेशन को फिर से इंस्टॉल करता है और उसे फिर से अनुमति देता है, तो ऐप्लिकेशन उस नई तारीख से 30 दिन पहले तक Health Connect का डेटा पढ़ सकता है.

30 दिनों के लिए

अगर किसी उपयोगकर्ता ने 30 मार्च, 2023 को आपके ऐप्लिकेशन को डेटा पढ़ने की अनुमति दी है, तो आपका ऐप्लिकेशन 28 फ़रवरी, 2023 से पहले का डेटा पढ़ सकता है.

इसके बाद, उपयोगकर्ता 10 मई, 2023 को आपका ऐप्लिकेशन मिटा देता है. उपयोगकर्ता ने 15 मई, 2023 को इसे फिर से इंस्टॉल करने का फ़ैसला किया और उसे पढ़ने की अनुमति दी. आपका ऐप्लिकेशन इस तारीख से 15 अप्रैल, 2023 से डेटा पढ़ पाएगा.

30 दिन से ज़्यादा पुराना डेटा पढ़ना

अगर आपको 30 दिनों से पुराना डेटा पढ़ना है, तो आपको PERMISSION_READ_HEALTH_DATA_HISTORY अनुमति का इस्तेमाल करना होगा. इस अनुमति के बिना, 30 दिन से ज़्यादा पुराने किसी भी रिकॉर्ड को पढ़ने की कोशिश करने पर गड़बड़ी का मैसेज दिखता है. समयसीमा के किसी अनुरोध का इस्तेमाल करके, 30 दिनों से ज़्यादा पुराना डेटा भी नहीं पढ़ा जा सकता.