chromeos/dbus/nfc_device_client.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 "chromeos/dbus/nfc_device_client.h"
   6
   7 #include "base/bind.h"
   8 #include "base/memory/weak_ptr.h"
   9 #include "base/observer_list.h"
  10 #include "base/strings/stringprintf.h"
  11 #include "chromeos/dbus/fake_nfc_device_client.h"
  12 #include "chromeos/dbus/nfc_adapter_client.h"
  13 #include "dbus/bus.h"
  14 #include "dbus/message.h"
  15 #include "third_party/cros_system_api/dbus/service_constants.h"
  16
  17 using chromeos::nfc_client_helpers::DBusObjectMap;
  18 using chromeos::nfc_client_helpers::ObjectProxyTree;
  19
  20 namespace chromeos {
  21
  22 NfcDeviceClient::Properties::Properties(
  23     dbus::ObjectProxy* object_proxy,
  24     const PropertyChangedCallback& callback)
  25     : NfcPropertySet(object_proxy,
  26                      nfc_device::kNfcDeviceInterface,
  27                      callback) {
  28   RegisterProperty(nfc_device::kRecordsProperty, &records);
  29 }
  30
  31 NfcDeviceClient::Properties::~Properties() {
  32 }
  33
  34 // The NfcDeviceClient implementation used in production.
  35 class NfcDeviceClientImpl : public NfcDeviceClient,
  36                             public NfcAdapterClient::Observer,
  37                             public DBusObjectMap::Delegate {
  38  public:
  39   explicit NfcDeviceClientImpl(NfcAdapterClient* adapter_client)
  40       : bus_(NULL),
  41         adapter_client_(adapter_client),
  42         weak_ptr_factory_(this) {
  43     DCHECK(adapter_client);
  44   }
  45
  46   virtual ~NfcDeviceClientImpl() {
  47     DCHECK(adapter_client_);
  48     adapter_client_->RemoveObserver(this);
  49   }
  50
  51   // NfcDeviceClient override.
  52   virtual void AddObserver(NfcDeviceClient::Observer* observer) OVERRIDE {
  53     DCHECK(observer);
  54     observers_.AddObserver(observer);
  55   }
  56
  57   // NfcDeviceClient override.
  58   virtual void RemoveObserver(NfcDeviceClient::Observer* observer) OVERRIDE {
  59     DCHECK(observer);
  60     observers_.RemoveObserver(observer);
  61   }
  62
  63   // NfcDeviceClient override.
  64   virtual Properties* GetProperties(
  65       const dbus::ObjectPath& object_path) OVERRIDE {
  66     return static_cast<Properties*>(
  67         adapters_to_object_maps_.FindObjectProperties(object_path));
  68   }
  69
  70   // NfcDeviceClient override.
  71   virtual void Push(
  72       const dbus::ObjectPath& object_path,
  73       const NfcRecordClient::Attributes& attributes,
  74       const base::Closure& callback,
  75       const nfc_client_helpers::ErrorCallback& error_callback) OVERRIDE {
  76     dbus::ObjectProxy* object_proxy =
  77         adapters_to_object_maps_.FindObjectProxy(object_path);
  78     if (!object_proxy) {
  79       std::string error_message =
  80           base::StringPrintf(
  81               "NFC device with object path \"%s\" does not exist.",
  82               object_path.value().c_str());
  83       LOG(ERROR) << error_message;
  84       error_callback.Run(nfc_client_helpers::kUnknownObjectError,
  85                          error_message);
  86       return;
  87     }
  88
  89     // |attributes| should not be empty.
  90     if (attributes.empty()) {
  91       std::string error_message =
  92           "Cannot push data to device with empty arguments.";
  93       LOG(ERROR) << error_message;
  94       error_callback.Run(nfc_error::kInvalidArguments, error_message);
  95       return;
  96     }
  97
  98     // Create the arguments.
  99     dbus::MethodCall method_call(nfc_device::kNfcDeviceInterface,
 100                                  nfc_device::kPush);
 101     dbus::MessageWriter writer(&method_call);
 102     dbus::MessageWriter array_writer(NULL);
 103     dbus::MessageWriter dict_entry_writer(NULL);
 104     writer.OpenArray("{sv}", &array_writer);
 105     for (NfcRecordClient::Attributes::const_iterator iter = attributes.begin();
 106          iter != attributes.end(); ++iter) {
 107       array_writer.OpenDictEntry(&dict_entry_writer);
 108       dict_entry_writer.AppendString(iter->first);
 109       dict_entry_writer.AppendVariantOfString(iter->second);
 110       array_writer.CloseContainer(&dict_entry_writer);
 111     }
 112     writer.CloseContainer(&array_writer);
 113
 114     object_proxy->CallMethodWithErrorCallback(
 115         &method_call,
 116         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 117         base::Bind(&nfc_client_helpers::OnSuccess, callback),
 118         base::Bind(&nfc_client_helpers::OnError, error_callback));
 119   }
 120
 121  protected:
 122   // DBusClient override.
 123   virtual void Init(dbus::Bus* bus) OVERRIDE {
 124     VLOG(1) << "Creating NfcDeviceClientImpl";
 125     DCHECK(bus);
 126     bus_ = bus;
 127     DCHECK(adapter_client_);
 128     adapter_client_->AddObserver(this);
 129   }
 130
 131  private:
 132   // NfcAdapterClient::Observer override.
 133   virtual void AdapterAdded(const dbus::ObjectPath& object_path) OVERRIDE {
 134     VLOG(1) << "Adapter added. Creating map for device proxies belonging to "
 135             << "adapter: " << object_path.value();
 136     adapters_to_object_maps_.CreateObjectMap(
 137         object_path, nfc_device::kNfcDeviceServiceName, this, bus_);
 138   }
 139
 140   // NfcAdapterClient::Observer override.
 141   virtual void AdapterRemoved(const dbus::ObjectPath& object_path) OVERRIDE {
 142     // Neard doesn't send out property changed signals for the devices that
 143     // are removed when the adapter they belong to is removed. Clean up the
 144     // object proxies for devices that are managed by the removed adapter.
 145     // Note: DBusObjectMap guarantees that the Properties structure for the
 146     // removed adapter will be valid before this method returns.
 147     VLOG(1) << "Adapter removed. Cleaning up device proxies belonging to "
 148             << "adapter: " << object_path.value();
 149     adapters_to_object_maps_.RemoveObjectMap(object_path);
 150   }
 151
 152   // NfcAdapterClient::Observer override.
 153   virtual void AdapterPropertyChanged(
 154       const dbus::ObjectPath& object_path,
 155       const std::string& property_name) OVERRIDE {
 156     DCHECK(adapter_client_);
 157     NfcAdapterClient::Properties *adapter_properties =
 158         adapter_client_->GetProperties(object_path);
 159     DCHECK(adapter_properties);
 160
 161     // Ignore changes to properties other than "Devices".
 162     if (property_name != adapter_properties->devices.name())
 163       return;
 164
 165     // Update the known devices.
 166     VLOG(1) << "NFC devices changed.";
 167     const std::vector<dbus::ObjectPath>& received_devices =
 168         adapter_properties->devices.value();
 169     DBusObjectMap* object_map =
 170         adapters_to_object_maps_.GetObjectMap(object_path);
 171     DCHECK(object_map);
 172     object_map->UpdateObjects(received_devices);
 173   }
 174
 175   // nfc_client_helpers::DBusObjectMap::Delegate override.
 176   virtual NfcPropertySet* CreateProperties(
 177       dbus::ObjectProxy* object_proxy) OVERRIDE {
 178     return new Properties(
 179         object_proxy,
 180         base::Bind(&NfcDeviceClientImpl::OnPropertyChanged,
 181                    weak_ptr_factory_.GetWeakPtr(),
 182                    object_proxy->object_path()));
 183   }
 184
 185   // nfc_client_helpers::DBusObjectMap::Delegate override.
 186   virtual void ObjectAdded(const dbus::ObjectPath& object_path) OVERRIDE {
 187     FOR_EACH_OBSERVER(NfcDeviceClient::Observer, observers_,
 188                       DeviceAdded(object_path));
 189   }
 190
 191   virtual void ObjectRemoved(const dbus::ObjectPath& object_path) OVERRIDE {
 192     FOR_EACH_OBSERVER(NfcDeviceClient::Observer, observers_,
 193                       DeviceRemoved(object_path));
 194   }
 195
 196   // Called by NfcPropertySet when a property value is changed, either by
 197   // result of a signal or response to a GetAll() or Get() call.
 198   void OnPropertyChanged(const dbus::ObjectPath& object_path,
 199                          const std::string& property_name) {
 200     VLOG(1) << "Device property changed; Path: " << object_path.value()
 201             << " Property: " << property_name;
 202     FOR_EACH_OBSERVER(NfcDeviceClient::Observer, observers_,
 203                       DevicePropertyChanged(object_path, property_name));
 204   }
 205
 206   // We maintain a pointer to the bus to be able to request proxies for
 207   // new NFC devices that appear.
 208   dbus::Bus* bus_;
 209
 210   // List of observers interested in event notifications.
 211   ObserverList<NfcDeviceClient::Observer> observers_;
 212
 213   // Mapping from object paths to object proxies and properties structures that
 214   // were already created by us. This stucture stores a different DBusObjectMap
 215   // for each known NFC adapter object path.
 216   ObjectProxyTree adapters_to_object_maps_;
 217
 218   // The adapter client that we listen to events notifications from.
 219   NfcAdapterClient* adapter_client_;
 220
 221   // Weak pointer factory for generating 'this' pointers that might live longer
 222   // than we do.
 223   // Note: This should remain the last member so it'll be destroyed and
 224   // invalidate its weak pointers before any other members are destroyed.
 225   base::WeakPtrFactory<NfcDeviceClientImpl> weak_ptr_factory_;
 226
 227   DISALLOW_COPY_AND_ASSIGN(NfcDeviceClientImpl);
 228 };
 229
 230 NfcDeviceClient::NfcDeviceClient() {
 231 }
 232
 233 NfcDeviceClient::~NfcDeviceClient() {
 234 }
 235
 236 NfcDeviceClient* NfcDeviceClient::Create(DBusClientImplementationType type,
 237                                          NfcAdapterClient* adapter_client) {
 238   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
 239     return new NfcDeviceClientImpl(adapter_client);
 240   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
 241   return new FakeNfcDeviceClient();
 242 }
 243
 244 }  // namespace chromeos