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