munim-bluetooth 0.3.26 → 0.3.27

package/android/src/main/java/com/munimbluetooth/BluetoothPermissionUtils.kt

@@ -0,0 +1,40 @@
+package com.munimbluetooth
+
+import android.Manifest
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+
+internal object BluetoothPermissionUtils {
+    fun requiredPermissions(): Array<String> {
+        return when {
+            Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> arrayOf(
+                Manifest.permission.BLUETOOTH_SCAN,
+                Manifest.permission.BLUETOOTH_CONNECT,
+                Manifest.permission.BLUETOOTH_ADVERTISE
+            )
+
+            Build.VERSION.SDK_INT >= Build.VERSION_CODES.M -> arrayOf(
+                Manifest.permission.ACCESS_FINE_LOCATION
+            )
+
+            else -> emptyArray()
+        }
+    }
+
+    fun missingPermissions(context: Context): Array<String> {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+            return emptyArray()
+        }
+
+        return requiredPermissions()
+            .filter { permission ->
+                context.checkSelfPermission(permission) != PackageManager.PERMISSION_GRANTED
+            }
+            .toTypedArray()
+    }
+
+    fun hasRequiredPermissions(context: Context): Boolean {
+        return missingPermissions(context).isEmpty()
+    }
+}

package/android/src/main/java/com/munimbluetooth/HybridMunimBluetooth.kt

@@ -23,6 +23,7 @@ import android.bluetooth.le.ScanResult
 import android.bluetooth.le.ScanSettings
 import android.content.Context
 import android.content.Intent
+import android.content.pm.PackageManager
 import android.os.Build
 import android.os.ParcelUuid
 import android.util.Log
@@ -30,6 +31,8 @@ import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.WritableArray
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.facebook.react.modules.core.PermissionAwareActivity
+import com.facebook.react.modules.core.PermissionListener
 import com.margelo.nitro.NitroModules
 import com.margelo.nitro.core.Promise
 import com.margelo.nitro.munimbluetooth.AdvertisingDataTypes
@@ -80,6 +83,7 @@ class HybridMunimBluetooth : HybridMunimBluetoothSpec() {
     private val lastCharacteristicValues = mutableMapOf<String, CharacteristicValue>()
     private val lastRssiValues = mutableMapOf<String, Double>()
     private val eventEmitter = NitroEventEmitter(TAG)
+    private var nextPermissionRequestCode = BLUETOOTH_PERMISSION_REQUEST_CODE
 
     private fun getBluetoothManager(): BluetoothManager? {
         val context = NitroModules.applicationContext ?: return null
@@ -93,7 +97,35 @@ class HybridMunimBluetooth : HybridMunimBluetoothSpec() {
         }
     }
 
+    private fun hasRequiredBluetoothPermissions(): Boolean {
+        val context = NitroModules.applicationContext ?: return false
+        return BluetoothPermissionUtils.hasRequiredPermissions(context)
+    }
+
+    private fun ensureBluetoothPermissions(operationName: String): Boolean {
+        val context = NitroModules.applicationContext
+        if (context == null) {
+            Log.w(TAG, "Unable to $operationName: React context unavailable")
+            return false
+        }
+
+        val missingPermissions = BluetoothPermissionUtils.missingPermissions(context)
+        if (missingPermissions.isNotEmpty()) {
+            Log.w(
+                TAG,
+                "Unable to $operationName: missing Bluetooth permissions (${missingPermissions.joinToString()})"
+            )
+            return false
+        }
+
+        return true
+    }
+
     override fun startAdvertising(options: AdvertisingOptions) {
+        if (!ensureBluetoothPermissions("start advertising")) {
+            return
+        }
+
         ensureBluetoothManager()
         val adapter = bluetoothAdapter
         if (adapter == null || !adapter.isEnabled) {
@@ -115,7 +147,12 @@ class HybridMunimBluetooth : HybridMunimBluetoothSpec() {
         )
 
         if (!currentLocalName.isNullOrBlank() && previousAdapterName == null) {
-            previousAdapterName = adapter.name
+            previousAdapterName = try {
+                adapter.name
+            } catch (error: SecurityException) {
+                Log.w(TAG, "Unable to read Bluetooth adapter name", error)
+                null
+            }
         }
         if (!currentLocalName.isNullOrBlank()) {
             try {
@@ -161,6 +198,10 @@ class HybridMunimBluetooth : HybridMunimBluetoothSpec() {
     }
 
     override fun setServices(services: Array<GATTService>) {
+        if (!ensureBluetoothPermissions("set GATT services")) {
+            return
+        }
+
         ensureBluetoothManager()
         gattServerReady = false
 
@@ -197,15 +238,63 @@ class HybridMunimBluetooth : HybridMunimBluetoothSpec() {
     }
 
     override fun isBluetoothEnabled(): Promise<Boolean> {
+        if (!hasRequiredBluetoothPermissions()) {
+            return Promise.resolved(false)
+        }
+
         ensureBluetoothManager()
         return Promise.resolved(bluetoothAdapter?.isEnabled == true)
     }
 
     override fun requestBluetoothPermission(): Promise<Boolean> {
-        return Promise.resolved(true)
+        val context = NitroModules.applicationContext ?: run {
+            Log.w(TAG, "Unable to request Bluetooth permissions: React context unavailable")
+            return Promise.resolved(false)
+        }
+
+        val missingPermissions = BluetoothPermissionUtils.missingPermissions(context)
+        if (missingPermissions.isEmpty()) {
+            return Promise.resolved(true)
+        }
+
+        val activity = context.currentActivity as? PermissionAwareActivity
+        if (activity == null) {
+            Log.w(TAG, "Unable to request Bluetooth permissions: current activity unavailable")
+            return Promise.resolved(false)
+        }
+
+        val requestCode = nextPermissionRequestCode++
+        val promise = Promise<Boolean>()
+
+        try {
+            activity.requestPermissions(
+                missingPermissions,
+                requestCode,
+                PermissionListener { callbackRequestCode, _, grantResults ->
+                    if (callbackRequestCode != requestCode) {
+                        return@PermissionListener false
+                    }
+
+                    val isGranted =
+                        grantResults.isNotEmpty() &&
+                            grantResults.all { it == PackageManager.PERMISSION_GRANTED }
+                    promise.resolve(isGranted)
+                    true
+                }
+            )
+        } catch (error: IllegalStateException) {
+            Log.w(TAG, "Unable to request Bluetooth permissions", error)
+            promise.resolve(false)
+        }
+
+        return promise
     }
 
     override fun startScan(options: ScanOptions?) {
+        if (!ensureBluetoothPermissions("start scanning")) {
+            return
+        }
+
         ensureBluetoothManager()
         val adapter = bluetoothAdapter
         if (adapter == null || !adapter.isEnabled) {
@@ -278,6 +367,10 @@ class HybridMunimBluetooth : HybridMunimBluetoothSpec() {
     }
 
     override fun connect(deviceId: String): Promise<Unit> {
+        if (!ensureBluetoothPermissions("connect to BLE device")) {
+            return Promise.rejected(IllegalStateException("Bluetooth permissions not granted"))
+        }
+
         ensureBluetoothManager()
         connectedDevices[deviceId]?.let { existingGatt ->
             if (existingGatt.services != null) {
@@ -453,6 +546,10 @@ class HybridMunimBluetooth : HybridMunimBluetoothSpec() {
             return
         }
 
+        if (!ensureBluetoothPermissions("start background BLE session")) {
+            return
+        }
+
         val intent = Intent(context, MunimBluetoothBackgroundService::class.java).apply {
             action = MunimBluetoothBackgroundService.ACTION_START
             putExtra(
@@ -517,6 +614,10 @@ class HybridMunimBluetooth : HybridMunimBluetoothSpec() {
     }
 
     private fun restartAdvertising(delayMs: Long) {
+        if (!ensureBluetoothPermissions("restart advertising")) {
+            return
+        }
+
         ensureBluetoothManager()
         val adapter = bluetoothAdapter
         if (adapter == null || !adapter.isEnabled) {
@@ -1027,6 +1128,7 @@ class HybridMunimBluetooth : HybridMunimBluetoothSpec() {
 
     companion object {
         private const val TAG = "HybridMunimBluetooth"
+        private const val BLUETOOTH_PERMISSION_REQUEST_CODE = 9137
         private val CLIENT_CHARACTERISTIC_CONFIG_UUID =
             UUID.fromString("00002902-0000-1000-8000-00805f9b34fb")
     }

package/android/src/main/java/com/munimbluetooth/MunimBluetoothBackgroundService.kt

@@ -100,19 +100,38 @@ class MunimBluetoothBackgroundService : Service() {
         allowDuplicates: Boolean,
         scanMode: ScanMode
     ) {
+        if (!BluetoothPermissionUtils.hasRequiredPermissions(applicationContext)) {
+            Log.w(TAG, "Unable to start background BLE session: missing runtime permissions")
+            stopSelf()
+            return
+        }
+
         bluetoothManager =
             applicationContext.getSystemService(Context.BLUETOOTH_SERVICE) as? BluetoothManager
         bluetoothAdapter = bluetoothManager?.adapter
 
         val adapter = bluetoothAdapter
-        if (adapter == null || !adapter.isEnabled) {
+        val isEnabled = try {
+            adapter?.isEnabled == true
+        } catch (error: SecurityException) {
+            Log.w(TAG, "Unable to inspect Bluetooth adapter state for background session", error)
+            false
+        }
+
+        if (adapter == null || !isEnabled) {
             Log.w(TAG, "Unable to start background BLE session: Bluetooth unavailable")
             stopSelf()
             return
         }
 
         if (!localName.isNullOrBlank() && previousAdapterName == null) {
-            previousAdapterName = adapter.name
+            previousAdapterName = try {
+                adapter.name
+            } catch (error: SecurityException) {
+                Log.w(TAG, "Unable to read adapter name for background advertising", error)
+                null
+            }
+
             try {
                 adapter.name = localName
             } catch (error: SecurityException) {
@@ -193,7 +212,11 @@ class MunimBluetoothBackgroundService : Service() {
             }
         }
 
-        activeAdvertiser.startAdvertising(settings, data.build(), advertiseCallback)
+        try {
+            activeAdvertiser.startAdvertising(settings, data.build(), advertiseCallback)
+        } catch (error: SecurityException) {
+            Log.w(TAG, "Unable to start background advertising", error)
+        }
     }
 
     private fun startScan(
@@ -242,7 +265,11 @@ class MunimBluetoothBackgroundService : Service() {
             }
         }
 
-        activeScanner.startScan(filters, settingsBuilder.build(), scanCallback)
+        try {
+            activeScanner.startScan(filters, settingsBuilder.build(), scanCallback)
+        } catch (error: SecurityException) {
+            Log.w(TAG, "Unable to start background scan", error)
+        }
     }
 
     private fun handleScanResult(result: ScanResult, allowDuplicates: Boolean) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "munim-bluetooth",
-  "version": "0.3.26",
+  "version": "0.3.27",
   "description": "A comprehensive React Native library for all your Bluetooth Low Energy (BLE) needs, supporting both peripheral and central roles with Expo support",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/module/index.js",