device-manager-dbus: use pa dbus wrapper function if possible

[Version] 13.0.35
[Issue Type] Revise

Change-Id: I926a1860bc43b789ae5cf5490973f92b9ddd6cbd

diff --git a/packaging/pulseaudio-modules-tizen.spec b/packaging/pulseaudio-modules-tizen.spec
index 638827d279ceb94da0c4799d12997d7daffa4955..e6f794d29cecf9babc599727bee95ceb9421a518 100644 (file)
--- 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.34
+Version:          13.0.35
 Release:          0
 Group:            Multimedia/Audio
 License:          LGPL-2.1+

diff --git a/src/device-manager-dbus.c b/src/device-manager-dbus.c
index 719096574c33d5cf3d3fa1bf1510c5c56be609cd..52e87e19d1ae11e72528d899a0b1fee411d2c163 100644 (file)
--- a/src/device-manager-dbus.c
+++ b/src/device-manager-dbus.c
@@ -507,10 +507,10 @@ static int handle_bluez_headset_property_changed(DBusConnection *c, DBusMessage
 static DBusHandlerResult dbus_filter_device_detect_handler(DBusConnection *c, DBusMessage *s, void *userdata) {
     DBusError error;
     int status = 0;
-    pa_device_manager *dm = (pa_device_manager *) userdata;
+    pa_device_manager *dm = (pa_device_manager *)userdata;
     device_detected_type_t detected;
 
-    pa_assert(userdata);
+    pa_assert(dm);
 
     if (dbus_message_get_type(s) != DBUS_MESSAGE_TYPE_SIGNAL)
         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
@@ -678,7 +678,7 @@ static int method_call_bt_get_name(DBusConnection *conn, const char *device_path
 }
 
 static void handle_get_connected_device_list(DBusConnection *conn, DBusMessage *msg, void *userdata) {
-    pa_device_manager *dm;
+    pa_device_manager *dm = (pa_device_manager *)userdata;
     DBusMessage *reply = NULL;
     DBusMessageIter msg_iter, array_iter, device_iter;
     pa_tz_device *device;
@@ -692,10 +692,7 @@ static void handle_get_connected_device_list(DBusConnection *conn, DBusMessage *
 
     pa_assert(conn);
     pa_assert(msg);
-    pa_assert(userdata);
-
-
-    dm = (pa_device_manager*) userdata;
+    pa_assert(dm);
 
     pa_assert_se((reply = dbus_message_new_method_return(msg)));
 
@@ -742,7 +739,7 @@ static void handle_get_connected_device_list(DBusConnection *conn, DBusMessage *
 }
 
 static void handle_get_device_by_id(DBusConnection *conn, DBusMessage *msg, void *userdata) {
-    pa_device_manager *manager;
+    pa_device_manager *dm = (pa_device_manager *)userdata;
     DBusMessage *reply;
     DBusMessageIter msg_iter;
     pa_tz_device *device;
@@ -753,9 +750,7 @@ static void handle_get_device_by_id(DBusConnection *conn, DBusMessage *msg, void
 
     pa_assert(conn);
     pa_assert(msg);
-    pa_assert(userdata);
-
-    manager = (pa_device_manager*) userdata;
+    pa_assert(dm);
 
     pa_assert_se(dbus_message_get_args(msg, NULL,
                                        DBUS_TYPE_INT32, &device_id,
@@ -763,7 +758,7 @@ static void handle_get_device_by_id(DBusConnection *conn, DBusMessage *msg, void
 
     pa_log_info("Get device by id(%d)", device_id);
 
-    if ((device = device_list_get_device_by_id(manager, device_id))) {
+    if ((device = device_list_get_device_by_id(dm, device_id))) {
         pa_assert_se((reply = dbus_message_new_method_return(msg)));
         dbus_message_iter_init_append(reply, &msg_iter);
 
@@ -792,19 +787,15 @@ static void handle_get_device_by_id(DBusConnection *conn, DBusMessage *msg, void
     }
 }
 
-static void handle_is_device_running_by_id(DBusConnection *conn, DBusMessage *msg, void *userdata)
-{
-    pa_device_manager *manager;
-    DBusMessage *reply;
+static void handle_is_device_running_by_id(DBusConnection *conn, DBusMessage *msg, void *userdata) {
+    pa_device_manager *dm = (pa_device_manager *)userdata;
     pa_tz_device *device;
     dbus_int32_t device_id;
     dbus_bool_t is_running;
 
     pa_assert(conn);
     pa_assert(msg);
-    pa_assert(userdata);
-
-    manager = (pa_device_manager *)userdata;
+    pa_assert(dm);
 
     pa_assert_se(dbus_message_get_args(msg, NULL,
                                        DBUS_TYPE_INT32, &device_id,
@@ -812,28 +803,21 @@ static void handle_is_device_running_by_id(DBusConnection *conn, DBusMessage *ms
 
     pa_log_info("Is device running by id(%d)", device_id);
 
-    if ((device = device_list_get_device_by_id(manager, device_id))) {
-        pa_assert_se((reply = dbus_message_new_method_return(msg)));
-
+    if ((device = device_list_get_device_by_id(dm, device_id))) {
         is_running = pa_tz_device_is_running(device);
 
         pa_log_info("device(id:%d) is %s", device_id, is_running ? "Running" : "Not Running");
 
-        pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &is_running,
-                                              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_BOOLEAN, &is_running);
     } else {
         pa_dbus_send_error(conn, msg, DBUS_ERROR_FAILED, "%s", "org.tizen.multimedia.audio.Internal");
     }
 }
 
 static void handle_is_stream_on_device(DBusConnection *conn, DBusMessage *msg, void *userdata) {
-    pa_device_manager *manager;
-    DBusMessage *reply;
+    pa_device_manager *dm = (pa_device_manager *)userdata;
     pa_tz_device *device;
-    dbus_bool_t is_on = false;
+    dbus_bool_t is_on = FALSE;
     dbus_int32_t stream_id, device_id;
     pa_intset *stream_id_set;
     int32_t stream_id_val;
@@ -842,27 +826,22 @@ static void handle_is_stream_on_device(DBusConnection *conn, DBusMessage *msg, v
 
     pa_assert(conn);
     pa_assert(msg);
-    pa_assert(userdata);
+    pa_assert(dm);
 
     pa_log_info("Is stream on device");
 
-    manager = (pa_device_manager*) userdata;
-
-
     pa_assert_se(dbus_message_get_args(msg, NULL,
                                        DBUS_TYPE_INT32, &stream_id,
                                        DBUS_TYPE_INT32, &device_id,
                                        DBUS_TYPE_INVALID));
 
-    if ((device = device_list_get_device_by_id(manager, device_id))) {
-        pa_assert_se((reply = dbus_message_new_method_return(msg)));
-
+    if ((device = device_list_get_device_by_id(dm, device_id))) {
         state = pa_tz_device_get_state(device);
         if (state == DM_DEVICE_STATE_ACTIVATED) {
             stream_id_set = pa_tz_device_get_stream_list(device);
             PA_INTSET_FOREACH(stream_id_val, stream_id_set, ret) {
                 if (stream_id_val == stream_id) {
-                    is_on = true;
+                    is_on = TRUE;
                     pa_log_info("stream(%d) is on device(%d)", stream_id, device_id);
                     break;
                 }
@@ -870,113 +849,106 @@ static void handle_is_stream_on_device(DBusConnection *conn, DBusMessage *msg, v
             pa_intset_free(stream_id_set);
         } else {
             pa_log_info("device(%d) is not activated, regard as no stream on it", device_id);
-            is_on = false;
+            is_on = FALSE;
         }
-
-        pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &is_on,
-                                                     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_BOOLEAN, &is_on);
     } else {
         pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", "org.tizen.multimedia.audio.Internal");
     }
 }
 
 static void handle_get_bt_a2dp_status(DBusConnection *conn, DBusMessage *msg, void *userdata) {
-    pa_device_manager *dm;
+    pa_device_manager *dm = (pa_device_manager *)userdata;
     DBusMessage *reply = NULL;
     pa_tz_device *device;
-    dbus_bool_t is_bt_on = false;
+    dbus_bool_t is_bt_on = FALSE;
     const char *bt_name = "none";
 
     pa_assert(conn);
     pa_assert(msg);
-    pa_assert(userdata);
+    pa_assert(dm);
 
     pa_log_info("Get BT A2DP list");
 
-    dm = (pa_device_manager*) userdata;
-
-    pa_assert_se((reply = dbus_message_new_method_return(msg)));
-
     /* FIXME : Give system_id for multi device */
     if ((device = device_list_get_device(dm, DEVICE_TYPE_BT_A2DP, NULL, NULL)) != NULL) {
-        is_bt_on = true;
+        is_bt_on = TRUE;
         bt_name = pa_tz_device_get_name(device);
     }
 
+    pa_assert_se((reply = dbus_message_new_method_return(msg)));
     pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &is_bt_on,
                                                  DBUS_TYPE_STRING, &bt_name,
                                                  DBUS_TYPE_INVALID));
-
     pa_assert_se(dbus_connection_send(conn, reply, NULL));
     dbus_message_unref(reply);
 }
 
 static void handle_load_sink(DBusConnection *conn, DBusMessage *msg, void *userdata) {
-    pa_device_manager *dm;
+    pa_device_manager *dm = (pa_device_manager *)userdata;
     char *type, *role;
     pa_sink *sink;
-    DBusMessage *reply = NULL;
 
-    dm = (pa_device_manager *) userdata;
+    pa_assert(conn);
+    pa_assert(msg);
+    pa_assert(dm);
+
     pa_assert_se(dbus_message_get_args(msg, NULL,
                                        DBUS_TYPE_STRING, &type,
                                        DBUS_TYPE_STRING, &role,
                                        DBUS_TYPE_INVALID));
 
-    if (!(sink = pa_device_manager_load_sink(dm, type, role))) {
+    if (!(sink = pa_device_manager_load_sink(dm, type, role)))
         pa_dbus_send_error(conn, msg, DBUS_ERROR_FAILED, "%s", "org.tizen.multimedia.audio.Internal");
-        return;
-    }
-
-    pa_assert_se((reply = dbus_message_new_method_return(msg)));
-    pa_assert_se(dbus_connection_send(conn, reply, NULL));
-    dbus_message_unref(reply);
+    else
+        pa_dbus_send_empty_reply(conn, msg);
 }
 
 static void handle_unload_sink(DBusConnection *conn, DBusMessage *msg, void *userdata) {
-    pa_device_manager *dm;
+    pa_device_manager *dm = (pa_device_manager *)userdata;
     char *type, *role;
-    DBusMessage *reply = NULL;
 
-    pa_assert_se((reply = dbus_message_new_method_return(msg)));
-    dm = (pa_device_manager *) userdata;
+    pa_assert(conn);
+    pa_assert(msg);
+    pa_assert(dm);
+
     pa_assert_se(dbus_message_get_args(msg, NULL,
                                        DBUS_TYPE_STRING, &type,
                                        DBUS_TYPE_STRING, &role,
                                        DBUS_TYPE_INVALID));
 
     pa_device_manager_unload_sink(dm, type, role);
-    pa_assert_se(dbus_connection_send(conn, reply, NULL));
-    dbus_message_unref(reply);
+
+    pa_dbus_send_empty_reply(conn, msg);
 }
 
 static void handle_unload_sink_with_device_string(DBusConnection *conn, DBusMessage *msg, void *userdata) {
-    pa_device_manager *dm;
+    pa_device_manager *dm = (pa_device_manager *)userdata;
     char *device_string;
-    DBusMessage *reply = NULL;
 
-    pa_assert_se((reply = dbus_message_new_method_return(msg)));
-    dm = (pa_device_manager *) userdata;
+    pa_assert(conn);
+    pa_assert(msg);
+    pa_assert(dm);
+
     pa_assert_se(dbus_message_get_args(msg, NULL,
                                        DBUS_TYPE_STRING, &device_string,
                                        DBUS_TYPE_INVALID));
 
     pa_device_manager_unload_sink_with_device_string(dm, device_string);
-    pa_assert_se(dbus_connection_send(conn, reply, NULL));
-    dbus_message_unref(reply);
+
+    pa_dbus_send_empty_reply(conn, msg);
 }
 
 static void handle_get_device_string(DBusConnection *conn, DBusMessage *msg, void *userdata) {
-    pa_device_manager *dm;
+    pa_device_manager *dm = (pa_device_manager *)userdata;
     char *type, *role;
     const char *device_string;
     dbus_bool_t is_playback;
-    DBusMessage *reply;
 
-    dm = (pa_device_manager *) userdata;
+    pa_assert(conn);
+    pa_assert(msg);
+    pa_assert(dm);
+
     pa_assert_se(dbus_message_get_args(msg, NULL,
                                        DBUS_TYPE_BOOLEAN, &is_playback,
                                        DBUS_TYPE_STRING, &type,
@@ -990,27 +962,24 @@ static void handle_get_device_string(DBusConnection *conn, DBusMessage *msg, voi
     }
 
     pa_log_info("device string : %s", device_string);
-    pa_assert_se((reply = dbus_message_new_method_return(msg)));
-    pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &device_string,
-                                                 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, &device_string);
 }
 
 static void handle_dump_device_list(DBusConnection *conn, DBusMessage *msg, void *userdata) {
-    pa_device_manager *dm;
+    pa_device_manager *dm = (pa_device_manager *)userdata;
     pa_tz_device *device;
     uint32_t device_idx;
-    DBusMessage *reply = NULL;
 
-    pa_assert_se((reply = dbus_message_new_method_return(msg)));
-    dm = (pa_device_manager *) userdata;
+    pa_assert(conn);
+    pa_assert(msg);
+    pa_assert(dm);
 
     PA_IDXSET_FOREACH(device, dm->device_list, device_idx) {
         pa_tz_device_dump_info(device, PA_LOG_INFO);
     }
-    pa_assert_se(dbus_connection_send(conn, reply, NULL));
-    dbus_message_unref(reply);
+
+    pa_dbus_send_empty_reply(conn, msg);
 }
 
 static bool is_usb_output_device(pa_tz_device *device) {
@@ -1057,7 +1026,7 @@ static bool is_supported_sample_format(pa_sample_format_t *supported_sample_form
 }
 
 static void handle_get_supported_sample_formats(DBusConnection *conn, DBusMessage *msg, void *userdata) {
-    pa_device_manager *dm;
+    pa_device_manager *dm = (pa_device_manager *)userdata;
     DBusMessage *reply = NULL;
     DBusMessageIter msg_iter, array_iter;
     dbus_int32_t device_id;
@@ -1068,9 +1037,7 @@ static void handle_get_supported_sample_formats(DBusConnection *conn, DBusMessag
 
     pa_assert(conn);
     pa_assert(msg);
-    pa_assert(userdata);
-
-    dm = (pa_device_manager *)userdata;
+    pa_assert(dm);
 
     pa_assert_se((reply = dbus_message_new_method_return(msg)));
 
@@ -1114,8 +1081,7 @@ static void handle_get_supported_sample_formats(DBusConnection *conn, DBusMessag
 }
 
 static void handle_set_sample_format(DBusConnection *conn, DBusMessage *msg, void *userdata) {
-    pa_device_manager *dm;
-    DBusMessage *reply = NULL;
+    pa_device_manager *dm = (pa_device_manager *)userdata;
     dbus_int32_t device_id;
     char *sample_format;
     pa_sample_format_t prev_selected_sample_format;
@@ -1125,10 +1091,8 @@ static void handle_set_sample_format(DBusConnection *conn, DBusMessage *msg, voi
 
     pa_assert(conn);
     pa_assert(msg);
-    pa_assert(userdata);
+    pa_assert(dm);
 
-    pa_assert_se((reply = dbus_message_new_method_return(msg)));
-    dm = (pa_device_manager *)userdata;
     pa_assert_se(dbus_message_get_args(msg, NULL,
                                        DBUS_TYPE_INT32, &device_id,
                                        DBUS_TYPE_STRING, &sample_format,
@@ -1172,13 +1136,12 @@ static void handle_set_sample_format(DBusConnection *conn, DBusMessage *msg, voi
     }
 
     pa_log_info("Set sample format(%s) of the device(id:%d) successfully", sample_format, device_id);
-    pa_assert_se(dbus_connection_send(conn, reply, NULL));
-    dbus_message_unref(reply);
+
+    pa_dbus_send_empty_reply(conn, msg);
 }
 
 static void handle_get_sample_format(DBusConnection *conn, DBusMessage *msg, void *userdata) {
-    pa_device_manager *dm;
-    DBusMessage *reply = NULL;
+    pa_device_manager *dm = (pa_device_manager *)userdata;
     dbus_int32_t device_id;
     pa_tz_device *device;
     pa_sink *sink;
@@ -1186,11 +1149,7 @@ static void handle_get_sample_format(DBusConnection *conn, DBusMessage *msg, voi
 
     pa_assert(conn);
     pa_assert(msg);
-    pa_assert(userdata);
-
-    dm = (pa_device_manager *)userdata;
-
-    pa_assert_se((reply = dbus_message_new_method_return(msg)));
+    pa_assert(dm);
 
     pa_assert_se(dbus_message_get_args(msg, NULL,
                                        DBUS_TYPE_INT32, &device_id,
@@ -1215,10 +1174,8 @@ static void handle_get_sample_format(DBusConnection *conn, DBusMessage *msg, voi
 
     format = pa_sample_format_to_string(sink->selected_sample_format);
     pa_log_info("Get sample format(%s) of the device(id:%d) successfully", format, device_id);
-    pa_assert_se((reply = dbus_message_new_method_return(msg)));
-    pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &format, 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, &format);
 }
 
 static bool is_supported_sample_rate(uint32_t *supported_sample_rates, uint32_t sample_rate) {
@@ -1237,7 +1194,7 @@ static bool is_supported_sample_rate(uint32_t *supported_sample_rates, uint32_t
 }
 
 static void handle_get_supported_sample_rates(DBusConnection *conn, DBusMessage *msg, void *userdata) {
-    pa_device_manager *dm;
+    pa_device_manager *dm = (pa_device_manager *)userdata;
     DBusMessage *reply = NULL;
     DBusMessageIter msg_iter, array_iter;
     dbus_int32_t device_id;
@@ -1247,9 +1204,7 @@ static void handle_get_supported_sample_rates(DBusConnection *conn, DBusMessage
 
     pa_assert(conn);
     pa_assert(msg);
-    pa_assert(userdata);
-
-    dm = (pa_device_manager *)userdata;
+    pa_assert(dm);
 
     pa_assert_se((reply = dbus_message_new_method_return(msg)));
 
@@ -1292,8 +1247,7 @@ static void handle_get_supported_sample_rates(DBusConnection *conn, DBusMessage
 }
 
 static void handle_set_sample_rate(DBusConnection *conn, DBusMessage *msg, void *userdata) {
-    pa_device_manager *dm;
-    DBusMessage *reply = NULL;
+    pa_device_manager *dm = (pa_device_manager *)userdata;
     dbus_int32_t device_id;
     dbus_uint32_t sample_rate;
     uint32_t prev_selected_sample_rate;
@@ -1303,10 +1257,8 @@ static void handle_set_sample_rate(DBusConnection *conn, DBusMessage *msg, void
 
     pa_assert(conn);
     pa_assert(msg);
-    pa_assert(userdata);
+    pa_assert(dm);
 
-    pa_assert_se((reply = dbus_message_new_method_return(msg)));
-    dm = (pa_device_manager *)userdata;
     pa_assert_se(dbus_message_get_args(msg, NULL,
                                        DBUS_TYPE_INT32, &device_id,
                                        DBUS_TYPE_UINT32, &sample_rate,
@@ -1350,24 +1302,19 @@ static void handle_set_sample_rate(DBusConnection *conn, DBusMessage *msg, void
     }
 
     pa_log_info("Set sample rate(%u) of the device(id:%d) successfully", sample_rate, device_id);
-    pa_assert_se(dbus_connection_send(conn, reply, NULL));
-    dbus_message_unref(reply);
+
+    pa_dbus_send_empty_reply(conn, msg);
 }
 
 static void handle_get_sample_rate(DBusConnection *conn, DBusMessage *msg, void *userdata) {
-    pa_device_manager *dm;
-    DBusMessage *reply = NULL;
+    pa_device_manager *dm = (pa_device_manager *)userdata;
     dbus_int32_t device_id;
     pa_tz_device *device;
     pa_sink *sink;
 
     pa_assert(conn);
     pa_assert(msg);
-    pa_assert(userdata);
-
-    dm = (pa_device_manager *)userdata;
-
-    pa_assert_se((reply = dbus_message_new_method_return(msg)));
+    pa_assert(dm);
 
     pa_assert_se(dbus_message_get_args(msg, NULL,
                                        DBUS_TYPE_INT32, &device_id,
@@ -1391,25 +1338,20 @@ static void handle_get_sample_rate(DBusConnection *conn, DBusMessage *msg, void
     }
 
     pa_log_info("Get sample rate(%u) of the device(id:%d) successfully", sink->selected_sample_rate, device_id);
-    pa_assert_se((reply = dbus_message_new_method_return(msg)));
-    pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &sink->selected_sample_rate, 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_UINT32, &sink->selected_sample_rate);
 }
 
 static void handle_set_specific_stream_only(DBusConnection *conn, DBusMessage *msg, void *userdata) {
-    pa_device_manager *dm;
-    DBusMessage *reply = NULL;
+    pa_device_manager *dm = (pa_device_manager *)userdata;
     dbus_int32_t device_id;
     char *stream_role;
     pa_tz_device *device;
 
     pa_assert(conn);
     pa_assert(msg);
-    pa_assert(userdata);
+    pa_assert(dm);
 
-    pa_assert_se((reply = dbus_message_new_method_return(msg)));
-    dm = (pa_device_manager *)userdata;
     pa_assert_se(dbus_message_get_args(msg, NULL,
                                        DBUS_TYPE_INT32, &device_id,
                                        DBUS_TYPE_STRING, &stream_role,
@@ -1434,24 +1376,18 @@ static void handle_set_specific_stream_only(DBusConnection *conn, DBusMessage *m
     pa_xfree(device->specified_stream_role);
     device->specified_stream_role = pa_xstrdup(stream_role);
 
-    pa_assert_se(dbus_connection_send(conn, reply, NULL));
-    dbus_message_unref(reply);
+    pa_dbus_send_empty_reply(conn, msg);
 }
 
 static void handle_get_specified_stream(DBusConnection *conn, DBusMessage *msg, void *userdata) {
-    pa_device_manager *dm;
-    DBusMessage *reply = NULL;
+    pa_device_manager *dm = (pa_device_manager *)userdata;
     dbus_int32_t device_id;
     char *specified_stream_role;
     pa_tz_device *device;
 
     pa_assert(conn);
     pa_assert(msg);
-    pa_assert(userdata);
-
-    dm = (pa_device_manager *)userdata;
-
-    pa_assert_se((reply = dbus_message_new_method_return(msg)));
+    pa_assert(dm);
 
     pa_assert_se(dbus_message_get_args(msg, NULL,
                                        DBUS_TYPE_INT32, &device_id,
@@ -1472,15 +1408,12 @@ static void handle_get_specified_stream(DBusConnection *conn, DBusMessage *msg,
     specified_stream_role = device->specified_stream_role;
 
     pa_log_info("stream role(%s) is specified for the device(id:%d)", device->specified_stream_role, device_id);
-    pa_assert_se((reply = dbus_message_new_method_return(msg)));
-    pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &specified_stream_role, 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, &specified_stream_role);
 }
 
 static void handle_set_avoid_resampling(DBusConnection *conn, DBusMessage *msg, void *userdata) {
-    pa_device_manager *dm;
-    DBusMessage *reply = NULL;
+    pa_device_manager *dm = (pa_device_manager *)userdata;
     dbus_int32_t device_id;
     dbus_bool_t avoid_resampling;
     pa_tz_device *device;
@@ -1488,10 +1421,8 @@ static void handle_set_avoid_resampling(DBusConnection *conn, DBusMessage *msg,
 
     pa_assert(conn);
     pa_assert(msg);
-    pa_assert(userdata);
+    pa_assert(dm);
 
-    pa_assert_se((reply = dbus_message_new_method_return(msg)));
-    dm = (pa_device_manager *)userdata;
     pa_assert_se(dbus_message_get_args(msg, NULL,
                                        DBUS_TYPE_INT32, &device_id,
                                        DBUS_TYPE_BOOLEAN, &avoid_resampling,
@@ -1515,24 +1446,17 @@ static void handle_set_avoid_resampling(DBusConnection *conn, DBusMessage *msg,
     }
     if (sink->avoid_resampling == avoid_resampling) {
         pa_log_info("already set to %d", avoid_resampling);
-        pa_assert_se(dbus_connection_send(conn, reply, NULL));
-        dbus_message_unref(reply);
-        return;
+    } else {
+        sink->avoid_resampling = avoid_resampling;
+        save_preference(dm, sink);
+        pa_log_info("Set avoid-resampling(%d) to the device(id:%d)", avoid_resampling, device_id);
     }
 
-    sink->avoid_resampling = avoid_resampling;
-
-    save_preference(dm, sink);
-
-    pa_log_info("Set avoid-resampling(%d) to the device(id:%d)", avoid_resampling, device_id);
-
-    pa_assert_se(dbus_connection_send(conn, reply, NULL));
-    dbus_message_unref(reply);
+    pa_dbus_send_empty_reply(conn, msg);
 }
 
 static void handle_get_avoid_resampling(DBusConnection *conn, DBusMessage *msg, void *userdata) {
-    pa_device_manager *dm;
-    DBusMessage *reply = NULL;
+    pa_device_manager *dm = (pa_device_manager *)userdata;
     dbus_int32_t device_id;
     dbus_bool_t avoid_resampling;
     pa_tz_device *device;
@@ -1540,11 +1464,7 @@ static void handle_get_avoid_resampling(DBusConnection *conn, DBusMessage *msg,
 
     pa_assert(conn);
     pa_assert(msg);
-    pa_assert(userdata);
-
-    dm = (pa_device_manager *)userdata;
-
-    pa_assert_se((reply = dbus_message_new_method_return(msg)));
+    pa_assert(dm);
 
     pa_assert_se(dbus_message_get_args(msg, NULL,
                                        DBUS_TYPE_INT32, &device_id,
@@ -1570,48 +1490,38 @@ static void handle_get_avoid_resampling(DBusConnection *conn, DBusMessage *msg,
     avoid_resampling = sink->avoid_resampling;
     pa_log_info("got avoid-resampling(%d) of the device(id:%d)", avoid_resampling, device_id);
 
-    pa_assert_se((reply = dbus_message_new_method_return(msg)));
-    pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &avoid_resampling, 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_BOOLEAN, &avoid_resampling);
 }
 
 static void handle_test_device_status_change(DBusConnection *conn, DBusMessage *msg, void *userdata) {
     pa_device_manager *dm = (pa_device_manager *)userdata;
     char *type;
     dbus_int32_t status;
-    DBusMessage *reply = NULL;
-    DBusError error;
 
-    pa_assert_se((reply = dbus_message_new_method_return(msg)));
+    pa_assert(conn);
+    pa_assert(msg);
+    pa_assert(dm);
 
-    dbus_error_init(&error);
-    if (!dbus_message_get_args(msg, NULL,
+    pa_assert_se(dbus_message_get_args(msg, NULL,
                                        DBUS_TYPE_STRING, &type,
                                        DBUS_TYPE_INT32, &status,
-                                       DBUS_TYPE_INVALID)) {
-        pa_log_error("failed to get dbus args : %s", error.message);
-        pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message);
-        dbus_error_free(&error);
-    }
+                                       DBUS_TYPE_INVALID));
 
     pa_log_debug("handle_test_device_status_change, type:%s, status:%d", type, status);
 
-    handle_device_status_changed(dm, type, NULL,  NULL, status);
-    pa_assert_se(dbus_connection_send(conn, reply, NULL));
-    dbus_message_unref(reply);
+    handle_device_status_changed(dm, type, NULL, NULL, status);
+
+    pa_dbus_send_empty_reply(conn, msg);
 }
 
 static void handle_set_acm_mode(DBusConnection *conn, DBusMessage *msg, void *userdata) {
-    pa_device_manager *dm;
-    DBusMessage *reply = NULL;
+    pa_device_manager *dm = (pa_device_manager *)userdata;
     uint32_t mode = 0;
 
     pa_assert(conn);
     pa_assert(msg);
-    pa_assert(userdata);
+    pa_assert(dm);
 
-    dm = (pa_device_manager *)userdata;
     pa_assert_se(dbus_message_get_args(msg, NULL,
                                        DBUS_TYPE_UINT32, &mode,
                                        DBUS_TYPE_INVALID));
@@ -1629,9 +1539,7 @@ static void handle_set_acm_mode(DBusConnection *conn, DBusMessage *msg, void *us
         }
     }
 
-    pa_assert_se((reply = dbus_message_new_method_return(msg)));
-    pa_assert_se(dbus_connection_send(conn, reply, NULL));
-    dbus_message_unref(reply);
+    pa_dbus_send_empty_reply(conn, msg);
 }
 
 static DBusHandlerResult handle_introspect(DBusConnection *conn, DBusMessage *msg, void *userdata) {