@tsachit/react-native-geo-service 1.0.0

package/android/src/main/java/com/geoservice/GeoServiceModule.kt

@@ -0,0 +1,291 @@
+package com.geoservice
+
+import android.annotation.SuppressLint
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.os.Build
+import android.util.Log
+import androidx.localbroadcastmanager.content.LocalBroadcastManager
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.google.android.gms.location.LocationServices
+import org.json.JSONObject
+
+class GeoServiceModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    companion object {
+        const val TAG = "GeoService:Module"
+        const val MODULE_NAME = "RNGeoService"
+
+        // Tracks whether the React context / JS engine is alive.
+        // LocationService reads this to decide whether to use EventEmitter or HeadlessJS.
+        @Volatile
+        var isReactContextActive = false
+            private set
+    }
+
+    private var config: GeoServiceConfig = GeoServiceConfig()
+    private var listenerCount = 0
+    private var locationReceiver: BroadcastReceiver? = null
+
+    init {
+        isReactContextActive = true
+        reactContext.addLifecycleEventListener(object : LifecycleEventListener {
+            override fun onHostResume() {
+                isReactContextActive = true
+            }
+
+            override fun onHostPause() {
+                // Still alive; HeadlessJS not needed yet
+                isReactContextActive = true
+            }
+
+            override fun onHostDestroy() {
+                isReactContextActive = false
+            }
+        })
+    }
+
+    override fun getName() = MODULE_NAME
+
+    // --------------------------------------------------------------------------------------------
+    // Required for NativeEventEmitter
+    // --------------------------------------------------------------------------------------------
+
+    @ReactMethod
+    fun addListener(eventName: String) {
+        listenerCount++
+        if (listenerCount == 1) registerLocationReceiver()
+    }
+
+    @ReactMethod
+    fun removeListeners(count: Int) {
+        listenerCount = (listenerCount - count).coerceAtLeast(0)
+        if (listenerCount == 0) unregisterLocationReceiver()
+    }
+
+    // --------------------------------------------------------------------------------------------
+    // JS-exposed API
+    // --------------------------------------------------------------------------------------------
+
+    @ReactMethod
+    fun configure(options: ReadableMap, promise: Promise) {
+        try {
+            config = GeoServiceConfig(
+                minDistanceMeters = options.getDoubleOrDefault("minDistanceMeters", 10.0).toFloat(),
+                accuracy = options.getStringOrDefault("accuracy", "balanced"),
+                stopOnAppClose = options.getBooleanOrDefault("stopOnAppClose", false),
+                restartOnBoot = options.getBooleanOrDefault("restartOnBoot", false),
+                updateIntervalMs = options.getDoubleOrDefault("updateIntervalMs", 5000.0).toLong(),
+                minUpdateIntervalMs = options.getDoubleOrDefault("minUpdateIntervalMs", 2000.0).toLong(),
+                serviceTitle = options.getStringOrDefault("serviceTitle", "Location Tracking"),
+                serviceBody = options.getStringOrDefault("serviceBody", "Your location is being tracked in the background."),
+                backgroundTaskName = options.getStringOrDefault("backgroundTaskName", "GeoServiceHeadlessTask"),
+                adaptiveAccuracy = options.getBooleanOrDefault("adaptiveAccuracy", true),
+                idleSpeedThreshold = options.getDoubleOrDefault("idleSpeedThreshold", 0.5).toFloat(),
+                idleSampleCount = options.getDoubleOrDefault("idleSampleCount", 3.0).toInt(),
+                debug = options.getBooleanOrDefault("debug", false)
+            )
+            persistConfig()
+            log("Config updated: $config")
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("CONFIGURE_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun start(promise: Promise) {
+        try {
+            registerLocationReceiver()
+            startLocationService()
+            saveTrackingState(true)
+            log("Tracking started")
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("START_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun stop(promise: Promise) {
+        try {
+            reactContext.stopService(Intent(reactContext, LocationService::class.java))
+            saveTrackingState(false)
+            log("Tracking stopped")
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("STOP_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun isTracking(promise: Promise) {
+        promise.resolve(LocationService.isRunning)
+    }
+
+    @SuppressLint("MissingPermission")
+    @ReactMethod
+    fun getCurrentLocation(promise: Promise) {
+        val client = LocationServices.getFusedLocationProviderClient(reactContext)
+        client.lastLocation
+            .addOnSuccessListener { location ->
+                if (location != null) {
+                    promise.resolve(locationToWritableMap(location))
+                } else {
+                    promise.reject("NO_LOCATION", "No last known location available. Start tracking first.")
+                }
+            }
+            .addOnFailureListener { e ->
+                promise.reject("LOCATION_ERROR", e.message, e)
+            }
+    }
+
+    // --------------------------------------------------------------------------------------------
+    // Internal helpers
+    // --------------------------------------------------------------------------------------------
+
+    private fun startLocationService() {
+        val intent = Intent(reactContext, LocationService::class.java).apply {
+            putExtra("config", config.toBundle())
+        }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            reactContext.startForegroundService(intent)
+        } else {
+            reactContext.startService(intent)
+        }
+    }
+
+    private fun registerLocationReceiver() {
+        if (locationReceiver != null) return
+
+        locationReceiver = object : BroadcastReceiver() {
+            override fun onReceive(context: Context, intent: Intent) {
+                when (intent.action) {
+                    LocationService.ACTION_LOCATION_UPDATE -> {
+                        val json = intent.getStringExtra(LocationService.EXTRA_LOCATION) ?: return
+                        sendEvent("onLocation", json)
+                    }
+                    LocationService.ACTION_LOCATION_ERROR -> {
+                        val json = intent.getStringExtra(LocationService.EXTRA_ERROR) ?: return
+                        sendEvent("onError", json)
+                    }
+                }
+            }
+        }
+
+        val filter = IntentFilter().apply {
+            addAction(LocationService.ACTION_LOCATION_UPDATE)
+            addAction(LocationService.ACTION_LOCATION_ERROR)
+        }
+        LocalBroadcastManager.getInstance(reactContext)
+            .registerReceiver(locationReceiver!!, filter)
+    }
+
+    private fun unregisterLocationReceiver() {
+        locationReceiver?.let {
+            LocalBroadcastManager.getInstance(reactContext).unregisterReceiver(it)
+            locationReceiver = null
+        }
+    }
+
+    private fun sendEvent(eventName: String, jsonString: String) {
+        if (!reactContext.hasActiveCatalystInstance()) return
+        try {
+            val map = Arguments.createMap()
+            val json = JSONObject(jsonString)
+            for (key in json.keys()) {
+                when (val value = json.get(key)) {
+                    is Double -> map.putDouble(key, value)
+                    is Int -> map.putInt(key, value)
+                    is Long -> map.putDouble(key, value.toDouble())
+                    is Boolean -> map.putBoolean(key, value)
+                    is String -> map.putString(key, value)
+                }
+            }
+            reactContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit(eventName, map)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error sending event: ${e.message}")
+        }
+    }
+
+    private fun locationToWritableMap(location: android.location.Location): WritableMap {
+        return Arguments.createMap().apply {
+            putDouble("latitude", location.latitude)
+            putDouble("longitude", location.longitude)
+            putDouble("accuracy", location.accuracy.toDouble())
+            putDouble("altitude", location.altitude)
+            putDouble("altitudeAccuracy", if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
+                location.verticalAccuracyMeters.toDouble() else -1.0)
+            putDouble("speed", if (location.hasSpeed()) location.speed.toDouble() else -1.0)
+            putDouble("bearing", if (location.hasBearing()) location.bearing.toDouble() else -1.0)
+            putDouble("timestamp", location.time.toDouble())
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                putBoolean("isFromMockProvider", location.isMock)
+            }
+        }
+    }
+
+    private fun persistConfig() {
+        val prefs = reactContext.getSharedPreferences(
+            BootReceiver.PREFS_NAME, Context.MODE_PRIVATE
+        )
+        val json = JSONObject().apply {
+            put("minDistanceMeters", config.minDistanceMeters.toDouble())
+            put("accuracy", config.accuracy)
+            put("stopOnAppClose", config.stopOnAppClose)
+            put("restartOnBoot", config.restartOnBoot)
+            put("updateIntervalMs", config.updateIntervalMs)
+            put("minUpdateIntervalMs", config.minUpdateIntervalMs)
+            put("serviceTitle", config.serviceTitle)
+            put("serviceBody", config.serviceBody)
+            put("backgroundTaskName", config.backgroundTaskName)
+            put("adaptiveAccuracy", config.adaptiveAccuracy)
+            put("idleSpeedThreshold", config.idleSpeedThreshold.toDouble())
+            put("idleSampleCount", config.idleSampleCount)
+            put("debug", config.debug)
+        }
+        prefs.edit()
+            .putString("configBundle", json.toString())
+            .putBoolean(BootReceiver.KEY_RESTART_ON_BOOT, config.restartOnBoot)
+            .apply()
+    }
+
+    private fun saveTrackingState(isTracking: Boolean) {
+        reactContext.getSharedPreferences(BootReceiver.PREFS_NAME, Context.MODE_PRIVATE)
+            .edit()
+            .putBoolean(BootReceiver.KEY_IS_TRACKING, isTracking)
+            .apply()
+    }
+
+    private fun log(msg: String) {
+        if (config.debug) Log.d(TAG, msg)
+    }
+
+    override fun invalidate() {
+        super.invalidate()
+        isReactContextActive = false
+        unregisterLocationReceiver()
+        if (config.stopOnAppClose) {
+            reactContext.stopService(Intent(reactContext, LocationService::class.java))
+        }
+    }
+}
+
+// --------------------------------------------------------------------------------------------
+// Extension helpers for ReadableMap
+// --------------------------------------------------------------------------------------------
+
+private fun ReadableMap.getDoubleOrDefault(key: String, default: Double): Double =
+    if (hasKey(key) && !isNull(key)) getDouble(key) else default
+
+private fun ReadableMap.getStringOrDefault(key: String, default: String): String =
+    if (hasKey(key) && !isNull(key)) getString(key) ?: default else default
+
+private fun ReadableMap.getBooleanOrDefault(key: String, default: Boolean): Boolean =
+    if (hasKey(key) && !isNull(key)) getBoolean(key) else default

package/android/src/main/java/com/geoservice/GeoServicePackage.kt

@@ -0,0 +1,14 @@
+package com.geoservice
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class GeoServicePackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
+        listOf(GeoServiceModule(reactContext))
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
+        emptyList()
+}

package/android/src/main/java/com/geoservice/HeadlessLocationTask.kt

@@ -0,0 +1,76 @@
+package com.geoservice
+
+import android.content.Intent
+import android.os.Bundle
+import android.util.Log
+import com.facebook.react.HeadlessJsTaskService
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.jstasks.HeadlessJsTaskConfig
+import org.json.JSONObject
+
+/**
+ * HeadlessJS task service invoked by LocationService when no React context is active.
+ *
+ * This allows JavaScript code to run in the background (e.g. to save the location to
+ * a server or local storage) even when the app UI is not visible.
+ *
+ * The user must register a matching headless task in their app's index.js:
+ *
+ *   AppRegistry.registerHeadlessTask('GeoServiceHeadlessTask', () => async (location) => {
+ *     // handle background location update
+ *   });
+ */
+class HeadlessLocationTask : HeadlessJsTaskService() {
+
+    companion object {
+        const val TAG = "GeoService:HeadlessTask"
+        // Max time (ms) the headless task is allowed to run before the OS kills it.
+        const val TIMEOUT_MS = 30_000L
+    }
+
+    override fun getTaskConfig(intent: Intent?): HeadlessJsTaskConfig? {
+        val taskName = intent?.getStringExtra("taskName") ?: run {
+            Log.w(TAG, "No taskName provided to HeadlessLocationTask")
+            return null
+        }
+        val locationJson = intent.getStringExtra("location") ?: run {
+            Log.w(TAG, "No location data provided to HeadlessLocationTask")
+            return null
+        }
+
+        val extras = buildTaskExtras(locationJson) ?: run {
+            Log.e(TAG, "Failed to parse location JSON")
+            return null
+        }
+
+        Log.d(TAG, "Starting headless task: $taskName")
+        return HeadlessJsTaskConfig(
+            taskName,
+            extras,
+            TIMEOUT_MS,
+            true // allow task to run in foreground (when app is visible too)
+        )
+    }
+
+    private fun buildTaskExtras(locationJson: String): com.facebook.react.bridge.WritableMap? {
+        return try {
+            val json = JSONObject(locationJson)
+            val map = Arguments.createMap()
+            map.putDouble("latitude", json.getDouble("latitude"))
+            map.putDouble("longitude", json.getDouble("longitude"))
+            map.putDouble("accuracy", json.getDouble("accuracy"))
+            map.putDouble("altitude", json.getDouble("altitude"))
+            map.putDouble("altitudeAccuracy", json.getDouble("altitudeAccuracy"))
+            map.putDouble("speed", json.getDouble("speed"))
+            map.putDouble("bearing", json.getDouble("bearing"))
+            map.putDouble("timestamp", json.getDouble("timestamp"))
+            if (json.has("isFromMockProvider")) {
+                map.putBoolean("isFromMockProvider", json.getBoolean("isFromMockProvider"))
+            }
+            map
+        } catch (e: Exception) {
+            Log.e(TAG, "Error building task extras: ${e.message}")
+            null
+        }
+    }
+}

package/android/src/main/java/com/geoservice/LocationService.kt

@@ -0,0 +1,265 @@
+package com.geoservice
+
+import android.annotation.SuppressLint
+import android.app.*
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.os.IBinder
+import android.util.Log
+import androidx.localbroadcastmanager.content.LocalBroadcastManager
+import com.google.android.gms.location.*
+import org.json.JSONObject
+
+class LocationService : Service() {
+
+    companion object {
+        const val TAG = "GeoService:LocationService"
+        const val ACTION_LOCATION_UPDATE = "com.geoservice.LOCATION_UPDATE"
+        const val ACTION_LOCATION_ERROR = "com.geoservice.LOCATION_ERROR"
+        const val EXTRA_LOCATION = "location"
+        const val EXTRA_ERROR = "error"
+        const val NOTIFICATION_CHANNEL_ID = "geo_service_channel"
+        const val NOTIFICATION_ID = 9731
+
+        var isRunning = false
+            private set
+    }
+
+    private lateinit var fusedLocationClient: FusedLocationProviderClient
+    private lateinit var locationCallback: LocationCallback
+    private var config: GeoServiceConfig = GeoServiceConfig()
+
+    // ---------------------------------------------------------------------------
+    // Adaptive accuracy state
+    // ---------------------------------------------------------------------------
+    private var slowReadingCount = 0
+    private var isIdle = false
+
+    override fun onCreate() {
+        super.onCreate()
+        fusedLocationClient = LocationServices.getFusedLocationProviderClient(this)
+        createNotificationChannel()
+        log("Service created")
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        val bundle = intent?.getBundleExtra("config")
+        config = GeoServiceConfig.fromBundle(bundle)
+
+        slowReadingCount = 0
+        isIdle = false
+
+        log("Starting — adaptiveAccuracy=${config.adaptiveAccuracy}, accuracy=${config.accuracy}")
+        startForeground(NOTIFICATION_ID, buildNotification())
+        startLocationUpdates(idleOverride = false)
+        isRunning = true
+
+        return START_STICKY
+    }
+
+    // ---------------------------------------------------------------------------
+    // Location updates
+    // ---------------------------------------------------------------------------
+
+    @SuppressLint("MissingPermission")
+    private fun startLocationUpdates(idleOverride: Boolean) {
+        if (::locationCallback.isInitialized) {
+            fusedLocationClient.removeLocationUpdates(locationCallback)
+        }
+
+        val (priority, interval, distanceMeters) = if (idleOverride) {
+            // Device is idle: cell-tower only, long interval, large gate.
+            // GPS chip goes completely idle.
+            Triple(Priority.PRIORITY_LOW_POWER, 30_000L, 50f)
+        } else {
+            Triple(activePriority(), config.updateIntervalMs, config.minDistanceMeters)
+        }
+
+        val locationRequest = LocationRequest.Builder(priority, interval)
+            .setMinUpdateIntervalMillis(if (idleOverride) 30_000L else config.minUpdateIntervalMs)
+            .setMinUpdateDistanceMeters(distanceMeters)
+            // Batching: OS can hold fixes and deliver them together → fewer CPU wake-ups.
+            .setMaxUpdateDelayMillis(interval * 2)
+            .setGranularity(Granularity.GRANULARITY_PERMISSION_LEVEL)
+            .build()
+
+        locationCallback = object : LocationCallback() {
+            override fun onLocationResult(result: LocationResult) {
+                result.lastLocation?.let { handleLocation(it) }
+            }
+
+            override fun onLocationAvailability(availability: LocationAvailability) {
+                if (!availability.isLocationAvailable) {
+                    broadcastError(1, "Location is not available")
+                }
+            }
+        }
+
+        try {
+            fusedLocationClient.requestLocationUpdates(locationRequest, locationCallback, mainLooper)
+            log("Updates registered — idle=$idleOverride, priority=$priority, interval=${interval}ms, dist=${distanceMeters}m")
+        } catch (e: SecurityException) {
+            broadcastError(2, "Location permission denied: ${e.message}")
+        }
+    }
+
+    // ---------------------------------------------------------------------------
+    // Adaptive accuracy — speed-based GPS on/off switching
+    // ---------------------------------------------------------------------------
+
+    private fun handleLocation(location: android.location.Location) {
+        if (config.adaptiveAccuracy) {
+            evaluateMotionState(location)
+        }
+        broadcastLocation(location)
+    }
+
+    private fun evaluateMotionState(location: android.location.Location) {
+        val speed = if (location.hasSpeed()) location.speed else 0f
+
+        if (speed < config.idleSpeedThreshold) {
+            slowReadingCount++
+            if (!isIdle && slowReadingCount >= config.idleSampleCount) {
+                isIdle = true
+                slowReadingCount = 0
+                log("Device idle — switching to LOW_POWER (GPS off)")
+                startLocationUpdates(idleOverride = true)
+            }
+        } else {
+            if (isIdle) {
+                isIdle = false
+                slowReadingCount = 0
+                log("Movement detected — restoring ${config.accuracy} accuracy")
+                startLocationUpdates(idleOverride = false)
+            } else {
+                slowReadingCount = 0
+            }
+        }
+    }
+
+    private fun activePriority(): Int = when (config.accuracy) {
+        "navigation", "high" -> Priority.PRIORITY_HIGH_ACCURACY
+        "low" -> Priority.PRIORITY_LOW_POWER
+        else -> Priority.PRIORITY_BALANCED_POWER_ACCURACY
+    }
+
+    // ---------------------------------------------------------------------------
+    // Broadcast helpers
+    // ---------------------------------------------------------------------------
+
+    private fun broadcastLocation(location: android.location.Location) {
+        val locationJson = JSONObject().apply {
+            put("latitude", location.latitude)
+            put("longitude", location.longitude)
+            put("accuracy", location.accuracy.toDouble())
+            put("altitude", location.altitude)
+            put("altitudeAccuracy", if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
+                location.verticalAccuracyMeters.toDouble() else -1.0)
+            put("speed", if (location.hasSpeed()) location.speed.toDouble() else -1.0)
+            put("bearing", if (location.hasBearing()) location.bearing.toDouble() else -1.0)
+            put("timestamp", location.time)
+            put("isStationary", isIdle)
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                put("isFromMockProvider", location.isMock)
+            }
+        }.toString()
+
+        log("Location: lat=${location.latitude}, lng=${location.longitude}, speed=${location.speed} m/s, idle=$isIdle")
+
+        val localIntent = Intent(ACTION_LOCATION_UPDATE).apply {
+            putExtra(EXTRA_LOCATION, locationJson)
+        }
+        LocalBroadcastManager.getInstance(this).sendBroadcast(localIntent)
+
+        if (!GeoServiceModule.isReactContextActive && config.backgroundTaskName.isNotEmpty()) {
+            startHeadlessTask(locationJson)
+        }
+    }
+
+    private fun broadcastError(code: Int, message: String) {
+        Log.e(TAG, "Location error [$code]: $message")
+        val errorJson = JSONObject().apply {
+            put("code", code)
+            put("message", message)
+        }.toString()
+        val intent = Intent(ACTION_LOCATION_ERROR).apply {
+            putExtra(EXTRA_ERROR, errorJson)
+        }
+        LocalBroadcastManager.getInstance(this).sendBroadcast(intent)
+    }
+
+    private fun startHeadlessTask(locationJson: String) {
+        log("Starting background task: ${config.backgroundTaskName}")
+        val intent = Intent(this, HeadlessLocationTask::class.java).apply {
+            putExtra("location", locationJson)
+            putExtra("taskName", config.backgroundTaskName)
+        }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            startForegroundService(intent)
+        } else {
+            startService(intent)
+        }
+    }
+
+    // ---------------------------------------------------------------------------
+    // Notification
+    // ---------------------------------------------------------------------------
+
+    private fun createNotificationChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(
+                NOTIFICATION_CHANNEL_ID,
+                "Location Tracking",
+                NotificationManager.IMPORTANCE_LOW
+            ).apply {
+                description = "Background location tracking"
+                setShowBadge(false)
+                enableVibration(false)
+                setSound(null, null)
+            }
+            val manager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+            manager.createNotificationChannel(channel)
+        }
+    }
+
+    private fun buildNotification(): Notification {
+        val builder = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            Notification.Builder(this, NOTIFICATION_CHANNEL_ID)
+        } else {
+            @Suppress("DEPRECATION")
+            Notification.Builder(this)
+        }
+        val launchIntent = packageManager.getLaunchIntentForPackage(packageName)
+        val pendingFlags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
+            PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
+        else
+            PendingIntent.FLAG_UPDATE_CURRENT
+        val pendingIntent = PendingIntent.getActivity(this, 0, launchIntent, pendingFlags)
+
+        return builder
+            .setContentTitle(config.serviceTitle)
+            .setContentText(config.serviceBody)
+            .setSmallIcon(android.R.drawable.ic_menu_mylocation)
+            .setOngoing(true)
+            .setContentIntent(pendingIntent)
+            .build()
+    }
+
+    // ---------------------------------------------------------------------------
+
+    override fun onDestroy() {
+        super.onDestroy()
+        if (::locationCallback.isInitialized) {
+            fusedLocationClient.removeLocationUpdates(locationCallback)
+        }
+        isRunning = false
+        log("Service destroyed")
+    }
+
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    private fun log(msg: String) {
+        if (config.debug) Log.d(TAG, msg)
+    }
+}

package/ios/RNGeoService.h

@@ -0,0 +1,19 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import <CoreLocation/CoreLocation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * RNGeoService — Battery-efficient background geolocation for React Native (iOS)
+ *
+ * Supports:
+ *  - Standard location updates (fine-grained, respects minDistanceMeters)
+ *  - Significant location changes (coarse, very battery-efficient, wakes app when terminated)
+ *  - Background location via UIBackgroundModes: location
+ */
+@interface RNGeoService : RCTEventEmitter <RCTBridgeModule, CLLocationManagerDelegate>
+
+@end
+
+NS_ASSUME_NONNULL_END