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;
}
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);
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);
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;
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.");
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);
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;
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");
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;
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");
SM_LEAVE_CRITICAL_SECTION(&ducking_mutex);
- return _convert_sound_manager_error_code(__func__, ret);
+ return ret;
}
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;
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;
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;
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;
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;
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)
LEAVE:
g_variant_unref(result);
g_object_unref(conn);
-
- return;
}
//LCOV_EXCL_START
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;
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;
}
}
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)
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)
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)
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)
//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);
}
}
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;
(*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;
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;
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);
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) {
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;
}
}
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;
}
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);
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);
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,
&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;
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);
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);
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;
}
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,
&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;
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);
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,
&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;
*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);
projects / platform / core / api / sound-manager.git / commitdiff