2 This file is part of PulseAudio.
4 Copyright 2009 Tanu Kaskinen
6 PulseAudio is free software; you can redistribute it and/or modify
7 it under the terms of the GNU Lesser General Public License as published
8 by the Free Software Foundation; either version 2.1 of the License,
9 or (at your option) any later version.
11 PulseAudio is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with PulseAudio; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
26 #include <dbus/dbus.h>
28 #include <pulsecore/core-util.h>
29 #include <pulsecore/dbus-util.h>
30 #include <pulsecore/protocol-dbus.h>
32 #include "iface-card-profile.h"
34 #include "iface-card.h"
36 #define OBJECT_NAME "card"
38 static void handle_get_index(DBusConnection *conn, DBusMessage *msg, void *userdata);
39 static void handle_get_name(DBusConnection *conn, DBusMessage *msg, void *userdata);
40 static void handle_get_driver(DBusConnection *conn, DBusMessage *msg, void *userdata);
41 static void handle_get_owner_module(DBusConnection *conn, DBusMessage *msg, void *userdata);
42 static void handle_get_sinks(DBusConnection *conn, DBusMessage *msg, void *userdata);
43 static void handle_get_sources(DBusConnection *conn, DBusMessage *msg, void *userdata);
44 static void handle_get_profiles(DBusConnection *conn, DBusMessage *msg, void *userdata);
45 static void handle_get_active_profile(DBusConnection *conn, DBusMessage *msg, void *userdata);
46 static void handle_set_active_profile(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata);
47 static void handle_get_property_list(DBusConnection *conn, DBusMessage *msg, void *userdata);
49 static void handle_get_all(DBusConnection *conn, DBusMessage *msg, void *userdata);
51 static void handle_get_profile_by_name(DBusConnection *conn, DBusMessage *msg, void *userdata);
53 struct pa_dbusiface_card {
54 pa_dbusiface_core *core;
59 uint32_t next_profile_index;
60 pa_card_profile *active_profile;
61 pa_proplist *proplist;
63 pa_hook_slot *card_profile_added_slot;
65 pa_dbus_protocol *dbus_protocol;
66 pa_subscription *subscription;
69 enum property_handler_index {
70 PROPERTY_HANDLER_INDEX,
71 PROPERTY_HANDLER_NAME,
72 PROPERTY_HANDLER_DRIVER,
73 PROPERTY_HANDLER_OWNER_MODULE,
74 PROPERTY_HANDLER_SINKS,
75 PROPERTY_HANDLER_SOURCES,
76 PROPERTY_HANDLER_PROFILES,
77 PROPERTY_HANDLER_ACTIVE_PROFILE,
78 PROPERTY_HANDLER_PROPERTY_LIST,
82 static pa_dbus_property_handler property_handlers[PROPERTY_HANDLER_MAX] = {
83 [PROPERTY_HANDLER_INDEX] = { .property_name = "Index", .type = "u", .get_cb = handle_get_index, .set_cb = NULL },
84 [PROPERTY_HANDLER_NAME] = { .property_name = "Name", .type = "s", .get_cb = handle_get_name, .set_cb = NULL },
85 [PROPERTY_HANDLER_DRIVER] = { .property_name = "Driver", .type = "s", .get_cb = handle_get_driver, .set_cb = NULL },
86 [PROPERTY_HANDLER_OWNER_MODULE] = { .property_name = "OwnerModule", .type = "o", .get_cb = handle_get_owner_module, .set_cb = NULL },
87 [PROPERTY_HANDLER_SINKS] = { .property_name = "Sinks", .type = "ao", .get_cb = handle_get_sinks, .set_cb = NULL },
88 [PROPERTY_HANDLER_SOURCES] = { .property_name = "Sources", .type = "ao", .get_cb = handle_get_sources, .set_cb = NULL },
89 [PROPERTY_HANDLER_PROFILES] = { .property_name = "Profiles", .type = "ao", .get_cb = handle_get_profiles, .set_cb = NULL },
90 [PROPERTY_HANDLER_ACTIVE_PROFILE] = { .property_name = "ActiveProfile", .type = "o", .get_cb = handle_get_active_profile, .set_cb = handle_set_active_profile },
91 [PROPERTY_HANDLER_PROPERTY_LIST] = { .property_name = "PropertyList", .type = "a{say}", .get_cb = handle_get_property_list, .set_cb = NULL }
94 enum method_handler_index {
95 METHOD_HANDLER_GET_PROFILE_BY_NAME,
99 static pa_dbus_arg_info get_profile_by_name_args[] = { { "name", "s", "in" }, { "profile", "o", "out" } };
101 static pa_dbus_method_handler method_handlers[METHOD_HANDLER_MAX] = {
102 [METHOD_HANDLER_GET_PROFILE_BY_NAME] = {
103 .method_name = "GetProfileByName",
104 .arguments = get_profile_by_name_args,
105 .n_arguments = sizeof(get_profile_by_name_args) / sizeof(pa_dbus_arg_info),
106 .receive_cb = handle_get_profile_by_name }
110 SIGNAL_ACTIVE_PROFILE_UPDATED,
112 SIGNAL_PROPERTY_LIST_UPDATED,
116 static pa_dbus_arg_info active_profile_updated_args[] = { { "profile", "o", NULL } };
117 static pa_dbus_arg_info new_profile_args[] = { { "profile", "o", NULL } };
118 static pa_dbus_arg_info property_list_updated_args[] = { { "property_list", "a{say}", NULL } };
120 static pa_dbus_signal_info signals[SIGNAL_MAX] = {
121 [SIGNAL_ACTIVE_PROFILE_UPDATED] = { .name = "ActiveProfileUpdated", .arguments = active_profile_updated_args, .n_arguments = 1 },
122 [SIGNAL_NEW_PROFILE] = { .name = "NewProfile", .arguments = new_profile_args, .n_arguments = 1 },
123 [SIGNAL_PROPERTY_LIST_UPDATED] = { .name = "PropertyListUpdated", .arguments = property_list_updated_args, .n_arguments = 1 }
126 static pa_dbus_interface_info card_interface_info = {
127 .name = PA_DBUSIFACE_CARD_INTERFACE,
128 .method_handlers = method_handlers,
129 .n_method_handlers = METHOD_HANDLER_MAX,
130 .property_handlers = property_handlers,
131 .n_property_handlers = PROPERTY_HANDLER_MAX,
132 .get_all_properties_cb = handle_get_all,
134 .n_signals = SIGNAL_MAX
137 static void handle_get_index(DBusConnection *conn, DBusMessage *msg, void *userdata) {
138 pa_dbusiface_card *c = userdata;
145 idx = c->card->index;
147 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &idx);
150 static void handle_get_name(DBusConnection *conn, DBusMessage *msg, void *userdata) {
151 pa_dbusiface_card *c = userdata;
157 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_STRING, &c->card->name);
160 static void handle_get_driver(DBusConnection *conn, DBusMessage *msg, void *userdata) {
161 pa_dbusiface_card *c = userdata;
167 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_STRING, &c->card->driver);
170 static void handle_get_owner_module(DBusConnection *conn, DBusMessage *msg, void *userdata) {
171 pa_dbusiface_card *c = userdata;
172 const char *owner_module;
178 if (!c->card->module) {
179 pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NO_SUCH_PROPERTY, "Card %s doesn't have an owner module.", c->card->name);
183 owner_module = pa_dbusiface_core_get_module_path(c->core, c->card->module);
185 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &owner_module);
188 /* The caller frees the array, but not the strings. */
189 static const char **get_sinks(pa_dbusiface_card *c, unsigned *n) {
190 const char **sinks = NULL;
193 pa_sink *sink = NULL;
198 *n = pa_idxset_size(c->card->sinks);
203 sinks = pa_xnew(const char *, *n);
205 PA_IDXSET_FOREACH(sink, c->card->sinks, idx) {
206 sinks[i] = pa_dbusiface_core_get_sink_path(c->core, sink);
213 static void handle_get_sinks(DBusConnection *conn, DBusMessage *msg, void *userdata) {
214 pa_dbusiface_card *c = userdata;
222 sinks = get_sinks(c, &n_sinks);
224 pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, sinks, n_sinks);
229 /* The caller frees the array, but not the strings. */
230 static const char **get_sources(pa_dbusiface_card *c, unsigned *n) {
231 const char **sources = NULL;
234 pa_source *source = NULL;
239 *n = pa_idxset_size(c->card->sources);
244 sources = pa_xnew(const char *, *n);
246 PA_IDXSET_FOREACH(source, c->card->sinks, idx) {
247 sources[i] = pa_dbusiface_core_get_source_path(c->core, source);
254 static void handle_get_sources(DBusConnection *conn, DBusMessage *msg, void *userdata) {
255 pa_dbusiface_card *c = userdata;
256 const char **sources;
263 sources = get_sources(c, &n_sources);
265 pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, sources, n_sources);
270 /* The caller frees the array, but not the strings. */
271 static const char **get_profiles(pa_dbusiface_card *c, unsigned *n) {
272 const char **profiles;
275 pa_dbusiface_card_profile *profile;
280 *n = pa_hashmap_size(c->profiles);
285 profiles = pa_xnew(const char *, *n);
287 PA_HASHMAP_FOREACH(profile, c->profiles, state)
288 profiles[i++] = pa_dbusiface_card_profile_get_path(profile);
293 static void handle_get_profiles(DBusConnection *conn, DBusMessage *msg, void *userdata) {
294 pa_dbusiface_card *c = userdata;
295 const char **profiles;
302 profiles = get_profiles(c, &n_profiles);
304 pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, profiles, n_profiles);
309 static void handle_get_active_profile(DBusConnection *conn, DBusMessage *msg, void *userdata) {
310 pa_dbusiface_card *c = userdata;
311 const char *active_profile;
317 active_profile = pa_dbusiface_card_profile_get_path(pa_hashmap_get(c->profiles, c->active_profile->name));
318 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &active_profile);
321 static void handle_set_active_profile(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata) {
322 pa_dbusiface_card *c = userdata;
323 const char *new_active_path;
324 pa_dbusiface_card_profile *new_active;
332 dbus_message_iter_get_basic(iter, &new_active_path);
334 if (!(new_active = pa_hashmap_get(c->profiles, new_active_path))) {
335 pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "%s: No such profile.", new_active_path);
339 if ((r = pa_card_set_profile(c->card, pa_dbusiface_card_profile_get_name(new_active), true)) < 0) {
340 pa_dbus_send_error(conn, msg, DBUS_ERROR_FAILED,
341 "Internal error in PulseAudio: pa_card_set_profile() failed with error code %i.", r);
345 pa_dbus_send_empty_reply(conn, msg);
348 static void handle_get_property_list(DBusConnection *conn, DBusMessage *msg, void *userdata) {
349 pa_dbusiface_card *c = userdata;
355 pa_dbus_send_proplist_variant_reply(conn, msg, c->proplist);
358 static void handle_get_all(DBusConnection *conn, DBusMessage *msg, void *userdata) {
359 pa_dbusiface_card *c = userdata;
360 DBusMessage *reply = NULL;
361 DBusMessageIter msg_iter;
362 DBusMessageIter dict_iter;
364 const char *owner_module = NULL;
365 const char **sinks = NULL;
366 unsigned n_sinks = 0;
367 const char **sources = NULL;
368 unsigned n_sources = 0;
369 const char **profiles = NULL;
370 unsigned n_profiles = 0;
371 const char *active_profile = NULL;
377 idx = c->card->index;
379 owner_module = pa_dbusiface_core_get_module_path(c->core, c->card->module);
380 sinks = get_sinks(c, &n_sinks);
381 sources = get_sources(c, &n_sources);
382 profiles = get_profiles(c, &n_profiles);
383 active_profile = pa_dbusiface_card_profile_get_path(pa_hashmap_get(c->profiles, c->active_profile->name));
385 pa_assert_se((reply = dbus_message_new_method_return(msg)));
387 dbus_message_iter_init_append(reply, &msg_iter);
388 pa_assert_se(dbus_message_iter_open_container(&msg_iter, DBUS_TYPE_ARRAY, "{sv}", &dict_iter));
390 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_INDEX].property_name, DBUS_TYPE_UINT32, &idx);
391 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_NAME].property_name, DBUS_TYPE_STRING, &c->card->name);
392 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_DRIVER].property_name, DBUS_TYPE_STRING, &c->card->driver);
395 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_OWNER_MODULE].property_name, DBUS_TYPE_OBJECT_PATH, &owner_module);
397 pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_SINKS].property_name, DBUS_TYPE_OBJECT_PATH, sinks, n_sinks);
398 pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_SOURCES].property_name, DBUS_TYPE_OBJECT_PATH, sources, n_sources);
399 pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_PROFILES].property_name, DBUS_TYPE_OBJECT_PATH, profiles, n_profiles);
400 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_ACTIVE_PROFILE].property_name, DBUS_TYPE_OBJECT_PATH, &active_profile);
402 pa_dbus_append_proplist_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_PROPERTY_LIST].property_name, c->proplist);
404 pa_assert_se(dbus_message_iter_close_container(&msg_iter, &dict_iter));
406 pa_assert_se(dbus_connection_send(conn, reply, NULL));
408 dbus_message_unref(reply);
415 static void handle_get_profile_by_name(DBusConnection *conn, DBusMessage *msg, void *userdata) {
416 pa_dbusiface_card *c = userdata;
417 const char *profile_name = NULL;
418 pa_dbusiface_card_profile *profile = NULL;
419 const char *profile_path = NULL;
425 pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &profile_name, DBUS_TYPE_INVALID));
427 if (!(profile = pa_hashmap_get(c->profiles, profile_name))) {
428 pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "%s: No such profile on card %s.", profile_name, c->card->name);
432 profile_path = pa_dbusiface_card_profile_get_path(profile);
434 pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &profile_path);
437 static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint32_t idx, void *userdata) {
438 pa_dbusiface_card *c = userdata;
439 DBusMessage *signal_msg = NULL;
442 pa_assert((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_CARD);
445 /* We can't use idx != c->card->index, because the c->card pointer may
446 * be stale at this point. */
447 if (pa_idxset_get_by_index(core->cards, idx) != c->card)
450 if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) != PA_SUBSCRIPTION_EVENT_CHANGE)
453 if (c->active_profile != c->card->active_profile) {
454 const char *object_path;
456 c->active_profile = c->card->active_profile;
457 object_path = pa_dbusiface_card_profile_get_path(pa_hashmap_get(c->profiles, c->active_profile->name));
459 pa_assert_se(signal_msg = dbus_message_new_signal(c->path,
460 PA_DBUSIFACE_CARD_INTERFACE,
461 signals[SIGNAL_ACTIVE_PROFILE_UPDATED].name));
462 pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
464 pa_dbus_protocol_send_signal(c->dbus_protocol, signal_msg);
465 dbus_message_unref(signal_msg);
469 if (!pa_proplist_equal(c->proplist, c->card->proplist)) {
470 DBusMessageIter msg_iter;
472 pa_proplist_update(c->proplist, PA_UPDATE_SET, c->card->proplist);
474 pa_assert_se(signal_msg = dbus_message_new_signal(c->path,
475 PA_DBUSIFACE_CARD_INTERFACE,
476 signals[SIGNAL_PROPERTY_LIST_UPDATED].name));
477 dbus_message_iter_init_append(signal_msg, &msg_iter);
478 pa_dbus_append_proplist(&msg_iter, c->proplist);
480 pa_dbus_protocol_send_signal(c->dbus_protocol, signal_msg);
481 dbus_message_unref(signal_msg);
486 static pa_hook_result_t card_profile_added_cb(void *hook_data, void *call_data, void *slot_data) {
487 pa_core *core = hook_data;
488 pa_dbusiface_card *c = slot_data;
489 pa_card_profile *profile = call_data;
490 pa_dbusiface_card_profile *p;
491 const char *object_path;
492 DBusMessage *signal_msg;
494 if (profile->card != c->card)
497 p = pa_dbusiface_card_profile_new(c, core, profile, c->next_profile_index++);
498 pa_assert_se(pa_hashmap_put(c->profiles, pa_dbusiface_card_profile_get_name(p), p) >= 0);
500 /* Send D-Bus signal */
501 object_path = pa_dbusiface_card_profile_get_path(p);
503 pa_assert_se(signal_msg = dbus_message_new_signal(c->path,
504 PA_DBUSIFACE_CARD_INTERFACE,
505 signals[SIGNAL_NEW_PROFILE].name));
506 pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
508 pa_dbus_protocol_send_signal(c->dbus_protocol, signal_msg);
509 dbus_message_unref(signal_msg);
514 pa_dbusiface_card *pa_dbusiface_card_new(pa_dbusiface_core *core, pa_card *card) {
515 pa_dbusiface_card *c = NULL;
516 pa_card_profile *profile;
522 c = pa_xnew0(pa_dbusiface_card, 1);
525 c->path = pa_sprintf_malloc("%s/%s%u", PA_DBUS_CORE_OBJECT_PATH, OBJECT_NAME, card->index);
526 c->profiles = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
527 c->next_profile_index = 0;
528 c->active_profile = card->active_profile;
529 c->proplist = pa_proplist_copy(card->proplist);
530 c->dbus_protocol = pa_dbus_protocol_get(card->core);
531 c->subscription = pa_subscription_new(card->core, PA_SUBSCRIPTION_MASK_CARD, subscription_cb, c);
533 PA_HASHMAP_FOREACH(profile, card->profiles, state) {
534 pa_dbusiface_card_profile *p = pa_dbusiface_card_profile_new(c, card->core, profile, c->next_profile_index++);
535 pa_hashmap_put(c->profiles, pa_dbusiface_card_profile_get_name(p), p);
538 pa_assert_se(pa_dbus_protocol_add_interface(c->dbus_protocol, c->path, &card_interface_info, c) >= 0);
540 c->card_profile_added_slot = pa_hook_connect(&card->core->hooks[PA_CORE_HOOK_CARD_PROFILE_ADDED], PA_HOOK_NORMAL,
541 card_profile_added_cb, c);
546 void pa_dbusiface_card_free(pa_dbusiface_card *c) {
549 pa_assert_se(pa_dbus_protocol_remove_interface(c->dbus_protocol, c->path, card_interface_info.name) >= 0);
551 pa_hook_slot_free(c->card_profile_added_slot);
553 pa_hashmap_free(c->profiles, (pa_free_cb_t) pa_dbusiface_card_profile_free);
554 pa_proplist_free(c->proplist);
555 pa_dbus_protocol_unref(c->dbus_protocol);
556 pa_subscription_free(c->subscription);
562 const char *pa_dbusiface_card_get_path(pa_dbusiface_card *c) {