device/bluetooth/bluetooth_discovery_session.cc

   1 // Copyright 2014 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_session.h"
   6
   7 #include "base/bind.h"
   8 #include "device/bluetooth/bluetooth_adapter.h"
   9
  10 namespace device {
  11
  12 BluetoothDiscoveryFilter::BluetoothDiscoveryFilter(TransportMask transport) {
  13   SetTransport(transport);
  14 }
  15
  16 BluetoothDiscoveryFilter::~BluetoothDiscoveryFilter() {
  17 }
  18
  19 bool BluetoothDiscoveryFilter::GetRSSI(int16_t* out_rssi) const {
  20   DCHECK(out_rssi);
  21   if (!rssi_.get())
  22     return false;
  23
  24   *out_rssi = *rssi_;
  25   return true;
  26 }
  27
  28 void BluetoothDiscoveryFilter::SetRSSI(int16_t rssi) {
  29   if (!rssi_.get())
  30     rssi_.reset(new int16_t());
  31
  32   *rssi_ = rssi;
  33 }
  34
  35 bool BluetoothDiscoveryFilter::GetPathloss(uint16_t* out_pathloss) const {
  36   DCHECK(out_pathloss);
  37   if (!pathloss_.get())
  38     return false;
  39
  40   *out_pathloss = *pathloss_;
  41   return true;
  42 }
  43
  44 void BluetoothDiscoveryFilter::SetPathloss(uint16_t pathloss) {
  45   if (!pathloss_.get())
  46     pathloss_.reset(new uint16_t());
  47
  48   *pathloss_ = pathloss;
  49 }
  50
  51 BluetoothDiscoveryFilter::TransportMask BluetoothDiscoveryFilter::GetTransport()
  52     const {
  53   return transport_;
  54 }
  55
  56 void BluetoothDiscoveryFilter::SetTransport(TransportMask transport) {
  57   DCHECK(transport > 0 && transport < 4);
  58   transport_ = transport;
  59 }
  60
  61 void BluetoothDiscoveryFilter::GetUUIDs(
  62     std::set<device::BluetoothUUID>& out_uuids) const {
  63   out_uuids.clear();
  64
  65   for (auto& uuid : uuids_)
  66     out_uuids.insert(*uuid);
  67 }
  68
  69 void BluetoothDiscoveryFilter::AddUUID(const device::BluetoothUUID& uuid) {
  70   DCHECK(uuid.IsValid());
  71   for (auto& uuid_it : uuids_) {
  72     if (*uuid_it == uuid)
  73       return;
  74   }
  75
  76   uuids_.push_back(new device::BluetoothUUID(uuid));
  77 }
  78
  79 void BluetoothDiscoveryFilter::CopyFrom(
  80     const BluetoothDiscoveryFilter& filter) {
  81   transport_ = filter.transport_;
  82
  83   if (filter.uuids_.size()) {
  84     for (auto& uuid : filter.uuids_)
  85       AddUUID(*uuid);
  86   } else
  87     uuids_.clear();
  88
  89   if (filter.rssi_.get()) {
  90     SetRSSI(*filter.rssi_);
  91   } else
  92     rssi_.reset();
  93
  94   if (filter.pathloss_.get()) {
  95     SetPathloss(*filter.pathloss_);
  96   } else
  97     pathloss_.reset();
  98 }
  99
 100 scoped_ptr<device::BluetoothDiscoveryFilter> BluetoothDiscoveryFilter::Merge(
 101     const device::BluetoothDiscoveryFilter* filter_a,
 102     const device::BluetoothDiscoveryFilter* filter_b) {
 103   scoped_ptr<BluetoothDiscoveryFilter> result;
 104
 105   if (!filter_a && !filter_b) {
 106     return result;
 107   }
 108
 109   result.reset(new BluetoothDiscoveryFilter(Transport::TRANSPORT_DUAL));
 110
 111   if (!filter_a || !filter_b || filter_a->IsDefault() ||
 112       filter_b->IsDefault()) {
 113     return result;
 114   }
 115
 116   // both filters are not empty, so they must have transport set.
 117   result->SetTransport(filter_a->transport_ | filter_b->transport_);
 118
 119   // if both filters have uuids, them merge them. Otherwise uuids filter should
 120   // be left empty
 121   if (filter_a->uuids_.size() && filter_b->uuids_.size()) {
 122     std::set<device::BluetoothUUID> uuids;
 123     filter_a->GetUUIDs(uuids);
 124     for (auto& uuid : uuids)
 125       result->AddUUID(uuid);
 126
 127     filter_b->GetUUIDs(uuids);
 128     for (auto& uuid : uuids)
 129       result->AddUUID(uuid);
 130   }
 131
 132   if ((filter_a->rssi_.get() && filter_b->pathloss_.get()) ||
 133       (filter_a->pathloss_.get() && filter_b->rssi_.get())) {
 134     // if both rssi and pathloss filtering is enabled in two different
 135     // filters, we can't tell which filter is more generic, and we don't set
 136     // proximity filtering on merged filter.
 137     return result;
 138   }
 139
 140   if (filter_a->rssi_.get() && filter_b->rssi_.get()) {
 141     result->SetRSSI(std::min(*filter_a->rssi_, *filter_b->rssi_));
 142   } else if (filter_a->pathloss_.get() && filter_b->pathloss_.get()) {
 143     result->SetPathloss(std::max(*filter_a->pathloss_, *filter_b->pathloss_));
 144   }
 145
 146   return result;
 147 }
 148
 149 bool BluetoothDiscoveryFilter::Equals(
 150     const BluetoothDiscoveryFilter& other) const {
 151   if (((!!rssi_.get()) != (!!other.rssi_.get())) ||
 152       (rssi_.get() && other.rssi_.get() && *rssi_ != *other.rssi_)) {
 153     return false;
 154   }
 155
 156   if (((!!pathloss_.get()) != (!!other.pathloss_.get())) ||
 157       (pathloss_.get() && other.pathloss_.get() &&
 158        *pathloss_ != *other.pathloss_)) {
 159     return false;
 160   }
 161
 162   if (transport_ != other.transport_)
 163     return false;
 164
 165   std::set<device::BluetoothUUID> uuids_a, uuids_b;
 166   GetUUIDs(uuids_a);
 167   other.GetUUIDs(uuids_b);
 168   if (uuids_a != uuids_b)
 169     return false;
 170
 171   return true;
 172 }
 173
 174 bool BluetoothDiscoveryFilter::IsDefault() const {
 175   return !(rssi_.get() || pathloss_.get() || uuids_.size() ||
 176            transport_ != Transport::TRANSPORT_DUAL);
 177 }
 178
 179 BluetoothDiscoverySession::BluetoothDiscoverySession(
 180     scoped_refptr<BluetoothAdapter> adapter,
 181     scoped_ptr<BluetoothDiscoveryFilter> discovery_filter)
 182     : active_(true),
 183       adapter_(adapter),
 184       discovery_filter_(discovery_filter.release()),
 185       weak_ptr_factory_(this) {
 186   DCHECK(adapter_.get());
 187 }
 188
 189 BluetoothDiscoverySession::~BluetoothDiscoverySession() {
 190   if (active_) {
 191     Stop(base::Bind(&base::DoNothing), base::Bind(&base::DoNothing));
 192     MarkAsInactive();
 193   }
 194 }
 195
 196 bool BluetoothDiscoverySession::IsActive() const {
 197   return active_;
 198 }
 199
 200 void BluetoothDiscoverySession::Stop(const base::Closure& success_callback,
 201                                      const ErrorCallback& error_callback) {
 202   if (!active_) {
 203     LOG(WARNING) << "Discovery session not active. Cannot stop.";
 204     error_callback.Run();
 205     return;
 206   }
 207   VLOG(1) << "Stopping device discovery session.";
 208   base::Closure deactive_discovery_session =
 209       base::Bind(&BluetoothDiscoverySession::DeactivateDiscoverySession,
 210                  weak_ptr_factory_.GetWeakPtr());
 211
 212   // Create a callback that runs
 213   // BluetoothDiscoverySession::DeactivateDiscoverySession if the session still
 214   // exists, but always runs success_callback.
 215   base::Closure discovery_session_removed_callback =
 216       base::Bind(&BluetoothDiscoverySession::OnDiscoverySessionRemoved,
 217                  deactive_discovery_session, success_callback);
 218   adapter_->RemoveDiscoverySession(discovery_filter_.get(),
 219                                    discovery_session_removed_callback,
 220                                    error_callback);
 221 }
 222
 223 // static
 224 void BluetoothDiscoverySession::OnDiscoverySessionRemoved(
 225     const base::Closure& deactivate_discovery_session,
 226     const base::Closure& success_callback) {
 227   deactivate_discovery_session.Run();
 228   success_callback.Run();
 229 }
 230
 231 void BluetoothDiscoverySession::DeactivateDiscoverySession() {
 232   MarkAsInactive();
 233   discovery_filter_.reset();
 234 }
 235
 236 void BluetoothDiscoverySession::MarkAsInactive() {
 237   if (!active_)
 238     return;
 239   active_ = false;
 240   adapter_->DiscoverySessionBecameInactive(this);
 241 }
 242
 243 void BluetoothDiscoverySession::SetDiscoveryFilter(
 244     scoped_ptr<BluetoothDiscoveryFilter> discovery_filter,
 245     const base::Closure& callback,
 246     const ErrorCallback& error_callback) {
 247   discovery_filter_.reset(discovery_filter.release());
 248   adapter_->SetDiscoveryFilter(adapter_->GetMergedDiscoveryFilter().Pass(),
 249                                callback, error_callback);
 250 }
 251
 252 const BluetoothDiscoveryFilter* BluetoothDiscoverySession::GetDiscoveryFilter()
 253     const {
 254   return discovery_filter_.get();
 255 }
 256
 257 }  // namespace device