रॉ डेटा पढ़ें

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

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

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 */
}
HealthConnectManager.kt

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
}
HealthConnectManager.kt

मोबाइल से ट्रैक किए गए कदमों का डेटा देखने की अनुमति दें

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()
    }
}
HealthConnectWorker.kt

@OptIn(ExperimentalFeatureAvailabilityApi::class)
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
        )
    }
}
HealthConnectWorker.kt

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
}
HealthConnectManager.kt

पहले से लिखे गए डेटा को पढ़ना

अगर किसी ऐप्लिकेशन ने 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
}
HealthConnectManager.kt

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

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

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

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

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

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

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

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

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