Code changes for #30

nkolban · nkolban · commit 4401dc05e44b · 2017-08-07T19:03:05.000-05:00
diff --git a/cpp_utils/BLEAdvertisedDevice.h b/cpp_utils/BLEAdvertisedDevice.h
@@ -98,7 +98,7 @@ class BLEAdvertisedDeviceCallbacks {
 	 * As we are scanning, we will find new devices.  When found, this call back is invoked with a reference to the
 	 * device that was found.  During any individual scan, a device will only be detected one time.
 	 */
-	virtual void onResult(BLEAdvertisedDevice* pAdvertisedDevice) = 0;
+	virtual void onResult(BLEAdvertisedDevice advertisedDevice) = 0;
 };
 
 #endif /* CONFIG_BT_ENABLED */
diff --git a/cpp_utils/BLEAdvertisedDeviceCallbacks.cpp b/cpp_utils/BLEAdvertisedDeviceCallbacks.cpp
diff --git a/cpp_utils/BLEScan.cpp b/cpp_utils/BLEScan.cpp
@@ -32,21 +32,19 @@ BLEScan::BLEScan() {
 } // BLEScan
 
 
-BLEScan::~BLEScan() {
-	clearAdvertisedDevices();
-} // ~BLEScan
-
 
 /**
  * @brief Clear the history of previously detected advertised devices.
  * @return N/A
  */
+/*
 void BLEScan::clearAdvertisedDevices() {
 	for (int i=0; i<m_vectorAvdertisedDevices.size(); i++) {
 		delete m_vectorAvdertisedDevices[i];
 	}
 	m_vectorAvdertisedDevices.clear();
 } // clearAdvertisedDevices
+*/
 
 
 /**
@@ -92,31 +90,41 @@ void BLEScan::gapEventHandler(
 // ignore it.
 					BLEAddress advertisedAddress(param->scan_rst.bda);
 					bool found = false;
+					/*
 					for (int i=0; i<m_vectorAvdertisedDevices.size(); i++) {
 						if (m_vectorAvdertisedDevices[i]->getAddress().equals(advertisedAddress)) {
 							found = true;
 							break;
 						}
 					}
+					*/
+					for (int i=0; i<m_scanResults.getCount(); i++) {
+						if (m_scanResults.getDevice(i).getAddress().equals(advertisedAddress)) {
+							found = true;
+							break;
+						}
+					}
 					if (found) {
 						ESP_LOGD(LOG_TAG, "Ignoring %s, already seen it.", advertisedAddress.toString().c_str());
 						break;
 					}
 
 					// We now construct a model of the advertised device that we have just found for the first
 					// time.
-					BLEAdvertisedDevice* pAdvertisedDevice = new BLEAdvertisedDevice();
-					pAdvertisedDevice->setAddress(advertisedAddress);
-					pAdvertisedDevice->setRSSI(param->scan_rst.rssi);
-					pAdvertisedDevice->setAdFlag(param->scan_rst.flag);
-					pAdvertisedDevice->parseAdvertisement((uint8_t*)param->scan_rst.ble_adv);
-					pAdvertisedDevice->setScan(this);
-
-					m_vectorAvdertisedDevices.push_back(pAdvertisedDevice);
+					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);
+
+					//m_vectorAvdertisedDevices.push_back(pAdvertisedDevice);
 					if (m_pAdvertisedDeviceCallbacks) {
-						m_pAdvertisedDeviceCallbacks->onResult(pAdvertisedDevice);
+						m_pAdvertisedDeviceCallbacks->onResult(advertisedDevice);
 					}
 
+					m_scanResults.m_vectorAdvertisedDevices.push_back(advertisedDevice);
+
 					break;
 				} // ESP_GAP_SEARCH_INQ_RES_EVT
 
@@ -160,8 +168,8 @@ void BLEScan::setActiveScan(bool active) {
 
 
 /**
- * @brief Set the callbacks to be invoked.
- * @param [in] pAdvertisedDeviceCallbacks Callbacks to be invoked.
+ * @brief Set the call backs to be invoked.
+ * @param [in] pAdvertisedDeviceCallbacks Call backs to be invoked.
  */
 void BLEScan::setAdvertisedDeviceCallbacks(BLEAdvertisedDeviceCallbacks* pAdvertisedDeviceCallbacks) {
 	m_pAdvertisedDeviceCallbacks = pAdvertisedDeviceCallbacks;
@@ -191,27 +199,27 @@ void BLEScan::setWindow(uint16_t windowMSecs) {
  * @param [in] duration The duration in seconds for which to scan.
  * @return N/A.
  */
-std::vector<BLEAdvertisedDevice*> BLEScan::start(uint32_t duration) {
+BLEScanResults BLEScan::start(uint32_t duration) {
 	ESP_LOGD(LOG_TAG, ">> start(%d)", duration);
 
 	m_semaphoreScanEnd.take("start");
 
-	clearAdvertisedDevices();
+	m_scanResults.m_vectorAdvertisedDevices.empty();
 
 	esp_err_t errRc = ::esp_ble_gap_set_scan_params(&m_scan_params);
 
 	if (errRc != ESP_OK) {
 		ESP_LOGE(LOG_TAG, "esp_ble_gap_set_scan_params: err: %d, text: %s", errRc, GeneralUtils::errorToString(errRc));
 		m_semaphoreScanEnd.give();
-		return m_vectorAvdertisedDevices;
+		return m_scanResults;
 	}
 
 	errRc = ::esp_ble_gap_start_scanning(duration);
 
 	if (errRc != ESP_OK) {
 		ESP_LOGE(LOG_TAG, "esp_ble_gap_start_scanning: err: %d, text: %s", errRc, GeneralUtils::errorToString(errRc));
 		m_semaphoreScanEnd.give();
-		return m_vectorAvdertisedDevices;
+		return m_scanResults;
 	}
 
 	m_stopped = false;
@@ -220,7 +228,7 @@ std::vector<BLEAdvertisedDevice*> BLEScan::start(uint32_t duration) {
 	m_semaphoreScanEnd.give();
 
 	ESP_LOGD(LOG_TAG, "<< start()");
-	return m_vectorAvdertisedDevices;
+	return m_scanResults;
 } // start
 
 
@@ -245,4 +253,24 @@ void BLEScan::stop() {
 	ESP_LOGD(LOG_TAG, "<< stop()");
 } // stop
 
+
+/**
+ * @brief Return the count of devices found in the last scan.
+ * @return The number of devices found in the last scan.
+ */
+int BLEScanResults::getCount() {
+	return m_vectorAdvertisedDevices.size();
+} // getCount
+
+
+/**
+ * @brief Return the specified device at the given index.
+ * The index should be between 0 and getCount()-1.
+ * @param [in] i The index of the device.
+ * @return The device at the specified index.
+ */
+BLEAdvertisedDevice BLEScanResults::getDevice(uint32_t i) {
+	return m_vectorAdvertisedDevices.at(i);
+}
+
 #endif /* CONFIG_BT_ENABLED */
diff --git a/cpp_utils/BLEScan.h b/cpp_utils/BLEScan.h
@@ -19,6 +19,16 @@
 class BLEAdvertisedDevice;
 class BLEAdvertisedDeviceCallbacks;
 class BLEClient;
+class BLEScan;
+
+class BLEScanResults {
+public:
+	int getCount();
+	BLEAdvertisedDevice getDevice(uint32_t i);
+private:
+	friend BLEScan;
+	std::vector<BLEAdvertisedDevice> m_vectorAdvertisedDevices;
+};
 
 /**
  * @brief Perform and manage %BLE scans.
@@ -28,30 +38,29 @@ class BLEClient;
 class BLEScan {
 public:
 	BLEScan();
-	virtual ~BLEScan();
 
 	//virtual void onResults();
-	void         setActiveScan(bool active);
-	void         setAdvertisedDeviceCallbacks(BLEAdvertisedDeviceCallbacks* pAdvertisedDeviceCallbacks);
-	void         setInterval(uint16_t intervalMSecs);
-	void         setWindow(uint16_t windowMSecs);
-	std::vector<BLEAdvertisedDevice*> start(uint32_t duration);
-	void         stop();
+	void           setActiveScan(bool active);
+	void           setAdvertisedDeviceCallbacks(BLEAdvertisedDeviceCallbacks* pAdvertisedDeviceCallbacks);
+	void           setInterval(uint16_t intervalMSecs);
+	void           setWindow(uint16_t windowMSecs);
+	BLEScanResults start(uint32_t duration);
+	void           stop();
 
 private:
 	friend class BLE;
 	void         gapEventHandler(
 		esp_gap_ble_cb_event_t  event,
 		esp_ble_gap_cb_param_t* param);
-	void clearAdvertisedDevices();
 	void parseAdvertisement(BLEClient* pRemoteDevice, uint8_t *payload);
 
 
 	esp_ble_scan_params_t         m_scan_params;
 	BLEAdvertisedDeviceCallbacks* m_pAdvertisedDeviceCallbacks;
 	bool                          m_stopped;
 	FreeRTOS::Semaphore m_semaphoreScanEnd = FreeRTOS::Semaphore("ScanEnd");
-	std::vector<BLEAdvertisedDevice*> m_vectorAvdertisedDevices;
+	//std::vector<BLEAdvertisedDevice*> m_vectorAvdertisedDevices;
+	BLEScanResults m_scanResults;
 }; // BLEScan
 
 #endif /* CONFIG_BT_ENABLED */
diff --git a/cpp_utils/Makefile.arduino b/cpp_utils/Makefile.arduino
@@ -16,7 +16,6 @@ BLE_FILES= \
 	BLEAddress.h \
 	BLEAdvertisedDevice.cpp \
 	BLEAdvertisedDevice.h \
-	BLEAdvertisedDeviceCallbacks.cpp \
 	BLEAdvertising.cpp \
 	BLEAdvertising.h \
 	BLECharacteristic.cpp \
diff --git a/cpp_utils/tests/BLE Tests/SampleClient.cpp b/cpp_utils/tests/BLE Tests/SampleClient.cpp
@@ -80,16 +80,16 @@ class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks {
 	/**
 	 * Called for each advertising BLE server.
 	 */
-	void onResult(BLEAdvertisedDevice *pAdvertisedDevice) {
-		ESP_LOGD(LOG_TAG, "Advertised Device: %s", pAdvertisedDevice->toString().c_str());
+	void onResult(BLEAdvertisedDevice advertisedDevice) {
+		ESP_LOGD(LOG_TAG, "Advertised Device: %s", advertisedDevice.toString().c_str());
 
-		if (pAdvertisedDevice->haveServiceUUID() && pAdvertisedDevice->getServiceUUID().equals(serviceUUID)) {
-			pAdvertisedDevice->getScan()->stop();
+		if (advertisedDevice.haveServiceUUID() && advertisedDevice.getServiceUUID().equals(serviceUUID)) {
+			advertisedDevice.getScan()->stop();
 
-			ESP_LOGD(LOG_TAG, "Found our device!  address: %s", pAdvertisedDevice->getAddress().toString().c_str());
+			ESP_LOGD(LOG_TAG, "Found our device!  address: %s", advertisedDevice.getAddress().toString().c_str());
 			MyClient* pMyClient = new MyClient();
 			pMyClient->setStackSize(18000);
-			pMyClient->start(new BLEAddress(*pAdvertisedDevice->getAddress().getNative()));
+			pMyClient->start(new BLEAddress(*advertisedDevice.getAddress().getNative()));
 		} // Found our server
 	} // onResult
 }; // MyAdvertisedDeviceCallbacks
diff --git a/cpp_utils/tests/BLE Tests/SampleScan.cpp b/cpp_utils/tests/BLE Tests/SampleScan.cpp
@@ -10,8 +10,8 @@
 static const char LOG_TAG[] = "SampleScan";
 
 class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks {
-	void onResult(BLEAdvertisedDevice *pAdvertisedDevice) {
-		ESP_LOGD(LOG_TAG, "Advertised Device: %s", pAdvertisedDevice->toString().c_str());
+	void onResult(BLEAdvertisedDevice advertisedDevice) {
+		ESP_LOGD(LOG_TAG, "Advertised Device: %s", advertisedDevice.toString().c_str());
 	}
 };
 
@@ -21,8 +21,8 @@ static void run() {
 	BLEScan* pBLEScan = BLE::getScan();
 	pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
 	pBLEScan->setActiveScan(true);
-	std::vector<BLEAdvertisedDevice*> foundDevices = pBLEScan->start(30);
-	ESP_LOGD(LOG_TAG, "We found %d devices", foundDevices.size());
+	BLEScanResults scanResults = pBLEScan->start(30);
+	ESP_LOGD(LOG_TAG, "We found %d devices", scanResults.getCount());
 	ESP_LOGD(LOG_TAG, "Scanning sample ended");
 }
 
