4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Seungbae Shin <seungbae.shin@samsung.com>
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
32 #include <mm_session_private.h>
34 #include "include/mm_sound_private.h"
35 #include "include/mm_sound_utils.h"
36 #include "include/mm_sound_client.h"
37 #include "include/mm_sound_pa_client.h"
38 #include "include/mm_sound_common.h"
41 #define VOLUME_MAX_MULTIMEDIA 16
42 #define VOLUME_MAX_BASIC 8
43 #define VOLUME_MAX_SINGLE 1
46 #define MASTER_VOLUME_MAX 100
47 #define MASTER_VOLUME_MIN 0
51 static GList *g_subscribe_cb_list = NULL;
52 static pthread_mutex_t g_subscribe_cb_list_mutex = PTHREAD_MUTEX_INITIALIZER;
54 #define MM_SOUND_DBUS_BUS_NAME_PREPIX "org.tizen.MMSound"
55 #define MM_SOUND_DBUS_OBJECT_PATH "/org/tizen/MMSound"
56 #define MM_SOUND_DBUS_INTERFACE "org.tizen.mmsound"
58 GDBusConnection *g_dbus_conn_mmsound;
60 int g_dbus_signal_values[MM_SOUND_SIGNAL_MAX] = {0,};
62 const char* dbus_signal_name_str[] = {
63 "ReleaseInternalFocus",
66 typedef struct _subscribe_cb {
67 mm_sound_signal_name_t signal_type;
68 mm_sound_signal_callback callback;
74 static const char* _get_volume_str (volume_type_t type)
76 static const char *volume_type_str[VOLUME_TYPE_MAX] =
77 { "SYSTEM", "NOTIFICATION", "ALARM", "RINGTONE", "MEDIA", "CALL", "VOIP", "VOICE", "FIXED"};
79 return (type >= VOLUME_TYPE_SYSTEM && type < VOLUME_TYPE_MAX)? volume_type_str[type] : "Unknown";
82 static int _validate_volume(volume_type_t type, int value)
89 case VOLUME_TYPE_CALL:
90 case VOLUME_TYPE_VOIP:
91 if (value >= VOLUME_MAX_BASIC) {
95 case VOLUME_TYPE_SYSTEM:
96 case VOLUME_TYPE_MEDIA:
97 case VOLUME_TYPE_ALARM:
98 case VOLUME_TYPE_NOTIFICATION:
99 case VOLUME_TYPE_RINGTONE:
100 case VOLUME_TYPE_VOICE:
101 if (value >= VOLUME_MAX_MULTIMEDIA) {
113 int mm_sound_volume_remove_callback(volume_type_t type)
115 /* FIXME : Will be removed */
116 return MM_ERROR_NOT_SUPPORT_API;
120 int mm_sound_add_volume_changed_callback(mm_sound_volume_changed_cb func, void* user_data, unsigned int *subs_id)
122 int ret = MM_ERROR_NONE;
124 if (func == NULL || subs_id == NULL) {
125 debug_error("argument is not valid\n");
126 return MM_ERROR_INVALID_ARGUMENT;
129 ret = mm_sound_client_add_volume_changed_callback(func, user_data, subs_id);
131 debug_error("Can not add volume changed callback, ret = %x\n", ret);
138 int mm_sound_remove_volume_changed_callback(unsigned int subs_id)
140 int ret = MM_ERROR_NONE;
142 ret = mm_sound_client_remove_volume_changed_callback(subs_id);
144 debug_error("Can not remove volume changed callback, ret = %x\n", ret);
151 int mm_sound_volume_set_value(volume_type_t volume_type, const unsigned int volume_level)
153 int ret = MM_ERROR_NONE;
155 debug_msg("type = (%d)%s, value = %d", volume_type, _get_volume_str(volume_type), volume_level);
157 /* Check input param */
158 if (0 > _validate_volume(volume_type, (int)volume_level)) {
159 debug_error("invalid volume type %d, value %u\n", volume_type, volume_level);
160 return MM_ERROR_INVALID_ARGUMENT;
163 ret = mm_sound_util_volume_set_value_by_type(volume_type, volume_level);
164 if (ret == MM_ERROR_NONE) {
165 /* update shared memory value */
166 if(MM_ERROR_NONE != mm_sound_client_set_volume_by_type(volume_type, volume_level)) {
167 debug_error("Can not set volume to shared memory 0x%x\n", ret);
175 int mm_sound_volume_get_value(volume_type_t type, unsigned int *value)
177 int ret = MM_ERROR_NONE;
179 /* Check input param */
181 debug_error("invalid argument\n");
182 return MM_ERROR_INVALID_ARGUMENT;
184 if (type < 0 || type >= VOLUME_TYPE_MAX) {
185 debug_error("invalid volume type value %d\n", type);
186 return MM_ERROR_INVALID_ARGUMENT;
189 ret = mm_sound_util_volume_get_value_by_type(type, value);
191 debug_msg("returned %s = %d", _get_volume_str(type), *value);
196 int mm_sound_volume_primary_type_set(volume_type_t type)
198 int ret = MM_ERROR_NONE;
200 /* Check input param */
201 if(type < VOLUME_TYPE_UNKNOWN || type >= VOLUME_TYPE_MAX) {
202 debug_error("invalid argument\n");
203 return MM_ERROR_INVALID_ARGUMENT;
206 if (vconf_set_int(VCONFKEY_SOUND_PRIMARY_VOLUME_TYPE, type)) {
207 debug_error("could not set vconf for RIMARY_VOLUME_TYPE\n");
208 ret = MM_ERROR_SOUND_INTERNAL;
210 debug_msg("set primary volume type forcibly %d(%s)", type, _get_volume_str(type));
217 int mm_sound_volume_primary_type_get(volume_type_t *type)
219 int ret = MM_ERROR_NONE;
220 int voltype = VOLUME_TYPE_RINGTONE;
222 /* Check input param */
224 debug_error("invalid argument\n");
225 return MM_ERROR_INVALID_ARGUMENT;
228 /* check force set */
229 if (vconf_get_int(VCONFKEY_SOUND_PRIMARY_VOLUME_TYPE, &voltype)) {
230 debug_error("could not get vconf for PRIMARY_VOLUME_TYPE\n");
231 ret = MM_ERROR_SOUND_INTERNAL;
233 debug_msg("get primary volume type %d(%s)", voltype, _get_volume_str(voltype));
240 ///////////////////////////////////
241 //// MMSOUND PLAY APIs
242 ///////////////////////////////////
243 static inline void _mm_sound_fill_play_param(MMSoundPlayParam *param, const char *filename, int volume_config, mm_sound_stop_callback_func callback, void *data)
245 param->filename = filename;
246 param->volume = 0; //volume value dose not effect anymore
247 param->callback = callback;
250 param->volume_config = volume_config;
254 int mm_sound_play_loud_solo_sound(const char *filename, int volume_config, mm_sound_stop_callback_func callback, void *data, int *handle)
256 MMSoundPlayParam param = { 0, };
258 /* FIXME : this function will be deleted */
259 _mm_sound_fill_play_param(¶m, filename, volume_config, callback, data);
260 return mm_sound_play_sound_ex(¶m, handle);
264 int mm_sound_play_sound(const char *filename, int volume_config, mm_sound_stop_callback_func callback, void *data, int *handle)
266 MMSoundPlayParam param = { 0, };
268 _mm_sound_fill_play_param(¶m, filename, volume_config, callback, data);
269 return mm_sound_play_sound_ex(¶m, handle);
273 int mm_sound_play_sound_ex(MMSoundPlayParam *param, int *handle)
278 /* Check input param */
280 debug_error("param is null\n");
281 return MM_ERROR_INVALID_ARGUMENT;
284 volume_type = MM_SOUND_VOLUME_CONFIG_TYPE(param->volume_config);
286 if (param->filename == NULL) {
287 debug_error("filename is NULL\n");
288 return MM_ERROR_SOUND_FILE_NOT_FOUND;
290 if (volume_type < 0 || volume_type >= VOLUME_TYPE_MAX) {
291 debug_error("Volume type is invalid %d\n", volume_type);
292 return MM_ERROR_INVALID_ARGUMENT;
296 err = mm_sound_client_play_sound(param, 0, &lhandle);
298 debug_error("Failed to play sound\n");
302 /* Set handle to return */
306 debug_critical("The sound hadle cannot be get [%d]\n", lhandle);
309 debug_warning ("success : handle=[%p]\n", handle);
311 return MM_ERROR_NONE;
315 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)
317 MMSoundPlayParam param = { 0, };
320 param.filename = filename;
321 param.volume = 0; //volume value dose not effect anymore
322 param.callback = callback;
330 err = mm_sound_client_play_sound_with_stream_info(¶m, handle, stream_type, stream_id);
332 debug_error("Failed to play sound\n");
336 debug_warning ("success : handle=[%p]\n", handle);
338 return MM_ERROR_NONE;
344 int mm_sound_stop_sound(int handle)
348 debug_warning ("enter : handle=[%d]\n", handle);
350 err = mm_sound_client_stop_sound(handle);
352 debug_error("Fail to stop sound\n");
355 debug_warning ("success : handle=[%d]\n", handle);
357 return MM_ERROR_NONE;
360 ///////////////////////////////////
361 //// MMSOUND TONE APIs
362 ///////////////////////////////////
364 int mm_sound_play_tone_ex (MMSoundTone_t num, int volume_config, const double volume, const int duration, int *handle, bool enable_session)
367 int err = MM_ERROR_NONE;
368 int volume_type = MM_SOUND_VOLUME_CONFIG_TYPE(volume_config);
372 /* Check input param */
374 debug_error("number is invalid %d\n", duration);
375 return MM_ERROR_INVALID_ARGUMENT;
377 if (num < MM_SOUND_TONE_DTMF_0 || num >= MM_SOUND_TONE_NUM) {
378 debug_error("TONE Value is invalid %d\n", num);
379 return MM_ERROR_INVALID_ARGUMENT;
381 if (volume_type < 0 || volume_type >= VOLUME_TYPE_MAX) {
382 debug_error("Volume type is invalid %d\n", volume_type);
383 return MM_ERROR_INVALID_ARGUMENT;
385 if (volume < 0.0 || volume > 1.0) {
386 debug_error("Volume Value is invalid %d\n", volume);
387 return MM_ERROR_INVALID_ARGUMENT;
391 debug_msg("Call MMSoundClientPlayTone\n");
392 err = mm_sound_client_play_tone(num, volume_config, volume, duration, &lhandle, enable_session);
394 debug_error("Failed to play sound\n");
398 /* Set handle to return */
402 debug_critical("The sound handle cannot be get [%d]\n", lhandle);
405 return MM_ERROR_NONE;
409 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)
412 int err = MM_ERROR_NONE;
414 err = mm_sound_client_play_tone_with_stream_info(tone, stream_type, stream_id, volume, duration, handle);
416 debug_error("Failed to play sound\n");
426 int mm_sound_play_tone (MMSoundTone_t num, int volume_config, const double volume, const int duration, int *handle)
428 return mm_sound_play_tone_ex (num, volume_config, volume, duration, handle, true);
431 ///////////////////////////////////
432 //// MMSOUND ROUTING APIs
433 ///////////////////////////////////
436 int mm_sound_test(int a, int b, int* getv)
438 int ret = MM_ERROR_NONE;
440 debug_log("mm_sound_test enter");
442 debug_error("argu null");
443 return MM_ERROR_INVALID_ARGUMENT;
445 ret = mm_sound_client_test(a, b, getv);
447 debug_error("Can not mm sound test, ret = %x\n", ret);
449 debug_log("mm_sound_test leave");
455 int mm_sound_add_test_callback(mm_sound_test_cb func, void *user_data, unsigned int *subs_id)
457 int ret = MM_ERROR_NONE;
459 debug_log("mm_sound_add_test_callback enter");
460 if (!func || !subs_id) {
461 debug_error("argument is not valid\n");
462 return MM_ERROR_INVALID_ARGUMENT;
465 ret = mm_sound_client_add_test_callback(func, user_data, subs_id);
467 debug_error("Can not add test callback, ret = %x\n", ret);
469 debug_log("mm_sound_add_test_callback leave");
475 int mm_sound_remove_test_callback(unsigned int subs_id)
477 int ret = MM_ERROR_NONE;
479 debug_log("mm_sound_remove_test_callback enter");
480 ret = mm_sound_client_remove_test_callback(subs_id);
482 debug_error("Can not remove test callback, ret = %x\n", ret);
484 debug_log("mm_sound_remove_test_callback leave");
489 static int _convert_signal_name_str_to_enum (const char *name_str, mm_sound_signal_name_t *name_enum) {
490 int ret = MM_ERROR_NONE;
492 if (!name_str || !name_enum)
493 return MM_ERROR_INVALID_ARGUMENT;
495 if (!strncmp(name_str, "ReleaseInternalFocus", strlen("ReleaseInternalFocus"))) {
496 *name_enum = MM_SOUND_SIGNAL_RELEASE_INTERNAL_FOCUS;
498 ret = MM_ERROR_INVALID_ARGUMENT;
499 LOGE("not supported signal name(%s), err(0x%08x)", name_str, ret);
504 static void _dbus_signal_callback (const char *signal_name, int value, void *user_data)
506 int ret = MM_ERROR_NONE;
507 mm_sound_signal_name_t signal;
508 subscribe_cb_t *subscribe_cb = (subscribe_cb_t*)user_data;
515 ret = _convert_signal_name_str_to_enum(signal_name, &signal);
519 debug_msg("signal: name[%s], value[%d], user_data[%p], type[%d]\n",
520 signal_name, value, user_data, subscribe_cb->signal_type);
522 if (subscribe_cb->signal_type == MM_SOUND_SIGNAL_RELEASE_INTERNAL_FOCUS) {
523 /* Trigger the signal callback when it comes from the same process.
524 * In this case, the second integer argument is consist of
525 * |<-- pid (16bits) -->|<-- value (16bits) -->|,
526 * FYI, #define PID_MAX_DEFAULT (CONFIG_BASE_SMALL ? 0x1000 : 0x8000).
527 * In case of daemon usage, it uses the client_pid of subscribe_cb. */
528 debug_msg ("client_pid[%d], getpid[%d], value>>16[%d], callback[%p]\n",
529 subscribe_cb->client_pid, getpid(), (value >> 16), subscribe_cb);
530 if ((subscribe_cb->client_pid ? subscribe_cb->client_pid : getpid()) == (value >> 16))
531 subscribe_cb->callback(signal, (value & 0x0000FFFF), subscribe_cb->user_data);
533 debug_warning("not supported type[%d]\n", subscribe_cb->signal_type);
541 static void signal_callback(GDBusConnection *conn,
542 const gchar *sender_name,
543 const gchar *object_path,
544 const gchar *interface_name,
545 const gchar *signal_name,
546 GVariant *parameters,
550 const GVariantType* value_type;
552 debug_msg ("sender : %s, object : %s, interface : %s, signal : %s",
553 sender_name, object_path, interface_name, signal_name);
554 if (g_variant_is_of_type(parameters, G_VARIANT_TYPE("(i)"))) {
555 g_variant_get(parameters, "(i)",&value);
556 debug_msg(" - value : %d\n", value);
557 _dbus_signal_callback(signal_name, value, user_data);
559 value_type = g_variant_get_type(parameters);
560 debug_warning("signal type is %s", value_type);
565 int mm_sound_subscribe_signal(mm_sound_signal_name_t signal, unsigned int *subscribe_id, mm_sound_signal_callback callback, void *user_data)
567 int ret = MM_ERROR_NONE;
570 subscribe_cb_t *subscribe_cb = NULL;
574 MMSOUND_ENTER_CRITICAL_SECTION_WITH_RETURN(&g_subscribe_cb_list_mutex, MM_ERROR_SOUND_INTERNAL);
576 if (signal < 0 || signal >= MM_SOUND_SIGNAL_MAX || !subscribe_id) {
577 debug_error ("invalid argument, signal(%d), subscribe_id(0x%p)", signal, subscribe_id);
578 ret = MM_ERROR_INVALID_ARGUMENT;
582 subscribe_cb = malloc(sizeof(subscribe_cb_t));
584 ret = MM_ERROR_SOUND_INTERNAL;
587 memset(subscribe_cb, 0, sizeof(subscribe_cb_t));
589 g_dbus_conn_mmsound = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
590 if (!g_dbus_conn_mmsound && err) {
591 debug_error ("g_bus_get_sync() error (%s) ", err->message);
593 ret = MM_ERROR_SOUND_INTERNAL;
597 subscribe_cb->signal_type = signal;
598 subscribe_cb->callback = callback;
599 subscribe_cb->user_data = user_data;
601 *subscribe_id = g_dbus_connection_signal_subscribe(g_dbus_conn_mmsound,
602 NULL, MM_SOUND_DBUS_INTERFACE, dbus_signal_name_str[signal], MM_SOUND_DBUS_OBJECT_PATH, NULL, 0,
603 signal_callback, subscribe_cb, NULL);
604 if (*subscribe_id == 0) {
605 debug_error ("g_dbus_connection_signal_subscribe() error (%d)", *subscribe_id);
606 ret = MM_ERROR_SOUND_INTERNAL;
610 subscribe_cb->id = *subscribe_id;
612 g_subscribe_cb_list = g_list_append(g_subscribe_cb_list, subscribe_cb);
613 if (g_subscribe_cb_list) {
614 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);
616 debug_error("g_list_append failed\n");
617 ret = MM_ERROR_SOUND_INTERNAL;
621 MMSOUND_LEAVE_CRITICAL_SECTION(&g_subscribe_cb_list_mutex);
628 g_dbus_connection_signal_unsubscribe(g_dbus_conn_mmsound, *subscribe_id);
629 g_object_unref(g_dbus_conn_mmsound);
635 MMSOUND_LEAVE_CRITICAL_SECTION(&g_subscribe_cb_list_mutex);
641 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)
643 int ret = MM_ERROR_NONE;
646 subscribe_cb_t *subscribe_cb = NULL;
650 MMSOUND_ENTER_CRITICAL_SECTION_WITH_RETURN(&g_subscribe_cb_list_mutex, MM_ERROR_SOUND_INTERNAL);
652 if (signal < 0 || signal >= MM_SOUND_SIGNAL_MAX || !client_pid || !subscribe_id) {
653 debug_error ("invalid argument, signal(%d), client_pid(%d), subscribe_id(0x%p)", signal, client_pid, subscribe_id);
654 ret = MM_ERROR_INVALID_ARGUMENT;
658 subscribe_cb = malloc(sizeof(subscribe_cb_t));
660 ret = MM_ERROR_SOUND_INTERNAL;
663 memset(subscribe_cb, 0, sizeof(subscribe_cb_t));
665 g_dbus_conn_mmsound = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
666 if (!g_dbus_conn_mmsound && err) {
667 debug_error ("g_bus_get_sync() error (%s) ", err->message);
669 ret = MM_ERROR_SOUND_INTERNAL;
673 subscribe_cb->signal_type = signal;
674 subscribe_cb->callback = callback;
675 subscribe_cb->user_data = user_data;
676 subscribe_cb->client_pid = client_pid;
678 *subscribe_id = g_dbus_connection_signal_subscribe(g_dbus_conn_mmsound,
679 NULL, MM_SOUND_DBUS_INTERFACE, dbus_signal_name_str[signal], MM_SOUND_DBUS_OBJECT_PATH, NULL, 0,
680 signal_callback, subscribe_cb, NULL);
681 if (*subscribe_id == 0) {
682 debug_error ("g_dbus_connection_signal_subscribe() error (%d)", *subscribe_id);
683 ret = MM_ERROR_SOUND_INTERNAL;
687 subscribe_cb->id = *subscribe_id;
689 g_subscribe_cb_list = g_list_append(g_subscribe_cb_list, subscribe_cb);
690 if (g_subscribe_cb_list) {
691 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);
693 debug_error("g_list_append failed\n");
694 ret = MM_ERROR_SOUND_INTERNAL;
698 MMSOUND_LEAVE_CRITICAL_SECTION(&g_subscribe_cb_list_mutex);
705 g_dbus_connection_signal_unsubscribe(g_dbus_conn_mmsound, *subscribe_id);
706 g_object_unref(g_dbus_conn_mmsound);
712 MMSOUND_LEAVE_CRITICAL_SECTION(&g_subscribe_cb_list_mutex);
718 void mm_sound_unsubscribe_signal(unsigned int subscribe_id)
721 subscribe_cb_t *subscribe_cb = NULL;
725 MMSOUND_ENTER_CRITICAL_SECTION(&g_subscribe_cb_list_mutex);
727 if (g_dbus_conn_mmsound && subscribe_id) {
728 g_dbus_connection_signal_unsubscribe(g_dbus_conn_mmsound, subscribe_id);
729 g_object_unref(g_dbus_conn_mmsound);
730 for (list = g_subscribe_cb_list; list != NULL; list = list->next) {
731 subscribe_cb = (subscribe_cb_t *)list->data;
732 if (subscribe_cb && (subscribe_cb->id == subscribe_id)) {
733 g_subscribe_cb_list = g_list_remove(g_subscribe_cb_list, subscribe_cb);
734 debug_log("subscribe_cb(0x%x) is removed\n", subscribe_cb);
740 MMSOUND_LEAVE_CRITICAL_SECTION(&g_subscribe_cb_list_mutex);
746 int mm_sound_send_signal(mm_sound_signal_name_t signal, int value)
748 int ret = MM_ERROR_NONE;
750 GDBusConnection *conn = NULL;
751 gboolean dbus_ret = TRUE;
755 MMSOUND_ENTER_CRITICAL_SECTION_WITH_RETURN(&g_subscribe_cb_list_mutex, MM_ERROR_SOUND_INTERNAL);
757 if (signal < 0 || signal >= MM_SOUND_SIGNAL_MAX) {
758 debug_error ("invalid argument, signal(%d)", signal);
759 ret = MM_ERROR_INVALID_ARGUMENT;
763 conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
765 debug_error ("g_bus_get_sync() error (%s)", err->message);
766 ret = MM_ERROR_SOUND_INTERNAL;
770 g_dbus_signal_values[signal] = value;
771 if (signal == MM_SOUND_SIGNAL_RELEASE_INTERNAL_FOCUS) {
772 /* Trigger the signal callback when it comes from the same process.
773 * |<-- pid (16bits) -->|<-- value (16bits) -->|,
774 * FYI, #define PID_MAX_DEFAULT (CONFIG_BASE_SMALL ? 0x1000 : 0x8000). */
775 value |= ((int)getpid() << 16);
776 if ((_mm_session_util_write_information((int)getpid(), MM_SESSION_TYPE_REPLACED_BY_STREAM, 0)))
777 debug_error ("failed to _mm_session_util_write_information for MM_SESSION_TYPE_REPLACED_BY_STREAM");
779 dbus_ret = g_dbus_connection_emit_signal (conn,
780 NULL, MM_SOUND_DBUS_OBJECT_PATH, MM_SOUND_DBUS_INTERFACE, dbus_signal_name_str[signal],
781 g_variant_new ("(i)", value),
783 if (!dbus_ret && err) {
784 debug_error ("g_dbus_connection_emit_signal() error (%s)", err->message);
785 ret = MM_ERROR_SOUND_INTERNAL;
789 dbus_ret = g_dbus_connection_flush_sync(conn, NULL, &err);
790 if (!dbus_ret && err) {
791 debug_error ("g_dbus_connection_flush_sync() error (%s)", err->message);
792 ret = MM_ERROR_SOUND_INTERNAL;
796 g_object_unref(conn);
797 debug_msg ("sending signal[%s], value[%d] success", dbus_signal_name_str[signal], value);
799 MMSOUND_LEAVE_CRITICAL_SECTION(&g_subscribe_cb_list_mutex);
809 g_object_unref(conn);
811 MMSOUND_LEAVE_CRITICAL_SECTION(&g_subscribe_cb_list_mutex);
817 int mm_sound_get_signal_value(mm_sound_signal_name_t signal, int *value)
819 int ret = MM_ERROR_NONE;
823 MMSOUND_ENTER_CRITICAL_SECTION_WITH_RETURN(&g_subscribe_cb_list_mutex, MM_ERROR_SOUND_INTERNAL);
825 *value = g_dbus_signal_values[signal];
827 MMSOUND_LEAVE_CRITICAL_SECTION(&g_subscribe_cb_list_mutex);
834 __attribute__ ((constructor))
835 static void _mm_sound_initialize(void)
837 mm_sound_client_initialize();
841 __attribute__ ((destructor))
842 static void _mm_sound_finalize(void)
844 mm_sound_client_finalize();