react-native-background-geolocation 5.2.0 → 5.4.0

package/RNBackgroundGeolocation.podspec

@@ -26,7 +26,7 @@ Pod::Spec.new do |s|
   s.source_files        = 'ios/RNBackgroundGeolocation/*.{h,m,mm}'
   s.preserve_paths      = 'docs', 'CHANGELOG.md', 'LICENSE', 'package.json', 'RNBackgroundGeolocation.ios.js'
 
-  tslm_version = ENV['TSLOCATIONMANAGER_VERSION'] || '~> 4.2.0'
+  tslm_version = ENV['TSLOCATIONMANAGER_VERSION'] || '~> 4.4.0'
   s.dependency 'TSLocationManager', tslm_version
 
   s.libraries           = 'sqlite3', 'z', 'stdc++'

package/android/build.gradle

@@ -9,7 +9,7 @@ def DEFAULT_TARGET_SDK_VERSION                      = 35
 
 // Plugin dependencies
 def DEFAULT_PLAY_SERVICES_LOCATION_VERSION          = "21.3.0"
-def DEFAULT_TSLOCATIONMANAGER_VERSION               = "4.2.+"
+def DEFAULT_TSLOCATIONMANAGER_VERSION               = "4.4.+"
 def DEFAULT_OK_HTTP_VERSION                         = "4.12.0"
 def DEFAULT_ANDROID_PERMISSIONS_VERSION             = "2.1.6"
 def DEFAULT_EVENTBUS_VERSION                        = "3.3.1"
@@ -25,6 +25,38 @@ def safeExtGet(prop, fallback) {
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
 }
 
+// Guards against the missing-symbol crash that occurs when an app pins an `ext.tslocationmanagerVersion`
+// older than the SDK this plugin's bridge adapter was built against. Returns `minVersion` (with a
+// warning) when the pinned version's entire range is below it; otherwise returns the pin unchanged.
+// Dynamic pins are handled by comparing the pin's ceiling to the minimum's floor, so "4.2.+" is
+// overridden while "4.+"/"+" are respected. Drop-in identical across the four plugin SDKs.
+def ensureTSLocationManagerVersion(String configured, String minVersion) {
+    def parse = { String v, boolean asCeiling ->
+        def parts = (v ?: "").trim().tokenize(".")
+        def out = [0, 0, 0]
+        boolean wild = false
+        for (int i = 0; i < 3; i++) {
+            if (wild) { out[i] = asCeiling ? Integer.MAX_VALUE : 0; continue }
+            def p = (i < parts.size()) ? parts[i] : null
+            if (p != null && p.isInteger()) {
+                out[i] = p as int
+            } else if (p != null) {          // "+" wildcard or qualifier
+                wild = true
+                out[i] = asCeiling ? Integer.MAX_VALUE : 0
+            }                                // missing trailing component stays 0
+        }
+        return out
+    }
+    def c = parse(configured, true)          // ceiling of the app's pin
+    def f = parse(minVersion, false)         // floor of the required minimum
+    def cmp = (c[0] <=> f[0]) ?: (c[1] <=> f[1]) ?: (c[2] <=> f[2])
+    if (cmp < 0) {
+        println("[tslocationmanager] ⚠️  ext.tslocationmanagerVersion '${configured}' is older than the '${minVersion}' required by this plugin release and has been overridden to '${minVersion}'. The native bridge adapter references symbols added in '${minVersion}'; an older SDK causes missing-symbol build failures / runtime crashes. Update or remove ext.tslocationmanagerVersion in your root build.gradle to silence this warning.")
+        return minVersion
+    }
+    return configured
+}
+
 react {
     libraryName = "react-native-background-geolocation"
     codegenJavaPackageName = "com.transistorsoft.rnbackgroundgeolocation"
@@ -51,6 +83,11 @@ android {
             java.srcDir("$buildDir/generated/source/codegen/java")
         }
     }
+    testOptions {
+        unitTests {
+            includeAndroidResources = true
+        }
+    }
 }
 
 repositories{
@@ -61,7 +98,7 @@ repositories{
 
 dependencies {
     def playServicesLocationVersion = safeExtGet('playServicesLocationVersion', safeExtGet('googlePlayServicesLocationVersion', DEFAULT_PLAY_SERVICES_LOCATION_VERSION))
-    def tslocationmanagerVersion = safeExtGet('tslocationmanagerVersion', DEFAULT_TSLOCATIONMANAGER_VERSION)
+    def tslocationmanagerVersion = ensureTSLocationManagerVersion(safeExtGet('tslocationmanagerVersion', DEFAULT_TSLOCATIONMANAGER_VERSION), DEFAULT_TSLOCATIONMANAGER_VERSION)
     implementation "com.facebook.react:react-native:${safeExtGet('reactNativeVersion', '+')}"
 
     def locationMajorVersion = playServicesLocationVersion.split('\\.')[0] as int
@@ -71,6 +108,10 @@ dependencies {
         api "com.transistorsoft:tslocationmanager-gms20:$tslocationmanagerVersion"
     }
         
-    implementation "com.google.android.gms:play-services-location:$playServicesLocationVersion"    
+    implementation "com.google.android.gms:play-services-location:$playServicesLocationVersion"
     implementation 'org.greenrobot:eventbus:3.3.1'
+
+    // Bridge-translation unit tests (JVM/Robolectric) — not shipped to consumers.
+    testImplementation "junit:junit:4.13.2"
+    testImplementation "org.robolectric:robolectric:4.14.1"
 }

package/android/src/main/java/com/transistorsoft/rnbackgroundgeolocation/RNBackgroundGeolocationModule.java

@@ -43,6 +43,7 @@ import com.transistorsoft.locationmanager.adapter.BackgroundGeolocation;
 import com.transistorsoft.locationmanager.adapter.callback.*;
 
 import com.transistorsoft.locationmanager.data.LocationModel;
+import com.transistorsoft.locationmanager.data.LocationQuery;
 
 import com.transistorsoft.locationmanager.data.SQLQuery;
 import com.transistorsoft.locationmanager.device.DeviceInfo;
@@ -489,8 +490,9 @@ public class RNBackgroundGeolocationModule
     }
 
     @ReactMethod
-    public void getLocations(final Promise response) {
-        getAdapter().getLocations(new TSGetLocationsCallback() {
+    public void getLocations(ReadableMap params, final Promise response) {
+        LocationQuery query = LocationQuery.fromMap(params != null ? params.toHashMap() : null);
+        getAdapter().getLocations(query, new TSGetLocationsCallback() {
             @Override public void onSuccess(List<LocationModel> records) {
                 try {
                     JSONArray data = new JSONArray();
@@ -519,7 +521,7 @@ public class RNBackgroundGeolocationModule
                 response.resolve(uuid);
             }
             @Override public void onFailure(String error) {
-                response.reject(error);
+                response.reject("insert_location_error", error);
             }
         });
     }

package/android/src/test/java/com/transistorsoft/rnbackgroundgeolocation/RNBackgroundGeolocationModuleTest.java

@@ -0,0 +1,70 @@
+package com.transistorsoft.rnbackgroundgeolocation;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.facebook.react.bridge.JavaOnlyMap;
+
+import org.json.JSONObject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+/**
+ * Bridge-translation tests for the React Native Android module — the JS→native marshaling seam.
+ *
+ * These run on the JVM (Robolectric only for a real {@code org.json} implementation) with no device
+ * and no SDK: they exercise the exact {@code ReadableMap → org.json.JSONObject} conversion the real
+ * {@code insertLocation} path hands to the native SDK. This is the layer where the bridge-audit
+ * findings live (a numeric timestamp must stay a number; nested {@code coords}/{@code extras} must
+ * survive), and it is un-catchable by either a JS-only Jest test (mocked native) or a native SDK
+ * test (no bridge).
+ *
+ * The complementary half — the native {@code onSuccess(uuid) → promise.resolve(uuid)} settlement —
+ * is trivial glue that needs a live React runtime (RN 0.81's {@code ReactApplicationContext} is
+ * abstract and the module constructor initialises the SDK), so it belongs to the on-device E2E
+ * layer rather than a JVM unit test.
+ */
+@RunWith(RobolectricTestRunner.class)
+@Config(sdk = 34)
+public class RNBackgroundGeolocationModuleTest {
+
+    /** A bridge-shaped insertLocation params map: {coords:{lat,lng}, timestamp, extras:{...}}. */
+    private JavaOnlyMap makeInsertParams(double timestampMillis) {
+        JavaOnlyMap coords = new JavaOnlyMap();
+        coords.putDouble("latitude", 45.5152);
+        coords.putDouble("longitude", -73.6104);
+
+        JavaOnlyMap extras = new JavaOnlyMap();
+        extras.putString("source", "import");
+
+        JavaOnlyMap params = new JavaOnlyMap();
+        params.putMap("coords", coords);
+        params.putDouble("timestamp", timestampMillis);
+        params.putMap("extras", extras);
+        return params;
+    }
+
+    @Test
+    public void mapToJson_preservesNestedCoordsAndExtras() throws Exception {
+        JSONObject json = RNBackgroundGeolocationModule.mapToJson(makeInsertParams(1_705_314_600_000d));
+
+        assertTrue("coords must survive as a nested object", json.has("coords"));
+        assertEquals(45.5152, json.getJSONObject("coords").getDouble("latitude"), 0.0);
+        assertEquals(-73.6104, json.getJSONObject("coords").getDouble("longitude"), 0.0);
+        assertEquals("import", json.getJSONObject("extras").getString("source"));
+    }
+
+    @Test
+    public void mapToJson_keepsNumericTimestampAsNumber_notString() throws Exception {
+        // Audit finding: a numeric epoch timestamp must reach the SDK as a NUMBER, so the SDK's
+        // epoch branch (TSLocation.normalizeTimestamp `raw instanceof Number`) fires — never a String.
+        JSONObject json = RNBackgroundGeolocationModule.mapToJson(makeInsertParams(1_705_314_600_000d));
+
+        Object ts = json.get("timestamp");
+        assertTrue("timestamp must be a JSON number, not a String (got " + ts.getClass().getSimpleName() + ")",
+                ts instanceof Number);
+        assertEquals(1_705_314_600_000L, ((Number) ts).longValue());
+    }
+}

package/ios/RNBackgroundGeolocation/RNBackgroundGeolocation.mm

@@ -389,9 +389,10 @@ RCT_EXPORT_METHOD(stopWatchPosition:(NSInteger)watchId resolve:(RCTPromiseResolv
     resolve(@(YES));
 }
 
-RCT_EXPORT_METHOD(getLocations:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXPORT_METHOD(getLocations:(NSDictionary*)params resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
 {
-    [locationManager getLocations:^(NSArray* records) {
+    LocationQuery *query = [[LocationQuery alloc] initWithDictionary:params];
+    [locationManager getLocations:query success:^(NSArray* records) {
         resolve(records);
     } failure:^(NSString* error) {
         reject(@"get_locations_error", error, nil);

package/mocks/react-native.js

@@ -9,38 +9,41 @@ class NativeEventEmitter {
   removeAllListeners() { listeners.clear(); }
 }
 
+// The native module is a TurboModule: every data method returns a Promise (not the pre-migration
+// callback convention). NativeModule.js returns these calls directly, so the mocks must resolve a
+// Promise. `log`/`playSound` are fire-and-forget (void).
 const RNBackgroundGeolocation = {
   // Minimal surface your JS calls in tests:
-  ready: (cfg, ok) => ok?.({ enabled: false }),
-  configure: (cfg, ok) => ok?.({}),
-  setConfig: (cfg, ok) => ok?.({}),
-  reset: (cfg, ok) => ok?.({ enabled: false }),
-  getState: (ok) => ok?.({ enabled: false }),
-  beginBackgroundTask: (ok) => ok?.(1),
-  finish: (id, ok) => ok?.(id),
-  addGeofence: (_cfg, ok) => ok?.(),
-  addGeofences: (_list, ok) => ok?.(),
-  removeGeofence: (_id, ok) => ok?.(),
-  removeGeofences: (ok) => ok?.(),
-  getGeofences: (ok) => ok?.([]),
-  getGeofence: (_id, ok) => ok?.(null),
-  geofenceExists: (_id, cb) => cb(false),
-  changePace: (_b, ok) => ok?.(),
-  getLog: (ok) => ok?.(''),
-  destroyLog: (ok) => ok?.(),
-  emailLog: (_email, ok) => ok?.(),
-  getOdometer: (ok) => ok?.(0),
-  setOdometer: (_v, ok) => ok?.({}),
-  getLocations: (ok) => ok?.([]),
-  getCount: (ok) => ok?.(0),
-  destroyLocations: (ok) => ok?.(),
-  insertLocation: (_p, ok) => ok?.({}),
-  sync: (ok) => ok?.({ success: true }),
-  getProviderState: (ok) => ok?.({ enabled: true }),
-  requestPermission: (ok) => ok?.(1),
-  requestTemporaryFullAccuracy: (_p, ok) => ok?.(1),
+  ready: () => Promise.resolve({ enabled: false }),
+  configure: () => Promise.resolve({}),
+  setConfig: () => Promise.resolve({}),
+  reset: () => Promise.resolve({ enabled: false }),
+  getState: () => Promise.resolve({ enabled: false }),
+  beginBackgroundTask: () => Promise.resolve(1),
+  finish: (id) => Promise.resolve(id),
+  addGeofence: () => Promise.resolve(),
+  addGeofences: () => Promise.resolve(),
+  removeGeofence: () => Promise.resolve(),
+  removeGeofences: () => Promise.resolve(),
+  getGeofences: () => Promise.resolve([]),
+  getGeofence: () => Promise.resolve(null),
+  geofenceExists: () => Promise.resolve(false),
+  changePace: () => Promise.resolve(),
+  getLog: () => Promise.resolve(''),
+  destroyLog: () => Promise.resolve(),
+  emailLog: () => Promise.resolve(),
+  getOdometer: () => Promise.resolve(0),
+  setOdometer: () => Promise.resolve({}),
+  getLocations: () => Promise.resolve([]),
+  getCount: () => Promise.resolve(0),
+  destroyLocations: () => Promise.resolve(),
+  insertLocation: () => Promise.resolve('00000000-0000-0000-0000-000000000000'),
+  sync: () => Promise.resolve({ success: true }),
+  getProviderState: () => Promise.resolve({ enabled: true }),
+  requestPermission: () => Promise.resolve(1),
+  requestTemporaryFullAccuracy: () => Promise.resolve(1),
   log: () => {},
-  getDeviceInfo: (ok) => ok?.({ model: 'mock' }),
+  getDeviceInfo: () => Promise.resolve({ model: 'mock' }),
   playSound: () => {},
 };
 

package/package.json

@@ -1,7 +1,7 @@
 {
 
   "name": "react-native-background-geolocation",  
-  "version": "5.2.0",
+  "version": "5.4.0",
   "description": "The most sophisticated cross-platform background location-tracking & geofencing module with battery-conscious motion-detection intelligence",
   "scripts": {
     "build": "yarn run build:expo",
@@ -41,7 +41,7 @@
   ],
   "dependencies": {
     "@babel/runtime": "^7.26.0",
-    "@transistorsoft/background-geolocation-types": "^5.2.0",
+    "@transistorsoft/background-geolocation-types": "^5.2.2",
     "tslib": "^2.6.3"
   },
   "author": "Chris Scott <chris@transistorsoft.com>",

package/src/NativeModule.js

@@ -330,8 +330,8 @@ export default class NativeModule {
   * HTTP & Persistence Methods
   */
 
-  static getLocations() {    
-    return RNBackgroundGeolocation.getLocations();    
+  static getLocations(query) {
+    return RNBackgroundGeolocation.getLocations(query || {});
   }
 
   static getCount() {

package/src/index.js

@@ -439,8 +439,8 @@ export default class BackgroundGeolocation {
   * HTTP & Persistence
   *
   */
-  static getLocations() {
-    return NativeModule.getLocations();
+  static getLocations(query) {
+    return NativeModule.getLocations(query);
   }
 
   /**

package/src/native/specs/NativeBackgroundGeolocation.ts

@@ -21,7 +21,7 @@ export interface Spec extends TurboModule {
   setOdometer(value: number): Promise<Object>;
 
   // HTTP & DB
-  getLocations(): Promise<Array<Object>>;
+  getLocations(query: Object): Promise<Array<Object>>;
   getCount(): Promise<number>;
   destroyLocations(): Promise<void>;
   sync(): Promise<Array<Object>>;

package/src/specs/NativeRNBackgroundGeolocation.js

@@ -28,7 +28,7 @@ export interface Spec extends TurboModule {
   +getState: () => Promise<Object>;
 
   // Locations / persistence
-  +getLocations: () => Promise<Array<Object>>;
+  +getLocations: (query: Object) => Promise<Array<Object>>;
   +getCount: () => Promise<Int32>;
   +insertLocation: (params: Object) => Promise<string>;
 

package/tests/insert-location.test.js

@@ -0,0 +1,51 @@
+// JS-side marshaling test for insertLocation: does the JavaScript API layer forward the caller's
+// location to the native bridge boundary *unchanged*, and pass the returned uuid back — with no
+// real SDK and no device? The native module is a jest spy standing in for the bridge; we assert on
+// what it receives (the args that crossed JS -> native) and what the caller ultimately gets back.
+//
+// This is the JS half of the two-halves bridge-marshaling strategy. The native half (ReadableMap ->
+// JSONObject) is covered by the Android Robolectric test `RNBackgroundGeolocationModuleTest`.
+
+const { NativeModules } = require('react-native'); // mapped to mocks/react-native.js via jest config
+const BG = require('../src/index.js').default;
+
+const native = NativeModules.RNBackgroundGeolocation;
+
+describe('insertLocation — JS -> native bridge marshaling', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test('forwards the location to the native module unchanged and resolves its uuid', async () => {
+    const insert = jest.spyOn(native, 'insertLocation').mockResolvedValue('uuid-abc');
+
+    const location = {
+      coords: { latitude: 45.5152, longitude: -73.6104 },
+      timestamp: 1705314600000, // numeric epoch
+      extras: { source: 'import' },
+    };
+
+    const uuid = await BG.insertLocation(location);
+
+    // The exact object reaches the native boundary — no mangling by index.js / NativeModule.
+    expect(insert).toHaveBeenCalledTimes(1);
+    expect(insert).toHaveBeenCalledWith(location);
+
+    // Type/shape preserved across the JS layers: numeric timestamp stays a number, coords/extras nested.
+    const [passed] = insert.mock.calls[0];
+    expect(typeof passed.timestamp).toBe('number');
+    expect(passed.coords).toEqual({ latitude: 45.5152, longitude: -73.6104 });
+    expect(passed.extras).toEqual({ source: 'import' });
+
+    // The uuid string flows back out through NativeModule + index.js.
+    expect(uuid).toBe('uuid-abc');
+  });
+
+  test('propagates a native rejection to the caller', async () => {
+    jest.spyOn(native, 'insertLocation').mockRejectedValue(new Error('insert_location_error'));
+
+    await expect(
+      BG.insertLocation({ coords: { latitude: 0, longitude: 0 }, timestamp: 0 })
+    ).rejects.toThrow('insert_location_error');
+  });
+});