device/nfc/nfc_adapter_chromeos.cc

   1 // Copyright 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 "device/nfc/nfc_adapter_chromeos.h"
   6
   7 #include <vector>
   8
   9 #include "base/callback.h"
  10 #include "base/logging.h"
  11 #include "chromeos/dbus/dbus_thread_manager.h"
  12 #include "device/nfc/nfc_peer_chromeos.h"
  13 #include "device/nfc/nfc_tag_chromeos.h"
  14 #include "third_party/cros_system_api/dbus/service_constants.h"
  15
  16 namespace chromeos {
  17
  18 namespace {
  19
  20 typedef std::vector<dbus::ObjectPath> ObjectPathVector;
  21
  22 }  // namespace
  23
  24 NfcAdapterChromeOS::NfcAdapterChromeOS()
  25     : weak_ptr_factory_(this) {
  26   DBusThreadManager::Get()->GetNfcAdapterClient()->AddObserver(this);
  27   DBusThreadManager::Get()->GetNfcDeviceClient()->AddObserver(this);
  28   DBusThreadManager::Get()->GetNfcTagClient()->AddObserver(this);
  29
  30   const ObjectPathVector& object_paths =
  31       DBusThreadManager::Get()->GetNfcAdapterClient()->GetAdapters();
  32   if (!object_paths.empty()) {
  33     VLOG(1) << object_paths.size() << " NFC adapter(s) available.";
  34     SetAdapter(object_paths[0]);
  35   }
  36 }
  37
  38 NfcAdapterChromeOS::~NfcAdapterChromeOS() {
  39   DBusThreadManager::Get()->GetNfcAdapterClient()->RemoveObserver(this);
  40   DBusThreadManager::Get()->GetNfcDeviceClient()->RemoveObserver(this);
  41   DBusThreadManager::Get()->GetNfcTagClient()->RemoveObserver(this);
  42 }
  43
  44 void NfcAdapterChromeOS::AddObserver(NfcAdapter::Observer* observer) {
  45   DCHECK(observer);
  46   observers_.AddObserver(observer);
  47 }
  48
  49 void NfcAdapterChromeOS::RemoveObserver(NfcAdapter::Observer* observer) {
  50   DCHECK(observer);
  51   observers_.RemoveObserver(observer);
  52 }
  53
  54 bool NfcAdapterChromeOS::IsPresent() const {
  55   return !object_path_.value().empty();
  56 }
  57
  58 bool NfcAdapterChromeOS::IsPowered() const {
  59   if (!IsPresent())
  60     return false;
  61   return DBusThreadManager::Get()->GetNfcAdapterClient()->
  62       GetProperties(object_path_)->powered.value();
  63 }
  64
  65 bool NfcAdapterChromeOS::IsPolling() const {
  66   if (!IsPresent())
  67     return false;
  68   return DBusThreadManager::Get()->GetNfcAdapterClient()->
  69       GetProperties(object_path_)->polling.value();
  70 }
  71
  72 bool NfcAdapterChromeOS::IsInitialized() const {
  73   return true;
  74 }
  75
  76 void NfcAdapterChromeOS::SetPowered(bool powered,
  77                                     const base::Closure& callback,
  78                                     const ErrorCallback& error_callback) {
  79   if (!IsPresent()) {
  80     LOG(WARNING) << "Adapter not present. Cannot power up the antenna.";
  81     error_callback.Run();
  82     return;
  83   }
  84   DBusThreadManager::Get()->GetNfcAdapterClient()->
  85       GetProperties(object_path_)->powered.Set(
  86           powered,
  87           base::Bind(&NfcAdapterChromeOS::OnSetPowered,
  88                      weak_ptr_factory_.GetWeakPtr(),
  89                      callback,
  90                      error_callback));
  91 }
  92
  93 void NfcAdapterChromeOS::StartPolling(const base::Closure& callback,
  94                                       const ErrorCallback& error_callback) {
  95   // Always poll in "Initiator" mode.
  96   DBusThreadManager::Get()->GetNfcAdapterClient()->
  97       StartPollLoop(object_path_,
  98                     nfc_adapter::kModeInitiator,
  99                     base::Bind(&NfcAdapterChromeOS::OnStartPolling,
 100                                weak_ptr_factory_.GetWeakPtr(),
 101                                callback),
 102                     base::Bind(&NfcAdapterChromeOS::OnStartPollingError,
 103                                weak_ptr_factory_.GetWeakPtr(),
 104                                error_callback));
 105 }
 106
 107 void NfcAdapterChromeOS::StopPolling(const base::Closure& callback,
 108                                      const ErrorCallback& error_callback) {
 109   DBusThreadManager::Get()->GetNfcAdapterClient()->
 110       StopPollLoop(object_path_,
 111                    base::Bind(&NfcAdapterChromeOS::OnStopPolling,
 112                               weak_ptr_factory_.GetWeakPtr(),
 113                               callback),
 114                    base::Bind(&NfcAdapterChromeOS::OnStopPollingError,
 115                               weak_ptr_factory_.GetWeakPtr(),
 116                               error_callback));
 117 }
 118
 119 void NfcAdapterChromeOS::AdapterAdded(const dbus::ObjectPath& object_path) {
 120   // Set the adapter to the newly added adapter only if no adapter is present.
 121   if (!IsPresent())
 122     SetAdapter(object_path);
 123 }
 124
 125 void NfcAdapterChromeOS::AdapterRemoved(const dbus::ObjectPath& object_path) {
 126   if (object_path != object_path_)
 127     return;
 128
 129   // The current adapter was removed, so mark us as not present and clean up
 130   // peers and tags.
 131   RemoveAdapter();
 132
 133   // There may still be other adapters present on the system. Set the next
 134   // available adapter as the current one.
 135   const ObjectPathVector& object_paths =
 136       DBusThreadManager::Get()->GetNfcAdapterClient()->GetAdapters();
 137   for (ObjectPathVector::const_iterator iter =
 138           object_paths.begin();
 139        iter != object_paths.end(); ++iter) {
 140     // The removed object will still be available until the call to
 141     // AdapterRemoved returns. Make sure that we are not re-adding the
 142     // removed adapter.
 143     if (*iter == object_path)
 144       continue;
 145     SetAdapter(*iter);
 146   }
 147 }
 148
 149 void NfcAdapterChromeOS::AdapterPropertyChanged(
 150     const dbus::ObjectPath& object_path,
 151     const std::string& property_name) {
 152   if (object_path != object_path_)
 153     return;
 154   NfcAdapterClient::Properties* properties =
 155       DBusThreadManager::Get()->GetNfcAdapterClient()->
 156           GetProperties(object_path_);
 157   if (property_name == properties->powered.name())
 158     PoweredChanged(properties->powered.value());
 159   else if (property_name == properties->polling.name())
 160     PollingChanged(properties->polling.value());
 161 }
 162
 163 void NfcAdapterChromeOS::DeviceAdded(const dbus::ObjectPath& object_path) {
 164   if (!IsPresent())
 165     return;
 166
 167   if (GetPeer(object_path.value()))
 168     return;
 169
 170   VLOG(1) << "NFC device found: " << object_path.value();
 171
 172   // Check to see if the device belongs to this adapter.
 173   const ObjectPathVector& devices =
 174       DBusThreadManager::Get()->GetNfcDeviceClient()->
 175           GetDevicesForAdapter(object_path_);
 176   bool device_found = false;
 177   for (ObjectPathVector::const_iterator iter = devices.begin();
 178        iter != devices.end(); ++iter) {
 179     if (*iter == object_path) {
 180       device_found = true;
 181       break;
 182     }
 183   }
 184   if (!device_found) {
 185     VLOG(1) << "Found peer device does not belong to the current adapter.";
 186     return;
 187   }
 188
 189   // Create the peer object.
 190   NfcPeerChromeOS* peer_chromeos = new NfcPeerChromeOS(object_path);
 191   SetPeer(object_path.value(), peer_chromeos);
 192   FOR_EACH_OBSERVER(NfcAdapter::Observer, observers_,
 193                     PeerFound(this, peer_chromeos));
 194 }
 195
 196 void NfcAdapterChromeOS::DeviceRemoved(const dbus::ObjectPath& object_path) {
 197   VLOG(1) << "NFC device lost: " << object_path.value();
 198   device::NfcPeer* peer = RemovePeer(object_path.value());
 199   if (!peer) {
 200     VLOG(1) << "Removed peer device does not belong to the current adapter.";
 201     return;
 202   }
 203   FOR_EACH_OBSERVER(NfcAdapter::Observer, observers_, PeerLost(this, peer));
 204   delete peer;
 205 }
 206
 207 void NfcAdapterChromeOS::TagAdded(const dbus::ObjectPath& object_path) {
 208   if (!IsPresent())
 209     return;
 210
 211   if (GetTag(object_path.value()))
 212     return;
 213
 214   VLOG(1) << "NFC tag found: " << object_path.value();
 215
 216   // Check to see if the tag belongs to this adapter.
 217   const std::vector<dbus::ObjectPath>& tags =
 218       DBusThreadManager::Get()->GetNfcTagClient()->
 219           GetTagsForAdapter(object_path_);
 220   bool tag_found = false;
 221   for (std::vector<dbus::ObjectPath>::const_iterator iter = tags.begin();
 222        iter != tags.end(); ++iter) {
 223     if (*iter == object_path) {
 224       tag_found = true;
 225       break;
 226     }
 227   }
 228   if (!tag_found) {
 229     VLOG(1) << "Found tag does not belong to the current adapter.";
 230     return;
 231   }
 232
 233   // Create the tag object.
 234   NfcTagChromeOS* tag_chromeos = new NfcTagChromeOS(object_path);
 235   SetTag(object_path.value(), tag_chromeos);
 236   FOR_EACH_OBSERVER(NfcAdapter::Observer, observers_,
 237                     TagFound(this, tag_chromeos));
 238 }
 239
 240 void NfcAdapterChromeOS::TagRemoved(const dbus::ObjectPath& object_path) {
 241   VLOG(1) << "NFC tag lost : " << object_path.value();
 242   device::NfcTag* tag = RemoveTag(object_path.value());
 243   if (!tag) {
 244     VLOG(1) << "Removed tag does not belong to the current adapter.";
 245     return;
 246   }
 247   FOR_EACH_OBSERVER(NfcAdapter::Observer, observers_, TagLost(this, tag));
 248   delete tag;
 249 }
 250
 251 void NfcAdapterChromeOS::SetAdapter(const dbus::ObjectPath& object_path) {
 252   DCHECK(!IsPresent());
 253   object_path_ = object_path;
 254   VLOG(1) << "Using NFC adapter: " << object_path.value();
 255
 256   NfcAdapterClient::Properties* properties =
 257       DBusThreadManager::Get()->GetNfcAdapterClient()->
 258           GetProperties(object_path_);
 259   PresentChanged(true);
 260   if (properties->powered.value())
 261     PoweredChanged(true);
 262   if (properties->polling.value())
 263     PollingChanged(true);
 264
 265   // Create peer objects for peers that were added before the adapter was set.
 266   const ObjectPathVector& devices =
 267       DBusThreadManager::Get()->GetNfcDeviceClient()->
 268           GetDevicesForAdapter(object_path_);
 269   for (ObjectPathVector::const_iterator iter = devices.begin();
 270        iter != devices.end(); ++iter) {
 271     const dbus::ObjectPath& object_path = *iter;
 272     if (GetPeer(object_path.value()))
 273       continue;
 274     NfcPeerChromeOS* peer_chromeos = new NfcPeerChromeOS(object_path);
 275     SetPeer(object_path.value(), peer_chromeos);
 276     FOR_EACH_OBSERVER(NfcAdapter::Observer, observers_,
 277                       PeerFound(this, peer_chromeos));
 278   }
 279
 280   // Create tag objects for tags that were added before the adapter was set.
 281   const std::vector<dbus::ObjectPath>& tags =
 282       DBusThreadManager::Get()->GetNfcTagClient()->
 283           GetTagsForAdapter(object_path_);
 284   for (std::vector<dbus::ObjectPath>::const_iterator iter = tags.begin();
 285        iter != tags.end(); ++iter) {
 286     const dbus::ObjectPath& object_path = *iter;
 287     if (GetTag(object_path.value()))
 288       continue;
 289     NfcTagChromeOS* tag_chromeos = new NfcTagChromeOS(object_path);
 290     SetTag(object_path.value(), tag_chromeos);
 291     FOR_EACH_OBSERVER(NfcAdapter::Observer, observers_,
 292                       TagFound(this, tag_chromeos));
 293   }
 294 }
 295
 296 void NfcAdapterChromeOS::RemoveAdapter() {
 297   DCHECK(IsPresent());
 298   VLOG(1) << "NFC adapter removed: " << object_path_.value();
 299
 300   NfcAdapterClient::Properties* properties =
 301       DBusThreadManager::Get()->GetNfcAdapterClient()->
 302           GetProperties(object_path_);
 303   if (properties->powered.value())
 304     PoweredChanged(false);
 305   if (properties->polling.value())
 306     PollingChanged(false);
 307
 308   // Copy the tags and peers here and clear the original containers so that
 309   // GetPeers and GetTags return no values during the *Removed observer calls.
 310   PeerList peers;
 311   TagList tags;
 312   GetPeers(&peers);
 313   GetTags(&tags);
 314   ClearPeers();
 315   ClearTags();
 316
 317   for (PeerList::iterator iter = peers.begin();
 318        iter != peers.end(); ++iter) {
 319     device::NfcPeer* peer = *iter;
 320     FOR_EACH_OBSERVER(NfcAdapter::Observer, observers_,
 321                       PeerLost(this, peer));
 322     delete peer;
 323   }
 324   for (TagList::iterator iter = tags.begin();
 325        iter != tags.end(); ++iter) {
 326     device::NfcTag* tag = *iter;
 327     FOR_EACH_OBSERVER(NfcAdapter::Observer, observers_,
 328                       TagLost(this, tag));
 329     delete tag;
 330   }
 331
 332   object_path_ = dbus::ObjectPath("");
 333   PresentChanged(false);
 334 }
 335
 336 void NfcAdapterChromeOS::PoweredChanged(bool powered) {
 337   FOR_EACH_OBSERVER(NfcAdapter::Observer, observers_,
 338                     AdapterPoweredChanged(this, powered));
 339 }
 340
 341 void NfcAdapterChromeOS::PollingChanged(bool polling) {
 342   FOR_EACH_OBSERVER(NfcAdapter::Observer, observers_,
 343                     AdapterPollingChanged(this, polling));
 344 }
 345
 346 void NfcAdapterChromeOS::PresentChanged(bool present) {
 347   FOR_EACH_OBSERVER(NfcAdapter::Observer, observers_,
 348                     AdapterPresentChanged(this, present));
 349 }
 350
 351 void NfcAdapterChromeOS::OnSetPowered(const base::Closure& callback,
 352                                       const ErrorCallback& error_callback,
 353                                       bool success) {
 354   VLOG(1) << "NfcAdapterChromeOS::OnSetPowered result: " << success;
 355   if (success) {
 356     // TODO(armansito): There is a bug in neard 0.13 that causes it not to emit
 357     // a signal when the "Powered" property changes. Sync the properties here,
 358     // but remove it in neard 0.14.
 359     if (IsPresent()) {
 360       DBusThreadManager::Get()->GetNfcAdapterClient()->
 361           GetProperties(object_path_)->GetAll();
 362     }
 363     callback.Run();
 364   } else {
 365     LOG(ERROR) << "Failed to power up the NFC antenna radio.";
 366     error_callback.Run();
 367   }
 368 }
 369
 370 void NfcAdapterChromeOS::OnStartPolling(const base::Closure& callback) {
 371   callback.Run();
 372 }
 373
 374 void NfcAdapterChromeOS::OnStartPollingError(
 375     const ErrorCallback& error_callback,
 376     const std::string& error_name,
 377     const std::string& error_message) {
 378   LOG(ERROR) << object_path_.value() << ": Failed to start polling: "
 379              << error_name << ": " << error_message;
 380   error_callback.Run();
 381 }
 382
 383 void NfcAdapterChromeOS::OnStopPolling(const base::Closure& callback) {
 384   callback.Run();
 385 }
 386
 387 void NfcAdapterChromeOS::OnStopPollingError(
 388     const ErrorCallback& error_callback,
 389     const std::string& error_name,
 390     const std::string& error_message) {
 391   LOG(ERROR) << object_path_.value() << ": Failed to stop polling: "
 392              << error_name << ": " << error_message;
 393   error_callback.Run();
 394 }
 395
 396 }  // namespace chromeos