react-native-step-tracker-pro 1.0.0

package/android/src/main/java/com/steptrackerpro/db/StepDao.kt

@@ -0,0 +1,118 @@
+package com.steptrackerpro.db
+
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+import androidx.room.Transaction
+
+@Dao
+interface StepHistoryDao {
+
+    @Query("SELECT * FROM step_history WHERE date = :date LIMIT 1")
+    suspend fun findByDate(date: String): StepHistoryEntity?
+
+    @Query("SELECT * FROM step_history WHERE date BETWEEN :start AND :end ORDER BY date ASC")
+    suspend fun findRange(start: String, end: String): List<StepHistoryEntity>
+
+    @Query("SELECT COALESCE(SUM(steps), 0) FROM step_history WHERE date BETWEEN :start AND :end")
+    suspend fun sumSteps(start: String, end: String): Int
+
+    @Query("SELECT * FROM step_history WHERE synced = 0 ORDER BY date ASC LIMIT :limit")
+    suspend fun findUnsyncedHealth(limit: Int = 100): List<StepHistoryEntity>
+
+    @Query("SELECT * FROM step_history WHERE syncedRemote = 0 ORDER BY date ASC LIMIT :limit")
+    suspend fun findUnsyncedRemote(limit: Int = 100): List<StepHistoryEntity>
+
+    @Query("SELECT COUNT(*) FROM step_history WHERE synced = 0 OR syncedRemote = 0")
+    suspend fun countUnsynced(): Int
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insert(entity: StepHistoryEntity): Long
+
+    @Query(
+        """
+        UPDATE step_history
+        SET steps = :steps, distance = :distance, calories = :calories,
+            synced = 0, syncedRemote = 0, updatedAt = :updatedAt
+        WHERE date = :date
+        """
+    )
+    suspend fun update(
+        date: String,
+        steps: Int,
+        distance: Double,
+        calories: Double,
+        updatedAt: Long
+    ): Int
+
+    /**
+     * Upsert that never lets a re-anchored counter walk a day backwards: a
+     * lower step count for an existing date is ignored. Deliberate writes that
+     * must be allowed to lower a day - `resetToday()` - go through [replace].
+     */
+    @Transaction
+    suspend fun upsert(entity: StepHistoryEntity) {
+        val existing = findByDate(entity.date)
+        if (existing == null) {
+            insert(entity)
+            return
+        }
+        if (entity.steps < existing.steps) return
+        update(
+            date = entity.date,
+            steps = entity.steps,
+            distance = entity.distance,
+            calories = entity.calories,
+            updatedAt = System.currentTimeMillis()
+        )
+    }
+
+    @Query("UPDATE step_history SET synced = 1, updatedAt = :updatedAt WHERE date IN (:dates)")
+    suspend fun markSyncedHealth(dates: List<String>, updatedAt: Long = System.currentTimeMillis()): Int
+
+    @Query("UPDATE step_history SET syncedRemote = 1, updatedAt = :updatedAt WHERE date IN (:dates)")
+    suspend fun markSyncedRemote(dates: List<String>, updatedAt: Long = System.currentTimeMillis()): Int
+
+    /** Overwrites a day outright, downwards included. */
+    @Transaction
+    suspend fun replace(entity: StepHistoryEntity) {
+        val existing = findByDate(entity.date)
+        if (existing == null) {
+            insert(entity)
+            return
+        }
+        update(
+            date = entity.date,
+            steps = entity.steps,
+            distance = entity.distance,
+            calories = entity.calories,
+            updatedAt = System.currentTimeMillis()
+        )
+    }
+
+    @Query("DELETE FROM step_history WHERE date < :cutoff")
+    suspend fun deleteOlderThan(cutoff: String): Int
+
+    @Query("DELETE FROM step_history")
+    suspend fun deleteAll()
+}
+
+@Dao
+interface DailySummaryDao {
+
+    @Query("SELECT * FROM daily_summary WHERE date = :date LIMIT 1")
+    suspend fun findByDate(date: String): DailySummaryEntity?
+
+    @Query("SELECT * FROM daily_summary WHERE date BETWEEN :start AND :end ORDER BY date ASC")
+    suspend fun findRange(start: String, end: String): List<DailySummaryEntity>
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun upsert(entity: DailySummaryEntity)
+
+    @Query("DELETE FROM daily_summary WHERE date < :cutoff")
+    suspend fun deleteOlderThan(cutoff: String): Int
+
+    @Query("DELETE FROM daily_summary")
+    suspend fun deleteAll()
+}

package/android/src/main/java/com/steptrackerpro/db/StepDatabase.kt

@@ -0,0 +1,60 @@
+package com.steptrackerpro.db
+
+import android.content.Context
+import androidx.room.Database
+import androidx.room.Room
+import androidx.room.RoomDatabase
+import androidx.room.migration.Migration
+import androidx.sqlite.db.SupportSQLiteDatabase
+
+@Database(
+    entities = [StepHistoryEntity::class, DailySummaryEntity::class],
+    version = 2,
+    exportSchema = true
+)
+abstract class StepDatabase : RoomDatabase() {
+
+    abstract fun stepHistoryDao(): StepHistoryDao
+    abstract fun dailySummaryDao(): DailySummaryDao
+
+    companion object {
+        private const val NAME = "step_tracker_pro.db"
+
+        /**
+         * Health Connect and the remote endpoint used to share the `synced`
+         * flag, so whichever synced first hid the row from the other. Existing
+         * rows keep `synced` as the Health Connect flag and start out pending
+         * for the remote endpoint, which at worst re-uploads days the endpoint
+         * already has - the upload is keyed by date and is idempotent.
+         */
+        private val MIGRATION_1_2 = object : Migration(1, 2) {
+            override fun migrate(db: SupportSQLiteDatabase) {
+                db.execSQL(
+                    "ALTER TABLE step_history ADD COLUMN syncedRemote INTEGER NOT NULL DEFAULT 0"
+                )
+                db.execSQL(
+                    "CREATE INDEX IF NOT EXISTS index_step_history_syncedRemote " +
+                        "ON step_history (syncedRemote)"
+                )
+            }
+        }
+
+        @Volatile
+        private var instance: StepDatabase? = null
+
+        fun get(context: Context): StepDatabase =
+            instance ?: synchronized(this) {
+                instance ?: Room.databaseBuilder(
+                    context.applicationContext,
+                    StepDatabase::class.java,
+                    NAME
+                )
+                    .addMigrations(MIGRATION_1_2)
+                    // Counter state lives in SharedPreferences, so a corrupt or
+                    // unmigratable history file costs history, never the live count.
+                    .fallbackToDestructiveMigrationOnDowngrade()
+                    .build()
+                    .also { instance = it }
+            }
+    }
+}

package/android/src/main/java/com/steptrackerpro/db/StepRepository.kt

@@ -0,0 +1,146 @@
+package com.steptrackerpro.db
+
+import android.content.Context
+import androidx.room.withTransaction
+import com.steptrackerpro.core.DateKeys
+import com.steptrackerpro.core.DayTotals
+import com.steptrackerpro.core.RangeStats
+import com.steptrackerpro.core.SyncTarget
+
+/**
+ * Everything the rest of the package knows about storage. Callers deal in
+ * [DayTotals], never in Room entities.
+ */
+class StepRepository(context: Context) {
+
+    private val db = StepDatabase.get(context)
+    private val history = db.stepHistoryDao()
+    private val summaries = db.dailySummaryDao()
+
+    /**
+     * Writes a day, refusing to lower an existing count. Both tables move in one
+     * transaction so a process death cannot leave them disagreeing.
+     */
+    suspend fun saveDay(totals: DayTotals) = db.withTransaction {
+        history.upsert(totals.toEntity())
+        summaries.upsert(totals.toSummary())
+    }
+
+    /**
+     * Writes a day even when that lowers it. Only for deliberate, user-initiated
+     * writes - `resetToday()` - where [saveDay]'s guard would silently keep the
+     * old total and leave history disagreeing with the live counter forever.
+     */
+    suspend fun overwriteDay(totals: DayTotals) = db.withTransaction {
+        history.replace(totals.toEntity())
+        summaries.upsert(totals.toSummary())
+    }
+
+    suspend fun getDay(date: String): DayTotals =
+        history.findByDate(date)?.toTotals()
+            ?: DayTotals(date, 0, 0.0, 0.0, synced = true, syncedRemote = true)
+
+    /** Zero-filled, ascending, inclusive of both ends. */
+    suspend fun getRange(start: String, end: String): List<DayTotals> {
+        val stored = history.findRange(start, end).associateBy { it.date }
+        return DateKeys.rangeOf(start, end).map { key ->
+            stored[key]?.toTotals()
+                ?: DayTotals(key, 0, 0.0, 0.0, synced = true, syncedRemote = true)
+        }
+    }
+
+    /**
+     * @param live today's in-memory totals, which are newer than anything
+     *   committed to the database. Pass null when today is outside the range.
+     */
+    suspend fun stats(
+        start: String,
+        end: String,
+        goal: Int?,
+        live: DayTotals?
+    ): RangeStats {
+        // The live counter is authoritative for today: it is newer than anything
+        // committed, and after a reset it is legitimately lower than the stored
+        // row. Preferring the larger of the two would resurrect the old total.
+        val days = getRange(start, end).map { day ->
+            if (live != null && day.date == live.date) live else day
+        }
+        val totalSteps = days.sumOf { it.steps }
+        val totalDistance = days.sumOf { it.distance }
+        val totalCalories = days.sumOf { it.calories }
+        val activeDays = days.count { it.steps > 0 }
+
+        // Average over elapsed days only, so a partially finished month is not
+        // diluted by days that have not happened yet.
+        val today = DateKeys.today()
+        val elapsed = if (today in start..end) {
+            DateKeys.daysBetween(start, if (today < end) today else end)
+        } else {
+            days.size
+        }.coerceAtLeast(1)
+
+        return RangeStats(
+            startDate = start,
+            endDate = end,
+            totalSteps = totalSteps,
+            totalDistance = totalDistance,
+            totalCalories = totalCalories,
+            averageSteps = totalSteps / elapsed,
+            activeDays = activeDays,
+            bestDay = days.maxByOrNull { it.steps }?.takeIf { it.steps > 0 },
+            days = days,
+            goal = goal,
+            goalProgress = goal?.takeIf { it > 0 }?.let {
+                (totalSteps.toDouble() / it).coerceIn(0.0, 1.0)
+            }
+        )
+    }
+
+    suspend fun sumSteps(start: String, end: String): Int = history.sumSteps(start, end)
+
+    suspend fun unsynced(target: SyncTarget, limit: Int = 100): List<DayTotals> = when (target) {
+        SyncTarget.HEALTH_CONNECT -> history.findUnsyncedHealth(limit)
+        SyncTarget.REMOTE -> history.findUnsyncedRemote(limit)
+    }.map { it.toTotals() }
+
+    suspend fun countUnsynced(): Int = history.countUnsynced()
+
+    suspend fun markSynced(target: SyncTarget, dates: List<String>) {
+        if (dates.isEmpty()) return
+        when (target) {
+            SyncTarget.HEALTH_CONNECT -> history.markSyncedHealth(dates)
+            SyncTarget.REMOTE -> history.markSyncedRemote(dates)
+        }
+    }
+
+    /** Drops rows older than the retention window. Returns rows removed. */
+    suspend fun prune(retentionDays: Int): Int {
+        val cutoff = DateKeys.minusDays(DateKeys.today(), retentionDays.coerceAtLeast(1))
+        summaries.deleteOlderThan(cutoff)
+        return history.deleteOlderThan(cutoff)
+    }
+
+    suspend fun clear() {
+        history.deleteAll()
+        summaries.deleteAll()
+    }
+
+    private fun StepHistoryEntity.toTotals() =
+        DayTotals(date, steps, distance, calories, syncedHealth, syncedRemote)
+
+    private fun DayTotals.toEntity() = StepHistoryEntity(
+        date = date,
+        steps = steps,
+        distance = distance,
+        calories = calories,
+        syncedHealth = synced,
+        syncedRemote = syncedRemote
+    )
+
+    private fun DayTotals.toSummary() = DailySummaryEntity(
+        date = date,
+        totalSteps = steps,
+        totalDistance = distance,
+        totalCalories = calories
+    )
+}

package/android/src/main/java/com/steptrackerpro/health/HealthConnectManager.kt

@@ -0,0 +1,198 @@
+package com.steptrackerpro.health
+
+import android.content.Context
+import android.content.Intent
+import androidx.health.connect.client.HealthConnectClient
+import androidx.health.connect.client.PermissionController
+import androidx.health.connect.client.aggregate.AggregationResultGroupedByPeriod
+import androidx.health.connect.client.permission.HealthPermission
+import androidx.health.connect.client.records.DistanceRecord
+import androidx.health.connect.client.records.StepsRecord
+import androidx.health.connect.client.records.TotalCaloriesBurnedRecord
+import androidx.health.connect.client.records.metadata.Device
+import androidx.health.connect.client.records.metadata.Metadata
+import androidx.health.connect.client.request.AggregateGroupByPeriodRequest
+import androidx.health.connect.client.time.TimeRangeFilter
+import androidx.health.connect.client.units.Energy
+import androidx.health.connect.client.units.Length
+import com.steptrackerpro.core.DateKeys
+import com.steptrackerpro.core.DayTotals
+import com.steptrackerpro.core.StepStateStore
+import java.time.Instant
+import java.time.LocalDateTime
+import java.time.Period
+import java.time.ZoneId
+
+/**
+ * Health Connect read/write.
+ *
+ * Writes are idempotent: every record carries a stable `clientRecordId` of the
+ * form `stp-<type>-<date>`, so re-syncing a day replaces the previous record
+ * instead of stacking duplicates. That is what makes "sync today's total every
+ * 30 minutes" safe. Health Connect keeps the higher `clientRecordVersion` on a
+ * collision, so that value must never go backwards - see
+ * [StepStateStore.nextHealthRecordVersion].
+ */
+class HealthConnectManager(
+    private val context: Context,
+    private val state: StepStateStore
+) {
+
+    enum class Availability { AVAILABLE, UPDATE_REQUIRED, UNAVAILABLE }
+
+    @Volatile
+    private var cachedClient: HealthConnectClient? = null
+
+    /**
+     * Only a *successful* client is cached. This used to be a `by lazy`, which
+     * on a process-wide singleton meant that one call made before Health
+     * Connect was installed pinned `null` for the life of the process: the user
+     * could install the provider and grant everything, and every operation
+     * would still fail until the app was killed.
+     */
+    private fun client(): HealthConnectClient? {
+        cachedClient?.let { return it }
+        if (availability() != Availability.AVAILABLE) return null
+        return runCatching { HealthConnectClient.getOrCreate(context) }
+            .getOrNull()
+            ?.also { cachedClient = it }
+    }
+
+    fun availability(): Availability = when (HealthConnectClient.getSdkStatus(context)) {
+        HealthConnectClient.SDK_AVAILABLE -> Availability.AVAILABLE
+        HealthConnectClient.SDK_UNAVAILABLE_PROVIDER_UPDATE_REQUIRED -> Availability.UPDATE_REQUIRED
+        else -> Availability.UNAVAILABLE
+    }
+
+    suspend fun grantedPermissions(): Set<String> =
+        client()?.permissionController?.getGrantedPermissions() ?: emptySet()
+
+    suspend fun hasAllPermissions(): Boolean =
+        grantedPermissions().containsAll(PERMISSIONS)
+
+    suspend fun status(): Map<String, Any?> {
+        val availability = availability()
+        val granted = if (availability == Availability.AVAILABLE) grantedPermissions() else emptySet()
+        return mapOf(
+            "available" to (availability == Availability.AVAILABLE),
+            "requiresUpdate" to (availability == Availability.UPDATE_REQUIRED),
+            "granted" to granted.containsAll(PERMISSIONS),
+            "grantedPermissions" to granted.toList()
+        )
+    }
+
+    /** Daily step totals from every source Health Connect knows about. */
+    suspend fun readDailySteps(start: Instant, end: Instant): List<DayTotals> {
+        val hc = client() ?: return emptyList()
+        val zone = ZoneId.systemDefault()
+        val request = AggregateGroupByPeriodRequest(
+            metrics = setOf(
+                StepsRecord.COUNT_TOTAL,
+                DistanceRecord.DISTANCE_TOTAL,
+                TotalCaloriesBurnedRecord.ENERGY_TOTAL
+            ),
+            timeRangeFilter = TimeRangeFilter.between(
+                LocalDateTime.ofInstant(start, zone),
+                LocalDateTime.ofInstant(end, zone)
+            ),
+            timeRangeSlicer = Period.ofDays(1)
+        )
+        return runCatching { hc.aggregateGroupByPeriod(request) }
+            .getOrDefault(emptyList<AggregationResultGroupedByPeriod>())
+            .map { group ->
+                DayTotals(
+                    date = DateKeys.format(group.startTime.toLocalDate()),
+                    steps = (group.result[StepsRecord.COUNT_TOTAL] ?: 0L).toInt(),
+                    distance = group.result[DistanceRecord.DISTANCE_TOTAL]?.inMeters ?: 0.0,
+                    calories = group.result[TotalCaloriesBurnedRecord.ENERGY_TOTAL]
+                        ?.inKilocalories ?: 0.0,
+                    synced = true
+                )
+            }
+    }
+
+    /**
+     * Upserts one day. Returns false when the client is missing, permissions
+     * were revoked, or the provider rejected the write.
+     */
+    suspend fun writeDay(totals: DayTotals): Boolean {
+        val hc = client() ?: return false
+        if (totals.steps <= 0) return true
+        if (!hasAllPermissions()) return false
+
+        val zone = ZoneId.systemDefault()
+        val start = DateKeys.startOfDayInstant(totals.date)
+        val rawEnd = DateKeys.endOfDayInstant(totals.date)
+        // An open day must not be written with an end time in the future.
+        val end = if (rawEnd.isAfter(Instant.now())) Instant.now() else rawEnd
+        if (!end.isAfter(start)) return true
+
+        val startOffset = zone.rules.getOffset(start)
+        val endOffset = zone.rules.getOffset(end)
+        // Health Connect resolves same-id collisions by keeping the higher
+        // version, so this has to be monotonic. Using the wall clock meant that
+        // after the user set the clock back, every write was silently discarded
+        // by the provider while insertRecords still reported success.
+        val version = state.nextHealthRecordVersion()
+        val device = Device(type = Device.TYPE_PHONE)
+
+        val records = listOf(
+            StepsRecord(
+                count = totals.steps.toLong(),
+                startTime = start,
+                endTime = end,
+                startZoneOffset = startOffset,
+                endZoneOffset = endOffset,
+                metadata = Metadata.autoRecorded(
+                    device = device,
+                    clientRecordId = "stp-steps-${totals.date}",
+                    clientRecordVersion = version
+                )
+            ),
+            DistanceRecord(
+                distance = Length.meters(totals.distance),
+                startTime = start,
+                endTime = end,
+                startZoneOffset = startOffset,
+                endZoneOffset = endOffset,
+                metadata = Metadata.autoRecorded(
+                    device = device,
+                    clientRecordId = "stp-distance-${totals.date}",
+                    clientRecordVersion = version
+                )
+            ),
+            TotalCaloriesBurnedRecord(
+                energy = Energy.kilocalories(totals.calories),
+                startTime = start,
+                endTime = end,
+                startZoneOffset = startOffset,
+                endZoneOffset = endOffset,
+                metadata = Metadata.autoRecorded(
+                    device = device,
+                    clientRecordId = "stp-calories-${totals.date}",
+                    clientRecordVersion = version
+                )
+            )
+        )
+
+        return runCatching { hc.insertRecords(records); true }.getOrDefault(false)
+    }
+
+    fun settingsIntent(): Intent =
+        Intent(HealthConnectClient.ACTION_HEALTH_CONNECT_SETTINGS)
+            .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+
+    companion object {
+        val PERMISSIONS: Set<String> = setOf(
+            HealthPermission.getReadPermission(StepsRecord::class),
+            HealthPermission.getWritePermission(StepsRecord::class),
+            HealthPermission.getReadPermission(DistanceRecord::class),
+            HealthPermission.getWritePermission(DistanceRecord::class),
+            HealthPermission.getReadPermission(TotalCaloriesBurnedRecord::class),
+            HealthPermission.getWritePermission(TotalCaloriesBurnedRecord::class)
+        )
+
+        fun permissionContract() =
+            PermissionController.createRequestPermissionResultContract()
+    }
+}

package/android/src/main/java/com/steptrackerpro/health/HealthPermissionActivity.kt

@@ -0,0 +1,99 @@
+package com.steptrackerpro.health
+
+import android.app.Activity
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.result.ActivityResultLauncher
+import java.util.concurrent.CopyOnWriteArrayList
+
+/**
+ * Health Connect permissions can only be requested through an
+ * ActivityResultContract, which needs a real Activity. The React module starts
+ * this transparent activity, which requests the grants and hands the result
+ * back through [Callbacks].
+ *
+ * The manifest entry must not carry `android:noHistory`: that finishes the
+ * activity the moment the Health Connect screen covers it, so the contract can
+ * never deliver and every request resolves with the pre-grant status.
+ */
+class HealthPermissionActivity : ComponentActivity() {
+
+    private lateinit var launcher: ActivityResultLauncher<Set<String>>
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        launcher = registerForActivityResult(HealthConnectManager.permissionContract()) { granted ->
+            Callbacks.deliver(granted)
+            setResult(Activity.RESULT_OK)
+            finish()
+            overridePendingTransition(0, 0)
+        }
+        // Only launch on a fresh start. After a configuration change or a
+        // process restart the contract is already in flight and relaunching
+        // would stack a second permission screen.
+        if (savedInstanceState == null) {
+            runCatching { launcher.launch(HealthConnectManager.PERMISSIONS) }
+                .onFailure {
+                    Callbacks.deliver(emptySet())
+                    finish()
+                }
+        }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        // Guard against the activity being torn down before the contract
+        // returns (e.g. the provider app was killed). isFinishing is false when
+        // the system is only recreating us, where the result is still coming.
+        if (isFinishing) Callbacks.deliverIfPending()
+    }
+
+    object Callbacks {
+        fun interface Listener {
+            fun onResult(granted: Set<String>)
+        }
+
+        private val listeners = CopyOnWriteArrayList<Listener>()
+
+        /**
+         * A result that arrived before anyone was waiting for it. The caller
+         * registers its listener only after `startActivity` succeeds, so that a
+         * failed launch cannot leave a listener armed to settle a promise that
+         * was already rejected; this closes the window that opens up.
+         */
+        private var latched: Set<String>? = null
+
+        /** Call before launching, so a stale result cannot be picked up. */
+        @Synchronized
+        fun expect() {
+            latched = null
+        }
+
+        @Synchronized
+        fun await(listener: Listener) {
+            val ready = latched
+            if (ready != null) {
+                latched = null
+                runCatching { listener.onResult(ready) }
+                return
+            }
+            listeners.add(listener)
+        }
+
+        @Synchronized
+        fun deliver(granted: Set<String>) {
+            if (listeners.isEmpty()) {
+                latched = granted
+                return
+            }
+            val snapshot = listeners.toList()
+            listeners.clear()
+            snapshot.forEach { runCatching { it.onResult(granted) } }
+        }
+
+        @Synchronized
+        fun deliverIfPending() {
+            if (listeners.isNotEmpty()) deliver(emptySet())
+        }
+    }
+}

package/android/src/main/java/com/steptrackerpro/service/BootReceiver.kt

@@ -0,0 +1,54 @@
+package com.steptrackerpro.service
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.util.Log
+import com.steptrackerpro.core.StepTrackerCore
+import com.steptrackerpro.util.PermissionHelper
+
+/**
+ * Brings tracking back after a reboot or an app update.
+ *
+ * The receiver only restarts when the user had tracking on before, so an app
+ * that has never called `startTracking()` never spawns a service at boot. The
+ * counter itself is reconciled inside the engine — the receiver's job is just
+ * to get the service running again so the notification and the database writes
+ * resume.
+ */
+class BootReceiver : BroadcastReceiver() {
+
+    override fun onReceive(context: Context, intent: Intent) {
+        val action = intent.action ?: return
+        if (action !in HANDLED_ACTIONS) return
+
+        val core = StepTrackerCore.get(context)
+        if (!core.isInitialized()) return
+        if (!core.config().autoStartOnBoot) return
+        if (!core.state.shouldAutoStart) return
+
+        if (!PermissionHelper.canStartTracking(context)) {
+            Log.w(TAG, "Skipping boot restart: ACTIVITY_RECOGNITION not granted")
+            return
+        }
+
+        // Re-anchor against the new boot before the first sample arrives.
+        core.engine.reconcile()
+
+        runCatching { ServiceCommands.start(context, fromBoot = true) }
+            .onFailure { Log.e(TAG, "Boot restart failed", it) }
+    }
+
+    companion object {
+        private const val TAG = "StepTrackerBoot"
+
+        // LOCKED_BOOT_COMPLETED is deliberately absent: it is only delivered to
+        // direct-boot-aware components, and the counter state lives in
+        // credential-encrypted storage that is not readable before unlock.
+        private val HANDLED_ACTIONS = setOf(
+            Intent.ACTION_BOOT_COMPLETED,
+            Intent.ACTION_MY_PACKAGE_REPLACED,
+            "android.intent.action.QUICKBOOT_POWERON"
+        )
+    }
+}

package/android/src/main/java/com/steptrackerpro/service/NotificationActionReceiver.kt

@@ -0,0 +1,17 @@
+package com.steptrackerpro.service
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+
+/** Routes the notification's Pause/Resume buttons back into the service. */
+class NotificationActionReceiver : BroadcastReceiver() {
+
+    override fun onReceive(context: Context, intent: Intent) {
+        when (intent.action) {
+            ServiceCommands.ACTION_PAUSE,
+            ServiceCommands.ACTION_RESUME,
+            ServiceCommands.ACTION_STOP -> ServiceCommands.send(context, intent.action!!)
+        }
+    }
+}