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

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

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

Android 14 (एपीआई लेवल 34) और SDK एक्सटेंशन के 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

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

अगर आपके ऐप्लिकेशन को डिवाइस पर मौजूद कदमों की जानकारी को पढ़ने की ज़रूरत है या वह सोर्स ऐप्लिकेशन या डिवाइस के हिसाब से कदमों की जानकारी दिखाता है, तो उन रिकॉर्ड के लिए क्वेरी की जा सकती है जिनमें DataOrigin android है. अगर आपका ऐप्लिकेशन, स्टेप डेटा के लिए एट्रिब्यूशन दिखाता है, तो आपको Android पैकेज से मिले डेटा को मौजूदा डिवाइस के लिए एट्रिब्यूट करना चाहिए. इसके लिए, "आपका फ़ोन" जैसे लेबल का इस्तेमाल करें. इसके अलावा, Settings.Global.getString(resolver, Settings.Global.DEVICE_NAME) की मदद से डिवाइस का नाम पाएं या रिकॉर्ड के मेटाडेटा में Device फ़ील्ड की जांच करें.

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

suspend fun readStepsByTimeRange(
    healthConnectClient: HealthConnectClient,
    startTime: Instant,
    endTime: Instant
) {
    try {
        val response = healthConnectClient.aggregate(
            AggregateRequest(
                metrics = setOf(StepsRecord.COUNT_TOTAL),
                timeRangeFilter = TimeRangeFilter.between(startTime, endTime),
                dataOriginFilter = setOf(DataOrigin("android"))
            )
        )
        // The result may be null if no data is available in the time range
        val stepCount = response[StepsRecord.COUNT_TOTAL]
    } catch (e: Exception) {
        // Run error handling here
    }
}

ऑन-डिवाइस स्टेप काउंटिंग

डिवाइस पर ही कदमों की गिनती करने की सुविधा के बारे में ज़्यादा जानकारी:

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

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

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

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 के लिए, ये एग्रीगेट वैल्यू उपलब्ध हैं:

• RATE_AVG
• RATE_MAX
• RATE_MIN

इस्तेमाल का उदाहरण

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

चलते समय लिए गए कदमों का डेटा सेव करने की अनुमति दें

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

suspend fun writeStepsData(
    healthConnectClient: HealthConnectClient,
    startTime: Instant,
    endTime: Instant,
    startZoneOffset: ZoneOffset,
    endZoneOffset: ZoneOffset
) {
    try {
        val stepsRecord = StepsRecord(
            startTime = startTime,
            startZoneOffset = startZoneOffset,
            endTime = endTime,
            endZoneOffset = endZoneOffset,
            count = 1000
        )
        healthConnectClient.insertRecords(listOf(stepsRecord))
    } catch (e: Exception) {
        // Run error handling
    }
}

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

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

suspend fun readStepsAggregate(
    healthConnectClient: HealthConnectClient,
    startTime: Instant,
    endTime: Instant
) {
    try {
        val response = healthConnectClient.aggregate(
            AggregateRequest(
                metrics = setOf(StepsRecord.COUNT_TOTAL),
                timeRangeFilter = TimeRangeFilter.between(startTime, endTime)
            )
        )
        // The result may be null if no data is available in the time range
        val stepCount = response[StepsRecord.COUNT_TOTAL]
    } catch (e: Exception) {
        // Run error handling here
    }
}

रॉ डेटा पढ़ने की अनुमति

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

suspend fun readStepsRaw(
    healthConnectClient: HealthConnectClient,
    startTime: Instant,
    endTime: Instant
) {
    try {
        val response = healthConnectClient.readRecords(
            ReadRecordsRequest(
                recordType = StepsRecord::class,
                timeRangeFilter = TimeRangeFilter.between(startTime, endTime)
            )
        )
        for (record in response.records) {
            // Process each record
        }
    } catch (e: Exception) {
        // Run error handling here
    }
}