react-native-nitro-geolocation 1.2.5 → 1.3.0

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

@@ -0,0 +1,134 @@
+package com.margelo.nitro.nitrogeolocation.background
+
+import com.margelo.nitro.nitrogeolocation.BackgroundHttpSyncOptions
+import com.margelo.nitro.nitrogeolocation.BackgroundHttpSyncResult
+import com.margelo.nitro.nitrogeolocation.StoredBackgroundLocation
+import java.io.OutputStreamWriter
+import java.net.HttpURLConnection
+import java.net.URL
+
+internal class AndroidBackgroundHttpSync {
+    fun uploadLocationsWithRetry(
+        sync: BackgroundHttpSyncOptions,
+        locations: Array<StoredBackgroundLocation>
+    ): BackgroundHttpSyncResult {
+        val ids = locations.map { it.id }
+        val maxAttempts = if (sync.retry == true) {
+            (sync.maxRetries?.toInt()?.takeIf { it >= 0 } ?: 3) + 1
+        } else {
+            1
+        }
+        var lastStatus: Int? = null
+        var lastError: String? = null
+
+        if (sync.batch == false) {
+            return uploadSingleLocationsWithRetry(sync, locations, maxAttempts)
+        }
+
+        repeat(maxAttempts) { attempt ->
+            try {
+                val response = uploadLocations(sync, locations)
+                lastStatus = response
+                if (response in 200..299) {
+                    return BackgroundHttpSyncResult(
+                        true,
+                        response.toDouble(),
+                        ids.toTypedArray(),
+                        emptyArray(),
+                        null
+                    )
+                }
+                lastError = "HTTP sync failed with status $response"
+            } catch (error: Exception) {
+                lastError = error.message ?: "HTTP sync failed"
+            }
+            if (attempt < maxAttempts - 1) {
+                Thread.sleep(1_000L)
+            }
+        }
+
+        return BackgroundHttpSyncResult(
+            false,
+            lastStatus?.toDouble(),
+            emptyArray(),
+            ids.toTypedArray(),
+            lastError ?: "HTTP sync failed"
+        )
+    }
+
+    private fun uploadLocations(
+        sync: BackgroundHttpSyncOptions,
+        locations: Array<StoredBackgroundLocation>
+    ): Int {
+        val connection = createConnection(sync)
+        OutputStreamWriter(connection.outputStream).use { writer ->
+            writer.write(sync.batchBody(locations).toString())
+        }
+        return connection.responseCode
+    }
+
+    private fun uploadSingleLocationsWithRetry(
+        sync: BackgroundHttpSyncOptions,
+        locations: Array<StoredBackgroundLocation>,
+        maxAttempts: Int
+    ): BackgroundHttpSyncResult {
+        val synced = mutableListOf<String>()
+        val failed = mutableListOf<String>()
+        var lastStatus: Int? = null
+        var lastError: String? = null
+
+        for (location in locations) {
+            var didSync = false
+            for (attempt in 0 until maxAttempts) {
+                try {
+                    val response = uploadLocation(sync, location)
+                    lastStatus = response
+                    if (response in 200..299) {
+                        synced += location.id
+                        didSync = true
+                        break
+                    }
+                    lastError = "HTTP sync failed with status $response"
+                } catch (error: Exception) {
+                    lastError = error.message ?: "HTTP sync failed"
+                }
+                if (!didSync && attempt < maxAttempts - 1) {
+                    Thread.sleep(1_000L)
+                }
+            }
+            if (!didSync) {
+                failed += location.id
+            }
+        }
+
+        return BackgroundHttpSyncResult(
+            failed.isEmpty(),
+            lastStatus?.toDouble(),
+            synced.toTypedArray(),
+            failed.toTypedArray(),
+            if (failed.isEmpty()) null else lastError ?: "HTTP sync failed"
+        )
+    }
+
+    private fun uploadLocation(
+        sync: BackgroundHttpSyncOptions,
+        location: StoredBackgroundLocation
+    ): Int {
+        val connection = createConnection(sync)
+        OutputStreamWriter(connection.outputStream).use { writer ->
+            writer.write(sync.singleBody(location).toString())
+        }
+        return connection.responseCode
+    }
+
+    private fun createConnection(sync: BackgroundHttpSyncOptions): HttpURLConnection {
+        return (URL(sync.url).openConnection() as HttpURLConnection).apply {
+            requestMethod = sync.method?.name ?: "POST"
+            connectTimeout = 15_000
+            readTimeout = 15_000
+            doOutput = true
+            setRequestProperty("Content-Type", "application/json")
+            sync.headers?.forEach { (key, value) -> setRequestProperty(key, value) }
+        }
+    }
+}

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

@@ -0,0 +1,196 @@
+package com.margelo.nitro.nitrogeolocation.background
+
+import android.Manifest
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.provider.Settings
+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
+import com.margelo.nitro.nitrogeolocation.*
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+
+internal class AndroidBackgroundPermissions(
+    private val appContext: Context,
+    private val configProvider: () -> BackgroundLocationOptions?
+) {
+    fun checkBackgroundPermission(): BackgroundPermissionResult {
+        val foreground = foregroundPermission()
+        val background = backgroundPermission()
+        return BackgroundPermissionResult(
+            foreground,
+            background,
+            accuracyAuthorization(),
+            Build.VERSION.SDK_INT < Build.VERSION_CODES.R,
+            background != BackgroundPermissionStatus.GRANTED
+        )
+    }
+
+    fun requestBackgroundPermission(reactContext: ReactApplicationContext): BackgroundPermissionResult {
+        val activity = reactContext.currentActivity
+        if (activity != null) {
+            val permissions = mutableListOf<String>()
+            if (foregroundPermission() != PermissionStatus.GRANTED) {
+                permissions += Manifest.permission.ACCESS_FINE_LOCATION
+                permissions += Manifest.permission.ACCESS_COARSE_LOCATION
+            }
+            if (Build.VERSION.SDK_INT == Build.VERSION_CODES.Q &&
+                backgroundPermission() != BackgroundPermissionStatus.GRANTED) {
+                permissions += Manifest.permission.ACCESS_BACKGROUND_LOCATION
+            }
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU &&
+                configProvider()?.android?.requestNotificationPermission != false &&
+                notificationPermission() != PermissionStatus.GRANTED) {
+                permissions += Manifest.permission.POST_NOTIFICATIONS
+            }
+            if (permissions.isNotEmpty()) {
+                requestPermissionsAndWait(activity, permissions.toTypedArray())
+            }
+        }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R &&
+            backgroundPermission() != BackgroundPermissionStatus.GRANTED) {
+            openAppLocationSettings()
+        }
+        return checkBackgroundPermission()
+    }
+
+    fun openAppLocationSettings() {
+        val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
+            .setData(Uri.fromParts("package", appContext.packageName, null))
+            .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        appContext.startActivity(intent)
+    }
+
+    fun foregroundPermission(): PermissionStatus {
+        val fine = ContextCompat.checkSelfPermission(
+            appContext,
+            Manifest.permission.ACCESS_FINE_LOCATION
+        ) == PackageManager.PERMISSION_GRANTED
+        val coarse = ContextCompat.checkSelfPermission(
+            appContext,
+            Manifest.permission.ACCESS_COARSE_LOCATION
+        ) == PackageManager.PERMISSION_GRANTED
+        return if (fine || coarse) PermissionStatus.GRANTED else PermissionStatus.DENIED
+    }
+
+    fun backgroundPermission(): BackgroundPermissionStatus {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+            return BackgroundPermissionStatus.GRANTED
+        }
+        return if (
+            ContextCompat.checkSelfPermission(
+                appContext,
+                Manifest.permission.ACCESS_BACKGROUND_LOCATION
+            ) == PackageManager.PERMISSION_GRANTED
+        ) {
+            BackgroundPermissionStatus.GRANTED
+        } else {
+            BackgroundPermissionStatus.DENIED
+        }
+    }
+
+    fun notificationPermission(): PermissionStatus? {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) return null
+        return if (
+            ContextCompat.checkSelfPermission(
+                appContext,
+                Manifest.permission.POST_NOTIFICATIONS
+            ) == PackageManager.PERMISSION_GRANTED
+        ) {
+            PermissionStatus.GRANTED
+        } else {
+            PermissionStatus.DENIED
+        }
+    }
+
+    fun accuracyAuthorization(): AccuracyAuthorization {
+        val fine = ContextCompat.checkSelfPermission(
+            appContext,
+            Manifest.permission.ACCESS_FINE_LOCATION
+        ) == PackageManager.PERMISSION_GRANTED
+        val coarse = ContextCompat.checkSelfPermission(
+            appContext,
+            Manifest.permission.ACCESS_COARSE_LOCATION
+        ) == PackageManager.PERMISSION_GRANTED
+        return when {
+            fine -> AccuracyAuthorization.FULL
+            coarse -> AccuracyAuthorization.REDUCED
+            else -> AccuracyAuthorization.UNKNOWN
+        }
+    }
+
+    private fun requestPermissionsAndWait(
+        activity: android.app.Activity,
+        permissions: Array<String>
+    ) {
+        val permissionAware = activity as? PermissionAwareActivity
+        val latch = CountDownLatch(1)
+        var lifecycleCallbacks: android.app.Application.ActivityLifecycleCallbacks? = null
+        fun finishNonPermissionAwareRequest() {
+            latch.countDown()
+            lifecycleCallbacks?.let {
+                runCatching {
+                    activity.application.unregisterActivityLifecycleCallbacks(it)
+                }
+                lifecycleCallbacks = null
+            }
+        }
+        if (permissionAware == null) {
+            lifecycleCallbacks = object : android.app.Application.ActivityLifecycleCallbacks {
+                override fun onActivityCreated(
+                    activity: android.app.Activity,
+                    savedInstanceState: android.os.Bundle?
+                ) = Unit
+                override fun onActivityStarted(activity: android.app.Activity) = Unit
+                override fun onActivityResumed(resumedActivity: android.app.Activity) {
+                    if (resumedActivity === activity) {
+                        finishNonPermissionAwareRequest()
+                    }
+                }
+                override fun onActivityPaused(activity: android.app.Activity) = Unit
+                override fun onActivityStopped(activity: android.app.Activity) = Unit
+                override fun onActivitySaveInstanceState(
+                    activity: android.app.Activity,
+                    outState: android.os.Bundle
+                ) = Unit
+                override fun onActivityDestroyed(activity: android.app.Activity) = Unit
+            }
+            activity.application.registerActivityLifecycleCallbacks(lifecycleCallbacks)
+        }
+        Handler(Looper.getMainLooper()).post {
+            if (permissionAware == null) {
+                androidx.core.app.ActivityCompat.requestPermissions(activity, permissions, 9473)
+                Handler(Looper.getMainLooper()).postDelayed(
+                    { finishNonPermissionAwareRequest() },
+                    60_000
+                )
+            } else {
+                permissionAware.requestPermissions(
+                    permissions,
+                    9473,
+                    PermissionListener { requestCode, _, _ ->
+                        if (requestCode == 9473) {
+                            latch.countDown()
+                            true
+                        } else {
+                            false
+                        }
+                    }
+                )
+            }
+        }
+        if (Looper.myLooper() != Looper.getMainLooper()) {
+            latch.await(60, TimeUnit.SECONDS)
+        }
+        if (permissionAware == null && Looper.myLooper() != Looper.getMainLooper()) {
+            finishNonPermissionAwareRequest()
+        }
+    }
+}

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

@@ -0,0 +1,266 @@
+package com.margelo.nitro.nitrogeolocation.background
+
+import android.location.LocationManager
+import com.google.android.gms.location.Geofence
+import com.google.android.gms.location.GeofencingRequest
+import com.google.android.gms.location.DetectedActivity as GmsDetectedActivity
+import com.margelo.nitro.core.NullType
+import com.margelo.nitro.nitrogeolocation.*
+import org.json.JSONArray
+import org.json.JSONObject
+
+internal fun backgroundProviderFrom(provider: String?): LocationProviderUsed {
+    return when (provider) {
+        LocationManager.GPS_PROVIDER -> LocationProviderUsed.GPS
+        LocationManager.NETWORK_PROVIDER -> LocationProviderUsed.NETWORK
+        LocationManager.PASSIVE_PROVIDER -> LocationProviderUsed.PASSIVE
+        "fused" -> LocationProviderUsed.FUSED
+        else -> LocationProviderUsed.UNKNOWN
+    }
+}
+
+internal fun BackgroundEventEnvelope.toJson(): JSONObject {
+    return JSONObject()
+        .put("id", id)
+        .put("type", type.jsValue())
+        .put("timestamp", timestamp)
+        .put("deliveredToJS", deliveredToJS)
+        .apply {
+            location?.let { put("location", it.toJson()) }
+            geofence?.let { put("geofence", it.toJson()) }
+            activity?.let { put("activity", it.toJson()) }
+            result?.let { put("result", it.toJson()) }
+        }
+}
+
+internal fun BackgroundHttpSyncResult.toJson(): JSONObject {
+    return JSONObject()
+        .put("success", success)
+        .put("statusCode", statusCode)
+        .put("syncedLocationIds", JSONArray(syncedLocationIds.toList()))
+        .put("failedLocationIds", JSONArray(failedLocationIds.toList()))
+        .put("error", error)
+}
+
+internal fun DetectedActivity.toJson(): JSONObject {
+    return JSONObject()
+        .put("type", type.jsValue())
+        .put("confidence", confidence)
+        .put("timestamp", timestamp)
+}
+
+internal fun StoredBackgroundLocation.toJson(): JSONObject {
+    return JSONObject()
+        .put("id", id)
+        .put("deliveredToJS", deliveredToJS)
+        .put("synced", synced)
+        .put("createdAt", createdAt)
+        .put("source", source.jsValue())
+        .put("isFromBackground", isFromBackground)
+        .put("provider", provider?.jsValue())
+        .put("mocked", mocked)
+        .put("recordedAt", recordedAt)
+        .put("coords", coords.toJson())
+        .put("timestamp", timestamp)
+}
+
+internal fun BackgroundLocation.toJson(): JSONObject {
+    return JSONObject()
+        .put("id", id)
+        .put("source", source.jsValue())
+        .put("isFromBackground", isFromBackground)
+        .put("provider", provider?.jsValue())
+        .put("mocked", mocked)
+        .put("recordedAt", recordedAt)
+        .put("coords", coords.toJson())
+        .put("timestamp", timestamp)
+}
+
+internal fun GeolocationCoordinates.toJson(): JSONObject {
+    return JSONObject()
+        .put("latitude", latitude)
+        .put("longitude", longitude)
+        .put("altitude", altitude?.asSecondOrNull())
+        .put("accuracy", accuracy)
+        .put("altitudeAccuracy", altitudeAccuracy?.asSecondOrNull())
+        .put("heading", heading?.asSecondOrNull())
+        .put("speed", speed?.asSecondOrNull())
+}
+
+internal fun GeofenceEvent.toJson(): JSONObject {
+    return JSONObject()
+        .put("region", region.toJson())
+        .put("transition", transition.jsValue())
+        .put("timestamp", timestamp)
+}
+
+internal fun GeofenceRegion.toJson(): JSONObject {
+    return JSONObject()
+        .put("identifier", identifier)
+        .put("latitude", latitude)
+        .put("longitude", longitude)
+        .put("radius", radius)
+        .put("notifyOnEntry", notifyOnEntry)
+        .put("notifyOnExit", notifyOnExit)
+        .put("notifyOnDwell", notifyOnDwell)
+        .put("loiteringDelay", loiteringDelay)
+        .put("expirationDuration", expirationDuration)
+        .put("metadata", metadataToJsonObject(metadata))
+}
+
+internal fun metadataToJsonObject(
+    metadata: Map<String, Variant_NullType_Boolean_String_Double>?
+): JSONObject? {
+    metadata ?: return null
+    val json = JSONObject()
+    metadata.forEach { (key, value) ->
+        when (value) {
+            is Variant_NullType_Boolean_String_Double.First -> json.put(key, JSONObject.NULL)
+            is Variant_NullType_Boolean_String_Double.Second -> json.put(key, value.value)
+            is Variant_NullType_Boolean_String_Double.Third -> json.put(key, value.value)
+            is Variant_NullType_Boolean_String_Double.Fourth -> json.put(key, value.value)
+        }
+    }
+    return json
+}
+
+internal fun stringMapToJson(map: Map<String, String>): String {
+    val json = JSONObject()
+    map.forEach { (key, value) -> json.put(key, value) }
+    return json.toString()
+}
+
+internal fun jsonToStringMap(payload: String): Map<String, String> {
+    val json = JSONObject(payload)
+    val map = mutableMapOf<String, String>()
+    val keys = json.keys()
+    while (keys.hasNext()) {
+        val key = keys.next()
+        map[key] = json.getString(key)
+    }
+    return map
+}
+
+internal fun variantMapToJson(map: Map<String, Variant_NullType_Boolean_String_Double>): String {
+    return metadataToJsonObject(map)?.toString() ?: "{}"
+}
+
+internal fun jsonToVariantMap(payload: String): Map<String, Variant_NullType_Boolean_String_Double> {
+    val json = JSONObject(payload)
+    val map = mutableMapOf<String, Variant_NullType_Boolean_String_Double>()
+    val keys = json.keys()
+    while (keys.hasNext()) {
+        val key = keys.next()
+        map[key] = when (val value = json.get(key)) {
+            JSONObject.NULL -> Variant_NullType_Boolean_String_Double.create(NullType.NULL)
+            is Boolean -> Variant_NullType_Boolean_String_Double.create(value)
+            is String -> Variant_NullType_Boolean_String_Double.create(value)
+            is Number -> Variant_NullType_Boolean_String_Double.create(value.toDouble())
+            else -> Variant_NullType_Boolean_String_Double.create(value.toString())
+        }
+    }
+    return map
+}
+
+internal fun BackgroundHttpSyncOptions.batchBody(locations: Array<StoredBackgroundLocation>): JSONObject {
+    val body = metadataToJsonObject(bodyTemplate) ?: JSONObject()
+    body.put("locations", JSONArray(locations.map { it.toJson() }))
+    return body
+}
+
+internal fun BackgroundHttpSyncOptions.singleBody(location: StoredBackgroundLocation): JSONObject {
+    val body = metadataToJsonObject(bodyTemplate)
+    if (body != null) {
+        body.put("location", location.toJson())
+        return body
+    }
+    return location.toJson()
+}
+
+internal fun BackgroundEventType.jsValue(): String {
+    return when (this) {
+        BackgroundEventType.LOCATION -> "location"
+        BackgroundEventType.GEOFENCE -> "geofence"
+        BackgroundEventType.ACTIVITY -> "activity"
+        BackgroundEventType.PROVIDERCHANGE -> "providerChange"
+        BackgroundEventType.HTTPSYNC -> "httpSync"
+        BackgroundEventType.ERROR -> "error"
+    }
+}
+
+internal fun BackgroundLocationSource.jsValue(): String {
+    return when (this) {
+        BackgroundLocationSource.FOREGROUNDSERVICE -> "foregroundService"
+        BackgroundLocationSource.BACKGROUND -> "background"
+        BackgroundLocationSource.SIGNIFICANTCHANGE -> "significantChange"
+        BackgroundLocationSource.GEOFENCE -> "geofence"
+        BackgroundLocationSource.DEFERRED -> "deferred"
+        BackgroundLocationSource.MANUAL -> "manual"
+        BackgroundLocationSource.UNKNOWN -> "unknown"
+    }
+}
+
+internal fun LocationProviderUsed.jsValue(): String {
+    return when (this) {
+        LocationProviderUsed.GPS -> "gps"
+        LocationProviderUsed.NETWORK -> "network"
+        LocationProviderUsed.PASSIVE -> "passive"
+        LocationProviderUsed.FUSED -> "fused"
+        LocationProviderUsed.UNKNOWN -> "unknown"
+    }
+}
+
+internal fun GeofenceTransition.jsValue(): String {
+    return when (this) {
+        GeofenceTransition.ENTER -> "enter"
+        GeofenceTransition.EXIT -> "exit"
+        GeofenceTransition.DWELL -> "dwell"
+    }
+}
+
+internal fun DetectedActivityType.jsValue(): String {
+    return when (this) {
+        DetectedActivityType.STILL -> "still"
+        DetectedActivityType.WALKING -> "walking"
+        DetectedActivityType.RUNNING -> "running"
+        DetectedActivityType.ONFOOT -> "onFoot"
+        DetectedActivityType.ONBICYCLE -> "onBicycle"
+        DetectedActivityType.INVEHICLE -> "inVehicle"
+        DetectedActivityType.TILTING -> "tilting"
+        DetectedActivityType.UNKNOWN -> "unknown"
+    }
+}
+
+internal fun GmsDetectedActivity.toNitroActivityType(): DetectedActivityType {
+    return when (type) {
+        GmsDetectedActivity.STILL -> DetectedActivityType.STILL
+        GmsDetectedActivity.WALKING -> DetectedActivityType.WALKING
+        GmsDetectedActivity.RUNNING -> DetectedActivityType.RUNNING
+        GmsDetectedActivity.ON_FOOT -> DetectedActivityType.ONFOOT
+        GmsDetectedActivity.ON_BICYCLE -> DetectedActivityType.ONBICYCLE
+        GmsDetectedActivity.IN_VEHICLE -> DetectedActivityType.INVEHICLE
+        GmsDetectedActivity.TILTING -> DetectedActivityType.TILTING
+        else -> DetectedActivityType.UNKNOWN
+    }
+}
+
+internal fun GeofenceRegion.toTransitionTypes(): Int {
+    var transitions = 0
+    if (notifyOnEntry != false) transitions = transitions or Geofence.GEOFENCE_TRANSITION_ENTER
+    if (notifyOnExit != false) transitions = transitions or Geofence.GEOFENCE_TRANSITION_EXIT
+    if (notifyOnDwell == true) transitions = transitions or Geofence.GEOFENCE_TRANSITION_DWELL
+    return transitions
+}
+
+internal fun GeofencingOptions?.toInitialTrigger(): Int {
+    val triggers = this?.initialTrigger ?: return 0
+    var value = 0
+    for (trigger in triggers) {
+        value = value or when (trigger) {
+            GeofenceTransition.ENTER -> GeofencingRequest.INITIAL_TRIGGER_ENTER
+            GeofenceTransition.EXIT -> GeofencingRequest.INITIAL_TRIGGER_EXIT
+            GeofenceTransition.DWELL -> GeofencingRequest.INITIAL_TRIGGER_DWELL
+        }
+    }
+    return value
+}

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

@@ -0,0 +1,13 @@
+package com.margelo.nitro.nitrogeolocation.background
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+
+class NitroActivityRecognitionReceiver : BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+        NitroBackgroundLocationController
+            .getInstance(context)
+            .handleActivityRecognition(intent)
+    }
+}

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

@@ -0,0 +1,65 @@
+package com.margelo.nitro.nitrogeolocation.background
+
+import com.margelo.nitro.nitrogeolocation.BackgroundEventEnvelope
+import com.margelo.nitro.nitrogeolocation.BackgroundEventType
+import com.margelo.nitro.nitrogeolocation.BackgroundLocation
+import com.margelo.nitro.nitrogeolocation.LocationError
+import java.util.UUID
+import java.util.concurrent.ConcurrentHashMap
+
+class NitroBackgroundEventHub {
+    private val eventListeners =
+        ConcurrentHashMap<String, (BackgroundEventEnvelope) -> Unit>()
+    private val locationListeners =
+        ConcurrentHashMap<String, (BackgroundLocation) -> Unit>()
+    private val errorListeners =
+        ConcurrentHashMap<String, (LocationError) -> Unit>()
+
+    fun addEventListener(listener: (BackgroundEventEnvelope) -> Unit): String {
+        val token = UUID.randomUUID().toString()
+        eventListeners[token] = listener
+        return token
+    }
+
+    fun removeEventListener(token: String) {
+        eventListeners.remove(token)
+    }
+
+    fun addLocationListener(listener: (BackgroundLocation) -> Unit): String {
+        val token = UUID.randomUUID().toString()
+        locationListeners[token] = listener
+        return token
+    }
+
+    fun removeLocationListener(token: String) {
+        locationListeners.remove(token)
+    }
+
+    fun addErrorListener(listener: (LocationError) -> Unit): String {
+        val token = UUID.randomUUID().toString()
+        errorListeners[token] = listener
+        return token
+    }
+
+    fun removeErrorListener(token: String) {
+        errorListeners.remove(token)
+    }
+
+    fun emit(event: BackgroundEventEnvelope) {
+        eventListeners.values.forEach { listener -> listener(event) }
+
+        when (event.type) {
+            BackgroundEventType.LOCATION -> {
+                event.location?.let { location ->
+                    locationListeners.values.forEach { listener -> listener(location) }
+                }
+            }
+            BackgroundEventType.ERROR -> {
+                event.error?.let { error ->
+                    errorListeners.values.forEach { listener -> listener(error) }
+                }
+            }
+            else -> Unit
+        }
+    }
+}