src/chromeos/dbus/fake_bluetooth_adapter_client.cc

   1 // Copyright (c) 2013 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 "chromeos/dbus/fake_bluetooth_adapter_client.h"
   6
   7 #include "base/bind.h"
   8 #include "base/logging.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/time/time.h"
  11 #include "chromeos/dbus/dbus_thread_manager.h"
  12 #include "chromeos/dbus/fake_bluetooth_device_client.h"
  13 #include "dbus/object_path.h"
  14 #include "third_party/cros_system_api/dbus/service_constants.h"
  15
  16 namespace chromeos {
  17
  18 const char FakeBluetoothAdapterClient::kAdapterPath[] =
  19     "/fake/hci0";
  20 const char FakeBluetoothAdapterClient::kAdapterName[] =
  21     "Fake Adapter";
  22 const char FakeBluetoothAdapterClient::kAdapterAddress[] =
  23     "01:1a:2b:1a:2b:03";
  24
  25 const char FakeBluetoothAdapterClient::kSecondAdapterPath[] =
  26     "/fake/hci1";
  27 const char FakeBluetoothAdapterClient::kSecondAdapterName[] =
  28     "Second Fake Adapter";
  29 const char FakeBluetoothAdapterClient::kSecondAdapterAddress[] =
  30     "00:de:51:10:01:00";
  31
  32 FakeBluetoothAdapterClient::Properties::Properties(
  33     const PropertyChangedCallback& callback)
  34     : BluetoothAdapterClient::Properties(
  35         NULL,
  36         bluetooth_adapter::kBluetoothAdapterInterface,
  37         callback) {
  38 }
  39
  40 FakeBluetoothAdapterClient::Properties::~Properties() {
  41 }
  42
  43 void FakeBluetoothAdapterClient::Properties::Get(
  44     dbus::PropertyBase* property,
  45     dbus::PropertySet::GetCallback callback) {
  46   VLOG(1) << "Get " << property->name();
  47   callback.Run(false);
  48 }
  49
  50 void FakeBluetoothAdapterClient::Properties::GetAll() {
  51   VLOG(1) << "GetAll";
  52 }
  53
  54 void FakeBluetoothAdapterClient::Properties::Set(
  55     dbus::PropertyBase *property,
  56     dbus::PropertySet::SetCallback callback) {
  57   VLOG(1) << "Set " << property->name();
  58   if (property->name() == powered.name() ||
  59       property->name() == alias.name() ||
  60       property->name() == discoverable.name() ||
  61       property->name() == discoverable_timeout.name()) {
  62     callback.Run(true);
  63     property->ReplaceValueWithSetValue();
  64   } else {
  65     callback.Run(false);
  66   }
  67 }
  68
  69 FakeBluetoothAdapterClient::FakeBluetoothAdapterClient()
  70     : visible_(true),
  71       second_visible_(false),
  72       discovering_count_(0) {
  73   properties_.reset(new Properties(base::Bind(
  74       &FakeBluetoothAdapterClient::OnPropertyChanged, base::Unretained(this))));
  75
  76   properties_->address.ReplaceValue(kAdapterAddress);
  77   properties_->name.ReplaceValue("Fake Adapter (Name)");
  78   properties_->alias.ReplaceValue(kAdapterName);
  79   properties_->pairable.ReplaceValue(true);
  80
  81   second_properties_.reset(new Properties(base::Bind(
  82       &FakeBluetoothAdapterClient::OnPropertyChanged, base::Unretained(this))));
  83
  84   second_properties_->address.ReplaceValue(kSecondAdapterAddress);
  85   second_properties_->name.ReplaceValue("Second Fake Adapter (Name)");
  86   second_properties_->alias.ReplaceValue(kSecondAdapterName);
  87   second_properties_->pairable.ReplaceValue(true);
  88 }
  89
  90 FakeBluetoothAdapterClient::~FakeBluetoothAdapterClient() {
  91 }
  92
  93 void FakeBluetoothAdapterClient::Init(dbus::Bus* bus) {
  94 }
  95
  96 void FakeBluetoothAdapterClient::AddObserver(Observer* observer) {
  97   observers_.AddObserver(observer);
  98 }
  99
 100 void FakeBluetoothAdapterClient::RemoveObserver(Observer* observer) {
 101   observers_.RemoveObserver(observer);
 102 }
 103
 104 std::vector<dbus::ObjectPath> FakeBluetoothAdapterClient::GetAdapters() {
 105   std::vector<dbus::ObjectPath> object_paths;
 106   if (visible_)
 107     object_paths.push_back(dbus::ObjectPath(kAdapterPath));
 108   if (second_visible_)
 109     object_paths.push_back(dbus::ObjectPath(kSecondAdapterPath));
 110   return object_paths;
 111 }
 112
 113 FakeBluetoothAdapterClient::Properties*
 114 FakeBluetoothAdapterClient::GetProperties(const dbus::ObjectPath& object_path) {
 115   if (object_path == dbus::ObjectPath(kAdapterPath))
 116     return properties_.get();
 117   else if (object_path == dbus::ObjectPath(kSecondAdapterPath))
 118     return second_properties_.get();
 119   else
 120     return NULL;
 121 }
 122
 123 void FakeBluetoothAdapterClient::StartDiscovery(
 124     const dbus::ObjectPath& object_path,
 125     const base::Closure& callback,
 126     const ErrorCallback& error_callback) {
 127   if (object_path != dbus::ObjectPath(kAdapterPath)) {
 128     error_callback.Run(kNoResponseError, "");
 129     return;
 130   }
 131
 132   ++discovering_count_;
 133   VLOG(1) << "StartDiscovery: " << object_path.value() << ", "
 134           << "count is now " << discovering_count_;
 135   callback.Run();
 136
 137   if (discovering_count_ == 1) {
 138     properties_->discovering.ReplaceValue(true);
 139
 140     FakeBluetoothDeviceClient* device_client =
 141         static_cast<FakeBluetoothDeviceClient*>(
 142             DBusThreadManager::Get()->GetBluetoothDeviceClient());
 143     device_client->BeginDiscoverySimulation(dbus::ObjectPath(kAdapterPath));
 144   }
 145 }
 146
 147 void FakeBluetoothAdapterClient::StopDiscovery(
 148     const dbus::ObjectPath& object_path,
 149     const base::Closure& callback,
 150     const ErrorCallback& error_callback) {
 151   if (object_path != dbus::ObjectPath(kAdapterPath)) {
 152     error_callback.Run(kNoResponseError, "");
 153     return;
 154   }
 155
 156   if (!discovering_count_) {
 157     LOG(WARNING) << "StopDiscovery called when not discovering";
 158     error_callback.Run(kNoResponseError, "");
 159     return;
 160   }
 161
 162   --discovering_count_;
 163   VLOG(1) << "StopDiscovery: " << object_path.value() << ", "
 164           << "count is now " << discovering_count_;
 165   callback.Run();
 166
 167   if (discovering_count_ == 0) {
 168     FakeBluetoothDeviceClient* device_client =
 169         static_cast<FakeBluetoothDeviceClient*>(
 170             DBusThreadManager::Get()->GetBluetoothDeviceClient());
 171     device_client->EndDiscoverySimulation(dbus::ObjectPath(kAdapterPath));
 172
 173     properties_->discovering.ReplaceValue(false);
 174   }
 175 }
 176
 177 void FakeBluetoothAdapterClient::RemoveDevice(
 178     const dbus::ObjectPath& object_path,
 179     const dbus::ObjectPath& device_path,
 180     const base::Closure& callback,
 181     const ErrorCallback& error_callback) {
 182   if (object_path != dbus::ObjectPath(kAdapterPath)) {
 183     error_callback.Run(kNoResponseError, "");
 184     return;
 185   }
 186
 187   VLOG(1) << "RemoveDevice: " << object_path.value()
 188           << " " << device_path.value();
 189   callback.Run();
 190
 191   FakeBluetoothDeviceClient* device_client =
 192       static_cast<FakeBluetoothDeviceClient*>(
 193           DBusThreadManager::Get()->GetBluetoothDeviceClient());
 194   device_client->RemoveDevice(dbus::ObjectPath(kAdapterPath), device_path);
 195 }
 196
 197 void FakeBluetoothAdapterClient::SetVisible(
 198     bool visible) {
 199   if (visible && !visible_) {
 200     // Adapter becoming visible
 201     visible_ = visible;
 202
 203     FOR_EACH_OBSERVER(BluetoothAdapterClient::Observer, observers_,
 204                       AdapterAdded(dbus::ObjectPath(kAdapterPath)));
 205
 206   } else if (visible_ && !visible) {
 207     // Adapter becoming invisible
 208     visible_ = visible;
 209
 210     FOR_EACH_OBSERVER(BluetoothAdapterClient::Observer, observers_,
 211                       AdapterRemoved(dbus::ObjectPath(kAdapterPath)));
 212   }
 213 }
 214
 215 void FakeBluetoothAdapterClient::SetSecondVisible(
 216     bool visible) {
 217   if (visible && !second_visible_) {
 218     // Second adapter becoming visible
 219     second_visible_ = visible;
 220
 221     FOR_EACH_OBSERVER(BluetoothAdapterClient::Observer, observers_,
 222                       AdapterAdded(dbus::ObjectPath(kSecondAdapterPath)));
 223
 224   } else if (second_visible_ && !visible) {
 225     // Second adapter becoming invisible
 226     second_visible_ = visible;
 227
 228     FOR_EACH_OBSERVER(BluetoothAdapterClient::Observer, observers_,
 229                       AdapterRemoved(dbus::ObjectPath(kSecondAdapterPath)));
 230   }
 231 }
 232
 233 void FakeBluetoothAdapterClient::OnPropertyChanged(
 234     const std::string& property_name) {
 235   if (property_name == properties_->powered.name() &&
 236       !properties_->powered.value()) {
 237     VLOG(1) << "Adapter powered off";
 238
 239     if (discovering_count_) {
 240       discovering_count_ = 0;
 241       properties_->discovering.ReplaceValue(false);
 242     }
 243   }
 244
 245   FOR_EACH_OBSERVER(BluetoothAdapterClient::Observer, observers_,
 246                     AdapterPropertyChanged(dbus::ObjectPath(kAdapterPath),
 247                                            property_name));
 248 }
 249
 250 }  // namespace chromeos