@expofp/react-native-efp-crowdconnected 0.0.2-alpha.1

package/android/src/main/java/com/expofpcrowdconnected/ExpofpCrowdconnectedPackage.kt

@@ -0,0 +1,33 @@
+package com.expofpcrowdconnected
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class ExpofpCrowdconnectedPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == RCTCrowdConnectedLocationProviderModule.MODULE_NAME) {
+      RCTCrowdConnectedLocationProviderModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[RCTCrowdConnectedLocationProviderModule.MODULE_NAME] = ReactModuleInfo(
+        RCTCrowdConnectedLocationProviderModule.MODULE_NAME,
+        RCTCrowdConnectedLocationProviderModule.MODULE_NAME,
+        false,  // canOverrideExistingModule
+        false,  // needsEagerInit
+        false,  // isCxxModule
+        false  // isTurboModule
+      )
+      moduleInfos
+    }
+  }
+}

package/android/src/main/java/com/expofpcrowdconnected/RCTCrowdConnectedLocationProviderModule.kt

@@ -0,0 +1,504 @@
+package com.expofpcrowdconnected
+
+import android.Manifest
+import android.app.Application
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import android.util.Log
+import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import net.crowdconnected.android.core.CrowdConnected
+import net.crowdconnected.android.core.StatusCallback
+import net.crowdconnected.android.core.Configuration
+import net.crowdconnected.android.core.ConfigurationBuilder
+import net.crowdconnected.android.geo.GeoModule
+import net.crowdconnected.android.ips.IPSModule
+
+/**
+ * React Native module for CrowdConnected location provider
+ * Provides cross-platform API: setup, startUpdatingLocation, stopUpdatingLocation, isLocationUpdating
+ * Emits events: onLocationChange, onLocationError
+ */
+class RCTCrowdConnectedLocationProviderModule(
+    reactContext: ReactApplicationContext
+) : ReactContextBaseJavaModule(reactContext) {
+
+    companion object {
+        const val MODULE_NAME = "RCTCrowdConnectedLocationProvider"
+        private const val TAG = "RCTCrowdConnected"
+        private const val EVENT_LOCATION_CHANGE = "onLocationChange"
+        private const val EVENT_LOCATION_ERROR = "onLocationError"
+        private const val TIMEOUT_DURATION_MS = 65_000L // 65 seconds timeout for SDK startup
+
+        // Foreground service notification
+        private const val NOTIFICATION_TITLE = "Location tracking is active"
+        private const val NOTIFICATION_ICON = android.R.drawable.ic_menu_mylocation
+
+        /**
+         * Check for missing runtime permissions
+         * Returns list of permissions that are not granted
+         */
+        fun missingPermissions(
+            context: Context,
+            settings: ExpoFpCrowdConnectedLocationProviderSettings
+        ): List<String> {
+            val required = buildList {
+                // Location permission (always required)
+                add(Manifest.permission.ACCESS_FINE_LOCATION)
+
+                // Bluetooth permissions vary by API level
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                    // Android 12+ (API 31+)
+                    if (settings.isBluetoothEnabled) {
+                        add(Manifest.permission.BLUETOOTH_SCAN)
+                        add(Manifest.permission.BLUETOOTH_CONNECT)
+                    }
+                } else {
+                    // Android 11 and below (API 30 and below)
+                    if (settings.isBluetoothEnabled) {
+                        add(Manifest.permission.BLUETOOTH)
+                        add(Manifest.permission.BLUETOOTH_ADMIN)
+                    }
+                    add(Manifest.permission.ACCESS_COARSE_LOCATION)
+                }
+
+                // Background location (Android 10+, API 29+)
+                if (settings.isBackgroundUpdateEnabled &&
+                    Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                    add(Manifest.permission.ACCESS_BACKGROUND_LOCATION)
+                }
+            }
+
+            return required.filter {
+                ContextCompat.checkSelfPermission(context, it) != PackageManager.PERMISSION_GRANTED
+            }
+        }
+    }
+
+    /**
+     * Coroutine scope for async operations
+     * - SupervisorJob ensures that failure in one coroutine doesn't cancel others
+     * - Dispatchers.Main ensures we're on the main thread for React Native operations
+     */
+    private val moduleScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+
+    /**
+     * Mutex for thread-safe state management
+     * Protects access to: settings, providerInfo, isStarted, currentPosition, azimuthProvider
+     * All ReactMethod calls and internal state modifications must acquire this lock
+     */
+    private val mutex = Mutex()
+
+    // Timeout job for SDK start (65 seconds)
+    private var timeoutJob: Job? = null
+
+    /**
+     * Module state - protected by mutex
+     * These fields should only be accessed within mutex.withLock { } blocks or on main thread
+     * @Volatile ensures visibility across threads for reads outside mutex (e.g., onCatalystInstanceDestroy)
+     */
+    @Volatile private var settings: ExpoFpCrowdConnectedLocationProviderSettings? = null
+    @Volatile private var providerInfo = ExpoFpProviderInfo(deviceId = null, isLocationUpdating = false)
+    @Volatile private var currentPosition: ExpoFpPosition? = null
+    @Volatile private var azimuthProvider: ExpoFpAzimuthProvider? = null
+    @Volatile private var isStarted = false
+
+    override fun getName(): String = MODULE_NAME
+
+    /**
+     * Setup and configure the CrowdConnected SDK
+     * If location updates are already running, they will be stopped and restarted with new settings
+     */
+    @ReactMethod
+    fun setup(settingsMap: ReadableMap, promise: Promise) {
+        moduleScope.launch {
+            try {
+                mutex.withLock {
+                    Log.d(TAG, "setup: Configuring CrowdConnected SDK")
+
+                    // Parse settings from JavaScript
+                    val newSettings = ExpoFpCrowdConnectedLocationProviderSettings.fromReadableMap(settingsMap)
+                    settings = newSettings
+
+                    Log.d(TAG, "setup: Navigation type: ${newSettings.navigationType}, Background: ${newSettings.isBackgroundUpdateEnabled}, Heading: ${newSettings.isHeadingEnabled}")
+
+                    // If already updating, stop first
+                    val wasUpdating = providerInfo.isLocationUpdating
+                    if (wasUpdating) {
+                        Log.d(TAG, "setup: Already updating, stopping before restart")
+                        stopUpdatingLocationInternal()
+                    }
+
+                    // If was updating, restart with new settings
+                    if (wasUpdating) {
+                        Log.d(TAG, "setup: Restarting with new settings")
+                        startUpdatingLocationInternal(promise)
+                    } else {
+                        Log.d(TAG, "setup: Configuration complete")
+                        promise.resolve(providerInfo.toWritableMap())
+                    }
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "setup: Failed to configure SDK", e)
+                promise.reject("SETUP_ERROR", e.message, e)
+            }
+        }
+    }
+
+    /**
+     * Start location updates
+     */
+    @ReactMethod
+    fun startUpdatingLocation(promise: Promise) {
+        moduleScope.launch {
+            try {
+                mutex.withLock {
+                    startUpdatingLocationInternal(promise)
+                }
+            } catch (e: Exception) {
+                promise.reject("START_ERROR", e.message, e)
+            }
+        }
+    }
+
+    /**
+     * Stop location updates
+     */
+    @ReactMethod
+    fun stopUpdatingLocation(promise: Promise) {
+        moduleScope.launch {
+            try {
+                mutex.withLock {
+                    stopUpdatingLocationInternal()
+                    promise.resolve(providerInfo.toWritableMap())
+                }
+            } catch (e: Exception) {
+                promise.reject("STOP_ERROR", e.message, e)
+            }
+        }
+    }
+
+    /**
+     * Check if location updates are currently active
+     */
+    @ReactMethod
+    fun isLocationUpdating(promise: Promise) {
+        try {
+            promise.resolve(providerInfo.toWritableMap())
+        } catch (e: Exception) {
+            promise.reject("STATUS_ERROR", e.message, e)
+        }
+    }
+
+    /**
+     * Internal method to start location updates (must be called within mutex lock)
+     */
+    private suspend fun startUpdatingLocationInternal(promise: Promise) {
+        Log.d(TAG, "startUpdatingLocationInternal: Starting location updates")
+
+        // Check settings
+        val currentSettings = settings
+            ?: throw IllegalStateException("Settings are missing. Use 'setup' method first.")
+
+        // Already updating
+        if (providerInfo.isLocationUpdating) {
+            Log.d(TAG, "startUpdatingLocationInternal: Already updating")
+            promise.resolve(providerInfo.toWritableMap())
+            return
+        }
+
+        // Check permissions
+        val missing = missingPermissions(reactApplicationContext, currentSettings)
+        if (missing.isNotEmpty()) {
+            Log.e(TAG, "startUpdatingLocationInternal: Missing permissions: ${missing.joinToString(", ")}")
+            throw IllegalStateException(
+                "Missing required permissions: ${missing.joinToString(", ")}"
+            )
+        }
+
+        Log.d(TAG, "startUpdatingLocationInternal: Permissions granted, starting SDK")
+
+        // Mark as updating (but not started yet - will set after SDK starts successfully)
+        providerInfo = providerInfo.copy(isLocationUpdating = true)
+
+        // Start azimuth provider if heading is enabled
+        if (currentSettings.isHeadingEnabled) {
+            Log.d(TAG, "startUpdatingLocationInternal: Starting azimuth provider")
+            azimuthProvider = ExpoFpAzimuthProvider(reactApplicationContext) { newAngle ->
+                // Update current position with new heading
+                currentPosition?.let { pos ->
+                    val updatedPosition = pos.updateHeading(newAngle)
+                    currentPosition = updatedPosition
+                    sendLocationEvent(updatedPosition)
+                }
+            }
+            val started = azimuthProvider?.start() ?: false
+            if (!started) {
+                Log.w(TAG, "Warning: Heading updates requested but sensor unavailable or failed to start")
+                // Continue with location tracking even if heading is not available
+            }
+        }
+
+        // Build CrowdConnected configuration
+        val statusCallback = object : StatusCallback {
+            override fun onStartUpSuccess() {
+                Log.d(TAG, "StatusCallback: SDK startup successful")
+                // Cancel timeout on SDK startup success
+                cancelTimeoutJob()
+            }
+
+            override fun onStartUpFailure(reason: String) {
+                Log.e(TAG, "StatusCallback: SDK startup failed: $reason")
+                sendErrorEvent("StartUp Failure: $reason")
+                moduleScope.launch {
+                    mutex.withLock {
+                        stopUpdatingLocationInternal()
+                    }
+                }
+            }
+
+            override fun onRuntimeError(error: String) {
+                Log.e(TAG, "StatusCallback: Runtime error: $error")
+                sendErrorEvent("Runtime Error: $error")
+            }
+        }
+
+        val builder = ConfigurationBuilder()
+            .withAppKey(currentSettings.appKey)
+            .withToken(currentSettings.token)
+            .withSecret(currentSettings.secret)
+            .withStatusCallback(statusCallback)
+
+        // Add modules based on navigation type
+        when (currentSettings.navigationType) {
+            ExpoFpCrowdConnectedNavigationType.ALL -> {
+                builder.addModule(IPSModule())
+                builder.addModule(GeoModule())
+            }
+            ExpoFpCrowdConnectedNavigationType.IPS -> {
+                builder.addModule(IPSModule())
+            }
+            ExpoFpCrowdConnectedNavigationType.GEO -> {
+                builder.addModule(GeoModule())
+            }
+        }
+
+        // Set foreground service notification if background updates are enabled
+        if (currentSettings.isBackgroundUpdateEnabled) {
+            builder.withServiceNotificationInfo(
+                NOTIFICATION_TITLE,
+                NOTIFICATION_ICON
+            )
+        }
+
+        val config: Configuration = builder.build()
+
+        // Start timeout job before starting SDK
+        startTimeoutJob(promise)
+
+        // Start CrowdConnected SDK
+        try {
+            val app = reactApplicationContext.applicationContext as Application
+            CrowdConnected.start(app, config)
+
+            Log.i(TAG, "CrowdConnected SDK start initiated")
+
+            // Get device ID from CrowdConnected instance
+            val deviceId = CrowdConnected.getInstance()?.getDeviceId()
+            if (deviceId != null) {
+                providerInfo = providerInfo.copy(deviceId = deviceId)
+                Log.d(TAG, "Device ID set: $deviceId")
+            }
+
+            // Mark as started (SDK successfully started)
+            isStarted = true
+
+            // Register position callback
+            registerPositionCallback()
+
+            // Apply aliases
+            if (currentSettings.aliases.isNotEmpty()) {
+                Log.d(TAG, "Applying ${currentSettings.aliases.size} aliases")
+                currentSettings.aliases.forEach { (key, value) ->
+                    CrowdConnected.getInstance()?.setAlias(key, value)
+                }
+            }
+
+            promise.resolve(providerInfo.toWritableMap())
+        } catch (e: Exception) {
+            Log.e(TAG, "CrowdConnected SDK start failed with exception", e)
+            cancelTimeoutJob()
+            stopUpdatingLocationInternal()
+            throw e
+        }
+    }
+
+    /**
+     * Internal method to stop location updates (must be called within mutex lock)
+     */
+    private fun stopUpdatingLocationInternal() {
+        if (!isStarted) {
+            Log.d(TAG, "stopUpdatingLocationInternal: Not started, nothing to stop")
+            return
+        }
+
+        Log.d(TAG, "stopUpdatingLocationInternal: Stopping location updates")
+
+        // Cancel timeout job
+        cancelTimeoutJob()
+
+        isStarted = false
+        providerInfo = providerInfo.copy(isLocationUpdating = false)
+
+        // Deregister position callback
+        Log.d(TAG, "stopUpdatingLocationInternal: Deregistering position callback")
+        CrowdConnected.getInstance()?.deregisterPositionCallback()
+
+        // Stop CrowdConnected SDK
+        try {
+            Log.d(TAG, "stopUpdatingLocationInternal: Stopping CrowdConnected SDK")
+            CrowdConnected.getInstance()?.stop()
+        } catch (e: Exception) {
+            Log.e(TAG, "stopUpdatingLocationInternal: Error stopping CrowdConnected SDK", e)
+        }
+
+        // Stop azimuth provider
+        if (azimuthProvider != null) {
+            Log.d(TAG, "stopUpdatingLocationInternal: Stopping azimuth provider")
+            azimuthProvider?.stop()
+            azimuthProvider = null
+        }
+
+        currentPosition = null
+        Log.i(TAG, "stopUpdatingLocationInternal: Location updates stopped")
+    }
+
+    /**
+     * Register callback for position updates from CrowdConnected SDK
+     */
+    private fun registerPositionCallback() {
+        CrowdConnected.getInstance()?.registerPositionCallback { position ->
+            // Ensure we're on the main thread for React Native event emission
+            moduleScope.launch {
+                val angle = azimuthProvider?.azimuth
+
+                val expoFpPosition = ExpoFpPosition.fromCrowdConnected(
+                    locationType = position.locationType,
+                    xPixels = position.xPixels,
+                    yPixels = position.yPixels,
+                    floor = position.floor,
+                    latitude = position.latitude,
+                    longitude = position.longitude,
+                    angle = angle
+                )
+
+                currentPosition = expoFpPosition
+                sendLocationEvent(expoFpPosition)
+            }
+        }
+    }
+
+    /**
+     * Send location change event to JavaScript
+     */
+    private fun sendLocationEvent(position: ExpoFpPosition) {
+        if (!providerInfo.isLocationUpdating) {
+            Log.w(TAG, "Attempted to send location event but location updates are not active")
+            return
+        }
+
+        try {
+            reactApplicationContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                ?.emit(EVENT_LOCATION_CHANGE, position.toWritableMap())
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to send location event to JavaScript", e)
+        }
+    }
+
+    /**
+     * Send error event to JavaScript
+     * Ensures thread-safety by dispatching on main thread
+     */
+    private fun sendErrorEvent(message: String) {
+        moduleScope.launch {
+            try {
+                val deviceIdSuffix = providerInfo.deviceId?.let { " Device ID: $it" } ?: ""
+                reactApplicationContext
+                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                    ?.emit(EVENT_LOCATION_ERROR, message + deviceIdSuffix)
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to send error event to JavaScript", e)
+            }
+        }
+    }
+
+    /**
+     * Start timeout job that will stop SDK if it doesn't respond in time
+     * Uses 65 second timeout for SDK startup
+     * Note: Does not automatically restart to avoid potential infinite loops
+     */
+    private fun startTimeoutJob(promise: Promise) {
+        cancelTimeoutJob()
+
+        timeoutJob = moduleScope.launch {
+            delay(TIMEOUT_DURATION_MS)
+
+            mutex.withLock {
+                if (isStarted && providerInfo.isLocationUpdating) {
+                    Log.w(TAG, "Timeout: SDK did not respond within 65 seconds")
+                    sendErrorEvent("Start Timeout! Location updates stopped. Please restart manually.")
+                    stopUpdatingLocationInternal()
+                    // Note: Not automatically restarting to avoid potential infinite loops
+                    // User will receive error event and can manually restart if needed
+                }
+            }
+        }
+    }
+
+    /**
+     * Cancel the timeout job
+     */
+    private fun cancelTimeoutJob() {
+        timeoutJob?.cancel()
+        timeoutJob = null
+    }
+
+    /**
+     * Cleanup when React Native context is destroyed
+     * Stops location updates synchronously to prevent resource leaks
+     */
+    override fun onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy()
+
+        // Stop location updates synchronously before cancelling the scope
+        // No mutex lock needed here as we're shutting down and there's no concurrent access risk
+        if (isStarted) {
+            try {
+                Log.d(TAG, "onCatalystInstanceDestroy: Stopping location updates")
+                stopUpdatingLocationInternal()
+            } catch (e: Exception) {
+                Log.e(TAG, "onCatalystInstanceDestroy: Error during cleanup", e)
+            }
+        }
+
+        // Cancel coroutine scope
+        moduleScope.cancel()
+    }
+}

package/ios/ExpoFpLocationProvider/ExpoFpCrowdConnectedLocationProviderSettings.swift

@@ -0,0 +1,116 @@
+//
+//  ExpoFpCrowdConnectedNavigationType.swift
+//  ExpoFpCrowdConnected
+//
+//  Created by Nikita Kolesnikov on 21.05.2025.
+//  Copyright © 2025 ExpoFP. All rights reserved.
+//
+
+import CrowdConnectedCore
+
+/// Settings for `ExpoFpCrowdConnectedLocationProvider` initialization.
+struct ExpoFpCrowdConnectedLocationProviderSettings {
+
+  /// Authentication credentials: `AppKey`, `Token`, `Secret`.
+  ///
+  /// For `AppKey` [register here](https://app.crowdconnected.com/register).
+  ///
+  /// For more information use [Tokens gude](https://customer.support.crowdconnected.com/servicedesk/customer/article/2888139205).
+  let credentials: SDKCredentials
+
+  /// Navigation type to enable.
+  let navigationType: ExpoFpCrowdConnectedNavigationType
+
+  /// Tracking mode: `foregroundOnly` or `foregroundAndBackground`.
+  let trackingMode: LocationTrackingMode
+
+  /// Enables CrowdConnected CoreBluetooth positioning.
+  let isBluetoothEnabled: Bool
+
+  /// Enables 'heading' on the map using build-in native CoreLocation tools.
+  let isHeadingEnabled: Bool
+
+  /// CrowdConnected aliases for deviceID.
+  ///
+  /// For more information use [Alias guide](https://customer.support.crowdconnected.com/servicedesk/customer/kb/view/2888204977).
+  let aliases: [String: String]
+
+  init(settings: ExpoFpLocationSettings) throws(ExpoFpError) {
+    let appKey = settings.appKey.replacingOccurrences(of: " ", with: "")
+    if appKey.isEmpty { throw ExpoFpError.locationProviderError(message: Self.message(for: .missingAppKey)) }
+
+    let token = settings.token.replacingOccurrences(of: " ", with: "")
+    if token.isEmpty { throw ExpoFpError.locationProviderError(message: Self.message(for: .missingToken)) }
+
+    let secret = settings.secret.replacingOccurrences(of: " ", with: "")
+    if secret.isEmpty { throw ExpoFpError.locationProviderError(message: Self.message(for: .missingSecret)) }
+
+    self.credentials = SDKCredentials(appKey: appKey, token: token, secret: secret)
+
+    let trackingMode = settings.isBackgroundUpdateEnabled ? LocationTrackingMode.foregroundAndBackground : .foregroundOnly
+    try Self.checkLocationPermissions(for: trackingMode)
+    self.trackingMode = trackingMode
+    self.navigationType = settings.navigationType
+
+    if settings.isBluetoothEnabled { try Self.checkBluetoothPermissions() }
+    self.isBluetoothEnabled = settings.isBluetoothEnabled
+
+    self.isHeadingEnabled = settings.isHeadingEnabled
+    self.aliases = settings.aliases ?? [:]
+  }
+
+  // MARK: - Check Permission Methods
+
+  private static func checkLocationPermissions(for mode: LocationTrackingMode) throws(ExpoFpError) {
+    guard checkDescription(for: .locationWhenInUse) else {
+      throw ExpoFpError.locationProviderError(message: Self.message(for: .missingWhileInUseLocationPermissionItem))
+    }
+
+    guard mode.isAllowedInBackground else { return }
+
+    guard checkDescription(for: .locationAlwaysAndWhenInUse) else {
+      throw ExpoFpError.locationProviderError(message: Self.message(for: .missingAlwaysLocationPermissionItem))
+    }
+
+    guard checkBackgroundMode(.location) else {
+      throw ExpoFpError.locationProviderError(message: Self.message(for: .missingLocationBackgroundModeItem))
+    }
+  }
+
+  private static func checkBluetoothPermissions() throws(ExpoFpError) {
+    guard checkDescription(for: .bluetoothAlwaysUsage) else {
+      throw ExpoFpError.locationProviderError(message: Self.message(for: .missingBluetoothPermissionItem))
+    }
+
+    guard checkBackgroundMode(.bluetooth) else {
+      throw ExpoFpError.locationProviderError(message: Self.message(for: .missingBluetoothBackgroundModeItem))
+    }
+  }
+
+  private static func message(for result: CrowdConnectedValidationResult) -> String {
+    result.description
+  }
+
+  private static func checkDescription(for permission: Permission) -> Bool {
+    let description = Bundle.main.object(forInfoDictionaryKey: permission.rawValue) as? String
+    return description?.isEmpty == false
+  }
+
+  private static func checkBackgroundMode(_ mode: BackgroundMode) -> Bool {
+    let modes = (Bundle.main.object(forInfoDictionaryKey: BackgroundMode.name) as? [String]) ?? []
+    return modes.contains(mode.rawValue)
+  }
+
+  private enum BackgroundMode: String {
+    case bluetooth = "bluetooth-central"
+    case location
+
+    static let name = "UIBackgroundModes"
+  }
+
+  private enum Permission: String {
+    case bluetoothAlwaysUsage = "NSBluetoothAlwaysUsageDescription"
+    case locationWhenInUse = "NSLocationWhenInUseUsageDescription"
+    case locationAlwaysAndWhenInUse = "NSLocationAlwaysAndWhenInUseUsageDescription"
+  }
+}

package/ios/ExpoFpLocationProvider/ExpoFpCrowdConnectedNavigationType.swift

@@ -0,0 +1,14 @@
+//
+//  ExpoFpCrowdConnectedNavigationType.swift
+//  ExpoFpCrowdConnected
+//
+//  Created by Nikita Kolesnikov on 21.05.2025.
+//  Copyright © 2025 ExpoFP. All rights reserved.
+//
+
+/// A type of navigation that can be enabled in the CrowdConnected framework.
+public enum ExpoFpCrowdConnectedNavigationType: String, Codable {
+    case all
+    case geo = "GEO"
+    case ips = "IPS"
+}

package/ios/ExpoFpLocationProvider/ExpoFpError.swift

@@ -0,0 +1,28 @@
+//
+//  ExpoFpError.swift
+//  ExpoFP
+//
+//  Created by Nikita Kolesnikov on 14.04.2025.
+//  Copyright © 2025 ExpoFP. All rights reserved.
+//
+
+/// An error that representing a cause of SDK failure.
+enum ExpoFpError: Error, CustomStringConvertible {
+  /// Error inside SDK.
+  case internalError(error: Error? = nil, message: String? = nil)
+  /// Decoding error inside SDK or after network response.
+  case decodingError(error: Error? = nil, message: String? = nil)
+  /// Error while using location provider.
+  case locationProviderError(error: Error? = nil, message: String? = nil)
+
+  var description: String {
+    switch self {
+    case .internalError(let error, let message):
+      "internalError(\(String(describing: error)));\n  message: \(message ?? "")"
+    case .decodingError(let error, let message):
+      "decodingError(\(String(describing: error)));\n  message: \(message ?? "")"
+    case .locationProviderError(let error, let message):
+      "locationProviderError(\(String(describing: error)));\n  message: \(message ?? "")"
+    }
+  }
+}