Add a timer for scan responses

This ensures that the callback will be called within the configured time (in ms) when devices fail to respond to a scan response request within that time.

Author: h2zero

src/NimBLEAdvertisedDevice.cpp

@@ -61,6 +61,10 @@ NimBLEAdvertisedDevice::NimBLEAdvertisedDevice(const ble_gap_event* event, uint8
 void NimBLEAdvertisedDevice::update(const ble_gap_event* event, uint8_t eventType) {
 # if MYNEWT_VAL(BLE_EXT_ADV)
     const auto& disc = event->ext_disc;
+    if (!disc.length_data) { // dummy sr, just return, don't update anything
+        return;
+    }
+
     if (m_dataStatus == BLE_GAP_EXT_ADV_DATA_STATUS_INCOMPLETE) {
         m_payload.reserve(m_advLength + disc.length_data);
         m_payload.insert(m_payload.end(), disc.data, disc.data + disc.length_data);
@@ -75,6 +79,10 @@ void NimBLEAdvertisedDevice::update(const ble_gap_event* event, uint8_t eventTyp
     const auto& disc = event->disc;
 # endif
 
+    if (!disc.length_data) { // dummy sr, just return, don't update anything
+        return;
+    }
+
     m_rssi = disc.rssi;
     if (eventType == BLE_HCI_ADV_RPT_EVTYPE_SCAN_RSP && isLegacyAdvertisement()) {
         m_payload.insert(m_payload.end(), disc.data, disc.data + disc.length_data);

src/NimBLEAdvertisedDevice.h

@@ -163,6 +163,9 @@ class NimBLEAdvertisedDevice {
     int8_t        m_rssi{};
     uint8_t       m_callbackSent{};
     uint16_t      m_advLength{};
+# if MYNEWT_VAL(NIMBLE_CPP_SCAN_RSP_TIMEOUT)
+    ble_npl_time_t m_time{};
+# endif
 
 # if MYNEWT_VAL(BLE_EXT_ADV)
     bool     m_isLegacyAdv{};

src/NimBLEScan.cpp

@@ -20,13 +20,106 @@
 
 # include "NimBLEDevice.h"
 # include "NimBLELog.h"
+# if defined(CONFIG_NIMBLE_CPP_IDF)
+#  include "nimble/nimble_port.h"
+# else
+#  include "nimble/porting/nimble/include/nimble/nimble_port.h"
+# endif
 
 # include <string>
 # include <climits>
 
+# define SR_TIMEOUT MYNEWT_VAL(NIMBLE_CPP_SCAN_RSP_TIMEOUT)
+
 static const char*         LOG_TAG = "NimBLEScan";
 static NimBLEScanCallbacks defaultScanCallbacks;
 
+# if SR_TIMEOUT
+static ble_npl_event  dummySrTimerEvent;
+static ble_npl_time_t srTimeoutTicks;
+
+#  if MYNEWT_VAL(BLE_EXT_ADV)
+struct ble_gap_ext_disc_desc dummyDesc{.props             = BLE_HCI_ADV_LEGACY_MASK,
+                                       .data_status       = BLE_GAP_EXT_ADV_DATA_STATUS_COMPLETE,
+                                       .legacy_event_type = BLE_HCI_ADV_RPT_EVTYPE_SCAN_RSP,
+                                       .addr{},
+                                       .rssi              = 127,
+                                       .tx_power          = 127,
+                                       .sid               = 0,
+                                       .primary_phy       = BLE_HCI_LE_PHY_1M,
+                                       .secondary_phy     = BLE_HCI_LE_PHY_1M,
+                                       .periodic_adv_itvl = 0,
+                                       .length_data       = 0,
+                                       .data              = nullptr,
+                                       .direct_addr{}};
+
+extern "C" void ble_gap_rx_ext_adv_report(struct ble_gap_ext_disc_desc* desc);
+#  else
+static ble_gap_disc_desc dummyDesc{
+    .event_type = BLE_HCI_ADV_RPT_EVTYPE_SCAN_RSP, .length_data = 0, .addr{}, .rssi = 127, .data = nullptr, .direct_addr{}};
+extern "C" void ble_gap_rx_adv_report(ble_gap_disc_desc* desc);
+#  endif
+
+/**
+ * @brief Sends dummy (null) scan response data to the scan event handler in order to
+ * provide the scan result to the callbacks when a device hasn't responded to the
+ * scan request in time. This is called by the host task from the default event queue.
+ */
+static void sendDummyScanResponse(ble_npl_event* ev) {
+    (void)ev;
+#  if MYNEWT_VAL(BLE_EXT_ADV)
+    ble_gap_rx_ext_adv_report(&dummyDesc);
+#  else
+    ble_gap_rx_adv_report(&dummyDesc);
+#  endif
+}
+
+/**
+ * @brief This will schedule an event to run in the host task that will call sendDummyScanResponse
+ * which will send a null data scan response to the scan event handler if the device
+ * hasn't responded to a scan response request within the timeout period.
+ */
+void NimBLEScan::srTimerCb(ble_npl_event* event) {
+    NimBLEScan*             pScan   = static_cast<NimBLEScan*>(ble_npl_event_get_arg(event));
+    NimBLEAdvertisedDevice* curDev  = nullptr;
+    NimBLEAdvertisedDevice* nextDev = nullptr;
+    ble_npl_time_t          now     = ble_npl_time_get();
+
+    for (auto& dev : pScan->m_scanResults.m_deviceVec) {
+        if (dev->m_callbackSent < 2 && dev->isScannable()) {
+            if (!curDev || (now - dev->m_time > now - curDev->m_time)) {
+                nextDev = curDev;
+                curDev  = dev;
+                continue;
+            }
+
+            if (!nextDev || now - dev->m_time > now - nextDev->m_time) {
+                nextDev = dev;
+            }
+        }
+    }
+
+    // Add the event to the host queue
+    if (curDev) {
+        memcpy(&dummyDesc.addr, curDev->getAddress().getBase(), sizeof(dummyDesc.addr));
+        NIMBLE_LOGI(LOG_TAG, "Scan response timeout for: %s", curDev->getAddress().toString().c_str());
+        ble_npl_eventq_put(nimble_port_get_dflt_eventq(), &dummySrTimerEvent);
+    }
+
+    // Restart the timer for the next device that we are expecting a scan response from
+    if (nextDev) {
+        auto nextTime = now - nextDev->m_time;
+        if (nextTime >= srTimeoutTicks) {
+            nextTime = 1;
+        } else {
+            nextTime = srTimeoutTicks - nextTime;
+        }
+
+        ble_npl_callout_reset(&pScan->m_srTimer, nextTime);
+    }
+}
+# endif // SR_TIMEOUT
+
 /**
  * @brief Scan constructor.
  */
@@ -35,7 +128,13 @@ NimBLEScan::NimBLEScan()
       // default interval + window, no whitelist scan filter,not limited scan, no scan response, filter_duplicates
       m_scanParams{0, 0, BLE_HCI_SCAN_FILT_NO_WL, 0, 1, 1},
       m_pTaskData{nullptr},
-      m_maxResults{0xFF} {}
+      m_maxResults{0xFF} {
+# if SR_TIMEOUT
+    ble_npl_callout_init(&m_srTimer, nimble_port_get_dflt_eventq(), NimBLEScan::srTimerCb, this);
+    ble_npl_event_init(&dummySrTimerEvent, sendDummyScanResponse, NULL);
+    ble_npl_time_ms_to_ticks(SR_TIMEOUT, &srTimeoutTicks);
+# endif
+} // NimBLEScan::NimBLEScan
 
 /**
  * @brief Scan destructor, release any allocated resources.
@@ -44,6 +143,10 @@ NimBLEScan::~NimBLEScan() {
     for (const auto& dev : m_scanResults.m_deviceVec) {
         delete dev;
     }
+# if SR_TIMEOUT
+    ble_npl_callout_deinit(&m_srTimer);
+    ble_npl_event_deinit(&dummySrTimerEvent);
+# endif
 }
 
 /**
@@ -114,6 +217,9 @@ int NimBLEScan::handleGapEvent(ble_gap_event* event, void* arg) {
 
                 advertisedDevice = new NimBLEAdvertisedDevice(event, event_type);
                 pScan->m_scanResults.m_deviceVec.push_back(advertisedDevice);
+# if SR_TIMEOUT
+                advertisedDevice->m_time = ble_npl_time_get();
+# endif
                 NIMBLE_LOGI(LOG_TAG, "New advertiser: %s", advertisedAddress.toString().c_str());
             } else {
                 advertisedDevice->update(event, event_type);
@@ -122,6 +228,11 @@ int NimBLEScan::handleGapEvent(ble_gap_event* event, void* arg) {
                         NIMBLE_LOGI(LOG_TAG, "Scan response from: %s", advertisedAddress.toString().c_str());
                     } else {
                         NIMBLE_LOGI(LOG_TAG, "Duplicate; updated: %s", advertisedAddress.toString().c_str());
+# if SR_TIMEOUT
+                        // Restart scan-response timeout when we see a new non-scan-response
+                        // legacy advertisement during active scanning for a scannable device.
+                        advertisedDevice->m_time = ble_npl_time_get();
+# endif
                     }
                 }
             }
@@ -147,6 +258,11 @@ int NimBLEScan::handleGapEvent(ble_gap_event* event, void* arg) {
                 advertisedDevice->m_callbackSent++;
                 // got the scan response report the full data.
                 pScan->m_pScanCallbacks->onResult(advertisedDevice);
+# if SR_TIMEOUT
+            } else if (isLegacyAdv && advertisedDevice->isScannable() && !ble_npl_callout_is_active(&pScan->m_srTimer)) {
+                // Start the timer to wait for the scan response.
+                ble_npl_callout_reset(&pScan->m_srTimer, srTimeoutTicks);
+# endif
             }
 
             // If not storing results and we have invoked the callback, delete the device.
@@ -158,14 +274,16 @@ int NimBLEScan::handleGapEvent(ble_gap_event* event, void* arg) {
         }
 
         case BLE_GAP_EVENT_DISC_COMPLETE: {
+# if SR_TIMEOUT
+            ble_npl_callout_stop(&pScan->m_srTimer);
+# endif
             NIMBLE_LOGD(LOG_TAG, "discovery complete; reason=%d", event->disc_complete.reason);
 
+            pScan->m_pScanCallbacks->onScanEnd(pScan->m_scanResults, event->disc_complete.reason);
             if (pScan->m_maxResults == 0) {
                 pScan->clearResults();
             }
 
-            pScan->m_pScanCallbacks->onScanEnd(pScan->m_scanResults, event->disc_complete.reason);
-
             if (pScan->m_pTaskData != nullptr) {
                 NimBLEUtils::taskRelease(*pScan->m_pTaskData, event->disc_complete.reason);
             }
@@ -394,6 +512,10 @@ bool NimBLEScan::stop() {
         return false;
     }
 
+# if SR_TIMEOUT
+    ble_npl_callout_stop(&m_srTimer);
+# endif
+
     if (m_maxResults == 0) {
         clearResults();
     }

src/NimBLEScan.h

@@ -96,13 +96,20 @@ class NimBLEScan {
     ~NimBLEScan();
     static int handleGapEvent(ble_gap_event* event, void* arg);
     void       onHostSync();
+# if MYNEWT_VAL(NIMBLE_CPP_SCAN_RSP_TIMEOUT)
+    static void srTimerCb(ble_npl_event* event);
+# endif
 
     NimBLEScanCallbacks* m_pScanCallbacks;
     ble_gap_disc_params  m_scanParams;
     NimBLEScanResults    m_scanResults;
     NimBLETaskData*      m_pTaskData;
     uint8_t              m_maxResults;
 
+# if MYNEWT_VAL(NIMBLE_CPP_SCAN_RSP_TIMEOUT)
+    ble_npl_callout m_srTimer{};
+# endif
+
 # if MYNEWT_VAL(BLE_EXT_ADV)
     uint8_t  m_phy{SCAN_ALL};
     uint16_t m_period{0};

src/nimconfig.h

@@ -69,6 +69,14 @@
 /** @brief Un-comment to change the stack size for the NimBLE host task */
 // #define MYNEWT_VAL_NIMBLE_HOST_TASK_STACK_SIZE 4096
 
+/**
+ * @brief Un-comment to change the timeout, in milliseconds.
+ * @details This is the time to wait for a scan response before calling the onResult scan callback,
+ * lower values increase callback rates but will lose data more often, higher values give full data more
+ * often. Setting this to 0 will disable the scan response timeout.
+ */
+ // #define MYNEWT_VAL_NIMBLE_CPP_SCAN_RSP_TIMEOUT (30)
+
 /**
  * @brief Un-comment to change the bit used to block tasks during BLE operations
  * that call NimBLEUtils::taskWait. This should be different than any other

src/syscfg/syscfg.h

@@ -2023,4 +2023,8 @@
 #define MYNEWT_VAL_NIMBLE_CPP_ENABLE_ADVERTISEMENT_TYPE_TEXT (0)
 #endif
 
+#ifndef MYNEWT_VAL_NIMBLE_CPP_SCAN_RSP_TIMEOUT
+#define MYNEWT_VAL_NIMBLE_CPP_SCAN_RSP_TIMEOUT (30)
+#endif
+
 #endif /* H_SYSCFG_ */