@capacitor-community/bluetooth-le 7.1.1 → 7.3.0

package/android/src/main/java/com/capacitorjs/community/plugins/bluetoothle/Device.kt

@@ -21,7 +21,9 @@ import android.os.HandlerThread
 import android.os.Looper
 import androidx.annotation.RequiresApi
 import com.getcapacitor.Logger
+import java.util.Collections
 import java.util.UUID
+import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.ConcurrentLinkedQueue
 
 class CallbackResponse(
@@ -70,6 +72,7 @@ class Device(
     private var callbackMap = HashMap<String, ((CallbackResponse) -> Unit)>()
     private val timeoutQueue = ConcurrentLinkedQueue<TimeoutHandler>()
     private var bondStateReceiver: BroadcastReceiver? = null
+    private val pendingBondKeys = Collections.newSetFromMap(ConcurrentHashMap<String, Boolean>())
     private var currentMtu = -1
 
     private lateinit var callbacksHandlerThread: HandlerThread
@@ -91,6 +94,22 @@ class Device(
         }
     }
 
+    fun cleanup() {
+        synchronized(this) {
+            bondStateReceiver?.let { receiver ->
+                try {
+                    context.unregisterReceiver(receiver)
+                } catch (e: IllegalArgumentException) {
+                    Logger.debug(TAG, "Bond state receiver already unregistered")
+                }
+                bondStateReceiver = null
+            }
+
+            pendingBondKeys.clear()
+            cleanupCallbacksHandlerThread()
+        }
+    }
+
     private val gattCallback: BluetoothGattCallback = object : BluetoothGattCallback() {
         override fun onConnectionStateChange(
             gatt: BluetoothGatt, status: Int, newState: Int
@@ -109,7 +128,7 @@ class Device(
                 bluetoothGatt?.close()
                 bluetoothGatt = null
                 Logger.debug(TAG, "Disconnected from GATT server.")
-                cleanupCallbacksHandlerThread()
+                cleanup()
                 resolve("disconnect", "Disconnected.")
             }
         }
@@ -358,9 +377,16 @@ class Device(
     fun createBond(timeout: Long, callback: (CallbackResponse) -> Unit) {
         val key = "createBond"
         callbackMap[key] = callback
+
+        // Check if already bonded first to avoid race condition
+        if (isBonded()) {
+            resolve(key, "Creating bond succeeded.")
+            return
+        }
+
         try {
-            createBondStateReceiver()
-        } catch (e: Error) {
+            ensureBondStateReceiverRegistered()
+        } catch (e: Exception) {
             Logger.error(TAG, "Error while registering bondStateReceiver: ${e.localizedMessage}", e)
             reject(key, "Creating bond failed.")
             return
@@ -370,22 +396,17 @@ class Device(
             reject(key, "Creating bond failed.")
             return
         }
-        // if already bonded, resolve immediately
-        if (isBonded()) {
-            resolve(key, "Creating bond succeeded.")
-            return
-        }
-        // otherwise, wait for bond state change
+        // Wait for bond state change
         setTimeout(key, "Bonding timeout.", timeout)
     }
 
-    private fun createBondStateReceiver() {
-        if (bondStateReceiver == null) {
+    private fun ensureBondStateReceiverRegistered() {
+        synchronized(this) {
+            if (bondStateReceiver != null) return
+
             bondStateReceiver = object : BroadcastReceiver() {
-                override fun onReceive(context: Context, intent: Intent) {
-                    val action = intent.action
-                    if (action == BluetoothDevice.ACTION_BOND_STATE_CHANGED) {
-                        val key = "createBond"
+                override fun onReceive(ctx: Context, intent: Intent) {
+                    if (intent.action == BluetoothDevice.ACTION_BOND_STATE_CHANGED) {
                         val updatedDevice =
                             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
                                 intent.getParcelableExtra(
@@ -395,27 +416,44 @@ class Device(
                             } else {
                                 intent.getParcelableExtra<BluetoothDevice>(BluetoothDevice.EXTRA_DEVICE)
                             }
+
                         // BroadcastReceiver receives bond state updates from all devices, need to filter by device
                         if (device.address == updatedDevice?.address) {
-                            val bondState = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE, -1)
-                            val previousBondState =
-                                intent.getIntExtra(BluetoothDevice.EXTRA_PREVIOUS_BOND_STATE, -1)
-                            Logger.debug(
-                                TAG, "Bond state transition $previousBondState -> $bondState"
-                            )
-                            if (bondState == BluetoothDevice.BOND_BONDED) {
-                                resolve(key, "Creating bond succeeded.")
-                            } else if (previousBondState == BluetoothDevice.BOND_BONDING && bondState == BluetoothDevice.BOND_NONE) {
-                                reject(key, "Creating bond failed.")
-                            } else if (bondState == -1) {
-                                reject(key, "Creating bond failed.")
+                            val prev = intent.getIntExtra(BluetoothDevice.EXTRA_PREVIOUS_BOND_STATE, -1)
+                            val state = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE, -1)
+                            Logger.debug(TAG, "Bond state transition $prev -> $state")
+
+                            // Handle createBond callback
+                            if (callbackMap.containsKey("createBond")) {
+                                if (state == BluetoothDevice.BOND_BONDED) {
+                                    resolve("createBond", "Creating bond succeeded.")
+                                } else if (prev == BluetoothDevice.BOND_BONDING && state == BluetoothDevice.BOND_NONE) {
+                                    reject("createBond", "Creating bond failed.")
+                                } else if (state == -1) {
+                                    reject("createBond", "Creating bond failed.")
+                                }
+                            }
+
+                            // Handle setNotifications callbacks (only for operations waiting on bonding)
+                            if (prev == BluetoothDevice.BOND_BONDING && state == BluetoothDevice.BOND_NONE) {
+                                val keysToReject = pendingBondKeys.toList()
+                                pendingBondKeys.clear()
+                                keysToReject.forEach { key ->
+                                    reject(key, "Pairing request was cancelled by the user.")
+                                }
                             }
                         }
                     }
                 }
             }
-            val intentFilter = IntentFilter(BluetoothDevice.ACTION_BOND_STATE_CHANGED)
-            context.registerReceiver(bondStateReceiver, intentFilter)
+            try {
+                val intentFilter = IntentFilter(BluetoothDevice.ACTION_BOND_STATE_CHANGED)
+                context.registerReceiver(bondStateReceiver, intentFilter)
+            } catch (e: Exception) {
+                Logger.error(TAG, "Error registering bond state receiver: ${e.localizedMessage}", e)
+                bondStateReceiver = null
+                throw e
+            }
         }
     }
 
@@ -546,6 +584,7 @@ class Device(
         characteristicUUID: UUID,
         enable: Boolean,
         notifyCallback: ((CallbackResponse) -> Unit)?,
+        timeout: Long,
         callback: (CallbackResponse) -> Unit,
     ) {
         val key = "writeDescriptor|$serviceUUID|$characteristicUUID|$CLIENT_CHARACTERISTIC_CONFIG"
@@ -585,6 +624,19 @@ class Device(
             BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE
         }
 
+        // Track this operation as potentially needing bonding
+        if (!isBonded()) {
+            try {
+                ensureBondStateReceiverRegistered()
+                pendingBondKeys.add(key)
+            } catch (e: Exception) {
+                // Don't fail the notification attempt just because bonding
+                // can't be tracked. The call will still timeout if bonding is
+                // required for some reason
+                Logger.warn(TAG, "Error while registering bondStateReceiver: ${e.localizedMessage}")
+            }
+        }
+
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
             val statusCode = bluetoothGatt?.writeDescriptor(descriptor, value)
             if (statusCode != BluetoothStatusCodes.SUCCESS) {
@@ -600,6 +652,7 @@ class Device(
             }
 
         }
+        setTimeout(key, "Setting notification timeout.", timeout)
         // wait for onDescriptorWrite
     }
 
@@ -672,21 +725,19 @@ class Device(
     }
 
     private fun resolve(key: String, value: String) {
-        if (callbackMap.containsKey(key)) {
+        pendingBondKeys.remove(key)
+        callbackMap.remove(key)?.let { callback ->
             Logger.debug(TAG, "resolve: $key $value")
             timeoutQueue.popFirstMatch { it.key == key }?.handler?.removeCallbacksAndMessages(null)
-            val callback = callbackMap[key]
-            callbackMap.remove(key)
             callback?.invoke(CallbackResponse(true, value))
         }
     }
 
     private fun reject(key: String, value: String) {
-        if (callbackMap.containsKey(key)) {
+        pendingBondKeys.remove(key)
+        callbackMap.remove(key)?.let { callback ->
             Logger.debug(TAG, "reject: $key $value")
             timeoutQueue.popFirstMatch { it.key == key }?.handler?.removeCallbacksAndMessages(null)
-            val callback = callbackMap[key]
-            callbackMap.remove(key)
             callback?.invoke(CallbackResponse(false, value))
         }
     }
@@ -713,7 +764,7 @@ class Device(
             connectionState = STATE_DISCONNECTED
             gatt?.disconnect()
             gatt?.close()
-            cleanupCallbacksHandlerThread()
+            cleanup()
             reject(key, message)
         }, timeout)
     }