mirrors/pulseaudio
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pulseaudio/pulseaudio.git synced 2025-11-04 13:29:59 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Rename all the signal parameters and variables to something more explicit.

Browse source 
Without this change, on FreeBSD you'll be bothered by tons of warnings
about overshadowing signal(2).
This commit is contained in:
Diego Elio 'Flameeyes' Pettenò 2009-11-21 00:30:46 +01:00
parent 2caf59d49f
commit d963998676
10 changed files with 307 additions and 307 deletions
Download patch file Download diff file Expand all files Collapse all files

22
src/modules/dbus/iface-card.c
View file

@ -452,7 +452,7 @@ static void handle_get_profile_by_name(DBusConnection *conn, DBusMessage *msg, v
static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint32_t idx, void *userdata) { static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint32_t idx, void *userdata) {
pa_dbusiface_card *c = userdata; pa_dbusiface_card *c = userdata;
DBusMessage *signal = NULL; DBusMessage *signal_msg = NULL;
pa_assert(core); pa_assert(core);
pa_assert((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_CARD); pa_assert((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_CARD);
@ -472,14 +472,14 @@ static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint3
c->active_profile = c->card->active_profile; c->active_profile = c->card->active_profile;
object_path = pa_dbusiface_card_profile_get_path(pa_hashmap_get(c->profiles, c->active_profile->name)); object_path = pa_dbusiface_card_profile_get_path(pa_hashmap_get(c->profiles, c->active_profile->name));
pa_assert_se(signal = dbus_message_new_signal(c->path, pa_assert_se(signal_msg = dbus_message_new_signal(c->path,
PA_DBUSIFACE_CARD_INTERFACE, PA_DBUSIFACE_CARD_INTERFACE,
signals[SIGNAL_ACTIVE_PROFILE_UPDATED].name)); signals[SIGNAL_ACTIVE_PROFILE_UPDATED].name));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
pa_dbus_protocol_send_signal(c->dbus_protocol, signal); pa_dbus_protocol_send_signal(c->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
signal = NULL; signal_msg = NULL;
} }
if (!pa_proplist_equal(c->proplist, c->card->proplist)) { if (!pa_proplist_equal(c->proplist, c->card->proplist)) {
@ -487,15 +487,15 @@ static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint3
pa_proplist_update(c->proplist, PA_UPDATE_SET, c->card->proplist); pa_proplist_update(c->proplist, PA_UPDATE_SET, c->card->proplist);
pa_assert_se(signal = dbus_message_new_signal(c->path, pa_assert_se(signal_msg = dbus_message_new_signal(c->path,
PA_DBUSIFACE_CARD_INTERFACE, PA_DBUSIFACE_CARD_INTERFACE,
signals[SIGNAL_PROPERTY_LIST_UPDATED].name)); signals[SIGNAL_PROPERTY_LIST_UPDATED].name));
dbus_message_iter_init_append(signal, &msg_iter); dbus_message_iter_init_append(signal_msg, &msg_iter);
pa_dbus_append_proplist(&msg_iter, c->proplist); pa_dbus_append_proplist(&msg_iter, c->proplist);
pa_dbus_protocol_send_signal(c->dbus_protocol, signal); pa_dbus_protocol_send_signal(c->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
signal = NULL; signal_msg = NULL;
} }
} }

12
src/modules/dbus/iface-client.c
View file

@ -391,7 +391,7 @@ static void handle_remove_properties(DBusConnection *conn, DBusMessage *msg, voi
static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint32_t idx, void *userdata) { static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint32_t idx, void *userdata) {
pa_dbusiface_client *c = userdata; pa_dbusiface_client *c = userdata;
DBusMessage *signal = NULL; DBusMessage *signal_msg = NULL;
pa_assert(core); pa_assert(core);
pa_assert((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_CLIENT); pa_assert((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_CLIENT);
@ -410,15 +410,15 @@ static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint3
pa_proplist_update(c->proplist, PA_UPDATE_SET, c->client->proplist); pa_proplist_update(c->proplist, PA_UPDATE_SET, c->client->proplist);
pa_assert_se(signal = dbus_message_new_signal(c->path, pa_assert_se(signal_msg = dbus_message_new_signal(c->path,
PA_DBUSIFACE_CLIENT_INTERFACE, PA_DBUSIFACE_CLIENT_INTERFACE,
signals[SIGNAL_PROPERTY_LIST_UPDATED].name)); signals[SIGNAL_PROPERTY_LIST_UPDATED].name));
dbus_message_iter_init_append(signal, &msg_iter); dbus_message_iter_init_append(signal_msg, &msg_iter);
pa_dbus_append_proplist(&msg_iter, c->proplist); pa_dbus_append_proplist(&msg_iter, c->proplist);
pa_dbus_protocol_send_signal(c->dbus_protocol, signal); pa_dbus_protocol_send_signal(c->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
signal = NULL; signal_msg = NULL;
} }
} }

172
src/modules/dbus/iface-core.c
View file

@ -1488,7 +1488,7 @@ static void handle_exit(DBusConnection *conn, DBusMessage *msg, void *userdata)
static void handle_listen_for_signal(DBusConnection *conn, DBusMessage *msg, void *userdata) { static void handle_listen_for_signal(DBusConnection *conn, DBusMessage *msg, void *userdata) {
pa_dbusiface_core *c = userdata; pa_dbusiface_core *c = userdata;
const char *signal; const char *signal_str;
char **objects = NULL; char **objects = NULL;
int n_objects; int n_objects;
@ -1497,11 +1497,11 @@ static void handle_listen_for_signal(DBusConnection *conn, DBusMessage *msg, voi
pa_assert(c); pa_assert(c);
pa_assert_se(dbus_message_get_args(msg, NULL, pa_assert_se(dbus_message_get_args(msg, NULL,
DBUS_TYPE_STRING, &signal, DBUS_TYPE_STRING, &signal_str,
DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &objects, &n_objects, DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &objects, &n_objects,
DBUS_TYPE_INVALID)); DBUS_TYPE_INVALID));
pa_dbus_protocol_add_signal_listener(c->dbus_protocol, conn, *signal ? signal : NULL, objects, n_objects); pa_dbus_protocol_add_signal_listener(c->dbus_protocol, conn, *signal_str ? signal_str : NULL, objects, n_objects);
pa_dbus_send_empty_reply(conn, msg); pa_dbus_send_empty_reply(conn, msg);
@ -1510,15 +1510,15 @@ static void handle_listen_for_signal(DBusConnection *conn, DBusMessage *msg, voi
static void handle_stop_listening_for_signal(DBusConnection *conn, DBusMessage *msg, void *userdata) { static void handle_stop_listening_for_signal(DBusConnection *conn, DBusMessage *msg, void *userdata) {
pa_dbusiface_core *c = userdata; pa_dbusiface_core *c = userdata;
const char *signal; const char *signal_str;
pa_assert(conn); pa_assert(conn);
pa_assert(msg); pa_assert(msg);
pa_assert(c); pa_assert(c);
pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &signal, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &signal_str, DBUS_TYPE_INVALID));
pa_dbus_protocol_remove_signal_listener(c->dbus_protocol, conn, *signal ? signal : NULL); pa_dbus_protocol_remove_signal_listener(c->dbus_protocol, conn, *signal_str ? signal_str : NULL);
pa_dbus_send_empty_reply(conn, msg); pa_dbus_send_empty_reply(conn, msg);
} }
@ -1531,7 +1531,7 @@ static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint3
pa_dbusiface_sample *sample_iface = NULL; pa_dbusiface_sample *sample_iface = NULL;
pa_dbusiface_module *module_iface = NULL; pa_dbusiface_module *module_iface = NULL;
pa_dbusiface_client *client_iface = NULL; pa_dbusiface_client *client_iface = NULL;
DBusMessage *signal = NULL; DBusMessage *signal_msg = NULL;
const char *object_path = NULL; const char *object_path = NULL;
pa_sink *new_fallback_sink = NULL; pa_sink *new_fallback_sink = NULL;
pa_source *new_fallback_source = NULL; pa_source *new_fallback_source = NULL;
@ -1552,21 +1552,21 @@ static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint3
&& (device_iface = pa_hashmap_get(c->sinks_by_index, PA_UINT32_TO_PTR(new_fallback_sink->index)))) { && (device_iface = pa_hashmap_get(c->sinks_by_index, PA_UINT32_TO_PTR(new_fallback_sink->index)))) {
object_path = pa_dbusiface_device_get_path(device_iface); object_path = pa_dbusiface_device_get_path(device_iface);
pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH, pa_assert_se((signal_msg = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
PA_DBUS_CORE_INTERFACE, PA_DBUS_CORE_INTERFACE,
signals[SIGNAL_FALLBACK_SINK_UPDATED].name))); signals[SIGNAL_FALLBACK_SINK_UPDATED].name)));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
pa_dbus_protocol_send_signal(c->dbus_protocol, signal); pa_dbus_protocol_send_signal(c->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
signal = NULL; signal_msg = NULL;
} else if (!new_fallback_sink) { } else if (!new_fallback_sink) {
pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH, pa_assert_se((signal_msg = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
PA_DBUS_CORE_INTERFACE, PA_DBUS_CORE_INTERFACE,
signals[SIGNAL_FALLBACK_SINK_UNSET].name))); signals[SIGNAL_FALLBACK_SINK_UNSET].name)));
pa_dbus_protocol_send_signal(c->dbus_protocol, signal); pa_dbus_protocol_send_signal(c->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
signal = NULL; signal_msg = NULL;
} }
} }
@ -1579,21 +1579,21 @@ static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint3
&& (device_iface = pa_hashmap_get(c->sources_by_index, PA_UINT32_TO_PTR(new_fallback_source->index)))) { && (device_iface = pa_hashmap_get(c->sources_by_index, PA_UINT32_TO_PTR(new_fallback_source->index)))) {
object_path = pa_dbusiface_device_get_path(device_iface); object_path = pa_dbusiface_device_get_path(device_iface);
pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH, pa_assert_se((signal_msg = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
PA_DBUS_CORE_INTERFACE, PA_DBUS_CORE_INTERFACE,
signals[SIGNAL_FALLBACK_SOURCE_UPDATED].name))); signals[SIGNAL_FALLBACK_SOURCE_UPDATED].name)));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
pa_dbus_protocol_send_signal(c->dbus_protocol, signal); pa_dbus_protocol_send_signal(c->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
signal = NULL; signal_msg = NULL;
} else if (!new_fallback_source) { } else if (!new_fallback_source) {
pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH, pa_assert_se((signal_msg = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
PA_DBUS_CORE_INTERFACE, PA_DBUS_CORE_INTERFACE,
signals[SIGNAL_FALLBACK_SOURCE_UNSET].name))); signals[SIGNAL_FALLBACK_SOURCE_UNSET].name)));
pa_dbus_protocol_send_signal(c->dbus_protocol, signal); pa_dbus_protocol_send_signal(c->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
signal = NULL; signal_msg = NULL;
} }
} }
break; break;
@ -1612,10 +1612,10 @@ static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint3
object_path = pa_dbusiface_card_get_path(card_iface); object_path = pa_dbusiface_card_get_path(card_iface);
pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH, pa_assert_se((signal_msg = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
PA_DBUS_CORE_INTERFACE, PA_DBUS_CORE_INTERFACE,
signals[SIGNAL_NEW_CARD].name))); signals[SIGNAL_NEW_CARD].name)));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
} else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) { } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
if (!(card_iface = pa_hashmap_remove(c->cards, PA_UINT32_TO_PTR(idx)))) if (!(card_iface = pa_hashmap_remove(c->cards, PA_UINT32_TO_PTR(idx))))
@ -1623,10 +1623,10 @@ static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint3
object_path = pa_dbusiface_card_get_path(card_iface); object_path = pa_dbusiface_card_get_path(card_iface);
pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH, pa_assert_se((signal_msg = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
PA_DBUS_CORE_INTERFACE, PA_DBUS_CORE_INTERFACE,
signals[SIGNAL_CARD_REMOVED].name))); signals[SIGNAL_CARD_REMOVED].name)));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
pa_dbusiface_card_free(card_iface); pa_dbusiface_card_free(card_iface);
} }
@ -1647,28 +1647,28 @@ static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint3
object_path = pa_dbusiface_device_get_path(device_iface); object_path = pa_dbusiface_device_get_path(device_iface);
pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH, pa_assert_se((signal_msg = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
PA_DBUS_CORE_INTERFACE, PA_DBUS_CORE_INTERFACE,
signals[SIGNAL_NEW_SINK].name))); signals[SIGNAL_NEW_SINK].name)));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
pa_dbus_protocol_send_signal(c->dbus_protocol, signal); pa_dbus_protocol_send_signal(c->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
signal = NULL; signal_msg = NULL;
if (c->fallback_sink && pa_streq(c->fallback_sink->name, sink->name)) { if (c->fallback_sink && pa_streq(c->fallback_sink->name, sink->name)) {
/* We have got default sink change event, but at that point /* We have got default sink change event, but at that point
* the D-Bus sink object wasn't created yet. Now that the * the D-Bus sink object wasn't created yet. Now that the
* object is created, let's send the fallback sink change * object is created, let's send the fallback sink change
* signal. */ * signal. */
pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH, pa_assert_se((signal_msg = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
PA_DBUS_CORE_INTERFACE, PA_DBUS_CORE_INTERFACE,
signals[SIGNAL_FALLBACK_SINK_UPDATED].name))); signals[SIGNAL_FALLBACK_SINK_UPDATED].name)));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
pa_dbus_protocol_send_signal(c->dbus_protocol, signal); pa_dbus_protocol_send_signal(c->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
signal = NULL; signal_msg = NULL;
} }
} else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) { } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
@ -1678,10 +1678,10 @@ static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint3
object_path = pa_dbusiface_device_get_path(device_iface); object_path = pa_dbusiface_device_get_path(device_iface);
pa_assert_se(pa_hashmap_remove(c->sinks_by_path, object_path)); pa_assert_se(pa_hashmap_remove(c->sinks_by_path, object_path));
pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH, pa_assert_se((signal_msg = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
PA_DBUS_CORE_INTERFACE, PA_DBUS_CORE_INTERFACE,
signals[SIGNAL_SINK_REMOVED].name))); signals[SIGNAL_SINK_REMOVED].name)));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
pa_dbusiface_device_free(device_iface); pa_dbusiface_device_free(device_iface);
} }
@ -1702,28 +1702,28 @@ static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint3
object_path = pa_dbusiface_device_get_path(device_iface); object_path = pa_dbusiface_device_get_path(device_iface);
pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH, pa_assert_se((signal_msg = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
PA_DBUS_CORE_INTERFACE, PA_DBUS_CORE_INTERFACE,
signals[SIGNAL_NEW_SOURCE].name))); signals[SIGNAL_NEW_SOURCE].name)));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
pa_dbus_protocol_send_signal(c->dbus_protocol, signal); pa_dbus_protocol_send_signal(c->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
signal = NULL; signal_msg = NULL;
if (c->fallback_source && pa_streq(c->fallback_source->name, source->name)) { if (c->fallback_source && pa_streq(c->fallback_source->name, source->name)) {
/* We have got default source change event, but at that /* We have got default source change event, but at that
* point the D-Bus source object wasn't created yet. Now * point the D-Bus source object wasn't created yet. Now
* that the object is created, let's send the fallback * that the object is created, let's send the fallback
* source change signal. */ * source change signal. */
pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH, pa_assert_se((signal_msg = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
PA_DBUS_CORE_INTERFACE, PA_DBUS_CORE_INTERFACE,
signals[SIGNAL_FALLBACK_SOURCE_UPDATED].name))); signals[SIGNAL_FALLBACK_SOURCE_UPDATED].name)));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
pa_dbus_protocol_send_signal(c->dbus_protocol, signal); pa_dbus_protocol_send_signal(c->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
signal = NULL; signal_msg = NULL;
} }
} else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) { } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
@ -1733,10 +1733,10 @@ static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint3
object_path = pa_dbusiface_device_get_path(device_iface); object_path = pa_dbusiface_device_get_path(device_iface);
pa_assert_se(pa_hashmap_remove(c->sources_by_path, object_path)); pa_assert_se(pa_hashmap_remove(c->sources_by_path, object_path));
pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH, pa_assert_se((signal_msg = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
PA_DBUS_CORE_INTERFACE, PA_DBUS_CORE_INTERFACE,
signals[SIGNAL_SOURCE_REMOVED].name))); signals[SIGNAL_SOURCE_REMOVED].name)));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
pa_dbusiface_device_free(device_iface); pa_dbusiface_device_free(device_iface);
} }
@ -1756,10 +1756,10 @@ static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint3
object_path = pa_dbusiface_stream_get_path(stream_iface); object_path = pa_dbusiface_stream_get_path(stream_iface);
pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH, pa_assert_se((signal_msg = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
PA_DBUS_CORE_INTERFACE, PA_DBUS_CORE_INTERFACE,
signals[SIGNAL_NEW_PLAYBACK_STREAM].name))); signals[SIGNAL_NEW_PLAYBACK_STREAM].name)));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
} else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) { } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
if (!(stream_iface = pa_hashmap_remove(c->playback_streams, PA_UINT32_TO_PTR(idx)))) if (!(stream_iface = pa_hashmap_remove(c->playback_streams, PA_UINT32_TO_PTR(idx))))
@ -1767,10 +1767,10 @@ static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint3
object_path = pa_dbusiface_stream_get_path(stream_iface); object_path = pa_dbusiface_stream_get_path(stream_iface);
pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH, pa_assert_se((signal_msg = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
PA_DBUS_CORE_INTERFACE, PA_DBUS_CORE_INTERFACE,
signals[SIGNAL_PLAYBACK_STREAM_REMOVED].name))); signals[SIGNAL_PLAYBACK_STREAM_REMOVED].name)));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
pa_dbusiface_stream_free(stream_iface); pa_dbusiface_stream_free(stream_iface);
} }
@ -1790,10 +1790,10 @@ static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint3
object_path = pa_dbusiface_stream_get_path(stream_iface); object_path = pa_dbusiface_stream_get_path(stream_iface);
pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH, pa_assert_se((signal_msg = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
PA_DBUS_CORE_INTERFACE, PA_DBUS_CORE_INTERFACE,
signals[SIGNAL_NEW_RECORD_STREAM].name))); signals[SIGNAL_NEW_RECORD_STREAM].name)));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
} else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) { } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
if (!(stream_iface = pa_hashmap_remove(c->record_streams, PA_UINT32_TO_PTR(idx)))) if (!(stream_iface = pa_hashmap_remove(c->record_streams, PA_UINT32_TO_PTR(idx))))
@ -1801,10 +1801,10 @@ static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint3
object_path = pa_dbusiface_stream_get_path(stream_iface); object_path = pa_dbusiface_stream_get_path(stream_iface);
pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH, pa_assert_se((signal_msg = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
PA_DBUS_CORE_INTERFACE, PA_DBUS_CORE_INTERFACE,
signals[SIGNAL_RECORD_STREAM_REMOVED].name))); signals[SIGNAL_RECORD_STREAM_REMOVED].name)));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
pa_dbusiface_stream_free(stream_iface); pa_dbusiface_stream_free(stream_iface);
} }
@ -1824,10 +1824,10 @@ static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint3
object_path = pa_dbusiface_sample_get_path(sample_iface); object_path = pa_dbusiface_sample_get_path(sample_iface);
pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH, pa_assert_se((signal_msg = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
PA_DBUS_CORE_INTERFACE, PA_DBUS_CORE_INTERFACE,
signals[SIGNAL_NEW_SAMPLE].name))); signals[SIGNAL_NEW_SAMPLE].name)));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
} else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) { } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
if (!(sample_iface = pa_hashmap_remove(c->samples, PA_UINT32_TO_PTR(idx)))) if (!(sample_iface = pa_hashmap_remove(c->samples, PA_UINT32_TO_PTR(idx))))
@ -1835,10 +1835,10 @@ static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint3
object_path = pa_dbusiface_sample_get_path(sample_iface); object_path = pa_dbusiface_sample_get_path(sample_iface);
pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH, pa_assert_se((signal_msg = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
PA_DBUS_CORE_INTERFACE, PA_DBUS_CORE_INTERFACE,
signals[SIGNAL_SAMPLE_REMOVED].name))); signals[SIGNAL_SAMPLE_REMOVED].name)));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
pa_dbusiface_sample_free(sample_iface); pa_dbusiface_sample_free(sample_iface);
} }
@ -1858,10 +1858,10 @@ static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint3
object_path = pa_dbusiface_module_get_path(module_iface); object_path = pa_dbusiface_module_get_path(module_iface);
pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH, pa_assert_se((signal_msg = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
PA_DBUS_CORE_INTERFACE, PA_DBUS_CORE_INTERFACE,
signals[SIGNAL_NEW_MODULE].name))); signals[SIGNAL_NEW_MODULE].name)));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
} else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) { } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
if (!(module_iface = pa_hashmap_remove(c->modules, PA_UINT32_TO_PTR(idx)))) if (!(module_iface = pa_hashmap_remove(c->modules, PA_UINT32_TO_PTR(idx))))
@ -1869,10 +1869,10 @@ static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint3
object_path = pa_dbusiface_module_get_path(module_iface); object_path = pa_dbusiface_module_get_path(module_iface);
pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH, pa_assert_se((signal_msg = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
PA_DBUS_CORE_INTERFACE, PA_DBUS_CORE_INTERFACE,
signals[SIGNAL_MODULE_REMOVED].name))); signals[SIGNAL_MODULE_REMOVED].name)));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
pa_dbusiface_module_free(module_iface); pa_dbusiface_module_free(module_iface);
} }
@ -1892,10 +1892,10 @@ static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint3
object_path = pa_dbusiface_client_get_path(client_iface); object_path = pa_dbusiface_client_get_path(client_iface);
pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH, pa_assert_se((signal_msg = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
PA_DBUS_CORE_INTERFACE, PA_DBUS_CORE_INTERFACE,
signals[SIGNAL_NEW_CLIENT].name))); signals[SIGNAL_NEW_CLIENT].name)));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
} else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) { } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
if (!(client_iface = pa_hashmap_remove(c->clients, PA_UINT32_TO_PTR(idx)))) if (!(client_iface = pa_hashmap_remove(c->clients, PA_UINT32_TO_PTR(idx))))
@ -1903,37 +1903,37 @@ static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint3
object_path = pa_dbusiface_client_get_path(client_iface); object_path = pa_dbusiface_client_get_path(client_iface);
pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH, pa_assert_se((signal_msg = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
PA_DBUS_CORE_INTERFACE, PA_DBUS_CORE_INTERFACE,
signals[SIGNAL_CLIENT_REMOVED].name))); signals[SIGNAL_CLIENT_REMOVED].name)));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
pa_dbusiface_client_free(client_iface); pa_dbusiface_client_free(client_iface);
} }
break; break;
} }
if (signal) { if (signal_msg) {
pa_dbus_protocol_send_signal(c->dbus_protocol, signal); pa_dbus_protocol_send_signal(c->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
} }
} }
static pa_hook_result_t extension_registered_cb(void *hook_data, void *call_data, void *slot_data) { static pa_hook_result_t extension_registered_cb(void *hook_data, void *call_data, void *slot_data) {
pa_dbusiface_core *c = slot_data; pa_dbusiface_core *c = slot_data;
const char *ext_name = call_data; const char *ext_name = call_data;
DBusMessage *signal = NULL; DBusMessage *signal_msg = NULL;
pa_assert(c); pa_assert(c);
pa_assert(ext_name); pa_assert(ext_name);
pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH, pa_assert_se((signal_msg = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
PA_DBUS_CORE_INTERFACE, PA_DBUS_CORE_INTERFACE,
signals[SIGNAL_NEW_EXTENSION].name))); signals[SIGNAL_NEW_EXTENSION].name)));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_STRING, &ext_name, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_STRING, &ext_name, DBUS_TYPE_INVALID));
pa_dbus_protocol_send_signal(c->dbus_protocol, signal); pa_dbus_protocol_send_signal(c->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
return PA_HOOK_OK; return PA_HOOK_OK;
} }
@ -1941,18 +1941,18 @@ static pa_hook_result_t extension_registered_cb(void *hook_data, void *call_data
static pa_hook_result_t extension_unregistered_cb(void *hook_data, void *call_data, void *slot_data) { static pa_hook_result_t extension_unregistered_cb(void *hook_data, void *call_data, void *slot_data) {
pa_dbusiface_core *c = slot_data; pa_dbusiface_core *c = slot_data;
const char *ext_name = call_data; const char *ext_name = call_data;
DBusMessage *signal = NULL; DBusMessage *signal_msg = NULL;
pa_assert(c); pa_assert(c);
pa_assert(ext_name); pa_assert(ext_name);
pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH, pa_assert_se((signal_msg = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
PA_DBUS_CORE_INTERFACE, PA_DBUS_CORE_INTERFACE,
signals[SIGNAL_EXTENSION_REMOVED].name))); signals[SIGNAL_EXTENSION_REMOVED].name)));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_STRING, &ext_name, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_STRING, &ext_name, DBUS_TYPE_INVALID));
pa_dbus_protocol_send_signal(c->dbus_protocol, signal); pa_dbus_protocol_send_signal(c->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
return PA_HOOK_OK; return PA_HOOK_OK;
} }

52
src/modules/dbus/iface-device.c
View file

@ -1063,7 +1063,7 @@ static void handle_source_get_all(DBusConnection *conn, DBusMessage *msg, void *
static void subscription_cb(pa_core *c, pa_subscription_event_type_t t, uint32_t idx, void *userdata) { static void subscription_cb(pa_core *c, pa_subscription_event_type_t t, uint32_t idx, void *userdata) {
pa_dbusiface_device *d = userdata; pa_dbusiface_device *d = userdata;
DBusMessage *signal = NULL; DBusMessage *signal_msg = NULL;
const pa_cvolume *new_volume = NULL; const pa_cvolume *new_volume = NULL;
pa_bool_t new_mute = FALSE; pa_bool_t new_mute = FALSE;
pa_sink_state_t new_sink_state = 0; pa_sink_state_t new_sink_state = 0;
@ -1099,16 +1099,16 @@ static void subscription_cb(pa_core *c, pa_subscription_event_type_t t, uint32_t
for (i = 0; i < d->volume.channels; ++i) for (i = 0; i < d->volume.channels; ++i)
volume[i] = d->volume.values[i]; volume[i] = d->volume.values[i];
pa_assert_se(signal = dbus_message_new_signal(d->path, pa_assert_se(signal_msg = dbus_message_new_signal(d->path,
PA_DBUSIFACE_DEVICE_INTERFACE, PA_DBUSIFACE_DEVICE_INTERFACE,
signals[SIGNAL_VOLUME_UPDATED].name)); signals[SIGNAL_VOLUME_UPDATED].name));
pa_assert_se(dbus_message_append_args(signal, pa_assert_se(dbus_message_append_args(signal_msg,
DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &volume_ptr, d->volume.channels, DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &volume_ptr, d->volume.channels,
DBUS_TYPE_INVALID)); DBUS_TYPE_INVALID));
pa_dbus_protocol_send_signal(d->dbus_protocol, signal); pa_dbus_protocol_send_signal(d->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
signal = NULL; signal_msg = NULL;
} }
new_mute = (d->type == DEVICE_TYPE_SINK) ? pa_sink_get_mute(d->sink, FALSE) : pa_source_get_mute(d->source, FALSE); new_mute = (d->type == DEVICE_TYPE_SINK) ? pa_sink_get_mute(d->sink, FALSE) : pa_source_get_mute(d->source, FALSE);
@ -1116,14 +1116,14 @@ static void subscription_cb(pa_core *c, pa_subscription_event_type_t t, uint32_t
if (d->mute != new_mute) { if (d->mute != new_mute) {
d->mute = new_mute; d->mute = new_mute;
pa_assert_se(signal = dbus_message_new_signal(d->path, pa_assert_se(signal_msg = dbus_message_new_signal(d->path,
PA_DBUSIFACE_DEVICE_INTERFACE, PA_DBUSIFACE_DEVICE_INTERFACE,
signals[SIGNAL_MUTE_UPDATED].name)); signals[SIGNAL_MUTE_UPDATED].name));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_BOOLEAN, &d->mute, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_BOOLEAN, &d->mute, DBUS_TYPE_INVALID));
pa_dbus_protocol_send_signal(d->dbus_protocol, signal); pa_dbus_protocol_send_signal(d->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
signal = NULL; signal_msg = NULL;
} }
if (d->type == DEVICE_TYPE_SINK) if (d->type == DEVICE_TYPE_SINK)
@ -1142,14 +1142,14 @@ static void subscription_cb(pa_core *c, pa_subscription_event_type_t t, uint32_t
state = (d->type == DEVICE_TYPE_SINK) ? d->sink_state : d->source_state; state = (d->type == DEVICE_TYPE_SINK) ? d->sink_state : d->source_state;
pa_assert_se(signal = dbus_message_new_signal(d->path, pa_assert_se(signal_msg = dbus_message_new_signal(d->path,
PA_DBUSIFACE_DEVICE_INTERFACE, PA_DBUSIFACE_DEVICE_INTERFACE,
signals[SIGNAL_STATE_UPDATED].name)); signals[SIGNAL_STATE_UPDATED].name));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_UINT32, &state, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_UINT32, &state, DBUS_TYPE_INVALID));
pa_dbus_protocol_send_signal(d->dbus_protocol, signal); pa_dbus_protocol_send_signal(d->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
signal = NULL; signal_msg = NULL;
} }
new_active_port = (d->type == DEVICE_TYPE_SINK) ? d->sink->active_port : d->source->active_port; new_active_port = (d->type == DEVICE_TYPE_SINK) ? d->sink->active_port : d->source->active_port;
@ -1160,14 +1160,14 @@ static void subscription_cb(pa_core *c, pa_subscription_event_type_t t, uint32_t
d->active_port = new_active_port; d->active_port = new_active_port;
object_path = pa_dbusiface_device_port_get_path(pa_hashmap_get(d->ports, d->active_port->name)); object_path = pa_dbusiface_device_port_get_path(pa_hashmap_get(d->ports, d->active_port->name));
pa_assert_se(signal = dbus_message_new_signal(d->path, pa_assert_se(signal_msg = dbus_message_new_signal(d->path,
PA_DBUSIFACE_DEVICE_INTERFACE, PA_DBUSIFACE_DEVICE_INTERFACE,
signals[SIGNAL_ACTIVE_PORT_UPDATED].name)); signals[SIGNAL_ACTIVE_PORT_UPDATED].name));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
pa_dbus_protocol_send_signal(d->dbus_protocol, signal); pa_dbus_protocol_send_signal(d->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
signal = NULL; signal_msg = NULL;
} }
new_proplist = (d->type == DEVICE_TYPE_SINK) ? d->sink->proplist : d->source->proplist; new_proplist = (d->type == DEVICE_TYPE_SINK) ? d->sink->proplist : d->source->proplist;
@ -1177,15 +1177,15 @@ static void subscription_cb(pa_core *c, pa_subscription_event_type_t t, uint32_t
pa_proplist_update(d->proplist, PA_UPDATE_SET, new_proplist); pa_proplist_update(d->proplist, PA_UPDATE_SET, new_proplist);
pa_assert_se(signal = dbus_message_new_signal(d->path, pa_assert_se(signal_msg = dbus_message_new_signal(d->path,
PA_DBUSIFACE_DEVICE_INTERFACE, PA_DBUSIFACE_DEVICE_INTERFACE,
signals[SIGNAL_PROPERTY_LIST_UPDATED].name)); signals[SIGNAL_PROPERTY_LIST_UPDATED].name));
dbus_message_iter_init_append(signal, &msg_iter); dbus_message_iter_init_append(signal_msg, &msg_iter);
pa_dbus_append_proplist(&msg_iter, d->proplist); pa_dbus_append_proplist(&msg_iter, d->proplist);
pa_dbus_protocol_send_signal(d->dbus_protocol, signal); pa_dbus_protocol_send_signal(d->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
signal = NULL; signal_msg = NULL;
} }
} }

12
src/modules/dbus/iface-module.c
View file

@ -268,7 +268,7 @@ static void handle_unload(DBusConnection *conn, DBusMessage *msg, void *userdata
static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint32_t idx, void *userdata) { static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint32_t idx, void *userdata) {
pa_dbusiface_module *m = userdata; pa_dbusiface_module *m = userdata;
DBusMessage *signal = NULL; DBusMessage *signal_msg = NULL;
pa_assert(core); pa_assert(core);
pa_assert((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_MODULE); pa_assert((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_MODULE);
@ -287,15 +287,15 @@ static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint3
pa_proplist_update(m->proplist, PA_UPDATE_SET, m->module->proplist); pa_proplist_update(m->proplist, PA_UPDATE_SET, m->module->proplist);
pa_assert_se(signal = dbus_message_new_signal(m->path, pa_assert_se(signal_msg = dbus_message_new_signal(m->path,
PA_DBUSIFACE_MODULE_INTERFACE, PA_DBUSIFACE_MODULE_INTERFACE,
signals[SIGNAL_PROPERTY_LIST_UPDATED].name)); signals[SIGNAL_PROPERTY_LIST_UPDATED].name));
dbus_message_iter_init_append(signal, &msg_iter); dbus_message_iter_init_append(signal_msg, &msg_iter);
pa_dbus_append_proplist(&msg_iter, m->proplist); pa_dbus_append_proplist(&msg_iter, m->proplist);
pa_dbus_protocol_send_signal(m->dbus_protocol, signal); pa_dbus_protocol_send_signal(m->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
signal = NULL; signal_msg = NULL;
} }
} }

12
src/modules/dbus/iface-sample.c
View file

@ -450,7 +450,7 @@ static void handle_remove(DBusConnection *conn, DBusMessage *msg, void *userdata
static void subscription_cb(pa_core *c, pa_subscription_event_type_t t, uint32_t idx, void *userdata) { static void subscription_cb(pa_core *c, pa_subscription_event_type_t t, uint32_t idx, void *userdata) {
pa_dbusiface_sample *s = userdata; pa_dbusiface_sample *s = userdata;
DBusMessage *signal = NULL; DBusMessage *signal_msg = NULL;
pa_assert(c); pa_assert(c);
pa_assert(s); pa_assert(s);
@ -468,15 +468,15 @@ static void subscription_cb(pa_core *c, pa_subscription_event_type_t t, uint32_t
pa_proplist_update(s->proplist, PA_UPDATE_SET, s->sample->proplist); pa_proplist_update(s->proplist, PA_UPDATE_SET, s->sample->proplist);
pa_assert_se(signal = dbus_message_new_signal(s->path, pa_assert_se(signal_msg = dbus_message_new_signal(s->path,
PA_DBUSIFACE_SAMPLE_INTERFACE, PA_DBUSIFACE_SAMPLE_INTERFACE,
signals[SIGNAL_PROPERTY_LIST_UPDATED].name)); signals[SIGNAL_PROPERTY_LIST_UPDATED].name));
dbus_message_iter_init_append(signal, &msg_iter); dbus_message_iter_init_append(signal_msg, &msg_iter);
pa_dbus_append_proplist(&msg_iter, s->proplist); pa_dbus_append_proplist(&msg_iter, s->proplist);
pa_dbus_protocol_send_signal(s->dbus_protocol, signal); pa_dbus_protocol_send_signal(s->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
signal = NULL; signal_msg = NULL;
} }
} }

72
src/modules/dbus/iface-stream.c
View file

@ -632,7 +632,7 @@ static void handle_kill(DBusConnection *conn, DBusMessage *msg, void *userdata)
static void subscription_cb(pa_core *c, pa_subscription_event_type_t t, uint32_t idx, void *userdata) { static void subscription_cb(pa_core *c, pa_subscription_event_type_t t, uint32_t idx, void *userdata) {
pa_dbusiface_stream *s = userdata; pa_dbusiface_stream *s = userdata;
DBusMessage *signal = NULL; DBusMessage *signal_msg = NULL;
const char *new_device_path = NULL; const char *new_device_path = NULL;
uint32_t new_sample_rate = 0; uint32_t new_sample_rate = 0;
pa_proplist *new_proplist = NULL; pa_proplist *new_proplist = NULL;
@ -662,14 +662,14 @@ static void subscription_cb(pa_core *c, pa_subscription_event_type_t t, uint32_t
new_device_path = pa_dbusiface_core_get_sink_path(s->core, new_sink); new_device_path = pa_dbusiface_core_get_sink_path(s->core, new_sink);
pa_assert_se(signal = dbus_message_new_signal(s->path, pa_assert_se(signal_msg = dbus_message_new_signal(s->path,
PA_DBUSIFACE_STREAM_INTERFACE, PA_DBUSIFACE_STREAM_INTERFACE,
signals[SIGNAL_DEVICE_UPDATED].name)); signals[SIGNAL_DEVICE_UPDATED].name));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &new_device_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &new_device_path, DBUS_TYPE_INVALID));
pa_dbus_protocol_send_signal(s->dbus_protocol, signal); pa_dbus_protocol_send_signal(s->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
signal = NULL; signal_msg = NULL;
} }
} else { } else {
pa_source *new_source = s->source_output->source; pa_source *new_source = s->source_output->source;
@ -680,14 +680,14 @@ static void subscription_cb(pa_core *c, pa_subscription_event_type_t t, uint32_t
new_device_path = pa_dbusiface_core_get_source_path(s->core, new_source); new_device_path = pa_dbusiface_core_get_source_path(s->core, new_source);
pa_assert_se(signal = dbus_message_new_signal(s->path, pa_assert_se(signal_msg = dbus_message_new_signal(s->path,
PA_DBUSIFACE_STREAM_INTERFACE, PA_DBUSIFACE_STREAM_INTERFACE,
signals[SIGNAL_DEVICE_UPDATED].name)); signals[SIGNAL_DEVICE_UPDATED].name));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &new_device_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &new_device_path, DBUS_TYPE_INVALID));
pa_dbus_protocol_send_signal(s->dbus_protocol, signal); pa_dbus_protocol_send_signal(s->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
signal = NULL; signal_msg = NULL;
} }
} }
@ -696,14 +696,14 @@ static void subscription_cb(pa_core *c, pa_subscription_event_type_t t, uint32_t
if (s->sample_rate != new_sample_rate) { if (s->sample_rate != new_sample_rate) {
s->sample_rate = new_sample_rate; s->sample_rate = new_sample_rate;
pa_assert_se(signal = dbus_message_new_signal(s->path, pa_assert_se(signal_msg = dbus_message_new_signal(s->path,
PA_DBUSIFACE_STREAM_INTERFACE, PA_DBUSIFACE_STREAM_INTERFACE,
signals[SIGNAL_SAMPLE_RATE_UPDATED].name)); signals[SIGNAL_SAMPLE_RATE_UPDATED].name));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_UINT32, &s->sample_rate, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_UINT32, &s->sample_rate, DBUS_TYPE_INVALID));
pa_dbus_protocol_send_signal(s->dbus_protocol, signal); pa_dbus_protocol_send_signal(s->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
signal = NULL; signal_msg = NULL;
} }
if (s->type == STREAM_TYPE_PLAYBACK) { if (s->type == STREAM_TYPE_PLAYBACK) {
@ -721,16 +721,16 @@ static void subscription_cb(pa_core *c, pa_subscription_event_type_t t, uint32_t
for (i = 0; i < s->volume.channels; ++i) for (i = 0; i < s->volume.channels; ++i)
volume[i] = s->volume.values[i]; volume[i] = s->volume.values[i];
pa_assert_se(signal = dbus_message_new_signal(s->path, pa_assert_se(signal_msg = dbus_message_new_signal(s->path,
PA_DBUSIFACE_STREAM_INTERFACE, PA_DBUSIFACE_STREAM_INTERFACE,
signals[SIGNAL_VOLUME_UPDATED].name)); signals[SIGNAL_VOLUME_UPDATED].name));
pa_assert_se(dbus_message_append_args(signal, pa_assert_se(dbus_message_append_args(signal_msg,
DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &volume_ptr, s->volume.channels, DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &volume_ptr, s->volume.channels,
DBUS_TYPE_INVALID)); DBUS_TYPE_INVALID));
pa_dbus_protocol_send_signal(s->dbus_protocol, signal); pa_dbus_protocol_send_signal(s->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
signal = NULL; signal_msg = NULL;
} }
new_mute = pa_sink_input_get_mute(s->sink_input); new_mute = pa_sink_input_get_mute(s->sink_input);
@ -738,14 +738,14 @@ static void subscription_cb(pa_core *c, pa_subscription_event_type_t t, uint32_t
if (s->mute != new_mute) { if (s->mute != new_mute) {
s->mute = new_mute; s->mute = new_mute;
pa_assert_se(signal = dbus_message_new_signal(s->path, pa_assert_se(signal_msg = dbus_message_new_signal(s->path,
PA_DBUSIFACE_STREAM_INTERFACE, PA_DBUSIFACE_STREAM_INTERFACE,
signals[SIGNAL_MUTE_UPDATED].name)); signals[SIGNAL_MUTE_UPDATED].name));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_BOOLEAN, &s->mute, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_BOOLEAN, &s->mute, DBUS_TYPE_INVALID));
pa_dbus_protocol_send_signal(s->dbus_protocol, signal); pa_dbus_protocol_send_signal(s->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
signal = NULL; signal_msg = NULL;
} }
} }
@ -756,21 +756,21 @@ static void subscription_cb(pa_core *c, pa_subscription_event_type_t t, uint32_t
pa_proplist_update(s->proplist, PA_UPDATE_SET, new_proplist); pa_proplist_update(s->proplist, PA_UPDATE_SET, new_proplist);
pa_assert_se(signal = dbus_message_new_signal(s->path, pa_assert_se(signal_msg = dbus_message_new_signal(s->path,
PA_DBUSIFACE_STREAM_INTERFACE, PA_DBUSIFACE_STREAM_INTERFACE,
signals[SIGNAL_PROPERTY_LIST_UPDATED].name)); signals[SIGNAL_PROPERTY_LIST_UPDATED].name));
dbus_message_iter_init_append(signal, &msg_iter); dbus_message_iter_init_append(signal_msg, &msg_iter);
pa_dbus_append_proplist(&msg_iter, s->proplist); pa_dbus_append_proplist(&msg_iter, s->proplist);
pa_dbus_protocol_send_signal(s->dbus_protocol, signal); pa_dbus_protocol_send_signal(s->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
signal = NULL; signal_msg = NULL;
} }
} }
static pa_hook_result_t send_event_cb(void *hook_data, void *call_data, void *slot_data) { static pa_hook_result_t send_event_cb(void *hook_data, void *call_data, void *slot_data) {
pa_dbusiface_stream *s = slot_data; pa_dbusiface_stream *s = slot_data;
DBusMessage *signal = NULL; DBusMessage *signal_msg = NULL;
DBusMessageIter msg_iter; DBusMessageIter msg_iter;
const char *name = NULL; const char *name = NULL;
pa_proplist *property_list = NULL; pa_proplist *property_list = NULL;
@ -796,15 +796,15 @@ static pa_hook_result_t send_event_cb(void *hook_data, void *call_data, void *sl
property_list = data->data; property_list = data->data;
} }
pa_assert_se(signal = dbus_message_new_signal(s->path, pa_assert_se(signal_msg = dbus_message_new_signal(s->path,
PA_DBUSIFACE_STREAM_INTERFACE, PA_DBUSIFACE_STREAM_INTERFACE,
signals[SIGNAL_STREAM_EVENT].name)); signals[SIGNAL_STREAM_EVENT].name));
dbus_message_iter_init_append(signal, &msg_iter); dbus_message_iter_init_append(signal_msg, &msg_iter);
pa_assert_se(dbus_message_iter_append_basic(&msg_iter, DBUS_TYPE_STRING, &name)); pa_assert_se(dbus_message_iter_append_basic(&msg_iter, DBUS_TYPE_STRING, &name));
pa_dbus_append_proplist(&msg_iter, property_list); pa_dbus_append_proplist(&msg_iter, property_list);
pa_dbus_protocol_send_signal(s->dbus_protocol, signal); pa_dbus_protocol_send_signal(s->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
return PA_HOOK_OK; return PA_HOOK_OK;
} }

10
src/modules/dbus/module-dbus-protocol.c
View file

@ -126,7 +126,7 @@ static void client_kill_cb(pa_client *c) {
/* Called from pa_client_send_event(). */ /* Called from pa_client_send_event(). */
static void client_send_event_cb(pa_client *c, const char *name, pa_proplist *data) { static void client_send_event_cb(pa_client *c, const char *name, pa_proplist *data) {
struct connection *conn = NULL; struct connection *conn = NULL;
DBusMessage *signal = NULL; DBusMessage *signal_msg = NULL;
DBusMessageIter msg_iter; DBusMessageIter msg_iter;
pa_assert(c); pa_assert(c);
@ -136,15 +136,15 @@ static void client_send_event_cb(pa_client *c, const char *name, pa_proplist *da
conn = c->userdata; conn = c->userdata;
pa_assert_se(signal = dbus_message_new_signal(pa_dbusiface_core_get_client_path(conn->server->userdata->core_iface, c), pa_assert_se(signal_msg = dbus_message_new_signal(pa_dbusiface_core_get_client_path(conn->server->userdata->core_iface, c),
PA_DBUSIFACE_CLIENT_INTERFACE, PA_DBUSIFACE_CLIENT_INTERFACE,
"ClientEvent")); "ClientEvent"));
dbus_message_iter_init_append(signal, &msg_iter); dbus_message_iter_init_append(signal_msg, &msg_iter);
pa_assert_se(dbus_message_iter_append_basic(&msg_iter, DBUS_TYPE_STRING, &name)); pa_assert_se(dbus_message_iter_append_basic(&msg_iter, DBUS_TYPE_STRING, &name));
pa_dbus_append_proplist(&msg_iter, data); pa_dbus_append_proplist(&msg_iter, data);
pa_assert_se(dbus_connection_send(pa_dbus_wrap_connection_get(conn->wrap_conn), signal, NULL)); pa_assert_se(dbus_connection_send(pa_dbus_wrap_connection_get(conn->wrap_conn), signal_msg, NULL));
dbus_message_unref(signal); dbus_message_unref(signal_msg);
} }
/* Called by D-Bus at the authentication phase. */ /* Called by D-Bus at the authentication phase. */

50
src/modules/module-stream-restore.c
View file

@ -433,29 +433,29 @@ static void append_volume_variant(DBusMessageIter *iter, struct entry *e) {
} }
static void send_new_entry_signal(struct dbus_entry *entry) { static void send_new_entry_signal(struct dbus_entry *entry) {
DBusMessage *signal; DBusMessage *signal_msg;
pa_assert(entry); pa_assert(entry);
pa_assert_se(signal = dbus_message_new_signal(OBJECT_PATH, INTERFACE_STREAM_RESTORE, signals[SIGNAL_NEW_ENTRY].name)); pa_assert_se(signal_msg = dbus_message_new_signal(OBJECT_PATH, INTERFACE_STREAM_RESTORE, signals[SIGNAL_NEW_ENTRY].name));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &entry->object_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &entry->object_path, DBUS_TYPE_INVALID));
pa_dbus_protocol_send_signal(entry->userdata->dbus_protocol, signal); pa_dbus_protocol_send_signal(entry->userdata->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
} }
static void send_entry_removed_signal(struct dbus_entry *entry) { static void send_entry_removed_signal(struct dbus_entry *entry) {
DBusMessage *signal; DBusMessage *signal_msg;
pa_assert(entry); pa_assert(entry);
pa_assert_se(signal = dbus_message_new_signal(OBJECT_PATH, INTERFACE_STREAM_RESTORE, signals[SIGNAL_ENTRY_REMOVED].name)); pa_assert_se(signal_msg = dbus_message_new_signal(OBJECT_PATH, INTERFACE_STREAM_RESTORE, signals[SIGNAL_ENTRY_REMOVED].name));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &entry->object_path, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_OBJECT_PATH, &entry->object_path, DBUS_TYPE_INVALID));
pa_dbus_protocol_send_signal(entry->userdata->dbus_protocol, signal); pa_dbus_protocol_send_signal(entry->userdata->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
} }
static void send_device_updated_signal(struct dbus_entry *de, struct entry *e) { static void send_device_updated_signal(struct dbus_entry *de, struct entry *e) {
DBusMessage *signal; DBusMessage *signal_msg;
const char *device; const char *device;
pa_assert(de); pa_assert(de);
@ -463,28 +463,28 @@ static void send_device_updated_signal(struct dbus_entry *de, struct entry *e) {
device = e->device_valid ? e->device : ""; device = e->device_valid ? e->device : "";
pa_assert_se(signal = dbus_message_new_signal(de->object_path, INTERFACE_ENTRY, entry_signals[ENTRY_SIGNAL_DEVICE_UPDATED].name)); pa_assert_se(signal_msg = dbus_message_new_signal(de->object_path, INTERFACE_ENTRY, entry_signals[ENTRY_SIGNAL_DEVICE_UPDATED].name));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_STRING, &device, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_STRING, &device, DBUS_TYPE_INVALID));
pa_dbus_protocol_send_signal(de->userdata->dbus_protocol, signal); pa_dbus_protocol_send_signal(de->userdata->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
} }
static void send_volume_updated_signal(struct dbus_entry *de, struct entry *e) { static void send_volume_updated_signal(struct dbus_entry *de, struct entry *e) {
DBusMessage *signal; DBusMessage *signal_msg;
DBusMessageIter msg_iter; DBusMessageIter msg_iter;
pa_assert(de); pa_assert(de);
pa_assert(e); pa_assert(e);
pa_assert_se(signal = dbus_message_new_signal(de->object_path, INTERFACE_ENTRY, entry_signals[ENTRY_SIGNAL_VOLUME_UPDATED].name)); pa_assert_se(signal_msg = dbus_message_new_signal(de->object_path, INTERFACE_ENTRY, entry_signals[ENTRY_SIGNAL_VOLUME_UPDATED].name));
dbus_message_iter_init_append(signal, &msg_iter); dbus_message_iter_init_append(signal_msg, &msg_iter);
append_volume(&msg_iter, e); append_volume(&msg_iter, e);
pa_dbus_protocol_send_signal(de->userdata->dbus_protocol, signal); pa_dbus_protocol_send_signal(de->userdata->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
} }
static void send_mute_updated_signal(struct dbus_entry *de, struct entry *e) { static void send_mute_updated_signal(struct dbus_entry *de, struct entry *e) {
DBusMessage *signal; DBusMessage *signal_msg;
dbus_bool_t muted; dbus_bool_t muted;
pa_assert(de); pa_assert(de);
@ -494,10 +494,10 @@ static void send_mute_updated_signal(struct dbus_entry *de, struct entry *e) {
muted = e->muted; muted = e->muted;
pa_assert_se(signal = dbus_message_new_signal(de->object_path, INTERFACE_ENTRY, entry_signals[ENTRY_SIGNAL_MUTE_UPDATED].name)); pa_assert_se(signal_msg = dbus_message_new_signal(de->object_path, INTERFACE_ENTRY, entry_signals[ENTRY_SIGNAL_MUTE_UPDATED].name));
pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_BOOLEAN, &muted, DBUS_TYPE_INVALID)); pa_assert_se(dbus_message_append_args(signal_msg, DBUS_TYPE_BOOLEAN, &muted, DBUS_TYPE_INVALID));
pa_dbus_protocol_send_signal(de->userdata->dbus_protocol, signal); pa_dbus_protocol_send_signal(de->userdata->dbus_protocol, signal_msg);
dbus_message_unref(signal); dbus_message_unref(signal_msg);
} }
static void handle_get_interface_revision(DBusConnection *conn, DBusMessage *msg, void *userdata) { static void handle_get_interface_revision(DBusConnection *conn, DBusMessage *msg, void *userdata) {

32
src/pulsecore/protocol-dbus.c
View file

@ -958,7 +958,7 @@ pa_client *pa_dbus_protocol_get_client(pa_dbus_protocol *p, DBusConnection *conn
void pa_dbus_protocol_add_signal_listener( void pa_dbus_protocol_add_signal_listener(
pa_dbus_protocol *p, pa_dbus_protocol *p,
DBusConnection *conn, DBusConnection *conn,
const char *signal, const char *signal_name,
char **objects, char **objects,
unsigned n_objects) { unsigned n_objects) {
struct connection_entry *conn_entry; struct connection_entry *conn_entry;
@ -978,18 +978,18 @@ void pa_dbus_protocol_add_signal_listener(
while ((object_path = pa_idxset_steal_first(conn_entry->all_signals_objects, NULL))) while ((object_path = pa_idxset_steal_first(conn_entry->all_signals_objects, NULL)))
pa_xfree(object_path); pa_xfree(object_path);
if (signal) { if (signal_name) {
conn_entry->listening_for_all_signals = FALSE; conn_entry->listening_for_all_signals = FALSE;
/* Replace the old object list with a new one. */ /* Replace the old object list with a new one. */
if ((object_set = pa_hashmap_remove(conn_entry->listening_signals, signal))) if ((object_set = pa_hashmap_remove(conn_entry->listening_signals, signal_name)))
pa_idxset_free(object_set, free_listened_object_name_cb, NULL); pa_idxset_free(object_set, free_listened_object_name_cb, NULL);
object_set = pa_idxset_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func); object_set = pa_idxset_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
for (i = 0; i < n_objects; ++i) for (i = 0; i < n_objects; ++i)
pa_idxset_put(object_set, pa_xstrdup(objects[i]), NULL); pa_idxset_put(object_set, pa_xstrdup(objects[i]), NULL);
pa_hashmap_put(conn_entry->listening_signals, signal, object_set); pa_hashmap_put(conn_entry->listening_signals, signal_name, object_set);
} else { } else {
conn_entry->listening_for_all_signals = TRUE; conn_entry->listening_for_all_signals = TRUE;
@ -1004,7 +1004,7 @@ void pa_dbus_protocol_add_signal_listener(
} }
} }
void pa_dbus_protocol_remove_signal_listener(pa_dbus_protocol *p, DBusConnection *conn, const char *signal) { void pa_dbus_protocol_remove_signal_listener(pa_dbus_protocol *p, DBusConnection *conn, const char *signal_name) {
struct connection_entry *conn_entry; struct connection_entry *conn_entry;
pa_idxset *object_set; pa_idxset *object_set;
@ -1013,8 +1013,8 @@ void pa_dbus_protocol_remove_signal_listener(pa_dbus_protocol *p, DBusConnection
pa_assert_se((conn_entry = pa_hashmap_get(p->connections, conn))); pa_assert_se((conn_entry = pa_hashmap_get(p->connections, conn)));
if (signal) { if (signal_name) {
if ((object_set = pa_hashmap_get(conn_entry->listening_signals, signal))) if ((object_set = pa_hashmap_get(conn_entry->listening_signals, signal_name)))
pa_idxset_free(object_set, free_listened_object_name_cb, NULL); pa_idxset_free(object_set, free_listened_object_name_cb, NULL);
} else { } else {
@ -1030,7 +1030,7 @@ void pa_dbus_protocol_remove_signal_listener(pa_dbus_protocol *p, DBusConnection
} }
} }
void pa_dbus_protocol_send_signal(pa_dbus_protocol *p, DBusMessage *signal) { void pa_dbus_protocol_send_signal(pa_dbus_protocol *p, DBusMessage *signal_name) {
struct connection_entry *conn_entry; struct connection_entry *conn_entry;
void *state = NULL; void *state = NULL;
pa_idxset *object_set; pa_idxset *object_set;
@ -1038,24 +1038,24 @@ void pa_dbus_protocol_send_signal(pa_dbus_protocol *p, DBusMessage *signal) {
char *signal_string; char *signal_string;
pa_assert(p); pa_assert(p);
pa_assert(signal); pa_assert(signal_name);
pa_assert(dbus_message_get_type(signal) == DBUS_MESSAGE_TYPE_SIGNAL); pa_assert(dbus_message_get_type(signal_name) == DBUS_MESSAGE_TYPE_SIGNAL);
pa_assert_se(dbus_message_get_interface(signal)); pa_assert_se(dbus_message_get_interface(signal_name));
pa_assert_se(dbus_message_get_member(signal)); pa_assert_se(dbus_message_get_member(signal_name));
signal_string = pa_sprintf_malloc("%s.%s", dbus_message_get_interface(signal), dbus_message_get_member(signal)); signal_string = pa_sprintf_malloc("%s.%s", dbus_message_get_interface(signal_name), dbus_message_get_member(signal_name));
PA_HASHMAP_FOREACH(conn_entry, p->connections, state) { PA_HASHMAP_FOREACH(conn_entry, p->connections, state) {
if ((conn_entry->listening_for_all_signals /* Case 1: listening for all signals */ if ((conn_entry->listening_for_all_signals /* Case 1: listening for all signals */
&& (pa_idxset_get_by_data(conn_entry->all_signals_objects, dbus_message_get_path(signal), NULL) && (pa_idxset_get_by_data(conn_entry->all_signals_objects, dbus_message_get_path(signal_name), NULL)
|| pa_idxset_isempty(conn_entry->all_signals_objects))) || pa_idxset_isempty(conn_entry->all_signals_objects)))
|| (!conn_entry->listening_for_all_signals /* Case 2: not listening for all signals */ || (!conn_entry->listening_for_all_signals /* Case 2: not listening for all signals */
&& (object_set = pa_hashmap_get(conn_entry->listening_signals, signal_string)) && (object_set = pa_hashmap_get(conn_entry->listening_signals, signal_string))
&& (pa_idxset_get_by_data(object_set, dbus_message_get_path(signal), NULL) && (pa_idxset_get_by_data(object_set, dbus_message_get_path(signal_name), NULL)
|| pa_idxset_isempty(object_set)))) { || pa_idxset_isempty(object_set)))) {
pa_assert_se(signal_copy = dbus_message_copy(signal)); pa_assert_se(signal_copy = dbus_message_copy(signal_name));
pa_assert_se(dbus_connection_send(conn_entry->connection, signal_copy, NULL)); pa_assert_se(dbus_connection_send(conn_entry->connection, signal_copy, NULL));
dbus_message_unref(signal_copy); dbus_message_unref(signal_copy);
} }