Remove useless converting error logic in filter and preemptive device APIs

[Version] 0.6.19
[Issue Type] Refactoring

Change-Id: I485645a4190045f3bf547aa39070272b9db5b47a
Signed-off-by: Sangchul Lee <sc11.lee@samsung.com>

diff --git a/include/sound_manager_private.h b/include/sound_manager_private.h
index b4ce72f..e534331 100644 (file)
--- a/include/sound_manager_private.h
+++ b/include/sound_manager_private.h
@@ -59,9 +59,6 @@ _CHECK_CONDITION(handle->state == expected_state, SOUND_MANAGER_ERROR_INVALID_ST
 _CHECK_CONDITION(arg <= max, SOUND_MANAGER_ERROR_INVALID_PARAMETER, "SOUND_MANAGER_ERROR_INVALID_PARAMETER") \
 _CHECK_CONDITION(arg >= min, SOUND_MANAGER_ERROR_INVALID_PARAMETER, "SOUND_MANAGER_ERROR_INVALID_PARAMETER")
 
-#define SM_NULL_ARG_CHECK_FOR_PRIV(arg) \
-_CHECK_CONDITION(!!(arg) != false, MM_ERROR_INVALID_ARGUMENT, "MM_ERROR_INVALID_ARGUMENT")
-
 #define SM_ENTER_CRITICAL_SECTION_WITH_UNLOCK_AND_RETURN(x_mutex, x_mutex_to_unlock, x_return) \
 switch (pthread_mutex_lock(x_mutex)) { \
 case EINVAL: \

diff --git a/packaging/capi-media-sound-manager.spec b/packaging/capi-media-sound-manager.spec
index 0511845..ad55e24 100644 (file)
--- a/packaging/capi-media-sound-manager.spec
+++ b/packaging/capi-media-sound-manager.spec
@@ -1,6 +1,6 @@
 Name:       capi-media-sound-manager
 Summary:    Sound Manager library
-Version:    0.6.18
+Version:    0.6.19
 Release:    0
 Group:      Multimedia/API
 License:    Apache-2.0

diff --git a/src/sound_manager_internal.c b/src/sound_manager_internal.c
index b7f83bb..dfaba24 100644 (file)
--- a/src/sound_manager_internal.c
+++ b/src/sound_manager_internal.c
@@ -526,8 +526,8 @@ int sound_manager_set_virtual_stream_volume(virtual_sound_stream_h virtual_strea
 
 static int _convert_filter(sound_filter_e filter, char **filter_str, char **filter_params_str)
 {
-       if (filter_str == NULL || filter_params_str == NULL)
-               return MM_ERROR_INVALID_ARGUMENT;
+       SM_ARG_CHECK(filter_str);
+       SM_ARG_CHECK(filter_params_str);
 
        switch (filter) {
        case SOUND_FILTER_LOW_PASS:
@@ -549,20 +549,17 @@ static int _convert_filter(sound_filter_e filter, char **filter_str, char **filt
                break;
        default:
                LOGE("could not find filter[%d]", filter);
-               return MM_ERROR_SOUND_INTERNAL;
+               return SOUND_MANAGER_ERROR_INTERNAL;
        //LCOV_EXCL_STOP
        }
        LOGI("filter[%s], param[%s]", *filter_str, *filter_params_str);
 
-       return MM_ERROR_NONE;
+       return SOUND_MANAGER_ERROR_NONE;
 }
 
 static int _convert_filter_preset(sound_filter_preset_e preset, char **control)
 {
-       int ret = MM_ERROR_NONE;
-
-       if (control == NULL)
-               return MM_ERROR_INVALID_ARGUMENT;
+       SM_ARG_CHECK(control);
 
        switch (preset) {
        case SOUND_FILTER_PRESET_LOW_PASS_NONE:
@@ -614,11 +611,11 @@ static int _convert_filter_preset(sound_filter_preset_e preset, char **control)
        //LCOV_EXCL_STOP
        default:
                LOGE("could not find the preset[%d]", preset);
-               return MM_ERROR_SOUND_INTERNAL;
+               return SOUND_MANAGER_ERROR_INTERNAL;
        }
        LOGI("preset[%s]", *control);
 
-       return ret;
+       return SOUND_MANAGER_ERROR_NONE;
 }
 
 static int _check_valid_filter_preset(sound_filter_e filter, sound_filter_preset_e preset)
@@ -652,82 +649,78 @@ static int _check_valid_filter_preset(sound_filter_e filter, sound_filter_preset
        //LCOV_EXCL_STOP
        default:
                LOGE("invalid filter(%d)", filter);
-               return MM_ERROR_INVALID_ARGUMENT;
+               return SOUND_MANAGER_ERROR_INVALID_PARAMETER;
        }
 
-       return MM_ERROR_NONE;
+       return SOUND_MANAGER_ERROR_NONE;
 
 ERROR_INVALID_ARGS:
        LOGE("invalid preset(%d) for filter(%d)", preset, filter);
-       return MM_ERROR_INVALID_ARGUMENT;
+       return SOUND_MANAGER_ERROR_INVALID_PARAMETER;
 }
 
 int sound_manager_set_filter(sound_stream_type_e stream_type, sound_filter_e filter)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        char *stream_type_str = NULL;
-       char *filter_str = NULL, *filter_params_str = NULL;
+       char *filter_str = NULL;
+       char *filter_params_str = NULL;
 
        LOGI(">> enter");
 
        if (stream_type != SOUND_STREAM_TYPE_MEDIA) {
-               ret = MM_ERROR_NOT_SUPPORT_API;
-               goto LEAVE;
+               LOGE("Not supported stream type(%d)", stream_type);
+               return SOUND_MANAGER_ERROR_NOT_SUPPORTED;
        }
-       if ((ret = _convert_stream_type(stream_type, &stream_type_str)) != MM_ERROR_NONE)
-               goto LEAVE;
-       if ((ret = _convert_filter(filter, &filter_str, &filter_params_str)) != MM_ERROR_NONE)
-               goto LEAVE;
 
-       ret = mm_sound_set_filter(stream_type_str, filter_str, filter_params_str, stream_type_str);
+       if ((ret = _convert_stream_type(stream_type, &stream_type_str)) != SOUND_MANAGER_ERROR_NONE)
+               return ret;
+       if ((ret = _convert_filter(filter, &filter_str, &filter_params_str)) != SOUND_MANAGER_ERROR_NONE)
+               return ret;
 
-LEAVE:
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _convert_sound_manager_error_code(__func__, mm_sound_set_filter(stream_type_str, filter_str, filter_params_str, stream_type_str));
 }
 
 int sound_manager_unset_filter(sound_stream_type_e stream_type)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        char *stream_type_str = NULL;
 
        LOGI(">> enter");
 
-       if ((ret = _convert_stream_type(stream_type, &stream_type_str)) != MM_ERROR_NONE)
-               goto LEAVE;
+       if ((ret = _convert_stream_type(stream_type, &stream_type_str)) != SOUND_MANAGER_ERROR_NONE)
+               return ret;
 
-       ret = mm_sound_unset_filter(stream_type_str);
        LOGI("stream_type[%s]", stream_type_str);
 
-LEAVE:
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _convert_sound_manager_error_code(__func__, mm_sound_unset_filter(stream_type_str));
 }
 
 int sound_manager_set_filter_preset(sound_stream_type_e stream_type, sound_filter_e filter, sound_filter_preset_e preset)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        char *stream_type_str = NULL;
-       char *filter_str = NULL, *filter_params_str = NULL;
+       char *filter_str = NULL;
+       char *filter_params_str = NULL;
        char *control_str = NULL;
 
        LOGI(">> enter");
 
        if (stream_type != SOUND_STREAM_TYPE_MEDIA) {
-               ret = MM_ERROR_NOT_SUPPORT_API;
-               goto LEAVE;
+               LOGE("Not supported stream type(%d)", stream_type);
+               return SOUND_MANAGER_ERROR_NOT_SUPPORTED;
        }
-       if ((ret = _check_valid_filter_preset(filter, preset)))
-               goto LEAVE;
-       if ((ret = _convert_stream_type(stream_type, &stream_type_str)) != MM_ERROR_NONE)
-               goto LEAVE;
-       if ((ret = _convert_filter(filter, &filter_str, &filter_params_str)) != MM_ERROR_NONE)
-               goto LEAVE;
-       if ((ret = _convert_filter_preset(preset, &control_str)) != MM_ERROR_NONE)
-               goto LEAVE;
 
-       ret = mm_sound_control_filter(stream_type_str, filter_str, control_str);
+       if ((ret = _check_valid_filter_preset(filter, preset)) != SOUND_MANAGER_ERROR_NONE)
+               return ret;
+       if ((ret = _convert_stream_type(stream_type, &stream_type_str)) != SOUND_MANAGER_ERROR_NONE)
+               return ret;
+       if ((ret = _convert_filter(filter, &filter_str, &filter_params_str)) != SOUND_MANAGER_ERROR_NONE)
+               return ret;
+       if ((ret = _convert_filter_preset(preset, &control_str)) != SOUND_MANAGER_ERROR_NONE)
+               return ret;
 
-LEAVE:
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _convert_sound_manager_error_code(__func__, mm_sound_control_filter(stream_type_str, filter_str, control_str));
 }
 
 int sound_manager_get_device_vendor_id(sound_device_h device, int *vendor_id)
@@ -793,45 +786,29 @@ int sound_manager_is_stream_on_device_by_id(sound_stream_info_h stream_info, int
 
 int sound_manager_set_acm_master_mode(bool enable)
 {
-       int ret = MM_ERROR_NONE;
-
        LOGI(">> enter");
 
-       ret = _set_acm_master_mode(enable);
-
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _set_acm_master_mode(enable);
 }
 
 int sound_manager_get_latest_stream_pid(int stream_type, unsigned int *pid)
 {
-       int ret = MM_ERROR_NONE;
-
        SM_ARG_CHECK(pid);
-       SM_ARG_CHECK(stream_type);
+       SM_ARG_CHECK(stream_type >= 0);
 
        LOGI(">> enter, stream_type(0x%x)", stream_type);
 
-       ret = _get_latest_stream_pid(stream_type, pid);
-
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _get_latest_stream_pid(stream_type, pid);
 }
 
 int sound_manager_set_stream_preemptive_device(sound_stream_type_e stream_type, sound_device_io_direction_e io_direction, int device_id)
 {
-       int ret = MM_ERROR_NONE;
-
-       ret = _set_preemptive_device(stream_type, io_direction, device_id);
-
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _set_preemptive_device(stream_type, io_direction, device_id);
 }
 
 int sound_manager_get_stream_preemptive_device(sound_stream_type_e stream_type, int *in_device_id, int *out_device_id)
 {
-       int ret = MM_ERROR_NONE;
-
        SM_ARG_CHECK(in_device_id || out_device_id);
 
-       ret = _get_preemptive_device(stream_type, in_device_id, out_device_id);
-
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _get_preemptive_device(stream_type, in_device_id, out_device_id);
 }

diff --git a/src/sound_manager_private.c b/src/sound_manager_private.c
index a1be367..280e9d0 100644 (file)
--- a/src/sound_manager_private.c
+++ b/src/sound_manager_private.c
@@ -377,11 +377,11 @@ static int __get_dbus_connection(GDBusConnection **conn)
                LOGE("g_bus_get_sync() error (%s)", err ? err->message : NULL);
                if (err)
                        g_error_free(err);
-               return MM_ERROR_SOUND_INTERNAL;
+               return SOUND_MANAGER_ERROR_INTERNAL;
                //LCOV_EXCL_STOP
        }
 
-       return MM_ERROR_NONE;
+       return SOUND_MANAGER_ERROR_NONE;
 }
 
 int _convert_sound_type(sound_type_e sound_type, const char **volume_type)
@@ -958,7 +958,7 @@ int _get_stream_conf_info(const char *stream_type, stream_conf_info_s *info)
        assert(info);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return SOUND_MANAGER_ERROR_INTERNAL;
+               return ret;
 
        result = g_dbus_connection_call_sync(conn,
                                                        PA_BUS_NAME,
@@ -1094,7 +1094,7 @@ int _set_manual_route_info(unsigned int index, manual_route_info_s *info)
        assert(info);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return SOUND_MANAGER_ERROR_INTERNAL;
+               return ret;
 
        LOGI("stream info index(%u)", index);
 
@@ -1170,7 +1170,7 @@ int _set_route_option(unsigned int index, const char *name, int value)
        assert(name);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return SOUND_MANAGER_ERROR_INTERNAL;
+               return ret;
 
        LOGI("[OPTION] %s(%d)", name, value);
 
@@ -1221,7 +1221,7 @@ int _get_volume_max_level(const char *direction, const char *volume_type, unsign
        assert(max_level);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return SOUND_MANAGER_ERROR_INTERNAL;
+               return ret;
 
        result = g_dbus_connection_call_sync(conn,
                                                        PA_BUS_NAME,
@@ -1270,7 +1270,7 @@ int _get_volume_level(const char *direction, const char *volume_type, unsigned i
        assert(level);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return SOUND_MANAGER_ERROR_INTERNAL;
+               return ret;
 
        result = g_dbus_connection_call_sync(conn,
                                                        PA_BUS_NAME,
@@ -1370,7 +1370,7 @@ int _get_current_volume_type(const char *direction, char **volume_type)
        assert(volume_type);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return SOUND_MANAGER_ERROR_INTERNAL;
+               return ret;
 
        result = g_dbus_connection_call_sync(conn,
                                                        PA_BUS_NAME,
@@ -1424,7 +1424,7 @@ int _get_current_media_routing_path(const char *direction, sound_device_type_e *
        assert(device_type);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return SOUND_MANAGER_ERROR_INTERNAL;
+               return ret;
 
        result = g_dbus_connection_call_sync(conn,
                                                        PA_BUS_NAME,
@@ -1517,7 +1517,7 @@ int _is_device_running_by_id(int device_id, bool *is_running)
        assert(is_running);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return SOUND_MANAGER_ERROR_INTERNAL;
+               return ret;
 
        result = g_dbus_connection_call_sync(conn,
                                                                          PA_BUS_NAME,
@@ -1566,7 +1566,7 @@ int _get_supported_sample_formats(int device_id, sound_sample_format_e **formats
        SM_ARG_CHECK(num);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return SOUND_MANAGER_ERROR_INTERNAL;
+               return ret;
 
        result = g_dbus_connection_call_sync(conn,
                                                        PA_BUS_NAME,
@@ -1634,7 +1634,7 @@ int _set_sample_format(int device_id, sound_sample_format_e format)
        char *format_str = NULL;
 
        if ((ret = __get_dbus_connection(&conn)))
-               return SOUND_MANAGER_ERROR_INTERNAL;
+               return ret;
 
        if ((ret = _convert_sample_format_enum_to_str(format, &format_str)))
                return ret;
@@ -1673,7 +1673,7 @@ int _get_sample_format(int device_id, sound_sample_format_e *format)
        SM_ARG_CHECK(format);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return SOUND_MANAGER_ERROR_INTERNAL;
+               return ret;
 
        result = g_dbus_connection_call_sync(conn,
                                                        PA_BUS_NAME,
@@ -1723,7 +1723,7 @@ int _get_supported_sample_rates(int device_id, sound_sample_rate_e **rates, unsi
        SM_ARG_CHECK(num);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return SOUND_MANAGER_ERROR_INTERNAL;
+               return ret;
 
        result = g_dbus_connection_call_sync(conn,
                                                        PA_BUS_NAME,
@@ -1791,7 +1791,7 @@ int _set_sample_rate(int device_id, sound_sample_rate_e rate)
        unsigned int _rate;
 
        if ((ret = __get_dbus_connection(&conn)))
-               return SOUND_MANAGER_ERROR_INTERNAL;
+               return ret;
 
        if ((ret = _convert_sample_rate_enum_to_uint(rate, &_rate)))
                return ret;
@@ -1830,7 +1830,7 @@ int _get_sample_rate(int device_id, sound_sample_rate_e *rate)
        SM_ARG_CHECK(rate);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return SOUND_MANAGER_ERROR_INTERNAL;
+               return ret;
 
        result = g_dbus_connection_call_sync(conn,
                                                        PA_BUS_NAME,
@@ -1869,7 +1869,7 @@ int _set_avoid_resampling(int device_id, bool enable)
        GError *err = NULL;
 
        if ((ret = __get_dbus_connection(&conn)))
-               return SOUND_MANAGER_ERROR_INTERNAL;
+               return ret;
 
        g_dbus_connection_call_sync(conn,
                                                PA_BUS_NAME,
@@ -1901,10 +1901,10 @@ int _get_avoid_resampling(int device_id, bool *enabled)
        GError *err = NULL;
        gboolean _enabled;
 
-       SM_NULL_ARG_CHECK_FOR_PRIV(enabled);
+       SM_ARG_CHECK(enabled);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return SOUND_MANAGER_ERROR_INTERNAL;
+               return ret;
 
        result = g_dbus_connection_call_sync(conn,
                                                        PA_BUS_NAME,
@@ -1943,7 +1943,7 @@ int _set_media_stream_only(int device_id, bool enable)
        const char *stream_type;
 
        if ((ret = __get_dbus_connection(&conn)))
-               return SOUND_MANAGER_ERROR_INTERNAL;
+               return ret;
 
        if (enable)
                stream_type = STREAM_MEDIA;
@@ -1980,10 +1980,10 @@ int _get_media_stream_only(int device_id, bool *enabled)
        GError *err = NULL;
        char *stream_type;
 
-       SM_NULL_ARG_CHECK_FOR_PRIV(enabled);
+       SM_ARG_CHECK(enabled);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return SOUND_MANAGER_ERROR_INTERNAL;
+               return ret;
 
        result = g_dbus_connection_call_sync(conn,
                                                        PA_BUS_NAME,
@@ -2766,7 +2766,7 @@ int _set_volume_ratio(uint32_t stream_index, sound_stream_direction_e direction,
        const gchar *dbus_ret = NULL;
 
        if ((ret = __get_dbus_connection(&conn)))
-               return SOUND_MANAGER_ERROR_INTERNAL;
+               return ret;
 
        result = g_dbus_connection_call_sync(conn,
                                                PA_BUS_NAME,
@@ -2833,7 +2833,7 @@ int _set_virtual_stream_volume(virtual_sound_stream_info_s *virtual_stream, doub
 
 int _set_acm_master_mode(bool on)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        GVariant *result = NULL;
        GDBusConnection *conn = NULL;
        GError *err = NULL;
@@ -2854,7 +2854,7 @@ int _set_acm_master_mode(bool on)
                                                                          &err);
        if (err) {
                LOGE("g_dbus_connection_call_sync() for SET ACM MODE error (%s)", err->message);
-               ret = _convert_dbus_error(err->message);
+               ret = _convert_sound_manager_error_code(__func__, _convert_dbus_error(err->message));
                g_error_free(err);
                goto LEAVE;
        } else {
@@ -2877,7 +2877,7 @@ int _activate_ducking(uint32_t stream_index, bool enable, const char *target_str
        const gchar *dbus_ret = NULL;
 
        if ((ret = __get_dbus_connection(&conn)))
-               return SOUND_MANAGER_ERROR_INTERNAL;
+               return ret;
 
        result = g_dbus_connection_call_sync(conn,
                PA_BUS_NAME,
@@ -2932,7 +2932,7 @@ int _get_ducking_state(sound_pa_info_s *pa_info, bool *is_ducked)
        }
 
        if ((ret = __get_dbus_connection(&conn)))
-               return SOUND_MANAGER_ERROR_INTERNAL;
+               return ret;
 
        result = g_dbus_connection_call_sync(conn,
                PA_BUS_NAME,
@@ -2987,7 +2987,7 @@ static int __invoke_ipc_set_preferred_device_id(sound_stream_info_s *stream_info
        SM_ARG_CHECK(stream_info);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return SOUND_MANAGER_ERROR_INTERNAL;
+               return ret;
 
        for (i = SOUND_DEVICE_IO_DIRECTION_IN; i < SOUND_DEVICE_IO_DIRECTION_BOTH; i++) {
                if (device_id) {
@@ -3138,7 +3138,7 @@ int _get_preferred_device(sound_stream_info_s *stream_info, int *in_device_id, i
        SM_ARG_CHECK(stream_info);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return SOUND_MANAGER_ERROR_INTERNAL;
+               return ret;
 
        result = g_dbus_connection_call_sync(conn,
                PA_BUS_NAME,
@@ -3195,7 +3195,7 @@ LEAVE:
 
 static int __invoke_ipc_set_preemptive_device(sound_stream_type_e stream_type, sound_device_io_direction_e io_direction, int device_id)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        GVariant *result = NULL;
        GDBusConnection *conn = NULL;
        GError *err = NULL;
@@ -3204,7 +3204,7 @@ static int __invoke_ipc_set_preemptive_device(sound_stream_type_e stream_type, s
        char *stream_type_str;
        int i;
 
-       if ((ret = _convert_stream_type(stream_type, &stream_type_str)) != MM_ERROR_NONE)
+       if ((ret = _convert_stream_type(stream_type, &stream_type_str)) != SOUND_MANAGER_ERROR_NONE)
                return ret;
 
        if ((ret = __get_dbus_connection(&conn)))
@@ -3229,7 +3229,7 @@ static int __invoke_ipc_set_preemptive_device(sound_stream_type_e stream_type, s
                if (!result || err) {
                        LOGE("g_dbus_connection_call_sync() for SET_STREAM_PREEMPTIVE_DEVICE, direction(%s) error (%s)",
                                        direction_str, err ? err->message : NULL);
-                       ret = _convert_dbus_error(err ? err->message : NULL);
+                       ret = _convert_sound_manager_error_code(__func__, _convert_dbus_error(err ? err->message : NULL));
                        if (err)
                                g_error_free(err);
                        if (result)
@@ -3242,11 +3242,11 @@ static int __invoke_ipc_set_preemptive_device(sound_stream_type_e stream_type, s
                g_variant_get(result, "(&s)", &dbus_ret);
                LOGI("g_dbus_connection_call_sync() success, method return value is (%s)", dbus_ret);
                if (!strncmp("STREAM_MANAGER_RETURN_INVALID_ARGUMENT", dbus_ret, strlen(dbus_ret)))
-                       ret = MM_ERROR_INVALID_ARGUMENT;
+                       ret = SOUND_MANAGER_ERROR_INVALID_PARAMETER;
                else if (!strncmp("STREAM_MANAGER_RETURN_POLICY", dbus_ret, strlen(dbus_ret)))
-                       ret = MM_ERROR_POLICY_INTERNAL;
+                       ret = SOUND_MANAGER_ERROR_POLICY;
                else if (strncmp("STREAM_MANAGER_RETURN_OK", dbus_ret, strlen(dbus_ret)))
-                       ret = MM_ERROR_SOUND_INTERNAL;
+                       ret = SOUND_MANAGER_ERROR_INTERNAL;
 
                g_variant_unref(result);
                if (ret)
@@ -3260,7 +3260,7 @@ LEAVE:
 
 static int __invoke_ipc_get_preemptive_device(sound_stream_type_e stream_type, int *in_device_id, int *out_device_id)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        GDBusConnection *conn = NULL;
        GError *err = NULL;
        GVariant *result = NULL;
@@ -3269,7 +3269,7 @@ static int __invoke_ipc_get_preemptive_device(sound_stream_type_e stream_type, i
        unsigned int _out_device_id;
        char *stream_type_str;
 
-       if ((ret = _convert_stream_type(stream_type, &stream_type_str)) != MM_ERROR_NONE)
+       if ((ret = _convert_stream_type(stream_type, &stream_type_str)) != SOUND_MANAGER_ERROR_NONE)
                return ret;
 
        if ((ret = __get_dbus_connection(&conn)))
@@ -3288,7 +3288,7 @@ static int __invoke_ipc_get_preemptive_device(sound_stream_type_e stream_type, i
                &err);
        if (!result || err) {
                LOGE("g_dbus_connection_call_sync() for GET_STREAM_PREEMPTIVE_DEVICE error");
-               ret = _convert_dbus_error(err ? err->message : NULL);
+               ret = _convert_sound_manager_error_code(__func__, _convert_dbus_error(err ? err->message : NULL));
                if (err)
                        g_error_free(err);
                goto LEAVE;
@@ -3307,7 +3307,7 @@ static int __invoke_ipc_get_preemptive_device(sound_stream_type_e stream_type, i
                        LOGI("preemptive device id[out:%d]", *out_device_id);
                }
        } else {
-               ret = MM_ERROR_SOUND_INTERNAL;
+               ret = SOUND_MANAGER_ERROR_INTERNAL;
        }
 
 LEAVE:
@@ -3329,7 +3329,7 @@ int _get_preemptive_device(sound_stream_type_e stream_type, int *in_device_id, i
 
 int _get_latest_stream_pid(int stream_type, unsigned int *pid)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        GDBusConnection *conn = NULL;
        GError *err = NULL;
        GVariant *result = NULL;
@@ -3337,7 +3337,7 @@ int _get_latest_stream_pid(int stream_type, unsigned int *pid)
        const gchar *dbus_ret = NULL;
        unsigned int _pid;
 
-       SM_NULL_ARG_CHECK_FOR_PRIV(pid);
+       SM_ARG_CHECK(pid);
 
        if ((ret = __get_dbus_connection(&conn)))
                return ret;
@@ -3345,7 +3345,7 @@ int _get_latest_stream_pid(int stream_type, unsigned int *pid)
        builder_for_stream_types = g_variant_builder_new(G_VARIANT_TYPE("as"));
        if (!builder_for_stream_types) {
                LOGE("failed to g_variant_builder_new()");
-               ret = MM_ERROR_SOUND_INTERNAL;
+               ret = SOUND_MANAGER_ERROR_INTERNAL;
                goto LEAVE;
        }
 
@@ -3375,7 +3375,7 @@ int _get_latest_stream_pid(int stream_type, unsigned int *pid)
                &err);
        if (!result || err) {
                LOGE("g_dbus_connection_call_sync() for GET_LASTEST_STREAM_PID error");
-               ret = _convert_dbus_error(err ? err->message : NULL);
+               ret = _convert_sound_manager_error_code(__func__, _convert_dbus_error(err ? err->message : NULL));
                if (err)
                        g_error_free(err);
                goto LEAVE;
@@ -3388,9 +3388,9 @@ int _get_latest_stream_pid(int stream_type, unsigned int *pid)
        if (!strncmp("STREAM_MANAGER_RETURN_OK", dbus_ret, strlen(dbus_ret)))
                *pid = _pid;
        else if (!strncmp("STREAM_MANAGER_RETURN_ERROR_NO_STREAM", dbus_ret, strlen(dbus_ret)))
-               ret = MM_ERROR_SOUND_NO_DATA;
+               ret = SOUND_MANAGER_ERROR_NO_DATA;
        else
-               ret = MM_ERROR_SOUND_INTERNAL;
+               ret = SOUND_MANAGER_ERROR_INTERNAL;
 
 LEAVE:
        if (builder_for_stream_types)