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