Jira 836, Enumerate non connectable Peripherals in Central scan …

Added feature:
  - In Central mode, the BLE library should enumerate Peripheral
    that are non-connectable (eg beacon).

Code Mods:
1. BLEDevice.cpp:
   - Add the call to get Manufacturer Data info from a
     Peripheral.  Non-connectable device may only broadcast
     this info.
2. BLEDevice.h:
   - Prototyping.
3. BLEDeviceManager.cpp:
   - Delete the filter about non-connectable advertisement.
   - Added APIs, hasManufacturerData(), setManufacturerData(),
     hasManufacturerData(), to gain access to adv info
     of non-connectable Peripherals.

Author: sgbihu

libraries/CurieBLE/src/BLEDevice.cpp

@@ -133,6 +133,17 @@ void BLEDevice::setManufacturerData(const unsigned char manufacturerData[],
     BLEDeviceManager::instance()->setManufacturerData(manufacturerData, manufacturerDataLength);
 }
 
+bool BLEDevice::getManufacturerData (unsigned char* manu_data, 
+                                     unsigned char& manu_data_len) const
+{
+    return BLEDeviceManager::instance()->getManufacturerData(this, manu_data, manu_data_len);
+}
+
+bool BLEDevice::hasManufacturerData() const
+{
+    return BLEDeviceManager::instance()->hasManufacturerData(this);
+}
+
 void BLEDevice::setLocalName(const char *localName)
 {
     BLEDeviceManager::instance()->setLocalName(localName);

libraries/CurieBLE/src/BLEDevice.h

@@ -191,6 +191,11 @@ class BLEDevice
     void setManufacturerData(const unsigned char manufacturerData[], 
                              unsigned char manufacturerDataLength);
 
+    bool getManufacturerData (unsigned char* manu_data, 
+                              unsigned char& manu_data_len) const;
+    
+    bool hasManufacturerData() const;
+    
     /**
      * Set the local name that the BLE Peripheral Device advertises
      *

libraries/CurieBLE/src/internal/BLEDeviceManager.cpp

@@ -41,6 +41,7 @@ BLEDeviceManager::BLEDeviceManager():
     _available_for_connect_peripheral_adv_data_len(0),
     _available_for_connect_peripheral_scan_rsp_data_len(0),
     _available_for_connect_peripheral_adv_rssi(0),
+    _available_for_connect_peripheral_connectable(false),
     _connecting(false),
     _has_service_uuid(false),
     _has_service_solicit_uuid(false),
@@ -83,9 +84,12 @@ BLEDeviceManager::BLEDeviceManager():
     memset(_peer_scan_rsp_data_len, 0, sizeof(_peer_scan_rsp_data_len));
     memset(_peer_adv_rssi, 0, sizeof(_peer_adv_rssi));
 
+    memset(_peer_adv_connectable, 0, sizeof(_peer_adv_connectable));
+    
     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(&_adv_accept_critical, 0, sizeof(_adv_accept_critical));
     memset(&_adv_critical_service_uuid, 0, sizeof(_adv_critical_service_uuid));
@@ -735,6 +739,44 @@ bool BLEDeviceManager::hasLocalName(const BLEDevice* device) const
     return retval;
 }
 
+bool BLEDeviceManager::hasManufacturerData(const BLEDevice* device) const
+{
+    if (BLEUtils::isLocalBLE(*device) == true)
+    {
+        return (_manufacturer_data_length != 0);
+    }
+    
+    const uint8_t* manufactgurer_data = NULL;
+    uint8_t manufactgurer_data_len = 0;
+    return getDataFromAdvertiseByType(device, 
+                                      BT_DATA_MANUFACTURER_DATA,
+                                      manufactgurer_data, 
+                                      manufactgurer_data_len);
+}
+
+bool BLEDeviceManager::getManufacturerData (const BLEDevice* device, 
+                                            uint8_t* manu_data, 
+                                            uint8_t&manu_data_len) const
+{
+    if (BLEUtils::isLocalBLE(*device) == true)
+    {
+        return (_manufacturer_data_length != 0);
+    }
+    
+    const uint8_t* manufactgurer_data = NULL;
+    uint8_t manufactgurer_data_len = 0;
+    bool retval = getDataFromAdvertiseByType(device, 
+                                              BT_DATA_MANUFACTURER_DATA,
+                                              manufactgurer_data, 
+                                              manufactgurer_data_len);
+    if (retval)
+    {
+        memcpy (manu_data, manufactgurer_data, manufactgurer_data_len);
+        manu_data_len = manufactgurer_data_len;
+    }
+    return retval;
+}
+
 bool BLEDeviceManager::hasAdvertisedServiceUuid(const BLEDevice* device) const
 {
     if (BLEUtils::isLocalBLE(*device) == true)
@@ -882,50 +924,34 @@ String BLEDeviceManager::localName(const BLEDevice* device) const
     {
         return _local_name;
     }
-    const uint8_t* adv_data = NULL;
-    uint8_t adv_data_len = 0;
-    char localname_string[BLE_MAX_ADV_SIZE];
-    memset(localname_string, 0, sizeof(localname_string));
-    
-    getDeviceAdvertiseBuffer(device->bt_le_address(),
-                             adv_data,
-                             adv_data_len);
 
-    if (NULL == adv_data) {
-        String temp(localname_string);
-        return temp;
+    const uint8_t* local_name = NULL;
+    uint8_t local_name_len = 0;
+    String temp("");
+    char local_name_buff[BLE_MAX_ADV_SIZE];
+    bool retval = getDataFromAdvertiseByType(device, 
+                                             BT_DATA_NAME_COMPLETE,
+                                             local_name, 
+                                             local_name_len);
+    if (false == retval)
+    {
+        retval = getDataFromAdvertiseByType(device,
+                                            BT_DATA_NAME_SHORTENED,
+                                            local_name,
+                                            local_name_len);
     }
 
-    while (adv_data_len > 1)
+    if (true == retval) 
     {
-        uint8_t len = adv_data[0];
-        uint8_t type = adv_data[1];
-
-        /* Check for early termination */
-        if ((len == 0) || ((len + 1) > adv_data_len)) {
-            break;
-        }
-
-	/* Sid, 2/15/2017.  Support both forms of data name.
-	 */
-        if (type == BT_DATA_NAME_COMPLETE ||
-	    type == BT_DATA_NAME_SHORTENED)
+        if (local_name_len >= BLE_MAX_ADV_SIZE)
         {
-            if (len >= BLE_MAX_ADV_SIZE)
-            {
-                len = BLE_MAX_ADV_SIZE-1;
-            }
-            uint8_t copy_len = len - 1;
-            memcpy(localname_string, &adv_data[2], copy_len);
-            localname_string[copy_len] = '\0';
-            break;
+            local_name_len = BLE_MAX_ADV_SIZE - 1;
         }
-
-        adv_data_len -= len + 1;
-        adv_data += len + 1;
+        memcpy(local_name_buff, local_name, local_name_len);
+        local_name_buff[local_name_len] = '\0';
+        temp = local_name_buff;
     }
-
-    String temp(localname_string);
+    
     return temp;
 }
 
@@ -1347,8 +1373,8 @@ BLEDevice BLEDeviceManager::available()
             _available_for_connect_peripheral_scan_rsp_data_len = _peer_scan_rsp_data_len[index];
             _available_for_connect_peripheral_adv_data_len = _peer_adv_data_len[index];
             _available_for_connect_peripheral_adv_rssi = _peer_adv_rssi[index];
-            
-            pr_debug(LOG_MODULE_BLE, "%s-%d:Con addr-%s", __FUNCTION__, __LINE__, BLEUtils::macAddressBT2String(*temp).c_str());
+            _available_for_connect_peripheral_connectable = _peer_adv_connectable[index];
+            //pr_debug(LOG_MODULE_BLE, "%s-%d:Con addr-%s", __FUNCTION__, __LINE__, BLEUtils::macAddressBT2String(*temp).c_str());
             _peer_adv_mill[index] -= 2000; // Set it as expired
             if (_adv_duplicate_filter_enabled)
             {
@@ -1362,7 +1388,8 @@ BLEDevice BLEDeviceManager::available()
 bool BLEDeviceManager::setAdvertiseBuffer(const bt_addr_le_t* bt_addr,
                                           const uint8_t *ad, 
                                           uint8_t data_len,
-                                          int8_t rssi)
+                                          int8_t rssi,
+                                          bool connectable)
 {
     bt_addr_le_t* temp = NULL;
     uint64_t timestamp = millis();
@@ -1408,6 +1435,7 @@ bool BLEDeviceManager::setAdvertiseBuffer(const bt_addr_le_t* bt_addr,
         _peer_adv_rssi[index] = rssi;
         // Update the timestamp
         _peer_adv_mill[index] = timestamp;
+        _peer_adv_connectable[index] = connectable;
         retval = true;
     }
 
@@ -1477,7 +1505,8 @@ uint8_t BLEDeviceManager::getTempAdvertiseIndexFromBuffer(const bt_addr_le_t* bt
 void BLEDeviceManager::setTempAdvertiseBuffer(const bt_addr_le_t* bt_addr, 
                                               int8_t rssi, 
                                               const uint8_t *ad, 
-                                              uint8_t data_len)
+                                              uint8_t data_len, 
+                                              bool connectable)
 {
     bt_addr_le_t* temp = NULL;
     uint8_t i = getTempAdvertiseIndexFromBuffer(bt_addr);
@@ -1496,6 +1525,7 @@ void BLEDeviceManager::setTempAdvertiseBuffer(const bt_addr_le_t* bt_addr,
 
     memcpy(_peer_temp_adv_data[i], ad, data_len);
     _peer_temp_adv_data_len[i] = data_len;
+    _peer_temp_adv_connectable[i] = connectable;
 
     return;
 }
@@ -1520,12 +1550,14 @@ void BLEDeviceManager::advertiseAcceptHandler(const bt_addr_le_t *addr,
     {
         const uint8_t *adv_data = ad;
         uint8_t adv_data_len = data_len;
+        bool connectable = (BT_LE_ADV_NONCONN_IND != type);
         bool update_advertise_data = true;
         // The critical is accepted
         //  Find the oldest and expired buffer 
         if (BT_LE_ADV_SCAN_RSP == type)
         {
-        pr_debug(LOG_MODULE_BLE, "%s-%d", __FUNCTION__, __LINE__);
+            update_advertise_data = false;
+            pr_debug(LOG_MODULE_BLE, "%s-%d", __FUNCTION__, __LINE__);
             if (false == setScanRespBuffer(addr, ad, data_len, rssi))
             {
                 // Find the device in the ADV temp buffer
@@ -1534,22 +1566,20 @@ void BLEDeviceManager::advertiseAcceptHandler(const bt_addr_le_t *addr,
                 {
                     adv_data = _peer_temp_adv_data[tempIndex];
                     adv_data_len = _peer_temp_adv_data_len[tempIndex];
-                }
-                else
-                {
-                    update_advertise_data = false;
+                    connectable = _peer_temp_adv_connectable[tempIndex];
+                    update_advertise_data = true;
                 }
             }
-            else
-            {
-                update_advertise_data = false;
-            }
         }
         pr_debug(LOG_MODULE_BLE, "%s-%d", __FUNCTION__, __LINE__);
 
         if (true == update_advertise_data)
         {
-            if (false == setAdvertiseBuffer(addr, adv_data, adv_data_len, rssi))
+            if (false == setAdvertiseBuffer(addr, 
+                                            adv_data, 
+                                            adv_data_len, 
+                                            rssi, 
+                                            connectable))
             {
                 pr_info(LOG_MODULE_BLE, "No buffer to store the ADV\n");
             }
@@ -1571,54 +1601,52 @@ void BLEDeviceManager::handleDeviceFound(const bt_addr_le_t *addr,
     uint8_t real_adv_len = data_len;
 
     /* We're only interested in connectable events */
-    if (type == BT_LE_ADV_IND || type == BT_LE_ADV_DIRECT_IND || 
-        type == BT_LE_ADV_SCAN_RSP)
+    //pr_debug(LOG_MODULE_BLE, "%s-%d", __FUNCTION__, __LINE__);
+    // Filter address
+    if (BLEUtils::macAddressValid(_adv_accept_device) == true && 
+       (memcmp(addr->val, _adv_accept_device.val, sizeof (addr->val)) != 0))
     {
-        //pr_debug(LOG_MODULE_BLE, "%s-%d", __FUNCTION__, __LINE__);
-        // Filter address
-        if (BLEUtils::macAddressValid(_adv_accept_device) == true && 
-		   (memcmp(addr->val, _adv_accept_device.val, sizeof (addr->val)) != 0))
+        pr_debug(LOG_MODULE_BLE, "%s-%d", __FUNCTION__, __LINE__);
+        return;
+    }
+    
+    while (data_len > 1)
+    {
+        uint8_t len = data[0];
+
+        /* Check for early termination */
+        if (len == 0)
         {
             return;
         }
-        
-        while (data_len > 1)
-        {
-            uint8_t len = data[0];
 
-            /* Check for early termination */
-            if (len == 0)
-            {
-                return;
-            }
-
-            if ((len + 1) > data_len) {    // Sid. KW, cannot be (data_len < 2)
-                pr_info(LOG_MODULE_BLE, "AD malformed\n");
-                return;
-            }
-
-            if (true == advertiseDataProc(data[1], &data[2], len - 1))
-            {
-                advertiseAcceptHandler(addr, rssi, type, ad, real_adv_len);
-                pr_debug(LOG_MODULE_BLE, "%s-%d: Done", __FUNCTION__, __LINE__);
-                return;
-            }
-
-            data_len -= len + 1;
-            data += len + 1;
-        }
-        //pr_debug(LOG_MODULE_BLE, "%s: done", __FUNCTION__);
-        // Doesn't accept the ADV/scan data
-        // Check it in the buffer
-        if (BT_LE_ADV_SCAN_RSP == type)
-        {
-            setScanRespBuffer(addr, ad, real_adv_len, rssi);
+        if ((len + 1) > data_len) {    // Sid. KW, cannot be (data_len < 2)
+            pr_info(LOG_MODULE_BLE, "AD malformed\n");
+            return;
         }
-        else
+
+        if (true == advertiseDataProc(data[1], &data[2], len - 1))
         {
-            // Add advertise into buffer
-            setTempAdvertiseBuffer(addr, rssi, ad, real_adv_len);
+            advertiseAcceptHandler(addr, rssi, type, ad, real_adv_len);
+            //pr_debug(LOG_MODULE_BLE, "%s-%d: Done", __FUNCTION__, __LINE__);
+            return;
         }
+
+        data_len -= len + 1;
+        data += len + 1;
+    }
+    //pr_debug(LOG_MODULE_BLE, "%s: done", __FUNCTION__);
+    // Doesn't accept the ADV/scan data
+    // Check it in the buffer
+    if (BT_LE_ADV_SCAN_RSP == type)
+    {
+        // Find the ADV and set response
+        setScanRespBuffer(addr, ad, real_adv_len, rssi);
+    }
+    else
+    {
+        // Add advertise into buffer
+        setTempAdvertiseBuffer(addr, rssi, ad, real_adv_len, BT_LE_ADV_NONCONN_IND != type);
     }
 
 }