Recording API का इस्तेमाल करके फ़िटनेस डेटा रिकॉर्ड करना

मोबाइल पर Recording API की मदद से, आपका ऐप्लिकेशन बैटरी की खपत कम करके, मोबाइल डिवाइस से फ़िटनेस डेटा रिकॉर्ड कर सकता है. उदाहरण के लिए, इस एपीआई का इस्तेमाल करके कदमों की संख्या रिकॉर्ड करें. यह पेडोमीटर की तरह काम करता है और कदमों की संख्या का डेटा दिखाता है. यह एपीआई, बिना खाते के काम करता है. इसका मतलब है कि सेवा का इस्तेमाल करने के लिए, Google खाते की ज़रूरत नहीं होती. साथ ही, डेटा डिवाइस पर सेव होता है.

अगर आपके ऐप्लिकेशन को डिवाइस पर गिने गए कदमों के अलावा, अलग-अलग सोर्स से सेहत और फ़िटनेस से जुड़ा अन्य डेटा भी पढ़ना है, तो Health Connect के साथ इंटिग्रेट करना बेहतर विकल्प है. Health Connect, Android 14 (एपीआई लेवल 34) और इसके बाद के वर्शन पर, डिवाइस पर गिने गए कदमों का डेटा ऐक्सेस करने की सुविधा भी देता है.

इस गाइड में, आपको सेहत और फ़िटनेस से जुड़े अनुभवों में, मोबाइल पर Recording API का इस्तेमाल करने का तरीका बताया गया है.

उदाहरण के लिए, GitHub पर मोबाइल पर Recording API का सैंपल देखें.

अहम जानकारी

मोबाइल पर Recording API की कुछ अहम सुविधाएं यहां दी गई हैं:

  • रिकॉर्डिंग की सदस्यता शुरू होने या रिन्यू होने के बाद, पिछली सदस्यता के बाद से लेकर 10 दिनों तक का डेटा ऐक्सेस किया जा सकता है.
  • डेटा सिर्फ़ तब उपलब्ध होता है, जब कोई सदस्यता चालू हो. unsubscribe को कॉल करके, अगर कोई सदस्यता हटा दी जाती है, तो इकट्ठा किया गया डेटा ऐक्सेस नहीं किया जा सकेगा.

डेटा टाइप

मोबाइल पर Recording API, इस तरह का डेटा रिकॉर्ड कर सकता है:

शुरू करें

शुरू करने के लिए, अपनी build.gradle फ़ाइल में यह डिपेंडेंसी जोड़ें:

Kotlin DSL

plugin {
  id("com.android.application")
}

...

dependencies {
  implementation("com.google.android.gms:play-services-fitness:21.2.0")
}

Groovy DSL

apply plugin: 'com.android.application'

...

dependencies {
  implementation 'com.google.android.gms:play-services-fitness:21.2.0'
}

अनुमतियों का अनुरोध करें

मोबाइल पर Recording API का इस्तेमाल करके डेटा रिकॉर्ड करने के लिए, आपके ऐप्लिकेशन को यह अनुमति का अनुरोध करना होगा:

  • android.permission.ACTIVITY_RECOGNITION

Play services के वर्शन की जांच करना

मोबाइल पर Recording API का इस्तेमाल करने के लिए, उपयोगकर्ता के पास Google Play services का LOCAL_RECORDING_CLIENT_MIN_VERSION_CODE पर अपडेट किया गया वर्शन होना चाहिए. इसकी जांच के लिए isGooglePlayServicesAvailable तरीके का इस्तेमाल किया जा सकता है:

val hasMinPlayServices = isGooglePlayServicesAvailable(context, LocalRecordingClient.LOCAL_RECORDING_CLIENT_MIN_VERSION_CODE)

if(hasMinPlayServices != ConnectionResult.SUCCESS) {
  // Prompt user to update their device's Google Play services app and return
}

// Continue with Recording API functions

ऐसा न होने पर, अगर उपयोगकर्ता के पास Google Play services का पुराना वर्शन है, तो सिस्टम ConnectionResult.SERVICE_VERSION_UPDATE_REQUIRED अपवाद दिखाता है.

फ़िटनेस डेटा की सदस्यता लेना

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

val localRecordingClient = FitnessLocal.getLocalRecordingClient(this)
// Subscribe to steps data
localRecordingClient.subscribe(LocalDataType.TYPE_STEP_COUNT_DELTA)
  .addOnSuccessListener {
    Log.i(TAG, "Successfully subscribed!")
  }
  .addOnFailureListener { e ->
    Log.w(TAG, "There was a problem subscribing.", e)
  }

फ़िटनेस डेटा पढ़ना और प्रोसेस करना

सदस्यता लेने के बाद, readData तरीके का इस्तेमाल करके डेटा का अनुरोध करें. इसके बाद, नतीजे में मिले LocalDataSet से LocalDataPoints हासिल किए जा सकते हैं. यह तरीका, यहां दिए गए कोड स्निपेट में दिखाया गया है:LocalDataReadRequest

val endTime = LocalDateTime.now().atZone(ZoneId.systemDefault())
val startTime = endTime.minusWeeks(1)
val readRequest =
  LocalDataReadRequest.Builder()
    // The data request can specify multiple data types to return,
    // effectively combining multiple data queries into one call.
    // This example demonstrates aggregating only one data type.
    .aggregate(LocalDataType.TYPE_STEP_COUNT_DELTA)
    // Analogous to a "Group By" in SQL, defines how data should be
    // aggregated. bucketByTime allows bucketing by time span.
    .bucketByTime(1, TimeUnit.DAYS)
    .setTimeRange(startTime.toEpochSecond(), endTime.toEpochSecond(), TimeUnit.SECONDS)
    .build()

  localRecordingClient.readData(readRequest).addOnSuccessListener { response ->
    // The aggregate query puts datasets into buckets, so flatten into a
    // single list of datasets.
    for (dataSet in response.buckets.flatMap { it.dataSets }) {
      dumpDataSet(dataSet)
    }
  }
  .addOnFailureListener { e ->
    Log.w(TAG,"There was an error reading data", e)
  }

fun dumpDataSet(dataSet: LocalDataSet) {
  Log.i(TAG, "Data returned for Data type: ${dataSet.dataType.name}")
  for (dp in dataSet.dataPoints) {
    Log.i(TAG,"Data point:")
    Log.i(TAG,"\tType: ${dp.dataType.name}")
    Log.i(TAG,"\tStart: ${dp.getStartTime(TimeUnit.HOURS)}")
    Log.i(TAG,"\tEnd: ${dp.getEndTime(TimeUnit.HOURS)}")
    for (field in dp.dataType.fields) {
      Log.i(TAG,"\tLocalField: ${field.name.toString()} LocalValue: ${dp.getValue(field)}")
    }
  }
}

LocalRecordingClient, डेटा के कलेक्शन को लगातार अपडेट करता रहता है. readData का इस्तेमाल करके, किसी भी समय सबसे नया डेटा हासिल किया जा सकता है.

ध्यान दें कि LocalRecordingClient, 10 दिनों तक का डेटा सेव करता है. डेटा खोने के जोखिम को कम करने के लिए, WorkManager का इस्तेमाल करके, बैकग्राउंड में समय-समय पर डेटा इकट्ठा किया जा सकता है.

फ़िटनेस डेटा की सदस्यता छोड़ना

संसाधन खाली करने के लिए, यह पक्का करें कि जब आपके ऐप्लिकेशन को सेंसर डेटा की ज़रूरत न हो, तब उसकी सदस्यता छोड़ दी जाए. सदस्यता छोड़ने के लिए, unsubscribe तरीके का इस्तेमाल करें:

val localRecordingClient = FitnessLocal.getLocalRecordingClient(this)
// Unsubscribe from steps data
localRecordingClient.unsubscribe(LocalDataType.TYPE_STEP_COUNT_DELTA)
  .addOnSuccessListener {
    Log.i(TAG, "Successfully unsubscribed!")
  }
  .addOnFailureListener { e ->
    Log.w(TAG, "There was a problem unsubscribing.", e)
  }