react-native-nitro-location-tracking 0.1.10 → 0.1.11

package/android/src/main/java/com/margelo/nitro/nitrolocationtracking/PermissionStatusMonitor.kt

@@ -3,6 +3,8 @@ package com.margelo.nitro.nitrolocationtracking
 import android.content.Context
 import android.content.pm.PackageManager
 import android.os.Build
+import android.os.Handler
+import android.os.Looper
 import android.util.Log
 import androidx.core.content.ContextCompat
 import androidx.lifecycle.DefaultLifecycleObserver
@@ -24,6 +26,7 @@ class PermissionStatusMonitor(private val context: Context) {
 
     private var callback: ((PermissionStatus) -> Unit)? = null
     private var lastStatus: PermissionStatus? = null
+    private val mainHandler = Handler(Looper.getMainLooper())
 
     private val lifecycleObserver = object : DefaultLifecycleObserver {
         override fun onStart(owner: LifecycleOwner) {
@@ -36,12 +39,14 @@ class PermissionStatusMonitor(private val context: Context) {
         // Capture the current status so we only fire on actual changes
         lastStatus = getCurrentPermissionStatus()
 
-        // Observe the process lifecycle (app foreground / background)
-        try {
-            ProcessLifecycleOwner.get().lifecycle.addObserver(lifecycleObserver)
-            Log.d(TAG, "Registered lifecycle observer for permission changes")
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to register lifecycle observer: ${e.message}")
+        // addObserver MUST be called on the main thread
+        mainHandler.post {
+            try {
+                ProcessLifecycleOwner.get().lifecycle.addObserver(lifecycleObserver)
+                Log.d(TAG, "Registered lifecycle observer for permission changes")
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to register lifecycle observer: ${e.message}")
+            }
         }
     }
 
@@ -76,9 +81,11 @@ class PermissionStatusMonitor(private val context: Context) {
     }
 
     fun destroy() {
-        try {
-            ProcessLifecycleOwner.get().lifecycle.removeObserver(lifecycleObserver)
-        } catch (_: Exception) {}
+        mainHandler.post {
+            try {
+                ProcessLifecycleOwner.get().lifecycle.removeObserver(lifecycleObserver)
+            } catch (_: Exception) {}
+        }
         callback = null
         lastStatus = null
     }

package/android/src/main/java/com/margelo/nitro/nitrolocationtracking/ProviderStatusMonitor.kt

@@ -1,27 +1,54 @@
 package com.margelo.nitro.nitrolocationtracking
 
-import android.content.BroadcastReceiver
 import android.content.Context
-import android.content.Intent
-import android.content.IntentFilter
+import android.database.ContentObserver
 import android.location.LocationManager
 import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.provider.Settings
 import android.util.Log
 
+/**
+ * Monitors GPS / network location provider status changes using a ContentObserver
+ * on Settings.Secure.LOCATION_MODE.
+ *
+ * Why ContentObserver instead of BroadcastReceiver?
+ * Several OEMs (notably Samsung) suppress PROVIDERS_CHANGED_ACTION broadcasts,
+ * making BroadcastReceiver unreliable.  ContentObserver watches the Settings DB
+ * directly and fires on all devices.
+ *
+ * Implementation notes:
+ * - ContentObserver.onChange fires BEFORE the LocationManager reflects the new
+ *   state, so we post a short delayed read (150 ms) to get the correct values.
+ * - onChange can fire multiple times per toggle; we debounce with a pending
+ *   Runnable and deduplicate by comparing with lastGps / lastNetwork.
+ */
 class ProviderStatusMonitor(private val context: Context) {
 
     companion object {
         private const val TAG = "ProviderStatusMonitor"
+        /** Delay (ms) to let the system apply the setting before we read it. */
+        private const val READ_DELAY_MS = 150L
     }
 
     private val locationManager =
         context.getSystemService(Context.LOCATION_SERVICE) as LocationManager
+    private val mainHandler = Handler(Looper.getMainLooper())
+
     private var callback: ((LocationProviderStatus, LocationProviderStatus) -> Unit)? = null
-    private var receiver: BroadcastReceiver? = null
+    private var contentObserver: ContentObserver? = null
+    private var pendingNotify: Runnable? = null
+
+    // Track last-notified values to avoid duplicate callbacks
+    private var lastGps: LocationProviderStatus? = null
+    private var lastNetwork: LocationProviderStatus? = null
 
     fun setCallback(callback: (LocationProviderStatus, LocationProviderStatus) -> Unit) {
         this.callback = callback
-        registerReceiver()
+        registerObserver()
+        // Emit current status immediately (no delay needed — values are already settled)
+        emitCurrentStatus()
     }
 
     fun isLocationServicesEnabled(): Boolean {
@@ -33,41 +60,78 @@ class ProviderStatusMonitor(private val context: Context) {
         }
     }
 
-    private fun registerReceiver() {
-        if (receiver != null) return
+    // ── Observer registration ────────────────────────────────────────────
 
-        receiver = object : BroadcastReceiver() {
-            override fun onReceive(context: Context?, intent: Intent?) {
-                if (intent?.action == LocationManager.PROVIDERS_CHANGED_ACTION) {
-                    notifyStatus()
-                }
+    private fun registerObserver() {
+        if (contentObserver != null) return
+
+        contentObserver = object : ContentObserver(mainHandler) {
+            override fun onChange(selfChange: Boolean) {
+                super.onChange(selfChange)
+                scheduleNotify()
             }
         }
 
-        val filter = IntentFilter(LocationManager.PROVIDERS_CHANGED_ACTION)
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-            context.registerReceiver(receiver, filter, Context.RECEIVER_NOT_EXPORTED)
-        } else {
-            context.registerReceiver(receiver, filter)
-        }
-        Log.d(TAG, "Registered provider status receiver")
+        // LOCATION_MODE is the single authoritative setting for the global
+        // location toggle (GPS + Network).  Watching only this avoids the
+        // double-fire that occurs when observing LOCATION_PROVIDERS_ALLOWED too.
+        context.contentResolver.registerContentObserver(
+            Settings.Secure.getUriFor(Settings.Secure.LOCATION_MODE),
+            false,
+            contentObserver!!
+        )
+
+        Log.d(TAG, "ContentObserver registered")
+    }
+
+    // ── Debounced + delayed notification ─────────────────────────────────
+
+    /**
+     * Schedule a delayed read of the provider status.
+     * If onChange fires multiple times in quick succession, the previous
+     * pending Runnable is cancelled so we only read once after things settle.
+     */
+    private fun scheduleNotify() {
+        pendingNotify?.let { mainHandler.removeCallbacks(it) }
+
+        val runnable = Runnable { emitCurrentStatus() }
+        pendingNotify = runnable
+        mainHandler.postDelayed(runnable, READ_DELAY_MS)
     }
 
-    private fun notifyStatus() {
+    /**
+     * Read the current GPS + Network provider state and invoke the callback
+     * only if the values actually changed since the last notification.
+     */
+    private fun emitCurrentStatus() {
         val gps = if (locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER))
             LocationProviderStatus.ENABLED else LocationProviderStatus.DISABLED
         val network = if (locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER))
             LocationProviderStatus.ENABLED else LocationProviderStatus.DISABLED
+
+        // Deduplicate — only fire if something actually changed
+        if (gps == lastGps && network == lastNetwork) return
+
+        lastGps = gps
+        lastNetwork = network
+        Log.d(TAG, "Provider status changed: GPS=$gps, Network=$network")
         callback?.invoke(gps, network)
     }
 
+    // ── Cleanup ──────────────────────────────────────────────────────────
+
     fun destroy() {
-        receiver?.let {
+        pendingNotify?.let { mainHandler.removeCallbacks(it) }
+        pendingNotify = null
+
+        contentObserver?.let {
             try {
-                context.unregisterReceiver(it)
+                context.contentResolver.unregisterContentObserver(it)
             } catch (_: Exception) {}
         }
-        receiver = null
+        contentObserver = null
         callback = null
+        lastGps = null
+        lastNetwork = null
     }
 }

package/ios/LocationEngine.swift

@@ -21,8 +21,31 @@ class LocationEngine: NSObject, CLLocationManagerDelegate {
     var rejectMockLocations: Bool = false
     let speedMonitor = SpeedMonitor()
     let tripCalculator = TripCalculator()
-    var providerStatusCallback: ((LocationProviderStatus, LocationProviderStatus) -> Void)?
-    var permissionStatusCallback: ((PermissionStatus) -> Void)?
+    var providerStatusCallback: ((LocationProviderStatus, LocationProviderStatus) -> Void)? {
+        didSet {
+            // Emit current status immediately when the callback is first set
+            if providerStatusCallback != nil {
+                let enabled = CLLocationManager.locationServicesEnabled()
+                let status: LocationProviderStatus = enabled ? .enabled : .disabled
+                lastProviderEnabled = enabled
+                providerStatusCallback?(status, status)
+            }
+        }
+    }
+    var permissionStatusCallback: ((PermissionStatus) -> Void)? {
+        didSet {
+            // Emit current status immediately when the callback is first set
+            if permissionStatusCallback != nil {
+                let current = Self.mapAuthStatus(CLLocationManager.authorizationStatus())
+                lastPermissionStatus = current
+                permissionStatusCallback?(current)
+            }
+        }
+    }
+
+    // Deduplication: track last-notified values
+    private var lastPermissionStatus: PermissionStatus?
+    private var lastProviderEnabled: Bool?
 
     /// The most recently received location from Core Location (for distance calculations)
     var lastCLLocation: CLLocation? {
@@ -193,6 +216,8 @@ class LocationEngine: NSObject, CLLocationManagerDelegate {
         return CLLocationManager.locationServicesEnabled()
     }
 
+    // MARK: - Authorization / Provider change delegate
+
     func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
         guard manager === locationManager else { return }
 
@@ -213,27 +238,39 @@ class LocationEngine: NSObject, CLLocationManagerDelegate {
             }
         }
 
-        // Notify JS about permission status change
-        let permStatus: PermissionStatus
-        switch authStatus {
+        // Notify JS about permission status change (deduplicated)
+        let permStatus = Self.mapAuthStatus(authStatus)
+        if permStatus != lastPermissionStatus {
+            lastPermissionStatus = permStatus
+            permissionStatusCallback?(permStatus)
+        }
+
+        // Notify JS about provider status change (deduplicated)
+        let enabled = CLLocationManager.locationServicesEnabled()
+        if enabled != lastProviderEnabled {
+            lastProviderEnabled = enabled
+            let status: LocationProviderStatus = enabled ? .enabled : .disabled
+            providerStatusCallback?(status, status)
+        }
+    }
+
+    // MARK: - Helpers
+
+    private static func mapAuthStatus(_ status: CLAuthorizationStatus) -> PermissionStatus {
+        switch status {
         case .notDetermined:
-            permStatus = .notdetermined
+            return .notdetermined
         case .restricted:
-            permStatus = .restricted
+            return .restricted
         case .denied:
-            permStatus = .denied
+            return .denied
         case .authorizedWhenInUse:
-            permStatus = .wheninuse
+            return .wheninuse
         case .authorizedAlways:
-            permStatus = .always
+            return .always
         @unknown default:
-            permStatus = .notdetermined
+            return .notdetermined
         }
-        permissionStatusCallback?(permStatus)
-
-        let enabled = CLLocationManager.locationServicesEnabled()
-        let status: LocationProviderStatus = enabled ? .enabled : .disabled
-        providerStatusCallback?(status, status)
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-location-tracking",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "A React Native Nitro module for location tracking",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",