Remove useless converting error logic inside of device APIs

[Version] 0.6.15
[Issue Type] Refactoring

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

diff --git a/packaging/capi-media-sound-manager.spec b/packaging/capi-media-sound-manager.spec
index c00e82a..d18c46d 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.14
+Version:    0.6.15
 Release:    0
 Group:      Multimedia/API
 License:    Apache-2.0

diff --git a/src/sound_manager.c b/src/sound_manager.c
index 26e9b56..52f9180 100644 (file)
--- a/src/sound_manager.c
+++ b/src/sound_manager.c
@@ -660,15 +660,11 @@ int sound_manager_is_stream_on_device(sound_stream_info_h stream_info, sound_dev
 
 int sound_manager_get_current_media_playback_device_type(sound_device_type_e *device_type)
 {
-       int ret = MM_ERROR_NONE;
-
-       LOGI(">> enter");
-
        SM_ARG_CHECK(device_type);
 
-       ret = _get_current_media_routing_path("out", device_type);
+       LOGI(">> enter");
 
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _get_current_media_routing_path("out", device_type);
 }
 
 int sound_manager_get_current_playback_focus(sound_stream_focus_change_reason_e *acquired_by, int *flags, char **extra_info)
@@ -816,6 +812,8 @@ int sound_manager_get_device_list(int device_mask, sound_device_list_h *device_l
 {
        int ret = MM_ERROR_NONE;
 
+       SM_ARG_CHECK(device_list);
+
        ret = mm_sound_get_device_list(device_mask, device_list);
 
        return _convert_sound_manager_error_code(__func__, ret);
@@ -825,6 +823,8 @@ int sound_manager_free_device_list(sound_device_list_h device_list)
 {
        int ret = MM_ERROR_NONE;
 
+       SM_ARG_CHECK(device_list);
+
        ret = mm_sound_free_device_list(device_list);
 
        return _convert_sound_manager_error_code(__func__, ret);
@@ -834,6 +834,9 @@ int sound_manager_get_next_device(sound_device_list_h device_list, sound_device_
 {
        int ret = MM_ERROR_NONE;
 
+       SM_ARG_CHECK(device_list);
+       SM_ARG_CHECK(device);
+
        ret = mm_sound_get_next_device(device_list, device);
 
        return _convert_sound_manager_error_code(__func__, ret);
@@ -843,6 +846,9 @@ int sound_manager_get_prev_device(sound_device_list_h device_list, sound_device_
 {
        int ret = MM_ERROR_NONE;
 
+       SM_ARG_CHECK(device_list);
+       SM_ARG_CHECK(device);
+
        ret = mm_sound_get_prev_device(device_list, device);
 
        return _convert_sound_manager_error_code(__func__, ret);
@@ -853,11 +859,13 @@ int sound_manager_get_device_type(sound_device_h device, sound_device_type_e *ty
        int ret = MM_ERROR_NONE;
        mm_sound_device_type_e mm_sound_device_type;
 
-       ret = mm_sound_get_device_type(device, &mm_sound_device_type);
-       if (ret == MM_ERROR_NONE)
-               ret = _convert_device_type(mm_sound_device_type, type);
+       SM_ARG_CHECK(device);
+       SM_ARG_CHECK(type);
 
-       return _convert_sound_manager_error_code(__func__, ret);
+       if ((ret = mm_sound_get_device_type(device, &mm_sound_device_type)))
+               return _convert_sound_manager_error_code(__func__, ret);
+
+       return _convert_device_type(mm_sound_device_type, type);
 }
 
 int sound_manager_get_device_io_direction(sound_device_h device, sound_device_io_direction_e *io_direction)
@@ -865,17 +873,22 @@ int sound_manager_get_device_io_direction(sound_device_h device, sound_device_io
        int ret = MM_ERROR_NONE;
        mm_sound_device_io_direction_e mm_sound_io_direction;
 
-       ret = mm_sound_get_device_io_direction(device, &mm_sound_io_direction);
-       if (ret == MM_ERROR_NONE)
-               ret = _convert_device_io_direction(mm_sound_io_direction, io_direction);
+       SM_ARG_CHECK(device);
+       SM_ARG_CHECK(io_direction);
 
-       return _convert_sound_manager_error_code(__func__, ret);
+       if ((ret = mm_sound_get_device_io_direction(device, &mm_sound_io_direction)))
+               return _convert_sound_manager_error_code(__func__, ret);
+
+       return _convert_device_io_direction(mm_sound_io_direction, io_direction);
 }
 
 int sound_manager_get_device_id(sound_device_h device, int *id)
 {
        int ret = MM_ERROR_NONE;
 
+       SM_ARG_CHECK(device);
+       SM_ARG_CHECK(id);
+
        ret = mm_sound_get_device_id(device, id);
 
        return _convert_sound_manager_error_code(__func__, ret);
@@ -885,6 +898,9 @@ int sound_manager_get_device_name(sound_device_h device, char **name)
 {
        int ret = MM_ERROR_NONE;
 
+       SM_ARG_CHECK(device);
+       SM_ARG_CHECK(name);
+
        ret = mm_sound_get_device_name(device, name);
 
        return _convert_sound_manager_error_code(__func__, ret);
@@ -908,6 +924,9 @@ int sound_manager_get_device_state(sound_device_h device, sound_device_state_e *
 {
        int ret = MM_ERROR_NONE;
 
+       SM_ARG_CHECK(device);
+       SM_ARG_CHECK(state);
+
        LOGW("DEPRECATION WARNING: %s() is deprecated and will be removed from next release.", __func__);
        ret = mm_sound_get_device_state(device, (mm_sound_device_state_e*)state);
 
@@ -916,7 +935,8 @@ int sound_manager_get_device_state(sound_device_h device, sound_device_state_e *
 
 int sound_manager_get_supported_sample_formats(sound_device_h device, sound_sample_format_e **formats, unsigned int *num_of_elems)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
+       int mm_ret = MM_ERROR_NONE;
        int device_id;
 
        SM_ARG_CHECK(device);
@@ -926,15 +946,16 @@ int sound_manager_get_supported_sample_formats(sound_device_h device, sound_samp
        if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
                return ret;
 
-       if (!(ret = mm_sound_get_device_id(device, &device_id)))
-               ret = _get_supported_sample_formats(device_id, formats, num_of_elems);
+       if ((mm_ret = mm_sound_get_device_id(device, &device_id)))
+               return _convert_sound_manager_error_code(__func__, mm_ret);
 
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _get_supported_sample_formats(device_id, formats, num_of_elems);
 }
 
 int sound_manager_set_sample_format(sound_device_h device, sound_sample_format_e format)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
+       int mm_ret = MM_ERROR_NONE;
        int device_id;
 
        SM_ARG_CHECK(device);
@@ -942,15 +963,16 @@ int sound_manager_set_sample_format(sound_device_h device, sound_sample_format_e
        if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
                return ret;
 
-       if (!(ret = mm_sound_get_device_id(device, &device_id)))
-               ret = _set_sample_format(device_id, format);
+       if ((mm_ret = mm_sound_get_device_id(device, &device_id)))
+               return _convert_sound_manager_error_code(__func__, mm_ret);
 
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _set_sample_format(device_id, format);
 }
 
 int sound_manager_get_sample_format(sound_device_h device, sound_sample_format_e *format)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
+       int mm_ret = MM_ERROR_NONE;
        int device_id;
 
        SM_ARG_CHECK(device);
@@ -959,15 +981,16 @@ int sound_manager_get_sample_format(sound_device_h device, sound_sample_format_e
        if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
                return ret;
 
-       if (!(ret = mm_sound_get_device_id(device, &device_id)))
-               ret = _get_sample_format(device_id, format);
+       if ((mm_ret = mm_sound_get_device_id(device, &device_id)))
+               return _convert_sound_manager_error_code(__func__, mm_ret);
 
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _get_sample_format(device_id, format);
 }
 
 int sound_manager_get_supported_sample_rates(sound_device_h device, sound_sample_rate_e **rates, unsigned int *num_of_elems)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
+       int mm_ret = MM_ERROR_NONE;
        int device_id;
 
        SM_ARG_CHECK(device);
@@ -977,15 +1000,16 @@ int sound_manager_get_supported_sample_rates(sound_device_h device, sound_sample
        if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
                return ret;
 
-       if (!(ret = mm_sound_get_device_id(device, &device_id)))
-               ret = _get_supported_sample_rates(device_id, rates, num_of_elems);
+       if ((mm_ret = mm_sound_get_device_id(device, &device_id)))
+               return _convert_sound_manager_error_code(__func__, mm_ret);
 
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _get_supported_sample_rates(device_id, rates, num_of_elems);
 }
 
 int sound_manager_set_sample_rate(sound_device_h device, sound_sample_rate_e rate)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
+       int mm_ret = MM_ERROR_NONE;
        int device_id;
 
        SM_ARG_CHECK(device);
@@ -993,15 +1017,16 @@ int sound_manager_set_sample_rate(sound_device_h device, sound_sample_rate_e rat
        if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
                return ret;
 
-       if (!(ret = mm_sound_get_device_id(device, &device_id)))
-               ret = _set_sample_rate(device_id, rate);
+       if ((mm_ret = mm_sound_get_device_id(device, &device_id)))
+               return _convert_sound_manager_error_code(__func__, mm_ret);
 
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _set_sample_rate(device_id, rate);
 }
 
 int sound_manager_get_sample_rate(sound_device_h device, sound_sample_rate_e *rate)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
+       int mm_ret = MM_ERROR_NONE;
        int device_id;
 
        SM_ARG_CHECK(device);
@@ -1010,15 +1035,16 @@ int sound_manager_get_sample_rate(sound_device_h device, sound_sample_rate_e *ra
        if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
                return ret;
 
-       if (!(ret = mm_sound_get_device_id(device, &device_id)))
-               ret = _get_sample_rate(device_id, rate);
+       if ((mm_ret = mm_sound_get_device_id(device, &device_id)))
+               return _convert_sound_manager_error_code(__func__, mm_ret);
 
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _get_sample_rate(device_id, rate);
 }
 
 int sound_manager_set_avoid_resampling(sound_device_h device, bool enable)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
+       int mm_ret = MM_ERROR_NONE;
        int device_id;
 
        SM_ARG_CHECK(device);
@@ -1026,15 +1052,16 @@ int sound_manager_set_avoid_resampling(sound_device_h device, bool enable)
        if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
                return ret;
 
-       if (!(ret = mm_sound_get_device_id(device, &device_id)))
-               ret = _set_avoid_resampling(device_id, enable);
+       if ((mm_ret = mm_sound_get_device_id(device, &device_id)))
+               return _convert_sound_manager_error_code(__func__, mm_ret);
 
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _set_avoid_resampling(device_id, enable);
 }
 
 int sound_manager_get_avoid_resampling(sound_device_h device, bool *enabled)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
+       int mm_ret = MM_ERROR_NONE;
        int device_id;
 
        SM_ARG_CHECK(device);
@@ -1043,15 +1070,16 @@ int sound_manager_get_avoid_resampling(sound_device_h device, bool *enabled)
        if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
                return ret;
 
-       if (!(ret = mm_sound_get_device_id(device, &device_id)))
-               ret = _get_avoid_resampling(device_id, enabled);
+       if ((mm_ret = mm_sound_get_device_id(device, &device_id)))
+               return _convert_sound_manager_error_code(__func__, mm_ret);
 
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _get_avoid_resampling(device_id, enabled);
 }
 
 int sound_manager_set_media_stream_only(sound_device_h device, bool enable)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
+       int mm_ret = MM_ERROR_NONE;
        int device_id;
 
        SM_ARG_CHECK(device);
@@ -1059,15 +1087,16 @@ int sound_manager_set_media_stream_only(sound_device_h device, bool enable)
        if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
                return ret;
 
-       if (!(ret = mm_sound_get_device_id(device, &device_id)))
-               ret = _set_media_stream_only(device_id, enable);
+       if ((mm_ret = mm_sound_get_device_id(device, &device_id)))
+               return _convert_sound_manager_error_code(__func__, mm_ret);
 
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _set_media_stream_only(device_id, enable);
 }
 
 int sound_manager_get_media_stream_only(sound_device_h device, bool *enabled)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
+       int mm_ret = MM_ERROR_NONE;
        int device_id;
 
        SM_ARG_CHECK(device);
@@ -1076,10 +1105,10 @@ int sound_manager_get_media_stream_only(sound_device_h device, bool *enabled)
        if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
                return ret;
 
-       if (!(ret = mm_sound_get_device_id(device, &device_id)))
-               ret = _get_media_stream_only(device_id, enabled);
+       if ((mm_ret = mm_sound_get_device_id(device, &device_id)))
+               return _convert_sound_manager_error_code(__func__, mm_ret);
 
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _get_media_stream_only(device_id, enabled);
 }
 
 int sound_manager_add_device_connection_changed_cb(int device_mask, sound_device_connection_changed_cb callback, void *user_data, int *id)
@@ -1098,8 +1127,7 @@ int sound_manager_remove_device_connection_changed_cb(int id)
 {
        int ret = MM_ERROR_NONE;
 
-       if (id < 0)
-               return _convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
+       SM_ARG_CHECK(id >= 0);
 
        ret = mm_sound_remove_device_connected_callback((unsigned int)id);
 

diff --git a/src/sound_manager_internal.c b/src/sound_manager_internal.c
index 7780dbd..e90ef51 100644 (file)
--- a/src/sound_manager_internal.c
+++ b/src/sound_manager_internal.c
@@ -318,137 +318,95 @@ LEAVE:
 
 int sound_manager_is_device_running_by_id(int device_id, bool *is_running)
 {
-       int ret = MM_ERROR_NONE;
+       SM_ARG_CHECK(is_running);
 
        LOGI(">> enter");
 
-       ret = _is_device_running_by_id(device_id, is_running);
-
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _is_device_running_by_id(device_id, is_running);
 }
 
 int sound_manager_get_supported_sample_formats_by_id(int device_id, sound_sample_format_e **formats, unsigned int *num_of_elems)
 {
-       int ret = MM_ERROR_NONE;
-
        SM_ARG_CHECK(formats);
        SM_ARG_CHECK(num_of_elems);
 
        LOGI(">> enter");
 
-       ret = _get_supported_sample_formats(device_id, formats, num_of_elems);
-
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _get_supported_sample_formats(device_id, formats, num_of_elems);
 }
 
 int sound_manager_set_sample_format_by_id(int device_id, sound_sample_format_e format)
 {
-       int ret = MM_ERROR_NONE;
-
        LOGI(">> enter");
 
-       ret = _set_sample_format(device_id, format);
-
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _set_sample_format(device_id, format);
 }
 
 int sound_manager_get_sample_format_by_id(int device_id, sound_sample_format_e *format)
 {
-       int ret = MM_ERROR_NONE;
-
        SM_ARG_CHECK(format);
 
        LOGI(">> enter");
 
-       ret = _get_sample_format(device_id, format);
-
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _get_sample_format(device_id, format);
 }
 
 int sound_manager_get_supported_sample_rates_by_id(int device_id, sound_sample_rate_e **rates, unsigned int *num_of_elems)
 {
-       int ret = MM_ERROR_NONE;
-
        SM_ARG_CHECK(rates);
        SM_ARG_CHECK(num_of_elems);
 
        LOGI(">> enter");
 
-       ret = _get_supported_sample_rates(device_id, rates, num_of_elems);
-
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _get_supported_sample_rates(device_id, rates, num_of_elems);
 }
 
 int sound_manager_set_sample_rate_by_id(int device_id, sound_sample_rate_e rate)
 {
-       int ret = MM_ERROR_NONE;
-
        LOGI(">> enter");
 
-       ret = _set_sample_rate(device_id, rate);
-
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _set_sample_rate(device_id, rate);
 }
 
 int sound_manager_get_sample_rate_by_id(int device_id, sound_sample_rate_e *rate)
 {
-       int ret = MM_ERROR_NONE;
-
        SM_ARG_CHECK(rate);
 
        LOGI(">> enter");
 
-       ret = _get_sample_rate(device_id, rate);
-
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _get_sample_rate(device_id, rate);
 }
 
 int sound_manager_set_avoid_resampling_by_id(int device_id, bool enable)
 {
-       int ret = MM_ERROR_NONE;
-
        LOGI(">> enter");
 
-       ret = _set_avoid_resampling(device_id, enable);
-
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _set_avoid_resampling(device_id, enable);
 }
 
 int sound_manager_get_avoid_resampling_by_id(int device_id, bool *enabled)
 {
-       int ret = MM_ERROR_NONE;
-
-       LOGI(">> enter");
-
        SM_ARG_CHECK(enabled);
 
-       ret = _get_avoid_resampling(device_id, enabled);
+       LOGI(">> enter");
 
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _get_avoid_resampling(device_id, enabled);
 }
 
 int sound_manager_set_media_stream_only_by_id(int device_id, bool enable)
 {
-       int ret = MM_ERROR_NONE;
-
        LOGI(">> enter");
 
-       ret = _set_media_stream_only(device_id, enable);
-
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _set_media_stream_only(device_id, enable);
 }
 
 int sound_manager_get_media_stream_only_by_id(int device_id, bool *enabled)
 {
-       int ret = MM_ERROR_NONE;
-
        SM_ARG_CHECK(enabled);
 
        LOGI(">> enter");
 
-       ret = _get_media_stream_only(device_id, enabled);
-
-       return _convert_sound_manager_error_code(__func__, ret);
+       return _get_media_stream_only(device_id, enabled);
 }
 
 int sound_manager_create_virtual_stream(sound_stream_info_h stream_info, virtual_sound_stream_h *virtual_stream)

diff --git a/src/sound_manager_private.c b/src/sound_manager_private.c
index d0985e0..79aaf50 100644 (file)
--- a/src/sound_manager_private.c
+++ b/src/sound_manager_private.c
@@ -530,8 +530,8 @@ int _convert_device_type_enum_to_str(sound_device_type_e device_type, char **dev
 
 int _convert_device_type_str_to_enum(const char *device_type_str, sound_device_type_e *device_type)
 {
-       SM_NULL_ARG_CHECK_FOR_PRIV(device_type_str);
-       SM_NULL_ARG_CHECK_FOR_PRIV(device_type);
+       SM_ARG_CHECK(device_type_str);
+       SM_ARG_CHECK(device_type);
 
        if (!strncmp(device_type_str, "builtin-speaker", SOUND_DEVICE_TYPE_LEN)) {
                *device_type = SOUND_DEVICE_BUILTIN_SPEAKER;
@@ -561,10 +561,10 @@ int _convert_device_type_str_to_enum(const char *device_type_str, sound_device_t
 
        } else {
                LOGE("not supported device_type(%s)", device_type_str);
-               return MM_ERROR_INVALID_ARGUMENT;
+               return SOUND_MANAGER_ERROR_INVALID_PARAMETER;
        }
 
-       return MM_ERROR_NONE;
+       return SOUND_MANAGER_ERROR_NONE;
 }
 //LCOV_EXCL_STOP
 int _convert_device_type(mm_sound_device_type_e device_type, sound_device_type_e *sound_device_type)
@@ -614,7 +614,7 @@ int _convert_device_type(mm_sound_device_type_e device_type, sound_device_type_e
 
 int _convert_device_io_direction(mm_sound_device_io_direction_e io_direction, sound_device_io_direction_e *sound_io_direction)
 {
-       SM_NULL_ARG_CHECK_FOR_PRIV(sound_io_direction);
+       SM_ARG_CHECK(sound_io_direction);
 
        switch (io_direction) {
        case MM_SOUND_DEVICE_IO_DIRECTION_IN:
@@ -628,7 +628,7 @@ int _convert_device_io_direction(mm_sound_device_io_direction_e io_direction, so
                break;
        }
 
-       return MM_ERROR_NONE;
+       return SOUND_MANAGER_ERROR_NONE;
 }
 //LCOV_EXCL_START
 const char* _convert_api_name(native_api_e api_name)
@@ -661,7 +661,7 @@ const char* _convert_api_name(native_api_e api_name)
 
 int _convert_sample_format_enum_to_str(sound_sample_format_e format, char **format_str)
 {
-       SM_NULL_ARG_CHECK_FOR_PRIV(format_str);
+       SM_ARG_CHECK(format_str);
 
        switch (format) {
        case SOUND_SAMPLE_FORMAT_U8:
@@ -678,16 +678,16 @@ int _convert_sample_format_enum_to_str(sound_sample_format_e format, char **form
                break;
        default:
                LOGE("could not find format[%d] in this switch case statement", format);
-               return MM_ERROR_SOUND_INTERNAL;
+               return SOUND_MANAGER_ERROR_INTERNAL;
        }
 
-       return MM_ERROR_NONE;
+       return SOUND_MANAGER_ERROR_NONE;
 }
 
 int _convert_sample_format_str_to_enum(const char *format_str, sound_sample_format_e *format)
 {
-       SM_NULL_ARG_CHECK_FOR_PRIV(format_str);
-       SM_NULL_ARG_CHECK_FOR_PRIV(format);
+       SM_ARG_CHECK(format_str);
+       SM_ARG_CHECK(format);
 
        if (!strncmp(format_str, "u8", SOUND_SAMPLE_FORMAT_LEN) || !strncmp(format_str, "8", SOUND_SAMPLE_FORMAT_LEN)) {
                *format = SOUND_SAMPLE_FORMAT_U8;
@@ -699,15 +699,15 @@ int _convert_sample_format_str_to_enum(const char *format_str, sound_sample_form
                *format = SOUND_SAMPLE_FORMAT_S24_32_LE;
        } else {
                LOGE("not supported sample format(%s)", format_str);
-               return MM_ERROR_INVALID_ARGUMENT;
+               return SOUND_MANAGER_ERROR_INVALID_PARAMETER;
        }
 
-       return MM_ERROR_NONE;
+       return SOUND_MANAGER_ERROR_NONE;
 }
 
 int _convert_sample_rate_enum_to_uint(sound_sample_rate_e rate, unsigned int *sample_rate)
 {
-       SM_NULL_ARG_CHECK_FOR_PRIV(sample_rate);
+       SM_ARG_CHECK(sample_rate);
 
        switch (rate) {
        case SOUND_SAMPLE_RATE_8000:
@@ -736,15 +736,15 @@ int _convert_sample_rate_enum_to_uint(sound_sample_rate_e rate, unsigned int *sa
                break;
        default:
                LOGE("not supported sample rate(%u)", rate);
-               return MM_ERROR_INVALID_ARGUMENT;
+               return SOUND_MANAGER_ERROR_INVALID_PARAMETER;
        }
 
-       return MM_ERROR_NONE;
+       return SOUND_MANAGER_ERROR_NONE;
 }
 
 int _convert_sample_rate_to_enum(unsigned int rate, sound_sample_rate_e *rate_e)
 {
-       SM_NULL_ARG_CHECK_FOR_PRIV(rate_e);
+       SM_ARG_CHECK(rate_e);
 
        switch (rate) {
        case 8000:
@@ -773,10 +773,10 @@ int _convert_sample_rate_to_enum(unsigned int rate, sound_sample_rate_e *rate_e)
                break;
        default:
                LOGE("not supported sample rate(%u)", rate);
-               return MM_ERROR_INVALID_ARGUMENT;
+               return SOUND_MANAGER_ERROR_INVALID_PARAMETER;
        }
 
-       return MM_ERROR_NONE;
+       return SOUND_MANAGER_ERROR_NONE;
 }
 //LCOV_EXCL_STOP
 
@@ -792,7 +792,7 @@ int _return_val_if_not_usb_device(sound_device_h device, int ret_val)
                return ret_val;
        }
 
-       return MM_ERROR_NONE;
+       return SOUND_MANAGER_ERROR_NONE;
 }
 
 //LCOV_EXCL_START
@@ -1413,7 +1413,7 @@ LEAVE:
 
 int _get_current_media_routing_path(const char *direction, sound_device_type_e *device_type)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        GVariant *result = NULL;
        GDBusConnection *conn = NULL;
        GError *err = NULL;
@@ -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 ret;
+               return SOUND_MANAGER_ERROR_INTERNAL;
 
        result = g_dbus_connection_call_sync(conn,
                                                        PA_BUS_NAME,
@@ -1442,7 +1442,7 @@ int _get_current_media_routing_path(const char *direction, sound_device_type_e *
                LOGE("g_dbus_connection_call_sync() for GET_CURRENT_MEDIA_ROUTING_PATH error (%s)", err ? err->message : NULL);
                if (err)
                        g_error_free(err);
-               ret = MM_ERROR_SOUND_INTERNAL;
+               ret = SOUND_MANAGER_ERROR_INTERNAL;
                goto LEAVE;
                //LCOV_EXCL_STOP
        }
@@ -1450,14 +1450,13 @@ int _get_current_media_routing_path(const char *direction, sound_device_type_e *
        g_variant_get(result, "(&s&s)", &dbus_device_type, &dbus_ret);
        LOGI("g_dbus_connection_call_sync() success, method return value is (%s, %s)", dbus_device_type, dbus_ret);
        if (!strncmp("STREAM_MANAGER_RETURN_OK", dbus_ret, strlen(dbus_ret))) {
-               ret = MM_ERROR_NONE;
                if (_convert_device_type_str_to_enum(dbus_device_type, device_type) < 0)
-                       ret = MM_ERROR_SOUND_INTERNAL;//LCOV_EXCL_LINE
+                       ret = SOUND_MANAGER_ERROR_INTERNAL;//LCOV_EXCL_LINE
        } else {
                if (!strncmp("none", dbus_device_type, strlen(dbus_device_type)))
-                       ret = MM_ERROR_SOUND_NO_DATA;
+                       ret = SOUND_MANAGER_ERROR_NO_DATA;
                else
-                       ret = MM_ERROR_SOUND_INTERNAL;
+                       ret = SOUND_MANAGER_ERROR_INTERNAL;
        }
 
 LEAVE:
@@ -1511,7 +1510,7 @@ LEAVE:
 //LCOV_EXCL_START
 int _is_device_running_by_id(int device_id, bool *is_running)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        GVariant *result = NULL;
        GDBusConnection *conn = NULL;
        GError *err = NULL;
@@ -1520,7 +1519,7 @@ int _is_device_running_by_id(int device_id, bool *is_running)
        assert(is_running);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return ret;
+               return SOUND_MANAGER_ERROR_INTERNAL;
 
        result = g_dbus_connection_call_sync(conn,
                                                                          PA_BUS_NAME,
@@ -1535,7 +1534,7 @@ int _is_device_running_by_id(int device_id, bool *is_running)
                                                                          &err);
        if (err) {
                LOGE("g_dbus_connection_call_sync() for IS_DEVICE_RUNNING_BY_ID 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 {
@@ -1554,7 +1553,7 @@ LEAVE:
 #define SM_SAMPLE_FORMAT_NUM    4 /* check declaration of sound_sample_format_e */
 int _get_supported_sample_formats(int device_id, sound_sample_format_e **formats, unsigned int *num)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        GVariant *result = NULL;
        GDBusConnection *conn = NULL;
        GError *err = NULL;
@@ -1565,11 +1564,11 @@ int _get_supported_sample_formats(int device_id, sound_sample_format_e **formats
        sound_sample_format_e format;
        sound_sample_format_e sm_formats[SM_SAMPLE_FORMAT_NUM] = {0, };
 
-       SM_NULL_ARG_CHECK_FOR_PRIV(formats);
-       SM_NULL_ARG_CHECK_FOR_PRIV(num);
+       SM_ARG_CHECK(formats);
+       SM_ARG_CHECK(num);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return ret;
+               return SOUND_MANAGER_ERROR_INTERNAL;
 
        result = g_dbus_connection_call_sync(conn,
                                                        PA_BUS_NAME,
@@ -1584,7 +1583,7 @@ int _get_supported_sample_formats(int device_id, sound_sample_format_e **formats
                                                        &err);
        if (!result || err) {
                LOGE("g_dbus_connection_call_sync() for GET_SUPPORTED_SAMPLE_FORMATS error (%s)", 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);
                goto LEAVE;
@@ -1593,7 +1592,7 @@ int _get_supported_sample_formats(int device_id, sound_sample_format_e **formats
        g_variant_get(result, "(as)", &iter);
        if ((iter_num = (unsigned int) g_variant_iter_n_children(iter)) == 0) {
                LOGE("could not get supported sample formats");
-               ret = MM_ERROR_SOUND_INTERNAL;
+               ret = SOUND_MANAGER_ERROR_INTERNAL;
                goto LEAVE;
        }
 
@@ -1607,13 +1606,13 @@ int _get_supported_sample_formats(int device_id, sound_sample_format_e **formats
 
        if (elem_num == 0) {
                LOGE("could not find supported sample formats");
-               ret = MM_ERROR_SOUND_INTERNAL;
+               ret = SOUND_MANAGER_ERROR_INTERNAL;
                goto LEAVE;
        }
 
        if (!(*formats = (sound_sample_format_e *) calloc(elem_num, sizeof(sound_sample_format_e)))) {
                LOGE("failed to calloc(), elem_num(%d)", elem_num);
-               ret = MM_ERROR_SOUND_INTERNAL;
+               ret = SOUND_MANAGER_ERROR_INTERNAL;
                goto LEAVE;
        } else {
                memcpy(*formats, sm_formats, elem_num * sizeof(sound_sample_format_e));
@@ -1631,13 +1630,13 @@ LEAVE:
 
 int _set_sample_format(int device_id, sound_sample_format_e format)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        GDBusConnection *conn = NULL;
        GError *err = NULL;
        char *format_str = NULL;
 
        if ((ret = __get_dbus_connection(&conn)))
-               return ret;
+               return SOUND_MANAGER_ERROR_INTERNAL;
 
        if ((ret = _convert_sample_format_enum_to_str(format, &format_str)))
                return ret;
@@ -1655,7 +1654,7 @@ int _set_sample_format(int device_id, sound_sample_format_e format)
                                                &err);
        if (err) {
                LOGE("g_dbus_connection_call_sync() for SET_SAMPLE_FORMAT error (%s)", err->message);
-               ret = _convert_dbus_error(err->message);
+               ret = _convert_sound_manager_error_code(__func__, _convert_dbus_error(err ? err->message : NULL));
                g_error_free(err);
        }
 
@@ -1666,17 +1665,17 @@ int _set_sample_format(int device_id, sound_sample_format_e format)
 
 int _get_sample_format(int device_id, sound_sample_format_e *format)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        GVariant *result = NULL;
        GDBusConnection *conn = NULL;
        GError *err = NULL;
        gchar *format_str;
        sound_sample_format_e format_e;
 
-       SM_NULL_ARG_CHECK_FOR_PRIV(format);
+       SM_ARG_CHECK(format);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return ret;
+               return SOUND_MANAGER_ERROR_INTERNAL;
 
        result = g_dbus_connection_call_sync(conn,
                                                        PA_BUS_NAME,
@@ -1691,15 +1690,13 @@ int _get_sample_format(int device_id, sound_sample_format_e *format)
                                                        &err);
        if (!result || err) {
                LOGE("g_dbus_connection_call_sync() for GET_SAMPLE_FORMAT error (%s)", 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);
                goto LEAVE;
        }
        g_variant_get(result, "(&s)", &format_str);
-       if (_convert_sample_format_str_to_enum((const char *)format_str, &format_e))
-               ret = MM_ERROR_SOUND_INTERNAL;
-       else
+       if (!(ret = _convert_sample_format_str_to_enum((const char *)format_str, &format_e)))
                *format = format_e;
 
        g_variant_unref(result);
@@ -1713,7 +1710,7 @@ LEAVE:
 #define SM_SAMPLE_RATE_NUM    8 /* check declaration of sound_sample_rate_e */
 int _get_supported_sample_rates(int device_id, sound_sample_rate_e **rates, unsigned int *num)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        GVariant *result = NULL;
        GDBusConnection *conn = NULL;
        GError *err = NULL;
@@ -1724,11 +1721,11 @@ int _get_supported_sample_rates(int device_id, sound_sample_rate_e **rates, unsi
        sound_sample_rate_e rate_e;
        sound_sample_rate_e sm_rates[SM_SAMPLE_RATE_NUM] = {0, };
 
-       SM_NULL_ARG_CHECK_FOR_PRIV(rates);
-       SM_NULL_ARG_CHECK_FOR_PRIV(num);
+       SM_ARG_CHECK(rates);
+       SM_ARG_CHECK(num);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return ret;
+               return SOUND_MANAGER_ERROR_INTERNAL;
 
        result = g_dbus_connection_call_sync(conn,
                                                        PA_BUS_NAME,
@@ -1743,7 +1740,7 @@ int _get_supported_sample_rates(int device_id, sound_sample_rate_e **rates, unsi
                                                        &err);
        if (!result || err) {
                LOGE("g_dbus_connection_call_sync() for GET_SUPPORTED_SAMPLE_RATES error (%s)", 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);
                goto LEAVE;
@@ -1752,7 +1749,7 @@ int _get_supported_sample_rates(int device_id, sound_sample_rate_e **rates, unsi
        g_variant_get(result, "(au)", &iter);
        if ((iter_num = (unsigned int) g_variant_iter_n_children(iter)) == 0) {
                LOGE("could not get supported sample rates");
-               ret = MM_ERROR_SOUND_INTERNAL;
+               ret = SOUND_MANAGER_ERROR_INTERNAL;
                goto LEAVE;
        }
 
@@ -1766,13 +1763,13 @@ int _get_supported_sample_rates(int device_id, sound_sample_rate_e **rates, unsi
 
        if (elem_num == 0) {
                LOGE("could not find supported sample rates");
-               ret = MM_ERROR_SOUND_INTERNAL;
+               ret = SOUND_MANAGER_ERROR_INTERNAL;
                goto LEAVE;
        }
 
        if (!(*rates = (sound_sample_rate_e *) calloc(elem_num, sizeof(sound_sample_rate_e)))) {
                LOGE("failed to calloc(), elem_num(%d)", elem_num);
-               ret = MM_ERROR_SOUND_INTERNAL;
+               ret = SOUND_MANAGER_ERROR_INTERNAL;
                goto LEAVE;
        } else {
                memcpy(*rates, sm_rates, elem_num * sizeof(sound_sample_rate_e));
@@ -1790,13 +1787,13 @@ LEAVE:
 
 int _set_sample_rate(int device_id, sound_sample_rate_e rate)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        GDBusConnection *conn = NULL;
        GError *err = NULL;
        unsigned int _rate;
 
        if ((ret = __get_dbus_connection(&conn)))
-               return ret;
+               return SOUND_MANAGER_ERROR_INTERNAL;
 
        if ((ret = _convert_sample_rate_enum_to_uint(rate, &_rate)))
                return ret;
@@ -1814,7 +1811,7 @@ int _set_sample_rate(int device_id, sound_sample_rate_e rate)
                                                &err);
        if (err) {
                LOGE("g_dbus_connection_call_sync() for SET_SAMPLE_RATE 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);
        }
 
@@ -1825,7 +1822,7 @@ int _set_sample_rate(int device_id, sound_sample_rate_e rate)
 
 int _get_sample_rate(int device_id, sound_sample_rate_e *rate)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        GVariant *result = NULL;
        GDBusConnection *conn = NULL;
        GError *err = NULL;
@@ -1835,7 +1832,7 @@ int _get_sample_rate(int device_id, sound_sample_rate_e *rate)
        SM_NULL_ARG_CHECK_FOR_PRIV(rate);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return ret;
+               return SOUND_MANAGER_ERROR_INTERNAL;
 
        result = g_dbus_connection_call_sync(conn,
                                                        PA_BUS_NAME,
@@ -1850,15 +1847,13 @@ int _get_sample_rate(int device_id, sound_sample_rate_e *rate)
                                                        &err);
        if (!result || err) {
                LOGE("g_dbus_connection_call_sync() for GET_SAMPLE_RATE error (%s)", 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);
                goto LEAVE;
        }
        g_variant_get(result, "(u)", &_rate);
-       if (_convert_sample_rate_to_enum(_rate, &rate_e))
-               ret = MM_ERROR_SOUND_INTERNAL;
-       else
+       if (!(ret = _convert_sample_rate_to_enum(_rate, &rate_e)))
                *rate = rate_e;
 
        g_variant_unref(result);
@@ -1871,12 +1866,12 @@ LEAVE:
 
 int _set_avoid_resampling(int device_id, bool enable)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        GDBusConnection *conn = NULL;
        GError *err = NULL;
 
        if ((ret = __get_dbus_connection(&conn)))
-               return ret;
+               return SOUND_MANAGER_ERROR_INTERNAL;
 
        g_dbus_connection_call_sync(conn,
                                                PA_BUS_NAME,
@@ -1891,7 +1886,7 @@ int _set_avoid_resampling(int device_id, bool enable)
                                                &err);
        if (err) {
                LOGE("g_dbus_connection_call_sync() for SET_AVOID_RESAMPLING 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);
        }
 
@@ -1902,7 +1897,7 @@ int _set_avoid_resampling(int device_id, bool enable)
 
 int _get_avoid_resampling(int device_id, bool *enabled)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        GVariant *result = NULL;
        GDBusConnection *conn = NULL;
        GError *err = NULL;
@@ -1911,7 +1906,7 @@ int _get_avoid_resampling(int device_id, bool *enabled)
        SM_NULL_ARG_CHECK_FOR_PRIV(enabled);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return ret;
+               return SOUND_MANAGER_ERROR_INTERNAL;
 
        result = g_dbus_connection_call_sync(conn,
                                                        PA_BUS_NAME,
@@ -1926,7 +1921,7 @@ int _get_avoid_resampling(int device_id, bool *enabled)
                                                        &err);
        if (!result || err) {
                LOGE("g_dbus_connection_call_sync() for GET_AVOID_RESAMPLING error (%s)", 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);
                goto LEAVE;
@@ -1944,13 +1939,13 @@ LEAVE:
 
 int _set_media_stream_only(int device_id, bool enable)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        GDBusConnection *conn = NULL;
        GError *err = NULL;
        const char *stream_type;
 
        if ((ret = __get_dbus_connection(&conn)))
-               return ret;
+               return SOUND_MANAGER_ERROR_INTERNAL;
 
        if (enable)
                stream_type = STREAM_MEDIA;
@@ -1970,7 +1965,7 @@ int _set_media_stream_only(int device_id, bool enable)
                                                &err);
        if (err) {
                LOGE("g_dbus_connection_call_sync() for SET_SPECIFIC_STREAM 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);
        }
 
@@ -1981,7 +1976,7 @@ int _set_media_stream_only(int device_id, bool enable)
 
 int _get_media_stream_only(int device_id, bool *enabled)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        GVariant *result = NULL;
        GDBusConnection *conn = NULL;
        GError *err = NULL;
@@ -1990,7 +1985,7 @@ int _get_media_stream_only(int device_id, bool *enabled)
        SM_NULL_ARG_CHECK_FOR_PRIV(enabled);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return ret;
+               return SOUND_MANAGER_ERROR_INTERNAL;
 
        result = g_dbus_connection_call_sync(conn,
                                                        PA_BUS_NAME,
@@ -2005,7 +2000,7 @@ int _get_media_stream_only(int device_id, bool *enabled)
                                                        &err);
        if (!result || err) {
                LOGE("g_dbus_connection_call_sync() for GET_SPECIFIED_STREAM error (%s)", 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);
                goto LEAVE;