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

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

इस गाइड से, मोबाइल पर रिकॉर्डिंग एपीआई को इस्तेमाल करने का तरीका पता चलता है. साथ ही, फ़िटनेस से जुड़े अनुभव.

अहम जानकारी

मोबाइल पर रिकॉर्डिंग एपीआई में, कई खास सुविधाएं मिलती हैं:

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

डेटा टाइप

मोबाइल पर रिकॉर्डिंग एपीआई की मदद से, इस तरह का डेटा रिकॉर्ड किया जा सकता है:

शुरू करें

शुरू करने के लिए, अपनी 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'
}

अनुमतियां मांगें

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

  • android.permission.ACTIVITY_RECOGNITION

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

मोबाइल पर रिकॉर्डिंग एपीआई का इस्तेमाल करने के लिए, उपयोगकर्ता के पास Google Play सेवाएं होनी चाहिए 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 बनाया जा रहा है, जैसा कि इस कोड में दिखाया गया है snippet:

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