Merge commit 'b232e7f5f0e87f36afbc2f4e03a2c49c48dd47bc'

1 files changed, 87 insertions, 22 deletions

diff --git a/sensor/patchedBLE/src/BLEClient.cpp b/sensor/patchedBLE/src/BLEClient.cpp
index 141cf0f..0e552ec 100644
--- a/sensor/patchedBLE/src/BLEClient.cpp
+++ b/sensor/patchedBLE/src/BLEClient.cpp
@@ -6,7 +6,6 @@
  */
 #include "sdkconfig.h"
 #if defined(CONFIG_BT_ENABLED)
-#include <esp_log.h>
 #include <esp_bt.h>
 #include <esp_bt_main.h>
 #include <esp_gap_ble_api.h>
@@ -18,10 +17,16 @@
 #include <string>
 #include <sstream>
 #include <unordered_set>
-#ifdef ARDUINO_ARCH_ESP32
+#include "BLEDevice.h"
+#if defined(ARDUINO_ARCH_ESP32) && defined(CONFIG_ARDUHAL_ESP_LOG)
 #include "esp32-hal-log.h"
+#define LOG_TAG ""
+#else
+#include "esp_log.h"
+static const char* LOG_TAG = "BLEClient";
 #endif
 
+
 /*
  * Design
  * ------
@@ -42,12 +47,11 @@
  *
  *
  */
-static const char* LOG_TAG = "BLEClient";
 
 BLEClient::BLEClient() {
 	m_pClientCallbacks = nullptr;
-	m_conn_id          = 0;
-	m_gattc_if         = 0;
+	m_conn_id          = ESP_GATT_IF_NONE;
+	m_gattc_if         = ESP_GATT_IF_NONE;
 	m_haveServices     = false;
 	m_isConnected      = false;  // Initially, we are flagged as not connected.
 } // BLEClient
@@ -81,22 +85,31 @@ void BLEClient::clearServices() {
 	ESP_LOGD(LOG_TAG, "<< clearServices");
 } // clearServices
 
+/**
+ * Add overloaded function to ease connect to peer device with not public address
+ */
+bool BLEClient::connect(BLEAdvertisedDevice* device) {
+	BLEAddress address =  device->getAddress();
+	esp_ble_addr_type_t type = device->getAddressType();
+	return connect(address, type);
+}
 
 /**
  * @brief Connect to the partner (BLE Server).
  * @param [in] address The address of the partner.
  * @return True on success.
  */
-bool BLEClient::connect(BLEAddress address) {
+bool BLEClient::connect(BLEAddress address, esp_ble_addr_type_t type) {
 	ESP_LOGD(LOG_TAG, ">> connect(%s)", address.toString().c_str());
 
 // We need the connection handle that we get from registering the application.  We register the app
 // and then block on its completion.  When the event has arrived, we will have the handle.
+	m_appId = BLEDevice::m_appId++;
+	BLEDevice::addPeerDevice(this, true, m_appId);
 	m_semaphoreRegEvt.take("connect");
 
-	clearServices(); // Delete any services that may exist.
-
-	esp_err_t errRc = ::esp_ble_gattc_app_register(0);
+	// clearServices(); // we dont need to delete services since every client is unique?
+	esp_err_t errRc = ::esp_ble_gattc_app_register(m_appId);
 	if (errRc != ESP_OK) {
 		ESP_LOGE(LOG_TAG, "esp_ble_gattc_app_register: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
 		return false;
@@ -109,10 +122,10 @@ bool BLEClient::connect(BLEAddress address) {
 	// Perform the open connection request against the target BLE Server.
 	m_semaphoreOpenEvt.take("connect");
 	errRc = ::esp_ble_gattc_open(
-		getGattcIf(),
+		m_gattc_if,
 		*getPeerAddress().getNative(), // address
-		BLE_ADDR_TYPE_PUBLIC,          // Note: This was added on 2018-04-03 when the latest ESP-IDF was detected to have changed the signature.
-		1                              // direct connection
+		type,          // Note: This was added on 2018-04-03 when the latest ESP-IDF was detected to have changed the signature.
+		1                              // direct connection <-- maybe needs to be changed in case of direct indirect connection???
 	);
 	if (errRc != ESP_OK) {
 		ESP_LOGE(LOG_TAG, "esp_ble_gattc_open: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
@@ -136,8 +149,6 @@ void BLEClient::disconnect() {
 		ESP_LOGE(LOG_TAG, "esp_ble_gattc_close: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
 		return;
 	}
-	esp_ble_gattc_app_unregister(getGattcIf());
-	m_peerAddress = BLEAddress("00:00:00:00:00:00");
 	ESP_LOGD(LOG_TAG, "<< disconnect()");
 } // disconnect
 
@@ -150,9 +161,22 @@ void BLEClient::gattClientEventHandler(
 	esp_gatt_if_t             gattc_if,
 	esp_ble_gattc_cb_param_t* evtParam) {
 
+	ESP_LOGD(LOG_TAG, "gattClientEventHandler [esp_gatt_if: %d] ... %s",
+		gattc_if, BLEUtils::gattClientEventTypeToString(event).c_str());
+
 	// Execute handler code based on the type of event received.
 	switch(event) {
 
+		case ESP_GATTC_SRVC_CHG_EVT:
+			ESP_LOGI(LOG_TAG, "SERVICE CHANGED");
+			break;
+
+		case ESP_GATTC_CLOSE_EVT: {
+				// esp_ble_gattc_app_unregister(m_appId);
+				// BLEDevice::removePeerDevice(m_gattc_if, true);
+			break;
+		}
+
 		//
 		// ESP_GATTC_DISCONNECT_EVT
 		//
@@ -163,10 +187,12 @@ void BLEClient::gattClientEventHandler(
 		case ESP_GATTC_DISCONNECT_EVT: {
 				// If we receive a disconnect event, set the class flag that indicates that we are
 				// no longer connected.
+				m_isConnected = false;
 				if (m_pClientCallbacks != nullptr) {
 					m_pClientCallbacks->onDisconnect(this);
 				}
-				m_isConnected = false;
+				BLEDevice::removePeerDevice(m_appId, true);
+				esp_ble_gattc_app_unregister(m_gattc_if);
 				m_semaphoreRssiCmplEvt.give();
 				m_semaphoreSearchCmplEvt.give(1);
 				break;
@@ -179,7 +205,6 @@ void BLEClient::gattClientEventHandler(
 		// - esp_gatt_status_t status
 		// - uint16_t          conn_id
 		// - esp_bd_addr_t     remote_bda
-		// - uint16_t          mtu
 		//
 		case ESP_GATTC_OPEN_EVT: {
 			m_conn_id = evtParam->open.conn_id;
@@ -207,6 +232,26 @@ void BLEClient::gattClientEventHandler(
 			break;
 		} // ESP_GATTC_REG_EVT
 
+		case ESP_GATTC_CFG_MTU_EVT:
+			if(evtParam->cfg_mtu.status != ESP_GATT_OK) {
+				ESP_LOGE(LOG_TAG,"Config mtu failed");
+			}
+			m_mtu = evtParam->cfg_mtu.mtu;
+			break;
+
+		case ESP_GATTC_CONNECT_EVT: {
+			BLEDevice::updatePeerDevice(this, true, m_gattc_if);
+			esp_err_t errRc = esp_ble_gattc_send_mtu_req(gattc_if, evtParam->connect.conn_id);
+			if (errRc != ESP_OK) {
+				ESP_LOGE(LOG_TAG, "esp_ble_gattc_send_mtu_req: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
+			}
+#ifdef CONFIG_BLE_SMP_ENABLE   // Check that BLE SMP (security) is configured in make menuconfig
+			if(BLEDevice::m_securityLevel){
+				esp_ble_set_encryption(evtParam->connect.remote_bda, BLEDevice::m_securityLevel);
+			}
+#endif	// CONFIG_BLE_SMP_ENABLE
+			break;
+		} // ESP_GATTC_CONNECT_EVT
 
 		//
 		// ESP_GATTC_SEARCH_CMPL_EVT
@@ -216,6 +261,21 @@ void BLEClient::gattClientEventHandler(
 		// - uint16_t          conn_id
 		//
 		case ESP_GATTC_SEARCH_CMPL_EVT: {
+			esp_ble_gattc_cb_param_t* p_data = (esp_ble_gattc_cb_param_t*)evtParam;
+			if (p_data->search_cmpl.status != ESP_GATT_OK){
+				ESP_LOGE(LOG_TAG, "search service failed, error status = %x", p_data->search_cmpl.status);
+				break;
+			}
+#ifndef ARDUINO_ARCH_ESP32
+// commented out just for now to keep backward compatibility			
+			// if(p_data->search_cmpl.searched_service_source == ESP_GATT_SERVICE_FROM_REMOTE_DEVICE) {
+			// 	ESP_LOGI(LOG_TAG, "Get service information from remote device");
+			// } else if (p_data->search_cmpl.searched_service_source == ESP_GATT_SERVICE_FROM_NVS_FLASH) {
+			// 	ESP_LOGI(LOG_TAG, "Get service information from flash");
+			// } else {
+			// 	ESP_LOGI(LOG_TAG, "unknown service source");
+			// }
+#endif
 			m_semaphoreSearchCmplEvt.give(0);
 			break;
 		} // ESP_GATTC_SEARCH_CMPL_EVT
@@ -238,7 +298,8 @@ void BLEClient::gattClientEventHandler(
 				evtParam->search_res.start_handle,
 				evtParam->search_res.end_handle
 			);
-			m_servicesMap.insert(std::pair<std::string, BLERemoteService *>(uuid.toString(), pRemoteService));
+			m_servicesMap.insert(std::pair<std::string, BLERemoteService*>(uuid.toString(), pRemoteService));
+			m_servicesMapByInstID.insert(std::pair<BLERemoteService *, uint16_t>(pRemoteService, evtParam->search_res.srvc_id.inst_id));
 			break;
 		} // ESP_GATTC_SEARCH_RES_EVT
 
@@ -337,7 +398,7 @@ BLERemoteService* BLEClient::getService(BLEUUID uuid) {
 		}
 	} // End of each of the services.
 	ESP_LOGD(LOG_TAG, "<< getService: not found");
-	throw new BLEUuidNotFoundException;
+	return nullptr;
 } // getService
 
 
@@ -356,14 +417,15 @@ std::map<std::string, BLERemoteService*>* BLEClient::getServices() {
  * and will culminate with an ESP_GATTC_SEARCH_CMPL_EVT when all have been received.
  */
 	ESP_LOGD(LOG_TAG, ">> getServices");
-
+// TODO implement retrieving services from cache
 	clearServices(); // Clear any services that may exist.
 
 	esp_err_t errRc = esp_ble_gattc_search_service(
 		getGattcIf(),
 		getConnId(),
-		nullptr            // Filter UUID
+		NULL            // Filter UUID
 	);
+
 	m_semaphoreSearchCmplEvt.take("getServices");
 	if (errRc != ESP_OK) {
 		ESP_LOGE(LOG_TAG, "esp_ble_gattc_search_service: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
@@ -400,7 +462,7 @@ void BLEClient::handleGAPEvent(
 		esp_gap_ble_cb_event_t  event,
 		esp_ble_gap_cb_param_t* param) {
 	ESP_LOGD(LOG_TAG, "BLEClient ... handling GAP event!");
-	switch(event) {
+	switch (event) {
 		//
 		// ESP_GAP_BLE_READ_RSSI_COMPLETE_EVT
 		//
@@ -410,7 +472,7 @@ void BLEClient::handleGAPEvent(
 		// - esp_bd_addr_t remote_addr
 		//
 		case ESP_GAP_BLE_READ_RSSI_COMPLETE_EVT: {
-			m_semaphoreRssiCmplEvt.give((uint32_t)param->read_rssi_cmpl.rssi);
+			m_semaphoreRssiCmplEvt.give((uint32_t) param->read_rssi_cmpl.rssi);
 			break;
 		} // ESP_GAP_BLE_READ_RSSI_COMPLETE_EVT
 
@@ -451,6 +513,9 @@ void BLEClient::setValue(BLEUUID serviceUUID, BLEUUID characteristicUUID, std::s
 	ESP_LOGD(LOG_TAG, "<< setValue");
 } // setValue
 
+uint16_t BLEClient::getMTU() {
+	return m_mtu;
+}
 
 /**
  * @brief Return a string representation of this client.