Updates 2017-11-21 0950

Author: nkolban

src/BLEAdvertisedDevice.cpp

@@ -108,10 +108,21 @@ BLEScan* BLEAdvertisedDevice::getScan() {
  * @brief Get the Service UUID.
  * @return The Service UUID of the advertised device.
  */
-BLEUUID BLEAdvertisedDevice::getServiceUUID() {
-	return m_serviceUUID;
+BLEUUID BLEAdvertisedDevice::getServiceUUID() {  //TODO Remove it eventually, is no longer useful
+	return m_serviceUUIDs[0];
 } // getServiceUUID
 
+/**
+ * @brief Check advertised serviced for existence required UUID
+ * @return Return true if service is advertised
+ */
+bool BLEAdvertisedDevice::isAdvertisingService(BLEUUID uuid){
+	for (int i = 0; i < m_serviceUUIDs.size(); ++i) {
+		if(m_serviceUUIDs[i].equals(uuid))
+			return true;
+	}
+	return false;
+}
 
 /**
  * @brief Get the TX Power.
@@ -198,7 +209,7 @@ void BLEAdvertisedDevice::parseAdvertisement(uint8_t* payload) {
 		payload++; // Skip to type
 		sizeConsumed += 1 + length; // increase the size consumed.
 
-		if (length != 0) { // A length of 0 indicate that we have reached the end.
+		if (length != 0) { // A length of 0 indicates that we have reached the end.
 			ad_type = *payload;
 			payload++;
 			length--;
@@ -231,23 +242,19 @@ void BLEAdvertisedDevice::parseAdvertisement(uint8_t* payload) {
 					break;
 				} // ESP_BLE_AD_TYPE_FLAG
 
-				case ESP_BLE_AD_TYPE_16SRV_CMPL: { // Adv Data Type: 0x03
-					setServiceUUID(BLEUUID(*reinterpret_cast<uint16_t*>(payload)));
-					break;
-				} // ESP_BLE_AD_TYPE_16SRV_CMPL
-
+				case ESP_BLE_AD_TYPE_16SRV_CMPL:
 				case ESP_BLE_AD_TYPE_16SRV_PART: { // Adv Data Type: 0x02
-					setServiceUUID(BLEUUID(*reinterpret_cast<uint16_t*>(payload)));
+					for (int var = 0; var < length/2; ++var) {
+						setServiceUUID(BLEUUID(*reinterpret_cast<uint16_t*>(payload+var*2)));
+					}
 					break;
 				} // ESP_BLE_AD_TYPE_16SRV_PART
 
-				case ESP_BLE_AD_TYPE_32SRV_CMPL: { // Adv Data Type: 0x05
-					setServiceUUID(BLEUUID(*reinterpret_cast<uint32_t*>(payload)));
-					break;
-				} // ESP_BLE_AD_TYPE_32SRV_CMPL
-
+				case ESP_BLE_AD_TYPE_32SRV_CMPL:
 				case ESP_BLE_AD_TYPE_32SRV_PART: { // Adv Data Type: 0x04
-					setServiceUUID(BLEUUID(*reinterpret_cast<uint32_t*>(payload)));
+					for (int var = 0; var < length/4; ++var) {
+						setServiceUUID(BLEUUID(*reinterpret_cast<uint32_t*>(payload+var*4)));
+					}
 					break;
 				} // ESP_BLE_AD_TYPE_32SRV_PART
 
@@ -355,23 +362,25 @@ 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
+} // setServiceUUID
+
 
 /**
  * @brief Set the Service UUID for this device.
  * @param [in] serviceUUID The discovered serviceUUID
  */
 void BLEAdvertisedDevice::setServiceUUID(BLEUUID serviceUUID) {
-	m_serviceUUID     = serviceUUID;
+	m_serviceUUIDs.push_back(serviceUUID);
 	m_haveServiceUUID = true;
-	ESP_LOGD(LOG_TAG, "- setServiceUUID(): serviceUUID: %s", serviceUUID.toString().c_str());
-} // setRSSI
+	ESP_LOGD(LOG_TAG, "- addServiceUUID(): serviceUUID: %s", serviceUUID.toString().c_str());
+} // setServiceUUID
 
 
 /**

src/BLEAdvertisedDevice.h

@@ -38,6 +38,7 @@ class BLEAdvertisedDevice {
 	BLEUUID     getServiceUUID();
 	int8_t      getTXPower();
 
+	bool		isAdvertisingService(BLEUUID uuid);
 	bool        haveAppearance();
 	bool        haveManufacturerData();
 	bool        haveName();
@@ -79,7 +80,7 @@ class BLEAdvertisedDevice {
 	std::string m_name;
 	BLEScan*    m_pScan;
 	int         m_rssi;
-	BLEUUID     m_serviceUUID;
+	std::vector<BLEUUID> m_serviceUUIDs;
 	int8_t      m_txPower;
 };
 

src/BLECharacteristic.cpp

@@ -244,6 +244,7 @@ void BLECharacteristic::handleGATTServerEvent(
 		// - esp_bt_uuid_t char_uuid
 		case ESP_GATTS_ADD_CHAR_EVT: {
 			if (getUUID().equals(BLEUUID(param->add_char.char_uuid)) &&
+					getHandle() == param->add_char.attr_handle &&
 					getService()->getHandle()==param->add_char.service_handle) {
 				m_semaphoreCreateEvt.give();
 			}
@@ -418,11 +419,8 @@ void BLECharacteristic::handleGATTServerEvent(
 
 	// Give each of the descriptors associated with this characteristic the opportunity to handle the
 	// event.
-	BLEDescriptor *pDescriptor = m_descriptorMap.getFirst();
-	while(pDescriptor != nullptr) {
-		pDescriptor->handleGATTServerEvent(event, gatts_if, param);
-		pDescriptor = m_descriptorMap.getNext();
-	}
+
+	m_descriptorMap.handleGATTServerEvent(event, gatts_if, param);
 
 } // handleGATTServerEvent
 
@@ -556,7 +554,9 @@ void BLECharacteristic::setBroadcastProperty(bool value) {
  * @param [in] pCallbacks An instance of a callbacks structure used to define any callbacks for the characteristic.
  */
 void BLECharacteristic::setCallbacks(BLECharacteristicCallbacks* pCallbacks) {
+	ESP_LOGD(LOG_TAG, ">> setCallbacks: 0x%x", (uint32_t)pCallbacks);
 	m_pCallbacks = pCallbacks;
+	ESP_LOGD(LOG_TAG, "<< setCallbacks");
 } // setCallbacks
 
 
@@ -695,4 +695,25 @@ std::string BLECharacteristic::toString() {
 	return stringstream.str();
 } // toString
 
+BLECharacteristicCallbacks::~BLECharacteristicCallbacks() {}
+
+/**
+ * @brief Callback function to support a read request.
+ * @param [in] pCharacteristic The characteristic that is the source of the event.
+ */
+void BLECharacteristicCallbacks::onRead(BLECharacteristic *pCharacteristic) {
+	ESP_LOGD("BLECharacteristicCallbacks", ">> onRead: default");
+	ESP_LOGD("BLECharacteristicCallbacks", "<< onRead");
+} // onRead
+
+
+/**
+ * @brief Callback function to support a write request.
+ * @param [in] pCharacteristic The characteristic that is the source of the event.
+ */
+void BLECharacteristicCallbacks::onWrite(BLECharacteristic *pCharacteristic) {
+	ESP_LOGD("BLECharacteristicCallbacks", ">> onWrite: default");
+	ESP_LOGD("BLECharacteristicCallbacks", "<< onWrite");
+} // onWrite
+
 #endif /* CONFIG_BT_ENABLED */

src/BLECharacteristic.h

@@ -77,6 +77,7 @@ class BLECharacteristic {
 	void setWriteProperty(bool value);
 	void setWriteNoResponseProperty(bool value);
 	std::string toString();
+	uint16_t getHandle();
 
 
 	static const uint32_t PROPERTY_READ      = 1<<0;
@@ -106,7 +107,6 @@ class BLECharacteristic {
 			esp_ble_gatts_cb_param_t* param);
 
 	void                 executeCreate(BLEService* pService);
-	uint16_t             getHandle();
 	esp_gatt_char_prop_t getProperties();
 	BLEService*          getService();
 	void                 setHandle(uint16_t handle);

src/BLECharacteristicMap.cpp

@@ -41,8 +41,8 @@ BLECharacteristic* BLECharacteristicMap::getByUUID(const char* uuid) {
  */
 BLECharacteristic* BLECharacteristicMap::getByUUID(BLEUUID uuid) {
 	for (auto &myPair : m_uuidMap) {
-		if (myPair.second->getUUID().equals(uuid)) {
-			return myPair.second;
+		if (myPair.first->getUUID().equals(uuid)) {
+			return myPair.first;
 		}
 	}
 	//return m_uuidMap.at(uuid.toString());
@@ -59,7 +59,7 @@ BLECharacteristic* BLECharacteristicMap::getFirst() {
 	if (m_iterator == m_uuidMap.end()) {
 		return nullptr;
 	}
-	BLECharacteristic* pRet = m_iterator->second;
+	BLECharacteristic* pRet = m_iterator->first;
 	m_iterator++;
 	return pRet;
 } // getFirst
@@ -73,7 +73,7 @@ BLECharacteristic* BLECharacteristicMap::getNext() {
 	if (m_iterator == m_uuidMap.end()) {
 		return nullptr;
 	}
-	BLECharacteristic* pRet = m_iterator->second;
+	BLECharacteristic* pRet = m_iterator->first;
 	m_iterator++;
 	return pRet;
 } // getNext
@@ -91,7 +91,7 @@ void BLECharacteristicMap::handleGATTServerEvent(
 		esp_ble_gatts_cb_param_t* param) {
 	// Invoke the handler for every Service we have.
 	for (auto &myPair : m_uuidMap) {
-		myPair.second->handleGATTServerEvent(event, gatts_if, param);
+		myPair.first->handleGATTServerEvent(event, gatts_if, param);
 	}
 } // handleGATTServerEvent
 
@@ -115,9 +115,9 @@ void BLECharacteristicMap::setByHandle(uint16_t handle,
  * @return N/A.
  */
 void BLECharacteristicMap::setByUUID(
-		BLEUUID            uuid,
-		BLECharacteristic *pCharacteristic) {
-	m_uuidMap.insert(std::pair<std::string, BLECharacteristic *>(uuid.toString(), pCharacteristic));
+		BLECharacteristic *pCharacteristic,
+		BLEUUID            uuid) {
+	m_uuidMap.insert(std::pair<BLECharacteristic *, std::string>(pCharacteristic, uuid.toString()));
 } // setByUUID
 
 
@@ -134,7 +134,7 @@ std::string BLECharacteristicMap::toString() {
 			stringStream << "\n";
 		}
 		count++;
-		stringStream << "handle: 0x" << std::setw(2) << myPair.second->getHandle() << ", uuid: " + myPair.second->getUUID().toString();
+		stringStream << "handle: 0x" << std::setw(2) << myPair.first->getHandle() << ", uuid: " + myPair.first->getUUID().toString();
 	}
 	return stringStream.str();
 } // toString