Health Connect का इस्तेमाल शुरू करना

यह गाइड, Health Connect के वर्शन 1.1.0-alpha12 के साथ काम करती है.

इस गाइड में बताया गया है कि अपने ऐप्लिकेशन में Health Connect का इस्तेमाल कैसे शुरू किया जा सकता है.

पहला चरण: Health Connect ऐप्लिकेशन तैयार करना

Health Connect ऐप्लिकेशन, आपके ऐप्लिकेशन के Health Connect SDK टूल के ज़रिए भेजे गए सभी अनुरोधों को मैनेज करता है. इन अनुरोधों में, डेटा सेव करना और उसके ऐक्सेस को मैनेज करना शामिल है.

Health Connect को ऐक्सेस करने की सुविधा, फ़ोन में इंस्टॉल किए गए Android वर्शन पर निर्भर करती है. यहां दिए गए सेक्शन में, Android के हाल ही के कुछ वर्शन को मैनेज करने का तरीका बताया गया है.

Android 14

Android 14 (एपीआई लेवल 34) से, Health Connect, Android फ़्रेमवर्क का हिस्सा है. Health Connect का यह वर्शन, एक फ़्रेमवर्क मॉड्यूल है. इसलिए, इसे सेट अप करने की ज़रूरत नहीं है.

Android 13 और उससे पहले के वर्शन

Android 13 (एपीआई लेवल 33) और उससे पहले के वर्शन में, Health Connect, Android फ़्रेमवर्क का हिस्सा नहीं है. इसलिए, आपको Google Play Store से Health Connect ऐप्लिकेशन इंस्टॉल करना होगा.

अगर आपने अपने ऐप्लिकेशन को Android 13 और उससे पहले के वर्शन पर Health Connect के साथ इंटिग्रेट किया है और आपको Android 14 पर माइग्रेट करना है, तो Android 13 से 14 पर माइग्रेट करना लेख पढ़ें.

Health Connect ऐप्लिकेशन खोलना

अब Health Connect, डिफ़ॉल्ट रूप से होम स्क्रीन पर नहीं दिखता. Health Connect को सेटिंग में जाकर खोला जा सकता है. हालांकि, Android वर्शन के हिसाब से इसका पाथ अलग-अलग होता है:

• Android 14 और इसके बाद के वर्शन पर: सेटिंग > सुरक्षा और निजता > निजता कंट्रोल > Health Connect पर जाएं. इसके अलावा, सेटिंग में Health Connect खोजें.
• Android 13 और उससे पहले के वर्शन पर: सेटिंग > ऐप्लिकेशन > Health Connect पर जाएं. इसके अलावा, Health Connect को फ़टाफ़ट सेटिंग के मेन्यू में जोड़ें.

दूसरा चरण: अपने ऐप्लिकेशन में Health Connect SDK टूल जोड़ना

Health Connect SDK टूल, Health Connect API का इस्तेमाल करके, Health Connect ऐप्लिकेशन में मौजूद डेटा स्टोर के ख़िलाफ़ कार्रवाई करने के लिए अनुरोध भेजता है.

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

dependencies {
  ...
  implementation "androidx.health.connect:connect-client:1.2.0-alpha04"
  ...
}

नए वर्शन के लिए, Health Connect के रिलीज़ देखें.

Canary रिलीज़ चैनल की सुविधाओं का इस्तेमाल करना

Canary रिलीज़ चैनल में मौजूद सुविधाओं का इस्तेमाल करने के लिए, अपने मॉड्यूल-लेवल की build.gradle फ़ाइल में compileSdk का वर्शन बदलें:

android {
  compileSdkPreview = "CANARY"
}

तीसरा चरण: अपने ऐप्लिकेशन को कॉन्फ़िगर करना

यहां दिए गए सेक्शन में, अपने ऐप्लिकेशन को Health Connect के साथ इंटिग्रेट करने के लिए कॉन्फ़िगर करने का तरीका बताया गया है.

सुविधा की उपलब्धता देखें

Health Connect में नई सुविधाएं जोड़े जाने पर, हो सकता है कि उपयोगकर्ता अपने Health Connect के वर्शन को हमेशा अपडेट न करें. सुविधा की उपलब्धता के लिए एपीआई की मदद से, यह देखा जा सकता है कि Health Connect की कोई सुविधा, उपयोगकर्ता के डिवाइस पर उपलब्ध है या नहीं. साथ ही, यह तय किया जा सकता है कि क्या कार्रवाई करनी है.

सुविधा की उपलब्धता देखने के लिए, मुख्य फ़ंक्शन है getFeatureStatus(). इससे, इंटिजर कॉन्स्टैंट FEATURE_STATUS_AVAILABLE या FEATURE_STATUS_UNAVAILABLE मिलता है:

@OptIn(ExperimentalFeatureAvailabilityApi::class)
fun enqueueBackgroundReadWorker(context: Context, healthConnectClient: HealthConnectClient) {
    if (healthConnectClient
            .features
            .getFeatureStatus(
                HealthConnectFeatures.FEATURE_READ_HEALTH_DATA_IN_BACKGROUND
            ) == HealthConnectFeatures.FEATURE_STATUS_AVAILABLE
    ) {

        val periodicWorkRequest = PeriodicWorkRequestBuilder<ScheduleWorker>(1, TimeUnit.HOURS)
            .build()

        WorkManager.getInstance(context).enqueueUniquePeriodicWork(
            "read_health_connect",
            ExistingPeriodicWorkPolicy.KEEP,
            periodicWorkRequest
        )
    }
}
HealthConnectWorker.kt

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

सेहत और फ़िटनेस से जुड़े डेटा को ऐक्सेस करने के लिए, अनुमति देना ज़रूरी है. Health Connect, डेटा को पढ़ने और उसमें बदलाव करने के लिए सुरक्षा की एक लेयर लागू करता है, ताकि उपयोगकर्ताओं का भरोसा बना रहे.

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

Health Connect, Android की अनुमतियों के एलान के स्टैंडर्ड फ़ॉर्मैट का इस्तेमाल करता है. <uses-permission> टैग की मदद से, अनुमतियां असाइन करें. इन्हें <manifest> टैग में नेस्ट करें.

<manifest>
  <uses-permission android:name="android.permission.health.READ_HEART_RATE"/>
  <uses-permission android:name="android.permission.health.WRITE_HEART_RATE"/>
  <uses-permission android:name="android.permission.health.READ_STEPS"/>
  <uses-permission android:name="android.permission.health.WRITE_STEPS"/>

  <application>
  ...
  </application>
</manifest>

अनुमतियों और उनसे जुड़े डेटा टाइप की पूरी सूची देखने के लिए, डेटा टाइप की सूची देखें.

अपने ऐप्लिकेशन की निजता नीति का डायलॉग दिखाना

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

इस गतिविधि को, ACTION_SHOW_PERMISSIONS_RATIONALE इंटेंट को मैनेज करने के लिए एलान करें. यह इंटेंट, Health Connect की अनुमतियों वाली स्क्रीन में निजता नीति लिंक पर क्लिक करने पर, ऐप्लिकेशन को भेजा जाता है.

...
<application>
  ...
  <!-- For supported versions through Android 13, create an activity to show the rationale
       of Health Connect permissions once users click the privacy policy link. -->
  <activity
      android:name=".PermissionsRationaleActivity"
      android:exported="true">
    <intent-filter>
      <action android:name="androidx.health.ACTION_SHOW_PERMISSIONS_RATIONALE" />
    </intent-filter>
  </activity>

  <!-- For versions starting Android 14, create an activity alias to show the rationale
       of Health Connect permissions once users click the privacy policy link. -->
  <activity-alias
      android:name="ViewPermissionUsageActivity"
      android:exported="true"
      android:targetActivity=".PermissionsRationaleActivity"
      android:permission="android.permission.START_VIEW_PERMISSION_USAGE">
    <intent-filter>
      <action android:name="android.intent.action.VIEW_PERMISSION_USAGE" />
      <category android:name="android.intent.category.HEALTH_PERMISSIONS" />
    </intent-filter>
  </activity-alias>
  ...
</application>
...

Health Connect का क्लाइंट पाना

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

क्लाइंट इंस्टेंस पाने के लिए, सबसे पहले अपने Android मेनिफ़ेस्ट में Health Connect के पैकेज का नाम डालें.

<application> ... </application>
...
<!-- Check if Health Connect is installed -->
<queries>
    <package android:name="com.google.android.apps.healthdata" />
</queries>

इसके बाद, अपनी गतिविधि में देखें कि Health Connect इंस्टॉल है या नहीं using getSdkStatus. अगर इंस्टॉल है, तो HealthConnectClient का इंस्टेंस पाएं.

val availabilityStatus = HealthConnectClient.getSdkStatus(context)
if (availabilityStatus == HealthConnectClient.SDK_UNAVAILABLE) {
    Box(modifier = modifier.padding(16.dp), contentAlignment = Alignment.Center) {
        Text(
            text = "Health Connect is not available on this device. Please ensure it is installed and updated.",
            style = MaterialTheme.typography.bodyLarge,
            textAlign = TextAlign.Center
        )
    }
    return
}

val healthConnectClient = remember {
    if (availabilityStatus == HealthConnectClient.SDK_AVAILABLE) {
        HealthConnectClient.getOrCreate(context)
    } else {
        null
    }
}
HealthConnectActivity.kt

चौथा चरण: उपयोगकर्ता से अनुमतियों का अनुरोध करना

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

इसके लिए, ज़रूरी डेटा टाइप के लिए अनुमतियों का सेट बनाएं. पक्का करें कि सेट में मौजूद अनुमतियों का एलान, सबसे पहले आपके Android मेनिफ़ेस्ट में किया गया हो.

// Create a set of permissions for required data types
val PERMISSIONS =
    setOf(
  HealthPermission.getReadPermission(HeartRateRecord::class),
  HealthPermission.getWritePermission(HeartRateRecord::class),
  HealthPermission.getReadPermission(StepsRecord::class),
  HealthPermission.getWritePermission(StepsRecord::class)
)

यह देखने के लिए getGrantedPermissions का इस्तेमाल करें कि आपके ऐप्लिकेशन को पहले से ही ज़रूरी अनुमतियां मिली हुई हैं या नहीं. अगर नहीं मिली हैं, तो उन अनुमतियों का अनुरोध करने के लिए, createRequestPermissionResultContract का इस्तेमाल करें. इससे, Health Connect की अनुमतियों वाली स्क्रीन दिखती है.

// Create the permissions launcher
val requestPermissionActivityContract = PermissionController.createRequestPermissionResultContract()

val requestPermissions = registerForActivityResult(requestPermissionActivityContract) { granted ->
  if (granted.containsAll(PERMISSIONS)) {
    // Permissions successfully granted
  } else {
    // Lack of required permissions
  }
}

suspend fun checkPermissionsAndRun(healthConnectClient: HealthConnectClient) {
  val granted = healthConnectClient.permissionController.getGrantedPermissions()
  if (granted.containsAll(PERMISSIONS)) {
    // Permissions already granted; proceed with inserting or reading data
  } else {
    requestPermissions.launch(PERMISSIONS)
  }
}

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

उपयोगकर्ताओं की ऑनबोर्डिंग करना

कई ऐप्लिकेशन में, ऑनबोर्डिंग का कस्टम फ़्लो होता है. जैसे, सुविधा के बारे में जानकारी देना या उपयोगकर्ता की सहमति लेना. Health Connect को अपना ऑनबोर्डिंग फ़्लो लॉन्च करने की अनुमति देने के लिए, अपने मेनिफ़ेस्ट में यह जोड़ें:

<!-- Required to support pre-Android 14 devices with APK Health Connect -->
<activity
  android:name=".OnboardingActivity"
  android:exported="true"
  android:permission="com.google.android.apps.healthdata.permission.START_ONBOARDING">
  <intent-filter>
    <action android:name="androidx.health.ACTION_SHOW_ONBOARDING"/>
  </intent-filter>
</activity>
<!-- Required to support Android 14+ devices with platform Health Connect -->
<activity-alias
  android:name="UAndAboveOnboardingActivity"
  android:exported="true"
  android:targetActivity=".OnboardingActivity"
  android:permission="android.permission.health.START_ONBOARDING">
  <intent-filter>
    <action android:name="android.health.connect.action.SHOW_ONBOARDING" />
  </intent-filter>
</activity-alias>

उपयोगकर्ता, आपके ऐप्लिकेशन से सीधे तौर पर कनेक्ट करने की प्रोसेस, आपके ऐप्लिकेशन के बजाय Health Connect ऐप्लिकेशन से शुरू कर सकते हैं. अगर आपके ऐप्लिकेशन को, डेटा को पढ़ने या उसमें बदलाव करने की अनुमति मिलने के अलावा, किसी अन्य इंटरैक्शन की ज़रूरत है, तो ऑनबोर्डिंग गतिविधि उपलब्ध कराएं.

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

पांचवा चरण: कार्रवाइयां करना

अब सब कुछ सेट हो गया है, तो अपने ऐप्लिकेशन में डेटा को पढ़ने और उसमें बदलाव करने की कार्रवाइयां करें.

आपके उपयोगकर्ता, ऐसे अन्य ऐप्लिकेशन का इस्तेमाल कर सकते हैं जो Health Connect के साथ डेटा सिंक करते हैं. आपका ऐप्लिकेशन, इन ऐप्लिकेशन का डेटा ऐक्सेस कर सकता है. अगर उपयोगकर्ता ने इन ऐप्लिकेशन को Health Connect में डेटा सेव करने के लिए सेट अप नहीं किया है, तो Matchmaking API का इस्तेमाल करके, अपने उपयोगकर्ताओं के लिए इन ऐप्लिकेशन को आसानी से कनेक्ट किया जा सकता है.

डेटा सेव करने की अनुमति दें

अपने डेटा को रिकॉर्ड में स्ट्रक्चर करें. Health Connect में उपलब्ध डेटा टाइप की सूची देखें.

val zoneOffset = ZoneOffset.systemDefault().rules.getOffset(startTime)
val stepsRecord = StepsRecord(
    count = 120,
    startTime = startTime,
    endTime = endTime,
    startZoneOffset = zoneOffset,
    endZoneOffset = zoneOffset,
    metadata = Metadata(
        device = Device(type = Device.TYPE_WATCH),
        recordingMethod = Metadata.RECORDING_METHOD_AUTOMATICALLY_RECORDED
    )
)
healthConnectClient.insertRecords(listOf(stepsRecord))
HealthConnectManager.kt

इसके बाद, insertRecords का इस्तेमाल करके अपना रिकॉर्ड सेव करें.

val zoneOffset = ZoneOffset.systemDefault().rules.getOffset(startTime)
val stepsRecord = StepsRecord(
    count = 120,
    startTime = startTime,
    endTime = endTime,
    startZoneOffset = zoneOffset,
    endZoneOffset = zoneOffset,
    metadata = Metadata(
        device = Device(type = Device.TYPE_WATCH),
        recordingMethod = Metadata.RECORDING_METHOD_AUTOMATICALLY_RECORDED
    )
)
healthConnectClient.insertRecords(listOf(stepsRecord))
HealthConnectManager.kt

डेटा पढ़ने की अनुमति दें

readRecords का इस्तेमाल करके, अपना डेटा अलग-अलग पढ़ा जा सकता है.

val response = healthConnectClient.readRecords(
    ReadRecordsRequest(
        HeartRateRecord::class,
        timeRangeFilter = TimeRangeFilter.between(startTime, endTime)
    )
)
response.records.forEach { record ->
    /* Process records */
}
HealthConnectManager.kt

` aggregate` का इस्तेमाल करके, अपना डेटा इकट्ठा करके भी पढ़ा जा सकता है.

suspend fun readStepsAggregate(startTime: Instant, endTime: Instant): Long {
    val response = healthConnectClient.aggregate(
        AggregateRequest(
            metrics = setOf(StepsRecord.COUNT_TOTAL),
            timeRangeFilter = TimeRangeFilter.between(startTime, endTime)
        )
    )
    return response[StepsRecord.COUNT_TOTAL] ?: 0L
}
HealthConnectManager.kt

वीडियो ट्यूटोरियल

ये वीडियो देखें. इनमें, Health Connect की सुविधाओं के बारे में ज़्यादा जानकारी दी गई है. साथ ही, आसानी से इंटिग्रेट करने के लिए सबसे सही तरीके बताए गए हैं:

• Health Connect में अनुमतियां मैनेज करना
• Health Connect में डेटा पढ़ना और उसमें बदलाव करना
• Health Connect को आसानी से इंटिग्रेट करने के लिए सुझाव

संसाधन

यहां दिए गए लेख पढ़ें. इनसे, बाद में डेवलपमेंट में मदद मिलेगी.

• Health Connect SDK टूल (Jetpack पर उपलब्ध): Health Connect API का इस्तेमाल करने के लिए, इस SDK टूल को अपने ऐप्लिकेशन में शामिल करें.
• एपीआई के बारे में जानकारी: Health Connect API के लिए, Jetpack के रेफ़रंस देखें.
• डेटा टाइप के इस्तेमाल का एलान करना: Play Console में, Health Connect के उन डेटा टाइप के ऐक्सेस का एलान करें जिन्हें आपका ऐप्लिकेशन पढ़ता और जिनमें डेटा सेव करता है.
• GitHub पर कोड का सैंपल और कोडलैब (ज़रूरी नहीं): शुरू करने में मदद पाने के लिए, GitHub पर कोड के सैंपल का कलेक्शन और कोडलैब की गतिविधि देखें.

अगले चरण

आम तौर पर इस्तेमाल होने वाले वर्कफ़्लो देखें. इससे आपको Health Connect में कार्रवाइयां करने का तरीका पता चलेगा. जैसे:

• डेटा सेव करना
• रॉ डेटा पढ़ना
• इकट्ठा किया गया डेटा पढ़ना