// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ash/quick_pair/scanning/fast_pair/fast_pair_scanner_impl.h"
#include "ash/constants/ash_features.h"
#include "ash/quick_pair/common/constants.h"
#include "ash/quick_pair/common/device.h"
#include "ash/quick_pair/common/fast_pair/fast_pair_metrics.h"
#include "ash/quick_pair/fast_pair_handshake/fast_pair_handshake.h"
#include "ash/quick_pair/fast_pair_handshake/fast_pair_handshake_lookup.h"
#include "base/containers/contains.h"
#include "base/functional/bind.h"
#include "base/task/sequenced_task_runner.h"
#include "base/time/time.h"
#include "components/cross_device/logging/logging.h"
#include "device/bluetooth/bluetooth_adapter_factory.h"
#include "device/bluetooth/bluetooth_low_energy_scan_filter.h"
namespace {
constexpr base::TimeDelta kFilterDeviceFoundTimeout = base::Seconds(1);
// We use a high value here for the time out because we want to give our E2E
// flow enough time to complete during it. We do this because the platform will
// consider the device 'lost' if it doesn't receive an advertisement within this
// timeframe, BUT the E2E pairing flow will cause the device to stop
// advertising (and therefore we can see false 'lost' events if this is too
// short).
constexpr base::TimeDelta kFilterDeviceLostTimeout = base::Seconds(40);
constexpr uint8_t kFilterPatternStartPosition = 0;
const std::vector<uint8_t> kFastPairFilterPatternValue = {0x2c, 0xfe};
constexpr base::TimeDelta kRssiSamplingPeriod = base::Milliseconds(500);
} // namespace
namespace ash {
namespace quick_pair {
std::ostream& operator<<(
std::ostream& out,
const device::BluetoothLowEnergyScanSession::ErrorCode& error_code) {
switch (error_code) {
case device::BluetoothLowEnergyScanSession::ErrorCode::kFailed:
out << "[Failed]";
break;
}
return out;
}
// static
FastPairScannerImpl::Factory* FastPairScannerImpl::Factory::g_test_factory_ =
nullptr;
// static
scoped_refptr<FastPairScanner> FastPairScannerImpl::Factory::Create() {
if (g_test_factory_) {
return g_test_factory_->CreateInstance();
}
return base::MakeRefCounted<FastPairScannerImpl>();
}
// static
void FastPairScannerImpl::Factory::SetFactoryForTesting(
Factory* g_test_factory) {
g_test_factory_ = g_test_factory;
}
FastPairScannerImpl::Factory::~Factory() = default;
FastPairScannerImpl::FastPairScannerImpl()
: task_runner_(base::SequencedTaskRunner::GetCurrentDefault()) {
device::BluetoothAdapterFactory::Get()->GetAdapter(base::BindOnce(
&FastPairScannerImpl::OnGetAdapter, weak_ptr_factory_.GetWeakPtr()));
}
FastPairScannerImpl::~FastPairScannerImpl() = default;
void FastPairScannerImpl::OnGetAdapter(
scoped_refptr<device::BluetoothAdapter> adapter) {
adapter_ = adapter;
adapter_observation_.Observe(adapter_.get());
task_runner_->PostTask(FROM_HERE,
base::BindOnce(&FastPairScannerImpl::StartScanning,
weak_ptr_factory_.GetWeakPtr()));
}
void FastPairScannerImpl::StartScanning() {
device::BluetoothLowEnergyScanFilter::Pattern pattern(
kFilterPatternStartPosition,
device::BluetoothLowEnergyScanFilter::AdvertisementDataType::kServiceData,
kFastPairFilterPatternValue);
auto filter = device::BluetoothLowEnergyScanFilter::Create(
device::BluetoothLowEnergyScanFilter::Range::kNear,
kFilterDeviceFoundTimeout, kFilterDeviceLostTimeout, {pattern},
kRssiSamplingPeriod);
RecordBluetoothLowEnergyScanFilterResult(/*success=*/filter != nullptr);
if (!filter) {
CD_LOG(ERROR, Feature::FP)
<< "Bluetooth Low Energy Scan Session failed to start due to "
"failure to create filter.";
return;
}
background_scan_session_ = adapter_->StartLowEnergyScanSession(
std::move(filter), weak_ptr_factory_.GetWeakPtr());
}
void FastPairScannerImpl::AddObserver(FastPairScanner::Observer* observer) {
observers_.AddObserver(observer);
}
void FastPairScannerImpl::RemoveObserver(FastPairScanner::Observer* observer) {
observers_.RemoveObserver(observer);
}
void FastPairScannerImpl::OnSessionStarted(
device::BluetoothLowEnergyScanSession* scan_session,
std::optional<device::BluetoothLowEnergyScanSession::ErrorCode>
error_code) {
RecordBluetoothLowEnergyScannerStartSessionResult(
/*success=*/!error_code.has_value());
if (error_code) {
CD_LOG(ERROR, Feature::FP)
<< "Bluetooth Low Energy Scan Session failed to start with "
"the following error: "
<< error_code.value();
return;
}
}
void FastPairScannerImpl::OnSessionInvalidated(
device::BluetoothLowEnergyScanSession* scan_session) {
// TODO(crbug.com/1227519) Handle Session Invalidation by adding exponential
// retry to restart the scanner.
background_scan_session_.reset();
}
void FastPairScannerImpl::OnDeviceFound(
device::BluetoothLowEnergyScanSession* scan_session,
device::BluetoothDevice* device) {
const std::vector<uint8_t>* service_data =
device->GetServiceDataForUUID(kFastPairBluetoothUuid);
if (!service_data) {
CD_LOG(WARNING, Feature::FP) << "No Fast Pair service data found on device";
return;
}
if (base::Contains(device_address_advertisement_data_map_,
device->GetAddress())) {
CD_LOG(INFO, Feature::FP)
<< __func__ << ": Ignoring found device because it was already found.";
return;
}
FastPairHandshake* handshake =
FastPairHandshakeLookup::GetInstance()->Get(device->GetAddress());
if (handshake) {
CD_LOG(INFO, Feature::FP)
<< __func__
<< ": We have an active handshake for this device, which "
"means we never 'lost' it. We ignore this event.";
return;
}
device_address_advertisement_data_map_[device->GetAddress()].insert(
*service_data);
NotifyDeviceFound(device);
}
void FastPairScannerImpl::DeviceChanged(device::BluetoothAdapter* adapter,
device::BluetoothDevice* device) {
std::string device_address = device->GetAddress();
const std::vector<uint8_t>* service_data =
device->GetServiceDataForUUID(kFastPairBluetoothUuid);
if (!service_data || service_data->empty())
return;
// If the advertisement data we have received does not pertain to a device
// we have seen already from the scanner, or if the advertisement data for
// a device we have already seen is not new, then early return and do not
// notify observers or add data to the device address advertisement data map.
if (!base::Contains(device_address_advertisement_data_map_, device_address) ||
base::Contains(device_address_advertisement_data_map_[device_address],
*service_data)) {
return;
}
// TODO(b/219600346): Handle Subsequent pair service data changing more
// robustly. During Subsequent pair, the service data can change during
// handshake--we can differentiate this from other pairing scenarios by
// checking that the service data is the same size. Don't notify observers in
// this case.
if (!device_address_advertisement_data_map_[device_address].empty() &&
(device_address_advertisement_data_map_[device_address]
.rbegin()
->size() == service_data->size())) {
device_address_advertisement_data_map_[device_address].insert(
*service_data);
return;
}
CD_LOG(INFO, Feature::FP) << __func__ << ": Notifying device found.";
device_address_advertisement_data_map_[device_address].insert(*service_data);
NotifyDeviceFound(device);
}
void FastPairScannerImpl::DeviceRemoved(device::BluetoothAdapter* adapter,
device::BluetoothDevice* device) {
device_address_advertisement_data_map_.erase(device->GetAddress());
}
void FastPairScannerImpl::DevicePairedChanged(device::BluetoothAdapter* adapter,
device::BluetoothDevice* device,
bool new_paired_status) {
device_address_advertisement_data_map_.erase(device->GetAddress());
}
void FastPairScannerImpl::NotifyDeviceFound(device::BluetoothDevice* device) {
auto it = ble_address_to_classic_.find(device->GetAddress());
if (it != ble_address_to_classic_.end()) {
device::BluetoothDevice* classic_device = adapter_->GetDevice(it->second);
if (classic_device && classic_device->IsPaired()) {
CD_LOG(INFO, Feature::FP)
<< __func__ << ": Skipping notify for already paired device.";
return;
}
}
for (auto& observer : observers_)
observer.OnDeviceFound(device);
}
void FastPairScannerImpl::OnDeviceLost(
device::BluetoothLowEnergyScanSession* scan_session,
device::BluetoothDevice* device) {
FastPairHandshakeLookup::GetInstance()->Erase(device->GetAddress());
device_address_advertisement_data_map_.erase(device->GetAddress());
for (auto& observer : observers_)
observer.OnDeviceLost(device);
}
void FastPairScannerImpl::OnDevicePaired(scoped_refptr<Device> device) {
CD_LOG(INFO, Feature::FP) << __func__ << ": device: " << device;
if (device->classic_address()) {
ble_address_to_classic_[device->ble_address()] =
device->classic_address().value();
}
}
} // namespace quick_pair
} // namespace ash
Codebase Browser
chromium