बैकग्राउंड में डेटा की निगरानी करें

पैसिव डेटा अपडेट, उन ऐप्लिकेशन के लिए सही हैं जिन्हें बैकग्राउंड में Health Services का डेटा मॉनिटर करना होता है. इनका इस्तेमाल ऐसे मामलों में किया जाता है जिनमें घंटों, दिनों या इससे भी ज़्यादा समय लगता है. अगर आपको ऐप्लिकेशन बंद होने पर या उपयोगकर्ता के किसी कसरत में शामिल न होने पर, सेहत और फ़िटनेस का डेटा सेव या प्रोसेस करना है, तो Health Service के पैसिव क्लाइंट का इस्तेमाल करें.

पैसिव डेटा के इस्तेमाल के उदाहरण देखने के लिए, GitHub पर पैसिव डेटा और पैसिव लक्ष्य के सैंपल देखें.

डिपेंडेंसी जोड़ें

Health Services पर डिपेंडेंसी जोड़ने के लिए, आपको अपने प्रोजेक्ट में Google Maven रिपॉज़िटरी जोड़नी होगी. ज़्यादा जानकारी के लिए, Google की Maven रिपॉज़िटरी देखें.

अपने मॉड्यूल-लेवल की build.gradle फ़ाइल में, यह डिपेंडेंसी जोड़ें:

ग्रूवी

dependencies {
    implementation "androidx.health:health-services-client:1.1.0-alpha05"
}

Kotlin

dependencies {
    implementation("androidx.health:health-services-client:1.1.0-alpha05")
}

सुविधाओं के बारे में जानकारी

डेटा अपडेट के लिए रजिस्टर करने से पहले, यह देख लें कि डिवाइस, आपके ऐप्लिकेशन की ज़रूरत के हिसाब से डेटा उपलब्ध करा सकता है या नहीं. जांच करने की सुविधाओं की मदद से, कुछ सुविधाओं को चालू या बंद किया जा सकता है. इसके अलावा, अपने ऐप्लिकेशन के यूज़र इंटरफ़ेस (यूआई) में बदलाव करके, उन सुविधाओं की कमी को पूरा किया जा सकता है जो उपलब्ध नहीं हैं.

val healthClient = HealthServices.getClient(this /*context*/)
val passiveMonitoringClient = healthClient.passiveMonitoringClient
lifecycleScope.launchWhenCreated {
    val capabilities = passiveMonitoringClient.capabilities.await()
    // Supported types for passive data collection
    supportsHeartRate =
        DataType.HEART_RATE_BPM in capabilities.supportedDataTypesPassiveMonitoring
    // Supported types for PassiveGoals
    supportsStepsGoal =
        DataType.STEPS_DAILY in capabilities.supportedDataTypesPassiveGoals
}

पैसिव डेटा के लिए रजिस्टर करना

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

आप जिस भी तरीके का इस्तेमाल करें, सबसे पहले एक PassiveListenerConfig बनाएं. इससे यह तय होता है कि किस तरह के डेटा टाइप को पाना है. इसे यहां दिए गए उदाहरण में दिखाया गया है:

val passiveListenerConfig = PassiveListenerConfig.builder()
    .setDataTypes(setOf(DataType.HEART_RATE_BPM))
    .build()

कॉलबैक का इस्तेमाल करके डेटा पाने के लिए, कॉलबैक को इस तरह से तय करें और रजिस्टर करें जैसा कि यहां दिए गए उदाहरण में दिखाया गया है:

val passiveListenerCallback: PassiveListenerCallback = object : PassiveListenerCallback {
    override fun onNewDataPointsReceived(dataPoints: DataPointContainer) {
        // TODO: Do something with dataPoints
    }
}

passiveMonitoringClient.setPassiveListenerCallback(
    passiveListenerConfig,
    passiveListenerCallback
)

// To remove the listener
passiveMonitoringClient.clearPassiveListenerCallbackAsync()

किसी सेवा का इस्तेमाल करने का तरीका एक जैसा होता है. हालांकि, PassiveListenerCallback से ली गई क्लास बनाने के बजाय, PassiveListenerService से ली गई क्लास बनाएं. जैसा कि इस उदाहरण में दिखाया गया है:

class PassiveDataService : PassiveListenerService() {
    override fun onNewDataPointsReceived(dataPoints: DataPointContainer) {
        // TODO: Do something with dataPoints
    }
}

passiveMonitoringClient.setPassiveListenerServiceAsync(
    PassiveDataService::class.java,
    passiveListenerConfig
)

इसके बाद, अपनी AndroidManifest.xml फ़ाइल में सेवा के बारे में बताएं. Health Services की अनुमति ज़रूरी है. इससे यह पुष्टि होती है कि सिर्फ़ Health Services ही सेवा से जुड़ सकता है:

<service android:name=".PassiveDataService"
    android:permission="com.google.android.wearable.healthservices.permission.PASSIVE_DATA_BINDING"
    android:exported="true" />

अनुवाद करने में लगने वाला समय

आपको Health Services से मिलने वाला डेटा बैच में होता है. इसलिए, आपको एक ही बैच में अलग-अलग तरह के डेटा पॉइंट या एक ही तरह के कई डेटा पॉइंट मिल सकते हैं. इवेंट के सही क्रम का पता लगाने के लिए, इन ऑब्जेक्ट में शामिल टाइमस्टैंप का इस्तेमाल करें. इसके बजाय, उस समय का इस्तेमाल करें जब आपके ऐप्लिकेशन को ये ऑब्जेक्ट मिले थे.

हर DataPoint के लिए टाइमस्टैंप पाने के लिए, सबसे पहले बूट टाइमस्टैंप का हिसाब लगाएं. इसके लिए, यहां दिया गया उदाहरण देखें:

val bootInstant =
    Instant.ofEpochMilli(System.currentTimeMillis() - SystemClock.elapsedRealtime())

इसके बाद, इस वैल्यू को getStartInstant() या getEndInstant() को पास किया जा सकता है.

बूट करने के बाद रजिस्ट्रेशन वापस पाएं

पैसिव डेटा रजिस्ट्रेशन, सिस्टम के फिर से चालू होने पर भी बने नहीं रहते. डिवाइस को रीस्टार्ट करने के बाद डेटा पाने के लिए, BroadcastReceiver का इस्तेमाल करके अपने रजिस्ट्रेशन फिर से बनाएं. यह ACTION_BOOT_COMPLETED सिस्टम ब्रॉडकास्ट को सुनता है.

पैसे पाने वाले के खाते में, सीधे तौर पर रजिस्ट्रेशन वापस लाने की कोशिश न करें. इसके बजाय, इस सुविधा को WorkManager वर्कर को सौंपें. डिवाइस चालू होने पर, Health Services को पैसिव डेटा रजिस्ट्रेशन के अनुरोध को स्वीकार करने में 10 सेकंड या उससे ज़्यादा समय लग सकता है. ऐसा हो सकता है कि यह समय, BroadcastReceiver के लिए तय किए गए समय से ज़्यादा हो. इसके उलट, WorkManager वर्कर के लिए, 10 मिनट की समयसीमा तय की गई है.

नीचे दिए गए स्निपेट में दिखाया गया है कि BroadcastReceiver कैसा दिख सकता है:

class StartupReceiver : BroadcastReceiver() {

   override fun onReceive(context: Context, intent: Intent) {
       if (intent.action != Intent.ACTION_BOOT_COMPLETED) return


       // TODO: Check permissions first
       WorkManager.getInstance(context).enqueue(
           OneTimeWorkRequestBuilder<RegisterForPassiveDataWorker>().build()
       )
   }
}

class RegisterForPassiveDataWorker(
   private val appContext: Context,
   workerParams: WorkerParameters
) : Worker(appContext, workerParams) {

   override fun doWork(): Result {
       runBlocking {
           HealthServices.getClient(appContext)
                .passiveMonitoringClient
                .setPassiveListenerCallback(...)
       }
       return Result.success()
   }
}

डिवाइस बूट अप होने पर सिस्टम को यह कोड चलाने के लिए, AndroidManifest.xml फ़ाइल में दो बदलाव करें.

सबसे पहले, <manifest> के चाइल्ड कॉम्पोनेंट के तौर पर यह अनुमति जोड़ें:

<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />

दूसरा, <application> के चाइल्ड के तौर पर, यहां दिए गए रिसीवर इंटेंट फ़िल्टर को जोड़ें:

<receiver
    android:name=".StartupReceiver"
    android:exported="true">
    <intent-filter>
        <action android:name="android.intent.action.BOOT_COMPLETED" />
    </intent-filter>
</receiver>

गतिविधि की स्थिति

पैसिव क्लाइंट, उपयोगकर्ता की स्थिति के बारे में भी खास जानकारी दे सकता है. जैसे, उपयोगकर्ता सो रहा है या नहीं. इन अपडेट को पाने के लिए, यह तरीका अपनाएं:

  1. ACTIVITY_RECOGNITION की अनुमति का अनुरोध करें.
  2. PassiveListenerConfig बिल्डर में setShouldUserActivityInfoBeRequested(true) को कॉल करें.

अपने कॉलबैक या सेवा में onUserActivityInfoReceived() तरीके को बदलें और UserActivityInfo से मिली वैल्यू का इस्तेमाल करें. ऐसा करने का तरीका इस उदाहरण में दिखाया गया है:

override fun onUserActivityInfoReceived(info: UserActivityInfo) {
    val stateChangeTime: Instant = info.stateChangeTime // may be in the past!
    val userActivityState: UserActivityState = info.userActivityState
    if (userActivityState == UserActivityState.USER_ACTIVITY_ASLEEP) {
        // ...
    }
}

पैसिव गोल

पैसिव क्लाइंट को कॉन्फ़िगर किया जा सकता है, ताकि पैसिव लक्ष्यों के पूरा होने पर ऐप्लिकेशन को सूचना मिल सके. जैसे, उपयोगकर्ता के एक दिन में 10,000 कदम पूरे करने पर.

इसके लिए, एक लक्ष्य बनाएं. यहां दिए गए उदाहरण में बताया गया है कि लक्ष्य कैसे बनाया जाता है:

val dailyStepsGoal by lazy {
    val condition = DataTypeCondition(
        dataType = DataType.STEPS_DAILY,
        threshold = 10_000, // Trigger every 10000 steps
        comparisonType = ComparisonType.GREATER_THAN_OR_EQUAL
    )
    PassiveGoal(condition)
}

इस लक्ष्य को अपने PassiveListenerConfig में जोड़ें. ऐसा करने का तरीका यहां दिए गए उदाहरण में बताया गया है:

val passiveListenerConfig = PassiveListenerConfig.builder()
    .setDailyGoals(setOf(dailyStepsGoal))
    .build()

अपने कॉलबैक या सेवा में onGoalCompleted() तरीके को बदलें और PassiveGoal का इस्तेमाल करें. इसके बारे में यहां दिए गए उदाहरण में बताया गया है:

override fun onGoalCompleted(goal: PassiveGoal) {
    when (goal.dataTypeCondition.dataType) {
        DataType.STEPS_DAILY -> {
            // ...
        }
    }
}