Set a time for scan responses so that callbacks are triggered.

* General code cleanup
* `NimBLEScan::start` will no longer clear cache or results if scanning is already in progress.
* `NimBLEScan::clearResults` will now reset the vector capacity to 0.
* `NimBLEScan::stop` will no longer call the `onScanEnd` callback as the caller should know its been stopped when this is called.
* `NimBLEScan::clearDuplicateCache` has been removed as it was problematic and only for the esp32. Stop and start the scanner for the same effect.
* `NimBLEScan::start` takes a new bool parameter `restart`, default `true`, that will restart an already in progress scan and clear the duplicate filter so all devices will be discovered again.
* Scan response data that is received without advertisement first will now create the device and send a callback.

.github/workflows/build.yml

@@ -1,7 +1,7 @@
 name: Build
 
 on:
-  workflow_dispatch:
+  workflow_dispatch:      # Start a workflow
   pull_request:
   push:
     branches:
@@ -17,28 +17,33 @@ jobs:
         # 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-v4.4", "release-v5.1", "release-v5.3"]
-        idf_target: ["esp32", "esp32s3", "esp32c2", "esp32c3", "esp32c6", "esp32h2", "esp32p4"]
+        idf_ver: ["release-v4.4", "release-v5.1"]
+        idf_target: ["esp32", "esp32s3", "esp32c2", "esp32c3", "esp32c6", "esp32h2"]
         example:
-          - NimBLE_Client
-          - NimBLE_Server
+          - Advanced/NimBLE_Client
+          - Advanced/NimBLE_Server
+          - basic/BLE_client
+          - basic/BLE_notify
+          - basic/BLE_scan
+          - basic/BLE_server
+          - basic/BLE_uart
           - Bluetooth_5/NimBLE_extended_client
           - Bluetooth_5/NimBLE_extended_server
+          - Bluetooth_5/NimBLE_multi_advertiser
+          - NimBLE_server_get_client_name
         exclude:
           - idf_target: "esp32"
             example: Bluetooth_5/NimBLE_extended_client
           - idf_target: "esp32"
             example: Bluetooth_5/NimBLE_extended_server
+          - idf_target: "esp32"
+            example: Bluetooth_5/NimBLE_multi_advertiser
           - idf_ver: release-v4.4
             idf_target: "esp32c2"
           - idf_ver: release-v4.4
             idf_target: "esp32c6"
           - idf_ver: release-v4.4
             idf_target: "esp32h2"
-          - idf_ver: release-v4.4
-            idf_target: "esp32p4"
-          - idf_ver: release-v5.1
-            idf_target: "esp32p4"
 
     container: espressif/idf:${{ matrix.idf_ver }}
     steps:
@@ -60,6 +65,6 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Doxygen Action
-        uses: mattnotmitt/doxygen-action@v1.9.8
+        uses: mattnotmitt/doxygen-action@v1.9.5
         with:
           working-directory: 'docs/'

CHANGELOG.md

@@ -3,237 +3,12 @@
 All notable changes to this project will be documented in this file.
 ## [Unreleased]
 
-## **Breaking changes**
-- All connection oriented callbacks now receive a reference to `NimBLEConnInfo`, the `ble_gap_conn_desc` has also been replace with `NimBLEConnInfo` in the functions that received it.
-- All functions that take a time input parameter now expect the value to be in milliseconds instead of seconds.
-- Removed Eddystone URL as it has been shutdown by google since 2021.
+### Changed
 - NimBLESecurity class removed.
-- `NimBLEDevice` Ignore list functions removed.
-- `NimBLEDevice::startSecurity` now returns a `bool`, true on success, instead of an int to be consistent with the rest of the library.
-- `NimBLEDevice::getInitialized` renamed to `NimBLEDevice::isInitialized`.
-- `NimBLEDevice::setPower` no longer takes the `esp_power_level_t` and `esp_ble_power_type_t`, instead only an integer value in dbm units is accepted.
-- `NimBLEDevice::setOwnAddrType` no longer takes a `bool nrpa` parameter.
-- `NimBLEDevice::getClientListSize` replaced with `NimBLEDevice::getCreatedClientCount`.
-- `NimBLEDevice::getClientList` was removed.
-- `NimBLEServer::disconnect` now returns `bool`, true = success,  instead of `int` to be consistent with the rest of the library.
-- `NimBLEServerCallbacks::onMTUChanged` renamed to `NimBLEServerCallbacks::onMTUChange` to be consistent with the client callback.
-- `NimBLEServer::getPeerIDInfo` renamed to `NimBLEServer::getPeerInfoByHandle` to better describe it's use.
-- `NimBLEServerCallbacks::onPassKeyRequest` has been replaced with `NimBLEServer::onPassKeyDisplay` which should display the pairing pin that the client is expected to send.
-- `NimBLEServerCallbacks::onAuthenticationComplete` now takes a `NimBLEConnInfo&` parameter.
-- `NimBLEClient::getServices` now returns a const reference to std::vector<NimBLERemoteService*> instead of a pointer to the internal vector.
-- `NimBLEClient::getConnId` has been renamed to `getConnHandle` to be consistent with bluetooth terminology.
-- `NimBLEClient::disconnect` now returns a `bool`, true on success, instead of an int to be consistent with the rest of the library.
-- `NimBLEClientCallbacks::onDisconnect` now takes an additional `int reason` parameter to let the application know why the disconnect occurred.
-- `NimBLEClientCallbacks::onPassKeyRequest` has been changed to `NimBLEClientCallbacks::onPassKeyEntry` which takes a `NimBLEConnInfo&` parameter and does not return a value. Instead or returning a value this callback should prompt a user to enter a pin number which is sent later via `NimBLEDevice::injectPassKey`.
-- `NimBLEClientCallbacks::onConfirmPIN` renamed to `NimBLEClientCallbacks::onConfirmPasskey` and no longer returns a value and now takes a `NimBLEConnInfo&` parameter. This should be used to prompt a user to confirm the pin on the display (YES/NO) after which the response should be sent with `NimBLEDevice::injectConfirmPasskey`.
-- `NimBLEAdvertising::setMinPreferred` and `NimBLEAdvertising::setMaxPreferred` have been removed, use `NimBLEAdvertising::setPreferredParams` instead.
-- Advertising the name and TX power of the device will no longer happen by default and should be set manually by the application.
-- `NimBLEAdvertising::setAdvertisementType` has been renamed to `NimBLEAdvertising::setConnectableMode` to better reflect it's function.
-- `NimBLEAdvertising::setScanResponse` has been renamed to `NimBLEAdvertising::enableScanResponse` to better reflect it's function.
-- `NimBLEAdvertising`; Scan response is no longer enabled by default.
-- `NimBLEAdvertising::start` No longer takes a callback pointer parameter, instead the new method `NimBLEAdvertising::setAdvertisingCompleteCallback` should be used.
-- `NimBLEAdvertisementData::addData` now takes either a `std::vector<uint8_t>` or `uint8_t* + length` instead of `std::string` or `char + length`.
-- `NimBLEAdvertisementData::getPayload` now returns `std::vector<uint8_t>` instead of `std::string`.
-- The callback parameter for `NimBLEScan::start` has been removed and the blocking overload of `NimBLEScan::start` has been replaced by an overload of `NimBLEScan::getResults` with the same parameters.
-- `NimBLEAdvertisedDeviceCallbacks` Has been replaced by `NimBLEScanCallbacks` which contains the following methods: `onResult`, `onScanEnd`, and `onDiscovered
-- - `NimBLEScanCallbacks::onResult`, functions the same as the old `NimBLEAdvertisedDeviceCallbacks::onResult` but now takes aa `const NimBLEAdvertisedDevice*` instead of non-const.
-- - `NimBLEScanCallbacks::onScanEnd`, replaces the scanEnded callback passed to `NimBLEScan::start` and now takes a `const NimBLEScanResults&` and `int reason` parameter.
-- - `NimBLEScanCallbacks::onDiscovered`, This is called immediately when a device is first scanned, before any scan response data is available and takes a `const NimBLEAdvertisedDevice*` parameter.
-- `NimBLEScan::stop` will no longer call the `onScanEnd` callback as the caller should know its been stopped when this is called.
-- `NimBLEScan::clearDuplicateCache` has been removed as it was problematic and only for the esp32. Stop and start the scanner for the same effect.
-- `NimBLEScanResults::getDevice` methods now return `const NimBLEAdvertisedDevice*`.
-- `NimBLEScanResults` iterators are now `const_iterator`.
-- `NimBLEAdvertisedDevice::hasRSSI` removed as redundant, RSSI is always available.
-- `NimBLEAdvertisedDevice::getPayload` now returns `const std::vector<uint8_t>` instead of a pointer to internal memory.
-- `NimBLEAdvertisedDevice` Timestamp removed, if needed then the app should track the time from the callback.
-- `NimBLECharacteristic::notify` no longer takes a `bool is_notification` parameter, instead `indicate()` should be called to send indications.
-- `NimBLECharacteristicCallbacks::onNotify` removed as unnecessary, the library does not call notify without app input.
-- `NimBLECharacteristicCallbacks::onStatus` No longer takes a `status` parameter, refer to the return code for success/failure.
-- `NimBLERemoteCharacteristic::getRemoteService` now returns a `const NimBLERemoteService*` instead of non-const.
-- `NimBLERemoteCharacteristic::readUInt32` Has been removed.
-- `NimBLERemoteCharacteristic::readUInt16` Has been removed.
-- `NimBLERemoteCharacteristic::readUInt8` Has been removed.
-- `NimBLERemoteCharacteristic::readFloat` Has been removed.
-- `NimBLERemoteCharacteristic::registerForNotify` Has been removed.
-- `NimBLERemoteService::getCharacteristics` now returns a `const std::vector<NimBLERemoteCharacteristic*>&` instead of non-const `std::vector<NimBLERemoteCharacteristic*>*`.
-- `NimBLERemoteService::getValue` now returns `NimBLEAttValue` instead of `std::string`.
-- `NimBLEService::getCharacteristics` now returns a `const std::vector<NimBLECharacteristic*>&` instead of std::vector<NimBLECharacteristic *>.
-- `NimBLEUUID::getNative` method replaced with `NimBLEUUID::getBase` which returns a read-only pointer to the underlying `ble_uuid_t` struct.
-- `NimBLEUUID`; `msbFirst` parameter has been removed from constructor, caller should reverse the data first or call the new `reverseByteOrder` method after.
-- `NimBLEAddress::getNative` replaced with `NimBLEAddress::getBase` and now returns a pointer to `const ble_addr_t` instead of a pointer to the address value.
-- `NimBLEAddress::equals` method and `NimBLEAddress::== operator` will now also test if the address types are the same.
-- `NimBLEUtils::dumpGapEvent` function removed.
-- `NimBLEUtils::buildHexData` replaced with `NimBLEUtils::dataToHexString`, which returns a `std::string` containing the hex string.
-- `NimBLEEddystoneTLM::setTemp` now takes an `int16_t` parameter instead of float to be friendly to devices without floating point support.
-- `NimBLEEddystoneTLM::getTemp` now returns `int16_t` to work with devices that don't have floating point support.
-- `NimBLEEddystoneTLM::setData` now takes a reference to * `NimBLEEddystoneTLM::BeaconData` instead of `std::string`.
-- `NimBLEEddystoneTLM::getData` now returns a reference to * `NimBLEEddystoneTLM::BeaconData` instead of `std::string`.
-- `NimBLEBeacon::setData` now takes `const NimBLEBeacon::BeaconData&` instead of `std::string`.
-- `NimBLEBeacon::getData` now returns `const NimBLEBeacon::BeaconData&` instead of `std::string`.
-- `NimBLEHIDDevice::reportMap` renamed to `NimBLEHIDDevice::getReportMap`.
-- `NimBLEHIDDevice::hidControl` renamed to `NimBLEHIDDevice::getHidControl`.
-- `NimBLEHIDDevice::inputReport`renamed to `NimBLEHIDDevice::getInputReport`.
-- `NimBLEHIDDevice::outputReport`renamed to `NimBLEHIDDevice::getOutputReport`.
-- `NimBLEHIDDevice::featureReport`renamed to `NimBLEHIDDevice::getFeatureReport`.
-- `NimBLEHIDDevice::protocolMode`renamed to `NimBLEHIDDevice::getProtocolMode`.
-- `NimBLEHIDDevice::bootOutput`renamed to `NimBLEHIDDevice::getBootOutput`.
-- `NimBLEHIDDevice::pnp`renamed to `NimBLEHIDDevice::setPnp`.
-- `NimBLEHIDDevice::hidInfo`renamed to `NimBLEHIDDevice::setHidInfo`.
-- `NimBLEHIDDevice::deviceInfo`renamed to `NimBLEHIDDevice::getDeviceInfoService`.
-- `NimBLEHIDDevice::hidService`renamed to `NimBLEHIDDevice::getHidService`.
-- `NimBLEHIDDevice::batteryService`renamed to `NimBLEHIDDevice::getBatteryService`.
-
-## Fixed
-- `NimBLEDevice::getPower` and `NimBLEDevice::getPowerLevel` bug worked around for the esp32s3 and esp32c3.
-- `NimBLEDevice::setPower` and `NimBLEDevice::getPower` now support the full power range for all esp devices.
-- `NimBLEDevice::setOwnAddrType` will now correctly apply the provided address type for all devices.
-- `NimBLEDevice::getPower` (esp32) return value is now calculated to support devices with different min/max ranges.
-- Crash if `NimBLEDevice::deinit` is called when the stack has not been initialized.
-- `NimBLEServer` service changed notifications will now wait until the changes have taken effect and the server re-started before indicating the change to peers, reducing difficultly for some clients to update their data.
-- `NimBLEService::getHandle` will now fetch the handle from the stack if not valid to avoid returning an invalid value.
-- `std::vector` input to set/write values template.
-- `NimBLEHIDDevice::pnp` will now set the data correctly.
-- Check for Arduino component 
-- Fixed building with esp-idf version 5.x.
-- Fixed pairing failing when the process was started by the peer first.
-- Fixed building with esp-idf and Arduino component.
-- Workaround for esp32s3 and esp32c3 not returning the correct txPower with some IDF versions.
-
-### Changed
-- `NimBLEClient::secureConnection` now takes an additional parameter `bool async`, if true, will send the secure command and return immediately with a true value for successfully sending the command, else false. This allows for asynchronously securing a connection.
-- Deleting the client instance from the `onDisconnect` callback is now supported.
-- `NimBLEClient::connect` will no longer cancel already in progress connections.
-- `NimBLEClient::setDataLen` now returns bool, true if successful.
-- `NimBLEClient::updateConnParams` now returns bool, true if successful.
-- `NimBLEClient::setPeerAddress` now returns a bool, true on success.
-- `NimBLEDevice::startSecurity` now takes and additional parameter `int* rcPtr` which will provide the return code from the stack if provided.
-- `NimBLEDevice::deleteClient` no longer blocks tasks.
-- `NimBLEDevice::getAddress` will now return the address currently in use.
-- `NimBLEDevice::init` now returns a bool with `true` indicating success.
-- `NimBLEDevice::deinit` now returns a bool with `true` indicating success.
-- `NimBLEDevice::setDeviceName` now returns a bool with `true` indicating success.
-- `NimBLEDevice::setCustomGapHandler` now returns a bool with `true` indicating success.
-- `NimBLEDevice::setOwnAddrType` now returns a bool with `true` indicating success and works with non-esp32 devices.
-- `NimBLEDevice::setPower` now returns a bool value, true = success.
-- `NimBLEDevice::setMTU` now returns a bool value, true = success.
-- `NimBLEDevice::deleteAllBonds` now returns true on success, otherwise false.
-- `NimBLEEddystoneTLM` internal data struct type `BeaconData` is now public and usable by the application.
-- `NimBLEBeacon` internal data struct type `BeaconData` is now public and can be used by the application.
-- Removed tracking of client characteristic subscription status from `NimBLEServer` and `NimBLECharacteristic` and instead uses
-the functions and tracking in the host stack.
-- `NimBLECharacteristic::indicate` now takes the same parameters as `notify`.
-- `NimBLECharacteristic::notify` and `NimBLECharacteristic::indicate` now return a `bool`, true = success.
-- Added optional `connHandle` parameter to `NimBLECharacteristic::notify` to allow for sending notifications to specific clients.
-- `NimBLEServer` Now uses a std::array to store client connection handles instead of std::vector to reduce memory allocation.
-- `NimBLEExtAdvertisement` : All functions that set data now return `bool`, true = success.
-- `NimBLEAdvertising` Advertising data is now stored in instances of `NimBLEAdvertisingData` and old vectors removed.
-- `NimBLEAdvertising::setAdvertisementData` and `NimBLEAdvertising::setScanResponseData` now return `bool`, true = success.
-- Added optional `NimBLEAddress` parameter to `NimBLEAdvertising::start` to allow for directed advertising to a peer.
-- All `NimBLEAdvertising` functions that change data values now return `bool`, true = success.
-- All `NimBLEAdvertisementData` functions that change data values now return `bool`, true = success.
-- `NimBLEAdvertising` advertising complete callback is now defined as std::function to allow for using std::bind for callback functions.
-- `NimBLEAdvertisementData::setName` now takes an optional `bool` parameter to indicate if the name is complete or incomplete, default = complete.
-- `NimBLEAdvertisementData` moved to it's own .h and .cpp files.
-- `NimBLEScan::start` takes a new `bool restart` parameter, default `true`, that will restart an already in progress scan and clear the duplicate filter so all devices will be discovered again.
-- Scan response data that is received without advertisement first will now create the device and send a callback.
-- `NimBLEScan::start` will no longer clear cache or results if scanning is already in progress.
-- `NimBLEScan::start` will now allow the start command to be sent with updated parameters if already scanning.
-- `NimBLEScan::clearResults` will now reset the vector capacity to 0.
-- Host reset will now no longer restart scanning and instead will call `NimBLEScanCallbacks::onScanEnd`.
-- Added optional `index` parameter to `NimBLEAdvertisedDevice::getPayloadByType`
-- `NimBLEAdvertisedDevice::getManufacturerData` now takes an optional index parameter for use in the case of multiple manufacturer data fields.
-- `NimBLEUtils`: Add missing GAP event strings.
-- `NimBLEUtils`: Add missing return code strings.
-- `NimBLEUtils`: Event/error code strings optimized.
-- `NimBLEAttValue` cleanup and optimization.
-- cleaned up code, removed assert/abort calls, replaced with a configurable option to enable debug asserts.
 
 ### Added
-- (esp32 specific) `NimBLEDevice::setPowerLevel` and `NimBLEDevice::getPowerLevel` which take and return the related `esp_power_level* ` types.
-- `NimBLEDevice::setDefaultPhy` which will set the default preferred PHY for all connections.
-- `NimBLEDevice::getConnectedClients`, which returns a vector of pointers to the currently connected client instances.
-- `NimBLEDevice::setOwnAddr` function added, which takes a `uint8_t*` or `NimBLEAddress&` and will set the mac address of the device, returns `bool` true= success.
-- `NimBLEDevice::injectPassKey` Used to send the pairing passkey instead of a return value from the client callback.
-- `NimBLEDevice::injectConfirmPasskey` Used to send the numeric comparison pairing passkey confirmation instead of a return value from the client callback.
 - `NimBLEDevice::setDeviceName` to change the device name after initialization.
-- `NimBLECharacteristic::create2904` which will specifically create a Characteristic Presentation Format (0x2904) descriptor.
-- `NimBLEAdvertising::refreshAdvertisingData` refreshes the advertisement data while still actively advertising.
-- `NimBLEClient::updatePhy` to request a PHY change with a peer.
-- `NimBLEClient::getPhy` to read the current connection PHY setting.
-- `Config` struct to `NimBLEClient` to efficiently set single bit config settings.
-- `NimBLEClient::setSelfDelete` that takes the bool parameters `deleteOnDisconnect` and `deleteOnConnectFail`, which will configure the client to delete itself when disconnected or the connection attempt fails.
-- `NimBLEClient::setConfig` and `NimBLEClient::getConfig` which takes or returns a `NimBLEClient::Config` object respectively.
-- `NimBLEClient::cancelConnect()` to cancel an in-progress connection, returns `bool`, true = success.
-- Non-blocking `NimBLEClient::connect` option added via 2 new `bool` parameters added to the function:
-- * `asyncConnect`; if true, will send the connect command and return immediately.
-- * `exchangeMTU`; if true will send the exchange MTU command upon connection.
-- `NimBLEClientCallbacks::onConnectFail` callback that is called when the connection attempt fail while connecting asynchronously.
-- `NimBLEClientCallbacks::onMTUChange` callback which will be called when the MTU exchange completes and takes a `NimBLEClient*` and `uint16_t MTU` parameter.
-- `NimBLEClientCallbacks::onPhyUpdate` and -`NimBLEServerCallbacks::onPhyUpdate` Which are called when the PHY update is complete.
-- Extended scan example.
-- `NimBLEServer::updatePhy` to request a PHY change with a peer.
-- `NimBLEServer::getPhy` to read the PHY of a peer connection.
-- `NimBLEServer::getClient` which will create a client instance from the provided peer connHandle or connInfo to facilitate reading/write from the connected client.
-- `NimBLEServerCallbacks::onConnParamsUpdate` callback.
-- `NimBLEScan::erase` overload that takes a `const NimBLEAdvertisedDevice*` parameter.
-- `NimBLEScan::setScanPhy` to enable/disable the PHY's to scan on (extended advertising only).
-- `NimBLEScan::setScanPeriod` which will allow for setting a scan restart timer in the controller (extended advertising only).
-- `NimBLEAdvertisedDevice::isScannable()` that returns true if the device is scannable.
-- `NimBLEAdvertisedDevice::begin` and `NimBLEAdvertisedDevice::end` read-only iterators for convenience and use in range loops.
-- `NimBLEAdvertisedDevice::getAdvFlags` returns the advertisement flags of the advertiser.
-- `NimBLEAdvertisedDevice::getPayloadByType` Generic use function that returns the data from the advertisement with the specified type.
-- `NimBLEAdvertisedDevice::haveType` Generic use function that returns true if the advertisement data contains a field with the specified type.
-- Support for esp32c6, esp32c2, esp32h2, and esp32p4.
-- `NimBLEExtAdvertisement::removeData`, which will remove the data of the specified type from the advertisement.
-- `NimBLEExtAdvertisement::addServiceUUID`, which will append to the service uuids advertised.
-- `NimBLEExtAdvertisement::removeServiceUUID`, which will remove the service from the uuids advertised.
-- `NimBLEExtAdvertisement::removeServices`, which will remove all service uuids advertised.
-- New overloads for `NimBLEExtAdvertisement::setServiceData` with the parameters `const NimBLEUUID& uuid, const uint8_t* data, size_t length` and `const NimBLEUUID& uuid, const std::vector<uint8_t>& data`.
-- `NimBLEExtAdvertisement::getDataLocation`, which returns the location in the advertisement data of the type requested in parameter `uint8_t type`.
-- `NimBLEExtAdvertisement::toString` which returns a hex string representation of the advertisement data.
-- `NimBLEAdvertising::getAdvertisementData`, which returns a reference to the currently set advertisement data.
-- `NimBLEAdvertising::getScanData`, which returns a reference to the currently set scan response data.
-- New overloads for `NimBLEAdvertising::removeServiceUUID` and `NimBLEAdvertisementData::removeServiceUUID` to accept a `const char*`
-- `NimBLEAdvertising::clearData`, which will clear the advertisement and scan response data.
-- `NimBLEAdvertising::setManufacturerData` Overload that takes a `const uint8_t*` and , size_t` parameter.
-- `NimBLEAdvertising::setServiceData` Overload that takes `const NimBLEUUID& uuid`, ` const uint8_t* data`, ` size_t length` as parameters.
-- `NimBLEAdvertising::setServiceData` Overload that takes `const NimBLEUUID& uuid`, `const std::vector<uint8_t>&` as parameters.
-- `NimBLEAdvertising::setDiscoverableMode` to allow applications to control the discoverability of the advertiser.
-- `NimBLEAdvertising::setAdvertisingCompleteCallback` sets the callback to call when advertising ends.
-- `NimBLEAdvertising::setPreferredParams` that takes the min and max preferred connection parameters as an alternative for `setMinPreferred` and `setMaxPreferred`.
-- `NimBLEAdvertising::setAdvertisingInterval` Sets the advertisement interval for min and max to the same value instead of calling `setMinInterval` and `setMaxInterval` separately if there is not value difference.
-- `NimBLEAdvertisementData::removeData`, which takes a parameter `uint8_t type`, the data type to remove.
-- `NimBLEAdvertisementData::toString`, which will print the data in hex.
-- `NimBLEUtils::taskWait` which causes the calling task to wait for an event.
-- `NimBLEUtils::taskRelease` releases the task from and event.
-- `NimBLEUtils::generateAddr` function added with will generate a random address and takes a `bool` parameter, true = create non-resolvable private address, otherwise a random static address is created, returns `NimBLEAddress`.
-- `NimBLEUUID::getValue` which returns a read-only `uint8_t` pointer to the UUID value.
-- `NimBLEUUID::reverseByteOrder`, this will reverse the bytes of the UUID, which can be useful for advertising/logging.
-- `NimBLEUUID` constructor overload that takes a reference to `ble_uuid_any_t`.
-- `NimBLEAddress::isNrpa` method to test if an address is random non-resolvable.
-- `NimBLEAddress::isStatic` method to test if an address is random static.
-- `NimBLEAddress::isPublic` method to test if an address is a public address.
-- `NimBLEAddress::isNull` methods to test if an address is NULL.
-- `NimBLEAddress::getValue` method which returns a read-only pointer to the address value.
-- `NimBLEAddress::reverseByteOrder` method which will reverse the byte order of the address value.
 - `NimBLEHIDDevice::batteryLevel` returns the HID device battery level characteristic.
-- `NimBLEBeacon::setData` overload that takes `uint8_t* data` and `uint8_t length`.
-- `NimBLEHIDDevice::getPnp` function added to access the pnp characteristic.
-- `NimBLEHIDDevice::getHidInfo` function added to access the hid info characteristic.
-
-## [1.4.1] - 2022-10-30
-
-### Fixed
- - NimBLEDevice::getPower incorrect value when power level is -3db.
- - Failed pairing when already in progress.
-
-### Changed
- - Revert previous change that forced writing with response when subscribing in favor of allowing the application to decide.
-
-### Added
- - Added NimBLEHIDDevice::batteryLevel.
- - Added NimBLEDevice::setDeviceName allowing for changing the device name while the BLE stack is active.
- - CI Builds
 
 ## [1.4.0] - 2022-07-31
 
@@ -296,7 +71,7 @@ the functions and tracking in the host stack.
 ## [1.3.0] - 2021-08-02
 
 ### Added
-- `NimBLECharacteristic::removeDescriptor`: Dynamically remove a descriptor from a characteristic. Takes effect after all connections are closed and sends a service changed indication.
+- `NimBLECharacteristic::removeDescriptor`: Dynamically remove a descriptor from a characterisic. Takes effect after all connections are closed and sends a service changed indication.
 - `NimBLEService::removeCharacteristic`: Dynamically remove a characteristic from a service. Takes effect after all connections are closed and sends a service changed indication
 - `NimBLEServerCallbacks::onMTUChange`: This is callback is called when the MTU is updated after connection with a client.
 - ESP32C3 support
@@ -327,12 +102,12 @@ the functions and tracking in the host stack.
 ### Fixed
 - `NimBLECharacteristicCallbacks::onSubscribe` Is now called after the connection is added to the vector.
 - Corrected bonding failure when reinitializing the BLE stack.
-- Writing to a characteristic with a std::string value now correctly writes values with null characters.
-- Retrieving remote descriptors now uses the characteristic end handle correctly.
+- Writing to a characterisic with a std::string value now correctly writes values with null characters.
+- Retrieving remote descriptors now uses the characterisic end handle correctly.
 - Missing data in long writes to remote descriptors.
 - Hanging on task notification when sending an indication from the characteristic callback.
 - BLE controller memory could be released when using Arduino as a component.
-- Compile errors with NimBLE release 1.3.0.
+- Complile errors with NimBLE release 1.3.0.
 
 ## [1.2.0] - 2021-02-08
 
@@ -345,7 +120,7 @@ the functions and tracking in the host stack.
 
 - `NimBLEService::getCharacteristicByHandle`: Get a pointer to the characteristic object with the specified handle.
 
-- `NimBLEService::getCharacteristics`: Get the vector containing pointers to each characteristic associated with this service.
+- `NimBLEService::getCharacteristics`: Get the vector containing pointers to each characteristic associated with this service.  
 Overloads to get a vector containing pointers to all the characteristics in a service with the UUID. (supports multiple same UUID's in a service)
   - `NimBLEService::getCharacteristics(const char *uuid)`
   - `NimBLEService::getCharacteristics(const NimBLEUUID &uuid)`
@@ -387,12 +162,12 @@ Overloads to get a vector containing pointers to all the characteristics in a se
 
 - `NimBLEAdvertising` Transmission power is no longer advertised by default and can be added to the advertisement by calling `NimBLEAdvertising::addTxPower`
 
-- `NimBLEAdvertising` Custom scan response data can now be used without custom advertisement.
+- `NimBLEAdvertising` Custom scan response data can now be used without custom advertisment.
 
-- `NimBLEScan` Now uses the controller duplicate filter.
+- `NimBLEScan` Now uses the controller duplicate filter.  
 
-- `NimBLEAdvertisedDevice` Has been refactored to store the complete advertisement payload and no longer parses the data from each advertisement.
-Instead the data will be parsed on-demand when the user application asks for specific data.
+- `NimBLEAdvertisedDevice` Has been refactored to store the complete advertisement payload and no longer parses the data from each advertisement.  
+Instead the data will be parsed on-demand when the user application asks for specific data.  
 
 ### Fixed
 - `NimBLEHIDDevice` Characteristics now use encryption, this resolves an issue with communicating with devices requiring encryption for HID devices.
@@ -401,84 +176,84 @@ Instead the data will be parsed on-demand when the user application asks for spe
 ## [1.1.0] - 2021-01-20
 
 ### Added
-- `NimBLEDevice::setOwnAddrType` added to enable the use of random and random-resolvable addresses, by asukiaaa
+- `NimBLEDevice::setOwnAddrType` added to enable the use of random and random-resolvable addresses, by asukiaaa  
 
-- New examples for securing and authenticating client/server connections, by mblasee.
+- New examples for securing and authenticating client/server connections, by mblasee.  
 
-- `NimBLEAdvertising::SetMinPreferred` and `NimBLEAdvertising::SetMinPreferred` re-added.
+- `NimBLEAdvertising::SetMinPreferred` and `NimBLEAdvertising::SetMinPreferred` re-added.  
 
-- Conditional checks added for command line config options in `nimconfig.h` to support custom configuration in platformio.
+- Conditional checks added for command line config options in `nimconfig.h` to support custom configuration in platformio.  
 
-- `NimBLEClient::setValue` Now takes an extra bool parameter `response` to enable the use of write with response (default = false).
+- `NimBLEClient::setValue` Now takes an extra bool parameter `response` to enable the use of write with response (default = false).  
 
-- `NimBLEClient::getCharacteristic(uint16_t handle)` Enabling the use of the characteristic handle to be used to find
-the NimBLERemoteCharacteristic object.
+- `NimBLEClient::getCharacteristic(uint16_t handle)` Enabling the use of the characteristic handle to be used to find 
+the NimBLERemoteCharacteristic object.  
 
-- `NimBLEHIDDevice` class added by wakwak-koba.
+- `NimBLEHIDDevice` class added by wakwak-koba.  
 
-- `NimBLEServerCallbacks::onDisconnect` overloaded callback added to provide a ble_gap_conn_desc parameter for the application
-to obtain information about the disconnected client.
+- `NimBLEServerCallbacks::onDisconnect` overloaded callback added to provide a ble_gap_conn_desc parameter for the application  
+to obtain information about the disconnected client.  
 
-- Conditional checks in `nimconfig.h` for command line defined macros to support platformio config settings.
+- Conditional checks in `nimconfig.h` for command line defined macros to support platformio config settings.  
 
 ### Changed
-- `NimBLEAdvertising::start` now returns a bool value to indicate success/failure.
+- `NimBLEAdvertising::start` now returns a bool value to indicate success/failure.  
 
-- Some asserts were removed in `NimBLEAdvertising::start` and replaced with better return code handling and logging.
+- Some asserts were removed in `NimBLEAdvertising::start` and replaced with better return code handling and logging.    
 
-- If a host reset event occurs, scanning and advertising will now only be restarted if their previous duration was indefinite.
+- If a host reset event occurs, scanning and advertising will now only be restarted if their previous duration was indefinite.  
 
 - `NimBLERemoteCharacteristic::subscribe` and `NimBLERemoteCharacteristic::registerForNotify` will now set the callback
-regardless of the existence of the CCCD and return true unless the descriptor write operation failed.
+regardless of the existance of the CCCD and return true unless the descriptor write operation failed.  
 
-- Advertising tx power level is now sent in the advertisement packet instead of scan response.
+- Advertising tx power level is now sent in the advertisement packet instead of scan response.  
 
-- `NimBLEScan` When the scan ends the scan stopped flag is now set before calling the scan complete callback (if used)
-this allows the starting of a new scan from the callback function.
+- `NimBLEScan` When the scan ends the scan stopped flag is now set before calling the scan complete callback (if used)  
+this allows the starting of a new scan from the callback function.  
 
 ### Fixed
-- Sometimes `NimBLEClient::connect` would hang on the task block if no event arrived to unblock.
-A time limit has been added to timeout appropriately.
+- Sometimes `NimBLEClient::connect` would hang on the task block if no event arrived to unblock.  
+A time limit has been added to timeout appropriately.  
 
-- When getting descriptors for a characteristic the end handle of the service was used as a proxy for the characteristic end
-handle. This would be rejected by some devices and has been changed to use the next characteristic handle as the end when possible.
+- When getting descriptors for a characterisic the end handle of the service was used as a proxy for the characteristic end  
+handle. This would be rejected by some devices and has been changed to use the next characteristic handle as the end when possible.  
 
-- An exception could occur when deleting a client instance if a notification arrived while the attribute vectors were being
-deleted. A flag has been added to prevent this.
+- An exception could occur when deleting a client instance if a notification arrived while the attribute vectors were being  
+deleted. A flag has been added to prevent this.  
+  
+- An exception could occur after a host reset event when the host re-synced if the tasks that were stopped during the event did  
+not finish processing. A yield has been added after re-syncing to allow tasks to finish before proceeding.  
+  
+- Occasionally the controller would fail to send a disconnected event causing the client to indicate it is connected  
+and would be unable to reconnect. A timer has been added to reset the host/controller if it expires.  
+  
+- Occasionally the call to start scanning would get stuck in a loop on BLE_HS_EBUSY, this loop has been removed.  
 
-- An exception could occur after a host reset event when the host re-synced if the tasks that were stopped during the event did
-not finish processing. A yield has been added after re-syncing to allow tasks to finish before proceeding.
+- 16bit and 32bit UUID's in some cases were not discovered or compared correctly if the device  
+advertised them as 16/32bit but resolved them to 128bits. Both are now checked.  
+  
+- `FreeRTOS` compile errors resolved in latest Ardruino core and IDF v3.3.  
 
-- Occasionally the controller would fail to send a disconnected event causing the client to indicate it is connected
-and would be unable to reconnect. A timer has been added to reset the host/controller if it expires.
+- Multiple instances of `time()` called inside critical sections caused sporadic crashes, these have been moved out of critical regions.  
 
-- Occasionally the call to start scanning would get stuck in a loop on BLE_HS_EBUSY, this loop has been removed.
+- Advertisement type now correctly set when using non-connectable (advertiser only) mode.  
 
-- 16bit and 32bit UUID's in some cases were not discovered or compared correctly if the device
-advertised them as 16/32bit but resolved them to 128bits. Both are now checked.
+- Advertising payload length correction, now accounts for appearance.  
 
-- `FreeRTOS` compile errors resolved in latest Arduino core and IDF v3.3.
-
-- Multiple instances of `time()` called inside critical sections caused sporadic crashes, these have been moved out of critical regions.
-
-- Advertisement type now correctly set when using non-connectable (advertiser only) mode.
-
-- Advertising payload length correction, now accounts for appearance.
-
-- (Arduino) Ensure controller mode is set to BLE Only.
+- (Arduino) Ensure controller mode is set to BLE Only.  
 
 
 ## [1.0.2] - 2020-09-13
 
 ### Changed
 
-- `NimBLEAdvertising::start` Now takes 2 optional parameters, the first is the duration to advertise for (in seconds), the second is a
-callback that is invoked when advertising ends and takes a pointer to a `NimBLEAdvertising` object (similar to the `NimBLEScan::start` API).
+- `NimBLEAdvertising::start` Now takes 2 optional parameters, the first is the duration to advertise for (in seconds), the second is a  
+callback that is invoked when advertsing ends and takes a pointer to a `NimBLEAdvertising` object (similar to the `NimBLEScan::start` API).
 
 - (Arduino) Maximum BLE connections can now be altered by only changing the value of `CONFIG_BT_NIMBLE_MAX_CONNECTIONS` in `nimconfig.h`.
 Any changes to the controller max connection settings in `sdkconfig.h` will now have no effect when using this library.
 
-- (Arduino) Revert the previous change to fix the advertising start delay. Instead a replacement fix that routes all BLE controller commands from
+- (Arduino) Revert the previous change to fix the advertising start delay. Instead a replacement fix that routes all BLE controller commands from  
 a task running on core 0 (same as the controller) has been implemented. This improves response times and reliability for all BLE functions.
 
 

CMakeLists.txt

@@ -44,7 +44,6 @@ idf_component_register(
     "src/NimBLE2904.cpp"
     "src/NimBLEAddress.cpp"
     "src/NimBLEAdvertisedDevice.cpp"
-    "src/NimBLEAdvertisementData.cpp"
     "src/NimBLEAdvertising.cpp"
     "src/NimBLEAttValue.cpp"
     "src/NimBLEBeacon.cpp"
@@ -53,6 +52,7 @@ idf_component_register(
     "src/NimBLEDescriptor.cpp"
     "src/NimBLEDevice.cpp"
     "src/NimBLEEddystoneTLM.cpp"
+    "src/NimBLEEddystoneURL.cpp"
     "src/NimBLEExtAdvertising.cpp"
     "src/NimBLEHIDDevice.cpp"
     "src/NimBLERemoteCharacteristic.cpp"

docs/1.x_to2.x_migration_guide.md

@@ -1,165 +0,0 @@
-# Migrating from 1.x to 2.x
-
-Nearly all of the codebase has been updated and changed under the surface, which has greatly reduced the resource use of the library and improved it's performance. To be able to support these changes it required various API changes and additions.
-
-This guide will help you migrate your application code to use the new API.
-
-The changes listed here are only the required changes that must be made, and a short overview of options for migrating existing applications.
-
-* [General changes](#general-changes)
-* [BLE Device](#ble-device)
-* [BLE Addresses](#ble-addresses)
-* [BLE UUID's](#ble-uuids)
-* [Server](#server)
-    * [Services](#services)
-    * [Characteristics](#characteristics)
-    * [Characteristic Callbacks](#characteristic-callbacks)
-    * [Security](#server)
-* [Client](#client)
-    * [Client Callbacks](#client-callbacks)
-    * [Remote Services](#remote-services)
-    * [Remote characteristics](#remote-characteristics)
-* [Scanning](#scan)
-    * [Advertise device](#advertised-device)
-* [Advertising](#advertising)
-* [Beacons](#beacons)
-* [Utilities](#utilities)  
-<br/>
-
-## General changes
-- All functions that take a time parameter now require the time in milliseconds instead of seconds, i.e. `NimBLEScan::start(10000); // 10 seconds`
-- `NimBLESecurity` class has been removed it's functionality has been merged into the `NimBLEServer` and `NimBLEClient` classes.
-- All connection oriented callbacks now receive a reference to `NimBLEConnInfo` and the `ble_gap_conn_desc` parameter has been replaced with `NimBLEConnInfo` in the functions that received it.  
-    For instance `onAuthenticationComplete(ble_gap_conn_desc* desc)` signature is now `onAuthenticationComplete(NimBLEConnInfo& connInfo)` and  
-    `NimBLEServerCallbacks::onConnect(NimBLEServer* pServer)` signature is now `NimBLEServerCallbacks::onConnect(NimBLEServer* pServer, NimBLEConnInfo& connInfo)`.  
-<br/>
-
-## BLE Device
-- Ignore list functions and vector have been removed, the application should implement this if desired. It was no longer used by the library.
-- `NimBLEDevice::startSecurity` now returns a `bool`, true on success, instead of an int to be consistent with the rest of the library.
-- `NimBLEDevice::getInitialized` renamed to `NimBLEDevice::isInitialized`.
-- `NimBLEDevice::setPower` no longer takes the `esp_power_level_t` and `esp_ble_power_type_t`, instead only an integer value in dbm units is accepted, so instead of `ESP_PWR_LVL_P9` an `int8_t` value of `9` would be used for the same result.
-- `NimBLEDevice::setOwnAddrType` no longer takes a `bool nrpa` parameter, the random address type will be determined by the bits the in the address instead.  
-    Note: If setting a custom address, it should be set with `NimBLEDevice::setOwnAddr` first before calling  `NimBLEDevice::setOwnAddrType`.
-- `NimBLEDevice::getClientListSize` replaced with `NimBLEDevice::getCreatedClientCount`.
-- `NimBLEDevice::getClientList` was removed and `NimBLEDevice::getConnectedClients` can be used instead which returns a `std::vector` of pointers to the connected client instances. This was done because internally the clients are managed in a `std::array` which replaced the 'std::list`.  
-<br/>
-
-## BLE Addresses
-NimBLEAddress comparisons have changed to now consider the address type. If 2 address values are the same but the type is different then they are no longer considered equal. This is a correction to the 1.x version which did not consider the type, whereas the BLE specification states:
-> Whenever two device addresses are compared, the comparison shall include the device address type (i.e. if the two addresses have different types, they are different even if the two 48-bit addresses are the same).
-
-This means that if in your application you create a NimBLEAddress instance and are comparing a scan result or some other address created by the library and you did not define the address type then the comparison may fail.
-The default address type is public `0`, whereas many devices use a random `1` address type.
-If you experience this issue please create your address instances with the address type specified, i.e. `NimBLEAddress address("11:22:33:44:55:66", TYPE_HERE)`
-
-`NimBLEAddress::getNative` has been removed and replaced with `NimBLEAddress::getBase`.
-This returns a pointer to `const ble_addr_t` instead of a pointer to the address value that `getNative` did. The value can be accessed through this struct via `ble_addr_t.value` and type is in `ble_addr_t.type`.  
-<br/>
-
-## BLE UUID's
-- `NimBLEUUID::getNative` method replaced with `NimBLEUUID::getBase` which returns a read-only pointer to the underlying `ble_uuid_t` struct.
-- `NimBLEUUID`; `msbFirst` parameter has been removed from constructor, caller should reverse the data first or call the new `NimBLEUUID::reverseByteOrder` method after.  
-<br/>
-
-## Server
-- `NimBLEServer::disconnect` now returns `bool`, true = success,  instead of `int` to be consistent with the rest of the library.
-- `NimBLEServerCallbacks::onMTUChanged` renamed to `NimBLEServerCallbacks::onMTUChange` to be consistent with the client callback.
-- `NimBLEServer::getPeerIDInfo` renamed to `NimBLEServer::getPeerInfoByHandle` to better describe it's use.  
-<br/>
-
-### Services
-- `NimBLEService::getCharacteristics` now returns a `const std::vector<NimBLECharacteristic*>&` instead of a copy of the vector.  
-<br/>
-
-### Characteristics
-- `NimBLECharacteristic::notify` no longer takes a `bool is_notification` parameter, instead `NimBLECharacteristic::indicate` should be called to send indications.  
-<br/>
-
-#### Characteristic callbacks
-- `NimBLECharacteristicCallbacks::onNotify` removed as unnecessary, the library does not call notify without app input.
-- `NimBLECharacteristicCallbacks::onStatus` No longer takes a `status` parameter, refer to the return code parameter for success/failure.  
-<br/>
-
-### Server Security
-- `NimBLEServerCallbacks::onPassKeyRequest` has been renamed to `NimBLEServerCallbacks::onPassKeyDisplay` as it is intended that the device should display the passkey for the client to enter.
-- `NimBLEServerCallbacks::onAuthenticationComplete` now takes a `NimBLEConnInfo&` parameter.  
-<br/>
-
-## Client
-- `NimBLEClient::getServices` now returns a const reference to std::vector<NimBLERemoteService*> instead of a pointer to the internal vector.
-- `NimBLEClient::getConnId` has been renamed to `getConnHandle` to be consistent with bluetooth terminology.
-- `NimBLEClient::disconnect` now returns a `bool`, true on success, instead of an `int` to be consistent with the rest of the library.  
-<br/>
-
-### Client callbacks
-- `NimBLEClientCallbacks::onConfirmPIN` renamed to `NimBLEClientCallbacks::onConfirmPasskey`,  takes a `NimBLEConnInfo&` parameter and no longer returns a value. This should be used to prompt a user to confirm the pin on the display (YES/NO) after which the response should be sent with `NimBLEDevice::injectConfirmPasskey`.
-- `NimBLEClientCallbacks::onPassKeyRequest` has been changed to `NimBLEClientCallbacks::onPassKeyEntry` which takes a `NimBLEConnInfo&` parameter and no longer returns a value. Instead of returning a value this callback should prompt a user to enter a passkey number which is sent later via `NimBLEDevice::injectPassKey`.  
-<br/>
-
-### Remote Services
-- `NimBLERemoteService::getCharacteristics` now returns a `const std::vector<NimBLERemoteCharacteristic*>&` instead of non-const `std::vector<NimBLERemoteCharacteristic*>*`.  
-<br/>
-
-### Remote Characteristics
-- `NimBLERemoteCharacteristic::getRemoteService` now returns a `const NimBLERemoteService*` instead of non-const.
-- `NimBLERemoteCharacteristic::registerForNotify`, has been removed, the application should use `NimBLERemoteCharacteristic::subscribe` and `NimBLERemoteCharacteristic::unSubscribe`.
-
-        `NimBLERemoteCharacteristic::readUInt32`
-        `NimBLERemoteCharacteristic::readUInt16`
-        `NimBLERemoteCharacteristic::readUInt8`
-        `NimBLERemoteCharacteristic::readFloat`
-
-Have been removed, instead the application should use `NimBLERemoteCharacteristic::readValue<type\>`.  
-<br/>
-
-## Scan
-- `NimBLEScan::stop` will no longer call the `onScanEnd` callback as the caller should know it has been stopped either by initiating a connection or calling this function itself.
-- `NimBLEScan::clearDuplicateCache` has been removed as it was problematic and only for the original esp32. The application should stop and start the scanner for the same effect or call `NimBLEScan::start` with the new `bool restart` parameter set to true.
-- `NimBLEScanResults::getDevice` methods now return `const NimBLEAdvertisedDevice*` instead of a non-const pointer.
-- `NimBLEScanResults` iterators are now `const_iterator`.
-- The callback parameter for `NimBLEScan::start` has been removed and the blocking overload of `NimBLEScan::start` has been replaced by an overload of `NimBLEScan::getResults` with the same parameters.
-
-    So if your code prior was this:
-
-        NimBLEScanResults results = pScan->start(10, false);
-
-    It should now be:
-
-        NimBLEScanResults results = pScan->getResults(10000, false); // note the time is now in milliseconds
-
-- `NimBLEAdvertisedDeviceCallbacks` Has been replaced by `NimBLEScanCallbacks` which contains the following methods:
-- - `NimBLEScanCallbacks::onResult`, functions the same as the old `NimBLEAdvertisedDeviceCallbacks::onResult` but now takes aa `const NimBLEAdvertisedDevice*` instead of non-const.
-- - `NimBLEScanCallbacks::onScanEnd`, replaces the scanEnded callback passed to `NimBLEScan::start` and now takes a `const NimBLEScanResults&` and `int reason` parameter.
-- - `NimBLEScanCallbacks::onDiscovered`, This is called immediately when a device is first scanned, before any scan response data is available and takes a `const NimBLEAdvertisedDevice*` parameter.  
-<br/>
-
-### Advertised Device
-- `NimBLEAdvertisedDevice::hasRSSI` removed as redundant, RSSI is always available.
-- `NimBLEAdvertisedDevice::getPayload` now returns `const std::vector<uint8_t>&` instead of a pointer to internal memory.
-- `NimBLEAdvertisedDevice` Timestamp removed, if needed then the app should track the time from the callback.  
-<br/>
-
-## Advertising
-- `NimBLEAdvertising::setMinPreferred` and `NimBLEAdvertising::setMaxPreferred` have been removed and replaced by `NimBLEAdvertising::setPreferredParams` which takes both the min and max parameters.
-- Advertising the name and TX power of the device will no longer happen by default and should be set manually by the application using `NimBLEAdvertising::setName` and `NimBLEAdvertising::addTxPower`.
-- `NimBLEAdvertising::setAdvertisementType` has been renamed to `NimBLEAdvertising::setConnectableMode` to better reflect it's function.
-- `NimBLEAdvertising::setScanResponse` has been renamed to `NimBLEAdvertising::enableScanResponse` to better reflect it's function.
-- `NimBLEAdvertising`; Scan response is no longer enabled by default.
-- `NimBLEAdvertising::start` No longer takes a callback pointer parameter, instead the new method `NimBLEAdvertising::setAdvertisingCompleteCallback` should be used to set the callback function.  
-<br/>
-
-## Beacons
-- Removed Eddystone URL as it has been shutdown by google since 2021.
-- `NimBLEEddystoneTLM::setTemp` now takes an `int16_t` parameter instead of float to be friendly to devices without floating point support.
-- `NimBLEEddystoneTLM::getTemp` now returns `int16_t` to work with devices that don't have floating point support.
-- `NimBLEEddystoneTLM::setData` now takes a reference to * `NimBLEEddystoneTLM::BeaconData` instead of `std::string`.
-- `NimBLEEddystoneTLM::getData` now returns a reference to * `NimBLEEddystoneTLM::BeaconData` instead of `std::string`.
-- `NimBLEBeacon::setData` now takes `const NimBLEBeacon::BeaconData&` instead of `std::string`.
-- `NimBLEBeacon::getData` now returns `const NimBLEBeacon::BeaconData&` instead of `std::string`.  
-<br/>
-
-## Utilities
-- `NimBLEUtils::dumpGapEvent` function removed.
-- `NimBLEUtils::buildHexData` replaced with `NimBLEUtils::dataToHexString`, which returns a `std::string` containing the hex string.  
-<br/>

docs/Doxyfile

@@ -1,4 +1,4 @@
-# Doxyfile 1.10.0
+# Doxyfile 1.9.5
 
 # This file describes the settings to be used by the documentation system
 # doxygen (www.doxygen.org) for a project.
@@ -48,7 +48,7 @@ PROJECT_NAME           = esp-nimble-cpp
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 2.0.0
+PROJECT_NUMBER         = 1.4.1
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
@@ -63,12 +63,6 @@ PROJECT_BRIEF          =
 
 PROJECT_LOGO           =
 
-# With the PROJECT_ICON tag one can specify an icon that is included in the tabs
-# when the HTML document is shown. Doxygen will copy the logo to the output
-# directory.
-
-PROJECT_ICON           =
-
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
 # into which the generated documentation will be written. If a relative path is
 # entered, it will be relative to the location where doxygen was started. If
@@ -92,7 +86,7 @@ CREATE_SUBDIRS         = NO
 # level increment doubles the number of directories, resulting in 4096
 # directories at level 8 which is the default and also the maximum value. The
 # sub-directories are organized in 2 levels, the first level always has a fixed
-# number of 16 directories.
+# numer of 16 directories.
 # Minimum value: 0, maximum value: 8, default value: 8.
 # This tag requires that the tag CREATE_SUBDIRS is set to YES.
 
@@ -369,17 +363,6 @@ MARKDOWN_SUPPORT       = YES
 
 TOC_INCLUDE_HEADINGS   = 5
 
-# The MARKDOWN_ID_STYLE tag can be used to specify the algorithm used to
-# generate identifiers for the Markdown headings. Note: Every identifier is
-# unique.
-# Possible values are: DOXYGEN use a fixed 'autotoc_md' string followed by a
-# sequence number starting at 0 and GITHUB use the lower case version of title
-# with any whitespace replaced by '-' and punctuation characters removed.
-# The default value is: DOXYGEN.
-# This tag requires that the tag MARKDOWN_SUPPORT is set to YES.
-
-MARKDOWN_ID_STYLE      = GITHUB
-
 # When enabled doxygen tries to link words that correspond to documented
 # classes, or namespaces to their corresponding documentation. Such a link can
 # be prevented in individual cases by putting a % sign in front of the word or
@@ -504,14 +487,6 @@ LOOKUP_CACHE_SIZE      = 0
 
 NUM_PROC_THREADS       = 1
 
-# If the TIMESTAMP tag is set different from NO then each generated page will
-# contain the date or date and time when the page was generated. Setting this to
-# NO can help when comparing the output of multiple runs.
-# Possible values are: YES, NO, DATETIME and DATE.
-# The default value is: NO.
-
-TIMESTAMP              = NO
-
 #---------------------------------------------------------------------------
 # Build related configuration options
 #---------------------------------------------------------------------------
@@ -593,8 +568,7 @@ HIDE_UNDOC_MEMBERS     = YES
 # If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
 # undocumented classes that are normally visible in the class hierarchy. If set
 # to NO, these classes will be included in the various overviews. This option
-# will also hide undocumented C++ concepts if enabled. This option has no effect
-# if EXTRACT_ALL is enabled.
+# has no effect if EXTRACT_ALL is enabled.
 # The default value is: NO.
 
 HIDE_UNDOC_CLASSES     = YES
@@ -885,29 +859,14 @@ WARN_IF_INCOMPLETE_DOC = YES
 
 WARN_NO_PARAMDOC       = NO
 
-# If WARN_IF_UNDOC_ENUM_VAL option is set to YES, doxygen will warn about
-# undocumented enumeration values. If set to NO, doxygen will accept
-# undocumented enumeration values. If EXTRACT_ALL is set to YES then this flag
-# will automatically be disabled.
-# The default value is: NO.
-
-WARN_IF_UNDOC_ENUM_VAL = NO
-
 # If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when
 # a warning is encountered. If the WARN_AS_ERROR tag is set to FAIL_ON_WARNINGS
 # then doxygen will continue running as if WARN_AS_ERROR tag is set to NO, but
 # at the end of the doxygen process doxygen will return with a non-zero status.
-# If the WARN_AS_ERROR tag is set to FAIL_ON_WARNINGS_PRINT then doxygen behaves
-# like FAIL_ON_WARNINGS but in case no WARN_LOGFILE is defined doxygen will not
-# write the warning messages in between other messages but write them at the end
-# of a run, in case a WARN_LOGFILE is defined the warning messages will be
-# besides being in the defined file also be shown at the end of a run, unless
-# the WARN_LOGFILE is defined as - i.e. standard output (stdout) in that case
-# the behavior will remain as with the setting FAIL_ON_WARNINGS.
-# Possible values are: NO, YES, FAIL_ON_WARNINGS and FAIL_ON_WARNINGS_PRINT.
+# Possible values are: NO, YES and FAIL_ON_WARNINGS.
 # The default value is: NO.
 
-WARN_AS_ERROR          = NO
+WARN_AS_ERROR          = YES
 
 # The WARN_FORMAT tag determines the format of the warning messages that doxygen
 # can produce. The string should contain the $file, $line, and $text tags, which
@@ -984,12 +943,12 @@ INPUT_FILE_ENCODING    =
 # Note the list of default checked file patterns might differ from the list of
 # default file extension mappings.
 #
-# If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cxxm,
-# *.cpp, *.cppm, *.ccm, *.c++, *.c++m, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl,
-# *.idl, *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp, *.h++, *.ixx, *.l, *.cs, *.d,
-# *.php, *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown, *.md, *.mm, *.dox (to
-# be provided as doxygen C comment), *.py, *.pyw, *.f90, *.f95, *.f03, *.f08,
-# *.f18, *.f, *.for, *.vhd, *.vhdl, *.ucf, *.qsf and *.ice.
+# If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
+# *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
+# *.hh, *.hxx, *.hpp, *.h++, *.l, *.cs, *.d, *.php, *.php4, *.php5, *.phtml,
+# *.inc, *.m, *.markdown, *.md, *.mm, *.dox (to be provided as doxygen C
+# comment), *.py, *.pyw, *.f90, *.f95, *.f03, *.f08, *.f18, *.f, *.for, *.vhd,
+# *.vhdl, *.ucf, *.qsf and *.ice.
 
 FILE_PATTERNS          = *.c \
                          *.cc \
@@ -1075,6 +1034,9 @@ EXCLUDE_PATTERNS       =
 # output. The symbol name can be a fully qualified name, a word, or if the
 # wildcard * is used, a substring. Examples: ANamespace, AClass,
 # ANamespace::AClass, ANamespace::*Test
+#
+# Note that the wildcards are matched against the file with absolute path, so to
+# exclude all test directories use the pattern */test/*
 
 EXCLUDE_SYMBOLS        =
 
@@ -1188,8 +1150,7 @@ FORTRAN_COMMENT_AFTER  = 72
 SOURCE_BROWSER         = NO
 
 # Setting the INLINE_SOURCES tag to YES will include the body of functions,
-# multi-line macros, enums or list initialized variables directly into the
-# documentation.
+# classes and enums directly into the documentation.
 # The default value is: NO.
 
 INLINE_SOURCES         = NO
@@ -1261,6 +1222,46 @@ USE_HTAGS              = NO
 
 VERBATIM_HEADERS       = YES
 
+# If the CLANG_ASSISTED_PARSING tag is set to YES then doxygen will use the
+# clang parser (see:
+# http://clang.llvm.org/) for more accurate parsing at the cost of reduced
+# performance. This can be particularly helpful with template rich C++ code for
+# which doxygen's built-in parser lacks the necessary type information.
+# Note: The availability of this option depends on whether or not doxygen was
+# generated with the -Duse_libclang=ON option for CMake.
+# The default value is: NO.
+
+CLANG_ASSISTED_PARSING = NO
+
+# If the CLANG_ASSISTED_PARSING tag is set to YES and the CLANG_ADD_INC_PATHS
+# tag is set to YES then doxygen will add the directory of each input to the
+# include path.
+# The default value is: YES.
+# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES.
+
+CLANG_ADD_INC_PATHS    = YES
+
+# If clang assisted parsing is enabled you can provide the compiler with command
+# line options that you would normally use when invoking the compiler. Note that
+# the include paths will already be set by doxygen for the files and directories
+# specified with INPUT and INCLUDE_PATH.
+# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES.
+
+CLANG_OPTIONS          =
+
+# If clang assisted parsing is enabled you can provide the clang parser with the
+# path to the directory containing a file called compile_commands.json. This
+# file is the compilation database (see:
+# http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html) containing the
+# options used when the source files were built. This is equivalent to
+# specifying the -p option to a clang tool, such as clang-check. These options
+# will then be passed to the parser. Any options specified with CLANG_OPTIONS
+# will be added as well.
+# Note: The availability of this option depends on whether or not doxygen was
+# generated with the -Duse_libclang=ON option for CMake.
+
+CLANG_DATABASE_PATH    =
+
 #---------------------------------------------------------------------------
 # Configuration options related to the alphabetical class index
 #---------------------------------------------------------------------------
@@ -1272,11 +1273,10 @@ VERBATIM_HEADERS       = YES
 
 ALPHABETICAL_INDEX     = YES
 
-# The IGNORE_PREFIX tag can be used to specify a prefix (or a list of prefixes)
-# that should be ignored while generating the index headers. The IGNORE_PREFIX
-# tag works for classes, function and member names. The entity will be placed in
-# the alphabetical list under the first letter of the entity name that remains
-# after removing the prefix.
+# In case all classes in a project start with a common prefix, all classes will
+# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
+# can be used to specify a prefix (or a list of prefixes) that should be ignored
+# while generating the index headers.
 # This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
 
 IGNORE_PREFIX          =
@@ -1355,12 +1355,7 @@ HTML_STYLESHEET        =
 # Doxygen will copy the style sheet files to the output directory.
 # Note: The order of the extra style sheet files is of importance (e.g. the last
 # style sheet in the list overrules the setting of the previous ones in the
-# list).
-# Note: Since the styling of scrollbars can currently not be overruled in
-# Webkit/Chromium, the styling will be left out of the default doxygen.css if
-# one or more extra stylesheets have been specified. So if scrollbar
-# customization is desired it has to be added explicitly. For an example see the
-# documentation.
+# list). For an example see the documentation.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_EXTRA_STYLESHEET  =
@@ -1376,13 +1371,17 @@ HTML_EXTRA_STYLESHEET  =
 HTML_EXTRA_FILES       =
 
 # The HTML_COLORSTYLE tag can be used to specify if the generated HTML output
-# should be rendered with a dark or light theme.
-# Possible values are: LIGHT always generate light mode output, DARK always
-# generate dark mode output, AUTO_LIGHT automatically set the mode according to
-# the user preference, use light mode if no preference is set (the default),
-# AUTO_DARK automatically set the mode according to the user preference, use
-# dark mode if no preference is set and TOGGLE allow to user to switch between
-# light and dark mode via a button.
+# should be rendered with a dark or light theme. Default setting AUTO_LIGHT
+# enables light output unless the user preference is dark output. Other options
+# are DARK to always use dark mode, LIGHT to always use light mode, AUTO_DARK to
+# default to dark mode unless the user prefers light mode, and TOGGLE to let the
+# user toggle between dark and light mode via a button.
+# Possible values are: LIGHT Always generate light output., DARK Always generate
+# dark output., AUTO_LIGHT Automatically set the mode according to the user
+# preference, use light mode if no preference is set (the default)., AUTO_DARK
+# Automatically set the mode according to the user preference, use dark mode if
+# no preference is set. and TOGGLE Allow to user to switch between light and
+# dark mode via a button..
 # The default value is: AUTO_LIGHT.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
@@ -1418,6 +1417,15 @@ HTML_COLORSTYLE_SAT    = 100
 
 HTML_COLORSTYLE_GAMMA  = 80
 
+# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting this
+# to YES can help to show when doxygen was last run and thus if the
+# documentation is up to date.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_TIMESTAMP         = NO
+
 # If the HTML_DYNAMIC_MENUS tag is set to YES then the generated HTML
 # documentation will contain a main index with vertical navigation menus that
 # are dynamically created via JavaScript. If disabled, the navigation index will
@@ -1437,33 +1445,6 @@ HTML_DYNAMIC_MENUS     = YES
 
 HTML_DYNAMIC_SECTIONS  = NO
 
-# If the HTML_CODE_FOLDING tag is set to YES then classes and functions can be
-# dynamically folded and expanded in the generated HTML source code.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_CODE_FOLDING      = YES
-
-# If the HTML_COPY_CLIPBOARD tag is set to YES then doxygen will show an icon in
-# the top right corner of code and text fragments that allows the user to copy
-# its content to the clipboard. Note this only works if supported by the browser
-# and the web page is served via a secure context (see:
-# https://www.w3.org/TR/secure-contexts/), i.e. using the https: or file:
-# protocol.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_COPY_CLIPBOARD    = YES
-
-# Doxygen stores a couple of settings persistently in the browser (via e.g.
-# cookies). By default these settings apply to all HTML pages generated by
-# doxygen across all projects. The HTML_PROJECT_COOKIE tag can be used to store
-# the settings under a project specific key, such that the user preferences will
-# be stored separately.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_PROJECT_COOKIE    =
-
 # With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
 # shown in the various tree structured indices initially; the user can expand
 # and collapse entries dynamically later on. Doxygen will expand the tree to
@@ -1594,16 +1575,6 @@ BINARY_TOC             = NO
 
 TOC_EXPAND             = NO
 
-# The SITEMAP_URL tag is used to specify the full URL of the place where the
-# generated documentation will be placed on the server by the user during the
-# deployment of the documentation. The generated sitemap is called sitemap.xml
-# and placed on the directory specified by HTML_OUTPUT. In case no SITEMAP_URL
-# is specified no sitemap is generated. For information about the sitemap
-# protocol see https://www.sitemaps.org
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-SITEMAP_URL            =
-
 # If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
 # QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
 # can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
@@ -1840,8 +1811,8 @@ MATHJAX_RELPATH        = https://cdn.jsdelivr.net/npm/mathjax@2
 
 # The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
 # extension names that should be enabled during MathJax rendering. For example
-# for MathJax version 2 (see
-# https://docs.mathjax.org/en/v2.7-latest/tex.html#tex-and-latex-extensions):
+# for MathJax version 2 (see https://docs.mathjax.org/en/v2.7-latest/tex.html
+# #tex-and-latex-extensions):
 # MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
 # For example for MathJax version 3 (see
 # http://docs.mathjax.org/en/latest/input/tex/extensions/index.html):
@@ -2092,16 +2063,9 @@ PDF_HYPERLINKS         = YES
 
 USE_PDFLATEX           = YES
 
-# The LATEX_BATCHMODE tag signals the behavior of LaTeX in case of an error.
-# Possible values are: NO same as ERROR_STOP, YES same as BATCH, BATCH In batch
-# mode nothing is printed on the terminal, errors are scrolled as if <return> is
-# hit at every error; missing files that TeX tries to input or request from
-# keyboard input (\read on a not open input stream) cause the job to abort,
-# NON_STOP In nonstop mode the diagnostic message will appear on the terminal,
-# but there is no possibility of user interaction just like in batch mode,
-# SCROLL In scroll mode, TeX will stop only for missing files to input or if
-# keyboard input is necessary and ERROR_STOP In errorstop mode, TeX will stop at
-# each error, asking for user intervention.
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
+# command to the generated LaTeX files. This will instruct LaTeX to keep running
+# if errors occur, instead of asking the user for help.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
@@ -2122,6 +2086,14 @@ LATEX_HIDE_INDICES     = NO
 
 LATEX_BIB_STYLE        = plain
 
+# If the LATEX_TIMESTAMP tag is set to YES then the footer of each generated
+# page will contain the date and time when the page was generated. Setting this
+# to NO can help when comparing the output of multiple runs.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_TIMESTAMP        = NO
+
 # The LATEX_EMOJI_DIRECTORY tag is used to specify the (relative or absolute)
 # path from which the emoji images will be read. If a relative path is entered,
 # it will be relative to the LATEX_OUTPUT directory. If left blank the
@@ -2287,7 +2259,7 @@ DOCBOOK_OUTPUT         = docbook
 #---------------------------------------------------------------------------
 
 # If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an
-# AutoGen Definitions (see https://autogen.sourceforge.net/) file that captures
+# AutoGen Definitions (see http://autogen.sourceforge.net/) file that captures
 # the structure of the code including all documentation. Note that this feature
 # is still experimental and incomplete at the moment.
 # The default value is: NO.
@@ -2298,28 +2270,6 @@ GENERATE_AUTOGEN_DEF   = NO
 # Configuration options related to Sqlite3 output
 #---------------------------------------------------------------------------
 
-# If the GENERATE_SQLITE3 tag is set to YES doxygen will generate a Sqlite3
-# database with symbols found by doxygen stored in tables.
-# The default value is: NO.
-
-GENERATE_SQLITE3       = NO
-
-# The SQLITE3_OUTPUT tag is used to specify where the Sqlite3 database will be
-# put. If a relative path is entered the value of OUTPUT_DIRECTORY will be put
-# in front of it.
-# The default directory is: sqlite3.
-# This tag requires that the tag GENERATE_SQLITE3 is set to YES.
-
-SQLITE3_OUTPUT         = sqlite3
-
-# The SQLITE3_RECREATE_DB tag is set to YES, the existing doxygen_sqlite3.db
-# database file will be recreated with each doxygen run. If set to NO, doxygen
-# will warn if a database file is already found and not modify it.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_SQLITE3 is set to YES.
-
-SQLITE3_RECREATE_DB    = YES
-
 #---------------------------------------------------------------------------
 # Configuration options related to the Perl module output
 #---------------------------------------------------------------------------
@@ -2468,15 +2418,15 @@ TAGFILES               =
 
 GENERATE_TAGFILE       =
 
-# If the ALLEXTERNALS tag is set to YES, all external classes and namespaces
-# will be listed in the class and namespace index. If set to NO, only the
-# inherited external classes will be listed.
+# If the ALLEXTERNALS tag is set to YES, all external class will be listed in
+# the class index. If set to NO, only the inherited external classes will be
+# listed.
 # The default value is: NO.
 
 ALLEXTERNALS           = NO
 
 # If the EXTERNAL_GROUPS tag is set to YES, all external groups will be listed
-# in the topic index. If set to NO, only the current project's groups will be
+# in the modules index. If set to NO, only the current project's groups will be
 # listed.
 # The default value is: YES.
 
@@ -2490,9 +2440,16 @@ EXTERNAL_GROUPS        = YES
 EXTERNAL_PAGES         = YES
 
 #---------------------------------------------------------------------------
-# Configuration options related to diagram generator tools
+# Configuration options related to the dot tool
 #---------------------------------------------------------------------------
 
+# You can include diagrams made with dia in doxygen documentation. Doxygen will
+# then run dia to produce the diagram and insert it in the documentation. The
+# DIA_PATH tag allows you to specify the directory where the dia binary resides.
+# If left empty dia is assumed to be found in the default search path.
+
+DIA_PATH               =
+
 # If set to YES the inheritance and collaboration graphs will hide inheritance
 # and usage relations if the target is undocumented or is not a class.
 # The default value is: YES.
@@ -2501,7 +2458,7 @@ HIDE_UNDOC_RELATIONS   = YES
 
 # If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
 # available from the path. This tool is part of Graphviz (see:
-# https://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
+# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
 # Bell Labs. The other options in this section have no effect if this option is
 # set to NO
 # The default value is: NO.
@@ -2554,19 +2511,13 @@ DOT_NODE_ATTR          = "shape=box,height=0.2,width=0.4"
 
 DOT_FONTPATH           =
 
-# If the CLASS_GRAPH tag is set to YES or GRAPH or BUILTIN then doxygen will
-# generate a graph for each documented class showing the direct and indirect
-# inheritance relations. In case the CLASS_GRAPH tag is set to YES or GRAPH and
-# HAVE_DOT is enabled as well, then dot will be used to draw the graph. In case
-# the CLASS_GRAPH tag is set to YES and HAVE_DOT is disabled or if the
-# CLASS_GRAPH tag is set to BUILTIN, then the built-in generator will be used.
-# If the CLASS_GRAPH tag is set to TEXT the direct and indirect inheritance
-# relations will be shown as texts / links. Explicit enabling an inheritance
-# graph or choosing a different representation for an inheritance graph of a
-# specific class, can be accomplished by means of the command \inheritancegraph.
-# Disabling an inheritance graph can be accomplished by means of the command
-# \hideinheritancegraph.
-# Possible values are: NO, YES, TEXT, GRAPH and BUILTIN.
+# If the CLASS_GRAPH tag is set to YES (or GRAPH) then doxygen will generate a
+# graph for each documented class showing the direct and indirect inheritance
+# relations. In case HAVE_DOT is set as well dot will be used to draw the graph,
+# otherwise the built-in generator will be used. If the CLASS_GRAPH tag is set
+# to TEXT the direct and indirect inheritance relations will be shown as texts /
+# links.
+# Possible values are: NO, YES, TEXT and GRAPH.
 # The default value is: YES.
 
 CLASS_GRAPH            = TEXT
@@ -2574,21 +2525,15 @@ CLASS_GRAPH            = TEXT
 # If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
 # graph for each documented class showing the direct and indirect implementation
 # dependencies (inheritance, containment, and class references variables) of the
-# class with other documented classes. Explicit enabling a collaboration graph,
-# when COLLABORATION_GRAPH is set to NO, can be accomplished by means of the
-# command \collaborationgraph. Disabling a collaboration graph can be
-# accomplished by means of the command \hidecollaborationgraph.
+# class with other documented classes.
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 COLLABORATION_GRAPH    = YES
 
 # If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
-# groups, showing the direct groups dependencies. Explicit enabling a group
-# dependency graph, when GROUP_GRAPHS is set to NO, can be accomplished by means
-# of the command \groupgraph. Disabling a directory graph can be accomplished by
-# means of the command \hidegroupgraph. See also the chapter Grouping in the
-# manual.
+# groups, showing the direct groups dependencies. See also the chapter Grouping
+# in the manual.
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
@@ -2630,8 +2575,8 @@ DOT_UML_DETAILS        = NO
 
 # The DOT_WRAP_THRESHOLD tag can be used to set the maximum number of characters
 # to display on a single line. If the actual line length exceeds this threshold
-# significantly it will be wrapped across multiple lines. Some heuristics are
-# applied to avoid ugly line breaks.
+# significantly it will wrapped across multiple lines. Some heuristics are apply
+# to avoid ugly line breaks.
 # Minimum value: 0, maximum value: 1000, default value: 17.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
@@ -2648,9 +2593,7 @@ TEMPLATE_RELATIONS     = NO
 # If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
 # YES then doxygen will generate a graph for each documented file showing the
 # direct and indirect include dependencies of the file with other documented
-# files. Explicit enabling an include graph, when INCLUDE_GRAPH is is set to NO,
-# can be accomplished by means of the command \includegraph. Disabling an
-# include graph can be accomplished by means of the command \hideincludegraph.
+# files.
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
@@ -2659,10 +2602,7 @@ INCLUDE_GRAPH          = YES
 # If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
 # set to YES then doxygen will generate a graph for each documented file showing
 # the direct and indirect include dependencies of the file with other documented
-# files. Explicit enabling an included by graph, when INCLUDED_BY_GRAPH is set
-# to NO, can be accomplished by means of the command \includedbygraph. Disabling
-# an included by graph can be accomplished by means of the command
-# \hideincludedbygraph.
+# files.
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
@@ -2702,10 +2642,7 @@ GRAPHICAL_HIERARCHY    = YES
 # If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
 # dependencies a directory has on other directories in a graphical way. The
 # dependency relations are determined by the #include relations between the
-# files in the directories. Explicit enabling a directory graph, when
-# DIRECTORY_GRAPH is set to NO, can be accomplished by means of the command
-# \directorygraph. Disabling a directory graph can be accomplished by means of
-# the command \hidedirectorygraph.
+# files in the directories.
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
@@ -2721,7 +2658,7 @@ DIR_GRAPH_MAX_DEPTH    = 1
 # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
 # generated by dot. For an explanation of the image formats see the section
 # output formats in the documentation of the dot tool (Graphviz (see:
-# https://www.graphviz.org/)).
+# http://www.graphviz.org/)).
 # Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
 # to make the SVG files visible in IE 9+ (other browsers do not have this
 # requirement).
@@ -2758,12 +2695,11 @@ DOT_PATH               =
 
 DOTFILE_DIRS           =
 
-# You can include diagrams made with dia in doxygen documentation. Doxygen will
-# then run dia to produce the diagram and insert it in the documentation. The
-# DIA_PATH tag allows you to specify the directory where the dia binary resides.
-# If left empty dia is assumed to be found in the default search path.
+# The MSCFILE_DIRS tag can be used to specify one or more directories that
+# contain msc files that are included in the documentation (see the \mscfile
+# command).
 
-DIA_PATH               =
+MSCFILE_DIRS           =
 
 # The DIAFILE_DIRS tag can be used to specify one or more directories that
 # contain dia files that are included in the documentation (see the \diafile
@@ -2840,19 +2776,3 @@ GENERATE_LEGEND        = YES
 # The default value is: YES.
 
 DOT_CLEANUP            = YES
-
-# You can define message sequence charts within doxygen comments using the \msc
-# command. If the MSCGEN_TOOL tag is left empty (the default), then doxygen will
-# use a built-in version of mscgen tool to produce the charts. Alternatively,
-# the MSCGEN_TOOL tag can also specify the name an external tool. For instance,
-# specifying prog as the value, doxygen will call the tool as prog -T
-# <outfile_format> -o <outputfile> <inputfile>. The external tool should support
-# output file formats "png", "eps", "svg", and "ismap".
-
-MSCGEN_TOOL            =
-
-# The MSCFILE_DIRS tag can be used to specify one or more directories that
-# contain msc files that are included in the documentation (see the \mscfile
-# command).
-
-MSCFILE_DIRS           =

docs/Improvements_and_updates.md

@@ -0,0 +1,149 @@
+# Improvements and updates
+
+Many improvements have been made to this library vs the original, this is a brief overview of the most significant changes. Refer to the [class documentation](https://h2zero.github.io/esp-nimble-cpp/annotated.html) for further information on class specifics.
+
+* [Server](#server)
+* [Advertising](#advertising)
+* [Client](#client)
+* [General](#general)  
+<br/>
+
+<a name="server"></a>
+# Server
+
+`NimBLEService::NimBLEService::createCharacteristic` takes a 3rd parameter to specify the maximum data size that can be stored by the characteristic. This allows for limiting the RAM use of the characteristic in cases where small amounts of data are expected.  
+<br/>
+
+`NimBLECharacteristic::setValue(const T &s)`
+`NimBLEDescriptor::setValue(const T &s)`
+
+Now use the `NimbleAttValue` class and templates to accommodate standard and custom types/values.
+
+**Example**
+```
+struct my_struct {
+    uint8_t  one;
+    uint16_t two;
+    uint32_t four;
+    uint64_t eight;
+    float    flt;
+} myStruct;
+
+    myStruct.one = 1;
+    myStruct.two = 2;
+    myStruct.four = 4;
+    myStruct.eight = 8;
+    myStruct.flt = 1234.56;
+
+    pCharacteristic->setValue(myStruct);
+
+    // Arduino String support
+    String myString = "Hello";
+    pCharacteristic->setValue(myString);
+ ```
+This will send the struct to the receiving client when read or a notification sent.
+
+`NimBLECharacteristic::getValue` now takes an optional timestamp parameter which will update it's value with the time the last value was received. In addition an overloaded template has been added to retrieve the value as a type specified by the user.
+
+**Example**
+```
+    time_t timestamp;
+    myStruct = pCharacteristic->getValue<myStruct>(&timestamp); // timestamp optional
+```
+<br/>
+
+**Advertising will automatically start when a client disconnects.**
+
+A new method `NimBLEServer::advertiseOnDisconnect(bool)` has been implemented to control this, true(default) = enabled.  
+<br/>
+
+`NimBLEServer::removeService` takes an additional parameter `bool deleteSvc` that if true will delete the service and all characteristics / descriptors belonging to it and invalidating any pointers to them.
+
+If false the service is only removed from visibility by clients. The pointers to the service and it's characteristics / descriptors will remain valid and the service can be re-added in the future using `NimBLEServer::addService`.  
+<br/>
+
+<a name="advertising"></a>
+# Advertising
+`NimBLEAdvertising::start`
+
+Now takes 2 optional parameters, the first is the duration to advertise for (in milliseconds), the second is a callback that is invoked when advertising ends and takes a pointer to a `NimBLEAdvertising` object (similar to the `NimBLEScan::start` API).
+
+This provides an opportunity to update the advertisement data if desired.
+
+Also now returns a bool value to indicate if advertising successfully started or not.  
+<br/>
+
+<a name="client"></a>
+# Client
+
+`NimBLERemoteCharacteristic::readValue(time_t\*, bool)`
+`NimBLERemoteDescriptor::readValue(bool)`
+
+Have been added as templates to allow reading the values as any specified type.
+
+**Example**
+```
+struct my_struct{
+    uint8_t  one;
+    uint16_t two;
+    uint32_t four;
+    uint64_t eight;
+    float    flt;
+}myStruct;
+
+    time_t timestamp;
+    myStruct = pRemoteCharacteristic->readValue<myStruct>(&timestamp); // timestamp optional
+```
+<br/>
+
+`NimBLERemoteCharacteristic::registerForNotify`  
+Has been removed.
+
+`NimBLERemoteCharacteristic::subscribe` and `NimBLERemoteCharacteristic::unsubscribe` have been implemented to replace it.  
+
+The internally stored characteristic value is now updated when notification/indication is recieved. Making a callback no longer required to get the most recent value unless timing is important. Instead, the application can call `NimBLERemoteCharacteristic::getValue` to get the most recent value any time.  
+<br/>  
+
+The `notify_callback` function is now defined as a `std::function` to take advantage of using `std::bind` to specify a class member function for the callback.
+
+Example:
+```
+using namespace std::placeholders;
+notify_callback callback = std::bind(&<ClassName>::<memberFunctionCallbackName>, this, _1, _2, _3, _4);
+
+<remoteCharacteristicInstance>->subscribe(true, callback);
+```
+
+`NimBLERemoteCharacteristic::readValue` and `NimBLERemoteCharacteristic::getValue` take an optional timestamp parameter which will update it's value with
+the time the last value was received.
+
+> NimBLEClient::getService  
+> NimBLERemoteService::getCharacteristic  
+> NimBLERemoteCharacteristic::getDescriptor
+
+These methods will now check the respective vectors for the attribute object and, if not found, will retrieve (only)
+the specified attribute from the peripheral.
+
+These changes allow more control for the user to manage the resources used for the attributes.  
+<br/>
+
+`NimBLEClient::connect()` can now be called without an address or advertised device parameter. This will connect to the device with the address previously set when last connected or set with `NimBLEDevice::setPeerAddress()`.
+
+<a name="general"></a>
+# General
+To reduce resource use all instances of `std::map` have been replaced with `std::vector`.
+
+Use of `FreeRTOS::Semaphore` has been removed as it was consuming too much ram, the related files have been left in place to accomodate application use.
+
+Operators `==`, `!=` and `std::string` have been added to `NimBLEAddress` and `NimBLEUUID` for easier comparison and logging.
+
+New constructor for `NimBLEUUID(uint32_t, uint16_t, uint16_t, uint64_t)` added to lower memory use vs string construction. See: [#21](https://github.com/h2zero/NimBLE-Arduino/pull/21).
+
+Security/pairing operations are now handled in the respective `NimBLEClientCallbacks` and `NimBLEServerCallbacks` classes, `NimBLESecurity`(deprecated) remains for backward compatibility.
+
+Configuration options have been added to add or remove debugging information, when disabled (default) significantly reduces binary size.
+In ESP-IDF the options are in menuconfig: `Main menu -> ESP-NimBLE-cpp configuration`.  
+For Arduino the options must be commented / uncommented in nimconfig.h.
+
+Characteristics and descriptors now use the `NimBLEAttValue` class to store their data. This is a polymorphic container class capable of converting to/from many different types efficiently. See: [#286](https://github.com/h2zero/NimBLE-Arduino/pull/286)
+

docs/Migration_guide.md

@@ -4,7 +4,7 @@ This guide describes the required changes to existing projects migrating from th
 
 **The changes listed here are only the required changes that must be made**, and a short overview of options for migrating existing applications.
 
-For more information on the improvements and additions please refer to the [class documentation](https://h2zero.github.io/esp-nimble-cpp/annotated.html)
+For more information on the improvements and additions please refer to the [class documentation](https://h2zero.github.io/NimBLE-Arduino/annotated.html) and [Improvements and updates](Improvements_and_updates.md)
 
 * [General Changes](#general-information)
 * [Server](#server-api)
@@ -20,11 +20,12 @@ For more information on the improvements and additions please refer to the [clas
     * [Remote characteristics](#remote-characteristics)
     * [Client Callbacks](#client-callbacks)
     * [Security](#client-security)
-* [BLE scan](#ble-scan)
+* [Scanning](#scan-api)
 * [General Security](#security-api)
 * [Configuration](#arduino-configuration)
 <br/>
 
+<a name="general-information"></a>
 ## General Information
 
 ### Header Files
@@ -47,9 +48,10 @@ For example `BLEAddress addr(11:22:33:44:55:66, 1)` will create the address obje
 
 As this parameter is optional no changes to existing code are needed, it is mentioned here for information.
 
-`BLEAddress::getNative` is now named `NimBLEAddress::getBase` and returns a pointer to `const ble_addr_t` instead of a pointer to the address value.  
+`BLEAddress::getNative` (`NimBLEAddress::getNative`) returns a uint8_t pointer to the native address byte array. In this library the address bytes are stored in reverse order from the original library. This is due to the way the NimBLE stack expects addresses to be presented to it. All other functions such as `toString` are not affected as the endian change is made within them.  
 <br/>
 
+<a name="server-api"></a>
 ## Server API
 Creating a `BLEServer` instance is the same as original, no changes required.
 For example `BLEDevice::createServer()` will work just as it did before.
@@ -70,7 +72,7 @@ void onDisconnect(NimBLEServer* pServer, NimBLEConnInfo& connInfo, int reason)`
 ```
 <br/>
 
-`BLEServerCallbacks::onMtuChanged` is now (`NimBLEServerCallbacks::onMtuChange`) and takes the parameter `NimBLEConnInfo & connInfo` instead of `esp_ble_gatts_cb_param_t`, which has methods to get information about the connected peer.
+`BLEServerCallbacks::onMtuChanged` (`NimBLEServerCallbacks::onMtuChanged`) takes the parameter `NimBLEConnInfo & connInfo` instead of `esp_ble_gatts_cb_param_t`, which has methods to get information about the connected peer.
 
 ```
 onMTUChange(uint16_t MTU, NimBLEConnInfo& connInfo)
@@ -79,11 +81,13 @@ onMTUChange(uint16_t MTU, NimBLEConnInfo& connInfo)
 **Note:** All callback methods have default implementations which allows the application to implement only the methods applicable.  
 <br/>
 
+<a name="services"></a>
 ### Services
 Creating a `BLEService` (`NimBLEService`) instance is the same as original, no changes required.
 For example `BLEServer::createService(SERVICE_UUID)` will work just as it did before.  
 <br/>
 
+<a name="characteristics"></a>
 ### Characteristics
 `BLEService::createCharacteristic` (`NimBLEService::createCharacteristic`) is used the same way as originally except the properties parameter has changed.
 
@@ -133,8 +137,8 @@ BLECharacteristic *pCharacteristic = pService->createCharacteristic(
 ```
 <br/>
 
+<a name="characteristic-callbacks"></a>
 #### Characteristic callbacks
-
 `BLECharacteristicCallbacks` (`NimBLECharacteristicCallbacks`) has a new method `NimBLECharacteristicCallbacks::onSubscribe` which is called when a client subscribes to notifications/indications.
 
 `BLECharacteristicCallbacks::onRead` (`NimBLECharacteristicCallbacks::onRead`)  only has a single callback declaration, which takes an additional (required) parameter of `NimBLEConnInfo& connInfo`, which provides connection information about the peer.
@@ -164,6 +168,7 @@ my_struct_t myStruct = pChr->getValue<my_struct_t>();
 ```
 <br/>
 
+<a name="descriptors"></a>
 ### Descriptors
 
 Descriptors are now created using the `NimBLECharacteristic::createDescriptor` method.
@@ -174,7 +179,8 @@ NimBLE automatically creates the 0x2902 descriptor if a characteristic has a not
 It was no longer useful to have a class for the 0x2902 descriptor as a new callback `NimBLECharacteristicCallbacks::onSubscribe` was added
 to handle callback functionality and the client subscription status is handled internally.
 
-**Note:** Attempting to create a 0x2902 descriptor will trigger a warning message and flag it internally as removed and will not be functional.
+**Note:** Attempting to create a 0x2902 descriptor will trigger an assert to notify the error,
+allowing the creation of it would cause a fault in the NimBLE stack.
 
 All other descriptors are now created just as characteristics are by using the `NimBLECharacteristic::createDescriptor` method (except 0x2904, see below).
 Which are defined as:
@@ -191,7 +197,7 @@ NimBLEDescriptor* createDescriptor(NimBLEUUID uuid,
                                    NIMBLE_PROPERTY::WRITE,
                                    uint16_t max_len = 100);
 ```
-#### Example
+##### Example
 ```
 pDescriptor = pCharacteristic->createDescriptor("ABCD",
                                                 NIMBLE_PROPERTY::READ |
@@ -202,18 +208,27 @@ pDescriptor = pCharacteristic->createDescriptor("ABCD",
 Would create a descriptor with the UUID 0xABCD, publicly readable but only writable if paired/bonded (encrypted) and has a max value length of 25 bytes.
 <br/>
 
-For the 0x2904, there is a specialized class that is created through `NimBLECharacteristic::create2904` which returns a pointer to a `NimBLE2904` instance which has specific 
-functions for handling the data expect in the Characteristic Presentation Format Descriptor specification.  
+For the 0x2904, there is a special class that is created when you call `createDescriptor("2904").
+
+The pointer returned is of the base class `NimBLEDescriptor` but the call will create the derived class of `NimBLE2904` so you must cast the returned pointer to
+`NimBLE2904` to access the specific class methods.
+
+##### Example
+```
+p2904 = (NimBLE2904*)pCharacteristic->createDescriptor("2904");
+```
 <br/>
 
+<a name="descriptor-callbacks"></a>
 #### Descriptor callbacks
 
 > `BLEDescriptorCallbacks::onRead` (`NimBLEDescriptorCallbacks::onRead`)
- `BLEDescriptorCallbacks::onWrite` (`NimBLEDescriptorCallbacks::onWrite`)
+ `BLEDescriptorCallbacks::onwrite` (`NimBLEDescriptorCallbacks::onwrite`)
 
 The above descriptor callbacks take an additional (required) parameter `NimBLEConnInfo& connInfo`, which contains the connection information of the peer.
 <br/>
 
+<a name="server-security"></a>
 ### Server Security
 Security is set on the characteristic or descriptor properties by applying one of the following:
 > NIMBLE_PROPERTY::READ_ENC  
@@ -230,6 +245,7 @@ When a peer wants to read or write a characteristic or descriptor with any of th
 This can be changed to use passkey authentication or numeric comparison. See [Security API](#security-api) for details.  
 <br/>
 
+<a name="advertising-api"></a>
 ## Advertising API
 Advertising works the same as the original API except:
 
@@ -239,9 +255,11 @@ Calling `NimBLEAdvertising::setAdvertisementData` will entirely replace any data
 
 > BLEAdvertising::start (NimBLEAdvertising::start)
 
-Now takes 2 optional parameters, the first is the duration to advertise for (in milliseconds), the second `NimBLEAddress` to direct advertising to a specific device.  
+Now takes 2 optional parameters, the first is the duration to advertise for (in milliseconds), the second is a callback that is invoked when advertising ends and takes a pointer to a `NimBLEAdvertising` object (similar to the `NimBLEScan::start` API).
+This provides an opportunity to update the advertisement data if desired.  
 <br/>
 
+<a name="client-api"></a>
 ## Client API
 
 Client instances are created just as before with `BLEDevice::createClient` (`NimBLEDevice::createClient`).
@@ -250,17 +268,15 @@ Multiple client instances can be created, up to the maximum number of connection
 
 `BLEClient::connect`(`NimBLEClient::connect`) Has had it's parameters altered.
 Defined as:
-> NimBLEClient::connect(bool deleteServices = true, , bool asyncConnect = false, bool exchangeMTU = true);  
-> NimBLEClient::connect(const NimBLEAddress& address, bool deleteAttributes = true, bool asyncConnect = false, bool exchangeMTU = true);  
-> NimBLEClient::connect(const NimBLEAdvertisedDevice* device, bool deleteServices = true, bool asyncConnect = false, bool exchangeMTU = true);
+> NimBLEClient::connect(bool deleteServices = true);
+> NimBLEClient::connect(NimBLEAdvertisedDevice\* device, bool deleteServices = true);
+> NimBLEClient::connect(NimBLEAddress address, bool deleteServices = true);
 
 The type parameter has been removed and a new bool parameter has been added to indicate if the client should delete the attribute database previously retrieved (if applicable) for the peripheral, default value is true.
 
-If set to false the client will use the attribute database it retrieved from the peripheral when previously connected. This allows for faster connections and power saving if the devices dropped connection and are reconnecting.  
+If set to false the client will use the attribute database it retrieved from the peripheral when previously connected.
 
-The parameter `bool asyncConnect` if true, will cause the client to send the connect command to the stack and return immediately without blocking. The return value will represent wether the command was sent successfully or not and the `NimBLEClientCallbacks::onConnect` or `NimBLEClientCallbacks::onConnectFail` will be called when the operation is complete.  
-
-The parameter `bool exchangeMTU` if true, will cause the client to perform the exchange MTU process upon connecting. If false the MTU exchange will need to be performed by the application by calling `NimBLEClient::exchangeMTU`. If the connection is only sending small payloads it may be advantageous to not exchange the MTU to gain performance in the connection process.  
+This allows for faster connections and power saving if the devices dropped connection and are reconnecting.  
 <br/>
 
 > `BLEClient::getServices` (`NimBLEClient::getServices`)
@@ -274,6 +290,7 @@ Also now returns a pointer to `std::vector` instead of `std::map`.
 **Added:** `NimBLEClient::discoverAttributes` for the user to discover all the peripheral attributes to replace the the removed automatic functionality.  
 <br/>
 
+<a name="remote-services"></a>
 ### Remote Services
 `BLERemoteService` (`NimBLERemoteService`) Methods remain mostly unchanged with the exceptions of:
 
@@ -284,10 +301,12 @@ This method has been removed.
 
 > `BLERemoteService::getCharacteristics` (`NimBLERemoteService::getCharacteristics`)
 
-This method now takes an optional (bool) parameter to indicate if the characteristics should be retrieved from the server (true) or the currently known database returned, default = false.  
+This method now takes an optional (bool) parameter to indicate if the characteristics should be retrieved from the server (true) or
+the currently known database returned (false : default).
 Also now returns a pointer to `std::vector` instead of `std::map`.  
 <br/>
 
+<a name="remote-characteristics"></a>
 ### Remote Characteristics
 `BLERemoteCharacteristic` (`NimBLERemoteCharacteristic`)
  There have been a few changes to the methods in this class:
@@ -307,12 +326,12 @@ Has been removed.
 Are the new methods added to replace it.  
 <br/>
 
-> `BLERemoteCharacteristic::readUInt8` (`NimBLERemoteCharacteristic::readUInt8`)  
-> `BLERemoteCharacteristic::readUInt16` (`NimBLERemoteCharacteristic::readUInt16`)  
-> `BLERemoteCharacteristic::readUInt32` (`NimBLERemoteCharacteristic::readUInt32`)  
+> `BLERemoteCharacteristic::readUInt8` (`NimBLERemoteCharacteristic::readUInt8`)
+> `BLERemoteCharacteristic::readUInt16` (`NimBLERemoteCharacteristic::readUInt16`)
+> `BLERemoteCharacteristic::readUInt32` (`NimBLERemoteCharacteristic::readUInt32`)
 > `BLERemoteCharacteristic::readFloat` (`NimBLERemoteCharacteristic::readFloat`)
 
-Are **removed** a template: `NimBLERemoteCharacteristic::readValue<type\>(time_t\*, bool)` has been added to replace them.  
+Are **deprecated** a template: `NimBLERemoteCharacteristic::readValue<type\>(time_t\*, bool)` has been added to replace them.  
 <br/>
 
 > `BLERemoteCharacteristic::readRawData`
@@ -320,10 +339,10 @@ Are **removed** a template: `NimBLERemoteCharacteristic::readValue<type\>(time_t
 **Has been removed from the API**
 Originally it stored an unnecessary copy of the data and was returning a `uint8_t` pointer to volatile internal data.
 The user application should use `NimBLERemoteCharacteristic::readValue` or `NimBLERemoteCharacteristic::getValue`.
-To obtain a copy of the data as a `NimBLEAttValue` instance and use the `NimBLEAttValue::data` member function to obtain the pointer.
+To obtain a copy of the data, then cast the returned std::string to the type required such as:
 ```
-NimBLEAttValue value = pChr->readValue();
-const uint8_t *data = value.data();
+std::string value = pChr->readValue();
+uint8_t *data = (uint8_t*)value.data();
 ```
 Alternatively use the `readValue` template:
 ```
@@ -333,10 +352,12 @@ my_struct_t myStruct = pChr->readValue<my_struct_t>();
 
 > `BLERemoteCharacteristic::getDescriptors` (`NimBLERemoteCharacteristic::getDescriptors`)
 
-This method now takes an optional (bool) parameter to indicate if the descriptors should be retrieved from the server (true) or the currently known database returned, default = false.
+This method now takes an optional (bool) parameter to indicate if the descriptors should be retrieved from the server (true) or
+the currently known database returned (false : default).
 Also now returns a pointer to `std::vector` instead of `std::map`.  
 <br/>
 
+<a name="client-callbacks"></a>
 ### Client callbacks
 
 > `BLEClientCallbacks::onDisconnect` (`NimBLEClientCallbacks::onDisconnect`)
@@ -344,20 +365,18 @@ Also now returns a pointer to `std::vector` instead of `std::map`.
 This now takes a second parameter `int reason` which provides the reason code for disconnection.  
 <br/>
 
+<a name="client-security"></a>
 ### Client Security
 The client will automatically initiate security when the peripheral responds that it's required.
 The default configuration will use "just-works" pairing with no bonding, if you wish to enable bonding see below.  
 <br/>
 
+<a name="scan-api"></a>
 ## BLE Scan
-The scan API is mostly unchanged from the original except for `NimBLEScan::start`, which has the following changes:  
-* The duration parameter is now in milliseconds instead of seconds.
-* The callback parameter has been removed.
-* A new parameter `bool restart` has been added, when set to true to restart the scan if already in progress and clear the duplicate cache.
-
- The blocking overload of `NimBLEScan::start` has been replaced by an overload of `NimBLEScan::getResults` with the same parameters. 
+The scan API is mostly unchanged from the original except for `NimBLEScan::start`, in which the duration parameter is now in milliseconds instead of seconds.  
 <br/>
 
+<a name="security-api"></a>
 ## Security API
 Security operations have been moved to `BLEDevice` (`NimBLEDevice`).  
 The security callback methods are now incorporated in the `NimBLEServerCallbacks` / `NimBLEClientCallbacks` classes.
@@ -367,7 +386,7 @@ The callback methods are:
 > `bool onConfirmPasskey(NimBLEConnInfo& connInfo, uint32_t pin)`
 
 Receives the pin when using numeric comparison authentication.
-Call `NimBLEDevice::injectConfirmPasskey(connInfo, true);` to accept or `NimBLEDevice::injectConfirmPasskey(connInfo, false);` to reject.
+Call `NimBLEDevice::injectConfirmPIN(connInfo, true);` to accept or `NimBLEDevice::injectConfirmPIN(connInfo, false);` to reject.
 <br/>
 
 > `void onPassKeyEntry(NimBLEConnInfo& connInfo)`
@@ -407,6 +426,7 @@ If we are the initiator of the security procedure this sets the keys we will dis
 Sets the keys we are willing to accept from the peer during pairing.  
 <br/>
 
+<a name="arduino-configuration"></a>
 ## Arduino Configuration
 
 Unlike the original library pre-packaged in the esp32-arduino, this library has all the configuration options that are normally set in menuconfig available in the *src/nimconfig.h* file.

docs/New_user_guide.md

@@ -21,6 +21,7 @@ If you're not creating a server or do not want to advertise a name, simply pass
 This can be called any time you wish to use BLE functions and does not need to be called from app_main(IDF) or setup(Arduino) but usually is.  
 <br/>
 
+<a name="creating-a-server"></a>
 ## Creating a Server
 BLE servers perform 2 tasks, they advertise their existence for clients to find them and they provide services which contain information for the connecting client.  
 
@@ -136,6 +137,7 @@ Now if you scan with your phone using nRFConnect or any other BLE app you should
 For more advanced features and options please see the server examples in the examples folder.  
 <br/>
 
+<a name="creating-a-client"></a>
 ## Creating a Client 
 
 BLE clients perform 2 tasks, they scan for advertising servers and form connections to them to read and write to their characteristics/descriptors.

docs/index.md

@@ -14,7 +14,7 @@ It is more suited to resource constrained devices than bluedroid and has now bee
 <br/>
 
 # ESP-IDF Installation
-## v4.0+
+### v4.0+
 Download as .zip and extract or clone into the components folder in your esp-idf project.
 
 Run menuconfig, go to `Component config->Bluetooth` enable Bluetooth and in `Bluetooth host` NimBLE.  
@@ -38,7 +38,9 @@ This library is intended to be compatible with the original ESP32 BLE functions
 
 If you have not used the original Bluedroid library please refer to the [New user guide](New_user_guide.md).
 
-If you are familiar with the original library, see: [The migration guide](Migration_guide.md) for details.   
+If you are familiar with the original library, see: [The migration guide](Migration_guide.md) for details.  
+
+Also see [Improvements and updates](Improvements_and_updates.md) for information about non-breaking changes.  
 
 For more advanced usage see [Usage tips](Usage_tips.md) for more performance and optimization.  
 <br/>

examples/Advanced/NimBLE_Client/CMakeLists.txt

@@ -3,4 +3,5 @@
 cmake_minimum_required(VERSION 3.5)
 
 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+set(SUPPORTED_TARGETS esp32)
 project(NimBLE_Client)

examples/Advanced/NimBLE_Client/Makefile

@@ -0,0 +1,3 @@
+PROJECT_NAME := NimBLE_Client
+
+include $(IDF_PATH)/make/project.mk

examples/Advanced/NimBLE_Client/main/component.mk

@@ -0,0 +1,4 @@
+#
+# "main" pseudo-component makefile.
+#
+# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)

examples/Advanced/NimBLE_Client/main/main.cpp

@@ -0,0 +1,372 @@
+
+/** NimBLE_Client Demo:
+ *
+ *  Demonstrates many of the available features of the NimBLE client library.
+ *
+ *  Created: on March 24 2020
+ *      Author: H2zero
+ *
+*/
+#include <NimBLEDevice.h>
+
+extern "C" {void app_main(void);}
+
+static NimBLEAdvertisedDevice* advDevice;
+
+static bool doConnect = false;
+static uint32_t scanTime = 0; /** scan time in milliseconds, 0 = scan forever */
+
+
+/**  None of these are required as they will be handled by the library with defaults. **
+ **                       Remove as you see fit for your needs                        */
+class ClientCallbacks : public NimBLEClientCallbacks {
+    void onConnect(NimBLEClient* pClient) {
+        printf("Connected\n");
+        /** After connection we should change the parameters if we don't need fast response times.
+         *  These settings are 150ms interval, 0 latency, 450ms timout.
+         *  Timeout should be a multiple of the interval, minimum is 100ms.
+         *  I find a multiple of 3-5 * the interval works best for quick response/reconnect.
+         *  Min interval: 120 * 1.25ms = 150, Max interval: 120 * 1.25ms = 150, 0 latency, 45 * 10ms = 450ms timeout
+         */
+        pClient->updateConnParams(120,120,0,45);
+    }
+
+    void onDisconnect(NimBLEClient* pClient, int reason) {
+        printf("%s Disconnected, reason = %d - Starting scan\n",
+               pClient->getPeerAddress().toString().c_str(), reason);
+        NimBLEDevice::getScan()->start(scanTime);
+    }
+
+    /********************* Security handled here **********************
+    ****** Note: these are the same return values as defaults ********/
+    void onPassKeyEntry(NimBLEConnInfo& connInfo){
+        printf("Server Passkey Entry\n");
+        /** This should prompt the user to enter the passkey displayed
+         * on the peer device.
+         */
+        NimBLEDevice::injectPassKey(connInfo, 123456);
+    };
+
+    void onConfirmPasskey(NimBLEConnInfo& connInfo, uint32_t pass_key){
+        printf("The passkey YES/NO number: %" PRIu32 "\n", pass_key);
+        /** Inject false if passkeys don't match. */
+        NimBLEDevice::injectConfirmPasskey(connInfo, true);
+    };
+
+    /** Pairing process complete, we can check the results in connInfo */
+    void onAuthenticationComplete(NimBLEConnInfo& connInfo){
+        if(!connInfo.isEncrypted()) {
+            printf("Encrypt connection failed - disconnecting\n");
+            /** Find the client with the connection handle provided in desc */
+            NimBLEDevice::getClientByHandle(connInfo.getConnHandle())->disconnect();
+            return;
+        }
+    }
+};
+
+
+/** Define a class to handle the callbacks when advertisments are received */
+class scanCallbacks: public NimBLEScanCallbacks {
+    void onResult(NimBLEAdvertisedDevice* advertisedDevice) {
+        printf("Advertised Device found: %s\n", advertisedDevice->toString().c_str());
+        if(advertisedDevice->isAdvertisingService(NimBLEUUID("DEAD")))
+        {
+            printf("Found Our Service\n");
+            /** stop scan before connecting */
+            NimBLEDevice::getScan()->stop();
+            /** Save the device reference in a global for the client to use*/
+            advDevice = advertisedDevice;
+            /** Ready to connect now */
+            doConnect = true;
+        }
+    }
+
+    /** Callback to process the results of the completed scan or restart it */
+    void onScanEnd(NimBLEScanResults results) {
+        printf("Scan Ended\n");
+    }
+};
+
+
+/** Notification / Indication receiving handler callback */
+void notifyCB(NimBLERemoteCharacteristic* pRemoteCharacteristic, uint8_t* pData, size_t length, bool isNotify){
+    std::string str = (isNotify == true) ? "Notification" : "Indication";
+    str += " from ";
+    str += pRemoteCharacteristic->getClient()->getPeerAddress().toString();
+    str += ": Service = " + pRemoteCharacteristic->getRemoteService()->getUUID().toString();
+    str += ", Characteristic = " + pRemoteCharacteristic->getUUID().toString();
+    str += ", Value = " + std::string((char*)pData, length);
+    printf("%s\n", str.c_str());
+}
+
+
+/** Create a single global instance of the callback class to be used by all clients */
+static ClientCallbacks clientCB;
+
+
+/** Handles the provisioning of clients and connects / interfaces with the server */
+bool connectToServer() {
+    NimBLEClient* pClient = nullptr;
+
+    /** Check if we have a client we should reuse first **/
+    if(NimBLEDevice::getCreatedClientCount()) {
+        /** Special case when we already know this device, we send false as the
+         *  second argument in connect() to prevent refreshing the service database.
+         *  This saves considerable time and power.
+         */
+        pClient = NimBLEDevice::getClientByPeerAddress(advDevice->getAddress());
+        if(pClient){
+            if(!pClient->connect(advDevice, false)) {
+                printf("Reconnect failed\n");
+                return false;
+            }
+            printf("Reconnected client\n");
+        }
+        /** We don't already have a client that knows this device,
+         *  we will check for a client that is disconnected that we can use.
+         */
+        else {
+            pClient = NimBLEDevice::getDisconnectedClient();
+        }
+    }
+
+    /** No client to reuse? Create a new one. */
+    if(!pClient) {
+        if(NimBLEDevice::getCreatedClientCount() >= NIMBLE_MAX_CONNECTIONS) {
+            printf("Max clients reached - no more connections available\n");
+            return false;
+        }
+
+        pClient = NimBLEDevice::createClient();
+
+        printf("New client created\n");
+
+        pClient->setClientCallbacks(&clientCB, false);
+        /** Set initial connection parameters: These settings are 15ms interval, 0 latency, 120ms timout.
+         *  These settings are safe for 3 clients to connect reliably, can go faster if you have less
+         *  connections. Timeout should be a multiple of the interval, minimum is 100ms.
+         *  Min interval: 12 * 1.25ms = 15, Max interval: 12 * 1.25ms = 15, 0 latency, 12 * 10ms = 120ms timeout
+         */
+        pClient->setConnectionParams(6,6,0,15);
+        /** Set how long we are willing to wait for the connection to complete (milliseconds), default is 30000. */
+        pClient->setConnectTimeout(5 * 1000);
+
+
+        if (!pClient->connect(advDevice)) {
+            /** Created a client but failed to connect, don't need to keep it as it has no data */
+            NimBLEDevice::deleteClient(pClient);
+            printf("Failed to connect, deleted client\n");
+            return false;
+        }
+    }
+
+    if(!pClient->isConnected()) {
+        if (!pClient->connect(advDevice)) {
+            printf("Failed to connect\n");
+            return false;
+        }
+    }
+
+    printf("Connected to: %s RSSI: %d\n",
+          pClient->getPeerAddress().toString().c_str(),
+          pClient->getRssi());
+
+    /** Now we can read/write/subscribe the charateristics of the services we are interested in */
+    NimBLERemoteService* pSvc = nullptr;
+    NimBLERemoteCharacteristic* pChr = nullptr;
+    NimBLERemoteDescriptor* pDsc = nullptr;
+
+    pSvc = pClient->getService("DEAD");
+    if(pSvc) {     /** make sure it's not null */
+        pChr = pSvc->getCharacteristic("BEEF");
+    }
+
+    if(pChr) {     /** make sure it's not null */
+        if(pChr->canRead()) {
+            printf("%s Value: %s\n",
+            pChr->getUUID().toString().c_str(),
+            pChr->readValue().c_str());
+        }
+
+        if(pChr->canWrite()) {
+            if(pChr->writeValue("Tasty")) {
+                printf("Wrote new value to: %s\n", pChr->getUUID().toString().c_str());
+            }
+            else {
+                /** Disconnect if write failed */
+                pClient->disconnect();
+                return false;
+            }
+
+            if(pChr->canRead()) {
+                printf("The value of: %s is now: %s\n",
+                       pChr->getUUID().toString().c_str(),
+                       pChr->readValue().c_str());
+            }
+        }
+
+        /** registerForNotify() has been removed and replaced with subscribe() / unsubscribe().
+         *  Subscribe parameter defaults are: notifications=true, notifyCallback=nullptr, response=true.
+         *  Unsubscribe parameter defaults are: response=true.
+         */
+        if(pChr->canNotify()) {
+            //if(!pChr->registerForNotify(notifyCB)) {
+            if(!pChr->subscribe(true, notifyCB)) {
+                /** Disconnect if subscribe failed */
+                pClient->disconnect();
+                return false;
+            }
+        }
+        else if(pChr->canIndicate()) {
+            /** Send false as first argument to subscribe to indications instead of notifications */
+            //if(!pChr->registerForNotify(notifyCB, false)) {
+            if(!pChr->subscribe(false, notifyCB)) {
+                /** Disconnect if subscribe failed */
+                pClient->disconnect();
+                return false;
+            }
+        }
+    }
+
+    else{
+        printf("DEAD service not found.\n");
+    }
+
+    pSvc = pClient->getService("BAAD");
+    if(pSvc) {     /** make sure it's not null */
+        pChr = pSvc->getCharacteristic("F00D");
+    }
+
+    if(pChr) {     /** make sure it's not null */
+        if(pChr->canRead()) {
+            printf("%s Value: %s\n",
+            pChr->getUUID().toString().c_str(),
+            pChr->readValue().c_str());
+        }
+
+        pDsc = pChr->getDescriptor(NimBLEUUID("C01D"));
+        if(pDsc) {   /** make sure it's not null */
+            printf("Descriptor: %s  Value: %s\n",
+                   pDsc->getUUID().toString().c_str(),
+                   pDsc->readValue().c_str());
+        }
+
+        if(pChr->canWrite()) {
+            if(pChr->writeValue("No tip!")) {
+                printf("Wrote new value to: %s\n", pChr->getUUID().toString().c_str());
+            }
+            else {
+                /** Disconnect if write failed */
+                pClient->disconnect();
+                return false;
+            }
+
+            if(pChr->canRead()) {
+                printf("The value of: %s is now: %s\n",
+                       pChr->getUUID().toString().c_str(),
+                       pChr->readValue().c_str());
+            }
+        }
+
+        /** registerForNotify() has been deprecated and replaced with subscribe() / unsubscribe().
+         *  Subscribe parameter defaults are: notifications=true, notifyCallback=nullptr, response=true.
+         *  Unsubscribe parameter defaults are: response=true.
+         */
+        if(pChr->canNotify()) {
+            //if(!pChr->registerForNotify(notifyCB)) {
+            if(!pChr->subscribe(true, notifyCB)) {
+                /** Disconnect if subscribe failed */
+                pClient->disconnect();
+                return false;
+            }
+        }
+        else if(pChr->canIndicate()) {
+            /** Send false as first argument to subscribe to indications instead of notifications */
+            //if(!pChr->registerForNotify(notifyCB, false)) {
+            if(!pChr->subscribe(false, notifyCB)) {
+                /** Disconnect if subscribe failed */
+                pClient->disconnect();
+                return false;
+            }
+        }
+    }
+
+    else{
+        printf("BAAD service not found.\n");
+    }
+
+    printf("Done with this device!\n");
+    return true;
+}
+
+void connectTask (void * parameter){
+    /** Loop here until we find a device we want to connect to */
+    for(;;) {
+        if(doConnect) {
+            doConnect = false;
+            /** Found a device we want to connect to, do it now */
+            if(connectToServer()) {
+                printf("Success! we should now be getting notifications, scanning for more!\n");
+            } else {
+                printf("Failed to connect, starting scan\n");
+            }
+
+            NimBLEDevice::getScan()->start(scanTime);
+        }
+        vTaskDelay(10/portTICK_PERIOD_MS);
+    }
+
+    vTaskDelete(NULL);
+}
+
+void app_main (void){
+    printf("Starting NimBLE Client\n");
+    /** Initialize NimBLE, no device name spcified as we are not advertising */
+    NimBLEDevice::init("");
+
+    /** Set the IO capabilities of the device, each option will trigger a different pairing method.
+     *  BLE_HS_IO_KEYBOARD_ONLY    - Passkey pairing
+     *  BLE_HS_IO_DISPLAY_YESNO   - Numeric comparison pairing
+     *  BLE_HS_IO_NO_INPUT_OUTPUT - DEFAULT setting - just works pairing
+     */
+    //NimBLEDevice::setSecurityIOCap(BLE_HS_IO_KEYBOARD_ONLY); // use passkey
+    //NimBLEDevice::setSecurityIOCap(BLE_HS_IO_DISPLAY_YESNO); //use numeric comparison
+
+    /** 2 different ways to set security - both calls achieve the same result.
+     *  no bonding, no man in the middle protection, secure connections.
+     *
+     *  These are the default values, only shown here for demonstration.
+     */
+    //NimBLEDevice::setSecurityAuth(false, false, true);
+    NimBLEDevice::setSecurityAuth(/*BLE_SM_PAIR_AUTHREQ_BOND | BLE_SM_PAIR_AUTHREQ_MITM |*/ BLE_SM_PAIR_AUTHREQ_SC);
+
+    /** Optional: set the transmit power, default is -3db */
+    NimBLEDevice::setPower(ESP_PWR_LVL_P9); /** 12db */
+
+    /** Optional: set any devices you don't want to get advertisments from */
+    // NimBLEDevice::addIgnored(NimBLEAddress ("aa:bb:cc:dd:ee:ff"));
+
+    /** create new scan */
+    NimBLEScan* pScan = NimBLEDevice::getScan();
+
+    /** create a callback that gets called when advertisers are found */
+    pScan->setScanCallbacks (new scanCallbacks());
+
+    /** Set scan interval (how often) and window (how long) in milliseconds */
+    pScan->setInterval(400);
+    pScan->setWindow(100);
+
+    /** Active scan will gather scan response data from advertisers
+     *  but will use more energy from both devices
+     */
+    pScan->setActiveScan(true);
+    /** Start scanning for advertisers for the scan time specified (in milliseconds) 0 = forever
+     *  Optional callback for when scanning stops.
+     */
+    pScan->start(scanTime);
+
+    printf("Scanning for peripherals\n");
+
+    xTaskCreate(connectTask, "connectTask", 5000, NULL, 1, NULL);
+}
+

examples/Advanced/NimBLE_Server/CMakeLists.txt

@@ -3,4 +3,5 @@
 cmake_minimum_required(VERSION 3.5)
 
 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+set(SUPPORTED_TARGETS esp32)
 project(NimBLE_Server)

examples/Advanced/NimBLE_Server/Makefile

@@ -0,0 +1,3 @@
+PROJECT_NAME := NimBLE_Server
+
+include $(IDF_PATH)/make/project.mk

examples/Advanced/NimBLE_Server/main/component.mk

@@ -0,0 +1,4 @@
+#
+# "main" pseudo-component makefile.
+#
+# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)

examples/Advanced/NimBLE_Server/main/main.cpp

@@ -1,186 +1,224 @@
 
-/**
- *  NimBLE_Server Demo:
+/** NimBLE_Server Demo:
  *
  *  Demonstrates many of the available features of the NimBLE server library.
  *
  *  Created: on March 22 2020
  *      Author: H2zero
- */
+ *
+*/
+#include "NimBLEDevice.h"
+#include "NimBLELog.h"
 
-#include <NimBLEDevice.h>
+#include <stdio.h>
+
+extern "C" {void app_main(void);}
 
 static NimBLEServer* pServer;
 
 /**  None of these are required as they will be handled by the library with defaults. **
  **                       Remove as you see fit for your needs                        */
-class ServerCallbacks : public NimBLEServerCallbacks {
-    void onConnect(NimBLEServer* pServer, NimBLEConnInfo& connInfo) override {
+class ServerCallbacks: public NimBLEServerCallbacks {
+    void onConnect(NimBLEServer* pServer, NimBLEConnInfo& connInfo) {
         printf("Client address: %s\n", connInfo.getAddress().toString().c_str());
 
-        /**
-         *  We can use the connection handle here to ask for different connection parameters.
+        /** We can use the connection handle here to ask for different connection parameters.
          *  Args: connection handle, min connection interval, max connection interval
          *  latency, supervision timeout.
          *  Units; Min/Max Intervals: 1.25 millisecond increments.
          *  Latency: number of intervals allowed to skip.
-         *  Timeout: 10 millisecond increments.
+         *  Timeout: 10 millisecond increments, try for 3x interval time for best results.
          */
         pServer->updateConnParams(connInfo.getConnHandle(), 24, 48, 0, 18);
-    }
+    };
 
-    void onDisconnect(NimBLEServer* pServer, NimBLEConnInfo& connInfo, int reason) override {
+    void onDisconnect(NimBLEServer* pServer, NimBLEConnInfo& connInfo, int reason) {
         printf("Client disconnected - start advertising\n");
         NimBLEDevice::startAdvertising();
-    }
+    };
 
-    void onMTUChange(uint16_t MTU, NimBLEConnInfo& connInfo) override {
+    void onMTUChange(uint16_t MTU, NimBLEConnInfo& connInfo) {
         printf("MTU updated: %u for connection ID: %u\n", MTU, connInfo.getConnHandle());
-    }
+        pServer->updateConnParams(connInfo.getConnHandle(), 24, 48, 0, 60);
+    };
 
-    /********************* Security handled here *********************/
-    uint32_t onPassKeyDisplay() override {
+/********************* Security handled here **********************
+****** Note: these are the same return values as defaults ********/
+    uint32_t onPassKeyDisplay(){
         printf("Server Passkey Display\n");
-        /**
-         * This should return a random 6 digit number for security
+        /** This should return a random 6 digit number for security
          *  or make your own static passkey as done here.
          */
         return 123456;
-    }
+    };
 
-    void onConfirmPassKey(NimBLEConnInfo& connInfo, uint32_t pass_key) override {
+    void onConfirmasskeyN(NimBLEConnInfo& connInfo, uint32_t pass_key){
         printf("The passkey YES/NO number: %" PRIu32 "\n", pass_key);
         /** Inject false if passkeys don't match. */
         NimBLEDevice::injectConfirmPasskey(connInfo, true);
-    }
+    };
 
-    void onAuthenticationComplete(NimBLEConnInfo& connInfo) override {
+    void onAuthenticationComplete(NimBLEConnInfo& connInfo){
         /** Check that encryption was successful, if not we disconnect the client */
-        if (!connInfo.isEncrypted()) {
+        if(!connInfo.isEncrypted()) {
             NimBLEDevice::getServer()->disconnect(connInfo.getConnHandle());
             printf("Encrypt connection failed - disconnecting client\n");
             return;
         }
-
-        printf("Secured connection to: %s\n", connInfo.getAddress().toString().c_str());
-    }
-} serverCallbacks;
+        printf("Starting BLE work!");
+    };
+};
 
 /** Handler class for characteristic actions */
-class CharacteristicCallbacks : public NimBLECharacteristicCallbacks {
-    void onRead(NimBLECharacteristic* pCharacteristic, NimBLEConnInfo& connInfo) override {
+class CharacteristicCallbacks: public NimBLECharacteristicCallbacks {
+    void onRead(NimBLECharacteristic* pCharacteristic, NimBLEConnInfo& connInfo) {
         printf("%s : onRead(), value: %s\n",
                pCharacteristic->getUUID().toString().c_str(),
                pCharacteristic->getValue().c_str());
     }
 
-    void onWrite(NimBLECharacteristic* pCharacteristic, NimBLEConnInfo& connInfo) override {
+    void onWrite(NimBLECharacteristic* pCharacteristic, NimBLEConnInfo& connInfo) {
         printf("%s : onWrite(), value: %s\n",
                pCharacteristic->getUUID().toString().c_str(),
                pCharacteristic->getValue().c_str());
     }
 
+    /** Called before notification or indication is sent,
+     *  the value can be changed here before sending if desired.
+     */
+    void onNotify(NimBLECharacteristic* pCharacteristic) {
+        printf("Sending notification to clients\n");
+    }
+
     /**
      *  The value returned in code is the NimBLE host return code.
      */
-    void onStatus(NimBLECharacteristic* pCharacteristic, int code) override {
-        printf("Notification/Indication return code: %d, %s\n", code, NimBLEUtils::returnCodeToString(code));
+    void onStatus(NimBLECharacteristic* pCharacteristic, int code) {
+        printf("Notification/Indication return code: %d, %s\n",
+               code, NimBLEUtils::returnCodeToString(code));
     }
 
-    /** Peer subscribed to notifications/indications */
-    void onSubscribe(NimBLECharacteristic* pCharacteristic, NimBLEConnInfo& connInfo, uint16_t subValue) override {
-        std::string str  = "Client ID: ";
-        str             += connInfo.getConnHandle();
-        str             += " Address: ";
-        str             += connInfo.getAddress().toString();
-        if (subValue == 0) {
+    void onSubscribe(NimBLECharacteristic* pCharacteristic, NimBLEConnInfo& connInfo, uint16_t subValue) {
+        std::string str = "Client ID: ";
+        str += connInfo.getConnHandle();
+        str += " Address: ";
+        str += connInfo.getAddress().toString();
+        if(subValue == 0) {
             str += " Unsubscribed to ";
-        } else if (subValue == 1) {
-            str += " Subscribed to notifications for ";
-        } else if (subValue == 2) {
+        }else if(subValue == 1) {
+            str += " Subscribed to notfications for ";
+        } else if(subValue == 2) {
             str += " Subscribed to indications for ";
-        } else if (subValue == 3) {
+        } else if(subValue == 3) {
             str += " Subscribed to notifications and indications for ";
         }
         str += std::string(pCharacteristic->getUUID());
 
         printf("%s\n", str.c_str());
     }
-} chrCallbacks;
+};
 
 /** Handler class for descriptor actions */
 class DescriptorCallbacks : public NimBLEDescriptorCallbacks {
-    void onWrite(NimBLEDescriptor* pDescriptor, NimBLEConnInfo& connInfo) override {
+    void onWrite(NimBLEDescriptor* pDescriptor, NimBLEConnInfo& connInfo) {
         std::string dscVal = pDescriptor->getValue();
-        printf("Descriptor written value: %s\n", dscVal.c_str());
-    }
+        printf("Descriptor witten value: %s\n", dscVal.c_str());
+    };
 
-    void onRead(NimBLEDescriptor* pDescriptor, NimBLEConnInfo& connInfo) override {
+    void onRead(NimBLEDescriptor* pDescriptor, NimBLEConnInfo& connInfo) {
         printf("%s Descriptor read\n", pDescriptor->getUUID().toString().c_str());
-    }
-} dscCallbacks;
+    };;
+};
 
-extern "C" void app_main(void) {
+
+/** Define callback instances globally to use for multiple Charateristics \ Descriptors */
+static DescriptorCallbacks dscCallbacks;
+static CharacteristicCallbacks chrCallbacks;
+
+void notifyTask(void * parameter){
+    for(;;) {
+        if(pServer->getConnectedCount()) {
+            NimBLEService* pSvc = pServer->getServiceByUUID("BAAD");
+            if(pSvc) {
+                NimBLECharacteristic* pChr = pSvc->getCharacteristic("F00D");
+                if(pChr) {
+                    pChr->notify();
+                }
+            }
+        }
+        vTaskDelay(2000/portTICK_PERIOD_MS);
+    }
+
+    vTaskDelete(NULL);
+}
+
+void app_main(void) {
     printf("Starting NimBLE Server\n");
 
-    /** Initialize NimBLE and set the device name */
+    /** sets device name */
     NimBLEDevice::init("NimBLE");
 
-    /**
-     * Set the IO capabilities of the device, each option will trigger a different pairing method.
+    /** Set the IO capabilities of the device, each option will trigger a different pairing method.
      *  BLE_HS_IO_DISPLAY_ONLY    - Passkey pairing
      *  BLE_HS_IO_DISPLAY_YESNO   - Numeric comparison pairing
      *  BLE_HS_IO_NO_INPUT_OUTPUT - DEFAULT setting - just works pairing
      */
-    // NimBLEDevice::setSecurityIOCap(BLE_HS_IO_DISPLAY_ONLY); // use passkey
-    // NimBLEDevice::setSecurityIOCap(BLE_HS_IO_DISPLAY_YESNO); //use numeric comparison
+    //NimBLEDevice::setSecurityIOCap(BLE_HS_IO_DISPLAY_ONLY); // use passkey
+    //NimBLEDevice::setSecurityIOCap(BLE_HS_IO_DISPLAY_YESNO); //use numeric comparison
 
-    /**
-     *  2 different ways to set security - both calls achieve the same result.
-     *  no bonding, no man in the middle protection, BLE secure connections.
+    /** 2 different ways to set security - both calls achieve the same result.
+     *  no bonding, no man in the middle protection, secure connections.
      *
      *  These are the default values, only shown here for demonstration.
      */
-    // NimBLEDevice::setSecurityAuth(false, false, true);
-
+    //NimBLEDevice::setSecurityAuth(false, false, true);
     NimBLEDevice::setSecurityAuth(/*BLE_SM_PAIR_AUTHREQ_BOND | BLE_SM_PAIR_AUTHREQ_MITM |*/ BLE_SM_PAIR_AUTHREQ_SC);
-    pServer = NimBLEDevice::createServer();
-    pServer->setCallbacks(&serverCallbacks);
 
-    NimBLEService*        pDeadService = pServer->createService("DEAD");
-    NimBLECharacteristic* pBeefCharacteristic =
-        pDeadService->createCharacteristic("BEEF",
-                                           NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE |
-                                               /** Require a secure connection for read and write access */
-                                               NIMBLE_PROPERTY::READ_ENC | // only allow reading if paired / encrypted
-                                               NIMBLE_PROPERTY::WRITE_ENC  // only allow writing if paired / encrypted
-        );
+    pServer = NimBLEDevice::createServer();
+    pServer->setCallbacks(new ServerCallbacks());
+
+    NimBLEService* pDeadService = pServer->createService("DEAD");
+    NimBLECharacteristic* pBeefCharacteristic = pDeadService->createCharacteristic(
+                                               "BEEF",
+                                               NIMBLE_PROPERTY::READ |
+                                               NIMBLE_PROPERTY::WRITE |
+                               /** Require a secure connection for read and write access */
+                                               NIMBLE_PROPERTY::READ_ENC |  // only allow reading if paired / encrypted
+                                               NIMBLE_PROPERTY::WRITE_ENC   // only allow writing if paired / encrypted
+                                              );
 
     pBeefCharacteristic->setValue("Burger");
     pBeefCharacteristic->setCallbacks(&chrCallbacks);
 
-    /**
-     *  2902 and 2904 descriptors are a special case, when createDescriptor is called with
+    /** 2902 and 2904 descriptors are a special case, when createDescriptor is called with
      *  either of those uuid's it will create the associated class with the correct properties
      *  and sizes. However we must cast the returned reference to the correct type as the method
      *  only returns a pointer to the base NimBLEDescriptor class.
      */
-    NimBLE2904* pBeef2904 = pBeefCharacteristic->create2904();
+    NimBLE2904* pBeef2904 = (NimBLE2904*)pBeefCharacteristic->createDescriptor("2904");
     pBeef2904->setFormat(NimBLE2904::FORMAT_UTF8);
     pBeef2904->setCallbacks(&dscCallbacks);
 
-    NimBLEService*        pBaadService = pServer->createService("BAAD");
-    NimBLECharacteristic* pFoodCharacteristic =
-        pBaadService->createCharacteristic("F00D", NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::NOTIFY);
+
+    NimBLEService* pBaadService = pServer->createService("BAAD");
+    NimBLECharacteristic* pFoodCharacteristic = pBaadService->createCharacteristic(
+                                               "F00D",
+                                               NIMBLE_PROPERTY::READ |
+                                               NIMBLE_PROPERTY::WRITE |
+                                               NIMBLE_PROPERTY::NOTIFY
+                                              );
 
     pFoodCharacteristic->setValue("Fries");
     pFoodCharacteristic->setCallbacks(&chrCallbacks);
 
-    /** Custom descriptor: Arguments are UUID, Properties, max length of the value in bytes */
-    NimBLEDescriptor* pC01Ddsc =
-        pFoodCharacteristic->createDescriptor("C01D",
-                                              NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::WRITE_ENC,
-                                              20);
+    /** Custom descriptor: Arguments are UUID, Properties, max length in bytes of the value */
+    NimBLEDescriptor* pC01Ddsc = pFoodCharacteristic->createDescriptor(
+                                               "C01D",
+                                               NIMBLE_PROPERTY::READ |
+                                               NIMBLE_PROPERTY::WRITE|
+                                               NIMBLE_PROPERTY::WRITE_ENC, // only allow writing if paired / encrypted
+                                               20
+                                              );
     pC01Ddsc->setValue("Send it back!");
     pC01Ddsc->setCallbacks(&dscCallbacks);
 
@@ -188,31 +226,17 @@ extern "C" void app_main(void) {
     pDeadService->start();
     pBaadService->start();
 
-    /** Create an advertising instance and add the services to the advertised data */
     NimBLEAdvertising* pAdvertising = NimBLEDevice::getAdvertising();
-    pAdvertising->setName("NimBLE-Server");
+    /** Add the services to the advertisment data **/
     pAdvertising->addServiceUUID(pDeadService->getUUID());
     pAdvertising->addServiceUUID(pBaadService->getUUID());
-    /**
-     *  If your device is battery powered you may consider setting scan response
+    /** If your device is battery powered you may consider setting scan response
      *  to false as it will extend battery life at the expense of less data sent.
      */
-    pAdvertising->enableScanResponse(true);
+    pAdvertising->setScanResponse(true);
     pAdvertising->start();
 
     printf("Advertising Started\n");
 
-    /** Loop here and send notifications to connected peers */
-    for (;;) {
-        if (pServer->getConnectedCount()) {
-            NimBLEService* pSvc = pServer->getServiceByUUID("BAAD");
-            if (pSvc) {
-                NimBLECharacteristic* pChr = pSvc->getCharacteristic("F00D");
-                if (pChr) {
-                    pChr->notify();
-                }
-            }
-        }
-        vTaskDelay(2000 / portTICK_PERIOD_MS);
-    }
+    xTaskCreate(notifyTask, "notifyTask", 5000, NULL, 1, NULL);
 }

examples/Bluetooth_5/NimBLE_extended_client/CMakeLists.txt

@@ -3,4 +3,5 @@
 cmake_minimum_required(VERSION 3.5)
 
 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+set(SUPPORTED_TARGETS esp32c3 esp32s3)
 project(NimBLE_extended_client)

examples/Bluetooth_5/NimBLE_extended_client/Makefile

@@ -0,0 +1,3 @@
+PROJECT_NAME := NimBLE_extended_client
+
+include $(IDF_PATH)/make/project.mk

examples/Bluetooth_5/NimBLE_extended_client/main/component.mk

@@ -0,0 +1,4 @@
+#
+# "main" pseudo-component makefile.
+#
+# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)

examples/Bluetooth_5/NimBLE_extended_client/main/main.cpp

@@ -1,62 +1,71 @@
 
-/**
- *  NimBLE Extended Client Demo:
+/** NimBLE Extended Client Demo:
  *
  *  Demonstrates the Bluetooth 5.x client capabilities.
  *
  *  Created: on April 2 2022
  *      Author: H2zero
- */
-
+ *
+*/
 #include <NimBLEDevice.h>
 
+extern "C" void app_main(void);
+
 #define SERVICE_UUID        "ABCD"
 #define CHARACTERISTIC_UUID "1234"
 
-static const NimBLEAdvertisedDevice* advDevice;
-static bool                          doConnect = false;
-static uint32_t                      scanTime  = 10 * 1000; // In milliseconds, 0 = scan forever
+static NimBLEAdvertisedDevice* advDevice;
+static bool doConnect = false;
+static uint32_t scanTime = 10 * 1000; // In milliseconds, 0 = scan forever
 
-/** Define the PHY's to use when connecting to peer devices, can be 1, 2, or all 3 (default).*/
-static uint8_t connectPhys = BLE_GAP_LE_PHY_CODED_MASK | BLE_GAP_LE_PHY_1M_MASK /*| BLE_GAP_LE_PHY_2M_MASK */;
+/* Define the PHY's to use when connecting to peer devices, can be 1, 2, or all 3 (default).*/
+static uint8_t connectPhys = BLE_GAP_LE_PHY_CODED_MASK | BLE_GAP_LE_PHY_1M_MASK /*| BLE_GAP_LE_PHY_2M_MASK */ ;
 
-/** Define a class to handle the callbacks for client connection events */
+/* Define a class to handle the callbacks for client connection events */
 class ClientCallbacks : public NimBLEClientCallbacks {
-    void onConnect(NimBLEClient* pClient) override { printf("Connected\n"); };
+    void onConnect(NimBLEClient* pClient) {
+        printf("Connected\n");
+    };
 
-    void onDisconnect(NimBLEClient* pClient, int reason) override {
-        printf("%s Disconnected, reason = %d - Starting scan\n", pClient->getPeerAddress().toString().c_str(), reason);
+    void onDisconnect(NimBLEClient* pClient, int reason) {
+        printf("%s Disconnected, reason = %d - Starting scan\n",
+                      pClient->getPeerAddress().toString().c_str(), reason);
         NimBLEDevice::getScan()->start(scanTime);
-    }
-} clientCallbacks;
+    };
+};
 
-/** Define a class to handle the callbacks when advertisements are received */
-class scanCallbacks : public NimBLEScanCallbacks {
-    void onResult(const NimBLEAdvertisedDevice* advertisedDevice) override {
+
+/* Define a class to handle the callbacks when advertisements are received */
+class scanCallbacks: public NimBLEScanCallbacks {
+    void onResult(NimBLEAdvertisedDevice* advertisedDevice) {
         printf("Advertised Device found: %s\n", advertisedDevice->toString().c_str());
-        if (advertisedDevice->isAdvertisingService(NimBLEUUID("ABCD"))) {
+        if(advertisedDevice->isAdvertisingService(NimBLEUUID("ABCD")))
+        {
             printf("Found Our Service\n");
+            /* Ready to connect now */
             doConnect = true;
-            /** Save the device reference in a global for the client to use*/
+            /* Save the device reference in a global for the client to use*/
             advDevice = advertisedDevice;
-            /** stop scan before connecting */
+            /* stop scan before connecting */
             NimBLEDevice::getScan()->stop();
         }
     }
 
     /** Callback to process the results of the completed scan or restart it */
-    void onScanEnd(const NimBLEScanResults& results, int rc) override { printf("Scan Ended\n"); }
-} scanCallbacks;
+    void onScanEnd(NimBLEScanResults results) {
+        printf("Scan Ended\n");
+    }
+};
 
-/** Handles the provisioning of clients and connects / interfaces with the server */
+
+/* Handles the provisioning of clients and connects / interfaces with the server */
 bool connectToServer() {
     NimBLEClient* pClient = nullptr;
 
     pClient = NimBLEDevice::createClient();
-    pClient->setClientCallbacks(&clientCallbacks, false);
+    pClient->setClientCallbacks(new ClientCallbacks, false);
 
-    /**
-     * Set the PHY's to use for this connection. This is a bitmask that represents the PHY's:
+    /* Set the PHY's to use for this connection. This is a bitmask that represents the PHY's:
      * * 0x01 BLE_GAP_LE_PHY_1M_MASK
      * * 0x02 BLE_GAP_LE_PHY_2M_MASK
      * * 0x04 BLE_GAP_LE_PHY_CODED_MASK
@@ -68,22 +77,27 @@ bool connectToServer() {
     pClient->setConnectTimeout(10 * 1000);
 
     if (!pClient->connect(advDevice)) {
-        /** Created a client but failed to connect, don't need to keep it as it has no data */
+        /* Created a client but failed to connect, don't need to keep it as it has no data */
         NimBLEDevice::deleteClient(pClient);
         printf("Failed to connect, deleted client\n");
         return false;
     }
 
-    printf("Connected to: %s RSSI: %d\n", pClient->getPeerAddress().toString().c_str(), pClient->getRssi());
+    printf("Connected to: %s RSSI: %d\n",
+           pClient->getPeerAddress().toString().c_str(),
+           pClient->getRssi());
 
-    /** Now we can read/write/subscribe the characteristics of the services we are interested in */
-    NimBLERemoteService*        pSvc = nullptr;
+    /* Now we can read/write/subscribe the charateristics of the services we are interested in */
+    NimBLERemoteService* pSvc = nullptr;
     NimBLERemoteCharacteristic* pChr = nullptr;
 
     pSvc = pClient->getService(SERVICE_UUID);
+
     if (pSvc) {
         pChr = pSvc->getCharacteristic(CHARACTERISTIC_UUID);
+
         if (pChr) {
+            // Read the value of the characteristic.
             if (pChr->canRead()) {
                 std::string value = pChr->readValue();
                 printf("Characteristic value: %s\n", value.c_str());
@@ -99,37 +113,11 @@ bool connectToServer() {
     return true;
 }
 
-extern "C" void app_main(void) {
-    printf("Starting NimBLE Client\n");
-
-    /** Initialize NimBLE and set the device name */
-    NimBLEDevice::init("NimBLE Extended Client");
-
-    /** Create aNimBLE Scan instance and set the callbacks for scan events */
-    NimBLEScan* pScan = NimBLEDevice::getScan();
-    pScan->setScanCallbacks(&scanCallbacks);
-
-    /** Set scan interval (how often) and window (how long) in milliseconds */
-    pScan->setInterval(97);
-    pScan->setWindow(67);
-
-    /**
-     * Active scan will gather scan response data from advertisers
-     *  but will use more energy from both devices
-     */
-    pScan->setActiveScan(true);
-
-    /**
-     *  Start scanning for advertisers for the scan time specified (in milliseconds) 0 = forever
-     *  Optional callback for when scanning stops.
-     */
-    pScan->start(scanTime);
-
-    printf("Scanning for peripherals\n");
-
-    /** Loop here until we find a device we want to connect to */
+void connectTask (void * parameter){
+    /* Loop here until we find a device we want to connect to */
     for (;;) {
         if (doConnect) {
+            /* Found a device we want to connect to, do it now */
             if (connectToServer()) {
                 printf("Success!, scanning for more!\n");
             } else {
@@ -141,4 +129,35 @@ extern "C" void app_main(void) {
         }
         vTaskDelay(pdMS_TO_TICKS(10));
     }
+
+    vTaskDelete(NULL);
+}
+
+void app_main (void) {
+    printf("Starting NimBLE Client\n");
+    /* Create a task to handle connecting to peers */
+    xTaskCreate(connectTask, "connectTask", 5000, NULL, 1, NULL);
+
+    /* Initialize NimBLE, no device name specified as we are not advertising */
+    NimBLEDevice::init("");
+    NimBLEScan* pScan = NimBLEDevice::getScan();
+
+    /* create a callback that gets called when advertisers are found */
+    pScan->setScanCallbacks(new scanCallbacks());
+
+    /* Set scan interval (how often) and window (how long) in milliseconds */
+    pScan->setInterval(97);
+    pScan->setWindow(67);
+
+    /*  Active scan will gather scan response data from advertisers
+     *  but will use more energy from both devices
+     */
+    pScan->setActiveScan(true);
+
+    /*  Start scanning for advertisers for the scan time specified (in milliseconds) 0 = forever
+     *  Optional callback for when scanning stops.
+     */
+    pScan->start(scanTime);
+
+    printf("Scanning for peripherals\n");
 }

examples/Bluetooth_5/NimBLE_extended_scan/main/main.cpp

@@ -1,69 +0,0 @@
-/**
- *  NimBLE Extended Scanner Demo:
- *
- *  Demonstrates the Bluetooth 5.x scanning capabilities of the NimBLE library.
- *
- *  Created: on November 28, 2024
- *      Author: H2zero
- */
-
-#include <NimBLEDevice.h>
-
-static uint32_t        scanTime = 10 * 1000; // In milliseconds, 0 = scan forever
-static NimBLEScan::Phy scanPhy  = NimBLEScan::Phy::SCAN_ALL;
-
-/** Define a class to handle the callbacks when advertisements are received */
-class ScanCallbacks : public NimBLEScanCallbacks {
-    void onResult(const NimBLEAdvertisedDevice* advertisedDevice) {
-        printf("Advertised Device found: %s\n PHY1: %d\n PHY2: %d\n",
-               advertisedDevice->toString().c_str(),
-               advertisedDevice->getPrimaryPhy(),
-               advertisedDevice->getSecondaryPhy());
-    }
-
-    /** Callback to process the results of the completed scan or restart it */
-    void onScanEnd(const NimBLEScanResults& scanResults, int reason) {
-        printf("Scan Ended, reason: %d; found %d devices\n", reason, scanResults.getCount());
-
-        /** Try Different PHY's */
-        switch (scanPhy) {
-            case NimBLEScan::Phy::SCAN_ALL:
-                printf("Scanning only 1M PHY\n");
-                scanPhy = NimBLEScan::Phy::SCAN_1M;
-                break;
-            case NimBLEScan::Phy::SCAN_1M:
-                printf("Scanning only CODED PHY\n");
-                scanPhy = NimBLEScan::Phy::SCAN_CODED;
-                break;
-            case NimBLEScan::Phy::SCAN_CODED:
-                printf("Scanning all PHY's\n");
-                scanPhy = NimBLEScan::Phy::SCAN_ALL;
-                break;
-        }
-
-        NimBLEScan* pScan = NimBLEDevice::getScan();
-        pScan->setPhy(scanPhy);
-        pScan->start(scanTime);
-    }
-} scanCallbacks;
-
-extern "C" void app_main(void) {
-    printf("Starting Extended Scanner\n");
-
-    /** Initialize NimBLE and set the device name */
-    NimBLEDevice::init("NimBLE Extended Scanner");
-    NimBLEScan* pScan = NimBLEDevice::getScan();
-
-    /** Set the callbacks that the scanner will call on events. */
-    pScan->setScanCallbacks(&scanCallbacks);
-
-    /** Use active scanning to obtain scan response data from advertisers */
-    pScan->setActiveScan(true);
-
-    /** Set the initial PHY's to scan on, default is SCAN_ALL */
-    pScan->setPhy(scanPhy);
-
-    /** Start scanning for scanTime */
-    pScan->start(scanTime);
-    printf("Scanning for peripherals\n");
-}

examples/Bluetooth_5/NimBLE_extended_server/CMakeLists.txt

@@ -3,4 +3,5 @@
 cmake_minimum_required(VERSION 3.5)
 
 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+set(SUPPORTED_TARGETS esp32c3 esp32s3)
 project(NimBLE_extended_server)

examples/Bluetooth_5/NimBLE_extended_server/Makefile

@@ -0,0 +1,3 @@
+PROJECT_NAME := NimBLE_extended_server
+
+include $(IDF_PATH)/make/project.mk

examples/Bluetooth_5/NimBLE_extended_server/main/component.mk

@@ -0,0 +1,4 @@
+#
+# "main" pseudo-component makefile.
+#
+# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)

examples/Bluetooth_5/NimBLE_extended_server/main/main.cpp

@@ -1,5 +1,4 @@
-/**
- *  NimBLE Extended Server Demo:
+/** NimBLE Extended Server Demo:
  *
  *  Demonstrates the Bluetooth 5.x extended advertising capabilities.
  *
@@ -10,52 +9,55 @@
  *
  *  Created: on April 2 2022
  *      Author: H2zero
- */
+ *
+*/
 
-#include <NimBLEDevice.h>
-#include <esp_sleep.h>
+#include "NimBLEDevice.h"
+#include "esp_sleep.h"
+
+extern "C" void app_main(void);
 
 #define SERVICE_UUID        "ABCD"
 #define CHARACTERISTIC_UUID "1234"
 
-/** Time in milliseconds to advertise */
+/* Time in milliseconds to advertise */
 static uint32_t advTime = 5000;
 
-/** Time to sleep between advertisements */
+/* Time to sleep between advertisements */
 static uint32_t sleepSeconds = 20;
 
-/** Primary PHY used for advertising, can be one of BLE_HCI_LE_PHY_1M or BLE_HCI_LE_PHY_CODED */
+/* Primary PHY used for advertising, can be one of BLE_HCI_LE_PHY_1M or BLE_HCI_LE_PHY_CODED */
 static uint8_t primaryPhy = BLE_HCI_LE_PHY_CODED;
 
-/**
- *  Secondary PHY used for advertising and connecting,
- *  can be one of BLE_HCI_LE_PHY_1M, BLE_HCI_LE_PHY_2M or BLE_HCI_LE_PHY_CODED
+/* Secondary PHY used for advertising and connecting,
+ * can be one of BLE_HCI_LE_PHY_1M, BLE_HCI_LE_PHY_2M or BLE_HCI_LE_PHY_CODED
  */
 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 {
+
+/* Handler class for server events */
+class ServerCallbacks: public NimBLEServerCallbacks {
+    void onConnect(NimBLEServer* pServer, NimBLEConnInfo& connInfo) {
         printf("Client connected:: %s\n", connInfo.getAddress().toString().c_str());
-    }
+    };
 
-    void onDisconnect(NimBLEServer* pServer, NimBLEConnInfo& connInfo, int reason) override {
-        printf("Client disconnected - sleeping for %" PRIu32 " seconds\n", sleepSeconds);
+    void onDisconnect(NimBLEServer* pServer, NimBLEConnInfo& connInfo, int reason) {
+        printf("Client disconnected - sleeping for %" PRIu32" seconds\n", sleepSeconds);
         esp_deep_sleep_start();
-    }
-} serverCallbacks;
+    };
+};
 
-/** Callback class to handle advertising events */
-class AdvertisingCallbacks : public NimBLEExtAdvertisingCallbacks {
-    void onStopped(NimBLEExtAdvertising* pAdv, int reason, uint8_t instId) override {
+/* Callback class to handle advertising events */
+class advertisingCallbacks: public NimBLEExtAdvertisingCallbacks {
+    void onStopped(NimBLEExtAdvertising* pAdv, int reason, uint8_t inst_id) {
         /* Check the reason advertising stopped, don't sleep if client is connecting */
-        printf("Advertising instance %u stopped\n", instId);
+        printf("Advertising instance %u stopped\n", inst_id);
         switch (reason) {
             case 0:
                 printf("Client connecting\n");
                 return;
             case BLE_HS_ETIMEOUT:
-                printf("Time expired - sleeping for %" PRIu32 " seconds\n", sleepSeconds);
+                printf("Time expired - sleeping for %" PRIu32" seconds\n", sleepSeconds);
                 break;
             default:
                 break;
@@ -63,69 +65,66 @@ class AdvertisingCallbacks : public NimBLEExtAdvertisingCallbacks {
 
         esp_deep_sleep_start();
     }
-} advertisingCallbacks;
+};
 
-extern "C"
-void app_main(void) {
-    /** Initialize NimBLE and set the device name */
+void app_main (void) {
     NimBLEDevice::init("Extended advertiser");
 
-    /** Create the server and add the services/characteristics/descriptors */
-    NimBLEServer* pServer = NimBLEDevice::createServer();
-    pServer->setCallbacks(&serverCallbacks);
+    /* Create the server and add the services/characteristics/descriptors */
+    NimBLEServer *pServer = NimBLEDevice::createServer();
+    pServer->setCallbacks(new ServerCallbacks);
 
-    NimBLEService*        pService = pServer->createService(SERVICE_UUID);
-    NimBLECharacteristic* pCharacteristic =
-        pService->createCharacteristic(CHARACTERISTIC_UUID,
-                                       NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::NOTIFY);
+    NimBLEService *pService = pServer->createService(SERVICE_UUID);
+    NimBLECharacteristic *pCharacteristic = pService->createCharacteristic(CHARACTERISTIC_UUID,
+                                                                           NIMBLE_PROPERTY::READ |
+                                                                           NIMBLE_PROPERTY::WRITE |
+                                                                           NIMBLE_PROPERTY::NOTIFY);
 
     pCharacteristic->setValue("Hello World");
 
-    /** Start the service */
+    /* Start the services */
     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.
-     */
+    /*
+    * 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.
+    */
     NimBLEExtAdvertisement extAdv(primaryPhy, secondaryPhy);
 
-    /** Set the advertisement as connectable */
+    /* Set the advertisement as connectable */
     extAdv.setConnectable(true);
 
-    /** As per Bluetooth specification, extended advertising cannot be both scannable and connectable */
+    /* As per Bluetooth specification, extended advertising cannot be both scannable and connectable */
     extAdv.setScannable(false); // The default is false, set here for demonstration.
 
-    /** Extended advertising allows for 251 bytes (minus header bytes ~20) in a single advertisement or up to 1650 if chained */
-    extAdv.setServiceData(NimBLEUUID(SERVICE_UUID),
-                          std::string("Extended Advertising Demo.\r\n"
-                                      "Extended advertising allows for "
-                                      "251 bytes of data in a single advertisement,\r\n"
-                                      "or up to 1650 bytes with chaining.\r\n"
-                                      "This example message is 226 bytes long "
-                                      "and is using CODED_PHY for long range."));
+    /* Extended advertising allows for 251 bytes (minus header bytes ~20) in a single advertisement or up to 1650 if chained */
+    extAdv.setServiceData(NimBLEUUID(SERVICE_UUID), std::string("Extended Advertising Demo.\r\n"
+                                                                "Extended advertising allows for "
+                                                                "251 bytes of data in a single advertisement,\r\n"
+                                                                "or up to 1650 bytes with chaining.\r\n"
+                                                                "This example message is 226 bytes long "
+                                                                "and is using CODED_PHY for long range."));
 
     extAdv.setCompleteServices16({NimBLEUUID(SERVICE_UUID)});
-    extAdv.setName("Extended advertiser");
 
-    /** When extended advertising is enabled `NimBLEDevice::getAdvertising` returns a pointer to `NimBLEExtAdvertising */
+    /* When extended advertising is enabled `NimBLEDevice::getAdvertising` returns a pointer to `NimBLEExtAdvertising */
     NimBLEExtAdvertising* pAdvertising = NimBLEDevice::getAdvertising();
 
-    /** Set the callbacks for advertising events */
-    pAdvertising->setCallbacks(&advertisingCallbacks);
+    /* Set the callbacks for advertising events */
+    pAdvertising->setCallbacks(new advertisingCallbacks);
 
-    /**
-     *  NimBLEExtAdvertising::setInstanceData takes the instance ID and
-     *  a reference to a `NimBLEExtAdvertisement` object. This sets the data
-     *  that will be advertised for this instance ID, returns true if successful.
+    /*
+     * NimBLEExtAdvertising::setInstanceData takes the instance ID and
+     * a reference to a `NimBLEExtAdvertisement` object. This sets the data
+     * that will be advertised for this instance ID, returns true if successful.
      *
-     *  Note: It is safe to create the advertisement as a local variable if setInstanceData
-     *  is called before exiting the code block as the data will be copied.
+     * Note: It is safe to create the advertisement as a local variable if setInstanceData
+     * is called before exiting the code block as the data will be copied.
      */
     if (pAdvertising->setInstanceData(0, extAdv)) {
-        /**
-         *  NimBLEExtAdvertising::start takes the advertisement instance ID to start
-         *  and a duration in milliseconds or a max number of advertisements to send (or both).
+        /*
+         * `NimBLEExtAdvertising::start` takes the advertisement instance ID to start
+         * and a duration in milliseconds or a max number of advertisements to send (or both).
          */
         if (pAdvertising->start(0, advTime)) {
             printf("Started advertising\n");
@@ -133,7 +132,7 @@ void app_main(void) {
             printf("Failed to start advertising\n");
         }
     } else {
-        printf("Failed to register advertisement data\n");
+        printf("Failed to register advertisment data\n");
     }
 
     esp_sleep_enable_timer_wakeup(sleepSeconds * 1000000);

examples/Bluetooth_5/NimBLE_multi_advertiser/CMakeLists.txt

@@ -3,4 +3,5 @@
 cmake_minimum_required(VERSION 3.5)
 
 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+set(SUPPORTED_TARGETS esp32c3 esp32s3)
 project(NimBLE_multi_advertiser)

examples/Bluetooth_5/NimBLE_multi_advertiser/Makefile

@@ -0,0 +1,3 @@
+PROJECT_NAME := NimBLE_multi_advertiser
+
+include $(IDF_PATH)/make/project.mk

examples/Bluetooth_5/NimBLE_multi_advertiser/main/component.mk

@@ -0,0 +1,4 @@
+#
+# "main" pseudo-component makefile.
+#
+# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)

examples/Bluetooth_5/NimBLE_multi_advertiser/main/main.cpp

@@ -1,5 +1,4 @@
-/**
- *  NimBLE Multi Advertiser Demo:
+/** NimBLE Multi Advertiser Demo:
  *
  *  Demonstrates the Bluetooth 5.x extended advertising capabilities.
  *
@@ -10,56 +9,59 @@
  *
  *  Created: on April 9 2022
  *      Author: H2zero
- */
+ *
+*/
 
-#include <NimBLEDevice.h>
-#include <esp_sleep.h>
+#include "NimBLEDevice.h"
+#include "esp_sleep.h"
+
+extern "C" void app_main(void);
 
 #define SERVICE_UUID        "ABCD"
 #define CHARACTERISTIC_UUID "1234"
 
-/** Time in milliseconds to advertise */
+/* Time in milliseconds to advertise */
 static uint32_t advTime = 5000;
 
-/** Time to sleep between advertisements */
+/* Time to sleep between advertisements */
 static uint32_t sleepTime = 20;
 
-/** Primary PHY used for advertising, can be one of BLE_HCI_LE_PHY_1M or BLE_HCI_LE_PHY_CODED */
+/* Primary PHY used for advertising, can be one of BLE_HCI_LE_PHY_1M or BLE_HCI_LE_PHY_CODED */
 static uint8_t primaryPhy = BLE_HCI_LE_PHY_CODED;
 
-/**
- *  Secondary PHY used for advertising and connecting,
- *  can be one of BLE_HCI_LE_PHY_1M, BLE_HCI_LE_PHY_2M or BLE_HCI_LE_PHY_CODED
+/* Secondary PHY used for advertising and connecting,
+ * can be one of BLE_HCI_LE_PHY_1M, BLE_HCI_LE_PHY_2M or BLE_HCI_LE_PHY_CODED
  */
 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: %s\n", connInfo.getAddress().toString().c_str());
-    }
 
-    void onDisconnect(NimBLEServer* pServer, NimBLEConnInfo& connInfo, int reason) override {
+/* Handler class for server events */
+class ServerCallbacks: public NimBLEServerCallbacks {
+    void onConnect(NimBLEServer* pServer, NimBLEConnInfo& connInfo) {
+        printf("Client connected: %s\n", connInfo.getAddress().toString().c_str());
+    };
+
+    void onDisconnect(NimBLEServer* pServer, NimBLEConnInfo& connInfo, int reason) {
         printf("Client disconnected\n");
         // if still advertising we won't sleep yet.
         if (!pServer->getAdvertising()->isAdvertising()) {
-            printf("Sleeping for %" PRIu32 " seconds\n", sleepTime);
+            printf("Sleeping for %" PRIu32" seconds\n", sleepTime);
             esp_deep_sleep_start();
         }
-    }
-} serverCallbacks;
+    };
+};
 
-/** Callback class to handle advertising events */
-class AdvCallbacks : public NimBLEExtAdvertisingCallbacks {
-    void onStopped(NimBLEExtAdvertising* pAdv, int reason, uint8_t instId) override {
+/* Callback class to handle advertising events */
+class advCallbacks: public NimBLEExtAdvertisingCallbacks {
+    void onStopped(NimBLEExtAdvertising* pAdv, int reason, uint8_t inst_id) {
         /* Check the reason advertising stopped, don't sleep if client is connecting */
-        printf("Advertising instance %u stopped\n", instId);
+        printf("Advertising instance %u stopped\n", inst_id);
         switch (reason) {
             case 0:
                 printf(" client connecting\n");
                 return;
             case BLE_HS_ETIMEOUT:
-                printf("Time expired - sleeping for %" PRIu32 " seconds\n", sleepTime);
+                printf("Time expired - sleeping for %" PRIu32" seconds\n", sleepTime);
                 break;
             default:
                 break;
@@ -70,90 +72,90 @@ class AdvCallbacks : public NimBLEExtAdvertisingCallbacks {
 
     bool m_updatedSR = false;
 
-    void onScanRequest(NimBLEExtAdvertising* pAdv, uint8_t instId, NimBLEAddress addr) override {
-        printf("Scan request for instance %u\n", instId);
+    void onScanRequest(NimBLEExtAdvertising* pAdv, uint8_t inst_id, NimBLEAddress addr) {
+        printf("Scan request for instance %u\n", inst_id);
         // if the data has already been updated we don't need to change it again.
         if (!m_updatedSR) {
             printf("Updating scan data\n");
             NimBLEExtAdvertisement sr;
             sr.setServiceData(NimBLEUUID(SERVICE_UUID), std::string("Hello from scan response!"));
-            pAdv->setScanResponseData(instId, sr);
+            pAdv->setScanResponseData(inst_id, sr);
             m_updatedSR = true;
         }
     }
-} advCallbacks;
+};
 
-extern "C" void app_main(void) {
-    /** Initialize NimBLE and set the device name */
+void app_main (void) {
     NimBLEDevice::init("Multi advertiser");
 
-    /** Create a server for our legacy advertiser */
-    NimBLEServer* pServer = NimBLEDevice::createServer();
-    pServer->setCallbacks(&serverCallbacks);
+    /* Create a server for our legacy advertiser */
+    NimBLEServer *pServer = NimBLEDevice::createServer();
+    pServer->setCallbacks(new ServerCallbacks);
 
-    NimBLEService*        pService = pServer->createService(SERVICE_UUID);
-    NimBLECharacteristic* pCharacteristic =
-        pService->createCharacteristic(CHARACTERISTIC_UUID,
-                                       NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::NOTIFY);
+    NimBLEService *pService = pServer->createService(SERVICE_UUID);
+    NimBLECharacteristic *pCharacteristic = pService->createCharacteristic(CHARACTERISTIC_UUID,
+                                                                           NIMBLE_PROPERTY::READ |
+                                                                           NIMBLE_PROPERTY::WRITE |
+                                                                           NIMBLE_PROPERTY::NOTIFY);
 
     pCharacteristic->setValue("Hello World");
 
-    /** Start the service */
+    /* Start the service */
     pService->start();
 
-    /** Create our multi advertising instances */
+    /* Create our multi advertising instances */
 
-    /** extended scannable instance advertising on coded and 1m PHY's. */
+    // extended scannable instance advertising on coded and 1m PHY's.
     NimBLEExtAdvertisement extScannable(primaryPhy, secondaryPhy);
 
-    /** Legacy advertising as a connectable device. */
+    // Legacy advertising as a connectable device.
     NimBLEExtAdvertisement legacyConnectable;
 
-    /** Optional scan response data. */
+    // Optional scan response data.
     NimBLEExtAdvertisement legacyScanResponse;
 
-    /** As per Bluetooth specification, extended advertising cannot be both scannable and connectable */
+    /* As per Bluetooth specification, extended advertising cannot be both scannable and connectable */
     extScannable.setScannable(true);
     extScannable.setConnectable(false);
 
-    /** Set the initial data */
+    /* Set the initial data */
     extScannable.setServiceData(NimBLEUUID(SERVICE_UUID), std::string("Scan me!"));
 
-    /** Enable the scan response callback, we will use this to update the data. */
+    /* enable the scan response callback, we will use this to update the data. */
     extScannable.enableScanRequestCallback(true);
 
-    /** Optional custom address for this advertisment. */
+    /* Optional custom address for this advertisment. */
     legacyConnectable.setAddress(NimBLEAddress("DE:AD:BE:EF:BA:AD"));
 
-    /** Set the advertising data. */
+    /* Set the advertising data. */
     legacyConnectable.setName("Legacy");
     legacyConnectable.setCompleteServices16({NimBLEUUID(SERVICE_UUID)});
 
-    /** Set the legacy and connectable flags. */
+    /* Set the legacy and connectable flags. */
     legacyConnectable.setLegacyAdvertising(true);
     legacyConnectable.setConnectable(true);
 
-    /** Put some data in the scan response if desired. */
+    /* Put some data in the scan response if desired. */
     legacyScanResponse.setServiceData(NimBLEUUID(SERVICE_UUID), "Legacy SR");
 
-    /** Get the advertising ready */
+    /* Get the advertising ready */
     NimBLEExtAdvertising* pAdvertising = NimBLEDevice::getAdvertising();
 
-    /** Set the callbacks to handle advertising events */
-    pAdvertising->setCallbacks(&advCallbacks);
+    /* Set the callbacks to handle advertising events */
+    pAdvertising->setCallbacks(new advCallbacks);
 
-    /**
-     *  Set instance data.
-     *  Up to 5 instances can be used if configured in menuconfig, instance 0 is always available.
+    /* Set instance data.
+     * Up to 5 instances can be used if configured in menuconfig, instance 0 is always available.
      *
-     *  We will set the extended scannable data on instance 0 and the legacy data on instance 1.
-     *  Note that the legacy scan response data needs to be set to the same instance (1).
+     * We will set the extended scannable data on instance 0 and the legacy data on instance 1.
+     * Note that the legacy scan response data needs to be set to the same instance (1).
      */
-    if (pAdvertising->setInstanceData(0, extScannable) && pAdvertising->setInstanceData(1, legacyConnectable) &&
-        pAdvertising->setScanResponseData(1, legacyScanResponse)) {
-        /**
-         *  NimBLEExtAdvertising::start takes the advertisement instance ID to start
-         *  and a duration in milliseconds or a max number of advertisements to send (or both).
+    if (pAdvertising->setInstanceData( 0, extScannable )  &&
+        pAdvertising->setInstanceData( 1, legacyConnectable ) &&
+        pAdvertising->setScanResponseData( 1, legacyScanResponse )) {
+        /*
+         * `NimBLEExtAdvertising::start` takes the advertisement instance ID to start
+         * and a duration in milliseconds or a max number of advertisements to send (or both).
          */
         if (pAdvertising->start(0, advTime) && pAdvertising->start(1, advTime)) {
             printf("Started advertising\n");
@@ -161,7 +163,7 @@ extern "C" void app_main(void) {
             printf("Failed to start advertising\n");
         }
     } else {
-        printf("Failed to register advertisement data\n");
+        printf("Failed to register advertisment data\n");
     }
 
     esp_sleep_enable_timer_wakeup(sleepTime * 1000000);

examples/Continuous_scan/main/main.cpp

@@ -1,46 +0,0 @@
-/**
- *  Continuous Scan Example
- *
- *  This example demonstrates how to continuously scan for BLE devices.
- *  When devices are found the onDiscovered and onResults callbacks will be called with the device data.
- *  The scan will not store the results, only the callbacks will be used
- *  When the scan timeout is reached the onScanEnd callback will be called and the scan will be restarted.
- *  This will clear the duplicate cache in the controller and allow the same devices to be reported again.
- *
- *  Created: on March 24 2020
- *      Author: H2zero
- */
-
-#include <NimBLEDevice.h>
-
-static constexpr uint32_t scanTime = 30 * 1000; // 30 seconds scan time.
-
-class scanCallbacks : public NimBLEScanCallbacks {
-    /** Initial discovery, advertisement data only. */
-    void onDiscovered(const NimBLEAdvertisedDevice* advertisedDevice) override {
-        printf("Discovered Device: %s\n", advertisedDevice->toString().c_str());
-    }
-
-    /**
-     *  If active scanning the result here will have the scan response data.
-     *  If not active scanning then this will be the same as onDiscovered.
-     */
-    void onResult(const NimBLEAdvertisedDevice* advertisedDevice) override {
-        printf("Device result: %s\n", advertisedDevice->toString().c_str());
-    }
-
-    void onScanEnd(const NimBLEScanResults& results, int reason) override {
-        printf("Scan ended reason = %d; restarting scan\n", reason);
-        NimBLEDevice::getScan()->start(scanTime, false, true);
-    }
-} scanCallbacks;
-
-extern "C" void app_main() {
-    NimBLEDevice::init("");                         // Initialize the device, you can specify a device name if you want.
-    NimBLEScan* pBLEScan = NimBLEDevice::getScan(); // Create the scan object.
-    pBLEScan->setScanCallbacks(&scanCallbacks, false); // Set the callback for when devices are discovered, no duplicates.
-    pBLEScan->setActiveScan(true);          // Set active scanning, this will get more data from the advertiser.
-    pBLEScan->setMaxResults(0);             // Do not store the scan results, use callback only.
-    pBLEScan->start(scanTime, false, true); // duration, not a continuation of last scan, restart to get all devices again.
-    printf("Scanning...\n");
-}

examples/NimBLE_Async_Client/Makefile

@@ -0,0 +1,3 @@
+PROJECT_NAME := NimBLE_Async_Client
+
+include $(IDF_PATH)/make/project.mk

examples/NimBLE_Async_Client/main/component.mk

@@ -0,0 +1,4 @@
+#
+# "main" pseudo-component makefile.
+#
+# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)

examples/NimBLE_Async_Client/main/main.cpp

@@ -6,6 +6,7 @@
  *
  *  Created: on November 4, 2024
  *      Author: H2zero
+ *
  */
 
 #include <NimBLEDevice.h>
@@ -13,23 +14,22 @@
 static constexpr uint32_t scanTimeMs = 5 * 1000;
 
 class ClientCallbacks : public NimBLEClientCallbacks {
-    void onConnect(NimBLEClient* pClient) override {
+    void onConnect(NimBLEClient* pClient) {
         printf("Connected to: %s\n", pClient->getPeerAddress().toString().c_str());
     }
 
-    void onDisconnect(NimBLEClient* pClient, int reason) override {
+    void onDisconnect(NimBLEClient* pClient, int reason) {
         printf("%s Disconnected, reason = %d - Starting scan\n", pClient->getPeerAddress().toString().c_str(), reason);
         NimBLEDevice::getScan()->start(scanTimeMs);
     }
-} clientCallbacks;
+} clientCB;
 
-class ScanCallbacks : public NimBLEScanCallbacks {
-    void onResult(const NimBLEAdvertisedDevice* advertisedDevice) override {
+class scanCallbacks : public NimBLEScanCallbacks {
+    void onResult(NimBLEAdvertisedDevice* advertisedDevice) {
         printf("Advertised Device found: %s\n", advertisedDevice->toString().c_str());
         if (advertisedDevice->haveName() && advertisedDevice->getName() == "NimBLE-Server") {
             printf("Found Our Device\n");
 
-            /** Async connections can be made directly in the scan callbacks */
             auto pClient = NimBLEDevice::getDisconnectedClient();
             if (!pClient) {
                 pClient = NimBLEDevice::createClient(advertisedDevice->getAddress());
@@ -39,7 +39,7 @@ class ScanCallbacks : public NimBLEScanCallbacks {
                 }
             }
 
-            pClient->setClientCallbacks(&clientCallbacks, false);
+            pClient->setClientCallbacks(&clientCB, false);
             if (!pClient->connect(true, true, false)) { // delete attributes, async connect, no MTU exchange
                 NimBLEDevice::deleteClient(pClient);
                 printf("Failed to connect\n");
@@ -48,19 +48,19 @@ class ScanCallbacks : public NimBLEScanCallbacks {
         }
     }
 
-    void onScanEnd(const NimBLEScanResults& results, int reason) override {
+    void onScanEnd(NimBLEScanResults results) {
         printf("Scan Ended\n");
         NimBLEDevice::getScan()->start(scanTimeMs);
     }
-} scanCallbacks;
+};
 
 extern "C" void app_main(void) {
     printf("Starting NimBLE Async Client\n");
-    NimBLEDevice::init("Async-Client");
+    NimBLEDevice::init("");
     NimBLEDevice::setPower(3); /** +3db */
 
     NimBLEScan* pScan = NimBLEDevice::getScan();
-    pScan->setScanCallbacks(&scanCallbacks);
+    pScan->setScanCallbacks(new scanCallbacks());
     pScan->setInterval(45);
     pScan->setWindow(15);
     pScan->setActiveScan(true);

examples/NimBLE_Client/main/main.cpp

@@ -1,305 +0,0 @@
-
-/** NimBLE_Client Demo:
- *
- *  Demonstrates many of the available features of the NimBLE client library.
- *
- *  Created: on March 24 2020
- *      Author: H2zero
- */
-
-#include <NimBLEDevice.h>
-
-static const NimBLEAdvertisedDevice* advDevice;
-static bool                          doConnect = false;
-static uint32_t                      scanTime  = 5000; /** scan time in milliseconds, 0 = scan forever */
-
-/**  None of these are required as they will be handled by the library with defaults. **
- **                       Remove as you see fit for your needs                        */
-class ClientCallbacks : public NimBLEClientCallbacks {
-    void onConnect(NimBLEClient* pClient) override { printf("Connected\n"); }
-
-    void onDisconnect(NimBLEClient* pClient, int reason) override {
-        printf("%s Disconnected, reason = %d - Starting scan\n", pClient->getPeerAddress().toString().c_str(), reason);
-        NimBLEDevice::getScan()->start(scanTime, false, true);
-    }
-
-    /********************* Security handled here *********************/
-    void onPassKeyEntry(NimBLEConnInfo& connInfo) override {
-        printf("Server Passkey Entry\n");
-        /**
-         * This should prompt the user to enter the passkey displayed
-         * on the peer device.
-         */
-        NimBLEDevice::injectPassKey(connInfo, 123456);
-    }
-
-    void onConfirmPasskey(NimBLEConnInfo& connInfo, uint32_t pass_key) override {
-        printf("The passkey YES/NO number: %" PRIu32 "\n", pass_key);
-        /** Inject false if passkeys don't match. */
-        NimBLEDevice::injectConfirmPasskey(connInfo, true);
-    }
-
-    /** Pairing process complete, we can check the results in connInfo */
-    void onAuthenticationComplete(NimBLEConnInfo& connInfo) override {
-        if (!connInfo.isEncrypted()) {
-            printf("Encrypt connection failed - disconnecting\n");
-            /** Find the client with the connection handle provided in connInfo */
-            NimBLEDevice::getClientByHandle(connInfo.getConnHandle())->disconnect();
-            return;
-        }
-    }
-} clientCB;
-
-/** Define a class to handle the callbacks when scan events are received */
-class scanCallbacks : public NimBLEScanCallbacks {
-    void onResult(const NimBLEAdvertisedDevice* advertisedDevice) override {
-        printf("Advertised Device found: %s\n", advertisedDevice->toString().c_str());
-        if (advertisedDevice->isAdvertisingService(NimBLEUUID("DEAD"))) {
-            printf("Found Our Service\n");
-            /** stop scan before connecting */
-            NimBLEDevice::getScan()->stop();
-            /** Save the device reference in a global for the client to use*/
-            advDevice = advertisedDevice;
-            /** Ready to connect now */
-            doConnect = true;
-        }
-    }
-
-    /** Callback to process the results of the completed scan or restart it */
-    void onScanEnd(const NimBLEScanResults& results, int reason) override {
-        printf("Scan Ended, reason: %d, device count: %d; Restarting scan\n", reason, results.getCount());
-        NimBLEDevice::getScan()->start(scanTime, false, true);
-    }
-} scanCB;
-
-/** Notification / Indication receiving handler callback */
-void notifyCB(NimBLERemoteCharacteristic* pRemoteCharacteristic, uint8_t* pData, size_t length, bool isNotify) {
-    std::string str  = (isNotify == true) ? "Notification" : "Indication";
-    str             += " from ";
-    str             += pRemoteCharacteristic->getClient()->getPeerAddress().toString();
-    str             += ": Service = " + pRemoteCharacteristic->getRemoteService()->getUUID().toString();
-    str             += ", Characteristic = " + pRemoteCharacteristic->getUUID().toString();
-    str             += ", Value = " + std::string((char*)pData, length);
-    printf("%s\n", str.c_str());
-}
-
-/** Handles the provisioning of clients and connects / interfaces with the server */
-bool connectToServer() {
-    NimBLEClient* pClient = nullptr;
-
-    /** Check if we have a client we should reuse first **/
-    if (NimBLEDevice::getCreatedClientCount()) {
-        /**
-         *  Special case when we already know this device, we send false as the
-         *  second argument in connect() to prevent refreshing the service database.
-         *  This saves considerable time and power.
-         */
-        pClient = NimBLEDevice::getClientByPeerAddress(advDevice->getAddress());
-        if (pClient) {
-            if (!pClient->connect(advDevice, false)) {
-                printf("Reconnect failed\n");
-                return false;
-            }
-            printf("Reconnected client\n");
-        } else {
-            /**
-             *  We don't already have a client that knows this device,
-             *  check for a client that is disconnected that we can use.
-             */
-            pClient = NimBLEDevice::getDisconnectedClient();
-        }
-    }
-
-    /** No client to reuse? Create a new one. */
-    if (!pClient) {
-        if (NimBLEDevice::getCreatedClientCount() >= NIMBLE_MAX_CONNECTIONS) {
-            printf("Max clients reached - no more connections available\n");
-            return false;
-        }
-
-        pClient = NimBLEDevice::createClient();
-
-        printf("New client created\n");
-
-        pClient->setClientCallbacks(&clientCB, false);
-        /**
-         *  Set initial connection parameters:
-         *  These settings are safe for 3 clients to connect reliably, can go faster if you have less
-         *  connections. Timeout should be a multiple of the interval, minimum is 100ms.
-         *  Min interval: 12 * 1.25ms = 15, Max interval: 12 * 1.25ms = 15, 0 latency, 150 * 10ms = 1500ms timeout
-         */
-        pClient->setConnectionParams(12, 12, 0, 150);
-
-        /** Set how long we are willing to wait for the connection to complete (milliseconds), default is 30000. */
-        pClient->setConnectTimeout(5 * 1000);
-
-        if (!pClient->connect(advDevice)) {
-            /** Created a client but failed to connect, don't need to keep it as it has no data */
-            NimBLEDevice::deleteClient(pClient);
-            printf("Failed to connect, deleted client\n");
-            return false;
-        }
-    }
-
-    if (!pClient->isConnected()) {
-        if (!pClient->connect(advDevice)) {
-            printf("Failed to connect\n");
-            return false;
-        }
-    }
-
-    printf("Connected to: %s RSSI: %d\n", pClient->getPeerAddress().toString().c_str(), pClient->getRssi());
-
-    /** Now we can read/write/subscribe the characteristics of the services we are interested in */
-    NimBLERemoteService*        pSvc = nullptr;
-    NimBLERemoteCharacteristic* pChr = nullptr;
-    NimBLERemoteDescriptor*     pDsc = nullptr;
-
-    pSvc = pClient->getService("DEAD");
-    if (pSvc) {
-        pChr = pSvc->getCharacteristic("BEEF");
-    }
-
-    if (pChr) {
-        if (pChr->canRead()) {
-            printf("%s Value: %s\n", pChr->getUUID().toString().c_str(), pChr->readValue().c_str());
-        }
-
-        if (pChr->canWrite()) {
-            if (pChr->writeValue("Tasty")) {
-                printf("Wrote new value to: %s\n", pChr->getUUID().toString().c_str());
-            } else {
-                pClient->disconnect();
-                return false;
-            }
-
-            if (pChr->canRead()) {
-                printf("The value of: %s is now: %s\n", pChr->getUUID().toString().c_str(), pChr->readValue().c_str());
-            }
-        }
-
-        if (pChr->canNotify()) {
-            if (!pChr->subscribe(true, notifyCB)) {
-                pClient->disconnect();
-                return false;
-            }
-        } else if (pChr->canIndicate()) {
-            /** Send false as first argument to subscribe to indications instead of notifications */
-            if (!pChr->subscribe(false, notifyCB)) {
-                pClient->disconnect();
-                return false;
-            }
-        }
-    } else {
-        printf("DEAD service not found.\n");
-    }
-
-    pSvc = pClient->getService("BAAD");
-    if (pSvc) {
-        pChr = pSvc->getCharacteristic("F00D");
-        if (pChr) {
-            if (pChr->canRead()) {
-                printf("%s Value: %s\n", pChr->getUUID().toString().c_str(), pChr->readValue().c_str());
-            }
-
-            pDsc = pChr->getDescriptor(NimBLEUUID("C01D"));
-            if (pDsc) {
-                printf("Descriptor: %s  Value: %s\n", pDsc->getUUID().toString().c_str(), pDsc->readValue().c_str());
-            }
-
-            if (pChr->canWrite()) {
-                if (pChr->writeValue("No tip!")) {
-                    printf("Wrote new value to: %s\n", pChr->getUUID().toString().c_str());
-                } else {
-                    pClient->disconnect();
-                    return false;
-                }
-
-                if (pChr->canRead()) {
-                    printf("The value of: %s is now: %s\n", pChr->getUUID().toString().c_str(), pChr->readValue().c_str());
-                }
-            }
-
-            if (pChr->canNotify()) {
-                if (!pChr->subscribe(true, notifyCB)) {
-                    pClient->disconnect();
-                    return false;
-                }
-            } else if (pChr->canIndicate()) {
-                /** Send false as first argument to subscribe to indications instead of notifications */
-                if (!pChr->subscribe(false, notifyCB)) {
-                    pClient->disconnect();
-                    return false;
-                }
-            }
-        }
-    } else {
-        printf("BAAD service not found.\n");
-    }
-
-    printf("Done with this device!\n");
-    return true;
-}
-
-extern "C"
-void app_main(void) {
-    printf("Starting NimBLE Client\n");
-    /** Initialize NimBLE and set the device name */
-    NimBLEDevice::init("NimBLE-Client");
-
-    /**
-     * Set the IO capabilities of the device, each option will trigger a different pairing method.
-     *  BLE_HS_IO_KEYBOARD_ONLY   - Passkey pairing
-     *  BLE_HS_IO_DISPLAY_YESNO   - Numeric comparison pairing
-     *  BLE_HS_IO_NO_INPUT_OUTPUT - DEFAULT setting - just works pairing
-     */
-    // NimBLEDevice::setSecurityIOCap(BLE_HS_IO_KEYBOARD_ONLY); // use passkey
-    // NimBLEDevice::setSecurityIOCap(BLE_HS_IO_DISPLAY_YESNO); //use numeric comparison
-
-    /**
-     * 2 different ways to set security - both calls achieve the same result.
-     *  no bonding, no man in the middle protection, BLE secure connections.
-     *  These are the default values, only shown here for demonstration.
-     */
-    // NimBLEDevice::setSecurityAuth(false, false, true);
-
-    NimBLEDevice::setSecurityAuth(/*BLE_SM_PAIR_AUTHREQ_BOND | BLE_SM_PAIR_AUTHREQ_MITM |*/ BLE_SM_PAIR_AUTHREQ_SC);
-
-    /** Optional: set the transmit power */
-    NimBLEDevice::setPower(3); // 9dbm
-    NimBLEScan* pScan = NimBLEDevice::getScan();
-
-    /** Set the callbacks to call when scan events occur, no duplicates */
-    pScan->setScanCallbacks(&scanCB, false);
-
-    /** Set scan interval (how often) and window (how long) in milliseconds */
-    pScan->setInterval(100);
-    pScan->setWindow(100);
-
-    /**
-     * Active scan will gather scan response data from advertisers
-     *  but will use more energy from both devices
-     */
-    pScan->setActiveScan(true);
-
-    /** Start scanning for advertisers */
-    pScan->start(scanTime);
-    printf("Scanning for peripherals\n");
-
-    /** Loop here until we find a device we want to connect to */
-    for (;;) {
-        vTaskDelay(10 / portTICK_PERIOD_MS);
-
-        if (doConnect) {
-            doConnect = false;
-            /** Found a device we want to connect to, do it now */
-            if (connectToServer()) {
-                printf("Success! we should now be getting notifications, scanning for more!\n");
-            } else {
-                printf("Failed to connect, starting scan\n");
-            }
-
-            NimBLEDevice::getScan()->start(scanTime, false, true);
-        }
-    }
-}

examples/NimBLE_server_get_client_name/CMakeLists.txt

@@ -0,0 +1,7 @@
+# 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)
+set(SUPPORTED_TARGETS esp32)
+project(NimBLE_server_get_client_name)

examples/NimBLE_server_get_client_name/main/main.cpp

@@ -0,0 +1,83 @@
+/** NimBLE_server_get_client_name
+ *
+ *  Demonstrates 2 ways for the server to read the device name from the connected client.
+ *
+ *  Created: on June 24 2024
+ *      Author: H2zero
+ *
+ */
+
+#include <NimBLEDevice.h>
+
+// See the following for generating UUIDs:
+// https://www.uuidgenerator.net/
+
+#define SERVICE_UUID            "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
+#define CHARACTERISTIC_UUID     "beb5483e-36e1-4688-b7f5-ea07361b26a8"
+#define ENC_CHARACTERISTIC_UUID "9551f35b-8d91-42e4-8f7e-1358dfe272dc"
+
+NimBLEServer* pServer;
+
+class ServerCallbacks : public NimBLEServerCallbacks {
+    // Same as before but now includes the name parameter
+    void onConnect(NimBLEServer* pServer, NimBLEConnInfo& connInfo, std::string& name) override {
+        printf("Client address: %s Name: %s\n", connInfo.getAddress().toString().c_str(), name.c_str());
+    }
+
+    // Same as before but now includes the name parameter
+    void onAuthenticationComplete(NimBLEConnInfo& connInfo, const std::string& name) override {
+        if (!connInfo.isEncrypted()) {
+            NimBLEDevice::getServer()->disconnect(connInfo.getConnHandle());
+            printf("Encrypt connection failed - disconnecting client\n");
+            return;
+        }
+
+        printf("Encrypted Client address: %s Name: %s\n", connInfo.getAddress().toString().c_str(), name.c_str());
+    }
+};
+
+extern "C" void app_main(void) {
+    printf("Starting BLE Server!\n");
+
+    NimBLEDevice::init("Connect to me!");
+    NimBLEDevice::setSecurityAuth(true, false, true); // Enable bonding to see full name on phones.
+
+    pServer                               = NimBLEDevice::createServer();
+    NimBLEService*        pService        = pServer->createService(SERVICE_UUID);
+    NimBLECharacteristic* pCharacteristic =
+        pService->createCharacteristic(CHARACTERISTIC_UUID, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE);
+    pCharacteristic->setValue("Hello World says NimBLE!");
+
+    NimBLECharacteristic* pEncCharacteristic = pService->createCharacteristic(
+        ENC_CHARACTERISTIC_UUID,
+        (NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::READ_ENC | NIMBLE_PROPERTY::WRITE_ENC));
+    pEncCharacteristic->setValue("Hello World says NimBLE Encrypted");
+
+    pService->start();
+
+    pServer->setCallbacks(new ServerCallbacks());
+    pServer->getPeerNameOnConnect(true); // Setting this will enable the onConnect callback that provides the name.
+
+    BLEAdvertising* pAdvertising = NimBLEDevice::getAdvertising();
+    pAdvertising->addServiceUUID(SERVICE_UUID);
+    pAdvertising->setScanResponse(true);
+
+    pAdvertising->start();
+    printf("Advertising started, connect with your phone.\n");
+
+    while (true) {
+        auto clientCount = pServer->getConnectedCount();
+        if (clientCount) {
+            printf("Connected clients:\n");
+            for (auto i = 0; i < clientCount; ++i) {
+                NimBLEConnInfo peerInfo = pServer->getPeerInfo(i);
+                printf("Client address: %s Name: %s\n", peerInfo.getAddress().toString().c_str(),
+                // This function blocks until the name is retrieved, so cannot be used in callback functions.
+                       pServer->getPeerName(peerInfo).c_str());
+
+            }
+        }
+
+        vTaskDelay(pdMS_TO_TICKS(10000));
+    }
+}

examples/basic/BLE_client/CMakeLists.txt

@@ -0,0 +1,7 @@
+# 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)
+set(SUPPORTED_TARGETS esp32)
+project(BLE_client)

examples/basic/BLE_client/Makefile

@@ -0,0 +1,3 @@
+PROJECT_NAME := BLE_client
+
+include $(IDF_PATH)/make/project.mk

examples/basic/BLE_client/main/component.mk

@@ -0,0 +1,4 @@
+#
+# "main" pseudo-component makefile.
+#
+# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)

examples/basic/BLE_client/main/main.cpp

@@ -0,0 +1,214 @@
+/**
+ * A BLE client example that is rich in capabilities.
+ * There is a lot new capabilities implemented.
+ * author unknown
+ * updated by chegewara
+ * updated for NimBLE by H2zero
+ */
+
+/** NimBLE differences highlighted in comment blocks **/
+
+/*******original********
+#include "BLEDevice.h"
+***********************/
+#include "NimBLEDevice.h"
+
+extern "C"{void app_main(void);}
+
+// The remote service we wish to connect to.
+static BLEUUID serviceUUID("4fafc201-1fb5-459e-8fcc-c5c9c331914b");
+// The characteristic of the remote service we are interested in.
+static BLEUUID    charUUID("beb5483e-36e1-4688-b7f5-ea07361b26a8");
+
+static bool doConnect = false;
+static bool connected = false;
+static bool doScan = false;
+static BLERemoteCharacteristic* pRemoteCharacteristic;
+static BLEAdvertisedDevice* myDevice;
+
+static void notifyCallback(
+  BLERemoteCharacteristic* pBLERemoteCharacteristic,
+  uint8_t* pData,
+  size_t length,
+  bool isNotify) {
+    printf("Notify callback for characteristic %s of data length %d data: %s\n",
+           pBLERemoteCharacteristic->getUUID().toString().c_str(),
+           length,
+           (char*)pData);
+}
+
+/**  None of these are required as they will be handled by the library with defaults. **
+ **                       Remove as you see fit for your needs                        */
+class MyClientCallback : public BLEClientCallbacks {
+  void onConnect(BLEClient* pclient) {
+  }
+
+  /** onDisconnect now takes a reason parameter to indicate the reason for disconnection
+  void onDisconnect(BLEClient* pclient) { */
+  void onDisconnect(BLEClient* pclient, int reason) {
+    connected = false;
+    printf("onDisconnect");
+  }
+/***************** New - Security handled here ********************
+****** Note: these are the same return values as defaults ********/
+  void onPassKeyEntry(NimBLEConnInfo& connInfo){
+      printf("Server Passkey Entry\n");
+      /** This should prompt the user to enter the passkey displayed
+       * on the peer device.
+       */
+      NimBLEDevice::injectPassKey(connInfo, 123456);
+  };
+
+  void onConfirmPasskey(NimBLEConnInfo& connInfo, uint32_t pass_key){
+      printf("The passkey YES/NO number: %" PRIu32 "\n", pass_key);
+      /** Inject false if passkeys don't match. */
+      NimBLEDevice::injectConfirmPasskey(connInfo, true);
+  };
+
+  /** Pairing process complete, we can check the results in connInfo */
+  void onAuthenticationComplete(NimBLEConnInfo& connInfo){
+      if(!connInfo.isEncrypted()) {
+          printf("Encrypt connection failed - disconnecting\n");
+          /** Find the client with the connection handle provided in desc */
+          NimBLEDevice::getClientByHandle(connInfo.getConnHandle())->disconnect();
+          return;
+      }
+  }
+/*******************************************************************/
+};
+
+bool connectToServer() {
+    printf("Forming a connection to %s\n", myDevice->getAddress().toString().c_str());
+
+    BLEClient*  pClient  = BLEDevice::createClient();
+    printf(" - Created client\n");
+
+    pClient->setClientCallbacks(new MyClientCallback());
+
+    // Connect to the remove BLE Server.
+    pClient->connect(myDevice);  // if you pass BLEAdvertisedDevice instead of address, it will be recognized type of peer device address (public or private)
+    printf(" - Connected to server\n");
+
+    // Obtain a reference to the service we are after in the remote BLE server.
+    BLERemoteService* pRemoteService = pClient->getService(serviceUUID);
+    if (pRemoteService == nullptr) {
+      printf("Failed to find our service UUID: %s\n", serviceUUID.toString().c_str());
+      pClient->disconnect();
+      return false;
+    }
+    printf(" - Found our service\n");
+
+
+    // Obtain a reference to the characteristic in the service of the remote BLE server.
+    pRemoteCharacteristic = pRemoteService->getCharacteristic(charUUID);
+    if (pRemoteCharacteristic == nullptr) {
+      printf("Failed to find our characteristic UUID: %s\n", charUUID.toString().c_str());
+      pClient->disconnect();
+      return false;
+    }
+    printf(" - Found our characteristic\n");
+
+    // Read the value of the characteristic.
+    if(pRemoteCharacteristic->canRead()) {
+      std::string value = pRemoteCharacteristic->readValue();
+      printf("The characteristic value was: %s\n", value.c_str());
+    }
+
+    /** registerForNotify() has been removed and replaced with subscribe() / unsubscribe().
+     *  Subscribe parameter defaults are: notifications=true, notifyCallback=nullptr, response=true.
+     *  Unsubscribe parameter defaults are: response=true.
+     */
+    if(pRemoteCharacteristic->canNotify()) {
+        //pRemoteCharacteristic->registerForNotify(notifyCallback);
+        pRemoteCharacteristic->subscribe(true, notifyCallback);
+    }
+
+    connected = true;
+    return true;
+}
+
+/**
+ * Scan for BLE servers and find the first one that advertises the service we are looking for.
+ */
+class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks {
+ /**
+   * Called for each advertising BLE server.
+   */
+
+/*** Only a reference to the advertised device is passed now
+  void onResult(BLEAdvertisedDevice advertisedDevice) { **/
+  void onResult(BLEAdvertisedDevice* advertisedDevice) {
+    printf("BLE Advertised Device found: %s\n", advertisedDevice->toString().c_str());
+
+    // We have found a device, let us now see if it contains the service we are looking for.
+/********************************************************************************
+    if (advertisedDevice.haveServiceUUID() && advertisedDevice.isAdvertisingService(serviceUUID)) {
+********************************************************************************/
+    if (advertisedDevice->haveServiceUUID() && advertisedDevice->isAdvertisingService(serviceUUID)) {
+
+      BLEDevice::getScan()->stop();
+/*******************************************************************
+      myDevice = new BLEAdvertisedDevice(advertisedDevice);
+*******************************************************************/
+      myDevice = advertisedDevice; /** Just save the reference now, no need to copy the object */
+      doConnect = true;
+      doScan = true;
+
+    } // Found our server
+  } // onResult
+}; // MyAdvertisedDeviceCallbacks
+
+
+// This is the Arduino main loop function.
+void connectTask (void * parameter){
+    for(;;) {
+      // If the flag "doConnect" is true then we have scanned for and found the desired
+      // BLE Server with which we wish to connect.  Now we connect to it.  Once we are
+      // connected we set the connected flag to be true.
+      if (doConnect == true) {
+        if (connectToServer()) {
+          printf("We are now connected to the BLE Server.\n");
+        } else {
+          printf("We have failed to connect to the server; there is nothin more we will do.\n");
+        }
+        doConnect = false;
+      }
+
+      // If we are connected to a peer BLE Server, update the characteristic each time we are reached
+      // with the current time since boot.
+      if (connected) {
+        char buf[256];
+        snprintf(buf, 256, "Time since boot: %lu", (unsigned long)(esp_timer_get_time() / 1000000ULL));
+        printf("Setting new characteristic value to %s\n", buf);
+
+        // Set the characteristic's value to be the array of bytes that is actually a string.
+        /*** Note: write value now returns true if successful, false otherwise - try again or disconnect ***/
+        pRemoteCharacteristic->writeValue((uint8_t*)buf, strlen(buf), false);
+      }else if(doScan){
+        BLEDevice::getScan()->start(0);  // this is just eample to start scan after disconnect, most likely there is better way to do it
+      }
+
+      vTaskDelay(1000/portTICK_PERIOD_MS); // Delay a second between loops.
+    }
+
+    vTaskDelete(NULL);
+} // End of loop
+
+
+void app_main(void) {
+  printf("Starting BLE Client application...\n");
+  BLEDevice::init("");
+
+  // Retrieve a Scanner and set the callback we want to use to be informed when we
+  // have detected a new device.  Specify that we want active scanning and start the
+  // scan to run for 5 seconds.
+  BLEScan* pBLEScan = BLEDevice::getScan();
+  pBLEScan->setScanCallbacks(new MyAdvertisedDeviceCallbacks());
+  pBLEScan->setInterval(1349);
+  pBLEScan->setWindow(449);
+  pBLEScan->setActiveScan(true);
+
+  xTaskCreate(connectTask, "connectTask", 5000, NULL, 1, NULL);
+  pBLEScan->start(5 * 1000, false);
+} // End of setup.
+

examples/basic/BLE_client/sdkconfig.defaults

@@ -10,4 +10,3 @@ 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_EXT_ADV=y

examples/basic/BLE_notify/CMakeLists.txt

@@ -0,0 +1,7 @@
+# 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)
+set(SUPPORTED_TARGETS esp32)
+project(BLE_notify)

examples/basic/BLE_notify/Makefile

@@ -0,0 +1,3 @@
+PROJECT_NAME := BLE_notify
+
+include $(IDF_PATH)/make/project.mk

examples/basic/BLE_notify/main/CMakeLists.txt

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

examples/basic/BLE_notify/main/component.mk

@@ -0,0 +1,4 @@
+#
+# "main" pseudo-component makefile.
+#
+# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)

examples/basic/BLE_notify/main/main.cpp

@@ -0,0 +1,164 @@
+/*
+    Video: https://www.youtube.com/watch?v=oCMOYS71NIU
+    Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleNotify.cpp
+    Ported to Arduino ESP32 by Evandro Copercini
+    updated by chegewara
+    Refactored back to IDF by H2zero
+
+   Create a BLE server that, once we receive a connection, will send periodic notifications.
+   The service advertises itself as: 4fafc201-1fb5-459e-8fcc-c5c9c331914b
+   And has a characteristic of: beb5483e-36e1-4688-b7f5-ea07361b26a8
+
+   The design of creating the BLE server is:
+   1. Create a BLE Server
+   2. Create a BLE Service
+   3. Create a BLE Characteristic on the Service
+   4. Create a BLE Descriptor on the characteristic
+   5. Start the service.
+   6. Start advertising.
+
+   A connect hander associated with the server starts a background task that performs notification
+   every couple of seconds.
+*/
+
+/** NimBLE differences highlighted in comment blocks **/
+
+/*******original********
+#include <BLEDevice.h>
+#include <BLEServer.h>
+#include <BLEUtils.h>
+#include <BLE2902.h>
+***********************/
+#include <NimBLEDevice.h>
+
+extern "C" {void app_main(void);}
+
+BLEServer* pServer = NULL;
+BLECharacteristic* pCharacteristic = NULL;
+bool deviceConnected = false;
+bool oldDeviceConnected = false;
+uint32_t value = 0;
+
+// See the following for generating UUIDs:
+// https://www.uuidgenerator.net/
+
+#define SERVICE_UUID        "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
+#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"
+
+/**  None of these are required as they will be handled by the library with defaults. **
+ **                       Remove as you see fit for your needs                        */
+class MyServerCallbacks: public BLEServerCallbacks {
+    void onConnect(BLEServer* pServer, BLEConnInfo& connInfo) {
+      deviceConnected = true;
+    };
+
+    void onDisconnect(BLEServer* pServer, BLEConnInfo& connInfo, int reason) {
+      deviceConnected = false;
+    }
+/***************** New - Security handled here ********************
+****** Note: these are the same return values as defaults ********/
+    uint32_t onPassKeyDisplay(){
+        printf("Server Passkey Display\n");
+        /** This should return a random 6 digit number for security
+         *  or make your own static passkey as done here.
+         */
+        return 123456;
+    };
+
+    void onConfirmPasskey(NimBLEConnInfo& connInfo, uint32_t pass_key){
+        printf("The passkey YES/NO number: %" PRIu32 "\n", pass_key);
+        /** Inject false if passkeys don't match. */
+        NimBLEDevice::injectConfirmPasskey(connInfo, true);
+    };
+
+    void onAuthenticationComplete(NimBLEConnInfo& connInfo){
+        /** Check that encryption was successful, if not we disconnect the client */
+        if(!connInfo.isEncrypted()) {
+            NimBLEDevice::getServer()->disconnect(connInfo.getConnHandle());
+            printf("Encrypt connection failed - disconnecting client\n");
+            return;
+        }
+        printf("Starting BLE work!");
+    };
+/*******************************************************************/
+};
+
+void connectedTask (void * parameter){
+    for(;;) {
+        // notify changed value
+        if (deviceConnected) {
+            pCharacteristic->setValue((uint8_t*)&value, 4);
+            pCharacteristic->notify();
+            value++;
+            vTaskDelay(100/portTICK_PERIOD_MS);  // bluetooth stack will go into congestion, if too many packets are sent
+        }
+        // disconnecting
+        if (!deviceConnected && oldDeviceConnected) {
+            vTaskDelay(500/portTICK_PERIOD_MS); // give the bluetooth stack the chance to get things ready
+            pServer->startAdvertising(); // restart advertising
+            printf("start advertising\n");
+            oldDeviceConnected = deviceConnected;
+        }
+        // connecting
+        if (deviceConnected && !oldDeviceConnected) {
+            // do stuff here on connecting
+            oldDeviceConnected = deviceConnected;
+        }
+
+        vTaskDelay(10/portTICK_PERIOD_MS); // Delay between loops to reset watchdog timer
+    }
+
+    vTaskDelete(NULL);
+}
+
+void app_main(void) {
+  // Create the BLE Device
+  BLEDevice::init("ESP32");
+
+  // Create the BLE Server
+  pServer = BLEDevice::createServer();
+  pServer->setCallbacks(new MyServerCallbacks());
+
+  // Create the BLE Service
+  BLEService *pService = pServer->createService(SERVICE_UUID);
+
+  // Create a BLE Characteristic
+  pCharacteristic = pService->createCharacteristic(
+                      CHARACTERISTIC_UUID,
+                /******* Enum Type NIMBLE_PROPERTY now *******
+                      BLECharacteristic::PROPERTY_READ   |
+                      BLECharacteristic::PROPERTY_WRITE  |
+                      BLECharacteristic::PROPERTY_NOTIFY |
+                      BLECharacteristic::PROPERTY_INDICATE
+                    );
+                **********************************************/
+                      NIMBLE_PROPERTY::READ   |
+                      NIMBLE_PROPERTY::WRITE  |
+                      NIMBLE_PROPERTY::NOTIFY |
+                      NIMBLE_PROPERTY::INDICATE
+                    );
+
+  // Create a BLE Descriptor
+  /***************************************************
+   NOTE: DO NOT create a 2902 descriptor.
+   it will be created automatically if notifications
+   or indications are enabled on a characteristic.
+
+   pCharacteristic->addDescriptor(new BLE2902());
+  ****************************************************/
+  // Start the service
+  pService->start();
+
+  // Start advertising
+  BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
+  pAdvertising->addServiceUUID(SERVICE_UUID);
+  pAdvertising->setScanResponse(false);
+  /** This method had been removed **
+  pAdvertising->setMinPreferred(0x0);  // set value to 0x00 to not advertise this parameter
+  **/
+
+  xTaskCreate(connectedTask, "connectedTask", 5000, NULL, 1, NULL);
+
+  BLEDevice::startAdvertising();
+  printf("Waiting a client connection to notify...\n");
+}

examples/basic/BLE_notify/sdkconfig.defaults

@@ -0,0 +1,12 @@
+# 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/basic/BLE_scan/CMakeLists.txt

@@ -3,4 +3,5 @@
 cmake_minimum_required(VERSION 3.5)
 
 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
-project(Continuous_scan)
+set(SUPPORTED_TARGETS esp32)
+project(BLE_scan)

examples/basic/BLE_scan/Makefile

@@ -0,0 +1,3 @@
+PROJECT_NAME := BLE_scan
+
+include $(IDF_PATH)/make/project.mk

examples/basic/BLE_scan/main/CMakeLists.txt

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

examples/basic/BLE_scan/main/component.mk

@@ -0,0 +1,4 @@
+#
+# "main" pseudo-component makefile.
+#
+# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)

examples/basic/BLE_scan/main/main.cpp

@@ -0,0 +1,52 @@
+/*
+   Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleScan.cpp
+   Ported to Arduino ESP32 by Evandro Copercini
+   Refactored back to IDF by H2zero
+*/
+
+/** NimBLE differences highlighted in comment blocks **/
+
+/*******original********
+#include <BLEDevice.h>
+#include <BLEUtils.h>
+#include <BLEScan.h>
+#include <BLEAdvertisedDevice.h>
+***********************/
+
+#include <NimBLEDevice.h>
+
+extern "C"{void app_main(void);}
+
+int scanTime = 5 * 1000; // In milliseconds, 0 = scan forever
+BLEScan* pBLEScan;
+
+class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks {
+    void onResult(BLEAdvertisedDevice* advertisedDevice) {
+      printf("Advertised Device: %s \n", advertisedDevice->toString().c_str());
+    }
+};
+
+void scanTask (void * parameter){
+    for(;;) {
+        // put your main code here, to run repeatedly:
+        BLEScanResults foundDevices = pBLEScan->getResults(scanTime, false);
+        printf("Devices found: %d\n", foundDevices.getCount());
+        printf("Scan done!\n");
+        pBLEScan->clearResults();   // delete results fromBLEScan buffer to release memory
+        vTaskDelay(2000/portTICK_PERIOD_MS); // Delay a second between loops.
+    }
+    
+    vTaskDelete(NULL);
+}
+
+void app_main(void) {
+  printf("Scanning...\n");
+
+  BLEDevice::init("");
+  pBLEScan = BLEDevice::getScan(); //create new scan
+  pBLEScan->setScanCallbacks(new MyAdvertisedDeviceCallbacks());
+  pBLEScan->setActiveScan(true); //active scan uses more power, but get results faster
+  pBLEScan->setInterval(100);
+  pBLEScan->setWindow(99);  // less or equal setInterval value
+  xTaskCreate(scanTask, "scanTask", 5000, NULL, 1, NULL);
+}

examples/basic/BLE_scan/sdkconfig.defaults

@@ -0,0 +1,12 @@
+# 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/basic/BLE_server/CMakeLists.txt

@@ -0,0 +1,7 @@
+# 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)
+set(SUPPORTED_TARGETS esp32)
+project(BLE_server)

examples/basic/BLE_server/Makefile

@@ -0,0 +1,3 @@
+PROJECT_NAME := BLE_server
+
+include $(IDF_PATH)/make/project.mk

examples/basic/BLE_server/main/CMakeLists.txt

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

examples/basic/BLE_server/main/component.mk

@@ -0,0 +1,4 @@
+#
+# "main" pseudo-component makefile.
+#
+# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)

examples/basic/BLE_server/main/main.cpp

@@ -0,0 +1,57 @@
+/*
+    Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleServer.cpp
+    Ported to Arduino ESP32 by Evandro Copercini
+    updates by chegewara
+    Refactored back to IDF by H2zero
+*/
+
+/** NimBLE differences highlighted in comment blocks **/
+
+/*******original********
+#include <BLEDevice.h>
+#include <BLEUtils.h>
+#include <BLEServer.h>
+***********************/
+
+#include <NimBLEDevice.h>
+
+extern "C"{void app_main(void);}
+
+// See the following for generating UUIDs:
+// https://www.uuidgenerator.net/
+
+#define SERVICE_UUID        "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
+#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"
+
+void app_main(void) {
+  printf("Starting BLE work!\n");
+
+  BLEDevice::init("Long name works now");
+  BLEServer *pServer = BLEDevice::createServer();
+  BLEService *pService = pServer->createService(SERVICE_UUID);
+  BLECharacteristic *pCharacteristic = pService->createCharacteristic(
+                                        CHARACTERISTIC_UUID,
+                                  /***** Enum Type NIMBLE_PROPERTY now *****      
+                                        BLECharacteristic::PROPERTY_READ   |
+                                        BLECharacteristic::PROPERTY_WRITE  
+                                        );
+                                  *****************************************/
+                                        NIMBLE_PROPERTY::READ |
+                                        NIMBLE_PROPERTY::WRITE 
+                                       );
+
+  pCharacteristic->setValue("Hello World says Neil");
+  pService->start();
+  // BLEAdvertising *pAdvertising = pServer->getAdvertising();  // this still is working for backward compatibility
+  BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
+  pAdvertising->addServiceUUID(SERVICE_UUID);
+  pAdvertising->setScanResponse(true);
+  
+  /** These methods have been removed **
+  pAdvertising->setMinPreferred(0x06);  // functions that help with iPhone connections issue
+  pAdvertising->setMinPreferred(0x12);
+  */
+  
+  BLEDevice::startAdvertising();
+  printf("Characteristic defined! Now you can read it in your phone!\n");
+}

examples/basic/BLE_server/sdkconfig.defaults

@@ -0,0 +1,12 @@
+# 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/basic/BLE_uart/CMakeLists.txt

@@ -3,4 +3,5 @@
 cmake_minimum_required(VERSION 3.5)
 
 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
-project(NimBLE_extended_scan)
+set(SUPPORTED_TARGETS esp32)
+project(BLE_uart)

examples/basic/BLE_uart/Makefile

@@ -0,0 +1,3 @@
+PROJECT_NAME := BLE_uart
+
+include $(IDF_PATH)/make/project.mk

examples/basic/BLE_uart/main/CMakeLists.txt

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

examples/basic/BLE_uart/main/component.mk

@@ -0,0 +1,4 @@
+#
+# "main" pseudo-component makefile.
+#
+# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)

examples/basic/BLE_uart/main/main.cpp

@@ -0,0 +1,177 @@
+/*
+    Video: https://www.youtube.com/watch?v=oCMOYS71NIU
+    Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleNotify.cpp
+    Ported to Arduino ESP32 by Evandro Copercini
+    Refactored back to IDF by H2zero
+
+   Create a BLE server that, once we receive a connection, will send periodic notifications.
+   The service advertises itself as: 6E400001-B5A3-F393-E0A9-E50E24DCCA9E
+   Has a characteristic of: 6E400002-B5A3-F393-E0A9-E50E24DCCA9E - used for receiving data with "WRITE"
+   Has a characteristic of: 6E400003-B5A3-F393-E0A9-E50E24DCCA9E - used to send data with  "NOTIFY"
+
+   The design of creating the BLE server is:
+   1. Create a BLE Server
+   2. Create a BLE Service
+   3. Create a BLE Characteristic on the Service
+   4. Create a BLE Descriptor on the characteristic
+   5. Start the service.
+   6. Start advertising.
+
+   In this example rxValue is the data received (only accessible inside that function).
+   And txValue is the data to be sent, in this example just a byte incremented every second.
+*/
+
+/** NimBLE differences highlighted in comment blocks **/
+
+/*******original********
+#include <BLEDevice.h>
+#include <BLEServer.h>
+#include <BLEUtils.h>
+#include <BLE2902.h>
+***********************/
+#include <NimBLEDevice.h>
+
+extern "C"{void app_main(void);}
+
+BLEServer *pServer = NULL;
+BLECharacteristic * pTxCharacteristic;
+bool deviceConnected = false;
+bool oldDeviceConnected = false;
+uint8_t txValue = 0;
+
+// See the following for generating UUIDs:
+// https://www.uuidgenerator.net/
+
+#define SERVICE_UUID           "6E400001-B5A3-F393-E0A9-E50E24DCCA9E" // UART service UUID
+#define CHARACTERISTIC_UUID_RX "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
+#define CHARACTERISTIC_UUID_TX "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"
+
+
+/**  None of these are required as they will be handled by the library with defaults. **
+ **                       Remove as you see fit for your needs                        */
+class MyServerCallbacks: public BLEServerCallbacks {
+    void onConnect(BLEServer* pServer, BLEConnInfo& connInfo) {
+      deviceConnected = true;
+    };
+
+    void onDisconnect(BLEServer* pServer, BLEConnInfo& connInfo, int reason) {
+      deviceConnected = false;
+    }
+  /***************** New - Security handled here ********************
+  ****** Note: these are the same return values as defaults ********/
+    uint32_t onPassKeyDisplay(){
+        printf("Server Passkey Display\n");
+        /** This should return a random 6 digit number for security
+         *  or make your own static passkey as done here.
+         */
+        return 123456;
+    };
+
+    void onConfirmPasskey(NimBLEConnInfo& connInfo, uint32_t pass_key){
+        printf("The passkey YES/NO number: %" PRIu32 "\n", pass_key);
+        /** Inject false if passkeys don't match. */
+        NimBLEDevice::injectConfirmPasskey(connInfo, true);
+    };
+
+    void onAuthenticationComplete(NimBLEConnInfo& connInfo){
+        /** Check that encryption was successful, if not we disconnect the client */
+        if(!connInfo.isEncrypted()) {
+            NimBLEDevice::getServer()->disconnect(connInfo.getConnHandle());
+            printf("Encrypt connection failed - disconnecting client\n");
+            return;
+        }
+        printf("Starting BLE work!");
+    };
+  /*******************************************************************/
+};
+
+class MyCallbacks: public BLECharacteristicCallbacks {
+    void onWrite(BLECharacteristic *pCharacteristic, BLEConnInfo& connInfo) {
+      std::string rxValue = pCharacteristic->getValue();
+
+      if (rxValue.length() > 0) {
+        printf("*********\n");
+        printf("Received Value: ");
+        for (int i = 0; i < rxValue.length(); i++)
+          printf("%d", rxValue[i]);
+
+        printf("\n*********\n");
+      }
+    }
+};
+
+void connectedTask (void * parameter){
+    for(;;) {
+        if (deviceConnected) {
+            pTxCharacteristic->setValue(&txValue, 1);
+            pTxCharacteristic->notify();
+            txValue++;
+        }
+
+        // disconnecting
+        if (!deviceConnected && oldDeviceConnected) {
+            pServer->startAdvertising(); // restart advertising
+            printf("start advertising\n");
+            oldDeviceConnected = deviceConnected;
+        }
+        // connecting
+        if (deviceConnected && !oldDeviceConnected) {
+            // do stuff here on connecting
+            oldDeviceConnected = deviceConnected;
+        }
+
+        vTaskDelay(10/portTICK_PERIOD_MS); // Delay between loops to reset watchdog timer
+    }
+
+    vTaskDelete(NULL);
+}
+
+void app_main(void) {
+  // Create the BLE Device
+  BLEDevice::init("UART Service");
+
+  // Create the BLE Server
+  pServer = BLEDevice::createServer();
+  pServer->setCallbacks(new MyServerCallbacks());
+
+  // Create the BLE Service
+  BLEService *pService = pServer->createService(SERVICE_UUID);
+
+  // Create a BLE Characteristic
+  pTxCharacteristic = pService->createCharacteristic(
+                                        CHARACTERISTIC_UUID_TX,
+                                    /******* Enum Type NIMBLE_PROPERTY now *******
+                                        BLECharacteristic::PROPERTY_NOTIFY
+                                        );
+                                    **********************************************/
+                                        NIMBLE_PROPERTY::NOTIFY
+                                       );
+
+  /***************************************************
+   NOTE: DO NOT create a 2902 descriptor
+   it will be created automatically if notifications
+   or indications are enabled on a characteristic.
+
+   pCharacteristic->addDescriptor(new BLE2902());
+  ****************************************************/
+
+  BLECharacteristic * pRxCharacteristic = pService->createCharacteristic(
+                                            CHARACTERISTIC_UUID_RX,
+                                    /******* Enum Type NIMBLE_PROPERTY now *******
+                                            BLECharacteristic::PROPERTY_WRITE
+                                            );
+                                    *********************************************/
+                                            NIMBLE_PROPERTY::WRITE
+                                            );
+
+  pRxCharacteristic->setCallbacks(new MyCallbacks());
+
+  // Start the service
+  pService->start();
+
+  xTaskCreate(connectedTask, "connectedTask", 5000, NULL, 1, NULL);
+
+  // Start advertising
+  pServer->getAdvertising()->start();
+  printf("Waiting a client connection to notify...\n");
+}

examples/basic/BLE_uart/sdkconfig.defaults

@@ -0,0 +1,12 @@
+# 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

pkg.yml

@@ -1,20 +0,0 @@
-pkg.name: esp-nimble-cpp
-pkg.type: lib
-pkg.description: NimBLE CPP wrapper
-pkg.author: "Ryan Powell"
-pkg.homepage: "http://mynewt.apache.org/"
-pkg.keywords:
-
-pkg.deps:
-    - "@apache-mynewt-nimble/nimble"
-    - "@apache-mynewt-nimble/nimble/host"
-    - "@apache-mynewt-nimble/nimble/host/services/gap"
-    - "@apache-mynewt-nimble/nimble/host/services/gatt"
-    - "@apache-mynewt-nimble/nimble/host/store/config"
-    - "@apache-mynewt-nimble/nimble/host/util"
-
-pkg.source_dirs:
-    - src
-
-pkg.include_dirs:
-    - src

src/HIDTypes.h

@@ -25,9 +25,9 @@
 #define HID_VERSION_1_11    (0x0111)
 
 /* HID Class */
-#define BLE_HID_CLASS           (3)
-#define BLE_HID_SUBCLASS_NONE   (0)
-#define BLE_HID_PROTOCOL_NONE   (0)
+#define HID_CLASS           (3)
+#define HID_SUBCLASS_NONE   (0)
+#define HID_PROTOCOL_NONE   (0)
 
 /* Descriptors */
 #define HID_DESCRIPTOR          (33)

src/NimBLE2904.cpp

@@ -15,57 +15,68 @@
 #include "nimconfig.h"
 #if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
 
-# include "NimBLE2904.h"
+#include "NimBLE2904.h"
+
+
+NimBLE2904::NimBLE2904(NimBLECharacteristic* pCharacteristic)
+: NimBLEDescriptor(NimBLEUUID((uint16_t) 0x2904),
+                            BLE_GATT_CHR_F_READ,
+                            sizeof(BLE2904_Data),
+                            pCharacteristic)
+{
+    m_data.m_format      = 0;
+    m_data.m_exponent    = 0;
+    m_data.m_namespace   = 1;  // 1 = Bluetooth SIG Assigned Numbers
+    m_data.m_unit        = 0;
+    m_data.m_description = 0;
+    setValue((uint8_t*) &m_data, sizeof(m_data));
+} // BLE2904
 
-NimBLE2904::NimBLE2904(NimBLECharacteristic* pChr)
-    : NimBLEDescriptor(NimBLEUUID((uint16_t)0x2904), BLE_GATT_CHR_F_READ, sizeof(NimBLE2904Data), pChr) {
-    setValue(m_data);
-} // NimBLE2904
 
 /**
  * @brief Set the description.
- * @param [in] description The description value to set.
  */
 void NimBLE2904::setDescription(uint16_t description) {
     m_data.m_description = description;
-    setValue(m_data);
-} // setDescription
+    setValue((uint8_t*) &m_data, sizeof(m_data));
+}
+
 
 /**
  * @brief Set the exponent.
- * @param [in] exponent The exponent value to set.
  */
 void NimBLE2904::setExponent(int8_t exponent) {
     m_data.m_exponent = exponent;
-    setValue(m_data);
+    setValue((uint8_t*) &m_data, sizeof(m_data));
 } // setExponent
 
+
 /**
  * @brief Set the format.
- * @param [in] format The format value to set.
  */
 void NimBLE2904::setFormat(uint8_t format) {
     m_data.m_format = format;
-    setValue(m_data);
+    setValue((uint8_t*) &m_data, sizeof(m_data));
 } // setFormat
 
+
 /**
  * @brief Set the namespace.
- * @param [in] namespace_value The namespace value toset.
  */
 void NimBLE2904::setNamespace(uint8_t namespace_value) {
     m_data.m_namespace = namespace_value;
-    setValue(m_data);
+    setValue((uint8_t*) &m_data, sizeof(m_data));
 } // setNamespace
 
+
 /**
- * @brief Set the units for this value.
+ * @brief Set the units for this value.  It should be one of the encoded values defined here:
+ * https://www.bluetooth.com/specifications/assigned-numbers/units
  * @param [in] unit The type of units of this characteristic as defined by assigned numbers.
- * @details See https://www.bluetooth.com/specifications/assigned-numbers/units
  */
 void NimBLE2904::setUnit(uint16_t unit) {
     m_data.m_unit = unit;
-    setValue(m_data);
+    setValue((uint8_t*) &m_data, sizeof(m_data));
 } // setUnit
 
 #endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */

src/NimBLE2904.h

@@ -12,30 +12,31 @@
  *      Author: kolban
  */
 
-#ifndef NIMBLE_CPP_2904_H_
-#define NIMBLE_CPP_2904_H_
-
+#ifndef MAIN_NIMBLE2904_H_
+#define MAIN_NIMBLE2904_H_
 #include "nimconfig.h"
 #if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
 
-# include "NimBLEDescriptor.h"
+#include "NimBLEDescriptor.h"
+
+struct BLE2904_Data {
+    uint8_t  m_format;
+    int8_t   m_exponent;
+    uint16_t m_unit;      // See https://www.bluetooth.com/specifications/assigned-numbers/units
+    uint8_t  m_namespace;
+    uint16_t m_description;
 
-struct NimBLE2904Data {
-    uint8_t  m_format{0};
-    int8_t   m_exponent{0};
-    uint16_t m_unit{0x2700}; // Unitless; See https://www.bluetooth.com/specifications/assigned-numbers/units
-    uint8_t  m_namespace{1}; // 1 = Bluetooth SIG Assigned Numbers
-    uint16_t m_description{0}; // unknown description
 } __attribute__((packed));
 
+
 /**
  * @brief Descriptor for Characteristic Presentation Format.
  *
  * This is a convenience descriptor for the Characteristic Presentation Format which has a UUID of 0x2904.
  */
-class NimBLE2904 : public NimBLEDescriptor {
-  public:
-    NimBLE2904(NimBLECharacteristic* pChr = nullptr);
+class NimBLE2904: public NimBLEDescriptor {
+public:
+    NimBLE2904(NimBLECharacteristic* pCharacterisitic = nullptr);
     static const uint8_t FORMAT_BOOLEAN   = 1;
     static const uint8_t FORMAT_UINT2     = 2;
     static const uint8_t FORMAT_UINT4     = 3;
@@ -63,7 +64,6 @@ class NimBLE2904 : public NimBLEDescriptor {
     static const uint8_t FORMAT_UTF8      = 25;
     static const uint8_t FORMAT_UTF16     = 26;
     static const uint8_t FORMAT_OPAQUE    = 27;
-    static const uint8_t FORMAT_MEDASN1   = 28;
 
     void setDescription(uint16_t);
     void setExponent(int8_t exponent);
@@ -71,10 +71,10 @@ class NimBLE2904 : public NimBLEDescriptor {
     void setNamespace(uint8_t namespace_value);
     void setUnit(uint16_t unit);
 
-  private:
+private:
     friend class NimBLECharacteristic;
-    NimBLE2904Data m_data{};
-}; // NimBLE2904
+    BLE2904_Data m_data;
+}; // BLE2904
 
-#endif // CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL
-#endif // NIMBLE_CPP_2904_H_
+#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */
+#endif /* MAIN_NIMBLE2904_H_ */

src/NimBLEAdvertisedDevice.cpp

@@ -35,6 +35,7 @@ NimBLEAdvertisedDevice::NimBLEAdvertisedDevice(const ble_gap_event* event, uint8
       m_rssi{event->ext_disc.rssi},
       m_callbackSent{0},
       m_advLength{event->ext_disc.length_data},
+      m_srTimeout{0},
       m_isLegacyAdv{!!(event->ext_disc.props & BLE_HCI_ADV_LEGACY_MASK)},
       m_sid{event->ext_disc.sid},
       m_primPhy{event->ext_disc.prim_phy},
@@ -47,6 +48,7 @@ NimBLEAdvertisedDevice::NimBLEAdvertisedDevice(const ble_gap_event* event, uint8
       m_rssi{event->disc.rssi},
       m_callbackSent{0},
       m_advLength{event->disc.length_data},
+      m_srTimeout{0},
       m_payload(event->disc.data, event->disc.data + event->disc.length_data) {
 # endif
 } // NimBLEAdvertisedDevice
@@ -757,14 +759,6 @@ bool NimBLEAdvertisedDevice::isConnectable() const {
     return (m_advType & BLE_HCI_ADV_CONN_MASK) || (m_advType & BLE_HCI_ADV_DIRECT_MASK);
 } // isConnectable
 
-/**
- * @brief Check if this device is advertising as scannable.
- * @return True if the device is scannable.
- */
-bool NimBLEAdvertisedDevice::isScannable() const {
-    return isLegacyAdvertisement() && (m_advType == BLE_HCI_ADV_TYPE_ADV_IND || m_advType == BLE_HCI_ADV_TYPE_ADV_SCAN_IND);
-} // isScannable
-
 /**
  * @brief Check if this advertisement is a legacy or extended type
  * @return True if legacy (Bluetooth 4.x), false if extended (bluetooth 5.x).

src/NimBLEAdvertisedDevice.h

@@ -82,7 +82,6 @@ class NimBLEAdvertisedDevice {
     bool                 haveType(uint16_t type) const;
     std::string          toString() const;
     bool                 isConnectable() const;
-    bool                 isScannable() const;
     bool                 isLegacyAdvertisement() const;
 # if CONFIG_BT_NIMBLE_EXT_ADV
     uint8_t  getSetId() const;
@@ -158,6 +157,7 @@ class NimBLEAdvertisedDevice {
     int8_t        m_rssi{};
     uint8_t       m_callbackSent{};
     uint8_t       m_advLength{};
+    uint32_t      m_srTimeout{};
 
 # if CONFIG_BT_NIMBLE_EXT_ADV
     bool     m_isLegacyAdv{};

src/NimBLEAdvertisementData.cpp

@@ -1,574 +0,0 @@
-/*
- * NimBLEAdvertisementData.cpp
- *
- *  Created: on November 24, 2024
- *      Author H2zero
- *
- */
-
-#include "nimconfig.h"
-#if (defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER) && !CONFIG_BT_NIMBLE_EXT_ADV) || \
-    defined(_DOXYGEN_)
-
-# include "NimBLEAdvertisementData.h"
-# include "NimBLEDevice.h"
-# include "NimBLEUtils.h"
-# include "NimBLEUUID.h"
-# include "NimBLELog.h"
-
-# if defined(CONFIG_NIMBLE_CPP_IDF)
-#  include "host/ble_hs_adv.h"
-# else
-#  include "nimble/nimble/host/include/host/ble_hs_adv.h"
-# endif
-
-static const char* LOG_TAG = "NimBLEAdvertisementData";
-
-/**
- * @brief Add data to the payload to be advertised.
- * @param [in] data The data to be added to the payload.
- * @param [in] length The size of data to be added to the payload.
- */
-bool NimBLEAdvertisementData::addData(const uint8_t* data, size_t length) {
-    if ((m_payload.size() + length) > BLE_HS_ADV_MAX_SZ) {
-        NIMBLE_LOGE(LOG_TAG, "Data length exceeded");
-        return false;
-    }
-
-    m_payload.insert(m_payload.end(), data, data + length);
-    return true;
-} // addData
-
-/**
- * @brief Add data to the payload to be advertised.
- * @param [in] data The data to be added to the payload.
- */
-bool NimBLEAdvertisementData::addData(const std::vector<uint8_t>& data) {
-    return addData(&data[0], data.size());
-} // addData
-
-/**
- * @brief Set the appearance.
- * @param [in] appearance The appearance code value.
- * @return True if successful.
- * @details If the appearance value is 0 then it will be removed from the advertisement if set previously.
- */
-bool NimBLEAdvertisementData::setAppearance(uint16_t appearance) {
-    if (appearance == 0) {
-        return removeData(BLE_HS_ADV_TYPE_APPEARANCE);
-    }
-
-    uint8_t data[4];
-    data[0] = 3;
-    data[1] = BLE_HS_ADV_TYPE_APPEARANCE;
-    data[2] = appearance;
-    data[3] = (appearance >> 8) & 0xFF;
-    return addData(data, 4);
-} // setAppearance
-
-/**
- * @brief Set the advertisement flags.
- * @param [in] flag The flags to be set in the advertisement.
- * * BLE_HS_ADV_F_DISC_LTD
- * * BLE_HS_ADV_F_DISC_GEN
- * * BLE_HS_ADV_F_BREDR_UNSUP - must always use with NimBLE
- * A flag value of 0 will remove the flags from the advertisement.
- */
-bool NimBLEAdvertisementData::setFlags(uint8_t flag) {
-    int dataLoc = getDataLocation(BLE_HS_ADV_TYPE_FLAGS);
-    if (dataLoc != -1) {
-        if (flag) {
-            m_payload[dataLoc + 2] = flag | BLE_HS_ADV_F_BREDR_UNSUP;
-            return true;
-        } else {
-            return removeData(BLE_HS_ADV_TYPE_FLAGS);
-        }
-    }
-
-    uint8_t data[3];
-    data[0] = 2;
-    data[1] = BLE_HS_ADV_TYPE_FLAGS;
-    data[2] = flag | BLE_HS_ADV_F_BREDR_UNSUP;
-    return addData(data, 3);
-} // setFlags
-
-/**
- * @brief Adds Tx power level to the advertisement data.
- * @return True if successful.
- */
-bool NimBLEAdvertisementData::addTxPower() {
-    uint8_t data[3];
-    data[0] = BLE_HS_ADV_TX_PWR_LVL_LEN + 1;
-    data[1] = BLE_HS_ADV_TYPE_TX_PWR_LVL;
-# ifndef CONFIG_IDF_TARGET_ESP32P4
-    data[2] = NimBLEDevice::getPower();
-# else
-    data[2] = 0;
-# endif
-    return addData(data, 3);
-} // addTxPower
-
-/**
- * @brief Set the preferred min and max connection intervals to advertise.
- * @param [in] minInterval The minimum preferred connection interval.
- * @param [in] maxInterval The Maximum preferred connection interval.
- * @details  Range = 0x0006(7.5ms) to 0x0C80(4000ms), values not within the range will be limited to this range.
- * @return True if successful.
- */
-bool NimBLEAdvertisementData::setPreferredParams(uint16_t minInterval, uint16_t maxInterval) {
-    minInterval = std::max<uint16_t>(minInterval, 0x6);
-    minInterval = std::min<uint16_t>(minInterval, 0xC80);
-    maxInterval = std::max<uint16_t>(maxInterval, 0x6);
-    maxInterval = std::min<uint16_t>(maxInterval, 0xC80);
-    maxInterval = std::max<uint16_t>(maxInterval, minInterval); // Max must be greater than or equal to min.
-
-    uint8_t data[6];
-    data[0] = BLE_HS_ADV_SLAVE_ITVL_RANGE_LEN + 1;
-    data[1] = BLE_HS_ADV_TYPE_SLAVE_ITVL_RANGE;
-    data[2] = minInterval;
-    data[3] = minInterval >> 8;
-    data[4] = maxInterval;
-    data[5] = maxInterval >> 8;
-    return addData(data, 6);
-} // setPreferredParams
-
-/**
- * @brief Add a service uuid to exposed list of services.
- * @param [in] serviceUUID The UUID of the service to expose.
- */
-bool NimBLEAdvertisementData::addServiceUUID(const NimBLEUUID& serviceUUID) {
-    uint8_t bytes = serviceUUID.bitSize() / 8;
-    int     type;
-    switch (bytes) {
-        case 2:
-            type = BLE_HS_ADV_TYPE_COMP_UUIDS16;
-            break;
-        case 4:
-            type = BLE_HS_ADV_TYPE_COMP_UUIDS32;
-            break;
-        case 16:
-            type = BLE_HS_ADV_TYPE_COMP_UUIDS128;
-            break;
-        default:
-            return false;
-    }
-
-    int     dataLoc = getDataLocation(type);
-    uint8_t length  = bytes;
-    if (dataLoc == -1) {
-        length += 2;
-    }
-
-    if (length + getPayload().size() > BLE_HS_ADV_MAX_SZ) {
-        return false;
-    }
-
-    uint8_t        data[31];
-    const uint8_t* uuid = serviceUUID.getValue();
-    if (dataLoc == -1) {
-        data[0] = 1 + bytes;
-        data[1] = type;
-        memcpy(&data[2], uuid, bytes);
-        return addData(data, length);
-    }
-
-    m_payload.insert(m_payload.begin() + dataLoc + m_payload[dataLoc] + 1, uuid, uuid + bytes);
-    m_payload[dataLoc] += bytes;
-    return true;
-} // addServiceUUID
-
-/**
- * @brief Add a service uuid to exposed list of services.
- * @param [in] serviceUUID The string representation of the service to expose.
- * @return True if successful.
- */
-bool NimBLEAdvertisementData::addServiceUUID(const char* serviceUUID) {
-    return addServiceUUID(NimBLEUUID(serviceUUID));
-} // addServiceUUID
-
-/**
- * @brief Remove a service UUID from the advertisement.
- * @param [in] serviceUUID The UUID of the service to remove.
- * @return True if successful or uuid not found, false if uuid error or data could not be reset.
- */
-bool NimBLEAdvertisementData::removeServiceUUID(const NimBLEUUID& serviceUUID) {
-    uint8_t bytes = serviceUUID.bitSize() / 8;
-    int     type;
-    switch (bytes) {
-        case 2:
-            type = BLE_HS_ADV_TYPE_COMP_UUIDS16;
-            break;
-        case 4:
-            type = BLE_HS_ADV_TYPE_COMP_UUIDS32;
-            break;
-        case 16:
-            type = BLE_HS_ADV_TYPE_COMP_UUIDS128;
-            break;
-        default:
-            return false;
-    }
-
-    int dataLoc = getDataLocation(type);
-    if (dataLoc == -1) {
-        return true;
-    }
-
-    int uuidLoc = -1;
-    for (size_t i = dataLoc + 2; i < m_payload.size(); i += bytes) {
-        if (memcmp(&m_payload[i], serviceUUID.getValue(), bytes) == 0) {
-            uuidLoc = i;
-            break;
-        }
-    }
-
-    if (uuidLoc == -1) {
-        return true;
-    }
-
-    if (m_payload[dataLoc] - bytes == 1) {
-        return removeData(type);
-    }
-
-    m_payload.erase(m_payload.begin() + uuidLoc, m_payload.begin() + uuidLoc + bytes);
-    m_payload[dataLoc] -= bytes;
-    return true;
-} // removeServiceUUID
-
-/**
- * @brief Remove a service UUID from the advertisement.
- * @param [in] serviceUUID The UUID of the service to remove.
- * @return True if successful or uuid not found, false if uuid error or data could not be reset.
- */
-bool NimBLEAdvertisementData::removeServiceUUID(const char* serviceUUID) {
-    return removeServiceUUID(NimBLEUUID(serviceUUID));
-} // removeServiceUUID
-
-/**
- * @brief Remove all service UUIDs from the advertisement.
- */
-bool NimBLEAdvertisementData::removeServices() {
-    return true;
-} // removeServices
-
-/**
- * @brief Set manufacturer specific data.
- * @param [in] data The manufacturer data to advertise.
- * @param [in] length The length of the data.
- * @return True if successful.
- */
-bool NimBLEAdvertisementData::setManufacturerData(const uint8_t* data, size_t length) {
-    if (length > 29) {
-        NIMBLE_LOGE(LOG_TAG, "MFG data too long");
-        return false;
-    }
-
-    uint8_t mdata[31];
-    mdata[0] = length + 1;
-    mdata[1] = BLE_HS_ADV_TYPE_MFG_DATA;
-    memcpy(&mdata[2], data, length);
-    return addData(mdata, length + 2);
-} // setManufacturerData
-
-/**
- * @brief Set manufacturer specific data.
- * @param [in] data The manufacturer data to advertise.
- * @return True if successful.
- */
-bool NimBLEAdvertisementData::setManufacturerData(const std::string& data) {
-    return setManufacturerData(reinterpret_cast<const uint8_t*>(data.data()), data.length());
-} // setManufacturerData
-
-/**
- * @brief Set manufacturer specific data.
- * @param [in] data The manufacturer data to advertise.
- * @return True if successful.
- */
-bool NimBLEAdvertisementData::setManufacturerData(const std::vector<uint8_t>& data) {
-    return setManufacturerData(&data[0], data.size());
-} // setManufacturerData
-
-/**
- * @brief Set the URI to advertise.
- * @param [in] uri The uri to advertise.
- * @return True if successful.
- */
-bool NimBLEAdvertisementData::setURI(const std::string& uri) {
-    if (uri.length() > 29) {
-        NIMBLE_LOGE(LOG_TAG, "URI too long");
-        return false;
-    }
-
-    uint8_t data[31];
-    uint8_t length = 2 + uri.length();
-    data[0]        = length - 1;
-    data[1]        = BLE_HS_ADV_TYPE_URI;
-    memcpy(&data[2], uri.c_str(), uri.length());
-    return addData(data, length);
-} // setURI
-
-/**
- * @brief Set the complete name of this device.
- * @param [in] name The name to advertise.
- * @param [in] isComplete If true the name is complete, which will set the data type accordingly.
- * @details If the name is longer than 29 characters it will be truncated.
- * and the data type will be set to incomplete name.
- * @return True if successful.
- */
-bool NimBLEAdvertisementData::setName(const std::string& name, bool isComplete) {
-    if (name.length() > 29) {
-        NIMBLE_LOGE(LOG_TAG, "Name too long - truncating");
-        isComplete = false;
-    }
-
-    uint8_t data[31];
-    uint8_t length = 2 + std::min<uint8_t>(name.length(), 29);
-    data[0]        = length - 1;
-    data[1]        = isComplete ? BLE_HS_ADV_TYPE_COMP_NAME : BLE_HS_ADV_TYPE_INCOMP_NAME;
-    memcpy(&data[2], name.c_str(), std::min<uint8_t>(name.length(), 29));
-    return addData(data, length);
-} // setName
-
-/**
- * @brief Set the short name.
- * @param [in] name The short name of the device.
- * @return True if successful.
- */
-bool NimBLEAdvertisementData::setShortName(const std::string& name) {
-    return setName(name, false);
-} // setShortName
-
-/**
- * @brief Set a single service to advertise as a complete list of services.
- * @param [in] uuid The service to advertise.
- * @return True if successful.
- */
-bool NimBLEAdvertisementData::setCompleteServices(const NimBLEUUID& uuid) {
-    return setServices(true, uuid.bitSize(), {uuid});
-} // setCompleteServices
-
-/**
- * @brief Set the complete list of 16 bit services to advertise.
- * @param [in] uuids A vector of 16 bit UUID's to advertise.
- * @return True if successful.
- */
-bool NimBLEAdvertisementData::setCompleteServices16(const std::vector<NimBLEUUID>& uuids) {
-    return setServices(true, 16, uuids);
-} // setCompleteServices16
-
-/**
- * @brief Set the complete list of 32 bit services to advertise.
- * @param [in] uuids A vector of 32 bit UUID's to advertise.
- * @return True if successful.
- */
-bool NimBLEAdvertisementData::setCompleteServices32(const std::vector<NimBLEUUID>& uuids) {
-    return setServices(true, 32, uuids);
-} // setCompleteServices32
-
-/**
- * @brief Set a single service to advertise as a partial list of services.
- * @param [in] uuid The service to advertise.
- * @return True if successful.
- */
-bool NimBLEAdvertisementData::setPartialServices(const NimBLEUUID& uuid) {
-    return setServices(false, uuid.bitSize(), {uuid});
-} // setPartialServices
-
-/**
- * @brief Set the partial list of services to advertise.
- * @param [in] uuids A vector of 16 bit UUID's to advertise.
- * @return True if successful.
- */
-bool NimBLEAdvertisementData::setPartialServices16(const std::vector<NimBLEUUID>& uuids) {
-    return setServices(false, 16, uuids);
-} // setPartialServices16
-
-/**
- * @brief Set the partial list of services to advertise.
- * @param [in] uuids A vector of 32 bit UUID's to advertise.
- * @return True if successful.
- */
-bool NimBLEAdvertisementData::setPartialServices32(const std::vector<NimBLEUUID>& uuids) {
-    return setServices(false, 32, uuids);
-} // setPartialServices32
-
-/**
- * @brief Utility function to create the list of service UUID's from a vector.
- * @param [in] complete If true the vector is the complete set of services.
- * @param [in] size The bit size of the UUID's in the vector. (16, 32, or 128).
- * @param [in] uuids The vector of service UUID's to advertise.
- * @return True if successful.
- * @details The number of services will be truncated if the total length exceeds 31 bytes.
- */
-bool NimBLEAdvertisementData::setServices(bool complete, uint8_t size, const std::vector<NimBLEUUID>& uuids) {
-    uint8_t bytes  = size / 8;
-    uint8_t length = 2; // start with 2 for length + type bytes
-    uint8_t data[31];
-
-    for (const auto& uuid : uuids) {
-        if (uuid.bitSize() != size) {
-            NIMBLE_LOGE(LOG_TAG, "Service UUID(%d) invalid", size);
-            continue;
-        } else {
-            if (length + bytes >= 31) {
-                NIMBLE_LOGW(LOG_TAG, "Too many services - truncating");
-                complete = false;
-                break;
-            }
-            memcpy(&data[length], uuid.getValue(), bytes);
-            length += bytes;
-        }
-    }
-
-    data[0] = length - 1; // don't count the length byte as part of the AD length
-
-    switch (size) {
-        case 16:
-            data[1] = (complete ? BLE_HS_ADV_TYPE_COMP_UUIDS16 : BLE_HS_ADV_TYPE_INCOMP_UUIDS16);
-            break;
-        case 32:
-            data[1] = (complete ? BLE_HS_ADV_TYPE_COMP_UUIDS32 : BLE_HS_ADV_TYPE_INCOMP_UUIDS32);
-            break;
-        case 128:
-            data[1] = (complete ? BLE_HS_ADV_TYPE_COMP_UUIDS128 : BLE_HS_ADV_TYPE_INCOMP_UUIDS128);
-            break;
-        default:
-            return false;
-    }
-
-    return addData(data, length);
-} // setServices
-
-/**
- * @brief Set the service data advertised for the UUID.
- * @param [in] uuid The UUID the service data belongs to.
- * @param [in] data The data to advertise.
- * @param [in] length The length of the data.
- * @note If data length is 0 the service data will not be advertised.
- * @return True if successful, false if data length is too long or could not be set.
- */
-bool NimBLEAdvertisementData::setServiceData(const NimBLEUUID& uuid, const uint8_t* data, size_t length) {
-    uint8_t uuidBytes = uuid.bitSize() / 8;
-    uint8_t sDataLen  = 2 + uuidBytes + length;
-    if (sDataLen > 31) {
-        NIMBLE_LOGE(LOG_TAG, "Service Data too long");
-        return false;
-    }
-
-    uint8_t type;
-    switch (uuidBytes) {
-        case 2:
-            type = BLE_HS_ADV_TYPE_SVC_DATA_UUID16;
-            break;
-        case 4:
-            type = BLE_HS_ADV_TYPE_SVC_DATA_UUID32;
-            break;
-        case 16:
-            type = BLE_HS_ADV_TYPE_SVC_DATA_UUID128;
-            break;
-        default:
-            return false;
-    }
-
-    if (length == 0) {
-        removeData(type);
-        return true;
-    }
-
-    uint8_t sData[31];
-    sData[0] = uuidBytes + length + 1;
-    sData[1] = type;
-    memcpy(&sData[2], uuid.getValue(), uuidBytes);
-    memcpy(&sData[2 + uuidBytes], data, length);
-    return addData(sData, sDataLen);
-} // setServiceData
-
-/**
- * @brief Set the service data (UUID + data)
- * @param [in] uuid The UUID to set with the service data.
- * @param [in] data The data to be associated with the service data advertised.
- * @return True if the service data was set successfully.
- * @note If data length is 0 the service data will not be advertised.
- */
-bool NimBLEAdvertisementData::setServiceData(const NimBLEUUID& uuid, const std::string& data) {
-    return setServiceData(uuid, reinterpret_cast<const uint8_t*>(data.data()), data.length());
-} // setServiceData
-
-/**
- * @brief Set the service data advertised for the UUID.
- * @param [in] uuid The UUID the service data belongs to.
- * @param [in] data The data to advertise.
- * @return True if the service data was set successfully.
- * @note If data length is 0 the service data will not be advertised.
- */
-bool NimBLEAdvertisementData::setServiceData(const NimBLEUUID& uuid, const std::vector<uint8_t>& data) {
-    return setServiceData(uuid, &data[0], data.size());
-} // setServiceData
-
-/**
- * @brief Get the location of the data in the payload.
- * @param [in] type The type of data to search for.
- * @return -1 if the data is not found, otherwise the index of the data in the payload.
- */
-int NimBLEAdvertisementData::getDataLocation(uint8_t type) const {
-    size_t index = 0;
-    while (index < m_payload.size()) {
-        if (m_payload[index + 1] == type) {
-            return index;
-        }
-        index += m_payload[index] + 1;
-    }
-    return -1;
-} // getDataLocation
-
-/**
- * @brief Remove data from the advertisement data.
- * @param [in] type The type of data to remove.
- * @return True if successful, false if the data was not found.
- */
-bool NimBLEAdvertisementData::removeData(uint8_t type) {
-    int dataLoc = getDataLocation(type);
-    if (dataLoc != -1) {
-        std::vector<uint8_t> swap(m_payload.begin(), m_payload.begin() + dataLoc);
-        int                  nextData = dataLoc + m_payload[dataLoc] + 1;
-        swap.insert(swap.end(), m_payload.begin() + nextData, m_payload.end());
-        swap.swap(m_payload);
-        return true;
-    }
-
-    return false;
-} // removeData
-
-/**
- * @brief Retrieve the payload that is to be advertised.
- * @return The payload of the advertisement data.
- */
-std::vector<uint8_t> NimBLEAdvertisementData::getPayload() const {
-    return m_payload;
-} // getPayload
-
-/**
- * @brief Clear the advertisement data for reuse.
- */
-void NimBLEAdvertisementData::clearData() {
-    std::vector<uint8_t>().swap(m_payload);
-} // clearData
-
-/**
- * @brief Get the string representation of the advertisement data.
- * @return The string representation of the advertisement data.
- */
-std::string NimBLEAdvertisementData::toString() const {
-    std::string hexStr = NimBLEUtils::dataToHexString(&m_payload[0], m_payload.size());
-    std::string str;
-    for (size_t i = 0; i < hexStr.length(); i += 2) {
-        str += hexStr[i];
-        str += hexStr[i + 1];
-        if (i + 2 < hexStr.length()) {
-            str += " ";
-        }
-    }
-
-    return str;
-} // toString
-
-#endif // CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_BROADCASTER && !CONFIG_BT_NIMBLE_EXT_ADV

src/NimBLEAdvertisementData.h

@@ -1,70 +0,0 @@
-/*
- * NimBLEAdvertisementData.h
- *
- *  Created: on November 24, 2024
- *      Author H2zero
- *
- */
-
-#ifndef NIMBLE_CPP_ADVERTISEMENT_DATA_H_
-#define NIMBLE_CPP_ADVERTISEMENT_DATA_H_
-
-#include "nimconfig.h"
-#if (defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER) && !CONFIG_BT_NIMBLE_EXT_ADV) || \
-    defined(_DOXYGEN_)
-
-#include <cstdint>
-#include <string>
-#include <vector>
-
-class NimBLEUUID;
-/**
- * @brief Advertisement data set by the programmer to be published by the BLE server.
- */
-class NimBLEAdvertisementData {
-    // Only a subset of the possible BLE architected advertisement fields are currently exposed.  Others will
-    // be exposed on demand/request or as time permits.
-    //
-  public:
-    bool addData(const uint8_t* data, size_t length);
-    bool addData(const std::vector<uint8_t>& data);
-    bool setAppearance(uint16_t appearance);
-    bool setFlags(uint8_t);
-    bool addTxPower();
-    bool setPreferredParams(uint16_t minInterval, uint16_t maxInterval);
-    bool addServiceUUID(const NimBLEUUID& serviceUUID);
-    bool addServiceUUID(const char* serviceUUID);
-    bool removeServiceUUID(const NimBLEUUID& serviceUUID);
-    bool removeServiceUUID(const char* serviceUUID);
-    bool removeServices();
-    bool setManufacturerData(const uint8_t* data, size_t length);
-    bool setManufacturerData(const std::string& data);
-    bool setManufacturerData(const std::vector<uint8_t>& data);
-    bool setURI(const std::string& uri);
-    bool setName(const std::string& name, bool isComplete = true);
-    bool setShortName(const std::string& name);
-    bool setCompleteServices(const NimBLEUUID& uuid);
-    bool setCompleteServices16(const std::vector<NimBLEUUID>& uuids);
-    bool setCompleteServices32(const std::vector<NimBLEUUID>& uuids);
-    bool setPartialServices(const NimBLEUUID& uuid);
-    bool setPartialServices16(const std::vector<NimBLEUUID>& uuids);
-    bool setPartialServices32(const std::vector<NimBLEUUID>& uuids);
-    bool setServiceData(const NimBLEUUID& uuid, const uint8_t* data, size_t length);
-    bool setServiceData(const NimBLEUUID& uuid, const std::string& data);
-    bool setServiceData(const NimBLEUUID& uuid, const std::vector<uint8_t>& data);
-    bool removeData(uint8_t type);
-    void clearData();
-    int  getDataLocation(uint8_t type) const;
-
-    std::string          toString() const;
-    std::vector<uint8_t> getPayload() const;
-
-  private:
-    friend class NimBLEAdvertising;
-
-    bool                 setServices(bool complete, uint8_t size, const std::vector<NimBLEUUID>& v_uuid);
-    std::vector<uint8_t> m_payload{};
-}; // NimBLEAdvertisementData
-
-#endif // CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_BROADCASTER && !CONFIG_BT_NIMBLE_EXT_ADV
-#endif // NIMBLE_CPP_ADVERTISEMENT_DATA_H_

src/NimBLEAdvertising.h

@@ -12,96 +12,139 @@
  *      Author: kolban
  */
 
-#ifndef NIMBLE_CPP_ADVERTISING_H_
-#define NIMBLE_CPP_ADVERTISING_H_
-
+#ifndef MAIN_BLEADVERTISING_H_
+#define MAIN_BLEADVERTISING_H_
 #include "nimconfig.h"
-#if (defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER) && !CONFIG_BT_NIMBLE_EXT_ADV) || \
-    defined(_DOXYGEN_)
+#if (defined(CONFIG_BT_ENABLED) && \
+    defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER) && \
+    !CONFIG_BT_NIMBLE_EXT_ADV) || defined(_DOXYGEN_)
 
-# if defined(CONFIG_NIMBLE_CPP_IDF)
-#  include "host/ble_gap.h"
-# else
-#  include "nimble/nimble/host/include/host/ble_gap.h"
-# endif
+#if defined(CONFIG_NIMBLE_CPP_IDF)
+#include "host/ble_gap.h"
+#else
+#include "nimble/nimble/host/include/host/ble_gap.h"
+#endif
 
 /****  FIX COMPILATION ****/
-# undef min
-# undef max
+#undef min
+#undef max
 /**************************/
 
-# include "NimBLEUUID.h"
-# include "NimBLEAddress.h"
-# include "NimBLEAdvertisementData.h"
+#include "NimBLEUUID.h"
+#include "NimBLEAddress.h"
 
-# include <functional>
-# include <string>
-# include <vector>
+#include <functional>
+#include <vector>
+
+/* COMPATIBILITY - DO NOT USE */
+#define ESP_BLE_ADV_FLAG_LIMIT_DISC         (0x01 << 0)
+#define ESP_BLE_ADV_FLAG_GEN_DISC           (0x01 << 1)
+#define ESP_BLE_ADV_FLAG_BREDR_NOT_SPT      (0x01 << 2)
+#define ESP_BLE_ADV_FLAG_DMT_CONTROLLER_SPT (0x01 << 3)
+#define ESP_BLE_ADV_FLAG_DMT_HOST_SPT       (0x01 << 4)
+#define ESP_BLE_ADV_FLAG_NON_LIMIT_DISC     (0x00 )
+ /* ************************* */
 
 class NimBLEAdvertising;
+
 typedef std::function<void(NimBLEAdvertising*)> advCompleteCB_t;
 
 /**
- * @brief Perform and manage BLE advertising.
+ * @brief Advertisement data set by the programmer to be published by the %BLE server.
+ */
+class NimBLEAdvertisementData {
+    // Only a subset of the possible BLE architected advertisement fields are currently exposed.  Others will
+    // be exposed on demand/request or as time permits.
+    //
+public:
+    void setAppearance(uint16_t appearance);
+    void setCompleteServices(const NimBLEUUID &uuid);
+    void setCompleteServices16(const std::vector<NimBLEUUID> &v_uuid);
+    void setCompleteServices32(const std::vector<NimBLEUUID> &v_uuid);
+    void setFlags(uint8_t);
+    void setManufacturerData(const std::string &data);
+    void setManufacturerData(const std::vector<uint8_t> &data);
+    void setURI(const std::string &uri);
+    void setName(const std::string &name);
+    void setPartialServices(const NimBLEUUID &uuid);
+    void setPartialServices16(const std::vector<NimBLEUUID> &v_uuid);
+    void setPartialServices32(const std::vector<NimBLEUUID> &v_uuid);
+    void setServiceData(const NimBLEUUID &uuid, const std::string &data);
+    void setShortName(const std::string &name);
+    void addData(const std::string &data);  // Add data to the payload.
+    void addData(char * data, size_t length);
+    void addTxPower();
+    void setPreferredParams(uint16_t min, uint16_t max);
+    std::string getPayload();               // Retrieve the current advert payload.
+    void clearData();                       // Clear the advertisement data.
+
+private:
+    friend class NimBLEAdvertising;
+    void setServices(const bool complete, const uint8_t size,
+                     const std::vector<NimBLEUUID> &v_uuid);
+    std::string m_payload;   // The payload of the advertisement.
+};   // NimBLEAdvertisementData
+
+
+/**
+ * @brief Perform and manage %BLE advertising.
  *
- * A BLE server will want to perform advertising in order to make itself known to BLE clients.
+ * A %BLE server will want to perform advertising in order to make itself known to %BLE clients.
  */
 class NimBLEAdvertising {
-  public:
+public:
     NimBLEAdvertising();
-    bool start(uint32_t duration = 0, const NimBLEAddress* dirAddr = nullptr);
-    void setAdvertisingCompleteCallback(advCompleteCB_t callback);
+    void addServiceUUID(const NimBLEUUID &serviceUUID);
+    void addServiceUUID(const char* serviceUUID);
+    void removeServiceUUID(const NimBLEUUID &serviceUUID);
+    bool start(uint32_t duration = 0, advCompleteCB_t advCompleteCB = nullptr, NimBLEAddress* dirAddr = nullptr);
+    void removeServices();
     bool stop();
-    bool setConnectableMode(uint8_t mode);
-    bool setDiscoverableMode(uint8_t mode);
-    bool reset();
-    bool isAdvertising();
+    void setAppearance(uint16_t appearance);
+    void setName(const std::string &name);
+    void setManufacturerData(const std::string &data);
+    void setManufacturerData(const std::vector<uint8_t> &data);
+    void setURI(const std::string &uri);
+    void setServiceData(const NimBLEUUID &uuid, const std::string &data);
+    void setAdvertisementType(uint8_t adv_type);
+    void setMaxInterval(uint16_t maxinterval);
+    void setMinInterval(uint16_t mininterval);
+    void setAdvertisementData(NimBLEAdvertisementData& advertisementData);
     void setScanFilter(bool scanRequestWhitelistOnly, bool connectWhitelistOnly);
-    void enableScanResponse(bool enable);
-    void setAdvertisingInterval(uint16_t interval);
-    void setMaxInterval(uint16_t maxInterval);
-    void setMinInterval(uint16_t minInterval);
+    void setScanResponseData(NimBLEAdvertisementData& advertisementData);
+    void setScanResponse(bool);
+    void setMinPreferred(uint16_t);
+    void setMaxPreferred(uint16_t);
+    void addTxPower();
+    void reset();
+    void advCompleteCB();
+    bool isAdvertising();
 
-    bool                           setAdvertisementData(const NimBLEAdvertisementData& advertisementData);
-    bool                           setScanResponseData(const NimBLEAdvertisementData& advertisementData);
-    const NimBLEAdvertisementData& getAdvertisementData();
-    const NimBLEAdvertisementData& getScanData();
-    void                           clearData();
-    bool                           refreshAdvertisingData();
-
-    bool addServiceUUID(const NimBLEUUID& serviceUUID);
-    bool addServiceUUID(const char* serviceUUID);
-    bool removeServiceUUID(const NimBLEUUID& serviceUUID);
-    bool removeServiceUUID(const char* serviceUUID);
-    bool removeServices();
-    bool setAppearance(uint16_t appearance);
-    bool setPreferredParams(uint16_t minInterval, uint16_t maxInterval);
-    bool addTxPower();
-    bool setName(const std::string& name);
-    bool setManufacturerData(const uint8_t* data, size_t length);
-    bool setManufacturerData(const std::string& data);
-    bool setManufacturerData(const std::vector<uint8_t>& data);
-    bool setURI(const std::string& uri);
-    bool setServiceData(const NimBLEUUID& uuid, const uint8_t* data, size_t length);
-    bool setServiceData(const NimBLEUUID& uuid, const std::string& data);
-    bool setServiceData(const NimBLEUUID& uuid, const std::vector<uint8_t>& data);
-
-  private:
+private:
     friend class NimBLEDevice;
     friend class NimBLEServer;
 
-    void       onHostSync();
-    static int handleGapEvent(ble_gap_event* event, void* arg);
+    void                    onHostSync();
+    static int              handleGapEvent(struct ble_gap_event *event, void *arg);
 
-    NimBLEAdvertisementData m_advData;
-    NimBLEAdvertisementData m_scanData;
+    ble_hs_adv_fields       m_advData;
+    ble_hs_adv_fields       m_scanData;
     ble_gap_adv_params      m_advParams;
-    advCompleteCB_t         m_advCompCb;
+    std::vector<NimBLEUUID> m_serviceUUIDs;
+    bool                    m_customAdvData;
+    bool                    m_customScanResponseData;
+    bool                    m_scanResp;
+    bool                    m_advDataSet;
+    advCompleteCB_t         m_advCompCB{nullptr};
     uint8_t                 m_slaveItvl[4];
     uint32_t                m_duration;
-    bool                    m_scanResp : 1;
-    bool                    m_advDataSet : 1;
+    std::vector<uint8_t>    m_svcData16;
+    std::vector<uint8_t>    m_svcData32;
+    std::vector<uint8_t>    m_svcData128;
+    std::vector<uint8_t>    m_name;
+    std::vector<uint8_t>    m_mfgData;
+    std::vector<uint8_t>    m_uri;
 };
 
 #endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_BROADCASTER  && !CONFIG_BT_NIMBLE_EXT_ADV */
-#endif /* NIMBLE_CPP_ADVERTISING_H_ */
+#endif /* MAIN_BLEADVERTISING_H_ */

src/NimBLEAttValue.h

@@ -84,15 +84,16 @@ class NimBLEAttValue {
      * @param[in] len The size in bytes of the value to set.
      * @param[in] max_len The max size in bytes that the value can be.
      */
-    NimBLEAttValue(const uint8_t* value, uint16_t len, uint16_t max_len = BLE_ATT_ATTR_MAX_LEN);
+    NimBLEAttValue(const uint8_t *value, uint16_t len,
+                   uint16_t max_len = BLE_ATT_ATTR_MAX_LEN);
 
     /**
      * @brief Construct with an initial value from a const char string.
      * @param value A pointer to the initial value to set.
      * @param[in] max_len The max size in bytes that the value can be.
      */
-    NimBLEAttValue(const char* value, uint16_t max_len = BLE_ATT_ATTR_MAX_LEN)
-        : NimBLEAttValue((uint8_t*)value, (uint16_t)strlen(value), max_len) {}
+    NimBLEAttValue(const char *value, uint16_t max_len = BLE_ATT_ATTR_MAX_LEN)
+                   :NimBLEAttValue((uint8_t*)value, (uint16_t)strlen(value), max_len){}
 
     /**
      * @brief Construct with an initializer list.
@@ -220,61 +221,14 @@ class NimBLEAttValue {
 
     /*********************** Template Functions ************************/
 
-# if __cplusplus < 201703L
-    /**
-     * @brief Template to set value to the value of <type\>val.
-     * @param [in] v The <type\>value to set.
-     * @details Only used for types without a `c_str()` and `length()` or `data()` and `size()` method.
-     * <type\> size must be evaluatable by `sizeof()`.
-     */
-    template <typename T>
-#  ifdef _DOXYGEN_
-    bool
-#  else
-    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));
-    }
-
     /**
      * @brief Template to set value to the value of <type\>val.
      * @param [in] s The <type\>value to set.
-     * @details Only used if the <type\> has a `c_str()` method.
+     * @note This function is only availabe if the type T is not a pointer.
      */
     template <typename T>
-#  ifdef _DOXYGEN_
-    bool
-#  else
-    typename std::enable_if<Has_c_str_length<T>::value && !Has_data_size<T>::value, bool>::type
-#  endif
+    typename std::enable_if<!std::is_pointer<T>::value, bool>::type
     setValue(const T& s) {
-        return setValue(reinterpret_cast<const uint8_t*>(s.c_str()), s.length());
-    }
-
-    /**
-     * @brief Template to set value to the value of <type\>val.
-     * @param [in] v The <type\>value to set.
-     * @details Only used if the <type\> has a `data()` and `size()` method.
-     */
-    template <typename T>
-#  ifdef _DOXYGEN_
-    bool
-#  else
-    typename std::enable_if<Has_data_size<T>::value, bool>::type
-#  endif
-    setValue(const T& v) {
-        return setValue(reinterpret_cast<const uint8_t*>(v.data()), v.size());
-    }
-
-# else
-    /**
-     * @brief Template to set value to the value of <type\>val.
-     * @param [in] s The <type\>value to set.
-     * @note This function is only available if the type T is not a pointer.
-     */
-    template <typename T>
-    typename std::enable_if<!std::is_pointer<T>::value, bool>::type setValue(const T& s) {
         if constexpr (Has_data_size<T>::value) {
             return setValue(reinterpret_cast<const uint8_t*>(s.data()), s.size());
         } else if constexpr (Has_c_str_length<T>::value) {
@@ -283,7 +237,6 @@ class NimBLEAttValue {
             return setValue(reinterpret_cast<const uint8_t*>(&s), sizeof(s));
         }
     }
-# endif
 
     /**
      * @brief Template to return the value as a <type\>.

src/NimBLEBeacon.cpp

@@ -1,5 +1,5 @@
 /*
- * NimBLEBeacon.cpp
+ * NimBLEBeacon2.cpp
  *
  *  Created: on March 15 2020
  *      Author H2zero
@@ -11,33 +11,50 @@
  *  Created on: Jan 4, 2018
  *      Author: kolban
  */
-
 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER)
+#if defined(CONFIG_BT_ENABLED)
 
-# include "NimBLEBeacon.h"
-# include "NimBLEUUID.h"
-# include "NimBLELog.h"
+#include <string.h>
+#include <algorithm>
+#include "NimBLEBeacon.h"
+#include "NimBLELog.h"
 
-# define ENDIAN_CHANGE_U16(x) ((((x) & 0xFF00) >> 8) + (((x) & 0xFF) << 8))
+#define ENDIAN_CHANGE_U16(x) ((((x)&0xFF00)>>8) + (((x)&0xFF)<<8))
 
 static const char* LOG_TAG = "NimBLEBeacon";
 
+
+/**
+ * @brief Construct a default beacon object.
+ */
+NimBLEBeacon::NimBLEBeacon() {
+    m_beaconData.manufacturerId = 0x4c00;
+    m_beaconData.subType        = 0x02;
+    m_beaconData.subTypeLength  = 0x15;
+    m_beaconData.major          = 0;
+    m_beaconData.minor          = 0;
+    m_beaconData.signalPower    = 0;
+    memset(m_beaconData.proximityUUID, 0, sizeof(m_beaconData.proximityUUID));
+} // NimBLEBeacon
+
+
 /**
  * @brief Retrieve the data that is being advertised.
  * @return The advertised data.
  */
-const NimBLEBeacon::BeaconData& NimBLEBeacon::getData() {
-    return m_beaconData;
+std::string NimBLEBeacon::getData() {
+    return std::string((char*) &m_beaconData, sizeof(m_beaconData));
 } // getData
 
+
 /**
  * @brief Get the major value being advertised.
  * @return The major value advertised.
  */
 uint16_t NimBLEBeacon::getMajor() {
     return m_beaconData.major;
-} // getMajor
+}
+
 
 /**
  * @brief Get the manufacturer ID being advertised.
@@ -45,7 +62,8 @@ uint16_t NimBLEBeacon::getMajor() {
  */
 uint16_t NimBLEBeacon::getManufacturerId() {
     return m_beaconData.manufacturerId;
-} // getManufacturerId
+}
+
 
 /**
  * @brief Get the minor value being advertised.
@@ -53,7 +71,8 @@ uint16_t NimBLEBeacon::getManufacturerId() {
  */
 uint16_t NimBLEBeacon::getMinor() {
     return m_beaconData.minor;
-} // getMinor
+}
+
 
 /**
  * @brief Get the proximity UUID being advertised.
@@ -61,7 +80,8 @@ uint16_t NimBLEBeacon::getMinor() {
  */
 NimBLEUUID NimBLEBeacon::getProximityUUID() {
     return NimBLEUUID(m_beaconData.proximityUUID, 16).reverseByteOrder();
-} // getProximityUUID
+}
+
 
 /**
  * @brief Get the signal power being advertised.
@@ -69,28 +89,22 @@ NimBLEUUID NimBLEBeacon::getProximityUUID() {
  */
 int8_t NimBLEBeacon::getSignalPower() {
     return m_beaconData.signalPower;
-} // getSignalPower
+}
+
 
 /**
- * @brief Set the beacon data.
- * @param [in] data A pointer to the raw data that the beacon should advertise.
- * @param [in] length The length of the data.
+ * @brief Set the raw data for the beacon record.
+ * @param [in] data The raw beacon data.
  */
-void NimBLEBeacon::setData(const uint8_t* data, uint8_t length) {
-    if (length != sizeof(BeaconData)) {
-        NIMBLE_LOGE(LOG_TAG, "Data length must be %d bytes, sent: %d", sizeof(BeaconData), length);
+void NimBLEBeacon::setData(const std::string &data) {
+    if (data.length() != sizeof(m_beaconData)) {
+        NIMBLE_LOGE(LOG_TAG, "Unable to set the data ... length passed in was %d and expected %d",
+                                                        data.length(), sizeof(m_beaconData));
         return;
     }
-    memcpy(&m_beaconData, data, length);
+    memcpy(&m_beaconData, data.data(), sizeof(m_beaconData));
 } // setData
 
-/**
- * @brief Set the beacon data.
- * @param [in] data The data that the beacon should advertise.
- */
-void NimBLEBeacon::setData(const NimBLEBeacon::BeaconData& data) {
-    m_beaconData = data;
-} // setData
 
 /**
  * @brief Set the major value.
@@ -100,6 +114,7 @@ void NimBLEBeacon::setMajor(uint16_t major) {
     m_beaconData.major = ENDIAN_CHANGE_U16(major);
 } // setMajor
 
+
 /**
  * @brief Set the manufacturer ID.
  * @param [in] manufacturerId The manufacturer ID value.
@@ -108,6 +123,7 @@ void NimBLEBeacon::setManufacturerId(uint16_t manufacturerId) {
     m_beaconData.manufacturerId = ENDIAN_CHANGE_U16(manufacturerId);
 } // setManufacturerId
 
+
 /**
  * @brief Set the minor value.
  * @param [in] minor The minor value.
@@ -116,17 +132,18 @@ void NimBLEBeacon::setMinor(uint16_t minor) {
     m_beaconData.minor = ENDIAN_CHANGE_U16(minor);
 } // setMinor
 
+
 /**
  * @brief Set the proximity UUID.
  * @param [in] uuid The proximity UUID.
  */
-void NimBLEBeacon::setProximityUUID(const NimBLEUUID& uuid) {
+void NimBLEBeacon::setProximityUUID(const NimBLEUUID &uuid) {
     NimBLEUUID temp_uuid = uuid;
     temp_uuid.to128();
-    temp_uuid.reverseByteOrder();
-    memcpy(m_beaconData.proximityUUID, temp_uuid.getValue(), 16);
+    std::reverse_copy(temp_uuid.getValue(), temp_uuid.getValue() + 16, m_beaconData.proximityUUID);
 } // setProximityUUID
 
+
 /**
  * @brief Set the signal power.
  * @param [in] signalPower The signal power value.
@@ -135,4 +152,4 @@ void NimBLEBeacon::setSignalPower(int8_t signalPower) {
     m_beaconData.signalPower = signalPower;
 } // setSignalPower
 
-#endif // CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_BROADCASTER
+#endif

src/NimBLEBeacon.h

@@ -1,61 +1,51 @@
 /*
- * NimBLEBeacon.h
+ * NimBLEBeacon2.h
  *
  *  Created: on March 15 2020
  *      Author H2zero
  *
  * Originally:
  *
- * BLEBeacon.h
+ * BLEBeacon2.h
  *
  *  Created on: Jan 4, 2018
  *      Author: kolban
  */
 
-#ifndef NIMBLE_CPP_BEACON_H_
-#define NIMBLE_CPP_BEACON_H_
-
-#include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER)
-
-class NimBLEUUID;
-
-# include <cstdint>
+#ifndef MAIN_NIMBLEBEACON_H_
+#define MAIN_NIMBLEBEACON_H_
 
+#include "NimBLEUUID.h"
 /**
  * @brief Representation of a beacon.
  * See:
  * * https://en.wikipedia.org/wiki/IBeacon
  */
 class NimBLEBeacon {
-  public:
-    struct BeaconData {
-        uint16_t manufacturerId{0x4c00};
-        uint8_t  subType{0x02};
-        uint8_t  subTypeLength{0x15};
-        uint8_t  proximityUUID[16]{};
-        uint16_t major{};
-        uint16_t minor{};
-        int8_t   signalPower{};
-    } __attribute__((packed));
-
-    const BeaconData& getData();
-    uint16_t          getMajor();
-    uint16_t          getMinor();
-    uint16_t          getManufacturerId();
-    NimBLEUUID        getProximityUUID();
-    int8_t            getSignalPower();
-    void              setData(const uint8_t* data, uint8_t length);
-    void              setData(const BeaconData& data);
-    void              setMajor(uint16_t major);
-    void              setMinor(uint16_t minor);
-    void              setManufacturerId(uint16_t manufacturerId);
-    void              setProximityUUID(const NimBLEUUID& uuid);
-    void              setSignalPower(int8_t signalPower);
-
-  private:
-    BeaconData m_beaconData;
+private:
+    struct {
+        uint16_t manufacturerId;
+        uint8_t  subType;
+        uint8_t  subTypeLength;
+        uint8_t  proximityUUID[16];
+        uint16_t major;
+        uint16_t minor;
+        int8_t   signalPower;
+    } __attribute__((packed)) m_beaconData;
+public:
+    NimBLEBeacon();
+    std::string getData();
+    uint16_t    getMajor();
+    uint16_t    getMinor();
+    uint16_t    getManufacturerId();
+    NimBLEUUID     getProximityUUID();
+    int8_t      getSignalPower();
+    void        setData(const std::string &data);
+    void        setMajor(uint16_t major);
+    void        setMinor(uint16_t minor);
+    void        setManufacturerId(uint16_t manufacturerId);
+    void        setProximityUUID(const NimBLEUUID &uuid);
+    void        setSignalPower(int8_t signalPower);
 }; // NimBLEBeacon
 
-#endif // NIMBLE_CPP_BEACON_H_
-#endif // CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL
+#endif /* MAIN_NIMBLEBEACON_H_ */

src/NimBLECharacteristic.cpp

@@ -18,6 +18,9 @@
 # include "NimBLEDevice.h"
 # include "NimBLELog.h"
 
+# define NIMBLE_SUB_NOTIFY   0x0001
+# define NIMBLE_SUB_INDICATE 0x0002
+
 static NimBLECharacteristicCallbacks defaultCallback;
 static const char*                   LOG_TAG = "NimBLECharacteristic";
 
@@ -25,21 +28,21 @@ static const char*                   LOG_TAG = "NimBLECharacteristic";
  * @brief Construct a characteristic
  * @param [in] uuid - UUID (const char*) for the characteristic.
  * @param [in] properties - Properties for the characteristic.
- * @param [in] maxLen - The maximum length in bytes that the characteristic value can hold. (Default: 512 bytes for esp32, 20 for all others).
+ * @param [in] max_len - The maximum length in bytes that the characteristic value can hold. (Default: 512 bytes for esp32, 20 for all others).
  * @param [in] pService - pointer to the service instance this characteristic belongs to.
  */
-NimBLECharacteristic::NimBLECharacteristic(const char* uuid, uint16_t properties, uint16_t maxLen, NimBLEService* pService)
-    : NimBLECharacteristic(NimBLEUUID(uuid), properties, maxLen, pService) {}
+NimBLECharacteristic::NimBLECharacteristic(const char* uuid, uint16_t properties, uint16_t max_len, NimBLEService* pService)
+    : NimBLECharacteristic(NimBLEUUID(uuid), properties, max_len, pService) {}
 
 /**
  * @brief Construct a characteristic
  * @param [in] uuid - UUID for the characteristic.
  * @param [in] properties - Properties for the characteristic.
- * @param [in] maxLen - The maximum length in bytes that the characteristic value can hold. (Default: 512 bytes for esp32, 20 for all others).
+ * @param [in] max_len - The maximum length in bytes that the characteristic value can hold. (Default: 512 bytes for esp32, 20 for all others).
  * @param [in] pService - pointer to the service instance this characteristic belongs to.
  */
-NimBLECharacteristic::NimBLECharacteristic(const NimBLEUUID& uuid, uint16_t properties, uint16_t maxLen, NimBLEService* pService)
-    : NimBLELocalValueAttribute{uuid, 0, maxLen}, m_pCallbacks{&defaultCallback}, m_pService{pService} {
+NimBLECharacteristic::NimBLECharacteristic(const NimBLEUUID& uuid, uint16_t properties, uint16_t max_len, NimBLEService* pService)
+    : NimBLELocalValueAttribute{uuid, 0, max_len}, m_pCallbacks{&defaultCallback}, m_pService{pService} {
     setProperties(properties);
 } // NimBLECharacteristic
 
@@ -56,43 +59,32 @@ NimBLECharacteristic::~NimBLECharacteristic() {
  * @brief Create a new BLE Descriptor associated with this characteristic.
  * @param [in] uuid - The UUID of the descriptor.
  * @param [in] properties - The properties of the descriptor.
- * @param [in] maxLen - The max length in bytes of the descriptor value.
+ * @param [in] max_len - The max length in bytes of the descriptor value.
  * @return The new BLE descriptor.
  */
-NimBLEDescriptor* NimBLECharacteristic::createDescriptor(const char* uuid, uint32_t properties, uint16_t maxLen) {
-    return createDescriptor(NimBLEUUID(uuid), properties, maxLen);
+NimBLEDescriptor* NimBLECharacteristic::createDescriptor(const char* uuid, uint32_t properties, uint16_t max_len) {
+    return createDescriptor(NimBLEUUID(uuid), properties, max_len);
 }
 
 /**
  * @brief Create a new BLE Descriptor associated with this characteristic.
  * @param [in] uuid - The UUID of the descriptor.
  * @param [in] properties - The properties of the descriptor.
- * @param [in] maxLen - The max length in bytes of the descriptor value.
+ * @param [in] max_len - The max length in bytes of the descriptor value.
  * @return The new BLE descriptor.
  */
-NimBLEDescriptor* NimBLECharacteristic::createDescriptor(const NimBLEUUID& uuid, uint32_t properties, uint16_t maxLen) {
+NimBLEDescriptor* NimBLECharacteristic::createDescriptor(const NimBLEUUID& uuid, uint32_t properties, uint16_t max_len) {
     NimBLEDescriptor* pDescriptor = nullptr;
-    if (uuid == NimBLEUUID(static_cast<uint16_t>(0x2904))) {
-        NIMBLE_LOGW(LOG_TAG, "0x2904 descriptor should be created with create2904()");
-        pDescriptor = create2904();
+    if (uuid == NimBLEUUID(uint16_t(0x2904))) {
+        pDescriptor = new NimBLE2904(this);
     } else {
-        pDescriptor = new NimBLEDescriptor(uuid, properties, maxLen, this);
+        pDescriptor = new NimBLEDescriptor(uuid, properties, max_len, this);
     }
 
     addDescriptor(pDescriptor);
     return pDescriptor;
 } // createDescriptor
 
-/**
- * @brief Create a Characteristic Presentation Format Descriptor for this characteristic.
- * @return A pointer to a NimBLE2904 descriptor.
- */
-NimBLE2904* NimBLECharacteristic::create2904() {
-    NimBLE2904* pDescriptor = new NimBLE2904(this);
-    addDescriptor(pDescriptor);
-    return pDescriptor;
-} // create2904
-
 /**
  * @brief Add a descriptor to the characteristic.
  * @param [in] pDescriptor A pointer to the descriptor to add.
@@ -208,107 +200,181 @@ void NimBLECharacteristic::setService(NimBLEService* pService) {
 } // setService
 
 /**
- * @brief Send an indication.
- * @param[in] connHandle Connection handle to send an individual indication, or BLE_HS_CONN_HANDLE_NONE to send
- * the indication to all subscribed clients.
- * @return True if the indication was sent successfully, false otherwise.
+ * @brief Get the number of clients subscribed to the characteristic.
+ * @returns Number of clients subscribed to notifications / indications.
  */
-bool NimBLECharacteristic::indicate(uint16_t connHandle) const {
-    return sendValue(nullptr, 0, false, connHandle);
+size_t NimBLECharacteristic::getSubscribedCount() const {
+    return m_subscribedVec.size();
+}
+
+/**
+ * @brief Set the subscribe status for this characteristic.\n
+ * This will maintain a vector of subscribed clients and their indicate/notify status.
+ */
+void NimBLECharacteristic::setSubscribe(const ble_gap_event* event, NimBLEConnInfo& connInfo) {
+    uint16_t subVal = 0;
+    if (event->subscribe.cur_notify > 0 && (m_properties & NIMBLE_PROPERTY::NOTIFY)) {
+        subVal |= NIMBLE_SUB_NOTIFY;
+    }
+    if (event->subscribe.cur_indicate && (m_properties & NIMBLE_PROPERTY::INDICATE)) {
+        subVal |= NIMBLE_SUB_INDICATE;
+    }
+
+    NIMBLE_LOGI(LOG_TAG, "New subscribe value for conn: %d val: %d", connInfo.getConnHandle(), subVal);
+
+    if (!event->subscribe.cur_indicate && event->subscribe.prev_indicate) {
+        NimBLEDevice::getServer()->clearIndicateWait(connInfo.getConnHandle());
+    }
+
+    auto it = m_subscribedVec.begin();
+    for (; it != m_subscribedVec.end(); ++it) {
+        if ((*it).first == connInfo.getConnHandle()) {
+            break;
+        }
+    }
+
+    if (subVal > 0) {
+        if (it == m_subscribedVec.end()) {
+            m_subscribedVec.push_back({connInfo.getConnHandle(), subVal});
+        } else {
+            (*it).second = subVal;
+        }
+    } else if (it != m_subscribedVec.end()) {
+        m_subscribedVec.erase(it);
+    }
+
+    m_pCallbacks->onSubscribe(this, connInfo, subVal);
+}
+
+/**
+ * @brief Send an indication.
+ * @param[in] conn_handle Connection handle to send an individual indication, or BLE_HS_CONN_HANDLE_NONE to send
+ * the indication to all subscribed clients.
+ */
+void NimBLECharacteristic::indicate(uint16_t conn_handle) const {
+    sendValue(m_value.data(), m_value.size(), false, conn_handle);
 } // indicate
 
 /**
  * @brief Send an indication.
  * @param[in] value A pointer to the data to send.
  * @param[in] length The length of the data to send.
- * @param[in] connHandle Connection handle to send an individual indication, or BLE_HS_CONN_HANDLE_NONE to send
+ * @param[in] conn_handle Connection handle to send an individual indication, or BLE_HS_CONN_HANDLE_NONE to send
  * the indication to all subscribed clients.
- * @return True if the indication was sent successfully, false otherwise.
  */
-bool NimBLECharacteristic::indicate(const uint8_t* value, size_t length, uint16_t connHandle) const {
-    return sendValue(value, length, false, connHandle);
+void NimBLECharacteristic::indicate(const uint8_t* value, size_t length, uint16_t conn_handle) const {
+    sendValue(value, length, false, conn_handle);
 } // indicate
 
 /**
  * @brief Send a notification.
- * @param[in] connHandle Connection handle to send an individual notification, or BLE_HS_CONN_HANDLE_NONE to send
+ * @param[in] conn_handle Connection handle to send an individual notification, or BLE_HS_CONN_HANDLE_NONE to send
  * the notification to all subscribed clients.
- * @return True if the notification was sent successfully, false otherwise.
  */
-bool NimBLECharacteristic::notify(uint16_t connHandle) const {
-    return sendValue(nullptr, 0, true, connHandle);
+void NimBLECharacteristic::notify(uint16_t conn_handle) const {
+    sendValue(m_value.data(), m_value.size(), true, conn_handle);
 } // notify
 
 /**
  * @brief Send a notification.
  * @param[in] value A pointer to the data to send.
  * @param[in] length The length of the data to send.
- * @param[in] connHandle Connection handle to send an individual notification, or BLE_HS_CONN_HANDLE_NONE to send
+ * @param[in] conn_handle Connection handle to send an individual notification, or BLE_HS_CONN_HANDLE_NONE to send
  * the notification to all subscribed clients.
- * @return True if the notification was sent successfully, false otherwise.
  */
-bool NimBLECharacteristic::notify(const uint8_t* value, size_t length, uint16_t connHandle) const {
-    return sendValue(value, length, true, connHandle);
+void NimBLECharacteristic::notify(const uint8_t* value, size_t length, uint16_t conn_handle) const {
+    sendValue(value, length, true, conn_handle);
 } // indicate
 
 /**
  * @brief Sends a notification or indication.
  * @param[in] value A pointer to the data to send.
  * @param[in] length The length of the data to send.
- * @param[in] isNotification if true sends a notification, false sends an indication.
- * @param[in] connHandle Connection handle to send to a specific peer.
- * @return True if the value was sent successfully, false otherwise.
+ * @param[in] is_notification if true sends a notification, false sends an indication.
+ * @param[in] conn_handle Connection handle to send to a specific peer, or BLE_HS_CONN_HANDLE_NONE to send
+ * to all subscribed clients.
  */
-bool NimBLECharacteristic::sendValue(const uint8_t* value, size_t length, bool isNotification, uint16_t connHandle) const {
-    int rc = 0;
+void NimBLECharacteristic::sendValue(const uint8_t* value, size_t length, bool is_notification, uint16_t conn_handle) const {
+    NIMBLE_LOGD(LOG_TAG, ">> sendValue");
 
-    if (value != nullptr && length > 0) { // custom notification value
-        // Notify all connected peers unless a specific handle is provided
-        for (const auto& ch : NimBLEDevice::getServer()->getPeerDevices()) {
-            if (connHandle != BLE_HS_CONN_HANDLE_NONE && ch != connHandle) {
-                continue; // only send to the specific handle, minor inefficiency but saves code.
-            }
-
-            // Must re-create the data buffer on each iteration because it is freed by the calls bellow.
-            os_mbuf* om = ble_hs_mbuf_from_flat(value, length);
-            if (!om) {
-                NIMBLE_LOGE(LOG_TAG, "<< sendValue: failed to allocate mbuf");
-                return false;
-            }
-
-            if (isNotification) {
-                rc = ble_gattc_notify_custom(ch, m_handle, om);
-            } else {
-                rc = ble_gattc_indicate_custom(ch, m_handle, om);
-            }
-
-            if (rc != 0) {
-                NIMBLE_LOGE(LOG_TAG, "<< sendValue: failed to send value, rc=%d %s", rc, NimBLEUtils::returnCodeToString(rc));
-                break;
-            }
-        }
-    } else if (connHandle != BLE_HS_CONN_HANDLE_NONE) { // only sending to specific peer
-        // Null buffer will read the value from the characteristic
-        if (isNotification) {
-            rc = ble_gattc_notify_custom(connHandle, m_handle, NULL);
-        } else {
-            rc = ble_gattc_indicate_custom(connHandle, m_handle, NULL);
-        }
-    } else { // Notify or indicate to all connected peers the characteristic value
-        ble_gatts_chr_updated(m_handle);
+    if (is_notification && !(getProperties() & NIMBLE_PROPERTY::NOTIFY)) {
+        NIMBLE_LOGE(LOG_TAG, "<< sendValue: notification not enabled for characteristic");
+        return;
     }
 
-    return rc == 0;
+    if (!is_notification && !(getProperties() & NIMBLE_PROPERTY::INDICATE)) {
+        NIMBLE_LOGE(LOG_TAG, "<< sendValue: indication not enabled for characteristic");
+        return;
+    }
+
+    if (!m_subscribedVec.size()) {
+        NIMBLE_LOGD(LOG_TAG, "<< sendValue: No clients subscribed.");
+        return;
+    }
+
+    for (const auto& it : m_subscribedVec) {
+        // check if connected and subscribed
+        if (!it.second) {
+            continue;
+        }
+
+        // sending to a specific client?
+        if ((conn_handle <= BLE_HCI_LE_CONN_HANDLE_MAX) && (it.first != conn_handle)) {
+            continue;
+        }
+
+        if (is_notification && !(it.second & NIMBLE_SUB_NOTIFY)) {
+            continue;
+        }
+
+        if (!is_notification && !(it.second & NIMBLE_SUB_INDICATE)) {
+            continue;
+        }
+
+        // check if security requirements are satisfied
+        if ((getProperties() & BLE_GATT_CHR_F_READ_AUTHEN) || (getProperties() & BLE_GATT_CHR_F_READ_AUTHOR) ||
+            (getProperties() & BLE_GATT_CHR_F_READ_ENC)) {
+            ble_gap_conn_desc desc;
+            if (ble_gap_conn_find(it.first, &desc) != 0 || !desc.sec_state.encrypted) {
+                continue;
+            }
+        }
+
+        // don't create the m_buf until we are sure to send the data or else
+        // we could be allocating a buffer that doesn't get released.
+        // We also must create it in each loop iteration because it is consumed with each host call.
+        os_mbuf* om = ble_hs_mbuf_from_flat(value, length);
+        if (!om) {
+            NIMBLE_LOGE(LOG_TAG, "<< sendValue: failed to allocate mbuf");
+            return;
+        }
+
+        if (is_notification) {
+            ble_gattc_notify_custom(it.first, getHandle(), om);
+        } else {
+            if (!NimBLEDevice::getServer()->setIndicateWait(it.first)) {
+                NIMBLE_LOGE(LOG_TAG, "<< sendValue: waiting for previous indicate");
+                os_mbuf_free_chain(om);
+                return;
+            }
+
+            if (ble_gattc_indicate_custom(it.first, getHandle(), om) != 0) {
+                NimBLEDevice::getServer()->clearIndicateWait(it.first);
+            }
+        }
+    }
+
+    NIMBLE_LOGD(LOG_TAG, "<< sendValue");
 } // sendValue
 
 void NimBLECharacteristic::readEvent(NimBLEConnInfo& connInfo) {
     m_pCallbacks->onRead(this, connInfo);
-} // readEvent
+}
 
 void NimBLECharacteristic::writeEvent(const uint8_t* val, uint16_t len, NimBLEConnInfo& connInfo) {
     setValue(val, len);
     m_pCallbacks->onWrite(this, connInfo);
-} // writeEvent
+}
 
 /**
  * @brief Set the callback handlers for this characteristic.
@@ -389,7 +455,7 @@ void NimBLECharacteristicCallbacks::onStatus(NimBLECharacteristic* pCharacterist
  * * 3 = Notifications and Indications
  */
 void NimBLECharacteristicCallbacks::onSubscribe(NimBLECharacteristic* pCharacteristic,
-                                                NimBLEConnInfo&       connInfo,
+                                                NimBLEConnInfo& connInfo,
                                                 uint16_t              subValue) {
     NIMBLE_LOGD("NimBLECharacteristicCallbacks", "onSubscribe: default");
 }

src/NimBLECharacteristic.h

@@ -17,12 +17,14 @@
 #if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
 
 class NimBLECharacteristicCallbacks;
-class NimBLEService;
 class NimBLECharacteristic;
-class NimBLEDescriptor;
-class NimBLE2904;
 
 # include "NimBLELocalValueAttribute.h"
+# include "NimBLEServer.h"
+# include "NimBLEService.h"
+# include "NimBLEDescriptor.h"
+# include "NimBLEAttValue.h"
+# include "NimBLEConnInfo.h"
 
 # include <string>
 # include <vector>
@@ -37,32 +39,32 @@ class NimBLECharacteristic : public NimBLELocalValueAttribute {
   public:
     NimBLECharacteristic(const char*    uuid,
                          uint16_t       properties = NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE,
-                         uint16_t       maxLen     = BLE_ATT_ATTR_MAX_LEN,
+                         uint16_t       max_len    = BLE_ATT_ATTR_MAX_LEN,
                          NimBLEService* pService   = nullptr);
     NimBLECharacteristic(const NimBLEUUID& uuid,
                          uint16_t          properties = NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE,
-                         uint16_t          maxLen     = BLE_ATT_ATTR_MAX_LEN,
+                         uint16_t          max_len    = BLE_ATT_ATTR_MAX_LEN,
                          NimBLEService*    pService   = nullptr);
 
     ~NimBLECharacteristic();
 
     std::string toString() const;
+    size_t      getSubscribedCount() const;
     void        addDescriptor(NimBLEDescriptor* pDescriptor);
     void        removeDescriptor(NimBLEDescriptor* pDescriptor, bool deleteDsc = false);
     uint16_t    getProperties() const;
     void        setCallbacks(NimBLECharacteristicCallbacks* pCallbacks);
-    bool        indicate(uint16_t connHandle = BLE_HS_CONN_HANDLE_NONE) const;
-    bool        indicate(const uint8_t* value, size_t length, uint16_t connHandle = BLE_HS_CONN_HANDLE_NONE) const;
-    bool        notify(uint16_t connHandle = BLE_HS_CONN_HANDLE_NONE) const;
-    bool        notify(const uint8_t* value, size_t length, uint16_t connHandle = BLE_HS_CONN_HANDLE_NONE) const;
+    void        indicate(uint16_t conn_handle = BLE_HS_CONN_HANDLE_NONE) const;
+    void        indicate(const uint8_t* value, size_t length, uint16_t conn_handle = BLE_HS_CONN_HANDLE_NONE) const;
+    void        notify(uint16_t conn_handle = BLE_HS_CONN_HANDLE_NONE) const;
+    void        notify(const uint8_t* value, size_t length, uint16_t conn_handle = BLE_HS_CONN_HANDLE_NONE) const;
 
     NimBLEDescriptor* createDescriptor(const char* uuid,
                                        uint32_t    properties = NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE,
-                                       uint16_t    maxLen     = BLE_ATT_ATTR_MAX_LEN);
+                                       uint16_t    max_len    = BLE_ATT_ATTR_MAX_LEN);
     NimBLEDescriptor* createDescriptor(const NimBLEUUID& uuid,
                                        uint32_t          properties = NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE,
-                                       uint16_t          maxLen     = BLE_ATT_ATTR_MAX_LEN);
-    NimBLE2904*       create2904();
+                                       uint16_t          max_len    = BLE_ATT_ATTR_MAX_LEN);
     NimBLEDescriptor* getDescriptorByUUID(const char* uuid) const;
     NimBLEDescriptor* getDescriptorByUUID(const NimBLEUUID& uuid) const;
     NimBLEDescriptor* getDescriptorByHandle(uint16_t handle) const;
@@ -72,101 +74,6 @@ class NimBLECharacteristic : public NimBLELocalValueAttribute {
 
     /*********************** Template Functions ************************/
 
-# if __cplusplus < 201703L
-    /**
-     * @brief Template to send a notification with a value from a struct or array.
-     * @param [in] v The value to send.
-     * @param [in] connHandle Optional, a connection handle to send the notification to.
-     * @details <type\> size must be evaluatable by `sizeof()`.
-     */
-    template <typename T>
-#  ifdef _DOXYGEN_
-    bool
-#  else
-    typename std::enable_if<!std::is_pointer<T>::value && !Has_c_str_length<T>::value && !Has_data_size<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), sizeof(T), connHandle);
-    }
-
-    /**
-     * @brief Template to send a notification with a value from a class that has a c_str() and length() method.
-     * @param [in] s The value to send.
-     * @param [in] connHandle Optional, a connection handle to send the notification to.
-     */
-    template <typename T>
-#  ifdef _DOXYGEN_
-    bool
-#  else
-    typename std::enable_if<Has_c_str_length<T>::value && !Has_data_size<T>::value, bool>::type
-#  endif
-    notify(const T& s, uint16_t connHandle = BLE_HS_CONN_HANDLE_NONE) const {
-        return notify(reinterpret_cast<const uint8_t*>(s.c_str()), s.length(), connHandle);
-    }
-
-    /**
-     * @brief Template to send a notification with a value from a class that has a data() and size() method.
-     * @param [in] v The value to send.
-     * @param [in] connHandle Optional, a connection handle to send the notification to.
-     */
-    template <typename T>
-#  ifdef _DOXYGEN_
-    bool
-#  else
-    typename std::enable_if<Has_data_size<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(), connHandle);
-    }
-
-    /**
-     * @brief Template to send an indication with a value from a struct or array.
-     * @param [in] v The value to send.
-     * @param [in] connHandle Optional, a connection handle to send the notification to.
-     * @details <type\> size must be evaluatable by `sizeof()`.
-     */
-    template <typename T>
-#  ifdef _DOXYGEN_
-    bool
-#  else
-    typename std::enable_if<!std::is_pointer<T>::value && !Has_c_str_length<T>::value && !Has_data_size<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), sizeof(T), connHandle);
-    }
-
-    /**
-     * @brief Template to send a indication with a value from a class that has a c_str() and length() method.
-     * @param [in] s The value to send.
-     * @param [in] connHandle Optional, a connection handle to send the notification to.
-     */
-    template <typename T>
-#  ifdef _DOXYGEN_
-    bool
-#  else
-    typename std::enable_if<Has_c_str_length<T>::value && !Has_data_size<T>::value, bool>::type
-#  endif
-    indicate(const T& s, uint16_t connHandle = BLE_HS_CONN_HANDLE_NONE) const {
-        return indicate(reinterpret_cast<const uint8_t*>(s.c_str()), s.length(), connHandle);
-    }
-
-    /**
-     * @brief Template to send a indication with a value from a class that has a data() and size() method.
-     * @param [in] v The value to send.
-     * @param [in] connHandle Optional, a connection handle to send the notification to.
-     */
-    template <typename T>
-#  ifdef _DOXYGEN_
-    bool
-#  else
-    typename std::enable_if<Has_data_size<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(), connHandle);
-    }
-
-# else
-
     /**
      * @brief Template to send a notification for classes which may have
      *        data()/size() or c_str()/length() methods. Falls back to sending
@@ -174,18 +81,18 @@ class NimBLECharacteristic : public NimBLELocalValueAttribute {
      *        pointer and getting the length of the array using sizeof.
      * @tparam T The a reference to a class containing the data to send.
      * @param[in] value The <type\>value to set.
-     * @param[in] connHandle The connection handle to send the notification to.
+     * @param[in] conn_handle The connection handle to send the notification to.
      * @note This function is only available if the type T is not a pointer.
      */
     template <typename T>
-    typename std::enable_if<!std::is_pointer<T>::value, bool>::type notify(const T& value,
-                                                                           uint16_t connHandle = BLE_HS_CONN_HANDLE_NONE) const {
+    typename std::enable_if<!std::is_pointer<T>::value, void>::type
+    notify(const T& value, uint16_t conn_handle = BLE_HS_CONN_HANDLE_NONE) const {
         if constexpr (Has_data_size<T>::value) {
-            return notify(reinterpret_cast<const uint8_t*>(value.data()), value.size(), connHandle);
+            notify(reinterpret_cast<const uint8_t*>(value.data()), value.size(), conn_handle);
         } else if constexpr (Has_c_str_length<T>::value) {
-            return notify(reinterpret_cast<const uint8_t*>(value.c_str()), value.length(), connHandle);
+            notify(reinterpret_cast<const uint8_t*>(value.c_str()), value.length(), conn_handle);
         } else {
-            return notify(reinterpret_cast<const uint8_t*>(&value), sizeof(value), connHandle);
+            notify(reinterpret_cast<const uint8_t*>(&value), sizeof(value), conn_handle);
         }
     }
 
@@ -196,37 +103,38 @@ class NimBLECharacteristic : public NimBLELocalValueAttribute {
      *       pointer and getting the length of the array using sizeof.
      * @tparam T The a reference to a class containing the data to send.
      * @param[in] value The <type\>value to set.
-     * @param[in] connHandle The connection handle to send the indication to.
+     * @param[in] conn_handle The connection handle to send the indication to.
      * @note This function is only available if the type T is not a pointer.
      */
     template <typename T>
-    typename std::enable_if<!std::is_pointer<T>::value, bool>::type indicate(
-        const T& value, uint16_t connHandle = BLE_HS_CONN_HANDLE_NONE) const {
+    typename std::enable_if<!std::is_pointer<T>::value, void>::type
+    indicate(const T& value, uint16_t conn_handle = BLE_HS_CONN_HANDLE_NONE) const {
         if constexpr (Has_data_size<T>::value) {
-            return indicate(reinterpret_cast<const uint8_t*>(value.data()), value.size(), connHandle);
+            indicate(reinterpret_cast<const uint8_t*>(value.data()), value.size(), conn_handle);
         } else if constexpr (Has_c_str_length<T>::value) {
-            return indicate(reinterpret_cast<const uint8_t*>(value.c_str()), value.length(), connHandle);
+            indicate(reinterpret_cast<const uint8_t*>(value.c_str()), value.length(), conn_handle);
         } else {
-            return indicate(reinterpret_cast<const uint8_t*>(&value), sizeof(value), connHandle);
+            indicate(reinterpret_cast<const uint8_t*>(&value), sizeof(value), conn_handle);
         }
     }
-# endif
 
   private:
     friend class NimBLEServer;
     friend class NimBLEService;
 
     void setService(NimBLEService* pService);
+    void setSubscribe(const ble_gap_event* event, NimBLEConnInfo& connInfo);
     void readEvent(NimBLEConnInfo& connInfo) override;
     void writeEvent(const uint8_t* val, uint16_t len, NimBLEConnInfo& connInfo) override;
-    bool sendValue(const uint8_t* value,
+    void sendValue(const uint8_t* value,
                    size_t         length,
                    bool           is_notification = true,
-                   uint16_t       connHandle      = BLE_HS_CONN_HANDLE_NONE) const;
+                   uint16_t       conn_handle     = BLE_HS_CONN_HANDLE_NONE) const;
 
-    NimBLECharacteristicCallbacks* m_pCallbacks{nullptr};
-    NimBLEService*                 m_pService{nullptr};
-    std::vector<NimBLEDescriptor*> m_vDescriptors{};
+    NimBLECharacteristicCallbacks*             m_pCallbacks{nullptr};
+    NimBLEService*                             m_pService{nullptr};
+    std::vector<NimBLEDescriptor*>             m_vDescriptors{};
+    std::vector<std::pair<uint16_t, uint16_t>> m_subscribedVec{};
 }; // NimBLECharacteristic
 
 /**

src/NimBLEClient.cpp

@@ -21,7 +21,7 @@
 # include "NimBLELog.h"
 
 # if defined(CONFIG_NIMBLE_CPP_IDF)
-//#  include "nimble/nimble_port.h"
+#  include "nimble/nimble_port.h"
 # else
 #  include "nimble/porting/nimble/include/nimble/nimble_port.h"
 # endif
@@ -63,7 +63,6 @@ NimBLEClient::NimBLEClient(const NimBLEAddress& peerAddress)
       m_pClientCallbacks{&defaultCallbacks},
       m_connHandle{BLE_HS_CONN_HANDLE_NONE},
       m_terminateFailCount{0},
-      m_asyncSecureAttempt{0},
       m_config{},
 # if CONFIG_BT_NIMBLE_EXT_ADV
       m_phyMask{BLE_GAP_LE_PHY_1M_MASK | BLE_GAP_LE_PHY_2M_MASK | BLE_GAP_LE_PHY_CODED_MASK},
@@ -135,7 +134,7 @@ size_t NimBLEClient::deleteService(const NimBLEUUID& uuid) {
  */
 bool NimBLEClient::connect(bool deleteAttributes, bool asyncConnect, bool exchangeMTU) {
     return connect(m_peerAddress, deleteAttributes, asyncConnect, exchangeMTU);
-} // connect
+}
 
 /**
  * @brief Connect to an advertising device.
@@ -148,10 +147,10 @@ bool NimBLEClient::connect(bool deleteAttributes, bool asyncConnect, bool exchan
  * 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 NimBLEAdvertisedDevice* device, bool deleteAttributes, bool asyncConnect, bool exchangeMTU) {
+bool NimBLEClient::connect(NimBLEAdvertisedDevice* device, bool deleteAttributes, bool asyncConnect, bool exchangeMTU) {
     NimBLEAddress address(device->getAddress());
     return connect(address, deleteAttributes, asyncConnect, exchangeMTU);
-} // connect
+}
 
 /**
  * @brief Connect to a BLE Server by address.
@@ -294,26 +293,12 @@ bool NimBLEClient::connect(const NimBLEAddress& address, bool deleteAttributes,
 /**
  * @brief Initiate a secure connection (pair/bond) with the server.\n
  * Called automatically when a characteristic or descriptor requires encryption or authentication to access it.
- * @param [in] async If true, the connection will be secured asynchronously and this function will return immediately.\n
- * If false, this function will block until the connection is secured or the client disconnects.
  * @return True on success.
- * @details If async=false, this function will block and should not be used in a callback.
+ * @details This is a blocking function and should not be used in a callback.
  */
-bool NimBLEClient::secureConnection(bool async) const {
+bool NimBLEClient::secureConnection() const {
     NIMBLE_LOGD(LOG_TAG, ">> secureConnection()");
 
-    int rc = 0;
-    if (async && !NimBLEDevice::startSecurity(m_connHandle, &rc)) {
-        m_lastErr = rc;
-        m_asyncSecureAttempt = 0;
-        return false;
-    }
-
-    if (async) {
-        m_asyncSecureAttempt++;
-        return true;
-    }
-
     NimBLETaskData taskData(const_cast<NimBLEClient*>(this), BLE_HS_ENOTCONN);
     m_pTaskData    = &taskData;
     int retryCount = 1;
@@ -403,49 +388,7 @@ void NimBLEClient::setConfig(NimBLEClient::Config config) {
  */
 void NimBLEClient::setConnectPhy(uint8_t mask) {
     m_phyMask = mask;
-} // setConnectPhy
-
-/**
- * @brief Request a change to the PHY used for this peer connection.
- * @param [in] txPhyMask TX PHY. Can be mask of following:
- * - BLE_GAP_LE_PHY_1M_MASK
- * - BLE_GAP_LE_PHY_2M_MASK
- * - BLE_GAP_LE_PHY_CODED_MASK
- * - BLE_GAP_LE_PHY_ANY_MASK
- * @param [in] rxPhyMask RX PHY. Can be mask of following:
- * - BLE_GAP_LE_PHY_1M_MASK
- * - BLE_GAP_LE_PHY_2M_MASK
- * - BLE_GAP_LE_PHY_CODED_MASK
- * - BLE_GAP_LE_PHY_ANY_MASK
- * @param phyOptions Additional PHY options. Valid values are:
- * - BLE_GAP_LE_PHY_CODED_ANY (default)
- * - BLE_GAP_LE_PHY_CODED_S2
- * - BLE_GAP_LE_PHY_CODED_S8
- * @return True if successful.
- */
-bool NimBLEClient::updatePhy(uint8_t txPhyMask, uint8_t rxPhyMask, uint16_t phyOptions) {
-    int rc = ble_gap_set_prefered_le_phy(m_connHandle, txPhyMask, rxPhyMask, phyOptions);
-    if (rc != 0) {
-        NIMBLE_LOGE(LOG_TAG, "Failed to update phy; rc=%d %s", rc, NimBLEUtils::returnCodeToString(rc));
-    }
-
-    return rc == 0;
-} // updatePhy
-
-/**
- * @brief Get the PHY used for this peer connection.
- * @param [out] txPhy The TX PHY.
- * @param [out] rxPhy The RX PHY.
- * @return True if successful.
- */
-bool NimBLEClient::getPhy(uint8_t* txPhy, uint8_t* rxPhy) {
-    int rc = ble_gap_read_le_phy(m_connHandle, txPhy, rxPhy);
-    if (rc != 0) {
-        NIMBLE_LOGE(LOG_TAG, "Failed to read phy; rc=%d %s", rc, NimBLEUtils::returnCodeToString(rc));
-    }
-
-    return rc == 0;
-} // getPhy
+}
 # endif
 
 /**
@@ -551,6 +494,62 @@ uint16_t NimBLEClient::getConnHandle() const {
     return m_connHandle;
 } // getConnHandle
 
+/**
+ * @brief Clear the connection information for this client.
+ * @note This is designed to be used to reset the connection information after
+ * calling setConnection(), and should not be used to disconnect from a peer.
+ * To disconnect from a peer, use disconnect().
+ */
+void NimBLEClient::clearConnection() {
+    m_connHandle  = BLE_HS_CONN_HANDLE_NONE;
+    m_peerAddress = NimBLEAddress{};
+} // clearConnection
+
+/**
+ * @brief Set the connection information for this client.
+ * @param [in] connInfo The connection information.
+ * @return True on success.
+ * @note Sets the connection established flag to true.
+ * @note If the client is already connected to a peer, this will return false.
+ * @note This is designed to be used when a connection is made outside of the
+ * NimBLEClient class, such as when a connection is made by the
+ * NimBLEServer class and the client is passed the connection info.
+ * This enables the GATT Server to read the attributes of the client connected to it.
+ */
+bool NimBLEClient::setConnection(const NimBLEConnInfo& connInfo) {
+    if (isConnected()) {
+        NIMBLE_LOGE(LOG_TAG, "Already connected");
+        return false;
+    }
+
+    m_peerAddress = connInfo.getAddress();
+    m_connHandle  = connInfo.getConnHandle();
+    return true;
+} // setConnection
+
+/**
+ * @brief Set the connection information for this client.
+ * @param [in] connHandle The connection handle.
+ * @note Sets the connection established flag to true.
+ * @note This is designed to be used when a connection is made outside of the
+ * NimBLEClient class, such as when a connection is made by the
+ * NimBLEServer class and the client is passed the connection handle.
+ * This enables the GATT Server to read the attributes of the client connected to it.
+ * @note If the client is already connected to a peer, this will return false.
+ * @note This will look up the peer address using the connection handle.
+ */
+bool NimBLEClient::setConnection(uint16_t connHandle) {
+    // we weren't provided the peer address, look it up using ble_gap_conn_find
+    NimBLEConnInfo connInfo;
+    int            rc = ble_gap_conn_find(connHandle, &connInfo.m_desc);
+    if (rc != 0) {
+        NIMBLE_LOGE(LOG_TAG, "Connection info not found");
+        return false;
+    }
+
+    return setConnection(connInfo);
+} // setConnection
+
 /**
  * @brief Retrieve the address of the peer.
  * @return A NimBLEAddress instance with the peer address data.
@@ -601,7 +600,7 @@ int NimBLEClient::getRssi() const {
  */
 std::vector<NimBLERemoteService*>::iterator NimBLEClient::begin() {
     return m_svcVec.begin();
-} // begin
+}
 
 /**
  * @brief Get iterator to the end of the vector of remote service pointers.
@@ -609,7 +608,7 @@ std::vector<NimBLERemoteService*>::iterator NimBLEClient::begin() {
  */
 std::vector<NimBLERemoteService*>::iterator NimBLEClient::end() {
     return m_svcVec.end();
-} // end
+}
 
 /**
  * @brief Get the service BLE Remote Service instance corresponding to the uuid.
@@ -771,7 +770,7 @@ int NimBLEClient::serviceDiscoveredCB(uint16_t                     connHandle,
     NimBLEClient*   pClient   = (NimBLEClient*)pTaskData->m_pInstance;
 
     if (error->status == BLE_HS_ENOTCONN) {
-        NIMBLE_LOGE(LOG_TAG, "<< Service Discovered; Disconnected");
+        NIMBLE_LOGE(LOG_TAG, "<< Service Discovered; Not connected");
         NimBLEUtils::taskRelease(*pTaskData, error->status);
         return error->status;
     }
@@ -790,7 +789,7 @@ int NimBLEClient::serviceDiscoveredCB(uint16_t                     connHandle,
     NimBLEUtils::taskRelease(*pTaskData, error->status);
     NIMBLE_LOGD(LOG_TAG, "<< Service Discovered");
     return error->status;
-} // serviceDiscoveredCB
+}
 
 /**
  * @brief Get the value of a specific characteristic associated with a specific service.
@@ -864,7 +863,7 @@ NimBLERemoteCharacteristic* NimBLEClient::getCharacteristic(uint16_t handle) {
     }
 
     return nullptr;
-} // getCharacteristic
+}
 
 /**
  * @brief Get the current mtu of this connection.
@@ -892,7 +891,7 @@ int NimBLEClient::exchangeMTUCb(uint16_t conn_handle, const ble_gatt_error* erro
     }
 
     return 0;
-} // exchangeMTUCb
+}
 
 /**
  * @brief Begin the MTU exchange process with the server.
@@ -919,7 +918,7 @@ int NimBLEClient::handleGapEvent(struct ble_gap_event* event, void* arg) {
     int             rc        = 0;
     NimBLETaskData* pTaskData = pClient->m_pTaskData; // save a copy in case client is deleted
 
-    NIMBLE_LOGD(LOG_TAG, ">> handleGapEvent %s", NimBLEUtils::gapEventToString(event->type));
+    NIMBLE_LOGD(LOG_TAG, "Got Client event %s", NimBLEUtils::gapEventToString(event->type));
 
     switch (event->type) {
         case BLE_GAP_EVENT_DISCONNECT: {
@@ -947,7 +946,7 @@ int NimBLEClient::handleGapEvent(struct ble_gap_event* event, void* arg) {
             NIMBLE_LOGD(LOG_TAG, "disconnect; reason=%d, %s", rc, NimBLEUtils::returnCodeToString(rc));
 
             pClient->m_terminateFailCount = 0;
-            pClient->m_asyncSecureAttempt = 0;
+            NimBLEDevice::removeIgnored(pClient->m_peerAddress);
 
             // 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) {
@@ -980,31 +979,35 @@ int NimBLEClient::handleGapEvent(struct ble_gap_event* event, void* arg) {
             rc = event->connect.status;
             if (rc == 0) {
                 pClient->m_connHandle = event->connect.conn_handle;
-
-                if (pClient->m_config.asyncConnect) {
-                    pClient->m_pClientCallbacks->onConnect(pClient);
-                }
-
                 if (pClient->m_config.exchangeMTU) {
-                    if (!pClient->exchangeMTU()) {
+                    if (!pClient->exchangeMTU() && !pClient->m_config.asyncConnect) {
                         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.
                 }
+
+                // In the case of a multi-connecting device we ignore this device when
+                // scanning since we are already connected to it
+                NimBLEDevice::addIgnored(pClient->m_peerAddress);
             } else {
                 pClient->m_connHandle = BLE_HS_CONN_HANDLE_NONE;
+                if (!pClient->m_config.asyncConnect) {
+                    break;
+                }
 
-                if (pClient->m_config.asyncConnect) {
-                    pClient->m_pClientCallbacks->onConnectFail(pClient, rc);
-                    if (pClient->m_config.deleteOnConnectFail) {
-                        NimBLEDevice::deleteClient(pClient);
-                    }
+                if (pClient->m_config.deleteOnConnectFail) { // async connect
+                    delete pClient;
+                    return 0;
                 }
             }
 
-            break;
+            if (pClient->m_config.asyncConnect) {
+                pClient->m_pClientCallbacks->onConnect(pClient);
+            } else if (!pClient->m_config.exchangeMTU) {
+                break; // not waiting for MTU exchange so release the task now.
+            }
+
+            return 0;
         } // BLE_GAP_EVENT_CONNECT
 
         case BLE_GAP_EVENT_TERM_FAILURE: {
@@ -1111,12 +1114,7 @@ int NimBLEClient::handleGapEvent(struct ble_gap_event* event, void* arg) {
                 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.
-                    if (pClient->m_asyncSecureAttempt == 1) {
-                        pClient->secureConnection(true);
-                    }
                 } else {
-                    pClient->m_asyncSecureAttempt = 0;
                     pClient->m_pClientCallbacks->onAuthenticationComplete(peerInfo);
                 }
             }
@@ -1137,19 +1135,6 @@ int NimBLEClient::handleGapEvent(struct ble_gap_event* event, void* arg) {
             break;
         } // BLE_GAP_EVENT_IDENTITY_RESOLVED
 
-# if CONFIG_BT_NIMBLE_EXT_ADV
-        case BLE_GAP_EVENT_PHY_UPDATE_COMPLETE: {
-            NimBLEConnInfo peerInfo;
-            rc = ble_gap_conn_find(event->phy_updated.conn_handle, &peerInfo.m_desc);
-            if (rc != 0) {
-                return BLE_ATT_ERR_INVALID_HANDLE;
-            }
-
-            pClient->m_pClientCallbacks->onPhyUpdate(pClient, event->phy_updated.tx_phy, event->phy_updated.rx_phy);
-            return 0;
-        } // BLE_GAP_EVENT_PHY_UPDATE_COMPLETE
-# endif
-
         case BLE_GAP_EVENT_MTU: {
             if (pClient->m_connHandle != event->mtu.conn_handle) {
                 return 0;
@@ -1203,7 +1188,6 @@ int NimBLEClient::handleGapEvent(struct ble_gap_event* event, void* arg) {
         NimBLEUtils::taskRelease(*pTaskData, rc);
     }
 
-    NIMBLE_LOGD(LOG_TAG, "<< handleGapEvent");
     return 0;
 } // handleGapEvent
 
@@ -1246,31 +1230,26 @@ std::string NimBLEClient::toString() const {
 } // toString
 
 static const char* CB_TAG = "NimBLEClientCallbacks";
-
 /**
  * @brief Get the last error code reported by the NimBLE host
  * @return int, the NimBLE error code.
  */
-int NimBLEClient::getLastError() const {
+int                NimBLEClient::getLastError() const {
     return m_lastErr;
 } // getLastError
 
 void NimBLEClientCallbacks::onConnect(NimBLEClient* pClient) {
     NIMBLE_LOGD(CB_TAG, "onConnect: default");
-} // onConnect
-
-void NimBLEClientCallbacks::onConnectFail(NimBLEClient* pClient, int reason) {
-    NIMBLE_LOGD(CB_TAG, "onConnectFail: default, reason: %d", reason);
-} // onConnectFail
+}
 
 void NimBLEClientCallbacks::onDisconnect(NimBLEClient* pClient, int reason) {
-    NIMBLE_LOGD(CB_TAG, "onDisconnect: default, reason: %d", reason);
-} // onDisconnect
+    NIMBLE_LOGD(CB_TAG, "onDisconnect: default");
+}
 
 bool NimBLEClientCallbacks::onConnParamsUpdateRequest(NimBLEClient* pClient, const ble_gap_upd_params* params) {
     NIMBLE_LOGD(CB_TAG, "onConnParamsUpdateRequest: default");
     return true;
-} // onConnParamsUpdateRequest
+}
 
 void NimBLEClientCallbacks::onPassKeyEntry(NimBLEConnInfo& connInfo) {
     NIMBLE_LOGD(CB_TAG, "onPassKeyEntry: default: 123456");
@@ -1279,7 +1258,7 @@ void NimBLEClientCallbacks::onPassKeyEntry(NimBLEConnInfo& connInfo) {
 
 void NimBLEClientCallbacks::onAuthenticationComplete(NimBLEConnInfo& connInfo) {
     NIMBLE_LOGD(CB_TAG, "onAuthenticationComplete: default");
-} // onAuthenticationComplete
+}
 
 void NimBLEClientCallbacks::onIdentity(NimBLEConnInfo& connInfo) {
     NIMBLE_LOGD(CB_TAG, "onIdentity: default");
@@ -1288,16 +1267,10 @@ void NimBLEClientCallbacks::onIdentity(NimBLEConnInfo& connInfo) {
 void NimBLEClientCallbacks::onConfirmPasskey(NimBLEConnInfo& connInfo, uint32_t pin) {
     NIMBLE_LOGD(CB_TAG, "onConfirmPasskey: default: true");
     NimBLEDevice::injectConfirmPasskey(connInfo, true);
-} // onConfirmPasskey
+}
 
 void NimBLEClientCallbacks::onMTUChange(NimBLEClient* pClient, uint16_t mtu) {
     NIMBLE_LOGD(CB_TAG, "onMTUChange: default");
-} // onMTUChange
-
-# if CONFIG_BT_NIMBLE_EXT_ADV
-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
+}
 
 #endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_CENTRAL */

src/NimBLEClient.h

@@ -44,10 +44,10 @@ struct NimBLETaskData;
  */
 class NimBLEClient {
   public:
-    bool connect(const NimBLEAdvertisedDevice* device,
-                 bool                          deleteAttributes = true,
-                 bool                          asyncConnect     = false,
-                 bool                          exchangeMTU      = true);
+    bool connect(NimBLEAdvertisedDevice* device,
+                 bool                    deleteAttributes = true,
+                 bool                    asyncConnect     = false,
+                 bool                    exchangeMTU      = true);
     bool connect(const NimBLEAddress& address, bool deleteAttributes = true, bool asyncConnect = false, bool exchangeMTU = true);
     bool           connect(bool deleteAttributes = true, bool asyncConnect = false, bool exchangeMTU = true);
     bool           disconnect(uint8_t reason = BLE_ERR_REM_USER_CONN_TERM);
@@ -60,9 +60,12 @@ class NimBLEClient {
     void           setClientCallbacks(NimBLEClientCallbacks* pClientCallbacks, bool deleteCallbacks = true);
     std::string    toString() const;
     uint16_t       getConnHandle() const;
+    void           clearConnection();
+    bool           setConnection(const NimBLEConnInfo& connInfo);
+    bool           setConnection(uint16_t connHandle);
     uint16_t       getMTU() const;
     bool           exchangeMTU();
-    bool           secureConnection(bool async = false) const;
+    bool           secureConnection() const;
     void           setConnectTimeout(uint32_t timeout);
     bool           setDataLen(uint16_t txOctets);
     bool           discoverAttributes();
@@ -90,9 +93,7 @@ class NimBLEClient {
                             bool                  response = false);
 
 # if CONFIG_BT_NIMBLE_EXT_ADV
-    void setConnectPhy(uint8_t phyMask);
-    bool updatePhy(uint8_t txPhysMask, uint8_t rxPhysMask, uint16_t phyOptions = 0);
-    bool getPhy(uint8_t* txPhy, uint8_t* rxPhy);
+    void setConnectPhy(uint8_t mask);
 # endif
 
     struct Config {
@@ -128,7 +129,6 @@ class NimBLEClient {
     NimBLEClientCallbacks*            m_pClientCallbacks;
     uint16_t                          m_connHandle;
     uint8_t                           m_terminateFailCount;
-    mutable uint8_t                   m_asyncSecureAttempt;
     Config                            m_config;
 
 # if CONFIG_BT_NIMBLE_EXT_ADV
@@ -137,7 +137,6 @@ class NimBLEClient {
     ble_gap_conn_params m_connParams;
 
     friend class NimBLEDevice;
-    friend class NimBLEServer;
 }; // class NimBLEClient
 
 /**
@@ -149,17 +148,10 @@ class NimBLEClientCallbacks {
 
     /**
      * @brief Called after client connects.
-     * @param [in] pClient A pointer to the connecting client object.
+     * @param [in] pClient A pointer to the calling client object.
      */
     virtual void onConnect(NimBLEClient* pClient);
 
-    /**
-     * @brief Called when a connection attempt fails.
-     * @param [in] pClient A pointer to the connecting client object.
-     * @param [in] reason Contains the reason code for the connection failure.
-     */
-    virtual void onConnectFail(NimBLEClient* pClient, int reason);
-
     /**
      * @brief Called when disconnected from the server.
      * @param [in] pClient A pointer to the calling client object.
@@ -208,21 +200,6 @@ class NimBLEClientCallbacks {
      * about the peer connection parameters.
      */
     virtual void onMTUChange(NimBLEClient* pClient, uint16_t MTU);
-
-# if CONFIG_BT_NIMBLE_EXT_ADV
-    /**
-     * @brief Called when the PHY update procedure is complete.
-     * @param [in] pClient A pointer to the client whose PHY was updated.
-     * about the peer connection parameters.
-     * @param [in] txPhy The transmit PHY.
-     * @param [in] rxPhy The receive PHY.
-     * Possible values:
-     * * BLE_GAP_LE_PHY_1M
-     * * BLE_GAP_LE_PHY_2M
-     * * BLE_GAP_LE_PHY_CODED
-     */
-    virtual void onPhyUpdate(NimBLEClient* pClient, uint8_t txPhy, uint8_t rxPhy);
-# endif
 };
 
 #endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_CENTRAL */

src/NimBLEDescriptor.h

@@ -34,11 +34,11 @@ class NimBLEDescriptorCallbacks;
  */
 class NimBLEDescriptor : public NimBLELocalValueAttribute {
   public:
-    NimBLEDescriptor(const char* uuid, uint16_t properties, uint16_t maxLen, NimBLECharacteristic* pCharacteristic = nullptr);
+    NimBLEDescriptor(const char* uuid, uint16_t properties, uint16_t max_len, NimBLECharacteristic* pCharacteristic = nullptr);
 
     NimBLEDescriptor(const NimBLEUUID&     uuid,
                      uint16_t              properties,
-                     uint16_t              maxLen,
+                     uint16_t              max_len,
                      NimBLECharacteristic* pCharacteristic = nullptr);
     ~NimBLEDescriptor() = default;
 

src/NimBLEDevice.cpp

@@ -39,12 +39,7 @@
 #   include "nimble/esp_port/esp-hci/include/esp_nimble_hci.h"
 #  endif
 # else
-//#  include "nimble/nimble/controller/include/controller/ble_phy.h"
-#    include "controller/ble_phy.h"
-#    include "host/ble_hs.h"
-#    include "host/util/util.h"
-#    include "services/gap/ble_svc_gap.h"
-#    include "services/gatt/ble_svc_gatt.h"
+#  include "nimble/nimble/controller/include/controller/ble_phy.h"
 # endif
 
 # ifndef CONFIG_NIMBLE_CPP_IDF
@@ -102,6 +97,7 @@ bool                       NimBLEDevice::m_initialized{false};
 uint32_t                   NimBLEDevice::m_passkey{123456};
 bool                       NimBLEDevice::m_synced{false};
 ble_gap_event_listener     NimBLEDevice::m_listener{};
+std::vector<NimBLEAddress> NimBLEDevice::m_ignoreList{};
 std::vector<NimBLEAddress> NimBLEDevice::m_whiteList{};
 uint8_t                    NimBLEDevice::m_ownAddrType{BLE_OWN_ADDR_PUBLIC};
 
@@ -426,58 +422,47 @@ std::vector<NimBLEClient*> NimBLEDevice::getConnectedClients() {
 /*                               TRANSMIT POWER                               */
 /* -------------------------------------------------------------------------- */
 
-# ifdef ESP_PLATFORM
-#  ifndef CONFIG_IDF_TARGET_ESP32P4
-/**
- * @brief Get the transmission power.
- * @return The power level currently used in esp_power_level_t or a negative value on error.
- */
-esp_power_level_t NimBLEDevice::getPowerLevel(esp_ble_power_type_t powerType) {
-    esp_power_level_t pwr = esp_ble_tx_power_get(powerType);
-
-#   if defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S3)
-    // workaround for bug when "enhanced tx power" was added
-    if (pwr == 0xFF) {
-        pwr = esp_ble_tx_power_get(ESP_BLE_PWR_TYPE_CONN_HDL3);
-    }
-#   endif
-
-    return pwr;
-} // getPowerLevel
-
-/**
- * @brief Set the transmission power.
- * @param [in] powerLevel The power level to set in esp_power_level_t.
- * @return True if the power level was set successfully.
- */
-bool NimBLEDevice::setPowerLevel(esp_power_level_t powerLevel, esp_ble_power_type_t powerType) {
-    esp_err_t errRc = esp_ble_tx_power_set(powerType, powerLevel);
-    if (errRc != ESP_OK) {
-        NIMBLE_LOGE(LOG_TAG, "esp_ble_tx_power_set: rc=%d", errRc);
-    }
-
-    return errRc == ESP_OK;
-} // setPowerLevel
-#  endif // !CONFIG_IDF_TARGET_ESP32P4
-# endif  // ESP_PLATFORM
-
 /**
  * @brief Set the transmission power.
  * @param [in] dbm The power level to set in dBm.
  * @return True if the power level was set successfully.
  */
 bool NimBLEDevice::setPower(int8_t dbm) {
-# ifdef ESP_PLATFORM
-#  ifdef CONFIG_IDF_TARGET_ESP32P4
-    return false; // CONFIG_IDF_TARGET_ESP32P4 does not support esp_ble_tx_power_set
-#  else
-    if (dbm % 3 == 2) {
-        dbm++; // round up to the next multiple of 3 to be able to target 20dbm
-    }
-    return setPowerLevel(static_cast<esp_power_level_t>(dbm / 3 + ESP_PWR_LVL_N0));
-#  endif
-# else
     NIMBLE_LOGD(LOG_TAG, ">> setPower: %d", dbm);
+# ifdef ESP_PLATFORM
+#  ifndef CONFIG_IDF_TARGET_ESP32P4
+    if (dbm >= 9) {
+        dbm = ESP_PWR_LVL_P9;
+    } else if (dbm >= 6) {
+        dbm = ESP_PWR_LVL_P6;
+    } else if (dbm >= 3) {
+        dbm = ESP_PWR_LVL_P3;
+    } else if (dbm >= 0) {
+        dbm = ESP_PWR_LVL_N0;
+    } else if (dbm >= -3) {
+        dbm = ESP_PWR_LVL_N3;
+    } else if (dbm >= -6) {
+        dbm = ESP_PWR_LVL_N6;
+    } else if (dbm >= -9) {
+        dbm = ESP_PWR_LVL_N9;
+    } else if (dbm >= -12) {
+        dbm = ESP_PWR_LVL_N12;
+    } else {
+        NIMBLE_LOGE(LOG_TAG, "Unsupported power level");
+        return false;
+    }
+
+    esp_err_t errRc = esp_ble_tx_power_set(ESP_BLE_PWR_TYPE_DEFAULT, (esp_power_level_t)dbm);
+    if (errRc != ESP_OK) {
+        NIMBLE_LOGE(LOG_TAG, "esp_ble_tx_power_set: rc=%d", errRc);
+    }
+
+    return errRc == ESP_OK;
+#  else
+    return 0xFF; // CONFIG_IDF_TARGET_ESP32P4
+#  endif
+
+# else
     ble_hci_vs_set_tx_pwr_cp cmd{dbm};
     ble_hci_vs_set_tx_pwr_rp rsp{0};
     int rc = ble_hs_hci_send_vs_cmd(BLE_HCI_OCF_VS_SET_TX_PWR, &cmd, sizeof(cmd), &rsp, sizeof(rsp));
@@ -493,31 +478,37 @@ bool NimBLEDevice::setPower(int8_t dbm) {
 
 /**
  * @brief Get the transmission power.
- * @return The power level currently used in dbm or 0xFF on error.
+ * @return The power level currently used in dbm.
  */
 int NimBLEDevice::getPower() {
 # ifdef ESP_PLATFORM
-#  ifdef CONFIG_IDF_TARGET_ESP32P4
-    return 0xFF; // CONFIG_IDF_TARGET_ESP32P4 does not support esp_ble_tx_power_get
+#  ifndef CONFIG_IDF_TARGET_ESP32P4
+    switch (esp_ble_tx_power_get(ESP_BLE_PWR_TYPE_DEFAULT)) {
+        case ESP_PWR_LVL_N12:
+            return -12;
+        case ESP_PWR_LVL_N9:
+            return -9;
+        case ESP_PWR_LVL_N6:
+            return -6;
+        case ESP_PWR_LVL_N3:
+            return -3;
+        case ESP_PWR_LVL_N0:
+            return 0;
+        case ESP_PWR_LVL_P3:
+            return 3;
+        case ESP_PWR_LVL_P6:
+            return 6;
+        case ESP_PWR_LVL_P9:
+            return 9;
+        default:
+            return 0xFF;
+    }
 #  else
-    int pwr = getPowerLevel();
-    if (pwr < 0) {
-        NIMBLE_LOGE(LOG_TAG, "esp_ble_tx_power_get failed rc=%d", pwr);
-        return 0xFF;
-    }
-
-    if (pwr < ESP_PWR_LVL_N0) {
-        return -3 * (ESP_PWR_LVL_N0 - pwr);
-    }
-
-    if (pwr > ESP_PWR_LVL_N0) {
-        return std::min<int>((pwr - ESP_PWR_LVL_N0) * 3, 20);
-    }
-
-    return 0;
+    return 0xFF; // CONFIG_IDF_TARGET_ESP32P4 does not support esp_ble_tx_power_get
 #  endif
+
 # else
-    return ble_phy_tx_power_get(); //ble_phy_txpwr_get();
+    return ble_phy_txpwr_get();
 # endif
 } // getPower
 
@@ -721,31 +712,6 @@ NimBLEAddress NimBLEDevice::getWhiteListAddress(size_t index) {
 /*                               STACK FUNCTIONS                              */
 /* -------------------------------------------------------------------------- */
 
-# if CONFIG_BT_NIMBLE_EXT_ADV || defined(_DOXYGEN_)
-/**
- * @brief Set the preferred default phy to use for connections.
- * @param [in] txPhyMask TX PHY. Can be mask of following:
- * - BLE_GAP_LE_PHY_1M_MASK
- * - BLE_GAP_LE_PHY_2M_MASK
- * - BLE_GAP_LE_PHY_CODED_MASK
- * - BLE_GAP_LE_PHY_ANY_MASK
- * @param [in] rxPhyMask RX PHY. Can be mask of following:
- * - BLE_GAP_LE_PHY_1M_MASK
- * - BLE_GAP_LE_PHY_2M_MASK
- * - BLE_GAP_LE_PHY_CODED_MASK
- * - BLE_GAP_LE_PHY_ANY_MASK
- * @return True if successful.
- */
-bool NimBLEDevice::setDefaultPhy(uint8_t txPhyMask, uint8_t rxPhyMask) {
-    int rc = ble_gap_set_prefered_default_le_phy(txPhyMask, rxPhyMask);
-    if (rc != 0) {
-        NIMBLE_LOGE(LOG_TAG, "Failed to set default phy; rc=%d %s", rc, NimBLEUtils::returnCodeToString(rc));
-    }
-
-    return rc == 0;
-}
-# endif
-
 /**
  * @brief Host reset, we pass the message so we don't make calls until re-synced.
  * @param [in] reason The reason code for the reset.
@@ -814,19 +780,10 @@ void NimBLEDevice::onSync(void) {
  */
 void NimBLEDevice::host_task(void* param) {
     NIMBLE_LOGI(LOG_TAG, "BLE Host Task Started");
-#ifndef MYNEWT
     nimble_port_run(); // This function will return only when nimble_port_stop() is executed
     nimble_port_freertos_deinit();
-#else
-    while (1) {
-        os_eventq_run(os_eventq_dflt_get());
-    }
-#endif
 } // host_task
 
-static struct os_task ble_nimble_task;
-static os_stack_t ble_nimble_stack[1024];
-
 /**
  * @brief Initialize the BLE environment.
  * @param [in] deviceName The device name of the device.
@@ -889,10 +846,8 @@ bool NimBLEDevice::init(const std::string& deviceName) {
         }
 #  endif
 # endif
-
-#ifndef MYNEWT
         nimble_port_init();
-#endif
+
         // Setup callbacks for host events
         ble_hs_cfg.reset_cb = NimBLEDevice::onReset;
         ble_hs_cfg.sync_cb  = NimBLEDevice::onSync;
@@ -907,13 +862,8 @@ bool NimBLEDevice::init(const std::string& deviceName) {
         ble_hs_cfg.store_status_cb   = ble_store_util_status_rr; /*TODO: Implement handler for this*/
 
         setDeviceName(deviceName);
-#ifndef MYNEWT
         ble_store_config_init();
         nimble_port_freertos_init(NimBLEDevice::host_task);
-#else
-        os_task_init(&ble_nimble_task, "ble_nimble_task", NimBLEDevice::host_task, NULL, 8,
-                     OS_WAIT_FOREVER, ble_nimble_stack, 1024);
-#endif
     }
 
     // Wait for host and controller to sync before returning and accepting new tasks
@@ -935,7 +885,6 @@ bool NimBLEDevice::init(const std::string& deviceName) {
 bool NimBLEDevice::deinit(bool clearAll) {
     int rc = 0;
     if (m_initialized) {
-#ifndef MYNEWT
         rc = nimble_port_stop();
         if (rc == 0) {
             nimble_port_deinit();
@@ -947,10 +896,6 @@ bool NimBLEDevice::deinit(bool clearAll) {
             }
 #  endif
 # endif
-#else
-        rc = ble_hs_shutdown(0);
-        if (rc == 0) {
-#endif
             m_initialized = false;
             m_synced      = false;
         }
@@ -983,6 +928,7 @@ bool NimBLEDevice::deinit(bool clearAll) {
             deleteClient(clt);
         }
 # endif
+        m_ignoreList.clear();
     }
 
     return rc == 0;
@@ -1167,17 +1113,14 @@ uint32_t NimBLEDevice::getSecurityPasskey() {
 /**
  * @brief Start the connection securing and authorization for this connection.
  * @param connHandle The connection handle of the peer device.
- * @param rcPtr Optional pointer to pass the return code to the caller.
- * @returns True if successfully started, success = 0 or BLE_HS_EALREADY.
+ * @returns NimBLE stack return code, 0 = success.
  */
-bool NimBLEDevice::startSecurity(uint16_t connHandle, int* rcPtr) {
+bool NimBLEDevice::startSecurity(uint16_t connHandle) {
     int rc = ble_gap_security_initiate(connHandle);
     if (rc != 0) {
         NIMBLE_LOGE(LOG_TAG, "ble_gap_security_initiate: rc=%d %s", rc, NimBLEUtils::returnCodeToString(rc));
     }
-    if (rcPtr) {
-        *rcPtr = rc;
-    }
+
     return rc == 0 || rc == BLE_HS_EALREADY;
 } // startSecurity
 
@@ -1206,6 +1149,48 @@ bool NimBLEDevice::injectConfirmPasskey(const NimBLEConnInfo& peerInfo, bool acc
     return rc == 0;
 }
 
+/* -------------------------------------------------------------------------- */
+/*                                 IGNORE LIST                                */
+/* -------------------------------------------------------------------------- */
+
+/**
+ * @brief Check if the device address is on our ignore list.
+ * @param [in] address The address to look for.
+ * @return True if ignoring.
+ */
+bool NimBLEDevice::isIgnored(const NimBLEAddress& address) {
+    for (const auto& addr : m_ignoreList) {
+        if (addr == address) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+/**
+ * @brief Add a device to the ignore list.
+ * @param [in] address The address of the device we want to ignore.
+ */
+void NimBLEDevice::addIgnored(const NimBLEAddress& address) {
+    if (!isIgnored(address)) {
+        m_ignoreList.push_back(address);
+    }
+}
+
+/**
+ * @brief Remove a device from the ignore list.
+ * @param [in] address The address of the device we want to remove from the list.
+ */
+void NimBLEDevice::removeIgnored(const NimBLEAddress& address) {
+    for (auto it = m_ignoreList.begin(); it < m_ignoreList.end(); ++it) {
+        if (*it == address) {
+            m_ignoreList.erase(it);
+            std::vector<NimBLEAddress>(m_ignoreList).swap(m_ignoreList);
+        }
+    }
+}
+
 /* -------------------------------------------------------------------------- */
 /*                                  UTILITIES                                 */
 /* -------------------------------------------------------------------------- */

src/NimBLEDevice.h

@@ -18,9 +18,7 @@
 #include "nimconfig.h"
 #if defined(CONFIG_BT_ENABLED)
 # ifdef ESP_PLATFORM
-#  ifndef CONFIG_IDF_TARGET_ESP32P4
-#   include <esp_bt.h>
-#  endif
+#  include <esp_bt.h>
 # endif
 
 # if defined(CONFIG_NIMBLE_CPP_IDF)
@@ -116,6 +114,8 @@ class NimBLEDevice {
     static bool          onWhiteList(const NimBLEAddress& address);
     static size_t        getWhiteListCount();
     static NimBLEAddress getWhiteListAddress(size_t index);
+    static bool          setPower(int8_t dbm);
+    static int           getPower();
     static bool          setOwnAddrType(uint8_t type);
     static bool          setOwnAddr(const NimBLEAddress& addr);
     static bool          setOwnAddr(const uint8_t* addr);
@@ -129,25 +129,15 @@ class NimBLEDevice {
     static void          setSecurityRespKey(uint8_t respKey);
     static void          setSecurityPasskey(uint32_t passKey);
     static uint32_t      getSecurityPasskey();
-    static bool          startSecurity(uint16_t connHandle, int* rcPtr = nullptr);
+    static bool          startSecurity(uint16_t connHandle);
     static bool          setMTU(uint16_t mtu);
     static uint16_t      getMTU();
+    static bool          isIgnored(const NimBLEAddress& address);
+    static void          addIgnored(const NimBLEAddress& address);
+    static void          removeIgnored(const NimBLEAddress& address);
     static void          onReset(int reason);
     static void          onSync(void);
     static void          host_task(void* param);
-    static int           getPower();
-    static bool          setPower(int8_t dbm);
-
-# ifdef ESP_PLATFORM
-#  ifndef CONFIG_IDF_TARGET_ESP32P4
-    static esp_power_level_t getPowerLevel(esp_ble_power_type_t powerType = ESP_BLE_PWR_TYPE_DEFAULT);
-    static bool setPowerLevel(esp_power_level_t powerLevel, esp_ble_power_type_t powerType = ESP_BLE_PWR_TYPE_DEFAULT);
-#  endif
-# endif
-
-# if CONFIG_BT_NIMBLE_EXT_ADV
-    static bool setDefaultPhy(uint8_t txPhyMask, uint8_t rxPhyMask);
-# endif
 
 # if defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
     static NimBLEScan* getScan();
@@ -199,6 +189,7 @@ class NimBLEDevice {
   private:
     static bool                       m_synced;
     static bool                       m_initialized;
+    static std::vector<NimBLEAddress> m_ignoreList;
     static uint32_t                   m_passkey;
     static ble_gap_event_listener     m_listener;
     static uint8_t                    m_ownAddrType;

src/NimBLEEddystoneTLM.cpp

@@ -13,26 +13,42 @@
  */
 
 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER)
+#if defined(CONFIG_BT_ENABLED)
 
-# include "NimBLEEddystoneTLM.h"
-# include "NimBLEUUID.h"
-# include "NimBLELog.h"
+#include "NimBLEEddystoneTLM.h"
+#include "NimBLELog.h"
 
-# define ENDIAN_CHANGE_U16(x) ((((x) & 0xFF00) >> 8) + (((x) & 0xFF) << 8))
-# define ENDIAN_CHANGE_U32(x) \
-     ((((x) & 0xFF000000) >> 24) + (((x) & 0x00FF0000) >> 8)) + ((((x) & 0xFF00) << 8) + (((x) & 0xFF) << 24))
+#include <stdio.h>
+#include <cstring>
+
+#define ENDIAN_CHANGE_U16(x) ((((x)&0xFF00)>>8) + (((x)&0xFF)<<8))
+#define ENDIAN_CHANGE_U32(x) ((((x)&0xFF000000)>>24) + (((x)&0x00FF0000)>>8)) + ((((x)&0xFF00)<<8) + (((x)&0xFF)<<24))
+
+static const char LOG_TAG[] = "NimBLEEddystoneTLM";
+
+/**
+ * @brief Construct a default EddystoneTLM beacon object.
+ */
+NimBLEEddystoneTLM::NimBLEEddystoneTLM() {
+    beaconUUID = 0xFEAA;
+    m_eddystoneData.frameType = EDDYSTONE_TLM_FRAME_TYPE;
+    m_eddystoneData.version = 0;
+    m_eddystoneData.volt = 3300; // 3300mV = 3.3V
+    m_eddystoneData.temp = (uint16_t) ((float) 23.00 * 256); // 8.8 fixed format
+    m_eddystoneData.advCount = 0;
+    m_eddystoneData.tmil = 0;
+} // NimBLEEddystoneTLM
 
-static const char* LOG_TAG = "NimBLEEddystoneTLM";
 
 /**
  * @brief Retrieve the data that is being advertised.
  * @return The advertised data.
  */
-const NimBLEEddystoneTLM::BeaconData NimBLEEddystoneTLM::getData() {
-    return m_eddystoneData;
+std::string NimBLEEddystoneTLM::getData() {
+    return std::string((char*) &m_eddystoneData, sizeof(m_eddystoneData));
 } // getData
 
+
 /**
  * @brief Get the UUID being advertised.
  * @return The UUID advertised.
@@ -41,6 +57,7 @@ NimBLEUUID NimBLEEddystoneTLM::getUUID() {
     return NimBLEUUID(beaconUUID);
 } // getUUID
 
+
 /**
  * @brief Get the version being advertised.
  * @return The version number.
@@ -49,6 +66,7 @@ uint8_t NimBLEEddystoneTLM::getVersion() {
     return m_eddystoneData.version;
 } // getVersion
 
+
 /**
  * @brief Get the battery voltage.
  * @return The battery voltage.
@@ -57,12 +75,13 @@ uint16_t NimBLEEddystoneTLM::getVolt() {
     return ENDIAN_CHANGE_U16(m_eddystoneData.volt);
 } // getVolt
 
+
 /**
  * @brief Get the temperature being advertised.
  * @return The temperature value.
  */
-int16_t NimBLEEddystoneTLM::getTemp() {
-    return ENDIAN_CHANGE_U16(m_eddystoneData.temp);
+float NimBLEEddystoneTLM::getTemp() {
+    return (int16_t)ENDIAN_CHANGE_U16(m_eddystoneData.temp) / 256.0f;
 } // getTemp
 
 /**
@@ -73,6 +92,7 @@ uint32_t NimBLEEddystoneTLM::getCount() {
     return ENDIAN_CHANGE_U32(m_eddystoneData.advCount);
 } // getCount
 
+
 /**
  * @brief Get the advertisement time.
  * @return The advertisement time.
@@ -81,98 +101,89 @@ uint32_t NimBLEEddystoneTLM::getTime() {
     return (ENDIAN_CHANGE_U32(m_eddystoneData.tmil)) / 10;
 } // getTime
 
+
 /**
  * @brief Get a string representation of the beacon.
  * @return The string representation.
  */
 std::string NimBLEEddystoneTLM::toString() {
-    std::string out    = "";
-    uint32_t    rawsec = ENDIAN_CHANGE_U32(m_eddystoneData.tmil);
-    char        val[12];
+  std::string out = "";
+  uint32_t rawsec = ENDIAN_CHANGE_U32(m_eddystoneData.tmil);
+  char val[12];
 
-    out += "Version ";
-    snprintf(val, sizeof(val), "%d", m_eddystoneData.version);
-    out += val;
-    out += "\n";
-    out += "Battery Voltage ";
-    snprintf(val, sizeof(val), "%d", ENDIAN_CHANGE_U16(m_eddystoneData.volt));
-    out += val;
-    out += " mV\n";
+  out += "Version "; // + std::string(m_eddystoneData.version);
+  snprintf(val, sizeof(val), "%d", m_eddystoneData.version);
+  out += val;
+  out += "\n";
+  out += "Battery Voltage "; // + ENDIAN_CHANGE_U16(m_eddystoneData.volt);
+  snprintf(val, sizeof(val), "%d", ENDIAN_CHANGE_U16(m_eddystoneData.volt));
+  out += val;
+  out += " mV\n";
 
-    out             += "Temperature ";
-    uint8_t intTemp  = m_eddystoneData.temp / 256;
-    uint8_t frac     = m_eddystoneData.temp % 256 * 100 / 256;
-    snprintf(val, sizeof(val), "%d.%d", intTemp, frac);
-    out += val;
-    out += " C\n";
+  out += "Temperature ";
+  snprintf(val, sizeof(val), "%.2f", ENDIAN_CHANGE_U16(m_eddystoneData.temp) / 256.0f);
+  out += val;
+  out += " C\n";
 
-    out += "Adv. Count ";
-    snprintf(val, sizeof(val), "%" PRIu32, ENDIAN_CHANGE_U32(m_eddystoneData.advCount));
-    out += val;
-    out += "\n";
+  out += "Adv. Count ";
+  snprintf(val, sizeof(val), "%" PRIu32, ENDIAN_CHANGE_U32(m_eddystoneData.advCount));
+  out += val;
+  out += "\n";
 
-    out += "Time in seconds ";
-    snprintf(val, sizeof(val), "%" PRIu32, rawsec / 10);
-    out += val;
-    out += "\n";
+  out += "Time in seconds ";
+  snprintf(val, sizeof(val), "%" PRIu32, rawsec/10);
+  out += val;
+  out += "\n";
 
-    out += "Time ";
+  out += "Time ";
 
-    snprintf(val, sizeof(val), "%04" PRIu32, rawsec / 864000);
-    out += val;
-    out += ".";
+  snprintf(val, sizeof(val), "%04" PRIu32, rawsec / 864000);
+  out += val;
+  out += ".";
 
-    snprintf(val, sizeof(val), "%02" PRIu32, (rawsec / 36000) % 24);
-    out += val;
-    out += ":";
+  snprintf(val, sizeof(val), "%02" PRIu32, (rawsec / 36000) % 24);
+  out += val;
+  out += ":";
 
-    snprintf(val, sizeof(val), "%02" PRIu32, (rawsec / 600) % 60);
-    out += val;
-    out += ":";
+  snprintf(val, sizeof(val), "%02" PRIu32, (rawsec / 600) % 60);
+  out += val;
+  out += ":";
 
-    snprintf(val, sizeof(val), "%02" PRIu32, (rawsec / 10) % 60);
-    out += val;
-    out += "\n";
+  snprintf(val, sizeof(val), "%02" PRIu32, (rawsec / 10) % 60);
+  out += val;
+  out += "\n";
 
-    return out;
+  return out;
 } // toString
 
-/**
- * @brief Set the raw data for the beacon advertisement.
- * @param [in] data A pointer to the data to advertise.
- * @param [in] length The length of the data.
- */
-void NimBLEEddystoneTLM::setData(const uint8_t* data, uint8_t length) {
-    if (length != sizeof(m_eddystoneData)) {
-        NIMBLE_LOGE(LOG_TAG,
-                    "Unable to set the data ... length passed in was %d and expected %d",
-                    length,
-                    sizeof(m_eddystoneData));
-        return;
-    }
-    memcpy(&m_eddystoneData, data, length);
-} // setData
 
 /**
  * @brief Set the raw data for the beacon advertisement.
  * @param [in] data The raw data to advertise.
  */
-void NimBLEEddystoneTLM::setData(const NimBLEEddystoneTLM::BeaconData& data) {
-    m_eddystoneData = data;
+void NimBLEEddystoneTLM::setData(const std::string &data) {
+    if (data.length() != sizeof(m_eddystoneData)) {
+        NIMBLE_LOGE(LOG_TAG, "Unable to set the data ... length passed in was %d and expected %d",
+                                                data.length(), sizeof(m_eddystoneData));
+        return;
+    }
+  memcpy(&m_eddystoneData, data.data(), data.length());
 } // setData
 
+
 /**
  * @brief Set the UUID to advertise.
- * @param [in] uuid The UUID.
+ * @param [in] l_uuid The UUID.
  */
-void NimBLEEddystoneTLM::setUUID(const NimBLEUUID& uuid) {
-    if (uuid.bitSize() != 16) {
+void NimBLEEddystoneTLM::setUUID(const NimBLEUUID &l_uuid) {
+    if (l_uuid.bitSize() != 16) {
         NIMBLE_LOGE(LOG_TAG, "UUID must be 16 bits");
         return;
     }
-    beaconUUID = *reinterpret_cast<const uint16_t*>(uuid.getValue());
+    beaconUUID = *reinterpret_cast<const uint16_t*>(l_uuid.getValue());
 } // setUUID
 
+
 /**
  * @brief Set the version to advertise.
  * @param [in] version The version number.
@@ -181,6 +192,7 @@ void NimBLEEddystoneTLM::setVersion(uint8_t version) {
     m_eddystoneData.version = version;
 } // setVersion
 
+
 /**
  * @brief Set the battery voltage to advertise.
  * @param [in] volt The voltage in millivolts.
@@ -189,14 +201,16 @@ void NimBLEEddystoneTLM::setVolt(uint16_t volt) {
     m_eddystoneData.volt = volt;
 } // setVolt
 
+
 /**
  * @brief Set the temperature to advertise.
- * @param [in] temp The temperature value in 8.8 fixed point format.
+ * @param [in] temp The temperature value.
  */
-void NimBLEEddystoneTLM::setTemp(int16_t temp) {
-    m_eddystoneData.temp = temp;
+void NimBLEEddystoneTLM::setTemp(float temp) {
+    m_eddystoneData.temp = ENDIAN_CHANGE_U16((int16_t)(temp * 256.0f));
 } // setTemp
 
+
 /**
  * @brief Set the advertisement count.
  * @param [in] advCount The advertisement number.
@@ -205,6 +219,7 @@ void NimBLEEddystoneTLM::setCount(uint32_t advCount) {
     m_eddystoneData.advCount = advCount;
 } // setCount
 
+
 /**
  * @brief Set the advertisement time.
  * @param [in] tmil The advertisement time in milliseconds.
@@ -213,4 +228,4 @@ void NimBLEEddystoneTLM::setTime(uint32_t tmil) {
     m_eddystoneData.tmil = tmil;
 } // setTime
 
-#endif // CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_BROADCASTER
+#endif

src/NimBLEEddystoneTLM.h

@@ -12,17 +12,14 @@
  *      Author: pcbreflux
  */
 
-#ifndef NIMBLE_CPP_EDDYSTONETLM_H_
-#define NIMBLE_CPP_EDDYSTONETLM_H_
+#ifndef _NimBLEEddystoneTLM_H_
+#define _NimBLEEddystoneTLM_H_
 
-#include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER)
+#include "NimBLEUUID.h"
 
-class NimBLEUUID;
+#include <string>
 
-# include <string>
-
-# define EDDYSTONE_TLM_FRAME_TYPE 0x20
+#define EDDYSTONE_TLM_FRAME_TYPE 0x20
 
 /**
  * @brief Representation of a beacon.
@@ -30,38 +27,35 @@ class NimBLEUUID;
  * * https://github.com/google/eddystone
  */
 class NimBLEEddystoneTLM {
-  public:
-    struct BeaconData {
-        uint8_t  frameType{EDDYSTONE_TLM_FRAME_TYPE};
-        uint8_t  version{0};
-        uint16_t volt{3300};
-        uint16_t temp{23 * 256};
-        uint32_t advCount{0};
-        uint32_t tmil{0};
-    } __attribute__((packed));
+public:
+    NimBLEEddystoneTLM();
+    std::string getData();
+    NimBLEUUID   getUUID();
+    uint8_t  getVersion();
+    uint16_t    getVolt();
+    float      getTemp();
+    uint32_t    getCount();
+    uint32_t    getTime();
+    std::string toString();
+    void        setData(const std::string &data);
+    void        setUUID(const NimBLEUUID &l_uuid);
+    void        setVersion(uint8_t version);
+    void        setVolt(uint16_t volt);
+    void        setTemp(float temp);
+    void        setCount(uint32_t advCount);
+    void        setTime(uint32_t tmil);
 
-    const BeaconData getData();
-    NimBLEUUID       getUUID();
-    uint8_t          getVersion();
-    uint16_t         getVolt();
-    int16_t          getTemp();
-    uint32_t         getCount();
-    uint32_t         getTime();
-    std::string      toString();
-    void             setData(const uint8_t* data, uint8_t length);
-    void             setData(const BeaconData& data);
-    void             setUUID(const NimBLEUUID& l_uuid);
-    void             setVersion(uint8_t version);
-    void             setVolt(uint16_t volt);
-    void             setTemp(int16_t temp);
-    void             setCount(uint32_t advCount);
-    void             setTime(uint32_t tmil);
-
-  private:
-    uint16_t   beaconUUID{0xFEAA};
-    BeaconData m_eddystoneData;
+private:
+    uint16_t beaconUUID;
+    struct {
+        uint8_t frameType;
+        uint8_t version;
+        uint16_t volt;
+        uint16_t temp;
+        uint32_t advCount;
+        uint32_t tmil;
+    } __attribute__((packed)) m_eddystoneData;
 
 }; // NimBLEEddystoneTLM
 
-#endif // CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_BROADCASTER
-#endif // NIMBLE_CPP_EDDYSTONETLM_H_
+#endif /* _NimBLEEddystoneTLM_H_ */

src/NimBLEEddystoneURL.cpp

@@ -0,0 +1,208 @@
+/*
+ * NimBLEEddystoneURL.cpp
+ *
+ *  Created: on March 15 2020
+ *      Author H2zero
+ *
+ * Originally:
+ *
+ * BLEEddystoneURL.cpp
+ *
+ *  Created on: Mar 12, 2018
+ *      Author: pcbreflux
+ */
+#include "nimconfig.h"
+#if defined(CONFIG_BT_ENABLED)
+
+#include "NimBLEEddystoneURL.h"
+#include "NimBLELog.h"
+
+#include <cstring>
+
+static const char LOG_TAG[] = "NimBLEEddystoneURL";
+
+
+/**
+ * @brief Construct a default EddystoneURL beacon object.
+ */
+NimBLEEddystoneURL::NimBLEEddystoneURL() {
+    beaconUUID = 0xFEAA;
+    lengthURL = 0;
+    m_eddystoneData.frameType = EDDYSTONE_URL_FRAME_TYPE;
+    m_eddystoneData.advertisedTxPower = 0;
+    memset(m_eddystoneData.url, 0, sizeof(m_eddystoneData.url));
+} // BLEEddystoneURL
+
+
+/**
+ * @brief Retrieve the data that is being advertised.
+ * @return The advertised data.
+ */
+std::string NimBLEEddystoneURL::getData() {
+    return std::string((char*) &m_eddystoneData, sizeof(m_eddystoneData));
+} // getData
+
+
+/**
+ * @brief Get the UUID being advertised.
+ * @return The UUID advertised.
+ */
+NimBLEUUID NimBLEEddystoneURL::getUUID() {
+    return NimBLEUUID(beaconUUID);
+} // getUUID
+
+
+/**
+ * @brief Get the transmit power being advertised.
+ * @return The transmit power.
+ */
+int8_t NimBLEEddystoneURL::getPower() {
+    return m_eddystoneData.advertisedTxPower;
+} // getPower
+
+
+/**
+ * @brief Get the raw URL being advertised.
+ * @return The raw URL.
+ */
+std::string NimBLEEddystoneURL::getURL() {
+    return std::string((char*) &m_eddystoneData.url, sizeof(m_eddystoneData.url));
+} // getURL
+
+
+/**
+ * @brief Get the full URL being advertised.
+ * @return The full URL.
+ */
+std::string NimBLEEddystoneURL::getDecodedURL() {
+    std::string decodedURL = "";
+
+    switch (m_eddystoneData.url[0]) {
+        case 0x00:
+            decodedURL += "http://www.";
+            break;
+        case 0x01:
+            decodedURL += "https://www.";
+            break;
+        case 0x02:
+            decodedURL += "http://";
+            break;
+        case 0x03:
+            decodedURL += "https://";
+            break;
+        default:
+            decodedURL += m_eddystoneData.url[0];
+    }
+
+    for (int i = 1; i < lengthURL; i++) {
+        if (m_eddystoneData.url[i] > 33 && m_eddystoneData.url[i] < 127) {
+            decodedURL += m_eddystoneData.url[i];
+        } else {
+            switch (m_eddystoneData.url[i]) {
+                case 0x00:
+                    decodedURL += ".com/";
+                    break;
+                case 0x01:
+                    decodedURL += ".org/";
+                    break;
+                case 0x02:
+                    decodedURL += ".edu/";
+                    break;
+                case 0x03:
+                    decodedURL += ".net/";
+                    break;
+                case 0x04:
+                    decodedURL += ".info/";
+                    break;
+                case 0x05:
+                    decodedURL += ".biz/";
+                    break;
+                case 0x06:
+                    decodedURL += ".gov/";
+                    break;
+                case 0x07:
+                    decodedURL += ".com";
+                    break;
+                case 0x08:
+                    decodedURL += ".org";
+                    break;
+                case 0x09:
+                    decodedURL += ".edu";
+                    break;
+                case 0x0A:
+                    decodedURL += ".net";
+                    break;
+                case 0x0B:
+                    decodedURL += ".info";
+                    break;
+                case 0x0C:
+                    decodedURL += ".biz";
+                    break;
+                case 0x0D:
+                    decodedURL += ".gov";
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    return decodedURL;
+} // getDecodedURL
+
+
+
+/**
+ * @brief Set the raw data for the beacon advertisement.
+ * @param [in] data The raw data to advertise.
+ */
+void NimBLEEddystoneURL::setData(const std::string &data) {
+    if (data.length() > sizeof(m_eddystoneData)) {
+        NIMBLE_LOGE(LOG_TAG, "Unable to set the data ... length passed in was %d and max expected %d",
+                                                    data.length(), sizeof(m_eddystoneData));
+        return;
+    }
+    memset(&m_eddystoneData, 0, sizeof(m_eddystoneData));
+    memcpy(&m_eddystoneData, data.data(), data.length());
+    lengthURL = data.length() - (sizeof(m_eddystoneData) - sizeof(m_eddystoneData.url));
+} // setData
+
+
+/**
+ * @brief Set the UUID to advertise.
+ * @param [in] l_uuid The UUID.
+ */
+void NimBLEEddystoneURL::setUUID(const NimBLEUUID &l_uuid) {
+    if (l_uuid.bitSize() != 16) {
+        NIMBLE_LOGE(LOG_TAG, "UUID must be 16 bits");
+        return;
+    }
+    beaconUUID = *reinterpret_cast<const uint16_t*>(l_uuid.getValue());
+} // setUUID
+
+
+/**
+ * @brief Set the transmit power to advertise.
+ * @param [in] advertisedTxPower The transmit power level.
+ */
+void NimBLEEddystoneURL::setPower(int8_t advertisedTxPower) {
+    m_eddystoneData.advertisedTxPower = advertisedTxPower;
+} // setPower
+
+
+/**
+ * @brief Set the URL to advertise.
+ * @param [in] url The URL.
+ */
+void NimBLEEddystoneURL::setURL(const std::string &url) {
+  if (url.length() > sizeof(m_eddystoneData.url)) {
+    NIMBLE_LOGE(LOG_TAG, "Unable to set the url ... length passed in was %d and max expected %d",
+                                                    url.length(), sizeof(m_eddystoneData.url));
+    return;
+  }
+  memset(m_eddystoneData.url, 0, sizeof(m_eddystoneData.url));
+  memcpy(m_eddystoneData.url, url.data(), url.length());
+  lengthURL = url.length();
+} // setURL
+
+
+#endif

src/NimBLEEddystoneURL.h

@@ -0,0 +1,52 @@
+/*
+ * NimBLEEddystoneURL.h
+ *
+ *  Created: on March 15 2020
+ *      Author H2zero
+ *
+ * Originally:
+ *
+ * BLEEddystoneURL.h
+ *
+ *  Created on: Mar 12, 2018
+ *      Author: pcbreflux
+ */
+
+#ifndef _NIMBLEEddystoneURL_H_
+#define _NIMBLEEddystoneURL_H_
+#include "NimBLEUUID.h"
+
+#include <string>
+
+#define EDDYSTONE_URL_FRAME_TYPE 0x10
+
+/**
+ * @brief Representation of a beacon.
+ * See:
+ * * https://github.com/google/eddystone
+ */
+class NimBLEEddystoneURL {
+public:
+    NimBLEEddystoneURL();
+    std::string getData();
+    NimBLEUUID   getUUID();
+    int8_t    getPower();
+    std::string getURL();
+    std::string getDecodedURL();
+    void        setData(const std::string &data);
+    void        setUUID(const NimBLEUUID &l_uuid);
+    void        setPower(int8_t advertisedTxPower);
+    void        setURL(const std::string &url);
+
+private:
+    uint16_t beaconUUID;
+    uint8_t  lengthURL;
+    struct {
+        uint8_t frameType;
+        int8_t  advertisedTxPower;
+        uint8_t url[16];
+    } __attribute__((packed)) m_eddystoneData;
+
+}; // NIMBLEEddystoneURL
+
+#endif /* _NIMBLEEddystoneURL_H_ */

src/NimBLEExtAdvertising.h

@@ -5,150 +5,148 @@
  *      Author H2zero
  */
 
-#ifndef NIMBLE_CPP_EXTADVERTISING_H_
-#define NIMBLE_CPP_EXTADVERTISING_H_
-
+#ifndef MAIN_BLEEXTADVERTISING_H_
+#define MAIN_BLEEXTADVERTISING_H_
 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER) && CONFIG_BT_NIMBLE_EXT_ADV
+#if defined(CONFIG_BT_ENABLED) && \
+    defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER) && \
+    CONFIG_BT_NIMBLE_EXT_ADV
 
-# if defined(CONFIG_NIMBLE_CPP_IDF)
-#  include "host/ble_gap.h"
-# else
-#  include "nimble/nimble/host/include/host/ble_gap.h"
-# endif
+#  if defined(CONFIG_NIMBLE_CPP_IDF)
+#    include "host/ble_gap.h"
+#  else
+#    include "nimble/nimble/host/include/host/ble_gap.h"
+#  endif
 
 /****  FIX COMPILATION ****/
-# undef min
-# undef max
+#undef min
+#undef max
 /**************************/
 
-# include "NimBLEAddress.h"
+#include "NimBLEAddress.h"
+#include "NimBLEUUID.h"
 
-# include <string>
-# include <vector>
+#include <vector>
 
 class NimBLEExtAdvertisingCallbacks;
-class NimBLEUUID;
+
 
 /**
  * @brief Extended advertisement data
  */
 class NimBLEExtAdvertisement {
-  public:
-    NimBLEExtAdvertisement(uint8_t priPhy = BLE_HCI_LE_PHY_1M, uint8_t secPhy = BLE_HCI_LE_PHY_1M);
-    bool setAppearance(uint16_t appearance);
-    bool addServiceUUID(const NimBLEUUID& serviceUUID);
-    bool addServiceUUID(const char* serviceUUID);
-    bool removeServiceUUID(const NimBLEUUID& serviceUUID);
-    bool removeServiceUUID(const char* serviceUUID);
-    bool removeServices();
-    bool setCompleteServices(const NimBLEUUID& uuid);
-    bool setCompleteServices16(const std::vector<NimBLEUUID>& uuids);
-    bool setCompleteServices32(const std::vector<NimBLEUUID>& uuids);
-    bool setFlags(uint8_t flag);
-    bool setManufacturerData(const uint8_t* data, size_t length);
-    bool setManufacturerData(const std::string& data);
-    bool setManufacturerData(const std::vector<uint8_t>& data);
-    bool setURI(const std::string& uri);
-    bool setName(const std::string& name, bool isComplete = true);
-    bool setPartialServices(const NimBLEUUID& uuid);
-    bool setPartialServices16(const std::vector<NimBLEUUID>& uuids);
-    bool setPartialServices32(const std::vector<NimBLEUUID>& uuids);
-    bool setServiceData(const NimBLEUUID& uuid, const uint8_t* data, size_t length);
-    bool setServiceData(const NimBLEUUID& uuid, const std::string& data);
-    bool setServiceData(const NimBLEUUID& uuid, const std::vector<uint8_t>& data);
-    bool setShortName(const std::string& name);
-    bool setData(const uint8_t* data, size_t length);
-    bool addData(const uint8_t* data, size_t length);
-    bool addData(const std::string& data);
-    bool setPreferredParams(uint16_t min, uint16_t max);
+public:
+    NimBLEExtAdvertisement(uint8_t priPhy = BLE_HCI_LE_PHY_1M,
+                           uint8_t secPhy = BLE_HCI_LE_PHY_1M);
+    void   setAppearance(uint16_t appearance);
+    void   setCompleteServices(const NimBLEUUID &uuid);
+    void   setCompleteServices16(const std::vector<NimBLEUUID> &v_uuid);
+    void   setCompleteServices32(const std::vector<NimBLEUUID> &v_uuid);
+    void   setFlags(uint8_t flag);
+    void   setManufacturerData(const std::string &data);
+    void   setURI(const std::string &uri);
+    void   setName(const std::string &name);
+    void   setPartialServices(const NimBLEUUID &uuid);
+    void   setPartialServices16(const std::vector<NimBLEUUID> &v_uuid);
+    void   setPartialServices32(const std::vector<NimBLEUUID> &v_uuid);
+    void   setServiceData(const NimBLEUUID &uuid, const std::string &data);
+    void   setShortName(const std::string &name);
+    void   setData(const uint8_t * data, size_t length);
+    void   addData(const std::string &data);
+    void   addData(const uint8_t * data, size_t length);
+    void   addTxPower();
+    void   setPreferredParams(uint16_t min, uint16_t max);
+    void   setLegacyAdvertising(bool val);
+    void   setConnectable(bool val);
+    void   setScannable(bool val);
+    void   setMinInterval(uint32_t mininterval);
+    void   setMaxInterval(uint32_t maxinterval);
+    void   setPrimaryPhy(uint8_t phy);
+    void   setSecondaryPhy(uint8_t phy);
+    void   setScanFilter(bool scanRequestWhitelistOnly, bool connectWhitelistOnly);
+    void   setDirectedPeer(const NimBLEAddress & addr);
+    void   setDirected(bool val, bool high_duty = true);
+    void   setAnonymous(bool val);
+    void   setPrimaryChannels(bool ch37, bool ch38, bool ch39);
+    void   setTxPower(int8_t dbm);
+    void   setAddress(const NimBLEAddress & addr);
+    void   enableScanRequestCallback(bool enable);
+    void   clearData();
+    size_t getDataSize();
 
-    void        addTxPower();
-    void        setLegacyAdvertising(bool enable);
-    void        setConnectable(bool enable);
-    void        setScannable(bool enable);
-    void        setMinInterval(uint32_t mininterval);
-    void        setMaxInterval(uint32_t maxinterval);
-    void        setPrimaryPhy(uint8_t phy);
-    void        setSecondaryPhy(uint8_t phy);
-    void        setScanFilter(bool scanRequestWhitelistOnly, bool connectWhitelistOnly);
-    void        setDirectedPeer(const NimBLEAddress& addr);
-    void        setDirected(bool enable, bool high_duty = true);
-    void        setAnonymous(bool enable);
-    void        setPrimaryChannels(bool ch37, bool ch38, bool ch39);
-    void        setTxPower(int8_t dbm);
-    void        setAddress(const NimBLEAddress& addr);
-    void        enableScanRequestCallback(bool enable);
-    void        clearData();
-    int         getDataLocation(uint8_t type) const;
-    bool        removeData(uint8_t type);
-    size_t      getDataSize() const;
-    std::string toString() const;
-
-  private:
+private:
     friend class NimBLEExtAdvertising;
 
-    bool setServices(bool complete, uint8_t size, const std::vector<NimBLEUUID>& uuids);
+    void setServices(const bool complete, const uint8_t size,
+                     const std::vector<NimBLEUUID> &v_uuid);
+
+    std::vector<uint8_t>    m_payload;
+    ble_gap_ext_adv_params  m_params;
+    NimBLEAddress           m_advAddress;
+};   // NimBLEExtAdvertisement
 
-    std::vector<uint8_t>   m_payload{};
-    ble_gap_ext_adv_params m_params{};
-    NimBLEAddress          m_advAddress{};
-}; // NimBLEExtAdvertisement
 
 /**
  * @brief Extended advertising class.
  */
 class NimBLEExtAdvertising {
-  public:
-    NimBLEExtAdvertising();
+public:
+    /**
+     * @brief Construct an extended advertising object.
+     */
+    NimBLEExtAdvertising() :m_advStatus(CONFIG_BT_NIMBLE_MAX_EXT_ADV_INSTANCES + 1, false) {}
     ~NimBLEExtAdvertising();
-    bool start(uint8_t instId, int duration = 0, int maxEvents = 0);
-    bool setInstanceData(uint8_t instId, NimBLEExtAdvertisement& adv);
-    bool setScanResponseData(uint8_t instId, NimBLEExtAdvertisement& data);
-    bool removeInstance(uint8_t instId);
+    bool start(uint8_t inst_id, int duration = 0, int max_events = 0);
+    bool setInstanceData(uint8_t inst_id, NimBLEExtAdvertisement& adv);
+    bool setScanResponseData(uint8_t inst_id, NimBLEExtAdvertisement & data);
+    bool removeInstance(uint8_t inst_id);
     bool removeAll();
-    bool stop(uint8_t instId);
+    bool stop(uint8_t inst_id);
     bool stop();
-    bool isActive(uint8_t instId);
+    bool isActive(uint8_t inst_id);
     bool isAdvertising();
-    void setCallbacks(NimBLEExtAdvertisingCallbacks* callbacks, bool deleteCallbacks = true);
+    void setCallbacks(NimBLEExtAdvertisingCallbacks* callbacks,
+                      bool deleteCallbacks = true);
 
-  private:
+private:
     friend class NimBLEDevice;
     friend class NimBLEServer;
 
-    void       onHostSync();
-    static int handleGapEvent(struct ble_gap_event* event, void* arg);
+    void           onHostSync();
+    static int     handleGapEvent(struct ble_gap_event *event, void *arg);
 
-    bool                           m_deleteCallbacks;
-    NimBLEExtAdvertisingCallbacks* m_pCallbacks;
-    std::vector<bool>              m_advStatus;
+    bool                            m_scanResp;
+    bool                            m_deleteCallbacks;
+    NimBLEExtAdvertisingCallbacks*  m_pCallbacks;
+    ble_gap_ext_adv_params          m_advParams;
+    std::vector<bool>               m_advStatus;
 };
 
+
 /**
  * @brief Callbacks associated with NimBLEExtAdvertising class.
  */
 class NimBLEExtAdvertisingCallbacks {
-  public:
+public:
     virtual ~NimBLEExtAdvertisingCallbacks() {};
 
     /**
      * @brief Handle an advertising stop event.
      * @param [in] pAdv A convenience pointer to the extended advertising interface.
      * @param [in] reason The reason code for stopping the advertising.
-     * @param [in] instId The instance ID of the advertisement that was stopped.
+     * @param [in] inst_id The instance ID of the advertisement that was stopped.
      */
-    virtual void onStopped(NimBLEExtAdvertising* pAdv, int reason, uint8_t instId);
+    virtual void onStopped(NimBLEExtAdvertising *pAdv, int reason, uint8_t inst_id);
 
     /**
      * @brief Handle a scan response request.
      * This is called when a scanning device requests a scan response.
      * @param [in] pAdv A convenience pointer to the extended advertising interface.
-     * @param [in] instId The instance ID of the advertisement that the scan response request was made.
+     * @param [in] inst_id The instance ID of the advertisement that the scan response request was made.
      * @param [in] addr The address of the device making the request.
      */
-    virtual void onScanRequest(NimBLEExtAdvertising* pAdv, uint8_t instId, NimBLEAddress addr);
+    virtual void onScanRequest(NimBLEExtAdvertising *pAdv, uint8_t inst_id, NimBLEAddress addr);
 }; // NimBLEExtAdvertisingCallbacks
 
-#endif // CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_BROADCASTER && CONFIG_BT_NIMBLE_EXT_ADV
-#endif // NIMBLE_CPP_EXTADVERTISING_H_
+#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_BROADCASTER && CONFIG_BT_NIMBLE_EXT_ADV */
+#endif /* MAIN_BLEADVERTISING_H_ */

src/NimBLEHIDDevice.cpp

@@ -15,95 +15,97 @@
 #include "nimconfig.h"
 #if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
 
-# include "NimBLEHIDDevice.h"
-# include "NimBLEServer.h"
-# include "NimBLEService.h"
-# include "NimBLE2904.h"
-
-static constexpr uint16_t deviceInfoSvcUuid = 0x180a;
-static constexpr uint16_t hidSvcUuid        = 0x1812;
-static constexpr uint16_t batterySvcUuid    = 0x180f;
-
-static constexpr uint16_t pnpCharUuid           = 0x2a50;
-static constexpr uint16_t hidInfoCharUuid       = 0x2a4a;
-static constexpr uint16_t reportMapCharUuid     = 0x2a4b;
-static constexpr uint16_t hidControlCharUuid    = 0x2a4c;
-static constexpr uint16_t inputReportChrUuid    = 0x2a4d;
-static constexpr uint16_t protocolModeCharUuid  = 0x2a4e;
-static constexpr uint16_t batteryLevelCharUuid  = 0x2a19;
-static constexpr uint16_t batteryLevelDscUuid   = 0x2904;
-static constexpr uint16_t featureReportDscUuid  = 0x2908;
-static constexpr uint16_t m_manufacturerChrUuid = 0x2a29;
-static constexpr uint16_t bootInputChrUuid      = 0x2a22;
-static constexpr uint16_t bootOutputChrUuid     = 0x2a32;
+#include "NimBLEHIDDevice.h"
+#include "NimBLE2904.h"
 
 /**
  * @brief Construct a default NimBLEHIDDevice object.
  * @param [in] server A pointer to the server instance this HID Device will use.
  */
 NimBLEHIDDevice::NimBLEHIDDevice(NimBLEServer* server) {
-    // Here we create mandatory services described in bluetooth specification
-    m_deviceInfoSvc = server->createService(deviceInfoSvcUuid);
-    m_hidSvc        = server->createService(hidSvcUuid);
-    m_batterySvc    = server->createService(batterySvcUuid);
+	/*
+	 * Here we create mandatory services described in bluetooth specification
+	 */
+	m_deviceInfoService = server->createService(NimBLEUUID((uint16_t)0x180a));
+	m_hidService = server->createService(NimBLEUUID((uint16_t)0x1812));
+	m_batteryService = server->createService(NimBLEUUID((uint16_t)0x180f));
 
-    // Mandatory characteristic for device info service
-    m_pnpChr = m_deviceInfoSvc->createCharacteristic(pnpCharUuid, NIMBLE_PROPERTY::READ);
+	/*
+	 * Mandatory characteristic for device info service
+	 */
+	m_pnpCharacteristic = m_deviceInfoService->createCharacteristic((uint16_t)0x2a50, NIMBLE_PROPERTY::READ);
 
-    // Mandatory characteristics for HID service
-    m_hidInfoChr    = m_hidSvc->createCharacteristic(hidInfoCharUuid, NIMBLE_PROPERTY::READ);
-    m_reportMapChr  = m_hidSvc->createCharacteristic(reportMapCharUuid, NIMBLE_PROPERTY::READ);
-    m_hidControlChr = m_hidSvc->createCharacteristic(hidControlCharUuid, NIMBLE_PROPERTY::WRITE_NR);
-    m_protocolModeChr =
-        m_hidSvc->createCharacteristic(protocolModeCharUuid, NIMBLE_PROPERTY::WRITE_NR | NIMBLE_PROPERTY::READ);
+	/*
+	 * Non-mandatory characteristics for device info service
+	 * Will be created on demand
+	 */
+	m_manufacturerCharacteristic = nullptr;
 
-    // Mandatory battery level characteristic with notification and presence descriptor
-    m_batteryLevelChr =
-        m_batterySvc->createCharacteristic(batteryLevelCharUuid, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::NOTIFY);
-    NimBLE2904* batteryLevelDescriptor = m_batteryLevelChr->create2904();
-    batteryLevelDescriptor->setFormat(NimBLE2904::FORMAT_UINT8);
-    batteryLevelDescriptor->setUnit(0x27ad); // percentage
+	/*
+	 * Mandatory characteristics for HID service
+	 */
+	m_hidInfoCharacteristic = m_hidService->createCharacteristic((uint16_t)0x2a4a, NIMBLE_PROPERTY::READ);
+	m_reportMapCharacteristic = m_hidService->createCharacteristic((uint16_t)0x2a4b, NIMBLE_PROPERTY::READ);
+	m_hidControlCharacteristic = m_hidService->createCharacteristic((uint16_t)0x2a4c, NIMBLE_PROPERTY::WRITE_NR);
+	m_protocolModeCharacteristic = m_hidService->createCharacteristic((uint16_t)0x2a4e, NIMBLE_PROPERTY::WRITE_NR | NIMBLE_PROPERTY::READ);
 
-    // This value is setup here because its default value in most usage cases, it's very rare to use boot mode
-    m_protocolModeChr->setValue(static_cast<uint8_t>(0x01));
-} // NimBLEHIDDevice
+	/*
+	 * Mandatory battery level characteristic with notification and presence descriptor
+	 */
+	m_batteryLevelCharacteristic = m_batteryService->createCharacteristic((uint16_t)0x2a19, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::NOTIFY);
+	NimBLE2904 *batteryLevelDescriptor = (NimBLE2904*)m_batteryLevelCharacteristic->createDescriptor((uint16_t)0x2904);
+	batteryLevelDescriptor->setFormat(NimBLE2904::FORMAT_UINT8);
+	batteryLevelDescriptor->setNamespace(1);
+	batteryLevelDescriptor->setUnit(0x27ad);
+
+	/*
+	 * This value is setup here because its default value in most usage cases, its very rare to use boot mode
+	 * and we want to simplify library using as much as possible
+	 */
+	const uint8_t pMode[] = {0x01};
+	protocolMode()->setValue((uint8_t*)pMode, 1);
+}
+
+NimBLEHIDDevice::~NimBLEHIDDevice() {
+}
 
 /**
  * @brief Set the report map data formatting information.
  * @param [in] map A pointer to an array with the values to set.
  * @param [in] size The number of values in the array.
  */
-void NimBLEHIDDevice::setReportMap(uint8_t* map, uint16_t size) {
-    m_reportMapChr->setValue(map, size);
-} // setReportMap
+void NimBLEHIDDevice::reportMap(uint8_t* map, uint16_t size) {
+	m_reportMapCharacteristic->setValue(map, size);
+}
 
 /**
- * @brief Start the HID device services.
+ * @brief Start the HID device services.\n
  * This function called when all the services have been created.
  */
 void NimBLEHIDDevice::startServices() {
-    m_deviceInfoSvc->start();
-    m_hidSvc->start();
-    m_batterySvc->start();
-} // startServices
+	m_deviceInfoService->start();
+	m_hidService->start();
+	m_batteryService->start();
+}
 
 /**
- * @brief Get the manufacturer characteristic (this characteristic is optional).
- * @details The characteristic will be created if not already existing.
- * @returns True if the name was set and/or the characteristic created.
+ * @brief Create a manufacturer characteristic (this characteristic is optional).
  */
-bool NimBLEHIDDevice::setManufacturer(const std::string& name) {
-    if (m_manufacturerChr == nullptr) {
-        m_manufacturerChr = m_deviceInfoSvc->createCharacteristic(m_manufacturerChrUuid, NIMBLE_PROPERTY::READ);
-    }
+NimBLECharacteristic* NimBLEHIDDevice::manufacturer() {
+	if (m_manufacturerCharacteristic == nullptr) {
+		m_manufacturerCharacteristic = m_deviceInfoService->createCharacteristic((uint16_t)0x2a29, NIMBLE_PROPERTY::READ);
+	}
 
-    if (m_manufacturerChr) {
-        m_manufacturerChr->setValue(name);
-        return true;
-    }
+	return m_manufacturerCharacteristic;
+}
 
-    return false;
-} // setManufacturer
+/**
+ * @brief Set manufacturer name
+ * @param [in] name The manufacturer name of this HID device.
+ */
+void NimBLEHIDDevice::manufacturer(std::string name) {
+	manufacturer()->setValue(name);
+}
 
 /**
  * @brief Sets the Plug n Play characteristic value.
@@ -112,208 +114,152 @@ bool NimBLEHIDDevice::setManufacturer(const std::string& name) {
  * @param [in] pid The product ID number.
  * @param [in] version The produce version number.
  */
-void NimBLEHIDDevice::setPnp(uint8_t sig, uint16_t vid, uint16_t pid, uint16_t version) {
-    uint8_t pnp[] = {sig,
-                     static_cast<uint8_t>(vid & 0xFF),
-                     static_cast<uint8_t>((vid >> 8) & 0xFF),
-                     static_cast<uint8_t>(pid & 0xFF),
-                     static_cast<uint8_t>((pid >> 8) & 0xFF),
-                     static_cast<uint8_t>(version & 0xFF),
-                     static_cast<uint8_t>((version >> 8) & 0xFF)};
-
-    m_pnpChr->setValue(pnp, sizeof(pnp));
-} // setPnp
+void NimBLEHIDDevice::pnp(uint8_t sig, uint16_t vid, uint16_t pid, uint16_t version) {
+	uint8_t pnp[] = {
+		sig,
+		((uint8_t*)&vid)[0],
+		((uint8_t*)&vid)[1],
+		((uint8_t*)&pid)[0],
+		((uint8_t*)&pid)[1],
+		((uint8_t*)&version)[0],
+		((uint8_t*)&version)[1]
+		};
+	m_pnpCharacteristic->setValue(pnp, sizeof(pnp));
+}
 
 /**
  * @brief Sets the HID Information characteristic value.
  * @param [in] country The country code for the device.
  * @param [in] flags The HID Class Specification release number to use.
  */
-void NimBLEHIDDevice::setHidInfo(uint8_t country, uint8_t flags) {
-    uint8_t info[] = {0x11, 0x1, country, flags};
-    m_hidInfoChr->setValue(info, sizeof(info));
-} // setHidInfo
+void NimBLEHIDDevice::hidInfo(uint8_t country, uint8_t flags) {
+	uint8_t info[] = {0x11, 0x1, country, flags};
+	m_hidInfoCharacteristic->setValue(info, sizeof(info));
+}
+
+/**
+ * @brief Create input report characteristic
+ * @param [in] reportID input report ID, the same as in report map for input object related to the characteristic
+ * @return pointer to new input report characteristic
+ */
+NimBLECharacteristic* NimBLEHIDDevice::inputReport(uint8_t reportID) {
+	NimBLECharacteristic *inputReportCharacteristic = m_hidService->createCharacteristic((uint16_t)0x2a4d, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::NOTIFY | NIMBLE_PROPERTY::READ_ENC);
+	NimBLEDescriptor *inputReportDescriptor = inputReportCharacteristic->createDescriptor((uint16_t)0x2908, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::READ_ENC);
+
+	uint8_t desc1_val[] = {reportID, 0x01};
+	inputReportDescriptor->setValue((uint8_t*)desc1_val, 2);
+
+	return inputReportCharacteristic;
+}
+
+/**
+ * @brief Create output report characteristic
+ * @param [in] reportID Output report ID, the same as in report map for output object related to the characteristic
+ * @return Pointer to new output report characteristic
+ */
+NimBLECharacteristic* NimBLEHIDDevice::outputReport(uint8_t reportID) {
+	NimBLECharacteristic *outputReportCharacteristic = m_hidService->createCharacteristic((uint16_t)0x2a4d, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::WRITE_NR | NIMBLE_PROPERTY::READ_ENC | NIMBLE_PROPERTY::WRITE_ENC);
+	NimBLEDescriptor *outputReportDescriptor = outputReportCharacteristic->createDescriptor((uint16_t)0x2908, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::READ_ENC | NIMBLE_PROPERTY::WRITE_ENC);
+
+	uint8_t desc1_val[] = {reportID, 0x02};
+	outputReportDescriptor->setValue((uint8_t*)desc1_val, 2);
+
+	return outputReportCharacteristic;
+}
+
+/**
+ * @brief Create feature report characteristic.
+ * @param [in] reportID Feature report ID, the same as in report map for feature object related to the characteristic
+ * @return Pointer to new feature report characteristic
+ */
+NimBLECharacteristic* NimBLEHIDDevice::featureReport(uint8_t reportID) {
+	NimBLECharacteristic *featureReportCharacteristic = m_hidService->createCharacteristic((uint16_t)0x2a4d, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::READ_ENC | NIMBLE_PROPERTY::WRITE_ENC);
+	NimBLEDescriptor *featureReportDescriptor = featureReportCharacteristic->createDescriptor((uint16_t)0x2908, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::READ_ENC | NIMBLE_PROPERTY::WRITE_ENC);
+
+	uint8_t desc1_val[] = {reportID, 0x03};
+	featureReportDescriptor->setValue((uint8_t*)desc1_val, 2);
+
+	return featureReportCharacteristic;
+}
+
+/**
+ * @brief Creates a keyboard boot input report characteristic
+ */
+NimBLECharacteristic* NimBLEHIDDevice::bootInput() {
+	return m_hidService->createCharacteristic((uint16_t)0x2a22, NIMBLE_PROPERTY::NOTIFY);
+}
+
+/**
+ * @brief Create a keyboard boot output report characteristic
+ */
+NimBLECharacteristic* NimBLEHIDDevice::bootOutput() {
+	return m_hidService->createCharacteristic((uint16_t)0x2a32, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::WRITE_NR);
+}
+
+/**
+ * @brief Returns a pointer to the HID control point characteristic.
+ */
+NimBLECharacteristic* NimBLEHIDDevice::hidControl() {
+	return m_hidControlCharacteristic;
+}
+
+/**
+ * @brief Returns a pointer to the protocol mode characteristic.
+ */
+NimBLECharacteristic* NimBLEHIDDevice::protocolMode() {
+	return m_protocolModeCharacteristic;
+}
 
 /**
  * @brief Set the battery level characteristic value.
  * @param [in] level The battery level value.
- * @param [in] notify If true sends a notification to the peer device, otherwise not. default = false
  */
-void NimBLEHIDDevice::setBatteryLevel(uint8_t level, bool notify) {
-    m_batteryLevelChr->setValue(&level, 1);
-    if (notify) {
-        m_batteryLevelChr->notify();
-    }
-} // setBatteryLevel
+void NimBLEHIDDevice::setBatteryLevel(uint8_t level) {
+	m_batteryLevelCharacteristic->setValue(&level, 1);
+}
+/*
+ * @brief Returns battery level characteristic
+ * @ return battery level characteristic
+ */
+NimBLECharacteristic* NimBLEHIDDevice::batteryLevel() {
+	return m_batteryLevelCharacteristic;
+}
+
+NimBLECharacteristic* NimBLEHIDDevice::reportMap() {
+	return m_reportMapCharacteristic;
+}
+
+/*
+
+BLECharacteristic*	 BLEHIDDevice::pnp() {
+	return m_pnpCharacteristic;
+}
+
+
+BLECharacteristic*	BLEHIDDevice::hidInfo() {
+	return m_hidInfoCharacteristic;
+}
+*/
 
 /**
- * @brief Get the input report characteristic.
- * @param [in] reportId input report ID, the same as in report map for input object related to the characteristic.
- * @return A pointer to the input report characteristic.
- * @details This will create the characteristic if not already created.
+ * @brief Returns a pointer to the device information service.
  */
-NimBLECharacteristic* NimBLEHIDDevice::getInputReport(uint8_t reportId) {
-    NimBLECharacteristic* inputReportChr = m_hidSvc->getCharacteristic(inputReportChrUuid);
-    if (inputReportChr == nullptr) {
-        inputReportChr =
-            m_hidSvc->createCharacteristic(inputReportChrUuid,
-                                           NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::NOTIFY | NIMBLE_PROPERTY::READ_ENC);
-        NimBLEDescriptor* inputReportDsc =
-            inputReportChr->createDescriptor(featureReportDscUuid, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::READ_ENC);
-
-        uint8_t desc1_val[] = {reportId, 0x01};
-        inputReportDsc->setValue(desc1_val, 2);
-    }
-
-    return inputReportChr;
-} // getInputReport
+NimBLEService* NimBLEHIDDevice::deviceInfo() {
+	return m_deviceInfoService;
+}
 
 /**
- * @brief Get the output report characteristic.
- * @param [in] reportId Output report ID, the same as in report map for output object related to the characteristic.
- * @return A pointer to the output report characteristic.
- * @details This will create the characteristic if not already created.
+ * @brief Returns a pointer to the HID service.
  */
-NimBLECharacteristic* NimBLEHIDDevice::getOutputReport(uint8_t reportId) {
-    NimBLECharacteristic* outputReportChr = m_hidSvc->getCharacteristic(inputReportChrUuid);
-    if (outputReportChr == nullptr) {
-        outputReportChr =
-            m_hidSvc->createCharacteristic(inputReportChrUuid,
-                                           NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::WRITE_NR |
-                                               NIMBLE_PROPERTY::READ_ENC | NIMBLE_PROPERTY::WRITE_ENC);
-        NimBLEDescriptor* outputReportDsc = outputReportChr->createDescriptor(
-            featureReportDscUuid,
-            NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::READ_ENC | NIMBLE_PROPERTY::WRITE_ENC);
-
-        uint8_t desc1_val[] = {reportId, 0x02};
-        outputReportDsc->setValue(desc1_val, 2);
-    }
-
-    return outputReportChr;
-} // getOutputReport
+NimBLEService* NimBLEHIDDevice::hidService() {
+	return m_hidService;
+}
 
 /**
- * @brief Get the feature report characteristic.
- * @param [in] reportId Feature report ID, the same as in report map for feature object related to the characteristic.
- * @return A pointer to feature report characteristic.
- * @details This will create the characteristic if not already created.
+ * @brief @brief Returns a pointer to the battery service.
  */
-NimBLECharacteristic* NimBLEHIDDevice::getFeatureReport(uint8_t reportId) {
-    NimBLECharacteristic* featureReportChr = m_hidSvc->getCharacteristic(inputReportChrUuid);
-    if (featureReportChr == nullptr) {
-        featureReportChr = m_hidSvc->createCharacteristic(
-            inputReportChrUuid,
-            NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::READ_ENC | NIMBLE_PROPERTY::WRITE_ENC);
-        NimBLEDescriptor* featureReportDsc = featureReportChr->createDescriptor(
-            featureReportDscUuid,
-            NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::READ_ENC | NIMBLE_PROPERTY::WRITE_ENC);
-
-        uint8_t desc1_val[] = {reportId, 0x03};
-        featureReportDsc->setValue(desc1_val, 2);
-    }
-
-    return featureReportChr;
-} // getFeatureReport
-
-/**
- * @brief Get a keyboard boot input report characteristic.
- * @returns A pointer to the boot input report characteristic, or nullptr on error.
- * @details This will create the characteristic if not already created.
- */
-NimBLECharacteristic* NimBLEHIDDevice::getBootInput() {
-    NimBLECharacteristic* bootInputChr = m_hidSvc->getCharacteristic(bootInputChrUuid);
-    if (bootInputChr) {
-        return bootInputChr;
-    }
-
-    return m_hidSvc->createCharacteristic(bootInputChrUuid, NIMBLE_PROPERTY::NOTIFY);
-} // getBootInput
-
-/**
- * @brief Create a keyboard boot output report characteristic
- * @returns A pointer to the boot output report characteristic, or nullptr on error.
- * @details This will create the characteristic if not already created.
- */
-NimBLECharacteristic* NimBLEHIDDevice::getBootOutput() {
-    NimBLECharacteristic* bootOutputChr = m_hidSvc->getCharacteristic(bootOutputChrUuid);
-    if (bootOutputChr) {
-        return bootOutputChr;
-    }
-
-    return m_hidSvc->createCharacteristic(bootOutputChrUuid,
-                                          NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::WRITE_NR);
-} // getBootOutput
-
-/**
- * @brief Get the HID control point characteristic.
- * @returns A pointer to the HID control point characteristic.
- */
-NimBLECharacteristic* NimBLEHIDDevice::getHidControl() {
-    return m_hidControlChr;
-} // getHidControl
-
-/**
- * @brief Get the HID protocol mode characteristic.
- * @returns a pointer to the protocol mode characteristic.
- */
-NimBLECharacteristic* NimBLEHIDDevice::getProtocolMode() {
-    return m_protocolModeChr;
-} // getProtocolMode
-
-/**
- * @brief Get the battery level characteristic
- * @returns A pointer to the battery level characteristic
- */
-NimBLECharacteristic* NimBLEHIDDevice::getBatteryLevel() {
-    return m_batteryLevelChr;
-} // getBatteryLevel
-
-/**
- * @brief Get the report map characteristic.
- * @returns A pointer to the report map characteristic.
- */
-NimBLECharacteristic* NimBLEHIDDevice::getReportMap() {
-    return m_reportMapChr;
-} // getReportMap
-
-/**
- * @brief Get the PnP characteristic.
- * @returns A pointer to the PnP characteristic.
- */
-NimBLECharacteristic* NimBLEHIDDevice::getPnp() {
-    return m_pnpChr;
-} // getPnp
-
-/**
- * @brief Get the HID information characteristic.
- * @returns A pointer to the HID information characteristic.
- */
-NimBLECharacteristic* NimBLEHIDDevice::getHidInfo() {
-    return m_hidInfoChr;
-} // hidInfo
-
-/**
- * @brief Get the manufacturer characteristic.
- * @returns A pointer to the manufacturer characteristic.
- */
-NimBLEService* NimBLEHIDDevice::getDeviceInfoService() {
-    return m_deviceInfoSvc;
-} // getDeviceInfoService
-
-/**
- * @brief Get the HID service.
- * @returns A pointer to the HID service.
- */
-NimBLEService* NimBLEHIDDevice::getHidService() {
-    return m_hidSvc;
-} // getHidService
-
-/**
- * @brief Get the battery service.
- * @returns A pointer to the battery service.
- */
-NimBLEService* NimBLEHIDDevice::getBatteryService() {
-    return m_batterySvc;
-} // getBatteryService
+NimBLEService* NimBLEHIDDevice::batteryService() {
+	return m_batteryService;
+}
 
 #endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */