Call the onResult callback directly instead of creating an rx event

h2zero · h2zero · commit 11530a85f024 · 2026-03-22T09:53:58.000-06:00
diff --git a/src/NimBLEAdvertisedDevice.cpp b/src/NimBLEAdvertisedDevice.cpp
@@ -58,40 +58,30 @@ NimBLEAdvertisedDevice::NimBLEAdvertisedDevice(const ble_gap_event* event, uint8
  * @brief Update the advertisement data.
  * @param [in] event The advertisement event data.
  */
-bool NimBLEAdvertisedDevice::update(const ble_gap_event* event, uint8_t eventType) {
+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 false;
-    }
-
     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);
         m_dataStatus = disc.data_status;
         m_advLength  = m_payload.size();
-        return true;
+        return;
     }
 
     m_dataStatus  = disc.data_status;
     m_isLegacyAdv = disc.props & BLE_HCI_ADV_LEGACY_MASK;
 # else
     const auto& disc = event->disc;
 # endif
-
-    if (!disc.length_data) { // dummy sr, just return, don't update anything
-        return false;
-    }
-
     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);
-        return true;
+        return;
     }
     m_advLength = disc.length_data;
     m_payload.assign(disc.data, disc.data + disc.length_data);
     m_callbackSent = 0; // new data, reset callback sent flag
-    return true;
 } // update
 
 /**
diff --git a/src/NimBLEAdvertisedDevice.h b/src/NimBLEAdvertisedDevice.h
@@ -154,7 +154,7 @@ class NimBLEAdvertisedDevice {
     friend class NimBLEScan;
 
     NimBLEAdvertisedDevice(const ble_gap_event* event, uint8_t eventType);
-    bool    update(const ble_gap_event* event, uint8_t eventType);
+    void    update(const ble_gap_event* event, uint8_t eventType);
     uint8_t findAdvField(uint8_t type, uint8_t index = 0, size_t* data_loc = nullptr) const;
     size_t  findServiceData(uint8_t index, uint8_t* bytes) const;
 
diff --git a/src/NimBLEScan.cpp b/src/NimBLEScan.cpp
@@ -31,49 +31,23 @@
 
 static const char*         LOG_TAG = "NimBLEScan";
 static NimBLEScanCallbacks defaultScanCallbacks;
-static ble_npl_event       dummySrTimerEvent;
-
-# 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,
-                                       .prim_phy          = BLE_HCI_LE_PHY_1M,
-                                       .sec_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.
- */
-void NimBLEScan::sendDummyScanResponse(ble_npl_event* ev) {
-    (void)ev;
-    NimBLEDevice::getScan()->m_stats.incMissedSrCount();
-# if MYNEWT_VAL(BLE_EXT_ADV)
-    ble_gap_rx_ext_adv_report(&dummyDesc);
-# else
-    ble_gap_rx_adv_report(&dummyDesc);
-# endif
+ * @brief Calls the onResult callback with the given device,
+ * this is used to provide a 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.
+ */
+void NimBLEScan::forceResultCallback(ble_npl_event* ev) {
+    auto pScan = NimBLEDevice::getScan();
+    pScan->m_stats.incMissedSrCount();
+    NimBLEAdvertisedDevice* pDev = static_cast<NimBLEAdvertisedDevice*>(ble_npl_event_get_arg(ev));
+    pDev->m_callbackSent         = 2;
+    pScan->m_pScanCallbacks->onResult(pDev);
 }
 
 /**
- * @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.
+ * @brief This will schedule an event to run in the host task that will call forceResultCallback
+ * which will call the onResult callback with the current data.
  */
 void NimBLEScan::srTimerCb(ble_npl_event* event) {
     NimBLEScan*             pScan   = static_cast<NimBLEScan*>(ble_npl_event_get_arg(event));
@@ -97,12 +71,9 @@ void NimBLEScan::srTimerCb(ble_npl_event* event) {
 
     // Add the event to the host queue
     if (curDev && now - curDev->m_time >= pScan->m_srTimeoutTicks) {
-# if MYNEWT_VAL(BLE_EXT_ADV)
-        dummyDesc.sid = curDev->getSetId();
-# endif
-        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);
+        ble_npl_event_set_arg(&pScan->m_srTimeoutEvent, curDev);
+        ble_npl_eventq_put(nimble_port_get_dflt_eventq(), &pScan->m_srTimeoutEvent);
     }
 
     // Restart the timer for the next device that we are expecting a scan response from
@@ -128,7 +99,7 @@ NimBLEScan::NimBLEScan()
       m_pTaskData{nullptr},
       m_maxResults{0xFF} {
     ble_npl_callout_init(&m_srTimer, nimble_port_get_dflt_eventq(), NimBLEScan::srTimerCb, this);
-    ble_npl_event_init(&dummySrTimerEvent, sendDummyScanResponse, NULL);
+    ble_npl_event_init(&m_srTimeoutEvent, forceResultCallback, NULL);
     ble_npl_time_ms_to_ticks(BLE_GAP_SCAN_FAST_WINDOW, &m_srTimeoutTicks);
 } // NimBLEScan::NimBLEScan
 
@@ -141,7 +112,7 @@ NimBLEScan::~NimBLEScan() {
     }
 
     ble_npl_callout_deinit(&m_srTimer);
-    ble_npl_event_deinit(&dummySrTimerEvent);
+    ble_npl_event_deinit(&m_srTimeoutEvent);
 }
 
 /**
@@ -223,7 +194,7 @@ int NimBLEScan::handleGapEvent(ble_gap_event* event, void* arg) {
                     if (event_type == BLE_HCI_ADV_RPT_EVTYPE_SCAN_RSP) {
                         NIMBLE_LOGI(LOG_TAG, "Scan response from: %s", advertisedAddress.toString().c_str());
                         if (!pScan->m_stats.recordSrTime(ble_npl_time_get() - advertisedDevice->m_time,
-                                                    pScan->m_scanParams.window * 625 / 1000)) {
+                                                         pScan->m_scanParams.window * 625 / 1000)) {
                             NIMBLE_LOGD(LOG_TAG,
                                         "Abnormal scan response time, stats ignored for device: %s",
                                         advertisedAddress.toString().c_str());
@@ -288,6 +259,7 @@ int NimBLEScan::handleGapEvent(ble_gap_event* event, void* arg) {
             }
 
             NIMBLE_LOGD(LOG_TAG, "discovery complete; reason=%d", event->disc_complete.reason);
+            NIMBLE_LOGD(LOG_TAG, "%s", pScan->getStatsString().c_str());
 
             pScan->m_pScanCallbacks->onScanEnd(pScan->m_scanResults, event->disc_complete.reason);
             if (pScan->m_maxResults == 0) {
diff --git a/src/NimBLEScan.h b/src/NimBLEScan.h
@@ -143,7 +143,7 @@ class NimBLEScan {
                      srCount ? srTotalMs / srCount : 0,
                      orphanedSrCount,
                      missedSrCount);
-
+            out.resize(strlen(out.c_str()));
             return out;
         }
 
@@ -153,7 +153,7 @@ class NimBLEScan {
             uint32_t ms;
             ble_npl_time_ticks_to_ms(ticks, &ms);
             if (ms >= (window ? window : BLE_GAP_SCAN_FAST_WINDOW) * 5) {
-                return false;
+                //return false;
             }
 
             if (ms < srMinMs) {
@@ -182,14 +182,15 @@ class NimBLEScan {
     static int  handleGapEvent(ble_gap_event* event, void* arg);
     void        onHostSync();
     static void srTimerCb(ble_npl_event* event);
-    static void sendDummyScanResponse(ble_npl_event* ev);
+    static void forceResultCallback(ble_npl_event* ev);
 
     NimBLEScanCallbacks* m_pScanCallbacks;
     ble_gap_disc_params  m_scanParams;
     NimBLEScanResults    m_scanResults;
     NimBLETaskData*      m_pTaskData;
     ble_npl_callout      m_srTimer{};
     ble_npl_time_t       m_srTimeoutTicks{};
+    ble_npl_event        m_srTimeoutEvent{};
     uint8_t              m_maxResults;
 
 # if MYNEWT_VAL(BLE_EXT_ADV)
