react-native-step-tracker-pro 1.0.0

package/android/src/main/java/com/steptrackerpro/sync/SyncScheduler.kt

@@ -0,0 +1,102 @@
+package com.steptrackerpro.sync
+
+import android.content.Context
+import androidx.work.BackoffPolicy
+import androidx.work.Constraints
+import androidx.work.ExistingPeriodicWorkPolicy
+import androidx.work.ExistingWorkPolicy
+import androidx.work.NetworkType
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.PeriodicWorkRequestBuilder
+import androidx.work.WorkManager
+import com.steptrackerpro.core.StepTrackerConfig
+import java.util.concurrent.TimeUnit
+
+/**
+ * All WorkManager wiring.
+ *
+ * The two syncs use UPDATE rather than KEEP so a config change takes effect on
+ * the next run; UPDATE preserves the existing work's `lastEnqueueTime` and
+ * `periodCount`, so calling this on every app launch does not push the next run
+ * out and starve the job the way REPLACE would.
+ */
+object SyncScheduler {
+
+    fun schedule(context: Context, config: StepTrackerConfig) {
+        val work = WorkManager.getInstance(context)
+
+        if (config.healthConnectEnabled && config.healthConnectSyncIntervalMinutes > 0) {
+            val interval = config.healthConnectSyncIntervalMinutes.toLong()
+                .coerceAtLeast(15L) // WorkManager's minimum period
+            work.enqueueUniquePeriodicWork(
+                HealthConnectSyncWorker.NAME,
+                ExistingPeriodicWorkPolicy.UPDATE,
+                PeriodicWorkRequestBuilder<HealthConnectSyncWorker>(interval, TimeUnit.MINUTES)
+                    .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 5, TimeUnit.MINUTES)
+                    .build()
+            )
+        } else {
+            work.cancelUniqueWork(HealthConnectSyncWorker.NAME)
+        }
+
+        if (!config.remoteSyncUrl.isNullOrEmpty()) {
+            work.enqueueUniquePeriodicWork(
+                RemoteSyncWorker.NAME,
+                ExistingPeriodicWorkPolicy.UPDATE,
+                PeriodicWorkRequestBuilder<RemoteSyncWorker>(1, TimeUnit.HOURS)
+                    .setConstraints(
+                        Constraints.Builder()
+                            .setRequiredNetworkType(NetworkType.CONNECTED)
+                            .build()
+                    )
+                    .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 10, TimeUnit.MINUTES)
+                    .build()
+            )
+        } else {
+            work.cancelUniqueWork(RemoteSyncWorker.NAME)
+        }
+
+        work.enqueueUniquePeriodicWork(
+            RetentionWorker.NAME,
+            ExistingPeriodicWorkPolicy.KEEP,
+            PeriodicWorkRequestBuilder<RetentionWorker>(1, TimeUnit.DAYS).build()
+        )
+    }
+
+    /** Fires both syncs immediately, ignoring the periodic schedule. */
+    fun runNow(context: Context, config: StepTrackerConfig) {
+        val work = WorkManager.getInstance(context)
+        if (config.healthConnectEnabled) {
+            work.enqueueUniqueWork(
+                "${HealthConnectSyncWorker.NAME}_now",
+                ExistingWorkPolicy.REPLACE,
+                OneTimeWorkRequestBuilder<HealthConnectSyncWorker>().build()
+            )
+        }
+        if (!config.remoteSyncUrl.isNullOrEmpty()) {
+            work.enqueueUniqueWork(
+                "${RemoteSyncWorker.NAME}_now",
+                ExistingWorkPolicy.REPLACE,
+                OneTimeWorkRequestBuilder<RemoteSyncWorker>()
+                    .setConstraints(
+                        Constraints.Builder()
+                            .setRequiredNetworkType(NetworkType.CONNECTED)
+                            .build()
+                    )
+                    .build()
+            )
+        }
+    }
+
+    /**
+     * Drops every periodic job, retention included: once tracking is stopped the
+     * database is not growing, so a daily wake-up to prune it is pure cost.
+     * [schedule] re-enqueues all three when tracking starts again.
+     */
+    fun cancelAll(context: Context) {
+        val work = WorkManager.getInstance(context)
+        work.cancelUniqueWork(HealthConnectSyncWorker.NAME)
+        work.cancelUniqueWork(RemoteSyncWorker.NAME)
+        work.cancelUniqueWork(RetentionWorker.NAME)
+    }
+}

package/android/src/main/java/com/steptrackerpro/sync/SyncWorkers.kt

@@ -0,0 +1,175 @@
+package com.steptrackerpro.sync
+
+import android.content.Context
+import androidx.work.CoroutineWorker
+import androidx.work.WorkerParameters
+import com.steptrackerpro.core.DayTotals
+import com.steptrackerpro.core.StepTrackerCore
+import com.steptrackerpro.core.SyncTarget
+import com.steptrackerpro.util.StepEventBus
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeoutOrNull
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.BufferedReader
+import java.net.HttpURLConnection
+import java.net.URL
+
+/**
+ * Mirrors unsynced day rows into Health Connect. Runs without a network
+ * constraint because Health Connect is entirely on-device — offline sync is
+ * still sync.
+ */
+class HealthConnectSyncWorker(
+    context: Context,
+    params: WorkerParameters
+) : CoroutineWorker(context, params) {
+
+    override suspend fun doWork(): Result {
+        val core = StepTrackerCore.get(applicationContext)
+        val config = core.config()
+        if (!config.healthConnectEnabled) return Result.success()
+
+        val result = core.syncHealthConnect()
+        return when {
+            result["success"] == true -> Result.success()
+            // Provider missing, permissions not granted, disabled in config:
+            // states only the user can change. Retrying backs off and tries
+            // again forever on a device that will never succeed.
+            result["retryable"] != true -> Result.success()
+            runAttemptCount < MAX_ATTEMPTS -> Result.retry()
+            // Result.failure() on a PeriodicWorkRequest ends the whole periodic
+            // chain, not just this attempt. Give up on this period instead and
+            // let the next one come round.
+            else -> Result.success()
+        }
+    }
+
+    companion object {
+        const val NAME = "stp_health_connect_sync"
+        private const val MAX_ATTEMPTS = 5
+    }
+}
+
+/**
+ * Ships unsynced day rows to the configured HTTPS endpoint. This is the only
+ * part of the package that needs the internet, and nothing else waits on it.
+ */
+class RemoteSyncWorker(
+    context: Context,
+    params: WorkerParameters
+) : CoroutineWorker(context, params) {
+
+    override suspend fun doWork(): Result {
+        val core = StepTrackerCore.get(applicationContext)
+        val config = core.config()
+        val url = config.remoteSyncUrl ?: return Result.success()
+
+        val pending = core.repository.unsynced(SyncTarget.REMOTE, limit = 200)
+        if (pending.isEmpty()) return Result.success()
+
+        val ok = withTimeoutOrNull(REQUEST_TIMEOUT_MS) {
+            post(url, config.remoteSyncHeaders, pending)
+        } ?: false
+
+        if (ok) {
+            core.repository.markSynced(SyncTarget.REMOTE, pending.map { it.date })
+            StepEventBus.emit(
+                StepEventBus.Events.SYNC_COMPLETED,
+                mapOf(
+                    "target" to "remote",
+                    "syncedRecords" to pending.size,
+                    "failedRecords" to 0,
+                    "success" to true
+                )
+            )
+            return Result.success()
+        }
+
+        StepEventBus.emit(
+            StepEventBus.Events.SYNC_COMPLETED,
+            mapOf(
+                "target" to "remote",
+                "syncedRecords" to 0,
+                "failedRecords" to pending.size,
+                "success" to false,
+                "error" to "Upload failed"
+            )
+        )
+        // As above: failure() would retire the periodic work permanently, so an
+        // endpoint that is down for a day would never be retried again.
+        return if (runAttemptCount < MAX_ATTEMPTS) Result.retry() else Result.success()
+    }
+
+    private suspend fun post(
+        url: String,
+        headers: Map<String, String>,
+        records: List<DayTotals>
+    ): Boolean = withContext(Dispatchers.IO) {
+        var connection: HttpURLConnection? = null
+        try {
+            val body = JSONObject().apply {
+                put("source", "react-native-step-tracker-pro")
+                put("sentAt", System.currentTimeMillis())
+                put(
+                    "records",
+                    JSONArray().apply {
+                        records.forEach { record ->
+                            put(
+                                JSONObject().apply {
+                                    put("date", record.date)
+                                    put("steps", record.steps)
+                                    put("distance", record.distance)
+                                    put("calories", record.calories)
+                                }
+                            )
+                        }
+                    }
+                )
+            }.toString()
+
+            connection = (URL(url).openConnection() as HttpURLConnection).apply {
+                requestMethod = "POST"
+                connectTimeout = 15_000
+                readTimeout = 15_000
+                doOutput = true
+                setRequestProperty("Content-Type", "application/json; charset=utf-8")
+                headers.forEach { (key, value) -> setRequestProperty(key, value) }
+            }
+            connection.outputStream.use { it.write(body.toByteArray(Charsets.UTF_8)) }
+            val code = connection.responseCode
+            if (code !in 200..299) {
+                connection.errorStream?.bufferedReader()?.use(BufferedReader::readText)
+            }
+            code in 200..299
+        } catch (error: Exception) {
+            false
+        } finally {
+            connection?.disconnect()
+        }
+    }
+
+    companion object {
+        const val NAME = "stp_remote_sync"
+        private const val MAX_ATTEMPTS = 5
+        private const val REQUEST_TIMEOUT_MS = 45_000L
+    }
+}
+
+/** Enforces the retention window so the database cannot grow without bound. */
+class RetentionWorker(
+    context: Context,
+    params: WorkerParameters
+) : CoroutineWorker(context, params) {
+
+    override suspend fun doWork(): Result {
+        val core = StepTrackerCore.get(applicationContext)
+        core.repository.prune(core.config().historyRetentionDays)
+        return Result.success()
+    }
+
+    companion object {
+        const val NAME = "stp_retention"
+    }
+}

package/android/src/main/java/com/steptrackerpro/util/BatteryOptimizationHelper.kt

@@ -0,0 +1,94 @@
+package com.steptrackerpro.util
+
+import android.annotation.SuppressLint
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.os.Build
+import android.os.PowerManager
+import android.provider.Settings
+
+/**
+ * Doze and OEM task-killer helpers.
+ *
+ * A hardware step counter keeps ticking in the SoC sensor hub even in Doze, so
+ * these are about the *service* surviving, not the sensor. On stock Android the
+ * foreground service is enough. On aggressive OEM skins (Xiaomi, Oppo, Vivo,
+ * Realme, Huawei, Samsung's "put unused apps to sleep") the user has to grant an
+ * exemption, and there is no API to do it for them.
+ */
+object BatteryOptimizationHelper {
+
+    fun isOptimizationEnabled(context: Context): Boolean {
+        val power = context.getSystemService(Context.POWER_SERVICE) as? PowerManager
+            ?: return false
+        return !power.isIgnoringBatteryOptimizations(context.packageName)
+    }
+
+    /**
+     * Direct system dialog. Requires REQUEST_IGNORE_BATTERY_OPTIMIZATIONS, which
+     * Play restricts to apps whose core function genuinely breaks under Doze —
+     * declare it in the Play Console or use [openSettings] instead.
+     */
+    @SuppressLint("BatteryLife")
+    fun requestExemption(context: Context): Boolean {
+        if (!isOptimizationEnabled(context)) return true
+        return runCatching {
+            val intent = Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS)
+                .setData(Uri.parse("package:${context.packageName}"))
+                .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+            context.startActivity(intent)
+            true
+        }.getOrDefault(false)
+    }
+
+    /** Policy-safe: opens the exemption list, the user picks the app. */
+    fun openSettings(context: Context): Boolean = runCatching {
+        val intent = Intent(Settings.ACTION_IGNORE_BATTERY_OPTIMIZATION_SETTINGS)
+            .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        context.startActivity(intent)
+        true
+    }.getOrDefault(false)
+
+    /** Best-effort deep link into OEM autostart screens; falls back to app info. */
+    fun openAutoStartSettings(context: Context): Boolean {
+        val candidates = when (Build.MANUFACTURER.lowercase()) {
+            "xiaomi", "redmi", "poco" -> listOf(
+                "com.miui.securitycenter" to
+                    "com.miui.permcenter.autostart.AutoStartManagementActivity"
+            )
+            "oppo", "realme", "oneplus" -> listOf(
+                "com.coloros.safecenter" to
+                    "com.coloros.safecenter.permission.startup.StartupAppListActivity",
+                "com.coloros.safecenter" to
+                    "com.coloros.safecenter.startupapp.StartupAppListActivity"
+            )
+            "vivo", "iqoo" -> listOf(
+                "com.vivo.permissionmanager" to
+                    "com.vivo.permissionmanager.activity.BgStartUpManagerActivity"
+            )
+            "huawei", "honor" -> listOf(
+                "com.huawei.systemmanager" to
+                    "com.huawei.systemmanager.startupmgr.ui.StartupNormalAppListActivity"
+            )
+            "letv" -> listOf(
+                "com.letv.android.letvsafe" to
+                    "com.letv.android.letvsafe.AutobootManageActivity"
+            )
+            else -> emptyList()
+        }
+
+        for ((pkg, cls) in candidates) {
+            val intent = Intent()
+                .setComponent(ComponentName(pkg, cls))
+                .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+            if (context.packageManager.resolveActivity(intent, 0) != null) {
+                val launched = runCatching { context.startActivity(intent); true }
+                    .getOrDefault(false)
+                if (launched) return true
+            }
+        }
+        return PermissionHelper.openAppSettings(context)
+    }
+}

package/android/src/main/java/com/steptrackerpro/util/Bridge.kt

@@ -0,0 +1,149 @@
+package com.steptrackerpro.util
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.steptrackerpro.core.DayTotals
+import com.steptrackerpro.core.RangeStats
+import com.steptrackerpro.core.StepSnapshot
+
+/** Conversions between package models and the React Native bridge. */
+object Bridge {
+
+    fun snapshot(snapshot: StepSnapshot): WritableMap = Arguments.createMap().apply {
+        putString("date", snapshot.date)
+        putInt("steps", snapshot.steps)
+        putDouble("distance", round(snapshot.distance, 2))
+        putDouble("calories", round(snapshot.calories, 2))
+        putInt("dailyGoal", snapshot.dailyGoal)
+        putDouble("goalProgress", round(snapshot.goalProgress, 4))
+        putBoolean("goalReached", snapshot.goalReached)
+        putString("state", snapshot.state.jsValue)
+        putString("source", snapshot.source.jsValue)
+        putDouble("timestamp", snapshot.timestamp.toDouble())
+    }
+
+    fun snapshotMap(snapshot: StepSnapshot): Map<String, Any?> = mapOf(
+        "date" to snapshot.date,
+        "steps" to snapshot.steps,
+        "distance" to round(snapshot.distance, 2),
+        "calories" to round(snapshot.calories, 2),
+        "dailyGoal" to snapshot.dailyGoal,
+        "goalProgress" to round(snapshot.goalProgress, 4),
+        "goalReached" to snapshot.goalReached,
+        "state" to snapshot.state.jsValue,
+        "source" to snapshot.source.jsValue,
+        "timestamp" to snapshot.timestamp
+    )
+
+    fun day(totals: DayTotals): WritableMap = Arguments.createMap().apply {
+        putString("date", totals.date)
+        putInt("steps", totals.steps)
+        putDouble("distance", round(totals.distance, 2))
+        putDouble("calories", round(totals.calories, 2))
+        putBoolean("synced", totals.synced)
+        putBoolean("syncedRemote", totals.syncedRemote)
+    }
+
+    fun days(list: List<DayTotals>): WritableArray = Arguments.createArray().apply {
+        list.forEach { pushMap(day(it)) }
+    }
+
+    fun stats(stats: RangeStats): WritableMap = Arguments.createMap().apply {
+        putString("startDate", stats.startDate)
+        putString("endDate", stats.endDate)
+        putInt("totalSteps", stats.totalSteps)
+        putDouble("totalDistance", round(stats.totalDistance, 2))
+        putDouble("totalCalories", round(stats.totalCalories, 2))
+        putInt("averageSteps", stats.averageSteps)
+        putInt("activeDays", stats.activeDays)
+        if (stats.bestDay != null) putMap("bestDay", day(stats.bestDay)) else putNull("bestDay")
+        putArray("days", days(stats.days))
+        stats.goal?.let { putInt("goal", it) }
+        stats.goalProgress?.let { putDouble("goalProgress", round(it, 4)) }
+    }
+
+    fun map(values: Map<String, Any?>): WritableMap = Arguments.createMap().apply {
+        values.forEach { (key, value) ->
+            when (value) {
+                null -> putNull(key)
+                is Boolean -> putBoolean(key, value)
+                is Int -> putInt(key, value)
+                is Long -> putDouble(key, value.toDouble())
+                is Float -> putDouble(key, value.toDouble())
+                is Double -> putDouble(key, value)
+                is String -> putString(key, value)
+                is List<*> -> putArray(key, list(value))
+                is Map<*, *> -> putMap(key, map(value.entries.associate {
+                    it.key.toString() to it.value
+                }))
+                else -> putString(key, value.toString())
+            }
+        }
+    }
+
+    private fun list(values: List<*>): WritableArray = Arguments.createArray().apply {
+        values.forEach { value ->
+            when (value) {
+                null -> pushNull()
+                is Boolean -> pushBoolean(value)
+                is Int -> pushInt(value)
+                is Long -> pushDouble(value.toDouble())
+                is Float -> pushDouble(value.toDouble())
+                is Double -> pushDouble(value)
+                is String -> pushString(value)
+                is List<*> -> pushArray(list(value))
+                is Map<*, *> -> pushMap(map(value.entries.associate {
+                    it.key.toString() to it.value
+                }))
+                // Mirrors map(): anything else crosses the bridge as its
+                // toString rather than being dropped.
+                else -> pushString(value.toString())
+            }
+        }
+    }
+
+    fun stringMap(source: ReadableMap?): Map<String, String> {
+        if (source == null) return emptyMap()
+        val out = HashMap<String, String>()
+        val iterator = source.keySetIterator()
+        while (iterator.hasNextKey()) {
+            val key = iterator.nextKey()
+            if (source.getType(key) == ReadableType.String) {
+                source.getString(key)?.let { out[key] = it }
+            }
+        }
+        return out
+    }
+
+    private fun round(value: Double, decimals: Int): Double {
+        if (value.isNaN() || value.isInfinite()) return 0.0
+        var factor = 1.0
+        repeat(decimals) { factor *= 10 }
+        return Math.round(value * factor) / factor
+    }
+}
+
+// Top-level so they can be imported and used outside this file. Extensions
+// declared inside an object are members and are not importable.
+
+fun ReadableMap.optDouble(key: String, fallback: Double): Double =
+    if (hasKey(key) && !isNull(key)) getDouble(key) else fallback
+
+fun ReadableMap.optInt(key: String, fallback: Int): Int =
+    if (hasKey(key) && !isNull(key)) getInt(key) else fallback
+
+fun ReadableMap.optLong(key: String, fallback: Long): Long =
+    if (hasKey(key) && !isNull(key)) getDouble(key).toLong() else fallback
+
+fun ReadableMap.optBoolean(key: String, fallback: Boolean): Boolean =
+    if (hasKey(key) && !isNull(key)) getBoolean(key) else fallback
+
+fun ReadableMap.optString(key: String, fallback: String?): String? =
+    if (hasKey(key) && !isNull(key)) getString(key) else fallback
+
+fun ReadableArray.toStringList(): List<String> =
+    (0 until size()).mapNotNull { getString(it) }

package/android/src/main/java/com/steptrackerpro/util/PermissionHelper.kt

@@ -0,0 +1,92 @@
+package com.steptrackerpro.util
+
+import android.Manifest
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.hardware.Sensor
+import android.hardware.SensorManager
+import android.net.Uri
+import android.os.Build
+import android.provider.Settings
+import androidx.core.content.ContextCompat
+
+object PermissionHelper {
+
+    /** Runtime permissions this package needs, filtered by API level. */
+    fun required(): List<String> = buildList {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            add(Manifest.permission.ACTIVITY_RECOGNITION)
+        }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            add(Manifest.permission.POST_NOTIFICATIONS)
+        }
+    }
+
+    fun isGranted(context: Context, permission: String): Boolean =
+        ContextCompat.checkSelfPermission(context, permission) ==
+            PackageManager.PERMISSION_GRANTED
+
+    fun hasActivityRecognition(context: Context): Boolean =
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            isGranted(context, Manifest.permission.ACTIVITY_RECOGNITION)
+        } else {
+            true
+        }
+
+    fun hasPostNotifications(context: Context): Boolean =
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            isGranted(context, Manifest.permission.POST_NOTIFICATIONS)
+        } else {
+            true
+        }
+
+    /**
+     * FOREGROUND_SERVICE_HEALTH is a normal permission, so it is granted at
+     * install time whenever it is declared in the merged manifest.
+     */
+    fun hasForegroundServiceHealth(context: Context): Boolean =
+        if (Build.VERSION.SDK_INT >= 34) {
+            isGranted(context, "android.permission.FOREGROUND_SERVICE_HEALTH")
+        } else {
+            true
+        }
+
+    /**
+     * POST_NOTIFICATIONS is deliberately excluded: a denied notification
+     * permission downgrades the notification to invisible on Android 13+, but
+     * the foreground service and the counting still work.
+     */
+    fun canStartTracking(context: Context): Boolean =
+        hasActivityRecognition(context) && hasForegroundServiceHealth(context)
+
+    fun status(context: Context): Map<String, Any?> = mapOf(
+        "activityRecognition" to hasActivityRecognition(context),
+        "postNotifications" to hasPostNotifications(context),
+        "foregroundServiceHealth" to hasForegroundServiceHealth(context),
+        "allGranted" to canStartTracking(context)
+    )
+
+    fun capabilities(context: Context): Map<String, Any?> {
+        val sensors = context.getSystemService(Context.SENSOR_SERVICE) as? SensorManager
+        val counter = sensors?.getDefaultSensor(Sensor.TYPE_STEP_COUNTER) != null
+        val detector = sensors?.getDefaultSensor(Sensor.TYPE_STEP_DETECTOR) != null
+        return mapOf(
+            "hasStepCounter" to counter,
+            "hasStepDetector" to detector,
+            "supported" to (counter || detector),
+            "sdkInt" to Build.VERSION.SDK_INT,
+            "manufacturer" to Build.MANUFACTURER,
+            "model" to Build.MODEL
+        )
+    }
+
+    fun openAppSettings(context: Context): Boolean = runCatching {
+        val intent = Intent(
+            Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
+            Uri.fromParts("package", context.packageName, null)
+        ).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        context.startActivity(intent)
+        true
+    }.getOrDefault(false)
+}

package/android/src/main/java/com/steptrackerpro/util/StepEventBus.kt

@@ -0,0 +1,53 @@
+package com.steptrackerpro.util
+
+import java.util.concurrent.CopyOnWriteArrayList
+
+/**
+ * The service and the React module live in the same process, so events go
+ * through a plain in-memory bus rather than broadcasts. The module attaches on
+ * `initialize` and detaches on catalyst teardown; the service keeps running and
+ * writing to storage whether or not anyone is listening.
+ */
+object StepEventBus {
+
+    /** Names match the JS side minus the `StepTrackerPro:` prefix. */
+    object Events {
+        const val STEPS_CHANGED = "stepsChanged"
+        const val GOAL_REACHED = "goalReached"
+        const val GOAL_PROGRESS_CHANGED = "goalProgressChanged"
+        const val TRACKING_STATE_CHANGED = "trackingStateChanged"
+        const val DAY_CHANGED = "dayChanged"
+        const val SYNC_COMPLETED = "syncCompleted"
+        const val ERROR = "error"
+    }
+
+    fun interface Subscriber {
+        fun onEvent(name: String, payload: Map<String, Any?>)
+    }
+
+    private val subscribers = CopyOnWriteArrayList<Subscriber>()
+
+    /**
+     * Identity-based: a subscriber added twice is delivered to twice. There is
+     * no useful dedupe to do here, because every caller passes a freshly
+     * SAM-converted lambda that is never equal to any other. The contract is
+     * that whoever subscribes also unsubscribes — the React module does so in
+     * `invalidate()`, and a subscriber that outlives its context is inert
+     * because `emit` checks for a live React instance first.
+     */
+    fun subscribe(subscriber: Subscriber) {
+        subscribers.add(subscriber)
+    }
+
+    fun unsubscribe(subscriber: Subscriber) {
+        subscribers.remove(subscriber)
+    }
+
+    fun emit(name: String, payload: Map<String, Any?>) {
+        subscribers.forEach { subscriber ->
+            runCatching { subscriber.onEvent(name, payload) }
+        }
+    }
+
+    fun hasSubscribers(): Boolean = subscribers.isNotEmpty()
+}

package/android/src/main/res/drawable/stp_ic_steps.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="#FFFFFF"
+        android:pathData="M7.5,3C6.1,3 5,4.4 5,6.3c0,1.3 0.3,2.6 0.8,3.9C6.3,11.4 6.6,12.6 6.6,13.6c0,1 0.6,1.7 1.6,1.7h0.9c1,0 1.6,-0.7 1.6,-1.8c0,-1.2 -0.2,-2.4 -0.6,-3.6C9.6,8.6 9.3,7.3 9.3,6.1C9.3,4.3 8.6,3 7.5,3zM8.1,17c-0.9,0 -1.5,0.6 -1.5,1.5v1.1C6.6,20.5 7.3,21 8.2,21h1c0.9,0 1.5,-0.6 1.5,-1.5v-1c0,-0.9 -0.6,-1.5 -1.5,-1.5H8.1zM16.5,5c-1.1,0 -1.8,1.3 -1.8,3.1c0,1.2 -0.3,2.5 -0.7,3.8c-0.4,1.2 -0.6,2.4 -0.6,3.6c0,1.1 0.6,1.8 1.6,1.8h0.9c1,0 1.6,-0.7 1.6,-1.7c0,-1 0.3,-2.2 0.8,-3.4C18.7,10.9 19,9.6 19,8.3C19,6.4 17.9,5 16.5,5zM15.4,19c-0.9,0 -1.5,0.6 -1.5,1.5v0.4h4v-0.4c0,-0.9 -0.6,-1.5 -1.5,-1.5H15.4z" />
+</vector>

package/android/src/main/res/values/strings.xml

@@ -0,0 +1,9 @@
+<resources>
+    <string name="stp_channel_name">Step tracking</string>
+    <string name="stp_channel_description">Keeps counting your steps while the app is closed.</string>
+    <string name="stp_notification_text">%1$s km · %2$s kcal · %3$d%% of goal</string>
+    <string name="stp_action_open">Open</string>
+    <string name="stp_action_pause">Pause</string>
+    <string name="stp_action_resume">Resume</string>
+    <string name="stp_paused_text">Tracking paused</string>
+</resources>