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

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
    }
}

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

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

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

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
    }
}

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

डिफ़ॉल्ट रूप से, आपका ऐप्लिकेशन किसी भी अनुमति के साथ 30 दिनों तक का डेटा पढ़ सकता है. PERMISSION_READ_HEALTH_DATA_HISTORY अनुमति मिलने पर, आपका ऐप्लिकेशन 30 दिन से ज़्यादा पुराना डेटा पढ़ सकता है.

30 दिनों के लिए पाबंदी

ऐप्लिकेशन, पहली बार अनुमति मिलने से 30 दिन पहले तक Health Connect का डेटा पढ़ सकते हैं.

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

30 दिनों के लिए

अगर किसी उपयोगकर्ता ने 30 मार्च, 2023 को आपके ऐप्लिकेशन को डेटा पढ़ने की अनुमति दी है, तो आपका ऐप्लिकेशन 28 फ़रवरी, 2023 से पहले का डेटा पढ़ सकता है.

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

30 दिन से ज़्यादा पुराना डेटा पढ़ना

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