device/bluetooth/bluetooth_discovery_filter.cc

   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
   5 #include "device/bluetooth/bluetooth_discovery_filter.h"
   6
   7 namespace device {
   8
   9 BluetoothDiscoveryFilter::BluetoothDiscoveryFilter(TransportMask transport) {
  10   SetTransport(transport);
  11 }
  12
  13 BluetoothDiscoveryFilter::~BluetoothDiscoveryFilter() {
  14 }
  15
  16 bool BluetoothDiscoveryFilter::GetRSSI(int16_t* out_rssi) const {
  17   DCHECK(out_rssi);
  18   if (!rssi_.get())
  19     return false;
  20
  21   *out_rssi = *rssi_;
  22   return true;
  23 }
  24
  25 void BluetoothDiscoveryFilter::SetRSSI(int16_t rssi) {
  26   if (!rssi_.get())
  27     rssi_.reset(new int16_t());
  28
  29   *rssi_ = rssi;
  30 }
  31
  32 bool BluetoothDiscoveryFilter::GetPathloss(uint16_t* out_pathloss) const {
  33   DCHECK(out_pathloss);
  34   if (!pathloss_.get())
  35     return false;
  36
  37   *out_pathloss = *pathloss_;
  38   return true;
  39 }
  40
  41 void BluetoothDiscoveryFilter::SetPathloss(uint16_t pathloss) {
  42   if (!pathloss_.get())
  43     pathloss_.reset(new uint16_t());
  44
  45   *pathloss_ = pathloss;
  46 }
  47
  48 BluetoothDiscoveryFilter::TransportMask BluetoothDiscoveryFilter::GetTransport()
  49     const {
  50   return transport_;
  51 }
  52
  53 void BluetoothDiscoveryFilter::SetTransport(TransportMask transport) {
  54   DCHECK(transport > 0 && transport < 4);
  55   transport_ = transport;
  56 }
  57
  58 void BluetoothDiscoveryFilter::GetUUIDs(
  59     std::set<device::BluetoothUUID>& out_uuids) const {
  60   out_uuids.clear();
  61
  62   for (auto& uuid : uuids_)
  63     out_uuids.insert(*uuid);
  64 }
  65
  66 void BluetoothDiscoveryFilter::AddUUID(const device::BluetoothUUID& uuid) {
  67   DCHECK(uuid.IsValid());
  68   for (auto& uuid_it : uuids_) {
  69     if (*uuid_it == uuid)
  70       return;
  71   }
  72
  73   uuids_.push_back(new device::BluetoothUUID(uuid));
  74 }
  75
  76 void BluetoothDiscoveryFilter::CopyFrom(
  77     const BluetoothDiscoveryFilter& filter) {
  78   transport_ = filter.transport_;
  79
  80   if (filter.uuids_.size()) {
  81     for (auto& uuid : filter.uuids_)
  82       AddUUID(*uuid);
  83   } else
  84     uuids_.clear();
  85
  86   if (filter.rssi_.get()) {
  87     SetRSSI(*filter.rssi_);
  88   } else
  89     rssi_.reset();
  90
  91   if (filter.pathloss_.get()) {
  92     SetPathloss(*filter.pathloss_);
  93   } else
  94     pathloss_.reset();
  95 }
  96
  97 scoped_ptr<device::BluetoothDiscoveryFilter> BluetoothDiscoveryFilter::Merge(
  98     const device::BluetoothDiscoveryFilter* filter_a,
  99     const device::BluetoothDiscoveryFilter* filter_b) {
 100   scoped_ptr<BluetoothDiscoveryFilter> result;
 101
 102   if (!filter_a && !filter_b) {
 103     return result;
 104   }
 105
 106   result.reset(new BluetoothDiscoveryFilter(Transport::TRANSPORT_DUAL));
 107
 108   if (!filter_a || !filter_b || filter_a->IsDefault() ||
 109       filter_b->IsDefault()) {
 110     return result;
 111   }
 112
 113   // both filters are not empty, so they must have transport set.
 114   result->SetTransport(filter_a->transport_ | filter_b->transport_);
 115
 116   // if both filters have uuids, them merge them. Otherwise uuids filter should
 117   // be left empty
 118   if (filter_a->uuids_.size() && filter_b->uuids_.size()) {
 119     std::set<device::BluetoothUUID> uuids;
 120     filter_a->GetUUIDs(uuids);
 121     for (auto& uuid : uuids)
 122       result->AddUUID(uuid);
 123
 124     filter_b->GetUUIDs(uuids);
 125     for (auto& uuid : uuids)
 126       result->AddUUID(uuid);
 127   }
 128
 129   if ((filter_a->rssi_.get() && filter_b->pathloss_.get()) ||
 130       (filter_a->pathloss_.get() && filter_b->rssi_.get())) {
 131     // if both rssi and pathloss filtering is enabled in two different
 132     // filters, we can't tell which filter is more generic, and we don't set
 133     // proximity filtering on merged filter.
 134     return result;
 135   }
 136
 137   if (filter_a->rssi_.get() && filter_b->rssi_.get()) {
 138     result->SetRSSI(std::min(*filter_a->rssi_, *filter_b->rssi_));
 139   } else if (filter_a->pathloss_.get() && filter_b->pathloss_.get()) {
 140     result->SetPathloss(std::max(*filter_a->pathloss_, *filter_b->pathloss_));
 141   }
 142
 143   return result;
 144 }
 145
 146 bool BluetoothDiscoveryFilter::Equals(
 147     const BluetoothDiscoveryFilter& other) const {
 148   if (((!!rssi_.get()) != (!!other.rssi_.get())) ||
 149       (rssi_.get() && other.rssi_.get() && *rssi_ != *other.rssi_)) {
 150     return false;
 151   }
 152
 153   if (((!!pathloss_.get()) != (!!other.pathloss_.get())) ||
 154       (pathloss_.get() && other.pathloss_.get() &&
 155        *pathloss_ != *other.pathloss_)) {
 156     return false;
 157   }
 158
 159   if (transport_ != other.transport_)
 160     return false;
 161
 162   std::set<device::BluetoothUUID> uuids_a, uuids_b;
 163   GetUUIDs(uuids_a);
 164   other.GetUUIDs(uuids_b);
 165   if (uuids_a != uuids_b)
 166     return false;
 167
 168   return true;
 169 }
 170
 171 bool BluetoothDiscoveryFilter::IsDefault() const {
 172   return !(rssi_.get() || pathloss_.get() || uuids_.size() ||
 173            transport_ != Transport::TRANSPORT_DUAL);
 174 }
 175
 176 }  // namespace device