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         } else if (event == AUDIO_EVENT_DUCKING_STATE_CHANGED) {
 242                 int idx = 0;
 243                 int is_ducked = 0;
 244
 245                 g_variant_get(params, "(ii)", &idx, &is_ducked);
 246
 247                 ((mm_sound_ducking_state_changed_wrapper_cb)(cb_data->user_cb))(idx, is_ducked, cb_data->user_data);
 248         }
 249 }
 250
 251 static void simple_callback_data_free_func(void *data)
 252 {
 253         struct callback_data *cb_data = (struct callback_data*) data;
 254
 255         if (cb_data) {
 256                 if (cb_data->free_func)
 257                         cb_data->free_func(cb_data->user_data);
 258                 g_free(cb_data);
 259         }
 260 }
 261
 262 int mm_sound_proxy_add_test_callback(mm_sound_test_cb func, void *userdata, mm_sound_proxy_userdata_free freefunc, unsigned *subs_id)
 263 {
 264         int ret = MM_ERROR_NONE;
 265         struct callback_data *cb_data;
 266
 267         debug_fenter();
 268
 269         CB_DATA_NEW(cb_data, func, userdata, freefunc);
 270
 271         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)
 272                 debug_error("add test callback failed");
 273         else
 274                 *subs_id = cb_data->subs_id;
 275
 276         debug_fleave();
 277         return ret;
 278 }
 279
 280 int mm_sound_proxy_remove_test_callback(unsigned subs_id)
 281 {
 282         int ret = MM_ERROR_NONE;
 283         debug_fenter();
 284
 285         if ((ret = mm_sound_dbus_signal_unsubscribe(subs_id)) != MM_ERROR_NONE)
 286                 debug_error("remove test callback failed");
 287
 288         debug_fleave();
 289         return ret;
 290 }
 291
 292 int mm_sound_proxy_test(int a, int b, int *get)
 293 {
 294         int ret = MM_ERROR_NONE;
 295         int reply = 0;
 296         GVariant *params = NULL, *result = NULL;
 297
 298         debug_fenter();
 299
 300         if ((params = g_variant_new("(ii)", a, b)) == NULL) {
 301                 debug_error("Construct Param for method call failed");
 302                 return MM_ERROR_SOUND_INTERNAL;
 303         }
 304
 305         if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_SOUND_SERVER, AUDIO_METHOD_TEST, params, &result)) != MM_ERROR_NONE) {
 306                 debug_error("dbus test call failed");
 307                 g_variant_unref(result);
 308                 return ret;
 309         }
 310
 311         if (result) {
 312                 g_variant_get(result, "(i)",  &reply);
 313                 debug_log("reply : %d", reply);
 314                 *get = reply;
 315                 g_variant_unref(result);
 316         } else {
 317                 debug_error("reply null");
 318                 ret = MM_ERROR_SOUND_INTERNAL;
 319         }
 320
 321         debug_fleave();
 322         return ret;
 323 }
 324
 325 int mm_sound_proxy_is_stream_on_device(int stream_id, int device_id, bool *is_on)
 326 {
 327         int ret = MM_ERROR_NONE;
 328         GVariant *params = NULL, *result = NULL;
 329         gboolean _is_on;
 330
 331         debug_fenter();
 332
 333         if (!is_on) {
 334                 debug_error("Invalid Parameter, is_on null");
 335                 return MM_ERROR_INVALID_ARGUMENT;
 336         }
 337
 338         if ((params = g_variant_new("(ii)", stream_id, device_id)) == NULL) {
 339                 debug_error("Construct Param for query is stream on device failed");
 340                 return MM_ERROR_SOUND_INTERNAL;
 341         }
 342
 343         if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_DEVICE_MANAGER, AUDIO_METHOD_IS_STREAM_ON_DEVICE, params, &result)) != MM_ERROR_NONE) {
 344                 debug_error("is stream on device failed");
 345                 goto cleanup;
 346         }
 347
 348         if (result) {
 349                 g_variant_get(result, "(b)",  &_is_on);
 350                 debug_log("is_on : %d", _is_on);
 351                 *is_on = (bool)_is_on;
 352         } else {
 353                 debug_error("reply null");
 354                 ret = MM_ERROR_SOUND_INTERNAL;
 355         }
 356
 357 cleanup:
 358         g_variant_unref(result);
 359
 360         debug_fleave();
 361         return ret;
 362 }
 363
 364 #ifdef TIZEN_TV
 365 #define _VCONF_KEY_SOUND_SPEAKER_SELECTION "file/private/sound/feature/SpeakerSelection"
 366 #define _AUDIO_TV_OUTPUT_BT_HEADSET 5
 367
 368 static mm_sound_device_t* _get_tv_bt_device(void)
 369 {
 370         int speaker_value = 0;
 371         mm_sound_device_t* device_item = NULL;
 372
 373         if (vconf_get_int(_VCONF_KEY_SOUND_SPEAKER_SELECTION, &speaker_value) == VCONF_ERROR) {
 374                 debug_error("vconf_get_int(%s) failed..", _VCONF_KEY_SOUND_SPEAKER_SELECTION);
 375                 return NULL;
 376         }
 377
 378         debug_warning("speaker selection value = %d", speaker_value);
 379         if (speaker_value != _AUDIO_TV_OUTPUT_BT_HEADSET)
 380                 return NULL;
 381
 382         device_item = g_malloc0(sizeof(mm_sound_device_t));
 383         if (!device_item)
 384                 return NULL;
 385
 386         MMSOUND_STRNCPY(device_item->name, "BluetoothMedia", MAX_DEVICE_NAME_NUM);
 387         MMSOUND_STRNCPY(device_item->type, "bt-a2dp", MAX_DEVICE_TYPE_STR_LEN);
 388         device_item->id = 99;
 389         device_item->io_direction = DEVICE_IO_DIRECTION_OUT;
 390         device_item->state = DEVICE_STATE_ACTIVATED;
 391         device_item->vendor_id = -1;
 392         device_item->product_id = -1;
 393         device_item->stream_num = -1;
 394
 395         return device_item;
 396 }
 397 #endif /* TIZEN_TV */
 398
 399 int mm_sound_proxy_get_current_connected_device_list(int device_flags, GList** device_list)
 400 {
 401         int ret = MM_ERROR_NONE;
 402         GVariant *result = NULL, *child = NULL;
 403         GVariant *params = NULL;
 404         GVariantIter iter;
 405         mm_sound_device_t* device_item;
 406         const gchar *device_name_tmp = NULL, *device_type_tmp = NULL;
 407
 408         debug_fenter();
 409
 410         if (!device_list) {
 411                 debug_error("Invalid Parameter, device_list null");
 412                 ret = MM_ERROR_INVALID_ARGUMENT;
 413                 goto cleanup;
 414         }
 415
 416         params = g_variant_new("(i)", device_flags);
 417
 418         if (params) {
 419                 if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_DEVICE_MANAGER, AUDIO_METHOD_GET_CONNECTED_DEVICE_LIST, params, &result)) != MM_ERROR_NONE) {
 420                         debug_error("Get current connected device list failed");
 421                         goto cleanup;
 422                 }
 423         } else {
 424                 debug_error("Construct Param for get current connected device failed");
 425                 return MM_ERROR_SOUND_INTERNAL;
 426         }
 427
 428         child = g_variant_get_child_value(result, 0);
 429         g_variant_iter_init(&iter, child);
 430         while (1) {
 431                 device_item = g_malloc0(sizeof(mm_sound_device_t));
 432                 if (device_item && g_variant_iter_loop(&iter, "(i&sii&siib)",
 433                                         &device_item->id, &device_type_tmp, &device_item->io_direction, &device_item->state,
 434                                         &device_name_tmp, &device_item->vendor_id, &device_item->product_id, &device_item->is_running)) {
 435                         MMSOUND_STRNCPY(device_item->name, device_name_tmp, MAX_DEVICE_NAME_NUM);
 436                         MMSOUND_STRNCPY(device_item->type, device_type_tmp, MAX_DEVICE_TYPE_STR_LEN);
 437                         *device_list = g_list_append(*device_list, device_item);
 438                         debug_log("Added device id(%d) type(%17s) direction(%d) state(%d) name(%s) vendor-id(%04x) product-id(%04x) is_running(%d)",
 439                                         device_item->id, device_item->type, device_item->io_direction, device_item->state,
 440                                         device_item->name, device_item->vendor_id, device_item->product_id, device_item->is_running);
 441                         device_item->stream_num = -1;
 442                 } else {
 443                         g_free(device_item);
 444                         break;
 445                 }
 446         }
 447
 448
 449 #ifdef TIZEN_TV
 450         device_item = _get_tv_bt_device();
 451         if (device_item) {
 452                 *device_list = g_list_append(*device_list, device_item);
 453                 debug_msg("Added TV bt device id(%d) type(%17s) direction(%d) state(%d) name(%s) vendor-id(%04x) product-id(%04x)",
 454                                         device_item->id, device_item->type, device_item->io_direction, device_item->state,
 455                                         device_item->name, device_item->vendor_id, device_item->product_id);
 456         }
 457 #endif /* TIZEN_TV */
 458
 459 cleanup:
 460         g_variant_unref(result);
 461
 462         debug_fleave();
 463         return ret;
 464 }
 465
 466 int mm_sound_proxy_get_device_by_id(int device_id, mm_sound_device_t **device)
 467 {
 468         int ret = MM_ERROR_NONE;
 469         GVariant *params = NULL, *result = NULL;
 470         mm_sound_device_t* device_item = NULL;
 471         const gchar *device_name_tmp = NULL, *device_type_tmp = NULL;
 472
 473         debug_fenter();
 474
 475         if (!device || device_id < 1) {
 476                 debug_error("Invalid Parameter, device null or improper device id");
 477                 return MM_ERROR_INVALID_ARGUMENT;
 478         }
 479
 480         if ((params = g_variant_new("(i)", device_id)) == NULL) {
 481                 debug_error("Construct Param for get device by id failed");
 482                 return MM_ERROR_SOUND_INTERNAL;
 483         }
 484
 485         if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_DEVICE_MANAGER, AUDIO_METHOD_GET_DEVICE_BY_ID, params, &result)) != MM_ERROR_NONE) {
 486                 debug_error("get device by id failed");
 487                 ret = MM_ERROR_SOUND_NO_DATA;
 488                 goto cleanup;
 489         }
 490
 491         if (result) {
 492                 if ((device_item = g_malloc0(sizeof(mm_sound_device_t))) == NULL) {
 493                         debug_error("Alloc device handle failed");
 494                         ret = MM_ERROR_SOUND_INTERNAL;
 495                         goto cleanup;
 496                 }
 497
 498                 g_variant_get(result, "(i&sii&sii)",
 499                                 &device_item->id, &device_type_tmp, &device_item->io_direction,
 500                                 &device_item->state, &device_name_tmp,
 501                                 &device_item->vendor_id, &device_item->product_id);
 502                 MMSOUND_STRNCPY(device_item->name, device_name_tmp, MAX_DEVICE_NAME_NUM);
 503                 MMSOUND_STRNCPY(device_item->type, device_type_tmp, MAX_DEVICE_TYPE_STR_LEN);
 504                 debug_log("Get device id(%d) type(%17s) direction(%d) state(%d) name(%s) vendor-id(%04x) product-id(%04x)",
 505                                 device_item->id, device_item->type, device_item->io_direction,
 506                                 device_item->state, device_item->name,
 507                                 device_item->vendor_id, device_item->product_id);
 508                 device_item->stream_num = -1;
 509                 *device = device_item;
 510         } else {
 511                 debug_error("reply null");
 512                 ret = MM_ERROR_SOUND_INTERNAL;
 513         }
 514
 515 cleanup:
 516         g_variant_unref(result);
 517
 518         debug_fleave();
 519         return ret;
 520 }
 521
 522 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)
 523 {
 524         int ret = MM_ERROR_NONE;
 525         struct callback_data *cb_data;
 526
 527         debug_fenter();
 528
 529         CB_DATA_NEW(cb_data, func, userdata, freefunc);
 530
 531         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) {
 532                 debug_error("add device connected callback failed");
 533                 goto finish;
 534         }
 535
 536         if ((ret = _notify_subscription(AUDIO_EVENT_DEVICE_CONNECTED, cb_data->subs_id, TRUE)) != MM_ERROR_NONE) {
 537                 debug_error("failed to notify subscription of device connected event");
 538                 goto finish;
 539         }
 540
 541         *subs_id = cb_data->subs_id;
 542
 543 finish:
 544         debug_fleave();
 545         return ret;
 546 }
 547
 548 int mm_sound_proxy_remove_device_connected_callback(unsigned subs_id)
 549 {
 550         int ret = MM_ERROR_NONE;
 551         debug_fenter();
 552
 553         if ((ret = mm_sound_dbus_signal_unsubscribe(subs_id)) != MM_ERROR_NONE) {
 554                 debug_error("remove device connected callback failed");
 555                 goto finish;
 556         }
 557
 558         if ((ret = _notify_subscription(AUDIO_EVENT_DEVICE_CONNECTED, subs_id, FALSE)) != MM_ERROR_NONE)
 559                 debug_error("failed to notify unsubscription of device connected event");
 560
 561 finish:
 562         debug_fleave();
 563         return ret;
 564 }
 565
 566 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)
 567 {
 568         int ret = MM_ERROR_NONE;
 569         struct callback_data *cb_data;
 570
 571         debug_fenter();
 572
 573         CB_DATA_NEW(cb_data, func, userdata, freefunc);
 574
 575         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)
 576                 debug_error("Add device info changed callback failed");
 577         else
 578                 *subs_id = cb_data->subs_id;
 579
 580         debug_fleave();
 581         return ret;
 582 }
 583
 584 int mm_sound_proxy_remove_device_info_changed_callback(unsigned subs_id)
 585 {
 586         int ret = MM_ERROR_NONE;
 587         debug_fenter();
 588
 589         if ((ret = mm_sound_dbus_signal_unsubscribe(subs_id)) != MM_ERROR_NONE)
 590                 debug_error("remove device info changed callback failed");
 591
 592         debug_fleave();
 593         return ret;
 594 }
 595
 596 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)
 597 {
 598         int ret = MM_ERROR_NONE;
 599         struct callback_data *cb_data;
 600
 601         debug_fenter();
 602
 603         CB_DATA_NEW(cb_data, func, userdata, freefunc);
 604
 605         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)
 606                 debug_error("Add device state changed callback failed");
 607         else
 608                 *subs_id = cb_data->subs_id;
 609
 610         debug_fleave();
 611         return ret;
 612 }
 613
 614 int mm_sound_proxy_remove_device_state_changed_callback(unsigned subs_id)
 615 {
 616         int ret = MM_ERROR_NONE;
 617         debug_fenter();
 618
 619         if ((ret = mm_sound_dbus_signal_unsubscribe(subs_id)) != MM_ERROR_NONE)
 620                 debug_error("remove device state changed callback failed");
 621
 622         debug_fleave();
 623         return ret;
 624 }
 625
 626 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)
 627 {
 628         int ret = MM_ERROR_NONE;
 629         struct callback_data *cb_data;
 630
 631         debug_fenter();
 632
 633         CB_DATA_NEW(cb_data, func, userdata, freefunc);
 634
 635         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)
 636                 debug_error("Add device running changed callback failed");
 637         else
 638                 *subs_id = cb_data->subs_id;
 639
 640         debug_fleave();
 641         return ret;
 642 }
 643
 644 int mm_sound_proxy_remove_device_running_changed_callback(unsigned subs_id)
 645 {
 646         int ret = MM_ERROR_NONE;
 647         debug_fenter();
 648
 649         if ((ret = mm_sound_dbus_signal_unsubscribe(subs_id)) != MM_ERROR_NONE)
 650                 debug_error("remove device running changed callback failed");
 651
 652         debug_fleave();
 653         return ret;
 654 }
 655
 656 int mm_sound_proxy_set_volume_by_type(const char *volume_type, const unsigned volume_level)
 657 {
 658         int ret = MM_ERROR_NONE;
 659         char *reply = NULL, *direction = "out";
 660         GVariant *params = NULL, *result = NULL;
 661
 662         debug_fenter();
 663
 664         if ((params = g_variant_new("(ssu)", direction, volume_type, volume_level)) == NULL) {
 665                 debug_error("Construct Param for method call failed");
 666                 return MM_ERROR_SOUND_INTERNAL;
 667         }
 668
 669         if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_STREAM_MANAGER, AUDIO_METHOD_SET_VOLUME_LEVEL, params, &result)) != MM_ERROR_NONE) {
 670                 debug_error("dbus set volume by type failed");
 671                 g_variant_unref(result);
 672                 return ret;
 673         }
 674
 675         if (result) {
 676                 g_variant_get(result, "(&s)",  &reply);
 677                 debug_log("reply : %s", reply);
 678                 if (strcmp(reply, "STREAM_MANAGER_RETURN_OK"))
 679                         ret = MM_ERROR_SOUND_INTERNAL;
 680                 g_variant_unref(result);
 681         } else {
 682                 debug_error("reply null");
 683                 ret = MM_ERROR_SOUND_INTERNAL;
 684         }
 685
 686         debug_fleave();
 687         return ret;
 688 }
 689
 690 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)
 691 {
 692         int ret = MM_ERROR_NONE;
 693         struct callback_data *cb_data;
 694
 695         debug_fenter();
 696
 697         CB_DATA_NEW(cb_data, func, userdata, freefunc);
 698
 699         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)
 700                 debug_error("Add Volume changed callback failed");
 701         else
 702                 *subs_id = cb_data->subs_id;
 703
 704         debug_fleave();
 705
 706         return ret;
 707 }
 708
 709 int mm_sound_proxy_remove_volume_changed_callback(unsigned subs_id)
 710 {
 711         int ret = MM_ERROR_NONE;
 712         debug_fenter();
 713
 714         if ((ret = mm_sound_dbus_signal_unsubscribe(subs_id)) != MM_ERROR_NONE)
 715                 debug_error("Remove Volume changed callback failed");
 716
 717         debug_fleave();
 718         return ret;
 719 }
 720
 721 int mm_sound_proxy_add_ducking_state_changed_callback(mm_sound_ducking_state_changed_wrapper_cb func, void* userdata, mm_sound_proxy_userdata_free freefunc, unsigned *subs_id)
 722 {
 723         int ret = MM_ERROR_NONE;
 724         struct callback_data *cb_data;
 725
 726         debug_fenter();
 727
 728         CB_DATA_NEW(cb_data, func, userdata, freefunc);
 729
 730         if ((ret = mm_sound_dbus_signal_subscribe_to(AUDIO_PROVIDER_STREAM_MANAGER, AUDIO_EVENT_DUCKING_STATE_CHANGED, dbus_callback, cb_data, simple_callback_data_free_func, &cb_data->subs_id)) != MM_ERROR_NONE)
 731                 debug_error("Add Duckding State changed callback failed");
 732         else
 733                 *subs_id = cb_data->subs_id;
 734
 735         debug_fleave();
 736
 737         return ret;
 738 }
 739
 740 int mm_sound_proxy_remove_ducking_state_changed_callback(unsigned subs_id)
 741 {
 742         int ret = MM_ERROR_NONE;
 743         debug_fenter();
 744
 745         if ((ret = mm_sound_dbus_signal_unsubscribe(subs_id)) != MM_ERROR_NONE)
 746                 debug_error("Remove Ducking State changed callback failed");
 747
 748         debug_fleave();
 749         return ret;
 750 }
 751
 752 int mm_sound_proxy_set_mute_by_type(const char *volume_type, bool mute)
 753 {
 754         int ret = MM_ERROR_NONE;
 755         char *reply = NULL, *direction = "out";
 756         GVariant *params = NULL, *result = NULL;
 757
 758         debug_fenter();
 759
 760         if ((params = g_variant_new("(ssu)", direction, volume_type, (unsigned int)mute)) == NULL) {
 761                 debug_error("Construct Param for method call failed");
 762                 return MM_ERROR_SOUND_INTERNAL;
 763         }
 764
 765         if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_STREAM_MANAGER, AUDIO_METHOD_SET_MUTE, params, &result)) != MM_ERROR_NONE) {
 766                 debug_error("dbus set mute by type failed");
 767                 g_variant_unref(result);
 768                 return ret;
 769         }
 770
 771         if (result) {
 772                 g_variant_get(result, "(&s)",  &reply);
 773                 debug_log("reply : %s", reply);
 774                 if (strcmp(reply, "STREAM_MANAGER_RETURN_OK"))
 775                         ret = MM_ERROR_SOUND_INTERNAL;
 776                 g_variant_unref(result);
 777         } else {
 778                 debug_error("reply null");
 779                 ret = MM_ERROR_SOUND_INTERNAL;
 780         }
 781
 782         debug_fleave();
 783         return ret;
 784 }
 785
 786 int mm_sound_proxy_set_filter_by_type(const char *stream_type, const char *filter_name, const char *filter_parameters, const char *filter_group)
 787 {
 788         int ret = MM_ERROR_NONE;
 789         char *reply = NULL;
 790         GVariant *params = NULL, *result = NULL;
 791
 792         debug_fenter();
 793
 794         if ((params = g_variant_new("(ssss)", filter_name, filter_parameters, filter_group, stream_type)) == NULL) {
 795                 debug_error("construct param for method call failed");
 796                 return MM_ERROR_SOUND_INTERNAL;
 797         }
 798
 799         if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_STREAM_MANAGER, AUDIO_METHOD_SET_FILTER, params, &result)) != MM_ERROR_NONE)
 800                 debug_error("dbus set filter by type failed");
 801
 802         /* stream-manager always returns a string as return value */
 803         if (result) {
 804                 g_variant_get(result, "(&s)", &reply);
 805                 debug_log("reply : %s", reply);
 806                 if (strcmp(reply, "STREAM_MANAGER_RETURN_OK"))
 807                         ret = MM_ERROR_SOUND_INTERNAL;
 808                 g_variant_unref(result);
 809         } else {
 810                 debug_error("reply null");
 811                 if (ret == MM_ERROR_NONE)
 812                         ret = MM_ERROR_SOUND_INTERNAL;
 813         }
 814
 815         debug_fleave();
 816         return ret;
 817 }
 818
 819 int mm_sound_proxy_unset_filter_by_type(const char *stream_type)
 820 {
 821         int ret = MM_ERROR_NONE;
 822         char *reply = NULL;
 823         GVariant *params = NULL, *result = NULL;
 824
 825         debug_fenter();
 826
 827         if ((params = g_variant_new("(s)", stream_type)) == NULL) {
 828                 debug_error("construct param for method call failed");
 829                 return MM_ERROR_SOUND_INTERNAL;
 830         }
 831
 832         if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_STREAM_MANAGER, AUDIO_METHOD_UNSET_FILTER, params, &result)) != MM_ERROR_NONE)
 833                 debug_error("dbus unset filter by type failed");
 834
 835         /* stream-manager always returns a string as return value */
 836         if (result) {
 837                 g_variant_get(result, "(&s)", &reply);
 838                 debug_log("reply : %s", reply);
 839                 if (strcmp(reply, "STREAM_MANAGER_RETURN_OK"))
 840                         ret = MM_ERROR_SOUND_INTERNAL;
 841                 g_variant_unref(result);
 842         } else {
 843                 debug_error("reply null");
 844                 if (ret == MM_ERROR_NONE)
 845                         ret = MM_ERROR_SOUND_INTERNAL;
 846         }
 847
 848         debug_fleave();
 849         return ret;
 850 }
 851
 852 int mm_sound_proxy_control_filter_by_type(const char *stream_type, const char *filter_name, const char *filter_controls)
 853 {
 854         int ret = MM_ERROR_NONE;
 855         char *reply = NULL;
 856         GVariant *params = NULL, *result = NULL;
 857
 858         debug_fenter();
 859
 860         if ((params = g_variant_new("(sss)", filter_name, filter_controls, stream_type)) == NULL) {
 861                 debug_error("construct param for method call failed");
 862                 return MM_ERROR_SOUND_INTERNAL;
 863         }
 864
 865         if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_STREAM_MANAGER, AUDIO_METHOD_CONTROL_FILTER, params, &result)) != MM_ERROR_NONE)
 866                 debug_error("dbus control filter by type failed");
 867
 868         /* stream-manager always returns a string as return value */
 869         if (result) {
 870                 g_variant_get(result, "(&s)", &reply);
 871                 debug_log("reply : %s", reply);
 872                 if (strcmp(reply, "STREAM_MANAGER_RETURN_OK"))
 873                         ret = MM_ERROR_SOUND_INTERNAL;
 874                 g_variant_unref(result);
 875         } else {
 876                 debug_error("reply null");
 877                 if (ret == MM_ERROR_NONE)
 878                         ret = MM_ERROR_SOUND_INTERNAL;
 879         }
 880
 881         g_variant_unref(result);
 882
 883         debug_fleave();
 884         return ret;
 885 }
 886
 887 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)
 888 {
 889         int ret = MM_ERROR_NONE;
 890         int handle = 0;
 891         GVariant *params = NULL, *result = NULL;
 892
 893         debug_fenter();
 894
 895         if (!codechandle) {
 896                 debug_error("Param for play is null");
 897                 return MM_ERROR_INVALID_ARGUMENT;
 898         }
 899
 900         if ((params = g_variant_new("(iiiisi)", tone, repeat, volume, client_pid, stream_type, stream_index)) == NULL) {
 901                 debug_error("Construct Param for method call failed");
 902                 return MM_ERROR_SOUND_INTERNAL;
 903         }
 904
 905         if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_SOUND_SERVER, AUDIO_METHOD_PLAY_DTMF_WITH_STREAM_INFO, params, &result)) != MM_ERROR_NONE) {
 906                 debug_error("dbus play tone failed");
 907                 g_variant_unref(result);
 908                 return ret;
 909         }
 910
 911         if (result) {
 912                 g_variant_get(result, "(i)",  &handle);
 913                 debug_log("handle : %d", handle);
 914                 *codechandle = handle;
 915                 g_variant_unref(result);
 916         } else {
 917                 debug_error("reply null");
 918                 ret = MM_ERROR_SOUND_INTERNAL;
 919         }
 920
 921         debug_fleave();
 922         return ret;
 923 }
 924
 925 int mm_sound_proxy_play_sound_with_stream_info(const char* filename, int repeat, int volume,
 926                                 int client_pid, int *codechandle, char *stream_type, int stream_index)
 927 {
 928         int ret = MM_ERROR_NONE;
 929         int handle = 0;
 930         GVariant *params = NULL, *result = NULL;
 931
 932         if (!filename || !codechandle) {
 933                 debug_error("Param for play is null");
 934                 return MM_ERROR_INVALID_ARGUMENT;
 935         }
 936
 937         debug_fenter();
 938
 939         if ((params = g_variant_new("(siiisi)", filename, repeat, volume, client_pid, stream_type, stream_index)) == NULL) {
 940                 debug_error("Construct Param for method call failed");
 941                 return MM_ERROR_SOUND_INTERNAL;
 942         }
 943
 944         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) {
 945                 debug_error("dbus play file failed");
 946                 g_variant_unref(result);
 947                 return ret;
 948         }
 949
 950         if (result) {
 951                 g_variant_get(result, "(i)",  &handle);
 952                 debug_log("handle : %d", handle);
 953                 *codechandle = handle;
 954                 g_variant_unref(result);
 955         } else {
 956                 debug_error("reply null");
 957                 ret = MM_ERROR_SOUND_INTERNAL;
 958         }
 959
 960         debug_fleave();
 961         return ret;
 962 }
 963
 964 int mm_sound_proxy_stop_sound(int handle)
 965 {
 966         int ret = MM_ERROR_NONE;
 967         GVariant *result = NULL;
 968
 969         debug_fenter();
 970
 971         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)
 972                 debug_error("dbus stop file playing failed");
 973
 974         g_variant_unref(result);
 975
 976         debug_fleave();
 977         return ret;
 978 }
 979
 980 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)
 981 {
 982         int ret = MM_ERROR_NONE;
 983         struct callback_data *cb_data;
 984
 985         debug_fenter();
 986
 987         CB_DATA_NEW(cb_data, func, userdata, freefunc);
 988
 989         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)
 990                 debug_error("add play sound end callback failed");
 991         else
 992                 *subs_id = cb_data->subs_id;
 993
 994         debug_fleave();
 995
 996         return ret;
 997 }
 998
 999 int mm_sound_proxy_remove_play_sound_end_callback(unsigned subs_id)
1000 {
1001         int ret = MM_ERROR_NONE;
1002         debug_fenter();
1003
1004         if ((ret = mm_sound_dbus_signal_unsubscribe(subs_id)) != MM_ERROR_NONE)
1005                 debug_error("Remove Play File End callback failed");
1006
1007         debug_fleave();
1008         return ret;
1009 }
1010
1011 int mm_sound_proxy_register_focus(int index, const char *stream_type, int *id)
1012 {
1013         int ret = MM_ERROR_NONE;
1014         int pid = g_focus_sound_handle[index].focus_pid;
1015         int client_fd = 0;
1016
1017 #ifndef TIZEN_TV
1018         debug_fenter();
1019 #endif
1020         ret = mm_sound_focus_socket_register(pid, stream_type, &client_fd, id);
1021         if (ret) {
1022                 debug_error("failed to mm_sound_focus_socket_register(), ret[0x%x]", ret);
1023         } else {
1024                 g_focus_sound_handle[index].client_fd = client_fd;
1025                 g_focus_sound_handle[index].handle = *id;
1026         }
1027
1028         debug_fleave();
1029
1030         return ret;
1031 }
1032
1033 int mm_sound_proxy_unregister_focus(int index)
1034 {
1035         int ret = MM_ERROR_NONE;
1036         int pid = g_focus_sound_handle[index].focus_pid;
1037         int client_fd = g_focus_sound_handle[index].client_fd;
1038         int id = g_focus_sound_handle[index].handle;
1039
1040         debug_fenter();
1041
1042         ret = mm_sound_focus_socket_unregister(pid, client_fd, id);
1043         if (ret)
1044                 debug_error("failed to mm_sound_focus_socket_unregister(), client_fd[%d], id[%d], ret[0x%x]", client_fd, id, ret);
1045
1046         debug_fleave();
1047
1048         return ret;
1049 }
1050
1051 int mm_sound_proxy_set_focus_reacquisition(int index, bool reacquisition)
1052 {
1053         int ret = MM_ERROR_NONE;
1054         int pid = g_focus_sound_handle[index].focus_pid;
1055         int client_fd = g_focus_sound_handle[index].client_fd;
1056         int id = g_focus_sound_handle[index].handle;
1057
1058         debug_fenter();
1059
1060         ret = mm_sound_focus_socket_set_reacquisition(pid, client_fd, id, reacquisition);
1061         if (ret)
1062                 debug_error("failed to mm_sound_focus_socket_set_reacquisition(), ret[0x%x]", ret);
1063
1064         debug_fleave();
1065         return ret;
1066 }
1067
1068 int mm_sound_proxy_get_acquired_focus_stream_type(int focus_type, char **stream_type, int *option, char **ext_info)
1069 {
1070         int ret = MM_ERROR_NONE;
1071
1072         debug_fenter();
1073
1074         ret = mm_sound_focus_socket_get_acquired_focus_stream_type(focus_type, stream_type, option, ext_info);
1075         if (ret)
1076                 debug_error("failed to mm_sound_focus_socket_get_acquired_focus_stream_type(), ret[0x%x]", ret);
1077
1078         debug_fleave();
1079         return ret;
1080 }
1081
1082 int mm_sound_proxy_acquire_focus(int index, mm_sound_focus_type_e type, int option, const char *ext_info)
1083 {
1084         int ret = MM_ERROR_NONE;
1085         bool is_in_focus_cb_thread = false;
1086         int pid = g_focus_sound_handle[index].focus_pid;
1087         int client_fd = g_focus_sound_handle[index].client_fd;
1088         int id = g_focus_sound_handle[index].handle;
1089
1090         debug_fenter();
1091
1092         mm_sound_client_is_focus_cb_thread(g_thread_self(), &is_in_focus_cb_thread, NULL);
1093         if (!is_in_focus_cb_thread) {
1094                 if ((ret = mm_sound_focus_socket_acquire(pid, client_fd, id,
1095                                                                                                 type, option, ext_info ? ext_info : "", true)))
1096                         debug_error("failed to mm_sound_focus_socket_acquire(), ret[0x%x]", ret);
1097         } else {
1098                 GVariant *params = NULL, *result = NULL;
1099
1100                 if ((params = g_variant_new("(iiiis)", pid, id, type, option, ext_info ? ext_info : "")) == NULL) {
1101                         debug_error("Construct Param for method call failed");
1102                         return MM_ERROR_SOUND_INTERNAL;
1103                 }
1104
1105                 if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_FOCUS_SERVER, AUDIO_METHOD_ACQUIRE_FOCUS, params, &result)) != MM_ERROR_NONE)
1106                         debug_error("dbus acquire focus failed");
1107
1108                 g_variant_unref(result);
1109         }
1110
1111         debug_fleave();
1112
1113         return ret;
1114 }
1115
1116 int mm_sound_proxy_release_focus(int index, mm_sound_focus_type_e type, int option, const char *ext_info)
1117 {
1118         int ret = MM_ERROR_NONE;
1119         bool is_in_focus_cb_thread = false;
1120         int pid = g_focus_sound_handle[index].focus_pid;
1121         int client_fd = g_focus_sound_handle[index].client_fd;
1122         int id = g_focus_sound_handle[index].handle;
1123
1124         debug_fenter();
1125
1126         mm_sound_client_is_focus_cb_thread(g_thread_self(), &is_in_focus_cb_thread, NULL);
1127         if (!is_in_focus_cb_thread) {
1128                 if ((ret = mm_sound_focus_socket_release(pid, client_fd, id, type, option, ext_info ? ext_info : "", true)))
1129                         debug_error("failed to mm_sound_focus_socket_release(), ret[0x%x]", ret);
1130         } else {
1131                 GVariant *params = NULL, *result = NULL;
1132
1133                 if ((params = g_variant_new("(iiiis)", pid, id, type, option, ext_info ? ext_info : "")) == NULL) {
1134                         debug_error("Construct Param for method call failed");
1135                         return MM_ERROR_SOUND_INTERNAL;
1136                 }
1137
1138                 if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_FOCUS_SERVER, AUDIO_METHOD_RELEASE_FOCUS, params, &result)) != MM_ERROR_NONE)
1139                         debug_error("dbus release focus failed");
1140
1141                 g_variant_unref(result);
1142         }
1143
1144         debug_fleave();
1145
1146         return ret;
1147 }
1148
1149 int mm_sound_proxy_update_stream_focus_status(int focus_id, unsigned int status)
1150 {
1151         int ret = MM_ERROR_NONE;
1152         char *reply = NULL;
1153         GVariant *params = NULL, *result = NULL;
1154
1155         debug_fenter();
1156
1157         if ((params = g_variant_new("(iu)", focus_id, status)) == NULL) {
1158                 debug_error("Construct Param for method call failed");
1159                 return MM_ERROR_SOUND_INTERNAL;
1160         }
1161
1162         if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_STREAM_MANAGER, AUDIO_METHOD_UPDATE_STREAM_FOCUS_STATUS, params, &result)) != MM_ERROR_NONE)
1163                 debug_error("dbus set volume by type failed");
1164
1165         /* stream-manager always returns a string as return value */
1166         if (result) {
1167                 g_variant_get(result, "(&s)", &reply);
1168                 debug_log("reply : %s", reply);
1169                 if (strcmp(reply, "STREAM_MANAGER_RETURN_OK"))
1170                         ret = MM_ERROR_SOUND_INTERNAL;
1171                 g_variant_unref(result);
1172         } else {
1173                 debug_error("reply null");
1174                 ret = MM_ERROR_SOUND_INTERNAL;
1175         }
1176
1177         debug_fleave();
1178
1179         return ret;
1180 }
1181
1182 int mm_sound_proxy_deliver_focus(int src_index, int dst_index, mm_sound_focus_type_e focus_type)
1183 {
1184         int ret = MM_ERROR_NONE;
1185         int pid = g_focus_sound_handle[src_index].focus_pid;
1186         int src_client_fd = g_focus_sound_handle[src_index].client_fd;
1187         int src_server_fd = g_focus_sound_handle[src_index].handle;
1188         int dst_client_fd = g_focus_sound_handle[dst_index].client_fd;
1189         int dst_server_fd = g_focus_sound_handle[dst_index].handle;
1190
1191         debug_fenter();
1192
1193         ret = mm_sound_focus_socket_deliver(pid, src_client_fd, src_server_fd, dst_client_fd, dst_server_fd, focus_type);
1194         if (ret)
1195                 debug_error("failed to mm_sound_focus_socket_deliver(), ret[0x%x]", ret);
1196
1197         debug_fleave();
1198         return ret;
1199 }
1200
1201 int mm_sound_proxy_add_focus_watch_callback(int index, mm_sound_focus_type_e type)
1202 {
1203         int ret = MM_ERROR_NONE;
1204         int pid = g_focus_sound_handle[index].focus_pid;
1205         int id = 0;
1206         int client_fd = 0;
1207
1208         debug_fenter();
1209
1210         ret = mm_sound_focus_socket_add_watch_cb(pid, type, &client_fd, &id);
1211         if (ret) {
1212                 debug_error("failed to mm_sound_focus_socket_add_watch_cb(), ret[0x%x]", ret);
1213         } else {
1214                 g_focus_sound_handle[index].handle = id;
1215                 g_focus_sound_handle[index].client_fd = client_fd;
1216         }
1217
1218         debug_fleave();
1219
1220         return ret;
1221 }
1222
1223 int mm_sound_proxy_remove_focus_watch_callback(int index)
1224 {
1225         int ret = MM_ERROR_NONE;
1226         int pid = g_focus_sound_handle[index].focus_pid;
1227         int client_fd = g_focus_sound_handle[index].client_fd;
1228         int id = g_focus_sound_handle[index].handle;
1229
1230         debug_fenter();
1231
1232         ret = mm_sound_focus_socket_remove_watch_cb(pid, client_fd, id);
1233         if (ret)
1234                 debug_error("failed to mm_sound_focus_socket_remove_watch_cb(), ret[0x%x]", ret);
1235
1236         debug_fleave();
1237
1238         return ret;
1239 }
1240
1241 int mm_sound_proxy_initialize(void)
1242 {
1243         int ret = MM_ERROR_NONE;
1244
1245         debug_fenter();
1246         debug_fleave();
1247
1248         return ret;
1249 }
1250
1251 int mm_sound_proxy_finalize(void)
1252 {
1253         int ret = MM_ERROR_NONE;
1254
1255         debug_fenter();
1256         debug_fleave();
1257
1258         return ret;
1259 }