react-native-nitro-geolocation 1.1.3 → 1.2.0

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

@@ -0,0 +1,313 @@
+package com.margelo.nitro.nitrogeolocation
+
+import android.content.Context
+import android.hardware.GeomagneticField
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorEventListener
+import android.hardware.SensorManager
+import android.location.Location
+import android.os.Handler
+import android.os.Looper
+import java.util.UUID
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.math.abs
+
+private const val DEFAULT_HEADING_TIMEOUT_MS = 10_000L
+
+internal class AndroidHeadingManager(
+    context: Context,
+    private val createLocationError: (Double, String) -> LocationError,
+    private val getReferenceLocation: () -> Location?
+) {
+    private data class PendingHeadingRequest(
+        val id: UUID,
+        val success: (Heading) -> Unit,
+        val error: ((LocationError) -> Unit)?,
+        val timeoutRunnable: Runnable
+    )
+
+    private data class HeadingSubscription(
+        val token: String,
+        val success: (Heading) -> Unit,
+        val error: ((LocationError) -> Unit)?,
+        val headingFilter: Double,
+        var lastDeliveredHeading: Double?
+    )
+
+    private val sensorManager =
+        context.getSystemService(Context.SENSOR_SERVICE) as? SensorManager
+    private val mainHandler = Handler(Looper.getMainLooper())
+    private val pendingRequests = ConcurrentHashMap<UUID, PendingHeadingRequest>()
+    private val subscriptions = ConcurrentHashMap<String, HeadingSubscription>()
+    private val rotationVectorSensor: Sensor? =
+        sensorManager?.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR)
+            ?: sensorManager?.getDefaultSensor(Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR)
+    private val accelerometerSensor: Sensor? =
+        sensorManager?.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
+    private val magneticFieldSensor: Sensor? =
+        sensorManager?.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD)
+
+    private var isListening = false
+    private var sensorAccuracy: Int? = null
+    private var gravityValues: FloatArray? = null
+    private var magneticValues: FloatArray? = null
+
+    private val sensorListener = object : SensorEventListener {
+        override fun onSensorChanged(event: SensorEvent) {
+            val magneticHeading = when (event.sensor.type) {
+                Sensor.TYPE_ROTATION_VECTOR,
+                Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR -> {
+                    headingFromRotationVector(event.values)
+                }
+                Sensor.TYPE_ACCELEROMETER -> {
+                    gravityValues = event.values.clone()
+                    headingFromAccelerationAndMagnetometer()
+                }
+                Sensor.TYPE_MAGNETIC_FIELD -> {
+                    magneticValues = event.values.clone()
+                    headingFromAccelerationAndMagnetometer()
+                }
+                else -> null
+            } ?: return
+
+            emitHeading(createHeading(magneticHeading))
+        }
+
+        override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {
+            sensorAccuracy = accuracy
+        }
+    }
+
+    fun getHeading(
+        success: (Heading) -> Unit,
+        error: ((LocationError) -> Unit)?
+    ) {
+        if (!hasHeadingSensor()) {
+            error?.invoke(createUnavailableError())
+            return
+        }
+
+        val id = UUID.randomUUID()
+        val timeoutRunnable = Runnable {
+            pendingRequests.remove(id)?.error?.invoke(
+                createLocationError(
+                    TIMEOUT,
+                    "Unable to fetch heading within ${DEFAULT_HEADING_TIMEOUT_MS / 1000.0}s."
+                )
+            )
+            stopIfIdle()
+        }
+
+        pendingRequests[id] = PendingHeadingRequest(
+            id = id,
+            success = success,
+            error = error,
+            timeoutRunnable = timeoutRunnable
+        )
+        mainHandler.postDelayed(timeoutRunnable, DEFAULT_HEADING_TIMEOUT_MS)
+        startIfNeeded()
+    }
+
+    fun watchHeading(
+        success: (Heading) -> Unit,
+        error: ((LocationError) -> Unit)?,
+        options: HeadingOptions?
+    ): String {
+        val token = UUID.randomUUID().toString()
+        val headingFilter = options?.headingFilter ?: 0.0
+
+        if (!headingFilter.isFinite() || headingFilter < 0.0) {
+            error?.invoke(createLocationError(
+                INTERNAL_ERROR,
+                "headingFilter must be a finite number greater than or equal to 0."
+            ))
+            return token
+        }
+
+        if (!hasHeadingSensor()) {
+            error?.invoke(createUnavailableError())
+            return token
+        }
+
+        subscriptions[token] = HeadingSubscription(
+            token = token,
+            success = success,
+            error = error,
+            headingFilter = headingFilter,
+            lastDeliveredHeading = null
+        )
+        startIfNeeded()
+
+        return token
+    }
+
+    fun unwatch(token: String) {
+        subscriptions.remove(token)
+        stopIfIdle()
+    }
+
+    fun stopObserving() {
+        pendingRequests.values.forEach { request ->
+            mainHandler.removeCallbacks(request.timeoutRunnable)
+        }
+        pendingRequests.clear()
+        subscriptions.clear()
+        stopListening()
+    }
+
+    fun hasActiveWork(): Boolean {
+        return pendingRequests.isNotEmpty() || subscriptions.isNotEmpty()
+    }
+
+    private fun hasHeadingSensor(): Boolean {
+        return sensorManager != null &&
+            (rotationVectorSensor != null || (accelerometerSensor != null && magneticFieldSensor != null))
+    }
+
+    private fun startIfNeeded() {
+        if (isListening) return
+
+        val manager = sensorManager ?: return
+        val didRegister = if (rotationVectorSensor != null) {
+            manager.registerListener(
+                sensorListener,
+                rotationVectorSensor,
+                SensorManager.SENSOR_DELAY_UI,
+                mainHandler
+            )
+        } else {
+            val accelerometerRegistered = manager.registerListener(
+                sensorListener,
+                accelerometerSensor!!,
+                SensorManager.SENSOR_DELAY_UI,
+                mainHandler
+            )
+            val magneticRegistered = manager.registerListener(
+                sensorListener,
+                magneticFieldSensor!!,
+                SensorManager.SENSOR_DELAY_UI,
+                mainHandler
+            )
+            accelerometerRegistered && magneticRegistered
+        }
+
+        isListening = didRegister
+        if (!didRegister) {
+            val error = createUnavailableError()
+            pendingRequests.values.forEach { it.error?.invoke(error) }
+            subscriptions.values.forEach { it.error?.invoke(error) }
+            stopObserving()
+        }
+    }
+
+    private fun stopIfIdle() {
+        if (!hasActiveWork()) {
+            stopListening()
+        }
+    }
+
+    private fun stopListening() {
+        if (!isListening) return
+
+        try {
+            sensorManager?.unregisterListener(sensorListener)
+        } catch (_: Exception) {
+            // Ignore unregister races.
+        }
+        isListening = false
+        gravityValues = null
+        magneticValues = null
+    }
+
+    private fun headingFromRotationVector(values: FloatArray): Double? {
+        val rotationMatrix = FloatArray(9)
+        val orientation = FloatArray(3)
+        SensorManager.getRotationMatrixFromVector(rotationMatrix, values)
+        SensorManager.getOrientation(rotationMatrix, orientation)
+        return normalizeHeading(Math.toDegrees(orientation[0].toDouble()))
+    }
+
+    private fun headingFromAccelerationAndMagnetometer(): Double? {
+        val gravity = gravityValues ?: return null
+        val magnetic = magneticValues ?: return null
+        val rotationMatrix = FloatArray(9)
+        val inclinationMatrix = FloatArray(9)
+
+        if (!SensorManager.getRotationMatrix(rotationMatrix, inclinationMatrix, gravity, magnetic)) {
+            return null
+        }
+
+        val orientation = FloatArray(3)
+        SensorManager.getOrientation(rotationMatrix, orientation)
+        return normalizeHeading(Math.toDegrees(orientation[0].toDouble()))
+    }
+
+    private fun createHeading(magneticHeading: Double): Heading {
+        val referenceLocation = getReferenceLocation()
+        val trueHeading = referenceLocation?.let { location ->
+            val field = GeomagneticField(
+                location.latitude.toFloat(),
+                location.longitude.toFloat(),
+                if (location.hasAltitude()) location.altitude.toFloat() else 0f,
+                location.time
+            )
+            normalizeHeading(magneticHeading + field.declination)
+        }
+
+        return Heading(
+            magneticHeading = magneticHeading,
+            trueHeading = trueHeading,
+            accuracy = sensorAccuracy?.takeIf {
+                it != SensorManager.SENSOR_STATUS_UNRELIABLE
+            }?.toDouble(),
+            timestamp = System.currentTimeMillis().toDouble()
+        )
+    }
+
+    private fun emitHeading(heading: Heading) {
+        val pendingSnapshot = pendingRequests.values.toList()
+        pendingSnapshot.forEach { request ->
+            mainHandler.removeCallbacks(request.timeoutRunnable)
+            if (pendingRequests.remove(request.id) != null) {
+                request.success(heading)
+            }
+        }
+
+        subscriptions.values.forEach { subscription ->
+            val lastHeading = subscription.lastDeliveredHeading
+            if (
+                lastHeading == null ||
+                angularDistance(lastHeading, heading.magneticHeading) >= subscription.headingFilter
+            ) {
+                subscription.lastDeliveredHeading = heading.magneticHeading
+                subscription.success(heading)
+            }
+        }
+
+        stopIfIdle()
+    }
+
+    private fun angularDistance(first: Double, second: Double): Double {
+        val distance = abs(first - second) % 360.0
+        return if (distance > 180.0) 360.0 - distance else distance
+    }
+
+    private fun normalizeHeading(value: Double): Double {
+        val normalized = value % 360.0
+        return if (normalized < 0.0) normalized + 360.0 else normalized
+    }
+
+    private fun createUnavailableError(): LocationError {
+        return createLocationError(
+            POSITION_UNAVAILABLE,
+            "Heading sensor is not available."
+        )
+    }
+
+    private companion object {
+        private const val INTERNAL_ERROR = -1.0
+        private const val POSITION_UNAVAILABLE = 2.0
+        private const val TIMEOUT = 3.0
+    }
+}

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