react-native-nitro-geolocation 1.1.1 → 1.1.3

package/android/src/main/java/com/margelo/nitro/nitrogeolocation/NitroGeolocation.kt

@@ -29,6 +29,11 @@ private class GeolocationErrorException(
     val locationError: LocationError
 ) : Exception(locationError.message)
 
+private const val NO_LOCATION_PROVIDER_AVAILABLE_MESSAGE = "No location provider available"
+private const val NO_APPROXIMATE_LOCATION_PROVIDER_AVAILABLE_MESSAGE =
+    "No location provider is available for approximate location. " +
+        "ACCESS_COARSE_LOCATION is granted, but no enabled coarse-compatible provider is available."
+
 /**
  * Modern Geolocation implementation for Android.
  *
@@ -85,8 +90,15 @@ class NitroGeolocation(
         val resolver: (Result<GeolocationResponse>) -> Unit,
         val options: ParsedOptions,
         val handler: Handler,
+        val providers: List<String>,
+        val deadlineElapsedRealtime: Long,
+        var providerIndex: Int = 0,
         var cancellationSignal: CancellationSignal? = null
-    )
+    ) {
+        fun remainingTimeoutMillis(): Long {
+            return (deadlineElapsedRealtime - SystemClock.elapsedRealtime()).coerceAtLeast(0L)
+        }
+    }
 
     // MARK: - Properties
 
@@ -184,39 +196,20 @@ class NitroGeolocation(
 
         val parsedOptions = ParsedOptions.parse(options)
 
-        // Check cached location
-        val provider = getValidProvider(parsedOptions.enableHighAccuracy)
-        if (provider != null) {
-            val lastKnownLocation = try {
-                locationManager.getLastKnownLocation(provider)
-            } catch (e: SecurityException) {
-                null
-            }
-
-            if (lastKnownLocation != null && isCachedLocationValid(lastKnownLocation, parsedOptions)) {
-                val position = locationToPosition(lastKnownLocation)
-                promise.resolve(position)
-                return promise
-            }
-
-            // maximumAge is Infinity -> use cached if available
-            if (lastKnownLocation != null && parsedOptions.maximumAge == Double.POSITIVE_INFINITY) {
-                val position = locationToPosition(lastKnownLocation)
-                promise.resolve(position)
-                return promise
-            }
+        val providers = getValidProviders(parsedOptions.enableHighAccuracy)
+        if (providers.isEmpty()) {
+            promise.reject(createNoLocationProviderError(parsedOptions))
+            return promise
         }
 
-        // Request fresh location
-        if (provider == null) {
-            promise.reject(createLocationError(
-                POSITION_UNAVAILABLE,
-                "No location provider available"
-            ))
+        val cachedLocation = getBestCachedLocation(providers, parsedOptions)
+        if (cachedLocation != null) {
+            promise.resolve(locationToPosition(cachedLocation))
             return promise
         }
 
-        requestFreshLocation(provider, parsedOptions) { result ->
+        // Request fresh location
+        requestFreshLocation(providers, parsedOptions) { result ->
             result.fold(
                 onSuccess = { promise.resolve(it) },
                 onFailure = { promise.reject(it) }
@@ -299,6 +292,20 @@ class NitroGeolocation(
         return getCurrentPermissionStatus() == PermissionStatus.GRANTED
     }
 
+    private fun hasFineLocationPermission(): Boolean {
+        return ContextCompat.checkSelfPermission(
+            reactContext,
+            Manifest.permission.ACCESS_FINE_LOCATION
+        ) == PackageManager.PERMISSION_GRANTED
+    }
+
+    private fun hasCoarseLocationPermission(): Boolean {
+        return ContextCompat.checkSelfPermission(
+            reactContext,
+            Manifest.permission.ACCESS_COARSE_LOCATION
+        ) == PackageManager.PERMISSION_GRANTED
+    }
+
     // Handle permission request result (called from Activity)
     fun onPermissionResult(requestCode: Int, grantResults: IntArray) {
         if (requestCode != PERMISSION_REQUEST_CODE) return
@@ -316,6 +323,10 @@ class NitroGeolocation(
     // MARK: - Helper Functions - Provider Selection
 
     private fun getValidProvider(highAccuracy: Boolean): String? {
+        return getValidProviders(highAccuracy).firstOrNull()
+    }
+
+    private fun getValidProviders(highAccuracy: Boolean): List<String> {
         val preferredProvider = if (highAccuracy)
             AndroidLocationManager.GPS_PROVIDER
         else
@@ -326,21 +337,44 @@ class NitroGeolocation(
         else
             AndroidLocationManager.GPS_PROVIDER
 
-        return when {
-            isProviderValid(preferredProvider) -> preferredProvider
-            isProviderValid(fallbackProvider) -> fallbackProvider
-            else -> null
-        }
+        return listOf(preferredProvider, fallbackProvider)
+            .distinct()
+            .filter { provider -> isProviderValid(provider) }
     }
 
     private fun isProviderValid(provider: String): Boolean {
         return try {
-            locationManager.isProviderEnabled(provider)
+            if (!locationManager.isProviderEnabled(provider)) return false
+
+            when (provider) {
+                AndroidLocationManager.GPS_PROVIDER -> hasFineLocationPermission()
+                AndroidLocationManager.NETWORK_PROVIDER -> hasCoarseLocationPermission() || hasFineLocationPermission()
+                else -> hasLocationPermission()
+            }
         } catch (e: Exception) {
             false
         }
     }
 
+    private fun createNoLocationProviderError(options: ParsedOptions): Exception {
+        return createLocationError(
+            POSITION_UNAVAILABLE,
+            getNoLocationProviderMessage(options)
+        )
+    }
+
+    private fun getNoLocationProviderMessage(options: ParsedOptions): String {
+        if (
+            !options.enableHighAccuracy &&
+            hasCoarseLocationPermission() &&
+            !hasFineLocationPermission()
+        ) {
+            return NO_APPROXIMATE_LOCATION_PROVIDER_AVAILABLE_MESSAGE
+        }
+
+        return NO_LOCATION_PROVIDER_AVAILABLE_MESSAGE
+    }
+
     // MARK: - Helper Functions - Cache Validation
 
     private fun isCachedLocationValid(location: Location, options: ParsedOptions): Boolean {
@@ -348,10 +382,32 @@ class NitroGeolocation(
         return locationAge < options.maximumAge
     }
 
+    private fun getBestCachedLocation(providers: List<String>, options: ParsedOptions): Location? {
+        var bestLocation: Location? = null
+
+        for (provider in providers) {
+            val lastKnownLocation = try {
+                locationManager.getLastKnownLocation(provider)
+            } catch (e: SecurityException) {
+                null
+            }
+
+            if (
+                lastKnownLocation != null &&
+                (isCachedLocationValid(lastKnownLocation, options) ||
+                    options.maximumAge == Double.POSITIVE_INFINITY)
+            ) {
+                bestLocation = selectBestLocation(lastKnownLocation, bestLocation)
+            }
+        }
+
+        return bestLocation
+    }
+
     // MARK: - Helper Functions - Request Fresh Location
 
     private fun requestFreshLocation(
-        provider: String,
+        providers: List<String>,
         options: ParsedOptions,
         resolver: (Result<GeolocationResponse>) -> Unit
     ) {
@@ -362,25 +418,48 @@ class NitroGeolocation(
             id = id,
             resolver = resolver,
             options = options,
-            handler = handler
+            handler = handler,
+            providers = providers,
+            deadlineElapsedRealtime = createRequestDeadlineElapsedRealtime(options.timeout)
         )
 
         pendingPositionRequests[id] = request
+        requestFreshLocationForCurrentProvider(id)
+    }
+
+    private fun requestFreshLocationForCurrentProvider(requestId: UUID) {
+        val request = pendingPositionRequests[requestId] ?: return
+        val provider = request.providers.getOrNull(request.providerIndex)
+        val remainingTimeoutMillis = request.remainingTimeoutMillis()
+
+        if (provider == null) {
+            pendingPositionRequests.remove(requestId)?.resolver(Result.failure(
+                createNoLocationProviderError(request.options)
+            ))
+            return
+        }
+
+        if (remainingTimeoutMillis <= 0L) {
+            pendingPositionRequests.remove(requestId)?.resolver(Result.failure(
+                createPositionTimeoutError(request.options)
+            ))
+            return
+        }
 
         // Use modern API on Android 11+
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-            requestCurrentLocationModern(provider, options, id, handler)
+            requestCurrentLocationModern(provider, requestId, request.handler, remainingTimeoutMillis)
         } else {
-            requestCurrentLocationLegacy(provider, options, id, handler)
+            requestCurrentLocationLegacy(provider, requestId, request.handler, remainingTimeoutMillis)
         }
     }
 
     @androidx.annotation.RequiresApi(Build.VERSION_CODES.R)
     private fun requestCurrentLocationModern(
         provider: String,
-        options: ParsedOptions,
         requestId: UUID,
-        handler: Handler
+        handler: Handler,
+        timeoutMillis: Long
     ) {
         val cancellationSignal = CancellationSignal()
 
@@ -397,39 +476,39 @@ class NitroGeolocation(
             ) { location ->
                 handler.removeCallbacks(timeoutRunnable)
 
-                val request = pendingPositionRequests.remove(requestId)
+                val request = pendingPositionRequests[requestId]
                 if (request != null) {
                     if (location != null) {
+                        pendingPositionRequests.remove(requestId)
                         val position = locationToPosition(location)
                         request.resolver(Result.success(position))
                     } else {
-                        request.resolver(Result.failure(createLocationError(
+                        handleProviderFailure(requestId, createLocationError(
                             POSITION_UNAVAILABLE,
                             "Unable to get location"
-                        )))
+                        ))
                     }
                 }
             }
 
-            handler.postDelayed(timeoutRunnable, options.timeout.toLong())
+            handler.postDelayed(timeoutRunnable, timeoutMillis)
 
             pendingPositionRequests[requestId]?.cancellationSignal = cancellationSignal
 
         } catch (e: SecurityException) {
-            pendingPositionRequests.remove(requestId)
-            val request = pendingPositionRequests[requestId]
-            request?.resolver(Result.failure(createLocationError(
+            handler.removeCallbacks(timeoutRunnable)
+            handleProviderFailure(requestId, createLocationError(
                 PERMISSION_DENIED,
                 "Security exception: ${e.message}"
-            )))
+            ))
         }
     }
 
     private fun requestCurrentLocationLegacy(
         provider: String,
-        options: ParsedOptions,
         requestId: UUID,
-        handler: Handler
+        handler: Handler,
+        timeoutMillis: Long
     ) {
         var isResolved = false
         var oldLocation: Location? = null
@@ -490,16 +569,38 @@ class NitroGeolocation(
                 Looper.getMainLooper()
             )
 
-            handler.postDelayed(timeoutRunnable, options.timeout.toLong())
+            handler.postDelayed(timeoutRunnable, timeoutMillis)
 
         } catch (e: SecurityException) {
-            pendingPositionRequests.remove(requestId)?.resolver(Result.failure(createLocationError(
+            handleProviderFailure(requestId, createLocationError(
                 PERMISSION_DENIED,
                 "Security exception: ${e.message}"
-            )))
+            ))
         }
     }
 
+    private fun handleProviderFailure(requestId: UUID, error: Exception) {
+        val request = pendingPositionRequests[requestId] ?: return
+
+        request.cancellationSignal?.cancel()
+        request.cancellationSignal = null
+        request.providerIndex += 1
+
+        if (request.providerIndex < request.providers.size) {
+            if (request.remainingTimeoutMillis() <= 0L) {
+                pendingPositionRequests.remove(requestId)?.resolver(Result.failure(
+                    createPositionTimeoutError(request.options)
+                ))
+                return
+            }
+
+            requestFreshLocationForCurrentProvider(requestId)
+            return
+        }
+
+        pendingPositionRequests.remove(requestId)?.resolver(Result.failure(error))
+    }
+
     private fun selectBestLocation(newLocation: Location, currentBest: Location?): Location {
         if (currentBest == null) return newLocation
 
@@ -526,16 +627,15 @@ class NitroGeolocation(
     }
 
     private fun handlePositionTimeout(requestId: UUID) {
-        val request = pendingPositionRequests.remove(requestId)
+        val request = pendingPositionRequests[requestId]
         if (request != null) {
-            request.cancellationSignal?.cancel()
             request.handler.removeCallbacksAndMessages(null)
+            request.cancellationSignal?.cancel()
+            request.cancellationSignal = null
 
-            val timeoutSeconds = request.options.timeout / 1000.0
-            val message = String.format("Unable to fetch location within %.1fs.", timeoutSeconds)
-            val error = createLocationError(TIMEOUT, message)
-
-            request.resolver(Result.failure(error))
+            pendingPositionRequests.remove(requestId)?.resolver(Result.failure(
+                createPositionTimeoutError(request.options)
+            ))
         }
     }
 
@@ -555,7 +655,11 @@ class NitroGeolocation(
             smallestDistanceFilter = minOf(smallestDistanceFilter, subscription.options.distanceFilter.toFloat())
         }
 
-        val provider = getValidProvider(useHighAccuracy) ?: return
+        val provider = getValidProvider(useHighAccuracy)
+        if (provider == null) {
+            notifyWatchProviderUnavailable()
+            return
+        }
         currentWatchProvider = provider
 
         val listener = object : LocationListener {
@@ -606,6 +710,15 @@ class NitroGeolocation(
         }
     }
 
+    private fun notifyWatchProviderUnavailable() {
+        for ((_, subscription) in watchSubscriptions) {
+            subscription.error?.invoke(LocationError(
+                code = POSITION_UNAVAILABLE,
+                message = getNoLocationProviderMessage(subscription.options)
+            ))
+        }
+    }
+
     private fun stopWatchingLocation() {
         watchLocationListener?.let { listener ->
             try {
@@ -666,6 +779,32 @@ class NitroGeolocation(
         return GeolocationErrorException(locationError)
     }
 
+    private fun createPositionTimeoutError(options: ParsedOptions): Exception {
+        val timeoutSeconds = options.timeout / 1000.0
+        val message = String.format("Unable to fetch location within %.1fs.", timeoutSeconds)
+        return createLocationError(TIMEOUT, message)
+    }
+
+    private fun createRequestDeadlineElapsedRealtime(timeout: Double): Long {
+        val now = SystemClock.elapsedRealtime()
+        val timeoutMillis = coerceTimeoutMillis(timeout)
+        val maxTimeoutMillis = Long.MAX_VALUE - now
+
+        return if (timeoutMillis >= maxTimeoutMillis) {
+            Long.MAX_VALUE
+        } else {
+            now + timeoutMillis
+        }
+    }
+
+    private fun coerceTimeoutMillis(timeout: Double): Long {
+        return when {
+            timeout.isNaN() || timeout <= 0.0 -> 0L
+            timeout.isInfinite() || timeout >= Long.MAX_VALUE.toDouble() -> Long.MAX_VALUE
+            else -> timeout.toLong()
+        }
+    }
+
     companion object {
         private const val PERMISSION_REQUEST_CODE = 8947
         private const val TWO_MINUTES_MS = 2 * 60 * 1000L

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-geolocation",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "⚡🚀Blazing-fast geolocation for React Native powered by Nitro Modules",
   "main": "src/index",
   "source": "src/index",
@@ -20,7 +20,9 @@
     "jsSrcsDir": "src"
   },
   "scripts": {
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "vitest --run",
+    "test:watch": "vitest"
   },
   "author": "jingjing2222",
   "license": "MIT",
@@ -50,6 +52,7 @@
     "README.md"
   ],
   "devDependencies": {
+    "@granite-js/vitest": "1.0.23",
     "@react-native/babel-preset": "0.81.1",
     "@tsconfig/react-native": "^3.0.7",
     "@types/react": "^19.1.0",
@@ -57,7 +60,8 @@
     "react": "19.1.0",
     "react-native": "0.81.1",
     "react-native-nitro-modules": "0.35.0",
-    "typescript": "^5.9.3"
+    "typescript": "5.9.3",
+    "vitest": "4.1.5"
   },
   "peerDependencies": {
     "react": ">=18.0.0",

package/src/devtools/index.test.ts

@@ -0,0 +1,54 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { isDevtoolsEnabled } from "./index";
+
+const globalState = globalThis as typeof globalThis & {
+  __DEV__?: boolean;
+  __geolocationDevToolsEnabled?: boolean;
+};
+
+const originalState = {
+  hasDev: Object.prototype.hasOwnProperty.call(globalState, "__DEV__"),
+  dev: globalState.__DEV__,
+  hasDevtoolsEnabled: Object.prototype.hasOwnProperty.call(
+    globalState,
+    "__geolocationDevToolsEnabled"
+  ),
+  devtoolsEnabled: globalState.__geolocationDevToolsEnabled
+};
+
+describe("isDevtoolsEnabled", () => {
+  afterEach(() => {
+    if (originalState.hasDev) {
+      globalState.__DEV__ = originalState.dev;
+    } else {
+      globalState.__DEV__ = undefined;
+    }
+
+    if (originalState.hasDevtoolsEnabled) {
+      globalState.__geolocationDevToolsEnabled = originalState.devtoolsEnabled;
+    } else {
+      globalState.__geolocationDevToolsEnabled = undefined;
+    }
+  });
+
+  it("enables devtools only when React Native __DEV__ and the devtools flag are true", () => {
+    globalState.__DEV__ = true;
+    globalState.__geolocationDevToolsEnabled = true;
+
+    expect(isDevtoolsEnabled()).toBe(true);
+  });
+
+  it("ignores the devtools flag outside React Native __DEV__", () => {
+    globalState.__DEV__ = false;
+    globalState.__geolocationDevToolsEnabled = true;
+
+    expect(isDevtoolsEnabled()).toBe(false);
+  });
+
+  it("stays disabled when __DEV__ is unavailable", () => {
+    globalState.__DEV__ = undefined;
+    globalState.__geolocationDevToolsEnabled = true;
+
+    expect(isDevtoolsEnabled()).toBe(false);
+  });
+});

package/src/devtools/index.ts

@@ -1,5 +1,7 @@
 import type { GeolocationResponse } from "../types";
 
+declare const __DEV__: boolean;
+
 declare global {
   var __geolocationDevToolsEnabled: boolean | undefined;
   var __geolocationDevtools: DevtoolsState | undefined;
@@ -18,6 +20,10 @@ export function getDevtoolsState(): DevtoolsState {
   return globalThis.__geolocationDevtools;
 }
 
+function isReactNativeDev(): boolean {
+  return typeof __DEV__ !== "undefined" && __DEV__ === true;
+}
+
 export function isDevtoolsEnabled(): boolean {
-  return globalThis.__geolocationDevToolsEnabled === true;
+  return isReactNativeDev() && globalThis.__geolocationDevToolsEnabled === true;
 }

package/src/utils/provider.test.ts

@@ -0,0 +1,132 @@
+import { describe, expect, it } from "vitest";
+import { selectProviderForAndroidPermissions } from "./provider";
+
+describe("selectProviderForAndroidPermissions", () => {
+  it("prefers the network provider for low-accuracy coarse-only requests", () => {
+    expect(
+      selectProviderForAndroidPermissions({
+        enableHighAccuracy: false,
+        providers: {
+          gps: true,
+          network: true
+        },
+        permissions: {
+          fine: false,
+          coarse: true
+        }
+      })
+    ).toBe("network");
+  });
+
+  it("does not fall back to GPS when only coarse permission is granted", () => {
+    expect(
+      selectProviderForAndroidPermissions({
+        enableHighAccuracy: false,
+        providers: {
+          gps: true,
+          network: false
+        },
+        permissions: {
+          fine: false,
+          coarse: true
+        }
+      })
+    ).toBeNull();
+  });
+
+  it("does not use GPS for high-accuracy coarse-only requests when network is unavailable", () => {
+    expect(
+      selectProviderForAndroidPermissions({
+        enableHighAccuracy: true,
+        providers: {
+          gps: true,
+          network: false
+        },
+        permissions: {
+          fine: false,
+          coarse: true
+        }
+      })
+    ).toBeNull();
+  });
+
+  it("can satisfy high-accuracy requests with a coarse-compatible fallback", () => {
+    expect(
+      selectProviderForAndroidPermissions({
+        enableHighAccuracy: true,
+        providers: {
+          gps: true,
+          network: true
+        },
+        permissions: {
+          fine: false,
+          coarse: true
+        }
+      })
+    ).toBe("network");
+  });
+
+  it("uses GPS as the low-accuracy fallback only when fine permission is granted", () => {
+    expect(
+      selectProviderForAndroidPermissions({
+        enableHighAccuracy: false,
+        providers: {
+          gps: true,
+          network: false
+        },
+        permissions: {
+          fine: true,
+          coarse: true
+        }
+      })
+    ).toBe("gps");
+  });
+
+  it("uses GPS for high-accuracy requests when fine permission is granted", () => {
+    expect(
+      selectProviderForAndroidPermissions({
+        enableHighAccuracy: true,
+        providers: {
+          gps: true,
+          network: true
+        },
+        permissions: {
+          fine: true,
+          coarse: true
+        }
+      })
+    ).toBe("gps");
+  });
+
+  it("rejects provider selection when no Android location permission is granted", () => {
+    expect(
+      selectProviderForAndroidPermissions({
+        enableHighAccuracy: false,
+        providers: {
+          gps: true,
+          network: true
+        },
+        permissions: {
+          fine: false,
+          coarse: false
+        }
+      })
+    ).toBeNull();
+  });
+
+  it("rejects provider selection when every compatible provider is disabled", () => {
+    expect(
+      selectProviderForAndroidPermissions({
+        enableHighAccuracy: false,
+        providers: {
+          gps: false,
+          network: false
+        },
+        permissions: {
+          fine: true,
+          coarse: true
+        }
+      })
+    ).toBeNull();
+  });
+});

package/src/utils/provider.ts

@@ -3,6 +3,18 @@
  */
 export type Provider = "gps" | "network" | null;
 
+export interface AndroidProviderSelectionInput {
+  enableHighAccuracy: boolean;
+  providers: {
+    gps: boolean;
+    network: boolean;
+  };
+  permissions: {
+    fine: boolean;
+    coarse: boolean;
+  };
+}
+
 /**
  * Selects the best available location provider based on user preferences
  * and provider availability.
@@ -59,3 +71,15 @@ export function selectProvider(
 
   return null;
 }
+
+export function selectProviderForAndroidPermissions({
+  enableHighAccuracy,
+  providers,
+  permissions
+}: AndroidProviderSelectionInput): Provider {
+  const gpsAvailable = providers.gps && permissions.fine;
+  const networkAvailable =
+    providers.network && (permissions.coarse || permissions.fine);
+
+  return selectProvider(enableHighAccuracy, gpsAvailable, networkAvailable);
+}