ExerciseClient का इस्तेमाल करके, किसी कसरत को रिकॉर्ड करें

Health Services, कसरत करने वाले ऐप्लिकेशन के लिए बेहतरीन सहायता देता है. इसके लिए, ExerciseClient. ExerciseClient की मदद से, आपका ऐप्लिकेशन यह कंट्रोल कर सकता है कि व्यायाम चल रहा है, व्यायाम के लक्ष्य जोड़ें, और इसके बारे में अपडेट पाएँ स्थिति, कसरत वाले इवेंट, या अन्य इच्छित मेट्रिक का इस्तेमाल किया जा सकता है. ज़्यादा जानकारी के लिए, कसरत के टाइप का इस्तेमाल करें.

ज़्यादा जानकारी के लिए, कसरत का सैंपल GitHub पर.

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

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

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

Groovy

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

Kotlin

dependencies {
    implementation("androidx.health:health-services-client:1.1.0-alpha03")
}
अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है

ऐप्लिकेशन का स्ट्रक्चर

कसरत से जुड़ा कोई ऐप्लिकेशन बनाते समय, नीचे दिए गए ऐप्लिकेशन स्ट्रक्चर का इस्तेमाल करें स्वास्थ्य सेवाएं:

कसरत की तैयारी करते समय और वर्कआउट के दौरान, आपकी गतिविधि कई वजहों से रोके जा सकते हैं. उपयोगकर्ता किसी दूसरे ऐप्लिकेशन पर स्विच कर सकता है या होम स्क्रीन पर वापस जाएं. सिस्टम आपके डिवाइस के ऊपर कुछ दिखा सकता है कोई गतिविधि नहीं होती है या कुछ समय तक कोई गतिविधि न होने पर स्क्रीन बंद हो सकती है. लगातार चलने वाले ForegroundService का इस्तेमाल करें ExerciseClient के साथ जोड़ा जा सकता है, ताकि पूरे डेटा के लिए सही तरीके से काम किया जा सके और कसरत करें.

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

यह ज़रूरी है कि आप फ़ोरग्राउंड में जगह की जानकारी के डेटा का अनुरोध सही तरीके से करें सेवा. अपनी मेनिफ़ेस्ट फ़ाइल में, ज़रूरी फ़ोरग्राउंड सेवा की जानकारी दें टाइप और अनुमतियां:

<manifest ...>
  <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
    <application ...>
    
      <!-- If your app is designed only for devices that run Wear OS 4
           or lower, use android:foregroundServiceType="location" instead. -->
      <service
          android:name=".MyExerciseSessionRecorder"
          android:foregroundServiceType="health|location">
      </service>
      
    </application>
</manifest>
अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है

इस्तेमाल की जाने वाली चीज़ें AmbientLifecycleObserver कसरत से पहले की गतिविधि के लिए, जिसमें prepareExercise() कॉल और आपकी कसरत की गतिविधि के लिए. हालांकि, वर्कआउट के दौरान डिस्प्ले अपडेट न करें ऐंबियंट मोड के दौरान: ऐसा इसलिए होता है, क्योंकि Health Services कसरत के डेटा को बैच बनाकर इकट्ठा करता है जब पावर बचाने के लिए डिवाइस की स्क्रीन ऐंबियंट मोड में होती है, तो जानकारी हो सकता है कि प्रदर्शित हाल ही का न हो. वर्कआउट के दौरान, ऐसा डेटा दिखाएं जो अप-टू-डेट जानकारी या खाली स्क्रीन दिखा रहे उपयोगकर्ता.

सुविधाएं देखें

हर ExerciseType मेट्रिक और इनके लिए कुछ खास तरह के डेटा टाइप के साथ काम करता है व्यायाम के लक्ष्यों को हासिल करें. ऐप्लिकेशन को चालू करते समय इन सुविधाओं की जांच करें, क्योंकि ये अलग-अलग हो सकती हैं डिवाइस पर. ऐसा हो सकता है कि डिवाइस पर किसी खास तरह की कसरत के लिए सुविधा न हो या वह काम न करे किसी खास फ़ंक्शन के साथ काम करते हों, जैसे कि अपने-आप रुकने की सुविधा. साथ ही, डिवाइस की क्षमता में बदलाव हो सकता है, जैसे कि सॉफ़्टवेयर अपडेट होने के बाद.

ऐप स्टार्टअप पर, डिवाइस की क्षमताओं के बारे में क्वेरी करें और फ़ॉलो किया जा रहा है:

  • ऐसी कसरतें जो प्लैटफ़ॉर्म पर काम करती हैं.
  • हर कसरत के लिए इस्तेमाल की जाने वाली सुविधाएं.
  • हर कसरत के लिए इस्तेमाल किए गए डेटा टाइप.
  • उनमें से हर तरह के डेटा के लिए ज़रूरी अनुमतियां.

ExerciseCapabilities.getExerciseTypeCapabilities() का इस्तेमाल इसके साथ करें यह देखने के लिए कि किस तरह की मेट्रिक का अनुरोध किया जा सकता है, कसरत के ऐसे लक्ष्य जिन्हें कॉन्फ़िगर किया जा सकता है और जो उनके लिए उपलब्ध हैं आपकी सहायता कर सकता है. यह नीचे दिए गए उदाहरण में दिखाया गया है:

val healthClient = HealthServices.getClient(this /*context*/)
val exerciseClient = healthClient.exerciseClient
lifecycleScope.launch {
    val capabilities = exerciseClient.getCapabilitiesAsync().await()
    if (ExerciseType.RUNNING in capabilities.supportedExerciseTypes) {
        runningCapabilities =
            capabilities.getExerciseTypeCapabilities(ExerciseType.RUNNING)
    }
}

लौटाए गए ExerciseTypeCapabilities में, supportedDataTypes यह उन डेटा टाइप की सूची बनाता है जिनके लिए डेटा का अनुरोध किया जा सकता है. यह डिवाइस के हिसाब से अलग-अलग होता है, इसलिए ध्यान रखें कि आप ऐसे DataType का अनुरोध न करें जो मौजूद नहीं है या आपका अनुरोध विफल.

इसका इस्तेमाल करें supportedGoals और supportedMilestones यह तय करने के लिए फ़ील्ड कि वह कसरत आपके उस लक्ष्य का पूरा कर सकती है जिसे आपने बनाना चाहते हैं.

अगर आपका ऐप्लिकेशन, लोगों को अपने-आप रुकने की सुविधा इस्तेमाल करने की अनुमति देता है, तो आपको को यह जांच करनी चाहिए कि यह सुविधा supportsAutoPauseAndResume. ExerciseClient उन अनुरोधों को अस्वीकार कर देता है जो डिवाइस.

नीचे दिए गए उदाहरण में, HEART_RATE_BPM डेटा टाइप के साथ काम करने की जांच की गई है: STEPS_TOTAL लक्ष्य क्षमता और ऑटो-पॉज़ काम की क्षमता: 

// Whether we can request heart rate metrics.
supportsHeartRate = DataType.HEART_RATE_BPM in runningCapabilities.supportedDataTypes

// Whether we can make a one-time goal for aggregate steps.
val stepGoals = runningCapabilities.supportedGoals[DataType.STEPS_TOTAL]
supportsStepGoals = 
    (stepGoals != null && ComparisonType.GREATER_THAN_OR_EQUAL in stepGoals)

// Whether auto-pause is supported.
val supportsAutoPause = runningCapabilities.supportsAutoPauseAndResume

कसरत की स्थिति के बारे में अपडेट पाने के लिए रजिस्टर करें

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

val callback = object : ExerciseUpdateCallback {
    override fun onExerciseUpdateReceived(update: ExerciseUpdate) {
        val exerciseStateInfo = update.exerciseStateInfo
        val activeDuration = update.activeDurationCheckpoint
        val latestMetrics = update.latestMetrics
        val latestGoals = update.latestAchievedGoals
    }

    override fun onLapSummaryReceived(lapSummary: ExerciseLapSummary) {
        // For ExerciseTypes that support laps, this is called when a lap is marked.
    }

    override fun onAvailabilityChanged(
        dataType: DataType<*, *>,
        availability: Availability
    ) {
        // Called when the availability of a particular DataType changes.
        when {
            availability is LocationAvailability -> // Relates to Location/GPS.
            availability is DataTypeAvailability -> // Relates to another DataType.
        }
    }
}
exerciseClient.setUpdateCallback(callback)

कसरत के लाइफ़टाइम को मैनेज करें

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

अपना व्यायाम शुरू करने से पहले, ये करें:

  • जांचें कि क्या किसी व्यायाम को पहले से ही ट्रैक किया जा रहा है. और उस पर प्रतिक्रिया दें. उदाहरण के लिए, उपयोगकर्ता से पुष्टि करने के लिए कहें पिछले व्यायाम को ओवरराइड करने और नए व्यायाम को ट्रैक करने से पहले.

नीचे दिए गए उदाहरण में, किसी मौजूदा कसरत का पता लगाने का तरीका बताया गया है getCurrentExerciseInfoAsync:

lifecycleScope.launch {
    val exerciseInfo = exerciseClient.getCurrentExerciseInfoAsync().await()
    when (exerciseInfo.exerciseTrackedStatus) {
        OTHER_APP_IN_PROGRESS -> // Warn user before continuing, will stop the existing workout.
        OWNED_EXERCISE_IN_PROGRESS -> // This app has an existing workout.
        NO_EXERCISE_IN_PROGRESS -> // Start a fresh workout.
    }
}

अनुमतियां

ExerciseClient का इस्तेमाल करते समय, पक्का करें कि आपका ऐप्लिकेशन ज़रूरी अनुमतियां. अगर आपका ऐप्लिकेशन, LOCATION के डेटा का इस्तेमाल करता है, तो पक्का करें कि आपका ऐप्लिकेशन उचित अनुमतियां भी देनी होंगी.

सभी डेटा टाइप के लिए, prepareExercise() या startExercise() को कॉल करने से पहले, ये काम करें:

  • अपनी AndroidManifest.xml फ़ाइल में, अनुरोध किए गए डेटा टाइप के लिए सही अनुमतियां बताएं.
  • पुष्टि करें कि उपयोगकर्ता ने ज़रूरी अनुमतियां दी हैं. ज़्यादा जानकारी के लिए, यह देखें ऐप्लिकेशन अनुमतियों का अनुरोध करें. स्वास्थ्य सेवाएं अगर ज़रूरी अनुमतियां पहले से नहीं हैं, तो अनुरोध को अस्वीकार कर दिया जाता है अनुमति दी गई है.

जगह की जानकारी का डेटा देखने के लिए, नीचे दिए गए अतिरिक्त चरण पूरे करें:

  • यह जांचना कि क्या आपके डिवाइस पर GPS सक्षम है isProviderEnabled(LocationManager.GPS_PROVIDER). उपयोगकर्ता को जगह की जानकारी की सेटिंग खोलने का निर्देश दें ऐसा करना ज़रूरी है.
  • पक्का करें कि सही ForegroundService कसरत के दौरान, foregroundServiceType पर कोई असर नहीं पड़ता है.

वर्कआउट की तैयारी करें

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

prepareExerciseAsync() को कॉल करने से पहले, इनकी जांच करें:

  • पूरे प्लैटफ़ॉर्म के लिए जगह की जानकारी की सेटिंग देखें. उपयोगकर्ता इसमें इस सेटिंग को कंट्रोल करता है मुख्य सेटिंग मेन्यू; यह ऐप्लिकेशन लेवल की अनुमतियों से अलग होता है चेक करें.

    अगर यह सेटिंग बंद है, तो उपयोगकर्ता को सूचित करें कि उन्होंने है, और अगर आपके ऐप्लिकेशन को जगह की जानकारी की ज़रूरत हो, तो उन्हें इसे चालू करने के लिए कहें.

  • यह पुष्टि करें कि आपके ऐप्लिकेशन के पास बॉडी सेंसर और गतिविधि के लिए रनटाइम की अनुमतियां हैं की पहचान करने की ज़रूरत होती है. अनुपलब्ध अनुमतियों के लिए, उपयोगकर्ता को इसके लिए संकेत दें ज़रूरी जानकारी उपलब्ध कराने के लिए, रनटाइम की अनुमतियों का इस्तेमाल करें. अगर उपयोगकर्ता अनुमति नहीं देता है करने के लिए, उस अनुमति से जुड़े डेटा टाइप को हटाएं prepareExerciseAsync() के कॉल से. अगर बॉडी सेंसर और जगह की जानकारी की अनुमतियां, दोनों में से कोई एक न हों दिया गया है, prepareExerciseAsync() पर कॉल न करें, क्योंकि तैयार कॉल खास तौर पर व्यायाम शुरू करने से पहले एक स्थिर हृदय गति या GPS सुधार प्राप्त करना. ऐप्लिकेशन कदम के हिसाब से दूरी, रफ़्तार, स्पीड, और अन्य मेट्रिक हासिल की जा सकती हैं उन अनुमतियों की ज़रूरत है.

prepareExerciseAsync() को किया गया कॉल सफल हो, यह पक्का करने के लिए नीचे दिया गया तरीका अपनाएं:

  • AmbientLifecycleObserver का इस्तेमाल करें वर्कआउट से पहले की गतिविधि के लिए, जिसमें तैयारी रखने का कॉल शामिल है.
  • अपनी फ़ोरग्राउंड सेवा से prepareExerciseAsync() को कॉल करें. अगर यह सेवा और गतिविधि के लाइफ़साइकल से जुड़ा होता है, तो सेंसर की तैयारी बिना वजह ही मारे गए.
  • अगर उपयोगकर्ता, सेंसर बंद कर देता है और बैटरी कम खर्च करता है, तो endExercise() को कॉल करें कसरत से पहले की गतिविधि से बाहर चला जाता है.

नीचे दिए गए उदाहरण में, prepareExerciseAsync() को कॉल करने का तरीका बताया गया है:

val warmUpConfig = WarmUpConfig(
    ExerciseType.RUNNING,
    setOf(
        DataType.HEART_RATE_BPM,
        DataType.LOCATION
    )
)
// Only necessary to call prepareExerciseAsync if body sensor or location
//permissions are given
exerciseClient.prepareExerciseAsync(warmUpConfig).await()

// Data and availability updates are delivered to the registered listener.

ऐप्लिकेशन के PREPARING की स्थिति में आने के बाद, सेंसर की उपलब्धता के अपडेट हो जाते हैं ExerciseUpdateCallback में onAvailabilityChanged() तक डिलीवर किया गया. इसके बाद, यह जानकारी उपयोगकर्ता को दिखाई जा सकती है, ताकि वे तय कर सकें कि ताकि वे वर्कआउट शुरू कर सकें.

कसरत शुरू करें

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

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

नीचे दिए गए नमूने में हर टाइप के लक्ष्य को बनाने का तरीका बताया गया है:

const val CALORIES_THRESHOLD = 250.0
const val DISTANCE_THRESHOLD = 1_000.0 // meters

suspend fun startExercise() {
    // Types for which we want to receive metrics.
    val dataTypes = setOf(
        DataType.HEART_RATE_BPM,
        DataType.CALORIES_TOTAL,
        DataType.DISTANCE
    )

    // Create a one-time goal.
    val calorieGoal = ExerciseGoal.createOneTimeGoal(
        DataTypeCondition(
            dataType = DataType.CALORIES_TOTAL,
            threshold = CALORIES_THRESHOLD,
            comparisonType = ComparisonType.GREATER_THAN_OR_EQUAL
        )
    )

    // Create a milestone goal. To make a milestone for every kilometer, set the initial
    // threshold to 1km and the period to 1km.
    val distanceGoal = ExerciseGoal.createMilestone(
        condition = DataTypeCondition(
            dataType = DataType.DISTANCE_TOTAL,
            threshold = DISTANCE_THRESHOLD,
            comparisonType = ComparisonType.GREATER_THAN_OR_EQUAL
        ),
        period = DISTANCE_THRESHOLD
    )

    val config = ExerciseConfig(
        exerciseType = ExerciseType.RUNNING,
        dataTypes = dataTypes,
        isAutoPauseAndResumeEnabled = false,
        isGpsEnabled = true,
        exerciseGoals = mutableListOf<ExerciseGoal<Double>>(calorieGoal, distanceGoal)
    )
    exerciseClient.startExerciseAsync(config).await()
}

सभी व्यायामों के लिए लैप का निशान भी लगाया जा सकता है. स्वास्थ्य सेवाएं, लैप की अवधि के दौरान एग्रीगेट की गई मेट्रिक वाला ExerciseLapSummary.

पिछले उदाहरण में, isGpsEnabled के इस्तेमाल के बारे में बताया गया है, जो कि सही होना चाहिए जगह की जानकारी के डेटा का अनुरोध करते समय हालांकि, जीपीएस का इस्तेमाल करने से दूसरे मेट्रिक के काम करने में भी मदद मिल सकती है. अगर ExerciseConfig, दूरी को DataType के तौर पर तय करता है, तो यह डिफ़ॉल्ट रूप से तय होता है दूरी का अनुमान लगाने के लिए चरणों का इस्तेमाल करें. वैकल्पिक रूप से GPS सक्षम करके, स्थान दूरी का अनुमान लगाने के बजाय, जानकारी का इस्तेमाल किया जा सकता है.

कसरत रोकें, फिर से शुरू करें, और खत्म करें

आप सही तरीका इस्तेमाल करके कसरत को रोक सकते हैं, फिर से शुरू कर सकते हैं, और खत्म कर सकते हैं. जैसे, pauseExerciseAsync() या endExerciseAsync().

सबसे सटीक जानकारी के तौर पर, ExerciseUpdate में दिए गए राज्य का इस्तेमाल करें. यह कसरत नहीं है pauseExerciseAsync() को किए गए कॉल के वापस आने पर, इसे रोका गया. जब यह स्थिति ExerciseUpdate मैसेज में दिखती है. यह खास तौर पर यूज़र इंटरफ़ेस (यूआई) की स्थितियों पर ध्यान देना ज़रूरी है. अगर उपयोगकर्ता 'रोकें' बटन को दबाता है, 'रोकें' बटन को बंद करें और इस पर pauseExerciseAsync() को कॉल करें स्वास्थ्य सेवाएं. स्वास्थ्य सेवाओं के रोके गए क्रेडिट तक पहुंचने का इंतज़ार करें ExerciseUpdate.exerciseStateInfo.state का इस्तेमाल करके निर्देश दें और फिर बटन को बदलें उसे फिर से शुरू करने के लिए. ऐसा इसलिए है, क्योंकि स्वास्थ्य सेवाओं की नीति से जुड़े अपडेट मिलने में ज़्यादा समय लग सकता है बटन दबाने के बाद भी डिलीवर होता है. इसलिए, अगर यूज़र इंटरफ़ेस (यूआई) में किए गए सभी बदलावों को बटन से जोड़ा जाता है क्लिक करने पर, यूज़र इंटरफ़ेस (यूआई) स्वास्थ्य सेवाओं की स्थिति के साथ सिंक नहीं हो सकता.

नीचे दी गई स्थितियों में इसका ध्यान रखें:

  • अपने-आप रुकने की सुविधा चालू है: कसरत किए बिना, कसरत को रोका या शुरू किया जा सकता है उपयोगकर्ता इंटरैक्शन.
  • किसी दूसरे ऐप्लिकेशन ने कसरत शुरू की: आपकी कसरत बिना किसी वजह के खत्म हो सकती है उपयोगकर्ता इंटरैक्शन.

अगर किसी दूसरे ऐप्लिकेशन ने आपके ऐप्लिकेशन की कसरत को बंद कर दिया है, तो आपके ऐप्लिकेशन को समझौता खत्म होने की समस्या हल करने के लिए:

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

साथ ही, उस मामले को मैनेज करें जहां किसी चरण के दौरान अनुमतियां वापस ले ली जाती हैं लगातार व्यायाम कर रहे हैं. इसे isEnded स्थिति का इस्तेमाल करके भेजा जाता है. ExerciseEndReason AUTO_END_PERMISSION_LOST में से. इस केस को समाप्ति केस: आंशिक स्थिति को सेव करें, चल रही गतिविधि को हटाएं आइकन पर क्लिक करें और उपयोगकर्ता को इस बारे में सूचना भेजें.

नीचे दिए गए उदाहरण में, खाते के बंद होने की जांच करने का सही तरीका बताया गया है:

val callback = object : ExerciseUpdateCallback {
    override fun onExerciseUpdateReceived(update: ExerciseUpdate) {
        if (update.exerciseStateInfo.state.isEnded) {
            // Workout has either been ended by the user, or otherwise terminated
        }
        ...
    }
    ...
}

ऐक्टिव अवधि को मैनेज करें

व्यायाम के दौरान, कोई ऐप सक्रिय रहने की कुल अवधि दिखा सकता है वाली कसरतें हैं. ऐप्लिकेशन, Health Services, और डिवाइस की माइक्रो कंट्रोलर यूनिट (MCU)—लो-पावर कसरत की ट्रैकिंग के लिए ज़िम्मेदार प्रोसेसर—इन सभी को सिंक में होना चाहिए, जिसमें एक ही चालू अवधि होनी चाहिए. इसे मैनेज करने में मदद करने के लिए, स्वास्थ्य सेवाएं ActiveDurationCheckpoint जो ऐंकर पॉइंट देता है. इससे ऐप्लिकेशन ये काम कर सकता है इसका टाइमर शुरू करती है.

इसकी वजह यह है कि चालू रहने की अवधि, MCU से भेजी जाती है और ऐप्लिकेशन में आने के समय के हिसाब से, ActiveDurationCheckpoint में दो प्रॉपर्टी शामिल होती हैं:

  • activeDuration: कसरत कितने समय पहले की गई थी
  • time: जब ऐक्टिव अवधि का हिसाब लगाया गया था

इसलिए, ऐप में किसी व्यायाम की सक्रिय अवधि नीचे दिए गए समीकरण का इस्तेमाल करके ActiveDurationCheckpoint से कैलकुलेट किया गया है:

(now() - checkpoint.time) + checkpoint.activeDuration

इसे चालू अवधि की गणना के बीच के छोटे डेल्टा को ध्यान में रखा जाता है पर पहुंच रहे हैं और ऐप पर पहुंच रहे हैं. इसकी मदद से, क्रोनोमीटर इस्तेमाल किया जा सकता है इससे आपको ऐप्लिकेशन का टाइमर मिलता है. इससे यह पक्का किया जा सकता है कि ऐप्लिकेशन का टाइमर, समय के हिसाब से सही है या नहीं का डॉक्टर हूं.

अगर कसरत को रोका जाता है, तो ऐप्लिकेशन, यूज़र इंटरफ़ेस (यूआई) में टाइमर को रीस्टार्ट करने का इंतज़ार करता है यूज़र इंटरफ़ेस (यूआई) में मौजूदा समय में दिखने वाला समय खत्म हो जाता है. ऐसा इसलिए होता है, क्योंकि रोकने का सिग्नल स्वास्थ्य सेवाओं और MCU तक थोड़ी देरी होगी. उदाहरण के लिए, अगर ऐप्लिकेशन को t=10 सेकंड पर रोका जाता है, तो Health ऐसा हो सकता है कि सेवाएं, t=10.2 सेकंड तक ऐप्लिकेशन को PAUSED का अपडेट न दे पाएं.

ExerciseClient से मिले डेटा के साथ काम करें

आपके ऐप्लिकेशन ने जिन डेटा टाइप के लिए रजिस्टर किया है उनसे जुड़ी मेट्रिक ExerciseUpdate मैसेज.

प्रोसेसर चालू होने या ज़्यादा से ज़्यादा रिपोर्टिंग की स्थिति में ही मैसेज डिलीवर करता है अवधि पूरी हो जाती है, जैसे कि हर 150 सेकंड. इन बातों पर भरोसा न करें: घंटे के साथ आगे बढ़ने के लिए, ExerciseUpdate फ़्रीक्वेंसी activeDuration. ज़्यादा जानकारी के लिए, कसरत का सैंपल पर एक उदाहरण देखें.

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

बैच बनाने की दर को कंट्रोल करें

कुछ मामलों में, हो सकता है कि आप अपने ऐप्लिकेशन की फ़्रीक्वेंसी को कंट्रोल करना चाहें स्क्रीन बंद होने पर भी कुछ डेटा टाइप रिसीव करता है. ऐप्लिकेशन BatchingMode ऑब्जेक्ट, डेटा पाने के लिए आपके ऐप्लिकेशन को बैच बनाने की डिफ़ॉल्ट प्रक्रिया को बदलने देता है अक्सर.

एक साथ कई ईमेल भेजने की दर को कॉन्फ़िगर करने के लिए, यह तरीका अपनाएं:

  1. यह पता करें कि डिवाइस पर BatchingMode की कौनसी डेफ़िनिशन काम करती है:

    // Confirm BatchingMode support to control heart rate stream to phone.
suspend fun supportsHrWorkoutCompanionMode(): Boolean {
    val capabilities = exerciseClient.getCapabilities()
    return BatchingMode.HEART_RATE_5_SECONDS in
            capabilities.supportedBatchingModeOverrides
}

  2. बताएं कि ExerciseConfig ऑब्जेक्ट को किसी खास BatchingMode, जैसा कि इस कोड स्निपेट में दिखाया गया है.

    val config = ExerciseConfig(
    exerciseType = ExerciseType.WORKOUT,
    dataTypes = setOf(
        DataType.HEART_RATE_BPM,
        DataType.TOTAL_CALORIES
    ),
    // ...
    batchingModeOverrides = setOf(BatchingMode.HEART_RATE_5_SECONDS)
)

  3. इसके अलावा, कसरत के दौरान BatchingMode को डाइनैमिक तरीके से कॉन्फ़िगर किया जा सकता है. एक खास बैचिंग व्यवहार के बजाय, जो पूरी अवधि के दौरान बना रहता है कसरत का प्रतिशत:

    val desiredModes = setOf(BatchingMode.HEART_RATE_5_SECONDS)
exerciseClient.overrideBatchingModesForActiveExercise(desiredModes)

  4. पसंद के मुताबिक बनाए गए BatchingMode को मिटाने और डिफ़ॉल्ट सेटिंग पर वापस जाने के लिए, एक खाली सेट exerciseClient.overrideBatchingModesForActiveExercise().

टाइमस्टैंप

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

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

इसके बाद, इस वैल्यू का इस्तेमाल getStartInstant() के साथ किया जा सकता है या getEndInstant() एक डेटा पॉइंट है.

डेटा कितना सटीक है

कुछ डेटा टाइप में, हर डेटा पॉइंट से जुड़ी सटीक जानकारी हो सकती है. इसे accuracy प्रॉपर्टी में दिखाया जाता है.

इनके लिए, HrAccuracy और LocationAccuracy क्लास में अपने-आप जानकारी भरी जा सकती है: HEART_RATE_BPM और LOCATION डेटा टाइप. जहां मौजूद हो वहां इसका इस्तेमाल करें accuracy प्रॉपर्टी का इस्तेमाल करके पता लगाया जा सकता है कि हर डेटा पॉइंट ज़रूरत के मुताबिक है या नहीं आपके आवेदन की सही जानकारी.

डेटा को सेव और अपलोड करना

Health से डिलीवर किए गए डेटा को सेव रखने के लिए रूम का इस्तेमाल करें सेवाएं. कसरत के खत्म होने पर, डेटा अपलोड करने के लिए एक तरीके का इस्तेमाल किया जाता है जैसे कि वर्क मैनेजर. इससे पक्का होता है कि कि यह एक्सरसाइज़ खत्म होने तक डेटा अपलोड करने के लिए नेटवर्क कॉल टाल देता है, कसरत के दौरान ऊर्जा की खपत को कम करना और काम को आसान बनाना.

एकीकरण चेकलिस्ट

स्वास्थ्य सेवाओं का इस्तेमाल करने वाला ऐप्लिकेशन पब्लिश करने से पहले ExerciseClient, सलाह लें नीचे दी गई चेकलिस्ट देखें, ताकि यह पक्का किया जा सके कि आपके उपयोगकर्ता अनुभव को कुछ सामान्य समस्याओं से बचाया जा सके. पुष्टि करें कि:

  • आपका ऐप्लिकेशन सुविधाओं की जांच करता है और हर बार ऐप्लिकेशन चलाने पर डिवाइस की क्षमता का पता चलता है. इस तरह, यह पता लगाया जा सकता है कि किसी डिवाइस या कसरत पर यह सुविधा काम नहीं करती डेटा टाइप का पता लगाता है.
  • आप ज़रूरी अनुमतियों का अनुरोध करते हैं और उन्हें बनाए रखते हैं. साथ ही, इन अनुमतियों के बारे में यहां बताया गया है को अपलोड करने की ज़रूरत नहीं है. prepareExerciseAsync() को कॉल करने से पहले, आपका ऐप्लिकेशन यह पुष्टि करता है कि रनटाइम की अनुमतियां दी गई हैं.
  • आपका ऐप्लिकेशन ऐसे मामलों को मैनेज करने के लिए getCurrentExerciseInfoAsync() का इस्तेमाल करता है जिनमें:
    • किसी कसरत को पहले से ही ट्रैक किया जा रहा है और आपका ऐप्लिकेशन उसे व्यायाम.
    • किसी अन्य ऐप्लिकेशन ने आपकी कसरत को खत्म कर दिया है. ऐसा तब हो सकता है, जब उपयोगकर्ता ऐप्लिकेशन को दोबारा खोलते हैं, लेकिन उनके सामने एक मैसेज मिलता है. इसमें यह बताया जाता है कि यह कसरत रुक गया है, क्योंकि किसी दूसरे ऐप्लिकेशन ने इसकी जगह ले ली है.
  • अगर LOCATION का डेटा इस्तेमाल किया जा रहा है, तो:
    • आपका ऐप्लिकेशन, आपके ऐप्लिकेशन की ForegroundService कसरत के दौरान foregroundServiceType (इसमें ये शामिल हैं कॉल करें).
    • यह जांचना कि क्या आपके डिवाइस पर GPS सक्षम है isProviderEnabled(LocationManager.GPS_PROVIDER). इसके बाद, उपयोगकर्ता को ज़रूरत होने पर जगह की जानकारी की सेटिंग खोलें.
    • जब जगह की जानकारी का डेटा कम मिल रहा हो, तब ज़रूरी इस्तेमाल के लिए इंतज़ार का समय बहुत ज़रूरी है, इसलिए Fused जगह की जानकारी देने वाली कंपनी (FLP) और इसके डेटा का इस्तेमाल, जगह की जानकारी के शुरुआती सुधार के तौर पर किया जा सकता है. ज़्यादा स्थिर होने पर जगह की जानकारी Health Services से उपलब्ध है. इसके बजाय, इसका इस्तेमाल करें FLP में बदल जाएगा.
  • अगर आपके ऐप्लिकेशन को डेटा अपलोड करना ज़रूरी है, तो डेटा अपलोड करने के लिए किए जाने वाले नेटवर्क कॉल व्यायाम समाप्त होने तक टाला जाता है. अगर ऐसा नहीं है, तो कसरत के दौरान ऐप किसी भी ज़रूरी नेटवर्क कॉल को बहुत ही कम समय में करता है.
{% endverba नया %} {% verbatim %}