chromeos/dbus/cras_audio_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/cras_audio_client.h"
   6
   7 #include "base/bind.h"
   8 #include "base/format_macros.h"
   9 #include "base/strings/stringprintf.h"
  10 #include "chromeos/dbus/cras_audio_client_stub_impl.h"
  11 #include "dbus/bus.h"
  12 #include "dbus/message.h"
  13 #include "dbus/object_path.h"
  14 #include "dbus/object_proxy.h"
  15 #include "third_party/cros_system_api/dbus/service_constants.h"
  16
  17 namespace chromeos {
  18
  19 // Error name if cras dbus call fails with empty ErrorResponse.
  20 const char kNoResponseError[] =
  21     "org.chromium.cras.Error.NoResponse";
  22
  23 // The CrasAudioClient implementation used in production.
  24 class CrasAudioClientImpl : public CrasAudioClient {
  25  public:
  26   CrasAudioClientImpl() : cras_proxy_(NULL), weak_ptr_factory_(this) {}
  27
  28   virtual ~CrasAudioClientImpl() {
  29   }
  30
  31   // CrasAudioClient overrides:
  32   virtual void AddObserver(Observer* observer) OVERRIDE {
  33     observers_.AddObserver(observer);
  34   }
  35
  36   virtual void RemoveObserver(Observer* observer) OVERRIDE {
  37     observers_.RemoveObserver(observer);
  38   }
  39
  40   virtual bool HasObserver(Observer* observer) OVERRIDE {
  41     return observers_.HasObserver(observer);
  42   }
  43
  44   virtual void GetVolumeState(const GetVolumeStateCallback& callback) OVERRIDE {
  45     dbus::MethodCall method_call(cras::kCrasControlInterface,
  46                                  cras::kGetVolumeState);
  47     cras_proxy_->CallMethod(
  48         &method_call,
  49         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
  50         base::Bind(&CrasAudioClientImpl::OnGetVolumeState,
  51                    weak_ptr_factory_.GetWeakPtr(), callback));
  52   }
  53
  54   virtual void GetNodes(const GetNodesCallback& callback,
  55                         const ErrorCallback& error_callback) OVERRIDE {
  56     dbus::MethodCall method_call(cras::kCrasControlInterface,
  57                                  cras::kGetNodes);
  58     cras_proxy_->CallMethodWithErrorCallback(
  59         &method_call,
  60         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
  61         base::Bind(&CrasAudioClientImpl::OnGetNodes,
  62                    weak_ptr_factory_.GetWeakPtr(), callback),
  63         base::Bind(&CrasAudioClientImpl::OnError,
  64                    weak_ptr_factory_.GetWeakPtr(), error_callback));
  65   }
  66
  67   virtual void SetOutputNodeVolume(uint64 node_id, int32 volume) OVERRIDE {
  68     dbus::MethodCall method_call(cras::kCrasControlInterface,
  69                                  cras::kSetOutputNodeVolume);
  70     dbus::MessageWriter writer(&method_call);
  71     writer.AppendUint64(node_id);
  72     writer.AppendInt32(volume);
  73     cras_proxy_->CallMethod(
  74         &method_call,
  75         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
  76         dbus::ObjectProxy::EmptyResponseCallback());
  77   }
  78
  79   virtual void SetOutputUserMute(bool mute_on) OVERRIDE {
  80     dbus::MethodCall method_call(cras::kCrasControlInterface,
  81                                  cras::kSetOutputUserMute);
  82     dbus::MessageWriter writer(&method_call);
  83     writer.AppendBool(mute_on);
  84     cras_proxy_->CallMethod(
  85         &method_call,
  86         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
  87         dbus::ObjectProxy::EmptyResponseCallback());
  88   }
  89
  90   virtual void SetInputNodeGain(uint64 node_id, int32 input_gain) OVERRIDE {
  91     dbus::MethodCall method_call(cras::kCrasControlInterface,
  92                                  cras::kSetInputNodeGain);
  93     dbus::MessageWriter writer(&method_call);
  94     writer.AppendUint64(node_id);
  95     writer.AppendInt32(input_gain);
  96     cras_proxy_->CallMethod(
  97         &method_call,
  98         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
  99         dbus::ObjectProxy::EmptyResponseCallback());
 100   }
 101
 102   virtual void SetInputMute(bool mute_on) OVERRIDE {
 103     dbus::MethodCall method_call(cras::kCrasControlInterface,
 104                                  cras::kSetInputMute);
 105     dbus::MessageWriter writer(&method_call);
 106     writer.AppendBool(mute_on);
 107     cras_proxy_->CallMethod(
 108         &method_call,
 109         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 110         dbus::ObjectProxy::EmptyResponseCallback());
 111   }
 112
 113   virtual void SetActiveOutputNode(uint64 node_id) OVERRIDE {
 114     dbus::MethodCall method_call(cras::kCrasControlInterface,
 115                                  cras::kSetActiveOutputNode);
 116     dbus::MessageWriter writer(&method_call);
 117     writer.AppendUint64(node_id);
 118     cras_proxy_->CallMethod(
 119         &method_call,
 120         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 121         dbus::ObjectProxy::EmptyResponseCallback());
 122   }
 123
 124   virtual void SetActiveInputNode(uint64 node_id) OVERRIDE {
 125     dbus::MethodCall method_call(cras::kCrasControlInterface,
 126                                  cras::kSetActiveInputNode);
 127     dbus::MessageWriter writer(&method_call);
 128     writer.AppendUint64(node_id);
 129     cras_proxy_->CallMethod(
 130         &method_call,
 131         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 132         dbus::ObjectProxy::EmptyResponseCallback());
 133   }
 134
 135  protected:
 136   virtual void Init(dbus::Bus* bus) OVERRIDE {
 137     cras_proxy_ = bus->GetObjectProxy(cras::kCrasServiceName,
 138                                       dbus::ObjectPath(cras::kCrasServicePath));
 139
 140     // Monitor NameOwnerChanged signal.
 141     cras_proxy_->SetNameOwnerChangedCallback(
 142         base::Bind(&CrasAudioClientImpl::NameOwnerChangedReceived,
 143                    weak_ptr_factory_.GetWeakPtr()));
 144
 145     // Monitor the D-Bus signal for output mute change.
 146     cras_proxy_->ConnectToSignal(
 147         cras::kCrasControlInterface,
 148         cras::kOutputMuteChanged,
 149         base::Bind(&CrasAudioClientImpl::OutputMuteChangedReceived,
 150                    weak_ptr_factory_.GetWeakPtr()),
 151         base::Bind(&CrasAudioClientImpl::SignalConnected,
 152                    weak_ptr_factory_.GetWeakPtr()));
 153
 154     // Monitor the D-Bus signal for input mute change.
 155     cras_proxy_->ConnectToSignal(
 156         cras::kCrasControlInterface,
 157         cras::kInputMuteChanged,
 158         base::Bind(&CrasAudioClientImpl::InputMuteChangedReceived,
 159                    weak_ptr_factory_.GetWeakPtr()),
 160         base::Bind(&CrasAudioClientImpl::SignalConnected,
 161                    weak_ptr_factory_.GetWeakPtr()));
 162
 163     // Monitor the D-Bus signal for nodes change.
 164     cras_proxy_->ConnectToSignal(
 165         cras::kCrasControlInterface,
 166         cras::kNodesChanged,
 167         base::Bind(&CrasAudioClientImpl::NodesChangedReceived,
 168                    weak_ptr_factory_.GetWeakPtr()),
 169         base::Bind(&CrasAudioClientImpl::SignalConnected,
 170                    weak_ptr_factory_.GetWeakPtr()));
 171
 172     // Monitor the D-Bus signal for active output node change.
 173     cras_proxy_->ConnectToSignal(
 174         cras::kCrasControlInterface,
 175         cras::kActiveOutputNodeChanged,
 176         base::Bind(&CrasAudioClientImpl::ActiveOutputNodeChangedReceived,
 177                    weak_ptr_factory_.GetWeakPtr()),
 178         base::Bind(&CrasAudioClientImpl::SignalConnected,
 179                    weak_ptr_factory_.GetWeakPtr()));
 180
 181     // Monitor the D-Bus signal for active input node change.
 182     cras_proxy_->ConnectToSignal(
 183         cras::kCrasControlInterface,
 184         cras::kActiveInputNodeChanged,
 185         base::Bind(&CrasAudioClientImpl::ActiveInputNodeChangedReceived,
 186                    weak_ptr_factory_.GetWeakPtr()),
 187         base::Bind(&CrasAudioClientImpl::SignalConnected,
 188                    weak_ptr_factory_.GetWeakPtr()));
 189   }
 190
 191  private:
 192   // Called when the cras signal is initially connected.
 193   void SignalConnected(const std::string& interface_name,
 194                        const std::string& signal_name,
 195                        bool success) {
 196     LOG_IF(ERROR, !success)
 197         << "Failed to connect to cras signal:" << signal_name;
 198   }
 199
 200   void NameOwnerChangedReceived(const std::string& old_owner,
 201                                 const std::string& new_owner) {
 202     FOR_EACH_OBSERVER(Observer, observers_, AudioClientRestarted());
 203   }
 204
 205   // Called when a OutputMuteChanged signal is received.
 206   void OutputMuteChangedReceived(dbus::Signal* signal) {
 207     // Chrome should always call SetOutputUserMute api to set the output
 208     // mute state and monitor user_mute state from OutputMuteChanged signal.
 209     dbus::MessageReader reader(signal);
 210     bool system_mute, user_mute;
 211     if (!reader.PopBool(&system_mute) || !reader.PopBool(&user_mute)) {
 212       LOG(ERROR) << "Error reading signal from cras:"
 213                  << signal->ToString();
 214     }
 215     FOR_EACH_OBSERVER(Observer, observers_, OutputMuteChanged(user_mute));
 216   }
 217
 218   // Called when a InputMuteChanged signal is received.
 219   void InputMuteChangedReceived(dbus::Signal* signal) {
 220     dbus::MessageReader reader(signal);
 221     bool mute;
 222     if (!reader.PopBool(&mute)) {
 223       LOG(ERROR) << "Error reading signal from cras:"
 224                  << signal->ToString();
 225     }
 226     FOR_EACH_OBSERVER(Observer, observers_, InputMuteChanged(mute));
 227   }
 228
 229   void NodesChangedReceived(dbus::Signal* signal) {
 230     FOR_EACH_OBSERVER(Observer, observers_, NodesChanged());
 231   }
 232
 233   void ActiveOutputNodeChangedReceived(dbus::Signal* signal) {
 234     dbus::MessageReader reader(signal);
 235     uint64 node_id;
 236     if (!reader.PopUint64(&node_id)) {
 237       LOG(ERROR) << "Error reading signal from cras:"
 238                  << signal->ToString();
 239     }
 240     FOR_EACH_OBSERVER(Observer, observers_, ActiveOutputNodeChanged(node_id));
 241   }
 242
 243   void ActiveInputNodeChangedReceived(dbus::Signal* signal) {
 244     dbus::MessageReader reader(signal);
 245     uint64 node_id;
 246     if (!reader.PopUint64(&node_id)) {
 247       LOG(ERROR) << "Error reading signal from cras:"
 248                  << signal->ToString();
 249     }
 250     FOR_EACH_OBSERVER(Observer, observers_, ActiveInputNodeChanged(node_id));
 251   }
 252
 253   void OnGetVolumeState(const GetVolumeStateCallback& callback,
 254                         dbus::Response* response) {
 255     bool success = true;
 256     VolumeState volume_state;
 257     if (response) {
 258       dbus::MessageReader reader(response);
 259       if (!reader.PopInt32(&volume_state.output_volume) ||
 260           !reader.PopBool(&volume_state.output_system_mute) ||
 261           !reader.PopInt32(&volume_state.input_gain) ||
 262           !reader.PopBool(&volume_state.input_mute) ||
 263           !reader.PopBool(&volume_state.output_user_mute)) {
 264         success = false;
 265         LOG(ERROR) << "Error reading response from cras: "
 266                    << response->ToString();
 267       }
 268     } else {
 269       success = false;
 270       LOG(ERROR) << "Error calling " << cras::kGetVolumeState;
 271     }
 272
 273     callback.Run(volume_state, success);
 274   }
 275
 276   void OnGetNodes(const GetNodesCallback& callback,
 277                   dbus::Response* response) {
 278     bool success = true;
 279     AudioNodeList node_list;
 280     if (response) {
 281       dbus::MessageReader response_reader(response);
 282       dbus::MessageReader array_reader(response);
 283       while (response_reader.HasMoreData()) {
 284         if (!response_reader.PopArray(&array_reader)) {
 285           success = false;
 286           LOG(ERROR) << "Error reading response from cras: "
 287                      << response->ToString();
 288           break;
 289         }
 290
 291         AudioNode node;
 292         if (!GetAudioNode(response, &array_reader, &node)) {
 293           success = false;
 294           LOG(WARNING) << "Error reading audio node data from cras: "
 295                        << response->ToString();
 296           break;
 297         }
 298         // Filter out the "UNKNOWN" type of audio devices.
 299         if (node.type != "UNKNOWN")
 300           node_list.push_back(node);
 301       }
 302     }
 303
 304     if (node_list.empty())
 305       return;
 306
 307     callback.Run(node_list, success);
 308   }
 309
 310   void OnError(const ErrorCallback& error_callback,
 311                dbus::ErrorResponse* response) {
 312     // Error response has optional error message argument.
 313     std::string error_name;
 314     std::string error_message;
 315     if (response) {
 316       dbus::MessageReader reader(response);
 317       error_name = response->GetErrorName();
 318       reader.PopString(&error_message);
 319     } else {
 320       error_name = kNoResponseError;
 321       error_message = "";
 322     }
 323     error_callback.Run(error_name, error_message);
 324   }
 325
 326   bool GetAudioNode(dbus::Response* response,
 327                     dbus::MessageReader* array_reader,
 328                     AudioNode *node) {
 329     while (array_reader->HasMoreData()) {
 330       dbus::MessageReader dict_entry_reader(response);
 331       dbus::MessageReader value_reader(response);
 332       std::string key;
 333       if (!array_reader->PopDictEntry(&dict_entry_reader) ||
 334           !dict_entry_reader.PopString(&key) ||
 335           !dict_entry_reader.PopVariant(&value_reader)) {
 336          return false;
 337       }
 338
 339       if (key == cras::kIsInputProperty) {
 340         if (!value_reader.PopBool(&node->is_input))
 341           return false;
 342       } else if (key == cras::kIdProperty) {
 343         if (!value_reader.PopUint64(&node->id))
 344           return false;
 345       } else if (key == cras::kDeviceNameProperty) {
 346         if (!value_reader.PopString(&node->device_name))
 347           return false;
 348       } else if (key == cras::kTypeProperty) {
 349         if (!value_reader.PopString(&node->type))
 350           return false;
 351       } else if (key == cras::kNameProperty) {
 352         if (!value_reader.PopString(&node->name))
 353           return false;
 354       } else if (key == cras::kActiveProperty) {
 355         if (!value_reader.PopBool(&node->active))
 356           return false;
 357       } else if (key == cras::kPluggedTimeProperty) {
 358         if (!value_reader.PopUint64(&node->plugged_time))
 359           return false;
 360       }
 361     }
 362
 363     return true;
 364   }
 365
 366   dbus::ObjectProxy* cras_proxy_;
 367   ObserverList<Observer> observers_;
 368
 369   // Note: This should remain the last member so it'll be destroyed and
 370   // invalidate its weak pointers before any other members are destroyed.
 371   base::WeakPtrFactory<CrasAudioClientImpl> weak_ptr_factory_;
 372
 373   DISALLOW_COPY_AND_ASSIGN(CrasAudioClientImpl);
 374 };
 375
 376 CrasAudioClient::Observer::~Observer() {
 377 }
 378
 379 void CrasAudioClient::Observer::AudioClientRestarted() {
 380 }
 381
 382 void CrasAudioClient::Observer::OutputMuteChanged(bool mute_on) {
 383 }
 384
 385 void CrasAudioClient::Observer::InputMuteChanged(bool mute_on) {
 386 }
 387
 388 void CrasAudioClient::Observer::NodesChanged() {
 389 }
 390
 391 void CrasAudioClient::Observer::ActiveOutputNodeChanged(uint64 node_id){
 392 }
 393
 394 void CrasAudioClient::Observer::ActiveInputNodeChanged(uint64 node_id) {
 395 }
 396
 397 CrasAudioClient::CrasAudioClient() {
 398 }
 399
 400 CrasAudioClient::~CrasAudioClient() {
 401 }
 402
 403 // static
 404 CrasAudioClient* CrasAudioClient::Create() {
 405   return new CrasAudioClientImpl();
 406 }
 407
 408 }  // namespace chromeos