इकट्ठा किया गया डेटा देखना

Health Connect में डेटा इकट्ठा करने का मतलब है कि बुनियादी तौर पर डेटा इकट्ठा करना या डेटा को बकेट में इकट्ठा करना. यहां दिए गए वर्कफ़्लो से, दोनों काम करने का तरीका जानें.

बेसिक एग्रीगेशन

अपने डेटा पर बुनियादी एग्रीगेशन का इस्तेमाल करने के लिए, अपने HealthConnectClient ऑब्जेक्ट पर aggregate फ़ंक्शन का इस्तेमाल करें. यह AggregateRequest ऑब्जेक्ट को स्वीकार करता है. इसमें मेट्रिक टाइप और समयसीमा को पैरामीटर के तौर पर जोड़ा जाता है. बुनियादी एग्रीगेट को कैसे कॉल किया जाता है, यह इस्तेमाल की गई मेट्रिक के टाइप पर निर्भर करता है.

कुल एग्रीगेशन

कुल एग्रीगेशन से कुल वैल्यू का पता चलता है.

यहां दिए गए उदाहरण में, डेटा टाइप के लिए डेटा इकट्ठा करने का तरीका बताया गया है:

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

डेटा के ओरिजन के हिसाब से फ़िल्टर करना

कुल डेटा को उसके ऑरिजिन के हिसाब से भी फ़िल्टर किया जा सकता है. उदाहरण के लिए, सिर्फ़ किसी ऐप्लिकेशन से लिखा गया डेटा शामिल करना.

यहां दिए गए उदाहरण में, किसी ऐप्लिकेशन से मिले कदमों की जानकारी को इकट्ठा करने के लिए, dataOriginFilter और AggregateRequest का इस्तेमाल करने का तरीका बताया गया है:

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

आंकड़ों का एग्रीगेशन

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

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

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

बकेट

Health Connect, डेटा को बकेट में इकट्ठा करने की सुविधा भी देता है. आपके पास दो तरह के बकेट इस्तेमाल करने का विकल्प होता है. इनमें अवधि और अवधि शामिल हैं.

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

कुल अवधि

इस मामले में, एग्रीगेट किए गए डेटा को तय समयसीमा के अंदर बकेट में बांटा जाता है. जैसे, एक मिनट या एक घंटा. डेटा को बकेट में एग्रीगेट करने के लिए, aggregateGroupByDuration का इस्तेमाल करें. यह एक AggregateGroupByDurationRequest ऑब्जेक्ट स्वीकार करता है. इसमें मेट्रिक टाइप, समयसीमा, और Duration को पैरामीटर के तौर पर जोड़ा जाता है.

यहां, एक मिनट के बकेट में चरणों को इकट्ठा करने का उदाहरण दिखाया गया है:

suspend fun aggregateStepsIntoMinutes(
    healthConnectClient: HealthConnectClient,
    startTime: LocalDateTime,
    endTime: LocalDateTime
) {
    try {
        val response =
            healthConnectClient.aggregateGroupByDuration(
                AggregateGroupByDurationRequest(
                    metrics = setOf(StepsRecord.COUNT_TOTAL),
                    timeRangeFilter = TimeRangeFilter.between(startTime, endTime),
                    timeRangeSlicer = Duration.ofMinutes(1L)
                )
            )
        for (durationResult in response) {
            // The result may be null if no data is available in the time range
            val totalSteps = durationResult.result[StepsRecord.COUNT_TOTAL]
        }
    } catch (e: Exception) {
        // Run error handling here
    }
}

पीरियड का बटन

इस मामले में, इकट्ठा किए गए डेटा को तारीख के हिसाब से तय की गई समयावधि के अंदर बकेट में बांटा जाता है. जैसे, एक हफ़्ता या एक महीना. डेटा को बकेट में एग्रीगेट करने के लिए, aggregateGroupByPeriod का इस्तेमाल करें. यह एक AggregateGroupByPeriodRequest ऑब्जेक्ट स्वीकार करता है. इसमें मेट्रिक टाइप, समयसीमा, और Period को पैरामीटर के तौर पर जोड़ा जाता है.

यहां चरणों को महीने के हिसाब से बकेट में इकट्ठा करने का उदाहरण दिया गया है:

suspend fun aggregateStepsIntoMonths(
    healthConnectClient: HealthConnectClient,
    startTime: LocalDateTime,
    endTime: LocalDateTime
) {
    try {
        val response =
            healthConnectClient.aggregateGroupByPeriod(
                AggregateGroupByPeriodRequest(
                    metrics = setOf(StepsRecord.COUNT_TOTAL),
                    timeRangeFilter = TimeRangeFilter.between(startTime, endTime),
                    timeRangeSlicer = Period.ofMonths(1)
                )
            )
        for (monthlyResult in response) {
            // The result may be null if no data is available in the time range
            val totalSteps = monthlyResult.result[StepsRecord.COUNT_TOTAL]
        }
    } catch (e: Exception) {
        // Run error handling here
    }
}

पाबंदियां पढ़ना

डिफ़ॉल्ट रूप से, सभी ऐप्लिकेशन को Health Connect से 30 दिन पहले तक का डेटा ऐक्सेस करने की अनुमति होती है. यह अवधि, पहली बार अनुमति दिए जाने से शुरू होती है.

अगर आपको डिफ़ॉल्ट पाबंदियों के अलावा, पढ़ने की अनुमतियों को बढ़ाना है, तो PERMISSION_READ_HEALTH_DATA_HISTORY से अनुरोध करें. इसके अलावा, इस अनुमति के बिना 30 दिन से पुराने रिकॉर्ड को पढ़ने की कोशिश करने पर गड़बड़ी होती है.

मिटाए गए ऐप्लिकेशन के लिए अनुमतियों का इतिहास

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

उदाहरण के लिए, मान लें कि उपयोगकर्ता ने 10 मई, 2023 को आपका ऐप्लिकेशन मिटा दिया. इसके बाद, उसने 15 मई, 2023 को ऐप्लिकेशन को फिर से इंस्टॉल किया और पढ़ने की अनुमतियां दीं. आपका ऐप्लिकेशन अब डिफ़ॉल्ट रूप से, 15 अप्रैल, 2023 से डेटा पढ़ सकता है.

उपयोगकर्ता की ओर से चुने गए ऐप्लिकेशन की प्राथमिकताओं से प्रभावित कुल डेटा

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

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

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

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

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

बैकग्राउंड में पढ़ने की सुविधा

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

रिकॉर्ड के हिसाब से, एग्रीगेट किए गए डेटा टाइप

इस टेबल में, Health Connect रिकॉर्ड के साथ काम करने वाले सभी एग्रीगेट डेटा टाइप की सूची दी गई है.