react-native-nitro-geolocation 1.2.6 → 1.3.1

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

@@ -0,0 +1,310 @@
+package com.margelo.nitro.nitrogeolocation
+
+import android.location.Location
+import android.os.Handler
+import android.os.Looper
+import com.google.android.gms.location.CurrentLocationRequest
+import com.google.android.gms.location.FusedLocationProviderClient
+import com.google.android.gms.location.LocationCallback
+import com.google.android.gms.location.LocationResult
+import com.google.android.gms.tasks.CancellationTokenSource
+import java.util.concurrent.atomic.AtomicBoolean
+
+private const val FUSED_ATTEMPT_TIMEOUT_MS = 15_000L
+private const val FUSED_FALLBACK_RESERVED_TIMEOUT_MS = 10_000L
+
+internal class AndroidFusedLocationProvider(
+    private val fusedLocationClient: FusedLocationProviderClient,
+    private val isCachedLocationValid: (Location, ParsedOptions) -> Boolean,
+    private val effectiveMaximumAge: (ParsedOptions) -> Double,
+    private val locationToPosition: (Location, LocationProviderUsed?) -> GeolocationResponse
+) {
+    fun getCurrentPosition(
+        success: (GeolocationResponse) -> Unit,
+        error: ((LocationError) -> Unit)?,
+        options: ParsedOptions,
+        deadlineElapsedRealtime: Long
+    ) {
+        if (effectiveMaximumAge(options) > 0.0) {
+            getCachedLocation(options) { cachedLocation, fusedError ->
+                if (cachedLocation != null) {
+                    success(locationToPosition(cachedLocation, LocationProviderUsed.FUSED))
+                    return@getCachedLocation
+                }
+                if (fusedError != null) {
+                    error?.invoke(fusedError)
+                    return@getCachedLocation
+                }
+
+                requestFreshLocation(success, error, options, deadlineElapsedRealtime)
+            }
+            return
+        }
+
+        requestFreshLocation(success, error, options, deadlineElapsedRealtime)
+    }
+
+    fun getLastKnownPosition(
+        success: (GeolocationResponse) -> Unit,
+        error: ((LocationError) -> Unit)?,
+        options: ParsedOptions
+    ) {
+        getCachedLocation(options) { cachedLocation, fusedError ->
+            if (cachedLocation != null) {
+                success(locationToPosition(cachedLocation, LocationProviderUsed.FUSED))
+                return@getCachedLocation
+            }
+            if (fusedError != null) {
+                error?.invoke(fusedError)
+                return@getCachedLocation
+            }
+
+            error?.invoke(createLocationError(
+                POSITION_UNAVAILABLE,
+                "No cached location available"
+            ))
+        }
+    }
+
+    fun requestWatchUpdates(
+        options: ParsedOptions,
+        callback: LocationCallback,
+        onInactiveStart: () -> Unit,
+        onFailure: (LocationError?) -> Unit
+    ) {
+        try {
+            fusedLocationClient.requestLocationUpdates(
+                buildFusedLocationRequest(options),
+                callback,
+                Looper.getMainLooper()
+            )
+                .addOnSuccessListener {
+                    onInactiveStart()
+                }
+                .addOnFailureListener { exception ->
+                    onFailure(createFusedRequestFailureError(exception))
+                }
+                .addOnCanceledListener {
+                    onFailure(null)
+                }
+        } catch (e: SecurityException) {
+            onFailure(createFusedSecurityError(e.message))
+        } catch (_: Exception) {
+            onFailure(null)
+        }
+    }
+
+    private fun getCachedLocation(
+        options: ParsedOptions,
+        completion: (Location?, LocationError?) -> 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, null)
+            return
+        }
+
+        try {
+            fusedLocationClient.lastLocation
+                .addOnSuccessListener { location ->
+                    completion(location?.takeIf { isCachedLocationValid(it, options) }, null)
+                }
+                .addOnFailureListener { exception ->
+                    completion(null, createPermissionErrorOrNull(exception))
+                }
+                .addOnCanceledListener {
+                    completion(null, null)
+                }
+        } catch (e: SecurityException) {
+            completion(null, createFusedSecurityError(e.message))
+        }
+    }
+
+    private fun requestFreshLocation(
+        success: (GeolocationResponse) -> Unit,
+        error: ((LocationError) -> Unit)?,
+        options: ParsedOptions,
+        deadlineElapsedRealtime: Long
+    ) {
+        val handler = Handler(Looper.getMainLooper())
+        val didComplete = AtomicBoolean(false)
+        val remainingTimeoutMillis = remainingTimeoutMillis(deadlineElapsedRealtime)
+
+        if (remainingTimeoutMillis <= 0L) {
+            error?.invoke(createPositionTimeoutError(options))
+            return
+        }
+        val fusedAttemptTimeoutMillis = fusedAttemptTimeoutMillis(remainingTimeoutMillis)
+        val cancellationTokenSource = CancellationTokenSource()
+        var locationUpdateCallback: LocationCallback? = null
+
+        fun complete(result: PositionResult) {
+            if (!didComplete.compareAndSet(false, true)) return
+
+            handler.removeCallbacksAndMessages(null)
+            locationUpdateCallback?.let { callback ->
+                try {
+                    fusedLocationClient.removeLocationUpdates(callback)
+                } catch (_: Exception) {
+                    // Ignore cleanup races.
+                }
+            }
+            locationUpdateCallback = null
+            try {
+                cancellationTokenSource.cancel()
+            } catch (_: Exception) {
+                // Ignore cleanup races.
+            }
+
+            when (result) {
+                is PositionResult.Success -> success(result.position)
+                is PositionResult.Failure -> error?.invoke(result.error)
+            }
+        }
+
+        val timeoutRunnable = Runnable {
+            complete(PositionResult.Failure(createPositionTimeoutError(options)))
+        }
+
+        try {
+            if (options.waitForAccurateLocation) {
+                val initialUpdateMaxAge = fusedInitialUpdateMaxAge(
+                    options,
+                    effectiveMaximumAge(options)
+                )
+                val request = buildFusedLocationRequest(
+                    options.copy(maxUpdateAge = initialUpdateMaxAge),
+                    maxUpdatesOverride = 1,
+                    includeDistanceFilter = false
+                )
+                val callback = object : LocationCallback() {
+                    override fun onLocationResult(result: LocationResult) {
+                        val location = result.lastLocation
+                        if (location != null) {
+                            complete(PositionResult.Success(
+                                locationToPosition(location, LocationProviderUsed.FUSED)
+                            ))
+                        } else {
+                            complete(PositionResult.Failure(createLocationError(
+                                POSITION_UNAVAILABLE,
+                                "Unable to get fused location"
+                            )))
+                        }
+                    }
+                }
+                locationUpdateCallback = callback
+
+                fusedLocationClient.requestLocationUpdates(
+                    request,
+                    callback,
+                    Looper.getMainLooper()
+                )
+                    .addOnFailureListener { exception ->
+                        complete(PositionResult.Failure(
+                            createFusedRequestFailureError(exception)
+                        ))
+                    }
+                    .addOnCanceledListener {
+                        complete(PositionResult.Failure(createPositionTimeoutError(options)))
+                    }
+
+                handler.postDelayed(timeoutRunnable, fusedAttemptTimeoutMillis)
+                return
+            }
+
+            val request = CurrentLocationRequest.Builder()
+                .setPriority(options.androidAccuracy.gmsPriority())
+                .setGranularity(options.granularity.gmsGranularity())
+                .setMaxUpdateAgeMillis(
+                    coerceNonNegativeMillis(
+                        fusedInitialUpdateMaxAge(options, effectiveMaximumAge(options))
+                    )
+                )
+                .setDurationMillis(fusedAttemptTimeoutMillis)
+                .build()
+
+            fusedLocationClient.getCurrentLocation(
+                request,
+                cancellationTokenSource.token
+            )
+                .addOnSuccessListener { location ->
+                    if (location != null) {
+                        complete(PositionResult.Success(
+                            locationToPosition(location, LocationProviderUsed.FUSED)
+                        ))
+                    } else {
+                        complete(PositionResult.Failure(createLocationError(
+                            POSITION_UNAVAILABLE,
+                            "Unable to get fused location"
+                        )))
+                    }
+                }
+                .addOnFailureListener { exception ->
+                    complete(PositionResult.Failure(
+                        createFusedRequestFailureError(exception)
+                    ))
+                }
+                .addOnCanceledListener {
+                    complete(PositionResult.Failure(createPositionTimeoutError(options)))
+                }
+
+            handler.postDelayed(timeoutRunnable, fusedAttemptTimeoutMillis)
+        } catch (e: SecurityException) {
+            complete(PositionResult.Failure(createFusedSecurityError(e.message)))
+        } catch (e: Exception) {
+            complete(PositionResult.Failure(createLocationError(
+                POSITION_UNAVAILABLE,
+                "Unable to request fused location: ${e.message}"
+            )))
+        }
+    }
+
+    private fun createPermissionErrorOrNull(exception: Exception): LocationError? {
+        return if (exception is SecurityException) {
+            createFusedSecurityError(exception.message)
+        } else {
+            null
+        }
+    }
+}
+
+internal fun createFusedRequestFailureError(exception: Exception): LocationError {
+    return if (exception is SecurityException) {
+        createFusedSecurityError(exception.message)
+    } else {
+        createLocationError(
+            POSITION_UNAVAILABLE,
+            "Unable to request fused location: ${exception.message}"
+        )
+    }
+}
+
+internal fun createFusedSecurityError(message: String?): LocationError {
+    return createLocationError(
+        PERMISSION_DENIED,
+        "Security exception: ${message ?: "unknown error"}"
+    )
+}
+
+internal fun fusedInitialUpdateMaxAge(
+    options: ParsedOptions,
+    effectiveMaximumAge: Double
+): Double {
+    return options.maxUpdateAge ?: effectiveMaximumAge
+}
+
+private fun fusedAttemptTimeoutMillis(remainingTimeoutMillis: Long): Long {
+    if (remainingTimeoutMillis == Long.MAX_VALUE) {
+        return FUSED_ATTEMPT_TIMEOUT_MS
+    }
+
+    if (remainingTimeoutMillis <= FUSED_FALLBACK_RESERVED_TIMEOUT_MS) {
+        return (remainingTimeoutMillis / 2L).coerceAtLeast(1L)
+    }
+
+    return minOf(
+        FUSED_ATTEMPT_TIMEOUT_MS,
+        (remainingTimeoutMillis - FUSED_FALLBACK_RESERVED_TIMEOUT_MS).coerceAtLeast(1L)
+    )
+}

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

@@ -0,0 +1,31 @@
+package com.margelo.nitro.nitrogeolocation
+
+import com.google.android.gms.location.LocationRequest as GmsLocationRequest
+
+internal 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()
+}

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

@@ -0,0 +1,71 @@
+package com.margelo.nitro.nitrogeolocation
+
+import android.location.Address
+import android.location.Location
+
+internal fun Location.toGeolocationResponse(
+    providerOverride: LocationProviderUsed? = null
+): GeolocationResponse {
+    val coords = GeolocationCoordinates(
+        latitude = latitude,
+        longitude = longitude,
+        altitude = altitudeValue(),
+        accuracy = accuracy.toDouble(),
+        altitudeAccuracy = altitudeAccuracyValue(),
+        heading = headingValue(),
+        speed = speedValue()
+    )
+
+    return GeolocationResponse(
+        coords = coords,
+        timestamp = time.toDouble(),
+        mocked = isMocked(),
+        provider = providerOverride ?: providerUsed()
+    )
+}
+
+internal fun Address.toGeocodedLocation(): GeocodedLocation? {
+    if (!hasLatitude() || !hasLongitude()) {
+        return null
+    }
+
+    return GeocodedLocation(
+        latitude = latitude,
+        longitude = longitude,
+        accuracy = null
+    )
+}
+
+internal fun Address.toReverseGeocodedAddress(): ReverseGeocodedAddress {
+    return ReverseGeocodedAddress(
+        country = countryName.nonBlankOrNull(),
+        region = adminArea.nonBlankOrNull(),
+        city = (locality ?: subAdminArea).nonBlankOrNull(),
+        district = subLocality.nonBlankOrNull(),
+        street = formatStreet(),
+        postalCode = postalCode.nonBlankOrNull(),
+        formattedAddress = formatAddressLines()
+    )
+}
+
+internal fun Address.formatStreet(): String? {
+    return listOf(subThoroughfare, thoroughfare)
+        .mapNotNull { it.nonBlankOrNull() }
+        .joinToString(" ")
+        .nonBlankOrNull()
+}
+
+internal fun Address.formatAddressLines(): String? {
+    if (maxAddressLineIndex < 0) {
+        return null
+    }
+
+    return (0..maxAddressLineIndex)
+        .mapNotNull { index -> getAddressLine(index).nonBlankOrNull() }
+        .joinToString(", ")
+        .nonBlankOrNull()
+}
+
+internal fun String?.nonBlankOrNull(): String? {
+    return this?.trim()?.takeIf { it.isNotEmpty() }
+}

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

@@ -0,0 +1,85 @@
+package com.margelo.nitro.nitrogeolocation
+
+import android.os.SystemClock
+
+internal const val NO_LOCATION_PROVIDER_AVAILABLE_MESSAGE = "No location provider available"
+internal 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."
+
+internal const val INTERNAL_ERROR = -1.0
+internal const val PERMISSION_DENIED = 1.0
+internal const val POSITION_UNAVAILABLE = 2.0
+internal const val TIMEOUT = 3.0
+internal const val PLAY_SERVICE_NOT_AVAILABLE = 4.0
+internal const val SETTINGS_NOT_SATISFIED = 5.0
+
+internal fun createLocationAvailability(
+    available: Boolean,
+    reason: String?
+): LocationAvailability {
+    return LocationAvailability(
+        available = available,
+        reason = reason
+    )
+}
+
+internal fun createLocationError(code: Double, message: String): LocationError {
+    return LocationError(
+        code = code,
+        message = message
+    )
+}
+
+internal fun createPlayServicesUnavailableError(): LocationError {
+    return createLocationError(
+        PLAY_SERVICE_NOT_AVAILABLE,
+        "Google Play Services location provider is not available."
+    )
+}
+
+internal 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)
+}
+
+internal 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
+    }
+}
+
+internal fun remainingTimeoutMillis(deadlineElapsedRealtime: Long): Long {
+    return (deadlineElapsedRealtime - SystemClock.elapsedRealtime()).coerceAtLeast(0L)
+}
+
+internal 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()
+    }
+}
+
+internal 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()
+    }
+}
+
+internal 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()
+    }
+}

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

@@ -0,0 +1,92 @@
+package com.margelo.nitro.nitrogeolocation
+
+import android.os.CancellationSignal
+import android.os.Handler
+import android.os.SystemClock
+import java.util.UUID
+
+internal 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)
+        }
+    }
+}
+
+internal data class WatchSubscription(
+    val token: String,
+    val success: (GeolocationResponse) -> Unit,
+    val error: ((LocationError) -> Unit)?,
+    val options: ParsedOptions,
+    var deliveredUpdates: Int = 0
+)
+
+internal sealed interface PositionResult {
+    data class Success(val position: GeolocationResponse) : PositionResult
+    data class Failure(val error: LocationError) : PositionResult
+}
+
+internal 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)
+    }
+}

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

@@ -134,12 +134,15 @@ internal class AndroidLocationSettings(
     private fun createProviderStatus(
         googleLocationAccuracyEnabled: Boolean?
     ): LocationProviderStatus {
+        val googlePlayServicesAvailable = isGooglePlayServicesAvailable()
+
         return LocationProviderStatus(
             locationServicesEnabled = hasServicesEnabled(),
             backgroundModeEnabled = hasBackgroundLocationPermission(),
             gpsAvailable = isProviderEnabled(AndroidLocationManager.GPS_PROVIDER),
             networkAvailable = isProviderEnabled(AndroidLocationManager.NETWORK_PROVIDER),
             passiveAvailable = isProviderEnabled(AndroidLocationManager.PASSIVE_PROVIDER),
+            googlePlayServicesAvailable = googlePlayServicesAvailable,
             googleLocationAccuracyEnabled = googleLocationAccuracyEnabled
         )
     }

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

@@ -0,0 +1,74 @@
+package com.margelo.nitro.nitrogeolocation
+
+internal enum class AndroidProviderRoute {
+    FUSED,
+    PLATFORM
+}
+
+internal fun selectAndroidProviderRoute(
+    locationProvider: LocationProvider?,
+    googlePlayServicesAvailable: Boolean
+): AndroidProviderRoute {
+    if (locationProvider == LocationProvider.ANDROID_PLATFORM) {
+        return AndroidProviderRoute.PLATFORM
+    }
+
+    return if (googlePlayServicesAvailable) {
+        AndroidProviderRoute.FUSED
+    } else {
+        AndroidProviderRoute.PLATFORM
+    }
+}
+
+internal fun selectAndroidFallbackRouteAfterFusedFailure(
+    @Suppress("UNUSED_PARAMETER") locationProvider: LocationProvider?
+): AndroidProviderRoute {
+    return AndroidProviderRoute.PLATFORM
+}
+
+private fun runAndroidProviderFallbackAfterFusedFailure(
+    locationProvider: LocationProvider?,
+    runPlatformFallback: () -> Unit,
+    failWithoutFallback: () -> Unit
+) {
+    when (selectAndroidFallbackRouteAfterFusedFailure(locationProvider)) {
+        AndroidProviderRoute.PLATFORM -> runPlatformFallback()
+        AndroidProviderRoute.FUSED -> failWithoutFallback()
+    }
+}
+
+internal fun runAndroidCurrentPositionFallbackAfterFusedFailure(
+    locationProvider: LocationProvider?,
+    runPlatformFallback: () -> Unit,
+    failWithoutFallback: () -> Unit
+) {
+    runAndroidProviderFallbackAfterFusedFailure(
+        locationProvider = locationProvider,
+        runPlatformFallback = runPlatformFallback,
+        failWithoutFallback = failWithoutFallback
+    )
+}
+
+internal fun runAndroidLastKnownPositionFallbackAfterFusedFailure(
+    locationProvider: LocationProvider?,
+    runPlatformFallback: () -> Unit,
+    failWithoutFallback: () -> Unit
+) {
+    runAndroidProviderFallbackAfterFusedFailure(
+        locationProvider = locationProvider,
+        runPlatformFallback = runPlatformFallback,
+        failWithoutFallback = failWithoutFallback
+    )
+}
+
+internal fun runAndroidWatchPositionFallbackAfterFusedFailure(
+    locationProvider: LocationProvider?,
+    runPlatformFallback: () -> Unit,
+    failWithoutFallback: () -> Unit
+) {
+    runAndroidProviderFallbackAfterFusedFailure(
+        locationProvider = locationProvider,
+        runPlatformFallback = runPlatformFallback,
+        failWithoutFallback = failWithoutFallback
+    )
+}