heepdog
diff --git a/‎cpp_utils/BLEDevice.cpp
Lines changed: 25 additions & 11 deletions b/‎cpp_utils/BLEDevice.cpp
Lines changed: 25 additions & 11 deletions
diff --git a/‎cpp_utils/BLEScan.cpp
Lines changed: 18 additions & 11 deletions b/‎cpp_utils/BLEScan.cpp
Lines changed: 18 additions & 11 deletions
diff --git a/‎cpp_utils/BLEScan.h
Lines changed: 2 additions & 1 deletion b/‎cpp_utils/BLEScan.h
Lines changed: 2 additions & 1 deletion
diff --git a/‎cpp_utils/BLEServer.cpp
Lines changed: 3 additions & 3 deletions b/‎cpp_utils/BLEServer.cpp
Lines changed: 3 additions & 3 deletions
diff --git a/‎cpp_utils/BLEService.cpp
Lines changed: 78 additions & 0 deletions b/‎cpp_utils/BLEService.cpp
Lines changed: 78 additions & 0 deletions
diff --git a/‎cpp_utils/BLEService.h
Lines changed: 4 additions & 0 deletions b/‎cpp_utils/BLEService.h
Lines changed: 4 additions & 0 deletions
diff --git a/‎cpp_utils/BLEServiceMap.cpp
Lines changed: 7 additions & 3 deletions b/‎cpp_utils/BLEServiceMap.cpp
Lines changed: 7 additions & 3 deletions
diff --git a/‎cpp_utils/WiFi.cpp
Lines changed: 4 additions & 3 deletions b/‎cpp_utils/WiFi.cpp
Lines changed: 4 additions & 3 deletions
diff --git a/‎cpp_utils/WiFi.h
Lines changed: 1 addition & 1 deletion b/‎cpp_utils/WiFi.h
Lines changed: 1 addition & 1 deletion
@@ -30,6 +30,7 @@
 #include "GeneralUtils.h"
 #ifdef ARDUINO_ARCH_ESP32
 #include "esp32-hal-log.h"
+#include "esp32-hal-bt.h"
 #endif
 
 static const char* LOG_TAG = "BLEDevice";
@@ -331,14 +332,21 @@ uint16_t   BLEDevice::m_localMTU = 23;
 	if(!initialized){
 		initialized = true;   // Set the initialization flag to ensure we are only initialized once.
 
-		esp_err_t errRc = ::nvs_flash_init();
+		esp_err_t errRc = ESP_OK;
+#ifdef ARDUINO_ARCH_ESP32
+		if (!btStart()) {
+			errRc = ESP_FAIL;
+			return;
+		}
+#else
+		errRc = ::nvs_flash_init();
 		if (errRc != ESP_OK) {
 			ESP_LOGE(LOG_TAG, "nvs_flash_init: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
 			return;
 		}
 
-	  esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
-	  errRc = esp_bt_controller_init(&bt_cfg);
+		esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
+		errRc = esp_bt_controller_init(&bt_cfg);
 		if (errRc != ESP_OK) {
 			ESP_LOGE(LOG_TAG, "esp_bt_controller_init: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
 			return;
@@ -358,18 +366,24 @@ uint16_t   BLEDevice::m_localMTU = 23;
 			ESP_LOGE(LOG_TAG, "esp_bt_controller_enable: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
 			return;
 		}
+#endif
 #endif
 
-		errRc = esp_bluedroid_init();
-		if (errRc != ESP_OK) {
-			ESP_LOGE(LOG_TAG, "esp_bluedroid_init: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
-			return;
+		esp_bluedroid_status_t bt_state = esp_bluedroid_get_status();
+		if (bt_state == ESP_BLUEDROID_STATUS_UNINITIALIZED){
+			errRc = esp_bluedroid_init();
+			if (errRc != ESP_OK) {
+				ESP_LOGE(LOG_TAG, "esp_bluedroid_init: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
+				return;
+			}
 		}
 
-		errRc = esp_bluedroid_enable();
-		if (errRc != ESP_OK) {
-			ESP_LOGE(LOG_TAG, "esp_bluedroid_enable: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
-			return;
+		if (bt_state != ESP_BLUEDROID_STATUS_ENABLED){
+			errRc = esp_bluedroid_enable();
+			if (errRc != ESP_OK) {
+				ESP_LOGE(LOG_TAG, "esp_bluedroid_enable: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
+				return;
+			}
 		}
 
 		errRc = esp_ble_gap_register_callback(BLEDevice::gapEventHandler);
 
@@ -189,16 +189,14 @@ 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.  This can
- * be supplied as nullptr (the default) in which case the call to start will block until scanning has
- * been completed.
- * @return The BLEScanResults.  Only applicable if we are waiting for results.
+ * @param [in] scanCompleteCB A function to be called when scanning has completed.
+ * @return True if scan started or false if there was an error.
  */
-BLEScanResults BLEScan::start(uint32_t duration, void (*scanCompleteCB)(BLEScanResults)) {
+bool BLEScan::start(uint32_t duration, void (*scanCompleteCB)(BLEScanResults)) {
 	ESP_LOGD(LOG_TAG, ">> start(duration=%d)", duration);
-	m_scanCompleteCB = scanCompleteCB;                  // Save the callback to be invoked when the scan completes.
 
 	m_semaphoreScanEnd.take(std::string("start"));
+	m_scanCompleteCB = scanCompleteCB;                  // Save the callback to be invoked when the scan completes.
 
 	m_scanResults.m_vectorAdvertisedDevices.clear();
 
@@ -207,24 +205,33 @@ BLEScanResults BLEScan::start(uint32_t duration, void (*scanCompleteCB)(BLEScanR
 	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_scanResults;
+		return false;
 	}
 
 	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_scanResults;
+		return false;
 	}
 
 	m_stopped = false;
 
-	if (m_scanCompleteCB == nullptr) {
+	ESP_LOGD(LOG_TAG, "<< start()");
+	return true;
+} // start
+
+
+/**
+ * @brief Start scanning and block until scanning has been completed.
+ * @param [in] duration The duration in seconds for which to scan.
+ * @return The BLEScanResults.
+ */
+BLEScanResults BLEScan::start(uint32_t duration) {
+	if(start(duration, nullptr)) {
 		m_semaphoreScanEnd.wait("start");   // Wait for the semaphore to release.
 	}
-
-	ESP_LOGD(LOG_TAG, "<< start()");
 	return m_scanResults;
 } // start
 
 
@@ -53,7 +53,8 @@ class BLEScan {
 										bool wantDuplicates = false);
 	void           setInterval(uint16_t intervalMSecs);
 	void           setWindow(uint16_t windowMSecs);
-	BLEScanResults start(uint32_t duration, void (*scanCompleteCB)(BLEScanResults) = nullptr);
+	bool           start(uint32_t duration, void (*scanCompleteCB)(BLEScanResults));
+	BLEScanResults start(uint32_t duration);
 	void           stop();
 
 private:
 
@@ -327,9 +327,9 @@ void BLEServer::setCallbacks(BLEServerCallbacks* pCallbacks) {
  * Remove service
  */
 void BLEServer::removeService(BLEService *service) {
-	esp_ble_gatts_delete_service(handle);
-	uint16_t handle = service->getHandle();
-	m_serviceMap->removeService(service);
+	service->stop();
+	service->executeDelete();	
+	m_serviceMap.removeService(service);
 }
 
 /**
 
@@ -91,6 +91,28 @@ void BLEService::executeCreate(BLEServer *pServer) {
 } // executeCreate
 
 
+/**
+ * @brief Delete the service.
+ * Delete the service.
+ * @return N/A.
+ */
+
+void BLEService::executeDelete() {
+	ESP_LOGD(LOG_TAG, ">> executeDelete()");
+	m_semaphoreDeleteEvt.take("executeDelete"); // Take the mutex and release at event ESP_GATTS_DELETE_EVT
+
+	esp_err_t errRc = ::esp_ble_gatts_delete_service( getHandle() );
+
+	if (errRc != ESP_OK) {
+		ESP_LOGE(LOG_TAG, "esp_ble_gatts_delete_service: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
+		return;
+	}
+
+	m_semaphoreDeleteEvt.wait("executeDelete");
+	ESP_LOGD(LOG_TAG, "<< executeDelete");
+} // executeDelete
+
+
 /**
  * @brief Dump details of this BLE GATT service.
  * @return N/A.
@@ -153,6 +175,34 @@ void BLEService::start() {
 } // start
 
 
+/**
+ * @brief Stop the service.
+ * @return Stop the service.
+ */
+void BLEService::stop() {
+// We ask the BLE runtime to start the service and then create each of the characteristics.
+// We start the service through its local handle which was returned in the ESP_GATTS_CREATE_EVT event
+// obtained as a result of calling esp_ble_gatts_create_service().
+//
+	ESP_LOGD(LOG_TAG, ">> stop(): Stopping service (esp_ble_gatts_stop_service): %s", toString().c_str());
+	if (m_handle == NULL_HANDLE) {
+		ESP_LOGE(LOG_TAG, "<< !!! We attempted to stop a service but don't know its handle!");
+		return;
+	}
+
+	m_semaphoreStopEvt.take("stop");
+	esp_err_t errRc = ::esp_ble_gatts_stop_service(m_handle);
+
+	if (errRc != ESP_OK) {
+		ESP_LOGE(LOG_TAG, "<< esp_ble_gatts_stop_service: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
+		return;
+	}
+	m_semaphoreStopEvt.wait("stop");
+
+	ESP_LOGD(LOG_TAG, "<< stop()");
+} // start
+
+
 /**
  * @brief Set the handle associated with this service.
  * @param [in] handle The handle associated with the service.
@@ -278,6 +328,19 @@ void BLEService::handleGATTServerEvent(
 			break;
 		} // ESP_GATTS_START_EVT
 
+		// ESP_GATTS_STOP_EVT
+		//
+		// stop:
+		// esp_gatt_status_t status
+		// uint16_t service_handle
+		//
+		case ESP_GATTS_STOP_EVT: {
+			if (param->stop.service_handle == getHandle()) {
+				m_semaphoreStopEvt.give();
+			}
+			break;
+		} // ESP_GATTS_STOP_EVT
+
 
 		// ESP_GATTS_CREATE_EVT
 		// Called when a new service is registered as having been created.
@@ -299,6 +362,21 @@ void BLEService::handleGATTServerEvent(
 			break;
 		} // ESP_GATTS_CREATE_EVT
 
+
+		// ESP_GATTS_DELETE_EVT
+		// Called when a service is deleted.
+		//
+		// delete:
+		// * esp_gatt_status_t status
+		// * uint16_t service_handle
+		//
+		case ESP_GATTS_DELETE_EVT: {
+			if (param->del.service_handle == getHandle()) {
+				m_semaphoreDeleteEvt.give();
+			}
+			break;
+		} // ESP_GATTS_DELETE_EVT
+
 		default: {
 			break;
 		} // Default
 
@@ -57,11 +57,13 @@ class BLEService {
 	BLECharacteristic* createCharacteristic(BLEUUID uuid, uint32_t properties);
 	void               dump();
 	void               executeCreate(BLEServer* pServer);
+	void			   executeDelete();
 	BLECharacteristic* getCharacteristic(const char* uuid);
 	BLECharacteristic* getCharacteristic(BLEUUID uuid);
 	BLEUUID            getUUID();
 	BLEServer*         getServer();
 	void               start();
+	void			   stop();
 	std::string        toString();
 	uint16_t           getHandle();
 	uint8_t			   m_id = 0;
@@ -82,7 +84,9 @@ class BLEService {
 	BLEUUID              m_uuid;
 
 	FreeRTOS::Semaphore  m_semaphoreCreateEvt = FreeRTOS::Semaphore("CreateEvt");
+	FreeRTOS::Semaphore  m_semaphoreDeleteEvt = FreeRTOS::Semaphore("DeleteEvt");
 	FreeRTOS::Semaphore  m_semaphoreStartEvt  = FreeRTOS::Semaphore("StartEvt");
+	FreeRTOS::Semaphore  m_semaphoreStopEvt   = FreeRTOS::Semaphore("StopEvt");
 
 	uint32_t             m_numHandles;
 
 
@@ -120,9 +120,13 @@ BLEService* BLEServiceMap::getNext() {
 	return pRet;
 } // getNext
 
+/**
+ * @brief Removes service from maps.
+ * @return N/A.
+ */
 void BLEServiceMap::removeService(BLEService *service){
-	m_handleMap->erase(serice->getHandle());
-	m_uuidMap->erase(service);
-}
+	m_handleMap.erase(service->getHandle());
+	m_uuidMap.erase(service);
+} // removeService
 
 #endif /* CONFIG_BT_ENABLED */
@@ -153,9 +153,10 @@ void WiFi::setDNSServer(int numdns, ip_addr_t ip) {
  * @param [in] ssid The network SSID of the access point to which we wish to connect.
  * @param [in] password The password of the access point to which we wish to connect.
  * @param [in] waitForConnection Block until the connection has an outcome.
- * @returns ESP_OK if successfully receives a SYSTEM_EVENT_STA_GOT_IP event.  Otherwise returns wifi_err_reason_t - use GeneralUtils::wifiErrorToString(uint8_t errCode) to print the error.
+ * @param [in] mode WIFI_MODE_AP for normal or WIFI_MODE_APSTA if you want to keep an Access Point running while you connect
+ * @return ESP_OK if we are now connected and wifi_err_reason_t if not.
  */
-uint8_t WiFi::connectAP(const std::string& ssid, const std::string& password, bool waitForConnection){
+uint8_t WiFi::connectAP(const std::string& ssid, const std::string& password, bool waitForConnection, wifi_mode_t mode){
 	ESP_LOGD(LOG_TAG, ">> connectAP");
 
 	m_apConnectionStatus = UINT8_MAX;
@@ -172,7 +173,7 @@ uint8_t WiFi::connectAP(const std::string& ssid, const std::string& password, bo
 			::tcpip_adapter_set_ip_info(TCPIP_ADAPTER_IF_STA, &ipInfo);
 	}
 
-	esp_err_t errRc = ::esp_wifi_set_mode(WIFI_MODE_STA);
+	esp_err_t errRc = ::esp_wifi_set_mode(mode);
 	if (errRc != ESP_OK) {
 		ESP_LOGE(LOG_TAG, "esp_wifi_set_mode: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
 		abort();
 
@@ -130,7 +130,7 @@ class WiFi {
     void                      setDNSServer(int numdns, ip_addr_t ip);
     struct in_addr            getHostByName(const std::string& hostName);
     struct in_addr            getHostByName(const char* hostName);
-    uint8_t                   connectAP(const std::string& ssid, const std::string& password, bool waitForConnection=true);
+    uint8_t                   connectAP(const std::string& ssid, const std::string& password, bool waitForConnection=true, wifi_mode_t mode=WIFI_MODE_STA);
     void                      dump();
     bool                      isConnectedToAP();
     static std::string        getApMac();