Fix: add BLE state cleanup to ducky_typer functions

lib/Bad_Usb_Lib/BleKeyboard.cpp

@@ -206,11 +206,9 @@ void BleKeyboard::end(void) {
         for (j = 0; j < i; j++) pServer->disconnect(pServer->getPeerInfo(i).getConnHandle());
     }
     delete hid;
-#if defined(CONFIG_IDF_TARGET_ESP32C5)
-    esp_bt_controller_deinit();
-#else
-    BLEDevice::deinit();
-#endif
+    hid = nullptr;
+
+    BLEDevice::deinit(true);
     this->connected = false;
 }
 
@@ -242,12 +240,13 @@ void BleKeyboard::set_version(uint16_t version) { this->version = version; }
 // full, made worse by reducing CONFIG_BT_NIMBLE_MSYS_*_BLOCK_COUNT). If untreated,
 // the key is silently dropped. Retry while yielding 1 tick for the host to drain.
 // Kept local because this library is self-contained (does not depend on src/).
-static bool bleKbNotifyRetry(BLECharacteristic *chr, uint8_t retries = 8) {
+
+static bool bleKbNotifyRetry(BLECharacteristic *chr, const uint8_t *value, size_t len, uint8_t retries = 8) {
     if (chr == nullptr) return false;
-    if (chr->notify()) return true;
+    if (chr->notify(value, len)) return true;
     for (uint8_t i = 0; i < retries; i++) {
         vTaskDelay(1);
-        if (chr->notify()) return true;
+        if (chr->notify(value, len)) return true;
     }
     return false;
 }
@@ -260,7 +259,7 @@ void BleKeyboard::sendReport(KeyReport *keys) {
 #endif
     {
         this->inputKeyboard->setValue((uint8_t *)keys, sizeof(KeyReport));
-        bleKbNotifyRetry(this->inputKeyboard);
+        bleKbNotifyRetry(this->inputKeyboard, (uint8_t *)keys, sizeof(KeyReport));
 #if defined(USE_NIMBLE)
         // vTaskDelay(delayTicks);
         this->delay_ms(_delay_ms);
@@ -276,7 +275,7 @@ void BleKeyboard::sendReport(MediaKeyReport *keys) {
 #endif
     {
         this->inputMediaKeys->setValue((uint8_t *)keys, sizeof(MediaKeyReport));
-        bleKbNotifyRetry(this->inputMediaKeys);
+        bleKbNotifyRetry(this->inputMediaKeys, (uint8_t *)keys, sizeof(MediaKeyReport));
 #if defined(USE_NIMBLE)
         // vTaskDelay(delayTicks);
         this->delay_ms(_delay_ms);
@@ -434,11 +433,11 @@ size_t BleKeyboard::write(const uint8_t *buffer, size_t size) {
 }
 #ifdef NIMBLE_V2_PLUS
 void BleKeyboard::ServerCallbacks::onConnect(NimBLEServer *pServer, NimBLEConnInfo &connInfo) {
-    // BleKeyboard::connected = true;
+    parent->connected = true;
     Serial.println("BRUCE KEYBOARD: lib connected");
 }
 void BleKeyboard::ServerCallbacks::onDisconnect(NimBLEServer *pServer, NimBLEConnInfo &connInfo, int reason) {
-    // BleKeyboard::connected = true;
+    parent->connected = false;
     Serial.println("BRUCE KEYBOARD: lib disconnected");
 }
 void BleKeyboard::ServerCallbacks::onAuthenticationComplete(NimBLEConnInfo &connInfo) {

src/core/menu_items/BleMenu.cpp

@@ -17,15 +17,10 @@ void BleMenu::optionsMenu() {
 #if !defined(LITE_VERSION)
     if (BLEConnected) {
         options.push_back({"Disconnect", [=]() {
-#if defined(CONFIG_IDF_TARGET_ESP32C5)
-                               esp_bt_controller_deinit();
-#else
-            BLEDevice::deinit();
-#endif
+                               BLEDevice::deinit();
                                BLEConnected = false;
                                delete hid_ble;
                                hid_ble = nullptr;
-                               if (_Ask_for_restart == 1) _Ask_for_restart = 2;
                            }});
     }
 #endif

src/core/radio_mem.h

@@ -17,6 +17,8 @@
 */
 #include <esp_heap_caps.h>
 #include <stddef.h>
+#include "core/wifi/wifi_common.h"
+#include <WiFi.h>
 
 // Largest contiguous DMA-capable internal block, in bytes. This is the number
 // that gates Wi-Fi/BLE controller init.
@@ -36,7 +38,35 @@ static inline bool radioHasMemForWifi() {
 
 static inline bool radioHasMemForBle() {
     // return true; // uncomment to disable it
-    return radioLargestDmaBlock() >= RADIO_BLE_MIN_DMA_BLOCK;
+
+    // First check if we have enough DMA memory
+    if (radioLargestDmaBlock() >= RADIO_BLE_MIN_DMA_BLOCK) {
+        return true;
+    }
+
+    // Not enough DMA memory - try to free WiFi
+    Serial.println("[RAM] Low contiguous DMA memory for BLE, attempting to free WiFi...");
+
+    // Disconnect WiFi if active
+    if (WiFi.getMode() != WIFI_MODE_NULL || wifiConnected) {
+        wifiDisconnect();
+        delay(200);
+        #ifdef WIFI_DEINIT_ON_DISCONNECT
+        WiFi.mode(WIFI_OFF);
+        #endif
+        delay(300);
+    }
+
+    // Recheck after freeing WiFi
+    if (radioLargestDmaBlock() >= RADIO_BLE_MIN_DMA_BLOCK) {
+        Serial.printf("[RAM] WiFi freed, DMA block: %d bytes\n", radioLargestDmaBlock());
+        return true;
+    }
+
+    // Still not enough - return false, caller shows error
+    Serial.printf("[RAM] Still only %d bytes DMA block, minimum %d needed\n", 
+                  radioLargestDmaBlock(), RADIO_BLE_MIN_DMA_BLOCK);
+    return false;
 }
 
 #endif // __RADIO_MEM_H__