react-native-nitro-geolocation 0.1.1 → 0.1.2

package/ios/LocationManager.swift

@@ -10,10 +10,11 @@ class LocationManager: NSObject, CLLocationManagerDelegate {
     }
 
     private struct LocationRequest {
+        let id: UUID = UUID()
         let success: (GeolocationResponse) -> Void
         let error: ((GeolocationError) -> Void)?
         let options: ParsedOptions
-        var timer: Timer?
+        var timer: DispatchSourceTimer?
     }
 
     private struct WatchSubscription {
@@ -22,7 +23,7 @@ class LocationManager: NSObject, CLLocationManagerDelegate {
         let options: ParsedOptions
     }
 
-    private struct ParsedOptions {
+    struct ParsedOptions {
         let timeout: Double
         let maximumAge: Double
         let accuracy: CLLocationAccuracy
@@ -51,7 +52,7 @@ class LocationManager: NSObject, CLLocationManagerDelegate {
     // MARK: - Properties
 
     private var locationManager: CLLocationManager?
-    private var lastLocation: CLLocation?
+    internal private(set) var lastLocation: CLLocation?
     private var usingSignificantChanges: Bool = false
 
     // Authorization
@@ -84,36 +85,32 @@ class LocationManager: NSObject, CLLocationManagerDelegate {
         success: (() -> Void)?,
         error: ((GeolocationError) -> Void)?
     ) {
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self else { return }
-
-            self.initializeLocationManagerIfNeeded()
-            self.enqueueAuthorizationCallbacks(success: success, error: error)
-
-            // Skip permission requests if configured
-            if skipPermissionRequests {
-                if enableBackgroundLocationUpdates {
-                    self.enableBackgroundLocationUpdatesIfNeeded()
-                }
-                self.handleAuthorizationSuccess()
-                return
-            }
+        initializeLocationManagerIfNeeded()
+        enqueueAuthorizationCallbacks(success: success, error: error)
 
-            // Check if already authorized
-            let currentStatus = CLLocationManager.authorizationStatus()
-            if currentStatus == .authorizedAlways || currentStatus == .authorizedWhenInUse {
-                self.handleAuthorizationSuccess()
-                return
+        // Skip permission requests if configured
+        if skipPermissionRequests {
+            if enableBackgroundLocationUpdates {
+                enableBackgroundLocationUpdatesIfNeeded()
             }
+            handleAuthorizationSuccess()
+            return
+        }
 
-            if currentStatus == .denied || currentStatus == .restricted {
-                self.handleAuthorizationError(for: currentStatus)
-                return
-            }
+        // Check if already authorized
+        let currentStatus = CLLocationManager.authorizationStatus()
+        if currentStatus == .authorizedAlways || currentStatus == .authorizedWhenInUse {
+            handleAuthorizationSuccess()
+            return
+        }
 
-            // Not determined yet, request permission
-            self.requestPermission(for: authType)
+        if currentStatus == .denied || currentStatus == .restricted {
+            handleAuthorizationError(for: currentStatus)
+            return
         }
+
+        // Not determined yet, request permission
+        requestPermission(for: authType)
     }
 
     private func enqueueAuthorizationCallbacks(
@@ -153,63 +150,51 @@ class LocationManager: NSObject, CLLocationManagerDelegate {
         error: ((GeolocationError) -> Void)?,
         options: GeolocationOptions?
     ) {
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self else { return }
-
-            let parsedOptions = ParsedOptions.parse(from: options)
-
-            // Check authorization
-            let status = CLLocationManager.authorizationStatus()
-            if status == .denied || status == .restricted {
-                let message =
-                    status == .restricted
-                    ? "This application is not authorized to use location services"
-                    : "User denied access to location services."
-                error?(self.createError(code: self.PERMISSION_DENIED, message: message))
-                return
-            }
-
-            if !CLLocationManager.locationServicesEnabled() {
-                error?(
-                    self.createError(
-                        code: self.POSITION_UNAVAILABLE, message: "Location services disabled."))
-                return
-            }
+        let parsedOptions = ParsedOptions.parse(from: options)
+
+        // Check authorization
+        let status = CLLocationManager.authorizationStatus()
+        if status == .denied || status == .restricted {
+            let message =
+                status == .restricted
+                ? "This application is not authorized to use location services"
+                : "User denied access to location services."
+            error?(createError(code: PERMISSION_DENIED, message: message))
+            return
+        }
 
-            // Check cached location
-            if let cached = self.lastLocation,
-                self.isCachedLocationValid(cached, options: parsedOptions)
-            {
-                success(self.locationToPosition(cached))
-                return
-            }
+        if !CLLocationManager.locationServicesEnabled() {
+            error?(createError(code: POSITION_UNAVAILABLE, message: "Location services disabled."))
+            return
+        }
 
-            self.initializeLocationManagerIfNeeded()
+        initializeLocationManagerIfNeeded()
 
-            // Configure location manager (use best accuracy from all pending requests)
-            self.updateLocationManagerConfiguration()
+        // Configure location manager
+        locationManager?.desiredAccuracy = parsedOptions.accuracy
+        locationManager?.distanceFilter = parsedOptions.distanceFilter
 
-            // Create request
-            var request = LocationRequest(
-                success: success,
-                error: error,
-                options: parsedOptions,
-                timer: nil
-            )
+        // Create request
+        var request = LocationRequest(
+            success: success,
+            error: error,
+            options: parsedOptions,
+            timer: nil
+        )
 
-            // Setup timeout
-            let timer = Timer.scheduledTimer(
-                withTimeInterval: parsedOptions.timeout / 1000.0, repeats: false
-            ) { [weak self] timer in
-                self?.handleTimeout(for: timer)
-            }
-            request.timer = timer
+        // Setup timeout with DispatchSourceTimer (no run loop needed)
+        let timer = DispatchSource.makeTimerSource(queue: .main)
+        timer.schedule(deadline: .now() + parsedOptions.timeout / 1000.0)
+        timer.setEventHandler { [weak self] in
+            self?.handleTimeout(for: request.id)
+        }
+        timer.resume()
+        request.timer = timer
 
-            self.pendingRequests.append(request)
+        pendingRequests.append(request)
 
-            // Start location updates
-            self.startMonitoring()
-        }
+        // Start location updates
+        startMonitoring()
     }
 
     // MARK: - Watch Position
@@ -219,56 +204,44 @@ class LocationManager: NSObject, CLLocationManagerDelegate {
         error: ((GeolocationError) -> Void)?,
         options: GeolocationOptions?
     ) -> Double {
-        var resultWatchId: Double = 0
-
-        DispatchQueue.main.sync { [weak self] in
-            guard let self = self else { return }
-
-            let parsedOptions = ParsedOptions.parse(from: options)
-            let watchId = self.nextWatchId
-            self.nextWatchId += 1
+        let parsedOptions = ParsedOptions.parse(from: options)
+        let watchId = nextWatchId
+        nextWatchId += 1
+
+        let subscription = WatchSubscription(
+            success: success,
+            error: error,
+            options: parsedOptions
+        )
 
-            let subscription = WatchSubscription(
-                success: success,
-                error: error,
-                options: parsedOptions
-            )
+        activeWatches[watchId] = subscription
 
-            self.activeWatches[watchId] = subscription
+        initializeLocationManagerIfNeeded()
 
-            self.initializeLocationManagerIfNeeded()
-            self.updateLocationManagerConfiguration()
-            self.startMonitoring()
+        // Configure location manager
+        locationManager?.desiredAccuracy = parsedOptions.accuracy
+        locationManager?.distanceFilter = parsedOptions.distanceFilter
 
-            resultWatchId = watchId
-        }
+        startMonitoring()
 
-        return resultWatchId
+        return watchId
     }
 
     func clearWatch(watchId: Double) {
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self else { return }
-
-            self.activeWatches.removeValue(forKey: watchId)
+        activeWatches.removeValue(forKey: watchId)
 
-            // Stop monitoring if no more watches or pending requests
-            if self.activeWatches.isEmpty && self.pendingRequests.isEmpty {
-                self.stopMonitoring()
-            }
+        // Stop monitoring if no more watches or pending requests
+        if activeWatches.isEmpty && pendingRequests.isEmpty {
+            stopMonitoring()
         }
     }
 
     func stopObserving() {
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self else { return }
+        activeWatches.removeAll()
 
-            self.activeWatches.removeAll()
-
-            // Stop monitoring if no pending requests
-            if self.pendingRequests.isEmpty {
-                self.stopMonitoring()
-            }
+        // Stop monitoring if no pending requests
+        if pendingRequests.isEmpty {
+            stopMonitoring()
         }
     }
 
@@ -298,7 +271,7 @@ class LocationManager: NSObject, CLLocationManagerDelegate {
 
         // 1. Fire all pending getCurrentPosition requests
         for request in pendingRequests {
-            request.timer?.invalidate()
+            request.timer?.cancel()
             request.success(position)
         }
         pendingRequests.removeAll()
@@ -338,7 +311,7 @@ class LocationManager: NSObject, CLLocationManagerDelegate {
 
         // Fire all pending requests with error
         for request in pendingRequests {
-            request.timer?.invalidate()
+            request.timer?.cancel()
             request.error?(geoError)
         }
         pendingRequests.removeAll()
@@ -355,8 +328,17 @@ class LocationManager: NSObject, CLLocationManagerDelegate {
 
     private func initializeLocationManagerIfNeeded() {
         guard locationManager == nil else { return }
-        locationManager = CLLocationManager()
-        locationManager?.delegate = self
+
+        // CLLocationManager must be created on main thread for delegate callbacks
+        if Thread.isMainThread {
+            locationManager = CLLocationManager()
+            locationManager?.delegate = self
+        } else {
+            DispatchQueue.main.sync {
+                locationManager = CLLocationManager()
+                locationManager?.delegate = self
+            }
+        }
     }
 
     private func updateLocationManagerConfiguration() {
@@ -408,7 +390,7 @@ class LocationManager: NSObject, CLLocationManagerDelegate {
         }
     }
 
-    private func isCachedLocationValid(_ location: CLLocation, options: ParsedOptions) -> Bool {
+    func isCachedLocationValid(_ location: CLLocation, options: ParsedOptions) -> Bool {
         // Check if maximumAge is infinity
         if options.maximumAge.isInfinite {
             return true
@@ -428,13 +410,16 @@ class LocationManager: NSObject, CLLocationManagerDelegate {
         return true
     }
 
-    private func handleTimeout(for timer: Timer) {
-        // Find and remove the request with this timer
-        if let index = pendingRequests.firstIndex(where: { $0.timer === timer }) {
+    private func handleTimeout(for requestId: UUID) {
+        // Find and remove the request with this ID
+        if let index = pendingRequests.firstIndex(where: { $0.id == requestId }) {
             let request = pendingRequests[index]
             pendingRequests.remove(at: index)
 
-            // Always return timeout error
+            // Cancel timer
+            request.timer?.cancel()
+
+            // Return timeout error
             let timeoutSeconds = request.options.timeout / 1000.0
             let message = String(format: "Unable to fetch location within %.1fs.", timeoutSeconds)
             request.error?(createError(code: TIMEOUT, message: message))
@@ -493,7 +478,7 @@ class LocationManager: NSObject, CLLocationManagerDelegate {
         queuedAuthorizationCallbacks.removeAll()
     }
 
-    private func locationToPosition(_ location: CLLocation) -> GeolocationResponse {
+    func locationToPosition(_ location: CLLocation) -> GeolocationResponse {
         let altitude = location.verticalAccuracy < 0 ? 0.0 : location.altitude
         let altitudeAccuracy = location.verticalAccuracy < 0 ? 0.0 : location.verticalAccuracy
         let heading = location.course >= 0 ? location.course : -1.0

package/ios/NitroGeolocation.swift

@@ -38,6 +38,16 @@ class NitroGeolocation: HybridNitroGeolocationSpec {
         success: @escaping (GeolocationResponse) -> Void, error: ((GeolocationError) -> Void)?,
         options: GeolocationOptions?
     ) throws {
+        // Fast path: check cached location immediately (no dispatch overhead!)
+        let parsedOptions = LocationManager.ParsedOptions.parse(from: options)
+
+        if let cached = locationManager.lastLocation,
+           locationManager.isCachedLocationValid(cached, options: parsedOptions) {
+            success(locationManager.locationToPosition(cached))
+            return
+        }
+
+        // Slow path: need GPS
         locationManager.getCurrentPosition(success: success, error: error, options: options)
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-geolocation",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "⚡🚀Blazing-fast geolocation for React Native powered by Nitro Modules",
   "main": "src/index",
   "source": "src/index",
@@ -43,7 +43,7 @@
     "@types/react-test-renderer": "^18.0.0",
     "react": "19.1.0",
     "react-native": "0.81.1",
-    "react-native-nitro-modules": "^0.29.7",
+    "react-native-nitro-modules": "^0.29.6",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {

package/README.md

@@ -1,318 +0,0 @@
-# react-native-nitro-geolocation
-
-[![NPM](https://img.shields.io/npm/v/react-native-nitro-geolocation)](https://www.npmjs.com/package/react-native-nitro-geolocation)
-
-[`@react-native-community/geolocation`](https://github.com/michalchudziak/react-native-geolocation)
-for the **React Native New Architecture** — with 100% API compatibility.
-
-![react-native-nitro-geolocation)(https://raw.githubusercontent.com/jingjing2222/react-native-nitro-geolocation/main/demo.gif)
-
----
-
-## 📘 Documentation
-
-Full documentation available at:
-👉 [https://react-native-nitro-geolocation.pages.dev](https://react-native-nitro-geolocation.pages.dev)
-
----
-
-## 🧭 Introduction
-
-The `@react-native-community/geolocation` package has long been the standard way to access device location in React Native apps.
-
-With React Native moving toward **Nitro Modules**, **Fabric**, and **JSI**,
-this project — **React Native Nitro Geolocation** — brings the same familiar API to the new architecture.
-
-It provides the **same API surface** with:
-
-- 🚀 Faster performance via direct **JSI bindings**
-- 📱 Improved native consistency (Android + iOS)
-- 🔁 Seamless migration from `@react-native-community/geolocation`
-- 🧩 TypeScript-first developer experience
-- 🔄 100% API compatibility (drop-in replacement)
-
-Whether upgrading an existing app or building a new one,
-**React Native Nitro Geolocation** keeps the simplicity you know — with modern internals.
-
-## 🏗 Architecture Comparison
-
-### 🧩 Origin: Event-based Architecture (`@react-native-community/geolocation`)
-
-~~~
-JavaScript
-  ↓ EventEmitter.addListener('geolocationDidChange', callback)
-  ↓ (Callback stored in JS)
-React Native Bridge (JSON serialization)
-  ↓
-Native Layer (Android/iOS)
-  ↓ LocationListener receives updates
-  ↓ emit('geolocationDidChange', data)
-  ↓
-EventEmitter dispatches to all listeners
-  ↓
-User callback executed
-~~~
-
-**Key traits:**
-- Callbacks stored only in JS
-- Bridge serialization on every update
-- One shared event stream
-
----
-
-### ⚡ Modern: Direct Callback Architecture (`react-native-nitro-geolocation`)
-
-~~~
-JavaScript
-  ↓ Geolocation.watchPosition(success, error)
-  ↓ (Callbacks passed directly to native via JSI)
-JSI Layer (No Bridge!)
-  ↓
-Native Layer (Kotlin/Swift)
-  ↓ callback.success(position) → JSI direct call
-  ↓
-User callback executed immediately
-~~~
-
-**Key traits:**
-- Callbacks passed as native JSI references
-- No Bridge serialization
-- Independent callback per watcher
-- Native → JS communication in real time
-
----
-
-## ⚡ Quick Start
-
-### 1. Installation
-
-~~~bash
-# Install Nitro core and Geolocation module
-yarn add react-native-nitro-modules react-native-nitro-geolocation
-
-# or using npm
-npm install react-native-nitro-modules react-native-nitro-geolocation
-~~~
-
-After installation, rebuild your native app:
-
-~~~bash
-cd ios && pod install
-~~~
-
----
-
-### 2. iOS Setup
-
-Add the following permissions to your **Info.plist**:
-
-~~~xml
-<key>NSLocationWhenInUseUsageDescription</key>
-<string>This app requires access to your location while it’s in use.</string>
-<key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
-<string>This app requires access to your location at all times.</string>
-~~~
-
----
-
-### 3. Android Setup
-
-Add these permissions to your **AndroidManifest.xml**:
-
-~~~xml
-<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
-<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
-~~~
-
-Optional (for background access):
-
-~~~xml
-<uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
-~~~
-
----
-
-### 4. Usage Example
-
-~~~tsx
-import Geolocation from 'react-native-nitro-geolocation';
-
-Geolocation.getCurrentPosition(
-  (position) => {
-    console.log('Latitude:', position.coords.latitude);
-    console.log('Longitude:', position.coords.longitude);
-  },
-  (error) => {
-    console.error('Location error:', error);
-  },
-  { enableHighAccuracy: true, timeout: 15000, maximumAge: 10000 }
-);
-
-// Subscribe to continuous updates
-const watchId = Geolocation.watchPosition(
-  (position) => {
-    console.log('Updated position:', position);
-  },
-  (error) => console.error(error),
-);
-~~~
-
----
-
-### Migrating from `@react-native-community/geolocation`
-
-Nitro Geolocation is **100% API-compatible** with the original package.
-You can migrate simply by replacing imports:
-
-~~~diff
-- import Geolocation from '@react-native-community/geolocation';
-+ import Geolocation from 'react-native-nitro-geolocation';
-~~~
-
-**Benefits:**
-- Better performance via JSI
-- Reduced bridge overhead
-- Improved permission consistency
-- Built-in TypeScript definitions
-
----
-
-## 🧠 API Methods
-
-### Summary
-- `setRNConfiguration`
-- `requestAuthorization`
-- `getCurrentPosition`
-- `watchPosition`
-- `clearWatch`
-- `stopObserving`
-
----
-
-### `setRNConfiguration()`
-
-Sets configuration options used for all location requests.
-
-~~~tsx
-import Geolocation from 'react-native-nitro-geolocation';
-
-Geolocation.setRNConfiguration({
-  skipPermissionRequests: false,
-  authorizationLevel: 'auto',
-  enableBackgroundLocationUpdates: true,
-  locationProvider: 'auto',
-});
-
-// recommended
-import { setRNConfiguration } from 'react-native-nitro-geolocation';
-
-setRNConfiguration({
-  skipPermissionRequests: false,
-  authorizationLevel: 'auto',
-  enableBackgroundLocationUpdates: true,
-  locationProvider: 'auto',
-});
-~~~
-
-**Options:**
-- `skipPermissionRequests` — default `false`
-- `authorizationLevel` — `'always' | 'whenInUse' | 'auto'` *(iOS only)*
-- `enableBackgroundLocationUpdates` — *(iOS only)*
-- `locationProvider` — `'playServices' | 'android' | 'auto'` *(Android only)*
-
----
-
-### `requestAuthorization()`
-
-Requests location permission from the system.
-
-~~~tsx
-import Geolocation from 'react-native-nitro-geolocation';
-
-Geolocation.requestAuthorization(
-  () => console.log('Permission granted'),
-  (error) => console.error('Permission error:', error),
-);
-
-// recommended
-import { requestAuthorization } from 'react-native-nitro-geolocation';
-
-requestAuthorization(
-  () => console.log('Permission granted'),
-  (error) => console.error('Permission error:', error),
-);
-~~~
-
----
-
-### `getCurrentPosition()`
-
-Retrieves the current device location once.
-
-~~~tsx
-import Geolocation from 'react-native-nitro-geolocation';
-
-Geolocation.getCurrentPosition(
-  (position) => console.log(position),
-  (error) => console.error(error),
-  { enableHighAccuracy: true, timeout: 15000, maximumAge: 10000 },
-);
-
-// recommended
-import { getCurrentPosition } from 'react-native-nitro-geolocation';
-
-getCurrentPosition(
-  (position) => console.log(position),
-  (error) => console.error(error),
-  { enableHighAccuracy: true, timeout: 15000, maximumAge: 10000 },
-);
-~~~
-
----
-
-### `watchPosition()`
-
-Watches location changes and calls the success callback each time.
-
-~~~tsx
-import Geolocation from 'react-native-nitro-geolocation';
-
-const id = Geolocation.watchPosition(
-  (position) => console.log('Position:', position),
-  (error) => console.error(error),
-  { interval: 5000, distanceFilter: 10 },
-);
-
-// recommended
-import { watchPosition } from 'react-native-nitro-geolocation';
-
-const id = watchPosition(
-  (position) => console.log('Position:', position),
-  (error) => console.error(error),
-  { interval: 5000, distanceFilter: 10 },
-);
-
-~~~
-
----
-
-### `clearWatch()`
-
-Stops watching location updates for a given watch ID.
-
-~~~tsx
-import Geolocation from 'react-native-nitro-geolocation';
-Geolocation.clearWatch(id);
-
-// recommended
-import { clearWatch } from 'react-native-nitro-geolocation';
-clearWatch(id);
-~~~
-
----
-
-## 🧪 Summary
-
-**React Native Nitro Geolocation** transforms the geolocation API
-from a bridge-based, event-driven system into a **JSI-powered direct-callback model** —
-delivering native-level performance with **zero API changes** for developers.