react-native-nitro-geolocation 1.1.3 → 1.2.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)
+}