chromeos/dbus/shill_service_client.cc

   1 // Copyright (c) 2012 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/shill_service_client.h"
   6
   7 #include "base/bind.h"
   8 #include "base/chromeos/chromeos_version.h"
   9 #include "base/message_loop.h"
  10 #include "base/stl_util.h"
  11 #include "base/values.h"
  12 #include "chromeos/dbus/shill_property_changed_observer.h"
  13 #include "chromeos/dbus/shill_service_client_stub.h"
  14 #include "dbus/bus.h"
  15 #include "dbus/message.h"
  16 #include "dbus/object_proxy.h"
  17 #include "third_party/cros_system_api/dbus/service_constants.h"
  18
  19 namespace chromeos {
  20
  21 namespace {
  22
  23 // Error callback for GetProperties.
  24 void OnGetPropertiesError(
  25     const dbus::ObjectPath& service_path,
  26     const ShillServiceClient::DictionaryValueCallback& callback,
  27     const std::string& error_name,
  28     const std::string& error_message) {
  29   const std::string log_string =
  30       "Failed to call org.chromium.shill.Service.GetProperties for: " +
  31       service_path.value() + ": " + error_name + ": " + error_message;
  32
  33   // Suppress ERROR log if error name is
  34   // "org.freedesktop.DBus.Error.UnknownMethod". crbug.com/130660
  35   if (error_name == DBUS_ERROR_UNKNOWN_METHOD)
  36     VLOG(1) << log_string;
  37   else
  38     LOG(ERROR) << log_string;
  39
  40   base::DictionaryValue empty_dictionary;
  41   callback.Run(DBUS_METHOD_CALL_FAILURE, empty_dictionary);
  42 }
  43
  44 // The ShillServiceClient implementation.
  45 class ShillServiceClientImpl : public ShillServiceClient {
  46  public:
  47   explicit ShillServiceClientImpl(dbus::Bus* bus)
  48       : bus_(bus),
  49         helpers_deleter_(&helpers_) {
  50   }
  51
  52   /////////////////////////////////////
  53   // ShillServiceClient overrides.
  54   virtual void AddPropertyChangedObserver(
  55       const dbus::ObjectPath& service_path,
  56       ShillPropertyChangedObserver* observer) OVERRIDE {
  57     GetHelper(service_path)->AddPropertyChangedObserver(observer);
  58   }
  59
  60   virtual void RemovePropertyChangedObserver(
  61       const dbus::ObjectPath& service_path,
  62       ShillPropertyChangedObserver* observer) OVERRIDE {
  63     GetHelper(service_path)->RemovePropertyChangedObserver(observer);
  64   }
  65
  66   virtual void GetProperties(const dbus::ObjectPath& service_path,
  67                              const DictionaryValueCallback& callback) OVERRIDE {
  68     dbus::MethodCall method_call(flimflam::kFlimflamServiceInterface,
  69                                  flimflam::kGetPropertiesFunction);
  70     GetHelper(service_path)->CallDictionaryValueMethodWithErrorCallback(
  71         &method_call,
  72         base::Bind(callback, DBUS_METHOD_CALL_SUCCESS),
  73         base::Bind(&OnGetPropertiesError, service_path, callback));
  74   }
  75
  76   virtual void SetProperty(const dbus::ObjectPath& service_path,
  77                            const std::string& name,
  78                            const base::Value& value,
  79                            const base::Closure& callback,
  80                            const ErrorCallback& error_callback) OVERRIDE {
  81     dbus::MethodCall method_call(flimflam::kFlimflamServiceInterface,
  82                                  flimflam::kSetPropertyFunction);
  83     dbus::MessageWriter writer(&method_call);
  84     writer.AppendString(name);
  85     ShillClientHelper::AppendValueDataAsVariant(&writer, value);
  86     GetHelper(service_path)->CallVoidMethodWithErrorCallback(&method_call,
  87                                                              callback,
  88                                                              error_callback);
  89   }
  90
  91   virtual void ClearProperty(const dbus::ObjectPath& service_path,
  92                              const std::string& name,
  93                              const base::Closure& callback,
  94                              const ErrorCallback& error_callback) OVERRIDE {
  95     dbus::MethodCall method_call(flimflam::kFlimflamServiceInterface,
  96                                  flimflam::kClearPropertyFunction);
  97     dbus::MessageWriter writer(&method_call);
  98     writer.AppendString(name);
  99     GetHelper(service_path)->CallVoidMethodWithErrorCallback(&method_call,
 100                                                              callback,
 101                                                              error_callback);
 102   }
 103
 104
 105   virtual void ClearProperties(const dbus::ObjectPath& service_path,
 106                                const std::vector<std::string>& names,
 107                                const ListValueCallback& callback,
 108                                const ErrorCallback& error_callback) OVERRIDE {
 109     dbus::MethodCall method_call(flimflam::kFlimflamServiceInterface,
 110                                  shill::kClearPropertiesFunction);
 111     dbus::MessageWriter writer(&method_call);
 112     writer.AppendArrayOfStrings(names);
 113     GetHelper(service_path)->CallListValueMethodWithErrorCallback(
 114         &method_call,
 115         callback,
 116         error_callback);
 117   }
 118
 119   virtual void Connect(const dbus::ObjectPath& service_path,
 120                        const base::Closure& callback,
 121                        const ErrorCallback& error_callback) OVERRIDE {
 122     dbus::MethodCall method_call(flimflam::kFlimflamServiceInterface,
 123                                  flimflam::kConnectFunction);
 124     GetHelper(service_path)->CallVoidMethodWithErrorCallback(
 125         &method_call, callback, error_callback);
 126   }
 127
 128   virtual void Disconnect(const dbus::ObjectPath& service_path,
 129                           const base::Closure& callback,
 130                           const ErrorCallback& error_callback) OVERRIDE {
 131     dbus::MethodCall method_call(flimflam::kFlimflamServiceInterface,
 132                                  flimflam::kDisconnectFunction);
 133     GetHelper(service_path)->CallVoidMethodWithErrorCallback(&method_call,
 134                                                              callback,
 135                                                              error_callback);
 136   }
 137
 138   virtual void Remove(const dbus::ObjectPath& service_path,
 139                       const base::Closure& callback,
 140                       const ErrorCallback& error_callback) OVERRIDE {
 141     dbus::MethodCall method_call(flimflam::kFlimflamServiceInterface,
 142                                  flimflam::kRemoveServiceFunction);
 143     GetHelper(service_path)->CallVoidMethodWithErrorCallback(&method_call,
 144                                                              callback,
 145                                                              error_callback);
 146   }
 147
 148   virtual void ActivateCellularModem(
 149       const dbus::ObjectPath& service_path,
 150       const std::string& carrier,
 151       const base::Closure& callback,
 152       const ErrorCallback& error_callback) OVERRIDE {
 153     dbus::MethodCall method_call(flimflam::kFlimflamServiceInterface,
 154                                  flimflam::kActivateCellularModemFunction);
 155     dbus::MessageWriter writer(&method_call);
 156     writer.AppendString(carrier);
 157     GetHelper(service_path)->CallVoidMethodWithErrorCallback(&method_call,
 158                                                              callback,
 159                                                              error_callback);
 160   }
 161
 162   virtual void CompleteCellularActivation(
 163       const dbus::ObjectPath& service_path,
 164       const base::Closure& callback,
 165       const ErrorCallback& error_callback) OVERRIDE {
 166     dbus::MethodCall method_call(flimflam::kFlimflamServiceInterface,
 167                                  shill::kCompleteCellularActivationFunction);
 168     dbus::MessageWriter writer(&method_call);
 169     GetHelper(service_path)->CallVoidMethodWithErrorCallback(&method_call,
 170                                                              callback,
 171                                                              error_callback);
 172   }
 173
 174   virtual bool CallActivateCellularModemAndBlock(
 175       const dbus::ObjectPath& service_path,
 176       const std::string& carrier) OVERRIDE {
 177     dbus::MethodCall method_call(flimflam::kFlimflamServiceInterface,
 178                                  flimflam::kActivateCellularModemFunction);
 179     dbus::MessageWriter writer(&method_call);
 180     writer.AppendString(carrier);
 181     return GetHelper(service_path)->CallVoidMethodAndBlock(&method_call);
 182   }
 183
 184   virtual ShillServiceClient::TestInterface* GetTestInterface() OVERRIDE {
 185     return NULL;
 186   }
 187
 188  private:
 189   typedef std::map<std::string, ShillClientHelper*> HelperMap;
 190
 191   // Returns the corresponding ShillClientHelper for the profile.
 192   ShillClientHelper* GetHelper(const dbus::ObjectPath& service_path) {
 193     HelperMap::iterator it = helpers_.find(service_path.value());
 194     if (it != helpers_.end())
 195       return it->second;
 196
 197     // There is no helper for the profile, create it.
 198     dbus::ObjectProxy* object_proxy =
 199         bus_->GetObjectProxy(flimflam::kFlimflamServiceName, service_path);
 200     ShillClientHelper* helper = new ShillClientHelper(bus_, object_proxy);
 201     helper->MonitorPropertyChanged(flimflam::kFlimflamServiceInterface);
 202     helpers_.insert(HelperMap::value_type(service_path.value(), helper));
 203     return helper;
 204   }
 205
 206   dbus::Bus* bus_;
 207   HelperMap helpers_;
 208   STLValueDeleter<HelperMap> helpers_deleter_;
 209
 210   DISALLOW_COPY_AND_ASSIGN(ShillServiceClientImpl);
 211 };
 212
 213 }  // namespace
 214
 215 ShillServiceClient::ShillServiceClient() {}
 216
 217 ShillServiceClient::~ShillServiceClient() {}
 218
 219 // static
 220 ShillServiceClient* ShillServiceClient::Create(
 221     DBusClientImplementationType type,
 222     dbus::Bus* bus) {
 223   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
 224     return new ShillServiceClientImpl(bus);
 225   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
 226   return new ShillServiceClientStub();
 227 }
 228
 229 }  // namespace chromeos