#include <gio/gio.h>
-static GList *g_subscribe_cb_list = NULL;
static pthread_mutex_t g_subscribe_cb_list_mutex = PTHREAD_MUTEX_INITIALIZER;
#define MM_SOUND_DBUS_BUS_NAME_PREPIX "org.tizen.MMSound"
#define MM_SOUND_DBUS_OBJECT_PATH "/org/tizen/MMSound"
#define MM_SOUND_DBUS_INTERFACE "org.tizen.mmsound"
-GDBusConnection *g_dbus_conn_mmsound;
-
-int g_dbus_signal_values[MM_SOUND_SIGNAL_MAX] = {0,};
-
-const char* dbus_signal_name_str[] = {
+static GDBusConnection *g_dbus_conn_mmsound;
+static int g_dbus_signal_values[MM_SOUND_SIGNAL_MAX] = {0,};
+static const char* dbus_signal_name_str[] = {
"ReleaseInternalFocus",
};
int ret = MM_ERROR_NONE;
if (func == NULL || subs_id == NULL) {
- debug_error("argument is not valid\n");
+ debug_error("argument is not valid");
return MM_ERROR_INVALID_ARGUMENT;
}
ret = mm_sound_client_add_volume_changed_callback(func, user_data, subs_id);
if (ret < 0) {
- debug_error("Can not add volume changed callback, ret = %x\n", ret);
+ debug_error("Can not add volume changed callback, ret = %x", ret);
}
return ret;
ret = mm_sound_client_remove_volume_changed_callback(subs_id);
if (ret < 0) {
- debug_error("Can not remove volume changed callback, ret = %x\n", ret);
+ debug_error("Can not remove volume changed callback, ret = %x", ret);
}
return ret;
/* Check input param */
if (0 > _validate_volume(volume_type, (int)volume_level)) {
- debug_error("invalid volume type %d, value %u\n", volume_type, volume_level);
+ debug_error("invalid volume type %d, value %u", volume_type, volume_level);
return MM_ERROR_INVALID_ARGUMENT;
}
- ret = mm_sound_util_volume_set_value_by_type(volume_type, volume_level);
- if (ret == MM_ERROR_NONE) {
- /* update shared memory value */
- if(MM_ERROR_NONE != mm_sound_client_set_volume_by_type(volume_type, volume_level)) {
- debug_error("Can not set volume to shared memory 0x%x\n", ret);
- }
- }
+ /* request daemon to set volume */
+ ret = mm_sound_client_set_volume_by_type(volume_type, volume_level);
+ if (MM_ERROR_NONE != ret)
+ debug_error("Can not set volume, ret=0x%x", ret);
return ret;
}
/* Check input param */
if (value == NULL) {
- debug_error("invalid argument\n");
+ debug_error("invalid argument");
return MM_ERROR_INVALID_ARGUMENT;
}
if (type < 0 || type >= VOLUME_TYPE_MAX) {
- debug_error("invalid volume type value %d\n", type);
+ debug_error("invalid volume type value %d", type);
return MM_ERROR_INVALID_ARGUMENT;
}
/* Check input param */
if(type < VOLUME_TYPE_UNKNOWN || type >= VOLUME_TYPE_MAX) {
- debug_error("invalid argument\n");
+ debug_error("invalid argument");
return MM_ERROR_INVALID_ARGUMENT;
}
if (vconf_set_int(VCONFKEY_SOUND_PRIMARY_VOLUME_TYPE, type)) {
- debug_error("could not set vconf for RIMARY_VOLUME_TYPE\n");
+ debug_error("could not set vconf for RIMARY_VOLUME_TYPE");
ret = MM_ERROR_SOUND_INTERNAL;
} else {
debug_msg("set primary volume type forcibly %d(%s)", type, _get_volume_str(type));
/* Check input param */
if(type == NULL) {
- debug_error("invalid argument\n");
+ debug_error("invalid argument");
return MM_ERROR_INVALID_ARGUMENT;
}
/* check force set */
if (vconf_get_int(VCONFKEY_SOUND_PRIMARY_VOLUME_TYPE, &voltype)) {
- debug_error("could not get vconf for PRIMARY_VOLUME_TYPE\n");
+ debug_error("could not get vconf for PRIMARY_VOLUME_TYPE");
ret = MM_ERROR_SOUND_INTERNAL;
} else {
debug_msg("get primary volume type %d(%s)", voltype, _get_volume_str(voltype));
return ret;
}
+EXPORT_API
+int mm_sound_set_filter(const char *stream_type, const char *filter_name, const char *filter_parameters, const char *filter_group)
+{
+ /* Check input param */
+ if (!stream_type || !filter_name) {
+ debug_error("invalid argument");
+ return MM_ERROR_INVALID_ARGUMENT;
+ }
+ if (!filter_parameters)
+ filter_parameters = "";
+ if (!filter_group)
+ filter_group = "default";
+
+ debug_msg("stream_type(%s), filter_name(%s), filter_parameters(%s), filter_group(%s)", stream_type, filter_name, filter_parameters, filter_group);
+
+ return mm_sound_client_set_filter_by_type(stream_type, filter_name, filter_parameters, filter_group);
+}
+
+EXPORT_API
+int mm_sound_unset_filter(const char *stream_type)
+{
+ /* Check input param */
+ if (!stream_type) {
+ debug_error("invalid argument");
+ return MM_ERROR_INVALID_ARGUMENT;
+ }
+
+ debug_msg("stream_type(%s)", stream_type);
+
+ return mm_sound_client_unset_filter_by_type(stream_type);
+}
+
+EXPORT_API
+int mm_sound_control_filter(const char *stream_type, const char *filter_name, const char *filter_controls)
+{
+ /* Check input param */
+ if (!stream_type || !filter_name || !filter_controls) {
+ debug_error("invalid argument");
+ return MM_ERROR_INVALID_ARGUMENT;
+ }
+
+ debug_msg("stream_type(%s), filter_name(%s), filter_controls(%s)", stream_type, filter_name, filter_controls);
+
+ return mm_sound_client_control_filter_by_type(stream_type, filter_name, filter_controls);
+}
+
///////////////////////////////////
//// MMSOUND PLAY APIs
///////////////////////////////////
-static inline void _mm_sound_fill_play_param(MMSoundPlayParam *param, const char *filename, int volume_config, mm_sound_stop_callback_func callback, void *data, int priority, int handle_route)
+static inline void _mm_sound_fill_play_param(MMSoundPlayParam *param, const char *filename, int volume_config, mm_sound_stop_callback_func callback, void *data)
{
param->filename = filename;
param->volume = 0; //volume value dose not effect anymore
param->data = data;
param->loop = 1;
param->volume_config = volume_config;
- param->priority = priority;
- param->handle_route = handle_route;
}
EXPORT_API
MMSoundPlayParam param = { 0, };
/* FIXME : this function will be deleted */
- _mm_sound_fill_play_param(¶m, filename, volume_config, callback, data, HANDLE_PRIORITY_NORMAL, MM_SOUND_HANDLE_ROUTE_USING_CURRENT);
+ _mm_sound_fill_play_param(¶m, filename, volume_config, callback, data);
return mm_sound_play_sound_ex(¶m, handle);
}
{
MMSoundPlayParam param = { 0, };
- _mm_sound_fill_play_param(¶m, filename, volume_config, callback, data, HANDLE_PRIORITY_NORMAL, MM_SOUND_HANDLE_ROUTE_USING_CURRENT);
+ _mm_sound_fill_play_param(¶m, filename, volume_config, callback, data);
return mm_sound_play_sound_ex(¶m, handle);
}
int volume_type = 0;
/* Check input param */
if (param == NULL) {
- debug_error("param is null\n");
+ debug_error("param is null");
return MM_ERROR_INVALID_ARGUMENT;
}
volume_type = MM_SOUND_VOLUME_CONFIG_TYPE(param->volume_config);
if (param->filename == NULL) {
- debug_error("filename is NULL\n");
+ debug_error("filename is NULL");
return MM_ERROR_SOUND_FILE_NOT_FOUND;
}
if (volume_type < 0 || volume_type >= VOLUME_TYPE_MAX) {
- debug_error("Volume type is invalid %d\n", volume_type);
+ debug_error("Volume type is invalid %d", volume_type);
return MM_ERROR_INVALID_ARGUMENT;
}
- debug_warning ("play sound : priority=[%d], handle_route=[%d]\n", param->priority, param->handle_route);
-
/* Play sound */
err = mm_sound_client_play_sound(param, 0, &lhandle);
if (err < 0) {
- debug_error("Failed to play sound\n");
+ debug_error("Failed to play sound");
return err;
}
if (handle) {
*handle = lhandle;
} else {
- debug_critical("The sound hadle cannot be get [%d]\n", lhandle);
+ debug_critical("The sound hadle cannot be get [%d]", lhandle);
}
- debug_warning ("success : handle=[%p]\n", handle);
+ debug_warning ("success : handle=[%p]", handle);
return MM_ERROR_NONE;
}
param.volume = 0; //volume value dose not effect anymore
param.callback = callback;
param.data = data;
- param.priority = HANDLE_PRIORITY_NORMAL;
- param.handle_route = MM_SOUND_HANDLE_ROUTE_USING_CURRENT;
+
if (loop == 0)
param.loop = -1;
else
err = mm_sound_client_play_sound_with_stream_info(¶m, handle, stream_type, stream_id);
if (err < 0) {
- debug_error("Failed to play sound\n");
+ debug_error("Failed to play sound");
return err;
}
- debug_warning ("success : handle=[%p]\n", handle);
+ debug_warning ("success : handle=[%p]", handle);
return MM_ERROR_NONE;
{
int err;
- debug_warning ("enter : handle=[%d]\n", handle);
+ debug_warning ("enter : handle=[%d]", handle);
/* Stop sound */
err = mm_sound_client_stop_sound(handle);
if (err < 0) {
- debug_error("Fail to stop sound\n");
+ debug_error("Fail to stop sound");
return err;
}
- debug_warning ("success : handle=[%d]\n", handle);
+ debug_warning ("success : handle=[%d]", handle);
return MM_ERROR_NONE;
}
/* Check input param */
if (duration < -1) {
- debug_error("number is invalid %d\n", duration);
+ debug_error("number is invalid %d", duration);
return MM_ERROR_INVALID_ARGUMENT;
}
if (num < MM_SOUND_TONE_DTMF_0 || num >= MM_SOUND_TONE_NUM) {
- debug_error("TONE Value is invalid %d\n", num);
+ debug_error("TONE Value is invalid %d", num);
return MM_ERROR_INVALID_ARGUMENT;
}
if (volume_type < 0 || volume_type >= VOLUME_TYPE_MAX) {
- debug_error("Volume type is invalid %d\n", volume_type);
+ debug_error("Volume type is invalid %d", volume_type);
return MM_ERROR_INVALID_ARGUMENT;
}
if (volume < 0.0 || volume > 1.0) {
- debug_error("Volume Value is invalid %d\n", volume);
+ debug_error("Volume Value is invalid %d", volume);
return MM_ERROR_INVALID_ARGUMENT;
}
/* Play tone */
- debug_msg("Call MMSoundClientPlayTone\n");
+ debug_msg("Call MMSoundClientPlayTone");
err = mm_sound_client_play_tone(num, volume_config, volume, duration, &lhandle, enable_session);
if (err < 0) {
- debug_error("Failed to play sound\n");
+ debug_error("Failed to play sound");
return err;
}
if (handle)
*handle = lhandle;
else
- debug_critical("The sound handle cannot be get [%d]\n", lhandle);
+ debug_critical("The sound handle cannot be get [%d]", lhandle);
debug_fleave();
return MM_ERROR_NONE;
err = mm_sound_client_play_tone_with_stream_info(tone, stream_type, stream_id, volume, duration, handle);
if (err <0) {
- debug_error("Failed to play sound\n");
+ debug_error("Failed to play sound");
return err;
}
}
ret = mm_sound_client_test(a, b, getv);
if (ret < 0) {
- debug_error("Can not mm sound test, ret = %x\n", ret);
+ debug_error("Can not mm sound test, ret = %x", ret);
}
debug_log("mm_sound_test leave");
{
int ret = MM_ERROR_NONE;
- debug_log("mm_sound_add_test_callback enter");
+ debug_log("enter");
if (!func || !subs_id) {
- debug_error("argument is not valid\n");
+ debug_error("argument is not valid");
return MM_ERROR_INVALID_ARGUMENT;
}
ret = mm_sound_client_add_test_callback(func, user_data, subs_id);
if (ret < 0) {
- debug_error("Can not add test callback, ret = %x\n", ret);
+ debug_error("Can not add test callback, ret = %x", ret);
}
- debug_log("mm_sound_add_test_callback leave");
+ debug_log("leave");
return ret;
}
{
int ret = MM_ERROR_NONE;
- debug_log("mm_sound_remove_test_callback enter");
+ debug_log("enter");
ret = mm_sound_client_remove_test_callback(subs_id);
if (ret < 0) {
- debug_error("Can not remove test callback, ret = %x\n", ret);
+ debug_error("Can not remove test callback, ret = %x", ret);
}
- debug_log("mm_sound_remove_test_callback leave");
+ debug_log("leave");
return ret;
}
if (ret)
return;
- debug_msg ("signal_name[%s], value[%d], user_data[0x%x]\n", signal_name, value, user_data);
+ debug_msg("signal: name[%s], value[0x%08x], user_data[%p], type[%d]",
+ signal_name, value, user_data, subscribe_cb->signal_type);
if (subscribe_cb->signal_type == MM_SOUND_SIGNAL_RELEASE_INTERNAL_FOCUS) {
/* Trigger the signal callback when it comes from the same process.
* |<-- pid (16bits) -->|<-- value (16bits) -->|,
* FYI, #define PID_MAX_DEFAULT (CONFIG_BASE_SMALL ? 0x1000 : 0x8000).
* In case of daemon usage, it uses the client_pid of subscribe_cb. */
- if ((subscribe_cb->client_pid ? subscribe_cb->client_pid : getpid()) == (value >> 16)) {
+ debug_msg ("client_pid[%d], getpid[%d], value>>16[%d], callback[%p]",
+ subscribe_cb->client_pid, getpid(), (value >> 16), subscribe_cb);
+ if ((subscribe_cb->client_pid ? subscribe_cb->client_pid : getpid()) == (value >> 16))
subscribe_cb->callback(signal, (value & 0x0000FFFF), subscribe_cb->user_data);
- }
} else {
- subscribe_cb->callback(signal, value, subscribe_cb->user_data);
+ debug_warning("not supported type[%d]", subscribe_cb->signal_type);
}
debug_fleave();
sender_name, object_path, interface_name, signal_name);
if (g_variant_is_of_type(parameters, G_VARIANT_TYPE("(i)"))) {
g_variant_get(parameters, "(i)",&value);
- debug_msg(" - value : %d\n", value);
+ debug_msg(" - value : 0x08%x", value);
_dbus_signal_callback(signal_name, value, user_data);
} else {
value_type = g_variant_get_type(parameters);
}
EXPORT_API
-int mm_sound_subscribe_signal(mm_sound_signal_name_t signal, unsigned int *subscribe_id, mm_sound_signal_callback callback, void *user_data)
+int mm_sound_subscribe_signal(mm_sound_signal_name_t signal_type, unsigned int *subscribe_id,
+ mm_sound_signal_callback callback, void *user_data)
{
int ret = MM_ERROR_NONE;
GError *err = NULL;
-
+ guint subs_id;
subscribe_cb_t *subscribe_cb = NULL;
debug_fenter();
MMSOUND_ENTER_CRITICAL_SECTION_WITH_RETURN(&g_subscribe_cb_list_mutex, MM_ERROR_SOUND_INTERNAL);
- if (signal < 0 || signal >= MM_SOUND_SIGNAL_MAX || !subscribe_id) {
- debug_error ("invalid argument, signal(%d), subscribe_id(0x%p)", signal, subscribe_id);
+ if (signal_type < 0 || signal_type >= MM_SOUND_SIGNAL_MAX || !subscribe_id) {
+ debug_error ("invalid argument, signal(%d), subscribe_id(%p)", signal_type, subscribe_id);
ret = MM_ERROR_INVALID_ARGUMENT;
goto error;
}
goto error;
}
memset(subscribe_cb, 0, sizeof(subscribe_cb_t));
+ subscribe_cb->signal_type = signal_type;
+ subscribe_cb->callback = callback;
+ subscribe_cb->user_data = user_data;
g_dbus_conn_mmsound = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
if (!g_dbus_conn_mmsound && err) {
ret = MM_ERROR_SOUND_INTERNAL;
goto error;
}
-
- subscribe_cb->signal_type = signal;
- subscribe_cb->callback = callback;
- subscribe_cb->user_data = user_data;
-
- *subscribe_id = g_dbus_connection_signal_subscribe(g_dbus_conn_mmsound,
- NULL, MM_SOUND_DBUS_INTERFACE, dbus_signal_name_str[signal], MM_SOUND_DBUS_OBJECT_PATH, NULL, 0,
- signal_callback, subscribe_cb, NULL);
- if (*subscribe_id == 0) {
- debug_error ("g_dbus_connection_signal_subscribe() error (%d)", *subscribe_id);
- ret = MM_ERROR_SOUND_INTERNAL;
- goto sig_error;
- }
-
- subscribe_cb->id = *subscribe_id;
-
- g_subscribe_cb_list = g_list_append(g_subscribe_cb_list, subscribe_cb);
- if (g_subscribe_cb_list) {
- debug_log("new subscribe_cb(0x%x)[user_callback(0x%x), subscribe_id(%u)] is added\n", subscribe_cb, subscribe_cb->callback, subscribe_cb->id);
- } else {
- debug_error("g_list_append failed\n");
+ subs_id = g_dbus_connection_signal_subscribe(g_dbus_conn_mmsound, NULL, MM_SOUND_DBUS_INTERFACE,
+ dbus_signal_name_str[signal_type], MM_SOUND_DBUS_OBJECT_PATH,
+ NULL, G_DBUS_SIGNAL_FLAGS_NONE, signal_callback,
+ subscribe_cb, free);
+ if (subs_id == 0) {
+ debug_error ("g_dbus_connection_signal_subscribe() error (%d)", subs_id);
ret = MM_ERROR_SOUND_INTERNAL;
+ g_object_unref(g_dbus_conn_mmsound);
goto error;
}
+ subscribe_cb->id = subs_id;
+ *subscribe_id = subs_id;
MMSOUND_LEAVE_CRITICAL_SECTION(&g_subscribe_cb_list_mutex);
return ret;
-sig_error:
- g_dbus_connection_signal_unsubscribe(g_dbus_conn_mmsound, *subscribe_id);
- g_object_unref(g_dbus_conn_mmsound);
-
error:
if (subscribe_cb)
- free (subscribe_cb);
+ free(subscribe_cb);
MMSOUND_LEAVE_CRITICAL_SECTION(&g_subscribe_cb_list_mutex);
return ret;
}
+/* ToDo : Almost same as mm_sound_subscribe_signal, need to be merged */
EXPORT_API
-int mm_sound_subscribe_signal_for_daemon(mm_sound_signal_name_t signal, int client_pid, unsigned int *subscribe_id, mm_sound_signal_callback callback, void *user_data)
+int mm_sound_subscribe_signal_for_daemon(mm_sound_signal_name_t signal_type, int client_pid, unsigned int *subscribe_id,
+ mm_sound_signal_callback callback, void *user_data)
{
int ret = MM_ERROR_NONE;
GError *err = NULL;
-
+ guint subs_id;
subscribe_cb_t *subscribe_cb = NULL;
debug_fenter();
MMSOUND_ENTER_CRITICAL_SECTION_WITH_RETURN(&g_subscribe_cb_list_mutex, MM_ERROR_SOUND_INTERNAL);
- if (signal < 0 || signal >= MM_SOUND_SIGNAL_MAX || !client_pid || !subscribe_id) {
- debug_error ("invalid argument, signal(%d), client_pid(%d), subscribe_id(0x%p)", signal, client_pid, subscribe_id);
+ if (signal_type < 0 || signal_type >= MM_SOUND_SIGNAL_MAX || !client_pid || !subscribe_id) {
+ debug_error ("invalid argument, signal(%d), client_pid(%d), subscribe_id(%p)", signal_type, client_pid, subscribe_id);
ret = MM_ERROR_INVALID_ARGUMENT;
goto error;
}
goto error;
}
memset(subscribe_cb, 0, sizeof(subscribe_cb_t));
+ subscribe_cb->signal_type = signal_type;
+ subscribe_cb->callback = callback;
+ subscribe_cb->user_data = user_data;
+ subscribe_cb->client_pid = client_pid;
g_dbus_conn_mmsound = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
if (!g_dbus_conn_mmsound && err) {
ret = MM_ERROR_SOUND_INTERNAL;
goto error;
}
-
- subscribe_cb->signal_type = signal;
- subscribe_cb->callback = callback;
- subscribe_cb->user_data = user_data;
- subscribe_cb->client_pid = client_pid;
-
- *subscribe_id = g_dbus_connection_signal_subscribe(g_dbus_conn_mmsound,
- NULL, MM_SOUND_DBUS_INTERFACE, dbus_signal_name_str[signal], MM_SOUND_DBUS_OBJECT_PATH, NULL, 0,
- signal_callback, subscribe_cb, NULL);
- if (*subscribe_id == 0) {
- debug_error ("g_dbus_connection_signal_subscribe() error (%d)", *subscribe_id);
- ret = MM_ERROR_SOUND_INTERNAL;
- goto sig_error;
- }
-
- subscribe_cb->id = *subscribe_id;
-
- g_subscribe_cb_list = g_list_append(g_subscribe_cb_list, subscribe_cb);
- if (g_subscribe_cb_list) {
- debug_log("new subscribe_cb(0x%x)[user_callback(0x%x), subscribe_id(%u)] is added\n", subscribe_cb, subscribe_cb->callback, subscribe_cb->id);
- } else {
- debug_error("g_list_append failed\n");
+ subs_id = g_dbus_connection_signal_subscribe(g_dbus_conn_mmsound, NULL, MM_SOUND_DBUS_INTERFACE,
+ dbus_signal_name_str[signal_type], MM_SOUND_DBUS_OBJECT_PATH,
+ NULL, G_DBUS_SIGNAL_FLAGS_NONE, signal_callback,
+ subscribe_cb, free);
+ if (subs_id == 0) {
+ debug_error ("g_dbus_connection_signal_subscribe() error (%d)", subs_id);
ret = MM_ERROR_SOUND_INTERNAL;
+ g_object_unref(g_dbus_conn_mmsound);
goto error;
}
+ subscribe_cb->id = subs_id;
+ *subscribe_id = subs_id;
MMSOUND_LEAVE_CRITICAL_SECTION(&g_subscribe_cb_list_mutex);
return ret;
-sig_error:
- g_dbus_connection_signal_unsubscribe(g_dbus_conn_mmsound, *subscribe_id);
- g_object_unref(g_dbus_conn_mmsound);
-
error:
if (subscribe_cb)
- free (subscribe_cb);
+ free(subscribe_cb);
MMSOUND_LEAVE_CRITICAL_SECTION(&g_subscribe_cb_list_mutex);
EXPORT_API
void mm_sound_unsubscribe_signal(unsigned int subscribe_id)
{
- GList *list = NULL;
- subscribe_cb_t *subscribe_cb = NULL;
-
debug_fenter();
MMSOUND_ENTER_CRITICAL_SECTION(&g_subscribe_cb_list_mutex);
if (g_dbus_conn_mmsound && subscribe_id) {
g_dbus_connection_signal_unsubscribe(g_dbus_conn_mmsound, subscribe_id);
g_object_unref(g_dbus_conn_mmsound);
- for (list = g_subscribe_cb_list; list != NULL; list = list->next) {
- subscribe_cb = (subscribe_cb_t *)list->data;
- if (subscribe_cb && (subscribe_cb->id == subscribe_id)) {
- g_subscribe_cb_list = g_list_remove(g_subscribe_cb_list, subscribe_cb);
- debug_log("subscribe_cb(0x%x) is removed\n", subscribe_cb);
- free (subscribe_cb);
- }
- }
}
MMSOUND_LEAVE_CRITICAL_SECTION(&g_subscribe_cb_list_mutex);
}
EXPORT_API
-int mm_sound_send_signal(mm_sound_signal_name_t signal, int value)
+int mm_sound_send_signal(mm_sound_signal_name_t signal_type, int value)
{
int ret = MM_ERROR_NONE;
GError *err = NULL;
MMSOUND_ENTER_CRITICAL_SECTION_WITH_RETURN(&g_subscribe_cb_list_mutex, MM_ERROR_SOUND_INTERNAL);
- if (signal < 0 || signal >= MM_SOUND_SIGNAL_MAX) {
- debug_error ("invalid argument, signal(%d)", signal);
+ if (signal_type < 0 || signal_type >= MM_SOUND_SIGNAL_MAX) {
+ debug_error ("invalid argument, signal(%d)", signal_type);
ret = MM_ERROR_INVALID_ARGUMENT;
goto error;
}
goto error;
}
- g_dbus_signal_values[signal] = value;
- if (signal == MM_SOUND_SIGNAL_RELEASE_INTERNAL_FOCUS) {
+ g_dbus_signal_values[signal_type] = value;
+ if (signal_type == MM_SOUND_SIGNAL_RELEASE_INTERNAL_FOCUS) {
/* Trigger the signal callback when it comes from the same process.
* |<-- pid (16bits) -->|<-- value (16bits) -->|,
* FYI, #define PID_MAX_DEFAULT (CONFIG_BASE_SMALL ? 0x1000 : 0x8000). */
debug_error ("failed to _mm_session_util_write_information for MM_SESSION_TYPE_REPLACED_BY_STREAM");
}
dbus_ret = g_dbus_connection_emit_signal (conn,
- NULL, MM_SOUND_DBUS_OBJECT_PATH, MM_SOUND_DBUS_INTERFACE, dbus_signal_name_str[signal],
+ NULL, MM_SOUND_DBUS_OBJECT_PATH, MM_SOUND_DBUS_INTERFACE, dbus_signal_name_str[signal_type],
g_variant_new ("(i)", value),
&err);
if (!dbus_ret && err) {
}
g_object_unref(conn);
- debug_msg ("sending signal[%s], value[%d] success", dbus_signal_name_str[signal], value);
+ debug_msg ("sending signal[%s], value[%d] success", dbus_signal_name_str[signal_type], value);
MMSOUND_LEAVE_CRITICAL_SECTION(&g_subscribe_cb_list_mutex);
}
EXPORT_API
-int mm_sound_get_signal_value(mm_sound_signal_name_t signal, int *value)
+int mm_sound_get_signal_value(mm_sound_signal_name_t signal_type, int *value)
{
int ret = MM_ERROR_NONE;
MMSOUND_ENTER_CRITICAL_SECTION_WITH_RETURN(&g_subscribe_cb_list_mutex, MM_ERROR_SOUND_INTERNAL);
- *value = g_dbus_signal_values[signal];
+ *value = g_dbus_signal_values[signal_type];
MMSOUND_LEAVE_CRITICAL_SECTION(&g_subscribe_cb_list_mutex);
projects / platform / core / multimedia / libmm-sound.git / blobdiff