react-native-nitro-geolocation 1.1.4 → 1.2.1

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

@@ -0,0 +1,313 @@
+package com.margelo.nitro.nitrogeolocation
+
+import android.Manifest
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import android.content.IntentSender
+import android.content.pm.PackageManager
+import android.location.LocationManager as AndroidLocationManager
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.BaseActivityEventListener
+import com.facebook.react.bridge.ReactApplicationContext
+import com.google.android.gms.common.ConnectionResult
+import com.google.android.gms.common.GoogleApiAvailability
+import com.google.android.gms.common.api.ResolvableApiException
+import com.google.android.gms.location.LocationRequest as GmsLocationRequest
+import com.google.android.gms.location.LocationServices
+import com.google.android.gms.location.LocationSettingsRequest
+import com.google.android.gms.location.Priority
+import java.util.concurrent.atomic.AtomicBoolean
+
+private const val LOCATION_SETTINGS_REQUEST_CODE = 8948
+private const val GOOGLE_LOCATION_ACCURACY_TIMEOUT_MS = 2_000L
+
+internal class AndroidLocationSettings(
+    private val reactContext: ReactApplicationContext,
+    private val locationManager: AndroidLocationManager,
+    private val createLocationError: (Double, String) -> LocationError,
+    private val createPlayServicesUnavailableError: () -> LocationError
+) {
+    private data class ParsedSettingsOptions(
+        val androidAccuracy: AndroidAccuracyResolution,
+        val intervalMillis: Long,
+        val fastestIntervalMillis: Long,
+        val distanceFilterMeters: Float,
+        val alwaysShow: Boolean,
+        val needBle: Boolean
+    ) {
+        companion object {
+            private const val DEFAULT_INTERVAL_MS = 5_000.0
+            private const val DEFAULT_FASTEST_INTERVAL_MS = 1_000.0
+            private const val DEFAULT_DISTANCE_FILTER_METERS = 0.0
+
+            fun parse(options: LocationSettingsOptions?): ParsedSettingsOptions {
+                val enableHighAccuracy = options?.enableHighAccuracy ?: true
+                return ParsedSettingsOptions(
+                    androidAccuracy = resolveAndroidAccuracy(
+                        options?.accuracy,
+                        enableHighAccuracy
+                    ),
+                    intervalMillis = coercePositiveMillis(
+                        options?.interval,
+                        DEFAULT_INTERVAL_MS
+                    ),
+                    fastestIntervalMillis = coercePositiveMillis(
+                        options?.fastestInterval,
+                        DEFAULT_FASTEST_INTERVAL_MS
+                    ),
+                    distanceFilterMeters = (options?.distanceFilter
+                        ?: DEFAULT_DISTANCE_FILTER_METERS)
+                        .coerceAtLeast(0.0)
+                        .toFloat(),
+                    alwaysShow = options?.alwaysShow ?: true,
+                    needBle = options?.needBle ?: false
+                )
+            }
+
+            private fun coercePositiveMillis(value: Double?, defaultValue: Double): Long {
+                val nextValue = value ?: defaultValue
+                return when {
+                    nextValue.isNaN() || nextValue <= 0.0 -> defaultValue.toLong()
+                    nextValue.isInfinite() || nextValue >= Long.MAX_VALUE.toDouble() -> Long.MAX_VALUE
+                    else -> nextValue.toLong()
+                }
+            }
+        }
+    }
+
+    private data class PendingLocationSettingsRequest(
+        val success: (LocationProviderStatus) -> Unit,
+        val error: ((LocationError) -> Unit)?,
+        val options: ParsedSettingsOptions
+    )
+
+    private var pendingLocationSettingsRequest: PendingLocationSettingsRequest? = null
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    private val activityEventListener = object : BaseActivityEventListener() {
+        override fun onActivityResult(
+            activity: Activity,
+            requestCode: Int,
+            resultCode: Int,
+            data: Intent?
+        ) {
+            if (requestCode != LOCATION_SETTINGS_REQUEST_CODE) return
+
+            val pendingRequest = pendingLocationSettingsRequest ?: return
+            pendingLocationSettingsRequest = null
+
+            if (resultCode == Activity.RESULT_OK) {
+                checkLocationSettings(pendingRequest, shouldShowResolution = false)
+                return
+            }
+
+            pendingRequest.error?.invoke(createLocationError(
+                SETTINGS_NOT_SATISFIED,
+                "Location settings change was cancelled."
+            ))
+        }
+    }
+
+    init {
+        reactContext.addActivityEventListener(activityEventListener)
+    }
+
+    fun hasServicesEnabled(): Boolean {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+            locationManager.isLocationEnabled
+        } else {
+            isProviderEnabled(AndroidLocationManager.GPS_PROVIDER) ||
+                isProviderEnabled(AndroidLocationManager.NETWORK_PROVIDER)
+        }
+    }
+
+    fun getProviderStatus(success: (LocationProviderStatus) -> Unit) {
+        getGoogleLocationAccuracyEnabled { googleLocationAccuracyEnabled ->
+            success(createProviderStatus(googleLocationAccuracyEnabled))
+        }
+    }
+
+    private fun createProviderStatus(
+        googleLocationAccuracyEnabled: Boolean?
+    ): LocationProviderStatus {
+        return LocationProviderStatus(
+            locationServicesEnabled = hasServicesEnabled(),
+            backgroundModeEnabled = hasBackgroundLocationPermission(),
+            gpsAvailable = isProviderEnabled(AndroidLocationManager.GPS_PROVIDER),
+            networkAvailable = isProviderEnabled(AndroidLocationManager.NETWORK_PROVIDER),
+            passiveAvailable = isProviderEnabled(AndroidLocationManager.PASSIVE_PROVIDER),
+            googleLocationAccuracyEnabled = googleLocationAccuracyEnabled
+        )
+    }
+
+    fun requestLocationSettings(
+        success: (LocationProviderStatus) -> Unit,
+        error: ((LocationError) -> Unit)?,
+        options: LocationSettingsOptions?
+    ) {
+        if (!isGooglePlayServicesAvailable()) {
+            error?.invoke(createPlayServicesUnavailableError())
+            return
+        }
+
+        if (pendingLocationSettingsRequest != null) {
+            error?.invoke(createLocationError(
+                INTERNAL_ERROR,
+                "A location settings request is already in progress."
+            ))
+            return
+        }
+
+        val pendingRequest = PendingLocationSettingsRequest(
+            success = success,
+            error = error,
+            options = ParsedSettingsOptions.parse(options)
+        )
+
+        checkLocationSettings(pendingRequest, shouldShowResolution = true)
+    }
+
+    private fun checkLocationSettings(
+        pendingRequest: PendingLocationSettingsRequest,
+        shouldShowResolution: Boolean
+    ) {
+        val settingsClient = LocationServices.getSettingsClient(reactContext)
+        settingsClient
+            .checkLocationSettings(buildLocationSettingsRequest(pendingRequest.options))
+            .addOnSuccessListener {
+                getProviderStatus(pendingRequest.success)
+            }
+            .addOnFailureListener { exception ->
+                if (shouldShowResolution && exception is ResolvableApiException) {
+                    showResolutionDialog(exception, pendingRequest)
+                    return@addOnFailureListener
+                }
+
+                pendingRequest.error?.invoke(createLocationError(
+                    SETTINGS_NOT_SATISFIED,
+                    "Location settings do not satisfy the requested options."
+                ))
+            }
+    }
+
+    private fun showResolutionDialog(
+        exception: ResolvableApiException,
+        pendingRequest: PendingLocationSettingsRequest
+    ) {
+        val activity = reactContext.currentActivity
+        if (activity == null) {
+            pendingRequest.error?.invoke(createLocationError(
+                INTERNAL_ERROR,
+                "No activity available to request location settings."
+            ))
+            return
+        }
+
+        pendingLocationSettingsRequest = pendingRequest
+
+        try {
+            exception.startResolutionForResult(activity, LOCATION_SETTINGS_REQUEST_CODE)
+        } catch (e: IntentSender.SendIntentException) {
+            pendingLocationSettingsRequest = null
+            pendingRequest.error?.invoke(createLocationError(
+                INTERNAL_ERROR,
+                "Failed to show location settings dialog: ${e.message}"
+            ))
+        }
+    }
+
+    private fun buildLocationSettingsRequest(
+        options: ParsedSettingsOptions
+    ): LocationSettingsRequest {
+        val priority = when (options.androidAccuracy.mode) {
+            AndroidAccuracyMode.HIGH -> Priority.PRIORITY_HIGH_ACCURACY
+            AndroidAccuracyMode.BALANCED -> Priority.PRIORITY_BALANCED_POWER_ACCURACY
+            AndroidAccuracyMode.LOW -> Priority.PRIORITY_LOW_POWER
+            AndroidAccuracyMode.PASSIVE -> Priority.PRIORITY_PASSIVE
+        }
+
+        val request = GmsLocationRequest
+            .Builder(priority, options.intervalMillis)
+            .setMinUpdateIntervalMillis(options.fastestIntervalMillis)
+            .setMinUpdateDistanceMeters(options.distanceFilterMeters)
+            .build()
+
+        return LocationSettingsRequest
+            .Builder()
+            .addLocationRequest(request)
+            .setAlwaysShow(options.alwaysShow)
+            .setNeedBle(options.needBle)
+            .build()
+    }
+
+    private fun isProviderEnabled(provider: String): Boolean {
+        return try {
+            locationManager.isProviderEnabled(provider)
+        } catch (e: Exception) {
+            false
+        }
+    }
+
+    private fun hasBackgroundLocationPermission(): Boolean {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) return true
+
+        return ContextCompat.checkSelfPermission(
+            reactContext,
+            Manifest.permission.ACCESS_BACKGROUND_LOCATION
+        ) == PackageManager.PERMISSION_GRANTED
+    }
+
+    private fun getGoogleLocationAccuracyEnabled(success: (Boolean?) -> Unit) {
+        if (!isGooglePlayServicesAvailable()) {
+            success(null)
+            return
+        }
+
+        val didComplete = AtomicBoolean(false)
+        val timeoutRunnable = Runnable {
+            if (didComplete.compareAndSet(false, true)) {
+                success(null)
+            }
+        }
+
+        fun complete(value: Boolean?) {
+            if (didComplete.compareAndSet(false, true)) {
+                mainHandler.removeCallbacks(timeoutRunnable)
+                success(value)
+            }
+        }
+
+        mainHandler.postDelayed(timeoutRunnable, GOOGLE_LOCATION_ACCURACY_TIMEOUT_MS)
+
+        try {
+            LocationServices
+                .getSettingsClient(reactContext)
+                .isGoogleLocationAccuracyEnabled
+                .addOnSuccessListener { enabled ->
+                    complete(enabled)
+                }
+                .addOnFailureListener {
+                    complete(null)
+                }
+                .addOnCanceledListener {
+                    complete(null)
+                }
+        } catch (e: Exception) {
+            complete(null)
+        }
+    }
+
+    private fun isGooglePlayServicesAvailable(): Boolean {
+        return GoogleApiAvailability.getInstance()
+            .isGooglePlayServicesAvailable(reactContext) == ConnectionResult.SUCCESS
+    }
+
+    private companion object {
+        private const val INTERNAL_ERROR = -1.0
+        private const val SETTINGS_NOT_SATISFIED = 5.0
+    }
+}

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

@@ -16,9 +16,9 @@ import com.facebook.react.bridge.ReactApplicationContext
 class GetCurrentPosition(private val reactContext: ReactApplicationContext) {
 
     fun execute(
-            success: (position: GeolocationResponse) -> Unit,
-            error: ((error: GeolocationError) -> Unit)?,
-            options: GeolocationOptions?
+            success: (position: CompatGeolocationResponse) -> Unit,
+            error: ((error: CompatGeolocationError) -> Unit)?,
+            options: CompatGeolocationOptions?
     ) {
         val locationManager =
                 reactContext.getSystemService(Context.LOCATION_SERVICE) as? LocationManager
@@ -29,7 +29,7 @@ class GetCurrentPosition(private val reactContext: ReactApplicationContext) {
         }
 
         val opts = parseOptions(options)
-        val provider = getValidProvider(locationManager, opts.enableHighAccuracy)
+        val provider = getValidProvider(locationManager, opts.androidAccuracy)
 
         if (provider == null) {
             Log.e(TAG, "No location provider available")
@@ -64,11 +64,15 @@ class GetCurrentPosition(private val reactContext: ReactApplicationContext) {
 
     // ===== Helper Functions =====
 
-    private fun parseOptions(options: GeolocationOptions?): ParsedOptions {
+    private fun parseOptions(options: CompatGeolocationOptions?): ParsedOptions {
         return ParsedOptions(
                 timeout = options?.timeout ?: DEFAULT_TIMEOUT,
                 maximumAge = options?.maximumAge ?: DEFAULT_MAXIMUM_AGE,
-                enableHighAccuracy = options?.enableHighAccuracy ?: false
+                androidAccuracy =
+                        resolveAndroidAccuracy(
+                                options?.accuracy,
+                                options?.enableHighAccuracy ?: false
+                        )
         )
     }
 
@@ -77,37 +81,42 @@ class GetCurrentPosition(private val reactContext: ReactApplicationContext) {
         return age < options.maximumAge
     }
 
-    private fun getValidProvider(locationManager: LocationManager, highAccuracy: Boolean): String? {
-        val preferredProvider =
-                if (highAccuracy) LocationManager.GPS_PROVIDER else LocationManager.NETWORK_PROVIDER
-        val fallbackProvider =
-                if (highAccuracy) LocationManager.NETWORK_PROVIDER else LocationManager.GPS_PROVIDER
-
-        return when {
-            isProviderValid(locationManager, preferredProvider) -> preferredProvider
-            isProviderValid(locationManager, fallbackProvider) -> fallbackProvider
-            else -> null
+    private fun getValidProvider(
+            locationManager: LocationManager,
+            accuracy: AndroidAccuracyResolution
+    ): String? {
+        return accuracy.providerOrder().firstOrNull { provider ->
+            isProviderValid(locationManager, provider)
         }
     }
 
     private fun isProviderValid(locationManager: LocationManager, provider: String): Boolean {
         if (!locationManager.isProviderEnabled(provider)) return false
 
-        val permission =
-                if (provider == LocationManager.GPS_PROVIDER)
+        val fineGranted =
+                ContextCompat.checkSelfPermission(
+                        reactContext,
                         Manifest.permission.ACCESS_FINE_LOCATION
-                else Manifest.permission.ACCESS_COARSE_LOCATION
-
-        return ContextCompat.checkSelfPermission(reactContext, permission) ==
-                PackageManager.PERMISSION_GRANTED
+                ) == PackageManager.PERMISSION_GRANTED
+        val coarseGranted =
+                ContextCompat.checkSelfPermission(
+                        reactContext,
+                        Manifest.permission.ACCESS_COARSE_LOCATION
+                ) == PackageManager.PERMISSION_GRANTED
+
+        return if (provider == LocationManager.GPS_PROVIDER) {
+            fineGranted
+        } else {
+            coarseGranted || fineGranted
+        }
     }
 
     private fun requestFreshLocation(
             locationManager: LocationManager,
             provider: String,
             options: ParsedOptions,
-            success: (GeolocationResponse) -> Unit,
-            error: ((GeolocationError) -> Unit)?,
+            success: (CompatGeolocationResponse) -> Unit,
+            error: ((CompatGeolocationError) -> Unit)?,
             fallbackLocation: Location?
     ) {
         if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.R) {
@@ -138,8 +147,8 @@ class GetCurrentPosition(private val reactContext: ReactApplicationContext) {
             locationManager: LocationManager,
             provider: String,
             options: ParsedOptions,
-            success: (GeolocationResponse) -> Unit,
-            error: ((GeolocationError) -> Unit)?,
+            success: (CompatGeolocationResponse) -> Unit,
+            error: ((CompatGeolocationError) -> Unit)?,
             fallbackLocation: Location?
     ) {
         val handler = Handler(Looper.getMainLooper())
@@ -187,8 +196,8 @@ class GetCurrentPosition(private val reactContext: ReactApplicationContext) {
             locationManager: LocationManager,
             provider: String,
             options: ParsedOptions,
-            success: (GeolocationResponse) -> Unit,
-            error: ((GeolocationError) -> Unit)?,
+            success: (CompatGeolocationResponse) -> Unit,
+            error: ((CompatGeolocationError) -> Unit)?,
             fallbackLocation: Location?
     ) {
         val handler = Handler(Looper.getMainLooper())
@@ -285,32 +294,24 @@ class GetCurrentPosition(private val reactContext: ReactApplicationContext) {
 
     // ===== Data Conversion =====
 
-    private fun locationToPosition(location: Location): GeolocationResponse {
-        return GeolocationResponse(
+    private fun locationToPosition(location: Location): CompatGeolocationResponse {
+        return CompatGeolocationResponse(
                 coords =
                         GeolocationCoordinates(
                                 latitude = location.latitude,
                                 longitude = location.longitude,
-                                altitude = if (location.hasAltitude()) NullableDouble.create(location.altitude) else null,
+                                altitude = location.altitudeValue(),
                                 accuracy = location.accuracy.toDouble(),
-                                altitudeAccuracy =
-                                        if (android.os.Build.VERSION.SDK_INT >=
-                                                        android.os.Build.VERSION_CODES.O &&
-                                                        location.hasVerticalAccuracy()
-                                        )
-                                                NullableDouble.create(location.verticalAccuracyMeters.toDouble())
-                                        else null,
-                                heading =
-                                        if (location.hasBearing()) NullableDouble.create(location.bearing.toDouble())
-                                        else null,
-                                speed = if (location.hasSpeed()) NullableDouble.create(location.speed.toDouble()) else null
+                                altitudeAccuracy = location.altitudeAccuracyValue(),
+                                heading = location.headingValue(),
+                                speed = location.speedValue()
                         ),
                 timestamp = location.time.toDouble()
         )
     }
 
-    private fun createError(code: Int, message: String): GeolocationError {
-        return GeolocationError(
+    private fun createError(code: Int, message: String): CompatGeolocationError {
+        return CompatGeolocationError(
                 code = code.toDouble(),
                 message = message,
                 PERMISSION_DENIED = PERMISSION_DENIED.toDouble(),
@@ -324,7 +325,7 @@ class GetCurrentPosition(private val reactContext: ReactApplicationContext) {
     private data class ParsedOptions(
             val timeout: Double,
             val maximumAge: Double,
-            val enableHighAccuracy: Boolean
+            val androidAccuracy: AndroidAccuracyResolution
     )
 
     companion object {

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

@@ -0,0 +1,26 @@
+package com.margelo.nitro.nitrogeolocation
+
+import android.location.Location
+import android.location.LocationManager
+import android.os.Build
+
+private const val FUSED_PROVIDER = "fused"
+
+internal fun Location.isMocked(): Boolean {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+        isMock
+    } else {
+        @Suppress("DEPRECATION")
+        isFromMockProvider
+    }
+}
+
+internal fun Location.providerUsed(): LocationProviderUsed {
+    return when (provider) {
+        FUSED_PROVIDER -> LocationProviderUsed.FUSED
+        LocationManager.GPS_PROVIDER -> LocationProviderUsed.GPS
+        LocationManager.NETWORK_PROVIDER -> LocationProviderUsed.NETWORK
+        LocationManager.PASSIVE_PROVIDER -> LocationProviderUsed.PASSIVE
+        else -> LocationProviderUsed.UNKNOWN
+    }
+}

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

@@ -0,0 +1,31 @@
+package com.margelo.nitro.nitrogeolocation
+
+import android.location.Location
+import android.os.Build
+import com.margelo.nitro.core.NullType.Companion.NULL
+
+internal fun nullableDouble(value: Double?): NullableDouble {
+    return value?.let { NullableDouble.create(it) } ?: NullableDouble.create(NULL)
+}
+
+internal fun Location.altitudeValue(): NullableDouble {
+    return nullableDouble(if (hasAltitude()) altitude else null)
+}
+
+internal fun Location.altitudeAccuracyValue(): NullableDouble {
+    return nullableDouble(
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && hasVerticalAccuracy()) {
+            verticalAccuracyMeters.toDouble()
+        } else {
+            null
+        }
+    )
+}
+
+internal fun Location.headingValue(): NullableDouble {
+    return nullableDouble(if (hasBearing()) bearing.toDouble() else null)
+}
+
+internal fun Location.speedValue(): NullableDouble {
+    return nullableDouble(if (hasSpeed()) speed.toDouble() else null)
+}