react-native-nitro-geolocation 0.1.1 → 0.2.0

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

@@ -0,0 +1,81 @@
+package com.margelo.nitro.nitrogeolocation
+
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.ReactApplicationContext
+import com.margelo.nitro.NitroModules
+
+@DoNotStrip
+class NitroGeolocationCompat(
+        private val reactContext: ReactApplicationContext = NitroModules.applicationContext!!
+) : HybridNitroGeolocationCompatSpec() {
+    private var configuration: RNConfigurationInternal =
+            RNConfigurationInternal(
+                    skipPermissionRequests = false,
+                    authorizationLevel = null,
+                    enableBackgroundLocationUpdates = null,
+                    locationProvider = null
+            )
+
+    private val requestAuthorizationHandler by lazy {
+        RequestAuthorization(
+                reactContext = reactContext,
+                onPermissionResult = { result, success, error ->
+                    when (result) {
+                        is PermissionResult.Granted -> success?.invoke()
+                        is PermissionResult.Denied ->
+                                error?.invoke(
+                                        createPermissionError(
+                                                "Location permission was not granted."
+                                        )
+                                )
+                    }
+                }
+        )
+    }
+
+    private val watchPositionHandler by lazy { WatchPosition(reactContext) }
+
+    override fun setRNConfiguration(config: RNConfigurationInternal) {
+        configuration = config
+    }
+
+    override fun requestAuthorization(
+            success: (() -> Unit)?,
+            error: ((error: GeolocationError) -> Unit)?
+    ) {
+        requestAuthorizationHandler.execute(success, error)
+    }
+
+    override fun getCurrentPosition(
+            success: (position: GeolocationResponse) -> Unit,
+            error: ((error: GeolocationError) -> Unit)?,
+            options: GeolocationOptions?
+    ) {
+        GetCurrentPosition(reactContext).execute(success, error, options)
+    }
+
+    override fun watchPosition(
+            success: (position: GeolocationResponse) -> Unit,
+            error: ((error: GeolocationError) -> Unit)?,
+            options: GeolocationOptions?
+    ): Double {
+        return watchPositionHandler.watch(success, error, options).toDouble()
+    }
+
+    override fun clearWatch(watchId: Double) {
+        watchPositionHandler.clearWatch(watchId.toInt())
+    }
+
+    override fun stopObserving() {
+        watchPositionHandler.stopObserving()
+    }
+
+    private fun createPermissionError(message: String) =
+            GeolocationError(
+                    code = RequestAuthorization.PERMISSION_DENIED.toDouble(),
+                    message = message,
+                    PERMISSION_DENIED = RequestAuthorization.PERMISSION_DENIED.toDouble(),
+                    POSITION_UNAVAILABLE = RequestAuthorization.POSITION_UNAVAILABLE.toDouble(),
+                    TIMEOUT = RequestAuthorization.TIMEOUT.toDouble()
+            )
+}

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

@@ -186,19 +186,19 @@ class WatchPosition(private val reactContext: ReactApplicationContext) {
                         GeolocationCoordinates(
                                 latitude = location.latitude,
                                 longitude = location.longitude,
-                                altitude = if (location.hasAltitude()) location.altitude else null,
+                                altitude = if (location.hasAltitude()) NullableDouble.create(location.altitude) else null,
                                 accuracy = location.accuracy.toDouble(),
                                 altitudeAccuracy =
                                         if (android.os.Build.VERSION.SDK_INT >=
                                                         android.os.Build.VERSION_CODES.O &&
                                                         location.hasVerticalAccuracy()
                                         )
-                                                location.verticalAccuracyMeters.toDouble()
+                                                NullableDouble.create(location.verticalAccuracyMeters.toDouble())
                                         else null,
                                 heading =
-                                        if (location.hasBearing()) location.bearing.toDouble()
+                                        if (location.hasBearing()) NullableDouble.create(location.bearing.toDouble())
                                         else null,
-                                speed = if (location.hasSpeed()) location.speed.toDouble() else null
+                                speed = if (location.hasSpeed()) NullableDouble.create(location.speed.toDouble()) else null
                         ),
                 timestamp = location.time.toDouble()
         )

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
@@ -502,11 +487,11 @@ class LocationManager: NSObject, CLLocationManagerDelegate {
         let coordsObj = GeolocationCoordinates(
             latitude: location.coordinate.latitude,
             longitude: location.coordinate.longitude,
-            altitude: altitude,
+            altitude: .second(altitude),
             accuracy: location.horizontalAccuracy,
-            altitudeAccuracy: altitudeAccuracy,
-            heading: heading,
-            speed: speed
+            altitudeAccuracy: .second(altitudeAccuracy),
+            heading: .second(heading),
+            speed: .second(speed)
         )
 
         let position = GeolocationResponse(