react-native-background-geolocation 5.5.0 → 5.6.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.5.0'
+  tslm_version = ENV['TSLOCATIONMANAGER_VERSION'] || '~> 4.6.0'
   s.dependency 'TSLocationManager', tslm_version
 
   s.libraries           = 'sqlite3', 'z', 'stdc++'

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

@@ -4,6 +4,8 @@ import com.transistorsoft.rnbackgroundgeolocation.NativeRNBackgroundGeolocationS
 
 import android.Manifest;
 import android.app.Activity;
+
+import androidx.annotation.Nullable;
 import android.content.Context;
 import android.content.Intent;
 import android.os.Build;
@@ -990,15 +992,27 @@ public class RNBackgroundGeolocationModule
     }
 
     @ReactMethod
-    public void requestPermission(final Promise response) {
-        getAdapter().requestPermission(new TSRequestPermissionCallback() {
+    public void requestPermission(@Nullable final String permission, final Promise response) {
+        TSRequestPermissionCallback callback = new TSRequestPermissionCallback() {
             @Override public void onSuccess(int status) {
                 response.resolve(status);
             }
             @Override public void onFailure(int status) {
-                response.reject("Permission request failed with status: " + status);
+                // The error code carries the bare AuthorizationStatus — the JavaScript
+                // layer normalizes the rejection to that value (cross-platform contract).
+                response.reject(String.valueOf(status), String.valueOf(status));
             }
-        });
+        };
+        // (WO-007) permission ∈ "location" | "motion" | null (null = everything).
+        // Null MUST route to the historical no-argument overload here in the bridge:
+        // the string overload's own null-guard exists only in tslocationmanager >=
+        // the WO-007 release — against an older AAR, handing it null would NPE inside
+        // the adapter and crash every legacy requestPermission() call.
+        if (permission == null) {
+            getAdapter().requestPermission(callback);
+        } else {
+            getAdapter().requestPermission(permission, callback);
+        }
     }
 
     @ReactMethod

package/ios/RNBackgroundGeolocation/RNBackgroundGeolocation.mm

@@ -658,12 +658,15 @@ RCT_EXPORT_METHOD(getProviderState:(RCTPromiseResolveBlock)resolve reject:(RCTPr
     resolve([event toDictionary]);
 }
 
-RCT_EXPORT_METHOD(requestPermission:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXPORT_METHOD(requestPermission:(NSString * _Nullable)permission resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
 {
-    [locationManager requestPermission:^(NSNumber *status) {
+    // (WO-007) permission ∈ @"location" | @"motion" | nil (nil = everything).
+    [locationManager requestPermission:permission success:^(NSNumber *status) {
         resolve(status);
     } failure:^(NSNumber *status) {
-        reject(@"request_permission_error", [status stringValue], nil);
+        // The error code carries the bare AuthorizationStatus — the JavaScript layer
+        // normalizes the rejection to that value (cross-platform contract).
+        reject([status stringValue], [status stringValue], nil);
     }];
 }
 

package/package.json

@@ -1,11 +1,10 @@
 {
-
-  "name": "react-native-background-geolocation",  
-  "version": "5.5.0",
+  "name": "react-native-background-geolocation",
+  "version": "5.6.0",
   "description": "The most sophisticated cross-platform background location-tracking & geofencing module with battery-conscious motion-detection intelligence",
   "scripts": {
     "build": "yarn run build:expo",
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "jest && tsc -p tests-types --noEmit",
     "build:expo": "rimraf expo/plugin/build && tsc --build ./expo/plugin",
     "docs": "node ./scripts/generate-docs.mjs",
     "docs:publish": "./scripts/publish-docs.sh",
@@ -21,7 +20,7 @@
     "ios": {
       "swiftModuleName": "RNBackgroundGeolocation",
       "packageName": "RNBackgroundGeolocation"
-    }    
+    }
   },
   "main": "src/index.js",
   "repository": {
@@ -41,7 +40,7 @@
   ],
   "dependencies": {
     "@babel/runtime": "^7.26.0",
-    "@transistorsoft/background-geolocation-types": "^5.2.2",
+    "@transistorsoft/background-geolocation-types": "^5.3.2",
     "tslib": "^2.6.3"
   },
   "author": "Chris Scott <chris@transistorsoft.com>",
@@ -51,10 +50,14 @@
   },
   "homepage": "https://www.transistorsoft.com/shop/products/react-native-background-geolocation",
   "devDependencies": {
+    "@babel/core": "^8.0.1",
+    "@babel/preset-env": "^8.0.2",
     "@expo/config-plugins": "^4.1.0",
     "@types/node": "^18.11.5",
+    "babel-jest": "^30.5.0",
     "chalk": "^4.1.0",
     "fs-extra": "^9.1.0",
+    "jest": "^30.5.0",
     "path": "^0.12.7",
     "rimraf": "^5.0.0",
     "typescript": "^5.6.0"

package/src/NativeModule.js

@@ -170,8 +170,11 @@ export default class NativeModule {
     return RNBackgroundGeolocation.configure(validateConfig(config));    
   }
 
-  static requestPermission() {
-    return RNBackgroundGeolocation.requestPermission();
+  static requestPermission(permission) {
+    // (WO-007) permission ∈ 'location' | 'motion' | null (null = everything, the
+    // historical behaviour).  Always pass the argument explicitly — both the
+    // TurboModule spec and the old-architecture bridge expect it.
+    return RNBackgroundGeolocation.requestPermission((typeof permission === 'string') ? permission : null);
   }
 
   static requestTemporaryFullAccuracy(purpose) {

package/src/index.js

@@ -24,9 +24,47 @@ import {
   HttpMethod,
   TriggerActivity,
   ActivityType,
-  Event
+  Event,
+  Permission,
+  MotionActivityType,
+  TrackingMode,
+  LogLevelName,
+  GeofenceAction,
+  LocationError,
+  LocationFilterReason,
+  SQLQueryOrder
 } from '@transistorsoft/background-geolocation-types';
 
+// (WO-007) Named RUNTIME exports — every const-enum value the shared types package
+// exports.  index.d.ts has always re-exported the types package, but these objects
+// only existed (partially) as statics on the default export — named value imports
+// like `import { AuthorizationStatus }` were undefined at runtime.  The jest parity
+// test asserts this list stays complete against the installed types package.
+export {
+  LogLevel,
+  DesiredAccuracy,
+  PersistMode,
+  AuthorizationStatus,
+  AccuracyAuthorization,
+  LocationRequest,
+  AuthorizationStrategy,
+  LocationFilterPolicy,
+  KalmanProfile,
+  NotificationPriority,
+  HttpMethod,
+  TriggerActivity,
+  ActivityType,
+  Event,
+  Permission,
+  MotionActivityType,
+  TrackingMode,
+  LogLevelName,
+  GeofenceAction,
+  LocationError,
+  LocationFilterReason,
+  SQLQueryOrder
+};
+
 // Build a lookup table of allowed event names (runtime)
 const VALID_EVENT_NAMES = new Set(Object.values(Event));
 
@@ -160,6 +198,10 @@ export default class BackgroundGeolocation {
     return AuthorizationStatus;
   }
 
+  static get Permission() {
+    return Permission;
+  }
+
   static get AccuracyAuthorization() {
     return AccuracyAuthorization;
   }
@@ -226,8 +268,13 @@ export default class BackgroundGeolocation {
     return NativeModule.configure(config);
   }
 
-  static requestPermission() {
-    return NativeModule.requestPermission();
+  static requestPermission(permission) {
+    return NativeModule.requestPermission(permission).catch((error) => {
+      // (WO-007) Cross-platform contract: reject with the bare AuthorizationStatus
+      // value (the natives carry it in the error code).
+      const status = parseInt(error.code, 10);
+      return Promise.reject(Number.isNaN(status) ? error : status);
+    });
   }
 
   static requestTemporaryFullAccuracy(purpose) {

package/src/native/specs/NativeBackgroundGeolocation.ts

@@ -31,7 +31,7 @@ export interface Spec extends TurboModule {
   getDeviceInfo(): Promise<Object>;
   isPowerSaveMode(): Promise<boolean>;
   isIgnoringBatteryOptimizations(): Promise<boolean>;
-  requestPermission(): Promise<number>;
+  requestPermission(permission: string | null): Promise<number>;
   requestTemporaryFullAccuracy(purpose: string): Promise<number>;
 
   // Transistor token helpers

package/src/specs/NativeRNBackgroundGeolocation.js

@@ -90,7 +90,7 @@ export interface Spec extends TurboModule {
   +showSettings: (args: Object) => Promise<boolean>;
 
   +getProviderState: () => Promise<Object>;
-  +requestPermission: () => Promise<Int32>;
+  +requestPermission: (permission: ?string) => Promise<Int32>;
   +requestTemporaryFullAccuracy: (purpose: string) => Promise<Int32>;
 
   // Required by NativeEventEmitter

package/tests/request-permission.test.js

@@ -0,0 +1,78 @@
+// (WO-007) JS-side marshaling for the per-permission requestPermission API: does the
+// JavaScript layer forward the Permission selector to the native bridge boundary, and
+// normalize native rejections to the bare AuthorizationStatus value the cross-platform
+// contract documents?  The native module is a jest spy standing in for the bridge.
+
+const { NativeModules } = require('react-native'); // mapped to mocks/react-native.js via jest config
+const BG = require('../src/index.js').default;
+const { Permission, AuthorizationStatus } = require('../src/index.js');
+
+const native = NativeModules.RNBackgroundGeolocation;
+
+describe('named runtime exports (WO-007 regression)', () => {
+  // index.d.ts has always promised `export *` of the shared types package, but the
+  // runtime module exported only the default class — named VALUE imports were
+  // silently undefined (field: "Cannot read property 'Location' of undefined").
+  test('Permission and AuthorizationStatus are real values, importable by name', () => {
+    expect(Permission).toBeDefined();
+    expect(Permission.Location).toBe('location');
+    expect(Permission.Motion).toBe('motion');
+    expect(AuthorizationStatus).toBeDefined();
+    expect(AuthorizationStatus.DeniedAlways).toBe(5);
+    // The class statics remain, unchanged.
+    expect(BG.Permission).toBe(Permission);
+    expect(BG.AuthorizationStatus).toBe(AuthorizationStatus);
+  });
+
+  // Drift-proof: EVERY runtime value the types package exports must be re-exported
+  // by name from this module — a hardcoded list rots (the first fix missed 7 of 22).
+  test('every types-package runtime export is re-exported by name', () => {
+    const typesPkg = require('@transistorsoft/background-geolocation-types');
+    const sdk = require('../src/index.js');
+    const runtimeKeys = Object.keys(typesPkg).filter((k) => k !== 'default' && k !== '__esModule');
+    expect(runtimeKeys.length).toBeGreaterThan(0);
+    for (const key of runtimeKeys) {
+      expect(sdk[key]).toBe(typesPkg[key]);
+    }
+  });
+});
+
+describe('requestPermission — JS -> native bridge marshaling (WO-007)', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test('forwards the permission selector to the native module', async () => {
+    const request = jest.spyOn(native, 'requestPermission').mockResolvedValue(3);
+
+    await expect(BG.requestPermission('location')).resolves.toBe(3);
+    expect(request).toHaveBeenLastCalledWith('location');
+
+    await expect(BG.requestPermission('motion')).resolves.toBe(3);
+    expect(request).toHaveBeenLastCalledWith('motion');
+  });
+
+  test('the no-argument form passes an explicit null (both bridge architectures expect the slot)', async () => {
+    const request = jest.spyOn(native, 'requestPermission').mockResolvedValue(4);
+
+    await expect(BG.requestPermission()).resolves.toBe(4);
+    expect(request).toHaveBeenLastCalledWith(null);
+  });
+
+  test('normalizes a native rejection to the bare AuthorizationStatus carried in the error code', async () => {
+    // Both natives reject with code = String(status).
+    const error = new Error('5');
+    error.code = '5';
+    jest.spyOn(native, 'requestPermission').mockRejectedValue(error);
+
+    await expect(BG.requestPermission('motion')).rejects.toBe(5); // DeniedAlways
+  });
+
+  test('passes an unparseable native error through unchanged', async () => {
+    const error = new Error('bridge exploded');
+    error.code = 'E_UNEXPECTED';
+    jest.spyOn(native, 'requestPermission').mockRejectedValue(error);
+
+    await expect(BG.requestPermission()).rejects.toBe(error);
+  });
+});

package/tests-types/api-surface.ts

@@ -0,0 +1,33 @@
+// Type-surface assertions — compile-only, no runtime.  (WO-007)
+//
+// Verifies the per-permission requestPermission API against the published
+// @transistorsoft/background-geolocation-types surface this package re-exports.
+import BackgroundGeolocation, {
+  Permission,
+  AuthorizationStatus,
+} from "react-native-background-geolocation";
+
+async function requestPermissionSurface(): Promise<void> {
+  // A-form: no argument — everything the configuration requires.
+  const all: AuthorizationStatus = await BackgroundGeolocation.requestPermission();
+
+  // B-form: location only.
+  const location: AuthorizationStatus =
+    await BackgroundGeolocation.requestPermission(Permission.Location);
+
+  // C-form: motion only; DeniedAlways is the Android permanent-denial status.
+  try {
+    const motion: AuthorizationStatus =
+      await BackgroundGeolocation.requestPermission(Permission.Motion);
+    void motion;
+  } catch (status) {
+    if (status === AuthorizationStatus.DeniedAlways) {
+      // Only the app-settings screen can restore the motion permission now.
+    }
+  }
+
+  void all;
+  void location;
+}
+
+void requestPermissionSurface;