From 7275b04d86b876e76c958170541c1d5922566828 Mon Sep 17 00:00:00 2001 From: Seungbae Shin Date: Thu, 29 Oct 2020 16:34:37 +0900 Subject: [PATCH] stream-manager-dbus: use pa dbus wrapper function if possible [Version] 13.0.36 [Issue Type] Revise Change-Id: Ib30dd5934fa4a2554652feb550937d15a2fa177f --- packaging/pulseaudio-modules-tizen.spec | 2 +- src/stream-manager-dbus.c | 708 +++++++++++++------------------- 2 files changed, 278 insertions(+), 432 deletions(-) diff --git a/packaging/pulseaudio-modules-tizen.spec b/packaging/pulseaudio-modules-tizen.spec index e6f794d..9f5b1f7 100644 --- a/packaging/pulseaudio-modules-tizen.spec +++ b/packaging/pulseaudio-modules-tizen.spec @@ -1,6 +1,6 @@ Name: pulseaudio-modules-tizen Summary: Pulseaudio modules for Tizen -Version: 13.0.35 +Version: 13.0.36 Release: 0 Group: Multimedia/Audio License: LGPL-2.1+ diff --git a/src/stream-manager-dbus.c b/src/stream-manager-dbus.c index c365345..d5c87b3 100644 --- a/src/stream-manager-dbus.c +++ b/src/stream-manager-dbus.c @@ -381,6 +381,28 @@ static pa_dbus_method_handler method_handlers[METHOD_HANDLER_MAX] = { .receive_cb = handle_publish_local_device }, }; +static int get_stream_type(const char *direction, stream_type_t *stream_type) { + if (pa_safe_streq(direction, "in")) + *stream_type = STREAM_SOURCE_OUTPUT; + else if (pa_safe_streq(direction, "out")) + *stream_type = STREAM_SINK_INPUT; + else + return -1; + + return 0; +} + +static int get_direction_type(const char *direction, stream_direction_t *direction_type) { + if (pa_safe_streq(direction, "in")) + *direction_type = STREAM_DIRECTION_IN; + else if (pa_safe_streq(direction, "out")) + *direction_type = STREAM_DIRECTION_OUT; + else + return -1; + + return 0; +} + static DBusHandlerResult handle_introspect(DBusConnection *conn, DBusMessage *msg, void *userdata) { const char *xml = STREAM_MGR_INTROSPECT_XML; DBusMessage *r = NULL; @@ -401,10 +423,10 @@ static DBusHandlerResult handle_introspect(DBusConnection *conn, DBusMessage *ms } static void handle_get_stream_list(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; stream_list list; DBusMessage *reply = NULL; DBusMessageIter msg_iter; - pa_stream_manager *m = (pa_stream_manager*)userdata; pa_assert(conn); pa_assert(msg); @@ -429,11 +451,11 @@ static void handle_get_stream_list(DBusConnection *conn, DBusMessage *msg, void } static void handle_get_stream_info(DBusConnection *conn, DBusMessage *msg, void *userdata) { - char *type; + pa_stream_manager *m = (pa_stream_manager *)userdata; + const char *type; stream_info_per_type info; DBusMessage *reply = NULL; DBusMessageIter msg_iter; - pa_stream_manager *m = (pa_stream_manager*)userdata; pa_assert(conn); pa_assert(msg); @@ -550,15 +572,14 @@ static ret_msg_t update_devices_and_trigger_routing(pa_stream_manager *m, stream } static void handle_set_stream_route_devices(DBusConnection *conn, DBusMessage *msg, void *userdata) { - uint32_t id = 0; + pa_stream_manager *m = (pa_stream_manager *)userdata; int i = 0; - uint32_t *in_device_list = NULL; - uint32_t *out_device_list = NULL; - int list_len_in = 0; - int list_len_out = 0; + dbus_uint32_t *in_device_list = NULL; + dbus_uint32_t *out_device_list = NULL; + dbus_uint32_t id = 0; + dbus_uint32_t list_len_in = 0; + dbus_uint32_t list_len_out = 0; stream_parent *sp = NULL; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; ret_msg_t ret = RET_MSG_OK; pa_assert(conn); @@ -570,11 +591,9 @@ static void handle_set_stream_route_devices(DBusConnection *conn, DBusMessage *m DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &in_device_list, &list_len_in, DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &out_device_list, &list_len_out, DBUS_TYPE_INVALID)); - pa_log_info("id[%u], in_device_list[%p]:length[%d], out_device_list[%p]:length[%d]", + pa_log_info("id[%u], in_device_list[%p]:length[%u], out_device_list[%p]:length[%u]", id, in_device_list, list_len_in, out_device_list, list_len_out); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - sp = pa_hashmap_get(m->stream_parents, (const void*)id); if (!sp) { pa_log_error("could not find matching client for this parent_id[%u]", id); @@ -606,9 +625,9 @@ static void handle_set_stream_route_devices(DBusConnection *conn, DBusMessage *m } pa_idxset_remove_all(sp->idx_route_in_devices, pa_xfree); - if (in_device_list && list_len_in) { + if (in_device_list) { for (i = 0; i < list_len_in; i++) { - pa_idxset_put(sp->idx_route_in_devices, pa_xmemdup(&in_device_list[i], sizeof(uint32_t)), NULL); + pa_idxset_put(sp->idx_route_in_devices, pa_xmemdup(&in_device_list[i], sizeof(dbus_uint32_t)), NULL); pa_log_debug(" -- [in] device id:%u", in_device_list[i]); } } @@ -616,30 +635,28 @@ static void handle_set_stream_route_devices(DBusConnection *conn, DBusMessage *m goto finish; pa_idxset_remove_all(sp->idx_route_out_devices, pa_xfree); - if (out_device_list && list_len_out) { + if (out_device_list) { for (i = 0; i < list_len_out; i++) { - pa_idxset_put(sp->idx_route_out_devices, pa_xmemdup(&out_device_list[i], sizeof(uint32_t)), NULL); + pa_idxset_put(sp->idx_route_out_devices, pa_xmemdup(&out_device_list[i], sizeof(dbus_uint32_t)), NULL); pa_log_debug(" -- [out] device id:%u", out_device_list[i]); } } - if ((ret = update_devices_and_trigger_routing(m, sp, STREAM_SINK_INPUT))) - goto finish; + + ret = update_devices_and_trigger_routing(m, sp, STREAM_SINK_INPUT); finish: - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], DBUS_TYPE_INVALID)); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static void handle_set_stream_route_option(DBusConnection *conn, DBusMessage *msg, void *userdata) { - uint32_t id = 0; + pa_stream_manager *m = (pa_stream_manager *)userdata; + dbus_uint32_t id = 0; const char *name = NULL; - int32_t value = 0; + dbus_int32_t value = 0; bool updated = false; stream_parent *sp = NULL; stream_route_option route_option; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -650,9 +667,7 @@ static void handle_set_stream_route_option(DBusConnection *conn, DBusMessage *ms DBUS_TYPE_STRING, &name, DBUS_TYPE_INT32, &value, DBUS_TYPE_INVALID)); - pa_log_info("name[%s], value[%d]", name, value); - - pa_assert_se((reply = dbus_message_new_method_return(msg))); + pa_log_info("id[%u], name[%s], value[%d]", id, name, value); sp = pa_hashmap_get(m->stream_parents, (const void*)id); if (sp) { @@ -679,21 +694,18 @@ static void handle_set_stream_route_option(DBusConnection *conn, DBusMessage *ms } if (!updated) { pa_log_error("invalid state"); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_NO_STREAM], DBUS_TYPE_INVALID)); - } else - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); + ret = RET_MSG_ERROR_NO_STREAM; + } } else { pa_log_error("invalid arguments"); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INVALID_ARGUMENT], DBUS_TYPE_INVALID)); + ret = RET_MSG_ERROR_INVALID_ARGUMENT; } - } else { pa_log_error("could not find matching client for this parent_id[%u]", id); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); + ret = RET_MSG_ERROR_INTERNAL; } - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static int get_device_for_preference(pa_stream_manager *m, stream_parent *sp, stream_direction_t direction, uint32_t device_id, pa_tz_device **device) { @@ -721,9 +733,10 @@ static int get_device_for_preference(pa_stream_manager *m, stream_parent *sp, st } static void handle_set_stream_preferred_device(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *device_direction = NULL; - uint32_t sp_id = 0; - uint32_t device_id = 0; + dbus_uint32_t sp_id = 0; + dbus_uint32_t device_id = 0; uint32_t idx; uint32_t count = 0; stream_direction_t direction; @@ -741,9 +754,6 @@ static void handle_set_stream_preferred_device(DBusConnection *conn, DBusMessage pa_hashmap *devices; void *new_device = NULL; ret_msg_t ret = RET_MSG_OK; - DBusMessage *reply = NULL; - - pa_stream_manager *m = (pa_stream_manager*)userdata; pa_assert(conn); pa_assert(msg); @@ -756,19 +766,13 @@ static void handle_set_stream_preferred_device(DBusConnection *conn, DBusMessage DBUS_TYPE_INVALID)); pa_log_info("stream parent id[%u], device direction[%s], device_id[%u]", sp_id, device_direction, device_id); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - if (!(sp = pa_hashmap_get(m->stream_parents, (const void*)sp_id))) { pa_log_error("could not find matching client for this parent_id[%u]", sp_id); ret = RET_MSG_ERROR_INTERNAL; goto finish; } - if (pa_safe_streq(device_direction, "in")) - direction = STREAM_DIRECTION_IN; - else if (pa_safe_streq(device_direction, "out")) - direction = STREAM_DIRECTION_OUT; - else { + if (get_direction_type(device_direction, &direction) != 0) { ret = RET_MSG_ERROR_INVALID_ARGUMENT; goto finish; } @@ -863,14 +867,13 @@ static void handle_set_stream_preferred_device(DBusConnection *conn, DBusMessage } finish: - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], DBUS_TYPE_INVALID)); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static void handle_get_stream_preferred_device(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; stream_parent *sp = NULL; - uint32_t sp_id = 0; + dbus_uint32_t sp_id = 0; uint32_t in_device_id = 0; uint32_t out_device_id = 0; const char *pref_in_type, *pref_out_type; @@ -882,8 +885,6 @@ static void handle_get_stream_preferred_device(DBusConnection *conn, DBusMessage ret_msg_t ret = RET_MSG_OK; DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; - pa_assert(conn); pa_assert(msg); pa_assert(m); @@ -910,13 +911,13 @@ static void handle_get_stream_preferred_device(DBusConnection *conn, DBusMessage dm_device_list = pa_device_manager_get_device_list(m->dm); PA_IDXSET_FOREACH(dm_device, dm_device_list, idx) { dm_direction = pa_tz_device_get_direction(dm_device); - if (!in_device_id && dm_direction & DM_DEVICE_DIRECTION_IN) { + if (in_device_id == 0 && (dm_direction & DM_DEVICE_DIRECTION_IN)) { if (pa_safe_streq(pref_in_type, pa_tz_device_get_type(dm_device))) { if (pa_safe_streq(pref_in_role, pa_tz_device_get_role(dm_device, pref_in_role))) in_device_id = pa_tz_device_get_id(dm_device); } } - if (!out_device_id && dm_direction & DM_DEVICE_DIRECTION_OUT) { + if (out_device_id == 0 && (dm_direction & DM_DEVICE_DIRECTION_OUT)) { if (pa_safe_streq(pref_out_type, pa_tz_device_get_type(dm_device))) { if (pa_safe_streq(pref_out_role, pa_tz_device_get_role(dm_device, pref_out_role))) out_device_id = pa_tz_device_get_id(dm_device); @@ -928,9 +929,10 @@ static void handle_get_stream_preferred_device(DBusConnection *conn, DBusMessage pa_log_info("preferred OUT device: type[%s] role[%s] id[%u]", pref_out_type, pref_out_role, out_device_id); finish: - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &in_device_id, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &out_device_id, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], DBUS_TYPE_INVALID)); + pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &in_device_id, + DBUS_TYPE_UINT32, &out_device_id, + DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], + DBUS_TYPE_INVALID)); pa_assert_se(dbus_connection_send(conn, reply, NULL)); dbus_message_unref(reply); } @@ -1052,10 +1054,11 @@ static void rollback_process_from_preemptive_device(pa_stream_manager *m, stream } static void handle_set_stream_preemptive_device(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *stream_type = NULL; const char *device_direction = NULL; stream_direction_t direction; - uint32_t device_id = 0; + dbus_uint32_t device_id = 0; stream_info *s = NULL; pa_tz_device *device = NULL; char *device_type = NULL; @@ -1064,9 +1067,6 @@ static void handle_set_stream_preemptive_device(DBusConnection *conn, DBusMessag uint32_t idx; bool found = false; ret_msg_t ret = RET_MSG_OK; - DBusMessage *reply = NULL; - - pa_stream_manager *m = (pa_stream_manager*)userdata; pa_assert(conn); pa_assert(msg); @@ -1079,19 +1079,13 @@ static void handle_set_stream_preemptive_device(DBusConnection *conn, DBusMessag DBUS_TYPE_INVALID)); pa_log_info("stream type[%s], device direction[%s], device_id[%u]", stream_type, device_direction, device_id); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - if ((s = pa_hashmap_get(m->stream_infos, stream_type)) == NULL) { pa_log_error("could not find this stream type(%s)", stream_type); ret = RET_MSG_ERROR_INTERNAL; goto finish; } - if (pa_safe_streq(device_direction, "in")) - direction = STREAM_DIRECTION_IN; - else if (pa_safe_streq(device_direction, "out")) - direction = STREAM_DIRECTION_OUT; - else { + if (get_direction_type(device_direction, &direction) != 0) { ret = RET_MSG_ERROR_INVALID_ARGUMENT; goto finish; } @@ -1141,7 +1135,8 @@ static void handle_set_stream_preemptive_device(DBusConnection *conn, DBusMessag /* move streams and change routing */ if (device_id == 0) { - if (!(device = pa_device_manager_get_device_by_id(m->dm, prev_device_id)) || !pa_safe_streq(device->type, prev_device_type)) { + if (!(device = pa_device_manager_get_device_by_id(m->dm, prev_device_id)) || + !pa_safe_streq(device->type, prev_device_type)) { pa_log_debug("could not find the previous device of id[%u], type[%s], nothing to do.", prev_device_id, prev_device_type); goto finish; } @@ -1151,12 +1146,11 @@ static void handle_set_stream_preemptive_device(DBusConnection *conn, DBusMessag } finish: - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], DBUS_TYPE_INVALID)); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static void handle_get_stream_preemptive_device(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *stream_type = NULL; stream_info *s = NULL; uint32_t in_device_id = 0; @@ -1166,8 +1160,6 @@ static void handle_get_stream_preemptive_device(DBusConnection *conn, DBusMessag ret_msg_t ret = RET_MSG_OK; DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; - pa_assert(conn); pa_assert(msg); pa_assert(m); @@ -1194,22 +1186,21 @@ static void handle_get_stream_preemptive_device(DBusConnection *conn, DBusMessag pa_log_info("preemptive OUT device: type[%s] id[%u]", out_device_type, out_device_id); finish: - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &in_device_id, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &out_device_id, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], DBUS_TYPE_INVALID)); + pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &in_device_id, + DBUS_TYPE_UINT32, &out_device_id, + DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], + DBUS_TYPE_INVALID)); pa_assert_se(dbus_connection_send(conn, reply, NULL)); dbus_message_unref(reply); } static void handle_set_volume_level(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *direction = NULL; const char *type = NULL; - uint32_t level = 0; + dbus_uint32_t level = 0; stream_type_t stream_type = STREAM_SINK_INPUT; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; int ret = 0; - ret_msg_t ret_msg = RET_MSG_ERROR_INTERNAL; pa_assert(conn); pa_assert(msg); @@ -1222,47 +1213,35 @@ static void handle_set_volume_level(DBusConnection *conn, DBusMessage *msg, void DBUS_TYPE_INVALID)); pa_log_info("direction[%s], type[%s], level[%u]", direction, type, level); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - - if (pa_safe_streq(direction, "in")) - stream_type = STREAM_SOURCE_OUTPUT; - else if (pa_safe_streq(direction, "out")) - stream_type = STREAM_SINK_INPUT; - else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret_msg], DBUS_TYPE_INVALID)); - ret = -1; + if (get_stream_type(direction, &stream_type) != 0) { + ret = RET_MSG_ERROR_INTERNAL; goto finish; } /* check vconf update here, volume will not be set if update fails */ if ((ret = update_volume_vconf(type, level))) { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret_msg], DBUS_TYPE_INVALID)); + ret = RET_MSG_ERROR_INTERNAL; goto finish; } - if ((ret = set_volume_level_by_type(m, stream_type, type, level))) { - if (ret == -2) - ret_msg = RET_MSG_ERROR_INVALID_ARGUMENT; - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret_msg], DBUS_TYPE_INVALID)); - } else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); - } + if ((ret = set_volume_level_by_type(m, stream_type, type, level)) != 0) + ret = (ret == -2) ? RET_MSG_ERROR_INVALID_ARGUMENT : RET_MSG_ERROR_INTERNAL; finish: - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); - if (!ret) + if (ret == 0) send_volume_changed_signal(conn, direction, type, level); } static void handle_get_volume_level(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *direction = NULL; const char *type = NULL; uint32_t level = 0; stream_type_t stream_type = STREAM_SINK_INPUT; DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -1276,36 +1255,30 @@ static void handle_get_volume_level(DBusConnection *conn, DBusMessage *msg, void pa_assert_se((reply = dbus_message_new_method_return(msg))); - if (pa_safe_streq(direction, "in")) - stream_type = STREAM_SOURCE_OUTPUT; - else if (pa_safe_streq(direction, "out")) - stream_type = STREAM_SINK_INPUT; - else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &level, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); + if (get_stream_type(direction, &stream_type) != 0) { + ret = RET_MSG_ERROR_INTERNAL; goto finish; } - if (get_volume_level_by_type(m, GET_VOLUME_CURRENT_LEVEL, stream_type, type, &level)) { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &level, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); - } else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &level, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); - } + if (get_volume_level_by_type(m, GET_VOLUME_CURRENT_LEVEL, stream_type, type, &level) != 0) + ret = RET_MSG_ERROR_INTERNAL; finish: + pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &level, + DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], + DBUS_TYPE_INVALID)); pa_assert_se(dbus_connection_send(conn, reply, NULL)); dbus_message_unref(reply); } static void handle_get_volume_max_level(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *direction = NULL; const char *type = NULL; uint32_t level = 0; stream_type_t stream_type = STREAM_SINK_INPUT; DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -1319,36 +1292,29 @@ static void handle_get_volume_max_level(DBusConnection *conn, DBusMessage *msg, pa_assert_se((reply = dbus_message_new_method_return(msg))); - if (pa_safe_streq(direction, "in")) - stream_type = STREAM_SOURCE_OUTPUT; - else if (pa_safe_streq(direction, "out")) - stream_type = STREAM_SINK_INPUT; - else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &level, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); + if (get_stream_type(direction, &stream_type) != 0) { + ret = RET_MSG_ERROR_INTERNAL; goto finish; } - if (get_volume_level_by_type(m, GET_VOLUME_MAX_LEVEL, stream_type, type, &level)) { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &level, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); - } else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &level, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); - } + if (get_volume_level_by_type(m, GET_VOLUME_MAX_LEVEL, stream_type, type, &level) != 0) + ret = RET_MSG_ERROR_INTERNAL; + finish: + pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &level, + DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], + DBUS_TYPE_INVALID)); pa_assert_se(dbus_connection_send(conn, reply, NULL)); dbus_message_unref(reply); } static void handle_set_volume_mute(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *direction = NULL; const char *type = NULL; - uint32_t do_mute = 0; + dbus_uint32_t do_mute = 0; stream_type_t stream_type = STREAM_SINK_INPUT; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; - int ret = 0; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -1361,40 +1327,33 @@ static void handle_set_volume_mute(DBusConnection *conn, DBusMessage *msg, void DBUS_TYPE_INVALID)); pa_log_info("direction[%s], type[%s], do_mute[%u]", direction, type, do_mute); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - - if (pa_safe_streq(direction, "in")) - stream_type = STREAM_SOURCE_OUTPUT; - else if (pa_safe_streq(direction, "out")) - stream_type = STREAM_SINK_INPUT; - else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); + if (get_stream_type(direction, &stream_type) != 0) { + ret = RET_MSG_ERROR_INTERNAL; goto finish; } /* check vconf update here, mute will not be set if update fails */ - if ((ret = update_mute_vconf(type, do_mute))) { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); + if (update_mute_vconf(type, do_mute) != 0) { + ret = RET_MSG_ERROR_INTERNAL; goto finish; } - if (set_volume_mute_by_type(m, stream_type, type, (bool)do_mute)) - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); - else - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); + if (set_volume_mute_by_type(m, stream_type, type, (bool)do_mute) != 0) + ret = RET_MSG_ERROR_INTERNAL; finish: - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static void handle_get_volume_mute(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *direction = NULL; const char *type = NULL; - uint32_t is_muted = 0; + dbus_uint32_t is_muted = 0; stream_type_t stream_type = STREAM_SINK_INPUT; DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + bool _is_muted = false; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -1408,38 +1367,33 @@ static void handle_get_volume_mute(DBusConnection *conn, DBusMessage *msg, void pa_assert_se((reply = dbus_message_new_method_return(msg))); - if (pa_safe_streq(direction, "in")) - stream_type = STREAM_SOURCE_OUTPUT; - else if (pa_safe_streq(direction, "out")) - stream_type = STREAM_SINK_INPUT; - else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &is_muted, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); - goto fail; + if (get_stream_type(direction, &stream_type) != 0) { + ret = RET_MSG_ERROR_INTERNAL; + goto finish; } - if (get_volume_mute_by_type(m, stream_type, type, (bool*)&is_muted)) { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &is_muted, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); - } else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &is_muted, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); + if (get_volume_mute_by_type(m, stream_type, type, &_is_muted) != 0) { + ret = RET_MSG_ERROR_INTERNAL; + goto finish; } -fail: + is_muted = (dbus_uint32_t)_is_muted; + +finish: + pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &is_muted, + DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], + DBUS_TYPE_INVALID)); pa_assert_se(dbus_connection_send(conn, reply, NULL)); dbus_message_unref(reply); } static void handle_set_volume_ratio(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *direction = NULL; - uint32_t idx; + dbus_uint32_t idx; double ratio; stream_type_t stream_type = STREAM_SINK_INPUT; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; - int ret = 0; - ret_msg_t ret_msg = RET_MSG_ERROR_INTERNAL; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -1452,49 +1406,34 @@ static void handle_set_volume_ratio(DBusConnection *conn, DBusMessage *msg, void DBUS_TYPE_INVALID)); pa_log_info("direction[%s], idx[%u], ratio[%f]", direction, idx, ratio); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - - if (pa_safe_streq(direction, "in")) - stream_type = STREAM_SOURCE_OUTPUT; - else if (pa_safe_streq(direction, "out")) - stream_type = STREAM_SINK_INPUT; - else { + if (get_stream_type(direction, &stream_type) != 0) { pa_log_error("invalid direction[%s]", direction); - goto invalid_argument; + ret = RET_MSG_ERROR_INVALID_ARGUMENT; + goto finish; } /* Check the ratio range (0.0 ~ 1.0) */ if (ratio < 0 || ratio > 1) { pa_log_error("invalid range, ratio[%f]", ratio); - goto invalid_argument; - } - - if ((ret = set_volume_ratio_by_idx(m, stream_type, idx, ratio))) { - if (ret == -2) - ret_msg = RET_MSG_ERROR_NO_STREAM; - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret_msg], DBUS_TYPE_INVALID)); - } else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); + ret = RET_MSG_ERROR_INVALID_ARGUMENT; + goto finish; } - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); - return; + if ((ret = set_volume_ratio_by_idx(m, stream_type, idx, ratio)) != 0) + ret = (ret == -2) ? RET_MSG_ERROR_NO_STREAM : RET_MSG_ERROR_INTERNAL; -invalid_argument: - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INVALID_ARGUMENT], - DBUS_TYPE_INVALID)); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); +finish: + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static void handle_get_volume_ratio(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *direction = NULL; - uint32_t idx = 0; + dbus_uint32_t idx = 0; double ratio; stream_type_t stream_type = STREAM_SINK_INPUT; DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -1508,38 +1447,33 @@ static void handle_get_volume_ratio(DBusConnection *conn, DBusMessage *msg, void pa_assert_se((reply = dbus_message_new_method_return(msg))); - if (pa_safe_streq(direction, "in")) - stream_type = STREAM_SOURCE_OUTPUT; - else if (pa_safe_streq(direction, "out")) - stream_type = STREAM_SINK_INPUT; - else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_DOUBLE, &ratio, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INVALID_ARGUMENT], DBUS_TYPE_INVALID)); + if (get_stream_type(direction, &stream_type) != 0) { + pa_log_error("invalid direction[%s]", direction); + ret = RET_MSG_ERROR_INVALID_ARGUMENT; goto finish; } - if (get_volume_ratio_by_idx(m, stream_type, idx, &ratio)) { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_DOUBLE, &ratio, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_NO_STREAM], DBUS_TYPE_INVALID)); - } else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_DOUBLE, &ratio, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); - } + if (get_volume_ratio_by_idx(m, stream_type, idx, &ratio) != 0) + ret = RET_MSG_ERROR_NO_STREAM; finish: + pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_DOUBLE, &ratio, + DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], + DBUS_TYPE_INVALID)); pa_assert_se(dbus_connection_send(conn, reply, NULL)); dbus_message_unref(reply); } static void handle_get_current_volume_type(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *direction = NULL; - const char *type = NULL; + const char *type = dbus_str_none; void *s = NULL; stream_type_t stream_type = STREAM_SINK_INPUT; DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; uint32_t idx = 0; pa_idxset *streams = NULL; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -1552,18 +1486,13 @@ static void handle_get_current_volume_type(DBusConnection *conn, DBusMessage *ms pa_assert_se((reply = dbus_message_new_method_return(msg))); - if (pa_safe_streq(direction, "in")) { - stream_type = STREAM_SOURCE_OUTPUT; - streams = m->core->source_outputs; - } else if (pa_safe_streq(direction, "out")) { - stream_type = STREAM_SINK_INPUT; - streams = m->core->sink_inputs; - } else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &dbus_str_none, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); - goto fail; + if (get_stream_type(direction, &stream_type) != 0) { + ret = RET_MSG_ERROR_INTERNAL; + goto finish; } + streams = (stream_type == STREAM_SOURCE_OUTPUT) ? m->core->source_outputs : m->core->sink_inputs; + /* Get a volume type of a stream that has the max priority role among all the running streams regardless of devices. Note that it does not represent any focus status of a stream rather only checking the priority of it */ if (pa_idxset_size(streams)) { @@ -1590,27 +1519,26 @@ static void handle_get_current_volume_type(DBusConnection *conn, DBusMessage *ms type = cur_max_type; } - if (type) { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &type, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); - } else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &dbus_str_none, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_NO_STREAM], DBUS_TYPE_INVALID)); - } + if (!strncmp(type, dbus_str_none, strlen(dbus_str_none))) + ret = RET_MSG_ERROR_NO_STREAM; -fail: +finish: + pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &type, + DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], + DBUS_TYPE_INVALID)); pa_assert_se(dbus_connection_send(conn, reply, NULL)); dbus_message_unref(reply); } static void handle_get_current_media_routing_path(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *direction = NULL; - const char *device_type = NULL; + const char *device_type = dbus_str_none; dm_device_direction_t dm_device_direction = DM_DEVICE_DIRECTION_NONE; stream_info *s = NULL; DBusMessage *reply = NULL; pa_tz_device *device = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + ret_msg_t ret = RET_MSG_ERROR_INTERNAL; pa_assert(conn); pa_assert(msg); @@ -1629,12 +1557,12 @@ static void handle_get_current_media_routing_path(DBusConnection *conn, DBusMess dm_device_direction = DM_DEVICE_DIRECTION_OUT; } else { pa_log_error("invalid direction[%s]", direction); - goto fail; + goto finish; } if ((s = pa_hashmap_get(m->stream_infos, STREAM_ROLE_MEDIA)) == NULL) { pa_log_error("could not find media role"); - goto fail; + goto finish; } if (s->route_type == STREAM_ROUTE_TYPE_AUTO) { @@ -1643,39 +1571,34 @@ static void handle_get_current_media_routing_path(DBusConnection *conn, DBusMess device = get_media_last_device(m, dm_device_direction); } else { pa_log_error("unexpected routing type for media[%d]", s->route_type); - goto fail; + goto finish; } if (device) { device_type = pa_tz_device_get_type(device); - goto success; + ret = RET_MSG_OK; } else { pa_log_error("could not found matched device"); } -fail: - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &dbus_str_none, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); - return; -success: - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &device_type, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); +finish: + pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &device_type, + DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], + DBUS_TYPE_INVALID)); pa_assert_se(dbus_connection_send(conn, reply, NULL)); dbus_message_unref(reply); } static void handle_update_focus_status(DBusConnection *conn, DBusMessage *msg, void *userdata) { - uint32_t id = 0; + pa_stream_manager *m = (pa_stream_manager *)userdata; + dbus_uint32_t id = 0; + dbus_uint32_t acquired_focus_status = 0; uint32_t idx = 0; uint32_t count = 0; - uint32_t acquired_focus_status = 0; stream_parent *sp = NULL; void *stream = NULL; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; int prev_status = STREAM_FOCUS_ACQUIRED_NONE; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -1687,8 +1610,6 @@ static void handle_update_focus_status(DBusConnection *conn, DBusMessage *msg, v DBUS_TYPE_INVALID)); pa_log_info("id[%u], acquired_focus_status[0x%x]", id, acquired_focus_status); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - if ((sp = pa_hashmap_get(m->stream_parents, (const void*)id))) { if (sp->focus_status != acquired_focus_status) { /* need to update */ @@ -1717,24 +1638,21 @@ static void handle_update_focus_status(DBusConnection *conn, DBusMessage *msg, v } else { pa_log_error("could not find matching client for this parent_id[%u]", id); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); - goto fail; + ret = RET_MSG_ERROR_INTERNAL; } - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); -fail: - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static void handle_update_focus_status_by_focus_id(DBusConnection *conn, DBusMessage *msg, void *userdata) { - int32_t id = 0; + pa_stream_manager *m = (pa_stream_manager *)userdata; + dbus_int32_t id = 0; + dbus_uint32_t acquired_focus_status = 0; uint32_t idx = 0; - uint32_t acquired_focus_status = 0; int32_t focus_id = 0; const char *focus_id_str; pa_sink_input *i = NULL; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + ret_msg_t ret = RET_MSG_ERROR_INTERNAL; pa_assert(conn); pa_assert(msg); @@ -1746,36 +1664,37 @@ static void handle_update_focus_status_by_focus_id(DBusConnection *conn, DBusMes DBUS_TYPE_INVALID)); pa_log_info("id[%d], acquired_focus_status[0x%x]", id, acquired_focus_status); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - /* Currently, we only support sink-inputs */ PA_IDXSET_FOREACH(i, m->core->sink_inputs, idx) { if ((focus_id_str = pa_proplist_gets(GET_STREAM_PROPLIST(i, STREAM_SINK_INPUT), PA_PROP_MEDIA_FOCUS_ID))) { if (pa_atoi(focus_id_str, &focus_id)) - continue; - if (id == focus_id) { + continue; + + if (id != focus_id) + continue; + pa_log_info("found matching sink-input(%p, %u) - focus_id(%d)", i, i->index, id); pa_proplist_sets(GET_STREAM_PROPLIST(i, STREAM_SINK_INPUT), PA_PROP_MEDIA_FOCUS_STATUS, acquired_focus_status ? STREAM_FOCUS_STATE_ACQUIRED : STREAM_FOCUS_STATE_RELEASED); + process_stream(m, i, STREAM_SINK_INPUT, PROCESS_COMMAND_CHANGE_ROUTE_BY_STREAM_FOCUS_CHANGED, false); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); - goto success; + ret = RET_MSG_OK; + break; } - } } - pa_log_error("could not find matching stream for this focus_id[%i]", id); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); -success: - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + + if (ret != RET_MSG_OK) + pa_log_error("could not find matching stream for this focus_id[%d]", id); + + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static void handle_update_restriction(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *name; - uint32_t value = 0; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + dbus_uint32_t value = 0; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -1787,17 +1706,10 @@ static void handle_update_restriction(DBusConnection *conn, DBusMessage *msg, vo DBUS_TYPE_INVALID)); pa_log_info("name[%s], value[%u]", name, value); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - - if (handle_restrictions(m, name, value) < 0) { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); - goto fail; - } + if (handle_restrictions(m, name, value) != 0) + ret = RET_MSG_ERROR_INTERNAL; - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); -fail: - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } #define MAX_CALL_PARAM_SIZE 32 @@ -1851,9 +1763,8 @@ static int32_t parse_call_parameters(const char *parameters, char *call_type, ch } static void handle_update_call_parameters(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *parameters; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; char call_type[MAX_CALL_PARAM_SIZE] = {0,}; char call_domain[MAX_CALL_PARAM_SIZE] = {0,}; char network_band[MAX_CALL_PARAM_SIZE] = {0,}; @@ -1869,33 +1780,27 @@ static void handle_update_call_parameters(DBusConnection *conn, DBusMessage *msg DBUS_TYPE_INVALID)); pa_log_info("parameters[%s]", parameters); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - - if (parse_call_parameters(parameters, call_type, call_domain, network_band) < 0) { + if (parse_call_parameters(parameters, call_type, call_domain, network_band) != 0) { ret = RET_MSG_ERROR_INTERNAL; - goto fail; + goto finish; } pa_log_debug("call_type[%s], call_domain[%s], network_band[%s]", call_type, call_domain, network_band); /* Currently, we only use network band */ route_option.name = "call-wideband"; - if (pa_safe_streq(network_band, "wb")) - route_option.value = 1; - else - route_option.value = 0; + route_option.value = pa_safe_streq(network_band, "wb") ? 1 : 0; + ret = do_notify(m, NOTIFY_COMMAND_UPDATE_ROUTE_OPTION, STREAM_SINK_INPUT, false, &route_option); -fail: - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], DBUS_TYPE_INVALID)); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); +finish: + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static void handle_set_filter(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *filter_name, *filter_parameters, *filter_group, *stream_type; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -1907,30 +1812,20 @@ static void handle_set_filter(DBusConnection *conn, DBusMessage *msg, void *user DBUS_TYPE_STRING, &filter_group, DBUS_TYPE_STRING, &stream_type, DBUS_TYPE_INVALID)); - pa_log_info("filter_name[%s], filter_parameters[%s], filter_group[%s], stream_type[%s]", filter_name, - filter_parameters, filter_group, stream_type); - - pa_assert_se((reply = dbus_message_new_method_return(msg))); + pa_log_info("filter_name[%s], filter_parameters[%s], filter_group[%s], stream_type[%s]", + filter_name, filter_parameters, filter_group, stream_type); /* Set filter sink according to stream type */ - if (update_filter(m, filter_name, filter_parameters, filter_group, stream_type) < 0) { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], - DBUS_TYPE_INVALID)); - goto fail; - } - - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], - DBUS_TYPE_INVALID)); + if (update_filter(m, filter_name, filter_parameters, filter_group, stream_type) != 0) + ret = RET_MSG_ERROR_INTERNAL; -fail: - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static void handle_unset_filter(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *stream_type; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -1941,27 +1836,17 @@ static void handle_unset_filter(DBusConnection *conn, DBusMessage *msg, void *us DBUS_TYPE_INVALID)); pa_log_info("stream_type[%s]", stream_type); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - /* Unset filter sink according to stream type */ - if (update_filter(m, NULL, NULL, NULL, stream_type) < 0) { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], - DBUS_TYPE_INVALID)); - goto fail; - } - - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], - DBUS_TYPE_INVALID)); + if (update_filter(m, NULL, NULL, NULL, stream_type) != 0) + ret = RET_MSG_ERROR_INTERNAL; -fail: - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static void handle_control_filter(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *filter_name, *filter_controls, *stream_type; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -1974,20 +1859,11 @@ static void handle_control_filter(DBusConnection *conn, DBusMessage *msg, void * DBUS_TYPE_INVALID)); pa_log_info("filter_name[%s], filter_controls[%s], stream_type[%s]", filter_name, filter_controls, stream_type); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - /* Control parameters to filter sink */ - if (control_filter(m, filter_name, filter_controls, stream_type, conn) < 0) { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], - DBUS_TYPE_INVALID)); - goto fail; - } + if (control_filter(m, filter_name, filter_controls, stream_type, conn) != 0) + ret = RET_MSG_ERROR_INTERNAL; - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], - DBUS_TYPE_INVALID)); -fail: - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static bool check_stream_exist_by_pid(pa_stream_manager *m, uint32_t pid, const char *stream_role, stream_type_t type) { @@ -2025,12 +1901,12 @@ static bool check_stream_exist_by_pid(pa_stream_manager *m, uint32_t pid, const } static void handle_check_stream_exist_by_pid(DBusConnection *conn, DBusMessage *msg, void *userdata) { - uint32_t pid = 0; + pa_stream_manager *m = (pa_stream_manager *)userdata; + dbus_uint32_t pid = 0; const char *type; const char *direction; stream_type_t stream_type = STREAM_SINK_INPUT; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -2043,29 +1919,16 @@ static void handle_check_stream_exist_by_pid(DBusConnection *conn, DBusMessage * DBUS_TYPE_INVALID)); pa_log_info("pid[%u], type[%s], direction[%s]", pid, type, direction); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - - if (pa_safe_streq(direction, "in")) - stream_type = STREAM_SOURCE_OUTPUT; - else if (pa_safe_streq(direction, "out")) - stream_type = STREAM_SINK_INPUT; - else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INVALID_ARGUMENT], - DBUS_TYPE_INVALID)); - goto fail; + if (get_stream_type(direction, &stream_type) != 0) { + ret = RET_MSG_ERROR_INVALID_ARGUMENT; + goto finish; } - if (!check_stream_exist_by_pid(m, pid, type, stream_type)) { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_NO_STREAM], - DBUS_TYPE_INVALID)); - goto fail; - } + if (!check_stream_exist_by_pid(m, pid, type, stream_type)) + ret = RET_MSG_ERROR_NO_STREAM; - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], - DBUS_TYPE_INVALID)); -fail: - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); +finish: + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static bool find_the_lastest_stream(pa_stream_manager *m, stream_type_t type, const char ** stream_roles, int length, uint32_t *pid) { @@ -2126,15 +1989,15 @@ static bool find_the_lastest_stream(pa_stream_manager *m, stream_type_t type, co } static void handle_get_pid_of_latest_stream(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *direction; const char **types; int length; stream_type_t stream_type = STREAM_SINK_INPUT; uint32_t pid = 0; - ret_msg_t ret_msg = RET_MSG_OK; + ret_msg_t ret = RET_MSG_OK; DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; pa_assert(conn); pa_assert(msg); @@ -2147,48 +2010,38 @@ static void handle_get_pid_of_latest_stream(DBusConnection *conn, DBusMessage *m pa_assert_se((reply = dbus_message_new_method_return(msg))); - if (pa_safe_streq(direction, "in")) - stream_type = STREAM_SOURCE_OUTPUT; - else if (pa_safe_streq(direction, "out")) - stream_type = STREAM_SINK_INPUT; - else { + if (get_stream_type(direction, &stream_type) != 0) { pa_log_error("invalid direction[%s]", direction); - goto invalid_argument; + ret = RET_MSG_ERROR_INVALID_ARGUMENT; + goto finish; } if (length <= 0) { pa_log_error("At least one stream type should be contained"); - goto invalid_argument; + ret = RET_MSG_ERROR_INVALID_ARGUMENT; + goto finish; } if (!find_the_lastest_stream(m, stream_type, types, length, &pid)) - ret_msg = RET_MSG_ERROR_NO_STREAM; - - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &pid, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret_msg], - DBUS_TYPE_INVALID)); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); - return; + ret = RET_MSG_ERROR_NO_STREAM; -invalid_argument: - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &pid, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INVALID_ARGUMENT], - DBUS_TYPE_INVALID)); +finish: + pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &pid, + DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], + DBUS_TYPE_INVALID)); pa_assert_se(dbus_connection_send(conn, reply, NULL)); dbus_message_unref(reply); } static void handle_activate_ducking(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; dbus_uint32_t id = 0; dbus_bool_t enable = 0; const char *target_stream = NULL; - uint32_t idx = 0; - pa_sink_input *i = NULL; dbus_uint32_t duration = 0; double ratio = 0.0; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + uint32_t idx = 0; + pa_sink_input *i = NULL; pa_cvolume vol; pa_cvolume_ramp vol_ramp; stream_ducking *sd = NULL; @@ -2210,8 +2063,6 @@ static void handle_activate_ducking(DBusConnection *conn, DBusMessage *msg, void pa_log_info("id[%u], enable[%u], target stream[%s], duration[%u], ratio[%lf]", id, enable, target_stream, duration, ratio); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - /* get stream_ducking */ sd = pa_hashmap_get(m->stream_duckings, (const void*)id); if (!sd) { @@ -2281,9 +2132,7 @@ static void handle_activate_ducking(DBusConnection *conn, DBusMessage *msg, void pa_log_info("ducking stream count[%p,%d]", sd, sd->ducking_stream_count); _ACTIVATE_DUCKING_DONE: - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret_msg], DBUS_TYPE_INVALID)); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret_msg]); if (ret_msg != RET_MSG_OK) return; @@ -2315,9 +2164,9 @@ _ACTIVATE_DUCKING_DONE: } static void handle_get_ducking_state(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; dbus_uint32_t id = 0; DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; stream_ducking *sd = NULL; dbus_bool_t is_ducked = FALSE; ret_msg_t ret_msg = RET_MSG_OK; @@ -2334,16 +2183,19 @@ static void handle_get_ducking_state(DBusConnection *conn, DBusMessage *msg, voi /* get stream_ducking */ sd = pa_hashmap_get(m->stream_duckings, (const void *)id); - if (sd) { - is_ducked = (dbus_bool_t)is_stream_ducked(sd); - pa_log_info("id[%u], is_ducked[%p,%d]", id, sd, is_ducked); - } else { - ret_msg = RET_MSG_ERROR_INTERNAL; + if (!sd) { pa_log_error("no matched stream ducking for id[%u]", id); + ret_msg = RET_MSG_ERROR_INTERNAL; + goto finish; } - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &is_ducked, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret_msg], DBUS_TYPE_INVALID)); + is_ducked = (dbus_bool_t)is_stream_ducked(sd); + pa_log_info("id[%u], is_ducked[%p,%d]", id, sd, is_ducked); + +finish: + pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &is_ducked, + DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret_msg], + DBUS_TYPE_INVALID)); pa_assert_se(dbus_connection_send(conn, reply, NULL)); dbus_message_unref(reply); @@ -2382,11 +2234,11 @@ static int dbus_launch_mdnsd(pa_stream_manager *m, DBusConnection *conn) { } static void handle_set_remote_permission(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_stream_manager *m = (pa_stream_manager*)userdata; + pa_stream_manager *m = (pa_stream_manager *)userdata; + const char *type = NULL; dbus_uint32_t index; dbus_bool_t allowed; pa_proplist *p = NULL; - char *type = NULL; pa_assert(conn); pa_assert(msg); @@ -2403,7 +2255,7 @@ static void handle_set_remote_permission(DBusConnection *conn, DBusMessage *msg, goto out; } - pa_log_info("type(%s), index(%d), allowed(%d)", type, index, allowed); + pa_log_info("type(%s), index(%u), allowed(%u)", type, index, allowed); p = pa_proplist_new(); if (!p) { @@ -2417,9 +2269,7 @@ static void handle_set_remote_permission(DBusConnection *conn, DBusMessage *msg, } if (pa_streq(type, "sink-input")) { - pa_sink_input *i; - - i = pa_idxset_get_by_index(m->core->sink_inputs, index); + pa_sink_input *i = pa_idxset_get_by_index(m->core->sink_inputs, index); if (!i) { pa_log_error("not found sink-input"); goto out; @@ -2431,9 +2281,7 @@ static void handle_set_remote_permission(DBusConnection *conn, DBusMessage *msg, } } else if (pa_streq(type, "source-output")) { - pa_source_output *o; - - o = pa_idxset_get_by_index(m->core->source_outputs, index); + pa_source_output *o = pa_idxset_get_by_index(m->core->source_outputs, index); if (!o) { pa_log_error("not found source-output"); goto out; @@ -2456,7 +2304,7 @@ out: } static void handle_discover_remote_device(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_stream_manager *m = (pa_stream_manager*)userdata; + pa_stream_manager *m = (pa_stream_manager *)userdata; pa_module *module; dbus_bool_t enable; @@ -2468,7 +2316,7 @@ static void handle_discover_remote_device(DBusConnection *conn, DBusMessage *msg DBUS_TYPE_BOOLEAN, &enable, DBUS_TYPE_INVALID)); - pa_log_info("discover module enable(%d)", enable); + pa_log_info("discover module enable(%u)", enable); if (enable) { if (m->m_discover) { @@ -2494,7 +2342,6 @@ static void handle_discover_remote_device(DBusConnection *conn, DBusMessage *msg } pa_dbus_send_empty_reply(conn, msg); - return; error: @@ -2503,7 +2350,7 @@ error: } static void handle_publish_local_device(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_stream_manager *m = (pa_stream_manager*)userdata; + pa_stream_manager *m = (pa_stream_manager *)userdata; pa_module *module; dbus_bool_t enable; @@ -2515,7 +2362,7 @@ static void handle_publish_local_device(DBusConnection *conn, DBusMessage *msg, DBUS_TYPE_BOOLEAN, &enable, DBUS_TYPE_INVALID)); - pa_log_info("publish module enable(%d)", enable); + pa_log_info("publish module enable(%u)", enable); if (enable) { if (m->m_protocol_tcp || m->m_publish) { @@ -2552,7 +2399,6 @@ static void handle_publish_local_device(DBusConnection *conn, DBusMessage *msg, } pa_dbus_send_empty_reply(conn, msg); - return; error: @@ -2562,7 +2408,7 @@ error: static DBusHandlerResult handle_methods(DBusConnection *conn, DBusMessage *msg, void *userdata) { int idx = 0; - pa_stream_manager *m = (pa_stream_manager*)userdata; + pa_stream_manager *m = (pa_stream_manager *)userdata; pa_assert(conn); pa_assert(msg); @@ -2586,7 +2432,7 @@ static DBusHandlerResult handle_methods(DBusConnection *conn, DBusMessage *msg, } static DBusHandlerResult method_handler_for_vt(DBusConnection *c, DBusMessage *m, void *userdata) { - pa_stream_manager *u = (pa_stream_manager*)userdata; + pa_stream_manager *u = (pa_stream_manager *)userdata; const char *path, *interface, *member; pa_assert(c); -- 2.7.4