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

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 मेनिफ़ेस्ट में किया गया हो.

// Create a set of permissions for required data types
val PERMISSIONS =
    setOf(
  HealthPermission.getReadPermission(StepsRecord::class),
  HealthPermission.getWritePermission(StepsRecord::class)
)

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

// Create the permissions launcher
val requestPermissionActivityContract = PermissionController.createRequestPermissionResultContract()

val requestPermissions = registerForActivityResult(requestPermissionActivityContract) { granted ->
  if (granted.containsAll(PERMISSIONS)) {
    // Permissions successfully granted
  } else {
    // Lack of required permissions
  }
}

suspend fun checkPermissionsAndRun(healthConnectClient: HealthConnectClient) {
  val granted = healthConnectClient.permissionController.getGrantedPermissions()
  if (granted.containsAll(PERMISSIONS)) {
    // Permissions already granted; proceed with inserting or reading data
  } else {
    requestPermissions.launch(PERMISSIONS)
  }
}

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

कदमों की जानकारी के रिकॉर्ड में शामिल जानकारी

हर 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