@mapvina-com/mapvina-react-native 1.0.0

package/android/src/main/java/io/github/mapvina/reactnative/modules/MLRNLocationModule.kt

@@ -0,0 +1,179 @@
+package io.github.mapvina.reactnative.modules
+
+import android.Manifest
+import android.location.Location
+import android.os.Build
+import androidx.annotation.RequiresPermission
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
+import io.github.mapvina.android.location.engine.LocationEngineCallback
+import io.github.mapvina.android.location.engine.LocationEngineResult
+import io.github.mapvina.reactnative.NativeLocationModuleSpec
+import io.github.mapvina.reactnative.location.LocationManager
+import io.github.mapvina.reactnative.location.LocationManager.OnUserLocationChange
+
+class MLRNLocationModule(
+    reactContext: ReactApplicationContext,
+) : NativeLocationModuleSpec(reactContext) {
+    companion object {
+        const val NAME = "MLRNLocationModule"
+    }
+
+    override fun getName() = NAME
+
+    private var isEnabled = false
+    private var minDisplacement = 0f
+    private var isPaused = false
+
+    private val locationManager: LocationManager = LocationManager.getInstance(reactContext)
+
+    private val lifecycleEventListener: LifecycleEventListener =
+        object : LifecycleEventListener {
+            @RequiresPermission(allOf = [Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION])
+            override fun onHostResume() {
+                if (isEnabled) {
+                    startLocationManager()
+                }
+            }
+
+            override fun onHostPause() {
+                pauseLocationManager()
+            }
+
+            override fun onHostDestroy() {
+                stopLocationManager()
+            }
+        }
+
+    private val onUserLocationChangeCallback: OnUserLocationChange =
+        object : OnUserLocationChange {
+            override fun onLocationChange(location: Location) {
+                emitOnUpdate(locationToGeolocationPosition(location))
+            }
+        }
+
+    init {
+        reactContext.addLifecycleEventListener(lifecycleEventListener)
+    }
+
+    @RequiresPermission(allOf = [Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION])
+    override fun start() {
+        isEnabled = true
+        startLocationManager()
+    }
+
+    @RequiresPermission(allOf = [Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION])
+    override fun setMinDisplacement(minDisplacement: Double) {
+        if (this.minDisplacement == minDisplacement.toFloat()) return
+
+        this.minDisplacement = minDisplacement.toFloat()
+        if (isEnabled) {
+            locationManager.setMinDisplacement(this.minDisplacement)
+            locationManager.enable()
+        }
+    }
+
+    override fun stop() {
+        stopLocationManager()
+    }
+
+    fun pause() {
+        pauseLocationManager()
+    }
+
+    @RequiresPermission(allOf = [Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION])
+    override fun getCurrentPosition(promise: Promise) {
+        locationManager.getLastKnownLocation(
+            object :
+                LocationEngineCallback<LocationEngineResult?> {
+                override fun onSuccess(result: LocationEngineResult?) {
+                    val location = result?.lastLocation
+
+                    if (location != null) {
+                        promise.resolve(locationToGeolocationPosition(location))
+                    } else {
+                        promise.resolve(null)
+                    }
+                }
+
+                override fun onFailure(exception: Exception) {
+                    promise.reject(exception)
+                }
+            },
+        )
+    }
+
+    override fun requestPermissions(promise: Promise) {
+        // On Android, permissions are handled at the JS level using PermissionsAndroid
+        promise.resolve(null)
+    }
+
+    @RequiresPermission(allOf = [Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION])
+    private fun startLocationManager() {
+        locationManager.addLocationListener(onUserLocationChangeCallback)
+        locationManager.setMinDisplacement(minDisplacement)
+        locationManager.enable()
+        isPaused = false
+    }
+
+    private fun pauseLocationManager() {
+        if (isPaused) {
+            return
+        }
+
+        locationManager.disable()
+        isPaused = true
+    }
+
+    private fun stopLocationManager() {
+        if (!isEnabled) {
+            return
+        }
+
+        locationManager.removeLocationListener(onUserLocationChangeCallback)
+        locationManager.dispose()
+        isEnabled = false
+        isPaused = false
+    }
+
+    private fun locationToGeolocationPosition(location: Location): WritableMap {
+        val coords: WritableMap = WritableNativeMap()
+
+        coords.putDouble("longitude", location.longitude)
+        coords.putDouble("latitude", location.latitude)
+        coords.putDouble("accuracy", location.accuracy.toDouble())
+
+        if (location.hasAltitude()) {
+            coords.putDouble("altitude", location.altitude)
+        } else {
+            coords.putNull("altitude")
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && location.hasVerticalAccuracy()) {
+            coords.putDouble("altitudeAccuracy", location.verticalAccuracyMeters.toDouble())
+        } else {
+            coords.putNull("altitudeAccuracy")
+        }
+
+        if (location.hasBearing()) {
+            coords.putDouble("heading", location.bearing.toDouble())
+        } else {
+            coords.putNull("heading")
+        }
+
+        if (location.hasSpeed()) {
+            coords.putDouble("speed", location.speed.toDouble())
+        } else {
+            coords.putNull("speed")
+        }
+
+        val geolocationPosition: WritableMap = WritableNativeMap()
+        geolocationPosition.putMap("coords", coords)
+        geolocationPosition.putDouble("timestamp", location.time.toDouble())
+
+        return geolocationPosition
+    }
+}

package/android/src/main/java/io/github/mapvina/reactnative/modules/MLRNLogModule.kt

@@ -0,0 +1,141 @@
+package io.github.mapvina.reactnative.modules
+
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import io.github.mapvina.android.log.Logger
+import io.github.mapvina.android.log.LoggerDefinition
+import io.github.mapvina.reactnative.NativeLogModuleSpec
+
+@ReactModule(name = MLRNLogModule.NAME)
+class MLRNLogModule(
+    reactContext: ReactApplicationContext,
+) : NativeLogModuleSpec(
+        reactContext,
+    ) {
+    companion object {
+        const val NAME: String = "MLRNLogModule"
+    }
+
+    override fun getName() = NAME
+
+    init {
+        Logger.setVerbosity(Logger.WARN)
+
+        Logger.setLoggerDefinition(
+            object : LoggerDefinition {
+                override fun v(
+                    tag: String,
+                    msg: String,
+                ) {
+                    Log.v(tag, msg)
+                    onLog("verbose", tag, msg)
+                }
+
+                override fun v(
+                    tag: String,
+                    msg: String,
+                    tr: Throwable,
+                ) {
+                    Log.v(tag, msg, tr)
+                    onLog("verbose", tag, msg)
+                }
+
+                override fun d(
+                    tag: String,
+                    msg: String,
+                ) {
+                    Log.d(tag, msg)
+                    onLog("debug", tag, msg)
+                }
+
+                override fun d(
+                    tag: String,
+                    msg: String,
+                    tr: Throwable,
+                ) {
+                    Log.d(tag, msg, tr)
+                    onLog("debug", tag, msg)
+                }
+
+                override fun i(
+                    tag: String,
+                    msg: String,
+                ) {
+                    Log.i(tag, msg)
+                    onLog("info", tag, msg)
+                }
+
+                override fun i(
+                    tag: String,
+                    msg: String,
+                    tr: Throwable,
+                ) {
+                    Log.i(tag, msg, tr)
+                    onLog("info", tag, msg)
+                }
+
+                override fun w(
+                    tag: String,
+                    msg: String,
+                ) {
+                    Log.w(tag, msg)
+                    onLog("warn", tag, msg)
+                }
+
+                override fun w(
+                    tag: String,
+                    msg: String,
+                    tr: Throwable,
+                ) {
+                    Log.w(tag, msg, tr)
+                    onLog("warn", tag, msg)
+                }
+
+                override fun e(
+                    tag: String,
+                    msg: String,
+                ) {
+                    Log.e(tag, msg)
+                    onLog("error", tag, msg)
+                }
+
+                override fun e(
+                    tag: String,
+                    msg: String,
+                    tr: Throwable,
+                ) {
+                    Log.e(tag, msg, tr)
+                    onLog("error", tag, msg)
+                }
+            },
+        )
+    }
+
+    override fun setLogLevel(level: String) {
+        @Logger.LogLevel val logLevel =
+            when (level) {
+                "error" -> Logger.ERROR
+                "warn" -> Logger.WARN
+                "info" -> Logger.INFO
+                "debug" -> Logger.DEBUG
+                "verbose" -> Logger.VERBOSE
+                else -> Logger.NONE
+            }
+        Logger.setVerbosity(logLevel)
+    }
+
+    fun onLog(
+        level: String,
+        tag: String,
+        msg: String,
+    ) {
+        val event = Arguments.createMap()
+        event.putString("level", level)
+        event.putString("tag", tag)
+        event.putString("message", msg)
+
+        emitOnLog(event)
+    }
+}

package/android/src/main/java/io/github/mapvina/reactnative/modules/MLRNNetworkModule.kt

@@ -0,0 +1,25 @@
+package io.github.mapvina.reactnative.modules
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import io.github.mapvina.android.MapVina
+import io.github.mapvina.reactnative.NativeNetworkModuleSpec
+
+@ReactModule(name = MLRNNetworkModule.NAME)
+class MLRNNetworkModule(
+    reactContext: ReactApplicationContext,
+) : NativeNetworkModuleSpec(reactContext) {
+    companion object {
+        const val NAME = "MLRNNetworkModule"
+    }
+
+    override fun getName() = NAME
+
+    private val context: ReactApplicationContext = reactContext
+
+    override fun setConnected(connected: Boolean) {
+        context.runOnUiQueueThread {
+            MapVina.setConnected(connected)
+        }
+    }
+}