Remove useless converting error logic inside of volume APIs

[Version] 0.6.11
[Issue Type] Refactoring

Change-Id: I57aa5dac85c57532a313a8a1271c9b2eaf14a633
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 55fb6e867385df63adc373b2e029c5af1b0bc251..8d5f8aaed4e2179185baf2971c3799a49ac893a0 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.10
+Version:    0.6.11
 Release:    0
 Group:      Multimedia/API
 License:    Apache-2.0

diff --git a/src/sound_manager.c b/src/sound_manager.c
index 4856a7682cc7afa3db1dbc96e2158ac70e559d74..b05e721af427db7270351b3f390ab65fb57e4038 100644 (file)
--- a/src/sound_manager.c
+++ b/src/sound_manager.c
@@ -55,19 +55,19 @@ int sound_manager_get_max_volume(sound_type_e type, int *max)
 {
        const char *volume_type = NULL;
        unsigned int max_level = 0;
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
 
        SM_ARG_CHECK(max);
        SM_ARG_CHECK(type < SOUND_TYPE_NUM);
 
        ret = _convert_sound_type(type, &volume_type);
-       if (ret == MM_ERROR_NONE) {
+       if (ret == SOUND_MANAGER_ERROR_NONE) {
                ret = _get_volume_max_level(DIRECTION_OUT_STR, volume_type, &max_level);
-               if (ret == MM_ERROR_NONE)
+               if (ret == SOUND_MANAGER_ERROR_NONE)
                        *max = (int)max_level -1;       /* actual volume step can be max step - 1 */
        }
 
-       return _convert_sound_manager_error_code(__func__, ret);
+       return ret;
 }
 
 int sound_manager_set_volume(sound_type_e type, int volume)
@@ -102,20 +102,20 @@ int sound_manager_get_volume(sound_type_e type, int *volume)
 
 int sound_manager_get_current_sound_type(sound_type_e *type)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        char *volume_type = NULL;
 
        SM_ARG_CHECK(type);
 
        /* get the volume type of the current playing stream */
        ret = _get_current_volume_type(DIRECTION_OUT_STR, &volume_type);
-       if (ret == MM_ERROR_NONE) {
+       if (ret == SOUND_MANAGER_ERROR_NONE) {
                ret = _convert_sound_type_to_enum((const char*)volume_type, type);
-               if (ret == MM_ERROR_NONE)
+               if (ret == SOUND_MANAGER_ERROR_NONE)
                        LOGI("type=%d", *type);
        }
 
-       return _convert_sound_manager_error_code(__func__, ret);
+       return ret;
 }
 
 int sound_manager_add_volume_changed_cb(sound_manager_volume_changed_cb callback, void *user_data, int *id)
@@ -201,7 +201,7 @@ int sound_manager_destroy_stream_information(sound_stream_info_h stream_info)
 
 int sound_manager_get_sound_type(sound_stream_info_h stream_info, sound_type_e *sound_type)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 
        SM_ARG_CHECK(stream_h);
@@ -210,7 +210,8 @@ int sound_manager_get_sound_type(sound_stream_info_h stream_info, sound_type_e *
        LOGI(">> enter");
 
        if (stream_h->stream_conf_info.volume_type == NULL) {
-               ret = MM_ERROR_SOUND_NO_DATA;
+               ret = SOUND_MANAGER_ERROR_NO_DATA;
+               LOGW("There's no sound type for this stream_info(%p)", stream_info);
                goto LEAVE;
        }
 
@@ -218,7 +219,7 @@ int sound_manager_get_sound_type(sound_stream_info_h stream_info, sound_type_e *
        LOGI("sound type(%d)", *sound_type);
 
 LEAVE:
-       return _convert_sound_manager_error_code(__func__, ret);
+       return ret;
 }
 
 int sound_manager_add_device_for_stream_routing(sound_stream_info_h stream_info, sound_device_h device)

diff --git a/src/sound_manager_internal.c b/src/sound_manager_internal.c
index 9ddc2268ccc2b5320f14cf622173cbb618c9c6c7..385a89651ace5360dee7d7b2271f61923aaca86c 100644 (file)
--- a/src/sound_manager_internal.c
+++ b/src/sound_manager_internal.c
@@ -22,7 +22,7 @@
 #ifndef TIZEN_FEATURE_TV_PROD
 int sound_manager_get_max_master_volume(int *max_level)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        unsigned int volume_level = 0;
 
        SM_ARG_CHECK(max_level);
@@ -30,26 +30,26 @@ int sound_manager_get_max_master_volume(int *max_level)
        LOGI(">> enter");
 
        ret = _get_volume_max_level(DIRECTION_OUT_STR, SOUND_TYPE_MASTER_STR, &volume_level);
-       if (ret == MM_ERROR_NONE)
+       if (ret == SOUND_MANAGER_ERROR_NONE)
                *max_level = (int)volume_level;
 
-       return _convert_sound_manager_error_code(__func__, ret);
+       return ret;
 }
 
 int sound_manager_set_master_volume(int level)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
 
        LOGI(">> enter");
 
        ret = _set_volume_level(DIRECTION_OUT_STR, SOUND_TYPE_MASTER_STR, (unsigned int)level);
 
-       return _convert_sound_manager_error_code(__func__, ret);
+       return ret;
 }
 
 int sound_manager_get_master_volume(int *level)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        unsigned int volume_level = 0;
 
        SM_ARG_CHECK(level);
@@ -57,10 +57,10 @@ int sound_manager_get_master_volume(int *level)
        LOGI(">> enter");
 
        ret = _get_volume_level(DIRECTION_OUT_STR, SOUND_TYPE_MASTER_STR, &volume_level);
-       if (ret == MM_ERROR_NONE)
+       if (ret == SOUND_MANAGER_ERROR_NONE)
                *level = (int)volume_level;
 
-       return _convert_sound_manager_error_code(__func__, ret);
+       return ret;
 }
 #endif
 
@@ -93,19 +93,19 @@ int sound_manager_get_max_volume_internal(sound_type_internal_e type, int *max)
 {
        const char *volume_type = NULL;
        unsigned int max_level = 0;
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
 
        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) {
+       if (ret == SOUND_MANAGER_ERROR_NONE) {
                ret = _get_volume_max_level(DIRECTION_OUT_STR, volume_type, &max_level);
-               if (ret == MM_ERROR_NONE)
+               if (ret == SOUND_MANAGER_ERROR_NONE)
                        *max = (int)max_level -1;       /* actual volume step can be max step - 1 */
        }
 
-       return _convert_sound_manager_error_code(__func__, ret);
+       return ret;
 }
 
 int sound_manager_set_volume_internal(sound_type_internal_e type, int level)
@@ -140,20 +140,20 @@ int sound_manager_get_volume_internal(sound_type_internal_e type, int *level)
 
 int sound_manager_get_current_sound_type_internal(sound_type_internal_e *type)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        char *volume_type = NULL;
 
        SM_ARG_CHECK(type);
 
        /* get the volume type of the current playing stream */
        ret = _get_current_volume_type(DIRECTION_OUT_STR, &volume_type);
-       if (ret == MM_ERROR_NONE) {
+       if (ret == SOUND_MANAGER_ERROR_NONE) {
                ret = _convert_sound_type_to_enum_for_internal((const char*)volume_type, type);
-               if (ret == MM_ERROR_NONE)
+               if (ret == SOUND_MANAGER_ERROR_NONE)
                        LOGI("type=%d", *type);
        }
 
-       return _convert_sound_manager_error_code(__func__, ret);
+       return ret;
 }
 
 int sound_manager_add_volume_changed_cb_internal(sound_manager_volume_changed_cb_internal callback, void *user_data, int *id)

diff --git a/src/sound_manager_private.c b/src/sound_manager_private.c
index 8b3d795027154233503582f0f48a51ad7382bd4b..571b324f3408a8fec4e39208f6eb03613b355ae6 100644 (file)
--- a/src/sound_manager_private.c
+++ b/src/sound_manager_private.c
@@ -391,7 +391,7 @@ static int __get_dbus_connection(GDBusConnection **conn)
 
 int _convert_sound_type(sound_type_e sound_type, const char **volume_type)
 {
-       SM_NULL_ARG_CHECK_FOR_PRIV(volume_type);
+       SM_ARG_CHECK(volume_type);
 
        switch (sound_type) {
        case SOUND_TYPE_SYSTEM:
@@ -421,13 +421,13 @@ int _convert_sound_type(sound_type_e sound_type, const char **volume_type)
        }
        LOGI("volume_type[%s]", *volume_type);
 
-       return MM_ERROR_NONE;
+       return SOUND_MANAGER_ERROR_NONE;
 }
 
 //LCOV_EXCL_START
 int _convert_sound_type_for_internal(sound_type_internal_e sound_type, const char **volume_type)
 {
-       SM_NULL_ARG_CHECK_FOR_PRIV(volume_type);
+       SM_ARG_CHECK(volume_type);
 
        switch (sound_type) {
        case SOUND_TYPE_BIXBY:
@@ -436,14 +436,14 @@ int _convert_sound_type_for_internal(sound_type_internal_e sound_type, const cha
        }
        LOGI("volume_type[%s]", *volume_type);
 
-       return MM_ERROR_NONE;
+       return SOUND_MANAGER_ERROR_NONE;
 }
 //LCOV_EXCL_STOP
 
 int _convert_sound_type_to_enum(const char *sound_type, sound_type_e *sound_type_enum)
 {
-       SM_NULL_ARG_CHECK_FOR_PRIV(sound_type);
-       SM_NULL_ARG_CHECK_FOR_PRIV(sound_type_enum);
+       SM_ARG_CHECK(sound_type);
+       SM_ARG_CHECK(sound_type_enum);
 
        if (!strncmp(sound_type, "system", strlen(sound_type))) {
                *sound_type_enum = SOUND_TYPE_SYSTEM;//LCOV_EXCL_LINE
@@ -463,29 +463,29 @@ int _convert_sound_type_to_enum(const char *sound_type, sound_type_e *sound_type
                *sound_type_enum = SOUND_TYPE_VOICE;
        } else {
                //LCOV_EXCL_START
-               SM_INTERNAL_SOUND_TYPE_CHECK(sound_type, MM_ERROR_SOUND_VOLUME_NO_INSTANCE);
+               SM_INTERNAL_SOUND_TYPE_CHECK(sound_type, SOUND_MANAGER_ERROR_NO_PLAYING_SOUND);
                LOGE("not supported sound_type(%s)", sound_type);
-               return MM_ERROR_INVALID_ARGUMENT;
+               return SOUND_MANAGER_ERROR_INVALID_PARAMETER;
                //LCOV_EXCL_STOP
        }
 
-       return MM_ERROR_NONE;
+       return SOUND_MANAGER_ERROR_NONE;
 }
 //LCOV_EXCL_START
 int _convert_sound_type_to_enum_for_internal(const char *sound_type, sound_type_internal_e *sound_type_enum)
 {
-       SM_NULL_ARG_CHECK_FOR_PRIV(sound_type);
-       SM_NULL_ARG_CHECK_FOR_PRIV(sound_type_enum);
+       SM_ARG_CHECK(sound_type);
+       SM_ARG_CHECK(sound_type_enum);
 
        if (!strncmp(sound_type, "bixby", strlen(sound_type))) {
                *sound_type_enum = SOUND_TYPE_BIXBY;
        } else {
-               SM_SOUND_TYPE_CHECK(sound_type, MM_ERROR_SOUND_VOLUME_NO_INSTANCE);
+               SM_SOUND_TYPE_CHECK(sound_type, SOUND_MANAGER_ERROR_NO_PLAYING_SOUND);
                LOGE("not supported internal sound_type(%s)", sound_type);
-               return MM_ERROR_INVALID_ARGUMENT;
+               return SOUND_MANAGER_ERROR_INVALID_PARAMETER;
        }
 
-       return MM_ERROR_NONE;
+       return SOUND_MANAGER_ERROR_NONE;
 }
 
 int _convert_device_type_enum_to_str(sound_device_type_e device_type, char **device_type_str)
@@ -1213,7 +1213,7 @@ LEAVE:
 
 int _get_volume_max_level(const char *direction, const char *volume_type, unsigned int *max_level)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        GVariant *result = NULL;
        GDBusConnection *conn = NULL;
        GError *err = NULL;
@@ -1224,7 +1224,7 @@ int _get_volume_max_level(const char *direction, const char *volume_type, unsign
        assert(max_level);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return ret;
+               return SOUND_MANAGER_ERROR_INTERNAL;
 
        result = g_dbus_connection_call_sync(conn,
                                                        PA_BUS_NAME,
@@ -1242,7 +1242,7 @@ int _get_volume_max_level(const char *direction, const char *volume_type, unsign
                LOGE("g_dbus_connection_call_sync() for GET_VOLUME_MAX_LEVEL 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
        }
@@ -1250,7 +1250,7 @@ int _get_volume_max_level(const char *direction, const char *volume_type, unsign
        g_variant_get(result, "(u&s)", max_level, &dbus_ret);
        LOGI("g_dbus_connection_call_sync() success, method return value is (%u, %s)", *max_level, dbus_ret);
        if (strncmp("STREAM_MANAGER_RETURN_OK", dbus_ret, strlen(dbus_ret)))
-               ret = MM_ERROR_SOUND_INTERNAL;//LCOV_EXCL_LINE
+               ret = SOUND_MANAGER_ERROR_INTERNAL;//LCOV_EXCL_LINE
 
 LEAVE:
        g_variant_unref(result);
@@ -1262,7 +1262,7 @@ LEAVE:
 //LCOV_EXCL_START
 int _get_volume_level(const char *direction, const char *volume_type, unsigned int *level)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        GVariant *result = NULL;
        GDBusConnection *conn = NULL;
        GError *err = NULL;
@@ -1273,7 +1273,7 @@ int _get_volume_level(const char *direction, const char *volume_type, unsigned i
        assert(level);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return ret;
+               return SOUND_MANAGER_ERROR_INTERNAL;
 
        result = g_dbus_connection_call_sync(conn,
                                                        PA_BUS_NAME,
@@ -1290,14 +1290,14 @@ int _get_volume_level(const char *direction, const char *volume_type, unsigned i
                LOGE("g_dbus_connection_call_sync() for GET_VOLUME_LEVEL error (%s)", err ? err->message : NULL);
                if (err)
                        g_error_free(err);
-               ret = MM_ERROR_SOUND_INTERNAL;
+               ret = SOUND_MANAGER_ERROR_INTERNAL;
                goto LEAVE;
        }
 
        g_variant_get(result, "(u&s)", level, &dbus_ret);
        LOGI("g_dbus_connection_call_sync() success, method return value is (%u, %s)", *level, dbus_ret);
        if (strncmp("STREAM_MANAGER_RETURN_OK", dbus_ret, strlen(dbus_ret)))
-               ret = MM_ERROR_SOUND_INTERNAL;
+               ret = SOUND_MANAGER_ERROR_INTERNAL;
 
 LEAVE:
        g_variant_unref(result);
@@ -1308,7 +1308,7 @@ LEAVE:
 
 int _set_volume_level(const char *direction, const char *volume_type, unsigned int level)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        GVariant *result = NULL;
        GDBusConnection *conn = NULL;
        GError *err = NULL;
@@ -1337,14 +1337,14 @@ int _set_volume_level(const char *direction, const char *volume_type, unsigned i
                LOGE("g_dbus_connection_call_sync() for SET_VOLUME_LEVEL error (%s)", err ? err->message : NULL);
                if (err)
                        g_error_free(err);
-               ret = MM_ERROR_SOUND_INTERNAL;
+               ret = SOUND_MANAGER_ERROR_INTERNAL;
                goto LEAVE;
        }
 
        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_OK", dbus_ret, strlen(dbus_ret)))
-               ret = MM_ERROR_SOUND_INTERNAL;
+               ret = SOUND_MANAGER_ERROR_INTERNAL;
        else {
                /* Set volume value to VCONF */
                snprintf(volume_path, sizeof(volume_path)-1, "%s%s", VCONF_PATH_PREFIX_VOLUME, volume_type);
@@ -1362,7 +1362,7 @@ LEAVE:
 
 int _get_current_volume_type(const char *direction, char **volume_type)
 {
-       int ret = MM_ERROR_NONE;
+       int ret = SOUND_MANAGER_ERROR_NONE;
        GVariant *result = NULL;
        GDBusConnection *conn = NULL;
        GError *err = NULL;
@@ -1373,7 +1373,7 @@ int _get_current_volume_type(const char *direction, char **volume_type)
        assert(volume_type);
 
        if ((ret = __get_dbus_connection(&conn)))
-               return ret;
+               return SOUND_MANAGER_ERROR_INTERNAL;
 
        result = g_dbus_connection_call_sync(conn,
                                                        PA_BUS_NAME,
@@ -1391,7 +1391,7 @@ int _get_current_volume_type(const char *direction, char **volume_type)
                LOGE("g_dbus_connection_call_sync() for GET_CURRENT_VOLUME_TYPE 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
        }
@@ -1399,12 +1399,12 @@ int _get_current_volume_type(const char *direction, char **volume_type)
        g_variant_get(result, "(&s&s)", &dbus_volume_type, &dbus_ret);
        LOGI("g_dbus_connection_call_sync() success, method return value is (%s, %s)", dbus_volume_type, dbus_ret);
        if (!strncmp("STREAM_MANAGER_RETURN_OK", dbus_ret, strlen(dbus_ret))) {
-               ret = MM_ERROR_NONE;//LCOV_EXCL_LINE
+               ret = SOUND_MANAGER_ERROR_NONE;//LCOV_EXCL_LINE
                *volume_type = strdup(dbus_volume_type);//LCOV_EXCL_LINE
        } else if (!strncmp("STREAM_MANAGER_RETURN_ERROR_NO_STREAM", dbus_ret, strlen(dbus_ret))) {
-               ret = MM_ERROR_SOUND_VOLUME_NO_INSTANCE;
+               ret = SOUND_MANAGER_ERROR_NO_PLAYING_SOUND;
        } else {
-               ret = MM_ERROR_SOUND_INTERNAL;//LCOV_EXCL_LINE
+               ret = SOUND_MANAGER_ERROR_INTERNAL;//LCOV_EXCL_LINE
        }
 
 LEAVE: