From 0820e40e1b47f538b69603be044b92cba40f1cfe Mon Sep 17 00:00:00 2001 From: Sangchul Lee Date: Fri, 26 Jun 2020 15:49:16 +0900 Subject: [PATCH] Remove useless converting error logic in ducking and virtual stream APIs [Version] 0.6.18 [Issue Type] Refactoring Change-Id: I2acfe52ab2cdb5d38fd056d5d1c30c48337a6d8b Signed-off-by: Sangchul Lee --- include/sound_manager_private.h | 6 -- packaging/capi-media-sound-manager.spec | 2 +- src/sound_manager.c | 86 +++++++++--------- src/sound_manager_internal.c | 24 ++--- src/sound_manager_private.c | 115 +++++++++++------------- 5 files changed, 108 insertions(+), 125 deletions(-) diff --git a/include/sound_manager_private.h b/include/sound_manager_private.h index e2cc289..b4ce72f 100644 --- a/include/sound_manager_private.h +++ b/include/sound_manager_private.h @@ -59,15 +59,9 @@ _CHECK_CONDITION(handle->state == expected_state, SOUND_MANAGER_ERROR_INVALID_ST _CHECK_CONDITION(arg <= max, SOUND_MANAGER_ERROR_INVALID_PARAMETER, "SOUND_MANAGER_ERROR_INVALID_PARAMETER") \ _CHECK_CONDITION(arg >= min, SOUND_MANAGER_ERROR_INVALID_PARAMETER, "SOUND_MANAGER_ERROR_INVALID_PARAMETER") -#define SM_INSTANCE_CHECK_FOR_PRIV(handle) \ -_CHECK_CONDITION(handle != NULL, MM_ERROR_INVALID_ARGUMENT, "MM_ERROR_INVALID_ARGUMENT") - #define SM_NULL_ARG_CHECK_FOR_PRIV(arg) \ _CHECK_CONDITION(!!(arg) != false, MM_ERROR_INVALID_ARGUMENT, "MM_ERROR_INVALID_ARGUMENT") -#define SM_STATE_CHECK_FOR_PRIV(handle, expected_state) \ -_CHECK_CONDITION(handle->state == expected_state, MM_ERROR_SOUND_INVALID_STATE, "MM_ERROR_SOUND_INVALID_STATE") - #define SM_ENTER_CRITICAL_SECTION_WITH_UNLOCK_AND_RETURN(x_mutex, x_mutex_to_unlock, x_return) \ switch (pthread_mutex_lock(x_mutex)) { \ case EINVAL: \ diff --git a/packaging/capi-media-sound-manager.spec b/packaging/capi-media-sound-manager.spec index e3045bc..0511845 100644 --- 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.17 +Version: 0.6.18 Release: 0 Group: Multimedia/API License: Apache-2.0 diff --git a/src/sound_manager.c b/src/sound_manager.c index 52f9180..1e9aac1 100644 --- a/src/sound_manager.c +++ b/src/sound_manager.c @@ -792,7 +792,7 @@ int sound_manager_remove_focus_state_watch_cb(int id) if (focus_watch_info_arr[i].id == id) break; if (i == SOUND_STREAM_INFO_ARR_MAX) { - LOGE("cound not find item in focus watch info array for this id(%d)", id); + LOGE("could not find item in focus watch info array for this id(%d)", id); ret = MM_ERROR_INVALID_ARGUMENT; goto LEAVE; } @@ -1185,7 +1185,8 @@ int sound_manager_remove_device_state_changed_cb(int id) int sound_manager_create_stream_ducking(sound_stream_type_e target_stream, sound_stream_ducking_state_changed_cb callback, void *user_data, sound_stream_ducking_h *stream_ducking) { int i = 0; - int ret = MM_ERROR_NONE; + int ret = SOUND_MANAGER_ERROR_NONE; + int mm_ret = MM_ERROR_NONE; sound_stream_ducking_s *new_ducking = NULL; SM_ARG_CHECK(stream_ducking); @@ -1198,45 +1199,48 @@ int sound_manager_create_stream_ducking(sound_stream_type_e target_stream, sound if (i == SOUND_DUCKING_ARR_MAX) { LOGE("ducking array is full"); - ret = MM_ERROR_SOUND_INTERNAL; + ret = SOUND_MANAGER_ERROR_INTERNAL; goto LEAVE; } new_ducking = (sound_stream_ducking_s *)calloc(1, sizeof(sound_stream_ducking_s)); if (!new_ducking) { - ret = MM_ERROR_OUT_OF_MEMORY; + ret = SOUND_MANAGER_ERROR_INTERNAL; goto LEAVE; } ret = _convert_stream_type(target_stream, &new_ducking->target_stream); - if (ret != MM_ERROR_NONE) + if (ret != SOUND_MANAGER_ERROR_NONE) goto LEAVE; ret = _make_pa_connection(&new_ducking->pa_info, "SOUND_MANAGER_STREAM_DUCKING"); + if (ret != SOUND_MANAGER_ERROR_NONE) + goto LEAVE; -LEAVE: - if (ret == MM_ERROR_NONE) { - if (++ducking_arr_count == 1) { - /* subscribe ducking finished signal */ - ret = mm_sound_add_ducking_state_changed_callback((mm_sound_ducking_state_changed_cb)_ducking_state_changed_cb, - NULL, &ducking_cb_subs_id); - if (ret != MM_ERROR_NONE) { - ducking_arr_count = 0; - goto LEAVE; - } - - LOGI("ducking state changed cb subs id %d", ducking_cb_subs_id); + if (++ducking_arr_count == 1) { + /* subscribe ducking finished signal */ + mm_ret = mm_sound_add_ducking_state_changed_callback((mm_sound_ducking_state_changed_cb)_ducking_state_changed_cb, + NULL, &ducking_cb_subs_id); + if (mm_ret != MM_ERROR_NONE) { + ducking_arr_count = 0; + ret = _convert_sound_manager_error_code(__func__, mm_ret); + goto LEAVE; } - new_ducking->user_cb = callback; - new_ducking->user_data = user_data; + LOGI("ducking state changed cb subs id %d", ducking_cb_subs_id); + } + + new_ducking->user_cb = callback; + new_ducking->user_data = user_data; - ducking_arr[i] = new_ducking; - *stream_ducking = (sound_stream_ducking_h)new_ducking; + ducking_arr[i] = new_ducking; + *stream_ducking = (sound_stream_ducking_h)new_ducking; - LOGI("new stream_ducking(%p), target_stream(%s), pa_index(%u), user_cb(%p)", - new_ducking, new_ducking->target_stream, new_ducking->pa_info.index, new_ducking->user_cb); - } else { + LOGI("new stream_ducking(%p), target_stream(%s), pa_index(%u), user_cb(%p)", + new_ducking, new_ducking->target_stream, new_ducking->pa_info.index, new_ducking->user_cb); + +LEAVE: + if (ret != SOUND_MANAGER_ERROR_NONE) { if (new_ducking) { _destroy_pa_connection(&new_ducking->pa_info); free(new_ducking); @@ -1245,13 +1249,13 @@ LEAVE: SM_LEAVE_CRITICAL_SECTION(&ducking_mutex); - return _convert_sound_manager_error_code(__func__, ret); + return ret; } int sound_manager_destroy_stream_ducking(sound_stream_ducking_h stream_ducking) { int i = 0; - int ret = MM_ERROR_NONE; + int ret = SOUND_MANAGER_ERROR_NONE; bool is_ducked = false; sound_stream_ducking_s *ducking = (sound_stream_ducking_s*)stream_ducking; @@ -1260,8 +1264,8 @@ int sound_manager_destroy_stream_ducking(sound_stream_ducking_h stream_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) - return _convert_sound_manager_error_code(__func__, ret); + if (ret != SOUND_MANAGER_ERROR_NONE && !ducking->pa_info.is_disconnected) + return ret; if (is_ducked) { LOGE("ducked now, it should be deactivated first."); @@ -1290,12 +1294,11 @@ int sound_manager_destroy_stream_ducking(sound_stream_ducking_h stream_ducking) SM_LEAVE_CRITICAL_SECTION(&ducking_mutex); - return _convert_sound_manager_error_code(__func__, MM_ERROR_NONE); + return SOUND_MANAGER_ERROR_NONE; } int sound_manager_is_ducked(sound_stream_ducking_h stream_ducking, bool *is_ducked) { - int ret = MM_ERROR_NONE; sound_stream_ducking_s *ducking = (sound_stream_ducking_s*)stream_ducking; SM_ARG_CHECK(ducking); @@ -1303,14 +1306,12 @@ int sound_manager_is_ducked(sound_stream_ducking_h stream_ducking, bool *is_duck LOGI(">> enter %p", ducking); - ret = _get_ducking_state(&ducking->pa_info, is_ducked); - - return _convert_sound_manager_error_code(__func__, ret); + return _get_ducking_state(&ducking->pa_info, is_ducked); } int sound_manager_activate_ducking(sound_stream_ducking_h stream_ducking, unsigned int duration, double ratio) { - int ret = MM_ERROR_NONE; + int ret = SOUND_MANAGER_ERROR_NONE; bool is_ducked = false; sound_stream_ducking_s *ducking = (sound_stream_ducking_s*)stream_ducking; @@ -1322,8 +1323,8 @@ int sound_manager_activate_ducking(sound_stream_ducking_h stream_ducking, unsign LOGI(">> enter %p - duration(%u), ratio(%lf)", ducking, duration, ratio); ret = _get_ducking_state(&ducking->pa_info, &is_ducked); - if (ret != MM_ERROR_NONE) - return _convert_sound_manager_error_code(__func__, ret); + if (ret != SOUND_MANAGER_ERROR_NONE) + return ret; if (is_ducked) { LOGE("already ducked"); @@ -1334,20 +1335,19 @@ int sound_manager_activate_ducking(sound_stream_ducking_h stream_ducking, unsign ret = _activate_ducking(ducking->pa_info.index, true, ducking->target_stream, (uint32_t)duration, ratio); - - if (ret == MM_ERROR_NONE) { + if (ret == SOUND_MANAGER_ERROR_NONE) { ducking->duration = duration; ducking->ratio = ratio; } SM_LEAVE_CRITICAL_SECTION(&ducking_mutex); - return _convert_sound_manager_error_code(__func__, ret); + return ret; } int sound_manager_deactivate_ducking(sound_stream_ducking_h stream_ducking) { - int ret = MM_ERROR_NONE; + int ret = SOUND_MANAGER_ERROR_NONE; bool is_ducked = false; sound_stream_ducking_s *ducking = (sound_stream_ducking_s*)stream_ducking; @@ -1356,8 +1356,8 @@ int sound_manager_deactivate_ducking(sound_stream_ducking_h stream_ducking) LOGI(">> enter %p", ducking); ret = _get_ducking_state(&ducking->pa_info, &is_ducked); - if (ret != MM_ERROR_NONE) - return _convert_sound_manager_error_code(__func__, ret); + if (ret != SOUND_MANAGER_ERROR_NONE) + return ret; if (!is_ducked) { LOGE("not ducked"); @@ -1371,5 +1371,5 @@ int sound_manager_deactivate_ducking(sound_stream_ducking_h stream_ducking) SM_LEAVE_CRITICAL_SECTION(&ducking_mutex); - return _convert_sound_manager_error_code(__func__, ret); + return ret; } diff --git a/src/sound_manager_internal.c b/src/sound_manager_internal.c index 336b083..b7f83bb 100644 --- a/src/sound_manager_internal.c +++ b/src/sound_manager_internal.c @@ -411,7 +411,7 @@ int sound_manager_get_media_stream_only_by_id(int device_id, bool *enabled) int sound_manager_create_virtual_stream(sound_stream_info_h stream_info, virtual_sound_stream_h *virtual_stream) { - int ret = MM_ERROR_NONE; + int ret = SOUND_MANAGER_ERROR_NONE; virtual_sound_stream_info_s *vstream_h = NULL; sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info; @@ -424,21 +424,21 @@ int sound_manager_create_virtual_stream(sound_stream_info_h stream_info, virtual if (stream_h->vstream) { LOGE("virtual stream was already created. stream_h(%p), vstream(%p)", stream_h, stream_h->vstream); SM_LEAVE_CRITICAL_SECTION(&stream_h->vstream_mutex); - return _convert_sound_manager_error_code(__func__, MM_ERROR_SOUND_INVALID_OPERATION); + return SOUND_MANAGER_ERROR_INVALID_OPERATION; } ret = _create_virtual_stream(stream_h, &vstream_h); - if (ret == MM_ERROR_NONE) + if (ret == SOUND_MANAGER_ERROR_NONE) *virtual_stream = stream_h->vstream = (virtual_sound_stream_h)vstream_h; SM_LEAVE_CRITICAL_SECTION(&stream_h->vstream_mutex); - return _convert_sound_manager_error_code(__func__, ret); + return ret; } int sound_manager_destroy_virtual_stream(virtual_sound_stream_h virtual_stream) { - int ret = MM_ERROR_NONE; + int ret = SOUND_MANAGER_ERROR_NONE; pthread_mutex_t *vstream_mutex; virtual_sound_stream_info_s *vstream_h = (virtual_sound_stream_info_s*)virtual_stream; @@ -455,12 +455,12 @@ int sound_manager_destroy_virtual_stream(virtual_sound_stream_h virtual_stream) SM_LEAVE_CRITICAL_SECTION(vstream_mutex); - return _convert_sound_manager_error_code(__func__, ret); + return ret; } int sound_manager_start_virtual_stream(virtual_sound_stream_h virtual_stream) { - int ret = MM_ERROR_NONE; + int ret = SOUND_MANAGER_ERROR_NONE; pthread_mutex_t *vstream_mutex; virtual_sound_stream_info_s *vstream_h = (virtual_sound_stream_info_s*)virtual_stream; @@ -477,12 +477,12 @@ int sound_manager_start_virtual_stream(virtual_sound_stream_h virtual_stream) SM_LEAVE_CRITICAL_SECTION(vstream_mutex); - return _convert_sound_manager_error_code(__func__, ret); + return ret; } int sound_manager_stop_virtual_stream(virtual_sound_stream_h virtual_stream) { - int ret = MM_ERROR_NONE; + int ret = SOUND_MANAGER_ERROR_NONE; pthread_mutex_t *vstream_mutex; virtual_sound_stream_info_s *vstream_h = (virtual_sound_stream_info_s*)virtual_stream; @@ -499,12 +499,12 @@ int sound_manager_stop_virtual_stream(virtual_sound_stream_h virtual_stream) SM_LEAVE_CRITICAL_SECTION(vstream_mutex); - return _convert_sound_manager_error_code(__func__, ret); + return ret; } int sound_manager_set_virtual_stream_volume(virtual_sound_stream_h virtual_stream, double ratio) { - int ret = MM_ERROR_NONE; + int ret = SOUND_MANAGER_ERROR_NONE; pthread_mutex_t *vstream_mutex; virtual_sound_stream_info_s *vstream_h = (virtual_sound_stream_info_s*)virtual_stream; @@ -521,7 +521,7 @@ int sound_manager_set_virtual_stream_volume(virtual_sound_stream_h virtual_strea SM_LEAVE_CRITICAL_SECTION(vstream_mutex); - return _convert_sound_manager_error_code(__func__, ret); + return ret; } static int _convert_filter(sound_filter_e filter, char **filter_str, char **filter_params_str) diff --git a/src/sound_manager_private.c b/src/sound_manager_private.c index 45f193e..a1be367 100644 --- a/src/sound_manager_private.c +++ b/src/sound_manager_private.c @@ -1503,8 +1503,6 @@ void _update_focus_status(unsigned int index, unsigned int acquired_focus_status LEAVE: g_variant_unref(result); g_object_unref(conn); - - return; } //LCOV_EXCL_START @@ -1829,7 +1827,7 @@ int _get_sample_rate(int device_id, sound_sample_rate_e *rate) unsigned int _rate; sound_sample_rate_e rate_e; - SM_NULL_ARG_CHECK_FOR_PRIV(rate); + SM_ARG_CHECK(rate); if ((ret = __get_dbus_connection(&conn))) return SOUND_MANAGER_ERROR_INTERNAL; @@ -2357,7 +2355,7 @@ static int __is_available_device(sound_stream_info_s *stream_info, sound_device_ if (!found) { LOGE("[OUT] this device(%s) is not available for this stream_info(%s)", device_type_str, stream_info->stream_type); *available = false; - return ret; + return SOUND_MANAGER_ERROR_NONE; } } @@ -2372,13 +2370,13 @@ static int __is_available_device(sound_stream_info_s *stream_info, sound_device_ if (!found) { LOGE("[IN] this device(%s) is not available for this stream_info(%s)", device_type_str, stream_info->stream_type); *available = false; - return ret; + return SOUND_MANAGER_ERROR_NONE; } } *available = true; - return ret; + return SOUND_MANAGER_ERROR_NONE; } int _add_device_for_stream_routing(sound_stream_info_s *stream_info, sound_device_h device) @@ -2413,7 +2411,7 @@ int _add_device_for_stream_routing(sound_stream_info_s *stream_info, sound_devic LOGI("*** added device[type:%s, id:%d]", device_type_str, device_id); - return ret; + return SOUND_MANAGER_ERROR_NONE; } int _remove_device_for_stream_routing(sound_stream_info_s *stream_info, sound_device_h device) @@ -2448,7 +2446,7 @@ int _remove_device_for_stream_routing(sound_stream_info_s *stream_info, sound_de LOGI("*** removed device[type:%s, id:%d]", device_type_str, device_id); - return ret; + return SOUND_MANAGER_ERROR_NONE; } int _remove_all_devices_for_stream_routing(sound_stream_info_s *stream_info) @@ -2470,7 +2468,7 @@ int _remove_all_devices_for_stream_routing(sound_stream_info_s *stream_info) LOGI("*** removed all devices"); - return ret; + return SOUND_MANAGER_ERROR_NONE; } //LCOV_EXCL_START int _add_device_id_for_stream_routing(sound_stream_info_s *stream_info, int device_id) @@ -2581,13 +2579,12 @@ int _apply_stream_routing(sound_stream_info_s *stream_info) //LCOV_EXCL_START int _create_virtual_stream(sound_stream_info_s *stream_info, virtual_sound_stream_info_s **virtual_stream) { - int ret = MM_ERROR_NONE; bool result = false; const char *name = NULL; int i = 0; - SM_INSTANCE_CHECK_FOR_PRIV(virtual_stream); - SM_INSTANCE_CHECK_FOR_PRIV(stream_info); + SM_ARG_CHECK(stream_info); + SM_ARG_CHECK(virtual_stream); /* check if this stream_info is available for virtual stream */ name = _convert_api_name(NATIVE_API_SOUND_MANAGER); @@ -2598,16 +2595,12 @@ int _create_virtual_stream(sound_stream_info_s *stream_info, virtual_sound_strea } } LOGI("stream_type[%s], native api[%s], is_available[%d]", stream_info->stream_type, name, result); - if (result == false) { - ret = MM_ERROR_NOT_SUPPORT_API; - goto LEAVE; - } + if (!result) + return SOUND_MANAGER_ERROR_NOT_SUPPORTED; (*virtual_stream) = malloc(sizeof(virtual_sound_stream_info_s)); - if (!(*virtual_stream)) { - ret = MM_ERROR_OUT_OF_MEMORY; - goto LEAVE; - } + if (!(*virtual_stream)) + return SOUND_MANAGER_ERROR_INTERNAL; memset((*virtual_stream), 0, sizeof(virtual_sound_stream_info_s)); (*virtual_stream)->stream_type = stream_info->stream_type; @@ -2619,16 +2612,13 @@ int _create_virtual_stream(sound_stream_info_s *stream_info, virtual_sound_strea (*virtual_stream)->state = _VSTREAM_STATE_READY; (*virtual_stream)->stream_info = stream_info; -LEAVE: - return ret; + return SOUND_MANAGER_ERROR_NONE; } int _destroy_virtual_stream(virtual_sound_stream_info_s *virtual_stream) { - int ret = MM_ERROR_NONE; - - SM_INSTANCE_CHECK_FOR_PRIV(virtual_stream); - SM_STATE_CHECK_FOR_PRIV(virtual_stream, _VSTREAM_STATE_READY); + SM_ARG_CHECK(virtual_stream); + SM_STATE_CHECK(virtual_stream, _VSTREAM_STATE_READY); virtual_stream->pa_mainloop = NULL; virtual_stream->pa_context = NULL; @@ -2639,20 +2629,20 @@ int _destroy_virtual_stream(virtual_sound_stream_info_s *virtual_stream) SM_SAFE_FREE(virtual_stream); - return ret; + return SOUND_MANAGER_ERROR_NONE; } int _start_virtual_stream(virtual_sound_stream_info_s *virtual_stream) { - int ret = MM_ERROR_NONE; + int ret = SOUND_MANAGER_ERROR_NONE; int pa_ret = PA_OK; int i = 0; int io_direction = 0; pa_sample_spec ss; pa_channel_map maps; - SM_INSTANCE_CHECK_FOR_PRIV(virtual_stream); - SM_STATE_CHECK_FOR_PRIV(virtual_stream, _VSTREAM_STATE_READY); + SM_ARG_CHECK(virtual_stream); + SM_STATE_CHECK(virtual_stream, _VSTREAM_STATE_READY); /* fill up with default value */ ss.channels = 2; @@ -2674,7 +2664,7 @@ int _start_virtual_stream(virtual_sound_stream_info_s *virtual_stream) if (virtual_stream->pa_stream[i] == NULL) { LOGE("failed to pa_stream_new_with_proplist()"); pa_ret = pa_context_errno(virtual_stream->pa_context); - ret = MM_ERROR_SOUND_INTERNAL; + ret = SOUND_MANAGER_ERROR_INTERNAL; goto ERROR_WITH_UNLOCK; } pa_stream_set_state_callback(virtual_stream->pa_stream[i], _pa_stream_state_cb, virtual_stream); @@ -2684,7 +2674,7 @@ int _start_virtual_stream(virtual_sound_stream_info_s *virtual_stream) if (pa_ret < 0) { LOGE("failed to pa_stream_connect_playback()"); pa_ret = pa_context_errno(virtual_stream->pa_context); - ret = MM_ERROR_SOUND_INTERNAL; + ret = SOUND_MANAGER_ERROR_INTERNAL; goto ERROR_WITH_UNLOCK; } } else if ((i + 1) == SOUND_STREAM_DIRECTION_INPUT) { @@ -2692,7 +2682,7 @@ int _start_virtual_stream(virtual_sound_stream_info_s *virtual_stream) if (pa_ret < 0) { LOGE("failed to pa_stream_connect_record()"); pa_ret = pa_context_errno(virtual_stream->pa_context); - ret = MM_ERROR_SOUND_INTERNAL; + ret = SOUND_MANAGER_ERROR_INTERNAL; goto ERROR_WITH_UNLOCK; } } @@ -2706,7 +2696,7 @@ int _start_virtual_stream(virtual_sound_stream_info_s *virtual_stream) if (!PA_STREAM_IS_GOOD(state)) { LOGE("stream(%d) is not good, state : %d", i, state); pa_ret = pa_context_errno(virtual_stream->pa_context); - ret = MM_ERROR_SOUND_INTERNAL; + ret = SOUND_MANAGER_ERROR_INTERNAL; goto ERROR_WITH_UNLOCK; } @@ -2718,7 +2708,7 @@ int _start_virtual_stream(virtual_sound_stream_info_s *virtual_stream) pa_threaded_mainloop_unlock(virtual_stream->pa_mainloop); - return ret; + return SOUND_MANAGER_ERROR_NONE; ERROR_WITH_UNLOCK: pa_threaded_mainloop_unlock(virtual_stream->pa_mainloop); @@ -2735,11 +2725,10 @@ ERROR_WITH_UNLOCK: int _stop_virtual_stream(virtual_sound_stream_info_s *virtual_stream) { - int ret = MM_ERROR_NONE; int i = 0; - SM_INSTANCE_CHECK_FOR_PRIV(virtual_stream); - SM_STATE_CHECK_FOR_PRIV(virtual_stream, _VSTREAM_STATE_RUNNING); + SM_ARG_CHECK(virtual_stream); + SM_STATE_CHECK(virtual_stream, _VSTREAM_STATE_RUNNING); pa_threaded_mainloop_lock(virtual_stream->pa_mainloop); @@ -2765,19 +2754,19 @@ int _stop_virtual_stream(virtual_sound_stream_info_s *virtual_stream) virtual_stream->state = _VSTREAM_STATE_READY; - return ret; + return SOUND_MANAGER_ERROR_NONE; } int _set_volume_ratio(uint32_t stream_index, sound_stream_direction_e direction, double ratio) { - int ret = MM_ERROR_NONE; + int ret = SOUND_MANAGER_ERROR_NONE; GDBusConnection *conn = NULL; GError *err = NULL; GVariant *result = NULL; const gchar *dbus_ret = NULL; if ((ret = __get_dbus_connection(&conn))) - return ret; + return SOUND_MANAGER_ERROR_INTERNAL; result = g_dbus_connection_call_sync(conn, PA_BUS_NAME, @@ -2792,7 +2781,7 @@ int _set_volume_ratio(uint32_t stream_index, sound_stream_direction_e direction, &err); if (!result || err) { LOGE("g_dbus_connection_call_sync() for SET_VOLUME_RATIO 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; @@ -2800,11 +2789,11 @@ int _set_volume_ratio(uint32_t stream_index, sound_stream_direction_e direction, 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_ERROR_INVALID_ARGUMENT", dbus_ret, strlen(dbus_ret))) - ret = MM_ERROR_INVALID_ARGUMENT; + ret = SOUND_MANAGER_ERROR_INVALID_PARAMETER; else if (!strncmp("STREAM_MANAGER_RETURN_ERROR_NO_STREAM", dbus_ret, strlen(dbus_ret))) - ret = MM_ERROR_SOUND_NO_DATA; + ret = SOUND_MANAGER_ERROR_NO_DATA; else 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); @@ -2815,12 +2804,12 @@ LEAVE: int _set_virtual_stream_volume(virtual_sound_stream_info_s *virtual_stream, double ratio) { - int ret = MM_ERROR_NONE; + int ret = SOUND_MANAGER_ERROR_NONE; int i = 0; uint32_t index; - SM_INSTANCE_CHECK_FOR_PRIV(virtual_stream); - SM_STATE_CHECK_FOR_PRIV(virtual_stream, _VSTREAM_STATE_RUNNING); + SM_ARG_CHECK(virtual_stream); + SM_STATE_CHECK(virtual_stream, _VSTREAM_STATE_RUNNING); pa_threaded_mainloop_lock(virtual_stream->pa_mainloop); @@ -2828,9 +2817,9 @@ int _set_virtual_stream_volume(virtual_sound_stream_info_s *virtual_stream, doub if (virtual_stream->pa_stream[i]) { index = pa_stream_get_index(virtual_stream->pa_stream[i]); if ((ret = _set_volume_ratio(index, i + 1, ratio))) { - if (ret == MM_ERROR_SOUND_NO_DATA) { + if (ret == SOUND_MANAGER_ERROR_NO_DATA) { LOGE("something wrong, no match index of %u", index); - ret = MM_ERROR_SOUND_INTERNAL; + ret = SOUND_MANAGER_ERROR_INTERNAL; } break; } @@ -2881,14 +2870,14 @@ LEAVE: int _activate_ducking(uint32_t stream_index, bool enable, const char *target_stream, uint32_t duration, double ratio) { - int ret = MM_ERROR_NONE; + int ret = SOUND_MANAGER_ERROR_NONE; GDBusConnection *conn = NULL; GError *err = NULL; GVariant *result = NULL; const gchar *dbus_ret = NULL; if ((ret = __get_dbus_connection(&conn))) - return ret; + return SOUND_MANAGER_ERROR_INTERNAL; result = g_dbus_connection_call_sync(conn, PA_BUS_NAME, @@ -2903,7 +2892,7 @@ int _activate_ducking(uint32_t stream_index, bool enable, const char *target_str &err); if (!result || err) { LOGE("g_dbus_connection_call_sync() for ACTIVATE_DUCKING error"); - ret = _convert_dbus_error(err ? err->message : NULL); + ret = _convert_sound_manager_error_code(__func__, _convert_dbus_error(err ? err->message : NULL)); if (err) g_error_free(err); goto LEAVE; @@ -2914,9 +2903,9 @@ int _activate_ducking(uint32_t stream_index, bool enable, const char *target_str LOGI("g_dbus_connection_call_sync() success, method return value is (%s)", dbus_ret); if (!strncmp("STREAM_MANAGER_RETURN_ERROR_INVALID_STATE", dbus_ret, strlen(dbus_ret))) - ret = MM_ERROR_SOUND_INVALID_STATE; + ret = SOUND_MANAGER_ERROR_INVALID_STATE; else 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); @@ -2927,23 +2916,23 @@ LEAVE: int _get_ducking_state(sound_pa_info_s *pa_info, bool *is_ducked) { - int ret = MM_ERROR_NONE; + int ret = SOUND_MANAGER_ERROR_NONE; gboolean _is_ducked = FALSE; GDBusConnection *conn = NULL; GError *err = NULL; GVariant *result = NULL; const gchar *dbus_ret = NULL; - SM_NULL_ARG_CHECK_FOR_PRIV(pa_info); - SM_NULL_ARG_CHECK_FOR_PRIV(is_ducked); + SM_ARG_CHECK(pa_info); + SM_ARG_CHECK(is_ducked); if (pa_info->is_disconnected) { LOGE("server disconnected"); - return MM_ERROR_SOUND_SERVER_DISCONNECTED; + return SOUND_MANAGER_ERROR_INTERNAL; } if ((ret = __get_dbus_connection(&conn))) - return ret; + return SOUND_MANAGER_ERROR_INTERNAL; result = g_dbus_connection_call_sync(conn, PA_BUS_NAME, @@ -2958,7 +2947,7 @@ int _get_ducking_state(sound_pa_info_s *pa_info, bool *is_ducked) &err); if (!result || err) { LOGE("g_dbus_connection_call_sync() for GET_DUCKING_STATE error"); - ret = _convert_dbus_error(err ? err->message : NULL); + ret = _convert_sound_manager_error_code(__func__, _convert_dbus_error(err ? err->message : NULL)); if (err) g_error_free(err); goto LEAVE; @@ -2972,11 +2961,11 @@ int _get_ducking_state(sound_pa_info_s *pa_info, bool *is_ducked) *is_ducked = (bool)_is_ducked; LOGI("is_ducked %u", *is_ducked); } else { - ret = MM_ERROR_SOUND_INTERNAL; + ret = SOUND_MANAGER_ERROR_INTERNAL; } 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); -- 2.34.1