रॉ डेटा पढ़ें

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

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

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 दिनों के लिए पाबंदी

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

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

30 दिनों के लिए

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

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

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

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