Merge branch 'master' into Jira896

SidLeung · web-flow · commit 4225e79d647c · 2017-03-22T22:45:03.000-07:00
diff --git a/libraries/CurieBLE/src/BLECharacteristic.cpp b/libraries/CurieBLE/src/BLECharacteristic.cpp
@@ -283,6 +283,10 @@ bool BLECharacteristic::writeValue(const byte value[], int length, int offset)
                                                                    characteristicImp->valueLength());
             BLEDeviceManager::instance()->startAdvertising();
         }
+    } else {
+        // not associated with a service yet
+        _setValue(value, length);
+        retVar = true;
     }
     return retVar;
 }
diff --git a/libraries/CurieBLE/src/internal/BLECharacteristicImp.cpp b/libraries/CurieBLE/src/internal/BLECharacteristicImp.cpp
@@ -697,15 +697,7 @@ bool BLECharacteristicImp::write(const unsigned char value[],
     }
     
     // Send write request
-    if (_gatt_chrc.properties | BT_GATT_CHRC_WRITE_WITHOUT_RESP)
-    {
-        retval = bt_gatt_write_without_response(conn, 
-                                                _value_handle,
-                                                value, 
-                                                length, 
-                                                false);
-    }
-    else if (_gatt_chrc.properties | BT_GATT_CHRC_WRITE)
+    if (_gatt_chrc.properties & BT_GATT_CHRC_WRITE)
     {
         _gattc_writing = true;
         retval = bt_gatt_write(conn, 
@@ -718,6 +710,13 @@ bool BLECharacteristicImp::write(const unsigned char value[],
         {
             delay(2);
         }
+    } else if (_gatt_chrc.properties & BT_GATT_CHRC_WRITE_WITHOUT_RESP)
+    {
+        retval = bt_gatt_write_without_response(conn, 
+                                                _value_handle,
+                                                value, 
+                                                length, 
+                                                false);
     }
     bt_conn_unref(conn);
     return (0 == retval);
diff --git a/libraries/CurieBLE/src/internal/BLEDescriptorImp.cpp b/libraries/CurieBLE/src/internal/BLEDescriptorImp.cpp
@@ -172,6 +172,7 @@ bool BLEDescriptorImp::read()
 {
     int retval = 0;
     bt_conn_t* conn = NULL;
+    bool ret_bool = true;
     
     if (true == BLEUtils::isLocalBLE(_bledev))
     {
@@ -209,6 +210,13 @@ bool BLEDescriptorImp::read()
     {
         _reading = true;
     }
+    
+    // Block the read
+    while (_reading == true && ret_bool)
+    {
+        delay(5);
+        ret_bool = _bledev.connected();
+    }
     return _reading;
 }
 
@@ -219,6 +227,12 @@ bool BLEDescriptorImp::writeValue(const byte value[],
     bool ret = true;
     int total_length = length + offset;
     int write_len = length;
+    
+    if (_reading)
+    {
+        _reading = false;
+    }
+    
     if (total_length > BLE_MAX_ATTR_DATA_LEN)
     {
         return false;
diff --git a/libraries/CurieBLE/src/internal/BLEDeviceManager.cpp b/libraries/CurieBLE/src/internal/BLEDeviceManager.cpp
@@ -101,8 +101,6 @@ BLEDeviceManager::BLEDeviceManager():
     
     memset(&_available_for_connect_peripheral_adv_data, 0, sizeof(_available_for_connect_peripheral_adv_data));
     memset(&_available_for_connect_peripheral_scan_rsp_data, 0, sizeof(_available_for_connect_peripheral_scan_rsp_data));
-
-    memset(&_wait_for_connect_peripheral, 0, sizeof(_wait_for_connect_peripheral));
     
     memset(&_service_uuid, 0, sizeof(_service_uuid));
     memset(&_service_solicit_uuid, 0, sizeof(_service_solicit_uuid));
@@ -576,6 +574,25 @@ BLEDevice BLEDeviceManager::peripheral()
     return temp;
 }
 
+void BLEDeviceManager::_clearAdvertiseBuffer()
+{
+    
+    // Clear the previous found ADV
+    memset(_peer_temp_adv_buffer, 0, sizeof(_peer_temp_adv_buffer));
+    memset(_peer_temp_adv_data, 0, sizeof(_peer_temp_adv_data));
+    memset(_peer_temp_adv_data_len, 0, sizeof(_peer_temp_adv_data_len));
+    memset(_peer_temp_adv_connectable, 0, sizeof(_peer_adv_connectable));
+    
+    memset(_peer_adv_buffer, 0, sizeof(_peer_adv_buffer));
+    memset(_peer_adv_mill, 0, sizeof(_peer_adv_mill));
+    memset(_peer_adv_data, 0, sizeof(_peer_adv_data));
+    memset(_peer_adv_data_len, 0, sizeof(_peer_adv_data_len));
+    memset(_peer_scan_rsp_data, 0, sizeof(_peer_scan_rsp_data));
+    memset(_peer_scan_rsp_data_len, 0, sizeof(_peer_scan_rsp_data_len));
+    memset(_peer_adv_rssi, 0, sizeof(_peer_adv_rssi));
+    
+}
+
 bool BLEDeviceManager::startScanningWithDuplicates()
 {
     _adv_duplicate_filter_enabled = false;
@@ -901,11 +918,6 @@ int BLEDeviceManager::advertisedServiceUuidCount(const BLEDevice* device) const
             return service_cnt;
         }
 
-        if ((len + 1) > adv_data_len) {    // Sid. KW, can't be (adv_data_len < 2)
-            pr_info(LOG_MODULE_BLE, "AD malformed\n");
-            return service_cnt;
-        }
-
 	/* Sid, 2/15/2017.  Sandeep reported that Apple devices may use
 	   BT_DATA_UUID16_SOME and BT_DATA_UUID128_SOME in addition to ALL.
 	   Practically, these types are same as ALL. */
@@ -1072,6 +1084,11 @@ bool BLEDeviceManager::connect(BLEDevice &device)
     uint64_t timestamp = millis();
     uint64_t timestampcur = timestamp;
     bool ret = true;
+    if (_available_for_connect_peripheral_connectable == false)
+    {
+        return false;
+    }
+    
     bt_addr_le_copy(&_wait_for_connect_peripheral, device.bt_le_address());
     // Buffer the ADV data
     memcpy(_wait_for_connect_peripheral_adv_data, _available_for_connect_peripheral_adv_data, BLE_MAX_ADV_SIZE);
@@ -1252,6 +1269,8 @@ void BLEDeviceManager::handleDisconnectEvent(bt_conn_t *conn, uint8_t reason)
                 memset(_peer_peripheral_adv_data[i], 0, BLE_MAX_ADV_SIZE);
                 _peer_peripheral_adv_data_len[i] = 0;
                 _peer_peripheral_adv_rssi[i] = 0;
+                memset(_peer_peripheral_scan_rsp_data[i], 0, BLE_MAX_ADV_SIZE);
+                _peer_peripheral_scan_rsp_data_len[i] = 0;
                 break;
             }
         }
@@ -1411,7 +1430,10 @@ bool BLEDeviceManager::setAdvertiseBuffer(const bt_addr_le_t* bt_addr,
         {
             max_delta = timestamp_delta;
             if (max_delta > 2000) // expired
+            {
                 index = i;
+                _peer_scan_rsp_data_len[index] = 0; // Invalid the scan response
+            }
         }
         
         if (bt_addr_le_cmp(temp, bt_addr) == 0)
diff --git a/libraries/CurieBLE/src/internal/BLEDeviceManager.h b/libraries/CurieBLE/src/internal/BLEDeviceManager.h
@@ -358,6 +358,7 @@ class BLEDeviceManager
                                    const uint8_t* data, 
                                    uint8_t length);
     BLE_STATUS_T _advDataInit(void);
+    void _clearAdvertiseBuffer();
     bool advertiseDataProc(uint8_t type, 
                            const uint8_t *dataPtr, 
                            uint8_t data_len);

Original file line number	Diff line number	Diff line change
`@@ -283,6 +283,10 @@ bool BLECharacteristic::writeValue(const byte value[], int length, int offset)`
`283`	`283`	`characteristicImp->valueLength());`
`284`	`284`	`BLEDeviceManager::instance()->startAdvertising();`
`285`	`285`	`}`
	`286`	`+ } else {`
	`287`	`+ // not associated with a service yet`
	`288`	`+ _setValue(value, length);`
	`289`	`+ retVar = true;`
`286`	`290`	`}`
`287`	`291`	`return retVar;`
`288`	`292`	`}`
Original file line number	Diff line number	Diff line change
`@@ -697,15 +697,7 @@ bool BLECharacteristicImp::write(const unsigned char value[],`
`697`	`697`	`}`
`698`	`698`
`699`	`699`	`// Send write request`
`700`		`- if (_gatt_chrc.properties \| BT_GATT_CHRC_WRITE_WITHOUT_RESP)`
`701`		`- {`
`702`		`- retval = bt_gatt_write_without_response(conn,`
`703`		`- _value_handle,`
`704`		`- value,`
`705`		`- length,`
`706`		`- false);`
`707`		`- }`
`708`		`- else if (_gatt_chrc.properties \| BT_GATT_CHRC_WRITE)`
	`700`	`+ if (_gatt_chrc.properties & BT_GATT_CHRC_WRITE)`
`709`	`701`	`{`
`710`	`702`	`_gattc_writing = true;`
`711`	`703`	`retval = bt_gatt_write(conn,`
`@@ -718,6 +710,13 @@ bool BLECharacteristicImp::write(const unsigned char value[],`
`718`	`710`	`{`
`719`	`711`	`delay(2);`
`720`	`712`	`}`
	`713`	`+ } else if (_gatt_chrc.properties & BT_GATT_CHRC_WRITE_WITHOUT_RESP)`
	`714`	`+ {`
	`715`	`+ retval = bt_gatt_write_without_response(conn,`
	`716`	`+ _value_handle,`
	`717`	`+ value,`
	`718`	`+ length,`
	`719`	`+ false);`
`721`	`720`	`}`
`722`	`721`	`bt_conn_unref(conn);`
`723`	`722`	`return (0 == retval);`
Original file line number	Diff line number	Diff line change
`@@ -172,6 +172,7 @@ bool BLEDescriptorImp::read()`
`172`	`172`	`{`
`173`	`173`	`int retval = 0;`
`174`	`174`	`bt_conn_t* conn = NULL;`
	`175`	`+ bool ret_bool = true;`
`175`	`176`
`176`	`177`	`if (true == BLEUtils::isLocalBLE(_bledev))`
`177`	`178`	`{`
`@@ -209,6 +210,13 @@ bool BLEDescriptorImp::read()`
`209`	`210`	`{`
`210`	`211`	`_reading = true;`
`211`	`212`	`}`
	`213`	`+`
	`214`	`+ // Block the read`
	`215`	`+ while (_reading == true && ret_bool)`
	`216`	`+ {`
	`217`	`+ delay(5);`
	`218`	`+ ret_bool = _bledev.connected();`
	`219`	`+ }`
`212`	`220`	`return _reading;`
`213`	`221`	`}`
`214`	`222`
`@@ -219,6 +227,12 @@ bool BLEDescriptorImp::writeValue(const byte value[],`
`219`	`227`	`bool ret = true;`
`220`	`228`	`int total_length = length + offset;`
`221`	`229`	`int write_len = length;`
	`230`	`+`
	`231`	`+ if (_reading)`
	`232`	`+ {`
	`233`	`+ _reading = false;`
	`234`	`+ }`
	`235`	`+`
`222`	`236`	`if (total_length > BLE_MAX_ATTR_DATA_LEN)`
`223`	`237`	`{`
`224`	`238`	`return false;`