रॉ डेटा पढ़ें

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

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

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

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

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

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

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

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

val response = healthConnectClient.readRecords(
    ReadRecordsRequest(
        HeartRateRecord::class,
        timeRangeFilter = TimeRangeFilter.between(startTime, endTime)
    )
)
response.records.forEach { record ->
    /* Process records */
}

` aggregate` का इस्तेमाल करके, इकट्ठा किया गया डेटा भी पढ़ा जा सकता है.

suspend fun readStepsAggregate(startTime: Instant, endTime: Instant): Long {
    val response = healthConnectClient.aggregate(
        AggregateRequest(
            metrics = setOf(StepsRecord.COUNT_TOTAL),
            timeRangeFilter = TimeRangeFilter.between(startTime, endTime)
        )
    )
    return response[StepsRecord.COUNT_TOTAL] ?: 0L
}

मोबाइल से चले गए कदमों का डेटा पढ़ना

Android 14 (एपीआई लेवल 34) और एसडीके एक्सटेंशन के वर्शन 20 या इसके बाद के वर्शन के साथ, Health Connect, उपयोगकर्ता के डिवाइस पर चले गए कदमों की संख्या की जानकारी देता है. अगर किसी ऐप्लिकेशन को READ_STEPS की अनुमति दी गई है, तो Health Connect, Android पर काम करने वाले डिवाइस से कदमों की संख्या की जानकारी कैप्चर करना शुरू कर देता है. साथ ही, उपयोगकर्ताओं को Health Connect की कदम वाली एंट्री में, कदमों की संख्या का डेटा अपने-आप दिखता है.

यह देखने के लिए कि उपयोगकर्ता के डिवाइस पर चले गए कदमों की संख्या की जानकारी उपलब्ध है या नहीं, यह पुष्टि करें कि डिवाइस, Android 14 (एपीआई लेवल 34) पर काम कर रहा है और उसमें एसडीके एक्सटेंशन का वर्शन कम से कम 20 है:

val isStepTrackingAvailable =
    Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE &&
        SdkExtensions.getExtensionVersion(Build.VERSION_CODES.UPSIDE_DOWN_CAKE) >= 20

अगर आपका ऐप्लिकेशन, aggregate का इस्तेमाल करके, इकट्ठा किए गए कदमों की संख्या का डेटा पढ़ता है और DataOrigin के हिसाब से फ़िल्टर नहीं करता है, तो उपयोगकर्ता के डिवाइस पर चले गए कदमों की संख्या, कुल संख्या में अपने-आप शामिल हो जाती है. साथ ही, जून 2026 के अपडेट के लिए कोई बदलाव करने की ज़रूरत नहीं होती.

उपयोगकर्ता के डिवाइस पर चले गए कदमों के लिए एट्रिब्यूशन में बदलाव

जून 2026 के अपडेट के बाद, Health Connect से ट्रैक किए गए कदमों का डेटा, सिंथेटिक पैकेज नेम (एसपीएन) से एट्रिब्यूट किया जाएगा. जैसे com.android.healthconnect.phone.jd5bdd37e1a8d3667a05d0abebfc4a89e.

पहले, बिल्ट-इन कदमों का डेटा, android पैकेज के नाम से एट्रिब्यूट किया जाता था. जून 2026 से पहले रिकॉर्ड किए गए कदमों के पुराने डेटा में, android पैकेज का नाम बना रहता है.

एसपीएन, डिवाइस के हिसाब से होते हैं और उपयोगकर्ता की निजता की सुरक्षा के लिए, हर ऐप्लिकेशन के हिसाब से तय किए जाते हैं:

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

उपयोगकर्ता के डिवाइस पर चले गए कदमों के लिए क्वेरी करना

एसपीएन, डिवाइस के हिसाब से तय किए जाते हैं. इसलिए, एसपीएन की वैल्यू को हार्डकोड नहीं किया जाना चाहिए. इसके बजाय, मौजूदा डिवाइस के लिए एसपीएन पाने के लिए, getCurrentDeviceDataSource() एपीआई का इस्तेमाल करें.

उपयोगकर्ता के डिवाइस पर चले गए कदमों की संख्या की जानकारी पाने के लिए, एसडीके एक्सटेंशन का वर्शन 20 या इसके बाद का होना ज़रूरी है. हालांकि, getCurrentDeviceDataSource() एपीआई, Android 14 (एपीआई लेवल 34) पर एसडीके एक्सटेंशन के वर्शन 11 या इसके बाद के वर्शन के साथ उपलब्ध है.

getCurrentDeviceDataSource() एपीआई, फ़िलहाल Health Connect Jetpack लाइब्रेरी में उपलब्ध नहीं है. यहां दिए गए उदाहरणों में, इसके बजाय Android फ़्रेमवर्क एपीआई का इस्तेमाल किया गया है:

import android.content.Context
import android.health.connect.HealthConnectManager

val healthConnectManager = context.getSystemService(HealthConnectManager::class.java)
val deviceDataSource = healthConnectManager?.getCurrentDeviceDataSource()
val currentDeviceSpn = deviceDataSource?.deviceDataOrigin?.packageName

अगर आपके ऐप्लिकेशन को डिवाइस पर चले गए कदमों की संख्या की जानकारी पढ़नी है या अगर यह सोर्स ऐप्लिकेशन या डिवाइस के हिसाब से, कदमों की संख्या का डेटा दिखाता है, तो आपको उन रिकॉर्ड के लिए क्वेरी करनी होगी जिनमें DataOrigin की वैल्यू android या डिवाइस के एसपीएन से मेल खाती हो. अगर आपका ऐप्लिकेशन, कदमों की संख्या के डेटा के लिए एट्रिब्यूशन दिखाता है, तो अलग-अलग रिकॉर्ड के लिए सोर्स डिवाइस की पहचान करने के लिए, metadata.device का इस्तेमाल करें. इकट्ठा किए गए डेटा में एसपीएन से पहचाने गए उपयोगकर्ता के डिवाइस पर चले गए कदमों के लिए, एट्रिब्यूशन के लिए DeviceDataSource से डिवाइस का मेटाडेटा इस्तेमाल किया जा सकता है. जैसे, model या manufacturer. इसके अलावा, उपयोगकर्ता के डिवाइस पर चले गए कदमों के लिए, "आपका फ़ोन" जैसा सामान्य लेबल इस्तेमाल किया जा सकता है.

यहां दिए गए उदाहरण में, android और मौजूदा डिवाइस के एसपीएन, दोनों के लिए फ़िल्टर करके, इकट्ठा किए गए डिवाइस पर चले गए कदमों की संख्या का डेटा पढ़ने का तरीका बताया गया है:

import android.content.Context
import android.health.connect.HealthConnectManager
import android.os.Build
import android.os.ext.SdkExtensions
import androidx.health.connect.client.HealthConnectClient
import androidx.health.connect.client.records.StepsRecord
import androidx.health.connect.client.records.metadata.DataOrigin
import androidx.health.connect.client.request.AggregateRequest
import androidx.health.connect.client.time.TimeRangeFilter
import java.time.Instant

suspend fun readDeviceStepsByTimeRange(
    healthConnectClient: HealthConnectClient,
    context: Context,
    startTime: Instant,
    endTime: Instant
) {
    // 1. Check if SDK Extension 11+ is available for getCurrentDeviceDataSource()
    val isDataSourceApiAvailable = Build.VERSION.SDK_INT >= Build.VERSION_CODES.U &&
            SdkExtensions.getExtensionVersion(Build.VERSION_CODES.U) >= 11

    try {
        val healthConnectManager = context.getSystemService(HealthConnectManager::class.java)

        // 2. Safely fetch the package name only if API is available and data exists
        val currentDeviceSpn = if (isDataSourceApiAvailable) {
            healthConnectManager?.getCurrentDeviceDataSource()?.deviceDataOrigin?.packageName
        } else {
            null
        }

        val dataOriginFilters = mutableSetOf(DataOrigin("android"))

        // 3. Explicit null-safety check using .let
        currentDeviceSpn?.let {
            dataOriginFilters.add(DataOrigin(it))
        }

        val response = healthConnectClient.aggregate(
            AggregateRequest(
                metrics = setOf(StepsRecord.COUNT_TOTAL),
                timeRangeFilter = TimeRangeFilter.between(startTime, endTime),
                dataOriginFilter = dataOriginFilters
            )
        )

        val stepCount = response[StepsRecord.COUNT_TOTAL]

    } catch (e: Exception) {
        // Now this catch block only handles actual runtime exceptions, 
        // rather than Errors from missing methods.
    }
}

डिवाइस पर चले गए कदमों की संख्या की जानकारी

  • सेंसर का इस्तेमाल: Health Connect, SensorManager से TYPE_STEP_COUNTER सेंसर का इस्तेमाल करता है. इस सेंसर को कम बैटरी खर्च करने के लिए ऑप्टिमाइज़ किया गया है. इसलिए, यह बैकग्राउंड में लगातार कदमों को ट्रैक करने के लिए सबसे सही है.
  • डेटा की ग्रैन्युलैरिटी: बैटरी लाइफ़ बचाने के लिए, कदमों के डेटा को आम तौर पर बैच में इकट्ठा किया जाता है और Health Connect डेटाबेस में हर मिनट में एक बार से ज़्यादा नहीं लिखा जाता.
  • एट्रिब्यूशन: जून 2026 से पहले, इस सुविधा से रिकॉर्ड किए गए कदमों का डेटा, android पैकेज के नाम से DataOrigin में एट्रिब्यूट किया जाता है. इस तारीख के बाद, यह डेटा डिवाइस के हिसाब से एसपीएन से एट्रिब्यूट किया जाता है. डिवाइस पर चले गए कदमों के लिए एट्रिब्यूशन में बदलाव लेख देखें .
  • सक्रिय करना: उपयोगकर्ता के डिवाइस पर चले गए कदमों की संख्या की जानकारी पाने का तरीका, सिर्फ़ तब काम करता है, जब डिवाइस पर कम से कम एक ऐप्लिकेशन को Health Connect में READ_STEPSकी अनुमति दी गई हो.

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

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

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

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

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

    override suspend fun doWork(): Result {
        val healthConnectClient = HealthConnectClient.getOrCreate(applicationContext)
        // Perform background read logic here
        return Result.success()
    }
}
 
fun enqueueBackgroundReadWorker(context: Context, healthConnectClient: HealthConnectClient) {
    if (healthConnectClient
            .features
            .getFeatureStatus(
                HealthConnectFeatures.FEATURE_READ_HEALTH_DATA_IN_BACKGROUND
            ) == HealthConnectFeatures.FEATURE_STATUS_AVAILABLE
    ) {

        val periodicWorkRequest = PeriodicWorkRequestBuilder<ScheduleWorker>(1, TimeUnit.HOURS)
            .build()

        WorkManager.getInstance(context).enqueueUniquePeriodicWork(
            "read_health_connect",
            ExistingPeriodicWorkPolicy.KEEP,
            periodicWorkRequest
        )
    }
}

ReadRecordsRequest पैरामीटर की डिफ़ॉल्ट pageSize वैल्यू 1000 होती है. अगर किसी एक readResponse में रिकॉर्ड की संख्या, अनुरोध की pageSize से ज़्यादा है, तो pageToken का इस्तेमाल करके, सभी रिकॉर्ड पाने के लिए, आपको जवाब के सभी पेजों पर इटरेट करना होगा. हालांकि, रेट-लिमिटिंग से जुड़ी समस्याओं से बचने के लिए सावधानी बरतें.

pageToken से डेटा पढ़ने का उदाहरण

अनुरोध की गई समयावधि का सारा उपलब्ध डेटा पाने के लिए, रिकॉर्ड पढ़ने के लिए pageToken का इस्तेमाल करने का सुझाव दिया जाता है.

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

val type = HeartRateRecord::class
val endTime = Instant.now()
val startTime = endTime.minus(Duration.ofDays(7))

try {
    var pageToken: String? = null
    do {
        val readResponse =
            healthConnectClient.readRecords(
                ReadRecordsRequest(
                    recordType = type,
                    timeRangeFilter = TimeRangeFilter.between(
                        startTime,
                        endTime
                    ),
                    pageToken = pageToken
                )
            )
        val records = readResponse.records
        // Do something with records
        pageToken = readResponse.pageToken
    } while (pageToken != null)
} catch (quotaError: IllegalStateException) {
    // Backoff
}
 बड़े डेटासेट पढ़ने के सबसे सही तरीकों के बारे में जानने के लिए, रेट लिमिटिंग से बचने की योजना बनाना लेख पढ़ें.

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

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

डेटा पढ़ने पर कुछ पाबंदियां लागू होती हैं:

  • Android 14 और इसके बाद के वर्शन के लिए

    • कोई ऐप्लिकेशन, अपना डेटा पढ़ने के लिए, पुराने डेटा की कोई सीमा नहीं होती.
    • कोई ऐप्लिकेशन, दूसरा डेटा पढ़ने के लिए, 30 दिनों की सीमा होती है.

  • Android 13 और इससे पुराने वर्शन के लिए

    • कोई ऐप्लिकेशन, कोई भी डेटा पढ़ने के लिए, 30 दिनों की सीमा होती है.

डेटा पढ़ने की अनुमति का अनुरोध करके, पाबंदियां हटाई जा सकती हैं.

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

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

try {
    val response =  healthConnectClient.readRecords(
        ReadRecordsRequest(
            recordType = HeartRateRecord::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 दिन से ज़्यादा पुराना डेटा पढ़ना

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

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

मिटाए गए ऐप्लिकेशन के लिए अनुमतियों का इतिहास

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

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

गड़बड़ियों को ठीक करना

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

HealthConnectClient के हर तरीके में, दिखाए जा सकने वाले अपवादों की सूची होती है. आम तौर पर, आपके ऐप्लिकेशन को ये अपवाद ठीक करने चाहिए:

टेबल 1: Health Connect के अपवाद और सुझाए गए सबसे सही तरीके
अपवाद ब्यौरा सुझाया गया सबसे सही तरीका
IllegalStateException इसका मतलब इनमें से एक हो सकता है:

  • Health Connect सेवा उपलब्ध नहीं है.
  • अनुरोध मान्य नहीं है. उदाहरण के लिए, समय-समय पर बकेट में इकट्ठा करने का अनुरोध, जिसमें timeRangeFilter के लिए Instant ऑब्जेक्ट का इस्तेमाल किया गया हो.

अनुरोध करने से पहले, इनपुट से जुड़ी संभावित समस्याओं को ठीक करें. बेहतर होगा कि आप अपने अनुरोधों में सीधे वैल्यू इस्तेमाल करने के बजाय, उन्हें वैरिएबल असाइन करें या कस्टम फ़ंक्शन में पैरामीटर के तौर पर इस्तेमाल करें, ताकि गड़बड़ी ठीक करने की रणनीतियां लागू की जा सकें.
IOException डिस्क से डेटा पढ़ने और लिखने में समस्याएं आ रही हैं. इस समस्या से बचने के लिए, यहां कुछ सुझाव दिए गए हैं:

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

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

उदाहरण के लिए, आपका ऐप्लिकेशन, दिए गए uid वाला रिकॉर्ड मिटाने की कोशिश कर रहा है. हालांकि, ऐप्लिकेशन को यह पता चलने के बाद अपवाद दिखाया जाता है कि मौजूदा सेवा में वह रिकॉर्ड मौजूद नहीं है. 		इस समस्या से बचने के लिए, यहां कुछ सुझाव दिए गए हैं:

  • अपने ऐप्लिकेशन के डेटास्टोर और Health Connect के बीच, समय-समय पर सिंक करें.
  • अनुरोध से जुड़ी समस्याओं को ठीक करने के लिए, फिर से कोशिश करने और बैकऑफ़ की रणनीतियां लागू करें.

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

पीछे जाएं
डेटा सेव करने की अनुमति दें
आगे बढ़ें
इकट्ठा किया गया डेटा देखना