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