@expofp/react-native-efp-crowdconnected 0.1.2 → 0.1.4

package/android/build.gradle

@@ -78,6 +78,7 @@ dependencies {
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.2"
+  implementation "androidx.fragment:fragment-ktx:1.6.2"
 
   implementation "net.crowdconnected.android.core:android-core:2.1.3"
   implementation "net.crowdconnected.android.ips:android-ips:2.1.3"

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

@@ -78,12 +78,20 @@ data class ExpoFpPosition(
                     lat = null,
                     lng = null
                 )
+                "GEO" -> ExpoFpPosition(
+                    x = null,
+                    y = null,
+                    z = z,
+                    angle = angle,
+                    lat = latitude,
+                    lng = longitude
+                )
                 else -> {
-                    // GEO and unknown types: only lat/lng, no x/y
-                    // GEO location type uses lat/lng only
+                    // Unknown or mixed types: include all available coordinates
+                    // This ensures blue dot works even if locationType is unexpected
                     ExpoFpPosition(
-                        x = null,
-                        y = null,
+                        x = xPixels,
+                        y = yPixels,
                         z = z,
                         angle = angle,
                         lat = latitude,

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

@@ -0,0 +1,233 @@
+package com.expofpcrowdconnected
+
+import android.Manifest
+import android.app.Activity
+import android.bluetooth.BluetoothAdapter
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.os.Build
+import android.os.Bundle
+import android.provider.Settings
+import androidx.activity.result.ActivityResultLauncher
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.core.content.ContextCompat
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentActivity
+import kotlin.coroutines.resume
+import kotlinx.coroutines.suspendCancellableCoroutine
+
+/**
+ * Result of a permission request containing grant status and lists of denied permissions.
+ *
+ * @param granted true if all requested permissions were granted
+ * @param denied list of permissions the user denied
+ * @param permanentlyDenied list of permissions the user denied with "Don't ask again"
+ */
+data class PermissionResult(
+    val granted: Boolean,
+    val denied: List<String>,
+    val permanentlyDenied: List<String>
+)
+
+/**
+ * Headless Fragment that handles runtime permission requests.
+ *
+ * Uses ActivityResultContracts to request permissions without requiring
+ * the hosting Activity to implement onRequestPermissionsResult.
+ * Mirrors the native CrowdConnected SDK's PermissionHostFragment pattern.
+ */
+class PermissionRequester : Fragment() {
+
+    companion object {
+        private const val FRAGMENT_TAG = "com.expofpcrowdconnected.PermissionRequester"
+
+        /**
+         * Obtain an existing or create a new PermissionRequester fragment
+         * attached to the given activity. Must be called on the main thread.
+         */
+        fun obtain(activity: FragmentActivity): PermissionRequester {
+            val fm = activity.supportFragmentManager
+            val existing = fm.findFragmentByTag(FRAGMENT_TAG) as? PermissionRequester
+            if (existing != null) {
+                return existing
+            }
+            val fragment = PermissionRequester()
+            fm.beginTransaction()
+                .add(fragment, FRAGMENT_TAG)
+                .setReorderingAllowed(true)
+                .commitNowAllowingStateLoss()
+            return fragment
+        }
+    }
+
+    // --- Launchers (registered in onCreate) ---
+
+    private lateinit var multiPermLauncher: ActivityResultLauncher<Array<String>>
+    private lateinit var singlePermLauncher: ActivityResultLauncher<String>
+    private lateinit var settingsLauncher: ActivityResultLauncher<Intent>
+    private lateinit var bluetoothLauncher: ActivityResultLauncher<Intent>
+
+    // --- Callbacks ---
+
+    private var multiPermCallback: ((PermissionResult) -> Unit)? = null
+    private var singlePermCallback: ((Boolean) -> Unit)? = null
+    private var settingsCallback: ((Boolean) -> Unit)? = null
+    private var settingsCheck: (() -> Boolean)? = null
+    private var bluetoothCallback: ((Boolean) -> Unit)? = null
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        multiPermLauncher = registerForActivityResult(
+            ActivityResultContracts.RequestMultiplePermissions()
+        ) { results ->
+            val denied = results.filterValues { !it }.keys.toList()
+            val permanentlyDenied = denied.filter { perm ->
+                !shouldShowRequestPermissionRationale(perm)
+            }
+            multiPermCallback?.invoke(
+                PermissionResult(
+                    granted = denied.isEmpty(),
+                    denied = denied,
+                    permanentlyDenied = permanentlyDenied
+                )
+            )
+            multiPermCallback = null
+        }
+
+        singlePermLauncher = registerForActivityResult(
+            ActivityResultContracts.RequestPermission()
+        ) { granted ->
+            singlePermCallback?.invoke(granted)
+            singlePermCallback = null
+        }
+
+        settingsLauncher = registerForActivityResult(
+            ActivityResultContracts.StartActivityForResult()
+        ) {
+            val ok = settingsCheck?.invoke() ?: false
+            settingsCallback?.invoke(ok)
+            settingsCallback = null
+            settingsCheck = null
+        }
+
+        bluetoothLauncher = registerForActivityResult(
+            ActivityResultContracts.StartActivityForResult()
+        ) { result ->
+            bluetoothCallback?.invoke(result.resultCode == Activity.RESULT_OK)
+            bluetoothCallback = null
+        }
+    }
+
+    override fun onDestroy() {
+        multiPermCallback?.let { cb ->
+            multiPermCallback = null
+            cb(PermissionResult(granted = false, denied = emptyList(), permanentlyDenied = emptyList()))
+        }
+        singlePermCallback?.let { cb ->
+            singlePermCallback = null
+            cb(false)
+        }
+        settingsCallback?.let { cb ->
+            settingsCallback = null
+            settingsCheck = null
+            cb(false)
+        }
+        bluetoothCallback?.let { cb ->
+            bluetoothCallback = null
+            cb(false)
+        }
+        super.onDestroy()
+    }
+
+    // --- Public suspend API ---
+
+    /**
+     * Request multiple permissions and suspend until the user responds.
+     */
+    suspend fun requestPermissions(permissions: Array<String>): PermissionResult =
+        suspendCancellableCoroutine { cont ->
+            if (permissions.isEmpty()) {
+                cont.resume(PermissionResult(true, emptyList(), emptyList()))
+                return@suspendCancellableCoroutine
+            }
+            multiPermCallback = { result ->
+                if (cont.isActive) cont.resume(result)
+            }
+            cont.invokeOnCancellation { multiPermCallback = null }
+            multiPermLauncher.launch(permissions)
+        }
+
+    /**
+     * Request the background location permission (Android 10+).
+     *
+     * On Android 11+ (API 30+), the system does not show a runtime dialog for
+     * ACCESS_BACKGROUND_LOCATION. Instead, the user is redirected to App Settings
+     * where they can manually toggle "Allow all the time".
+     * This matches the native CrowdConnected SDK's BackgroundPermissions behavior.
+     *
+     * @return true if permission was granted, false otherwise
+     */
+    suspend fun requestBackgroundPermission(): Boolean {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+            return true // background location not needed before Android 10
+        }
+
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            // API 30+: redirect to App Settings (system won't show a runtime dialog)
+            openAppSettingsAndCheck {
+                ContextCompat.checkSelfPermission(
+                    requireContext(),
+                    Manifest.permission.ACCESS_BACKGROUND_LOCATION
+                ) == PackageManager.PERMISSION_GRANTED
+            }
+        } else {
+            // API 29: standard permission dialog works
+            requestSinglePermission(Manifest.permission.ACCESS_BACKGROUND_LOCATION)
+        }
+    }
+
+    /**
+     * Request the user to enable Bluetooth via system dialog.
+     *
+     * @return true if Bluetooth was enabled, false if user declined
+     */
+    suspend fun requestEnableBluetooth(): Boolean =
+        suspendCancellableCoroutine { cont ->
+            bluetoothCallback = { enabled ->
+                if (cont.isActive) cont.resume(enabled)
+            }
+            cont.invokeOnCancellation { bluetoothCallback = null }
+            @Suppress("MissingPermission")
+            bluetoothLauncher.launch(Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE))
+        }
+
+    // --- Private helpers ---
+
+    private suspend fun requestSinglePermission(permission: String): Boolean =
+        suspendCancellableCoroutine { cont ->
+            singlePermCallback = { granted ->
+                if (cont.isActive) cont.resume(granted)
+            }
+            cont.invokeOnCancellation { singlePermCallback = null }
+            singlePermLauncher.launch(permission)
+        }
+
+    private suspend fun openAppSettingsAndCheck(isGranted: () -> Boolean): Boolean =
+        suspendCancellableCoroutine { cont ->
+            settingsCheck = isGranted
+            settingsCallback = { ok ->
+                if (cont.isActive) cont.resume(ok)
+            }
+            cont.invokeOnCancellation {
+                settingsCallback = null
+                settingsCheck = null
+            }
+            val intent = Intent(
+                Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
+                Uri.fromParts("package", requireContext().packageName, null)
+            )
+            settingsLauncher.launch(intent)
+        }
+}

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

@@ -2,11 +2,14 @@ package com.expofpcrowdconnected
 
 import android.Manifest
 import android.app.Application
+import android.bluetooth.BluetoothManager
 import android.content.Context
 import android.content.pm.PackageManager
 import android.os.Build
 import android.util.Log
 import androidx.core.content.ContextCompat
+import androidx.fragment.app.FragmentActivity
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
@@ -23,6 +26,7 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
 import net.crowdconnected.android.core.CrowdConnected
 import net.crowdconnected.android.core.StatusCallback
 import net.crowdconnected.android.core.Configuration
@@ -30,6 +34,15 @@ import net.crowdconnected.android.core.ConfigurationBuilder
 import net.crowdconnected.android.geo.GeoModule
 import net.crowdconnected.android.ips.IPSModule
 
+/**
+ * Exception for permission denial with detailed information about denied permissions.
+ */
+class PermissionDeniedException(
+    message: String,
+    val denied: List<String> = emptyList(),
+    val permanentlyDenied: List<String> = emptyList()
+) : Exception(message)
+
 /**
  * React Native module for CrowdConnected location provider
  * Provides cross-platform API: setup, startUpdatingLocation, stopUpdatingLocation, isLocationUpdating
@@ -83,6 +96,12 @@ class RCTCrowdConnectedLocationProviderModule(
                     Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
                     add(Manifest.permission.ACCESS_BACKGROUND_LOCATION)
                 }
+
+                // POST_NOTIFICATIONS (Android 13+, API 33+) for foreground service notification
+                if (settings.isBackgroundUpdateEnabled &&
+                    Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                    add(Manifest.permission.POST_NOTIFICATIONS)
+                }
             }
 
             return required.filter {
@@ -129,6 +148,8 @@ class RCTCrowdConnectedLocationProviderModule(
     fun setup(settingsMap: ReadableMap, promise: Promise) {
         moduleScope.launch {
             try {
+                val wasUpdating: Boolean
+
                 mutex.withLock {
                     Log.d(TAG, "setup: Configuring CrowdConnected SDK")
 
@@ -139,21 +160,34 @@ class RCTCrowdConnectedLocationProviderModule(
                     Log.d(TAG, "setup: Navigation type: ${newSettings.navigationType}, Background: ${newSettings.isBackgroundUpdateEnabled}, Heading: ${newSettings.isHeadingEnabled}")
 
                     // If already updating, stop first
-                    val wasUpdating = providerInfo.isLocationUpdating
+                    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 {
+                    if (!wasUpdating) {
                         Log.d(TAG, "setup: Configuration complete")
                         promise.resolve(providerInfo.toWritableMap())
                     }
                 }
+
+                // If was updating, restart with new settings
+                // Permission request runs OUTSIDE the mutex to avoid blocking
+                if (wasUpdating) {
+                    Log.d(TAG, "setup: Restarting with new settings")
+                    ensurePermissions()
+                    ensureBluetooth()
+                    mutex.withLock {
+                        startUpdatingLocationInternal(promise)
+                    }
+                }
+            } catch (e: PermissionDeniedException) {
+                val userInfo = Arguments.createMap().apply {
+                    putArray("denied", Arguments.fromList(e.denied))
+                    putArray("permanentlyDenied", Arguments.fromList(e.permanentlyDenied))
+                }
+                promise.reject("PERMISSIONS_DENIED", e.message, null as Throwable?, userInfo)
             } catch (e: Exception) {
                 Log.e(TAG, "setup: Failed to configure SDK", e)
                 promise.reject("SETUP_ERROR", e.message, e)
@@ -168,9 +202,19 @@ class RCTCrowdConnectedLocationProviderModule(
     fun startUpdatingLocation(promise: Promise) {
         moduleScope.launch {
             try {
+                // Request permissions OUTSIDE the mutex to avoid blocking
+                // other module operations while waiting for user interaction
+                ensurePermissions()
+                ensureBluetooth()
                 mutex.withLock {
                     startUpdatingLocationInternal(promise)
                 }
+            } catch (e: PermissionDeniedException) {
+                val userInfo = Arguments.createMap().apply {
+                    putArray("denied", Arguments.fromList(e.denied))
+                    putArray("permanentlyDenied", Arguments.fromList(e.permanentlyDenied))
+                }
+                promise.reject("PERMISSIONS_DENIED", e.message, null as Throwable?, userInfo)
             } catch (e: Exception) {
                 promise.reject("START_ERROR", e.message, e)
             }
@@ -206,6 +250,110 @@ class RCTCrowdConnectedLocationProviderModule(
         }
     }
 
+    /**
+     * Ensures all required permissions are granted, requesting them from the user if necessary.
+     * Must be called OUTSIDE the mutex to avoid blocking other module operations
+     * while waiting for user interaction.
+     *
+     * @throws PermissionDeniedException if permissions are denied
+     * @throws IllegalStateException if settings are missing or activity is unavailable
+     */
+    private suspend fun ensurePermissions() {
+        val currentSettings = settings
+            ?: throw IllegalStateException("Settings are missing. Use 'setup' method first.")
+
+        val missing = missingPermissions(reactApplicationContext, currentSettings)
+        if (missing.isEmpty()) return
+
+        Log.d(TAG, "ensurePermissions: Missing permissions: ${missing.joinToString(", ")}. Requesting...")
+
+        val activity = reactApplicationContext.currentActivity as? FragmentActivity
+            ?: throw IllegalStateException(
+                "Missing required permissions: ${missing.joinToString(", ")}. Cannot auto-request: no activity available."
+            )
+
+        val bgPermission = Manifest.permission.ACCESS_BACKGROUND_LOCATION
+        val needBg = Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q && missing.contains(bgPermission)
+        val foregroundPerms = missing.filterNot { it == bgPermission }
+
+        val requester = withContext(Dispatchers.Main) {
+            PermissionRequester.obtain(activity)
+        }
+
+        // 1. Request foreground permissions first
+        if (foregroundPerms.isNotEmpty()) {
+            val result = withContext(Dispatchers.Main) {
+                requester.requestPermissions(foregroundPerms.toTypedArray())
+            }
+            if (!result.granted) {
+                throw PermissionDeniedException(
+                    "Permissions denied: ${result.denied.joinToString(", ")}",
+                    denied = result.denied,
+                    permanentlyDenied = result.permanentlyDenied
+                )
+            }
+        }
+
+        // 2. Request background permission separately (Android requires this)
+        // On API 30+, this redirects the user to App Settings
+        if (needBg) {
+            val bgGranted = withContext(Dispatchers.Main) {
+                requester.requestBackgroundPermission()
+            }
+            if (!bgGranted) {
+                Log.w(TAG, "ensurePermissions: Background location permission denied")
+                throw PermissionDeniedException(
+                    "Background location not granted",
+                    denied = listOf(bgPermission),
+                    permanentlyDenied = emptyList()
+                )
+            }
+        }
+
+        // Final safety check — verify all permissions are actually granted
+        val stillMissing = missingPermissions(reactApplicationContext, currentSettings)
+        if (stillMissing.isNotEmpty()) {
+            throw PermissionDeniedException(
+                "Required permissions still not granted: ${stillMissing.joinToString(", ")}",
+                denied = stillMissing,
+                permanentlyDenied = emptyList()
+            )
+        }
+    }
+
+    /**
+     * Checks if Bluetooth is supported but disabled, and prompts the user to enable it.
+     * This is non-blocking — if the user declines, SDK start proceeds anyway.
+     * Matches native CrowdConnected SDK behavior (BluetoothEnableGateway).
+     */
+    private suspend fun ensureBluetooth() {
+        val currentSettings = settings ?: return
+        if (!currentSettings.isBluetoothEnabled) return
+
+        val context = reactApplicationContext
+        if (!context.packageManager.hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE)) return
+
+        val bluetoothManager = context.getSystemService(Context.BLUETOOTH_SERVICE) as? BluetoothManager
+        if (bluetoothManager?.adapter?.isEnabled == true) return
+
+        val activity = reactApplicationContext.currentActivity as? FragmentActivity ?: return
+
+        Log.d(TAG, "ensureBluetooth: Bluetooth is disabled, requesting user to enable")
+        try {
+            val requester = withContext(Dispatchers.Main) {
+                PermissionRequester.obtain(activity)
+            }
+            val enabled = withContext(Dispatchers.Main) {
+                requester.requestEnableBluetooth()
+            }
+            if (!enabled) {
+                Log.w(TAG, "ensureBluetooth: User declined to enable Bluetooth")
+            }
+        } catch (e: Exception) {
+            Log.w(TAG, "ensureBluetooth: Failed to request Bluetooth enable", e)
+        }
+    }
+
     /**
      * Internal method to start location updates (must be called within mutex lock)
      */
@@ -223,7 +371,7 @@ class RCTCrowdConnectedLocationProviderModule(
             return
         }
 
-        // Check permissions
+        // Check permissions (should already be granted by ensurePermissions called before mutex)
         val missing = missingPermissions(reactApplicationContext, currentSettings)
         if (missing.isNotEmpty()) {
             Log.e(TAG, "startUpdatingLocationInternal: Missing permissions: ${missing.joinToString(", ")}")
@@ -259,8 +407,11 @@ class RCTCrowdConnectedLocationProviderModule(
         val statusCallback = object : StatusCallback {
             override fun onStartUpSuccess() {
                 Log.d(TAG, "StatusCallback: SDK startup successful")
-                // Cancel timeout on SDK startup success
                 cancelTimeoutJob()
+                registerPositionCallback()
+                CrowdConnected.getInstance()?.getDeviceId()?.let {
+                    providerInfo = providerInfo.copy(deviceId = it)
+                }
             }
 
             override fun onStartUpFailure(reason: String) {
@@ -318,20 +469,8 @@ class RCTCrowdConnectedLocationProviderModule(
             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")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expofp/react-native-efp-crowdconnected",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "React Native wrapper for ExpoFP around CrowdConnected SDK",
   "keywords": [
     "react-native",