bt-api/bt-audio.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *              http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <stdio.h>
  19
  20 #include "bluetooth-api.h"
  21 #include "bluetooth-audio-api.h"
  22 #include "bt-internal-types.h"
  23
  24 #include "bt-common.h"
  25 #include "bt-request-sender.h"
  26 #include "bt-event-handler.h"
  27 #ifdef TIZEN_FEATURE_BT_DPM
  28 #include "bt-dpm.h"
  29 #endif
  30
  31 BT_EXPORT_API int bluetooth_audio_init(bt_audio_func_ptr cb, void *user_data)
  32 {
  33         int ret;
  34
  35         if (cb == NULL) {
  36                 BT_ERR("callback is NULL");
  37                 return BLUETOOTH_ERROR_INVALID_PARAM;
  38         }
  39         ret = _bt_init_event_handler();
  40
  41         if (ret != BLUETOOTH_ERROR_NONE &&
  42              ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
  43                 BT_ERR("Fail to init the event handler");
  44                 return ret;
  45         }
  46
  47         _bt_set_user_data(BT_AUDIO, (void *)cb, user_data);
  48
  49         /* Register All events */
  50         ret = _bt_register_event(BT_HEADSET_EVENT, (void *)cb, user_data);
  51         if (ret != BLUETOOTH_ERROR_NONE &&
  52             ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
  53                 _bt_deinit_event_handler();
  54                 return ret;
  55         }
  56
  57         ret = _bt_register_event(BT_A2DP_SOURCE_EVENT, (void *)cb, user_data);
  58         if (ret != BLUETOOTH_ERROR_NONE &&
  59                         ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
  60                 _bt_deinit_event_handler();
  61                 return ret;
  62         }
  63
  64         return BLUETOOTH_ERROR_NONE;
  65 }
  66
  67 BT_EXPORT_API int bluetooth_audio_deinit(void)
  68 {
  69         _bt_unregister_event(BT_HEADSET_EVENT);
  70         _bt_unregister_event(BT_A2DP_SOURCE_EVENT);
  71         _bt_set_user_data(BT_AUDIO, NULL, NULL);
  72
  73         return BLUETOOTH_ERROR_NONE;
  74 }
  75
  76 BT_EXPORT_API int bluetooth_audio_connect(bluetooth_device_address_t *remote_address)
  77 {
  78         int service_function = BT_AUDIO_CONNECT;
  79         int result;
  80         bt_user_info_t *user_info;
  81
  82         BT_CHECK_PARAMETER(remote_address, return);
  83         BT_CHECK_ENABLED(return);
  84
  85         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AUDIO_CONNECT)
  86              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
  87                 BT_ERR("Don't have a privilege to use this API");
  88                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
  89         }
  90
  91 #ifdef TIZEN_FEATURE_BT_DPM
  92         if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_address) == BT_DPM_RESTRICTED) {
  93                 BT_ERR("Blacklist device");
  94                 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
  95         }
  96
  97         if (_bt_check_dpm(BT_DPM_HSP, NULL) == BT_DPM_RESTRICTED &&
  98                  _bt_check_dpm(BT_DPM_A2DP, NULL) == BT_DPM_RESTRICTED) {
  99                 BT_ERR("Not allow to use HSP / A2DP profile");
 100                 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 101         } else if (_bt_check_dpm(BT_DPM_HSP, NULL) == BT_DPM_RESTRICTED) {
 102                 BT_ERR("Not allow to use HSP profile");
 103                 service_function = BT_AV_CONNECT;
 104         } else if (_bt_check_dpm(BT_DPM_A2DP, NULL) == BT_DPM_RESTRICTED) {
 105                 BT_ERR("Not allow to use A2DP profile");
 106                 service_function = BT_AG_CONNECT;
 107         }
 108
 109         if (_bt_check_dpm(BT_DPM_DESKTOP, NULL) == BT_DPM_RESTRICTED) {
 110                 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
 111                 bluetooth_device_class_t dev_class;
 112
 113                 _bt_convert_addr_type_to_string(address, remote_address->addr);
 114                 _bt_get_cod_by_address(address, &dev_class);
 115
 116                 if (dev_class.major_class == BLUETOOTH_DEVICE_MAJOR_CLASS_COMPUTER) {
 117                         BT_ERR("Reject a authorization due to MDM Policy");
 118                         return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 119                 }
 120         }
 121 #endif
 122
 123         user_info = _bt_get_user_data(BT_AUDIO);
 124         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 125
 126         BT_INIT_PARAMS();
 127         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 128
 129         g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
 130
 131 #ifdef TIZEN_FEATURE_BT_DPM
 132         if (service_function == BT_AV_CONNECT)
 133                 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AV_CONNECT,
 134                                 in_param1, in_param2, in_param3, in_param4,
 135                                 user_info->cb, user_info->user_data);
 136         else if (service_function == BT_AG_CONNECT)
 137                 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AG_CONNECT,
 138                                 in_param1, in_param2, in_param3, in_param4,
 139                                 user_info->cb, user_info->user_data);
 140         else /* default case - with or without DPM enabled */
 141 #endif
 142                 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AUDIO_CONNECT,
 143                                 in_param1, in_param2, in_param3, in_param4,
 144                                 user_info->cb, user_info->user_data);
 145
 146         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 147
 148         return result;
 149 }
 150
 151 BT_EXPORT_API int bluetooth_audio_disconnect(bluetooth_device_address_t *remote_address)
 152 {
 153         int result;
 154         bt_user_info_t *user_info;
 155
 156         BT_CHECK_PARAMETER(remote_address, return);
 157         BT_CHECK_ENABLED(return);
 158
 159         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AUDIO_DISCONNECT)
 160              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 161                 BT_ERR("Don't have a privilege to use this API");
 162                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 163         }
 164
 165         user_info = _bt_get_user_data(BT_AUDIO);
 166         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 167
 168         BT_INIT_PARAMS();
 169         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 170
 171         g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
 172
 173         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AUDIO_DISCONNECT,
 174                 in_param1, in_param2, in_param3, in_param4,
 175                 user_info->cb, user_info->user_data);
 176
 177         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 178
 179         return result;
 180 }
 181
 182 BT_EXPORT_API int bluetooth_ag_connect(bluetooth_device_address_t *remote_address)
 183 {
 184         int result;
 185         bt_user_info_t *user_info;
 186
 187         BT_CHECK_PARAMETER(remote_address, return);
 188         BT_CHECK_ENABLED(return);
 189
 190         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AG_CONNECT)
 191              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 192                 BT_ERR("Don't have a privilege to use this API");
 193                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 194         }
 195
 196 #ifdef TIZEN_FEATURE_BT_DPM
 197         if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_address) == BT_DPM_RESTRICTED) {
 198                 BT_ERR("Blacklist device");
 199                 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 200         }
 201
 202         if (_bt_check_dpm(BT_DPM_HSP, NULL) == BT_DPM_RESTRICTED) {
 203                 BT_ERR("Not allow to use HSP profile");
 204                 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 205         }
 206
 207         if (_bt_check_dpm(BT_DPM_DESKTOP, NULL) == BT_DPM_RESTRICTED) {
 208                 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
 209                 bluetooth_device_class_t dev_class;
 210
 211                 _bt_convert_addr_type_to_string(address, remote_address->addr);
 212                 _bt_get_cod_by_address(address, &dev_class);
 213
 214                 if (dev_class.major_class == BLUETOOTH_DEVICE_MAJOR_CLASS_COMPUTER) {
 215                         BT_ERR("Reject a authorization due to MDM Policy");
 216                         return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 217                 }
 218         }
 219 #endif
 220
 221         user_info = _bt_get_user_data(BT_AUDIO);
 222         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 223
 224         BT_INIT_PARAMS();
 225         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 226
 227         g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
 228
 229         BT_INFO_C("### Connect AG");
 230         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AG_CONNECT,
 231                 in_param1, in_param2, in_param3, in_param4,
 232                 user_info->cb, user_info->user_data);
 233
 234         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 235
 236         return result;
 237 }
 238
 239 BT_EXPORT_API int bluetooth_ag_disconnect(bluetooth_device_address_t *remote_address)
 240 {
 241         int result;
 242         bt_user_info_t *user_info;
 243
 244         BT_CHECK_PARAMETER(remote_address, return);
 245         BT_CHECK_ENABLED(return);
 246
 247         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AG_DISCONNECT)
 248              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 249                 BT_ERR("Don't have a privilege to use this API");
 250                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 251         }
 252
 253         user_info = _bt_get_user_data(BT_AUDIO);
 254         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 255
 256         BT_INIT_PARAMS();
 257         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 258
 259         g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
 260
 261         BT_INFO_C("### Disconnect AG");
 262         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AG_DISCONNECT,
 263                 in_param1, in_param2, in_param3, in_param4,
 264                 user_info->cb, user_info->user_data);
 265
 266         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 267
 268         return result;
 269 }
 270
 271 BT_EXPORT_API int bluetooth_av_connect(bluetooth_device_address_t *remote_address)
 272 {
 273         int result;
 274         bt_user_info_t *user_info;
 275
 276         BT_CHECK_PARAMETER(remote_address, return);
 277         BT_CHECK_ENABLED(return);
 278
 279         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AV_CONNECT)
 280              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 281                 BT_ERR("Don't have a privilege to use this API");
 282                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 283         }
 284
 285 #ifdef TIZEN_FEATURE_BT_DPM
 286         if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_address) == BT_DPM_RESTRICTED) {
 287                 BT_ERR("Blacklist device");
 288                 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 289         }
 290
 291         if (_bt_check_dpm(BT_DPM_A2DP, NULL) == BT_DPM_RESTRICTED) {
 292                 BT_ERR("Not allow to use A2DP profile");
 293                 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 294         }
 295
 296         if (_bt_check_dpm(BT_DPM_DESKTOP, NULL) == BT_DPM_RESTRICTED) {
 297                 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
 298                 bluetooth_device_class_t dev_class;
 299
 300                 _bt_convert_addr_type_to_string(address, remote_address->addr);
 301                 _bt_get_cod_by_address(address, &dev_class);
 302
 303                 if (dev_class.major_class == BLUETOOTH_DEVICE_MAJOR_CLASS_COMPUTER) {
 304                         BT_ERR("Reject a authorization due to MDM Policy");
 305                         return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 306                 }
 307         }
 308 #endif
 309
 310         user_info = _bt_get_user_data(BT_AUDIO);
 311         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 312
 313         BT_INIT_PARAMS();
 314         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 315
 316         g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
 317
 318         BT_INFO_C("### Connect AV");
 319         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AV_CONNECT,
 320                 in_param1, in_param2, in_param3, in_param4,
 321                 user_info->cb, user_info->user_data);
 322
 323         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 324
 325         return result;
 326 }
 327
 328 BT_EXPORT_API int bluetooth_av_source_connect(bluetooth_device_address_t *remote_address)
 329 {
 330         int result;
 331         bt_user_info_t *user_info;
 332
 333         BT_CHECK_PARAMETER(remote_address, return);
 334         BT_CHECK_ENABLED(return);
 335
 336         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AV_SOURCE_CONNECT)
 337                  == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 338                 BT_ERR("Don't have a privilege to use this API");
 339                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 340         }
 341
 342 #ifdef TIZEN_FEATURE_BT_DPM
 343         if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_address) == BT_DPM_RESTRICTED) {
 344                 BT_ERR("Blacklist device");
 345                 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 346         }
 347
 348         if (_bt_check_dpm(BT_DPM_A2DP, NULL) == BT_DPM_RESTRICTED) {
 349                 BT_ERR("Not allow to use A2DP profile");
 350                 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 351         }
 352 #endif
 353
 354         user_info = _bt_get_user_data(BT_AUDIO);
 355         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 356
 357         BT_INIT_PARAMS();
 358         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 359
 360         g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
 361
 362         BT_INFO_C("### Connect AV Source");
 363         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AV_SOURCE_CONNECT,
 364                 in_param1, in_param2, in_param3, in_param4,
 365                 user_info->cb, user_info->user_data);
 366
 367         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 368
 369         return result;
 370 }
 371
 372 BT_EXPORT_API int bluetooth_av_disconnect(bluetooth_device_address_t *remote_address)
 373 {
 374         int result;
 375         bt_user_info_t *user_info;
 376
 377         BT_CHECK_PARAMETER(remote_address, return);
 378         BT_CHECK_ENABLED(return);
 379
 380         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AV_DISCONNECT)
 381              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 382                 BT_ERR("Don't have a privilege to use this API");
 383                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 384         }
 385
 386         user_info = _bt_get_user_data(BT_AUDIO);
 387         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 388
 389         BT_INIT_PARAMS();
 390         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 391
 392         g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
 393
 394         BT_INFO_C("### Disconnect AV");
 395         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AV_DISCONNECT,
 396                 in_param1, in_param2, in_param3, in_param4,
 397                 user_info->cb, user_info->user_data);
 398
 399         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 400
 401         return result;
 402 }
 403
 404 BT_EXPORT_API int bluetooth_av_source_disconnect(bluetooth_device_address_t *remote_address)
 405 {
 406         int result;
 407         bt_user_info_t *user_info;
 408
 409         BT_CHECK_PARAMETER(remote_address, return);
 410         BT_CHECK_ENABLED(return);
 411
 412         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AV_SOURCE_DISCONNECT)
 413              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 414                 BT_ERR("Don't have a privilege to use this API");
 415                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 416         }
 417
 418         user_info = _bt_get_user_data(BT_AUDIO);
 419         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 420
 421         BT_INIT_PARAMS();
 422         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 423
 424         g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
 425
 426         BT_INFO_C("### Disconnect AV Source");
 427         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AV_SOURCE_DISCONNECT,
 428                 in_param1, in_param2, in_param3, in_param4,
 429                 user_info->cb, user_info->user_data);
 430
 431         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 432
 433         return result;
 434 }
 435
 436 BT_EXPORT_API int bluetooth_audio_select_role(bluetooth_audio_role_t role)
 437 {
 438         int result;
 439
 440         BT_CHECK_ENABLED(return);
 441
 442         BT_INIT_PARAMS();
 443         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 444
 445         g_array_append_vals(in_param1, &role, sizeof(bluetooth_audio_role_t));
 446
 447         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_AUDIO_SELECT_ROLE,
 448                 in_param1, in_param2, in_param3, in_param4, &out_param);
 449
 450         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 451         return result;
 452 }
 453
 454 BT_EXPORT_API int bluetooth_audio_set_absolute_volume(unsigned int volume)
 455 {
 456         int result;
 457
 458         BT_CHECK_ENABLED(return);
 459
 460         BT_INIT_PARAMS();
 461         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 462
 463         g_array_append_vals(in_param1, &volume, sizeof(unsigned int));
 464
 465         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_AUDIO_SET_ABSOLUTE_VOLUME,
 466                 in_param1, in_param2, in_param3, in_param4, &out_param);
 467
 468         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 469         return result;
 470 }
 471
 472 BT_EXPORT_API int bluetooth_audio_get_absolute_volume(unsigned int *volume)
 473 {
 474         int result;
 475
 476         BT_CHECK_PARAMETER(volume, return);
 477         BT_CHECK_ENABLED(return);
 478
 479         BT_INIT_PARAMS();
 480         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 481
 482         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_AUDIO_GET_ABSOLUTE_VOLUME,
 483                 in_param1, in_param2, in_param3, in_param4, &out_param);
 484
 485         if (result == BLUETOOTH_ERROR_NONE) {
 486                 *volume = g_array_index(out_param,
 487                                 unsigned int, 0);
 488         }
 489
 490         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 491
 492         return result;
 493 }
 494
 495 BT_EXPORT_API int bluetooth_audio_is_avc_activated(bool *activated)
 496 {
 497         int result;
 498
 499         BT_CHECK_PARAMETER(activated, return);
 500
 501         if (bluetooth_check_adapter() == BLUETOOTH_ADAPTER_DISABLED) {
 502                 BT_DBG("BT is not enabled. So activated value is false");
 503                 *activated = false;
 504                 return BLUETOOTH_ERROR_NONE;
 505         }
 506
 507         BT_INIT_PARAMS();
 508         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 509
 510         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_AUDIO_IS_AVC_ACTIVATED,
 511                 in_param1, in_param2, in_param3, in_param4, &out_param);
 512
 513         if (result == BLUETOOTH_ERROR_NONE) {
 514                 *activated = g_array_index(out_param,
 515                                 bool, 0);
 516         }
 517
 518         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 519
 520         return result;
 521 }
 522
 523 BT_EXPORT_API int bluetooth_ag_get_headset_volume(unsigned int *speaker_gain)
 524 {
 525         int result;
 526
 527         BT_CHECK_PARAMETER(speaker_gain, return);
 528         BT_CHECK_ENABLED(return);
 529
 530         BT_INIT_PARAMS();
 531         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 532
 533         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_SPEAKER_GAIN,
 534                 in_param1, in_param2, in_param3, in_param4, &out_param);
 535
 536         if (result == BLUETOOTH_ERROR_NONE) {
 537                 *speaker_gain = g_array_index(out_param,
 538                                 unsigned int, 0);
 539         }
 540
 541         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 542
 543         return result;
 544 }
 545
 546 BT_EXPORT_API int bluetooth_ag_set_speaker_gain(unsigned int speaker_gain)
 547 {
 548         int result;
 549
 550         BT_CHECK_ENABLED(return);
 551
 552 #ifdef TIZEN_FEATURE_BT_DPM
 553         if (_bt_check_dpm(BT_DPM_HSP, NULL) == BT_DPM_RESTRICTED) {
 554                 BT_ERR("Not allow to use HSP profile");
 555                 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 556         }
 557 #endif
 558
 559         BT_INIT_PARAMS();
 560         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 561
 562         g_array_append_vals(in_param1, &speaker_gain, sizeof(unsigned int));
 563
 564         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_SPEAKER_GAIN,
 565                 in_param1, in_param2, in_param3, in_param4, &out_param);
 566
 567         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 568
 569         return result;
 570 }
 571
 572 #define BT_HF_SERVICE_NAME "org.bluez.hf_agent"
 573 #define BT_HF_OBJECT_PATH "/org/bluez/handsfree_agent"
 574 #define BT_HF_INTERFACE "org.tizen.HfApp"
 575
 576
 577 static GVariant* __bt_hf_agent_dbus_send(const char *path, const char *interface,
 578                                 const char *method, GError **err, GVariant *parameters)
 579 {
 580         GVariant *reply = NULL;
 581         GDBusProxy *proxy = NULL;
 582         GDBusConnection *conn = NULL;
 583
 584         conn = _bt_get_system_private_conn();
 585         retv_if(conn == NULL, NULL);
 586
 587         proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
 588                 NULL, BT_HF_SERVICE_NAME, path, interface, NULL, err);
 589         if (proxy == NULL) {
 590                 BT_ERR("Unable to allocate new proxy");
 591                 return NULL;
 592         }
 593
 594         reply = g_dbus_proxy_call_sync(proxy, method, parameters,
 595                                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, err);
 596
 597         g_object_unref(proxy);
 598         return reply;
 599 }
 600
 601 static int __bt_hf_agent_read_call_list(GVariant *reply,
 602                                 bt_hf_call_list_s **call_list) {
 603
 604         GVariantIter iter;
 605         GVariant *var_temp = NULL;
 606         int32_t call_count;
 607         gchar *num = NULL;
 608         int dir, status, mpart, idx;
 609
 610         BT_DBG("+");
 611
 612         g_variant_get(reply, "(i@a(siiii))", &call_count, &var_temp);
 613
 614         if (call_count <= 0) {
 615                 *call_list = NULL;
 616                 return BLUETOOTH_ERROR_NOT_FOUND;
 617         }
 618         BT_DBG("Call count = %d", call_count);
 619
 620         *call_list = g_malloc0(sizeof(bt_hf_call_list_s));
 621         (*call_list)->count = call_count;
 622
 623         g_variant_iter_init(&iter, var_temp);
 624         while (g_variant_iter_loop(&iter, "(siiii)", &num, &dir, &status, &mpart, &idx)) {
 625                 bt_hf_call_status_info_t *call_info;
 626
 627                 call_info = g_malloc0(sizeof(bt_hf_call_status_info_t));
 628                 call_info->number = g_strdup(num);
 629                 call_info->direction = dir;
 630                 call_info->status = status;
 631                 call_info->mpart = mpart;
 632                 call_info->idx = idx;
 633
 634                 (*call_list)->list = g_list_append((*call_list)->list,
 635                                                         (gpointer)call_info);
 636         }
 637
 638         g_variant_unref(var_temp);
 639         BT_DBG("-");
 640         return BLUETOOTH_ERROR_NONE;
 641 }
 642
 643 static int __bluetooth_hf_get_error(const char *error_message)
 644 {
 645         if (error_message == NULL) {
 646                 BT_ERR("Error message NULL");
 647                 return BLUETOOTH_ERROR_INTERNAL;
 648         }
 649
 650         BT_ERR("Error message = %s", error_message);
 651
 652         if (g_strcmp0(error_message, "NotConnected") == 0)
 653                 return BLUETOOTH_ERROR_NOT_CONNECTED;
 654         else
 655                 return BLUETOOTH_ERROR_INTERNAL;
 656 }
 657
 658 BT_EXPORT_API int bluetooth_hf_init(bt_hf_func_ptr cb, void *user_data)
 659 {
 660         int ret;
 661
 662         if (cb == NULL) {
 663                 BT_ERR("callback is NULL");
 664                 return BLUETOOTH_ERROR_INVALID_PARAM;
 665         }
 666
 667         ret = _bt_init_event_handler();
 668
 669         if (ret != BLUETOOTH_ERROR_NONE &&
 670              ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
 671                 BT_ERR("Fail to init the event handler");
 672                 return ret;
 673         }
 674
 675         _bt_set_user_data(BT_HF, (void *)cb, user_data);
 676
 677         /* Register All events */
 678         ret = _bt_register_event(BT_HF_AGENT_EVENT, (void *)cb, user_data);
 679         if (ret != BLUETOOTH_ERROR_NONE &&
 680              ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
 681                 _bt_deinit_event_handler();
 682                 return ret;
 683         }
 684
 685         return BLUETOOTH_ERROR_NONE;
 686 }
 687
 688 BT_EXPORT_API int bluetooth_hf_deinit(void)
 689 {
 690         int ret;
 691
 692         ret = _bt_unregister_event(BT_HF_AGENT_EVENT);
 693         if (ret != BLUETOOTH_ERROR_NONE)
 694                 BT_ERR("_bt_unregister_event failed");
 695
 696         _bt_set_user_data(BT_HF, NULL, NULL);
 697
 698         return BLUETOOTH_ERROR_NONE;
 699 }
 700
 701 BT_EXPORT_API int bluetooth_hf_connect(bluetooth_device_address_t *remote_address)
 702 {
 703         int result;
 704         bt_user_info_t *user_info;
 705
 706         BT_CHECK_ENABLED(return);
 707         BT_CHECK_PARAMETER(remote_address, return);
 708
 709         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HF_CONNECT)
 710              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 711                 BT_ERR("Don't have a privilege to use this API");
 712                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 713         }
 714
 715         user_info = _bt_get_user_data(BT_HF);
 716         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 717
 718         BT_INIT_PARAMS();
 719         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 720
 721         g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
 722
 723         BT_INFO_C("### Connect HF");
 724         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_HF_CONNECT,
 725                 in_param1, in_param2, in_param3, in_param4,
 726                 user_info->cb, user_info->user_data);
 727
 728         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 729
 730         return result;
 731 }
 732
 733 BT_EXPORT_API int bluetooth_hf_disconnect(bluetooth_device_address_t *remote_address)
 734 {
 735         int result;
 736         bt_user_info_t *user_info;
 737
 738         BT_CHECK_PARAMETER(remote_address, return);
 739         BT_CHECK_ENABLED(return);
 740
 741         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HF_DISCONNECT)
 742              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 743                 BT_ERR("Don't have a privilege to use this API");
 744                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 745         }
 746
 747         user_info = _bt_get_user_data(BT_HF);
 748         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 749
 750         BT_INIT_PARAMS();
 751         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 752
 753         g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
 754
 755         BT_INFO_C("### Disconnect HF");
 756         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_HF_DISCONNECT,
 757                 in_param1, in_param2, in_param3, in_param4,
 758                 user_info->cb, user_info->user_data);
 759
 760         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 761
 762         return result;
 763 }
 764
 765 BT_EXPORT_API int bluetooth_hf_answer_call()
 766 {
 767         GVariant *reply = NULL;
 768         GError *err = NULL;
 769         int ret = BLUETOOTH_ERROR_INTERNAL;
 770
 771         BT_CHECK_ENABLED(return);
 772
 773         reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
 774                         "AnswerCall", &err, NULL);
 775         if (!reply) {
 776                 BT_ERR("Error returned in method call\n");
 777                 if (err) {
 778                         BT_ERR("Error = %s", err->message);
 779                         g_dbus_error_strip_remote_error(err);
 780                         ret = _bt_get_error_value_from_message(err->message);
 781                         g_clear_error(&err);
 782                 }
 783                 return ret;
 784         }
 785
 786         g_variant_unref(reply);
 787         return BLUETOOTH_ERROR_NONE;
 788
 789 }
 790
 791 BT_EXPORT_API int bluetooth_hf_terminate_call()
 792 {
 793         GVariant *reply = NULL;
 794         GError *err = NULL;
 795         int ret = BLUETOOTH_ERROR_INTERNAL;
 796
 797         BT_CHECK_ENABLED(return);
 798
 799         reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
 800                         "TerminateCall", &err, NULL);
 801         if (!reply) {
 802                 BT_ERR("Error returned in method call\n");
 803                 if (err) {
 804                         BT_ERR("Error = %s", err->message);
 805                         g_dbus_error_strip_remote_error(err);
 806                         ret = _bt_get_error_value_from_message(err->message);
 807                         g_clear_error(&err);
 808                 }
 809                 return ret;
 810         }
 811
 812         g_variant_unref(reply);
 813         return BLUETOOTH_ERROR_NONE;
 814 }
 815
 816 BT_EXPORT_API int bluetooth_hf_initiate_call(char *number)
 817 {
 818         GVariant *reply = NULL;
 819         GError *err = NULL;
 820         GVariant *param = NULL;
 821         int ret = BLUETOOTH_ERROR_INTERNAL;
 822
 823         BT_CHECK_ENABLED(return);
 824
 825         if (!number)
 826                 number = "";
 827
 828         param = g_variant_new("(s)", number);
 829         reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
 830                         "InitiateCall", &err, param);
 831         if (!reply) {
 832                 BT_ERR("Error returned in method call");
 833                 if (err) {
 834                         BT_ERR("Error = %s", err->message);
 835                         g_dbus_error_strip_remote_error(err);
 836                         ret = _bt_get_error_value_from_message(err->message);
 837                         g_clear_error(&err);
 838                 }
 839                 return ret;
 840         }
 841
 842         g_variant_unref(reply);
 843         return BLUETOOTH_ERROR_NONE;
 844 }
 845
 846 BT_EXPORT_API int bluetooth_hf_voice_recognition(unsigned int status)
 847 {
 848         GVariant *reply = NULL;
 849         GError *err = NULL;
 850         GVariant *param = NULL;
 851         int ret = BLUETOOTH_ERROR_INTERNAL;
 852
 853         BT_CHECK_ENABLED(return);
 854
 855         param = g_variant_new("(i)", status);
 856         reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
 857                         "VoiceRecognition", &err, param);
 858         if (!reply) {
 859                 BT_ERR("Error returned in method call\n");
 860                 if (err) {
 861                         BT_ERR("Error = %s", err->message);
 862                         g_dbus_error_strip_remote_error(err);
 863                         ret = _bt_get_error_value_from_message(err->message);
 864                         g_clear_error(&err);
 865                 }
 866                 return ret;
 867         }
 868
 869         g_variant_unref(reply);
 870         return BLUETOOTH_ERROR_NONE;
 871 }
 872
 873 BT_EXPORT_API int bluetooth_hf_audio_disconnect(void)
 874 {
 875         GVariant *reply = NULL;
 876         GError *err = NULL;
 877         int ret = BLUETOOTH_ERROR_INTERNAL;
 878
 879         BT_CHECK_ENABLED(return);
 880
 881         reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
 882                         "ScoDisconnect", &err, NULL);
 883         if (!reply) {
 884                 BT_ERR("Error returned in method call\n");
 885                 if (err) {
 886                         BT_ERR("Error = %s", err->message);
 887                         g_dbus_error_strip_remote_error(err);
 888                         ret = _bt_get_error_value_from_message(err->message);
 889                         g_clear_error(&err);
 890                 }
 891                 return ret;
 892         }
 893
 894         g_variant_unref(reply);
 895         return BLUETOOTH_ERROR_NONE;
 896 }
 897
 898 BT_EXPORT_API int bluetooth_hf_set_speaker_gain(unsigned int speaker_gain)
 899 {
 900         GVariant *reply = NULL;
 901         GError *err = NULL;
 902         GVariant *param = NULL;
 903         int ret = BLUETOOTH_ERROR_INTERNAL;
 904
 905         BT_CHECK_ENABLED(return);
 906
 907         param = g_variant_new("(u)", speaker_gain);
 908         reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
 909                         "SpeakerGain", &err, param);
 910         if (!reply) {
 911                 BT_ERR("Error returned in method call\n");
 912                 if (err) {
 913                         BT_ERR("Error = %s", err->message);
 914                         g_dbus_error_strip_remote_error(err);
 915                         ret = _bt_get_error_value_from_message(err->message);
 916                         g_clear_error(&err);
 917                 }
 918                 return ret;
 919         }
 920
 921         g_variant_unref(reply);
 922         return BLUETOOTH_ERROR_NONE;
 923 }
 924
 925 BT_EXPORT_API int bluetooth_hf_send_dtmf(char *dtmf)
 926 {
 927         GVariant *reply = NULL;
 928         GError *err = NULL;
 929         GVariant *param = NULL;
 930         int ret = BLUETOOTH_ERROR_INTERNAL;
 931
 932         BT_CHECK_ENABLED(return);
 933
 934         param = g_variant_new("(s)", dtmf);
 935         reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
 936                         "SendDtmf", &err, param);
 937         if (!reply) {
 938                 BT_ERR("Error returned in method call\n");
 939                 if (err) {
 940                         BT_ERR("Error = %s", err->message);
 941                         g_dbus_error_strip_remote_error(err);
 942                         ret = _bt_get_error_value_from_message(err->message);
 943                         g_clear_error(&err);
 944                 }
 945                 return ret;
 946         }
 947
 948         g_variant_unref(reply);
 949         return BLUETOOTH_ERROR_NONE;
 950 }
 951
 952 BT_EXPORT_API int bluetooth_hf_send_xsat_cmd(int app_id, char *xsat_cmd)
 953 {
 954         GVariant *reply = NULL;
 955         GError *err = NULL;
 956         GVariant *param = NULL;
 957         char buffer[200] = {0,};
 958         char *ptr = buffer;
 959         int ret = BLUETOOTH_ERROR_INTERNAL;
 960
 961         BT_CHECK_ENABLED(return);
 962
 963         strncpy(buffer, "AT+XSAT=\0", 200);
 964         snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer),
 965                 "%d,", app_id);
 966         strncat(buffer, xsat_cmd, (sizeof(buffer) - 1) - strlen(buffer));
 967         BT_DBG("Xsat cmd received = %s", buffer);
 968
 969         param = g_variant_new("(s)", ptr);
 970
 971         reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
 972                                         "SendAtCmd", &err, param);
 973         if (!reply) {
 974                 BT_ERR("Error returned in method call\n");
 975                 if (err) {
 976                         BT_ERR("Error = %s", err->message);
 977                         g_dbus_error_strip_remote_error(err);
 978                         ret = _bt_get_error_value_from_message(err->message);
 979                         g_clear_error(&err);
 980                 }
 981                 return ret;
 982         }
 983
 984         g_variant_unref(reply);
 985         return BLUETOOTH_ERROR_NONE;
 986 }
 987
 988 BT_EXPORT_API int bluetooth_hf_release_and_accept(void)
 989 {
 990         GVariant *reply = NULL;
 991         GError *err = NULL;
 992         int ret = BLUETOOTH_ERROR_INTERNAL;
 993
 994         BT_CHECK_ENABLED(return);
 995
 996         reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
 997                         "ReleaseAndAccept", &err, NULL);
 998         if (!reply) {
 999                 BT_ERR("Error returned in method call\n");
1000                 if (err) {
1001                         BT_ERR("Error = %s", err->message);
1002                         g_dbus_error_strip_remote_error(err);
1003                         ret = _bt_get_error_value_from_message(err->message);
1004                         g_clear_error(&err);
1005                 }
1006                 return ret;
1007         }
1008
1009         g_variant_unref(reply);
1010         return BLUETOOTH_ERROR_NONE;
1011 }
1012
1013 BT_EXPORT_API int bluetooth_hf_swap_call(void)
1014 {
1015         GVariant *reply = NULL;
1016         GError *err = NULL;
1017         int ret = BLUETOOTH_ERROR_INTERNAL;
1018
1019         BT_CHECK_ENABLED(return);
1020
1021         reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1022                         "CallSwap", &err, NULL);
1023         if (!reply) {
1024                 BT_ERR("Error returned in method call\n");
1025                 if (err) {
1026                         BT_ERR("Error = %s", err->message);
1027                         g_dbus_error_strip_remote_error(err);
1028                         ret = _bt_get_error_value_from_message(err->message);
1029                         g_clear_error(&err);
1030                 }
1031                 return ret;
1032         }
1033
1034         g_variant_unref(reply);
1035         return BLUETOOTH_ERROR_NONE;
1036 }
1037
1038 BT_EXPORT_API int bluetooth_hf_release_all_call(void)
1039 {
1040         GVariant *reply = NULL;
1041         GError *err = NULL;
1042         int ret = BLUETOOTH_ERROR_INTERNAL;
1043
1044         BT_CHECK_ENABLED(return);
1045
1046         reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1047                         "ReleaseAllCall", &err, NULL);
1048         if (!reply) {
1049                 BT_ERR("Error returned in method call\n");
1050                 if (err) {
1051                         BT_ERR("Error = %s", err->message);
1052                         g_dbus_error_strip_remote_error(err);
1053                         ret = _bt_get_error_value_from_message(err->message);
1054                         g_clear_error(&err);
1055                 }
1056                 return ret;
1057         }
1058
1059         g_variant_unref(reply);
1060         return BLUETOOTH_ERROR_NONE;
1061 }
1062
1063 BT_EXPORT_API int bluetooth_hf_join_call(void)
1064 {
1065         GVariant *reply = NULL;
1066         GError *err = NULL;
1067         int ret = BLUETOOTH_ERROR_INTERNAL;
1068
1069         BT_CHECK_ENABLED(return);
1070
1071         reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1072                         "JoinCall", &err, NULL);
1073         if (!reply) {
1074                 BT_ERR("Error returned in method call\n");
1075                 if (err) {
1076                         BT_ERR("Error = %s", err->message);
1077                         g_dbus_error_strip_remote_error(err);
1078                         ret = _bt_get_error_value_from_message(err->message);
1079                         g_clear_error(&err);
1080                 }
1081                 return ret;
1082         }
1083
1084         g_variant_unref(reply);
1085         return BLUETOOTH_ERROR_NONE;
1086 }
1087
1088 BT_EXPORT_API int bluetooth_hf_get_call_list(void *call_list,
1089                                                                 bt_hf_call_status_info_t **call_status)
1090 {
1091         int i;
1092         GList *list = call_list;
1093         int call_count;
1094         bt_hf_call_status_info_t * call_info;
1095
1096         BT_CHECK_ENABLED(return);
1097         retv_if(list == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
1098         retv_if(call_status == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
1099
1100         call_count = g_list_length(list);
1101
1102         BT_DBG(" call_count = [%d]", call_count);
1103
1104         for (i = 0; i < call_count; i++) {
1105                 call_info = g_list_nth_data(list, i);
1106                 BT_DBG(" direction = [%d]", call_info->direction);
1107                 BT_DBG(" status = [%d]", call_info->status);
1108                 BT_DBG(" mpart = [%d]", call_info->mpart);
1109                 BT_DBG(" number = [%s]", call_info->number);
1110                 BT_DBG(" idx = [%d]", call_info->idx);
1111                 call_status[i] = call_info;
1112         }
1113
1114         return BLUETOOTH_ERROR_NONE;
1115 }
1116
1117 BT_EXPORT_API int bluetooth_hf_free_call_list(bt_hf_call_list_s *call_list)
1118 {
1119         bt_hf_call_list_s *handle;
1120         bt_hf_call_status_info_t *call_status;
1121
1122         retv_if(call_list == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
1123
1124         handle = (bt_hf_call_list_s *)call_list;
1125         do  {
1126                 call_status = (bt_hf_call_status_info_t *)g_list_nth_data(
1127                                                         handle->list, 0);
1128                 if (call_status == NULL)
1129                         break;
1130                 handle->list = g_list_remove(handle->list, call_status);
1131                 g_free(call_status->number);
1132                 g_free(call_status);
1133         } while (1);
1134         g_free(handle);
1135         return BLUETOOTH_ERROR_NONE;
1136 }
1137
1138 BT_EXPORT_API int bluetooth_hf_request_call_list(
1139                                         bt_hf_call_list_s **call_list)
1140 {
1141         GVariant *reply = NULL;
1142         GError *err = NULL;
1143
1144         BT_CHECK_ENABLED(return);
1145
1146         reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1147                         "RequestCallList", &err, NULL);
1148         if (!reply) {
1149                 BT_ERR("dbus Error or call list is null\n");
1150                 if (err) {
1151                         BT_ERR("Error = %s", err->message);
1152                         g_clear_error(&err);
1153                 }
1154                 *call_list = NULL;
1155                 return BLUETOOTH_ERROR_INTERNAL;
1156         }
1157         __bt_hf_agent_read_call_list(reply, call_list);
1158
1159         g_variant_unref(reply);
1160         return BLUETOOTH_ERROR_NONE;
1161 }
1162
1163 BT_EXPORT_API int bluetooth_hf_request_call_list_async(void)
1164 {
1165         GVariant *reply = NULL;
1166         GError *err = NULL;
1167         int ret = BLUETOOTH_ERROR_INTERNAL;
1168
1169         BT_CHECK_ENABLED(return);
1170
1171         reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1172                         "RequestCallListAsync", &err, NULL);
1173         if (!reply) {
1174                 BT_ERR("Error returned in method call\n");
1175                 if (err) {
1176                         BT_ERR("Error = %s", err->message);
1177                         if (strstr(err->message, "No data"))
1178                                 ret = BLUETOOTH_ERROR_NO_DATA;
1179                         else if (strstr(err->message, "NotConnected"))
1180                                 ret = BLUETOOTH_ERROR_NOT_CONNECTED;
1181                         g_clear_error(&err);
1182                 }
1183                 return ret;
1184         }
1185
1186         g_variant_unref(reply);
1187         return BLUETOOTH_ERROR_NONE;
1188 }
1189
1190 BT_EXPORT_API int bluetooth_hf_get_codec(unsigned int *codec_id)
1191 {
1192         GVariant *reply = NULL;
1193         GError *err = NULL;
1194         int32_t current_codec;
1195
1196         BT_CHECK_ENABLED(return);
1197
1198         reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1199                         "GetCurrentCodec", &err, NULL);
1200         if (!reply) {
1201                 BT_ERR("Error returned in method call\n");
1202                 if (err) {
1203                         BT_ERR("Error = %s", err->message);
1204                         g_clear_error(&err);
1205                 }
1206                 return BLUETOOTH_ERROR_INTERNAL;
1207         }
1208
1209         g_variant_get(reply, "(i)", &current_codec);
1210         *codec_id = current_codec;
1211         BT_DBG(" Codec ID is : %d", *codec_id);
1212
1213         g_variant_unref(reply);
1214         return BLUETOOTH_ERROR_NONE;
1215 }
1216
1217 BT_EXPORT_API int bluetooth_hf_get_audio_connected(unsigned int *audio_connected)
1218 {
1219         GVariant *reply = NULL;
1220         GError *err = NULL;
1221         int32_t sco_audio_connected_from_bt_agent;
1222
1223         BT_CHECK_ENABLED(return);
1224
1225         reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1226                         "GetAudioConnected", &err, NULL);
1227         if (!reply) {
1228                 BT_ERR("Error returned in method call\n");
1229                 if (err) {
1230                         BT_ERR("Error = %s", err->message);
1231                         g_clear_error(&err);
1232                 }
1233                 return BLUETOOTH_ERROR_INTERNAL;
1234         }
1235
1236         g_variant_get(reply, "(i)", &sco_audio_connected_from_bt_agent);
1237         *audio_connected = sco_audio_connected_from_bt_agent;
1238
1239         if (*audio_connected == BLUETOOTH_HF_AUDIO_CONNECTED)
1240                 BT_DBG("SCO Audio is Connected");
1241         else
1242                 BT_DBG("SCO Audio is Disconnected");
1243
1244         g_variant_unref(reply);
1245         return BLUETOOTH_ERROR_NONE;
1246 }
1247
1248 BT_EXPORT_API int bluetooth_hf_is_connected(gboolean *hf_connected)
1249 {
1250         GVariant *reply = NULL;
1251         GError *err = NULL;
1252         gboolean hf_connected_from_bt_agent;
1253
1254         BT_CHECK_ENABLED(return);
1255
1256         reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1257                         "IsHfConnected", &err, NULL);
1258         if (!reply) {
1259                 BT_ERR("Error returned in method call\n");
1260                 if (err) {
1261                         BT_ERR("Error = %s", err->message);
1262                         g_clear_error(&err);
1263                 }
1264                 return BLUETOOTH_ERROR_INTERNAL;
1265         }
1266
1267         g_variant_get(reply, "(b)", &hf_connected_from_bt_agent);
1268         *hf_connected = hf_connected_from_bt_agent;
1269
1270         BT_DBG("%s", *hf_connected ? "Connected" : "Disconnected");
1271
1272         g_variant_unref(reply);
1273         return BLUETOOTH_ERROR_NONE;
1274 }
1275
1276 BT_EXPORT_API int bluetooth_hf_is_ibr_supported(gboolean *ibr_supported)
1277 {
1278         GVariant *reply = NULL;
1279         GError *err = NULL;
1280         gboolean is_supported;
1281         int ret = BLUETOOTH_ERROR_NONE;
1282
1283         BT_CHECK_ENABLED(return);
1284
1285         reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1286                         "IsInbandRingtoneSupported", &err, NULL);
1287         if (!reply) {
1288                 BT_ERR("Error returned in method call");
1289                 if (err) {
1290                         g_dbus_error_strip_remote_error(err);
1291                         ret = __bluetooth_hf_get_error(err->message);
1292                         g_error_free(err);
1293                         return ret;
1294                 }
1295                 return BLUETOOTH_ERROR_INTERNAL;
1296         }
1297
1298         g_variant_get(reply, "(b)", &is_supported);
1299         *ibr_supported = is_supported;
1300
1301         BT_DBG("%s", *ibr_supported ? "Supported" : "Not Supported");
1302
1303         g_variant_unref(reply);
1304         return ret;
1305 }