bluetooth_discovery_filter.cc 5.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189
  1. // Copyright 2015 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "device/bluetooth/bluetooth_discovery_filter.h"
  5. #include <algorithm>
  6. #include <memory>
  7. #include "base/check.h"
  8. #include "base/memory/ptr_util.h"
  9. #include "device/bluetooth/bluetooth_common.h"
  10. namespace device {
  11. BluetoothDiscoveryFilter::BluetoothDiscoveryFilter() {
  12. SetTransport(BluetoothTransport::BLUETOOTH_TRANSPORT_DUAL);
  13. }
  14. BluetoothDiscoveryFilter::BluetoothDiscoveryFilter(
  15. BluetoothTransport transport) {
  16. SetTransport(transport);
  17. }
  18. BluetoothDiscoveryFilter::~BluetoothDiscoveryFilter() = default;
  19. BluetoothDiscoveryFilter::DeviceInfoFilter::DeviceInfoFilter() = default;
  20. BluetoothDiscoveryFilter::DeviceInfoFilter::DeviceInfoFilter(
  21. const DeviceInfoFilter& other) = default;
  22. BluetoothDiscoveryFilter::DeviceInfoFilter::~DeviceInfoFilter() = default;
  23. bool BluetoothDiscoveryFilter::DeviceInfoFilter::operator==(
  24. const BluetoothDiscoveryFilter::DeviceInfoFilter& other) const {
  25. return uuids == other.uuids && name == other.name;
  26. }
  27. bool BluetoothDiscoveryFilter::DeviceInfoFilter::operator<(
  28. const BluetoothDiscoveryFilter::DeviceInfoFilter& other) const {
  29. if (name == other.name)
  30. return uuids < other.uuids;
  31. return name < other.name;
  32. }
  33. bool BluetoothDiscoveryFilter::GetRSSI(int16_t* out_rssi) const {
  34. DCHECK(out_rssi);
  35. if (!rssi_)
  36. return false;
  37. *out_rssi = *rssi_;
  38. return true;
  39. }
  40. void BluetoothDiscoveryFilter::SetRSSI(int16_t rssi) {
  41. rssi_ = rssi;
  42. }
  43. bool BluetoothDiscoveryFilter::GetPathloss(uint16_t* out_pathloss) const {
  44. DCHECK(out_pathloss);
  45. if (!pathloss_)
  46. return false;
  47. *out_pathloss = *pathloss_;
  48. return true;
  49. }
  50. void BluetoothDiscoveryFilter::SetPathloss(uint16_t pathloss) {
  51. pathloss_ = pathloss;
  52. }
  53. BluetoothTransport BluetoothDiscoveryFilter::GetTransport() const {
  54. return transport_;
  55. }
  56. void BluetoothDiscoveryFilter::SetTransport(BluetoothTransport transport) {
  57. DCHECK(transport != BLUETOOTH_TRANSPORT_INVALID);
  58. transport_ = transport;
  59. }
  60. void BluetoothDiscoveryFilter::GetUUIDs(
  61. std::set<device::BluetoothUUID>& out_uuids) const {
  62. out_uuids.clear();
  63. for (const auto& device_filter : device_filters_) {
  64. for (const auto& uuid : device_filter.uuids) {
  65. out_uuids.insert(uuid);
  66. }
  67. }
  68. }
  69. void BluetoothDiscoveryFilter::AddDeviceFilter(
  70. const BluetoothDiscoveryFilter::DeviceInfoFilter& device_filter) {
  71. device_filters_.insert(device_filter);
  72. }
  73. const base::flat_set<BluetoothDiscoveryFilter::DeviceInfoFilter>*
  74. BluetoothDiscoveryFilter::GetDeviceFilters() const {
  75. return &device_filters_;
  76. }
  77. void BluetoothDiscoveryFilter::ClearDeviceFilters() {
  78. device_filters_.clear();
  79. }
  80. void BluetoothDiscoveryFilter::CopyFrom(
  81. const BluetoothDiscoveryFilter& filter) {
  82. transport_ = filter.transport_;
  83. device_filters_.clear();
  84. for (const auto& device_filter : filter.device_filters_)
  85. AddDeviceFilter(device_filter);
  86. rssi_ = filter.rssi_;
  87. pathloss_ = filter.pathloss_;
  88. }
  89. std::unique_ptr<device::BluetoothDiscoveryFilter>
  90. BluetoothDiscoveryFilter::Merge(
  91. const device::BluetoothDiscoveryFilter* filter_a,
  92. const device::BluetoothDiscoveryFilter* filter_b) {
  93. std::unique_ptr<BluetoothDiscoveryFilter> result;
  94. if (!filter_a && !filter_b) {
  95. return result;
  96. }
  97. result = std::make_unique<BluetoothDiscoveryFilter>(BLUETOOTH_TRANSPORT_DUAL);
  98. if (!filter_a || !filter_b || filter_a->IsDefault() ||
  99. filter_b->IsDefault()) {
  100. return result;
  101. }
  102. // both filters are not empty, so they must have transport set.
  103. result->SetTransport(static_cast<BluetoothTransport>(filter_a->transport_ |
  104. filter_b->transport_));
  105. // if both filters have uuids, them merge them. Otherwise uuids filter should
  106. // be left empty
  107. if (!filter_a->device_filters_.empty() &&
  108. !filter_b->device_filters_.empty()) {
  109. for (const auto& device_filter : filter_a->device_filters_)
  110. result->AddDeviceFilter(device_filter);
  111. for (const auto& device_filter : filter_b->device_filters_)
  112. result->AddDeviceFilter(device_filter);
  113. }
  114. if ((filter_a->rssi_ && filter_b->pathloss_) ||
  115. (filter_a->pathloss_ && filter_b->rssi_)) {
  116. // if both rssi and pathloss filtering is enabled in two different
  117. // filters, we can't tell which filter is more generic, and we don't set
  118. // proximity filtering on merged filter.
  119. return result;
  120. }
  121. if (filter_a->rssi_ && filter_b->rssi_) {
  122. result->SetRSSI(std::min(*filter_a->rssi_, *filter_b->rssi_));
  123. } else if (filter_a->pathloss_ && filter_b->pathloss_) {
  124. result->SetPathloss(std::max(*filter_a->pathloss_, *filter_b->pathloss_));
  125. }
  126. return result;
  127. }
  128. bool BluetoothDiscoveryFilter::Equals(
  129. const BluetoothDiscoveryFilter& other) const {
  130. if ((rssi_.has_value() != other.rssi_.has_value()) ||
  131. (rssi_ && other.rssi_ && *rssi_ != *other.rssi_))
  132. return false;
  133. if ((pathloss_.has_value() != other.pathloss_.has_value()) ||
  134. (pathloss_ && other.pathloss_ && *pathloss_ != *other.pathloss_)) {
  135. return false;
  136. }
  137. if (transport_ != other.transport_)
  138. return false;
  139. if (device_filters_ != other.device_filters_)
  140. return false;
  141. return true;
  142. }
  143. bool BluetoothDiscoveryFilter::IsDefault() const {
  144. return !(rssi_ || pathloss_ || !device_filters_.empty() ||
  145. transport_ != BLUETOOTH_TRANSPORT_DUAL);
  146. }
  147. } // namespace device