Health Connect: Android Sağlık Verisi Entegrasyonu 2026 Rehberi

1// build.gradle.kts
2dependencies {
3    implementation("androidx.health.connect:connect-client:1.1.0-alpha11")
4 
5    // Wear OS entegrasyonu için (opsiyonel)
6    implementation("androidx.health:health-services-client:1.1.0-alpha04")
7}

1
2
3
4    
5
6 
7
8
9
10
11
12
13
14
15
16
17 
18
19
20    
21        
22    
23

1class HealthConnectManager(private val context: Context) {
2 
3    private val healthConnectClient by lazy {
4        HealthConnectClient.getOrCreate(context)
5    }
6 
7    companion object {
8        fun isHealthConnectAvailable(context: Context): Boolean {
9            val status = HealthConnectClient.getSdkStatus(context)
10            return status == HealthConnectClient.SDK_AVAILABLE
11        }
12 
13        fun getInstallIntent(context: Context): Intent? {
14            val status = HealthConnectClient.getSdkStatus(context)
15            return if (status == HealthConnectClient.SDK_UNAVAILABLE_PROVIDER_UPDATE_REQUIRED) {
16                // Kullanıcıyı Play Store'a yönlendir
17                Intent(Intent.ACTION_VIEW).apply {
18                    data = Uri.parse("market://details?id=com.google.android.apps.healthdata")
19                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
20                }
21            } else null
22        }
23    }
24 
25    // Client'a erişim noktası
26    suspend fun getClient(): HealthConnectClient {
27        return healthConnectClient
28    }
29}

1class HealthPermissionViewModel(
2    private val healthConnectManager: HealthConnectManager,
3    application: Application
4) : AndroidViewModel(application) {
5 
6    // İstenen tüm permission'lar
7    val requiredPermissions = setOf(
8        HealthPermission.getReadPermission(HeartRateRecord::class),
9        HealthPermission.getWritePermission(HeartRateRecord::class),
10        HealthPermission.getReadPermission(StepsRecord::class),
11        HealthPermission.getWritePermission(StepsRecord::class),
12        HealthPermission.getReadPermission(SleepSessionRecord::class),
13        HealthPermission.getReadPermission(ExerciseSessionRecord::class),
14        HealthPermission.getWritePermission(ExerciseSessionRecord::class),
15        HealthPermission.getReadPermission(WeightRecord::class),
16        HealthPermission.getWritePermission(WeightRecord::class),
17    )
18 
19    // Granted permission'ları kontrol et
20    suspend fun checkGrantedPermissions(): Set {
21        return healthConnectManager.getClient()
22            .permissionController
23            .getGrantedPermissions()
24    }
25 
26    // Eksik permission'ları hesapla
27    suspend fun getMissingPermissions(): Set {
28        val granted = checkGrantedPermissions()
29        return requiredPermissions - granted
30    }
31 
32    // Permission launch intent'i
33    fun getPermissionActivityContract(): ActivityResultContract, Set> {
34        return PermissionController.createRequestPermissionResultContract()
35    }
36}
37 
38// Activity/Fragment'ta kullanım
39class HealthActivity : ComponentActivity() {
40 
41    private val viewModel: HealthPermissionViewModel by viewModels()
42 
43    private val requestPermissions = registerForActivityResult(
44        viewModel.getPermissionActivityContract()
45    ) { granted ->
46        if (granted.containsAll(viewModel.requiredPermissions)) {
47            // Tüm izinler verildi
48            loadHealthData()
49        } else {
50            // Eksik izinler var - kullanıcıya bildir
51            showPermissionRationale(granted)
52        }
53    }
54 
55    override fun onCreate(savedInstanceState: Bundle?) {
56        super.onCreate(savedInstanceState)
57 
58        lifecycleScope.launch {
59            val missing = viewModel.getMissingPermissions()
60            if (missing.isNotEmpty()) {
61                requestPermissions.launch(missing)
62            } else {
63                loadHealthData()
64            }
65        }
66    }
67}

1class HealthDataWriter(private val client: HealthConnectClient) {
2 
3    // Adım verisi yaz
4    suspend fun writeSteps(
5        startTime: Instant,
6        endTime: Instant,
7        count: Long
8    ): InsertRecordsResponse {
9        val stepsRecord = StepsRecord(
10            startTime = startTime,
11            endTime = endTime,
12            count = count,
13            startZoneOffset = ZoneOffset.systemDefault().rules.getOffset(startTime),
14            endZoneOffset = ZoneOffset.systemDefault().rules.getOffset(endTime),
15            metadata = Metadata(
16                clientRecordId = "steps_${startTime.epochSecond}", // Idempotent insert
17                dataOrigin = DataOrigin(packageName = "com.myapp"),
18                recordingMethod = Metadata.RECORDING_METHOD_ACTIVELY_RECORDED
19            )
20        )
21        return client.insertRecords(listOf(stepsRecord))
22    }
23 
24    // Egzersiz seansı yaz (multi-metric)
25    suspend fun writeExerciseSession(
26        session: ExerciseData
27    ): InsertRecordsResponse {
28        val exerciseRecord = ExerciseSessionRecord(
29            startTime = session.startTime,
30            endTime = session.endTime,
31            exerciseType = ExerciseSessionRecord.EXERCISE_TYPE_RUNNING,
32            title = session.title,
33            notes = session.notes,
34            startZoneOffset = ZoneOffset.UTC,
35            endZoneOffset = ZoneOffset.UTC,
36            segments = session.segments.map { segment ->
37                ExerciseSegment(
38                    startTime = segment.startTime,
39                    endTime = segment.endTime,
40                    segmentType = ExerciseSegment.EXERCISE_SEGMENT_TYPE_RUNNING
41                )
42            },
43            laps = session.laps.map { lap ->
44                ExerciseLap(
45                    startTime = lap.startTime,
46                    endTime = lap.endTime,
47                    length = Length.meters(lap.distanceMeters)
48                )
49            }
50        )
51 
52        // İlgili kalp atış verilerini de birlikte yaz
53        val heartRateRecord = HeartRateRecord(
54            startTime = session.startTime,
55            endTime = session.endTime,
56            startZoneOffset = ZoneOffset.UTC,
57            endZoneOffset = ZoneOffset.UTC,
58            samples = session.heartRateSamples.map { sample ->
59                HeartRateRecord.Sample(
60                    time = sample.time,
61                    beatsPerMinute = sample.bpm
62                )
63            }
64        )
65 
66        return client.insertRecords(listOf(exerciseRecord, heartRateRecord))
67    }
68 
69    // Ağırlık verisi upsert (clientRecordId ile idempotent)
70    suspend fun upsertWeight(weightKg: Double, measuredAt: Instant) {
71        val weightRecord = WeightRecord(
72            weight = Mass.kilograms(weightKg),
73            time = measuredAt,
74            zoneOffset = ZoneOffset.systemDefault().rules.getOffset(measuredAt),
75            metadata = Metadata(
76                clientRecordId = "weight_${measuredAt.epochSecond / 3600}", // Saatlik idempotent
77            )
78        )
79        // insertRecords idempotent'tır: aynı clientRecordId'li kayıt varsa günceller
80        client.insertRecords(listOf(weightRecord))
81    }
82}

1class HealthDataReader(private val client: HealthConnectClient) {
2 
3    // Adım sayısını tarih aralığıyla oku
4    suspend fun readSteps(
5        startTime: Instant,
6        endTime: Instant
7    ): List {
8        val request = ReadRecordsRequest(
9            recordType = StepsRecord::class,
10            timeRangeFilter = TimeRangeFilter.between(startTime, endTime),
11            pageSize = 100
12        )
13        val response = client.readRecords(request)
14        return response.records
15    }
16 
17    // Kalp atış istatistiklerini toplu hesapla
18    suspend fun getHeartRateStats(
19        startTime: Instant,
20        endTime: Instant
21    ): HeartRateStats {
22        val response = client.aggregate(
23            AggregateRequest(
24                metrics = setOf(
25                    HeartRateRecord.BPM_AVG,
26                    HeartRateRecord.BPM_MIN,
27                    HeartRateRecord.BPM_MAX,
28                    HeartRateRecord.MEASUREMENTS_COUNT
29                ),
30                timeRangeFilter = TimeRangeFilter.between(startTime, endTime)
31            )
32        )
33 
34        return HeartRateStats(
35            avgBpm = response[HeartRateRecord.BPM_AVG] ?: 0.0,
36            minBpm = response[HeartRateRecord.BPM_MIN]?.toInt() ?: 0,
37            maxBpm = response[HeartRateRecord.BPM_MAX]?.toInt() ?: 0,
38            measurementCount = response[HeartRateRecord.MEASUREMENTS_COUNT]?.toInt() ?: 0
39        )
40    }
41 
42    // Uyku analizi
43    suspend fun getSleepData(lastNDays: Int = 7): List {
44        val endTime = Instant.now()
45        val startTime = endTime.minus(lastNDays.toLong(), ChronoUnit.DAYS)
46 
47        val request = ReadRecordsRequest(
48            recordType = SleepSessionRecord::class,
49            timeRangeFilter = TimeRangeFilter.between(startTime, endTime)
50        )
51 
52        return client.readRecords(request).records.map { session ->
53            SleepAnalysis(
54                date = session.startTime.atZone(ZoneOffset.systemDefault()).toLocalDate(),
55                durationMinutes = ChronoUnit.MINUTES.between(session.startTime, session.endTime),
56                stages = session.stages.groupBy { it.stage }
57                    .mapValues { (_, stages) ->
58                        stages.sumOf {
59                            ChronoUnit.MINUTES.between(it.startTime, it.endTime)
60                        }
61                    },
62                deepSleepMinutes = session.stages
63                    .filter { it.stage == SleepSessionRecord.STAGE_TYPE_DEEP }
64                    .sumOf { ChronoUnit.MINUTES.between(it.startTime, it.endTime) },
65                remSleepMinutes = session.stages
66                    .filter { it.stage == SleepSessionRecord.STAGE_TYPE_REM }
67                    .sumOf { ChronoUnit.MINUTES.between(it.startTime, it.endTime) }
68            )
69        }
70    }
71 
72    // Bucket aggregation: günlük adım trendi
73    suspend fun getDailyStepsTrend(lastNDays: Int = 30): List {
74        val endTime = Instant.now()
75        val startTime = endTime.minus(lastNDays.toLong(), ChronoUnit.DAYS)
76 
77        val response = client.aggregateGroupByPeriod(
78            AggregateGroupByPeriodRequest(
79                metrics = setOf(StepsRecord.COUNT_TOTAL),
80                timeRangeFilter = TimeRangeFilter.between(startTime, endTime),
81                timeRangeSlicer = Period.ofDays(1)
82            )
83        )
84 
85        return response.map { bucket ->
86            DailySteps(
87                date = bucket.startTime.atZone(ZoneOffset.systemDefault()).toLocalDate(),
88                steps = bucket.result[StepsRecord.COUNT_TOTAL]?.toInt() ?: 0
89            )
90        }
91    }
92}

1class HealthSyncManager(
2    private val client: HealthConnectClient,
3    private val preferences: SharedPreferences
4) {
5 
6    companion object {
7        private const val PREF_SYNC_TOKEN = "health_connect_sync_token"
8    }
9 
10    // İlk sync veya token geçersizleştiğinde
11    suspend fun getInitialChangesToken(): String {
12        val request = ChangesTokenRequest(
13            recordTypes = setOf(
14                StepsRecord::class,
15                HeartRateRecord::class,
16                SleepSessionRecord::class,
17                ExerciseSessionRecord::class
18            )
19        )
20        return client.getChangesToken(request)
21    }
22 
23    // Diferansiyel sync: sadece değişenleri al
24    suspend fun syncChanges(): SyncResult {
25        val token = preferences.getString(PREF_SYNC_TOKEN, null)
26            ?: getInitialChangesToken().also { saveToken(it) }
27 
28        var currentToken = token
29        val insertedRecords = mutableListOf()
30        val deletedUids = mutableListOf()
31 
32        do {
33            val changesResponse = client.getChanges(currentToken)
34 
35            for (change in changesResponse.changes) {
36                when (change) {
37                    is UpsertionChange -> insertedRecords.add(change.record)
38                    is DeletionChange -> deletedUids.add(change.recordId)
39                }
40            }
41 
42            currentToken = changesResponse.nextChangesToken
43 
44        } while (changesResponse.hasMore)
45 
46        // Yeni token'ı kaydet
47        saveToken(currentToken)
48 
49        return SyncResult(
50            upserted = insertedRecords,
51            deleted = deletedUids
52        )
53    }
54 
55    private fun saveToken(token: String) {
56        preferences.edit()
57            .putString(PREF_SYNC_TOKEN, token)
58            .apply()
59    }
60}

1suspend fun migrateFromGoogleFit(
2    fitnessClient: HistoryClient,
3    healthWriter: HealthDataWriter,
4    dateRange: Pair
5) {
6    // Google Fit'ten adım verisi oku
7    val dataReadRequest = DataReadRequest.Builder()
8        .read(DataType.TYPE_STEP_COUNT_DELTA)
9        .setTimeRange(
10            dateRange.first.toEpochMilli(),
11            dateRange.second.toEpochMilli(),
12            TimeUnit.MILLISECONDS
13        )
14        .build()
15 
16    val dataReadResult = fitnessClient.readData(dataReadRequest).await()
17 
18    // Health Connect formatına dönüştür
19    dataReadResult.getDataSet(DataType.TYPE_STEP_COUNT_DELTA)
20        .dataPoints
21        .forEach { dataPoint ->
22            val startInstant = Instant.ofEpochMilli(
23                dataPoint.getStartTime(TimeUnit.MILLISECONDS)
24            )
25            val endInstant = Instant.ofEpochMilli(
26                dataPoint.getEndTime(TimeUnit.MILLISECONDS)
27            )
28            val steps = dataPoint.getValue(Field.FIELD_STEPS).asInt().toLong()
29 
30            healthWriter.writeSteps(startInstant, endInstant, steps)
31        }
32}

1suspend fun readSamsungHealthData(client: HealthConnectClient): List {
2    val samsungOrigin = DataOrigin("com.samsung.android.shealth")
3 
4    val request = ReadRecordsRequest(
5        recordType = HeartRateRecord::class,
6        timeRangeFilter = TimeRangeFilter.between(
7            Instant.now().minus(24, ChronoUnit.HOURS),
8            Instant.now()
9        ),
10        dataOriginFilter = setOf(samsungOrigin)
11    )
12 
13    return client.readRecords(request).records
14}

1// Wear OS modülü (wearApp)
2class ExerciseService : ExerciseUpdateCallback, LifecycleService() {
3 
4    private lateinit var exerciseClient: ExerciseClient
5    private lateinit var healthServicesClient: HealthServicesClient
6 
7    override fun onCreate() {
8        super.onCreate()
9        healthServicesClient = HealthServices.getClient(this)
10        exerciseClient = healthServicesClient.exerciseClient
11    }
12 
13    // Egzersiz konfigürasyonu
14    suspend fun startRunningSession() {
15        val config = ExerciseConfig(
16            exerciseType = ExerciseType.RUNNING,
17            dataTypes = setOf(
18                DataType.HEART_RATE_BPM,
19                DataType.DISTANCE_TOTAL,
20                DataType.STEPS_TOTAL,
21                DataType.CALORIES_TOTAL,
22                DataType.PACE,
23                DataType.SPEED
24            ),
25            isAutoPauseAndResumeEnabled = true,
26            isGpsEnabled = true,
27            exerciseGoals = listOf(
28                ExerciseGoal.createOneTimeGoal(
29                    DataTypeCondition(
30                        dataType = DataType.DISTANCE_TOTAL,
31                        threshold = Value.ofDouble(5000.0), // 5km hedef
32                        comparisonType = ComparisonType.GREATER_THAN_OR_EQUAL
33                    )
34                )
35            )
36        )
37 
38        exerciseClient.setUpdateCallback(this, Dispatchers.IO.asExecutor(), this)
39        exerciseClient.startExercise(config).await()
40    }
41 
42    override fun onExerciseUpdateReceived(update: ExerciseUpdate) {
43        val latestMetrics = update.latestMetrics
44        val heartRate = latestMetrics.sample(DataType.HEART_RATE_BPM)
45        val distance = latestMetrics.total(DataType.DISTANCE_TOTAL)
46 
47        // UI güncelle veya notification fırlat
48        updateMetrics(heartRate?.value?.asDouble(), distance?.total?.asDouble())
49    }
50}
51 
52// Egzersiz tamamlandığında Health Connect'e kaydet (telefon tarafı)
53suspend fun syncWearExerciseToHealthConnect(
54    wearExerciseData: WearExerciseData,
55    healthWriter: HealthDataWriter
56) {
57    // Wear OS'ta Health Services API otomatik sync yapar Android 13+'ta
58    // Manuel sync için:
59    healthWriter.writeExerciseSession(
60        ExerciseData(
61            startTime = wearExerciseData.startTime,
62            endTime = wearExerciseData.endTime,
63            title = "Koşu - Wear OS",
64            heartRateSamples = wearExerciseData.heartRateSamples,
65            segments = emptyList(),
66            laps = wearExerciseData.laps
67        )
68    )
69}