#include <vconf.h>
#include <mm_types.h>
#include <mm_error.h>
-#include <mm_session_private.h>
#include <mm_debug.h>
#include "include/mm_sound_private.h"
#include "include/mm_sound_utils.h"
#include "include/mm_sound_pa_client.h"
#include "include/mm_sound_common.h"
-
-#define VOLUME_MAX_MULTIMEDIA 16
-#define VOLUME_MAX_BASIC 8
-#define VOLUME_MAX_SINGLE 1
-
-
#define MASTER_VOLUME_MAX 100
#define MASTER_VOLUME_MIN 0
#include <gio/gio.h>
-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"
-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",
-};
-
-typedef struct _subscribe_cb {
- mm_sound_signal_name_t signal_type;
- mm_sound_signal_callback callback;
- void *user_data;
- unsigned int id;
- int client_pid;
-} subscribe_cb_t;
-
static const char* _get_volume_str(volume_type_t type)
{
static const char *volume_type_str[VOLUME_TYPE_MAX] = {
"SYSTEM", "NOTIFICATION", "ALARM", "RINGTONE", "MEDIA", "CALL", "VOIP", "VOICE", "FIXED"
};
- return (type >= VOLUME_TYPE_SYSTEM && type < VOLUME_TYPE_MAX) ? volume_type_str[type] : "Unknown";
+ return (type < VOLUME_TYPE_MAX) ? volume_type_str[type] : "Unknown";
}
-static int _validate_volume(volume_type_t type, int value)
+static const char* _get_volume_str_internal(volume_type_internal_t type)
{
- if (value < 0)
- return -1;
-
- switch (type) {
- case VOLUME_TYPE_CALL:
- case VOLUME_TYPE_VOIP:
- if (value >= VOLUME_MAX_BASIC) {
- return -1;
- }
- break;
- case VOLUME_TYPE_SYSTEM:
- case VOLUME_TYPE_MEDIA:
- case VOLUME_TYPE_ALARM:
- case VOLUME_TYPE_NOTIFICATION:
- case VOLUME_TYPE_RINGTONE:
- case VOLUME_TYPE_VOICE:
- if (value >= VOLUME_MAX_MULTIMEDIA) {
- return -1;
- }
- break;
- default:
- return -1;
- break;
- }
- return 0;
-}
+ static const char *volume_type_str[] = {
+ "BIXBY"
+ };
-EXPORT_API
-int mm_sound_volume_remove_callback(volume_type_t type)
-{
- /* FIXME : Will be removed */
- return MM_ERROR_NOT_SUPPORT_API;
+ return (type < (VOLUME_TYPE_BIXBY + 1)) ? volume_type_str[type] : "Unknown";
}
EXPORT_API
}
EXPORT_API
-int mm_sound_volume_set_value(volume_type_t volume_type, const unsigned int volume_level)
+int mm_sound_volume_set_value(volume_type_t type, const unsigned int value)
{
int ret = MM_ERROR_NONE;
- debug_msg("type = (%d)%s, value = %d", volume_type, _get_volume_str(volume_type), volume_level);
-
- /* Check input param */
- if (0 > _validate_volume(volume_type, (int)volume_level)) {
- debug_error("invalid volume type %d, value %u", volume_type, volume_level);
- return MM_ERROR_INVALID_ARGUMENT;
- }
-
/* 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);
+ ret = mm_sound_client_set_volume_by_type(type, value);
+ if (ret)
+ debug_error("can not set volume, type(%s), value(%d), ret=0x%x", _get_volume_str(type), value, ret);
+ else
+ debug_msg("set (%s) volume to (%d)", _get_volume_str(type), value);
return ret;
}
{
int ret = MM_ERROR_NONE;
- /* Check input param */
- if (value == NULL) {
- debug_error("invalid argument");
- return MM_ERROR_INVALID_ARGUMENT;
- }
- if (type < 0 || type >= VOLUME_TYPE_MAX) {
- debug_error("invalid volume type value %d", type);
- return MM_ERROR_INVALID_ARGUMENT;
- }
-
- ret = mm_sound_util_volume_get_value_by_type(type, value);
+ ret = mm_sound_client_get_volume_by_type(type, value);
+ if (ret)
+ debug_error("can not get volume, type(%s), ret=0x%x", _get_volume_str(type), ret);
+ else
+ debug_msg("(%s) volume : %d", _get_volume_str(type), *value);
- debug_msg("returned %s = %d", _get_volume_str(type), *value);
return ret;
}
EXPORT_API
-int mm_sound_volume_primary_type_set(volume_type_t type)
+int mm_sound_add_volume_changed_callback_internal(mm_sound_volume_changed_cb_internal func, void* user_data, unsigned int *subs_id)
{
int ret = MM_ERROR_NONE;
- /* Check input param */
- if (type < VOLUME_TYPE_UNKNOWN || type >= VOLUME_TYPE_MAX) {
- debug_error("invalid argument");
+ if (func == NULL || subs_id == NULL) {
+ debug_error("argument is not valid");
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");
- ret = MM_ERROR_SOUND_INTERNAL;
- } else {
- debug_msg("set primary volume type forcibly %d(%s)", type, _get_volume_str(type));
- }
+ ret = mm_sound_client_add_volume_changed_callback_internal(func, user_data, subs_id);
+ if (ret < 0)
+ debug_error("Can not add internal volume changed callback, ret = %x", ret);
return ret;
}
EXPORT_API
-int mm_sound_volume_primary_type_get(volume_type_t *type)
+int mm_sound_remove_volume_changed_callback_internal(unsigned int subs_id)
{
int ret = MM_ERROR_NONE;
- int voltype = VOLUME_TYPE_RINGTONE;
- /* Check input param */
- if (type == NULL) {
- 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");
- ret = MM_ERROR_SOUND_INTERNAL;
- } else {
- debug_msg("get primary volume type %d(%s)", voltype, _get_volume_str(voltype));
- *type = voltype;
- }
+ ret = mm_sound_client_remove_volume_changed_callback(subs_id);
+ if (ret < 0)
+ debug_error("Can not remove internal volume changed callback, ret = %x", ret);
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)
+int mm_sound_volume_set_value_internal(volume_type_internal_t type, const unsigned int value)
{
- /* 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";
+ int ret = MM_ERROR_NONE;
- debug_msg("stream_type(%s), filter_name(%s), filter_parameters(%s), filter_group(%s)", stream_type, filter_name, filter_parameters, filter_group);
+ /* request daemon to set volume */
+ ret = mm_sound_client_set_volume_by_internal_type(type, value);
+ if (ret)
+ debug_error("can not set internal volume, type(%s), value(%d), ret=0x%x", _get_volume_str_internal(type), value, ret);
+ else
+ debug_msg("set (%s) volume to (%d)", _get_volume_str_internal(type), value);
- return mm_sound_client_set_filter_by_type(stream_type, filter_name, filter_parameters, filter_group);
+ return ret;
}
EXPORT_API
-int mm_sound_unset_filter(const char *stream_type)
+int mm_sound_volume_get_value_internal(volume_type_internal_t type, unsigned int *value)
{
- /* Check input param */
- if (!stream_type) {
- debug_error("invalid argument");
- return MM_ERROR_INVALID_ARGUMENT;
- }
+ int ret = MM_ERROR_NONE;
- debug_msg("stream_type(%s)", stream_type);
+ ret = mm_sound_client_get_volume_by_internal_type(type, value);
+ if (ret)
+ debug_error("can not get internal volume, type(%s), ret=0x%x", _get_volume_str_internal(type), ret);
+ else
+ debug_msg("(%s) volume : %d", _get_volume_str_internal(type), *value);
- return mm_sound_client_unset_filter_by_type(stream_type);
+ return ret;
}
EXPORT_API
-int mm_sound_control_filter(const char *stream_type, const char *filter_name, const char *filter_controls)
+int mm_sound_set_mute(volume_type_t type, bool mute)
{
- /* 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)
-{
- param->filename = filename;
- param->volume = 0; //volume value dose not effect anymore
- param->callback = callback;
- param->data = data;
- param->loop = 1;
- param->volume_config = volume_config;
-}
+ int ret = MM_ERROR_NONE;
-EXPORT_API
-int mm_sound_play_loud_solo_sound(const char *filename, int volume_config, mm_sound_stop_callback_func callback, void *data, int *handle)
-{
- MMSoundPlayParam param = { 0, };
+ ret = mm_sound_client_set_mute_by_type(type, mute);
+ if (ret)
+ debug_error("can not set mute, type(%s), mute(%d), ret=0x%x", _get_volume_str(type), mute, ret);
+ else
+ debug_msg("set (%s) mute to (%d)", _get_volume_str(type), mute);
- /* FIXME : this function will be deleted */
- _mm_sound_fill_play_param(¶m, filename, volume_config, callback, data);
- return mm_sound_play_sound_ex(¶m, handle);
+ return ret;
}
EXPORT_API
-int mm_sound_play_sound(const char *filename, int volume_config, mm_sound_stop_callback_func callback, void *data, int *handle)
+int mm_sound_get_mute(volume_type_t type, bool *muted)
{
- MMSoundPlayParam param = { 0, };
-
- _mm_sound_fill_play_param(¶m, filename, volume_config, callback, data);
- return mm_sound_play_sound_ex(¶m, handle);
-}
+ int ret = MM_ERROR_NONE;
-EXPORT_API
-int mm_sound_play_sound_ex(MMSoundPlayParam *param, int *handle)
-{
- int err;
- int lhandle = -1;
- int volume_type = 0;
/* Check input param */
- if (param == NULL) {
- debug_error("param is null");
+ if (!muted) {
+ debug_error("invalid argument");
return MM_ERROR_INVALID_ARGUMENT;
}
-
- volume_type = MM_SOUND_VOLUME_CONFIG_TYPE(param->volume_config);
-
- if (param->filename == NULL) {
- 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", volume_type);
+ if (type > VOLUME_TYPE_VOICE) {
+ debug_error("invalid volume type value %d", type);
return MM_ERROR_INVALID_ARGUMENT;
}
- /* Play sound */
- err = mm_sound_client_play_sound(param, 0, &lhandle);
- if (err < 0) {
- debug_error("Failed to play sound");
- return err;
- }
-
- /* Set handle to return */
- if (handle) {
- *handle = lhandle;
- } else {
- debug_critical("The sound hadle cannot be get [%d]", lhandle);
- }
-
- debug_warning("success : handle=[%p]", handle);
-
- return MM_ERROR_NONE;
-}
-
-EXPORT_API
-int mm_sound_play_sound_with_stream_info(const char *filename, char *stream_type, int stream_id, unsigned int loop, mm_sound_stop_callback_func callback, void *data, int *handle)
-{
- MMSoundPlayParam param = { 0, };
- int err;
-
- param.filename = filename;
- param.volume = 0; //volume value dose not effect anymore
- param.callback = callback;
- param.data = data;
-
- if (loop == 0)
- param.loop = -1;
+ ret = mm_sound_client_get_mute_by_type(type, muted);
+ if (ret)
+ debug_error("can not get mute, type(%s), ret=0x%x", _get_volume_str(type), ret);
else
- param.loop = loop;
-
- err = mm_sound_client_play_sound_with_stream_info(¶m, handle, stream_type, stream_id);
- if (err < 0) {
- debug_error("Failed to play sound");
- return err;
- }
-
- debug_warning("success : handle=[%p]", handle);
-
- return MM_ERROR_NONE;
+ debug_msg("(%s) mute state : %d", _get_volume_str(type), *muted);
+ return ret;
}
-
EXPORT_API
-int mm_sound_stop_sound(int handle)
+int mm_sound_set_filter(const char *stream_type, const char *filter_name, const char *filter_parameters, const char *filter_group)
{
- int err;
-
- debug_warning("enter : handle=[%d]", handle);
- /* Stop sound */
- err = mm_sound_client_stop_sound(handle);
- if (err < 0) {
- debug_error("Fail to stop sound");
- return err;
+ /* Check input param */
+ if (!stream_type || !filter_name) {
+ debug_error("invalid argument");
+ return MM_ERROR_INVALID_ARGUMENT;
}
- debug_warning("success : handle=[%d]", handle);
+ 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_ERROR_NONE;
+ return mm_sound_client_set_filter_by_type(stream_type, filter_name, filter_parameters, filter_group);
}
-///////////////////////////////////
-//// MMSOUND TONE APIs
-///////////////////////////////////
EXPORT_API
-int mm_sound_play_tone_ex(MMSoundTone_t num, int volume_config, const double volume, const int duration, int *handle, bool enable_session)
+int mm_sound_unset_filter(const char *stream_type)
{
- int lhandle = -1;
- int err = MM_ERROR_NONE;
- int volume_type = MM_SOUND_VOLUME_CONFIG_TYPE(volume_config);
-
- debug_fenter();
-
/* Check input param */
- if (duration < -1) {
- debug_error("number is invalid %d", duration);
- return MM_ERROR_INVALID_ARGUMENT;
- }
- if (num >= MM_SOUND_TONE_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", volume_type);
- return MM_ERROR_INVALID_ARGUMENT;
- }
- if (volume < 0.0 || volume > 1.0) {
- debug_error("Volume Value is invalid %d", volume);
+ if (!stream_type) {
+ debug_error("invalid argument");
return MM_ERROR_INVALID_ARGUMENT;
}
- /* Play tone */
- 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");
- return err;
- }
-
- /* Set handle to return */
- if (handle)
- *handle = lhandle;
- else
- debug_critical("The sound handle cannot be get [%d]", lhandle);
+ debug_msg("stream_type(%s)", stream_type);
- debug_fleave();
- return MM_ERROR_NONE;
+ return mm_sound_client_unset_filter_by_type(stream_type);
}
EXPORT_API
-int mm_sound_play_tone_with_stream_info(MMSoundTone_t tone, char *stream_type, int stream_id, const double volume, const int duration, int *handle)
+int mm_sound_control_filter(const char *stream_type, const char *filter_name, const char *filter_controls)
{
-
- int err = 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");
- return err;
+ /* Check input param */
+ if (!stream_type || !filter_name || !filter_controls) {
+ debug_error("invalid argument");
+ return MM_ERROR_INVALID_ARGUMENT;
}
- return err;
-
-}
-
+ debug_msg("stream_type(%s), filter_name(%s), filter_controls(%s)", stream_type, filter_name, filter_controls);
-EXPORT_API
-int mm_sound_play_tone(MMSoundTone_t num, int volume_config, const double volume, const int duration, int *handle)
-{
- return mm_sound_play_tone_ex(num, volume_config, volume, duration, handle, true);
+ return mm_sound_client_control_filter_by_type(stream_type, filter_name, filter_controls);
}
///////////////////////////////////
return ret;
}
-static int _convert_signal_name_str_to_enum(const char *name_str, mm_sound_signal_name_t *name_enum)
-{
- int ret = MM_ERROR_NONE;
-
- if (!name_str || !name_enum)
- return MM_ERROR_INVALID_ARGUMENT;
-
- if (!strncmp(name_str, "ReleaseInternalFocus", strlen("ReleaseInternalFocus"))) {
- *name_enum = MM_SOUND_SIGNAL_RELEASE_INTERNAL_FOCUS;
- } else {
- ret = MM_ERROR_INVALID_ARGUMENT;
- LOGE("not supported signal name(%s), err(0x%08x)", name_str, ret);
- }
- return ret;
-}
-
-static void _dbus_signal_callback(const char *signal_name, int value, void *user_data)
-{
- int ret = MM_ERROR_NONE;
- mm_sound_signal_name_t signal;
- subscribe_cb_t *subscribe_cb = (subscribe_cb_t*)user_data;
-
- debug_fenter();
-
- if (!subscribe_cb)
- return;
-
- ret = _convert_signal_name_str_to_enum(signal_name, &signal);
- if (ret)
- return;
-
- 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.
- * In this case, the second integer argument is consist of
- * |<-- 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. */
- 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 {
- debug_warning("not supported type[%d]", subscribe_cb->signal_type);
- }
-
- debug_fleave();
-
- return;
-}
-
-static void signal_callback(GDBusConnection *conn,
- const gchar *sender_name,
- const gchar *object_path,
- const gchar *interface_name,
- const gchar *signal_name,
- GVariant *parameters,
- gpointer user_data)
-{
- int value = 0;
- const GVariantType* value_type;
-
- debug_msg("sender : %s, object : %s, interface : %s, signal : %s",
- 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 : 0x08%x", value);
- _dbus_signal_callback(signal_name, value, user_data);
- } else {
- value_type = g_variant_get_type(parameters);
- debug_warning("signal type is %s", value_type);
- }
-}
-
-EXPORT_API
-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_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;
- }
-
- subscribe_cb = malloc(sizeof(subscribe_cb_t));
- if (!subscribe_cb) {
- ret = MM_ERROR_SOUND_INTERNAL;
- 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) {
- debug_error("g_bus_get_sync() error (%s) ", err ? err->message : NULL);
- g_error_free(err);
- ret = MM_ERROR_SOUND_INTERNAL;
- goto error;
- }
- 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);
-
- debug_fleave();
-
- return ret;
-
-error:
- if (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_type, int client_pid, unsigned int *subscribe_id,
- mm_sound_signal_callback callback, void *user_data)
+int mm_sound_add_ducking_state_changed_callback(mm_sound_ducking_state_changed_cb func, void *user_data, unsigned int *subs_id)
{
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_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;
+ if (func == NULL || subs_id == NULL) {
+ debug_error("argument is not valid");
+ return MM_ERROR_INVALID_ARGUMENT;
}
- subscribe_cb = malloc(sizeof(subscribe_cb_t));
- if (!subscribe_cb) {
- ret = MM_ERROR_SOUND_INTERNAL;
- 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) {
- debug_error("g_bus_get_sync() error (%s) ", err ? err->message : NULL);
- g_error_free(err);
- ret = MM_ERROR_SOUND_INTERNAL;
- goto error;
- }
- 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;
+ ret = mm_sound_client_add_ducking_state_changed_callback(func, user_data, subs_id);
+ if (ret < 0) {
+ debug_error("Can not add ducking state changed callback, ret = %x", ret);
}
- subscribe_cb->id = subs_id;
- *subscribe_id = subs_id;
-
- MMSOUND_LEAVE_CRITICAL_SECTION(&g_subscribe_cb_list_mutex);
-
- debug_fleave();
-
- return ret;
-
-error:
- if (subscribe_cb)
- free(subscribe_cb);
-
- MMSOUND_LEAVE_CRITICAL_SECTION(&g_subscribe_cb_list_mutex);
return ret;
}
EXPORT_API
-void mm_sound_unsubscribe_signal(unsigned int subscribe_id)
-{
- 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);
- }
-
- MMSOUND_LEAVE_CRITICAL_SECTION(&g_subscribe_cb_list_mutex);
-
- debug_fleave();
-}
-
-EXPORT_API
-int mm_sound_send_signal(mm_sound_signal_name_t signal_type, int value)
+int mm_sound_remove_ducking_state_changed_callback(unsigned int subs_id)
{
int ret = MM_ERROR_NONE;
- GError *err = NULL;
- GDBusConnection *conn = NULL;
- gboolean dbus_ret = TRUE;
-
- debug_fenter();
-
- MMSOUND_ENTER_CRITICAL_SECTION_WITH_RETURN(&g_subscribe_cb_list_mutex, MM_ERROR_SOUND_INTERNAL);
-
- if (signal_type >= MM_SOUND_SIGNAL_MAX) {
- debug_error("invalid argument, signal(%d)", signal_type);
- ret = MM_ERROR_INVALID_ARGUMENT;
- goto error;
- }
-
- conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
- if (!conn || err) {
- debug_error("g_bus_get_sync() error (%s)", err ? err->message : NULL);
- ret = MM_ERROR_SOUND_INTERNAL;
- goto error;
- }
-
- 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). */
- value |= ((int)getpid() << 16);
- if ((_mm_session_util_write_information((int)getpid(), MM_SESSION_TYPE_REPLACED_BY_STREAM, 0)))
- 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_type],
- g_variant_new("(i)", value),
- &err);
- if (!dbus_ret || err) {
- debug_error("g_dbus_connection_emit_signal() error (%s)", err ? err->message : NULL);
- ret = MM_ERROR_SOUND_INTERNAL;
- goto error;
- }
- dbus_ret = g_dbus_connection_flush_sync(conn, NULL, &err);
- if (!dbus_ret || err) {
- debug_error("g_dbus_connection_flush_sync() error (%s)", err ? err->message : NULL);
- ret = MM_ERROR_SOUND_INTERNAL;
- goto error;
+ ret = mm_sound_client_remove_ducking_state_changed_callback(subs_id);
+ if (ret < 0) {
+ debug_error("Can not remove ducking state changed callback, ret = %x", ret);
}
- g_object_unref(conn);
- debug_msg("sending signal[%s], value[%d] success", dbus_signal_name_str[signal_type], value);
-
- MMSOUND_LEAVE_CRITICAL_SECTION(&g_subscribe_cb_list_mutex);
-
- debug_fleave();
-
- return ret;
-
-error:
- if (err)
- g_error_free(err);
- if (conn)
- g_object_unref(conn);
-
- MMSOUND_LEAVE_CRITICAL_SECTION(&g_subscribe_cb_list_mutex);
-
- return ret;
-}
-
-EXPORT_API
-int mm_sound_get_signal_value(mm_sound_signal_name_t signal_type, int *value)
-{
- int ret = MM_ERROR_NONE;
-
- debug_fenter();
-
- MMSOUND_ENTER_CRITICAL_SECTION_WITH_RETURN(&g_subscribe_cb_list_mutex, MM_ERROR_SOUND_INTERNAL);
-
- *value = g_dbus_signal_values[signal_type];
-
- MMSOUND_LEAVE_CRITICAL_SECTION(&g_subscribe_cb_list_mutex);
-
- debug_fleave();
-
return ret;
}
EXPORT_API
void mm_sound_dotnet_cleanup(int signo)
{
- debug_warning("Dotnet cleanup %d : Start", signo);
- mm_sound_client_cleanup();
- debug_warning("Dotnet cleanup %d : End", signo);
}
#endif
projects / platform / core / multimedia / libmm-sound.git / blobdiff