diff --git a/src/NimBLE2904.h b/src/NimBLE2904.h index 9b615f5fb..a958b660a 100644 --- a/src/NimBLE2904.h +++ b/src/NimBLE2904.h @@ -68,7 +68,7 @@ class NimBLE2904 : public NimBLEDescriptor { static const uint8_t FORMAT_OPAQUE = 27; static const uint8_t FORMAT_MEDASN1 = 28; - void setDescription(uint16_t); + void setDescription(uint16_t description); void setExponent(int8_t exponent); void setFormat(uint8_t format); void setNamespace(uint8_t namespace_value); diff --git a/src/NimBLEAdvertisedDevice.cpp b/src/NimBLEAdvertisedDevice.cpp index cf6cf7108..71007ba52 100644 --- a/src/NimBLEAdvertisedDevice.cpp +++ b/src/NimBLEAdvertisedDevice.cpp @@ -780,6 +780,16 @@ bool NimBLEAdvertisedDevice::isLegacyAdvertisement() const { # endif } // isLegacyAdvertisement +/** + * @brief Convenience operator to convert this NimBLEAdvertisedDevice to NimBLEAddress representation. + * @details This allows passing NimBLEAdvertisedDevice to functions + * that accept NimBLEAddress and/or or it's methods as a parameter. + */ +NimBLEAdvertisedDevice::operator NimBLEAddress() const { + NimBLEAddress address(getAddress()); + return address; +} // operator NimBLEAddress + /** * @brief Get the payload advertised by the device. * @return The advertisement payload. diff --git a/src/NimBLEAdvertisedDevice.h b/src/NimBLEAdvertisedDevice.h index e8d3a7735..4b7da39ab 100644 --- a/src/NimBLEAdvertisedDevice.h +++ b/src/NimBLEAdvertisedDevice.h @@ -93,6 +93,7 @@ class NimBLEAdvertisedDevice { uint8_t getSecondaryPhy() const; uint16_t getPeriodicInterval() const; # endif + operator NimBLEAddress() const; const std::vector& getPayload() const; const std::vector::const_iterator begin() const; diff --git a/src/NimBLEAdvertisementData.h b/src/NimBLEAdvertisementData.h index 6ae2ccf20..86f47505c 100644 --- a/src/NimBLEAdvertisementData.h +++ b/src/NimBLEAdvertisementData.h @@ -38,7 +38,7 @@ class NimBLEAdvertisementData { bool addData(const uint8_t* data, size_t length); bool addData(const std::vector& data); bool setAppearance(uint16_t appearance); - bool setFlags(uint8_t); + bool setFlags(uint8_t flag); bool addTxPower(); bool setPreferredParams(uint16_t minInterval, uint16_t maxInterval); bool addServiceUUID(const NimBLEUUID& serviceUUID); diff --git a/src/NimBLEClient.cpp b/src/NimBLEClient.cpp index e5b1383c5..301ef79ab 100644 --- a/src/NimBLEClient.cpp +++ b/src/NimBLEClient.cpp @@ -141,22 +141,6 @@ bool NimBLEClient::connect(bool deleteAttributes, bool asyncConnect, bool exchan return connect(m_peerAddress, deleteAttributes, asyncConnect, exchangeMTU); } // connect -/** - * @brief Connect to an advertising device. - * @param [in] device The device to connect to. - * @param [in] deleteAttributes If true this will delete any attribute objects this client may already\n - * have created when last connected. - * @param [in] asyncConnect If true, the connection will be made asynchronously and this function will return immediately.\n - * If false, this function will block until the connection is established or the connection attempt times out. - * @param [in] exchangeMTU If true, the client will attempt to exchange MTU with the server after connection.\n - * If false, the client will use the default MTU size and the application will need to call exchangeMTU() later. - * @return true on success. - */ -bool NimBLEClient::connect(const 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. * @param [in] address The address of the server. diff --git a/src/NimBLEClient.h b/src/NimBLEClient.h index eba7165f7..d193f7d72 100644 --- a/src/NimBLEClient.h +++ b/src/NimBLEClient.h @@ -48,10 +48,6 @@ struct NimBLETaskData; */ class NimBLEClient { public: - bool connect(const 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); diff --git a/src/NimBLEDevice.cpp b/src/NimBLEDevice.cpp index 01cc079c8..52357f86c 100644 --- a/src/NimBLEDevice.cpp +++ b/src/NimBLEDevice.cpp @@ -76,6 +76,8 @@ extern "C" void ble_store_config_init(void); /** * Singletons for the NimBLEDevice. */ +NimBLEDeviceCallbacks* NimBLEDevice::m_pDeviceCallbacks = nullptr; + # if defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER) NimBLEScan* NimBLEDevice::m_pScan = nullptr; # endif @@ -900,7 +902,9 @@ bool NimBLEDevice::init(const std::string& deviceName) { // Setup callbacks for host events ble_hs_cfg.reset_cb = NimBLEDevice::onReset; ble_hs_cfg.sync_cb = NimBLEDevice::onSync; - ble_hs_cfg.store_status_cb = ble_store_util_status_rr; /*TODO: Implement handler for this*/ + ble_hs_cfg.store_status_cb = [](struct ble_store_status_event* event, void* arg) { + return m_pDeviceCallbacks->onStoreStatus(event, arg); + }; // Set initial security capabilities ble_hs_cfg.sm_io_cap = BLE_HS_IO_NO_INPUT_OUTPUT; @@ -1262,4 +1266,13 @@ void nimble_cpp_assert(const char* file, unsigned line) { } # endif // CONFIG_NIMBLE_CPP_DEBUG_ASSERT_ENABLED +void NimBLEDevice::setDeviceCallbacks(NimBLEDeviceCallbacks* cb) { + m_pDeviceCallbacks = cb ? cb : &defaultDeviceCallbacks; +} + +int NimBLEDeviceCallbacks::onStoreStatus(struct ble_store_status_event* event, void* arg) { + NIMBLE_LOGD("NimBLEDeviceCallbacks", "onStoreStatus: default"); + return ble_store_util_status_rr(event, arg); +} + #endif // CONFIG_BT_ENABLED diff --git a/src/NimBLEDevice.h b/src/NimBLEDevice.h index 9f9f52b2b..ad5976781 100644 --- a/src/NimBLEDevice.h +++ b/src/NimBLEDevice.h @@ -66,6 +66,7 @@ class NimBLEConnInfo; # endif class NimBLEAddress; +class NimBLEDeviceCallbacks; # define BLEDevice NimBLEDevice # define BLEClient NimBLEClient @@ -129,6 +130,7 @@ class NimBLEDevice { static bool setOwnAddrType(uint8_t type); static bool setOwnAddr(const NimBLEAddress& addr); static bool setOwnAddr(const uint8_t* addr); + static void setDeviceCallbacks(NimBLEDeviceCallbacks* cb); static void setScanDuplicateCacheSize(uint16_t cacheSize); static void setScanFilterMode(uint8_t type); static bool setCustomGapHandler(gap_event_handler handler); @@ -213,6 +215,8 @@ class NimBLEDevice { static ble_gap_event_listener m_listener; static uint8_t m_ownAddrType; static std::vector m_whiteList; + static NimBLEDeviceCallbacks* m_pDeviceCallbacks; + static NimBLEDeviceCallbacks defaultDeviceCallbacks; # if defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER) static NimBLEScan* m_pScan; @@ -295,5 +299,27 @@ class NimBLEDevice { # include "NimBLEUtils.h" +/** + * @brief Callbacks associated with a BLE device. + */ +class NimBLEDeviceCallbacks { + public: + virtual ~NimBLEDeviceCallbacks() {}; + + /** + * @brief Indicates an inability to perform a store operation. + * This callback should do one of two things: + * -Address the problem and return 0, indicating that the store operation + * should proceed. + * -Return nonzero to indicate that the store operation should be aborted. + * @param event Describes the store event being reported. + * BLE_STORE_EVENT_FULL; or + * BLE_STORE_EVENT_OVERFLOW + * @return 0 if the store operation should proceed; + * nonzero if the store operation should be aborted. + */ + virtual int onStoreStatus(struct ble_store_status_event* event, void* arg); +}; + #endif // CONFIG_BT_ENABLED #endif // NIMBLE_CPP_DEVICE_H_ diff --git a/src/NimBLELog.h b/src/NimBLELog.h index 618465ec3..ec8a0f086 100644 --- a/src/NimBLELog.h +++ b/src/NimBLELog.h @@ -110,16 +110,16 @@ # define NIMBLE_CPP_LOG_FORMAT(letter, format) NIMBLE_CPP_LOG_COLOR_##letter #letter " (%lu) %s: " format LOG_RESET_COLOR "\n" -# define NIMBLE_CPP_LOG_LEVEL_LOCAL(level, tag, format, ...) \ - do { \ - if (level==ESP_LOG_ERROR) { esp_log_write(ESP_LOG_ERROR, tag, NIMBLE_CPP_LOG_FORMAT(E, format), esp_log_timestamp(), tag __VA_OPT__(,) __VA_ARGS__); } \ +# define NIMBLE_CPP_LOG_LEVEL_LOCAL(level, tag, format, ...) \ + do { \ + if (level==ESP_LOG_ERROR) { esp_log_write(ESP_LOG_ERROR, tag, NIMBLE_CPP_LOG_FORMAT(E, format), esp_log_timestamp(), tag __VA_OPT__(,) __VA_ARGS__); } \ else if (level==ESP_LOG_WARN) { esp_log_write(ESP_LOG_WARN, tag, NIMBLE_CPP_LOG_FORMAT(W, format), esp_log_timestamp(), tag __VA_OPT__(,) __VA_ARGS__); } \ else if (level==ESP_LOG_INFO) { esp_log_write(ESP_LOG_INFO, tag, NIMBLE_CPP_LOG_FORMAT(I, format), esp_log_timestamp(), tag __VA_OPT__(,) __VA_ARGS__); } \ else { esp_log_write(ESP_LOG_DEBUG, tag, NIMBLE_CPP_LOG_FORMAT(D, format), esp_log_timestamp(), tag __VA_OPT__(,) __VA_ARGS__); } \ } while(0) -# define NIMBLE_CPP_LOG_PRINT(level, tag, format, ...) \ - do { \ +# define NIMBLE_CPP_LOG_PRINT(level, tag, format, ...) \ + do { \ if (CONFIG_NIMBLE_CPP_LOG_LEVEL >= level) NIMBLE_CPP_LOG_LEVEL_LOCAL(level, tag, format, ##__VA_ARGS__); \ } while (0) @@ -172,5 +172,12 @@ # endif # endif /* CONFIG_NIMBLE_CPP_IDF */ + +# define NIMBLE_LOGD_IF(cond, tag, format, ...) { if (cond) { NIMBLE_LOGD(tag, format, ##__VA_ARGS__); }} +# define NIMBLE_LOGI_IF(cond, tag, format, ...) { if (cond) { NIMBLE_LOGI(tag, format, ##__VA_ARGS__); }} +# define NIMBLE_LOGW_IF(cond, tag, format, ...) { if (cond) { NIMBLE_LOGW(tag, format, ##__VA_ARGS__); }} +# define NIMBLE_LOGE_IF(cond, tag, format, ...) { if (cond) { NIMBLE_LOGE(tag, format, ##__VA_ARGS__); }} +# define NIMBLE_LOGE_RC(rc, tag, format, ...) { if (rc) { NIMBLE_LOGE(tag, format "; rc=%d %s", ##__VA_ARGS__, rc, NimBLEUtils::returnCodeToString(rc)); }} + #endif /* CONFIG_BT_ENABLED */ #endif /* NIMBLE_CPP_LOG_H_ */ \ No newline at end of file