bt-api/bt-dpm.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 #ifdef TIZEN_FEATURE_BT_DPM
  19 #include <vconf.h>
  20
  21 #include "bluetooth-api.h"
  22 #include "bt-internal-types.h"
  23 #include "bt-common.h"
  24 #include "bt-request-sender.h"
  25 #include "bt-event-handler.h"
  26 #include "bt-event-handler.h"
  27 #include "bt-dpm.h"
  28
  29 #ifdef TIZEN_FEATURE_BT_DPM
  30 BT_EXPORT_API int bluetooth_dpm_is_mode_allowed(void)
  31 {
  32         int value;
  33         /* check VCONFKEY_BT_STATUS */
  34         if (vconf_get_int(VCONFKEY_BT_DPM_STATUS, &value) != 0) {
  35                 BT_ERR("fail to get vconf key!");
  36                 return BLUETOOTH_ERROR_INTERNAL;
  37         }
  38         if (value != VCONFKEY_BT_DPM_STATUS_RESTRICTED)
  39                 return BLUETOOTH_ERROR_NONE;
  40         else
  41                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
  42 }
  43 #endif
  44
  45 #if 0
  46 static bt_dpm_status_e _bt_check_dpm_allow_restriction(void)
  47 {
  48         bt_dpm_allow_t mode;
  49
  50         bluetooth_dpm_get_allow_mode(&mode);
  51
  52         return (mode == BLUETOOTH_DPM_BT_RESTRICTED) ? BT_DPM_RESTRICTED : BT_DPM_ALLOWED;
  53 }
  54 #endif
  55
  56 static bt_dpm_status_e _bt_check_dpm_handsfree_only(void)
  57 {
  58         bt_dpm_allow_t mode;
  59
  60         bluetooth_dpm_get_allow_mode(&mode);
  61
  62         return (mode == BLUETOOTH_DPM_HANDSFREE_ONLY ? BT_DPM_RESTRICTED : BT_DPM_ALLOWED);
  63 }
  64
  65 static bt_dpm_status_e _bt_check_dpm_pairing_restriction(void)
  66 {
  67         bt_dpm_status_t dpm_status = BLUETOOTH_DPM_ALLOWED;
  68
  69         bluetooth_dpm_get_pairing_state(&dpm_status);
  70
  71         return (dpm_status == BLUETOOTH_DPM_RESTRICTED ? BT_DPM_RESTRICTED : BT_DPM_ALLOWED);
  72 }
  73
  74 static bt_dpm_status_e _bt_check_dpm_desktop_connectivity_restriction(void)
  75 {
  76         bt_dpm_status_t dpm_status = BLUETOOTH_DPM_ALLOWED;
  77
  78         bluetooth_dpm_get_desktop_connectivity_state(&dpm_status);
  79
  80         return (dpm_status == BLUETOOTH_DPM_RESTRICTED ? BT_DPM_RESTRICTED : BT_DPM_ALLOWED);
  81 }
  82
  83 #if 0
  84 static bt_dpm_status_e _bt_check_dpm_visible_restriction(void)
  85 {
  86         bt_dpm_status_t dpm_status = BLUETOOTH_DPM_ALLOWED;
  87
  88         bluetooth_dpm_get_desktop_connectivity_state(&dpm_status);
  89
  90         return (dpm_status == BLUETOOTH_DPM_RESTRICTED ? BT_DPM_RESTRICTED : BT_DPM_ALLOWED);
  91 }
  92
  93 static bt_dpm_status_e _bt_check_dpm_limited_discoverable_mode(void)
  94 {
  95         bt_dpm_status_t dpm_status = BLUETOOTH_DPM_ALLOWED;
  96
  97         bluetooth_dpm_get_limited_discoverable_state(&dpm_status);
  98
  99         return (dpm_status == BLUETOOTH_DPM_RESTRICTED ? BT_DPM_RESTRICTED : BT_DPM_ALLOWED);
 100 }
 101 #endif
 102
 103 static bt_dpm_status_e _bt_check_dpm_blacklist_device(bluetooth_device_address_t *address)
 104 {
 105         int ret = BLUETOOTH_DPM_RESULT_SUCCESS;
 106         bt_dpm_device_list_t dev_list;
 107         char device_address[BT_ADDRESS_STRING_SIZE] = { 0 };
 108
 109         _bt_convert_addr_type_to_string(device_address,
 110                         (unsigned char *)address->addr);
 111
 112         ret = bluetooth_dpm_get_devices_from_blacklist(&dev_list);
 113         if (ret == BLUETOOTH_DPM_RESULT_SUCCESS) {
 114                 int i = 0;
 115                 for (i = 0; i < dev_list.count; i++) {
 116                         char temp_address[BT_ADDRESS_STRING_SIZE] = { 0 };
 117                         _bt_convert_addr_type_to_string(temp_address,
 118                         (unsigned char *)dev_list.addresses[i].addr);
 119                         if (g_strcmp0(device_address, temp_address) == 0)
 120                                 return BT_DPM_RESTRICTED;
 121                         else
 122                                 return BT_DPM_ALLOWED;
 123                 }
 124         } else {
 125                 return BT_DPM_NO_SERVICE;
 126         }
 127         return BT_DPM_ALLOWED;
 128 }
 129
 130 static bt_dpm_status_e _bt_check_dpm_blacklist_uuid(char *uuid)
 131 {
 132         bt_dpm_status_e bt_dpm_status = BT_DPM_ALLOWED;
 133         bt_dpm_status_t dpm_status = BLUETOOTH_DPM_ALLOWED;
 134         bt_dpm_profile_t dpm_profile = BLUETOOTH_DPM_PROFILE_NONE;
 135         bt_dpm_uuids_list_t uuid_list;
 136         int ret = BLUETOOTH_DPM_RESULT_SUCCESS;
 137         retv_if(!uuid, bt_dpm_status);
 138
 139         ret = bluetooth_dpm_get_uuids_from_blacklist(&uuid_list);
 140         if (ret == BLUETOOTH_DPM_RESULT_SUCCESS) {
 141                 int i = 0;
 142                 for (i = 0; i < uuid_list.count; i++) {
 143                         if (g_strcmp0(uuid, uuid_list.uuids[i]) == 0)
 144                                 return BT_DPM_RESTRICTED;
 145                         else
 146                                 return BT_DPM_ALLOWED;
 147                 }
 148         } else {
 149                 return BT_DPM_NO_SERVICE;
 150         }
 151
 152         if (g_strcmp0(BT_OPP_UUID, uuid) == 0) {
 153                 bt_dpm_status_t dpm_status = BLUETOOTH_DPM_ALLOWED;
 154                 bluetooth_dpm_get_data_transfer_state(&dpm_status);
 155                 return (dpm_status == BLUETOOTH_DPM_RESTRICTED ? BT_DPM_RESTRICTED : BT_DPM_ALLOWED);
 156         }
 157         /* TODO: MAP? see above */
 158
 159         /* ++ check MDM profile restriction ++ */
 160         if (g_strcmp0(BT_A2DP_UUID, uuid) == 0)
 161                 dpm_profile = BLUETOOTH_DPM_POLICY_A2DP_PROFILE_STATE;
 162         else if (g_strcmp0(BT_AVRCP_TARGET_UUID, uuid) == 0)
 163                 dpm_profile = BLUETOOTH_DPM_POLICY_AVRCP_PROFILE_STATE;
 164         else if (g_strcmp0(BT_HFP_AUDIO_GATEWAY_UUID, uuid) == 0)
 165                 dpm_profile = BLUETOOTH_DPM_POLICY_HFP_PROFILE_STATE;
 166         else if (g_strcmp0(BT_HSP_AUDIO_GATEWAY_UUID, uuid) == 0)
 167                 dpm_profile = BLUETOOTH_DPM_POLICY_HSP_PROFILE_STATE;
 168         else if (g_strcmp0(BT_OBEX_PSE_UUID, uuid) == 0)
 169                 dpm_profile = BLUETOOTH_DPM_POLICY_PBAP_PROFILE_STATE;
 170
 171         if (dpm_profile != BLUETOOTH_DPM_PROFILE_NONE) {
 172                 ret = bluetooth_dpm_get_profile_state(dpm_profile, &dpm_status);
 173                 return (dpm_status == BLUETOOTH_DPM_RESTRICTED ? BT_DPM_RESTRICTED : BT_DPM_ALLOWED);
 174         }
 175         /* -- check DPM profile restriction -- */
 176
 177         return bt_dpm_status;
 178 }
 179
 180 static bt_dpm_status_e _bt_check_dpm_transfer_restriction(void)
 181 {
 182         bt_dpm_status_e dpm_status = BT_DPM_ALLOWED;
 183         bt_dpm_status_t dpm_value = BLUETOOTH_DPM_ALLOWED;
 184
 185         dpm_status = _bt_check_dpm_blacklist_uuid(BT_OPP_UUID);
 186         /* TODO: MAP? see above */
 187
 188         if (dpm_status == BT_DPM_NO_SERVICE || dpm_status == BT_DPM_RESTRICTED)
 189                 return dpm_status;
 190
 191         bluetooth_dpm_get_data_transfer_state(&dpm_value);
 192
 193         return (dpm_value == BLUETOOTH_DPM_RESTRICTED ? BT_DPM_RESTRICTED : BT_DPM_ALLOWED);
 194 }
 195
 196 static bt_dpm_status_e _bt_check_dpm_hsp_restriction(void)
 197 {
 198         bt_dpm_status_e dpm_status = BT_DPM_ALLOWED;
 199
 200         dpm_status = _bt_check_dpm_blacklist_uuid(BT_HFP_AUDIO_GATEWAY_UUID);
 201
 202         if (dpm_status == BT_DPM_NO_SERVICE || dpm_status == BT_DPM_RESTRICTED)
 203                 return dpm_status;
 204
 205         dpm_status = _bt_check_dpm_blacklist_uuid(BT_HSP_AUDIO_GATEWAY_UUID);
 206         if (dpm_status == BT_DPM_NO_SERVICE || dpm_status == BT_DPM_RESTRICTED)
 207                 return dpm_status;
 208
 209         return dpm_status;
 210 }
 211
 212 static bt_dpm_status_e _bt_check_dpm_a2dp_restriction(void)
 213 {
 214         bt_dpm_status_e dpm_status = BT_DPM_ALLOWED;
 215
 216         dpm_status = _bt_check_dpm_blacklist_uuid(BT_A2DP_UUID);
 217
 218         if (dpm_status == BT_DPM_NO_SERVICE || dpm_status == BT_DPM_RESTRICTED)
 219                 return dpm_status;
 220
 221         return dpm_status;
 222 }
 223
 224 static bt_dpm_status_e _bt_check_dpm_avrcp_restriction(void)
 225 {
 226         bt_dpm_status_e dpm_status = BT_DPM_ALLOWED;
 227
 228         dpm_status = _bt_check_dpm_blacklist_uuid(BT_AVRCP_TARGET_UUID);
 229
 230         if (dpm_status == BT_DPM_NO_SERVICE || dpm_status == BT_DPM_RESTRICTED)
 231                 return dpm_status;
 232
 233         return dpm_status;
 234 }
 235
 236 static bt_dpm_status_e _bt_check_dpm_spp_restriction(void)
 237 {
 238         bt_dpm_status_e dpm_status = BT_DPM_ALLOWED;
 239
 240         dpm_status = _bt_check_dpm_blacklist_uuid(BT_SPP_UUID);
 241
 242         if (dpm_status == BT_DPM_NO_SERVICE || dpm_status == BT_DPM_RESTRICTED)
 243                 return dpm_status;
 244
 245         return dpm_status;
 246 }
 247
 248 int _bt_check_dpm(int service, void *param)
 249 {
 250         bt_dpm_status_e status = BT_DPM_ALLOWED;
 251         int ret = BLUETOOTH_ERROR_NONE;
 252         BT_CHECK_ENABLED_ANY(return);
 253
 254         switch (service) {
 255         case BT_DPM_HF_ONLY:
 256                 status = _bt_check_dpm_handsfree_only();
 257                 break;
 258
 259         case BT_DPM_PAIRING:
 260                 status = _bt_check_dpm_pairing_restriction();
 261                 break;
 262         case BT_DPM_DESKTOP:
 263                 status = _bt_check_dpm_desktop_connectivity_restriction();
 264                 break;
 265         case BT_DPM_ADDRESS: {
 266                 status = _bt_check_dpm_blacklist_device((bluetooth_device_address_t *)param);
 267                 }
 268                 break;
 269         case BT_DPM_UUID: {
 270                 char *uuid;
 271                 uuid = (char *)param;
 272                 status = _bt_check_dpm_blacklist_uuid(uuid);
 273                 }
 274                 break;
 275         case BT_DPM_OPP:
 276                 status = _bt_check_dpm_transfer_restriction();
 277                 break;
 278         /* TODO: MAP? see above */
 279         case BT_DPM_HSP:
 280                 status = _bt_check_dpm_hsp_restriction();
 281                 break;
 282         case BT_DPM_A2DP:
 283                 status = _bt_check_dpm_a2dp_restriction();
 284                 break;
 285         case BT_DPM_AVRCP:
 286                 status = _bt_check_dpm_avrcp_restriction();
 287                 break;
 288         case BT_DPM_SPP:
 289                 status = _bt_check_dpm_spp_restriction();
 290                 break;
 291
 292         default:
 293                 BT_ERR("Unknown service");
 294                 return status;
 295         }
 296
 297         if (status == BT_DPM_RESTRICTED) {
 298                 BT_INFO("Service [%d], DPM permission denied", service);
 299                 ret = BLUETOOTH_ERROR_PERMISSION_DEINED;
 300         } else if (status == BT_DPM_NO_SERVICE) {
 301                 BT_DBG("DPM no service [%d]", status);
 302                 ret = BLUETOOTH_ERROR_SERVICE_NOT_FOUND;
 303         }
 304
 305         return ret;
 306 }
 307
 308 BT_EXPORT_API int bluetooth_dpm_set_allow_mode(bt_dpm_allow_t value)
 309 {
 310         int result =  BLUETOOTH_ERROR_NONE;
 311 #ifdef TIZEN_FEATURE_BT_DPM
 312         int bt_status;
 313 #endif
 314
 315 #ifdef TIZEN_FEATURE_BT_DPM
 316         if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_status) < 0)
 317                 BT_ERR("Error in reading VCONFKEY_BT_STATUS");
 318
 319         if (bt_status == VCONFKEY_BT_STATUS_ON) {
 320                 if (vconf_set_int(VCONFKEY_BT_DPM_STATUS, value) != 0) {
 321                         BT_ERR("Set VCONFKEY_BT_DPM_STATUS failed\n");
 322                         result = BLUETOOTH_ERROR_INTERNAL;
 323                 } else {
 324                         BT_ERR("Set VCONFKEY_BT_DPM_STATUS success\n");
 325                         result = BLUETOOTH_ERROR_NONE;
 326                 }
 327
 328                 BT_INIT_PARAMS();
 329                 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 330
 331                 g_array_append_vals(in_param1, &value, sizeof(int));
 332
 333                 result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_ALLOW_BT_MODE,
 334                         in_param1, in_param2, in_param3, in_param4, &out_param);
 335
 336                 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 337
 338                 if (result == BLUETOOTH_ERROR_NONE &&
 339                         value == BLUETOOTH_DPM_BT_RESTRICTED) {
 340                         result = bluetooth_disable_adapter();
 341                 }
 342         } else {
 343                 if (value >= BLUETOOTH_DPM_BT_ALLOWED &&
 344                         value <= BLUETOOTH_DPM_BT_RESTRICTED) {
 345                         if (vconf_set_int(VCONFKEY_BT_DPM_STATUS, value) != 0) {
 346                                 BT_ERR("Set VCONFKEY_BT_DPM_STATUS failed\n");
 347                                 result = BLUETOOTH_ERROR_INTERNAL;
 348                         } else
 349                                 result = BLUETOOTH_ERROR_NONE;
 350                 } else
 351                         result = BLUETOOTH_ERROR_INVALID_PARAM;
 352         }
 353 #else
 354         BT_INIT_PARAMS();
 355         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 356
 357         g_array_append_vals(in_param1, &value, sizeof(int));
 358
 359         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_ALLOW_BT_MODE,
 360                 in_param1, in_param2, in_param3, in_param4, &out_param);
 361
 362         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 363 #endif
 364
 365         return result;
 366
 367 }
 368
 369 BT_EXPORT_API int bluetooth_dpm_get_allow_mode(bt_dpm_allow_t *value)
 370 {
 371         int result;
 372
 373 #ifdef TIZEN_FEATURE_BT_DPM
 374         *value = bluetooth_dpm_is_mode_allowed();
 375         result = BLUETOOTH_ERROR_NONE;
 376 #else
 377         BT_CHECK_ENABLED_ANY(return);
 378
 379         BT_INIT_PARAMS();
 380         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 381
 382         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_ALLOW_BT_MODE,
 383                 in_param1, in_param2, in_param3, in_param4, &out_param);
 384
 385         if (result == BLUETOOTH_ERROR_NONE) {
 386                 if (out_param->len > 0) {
 387                         *value = g_array_index(out_param,
 388                                         int, 0);
 389                 } else {
 390                         BT_ERR("out_param length is 0!!");
 391                 }
 392         }
 393
 394         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 395 #endif
 396
 397         return result;
 398 }
 399
 400
 401 BT_EXPORT_API int bluetooth_dpm_activate_device_restriction(bt_dpm_status_t value)
 402 {
 403         int result;
 404
 405         BT_CHECK_ENABLED_ANY(return);
 406
 407         BT_INIT_PARAMS();
 408         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 409
 410         g_array_append_vals(in_param1, &value, sizeof(int));
 411
 412         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_DEVICE_RESTRITION,
 413                 in_param1, in_param2, in_param3, in_param4, &out_param);
 414
 415         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 416
 417         return result;
 418 }
 419
 420
 421 BT_EXPORT_API int bluetooth_dpm_is_device_restriction_active(bt_dpm_status_t *value)
 422 {
 423         int result;
 424
 425         BT_CHECK_ENABLED_ANY(return);
 426
 427         BT_INIT_PARAMS();
 428         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 429
 430         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_DEVICE_RESTRITION,
 431                 in_param1, in_param2, in_param3, in_param4, &out_param);
 432
 433         if (result == BLUETOOTH_ERROR_NONE) {
 434                 if (out_param->len > 0) {
 435                         *value = g_array_index(out_param,
 436                                         int, 0);
 437                 } else {
 438                         BT_ERR("out_param length is 0!!");
 439                 }
 440         }
 441
 442         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 443
 444         return result;
 445 }
 446
 447
 448 BT_EXPORT_API int bluetooth_dpm_activate_uuid_restriction(bt_dpm_status_t value)
 449 {
 450         int result;
 451
 452         BT_CHECK_ENABLED_ANY(return);
 453
 454         BT_INIT_PARAMS();
 455         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 456
 457         g_array_append_vals(in_param1, &value, sizeof(int));
 458
 459         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_UUID_RESTRITION,
 460                 in_param1, in_param2, in_param3, in_param4, &out_param);
 461
 462         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 463
 464         return result;
 465 }
 466
 467
 468 BT_EXPORT_API int bluetooth_dpm_is_uuid_restriction_active(bt_dpm_status_t *value)
 469 {
 470         int result;
 471
 472         BT_CHECK_ENABLED_ANY(return);
 473
 474         BT_INIT_PARAMS();
 475         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 476
 477         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_UUID_RESTRITION,
 478                 in_param1, in_param2, in_param3, in_param4, &out_param);
 479
 480         if (result == BLUETOOTH_ERROR_NONE) {
 481                 if (out_param->len > 0) {
 482                         *value = g_array_index(out_param,
 483                                         int, 0);
 484                 } else {
 485                         BT_ERR("out_param length is 0!!");
 486                 }
 487         }
 488
 489         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 490
 491         return result;
 492
 493 }
 494
 495
 496 BT_EXPORT_API int bluetooth_dpm_add_devices_to_blacklist(const bluetooth_device_address_t *device_address)
 497 {
 498         int result;
 499
 500         BT_CHECK_PARAMETER(device_address, return);
 501         BT_CHECK_ENABLED_ANY(return);
 502
 503         BT_INIT_PARAMS();
 504         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 505
 506         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 507
 508
 509         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_ADD_DEVICES_BLACKLIST,
 510                 in_param1, in_param2, in_param3, in_param4, &out_param);
 511
 512         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 513
 514         return result;
 515 }
 516
 517
 518 BT_EXPORT_API int bluetooth_dpm_add_devices_to_whitelist(const bluetooth_device_address_t *device_address)
 519 {
 520         int result;
 521
 522         BT_CHECK_PARAMETER(device_address, return);
 523         BT_CHECK_ENABLED_ANY(return);
 524
 525         BT_INIT_PARAMS();
 526         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 527
 528         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 529
 530         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_ADD_DEVICES_WHITELIST,
 531                 in_param1, in_param2, in_param3, in_param4, &out_param);
 532
 533         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 534
 535         return result;
 536
 537 }
 538
 539
 540 BT_EXPORT_API int bluetooth_dpm_add_uuids_to_blacklist(const char *service_uuid)
 541 {
 542         int result;
 543         char uuid[BLUETOOTH_UUID_STRING_MAX];
 544
 545         BT_CHECK_PARAMETER(service_uuid, return);
 546         BT_CHECK_ENABLED_ANY(return);
 547
 548
 549         BT_INIT_PARAMS();
 550         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 551
 552         g_strlcpy(uuid, service_uuid, sizeof(uuid));
 553         g_array_append_vals(in_param1, uuid, BLUETOOTH_UUID_STRING_MAX);
 554
 555         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_ADD_UUIDS_BLACKLIST,
 556                 in_param1, in_param2, in_param3, in_param4, &out_param);
 557
 558         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 559
 560         return result;
 561
 562 }
 563
 564
 565 BT_EXPORT_API int bluetooth_dpm_add_uuids_to_whitelist(const char *service_uuid)
 566 {
 567         int result;
 568         char uuid[BLUETOOTH_UUID_STRING_MAX];
 569
 570         BT_CHECK_PARAMETER(service_uuid, return);
 571         BT_CHECK_ENABLED_ANY(return);
 572
 573         BT_INIT_PARAMS();
 574         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 575
 576         g_strlcpy(uuid, service_uuid, sizeof(uuid));
 577         g_array_append_vals(in_param1, uuid, BLUETOOTH_UUID_STRING_MAX);
 578
 579         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_ADD_UUIDS_WHITELIST,
 580                 in_param1, in_param2, in_param3, in_param4, &out_param);
 581
 582         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 583
 584         return result;
 585 }
 586
 587
 588 BT_EXPORT_API int bluetooth_dpm_clear_devices_from_blacklist(void)
 589 {
 590         int result;
 591
 592         BT_CHECK_ENABLED_ANY(return);
 593
 594         BT_INIT_PARAMS();
 595         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 596
 597         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_CLEAR_DEVICES_BLACKLIST,
 598                 in_param1, in_param2, in_param3, in_param4, &out_param);
 599
 600         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 601
 602         return result;
 603 }
 604
 605
 606 BT_EXPORT_API int bluetooth_dpm_clear_devices_from_whitelist(void)
 607 {
 608         int result;
 609
 610         BT_CHECK_ENABLED_ANY(return);
 611
 612         BT_INIT_PARAMS();
 613         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 614
 615         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_CLEAR_DEVICES_WHITELIST,
 616                 in_param1, in_param2, in_param3, in_param4, &out_param);
 617
 618         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 619
 620         return result;
 621 }
 622
 623
 624 BT_EXPORT_API int bluetooth_dpm_clear_uuids_from_blacklist(void)
 625 {
 626         int result;
 627
 628         BT_CHECK_ENABLED_ANY(return);
 629
 630         BT_INIT_PARAMS();
 631         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 632
 633         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_CLEAR_UUIDS_BLACKLIST,
 634                 in_param1, in_param2, in_param3, in_param4, &out_param);
 635
 636         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 637
 638         return result;
 639 }
 640
 641
 642 BT_EXPORT_API int bluetooth_dpm_clear_uuids_from_whitelist(void)
 643 {
 644         int result;
 645
 646         BT_CHECK_ENABLED_ANY(return);
 647
 648         BT_INIT_PARAMS();
 649         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 650
 651         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_CLEAR_UUIDS_WHITELIST,
 652                 in_param1, in_param2, in_param3, in_param4, &out_param);
 653
 654         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 655
 656         return result;
 657 }
 658
 659
 660 static void _bluetooth_extract_dpm_device_info(int count,
 661                                                         bt_dpm_device_list_t *dst_info,
 662                                                         bt_dpm_device_list_t *src_info)
 663 {
 664         int i;
 665
 666         for (i = 0; i < count; i++) {
 667                 memset(dst_info->addresses[i].addr, 0,
 668                         BLUETOOTH_ADDRESS_LENGTH);
 669
 670                 g_strlcpy((gchar *)dst_info->addresses[i].addr, (gchar *)src_info->addresses[i].addr,
 671                         BLUETOOTH_ADDRESS_LENGTH);
 672
 673 //              BT_DBG("address[%d] : %s", i, dst_info->addresses[i].addr);
 674         }
 675 }
 676
 677 static void _bluetooth_extract_dpm_uuid_info(int count,
 678                                                         bt_dpm_uuids_list_t *dst_info,
 679                                                         bt_dpm_uuids_list_t *src_info)
 680 {
 681         int i;
 682
 683         for (i = 0; i < count; i++) {
 684                 memset(dst_info->uuids[i], 0,
 685                         BLUETOOTH_UUID_STRING_MAX);
 686
 687                 g_strlcpy(dst_info->uuids[i], src_info->uuids[i],
 688                         BLUETOOTH_UUID_STRING_MAX);
 689
 690                 BT_DBG("uuids[%d] : %s", i, dst_info->uuids[i]);
 691         }
 692 }
 693
 694 BT_EXPORT_API int bluetooth_dpm_get_devices_from_blacklist(bt_dpm_device_list_t *device_list)
 695 {
 696         int result;
 697         bt_dpm_device_list_t *devices = NULL;
 698
 699         BT_CHECK_ENABLED_ANY(return);
 700
 701         BT_INIT_PARAMS();
 702         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 703
 704         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_DEVICES_BLACKLIST,
 705                 in_param1, in_param2, in_param3, in_param4, &out_param);
 706
 707         if (result == BLUETOOTH_ERROR_NONE) {
 708                 devices = &g_array_index(out_param, bt_dpm_device_list_t, 0);
 709                 BT_DBG("device_list->count : %d", devices->count);
 710
 711                 if (devices->count == 0) {
 712                         BT_ERR("device_list->count is zero !");
 713                         result = BLUETOOTH_ERROR_NOT_FOUND;
 714                 }
 715
 716                 device_list->count = devices->count;
 717
 718                 _bluetooth_extract_dpm_device_info(devices->count,
 719                                 device_list, devices);
 720         } else {
 721                 BT_ERR("Get Devices list Failed");
 722         }
 723
 724         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 725
 726         return result;
 727 }
 728
 729 BT_EXPORT_API int bluetooth_dpm_get_devices_from_whitelist(bt_dpm_device_list_t *device_list)
 730 {
 731         int result;
 732         bt_dpm_device_list_t *devices = NULL;
 733
 734         BT_CHECK_ENABLED_ANY(return);
 735
 736         BT_INIT_PARAMS();
 737         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 738
 739         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_DEVICES_WHITELIST,
 740                 in_param1, in_param2, in_param3, in_param4, &out_param);
 741
 742         if (result == BLUETOOTH_ERROR_NONE) {
 743                 devices = &g_array_index(out_param, bt_dpm_device_list_t, 0);
 744                 BT_DBG("device_list->count : %d", devices->count);
 745
 746                 if (devices->count == 0) {
 747                         BT_ERR("device_list->count is zero !");
 748                         result = BLUETOOTH_ERROR_NOT_FOUND;
 749                 }
 750
 751                 device_list->count = devices->count;
 752
 753                 _bluetooth_extract_dpm_device_info(devices->count,
 754                                 device_list, devices);
 755
 756         } else {
 757                 BT_ERR("Get Devices list Failed");
 758         }
 759         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 760
 761         return result;
 762 }
 763
 764 BT_EXPORT_API int bluetooth_dpm_get_uuids_from_blacklist(bt_dpm_uuids_list_t *uuid_list)
 765 {
 766         int result;
 767         bt_dpm_uuids_list_t *uuids;
 768
 769         BT_CHECK_ENABLED_ANY(return);
 770
 771         BT_INIT_PARAMS();
 772         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 773
 774         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_UUIDS_BLACKLIST,
 775                 in_param1, in_param2, in_param3, in_param4, &out_param);
 776
 777         if (result == BLUETOOTH_ERROR_NONE) {
 778                 uuids = &g_array_index(out_param, bt_dpm_uuids_list_t, 0);
 779                 BT_DBG("uuids->count : %d", uuids->count);
 780
 781                 if (uuids->count == 0) {
 782                         BT_ERR("uuids->count is zero !");
 783                         result = BLUETOOTH_ERROR_NOT_FOUND;
 784                 }
 785
 786                 uuid_list->count = uuids->count;
 787                 _bluetooth_extract_dpm_uuid_info(uuids->count,
 788                                 uuid_list, uuids);
 789         } else {
 790                 BT_ERR("Get UUIDS list Failed");
 791         }
 792
 793         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 794
 795         return result;
 796 }
 797
 798 BT_EXPORT_API int bluetooth_dpm_get_uuids_from_whitelist(bt_dpm_uuids_list_t *uuid_list)
 799 {
 800         int result;
 801         bt_dpm_uuids_list_t *uuids;
 802
 803         BT_CHECK_ENABLED_ANY(return);
 804
 805         BT_INIT_PARAMS();
 806         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 807
 808         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_UUIDS_WHITELIST,
 809                 in_param1, in_param2, in_param3, in_param4, &out_param);
 810
 811         if (result == BLUETOOTH_ERROR_NONE) {
 812                 uuids = &g_array_index(out_param, bt_dpm_uuids_list_t, 0);
 813                 BT_DBG("uuids->count : %d", uuids->count);
 814
 815                 if (uuids->count == 0) {
 816                         BT_ERR("uuids->count is zero !");
 817                         result = BLUETOOTH_ERROR_NOT_FOUND;
 818                 }
 819
 820                 uuid_list->count = uuids->count;
 821
 822                 _bluetooth_extract_dpm_uuid_info(uuids->count,
 823                                 uuid_list, uuids);
 824         } else {
 825                 BT_ERR("Get UUIDS list Failed");
 826         }
 827
 828         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 829
 830         return result;
 831 }
 832
 833 BT_EXPORT_API int bluetooth_dpm_remove_device_from_whitelist(const bluetooth_device_address_t *device_address)
 834 {
 835         int result;
 836
 837         BT_CHECK_PARAMETER(device_address, return);
 838         BT_CHECK_ENABLED_ANY(return);
 839
 840         BT_INIT_PARAMS();
 841         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 842
 843         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 844
 845         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_REMOVE_DEVICE_WHITELIST,
 846                 in_param1, in_param2, in_param3, in_param4, &out_param);
 847
 848         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 849
 850         return result;
 851 }
 852
 853 BT_EXPORT_API int bluetooth_dpm_remove_device_from_blacklist(const bluetooth_device_address_t *device_address)
 854 {
 855         int result;
 856
 857         BT_CHECK_PARAMETER(device_address, return);
 858         BT_CHECK_ENABLED_ANY(return);
 859
 860         BT_INIT_PARAMS();
 861         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 862
 863         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 864
 865         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_REMOVE_DEVICE_BLACKLIST,
 866                 in_param1, in_param2, in_param3, in_param4, &out_param);
 867
 868         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 869
 870         return result;
 871 }
 872
 873 BT_EXPORT_API int bluetooth_dpm_remove_uuid_from_whitelist(const char *service_uuid)
 874 {
 875         int result;
 876         char uuid[BLUETOOTH_UUID_STRING_MAX];
 877
 878         BT_CHECK_PARAMETER(service_uuid, return);
 879         BT_CHECK_ENABLED_ANY(return);
 880
 881         BT_INIT_PARAMS();
 882         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 883
 884         g_strlcpy(uuid, service_uuid, sizeof(uuid));
 885         g_array_append_vals(in_param1, uuid, BLUETOOTH_UUID_STRING_MAX);
 886
 887         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_REMOVE_UUID_WHITELIST,
 888                 in_param1, in_param2, in_param3, in_param4, &out_param);
 889
 890         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 891
 892         return result;
 893 }
 894
 895 BT_EXPORT_API int bluetooth_dpm_remove_uuid_from_blacklist(const char *service_uuid)
 896 {
 897         int result;
 898         char uuid[BLUETOOTH_UUID_STRING_MAX];
 899
 900         BT_CHECK_PARAMETER(service_uuid, return);
 901         BT_CHECK_ENABLED_ANY(return);
 902
 903         BT_INIT_PARAMS();
 904         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 905
 906         g_strlcpy(uuid, service_uuid, sizeof(uuid));
 907         g_array_append_vals(in_param1, uuid, BLUETOOTH_UUID_STRING_MAX);
 908
 909         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_REMOVE_UUID_BLACKLIST,
 910                 in_param1, in_param2, in_param3, in_param4, &out_param);
 911
 912         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 913
 914         return result;
 915
 916 }
 917
 918 BT_EXPORT_API int bluetooth_dpm_set_allow_outgoing_call(bt_dpm_status_t value)
 919 {
 920         int result;
 921
 922         BT_CHECK_ENABLED_ANY(return);
 923
 924         BT_INIT_PARAMS();
 925         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 926
 927         g_array_append_vals(in_param1, &value, sizeof(int));
 928
 929         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_ALLOW_OUTGOING_CALL,
 930                 in_param1, in_param2, in_param3, in_param4, &out_param);
 931
 932         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 933
 934         return result;
 935 }
 936
 937 BT_EXPORT_API int bluetooth_dpm_get_allow_outgoing_call(bt_dpm_status_t *value)
 938 {
 939         int result;
 940
 941         BT_CHECK_ENABLED_ANY(return);
 942
 943         BT_INIT_PARAMS();
 944         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 945
 946         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_ALLOW_OUTGOING_CALL,
 947                 in_param1, in_param2, in_param3, in_param4, &out_param);
 948
 949         if (result == BLUETOOTH_ERROR_NONE) {
 950                 if (out_param->len > 0) {
 951                         *value = g_array_index(out_param,
 952                                         int, 0);
 953                 } else {
 954                         BT_ERR("out_param length is 0!!");
 955                 }
 956         }
 957
 958         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 959
 960         return result;
 961 }
 962
 963 BT_EXPORT_API int bluetooth_dpm_set_pairing_state(bt_dpm_status_t value)
 964 {
 965         int result;
 966
 967         BT_CHECK_ENABLED_ANY(return);
 968
 969         BT_INIT_PARAMS();
 970         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 971
 972         g_array_append_vals(in_param1, &value, sizeof(int));
 973
 974         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_PAIRING_STATE,
 975                 in_param1, in_param2, in_param3, in_param4, &out_param);
 976
 977         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 978
 979         return result;
 980 }
 981
 982 BT_EXPORT_API int bluetooth_dpm_get_pairing_state(bt_dpm_status_t *value)
 983 {
 984         int result;
 985
 986         BT_CHECK_ENABLED_ANY(return);
 987
 988         BT_INIT_PARAMS();
 989         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 990
 991         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_ALLOW_BT_MODE,
 992                 in_param1, in_param2, in_param3, in_param4, &out_param);
 993
 994         if (result == BLUETOOTH_ERROR_NONE) {
 995                 if (out_param->len > 0) {
 996                         *value = g_array_index(out_param,
 997                                         int, 0);
 998                 } else {
 999                         BT_ERR("out_param length is 0!!");
1000                 }
1001         }
1002
1003         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1004
1005         return result;
1006 }
1007
1008 BT_EXPORT_API int bluetooth_dpm_set_profile_state(bt_dpm_profile_t profile, bt_dpm_status_t value)
1009 {
1010         int result;
1011
1012         BT_CHECK_ENABLED_ANY(return);
1013
1014         BT_INIT_PARAMS();
1015         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1016
1017         g_array_append_vals(in_param1, &profile, sizeof(int));
1018         g_array_append_vals(in_param2, &value, sizeof(int));
1019
1020         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_PROFILE_STATE,
1021                 in_param1, in_param2, in_param3, in_param4, &out_param);
1022
1023         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1024
1025         return result;
1026 }
1027
1028 BT_EXPORT_API int bluetooth_dpm_get_profile_state(bt_dpm_profile_t profile, bt_dpm_status_t *value)
1029 {
1030         int result;
1031
1032         BT_CHECK_ENABLED_ANY(return);
1033
1034         BT_INIT_PARAMS();
1035         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1036
1037         g_array_append_vals(in_param1, &profile, sizeof(int));
1038
1039         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_PROFILE_STATE,
1040                 in_param1, in_param2, in_param3, in_param4, &out_param);
1041
1042         if (result == BLUETOOTH_ERROR_NONE) {
1043                 if (out_param->len > 0) {
1044                         *value = g_array_index(out_param,
1045                                         int, 0);
1046                 } else {
1047                         BT_ERR("out_param length is 0!!");
1048                 }
1049         }
1050
1051         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1052
1053         return result;
1054 }
1055
1056 BT_EXPORT_API int bluetooth_dpm_set_desktop_connectivity_state(bt_dpm_status_t value)
1057 {
1058         int result;
1059
1060         BT_CHECK_ENABLED_ANY(return);
1061
1062         BT_INIT_PARAMS();
1063         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1064
1065         g_array_append_vals(in_param1, &value, sizeof(int));
1066
1067         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_DESKROP_CONNECTIVITY_STATE,
1068                 in_param1, in_param2, in_param3, in_param4, &out_param);
1069
1070         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1071
1072         return result;
1073 }
1074
1075 BT_EXPORT_API int bluetooth_dpm_get_desktop_connectivity_state(bt_dpm_status_t *value)
1076 {
1077         int result;
1078
1079         BT_CHECK_ENABLED_ANY(return);
1080
1081         BT_INIT_PARAMS();
1082         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1083
1084         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_DESKROP_CONNECTIVITY_STATE,
1085                 in_param1, in_param2, in_param3, in_param4, &out_param);
1086
1087         if (result == BLUETOOTH_ERROR_NONE) {
1088                 if (out_param->len > 0) {
1089                         *value = g_array_index(out_param,
1090                                         int, 0);
1091                 } else {
1092                         BT_ERR("out_param length is 0!!");
1093                 }
1094         }
1095
1096         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1097
1098         return result;
1099 }
1100
1101 BT_EXPORT_API int bluetooth_dpm_set_discoverable_state(bt_dpm_status_t value)
1102 {
1103         int result;
1104
1105         BT_CHECK_ENABLED_ANY(return);
1106
1107         BT_INIT_PARAMS();
1108         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1109
1110         g_array_append_vals(in_param1, &value, sizeof(int));
1111
1112         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_DISCOVERABLE_STATE,
1113                 in_param1, in_param2, in_param3, in_param4, &out_param);
1114
1115         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1116
1117         return result;
1118 }
1119
1120 BT_EXPORT_API int bluetooth_dpm_get_discoverable_state(bt_dpm_status_t *value)
1121 {
1122         int result;
1123
1124         BT_CHECK_ENABLED_ANY(return);
1125
1126         BT_INIT_PARAMS();
1127         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1128
1129         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_DISCOVERABLE_STATE,
1130                 in_param1, in_param2, in_param3, in_param4, &out_param);
1131
1132         if (result == BLUETOOTH_ERROR_NONE) {
1133                 if (out_param->len > 0) {
1134                         *value = g_array_index(out_param,
1135                                         int, 0);
1136                 } else {
1137                         BT_ERR("out_param length is 0!!");
1138                 }
1139         }
1140
1141         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1142
1143         return result;
1144 }
1145
1146 BT_EXPORT_API int bluetooth_dpm_set_limited_discoverable_state(bt_dpm_status_t value)
1147 {
1148         int result;
1149
1150         BT_CHECK_ENABLED_ANY(return);
1151
1152         BT_INIT_PARAMS();
1153         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1154
1155         g_array_append_vals(in_param1, &value, sizeof(int));
1156
1157         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_LIMITED_DISCOVERABLE_STATE,
1158                 in_param1, in_param2, in_param3, in_param4, &out_param);
1159
1160         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1161
1162         return result;
1163 }
1164
1165 BT_EXPORT_API int bluetooth_dpm_get_limited_discoverable_state(bt_dpm_status_t *value)
1166 {
1167         int result;
1168
1169         BT_CHECK_ENABLED_ANY(return);
1170
1171         BT_INIT_PARAMS();
1172         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1173
1174         g_array_append_vals(in_param1, &value, sizeof(int));
1175
1176         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_LIMITED_DISCOVERABLE_STATE,
1177                 in_param1, in_param2, in_param3, in_param4, &out_param);
1178
1179         if (result == BLUETOOTH_ERROR_NONE) {
1180                 if (out_param->len > 0) {
1181                         *value = g_array_index(out_param,
1182                                         int, 0);
1183                 } else {
1184                         BT_ERR("out_param length is 0!!");
1185                 }
1186         }
1187
1188         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1189
1190         return result;
1191 }
1192
1193 BT_EXPORT_API int bluetooth_dpm_set_data_transfer_state(bt_dpm_status_t value)
1194 {
1195         int result;
1196
1197         BT_CHECK_ENABLED_ANY(return);
1198
1199         BT_INIT_PARAMS();
1200         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1201
1202         g_array_append_vals(in_param1, &value, sizeof(int));
1203
1204         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_DATA_TRANSFER_STATE,
1205                 in_param1, in_param2, in_param3, in_param4, &out_param);
1206
1207         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1208
1209         return result;
1210 }
1211
1212 BT_EXPORT_API int bluetooth_dpm_get_data_transfer_state(bt_dpm_status_t *value)
1213 {
1214         int result;
1215
1216         BT_CHECK_ENABLED_ANY(return);
1217
1218         BT_INIT_PARAMS();
1219         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1220
1221         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_DATA_TRANSFER_STATE,
1222                 in_param1, in_param2, in_param3, in_param4, &out_param);
1223
1224         if (result == BLUETOOTH_ERROR_NONE) {
1225                 if (out_param->len > 0) {
1226                         *value = g_array_index(out_param,
1227                                         int, 0);
1228                 } else {
1229                         BT_ERR("out_param length is 0!!");
1230                 }
1231         }
1232
1233         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1234
1235         return result;
1236 }
1237 #endif /* #ifdef TIZEN_FEATURE_BT_DPM */