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

package/ExpofpCrowdconnected.podspec

@@ -0,0 +1,26 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "ExpofpCrowdconnected"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/expofp/react-native-crowdconnected.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,cpp,swift}"
+  s.private_header_files = "ios/**/*.h"
+
+  s.dependency 'CrowdConnectedShared', '2.2.1'
+  s.dependency 'CrowdConnectedCore', '2.2.1'
+  s.dependency 'CrowdConnectedIPS', '2.2.1'
+  s.dependency 'CrowdConnectedCoreBluetooth', '2.2.1'
+  s.dependency 'CrowdConnectedGeo', '2.2.1'
+
+  install_modules_dependencies(s)
+end

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2025 ExpoFP
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,169 @@
+# @expofp/react-native-efp-crowdconnected
+
+React Native Turbo Module for CrowdConnected location tracking and indoor positioning services. Provides cross-platform access to GPS, IPS (Indoor Positioning System), and Bluetooth-based positioning on iOS and Android.
+
+[![npm](https://img.shields.io/npm/v/@expofp/react-native-efp-crowdconnected)](https://www.npmjs.com/package/@expofp/react-native-efp-crowdconnected)
+[![npm downloads](https://img.shields.io/npm/dm/@expofp/react-native-efp-crowdconnected)](https://www.npmjs.com/package/@expofp/react-native-efp-crowdconnected)
+[![license](https://img.shields.io/npm/l/@expofp/react-native-efp-crowdconnected)](./LICENSE)
+
+## Features
+
+- 📍 **Multi-positioning support**: GPS, Indoor Positioning (IPS), and Bluetooth
+- 📱 **Cross-platform**: Native iOS (Swift) and Android (Kotlin) implementations
+- ⚡ **React Native New Architecture**: Built as a Turbo Module for optimal performance
+- 🔔 **Event-based**: Real-time location updates via event listeners
+- 🔄 **Background support**: Optional background location updates
+- 🎯 **Heading tracking**: Compass/bearing information
+- 📦 **TypeScript first**: Full type safety with generated type definitions
+
+## Requirements
+
+- React Native 0.71+
+- React 18+
+- iOS 12.0+ (CrowdConnected SDK v2.2.1)
+- Android 7+ (API 24+)
+
+## Installation
+
+```bash
+npm install @expofp/react-native-efp-crowdconnected
+# or
+yarn add @expofp/react-native-efp-crowdconnected
+```
+
+### iOS
+
+```bash
+cd ios && pod install
+```
+
+### Android
+
+No additional setup required. CocoaPods/Gradle will handle dependencies.
+
+## Quick Start
+
+```typescript
+import { CrowdConnectedLocationProvider } from '@expofp/react-native-efp-crowdconnected';
+
+// Initialize
+await CrowdConnectedLocationProvider.setup({
+  appKey: 'your-app-key',
+  token: 'your-token',
+  secret: 'your-secret',
+  navigationType: 'all', // 'all' | 'GEO' | 'IPS'
+  isBackgroundUpdateEnabled: false,
+  isBluetoothEnabled: true,
+  isHeadingEnabled: true,
+});
+
+// Listen to location updates
+const unsubscribe = CrowdConnectedLocationProvider.onLocationChange((position) => {
+  console.log('Location:', position);
+  // { lat: number, lng: number, x?: number, y?: number, z?: string | number, angle?: number }
+});
+
+// Listen to errors
+const unsubscribeError = CrowdConnectedLocationProvider.onError((error) => {
+  console.error('Location error:', error);
+});
+
+// Start tracking
+CrowdConnectedLocationProvider.startUpdatingLocation();
+
+// Check if location tracking is active
+const isUpdating = await CrowdConnectedLocationProvider.isLocationUpdating();
+
+// Stop tracking
+CrowdConnectedLocationProvider.stopUpdatingLocation();
+
+// Cleanup
+unsubscribe();
+unsubscribeError();
+```
+
+## API Reference
+
+### `setup(settings: ExpoFpLocationSettings): Promise<string>`
+
+Initializes the CrowdConnected SDK with configuration.
+
+**Parameters:**
+- `appKey` - CrowdConnected application key
+- `token` - Authentication token
+- `secret` - Authentication secret
+- `navigationType` - Positioning type: `'all'` (GPS + IPS), `'GEO'` (GPS only), `'IPS'` (indoor only)
+- `isBackgroundUpdateEnabled` - Enable background location updates
+- `isBluetoothEnabled` - Enable Bluetooth-based positioning
+- `isHeadingEnabled` - Enable compass/heading tracking
+- `aliases?` - Custom location aliases (optional)
+
+**Returns:** Promise resolving to initialization status
+
+---
+
+### `startUpdatingLocation(): void`
+
+Starts location tracking.
+
+---
+
+### `stopUpdatingLocation(): void`
+
+Stops location tracking.
+
+---
+
+### `isLocationUpdating(): Promise<boolean>`
+
+Checks if location tracking is currently active.
+
+---
+
+### `onLocationChange(callback: (position: ExpoFpPosition) => void): Unsubscribe`
+
+Subscribes to location updates.
+
+**Position object:**
+```typescript
+{
+  lat?: number;      // Latitude
+  lng?: number;      // Longitude
+  x?: number;        // X coordinate (indoor)
+  y?: number;        // Y coordinate (indoor)
+  z?: string|number; // Z coordinate (floor/level)
+  angle?: number;    // Heading in degrees
+}
+```
+
+**Returns:** Unsubscribe function
+
+---
+
+### `onError(callback: (error: Error) => void): Unsubscribe`
+
+Subscribes to location errors.
+
+**Returns:** Unsubscribe function
+
+## Development
+
+### Setup
+```bash
+yarn install
+yarn prepare
+```
+
+### Commands
+- `yarn lint` - Run ESLint
+- `yarn typecheck` - Check TypeScript types
+- `yarn test` - Run Jest tests
+- `yarn example ios` - Run iOS example app
+- `yarn example android` - Run Android example app
+- `yarn clean` - Clean build artifacts
+
+## Support
+
+- 📖 [Documentation](https://developer.expofp.com)
+- 🐛 [Report Issues](https://github.com/expofp/react-native-crowdconnected/issues)
+- 💬 [Discussions](https://github.com/expofp/react-native-crowdconnected/discussions)

package/android/build.gradle

@@ -0,0 +1,86 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['ExpofpCrowdconnected_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["ExpofpCrowdconnected_" + name]).toInteger()
+}
+
+android {
+  namespace "com.expofpcrowdconnected"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+  // CrowdConnected SDK Maven repository
+  maven { url "https://maven2.crowdconnected.net/" }
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.2"
+
+  implementation "net.crowdconnected.android.core:android-core:2.1.0"
+  implementation "net.crowdconnected.android.ips:android-ips:2.1.0"
+  implementation "net.crowdconnected.android.geo:android-geo:2.1.0"
+  implementation "net.crowdconnected.android.background:android-background:2.1.0"
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+ExpofpCrowdconnected_kotlinVersion=2.0.21
+ExpofpCrowdconnected_minSdkVersion=24
+ExpofpCrowdconnected_targetSdkVersion=34
+ExpofpCrowdconnected_compileSdkVersion=35
+ExpofpCrowdconnected_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

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

@@ -0,0 +1,94 @@
+package com.expofpcrowdconnected
+
+import android.content.Context
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorEventListener
+import android.hardware.SensorManager
+
+/**
+ * Provides device heading/azimuth using Android sensors
+ * Uses rotation vector sensor with exponential moving average for smoothing
+ */
+class ExpoFpAzimuthProvider(
+    private val context: Context,
+    private val onAzimuthChanged: (Double) -> Unit
+) : SensorEventListener {
+
+    private var sensorManager: SensorManager? = null
+    private var rotation: Sensor? = null
+
+    // Current azimuth value in degrees (0-360), null until first reading
+    @Volatile
+    var azimuth: Double? = null
+        private set
+
+    // Reusable arrays to avoid allocations on each sensor event
+    private val rMat = FloatArray(9)
+    private val ori = FloatArray(3)
+    private var ema: Double? = null
+
+    /**
+     * Start listening for sensor updates
+     * Returns true if sensor is available and started successfully, false otherwise
+     */
+    fun start(): Boolean {
+        sensorManager =
+            context.getSystemService(Context.SENSOR_SERVICE) as? SensorManager ?: return false
+        rotation = sensorManager?.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR) ?: return false
+        return sensorManager?.registerListener(
+            this,
+            rotation,
+            SensorManager.SENSOR_DELAY_GAME
+        ) == true
+    }
+
+    /**
+     * Stop listening for sensor updates
+     */
+    fun stop() {
+        sensorManager?.unregisterListener(this, rotation)
+        sensorManager = null
+        rotation = null
+        ema = null
+        azimuth = null
+    }
+
+    override fun onSensorChanged(event: SensorEvent?) {
+        if (event?.sensor?.type != Sensor.TYPE_ROTATION_VECTOR) return
+
+        // Get rotation matrix from rotation vector
+        SensorManager.getRotationMatrixFromVector(rMat, event.values)
+        val values = SensorManager.getOrientation(rMat, ori)
+
+        // Extract azimuth (rotation around Z-axis) and convert to degrees
+        val raw = Math.toDegrees(values[0].toDouble())
+
+        // Normalize to 0-360 range
+        val normalized = ((raw % 360.0) + 360.0) % 360.0
+
+        // Apply exponential moving average for smoothing
+        val alpha = 0.2
+        ema = when (val e = ema) {
+            null -> normalized
+            else -> {
+                val delta = minimalAngleDiff(e, normalized)
+                (e + alpha * delta + 360.0) % 360.0
+            }
+        }
+        azimuth = ema
+        ema?.let { onAzimuthChanged(it) }
+    }
+
+    override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) = Unit
+
+    /**
+     * Calculate minimal angle difference handling circular nature of angles
+     */
+    private fun minimalAngleDiff(a: Double, b: Double): Double {
+        var d = (b - a) % 360.0
+        if (d > 180) d -= 360
+        if (d < -180) d += 360
+        return d
+    }
+}

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

@@ -0,0 +1,136 @@
+package com.expofpcrowdconnected
+
+import android.os.Build
+import com.facebook.react.bridge.ReadableMap
+
+/**
+ * Navigation type for the location provider
+ */
+enum class ExpoFpCrowdConnectedNavigationType {
+    ALL,  // Both IPS and GEO
+    GEO,  // GPS/outdoor only
+    IPS;  // Indoor positioning only
+
+    companion object {
+        fun fromString(value: String?): ExpoFpCrowdConnectedNavigationType {
+            return when (value?.uppercase()) {
+                "ALL" -> ALL
+                "GEO" -> GEO
+                "IPS" -> IPS
+                else -> ALL
+            }
+        }
+    }
+}
+
+/**
+ * Settings for CrowdConnected location provider
+ * Maps to ExpoFpLocationSettings TypeScript interface
+ */
+data class ExpoFpCrowdConnectedLocationProviderSettings(
+    val appKey: String,
+    val token: String,
+    val secret: String,
+    val navigationType: ExpoFpCrowdConnectedNavigationType = ExpoFpCrowdConnectedNavigationType.ALL,
+    val isBackgroundUpdateEnabled: Boolean = false,
+    val isBluetoothEnabled: Boolean = false,
+    val isHeadingEnabled: Boolean = false,
+    val aliases: Map<String, String> = emptyMap()
+) {
+    /**
+     * Validate settings - throws IllegalArgumentException if invalid
+     * Ensures required credentials are not blank and validates platform-specific requirements
+     */
+    fun validate() {
+        // Validate required fields are not blank
+        if (appKey.isBlank()) {
+            throw IllegalArgumentException("appKey cannot be blank")
+        }
+        if (token.isBlank()) {
+            throw IllegalArgumentException("token cannot be blank")
+        }
+        if (secret.isBlank()) {
+            throw IllegalArgumentException("secret cannot be blank")
+        }
+
+        // Validate background requirements
+        if (isBackgroundUpdateEnabled) {
+            // Android 8.0 (API 26) required for foreground service
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+                throw IllegalArgumentException(
+                    "Background location tracking requires Android 8.0 (API 26) or higher"
+                )
+            }
+
+            // Android 10 (API 29) required for background location permission
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                // Note: ACCESS_BACKGROUND_LOCATION permission must be requested at runtime
+                // This is checked separately in missingPermissions() function
+            }
+        }
+    }
+
+    companion object {
+        /**
+         * Parse settings from React Native ReadableMap
+         */
+        fun fromReadableMap(map: ReadableMap): ExpoFpCrowdConnectedLocationProviderSettings {
+            // Required fields - trim whitespace for consistency
+            val appKey = map.getString("appKey")
+                ?.trim()
+                ?: throw IllegalArgumentException("appKey is required")
+            val token = map.getString("token")
+                ?.trim()
+                ?: throw IllegalArgumentException("token is required")
+            val secret = map.getString("secret")
+                ?.trim()
+                ?: throw IllegalArgumentException("secret is required")
+
+            // Optional fields
+            val navigationType = ExpoFpCrowdConnectedNavigationType.fromString(
+                map.getString("navigationType")
+            )
+            val isBackgroundUpdateEnabled = if (map.hasKey("isBackgroundUpdateEnabled")) {
+                map.getBoolean("isBackgroundUpdateEnabled")
+            } else false
+
+            val isBluetoothEnabled = if (map.hasKey("isBluetoothEnabled")) {
+                map.getBoolean("isBluetoothEnabled")
+            } else false
+
+            val isHeadingEnabled = if (map.hasKey("isHeadingEnabled")) {
+                map.getBoolean("isHeadingEnabled")
+            } else false
+
+            // Parse aliases map
+            val aliases = if (map.hasKey("aliases")) {
+                val aliasesMap = map.getMap("aliases")
+                val result = mutableMapOf<String, String>()
+                aliasesMap?.toHashMap()?.forEach { (key, value) ->
+                    if (value is String) {
+                        result[key] = value
+                    }
+                }
+                result
+            } else {
+                emptyMap()
+            }
+
+            val settings = ExpoFpCrowdConnectedLocationProviderSettings(
+                appKey = appKey,
+                token = token,
+                secret = secret,
+                navigationType = navigationType,
+                isBackgroundUpdateEnabled = isBackgroundUpdateEnabled,
+                isBluetoothEnabled = isBluetoothEnabled,
+                isHeadingEnabled = isHeadingEnabled,
+                aliases = aliases
+            )
+
+            // Validate settings before returning
+            settings.validate()
+
+            return settings
+        }
+    }
+}

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

@@ -0,0 +1,96 @@
+package com.expofpcrowdconnected
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import net.crowdconnected.android.core.LocationType
+
+/**
+ * Floor type - can be either an index (number) or a name (string)
+ */
+sealed class ExpoFpFloorType {
+    data class Index(val value: Int) : ExpoFpFloorType()
+    data class Name(val value: String) : ExpoFpFloorType()
+}
+
+/**
+ * Position data matching ExpoFpPosition TypeScript interface
+ * Supports both IPS coordinates (x, y, z) and GPS coordinates (lat, lng)
+ */
+data class ExpoFpPosition(
+    val x: Double? = null,         // IPS pixel X coordinate
+    val y: Double? = null,         // IPS pixel Y coordinate
+    val z: ExpoFpFloorType? = null, // Floor information
+    val angle: Double? = null,      // Heading in degrees (0-360)
+    val lat: Double? = null,        // Latitude for GEO
+    val lng: Double? = null         // Longitude for GEO
+) {
+    /**
+     * Update position with new heading angle
+     */
+    fun updateHeading(newAngle: Double): ExpoFpPosition {
+        return this.copy(angle = newAngle)
+    }
+
+    /**
+     * Convert to React Native WritableMap for sending to JavaScript
+     */
+    fun toWritableMap(): WritableMap {
+        return Arguments.createMap().apply {
+            x?.let { putDouble("x", it) }
+            y?.let { putDouble("y", it) }
+
+            // Handle floor type (can be string or number)
+            when (val floor = z) {
+                is ExpoFpFloorType.Index -> putInt("z", floor.value)
+                is ExpoFpFloorType.Name -> putString("z", floor.value)
+                null -> {} // Don't include z if not present
+            }
+
+            angle?.let { putDouble("angle", it) }
+            lat?.let { putDouble("lat", it) }
+            lng?.let { putDouble("lng", it) }
+        }
+    }
+
+    companion object {
+        /**
+         * Create ExpoFpPosition from CrowdConnected position data
+         * Position data mapping: IPS has x/y, GEO has lat/lng, both are mutually exclusive
+         */
+        fun fromCrowdConnected(
+            locationType: LocationType?,
+            xPixels: Double?,
+            yPixels: Double?,
+            floor: Int?,
+            latitude: Double?,
+            longitude: Double?,
+            angle: Double? = null
+        ): ExpoFpPosition {
+            val z: ExpoFpFloorType? = floor?.let { ExpoFpFloorType.Index(it) }
+            val type = locationType?.toString()?.uppercase().orEmpty()
+
+            return when (type) {
+                "IPS" -> ExpoFpPosition(
+                    x = xPixels,
+                    y = yPixels,
+                    z = z,
+                    angle = angle,
+                    lat = null,
+                    lng = null
+                )
+                else -> {
+                    // GEO and unknown types: only lat/lng, no x/y
+                    // GEO location type uses lat/lng only
+                    ExpoFpPosition(
+                        x = null,
+                        y = null,
+                        z = z,
+                        angle = angle,
+                        lat = latitude,
+                        lng = longitude
+                    )
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,27 @@
+package com.expofpcrowdconnected
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+
+/**
+ * Provider information matching ExpoFpProviderInfo TypeScript interface
+ * Contains current state of the location provider
+ */
+data class ExpoFpProviderInfo(
+    val deviceId: String? = null,
+    val isLocationUpdating: Boolean = false
+) {
+    /**
+     * Convert to React Native WritableMap for sending to JavaScript
+     */
+    fun toWritableMap(): WritableMap {
+        return Arguments.createMap().apply {
+            if (deviceId != null) {
+                putString("deviceId", deviceId)
+            } else {
+                putNull("deviceId")
+            }
+            putBoolean("isLocationUpdating", isLocationUpdating)
+        }
+    }
+}