mm_sound_proxy.c

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