सजगता को ट्रैक करना

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

Health Connect, माइंडफ़ुलनेस डेटा टाइप उपलब्ध कराता है. इससे मानसिक स्वास्थ्य के अलग-अलग पहलुओं को मेज़र किया जा सकता है. जैसे, तनाव और चिंता. माइंडफ़ुलनेस एक डेटा टाइप है, जो Health Connect में सेहत से जुड़े डेटा का हिस्सा है.

यह देखना कि Health Connect मौजूद और चालू है या नहीं

Health Connect का इस्तेमाल करने से पहले, आपके ऐप्लिकेशन को यह पुष्टि करनी चाहिए कि उपयोगकर्ता के डिवाइस पर Health Connect इंस्टॉल हो. ऐसा हो सकता है कि Health Connect, सभी डिवाइसों पर पहले से इंस्टॉल न हो या इसे बंद कर दिया गया हो. HealthConnectClient.getSdkStatus() का इस्तेमाल करके, यह देखा जा सकता है कि Health Connect उपलब्ध है या नहीं.

यह देखने का तरीका कि Health Connect मौजूद और चालू है या नहीं

fun checkHealthConnectAvailability(context: Context) {
    val providerPackageName = "com.google.android.apps.healthdata"
    val availabilityStatus = HealthConnectClient.getSdkStatus(context, providerPackageName)

    if (availabilityStatus == HealthConnectClient.SDK_UNAVAILABLE) {
      // Health Connect is not available. Guide the user to install/enable it.
      // For example, show a dialog.
      return // early return as there is no viable integration
    }
    if (availabilityStatus == HealthConnectClient.SDK_UNAVAILABLE_PROVIDER_UPDATE_REQUIRED) {
      // Health Connect is available but requires an update.
      // 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
    }
    // Health Connect is available, obtain a HealthConnectClient instance
    val healthConnectClient = HealthConnectClient.getOrCreate(context)
    // Issue operations with healthConnectClient
}

getSdkStatus() से मिले स्टेटस के आधार पर, ज़रूरी होने पर उपयोगकर्ता को Google Play Store से Health Connect इंस्टॉल या अपडेट करने के लिए कहा जा सकता है.

सुविधा की उपलब्धता

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

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

  // Feature is available
} else {
  // Feature isn't available
}
ज़्यादा जानने के लिए, सुविधा की उपलब्धता देखना लेख पढ़ें.

ज़रूरी अनुमतियां

माइंडफ़ुलनेस को ऐक्सेस करने के लिए, इन अनुमतियों का इस्तेमाल किया जाता है:

  • android.permission.health.READ_MINDFULNESS
  • android.permission.health.WRITE_MINDFULNESS

अपने ऐप्लिकेशन में माइंडफ़ुलनेस की सुविधा जोड़ने के लिए, MindfulnessSession डेटा टाइप के लिए अनुमतियों का अनुरोध करें.

यहां उस अनुमति के बारे में बताया गया है जिसके बारे में आपको एलान करना होगा, ताकि माइंडफ़ुलनेस से जुड़े डेटा में बदलाव किया जा सके:

<application>
  <uses-permission
android:name="android.permission.health.WRITE_MINDFULNESS" />
...
</application>

माइंडफ़ुलनेस का डेटा ऐक्सेस करने के लिए, आपको ये अनुमतियां मांगनी होंगी:

<application>
  <uses-permission
android:name="android.permission.health.READ_MINDFULNESS" />
...
</application>

उपयोगकर्ता से अनुमतियां मांगना

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

val permissions =
    setOf(
        HealthPermission.getReadPermission(MindfulnessSessionRecord::class),
        HealthPermission.getWritePermission(MindfulnessSessionRecord::class)
    )
getGrantedPermissions का इस्तेमाल करके देखें कि आपके ऐप्लिकेशन को ज़रूरी अनुमतियां पहले से मिली हैं या नहीं. अगर नहीं, तो उन अनुमतियों का अनुरोध करने के लिए, createRequestPermissionResultContract का इस्तेमाल करें. इससे Health Connect की अनुमतियों वाली स्क्रीन दिखती है.
val permissions = setOf(
        HealthPermission.getReadPermission(StepsRecord::class),
        HealthPermission.getWritePermission(StepsRecord::class),
        HealthPermission.getReadPermission(HeartRateRecord::class),
        HealthPermission.getWritePermission(HeartRateRecord::class)
    )

val requestPermissionsLauncher = rememberLauncherForActivityResult(
    contract = PermissionController.createRequestPermissionResultContract()
) { grantedPermissions ->
    if (grantedPermissions.containsAll(permissions)) {
        coroutineScope.launch { snackbarHostState.showSnackbar("Permissions granted!") }
    } else {
        coroutineScope.launch { snackbarHostState.showSnackbar("Permissions denied.") }
    }
}
उपयोगकर्ता किसी भी समय अनुमतियां दे सकते हैं या उन्हें वापस ले सकते हैं. इसलिए, आपके ऐप्लिकेशन को अनुमतियों का इस्तेमाल करने से पहले, हर बार उनकी जांच करनी होगी. साथ ही, उन स्थितियों को मैनेज करना होगा जिनमें अनुमति वापस ले ली गई है.

माइंडफ़ुलनेस सेशन के रिकॉर्ड में शामिल जानकारी

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

MindfulnessSessionRecord के लिए, माइंडफ़ुलनेस सेशन के ये टाइप उपलब्ध हैं:

  • MINDFULNESS_SESSION_TYPE_UNKNOWN
  • MINDFULNESS_SESSION_TYPE_MEDITATION
  • MINDFULNESS_SESSION_TYPE_BREATHING
  • MINDFULNESS_SESSION_TYPE_MUSIC
  • MINDFULNESS_SESSION_TYPE_MOVEMENT
  • MINDFULNESS_SESSION_TYPE_UNGUIDED

माइंडफ़ुलनेस सेशन के टाइप की पूरी सूची देखने के लिए, MindfulnessSessionRecord रेफ़रंस दस्तावेज़ देखें.

इस्तेमाल किए जा सकने वाले एग्रीगेशन

MindfulnessSessionRecord के लिए, एग्रीगेट की गई ये वैल्यू उपलब्ध हैं:

सजगता सेशन से जुड़ा डेटा लिखें

नीचे दिए गए कोड स्निपेट में, माइंडफ़ुलनेस सेशन को लिखने का तरीका बताया गया है:

val isAvailable = healthConnectClient.features.getFeatureStatus(FEATURE_MINDFULNESS_SESSION)

if (isAvailable == HealthConnectFeatures.FEATURE_STATUS_AVAILABLE) {

    val record = MindfulnessSessionRecord(
        startTime = Instant.now().minus(Duration.ofHours(1)),
        startZoneOffset = ZoneOffset.UTC,
        endTime = Instant.now(),
        endZoneOffset = ZoneOffset.UTC,
        mindfulnessSessionType = MindfulnessSessionRecord.MINDFULNESS_SESSION_TYPE_MEDITATION,
        title = "Lake meditation",
        notes = "Meditation by the lake",
        metadata = Metadata.activelyRecorded(
            clientRecordId = "myid",
            clientRecordVersion = 1L,
            device = Device(type = Device.TYPE_PHONE)
        )
    )

सजगता सेशन से जुड़ा डेटा पढ़ें

नीचे दिए गए कोड स्निपेट में, किसी समयावधि के दौरान माइंडफ़ुलनेस सेशन को पढ़ने का तरीका बताया गया है:

Val now = Instant.now()

val records = healthConnectClient.readRecords(
    ReadRecordsRequest(
        recordType = MindfulnessSessionRecord::class,
        timeRangeFilter = TimeRangeFilter.between(
            startTime = now.minus(Duration.ofHours(5)),
            endTime = now
        )
    )
)

// Process the returned records
records.records.forEach { session ->
    println("Mindfulness session:")
    println("Start: ${session.startTime}")
    println("End: ${session.endTime}")
    println("Title: ${session.title}")
    println("Notes: ${session.notes}")
    println("Type: ${session.mindfulnessSessionType}")
}