| // Copyright 2019 The Chromium OS Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "bluetooth/newblued/scan_manager.h" |
| |
| #include <algorithm> |
| #include <set> |
| #include <string> |
| #include <utility> |
| |
| #include "bluetooth/newblued/util.h" |
| #include <chromeos/dbus/service_constants.h> |
| |
| namespace bluetooth { |
| |
| ScanManager::ScanManager(Newblue* newblue, |
| DeviceInterfaceHandler* device_interface_handler, |
| ExportedInterface* adapter_interface) |
| : newblue_(newblue), |
| device_interface_handler_(device_interface_handler), |
| adapter_interface_(adapter_interface), |
| weak_ptr_factory_(this) { |
| CHECK(newblue_); |
| CHECK(device_interface_handler_); |
| |
| device_interface_handler_->AddDeviceObserver(this); |
| } |
| |
| ScanManager::~ScanManager() { |
| if (device_interface_handler_) |
| device_interface_handler_->RemoveDeviceObserver(this); |
| } |
| |
| void ScanManager::OnGattConnected(const std::string& device_address, |
| gatt_client_conn_t conn_id) { |
| VLOG(2) << __func__; |
| paired_devices_[device_address].is_connected = true; |
| UpdateBackgroundScan(); |
| } |
| |
| void ScanManager::OnGattDisconnected(const std::string& device_address, |
| gatt_client_conn_t conn_id, |
| bool is_disconnected_by_newblue) { |
| VLOG(2) << __func__; |
| paired_devices_[device_address].is_connected = false; |
| paired_devices_[device_address].is_disconnected_by_newblue = |
| is_disconnected_by_newblue; |
| UpdateBackgroundScan(); |
| } |
| |
| void ScanManager::OnDevicePaired(const std::string& device_address) { |
| VLOG(2) << __func__; |
| PairedDevice paired_device; |
| paired_devices_.emplace(device_address, paired_device); |
| UpdateBackgroundScan(); |
| } |
| |
| void ScanManager::OnDeviceUnpaired(const std::string& device_address) { |
| VLOG(2) << __func__; |
| paired_devices_.erase(device_address); |
| UpdateBackgroundScan(); |
| } |
| |
| bool ScanManager::SetFilter(const std::string client_id, |
| const brillo::VariantDictionary& filter) { |
| VLOG(2) << __func__; |
| |
| // If failed to parse the filter parameters return with false. |
| if (!ParseAndSaveFilter(client_id, filter)) |
| return false; |
| |
| // If the there is no scanning activity or the client has not requested a |
| // scan. Postpone the filter merging. |
| if (scan_state_ == ScanState::IDLE || |
| std::find(clients_.begin(), clients_.end(), client_id) == |
| clients_.end()) { |
| return true; |
| } |
| |
| MergeFilters(); |
| return true; |
| } |
| |
| bool ScanManager::ParseAndSaveFilter(const std::string client_id, |
| const brillo::VariantDictionary& filter) { |
| // Initialize the filter struct with minimum RSSI requirement, largest |
| // pathloss tolerance, and none UUIDs filters. |
| Filter parsing_filter{SHRT_MIN, USHRT_MAX, std::set<Uuid>()}; |
| |
| // When this method is called with no filter parameter, filter is removed. |
| if (filter.empty()) { |
| filters_[client_id] = Filter(); |
| VLOG(2) << "Filter removed for client: " << client_id; |
| return true; |
| } |
| |
| // Parse and save the filter parameters. |
| GetVariantValue<int16_t>(filter, "RSSI", &parsing_filter.rssi); |
| GetVariantValue<uint16_t>(filter, "Pathloss", &parsing_filter.pathloss); |
| GetVariantValue<std::set<Uuid>>(filter, "UUIDs", &parsing_filter.uuids); |
| filters_[client_id] = parsing_filter; |
| |
| VLOG(2) << "Scan Filter Parameters: |RSSI = " << parsing_filter.rssi |
| << "|Pathloss = " << parsing_filter.pathloss |
| << "|# of UUIDs = " << parsing_filter.uuids.size() << "|"; |
| |
| return true; |
| } |
| |
| void ScanManager::MergeFilters(void) { |
| VLOG(2) << __func__; |
| |
| // Check if there is any active clients. Set the master flag accordingly. |
| if (clients_.empty()) { |
| is_filtered_scan_ = false; |
| VLOG(2) << "Filter Scan: is_filtered_scan_ = " << is_filtered_scan_; |
| return; |
| } |
| // Initialize the filter struct with maximum RSSI requirement, smallest |
| // pathloss tolerance, and none UUIDs filters. |
| Filter merged_filter{SHRT_MAX, 0, std::set<Uuid>()}; |
| bool is_filter_by_uuid = true; |
| |
| for (auto item : filters_) { |
| // If the client, who own this filter has not requested a scan. Do not |
| // merge this filter. |
| if (std::find(clients_.begin(), clients_.end(), item.first) == |
| clients_.end()) { |
| continue; |
| } |
| |
| // Choose the lower rssi and higher pathloss value. |
| if (item.second.rssi < merged_filter.rssi) |
| merged_filter.rssi = item.second.rssi; |
| if (item.second.pathloss > merged_filter.pathloss) |
| merged_filter.pathloss = item.second.pathloss; |
| |
| // If client passed uuid parameter with no list entry, disable uuid |
| // filtering, allow all to pass. |
| if (is_filter_by_uuid) { |
| if (item.second.uuids.size() == 0) { |
| is_filter_by_uuid = false; |
| merged_filter.uuids.clear(); |
| continue; |
| } |
| // Insert the UUID into merged filter UUID list and check for duplicates. |
| for (auto uuid : item.second.uuids) { |
| merged_filter.uuids.insert(uuid); |
| } |
| } |
| } |
| |
| merged_filter_ = merged_filter; |
| is_filtered_scan_ = merged_filter_.rssi != SHRT_MIN || |
| merged_filter_.pathloss != USHRT_MAX || is_filter_by_uuid; |
| |
| VLOG(2) << "Merged Filter Parameters: |is_filtered_scan = " |
| << is_filtered_scan_ << "|RSSI = " << merged_filter_.rssi |
| << "|Pathloss = " << merged_filter_.pathloss |
| << "|# of UUIDs = " << merged_filter_.uuids.size() << "|"; |
| } |
| |
| bool ScanManager::IsFilterMatch(const DeviceInfo& device_info) const { |
| VLOG(2) << __func__; |
| |
| if (!is_filtered_scan_) |
| return true; |
| if (device_info.rssi < merged_filter_.rssi && |
| device_info.tx_power - device_info.rssi > merged_filter_.pathloss) |
| return false; |
| if (merged_filter_.uuids.empty()) |
| return true; |
| for (auto uuid : merged_filter_.uuids) { |
| if (device_info.service_uuids.find(uuid) != device_info.service_uuids.end()) |
| return true; |
| } |
| return false; |
| } |
| |
| bool ScanManager::StartScan(std::string client_id) { |
| clients_.push_back(client_id); |
| // Create and initialize a new filter for the client if not exist yet. |
| if (!base::Contains(filters_, client_id)) |
| filters_[client_id] = Filter(); |
| MergeFilters(); |
| if (!UpdateScan()) { |
| clients_.pop_back(); |
| filters_.erase(client_id); |
| return false; |
| } |
| return true; |
| } |
| |
| bool ScanManager::StopScan(std::string client_id) { |
| clients_.erase(std::remove(clients_.begin(), clients_.end(), client_id), |
| clients_.end()); |
| MergeFilters(); |
| if (!UpdateScan()) { |
| clients_.push_back(client_id); |
| return false; |
| } |
| filters_.erase(client_id); |
| return true; |
| } |
| |
| bool ScanManager::UpdateScanSuspensionState(bool is_in_suspension) { |
| is_in_suspension_ = is_in_suspension; |
| if (!UpdateScan()) |
| return false; |
| |
| return true; |
| } |
| |
| bool ScanManager::UpdateScan(void) { |
| ScanState scan_state_new; |
| number_of_clients_ = clients_.size(); |
| |
| if (is_in_suspension_) { |
| // Stop scan if suspend is in progress. |
| scan_state_new = ScanState::IDLE; |
| } else if (number_of_clients_ > 0) { |
| // Start active scan if a client is requesting and system not in suspension. |
| scan_state_new = ScanState::ACTIVE_SCAN; |
| } else if (needs_background_scan_) { |
| // Check if background scan is needed. |
| scan_state_new = ScanState::PASSIVE_SCAN; |
| } else { |
| scan_state_new = ScanState::IDLE; |
| } |
| |
| if (scan_state_ == scan_state_new) { |
| VLOG(2) << "No need to change scan state"; |
| return true; |
| } |
| |
| VLOG(2) << "Scan Manager scan state change from: " << (uint8_t)scan_state_ |
| << " to: " << (uint8_t)scan_state_new; |
| |
| switch (scan_state_new) { |
| case ScanState::IDLE: |
| if (!newblue_->StopDiscovery()) |
| return false; |
| VLOG(1) << "Scan Manager: Stop scan."; |
| break; |
| case ScanState::ACTIVE_SCAN: |
| // If from passive scanning, stop it first then restart with active. |
| // settings. |
| if (scan_state_ == ScanState::PASSIVE_SCAN) { |
| if (!newblue_->StopDiscovery()) { |
| LOG(ERROR) << "Scan Manger received failed to stop discovery from " |
| "libnewblue."; |
| return false; |
| } |
| // Update state to IDLE in case start scan failed later. |
| scan_state_ = ScanState::IDLE; |
| } |
| |
| if (!newblue_->StartDiscovery( |
| profiles_["active-scan"].active, |
| profiles_["active-scan"].scan_interval, |
| profiles_["active-scan"].scan_window, |
| profiles_["active-scan"].use_randomAddr, |
| profiles_["active-scan"].only_whitelist, |
| profiles_["active-scan"].filter_duplicates, |
| base::Bind(&ScanManager::DeviceDiscoveryCallback, |
| weak_ptr_factory_.GetWeakPtr()))) { |
| LOG(ERROR) << "Scan Manger received failed to start discovery from " |
| "libnewblue."; |
| return false; |
| } |
| VLOG(1) << "Scan Manager: Start active scan."; |
| break; |
| case ScanState::PASSIVE_SCAN: |
| // If from active scanning, stop it first then restart with passive |
| // settings. |
| if (scan_state_ == ScanState::ACTIVE_SCAN) { |
| if (!newblue_->StopDiscovery()) { |
| LOG(ERROR) << "Scan Manger received failed to stop discovery from " |
| "libnewblue."; |
| return false; |
| } |
| // Update state to IDLE in case start scan failed later. |
| scan_state_ = ScanState::IDLE; |
| } |
| if (!newblue_->StartDiscovery( |
| profiles_["passive-scan"].active, |
| profiles_["passive-scan"].scan_interval, |
| profiles_["passive-scan"].scan_window, |
| profiles_["passive-scan"].use_randomAddr, |
| profiles_["passive-scan"].only_whitelist, |
| profiles_["passive-scan"].filter_duplicates, |
| base::Bind(&ScanManager::DeviceDiscoveryCallback, |
| weak_ptr_factory_.GetWeakPtr()))) { |
| LOG(ERROR) << "Scan Manger received failed to start discovery from " |
| "libnewblue."; |
| return false; |
| } |
| VLOG(1) << "Scan Manager: Start passive scan."; |
| break; |
| } |
| |
| scan_state_ = scan_state_new; |
| adapter_interface_ |
| ->EnsureExportedPropertyRegistered<bool>( |
| bluetooth_adapter::kDiscoveringProperty) |
| ->SetValue(scan_state_ == ScanState::ACTIVE_SCAN || |
| scan_state_ == ScanState::PASSIVE_SCAN); |
| |
| return true; |
| } |
| |
| void ScanManager::UpdateBackgroundScan() { |
| needs_background_scan_ = false; |
| // If a device is paired but not connected and is not disconnected |
| // intentionally by newblue, background scannning is needed. |
| for (const auto& kv : paired_devices_) { |
| if (!(kv.second.is_connected || kv.second.is_disconnected_by_newblue)) |
| needs_background_scan_ = true; |
| } |
| VLOG(2) << "Background scan needed: " |
| << (needs_background_scan_ ? "Yes" : "No"); |
| UpdateScan(); |
| } |
| |
| void ScanManager::DeviceDiscoveryCallback(const std::string& adv_address, |
| uint8_t address_type, |
| const std::string& resolved_address, |
| int8_t rssi, |
| uint8_t reply_type, |
| const std::vector<uint8_t>& eir) { |
| bool has_active_discovery_client = number_of_clients_ > 0; |
| DeviceInfo device_info(has_active_discovery_client, adv_address, address_type, |
| resolved_address, rssi, reply_type); |
| ParseEir(&device_info, eir); |
| if (IsFilterMatch(device_info)) |
| device_interface_handler_->OnDeviceDiscovered(device_info); |
| } |
| |
| } // namespace bluetooth |
