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:
CrasAudioClientImpl()26 CrasAudioClientImpl() : cras_proxy_(NULL), weak_ptr_factory_(this) {}
27
~CrasAudioClientImpl()28 virtual ~CrasAudioClientImpl() {
29 }
30
31 // CrasAudioClient overrides:
AddObserver(Observer * observer)32 virtual void AddObserver(Observer* observer) OVERRIDE {
33 observers_.AddObserver(observer);
34 }
35
RemoveObserver(Observer * observer)36 virtual void RemoveObserver(Observer* observer) OVERRIDE {
37 observers_.RemoveObserver(observer);
38 }
39
HasObserver(Observer * observer)40 virtual bool HasObserver(Observer* observer) OVERRIDE {
41 return observers_.HasObserver(observer);
42 }
43
GetVolumeState(const GetVolumeStateCallback & callback)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
GetNodes(const GetNodesCallback & callback,const ErrorCallback & error_callback)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
SetOutputNodeVolume(uint64 node_id,int32 volume)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
SetOutputUserMute(bool mute_on)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
SetInputNodeGain(uint64 node_id,int32 input_gain)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
SetInputMute(bool mute_on)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
SetActiveOutputNode(uint64 node_id)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
SetActiveInputNode(uint64 node_id)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:
Init(dbus::Bus * bus)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.
SignalConnected(const std::string & interface_name,const std::string & signal_name,bool success)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
NameOwnerChangedReceived(const std::string & old_owner,const std::string & new_owner)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.
OutputMuteChangedReceived(dbus::Signal * signal)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.
InputMuteChangedReceived(dbus::Signal * signal)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
NodesChangedReceived(dbus::Signal * signal)229 void NodesChangedReceived(dbus::Signal* signal) {
230 FOR_EACH_OBSERVER(Observer, observers_, NodesChanged());
231 }
232
ActiveOutputNodeChangedReceived(dbus::Signal * signal)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
ActiveInputNodeChangedReceived(dbus::Signal * signal)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
OnGetVolumeState(const GetVolumeStateCallback & callback,dbus::Response * response)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
OnGetNodes(const GetNodesCallback & callback,dbus::Response * response)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
OnError(const ErrorCallback & error_callback,dbus::ErrorResponse * response)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
GetAudioNode(dbus::Response * response,dbus::MessageReader * array_reader,AudioNode * node)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
~Observer()376 CrasAudioClient::Observer::~Observer() {
377 }
378
AudioClientRestarted()379 void CrasAudioClient::Observer::AudioClientRestarted() {
380 }
381
OutputMuteChanged(bool mute_on)382 void CrasAudioClient::Observer::OutputMuteChanged(bool mute_on) {
383 }
384
InputMuteChanged(bool mute_on)385 void CrasAudioClient::Observer::InputMuteChanged(bool mute_on) {
386 }
387
NodesChanged()388 void CrasAudioClient::Observer::NodesChanged() {
389 }
390
ActiveOutputNodeChanged(uint64 node_id)391 void CrasAudioClient::Observer::ActiveOutputNodeChanged(uint64 node_id){
392 }
393
ActiveInputNodeChanged(uint64 node_id)394 void CrasAudioClient::Observer::ActiveInputNodeChanged(uint64 node_id) {
395 }
396
CrasAudioClient()397 CrasAudioClient::CrasAudioClient() {
398 }
399
~CrasAudioClient()400 CrasAudioClient::~CrasAudioClient() {
401 }
402
403 // static
Create()404 CrasAudioClient* CrasAudioClient::Create() {
405 return new CrasAudioClientImpl();
406 }
407
408 } // namespace chromeos
409