@tsachit/react-native-geo-service 1.0.0 → 1.0.2

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");
     }
 }
 

package/lib/GeoDebugOverlay.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+/**
+ * Drop this anywhere in your component tree once.
+ * It renders the GeoDebugPanel automatically when:
+ *   - debug: true was passed to configure()
+ *   - location tracking is active (implies permission was granted)
+ * Nothing is rendered if debug is false or tracking hasn't started.
+ */
+export declare const GeoDebugOverlay: React.FC;

package/lib/GeoDebugOverlay.js

@@ -0,0 +1,86 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeoDebugOverlay = void 0;
+const react_1 = __importStar(require("react"));
+const index_1 = __importDefault(require("./index"));
+const index_2 = require("./index");
+const GeoDebugPanel_1 = require("./GeoDebugPanel");
+/**
+ * Drop this anywhere in your component tree once.
+ * It renders the GeoDebugPanel automatically when:
+ *   - debug: true was passed to configure()
+ *   - location tracking is active (implies permission was granted)
+ * Nothing is rendered if debug is false or tracking hasn't started.
+ */
+const GeoDebugOverlay = () => {
+    const [visible, setVisible] = (0, react_1.useState)(false);
+    (0, react_1.useEffect)(() => {
+        let cancelled = false;
+        const check = () => __awaiter(void 0, void 0, void 0, function* () {
+            try {
+                const tracking = yield index_1.default.isTracking();
+                if (!cancelled)
+                    setVisible((0, index_2._isDebugMode)() && tracking);
+            }
+            catch (_) {
+                if (!cancelled)
+                    setVisible(false);
+            }
+        });
+        check();
+        const id = setInterval(check, 3000);
+        return () => {
+            cancelled = true;
+            clearInterval(id);
+        };
+    }, []);
+    if (!visible)
+        return null;
+    return <GeoDebugPanel_1.GeoDebugPanel />;
+};
+exports.GeoDebugOverlay = GeoDebugOverlay;

package/lib/GeoDebugPanel.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface Props {
+    /** Refresh interval in ms. Default: 30000 */
+    pollInterval?: number;
+}
+export declare const GeoDebugPanel: React.FC<Props>;
+export {};