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