Provide signatures to allow BLEUUID as string

Code changes for #31

Author: copercini

cpp_utils/BLEAdvertisedDevice.cpp

@@ -352,6 +352,14 @@ void BLEAdvertisedDevice::setScan(BLEScan* pScan) {
 	m_pScan = pScan;
 } // setScan
 
+/**
+ * @brief Set the Service UUID for this device.
+ * @param [in] serviceUUID The discovered serviceUUID
+ */
+void BLEAdvertisedDevice::setServiceUUID(const char* serviceUUID) {
+	return setServiceUUID(BLEUUID(serviceUUID));
+} // setRSSI
+
 /**
  * @brief Set the Service UUID for this device.
  * @param [in] serviceUUID The discovered serviceUUID

cpp_utils/BLEAdvertisedDevice.h

@@ -59,6 +59,7 @@ class BLEAdvertisedDevice {
 	void setName(std::string name);
 	void setRSSI(int rssi);
 	void setScan(BLEScan* pScan);
+	void setServiceUUID(const char* serviceUUID);
 	void setServiceUUID(BLEUUID serviceUUID);
 	void setTXPower(int8_t txPower);
 

cpp_utils/BLEAdvertising.cpp

@@ -56,6 +56,18 @@ void BLEAdvertising::setAppearance(uint16_t appearance) {
 } // setAppearance
 
 
+/**
+ * @brief Set the service UUID.
+ * We maintain a class member called m_advData (esp_ble_adv_data_t) that is passed to the
+ * ESP-IDF advertising functions.  In this method, we see two fields within that structure
+ * namely service_uuid_len and p_service_uuid to be the information supplied in the passed
+ * in service uuid.
+ * @param [in] uuid The UUID of the service.
+ * @return N/A.
+ */
+void BLEAdvertising::setServiceUUID(const char* serviceUUID) {
+	return setServiceUUID(BLEUUID(serviceUUID)); 
+}
 /**
  * @brief Set the service UUID.
  * We maintain a class member called m_advData (esp_ble_adv_data_t) that is passed to the

cpp_utils/BLEAdvertising.h

@@ -23,6 +23,7 @@ class BLEAdvertising {
 	void start();
 	void stop();
 	void setAppearance(uint16_t appearance);
+	void setServiceUUID(const char* serviceUUID);
 	void setServiceUUID(BLEUUID serviceUUID);
 private:
 	esp_ble_adv_data_t   m_advData;

cpp_utils/BLECharacteristic.cpp

@@ -23,6 +23,16 @@ static const char* LOG_TAG = "BLECharacteristic";
 
 #define NULL_HANDLE (0xffff)
 
+
+/**
+ * @brief Construct a characteristic
+ * @param [in] uuid - UUID (const char*) for the characteristic.
+ * @param [in] properties - Properties for the characteristic.
+ */
+BLECharacteristic::BLECharacteristic(const char* uuid, uint32_t properties) {
+	BLECharacteristic(BLEUUID(uuid), properties);
+}
+
 /**
  * @brief Construct a characteristic
  * @param [in] uuid - UUID for the characteristic.
@@ -122,6 +132,16 @@ void BLECharacteristic::executeCreate(BLEService* pService) {
 } // executeCreate
 
 
+
+/**
+ * @brief Return the BLE Descriptor for the given UUID if associated with this characteristic.
+ * @param [in] descriptorUUID The UUID of the descriptor that we wish to retrieve.
+ * @return The BLE Descriptor.  If no such descriptor is associated with the characteristic, nullptr is returned.
+ */
+BLEDescriptor* BLECharacteristic::getDescriptorByUUID(const char* descriptorUUID) {
+	return m_descriptorMap.getByUUID(BLEUUID(descriptorUUID));
+} // getDescriptorByUUID
+
 /**
  * @brief Return the BLE Descriptor for the given UUID if associated with this characteristic.
  * @param [in] descriptorUUID The UUID of the descriptor that we wish to retrieve.

cpp_utils/BLECharacteristic.h

@@ -26,8 +26,10 @@ class BLECharacteristicCallbacks;
  */
 class BLEDescriptorMap {
 public:
+	void setByUUID(const char* uuid,  BLEDescriptor *pDescriptor);
 	void setByUUID(BLEUUID uuid,      BLEDescriptor *pDescriptor);
 	void setByHandle(uint16_t handle, BLEDescriptor *pDescriptor);
+	BLEDescriptor *getByUUID(const char* uuid);
 	BLEDescriptor *getByUUID(BLEUUID uuid);
 	BLEDescriptor *getByHandle(uint16_t handle);
 	std::string toString();
@@ -52,10 +54,12 @@ class BLEDescriptorMap {
  */
 class BLECharacteristic {
 public:
+	BLECharacteristic(const char* uuid, uint32_t properties = 0);
 	BLECharacteristic(BLEUUID uuid, uint32_t properties = 0);
 	virtual ~BLECharacteristic();
 
 	void           addDescriptor(BLEDescriptor* pDescriptor);
+	BLEDescriptor* getDescriptorByUUID(const char* descriptorUUID);
 	BLEDescriptor* getDescriptorByUUID(BLEUUID descriptorUUID);
 	//size_t         getLength();
 	BLEUUID        getUUID();

cpp_utils/BLECharacteristicMap.cpp

@@ -10,6 +10,14 @@
 #include <iomanip>
 #include "BLEService.h"
 
+/**
+ * @brief Return the characteristic by UUID.
+ * @param [in] UUID The UUID to look up the characteristic.
+ * @return The characteristic.
+ */
+BLECharacteristic* BLECharacteristicMap::getByUUID(const char* uuid) {
+    return getByUUID(BLEUUID(uuid));
+}
 
 /**
  * @brief Return the characteristic by UUID.

cpp_utils/BLEClient.cpp

@@ -202,6 +202,16 @@ esp_gatt_if_t BLEClient::getGattcIf() {
 } // getGattcIf
 
 
+
+/**
+ * @brief Get the service object corresponding to the uuid.
+ * @param [in] uuid The UUID of the service being sought.
+ * @return A reference to the Service or nullptr if don't know about it.
+ */
+BLERemoteService* BLEClient::getService(const char* uuid) {
+    return getService(BLEUUID(uuid));
+}
+
 /**
  * @brief Get the service object corresponding to the uuid.
  * @param [in] uuid The UUID of the service being sought.

cpp_utils/BLEClient.h

@@ -32,6 +32,7 @@ class BLEClient {
 	void                                       disconnect();
 	BLEAddress                                 getPeerAddress();
 	std::map<std::string, BLERemoteService*>*  getServices();
+	BLERemoteService*                          getService(const char* uuid);
 	BLERemoteService*                          getService(BLEUUID uuid);
 	void                                       setClientCallbacks(BLEClientCallbacks *pClientCallbacks);
 	std::string                                toString();

cpp_utils/BLEDescriptor.cpp

@@ -21,6 +21,14 @@ static const char* LOG_TAG = "BLEDescriptor";
 
 
 #define NULL_HANDLE (0xffff)
+
+
+/**
+ * @brief BLEDescriptor constructor.
+ */
+BLEDescriptor::BLEDescriptor(const char* uuid) {
+	BLEDescriptor(BLEUUID(uuid));
+}	
 /**
  * @brief BLEDescriptor constructor.
  */

cpp_utils/BLEDescriptor.h

@@ -23,6 +23,7 @@ class BLECharacteristic;
  */
 class BLEDescriptor {
 public:
+	BLEDescriptor(const char* uuid);
 	BLEDescriptor(BLEUUID uuid);
 	virtual ~BLEDescriptor();
 

cpp_utils/BLEDescriptorMap.cpp

@@ -12,6 +12,16 @@
 #include "BLEDescriptor.h"
 #include <esp_gatts_api.h>   // ESP32 BLE
 
+/**
+ * @brief Return the descriptor by UUID.
+ * @param [in] UUID The UUID to look up the descriptor.
+ * @return The descriptor.  If not present, then nullptr is returned.
+ */
+BLEDescriptor* BLEDescriptorMap::getByUUID(const char* uuid) {
+    return getByUUID(BLEUUID(uuid));
+}
+
+
 /**
  * @brief Return the descriptor by UUID.
  * @param [in] UUID The UUID to look up the descriptor.
@@ -44,9 +54,19 @@ BLEDescriptor* BLEDescriptorMap::getByHandle(uint16_t handle) {
  * @param [in] characteristic The descriptor to cache.
  * @return N/A.
  */
-void BLEDescriptorMap::setByUUID(
-		BLEUUID            uuid,
-		BLEDescriptor *pDescriptor) {
+void BLEDescriptorMap::setByUUID(const char* uuid, BLEDescriptor *pDescriptor){
+	m_uuidMap.insert(std::pair<std::string, BLEDescriptor *>(uuid, pDescriptor));
+} // setByUUID
+
+
+
+/**
+ * @brief Set the descriptor by UUID.
+ * @param [in] uuid The uuid of the descriptor.
+ * @param [in] characteristic The descriptor to cache.
+ * @return N/A.
+ */
+void BLEDescriptorMap::setByUUID(BLEUUID uuid, BLEDescriptor *pDescriptor) {
 	m_uuidMap.insert(std::pair<std::string, BLEDescriptor *>(uuid.toString(), pDescriptor));
 } // setByUUID
 

cpp_utils/BLERemoteService.cpp

@@ -101,6 +101,16 @@ void BLERemoteService::gattClientEventHandler(
 } // gattClientEventHandler
 
 
+/**
+ * @brief Get the characteristic object for the UUID.
+ * @param [in] uuid Characteristic uuid.
+ * @return Reference to the characteristic object.
+ */
+BLERemoteCharacteristic* BLERemoteService::getCharacteristic(const char* uuid) {
+    return getCharacteristic(BLEUUID(uuid));
+}
+	
+	
 /**
  * @brief Get the characteristic object for the UUID.
  * @param [in] uuid Characteristic uuid.

cpp_utils/BLERemoteService.h

@@ -30,6 +30,7 @@ class BLERemoteService {
 	virtual ~BLERemoteService();
 
 	// Public methods
+	BLERemoteCharacteristic* getCharacteristic(const char* uuid);	
 	BLERemoteCharacteristic* getCharacteristic(BLEUUID uuid);
 	void                     getCharacteristics(void);
 	BLEClient*               getClient(void);

cpp_utils/BLEServer.cpp

@@ -47,6 +47,20 @@ void BLEServer::createApp(uint16_t appId) {
 	registerApp();
 }
 
+
+/**
+ * @brief Create a %BLE Service.
+ *
+ * With a %BLE server, we can host one or more services.  Invoking this function causes the creation of a definition
+ * of a new service.  Every service must have a unique UUID.
+ * @param [in] uuid The UUID of the new service.
+ * @return A reference to the new service object.
+ */
+BLEService* BLEServer::createService(const char* uuid) {
+	return createService(BLEUUID(uuid));
+}
+
+
 /**
  * @brief Create a %BLE Service.
  *

cpp_utils/BLEServer.h

@@ -29,12 +29,14 @@ class BLEServerCallbacks;
 class BLEServiceMap {
 public:
 	BLEService* getByHandle(uint16_t handle);
+	BLEService* getByUUID(const char* uuid);	
 	BLEService* getByUUID(BLEUUID uuid);
 	void        handleGATTServerEvent(
 		esp_gatts_cb_event_t      event,
 		esp_gatt_if_t             gatts_if,
 		esp_ble_gatts_cb_param_t* param);
 	void        setByHandle(uint16_t handle, BLEService* service);
+	void        setByUUID(const char* uuid, BLEService* service);
 	void        setByUUID(BLEUUID uuid, BLEService* service);
 	std::string toString();
 
@@ -53,6 +55,7 @@ class BLEServer {
 
 
 	uint32_t        getConnectedCount();
+	BLEService*     createService(const char* uuid);	
 	BLEService*     createService(BLEUUID uuid);
 	BLEAdvertising* getAdvertising();
 	void            setCallbacks(BLEServerCallbacks *pCallbacks);

cpp_utils/BLEService.cpp

@@ -26,6 +26,15 @@
 
 static const char* LOG_TAG = "BLEService"; // Tag for logging.
 
+/**
+ * @brief Construct an instance of the BLEService
+ * @param [in] uuid The UUID of the service.
+ */
+BLEService::BLEService(const char* uuid) {
+	BLEService(BLEUUID(uuid));
+}
+
+
 /**
  * @brief Construct an instance of the BLEService
  * @param [in] uuid The UUID of the service.
@@ -200,9 +209,17 @@ void BLEService::addCharacteristic(BLECharacteristic* pCharacteristic) {
  * @param [in] properties - The properties of the characteristic.
  * @return The new BLE characteristic.
  */
-BLECharacteristic* BLEService::createCharacteristic(
-		BLEUUID uuid,
-		uint32_t properties) {
+BLECharacteristic* BLEService::createCharacteristic(const char* uuid, uint32_t properties) {
+	return createCharacteristic(BLEUUID(uuid), properties);
+}
+	
+/**
+ * @brief Create a new BLE Characteristic associated with this service.
+ * @param [in] uuid - The UUID of the characteristic.
+ * @param [in] properties - The properties of the characteristic.
+ * @return The new BLE characteristic.
+ */
+BLECharacteristic* BLEService::createCharacteristic(BLEUUID uuid, uint32_t properties) {
 	BLECharacteristic *pCharacteristic = new BLECharacteristic(uuid, properties);
 	addCharacteristic(pCharacteristic);
 	return pCharacteristic;
@@ -289,6 +306,11 @@ void BLEService::handleGATTServerEvent(
 } // handleGATTServerEvent
 
 
+BLECharacteristic* BLEService::getCharacteristic(const char* uuid) {
+	return getCharacteristic(BLEUUID(uuid));
+}
+
+
 BLECharacteristic* BLEService::getCharacteristic(BLEUUID uuid) {
 	return m_characteristicMap.getByUUID(uuid);
 }

cpp_utils/BLEService.h

@@ -24,8 +24,10 @@ class BLEServer;
  */
 class BLECharacteristicMap {
 public:
+	void setByUUID(const char* uuid, BLECharacteristic* pCharacteristic);
 	void setByUUID(BLEUUID uuid, BLECharacteristic* pCharacteristic);
 	void setByHandle(uint16_t handle, BLECharacteristic* pCharacteristic);
+	BLECharacteristic* getByUUID(const char* uuid);	
 	BLECharacteristic* getByUUID(BLEUUID uuid);
 	BLECharacteristic* getByHandle(uint16_t handle);
 	BLECharacteristic* getFirst();
@@ -50,12 +52,15 @@ class BLECharacteristicMap {
  */
 class BLEService {
 public:
+	BLEService(const char* uuid);
 	BLEService(BLEUUID uuid);
 
 	void               addCharacteristic(BLECharacteristic* pCharacteristic);
+	BLECharacteristic* createCharacteristic(const char* uuid, uint32_t properties);
 	BLECharacteristic* createCharacteristic(BLEUUID uuid, uint32_t properties);
 	void               dump();
 	void               executeCreate(BLEServer* pServer);
+	BLECharacteristic* getCharacteristic(const char* uuid);
 	BLECharacteristic* getCharacteristic(BLEUUID uuid);
 	BLEUUID            getUUID();
 	BLEServer*         getServer();

cpp_utils/BLEServiceMap.cpp

@@ -10,6 +10,16 @@
 #include <iomanip>
 #include "BLEService.h"
 
+
+/**
+ * @brief Return the service by UUID.
+ * @param [in] UUID The UUID to look up the service.
+ * @return The characteristic.
+ */
+BLEService* BLEServiceMap::getByUUID(const char* uuid) {
+    return getByUUID(BLEUUID(uuid));
+}
+	
 /**
  * @brief Return the service by UUID.
  * @param [in] UUID The UUID to look up the service.