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         BT_CHECK_ENABLED_ANY(return);
 252
 253         switch (service) {
 254         case BT_DPM_HF_ONLY:
 255                 status = _bt_check_dpm_handsfree_only();
 256                 break;
 257         case BT_DPM_PAIRING:
 258                 status = _bt_check_dpm_pairing_restriction();
 259                 break;
 260         case BT_DPM_DESKTOP:
 261                 status = _bt_check_dpm_desktop_connectivity_restriction();
 262                 break;
 263         case BT_DPM_ADDRESS: {
 264                 status = _bt_check_dpm_blacklist_device((bluetooth_device_address_t *)param);
 265                 }
 266                 break;
 267         case BT_DPM_UUID: {
 268                 char *uuid;
 269                 uuid = (char *)param;
 270                 status = _bt_check_dpm_blacklist_uuid(uuid);
 271                 }
 272                 break;
 273         case BT_DPM_OPP:
 274                 status = _bt_check_dpm_transfer_restriction();
 275                 break;
 276         /* TODO: MAP? see above */
 277         case BT_DPM_HSP:
 278                 status = _bt_check_dpm_hsp_restriction();
 279                 break;
 280         case BT_DPM_A2DP:
 281                 status = _bt_check_dpm_a2dp_restriction();
 282                 break;
 283         case BT_DPM_AVRCP:
 284                 status = _bt_check_dpm_avrcp_restriction();
 285                 break;
 286         case BT_DPM_SPP:
 287                 status = _bt_check_dpm_spp_restriction();
 288                 break;
 289         default:
 290                 BT_ERR("Unknown service");
 291                 return status;
 292         }
 293
 294         return status;
 295 }
 296
 297 BT_EXPORT_API int bluetooth_dpm_set_allow_mode(bt_dpm_allow_t value)
 298 {
 299         int result =  BLUETOOTH_ERROR_NONE;
 300 #ifdef TIZEN_FEATURE_BT_DPM
 301         int bt_status;
 302 #endif
 303
 304 #ifdef TIZEN_FEATURE_BT_DPM
 305         if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_status) < 0)
 306                 BT_ERR("Error in reading VCONFKEY_BT_STATUS");
 307
 308         if (bt_status == VCONFKEY_BT_STATUS_ON) {
 309                 if (vconf_set_int(VCONFKEY_BT_DPM_STATUS, value) != 0) {
 310                         BT_ERR("Set VCONFKEY_BT_DPM_STATUS failed\n");
 311                         result = BLUETOOTH_ERROR_INTERNAL;
 312                 } else {
 313                         BT_ERR("Set VCONFKEY_BT_DPM_STATUS success\n");
 314                         result = BLUETOOTH_ERROR_NONE;
 315                 }
 316
 317                 BT_INIT_PARAMS();
 318                 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 319
 320                 g_array_append_vals(in_param1, &value, sizeof(int));
 321
 322                 result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_ALLOW_BT_MODE,
 323                         in_param1, in_param2, in_param3, in_param4, &out_param);
 324
 325                 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 326
 327                 if (result == BLUETOOTH_ERROR_NONE &&
 328                         value == BLUETOOTH_DPM_BT_RESTRICTED) {
 329                         result = bluetooth_disable_adapter();
 330                 }
 331         } else {
 332                 if (value >= BLUETOOTH_DPM_BT_ALLOWED &&
 333                         value <= BLUETOOTH_DPM_BT_RESTRICTED) {
 334                         if (vconf_set_int(VCONFKEY_BT_DPM_STATUS, value) != 0) {
 335                                 BT_ERR("Set VCONFKEY_BT_DPM_STATUS failed\n");
 336                                 result = BLUETOOTH_ERROR_INTERNAL;
 337                         } else
 338                                 result = BLUETOOTH_ERROR_NONE;
 339                 } else
 340                         result = BLUETOOTH_ERROR_INVALID_PARAM;
 341         }
 342 #else
 343         BT_INIT_PARAMS();
 344         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 345
 346         g_array_append_vals(in_param1, &value, sizeof(int));
 347
 348         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_ALLOW_BT_MODE,
 349                 in_param1, in_param2, in_param3, in_param4, &out_param);
 350
 351         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 352 #endif
 353
 354         return result;
 355
 356 }
 357
 358 BT_EXPORT_API int bluetooth_dpm_get_allow_mode(bt_dpm_allow_t *value)
 359 {
 360         int result;
 361
 362 #ifdef TIZEN_FEATURE_BT_DPM
 363         if (vconf_get_int(VCONFKEY_BT_DPM_STATUS, value) != 0) {
 364                 BT_ERR("fail to get vconf key!");
 365                 return BLUETOOTH_ERROR_INTERNAL;
 366         }
 367         result = BLUETOOTH_ERROR_NONE;
 368 #else
 369         BT_CHECK_ENABLED_ANY(return);
 370
 371         BT_INIT_PARAMS();
 372         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 373
 374         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_ALLOW_BT_MODE,
 375                 in_param1, in_param2, in_param3, in_param4, &out_param);
 376
 377         if (result == BLUETOOTH_ERROR_NONE) {
 378                 if (out_param->len > 0) {
 379                         *value = g_array_index(out_param,
 380                                         int, 0);
 381                 } else {
 382                         BT_ERR("out_param length is 0!!");
 383                 }
 384         }
 385
 386         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 387 #endif
 388
 389         return result;
 390 }
 391
 392
 393 BT_EXPORT_API int bluetooth_dpm_activate_device_restriction(bt_dpm_status_t value)
 394 {
 395         int result;
 396
 397         BT_CHECK_ENABLED_ANY(return);
 398
 399         BT_INIT_PARAMS();
 400         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 401
 402         g_array_append_vals(in_param1, &value, sizeof(int));
 403
 404         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_DEVICE_RESTRITION,
 405                 in_param1, in_param2, in_param3, in_param4, &out_param);
 406
 407         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 408
 409         return result;
 410 }
 411
 412
 413 BT_EXPORT_API int bluetooth_dpm_is_device_restriction_active(bt_dpm_status_t *value)
 414 {
 415         int result;
 416
 417         BT_CHECK_ENABLED_ANY(return);
 418
 419         BT_INIT_PARAMS();
 420         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 421
 422         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_DEVICE_RESTRITION,
 423                 in_param1, in_param2, in_param3, in_param4, &out_param);
 424
 425         if (result == BLUETOOTH_ERROR_NONE) {
 426                 if (out_param->len > 0) {
 427                         *value = g_array_index(out_param,
 428                                         int, 0);
 429                 } else {
 430                         BT_ERR("out_param length is 0!!");
 431                 }
 432         }
 433
 434         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 435
 436         return result;
 437 }
 438
 439
 440 BT_EXPORT_API int bluetooth_dpm_activate_uuid_restriction(bt_dpm_status_t value)
 441 {
 442         int result;
 443
 444         BT_CHECK_ENABLED_ANY(return);
 445
 446         BT_INIT_PARAMS();
 447         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 448
 449         g_array_append_vals(in_param1, &value, sizeof(int));
 450
 451         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_UUID_RESTRITION,
 452                 in_param1, in_param2, in_param3, in_param4, &out_param);
 453
 454         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 455
 456         return result;
 457 }
 458
 459
 460 BT_EXPORT_API int bluetooth_dpm_is_uuid_restriction_active(bt_dpm_status_t *value)
 461 {
 462         int result;
 463
 464         BT_CHECK_ENABLED_ANY(return);
 465
 466         BT_INIT_PARAMS();
 467         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 468
 469         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_UUID_RESTRITION,
 470                 in_param1, in_param2, in_param3, in_param4, &out_param);
 471
 472         if (result == BLUETOOTH_ERROR_NONE) {
 473                 if (out_param->len > 0) {
 474                         *value = g_array_index(out_param,
 475                                         int, 0);
 476                 } else {
 477                         BT_ERR("out_param length is 0!!");
 478                 }
 479         }
 480
 481         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 482
 483         return result;
 484
 485 }
 486
 487
 488 BT_EXPORT_API int bluetooth_dpm_add_devices_to_blacklist(const bluetooth_device_address_t *device_address)
 489 {
 490         int result;
 491
 492         BT_CHECK_PARAMETER(device_address, return);
 493         BT_CHECK_ENABLED_ANY(return);
 494
 495         BT_INIT_PARAMS();
 496         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 497
 498         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 499
 500
 501         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_ADD_DEVICES_BLACKLIST,
 502                 in_param1, in_param2, in_param3, in_param4, &out_param);
 503
 504         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 505
 506         return result;
 507 }
 508
 509
 510 BT_EXPORT_API int bluetooth_dpm_add_devices_to_whitelist(const bluetooth_device_address_t *device_address)
 511 {
 512         int result;
 513
 514         BT_CHECK_PARAMETER(device_address, return);
 515         BT_CHECK_ENABLED_ANY(return);
 516
 517         BT_INIT_PARAMS();
 518         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 519
 520         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 521
 522         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_ADD_DEVICES_WHITELIST,
 523                 in_param1, in_param2, in_param3, in_param4, &out_param);
 524
 525         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 526
 527         return result;
 528
 529 }
 530
 531
 532 BT_EXPORT_API int bluetooth_dpm_add_uuids_to_blacklist(const char *service_uuid)
 533 {
 534         int result;
 535         char uuid[BLUETOOTH_UUID_STRING_MAX];
 536
 537         BT_CHECK_PARAMETER(service_uuid, return);
 538         BT_CHECK_ENABLED_ANY(return);
 539
 540
 541         BT_INIT_PARAMS();
 542         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 543
 544         g_strlcpy(uuid, service_uuid, sizeof(uuid));
 545         g_array_append_vals(in_param1, uuid, BLUETOOTH_UUID_STRING_MAX);
 546
 547         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_ADD_UUIDS_BLACKLIST,
 548                 in_param1, in_param2, in_param3, in_param4, &out_param);
 549
 550         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 551
 552         return result;
 553
 554 }
 555
 556
 557 BT_EXPORT_API int bluetooth_dpm_add_uuids_to_whitelist(const char *service_uuid)
 558 {
 559         int result;
 560         char uuid[BLUETOOTH_UUID_STRING_MAX];
 561
 562         BT_CHECK_PARAMETER(service_uuid, return);
 563         BT_CHECK_ENABLED_ANY(return);
 564
 565         BT_INIT_PARAMS();
 566         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 567
 568         g_strlcpy(uuid, service_uuid, sizeof(uuid));
 569         g_array_append_vals(in_param1, uuid, BLUETOOTH_UUID_STRING_MAX);
 570
 571         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_ADD_UUIDS_WHITELIST,
 572                 in_param1, in_param2, in_param3, in_param4, &out_param);
 573
 574         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 575
 576         return result;
 577 }
 578
 579
 580 BT_EXPORT_API int bluetooth_dpm_clear_devices_from_blacklist(void)
 581 {
 582         int result;
 583
 584         BT_CHECK_ENABLED_ANY(return);
 585
 586         BT_INIT_PARAMS();
 587         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 588
 589         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_CLEAR_DEVICES_BLACKLIST,
 590                 in_param1, in_param2, in_param3, in_param4, &out_param);
 591
 592         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 593
 594         return result;
 595 }
 596
 597
 598 BT_EXPORT_API int bluetooth_dpm_clear_devices_from_whitelist(void)
 599 {
 600         int result;
 601
 602         BT_CHECK_ENABLED_ANY(return);
 603
 604         BT_INIT_PARAMS();
 605         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 606
 607         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_CLEAR_DEVICES_WHITELIST,
 608                 in_param1, in_param2, in_param3, in_param4, &out_param);
 609
 610         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 611
 612         return result;
 613 }
 614
 615
 616 BT_EXPORT_API int bluetooth_dpm_clear_uuids_from_blacklist(void)
 617 {
 618         int result;
 619
 620         BT_CHECK_ENABLED_ANY(return);
 621
 622         BT_INIT_PARAMS();
 623         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 624
 625         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_CLEAR_UUIDS_BLACKLIST,
 626                 in_param1, in_param2, in_param3, in_param4, &out_param);
 627
 628         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 629
 630         return result;
 631 }
 632
 633
 634 BT_EXPORT_API int bluetooth_dpm_clear_uuids_from_whitelist(void)
 635 {
 636         int result;
 637
 638         BT_CHECK_ENABLED_ANY(return);
 639
 640         BT_INIT_PARAMS();
 641         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 642
 643         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_CLEAR_UUIDS_WHITELIST,
 644                 in_param1, in_param2, in_param3, in_param4, &out_param);
 645
 646         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 647
 648         return result;
 649 }
 650
 651
 652 static void _bluetooth_extract_dpm_device_info(int count,
 653                                                         bt_dpm_device_list_t *dst_info,
 654                                                         bt_dpm_device_list_t *src_info)
 655 {
 656         int i;
 657
 658         for (i = 0; i < count; i++) {
 659                 memset(dst_info->addresses[i].addr, 0,
 660                         BLUETOOTH_ADDRESS_LENGTH);
 661
 662                 g_strlcpy((gchar *)dst_info->addresses[i].addr, (gchar *)src_info->addresses[i].addr,
 663                         BLUETOOTH_ADDRESS_LENGTH);
 664
 665 //              BT_DBG("address[%d] : %s", i, dst_info->addresses[i].addr);
 666         }
 667 }
 668
 669 static void _bluetooth_extract_dpm_uuid_info(int count,
 670                                                         bt_dpm_uuids_list_t *dst_info,
 671                                                         bt_dpm_uuids_list_t *src_info)
 672 {
 673         int i;
 674
 675         for (i = 0; i < count; i++) {
 676                 memset(dst_info->uuids[i], 0,
 677                         BLUETOOTH_UUID_STRING_MAX);
 678
 679                 g_strlcpy(dst_info->uuids[i], src_info->uuids[i],
 680                         BLUETOOTH_UUID_STRING_MAX);
 681
 682                 BT_DBG("uuids[%d] : %s", i, dst_info->uuids[i]);
 683         }
 684 }
 685
 686 BT_EXPORT_API int bluetooth_dpm_get_devices_from_blacklist(bt_dpm_device_list_t *device_list)
 687 {
 688         int result;
 689         bt_dpm_device_list_t *devices = NULL;
 690
 691         BT_CHECK_ENABLED_ANY(return);
 692
 693         BT_INIT_PARAMS();
 694         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 695
 696         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_DEVICES_BLACKLIST,
 697                 in_param1, in_param2, in_param3, in_param4, &out_param);
 698
 699         if (result == BLUETOOTH_ERROR_NONE) {
 700                 devices = &g_array_index(out_param, bt_dpm_device_list_t, 0);
 701                 BT_DBG("device_list->count : %d", devices->count);
 702
 703                 if (devices->count == 0) {
 704                         BT_ERR("device_list->count is zero !");
 705                         result = BLUETOOTH_ERROR_NOT_FOUND;
 706                 }
 707
 708                 device_list->count = devices->count;
 709
 710                 _bluetooth_extract_dpm_device_info(devices->count,
 711                                 device_list, devices);
 712         } else {
 713                 BT_ERR("Get Devices list Failed");
 714         }
 715
 716         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 717
 718         return result;
 719 }
 720
 721 BT_EXPORT_API int bluetooth_dpm_get_devices_from_whitelist(bt_dpm_device_list_t *device_list)
 722 {
 723         int result;
 724         bt_dpm_device_list_t *devices = NULL;
 725
 726         BT_CHECK_ENABLED_ANY(return);
 727
 728         BT_INIT_PARAMS();
 729         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 730
 731         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_DEVICES_WHITELIST,
 732                 in_param1, in_param2, in_param3, in_param4, &out_param);
 733
 734         if (result == BLUETOOTH_ERROR_NONE) {
 735                 devices = &g_array_index(out_param, bt_dpm_device_list_t, 0);
 736                 BT_DBG("device_list->count : %d", devices->count);
 737
 738                 if (devices->count == 0) {
 739                         BT_ERR("device_list->count is zero !");
 740                         result = BLUETOOTH_ERROR_NOT_FOUND;
 741                 }
 742
 743                 device_list->count = devices->count;
 744
 745                 _bluetooth_extract_dpm_device_info(devices->count,
 746                                 device_list, devices);
 747
 748         } else {
 749                 BT_ERR("Get Devices list Failed");
 750         }
 751         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 752
 753         return result;
 754 }
 755
 756 BT_EXPORT_API int bluetooth_dpm_get_uuids_from_blacklist(bt_dpm_uuids_list_t *uuid_list)
 757 {
 758         int result;
 759         bt_dpm_uuids_list_t *uuids;
 760
 761         BT_CHECK_ENABLED_ANY(return);
 762
 763         BT_INIT_PARAMS();
 764         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 765
 766         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_UUIDS_BLACKLIST,
 767                 in_param1, in_param2, in_param3, in_param4, &out_param);
 768
 769         if (result == BLUETOOTH_ERROR_NONE) {
 770                 uuids = &g_array_index(out_param, bt_dpm_uuids_list_t, 0);
 771                 BT_DBG("uuids->count : %d", uuids->count);
 772
 773                 if (uuids->count == 0) {
 774                         BT_ERR("uuids->count is zero !");
 775                         result = BLUETOOTH_ERROR_NOT_FOUND;
 776                 }
 777
 778                 uuid_list->count = uuids->count;
 779                 _bluetooth_extract_dpm_uuid_info(uuids->count,
 780                                 uuid_list, uuids);
 781         } else {
 782                 BT_ERR("Get UUIDS list Failed");
 783         }
 784
 785         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 786
 787         return result;
 788 }
 789
 790 BT_EXPORT_API int bluetooth_dpm_get_uuids_from_whitelist(bt_dpm_uuids_list_t *uuid_list)
 791 {
 792         int result;
 793         bt_dpm_uuids_list_t *uuids;
 794
 795         BT_CHECK_ENABLED_ANY(return);
 796
 797         BT_INIT_PARAMS();
 798         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 799
 800         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_UUIDS_WHITELIST,
 801                 in_param1, in_param2, in_param3, in_param4, &out_param);
 802
 803         if (result == BLUETOOTH_ERROR_NONE) {
 804                 uuids = &g_array_index(out_param, bt_dpm_uuids_list_t, 0);
 805                 BT_DBG("uuids->count : %d", uuids->count);
 806
 807                 if (uuids->count == 0) {
 808                         BT_ERR("uuids->count is zero !");
 809                         result = BLUETOOTH_ERROR_NOT_FOUND;
 810                 }
 811
 812                 uuid_list->count = uuids->count;
 813
 814                 _bluetooth_extract_dpm_uuid_info(uuids->count,
 815                                 uuid_list, uuids);
 816         } else {
 817                 BT_ERR("Get UUIDS list Failed");
 818         }
 819
 820         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 821
 822         return result;
 823 }
 824
 825 BT_EXPORT_API int bluetooth_dpm_remove_device_from_whitelist(const bluetooth_device_address_t *device_address)
 826 {
 827         int result;
 828
 829         BT_CHECK_PARAMETER(device_address, return);
 830         BT_CHECK_ENABLED_ANY(return);
 831
 832         BT_INIT_PARAMS();
 833         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 834
 835         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 836
 837         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_REMOVE_DEVICE_WHITELIST,
 838                 in_param1, in_param2, in_param3, in_param4, &out_param);
 839
 840         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 841
 842         return result;
 843 }
 844
 845 BT_EXPORT_API int bluetooth_dpm_remove_device_from_blacklist(const bluetooth_device_address_t *device_address)
 846 {
 847         int result;
 848
 849         BT_CHECK_PARAMETER(device_address, return);
 850         BT_CHECK_ENABLED_ANY(return);
 851
 852         BT_INIT_PARAMS();
 853         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 854
 855         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 856
 857         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_REMOVE_DEVICE_BLACKLIST,
 858                 in_param1, in_param2, in_param3, in_param4, &out_param);
 859
 860         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 861
 862         return result;
 863 }
 864
 865 BT_EXPORT_API int bluetooth_dpm_remove_uuid_from_whitelist(const char *service_uuid)
 866 {
 867         int result;
 868         char uuid[BLUETOOTH_UUID_STRING_MAX];
 869
 870         BT_CHECK_PARAMETER(service_uuid, return);
 871         BT_CHECK_ENABLED_ANY(return);
 872
 873         BT_INIT_PARAMS();
 874         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 875
 876         g_strlcpy(uuid, service_uuid, sizeof(uuid));
 877         g_array_append_vals(in_param1, uuid, BLUETOOTH_UUID_STRING_MAX);
 878
 879         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_REMOVE_UUID_WHITELIST,
 880                 in_param1, in_param2, in_param3, in_param4, &out_param);
 881
 882         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 883
 884         return result;
 885 }
 886
 887 BT_EXPORT_API int bluetooth_dpm_remove_uuid_from_blacklist(const char *service_uuid)
 888 {
 889         int result;
 890         char uuid[BLUETOOTH_UUID_STRING_MAX];
 891
 892         BT_CHECK_PARAMETER(service_uuid, return);
 893         BT_CHECK_ENABLED_ANY(return);
 894
 895         BT_INIT_PARAMS();
 896         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 897
 898         g_strlcpy(uuid, service_uuid, sizeof(uuid));
 899         g_array_append_vals(in_param1, uuid, BLUETOOTH_UUID_STRING_MAX);
 900
 901         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_REMOVE_UUID_BLACKLIST,
 902                 in_param1, in_param2, in_param3, in_param4, &out_param);
 903
 904         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 905
 906         return result;
 907
 908 }
 909
 910 BT_EXPORT_API int bluetooth_dpm_set_allow_outgoing_call(bt_dpm_status_t value)
 911 {
 912         int result;
 913
 914         BT_CHECK_ENABLED_ANY(return);
 915
 916         BT_INIT_PARAMS();
 917         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 918
 919         g_array_append_vals(in_param1, &value, sizeof(int));
 920
 921         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_ALLOW_OUTGOING_CALL,
 922                 in_param1, in_param2, in_param3, in_param4, &out_param);
 923
 924         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 925
 926         return result;
 927 }
 928
 929 BT_EXPORT_API int bluetooth_dpm_get_allow_outgoing_call(bt_dpm_status_t *value)
 930 {
 931         int result;
 932
 933         BT_CHECK_ENABLED_ANY(return);
 934
 935         BT_INIT_PARAMS();
 936         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 937
 938         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_ALLOW_OUTGOING_CALL,
 939                 in_param1, in_param2, in_param3, in_param4, &out_param);
 940
 941         if (result == BLUETOOTH_ERROR_NONE) {
 942                 if (out_param->len > 0) {
 943                         *value = g_array_index(out_param,
 944                                         int, 0);
 945                 } else {
 946                         BT_ERR("out_param length is 0!!");
 947                 }
 948         }
 949
 950         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 951
 952         return result;
 953 }
 954
 955 BT_EXPORT_API int bluetooth_dpm_set_pairing_state(bt_dpm_status_t value)
 956 {
 957         int result;
 958
 959         BT_CHECK_ENABLED_ANY(return);
 960
 961         BT_INIT_PARAMS();
 962         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 963
 964         g_array_append_vals(in_param1, &value, sizeof(int));
 965
 966         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_PAIRING_STATE,
 967                 in_param1, in_param2, in_param3, in_param4, &out_param);
 968
 969         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 970
 971         return result;
 972 }
 973
 974 BT_EXPORT_API int bluetooth_dpm_get_pairing_state(bt_dpm_status_t *value)
 975 {
 976         int result;
 977
 978         BT_CHECK_ENABLED_ANY(return);
 979
 980         BT_INIT_PARAMS();
 981         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 982
 983         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_ALLOW_BT_MODE,
 984                 in_param1, in_param2, in_param3, in_param4, &out_param);
 985
 986         if (result == BLUETOOTH_ERROR_NONE) {
 987                 if (out_param->len > 0) {
 988                         *value = g_array_index(out_param,
 989                                         int, 0);
 990                 } else {
 991                         BT_ERR("out_param length is 0!!");
 992                 }
 993         }
 994
 995         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 996
 997         return result;
 998 }
 999
1000 BT_EXPORT_API int bluetooth_dpm_set_profile_state(bt_dpm_profile_t profile, bt_dpm_status_t value)
1001 {
1002         int result;
1003
1004         BT_CHECK_ENABLED_ANY(return);
1005
1006         BT_INIT_PARAMS();
1007         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1008
1009         g_array_append_vals(in_param1, &profile, sizeof(int));
1010         g_array_append_vals(in_param2, &value, sizeof(int));
1011
1012         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_PROFILE_STATE,
1013                 in_param1, in_param2, in_param3, in_param4, &out_param);
1014
1015         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1016
1017         return result;
1018 }
1019
1020 BT_EXPORT_API int bluetooth_dpm_get_profile_state(bt_dpm_profile_t profile, bt_dpm_status_t *value)
1021 {
1022         int result;
1023
1024         BT_CHECK_ENABLED_ANY(return);
1025
1026         BT_INIT_PARAMS();
1027         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1028
1029         g_array_append_vals(in_param1, &profile, sizeof(int));
1030
1031         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_PROFILE_STATE,
1032                 in_param1, in_param2, in_param3, in_param4, &out_param);
1033
1034         if (result == BLUETOOTH_ERROR_NONE) {
1035                 if (out_param->len > 0) {
1036                         *value = g_array_index(out_param,
1037                                         int, 0);
1038                 } else {
1039                         BT_ERR("out_param length is 0!!");
1040                 }
1041         }
1042
1043         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1044
1045         return result;
1046 }
1047
1048 BT_EXPORT_API int bluetooth_dpm_set_desktop_connectivity_state(bt_dpm_status_t value)
1049 {
1050         int result;
1051
1052         BT_CHECK_ENABLED_ANY(return);
1053
1054         BT_INIT_PARAMS();
1055         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1056
1057         g_array_append_vals(in_param1, &value, sizeof(int));
1058
1059         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_DESKROP_CONNECTIVITY_STATE,
1060                 in_param1, in_param2, in_param3, in_param4, &out_param);
1061
1062         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1063
1064         return result;
1065 }
1066
1067 BT_EXPORT_API int bluetooth_dpm_get_desktop_connectivity_state(bt_dpm_status_t *value)
1068 {
1069         int result;
1070
1071         BT_CHECK_ENABLED_ANY(return);
1072
1073         BT_INIT_PARAMS();
1074         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1075
1076         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_DESKROP_CONNECTIVITY_STATE,
1077                 in_param1, in_param2, in_param3, in_param4, &out_param);
1078
1079         if (result == BLUETOOTH_ERROR_NONE) {
1080                 if (out_param->len > 0) {
1081                         *value = g_array_index(out_param,
1082                                         int, 0);
1083                 } else {
1084                         BT_ERR("out_param length is 0!!");
1085                 }
1086         }
1087
1088         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1089
1090         return result;
1091 }
1092
1093 BT_EXPORT_API int bluetooth_dpm_set_discoverable_state(bt_dpm_status_t value)
1094 {
1095         int result;
1096
1097         BT_CHECK_ENABLED_ANY(return);
1098
1099         BT_INIT_PARAMS();
1100         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1101
1102         g_array_append_vals(in_param1, &value, sizeof(int));
1103
1104         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_DISCOVERABLE_STATE,
1105                 in_param1, in_param2, in_param3, in_param4, &out_param);
1106
1107         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1108
1109         return result;
1110 }
1111
1112 BT_EXPORT_API int bluetooth_dpm_get_discoverable_state(bt_dpm_status_t *value)
1113 {
1114         int result;
1115
1116         BT_CHECK_ENABLED_ANY(return);
1117
1118         BT_INIT_PARAMS();
1119         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1120
1121         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_DISCOVERABLE_STATE,
1122                 in_param1, in_param2, in_param3, in_param4, &out_param);
1123
1124         if (result == BLUETOOTH_ERROR_NONE) {
1125                 if (out_param->len > 0) {
1126                         *value = g_array_index(out_param,
1127                                         int, 0);
1128                 } else {
1129                         BT_ERR("out_param length is 0!!");
1130                 }
1131         }
1132
1133         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1134
1135         return result;
1136 }
1137
1138 BT_EXPORT_API int bluetooth_dpm_set_limited_discoverable_state(bt_dpm_status_t value)
1139 {
1140         int result;
1141
1142         BT_CHECK_ENABLED_ANY(return);
1143
1144         BT_INIT_PARAMS();
1145         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1146
1147         g_array_append_vals(in_param1, &value, sizeof(int));
1148
1149         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_LIMITED_DISCOVERABLE_STATE,
1150                 in_param1, in_param2, in_param3, in_param4, &out_param);
1151
1152         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1153
1154         return result;
1155 }
1156
1157 BT_EXPORT_API int bluetooth_dpm_get_limited_discoverable_state(bt_dpm_status_t *value)
1158 {
1159         int result;
1160
1161         BT_CHECK_ENABLED_ANY(return);
1162
1163         BT_INIT_PARAMS();
1164         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1165
1166         g_array_append_vals(in_param1, &value, sizeof(int));
1167
1168         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_LIMITED_DISCOVERABLE_STATE,
1169                 in_param1, in_param2, in_param3, in_param4, &out_param);
1170
1171         if (result == BLUETOOTH_ERROR_NONE) {
1172                 if (out_param->len > 0) {
1173                         *value = g_array_index(out_param,
1174                                         int, 0);
1175                 } else {
1176                         BT_ERR("out_param length is 0!!");
1177                 }
1178         }
1179
1180         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1181
1182         return result;
1183 }
1184
1185 BT_EXPORT_API int bluetooth_dpm_set_data_transfer_state(bt_dpm_status_t value)
1186 {
1187         int result;
1188
1189         BT_CHECK_ENABLED_ANY(return);
1190
1191         BT_INIT_PARAMS();
1192         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1193
1194         g_array_append_vals(in_param1, &value, sizeof(int));
1195
1196         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_DATA_TRANSFER_STATE,
1197                 in_param1, in_param2, in_param3, in_param4, &out_param);
1198
1199         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1200
1201         return result;
1202 }
1203
1204 BT_EXPORT_API int bluetooth_dpm_get_data_transfer_state(bt_dpm_status_t *value)
1205 {
1206         int result;
1207
1208         BT_CHECK_ENABLED_ANY(return);
1209
1210         BT_INIT_PARAMS();
1211         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1212
1213         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_DATA_TRANSFER_STATE,
1214                 in_param1, in_param2, in_param3, in_param4, &out_param);
1215
1216         if (result == BLUETOOTH_ERROR_NONE) {
1217                 if (out_param->len > 0) {
1218                         *value = g_array_index(out_param,
1219                                         int, 0);
1220                 } else {
1221                         BT_ERR("out_param length is 0!!");
1222                 }
1223         }
1224
1225         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1226
1227         return result;
1228 }
1229 #endif /* #ifdef TIZEN_FEATURE_BT_DPM */