react-native-nitro-geolocation 0.0.1 → 0.1.0

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

@@ -0,0 +1,341 @@
+package com.margelo.nitro.nitrogeolocation
+
+import android.Manifest
+import android.content.Context
+import android.content.pm.PackageManager
+import android.location.Location
+import android.location.LocationListener
+import android.location.LocationManager
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.ReactApplicationContext
+
+class GetCurrentPosition(private val reactContext: ReactApplicationContext) {
+
+    fun execute(
+            success: (position: GeolocationResponse) -> Unit,
+            error: ((error: GeolocationError) -> Unit)?,
+            options: GeolocationOptions?
+    ) {
+        val locationManager =
+                reactContext.getSystemService(Context.LOCATION_SERVICE) as? LocationManager
+        if (locationManager == null) {
+            Log.e(TAG, "LocationManager is not available")
+            error?.invoke(createError(POSITION_UNAVAILABLE, "LocationManager is not available"))
+            return
+        }
+
+        val opts = parseOptions(options)
+        val provider = getValidProvider(locationManager, opts.enableHighAccuracy)
+
+        if (provider == null) {
+            Log.e(TAG, "No location provider available")
+            error?.invoke(createError(POSITION_UNAVAILABLE, "No location provider available"))
+            return
+        }
+
+        try {
+            val lastKnownLocation = locationManager.getLastKnownLocation(provider)
+
+            // Check if cached location is fresh enough
+            if (lastKnownLocation != null && isCachedLocationValid(lastKnownLocation, opts)) {
+                success(locationToPosition(lastKnownLocation))
+                return
+            }
+
+            // If maximumAge is Infinity and we have a last known location, use it
+            if (lastKnownLocation != null && opts.maximumAge == Double.POSITIVE_INFINITY) {
+                success(locationToPosition(lastKnownLocation))
+                return
+            }
+
+            // Request fresh location
+            requestFreshLocation(locationManager, provider, opts, success, error, lastKnownLocation)
+        } catch (e: SecurityException) {
+            Log.e(TAG, "Security exception: ${e.message}")
+            error?.invoke(
+                    createError(PERMISSION_DENIED, "Location permission denied: ${e.message}")
+            )
+        }
+    }
+
+    // ===== Helper Functions =====
+
+    private fun parseOptions(options: GeolocationOptions?): ParsedOptions {
+        return ParsedOptions(
+                timeout = options?.timeout ?: DEFAULT_TIMEOUT,
+                maximumAge = options?.maximumAge ?: DEFAULT_MAXIMUM_AGE,
+                enableHighAccuracy = options?.enableHighAccuracy ?: false
+        )
+    }
+
+    private fun isCachedLocationValid(location: Location, options: ParsedOptions): Boolean {
+        val age = System.currentTimeMillis() - location.time
+        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 isProviderValid(locationManager: LocationManager, provider: String): Boolean {
+        if (!locationManager.isProviderEnabled(provider)) return false
+
+        val permission =
+                if (provider == LocationManager.GPS_PROVIDER)
+                        Manifest.permission.ACCESS_FINE_LOCATION
+                else Manifest.permission.ACCESS_COARSE_LOCATION
+
+        return ContextCompat.checkSelfPermission(reactContext, permission) ==
+                PackageManager.PERMISSION_GRANTED
+    }
+
+    private fun requestFreshLocation(
+            locationManager: LocationManager,
+            provider: String,
+            options: ParsedOptions,
+            success: (GeolocationResponse) -> Unit,
+            error: ((GeolocationError) -> Unit)?,
+            fallbackLocation: Location?
+    ) {
+        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.R) {
+            // Android 11+ supports getCurrentLocation
+            requestCurrentLocationModern(
+                    locationManager,
+                    provider,
+                    options,
+                    success,
+                    error,
+                    fallbackLocation
+            )
+        } else {
+            // Fallback to requestLocationUpdates
+            requestCurrentLocationLegacy(
+                    locationManager,
+                    provider,
+                    options,
+                    success,
+                    error,
+                    fallbackLocation
+            )
+        }
+    }
+
+    @androidx.annotation.RequiresApi(android.os.Build.VERSION_CODES.R)
+    private fun requestCurrentLocationModern(
+            locationManager: LocationManager,
+            provider: String,
+            options: ParsedOptions,
+            success: (GeolocationResponse) -> Unit,
+            error: ((GeolocationError) -> Unit)?,
+            fallbackLocation: Location?
+    ) {
+        val handler = Handler(Looper.getMainLooper())
+        val cancellationSignal = android.os.CancellationSignal()
+
+        val timeoutRunnable = Runnable {
+            cancellationSignal.cancel()
+            error?.invoke(createError(TIMEOUT, "Location request timed out"))
+        }
+
+        try {
+            locationManager.getCurrentLocation(
+                    provider,
+                    cancellationSignal,
+                    { runnable -> handler.post(runnable) }
+            ) { location ->
+                handler.removeCallbacks(timeoutRunnable)
+
+                val bestLocation = selectBestLocation(location, fallbackLocation)
+
+                if (bestLocation != null) {
+                    success(locationToPosition(bestLocation))
+                } else {
+                    Log.e(TAG, "No location available")
+                    error?.invoke(createError(POSITION_UNAVAILABLE, "Unable to get location"))
+                }
+            }
+            handler.postDelayed(timeoutRunnable, options.timeout.toLong())
+        } catch (e: SecurityException) {
+            Log.e(TAG, "SecurityException: ${e.message}")
+            error?.invoke(createError(PERMISSION_DENIED, "Permission denied: ${e.message}"))
+        }
+    }
+
+    private fun selectBestLocation(newLocation: Location?, fallbackLocation: Location?): Location? {
+        return when {
+            newLocation == null -> fallbackLocation
+            fallbackLocation == null -> newLocation
+            isBetterLocation(newLocation, fallbackLocation) -> newLocation
+            else -> fallbackLocation
+        }
+    }
+
+    private fun requestCurrentLocationLegacy(
+            locationManager: LocationManager,
+            provider: String,
+            options: ParsedOptions,
+            success: (GeolocationResponse) -> Unit,
+            error: ((GeolocationError) -> Unit)?,
+            fallbackLocation: Location?
+    ) {
+        val handler = Handler(Looper.getMainLooper())
+        var isResolved = false
+        var oldLocation = fallbackLocation
+        lateinit var listener: LocationListener
+
+        val timeoutRunnable = Runnable {
+            if (!isResolved) {
+                isResolved = true
+                locationManager.removeUpdates(listener)
+                error?.invoke(createError(TIMEOUT, "Location request timed out"))
+            }
+        }
+
+        listener =
+                object : LocationListener {
+                    override fun onLocationChanged(location: Location) {
+                        synchronized(this) {
+                            if (!isResolved) {
+                                val bestLocation = selectBestLocation(location, oldLocation)
+                                if (bestLocation == location) {
+                                    isResolved = true
+                                    handler.removeCallbacks(timeoutRunnable)
+                                    locationManager.removeUpdates(this)
+                                    success(locationToPosition(location))
+                                }
+                                oldLocation = location
+                            }
+                        }
+                    }
+
+                    override fun onStatusChanged(provider: String?, status: Int, extras: Bundle?) {}
+                    override fun onProviderEnabled(provider: String) {}
+                    override fun onProviderDisabled(provider: String) {}
+                }
+
+        try {
+            locationManager.requestLocationUpdates(
+                    provider,
+                    100,
+                    1f,
+                    listener,
+                    Looper.getMainLooper()
+            )
+            handler.postDelayed(timeoutRunnable, options.timeout.toLong())
+        } catch (e: SecurityException) {
+            Log.e(TAG, "SecurityException in requestLocationUpdates: ${e.message}")
+            error?.invoke(createError(PERMISSION_DENIED, "Permission denied: ${e.message}"))
+        }
+    }
+
+    /**
+     * Determines whether one Location reading is better than the current Location fix Taken from
+     * Android Examples: https://developer.android.com/guide/topics/location/strategies.html
+     */
+    private fun isBetterLocation(location: Location, currentBestLocation: Location?): Boolean {
+        if (currentBestLocation == null) {
+            return true
+        }
+
+        val timeDelta = location.time - currentBestLocation.time
+        val isSignificantlyNewer = timeDelta > TWO_MINUTES
+        val isSignificantlyOlder = timeDelta < -TWO_MINUTES
+        val isNewer = timeDelta > 0
+
+        if (isSignificantlyNewer) {
+            return true
+        } else if (isSignificantlyOlder) {
+            return false
+        }
+
+        val accuracyDelta = (location.accuracy - currentBestLocation.accuracy).toInt()
+        val isLessAccurate = accuracyDelta > 0
+        val isMoreAccurate = accuracyDelta < 0
+        val isSignificantlyLessAccurate = accuracyDelta > 200
+
+        val isFromSameProvider = isSameProvider(location.provider, currentBestLocation.provider)
+
+        return when {
+            isMoreAccurate -> true
+            isNewer && !isLessAccurate -> true
+            isNewer && !isSignificantlyLessAccurate && isFromSameProvider -> true
+            else -> false
+        }
+    }
+
+    private fun isSameProvider(provider1: String?, provider2: String?): Boolean {
+        if (provider1 == null) {
+            return provider2 == null
+        }
+        return provider1 == provider2
+    }
+
+    // ===== Data Conversion =====
+
+    private fun locationToPosition(location: Location): GeolocationResponse {
+        return GeolocationResponse(
+                coords =
+                        GeolocationCoordinates(
+                                latitude = location.latitude,
+                                longitude = location.longitude,
+                                altitude = if (location.hasAltitude()) location.altitude else null,
+                                accuracy = location.accuracy.toDouble(),
+                                altitudeAccuracy =
+                                        if (android.os.Build.VERSION.SDK_INT >=
+                                                        android.os.Build.VERSION_CODES.O &&
+                                                        location.hasVerticalAccuracy()
+                                        )
+                                                location.verticalAccuracyMeters.toDouble()
+                                        else null,
+                                heading =
+                                        if (location.hasBearing()) location.bearing.toDouble()
+                                        else null,
+                                speed = if (location.hasSpeed()) location.speed.toDouble() else null
+                        ),
+                timestamp = location.time.toDouble()
+        )
+    }
+
+    private fun createError(code: Int, message: String): GeolocationError {
+        return GeolocationError(
+                code = code.toDouble(),
+                message = message,
+                PERMISSION_DENIED = PERMISSION_DENIED.toDouble(),
+                POSITION_UNAVAILABLE = POSITION_UNAVAILABLE.toDouble(),
+                TIMEOUT = TIMEOUT.toDouble()
+        )
+    }
+
+    // ===== Data Classes =====
+
+    private data class ParsedOptions(
+            val timeout: Double,
+            val maximumAge: Double,
+            val enableHighAccuracy: Boolean
+    )
+
+    companion object {
+        private const val TAG = "GetCurrentPosition"
+        const val PERMISSION_DENIED = 1
+        const val POSITION_UNAVAILABLE = 2
+        const val TIMEOUT = 3
+
+        const val DEFAULT_TIMEOUT = 10 * 60 * 1000.0 // 10 minutes
+        const val DEFAULT_MAXIMUM_AGE = Double.POSITIVE_INFINITY
+
+        private const val TWO_MINUTES = 1000 * 60 * 2L // 2 minutes in milliseconds
+    }
+}

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

@@ -1,10 +1,81 @@
 package com.margelo.nitro.nitrogeolocation
-  
+
 import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.ReactApplicationContext
+import com.margelo.nitro.NitroModules
 
 @DoNotStrip
-class NitroGeolocation : HybridNitroGeolocationSpec() {
-  override fun multiply(a: Double, b: Double): Double {
-    return a * b
-  }
+class NitroGeolocation(
+        private val reactContext: ReactApplicationContext = NitroModules.applicationContext!!
+) : HybridNitroGeolocationSpec() {
+    private var configuration: RNConfigurationInternal =
+            RNConfigurationInternal(
+                    skipPermissionRequests = false,
+                    authorizationLevel = null,
+                    enableBackgroundLocationUpdates = null,
+                    locationProvider = null
+            )
+
+    private val requestAuthorizationHandler by lazy {
+        RequestAuthorization(
+                reactContext = reactContext,
+                onPermissionResult = { result, success, error ->
+                    when (result) {
+                        is PermissionResult.Granted -> success?.invoke()
+                        is PermissionResult.Denied ->
+                                error?.invoke(
+                                        createPermissionError(
+                                                "Location permission was not granted."
+                                        )
+                                )
+                    }
+                }
+        )
+    }
+
+    private val watchPositionHandler by lazy { WatchPosition(reactContext) }
+
+    override fun setRNConfiguration(config: RNConfigurationInternal) {
+        configuration = config
+    }
+
+    override fun requestAuthorization(
+            success: (() -> Unit)?,
+            error: ((error: GeolocationError) -> Unit)?
+    ) {
+        requestAuthorizationHandler.execute(success, error)
+    }
+
+    override fun getCurrentPosition(
+            success: (position: GeolocationResponse) -> Unit,
+            error: ((error: GeolocationError) -> Unit)?,
+            options: GeolocationOptions?
+    ) {
+        GetCurrentPosition(reactContext).execute(success, error, options)
+    }
+
+    override fun watchPosition(
+            success: (position: GeolocationResponse) -> Unit,
+            error: ((error: GeolocationError) -> Unit)?,
+            options: GeolocationOptions?
+    ): Double {
+        return watchPositionHandler.watch(success, error, options).toDouble()
+    }
+
+    override fun clearWatch(watchId: Double) {
+        watchPositionHandler.clearWatch(watchId.toInt())
+    }
+
+    override fun stopObserving() {
+        watchPositionHandler.stopObserving()
+    }
+
+    private fun createPermissionError(message: String) =
+            GeolocationError(
+                    code = RequestAuthorization.PERMISSION_DENIED.toDouble(),
+                    message = message,
+                    PERMISSION_DENIED = RequestAuthorization.PERMISSION_DENIED.toDouble(),
+                    POSITION_UNAVAILABLE = RequestAuthorization.POSITION_UNAVAILABLE.toDouble(),
+                    TIMEOUT = RequestAuthorization.TIMEOUT.toDouble()
+            )
 }

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

@@ -0,0 +1,164 @@
+package com.margelo.nitro.nitrogeolocation
+
+import android.Manifest
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.core.app.ActivityCompat
+import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.modules.core.PermissionAwareActivity
+import com.facebook.react.modules.core.PermissionListener
+
+// ===== Data Models =====
+sealed class PermissionState {
+    object LegacyAndroid : PermissionState()
+    object AlreadyGranted : PermissionState()
+    object NeedsRequest : PermissionState()
+    data class Error(val message: String) : PermissionState()
+}
+
+sealed class PermissionResult {
+    object Granted : PermissionResult()
+    object Denied : PermissionResult()
+}
+
+class RequestAuthorization(
+        private val reactContext: ReactApplicationContext,
+        private val onPermissionResult:
+                (PermissionResult, (() -> Unit)?, ((GeolocationError) -> Unit)?) -> Unit
+) {
+    private var pendingAuthSuccess: (() -> Unit)? = null
+    private var pendingAuthError: ((error: GeolocationError) -> Unit)? = null
+
+    fun execute(success: (() -> Unit)?, error: ((error: GeolocationError) -> Unit)?) {
+        val state = determinePermissionState()
+        executePermissionAction(state, success, error)
+    }
+
+    // ===== State Determination (Pure Functions) =====
+    private fun determinePermissionState(): PermissionState =
+            when {
+                isLegacyAndroid() -> PermissionState.LegacyAndroid
+                else -> determineModernAndroidState()
+            }
+
+    private fun determineModernAndroidState(): PermissionState =
+            when {
+                hasLocationPermission(reactContext) -> PermissionState.AlreadyGranted
+                reactContext.currentActivity == null ->
+                        PermissionState.Error("Current activity is null")
+                else -> PermissionState.NeedsRequest
+            }
+
+    private fun isLegacyAndroid(): Boolean = Build.VERSION.SDK_INT < Build.VERSION_CODES.M
+
+    private fun hasLocationPermission(context: ReactApplicationContext): Boolean =
+            LOCATION_PERMISSIONS.any { permission ->
+                ContextCompat.checkSelfPermission(context, permission) ==
+                        PackageManager.PERMISSION_GRANTED
+            }
+
+    private fun determinePermissionResult(
+            permissions: Array<String>,
+            grantResults: IntArray
+    ): PermissionResult {
+        val hasGrantedPermission =
+                permissions.indices.any { i ->
+                    isLocationPermission(permissions[i]) &&
+                            grantResults[i] == PackageManager.PERMISSION_GRANTED
+                }
+
+        return when {
+            hasGrantedPermission -> PermissionResult.Granted
+            else -> PermissionResult.Denied
+        }
+    }
+
+    private fun isLocationPermission(permission: String): Boolean =
+            permission in LOCATION_PERMISSIONS
+
+    // ===== Actions (Side Effects) =====
+    private fun executePermissionAction(
+            state: PermissionState,
+            success: (() -> Unit)?,
+            error: ((error: GeolocationError) -> Unit)?
+    ) {
+        when (state) {
+            is PermissionState.LegacyAndroid -> success?.invoke()
+            is PermissionState.AlreadyGranted -> success?.invoke()
+            is PermissionState.NeedsRequest -> showPermissionDialog(success, error)
+            is PermissionState.Error -> error?.invoke(createPermissionError(state.message))
+        }
+    }
+
+    private fun showPermissionDialog(
+            success: (() -> Unit)?,
+            error: ((error: GeolocationError) -> Unit)?
+    ) {
+        pendingAuthSuccess = success
+        pendingAuthError = error
+
+        reactContext.currentActivity?.let { activity ->
+            requestPermissionsFromActivity(activity)
+        }
+    }
+
+    private fun requestPermissionsFromActivity(activity: android.app.Activity) {
+        val permissions = LOCATION_PERMISSIONS.toTypedArray()
+
+        when (val permissionAware = activity as? PermissionAwareActivity) {
+            null ->
+                    ActivityCompat.requestPermissions(
+                            activity,
+                            permissions,
+                            PERMISSION_REQUEST_CODE
+                    )
+            else ->
+                    permissionAware.requestPermissions(
+                            permissions,
+                            PERMISSION_REQUEST_CODE,
+                            createPermissionListener()
+                    )
+        }
+    }
+
+    private fun createPermissionListener() =
+            PermissionListener { requestCode, permissions, grantResults ->
+                when (requestCode) {
+                    PERMISSION_REQUEST_CODE -> {
+                        val result = determinePermissionResult(permissions, grantResults)
+                        onPermissionResult(result, pendingAuthSuccess, pendingAuthError)
+                        clearPendingCallbacks()
+                        true
+                    }
+                    else -> false
+                }
+            }
+
+    private fun clearPendingCallbacks() {
+        pendingAuthSuccess = null
+        pendingAuthError = null
+    }
+
+    private fun createPermissionError(message: String) =
+            GeolocationError(
+                    code = PERMISSION_DENIED.toDouble(),
+                    message = message,
+                    PERMISSION_DENIED = PERMISSION_DENIED.toDouble(),
+                    POSITION_UNAVAILABLE = POSITION_UNAVAILABLE.toDouble(),
+                    TIMEOUT = TIMEOUT.toDouble()
+            )
+
+    companion object {
+        const val PERMISSION_DENIED = 1
+        const val POSITION_UNAVAILABLE = 2
+        const val TIMEOUT = 3
+        const val PERMISSION_REQUEST_CODE = 2025
+
+        private val LOCATION_PERMISSIONS =
+                listOf(
+                        Manifest.permission.ACCESS_FINE_LOCATION,
+                        Manifest.permission.ACCESS_COARSE_LOCATION
+                )
+    }
+}