Revise macro for checking argument value

SM_INSTANCE_CHECK() and SM_NULL_ARG_CHECK() are
unified by SM_ARG_CHECK().
Put entering log after the argument check.

[Version] 0.6.10
[Issue Type] Improvement

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

diff --git a/include/sound_manager_private.h b/include/sound_manager_private.h
index e772db5..e2cc289 100644 (file)
--- a/include/sound_manager_private.h
+++ b/include/sound_manager_private.h
@@ -44,16 +44,13 @@ extern "C"
 #define _CHECK_CONDITION(condition, error, msg)     \
 do { \
        if (!(condition)) { \
-               LOGE("[%s] %s(0x%08x)", __FUNCTION__, msg, error); \
+               LOGE("'%s' failed, error: %s(0x%08x)", #condition, msg, error); \
                return error; \
        } \
 } while (0)
 
-#define SM_INSTANCE_CHECK(handle) \
-_CHECK_CONDITION(handle != NULL, SOUND_MANAGER_ERROR_INVALID_PARAMETER, "SOUND_MANAGER_ERROR_INVALID_PARAMETER")
-
-#define SM_NULL_ARG_CHECK(arg) \
-_CHECK_CONDITION(!!(arg) != false, SOUND_MANAGER_ERROR_INVALID_PARAMETER, "SOUND_MANAGER_ERROR_INVALID_PARAMETER")
+#define SM_ARG_CHECK(arg) \
+_CHECK_CONDITION(arg, SOUND_MANAGER_ERROR_INVALID_PARAMETER, "SOUND_MANAGER_ERROR_INVALID_PARAMETER")
 
 #define SM_STATE_CHECK(handle, expected_state) \
 _CHECK_CONDITION(handle->state == expected_state, SOUND_MANAGER_ERROR_INVALID_STATE, "SOUND_MANAGER_ERROR_INVALID_STATE")

diff --git a/packaging/capi-media-sound-manager.spec b/packaging/capi-media-sound-manager.spec
index 0f203da..55fb6e8 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.9
+Version:    0.6.10
 Release:    0
 Group:      Multimedia/API
 License:    Apache-2.0

diff --git a/src/sound_manager.c b/src/sound_manager.c
index e90c738..4856a76 100644 (file)
--- a/src/sound_manager.c
+++ b/src/sound_manager.c
@@ -57,9 +57,8 @@ int sound_manager_get_max_volume(sound_type_e type, int *max)
        unsigned int max_level = 0;
        int ret = MM_ERROR_NONE;
 
-       SM_NULL_ARG_CHECK(max);
-       if (type >= SOUND_TYPE_NUM)
-               return _convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
+       SM_ARG_CHECK(max);
+       SM_ARG_CHECK(type < SOUND_TYPE_NUM);
 
        ret = _convert_sound_type(type, &volume_type);
        if (ret == MM_ERROR_NONE) {
@@ -75,10 +74,8 @@ int sound_manager_set_volume(sound_type_e type, int volume)
 {
        int ret = MM_ERROR_NONE;
 
-       if (type >= SOUND_TYPE_NUM)
-               return _convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
-       if (volume < 0)
-               return _convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
+       SM_ARG_CHECK(type < SOUND_TYPE_NUM);
+       SM_ARG_CHECK(volume >= 0);
 
        ret = mm_sound_volume_set_value(type, volume);
        LOGI("type=%d, volume=%d", type, volume);
@@ -91,10 +88,8 @@ int sound_manager_get_volume(sound_type_e type, int *volume)
        int ret = MM_ERROR_NONE;
        unsigned int uvolume;
 
-       if (type >= SOUND_TYPE_NUM)
-               return _convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
-       if (volume == NULL)
-               return _convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
+       SM_ARG_CHECK(type < SOUND_TYPE_NUM);
+       SM_ARG_CHECK(volume);
 
        ret = mm_sound_volume_get_value(type, &uvolume);
        if (ret == MM_ERROR_NONE)
@@ -110,8 +105,7 @@ int sound_manager_get_current_sound_type(sound_type_e *type)
        int ret = MM_ERROR_NONE;
        char *volume_type = NULL;
 
-       if (type == NULL)
-               return _convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
+       SM_ARG_CHECK(type);
 
        /* get the volume type of the current playing stream */
        ret = _get_current_volume_type(DIRECTION_OUT_STR, &volume_type);
@@ -128,8 +122,8 @@ int sound_manager_add_volume_changed_cb(sound_manager_volume_changed_cb callback
 {
        int ret = MM_ERROR_NONE;
 
-       if (!callback || !id)
-               return _convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
+       SM_ARG_CHECK(callback);
+       SM_ARG_CHECK(id);
 
        ret = mm_sound_add_volume_changed_callback((mm_sound_volume_changed_cb)callback, user_data, (unsigned int*)id);
 
@@ -140,8 +134,7 @@ int sound_manager_remove_volume_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_volume_changed_callback(id);
 
@@ -152,9 +145,9 @@ int sound_manager_create_stream_information(sound_stream_type_e stream_type, sou
 {
        int ret = MM_ERROR_NONE;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(stream_info);
 
-       SM_NULL_ARG_CHECK(stream_info);
+       LOGI(">> enter");
 
        sound_stream_info_s *stream_h = malloc(sizeof(sound_stream_info_s));
        if (!stream_h) {
@@ -185,9 +178,9 @@ int sound_manager_destroy_stream_information(sound_stream_info_h stream_info)
        int ret = MM_ERROR_NONE;
        sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(stream_h);
 
-       SM_INSTANCE_CHECK(stream_h);
+       LOGI(">> enter");
 
        SM_ENTER_CRITICAL_SECTION_WITH_RETURN(&stream_h->vstream_mutex, SOUND_MANAGER_ERROR_INTERNAL);
        if (stream_h->vstream) {
@@ -211,10 +204,10 @@ int sound_manager_get_sound_type(sound_stream_info_h stream_info, sound_type_e *
        int ret = MM_ERROR_NONE;
        sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(stream_h);
+       SM_ARG_CHECK(sound_type);
 
-       SM_INSTANCE_CHECK(stream_h);
-       SM_NULL_ARG_CHECK(sound_type);
+       LOGI(">> enter");
 
        if (stream_h->stream_conf_info.volume_type == NULL) {
                ret = MM_ERROR_SOUND_NO_DATA;
@@ -281,7 +274,7 @@ int sound_manager_set_stream_preferred_device(sound_stream_info_h stream_info, s
        int ret = MM_ERROR_NONE;
        sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 
-       SM_NULL_ARG_CHECK(stream_h);
+       SM_ARG_CHECK(stream_h);
 
        ret = _set_preferred_device(stream_h, io_direction, device);
 
@@ -293,8 +286,8 @@ int sound_manager_get_stream_preferred_device(sound_stream_info_h stream_info, i
        int ret = MM_ERROR_NONE;
        sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 
-       SM_NULL_ARG_CHECK(stream_h);
-       SM_NULL_ARG_CHECK(in_device_id || out_device_id);
+       SM_ARG_CHECK(stream_h);
+       SM_ARG_CHECK(in_device_id || out_device_id);
 
        ret = _get_preferred_device(stream_h, in_device_id, out_device_id);
 
@@ -306,9 +299,9 @@ int sound_manager_set_focus_reacquisition(sound_stream_info_h stream_info, bool
        int ret = MM_ERROR_NONE;
        sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(stream_h);
 
-       SM_INSTANCE_CHECK(stream_h);
+       LOGI(">> enter");
 
        ret = mm_sound_set_focus_reacquisition(stream_h->focus_id, enable);
 
@@ -322,10 +315,10 @@ int sound_manager_get_focus_reacquisition(sound_stream_info_h stream_info, bool
        int ret = MM_ERROR_NONE;
        sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(stream_h);
+       SM_ARG_CHECK(enabled);
 
-       SM_INSTANCE_CHECK(stream_h);
-       SM_NULL_ARG_CHECK(enabled);
+       LOGI(">> enter");
 
        ret = mm_sound_get_focus_reacquisition(stream_h->focus_id, enabled);
 
@@ -341,9 +334,9 @@ int sound_manager_acquire_focus(sound_stream_info_h stream_info, sound_stream_fo
        bool is_focus_watch_cb_thread = false;
        sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(stream_h);
 
-       SM_INSTANCE_CHECK(stream_h);
+       LOGI(">> enter");
 
        if ((ret = mm_sound_focus_is_cb_thread(&is_focus_cb_thread, &is_focus_watch_cb_thread)))
                return _convert_sound_manager_error_code(__func__, ret);
@@ -411,9 +404,9 @@ int sound_manager_release_focus(sound_stream_info_h stream_info, sound_stream_fo
        bool is_focus_watch_cb_thread = false;
        sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(stream_h);
 
-       SM_INSTANCE_CHECK(stream_h);
+       LOGI(">> enter");
 
        if ((ret = mm_sound_focus_is_cb_thread(&is_focus_cb_thread, &is_focus_watch_cb_thread)))
                return _convert_sound_manager_error_code(__func__, ret);
@@ -472,9 +465,9 @@ int sound_manager_acquire_focus_all(sound_stream_info_h stream_info, int sound_b
        bool is_focus_watch_cb_thread = false;
        sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(stream_h);
 
-       SM_INSTANCE_CHECK(stream_h);
+       LOGI(">> enter");
 
        if ((ret = mm_sound_focus_is_cb_thread(&is_focus_cb_thread, &is_focus_watch_cb_thread)))
                return _convert_sound_manager_error_code(__func__, ret);
@@ -541,9 +534,9 @@ int sound_manager_release_focus_all(sound_stream_info_h stream_info, int sound_b
        bool is_focus_watch_cb_thread = false;
        sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(stream_h);
 
-       SM_INSTANCE_CHECK(stream_h);
+       LOGI(">> enter");
 
        if ((ret = mm_sound_focus_is_cb_thread(&is_focus_cb_thread, &is_focus_watch_cb_thread)))
                return _convert_sound_manager_error_code(__func__, ret);
@@ -597,11 +590,10 @@ int sound_manager_get_focus_state(sound_stream_info_h stream_info, sound_stream_
        int ret = MM_ERROR_NONE;
        sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(stream_h);
+       SM_ARG_CHECK(state_for_playback || state_for_recording);
 
-       SM_INSTANCE_CHECK(stream_h);
-       if (!state_for_playback && !state_for_recording)
-               return SOUND_MANAGER_ERROR_INVALID_PARAMETER;
+       LOGI(">> enter");
 
        SM_ENTER_CRITICAL_SECTION_WITH_RETURN(&stream_h->focus_state_mutex, MM_ERROR_SOUND_INTERNAL);
 
@@ -624,10 +616,10 @@ int sound_manager_deliver_focus(sound_stream_info_h source, sound_stream_info_h
        sound_stream_info_s *dst_stream_h = (sound_stream_info_s*)destination;
        bool is_focus_cb_thread = false;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(src_stream_h);
+       SM_ARG_CHECK(dst_stream_h);
 
-       SM_INSTANCE_CHECK(src_stream_h);
-       SM_INSTANCE_CHECK(dst_stream_h);
+       LOGI(">> enter");
 
        if ((ret = mm_sound_focus_is_cb_thread(&is_focus_cb_thread, NULL)))
                return _convert_sound_manager_error_code(__func__, ret);
@@ -675,11 +667,11 @@ int sound_manager_is_stream_on_device(sound_stream_info_h stream_info, sound_dev
        int ret = MM_ERROR_NONE;
        sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(stream_h);
+       SM_ARG_CHECK(device);
+       SM_ARG_CHECK(is_on);
 
-       SM_NULL_ARG_CHECK(stream_h);
-       SM_NULL_ARG_CHECK(device);
-       SM_NULL_ARG_CHECK(is_on);
+       LOGI(">> enter");
 
        ret = mm_sound_is_stream_on_device(stream_h->pa_info.index, device, is_on);
 
@@ -692,7 +684,7 @@ int sound_manager_get_current_media_playback_device_type(sound_device_type_e *de
 
        LOGI(">> enter");
 
-       SM_NULL_ARG_CHECK(device_type);
+       SM_ARG_CHECK(device_type);
 
        ret = _get_current_media_routing_path("out", device_type);
 
@@ -707,10 +699,10 @@ int sound_manager_get_current_playback_focus(sound_stream_focus_change_reason_e
        int option = 0;
        bool is_focus_cb_thread = false;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(acquired_by);
+       SM_ARG_CHECK(flags);
 
-       SM_NULL_ARG_CHECK(acquired_by);
-       SM_NULL_ARG_CHECK(flags);
+       LOGI(">> enter");
 
        if ((ret = mm_sound_focus_is_cb_thread(&is_focus_cb_thread, NULL)))
                return _convert_sound_manager_error_code(__func__, ret);
@@ -745,10 +737,10 @@ int sound_manager_get_current_recording_focus(sound_stream_focus_change_reason_e
        int option = 0;
        bool is_focus_cb_thread = false;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(acquired_by);
+       SM_ARG_CHECK(flags);
 
-       SM_NULL_ARG_CHECK(acquired_by);
-       SM_NULL_ARG_CHECK(flags);
+       LOGI(">> enter");
 
        if ((ret = mm_sound_focus_is_cb_thread(&is_focus_cb_thread, NULL)))
                return _convert_sound_manager_error_code(__func__, ret);
@@ -782,8 +774,8 @@ int sound_manager_add_focus_state_watch_cb(sound_stream_focus_mask_e focus_mask,
 
        LOGI(">> enter");
 
-       SM_NULL_ARG_CHECK(callback);
-       SM_NULL_ARG_CHECK(id);
+       SM_ARG_CHECK(callback);
+       SM_ARG_CHECK(id);
 
        for (i = 0; i < SOUND_STREAM_INFO_ARR_MAX; i++)
                if (focus_watch_info_arr[i].id == 0)
@@ -918,10 +910,10 @@ int sound_manager_is_device_running(sound_device_h device, bool *is_running)
 {
        int ret = MM_ERROR_NONE;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(device);
+       SM_ARG_CHECK(is_running);
 
-       SM_INSTANCE_CHECK(device);
-       SM_NULL_ARG_CHECK(is_running);
+       LOGI(">> enter");
 
        ret = mm_sound_is_device_running(device, is_running);
 
@@ -943,9 +935,9 @@ int sound_manager_get_supported_sample_formats(sound_device_h device, sound_samp
        int ret = MM_ERROR_NONE;
        int device_id;
 
-       SM_INSTANCE_CHECK(device);
-       SM_NULL_ARG_CHECK(formats);
-       SM_NULL_ARG_CHECK(num_of_elems);
+       SM_ARG_CHECK(device);
+       SM_ARG_CHECK(formats);
+       SM_ARG_CHECK(num_of_elems);
 
        if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
                return ret;
@@ -961,7 +953,7 @@ int sound_manager_set_sample_format(sound_device_h device, sound_sample_format_e
        int ret = MM_ERROR_NONE;
        int device_id;
 
-       SM_INSTANCE_CHECK(device);
+       SM_ARG_CHECK(device);
 
        if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
                return ret;
@@ -977,8 +969,8 @@ int sound_manager_get_sample_format(sound_device_h device, sound_sample_format_e
        int ret = MM_ERROR_NONE;
        int device_id;
 
-       SM_INSTANCE_CHECK(device);
-       SM_NULL_ARG_CHECK(format);
+       SM_ARG_CHECK(device);
+       SM_ARG_CHECK(format);
 
        if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
                return ret;
@@ -994,9 +986,9 @@ int sound_manager_get_supported_sample_rates(sound_device_h device, sound_sample
        int ret = MM_ERROR_NONE;
        int device_id;
 
-       SM_INSTANCE_CHECK(device);
-       SM_NULL_ARG_CHECK(rates);
-       SM_NULL_ARG_CHECK(num_of_elems);
+       SM_ARG_CHECK(device);
+       SM_ARG_CHECK(rates);
+       SM_ARG_CHECK(num_of_elems);
 
        if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
                return ret;
@@ -1012,7 +1004,7 @@ int sound_manager_set_sample_rate(sound_device_h device, sound_sample_rate_e rat
        int ret = MM_ERROR_NONE;
        int device_id;
 
-       SM_INSTANCE_CHECK(device);
+       SM_ARG_CHECK(device);
 
        if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
                return ret;
@@ -1028,8 +1020,8 @@ int sound_manager_get_sample_rate(sound_device_h device, sound_sample_rate_e *ra
        int ret = MM_ERROR_NONE;
        int device_id;
 
-       SM_INSTANCE_CHECK(device);
-       SM_NULL_ARG_CHECK(rate);
+       SM_ARG_CHECK(device);
+       SM_ARG_CHECK(rate);
 
        if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
                return ret;
@@ -1045,7 +1037,7 @@ int sound_manager_set_avoid_resampling(sound_device_h device, bool enable)
        int ret = MM_ERROR_NONE;
        int device_id;
 
-       SM_INSTANCE_CHECK(device);
+       SM_ARG_CHECK(device);
 
        if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
                return ret;
@@ -1061,8 +1053,8 @@ int sound_manager_get_avoid_resampling(sound_device_h device, bool *enabled)
        int ret = MM_ERROR_NONE;
        int device_id;
 
-       SM_INSTANCE_CHECK(device);
-       SM_NULL_ARG_CHECK(enabled);
+       SM_ARG_CHECK(device);
+       SM_ARG_CHECK(enabled);
 
        if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
                return ret;
@@ -1078,7 +1070,7 @@ int sound_manager_set_media_stream_only(sound_device_h device, bool enable)
        int ret = MM_ERROR_NONE;
        int device_id;
 
-       SM_INSTANCE_CHECK(device);
+       SM_ARG_CHECK(device);
 
        if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
                return ret;
@@ -1094,8 +1086,8 @@ int sound_manager_get_media_stream_only(sound_device_h device, bool *enabled)
        int ret = MM_ERROR_NONE;
        int device_id;
 
-       SM_INSTANCE_CHECK(device);
-       SM_NULL_ARG_CHECK(enabled);
+       SM_ARG_CHECK(device);
+       SM_ARG_CHECK(enabled);
 
        if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
                return ret;
@@ -1110,8 +1102,8 @@ int sound_manager_add_device_connection_changed_cb(int device_mask, sound_device
 {
        int ret = MM_ERROR_NONE;
 
-       SM_NULL_ARG_CHECK(callback);
-       SM_NULL_ARG_CHECK(id);
+       SM_ARG_CHECK(callback);
+       SM_ARG_CHECK(id);
 
        ret = mm_sound_add_device_connected_callback((mm_sound_device_flags_e)device_mask, (mm_sound_device_connected_cb)callback, user_data, (unsigned int*)id);
 
@@ -1134,8 +1126,8 @@ int sound_manager_add_device_running_changed_cb(int device_mask, sound_device_ru
 {
        int ret = MM_ERROR_NONE;
 
-       SM_NULL_ARG_CHECK(callback);
-       SM_NULL_ARG_CHECK(id);
+       SM_ARG_CHECK(callback);
+       SM_ARG_CHECK(id);
 
        ret = mm_sound_add_device_running_changed_callback(device_mask, (mm_sound_device_running_changed_cb)callback, user_data, (unsigned int*)id);
 
@@ -1146,8 +1138,7 @@ int sound_manager_remove_device_running_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_running_changed_callback((unsigned int)id);
 
@@ -1159,8 +1150,8 @@ int sound_manager_add_device_state_changed_cb(int device_mask, sound_device_stat
        int ret = MM_ERROR_NONE;
 
        LOGW("DEPRECATION WARNING: %s() is deprecated and will be removed from next release.", __func__);
-       SM_NULL_ARG_CHECK(callback);
-       SM_NULL_ARG_CHECK(id);
+       SM_ARG_CHECK(callback);
+       SM_ARG_CHECK(id);
 
        ret = mm_sound_add_device_state_changed_callback(device_mask, (mm_sound_device_state_changed_cb)callback, user_data, (unsigned int*)id);
 
@@ -1172,8 +1163,7 @@ int sound_manager_remove_device_state_changed_cb(int id)
        int ret = MM_ERROR_NONE;
 
        LOGW("DEPRECATION WARNING: %s() is deprecated and will be removed from next release.", __func__);
-       if (id < 0)
-               return _convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
+       SM_ARG_CHECK(id >= 0);
 
        ret = mm_sound_remove_device_state_changed_callback((unsigned int)id);
 
@@ -1186,7 +1176,7 @@ int sound_manager_create_stream_ducking(sound_stream_type_e target_stream, sound
        int ret = MM_ERROR_NONE;
        sound_stream_ducking_s *new_ducking = NULL;
 
-       SM_NULL_ARG_CHECK(stream_ducking);
+       SM_ARG_CHECK(stream_ducking);
 
        SM_ENTER_CRITICAL_SECTION_WITH_RETURN(&ducking_mutex, SOUND_MANAGER_ERROR_INTERNAL);
 
@@ -1253,9 +1243,9 @@ int sound_manager_destroy_stream_ducking(sound_stream_ducking_h stream_ducking)
        bool is_ducked = false;
        sound_stream_ducking_s *ducking = (sound_stream_ducking_s*)stream_ducking;
 
-       LOGI(">> enter %p", ducking);
+       SM_ARG_CHECK(ducking);
 
-       SM_INSTANCE_CHECK(ducking);
+       LOGI(">> enter %p", ducking);
 
        ret = _get_ducking_state(&ducking->pa_info, &is_ducked);
        if (ret != MM_ERROR_NONE && ret != MM_ERROR_SOUND_SERVER_DISCONNECTED)
@@ -1296,10 +1286,10 @@ int sound_manager_is_ducked(sound_stream_ducking_h stream_ducking, bool *is_duck
        int ret = MM_ERROR_NONE;
        sound_stream_ducking_s *ducking = (sound_stream_ducking_s*)stream_ducking;
 
-       LOGI(">> enter %p", ducking);
+       SM_ARG_CHECK(ducking);
+       SM_ARG_CHECK(is_ducked);
 
-       SM_INSTANCE_CHECK(ducking);
-       SM_NULL_ARG_CHECK(is_ducked);
+       LOGI(">> enter %p", ducking);
 
        ret = _get_ducking_state(&ducking->pa_info, is_ducked);
 
@@ -1312,15 +1302,13 @@ int sound_manager_activate_ducking(sound_stream_ducking_h stream_ducking, unsign
        bool is_ducked = false;
        sound_stream_ducking_s *ducking = (sound_stream_ducking_s*)stream_ducking;
 
-       if (duration > 3000 || ratio >= 1.0 || ratio < 0.0) {
-               LOGE("Invalid params : duration(%u) or ratio(%lf)", duration, ratio);
-               return SOUND_MANAGER_ERROR_INVALID_PARAMETER;
-       }
+       SM_ARG_CHECK(ducking);
+       SM_ARG_CHECK(duration <= 3000);
+       SM_ARG_CHECK(ratio < 1.0);
+       SM_ARG_CHECK(ratio >= 0.0);
 
        LOGI(">> enter %p - duration(%u), ratio(%lf)", ducking, duration, ratio);
 
-       SM_INSTANCE_CHECK(ducking);
-
        ret = _get_ducking_state(&ducking->pa_info, &is_ducked);
        if (ret != MM_ERROR_NONE)
                return _convert_sound_manager_error_code(__func__, ret);
@@ -1351,9 +1339,9 @@ int sound_manager_deactivate_ducking(sound_stream_ducking_h stream_ducking)
        bool is_ducked = false;
        sound_stream_ducking_s *ducking = (sound_stream_ducking_s*)stream_ducking;
 
-       LOGI(">> enter %p", ducking);
+       SM_ARG_CHECK(ducking);
 
-       SM_INSTANCE_CHECK(ducking);
+       LOGI(">> enter %p", ducking);
 
        ret = _get_ducking_state(&ducking->pa_info, &is_ducked);
        if (ret != MM_ERROR_NONE)

diff --git a/src/sound_manager_internal.c b/src/sound_manager_internal.c
index 77be664..9ddc226 100644 (file)
--- a/src/sound_manager_internal.c
+++ b/src/sound_manager_internal.c
@@ -25,9 +25,9 @@ int sound_manager_get_max_master_volume(int *max_level)
        int ret = MM_ERROR_NONE;
        unsigned int volume_level = 0;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(max_level);
 
-       SM_NULL_ARG_CHECK(max_level);
+       LOGI(">> enter");
 
        ret = _get_volume_max_level(DIRECTION_OUT_STR, SOUND_TYPE_MASTER_STR, &volume_level);
        if (ret == MM_ERROR_NONE)
@@ -52,9 +52,9 @@ int sound_manager_get_master_volume(int *level)
        int ret = MM_ERROR_NONE;
        unsigned int volume_level = 0;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(level);
 
-       SM_NULL_ARG_CHECK(level);
+       LOGI(">> enter");
 
        ret = _get_volume_level(DIRECTION_OUT_STR, SOUND_TYPE_MASTER_STR, &volume_level);
        if (ret == MM_ERROR_NONE)
@@ -68,8 +68,7 @@ int sound_manager_set_mute(sound_type_e type, bool mute)
 {
        int ret = MM_ERROR_NONE;
 
-       if (type >= SOUND_TYPE_NUM)
-               return _convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
+       SM_ARG_CHECK(type < SOUND_TYPE_NUM);
 
        ret = mm_sound_set_mute(type, mute);
        LOGI("type=%d, mute=%d", type, mute);
@@ -81,9 +80,8 @@ int sound_manager_get_mute(sound_type_e type, bool *muted)
 {
        int ret = MM_ERROR_NONE;
 
-       if (type >= SOUND_TYPE_NUM)
-               return _convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
-       SM_NULL_ARG_CHECK(muted);
+       SM_ARG_CHECK(type < SOUND_TYPE_NUM);
+       SM_ARG_CHECK(muted);
 
        ret = mm_sound_get_mute(type, muted);
        LOGI("type=%d, mute=%d", type, *muted);
@@ -97,9 +95,8 @@ int sound_manager_get_max_volume_internal(sound_type_internal_e type, int *max)
        unsigned int max_level = 0;
        int ret = MM_ERROR_NONE;
 
-       SM_NULL_ARG_CHECK(max);
-       if (type >= SOUND_TYPE_INTERNAL_NUM)
-               return _convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
+       SM_ARG_CHECK(max);
+       SM_ARG_CHECK(type < SOUND_TYPE_INTERNAL_NUM);
 
        ret = _convert_sound_type_for_internal(type, &volume_type);
        if (ret == MM_ERROR_NONE) {
@@ -115,10 +112,8 @@ int sound_manager_set_volume_internal(sound_type_internal_e type, int level)
 {
        int ret = MM_ERROR_NONE;
 
-       if (type >= SOUND_TYPE_INTERNAL_NUM)
-               return _convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
-       if (level < 0)
-               return _convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
+       SM_ARG_CHECK(type < SOUND_TYPE_INTERNAL_NUM);
+       SM_ARG_CHECK(level >= 0);
 
        ret = mm_sound_volume_set_value_internal(type, level);
        LOGI("type=%d, level=%d", type, level);
@@ -131,10 +126,8 @@ int sound_manager_get_volume_internal(sound_type_internal_e type, int *level)
        int ret = MM_ERROR_NONE;
        unsigned int uvolume;
 
-       if (type >= SOUND_TYPE_INTERNAL_NUM)
-               return _convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
-       if (level == NULL)
-               return _convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
+       SM_ARG_CHECK(type < SOUND_TYPE_INTERNAL_NUM);
+       SM_ARG_CHECK(level);
 
        ret = mm_sound_volume_get_value_internal(type, &uvolume);
        if (ret == MM_ERROR_NONE)
@@ -150,8 +143,7 @@ int sound_manager_get_current_sound_type_internal(sound_type_internal_e *type)
        int ret = MM_ERROR_NONE;
        char *volume_type = NULL;
 
-       if (type == NULL)
-               return _convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
+       SM_ARG_CHECK(type);
 
        /* get the volume type of the current playing stream */
        ret = _get_current_volume_type(DIRECTION_OUT_STR, &volume_type);
@@ -168,8 +160,8 @@ int sound_manager_add_volume_changed_cb_internal(sound_manager_volume_changed_cb
 {
        int ret = MM_ERROR_NONE;
 
-       if (!callback || !id)
-               return _convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
+       SM_ARG_CHECK(callback);
+       SM_ARG_CHECK(id);
 
        ret = mm_sound_add_volume_changed_callback_internal((mm_sound_volume_changed_cb_internal)callback, user_data, (unsigned int*)id);
 
@@ -180,8 +172,7 @@ int sound_manager_remove_volume_changed_cb_internal(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_volume_changed_callback_internal(id);
 
@@ -192,9 +183,9 @@ int sound_manager_create_stream_information_internal(sound_stream_type_internal_
 {
        int ret = MM_ERROR_NONE;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(stream_info);
 
-       SM_NULL_ARG_CHECK(stream_info);
+       LOGI(">> enter");
 
        sound_stream_info_s *stream_h = malloc(sizeof(sound_stream_info_s));
        if (!stream_h) {
@@ -226,10 +217,10 @@ int sound_manager_set_stream_routing_option(sound_stream_info_h stream_info, con
        int ret = MM_ERROR_NONE;
        sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(stream_h);
+       SM_ARG_CHECK(name);
 
-       SM_INSTANCE_CHECK(stream_h);
-       SM_NULL_ARG_CHECK(name);
+       LOGI(">> enter");
 
        ret = _set_route_option(stream_h->pa_info.index, name, value);
 
@@ -243,8 +234,9 @@ int sound_manager_is_available_stream_information(sound_stream_info_h stream_inf
        const char *name = NULL;
        sound_stream_info_s* stream_h = (sound_stream_info_s*)stream_info;
 
-       SM_INSTANCE_CHECK(stream_h);
-       SM_NULL_ARG_CHECK(is_available);
+       SM_ARG_CHECK(stream_h);
+       SM_ARG_CHECK(is_available);
+
        *is_available = false;
 
        name = _convert_api_name(api_name);
@@ -263,8 +255,8 @@ int sound_manager_get_type_from_stream_information(sound_stream_info_h stream_in
 {
        sound_stream_info_s* stream_h = (sound_stream_info_s*)stream_info;
 
-       SM_INSTANCE_CHECK(stream_h);
-       SM_NULL_ARG_CHECK(type);
+       SM_ARG_CHECK(stream_h);
+       SM_ARG_CHECK(type);
 
        *type = stream_h->stream_type;
        LOGI("stream_type[%s]", *type);
@@ -275,8 +267,8 @@ int sound_manager_get_index_from_stream_information(sound_stream_info_h stream_i
 {
        sound_stream_info_s* stream_h = (sound_stream_info_s*)stream_info;
 
-       SM_INSTANCE_CHECK(stream_h);
-       SM_NULL_ARG_CHECK(index);
+       SM_ARG_CHECK(stream_h);
+       SM_ARG_CHECK(index);
 
        *index = stream_h->pa_info.index;
        LOGI("stream_index[%u]", stream_h->pa_info.index);
@@ -313,7 +305,7 @@ int sound_manager_set_stream_preferred_device_id(sound_stream_info_h stream_info
        int ret = MM_ERROR_NONE;
        sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 
-       SM_NULL_ARG_CHECK(stream_h);
+       SM_ARG_CHECK(stream_h);
 
        ret = _set_preferred_device_id(stream_h, io_direction, device_id);
 
@@ -354,10 +346,10 @@ int sound_manager_get_supported_sample_formats_by_id(int device_id, sound_sample
 {
        int ret = MM_ERROR_NONE;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(formats);
+       SM_ARG_CHECK(num_of_elems);
 
-       SM_NULL_ARG_CHECK(formats);
-       SM_NULL_ARG_CHECK(num_of_elems);
+       LOGI(">> enter");
 
        ret = _get_supported_sample_formats(device_id, formats, num_of_elems);
 
@@ -379,9 +371,9 @@ int sound_manager_get_sample_format_by_id(int device_id, sound_sample_format_e *
 {
        int ret = MM_ERROR_NONE;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(format);
 
-       SM_NULL_ARG_CHECK(format);
+       LOGI(">> enter");
 
        ret = _get_sample_format(device_id, format);
 
@@ -392,10 +384,10 @@ int sound_manager_get_supported_sample_rates_by_id(int device_id, sound_sample_r
 {
        int ret = MM_ERROR_NONE;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(rates);
+       SM_ARG_CHECK(num_of_elems);
 
-       SM_NULL_ARG_CHECK(rates);
-       SM_NULL_ARG_CHECK(num_of_elems);
+       LOGI(">> enter");
 
        ret = _get_supported_sample_rates(device_id, rates, num_of_elems);
 
@@ -417,9 +409,9 @@ int sound_manager_get_sample_rate_by_id(int device_id, sound_sample_rate_e *rate
 {
        int ret = MM_ERROR_NONE;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(rate);
 
-       SM_NULL_ARG_CHECK(rate);
+       LOGI(">> enter");
 
        ret = _get_sample_rate(device_id, rate);
 
@@ -443,7 +435,7 @@ int sound_manager_get_avoid_resampling_by_id(int device_id, bool *enabled)
 
        LOGI(">> enter");
 
-       SM_NULL_ARG_CHECK(enabled);
+       SM_ARG_CHECK(enabled);
 
        ret = _get_avoid_resampling(device_id, enabled);
 
@@ -465,9 +457,9 @@ int sound_manager_get_media_stream_only_by_id(int device_id, bool *enabled)
 {
        int ret = MM_ERROR_NONE;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(enabled);
 
-       SM_NULL_ARG_CHECK(enabled);
+       LOGI(">> enter");
 
        ret = _get_media_stream_only(device_id, enabled);
 
@@ -480,9 +472,9 @@ int sound_manager_create_virtual_stream(sound_stream_info_h stream_info, virtual
        virtual_sound_stream_info_s *vstream_h = NULL;
        sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(stream_h);
 
-       SM_INSTANCE_CHECK(stream_h);
+       LOGI(">> enter");
 
        SM_ENTER_CRITICAL_SECTION_WITH_RETURN(&stream_h->vstream_mutex, SOUND_MANAGER_ERROR_INTERNAL);
 
@@ -507,10 +499,10 @@ int sound_manager_destroy_virtual_stream(virtual_sound_stream_h virtual_stream)
        pthread_mutex_t *vstream_mutex;
        virtual_sound_stream_info_s *vstream_h = (virtual_sound_stream_info_s*)virtual_stream;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(vstream_h);
+       SM_ARG_CHECK(vstream_h->stream_info);
 
-       SM_INSTANCE_CHECK(vstream_h);
-       SM_INSTANCE_CHECK(vstream_h->stream_info);
+       LOGI(">> enter");
 
        vstream_mutex = &vstream_h->stream_info->vstream_mutex;
 
@@ -530,10 +522,10 @@ int sound_manager_start_virtual_stream(virtual_sound_stream_h virtual_stream)
        pthread_mutex_t *vstream_mutex;
        virtual_sound_stream_info_s *vstream_h = (virtual_sound_stream_info_s*)virtual_stream;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(vstream_h);
+       SM_ARG_CHECK(vstream_h->stream_info);
 
-       SM_INSTANCE_CHECK(vstream_h);
-       SM_INSTANCE_CHECK(vstream_h->stream_info);
+       LOGI(">> enter");
 
        vstream_mutex = &vstream_h->stream_info->vstream_mutex;
 
@@ -552,10 +544,10 @@ int sound_manager_stop_virtual_stream(virtual_sound_stream_h virtual_stream)
        pthread_mutex_t *vstream_mutex;
        virtual_sound_stream_info_s *vstream_h = (virtual_sound_stream_info_s*)virtual_stream;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(vstream_h);
+       SM_ARG_CHECK(vstream_h->stream_info);
 
-       SM_INSTANCE_CHECK(vstream_h);
-       SM_INSTANCE_CHECK(vstream_h->stream_info);
+       LOGI(">> enter");
 
        vstream_mutex = &vstream_h->stream_info->vstream_mutex;
 
@@ -574,10 +566,10 @@ int sound_manager_set_virtual_stream_volume(virtual_sound_stream_h virtual_strea
        pthread_mutex_t *vstream_mutex;
        virtual_sound_stream_info_s *vstream_h = (virtual_sound_stream_info_s*)virtual_stream;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(vstream_h);
+       SM_ARG_CHECK(vstream_h->stream_info);
 
-       SM_INSTANCE_CHECK(vstream_h);
-       SM_INSTANCE_CHECK(vstream_h->stream_info);
+       LOGI(">> enter");
 
        vstream_mutex = &vstream_h->stream_info->vstream_mutex;
 
@@ -801,10 +793,10 @@ int sound_manager_get_device_vendor_id(sound_device_h device, int *vendor_id)
        int ret = MM_ERROR_NONE;
        mm_sound_device_type_e type;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(device);
+       SM_ARG_CHECK(vendor_id);
 
-       SM_INSTANCE_CHECK(device);
-       SM_NULL_ARG_CHECK(vendor_id);
+       LOGI(">> enter");
 
        if ((ret = mm_sound_get_device_type(device, &type)))
                return _convert_sound_manager_error_code(__func__, ret);
@@ -824,10 +816,10 @@ int sound_manager_get_device_product_id(sound_device_h device, int *product_id)
        int ret = MM_ERROR_NONE;
        mm_sound_device_type_e type;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(device);
+       SM_ARG_CHECK(product_id);
 
-       SM_INSTANCE_CHECK(device);
-       SM_NULL_ARG_CHECK(product_id);
+       LOGI(">> enter");
 
        if ((ret = mm_sound_get_device_type(device, &type)))
                return _convert_sound_manager_error_code(__func__, ret);
@@ -847,10 +839,10 @@ int sound_manager_is_stream_on_device_by_id(sound_stream_info_h stream_info, int
        int ret = MM_ERROR_NONE;
        sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 
-       LOGI(">> enter");
+       SM_ARG_CHECK(stream_h);
+       SM_ARG_CHECK(is_on);
 
-       SM_NULL_ARG_CHECK(stream_h);
-       SM_NULL_ARG_CHECK(is_on);
+       LOGI(">> enter");
 
        ret = mm_sound_is_stream_on_device_by_id(stream_h->pa_info.index, device_id, is_on);
 
@@ -872,10 +864,10 @@ int sound_manager_get_latest_stream_pid(int stream_type, unsigned int *pid)
 {
        int ret = MM_ERROR_NONE;
 
-       LOGI(">> enter, stream_type(0x%x)", stream_type);
+       SM_ARG_CHECK(pid);
+       SM_ARG_CHECK(stream_type);
 
-       SM_NULL_ARG_CHECK(pid);
-       SM_NULL_ARG_CHECK(stream_type);
+       LOGI(">> enter, stream_type(0x%x)", stream_type);
 
        ret = _get_latest_stream_pid(stream_type, pid);
 
@@ -895,7 +887,7 @@ int sound_manager_get_stream_preemptive_device(sound_stream_type_e stream_type,
 {
        int ret = MM_ERROR_NONE;
 
-       SM_NULL_ARG_CHECK(in_device_id || out_device_id);
+       SM_ARG_CHECK(in_device_id || out_device_id);
 
        ret = _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 0e0458d..8b3d795 100644 (file)
--- a/src/sound_manager_private.c
+++ b/src/sound_manager_private.c
@@ -617,7 +617,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(sound_io_direction);
+       SM_NULL_ARG_CHECK_FOR_PRIV(sound_io_direction);
 
        switch (io_direction) {
        case MM_SOUND_DEVICE_IO_DIRECTION_IN: