Release 2.3.4

The previous implementation incorrectly used the service's end handle
when searching for descriptors, which caused it to retrieve descriptors
from subsequent characteristics as well.

This fix calculates the correct end handle by finding the next
characteristic's handle and using (next_handle - 1) as the search limit.
This ensures only descriptors belonging to the current characteristic
are retrieved.

Fixes incorrect descriptor retrieval when multiple characteristics
exist in the same service.

.github/workflows/build.yml

@@ -12,13 +12,12 @@ jobs:
     name: Build with ESP-IDF ${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
     runs-on: ubuntu-latest
     strategy:
-      fail-fast: false
       matrix:
         # The version names here correspond to the versions of espressif/idf Docker image.
         # See https://hub.docker.com/r/espressif/idf/tags and
         # https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-guides/tools/idf-docker-image.html
         # for details.
-        idf_ver: ["release-v5.4", "release-v5.5"]
+        idf_ver: ["release-v4.4", "release-v5.4", "release-v5.5"]
         idf_target: ["esp32", "esp32s3", "esp32c2", "esp32c3", "esp32c5", "esp32c6", "esp32c61", "esp32h2", "esp32p4"]
         example:
           - NimBLE_Client
@@ -65,7 +64,7 @@ jobs:
   build_docs:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
       - name: Doxygen Action
         uses: mattnotmitt/doxygen-action@v1.9.8
         with:

.gitignore

@@ -1,4 +1,2 @@
 docs/doxydocs
-dist
-.development
-_codeql_detected_source_root
+dist

CMakeLists.txt

@@ -66,7 +66,6 @@ idf_component_register(
     "src/NimBLEScan.cpp"
     "src/NimBLEServer.cpp"
     "src/NimBLEService.cpp"
-    "src/NimBLEStream.cpp"
     "src/NimBLEUtils.cpp"
     "src/NimBLEUUID.cpp"
   REQUIRES

Kconfig

@@ -208,4 +208,51 @@ config NIMBLE_CPP_IDF
     bool
     default BT_NIMBLE_ENABLED
 
+#
+# BT config
+#
+config BT_ENABLED
+    bool "Bluetooth"
+    default "y"
+    help
+        Select this option to enable Bluetooth and show the submenu with Bluetooth configuration choices.
+
+
+config BT_NIMBLE_ENABLED
+    bool "NimBLE - BLE only"
+    default "y"
+    help
+        This option is recommended for BLE only usecases to save on memory
+
+if IDF_TARGET_ESP32P4
+
+    config BT_NIMBLE_TRANSPORT_UART
+        bool "Enable Uart Transport"
+        default "n"
+
+    #
+    # Enable ESP Hosted BT
+    # Used as VHCI transport between BT Host and Controller
+    #
+    config ESP_ENABLE_BT
+        bool "Enable Hosted Bluetooth support"
+        default "y"
+        help
+            Enable Bluetooth Support via Hosted
+
+    choice ESP_WIFI_REMOTE_LIBRARY
+        prompt "Choose WiFi-remote implementation"
+        default ESP_WIFI_REMOTE_LIBRARY_HOSTED
+        help
+            Select type of WiFi Remote implementation
+
+            ESP-HOSTED is the default and most versatile option.
+            It's also possible to use EPPP, which uses PPPoS link between micros and NAPT, so it's slower
+            and less universal.
+
+        config ESP_WIFI_REMOTE_LIBRARY_HOSTED
+            bool "ESP-HOSTED"
+    endchoice
+endif
+
 endmenu

examples/ANCS/CMakeLists.txt

@@ -1,6 +0,0 @@
-# The following lines of boilerplate have to be in your project's
-# CMakeLists in this exact order for cmake to work correctly
-cmake_minimum_required(VERSION 3.5)
-
-include($ENV{IDF_PATH}/tools/cmake/project.cmake)
-project(ANCS)

examples/ANCS/main/CMakeLists.txt

@@ -1,4 +0,0 @@
-set(COMPONENT_SRCS "main.cpp")
-set(COMPONENT_ADD_INCLUDEDIRS ".")
-
-register_component()

examples/ANCS/main/main.cpp

@@ -1,253 +0,0 @@
-// Original: https://github.com/mathcampbell/ANCS
-#include "NimBLEDevice.h"
-#include "driver/uart.h"
-
-static NimBLEUUID ancsServiceUUID("7905F431-B5CE-4E99-A40F-4B1E122D00D0");
-static NimBLEUUID notificationSourceCharacteristicUUID("9FBF120D-6301-42D9-8C58-25E699A21DBD");
-static NimBLEUUID controlPointCharacteristicUUID("69D1D8F3-45E1-49A8-9821-9BBDFDAAD9D9");
-static NimBLEUUID dataSourceCharacteristicUUID("22EAC6E9-24D6-4BB5-BE44-B36ACE7C7BFB");
-
-static NimBLEClient *pClient;
-
-uint8_t latestMessageID[4];
-bool pendingNotification = false;
-bool incomingCall = false;
-uint8_t acceptCall = 0;
-
-static void initUart()
-{
-    uart_config_t uartConfig{};
-    uartConfig.baud_rate = 115200;
-    uartConfig.data_bits = UART_DATA_8_BITS;
-    uartConfig.parity = UART_PARITY_DISABLE;
-    uartConfig.stop_bits = UART_STOP_BITS_1;
-    uartConfig.flow_ctrl = UART_HW_FLOWCTRL_DISABLE;
-    uartConfig.source_clk = UART_SCLK_DEFAULT;
-
-    uart_driver_install(UART_NUM_0, 256, 0, 0, nullptr, 0);
-    uart_param_config(UART_NUM_0, &uartConfig);
-}
-
-static void dataSourceNotifyCallback(NimBLERemoteCharacteristic *pDataSourceCharacteristic,
-                                     uint8_t *pData,
-                                     size_t length,
-                                     bool isNotify)
-{
-    for (int i = 0; i < length; i++)
-    {
-        if (i > 7)
-        {
-            printf("%c", pData[i]);
-        }
-        else
-        {
-            printf("%02X ", pData[i]);
-        }
-    }
-    printf("\n");
-}
-
-static void NotificationSourceNotifyCallback(NimBLERemoteCharacteristic *pNotificationSourceCharacteristic,
-                                             uint8_t *pData,
-                                             size_t length,
-                                             bool isNotify)
-{
-    if (pData[0] == 0)
-    {
-        printf("New notification!\n");
-        latestMessageID[0] = pData[4];
-        latestMessageID[1] = pData[5];
-        latestMessageID[2] = pData[6];
-        latestMessageID[3] = pData[7];
-
-        switch (pData[2])
-        {
-        case 0:
-            printf("Category: Other\n");
-            break;
-        case 1:
-            incomingCall = true;
-            printf("Category: Incoming call\n");
-            break;
-        case 2:
-            printf("Category: Missed call\n");
-            break;
-        case 3:
-            printf("Category: Voicemail\n");
-            break;
-        case 4:
-            printf("Category: Social\n");
-            break;
-        case 5:
-            printf("Category: Schedule\n");
-            break;
-        case 6:
-            printf("Category: Email\n");
-            break;
-        case 7:
-            printf("Category: News\n");
-            break;
-        case 8:
-            printf("Category: Health\n");
-            break;
-        case 9:
-            printf("Category: Business\n");
-            break;
-        case 10:
-            printf("Category: Location\n");
-            break;
-        case 11:
-            printf("Category: Entertainment\n");
-            break;
-        default:
-            break;
-        }
-    }
-    else if (pData[0] == 1)
-    {
-        printf("Notification Modified!\n");
-        if (pData[2] == 1)
-        {
-            printf("Call Changed!\n");
-        }
-    }
-    else if (pData[0] == 2)
-    {
-        printf("Notification Removed!\n");
-        if (pData[2] == 1)
-        {
-            printf("Call Gone!\n");
-        }
-    }
-    pendingNotification = true;
-}
-
-class ServerCallbacks : public NimBLEServerCallbacks
-{
-    void onConnect(NimBLEServer *pServer, NimBLEConnInfo &connInfo)
-    {
-        printf("Client connected: %s\n", connInfo.getAddress().toString().c_str());
-        pClient = pServer->getClient(connInfo);
-        printf("Client connected!\n");
-    }
-
-    void onDisconnect(NimBLEServer *pServer, NimBLEConnInfo &connInfo, int reason)
-    {
-        printf("Client disconnected: %s, reason: %d\n", connInfo.getAddress().toString().c_str(), reason);
-    }
-} serverCallbacks;
-
-extern "C" void app_main()
-{
-    initUart();
-    printf("Starting setup...\n");
-
-    NimBLEDevice::init("ANCS");
-    NimBLEDevice::setSecurityAuth(true, true, true);
-    NimBLEDevice::setSecurityIOCap(BLE_HS_IO_DISPLAY_YESNO);
-    NimBLEDevice::setPower(9);
-
-    NimBLEServer *pServer = NimBLEDevice::createServer();
-    pServer->setCallbacks(&serverCallbacks);
-    pServer->advertiseOnDisconnect(true);
-
-    NimBLEAdvertising *pAdvertising = pServer->getAdvertising();
-    NimBLEAdvertisementData advData{};
-    advData.setFlags(0x06);
-    advData.addServiceUUID(ancsServiceUUID);
-    pAdvertising->setAdvertisementData(advData);
-    pAdvertising->start();
-
-    printf("Advertising started!\n");
-
-    while (1)
-    {
-        if (pClient != nullptr && pClient->isConnected())
-        {
-            auto pAncsService = pClient->getService(ancsServiceUUID);
-            if (pAncsService == nullptr)
-            {
-                printf("Failed to find our service UUID: %s\n", ancsServiceUUID.toString().c_str());
-                continue;
-            }
-            // Obtain a reference to the characteristic in the service of the remote BLE server.
-            auto pNotificationSourceCharacteristic = pAncsService->getCharacteristic(notificationSourceCharacteristicUUID);
-            if (pNotificationSourceCharacteristic == nullptr)
-            {
-                printf("Failed to find our characteristic UUID: %s\n",
-                       notificationSourceCharacteristicUUID.toString().c_str());
-                continue;
-            }
-            // Obtain a reference to the characteristic in the service of the remote BLE server.
-            auto pControlPointCharacteristic = pAncsService->getCharacteristic(controlPointCharacteristicUUID);
-            if (pControlPointCharacteristic == nullptr)
-            {
-                printf("Failed to find our characteristic UUID: %s\n",
-                       controlPointCharacteristicUUID.toString().c_str());
-                continue;
-            }
-            // Obtain a reference to the characteristic in the service of the remote BLE server.
-            auto pDataSourceCharacteristic = pAncsService->getCharacteristic(dataSourceCharacteristicUUID);
-            if (pDataSourceCharacteristic == nullptr)
-            {
-                printf("Failed to find our characteristic UUID: %s\n", dataSourceCharacteristicUUID.toString().c_str());
-                continue;
-            }
-            pDataSourceCharacteristic->subscribe(true, dataSourceNotifyCallback);
-            pNotificationSourceCharacteristic->subscribe(true, NotificationSourceNotifyCallback);
-
-            while (1)
-            {
-                if (pendingNotification || incomingCall)
-                {
-                    // CommandID: CommandIDGetNotificationAttributes
-                    // 32bit uid
-                    // AttributeID
-                    printf("Requesting details...\n");
-                    uint8_t val[8] =
-                        {0x0, latestMessageID[0], latestMessageID[1], latestMessageID[2], latestMessageID[3], 0x0, 0x0, 0x10};
-                    pControlPointCharacteristic->writeValue(val, 6, true); // Identifier
-                    val[5] = 0x1;
-                    pControlPointCharacteristic->writeValue(val, 8, true); // Title
-                    val[5] = 0x3;
-                    pControlPointCharacteristic->writeValue(val, 8, true); // Message
-                    val[5] = 0x5;
-                    pControlPointCharacteristic->writeValue(val, 6, true); // Date
-
-                    while (incomingCall)
-                    {
-                        int bytesRead = uart_read_bytes(UART_NUM_0, &acceptCall, 1, 0);
-                        if (bytesRead > 0)
-                        {
-                            printf("%c\n", (char)acceptCall);
-                        }
-
-                        if (acceptCall == 49)
-                        { // call accepted , get number 1 from serial
-                            const uint8_t vResponse[] =
-                                {0x02, latestMessageID[0], latestMessageID[1], latestMessageID[2], latestMessageID[3], 0x00};
-                            pControlPointCharacteristic->writeValue((uint8_t *)vResponse, 6, true);
-
-                            acceptCall = 0;
-                            // incomingCall = false;
-                        }
-                        else if (acceptCall == 48)
-                        { // call rejected , get number 0 from serial
-                            const uint8_t vResponse[] =
-                                {0x02, latestMessageID[0], latestMessageID[1], latestMessageID[2], latestMessageID[3], 0x01};
-                            pControlPointCharacteristic->writeValue((uint8_t *)vResponse, 6, true);
-
-                            acceptCall = 0;
-                            incomingCall = false;
-                        }
-                        vTaskDelay(10 / portTICK_PERIOD_MS);
-                    }
-
-                    pendingNotification = false;
-                }
-                vTaskDelay(10 / portTICK_PERIOD_MS);
-            }
-        }
-        vTaskDelay(10 / portTICK_PERIOD_MS);
-    }
-}

examples/ANCS/sdkconfig.defaults

@@ -1,13 +0,0 @@
-# Override some defaults so BT stack is enabled
-# in this example
-
-#
-# BT config
-#
-CONFIG_BT_ENABLED=y
-CONFIG_BTDM_CTRL_MODE_BLE_ONLY=y
-CONFIG_BTDM_CTRL_MODE_BR_EDR_ONLY=n
-CONFIG_BTDM_CTRL_MODE_BTDM=n
-CONFIG_BT_BLUEDROID_ENABLED=n
-CONFIG_BT_NIMBLE_ENABLED=y
-CONFIG_BT_NIMBLE_NVS_PERSIST=y

examples/Bluetooth_5/NimBLE_extended_server/main/main.cpp

@@ -36,7 +36,7 @@ static uint8_t secondaryPhy = BLE_HCI_LE_PHY_1M;
 /** Handler class for server events */
 class ServerCallbacks : public NimBLEServerCallbacks {
     void onConnect(NimBLEServer* pServer, NimBLEConnInfo& connInfo) override {
-        printf("Client connected:\n%s", connInfo.toString().c_str());
+        printf("Client connected:: %s\n", connInfo.getAddress().toString().c_str());
     }
 
     void onDisconnect(NimBLEServer* pServer, NimBLEConnInfo& connInfo, int reason) override {
@@ -80,6 +80,9 @@ extern "C" void app_main(void) {
 
     pCharacteristic->setValue("Hello World");
 
+    /** Start the service */
+    pService->start();
+
     /**
      *  Create an extended advertisement with the instance ID 0 and set the PHY's.
      *  Multiple instances can be added as long as the instance ID is incremented.

examples/Bluetooth_5/NimBLE_multi_advertiser/main/main.cpp

@@ -36,7 +36,7 @@ static uint8_t secondaryPhy = BLE_HCI_LE_PHY_1M;
 /** Handler class for server events */
 class ServerCallbacks : public NimBLEServerCallbacks {
     void onConnect(NimBLEServer* pServer, NimBLEConnInfo& connInfo) override {
-        printf("Client connected:\n%s", connInfo.toString().c_str());
+        printf("Client connected: %s\n", connInfo.getAddress().toString().c_str());
     }
 
     void onDisconnect(NimBLEServer* pServer, NimBLEConnInfo& connInfo, int reason) override {
@@ -98,6 +98,9 @@ extern "C" void app_main(void) {
 
     pCharacteristic->setValue("Hello World");
 
+    /** Start the service */
+    pService->start();
+
     /** Create our multi advertising instances */
 
     /** extended scannable instance advertising on coded and 1m PHY's. */

examples/NimBLE_Server/main/main.cpp

@@ -16,7 +16,7 @@ static NimBLEServer* pServer;
  **                       Remove as you see fit for your needs                        */
 class ServerCallbacks : public NimBLEServerCallbacks {
     void onConnect(NimBLEServer* pServer, NimBLEConnInfo& connInfo) override {
-        printf("Client connected:\n%s", connInfo.toString().c_str());
+        printf("Client address: %s\n", connInfo.getAddress().toString().c_str());
 
         /**
          *  We can use the connection handle here to ask for different connection parameters.
@@ -184,6 +184,10 @@ extern "C" void app_main(void) {
     pC01Ddsc->setValue("Send it back!");
     pC01Ddsc->setCallbacks(&dscCallbacks);
 
+    /** Start the services when finished creating all Characteristics and Descriptors */
+    pDeadService->start();
+    pBaadService->start();
+
     /** Create an advertising instance and add the services to the advertised data */
     NimBLEAdvertising* pAdvertising = NimBLEDevice::getAdvertising();
     pAdvertising->setName("NimBLE-Server");

examples/NimBLE_Stream_Client/CMakeLists.txt

@@ -1,6 +0,0 @@
-# The following lines of boilerplate have to be in your project's
-# CMakeLists in this exact order for cmake to work correctly
-cmake_minimum_required(VERSION 3.5)
-
-include($ENV{IDF_PATH}/tools/cmake/project.cmake)
-project(NimBLE_Stream_Client)

examples/NimBLE_Stream_Client/README.md

@@ -1,53 +0,0 @@
-# NimBLE Stream Client Example
-
-This example demonstrates how to use the `NimBLEStreamClient` class to connect to a BLE GATT server and communicate using the familiar Arduino Stream interface.
-
-## Features
-
-- Uses Arduino Stream interface (print, println, read, available, etc.)
-- Automatic server discovery and connection
-- Bidirectional communication
-- Buffered TX/RX using ring buffers
-- Automatic reconnection on disconnect
-- Similar usage to Serial communication
-
-## How it Works
-
-1. Scans for BLE devices advertising the target service UUID
-2. Connects to the server and discovers the stream characteristic
-3. Initializes `NimBLEStreamClient` with the remote characteristic
-4. Subscribes to notifications to receive data in the RX buffer
-5. Uses familiar Stream methods like `print()`, `println()`, `read()`, and `available()`
-
-## Usage
-
-1. Build and flash the NimBLE_Stream_Server example to one ESP32 using ESP-IDF (`idf.py build flash monitor`)
-2. Build and flash this client example to another ESP32 using ESP-IDF
-3. The client will automatically:
-   - Scan for the server
-   - Connect when found
-   - Set up the stream interface
-   - Begin bidirectional communication
-4. Open `idf.py monitor` on each board to observe stream traffic
-
-## Service UUIDs
-
-Must match the server:
-- Service: `6E400001-B5A3-F393-E0A9-E50E24DCCA9E`
-- Characteristic: `6E400002-B5A3-F393-E0A9-E50E24DCCA9E`
-
-## Monitor Output
-
-The example displays:
-- Server discovery progress
-- Connection status
-- All data received from the server
-- Confirmation of data sent to the server
-
-## Testing
-
-Run with NimBLE_Stream_Server to see bidirectional communication:
-- Server sends periodic status messages
-- Client sends periodic uptime messages
-- Both echo data received from each other
-- You can send data from either `idf.py monitor` session

examples/NimBLE_Stream_Client/main/CMakeLists.txt

@@ -1,4 +0,0 @@
-set(COMPONENT_SRCS "main.cpp")
-set(COMPONENT_ADD_INCLUDEDIRS ".")
-
-register_component()

examples/NimBLE_Stream_Client/main/main.cpp

@@ -1,217 +0,0 @@
-/**
- *  NimBLE_Stream_Client Example:
- *
- *  Demonstrates using NimBLEStreamClient to connect to a BLE GATT server
- *  and communicate using the Stream-like interface.
- *
- *  This example connects to the NimBLE_Stream_Server example.
- */
-
-#include <inttypes.h>
-#include <stdint.h>
-#include <stdio.h>
-
-#include "esp_timer.h"
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-
-#include <NimBLEDevice.h>
-
-// Service and Characteristic UUIDs (must match the server)
-#define SERVICE_UUID        "6E400001-B5A3-F393-E0A9-E50E24DCCA9E"
-#define CHARACTERISTIC_UUID "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
-
-// Create the stream client instance
-NimBLEStreamClient bleStream;
-
-struct RxOverflowStats {
-    uint32_t droppedOld{0};
-    uint32_t droppedNew{0};
-};
-
-RxOverflowStats g_rxOverflowStats;
-uint32_t        scanTime = 5000; // Scan duration in milliseconds
-
-NimBLEStream::RxOverflowAction onRxOverflow(const uint8_t* data, size_t len, void* userArg) {
-    auto* stats = static_cast<RxOverflowStats*>(userArg);
-    if (stats) {
-        stats->droppedOld++;
-    }
-
-    // For status/telemetry streams, prioritize newest packets.
-    (void)data;
-    (void)len;
-    return NimBLEStream::DROP_OLDER_DATA;
-}
-
-static uint64_t millis() {
-    return esp_timer_get_time() / 1000ULL;
-}
-
-// Connection state variables
-static bool                          doConnect     = false;
-static bool                          connected     = false;
-static const NimBLEAdvertisedDevice* pServerDevice = nullptr;
-static NimBLEClient*                 pClient       = nullptr;
-
-/** Scan callbacks to find the server */
-class ScanCallbacks : public NimBLEScanCallbacks {
-    void onResult(const NimBLEAdvertisedDevice* advertisedDevice) override {
-        printf("Advertised Device: %s\n", advertisedDevice->toString().c_str());
-
-        // Check if this device advertises our service.
-        if (advertisedDevice->isAdvertisingService(NimBLEUUID(SERVICE_UUID))) {
-            printf("Found our stream server!\n");
-            pServerDevice = advertisedDevice;
-            NimBLEDevice::getScan()->stop();
-            doConnect = true;
-        }
-    }
-
-    void onScanEnd(const NimBLEScanResults& results, int reason) override {
-        (void)results;
-        (void)reason;
-        printf("Scan ended\n");
-        if (!doConnect && !connected) {
-            printf("Server not found, restarting scan...\n");
-            NimBLEDevice::getScan()->start(scanTime, false, true);
-        }
-    }
-} scanCallbacks;
-
-/** Client callbacks for connection/disconnection events */
-class ClientCallbacks : public NimBLEClientCallbacks {
-    void onConnect(NimBLEClient* pClient) override {
-        printf("Connected to server\n");
-        // Update connection parameters for better throughput.
-        pClient->updateConnParams(12, 24, 0, 200);
-    }
-
-    void onDisconnect(NimBLEClient* pClient, int reason) override {
-        (void)pClient;
-        printf("Disconnected from server, reason: %d\n", reason);
-        connected = false;
-        bleStream.end();
-
-        // Restart scanning.
-        printf("Restarting scan...\n");
-        NimBLEDevice::getScan()->start(scanTime, false, true);
-    }
-} clientCallbacks;
-
-/** Connect to the BLE Server and set up the stream */
-bool connectToServer() {
-    printf("Connecting to: %s\n", pServerDevice->getAddress().toString().c_str());
-
-    // Create or reuse a client.
-    pClient = NimBLEDevice::getClientByPeerAddress(pServerDevice->getAddress());
-    if (!pClient) {
-        pClient = NimBLEDevice::createClient();
-        if (!pClient) {
-            printf("Failed to create client\n");
-            return false;
-        }
-        pClient->setClientCallbacks(&clientCallbacks, false);
-        pClient->setConnectionParams(12, 24, 0, 200);
-        pClient->setConnectTimeout(5000);
-    }
-
-    // Connect to the remote BLE Server.
-    if (!pClient->connect(pServerDevice)) {
-        printf("Failed to connect to server\n");
-        return false;
-    }
-
-    printf("Connected! Discovering services...\n");
-
-    // Get the service and characteristic.
-    NimBLERemoteService* pRemoteService = pClient->getService(SERVICE_UUID);
-    if (!pRemoteService) {
-        printf("Failed to find our service UUID\n");
-        pClient->disconnect();
-        return false;
-    }
-    printf("Found the stream service\n");
-
-    NimBLERemoteCharacteristic* pRemoteCharacteristic = pRemoteService->getCharacteristic(CHARACTERISTIC_UUID);
-    if (!pRemoteCharacteristic) {
-        printf("Failed to find our characteristic UUID\n");
-        pClient->disconnect();
-        return false;
-    }
-    printf("Found the stream characteristic\n");
-
-    // subscribeNotify=true means notifications are stored in the RX buffer.
-    if (!bleStream.begin(pRemoteCharacteristic, true)) {
-        printf("Failed to initialize BLE stream!\n");
-        pClient->disconnect();
-        return false;
-    }
-
-    bleStream.setRxOverflowCallback(onRxOverflow, &g_rxOverflowStats);
-
-    printf("BLE Stream initialized successfully!\n");
-    connected = true;
-    return true;
-}
-
-extern "C" void app_main(void) {
-    printf("Starting NimBLE Stream Client\n");
-
-    /** Initialize NimBLE */
-    NimBLEDevice::init("NimBLE-StreamClient");
-
-    // Create the BLE scan instance and set callbacks.
-    NimBLEScan* pScan = NimBLEDevice::getScan();
-    pScan->setScanCallbacks(&scanCallbacks, false);
-    pScan->setActiveScan(true);
-
-    // Start scanning for the server.
-    printf("Scanning for BLE Stream Server...\n");
-    pScan->start(scanTime, false, true);
-
-    uint32_t lastDroppedOld = 0;
-    uint32_t lastDroppedNew = 0;
-    uint64_t lastSend       = 0;
-
-    for (;;) {
-        if (g_rxOverflowStats.droppedOld != lastDroppedOld || g_rxOverflowStats.droppedNew != lastDroppedNew) {
-            lastDroppedOld = g_rxOverflowStats.droppedOld;
-            lastDroppedNew = g_rxOverflowStats.droppedNew;
-            printf("RX overflow handled (drop-old=%" PRIu32 ", drop-new=%" PRIu32 ")\n", lastDroppedOld, lastDroppedNew);
-        }
-
-        // If we found a server, try to connect.
-        if (doConnect) {
-            doConnect = false;
-            if (connectToServer()) {
-                printf("Stream ready for communication!\n");
-            } else {
-                printf("Failed to connect to server, restarting scan...\n");
-                pServerDevice = nullptr;
-                NimBLEDevice::getScan()->start(scanTime, false, true);
-            }
-        }
-
-        // If connected, demonstrate stream communication.
-        if (connected && bleStream) {
-            if (bleStream.available()) {
-                printf("Received from server: ");
-                while (bleStream.available()) {
-                    char c = bleStream.read();
-                    putchar(c);
-                }
-                printf("\n");
-            }
-
-            uint64_t now = millis();
-            if (now - lastSend > 5000) {
-                lastSend = now;
-                bleStream.printf("Hello from client! Uptime: %" PRIu64 " seconds\n", now / 1000);
-                printf("Sent data to server via BLE stream\n");
-            }
-        }
-
-        vTaskDelay(pdMS_TO_TICKS(10));
-    }
-}

examples/NimBLE_Stream_Client/sdkconfig.defaults

@@ -1,12 +0,0 @@
-# Override some defaults so BT stack is enabled
-# in this example
-
-#
-# BT config
-#
-CONFIG_BT_ENABLED=y
-CONFIG_BTDM_CTRL_MODE_BLE_ONLY=y
-CONFIG_BTDM_CTRL_MODE_BR_EDR_ONLY=n
-CONFIG_BTDM_CTRL_MODE_BTDM=n
-CONFIG_BT_BLUEDROID_ENABLED=n
-CONFIG_BT_NIMBLE_ENABLED=y

examples/NimBLE_Stream_Echo/CMakeLists.txt

@@ -1,6 +0,0 @@
-# The following lines of boilerplate have to be in your project's
-# CMakeLists in this exact order for cmake to work correctly
-cmake_minimum_required(VERSION 3.5)
-
-include($ENV{IDF_PATH}/tools/cmake/project.cmake)
-project(NimBLE_Stream_Echo)

examples/NimBLE_Stream_Echo/README.md

@@ -1,39 +0,0 @@
-# NimBLE Stream Echo Example
-
-This is the simplest example demonstrating `NimBLEStreamServer`. It echoes back any data received from BLE clients.
-
-## Features
-
-- Minimal code showing essential NimBLE Stream usage
-- Echoes all received data back to the client
-- Uses default service and characteristic UUIDs
-- Perfect starting point for learning the Stream interface
-
-## How it Works
-
-1. Initializes BLE with minimal configuration
-2. Creates a stream server with default UUIDs
-3. Waits for client connection and data
-4. Echoes received data back to the client
-5. Displays received data in the ESP-IDF monitor output
-
-## Default UUIDs
-
-- Service: `0xc0de`
-- Characteristic: `0xfeed`
-
-## Usage
-
-1. Build and flash this example to your ESP32 using ESP-IDF (`idf.py build flash monitor`)
-2. Connect with a BLE client app (nRF Connect, Serial Bluetooth Terminal, etc.)
-3. Find the service `0xc0de` and characteristic `0xfeed`
-4. Subscribe to notifications
-5. Write data to the characteristic
-6. The data will be echoed back and displayed in `idf.py monitor`
-
-## Good For
-
-- Learning the basic NimBLE Stream API
-- Testing BLE connectivity
-- Starting point for custom applications
-- Understanding Stream read/write operations

examples/NimBLE_Stream_Echo/main/CMakeLists.txt

@@ -1,4 +0,0 @@
-set(COMPONENT_SRCS "main.cpp")
-set(COMPONENT_ADD_INCLUDEDIRS ".")
-
-register_component()

examples/NimBLE_Stream_Echo/main/main.cpp

@@ -1,83 +0,0 @@
-/**
- *  NimBLE_Stream_Echo Example:
- *
- *  A minimal example demonstrating NimBLEStreamServer.
- *  Echoes back any data received from BLE clients.
- */
-
-#include <inttypes.h>
-#include <stdint.h>
-#include <stdio.h>
-
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-
-#include <NimBLEDevice.h>
-
-NimBLEStreamServer bleStream;
-
-struct RxOverflowStats {
-    uint32_t droppedOld{0};
-    uint32_t droppedNew{0};
-};
-
-RxOverflowStats g_rxOverflowStats;
-
-NimBLEStream::RxOverflowAction onRxOverflow(const uint8_t* data, size_t len, void* userArg) {
-    auto* stats = static_cast<RxOverflowStats*>(userArg);
-    if (stats) {
-        stats->droppedOld++;
-    }
-
-    // Echo mode prefers the latest incoming bytes.
-    (void)data;
-    (void)len;
-    return NimBLEStream::DROP_OLDER_DATA;
-}
-
-extern "C" void app_main(void) {
-    printf("NimBLE Stream Echo Server\n");
-
-    // Initialize BLE.
-    NimBLEDevice::init("BLE-Echo");
-    auto pServer = NimBLEDevice::createServer();
-    pServer->advertiseOnDisconnect(true); // Keep advertising after disconnects.
-
-    if (!bleStream.begin(NimBLEUUID(uint16_t(0xc0de)),
-                         NimBLEUUID(uint16_t(0xfeed)),
-                         1024,
-                         1024,
-                         false)) {
-        printf("Failed to initialize BLE stream\n");
-        return;
-    }
-
-    bleStream.setRxOverflowCallback(onRxOverflow, &g_rxOverflowStats);
-
-    // Start advertising.
-    NimBLEDevice::getAdvertising()->start();
-    printf("Ready! Connect with a BLE client and send data.\n");
-
-    uint32_t lastDroppedOld = 0;
-    uint32_t lastDroppedNew = 0;
-
-    for (;;) {
-        if (g_rxOverflowStats.droppedOld != lastDroppedOld || g_rxOverflowStats.droppedNew != lastDroppedNew) {
-            lastDroppedOld = g_rxOverflowStats.droppedOld;
-            lastDroppedNew = g_rxOverflowStats.droppedNew;
-            printf("RX overflow handled (drop-old=%" PRIu32 ", drop-new=%" PRIu32 ")\n", lastDroppedOld, lastDroppedNew);
-        }
-
-        // Echo any received data back to the client.
-        if (bleStream.ready() && bleStream.available()) {
-            printf("Echo: ");
-            while (bleStream.available()) {
-                char c = bleStream.read();
-                putchar(c);
-                bleStream.write(c);
-            }
-            printf("\n");
-        }
-        vTaskDelay(pdMS_TO_TICKS(10));
-    }
-}

examples/NimBLE_Stream_Echo/sdkconfig.defaults

@@ -1,12 +0,0 @@
-# Override some defaults so BT stack is enabled
-# in this example
-
-#
-# BT config
-#
-CONFIG_BT_ENABLED=y
-CONFIG_BTDM_CTRL_MODE_BLE_ONLY=y
-CONFIG_BTDM_CTRL_MODE_BR_EDR_ONLY=n
-CONFIG_BTDM_CTRL_MODE_BTDM=n
-CONFIG_BT_BLUEDROID_ENABLED=n
-CONFIG_BT_NIMBLE_ENABLED=y

examples/NimBLE_Stream_Server/CMakeLists.txt

@@ -1,6 +0,0 @@
-# The following lines of boilerplate have to be in your project's
-# CMakeLists in this exact order for cmake to work correctly
-cmake_minimum_required(VERSION 3.5)
-
-include($ENV{IDF_PATH}/tools/cmake/project.cmake)
-project(NimBLE_Stream_Server)

examples/NimBLE_Stream_Server/README.md

@@ -1,42 +0,0 @@
-# NimBLE Stream Server Example
-
-This example demonstrates how to use the `NimBLEStreamServer` class to create a BLE GATT server that behaves like a serial port using the familiar Arduino Stream interface.
-
-## Features
-
-- Uses Arduino Stream interface (print, println, read, available, etc.)
-- Automatic connection management
-- Bidirectional communication
-- Buffered TX/RX using ring buffers
-- Similar usage to Serial communication
-
-## How it Works
-
-1. Creates a BLE GATT server with a custom service and characteristic
-2. Initializes `NimBLEStreamServer` with the characteristic configured for notifications and writes
-3. Uses familiar Stream methods like `print()`, `println()`, `read()`, and `available()`
-4. Automatically handles connection state and MTU negotiation
-
-## Usage
-
-1. Build and flash this example to your ESP32 using ESP-IDF (`idf.py build flash monitor`)
-2. The device will advertise as "NimBLE-Stream"
-3. Connect with a BLE client (such as the NimBLE_Stream_Client example or a mobile app)
-4. Once connected, the server will:
-   - Send periodic messages to the client
-   - Echo back any data received from the client
-   - Display all communication in `idf.py monitor`
-
-## Service UUIDs
-
-- Service: `6E400001-B5A3-F393-E0A9-E50E24DCCA9E`
-- Characteristic: `6E400002-B5A3-F393-E0A9-E50E24DCCA9E`
-
-These are based on the Nordic UART Service (NUS) UUIDs for compatibility with many BLE terminal apps.
-
-## Compatible With
-
-- NimBLE_Stream_Client example
-- nRF Connect mobile app
-- Serial Bluetooth Terminal apps
-- Any BLE client that supports characteristic notifications and writes

examples/NimBLE_Stream_Server/main/CMakeLists.txt

@@ -1,4 +0,0 @@
-set(COMPONENT_SRCS "main.cpp")
-set(COMPONENT_ADD_INCLUDEDIRS ".")
-
-register_component()

examples/NimBLE_Stream_Server/main/main.cpp

@@ -1,146 +0,0 @@
-/**
- *  NimBLE_Stream_Server Example:
- *
- *  Demonstrates using NimBLEStreamServer to create a BLE GATT server
- *  that behaves like a serial port using the Stream-like interface.
- */
-
-#include <inttypes.h>
-#include <stdint.h>
-#include <stdio.h>
-
-#include "esp_heap_caps.h"
-#include "esp_timer.h"
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-
-#include <NimBLEDevice.h>
-
-// Create the stream server instance
-NimBLEStreamServer bleStream;
-
-struct RxOverflowStats {
-    uint32_t droppedOld{0};
-    uint32_t droppedNew{0};
-};
-
-RxOverflowStats g_rxOverflowStats;
-
-NimBLEStream::RxOverflowAction onRxOverflow(const uint8_t* data, size_t len, void* userArg) {
-    auto* stats = static_cast<RxOverflowStats*>(userArg);
-    if (stats) {
-        stats->droppedOld++;
-    }
-
-    // Keep the newest bytes for command/stream style traffic.
-    (void)data;
-    (void)len;
-    return NimBLEStream::DROP_OLDER_DATA;
-}
-
-static uint64_t millis() {
-    return esp_timer_get_time() / 1000ULL;
-}
-
-// Service and Characteristic UUIDs for the stream.
-#define SERVICE_UUID        "6E400001-B5A3-F393-E0A9-E50E24DCCA9E"
-#define CHARACTERISTIC_UUID "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
-
-/** Server callbacks to handle connection/disconnection events */
-class ServerCallbacks : public NimBLEServerCallbacks {
-    void onConnect(NimBLEServer* pServer, NimBLEConnInfo& connInfo) override {
-        printf("Client connected: %s\n", connInfo.getAddress().toString().c_str());
-        // Optionally update connection parameters for better throughput.
-        pServer->updateConnParams(connInfo.getConnHandle(), 12, 24, 0, 200);
-    }
-
-    void onDisconnect(NimBLEServer* pServer, NimBLEConnInfo& connInfo, int reason) override {
-        (void)pServer;
-        (void)connInfo;
-        printf("Client disconnected - reason: %d, restarting advertising\n", reason);
-        NimBLEDevice::startAdvertising();
-    }
-
-    void onMTUChange(uint16_t MTU, NimBLEConnInfo& connInfo) override {
-        printf("MTU updated: %u for connection ID: %u\n", MTU, connInfo.getConnHandle());
-    }
-} serverCallbacks;
-
-extern "C" void app_main(void) {
-    printf("Starting NimBLE Stream Server\n");
-
-    /** Initialize NimBLE and set the device name */
-    NimBLEDevice::init("NimBLE-Stream");
-
-    /**
-     * Create the BLE server and set callbacks.
-     * Note: The stream will create its own service and characteristic.
-     */
-    NimBLEServer* pServer = NimBLEDevice::createServer();
-    pServer->setCallbacks(&serverCallbacks);
-
-    /**
-     * Initialize the stream server with:
-     * - Service UUID
-     * - Characteristic UUID
-     * - txBufSize: 1024 bytes for outgoing data (notifications)
-     * - rxBufSize: 1024 bytes for incoming data (writes)
-     * - secure: false (no encryption required - set true for secure connections)
-     */
-    if (!bleStream.begin(NimBLEUUID(SERVICE_UUID),
-                         NimBLEUUID(CHARACTERISTIC_UUID),
-                         1024,
-                         1024,
-                         false)) {
-        printf("Failed to initialize BLE stream!\n");
-        return;
-    }
-
-    bleStream.setRxOverflowCallback(onRxOverflow, &g_rxOverflowStats);
-
-    // Make the stream service discoverable.
-    NimBLEAdvertising* pAdvertising = NimBLEDevice::getAdvertising();
-    pAdvertising->addServiceUUID(SERVICE_UUID);
-    pAdvertising->setName("NimBLE-Stream");
-    pAdvertising->enableScanResponse(true);
-    pAdvertising->start();
-
-    printf("BLE Stream Server ready!\n");
-    printf("Waiting for client connection...\n");
-
-    uint32_t lastDroppedOld = 0;
-    uint32_t lastDroppedNew = 0;
-    uint64_t lastSend       = 0;
-
-    for (;;) {
-        if (g_rxOverflowStats.droppedOld != lastDroppedOld || g_rxOverflowStats.droppedNew != lastDroppedNew) {
-            lastDroppedOld = g_rxOverflowStats.droppedOld;
-            lastDroppedNew = g_rxOverflowStats.droppedNew;
-            printf("RX overflow handled (drop-old=%" PRIu32 ", drop-new=%" PRIu32 ")\n", lastDroppedOld, lastDroppedNew);
-        }
-
-        if (bleStream.ready()) {
-            uint64_t now = millis();
-            if (now - lastSend > 2000) {
-                lastSend = now;
-                bleStream.printf("Hello from server! Uptime: %" PRIu64 " seconds\n", now / 1000);
-                bleStream.printf("Free heap: %" PRIu32 " bytes\n", esp_get_free_heap_size());
-                printf("Sent data to client via BLE stream\n");
-            }
-
-            if (bleStream.available()) {
-                printf("Received from client: ");
-                while (bleStream.available()) {
-                    char c = bleStream.read();
-                    putchar(c);
-                    bleStream.write(c); // Echo back to BLE client.
-                }
-                printf("\n");
-            }
-        } else {
-            vTaskDelay(pdMS_TO_TICKS(100));
-        }
-
-        vTaskDelay(pdMS_TO_TICKS(10));
-    }
-}

examples/NimBLE_Stream_Server/sdkconfig.defaults

@@ -1,12 +0,0 @@
-# Override some defaults so BT stack is enabled
-# in this example
-
-#
-# BT config
-#
-CONFIG_BT_ENABLED=y
-CONFIG_BTDM_CTRL_MODE_BLE_ONLY=y
-CONFIG_BTDM_CTRL_MODE_BR_EDR_ONLY=n
-CONFIG_BTDM_CTRL_MODE_BTDM=n
-CONFIG_BT_BLUEDROID_ENABLED=n
-CONFIG_BT_NIMBLE_ENABLED=y

src/NimBLEAdvertisedDevice.cpp

@@ -52,7 +52,6 @@ NimBLEAdvertisedDevice::NimBLEAdvertisedDevice(const ble_gap_event* event, uint8
       m_advLength{event->disc.length_data},
       m_payload(event->disc.data, event->disc.data + event->disc.length_data) {
 # endif
-    m_pNextWaiting = this; // initialize sentinel: self-pointer means "not in list"
 } // NimBLEAdvertisedDevice
 
 /**

src/NimBLEAdvertisedDevice.h

@@ -158,13 +158,11 @@ class NimBLEAdvertisedDevice {
     uint8_t findAdvField(uint8_t type, uint8_t index = 0, size_t* data_loc = nullptr) const;
     size_t  findServiceData(uint8_t index, uint8_t* bytes) const;
 
-    NimBLEAddress             m_address{};
-    uint8_t                   m_advType{};
-    int8_t                    m_rssi{};
-    uint8_t                   m_callbackSent{};
-    uint16_t                  m_advLength{};
-    ble_npl_time_t            m_time{};
-    NimBLEAdvertisedDevice*   m_pNextWaiting{}; // intrusive list node; self-pointer means "not in list", set in ctor
+    NimBLEAddress m_address{};
+    uint8_t       m_advType{};
+    int8_t        m_rssi{};
+    uint8_t       m_callbackSent{};
+    uint16_t      m_advLength{};
 
 # if MYNEWT_VAL(BLE_EXT_ADV)
     bool     m_isLegacyAdv{};

src/NimBLEAdvertising.cpp

@@ -197,9 +197,8 @@ bool NimBLEAdvertising::start(uint32_t duration, const NimBLEAddress* dirAddr) {
 
 # if MYNEWT_VAL(BLE_ROLE_PERIPHERAL)
     NimBLEServer* pServer = NimBLEDevice::getServer();
-    if (pServer != nullptr && !pServer->start()) { // make sure the GATT server is ready before advertising
-        NIMBLE_LOGE(LOG_TAG, "Failed to start GATT server");
-        return false;
+    if (pServer != nullptr) {
+        pServer->start(); // make sure the GATT server is ready before advertising
     }
 # endif
 

src/NimBLEAttValue.h

@@ -21,13 +21,8 @@
 #include "syscfg/syscfg.h"
 #if CONFIG_BT_NIMBLE_ENABLED
 
-/* Enables the use of Arduino String class for attribute values */
-# ifndef NIMBLE_CPP_ARDUINO_STRING_AVAILABLE
-#  define NIMBLE_CPP_ARDUINO_STRING_AVAILABLE (__has_include(<Arduino.h>))
-# endif
-
-# if NIMBLE_CPP_ARDUINO_STRING_AVAILABLE
-#  include <WString.h>
+# ifdef NIMBLE_CPP_ARDUINO_STRING_AVAILABLE
+#  include <Arduino.h>
 # endif
 
 # include <string>
@@ -150,7 +145,7 @@ class NimBLEAttValue {
     NimBLEAttValue(const std::vector<uint8_t> vec, uint16_t max_len = BLE_ATT_ATTR_MAX_LEN)
         : NimBLEAttValue(&vec[0], vec.size(), max_len) {}
 
-# if NIMBLE_CPP_ARDUINO_STRING_AVAILABLE
+# ifdef NIMBLE_CPP_ARDUINO_STRING_AVAILABLE
     /**
      * @brief Construct with an initial value from an Arduino String.
      * @param str An Arduino String containing to the initial value to set.
@@ -253,23 +248,6 @@ class NimBLEAttValue {
     /*********************** Template Functions ************************/
 
 # if __cplusplus < 201703L
-    /**
-     * @brief Template to set value to the value of a char array using strnlen.
-     * @param [in] s A reference to a char array.
-     * @details Only used for char array types to correctly determine length via strnlen.
-     */
-    template <typename T>
-#  ifdef _DOXYGEN_
-    bool
-#  else
-    typename std::enable_if<std::is_array<T>::value &&
-                                std::is_same<typename std::remove_extent<T>::type, char>::value,
-                            bool>::type
-#  endif
-    setValue(const T& s) {
-        return setValue(reinterpret_cast<const uint8_t*>(s), strnlen(s, sizeof(T)));
-    }
-
     /**
      * @brief Template to set value to the value of <type\>val.
      * @param [in] v The <type\>value to set.
@@ -280,10 +258,7 @@ class NimBLEAttValue {
 #  ifdef _DOXYGEN_
     bool
 #  else
-    typename std::enable_if<!std::is_pointer<T>::value && !Has_c_str_length<T>::value && !Has_data_size<T>::value &&
-                                !(std::is_array<T>::value &&
-                                  std::is_same<typename std::remove_extent<T>::type, char>::value),
-                            bool>::type
+    typename std::enable_if<!std::is_pointer<T>::value && !Has_c_str_length<T>::value && !Has_data_size<T>::value, bool>::type
 #  endif
     setValue(const T& v) {
         return setValue(reinterpret_cast<const uint8_t*>(&v), sizeof(T));
@@ -354,9 +329,6 @@ class NimBLEAttValue {
             }
         } else if constexpr (Has_c_str_length<T>::value) {
             return setValue(reinterpret_cast<const uint8_t*>(s.c_str()), s.length());
-        } else if constexpr (std::is_array<T>::value &&
-                             std::is_same<typename std::remove_extent<T>::type, char>::value) {
-            return setValue(reinterpret_cast<const uint8_t*>(s), strnlen(s, sizeof(s)));
         } else {
             return setValue(reinterpret_cast<const uint8_t*>(&s), sizeof(s));
         }
@@ -426,7 +398,7 @@ class NimBLEAttValue {
     /** @brief Inequality operator */
     bool operator!=(const NimBLEAttValue& source) const { return !(*this == source); }
 
-# if NIMBLE_CPP_ARDUINO_STRING_AVAILABLE
+# ifdef NIMBLE_CPP_ARDUINO_STRING_AVAILABLE
     /** @brief Operator; Get the value as an Arduino String value. */
     operator String() const { return String(reinterpret_cast<char*>(m_attr_value)); }
 # endif

src/NimBLECharacteristic.cpp

@@ -132,7 +132,7 @@ void NimBLECharacteristic::addDescriptor(NimBLEDescriptor* pDescriptor) {
     }
 
     pDescriptor->setCharacteristic(this);
-    NimBLEDevice::getServer()->setServiceChanged();
+    NimBLEDevice::getServer()->serviceChanged();
 }
 
 /**
@@ -159,33 +159,27 @@ void NimBLECharacteristic::removeDescriptor(NimBLEDescriptor* pDescriptor, bool
     }
 
     pDescriptor->setRemoved(deleteDsc ? NIMBLE_ATT_REMOVE_DELETE : NIMBLE_ATT_REMOVE_HIDE);
-    NimBLEDevice::getServer()->setServiceChanged();
+    NimBLEDevice::getServer()->serviceChanged();
 } // removeDescriptor
 
 /**
  * @brief Return the BLE Descriptor for the given UUID.
  * @param [in] uuid The UUID of the descriptor.
- * @param [in] index The index of the descriptor to return (used when multiple descriptors have the same UUID).
  * @return A pointer to the descriptor object or nullptr if not found.
  */
-NimBLEDescriptor* NimBLECharacteristic::getDescriptorByUUID(const char* uuid, uint16_t index) const {
-    return getDescriptorByUUID(NimBLEUUID(uuid), index);
+NimBLEDescriptor* NimBLECharacteristic::getDescriptorByUUID(const char* uuid) const {
+    return getDescriptorByUUID(NimBLEUUID(uuid));
 } // getDescriptorByUUID
 
 /**
  * @brief Return the BLE Descriptor for the given UUID.
  * @param [in] uuid The UUID of the descriptor.
- * @param [in] index The index of the descriptor to return (used when multiple descriptors have the same UUID).
  * @return A pointer to the descriptor object or nullptr if not found.
  */
-NimBLEDescriptor* NimBLECharacteristic::getDescriptorByUUID(const NimBLEUUID& uuid, uint16_t index) const {
-    uint16_t position = 0;
+NimBLEDescriptor* NimBLECharacteristic::getDescriptorByUUID(const NimBLEUUID& uuid) const {
     for (const auto& dsc : m_vDescriptors) {
         if (dsc->getUUID() == uuid) {
-            if (position == index) {
-                return dsc;
-            }
-            position++;
+            return dsc;
         }
     }
     return nullptr;

src/NimBLECharacteristic.h

@@ -69,8 +69,8 @@ class NimBLECharacteristic : public NimBLELocalValueAttribute {
                                        uint32_t          properties = NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE,
                                        uint16_t          maxLen     = BLE_ATT_ATTR_MAX_LEN);
     NimBLE2904*       create2904();
-    NimBLEDescriptor* getDescriptorByUUID(const char* uuid, uint16_t index = 0) const;
-    NimBLEDescriptor* getDescriptorByUUID(const NimBLEUUID& uuid, uint16_t index = 0) const;
+    NimBLEDescriptor* getDescriptorByUUID(const char* uuid) const;
+    NimBLEDescriptor* getDescriptorByUUID(const NimBLEUUID& uuid) const;
     NimBLEDescriptor* getDescriptorByHandle(uint16_t handle) const;
     NimBLEService*    getService() const;
 
@@ -113,7 +113,7 @@ class NimBLECharacteristic : public NimBLELocalValueAttribute {
     }
 
     /**
-     * @brief Template to send a notification with a value from a class that has a data() and size() method with value_type.
+         * @brief Template to send a notification with a value from a class that has a data() and size() method with value_type.
      * @param [in] v The value to send.
      * @param [in] connHandle Optional, a connection handle to send the notification to.
      * @details Correctly calculates byte size for containers with multi-byte element types.
@@ -125,7 +125,11 @@ class NimBLECharacteristic : public NimBLELocalValueAttribute {
     typename std::enable_if<Has_data_size<T>::value && Has_value_type<T>::value, bool>::type
 #  endif
     notify(const T& v, uint16_t connHandle = BLE_HS_CONN_HANDLE_NONE) const {
-        return notify(reinterpret_cast<const uint8_t*>(v.data()), v.size() * sizeof(typename T::value_type), connHandle);
+        return notify(
+            reinterpret_cast<const uint8_t*>(v.data()),
+            v.size() * sizeof(typename T::value_type),
+            connHandle
+        );
     }
 
     /**
@@ -189,7 +193,11 @@ class NimBLECharacteristic : public NimBLELocalValueAttribute {
     typename std::enable_if<Has_data_size<T>::value && Has_value_type<T>::value, bool>::type
 #  endif
     indicate(const T& v, uint16_t connHandle = BLE_HS_CONN_HANDLE_NONE) const {
-        return indicate(reinterpret_cast<const uint8_t*>(v.data()), v.size() * sizeof(typename T::value_type), connHandle);
+        return indicate(
+            reinterpret_cast<const uint8_t*>(v.data()),
+            v.size() * sizeof(typename T::value_type),
+            connHandle
+        );
     }
 
     /**
@@ -224,9 +232,7 @@ class NimBLECharacteristic : public NimBLELocalValueAttribute {
         const T& value, uint16_t connHandle = BLE_HS_CONN_HANDLE_NONE) const {
         if constexpr (Has_data_size<T>::value) {
             if constexpr (Has_value_type<T>::value) {
-                return notify(reinterpret_cast<const uint8_t*>(value.data()),
-                              value.size() * sizeof(typename T::value_type),
-                              connHandle);
+                return notify(reinterpret_cast<const uint8_t*>(value.data()), value.size() * sizeof(typename T::value_type), connHandle);
             } else {
                 return notify(reinterpret_cast<const uint8_t*>(value.data()), value.size(), connHandle);
             }
@@ -252,9 +258,7 @@ class NimBLECharacteristic : public NimBLELocalValueAttribute {
         const T& value, uint16_t connHandle = BLE_HS_CONN_HANDLE_NONE) const {
         if constexpr (Has_data_size<T>::value) {
             if constexpr (Has_value_type<T>::value) {
-                return indicate(reinterpret_cast<const uint8_t*>(value.data()),
-                                value.size() * sizeof(typename T::value_type),
-                                connHandle);
+                return indicate(reinterpret_cast<const uint8_t*>(value.data()), value.size() * sizeof(typename T::value_type), connHandle);
             } else {
                 return indicate(reinterpret_cast<const uint8_t*>(value.data()), value.size(), connHandle);
             }

src/NimBLEClient.cpp

@@ -34,12 +34,6 @@
 static const char*           LOG_TAG = "NimBLEClient";
 static NimBLEClientCallbacks defaultCallbacks;
 
-namespace {
-constexpr inline uint32_t connIntervalToMs(uint16_t interval) {
-    return (static_cast<uint32_t>(interval) * 5U) / 4U;
-} // connIntervalToMs
-} // namespace
-
 /*
  * Design
  * ------
@@ -73,9 +67,7 @@ NimBLEClient::NimBLEClient(const NimBLEAddress& peerAddress)
       m_connHandle{BLE_HS_CONN_HANDLE_NONE},
       m_terminateFailCount{0},
       m_asyncSecureAttempt{0},
-      m_connStatus{DISCONNECTED},
-      m_connectCallbackPending{false},
-      m_connectFailRetryCount{0},
+      m_config{},
 # if MYNEWT_VAL(BLE_EXT_ADV)
       m_phyMask{BLE_GAP_LE_PHY_1M_MASK | BLE_GAP_LE_PHY_2M_MASK | BLE_GAP_LE_PHY_CODED_MASK},
 # endif
@@ -87,10 +79,6 @@ NimBLEClient::NimBLEClient(const NimBLEAddress& peerAddress)
                    BLE_GAP_INITIAL_SUPERVISION_TIMEOUT,
                    BLE_GAP_INITIAL_CONN_MIN_CE_LEN,
                    BLE_GAP_INITIAL_CONN_MAX_CE_LEN} {
-    ble_npl_callout_init(&m_connectEstablishedTimer,
-                         nimble_port_get_dflt_eventq(),
-                         NimBLEClient::connectEstablishedTimerCb,
-                         this);
 } // NimBLEClient
 
 /**
@@ -98,9 +86,6 @@ NimBLEClient::NimBLEClient(const NimBLEAddress& peerAddress)
  * to ensure proper disconnect and removal from device list.
  */
 NimBLEClient::~NimBLEClient() {
-    ble_npl_callout_stop(&m_connectEstablishedTimer);
-    ble_npl_callout_deinit(&m_connectEstablishedTimer);
-
     // We may have allocated service references associated with this client.
     // Before we are finished with the client, we must release resources.
     deleteServices();
@@ -173,8 +158,50 @@ bool NimBLEClient::connect(bool deleteAttributes, bool asyncConnect, bool exchan
     return connect(m_peerAddress, deleteAttributes, asyncConnect, exchangeMTU);
 } // connect
 
-int NimBLEClient::startConnectionAttempt(const ble_addr_t* peerAddr) {
-    int rc = 0;
+/**
+ * @brief Connect to a BLE Server by address.
+ * @param [in] address The address of the server.
+ * @param [in] deleteAttributes If true this will delete any attribute objects this client may already\n
+ * have created when last connected.
+ * @param [in] asyncConnect If true, the connection will be made asynchronously and this function will return immediately.\n
+ * If false, this function will block until the connection is established or the connection attempt times out.
+ * @param [in] exchangeMTU If true, the client will attempt to exchange MTU with the server after connection.\n
+ * If false, the client will use the default MTU size and the application will need to call exchangeMTU() later.
+ * @return true on success.
+ */
+bool NimBLEClient::connect(const NimBLEAddress& address, bool deleteAttributes, bool asyncConnect, bool exchangeMTU) {
+    NIMBLE_LOGD(LOG_TAG, ">> connect(%s)", address.toString().c_str());
+
+    if (!NimBLEDevice::m_synced) {
+        NIMBLE_LOGE(LOG_TAG, "Host reset, wait for sync.");
+        return false;
+    }
+
+    if (isConnected()) {
+        NIMBLE_LOGE(LOG_TAG, "Client already connected");
+        return false;
+    }
+
+    const ble_addr_t* peerAddr = address.getBase();
+    if (ble_gap_conn_find_by_addr(peerAddr, NULL) == 0) {
+        NIMBLE_LOGE(LOG_TAG, "A connection to %s already exists", address.toString().c_str());
+        return false;
+    }
+
+    if (address.isNull()) {
+        NIMBLE_LOGE(LOG_TAG, "Invalid peer address; (NULL)");
+        return false;
+    } else {
+        m_peerAddress = address;
+    }
+
+    if (deleteAttributes) {
+        deleteServices();
+    }
+
+    int rc                = 0;
+    m_config.asyncConnect = asyncConnect;
+    m_config.exchangeMTU  = exchangeMTU;
 
     do {
 # if MYNEWT_VAL(BLE_EXT_ADV)
@@ -232,79 +259,25 @@ int NimBLEClient::startConnectionAttempt(const ble_addr_t* peerAddr) {
 
     } while (rc == BLE_HS_EBUSY);
 
-    return rc;
-}
-
-/**
- * @brief Connect to a BLE Server by address.
- * @param [in] address The address of the server.
- * @param [in] deleteAttributes If true this will delete any attribute objects this client may already\n
- * have created when last connected.
- * @param [in] asyncConnect If true, the connection will be made asynchronously and this function will return immediately.\n
- * If false, this function will block until the connection is established or the connection attempt times out.
- * @param [in] exchangeMTU If true, the client will attempt to exchange MTU with the server after connection.\n
- * If false, the client will use the default MTU size and the application will need to call exchangeMTU() later.
- * @return true on success.
- */
-bool NimBLEClient::connect(const NimBLEAddress& address, bool deleteAttributes, bool asyncConnect, bool exchangeMTU) {
-    NIMBLE_LOGD(LOG_TAG, ">> connect(%s)", address.toString().c_str());
-    NimBLETaskData    taskData(this);
-    const ble_addr_t* peerAddr = address.getBase();
-    int               rc       = 0;
-
-    if (!NimBLEDevice::m_synced) {
-        NIMBLE_LOGE(LOG_TAG, "Host not synced with controller.");
-        rc = BLE_HS_ENOTSYNCED;
-        goto error;
-    }
-
-    if (m_connStatus != DISCONNECTED) {
-        NIMBLE_LOGE(LOG_TAG, "Client not disconnected, cannot connect");
-        rc = BLE_HS_EREJECT;
-        goto error;
-    }
-
-    if (address.isNull()) {
-        NIMBLE_LOGE(LOG_TAG, "Invalid peer address; (NULL)");
-        rc = BLE_HS_EINVAL;
-        goto error;
-    }
-
-    if (!asyncConnect && NimBLEUtils::inHostTask()) {
-        NIMBLE_LOGE(LOG_TAG, "Cannot connect synchronously from host task");
-        rc = BLE_HS_EREJECT;
-        goto error;
-    }
-
-    m_connStatus             = CONNECTING;
-    m_peerAddress            = address;
-    m_config.asyncConnect    = asyncConnect;
-    m_config.exchangeMTU     = exchangeMTU;
-    m_connectCallbackPending = false;
-    m_connectFailRetryCount  = 0;
-
-    rc = startConnectionAttempt(peerAddr);
-
-    if (deleteAttributes) {
-        deleteServices();
-    }
-
     if (rc != 0) {
-        goto error;
+        m_lastErr = rc;
+        return false;
     }
 
     if (m_config.asyncConnect) {
         return true;
     }
 
+    NimBLETaskData taskData(this);
     m_pTaskData = &taskData;
 
-    // Wait for the connect timeout time +retry time * retries for the connection to complete
-    if (!NimBLEUtils::taskWait(
-            taskData,
-            (m_connectTimeout + connIntervalToMs(m_connParams.itvl_max) * 7) * (m_config.connectFailRetries + 1U))) {
-        if (m_connStatus != CONNECTED) {
-            // if the controller doesn't cancel the connection at the timeout, cancel it here.
+    // Wait for the connect timeout time +1 second for the connection to complete
+    if (!NimBLEUtils::taskWait(taskData, m_connectTimeout + 1000)) {
+        // If a connection was made but no response from MTU exchange proceed anyway
+        if (isConnected()) {
+            taskData.m_flags = 0;
+        } else {
+            // workaround; if the controller doesn't cancel the connection at the timeout, cancel it here.
             NIMBLE_LOGE(LOG_TAG, "Connect timeout - cancelling");
             ble_gap_conn_cancel();
             taskData.m_flags = BLE_HS_ETIMEOUT;
@@ -315,19 +288,17 @@ bool NimBLEClient::connect(const NimBLEAddress& address, bool deleteAttributes,
     rc          = taskData.m_flags;
     if (rc != 0) {
         NIMBLE_LOGE(LOG_TAG, "Connection failed; status=%d %s", rc, NimBLEUtils::returnCodeToString(rc));
-        goto error;
+        m_lastErr = rc;
+        if (m_config.deleteOnConnectFail) {
+            NimBLEDevice::deleteClient(this);
+        }
+        return false;
     }
 
+    m_pClientCallbacks->onConnect(this);
     NIMBLE_LOGD(LOG_TAG, "<< connect()");
-    return true;
-
-error:
-    m_connStatus = DISCONNECTED;
-    m_lastErr    = rc;
-    if (m_config.deleteOnConnectFail) {
-        NimBLEDevice::deleteClient(this);
-    }
-    return false;
+    // Check if still connected before returning
+    return isConnected();
 } // connect
 
 /**
@@ -340,11 +311,6 @@ error:
  */
 bool NimBLEClient::secureConnection(bool async) const {
     NIMBLE_LOGD(LOG_TAG, ">> secureConnection()");
-    if (!async && NimBLEUtils::inHostTask()) {
-        NIMBLE_LOGE(LOG_TAG, "Cannot secure connection synchronously from host task");
-        m_lastErr = BLE_HS_EREJECT;
-        return false;
-    }
 
     int rc = 0;
     if (async && !NimBLEDevice::startSecurity(m_connHandle, &rc)) {
@@ -365,7 +331,7 @@ bool NimBLEClient::secureConnection(bool async) const {
         if (NimBLEDevice::startSecurity(m_connHandle)) {
             NimBLEUtils::taskWait(taskData, BLE_NPL_TIME_FOREVER);
         }
-    } while (taskData.m_flags == BLE_HS_HCI_ERR(BLE_ERR_PINKEY_MISSING) && retryCount--);
+    } while (taskData.m_flags == (BLE_HS_ERR_HCI_BASE + BLE_ERR_PINKEY_MISSING) && retryCount--);
 
     m_pTaskData = nullptr;
 
@@ -375,10 +341,7 @@ bool NimBLEClient::secureConnection(bool async) const {
     }
 
     m_lastErr = taskData.m_flags;
-    NIMBLE_LOGE(LOG_TAG,
-                "secureConnection: failed rc=%d %s",
-                taskData.m_flags,
-                NimBLEUtils::returnCodeToString(taskData.m_flags));
+    NIMBLE_LOGE(LOG_TAG, "secureConnection: failed rc=%d", taskData.m_flags);
     return false;
 
 } // secureConnection
@@ -389,19 +352,13 @@ bool NimBLEClient::secureConnection(bool async) const {
  */
 bool NimBLEClient::disconnect(uint8_t reason) {
     int rc = ble_gap_terminate(m_connHandle, reason);
-    switch (rc) {
-        case 0:
-            m_connStatus = DISCONNECTING;
-            return true;
-        case BLE_HS_ENOTCONN:
-        case BLE_HS_EALREADY:
-        case BLE_HS_HCI_ERR(BLE_ERR_UNK_CONN_ID): // should not happen but just in case
-            return true;
+    if (rc != 0 && rc != BLE_HS_ENOTCONN && rc != BLE_HS_EALREADY) {
+        NIMBLE_LOGE(LOG_TAG, "ble_gap_terminate failed: rc=%d %s", rc, NimBLEUtils::returnCodeToString(rc));
+        m_lastErr = rc;
+        return false;
     }
 
-    NIMBLE_LOGE(LOG_TAG, "ble_gap_terminate failed: rc=%d %s", rc, NimBLEUtils::returnCodeToString(rc));
-    m_lastErr = rc;
-    return false;
+    return true;
 } // disconnect
 
 /**
@@ -618,8 +575,8 @@ NimBLEAddress NimBLEClient::getPeerAddress() const {
  * @return True if successful.
  */
 bool NimBLEClient::setPeerAddress(const NimBLEAddress& address) {
-    if (m_connStatus == CONNECTED || m_connStatus == CONNECTING) {
-        NIMBLE_LOGE(LOG_TAG, "Cannot set peer address while connected/connecting");
+    if (isConnected()) {
+        NIMBLE_LOGE(LOG_TAG, "Cannot set peer address while connected");
         return false;
     }
 
@@ -632,7 +589,7 @@ bool NimBLEClient::setPeerAddress(const NimBLEAddress& address) {
  * @return The RSSI value or 0 if there was an error.
  */
 int NimBLEClient::getRssi() const {
-    if (m_connStatus != CONNECTED) {
+    if (!isConnected()) {
         NIMBLE_LOGE(LOG_TAG, "getRssi(): Not connected");
         return 0;
     }
@@ -680,10 +637,6 @@ NimBLERemoteService* NimBLEClient::getService(const char* uuid) {
  */
 NimBLERemoteService* NimBLEClient::getService(const NimBLEUUID& uuid) {
     NIMBLE_LOGD(LOG_TAG, ">> getService: uuid: %s", uuid.toString().c_str());
-    if (NimBLEUtils::inHostTask()) {
-        NIMBLE_LOGE(LOG_TAG, "getService cannot be called from host task");
-        return nullptr;
-    }
 
     for (auto& it : m_svcVec) {
         if (it->getUUID() == uuid) {
@@ -779,7 +732,7 @@ bool NimBLEClient::discoverAttributes() {
  * @return true on success otherwise false if an error occurred
  */
 bool NimBLEClient::retrieveServices(const NimBLEUUID* uuidFilter) {
-    if (m_connStatus != CONNECTED) {
+    if (!isConnected()) {
         NIMBLE_LOGE(LOG_TAG, "Disconnected, could not retrieve services -aborting");
         return false;
     }
@@ -957,7 +910,7 @@ int NimBLEClient::exchangeMTUCb(uint16_t conn_handle, const ble_gatt_error* erro
  */
 bool NimBLEClient::exchangeMTU() {
     int rc = ble_gattc_exchange_mtu(m_connHandle, NimBLEClient::exchangeMTUCb, this);
-    if (rc != 0 && rc != BLE_HS_EALREADY) {
+    if (rc != 0) {
         NIMBLE_LOGE(LOG_TAG, "MTU exchange error; rc=%d %s", rc, NimBLEUtils::returnCodeToString(rc));
         m_lastErr = rc;
         return false;
@@ -966,59 +919,6 @@ bool NimBLEClient::exchangeMTU() {
     return true;
 } // exchangeMTU
 
-void NimBLEClient::startConnectEstablishedTimer(uint16_t connInterval) {
-    // As per Bluetooth spec, the connection is only established after receiving a PDU
-    // within 6 connections events, so we wait for 7 connection events for a margin.
-    uint32_t waitMs = connIntervalToMs(connInterval) * 7;
-    if (waitMs == 0) {
-        waitMs = 1;
-    }
-
-    ble_npl_time_t waitTicks = 1;
-    ble_npl_time_ms_to_ticks(waitMs, &waitTicks);
-    if (waitTicks == 0) {
-        waitTicks = 1;
-    }
-
-    ble_npl_callout_reset(&m_connectEstablishedTimer, waitTicks);
-} // startConnectEstablishedTimer
-
-bool NimBLEClient::completeConnectEstablished() {
-    if (!m_connectCallbackPending) {
-        return false;
-    }
-
-    m_connectCallbackPending = false;
-    ble_npl_callout_stop(&m_connectEstablishedTimer);
-    auto pTaskData = m_pTaskData; // save a copy in case something in the callback changes it
-    m_pTaskData    = nullptr;     // clear before callback to prevent other handlers from releasing
-    m_pClientCallbacks->onConnect(this);
-
-    if (pTaskData != nullptr) {
-        NimBLEUtils::taskRelease(*pTaskData, 0);
-    }
-
-    return true;
-} // completeConnectEstablished
-
-void NimBLEClient::connectEstablishedTimerCb(struct ble_npl_event* event) {
-    auto* pClient = static_cast<NimBLEClient*>(ble_npl_event_get_arg(event));
-    if (pClient == nullptr || pClient->m_connStatus != CONNECTED) {
-        return;
-    }
-
-    pClient->completeConnectEstablished();
-} // connectEstablishedTimerCb
-
-/**
- * @brief Set the number of times to retry connecting after a connection establishment error (0x3e).
- * @param [in] numRetries The number of retries to attempt before giving up and reporting the failure.
- * @details Max is 7, Default is 2.
- */
-void NimBLEClient::setConnectRetries(uint8_t numRetries) {
-    m_config.connectFailRetries = std::min<uint8_t>(numRetries, 7U);
-} // setConnectRetries
-
 /**
  * @brief Handle a received GAP event.
  * @param [in] event The event structure sent by the NimBLE stack.
@@ -1033,23 +933,23 @@ int NimBLEClient::handleGapEvent(struct ble_gap_event* event, void* arg) {
 
     switch (event->type) {
         case BLE_GAP_EVENT_DISCONNECT: {
-            // workaround for bug in NimBLE stack where disconnect event argument is not passed correctly
-            pClient = NimBLEDevice::getClientByHandle(event->disconnect.conn.conn_handle);
-            if (pClient == nullptr) {
-                pClient = NimBLEDevice::getClientByPeerAddress(event->disconnect.conn.peer_ota_addr);
-            }
 
+            // workaround for bug in NimBLE stack where disconnect event argument is not passed correctly
+            pClient = NimBLEDevice::getClientByPeerAddress(event->disconnect.conn.peer_ota_addr);
             if (pClient == nullptr) {
                 pClient = NimBLEDevice::getClientByPeerAddress(event->disconnect.conn.peer_id_addr);
             }
 
+            // try by connection handle
             if (pClient == nullptr) {
-                NIMBLE_LOGE(LOG_TAG, "Disconnected client not found, conn_handle=%d", event->disconnect.conn.conn_handle);
-                return 0;
+                pClient = NimBLEDevice::getClientByHandle(event->disconnect.conn.conn_handle);
             }
 
-            pClient->m_connectCallbackPending = false;
-            ble_npl_callout_stop(&pClient->m_connectEstablishedTimer);
+            if (pClient == nullptr) {
+                NIMBLE_LOGE(LOG_TAG, "Disconnected client not found, conn_handle=%d",
+                            event->disconnect.conn.conn_handle);
+                return 0;
+            }
 
             rc = event->disconnect.reason;
             // If Host reset tell the device now before returning to prevent
@@ -1071,42 +971,20 @@ int NimBLEClient::handleGapEvent(struct ble_gap_event* event, void* arg) {
             pClient->m_terminateFailCount = 0;
             pClient->m_asyncSecureAttempt = 0;
 
-            // set this incase the client instance was changed due to incorrect event arg bug above
-            pTaskData = pClient->m_pTaskData;
-
-            const int connEstablishFailReason = BLE_HS_HCI_ERR(BLE_ERR_CONN_ESTABLISHMENT);
-            if (rc == connEstablishFailReason && pClient->m_connectFailRetryCount < pClient->m_config.connectFailRetries) {
-                pClient->m_connHandle = BLE_HS_CONN_HANDLE_NONE;
-                ++pClient->m_connectFailRetryCount;
-                pClient->m_connStatus = CONNECTING;
-                NIMBLE_LOGW(LOG_TAG,
-                            "Connection establishment failed (0x3e), retry %u/%u",
-                            pClient->m_connectFailRetryCount,
-                            pClient->m_config.connectFailRetries);
-
-                const int retryRc = pClient->startConnectionAttempt(pClient->m_peerAddress.getBase());
-                if (retryRc == 0) {
-                    // A retry attempt is in progress; suppress user callbacks until final outcome.
-                    return 0;
-                }
-
-                NIMBLE_LOGE(LOG_TAG, "Retry connect start failed, rc=%d %s", retryRc, NimBLEUtils::returnCodeToString(retryRc));
-            }
-
-            if (rc == connEstablishFailReason) {
+            // Don't call the disconnect callback if we are waiting for a connection to complete and it fails
+            if (rc == (BLE_HS_ERR_HCI_BASE + BLE_ERR_CONN_ESTABLISHMENT) && pClient->m_config.asyncConnect) {
                 pClient->m_pClientCallbacks->onConnectFail(pClient, rc);
             } else {
                 pClient->m_pClientCallbacks->onDisconnect(pClient, rc);
             }
 
             pClient->m_connHandle = BLE_HS_CONN_HANDLE_NONE;
-            pClient->m_connStatus = DISCONNECTED;
 
-            if (pClient->m_config.deleteOnDisconnect ||
-                (rc == connEstablishFailReason && pClient->m_config.deleteOnConnectFail)) {
+            if (pClient->m_config.deleteOnDisconnect) {
                 // If we are set to self delete on disconnect but we have a task waiting on the connection
                 // completion we will set the flag to delete on connect fail instead of deleting here
-                if (pTaskData != nullptr && rc == connEstablishFailReason) {
+                // to prevent segmentation faults or double deleting
+                if (pTaskData != nullptr && rc == (BLE_HS_ERR_HCI_BASE + BLE_ERR_CONN_ESTABLISHMENT)) {
                     pClient->m_config.deleteOnConnectFail = true;
                     break;
                 }
@@ -1118,7 +996,7 @@ int NimBLEClient::handleGapEvent(struct ble_gap_event* event, void* arg) {
 
         case BLE_GAP_EVENT_CONNECT: {
             // If we aren't waiting for this connection response we should drop the connection immediately.
-            if (pClient->m_connStatus != CONNECTING) {
+            if (pClient->isConnected() || (!pClient->m_config.asyncConnect && pClient->m_pTaskData == nullptr)) {
                 ble_gap_terminate(event->connect.conn_handle, BLE_ERR_REM_USER_CONN_TERM);
                 return 0;
             }
@@ -1129,28 +1007,22 @@ int NimBLEClient::handleGapEvent(struct ble_gap_event* event, void* arg) {
             }
 
             if (rc == 0) {
-                pClient->m_connStatus             = CONNECTED;
-                pClient->m_connHandle             = event->connect.conn_handle;
-                pClient->m_connectCallbackPending = true;
+                pClient->m_connHandle = event->connect.conn_handle;
 
-                ble_gap_conn_desc desc;
-                if (ble_gap_conn_find(event->connect.conn_handle, &desc) == 0) {
-                    pClient->startConnectEstablishedTimer(desc.conn_itvl);
-                } else {
-                    pClient->startConnectEstablishedTimer(pClient->m_connParams.itvl_max);
+                if (pClient->m_config.asyncConnect) {
+                    pClient->m_pClientCallbacks->onConnect(pClient);
                 }
 
                 if (pClient->m_config.exchangeMTU) {
-                    pClient->exchangeMTU();
+                    if (!pClient->exchangeMTU()) {
+                        rc = pClient->m_lastErr; // sets the error in the task data
+                        break;
+                    }
+
+                    return 0; // return as we may have a task waiting for the MTU before releasing it.
                 }
-                // return as we may have a task waiting on the connection completion
-                // and will release it in the timer callback after the connection is fully established.
-                return 0;
             } else {
-                pClient->m_connStatus             = DISCONNECTED;
-                pClient->m_connHandle             = BLE_HS_CONN_HANDLE_NONE;
-                pClient->m_connectCallbackPending = false;
-                ble_npl_callout_stop(&pClient->m_connectEstablishedTimer);
+                pClient->m_connHandle = BLE_HS_CONN_HANDLE_NONE;
 
                 if (pClient->m_config.asyncConnect) {
                     pClient->m_pClientCallbacks->onConnectFail(pClient, rc);
@@ -1178,50 +1050,33 @@ int NimBLEClient::handleGapEvent(struct ble_gap_event* event, void* arg) {
         } // BLE_GAP_EVENT_TERM_FAILURE
 
         case BLE_GAP_EVENT_NOTIFY_RX: {
-            if (pClient->m_connHandle != event->notify_rx.conn_handle) {
-                return 0;
-            }
-
-            if (pClient->completeConnectEstablished()) {
-                pTaskData = nullptr;
-            }
-
+            if (pClient->m_connHandle != event->notify_rx.conn_handle) return 0;
             NIMBLE_LOGD(LOG_TAG, "Notify Received for handle: %d", event->notify_rx.attr_handle);
 
-            NimBLERemoteCharacteristic* pChr = pClient->getCharacteristic(event->notify_rx.attr_handle);
-            if (pChr == nullptr) {
-                NIMBLE_LOGW(LOG_TAG, "unknown handle: %d", event->notify_rx.attr_handle);
-                return BLE_ATT_ERR_INVALID_HANDLE;
-            }
+            for (const auto& svc : pClient->m_svcVec) {
+                // Dont waste cycles searching services without this handle in its range
+                if (svc->getEndHandle() < event->notify_rx.attr_handle) {
+                    continue;
+                }
 
-            auto len = event->notify_rx.om->om_len;
-            if (pChr->m_value.setValue(event->notify_rx.om->om_data, len)) {
-                os_mbuf* next;
-                next = SLIST_NEXT(event->notify_rx.om, om_next);
-                while (next != NULL) {
-                    pChr->m_value.append(next->om_data, next->om_len);
-                    if (pChr->m_value.length() != len + next->om_len) {
-                        rc = BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
+                NIMBLE_LOGD(LOG_TAG,
+                            "checking service %s for handle: %d",
+                            svc->getUUID().toString().c_str(),
+                            event->notify_rx.attr_handle);
+
+                for (const auto& chr : svc->m_vChars) {
+                    if (chr->getHandle() == event->notify_rx.attr_handle) {
+                        NIMBLE_LOGD(LOG_TAG, "Got Notification for characteristic %s", chr->toString().c_str());
+
+                        uint32_t data_len = OS_MBUF_PKTLEN(event->notify_rx.om);
+                        chr->m_value.setValue(event->notify_rx.om->om_data, data_len);
+
+                        if (chr->m_notifyCallback != nullptr) {
+                            chr->m_notifyCallback(chr, event->notify_rx.om->om_data, data_len, !event->notify_rx.indication);
+                        }
                         break;
                     }
-                    len  += next->om_len;
-                    next  = SLIST_NEXT(next, om_next);
                 }
-            } else {
-                rc = BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
-            }
-
-            if (rc != 0) { // This should never happen
-                NIMBLE_LOGE(LOG_TAG, "notification value error; exceeds limit");
-                return rc;
-            }
-
-            if (pChr->m_notifyCallback != nullptr) {
-                // TODO: change this callback to use the NimBLEAttValue class instead of raw data and length
-                pChr->m_notifyCallback(pChr,
-                                       const_cast<uint8_t*>(pChr->m_value.getValue().data()),
-                                       pChr->m_value.length(),
-                                       !event->notify_rx.indication);
             }
 
             return 0;
@@ -1232,11 +1087,6 @@ int NimBLEClient::handleGapEvent(struct ble_gap_event* event, void* arg) {
             if (pClient->m_connHandle != event->conn_update_req.conn_handle) {
                 return 0;
             }
-
-            if (pClient->completeConnectEstablished()) {
-                pTaskData = nullptr;
-            }
-
             NIMBLE_LOGD(LOG_TAG, "Peer requesting to update connection parameters");
             NIMBLE_LOGD(LOG_TAG,
                         "MinInterval: %d, MaxInterval: %d, Latency: %d, Timeout: %d",
@@ -1264,11 +1114,6 @@ int NimBLEClient::handleGapEvent(struct ble_gap_event* event, void* arg) {
             if (pClient->m_connHandle != event->conn_update.conn_handle) {
                 return 0;
             }
-
-            if (pClient->completeConnectEstablished()) {
-                pTaskData = nullptr;
-            }
-
             if (event->conn_update.status == 0) {
                 NIMBLE_LOGI(LOG_TAG, "Connection parameters updated.");
             } else {
@@ -1282,11 +1127,8 @@ int NimBLEClient::handleGapEvent(struct ble_gap_event* event, void* arg) {
                 return 0;
             }
 
-            if (pClient->completeConnectEstablished()) {
-                pTaskData = nullptr;
-            }
-
-            if (event->enc_change.status == 0 || event->enc_change.status == BLE_HS_HCI_ERR(BLE_ERR_PINKEY_MISSING)) {
+            if (event->enc_change.status == 0 ||
+                event->enc_change.status == (BLE_HS_ERR_HCI_BASE + BLE_ERR_PINKEY_MISSING)) {
                 NimBLEConnInfo peerInfo;
                 rc = ble_gap_conn_find(event->enc_change.conn_handle, &peerInfo.m_desc);
                 if (rc != 0) {
@@ -1294,7 +1136,7 @@ int NimBLEClient::handleGapEvent(struct ble_gap_event* event, void* arg) {
                     break;
                 }
 
-                if (event->enc_change.status == BLE_HS_HCI_ERR(BLE_ERR_PINKEY_MISSING)) {
+                if (event->enc_change.status == (BLE_HS_ERR_HCI_BASE + BLE_ERR_PINKEY_MISSING)) {
                     // Key is missing, try deleting.
                     ble_store_util_delete_peer(&peerInfo.m_desc.peer_id_addr);
                     // Attempt a retry if async secure failed.
@@ -1312,14 +1154,6 @@ int NimBLEClient::handleGapEvent(struct ble_gap_event* event, void* arg) {
         } // BLE_GAP_EVENT_ENC_CHANGE
 
         case BLE_GAP_EVENT_IDENTITY_RESOLVED: {
-            if (pClient->m_connHandle != event->identity_resolved.conn_handle) {
-                return 0;
-            }
-
-            if (pClient->completeConnectEstablished()) {
-                pTaskData = nullptr;
-            }
-
             NimBLEConnInfo peerInfo;
             rc = ble_gap_conn_find(event->identity_resolved.conn_handle, &peerInfo.m_desc);
             if (rc != 0) {
@@ -1332,14 +1166,6 @@ int NimBLEClient::handleGapEvent(struct ble_gap_event* event, void* arg) {
         } // BLE_GAP_EVENT_IDENTITY_RESOLVED
 
         case BLE_GAP_EVENT_PHY_UPDATE_COMPLETE: {
-            if (pClient->m_connHandle != event->phy_updated.conn_handle) {
-                return 0;
-            }
-
-            if (pClient->completeConnectEstablished()) {
-                pTaskData = nullptr;
-            }
-
             NimBLEConnInfo peerInfo;
             rc = ble_gap_conn_find(event->phy_updated.conn_handle, &peerInfo.m_desc);
             if (rc != 0) {
@@ -1355,10 +1181,6 @@ int NimBLEClient::handleGapEvent(struct ble_gap_event* event, void* arg) {
                 return 0;
             }
 
-            if (pClient->completeConnectEstablished()) {
-                pTaskData = nullptr;
-            }
-
             NIMBLE_LOGI(LOG_TAG, "mtu update: mtu=%d", event->mtu.value);
             pClient->m_pClientCallbacks->onMTUChange(pClient, event->mtu.value);
             rc = 0;
@@ -1370,10 +1192,6 @@ int NimBLEClient::handleGapEvent(struct ble_gap_event* event, void* arg) {
                 return 0;
             }
 
-            if (pClient->completeConnectEstablished()) {
-                pTaskData = nullptr;
-            }
-
             NimBLEConnInfo peerInfo;
             rc = ble_gap_conn_find(event->passkey.conn_handle, &peerInfo.m_desc);
             if (rc != 0) {
@@ -1381,16 +1199,7 @@ int NimBLEClient::handleGapEvent(struct ble_gap_event* event, void* arg) {
                 break;
             }
 
-            if (event->passkey.params.action == BLE_SM_IOACT_DISP) {
-                struct ble_sm_io pkey = {0, 0};
-                pkey.action           = event->passkey.params.action;
-                pkey.passkey          = NimBLEDevice::getSecurityPasskey();
-                if (pkey.passkey == 123456) {
-                    pkey.passkey = pClient->m_pClientCallbacks->onPassKeyDisplay(peerInfo);
-                }
-                rc = ble_sm_inject_io(event->passkey.conn_handle, &pkey);
-                NIMBLE_LOGD(LOG_TAG, "BLE_SM_IOACT_DISP; ble_sm_inject_io result: %d", rc);
-            } else if (event->passkey.params.action == BLE_SM_IOACT_NUMCMP) {
+            if (event->passkey.params.action == BLE_SM_IOACT_NUMCMP) {
                 NIMBLE_LOGD(LOG_TAG, "Passkey on device's display: %" PRIu32, event->passkey.params.numcmp);
                 pClient->m_pClientCallbacks->onConfirmPasskey(peerInfo, event->passkey.params.numcmp);
             } else if (event->passkey.params.action == BLE_SM_IOACT_OOB) {
@@ -1429,7 +1238,7 @@ int NimBLEClient::handleGapEvent(struct ble_gap_event* event, void* arg) {
  * @return True if we are connected and false if we are not connected.
  */
 bool NimBLEClient::isConnected() const {
-    return m_connStatus == CONNECTED;
+    return m_connHandle != BLE_HS_CONN_HANDLE_NONE;
 } // isConnected
 
 /**
@@ -1494,11 +1303,6 @@ void NimBLEClientCallbacks::onPassKeyEntry(NimBLEConnInfo& connInfo) {
     NimBLEDevice::injectPassKey(connInfo, 123456);
 } // onPassKeyEntry
 
-uint32_t NimBLEClientCallbacks::onPassKeyDisplay(NimBLEConnInfo& connInfo) {
-    NIMBLE_LOGD(CB_TAG, "onPassKeyDisplay: default");
-    return NimBLEDevice::getSecurityPasskey();
-} // onPassKeyDisplay
-
 void NimBLEClientCallbacks::onAuthenticationComplete(NimBLEConnInfo& connInfo) {
     NIMBLE_LOGD(CB_TAG, "onAuthenticationComplete: default");
 } // onAuthenticationComplete
@@ -1519,5 +1323,6 @@ void NimBLEClientCallbacks::onMTUChange(NimBLEClient* pClient, uint16_t mtu) {
 void NimBLEClientCallbacks::onPhyUpdate(NimBLEClient* pClient, uint8_t txPhy, uint8_t rxPhy) {
     NIMBLE_LOGD(CB_TAG, "onPhyUpdate: default, txPhy: %d, rxPhy: %d", txPhy, rxPhy);
 } // onPhyUpdate
+#
 
 #endif // CONFIG_BT_NIMBLE_ENABLED && MYNEWT_VAL(BLE_ROLE_CENTRAL)

src/NimBLEClient.h

@@ -58,7 +58,6 @@ class NimBLEClient {
     bool           connect(bool deleteAttributes = true, bool asyncConnect = false, bool exchangeMTU = true);
     bool           disconnect(uint8_t reason = BLE_ERR_REM_USER_CONN_TERM);
     bool           cancelConnect() const;
-    void           setConnectRetries(uint8_t numRetries);
     void           setSelfDelete(bool deleteOnDisconnect, bool deleteOnConnectFail);
     NimBLEAddress  getPeerAddress() const;
     bool           setPeerAddress(const NimBLEAddress& address);
@@ -108,49 +107,24 @@ class NimBLEClient {
         uint8_t deleteOnConnectFail : 1; // Delete the client when a connection attempt fails.
         uint8_t asyncConnect : 1;        // Connect asynchronously.
         uint8_t exchangeMTU : 1;         // Exchange MTU after connection.
-        uint8_t connectFailRetries : 3;  // Number of retries for 0x3e (connection establishment) failures.
-
-        /**
-         * @brief Construct a new Config object with default values.
-         * @details Default values are:
-         * - deleteCallbacks: false
-         * - deleteOnDisconnect: false
-         * - deleteOnConnectFail: false
-         * - asyncConnect: false
-         * - exchangeMTU: true
-         * - connectFailRetries: 2 
-         */
-        Config()
-            : deleteCallbacks(0),
-              deleteOnDisconnect(0),
-              deleteOnConnectFail(0),
-              asyncConnect(0),
-              exchangeMTU(1),
-              connectFailRetries(2) {}
     };
 
     Config getConfig() const;
     void   setConfig(Config config);
 
   private:
-    enum ConnStatus : uint8_t { CONNECTED, DISCONNECTED, CONNECTING, DISCONNECTING };
-
     NimBLEClient(const NimBLEAddress& peerAddress);
     ~NimBLEClient();
     NimBLEClient(const NimBLEClient&)            = delete;
     NimBLEClient& operator=(const NimBLEClient&) = delete;
 
-    bool        retrieveServices(const NimBLEUUID* uuidFilter = nullptr);
-    int         startConnectionAttempt(const ble_addr_t* peerAddr);
-    static int  handleGapEvent(struct ble_gap_event* event, void* arg);
-    static void connectEstablishedTimerCb(struct ble_npl_event* event);
-    void        startConnectEstablishedTimer(uint16_t connInterval);
-    bool        completeConnectEstablished();
-    static int  exchangeMTUCb(uint16_t conn_handle, const ble_gatt_error* error, uint16_t mtu, void* arg);
-    static int  serviceDiscoveredCB(uint16_t                     connHandle,
-                                    const struct ble_gatt_error* error,
-                                    const struct ble_gatt_svc*   service,
-                                    void*                        arg);
+    bool       retrieveServices(const NimBLEUUID* uuidFilter = nullptr);
+    static int handleGapEvent(struct ble_gap_event* event, void* arg);
+    static int exchangeMTUCb(uint16_t conn_handle, const ble_gatt_error* error, uint16_t mtu, void* arg);
+    static int serviceDiscoveredCB(uint16_t                     connHandle,
+                                   const struct ble_gatt_error* error,
+                                   const struct ble_gatt_svc*   service,
+                                   void*                        arg);
 
     NimBLEAddress                     m_peerAddress;
     mutable int                       m_lastErr;
@@ -162,10 +136,6 @@ class NimBLEClient {
     uint8_t                           m_terminateFailCount;
     mutable uint8_t                   m_asyncSecureAttempt;
     Config                            m_config;
-    ConnStatus                        m_connStatus;
-    ble_npl_callout                   m_connectEstablishedTimer{};
-    bool                              m_connectCallbackPending;
-    uint8_t                           m_connectFailRetryCount;
 
 # if MYNEWT_VAL(BLE_EXT_ADV)
     uint8_t m_phyMask;
@@ -217,13 +187,6 @@ class NimBLEClientCallbacks {
      */
     virtual void onPassKeyEntry(NimBLEConnInfo& connInfo);
 
-    /**
-     * @brief Called when using passkey entry pairing and the passkey should be displayed.
-     * @param [in] connInfo A reference to a NimBLEConnInfo instance containing the peer info.
-     * @return The passkey to display to the user. The peer device must enter this passkey to complete the pairing.
-     */
-    virtual uint32_t onPassKeyDisplay(NimBLEConnInfo& connInfo);
-
     /**
      * @brief Called when the pairing procedure is complete.
      * @param [in] connInfo A reference to a NimBLEConnInfo instance containing the peer info.\n

src/NimBLEConnInfo.h

@@ -25,7 +25,6 @@
 #endif
 
 #include "NimBLEAddress.h"
-#include <cstdio>
 
 /**
  * @brief Connection information.
@@ -71,41 +70,6 @@ class NimBLEConnInfo {
     /** @brief Gets the key size used to encrypt the connection */
     uint8_t getSecKeySize() const { return m_desc.sec_state.key_size; }
 
-    /** @brief Get a string representation of the connection info, useful for debugging */
-    std::string toString() const {
-        std::string str;
-        // 294 chars max expected from all labels + worst-case values, round up to 300.
-        str.resize(300);
-
-        snprintf(&str[0],
-                 str.size(),
-                 "  Address: %s\n"
-                 "  ID Address: %s\n"
-                 "  Connection Handle: %u\n"
-                 "  Connection Interval: %.1f ms\n"
-                 "  Connection Timeout: %u ms\n"
-                 "  Connection Latency: %u\n"
-                 "  MTU: %u bytes\n"
-                 "  Role: %s\n"
-                 "  Bonded: %s\n"
-                 "  Encrypted: %s\n"
-                 "  Authenticated: %s\n"
-                 "  Security Key Size: %u\n",
-                 getAddress().toString().c_str(),
-                 getIdAddress().toString().c_str(),
-                 getConnHandle(),
-                 getConnInterval() * 1.25f,
-                 getConnTimeout() * 10,
-                 getConnLatency(),
-                 getMTU(),
-                 isMaster() ? "Master" : "Slave",
-                 isBonded() ? "Yes" : "No",
-                 isEncrypted() ? "Yes" : "No",
-                 isAuthenticated() ? "Yes" : "No",
-                 getSecKeySize());
-        return str;
-    }
-
   private:
     friend class NimBLEServer;
     friend class NimBLEClient;

src/NimBLECppVersion.h

@@ -1,80 +0,0 @@
-/*
- * Copyright 2020-2025 Ryan Powell <ryan@nable-embedded.io> and
- * esp-nimble-cpp, NimBLE-Arduino contributors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef NIMBLE_CPP_VERSION_H_
-#define NIMBLE_CPP_VERSION_H_
-
-/** @brief NimBLE-Arduino library major version number. */
-#define NIMBLE_CPP_VERSION_MAJOR 2
-
-/** @brief NimBLE-Arduino library minor version number. */
-#define NIMBLE_CPP_VERSION_MINOR 3
-
-/** @brief NimBLE-Arduino library patch version number. */
-#define NIMBLE_CPP_VERSION_PATCH 9
-
-/**
- * @brief Macro to create a version number for comparison.
- * @param major Major version number.
- * @param minor Minor version number.
- * @param patch Patch version number.
- * @details Example usage:
- * @code{.cpp}
- * #if NIMBLE_CPP_VERSION >= NIMBLE_CPP_VERSION_VAL(2, 0, 0)
- *   // Using NimBLE-Arduino v2 or later
- * #endif
- * @endcode
- */
-#define NIMBLE_CPP_VERSION_VAL(major, minor, patch) (((major) << 16) | ((minor) << 8) | (patch))
-
-/**
- * @brief The library version as a single integer for compile-time comparison.
- * @details Format: (major << 16) | (minor << 8) | patch
- */
-#define NIMBLE_CPP_VERSION \
-    NIMBLE_CPP_VERSION_VAL(NIMBLE_CPP_VERSION_MAJOR, NIMBLE_CPP_VERSION_MINOR, NIMBLE_CPP_VERSION_PATCH)
-
-/** @cond NIMBLE_CPP_INTERNAL */
-#define NIMBLE_CPP_VERSION_STRINGIFY_IMPL(x) #x
-#define NIMBLE_CPP_VERSION_STRINGIFY(x)      NIMBLE_CPP_VERSION_STRINGIFY_IMPL(x)
-/** @endcond */
-
-/**
- * @brief Optional Semantic Versioning prerelease suffix.
- * @details Include the leading '-' when defined, for example: "-beta.1"
- */
-#ifndef NIMBLE_CPP_VERSION_PRERELEASE
-# define NIMBLE_CPP_VERSION_PRERELEASE ""
-#endif
-
-/**
- * @brief Optional Semantic Versioning build metadata suffix.
- * @details Include the leading '+' when defined, for example: "+sha.abcd1234"
- */
-#ifndef NIMBLE_CPP_VERSION_BUILD_METADATA
-# define NIMBLE_CPP_VERSION_BUILD_METADATA ""
-#endif
-
-/** @brief library version as a prefixed Semantic Versioning string. */
-#define NIMBLE_CPP_VERSION_STR                         \
-    "NimBLE-CPP " \
-    NIMBLE_CPP_VERSION_STRINGIFY(NIMBLE_CPP_VERSION_MAJOR) "." \
-    NIMBLE_CPP_VERSION_STRINGIFY(NIMBLE_CPP_VERSION_MINOR) "." \
-    NIMBLE_CPP_VERSION_STRINGIFY(NIMBLE_CPP_VERSION_PATCH) \
-    NIMBLE_CPP_VERSION_PRERELEASE NIMBLE_CPP_VERSION_BUILD_METADATA
-
-#endif // NIMBLE_CPP_VERSION_H_

src/NimBLEDevice.cpp

@@ -98,11 +98,15 @@ ble_gap_event_listener     NimBLEDevice::m_listener{};
 std::vector<NimBLEAddress> NimBLEDevice::m_whiteList{};
 uint8_t                    NimBLEDevice::m_ownAddrType{BLE_OWN_ADDR_PUBLIC};
 
-# if NIMBLE_CPP_SCAN_DUPL_ENABLED
-uint16_t NimBLEDevice::m_scanDuplicateSize{100};
-uint8_t  NimBLEDevice::m_scanFilterMode{0};
+# ifdef ESP_PLATFORM
+#  if CONFIG_BTDM_BLE_SCAN_DUPL
+uint16_t NimBLEDevice::m_scanDuplicateSize{CONFIG_BTDM_SCAN_DUPL_CACHE_SIZE};
+uint8_t  NimBLEDevice::m_scanFilterMode{CONFIG_BTDM_SCAN_DUPL_TYPE};
 uint16_t NimBLEDevice::m_scanDuplicateResetTime{0};
-#  if SOC_ESP_NIMBLE_CONTROLLER
+#  elif CONFIG_BT_LE_SCAN_DUPL
+uint16_t       NimBLEDevice::m_scanDuplicateSize{CONFIG_BT_LE_LL_DUP_SCAN_LIST_COUNT};
+uint8_t        NimBLEDevice::m_scanFilterMode{CONFIG_BT_LE_SCAN_DUPL_TYPE};
+uint16_t       NimBLEDevice::m_scanDuplicateResetTime{0};
 extern "C" int ble_vhci_disc_duplicate_set_max_cache_size(int max_cache_size);
 extern "C" int ble_vhci_disc_duplicate_set_period_refresh_time(int refresh_period_time);
 extern "C" int ble_vhci_disc_duplicate_mode_disable(int mode);
@@ -122,6 +126,9 @@ extern "C" int ble_vhci_disc_duplicate_mode_enable(int mode);
 NimBLEServer* NimBLEDevice::createServer() {
     if (NimBLEDevice::m_pServer == nullptr) {
         NimBLEDevice::m_pServer = new NimBLEServer();
+        ble_gatts_reset();
+        ble_svc_gap_init();
+        ble_svc_gatt_init();
     }
 
     return m_pServer;
@@ -359,12 +366,12 @@ bool NimBLEDevice::deleteClient(NimBLEClient* pClient) {
 
     for (auto& clt : m_pClients) {
         if (clt == pClient) {
-            if (clt->m_connStatus == NimBLEClient::CONNECTED || clt->m_connStatus == NimBLEClient::DISCONNECTING) {
+            if (clt->isConnected()) {
                 clt->m_config.deleteOnDisconnect = true;
                 if (!clt->disconnect()) {
                     break;
                 }
-            } else if (pClient->m_connStatus == NimBLEClient::CONNECTING) {
+            } else if (pClient->m_pTaskData != nullptr) {
                 clt->m_config.deleteOnConnectFail = true;
                 if (!clt->cancelConnect()) {
                     break;
@@ -432,7 +439,7 @@ NimBLEClient* NimBLEDevice::getClientByPeerAddress(const NimBLEAddress& addr) {
  */
 NimBLEClient* NimBLEDevice::getDisconnectedClient() {
     for (const auto clt : m_pClients) {
-        if (clt != nullptr && clt->m_connStatus == NimBLEClient::DISCONNECTED) {
+        if (clt != nullptr && !clt->isConnected()) {
             return clt;
         }
     }
@@ -611,7 +618,6 @@ uint16_t NimBLEDevice::getMTU() {
  * @brief Gets the number of bonded peers stored
  */
 int NimBLEDevice::getNumBonds() {
-#  if MYNEWT_VAL(BLE_STORE_MAX_BONDS)
     ble_addr_t peer_id_addrs[MYNEWT_VAL(BLE_STORE_MAX_BONDS)];
     int        num_peers, rc;
     rc = ble_store_util_bonded_peers(&peer_id_addrs[0], &num_peers, MYNEWT_VAL(BLE_STORE_MAX_BONDS));
@@ -620,9 +626,6 @@ int NimBLEDevice::getNumBonds() {
     }
 
     return num_peers;
-#  else
-    return 0;
-#  endif
 }
 
 /**
@@ -630,13 +633,10 @@ int NimBLEDevice::getNumBonds() {
  * @returns True on success.
  */
 bool NimBLEDevice::deleteAllBonds() {
-    int numBonds = NimBLEDevice::getNumBonds();
-    for (int i = numBonds - 1; i >= 0; i--) {
-        auto addr = NimBLEDevice::getBondedAddress(i);
-        if (!NimBLEDevice::deleteBond(addr)) {
-            NIMBLE_LOGE(LOG_TAG, "Failed to delete bond for address: %s", addr.toString().c_str());
-            return false;
-        }
+    int rc = ble_store_clear();
+    if (rc != 0) {
+        NIMBLE_LOGE(LOG_TAG, "Failed to delete all bonds; rc=%d", rc);
+        return false;
     }
     return true;
 }
@@ -656,7 +656,6 @@ bool NimBLEDevice::deleteBond(const NimBLEAddress& address) {
  * @returns True if bonded.
  */
 bool NimBLEDevice::isBonded(const NimBLEAddress& address) {
-#  if MYNEWT_VAL(BLE_STORE_MAX_BONDS)
     ble_addr_t peer_id_addrs[MYNEWT_VAL(BLE_STORE_MAX_BONDS)];
     int        num_peers, rc;
 
@@ -671,8 +670,7 @@ bool NimBLEDevice::isBonded(const NimBLEAddress& address) {
             return true;
         }
     }
-#  endif
-    (void)address; // unused
+
     return false;
 }
 
@@ -682,19 +680,14 @@ bool NimBLEDevice::isBonded(const NimBLEAddress& address) {
  * @returns NimBLEAddress of the found bonded peer or null address if not found.
  */
 NimBLEAddress NimBLEDevice::getBondedAddress(int index) {
-#  if MYNEWT_VAL(BLE_STORE_MAX_BONDS)
     ble_addr_t peer_id_addrs[MYNEWT_VAL(BLE_STORE_MAX_BONDS)];
     int        num_peers, rc;
     rc = ble_store_util_bonded_peers(&peer_id_addrs[0], &num_peers, MYNEWT_VAL(BLE_STORE_MAX_BONDS));
-    if (rc != 0 || index >= num_peers || index < 0) {
+    if (rc != 0 || index > num_peers || index < 0) {
         return NimBLEAddress{};
     }
 
     return NimBLEAddress(peer_id_addrs[index]);
-#  else
-    (void)index; // unused
-    return NimBLEAddress{};
-#  endif
 }
 # endif
 
@@ -773,7 +766,7 @@ size_t NimBLEDevice::getWhiteListCount() {
  * @returns The NimBLEAddress at the whitelist index or null address if not found.
  */
 NimBLEAddress NimBLEDevice::getWhiteListAddress(size_t index) {
-    if (index >= m_whiteList.size()) {
+    if (index > m_whiteList.size()) {
         NIMBLE_LOGE(LOG_TAG, "Invalid index; %u", index);
         return NimBLEAddress{};
     }
@@ -875,8 +868,7 @@ void NimBLEDevice::onSync(void) {
  * @brief The main host task.
  */
 void NimBLEDevice::host_task(void* param) {
-    NIMBLE_LOGI(LOG_TAG, "NimBLE Started!");
-    NimBLEUtils::m_hostTaskHandle = ble_npl_get_current_task_id();
+    NIMBLE_LOGI(LOG_TAG, "BLE Host Task Started");
     nimble_port_run(); // This function will return only when nimble_port_stop() is executed
     nimble_port_freertos_deinit();
 } // host_task
@@ -887,7 +879,6 @@ void NimBLEDevice::host_task(void* param) {
  */
 bool NimBLEDevice::init(const std::string& deviceName) {
     if (!m_initialized) {
-        NIMBLE_LOGD(LOG_TAG, "Starting %s", getVersion());
 # ifdef ESP_PLATFORM
 
 #  if defined(CONFIG_ENABLE_ARDUINO_DEPENDS) && SOC_BT_SUPPORTED
@@ -918,31 +909,28 @@ bool NimBLEDevice::init(const std::string& deviceName) {
         bt_cfg.mode         = ESP_BT_MODE_BLE;
         bt_cfg.ble_max_conn = MYNEWT_VAL(BLE_MAX_CONNECTIONS);
 #   elif defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S3)
-        bt_cfg.ble_max_act =
-            MYNEWT_VAL(BLE_MAX_CONNECTIONS) + MYNEWT_VAL(BLE_ROLE_BROADCASTER) + MYNEWT_VAL(BLE_ROLE_OBSERVER);
+        bt_cfg.ble_max_act = MYNEWT_VAL(BLE_MAX_CONNECTIONS) + MYNEWT_VAL(BLE_ROLE_BROADCASTER) + MYNEWT_VAL(BLE_ROLE_OBSERVER);
 #   else
         bt_cfg.nimble_max_connections = MYNEWT_VAL(BLE_MAX_CONNECTIONS);
 #   endif
 
-#   if NIMBLE_CPP_SCAN_DUPL_ENABLED
-#    if !SOC_ESP_NIMBLE_CONTROLLER
+#   if CONFIG_BTDM_BLE_SCAN_DUPL
         bt_cfg.normal_adv_size     = m_scanDuplicateSize;
         bt_cfg.scan_duplicate_type = m_scanFilterMode;
-        bt_cfg.scan_duplicate_mode = 0; // Ensure normal filter mode, could be set to mesh in default config
-#     if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
+#    if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
         bt_cfg.dup_list_refresh_period = m_scanDuplicateResetTime;
-#     endif
-#    else  // SOC_ESP_NIMBLE_CONTROLLER
+#    endif
+#   elif CONFIG_BT_LE_SCAN_DUPL
         bt_cfg.ble_ll_rsp_dup_list_count = m_scanDuplicateSize;
         bt_cfg.ble_ll_adv_dup_list_count = m_scanDuplicateSize;
-#    endif // SOC_ESP_NIMBLE_CONTROLLER
+#   endif
         err = esp_bt_controller_init(&bt_cfg);
         if (err != ESP_OK) {
             NIMBLE_LOGE(LOG_TAG, "esp_bt_controller_init() failed; err=%d", err);
             return false;
         }
 
-#    if SOC_ESP_NIMBLE_CONTROLLER
+#   if CONFIG_BT_LE_SCAN_DUPL
         int mode = (1UL << 4); // FILTER_DUPLICATE_EXCEPTION_FOR_MESH
         switch (m_scanFilterMode) {
             case 1:
@@ -952,15 +940,14 @@ bool NimBLEDevice::init(const std::string& deviceName) {
                 mode |= ((1UL << 2) | (1UL << 3)); // FILTER_DUPLICATE_ADDRESS | FILTER_DUPLICATE_ADVDATA
                 break;
             default:
-                mode |= ((1UL << 0) | (1UL << 2)); // FILTER_DUPLICATE_PDUTYPE | FILTER_DUPLICATE_ADDRESS
+                mode |= (1UL << 0) | (1UL << 2); // FILTER_DUPLICATE_PDUTYPE | FILTER_DUPLICATE_ADDRESS
         }
 
         ble_vhci_disc_duplicate_mode_disable(0xFFFFFFFF);
         ble_vhci_disc_duplicate_mode_enable(mode);
         ble_vhci_disc_duplicate_set_max_cache_size(m_scanDuplicateSize);
         ble_vhci_disc_duplicate_set_period_refresh_time(m_scanDuplicateResetTime);
-#    endif // SOC_ESP_NIMBLE_CONTROLLER
-#   endif  // NIMBLE_CPP_SCAN_DUPL_ENABLED
+#   endif
 
         err = esp_bt_controller_enable(ESP_BT_MODE_BLE);
         if (err != ESP_OK) {
@@ -1009,7 +996,6 @@ bool NimBLEDevice::init(const std::string& deviceName) {
     }
 
     m_initialized = true; // Set the initialization flag to ensure we are only initialized once.
-    NIMBLE_LOGD(LOG_TAG, "Initialized");
     return true;
 } // init
 
@@ -1276,17 +1262,10 @@ bool NimBLEDevice::startSecurity(uint16_t connHandle, int* rcPtr) {
  * @return true if the passkey was injected successfully.
  */
 bool NimBLEDevice::injectPassKey(const NimBLEConnInfo& peerInfo, uint32_t passkey) {
-#  if MYNEWT_VAL(BLE_SM_LEGACY)
     ble_sm_io pkey{.action = BLE_SM_IOACT_INPUT, .passkey = passkey};
     int       rc = ble_sm_inject_io(peerInfo.getConnHandle(), &pkey);
     NIMBLE_LOGD(LOG_TAG, "BLE_SM_IOACT_INPUT; ble_sm_inject_io result: %d", rc);
     return rc == 0;
-#  else
-    (void)peerInfo;
-    (void)passkey;
-    NIMBLE_LOGE(LOG_TAG, "Passkey entry not supported with current security settings");
-    return false;
-#  endif
 }
 
 /**
@@ -1295,17 +1274,10 @@ bool NimBLEDevice::injectPassKey(const NimBLEConnInfo& peerInfo, uint32_t passke
  * @param [in] accept Whether the user confirmed or declined the comparison.
  */
 bool NimBLEDevice::injectConfirmPasskey(const NimBLEConnInfo& peerInfo, bool accept) {
-#  if MYNEWT_VAL(BLE_SM_SC)
     ble_sm_io pkey{.action = BLE_SM_IOACT_NUMCMP, .numcmp_accept = accept};
     int       rc = ble_sm_inject_io(peerInfo.getConnHandle(), &pkey);
     NIMBLE_LOGD(LOG_TAG, "BLE_SM_IOACT_NUMCMP; ble_sm_inject_io result: %d", rc);
     return rc == 0;
-#  else
-    (void)peerInfo;
-    (void)accept;
-    NIMBLE_LOGE(LOG_TAG, "Numeric comparison not supported with current security settings");
-    return false;
-#  endif
 }
 # endif // MYNEWT_VAL(BLE_ROLE_CENTRAL) || MYNEWT_VAL(BLE_ROLE_PERIPHERAL)
 
@@ -1318,13 +1290,13 @@ bool NimBLEDevice::injectConfirmPasskey(const NimBLEConnInfo& peerInfo, bool acc
  * @param [in] deviceName The name to set.
  */
 bool NimBLEDevice::setDeviceName(const std::string& deviceName) {
-# if !defined(MYNEWT_VAL_BLE_GATTS) || MYNEWT_VAL(BLE_GATTS) > 0
+#if !defined(MYNEWT_VAL_BLE_GATTS) || MYNEWT_VAL(BLE_GATTS) > 0
     int rc = ble_svc_gap_device_name_set(deviceName.c_str());
     if (rc != 0) {
         NIMBLE_LOGE(LOG_TAG, "Device name not set - too long");
         return false;
     }
-# endif
+#endif
     return true;
 } // setDeviceName
 
@@ -1354,14 +1326,6 @@ std::string NimBLEDevice::toString() {
     return getAddress().toString();
 } // toString
 
-/**
- * @brief Return the library version as a string.
- * @return A const char* containing library version information.
- */
-const char* NimBLEDevice::getVersion() {
-    return NIMBLE_CPP_VERSION_STR;
-} // getVersion
-
 # if MYNEWT_VAL(NIMBLE_CPP_DEBUG_ASSERT_ENABLED) || __DOXYGEN__
 /**
  * @brief Debug assert - weak function.

src/NimBLEDevice.h

@@ -18,15 +18,12 @@
 #ifndef NIMBLE_CPP_DEVICE_H_
 #define NIMBLE_CPP_DEVICE_H_
 
-#include "NimBLECppVersion.h"
 #include "syscfg/syscfg.h"
 #if CONFIG_BT_NIMBLE_ENABLED
 # ifdef ESP_PLATFORM
 #  ifndef CONFIG_IDF_TARGET_ESP32P4
 #   include <esp_bt.h>
 #  endif
-#  define NIMBLE_CPP_SCAN_DUPL_ENABLED \
-      (CONFIG_BTDM_BLE_SCAN_DUPL || CONFIG_BT_LE_SCAN_DUPL || CONFIG_BT_CTRL_BLE_SCAN_DUPL)
 # endif
 
 # if defined(CONFIG_NIMBLE_CPP_IDF)
@@ -124,7 +121,6 @@ class NimBLEDevice {
     static bool          isInitialized();
     static NimBLEAddress getAddress();
     static std::string   toString();
-    static const char*   getVersion();
     static bool          whiteListAdd(const NimBLEAddress& address);
     static bool          whiteListRemove(const NimBLEAddress& address);
     static bool          onWhiteList(const NimBLEAddress& address);
@@ -247,7 +243,7 @@ class NimBLEDevice {
 # endif
 
 # ifdef ESP_PLATFORM
-#  if NIMBLE_CPP_SCAN_DUPL_ENABLED
+#  if CONFIG_BTDM_BLE_SCAN_DUPL || CONFIG_BT_LE_SCAN_DUPL
     static uint16_t m_scanDuplicateSize;
     static uint8_t  m_scanFilterMode;
     static uint16_t m_scanDuplicateResetTime;
@@ -308,7 +304,6 @@ class NimBLEDevice {
 
 # if MYNEWT_VAL(BLE_ROLE_CENTRAL) || MYNEWT_VAL(BLE_ROLE_PERIPHERAL)
 #  include "NimBLEConnInfo.h"
-#  include "NimBLEStream.h"
 # endif
 
 # include "NimBLEAddress.h"

src/NimBLEHIDDevice.cpp

@@ -84,7 +84,9 @@ void NimBLEHIDDevice::setReportMap(uint8_t* map, uint16_t size) {
  * This function called when all the services have been created.
  */
 void NimBLEHIDDevice::startServices() {
-    // no-op now, services started by server start.
+    m_deviceInfoSvc->start();
+    m_hidSvc->start();
+    m_batterySvc->start();
 } // startServices
 
 /**

src/NimBLEHIDDevice.h

@@ -49,8 +49,7 @@ class NimBLEHIDDevice {
     NimBLEHIDDevice(NimBLEServer* server);
 
     void                  setReportMap(uint8_t* map, uint16_t);
-    void                  startServices() __attribute__((deprecated("Services are now started by the server when start() is called, " 
-                                                         "this function is no longer needed and will be removed in a future release.")));
+    void                  startServices();
     bool                  setManufacturer(const std::string& name);
     void                  setPnp(uint8_t sig, uint16_t vid, uint16_t pid, uint16_t version);
     void                  setHidInfo(uint8_t country, uint8_t flags);

src/NimBLERemoteCharacteristic.cpp

@@ -155,11 +155,6 @@ bool NimBLERemoteCharacteristic::retrieveDescriptors(NimBLEDescriptorFilter* pFi
  */
 NimBLERemoteDescriptor* NimBLERemoteCharacteristic::getDescriptor(const NimBLEUUID& uuid) const {
     NIMBLE_LOGD(LOG_TAG, ">> getDescriptor: uuid: %s", uuid.toString().c_str());
-    if (NimBLEUtils::inHostTask()) {
-        NIMBLE_LOGE(LOG_TAG, "getDescriptor cannot be called from host task");
-        return nullptr;
-    }
-
     NimBLEUUID             uuidTmp{uuid};
     NimBLETaskData         taskData(const_cast<NimBLERemoteCharacteristic*>(this));
     NimBLEDescriptorFilter filter{nullptr, &uuidTmp, &taskData};

src/NimBLERemoteService.cpp

@@ -75,28 +75,32 @@ NimBLERemoteCharacteristic* NimBLERemoteService::getCharacteristic(const char* u
  */
 NimBLERemoteCharacteristic* NimBLERemoteService::getCharacteristic(const NimBLEUUID& uuid) const {
     NIMBLE_LOGD(LOG_TAG, ">> getCharacteristic: uuid: %s", uuid.toString().c_str());
-    if (NimBLEUtils::inHostTask()) {
-        NIMBLE_LOGE(LOG_TAG, "getCharacteristic cannot be called from host task");
-        return nullptr;
-    }
-
     NimBLERemoteCharacteristic* pChar     = nullptr;
+    size_t                      prev_size = m_vChars.size();
 
     for (const auto& it : m_vChars) {
         if (it->getUUID() == uuid) {
             pChar = it;
-            NIMBLE_LOGD(LOG_TAG, "<< getCharacteristic: found in cache");
-            return pChar;
+            goto Done;
         }
     }
 
-    if (retrieveCharacteristics(&uuid, &pChar) && pChar == nullptr) {
+    if (retrieveCharacteristics(&uuid)) {
+        if (m_vChars.size() > prev_size) {
+            pChar = m_vChars.back();
+            goto Done;
+        }
+
         // If the request was successful but 16/32 bit uuid not found
         // try again with the 128 bit uuid.
         if (uuid.bitSize() == BLE_UUID_TYPE_16 || uuid.bitSize() == BLE_UUID_TYPE_32) {
             NimBLEUUID uuid128(uuid);
             uuid128.to128();
-            retrieveCharacteristics(&uuid128, &pChar);
+            if (retrieveCharacteristics(&uuid128)) {
+                if (m_vChars.size() > prev_size) {
+                    pChar = m_vChars.back();
+                }
+            }
         } else {
             // If the request was successful but the 128 bit uuid not found
             // try again with the 16 bit uuid.
@@ -104,11 +108,16 @@ NimBLERemoteCharacteristic* NimBLERemoteService::getCharacteristic(const NimBLEU
             uuid16.to16();
             // if the uuid was 128 bit but not of the BLE base type this check will fail
             if (uuid16.bitSize() == BLE_UUID_TYPE_16) {
-                retrieveCharacteristics(&uuid16, &pChar);
+                if (retrieveCharacteristics(&uuid16)) {
+                    if (m_vChars.size() > prev_size) {
+                        pChar = m_vChars.back();
+                    }
+                }
             }
         }
     }
 
+Done:
     NIMBLE_LOGD(LOG_TAG, "<< Characteristic %sfound", pChar ? "" : "not ");
     return pChar;
 } // getCharacteristic
@@ -121,11 +130,6 @@ NimBLERemoteCharacteristic* NimBLERemoteService::getCharacteristic(const NimBLEU
  * @return A read-only reference to the vector of characteristics retrieved for this service.
  */
 const std::vector<NimBLERemoteCharacteristic*>& NimBLERemoteService::getCharacteristics(bool refresh) const {
-    if (refresh && NimBLEUtils::inHostTask()) {
-        NIMBLE_LOGE(LOG_TAG, "cannot refresh characteristics from host task");
-        return m_vChars;
-    }
-
     if (refresh) {
         deleteCharacteristics();
         retrieveCharacteristics();
@@ -161,18 +165,7 @@ int NimBLERemoteService::characteristicDiscCB(uint16_t              conn_handle,
     }
 
     if (error->status == 0) {
-        // insert in handle order
-        auto pNewChar = new NimBLERemoteCharacteristic(pSvc, chr);
-        for (auto it = pSvc->m_vChars.begin(); it != pSvc->m_vChars.end(); ++it) {
-            if ((*it)->getHandle() > chr->def_handle) {
-                pSvc->m_vChars.insert(it, pNewChar);
-                pTaskData->m_pBuf = pNewChar;
-                return 0;
-            }
-        }
-
-        pSvc->m_vChars.push_back(pNewChar);
-        pTaskData->m_pBuf = pNewChar;
+        pSvc->m_vChars.push_back(new NimBLERemoteCharacteristic(pSvc, chr));
         return 0;
     }
 
@@ -186,7 +179,7 @@ int NimBLERemoteService::characteristicDiscCB(uint16_t              conn_handle,
  * This function will not return until we have all the characteristics.
  * @return True if successful.
  */
-bool NimBLERemoteService::retrieveCharacteristics(const NimBLEUUID* uuidFilter, NimBLERemoteCharacteristic** ppChar) const {
+bool NimBLERemoteService::retrieveCharacteristics(const NimBLEUUID* uuidFilter) const {
     NIMBLE_LOGD(LOG_TAG, ">> retrieveCharacteristics()");
     int            rc = 0;
     NimBLETaskData taskData(const_cast<NimBLERemoteService*>(this));
@@ -214,9 +207,6 @@ bool NimBLERemoteService::retrieveCharacteristics(const NimBLEUUID* uuidFilter,
     NimBLEUtils::taskWait(taskData, BLE_NPL_TIME_FOREVER);
     rc = taskData.m_flags;
     if (rc == 0 || rc == BLE_HS_EDONE) {
-        if (ppChar != nullptr) {
-            *ppChar = static_cast<NimBLERemoteCharacteristic*>(taskData.m_pBuf);
-        }
         NIMBLE_LOGD(LOG_TAG, "<< retrieveCharacteristics()");
         return true;
     }

src/NimBLERemoteService.h

@@ -53,7 +53,7 @@ class NimBLERemoteService : public NimBLEAttribute {
 
     NimBLERemoteService(NimBLEClient* pClient, const struct ble_gatt_svc* service);
     ~NimBLERemoteService();
-    bool retrieveCharacteristics(const NimBLEUUID* uuidFilter = nullptr, NimBLERemoteCharacteristic** ppChar = nullptr) const;
+    bool       retrieveCharacteristics(const NimBLEUUID* uuidFilter = nullptr) const;
     static int characteristicDiscCB(uint16_t                     conn_handle,
                                     const struct ble_gatt_error* error,
                                     const struct ble_gatt_chr*   chr,

src/NimBLERemoteValueAttribute.cpp

@@ -42,11 +42,6 @@ bool NimBLERemoteValueAttribute::writeValue(const uint8_t* data, size_t length,
         goto Done;
     }
 
-    if (NimBLEUtils::inHostTask()) {
-        NIMBLE_LOGE(LOG_TAG, "writeValue cannot be called from the host task");
-        return false;
-    }
-
     do {
         if (length > mtu) {
             NIMBLE_LOGI(LOG_TAG, "writeValue: long write");
@@ -128,10 +123,6 @@ int NimBLERemoteValueAttribute::onWriteCB(uint16_t conn_handle, const ble_gatt_e
  */
 NimBLEAttValue NimBLERemoteValueAttribute::readValue(time_t* timestamp) {
     NIMBLE_LOGD(LOG_TAG, ">> readValue()");
-    if (NimBLEUtils::inHostTask()) {
-        NIMBLE_LOGE(LOG_TAG, "readValue cannot be called from the host task");
-        return NimBLEAttValue();
-    }
 
     NimBLEAttValue      value{};
     const NimBLEClient* pClient    = getClient();

src/NimBLEScan.cpp

@@ -20,192 +20,32 @@
 
 # include "NimBLEDevice.h"
 # include "NimBLELog.h"
-# if defined(CONFIG_NIMBLE_CPP_IDF)
-#  include "nimble/nimble_port.h"
-# else
-#  include "nimble/porting/nimble/include/nimble/nimble_port.h"
-# endif
 
 # include <string>
 # include <climits>
 
-# define DEFAULT_SCAN_RESP_TIMEOUT_MS 10240 // max advertising interval (10.24s)
-
 static const char*         LOG_TAG = "NimBLEScan";
 static NimBLEScanCallbacks defaultScanCallbacks;
 
-/**
- * @brief This handles an event run in the host task when the scan response timeout for the head of
- * the waiting list is triggered and directly invokes the onResult callback with the current device.
- */
-void NimBLEScan::srTimerCb(ble_npl_event* event) {
-    auto pScan = NimBLEDevice::getScan();
-    auto pDev  = pScan->m_pWaitingListHead;
-
-    if (pDev == nullptr) {
-        ble_npl_callout_stop(&pScan->m_srTimer);
-        return;
-    }
-
-    if (ble_npl_time_get() - pDev->m_time < pScan->m_srTimeoutTicks) {
-        // This can happen if a scan response was received and the device was removed from the waiting list
-        // after this was put in the queue. In this case, just reset the timer for this device.
-        pScan->resetWaitingTimer();
-        return;
-    }
-
-    NIMBLE_LOGI(LOG_TAG, "Scan response timeout for: %s", pDev->getAddress().toString().c_str());
-    pScan->m_stats.incMissedSrCount();
-    pScan->removeWaitingDevice(pDev);
-    pDev->m_callbackSent = 2;
-    pScan->m_pScanCallbacks->onResult(pDev);
-    if (pScan->m_maxResults == 0) {
-        pScan->erase(pDev);
-    }
-}
-
 /**
  * @brief Scan constructor.
  */
 NimBLEScan::NimBLEScan()
     : m_pScanCallbacks{&defaultScanCallbacks},
-      m_scanParams{
-          .itvl              = 0,                       // default interval
-          .window            = 0,                       // default window
-          .filter_policy     = BLE_HCI_SCAN_FILT_NO_WL, // no whitelist scan filter
-          .limited           = 0,                       // no limited scan
-          .passive           = 1,                       // no scan response
-          .filter_duplicates = 1,                       // filter duplicates
-# if defined(ESP_PLATFORM) && !defined(CONFIG_USING_NIMBLE_COMPONENT)
-#  if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 4, 2)
-          .disable_observer_mode = 0, // observer role enabled
-#  endif
-# endif
-      },
+      // default interval + window, no whitelist scan filter,not limited scan, no scan response, filter_duplicates
+      m_scanParams{0, 0, BLE_HCI_SCAN_FILT_NO_WL, 0, 1, 1},
       m_pTaskData{nullptr},
-      m_maxResults{0xFF} {
-    ble_npl_callout_init(&m_srTimer, nimble_port_get_dflt_eventq(), NimBLEScan::srTimerCb, nullptr);
-    ble_npl_time_ms_to_ticks(DEFAULT_SCAN_RESP_TIMEOUT_MS, &m_srTimeoutTicks);
-} // NimBLEScan::NimBLEScan
+      m_maxResults{0xFF} {}
 
 /**
  * @brief Scan destructor, release any allocated resources.
  */
 NimBLEScan::~NimBLEScan() {
-    ble_npl_callout_deinit(&m_srTimer);
-
     for (const auto& dev : m_scanResults.m_deviceVec) {
         delete dev;
     }
 }
 
-/**
- * @brief Add a device to the waiting list for scan responses.
- * @param [in] pDev The device to add to the list.
- */
-void NimBLEScan::addWaitingDevice(NimBLEAdvertisedDevice* pDev) {
-    if (pDev == nullptr) {
-        return;
-    }
-
-    ble_npl_hw_enter_critical();
-
-    // Self-pointer is the "not in list" sentinel; anything else means already in list.
-    if (pDev->m_pNextWaiting != pDev) {
-        ble_npl_hw_exit_critical(0);
-        return;
-    }
-
-    // Initialize link field before inserting into the list.
-    pDev->m_pNextWaiting = nullptr;
-    if (m_pWaitingListTail == nullptr) {
-        m_pWaitingListHead = pDev;
-        m_pWaitingListTail = pDev;
-        ble_npl_hw_exit_critical(0);
-        return;
-    }
-
-    m_pWaitingListTail->m_pNextWaiting = pDev;
-    m_pWaitingListTail                 = pDev;
-    ble_npl_hw_exit_critical(0);
-}
-
-/**
- * @brief Remove a device from the waiting list.
- * @param [in] pDev The device to remove from the list.
- */
-void NimBLEScan::removeWaitingDevice(NimBLEAdvertisedDevice* pDev) {
-    if (pDev == nullptr) {
-        return;
-    }
-
-    if (pDev->m_pNextWaiting == pDev) {
-        return; // Not in the list
-    }
-
-    bool resetTimer = false;
-    ble_npl_hw_enter_critical();
-    if (m_pWaitingListHead == pDev) {
-        m_pWaitingListHead = pDev->m_pNextWaiting;
-        if (m_pWaitingListHead == nullptr) {
-            m_pWaitingListTail = nullptr;
-        } else {
-            resetTimer = true;
-        }
-    } else {
-        NimBLEAdvertisedDevice* current = m_pWaitingListHead;
-        while (current != nullptr) {
-            if (current->m_pNextWaiting == pDev) {
-                current->m_pNextWaiting = pDev->m_pNextWaiting;
-                if (m_pWaitingListTail == pDev) {
-                    m_pWaitingListTail = current;
-                }
-                break;
-            }
-            current = current->m_pNextWaiting;
-        }
-    }
-    ble_npl_hw_exit_critical(0);
-    pDev->m_pNextWaiting = pDev; // Restore sentinel: self-pointer means "not in list"
-    if (resetTimer) {
-        resetWaitingTimer();
-    }
-}
-
-/**
- * @brief Clear all devices from the waiting list.
- */
-void NimBLEScan::clearWaitingList() {
-    // Stop the timer and remove any pending timeout events since we're clearing
-    // the list and won't be processing any more timeouts for these devices
-    ble_npl_callout_stop(&m_srTimer);
-    ble_npl_hw_enter_critical();
-    NimBLEAdvertisedDevice* current = m_pWaitingListHead;
-    while (current != nullptr) {
-        NimBLEAdvertisedDevice* next = current->m_pNextWaiting;
-        current->m_pNextWaiting      = current; // Restore sentinel
-        current                      = next;
-    }
-    m_pWaitingListHead = nullptr;
-    m_pWaitingListTail = nullptr;
-    ble_npl_hw_exit_critical(0);
-}
-
-/**
- * @brief Reset the timer for the next waiting device at the head of the FIFO list.
- */
-void NimBLEScan::resetWaitingTimer() {
-    if (m_srTimeoutTicks == 0 || m_pWaitingListHead == nullptr) {
-        ble_npl_callout_stop(&m_srTimer);
-        return;
-    }
-
-    ble_npl_time_t now      = ble_npl_time_get();
-    ble_npl_time_t elapsed  = now - m_pWaitingListHead->m_time;
-    ble_npl_time_t nextTime = elapsed >= m_srTimeoutTicks ? 1 : m_srTimeoutTicks - elapsed;
-    ble_npl_callout_reset(&m_srTimer, nextTime);
-}
-
 /**
  * @brief Handle GAP events related to scans.
  * @param [in] event The event type for this event.
@@ -261,8 +101,6 @@ int NimBLEScan::handleGapEvent(ble_gap_event* event, void* arg) {
             // If we haven't seen this device before; create a new instance and insert it in the vector.
             // Otherwise just update the relevant parameters of the already known device.
             if (advertisedDevice == nullptr) {
-                pScan->m_stats.incDevCount();
-
                 // Check if we have reach the scan results limit, ignore this one if so.
                 // We still need to store each device when maxResults is 0 to be able to append the scan results
                 if (pScan->m_maxResults > 0 && pScan->m_maxResults < 0xFF &&
@@ -271,39 +109,19 @@ int NimBLEScan::handleGapEvent(ble_gap_event* event, void* arg) {
                 }
 
                 if (isLegacyAdv && event_type == BLE_HCI_ADV_RPT_EVTYPE_SCAN_RSP) {
-                    pScan->m_stats.incOrphanedSrCount();
                     NIMBLE_LOGI(LOG_TAG, "Scan response without advertisement: %s", advertisedAddress.toString().c_str());
                 }
 
                 advertisedDevice = new NimBLEAdvertisedDevice(event, event_type);
                 pScan->m_scanResults.m_deviceVec.push_back(advertisedDevice);
-                advertisedDevice->m_time = ble_npl_time_get();
                 NIMBLE_LOGI(LOG_TAG, "New advertiser: %s", advertisedAddress.toString().c_str());
             } else {
                 advertisedDevice->update(event, event_type);
                 if (isLegacyAdv) {
                     if (event_type == BLE_HCI_ADV_RPT_EVTYPE_SCAN_RSP) {
-                        pScan->m_stats.recordSrTime(ble_npl_time_get() - advertisedDevice->m_time);
                         NIMBLE_LOGI(LOG_TAG, "Scan response from: %s", advertisedAddress.toString().c_str());
-                        // Remove device from waiting list since we got the response
-                        pScan->removeWaitingDevice(advertisedDevice);
                     } else {
-                        pScan->m_stats.incDupCount();
                         NIMBLE_LOGI(LOG_TAG, "Duplicate; updated: %s", advertisedAddress.toString().c_str());
-                        // Restart scan-response timeout when we see a new non-scan-response
-                        // legacy advertisement during active scanning for a scannable device.
-                        advertisedDevice->m_time = ble_npl_time_get();
-                        // Re-add to the tail so FIFO timeout order matches advertisement order.
-                        if (advertisedDevice->isScannable()) {
-                            pScan->removeWaitingDevice(advertisedDevice);
-                            pScan->addWaitingDevice(advertisedDevice);
-                        }
-
-                        // If we're not filtering duplicates, we need to reset the callbackSent count
-                        // so that callbacks will be triggered again for this device
-                        if (!pScan->m_scanParams.filter_duplicates) {
-                            advertisedDevice->m_callbackSent = 0;
-                        }
                     }
                 }
             }
@@ -329,12 +147,6 @@ int NimBLEScan::handleGapEvent(ble_gap_event* event, void* arg) {
                 advertisedDevice->m_callbackSent++;
                 // got the scan response report the full data.
                 pScan->m_pScanCallbacks->onResult(advertisedDevice);
-            } else if (isLegacyAdv && advertisedDevice->isScannable()) {
-                // Add to waiting list for scan response and start the timer
-                pScan->addWaitingDevice(advertisedDevice);
-                if (pScan->m_pWaitingListHead == advertisedDevice) {
-                    pScan->resetWaitingTimer();
-                }
             }
 
             // If not storing results and we have invoked the callback, delete the device.
@@ -346,26 +158,12 @@ int NimBLEScan::handleGapEvent(ble_gap_event* event, void* arg) {
         }
 
         case BLE_GAP_EVENT_DISC_COMPLETE: {
-            ble_npl_callout_stop(&pScan->m_srTimer);
-
-            // If we have any scannable devices that haven't received a scan response,
-            // we should trigger the callback with whatever data we have since the scan is complete
-            // and we won't be getting any more updates for these devices.
-            while (pScan->m_pWaitingListHead != nullptr) {
-                auto pDev = pScan->m_pWaitingListHead;
-                pScan->m_stats.incMissedSrCount();
-                pScan->removeWaitingDevice(pDev);
-                pDev->m_callbackSent = 2;
-                pScan->m_pScanCallbacks->onResult(pDev);
-            }
+            NIMBLE_LOGD(LOG_TAG, "discovery complete; reason=%d", event->disc_complete.reason);
 
             if (pScan->m_maxResults == 0) {
                 pScan->clearResults();
             }
 
-            NIMBLE_LOGD(LOG_TAG, "discovery complete; reason=%d", event->disc_complete.reason);
-            NIMBLE_LOGD(LOG_TAG, "%s", pScan->getStatsString().c_str());
-
             pScan->m_pScanCallbacks->onScanEnd(pScan->m_scanResults, event->disc_complete.reason);
 
             if (pScan->m_pTaskData != nullptr) {
@@ -380,27 +178,6 @@ int NimBLEScan::handleGapEvent(ble_gap_event* event, void* arg) {
     }
 } // handleGapEvent
 
-/**
- * @brief Set the scan response timeout.
- * @param [in] timeoutMs The timeout in milliseconds to wait for a scan response, default: max advertising interval (10.24s)
- * @details If a scan response is not received within the timeout period,
- * the pending device will be reported to the scan result callback with whatever
- * data was present in the advertisement; no synthetic scan-response event is generated.
- * If set to 0, the scan result callback will only be triggered when a scan response
- * is received from the advertiser or when the scan completes, at which point any
- * pending scannable devices will be reported with the advertisement data only.
- */
-void NimBLEScan::setScanResponseTimeout(uint32_t timeoutMs) {
-    if (timeoutMs == 0) {
-        ble_npl_callout_stop(&m_srTimer);
-        m_srTimeoutTicks = 0;
-        return;
-    }
-
-    ble_npl_time_ms_to_ticks(timeoutMs, &m_srTimeoutTicks);
-    resetWaitingTimer();
-} // setScanResponseTimeout
-
 /**
  * @brief Should we perform an active or passive scan?
  * The default is a passive scan. An active scan means that we will request a scan response.
@@ -431,7 +208,7 @@ void NimBLEScan::setDuplicateFilter(uint8_t enabled) {
  */
 void NimBLEScan::setLimitedOnly(bool enabled) {
     m_scanParams.limited = enabled;
-} // setLimitedOnly
+} // setLimited
 
 /**
  * @brief Sets the scan filter policy.
@@ -546,13 +323,11 @@ bool NimBLEScan::start(uint32_t duration, bool isContinue, bool restart) {
 
             if (!isContinue) {
                 clearResults();
-                m_stats.reset();
             }
         }
     } else { // Don't clear results while scanning is active
         if (!isContinue) {
             clearResults();
-            m_stats.reset();
         }
     }
 
@@ -619,8 +394,6 @@ bool NimBLEScan::stop() {
         return false;
     }
 
-    clearWaitingList();
-
     if (m_maxResults == 0) {
         clearResults();
     }
@@ -641,7 +414,6 @@ void NimBLEScan::erase(const NimBLEAddress& address) {
     NIMBLE_LOGD(LOG_TAG, "erase device: %s", address.toString().c_str());
     for (auto it = m_scanResults.m_deviceVec.begin(); it != m_scanResults.m_deviceVec.end(); ++it) {
         if ((*it)->getAddress() == address) {
-            removeWaitingDevice(*it);
             delete *it;
             m_scanResults.m_deviceVec.erase(it);
             break;
@@ -657,7 +429,6 @@ void NimBLEScan::erase(const NimBLEAdvertisedDevice* device) {
     NIMBLE_LOGD(LOG_TAG, "erase device: %s", device->getAddress().toString().c_str());
     for (auto it = m_scanResults.m_deviceVec.begin(); it != m_scanResults.m_deviceVec.end(); ++it) {
         if ((*it) == device) {
-            removeWaitingDevice(*it);
             delete *it;
             m_scanResults.m_deviceVec.erase(it);
             break;
@@ -689,11 +460,6 @@ NimBLEScanResults NimBLEScan::getResults(uint32_t duration, bool is_continue) {
         return m_scanResults;
     }
 
-    if (NimBLEUtils::inHostTask()) {
-        NIMBLE_LOGE(LOG_TAG, "Cannot call blocking getResults from NimBLE host task");
-        return m_scanResults;
-    }
-
     NimBLETaskData taskData;
     m_pTaskData = &taskData;
 
@@ -717,12 +483,6 @@ NimBLEScanResults NimBLEScan::getResults() {
  * @brief Clear the stored results of the scan.
  */
 void NimBLEScan::clearResults() {
-    if (isScanning()) {
-        NIMBLE_LOGW(LOG_TAG, "Cannot clear results while scan is active");
-        return;
-    }
-
-    clearWaitingList();
     if (m_scanResults.m_deviceVec.size()) {
         std::vector<NimBLEAdvertisedDevice*> vSwap{};
         ble_npl_hw_enter_critical();

src/NimBLEScan.h

@@ -31,8 +31,6 @@
 # endif
 
 # include <vector>
-# include <cinttypes>
-# include <cstdio>
 
 class NimBLEDevice;
 class NimBLEScan;
@@ -84,8 +82,6 @@ class NimBLEScan {
     void              setMaxResults(uint8_t maxResults);
     void              erase(const NimBLEAddress& address);
     void              erase(const NimBLEAdvertisedDevice* device);
-    void              setScanResponseTimeout(uint32_t timeoutMs);
-    std::string       getStatsString() const { return m_stats.toString(); }
 
 # if MYNEWT_VAL(BLE_EXT_ADV)
     enum Phy { SCAN_1M = 0x01, SCAN_CODED = 0x02, SCAN_ALL = 0x03 };
@@ -96,103 +92,16 @@ class NimBLEScan {
   private:
     friend class NimBLEDevice;
 
-    struct stats {
-# if MYNEWT_VAL(NIMBLE_CPP_LOG_LEVEL) >= 4
-        uint32_t devCount        = 0; // unique devices seen for the first time
-        uint32_t dupCount        = 0; // repeat advertisements from already-known devices
-        uint32_t srMinMs         = UINT32_MAX;
-        uint32_t srMaxMs         = 0;
-        uint64_t srTotalMs       = 0; // uint64 to avoid overflow on long/busy scans
-        uint32_t srCount         = 0; // matched scan responses (advertisement + SR pair)
-        uint32_t orphanedSrCount = 0; // scan responses received with no prior advertisement
-        uint32_t missedSrCount   = 0; // scannable devices for which no SR ever arrived
-
-        void reset() {
-            devCount        = 0;
-            dupCount        = 0;
-            srMinMs         = UINT32_MAX;
-            srMaxMs         = 0;
-            srTotalMs       = 0;
-            srCount         = 0;
-            orphanedSrCount = 0;
-            missedSrCount   = 0;
-        }
-
-        void incDevCount() { devCount++; }
-        void incDupCount() { dupCount++; }
-        void incMissedSrCount() { missedSrCount++; }
-        void incOrphanedSrCount() { orphanedSrCount++; }
-
-        std::string toString() const {
-            std::string out;
-            out.resize(400); // should be more than enough for the stats string
-            snprintf(&out[0],
-                     out.size(),
-                     "Scan stats:\n"
-                     "  Devices seen      : %" PRIu32 "\n"
-                     "  Duplicate advs    : %" PRIu32 "\n"
-                     "  Scan responses    : %" PRIu32 "\n"
-                     "  SR timing (ms)    : min=%" PRIu32 ", max=%" PRIu32 ", avg=%" PRIu64 "\n"
-                     "  Orphaned SR       : %" PRIu32 "\n"
-                     "  Missed SR         : %" PRIu32 "\n",
-                     devCount,
-                     dupCount,
-                     srCount,
-                     srCount ? srMinMs : 0,
-                     srCount ? srMaxMs : 0,
-                     srCount ? srTotalMs / srCount : 0,
-                     orphanedSrCount,
-                     missedSrCount);
-            return out;
-        }
-
-        // Records scan-response round-trip time.
-        void recordSrTime(uint32_t ticks) {
-            uint32_t ms;
-            ble_npl_time_ticks_to_ms(ticks, &ms);
-
-            if (ms < srMinMs) {
-                srMinMs = ms;
-            }
-            if (ms > srMaxMs) {
-                srMaxMs = ms;
-            }
-            srTotalMs += ms;
-            srCount++;
-            return;
-        }
-# else
-        void        reset() {}
-        void        incDevCount() {}
-        void        incDupCount() {}
-        void        incMissedSrCount() {}
-        void        incOrphanedSrCount() {}
-        std::string toString() const { return ""; }
-        void        recordSrTime(uint32_t ticks) {}
-# endif
-    } m_stats;
-
     NimBLEScan();
     ~NimBLEScan();
-    static int  handleGapEvent(ble_gap_event* event, void* arg);
-    void        onHostSync();
-    static void srTimerCb(ble_npl_event* event);
+    static int handleGapEvent(ble_gap_event* event, void* arg);
+    void       onHostSync();
 
-    // Linked list helpers for devices awaiting scan responses
-    void addWaitingDevice(NimBLEAdvertisedDevice* pDev);
-    void removeWaitingDevice(NimBLEAdvertisedDevice* pDev);
-    void clearWaitingList();
-    void resetWaitingTimer();
-
-    NimBLEScanCallbacks*    m_pScanCallbacks;
-    ble_gap_disc_params     m_scanParams;
-    NimBLEScanResults       m_scanResults;
-    NimBLETaskData*         m_pTaskData;
-    ble_npl_callout         m_srTimer{};
-    ble_npl_time_t          m_srTimeoutTicks{};
-    uint8_t                 m_maxResults;
-    NimBLEAdvertisedDevice* m_pWaitingListHead{}; // head of linked list for devices awaiting scan responses
-    NimBLEAdvertisedDevice* m_pWaitingListTail{}; // tail of linked list for FIFO ordering
+    NimBLEScanCallbacks* m_pScanCallbacks;
+    ble_gap_disc_params  m_scanParams;
+    NimBLEScanResults    m_scanResults;
+    NimBLETaskData*      m_pTaskData;
+    uint8_t              m_maxResults;
 
 # if MYNEWT_VAL(BLE_EXT_ADV)
     uint8_t  m_phy{SCAN_ALL};

src/NimBLEServer.cpp

@@ -39,11 +39,6 @@
 static const char*           LOG_TAG = "NimBLEServer";
 static NimBLEServerCallbacks defaultCallbacks;
 
-struct gattRegisterCallbackArgs {
-    NimBLEService*        pSvc{nullptr};
-    NimBLECharacteristic* pChar{nullptr};
-};
-
 /**
  * @brief Construct a BLE Server
  *
@@ -98,7 +93,8 @@ NimBLEService* NimBLEServer::createService(const char* uuid) {
 NimBLEService* NimBLEServer::createService(const NimBLEUUID& uuid) {
     NimBLEService* pService = new NimBLEService(uuid);
     m_svcVec.push_back(pService);
-    setServiceChanged();
+    serviceChanged();
+
     return pService;
 } // createService
 
@@ -186,145 +182,61 @@ NimBLEAdvertising* NimBLEServer::getAdvertising() const {
  * @brief Called when the services are added/removed and sets a flag to indicate they should be reloaded.
  * @details This has no effect if the GATT server was not already started.
  */
-void NimBLEServer::setServiceChanged() {
+void NimBLEServer::serviceChanged() {
     if (m_gattsStarted) {
         m_svcChanged = true;
     }
 } // serviceChanged
 
-/**
- * @brief Send a service changed indication to all clients.
- * @details This should be called when services are added, removed or modified after the server has been started.
- */
-void NimBLEServer::sendServiceChangedIndication() const {
-    ble_svc_gatt_changed(0x0001, 0xffff);
-}
-
-/**
- * @brief Callback for GATT registration events,
- * used to obtain the assigned handles for services, characteristics, and descriptors.
- * @param [in] ctxt The context of the registration event.
- * @param [in] arg A pointer to the gattRegisterCallbackArgs struct used to track the
- * service and characteristic being registered.
- */
-void NimBLEServer::gattRegisterCallback(ble_gatt_register_ctxt* ctxt, void* arg) {
-    gattRegisterCallbackArgs* args = static_cast<gattRegisterCallbackArgs*>(arg);
-
-    if (ctxt->op == BLE_GATT_REGISTER_OP_SVC) {
-        NimBLEUUID uuid(ctxt->svc.svc_def->uuid);
-        args->pSvc = nullptr;
-        for (auto pSvc : NimBLEDevice::getServer()->m_svcVec) {
-            if (!pSvc->getRemoved() && pSvc->m_handle == 0 && pSvc->getUUID() == uuid) {
-                pSvc->m_handle = ctxt->svc.handle;
-                NIMBLE_LOGD(LOG_TAG, "Service registered: %s, handle=%d", uuid.toString().c_str(), ctxt->svc.handle);
-                // Set the arg to the service so we know that the following
-                // characteristics and descriptors belong to this service
-                args->pSvc = pSvc;
-                break;
-            }
-        }
-
-        return;
-    }
-
-    if (args->pSvc == nullptr) {
-        // If the service is not found then this is likely a characteristic or descriptor that was registered as
-        // part of the GATT server setup and not found in the service vector
-        NIMBLE_LOGD(LOG_TAG, "Skipping characteristic or descriptor registered with unknown service");
-        return;
-    }
-
-    if (ctxt->op == BLE_GATT_REGISTER_OP_CHR) {
-        NimBLEUUID uuid(ctxt->chr.chr_def->uuid);
-        args->pChar = nullptr;
-        for (auto pChr : args->pSvc->m_vChars) {
-            if (!pChr->getRemoved() && pChr->m_handle == 0 && pChr->getUUID() == uuid) {
-                pChr->m_handle = ctxt->chr.val_handle;
-                // Set the arg to the characteristic so we know that the following descriptors belong to this characteristic
-                args->pChar    = pChr;
-                NIMBLE_LOGD(LOG_TAG,
-                            "Characteristic registered: %s, def_handle=%d, val_handle=%d",
-                            uuid.toString().c_str(),
-                            ctxt->chr.def_handle,
-                            ctxt->chr.val_handle);
-                break;
-            }
-        }
-
-        return;
-    }
-
-    if (ctxt->op == BLE_GATT_REGISTER_OP_DSC) {
-        if (args->pChar == nullptr) {
-            NIMBLE_LOGE(LOG_TAG, "Descriptor registered with unknown characteristic, skipping");
-            return;
-        }
-
-        NimBLEUUID uuid(ctxt->dsc.dsc_def->uuid);
-        for (auto pDsc : args->pChar->m_vDescriptors) {
-            if (!pDsc->getRemoved() && pDsc->m_handle == 0 && pDsc->getUUID() == uuid) {
-                pDsc->m_handle = ctxt->dsc.handle;
-                NIMBLE_LOGD(LOG_TAG, "Descriptor registered: %s, handle=%d", uuid.toString().c_str(), ctxt->dsc.handle);
-                return;
-            }
-        }
-    }
-}
-
 /**
  * @brief Start the GATT server.
  * @details Required to be called after setup of all services and characteristics / descriptors
  * for the NimBLE host to register them.
  */
-bool NimBLEServer::start() {
-    if (m_svcChanged && !getConnectedCount()) {
-        NIMBLE_LOGD(LOG_TAG, "Services have changed since last start, resetting GATT server");
-        m_gattsStarted = false;
-    }
-
+void NimBLEServer::start() {
     if (m_gattsStarted) {
-        return true; // already started
+        return; // already started
     }
 
-    if (!resetGATT()) {
-        return false;
-    }
-
-    ble_hs_cfg.gatts_register_cb = NimBLEServer::gattRegisterCallback;
-    gattRegisterCallbackArgs args{};
-    ble_hs_cfg.gatts_register_arg = &args;
-
     int rc = ble_gatts_start();
     if (rc != 0) {
         NIMBLE_LOGE(LOG_TAG, "ble_gatts_start; rc=%d, %s", rc, NimBLEUtils::returnCodeToString(rc));
-        return false;
+        return;
     }
 
 # if MYNEWT_VAL(NIMBLE_CPP_LOG_LEVEL) >= 4
     ble_gatts_show_local();
+# endif
 
-    // Check that all services were registered and log if any are missing.
+    // Get the assigned service handles and build a vector of characteristics
+    // with Notify / Indicate capabilities for event handling
     for (const auto& svc : m_svcVec) {
         if (svc->getRemoved() == 0) {
-            rc = ble_gatts_find_svc(svc->getUUID().getBase(), NULL);
+            rc = ble_gatts_find_svc(svc->getUUID().getBase(), &svc->m_handle);
             if (rc != 0) {
-                NIMBLE_LOGD(LOG_TAG,
+                NIMBLE_LOGW(LOG_TAG,
                             "GATT Server started without service: %s, Service %s",
                             svc->getUUID().toString().c_str(),
                             svc->isStarted() ? "missing" : "not started");
+                continue; // Skip this service as it was not started
+            }
+        }
+
+        // Set the descriptor handles now as the stack does not set these when the service is started
+        for (const auto& chr : svc->m_vChars) {
+            for (auto& desc : chr->m_vDescriptors) {
+                ble_gatts_find_dsc(svc->getUUID().getBase(), chr->getUUID().getBase(), desc->getUUID().getBase(), &desc->m_handle);
             }
         }
     }
-# endif
 
     // If the services have changed indicate it now
     if (m_svcChanged) {
         m_svcChanged = false;
-        sendServiceChangedIndication();
+        ble_svc_gatt_changed(0x0001, 0xffff);
     }
 
     m_gattsStarted = true;
-    return true;
 } // start
 
 /**
@@ -335,22 +247,19 @@ bool NimBLEServer::start() {
  */
 bool NimBLEServer::disconnect(uint16_t connHandle, uint8_t reason) const {
     int rc = ble_gap_terminate(connHandle, reason);
-    switch (rc) {
-        case 0:
-        case BLE_HS_ENOTCONN:
-        case BLE_HS_EALREADY:
-        case BLE_HS_HCI_ERR(BLE_ERR_UNK_CONN_ID):
-            return true;
+    if (rc != 0 && rc != BLE_HS_ENOTCONN && rc != BLE_HS_EALREADY) {
+        NIMBLE_LOGE(LOG_TAG, "ble_gap_terminate failed: rc=%d %s", rc, NimBLEUtils::returnCodeToString(rc));
+        return false;
     }
-    NIMBLE_LOGE(LOG_TAG, "ble_gap_terminate failed: rc=%d %s", rc, NimBLEUtils::returnCodeToString(rc));
-    return false;
+
+    return true;
 } // disconnect
 
 /**
  * @brief Disconnect the specified client with optional reason.
  * @param [in] connInfo Connection of the client to disconnect.
  * @param [in] reason code for disconnecting.
- * @return True if successful.
+ * @return NimBLE host return code.
  */
 bool NimBLEServer::disconnect(const NimBLEConnInfo& connInfo, uint8_t reason) const {
     return disconnect(connInfo.getConnHandle(), reason);
@@ -518,9 +427,13 @@ int NimBLEServer::handleGapEvent(ble_gap_event* event, void* arg) {
             }
 # endif
 
+            if (pServer->m_svcChanged) {
+                pServer->resetGATT();
+            }
+
             peerInfo.m_desc = event->disconnect.conn;
             pServer->m_pServerCallbacks->onDisconnect(pServer, peerInfo, event->disconnect.reason);
-# if !MYNEWT_VAL(BLE_EXT_ADV) && MYNEWT_VAL(BLE_ROLE_BROADCASTER)
+# if !MYNEWT_VAL(BLE_EXT_ADV)
             if (pServer->m_advertiseOnDisconnect) {
                 pServer->startAdvertising();
             }
@@ -699,15 +612,6 @@ int NimBLEServer::handleGapEvent(ble_gap_event* event, void* arg) {
                 // }
                 // rc = ble_sm_inject_io(event->passkey.conn_handle, &pkey);
                 // NIMBLE_LOGD(LOG_TAG, "BLE_SM_IOACT_OOB; ble_sm_inject_io result: %d", rc);
-            } else if (event->passkey.params.action == BLE_SM_IOACT_INPUT) {
-                NIMBLE_LOGD(LOG_TAG, "Enter the passkey");
-
-                rc = ble_gap_conn_find(event->passkey.conn_handle, &peerInfo.m_desc);
-                if (rc != 0) {
-                    return BLE_ATT_ERR_INVALID_HANDLE;
-                }
-
-                pServer->m_pServerCallbacks->onPassKeyEntry(peerInfo);
             } else if (event->passkey.params.action == BLE_SM_IOACT_NONE) {
                 NIMBLE_LOGD(LOG_TAG, "No passkey action required");
             }
@@ -846,7 +750,7 @@ void NimBLEServer::removeService(NimBLEService* service, bool deleteSvc) {
     }
 
     service->setRemoved(deleteSvc ? NIMBLE_ATT_REMOVE_DELETE : NIMBLE_ATT_REMOVE_HIDE);
-    setServiceChanged();
+    serviceChanged();
 # if !MYNEWT_VAL(BLE_EXT_ADV) && MYNEWT_VAL(BLE_ROLE_BROADCASTER)
     NimBLEDevice::getAdvertising()->removeServiceUUID(service->getUUID());
 # endif
@@ -873,70 +777,40 @@ void NimBLEServer::addService(NimBLEService* service) {
     }
 
     service->setRemoved(0);
-    setServiceChanged();
+    serviceChanged();
 } // addService
 
 /**
  * @brief Resets the GATT server, used when services are added/removed after initialization.
- * @return True if successful.
- * @details This will reset the GATT server and re-register all services, characteristics, and
- * descriptors that have not been removed. Services, characteristics, and descriptors that have been
- * removed but not deleted will be skipped and have their handles cleared, and those that have been
- * deleted will be removed from the server's service vector.
  */
-bool NimBLEServer::resetGATT() {
+void NimBLEServer::resetGATT() {
+    if (getConnectedCount() > 0) {
+        return;
+    }
+
 # if MYNEWT_VAL(BLE_ROLE_BROADCASTER)
     NimBLEDevice::stopAdvertising();
 # endif
-
     ble_gatts_reset();
     ble_svc_gap_init();
     ble_svc_gatt_init();
 
-    for (auto svcIt = m_svcVec.begin(); svcIt != m_svcVec.end();) {
-        auto* pSvc = *svcIt;
-        if (pSvc->getRemoved() == NIMBLE_ATT_REMOVE_DELETE) {
-            delete pSvc;
-            svcIt = m_svcVec.erase(svcIt);
+    for (auto it = m_svcVec.begin(); it != m_svcVec.end();) {
+        if ((*it)->getRemoved() > 0) {
+            if ((*it)->getRemoved() == NIMBLE_ATT_REMOVE_DELETE) {
+                delete *it;
+                it = m_svcVec.erase(it);
+            } else {
+                ++it;
+            }
             continue;
         }
 
-        for (auto chrIt = pSvc->m_vChars.begin(); chrIt != pSvc->m_vChars.end();) {
-            auto* pChr = *chrIt;
-            if (pChr->getRemoved() == NIMBLE_ATT_REMOVE_DELETE) {
-                delete pChr;
-                chrIt = pSvc->m_vChars.erase(chrIt);
-                continue;
-            }
-
-            for (auto dscIt = pChr->m_vDescriptors.begin(); dscIt != pChr->m_vDescriptors.end();) {
-                auto* pDsc = *dscIt;
-                if (pDsc->getRemoved() == NIMBLE_ATT_REMOVE_DELETE) {
-                    delete pDsc;
-                    dscIt = pChr->m_vDescriptors.erase(dscIt);
-                    continue;
-                }
-
-                pDsc->m_handle = 0;
-                ++dscIt;
-            }
-
-            pChr->m_handle = 0;
-            ++chrIt;
-        }
-
-        if (pSvc->getRemoved() == 0) {
-            if (!pSvc->start_internal()) {
-                NIMBLE_LOGE(LOG_TAG, "Failed to start service: %s", pSvc->getUUID().toString().c_str());
-                return false;
-            }
-        }
-
-        pSvc->m_handle = 0;
-        ++svcIt;
+        (*it)->start();
+        ++it;
     }
 
-    return true;
+    m_gattsStarted = false;
 } // resetGATT
 
 /**
@@ -1119,7 +993,6 @@ NimBLEClient* NimBLEServer::getClient(const NimBLEConnInfo& connInfo) {
     m_pClient->deleteServices(); // Changed peer connection delete the database.
     m_pClient->m_peerAddress = connInfo.getAddress();
     m_pClient->m_connHandle  = connInfo.getConnHandle();
-    m_pClient->m_connStatus  = NimBLEClient::CONNECTED;
     return m_pClient;
 } // getClient
 
@@ -1152,11 +1025,6 @@ uint32_t NimBLEServerCallbacks::onPassKeyDisplay() {
     return 123456;
 } // onPassKeyDisplay
 
-void NimBLEServerCallbacks::onPassKeyEntry(NimBLEConnInfo& connInfo) {
-    NIMBLE_LOGD("NimBLEServerCallbacks", "onPassKeyEntry: default: 123456");
-    NimBLEDevice::injectPassKey(connInfo, 123456);
-} // onPassKeyEntry
-
 void NimBLEServerCallbacks::onConfirmPassKey(NimBLEConnInfo& connInfo, uint32_t pin) {
     NIMBLE_LOGD("NimBLEServerCallbacks", "onConfirmPasskey: default: true");
     NimBLEDevice::injectConfirmPasskey(connInfo, true);

src/NimBLEServer.h

@@ -61,7 +61,7 @@ class NimBLEClient;
  */
 class NimBLEServer {
   public:
-    bool    start();
+    void    start();
     uint8_t getConnectedCount() const;
     bool    disconnect(uint16_t connHandle, uint8_t reason = BLE_ERR_REM_USER_CONN_TERM) const;
     bool    disconnect(const NimBLEConnInfo& connInfo, uint8_t reason = BLE_ERR_REM_USER_CONN_TERM) const;
@@ -84,7 +84,6 @@ class NimBLEServer {
     void                  setDataLen(uint16_t connHandle, uint16_t tx_octets) const;
     bool                  updatePhy(uint16_t connHandle, uint8_t txPhysMask, uint8_t rxPhysMask, uint16_t phyOptions);
     bool                  getPhy(uint16_t connHandle, uint8_t* txPhy, uint8_t* rxPhy);
-    void                  sendServiceChangedIndication() const;
 
 # if MYNEWT_VAL(BLE_ROLE_CENTRAL)
     NimBLEClient* getClient(uint16_t connHandle);
@@ -120,16 +119,15 @@ class NimBLEServer {
 
     NimBLEServer();
     ~NimBLEServer();
-    static int  handleGapEvent(struct ble_gap_event* event, void* arg);
-    static int  handleGattEvent(uint16_t connHandle, uint16_t attrHandle, ble_gatt_access_ctxt* ctxt, void* arg);
-    static void gattRegisterCallback(struct ble_gatt_register_ctxt* ctxt, void* arg);
-    void        setServiceChanged();
-    bool        resetGATT();
+    static int handleGapEvent(struct ble_gap_event* event, void* arg);
+    static int handleGattEvent(uint16_t connHandle, uint16_t attrHandle, ble_gatt_access_ctxt* ctxt, void* arg);
+    void       serviceChanged();
+    void       resetGATT();
 
     bool m_gattsStarted : 1;
     bool m_svcChanged : 1;
     bool m_deleteCallbacks : 1;
-# if !MYNEWT_VAL(BLE_EXT_ADV) && MYNEWT_VAL(BLE_ROLE_BROADCASTER)
+# if !MYNEWT_VAL(BLE_EXT_ADV)
     bool m_advertiseOnDisconnect : 1;
 # endif
     NimBLEServerCallbacks*                                m_pServerCallbacks;
@@ -181,15 +179,6 @@ class NimBLEServerCallbacks {
      */
     virtual uint32_t onPassKeyDisplay();
 
-    /**
-     * @brief Called when using passkey entry pairing and the peer requires the passkey to be entered.
-     * @param [in] connInfo A reference to a NimBLEConnInfo instance with information
-     * about the peer connection parameters.
-     * @details The application should call NimBLEDevice::injectPassKey with the passkey
-     * displayed on the peer device to complete the pairing process.
-     */
-    virtual void onPassKeyEntry(NimBLEConnInfo& connInfo);
-
     /**
      * @brief Called when using numeric comparision for pairing.
      * @param [in] connInfo A reference to a NimBLEConnInfo instance with information

src/NimBLEService.cpp

@@ -48,7 +48,12 @@ NimBLEService::NimBLEService(const NimBLEUUID& uuid)
  * @brief Destructor, make sure we release the resources allocated for the service.
  */
 NimBLEService::~NimBLEService() {
-    clearServiceDefinitions();
+    if (m_pSvcDef->characteristics) {
+        if (m_pSvcDef->characteristics->descriptors) {
+            delete[] m_pSvcDef->characteristics->descriptors;
+        }
+        delete[] m_pSvcDef->characteristics;
+    }
 
     for (const auto& it : m_vChars) {
         delete it;
@@ -83,10 +88,22 @@ void NimBLEService::dump() const {
  * and registers it with the NimBLE stack.
  * @return bool success/failure .
  */
-bool NimBLEService::start_internal() {
-    NIMBLE_LOGD(LOG_TAG, ">> start(): Starting service: UUID: %s", getUUID().toString().c_str());
-    // Make sure the definitions are cleared first
-    clearServiceDefinitions();
+bool NimBLEService::start() {
+    NIMBLE_LOGD(LOG_TAG, ">> start(): Starting service: %s", toString().c_str());
+
+    // If started previously and no characteristics have been added or removed,
+    // then we can skip the service registration process.
+    if (m_pSvcDef->characteristics && !getServer()->m_svcChanged) {
+        return true;
+    }
+
+    // If started previously, clear everything and start over
+    if (m_pSvcDef->characteristics) {
+        if (m_pSvcDef->characteristics->descriptors) {
+            delete[] m_pSvcDef->characteristics->descriptors;
+        }
+        delete[] m_pSvcDef->characteristics;
+    }
 
     size_t numChrs = 0;
     for (const auto& chr : m_vChars) {
@@ -96,7 +113,7 @@ bool NimBLEService::start_internal() {
         ++numChrs;
     }
 
-    NIMBLE_LOGD(LOG_TAG, "Adding %zu characteristics for service %s", numChrs, getUUID().toString().c_str());
+    NIMBLE_LOGD(LOG_TAG, "Adding %d characteristics for service %s", numChrs, toString().c_str());
     if (numChrs) {
         int i = 0;
 
@@ -143,7 +160,7 @@ bool NimBLEService::start_internal() {
             pChrs[i].arg          = chr;
             pChrs[i].flags        = chr->getProperties();
             pChrs[i].min_key_size = 0;
-            pChrs[i].val_handle   = nullptr;
+            pChrs[i].val_handle   = &chr->m_handle;
             ++i;
         }
 
@@ -151,18 +168,15 @@ bool NimBLEService::start_internal() {
     }
 
     m_pSvcDef->type = BLE_GATT_SVC_TYPE_PRIMARY;
-
-    int rc = ble_gatts_count_cfg(m_pSvcDef);
+    int rc          = ble_gatts_count_cfg(m_pSvcDef);
     if (rc != 0) {
         NIMBLE_LOGE(LOG_TAG, "ble_gatts_count_cfg failed, rc= %d, %s", rc, NimBLEUtils::returnCodeToString(rc));
-        clearServiceDefinitions(); // Clear the definitions to free memory and reset the service for re-registration.
         return false;
     }
 
     rc = ble_gatts_add_svcs(m_pSvcDef);
     if (rc != 0) {
         NIMBLE_LOGE(LOG_TAG, "ble_gatts_add_svcs, rc= %d, %s", rc, NimBLEUtils::returnCodeToString(rc));
-        clearServiceDefinitions(); // Clear the definitions to free memory and reset the service for re-registration.
         return false;
     }
 
@@ -170,25 +184,6 @@ bool NimBLEService::start_internal() {
     return true;
 } // start
 
-/**
- * @brief Clear the service definitions to free memory and reset the service for re-registration.
- */
-void NimBLEService::clearServiceDefinitions() {
-    if (m_pSvcDef->characteristics) {
-        const ble_gatt_chr_def* chrDef = m_pSvcDef->characteristics;
-        while (chrDef->uuid != nullptr) {
-            if (chrDef->descriptors) {
-                delete[] chrDef->descriptors;
-            }
-            ++chrDef;
-        }
-        delete[] m_pSvcDef->characteristics;
-        m_pSvcDef->characteristics = nullptr;
-    }
-
-    m_pSvcDef->type = 0; // Clear the type to indicate the service is not started/registered.
-} // clearServiceDefinitions
-
 /**
  * @brief Create a new BLE Characteristic associated with this service.
  * @param [in] uuid - The UUID of the characteristic.
@@ -245,7 +240,7 @@ void NimBLEService::addCharacteristic(NimBLECharacteristic* pChar) {
     }
 
     pChar->setService(this);
-    getServer()->setServiceChanged();
+    getServer()->serviceChanged();
 } // addCharacteristic
 
 /**
@@ -272,7 +267,7 @@ void NimBLEService::removeCharacteristic(NimBLECharacteristic* pChar, bool delet
     }
 
     pChar->setRemoved(deleteChr ? NIMBLE_ATT_REMOVE_DELETE : NIMBLE_ATT_REMOVE_HIDE);
-    getServer()->setServiceChanged();
+    getServer()->serviceChanged();
 } // removeCharacteristic
 
 /**

src/NimBLEService.h

@@ -37,19 +37,11 @@ class NimBLEService : public NimBLELocalAttribute {
     NimBLEService(const NimBLEUUID& uuid);
     ~NimBLEService();
 
-    NimBLEServer* getServer() const;
-    std::string   toString() const;
-    void          dump() const;
-    bool          isStarted() const;
-
-    /**
-     * @brief Dummy function to start the service. Services are started when the server is started.
-     * This will be removed in a future release. Use `NimBLEServer::start()` to start the server and all associated services.
-     */
-    __attribute__((deprecated("NimBLEService::start() has no effect. "
-                   "Services are started when the server is started.")))
-    bool start() { return true; }
-
+    NimBLEServer*         getServer() const;
+    std::string           toString() const;
+    void                  dump() const;
+    bool                  isStarted() const;
+    bool                  start();
     NimBLECharacteristic* createCharacteristic(const char* uuid,
                                                uint32_t    properties = NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE,
                                                uint16_t    max_len    = BLE_ATT_ATTR_MAX_LEN);
@@ -69,8 +61,6 @@ class NimBLEService : public NimBLELocalAttribute {
 
   private:
     friend class NimBLEServer;
-    bool start_internal();
-    void clearServiceDefinitions();
 
     std::vector<NimBLECharacteristic*> m_vChars{};
     // Nimble requires an array of services to be sent to the api

src/NimBLEStream.h

@@ -1,231 +0,0 @@
-/*
- * Copyright 2020-2025 Ryan Powell <ryan@nable-embedded.io> and
- * esp-nimble-cpp, NimBLE-Arduino contributors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef NIMBLE_CPP_STREAM_H
-#define NIMBLE_CPP_STREAM_H
-
-#include "syscfg/syscfg.h"
-#if CONFIG_BT_NIMBLE_ENABLED && (MYNEWT_VAL(BLE_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_ROLE_CENTRAL))
-
-# if defined(CONFIG_NIMBLE_CPP_IDF)
-#  include "nimble/nimble_npl.h"
-# else
-#  include "nimble/nimble/include/nimble/nimble_npl.h"
-# endif
-
-# include <functional>
-# include <type_traits>
-# include <cstdarg>
-
-# ifndef NIMBLE_CPP_ARDUINO_STRING_AVAILABLE
-#  define NIMBLE_CPP_ARDUINO_STRING_AVAILABLE (__has_include(<Arduino.h>))
-# endif
-
-# if NIMBLE_CPP_ARDUINO_STRING_AVAILABLE
-#  include <Stream.h>
-# else
-
-// Minimal Stream/Print stubs when Arduino not available
-class Print {
-  public:
-    virtual ~Print() {}
-    virtual size_t write(uint8_t)                            = 0;
-    virtual size_t write(const uint8_t* buffer, size_t size) = 0;
-    size_t         print(const char* s);
-    size_t         println(const char* s);
-    size_t         printf(const char* format, ...) __attribute__((format(printf, 2, 3)));
-};
-
-class Stream : public Print {
-  public:
-    virtual int   available() = 0;
-    virtual int   read()      = 0;
-    virtual int   peek()      = 0;
-    virtual void  flush() {}
-    void          setTimeout(unsigned long timeout) { m_timeout = timeout; }
-    unsigned long getTimeout() const { return m_timeout; }
-
-  protected:
-    unsigned long m_timeout{0};
-};
-# endif
-
-class NimBLEStream : public Stream {
-  public:
-    enum RxOverflowAction {
-        DROP_OLDER_DATA, // Drop older buffered data to make room for new data
-        DROP_NEW_DATA    // Drop new incoming data when buffer is full
-    };
-
-    using RxOverflowCallback = std::function<RxOverflowAction(const uint8_t* data, size_t len, void* userArg)>;
-
-    NimBLEStream() = default;
-    virtual ~NimBLEStream() { end(); }
-
-    // Print/Stream TX methods
-    virtual size_t write(const uint8_t* data, size_t len) override;
-    virtual size_t write(uint8_t data) override { return write(&data, 1); }
-
-    // Template for other integral types (char, int, long, etc.)
-    template <typename T>
-    typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, uint8_t>::value, size_t>::type write(T data) {
-        return write(static_cast<uint8_t>(data));
-    }
-
-    size_t availableForWrite() const;
-
-    // Read up to len bytes into buffer (non-blocking)
-    size_t read(uint8_t* buffer, size_t len);
-
-    // Stream RX methods
-    virtual int  available() override;
-    virtual int  read() override;
-    virtual int  peek() override;
-    virtual bool ready() const = 0;
-
-    /**
-     * @brief Set a callback to be invoked when incoming data exceeds RX buffer capacity.
-     * @param cb The callback function, which should return DROP_OLDER_DATA to drop older buffered data and
-     * make room for the new data, or DROP_NEW_DATA to drop the new data instead.
-     */
-    void setRxOverflowCallback(RxOverflowCallback cb, void* userArg = nullptr) {
-        m_rxOverflowCallback = cb;
-        m_rxOverflowUserArg  = userArg;
-    }
-
-    operator bool() const { return ready(); }
-
-    using Print::write;
-
-    struct ByteRingBuffer;
-
-  protected:
-    bool         begin();
-    void         drainTx();
-    size_t       pushRx(const uint8_t* data, size_t len);
-    virtual void end();
-    virtual bool send() = 0;
-    static void  txDrainEventCb(struct ble_npl_event* ev);
-    static void  txDrainCalloutCb(struct ble_npl_event* ev);
-
-    ByteRingBuffer*    m_txBuf{nullptr};
-    ByteRingBuffer*    m_rxBuf{nullptr};
-    uint8_t            m_txChunkBuf[MYNEWT_VAL(BLE_ATT_PREFERRED_MTU)];
-    uint32_t           m_txBufSize{1024};
-    uint32_t           m_rxBufSize{1024};
-    ble_npl_event      m_txDrainEvent{};
-    ble_npl_callout    m_txDrainCallout{};
-    RxOverflowCallback m_rxOverflowCallback{nullptr};
-    void*              m_rxOverflowUserArg{nullptr};
-    bool               m_coInitialized{false};
-    bool               m_eventInitialized{false};
-};
-
-# if MYNEWT_VAL(BLE_ROLE_PERIPHERAL)
-#  include "NimBLECharacteristic.h"
-
-class NimBLEStreamServer : public NimBLEStream {
-  public:
-    NimBLEStreamServer() : m_charCallbacks(this) {}
-    ~NimBLEStreamServer() override { end(); }
-
-    // non-copyable
-    NimBLEStreamServer(const NimBLEStreamServer&)            = delete;
-    NimBLEStreamServer& operator=(const NimBLEStreamServer&) = delete;
-
-    bool begin(NimBLECharacteristic* chr, uint32_t txBufSize = 1024, uint32_t rxBufSize = 1024);
-
-    // Convenience overload to create service/characteristic internally; service will be deleted on end()
-    bool begin(const NimBLEUUID& svcUuid,
-               const NimBLEUUID& chrUuid,
-               uint32_t          txBufSize = 1024,
-               uint32_t          rxBufSize = 1024,
-               bool              secure    = false);
-
-    void     end() override;
-    size_t   write(const uint8_t* data, size_t len) override;
-    uint16_t getPeerHandle() const { return m_charCallbacks.m_peerHandle; }
-    void     setCallbacks(NimBLECharacteristicCallbacks* pCallbacks) { m_charCallbacks.m_userCallbacks = pCallbacks; }
-    bool     ready() const override;
-    virtual void flush() override;
-
-    using NimBLEStream::write; // Inherit template write overloads
-
-  protected:
-    bool send() override;
-
-    struct ChrCallbacks : public NimBLECharacteristicCallbacks {
-        ChrCallbacks(NimBLEStreamServer* parent)
-            : m_parent(parent), m_userCallbacks(nullptr), m_peerHandle(BLE_HS_CONN_HANDLE_NONE) {}
-        void onWrite(NimBLECharacteristic* pCharacteristic, NimBLEConnInfo& connInfo) override;
-        void onSubscribe(NimBLECharacteristic* pCharacteristic, NimBLEConnInfo& connInfo, uint16_t subValue) override;
-        void onStatus(NimBLECharacteristic* pCharacteristic, NimBLEConnInfo& connInfo, int code) override;
-        // override this to avoid recursion when debug logs are enabled
-        void onStatus(NimBLECharacteristic* pCharacteristic, int code) override {
-            if (m_userCallbacks != nullptr) {
-                m_userCallbacks->onStatus(pCharacteristic, code);
-            }
-        }
-
-        NimBLEStreamServer*            m_parent;
-        NimBLECharacteristicCallbacks* m_userCallbacks;
-        uint16_t                       m_peerHandle;
-    } m_charCallbacks;
-
-    NimBLECharacteristic* m_pChr{nullptr};
-    int                   m_rc{0};
-    // Whether to delete the BLE service when end() is called; set to false if service is managed externally
-    bool                  m_deleteSvcOnEnd{false};
-};
-# endif // BLE_ROLE_PERIPHERAL
-
-# if MYNEWT_VAL(BLE_ROLE_CENTRAL)
-#  include "NimBLERemoteCharacteristic.h"
-
-class NimBLEStreamClient : public NimBLEStream {
-  public:
-    NimBLEStreamClient() = default;
-    ~NimBLEStreamClient() override { end(); }
-
-    // non-copyable
-    NimBLEStreamClient(const NimBLEStreamClient&)            = delete;
-    NimBLEStreamClient& operator=(const NimBLEStreamClient&) = delete;
-
-    // Attach a discovered remote characteristic; app owns discovery/connection.
-    // Set subscribeNotify=true to receive notifications into RX buffer.
-    bool         begin(NimBLERemoteCharacteristic* pChr,
-                       bool                        subscribeNotify = false,
-                       uint32_t                    txBufSize       = 1024,
-                       uint32_t                    rxBufSize       = 1024);
-    void         end() override;
-    void         setNotifyCallback(NimBLERemoteCharacteristic::notify_callback cb) { m_userNotifyCallback = cb; }
-    bool         ready() const override;
-    virtual void flush() override;
-
-    using NimBLEStream::write; // Inherit template write overloads
-
-  protected:
-    bool send() override;
-    void notifyCallback(NimBLERemoteCharacteristic* pChar, uint8_t* pData, size_t len, bool isNotify);
-
-    NimBLERemoteCharacteristic*                 m_pChr{nullptr};
-    NimBLERemoteCharacteristic::notify_callback m_userNotifyCallback{nullptr};
-};
-# endif // BLE_ROLE_CENTRAL
-
-#endif // CONFIG_BT_NIMBLE_ENABLED && (MYNEWT_VAL(BLE_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_ROLE_CENTRAL))
-#endif // NIMBLE_CPP_STREAM_H

src/NimBLEUUID.cpp

@@ -38,20 +38,6 @@ static const uint8_t ble_base_uuid[] = {
  */
 NimBLEUUID::NimBLEUUID(const ble_uuid_any_t& uuid) : m_uuid{uuid} {}
 
-/**
- * @brief Create a UUID from the native UUID pointer.
- * @param [in] uuid The native UUID pointer.
- */
-NimBLEUUID::NimBLEUUID(const ble_uuid_t* uuid) {
-    if (uuid == nullptr) {
-        NIMBLE_LOGE(LOG_TAG, "Invalid UUID pointer");
-        m_uuid.u.type = 0;
-        return;
-    }
-
-    ble_uuid_copy(&m_uuid, uuid);
-}
-
 /**
  * @brief Create a UUID from a string.
  *

src/NimBLEUUID.h

@@ -45,7 +45,6 @@ class NimBLEUUID {
      */
     NimBLEUUID() = default;
     NimBLEUUID(const ble_uuid_any_t& uuid);
-    NimBLEUUID(const ble_uuid_t* uuid);
     NimBLEUUID(const std::string& uuid);
     NimBLEUUID(uint16_t uuid);
     NimBLEUUID(uint32_t uuid);

src/NimBLEUtils.cpp

@@ -72,8 +72,6 @@
 constexpr uint32_t TASK_BLOCK_BIT = (1 << MYNEWT_VAL(NIMBLE_CPP_FREERTOS_TASK_BLOCK_BIT));
 static const char* LOG_TAG        = "NimBLEUtils";
 
-void* NimBLEUtils::m_hostTaskHandle = nullptr;
-
 /**
  * @brief Construct a NimBLETaskData instance.
  * @param [in] pInstance An instance of the class that will be waiting.
@@ -606,21 +604,4 @@ NimBLEAddress NimBLEUtils::generateAddr(bool nrpa) {
     return NimBLEAddress{addr};
 } // generateAddr
 
-
-/**
- * @brief Get the handle of the task that is running the NimBLE host.
- * @return The task handle or nullptr if there was an error.
- */
-void* NimBLEUtils::getHostTaskHandle() {
-    return m_hostTaskHandle;
-} // getHostTaskHandle
-
-/**
- * @brief Check if the current task is the NimBLE host task.
- * @return True if the current task is the host task, false otherwise.
- */
-bool NimBLEUtils::inHostTask() {
-    return ble_npl_get_current_task_id() == NimBLEUtils::getHostTaskHandle();
-}
-
 #endif // CONFIG_BT_NIMBLE_ENABLED

src/NimBLEUtils.h

@@ -29,18 +29,17 @@
 #  endif
 # endif
 
-# if MYNEWT_VAL(NIMBLE_CPP_DEBUG_ASSERT_ENABLED) && !defined NDEBUG
-void nimble_cpp_assert(const char* file, unsigned line) __attribute__((weak, noreturn));
-#  define NIMBLE_ATT_VAL_FILE (__builtin_strrchr(__FILE__, '/') ? __builtin_strrchr(__FILE__, '/') + 1 : __FILE__)
-#  define NIMBLE_CPP_DEBUG_ASSERT(cond)                         \
-      do {                                                      \
-          if (!(cond)) {                                        \
-              nimble_cpp_assert(NIMBLE_ATT_VAL_FILE, __LINE__); \
-          }                                                     \
-      } while (0)
-# else
-#  define NIMBLE_CPP_DEBUG_ASSERT(cond) (void(0))
-# endif
+#if MYNEWT_VAL(NIMBLE_CPP_DEBUG_ASSERT_ENABLED) && !defined NDEBUG
+void nimble_cpp_assert(const char *file, unsigned line) __attribute((weak, noreturn));
+# define NIMBLE_ATT_VAL_FILE  (__builtin_strrchr(__FILE__, '/') ? \
+                            __builtin_strrchr (__FILE__, '/') + 1 : __FILE__)
+# define NIMBLE_CPP_DEBUG_ASSERT(cond) \
+    if (!(cond)) { \
+        nimble_cpp_assert(NIMBLE_ATT_VAL_FILE, __LINE__); \
+    }
+#else
+# define NIMBLE_CPP_DEBUG_ASSERT(cond) (void(0))
+#endif
 
 # include <string>
 
@@ -75,12 +74,6 @@ class NimBLEUtils {
     static NimBLEAddress generateAddr(bool nrpa);
     static bool          taskWait(const NimBLETaskData& taskData, uint32_t timeout);
     static void          taskRelease(const NimBLETaskData& taskData, int rc = 0);
-    static void*         getHostTaskHandle();
-    static bool          inHostTask();
-
-  private:
-    friend class NimBLEDevice;
-    static void* m_hostTaskHandle;
 };
 
 #endif // CONFIG_BT_NIMBLE_ENABLED