react-native-nitro-geolocation 1.2.6 → 1.3.1

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

@@ -3,7 +3,6 @@ package com.margelo.nitro.nitrogeolocation
 import android.Manifest
 import android.content.Context
 import android.content.pm.PackageManager
-import android.location.Address
 import android.location.Geocoder
 import android.location.Location
 import android.location.LocationListener
@@ -13,14 +12,14 @@ import android.os.CancellationSignal
 import android.os.Handler
 import android.os.Looper
 import android.os.SystemClock
-import androidx.core.app.ActivityCompat
 import androidx.core.content.ContextCompat
 import com.facebook.proguard.annotations.DoNotStrip
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.modules.core.PermissionAwareActivity
+import com.facebook.react.modules.core.PermissionListener
 import com.google.android.gms.common.ConnectionResult
 import com.google.android.gms.common.GoogleApiAvailability
 import com.google.android.gms.location.LocationCallback
-import com.google.android.gms.location.LocationRequest as GmsLocationRequest
 import com.google.android.gms.location.LocationResult
 import com.google.android.gms.location.LocationServices
 import com.margelo.nitro.NitroModules
@@ -29,12 +28,7 @@ import java.io.IOException
 import java.util.Locale
 import java.util.UUID
 import java.util.concurrent.ConcurrentHashMap
-import java.util.concurrent.atomic.AtomicBoolean
-
-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."
+import java.util.concurrent.atomic.AtomicLong
 
 /**
  * Geolocation implementation for Android.
@@ -50,94 +44,6 @@ class NitroGeolocation(
     private val reactContext: ReactApplicationContext = NitroModules.applicationContext!!
 ) : HybridNitroGeolocationSpec() {
 
-    // MARK: - Types
-
-    private data class ParsedOptions(
-        val timeout: Double,
-        val maximumAge: Double,
-        val androidAccuracy: AndroidAccuracyResolution,
-        val interval: Double,
-        val fastestInterval: Double,
-        val distanceFilter: Double,
-        val granularity: AndroidGranularity,
-        val waitForAccurateLocation: Boolean,
-        val maxUpdateAge: Double?,
-        val maxUpdateDelay: Double,
-        val maxUpdates: Int?
-    ) {
-        companion object {
-            private const val DEFAULT_TIMEOUT = 10.0 * 60 * 1000 // 10 minutes in ms
-            private const val DEFAULT_MAXIMUM_AGE = 0.0
-            private const val DEFAULT_INTERVAL = 1000.0
-            private const val DEFAULT_FASTEST_INTERVAL = 100.0
-            private const val DEFAULT_DISTANCE_FILTER = 0.0
-            private const val DEFAULT_MAX_UPDATE_DELAY = 0.0
-
-            fun parse(
-                options: LocationRequestOptions?,
-                defaultMaximumAge: Double = DEFAULT_MAXIMUM_AGE
-            ): ParsedOptions {
-                val enableHighAccuracy = options?.enableHighAccuracy ?: false
-                val maxUpdates = options?.maxUpdates?.let { value ->
-                    if (!value.isFinite()) {
-                        0
-                    } else {
-                        value.toInt()
-                    }
-                }
-
-                return ParsedOptions(
-                    timeout = options?.timeout ?: DEFAULT_TIMEOUT,
-                    maximumAge = options?.maximumAge ?: defaultMaximumAge,
-                    androidAccuracy = resolveAndroidAccuracy(
-                        options?.accuracy,
-                        enableHighAccuracy
-                    ),
-                    interval = options?.interval ?: DEFAULT_INTERVAL,
-                    fastestInterval = options?.fastestInterval ?: DEFAULT_FASTEST_INTERVAL,
-                    distanceFilter = options?.distanceFilter ?: DEFAULT_DISTANCE_FILTER,
-                    granularity = options?.granularity ?: AndroidGranularity.PERMISSION,
-                    waitForAccurateLocation = options?.waitForAccurateLocation ?: false,
-                    maxUpdateAge = options?.maxUpdateAge,
-                    maxUpdateDelay = options?.maxUpdateDelay ?: DEFAULT_MAX_UPDATE_DELAY,
-                    maxUpdates = maxUpdates
-                )
-            }
-
-            fun parseLastKnown(options: LocationRequestOptions?): ParsedOptions {
-                return parse(options, defaultMaximumAge = Double.POSITIVE_INFINITY)
-            }
-        }
-    }
-
-    private data class WatchSubscription(
-        val token: String,
-        val success: (GeolocationResponse) -> Unit,
-        val error: ((LocationError) -> Unit)?,
-        val options: ParsedOptions,
-        var deliveredUpdates: Int = 0
-    )
-
-    private sealed interface PositionResult {
-        data class Success(val position: GeolocationResponse) : PositionResult
-        data class Failure(val error: LocationError) : PositionResult
-    }
-
-    private data class PositionRequest(
-        val id: UUID,
-        val resolver: (PositionResult) -> 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
 
     private var configuration: GeolocationConfiguration? = null
@@ -155,6 +61,14 @@ class NitroGeolocation(
     private val fusedLocationClient by lazy {
         LocationServices.getFusedLocationProviderClient(reactContext)
     }
+    private val fusedLocationProvider by lazy {
+        AndroidFusedLocationProvider(
+            fusedLocationClient = fusedLocationClient,
+            isCachedLocationValid = ::isCachedLocationValid,
+            effectiveMaximumAge = ::effectiveMaximumAge,
+            locationToPosition = ::locationToPosition
+        )
+    }
     private val headingManager: AndroidHeadingManager by lazy {
         AndroidHeadingManager(
             context = reactContext,
@@ -181,15 +95,7 @@ class NitroGeolocation(
     // Location listener for watch subscriptions
     private var watchLocationListener: LocationListener? = null
     private var fusedWatchLocationCallback: LocationCallback? = null
-    private var currentWatchProvider: String? = null
-
-    // Error codes
-    private val INTERNAL_ERROR = -1.0
-    private val PERMISSION_DENIED = 1.0
-    private val POSITION_UNAVAILABLE = 2.0
-    private val TIMEOUT = 3.0
-    private val PLAY_SERVICE_NOT_AVAILABLE = 4.0
-    private val SETTINGS_NOT_SATISFIED = 5.0
+    private val watchLocationGeneration = AtomicLong(0L)
 
     // MARK: - Configuration
 
@@ -227,6 +133,15 @@ class NitroGeolocation(
             return
         }
 
+        val permissionAware = activity as? PermissionAwareActivity
+        if (permissionAware == null) {
+            error?.invoke(createLocationError(
+                INTERNAL_ERROR,
+                "Current activity cannot request permissions"
+            ))
+            return
+        }
+
         // Queue resolver
         pendingPermissionResolvers.add(success)
 
@@ -236,10 +151,10 @@ class NitroGeolocation(
             Manifest.permission.ACCESS_COARSE_LOCATION
         )
 
-        ActivityCompat.requestPermissions(
-            activity,
+        permissionAware.requestPermissions(
             permissions,
-            PERMISSION_REQUEST_CODE
+            PERMISSION_REQUEST_CODE,
+            createPermissionListener()
         )
     }
 
@@ -272,36 +187,26 @@ class NitroGeolocation(
             return promise
         }
 
-        if (requiresPlayServices()) {
-            if (!isGooglePlayServicesAvailable()) {
-                promise.resolve(createLocationAvailability(false, "playServicesUnavailable"))
-                return promise
-            }
-
+        if (currentProviderRoute(isGooglePlayServicesAvailable()) == AndroidProviderRoute.FUSED) {
             fusedLocationClient.locationAvailability
                 .addOnSuccessListener { availability ->
-                    promise.resolve(
-                        createLocationAvailability(
-                            availability.isLocationAvailable,
-                            if (availability.isLocationAvailable) null else "fusedLocationUnavailable"
-                        )
-                    )
+                    if (availability.isLocationAvailable) {
+                        promise.resolve(createLocationAvailability(true, null))
+                        return@addOnSuccessListener
+                    }
+
+                    promise.resolve(getPlatformLocationAvailability())
                 }
-                .addOnFailureListener { exception ->
-                    promise.resolve(createLocationAvailability(
-                        false,
-                        "fusedLocationUnavailable: ${exception.message ?: "unknown error"}"
-                    ))
+                .addOnFailureListener {
+                    promise.resolve(getPlatformLocationAvailability())
                 }
                 .addOnCanceledListener {
-                    promise.resolve(createLocationAvailability(false, "fusedLocationUnavailable"))
+                    promise.resolve(getPlatformLocationAvailability())
                 }
             return promise
         }
 
-        val providers = getValidProviders(resolveAndroidAccuracy(null, enableHighAccuracy = false))
-        val reason = if (providers.isEmpty()) "noLocationProvider" else null
-        promise.resolve(createLocationAvailability(providers.isNotEmpty(), reason))
+        promise.resolve(getPlatformLocationAvailability())
         return promise
     }
 
@@ -362,16 +267,41 @@ class NitroGeolocation(
             error?.invoke(permissionError)
             return
         }
-        if (requiresPlayServices() && !isGooglePlayServicesAvailable()) {
-            error?.invoke(createPlayServicesUnavailableError())
+        val deadlineElapsedRealtime = createRequestDeadlineElapsedRealtime(parsedOptions.timeout)
+        if (currentProviderRoute(isGooglePlayServicesAvailable()) == AndroidProviderRoute.FUSED) {
+            fusedLocationProvider.getCurrentPosition(
+                success,
+                { fusedError ->
+                    runAndroidCurrentPositionFallbackAfterFusedFailure(
+                        locationProvider = configuration?.locationProvider,
+                        runPlatformFallback = {
+                            getCurrentPositionWithPlatform(
+                                success,
+                                error,
+                                parsedOptions,
+                                deadlineElapsedRealtime
+                            )
+                        },
+                        failWithoutFallback = {
+                            error?.invoke(fusedError)
+                        }
+                    )
+                },
+                parsedOptions,
+                deadlineElapsedRealtime
+            )
             return
         }
 
-        if (requiresPlayServices()) {
-            getCurrentPositionWithFused(success, error, parsedOptions)
-            return
-        }
+        getCurrentPositionWithPlatform(success, error, parsedOptions, deadlineElapsedRealtime)
+    }
 
+    private fun getCurrentPositionWithPlatform(
+        success: (GeolocationResponse) -> Unit,
+        error: ((LocationError) -> Unit)?,
+        parsedOptions: ParsedOptions,
+        deadlineElapsedRealtime: Long = createRequestDeadlineElapsedRealtime(parsedOptions.timeout)
+    ) {
         val providers = getValidProviders(parsedOptions)
         if (providers.isEmpty()) {
             error?.invoke(createNoLocationProviderError(parsedOptions))
@@ -384,8 +314,13 @@ class NitroGeolocation(
             return
         }
 
+        if (remainingTimeoutMillis(deadlineElapsedRealtime) <= 0L) {
+            error?.invoke(createPositionTimeoutError(parsedOptions))
+            return
+        }
+
         // Request fresh location
-        requestFreshLocation(providers, parsedOptions) { result ->
+        requestFreshLocation(providers, parsedOptions, deadlineElapsedRealtime) { result ->
             when (result) {
                 is PositionResult.Success -> success(result.position)
                 is PositionResult.Failure -> error?.invoke(result.error)
@@ -417,16 +352,33 @@ class NitroGeolocation(
             error?.invoke(permissionError)
             return
         }
-        if (requiresPlayServices() && !isGooglePlayServicesAvailable()) {
-            error?.invoke(createPlayServicesUnavailableError())
+        if (currentProviderRoute(isGooglePlayServicesAvailable()) == AndroidProviderRoute.FUSED) {
+            fusedLocationProvider.getLastKnownPosition(
+                success,
+                { fusedError ->
+                    runAndroidLastKnownPositionFallbackAfterFusedFailure(
+                        locationProvider = configuration?.locationProvider,
+                        runPlatformFallback = {
+                            getLastKnownPositionWithPlatform(success, error, parsedOptions)
+                        },
+                        failWithoutFallback = {
+                            error?.invoke(fusedError)
+                        }
+                    )
+                },
+                parsedOptions
+            )
             return
         }
 
-        if (requiresPlayServices()) {
-            getLastKnownPositionWithFused(success, error, parsedOptions)
-            return
-        }
+        getLastKnownPositionWithPlatform(success, error, parsedOptions)
+    }
 
+    private fun getLastKnownPositionWithPlatform(
+        success: (GeolocationResponse) -> Unit,
+        error: ((LocationError) -> Unit)?,
+        parsedOptions: ParsedOptions
+    ) {
         val providers = getValidProviders(parsedOptions)
         if (providers.isEmpty()) {
             error?.invoke(createNoLocationProviderError(parsedOptions))
@@ -466,7 +418,7 @@ class NitroGeolocation(
             @Suppress("DEPRECATION")
             geocoder.getFromLocationName(query, GEOCODER_MAX_RESULTS)
                 .orEmpty()
-                .mapNotNull { geocodedAddressToLocation(it) }
+                .mapNotNull { it.toGeocodedLocation() }
                 .toTypedArray()
         }
     }
@@ -491,7 +443,7 @@ class NitroGeolocation(
                 GEOCODER_MAX_RESULTS
             )
                 .orEmpty()
-                .map { addressToReverseGeocodedAddress(it) }
+                .map { it.toReverseGeocodedAddress() }
                 .toTypedArray()
         }
     }
@@ -730,8 +682,13 @@ class NitroGeolocation(
         return null
     }
 
-    // Handle permission request result (called from Activity)
-    fun onPermissionResult(requestCode: Int, grantResults: IntArray) {
+    private fun createPermissionListener() =
+        PermissionListener { requestCode, _, grantResults ->
+            onPermissionResult(requestCode, grantResults)
+            requestCode == PERMISSION_REQUEST_CODE
+        }
+
+    private fun onPermissionResult(requestCode: Int, grantResults: IntArray) {
         if (requestCode != PERMISSION_REQUEST_CODE) return
 
         val granted = grantResults.isNotEmpty() && grantResults.any { it == PackageManager.PERMISSION_GRANTED }
@@ -746,10 +703,13 @@ class NitroGeolocation(
 
     // MARK: - Helper Functions - Provider Selection
 
-    private fun requiresPlayServices(): Boolean {
-        // TODO: Switch auto/default Android provider selection to prefer
-        // Google Play Services when available.
-        return configuration?.locationProvider == LocationProvider.PLAYSERVICES
+    private fun currentProviderRoute(
+        googlePlayServicesAvailable: Boolean
+    ): AndroidProviderRoute {
+        return selectAndroidProviderRoute(
+            locationProvider = configuration?.locationProvider,
+            googlePlayServicesAvailable = googlePlayServicesAvailable
+        )
     }
 
     private fun isGooglePlayServicesAvailable(): Boolean {
@@ -757,6 +717,12 @@ class NitroGeolocation(
             .isGooglePlayServicesAvailable(reactContext) == ConnectionResult.SUCCESS
     }
 
+    private fun getPlatformLocationAvailability(): LocationAvailability {
+        val providers = getValidProviders(resolveAndroidAccuracy(null, enableHighAccuracy = false))
+        val reason = if (providers.isEmpty()) "noLocationProvider" else null
+        return createLocationAvailability(providers.isNotEmpty(), reason)
+    }
+
     private fun getValidProvider(accuracy: AndroidAccuracyResolution): String? {
         return getValidProviders(accuracy).firstOrNull()
     }
@@ -868,138 +834,12 @@ class NitroGeolocation(
         return bestLocation
     }
 
-    private fun getCurrentPositionWithFused(
-        success: (GeolocationResponse) -> Unit,
-        error: ((LocationError) -> Unit)?,
-        options: ParsedOptions
-    ) {
-        if (effectiveMaximumAge(options) > 0.0) {
-            getFusedCachedLocation(options) { cachedLocation ->
-                if (cachedLocation != null) {
-                    success(locationToPosition(cachedLocation))
-                    return@getFusedCachedLocation
-                }
-
-                requestFusedFreshLocation(success, error, options)
-            }
-            return
-        }
-
-        requestFusedFreshLocation(success, error, options)
-    }
-
-    private fun getLastKnownPositionWithFused(
-        success: (GeolocationResponse) -> Unit,
-        error: ((LocationError) -> Unit)?,
-        options: ParsedOptions
-    ) {
-        getFusedCachedLocation(options) { cachedLocation ->
-            if (cachedLocation != null) {
-                success(locationToPosition(cachedLocation))
-                return@getFusedCachedLocation
-            }
-
-            error?.invoke(createLocationError(
-                POSITION_UNAVAILABLE,
-                "No cached location available"
-            ))
-        }
-    }
-
-    private fun getFusedCachedLocation(
-        options: ParsedOptions,
-        completion: (Location?) -> Unit
-    ) {
-        // Fused lastLocation is not requested with LocationRequest granularity,
-        // so it cannot prove that a cached fix satisfies coarse-only callers.
-        if (options.granularity == AndroidGranularity.COARSE) {
-            completion(null)
-            return
-        }
-
-        try {
-            fusedLocationClient.lastLocation
-                .addOnSuccessListener { location ->
-                    completion(location?.takeIf { isCachedLocationValid(it, options) })
-                }
-                .addOnFailureListener {
-                    completion(null)
-                }
-                .addOnCanceledListener {
-                    completion(null)
-                }
-        } catch (e: SecurityException) {
-            completion(null)
-        }
-    }
-
-    private fun requestFusedFreshLocation(
-        success: (GeolocationResponse) -> Unit,
-        error: ((LocationError) -> Unit)?,
-        options: ParsedOptions
-    ) {
-        val handler = Handler(Looper.getMainLooper())
-        val didComplete = AtomicBoolean(false)
-        lateinit var callback: LocationCallback
-
-        fun complete(result: PositionResult) {
-            if (!didComplete.compareAndSet(false, true)) return
-
-            handler.removeCallbacksAndMessages(null)
-            try {
-                fusedLocationClient.removeLocationUpdates(callback)
-            } catch (_: Exception) {
-                // Ignore cleanup races.
-            }
-
-            when (result) {
-                is PositionResult.Success -> success(result.position)
-                is PositionResult.Failure -> error?.invoke(result.error)
-            }
-        }
-
-        callback = object : LocationCallback() {
-            override fun onLocationResult(result: LocationResult) {
-                val location = result.lastLocation
-                if (location != null) {
-                    complete(PositionResult.Success(locationToPosition(location)))
-                }
-            }
-        }
-
-        val timeoutRunnable = Runnable {
-            complete(PositionResult.Failure(createPositionTimeoutError(options)))
-        }
-
-        try {
-            fusedLocationClient.requestLocationUpdates(
-                buildFusedLocationRequest(
-                    options,
-                    maxUpdatesOverride = 1,
-                    includeDistanceFilter = false
-                ),
-                callback,
-                Looper.getMainLooper()
-            )
-            handler.postDelayed(timeoutRunnable, coerceTimeoutMillis(options.timeout))
-        } catch (e: SecurityException) {
-            complete(PositionResult.Failure(createLocationError(
-                PERMISSION_DENIED,
-                "Security exception: ${e.message}"
-            )))
-        } catch (e: Exception) {
-            complete(PositionResult.Failure(createLocationError(
-                POSITION_UNAVAILABLE,
-                "Unable to request fused location: ${e.message}"
-            )))
-        }
-    }
-
     // MARK: - Helper Functions - Request Fresh Location
 
     private fun requestFreshLocation(
         providers: List<String>,
         options: ParsedOptions,
+        deadlineElapsedRealtime: Long = createRequestDeadlineElapsedRealtime(options.timeout),
         resolver: (PositionResult) -> Unit
     ) {
         val id = UUID.randomUUID()
@@ -1011,7 +851,7 @@ class NitroGeolocation(
             options = options,
             handler = handler,
             providers = providers,
-            deadlineElapsedRealtime = createRequestDeadlineElapsedRealtime(options.timeout)
+            deadlineElapsedRealtime = deadlineElapsedRealtime
         )
 
         pendingPositionRequests[id] = request
@@ -1037,9 +877,9 @@ class NitroGeolocation(
             return
         }
 
-        // Android's getCurrentLocation may resolve a recent historical fix. A maximumAge of 0
-        // means callers explicitly asked us to wait for a fresh provider update.
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R && request.options.maximumAge > 0.0) {
+        // Android's getCurrentLocation may resolve a recent historical fix. An effective
+        // maximum age of 0 means callers explicitly asked us to wait for a fresh update.
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R && effectiveMaximumAge(request.options) > 0.0) {
             requestCurrentLocationModern(provider, requestId, request.handler, remainingTimeoutMillis)
         } else {
             requestCurrentLocationLegacy(provider, requestId, request.handler, remainingTimeoutMillis)
@@ -1070,14 +910,21 @@ class NitroGeolocation(
 
                 val request = pendingPositionRequests[requestId]
                 if (request != null) {
-                    if (location != null) {
+                    if (location != null && isCachedLocationValid(location, request.options)) {
                         pendingPositionRequests.remove(requestId)
                         val position = locationToPosition(location)
                         request.resolver(PositionResult.Success(position))
+                    } else if (location != null) {
+                        retryCurrentLocationLegacyAfterStaleModern(
+                            provider,
+                            requestId,
+                            handler,
+                            request
+                        )
                     } else {
                         handleProviderFailure(requestId, createLocationError(
                             POSITION_UNAVAILABLE,
-                            "Unable to get location"
+                            "Unable to get fresh location"
                         ))
                     }
                 }
@@ -1096,6 +943,24 @@ class NitroGeolocation(
         }
     }
 
+    private fun retryCurrentLocationLegacyAfterStaleModern(
+        provider: String,
+        requestId: UUID,
+        handler: Handler,
+        request: PositionRequest
+    ) {
+        request.cancellationSignal?.cancel()
+        request.cancellationSignal = null
+
+        val remainingTimeoutMillis = request.remainingTimeoutMillis()
+        if (remainingTimeoutMillis <= 0L) {
+            handlePositionTimeout(requestId)
+            return
+        }
+
+        requestCurrentLocationLegacy(provider, requestId, handler, remainingTimeoutMillis)
+    }
+
     private fun requestCurrentLocationLegacy(
         provider: String,
         requestId: UUID,
@@ -1234,31 +1099,41 @@ class NitroGeolocation(
     // MARK: - Helper Functions - Watch Position
 
     private fun startWatchingLocation() {
-        if (requiresPlayServices() && !isGooglePlayServicesAvailable()) {
-            notifyWatchPlayServicesUnavailable()
-            return
-        }
+        val generation = watchLocationGeneration.get()
 
-        if (requiresPlayServices()) {
-            startWatchingFusedLocation()
+        if (currentProviderRoute(isGooglePlayServicesAvailable()) == AndroidProviderRoute.FUSED) {
+            startWatchingFusedLocation(generation)
             return
         }
 
+        startWatchingPlatformLocation(generation)
+    }
+
+    private fun isActiveWatchGeneration(generation: Long): Boolean {
+        return watchSubscriptions.isNotEmpty() && watchLocationGeneration.get() == generation
+    }
+
+    private fun startWatchingPlatformLocation(generation: Long) {
+        if (!isActiveWatchGeneration(generation)) return
+
         val mergedOptions = mergeWatchOptions()
         val provider = getValidProvider(mergedOptions)
         if (provider == null) {
             notifyWatchProviderUnavailable()
             return
         }
-        currentWatchProvider = provider
 
         val listener = object : LocationListener {
             override fun onLocationChanged(location: Location) {
+                if (!isActiveWatchGeneration(generation)) return
+
                 val position = locationToPosition(location)
                 deliverWatchPosition(position)
             }
 
             override fun onProviderDisabled(provider: String) {
+                if (!isActiveWatchGeneration(generation)) return
+
                 val error = LocationError(
                     code = SETTINGS_NOT_SATISFIED,
                     message = "Provider disabled: $provider"
@@ -1274,6 +1149,7 @@ class NitroGeolocation(
             override fun onStatusChanged(provider: String?, status: Int, extras: android.os.Bundle?) {}
         }
 
+        removePlatformWatchLocationListener()
         watchLocationListener = listener
 
         try {
@@ -1296,42 +1172,53 @@ class NitroGeolocation(
         }
     }
 
-    private fun startWatchingFusedLocation() {
+    private fun startWatchingFusedLocation(generation: Long) {
+        if (!isActiveWatchGeneration(generation)) return
+
         val mergedOptions = mergeWatchOptions()
         val callback = object : LocationCallback() {
             override fun onLocationResult(result: LocationResult) {
+                if (!isActiveWatchGeneration(generation)) return
+
                 val location = result.lastLocation ?: return
-                deliverWatchPosition(locationToPosition(location))
+                deliverWatchPosition(locationToPosition(location, LocationProviderUsed.FUSED))
             }
         }
 
+        removeFusedWatchLocationCallback()
         fusedWatchLocationCallback = callback
 
-        try {
-            fusedLocationClient.requestLocationUpdates(
-                buildFusedLocationRequest(mergedOptions),
-                callback,
-                Looper.getMainLooper()
-            )
-        } catch (e: SecurityException) {
-            val error = LocationError(
-                code = PERMISSION_DENIED,
-                message = "Permission denied: ${e.message}"
-            )
+        fun handleFusedRequestFailure(fusedError: LocationError? = null) {
+            if (!isActiveWatchGeneration(generation)) return
 
-            for ((_, subscription) in watchSubscriptions) {
-                subscription.error?.invoke(error)
-            }
-        } catch (e: Exception) {
-            val error = LocationError(
-                code = POSITION_UNAVAILABLE,
-                message = "Unable to request fused location updates: ${e.message}"
+            removeFusedWatchLocationCallback()
+            runAndroidWatchPositionFallbackAfterFusedFailure(
+                locationProvider = configuration?.locationProvider,
+                runPlatformFallback = { startWatchingPlatformLocation(generation) },
+                failWithoutFallback = {
+                    if (fusedError != null) {
+                        notifyWatchError(fusedError)
+                    } else {
+                        notifyWatchProviderUnavailable()
+                    }
+                }
             )
-
-            for ((_, subscription) in watchSubscriptions) {
-                subscription.error?.invoke(error)
-            }
         }
+
+        fusedLocationProvider.requestWatchUpdates(
+            options = mergedOptions,
+            callback = callback,
+            onInactiveStart = {
+                if (!isActiveWatchGeneration(generation)) {
+                    try {
+                        fusedLocationClient.removeLocationUpdates(callback)
+                    } catch (e: Exception) {
+                        // Ignore
+                    }
+                }
+            },
+            onFailure = { fusedError -> handleFusedRequestFailure(fusedError) }
+        )
     }
 
     private fun mergeWatchOptions(): ParsedOptions {
@@ -1418,9 +1305,9 @@ class NitroGeolocation(
         }
     }
 
-    private fun notifyWatchPlayServicesUnavailable() {
+    private fun notifyWatchError(error: LocationError) {
         for ((_, subscription) in watchSubscriptions) {
-            subscription.error?.invoke(createPlayServicesUnavailableError())
+            subscription.error?.invoke(error)
         }
     }
 
@@ -1448,6 +1335,12 @@ class NitroGeolocation(
     }
 
     private fun stopWatchingLocation() {
+        watchLocationGeneration.incrementAndGet()
+        removePlatformWatchLocationListener()
+        removeFusedWatchLocationCallback()
+    }
+
+    private fun removePlatformWatchLocationListener() {
         watchLocationListener?.let { listener ->
             try {
                 locationManager.removeUpdates(listener)
@@ -1455,6 +1348,10 @@ class NitroGeolocation(
                 // Ignore
             }
         }
+        watchLocationListener = null
+    }
+
+    private fun removeFusedWatchLocationCallback() {
         fusedWatchLocationCallback?.let { callback ->
             try {
                 fusedLocationClient.removeLocationUpdates(callback)
@@ -1462,9 +1359,7 @@ class NitroGeolocation(
                 // Ignore
             }
         }
-        watchLocationListener = null
         fusedWatchLocationCallback = null
-        currentWatchProvider = null
     }
 
     private fun restartWatchingLocation() {
@@ -1474,67 +1369,13 @@ class NitroGeolocation(
 
     // MARK: - Helper Functions - Conversion
 
-    private fun locationToPosition(location: Location): GeolocationResponse {
+    private fun locationToPosition(
+        location: Location,
+        providerOverride: LocationProviderUsed? = null
+    ): GeolocationResponse {
         lastLocation = location
 
-        val coords = GeolocationCoordinates(
-            latitude = location.latitude,
-            longitude = location.longitude,
-            altitude = location.altitudeValue(),
-            accuracy = location.accuracy.toDouble(),
-            altitudeAccuracy = location.altitudeAccuracyValue(),
-            heading = location.headingValue(),
-            speed = location.speedValue()
-        )
-
-        return GeolocationResponse(
-            coords = coords,
-            timestamp = location.time.toDouble(),
-            mocked = location.isMocked(),
-            provider = location.providerUsed()
-        )
-    }
-
-    private fun geocodedAddressToLocation(address: Address): GeocodedLocation? {
-        if (!address.hasLatitude() || !address.hasLongitude()) {
-            return null
-        }
-
-        return GeocodedLocation(
-            latitude = address.latitude,
-            longitude = address.longitude,
-            accuracy = null
-        )
-    }
-
-    private fun addressToReverseGeocodedAddress(address: Address): ReverseGeocodedAddress {
-        return ReverseGeocodedAddress(
-            country = address.countryName.nonBlankOrNull(),
-            region = address.adminArea.nonBlankOrNull(),
-            city = (address.locality ?: address.subAdminArea).nonBlankOrNull(),
-            district = address.subLocality.nonBlankOrNull(),
-            street = formatStreet(address),
-            postalCode = address.postalCode.nonBlankOrNull(),
-            formattedAddress = formatAddressLines(address)
-        )
-    }
-
-    private fun formatStreet(address: Address): String? {
-        return listOf(address.subThoroughfare, address.thoroughfare)
-            .mapNotNull { it.nonBlankOrNull() }
-            .joinToString(" ")
-            .nonBlankOrNull()
-    }
-
-    private fun formatAddressLines(address: Address): String? {
-        if (address.maxAddressLineIndex < 0) {
-            return null
-        }
-
-        return (0..address.maxAddressLineIndex)
-            .mapNotNull { index -> address.getAddressLine(index).nonBlankOrNull() }
-            .joinToString(", ")
-            .nonBlankOrNull()
+        return location.toGeolocationResponse(providerOverride)
     }
 
     private fun validateGeocodingCoordinates(coords: GeocodingCoordinates): LocationError? {
@@ -1593,107 +1434,9 @@ class NitroGeolocation(
         }.start()
     }
 
-    private fun createLocationAvailability(
-        available: Boolean,
-        reason: String?
-    ): LocationAvailability {
-        return LocationAvailability(
-            available = available,
-            reason = reason
-        )
-    }
-
-    private fun createLocationError(code: Double, message: String): LocationError {
-        return LocationError(
-            code = code,
-            message = message
-        )
-    }
-
-    private fun createPlayServicesUnavailableError(): LocationError {
-        return createLocationError(
-            PLAY_SERVICE_NOT_AVAILABLE,
-            "Google Play Services location provider is not available."
-        )
-    }
-
-    private fun createPositionTimeoutError(options: ParsedOptions): LocationError {
-        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()
-        }
-    }
-
-    private fun buildFusedLocationRequest(
-        options: ParsedOptions,
-        maxUpdatesOverride: Int? = null,
-        includeDistanceFilter: Boolean = true
-    ): GmsLocationRequest {
-        val builder = GmsLocationRequest
-            .Builder(options.androidAccuracy.gmsPriority(), coercePositiveMillis(options.interval))
-            .setMinUpdateIntervalMillis(coercePositiveMillis(options.fastestInterval))
-            .setGranularity(options.granularity.gmsGranularity())
-            .setWaitForAccurateLocation(options.waitForAccurateLocation)
-            .setMaxUpdateDelayMillis(coerceNonNegativeMillis(options.maxUpdateDelay))
-
-        if (includeDistanceFilter) {
-            builder.setMinUpdateDistanceMeters(options.distanceFilter.toFloat())
-        }
-
-        options.maxUpdateAge?.let { value ->
-            builder.setMaxUpdateAgeMillis(coerceNonNegativeMillis(value))
-        }
-
-        val maxUpdates = maxUpdatesOverride ?: options.maxUpdates
-        if (maxUpdates != null) {
-            builder.setMaxUpdates(maxUpdates)
-        }
-
-        return builder.build()
-    }
-
-    private fun coercePositiveMillis(value: Double): Long {
-        return when {
-            value.isNaN() || value <= 0.0 -> 1L
-            value.isInfinite() || value >= Long.MAX_VALUE.toDouble() -> Long.MAX_VALUE
-            else -> value.toLong()
-        }
-    }
-
-    private fun coerceNonNegativeMillis(value: Double): Long {
-        return when {
-            value.isNaN() || value <= 0.0 -> 0L
-            value.isInfinite() || value >= Long.MAX_VALUE.toDouble() -> Long.MAX_VALUE
-            else -> value.toLong()
-        }
-    }
-
     companion object {
         private const val PERMISSION_REQUEST_CODE = 8947
         private const val GEOCODER_MAX_RESULTS = 5
         private const val TWO_MINUTES_MS = 2 * 60 * 1000L
     }
 }
-
-private fun String?.nonBlankOrNull(): String? {
-    return this?.trim()?.takeIf { it.isNotEmpty() }
-}