MrSwiss
diff --git a/‎cpp_utils/BLEScan.cpp
Lines changed: 72 additions & 44 deletions b/‎cpp_utils/BLEScan.cpp
Lines changed: 72 additions & 44 deletions
diff --git a/‎cpp_utils/BLEScan.h
Lines changed: 10 additions & 7 deletions b/‎cpp_utils/BLEScan.h
Lines changed: 10 additions & 7 deletions
@@ -48,22 +48,21 @@ void BLEScan::handleGAPEvent(
 	esp_gap_ble_cb_event_t  event,
 	esp_ble_gap_cb_param_t* param) {
 
-	switch (event) {
-
-	// ESP_GAP_BLE_SCAN_RESULT_EVT
-	// ---------------------------
-	// scan_rst:
-	// esp_gap_search_evt_t search_evt
-	// esp_bd_addr_t bda
-	// esp_bt_dev_type_t dev_type
-	// esp_ble_addr_type_t ble_addr_type
-	// esp_ble_evt_type_t ble_evt_type
-	// int rssi
-	// uint8_t ble_adv[ESP_BLE_ADV_DATA_LEN_MAX]
-	// int flag
-	// int num_resps
-	// uint8_t adv_data_len
-	// uint8_t scan_rsp_len
+	switch(event) {
+
+		// ---------------------------
+		// scan_rst:
+		// esp_gap_search_evt_t search_evt
+		// esp_bd_addr_t bda
+		// esp_bt_dev_type_t dev_type
+		// esp_ble_addr_type_t ble_addr_type
+		// esp_ble_evt_type_t ble_evt_type
+		// int rssi
+		// uint8_t ble_adv[ESP_BLE_ADV_DATA_LEN_MAX]
+		// int flag
+		// int num_resps
+		// uint8_t adv_data_len
+		// uint8_t scan_rsp_len
 		case ESP_GAP_BLE_SCAN_RESULT_EVT: {
 
 			switch(param->scan_rst.search_evt) {
@@ -73,11 +72,12 @@ void BLEScan::handleGAPEvent(
 				// Event that indicates that the duration allowed for the search has completed or that we have been
 				// asked to stop.
 				case ESP_GAP_SEARCH_INQ_CMPL_EVT: {
+					ESP_LOGW(LOG_TAG, "ESP_GAP_SEARCH_INQ_CMPL_EVT");
 					m_stopped = true;
+					m_semaphoreScanEnd.give();
 					if (m_scanCompleteCB != nullptr) {
 						m_scanCompleteCB(m_scanResults);
 					}
-					m_semaphoreScanEnd.give();
 					break;
 				} // ESP_GAP_SEARCH_INQ_CMPL_EVT
 
@@ -90,52 +90,58 @@ void BLEScan::handleGAPEvent(
 						break;
 					}
 
-					// Examine our list of previously scanned addresses and, if we found this one already,
-					// ignore it.
+// Examine our list of previously scanned addresses and, if we found this one already,
+// ignore it.
 					BLEAddress advertisedAddress(param->scan_rst.bda);
 					bool found = false;
 
-					for (uint32_t i = 0; i < m_scanResults.getCount(); i++) {
-						if (m_s
8000
canResults.getDevice(i).getAddress().equals(advertisedAddress)) {
-							found = true;
-							break;
-						}
+					if (m_scanResults.m_vectorAdvertisedDevices.count(advertisedAddress.toString()) != 0) {
+						found = true;
 					}
+
 					if (found && !m_wantDuplicates) {  // If we found a previous entry AND we don't want duplicates, then we are done.
 						ESP_LOGD(LOG_TAG, "Ignoring %s, already seen it.", advertisedAddress.toString().c_str());
+						vTaskDelay(1);  // <--- allow to switch task in case we scan infinity and dont have new devices to report, or we will blocked here
 						break;
 					}
 
 					// We now construct a model of the advertised device that we have just found for the first
 					// time.
-					BLEAdvertisedDevice advertisedDevice;
-					advertisedDevice.setAddress(advertisedAddress);
-					advertisedDevice.setRSSI(param->scan_rst.rssi);
-					advertisedDevice.setAdFlag(param->scan_rst.flag);
-					advertisedDevice.parseAdvertisement((uint8_t*)param->scan_rst.ble_adv);
-					advertisedDevice.setScan(this);
+					// ESP_LOG_BUFFER_HEXDUMP(LOG_TAG, (uint8_t*)param->scan_rst.ble_adv, param->scan_rst.adv_data_len + param->scan_rst.scan_rsp_len, ESP_LOG_DEBUG);
+					// ESP_LOGW(LOG_TAG, "bytes length: %d + %d, addr type: %d", param->scan_rst.adv_data_len, param->scan_rst.scan_rsp_len, param->scan_rst.ble_addr_type);
+					BLEAdvertisedDevice *advertisedDevice = new BLEAdvertisedDevice();
+					advertisedDevice->setAddress(advertisedAddress);
+					advertisedDevice->setRSSI(param->scan_rst.rssi);
+					advertisedDevice->setAdFlag(param->scan_rst.flag);
+					advertisedDevice->parseAdvertisement((uint8_t*)param->scan_rst.ble_adv, param->scan_rst.adv_data_len + param->scan_rst.scan_rsp_len);
+					advertisedDevice->setScan(this);
+					advertisedDevice->setAddressType(param->scan_rst.ble_addr_type);
 
-					if (m_pAdvertisedDeviceCallbacks) {
-						m_pAdvertisedDeviceCallbacks->onResult(advertisedDevice);
+					if (!found) {   // If we have previously seen this device, don't record it again.
+						m_scanResults.m_vectorAdvertisedDevices.insert(std::pair<std::string, BLEAdvertisedDevice*>(advertisedAddress.toString(), advertisedDevice));
 					}
 
-					if (!found) {   // If we have previously seen this device, don't record it again.
-						m_scanResults.m_vectorAdvertisedDevices.push_back(advertisedDevice);
+					if (m_pAdvertisedDeviceCallbacks) {
+						m_pAdvertisedDeviceCallbacks->onResu
9E81
lt(*advertisedDevice);
 					}
+					if(found)
+						delete advertisedDevice;
 
 					break;
 				} // ESP_GAP_SEARCH_INQ_RES_EVT
 
-				default:
+				default: {
 					break;
+				}
 			} // switch - search_evt
 
 
 			break;
 		} // ESP_GAP_BLE_SCAN_RESULT_EVT
 
-		default:
+		default: {
 			break;
+		} // default
 	} // End switch
 } // gapEventHandler
 
@@ -188,15 +194,23 @@ void BLEScan::setWindow(uint16_t windowMSecs) {
  * @brief Start scanning.
  * @param [in] duration The duration in seconds for which to scan.
  * @param [in] scanCompleteCB A function to be called when scanning has completed.
+ * @param [in] are we continue scan (true) or we want to clear stored devices (false)
  * @return True if scan started or false if there was an error.
  */
-bool BLEScan::start(uint32_t duration, void (*scanCompleteCB)(BLEScanResults)) {
+bool BLEScan::start(uint32_t duration, void (*scanCompleteCB)(BLEScanResults), bool is_continue) {
 	ESP_LOGD(LOG_TAG, ">> start(duration=%d)", duration);
 
 	m_semaphoreScanEnd.take(std::string("start"));
 	m_scanCompleteCB = scanCompleteCB;                  // Save the callback to be invoked when the scan completes.
 
-	m_scanResults.m_vectorAdvertisedDevices.clear();
+	//  if we are connecting to devices that are advertising even after being connected, multiconnecting peripherals
+	//  then we should not clear map or we will connect the same device few times
+	if(!is_continue) {  
+		for(auto _dev : m_scanResults.m_vectorAdvertisedDevices){
+			delete _dev.second;
+		}
+		m_scanResults.m_vectorAdvertisedDevices.clear();
+	}
 
 	esp_err_t errRc = ::esp_ble_gap_set_scan_params(&m_scan_params);
 
@@ -226,8 +240,8 @@ bool BLEScan::start(uint32_t duration, void (*scanCompleteCB)(BLEScanResults)) {
  * @param [in] duration The duration in seconds for which to scan.
  * @return The BLEScanResults.
  */
-BLEScanResults BLEScan::start(uint32_t duration) {
-	if (start(duration, nullptr)) {
+BLEScanResults BLEScan::start(uint32_t duration, bool is_continue) {
+	if(start(duration, nullptr, is_continue)) {
 		m_semaphoreScanEnd.wait("start");   // Wait for the semaphore to release.
 	}
 	return m_scanResults;
@@ -244,24 +258,31 @@ void BLEScan::stop() {
 	esp_err_t errRc = ::esp_ble_gap_stop_scanning();
 
 	m_stopped = true;
+	m_semaphoreScanEnd.give();
 
 	if (errRc != ESP_OK) {
 		ESP_LOGE(LOG_TAG, "esp_ble_gap_stop_scanning: err: %d, text: %s", errRc, GeneralUtils::errorToString(errRc));
 		return;
 	}
 
-	m_semaphoreScanEnd.give();
-
 	ESP_LOGD(LOG_TAG, "<< stop()");
 } // stop
 
+// delete peer device from cache after disconnecting, it is required in case we are connecting to devices with not public address
+void BLEScan::erase(BLEAddress address) {
+	ESP_LOGI(LOG_TAG, "erase device: %s", address.toString().c_str());
+	BLEAdvertisedDevice *advertisedDevice = m_scanResults.m_vectorAdvertisedDevices.find(address.toString())->second;
+	m_scanResults.m_vectorAdvertisedDevices.erase(address.toString());
+	delete advertisedDevice;
+}
+
 
 /**
  * @brief Dump the scan results to the log.
  */
 void BLEScanResults::dump() {
 	ESP_LOGD(LOG_TAG, ">> Dump scan results:");
-	for (uint32_t i = 0; i < getCount(); i++) {
+	for (int i=0; i<getCount(); i++) {
 		ESP_LOGD(LOG_TAG, "- %s", getDevice(i).toString().c_str());
 	}
 } // dump
@@ -283,7 +304,14 @@ int BLEScanResults::getCount() {
  * @return The device at the specified index.
  */
 BLEAdvertisedDevice BLEScanResults::getDevice(uint32_t i) {
-	return m_vectorAdvertisedDevices.at(i);
+	uint32_t x = 0;
+	BLEAdvertisedDevice dev = *m_vectorAdvertisedDevices.begin()->second;
+	for (auto it = m_vectorAdvertisedDevices.begin(); it != m_vectorAdvertisedDevices.end(); it++) {
+		dev = *it->second;
+		if (x==i)	break;
+		x++;
+	}
+	return dev;
 }
 
 
 
@@ -11,7 +11,8 @@
 #if defined(CONFIG_BT_ENABLED)
 #include <esp_gap_ble_api.h>
 
-#include <vector>
+// #include <vector>
+#include <string>
 #include "BLEAdvertisedDevice.h"
 #include "BLEClient.h"
 #include "FreeRTOS.h"
@@ -37,7 +38,7 @@ class BLEScanResults {
 
 private:
 	friend BLEScan;
-	std::vector<BLEAdvertisedDevice> m_vectorAdvertisedDevices;
+	std::map<std::string, BLEAdvertisedDevice*> m_vectorAdvertisedDevices;
 };
 
 /**
@@ -53,22 +54,24 @@ class BLEScan {
 										bool wantDuplicates = false);
 	void           setInterval(uint16_t intervalMSecs);
 	void           setWindow(uint16_t windowMSecs);
-	bool           start(uint32_t duration, void (*scanCompleteCB)(BLEScanResults));
-	BLEScanResults start(uint32_t duration);
+	bool           start(uint32_t duration, void (*scanCompleteCB)(BLEScanResults), bool is_continue = false);
+	BLEScanResults start(uint32_t duration, bool is_continue = false);
 	void           stop();
+	void 		   erase(BLEAddress address);
+	// void 		   setPower(esp_power_level_t powerLevel);
 
 private:
 	BLEScan();   // One doesn't create a new instance instead one asks the BLEDevice for the singleton.
 	friend class BLEDevice;
 	void         handleGAPEvent(
 		esp_gap_ble_cb_event_t  event,
 		esp_ble_gap_cb_param_t* param);
-	void parseAdvertisement(BLEClient* pRemoteDevice, uint8_t* payload);
+	void parseAdvertisement(BLEClient* pRemoteDevice, uint8_t *payload);
 
 
 	esp_ble_scan_params_t         m_scan_params;
-	BLEAdvertisedDeviceCallbacks* m_pAdvertisedDeviceCallbacks;
-	bool                          m_stopped;
+	BLEAdvertisedDeviceCallbacks* m_pAdvertisedDeviceCallbacks = nullptr;
+	bool                          m_stopped = true;
 	FreeRTOS::Semaphore           m_semaphoreScanEnd = FreeRTOS::Semaphore("ScanEnd");
 	BLEScanResults                m_scanResults;
 	bool                          m_wantDuplicates;