From: Chienyuan Date: Thu, 7 Jan 2021 13:22:03 +0000 (+0800) Subject: gd: Implement basic scan function X-Git-Url: http://git.osdn.net/view?a=commitdiff_plain;h=af86b3223c2b01fad433a0d5aa493c2d916206f5;p=android-x86%2Fsystem-bt.git gd: Implement basic scan function Tag: #refactor Bug: 169390539 Test: gd/cert/run --host Change-Id: Ifb4ea21a4cdab2d3587a9d5d4cf1255be536b231 --- diff --git a/gd/hci/hci_packets.pdl b/gd/hci/hci_packets.pdl index f88953249..b86a847a7 100644 --- a/gd/hci/hci_packets.pdl +++ b/gd/hci/hci_packets.pdl @@ -4618,8 +4618,7 @@ struct LeExtendedAdvertisingReport { address : Address, primary_phy : PrimaryPhyType, secondary_phy : SecondaryPhyType, - advertising_sid : 4, // SID subfield in the ADI field - _reserved_ : 4, + advertising_sid : 8, // SID subfield in the ADI field tx_power : 8, rssi : 8, // -127 to +20 (0x7F means not available) periodic_advertising_interval : 16, // 0x006 to 0xFFFF (7.5 ms to 82s) diff --git a/gd/hci/le_scanning_manager.cc b/gd/hci/le_scanning_manager.cc index d24becc29..5b58e5344 100644 --- a/gd/hci/le_scanning_manager.cc +++ b/gd/hci/le_scanning_manager.cc @@ -91,6 +91,7 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback case hci::SubeventCode::EXTENDED_ADVERTISING_REPORT: handle_advertising_report( LeExtendedAdvertisingReportView::Create(event)); + handle_extended_advertising_report(LeExtendedAdvertisingReportView::Create(event)); break; case hci::SubeventCode::SCAN_TIMEOUT: if (registered_callback_ != nullptr) { @@ -104,6 +105,40 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback } } + void handle_extended_advertising_report(LeExtendedAdvertisingReportView event_view) { + if (scanning_callbacks_ == nullptr) { + LOG_INFO("Dropping advertising event (no registered handler)"); + return; + } + if (!event_view.IsValid()) { + LOG_INFO("Dropping invalid advertising event"); + return; + } + std::vector reports = event_view.GetAdvertisingReports(); + if (reports.empty()) { + LOG_INFO("Zero results in advertising event"); + return; + } + + // TODO: handle AdvertisingCache for scan response + for (LeExtendedAdvertisingReport report : reports) { + uint16_t event_type = report.connectable_ | (report.scannable_ << 1) | (report.directed_ << 2) | + (report.scan_response_ << 3) | (report.legacy_ << 4) | ((uint16_t)report.data_status_ << 5); + + scanning_callbacks_->OnScanResult( + 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_); + } + } + template void handle_advertising_report(EventType event_view) { if (registered_callback_ == nullptr) { @@ -196,7 +231,52 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback } } - void start_scan(LeScanningManagerCallbacks* le_scanning_manager_callbacks) { + void scan(bool start) { + if (start) { + start_scan(); + } else { + stop_scan(); + } + } + + void start_scan() { + switch (api_type_) { + case ScanApiType::EXTENDED: + le_scanning_interface_->EnqueueCommand( + hci::LeSetExtendedScanEnableBuilder::Create( + Enable::ENABLED, FilterDuplicates::DISABLED /* filter duplicates */, 0, 0), + module_handler_->BindOnce(impl::check_status)); + break; + case ScanApiType::ANDROID_HCI: + case ScanApiType::LEGACY: + le_scanning_interface_->EnqueueCommand( + hci::LeSetScanEnableBuilder::Create(Enable::ENABLED, Enable::DISABLED /* filter duplicates */), + module_handler_->BindOnce(impl::check_status)); + break; + } + } + + void stop_scan() { + switch (api_type_) { + case ScanApiType::EXTENDED: + le_scanning_interface_->EnqueueCommand( + hci::LeSetExtendedScanEnableBuilder::Create( + Enable::DISABLED, FilterDuplicates::DISABLED /* filter duplicates */, 0, 0), + module_handler_->BindOnce(impl::check_status)); + registered_callback_ = nullptr; + break; + case ScanApiType::ANDROID_HCI: + case ScanApiType::LEGACY: + le_scanning_interface_->EnqueueCommand( + hci::LeSetScanEnableBuilder::Create(Enable::DISABLED, Enable::DISABLED /* filter duplicates */), + module_handler_->BindOnce(impl::check_status)); + registered_callback_ = nullptr; + break; + } + } + + // TODO remove + void start_scan_old(LeScanningManagerCallbacks* le_scanning_manager_callbacks) { registered_callback_ = le_scanning_manager_callbacks; if (!address_manager_registered) { @@ -226,7 +306,8 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback } } - void stop_scan(common::Callback on_stopped, bool from_on_pause) { + // TODO remove + void stop_scan_old(common::Callback on_stopped, bool from_on_pause) { if (address_manager_registered && !from_on_pause) { cached_registered_callback_ = nullptr; le_address_manager_->Unregister(this); @@ -260,7 +341,7 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback void OnPause() override { cached_registered_callback_ = registered_callback_; - stop_scan(common::Bind(&impl::ack_pause, common::Unretained(this)), true); + stop_scan_old(common::Bind(&impl::ack_pause, common::Unretained(this)), true); } void ack_pause() { @@ -271,7 +352,7 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback if (cached_registered_callback_ != nullptr) { auto cached_registered_callback = cached_registered_callback_; cached_registered_callback_ = nullptr; - start_scan(cached_registered_callback); + start_scan_old(cached_registered_callback); } le_address_manager_->AckResume(this); } @@ -359,12 +440,16 @@ 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::StartScan(LeScanningManagerCallbacks* callbacks) { - GetHandler()->Post(common::Bind(&impl::start_scan, common::Unretained(pimpl_.get()), callbacks)); + GetHandler()->Post(common::Bind(&impl::start_scan_old, common::Unretained(pimpl_.get()), callbacks)); } void LeScanningManager::StopScan(common::Callback on_stopped) { - GetHandler()->Post(common::Bind(&impl::stop_scan, common::Unretained(pimpl_.get()), on_stopped, false)); + GetHandler()->Post(common::Bind(&impl::stop_scan_old, common::Unretained(pimpl_.get()), on_stopped, false)); } void LeScanningManager::RegisterScanningCallback(ScanningCallback* scanning_callback) { diff --git a/gd/hci/le_scanning_manager.h b/gd/hci/le_scanning_manager.h index 33b981670..ab99fc536 100644 --- a/gd/hci/le_scanning_manager.h +++ b/gd/hci/le_scanning_manager.h @@ -49,15 +49,15 @@ class ScanningCallback { const bluetooth::hci::Uuid app_uuid, ScannerId scanner_id, ScanningStatus status) = 0; virtual void OnScanResult( uint16_t event_type, - uint8_t addr_type, - Address* bda, + 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_adv_int, - std::vector adv_data) = 0; + uint16_t periodic_advertising_interval, + std::vector advertising_data) = 0; virtual void OnTrackAdvFoundLost() = 0; virtual void OnBatchScanReports( int client_if, int status, int report_format, int num_records, std::vector data) = 0; @@ -72,6 +72,8 @@ class LeScanningManager : public bluetooth::Module { void Unregister(ScannerId scanner_id); + void Scan(bool start); + void StartScan(LeScanningManagerCallbacks* callbacks); void StopScan(common::Callback on_stopped); diff --git a/main/shim/le_scanning_manager.cc b/main/shim/le_scanning_manager.cc index 620b22148..d19d053bd 100644 --- a/main/shim/le_scanning_manager.cc +++ b/main/shim/le_scanning_manager.cc @@ -52,7 +52,10 @@ class BleScannerInterfaceImpl : public BleScannerInterface, } /** Start or stop LE device scanning */ - void Scan(bool start) { LOG(INFO) << __func__ << " in shim layer"; } + void Scan(bool start) { + LOG(INFO) << __func__ << " in shim layer"; + bluetooth::shim::GetScanning()->Scan(start); + } /** Setup scan filter params */ void ScanFilterParamSetup( @@ -134,11 +137,34 @@ class BleScannerInterfaceImpl : public BleScannerInterface, scanner_id, status)); }; - void OnScanResult(uint16_t event_type, uint8_t addr_type, - bluetooth::hci::Address* bda, uint8_t primary_phy, + void OnScanResult(uint16_t event_type, uint8_t address_type, + bluetooth::hci::Address address, uint8_t primary_phy, uint8_t secondary_phy, uint8_t advertising_sid, - int8_t tx_power, int8_t rssi, uint16_t periodic_adv_int, - std::vector adv_data){}; + int8_t tx_power, int8_t rssi, + uint16_t periodic_advertising_interval, + std::vector advertising_data) { + RawAddress raw_address; + RawAddress::FromString(address.ToString(), raw_address); + std::unique_ptr raw_address_ptr(new RawAddress(raw_address)); + + std::vector adv_data = {}; + for (auto gap_data : advertising_data) { + gap_data.size(); + adv_data.push_back((uint8_t)gap_data.size() - 1); + adv_data.push_back((uint8_t)gap_data.data_type_); + adv_data.insert(adv_data.end(), gap_data.data_.begin(), + gap_data.data_.end()); + } + + do_in_jni_thread( + FROM_HERE, + base::BindOnce(&ScanningCallbacks::OnScanResult, + base::Unretained(scanning_callbacks_), event_type, + address_type, raw_address_ptr.get(), primary_phy, + secondary_phy, advertising_sid, tx_power, rssi, + periodic_advertising_interval, adv_data)); + }; + void OnTrackAdvFoundLost(){}; void OnBatchScanReports(int client_if, int status, int report_format,