Refactor: Enhance BLESecure::removeBonding for specific device bond removal

This commit significantly refactors the `BLESecureClass::removeBonding(BLEDevice *device)` method to provide a functional implementation for deleting the bonding information of a specific, currently or recently connected LE device.

Previously, this method was a placeholder that only disconnected the device and noted the need for a full implementation.

The updated method now performs the following steps:
1.  **Input Validation**: Checks if the provided `BLEDevice` object is valid and if it has a valid `hci_con_handle_t`.
2.  **Device DB Index Lookup**: Uses `sm_le_device_index(handle)` to retrieve the internal index of the device within BTstack's LE Device Database. This requires the device's security context to be known to the Security Manager (SM).
3.  **Address Information Retrieval**: If a valid DB index is found, `le_device_db_info()` is called to fetch the `bd_addr_t` (Bluetooth address) and `bd_addr_type_t` (address type) of the device from the LE Device Database (which, in the `arduino-pico` context, is typically a TLV store on flash).
4.  **GAP-Level Bond Deletion**: Calls `gap_delete_bonding(addr_type, addr)` with the retrieved address and type. This is the appropriate high-level BTstack API function to request the deletion of an LE bond. It is expected to interact with both the LE Device Database and the Security Manager.
5.  **Verification and Logging**:
    * Includes extensive `Serial.println()` messages to log the steps taken, including the device's DB index, address, and address type.
    * Calls `le_device_db_dump()` after `gap_delete_bonding` to allow observation of the LE Device DB state (though immediate changes to flash might not always be reflected without a re-scan or if the dump relies on a RAM cache).
    * Checks `le_device_db_count()` after the deletion attempt to log if the count of bonded devices has changed.
6.  **Disconnection**: Calls `gap_disconnect(handle)` to disconnect the device after the bond removal attempt, maintaining a similar behavior to the original placeholder in this regard.
7.  **Error Handling**: Provides log messages if the device is not found in the LE Device DB or if a valid LE address type cannot be retrieved.

This enhancement aims to provide a more robust mechanism for managing individual device bonds within the `BLESecure` library, complementing the `clearAllBondings` function which targets all stored bonds. The effectiveness in completely preventing re-encryption still depends on the underlying behavior of BTstack's TLV flash backend and Security Manager regarding persistent key storage.

Author: IoT-gamer

src/BLESecure.cpp

@@ -186,35 +186,64 @@ bool BLESecureClass::bondWithDevice(BLEDevice *device)
     return result;
 }
 
-bool BLESecureClass::removeBonding(BLEDevice *device)
-{
-    if (!device)
+bool BLESecureClass::removeBonding(BLEDevice *device) {
+    if (!device) {
+        Serial.println("removeBonding: BLEDevice object is NULL.");
         return false;
+    }
 
     hci_con_handle_t handle = device->getHandle();
-    if (handle == HCI_CON_HANDLE_INVALID)
+    if (handle == HCI_CON_HANDLE_INVALID) {
+        Serial.println("removeBonding: Invalid connection handle from BLEDevice.");
         return false;
+    }
 
+    Serial.println("Attempting to remove bonding for specific device.");
     BluetoothLock b;
 
-    // Try to get the device index from the Security Manager
     int device_db_index = sm_le_device_index(handle);
-    if (device_db_index < 0)
-    {
-        Serial.println("No bonding info found for this device");
+
+    if (device_db_index < 0) {
+        Serial.print("removeBonding: Device not found in LE Device DB (sm_le_device_index returned ");
+        Serial.print(device_db_index);
+        Serial.println("). Cannot get address to remove bond. It might not be bonded or not connected.");
         return false;
     }
 
-    // We can't directly call le_device_db_remove as it might not be exposed
-    // but we can log the information for debugging
-    Serial.print("Found device at index: ");
+    Serial.print("removeBonding: Found device in LE DB at index: ");
     Serial.println(device_db_index);
-    Serial.println("Note: Full removeBonding() implementation requires access to le_device_db functions");
 
-    // For now, we'll just disconnect which should help in some cases
-    gap_disconnect(handle);
+    int addr_type_int;
+    bd_addr_t addr;
+    le_device_db_info(device_db_index, &addr_type_int, addr, NULL /* irk */);
+    bd_addr_type_t current_addr_type = (bd_addr_type_t)addr_type_int;
 
-    return true;
+    if (current_addr_type == BD_ADDR_TYPE_LE_PUBLIC || current_addr_type == BD_ADDR_TYPE_LE_RANDOM) {
+        Serial.print("removeBonding: Calling gap_delete_bonding for AddrType: ");
+        Serial.print(current_addr_type);
+        Serial.print(", Addr: ");
+        Serial.println(bd_addr_to_str(addr));
+
+        gap_delete_bonding(current_addr_type, addr); 
+
+        Serial.println("removeBonding: gap_delete_bonding called. Verifying DB state:");
+        le_device_db_dump(); 
+
+        int current_db_count = le_device_db_count();
+        Serial.print("removeBonding: le_device_db_count() after gap_delete_bonding: ");
+        Serial.println(current_db_count);
+
+
+        Serial.println("removeBonding: Disconnecting device.");
+        gap_disconnect(handle); 
+
+        return true; 
+    } else {
+        Serial.print("removeBonding: Could not retrieve a valid LE address type for device at DB index ");
+        Serial.print(device_db_index);
+        Serial.print(" (type was "); Serial.print(current_addr_type); Serial.println("). Bond not removed.");
+        return false;
+    }
 }
 
 void BLESecureClass::clearAllBondings() {