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
  12 struct callback_data {
  13         void *user_cb;
  14         void *user_data;
  15         mm_sound_proxy_userdata_free free_func;
  16         uint32_t subs_id;
  17 };
  18
  19 #define CB_DATA_NEW(_cb_data, _func, _userdata, _freefunc) \
  20         do { \
  21                 _cb_data = (struct callback_data*) g_malloc0(sizeof(struct callback_data)); \
  22                 _cb_data->user_cb = _func; \
  23                 _cb_data->user_data = _userdata; \
  24                 _cb_data->free_func = _freefunc; \
  25                 _cb_data->subs_id = 0; \
  26         } while (0)
  27
  28 /* subscribe is true when add callback,
  29  * false when remove callback */
  30 static int _notify_subscription(audio_event_t event, uint32_t subs_id, gboolean subscribe)
  31 {
  32         int ret = MM_ERROR_NONE;
  33         GVariant *params = NULL;
  34         const char *event_name = NULL;
  35
  36         debug_fenter();
  37
  38         if ((ret = mm_sound_dbus_get_event_name(event, &event_name) != MM_ERROR_NONE)) {
  39                 debug_error("Failed to get event name");
  40                 return MM_ERROR_SOUND_INTERNAL;
  41         }
  42
  43         if (!(params = g_variant_new("(sub)", event_name, subs_id, subscribe))) {
  44                 debug_error("Construct Param failed");
  45                 return MM_ERROR_SOUND_INTERNAL;
  46         }
  47
  48         if ((ret = mm_sound_dbus_emit_signal(AUDIO_PROVIDER_AUDIO_CLIENT, AUDIO_EVENT_CLIENT_SUBSCRIBED, params))) {
  49                 debug_error("dbus send signal for client subscribed failed");
  50         }
  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 /* This callback unmarshall general-formed paramters to subject specific parameters,
  83  * and call proper callback */
  84 static void dbus_callback(audio_event_t event, GVariant *params, void *userdata)
  85 {
  86         struct callback_data *cb_data  = (struct callback_data*) userdata;
  87         uint32_t event_id;
  88
  89         if (event == AUDIO_EVENT_VOLUME_CHANGED) {
  90                 char *volume_type_str = NULL, *direction = NULL;
  91                 unsigned volume_level;
  92
  93                 g_variant_get(params, "(&s&su)", &direction, &volume_type_str, &volume_level);
  94                 ((mm_sound_volume_changed_wrapper_cb)(cb_data->user_cb))(direction, volume_type_str, volume_level, cb_data->user_data);
  95         } else if (event == AUDIO_EVENT_DEVICE_CONNECTED) {
  96                 const char *name = NULL, *device_type = NULL;
  97                 gboolean is_connected = FALSE;
  98                 int device_id, io_direction, state;
  99
 100                 g_variant_get(params, "(u(i&sii&s)b)", &event_id, &device_id, &device_type, &io_direction,
 101                                         &state, &name, &is_connected);
 102                 ((mm_sound_device_connected_wrapper_cb)(cb_data->user_cb))(device_id, device_type, io_direction,
 103                         state, name, is_connected, cb_data->user_data);
 104                 _notify_signal_handled(event, event_id, cb_data->subs_id, g_variant_new("(ib)", device_id, is_connected));
 105         } else if (event == AUDIO_EVENT_DEVICE_INFO_CHANGED) {
 106                 const char *name = NULL, *device_type = NULL;
 107                 int changed_device_info_type = 0;
 108                 int device_id, io_direction, state;
 109
 110                 g_variant_get(params, "(u(i&sii&s)i)", &event_id, &device_id, &device_type, &io_direction,
 111                                         &state, &name, &changed_device_info_type);
 112                 ((mm_sound_device_info_changed_wrapper_cb)(cb_data->user_cb))(device_id, device_type, io_direction,
 113                         state, name, changed_device_info_type, cb_data->user_data);
 114         } else if (event == AUDIO_EVENT_FOCUS_CHANGED) {
 115         } else if (event == AUDIO_EVENT_FOCUS_WATCH) {
 116         } else if (event == AUDIO_EVENT_TEST) {
 117                 int test_var = 0;
 118                 g_variant_get(params, "(i)", &test_var);
 119                 ((mm_sound_test_cb)(cb_data->user_cb))(test_var, cb_data->user_data);
 120         } else if (event == AUDIO_EVENT_PLAY_FILE_END) {
 121                 int ended_handle = 0;
 122                 g_variant_get(params, "(i)", &ended_handle);
 123                 ((mm_sound_stop_callback_wrapper_func)(cb_data->user_cb))(ended_handle, cb_data->user_data);
 124         }
 125 }
 126
 127 static void simple_callback_data_free_func(void *data)
 128 {
 129         struct callback_data *cb_data = (struct callback_data*) data;
 130
 131         if (cb_data) {
 132                 if (cb_data->free_func)
 133                         cb_data->free_func(cb_data->user_data);
 134                 g_free(cb_data);
 135         }
 136 }
 137
 138 int mm_sound_proxy_add_test_callback(mm_sound_test_cb func, void *userdata, mm_sound_proxy_userdata_free freefunc, unsigned *subs_id)
 139 {
 140         int ret = MM_ERROR_NONE;
 141         struct callback_data *cb_data;
 142
 143         debug_fenter();
 144
 145         CB_DATA_NEW(cb_data, func, userdata, freefunc);
 146
 147         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)
 148                 debug_error("add test callback failed");
 149         else
 150                 *subs_id = cb_data->subs_id;
 151
 152         debug_fleave();
 153         return ret;
 154 }
 155
 156 int mm_sound_proxy_remove_test_callback(unsigned subs_id)
 157 {
 158         int ret = MM_ERROR_NONE;
 159         debug_fenter();
 160
 161         if ((ret = mm_sound_dbus_signal_unsubscribe(subs_id)) != MM_ERROR_NONE) {
 162                 debug_error("remove test callback failed");
 163         }
 164
 165         debug_fleave();
 166         return ret;
 167 }
 168
 169 int mm_sound_proxy_test(int a, int b, int *get)
 170 {
 171         int ret = MM_ERROR_NONE;
 172         int reply = 0;
 173         GVariant *params = NULL, *result = NULL;
 174
 175         debug_fenter();
 176
 177         params = g_variant_new("(ii)", a, b);
 178         if (params) {
 179                 if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_SOUND_SERVER, AUDIO_METHOD_TEST, params, &result)) != MM_ERROR_NONE) {
 180                         debug_error("dbus test call failed");
 181                         goto cleanup;
 182                 }
 183         } else {
 184                 debug_error("Construct Param for method call failed");
 185                 return MM_ERROR_SOUND_INTERNAL;
 186         }
 187
 188         if (result) {
 189                 g_variant_get(result, "(i)",  &reply);
 190                 debug_log("reply : %d", reply);
 191                 *get = reply;
 192         } else {
 193                 debug_error("reply null");
 194         }
 195
 196 cleanup:
 197         if (result)
 198                 g_variant_unref(result);
 199
 200         debug_fleave();
 201         return ret;
 202 }
 203
 204 int mm_sound_proxy_get_current_connected_device_list(int device_flags, GList** device_list)
 205 {
 206         int ret = MM_ERROR_NONE;
 207         GVariant *result = NULL, *child = NULL;
 208         GVariant *params = NULL;
 209         GVariantIter iter;
 210         mm_sound_device_t* device_item;
 211         const gchar *device_name_tmp = NULL, *device_type_tmp = NULL;
 212
 213         debug_fenter();
 214
 215         if (!device_list) {
 216                 debug_error("Invalid Parameter, device_list null");
 217                 ret = MM_ERROR_INVALID_ARGUMENT;
 218                 goto cleanup;
 219         }
 220
 221         params = g_variant_new("(i)", device_flags);
 222
 223         if (params) {
 224                 if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_DEVICE_MANAGER, AUDIO_METHOD_GET_CONNECTED_DEVICE_LIST, params, &result)) != MM_ERROR_NONE) {
 225                         debug_error("Get current connected device list failed");
 226                         goto cleanup;
 227                 }
 228         } else {
 229                 debug_error("Construct Param for get current connected device failed");
 230                 return MM_ERROR_SOUND_INTERNAL;
 231         }
 232
 233         child = g_variant_get_child_value(result, 0);
 234         g_variant_iter_init(&iter, child);
 235         while (1) {
 236                 device_item = g_malloc0(sizeof(mm_sound_device_t));
 237                 if (device_item && g_variant_iter_loop(&iter, "(i&sii&s)",
 238                                         &device_item->id, &device_type_tmp, &device_item->io_direction, &device_item->state,
 239                                         &device_name_tmp)) {
 240                         MMSOUND_STRNCPY(device_item->name, device_name_tmp, MAX_DEVICE_NAME_NUM);
 241                         MMSOUND_STRNCPY(device_item->type, device_type_tmp, MAX_DEVICE_TYPE_STR_LEN);
 242                         *device_list = g_list_append(*device_list, device_item);
 243                         debug_log("Added device id(%d) type(%17s) direction(%d) state(%d) name(%s)",
 244                                         device_item->id, device_item->type,device_item->io_direction, device_item->state,
 245                                         device_item->name);
 246                 } else {
 247                         if (device_item)
 248                                 g_free(device_item);
 249                         break;
 250                 }
 251         }
 252
 253 cleanup:
 254         if (result)
 255                 g_variant_unref(result);
 256
 257         debug_fleave();
 258         return ret;
 259 }
 260
 261 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)
 262 {
 263         int ret = MM_ERROR_NONE;
 264         struct callback_data *cb_data;
 265
 266         debug_fenter();
 267
 268         CB_DATA_NEW(cb_data, func, userdata, freefunc);
 269
 270         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) {
 271                 debug_error("add device connected callback failed");
 272                 goto finish;
 273         }
 274
 275         if ((ret = _notify_subscription(AUDIO_EVENT_DEVICE_CONNECTED, cb_data->subs_id, TRUE)) != MM_ERROR_NONE) {
 276                 debug_error("failed to notify subscription of device connected event");
 277                 goto finish;
 278         }
 279
 280         *subs_id = cb_data->subs_id;
 281
 282 finish:
 283         debug_fleave();
 284         return ret;
 285 }
 286
 287 int mm_sound_proxy_remove_device_connected_callback(unsigned subs_id)
 288 {
 289         int ret = MM_ERROR_NONE;
 290         debug_fenter();
 291
 292         if ((ret = mm_sound_dbus_signal_unsubscribe(subs_id)) != MM_ERROR_NONE) {
 293                 debug_error("remove device connected callback failed");
 294                 goto finish;
 295         }
 296
 297         if ((ret = _notify_subscription(AUDIO_EVENT_DEVICE_CONNECTED, subs_id, FALSE)) != MM_ERROR_NONE)
 298                 debug_error("failed to notify unsubscription of device connected event");
 299
 300 finish:
 301         debug_fleave();
 302         return ret;
 303 }
 304
 305 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)
 306 {
 307         int ret = MM_ERROR_NONE;
 308         struct callback_data *cb_data;
 309
 310         debug_fenter();
 311
 312         CB_DATA_NEW(cb_data, func, userdata, freefunc);
 313
 314         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)
 315                 debug_error("Add device info changed callback failed");
 316         else
 317                 *subs_id = cb_data->subs_id;
 318
 319         debug_fleave();
 320         return ret;
 321 }
 322
 323 int mm_sound_proxy_remove_device_info_changed_callback(unsigned subs_id)
 324 {
 325         int ret = MM_ERROR_NONE;
 326         debug_fenter();
 327
 328         if ((ret = mm_sound_dbus_signal_unsubscribe(subs_id)) != MM_ERROR_NONE) {
 329                 debug_error("remove device info changed callback failed");
 330         }
 331
 332         debug_fleave();
 333         return ret;
 334 }
 335
 336 int mm_sound_proxy_set_volume_by_type(const char *volume_type, const unsigned volume_level)
 337 {
 338         int ret = MM_ERROR_NONE;
 339         char *reply = NULL, *direction = "out";
 340         GVariant *params = NULL, *result = NULL;
 341
 342         debug_fenter();
 343
 344         params = g_variant_new("(ssu)", direction, volume_type, volume_level);
 345         if (params) {
 346                 if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_STREAM_MANAGER, AUDIO_METHOD_SET_VOLUME_LEVEL, params, &result)) != MM_ERROR_NONE) {
 347                         debug_error("dbus set volume by type failed");
 348                         goto cleanup;
 349                 }
 350         } else {
 351                 debug_error("Construct Param for method call failed");
 352                 return MM_ERROR_SOUND_INTERNAL;
 353         }
 354
 355         if (result) {
 356                 g_variant_get(result, "(&s)",  &reply);
 357                 debug_log("reply : %s", reply);
 358                 if (!strcmp(reply, "STREAM_MANAGER_RETURN_ERROR"))
 359                         ret = MM_ERROR_SOUND_INTERNAL;
 360         } else {
 361                 debug_error("reply null");
 362         }
 363
 364 cleanup:
 365         if (result)
 366                 g_variant_unref(result);
 367
 368         debug_fleave();
 369         return ret;
 370 }
 371
 372 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)
 373 {
 374         int ret = MM_ERROR_NONE;
 375         struct callback_data *cb_data;
 376
 377         debug_fenter();
 378
 379         CB_DATA_NEW(cb_data, func, userdata, freefunc);
 380
 381         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)
 382                 debug_error("Add Volume changed callback failed");
 383         else
 384                 *subs_id = cb_data->subs_id;
 385
 386
 387         debug_fleave();
 388
 389         return ret;
 390 }
 391
 392 int mm_sound_proxy_remove_volume_changed_callback(unsigned subs_id)
 393 {
 394         int ret = MM_ERROR_NONE;
 395         debug_fenter();
 396
 397         if ((ret = mm_sound_dbus_signal_unsubscribe(subs_id)) != MM_ERROR_NONE) {
 398                 debug_error("Remove Volume changed callback failed");
 399         }
 400
 401         debug_fleave();
 402         return ret;
 403 }
 404
 405 int mm_sound_proxy_play_tone(int tone, int repeat, int volume, int volume_config,
 406                            int session_type, int session_options, int client_pid,
 407                            bool enable_session, int *codechandle, char *stream_type, int stream_index)
 408 {
 409         int ret = MM_ERROR_NONE;
 410         int handle = 0;
 411         GVariant *params = NULL, *result = NULL;
 412         gboolean _enable_session = enable_session;
 413
 414         if (!codechandle) {
 415                 debug_error("Param for play is null");
 416                 return MM_ERROR_INVALID_ARGUMENT;
 417         }
 418
 419         debug_fenter();
 420
 421         params = g_variant_new("(iiiiiiibsi)", tone, repeat, volume,
 422                       volume_config, session_type, session_options, client_pid , _enable_session, stream_type, stream_index);
 423         if (params) {
 424                 if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_SOUND_SERVER, AUDIO_METHOD_PLAY_DTMF, params, &result)) != MM_ERROR_NONE) {
 425                         debug_error("dbus play tone failed");
 426                         goto cleanup;
 427                 }
 428         } else {
 429                 debug_error("Construct Param for method call failed");
 430         }
 431
 432         if (result) {
 433                 g_variant_get(result, "(i)",  &handle);
 434                 debug_log("handle : %d", handle);
 435                 *codechandle = handle;
 436         } else {
 437                 debug_error("reply null");
 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_play_tone_with_stream_info(int client_pid, int tone, char *stream_type, int stream_index, int volume, int repeat, int *codechandle)
 449 {
 450         int ret = MM_ERROR_NONE;
 451         int handle = 0;
 452         GVariant *params = NULL, *result = NULL;
 453
 454         debug_fenter();
 455
 456         if (!codechandle) {
 457                 debug_error("Param for play is null");
 458                 return MM_ERROR_INVALID_ARGUMENT;
 459         }
 460
 461         params = g_variant_new("(iiiisi)", tone, repeat, volume, client_pid, stream_type, stream_index);
 462         if (params) {
 463                 if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_SOUND_SERVER, AUDIO_METHOD_PLAY_DTMF_WITH_STREAM_INFO, params, &result)) != MM_ERROR_NONE) {
 464                         debug_error("dbus play tone failed");
 465                         goto cleanup;
 466                 }
 467         } else {
 468                 debug_error("Construct Param for method call failed");
 469         }
 470
 471         if (result) {
 472                 g_variant_get(result, "(i)",  &handle);
 473                 debug_log("handle : %d", handle);
 474                 *codechandle = handle;
 475         } else {
 476                 debug_error("reply null");
 477         }
 478
 479 cleanup:
 480         if (result)
 481                 g_variant_unref(result);
 482
 483         debug_fleave();
 484         return ret;
 485 }
 486
 487 int mm_sound_proxy_play_sound(const char* filename, int tone, int repeat, int volume, int volume_config,
 488                            int priority, int session_type, int session_options, int client_pid, int handle_route,
 489                            bool enable_session, int *codechandle, char *stream_type, int stream_index)
 490 {
 491         int ret = MM_ERROR_NONE;
 492         int handle = 0;
 493         GVariant *params = NULL, *result = NULL;
 494         gboolean _enable_session = enable_session;
 495
 496         if (!filename || !codechandle) {
 497                 debug_error("Param for play is null");
 498                 return MM_ERROR_INVALID_ARGUMENT;
 499         }
 500
 501         debug_fenter();
 502
 503         params = g_variant_new("(siiiiiiiiibsi)", filename, tone, repeat, volume,
 504                       volume_config, priority, session_type, session_options, client_pid, handle_route, _enable_session, stream_type, stream_index);
 505         if (params) {
 506                 if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_SOUND_SERVER, AUDIO_METHOD_PLAY_FILE_START, params, &result)) != MM_ERROR_NONE) {
 507                         debug_error("dbus play file failed");
 508                         goto cleanup;
 509                 }
 510         } else {
 511                 debug_error("Construct Param for method call failed");
 512         }
 513
 514         if (result) {
 515                 g_variant_get(result, "(i)",  &handle);
 516                 debug_log("handle : %d", handle);
 517                 *codechandle = handle;
 518         } else {
 519                 debug_error("reply null");
 520         }
 521
 522 cleanup:
 523         if (result)
 524                 g_variant_unref(result);
 525
 526         debug_fleave();
 527         return ret;
 528 }
 529
 530 int mm_sound_proxy_play_sound_with_stream_info(const char* filename, int repeat, int volume,
 531                                 int priority, int client_pid, int handle_route, int *codechandle, char *stream_type, int stream_index)
 532 {
 533         int ret = MM_ERROR_NONE;
 534         int handle = 0;
 535         GVariant *params = NULL, *result = NULL;
 536
 537         if (!filename || !codechandle) {
 538                 debug_error("Param for play is null");
 539                 return MM_ERROR_INVALID_ARGUMENT;
 540         }
 541
 542         debug_fenter();
 543
 544         params = g_variant_new("(siiiiisi)", filename, repeat, volume,
 545                         priority, client_pid, handle_route, stream_type, stream_index);
 546         if (params) {
 547                 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) {
 548                         debug_error("dbus play file failed");
 549                         goto cleanup;
 550                 }
 551         } else {
 552                 debug_error("Construct Param for method call failed");
 553         }
 554
 555         if (result) {
 556                 g_variant_get(result, "(i)",  &handle);
 557                 debug_log("handle : %d", handle);
 558                 *codechandle = handle;
 559         } else {
 560                 debug_error("reply null");
 561         }
 562
 563 cleanup:
 564         if (result)
 565                 g_variant_unref(result);
 566
 567         debug_fleave();
 568         return ret;
 569
 570
 571 }
 572
 573 int mm_sound_proxy_stop_sound(int handle)
 574 {
 575         int ret = MM_ERROR_NONE;
 576         GVariant *result = NULL;
 577
 578         debug_fenter();
 579
 580         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) {
 581                 debug_error("dbus stop file playing failed");
 582                 goto cleanup;
 583         }
 584
 585 cleanup:
 586         if (result)
 587                 g_variant_unref(result);
 588
 589         debug_fleave();
 590         return ret;
 591 }
 592
 593 int mm_sound_proxy_clear_focus(int pid)
 594 {
 595         int ret = MM_ERROR_NONE;
 596         GVariant *result = NULL;
 597
 598         debug_fenter();
 599
 600         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) {
 601                 debug_error("dbus clear focus failed");
 602         }
 603
 604         if (result)
 605                 g_variant_unref(result);
 606
 607         debug_fleave();
 608         return ret;
 609 }
 610
 611 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)
 612 {
 613         int ret = MM_ERROR_NONE;
 614         struct callback_data *cb_data;
 615
 616         debug_fenter();
 617
 618         CB_DATA_NEW(cb_data, func, userdata, freefunc);
 619
 620         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)
 621                 debug_error("add play sound end callback failed");
 622         else
 623                 *subs_id = cb_data->subs_id;
 624
 625         debug_fleave();
 626
 627         return ret;
 628 }
 629
 630 int mm_sound_proxy_remove_play_sound_end_callback(unsigned subs_id)
 631 {
 632         int ret = MM_ERROR_NONE;
 633         debug_fenter();
 634
 635         if ((ret = mm_sound_dbus_signal_unsubscribe(subs_id)) != MM_ERROR_NONE) {
 636                 debug_error("Remove Play File End callback failed");
 637         }
 638
 639         debug_fleave();
 640         return ret;
 641 }
 642
 643 int mm_sound_proxy_emergent_exit(int exit_pid)
 644 {
 645         int ret = MM_ERROR_NONE;
 646         GVariant *params = NULL;
 647
 648         debug_fenter();
 649
 650         params = g_variant_new("(i)", exit_pid);
 651         if (params) {
 652                 if ((ret = mm_sound_dbus_emit_signal(AUDIO_PROVIDER_AUDIO_CLIENT, AUDIO_EVENT_EMERGENT_EXIT, params)) != MM_ERROR_NONE) {
 653                         debug_error("dbus emergent exit failed");
 654                         goto cleanup;
 655                 }
 656         } else {
 657                 debug_error("Construct Param for emergent exit signal failed");
 658                 ret = MM_ERROR_SOUND_INTERNAL;
 659         }
 660
 661 cleanup:
 662
 663         debug_fleave();
 664         return ret;
 665 }
 666
 667 /*------------------------------------------ FOCUS --------------------------------------------------*/
 668 #ifdef USE_FOCUS
 669
 670 int mm_sound_proxy_get_unique_id(int *id)
 671 {
 672         int ret = MM_ERROR_NONE;
 673         int res = 0;
 674         GVariant *result = NULL;
 675
 676         debug_fenter();
 677
 678         if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_FOCUS_SERVER, AUDIO_METHOD_GET_UNIQUE_ID, NULL, &result)) != MM_ERROR_NONE) {
 679                 debug_error("dbus get unique id failed");
 680         }
 681
 682         if (result) {
 683                 g_variant_get(result, "(i)", &res);
 684                 *id = res;
 685                 debug_msg("got unique id(%d)", *id);
 686                 g_variant_unref(result);
 687         }
 688
 689         debug_fleave();
 690
 691         return ret;
 692 }
 693
 694 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)
 695 {
 696         int ret = MM_ERROR_NONE;
 697         GVariant *params = NULL, *result = NULL;
 698
 699         debug_fenter();
 700
 701         params = g_variant_new("(iisb)", instance, id, stream_type, is_for_session);
 702         if (params) {
 703                 if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_FOCUS_SERVER, AUDIO_METHOD_REGISTER_FOCUS, params, &result)) != MM_ERROR_NONE) {
 704                         debug_error("dbus register focus failed");
 705                 }
 706         } else {
 707                 debug_error("Construct Param for method call failed");
 708         }
 709
 710         if (ret != MM_ERROR_NONE)
 711                 g_variant_get(result, "(i)",  &ret);
 712         if (result)
 713                 g_variant_unref(result);
 714
 715         debug_fleave();
 716
 717         return ret;
 718
 719 }
 720
 721 int mm_sound_proxy_unregister_focus(int instance, int id, bool is_for_session)
 722 {
 723         int ret = MM_ERROR_NONE;
 724         GVariant *params = NULL, *result = NULL;
 725
 726         debug_fenter();
 727
 728         params = g_variant_new("(iib)", instance, id, is_for_session);
 729         if (params) {
 730                 if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_FOCUS_SERVER, AUDIO_METHOD_UNREGISTER_FOCUS, params, &result)) != MM_ERROR_NONE) {
 731                         debug_error("dbus unregister focus failed");
 732                 }
 733         } else {
 734                 debug_error("Construct Param for method call failed");
 735         }
 736
 737         if (ret != MM_ERROR_NONE)
 738                 g_variant_get(result, "(i)",  &ret);
 739         if (result)
 740                 g_variant_unref(result);
 741
 742         debug_fleave();
 743
 744         return ret;
 745 }
 746
 747 int mm_sound_proxy_set_foucs_reacquisition(int instance, int id, bool reacquisition)
 748 {
 749         int ret = MM_ERROR_NONE;
 750         GVariant *params = NULL, *result = NULL;
 751
 752         debug_fenter();
 753
 754         params = g_variant_new("(iib)", instance, id, reacquisition);
 755         if (params) {
 756                 if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_FOCUS_SERVER, AUDIO_METHOD_SET_FOCUS_REACQUISITION, params, &result)) != MM_ERROR_NONE) {
 757                         debug_error("dbus set focus reacquisition failed");
 758                 }
 759         } else {
 760                 debug_error("Construct Param for method call failed");
 761         }
 762
 763         if (ret != MM_ERROR_NONE)
 764                 g_variant_get(result, "(i)",  &ret);
 765         if (result)
 766                 g_variant_unref(result);
 767
 768         debug_fleave();
 769         return ret;
 770 }
 771
 772 int mm_sound_proxy_get_acquired_focus_stream_type(int focus_type, char **stream_type, int *option, char **ext_info)
 773 {
 774         int ret = MM_ERROR_NONE;
 775         GVariant *params = NULL, *result = NULL;
 776
 777         debug_fenter();
 778
 779         if (!(params = g_variant_new("(i)", focus_type))) {
 780                 debug_error("Construct Param for method call failed");
 781                 return MM_ERROR_SOUND_INTERNAL;
 782         }
 783
 784         if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_FOCUS_SERVER, AUDIO_METHOD_GET_ACQUIRED_FOCUS_STREAM_TYPE, params, &result)) == MM_ERROR_NONE) {
 785                 if (result) {
 786                         g_variant_get(result, "(sis)", stream_type, option, ext_info);
 787                         g_variant_unref(result);
 788                 }
 789         } else {
 790                 debug_error("dbus get stream type of acquired focus failed");
 791         }
 792
 793         debug_fleave();
 794         return ret;
 795 }
 796
 797 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)
 798 {
 799         int ret = MM_ERROR_NONE;
 800         GVariant *params = NULL, *result = NULL;
 801
 802         debug_fenter();
 803
 804         params = g_variant_new("(iiiisb)", instance, id, type, option, ext_info ? ext_info : "", is_for_session);
 805         if (params) {
 806                 if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_FOCUS_SERVER, AUDIO_METHOD_ACQUIRE_FOCUS, params, &result)) != MM_ERROR_NONE) {
 807                         debug_error("dbus acquire focus failed");
 808                 }
 809         } else {
 810                 debug_error("Construct Param for method call failed");
 811         }
 812
 813         if (ret != MM_ERROR_NONE)
 814                 g_variant_get(result, "(i)",  &ret);
 815         if (result)
 816                 g_variant_unref(result);
 817
 818         debug_fleave();
 819         return ret;
 820 }
 821
 822 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)
 823 {
 824         int ret = MM_ERROR_NONE;
 825         GVariant *params = NULL, *result = NULL;
 826
 827         debug_fenter();
 828
 829         params = g_variant_new("(iiiisb)", instance, id, type, option, ext_info ? ext_info : "", is_for_session);
 830         if (params) {
 831                 if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_FOCUS_SERVER, AUDIO_METHOD_RELEASE_FOCUS, params, &result)) != MM_ERROR_NONE) {
 832                         debug_error("dbus release focus failed");
 833                 }
 834         } else {
 835                 debug_error("Construct Param for method call failed");
 836         }
 837
 838         if (ret != MM_ERROR_NONE)
 839                 g_variant_get(result, "(i)",  &ret);
 840         if (result)
 841                 g_variant_unref(result);
 842
 843         debug_fleave();
 844         return ret;
 845 }
 846
 847 int mm_sound_proxy_set_focus_watch_callback(int instance, int handle, mm_sound_focus_type_e type, mm_sound_focus_changed_watch_cb callback, bool is_for_session, void* userdata)
 848 {
 849         int ret = MM_ERROR_NONE;
 850         GVariant *params = NULL, *result = NULL;
 851
 852         debug_fenter();
 853
 854         params = g_variant_new("(iiib)", instance, handle, type, is_for_session);
 855         if (params) {
 856                 if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_FOCUS_SERVER, AUDIO_METHOD_WATCH_FOCUS, params, &result)) != MM_ERROR_NONE) {
 857                         debug_error("dbus set watch focus failed");
 858                 }
 859         } else {
 860                 debug_error("Construct Param for method call failed");
 861         }
 862
 863         if (ret != MM_ERROR_NONE)
 864                 g_variant_get(result, "(i)",  &ret);
 865         if (result)
 866                 g_variant_unref(result);
 867         debug_fleave();
 868
 869         return ret;
 870
 871 }
 872
 873 int mm_sound_proxy_unset_focus_watch_callback(int focus_tid, int handle, bool is_for_session)
 874 {
 875         int ret = MM_ERROR_NONE;
 876         GVariant *params = NULL, *result = NULL;
 877
 878         debug_fenter();
 879
 880         params = g_variant_new("(iib)", focus_tid, handle, is_for_session);
 881         if (params) {
 882                 if ((ret = mm_sound_dbus_method_call_to(AUDIO_PROVIDER_FOCUS_SERVER, AUDIO_METHOD_UNWATCH_FOCUS, params, &result)) != MM_ERROR_NONE) {
 883                         debug_error("dbus unset watch focus failed");
 884                 }
 885         } else {
 886                 debug_error("Construct Param for method call failed");
 887         }
 888         if (ret != MM_ERROR_NONE)
 889                 g_variant_get(result, "(i)",  &ret);
 890         if (result)
 891                 g_variant_unref(result);
 892
 893         debug_fleave();
 894
 895         return ret;
 896 }
 897
 898 #endif /* USE_FOCUS */
 899 /*------------------------------------------ FOCUS --------------------------------------------------*/
 900
 901 int mm_sound_proxy_initialize(void)
 902 {
 903         int ret = MM_ERROR_NONE;
 904
 905         debug_fenter();
 906         debug_fleave();
 907
 908         return ret;
 909 }
 910
 911 int mm_sound_proxy_finalize(void)
 912 {
 913         int ret = MM_ERROR_NONE;
 914
 915         debug_fenter();
 916         debug_fleave();
 917
 918         return ret;
 919 }