react-native-nitro-geolocation 0.0.1 → 0.1.1

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
+                )
+    }
+}

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

@@ -0,0 +1,228 @@
+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.Looper
+import android.util.Log
+import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.ReactApplicationContext
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicInteger
+
+class WatchPosition(private val reactContext: ReactApplicationContext) {
+
+    private val watchCallbacks = ConcurrentHashMap<Int, WatchCallback>()
+    private val watchIdGenerator = AtomicInteger(0)
+    private var locationListener: LocationListener? = null
+    private var watchedProvider: String? = null
+    private var currentOptions: GeolocationOptions? = null
+
+    data class WatchCallback(
+            val success: (GeolocationResponse) -> Unit,
+            val error: ((GeolocationError) -> Unit)?,
+            val options: GeolocationOptions?
+    )
+
+    fun watch(
+            success: (GeolocationResponse) -> Unit,
+            error: ((GeolocationError) -> Unit)?,
+            options: GeolocationOptions?
+    ): Int {
+        val watchId = watchIdGenerator.incrementAndGet()
+        watchCallbacks[watchId] = WatchCallback(success, error, options)
+
+        // Start observing if this is the first watch
+        if (watchCallbacks.size == 1) {
+            startObserving(options)
+        }
+
+        return watchId
+    }
+
+    fun clearWatch(watchId: Int) {
+        watchCallbacks.remove(watchId)
+
+        // Stop observing if no more watches
+        if (watchCallbacks.isEmpty()) {
+            stopObserving()
+        }
+    }
+
+    fun stopObserving() {
+        val locationManager =
+                reactContext.getSystemService(Context.LOCATION_SERVICE) as? LocationManager
+
+        locationListener?.let { listener -> locationManager?.removeUpdates(listener) }
+
+        locationListener = null
+        watchedProvider = null
+        currentOptions = null
+        watchCallbacks.clear()
+    }
+
+    private fun startObserving(options: GeolocationOptions?) {
+        val locationManager =
+                reactContext.getSystemService(Context.LOCATION_SERVICE) as? LocationManager
+
+        if (locationManager == null) {
+            Log.e(TAG, "LocationManager is not available")
+            emitErrorToAll(
+                    createError(
+                            GetCurrentPosition.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")
+            emitErrorToAll(
+                    createError(
+                            GetCurrentPosition.POSITION_UNAVAILABLE,
+                            "No location provider available"
+                    )
+            )
+            return
+        }
+
+        // If already watching with the same provider, don't restart
+        if (provider == watchedProvider) {
+            return
+        }
+
+        try {
+            // Remove old listener if exists
+            locationListener?.let { locationManager.removeUpdates(it) }
+
+            // Create new listener
+            val listener =
+                    object : LocationListener {
+                        override fun onLocationChanged(location: Location) {
+                            val position = locationToPosition(location)
+                            // Call all watch callbacks
+                            watchCallbacks.values.forEach { callback -> callback.success(position) }
+                        }
+
+                        override fun onStatusChanged(
+                                provider: String?,
+                                status: Int,
+                                extras: Bundle?
+                        ) {}
+                        override fun onProviderEnabled(provider: String) {}
+                        override fun onProviderDisabled(provider: String) {}
+                    }
+
+            locationManager.requestLocationUpdates(
+                    provider,
+                    opts.interval.toLong(),
+                    opts.distanceFilter.toFloat(),
+                    listener,
+                    Looper.getMainLooper()
+            )
+
+            locationListener = listener
+            watchedProvider = provider
+            currentOptions = options
+        } catch (e: SecurityException) {
+            Log.e(TAG, "SecurityException: ${e.message}")
+            emitErrorToAll(
+                    createError(
+                            GetCurrentPosition.PERMISSION_DENIED,
+                            "Location permission denied: ${e.message}"
+                    )
+            )
+        }
+    }
+
+    private fun emitErrorToAll(error: GeolocationError) {
+        watchCallbacks.values.forEach { callback -> callback.error?.invoke(error) }
+    }
+
+    private fun parseOptions(options: GeolocationOptions?): ParsedOptions {
+        return ParsedOptions(
+                interval = options?.interval ?: DEFAULT_INTERVAL,
+                distanceFilter = options?.distanceFilter ?: DEFAULT_DISTANCE_FILTER,
+                enableHighAccuracy = 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 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 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 = GetCurrentPosition.PERMISSION_DENIED.toDouble(),
+                POSITION_UNAVAILABLE = GetCurrentPosition.POSITION_UNAVAILABLE.toDouble(),
+                TIMEOUT = GetCurrentPosition.TIMEOUT.toDouble()
+        )
+    }
+
+    private data class ParsedOptions(
+            val interval: Double,
+            val distanceFilter: Double,
+            val enableHighAccuracy: Boolean
+    )
+
+    companion object {
+        private const val TAG = "WatchPosition"
+        const val DEFAULT_INTERVAL = 1000.0 // 1 second
+        const val DEFAULT_DISTANCE_FILTER = 100.0 // 100 meters
+    }
+}