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