chromium/device/bluetooth/floss/floss_lescan_client.cc

// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "device/bluetooth/floss/floss_lescan_client.h"

#include <algorithm>
#include <map>

#include "base/containers/contains.h"
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/logging.h"
#include "base/observer_list.h"
#include "base/strings/string_number_conversions.h"
#include "dbus/bus.h"
#include "dbus/exported_object.h"
#include "dbus/message.h"
#include "dbus/object_proxy.h"
#include "device/bluetooth/floss/exported_callback_manager.h"
#include "device/bluetooth/floss/floss_dbus_client.h"

namespace floss {

const char kNoCallbackRegistered[] = …;

ScanFilterPattern::ScanFilterPattern() = default;
ScanFilterPattern::ScanFilterPattern(const ScanFilterPattern&) = default;
ScanFilterPattern::~ScanFilterPattern() = default;

ScanFilterCondition::ScanFilterCondition() = default;
ScanFilterCondition::ScanFilterCondition(const ScanFilterCondition&) = default;
ScanFilterCondition::~ScanFilterCondition() = default;

ScanFilter::ScanFilter() = default;
ScanFilter::ScanFilter(const ScanFilter&) = default;
ScanFilter::~ScanFilter() = default;

ScanResult::ScanResult() = default;
ScanResult::ScanResult(const ScanResult&) = default;
ScanResult::~ScanResult() = default;

std::unique_ptr<FlossLEScanClient> FlossLEScanClient::Create() { … }

FlossLEScanClient::FlossLEScanClient() = default;
FlossLEScanClient::~FlossLEScanClient() { … }

void FlossLEScanClient::Init(dbus::Bus* bus,
                             const std::string& service_name,
                             const int adapter_index,
                             base::Version version,
                             base::OnceClosure on_ready) { … }

void FlossLEScanClient::AddObserver(ScannerClientObserver* observer) { … }

void FlossLEScanClient::RemoveObserver(ScannerClientObserver* observer) { … }

void FlossLEScanClient::RegisterScannerCallback() { … }

void FlossLEScanClient::OnRegisterScannerCallback(DBusResult<uint32_t> ret) { … }

void FlossLEScanClient::OnUnregisterScannerCallback(DBusResult<bool> ret) { … }

void FlossLEScanClient::RegisterScanner(
    ResponseCallback<device::BluetoothUUID> callback) { … }

void FlossLEScanClient::UnregisterScanner(ResponseCallback<bool> callback,
                                          uint8_t scanner_id) { … }

void FlossLEScanClient::StartScan(
    ResponseCallback<BtifStatus> callback,
    uint8_t scanner_id,
    const std::optional<ScanSettings>& scan_settings,
    const std::optional<ScanFilter>& filter) { … }

void FlossLEScanClient::StopScan(ResponseCallback<BtifStatus> callback,
                                 uint8_t scanner_id) { … }

void FlossLEScanClient::ScannerRegistered(device::BluetoothUUID uuid,
                                          uint8_t scanner_id,
                                          GattStatus status) { … }

void FlossLEScanClient::ScanResultReceived(ScanResult scan_result) { … }

void FlossLEScanClient::AdvertisementFound(uint8_t scanner_id,
                                           ScanResult scan_result) { … }

void FlossLEScanClient::AdvertisementLost(uint8_t scanner_id,
                                          ScanResult scan_result) { … }

template <>
void FlossDBusClient::WriteDBusParam(dbus::MessageWriter* writer,
                                     const ScanSettings& data) { … }

template <>
void FlossDBusClient::WriteDBusParam(dbus::MessageWriter* writer,
                                     const ScanType& type) { … }

template <>
void FlossDBusClient::WriteDBusParam(dbus::MessageWriter* writer,
                                     const ScanFilterPattern& data) { … }

template <>
void FlossDBusClient::WriteDBusParam(dbus::MessageWriter* writer,
                                     const ScanFilterCondition& data) { … }

template <>
void FlossDBusClient::WriteDBusParam(dbus::MessageWriter* writer,
                                     const ScanFilter& data) { … }

template <>
bool FlossDBusClient::ReadDBusParam(dbus::MessageReader* reader,
                                    ScanResult* scan_result) { … }

template <>
const DBusTypeInfo& GetDBusTypeInfo(const ScanSettings*) { … }

template <>
const DBusTypeInfo& GetDBusTypeInfo(const ScanType*) { … }

template <>
const DBusTypeInfo& GetDBusTypeInfo(const ScanFilterPattern*) { … }

template <>
const DBusTypeInfo& GetDBusTypeInfo(const ScanFilterCondition*) { … }

template <>
const DBusTypeInfo& GetDBusTypeInfo(const ScanFilter*) { … }

template <>
const DBusTypeInfo& GetDBusTypeInfo(const ScanResult*) { … }

}  // namespace floss