mm_sound_proxy.c

   1 #include <stdint.h>
   2 #include <glib.h>
   3
   4 #ifdef TIZEN_TV
   5 #include <vconf.h>
   6 #endif
   7
   8 #include <mm_error.h>
   9 #include <mm_debug.h>
  10
  11 #include "include/mm_sound_proxy.h"
  12 #include "include/mm_sound_common.h"
  13 #include "include/mm_sound_dbus.h"
  14 #include "include/mm_sound_intf.h"
  15 #include "include/mm_sound_focus_socket.h"
  16 #include "include/mm_sound_focus_private.h"
  17
  18 struct callback_data {
  19         void *user_cb;
  20         void *user_data;
  21         mm_sound_proxy_userdata_free free_func;
  22         uint32_t subs_id;
  23 };
  24
  25 #define CB_DATA_NEW(_cb_data, _func, _userdata, _freefunc) \
  26         do { \
  27                 _cb_data = (struct callback_data*) g_malloc0(sizeof(struct callback_data)); \
  28                 _cb_data->user_cb = _func; \
  29                 _cb_data->user_data = _userdata; \
  30                 _cb_data->free_func = _freefunc; \
  31                 _cb_data->subs_id = 0; \
  32         } while (0)
  33
  34 /* subscribe is true when add callback,
  35  * false when remove callback */
  36 static int _notify_subscription(audio_event_t event, uint32_t subs_id, gboolean subscribe)
  37 {
  38         int ret = MM_ERROR_NONE;
  39         GVariant *params = NULL;
  40         const char *event_name = NULL;
  41
  42         debug_fenter();
  43
  44         if ((ret = mm_sound_dbus_get_event_name(event, &event_name)) != MM_ERROR_NONE) {
  45                 debug_error("Failed to get event name");
  46                 return MM_ERROR_SOUND_INTERNAL;
  47         }
  48
  49         if (!(params = g_variant_new("(sub)", event_name, subs_id, subscribe))) {
  50                 debug_error("Construct Param failed");
  51                 return MM_ERROR_SOUND_INTERNAL;
  52         }
  53
  54         if ((ret = mm_sound_dbus_emit_signal(AUDIO_PROVIDER_AUDIO_CLIENT, AUDIO_EVENT_CLIENT_SUBSCRIBED, params)))
  55                 debug_error("dbus send signal for client subscribed failed");
  56
  57         debug_fleave();
  58         return ret;
  59 }
  60
  61 static int _notify_signal_handled(audio_event_t event, uint32_t event_id, uint32_t subs_id, GVariant *signal_params)
  62 {
  63         int ret = MM_ERROR_NONE;
  64         GVariant *params = NULL;
  65         const char *event_name = NULL;
  66
  67         debug_fenter();
  68
  69         if ((ret = mm_sound_dbus_get_event_name(event, &event_name)) != MM_ERROR_NONE) {
  70                 debug_error("Failed to get event name");
  71                 return MM_ERROR_SOUND_INTERNAL;
  72         }
  73
  74         if (!(params = g_variant_new("(usuv)", event_id, event_name, subs_id, signal_params))) {
  75                 debug_error("Construct Param failed");
  76                 return MM_ERROR_SOUND_INTERNAL;
  77         }
  78
  79         if ((ret = mm_sound_dbus_emit_signal(AUDIO_PROVIDER_AUDIO_CLIENT, AUDIO_EVENT_CLIENT_HANDLED, params)))
  80                 debug_error("dbus send signal for client handled failed");
  81
  82         debug_fleave();
  83         return ret;
  84 }
  85
  86 static int parse_device_variant(GVariant *v, int *device_id, const char **device_type, int *direction, int *state,
  87                                                 const char **device_name, int *vendor_id, int *product_id, gboolean *is_running, int *stream_id, int *stream_num)
  88 {
  89         const char *v_type;
  90         GVariant *array_v;
  91         GVariantIter iter, array_iter;
  92         int i = 0;
  93         int ret = MM_ERROR_NONE;
  94
  95         if (v == NULL) {
  96                 debug_error("Variant NULL");
  97                 return MM_ERROR_NONE;
  98         }
  99
 100         v_type = g_variant_get_type_string(v);
 101         if (g_variant_type_equal(v_type, "(isiisiibai)") == FALSE) {
 102                 debug_error("device variant type not matching '%s'", v_type);
 103                 return MM_ERROR_NONE;
 104         }
 105
 106         g_variant_iter_init(&iter, v);
 107         g_variant_iter_next(&iter, "i", device_id);
 108         g_variant_iter_next(&iter, "&s", device_type);
 109         g_variant_iter_next(&iter, "i", direction);
 110         g_variant_iter_next(&iter, "i", state);
 111         g_variant_iter_next(&iter, "&s", device_name);
 112         g_variant_iter_next(&iter, "i", vendor_id);
 113         g_variant_iter_next(&iter, "i", product_id);
 114         g_variant_iter_next(&iter, "b", is_running);
 115
 116         array_v = g_variant_iter_next_value(&iter);
 117         *stream_num = g_variant_iter_init(&array_iter, array_v);
 118         if (*stream_num > MAX_STREAM_ON_DEVICE) {
 119                 debug_error("too many streams on device %d", *stream_num);
 120                 ret = MM_ERROR_SOUND_INTERNAL;
 121                 goto finish;
 122         }
 123
 124         while (g_variant_iter_loop(&array_iter, "i", &stream_id[i++])) ;
 125 finish:
 126         g_variant_unref(array_v);
 127
 128         return ret;
 129 }
 130
 131 /* This callback unmarshall general-formed paramters to subject specific parameters,
 132  * and call proper callback */
 133 static void dbus_callback(audio_event_t event, GVariant *params, void *userdata)
 134 {
 135         struct callback_data *cb_data  = (struct callback_data*) userdata;
 136         uint32_t event_id;
 137         const char *name = NULL, *device_type = NULL;
 138         int device_id, direction, state;
 139         const gchar *v_type;
 140         GVariantIter iter;
 141         GVariant *device_v;
 142         int stream_id[MAX_STREAM_ON_DEVICE];
 143         int stream_num;
 144         int vendor_id, product_id;
 145         gboolean is_running = FALSE;
 146
 147         v_type = g_variant_get_type_string(params);
 148
 149         if (event == AUDIO_EVENT_VOLUME_CHANGED) {
 150                 char *volume_type_str = NULL, *direction = NULL;
 151                 unsigned volume_level;
 152
 153                 g_variant_get(params, "(&s&su)", &direction, &volume_type_str, &volume_level);
 154                 ((mm_sound_volume_changed_wrapper_cb)(cb_data->user_cb))(direction, volume_type_str, volume_level, cb_data->user_data);
 155         } else if (event == AUDIO_EVENT_DEVICE_CONNECTED) {
 156                 gboolean is_connected = FALSE;
 157
 158                 if (g_variant_type_equal(v_type, "(u(isiisiibai)b)") == FALSE) {
 159                         debug_error("Device connection changed signature not matching : %s", v_type);
 160                         return ;
 161                 }
 162                 g_variant_iter_init(&iter, params);
 163                 g_variant_iter_next(&iter, "u", &event_id);
 164                 device_v = g_variant_iter_next_value(&iter);
 165                 if (parse_device_variant(device_v, &device_id, &device_type, &direction, &state,
 166                                                         &name, &vendor_id, &product_id, &is_running, stream_id, &stream_num) < 0) {
 167                         debug_error("Failed to parse device variant");
 168                         return ;
 169                 }
 170                 g_variant_iter_next(&iter, "b", &is_connected);
 171
 172                 ((mm_sound_device_connected_wrapper_cb)(cb_data->user_cb))(device_id, device_type, direction,
 173                         state, name, vendor_id, product_id, (bool)is_running, stream_id, stream_num, (bool)is_connected, cb_data->user_data);
 174                 _notify_signal_handled(event, event_id, cb_data->subs_id, g_variant_new("(ib)", device_id, (bool)is_connected));
 175         } else if (event == AUDIO_EVENT_DEVICE_INFO_CHANGED) {
 176                 int changed_device_info_type = 0;
 177
 178                 if (g_variant_type_equal(v_type, "(u(isiisiibai)i)") == FALSE) {
 179                         debug_error("Device information changed signature not matching : %s", v_type);
 180                         return ;
 181                 }
 182
 183                 g_variant_iter_init(&iter, params);
 184                 g_variant_iter_next(&iter, "u", &event_id);
 185                 device_v = g_variant_iter_next_value(&iter);
 186                 if (parse_device_variant(device_v, &device_id, &device_type, &direction, &state,
 187                                                         &name, &vendor_id, &product_id, &is_running, stream_id, &stream_num) < 0) {
 188                         debug_error("Failed to parse device variant");
 189                         return ;
 190                 }
 191                 g_variant_iter_next(&iter, "i", &changed_device_info_type);
 192
 193                 ((mm_sound_device_info_changed_wrapper_cb)(cb_data->user_cb))(device_id, device_type, direction,
 194                         state, name, vendor_id, product_id, (bool)is_running, stream_id, stream_num, changed_device_info_type, cb_data->user_data);
 195         } else if (event == AUDIO_EVENT_DEVICE_STATE_CHANGED) {
 196
 197                 if (g_variant_type_equal(v_type, "(u(isiisiibai))") == FALSE) {
 198                         debug_error("Device state changed signature not matching : %s", v_type);
 199                         return ;
 200                 }
 201
 202                 g_variant_iter_init(&iter, params);
 203                 g_variant_iter_next(&iter, "u", &event_id);
 204                 device_v = g_variant_iter_next_value(&iter);
 205                 if (parse_device_variant(device_v, &device_id, &device_type, &direction, &state,
 206                                                         &name, &vendor_id, &product_id, &is_running, stream_id, &stream_num) < 0) {
 207                         debug_error("Failed to parse device variant");
 208                         return ;
 209                 }
 210
 211                 ((mm_sound_device_state_changed_wrapper_cb)(cb_data->user_cb))(device_id, device_type, direction,
 212                         state, name, vendor_id, product_id, (bool)is_running, stream_id, stream_num, cb_data->user_data);
 213         } else if (event == AUDIO_EVENT_DEVICE_RUNNING_CHANGED) {
 214
 215                 if (g_variant_type_equal(v_type, "(u(isiisiibai))") == FALSE) {
 216                         debug_error("Device state changed signature not matching : %s", v_type);
 217                         return ;
 218                 }
 219
 220                 g_variant_iter_init(&iter, params);
 221                 g_variant_iter_next(&iter, "u", &event_id);
 222                 device_v = g_variant_iter_next_value(&iter);
 223                 if (parse_device_variant(device_v, &device_id, &device_type, &direction, &state,
 224                                                         &name, &vendor_id, &product_id, &is_running, stream_id, &stream_num) < 0) {
 225                         debug_error("Failed to parse device variant");
 226                         return ;
 227                 }
 228
 229                 ((mm_sound_device_running_changed_wrapper_cb)(cb_data->user_cb))(device_id, device_type, direction,
 230                         state, name, vendor_id, product_id, (bool)is_running, stream_id, stream_num, cb_data->user_data);
 231         } else if (event == AUDIO_EVENT_FOCUS_CHANGED) {
 232         } else if (event == AUDIO_EVENT_FOCUS_WATCH) {
 233         } else if (event == AUDIO_EVENT_TEST) {
 234                 int test_var = 0;
 235                 g_variant_get(params, "(i)", &test_var);
 236                 ((mm_sound_test_cb)(cb_data->user_cb))(test_var, cb_data->user_data);
 237         } else if (event == AUDIO_EVENT_PLAY_FILE_END) {
 238                 int ended_handle = 0;
 239                 g_variant_get(params, "(i)", &ended_handle);
 240                 ((mm_sound_stop_callback_wrapper_func)(cb_data->user_cb))(ended_handle, cb_data->user_data);
 241         }
 242 }
 243
 244 static void simple_callback_data_free_func(void *data)
 245 {
 246         struct callback_data *cb_data = (struct callback_data*) data;
 247
 248         if (cb_data) {
 249                 if (cb_data->free_func)
 250                         cb_data->free_func(cb_data->user_data);
 251                 g_free(cb_data);
 252         }
 253 }
 254
 255 int mm_sound_proxy_add_test_callback(mm_sound_test_cb func, void *userdata, mm_sound_proxy_userdata_free freefunc, unsigned *subs_id)
 256 {
 257         int ret = MM_ERROR_NONE;
 258         struct callback_data *cb_data;
 259
 260         debug_fenter();
 261
 262         CB_DATA_NEW(cb_data, func, userdata, freefunc);
 263
 264         if ((ret = mm_sound_dbus_signal_subscribe_to(AUDIO_PROVIDER_SOUND_SERVER, AUDIO_EVENT_TEST, dbus_callback, cb_data, simple_callback_data_free_func, &cb_data->subs_id)) != MM_ERROR_NONE)
 265                 debug_error("add test callback failed");
 266         else
 267                 *subs_id = cb_data->subs_id;
 268
 269         debug_fleave();
 270         return ret;
 271 }
 272
 273 int mm_sound_proxy_remove_test_callback(unsigned subs_id)
 274 {
 275         int ret = MM_ERROR_NONE;
 276         debug_fenter();
 277
 278         if ((ret = mm_sound_dbus_signal_unsubscribe(subs_id)) != MM_ERROR_NONE)
 279                 debug_error("remove test callback failed");
 280
 281         debug_fleave();
 282         return ret;
 283 }
 284
 285 int mm_sound_proxy_test(int a, int b, int *get)
 286 {
 287         int ret = MM_ERROR_NONE;
 288         int reply = 0;
 289         GVariant *params = NULL, *result = NULL;
 290
 291         debug_fenter();
 292
 293         if ((params = g_variant_new("(ii)", a, b)) == NULL) {
 294                 debug_error("Construct Param for method call failed");
 295                 return MM_ERROR_SOUND_INTERNAL;
 296         }
 297
 298         if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_SOUND_SERVER, AUDIO_METHOD_TEST, params, &result)) != MM_ERROR_NONE) {
 299                 debug_error("dbus test call failed");
 300                 g_variant_unref(result);
 301                 return ret;
 302         }
 303
 304         if (result) {
 305                 g_variant_get(result, "(i)",  &reply);
 306                 debug_log("reply : %d", reply);
 307                 *get = reply;
 308                 g_variant_unref(result);
 309         } else {
 310                 debug_error("reply null");
 311                 ret = MM_ERROR_SOUND_INTERNAL;
 312         }
 313
 314         debug_fleave();
 315         return ret;
 316 }
 317
 318 int mm_sound_proxy_is_stream_on_device(int stream_id, int device_id, bool *is_on)
 319 {
 320         int ret = MM_ERROR_NONE;
 321         GVariant *params = NULL, *result = NULL;
 322         gboolean _is_on;
 323
 324         debug_fenter();
 325
 326         if (!is_on) {
 327                 debug_error("Invalid Parameter, is_on null");
 328                 return MM_ERROR_INVALID_ARGUMENT;
 329         }
 330
 331         if ((params = g_variant_new("(ii)", stream_id, device_id)) == NULL) {
 332                 debug_error("Construct Param for query is stream on device failed");
 333                 return MM_ERROR_SOUND_INTERNAL;
 334         }
 335
 336         if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_DEVICE_MANAGER, AUDIO_METHOD_IS_STREAM_ON_DEVICE, params, &result)) != MM_ERROR_NONE) {
 337                 debug_error("is stream on device failed");
 338                 goto cleanup;
 339         }
 340
 341         if (result) {
 342                 g_variant_get(result, "(b)",  &_is_on);
 343                 debug_log("is_on : %d", _is_on);
 344                 *is_on = (bool)_is_on;
 345         } else {
 346                 debug_error("reply null");
 347                 ret = MM_ERROR_SOUND_INTERNAL;
 348         }
 349
 350 cleanup:
 351         g_variant_unref(result);
 352
 353         debug_fleave();
 354         return ret;
 355 }
 356
 357 #ifdef TIZEN_TV
 358 #define _VCONF_KEY_SOUND_SPEAKER_SELECTION "file/private/sound/feature/SpeakerSelection"
 359 #define _AUDIO_TV_OUTPUT_BT_HEADSET 5
 360
 361 static mm_sound_device_t* _get_tv_bt_device(void)
 362 {
 363         int speaker_value = 0;
 364         mm_sound_device_t* device_item = NULL;
 365
 366         if (vconf_get_int(_VCONF_KEY_SOUND_SPEAKER_SELECTION, &speaker_value) == VCONF_ERROR) {
 367                 debug_error("vconf_get_int(%s) failed..", _VCONF_KEY_SOUND_SPEAKER_SELECTION);
 368                 return NULL;
 369         }
 370
 371         debug_warning("speaker selection value = %d", speaker_value);
 372         if (speaker_value != _AUDIO_TV_OUTPUT_BT_HEADSET)
 373                 return NULL;
 374
 375         device_item = g_malloc0(sizeof(mm_sound_device_t));
 376         if (!device_item)
 377                 return NULL;
 378
 379         MMSOUND_STRNCPY(device_item->name, "BluetoothMedia", MAX_DEVICE_NAME_NUM);
 380         MMSOUND_STRNCPY(device_item->type, "bt-a2dp", MAX_DEVICE_TYPE_STR_LEN);
 381         device_item->id = 99;
 382         device_item->io_direction = DEVICE_IO_DIRECTION_OUT;
 383         device_item->state = DEVICE_STATE_ACTIVATED;
 384         device_item->vendor_id = -1;
 385         device_item->product_id = -1;
 386         device_item->stream_num = -1;
 387
 388         return device_item;
 389 }
 390 #endif /* TIZEN_TV */
 391
 392 int mm_sound_proxy_get_current_connected_device_list(int device_flags, GList** device_list)
 393 {
 394         int ret = MM_ERROR_NONE;
 395         GVariant *result = NULL, *child = NULL;
 396         GVariant *params = NULL;
 397         GVariantIter iter;
 398         mm_sound_device_t* device_item;
 399         const gchar *device_name_tmp = NULL, *device_type_tmp = NULL;
 400
 401         debug_fenter();
 402
 403         if (!device_list) {
 404                 debug_error("Invalid Parameter, device_list null");
 405                 ret = MM_ERROR_INVALID_ARGUMENT;
 406                 goto cleanup;
 407         }
 408
 409         params = g_variant_new("(i)", device_flags);
 410
 411         if (params) {
 412                 if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_DEVICE_MANAGER, AUDIO_METHOD_GET_CONNECTED_DEVICE_LIST, params, &result)) != MM_ERROR_NONE) {
 413                         debug_error("Get current connected device list failed");
 414                         goto cleanup;
 415                 }
 416         } else {
 417                 debug_error("Construct Param for get current connected device failed");
 418                 return MM_ERROR_SOUND_INTERNAL;
 419         }
 420
 421         child = g_variant_get_child_value(result, 0);
 422         g_variant_iter_init(&iter, child);
 423         while (1) {
 424                 device_item = g_malloc0(sizeof(mm_sound_device_t));
 425                 if (device_item && g_variant_iter_loop(&iter, "(i&sii&siib)",
 426                                         &device_item->id, &device_type_tmp, &device_item->io_direction, &device_item->state,
 427                                         &device_name_tmp, &device_item->vendor_id, &device_item->product_id, &device_item->is_running)) {
 428                         MMSOUND_STRNCPY(device_item->name, device_name_tmp, MAX_DEVICE_NAME_NUM);
 429                         MMSOUND_STRNCPY(device_item->type, device_type_tmp, MAX_DEVICE_TYPE_STR_LEN);
 430                         *device_list = g_list_append(*device_list, device_item);
 431                         debug_log("Added device id(%d) type(%17s) direction(%d) state(%d) name(%s) vendor-id(%04x) product-id(%04x) is_running(%d)",
 432                                         device_item->id, device_item->type, device_item->io_direction, device_item->state,
 433                                         device_item->name, device_item->vendor_id, device_item->product_id, device_item->is_running);
 434                         device_item->stream_num = -1;
 435                 } else {
 436                         g_free(device_item);
 437                         break;
 438                 }
 439         }
 440
 441
 442 #ifdef TIZEN_TV
 443         device_item = _get_tv_bt_device();
 444         if (device_item) {
 445                 *device_list = g_list_append(*device_list, device_item);
 446                 debug_msg("Added TV bt device id(%d) type(%17s) direction(%d) state(%d) name(%s) vendor-id(%04x) product-id(%04x)",
 447                                         device_item->id, device_item->type, device_item->io_direction, device_item->state,
 448                                         device_item->name, device_item->vendor_id, device_item->product_id);
 449         }
 450 #endif /* TIZEN_TV */
 451
 452 cleanup:
 453         g_variant_unref(result);
 454
 455         debug_fleave();
 456         return ret;
 457 }
 458
 459 int mm_sound_proxy_get_device_by_id(int device_id, mm_sound_device_t **device)
 460 {
 461         int ret = MM_ERROR_NONE;
 462         GVariant *params = NULL, *result = NULL;
 463         mm_sound_device_t* device_item = NULL;
 464         const gchar *device_name_tmp = NULL, *device_type_tmp = NULL;
 465
 466         debug_fenter();
 467
 468         if (!device || device_id < 1) {
 469                 debug_error("Invalid Parameter, device null or improper device id");
 470                 return MM_ERROR_INVALID_ARGUMENT;
 471         }
 472
 473         if ((params = g_variant_new("(i)", device_id)) == NULL) {
 474                 debug_error("Construct Param for get device by id failed");
 475                 return MM_ERROR_SOUND_INTERNAL;
 476         }
 477
 478         if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_DEVICE_MANAGER, AUDIO_METHOD_GET_DEVICE_BY_ID, params, &result)) != MM_ERROR_NONE) {
 479                 debug_error("get device by id failed");
 480                 ret = MM_ERROR_SOUND_NO_DATA;
 481                 goto cleanup;
 482         }
 483
 484         if (result) {
 485                 if ((device_item = g_malloc0(sizeof(mm_sound_device_t))) == NULL) {
 486                         debug_error("Alloc device handle failed");
 487                         ret = MM_ERROR_SOUND_INTERNAL;
 488                         goto cleanup;
 489                 }
 490
 491                 g_variant_get(result, "(i&sii&sii)",
 492                                 &device_item->id, &device_type_tmp, &device_item->io_direction,
 493                                 &device_item->state, &device_name_tmp,
 494                                 &device_item->vendor_id, &device_item->product_id);
 495                 MMSOUND_STRNCPY(device_item->name, device_name_tmp, MAX_DEVICE_NAME_NUM);
 496                 MMSOUND_STRNCPY(device_item->type, device_type_tmp, MAX_DEVICE_TYPE_STR_LEN);
 497                 debug_log("Get device id(%d) type(%17s) direction(%d) state(%d) name(%s) vendor-id(%04x) product-id(%04x)",
 498                                 device_item->id, device_item->type, device_item->io_direction,
 499                                 device_item->state, device_item->name,
 500                                 device_item->vendor_id, device_item->product_id);
 501                 device_item->stream_num = -1;
 502                 *device = device_item;
 503         } else {
 504                 debug_error("reply null");
 505                 ret = MM_ERROR_SOUND_INTERNAL;
 506         }
 507
 508 cleanup:
 509         g_variant_unref(result);
 510
 511         debug_fleave();
 512         return ret;
 513 }
 514
 515 int mm_sound_proxy_add_device_connected_callback(mm_sound_device_connected_wrapper_cb func, void *userdata, mm_sound_proxy_userdata_free freefunc, unsigned *subs_id)
 516 {
 517         int ret = MM_ERROR_NONE;
 518         struct callback_data *cb_data;
 519
 520         debug_fenter();
 521
 522         CB_DATA_NEW(cb_data, func, userdata, freefunc);
 523
 524         if ((ret = mm_sound_dbus_signal_subscribe_to(AUDIO_PROVIDER_DEVICE_MANAGER, AUDIO_EVENT_DEVICE_CONNECTED, dbus_callback, cb_data, simple_callback_data_free_func, &cb_data->subs_id)) != MM_ERROR_NONE) {
 525                 debug_error("add device connected callback failed");
 526                 goto finish;
 527         }
 528
 529         if ((ret = _notify_subscription(AUDIO_EVENT_DEVICE_CONNECTED, cb_data->subs_id, TRUE)) != MM_ERROR_NONE) {
 530                 debug_error("failed to notify subscription of device connected event");
 531                 goto finish;
 532         }
 533
 534         *subs_id = cb_data->subs_id;
 535
 536 finish:
 537         debug_fleave();
 538         return ret;
 539 }
 540
 541 int mm_sound_proxy_remove_device_connected_callback(unsigned subs_id)
 542 {
 543         int ret = MM_ERROR_NONE;
 544         debug_fenter();
 545
 546         if ((ret = mm_sound_dbus_signal_unsubscribe(subs_id)) != MM_ERROR_NONE) {
 547                 debug_error("remove device connected callback failed");
 548                 goto finish;
 549         }
 550
 551         if ((ret = _notify_subscription(AUDIO_EVENT_DEVICE_CONNECTED, subs_id, FALSE)) != MM_ERROR_NONE)
 552                 debug_error("failed to notify unsubscription of device connected event");
 553
 554 finish:
 555         debug_fleave();
 556         return ret;
 557 }
 558
 559 int mm_sound_proxy_add_device_info_changed_callback(mm_sound_device_info_changed_wrapper_cb func, void* userdata, mm_sound_proxy_userdata_free freefunc, unsigned *subs_id)
 560 {
 561         int ret = MM_ERROR_NONE;
 562         struct callback_data *cb_data;
 563
 564         debug_fenter();
 565
 566         CB_DATA_NEW(cb_data, func, userdata, freefunc);
 567
 568         if ((ret = mm_sound_dbus_signal_subscribe_to(AUDIO_PROVIDER_DEVICE_MANAGER, AUDIO_EVENT_DEVICE_INFO_CHANGED, dbus_callback, cb_data, simple_callback_data_free_func, &cb_data->subs_id)) != MM_ERROR_NONE)
 569                 debug_error("Add device info changed callback failed");
 570         else
 571                 *subs_id = cb_data->subs_id;
 572
 573         debug_fleave();
 574         return ret;
 575 }
 576
 577 int mm_sound_proxy_remove_device_info_changed_callback(unsigned subs_id)
 578 {
 579         int ret = MM_ERROR_NONE;
 580         debug_fenter();
 581
 582         if ((ret = mm_sound_dbus_signal_unsubscribe(subs_id)) != MM_ERROR_NONE)
 583                 debug_error("remove device info changed callback failed");
 584
 585         debug_fleave();
 586         return ret;
 587 }
 588
 589 int mm_sound_proxy_add_device_state_changed_callback(mm_sound_device_state_changed_wrapper_cb func, void* userdata, mm_sound_proxy_userdata_free freefunc, unsigned *subs_id)
 590 {
 591         int ret = MM_ERROR_NONE;
 592         struct callback_data *cb_data;
 593
 594         debug_fenter();
 595
 596         CB_DATA_NEW(cb_data, func, userdata, freefunc);
 597
 598         if ((ret = mm_sound_dbus_signal_subscribe_to(AUDIO_PROVIDER_DEVICE_MANAGER, AUDIO_EVENT_DEVICE_STATE_CHANGED, dbus_callback, cb_data, simple_callback_data_free_func, &cb_data->subs_id)) != MM_ERROR_NONE)
 599                 debug_error("Add device state changed callback failed");
 600         else
 601                 *subs_id = cb_data->subs_id;
 602
 603         debug_fleave();
 604         return ret;
 605 }
 606
 607 int mm_sound_proxy_remove_device_state_changed_callback(unsigned subs_id)
 608 {
 609         int ret = MM_ERROR_NONE;
 610         debug_fenter();
 611
 612         if ((ret = mm_sound_dbus_signal_unsubscribe(subs_id)) != MM_ERROR_NONE)
 613                 debug_error("remove device state changed callback failed");
 614
 615         debug_fleave();
 616         return ret;
 617 }
 618
 619 int mm_sound_proxy_add_device_running_changed_callback(mm_sound_device_running_changed_wrapper_cb func, void* userdata, mm_sound_proxy_userdata_free freefunc, unsigned *subs_id)
 620 {
 621         int ret = MM_ERROR_NONE;
 622         struct callback_data *cb_data;
 623
 624         debug_fenter();
 625
 626         CB_DATA_NEW(cb_data, func, userdata, freefunc);
 627
 628         if ((ret = mm_sound_dbus_signal_subscribe_to(AUDIO_PROVIDER_DEVICE_MANAGER, AUDIO_EVENT_DEVICE_RUNNING_CHANGED, dbus_callback, cb_data, simple_callback_data_free_func, &cb_data->subs_id)) != MM_ERROR_NONE)
 629                 debug_error("Add device running changed callback failed");
 630         else
 631                 *subs_id = cb_data->subs_id;
 632
 633         debug_fleave();
 634         return ret;
 635 }
 636
 637 int mm_sound_proxy_remove_device_running_changed_callback(unsigned subs_id)
 638 {
 639         int ret = MM_ERROR_NONE;
 640         debug_fenter();
 641
 642         if ((ret = mm_sound_dbus_signal_unsubscribe(subs_id)) != MM_ERROR_NONE)
 643                 debug_error("remove device running changed callback failed");
 644
 645         debug_fleave();
 646         return ret;
 647 }
 648
 649 int mm_sound_proxy_set_volume_by_type(const char *volume_type, const unsigned volume_level)
 650 {
 651         int ret = MM_ERROR_NONE;
 652         char *reply = NULL, *direction = "out";
 653         GVariant *params = NULL, *result = NULL;
 654
 655         debug_fenter();
 656
 657         if ((params = g_variant_new("(ssu)", direction, volume_type, volume_level)) == NULL) {
 658                 debug_error("Construct Param for method call failed");
 659                 return MM_ERROR_SOUND_INTERNAL;
 660         }
 661
 662         if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_STREAM_MANAGER, AUDIO_METHOD_SET_VOLUME_LEVEL, params, &result)) != MM_ERROR_NONE) {
 663                 debug_error("dbus set volume by type failed");
 664                 g_variant_unref(result);
 665                 return ret;
 666         }
 667
 668         if (result) {
 669                 g_variant_get(result, "(&s)",  &reply);
 670                 debug_log("reply : %s", reply);
 671                 if (strcmp(reply, "STREAM_MANAGER_RETURN_OK"))
 672                         ret = MM_ERROR_SOUND_INTERNAL;
 673                 g_variant_unref(result);
 674         } else {
 675                 debug_error("reply null");
 676                 ret = MM_ERROR_SOUND_INTERNAL;
 677         }
 678
 679         debug_fleave();
 680         return ret;
 681 }
 682
 683 int mm_sound_proxy_add_volume_changed_callback(mm_sound_volume_changed_wrapper_cb func, void* userdata, mm_sound_proxy_userdata_free freefunc, unsigned *subs_id)
 684 {
 685         int ret = MM_ERROR_NONE;
 686         struct callback_data *cb_data;
 687
 688         debug_fenter();
 689
 690         CB_DATA_NEW(cb_data, func, userdata, freefunc);
 691
 692         if ((ret = mm_sound_dbus_signal_subscribe_to(AUDIO_PROVIDER_STREAM_MANAGER, AUDIO_EVENT_VOLUME_CHANGED, dbus_callback, cb_data, simple_callback_data_free_func, &cb_data->subs_id)) != MM_ERROR_NONE)
 693                 debug_error("Add Volume changed callback failed");
 694         else
 695                 *subs_id = cb_data->subs_id;
 696
 697         debug_fleave();
 698
 699         return ret;
 700 }
 701
 702 int mm_sound_proxy_remove_volume_changed_callback(unsigned subs_id)
 703 {
 704         int ret = MM_ERROR_NONE;
 705         debug_fenter();
 706
 707         if ((ret = mm_sound_dbus_signal_unsubscribe(subs_id)) != MM_ERROR_NONE)
 708                 debug_error("Remove Volume changed callback failed");
 709
 710         debug_fleave();
 711         return ret;
 712 }
 713
 714 int mm_sound_proxy_set_mute_by_type(const char *volume_type, bool mute)
 715 {
 716         int ret = MM_ERROR_NONE;
 717         char *reply = NULL, *direction = "out";
 718         GVariant *params = NULL, *result = NULL;
 719
 720         debug_fenter();
 721
 722         if ((params = g_variant_new("(ssu)", direction, volume_type, (unsigned int)mute)) == NULL) {
 723                 debug_error("Construct Param for method call failed");
 724                 return MM_ERROR_SOUND_INTERNAL;
 725         }
 726
 727         if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_STREAM_MANAGER, AUDIO_METHOD_SET_MUTE, params, &result)) != MM_ERROR_NONE) {
 728                 debug_error("dbus set mute by type failed");
 729                 g_variant_unref(result);
 730                 return ret;
 731         }
 732
 733         if (result) {
 734                 g_variant_get(result, "(&s)",  &reply);
 735                 debug_log("reply : %s", reply);
 736                 if (strcmp(reply, "STREAM_MANAGER_RETURN_OK"))
 737                         ret = MM_ERROR_SOUND_INTERNAL;
 738                 g_variant_unref(result);
 739         } else {
 740                 debug_error("reply null");
 741                 ret = MM_ERROR_SOUND_INTERNAL;
 742         }
 743
 744         debug_fleave();
 745         return ret;
 746 }
 747
 748 int mm_sound_proxy_set_filter_by_type(const char *stream_type, const char *filter_name, const char *filter_parameters, const char *filter_group)
 749 {
 750         int ret = MM_ERROR_NONE;
 751         char *reply = NULL;
 752         GVariant *params = NULL, *result = NULL;
 753
 754         debug_fenter();
 755
 756         if ((params = g_variant_new("(ssss)", filter_name, filter_parameters, filter_group, stream_type)) == NULL) {
 757                 debug_error("construct param for method call failed");
 758                 return MM_ERROR_SOUND_INTERNAL;
 759         }
 760
 761         if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_STREAM_MANAGER, AUDIO_METHOD_SET_FILTER, params, &result)) != MM_ERROR_NONE)
 762                 debug_error("dbus set filter by type failed");
 763
 764         /* stream-manager always returns a string as return value */
 765         if (result) {
 766                 g_variant_get(result, "(&s)", &reply);
 767                 debug_log("reply : %s", reply);
 768                 if (strcmp(reply, "STREAM_MANAGER_RETURN_OK"))
 769                         ret = MM_ERROR_SOUND_INTERNAL;
 770                 g_variant_unref(result);
 771         } else {
 772                 debug_error("reply null");
 773                 if (ret == MM_ERROR_NONE)
 774                         ret = MM_ERROR_SOUND_INTERNAL;
 775         }
 776
 777         debug_fleave();
 778         return ret;
 779 }
 780
 781 int mm_sound_proxy_unset_filter_by_type(const char *stream_type)
 782 {
 783         int ret = MM_ERROR_NONE;
 784         char *reply = NULL;
 785         GVariant *params = NULL, *result = NULL;
 786
 787         debug_fenter();
 788
 789         if ((params = g_variant_new("(s)", stream_type)) == NULL) {
 790                 debug_error("construct param for method call failed");
 791                 return MM_ERROR_SOUND_INTERNAL;
 792         }
 793
 794         if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_STREAM_MANAGER, AUDIO_METHOD_UNSET_FILTER, params, &result)) != MM_ERROR_NONE)
 795                 debug_error("dbus unset filter by type failed");
 796
 797         /* stream-manager always returns a string as return value */
 798         if (result) {
 799                 g_variant_get(result, "(&s)", &reply);
 800                 debug_log("reply : %s", reply);
 801                 if (strcmp(reply, "STREAM_MANAGER_RETURN_OK"))
 802                         ret = MM_ERROR_SOUND_INTERNAL;
 803                 g_variant_unref(result);
 804         } else {
 805                 debug_error("reply null");
 806                 if (ret == MM_ERROR_NONE)
 807                         ret = MM_ERROR_SOUND_INTERNAL;
 808         }
 809
 810         debug_fleave();
 811         return ret;
 812 }
 813
 814 int mm_sound_proxy_control_filter_by_type(const char *stream_type, const char *filter_name, const char *filter_controls)
 815 {
 816         int ret = MM_ERROR_NONE;
 817         char *reply = NULL;
 818         GVariant *params = NULL, *result = NULL;
 819
 820         debug_fenter();
 821
 822         if ((params = g_variant_new("(sss)", filter_name, filter_controls, stream_type)) == NULL) {
 823                 debug_error("construct param for method call failed");
 824                 return MM_ERROR_SOUND_INTERNAL;
 825         }
 826
 827         if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_STREAM_MANAGER, AUDIO_METHOD_CONTROL_FILTER, params, &result)) != MM_ERROR_NONE)
 828                 debug_error("dbus control filter by type failed");
 829
 830         /* stream-manager always returns a string as return value */
 831         if (result) {
 832                 g_variant_get(result, "(&s)", &reply);
 833                 debug_log("reply : %s", reply);
 834                 if (strcmp(reply, "STREAM_MANAGER_RETURN_OK"))
 835                         ret = MM_ERROR_SOUND_INTERNAL;
 836                 g_variant_unref(result);
 837         } else {
 838                 debug_error("reply null");
 839                 if (ret == MM_ERROR_NONE)
 840                         ret = MM_ERROR_SOUND_INTERNAL;
 841         }
 842
 843         g_variant_unref(result);
 844
 845         debug_fleave();
 846         return ret;
 847 }
 848
 849 int mm_sound_proxy_play_tone_with_stream_info(int client_pid, int tone, char *stream_type, int stream_index, int volume, int repeat, int *codechandle)
 850 {
 851         int ret = MM_ERROR_NONE;
 852         int handle = 0;
 853         GVariant *params = NULL, *result = NULL;
 854
 855         debug_fenter();
 856
 857         if (!codechandle) {
 858                 debug_error("Param for play is null");
 859                 return MM_ERROR_INVALID_ARGUMENT;
 860         }
 861
 862         if ((params = g_variant_new("(iiiisi)", tone, repeat, volume, client_pid, stream_type, stream_index)) == NULL) {
 863                 debug_error("Construct Param for method call failed");
 864                 return MM_ERROR_SOUND_INTERNAL;
 865         }
 866
 867         if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_SOUND_SERVER, AUDIO_METHOD_PLAY_DTMF_WITH_STREAM_INFO, params, &result)) != MM_ERROR_NONE) {
 868                 debug_error("dbus play tone failed");
 869                 g_variant_unref(result);
 870                 return ret;
 871         }
 872
 873         if (result) {
 874                 g_variant_get(result, "(i)",  &handle);
 875                 debug_log("handle : %d", handle);
 876                 *codechandle = handle;
 877                 g_variant_unref(result);
 878         } else {
 879                 debug_error("reply null");
 880                 ret = MM_ERROR_SOUND_INTERNAL;
 881         }
 882
 883         debug_fleave();
 884         return ret;
 885 }
 886
 887 int mm_sound_proxy_play_sound_with_stream_info(const char* filename, int repeat, int volume,
 888                                 int client_pid, int *codechandle, char *stream_type, int stream_index)
 889 {
 890         int ret = MM_ERROR_NONE;
 891         int handle = 0;
 892         GVariant *params = NULL, *result = NULL;
 893
 894         if (!filename || !codechandle) {
 895                 debug_error("Param for play is null");
 896                 return MM_ERROR_INVALID_ARGUMENT;
 897         }
 898
 899         debug_fenter();
 900
 901         if ((params = g_variant_new("(siiisi)", filename, repeat, volume, client_pid, stream_type, stream_index)) == NULL) {
 902                 debug_error("Construct Param for method call failed");
 903                 return MM_ERROR_SOUND_INTERNAL;
 904         }
 905
 906         if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_SOUND_SERVER, AUDIO_METHOD_PLAY_FILE_START_WITH_STREAM_INFO, params, &result)) != MM_ERROR_NONE) {
 907                 debug_error("dbus play file failed");
 908                 g_variant_unref(result);
 909                 return ret;
 910         }
 911
 912         if (result) {
 913                 g_variant_get(result, "(i)",  &handle);
 914                 debug_log("handle : %d", handle);
 915                 *codechandle = handle;
 916                 g_variant_unref(result);
 917         } else {
 918                 debug_error("reply null");
 919                 ret = MM_ERROR_SOUND_INTERNAL;
 920         }
 921
 922         debug_fleave();
 923         return ret;
 924 }
 925
 926 int mm_sound_proxy_stop_sound(int handle)
 927 {
 928         int ret = MM_ERROR_NONE;
 929         GVariant *result = NULL;
 930
 931         debug_fenter();
 932
 933         if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_SOUND_SERVER, AUDIO_METHOD_PLAY_FILE_STOP, g_variant_new("(i)", handle), &result)) != MM_ERROR_NONE)
 934                 debug_error("dbus stop file playing failed");
 935
 936         g_variant_unref(result);
 937
 938         debug_fleave();
 939         return ret;
 940 }
 941
 942 int mm_sound_proxy_add_play_sound_end_callback(mm_sound_stop_callback_wrapper_func func, void* userdata, mm_sound_proxy_userdata_free freefunc, unsigned *subs_id)
 943 {
 944         int ret = MM_ERROR_NONE;
 945         struct callback_data *cb_data;
 946
 947         debug_fenter();
 948
 949         CB_DATA_NEW(cb_data, func, userdata, freefunc);
 950
 951         if ((ret = mm_sound_dbus_signal_subscribe_to(AUDIO_PROVIDER_SOUND_SERVER, AUDIO_EVENT_PLAY_FILE_END, dbus_callback, cb_data, simple_callback_data_free_func, &cb_data->subs_id)) != MM_ERROR_NONE)
 952                 debug_error("add play sound end callback failed");
 953         else
 954                 *subs_id = cb_data->subs_id;
 955
 956         debug_fleave();
 957
 958         return ret;
 959 }
 960
 961 int mm_sound_proxy_remove_play_sound_end_callback(unsigned subs_id)
 962 {
 963         int ret = MM_ERROR_NONE;
 964         debug_fenter();
 965
 966         if ((ret = mm_sound_dbus_signal_unsubscribe(subs_id)) != MM_ERROR_NONE)
 967                 debug_error("Remove Play File End callback failed");
 968
 969         debug_fleave();
 970         return ret;
 971 }
 972
 973 int mm_sound_proxy_register_focus(int index, const char *stream_type, int *id)
 974 {
 975         int ret = MM_ERROR_NONE;
 976         int pid = g_focus_sound_handle[index].focus_pid;
 977         int client_fd = 0;
 978
 979 #ifndef TIZEN_TV
 980         debug_fenter();
 981 #endif
 982         ret = mm_sound_focus_socket_register(pid, stream_type, &client_fd, id);
 983         if (ret) {
 984                 debug_error("failed to mm_sound_focus_socket_register(), ret[0x%x]", ret);
 985         } else {
 986                 g_focus_sound_handle[index].client_fd = client_fd;
 987                 g_focus_sound_handle[index].handle = *id;
 988         }
 989
 990         debug_fleave();
 991
 992         return ret;
 993 }
 994
 995 int mm_sound_proxy_unregister_focus(int index)
 996 {
 997         int ret = MM_ERROR_NONE;
 998         int pid = g_focus_sound_handle[index].focus_pid;
 999         int client_fd = g_focus_sound_handle[index].client_fd;
1000         int id = g_focus_sound_handle[index].handle;
1001
1002         debug_fenter();
1003
1004         ret = mm_sound_focus_socket_unregister(pid, client_fd, id);
1005         if (ret)
1006                 debug_error("failed to mm_sound_focus_socket_unregister(), client_fd[%d], id[%d], ret[0x%x]", client_fd, id, ret);
1007
1008         debug_fleave();
1009
1010         return ret;
1011 }
1012
1013 int mm_sound_proxy_set_focus_reacquisition(int index, bool reacquisition)
1014 {
1015         int ret = MM_ERROR_NONE;
1016         int pid = g_focus_sound_handle[index].focus_pid;
1017         int client_fd = g_focus_sound_handle[index].client_fd;
1018         int id = g_focus_sound_handle[index].handle;
1019
1020         debug_fenter();
1021
1022         ret = mm_sound_focus_socket_set_reacquisition(pid, client_fd, id, reacquisition);
1023         if (ret)
1024                 debug_error("failed to mm_sound_focus_socket_set_reacquisition(), ret[0x%x]", ret);
1025
1026         debug_fleave();
1027         return ret;
1028 }
1029
1030 int mm_sound_proxy_get_acquired_focus_stream_type(int focus_type, char **stream_type, int *option, char **ext_info)
1031 {
1032         int ret = MM_ERROR_NONE;
1033
1034         debug_fenter();
1035
1036         ret = mm_sound_focus_socket_get_acquired_focus_stream_type(focus_type, stream_type, option, ext_info);
1037         if (ret)
1038                 debug_error("failed to mm_sound_focus_socket_get_acquired_focus_stream_type(), ret[0x%x]", ret);
1039
1040         debug_fleave();
1041         return ret;
1042 }
1043
1044 int mm_sound_proxy_acquire_focus(int index, mm_sound_focus_type_e type, int option, const char *ext_info)
1045 {
1046         int ret = MM_ERROR_NONE;
1047         bool is_in_focus_cb_thread = false;
1048         int pid = g_focus_sound_handle[index].focus_pid;
1049         int client_fd = g_focus_sound_handle[index].client_fd;
1050         int id = g_focus_sound_handle[index].handle;
1051
1052         debug_fenter();
1053
1054         mm_sound_client_is_focus_cb_thread(g_thread_self(), &is_in_focus_cb_thread);
1055         if (!is_in_focus_cb_thread) {
1056                 if ((ret = mm_sound_focus_socket_acquire(pid, client_fd, id,
1057                                                                                                 type, option, ext_info ? ext_info : "", true)))
1058                         debug_error("failed to mm_sound_focus_socket_acquire(), ret[0x%x]", ret);
1059         } else {
1060                 GVariant *params = NULL, *result = NULL;
1061
1062                 if ((params = g_variant_new("(iiiis)", pid, id, type, option, ext_info ? ext_info : "")) == NULL) {
1063                         debug_error("Construct Param for method call failed");
1064                         return MM_ERROR_SOUND_INTERNAL;
1065                 }
1066
1067                 if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_FOCUS_SERVER, AUDIO_METHOD_ACQUIRE_FOCUS, params, &result)) != MM_ERROR_NONE)
1068                         debug_error("dbus acquire focus failed");
1069
1070                 g_variant_unref(result);
1071         }
1072
1073         debug_fleave();
1074
1075         return ret;
1076 }
1077
1078 int mm_sound_proxy_release_focus(int index, mm_sound_focus_type_e type, int option, const char *ext_info)
1079 {
1080         int ret = MM_ERROR_NONE;
1081         bool is_in_focus_cb_thread = false;
1082         int pid = g_focus_sound_handle[index].focus_pid;
1083         int client_fd = g_focus_sound_handle[index].client_fd;
1084         int id = g_focus_sound_handle[index].handle;
1085
1086         debug_fenter();
1087
1088         mm_sound_client_is_focus_cb_thread(g_thread_self(), &is_in_focus_cb_thread);
1089         if (!is_in_focus_cb_thread) {
1090                 if ((ret = mm_sound_focus_socket_release(pid, client_fd, id, type, option, ext_info ? ext_info : "", true)))
1091                         debug_error("failed to mm_sound_focus_socket_release(), ret[0x%x]", ret);
1092         } else {
1093                 GVariant *params = NULL, *result = NULL;
1094
1095                 if ((params = g_variant_new("(iiiis)", pid, id, type, option, ext_info ? ext_info : "")) == NULL) {
1096                         debug_error("Construct Param for method call failed");
1097                         return MM_ERROR_SOUND_INTERNAL;
1098                 }
1099
1100                 if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_FOCUS_SERVER, AUDIO_METHOD_RELEASE_FOCUS, params, &result)) != MM_ERROR_NONE)
1101                         debug_error("dbus release focus failed");
1102
1103                 g_variant_unref(result);
1104         }
1105
1106         debug_fleave();
1107
1108         return ret;
1109 }
1110
1111 int mm_sound_proxy_update_stream_focus_status(int focus_id, unsigned int status)
1112 {
1113         int ret = MM_ERROR_NONE;
1114         char *reply = NULL;
1115         GVariant *params = NULL, *result = NULL;
1116
1117         debug_fenter();
1118
1119         if ((params = g_variant_new("(iu)", focus_id, status)) == NULL) {
1120                 debug_error("Construct Param for method call failed");
1121                 return MM_ERROR_SOUND_INTERNAL;
1122         }
1123
1124         if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_STREAM_MANAGER, AUDIO_METHOD_UPDATE_STREAM_FOCUS_STATUS, params, &result)) != MM_ERROR_NONE)
1125                 debug_error("dbus set volume by type failed");
1126
1127         /* stream-manager always returns a string as return value */
1128         if (result) {
1129                 g_variant_get(result, "(&s)", &reply);
1130                 debug_log("reply : %s", reply);
1131                 if (strcmp(reply, "STREAM_MANAGER_RETURN_OK"))
1132                         ret = MM_ERROR_SOUND_INTERNAL;
1133                 g_variant_unref(result);
1134         } else {
1135                 debug_error("reply null");
1136                 ret = MM_ERROR_SOUND_INTERNAL;
1137         }
1138
1139         debug_fleave();
1140
1141         return ret;
1142 }
1143
1144 int mm_sound_proxy_deliver_focus(int src_index, int dst_index, mm_sound_focus_type_e focus_type)
1145 {
1146         int ret = MM_ERROR_NONE;
1147         int pid = g_focus_sound_handle[src_index].focus_pid;
1148         int src_client_fd = g_focus_sound_handle[src_index].client_fd;
1149         int src_server_fd = g_focus_sound_handle[src_index].handle;
1150         int dst_client_fd = g_focus_sound_handle[dst_index].client_fd;
1151         int dst_server_fd = g_focus_sound_handle[dst_index].handle;
1152
1153         debug_fenter();
1154
1155         ret = mm_sound_focus_socket_deliver(pid, src_client_fd, src_server_fd, dst_client_fd, dst_server_fd, focus_type);
1156         if (ret)
1157                 debug_error("failed to mm_sound_focus_socket_deliver(), ret[0x%x]", ret);
1158
1159         debug_fleave();
1160         return ret;
1161 }
1162
1163 int mm_sound_proxy_add_focus_watch_callback(int index, mm_sound_focus_type_e type)
1164 {
1165         int ret = MM_ERROR_NONE;
1166         int pid = g_focus_sound_handle[index].focus_pid;
1167         int id = 0;
1168         int client_fd = 0;
1169
1170         debug_fenter();
1171
1172         ret = mm_sound_focus_socket_add_watch_cb(pid, type, &client_fd, &id);
1173         if (ret) {
1174                 debug_error("failed to mm_sound_focus_socket_add_watch_cb(), ret[0x%x]", ret);
1175         } else {
1176                 g_focus_sound_handle[index].handle = id;
1177                 g_focus_sound_handle[index].client_fd = client_fd;
1178         }
1179
1180         debug_fleave();
1181
1182         return ret;
1183 }
1184
1185 int mm_sound_proxy_remove_focus_watch_callback(int index)
1186 {
1187         int ret = MM_ERROR_NONE;
1188         int pid = g_focus_sound_handle[index].focus_pid;
1189         int client_fd = g_focus_sound_handle[index].client_fd;
1190         int id = g_focus_sound_handle[index].handle;
1191
1192         debug_fenter();
1193
1194         ret = mm_sound_focus_socket_remove_watch_cb(pid, client_fd, id);
1195         if (ret)
1196                 debug_error("failed to mm_sound_focus_socket_remove_watch_cb(), ret[0x%x]", ret);
1197
1198         debug_fleave();
1199
1200         return ret;
1201 }
1202
1203 int mm_sound_proxy_initialize(void)
1204 {
1205         int ret = MM_ERROR_NONE;
1206
1207         debug_fenter();
1208         debug_fleave();
1209
1210         return ret;
1211 }
1212
1213 int mm_sound_proxy_finalize(void)
1214 {
1215         int ret = MM_ERROR_NONE;
1216
1217         debug_fenter();
1218         debug_fleave();
1219
1220         return ret;
1221 }