.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;
}
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);
}
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);
}
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);
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);
}
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]);
}
}
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);
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) {
}
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) {
}
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;
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);
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;
}
}
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;
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);
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);
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);
}
}
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;
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);
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;
}
/* 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;
}
}
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;
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);
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);
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);
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);
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);
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);
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);
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);
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);
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)) {
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);
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) {
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);
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 */
} 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);
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);
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
}
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,};
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);
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);
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);
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) {
}
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);
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) {
}
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);
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;
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) {
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;
}
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;
/* 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);
}
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);
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) {
}
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;
}
} 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;
}
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;
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) {
}
pa_dbus_send_empty_reply(conn, msg);
-
return;
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;
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) {
}
pa_dbus_send_empty_reply(conn, msg);
-
return;
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);
}
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);
projects / platform / core / multimedia / pulseaudio-modules-tizen.git / commitdiff