mirror of
https://github.com/h2zero/esp-nimble-cpp.git
synced 2024-11-22 05:00:55 +01:00
[BREAKING] - Refactor NimBLEScan
* General code cleanup * `NimBLEScan::start` will no longer clear cache or results if scanning is already in progress. * `NimBLEScan::clearResults` will now reset the vector capacity to 0. * `NimBLEScan::stop` will no longer call the `onScanEnd` callback as the caller should know its been stopped when this is called. * `NimBLEScan::clearDuplicateCache` has been removed as it was problematic and only for the esp32. Stop and start the scanner for the same effect. * `NimBLEScan::start` takes a new bool parameter `restart`, default `true`, that will restart an already in progress scan and clear the duplicate filter so all devices will be discovered again. * Scan response data that is received without advertisement first will now create the device and send a callback.
This commit is contained in:
h2zero
parent
5f2730de02
commit
a9a79233bd
3 changed files with 160 additions and 230 deletions
|
|
@ -723,15 +723,7 @@ void NimBLEDevice::onReset(int reason) {
|
|||
|
||||
m_synced = false;
|
||||
|
||||
NIMBLE_LOGE(LOG_TAG, "Resetting state; reason=%d, %s", reason, NimBLEUtils::returnCodeToString(reason));
|
||||
|
||||
# if defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
|
||||
if (m_initialized) {
|
||||
if (m_pScan != nullptr) {
|
||||
m_pScan->onHostReset();
|
||||
}
|
||||
}
|
||||
# endif
|
||||
NIMBLE_LOGE(LOG_TAG, "Host reset; reason=%d, %s", reason, NimBLEUtils::returnCodeToString(reason));
|
||||
} // onReset
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -15,39 +15,31 @@
|
|||
#include "nimconfig.h"
|
||||
#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
|
||||
|
||||
#include "NimBLEScan.h"
|
||||
#include "NimBLEDevice.h"
|
||||
#include "NimBLELog.h"
|
||||
# include "NimBLEScan.h"
|
||||
# include "NimBLEDevice.h"
|
||||
# include "NimBLELog.h"
|
||||
|
||||
#include <string>
|
||||
#include <climits>
|
||||
# include <string>
|
||||
# include <climits>
|
||||
|
||||
static const char* LOG_TAG = "NimBLEScan";
|
||||
|
||||
|
||||
/**
|
||||
* @brief Scan constuctor.
|
||||
* @brief Scan constructor.
|
||||
*/
|
||||
NimBLEScan::NimBLEScan() {
|
||||
m_scan_params.filter_policy = BLE_HCI_SCAN_FILT_NO_WL;
|
||||
m_scan_params.passive = 1; // If set, don’t send scan requests to advertisers (i.e., don’t request additional advertising data).
|
||||
m_scan_params.itvl = 0; // This is defined as the time interval from when the Controller started its last LE scan until it begins the subsequent LE scan. (units=0.625 msec)
|
||||
m_scan_params.window = 0; // The duration of the LE scan. LE_Scan_Window shall be less than or equal to LE_Scan_Interval (units=0.625 msec)
|
||||
m_scan_params.limited = 0; // If set, only discover devices in limited discoverable mode.
|
||||
m_scan_params.filter_duplicates = 1; // If set, the controller ignores all but the first advertisement from each device.
|
||||
m_pScanCallbacks = nullptr;
|
||||
m_ignoreResults = false;
|
||||
m_pTaskData = nullptr;
|
||||
m_duration = BLE_HS_FOREVER; // make sure this is non-zero in the event of a host reset
|
||||
m_maxResults = 0xFF;
|
||||
}
|
||||
|
||||
NimBLEScan::NimBLEScan()
|
||||
: m_pScanCallbacks{nullptr},
|
||||
m_scanParams{
|
||||
.itvl{0}, .window{0}, .filter_policy{BLE_HCI_SCAN_FILT_NO_WL}, .limited{0}, .passive{1}, .filter_duplicates{1}},
|
||||
m_duration{BLE_HS_FOREVER},
|
||||
m_pTaskData{nullptr},
|
||||
m_maxResults{0xFF} {}
|
||||
|
||||
/**
|
||||
* @brief Scan destructor, release any allocated resources.
|
||||
*/
|
||||
NimBLEScan::~NimBLEScan() {
|
||||
clearResults();
|
||||
clearResults();
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -55,32 +47,26 @@ NimBLEScan::~NimBLEScan() {
|
|||
* @param [in] event The event type for this event.
|
||||
* @param [in] param Parameter data for this event.
|
||||
*/
|
||||
/*STATIC*/
|
||||
int NimBLEScan::handleGapEvent(ble_gap_event* event, void* arg) {
|
||||
(void)arg;
|
||||
NimBLEScan* pScan = NimBLEDevice::getScan();
|
||||
|
||||
switch(event->type) {
|
||||
|
||||
switch (event->type) {
|
||||
case BLE_GAP_EVENT_EXT_DISC:
|
||||
case BLE_GAP_EVENT_DISC: {
|
||||
if(pScan->m_ignoreResults) {
|
||||
NIMBLE_LOGI(LOG_TAG, "Scan op in progress - ignoring results");
|
||||
return 0;
|
||||
}
|
||||
#if CONFIG_BT_NIMBLE_EXT_ADV
|
||||
const auto& disc = event->ext_disc;
|
||||
const bool isLegacyAdv = disc.props & BLE_HCI_ADV_LEGACY_MASK;
|
||||
const auto event_type = isLegacyAdv ? disc.legacy_event_type : disc.props;
|
||||
#else
|
||||
const auto& disc = event->disc;
|
||||
const bool isLegacyAdv = true;
|
||||
const auto event_type = disc.event_type;
|
||||
#endif
|
||||
# if CONFIG_BT_NIMBLE_EXT_ADV
|
||||
const auto& disc = event->ext_disc;
|
||||
const bool isLegacyAdv = disc.props & BLE_HCI_ADV_LEGACY_MASK;
|
||||
const auto event_type = isLegacyAdv ? disc.legacy_event_type : disc.props;
|
||||
# else
|
||||
const auto& disc = event->disc;
|
||||
const bool isLegacyAdv = true;
|
||||
const auto event_type = disc.event_type;
|
||||
# endif
|
||||
NimBLEAddress advertisedAddress(disc.addr);
|
||||
|
||||
// Examine our list of ignored addresses and stop processing if we don't want to see it or are already connected
|
||||
if(NimBLEDevice::isIgnored(advertisedAddress)) {
|
||||
// stop processing if we don't want to see it or are already connected
|
||||
if (NimBLEDevice::isIgnored(advertisedAddress)) {
|
||||
NIMBLE_LOGI(LOG_TAG, "Ignoring device: address: %s", advertisedAddress.toString().c_str());
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -88,77 +74,79 @@ int NimBLEScan::handleGapEvent(ble_gap_event* event, void* arg) {
|
|||
NimBLEAdvertisedDevice* advertisedDevice = nullptr;
|
||||
|
||||
// If we've seen this device before get a pointer to it from the vector
|
||||
for(auto &it: pScan->m_scanResults.m_advertisedDevicesVector) {
|
||||
#if CONFIG_BT_NIMBLE_EXT_ADV
|
||||
for (auto& ad : pScan->m_scanResults.m_deviceVec) {
|
||||
# if CONFIG_BT_NIMBLE_EXT_ADV
|
||||
// Same address but different set ID should create a new advertised device.
|
||||
if (it->getAddress() == advertisedAddress && it->getSetId() == disc.sid) {
|
||||
#else
|
||||
if (it->getAddress() == advertisedAddress) {
|
||||
#endif
|
||||
advertisedDevice = it;
|
||||
if (ad->getAddress() == advertisedAddress && ad->getSetId() == disc.sid) {
|
||||
# else
|
||||
if (ad->getAddress() == advertisedAddress) {
|
||||
# endif
|
||||
advertisedDevice = ad;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// If we haven't seen this device before; create a new instance and insert it in the vector.
|
||||
// Otherwise just update the relevant parameters of the already known device.
|
||||
if (advertisedDevice == nullptr &&
|
||||
(!isLegacyAdv || event_type != BLE_HCI_ADV_RPT_EVTYPE_SCAN_RSP)) {
|
||||
if (advertisedDevice == nullptr) {
|
||||
if (event_type == BLE_HCI_ADV_RPT_EVTYPE_SCAN_RSP) {
|
||||
NIMBLE_LOGW(LOG_TAG, "Scan response without advertisement: %s", advertisedAddress.toString().c_str());
|
||||
}
|
||||
|
||||
// Check if we have reach the scan results limit, ignore this one if so.
|
||||
// We still need to store each device when maxResults is 0 to be able to append the scan results
|
||||
if (pScan->m_maxResults > 0 && pScan->m_maxResults < 0xFF &&
|
||||
(pScan->m_scanResults.m_advertisedDevicesVector.size() >= pScan->m_maxResults)) {
|
||||
(pScan->m_scanResults.m_deviceVec.size() >= pScan->m_maxResults)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
advertisedDevice = new NimBLEAdvertisedDevice(event, event_type);
|
||||
pScan->m_scanResults.m_advertisedDevicesVector.push_back(advertisedDevice);
|
||||
pScan->m_scanResults.m_deviceVec.push_back(advertisedDevice);
|
||||
NIMBLE_LOGI(LOG_TAG, "New advertiser: %s", advertisedAddress.toString().c_str());
|
||||
} else if (advertisedDevice != nullptr) {
|
||||
advertisedDevice->update(event, event_type);
|
||||
NIMBLE_LOGI(LOG_TAG, "Updated advertiser: %s", advertisedAddress.toString().c_str());
|
||||
} else {
|
||||
// Scan response from unknown device
|
||||
// unknown device
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (pScan->m_pScanCallbacks) {
|
||||
if (advertisedDevice->m_callbackSent == 0 || !pScan->m_scan_params.filter_duplicates) {
|
||||
if (advertisedDevice->m_callbackSent == 0 || !pScan->m_scanParams.filter_duplicates) {
|
||||
advertisedDevice->m_callbackSent = 1;
|
||||
pScan->m_pScanCallbacks->onDiscovered(advertisedDevice);
|
||||
}
|
||||
|
||||
if (pScan->m_scan_params.filter_duplicates && advertisedDevice->m_callbackSent >= 2) {
|
||||
if (pScan->m_scanParams.filter_duplicates && advertisedDevice->m_callbackSent >= 2) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
// If not active scanning or scan response is not available
|
||||
// or extended advertisement scanning, report the result to the callback now.
|
||||
if(pScan->m_scan_params.passive || !isLegacyAdv ||
|
||||
(advertisedDevice->getAdvType() != BLE_HCI_ADV_TYPE_ADV_IND &&
|
||||
advertisedDevice->getAdvType() != BLE_HCI_ADV_TYPE_ADV_SCAN_IND))
|
||||
{
|
||||
if (pScan->m_scanParams.passive || !isLegacyAdv ||
|
||||
(advertisedDevice->getAdvType() != BLE_HCI_ADV_TYPE_ADV_IND &&
|
||||
advertisedDevice->getAdvType() != BLE_HCI_ADV_TYPE_ADV_SCAN_IND)) {
|
||||
advertisedDevice->m_callbackSent = 2;
|
||||
pScan->m_pScanCallbacks->onResult(advertisedDevice);
|
||||
|
||||
// Otherwise, wait for the scan response so we can report the complete data.
|
||||
// Otherwise, wait for the scan response so we can report the complete data.
|
||||
} else if (isLegacyAdv && event_type == BLE_HCI_ADV_RPT_EVTYPE_SCAN_RSP) {
|
||||
advertisedDevice->m_callbackSent = 2;
|
||||
pScan->m_pScanCallbacks->onResult(advertisedDevice);
|
||||
}
|
||||
// If not storing results and we have invoked the callback, delete the device.
|
||||
if(pScan->m_maxResults == 0 && advertisedDevice->m_callbackSent >= 2) {
|
||||
if (pScan->m_maxResults == 0 && advertisedDevice->m_callbackSent >= 2) {
|
||||
pScan->erase(advertisedAddress);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
case BLE_GAP_EVENT_DISC_COMPLETE: {
|
||||
NIMBLE_LOGD(LOG_TAG, "discovery complete; reason=%d",
|
||||
event->disc_complete.reason);
|
||||
|
||||
if(pScan->m_maxResults == 0) {
|
||||
case BLE_GAP_EVENT_DISC_COMPLETE: {
|
||||
NIMBLE_LOGD(LOG_TAG, "discovery complete; reason=%d", event->disc_complete.reason);
|
||||
|
||||
if (pScan->m_maxResults == 0) {
|
||||
pScan->clearResults();
|
||||
}
|
||||
|
||||
|
|
@ -166,7 +154,7 @@ int NimBLEScan::handleGapEvent(ble_gap_event* event, void* arg) {
|
|||
pScan->m_pScanCallbacks->onScanEnd(pScan->m_scanResults);
|
||||
}
|
||||
|
||||
if(pScan->m_pTaskData != nullptr) {
|
||||
if (pScan->m_pTaskData != nullptr) {
|
||||
NimBLEUtils::taskRelease(*pScan->m_pTaskData, event->disc_complete.reason);
|
||||
}
|
||||
|
||||
|
|
@ -176,8 +164,7 @@ int NimBLEScan::handleGapEvent(ble_gap_event* event, void* arg) {
|
|||
default:
|
||||
return 0;
|
||||
}
|
||||
} // gapEventHandler
|
||||
|
||||
} // handleGapEvent
|
||||
|
||||
/**
|
||||
* @brief Should we perform an active or passive scan?
|
||||
|
|
@ -185,10 +172,9 @@ int NimBLEScan::handleGapEvent(ble_gap_event* event, void* arg) {
|
|||
* @param [in] active If true, we perform an active scan otherwise a passive scan.
|
||||
*/
|
||||
void NimBLEScan::setActiveScan(bool active) {
|
||||
m_scan_params.passive = !active;
|
||||
m_scanParams.passive = !active;
|
||||
} // setActiveScan
|
||||
|
||||
|
||||
/**
|
||||
* @brief Set whether or not the BLE controller should only report results
|
||||
* from devices it has not already seen.
|
||||
|
|
@ -197,20 +183,18 @@ void NimBLEScan::setActiveScan(bool active) {
|
|||
* duplicate devices once the limit is reached.
|
||||
*/
|
||||
void NimBLEScan::setDuplicateFilter(bool enabled) {
|
||||
m_scan_params.filter_duplicates = enabled;
|
||||
m_scanParams.filter_duplicates = enabled;
|
||||
} // setDuplicateFilter
|
||||
|
||||
|
||||
/**
|
||||
* @brief Set whether or not the BLE controller only report scan results
|
||||
* from devices advertising in limited discovery mode, i.e. directed advertising.
|
||||
* @param [in] enabled If true, only limited discovery devices will be in scan results.
|
||||
*/
|
||||
void NimBLEScan::setLimitedOnly(bool enabled) {
|
||||
m_scan_params.limited = enabled;
|
||||
m_scanParams.limited = enabled;
|
||||
} // setLimited
|
||||
|
||||
|
||||
/**
|
||||
* @brief Sets the scan filter policy.
|
||||
* @param [in] filter Can be one of:
|
||||
|
|
@ -230,10 +214,9 @@ void NimBLEScan::setLimitedOnly(bool enabled) {
|
|||
* resolvable private address.
|
||||
*/
|
||||
void NimBLEScan::setFilterPolicy(uint8_t filter) {
|
||||
m_scan_params.filter_policy = filter;
|
||||
m_scanParams.filter_policy = filter;
|
||||
} // setFilterPolicy
|
||||
|
||||
|
||||
/**
|
||||
* @brief Sets the max number of results to store.
|
||||
* @param [in] maxResults The number of results to limit storage to\n
|
||||
|
|
@ -243,7 +226,6 @@ void NimBLEScan::setMaxResults(uint8_t maxResults) {
|
|||
m_maxResults = maxResults;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @brief Set the call backs to be invoked.
|
||||
* @param [in] pScanCallbacks Call backs to be invoked.
|
||||
|
|
@ -254,25 +236,22 @@ void NimBLEScan::setScanCallbacks(NimBLEScanCallbacks* pScanCallbacks, bool want
|
|||
m_pScanCallbacks = pScanCallbacks;
|
||||
} // setScanCallbacks
|
||||
|
||||
|
||||
/**
|
||||
* @brief Set the interval to scan.
|
||||
* @param [in] intervalMSecs The scan interval (how often) in milliseconds.
|
||||
*/
|
||||
void NimBLEScan::setInterval(uint16_t intervalMSecs) {
|
||||
m_scan_params.itvl = intervalMSecs / 0.625;
|
||||
m_scanParams.itvl = intervalMSecs / 0.625;
|
||||
} // setInterval
|
||||
|
||||
|
||||
/**
|
||||
* @brief Set the window to actively scan.
|
||||
* @param [in] windowMSecs How long to actively scan.
|
||||
*/
|
||||
void NimBLEScan::setWindow(uint16_t windowMSecs) {
|
||||
m_scan_params.window = windowMSecs / 0.625;
|
||||
m_scanParams.window = windowMSecs / 0.625;
|
||||
} // setWindow
|
||||
|
||||
|
||||
/**
|
||||
* @brief Get the status of the scanner.
|
||||
* @return true if scanning or scan starting.
|
||||
|
|
@ -281,14 +260,15 @@ bool NimBLEScan::isScanning() {
|
|||
return ble_gap_disc_active();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @brief Start scanning.
|
||||
* @param [in] duration The duration in milliseconds for which to scan. 0 == scan forever.
|
||||
* @param [in] is_continue Set to true to save previous scan results, false to clear them.
|
||||
* @param [in] restart Set to true to restart the scan if already in progress.
|
||||
* this is useful to clear the duplicate filter so all devices are reported again.
|
||||
* @return True if scan started or false if there was an error.
|
||||
*/
|
||||
bool NimBLEScan::start(uint32_t duration, bool is_continue) {
|
||||
bool NimBLEScan::start(uint32_t duration, bool is_continue, bool restart) {
|
||||
NIMBLE_LOGD(LOG_TAG, ">> start: duration=%" PRIu32, duration);
|
||||
|
||||
if (ble_gap_conn_active()) {
|
||||
|
|
@ -296,51 +276,52 @@ bool NimBLEScan::start(uint32_t duration, bool is_continue) {
|
|||
return false;
|
||||
}
|
||||
|
||||
if (isScanning()) {
|
||||
if(restart) {
|
||||
//NIMBLE_LOGI(LOG_TAG, "Scan already in progress, stopping it");
|
||||
if (!stop()) {
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
NIMBLE_LOGI(LOG_TAG, "Scan already in progress");
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
if (!is_continue) {
|
||||
clearResults();
|
||||
}
|
||||
|
||||
// Save the duration in the case that the host is reset so we can reuse it.
|
||||
m_duration = duration;
|
||||
|
||||
// If 0 duration specified then we assume a continuous scan is desired.
|
||||
if(duration == 0){
|
||||
if (duration == 0) {
|
||||
duration = BLE_HS_FOREVER;
|
||||
}
|
||||
|
||||
// Set the flag to ignore the results while we are deleting the vector
|
||||
if(!is_continue) {
|
||||
m_ignoreResults = true;
|
||||
}
|
||||
|
||||
# if CONFIG_BT_NIMBLE_EXT_ADV
|
||||
ble_gap_ext_disc_params scan_params;
|
||||
scan_params.passive = m_scan_params.passive;
|
||||
scan_params.itvl = m_scan_params.itvl;
|
||||
scan_params.window = m_scan_params.window;
|
||||
int rc = ble_gap_ext_disc(NimBLEDevice::m_ownAddrType,
|
||||
duration/10,
|
||||
scan_params.passive = m_scanParams.passive;
|
||||
scan_params.itvl = m_scanParams.itvl;
|
||||
scan_params.window = m_scanParams.window;
|
||||
int rc = ble_gap_ext_disc(NimBLEDevice::m_ownAddrType,
|
||||
duration / 10,
|
||||
0,
|
||||
m_scan_params.filter_duplicates,
|
||||
m_scan_params.filter_policy,
|
||||
m_scan_params.limited,
|
||||
m_scanParams.filter_duplicates,
|
||||
m_scanParams.filter_policy,
|
||||
m_scanParams.limited,
|
||||
&scan_params,
|
||||
&scan_params,
|
||||
NimBLEScan::handleGapEvent,
|
||||
NULL);
|
||||
#else
|
||||
int rc = ble_gap_disc(NimBLEDevice::m_ownAddrType,
|
||||
duration,
|
||||
&m_scan_params,
|
||||
NimBLEScan::handleGapEvent,
|
||||
NULL);
|
||||
#endif
|
||||
switch(rc) {
|
||||
# else
|
||||
int rc = ble_gap_disc(NimBLEDevice::m_ownAddrType, duration, &m_scanParams, NimBLEScan::handleGapEvent, NULL);
|
||||
# endif
|
||||
switch (rc) {
|
||||
case 0:
|
||||
if(!is_continue) {
|
||||
clearResults();
|
||||
}
|
||||
break;
|
||||
|
||||
case BLE_HS_EALREADY:
|
||||
// Clear the cache if already scanning in case an advertiser was missed.
|
||||
clearDuplicateCache();
|
||||
NIMBLE_LOGD(LOG_TAG, "Scan started");
|
||||
break;
|
||||
|
||||
case BLE_HS_EBUSY:
|
||||
|
|
@ -355,21 +336,14 @@ bool NimBLEScan::start(uint32_t duration, bool is_continue) {
|
|||
break;
|
||||
|
||||
default:
|
||||
NIMBLE_LOGE(LOG_TAG, "Error initiating GAP discovery procedure; rc=%d, %s",
|
||||
rc, NimBLEUtils::returnCodeToString(rc));
|
||||
NIMBLE_LOGE(LOG_TAG, "Error starting scan; rc=%d, %s", rc, NimBLEUtils::returnCodeToString(rc));
|
||||
break;
|
||||
}
|
||||
|
||||
m_ignoreResults = false;
|
||||
NIMBLE_LOGD(LOG_TAG, "<< start()");
|
||||
|
||||
if(rc != 0 && rc != BLE_HS_EALREADY) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
return rc == 0 || rc == BLE_HS_EALREADY;
|
||||
} // start
|
||||
|
||||
|
||||
/**
|
||||
* @brief Stop an in progress scan.
|
||||
* @return True if successful.
|
||||
|
|
@ -383,15 +357,11 @@ bool NimBLEScan::stop() {
|
|||
return false;
|
||||
}
|
||||
|
||||
if(m_maxResults == 0) {
|
||||
if (m_maxResults == 0) {
|
||||
clearResults();
|
||||
}
|
||||
|
||||
if (rc != BLE_HS_EALREADY && m_pScanCallbacks != nullptr) {
|
||||
m_pScanCallbacks->onScanEnd(m_scanResults);
|
||||
}
|
||||
|
||||
if(m_pTaskData != nullptr) {
|
||||
if (m_pTaskData != nullptr) {
|
||||
NimBLEUtils::taskRelease(*m_pTaskData);
|
||||
}
|
||||
|
||||
|
|
@ -399,56 +369,32 @@ bool NimBLEScan::stop() {
|
|||
return true;
|
||||
} // stop
|
||||
|
||||
|
||||
/**
|
||||
* @brief Clears the duplicate scan filter cache.
|
||||
*/
|
||||
void NimBLEScan::clearDuplicateCache() {
|
||||
#ifdef CONFIG_IDF_TARGET_ESP32 // Not available for ESP32C3
|
||||
esp_ble_scan_dupilcate_list_flush();
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @brief Delete peer device from the scan results vector.
|
||||
* @param [in] address The address of the device to delete from the results.
|
||||
* @details After disconnecting, it may be required in the case we were connected to a device without a public address.
|
||||
*/
|
||||
void NimBLEScan::erase(const NimBLEAddress &address) {
|
||||
void NimBLEScan::erase(const NimBLEAddress& address) {
|
||||
NIMBLE_LOGD(LOG_TAG, "erase device: %s", address.toString().c_str());
|
||||
|
||||
for(auto it = m_scanResults.m_advertisedDevicesVector.begin(); it != m_scanResults.m_advertisedDevicesVector.end(); ++it) {
|
||||
if((*it)->getAddress() == address) {
|
||||
for (auto it = m_scanResults.m_deviceVec.begin(); it != m_scanResults.m_deviceVec.end(); ++it) {
|
||||
if ((*it)->getAddress() == address) {
|
||||
delete *it;
|
||||
m_scanResults.m_advertisedDevicesVector.erase(it);
|
||||
m_scanResults.m_deviceVec.erase(it);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @brief Called when host reset, we set a flag to stop scanning until synced.
|
||||
*/
|
||||
void NimBLEScan::onHostReset() {
|
||||
m_ignoreResults = true;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @brief If the host reset and re-synced this is called.
|
||||
* If the application was scanning indefinitely with a callback, restart it.
|
||||
*/
|
||||
void NimBLEScan::onHostSync() {
|
||||
m_ignoreResults = false;
|
||||
|
||||
if(m_duration == 0 && m_pScanCallbacks != nullptr) {
|
||||
if (m_duration == 0 && m_pScanCallbacks != nullptr) {
|
||||
start(0, false);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @brief Start scanning and block until scanning has been completed.
|
||||
* @param [in] duration The duration in milliseconds for which to scan.
|
||||
|
|
@ -456,14 +402,19 @@ void NimBLEScan::onHostSync() {
|
|||
* @return The scan results.
|
||||
*/
|
||||
NimBLEScanResults NimBLEScan::getResults(uint32_t duration, bool is_continue) {
|
||||
if(duration == 0) {
|
||||
if (duration == 0) {
|
||||
NIMBLE_LOGW(LOG_TAG, "Blocking scan called with duration = forever");
|
||||
}
|
||||
|
||||
if (m_pTaskData != nullptr) {
|
||||
NIMBLE_LOGE(LOG_TAG, "Scan already in progress");
|
||||
return m_scanResults;
|
||||
}
|
||||
|
||||
NimBLETaskData taskData;
|
||||
m_pTaskData = &taskData;
|
||||
|
||||
if(start(duration, is_continue)) {
|
||||
if (start(duration, is_continue)) {
|
||||
NimBLEUtils::taskWait(taskData, BLE_NPL_TIME_FOREVER);
|
||||
}
|
||||
|
||||
|
|
@ -471,7 +422,6 @@ NimBLEScanResults NimBLEScan::getResults(uint32_t duration, bool is_continue) {
|
|||
return m_scanResults;
|
||||
} // getResults
|
||||
|
||||
|
||||
/**
|
||||
* @brief Get the results of the scan.
|
||||
* @return NimBLEScanResults object.
|
||||
|
|
@ -480,39 +430,34 @@ NimBLEScanResults NimBLEScan::getResults() {
|
|||
return m_scanResults;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @brief Clear the results of the scan.
|
||||
*/
|
||||
void NimBLEScan::clearResults() {
|
||||
for(auto &it: m_scanResults.m_advertisedDevicesVector) {
|
||||
for (auto& it : m_scanResults.m_deviceVec) {
|
||||
delete it;
|
||||
}
|
||||
m_scanResults.m_advertisedDevicesVector.clear();
|
||||
clearDuplicateCache();
|
||||
}
|
||||
|
||||
std::vector<NimBLEAdvertisedDevice*>().swap(m_scanResults.m_deviceVec);
|
||||
} // clearResults
|
||||
|
||||
/**
|
||||
* @brief Dump the scan results to the log.
|
||||
*/
|
||||
void NimBLEScanResults::dump() {
|
||||
NIMBLE_LOGD(LOG_TAG, ">> Dump scan results:");
|
||||
for (int i=0; i<getCount(); i++) {
|
||||
for (int i = 0; i < getCount(); i++) {
|
||||
NIMBLE_LOGI(LOG_TAG, "- %s", getDevice(i).toString().c_str());
|
||||
}
|
||||
} // dump
|
||||
|
||||
|
||||
/**
|
||||
* @brief Get the count of devices found in the last scan.
|
||||
* @return The number of devices found in the last scan.
|
||||
*/
|
||||
int NimBLEScanResults::getCount() {
|
||||
return m_advertisedDevicesVector.size();
|
||||
return m_deviceVec.size();
|
||||
} // getCount
|
||||
|
||||
|
||||
/**
|
||||
* @brief Return the specified device at the given index.
|
||||
* The index should be between 0 and getCount()-1.
|
||||
|
|
@ -520,38 +465,35 @@ int NimBLEScanResults::getCount() {
|
|||
* @return The device at the specified index.
|
||||
*/
|
||||
NimBLEAdvertisedDevice NimBLEScanResults::getDevice(uint32_t i) {
|
||||
return *m_advertisedDevicesVector[i];
|
||||
return *m_deviceVec[i];
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @brief Get iterator to the beginning of the vector of advertised device pointers.
|
||||
* @return An iterator to the beginning of the vector of advertised device pointers.
|
||||
*/
|
||||
std::vector<NimBLEAdvertisedDevice*>::iterator NimBLEScanResults::begin() {
|
||||
return m_advertisedDevicesVector.begin();
|
||||
return m_deviceVec.begin();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @brief Get iterator to the end of the vector of advertised device pointers.
|
||||
* @return An iterator to the end of the vector of advertised device pointers.
|
||||
*/
|
||||
std::vector<NimBLEAdvertisedDevice*>::iterator NimBLEScanResults::end() {
|
||||
return m_advertisedDevicesVector.end();
|
||||
return m_deviceVec.end();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @brief Get a pointer to the specified device at the given address.
|
||||
* If the address is not found a nullptr is returned.
|
||||
* @param [in] address The address of the device.
|
||||
* @return A pointer to the device at the specified address.
|
||||
*/
|
||||
NimBLEAdvertisedDevice *NimBLEScanResults::getDevice(const NimBLEAddress &address) {
|
||||
for(size_t index = 0; index < m_advertisedDevicesVector.size(); index++) {
|
||||
if(m_advertisedDevicesVector[index]->getAddress() == address) {
|
||||
return m_advertisedDevicesVector[index];
|
||||
NimBLEAdvertisedDevice* NimBLEScanResults::getDevice(const NimBLEAddress& address) {
|
||||
for (size_t index = 0; index < m_deviceVec.size(); index++) {
|
||||
if (m_deviceVec[index]->getAddress() == address) {
|
||||
return m_deviceVec[index];
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -17,16 +17,16 @@
|
|||
#include "nimconfig.h"
|
||||
#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
|
||||
|
||||
#include "NimBLEAdvertisedDevice.h"
|
||||
#include "NimBLEUtils.h"
|
||||
# include "NimBLEAdvertisedDevice.h"
|
||||
# include "NimBLEUtils.h"
|
||||
|
||||
#if defined(CONFIG_NIMBLE_CPP_IDF)
|
||||
#include "host/ble_gap.h"
|
||||
#else
|
||||
#include "nimble/nimble/host/include/host/ble_gap.h"
|
||||
#endif
|
||||
# if defined(CONFIG_NIMBLE_CPP_IDF)
|
||||
# include "host/ble_gap.h"
|
||||
# else
|
||||
# include "nimble/nimble/host/include/host/ble_gap.h"
|
||||
# endif
|
||||
|
||||
#include <vector>
|
||||
# include <vector>
|
||||
|
||||
class NimBLEDevice;
|
||||
class NimBLEScan;
|
||||
|
|
@ -42,17 +42,17 @@ class NimBLEAddress;
|
|||
* index (starting at 0) of the desired device.
|
||||
*/
|
||||
class NimBLEScanResults {
|
||||
public:
|
||||
public:
|
||||
void dump();
|
||||
int getCount();
|
||||
NimBLEAdvertisedDevice getDevice(uint32_t i);
|
||||
std::vector<NimBLEAdvertisedDevice*>::iterator begin();
|
||||
std::vector<NimBLEAdvertisedDevice*>::iterator end();
|
||||
NimBLEAdvertisedDevice *getDevice(const NimBLEAddress &address);
|
||||
NimBLEAdvertisedDevice* getDevice(const NimBLEAddress& address);
|
||||
|
||||
private:
|
||||
private:
|
||||
friend NimBLEScan;
|
||||
std::vector<NimBLEAdvertisedDevice*> m_advertisedDevicesVector;
|
||||
std::vector<NimBLEAdvertisedDevice*> m_deviceVec;
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -61,48 +61,44 @@ private:
|
|||
* Scanning is associated with a %BLE client that is attempting to locate BLE servers.
|
||||
*/
|
||||
class NimBLEScan {
|
||||
public:
|
||||
bool start(uint32_t duration, bool is_continue = false);
|
||||
bool isScanning();
|
||||
void setScanCallbacks(NimBLEScanCallbacks* pScanCallbacks, bool wantDuplicates = false);
|
||||
void setActiveScan(bool active);
|
||||
void setInterval(uint16_t intervalMSecs);
|
||||
void setWindow(uint16_t windowMSecs);
|
||||
void setDuplicateFilter(bool enabled);
|
||||
void setLimitedOnly(bool enabled);
|
||||
void setFilterPolicy(uint8_t filter);
|
||||
void clearDuplicateCache();
|
||||
bool stop();
|
||||
void clearResults();
|
||||
NimBLEScanResults getResults();
|
||||
NimBLEScanResults getResults(uint32_t duration, bool is_continue = false);
|
||||
void setMaxResults(uint8_t maxResults);
|
||||
void erase(const NimBLEAddress &address);
|
||||
public:
|
||||
bool start(uint32_t duration, bool is_continue = false, bool restart = true);
|
||||
bool isScanning();
|
||||
void setScanCallbacks(NimBLEScanCallbacks* pScanCallbacks, bool wantDuplicates = false);
|
||||
void setActiveScan(bool active);
|
||||
void setInterval(uint16_t intervalMSecs);
|
||||
void setWindow(uint16_t windowMSecs);
|
||||
void setDuplicateFilter(bool enabled);
|
||||
void setLimitedOnly(bool enabled);
|
||||
void setFilterPolicy(uint8_t filter);
|
||||
bool stop();
|
||||
void clearResults();
|
||||
NimBLEScanResults getResults();
|
||||
NimBLEScanResults getResults(uint32_t duration, bool is_continue = false);
|
||||
void setMaxResults(uint8_t maxResults);
|
||||
void erase(const NimBLEAddress& address);
|
||||
|
||||
|
||||
private:
|
||||
private:
|
||||
friend class NimBLEDevice;
|
||||
|
||||
NimBLEScan();
|
||||
~NimBLEScan();
|
||||
static int handleGapEvent(ble_gap_event* event, void* arg);
|
||||
void onHostReset();
|
||||
void onHostSync();
|
||||
static int handleGapEvent(ble_gap_event* event, void* arg);
|
||||
void onHostSync();
|
||||
|
||||
NimBLEScanCallbacks* m_pScanCallbacks;
|
||||
ble_gap_disc_params m_scan_params;
|
||||
bool m_ignoreResults;
|
||||
NimBLEScanResults m_scanResults;
|
||||
uint32_t m_duration;
|
||||
NimBLETaskData *m_pTaskData;
|
||||
uint8_t m_maxResults;
|
||||
NimBLEScanCallbacks* m_pScanCallbacks;
|
||||
ble_gap_disc_params m_scanParams;
|
||||
NimBLEScanResults m_scanResults;
|
||||
uint32_t m_duration;
|
||||
NimBLETaskData* m_pTaskData;
|
||||
uint8_t m_maxResults;
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief A callback handler for callbacks associated device scanning.
|
||||
*/
|
||||
class NimBLEScanCallbacks {
|
||||
public:
|
||||
public:
|
||||
virtual ~NimBLEScanCallbacks() {}
|
||||
|
||||
/**
|
||||
|
|
|
|||
Loading…
Reference in a new issue