Use standard logging

Author: lucasssvaz

libraries/NimBLE/src/BLEAddress.cpp

@@ -19,7 +19,6 @@
 #if defined(CONFIG_BT_ENABLED)
 
 #include "BLEAddress.h"
-#include "BLELog.h"
 
 #include <algorithm>
 
@@ -78,7 +77,7 @@ BLEAddress::BLEAddress(const std::string &addr, uint8_t type) {
   }
 
   *this = BLEAddress{};
-  NIMBLE_LOGE(LOG_TAG, "Invalid address '%s'", addr.c_str());
+  log_e(LOG_TAG, "Invalid address '%s'", addr.c_str());
 }  // BLEAddress
 
 /**

libraries/NimBLE/src/BLEAdvertisedDevice.cpp

@@ -21,7 +21,6 @@
 #include "BLEDevice.h"
 #include "BLEAdvertisedDevice.h"
 #include "BLEUtils.h"
-#include "BLELog.h"
 
 #include <climits>
 
@@ -321,7 +320,7 @@ std::string BLEAdvertisedDevice::getServiceData(const BLEUUID &uuid) const {
     data_loc = findServiceData(index, &bytes);
   }
 
-  NIMBLE_LOGI(LOG_TAG, "No service data found");
+  log_i(LOG_TAG, "No service data found");
   return "";
 }  // getServiceData
 

libraries/NimBLE/src/BLEAdvertisementData.cpp

@@ -22,7 +22,6 @@
 #include "BLEDevice.h"
 #include "BLEUtils.h"
 #include "BLEUUID.h"
-#include "BLELog.h"
 
 #include "host/ble_hs_adv.h"
 
@@ -35,7 +34,7 @@ static const char *LOG_TAG = "BLEAdvertisementData";
  */
 bool BLEAdvertisementData::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");
+    log_e(LOG_TAG, "Data length exceeded");
     return false;
   }
 
@@ -147,7 +146,7 @@ bool BLEAdvertisementData::addServiceUUID(const BLEUUID &serviceUUID) {
     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: NIMBLE_LOGE(LOG_TAG, "Cannot add UUID, invalid size!"); return false;
+    default: log_e(LOG_TAG, "Cannot add UUID, invalid size!"); return false;
   }
 
   int dataLoc = getDataLocation(type);
@@ -157,7 +156,7 @@ bool BLEAdvertisementData::addServiceUUID(const BLEUUID &serviceUUID) {
   }
 
   if (length + getPayload().size() > BLE_HS_ADV_MAX_SZ) {
-    NIMBLE_LOGE(LOG_TAG, "Cannot add UUID, data length exceeded!");
+    log_e(LOG_TAG, "Cannot add UUID, data length exceeded!");
     return false;
   }
 
@@ -196,7 +195,7 @@ bool BLEAdvertisementData::removeServiceUUID(const BLEUUID &serviceUUID) {
     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: NIMBLE_LOGE(LOG_TAG, "Cannot remove UUID, invalid size!"); return false;
+    default: log_e(LOG_TAG, "Cannot remove UUID, invalid size!"); return false;
   }
 
   int dataLoc = getDataLocation(type);
@@ -249,7 +248,7 @@ bool BLEAdvertisementData::removeServices() {
  */
 bool BLEAdvertisementData::setManufacturerData(const uint8_t *data, size_t length) {
   if (length > BLE_HS_ADV_MAX_FIELD_SZ) {
-    NIMBLE_LOGE(LOG_TAG, "MFG data too long");
+    log_e(LOG_TAG, "MFG data too long");
     return false;
   }
 
@@ -285,7 +284,7 @@ bool BLEAdvertisementData::setManufacturerData(const std::vector<uint8_t> &data)
  */
 bool BLEAdvertisementData::setURI(const std::string &uri) {
   if (uri.length() > BLE_HS_ADV_MAX_FIELD_SZ) {
-    NIMBLE_LOGE(LOG_TAG, "URI too long");
+    log_e(LOG_TAG, "URI too long");
     return false;
   }
 
@@ -307,7 +306,7 @@ bool BLEAdvertisementData::setURI(const std::string &uri) {
  */
 bool BLEAdvertisementData::setName(const std::string &name, bool isComplete) {
   if (name.length() > BLE_HS_ADV_MAX_FIELD_SZ) {
-    NIMBLE_LOGE(LOG_TAG, "Name too long - truncating");
+    log_e(LOG_TAG, "Name too long - truncating");
     isComplete = false;
   }
 
@@ -397,11 +396,11 @@ bool BLEAdvertisementData::setServices(bool complete, uint8_t size, const std::v
 
   for (const auto &uuid : uuids) {
     if (uuid.bitSize() != size) {
-      NIMBLE_LOGE(LOG_TAG, "Service UUID(%d) invalid", size);
+      log_e(LOG_TAG, "Service UUID(%d) invalid", size);
       continue;
     } else {
       if (length + bytes >= BLE_HS_ADV_MAX_SZ) {
-        NIMBLE_LOGW(LOG_TAG, "Too many services - truncating");
+        log_w(LOG_TAG, "Too many services - truncating");
         complete = false;
         break;
       }
@@ -416,7 +415,7 @@ bool BLEAdvertisementData::setServices(bool complete, uint8_t size, const std::v
     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:  NIMBLE_LOGE(LOG_TAG, "Cannot set services, invalid size!"); return false;
+    default:  log_e(LOG_TAG, "Cannot set services, invalid size!"); return false;
   }
 
   return addData(data, length);
@@ -434,7 +433,7 @@ bool BLEAdvertisementData::setServiceData(const BLEUUID &uuid, const uint8_t *da
   uint8_t uuidBytes = uuid.bitSize() / 8;
   uint8_t sDataLen = 2 + uuidBytes + length;
   if (sDataLen > BLE_HS_ADV_MAX_SZ) {
-    NIMBLE_LOGE(LOG_TAG, "Service Data too long");
+    log_e(LOG_TAG, "Service Data too long");
     return false;
   }
 
@@ -443,7 +442,7 @@ bool BLEAdvertisementData::setServiceData(const BLEUUID &uuid, const uint8_t *da
     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: NIMBLE_LOGE(LOG_TAG, "Cannot set service data, invalid size!"); return false;
+    default: log_e(LOG_TAG, "Cannot set service data, invalid size!"); return false;
   }
 
   if (length == 0) {

libraries/NimBLE/src/BLEAdvertising.cpp

@@ -24,7 +24,6 @@
 #include "BLEDevice.h"
 #include "BLEServer.h"
 #include "BLEUtils.h"
-#include "BLELog.h"
 
 static const char *LOG_TAG = "BLEAdvertising";
 
@@ -65,7 +64,7 @@ bool BLEAdvertising::reset() {
  */
 bool BLEAdvertising::setConnectableMode(uint8_t mode) {
   if (mode > BLE_GAP_CONN_MODE_UND) {
-    NIMBLE_LOGE(LOG_TAG, "Invalid connectable mode: %u", mode);
+    log_e(LOG_TAG, "Invalid connectable mode: %u", mode);
     return false;
   }
 
@@ -90,7 +89,7 @@ bool BLEAdvertising::setDiscoverableMode(uint8_t mode) {
     case BLE_GAP_DISC_MODE_NON: m_advData.setFlags(BLE_HS_ADV_F_BREDR_UNSUP); break;
     case BLE_GAP_DISC_MODE_LTD: m_advData.setFlags(BLE_HS_ADV_F_DISC_LTD); break;
     case BLE_GAP_DISC_MODE_GEN: m_advData.setFlags(BLE_HS_ADV_F_DISC_GEN); break;
-    default:                    NIMBLE_LOGE(LOG_TAG, "Invalid discoverable mode: %u", mode); return false;
+    default:                    log_e(LOG_TAG, "Invalid discoverable mode: %u", mode); return false;
   }
 
   m_advParams.disc_mode = mode;
@@ -163,15 +162,15 @@ void BLEAdvertising::setScanFilter(bool scanRequestWhitelistOnly, bool connectWh
  * @return True if advertising started successfully.
  */
 bool BLEAdvertising::start(uint32_t duration, const BLEAddress *dirAddr) {
-  NIMBLE_LOGD(LOG_TAG, ">> Advertising start: duration=%" PRIu32 ", dirAddr=%s", duration, dirAddr ? dirAddr->toString().c_str() : "NULL");
+  log_d(LOG_TAG, ">> Advertising start: duration=%" PRIu32 ", dirAddr=%s", duration, dirAddr ? dirAddr->toString().c_str() : "NULL");
 
   if (!BLEDevice::m_synced) {
-    NIMBLE_LOGE(LOG_TAG, "Host not synced!");
+    log_e(LOG_TAG, "Host not synced!");
     return false;
   }
 
   if (ble_gap_adv_active()) {
-    NIMBLE_LOGW(LOG_TAG, "Advertising already active");
+    log_w(LOG_TAG, "Advertising already active");
     return true;
   }
 
@@ -209,11 +208,11 @@ bool BLEAdvertising::start(uint32_t duration, const BLEAddress *dirAddr) {
   int rc = ble_gap_adv_start(BLEDevice::m_ownAddrType, NULL, duration, &m_advParams, BLEAdvertising::handleGapEvent, this);
 #endif
   if (rc != 0 && rc != BLE_HS_EALREADY) {
-    NIMBLE_LOGE(LOG_TAG, "Error enabling advertising; rc=%d, %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "Error enabling advertising; rc=%d, %s", rc, BLEUtils::returnCodeToString(rc));
     return false;
   }
 
-  NIMBLE_LOGD(LOG_TAG, "<< Advertising start");
+  log_d(LOG_TAG, "<< Advertising start");
   return true;
 }  // start
 
@@ -224,7 +223,7 @@ bool BLEAdvertising::start(uint32_t duration, const BLEAddress *dirAddr) {
 bool BLEAdvertising::stop() {
   int rc = ble_gap_adv_stop();
   if (rc != 0 && rc != BLE_HS_EALREADY) {
-    NIMBLE_LOGE(LOG_TAG, "ble_gap_adv_stop rc=%d %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "ble_gap_adv_stop rc=%d %s", rc, BLEUtils::returnCodeToString(rc));
     return false;
   }
 
@@ -280,7 +279,7 @@ int BLEAdvertising::handleGapEvent(struct ble_gap_event *event, void *arg) {
       case BLE_HS_EOS:
       case BLE_HS_ECONTROLLER:
       case BLE_HS_ENOTSYNCED:
-        NIMBLE_LOGE(LOG_TAG, "host reset, rc=%d", event->adv_complete.reason);
+        log_e(LOG_TAG, "host reset, rc=%d", event->adv_complete.reason);
         BLEDevice::onReset(event->adv_complete.reason);
         return 0;
       default: break;
@@ -305,11 +304,11 @@ int BLEAdvertising::handleGapEvent(struct ble_gap_event *event, void *arg) {
 bool BLEAdvertising::setAdvertisementData(const BLEAdvertisementData &data) {
   int rc = ble_gap_adv_set_data(&data.getPayload()[0], data.getPayload().size());
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "ble_gap_adv_set_data: %d %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "ble_gap_adv_set_data: %d %s", rc, BLEUtils::returnCodeToString(rc));
     return false;
   }
 
-  NIMBLE_LOGD(LOG_TAG, "setAdvertisementData: %s", data.toString().c_str());
+  log_d(LOG_TAG, "setAdvertisementData: %s", data.toString().c_str());
   m_advData = data;     // make a copy in the member object in case this is custom.
   m_advDataSet = true;  // Set the flag that indicates the data was set already so we don't set it again.
   return true;
@@ -333,11 +332,11 @@ const BLEAdvertisementData &BLEAdvertising::getAdvertisementData() {
 bool BLEAdvertising::setScanResponseData(const BLEAdvertisementData &data) {
   int rc = ble_gap_adv_rsp_set_data(&data.getPayload()[0], data.getPayload().size());
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "ble_gap_adv_rsp_set_data: %d %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "ble_gap_adv_rsp_set_data: %d %s", rc, BLEUtils::returnCodeToString(rc));
     return false;
   }
 
-  NIMBLE_LOGD(LOG_TAG, "setScanResponseData: %s", data.toString().c_str());
+  log_d(LOG_TAG, "setScanResponseData: %s", data.toString().c_str());
   m_scanData = data;  // copy the data into the member object in case this is custom.
   return true;
 }  // setScanResponseData

libraries/NimBLE/src/BLEAttValue.cpp

@@ -21,7 +21,6 @@
 #include "nimble/nimble_npl.h"
 
 #include "BLEAttValue.h"
-#include "BLELog.h"
 
 static const char *LOG_TAG = "BLEAttValue";
 
@@ -36,7 +35,7 @@ BLEAttValue::BLEAttValue(uint16_t init_len, uint16_t max_len)
 {
   NIMBLE_CPP_DEBUG_ASSERT(m_attr_value);
   if (m_attr_value == nullptr) {
-    NIMBLE_LOGE(LOG_TAG, "Failed to calloc ctx");
+    log_e(LOG_TAG, "Failed to calloc ctx");
   }
 }
 
@@ -83,7 +82,7 @@ void BLEAttValue::deepCopy(const BLEAttValue &source) {
   uint8_t *res = static_cast<uint8_t *>(realloc(m_attr_value, source.m_capacity + 1));
   NIMBLE_CPP_DEBUG_ASSERT(res);
   if (res == nullptr) {
-    NIMBLE_LOGE(LOG_TAG, "Failed to realloc deepCopy");
+    log_e(LOG_TAG, "Failed to realloc deepCopy");
     return;
   }
 
@@ -111,7 +110,7 @@ BLEAttValue &BLEAttValue::append(const uint8_t *value, uint16_t len) {
   }
 
   if ((m_attr_len + len) > m_attr_max_len) {
-    NIMBLE_LOGE(LOG_TAG, "val > max, len=%u, max=%u", len, m_attr_max_len);
+    log_e(LOG_TAG, "val > max, len=%u, max=%u", len, m_attr_max_len);
     return *this;
   }
 
@@ -123,7 +122,7 @@ BLEAttValue &BLEAttValue::append(const uint8_t *value, uint16_t len) {
   }
   NIMBLE_CPP_DEBUG_ASSERT(res);
   if (res == nullptr) {
-    NIMBLE_LOGE(LOG_TAG, "Failed to realloc append");
+    log_e(LOG_TAG, "Failed to realloc append");
     return *this;
   }
 
@@ -147,7 +146,7 @@ BLEAttValue &BLEAttValue::append(const uint8_t *value, uint16_t len) {
 uint8_t BLEAttValue::operator[](int pos) const {
   NIMBLE_CPP_DEBUG_ASSERT(pos < m_attr_len);
   if (pos >= m_attr_len) {
-    NIMBLE_LOGE(LOG_TAG, "pos >= len, pos=%u, len=%u", pos, m_attr_len);
+    log_e(LOG_TAG, "pos >= len, pos=%u, len=%u", pos, m_attr_len);
     return 0;
   }
   return m_attr_value[pos];

libraries/NimBLE/src/BLEBeacon.cpp

@@ -20,7 +20,6 @@
 
 #include "BLEBeacon.h"
 #include "BLEUUID.h"
-#include "BLELog.h"
 
 #define ENDIAN_CHANGE_U16(x) ((((x) & 0xFF00) >> 8) + (((x) & 0xFF) << 8))
 
@@ -81,7 +80,7 @@ int8_t BLEBeacon::getSignalPower() {
  */
 void BLEBeacon::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);
+    log_e(LOG_TAG, "Data length must be %d bytes, sent: %d", sizeof(BeaconData), length);
     return;
   }
   memcpy(&m_beaconData, data, length);

libraries/NimBLE/src/BLECharacteristic.cpp

@@ -21,7 +21,6 @@
 #include "BLECharacteristic.h"
 #include "BLE2904.h"
 #include "BLEDevice.h"
-#include "BLELog.h"
 
 static BLECharacteristicCallbacks defaultCallback;
 static const char *LOG_TAG = "BLECharacteristic";
@@ -78,7 +77,7 @@ BLEDescriptor *BLECharacteristic::createDescriptor(const char *uuid, uint32_t pr
 BLEDescriptor *BLECharacteristic::createDescriptor(const BLEUUID &uuid, uint32_t properties, uint16_t maxLen) {
   BLEDescriptor *pDescriptor = nullptr;
   if (uuid == BLEUUID(static_cast<uint16_t>(0x2904))) {
-    NIMBLE_LOGW(LOG_TAG, "0x2904 descriptor should be created with create2904()");
+    log_w(LOG_TAG, "0x2904 descriptor should be created with create2904()");
     pDescriptor = create2904();
   } else {
     pDescriptor = new BLEDescriptor(uuid, properties, maxLen, this);
@@ -277,7 +276,7 @@ bool BLECharacteristic::sendValue(const uint8_t *value, size_t length, bool isNo
       // 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");
+        log_e(LOG_TAG, "<< sendValue: failed to allocate mbuf");
         return false;
       }
 
@@ -288,7 +287,7 @@ bool BLECharacteristic::sendValue(const uint8_t *value, size_t length, bool isNo
       }
 
       if (rc != 0) {
-        NIMBLE_LOGE(LOG_TAG, "<< sendValue: failed to send value, rc=%d %s", rc, BLEUtils::returnCodeToString(rc));
+        log_e(LOG_TAG, "<< sendValue: failed to send value, rc=%d %s", rc, BLEUtils::returnCodeToString(rc));
         break;
       }
     }
@@ -372,7 +371,7 @@ std::string BLECharacteristic::toString() const {
  * @param [in] connInfo A reference to a BLEConnInfo instance containing the peer info.
  */
 void BLECharacteristicCallbacks::onRead(BLECharacteristic *pCharacteristic, BLEConnInfo &connInfo) {
-  NIMBLE_LOGD("BLECharacteristicCallbacks", "onRead: default");
+  log_d("BLECharacteristicCallbacks", "onRead: default");
 }  // onRead
 
 /**
@@ -381,7 +380,7 @@ void BLECharacteristicCallbacks::onRead(BLECharacteristic *pCharacteristic, BLEC
  * @param [in] connInfo A reference to a BLEConnInfo instance containing the peer info.
  */
 void BLECharacteristicCallbacks::onWrite(BLECharacteristic *pCharacteristic, BLEConnInfo &connInfo) {
-  NIMBLE_LOGD("BLECharacteristicCallbacks", "onWrite: default");
+  log_d("BLECharacteristicCallbacks", "onWrite: default");
 }  // onWrite
 
 /**
@@ -392,7 +391,7 @@ void BLECharacteristicCallbacks::onWrite(BLECharacteristic *pCharacteristic, BLE
  * any other value is an error.
  */
 void BLECharacteristicCallbacks::onStatus(BLECharacteristic *pCharacteristic, int code) {
-  NIMBLE_LOGD("BLECharacteristicCallbacks", "onStatus: default");
+  log_d("BLECharacteristicCallbacks", "onStatus: default");
 }  // onStatus
 
 /**
@@ -406,7 +405,7 @@ void BLECharacteristicCallbacks::onStatus(BLECharacteristic *pCharacteristic, in
  * * 3 = Notifications and Indications
  */
 void BLECharacteristicCallbacks::onSubscribe(BLECharacteristic *pCharacteristic, BLEConnInfo &connInfo, uint16_t subValue) {
-  NIMBLE_LOGD("BLECharacteristicCallbacks", "onSubscribe: default");
+  log_d("BLECharacteristicCallbacks", "onSubscribe: default");
 }
 
 #endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */

libraries/NimBLE/src/BLEClient.cpp

@@ -20,7 +20,6 @@
 
 #include "BLEService.h"
 #include "BLEDescriptor.h"
-#include "BLELog.h"
 
 #include <string>
 
@@ -48,7 +47,7 @@ BLEDescriptor::BLEDescriptor(const BLEUUID &uuid, uint16_t properties, uint16_t
   : BLELocalValueAttribute{uuid, 0, max_len}, m_pCallbacks{&defaultCallbacks}, m_pCharacteristic{pCharacteristic} {
   // Check if this is the client configuration descriptor and set to removed if true.
   if (uuid == BLEUUID((uint16_t)0x2902)) {
-    NIMBLE_LOGW(LOG_TAG, "Manually created 2902 descriptor has no functionality; please remove.");
+    log_w(LOG_TAG, "Manually created 2902 descriptor has no functionality; please remove.");
     setRemoved(NIMBLE_ATT_REMOVE_HIDE);
   }
 
@@ -136,7 +135,7 @@ void BLEDescriptor::writeEvent(const uint8_t *val, uint16_t len, BLEConnInfo &co
  * @param [in] connInfo A reference to a BLEConnInfo instance containing the peer info.
  */
 void BLEDescriptorCallbacks::onRead(BLEDescriptor *pDescriptor, BLEConnInfo &connInfo) {
-  NIMBLE_LOGD("BLEDescriptorCallbacks", "onRead: default");
+  log_d("BLEDescriptorCallbacks", "onRead: default");
 }  // onRead
 
 /**
@@ -145,7 +144,7 @@ void BLEDescriptorCallbacks::onRead(BLEDescriptor *pDescriptor, BLEConnInfo &con
  * @param [in] connInfo A reference to a BLEConnInfo instance containing the peer info.
  */
 void BLEDescriptorCallbacks::onWrite(BLEDescriptor *pDescriptor, BLEConnInfo &connInfo) {
-  NIMBLE_LOGD("BLEDescriptorCallbacks", "onWrite: default");
+  log_d("BLEDescriptorCallbacks", "onWrite: default");
 }  // onWrite
 
 #endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */

libraries/NimBLE/src/BLEDescriptor.cpp

@@ -47,8 +47,6 @@
 #include "BLEServer.h"
 #endif
 
-#include "BLELog.h"
-
 static const char *LOG_TAG = "BLEDevice";
 
 extern "C" void ble_store_config_init(void);
@@ -214,7 +212,7 @@ BLEScan *BLEDevice::getScan() {
  */
 void BLEDevice::setScanDuplicateCacheSize(uint16_t size) {
   if (m_initialized) {
-    NIMBLE_LOGE(LOG_TAG, "Cannot change scan cache size while initialized");
+    log_e(LOG_TAG, "Cannot change scan cache size while initialized");
     return;
   } else {
     if (size > 1000) {
@@ -224,7 +222,7 @@ void BLEDevice::setScanDuplicateCacheSize(uint16_t size) {
     }
   }
 
-  NIMBLE_LOGD(LOG_TAG, "Set duplicate cache size to: %u", size);
+  log_d(LOG_TAG, "Set duplicate cache size to: %u", size);
   m_scanDuplicateSize = size;
 }
 
@@ -243,10 +241,10 @@ void BLEDevice::setScanDuplicateCacheSize(uint16_t size) {
  */
 void BLEDevice::setScanFilterMode(uint8_t mode) {
   if (m_initialized) {
-    NIMBLE_LOGE(LOG_TAG, "Cannot change scan duplicate type while initialized");
+    log_e(LOG_TAG, "Cannot change scan duplicate type while initialized");
     return;
   } else if (mode > 2) {
-    NIMBLE_LOGE(LOG_TAG, "Invalid scan duplicate type");
+    log_e(LOG_TAG, "Invalid scan duplicate type");
     return;
   }
 
@@ -282,7 +280,7 @@ BLEClient *BLEDevice::createClient(const BLEAddress &peerAddress) {
     }
   }
 
-  NIMBLE_LOGE(LOG_TAG, "Unable to create client; already at max: %d", NIMBLE_MAX_CONNECTIONS);
+  log_e(LOG_TAG, "Unable to create client; already at max: %d", NIMBLE_MAX_CONNECTIONS);
   return nullptr;
 }  // createClient
 
@@ -426,7 +424,7 @@ esp_power_level_t BLEDevice::getPowerLevel(esp_ble_power_type_t powerType) {
 bool BLEDevice::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);
+    log_e(LOG_TAG, "esp_ble_tx_power_set: rc=%d", errRc);
   }
 
   return errRc == ESP_OK;
@@ -478,7 +476,7 @@ int BLEDevice::getPower(BLETxPowerType type) {
 
   int pwr = getPowerLevel(espPwr);
   if (pwr < 0) {
-    NIMBLE_LOGE(LOG_TAG, "esp_ble_tx_power_get failed rc=%d", pwr);
+    log_e(LOG_TAG, "esp_ble_tx_power_get failed rc=%d", pwr);
     return 0xFF;
   }
 
@@ -507,7 +505,7 @@ int BLEDevice::getPower(BLETxPowerType type) {
 bool BLEDevice::setMTU(uint16_t mtu) {
   int rc = ble_att_set_preferred_mtu(mtu);
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "Could not set local mtu value to: %d, rc: %d", mtu, rc);
+    log_e(LOG_TAG, "Could not set local mtu value to: %d, rc: %d", mtu, rc);
   }
 
   return rc == 0;
@@ -547,7 +545,7 @@ int BLEDevice::getNumBonds() {
 bool BLEDevice::deleteAllBonds() {
   int rc = ble_store_clear();
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "Failed to delete all bonds; rc=%d", rc);
+    log_e(LOG_TAG, "Failed to delete all bonds; rc=%d", rc);
     return false;
   }
   return true;
@@ -632,7 +630,7 @@ bool BLEDevice::whiteListAdd(const BLEAddress &address) {
     m_whiteList.push_back(address);
     int rc = ble_gap_wl_set(reinterpret_cast<ble_addr_t *>(&m_whiteList[0]), m_whiteList.size());
     if (rc != 0) {
-      NIMBLE_LOGE(LOG_TAG, "Failed adding to whitelist rc=%d", rc);
+      log_e(LOG_TAG, "Failed adding to whitelist rc=%d", rc);
       m_whiteList.pop_back();
       return false;
     }
@@ -653,7 +651,7 @@ bool BLEDevice::whiteListRemove(const BLEAddress &address) {
       int rc = ble_gap_wl_set(reinterpret_cast<ble_addr_t *>(&m_whiteList[0]), m_whiteList.size());
       if (rc != 0) {
         m_whiteList.push_back(address);
-        NIMBLE_LOGE(LOG_TAG, "Failed removing from whitelist rc=%d", rc);
+        log_e(LOG_TAG, "Failed removing from whitelist rc=%d", rc);
         return false;
       }
 
@@ -679,7 +677,7 @@ size_t BLEDevice::getWhiteListCount() {
  */
 BLEAddress BLEDevice::getWhiteListAddress(size_t index) {
   if (index > m_whiteList.size()) {
-    NIMBLE_LOGE(LOG_TAG, "Invalid index; %u", index);
+    log_e(LOG_TAG, "Invalid index; %u", index);
     return BLEAddress{};
   }
 
@@ -708,7 +706,7 @@ BLEAddress BLEDevice::getWhiteListAddress(size_t index) {
 bool BLEDevice::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, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "Failed to set default phy; rc=%d %s", rc, BLEUtils::returnCodeToString(rc));
   }
 
   return rc == 0;
@@ -726,14 +724,14 @@ void BLEDevice::onReset(int reason) {
 
   m_synced = false;
 
-  NIMBLE_LOGE(LOG_TAG, "Host reset; reason=%d, %s", reason, BLEUtils::returnCodeToString(reason));
+  log_e(LOG_TAG, "Host reset; reason=%d, %s", reason, BLEUtils::returnCodeToString(reason));
 }  // onReset
 
 /**
  * @brief Host synced with controller, all clear to make calls to the stack.
  */
 void BLEDevice::onSync(void) {
-  NIMBLE_LOGI(LOG_TAG, "NimBle host synced.");
+  log_i(LOG_TAG, "NimBle host synced.");
   // This check is needed due to potentially being called multiple times in succession
   // If this happens, the call to scan start may get stuck or cause an advertising fault.
   if (m_synced) {
@@ -747,7 +745,7 @@ void BLEDevice::onSync(void) {
   }
 
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "error ensuring address; rc=%d", rc);
+    log_e(LOG_TAG, "error ensuring address; rc=%d", rc);
     return;
   }
 
@@ -782,7 +780,7 @@ void BLEDevice::onSync(void) {
  * @brief The main host task.
  */
 void BLEDevice::host_task(void *param) {
-  NIMBLE_LOGI(LOG_TAG, "BLE Host Task Started");
+  log_i(LOG_TAG, "BLE Host Task Started");
   nimble_port_run();  // This function will return only when nimble_port_stop() is executed
   nimble_port_freertos_deinit();
 }  // host_task
@@ -805,7 +803,7 @@ bool BLEDevice::init(const std::string &deviceName) {
     }
 
     if (err != ESP_OK) {
-      NIMBLE_LOGE(LOG_TAG, "nvs_flash_init() failed; err=%d", err);
+      log_e(LOG_TAG, "nvs_flash_init() failed; err=%d", err);
       return false;
     }
 
@@ -829,19 +827,19 @@ bool BLEDevice::init(const std::string &deviceName) {
 #   endif
         err = esp_bt_controller_init(&bt_cfg);
         if (err != ESP_OK) {
-            NIMBLE_LOGE(LOG_TAG, "esp_bt_controller_init() failed; err=%d", err);
+            log_e(LOG_TAG, "esp_bt_controller_init() failed; err=%d", err);
             return false;
         }
 
         err = esp_bt_controller_enable(ESP_BT_MODE_BLE);
         if (err != ESP_OK) {
-            NIMBLE_LOGE(LOG_TAG, "esp_bt_controller_enable() failed; err=%d", err);
+            log_e(LOG_TAG, "esp_bt_controller_enable() failed; err=%d", err);
             return false;
         }
 
         err = esp_nimble_hci_init();
         if (err != ESP_OK) {
-            NIMBLE_LOGE(LOG_TAG, "esp_nimble_hci_init() failed; err=%d", err);
+            log_e(LOG_TAG, "esp_nimble_hci_init() failed; err=%d", err);
             return false;
         }
 #  endif
@@ -895,7 +893,7 @@ bool BLEDevice::deinit(bool clearAll) {
 #if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
       rc = esp_nimble_hci_and_controller_deinit();
       if (rc != ESP_OK) {
-        NIMBLE_LOGE(LOG_TAG, "esp_nimble_hci_and_controller_deinit() failed with error: %d", rc);
+        log_e(LOG_TAG, "esp_nimble_hci_and_controller_deinit() failed with error: %d", rc);
       }
 #endif
       m_initialized = false;
@@ -956,7 +954,7 @@ BLEAddress BLEDevice::getAddress() {
   uint8_t type = m_ownAddrType & 1;  // input must be random or public, odd values are random
   int rc = ble_hs_id_copy_addr(type, addr.val, NULL);
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "No address, rc: %d", rc);
+    log_e(LOG_TAG, "No address, rc: %d", rc);
   } else {
     addr.type = type;
   }
@@ -976,7 +974,7 @@ BLEAddress BLEDevice::getAddress() {
 bool BLEDevice::setOwnAddrType(uint8_t type) {
   int rc = ble_hs_id_copy_addr(type & 1, NULL, NULL);  // Odd values are random
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "Unable to set address type %d, rc=%d", type, rc);
+    log_e(LOG_TAG, "Unable to set address type %d, rc=%d", type, rc);
     return false;
   }
 
@@ -1017,7 +1015,7 @@ bool BLEDevice::setOwnAddr(const BLEAddress &addr) {
 bool BLEDevice::setOwnAddr(const uint8_t *addr) {
   int rc = ble_hs_id_set_rnd(addr);
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "Failed to set address, rc=%d", rc);
+    log_e(LOG_TAG, "Failed to set address, rc=%d", rc);
     return false;
   }
 
@@ -1035,7 +1033,7 @@ bool BLEDevice::setOwnAddr(const uint8_t *addr) {
  * @param sc If true we will perform secure connection pairing, false we will use legacy pairing.
  */
 void BLEDevice::setSecurityAuth(bool bonding, bool mitm, bool sc) {
-  NIMBLE_LOGD(LOG_TAG, "Setting bonding: %d, mitm: %d, sc: %d", bonding, mitm, sc);
+  log_d(LOG_TAG, "Setting bonding: %d, mitm: %d, sc: %d", bonding, mitm, sc);
   ble_hs_cfg.sm_bonding = bonding;
   ble_hs_cfg.sm_mitm = mitm;
   ble_hs_cfg.sm_sc = sc;
@@ -1118,7 +1116,7 @@ uint32_t BLEDevice::getSecurityPasskey() {
 bool BLEDevice::startSecurity(uint16_t connHandle, int *rcPtr) {
   int rc = ble_gap_security_initiate(connHandle);
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "ble_gap_security_initiate: rc=%d %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "ble_gap_security_initiate: rc=%d %s", rc, BLEUtils::returnCodeToString(rc));
   }
   if (rcPtr) {
     *rcPtr = rc;
@@ -1136,7 +1134,7 @@ bool BLEDevice::startSecurity(uint16_t connHandle, int *rcPtr) {
 bool BLEDevice::injectPassKey(const BLEConnInfo &peerInfo, uint32_t passkey) {
   ble_sm_io pkey{.action = BLE_SM_IOACT_INPUT, .passkey = passkey};
   int rc = ble_sm_inject_io(peerInfo.getConnHandle(), &pkey);
-  NIMBLE_LOGD(LOG_TAG, "BLE_SM_IOACT_INPUT; ble_sm_inject_io result: %d", rc);
+  log_d(LOG_TAG, "BLE_SM_IOACT_INPUT; ble_sm_inject_io result: %d", rc);
   return rc == 0;
 }
 
@@ -1148,7 +1146,7 @@ bool BLEDevice::injectPassKey(const BLEConnInfo &peerInfo, uint32_t passkey) {
 bool BLEDevice::injectConfirmPasskey(const BLEConnInfo &peerInfo, bool accept) {
   ble_sm_io pkey{.action = BLE_SM_IOACT_NUMCMP, .numcmp_accept = accept};
   int rc = ble_sm_inject_io(peerInfo.getConnHandle(), &pkey);
-  NIMBLE_LOGD(LOG_TAG, "BLE_SM_IOACT_NUMCMP; ble_sm_inject_io result: %d", rc);
+  log_d(LOG_TAG, "BLE_SM_IOACT_NUMCMP; ble_sm_inject_io result: %d", rc);
   return rc == 0;
 }
 #endif  // CONFIG_BT_NIMBLE_ROLE_CENTRAL || CONFIG_BT_NIMBLE_ROLE_PERIPHERAL
@@ -1164,7 +1162,7 @@ bool BLEDevice::injectConfirmPasskey(const BLEConnInfo &peerInfo, bool accept) {
 bool BLEDevice::setDeviceName(const std::string &deviceName) {
   int rc = ble_svc_gap_device_name_set(deviceName.c_str());
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "Device name not set - too long");
+    log_e(LOG_TAG, "Device name not set - too long");
     return false;
   }
 
@@ -1179,10 +1177,10 @@ bool BLEDevice::setDeviceName(const std::string &deviceName) {
 bool BLEDevice::setCustomGapHandler(gap_event_handler handler) {
   int rc = ble_gap_event_listener_register(&m_listener, handler, NULL);
   if (rc == BLE_HS_EALREADY) {
-    NIMBLE_LOGI(LOG_TAG, "Already listening to GAP events.");
+    log_i(LOG_TAG, "Already listening to GAP events.");
     return true;
   } else if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "ble_gap_event_listener_register: rc=%d %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "ble_gap_event_listener_register: rc=%d %s", rc, BLEUtils::returnCodeToString(rc));
   }
 
   return rc == 0;

libraries/NimBLE/src/BLEDevice.cpp

@@ -20,7 +20,6 @@
 
 #include "BLEEddystoneTLM.h"
 #include "BLEUUID.h"
-#include "BLELog.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))
@@ -146,7 +145,7 @@ std::string BLEEddystoneTLM::toString() {
  */
 void BLEEddystoneTLM::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));
+    log_e(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);
@@ -166,7 +165,7 @@ void BLEEddystoneTLM::setData(const BLEEddystoneTLM::BeaconData &data) {
  */
 void BLEEddystoneTLM::setUUID(const BLEUUID &uuid) {
   if (uuid.bitSize() != 16) {
-    NIMBLE_LOGE(LOG_TAG, "UUID must be 16 bits");
+    log_e(LOG_TAG, "UUID must be 16 bits");
     return;
   }
   beaconUUID = *reinterpret_cast<const uint16_t *>(uuid.getValue());

libraries/NimBLE/src/BLEEddystoneTLM.cpp

@@ -24,7 +24,6 @@
 #include "BLEDevice.h"
 #include "BLEServer.h"
 #include "BLEUtils.h"
-#include "BLELog.h"
 
 static BLEExtAdvertisingCallbacks defaultCallbacks;
 static const char *LOG_TAG = "BLEExtAdvertising";
@@ -75,20 +74,20 @@ bool BLEExtAdvertising::setInstanceData(uint8_t instId, BLEExtAdvertisement &adv
 #endif
 
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "Advertising config error: rc = %d %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "Advertising config error: rc = %d %s", rc, BLEUtils::returnCodeToString(rc));
     return false;
   }
 
   os_mbuf *buf;
   buf = os_msys_get_pkthdr(adv.m_payload.size(), 0);
   if (!buf) {
-    NIMBLE_LOGE(LOG_TAG, "Data buffer allocation failed");
+    log_e(LOG_TAG, "Data buffer allocation failed");
     return false;
   }
 
   rc = os_mbuf_append(buf, &adv.m_payload[0], adv.m_payload.size());
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "Unable to copy data: rc = %d %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "Unable to copy data: rc = %d %s", rc, BLEUtils::returnCodeToString(rc));
     return false;
   }
 
@@ -99,7 +98,7 @@ bool BLEExtAdvertising::setInstanceData(uint8_t instId, BLEExtAdvertisement &adv
   }
 
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "Invalid advertisement data: rc = %d %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "Invalid advertisement data: rc = %d %s", rc, BLEUtils::returnCodeToString(rc));
     return false;
   }
 
@@ -108,7 +107,7 @@ bool BLEExtAdvertising::setInstanceData(uint8_t instId, BLEExtAdvertisement &adv
   }
 
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "Error setting advertisement address: rc = %d %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "Error setting advertisement address: rc = %d %s", rc, BLEUtils::returnCodeToString(rc));
     return false;
   }
 
@@ -123,13 +122,13 @@ bool BLEExtAdvertising::setInstanceData(uint8_t instId, BLEExtAdvertisement &adv
 bool BLEExtAdvertising::setScanResponseData(uint8_t instId, BLEExtAdvertisement &data) {
   os_mbuf *buf = os_msys_get_pkthdr(data.m_payload.size(), 0);
   if (!buf) {
-    NIMBLE_LOGE(LOG_TAG, "Data buffer allocation failed");
+    log_e(LOG_TAG, "Data buffer allocation failed");
     return false;
   }
 
   int rc = os_mbuf_append(buf, &data.m_payload[0], data.m_payload.size());
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "Unable to copy scan data: rc = %d %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "Unable to copy scan data: rc = %d %s", rc, BLEUtils::returnCodeToString(rc));
     return false;
   }
 
@@ -147,13 +146,13 @@ bool BLEExtAdvertising::setScanResponseData(uint8_t instId, BLEExtAdvertisement
 bool BLEExtAdvertising::start(uint8_t instId, int duration, int maxEvents) {
   // If Host is not synced we cannot start advertising.
   if (!BLEDevice::m_synced) {
-    NIMBLE_LOGE(LOG_TAG, "Host reset, wait for sync.");
+    log_e(LOG_TAG, "Host reset, wait for sync.");
     return false;
   }
 
   int rc = ble_gap_ext_adv_start(instId, duration / 10, maxEvents);
   if (rc != 0 && rc != BLE_HS_EALREADY) {
-    NIMBLE_LOGE(LOG_TAG, "Error enabling advertising; rc=%d, %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "Error enabling advertising; rc=%d, %s", rc, BLEUtils::returnCodeToString(rc));
     return false;
   }
 
@@ -173,7 +172,7 @@ bool BLEExtAdvertising::removeInstance(uint8_t instId) {
       return true;
     }
 
-    NIMBLE_LOGE(LOG_TAG, "ble_gap_ext_adv_remove rc = %d %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "ble_gap_ext_adv_remove rc = %d %s", rc, BLEUtils::returnCodeToString(rc));
   }
 
   return false;
@@ -190,7 +189,7 @@ bool BLEExtAdvertising::removeAll() {
       return true;
     }
 
-    NIMBLE_LOGE(LOG_TAG, "ble_gap_ext_adv_clear rc = %d %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "ble_gap_ext_adv_clear rc = %d %s", rc, BLEUtils::returnCodeToString(rc));
   }
 
   return false;
@@ -208,7 +207,7 @@ bool BLEExtAdvertising::stop(uint8_t instId) {
     return true;
   }
 
-  NIMBLE_LOGE(LOG_TAG, "ble_gap_ext_adv_stop rc = %d %s", rc, BLEUtils::returnCodeToString(rc));
+  log_e(LOG_TAG, "ble_gap_ext_adv_stop rc = %d %s", rc, BLEUtils::returnCodeToString(rc));
   return false;
 }  // stop
 
@@ -225,7 +224,7 @@ bool BLEExtAdvertising::stop() {
     return true;
   }
 
-  NIMBLE_LOGE(LOG_TAG, "ble_gap_ext_adv_stop rc = %d %s", rc, BLEUtils::returnCodeToString(rc));
+  log_e(LOG_TAG, "ble_gap_ext_adv_stop rc = %d %s", rc, BLEUtils::returnCodeToString(rc));
   return false;
 }  // stop
 
@@ -272,7 +271,7 @@ bool BLEExtAdvertising::isAdvertising() {
  * we need clear the flag so it reloads it.
  */
 void BLEExtAdvertising::onHostSync() {
-  NIMBLE_LOGD(LOG_TAG, "Host re-synced");
+  log_d(LOG_TAG, "Host re-synced");
   for (auto status : m_advStatus) {
     status = false;
   }
@@ -297,7 +296,7 @@ int BLEExtAdvertising::handleGapEvent(ble_gap_event *event, void *arg) {
         case BLE_HS_EOS:
         case BLE_HS_ECONTROLLER:
         case BLE_HS_ENOTSYNCED:
-          NIMBLE_LOGE(LOG_TAG, "host reset, rc = %d", event->adv_complete.reason);
+          log_e(LOG_TAG, "host reset, rc = %d", event->adv_complete.reason);
           BLEDevice::onReset(event->adv_complete.reason);
           return 0;
         default: break;
@@ -322,11 +321,11 @@ int BLEExtAdvertising::handleGapEvent(ble_gap_event *event, void *arg) {
 /* -------------------------------------------------------------------------- */
 
 void BLEExtAdvertisingCallbacks::onStopped(BLEExtAdvertising *pAdv, int reason, uint8_t instId) {
-  NIMBLE_LOGD("BLEExtAdvertisingCallbacks", "onStopped: Default");
+  log_d("BLEExtAdvertisingCallbacks", "onStopped: Default");
 }  // onStopped
 
 void BLEExtAdvertisingCallbacks::onScanRequest(BLEExtAdvertising *pAdv, uint8_t instId, BLEAddress addr) {
-  NIMBLE_LOGD("BLEExtAdvertisingCallbacks", "onScanRequest: Default");
+  log_d("BLEExtAdvertisingCallbacks", "onScanRequest: Default");
 }  // onScanRequest
 
 /* -------------------------------------------------------------------------- */
@@ -682,7 +681,7 @@ bool BLEExtAdvertisement::addServiceUUID(const BLEUUID &serviceUUID) {
     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: NIMBLE_LOGE(LOG_TAG, "Cannot add UUID, invalid size!"); return false;
+    default: log_e(LOG_TAG, "Cannot add UUID, invalid size!"); return false;
   }
 
   int dataLoc = getDataLocation(type);
@@ -692,7 +691,7 @@ bool BLEExtAdvertisement::addServiceUUID(const BLEUUID &serviceUUID) {
   }
 
   if (length + getDataSize() > CONFIG_BT_NIMBLE_MAX_EXT_ADV_DATA_LEN) {
-    NIMBLE_LOGE(LOG_TAG, "Cannot add UUID, data length exceeded!");
+    log_e(LOG_TAG, "Cannot add UUID, data length exceeded!");
     return false;
   }
 
@@ -731,7 +730,7 @@ bool BLEExtAdvertisement::removeServiceUUID(const BLEUUID &serviceUUID) {
     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: NIMBLE_LOGE(LOG_TAG, "Cannot remove UUID, invalid size!"); return false;
+    default: log_e(LOG_TAG, "Cannot remove UUID, invalid size!"); return false;
   }
 
   int dataLoc = getDataLocation(type);
@@ -846,20 +845,20 @@ bool BLEExtAdvertisement::setServices(bool complete, uint8_t size, const std::ve
     case 16:  header[1] = complete ? BLE_HS_ADV_TYPE_COMP_UUIDS16 : BLE_HS_ADV_TYPE_INCOMP_UUIDS16; break;
     case 32:  header[1] = complete ? BLE_HS_ADV_TYPE_COMP_UUIDS32 : BLE_HS_ADV_TYPE_INCOMP_UUIDS32; break;
     case 128: header[1] = complete ? BLE_HS_ADV_TYPE_COMP_UUIDS128 : BLE_HS_ADV_TYPE_INCOMP_UUIDS128; break;
-    default:  NIMBLE_LOGE(LOG_TAG, "Cannot set services, invalid size!"); return false;
+    default:  log_e(LOG_TAG, "Cannot set services, invalid size!"); return false;
   }
 
   if (addData(header, 2)) {
     int count = 0;
     for (const auto &uuid : uuids) {
       if (uuid.bitSize() != size) {
-        NIMBLE_LOGE(LOG_TAG, "Service UUID(%d) invalid", size);
+        log_e(LOG_TAG, "Service UUID(%d) invalid", size);
         continue;
       } else {
         if (addData(uuid.getValue(), uuidBytes)) {
           count++;
         } else {
-          NIMBLE_LOGE(LOG_TAG, "Error setting service UUIDs");
+          log_e(LOG_TAG, "Error setting service UUIDs");
           m_payload.erase(m_payload.end() - 2 - (count * uuidBytes), m_payload.end());
           return false;
         }
@@ -893,7 +892,7 @@ bool BLEExtAdvertisement::setServiceData(const BLEUUID &uuid, const uint8_t *dat
     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: NIMBLE_LOGE(LOG_TAG, "Cannot set service data, invalid size!"); return false;
+    default: log_e(LOG_TAG, "Cannot set service data, invalid size!"); return false;
   }
 
   if (length == 0) {

libraries/NimBLE/src/BLEExtAdvertising.cpp

@@ -23,7 +23,6 @@
 #include "BLERemoteService.h"
 #include "BLEClient.h"
 #include "BLEUtils.h"
-#include "BLELog.h"
 
 #include <climits>
 
@@ -66,7 +65,7 @@ int BLERemoteCharacteristic::descriptorDiscCB(uint16_t connHandle, const ble_gat
   auto pTaskData = (BLETaskData *)filter->taskData;
   const auto pChr = (BLERemoteCharacteristic *)pTaskData->m_pInstance;
   const auto uuid = filter->uuid;  // UUID to filter for
-  NIMBLE_LOGD(LOG_TAG, "Descriptor Discovery >> status: %d handle: %d", rc, (rc == 0) ? dsc->handle : -1);
+  log_d(LOG_TAG, "Descriptor Discovery >> status: %d handle: %d", rc, (rc == 0) ? dsc->handle : -1);
 
   // Results for chrHandle added until rc != 0
   // Must find specified UUID if filter is used
@@ -78,7 +77,7 @@ int BLERemoteCharacteristic::descriptorDiscCB(uint16_t connHandle, const ble_gat
 
   if (rc != 0) {
     BLEUtils::taskRelease(*pTaskData, rc);
-    NIMBLE_LOGD(LOG_TAG, "<< Descriptor Discovery");
+    log_d(LOG_TAG, "<< Descriptor Discovery");
   }
   return rc;
 }
@@ -89,30 +88,30 @@ int BLERemoteCharacteristic::descriptorDiscCB(uint16_t connHandle, const ble_gat
  * @return True if successfully retrieved, success = BLE_HS_EDONE.
  */
 bool BLERemoteCharacteristic::retrieveDescriptors(BLEDescriptorFilter *filter) const {
-  NIMBLE_LOGD(LOG_TAG, ">> retrieveDescriptors() for characteristic: %s", getUUID().toString().c_str());
+  log_d(LOG_TAG, ">> retrieveDescriptors() for characteristic: %s", getUUID().toString().c_str());
 
   // If this is the last handle then there are no descriptors
   if (getHandle() == getRemoteService()->getEndHandle()) {
-    NIMBLE_LOGD(LOG_TAG, "<< retrieveDescriptors(): found 0 descriptors.");
+    log_d(LOG_TAG, "<< retrieveDescriptors(): found 0 descriptors.");
     return true;
   }
 
   int rc =
     ble_gattc_disc_all_dscs(getClient()->getConnHandle(), getHandle(), getRemoteService()->getEndHandle(), BLERemoteCharacteristic::descriptorDiscCB, filter);
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "ble_gattc_disc_all_dscs: rc=%d %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "ble_gattc_disc_all_dscs: rc=%d %s", rc, BLEUtils::returnCodeToString(rc));
     return false;
   }
 
   BLEUtils::taskWait(filter->taskData, BLE_NPL_TIME_FOREVER);
   rc = ((BLETaskData *)filter->taskData)->m_flags;
   if (rc != BLE_HS_EDONE) {
-    NIMBLE_LOGE(LOG_TAG, "<< retrieveDescriptors(): failed: rc=%d %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "<< retrieveDescriptors(): failed: rc=%d %s", rc, BLEUtils::returnCodeToString(rc));
     return false;
   }
 
   filter->dsc = m_vDescriptors.back();
-  NIMBLE_LOGD(LOG_TAG, "<< retrieveDescriptors(): found %d descriptors.", m_vDescriptors.size());
+  log_d(LOG_TAG, "<< retrieveDescriptors(): found %d descriptors.", m_vDescriptors.size());
   return true;
 }  // retrieveDescriptors
 
@@ -122,7 +121,7 @@ bool BLERemoteCharacteristic::retrieveDescriptors(BLEDescriptorFilter *filter) c
  * @return The Remote descriptor (if present) or nullptr if not present.
  */
 BLERemoteDescriptor *BLERemoteCharacteristic::getDescriptor(const BLEUUID &uuid) const {
-  NIMBLE_LOGD(LOG_TAG, ">> getDescriptor: uuid: %s", uuid.toString().c_str());
+  log_d(LOG_TAG, ">> getDescriptor: uuid: %s", uuid.toString().c_str());
   BLETaskData taskData(const_cast<BLERemoteCharacteristic *>(this));
   BLEDescriptorFilter filter = {nullptr, &uuid, &taskData};
   BLEUUID uuidTmp;
@@ -151,7 +150,7 @@ BLERemoteDescriptor *BLERemoteCharacteristic::getDescriptor(const BLEUUID &uuid)
   }
 
 Done:
-  NIMBLE_LOGD(LOG_TAG, "<< getDescriptor: %sfound", filter.dsc ? "" : "not ");
+  log_d(LOG_TAG, "<< getDescriptor: %sfound", filter.dsc ? "" : "not ");
   return filter.dsc;
 }  // getDescriptor
 
@@ -205,16 +204,16 @@ const BLERemoteService *BLERemoteCharacteristic::getRemoteService() const {
  * @return false if writing to the descriptor failed.
  */
 bool BLERemoteCharacteristic::setNotify(uint16_t val, notify_callback notifyCallback, bool response) const {
-  NIMBLE_LOGD(LOG_TAG, ">> setNotify()");
+  log_d(LOG_TAG, ">> setNotify()");
 
   m_notifyCallback = notifyCallback;
   BLERemoteDescriptor *desc = getDescriptor(BLEUUID((uint16_t)0x2902));
   if (desc == nullptr) {
-    NIMBLE_LOGW(LOG_TAG, "<< setNotify(): Callback set, CCCD not found");
+    log_w(LOG_TAG, "<< setNotify(): Callback set, CCCD not found");
     return true;
   }
 
-  NIMBLE_LOGD(LOG_TAG, "<< setNotify()");
+  log_d(LOG_TAG, "<< setNotify()");
   return desc->writeValue(reinterpret_cast<uint8_t *>(&val), 2, response);
 }  // setNotify
 
@@ -246,14 +245,14 @@ bool BLERemoteCharacteristic::unsubscribe(bool response) const {
  * them. This method does just that.
  */
 void BLERemoteCharacteristic::deleteDescriptors() const {
-  NIMBLE_LOGD(LOG_TAG, ">> deleteDescriptors");
+  log_d(LOG_TAG, ">> deleteDescriptors");
 
   for (const auto &it : m_vDescriptors) {
     delete it;
   }
   std::vector<BLERemoteDescriptor *>().swap(m_vDescriptors);
 
-  NIMBLE_LOGD(LOG_TAG, "<< deleteDescriptors");
+  log_d(LOG_TAG, "<< deleteDescriptors");
 }  // deleteDescriptors
 
 /**
@@ -262,7 +261,7 @@ void BLERemoteCharacteristic::deleteDescriptors() const {
  * @return Number of descriptors left in the vector.
  */
 size_t BLERemoteCharacteristic::deleteDescriptor(const BLEUUID &uuid) const {
-  NIMBLE_LOGD(LOG_TAG, ">> deleteDescriptor");
+  log_d(LOG_TAG, ">> deleteDescriptor");
 
   for (auto it = m_vDescriptors.begin(); it != m_vDescriptors.end(); ++it) {
     if ((*it)->getUUID() == uuid) {
@@ -272,7 +271,7 @@ size_t BLERemoteCharacteristic::deleteDescriptor(const BLEUUID &uuid) const {
     }
   }
 
-  NIMBLE_LOGD(LOG_TAG, "<< deleteDescriptor");
+  log_d(LOG_TAG, "<< deleteDescriptor");
   return m_vDescriptors.size();
 }  // deleteDescriptor
 

libraries/NimBLE/src/BLELog.h

@@ -23,7 +23,6 @@
 #include "BLEClient.h"
 #include "BLEAttValue.h"
 #include "BLEUtils.h"
-#include "BLELog.h"
 
 #include <climits>
 
@@ -75,7 +74,7 @@ BLERemoteCharacteristic *BLERemoteService::getCharacteristic(const char *uuid) c
  * @return A pointer to the characteristic object, or nullptr if not found.
  */
 BLERemoteCharacteristic *BLERemoteService::getCharacteristic(const BLEUUID &uuid) const {
-  NIMBLE_LOGD(LOG_TAG, ">> getCharacteristic: uuid: %s", uuid.toString().c_str());
+  log_d(LOG_TAG, ">> getCharacteristic: uuid: %s", uuid.toString().c_str());
   BLERemoteCharacteristic *pChar = nullptr;
   size_t prev_size = m_vChars.size();
 
@@ -119,7 +118,7 @@ BLERemoteCharacteristic *BLERemoteService::getCharacteristic(const BLEUUID &uuid
   }
 
 Done:
-  NIMBLE_LOGD(LOG_TAG, "<< Characteristic %sfound", pChar ? "" : "not ");
+  log_d(LOG_TAG, "<< Characteristic %sfound", pChar ? "" : "not ");
   return pChar;
 }  // getCharacteristic
 
@@ -144,12 +143,12 @@ const std::vector<BLERemoteCharacteristic *> &BLERemoteService::getCharacteristi
  * @return success == 0 or error code.
  */
 int BLERemoteService::characteristicDiscCB(uint16_t conn_handle, const ble_gatt_error *error, const ble_gatt_chr *chr, void *arg) {
-  NIMBLE_LOGD(LOG_TAG, "Characteristic Discovery >> status: %d handle: %d", error->status, (error->status == 0) ? chr->def_handle : -1);
+  log_d(LOG_TAG, "Characteristic Discovery >> status: %d handle: %d", error->status, (error->status == 0) ? chr->def_handle : -1);
   auto pTaskData = (BLETaskData *)arg;
   const auto pSvc = (BLERemoteService *)pTaskData->m_pInstance;
 
   if (error->status == BLE_HS_ENOTCONN) {
-    NIMBLE_LOGE(LOG_TAG, "<< Characteristic Discovery; Not connected");
+    log_e(LOG_TAG, "<< Characteristic Discovery; Not connected");
     BLEUtils::taskRelease(*pTaskData, error->status);
     return error->status;
   }
@@ -165,7 +164,7 @@ int BLERemoteService::characteristicDiscCB(uint16_t conn_handle, const ble_gatt_
   }
 
   BLEUtils::taskRelease(*pTaskData, error->status);
-  NIMBLE_LOGD(LOG_TAG, "<< Characteristic Discovery");
+  log_d(LOG_TAG, "<< Characteristic Discovery");
   return error->status;
 }
 
@@ -175,7 +174,7 @@ int BLERemoteService::characteristicDiscCB(uint16_t conn_handle, const ble_gatt_
  * @return True if successful.
  */
 bool BLERemoteService::retrieveCharacteristics(const BLEUUID *uuidFilter) const {
-  NIMBLE_LOGD(LOG_TAG, ">> retrieveCharacteristics()");
+  log_d(LOG_TAG, ">> retrieveCharacteristics()");
   int rc = 0;
   BLETaskData taskData(const_cast<BLERemoteService *>(this));
 
@@ -188,18 +187,18 @@ bool BLERemoteService::retrieveCharacteristics(const BLEUUID *uuidFilter) const
   }
 
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "ble_gattc_disc_chrs rc=%d %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "ble_gattc_disc_chrs rc=%d %s", rc, BLEUtils::returnCodeToString(rc));
     return false;
   }
 
   BLEUtils::taskWait(taskData, BLE_NPL_TIME_FOREVER);
   rc = taskData.m_flags;
   if (rc == 0 || rc == BLE_HS_EDONE) {
-    NIMBLE_LOGD(LOG_TAG, "<< retrieveCharacteristics()");
+    log_d(LOG_TAG, "<< retrieveCharacteristics()");
     return true;
   }
 
-  NIMBLE_LOGE(LOG_TAG, "<< retrieveCharacteristics() rc=%d %s", rc, BLEUtils::returnCodeToString(rc));
+  log_e(LOG_TAG, "<< retrieveCharacteristics() rc=%d %s", rc, BLEUtils::returnCodeToString(rc));
   return false;
 }  // retrieveCharacteristics
 

libraries/NimBLE/src/BLERemoteCharacteristic.cpp

@@ -21,14 +21,13 @@
 #include "BLERemoteValueAttribute.h"
 #include "BLEClient.h"
 #include "BLEUtils.h"
-#include "BLELog.h"
 
 #include <climits>
 
 static const char *LOG_TAG = "BLERemoteValueAttribute";
 
 bool BLERemoteValueAttribute::writeValue(const uint8_t *data, size_t length, bool response) const {
-  NIMBLE_LOGD(LOG_TAG, ">> writeValue()");
+  log_d(LOG_TAG, ">> writeValue()");
 
   const BLEClient *pClient = getClient();
   int retryCount = 1;
@@ -45,7 +44,7 @@ bool BLERemoteValueAttribute::writeValue(const uint8_t *data, size_t length, boo
 
   do {
     if (length > mtu) {
-      NIMBLE_LOGI(LOG_TAG, "writeValue: long write");
+      log_i(LOG_TAG, "writeValue: long write");
       os_mbuf *om = ble_hs_mbuf_from_flat(data, length);
       rc = ble_gattc_write_long(pClient->getConnHandle(), getHandle(), 0, om, BLERemoteValueAttribute::onWriteCB, &taskData);
     } else {
@@ -62,7 +61,7 @@ bool BLERemoteValueAttribute::writeValue(const uint8_t *data, size_t length, boo
       case 0:
       case BLE_HS_EDONE: rc = 0; break;
       case BLE_HS_ATT_ERR(BLE_ATT_ERR_ATTR_NOT_LONG):
-        NIMBLE_LOGE(LOG_TAG, "Long write not supported by peer; Truncating length to %d", mtu);
+        log_e(LOG_TAG, "Long write not supported by peer; Truncating length to %d", mtu);
         retryCount++;
         length = mtu;
         break;
@@ -80,9 +79,9 @@ bool BLERemoteValueAttribute::writeValue(const uint8_t *data, size_t length, boo
 
 Done:
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "<< writeValue failed, rc: %d %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "<< writeValue failed, rc: %d %s", rc, BLEUtils::returnCodeToString(rc));
   } else {
-    NIMBLE_LOGD(LOG_TAG, "<< writeValue");
+    log_d(LOG_TAG, "<< writeValue");
   }
 
   return (rc == 0);
@@ -97,7 +96,7 @@ int BLERemoteValueAttribute::onWriteCB(uint16_t conn_handle, const ble_gatt_erro
   const auto pAtt = static_cast<BLERemoteValueAttribute *>(pTaskData->m_pInstance);
 
   if (error->status == BLE_HS_ENOTCONN) {
-    NIMBLE_LOGE(LOG_TAG, "<< Write complete; Not connected");
+    log_e(LOG_TAG, "<< Write complete; Not connected");
     BLEUtils::taskRelease(*pTaskData, error->status);
     return error->status;
   }
@@ -106,7 +105,7 @@ int BLERemoteValueAttribute::onWriteCB(uint16_t conn_handle, const ble_gatt_erro
     return 0;
   }
 
-  NIMBLE_LOGI(LOG_TAG, "Write complete; status=%d", error->status);
+  log_i(LOG_TAG, "Write complete; status=%d", error->status);
   BLEUtils::taskRelease(*pTaskData, error->status);
   return 0;
 }
@@ -117,7 +116,7 @@ int BLERemoteValueAttribute::onWriteCB(uint16_t conn_handle, const ble_gatt_erro
  * @return The value of the remote characteristic.
  */
 BLEAttValue BLERemoteValueAttribute::readValue(time_t *timestamp) const {
-  NIMBLE_LOGD(LOG_TAG, ">> readValue()");
+  log_d(LOG_TAG, ">> readValue()");
 
   BLEAttValue value{};
   const BLEClient *pClient = getClient();
@@ -138,7 +137,7 @@ BLEAttValue BLERemoteValueAttribute::readValue(time_t *timestamp) const {
       case BLE_HS_EDONE: rc = 0; break;
       // Characteristic is not long-readable, return with what we have.
       case BLE_HS_ATT_ERR(BLE_ATT_ERR_ATTR_NOT_LONG):
-        NIMBLE_LOGI(LOG_TAG, "Attribute not long");
+        log_i(LOG_TAG, "Attribute not long");
         rc = ble_gattc_read(pClient->getConnHandle(), getHandle(), BLERemoteValueAttribute::onReadCB, &taskData);
         if (rc != 0) {
           goto Done;
@@ -164,9 +163,9 @@ BLEAttValue BLERemoteValueAttribute::readValue(time_t *timestamp) const {
 
 Done:
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "<< readValue failed rc=%d, %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "<< readValue failed rc=%d, %s", rc, BLEUtils::returnCodeToString(rc));
   } else {
-    NIMBLE_LOGD(LOG_TAG, "<< readValue");
+    log_d(LOG_TAG, "<< readValue");
   }
 
   return value;
@@ -181,7 +180,7 @@ int BLERemoteValueAttribute::onReadCB(uint16_t conn_handle, const ble_gatt_error
   const auto pAtt = static_cast<BLERemoteValueAttribute *>(pTaskData->m_pInstance);
 
   if (error->status == BLE_HS_ENOTCONN) {
-    NIMBLE_LOGE(LOG_TAG, "<< Read complete; Not connected");
+    log_e(LOG_TAG, "<< Read complete; Not connected");
     BLEUtils::taskRelease(*pTaskData, error->status);
     return error->status;
   }
@@ -191,7 +190,7 @@ int BLERemoteValueAttribute::onReadCB(uint16_t conn_handle, const ble_gatt_error
   }
 
   int rc = error->status;
-  NIMBLE_LOGI(LOG_TAG, "Read complete; status=%d", rc);
+  log_i(LOG_TAG, "Read complete; status=%d", rc);
 
   if (rc == 0) {
     if (attr) {
@@ -200,7 +199,7 @@ int BLERemoteValueAttribute::onReadCB(uint16_t conn_handle, const ble_gatt_error
       if ((valBuf->size() + data_len) > BLE_ATT_ATTR_MAX_LEN) {
         rc = BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
       } else {
-        NIMBLE_LOGD(LOG_TAG, "Got %u bytes", data_len);
+        log_d(LOG_TAG, "Got %u bytes", data_len);
         valBuf->append(attr->om->om_data, data_len);
         return 0;
       }

libraries/NimBLE/src/BLERemoteService.cpp

@@ -20,7 +20,6 @@
 
 #include "BLEScan.h"
 #include "BLEDevice.h"
-#include "BLELog.h"
 
 #include <string>
 #include <climits>
@@ -71,7 +70,7 @@ int BLEScan::handleGapEvent(ble_gap_event *event, void *arg) {
       // stop processing if already connected
       BLEClient *pClient = BLEDevice::getClientByPeerAddress(advertisedAddress);
       if (pClient != nullptr && pClient->isConnected()) {
-        NIMBLE_LOGI(LOG_TAG, "Ignoring device: address: %s, already connected", advertisedAddress.toString().c_str());
+        log_i(LOG_TAG, "Ignoring device: address: %s, already connected", advertisedAddress.toString().c_str());
         return 0;
       }
 #endif
@@ -101,18 +100,18 @@ int BLEScan::handleGapEvent(ble_gap_event *event, void *arg) {
         }
 
         if (isLegacyAdv && event_type == BLE_HCI_ADV_RPT_EVTYPE_SCAN_RSP) {
-          NIMBLE_LOGI(LOG_TAG, "Scan response without advertisement: %s", advertisedAddress.toString().c_str());
+          log_i(LOG_TAG, "Scan response without advertisement: %s", advertisedAddress.toString().c_str());
         }
 
         advertisedDevice = new BLEAdvertisedDevice(event, event_type);
         pScan->m_scanResults.m_deviceVec.push_back(advertisedDevice);
-        NIMBLE_LOGI(LOG_TAG, "New advertiser: %s", advertisedAddress.toString().c_str());
+        log_i(LOG_TAG, "New advertiser: %s", advertisedAddress.toString().c_str());
       } else {
         advertisedDevice->update(event, event_type);
         if (isLegacyAdv && event_type == BLE_HCI_ADV_RPT_EVTYPE_SCAN_RSP) {
-          NIMBLE_LOGI(LOG_TAG, "Scan response from: %s", advertisedAddress.toString().c_str());
+          log_i(LOG_TAG, "Scan response from: %s", advertisedAddress.toString().c_str());
         } else {
-          NIMBLE_LOGI(LOG_TAG, "Duplicate; updated: %s", advertisedAddress.toString().c_str());
+          log_i(LOG_TAG, "Duplicate; updated: %s", advertisedAddress.toString().c_str());
         }
       }
 
@@ -142,7 +141,7 @@ int BLEScan::handleGapEvent(ble_gap_event *event, void *arg) {
 
     case BLE_GAP_EVENT_DISC_COMPLETE:
     {
-      NIMBLE_LOGD(LOG_TAG, "discovery complete; reason=%d", event->disc_complete.reason);
+      log_d(LOG_TAG, "discovery complete; reason=%d", event->disc_complete.reason);
 
       if (pScan->m_maxResults == 0) {
         pScan->clearResults();
@@ -296,10 +295,10 @@ void BLEScan::setPeriod(uint32_t periodMs) {
  * @return True if scan started or false if there was an error.
  */
 bool BLEScan::start(uint32_t duration, bool isContinue, bool restart) {
-  NIMBLE_LOGD(LOG_TAG, ">> start: duration=%" PRIu32, duration);
+  log_d(LOG_TAG, ">> start: duration=%" PRIu32, duration);
   if (isScanning()) {
     if (restart) {
-      NIMBLE_LOGI(LOG_TAG, "Scan already in progress, restarting it");
+      log_i(LOG_TAG, "Scan already in progress, restarting it");
       if (!stop()) {
         return false;
       }
@@ -332,19 +331,19 @@ bool BLEScan::start(uint32_t duration, bool isContinue, bool restart) {
 #endif
   switch (rc) {
     case 0:
-    case BLE_HS_EALREADY: NIMBLE_LOGD(LOG_TAG, "Scan started"); break;
+    case BLE_HS_EALREADY: log_d(LOG_TAG, "Scan started"); break;
 
-    case BLE_HS_EBUSY: NIMBLE_LOGE(LOG_TAG, "Unable to scan - connection in progress."); break;
+    case BLE_HS_EBUSY: log_e(LOG_TAG, "Unable to scan - connection in progress."); break;
 
     case BLE_HS_ETIMEOUT_HCI:
     case BLE_HS_EOS:
     case BLE_HS_ECONTROLLER:
-    case BLE_HS_ENOTSYNCED:   NIMBLE_LOGE(LOG_TAG, "Unable to scan - Host Reset"); break;
+    case BLE_HS_ENOTSYNCED:   log_e(LOG_TAG, "Unable to scan - Host Reset"); break;
 
-    default: NIMBLE_LOGE(LOG_TAG, "Error starting scan; rc=%d, %s", rc, BLEUtils::returnCodeToString(rc)); break;
+    default: log_e(LOG_TAG, "Error starting scan; rc=%d, %s", rc, BLEUtils::returnCodeToString(rc)); break;
   }
 
-  NIMBLE_LOGD(LOG_TAG, "<< start()");
+  log_d(LOG_TAG, "<< start()");
   return rc == 0 || rc == BLE_HS_EALREADY;
 }  // start
 
@@ -353,11 +352,11 @@ bool BLEScan::start(uint32_t duration, bool isContinue, bool restart) {
  * @return True if successful.
  */
 bool BLEScan::stop() {
-  NIMBLE_LOGD(LOG_TAG, ">> stop()");
+  log_d(LOG_TAG, ">> stop()");
 
   int rc = ble_gap_disc_cancel();
   if (rc != 0 && rc != BLE_HS_EALREADY) {
-    NIMBLE_LOGE(LOG_TAG, "Failed to cancel scan; rc=%d", rc);
+    log_e(LOG_TAG, "Failed to cancel scan; rc=%d", rc);
     return false;
   }
 
@@ -369,7 +368,7 @@ bool BLEScan::stop() {
     BLEUtils::taskRelease(*m_pTaskData);
   }
 
-  NIMBLE_LOGD(LOG_TAG, "<< stop()");
+  log_d(LOG_TAG, "<< stop()");
   return true;
 }  // stop
 
@@ -378,7 +377,7 @@ bool BLEScan::stop() {
  * @param [in] address The address of the device to delete from the results.
  */
 void BLEScan::erase(const BLEAddress &address) {
-  NIMBLE_LOGD(LOG_TAG, "erase device: %s", address.toString().c_str());
+  log_d(LOG_TAG, "erase device: %s", address.toString().c_str());
   for (auto it = m_scanResults.m_deviceVec.begin(); it != m_scanResults.m_deviceVec.end(); ++it) {
     if ((*it)->getAddress() == address) {
       delete *it;
@@ -393,7 +392,7 @@ void BLEScan::erase(const BLEAddress &address) {
  * @param [in] device The device to delete from the results.
  */
 void BLEScan::erase(const BLEAdvertisedDevice *device) {
-  NIMBLE_LOGD(LOG_TAG, "erase device: %s", device->getAddress().toString().c_str());
+  log_d(LOG_TAG, "erase device: %s", device->getAddress().toString().c_str());
   for (auto it = m_scanResults.m_deviceVec.begin(); it != m_scanResults.m_deviceVec.end(); ++it) {
     if ((*it) == device) {
       delete *it;
@@ -419,11 +418,11 @@ void BLEScan::onHostSync() {
  */
 BLEScanResults BLEScan::getResults(uint32_t duration, bool is_continue) {
   if (duration == 0) {
-    NIMBLE_LOGW(LOG_TAG, "Blocking scan called with duration = forever");
+    log_w(LOG_TAG, "Blocking scan called with duration = forever");
   }
 
   if (m_pTaskData != nullptr) {
-    NIMBLE_LOGE(LOG_TAG, "Scan already in progress");
+    log_e(LOG_TAG, "Scan already in progress");
     return m_scanResults;
   }
 
@@ -467,7 +466,7 @@ void BLEScan::clearResults() {
 void BLEScanResults::dump() const {
 #if CONFIG_NIMBLE_CPP_LOG_LEVEL >= 3
   for (const auto &dev : m_deviceVec) {
-    NIMBLE_LOGI(LOG_TAG, "- %s", dev->toString().c_str());
+    log_i(LOG_TAG, "- %s", dev->toString().c_str());
   }
 #endif
 }  // dump
@@ -525,15 +524,15 @@ const BLEAdvertisedDevice *BLEScanResults::getDevice(const BLEAddress &address)
 static const char *CB_TAG = "BLEScanCallbacks";
 
 void BLEScanCallbacks::onDiscovered(const BLEAdvertisedDevice *pAdvertisedDevice) {
-  NIMBLE_LOGD(CB_TAG, "Discovered: %s", pAdvertisedDevice->toString().c_str());
+  log_d(CB_TAG, "Discovered: %s", pAdvertisedDevice->toString().c_str());
 }
 
 void BLEScanCallbacks::onResult(const BLEAdvertisedDevice *pAdvertisedDevice) {
-  NIMBLE_LOGD(CB_TAG, "Result: %s", pAdvertisedDevice->toString().c_str());
+  log_d(CB_TAG, "Result: %s", pAdvertisedDevice->toString().c_str());
 }
 
 void BLEScanCallbacks::onScanEnd(const BLEScanResults &results, int reason) {
-  NIMBLE_LOGD(CB_TAG, "Scan ended; reason %d, num results: %d", reason, results.getCount());
+  log_d(CB_TAG, "Scan ended; reason %d, num results: %d", reason, results.getCount());
 }
 
 #endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_OBSERVER */

libraries/NimBLE/src/BLERemoteValueAttribute.cpp

@@ -20,7 +20,6 @@
 
 #include "BLEServer.h"
 #include "BLEDevice.h"
-#include "BLELog.h"
 
 #if defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
 #include "BLEClient.h"
@@ -178,7 +177,7 @@ void BLEServer::start() {
 
   int rc = ble_gatts_start();
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "ble_gatts_start; rc=%d, %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "ble_gatts_start; rc=%d, %s", rc, BLEUtils::returnCodeToString(rc));
     return;
   }
 
@@ -192,7 +191,7 @@ void BLEServer::start() {
     if (svc->getRemoved() == 0) {
       rc = ble_gatts_find_svc(svc->getUUID().getBase(), &svc->m_handle);
       if (rc != 0) {
-        NIMBLE_LOGW(
+        log_w(
           LOG_TAG, "GATT Server started without service: %s, Service %s", svc->getUUID().toString().c_str(), svc->isStarted() ? "missing" : "not started"
         );
         continue;  // Skip this service as it was not started
@@ -225,7 +224,7 @@ void BLEServer::start() {
 bool BLEServer::disconnect(uint16_t connHandle, uint8_t reason) const {
   int rc = ble_gap_terminate(connHandle, reason);
   if (rc != 0 && rc != BLE_HS_ENOTCONN && rc != BLE_HS_EALREADY) {
-    NIMBLE_LOGE(LOG_TAG, "ble_gap_terminate failed: rc=%d %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "ble_gap_terminate failed: rc=%d %s", rc, BLEUtils::returnCodeToString(rc));
     return false;
   }
 
@@ -289,7 +288,7 @@ std::vector<uint16_t> BLEServer::getPeerDevices() const {
  */
 BLEConnInfo BLEServer::getPeerInfo(uint8_t index) const {
   if (index >= m_connectedPeers.size()) {
-    NIMBLE_LOGE(LOG_TAG, "Invalid index %u", index);
+    log_e(LOG_TAG, "Invalid index %u", index);
     return BLEConnInfo{};
   }
 
@@ -314,7 +313,7 @@ BLEConnInfo BLEServer::getPeerInfo(uint8_t index) const {
 BLEConnInfo BLEServer::getPeerInfo(const BLEAddress &address) const {
   BLEConnInfo peerInfo{};
   if (ble_gap_conn_find_by_addr(address.getBase(), &peerInfo.m_desc) != 0) {
-    NIMBLE_LOGE(LOG_TAG, "Peer info not found");
+    log_e(LOG_TAG, "Peer info not found");
   }
 
   return peerInfo;
@@ -328,7 +327,7 @@ BLEConnInfo BLEServer::getPeerInfo(const BLEAddress &address) const {
 BLEConnInfo BLEServer::getPeerInfoByHandle(uint16_t connHandle) const {
   BLEConnInfo peerInfo{};
   if (ble_gap_conn_find(connHandle, &peerInfo.m_desc) != 0) {
-    NIMBLE_LOGE(LOG_TAG, "Peer info not found");
+    log_e(LOG_TAG, "Peer info not found");
   }
 
   return peerInfo;
@@ -338,7 +337,7 @@ BLEConnInfo BLEServer::getPeerInfoByHandle(uint16_t connHandle) const {
  * @brief Gap event handler.
  */
 int BLEServer::handleGapEvent(ble_gap_event *event, void *arg) {
-  NIMBLE_LOGD(LOG_TAG, ">> handleGapEvent: %s", BLEUtils::gapEventToString(event->type));
+  log_d(LOG_TAG, ">> handleGapEvent: %s", BLEUtils::gapEventToString(event->type));
 
   int rc = 0;
   BLEConnInfo peerInfo{};
@@ -348,7 +347,7 @@ int BLEServer::handleGapEvent(ble_gap_event *event, void *arg) {
     case BLE_GAP_EVENT_CONNECT:
     {
       if (event->connect.status != 0) {
-        NIMBLE_LOGE(LOG_TAG, "Connection failed");
+        log_e(LOG_TAG, "Connection failed");
 #if !CONFIG_BT_NIMBLE_EXT_ADV
         BLEDevice::startAdvertising();
 #endif
@@ -380,7 +379,7 @@ int BLEServer::handleGapEvent(ble_gap_event *event, void *arg) {
         case BLE_HS_EOS:
         case BLE_HS_ECONTROLLER:
         case BLE_HS_ENOTSYNCED:
-          NIMBLE_LOGE(LOG_TAG, "Disconnect - host reset, rc=%d", event->disconnect.reason);
+          log_e(LOG_TAG, "Disconnect - host reset, rc=%d", event->disconnect.reason);
           BLEDevice::onReset(event->disconnect.reason);
           break;
         default: break;
@@ -416,7 +415,7 @@ int BLEServer::handleGapEvent(ble_gap_event *event, void *arg) {
 
     case BLE_GAP_EVENT_SUBSCRIBE:
     {
-      NIMBLE_LOGI(
+      log_i(
         LOG_TAG, "subscribe event; attr_handle=%d, subscribed: %s", event->subscribe.attr_handle,
         ((event->subscribe.cur_notify || event->subscribe.cur_indicate) ? "true" : "false")
       );
@@ -445,7 +444,7 @@ int BLEServer::handleGapEvent(ble_gap_event *event, void *arg) {
 
     case BLE_GAP_EVENT_MTU:
     {
-      NIMBLE_LOGI(LOG_TAG, "mtu update event; conn_handle=%d mtu=%d", event->mtu.conn_handle, event->mtu.value);
+      log_i(LOG_TAG, "mtu update event; conn_handle=%d mtu=%d", event->mtu.conn_handle, event->mtu.value);
       if (ble_gap_conn_find(event->mtu.conn_handle, &peerInfo.m_desc) == 0) {
         pServer->m_pServerCallbacks->onMTUChange(event->mtu.value, peerInfo);
       }
@@ -567,10 +566,10 @@ int BLEServer::handleGapEvent(ble_gap_event *event, void *arg) {
           pkey.passkey = pServer->m_pServerCallbacks->onPassKeyDisplay();
         }
         rc = ble_sm_inject_io(event->passkey.conn_handle, &pkey);
-        NIMBLE_LOGD(LOG_TAG, "BLE_SM_IOACT_DISP; ble_sm_inject_io result: %d", rc);
+        log_d(LOG_TAG, "BLE_SM_IOACT_DISP; ble_sm_inject_io result: %d", rc);
 
       } else if (event->passkey.params.action == BLE_SM_IOACT_NUMCMP) {
-        NIMBLE_LOGD(LOG_TAG, "Passkey on device's display: %" PRIu32, event->passkey.params.numcmp);
+        log_d(LOG_TAG, "Passkey on device's display: %" PRIu32, event->passkey.params.numcmp);
 
         rc = ble_gap_conn_find(event->passkey.conn_handle, &peerInfo.m_desc);
         if (rc != 0) {
@@ -586,9 +585,9 @@ int BLEServer::handleGapEvent(ble_gap_event *event, void *arg) {
         //     pkey.oob[i] = tem_oob[i];
         // }
         // rc = ble_sm_inject_io(event->passkey.conn_handle, &pkey);
-        // NIMBLE_LOGD(LOG_TAG, "BLE_SM_IOACT_OOB; ble_sm_inject_io result: %d", rc);
+        // log_d(LOG_TAG, "BLE_SM_IOACT_OOB; ble_sm_inject_io result: %d", rc);
       } else if (event->passkey.params.action == BLE_SM_IOACT_NONE) {
-        NIMBLE_LOGD(LOG_TAG, "No passkey action required");
+        log_d(LOG_TAG, "No passkey action required");
       }
 
       break;
@@ -597,15 +596,15 @@ int BLEServer::handleGapEvent(ble_gap_event *event, void *arg) {
     default: break;
   }
 
-  NIMBLE_LOGD(LOG_TAG, "<< handleGapEvent");
+  log_d(LOG_TAG, "<< handleGapEvent");
   return 0;
 }  // handleGapEvent
 
 /**
  * @brief GATT event handler.
  */
 int BLEServer::handleGattEvent(uint16_t connHandle, uint16_t attrHandle, ble_gatt_access_ctxt *ctxt, void *arg) {
-  NIMBLE_LOGD(LOG_TAG, "Gatt %s event", (ctxt->op == BLE_GATT_ACCESS_OP_READ_CHR || ctxt->op == BLE_GATT_ACCESS_OP_READ_DSC) ? "Read" : "Write");
+  log_d(LOG_TAG, "Gatt %s event", (ctxt->op == BLE_GATT_ACCESS_OP_READ_CHR || ctxt->op == BLE_GATT_ACCESS_OP_READ_DSC) ? "Read" : "Write");
   auto pAtt = static_cast<BLELocalValueAttribute *>(arg);
   const BLEAttValue &val = pAtt->getAttVal();
 
@@ -742,7 +741,7 @@ void BLEServer::removeService(BLEService *service, bool deleteSvc) {
 void BLEServer::addService(BLEService *service) {
   // Check that a service with the supplied UUID does not already exist.
   if (getServiceByUUID(service->getUUID()) != nullptr) {
-    NIMBLE_LOGW(LOG_TAG, "Warning creating a duplicate service UUID: %s", std::string(service->getUUID()).c_str());
+    log_w(LOG_TAG, "Warning creating a duplicate service UUID: %s", std::string(service->getUUID()).c_str());
   }
 
   // If adding a service that was not removed add it and return.
@@ -832,7 +831,7 @@ bool BLEServer::stopAdvertising(uint8_t instId) const {
 bool BLEServer::updatePhy(uint16_t connHandle, uint8_t txPhyMask, uint8_t rxPhyMask, uint16_t phyOptions) {
   int rc = ble_gap_set_prefered_le_phy(connHandle, txPhyMask, rxPhyMask, phyOptions);
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "Failed to update phy; rc=%d %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "Failed to update phy; rc=%d %s", rc, BLEUtils::returnCodeToString(rc));
   }
 
   return rc == 0;
@@ -848,7 +847,7 @@ bool BLEServer::updatePhy(uint16_t connHandle, uint8_t txPhyMask, uint8_t rxPhyM
 bool BLEServer::getPhy(uint16_t connHandle, uint8_t *txPhy, uint8_t *rxPhy) {
   int rc = ble_gap_read_le_phy(connHandle, txPhy, rxPhy);
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "Failed to read phy; rc=%d %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "Failed to read phy; rc=%d %s", rc, BLEUtils::returnCodeToString(rc));
   }
 
   return rc == 0;
@@ -906,7 +905,7 @@ void BLEServer::updateConnParams(uint16_t connHandle, uint16_t minInterval, uint
 
   int rc = ble_gap_update_params(connHandle, &params);
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "Update params error: %d, %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "Update params error: %d, %s", rc, BLEUtils::returnCodeToString(rc));
   }
 }  // updateConnParams
 
@@ -924,7 +923,7 @@ void BLEServer::setDataLen(uint16_t connHandle, uint16_t octets) const {
 
   int rc = ble_gap_set_data_len(connHandle, octets, tx_time);
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "Set data length error: %d, %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "Set data length error: %d, %s", rc, BLEUtils::returnCodeToString(rc));
   }
 }  // setDataLen
 
@@ -940,7 +939,7 @@ BLEClient *BLEServer::getClient(uint16_t connHandle) {
   BLEConnInfo connInfo;
   int rc = ble_gap_conn_find(connHandle, &connInfo.m_desc);
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "Client info not found");
+    log_e(LOG_TAG, "Client info not found");
     return nullptr;
   }
 
@@ -978,42 +977,42 @@ void BLEServer::deleteClient() {
 
 /** Default callback handlers */
 void BLEServerCallbacks::onConnect(BLEServer *pServer, BLEConnInfo &connInfo) {
-  NIMBLE_LOGD("BLEServerCallbacks", "onConnect(): Default");
+  log_d("BLEServerCallbacks", "onConnect(): Default");
 }  // onConnect
 
 void BLEServerCallbacks::onDisconnect(BLEServer *pServer, BLEConnInfo &connInfo, int reason) {
-  NIMBLE_LOGD("BLEServerCallbacks", "onDisconnect(): Default");
+  log_d("BLEServerCallbacks", "onDisconnect(): Default");
 }  // onDisconnect
 
 void BLEServerCallbacks::onMTUChange(uint16_t MTU, BLEConnInfo &connInfo) {
-  NIMBLE_LOGD("BLEServerCallbacks", "onMTUChange(): Default");
+  log_d("BLEServerCallbacks", "onMTUChange(): Default");
 }  // onMTUChange
 
 uint32_t BLEServerCallbacks::onPassKeyDisplay() {
-  NIMBLE_LOGD("BLEServerCallbacks", "onPassKeyDisplay: default: 123456");
+  log_d("BLEServerCallbacks", "onPassKeyDisplay: default: 123456");
   return 123456;
 }  // onPassKeyDisplay
 
 void BLEServerCallbacks::onConfirmPassKey(BLEConnInfo &connInfo, uint32_t pin) {
-  NIMBLE_LOGD("BLEServerCallbacks", "onConfirmPasskey: default: true");
+  log_d("BLEServerCallbacks", "onConfirmPasskey: default: true");
   BLEDevice::injectConfirmPasskey(connInfo, true);
 }  // onConfirmPasskey
 
 void BLEServerCallbacks::onIdentity(BLEConnInfo &connInfo) {
-  NIMBLE_LOGD("BLEServerCallbacks", "onIdentity: default");
+  log_d("BLEServerCallbacks", "onIdentity: default");
 }  // onIdentity
 
 void BLEServerCallbacks::onAuthenticationComplete(BLEConnInfo &connInfo) {
-  NIMBLE_LOGD("BLEServerCallbacks", "onAuthenticationComplete: default");
+  log_d("BLEServerCallbacks", "onAuthenticationComplete: default");
 }  // onAuthenticationComplete
 
 void BLEServerCallbacks::onConnParamsUpdate(BLEConnInfo &connInfo) {
-  NIMBLE_LOGD("BLEServerCallbacks", "onConnParamsUpdate: default");
+  log_d("BLEServerCallbacks", "onConnParamsUpdate: default");
 }  // onConnParamsUpdate
 
 #if CONFIG_BT_NIMBLE_EXT_ADV
 void BLEServerCallbacks::onPhyUpdate(BLEConnInfo &connInfo, uint8_t txPhy, uint8_t rxPhy) {
-  NIMBLE_LOGD("BLEServerCallbacks", "onPhyUpdate: default, txPhy: %d, rxPhy: %d", txPhy, rxPhy);
+  log_d("BLEServerCallbacks", "onPhyUpdate: default, txPhy: %d, rxPhy: %d", txPhy, rxPhy);
 }  // onPhyUpdate
 #endif
 

libraries/NimBLE/src/BLEScan.cpp

@@ -26,7 +26,6 @@
 #endif
 #include "BLEDevice.h"
 #include "BLEUtils.h"
-#include "BLELog.h"
 
 #include <string>
 
@@ -64,7 +63,7 @@ BLEService::~BLEService() {
  * @brief Dump details of this BLE GATT service.
  */
 void BLEService::dump() const {
-  NIMBLE_LOGD(LOG_TAG, "Service: uuid:%s, handle: 0x%2x", getUUID().toString().c_str(), getHandle());
+  log_d(LOG_TAG, "Service: uuid:%s, handle: 0x%2x", getUUID().toString().c_str(), getHandle());
 
   std::string res;
   int count = 0;
@@ -80,7 +79,7 @@ void BLEService::dump() const {
     res += ", uuid: " + std::string(it->getUUID());
   }
 
-  NIMBLE_LOGD(LOG_TAG, "Characteristics:\n%s", res.c_str());
+  log_d(LOG_TAG, "Characteristics:\n%s", res.c_str());
 }  // dump
 
 /**
@@ -89,7 +88,7 @@ void BLEService::dump() const {
  * @return bool success/failure .
  */
 bool BLEService::start() {
-  NIMBLE_LOGD(LOG_TAG, ">> start(): Starting service: %s", toString().c_str());
+  log_d(LOG_TAG, ">> start(): Starting service: %s", toString().c_str());
 
   // If started previously and no characteristics have been added or removed,
   // then we can skip the service registration process.
@@ -113,7 +112,7 @@ bool BLEService::start() {
     ++numChrs;
   }
 
-  NIMBLE_LOGD(LOG_TAG, "Adding %d characteristics for service %s", numChrs, toString().c_str());
+  log_d(LOG_TAG, "Adding %d characteristics for service %s", numChrs, toString().c_str());
   if (numChrs) {
     int i = 0;
 
@@ -170,17 +169,17 @@ bool BLEService::start() {
   m_pSvcDef->type = BLE_GATT_SVC_TYPE_PRIMARY;
   int rc = ble_gatts_count_cfg(m_pSvcDef);
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "ble_gatts_count_cfg failed, rc= %d, %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "ble_gatts_count_cfg failed, rc= %d, %s", rc, BLEUtils::returnCodeToString(rc));
     return false;
   }
 
   rc = ble_gatts_add_svcs(m_pSvcDef);
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "ble_gatts_add_svcs, rc= %d, %s", rc, BLEUtils::returnCodeToString(rc));
+    log_e(LOG_TAG, "ble_gatts_add_svcs, rc= %d, %s", rc, BLEUtils::returnCodeToString(rc));
     return false;
   }
 
-  NIMBLE_LOGD(LOG_TAG, "<< start()");
+  log_d(LOG_TAG, "<< start()");
   return true;
 }  // start
 
@@ -205,7 +204,7 @@ BLECharacteristic *BLEService::createCharacteristic(const char *uuid, uint32_t p
 BLECharacteristic *BLEService::createCharacteristic(const BLEUUID &uuid, uint32_t properties, uint16_t max_len) {
   BLECharacteristic *pChar = new BLECharacteristic(uuid, properties, max_len, this);
   if (getCharacteristic(uuid) != nullptr) {
-    NIMBLE_LOGD(LOG_TAG, "Adding a duplicate characteristic with UUID: %s", std::string(uuid).c_str());
+    log_d(LOG_TAG, "Adding a duplicate characteristic with UUID: %s", std::string(uuid).c_str());
   }
 
   addCharacteristic(pChar);

libraries/NimBLE/src/BLEServer.cpp

@@ -20,7 +20,6 @@
 
 #include "BLEUtils.h"
 #include "BLEUUID.h"
-#include "BLELog.h"
 
 /****  FIX COMPILATION ****/
 #undef min
@@ -73,7 +72,7 @@ BLEUUID::BLEUUID(const std::string &value) {
     memcpy(m_uuid.u128.value, &second_half, 8);
     m_uuid.u.type = BLE_UUID_TYPE_128;
   } else {
-    NIMBLE_LOGE(LOG_TAG, "Invalid UUID length");
+    log_e(LOG_TAG, "Invalid UUID length");
     m_uuid.u.type = 0;
   }
 }  // BLEUUID(std::string)
@@ -85,7 +84,7 @@ BLEUUID::BLEUUID(const std::string &value) {
  */
 BLEUUID::BLEUUID(const uint8_t *pData, size_t size) {
   if (ble_uuid_init_from_buf(&m_uuid, pData, size)) {
-    NIMBLE_LOGE(LOG_TAG, "Invalid UUID size");
+    log_e(LOG_TAG, "Invalid UUID size");
     m_uuid.u.type = 0;
   }
 }  // BLEUUID(const uint8_t* pData, size_t size)

libraries/NimBLE/src/BLEService.cpp

@@ -20,7 +20,6 @@
 
 #include "BLEUtils.h"
 #include "BLEAddress.h"
-#include "BLELog.h"
 
 #include "host/ble_hs.h"
 
@@ -57,7 +56,7 @@ BLETaskData::BLETaskData(void *pInstance, int flags, void *buf)
 {
   ble_npl_sem *sem = new ble_npl_sem;
   if (ble_npl_sem_init(sem, 0) != BLE_NPL_OK) {
-    NIMBLE_LOGE(LOG_TAG, "Failed to init semaphore");
+    log_e(LOG_TAG, "Failed to init semaphore");
     delete sem;
     m_pHandle = nullptr;
   } else {
@@ -390,7 +389,7 @@ const char *BLEUtils::gapEventToString(uint8_t eventType) {
       return "BLE_GAP_EVENT_LINK_ESTAB";
 #endif
 #endif
-    default: NIMBLE_LOGD(LOG_TAG, "Unknown event type %d 0x%.2x", eventType, eventType); return "Unknown event type";
+    default: log_d(LOG_TAG, "Unknown event type %d 0x%.2x", eventType, eventType); return "Unknown event type";
   }
 #else   // #if defined(CONFIG_NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT)
   (void)eventType;
@@ -427,7 +426,7 @@ BLEAddress BLEUtils::generateAddr(bool nrpa) {
   ble_addr_t addr{};
   int rc = ble_hs_id_gen_rnd(nrpa, &addr);
   if (rc != 0) {
-    NIMBLE_LOGE(LOG_TAG, "Generate address failed, rc=%d", rc);
+    log_e(LOG_TAG, "Generate address failed, rc=%d", rc);
   }
 
   return BLEAddress{addr};