@tsachit/react-native-geo-service 1.0.1 → 1.0.3

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

@@ -7,6 +7,7 @@ import android.content.Intent
 import android.os.Build
 import android.os.IBinder
 import android.util.Log
+import androidx.core.content.ContextCompat
 import androidx.localbroadcastmanager.content.LocalBroadcastManager
 import com.google.android.gms.location.*
 import org.json.JSONObject
@@ -24,6 +25,21 @@ class LocationService : Service() {
 
         var isRunning = false
             private set
+
+        // Session tracking metrics (readable by GeoServiceModule)
+        var updateCount: Long = 0
+            private set
+        var trackingStartTimeMs: Long = 0
+            private set
+        // Accumulated GPS-on milliseconds (excludes current open window)
+        private var gpsAccumulatedMs: Long = 0
+        // When the current GPS-on window started (0 = GPS currently idle)
+        private var gpsActiveWindowStartMs: Long = 0
+
+        /** Total GPS-active ms including any currently open window */
+        val currentGpsActiveMs: Long
+            get() = gpsAccumulatedMs +
+                if (gpsActiveWindowStartMs > 0) System.currentTimeMillis() - gpsActiveWindowStartMs else 0L
     }
 
     private lateinit var fusedLocationClient: FusedLocationProviderClient
@@ -44,12 +60,30 @@ class LocationService : Service() {
     }
 
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-        val bundle = intent?.getBundleExtra("config")
-        config = GeoServiceConfig.fromBundle(bundle)
+        config = if (intent != null) {
+            GeoServiceConfig.fromBundle(intent.getBundleExtra("config"))
+        } else {
+            // START_STICKY restart after force-kill: intent is null, restore from SharedPreferences
+            Log.d(TAG, "START_STICKY restart detected — restoring config from SharedPreferences")
+            configFromSharedPreferences()
+        }
+
+        // Stop immediately if location permission was revoked while we were away
+        if (!hasLocationPermission()) {
+            Log.e(TAG, "Location permission not granted — stopping service")
+            stopSelf()
+            return START_NOT_STICKY
+        }
 
         slowReadingCount = 0
         isIdle = false
 
+        // Reset session metrics
+        updateCount = 0
+        trackingStartTimeMs = System.currentTimeMillis()
+        gpsAccumulatedMs = 0
+        gpsActiveWindowStartMs = System.currentTimeMillis() // GPS starts active
+
         log("Starting — adaptiveAccuracy=${config.adaptiveAccuracy}, accuracy=${config.accuracy}")
         startForeground(NOTIFICATION_ID, buildNotification())
         startLocationUpdates(idleOverride = false)
@@ -58,6 +92,63 @@ class LocationService : Service() {
         return START_STICKY
     }
 
+    // Called when the user swipes the app away from the recents screen.
+    // By default the foreground service keeps running — which is correct for
+    // always-on tracking. If stopOnAppClose=true we honour the user's intent.
+    override fun onTaskRemoved(rootIntent: Intent?) {
+        super.onTaskRemoved(rootIntent)
+        val prefs = getSharedPreferences(BootReceiver.PREFS_NAME, Context.MODE_PRIVATE)
+        val shouldStop = try {
+            val json = prefs.getString("configBundle", null)
+            json?.let { org.json.JSONObject(it).optBoolean("stopOnAppClose", false) } ?: false
+        } catch (e: Exception) { false }
+
+        if (shouldStop) {
+            log("App removed from recents — stopOnAppClose=true, stopping service")
+            prefs.edit().putBoolean(BootReceiver.KEY_IS_TRACKING, false).apply()
+            stopSelf()
+        } else {
+            log("App removed from recents — continuing background tracking")
+        }
+    }
+
+    private fun hasLocationPermission(): Boolean {
+        val fine = ContextCompat.checkSelfPermission(
+            this, android.Manifest.permission.ACCESS_FINE_LOCATION
+        ) == android.content.pm.PackageManager.PERMISSION_GRANTED
+        val coarse = ContextCompat.checkSelfPermission(
+            this, android.Manifest.permission.ACCESS_COARSE_LOCATION
+        ) == android.content.pm.PackageManager.PERMISSION_GRANTED
+        return fine || coarse
+    }
+
+    private fun configFromSharedPreferences(): GeoServiceConfig {
+        val prefs = getSharedPreferences(BootReceiver.PREFS_NAME, Context.MODE_PRIVATE)
+        val configJson = prefs.getString("configBundle", null) ?: return GeoServiceConfig()
+        return try {
+            val json = org.json.JSONObject(configJson)
+            val bundle = android.os.Bundle().apply {
+                putFloat("minDistanceMeters", json.optDouble("minDistanceMeters", 10.0).toFloat())
+                putString("accuracy", json.optString("accuracy", "balanced"))
+                putBoolean("stopOnAppClose", json.optBoolean("stopOnAppClose", false))
+                putBoolean("restartOnBoot", json.optBoolean("restartOnBoot", false))
+                putLong("updateIntervalMs", json.optLong("updateIntervalMs", 5000L))
+                putLong("minUpdateIntervalMs", json.optLong("minUpdateIntervalMs", 2000L))
+                putString("serviceTitle", json.optString("serviceTitle", "Location Tracking"))
+                putString("serviceBody", json.optString("serviceBody", "Your location is being tracked in the background."))
+                putString("backgroundTaskName", json.optString("backgroundTaskName", "GeoServiceHeadlessTask"))
+                putBoolean("adaptiveAccuracy", json.optBoolean("adaptiveAccuracy", true))
+                putFloat("idleSpeedThreshold", json.optDouble("idleSpeedThreshold", 0.5).toFloat())
+                putInt("idleSampleCount", json.optInt("idleSampleCount", 3))
+                putBoolean("debug", json.optBoolean("debug", false))
+            }
+            GeoServiceConfig.fromBundle(bundle)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to restore config from SharedPreferences: ${e.message}")
+            GeoServiceConfig()
+        }
+    }
+
     // ---------------------------------------------------------------------------
     // Location updates
     // ---------------------------------------------------------------------------
@@ -109,6 +200,7 @@ class LocationService : Service() {
     // ---------------------------------------------------------------------------
 
     private fun handleLocation(location: android.location.Location) {
+        updateCount++
         if (config.adaptiveAccuracy) {
             evaluateMotionState(location)
         }
@@ -123,6 +215,11 @@ class LocationService : Service() {
             if (!isIdle && slowReadingCount >= config.idleSampleCount) {
                 isIdle = true
                 slowReadingCount = 0
+                // Accumulate GPS-on time before going idle
+                if (gpsActiveWindowStartMs > 0) {
+                    gpsAccumulatedMs += System.currentTimeMillis() - gpsActiveWindowStartMs
+                    gpsActiveWindowStartMs = 0
+                }
                 log("Device idle — switching to LOW_POWER (GPS off)")
                 startLocationUpdates(idleOverride = true)
             }
@@ -130,6 +227,7 @@ class LocationService : Service() {
             if (isIdle) {
                 isIdle = false
                 slowReadingCount = 0
+                gpsActiveWindowStartMs = System.currentTimeMillis() // GPS back on
                 log("Movement detected — restoring ${config.accuracy} accuracy")
                 startLocationUpdates(idleOverride = false)
             } else {
@@ -195,11 +293,12 @@ class LocationService : Service() {
             putExtra("location", locationJson)
             putExtra("taskName", config.backgroundTaskName)
         }
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            startForegroundService(intent)
-        } else {
-            startService(intent)
-        }
+        // Always use startService — HeadlessJsTaskService does NOT call startForeground().
+        // Using startForegroundService() here would crash with
+        // ForegroundServiceDidNotStartInTimeException after 5 seconds on Android O+.
+        // This is safe because LocationService itself is a foreground service, which
+        // allows it to start background services regardless of app state.
+        startService(intent)
     }
 
     // ---------------------------------------------------------------------------
@@ -237,9 +336,12 @@ class LocationService : Service() {
             PendingIntent.FLAG_UPDATE_CURRENT
         val pendingIntent = PendingIntent.getActivity(this, 0, launchIntent, pendingFlags)
 
+        val title = if (config.debug) "[DEBUG] ${config.serviceTitle}" else config.serviceTitle
+        val body = if (config.debug) "Tracking active — debug mode on" else config.serviceBody
+
         return builder
-            .setContentTitle(config.serviceTitle)
-            .setContentText(config.serviceBody)
+            .setContentTitle(title)
+            .setContentText(body)
             .setSmallIcon(android.R.drawable.ic_menu_mylocation)
             .setOngoing(true)
             .setContentIntent(pendingIntent)

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

@@ -0,0 +1,87 @@
+package com.geoservice
+
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.util.Log
+import androidx.work.CoroutineWorker
+import androidx.work.WorkerParameters
+
+/**
+ * Periodic watchdog that detects when the LocationService was killed by the OS
+ * (common on Xiaomi, Samsung, Huawei with aggressive battery optimization) and
+ * restarts it using the config persisted in SharedPreferences.
+ *
+ * Scheduled every 15 minutes (WorkManager minimum). If the service is already
+ * running nothing happens. If tracking was expected but the service is dead,
+ * it is restarted with the user's original config.
+ */
+class WatchdogWorker(
+    private val appContext: Context,
+    workerParams: WorkerParameters
+) : CoroutineWorker(appContext, workerParams) {
+
+    companion object {
+        const val TAG = "GeoService:Watchdog"
+        const val WORK_NAME = "GeoServiceWatchdog"
+    }
+
+    override suspend fun doWork(): Result {
+        val prefs = appContext.getSharedPreferences(
+            BootReceiver.PREFS_NAME, Context.MODE_PRIVATE
+        )
+        val isTrackingExpected = prefs.getBoolean(BootReceiver.KEY_IS_TRACKING, false)
+
+        if (!isTrackingExpected) {
+            Log.d(TAG, "Tracking not expected — nothing to do")
+            return Result.success()
+        }
+
+        if (LocationService.isRunning) {
+            Log.d(TAG, "Service is running — no action needed")
+            return Result.success()
+        }
+
+        Log.w(TAG, "Service not running but tracking was expected — restarting")
+
+        val configJson = prefs.getString("configBundle", null)
+        val serviceIntent = Intent(appContext, LocationService::class.java)
+
+        if (configJson != null) {
+            try {
+                val json = org.json.JSONObject(configJson)
+                val bundle = android.os.Bundle().apply {
+                    putFloat("minDistanceMeters", json.optDouble("minDistanceMeters", 10.0).toFloat())
+                    putString("accuracy", json.optString("accuracy", "balanced"))
+                    putBoolean("stopOnAppClose", json.optBoolean("stopOnAppClose", false))
+                    putBoolean("restartOnBoot", json.optBoolean("restartOnBoot", false))
+                    putLong("updateIntervalMs", json.optLong("updateIntervalMs", 5000L))
+                    putLong("minUpdateIntervalMs", json.optLong("minUpdateIntervalMs", 2000L))
+                    putString("serviceTitle", json.optString("serviceTitle", "Location Tracking"))
+                    putString("serviceBody", json.optString("serviceBody", "Your location is being tracked in the background."))
+                    putString("backgroundTaskName", json.optString("backgroundTaskName", "GeoServiceHeadlessTask"))
+                    putBoolean("adaptiveAccuracy", json.optBoolean("adaptiveAccuracy", true))
+                    putFloat("idleSpeedThreshold", json.optDouble("idleSpeedThreshold", 0.5).toFloat())
+                    putInt("idleSampleCount", json.optInt("idleSampleCount", 3))
+                    putBoolean("debug", json.optBoolean("debug", false))
+                }
+                serviceIntent.putExtra("config", bundle)
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to parse config — starting with defaults: ${e.message}")
+            }
+        }
+
+        return try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                appContext.startForegroundService(serviceIntent)
+            } else {
+                appContext.startService(serviceIntent)
+            }
+            Log.d(TAG, "Service restarted successfully")
+            Result.success()
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to restart service: ${e.message}")
+            Result.retry()
+        }
+    }
+}

package/ios/RNGeoService.m

@@ -1,5 +1,6 @@
 #import "RNGeoService.h"
 #import <React/RCTLog.h>
+#import <UIKit/UIKit.h>
 
 // ---------------------------------------------------------------------------
 // CLActivityType helper
@@ -33,6 +34,9 @@ static CLLocationAccuracy accuracyFromString(NSString *accuracy) {
 @property (nonatomic, strong) CLLocationManager *locationManager;
 @property (nonatomic, strong) NSDictionary *config;
 
+// Locations buffered while JS listeners are not yet attached (background relaunch)
+@property (nonatomic, strong) NSMutableArray<NSDictionary *> *pendingLocations;
+
 @property (nonatomic, assign) BOOL isTracking;
 @property (nonatomic, assign) BOOL hasListeners;
 @property (nonatomic, assign) BOOL coarseTracking;
@@ -45,6 +49,15 @@ static CLLocationAccuracy accuracyFromString(NSString *accuracy) {
 @property (nonatomic, assign) NSInteger slowReadingCount;
 @property (nonatomic, assign) BOOL isIdle;
 
+// Battery tracking
+@property (nonatomic, assign) float batteryLevelAtStart;
+
+// Session tracking metrics
+@property (nonatomic, assign) NSInteger updateCount;
+@property (nonatomic, strong) NSDate *trackingStartTime;
+@property (nonatomic, assign) NSTimeInterval gpsActiveSeconds; // accumulated GPS-on time
+@property (nonatomic, strong) NSDate *gpsActiveStart;          // when current GPS-on window started
+
 @end
 
 @implementation RNGeoService
@@ -59,6 +72,56 @@ RCT_EXPORT_MODULE();
     return dispatch_get_main_queue();
 }
 
+// ---------------------------------------------------------------------------
+// Init — auto-resume tracking if app was relaunched from terminated state
+//
+// iOS can relaunch a terminated app when startMonitoringSignificantLocationChanges
+// is active. When this happens, React Native creates a fresh module instance.
+// We detect this via NSUserDefaults and immediately resume tracking so that
+// location updates are not lost during the relaunch window.
+// ---------------------------------------------------------------------------
+- (instancetype)init {
+    if (self = [super init]) {
+        self.pendingLocations = [NSMutableArray array];
+
+        NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
+        BOOL wasTracking = [defaults boolForKey:@"GeoServiceIsTracking"];
+
+        if (wasTracking) {
+            // Restore persisted config
+            NSData *configData = [defaults objectForKey:@"GeoServiceConfig"];
+            if (configData) {
+                NSDictionary *restoredConfig = [NSPropertyListSerialization
+                    propertyListWithData:configData options:0 format:nil error:nil];
+                if (restoredConfig) {
+                    self.config             = restoredConfig;
+                    self.coarseTracking     = [restoredConfig[@"coarseTracking"] boolValue];
+                    self.debugMode          = [restoredConfig[@"debug"] boolValue];
+                    self.adaptiveAccuracy   = restoredConfig[@"adaptiveAccuracy"]
+                        ? [restoredConfig[@"adaptiveAccuracy"] boolValue] : YES;
+                    self.idleSpeedThreshold = restoredConfig[@"idleSpeedThreshold"]
+                        ? [restoredConfig[@"idleSpeedThreshold"] floatValue] : 0.5f;
+                    self.idleSampleCount    = restoredConfig[@"idleSampleCount"]
+                        ? [restoredConfig[@"idleSampleCount"] integerValue] : 3;
+                }
+            }
+
+            [self applyConfigToLocationManager];
+
+            // Significant changes is always running alongside standard updates —
+            // it is the only mechanism that can wake a terminated app and costs
+            // almost nothing in battery (cell towers, not GPS).
+            [self.locationManager startMonitoringSignificantLocationChanges];
+            if (!self.coarseTracking) {
+                [self.locationManager startUpdatingLocation];
+            }
+            self.isTracking = YES;
+            if (self.debugMode) RCTLogInfo(@"[RNGeoService] Auto-resumed tracking after app relaunch");
+        }
+    }
+    return self;
+}
+
 // ---------------------------------------------------------------------------
 // Supported events
 // ---------------------------------------------------------------------------
@@ -66,8 +129,24 @@ RCT_EXPORT_MODULE();
     return @[@"onLocation", @"onError"];
 }
 
-- (void)startObserving { self.hasListeners = YES; }
-- (void)stopObserving  { self.hasListeners = NO;  }
+// Drain any locations that arrived before JS listeners were attached.
+// This is the normal case during a background relaunch from terminated state:
+// CLLocationManager fires before the React component tree has mounted.
+- (void)startObserving {
+    self.hasListeners = YES;
+    if (self.pendingLocations.count > 0) {
+        if (self.debugMode) {
+            RCTLogInfo(@"[RNGeoService] Draining %lu buffered location(s) to JS",
+                       (unsigned long)self.pendingLocations.count);
+        }
+        for (NSDictionary *loc in self.pendingLocations) {
+            [self sendEventWithName:@"onLocation" body:loc];
+        }
+        [self.pendingLocations removeAllObjects];
+    }
+}
+
+- (void)stopObserving { self.hasListeners = NO; }
 
 // ---------------------------------------------------------------------------
 // Lazy CLLocationManager
@@ -86,7 +165,7 @@ RCT_EXPORT_MODULE();
 RCT_EXPORT_METHOD(configure:(NSDictionary *)options
                   resolve:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject) {
-    self.config = options;
+    self.config           = options;
     self.coarseTracking   = [options[@"coarseTracking"] boolValue];
     self.debugMode        = [options[@"debug"] boolValue];
     self.adaptiveAccuracy = options[@"adaptiveAccuracy"] ? [options[@"adaptiveAccuracy"] boolValue] : YES;
@@ -95,6 +174,19 @@ RCT_EXPORT_METHOD(configure:(NSDictionary *)options
     self.slowReadingCount = 0;
     self.isIdle           = NO;
 
+    // Persist config so it survives app termination and can be restored on
+    // background relaunch triggered by significant location changes.
+    NSError *serializeError = nil;
+    NSData *configData = [NSPropertyListSerialization
+        dataWithPropertyList:options
+        format:NSPropertyListBinaryFormat_v1_0
+        options:0
+        error:&serializeError];
+    if (configData && !serializeError) {
+        [[NSUserDefaults standardUserDefaults] setObject:configData forKey:@"GeoServiceConfig"];
+        [[NSUserDefaults standardUserDefaults] synchronize];
+    }
+
     [self applyConfigToLocationManager];
 
     if (self.debugMode) RCTLogInfo(@"[RNGeoService] Config applied: %@", options);
@@ -117,7 +209,7 @@ RCT_EXPORT_METHOD(configure:(NSDictionary *)options
     self.locationManager.pausesLocationUpdatesAutomatically = autoPause;
 
     if (@available(iOS 11.0, *)) {
-        BOOL bgIndicator = [cfg[@"showBackgroundIndicator"] boolValue];
+        BOOL bgIndicator = self.debugMode ? YES : [cfg[@"showBackgroundIndicator"] boolValue];
         self.locationManager.showsBackgroundLocationIndicator = bgIndicator;
     }
 
@@ -131,30 +223,44 @@ RCT_EXPORT_METHOD(start:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject) {
     CLAuthorizationStatus status = [CLLocationManager authorizationStatus];
 
+    // If permission is denied or restricted, resolve without starting.
+    // The app is responsible for requesting OS permission (via react-native-permissions)
+    // before calling start(). If denied, the didChangeAuthorizationStatus delegate
+    // will handle cleanup.
     if (status == kCLAuthorizationStatusDenied ||
         status == kCLAuthorizationStatusRestricted) {
-        reject(@"PERMISSION_DENIED", @"Location permission denied. Request 'Always' permission before calling start().", nil);
+        resolve(nil);
         return;
     }
 
-    if (status == kCLAuthorizationStatusNotDetermined) {
-        [self.locationManager requestAlwaysAuthorization];
-    }
-
     [self applyConfigToLocationManager];
 
+    // Significant changes MUST always run alongside standard updates.
+    // It is the only iOS mechanism that can relaunch a terminated app —
+    // and it uses cell towers (not GPS), so battery cost is negligible.
+    [self.locationManager startMonitoringSignificantLocationChanges];
+
     if (self.coarseTracking) {
-        [self.locationManager startMonitoringSignificantLocationChanges];
-        if (self.debugMode) RCTLogInfo(@"[RNGeoService] Coarse (significant-change) tracking started");
+        if (self.debugMode) RCTLogInfo(@"[RNGeoService] Coarse (significant-change only) tracking started");
     } else {
         [self.locationManager startUpdatingLocation];
-        if (self.debugMode) RCTLogInfo(@"[RNGeoService] Standard tracking started");
+        if (self.debugMode) RCTLogInfo(@"[RNGeoService] Standard tracking started (+ significant changes for background wake)");
     }
 
     self.isTracking = YES;
     [[NSUserDefaults standardUserDefaults] setBool:YES forKey:@"GeoServiceIsTracking"];
     [[NSUserDefaults standardUserDefaults] synchronize];
 
+    // Record battery level at tracking start for drain calculation
+    [UIDevice currentDevice].batteryMonitoringEnabled = YES;
+    self.batteryLevelAtStart = [UIDevice currentDevice].batteryLevel;
+
+    // Reset session metrics
+    self.updateCount      = 0;
+    self.gpsActiveSeconds = 0;
+    self.trackingStartTime = [NSDate date];
+    self.gpsActiveStart    = [NSDate date]; // GPS starts active
+
     resolve(nil);
 }
 
@@ -163,14 +269,12 @@ RCT_EXPORT_METHOD(start:(RCTPromiseResolveBlock)resolve
 // ---------------------------------------------------------------------------
 RCT_EXPORT_METHOD(stop:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject) {
-    if (self.coarseTracking) {
-        [self.locationManager stopMonitoringSignificantLocationChanges];
-    } else {
-        [self.locationManager stopUpdatingLocation];
-    }
+    [self.locationManager stopUpdatingLocation];
+    [self.locationManager stopMonitoringSignificantLocationChanges];
 
     self.isTracking = NO;
     [[NSUserDefaults standardUserDefaults] setBool:NO forKey:@"GeoServiceIsTracking"];
+    [[NSUserDefaults standardUserDefaults] removeObjectForKey:@"GeoServiceConfig"];
     [[NSUserDefaults standardUserDefaults] synchronize];
 
     if (self.debugMode) RCTLogInfo(@"[RNGeoService] Tracking stopped");
@@ -195,6 +299,55 @@ RCT_EXPORT_METHOD(getCurrentLocation:(RCTPromiseResolveBlock)resolve
     }
 }
 
+// ---------------------------------------------------------------------------
+// getBatteryInfo() / setLocationIndicator()
+// ---------------------------------------------------------------------------
+RCT_EXPORT_METHOD(getBatteryInfo:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+    [UIDevice currentDevice].batteryMonitoringEnabled = YES;
+    float current = [UIDevice currentDevice].batteryLevel;
+    UIDeviceBatteryState state = [UIDevice currentDevice].batteryState;
+    BOOL isCharging = state == UIDeviceBatteryStateCharging || state == UIDeviceBatteryStateFull;
+    float drain = (self.batteryLevelAtStart > 0 && current > 0)
+        ? (self.batteryLevelAtStart - current) * 100.0f : 0.0f;
+
+    // Elapsed session time
+    NSTimeInterval elapsed = self.trackingStartTime
+        ? [[NSDate date] timeIntervalSinceDate:self.trackingStartTime] : 0;
+
+    // GPS active = accumulated time + current window (if GPS is on right now)
+    NSTimeInterval gpsActive = self.gpsActiveSeconds;
+    if (!self.isIdle && self.gpsActiveStart) {
+        gpsActive += [[NSDate date] timeIntervalSinceDate:self.gpsActiveStart];
+    }
+
+    double updatesPerMinute = (elapsed > 0)
+        ? (self.updateCount / (elapsed / 60.0)) : 0;
+    double drainRatePerHour = (elapsed > 0 && drain > 0)
+        ? (drain / (elapsed / 3600.0)) : 0;
+
+    resolve(@{
+        @"level":                  @(current * 100.0f),
+        @"isCharging":             @(isCharging),
+        @"levelAtStart":           @(self.batteryLevelAtStart * 100.0f),
+        @"drainSinceStart":        @(MAX(drain, 0.0f)),
+        @"updateCount":            @(self.updateCount),
+        @"trackingElapsedSeconds": @(elapsed),
+        @"gpsActiveSeconds":       @(gpsActive),
+        @"updatesPerMinute":       @(updatesPerMinute),
+        @"drainRatePerHour":       @(MAX(drainRatePerHour, 0.0))
+    });
+}
+
+RCT_EXPORT_METHOD(setLocationIndicator:(BOOL)show
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+    if (@available(iOS 11.0, *)) {
+        self.locationManager.showsBackgroundLocationIndicator = show;
+    }
+    resolve(nil);
+}
+
 // ---------------------------------------------------------------------------
 // CLLocationManagerDelegate
 // ---------------------------------------------------------------------------
@@ -203,8 +356,11 @@ RCT_EXPORT_METHOD(getCurrentLocation:(RCTPromiseResolveBlock)resolve
     CLLocation *location = [locations lastObject];
     if (!location) return;
 
+    self.updateCount++;
+
     if (self.debugMode) {
-        RCTLogInfo(@"[RNGeoService] Location: %f, %f (±%.0fm) speed=%.1fm/s",
+        RCTLogInfo(@"[RNGeoService] Location #%ld: %f, %f (±%.0fm) speed=%.1fm/s",
+                   (long)self.updateCount,
                    location.coordinate.latitude,
                    location.coordinate.longitude,
                    location.horizontalAccuracy,
@@ -215,8 +371,18 @@ RCT_EXPORT_METHOD(getCurrentLocation:(RCTPromiseResolveBlock)resolve
         [self evaluateMotionState:location];
     }
 
+    NSDictionary *locationDict = [self locationToDictionary:location];
+
     if (self.hasListeners) {
-        [self sendEventWithName:@"onLocation" body:[self locationToDictionary:location]];
+        [self sendEventWithName:@"onLocation" body:locationDict];
+    } else {
+        // Buffer the location — JS listeners haven't attached yet.
+        // This is normal during background relaunch: CLLocationManager fires
+        // before the React component tree has had time to mount.
+        // Events are drained in startObserving() once a listener attaches.
+        if (self.pendingLocations.count < 10) {
+            [self.pendingLocations addObject:locationDict];
+        }
     }
 }
 
@@ -229,6 +395,11 @@ RCT_EXPORT_METHOD(getCurrentLocation:(RCTPromiseResolveBlock)resolve
         if (!self.isIdle && self.slowReadingCount >= self.idleSampleCount) {
             self.isIdle = YES;
             self.slowReadingCount = 0;
+            // Accumulate GPS-on time before going idle
+            if (self.gpsActiveStart) {
+                self.gpsActiveSeconds += [[NSDate date] timeIntervalSinceDate:self.gpsActiveStart];
+                self.gpsActiveStart = nil;
+            }
             // Reduce accuracy — CoreLocation stops requesting GPS
             self.locationManager.desiredAccuracy = kCLLocationAccuracyKilometer;
             self.locationManager.distanceFilter = 50.0;
@@ -238,6 +409,7 @@ RCT_EXPORT_METHOD(getCurrentLocation:(RCTPromiseResolveBlock)resolve
         if (self.isIdle) {
             self.isIdle = NO;
             self.slowReadingCount = 0;
+            self.gpsActiveStart = [NSDate date]; // GPS back on
             [self applyConfigToLocationManager];
             if (self.debugMode) RCTLogInfo(@"[RNGeoService] Movement detected — accuracy restored");
         } else {
@@ -248,20 +420,21 @@ RCT_EXPORT_METHOD(getCurrentLocation:(RCTPromiseResolveBlock)resolve
 
 - (void)locationManager:(CLLocationManager *)manager
        didFailWithError:(NSError *)error {
-    // kCLErrorLocationUnknown (code 0) is transient — CoreLocation couldn't get a
-    // fix yet but will keep trying automatically. Silently ignore it so we don't
-    // surface a noisy error to the app before the GPS has warmed up.
+    // kCLErrorLocationUnknown (code 0) is transient — CoreLocation hasn't acquired
+    // a fix yet but will keep trying automatically. Silently ignore it.
     if ([error.domain isEqualToString:kCLErrorDomain] && error.code == kCLErrorLocationUnknown) {
         if (self.debugMode) RCTLogInfo(@"[RNGeoService] Location unknown (transient) — waiting for GPS fix");
         return;
     }
 
-    // kCLErrorDenied means the user revoked location permission — this is a real
-    // error worth surfacing, and we should stop tracking to avoid repeated failures.
+    // kCLErrorDenied: user revoked permission. Stop everything and clear state.
     if ([error.domain isEqualToString:kCLErrorDomain] && error.code == kCLErrorDenied) {
         RCTLogWarn(@"[RNGeoService] Location permission denied — stopping tracking");
         [self.locationManager stopUpdatingLocation];
         [self.locationManager stopMonitoringSignificantLocationChanges];
+        self.isTracking = NO;
+        [[NSUserDefaults standardUserDefaults] setBool:NO forKey:@"GeoServiceIsTracking"];
+        [[NSUserDefaults standardUserDefaults] synchronize];
     } else {
         RCTLogError(@"[RNGeoService] Location error: %@", error.localizedDescription);
     }
@@ -276,18 +449,38 @@ RCT_EXPORT_METHOD(getCurrentLocation:(RCTPromiseResolveBlock)resolve
 
 - (void)locationManager:(CLLocationManager *)manager
     didChangeAuthorizationStatus:(CLAuthorizationStatus)status {
-    if (self.debugMode) RCTLogInfo(@"[RNGeoService] Auth status: %d", status);
+    if (self.debugMode) RCTLogInfo(@"[RNGeoService] Auth status changed: %d", status);
+
+    // Permission was revoked while tracking — stop and notify JS
+    if (status == kCLAuthorizationStatusDenied || status == kCLAuthorizationStatusRestricted) {
+        if (self.isTracking) {
+            [self.locationManager stopUpdatingLocation];
+            [self.locationManager stopMonitoringSignificantLocationChanges];
+            self.isTracking = NO;
+            [[NSUserDefaults standardUserDefaults] setBool:NO forKey:@"GeoServiceIsTracking"];
+            [[NSUserDefaults standardUserDefaults] synchronize];
+            if (self.hasListeners) {
+                [self sendEventWithName:@"onError" body:@{
+                    @"code":    @(kCLErrorDenied),
+                    @"message": @"Location permission was revoked. Please re-enable in Settings."
+                }];
+            }
+        }
+        return;
+    }
 
-    // Resume tracking after background relaunch (e.g. significant location change)
-    if (status == kCLAuthorizationStatusAuthorizedAlways &&
+    // Permission granted after background relaunch — resume if we were tracking before
+    if ((status == kCLAuthorizationStatusAuthorizedAlways ||
+         status == kCLAuthorizationStatusAuthorizedWhenInUse) &&
+        !self.isTracking &&
         [[NSUserDefaults standardUserDefaults] boolForKey:@"GeoServiceIsTracking"]) {
         [self applyConfigToLocationManager];
-        if (self.coarseTracking) {
-            [self.locationManager startMonitoringSignificantLocationChanges];
-        } else {
+        [self.locationManager startMonitoringSignificantLocationChanges];
+        if (!self.coarseTracking) {
             [self.locationManager startUpdatingLocation];
         }
         self.isTracking = YES;
+        if (self.debugMode) RCTLogInfo(@"[RNGeoService] Tracking resumed after auth grant");
     }
 }