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

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

ध्यान दें: मोबाइल पर Recording API, Google Fit Android API की जगह इस्तेमाल किया जाता है. यह एपीआई अब सेवा में नहीं है.

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

उदाहरण के लिए, GitHub पर मोबाइल पर रिकॉर्डिंग एपीआई का सैंपल देखें.

अहम जानकारी

मोबाइल पर Recording API की कई खास सुविधाएं उपलब्ध हैं:

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

डेटा टाइप

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

• TYPE_STEP_COUNT_DELTA
• TYPE_DISTANCE_DELTA
• TYPE_CALORIES_EXPENDED

शुरू करें

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

Kotlin डीएसएल

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

...

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

ग्रूवी डीएसएल

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 to Fitness Data

कदमों की जानकारी को बैकग्राउंड में इकट्ठा करने का अनुरोध करने के लिए, 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)
  }

Read and Process Fitness Data

सदस्यता लेने के बाद, 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)
  }