मोबाइल पर रिकॉर्डिंग एपीआई

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

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

उदाहरण के लिए, GitHub पर Recording API on mobile sample देखें.

अहम जानकारी

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

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

डेटा टाइप

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

शुरू करें

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

Kotlin डीएसएल

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 अपवाद दिखाता है.

Fitness ऐप्लिकेशन के डेटा की सदस्यता लेना

चरणों के डेटा को बैकग्राउंड में इकट्ठा करने का अनुरोध करने के लिए, 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 तरीके का इस्तेमाल करके डेटा का अनुरोध करें. इसके बाद, LocalDataReadRequest बनाकर, LocalDataSet से LocalDataPoints पाएं, जैसा कि यहां दिए गए कोड स्निपेट में दिखाया गया है:

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)
  }