react-native-nitro-geolocation 1.1.4 → 1.2.1

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

@@ -8,8 +8,8 @@ import com.margelo.nitro.NitroModules
 class NitroGeolocationCompat(
         private val reactContext: ReactApplicationContext = NitroModules.applicationContext!!
 ) : HybridNitroGeolocationCompatSpec() {
-    private var configuration: RNConfigurationInternal =
-            RNConfigurationInternal(
+    private var configuration: CompatGeolocationConfigurationInternal =
+            CompatGeolocationConfigurationInternal(
                     skipPermissionRequests = false,
                     authorizationLevel = null,
                     enableBackgroundLocationUpdates = null,
@@ -35,29 +35,29 @@ class NitroGeolocationCompat(
 
     private val watchPositionHandler by lazy { WatchPosition(reactContext) }
 
-    override fun setRNConfiguration(config: RNConfigurationInternal) {
+    override fun setRNConfiguration(config: CompatGeolocationConfigurationInternal) {
         configuration = config
     }
 
     override fun requestAuthorization(
             success: (() -> Unit)?,
-            error: ((error: GeolocationError) -> Unit)?
+            error: ((error: CompatGeolocationError) -> Unit)?
     ) {
         requestAuthorizationHandler.execute(success, error)
     }
 
     override fun getCurrentPosition(
-            success: (position: GeolocationResponse) -> Unit,
-            error: ((error: GeolocationError) -> Unit)?,
-            options: GeolocationOptions?
+            success: (position: CompatGeolocationResponse) -> Unit,
+            error: ((error: CompatGeolocationError) -> Unit)?,
+            options: CompatGeolocationOptions?
     ) {
         GetCurrentPosition(reactContext).execute(success, error, options)
     }
 
     override fun watchPosition(
-            success: (position: GeolocationResponse) -> Unit,
-            error: ((error: GeolocationError) -> Unit)?,
-            options: GeolocationOptions?
+            success: (position: CompatGeolocationResponse) -> Unit,
+            error: ((error: CompatGeolocationError) -> Unit)?,
+            options: CompatGeolocationOptions?
     ): Double {
         return watchPositionHandler.watch(success, error, options).toDouble()
     }
@@ -71,7 +71,7 @@ class NitroGeolocationCompat(
     }
 
     private fun createPermissionError(message: String) =
-            GeolocationError(
+            CompatGeolocationError(
                     code = RequestAuthorization.PERMISSION_DENIED.toDouble(),
                     message = message,
                     PERMISSION_DENIED = RequestAuthorization.PERMISSION_DENIED.toDouble(),

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

@@ -25,12 +25,12 @@ sealed class PermissionResult {
 class RequestAuthorization(
         private val reactContext: ReactApplicationContext,
         private val onPermissionResult:
-                (PermissionResult, (() -> Unit)?, ((GeolocationError) -> Unit)?) -> Unit
+                (PermissionResult, (() -> Unit)?, ((CompatGeolocationError) -> Unit)?) -> Unit
 ) {
     private var pendingAuthSuccess: (() -> Unit)? = null
-    private var pendingAuthError: ((error: GeolocationError) -> Unit)? = null
+    private var pendingAuthError: ((error: CompatGeolocationError) -> Unit)? = null
 
-    fun execute(success: (() -> Unit)?, error: ((error: GeolocationError) -> Unit)?) {
+    fun execute(success: (() -> Unit)?, error: ((error: CompatGeolocationError) -> Unit)?) {
         val state = determinePermissionState()
         executePermissionAction(state, success, error)
     }
@@ -81,7 +81,7 @@ class RequestAuthorization(
     private fun executePermissionAction(
             state: PermissionState,
             success: (() -> Unit)?,
-            error: ((error: GeolocationError) -> Unit)?
+            error: ((error: CompatGeolocationError) -> Unit)?
     ) {
         when (state) {
             is PermissionState.LegacyAndroid -> success?.invoke()
@@ -93,7 +93,7 @@ class RequestAuthorization(
 
     private fun showPermissionDialog(
             success: (() -> Unit)?,
-            error: ((error: GeolocationError) -> Unit)?
+            error: ((error: CompatGeolocationError) -> Unit)?
     ) {
         pendingAuthSuccess = success
         pendingAuthError = error
@@ -141,7 +141,7 @@ class RequestAuthorization(
     }
 
     private fun createPermissionError(message: String) =
-            GeolocationError(
+            CompatGeolocationError(
                     code = PERMISSION_DENIED.toDouble(),
                     message = message,
                     PERMISSION_DENIED = PERMISSION_DENIED.toDouble(),

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

@@ -20,18 +20,18 @@ class WatchPosition(private val reactContext: ReactApplicationContext) {
     private val watchIdGenerator = AtomicInteger(0)
     private var locationListener: LocationListener? = null
     private var watchedProvider: String? = null
-    private var currentOptions: GeolocationOptions? = null
+    private var currentOptions: CompatGeolocationOptions? = null
 
     data class WatchCallback(
-            val success: (GeolocationResponse) -> Unit,
-            val error: ((GeolocationError) -> Unit)?,
-            val options: GeolocationOptions?
+            val success: (CompatGeolocationResponse) -> Unit,
+            val error: ((CompatGeolocationError) -> Unit)?,
+            val options: CompatGeolocationOptions?
     )
 
     fun watch(
-            success: (GeolocationResponse) -> Unit,
-            error: ((GeolocationError) -> Unit)?,
-            options: GeolocationOptions?
+            success: (CompatGeolocationResponse) -> Unit,
+            error: ((CompatGeolocationError) -> Unit)?,
+            options: CompatGeolocationOptions?
     ): Int {
         val watchId = watchIdGenerator.incrementAndGet()
         watchCallbacks[watchId] = WatchCallback(success, error, options)
@@ -65,7 +65,7 @@ class WatchPosition(private val reactContext: ReactApplicationContext) {
         watchCallbacks.clear()
     }
 
-    private fun startObserving(options: GeolocationOptions?) {
+    private fun startObserving(options: CompatGeolocationOptions?) {
         val locationManager =
                 reactContext.getSystemService(Context.LOCATION_SERVICE) as? LocationManager
 
@@ -81,7 +81,7 @@ class WatchPosition(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")
@@ -143,69 +143,70 @@ class WatchPosition(private val reactContext: ReactApplicationContext) {
         }
     }
 
-    private fun emitErrorToAll(error: GeolocationError) {
+    private fun emitErrorToAll(error: CompatGeolocationError) {
         watchCallbacks.values.forEach { callback -> callback.error?.invoke(error) }
     }
 
-    private fun parseOptions(options: GeolocationOptions?): ParsedOptions {
+    private fun parseOptions(options: CompatGeolocationOptions?): ParsedOptions {
         return ParsedOptions(
                 interval = options?.interval ?: DEFAULT_INTERVAL,
                 distanceFilter = options?.distanceFilter ?: DEFAULT_DISTANCE_FILTER,
-                enableHighAccuracy = options?.enableHighAccuracy ?: false
+                androidAccuracy =
+                        resolveAndroidAccuracy(
+                                options?.accuracy,
+                                options?.enableHighAccuracy ?: false
+                        )
         )
     }
 
-    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 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 = GetCurrentPosition.PERMISSION_DENIED.toDouble(),
@@ -217,7 +218,7 @@ class WatchPosition(private val reactContext: ReactApplicationContext) {
     private data class ParsedOptions(
             val interval: Double,
             val distanceFilter: Double,
-            val enableHighAccuracy: Boolean
+            val androidAccuracy: AndroidAccuracyResolution
     )
 
     companion object {

package/ios/CLLocation+GeolocationMetadata.swift

@@ -0,0 +1,32 @@
+import CoreLocation
+import NitroModules
+
+extension CLLocation {
+    var nitroGeolocationMocked: Bool? {
+        if #available(iOS 15.0, *) {
+            return sourceInformation?.isSimulatedBySoftware
+        }
+
+        return nil
+    }
+
+    var nitroGeolocationProvider: LocationProviderUsed {
+        return .unknown
+    }
+
+    var nitroGeolocationAltitude: NullableDouble {
+        return verticalAccuracy < 0 ? .first(NullType.null) : .second(altitude)
+    }
+
+    var nitroGeolocationAltitudeAccuracy: NullableDouble {
+        return verticalAccuracy < 0 ? .first(NullType.null) : .second(verticalAccuracy)
+    }
+
+    var nitroGeolocationHeading: NullableDouble {
+        return course >= 0 ? .second(course) : .first(NullType.null)
+    }
+
+    var nitroGeolocationSpeed: NullableDouble {
+        return speed >= 0 ? .second(speed) : .first(NullType.null)
+    }
+}