रॉ डेटा पढ़ें

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

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

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() API का इस्तेमाल करके, मौजूदा डिवाइस के लिए SPN पाएं.

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

getCurrentDeviceDataSource() API, फ़िलहाल 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 वैल्यू 1,000 होती है. अगर किसी एक 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 दिनों तक किसी भी डेटा को पढ़ने की सीमा.

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

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

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

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, CRUD ऑपरेशनों के लिए स्टैंडर्ड अपवाद दिखाता है. आपका ऐप्लिकेशन, इन सभी अपवादों को सही तरीके से पकड़कर हैंडल करे.

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

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

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

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

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

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

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

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

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

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