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-alpha02"
  ...
}

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

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

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

पता करना कि कोई सुविधा उपलब्ध है या नहीं

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

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

if (healthConnectClient
     .features
     .getFeatureStatus(
       HealthConnectFeatures.FEATURE_READ_HEALTH_DATA_IN_BACKGROUND
     ) == HealthConnectFeatures.FEATURE_STATUS_AVAILABLE) {

  // Feature is available
  ...
} else {
  // Feature is not available
  ...
}

अनुमतियों की जानकारी देना

सेहत और फ़िटनेस से जुड़े डेटा को ऐक्सेस करना संवेदनशील होता है. 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 को getSdkStatus का इस्तेमाल करके इंस्टॉल किया गया है या नहीं. अगर ऐसा है, तो HealthConnectClient इंस्टेंस पाएं.

val availabilityStatus = HealthConnectClient.getSdkStatus(context, providerPackageName)
if (availabilityStatus == HealthConnectClient.SDK_UNAVAILABLE) {
  return // early return as there is no viable integration
}
if (availabilityStatus == HealthConnectClient.SDK_UNAVAILABLE_PROVIDER_UPDATE_REQUIRED) {
  // Optionally redirect to package installer to find a provider, for example:
  val uriString = "market://details?id=$providerPackageName&url=healthconnect%3A%2F%2Fonboarding"
  context.startActivity(
    Intent(Intent.ACTION_VIEW).apply {
      setPackage("com.android.vending")
      data = Uri.parse(uriString)
      putExtra("overlay", true)
      putExtra("callerId", context.packageName)
    }
  )
  return
}
val healthConnectClient = HealthConnectClient.getOrCreate(context)
// Issue operations with healthConnectClient

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

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

इसके लिए, ज़रूरी डेटा टाइप के लिए अनुमतियों का सेट बनाएं. पक्का करें कि सेट में मौजूद अनुमतियों का एलान, सबसे पहले आपके 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 में उपलब्ध डेटा टाइप की सूची देखें.

val stepsRecord = StepsRecord(
    count = 120,
    startTime = START_TIME,
    endTime = END_TIME,
    startZoneOffset = START_ZONE_OFFSET,
    endZoneOffset = END_ZONE_OFFSET,
)

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

suspend fun insertSteps(healthConnectClient: HealthConnectClient) {
    val endTime = Instant.now()
    val startTime = endTime.minus(Duration.ofMinutes(15))
    try {
        val stepsRecord = StepsRecord(
            count = 120,
            startTime = startTime,
            endTime = endTime,
            startZoneOffset = ZoneOffset.UTC,
            endZoneOffset = ZoneOffset.UTC,
            metadata = Metadata.autoRecorded(
                device = Device(type = Device.TYPE_WATCH)
            ),
        )
        healthConnectClient.insertRecords(listOf(stepsRecord))
    } catch (e: Exception) {
        // Run error handling here
    }
}

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

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

suspend fun readHeartRateByTimeRange(
    healthConnectClient: HealthConnectClient,
    startTime: Instant,
    endTime: Instant
) {
    try {
        val response = healthConnectClient.readRecords(
            ReadRecordsRequest(
                HeartRateRecord::class,
                timeRangeFilter = TimeRangeFilter.between(startTime, endTime)
            )
        )
        for (record in response.records) {
            // Process each record
        }
    } catch (e: Exception) {
        // Run error handling here
    }
}

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

suspend fun aggregateSteps(
    healthConnectClient: HealthConnectClient,
    startTime: Instant,
    endTime: Instant
) {
    try {
        val response = healthConnectClient.aggregate(
            AggregateRequest(
                metrics = setOf(StepsRecord.COUNT_TOTAL),
                timeRangeFilter = TimeRangeFilter.between(startTime, endTime)
            )
        )
        // The result may be null if no data is available in the time range
        val stepCount = response[StepsRecord.COUNT_TOTAL]
    } catch (e: Exception) {
        // Run error handling here
    }
}

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

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

संसाधन

यहां दिए गए संसाधनों को देखें. इनसे आपको बाद में डेवलपमेंट में मदद मिलेगी.

अगले चरण

Health Connect में ये कार्रवाइयां करने का तरीका जानने के लिए, सामान्य वर्कफ़्लो देखें: