| /* |
| * Copyright 2019 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| #include "hci/le_scanning_manager.h" |
| |
| #include <bluetooth/log.h> |
| #include <com_android_bluetooth_flags.h> |
| |
| #include <memory> |
| #include <unordered_map> |
| |
| #include "hci/acl_manager.h" |
| #include "hci/controller.h" |
| #include "hci/event_checkers.h" |
| #include "hci/hci_layer.h" |
| #include "hci/hci_packets.h" |
| #include "hci/le_periodic_sync_manager.h" |
| #include "hci/le_scanning_interface.h" |
| #include "hci/le_scanning_reassembler.h" |
| #include "hci/vendor_specific_event_manager.h" |
| #include "module.h" |
| #include "os/handler.h" |
| #include "os/log.h" |
| #include "os/system_properties.h" |
| #include "storage/storage_module.h" |
| |
| namespace bluetooth { |
| namespace hci { |
| |
| constexpr uint16_t kLeScanWindowMin = 0x0004; |
| constexpr uint16_t kLeScanWindowMax = 0x4000; |
| constexpr int64_t kLeScanRssiMin = -127; |
| constexpr int64_t kLeScanRssiMax = 20; |
| constexpr int64_t kLeScanRssiUnknown = 127; |
| constexpr int64_t kLeRxPathLossCompMin = -128; |
| constexpr int64_t kLeRxPathLossCompMax = 127; |
| constexpr uint16_t kDefaultLeExtendedScanWindow = 4800; |
| constexpr uint16_t kLeExtendedScanWindowMax = 0xFFFF; |
| constexpr uint16_t kLeScanIntervalMin = 0x0004; |
| constexpr uint16_t kLeScanIntervalMax = 0x4000; |
| constexpr uint16_t kDefaultLeExtendedScanInterval = 4800; |
| constexpr uint16_t kLeExtendedScanIntervalMax = 0xFFFF; |
| |
| constexpr uint8_t kScannableBit = 1; |
| constexpr uint8_t kDirectedBit = 2; |
| constexpr uint8_t kScanResponseBit = 3; |
| constexpr uint8_t kLegacyBit = 4; |
| constexpr uint8_t kDataStatusBits = 5; |
| |
| // system properties |
| const std::string kLeRxPathLossCompProperty = "bluetooth.hardware.radio.le_rx_path_loss_comp_db"; |
| |
| const ModuleFactory LeScanningManager::Factory = ModuleFactory([]() { return new LeScanningManager(); }); |
| |
| enum class ScanApiType { |
| LEGACY = 1, |
| ANDROID_HCI = 2, |
| EXTENDED = 3, |
| }; |
| |
| struct Scanner { |
| Uuid app_uuid; |
| bool in_use; |
| }; |
| |
| class NullScanningCallback : public ScanningCallback { |
| void OnScannerRegistered( |
| const Uuid /* app_uuid */, ScannerId /* scanner_id */, ScanningStatus /* status */) override { |
| log::info("OnScannerRegistered in NullScanningCallback"); |
| } |
| void OnSetScannerParameterComplete( |
| ScannerId /* scanner_id */, ScanningStatus /* status */) override { |
| log::info("OnSetScannerParameterComplete in NullScanningCallback"); |
| } |
| void OnScanResult( |
| uint16_t /* event_type */, |
| uint8_t /* address_type */, |
| Address /* address */, |
| uint8_t /* primary_phy */, |
| uint8_t /* secondary_phy */, |
| uint8_t /* advertising_sid */, |
| int8_t /* tx_power */, |
| int8_t /* rssi */, |
| uint16_t /* periodic_advertising_interval */, |
| std::vector<uint8_t> /* advertising_data */) override { |
| log::info("OnScanResult in NullScanningCallback"); |
| } |
| void OnTrackAdvFoundLost( |
| AdvertisingFilterOnFoundOnLostInfo /* on_found_on_lost_info */) override { |
| log::info("OnTrackAdvFoundLost in NullScanningCallback"); |
| } |
| void OnBatchScanReports( |
| int /* client_if */, |
| int /* status */, |
| int /* report_format */, |
| int /* num_records */, |
| std::vector<uint8_t> /* data */) override { |
| log::info("OnBatchScanReports in NullScanningCallback"); |
| } |
| void OnBatchScanThresholdCrossed(int /* client_if */) override { |
| log::info("OnBatchScanThresholdCrossed in NullScanningCallback"); |
| } |
| void OnTimeout() override { |
| log::info("OnTimeout in NullScanningCallback"); |
| } |
| void OnFilterEnable(Enable /* enable */, uint8_t /* status */) override { |
| log::info("OnFilterEnable in NullScanningCallback"); |
| } |
| void OnFilterParamSetup( |
| uint8_t /* available_spaces */, ApcfAction /* action */, uint8_t /* status */) override { |
| log::info("OnFilterParamSetup in NullScanningCallback"); |
| } |
| void OnFilterConfigCallback( |
| ApcfFilterType /* filter_type */, |
| uint8_t /* available_spaces */, |
| ApcfAction /* action */, |
| uint8_t /* status */) override { |
| log::info("OnFilterConfigCallback in NullScanningCallback"); |
| } |
| void OnPeriodicSyncStarted( |
| int /* reg_id */, |
| uint8_t /* status */, |
| uint16_t /* sync_handle */, |
| uint8_t /* advertising_sid */, |
| AddressWithType /* address_with_type */, |
| uint8_t /* phy */, |
| uint16_t /* interval */) override { |
| log::info("OnPeriodicSyncStarted in NullScanningCallback"); |
| }; |
| void OnPeriodicSyncReport( |
| uint16_t /* sync_handle */, |
| int8_t /* tx_power */, |
| int8_t /* rssi */, |
| uint8_t /* status */, |
| std::vector<uint8_t> /* data */) override { |
| log::info("OnPeriodicSyncReport in NullScanningCallback"); |
| }; |
| void OnPeriodicSyncLost(uint16_t /* sync_handle */) override { |
| log::info("OnPeriodicSyncLost in NullScanningCallback"); |
| }; |
| void OnPeriodicSyncTransferred( |
| int /* pa_source */, uint8_t /* status */, Address /* address */) override { |
| log::info("OnPeriodicSyncTransferred in NullScanningCallback"); |
| }; |
| void OnBigInfoReport(uint16_t /* sync_handle */, bool /* encrypted */) { |
| log::info("OnBigInfoReport in NullScanningCallback"); |
| }; |
| }; |
| |
| enum class BatchScanState { |
| ERROR_STATE = 0, |
| ENABLE_CALLED = 1, |
| ENABLED_STATE = 2, |
| DISABLE_CALLED = 3, |
| DISABLED_STATE = 4, |
| }; |
| |
| #define BTM_BLE_BATCH_SCAN_MODE_DISABLE 0 |
| #define BTM_BLE_BATCH_SCAN_MODE_PASS 1 |
| #define BTM_BLE_BATCH_SCAN_MODE_ACTI 2 |
| #define BTM_BLE_BATCH_SCAN_MODE_PASS_ACTI 3 |
| |
| struct BatchScanConfig { |
| BatchScanState current_state; |
| BatchScanMode scan_mode; |
| uint32_t scan_interval; |
| uint32_t scan_window; |
| BatchScanDiscardRule discard_rule; |
| ScannerId ref_value; |
| }; |
| |
| struct LeScanningManager::impl : public LeAddressManagerCallback { |
| impl(Module* module) : module_(module), le_scanning_interface_(nullptr) {} |
| |
| ~impl() { |
| if (address_manager_registered_) { |
| le_address_manager_->Unregister(this); |
| } |
| } |
| |
| void start( |
| os::Handler* handler, |
| HciLayer* hci_layer, |
| Controller* controller, |
| AclManager* acl_manager, |
| VendorSpecificEventManager* vendor_specific_event_manager, |
| storage::StorageModule* storage_module) { |
| module_handler_ = handler; |
| hci_layer_ = hci_layer; |
| controller_ = controller; |
| acl_manager_ = acl_manager; |
| vendor_specific_event_manager_ = vendor_specific_event_manager; |
| storage_module_ = storage_module; |
| le_address_manager_ = acl_manager->GetLeAddressManager(); |
| le_scanning_interface_ = hci_layer_->GetLeScanningInterface( |
| module_handler_->BindOn(this, &LeScanningManager::impl::handle_scan_results)); |
| periodic_sync_manager_.Init(le_scanning_interface_, module_handler_); |
| /* Check to see if the opcode is supported and C19 (support for extended advertising). */ |
| if (controller_->IsSupported(OpCode::LE_SET_EXTENDED_SCAN_PARAMETERS) && |
| controller->SupportsBleExtendedAdvertising()) { |
| api_type_ = ScanApiType::EXTENDED; |
| interval_ms_ = kDefaultLeExtendedScanInterval; |
| window_ms_ = kDefaultLeExtendedScanWindow; |
| phy_ = static_cast<uint8_t>(PhyType::LE_1M); |
| } else if (controller_->IsSupported(OpCode::LE_EXTENDED_SCAN_PARAMS)) { |
| api_type_ = ScanApiType::ANDROID_HCI; |
| } else { |
| api_type_ = ScanApiType::LEGACY; |
| } |
| is_filter_supported_ = controller_->IsSupported(OpCode::LE_ADV_FILTER); |
| if (is_filter_supported_) { |
| le_scanning_interface_->EnqueueCommand( |
| LeAdvFilterReadExtendedFeaturesBuilder::Create(), |
| module_handler_->BindOnceOn(this, &impl::on_apcf_read_extended_features_complete)); |
| } |
| is_batch_scan_supported_ = controller->IsSupported(OpCode::LE_BATCH_SCAN); |
| is_periodic_advertising_sync_transfer_sender_supported_ = |
| controller_->SupportsBlePeriodicAdvertisingSyncTransferSender(); |
| total_num_of_advt_tracked_ = controller->GetVendorCapabilities().total_num_of_advt_tracked_; |
| if (is_batch_scan_supported_) { |
| vendor_specific_event_manager_->RegisterEventHandler( |
| VseSubeventCode::BLE_THRESHOLD, handler->BindOn(this, &LeScanningManager::impl::on_storage_threshold_breach)); |
| vendor_specific_event_manager_->RegisterEventHandler( |
| VseSubeventCode::BLE_TRACKING, handler->BindOn(this, &LeScanningManager::impl::on_advertisement_tracking)); |
| } |
| scanners_ = std::vector<Scanner>(kMaxAppNum + 1); |
| for (size_t i = 0; i < scanners_.size(); i++) { |
| scanners_[i].app_uuid = Uuid::kEmpty; |
| scanners_[i].in_use = false; |
| } |
| batch_scan_config_.current_state = BatchScanState::DISABLED_STATE; |
| batch_scan_config_.ref_value = kInvalidScannerId; |
| le_rx_path_loss_comp_ = get_rx_path_loss_compensation(); |
| } |
| |
| void stop() { |
| for (auto subevent_code : LeScanningEvents) { |
| hci_layer_->UnregisterLeEventHandler(subevent_code); |
| } |
| if (is_batch_scan_supported_) { |
| // TODO implete vse module |
| // hci_layer_->UnregisterVesEventHandler(VseSubeventCode::BLE_THRESHOLD); |
| // hci_layer_->UnregisterVesEventHandler(VseSubeventCode::BLE_TRACKING); |
| } |
| batch_scan_config_.current_state = BatchScanState::DISABLED_STATE; |
| batch_scan_config_.ref_value = kInvalidScannerId; |
| scanning_callbacks_ = &null_scanning_callback_; |
| periodic_sync_manager_.SetScanningCallback(scanning_callbacks_); |
| } |
| |
| void handle_scan_results(LeMetaEventView event) { |
| switch (event.GetSubeventCode()) { |
| case SubeventCode::ADVERTISING_REPORT: |
| handle_advertising_report(LeAdvertisingReportRawView::Create(event)); |
| break; |
| case SubeventCode::DIRECTED_ADVERTISING_REPORT: |
| handle_directed_advertising_report(LeDirectedAdvertisingReportView::Create(event)); |
| break; |
| case SubeventCode::EXTENDED_ADVERTISING_REPORT: |
| handle_extended_advertising_report(LeExtendedAdvertisingReportRawView::Create(event)); |
| break; |
| case SubeventCode::PERIODIC_ADVERTISING_SYNC_ESTABLISHED: |
| LePeriodicAdvertisingSyncEstablishedView::Create(event); |
| periodic_sync_manager_.HandleLePeriodicAdvertisingSyncEstablished( |
| LePeriodicAdvertisingSyncEstablishedView::Create(event)); |
| break; |
| case SubeventCode::PERIODIC_ADVERTISING_REPORT: |
| periodic_sync_manager_.HandleLePeriodicAdvertisingReport(LePeriodicAdvertisingReportView::Create(event)); |
| break; |
| case SubeventCode::PERIODIC_ADVERTISING_SYNC_LOST: |
| periodic_sync_manager_.HandleLePeriodicAdvertisingSyncLost(LePeriodicAdvertisingSyncLostView::Create(event)); |
| break; |
| case SubeventCode::PERIODIC_ADVERTISING_SYNC_TRANSFER_RECEIVED: |
| periodic_sync_manager_.HandleLePeriodicAdvertisingSyncTransferReceived( |
| LePeriodicAdvertisingSyncTransferReceivedView::Create(event)); |
| break; |
| case SubeventCode::SCAN_TIMEOUT: |
| scanning_callbacks_->OnTimeout(); |
| break; |
| case SubeventCode::BIG_INFO_ADVERTISING_REPORT: |
| periodic_sync_manager_.HandleLeBigInfoAdvertisingReport( |
| LeBigInfoAdvertisingReportView::Create(event)); |
| break; |
| default: |
| log::fatal("Unknown advertising subevent {}", SubeventCodeText(event.GetSubeventCode())); |
| } |
| } |
| |
| struct ExtendedEventTypeOptions { |
| bool connectable{false}; |
| bool scannable{false}; |
| bool directed{false}; |
| bool scan_response{false}; |
| bool legacy{false}; |
| bool continuing{false}; |
| bool truncated{false}; |
| }; |
| |
| int8_t get_rx_path_loss_compensation() { |
| int8_t compensation = 0; |
| auto compensation_prop = os::GetSystemProperty(kLeRxPathLossCompProperty); |
| if (compensation_prop) { |
| auto compensation_number = common::Int64FromString(compensation_prop.value()); |
| if (compensation_number) { |
| int64_t number = compensation_number.value(); |
| if (number < kLeRxPathLossCompMin || number > kLeRxPathLossCompMax) { |
| log::error("Invalid number for rx path loss compensation: {}", number); |
| } else { |
| compensation = number; |
| } |
| } |
| } |
| log::info("Rx path loss compensation: {}", compensation); |
| return compensation; |
| } |
| |
| int8_t get_rssi_after_calibration(int8_t rssi) { |
| if (le_rx_path_loss_comp_ == 0 || rssi == kLeScanRssiUnknown) { |
| return rssi; |
| } |
| int8_t calibrated_rssi = rssi; |
| int64_t number = rssi + le_rx_path_loss_comp_; |
| if (number < kLeScanRssiMin || number > kLeScanRssiMax) { |
| log::error("Invalid number for calibrated rssi: {}", number); |
| } else { |
| calibrated_rssi = number; |
| } |
| return calibrated_rssi; |
| } |
| |
| uint16_t transform_to_extended_event_type(ExtendedEventTypeOptions o) { |
| return (o.connectable ? 0x0001 << 0 : 0) | (o.scannable ? 0x0001 << 1 : 0) | |
| (o.directed ? 0x0001 << 2 : 0) | (o.scan_response ? 0x0001 << 3 : 0) | |
| (o.legacy ? 0x0001 << 4 : 0) | (o.continuing ? 0x0001 << 5 : 0) | |
| (o.truncated ? 0x0001 << 6 : 0); |
| } |
| |
| void handle_advertising_report(LeAdvertisingReportRawView event_view) { |
| if (!event_view.IsValid()) { |
| log::info("Dropping invalid advertising event"); |
| return; |
| } |
| std::vector<LeAdvertisingResponseRaw> reports = event_view.GetResponses(); |
| if (reports.empty()) { |
| log::info("Zero results in advertising event"); |
| return; |
| } |
| |
| for (LeAdvertisingResponseRaw report : reports) { |
| uint16_t extended_event_type = 0; |
| switch (report.event_type_) { |
| case AdvertisingEventType::ADV_IND: |
| extended_event_type = transform_to_extended_event_type( |
| {.connectable = true, .scannable = true, .legacy = true}); |
| break; |
| case AdvertisingEventType::ADV_DIRECT_IND: |
| extended_event_type = transform_to_extended_event_type( |
| {.connectable = true, .directed = true, .legacy = true}); |
| break; |
| case AdvertisingEventType::ADV_SCAN_IND: |
| extended_event_type = |
| transform_to_extended_event_type({.scannable = true, .legacy = true}); |
| break; |
| case AdvertisingEventType::ADV_NONCONN_IND: |
| extended_event_type = transform_to_extended_event_type({.legacy = true}); |
| break; |
| case AdvertisingEventType::SCAN_RESPONSE: |
| if (com::android::bluetooth::flags::fix_nonconnectable_scannable_advertisement()) { |
| // We don't know if the initial advertising report was connectable or not. |
| // LeScanningReassembler fixes the connectable field. |
| extended_event_type = transform_to_extended_event_type( |
| {.scannable = true, .scan_response = true, .legacy = true}); |
| } else { |
| extended_event_type = transform_to_extended_event_type( |
| {.connectable = true, .scannable = true, .scan_response = true, .legacy = true}); |
| } |
| break; |
| default: |
| log::warn("Unsupported event type:{}", (uint16_t)report.event_type_); |
| return; |
| } |
| |
| process_advertising_package_content( |
| extended_event_type, |
| (uint8_t)report.address_type_, |
| report.address_, |
| (uint8_t)PrimaryPhyType::LE_1M, |
| (uint8_t)SecondaryPhyType::NO_PACKETS, |
| kAdvertisingDataInfoNotPresent, |
| kTxPowerInformationNotPresent, |
| report.rssi_, |
| kNotPeriodicAdvertisement, |
| report.advertising_data_); |
| } |
| } |
| |
| void handle_directed_advertising_report(LeDirectedAdvertisingReportView /*event_view*/) { |
| log::warn("HCI Directed Advertising Report events are not supported"); |
| } |
| |
| void handle_extended_advertising_report(LeExtendedAdvertisingReportRawView event_view) { |
| if (!event_view.IsValid()) { |
| log::info("Dropping invalid advertising event"); |
| return; |
| } |
| |
| std::vector<LeExtendedAdvertisingResponseRaw> reports = event_view.GetResponses(); |
| if (reports.empty()) { |
| log::info("Zero results in advertising event"); |
| return; |
| } |
| |
| for (LeExtendedAdvertisingResponseRaw& report : reports) { |
| uint16_t event_type = report.connectable_ | (report.scannable_ << kScannableBit) | |
| (report.directed_ << kDirectedBit) | (report.scan_response_ << kScanResponseBit) | |
| (report.legacy_ << kLegacyBit) | ((uint16_t)report.data_status_ << kDataStatusBits); |
| process_advertising_package_content( |
| event_type, |
| (uint8_t)report.address_type_, |
| report.address_, |
| (uint8_t)report.primary_phy_, |
| (uint8_t)report.secondary_phy_, |
| report.advertising_sid_, |
| report.tx_power_, |
| report.rssi_, |
| report.periodic_advertising_interval_, |
| report.advertising_data_); |
| } |
| } |
| |
| void process_advertising_package_content( |
| uint16_t event_type, |
| uint8_t address_type, |
| Address address, |
| uint8_t primary_phy, |
| uint8_t secondary_phy, |
| uint8_t advertising_sid, |
| int8_t tx_power, |
| int8_t rssi, |
| uint16_t periodic_advertising_interval, |
| const std::vector<uint8_t>& advertising_data) { |
| // When using the vendor command Le Set Extended Params to |
| // configure a filter accept list based e.g. on the service UUIDs |
| // found in the report, we ignore the scan responses as we cannot be |
| // certain that they will not be dropped by the filter. |
| // TODO(b/275754998): Improve the decision on what to do with scan responses: Only when used |
| // with hardware-filtering features should we ignore waiting for scan response, and make sure |
| // scan responses are still reported too. |
| scanning_reassembler_.SetIgnoreScanResponses( |
| le_scan_type_ == LeScanType::PASSIVE || |
| filter_policy_ == LeScanningFilterPolicy::FILTER_ACCEPT_LIST_ONLY); |
| |
| std::optional<LeScanningReassembler::CompleteAdvertisingData> processed_report = |
| scanning_reassembler_.ProcessAdvertisingReport( |
| event_type, address_type, address, advertising_sid, advertising_data); |
| |
| if (processed_report.has_value()) { |
| switch (address_type) { |
| case (uint8_t)AddressType::PUBLIC_DEVICE_ADDRESS: |
| case (uint8_t)AddressType::PUBLIC_IDENTITY_ADDRESS: |
| address_type = (uint8_t)AddressType::PUBLIC_DEVICE_ADDRESS; |
| break; |
| case (uint8_t)AddressType::RANDOM_DEVICE_ADDRESS: |
| case (uint8_t)AddressType::RANDOM_IDENTITY_ADDRESS: |
| address_type = (uint8_t)AddressType::RANDOM_DEVICE_ADDRESS; |
| break; |
| } |
| |
| const uint16_t result_event_type = |
| com::android::bluetooth::flags::fix_nonconnectable_scannable_advertisement() |
| ? processed_report->extended_event_type |
| : event_type; |
| |
| scanning_callbacks_->OnScanResult( |
| result_event_type, |
| address_type, |
| address, |
| primary_phy, |
| secondary_phy, |
| advertising_sid, |
| tx_power, |
| get_rssi_after_calibration(rssi), |
| periodic_advertising_interval, |
| std::move(processed_report->data)); |
| } |
| } |
| |
| void configure_scan() { |
| std::vector<PhyScanParameters> parameter_vector; |
| for (int i = 0; i < 7; i++) { |
| if ((phy_ & 1 << i) != 0) { |
| PhyScanParameters phy_scan_parameters; |
| phy_scan_parameters.le_scan_window_ = window_ms_; |
| phy_scan_parameters.le_scan_interval_ = interval_ms_; |
| phy_scan_parameters.le_scan_type_ = le_scan_type_; |
| parameter_vector.push_back(phy_scan_parameters); |
| } |
| } |
| uint8_t phys_in_use = phy_; |
| |
| // The Host shall not issue set scan parameter command when scanning is enabled |
| stop_scan(); |
| |
| if (le_address_manager_->GetAddressPolicy() != LeAddressManager::USE_PUBLIC_ADDRESS) { |
| own_address_type_ = OwnAddressType::RANDOM_DEVICE_ADDRESS; |
| } else { |
| own_address_type_ = OwnAddressType::PUBLIC_DEVICE_ADDRESS; |
| } |
| |
| switch (api_type_) { |
| case ScanApiType::EXTENDED: |
| le_scanning_interface_->EnqueueCommand( |
| LeSetExtendedScanParametersBuilder::Create( |
| own_address_type_, filter_policy_, phys_in_use, parameter_vector), |
| module_handler_->BindOnceOn(this, &impl::on_set_scan_parameter_complete)); |
| break; |
| case ScanApiType::ANDROID_HCI: |
| le_scanning_interface_->EnqueueCommand( |
| LeExtendedScanParamsBuilder::Create( |
| le_scan_type_, interval_ms_, window_ms_, own_address_type_, filter_policy_), |
| module_handler_->BindOnceOn(this, &impl::on_set_scan_parameter_complete)); |
| |
| break; |
| case ScanApiType::LEGACY: |
| le_scanning_interface_->EnqueueCommand( |
| |
| LeSetScanParametersBuilder::Create( |
| le_scan_type_, interval_ms_, window_ms_, own_address_type_, filter_policy_), |
| module_handler_->BindOnceOn(this, &impl::on_set_scan_parameter_complete)); |
| break; |
| } |
| } |
| |
| void register_scanner(const Uuid app_uuid) { |
| for (uint8_t i = 1; i <= kMaxAppNum; i++) { |
| if (scanners_[i].in_use && scanners_[i].app_uuid == app_uuid) { |
| log::error("Application already registered {}", app_uuid.ToString()); |
| scanning_callbacks_->OnScannerRegistered(app_uuid, 0x00, ScanningCallback::ScanningStatus::INTERNAL_ERROR); |
| return; |
| } |
| } |
| |
| // valid value of scanner id : 1 ~ kMaxAppNum |
| for (uint8_t i = 1; i <= kMaxAppNum; i++) { |
| if (!scanners_[i].in_use) { |
| scanners_[i].app_uuid = app_uuid; |
| scanners_[i].in_use = true; |
| scanning_callbacks_->OnScannerRegistered(app_uuid, i, ScanningCallback::ScanningStatus::SUCCESS); |
| return; |
| } |
| } |
| |
| log::error("Unable to register scanner, max client reached:{}", kMaxAppNum); |
| scanning_callbacks_->OnScannerRegistered(app_uuid, 0x00, ScanningCallback::ScanningStatus::NO_RESOURCES); |
| } |
| |
| void unregister_scanner(ScannerId scanner_id) { |
| if (scanner_id <= 0 || scanner_id > kMaxAppNum) { |
| log::warn("Invalid scanner id"); |
| return; |
| } |
| |
| if (scanners_[scanner_id].in_use) { |
| scanners_[scanner_id].in_use = false; |
| scanners_[scanner_id].app_uuid = Uuid::kEmpty; |
| } else { |
| log::warn("Unregister scanner with unused scanner id"); |
| } |
| } |
| |
| void scan(bool start) { |
| // On-resume flag should always be reset if there is an explicit start/stop call. |
| scan_on_resume_ = false; |
| if (start) { |
| configure_scan(); |
| start_scan(); |
| } else { |
| if (address_manager_registered_) { |
| le_address_manager_->Unregister(this); |
| address_manager_registered_ = false; |
| paused_ = false; |
| } |
| stop_scan(); |
| } |
| } |
| |
| void start_scan() { |
| // If we receive start_scan during paused, set scan_on_resume_ to true |
| if (paused_ && address_manager_registered_) { |
| scan_on_resume_ = true; |
| return; |
| } |
| is_scanning_ = true; |
| if (!address_manager_registered_) { |
| le_address_manager_->Register(this); |
| address_manager_registered_ = true; |
| } |
| |
| switch (api_type_) { |
| case ScanApiType::EXTENDED: |
| le_scanning_interface_->EnqueueCommand( |
| LeSetExtendedScanEnableBuilder::Create( |
| Enable::ENABLED, |
| #if TARGET_FLOSS |
| FilterDuplicates::ENABLED /* filter duplicates */, |
| #else |
| FilterDuplicates::DISABLED /* filter duplicates */, |
| #endif |
| 0, |
| 0), |
| module_handler_->BindOnce(check_complete<LeSetExtendedScanEnableCompleteView>)); |
| break; |
| case ScanApiType::ANDROID_HCI: |
| case ScanApiType::LEGACY: |
| le_scanning_interface_->EnqueueCommand( |
| LeSetScanEnableBuilder::Create( |
| Enable::ENABLED, Enable::DISABLED /* filter duplicates */), |
| module_handler_->BindOnce(check_complete<LeSetScanEnableCompleteView>)); |
| break; |
| } |
| } |
| |
| void stop_scan() { |
| if (!is_scanning_) { |
| log::info("Scanning already stopped, return!"); |
| return; |
| } |
| is_scanning_ = false; |
| |
| switch (api_type_) { |
| case ScanApiType::EXTENDED: |
| le_scanning_interface_->EnqueueCommand( |
| LeSetExtendedScanEnableBuilder::Create( |
| Enable::DISABLED, |
| #if TARGET_FLOSS |
| FilterDuplicates::ENABLED /* filter duplicates */, |
| #else |
| FilterDuplicates::DISABLED /* filter duplicates */, |
| #endif |
| 0, |
| 0), |
| module_handler_->BindOnce(check_complete<LeSetExtendedScanEnableCompleteView>)); |
| break; |
| case ScanApiType::ANDROID_HCI: |
| case ScanApiType::LEGACY: |
| le_scanning_interface_->EnqueueCommand( |
| LeSetScanEnableBuilder::Create( |
| Enable::DISABLED, Enable::DISABLED /* filter duplicates */), |
| module_handler_->BindOnce(check_complete<LeSetScanEnableCompleteView>)); |
| break; |
| } |
| } |
| |
| void set_scan_parameters( |
| ScannerId scanner_id, |
| LeScanType scan_type, |
| uint16_t scan_interval, |
| uint16_t scan_window, |
| uint8_t scan_phy) { |
| uint32_t max_scan_interval = kLeScanIntervalMax; |
| uint32_t max_scan_window = kLeScanWindowMax; |
| if (api_type_ == ScanApiType::EXTENDED) { |
| max_scan_interval = kLeExtendedScanIntervalMax; |
| max_scan_window = kLeExtendedScanWindowMax; |
| } |
| |
| if (scan_type != LeScanType::ACTIVE && scan_type != LeScanType::PASSIVE) { |
| log::error("Invalid scan type"); |
| scanning_callbacks_->OnSetScannerParameterComplete( |
| scanner_id, ScanningCallback::ScanningStatus::ILLEGAL_PARAMETER); |
| return; |
| } |
| if (scan_interval > max_scan_interval || scan_interval < kLeScanIntervalMin) { |
| log::error("Invalid scan_interval {}", scan_interval); |
| scanning_callbacks_->OnSetScannerParameterComplete( |
| scanner_id, ScanningCallback::ScanningStatus::ILLEGAL_PARAMETER); |
| return; |
| } |
| if (scan_window > max_scan_window || scan_window < kLeScanWindowMin) { |
| log::error("Invalid scan_window {}", scan_window); |
| scanning_callbacks_->OnSetScannerParameterComplete( |
| scanner_id, ScanningCallback::ScanningStatus::ILLEGAL_PARAMETER); |
| return; |
| } |
| le_scan_type_ = scan_type; |
| interval_ms_ = scan_interval; |
| window_ms_ = scan_window; |
| if (com::android::bluetooth::flags::phy_to_native()) phy_ = scan_phy; |
| scanning_callbacks_->OnSetScannerParameterComplete(scanner_id, ScanningCallback::SUCCESS); |
| } |
| |
| void set_scan_filter_policy(LeScanningFilterPolicy filter_policy) { |
| filter_policy_ = filter_policy; |
| } |
| |
| void scan_filter_enable(bool enable) { |
| if (!is_filter_supported_) { |
| log::warn("Advertising filter is not supported"); |
| return; |
| } |
| |
| Enable apcf_enable = enable ? Enable::ENABLED : Enable::DISABLED; |
| le_scanning_interface_->EnqueueCommand( |
| LeAdvFilterEnableBuilder::Create(apcf_enable), |
| module_handler_->BindOnceOn(this, &impl::on_advertising_filter_complete)); |
| } |
| |
| bool is_bonded(Address target_address) { |
| for (auto device : storage_module_->GetBondedDevices()) { |
| if (device.GetAddress() == target_address) { |
| log::debug("Addresses match!"); |
| return true; |
| } |
| } |
| log::debug("Addresse DON'Ts match!"); |
| return false; |
| } |
| |
| void scan_filter_parameter_setup( |
| ApcfAction action, uint8_t filter_index, AdvertisingFilterParameter advertising_filter_parameter) { |
| if (!is_filter_supported_) { |
| log::warn("Advertising filter is not supported"); |
| return; |
| } |
| |
| auto entry = remove_me_later_map_.find(filter_index); |
| switch (action) { |
| case ApcfAction::ADD: |
| le_scanning_interface_->EnqueueCommand( |
| LeAdvFilterAddFilteringParametersBuilder::Create( |
| filter_index, |
| advertising_filter_parameter.feature_selection, |
| advertising_filter_parameter.list_logic_type, |
| advertising_filter_parameter.filter_logic_type, |
| advertising_filter_parameter.rssi_high_thresh, |
| advertising_filter_parameter.delivery_mode, |
| advertising_filter_parameter.onfound_timeout, |
| advertising_filter_parameter.onfound_timeout_cnt, |
| advertising_filter_parameter.rssi_low_thresh, |
| advertising_filter_parameter.onlost_timeout, |
| advertising_filter_parameter.num_of_tracking_entries), |
| module_handler_->BindOnceOn(this, &impl::on_advertising_filter_complete)); |
| break; |
| case ApcfAction::DELETE: |
| tracker_id_map_.erase(filter_index); |
| le_scanning_interface_->EnqueueCommand( |
| LeAdvFilterDeleteFilteringParametersBuilder::Create(filter_index), |
| module_handler_->BindOnceOn(this, &impl::on_advertising_filter_complete)); |
| |
| // IRK Scanning |
| if (entry != remove_me_later_map_.end()) { |
| // Don't want to remove for a bonded device |
| if (!is_bonded(entry->second.GetAddress())) { |
| le_address_manager_->RemoveDeviceFromResolvingList( |
| static_cast<PeerAddressType>(entry->second.GetAddressType()), entry->second.GetAddress()); |
| } |
| remove_me_later_map_.erase(filter_index); |
| } |
| |
| break; |
| case ApcfAction::CLEAR: |
| le_scanning_interface_->EnqueueCommand( |
| LeAdvFilterClearFilteringParametersBuilder::Create(), |
| module_handler_->BindOnceOn(this, &impl::on_advertising_filter_complete)); |
| |
| // IRK Scanning |
| if (entry != remove_me_later_map_.end()) { |
| // Don't want to remove for a bonded device |
| if (!is_bonded(entry->second.GetAddress())) { |
| le_address_manager_->RemoveDeviceFromResolvingList( |
| static_cast<PeerAddressType>(entry->second.GetAddressType()), entry->second.GetAddress()); |
| } |
| remove_me_later_map_.erase(filter_index); |
| } |
| |
| break; |
| default: |
| log::error("Unknown action type: {}", (uint16_t)action); |
| break; |
| } |
| } |
| |
| void scan_filter_add(uint8_t filter_index, std::vector<AdvertisingPacketContentFilterCommand> filters) { |
| if (!is_filter_supported_) { |
| log::warn("Advertising filter is not supported"); |
| return; |
| } |
| |
| ApcfAction apcf_action = ApcfAction::ADD; |
| for (auto filter : filters) { |
| /* If data is passed, both mask and data have to be the same length */ |
| if (filter.data.size() != filter.data_mask.size() && filter.data.size() != 0 && filter.data_mask.size() != 0) { |
| log::error("data and data_mask are of different size"); |
| continue; |
| } |
| |
| switch (filter.filter_type) { |
| case ApcfFilterType::BROADCASTER_ADDRESS: { |
| update_address_filter(apcf_action, filter_index, filter.address, filter.application_address_type, filter.irk); |
| break; |
| } |
| case ApcfFilterType::SERVICE_UUID: |
| case ApcfFilterType::SERVICE_SOLICITATION_UUID: { |
| update_uuid_filter(apcf_action, filter_index, filter.filter_type, filter.uuid, filter.uuid_mask); |
| break; |
| } |
| case ApcfFilterType::LOCAL_NAME: { |
| update_local_name_filter(apcf_action, filter_index, filter.name); |
| break; |
| } |
| case ApcfFilterType::MANUFACTURER_DATA: { |
| update_manufacturer_data_filter( |
| apcf_action, filter_index, filter.company, filter.company_mask, filter.data, filter.data_mask); |
| break; |
| } |
| case ApcfFilterType::SERVICE_DATA: { |
| update_service_data_filter(apcf_action, filter_index, filter.data, filter.data_mask); |
| break; |
| } |
| case ApcfFilterType::TRANSPORT_DISCOVERY_DATA: { |
| update_transport_discovery_data_filter( |
| apcf_action, |
| filter_index, |
| filter.org_id, |
| filter.tds_flags, |
| filter.tds_flags_mask, |
| filter.data, |
| filter.data_mask, |
| filter.meta_data_type, |
| filter.meta_data); |
| break; |
| } |
| case ApcfFilterType::AD_TYPE: { |
| update_ad_type_filter(apcf_action, filter_index, filter.ad_type, filter.data, filter.data_mask); |
| break; |
| } |
| default: |
| log::error("Unknown filter type: {}", (uint16_t)filter.filter_type); |
| break; |
| } |
| } |
| } |
| |
| std::unordered_map<uint8_t, AddressWithType> remove_me_later_map_; |
| |
| void update_address_filter( |
| ApcfAction action, |
| uint8_t filter_index, |
| Address address, |
| ApcfApplicationAddressType address_type, |
| std::array<uint8_t, 16> irk) { |
| if (action != ApcfAction::CLEAR) { |
| /* |
| * The vendor command (APCF Filtering 0x0157) takes Public (0) or Random (1) |
| * or Addresses type not applicable (2). |
| * |
| * Advertising results have four types: |
| *  - Public = 0 |
| *  - Random = 1 |
| *  - Public ID = 2 |
| *  - Random ID = 3 |
| * |
| * e.g. specifying PUBLIC (0) will only return results with a public |
| * address. It will ignore resolved addresses, since they return PUBLIC |
| * IDENTITY (2). For this, Addresses type not applicable (0x02) must be specified. |
| * This should also cover if the RPA is derived from RANDOM STATIC. |
| */ |
| le_scanning_interface_->EnqueueCommand( |
| LeAdvFilterBroadcasterAddressBuilder::Create( |
| action, filter_index, address, ApcfApplicationAddressType::NOT_APPLICABLE), |
| module_handler_->BindOnceOn(this, &impl::on_advertising_filter_complete)); |
| if (!is_empty_128bit(irk)) { |
| // If an entry exists for this filter index, replace data because the filter has been |
| // updated. |
| auto entry = remove_me_later_map_.find(filter_index); |
| // IRK Scanning |
| if (entry != remove_me_later_map_.end()) { |
| // Don't want to remove for a bonded device |
| if (!is_bonded(entry->second.GetAddress())) { |
| le_address_manager_->RemoveDeviceFromResolvingList( |
| static_cast<PeerAddressType>(entry->second.GetAddressType()), entry->second.GetAddress()); |
| } |
| remove_me_later_map_.erase(filter_index); |
| } |
| |
| // Now replace it with a new one |
| std::array<uint8_t, 16> empty_irk; |
| le_address_manager_->AddDeviceToResolvingList( |
| static_cast<PeerAddressType>(address_type), address, irk, empty_irk); |
| remove_me_later_map_.emplace(filter_index, AddressWithType(address, static_cast<AddressType>(address_type))); |
| } |
| } else { |
| le_scanning_interface_->EnqueueCommand( |
| LeAdvFilterClearBroadcasterAddressBuilder::Create(filter_index), |
| module_handler_->BindOnceOn(this, &impl::on_advertising_filter_complete)); |
| auto entry = remove_me_later_map_.find(filter_index); |
| if (entry != remove_me_later_map_.end()) { |
| // TODO(optedoblivion): If not bonded |
| le_address_manager_->RemoveDeviceFromResolvingList(static_cast<PeerAddressType>(address_type), address); |
| remove_me_later_map_.erase(filter_index); |
| } |
| } |
| } |
| |
| bool is_empty_128bit(const std::array<uint8_t, 16> data) { |
| for (int i = 0; i < 16; i++) { |
| if (data[i] != (uint8_t)0) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| void update_uuid_filter( |
| ApcfAction action, uint8_t filter_index, ApcfFilterType filter_type, Uuid uuid, Uuid uuid_mask) { |
| std::vector<uint8_t> combined_data = {}; |
| if (action != ApcfAction::CLEAR) { |
| uint8_t uuid_len = uuid.GetShortestRepresentationSize(); |
| if (uuid_len == Uuid::kNumBytes16) { |
| uint16_t data = uuid.As16Bit(); |
| combined_data.push_back((uint8_t)data); |
| combined_data.push_back((uint8_t)(data >> 8)); |
| } else if (uuid_len == Uuid::kNumBytes32) { |
| uint32_t data = uuid.As32Bit(); |
| combined_data.push_back((uint8_t)data); |
| combined_data.push_back((uint8_t)(data >> 8)); |
| combined_data.push_back((uint8_t)(data >> 16)); |
| combined_data.push_back((uint8_t)(data >> 24)); |
| } else if (uuid_len == Uuid::kNumBytes128) { |
| auto data = uuid.To128BitLE(); |
| combined_data.insert(combined_data.end(), data.begin(), data.end()); |
| } else { |
| log::error("illegal UUID length: {}", (uint16_t)uuid_len); |
| return; |
| } |
| |
| if (!uuid_mask.IsEmpty()) { |
| if (uuid_len == Uuid::kNumBytes16) { |
| uint16_t data = uuid_mask.As16Bit(); |
| combined_data.push_back((uint8_t)data); |
| combined_data.push_back((uint8_t)(data >> 8)); |
| } else if (uuid_len == Uuid::kNumBytes32) { |
| uint32_t data = uuid_mask.As32Bit(); |
| combined_data.push_back((uint8_t)data); |
| combined_data.push_back((uint8_t)(data >> 8)); |
| combined_data.push_back((uint8_t)(data >> 16)); |
| combined_data.push_back((uint8_t)(data >> 24)); |
| } else if (uuid_len == Uuid::kNumBytes128) { |
| auto data = uuid_mask.To128BitLE(); |
| combined_data.insert(combined_data.end(), data.begin(), data.end()); |
| } |
| } else { |
| std::vector<uint8_t> data(uuid_len, 0xFF); |
| combined_data.insert(combined_data.end(), data.begin(), data.end()); |
| } |
| } |
| |
| if (filter_type == ApcfFilterType::SERVICE_UUID) { |
| le_scanning_interface_->EnqueueCommand( |
| LeAdvFilterServiceUuidBuilder::Create(action, filter_index, combined_data), |
| module_handler_->BindOnceOn(this, &impl::on_advertising_filter_complete)); |
| } else { |
| le_scanning_interface_->EnqueueCommand( |
| LeAdvFilterSolicitationUuidBuilder::Create(action, filter_index, combined_data), |
| module_handler_->BindOnceOn(this, &impl::on_advertising_filter_complete)); |
| } |
| } |
| |
| void update_local_name_filter(ApcfAction action, uint8_t filter_index, std::vector<uint8_t> name) { |
| le_scanning_interface_->EnqueueCommand( |
| LeAdvFilterLocalNameBuilder::Create(action, filter_index, name), |
| module_handler_->BindOnceOn(this, &impl::on_advertising_filter_complete)); |
| } |
| |
| void update_manufacturer_data_filter( |
| ApcfAction action, |
| uint8_t filter_index, |
| uint16_t company_id, |
| uint16_t company_id_mask, |
| std::vector<uint8_t> data, |
| std::vector<uint8_t> data_mask) { |
| if (data.size() != data_mask.size()) { |
| log::error("manufacturer data mask should have the same length as manufacturer data"); |
| return; |
| } |
| std::vector<uint8_t> combined_data = {}; |
| if (action != ApcfAction::CLEAR) { |
| combined_data.push_back((uint8_t)company_id); |
| combined_data.push_back((uint8_t)(company_id >> 8)); |
| if (data.size() != 0) { |
| combined_data.insert(combined_data.end(), data.begin(), data.end()); |
| } |
| if (company_id_mask != 0) { |
| combined_data.push_back((uint8_t)company_id_mask); |
| combined_data.push_back((uint8_t)(company_id_mask >> 8)); |
| } else { |
| combined_data.push_back(0xFF); |
| combined_data.push_back(0xFF); |
| } |
| if (data_mask.size() != 0) { |
| combined_data.insert(combined_data.end(), data_mask.begin(), data_mask.end()); |
| } |
| } |
| |
| le_scanning_interface_->EnqueueCommand( |
| LeAdvFilterManufacturerDataBuilder::Create(action, filter_index, combined_data), |
| module_handler_->BindOnceOn(this, &impl::on_advertising_filter_complete)); |
| } |
| |
| void update_service_data_filter( |
| ApcfAction action, uint8_t filter_index, std::vector<uint8_t> data, std::vector<uint8_t> data_mask) { |
| if (data.size() != data_mask.size()) { |
| log::error("service data mask should have the same length as service data"); |
| return; |
| } |
| std::vector<uint8_t> combined_data = {}; |
| if (action != ApcfAction::CLEAR && data.size() != 0) { |
| combined_data.insert(combined_data.end(), data.begin(), data.end()); |
| combined_data.insert(combined_data.end(), data_mask.begin(), data_mask.end()); |
| } |
| |
| le_scanning_interface_->EnqueueCommand( |
| LeAdvFilterServiceDataBuilder::Create(action, filter_index, combined_data), |
| module_handler_->BindOnceOn(this, &impl::on_advertising_filter_complete)); |
| } |
| |
| void update_transport_discovery_data_filter( |
| ApcfAction action, |
| uint8_t filter_index, |
| uint8_t org_id, |
| uint8_t tds_flags, |
| uint8_t tds_flags_mask, |
| std::vector<uint8_t> transport_data, |
| std::vector<uint8_t> transport_data_mask, |
| ApcfMetaDataType meta_data_type, |
| std::vector<uint8_t> meta_data) { |
| LocalVersionInformation local_version_information = controller_->GetLocalVersionInformation(); |
| |
| // In QTI controller, transport discovery data filter are supported by default. Check is added |
| // to keep backward compatibility. |
| if (!is_transport_discovery_data_filter_supported_ && |
| !(local_version_information.manufacturer_name_ == LMP_COMPID_QTI)) { |
| log::warn("transport discovery data filter isn't supported"); |
| return; |
| } |
| |
| log::info( |
| "org id: {}, tds_flags: {}, tds_flags_mask: {}, transport_data size: {}, " |
| "transport_data_mask size: {}, meta_data_type: {}, meta_data size: {}", |
| org_id, |
| tds_flags, |
| tds_flags_mask, |
| transport_data.size(), |
| transport_data_mask.size(), |
| (uint8_t)meta_data_type, |
| meta_data.size()); |
| |
| // 0x02 Wi-Fi Alliance Neighbor Awareness Networking & meta_data_type is 0x01 for NAN Hash. |
| if (org_id == 0x02) { |
| // meta data contains WIFI NAN hash, reverse it before sending controller. |
| switch (meta_data_type) { |
| case ApcfMetaDataType::WIFI_NAN_HASH: |
| std::reverse(meta_data.begin(), meta_data.end()); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| if (is_transport_discovery_data_filter_supported_) { |
| le_scanning_interface_->EnqueueCommand( |
| LeAdvFilterTransportDiscoveryDataBuilder::Create( |
| action, |
| filter_index, |
| org_id, |
| tds_flags, |
| tds_flags_mask, |
| transport_data, |
| transport_data_mask, |
| meta_data_type, |
| meta_data), |
| module_handler_->BindOnceOn(this, &impl::on_advertising_filter_complete)); |
| } else { |
| // In QTI controller, transport discovery data filter are supported by default. |
| // keeping old version for backward compatibility |
| std::vector<uint8_t> combined_data = {}; |
| if (action != ApcfAction::CLEAR) { |
| combined_data.push_back((uint8_t)org_id); |
| combined_data.push_back((uint8_t)tds_flags); |
| combined_data.push_back((uint8_t)tds_flags_mask); |
| if (org_id == 0x02 && meta_data_type == ApcfMetaDataType::WIFI_NAN_HASH) { |
| // meta data contains WIFI NAN hash |
| combined_data.insert(combined_data.end(), meta_data.begin(), meta_data.end()); |
| } |
| } |
| le_scanning_interface_->EnqueueCommand( |
| LeAdvFilterTransportDiscoveryDataOldBuilder::Create(action, filter_index, combined_data), |
| module_handler_->BindOnceOn(this, &impl::on_advertising_filter_complete)); |
| } |
| } |
| |
| void update_ad_type_filter( |
| ApcfAction action, |
| uint8_t filter_index, |
| uint8_t ad_type, |
| std::vector<uint8_t> data, |
| std::vector<uint8_t> data_mask) { |
| if (!is_ad_type_filter_supported_) { |
| log::error("AD type filter isn't supported"); |
| return; |
| } |
| |
| if (data.size() != data_mask.size()) { |
| log::error("ad type mask should have the same length as ad type data"); |
| return; |
| } |
| std::vector<uint8_t> combined_data = {}; |
| if (action != ApcfAction::CLEAR) { |
| combined_data.push_back((uint8_t)ad_type); |
| combined_data.push_back((uint8_t)(data.size())); |
| if (data.size() != 0) { |
| combined_data.insert(combined_data.end(), data.begin(), data.end()); |
| combined_data.insert(combined_data.end(), data_mask.begin(), data_mask.end()); |
| } |
| } |
| |
| le_scanning_interface_->EnqueueCommand( |
| LeAdvFilterADTypeBuilder::Create(action, filter_index, combined_data), |
| module_handler_->BindOnceOn(this, &impl::on_advertising_filter_complete)); |
| } |
| |
| void batch_scan_set_storage_parameter( |
| uint8_t batch_scan_full_max, |
| uint8_t batch_scan_truncated_max, |
| uint8_t batch_scan_notify_threshold, |
| ScannerId scanner_id) { |
| if (!is_batch_scan_supported_) { |
| log::warn("Batch scan is not supported"); |
| return; |
| } |
| // scanner id for OnBatchScanThresholdCrossed |
| batch_scan_config_.ref_value = scanner_id; |
| |
| if (batch_scan_config_.current_state == BatchScanState::ERROR_STATE || |
| batch_scan_config_.current_state == BatchScanState::DISABLED_STATE || |
| batch_scan_config_.current_state == BatchScanState::DISABLE_CALLED) { |
| batch_scan_config_.current_state = BatchScanState::ENABLE_CALLED; |
| le_scanning_interface_->EnqueueCommand( |
| LeBatchScanEnableBuilder::Create(Enable::ENABLED), |
| module_handler_->BindOnceOn(this, &impl::on_batch_scan_enable_complete)); |
| } |
| |
| le_scanning_interface_->EnqueueCommand( |
| LeBatchScanSetStorageParametersBuilder::Create( |
| batch_scan_full_max, batch_scan_truncated_max, batch_scan_notify_threshold), |
| module_handler_->BindOnceOn(this, &impl::on_batch_scan_complete)); |
| } |
| |
| void batch_scan_enable( |
| BatchScanMode scan_mode, |
| uint32_t duty_cycle_scan_window_slots, |
| uint32_t duty_cycle_scan_interval_slots, |
| BatchScanDiscardRule batch_scan_discard_rule) { |
| if (!is_batch_scan_supported_) { |
| log::warn("Batch scan is not supported"); |
| return; |
| } |
| |
| if (batch_scan_config_.current_state == BatchScanState::ERROR_STATE || |
| batch_scan_config_.current_state == BatchScanState::DISABLED_STATE || |
| batch_scan_config_.current_state == BatchScanState::DISABLE_CALLED) { |
| batch_scan_config_.current_state = BatchScanState::ENABLE_CALLED; |
| le_scanning_interface_->EnqueueCommand( |
| LeBatchScanEnableBuilder::Create(Enable::ENABLED), |
| module_handler_->BindOnceOn(this, &impl::on_batch_scan_enable_complete)); |
| } |
| |
| batch_scan_config_.scan_mode = scan_mode; |
| batch_scan_config_.scan_interval = duty_cycle_scan_interval_slots; |
| batch_scan_config_.scan_window = duty_cycle_scan_window_slots; |
| batch_scan_config_.discard_rule = batch_scan_discard_rule; |
| /* This command starts batch scanning, if enabled */ |
| batch_scan_set_scan_parameter( |
| scan_mode, duty_cycle_scan_window_slots, duty_cycle_scan_interval_slots, batch_scan_discard_rule); |
| } |
| |
| void batch_scan_disable() { |
| if (!is_batch_scan_supported_) { |
| log::warn("Batch scan is not supported"); |
| return; |
| } |
| batch_scan_config_.current_state = BatchScanState::DISABLE_CALLED; |
| batch_scan_set_scan_parameter( |
| BatchScanMode::DISABLE, |
| batch_scan_config_.scan_window, |
| batch_scan_config_.scan_interval, |
| batch_scan_config_.discard_rule); |
| } |
| |
| void batch_scan_set_scan_parameter( |
| BatchScanMode scan_mode, |
| uint32_t duty_cycle_scan_window_slots, |
| uint32_t duty_cycle_scan_interval_slots, |
| BatchScanDiscardRule batch_scan_discard_rule) { |
| if (!is_batch_scan_supported_) { |
| log::warn("Batch scan is not supported"); |
| return; |
| } |
| PeerAddressType own_address_type = PeerAddressType::PUBLIC_DEVICE_OR_IDENTITY_ADDRESS; |
| if (own_address_type_ == OwnAddressType::RANDOM_DEVICE_ADDRESS || |
| own_address_type_ == OwnAddressType::RESOLVABLE_OR_RANDOM_ADDRESS) { |
| own_address_type = PeerAddressType::RANDOM_DEVICE_OR_IDENTITY_ADDRESS; |
| } |
| uint8_t truncated_mode_enabled = 0x00; |
| uint8_t full_mode_enabled = 0x00; |
| if (scan_mode == BatchScanMode::TRUNCATED || scan_mode == BatchScanMode::TRUNCATED_AND_FULL) { |
| truncated_mode_enabled = 0x01; |
| } |
| if (scan_mode == BatchScanMode::FULL || scan_mode == BatchScanMode::TRUNCATED_AND_FULL) { |
| full_mode_enabled = 0x01; |
| } |
| |
| if (scan_mode == BatchScanMode::DISABLE) { |
| le_scanning_interface_->EnqueueCommand( |
| LeBatchScanSetScanParametersBuilder::Create( |
| truncated_mode_enabled, |
| full_mode_enabled, |
| duty_cycle_scan_window_slots, |
| duty_cycle_scan_interval_slots, |
| own_address_type, |
| batch_scan_discard_rule), |
| module_handler_->BindOnceOn(this, &impl::on_batch_scan_disable_complete)); |
| } else { |
| le_scanning_interface_->EnqueueCommand( |
| LeBatchScanSetScanParametersBuilder::Create( |
| truncated_mode_enabled, |
| full_mode_enabled, |
| duty_cycle_scan_window_slots, |
| duty_cycle_scan_interval_slots, |
| own_address_type, |
| batch_scan_discard_rule), |
| module_handler_->BindOnceOn(this, &impl::on_batch_scan_complete)); |
| } |
| } |
| |
| void batch_scan_read_results(ScannerId scanner_id, uint16_t total_num_of_records, BatchScanMode scan_mode) { |
| if (!is_batch_scan_supported_) { |
| log::warn("Batch scan is not supported"); |
| int status = static_cast<int>(ErrorCode::UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE); |
| scanning_callbacks_->OnBatchScanReports(scanner_id, status, 0, 0, {}); |
| return; |
| } |
| |
| if (scan_mode != BatchScanMode::FULL && scan_mode != BatchScanMode::TRUNCATED) { |
| log::warn("Invalid scan mode {}", (uint16_t)scan_mode); |
| int status = static_cast<int>(ErrorCode::INVALID_HCI_COMMAND_PARAMETERS); |
| scanning_callbacks_->OnBatchScanReports(scanner_id, status, 0, 0, {}); |
| return; |
| } |
| |
| if (batch_scan_result_cache_.find(scanner_id) == batch_scan_result_cache_.end()) { |
| std::vector<uint8_t> empty_data = {}; |
| batch_scan_result_cache_.emplace(scanner_id, empty_data); |
| } |
| |
| le_scanning_interface_->EnqueueCommand( |
| LeBatchScanReadResultParametersBuilder::Create(static_cast<BatchScanDataRead>(scan_mode)), |
| module_handler_->BindOnceOn(this, &impl::on_batch_scan_read_result_complete, scanner_id, total_num_of_records)); |
| } |
| |
| void start_sync( |
| uint8_t sid, const AddressWithType& address_with_type, uint16_t skip, uint16_t timeout, int request_id) { |
| if (!is_periodic_advertising_sync_transfer_sender_supported_) { |
| log::warn("PAST sender not supported on this device"); |
| int status = static_cast<int>(ErrorCode::UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE); |
| scanning_callbacks_->OnPeriodicSyncStarted(request_id, status, -1, sid, address_with_type, 0, 0); |
| return; |
| } |
| PeriodicSyncStates request{ |
| .request_id = request_id, |
| .advertiser_sid = sid, |
| .address_with_type = address_with_type, |
| .sync_handle = 0, |
| .sync_state = PeriodicSyncState::PERIODIC_SYNC_STATE_IDLE, |
| }; |
| periodic_sync_manager_.StartSync(request, skip, timeout); |
| } |
| |
| void stop_sync(uint16_t handle) { |
| if (!is_periodic_advertising_sync_transfer_sender_supported_) { |
| log::warn("PAST sender not supported on this device"); |
| return; |
| } |
| periodic_sync_manager_.StopSync(handle); |
| } |
| |
| void cancel_create_sync(uint8_t sid, const Address& address) { |
| if (!is_periodic_advertising_sync_transfer_sender_supported_) { |
| log::warn("PAST sender not supported on this device"); |
| return; |
| } |
| periodic_sync_manager_.CancelCreateSync(sid, address); |
| } |
| |
| void transfer_sync( |
| const Address& address, |
| uint16_t connection_handle, |
| uint16_t service_data, |
| uint16_t sync_handle, |
| int pa_source) { |
| if (!is_periodic_advertising_sync_transfer_sender_supported_) { |
| log::warn("PAST sender not supported on this device"); |
| int status = static_cast<int>(ErrorCode::UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE); |
| scanning_callbacks_->OnPeriodicSyncTransferred(pa_source, status, address); |
| return; |
| } |
| if (connection_handle == 0xFFFF) { |
| log::error("[PAST]: Invalid connection handle or no LE ACL link"); |
| int status = static_cast<int>(ErrorCode::UNKNOWN_CONNECTION); |
| scanning_callbacks_->OnPeriodicSyncTransferred(pa_source, status, address); |
| return; |
| } |
| periodic_sync_manager_.TransferSync(address, service_data, sync_handle, pa_source, connection_handle); |
| } |
| |
| void transfer_set_info( |
| const Address& address, |
| uint16_t connection_handle, |
| uint16_t service_data, |
| uint8_t adv_handle, |
| int pa_source) { |
| if (!is_periodic_advertising_sync_transfer_sender_supported_) { |
| log::warn("PAST sender not supported on this device"); |
| int status = static_cast<int>(ErrorCode::UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE); |
| scanning_callbacks_->OnPeriodicSyncTransferred(pa_source, status, address); |
| return; |
| } |
| if (connection_handle == 0xFFFF) { |
| log::error("[PAST]:Invalid connection handle or no LE ACL link"); |
| int status = static_cast<int>(ErrorCode::UNKNOWN_CONNECTION); |
| scanning_callbacks_->OnPeriodicSyncTransferred(pa_source, status, address); |
| return; |
| } |
| periodic_sync_manager_.SyncSetInfo(address, service_data, adv_handle, pa_source, connection_handle); |
| } |
| |
| void sync_tx_parameters(const Address& address, uint8_t mode, uint16_t skip, uint16_t timeout, int reg_id) { |
| if (!is_periodic_advertising_sync_transfer_sender_supported_) { |
| log::warn("PAST sender not supported on this device"); |
| int status = static_cast<int>(ErrorCode::UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE); |
| AddressWithType address_with_type(address, AddressType::RANDOM_DEVICE_ADDRESS); |
| scanning_callbacks_->OnPeriodicSyncStarted(reg_id, status, -1, -1, address_with_type, 0, 0); |
| return; |
| } |
| periodic_sync_manager_.SyncTxParameters(address, mode, skip, timeout, reg_id); |
| } |
| |
| void track_advertiser(uint8_t filter_index, ScannerId scanner_id) { |
| if (total_num_of_advt_tracked_ <= 0) { |
| log::warn("advertisement tracking is not supported"); |
| AdvertisingFilterOnFoundOnLostInfo on_found_on_lost_info = {}; |
| on_found_on_lost_info.scanner_id = scanner_id; |
| on_found_on_lost_info.advertiser_info_present = AdvtInfoPresent::NO_ADVT_INFO_PRESENT; |
| scanning_callbacks_->OnTrackAdvFoundLost(on_found_on_lost_info); |
| return; |
| } else if (tracker_id_map_.size() >= total_num_of_advt_tracked_) { |
| AdvertisingFilterOnFoundOnLostInfo on_found_on_lost_info = {}; |
| on_found_on_lost_info.scanner_id = scanner_id; |
| on_found_on_lost_info.advertiser_info_present = AdvtInfoPresent::NO_ADVT_INFO_PRESENT; |
| scanning_callbacks_->OnTrackAdvFoundLost(on_found_on_lost_info); |
| return; |
| } |
| log::info( |
| "track_advertiser scanner_id {}, filter_index {}", |
| (uint16_t)scanner_id, |
| (uint16_t)filter_index); |
| tracker_id_map_[filter_index] = scanner_id; |
| } |
| |
| void register_scanning_callback(ScanningCallback* scanning_callbacks) { |
| scanning_callbacks_ = scanning_callbacks; |
| periodic_sync_manager_.SetScanningCallback(scanning_callbacks_); |
| } |
| |
| bool is_ad_type_filter_supported() { |
| return is_ad_type_filter_supported_; |
| } |
| |
| void on_set_scan_parameter_complete(CommandCompleteView view) { |
| switch (view.GetCommandOpCode()) { |
| case (OpCode::LE_SET_SCAN_PARAMETERS): { |
| auto status_view = LeSetScanParametersCompleteView::Create(view); |
| log::assert_that(status_view.IsValid(), "assert failed: status_view.IsValid()"); |
| if (status_view.GetStatus() != ErrorCode::SUCCESS) { |
| log::info( |
| "Receive set scan parameter complete with error code {}", |
| ErrorCodeText(status_view.GetStatus())); |
| } |
| } break; |
| case (OpCode::LE_EXTENDED_SCAN_PARAMS): { |
| auto status_view = LeExtendedScanParamsCompleteView::Create(view); |
| log::assert_that(status_view.IsValid(), "assert failed: status_view.IsValid()"); |
| if (status_view.GetStatus() != ErrorCode::SUCCESS) { |
| log::info( |
| "Receive extended scan parameter complete with error code {}", |
| ErrorCodeText(status_view.GetStatus())); |
| } |
| } break; |
| case (OpCode::LE_SET_EXTENDED_SCAN_PARAMETERS): { |
| auto status_view = LeSetExtendedScanParametersCompleteView::Create(view); |
| log::assert_that(status_view.IsValid(), "assert failed: status_view.IsValid()"); |
| if (status_view.GetStatus() != ErrorCode::SUCCESS) { |
| log::info( |
| "Receive set extended scan parameter complete with error code {}", |
| ErrorCodeText(status_view.GetStatus())); |
| } |
| } break; |
| default: |
| log::fatal("Unhandled event {}", OpCodeText(view.GetCommandOpCode())); |
| } |
| } |
| |
| void on_advertising_filter_complete(CommandCompleteView view) { |
| log::assert_that(view.IsValid(), "assert failed: view.IsValid()"); |
| auto status_view = LeAdvFilterCompleteView::Create(view); |
| log::assert_that(status_view.IsValid(), "assert failed: status_view.IsValid()"); |
| if (status_view.GetStatus() != ErrorCode::SUCCESS) { |
| log::info( |
| "Got a Command complete {}, status {}", |
| OpCodeText(view.GetCommandOpCode()), |
| ErrorCodeText(status_view.GetStatus())); |
| } |
| |
| ApcfOpcode apcf_opcode = status_view.GetApcfOpcode(); |
| switch (apcf_opcode) { |
| case ApcfOpcode::ENABLE: { |
| auto complete_view = LeAdvFilterEnableCompleteView::Create(status_view); |
| log::assert_that(complete_view.IsValid(), "assert failed: complete_view.IsValid()"); |
| scanning_callbacks_->OnFilterEnable(complete_view.GetApcfEnable(), (uint8_t)complete_view.GetStatus()); |
| } break; |
| case ApcfOpcode::SET_FILTERING_PARAMETERS: { |
| auto complete_view = LeAdvFilterSetFilteringParametersCompleteView::Create(status_view); |
| log::assert_that(complete_view.IsValid(), "assert failed: complete_view.IsValid()"); |
| scanning_callbacks_->OnFilterParamSetup( |
| complete_view.GetApcfAvailableSpaces(), complete_view.GetApcfAction(), (uint8_t)complete_view.GetStatus()); |
| } break; |
| case ApcfOpcode::BROADCASTER_ADDRESS: { |
| auto complete_view = LeAdvFilterBroadcasterAddressCompleteView::Create(status_view); |
| log::assert_that(complete_view.IsValid(), "assert failed: complete_view.IsValid()"); |
| scanning_callbacks_->OnFilterConfigCallback( |
| ApcfFilterType::BROADCASTER_ADDRESS, |
| complete_view.GetApcfAvailableSpaces(), |
| complete_view.GetApcfAction(), |
| (uint8_t)complete_view.GetStatus()); |
| } break; |
| case ApcfOpcode::SERVICE_UUID: { |
| auto complete_view = LeAdvFilterServiceUuidCompleteView::Create(status_view); |
| log::assert_that(complete_view.IsValid(), "assert failed: complete_view.IsValid()"); |
| scanning_callbacks_->OnFilterConfigCallback( |
| ApcfFilterType::SERVICE_UUID, |
| complete_view.GetApcfAvailableSpaces(), |
| complete_view.GetApcfAction(), |
| (uint8_t)complete_view.GetStatus()); |
| } break; |
| case ApcfOpcode::SERVICE_SOLICITATION_UUID: { |
| auto complete_view = LeAdvFilterSolicitationUuidCompleteView::Create(status_view); |
| log::assert_that(complete_view.IsValid(), "assert failed: complete_view.IsValid()"); |
| scanning_callbacks_->OnFilterConfigCallback( |
| ApcfFilterType::SERVICE_SOLICITATION_UUID, |
| complete_view.GetApcfAvailableSpaces(), |
| complete_view.GetApcfAction(), |
| (uint8_t)complete_view.GetStatus()); |
| } break; |
| case ApcfOpcode::LOCAL_NAME: { |
| auto complete_view = LeAdvFilterLocalNameCompleteView::Create(status_view); |
| log::assert_that(complete_view.IsValid(), "assert failed: complete_view.IsValid()"); |
| scanning_callbacks_->OnFilterConfigCallback( |
| ApcfFilterType::LOCAL_NAME, |
| complete_view.GetApcfAvailableSpaces(), |
| complete_view.GetApcfAction(), |
| (uint8_t)complete_view.GetStatus()); |
| } break; |
| case ApcfOpcode::MANUFACTURER_DATA: { |
| auto complete_view = LeAdvFilterManufacturerDataCompleteView::Create(status_view); |
| log::assert_that(complete_view.IsValid(), "assert failed: complete_view.IsValid()"); |
| scanning_callbacks_->OnFilterConfigCallback( |
| ApcfFilterType::MANUFACTURER_DATA, |
| complete_view.GetApcfAvailableSpaces(), |
| complete_view.GetApcfAction(), |
| (uint8_t)complete_view.GetStatus()); |
| } break; |
| case ApcfOpcode::SERVICE_DATA: { |
| auto complete_view = LeAdvFilterServiceDataCompleteView::Create(status_view); |
| log::assert_that(complete_view.IsValid(), "assert failed: complete_view.IsValid()"); |
| scanning_callbacks_->OnFilterConfigCallback( |
| ApcfFilterType::SERVICE_DATA, |
| complete_view.GetApcfAvailableSpaces(), |
| complete_view.GetApcfAction(), |
| (uint8_t)complete_view.GetStatus()); |
| } break; |
| case ApcfOpcode::TRANSPORT_DISCOVERY_DATA: { |
| auto complete_view = LeAdvFilterTransportDiscoveryDataCompleteView::Create(status_view); |
| log::assert_that(complete_view.IsValid(), "assert failed: complete_view.IsValid()"); |
| scanning_callbacks_->OnFilterConfigCallback( |
| ApcfFilterType::TRANSPORT_DISCOVERY_DATA, |
| complete_view.GetApcfAvailableSpaces(), |
| complete_view.GetApcfAction(), |
| (uint8_t)complete_view.GetStatus()); |
| } break; |
| case ApcfOpcode::AD_TYPE: { |
| auto complete_view = LeAdvFilterADTypeCompleteView::Create(status_view); |
| log::assert_that(complete_view.IsValid(), "assert failed: complete_view.IsValid()"); |
| scanning_callbacks_->OnFilterConfigCallback( |
| ApcfFilterType::AD_TYPE, |
| complete_view.GetApcfAvailableSpaces(), |
| complete_view.GetApcfAction(), |
| (uint8_t)complete_view.GetStatus()); |
| } break; |
| default: |
| log::warn("Unexpected event type {}", OpCodeText(view.GetCommandOpCode())); |
| } |
| } |
| |
| void on_apcf_read_extended_features_complete(CommandCompleteView view) { |
| log::assert_that(view.IsValid(), "assert failed: view.IsValid()"); |
| auto status_view = LeAdvFilterCompleteView::Create(view); |
| if (!status_view.IsValid()) { |
| log::warn("Can not get valid LeAdvFilterCompleteView, return"); |
| return; |
| } |
| if (status_view.GetStatus() != ErrorCode::SUCCESS) { |
| log::warn( |
| "Got a Command complete {}, status {}", |
| OpCodeText(view.GetCommandOpCode()), |
| ErrorCodeText(status_view.GetStatus())); |
| return; |
| } |
| auto complete_view = LeAdvFilterReadExtendedFeaturesCompleteView::Create(status_view); |
| log::assert_that(complete_view.IsValid(), "assert failed: complete_view.IsValid()"); |
| is_transport_discovery_data_filter_supported_ = |
| complete_view.GetTransportDiscoveryDataFilter() == 1; |
| is_ad_type_filter_supported_ = complete_view.GetAdTypeFilter() == 1; |
| log::info( |
| "set is_ad_type_filter_supported_ to {} & is_transport_discovery_data_filter_supported_ to " |
| "{}", |
| is_ad_type_filter_supported_, |
| is_transport_discovery_data_filter_supported_); |
| } |
| |
| void on_batch_scan_complete(CommandCompleteView view) { |
| log::assert_that(view.IsValid(), "assert failed: view.IsValid()"); |
| auto status_view = LeBatchScanCompleteView::Create(view); |
| log::assert_that(status_view.IsValid(), "assert failed: status_view.IsValid()"); |
| if (status_view.GetStatus() != ErrorCode::SUCCESS) { |
| log::info( |
| "Got a Command complete {}, status {}, batch_scan_opcode {}", |
| OpCodeText(view.GetCommandOpCode()), |
| ErrorCodeText(status_view.GetStatus()), |
| BatchScanOpcodeText(status_view.GetBatchScanOpcode())); |
| } |
| } |
| |
| void on_batch_scan_enable_complete(CommandCompleteView view) { |
| log::assert_that(view.IsValid(), "assert failed: view.IsValid()"); |
| auto status_view = LeBatchScanCompleteView::Create(view); |
| log::assert_that(status_view.IsValid(), "assert failed: status_view.IsValid()"); |
| auto complete_view = LeBatchScanEnableCompleteView::Create(status_view); |
| log::assert_that(complete_view.IsValid(), "assert failed: complete_view.IsValid()"); |
| if (status_view.GetStatus() != ErrorCode::SUCCESS) { |
| log::info( |
| "Got batch scan enable complete, status {}", ErrorCodeText(status_view.GetStatus())); |
| batch_scan_config_.current_state = BatchScanState::ERROR_STATE; |
| } else { |
| batch_scan_config_.current_state = BatchScanState::ENABLED_STATE; |
| } |
| } |
| |
| void on_batch_scan_disable_complete(CommandCompleteView view) { |
| log::assert_that(view.IsValid(), "assert failed: view.IsValid()"); |
| auto status_view = LeBatchScanCompleteView::Create(view); |
| log::assert_that(status_view.IsValid(), "assert failed: status_view.IsValid()"); |
| auto complete_view = LeBatchScanSetScanParametersCompleteView::Create(status_view); |
| log::assert_that(complete_view.IsValid(), "assert failed: complete_view.IsValid()"); |
| log::assert_that( |
| status_view.GetStatus() == ErrorCode::SUCCESS, |
| "assert failed: status_view.GetStatus() == ErrorCode::SUCCESS"); |
| batch_scan_config_.current_state = BatchScanState::DISABLED_STATE; |
| } |
| |
| void on_batch_scan_read_result_complete( |
| ScannerId scanner_id, uint16_t total_num_of_records, CommandCompleteView view) { |
| log::assert_that(view.IsValid(), "assert failed: view.IsValid()"); |
| auto status_view = LeBatchScanCompleteView::Create(view); |
| log::assert_that(status_view.IsValid(), "assert failed: status_view.IsValid()"); |
| auto complete_view = LeBatchScanReadResultParametersCompleteRawView::Create(status_view); |
| log::assert_that(complete_view.IsValid(), "assert failed: complete_view.IsValid()"); |
| if (complete_view.GetStatus() != ErrorCode::SUCCESS) { |
| log::info( |
| "Got batch scan read result complete, status {}", ErrorCodeText(status_view.GetStatus())); |
| } |
| uint8_t num_of_records = complete_view.GetNumOfRecords(); |
| auto report_format = complete_view.GetBatchScanDataRead(); |
| if (num_of_records == 0) { |
| scanning_callbacks_->OnBatchScanReports( |
| scanner_id, 0x00, (int)report_format, total_num_of_records, batch_scan_result_cache_[scanner_id]); |
| batch_scan_result_cache_.erase(scanner_id); |
| } else { |
| auto raw_data = complete_view.GetRawData(); |
| batch_scan_result_cache_[scanner_id].insert( |
| batch_scan_result_cache_[scanner_id].end(), raw_data.begin(), raw_data.end()); |
| total_num_of_records += num_of_records; |
| batch_scan_read_results(scanner_id, total_num_of_records, static_cast<BatchScanMode>(report_format)); |
| } |
| } |
| |
| void on_storage_threshold_breach(VendorSpecificEventView /* event */) { |
| if (batch_scan_config_.ref_value == kInvalidScannerId) { |
| log::warn("storage threshold was not set !!"); |
| return; |
| } |
| scanning_callbacks_->OnBatchScanThresholdCrossed(static_cast<int>(batch_scan_config_.ref_value)); |
| } |
| |
| void on_advertisement_tracking(VendorSpecificEventView event) { |
| auto view = LEAdvertisementTrackingEventView::Create(event); |
| log::assert_that(view.IsValid(), "assert failed: view.IsValid()"); |
| uint8_t filter_index = view.GetApcfFilterIndex(); |
| if (tracker_id_map_.find(filter_index) == tracker_id_map_.end()) { |
| log::warn("Advertisement track for filter_index {} is not register", (uint16_t)filter_index); |
| return; |
| } |
| AdvertisingFilterOnFoundOnLostInfo on_found_on_lost_info = {}; |
| on_found_on_lost_info.scanner_id = tracker_id_map_[filter_index]; |
| on_found_on_lost_info.filter_index = filter_index; |
| on_found_on_lost_info.advertiser_state = view.GetAdvertiserState(); |
| on_found_on_lost_info.advertiser_address = view.GetAdvertiserAddress(); |
| on_found_on_lost_info.advertiser_address_type = view.GetAdvertiserAddressType(); |
| on_found_on_lost_info.advertiser_info_present = view.GetAdvtInfoPresent(); |
| /* Extract the adv info details */ |
| if (on_found_on_lost_info.advertiser_info_present == AdvtInfoPresent::ADVT_INFO_PRESENT) { |
| auto info_view = LEAdvertisementTrackingWithInfoEventView::Create(view); |
| log::assert_that(info_view.IsValid(), "assert failed: info_view.IsValid()"); |
| on_found_on_lost_info.tx_power = info_view.GetTxPower(); |
| on_found_on_lost_info.rssi = info_view.GetRssi(); |
| on_found_on_lost_info.time_stamp = info_view.GetTimestamp(); |
| auto adv_data = info_view.GetAdvPacket(); |
| on_found_on_lost_info.adv_packet.reserve(adv_data.size()); |
| on_found_on_lost_info.adv_packet.insert(on_found_on_lost_info.adv_packet.end(), adv_data.begin(), adv_data.end()); |
| auto scan_rsp_data = info_view.GetScanResponse(); |
| on_found_on_lost_info.scan_response.reserve(scan_rsp_data.size()); |
| on_found_on_lost_info.scan_response.insert( |
| on_found_on_lost_info.scan_response.end(), scan_rsp_data.begin(), scan_rsp_data.end()); |
| } |
| scanning_callbacks_->OnTrackAdvFoundLost(on_found_on_lost_info); |
| } |
| |
| void OnPause() override { |
| if (!address_manager_registered_) { |
| log::warn("Unregistered!"); |
| return; |
| } |
| paused_ = true; |
| scan_on_resume_ = is_scanning_; |
| stop_scan(); |
| ack_pause(); |
| } |
| |
| void ack_pause() { |
| le_address_manager_->AckPause(this); |
| } |
| |
| void OnResume() override { |
| if (!address_manager_registered_) { |
| log::warn("Unregistered!"); |
| return; |
| } |
| paused_ = false; |
| if (scan_on_resume_ == true) { |
| scan_on_resume_ = false; |
| start_scan(); |
| } |
| le_address_manager_->AckResume(this); |
| } |
| |
| ScanApiType api_type_; |
| |
| Module* module_; |
| os::Handler* module_handler_; |
| HciLayer* hci_layer_; |
| Controller* controller_; |
| AclManager* acl_manager_; |
| VendorSpecificEventManager* vendor_specific_event_manager_; |
| storage::StorageModule* storage_module_; |
| LeScanningInterface* le_scanning_interface_; |
| LeAddressManager* le_address_manager_; |
| bool address_manager_registered_ = false; |
| NullScanningCallback null_scanning_callback_; |
| ScanningCallback* scanning_callbacks_ = &null_scanning_callback_; |
| PeriodicSyncManager periodic_sync_manager_{&null_scanning_callback_}; |
| std::vector<Scanner> scanners_; |
| bool is_scanning_ = false; |
| bool scan_on_resume_ = false; |
| bool paused_ = false; |
| LeScanningReassembler scanning_reassembler_; |
| bool is_filter_supported_ = false; |
| bool is_ad_type_filter_supported_ = false; |
| bool is_batch_scan_supported_ = false; |
| bool is_periodic_advertising_sync_transfer_sender_supported_ = false; |
| bool is_transport_discovery_data_filter_supported_ = false; |
| |
| LeScanType le_scan_type_ = LeScanType::ACTIVE; |
| uint32_t interval_ms_{1000}; |
| uint16_t window_ms_{1000}; |
| uint8_t phy_{(uint8_t)PhyType::LE_1M}; |
| OwnAddressType own_address_type_{OwnAddressType::PUBLIC_DEVICE_ADDRESS}; |
| LeScanningFilterPolicy filter_policy_{LeScanningFilterPolicy::ACCEPT_ALL}; |
| BatchScanConfig batch_scan_config_; |
| std::map<ScannerId, std::vector<uint8_t>> batch_scan_result_cache_; |
| std::unordered_map<uint8_t, ScannerId> tracker_id_map_; |
| uint16_t total_num_of_advt_tracked_ = 0x00; |
| int8_t le_rx_path_loss_comp_ = 0; |
| }; |
| |
| LeScanningManager::LeScanningManager() { |
| pimpl_ = std::make_unique<impl>(this); |
| } |
| |
| void LeScanningManager::ListDependencies(ModuleList* list) const { |
| list->add<HciLayer>(); |
| list->add<VendorSpecificEventManager>(); |
| list->add<Controller>(); |
| list->add<AclManager>(); |
| list->add<storage::StorageModule>(); |
| } |
| |
| void LeScanningManager::Start() { |
| pimpl_->start( |
| GetHandler(), |
| GetDependency<HciLayer>(), |
| GetDependency<Controller>(), |
| GetDependency<AclManager>(), |
| GetDependency<VendorSpecificEventManager>(), |
| GetDependency<storage::StorageModule>()); |
| } |
| |
| void LeScanningManager::Stop() { |
| pimpl_->stop(); |
| pimpl_.reset(); |
| } |
| |
| std::string LeScanningManager::ToString() const { |
| return "Le Scanning Manager"; |
| } |
| |
| void LeScanningManager::RegisterScanner(Uuid app_uuid) { |
| CallOn(pimpl_.get(), &impl::register_scanner, app_uuid); |
| } |
| |
| void LeScanningManager::Unregister(ScannerId scanner_id) { |
| CallOn(pimpl_.get(), &impl::unregister_scanner, scanner_id); |
| } |
| |
| void LeScanningManager::Scan(bool start) { |
| CallOn(pimpl_.get(), &impl::scan, start); |
| } |
| |
| void LeScanningManager::SetScanParameters( |
| ScannerId scanner_id, |
| LeScanType scan_type, |
| uint16_t scan_interval, |
| uint16_t scan_window, |
| uint8_t scan_phy) { |
| CallOn( |
| pimpl_.get(), |
| &impl::set_scan_parameters, |
| scanner_id, |
| scan_type, |
| scan_interval, |
| scan_window, |
| scan_phy); |
| } |
| |
| void LeScanningManager::SetScanFilterPolicy(LeScanningFilterPolicy filter_policy) { |
| CallOn(pimpl_.get(), &impl::set_scan_filter_policy, filter_policy); |
| } |
| |
| void LeScanningManager::ScanFilterEnable(bool enable) { |
| CallOn(pimpl_.get(), &impl::scan_filter_enable, enable); |
| } |
| |
| void LeScanningManager::ScanFilterParameterSetup( |
| ApcfAction action, uint8_t filter_index, AdvertisingFilterParameter advertising_filter_parameter) { |
| CallOn(pimpl_.get(), &impl::scan_filter_parameter_setup, action, filter_index, advertising_filter_parameter); |
| } |
| |
| void LeScanningManager::ScanFilterAdd( |
| uint8_t filter_index, std::vector<AdvertisingPacketContentFilterCommand> filters) { |
| CallOn(pimpl_.get(), &impl::scan_filter_add, filter_index, filters); |
| } |
| |
| void LeScanningManager::BatchScanConifgStorage( |
| uint8_t batch_scan_full_max, |
| uint8_t batch_scan_truncated_max, |
| uint8_t batch_scan_notify_threshold, |
| ScannerId scanner_id) { |
| CallOn( |
| pimpl_.get(), |
| &impl::batch_scan_set_storage_parameter, |
| batch_scan_full_max, |
| batch_scan_truncated_max, |
| batch_scan_notify_threshold, |
| scanner_id); |
| } |
| |
| void LeScanningManager::BatchScanEnable( |
| BatchScanMode scan_mode, |
| uint32_t duty_cycle_scan_window_slots, |
| uint32_t duty_cycle_scan_interval_slots, |
| BatchScanDiscardRule batch_scan_discard_rule) { |
| CallOn( |
| pimpl_.get(), |
| &impl::batch_scan_enable, |
| scan_mode, |
| duty_cycle_scan_window_slots, |
| duty_cycle_scan_interval_slots, |
| batch_scan_discard_rule); |
| } |
| |
| void LeScanningManager::BatchScanDisable() { |
| CallOn(pimpl_.get(), &impl::batch_scan_disable); |
| } |
| |
| void LeScanningManager::BatchScanReadReport(ScannerId scanner_id, BatchScanMode scan_mode) { |
| CallOn(pimpl_.get(), &impl::batch_scan_read_results, scanner_id, 0, scan_mode); |
| } |
| |
| void LeScanningManager::StartSync( |
| uint8_t sid, const AddressWithType& address_with_type, uint16_t skip, uint16_t timeout, int reg_id) { |
| CallOn(pimpl_.get(), &impl::start_sync, sid, address_with_type, skip, timeout, reg_id); |
| } |
| |
| void LeScanningManager::StopSync(uint16_t handle) { |
| CallOn(pimpl_.get(), &impl::stop_sync, handle); |
| } |
| |
| void LeScanningManager::CancelCreateSync(uint8_t sid, const Address& address) { |
| CallOn(pimpl_.get(), &impl::cancel_create_sync, sid, address); |
| } |
| |
| void LeScanningManager::TransferSync( |
| const Address& address, |
| uint16_t handle, |
| uint16_t service_data, |
| uint16_t sync_handle, |
| int pa_source) { |
| CallOn(pimpl_.get(), &impl::transfer_sync, address, handle, service_data, sync_handle, pa_source); |
| } |
| |
| void LeScanningManager::TransferSetInfo( |
| const Address& address, |
| uint16_t handle, |
| uint16_t service_data, |
| uint8_t adv_handle, |
| int pa_source) { |
| CallOn( |
| pimpl_.get(), &impl::transfer_set_info, address, handle, service_data, adv_handle, pa_source); |
| } |
| |
| void LeScanningManager::SyncTxParameters( |
| const Address& address, uint8_t mode, uint16_t skip, uint16_t timeout, int reg_id) { |
| CallOn(pimpl_.get(), &impl::sync_tx_parameters, address, mode, skip, timeout, reg_id); |
| } |
| |
| void LeScanningManager::TrackAdvertiser(uint8_t filter_index, ScannerId scanner_id) { |
| CallOn(pimpl_.get(), &impl::track_advertiser, filter_index, scanner_id); |
| } |
| |
| void LeScanningManager::RegisterScanningCallback(ScanningCallback* scanning_callback) { |
| CallOn(pimpl_.get(), &impl::register_scanning_callback, scanning_callback); |
| } |
| |
| bool LeScanningManager::IsAdTypeFilterSupported() const { |
| return pimpl_->is_ad_type_filter_supported(); |
| } |
| |
| } // namespace hci |
| } // namespace bluetooth |
