Google Fit API का इस्तेमाल 2026 के आखिर तक किया जा सकेगा. डेटा को दूसरी जगह भेजने के सुझाए गए तरीकों के बारे में जानने के लिए, डेटा को दूसरी जगह भेजने से जुड़ी गाइड देखें.

Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

कदमों को ट्रैक करना

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

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

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की अनुमति दी गई हो.

यह देखना कि Health Connect मौजूद और चालू है या नहीं

Health Connect का इस्तेमाल करने से पहले, आपके ऐप्लिकेशन को यह पुष्टि करनी चाहिए कि उपयोगकर्ता के डिवाइस पर Health Connect इंस्टॉल हो. ऐसा हो सकता है कि Health Connect, सभी डिवाइसों पर पहले से इंस्टॉल न हो या इसे बंद कर दिया गया हो. HealthConnectClient.getSdkStatus() का इस्तेमाल करके, यह देखा जा सकता है कि Health Connect उपलब्ध है या नहीं.

यह देखना कि Health Connect उपलब्ध है या नहीं

fun checkHealthConnectAvailability(context: Context) {
    val providerPackageName = "com.google.android.apps.healthdata" // Or get from HealthConnectClient.DEFAULT_PROVIDER_PACKAGE_NAME
    val availabilityStatus = HealthConnectClient.getSdkStatus(context, providerPackageName)

    if (availabilityStatus == HealthConnectClient.SDK_UNAVAILABLE) {
      // Health Connect is not available. Guide the user to install/enable it.
      // For example, show a dialog.
      return // early return as there is no viable integration
    }
    if (availabilityStatus == HealthConnectClient.SDK_UNAVAILABLE_PROVIDER_UPDATE_REQUIRED) {
      // Health Connect is available but requires an update.
      // Optionally redirect to package installer to find a provider, for example:
      val uriString = "market://details?id=$providerPackageName&url=healthconnect%3A%2F%2Fonboarding"
      context.startActivity(
        Intent(Intent.ACTION_VIEW).apply {
          setPackage("com.android.vending")
          data = Uri.parse(uriString)
          putExtra("overlay", true)
          putExtra("callerId", context.packageName)
        }
      )
      return
    }
    // Health Connect is available, obtain a HealthConnectClient instance
    val healthConnectClient = HealthConnectClient.getOrCreate(context)
    // Issue operations with healthConnectClient
}

getSdkStatus() से मिले स्टेटस के आधार पर, ज़रूरी होने पर उपयोगकर्ता को Google Play Store से Health Connect इंस्टॉल या अपडेट करने के लिए कहा जा सकता है.

ज़रूरी अनुमतियां

चले गए कदमों की संख्या को ऐक्सेस करने के लिए, इन अनुमतियों का इस्तेमाल किया जाता है:

android.permission.health.READ_STEPS
android.permission.health.WRITE_STEPS

अपने ऐप्लिकेशन में, चले गए कदमों की संख्या गिनने की सुविधा जोड़नी है, तो Steps डेटा टाइप के लिए अनुमतियों का अनुरोध करें.

यहां उस अनुमति के बारे में बताया गया है जिसके बारे में आपको एलान करना होगा, ताकि चले गए कदमों की संख्या से जुड़े डेटा में बदलाव किया जा सके:

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

चले गए कदमों की संख्या का डेटा ऐक्सेस करने के लिए, आपको ये अनुमतियां मांगनी होंगी:

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

उपयोगकर्ता से अनुमतियों का अनुरोध करना

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

val permissions =
    setOf(
        HealthPermission.getReadPermission(StepsRecord::class),
        HealthPermission.getWritePermission(StepsRecord::class)
    )HealthConnectManager.kt

यह देखने के लिए कि आपके ऐप्लिकेशन को पहले से ही ज़रूरी अनुमतियां मिली हुई हैं या नहीं, getGrantedPermissions का इस्तेमाल करें. अगर ऐसा नहीं है, तो उन अनुमतियों का अनुरोध करने के लिए, createRequestPermissionResultContract का इस्तेमाल करें. इससे, Health Connect की अनुमतियों वाली स्क्रीन दिखती है.

val permissions = setOf(
        HealthPermission.getReadPermission(StepsRecord::class),
        HealthPermission.getWritePermission(StepsRecord::class),
        HealthPermission.getReadPermission(HeartRateRecord::class),
        HealthPermission.getWritePermission(HeartRateRecord::class)
    )

val requestPermissionsLauncher = rememberLauncherForActivityResult(
    contract = PermissionController.createRequestPermissionResultContract()
) { grantedPermissions ->
    if (grantedPermissions.containsAll(permissions)) {
        coroutineScope.launch { snackbarHostState.showSnackbar("Permissions granted!") }
    } else {
        coroutineScope.launch { snackbarHostState.showSnackbar("Permissions denied.") }
    }
}HealthConnectActivity.kt

उपयोगकर्ता किसी भी समय अनुमतियां दे या वापस ले सकते हैं. इसलिए, आपके ऐप्लिकेशन को हर बार अनुमतियों का इस्तेमाल करने से पहले, यह देखना होगा कि उसके पास वे अनुमतियां हैं या नहीं. साथ ही, उसे उन स्थितियों को भी मैनेज करना होगा जिनमें अनुमति वापस ले ली गई हो.

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

हर StepsRecord में यह जानकारी शामिल होती है:

count: समय अंतराल में चले गए कदमों की संख्या, Long के तौर पर.
startTime: मेज़रमेंट इंटरवल शुरू होने का समय.
endTime: मेज़रमेंट इंटरवल खत्म होने का समय.
startZoneOffset: शुरू होने के समय के लिए ज़ोन ऑफ़सेट.
endZoneOffset: खत्म होने के समय के लिए ज़ोन ऑफ़सेट.

इस्तेमाल किए जा सकने वाले एग्रीगेशन

StepsRecord के लिए, ये कुल वैल्यू उपलब्ध हैं:

COUNT_TOTAL

StepsCadenceRecord के लिए, ये कुल वैल्यू उपलब्ध हैं:

उदाहरण उपयोग

यहां दिए गए सेक्शन में, StepsRecord डेटा को पढ़ने और सेव करने का तरीका बताया गया है.

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

आपका ऐप्लिकेशन, StepsRecord इंस्टेंस डालकर, चले गए कदमों की संख्या का डेटा सेव कर सकता है. यहां दिए गए उदाहरण में, किसी उपयोगकर्ता के 1,000 कदम चलने की जानकारी रिकॉर्ड करने का तरीका बताया गया है:

val zoneOffset = ZoneOffset.systemDefault().rules.getOffset(startTime)
val stepsRecord = StepsRecord(
    count = 120,
    startTime = startTime,
    endTime = endTime,
    startZoneOffset = zoneOffset,
    endZoneOffset = zoneOffset,
    metadata = Metadata(
        device = Device(type = Device.TYPE_WATCH),
        recordingMethod = Metadata.RECORDING_METHOD_AUTOMATICALLY_RECORDED
    )
)
healthConnectClient.insertRecords(listOf(stepsRecord))HealthConnectManager.kt

कुल डेटा पढ़ना

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

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

रॉ डेटा पढ़ना

यहां दिए गए उदाहरण में, शुरू होने और खत्म होने के समय के बीच, StepsRecord डेटा को पढ़ने का तरीका बताया गया है:

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