bt-api/bt-adapter-le.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *              http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <stdio.h>
  19 #include <vconf.h>
  20
  21 #include "bluetooth-api.h"
  22 #include "bt-internal-types.h"
  23
  24 #include "bt-common.h"
  25 #include "bt-request-sender.h"
  26 #include "bt-event-handler.h"
  27
  28 static gboolean is_le_scanning = FALSE;
  29
  30 BT_EXPORT_API int bluetooth_check_adapter_le(void)
  31 {
  32 #ifndef TIZEN_BLUEDROID_PORTING
  33         int ret;
  34         ret = _bt_get_adapter_path(_bt_get_system_common_conn(), NULL);
  35         return ret == BLUETOOTH_ERROR_NONE ? BLUETOOTH_ADAPTER_ENABLED :
  36                                                 BLUETOOTH_ADAPTER_DISABLED;
  37 #else
  38         int value = VCONFKEY_BT_LE_STATUS_OFF;
  39
  40         ret = vconf_get_int(VCONFKEY_BT_LE_STATUS, &value);
  41         if (ret != 0) {
  42                 BT_ERR("fail to get vconf key!");
  43                 return BLUETOOTH_ADAPTER_LE_DISABLED;
  44         }
  45
  46         BT_DBG("value : %d", value);
  47         return value == VCONFKEY_BT_LE_STATUS_ON ? BLUETOOTH_ADAPTER_LE_ENABLED :
  48                                                 BLUETOOTH_ADAPTER_LE_DISABLED;
  49 #endif
  50 }
  51
  52 BT_EXPORT_API int bluetooth_enable_adapter_le(void)
  53 {
  54         int result;
  55
  56         BT_INIT_PARAMS();
  57         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  58
  59         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ENABLE_ADAPTER_LE,
  60                 in_param1, in_param2, in_param3, in_param4, &out_param);
  61
  62         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  63         return result;
  64 }
  65
  66 BT_EXPORT_API int bluetooth_disable_adapter_le(void)
  67 {
  68         int result;
  69         retv_if(bluetooth_check_adapter_le() == BLUETOOTH_ADAPTER_LE_DISABLED,
  70                                 BLUETOOTH_ERROR_DEVICE_NOT_ENABLED);
  71
  72         BT_INIT_PARAMS();
  73         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  74
  75         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DISABLE_ADAPTER_LE,
  76                 in_param1, in_param2, in_param3, in_param4, &out_param);
  77
  78         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  79
  80         return result;
  81 }
  82
  83 void _bt_set_le_scan_status(gboolean mode)
  84 {
  85         BT_DBG("set LE scan mode : %d -> %d", is_le_scanning, mode);
  86         is_le_scanning = mode;
  87 }
  88
  89 BT_EXPORT_API gboolean bluetooth_is_le_scanning(void)
  90 {
  91         return is_le_scanning;
  92 }
  93
  94 BT_EXPORT_API int bluetooth_start_le_discovery(void)
  95 {
  96         int result;
  97         uid_t uid = getuid();
  98
  99         BT_CHECK_ENABLED_ANY(return);
 100
 101         BT_INIT_PARAMS();
 102         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 103
 104         g_array_append_vals(in_param1, &uid, sizeof(uid_t));
 105
 106         BT_INFO_C("### Start LE scan");
 107         _bt_print_api_caller_name();
 108         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_START_LE_DISCOVERY,
 109                 in_param1, in_param2, in_param3, in_param4, &out_param);
 110
 111         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 112
 113         if (result == BLUETOOTH_ERROR_NONE)
 114                 _bt_set_le_scan_status(TRUE);
 115
 116         return result;
 117 }
 118
 119 BT_EXPORT_API int bluetooth_set_le_scan_phy(bleutooth_le_scanning_phy_t phy)
 120 {
 121         int result;
 122
 123         BT_CHECK_ENABLED_ANY(return);
 124
 125         BT_INIT_PARAMS();
 126         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 127
 128         _bt_print_api_caller_name();
 129
 130         g_array_append_vals(in_param1, &phy, sizeof(int));
 131
 132         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_SCANNING_PHY,
 133                 in_param1, in_param2, in_param3, in_param4, &out_param);
 134
 135         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 136
 137         return result;
 138 }
 139
 140 BT_EXPORT_API int bluetooth_set_le_scan_role(bluetooth_le_scan_role_t role)
 141 {
 142         int result;
 143
 144         BT_CHECK_ENABLED_ANY(return);
 145
 146         BT_INIT_PARAMS();
 147         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 148
 149         _bt_print_api_caller_name();
 150
 151         g_array_append_vals(in_param1, &role, sizeof(int));
 152
 153         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_SCANNING_ROLE,
 154                 in_param1, in_param2, in_param3, in_param4, &out_param);
 155
 156         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 157
 158         return result;
 159 }
 160
 161 BT_EXPORT_API int bluetooth_stop_le_discovery(void)
 162 {
 163         int result;
 164         uid_t uid = getuid();
 165
 166         BT_CHECK_ENABLED_ANY(return);
 167
 168         BT_INIT_PARAMS();
 169         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 170
 171         g_array_append_vals(in_param1, &uid, sizeof(uid_t));
 172
 173         BT_INFO_C("### Stop LE scan");
 174         _bt_print_api_caller_name();
 175         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_STOP_LE_DISCOVERY,
 176                 in_param1, in_param2, in_param3, in_param4, &out_param);
 177
 178         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 179
 180         if (result == BLUETOOTH_ERROR_NONE)
 181                 _bt_set_le_scan_status(FALSE);
 182
 183         return result;
 184 }
 185
 186 BT_EXPORT_API int bluetooth_is_le_discovering(void)
 187 {
 188         int result;
 189         int is_discovering = FALSE;
 190
 191         BT_CHECK_ENABLED_ANY(return);
 192
 193         BT_INIT_PARAMS();
 194         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 195
 196         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_LE_DISCOVERYING,
 197                 in_param1, in_param2, in_param3, in_param4, &out_param);
 198
 199         if (result == BLUETOOTH_ERROR_NONE) {
 200                 is_discovering = g_array_index(out_param,
 201                                 int, 0);
 202         } else {
 203                 BT_ERR("Fail to send request");
 204         }
 205
 206         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 207
 208         return is_discovering;
 209 }
 210
 211 BT_EXPORT_API int bluetooth_is_scan_filter_supported(gboolean *is_supported)
 212 {
 213         int result;
 214
 215         BT_CHECK_PARAMETER(is_supported, return);
 216
 217         BT_INIT_PARAMS();
 218         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 219
 220         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_SCAN_FILTER_SUPPORTED,
 221                         in_param1, in_param2, in_param3, in_param4, &out_param);
 222
 223         if (result == BLUETOOTH_ERROR_NONE) {
 224                 *is_supported = g_array_index(out_param, int, 0);
 225                 BT_INFO("Scan Filter Support[%s]", *is_supported ? "TRUE" : "FALSE");
 226         } else
 227                 BT_ERR("Fail to send request");
 228
 229         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 230
 231         return result;
 232 }
 233
 234 BT_EXPORT_API int bluetooth_register_scan_filter(bluetooth_le_scan_filter_t *filter)
 235 {
 236         int result;
 237
 238         BT_CHECK_ENABLED_ANY(return);
 239
 240         BT_INIT_PARAMS();
 241         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 242
 243         g_array_append_vals(in_param1, filter, sizeof(bluetooth_le_scan_filter_t));
 244
 245         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_REGISTER_SCAN_FILTER,
 246                 in_param1, in_param2, in_param3, in_param4, &out_param);
 247
 248         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 249
 250         return result;
 251 }
 252
 253 gboolean __bluetooth_is_privileged_process(void)
 254 {
 255         FILE *fp = NULL;
 256         char path[30] = {0, };
 257         char buf[256] = {0, };
 258
 259         snprintf(path, sizeof(path), "/proc/%d/cmdline", getpid());
 260         fp = fopen(path, "r");
 261         if (fp == NULL)
 262                 return FALSE;
 263
 264         if (fgets(buf, 256, fp) != NULL) {
 265                 if (strstr(buf, "weconnd") != NULL) {
 266                         fclose(fp);
 267                         return TRUE;
 268                 }
 269         }
 270
 271         fclose(fp);
 272         return FALSE;
 273 }
 274
 275 BT_EXPORT_API int bluetooth_set_advertising(int handle, gboolean enable)
 276 {
 277         int result;
 278         gboolean use_reserved_slot = TRUE;
 279
 280         BT_CHECK_ENABLED_ANY(return);
 281
 282         if (TIZEN_PROFILE_WEARABLE)
 283                 use_reserved_slot = __bluetooth_is_privileged_process();
 284
 285         _bt_print_api_caller_name();
 286
 287         BT_INIT_PARAMS();
 288         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 289
 290         g_array_append_vals(in_param1, &handle, sizeof(int));
 291         g_array_append_vals(in_param2, &enable, sizeof(gboolean));
 292         g_array_append_vals(in_param3, &use_reserved_slot, sizeof(gboolean));
 293
 294         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_ADVERTISING,
 295                 in_param1, in_param2, in_param3, in_param4, &out_param);
 296
 297         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 298
 299         return result;
 300 }
 301
 302 BT_EXPORT_API int bluetooth_set_custom_advertising(int handle, gboolean enable,
 303                                                 bluetooth_advertising_params_t *params)
 304 {
 305         int result;
 306         gboolean use_reserved_slot = TRUE;
 307
 308         BT_CHECK_ENABLED_ANY(return);
 309
 310         if (TIZEN_PROFILE_WEARABLE)
 311         use_reserved_slot = __bluetooth_is_privileged_process();
 312
 313         _bt_print_api_caller_name();
 314
 315         BT_INIT_PARAMS();
 316         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 317
 318         g_array_append_vals(in_param1, &handle, sizeof(int));
 319         g_array_append_vals(in_param2, &enable, sizeof(gboolean));
 320         g_array_append_vals(in_param3, params, sizeof(bluetooth_advertising_params_t));
 321         g_array_append_vals(in_param4, &use_reserved_slot, sizeof(gboolean));
 322
 323         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_CUSTOM_ADVERTISING,
 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         return result;
 329 }
 330
 331 BT_EXPORT_API int bluetooth_get_advertising_data(bluetooth_advertising_data_t *adv_data, int *length)
 332 {
 333         int result;
 334         guint8 *data;
 335
 336         BT_CHECK_PARAMETER(adv_data, return);
 337         BT_CHECK_PARAMETER(length, return);
 338         BT_CHECK_ENABLED_ANY(return);
 339
 340         BT_INIT_PARAMS();
 341         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 342
 343         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_ADVERTISING_DATA,
 344                 in_param1, in_param2, in_param3, in_param4, &out_param);
 345
 346         if (result == BLUETOOTH_ERROR_NONE) {
 347                 data = &g_array_index(out_param, guint8, 0);
 348                 *length = out_param->len;
 349
 350                 memset(adv_data, 0x00, sizeof(bluetooth_advertising_data_t));
 351                 memcpy(adv_data->data, data, *length);
 352         }
 353
 354         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 355
 356         return result;
 357 }
 358
 359 BT_EXPORT_API int bluetooth_set_advertising_data(int handle,
 360                 const bluetooth_advertising_data_t *value, int length , bool is_legacy)
 361 {
 362         int result;
 363
 364         bluetooth_le_slot_and_adv_type_t rs_at;
 365         rs_at.is_legacy = is_legacy;
 366         rs_at.use_reserved_slot = TRUE;
 367
 368         int max_adv_data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX;
 369         /* TODO : Change to following once LE EXTENDED feature is supported
 370         int max_adv_data_len = is_legacy ? BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX : BLUETOOTH_EXTENDED_ADVERTISING_DATA_LENGTH_MAX; */
 371
 372         BT_CHECK_PARAMETER(value, return);
 373         BT_CHECK_ENABLED_ANY(return);
 374
 375         if (handle == 0) {
 376                 BT_ERR("Invalid handle value: %d", handle);
 377                 return BLUETOOTH_ERROR_INVALID_PARAM;
 378         }
 379
 380         if (length > max_adv_data_len- 3)
 381                 return BLUETOOTH_ERROR_INVALID_PARAM;
 382
 383         if (TIZEN_PROFILE_WEARABLE)
 384                 rs_at.use_reserved_slot = __bluetooth_is_privileged_process();
 385
 386         BT_INIT_PARAMS();
 387         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 388
 389         g_array_append_vals(in_param1, &handle, sizeof(int));
 390         g_array_append_vals(in_param2, value, sizeof(bluetooth_advertising_data_t));
 391         g_array_append_vals(in_param3, &length, sizeof(int));
 392         g_array_append_vals(in_param4, &rs_at, sizeof(bluetooth_le_slot_and_adv_type_t));
 393
 394         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_ADVERTISING_DATA,
 395                 in_param1, in_param2, in_param3, in_param4, &out_param);
 396
 397         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 398
 399         return result;
 400 }
 401
 402 BT_EXPORT_API int bluetooth_get_scan_response_data(bluetooth_scan_resp_data_t *value, int *length)
 403 {
 404         int result;
 405         guint8 *data;
 406
 407         BT_CHECK_PARAMETER(value, return);
 408         BT_CHECK_PARAMETER(length, return);
 409         BT_CHECK_ENABLED_ANY(return);
 410
 411         BT_INIT_PARAMS();
 412         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 413
 414         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_SCAN_RESPONSE_DATA,
 415                 in_param1, in_param2, in_param3, in_param4, &out_param);
 416
 417         if (result == BLUETOOTH_ERROR_NONE) {
 418                 data = &g_array_index(out_param, guint8, 0);
 419                 *length = out_param->len;
 420
 421                 memset(value, 0x00, sizeof(bluetooth_scan_resp_data_t));
 422                 memcpy(value->data, data, *length);
 423         }
 424
 425         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 426
 427         return result;
 428 }
 429
 430 BT_EXPORT_API int bluetooth_set_scan_response_data(int handle,
 431                         const bluetooth_scan_resp_data_t *value, int length)
 432 {
 433         int result;
 434         gboolean use_reserved_slot = TRUE;
 435
 436         BT_CHECK_PARAMETER(value, return);
 437         BT_CHECK_ENABLED_ANY(return);
 438
 439         if (length > BLUETOOTH_SCAN_RESP_DATA_LENGTH_MAX)
 440                 return BLUETOOTH_ERROR_INVALID_PARAM;
 441
 442         if (TIZEN_PROFILE_WEARABLE)
 443                 use_reserved_slot = __bluetooth_is_privileged_process();
 444
 445         BT_INIT_PARAMS();
 446         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 447
 448         g_array_append_vals(in_param1, &handle, sizeof(int));
 449         g_array_append_vals(in_param2, value, length);
 450         g_array_append_vals(in_param3, &length, sizeof(int));
 451         g_array_append_vals(in_param4, &use_reserved_slot, sizeof(gboolean));
 452
 453         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_SCAN_RESPONSE_DATA,
 454                 in_param1, in_param2, in_param3, in_param4, &out_param);
 455
 456         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 457
 458         return result;
 459 }
 460
 461 BT_EXPORT_API int bluetooth_set_scan_parameters(bluetooth_le_scan_params_t *params)
 462 {
 463         int result;
 464
 465         BT_CHECK_ENABLED_ANY(return);
 466
 467         BT_INIT_PARAMS();
 468         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 469
 470         g_array_append_vals(in_param1, params, sizeof(bluetooth_le_scan_params_t));
 471
 472         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_SCAN_PARAMETERS,
 473                 in_param1, in_param2, in_param3, in_param4, &out_param);
 474
 475         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 476
 477         return result;
 478 }
 479
 480 BT_EXPORT_API int bluetooth_set_scan_type(bluetooth_le_scan_type_t scan_type)
 481 {
 482         int result;
 483
 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, &scan_type, sizeof(int));
 490
 491         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_SCAN_TYPE,
 492                 in_param1, in_param2, in_param3, in_param4, &out_param);
 493
 494         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 495
 496         return result;
 497 }
 498
 499 BT_EXPORT_API int bluetooth_is_advertising(gboolean *is_advertising)
 500 {
 501         int result;
 502
 503         BT_CHECK_ENABLED_ANY(return);
 504
 505         BT_INIT_PARAMS();
 506         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 507
 508         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_ADVERTISING,
 509                 in_param1, in_param2, in_param3, in_param4, &out_param);
 510
 511         if (result == BLUETOOTH_ERROR_NONE)
 512                 *is_advertising = g_array_index(out_param, int, 0);
 513         else
 514                 BT_ERR("Fail to send request");
 515
 516         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 517
 518         return result;
 519 }
 520
 521 BT_EXPORT_API int bluetooth_add_allow_list(bluetooth_device_address_t *address, bluetooth_device_address_type_t address_type)
 522 {
 523         int result;
 524
 525         BT_CHECK_PARAMETER(address, return);
 526         BT_CHECK_ENABLED_ANY(return);
 527
 528         BT_INIT_PARAMS();
 529         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 530
 531         g_array_append_vals(in_param1, address, sizeof(bluetooth_device_address_t));
 532         g_array_append_vals(in_param2, &address_type, sizeof(int));
 533
 534         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ADD_ALLOW_LIST,
 535                 in_param1, in_param2, in_param3, in_param4, &out_param);
 536
 537         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 538
 539         return result;
 540 }
 541
 542 BT_EXPORT_API int bluetooth_remove_allow_list(bluetooth_device_address_t *address, bluetooth_device_address_type_t address_type)
 543 {
 544         int result;
 545
 546         BT_CHECK_PARAMETER(address, return);
 547         BT_CHECK_ENABLED_ANY(return);
 548
 549         BT_INIT_PARAMS();
 550         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 551
 552         g_array_append_vals(in_param1, address, sizeof(bluetooth_device_address_t));
 553         g_array_append_vals(in_param2, &address_type, sizeof(int));
 554
 555         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_REMOVE_ALLOW_LIST,
 556                 in_param1, in_param2, in_param3, in_param4, &out_param);
 557
 558         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 559
 560         return result;
 561 }
 562
 563 BT_EXPORT_API int bluetooth_clear_allow_list(void)
 564 {
 565         int result;
 566
 567         BT_CHECK_ENABLED_ANY(return);
 568
 569         BT_INIT_PARAMS();
 570         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 571
 572         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_CLEAR_ALLOW_LIST,
 573                 in_param1, in_param2, in_param3, in_param4, &out_param);
 574
 575         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 576
 577         return result;
 578 }
 579
 580 BT_EXPORT_API int bluetooth_enable_le_privacy(gboolean enable_privacy)
 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         g_array_append_vals(in_param1, &enable_privacy, sizeof(gboolean));
 590
 591         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_LE_PRIVACY,
 592                 in_param1, in_param2, in_param3, in_param4, &out_param);
 593
 594         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 595
 596         return result;
 597 }
 598
 599 BT_EXPORT_API int bluetooth_set_le_static_random_address(gboolean enable)
 600 {
 601         int result;
 602
 603         BT_CHECK_ENABLED_ANY(return);
 604
 605         BT_INIT_PARAMS();
 606         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 607
 608         g_array_append_vals(in_param1, &enable, sizeof(gboolean));
 609
 610         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_LE_STATIC_RANDOM_ADDRESS,
 611                 in_param1, in_param2, in_param3, in_param4, &out_param);
 612
 613         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 614
 615         return result;
 616 }
 617
 618 BT_EXPORT_API int bluetooth_check_privilege_advertising_parameter(void)
 619 {
 620         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_SET_ADVERTISING_PARAMETERS)
 621                      == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 622                 BT_ERR("Don't have a privilege to use this API");
 623                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 624         }
 625
 626         return BLUETOOTH_ERROR_NONE;
 627 }
 628
 629 BT_EXPORT_API int bluetooth_le_register_callback(bluetooth_cb_func_ptr callback_ptr, void *user_data)
 630 {
 631         int ret;
 632
 633         ret = _bt_register_event(BT_LE_ADAPTER_EVENT, (void *)callback_ptr, user_data);
 634         if (ret != BLUETOOTH_ERROR_NONE &&
 635             ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
 636                 BT_ERR("Fail to register BT_LE_ADAPTER_EVENT event : %d", ret);
 637                 return ret;
 638         }
 639
 640         return BLUETOOTH_ERROR_NONE;
 641 }
 642
 643 BT_EXPORT_API int bluetooth_le_unregister_callback(void)
 644 {
 645         _bt_unregister_event(BT_LE_ADAPTER_EVENT);
 646
 647         return BLUETOOTH_ERROR_NONE;
 648 }
 649
 650 BT_EXPORT_API int bluetooth_le_read_maximum_data_length(
 651                         bluetooth_le_read_maximum_data_length_t *max_le_datalength)
 652 {
 653         BT_CHECK_ENABLED_ANY(return);
 654         BT_INIT_PARAMS();
 655         int result;
 656         bluetooth_le_read_maximum_data_length_t *datalength = NULL;
 657
 658         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 659
 660         result = _bt_send_request(BT_BLUEZ_SERVICE,
 661                 BT_LE_READ_MAXIMUM_DATA_LENGTH,
 662                 in_param1, in_param2, in_param3, in_param4, &out_param);
 663
 664         if (result == BLUETOOTH_ERROR_NONE) {
 665                 datalength = &g_array_index(out_param,
 666                         bluetooth_le_read_maximum_data_length_t, 0);
 667                 max_le_datalength->max_tx_octets  = datalength->max_tx_octets;
 668                 max_le_datalength->max_tx_time = datalength->max_tx_time;
 669                 max_le_datalength->max_rx_octets = datalength->max_rx_octets;
 670                 max_le_datalength->max_rx_time = datalength->max_rx_time;
 671         }
 672
 673         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 674
 675         return result;
 676 }
 677
 678 BT_EXPORT_API int bluetooth_le_write_host_suggested_default_data_length(
 679         const unsigned int def_tx_Octets, const unsigned int def_tx_Time)
 680 {
 681         BT_CHECK_ENABLED_ANY(return);
 682         BT_INIT_PARAMS();
 683
 684         int result;
 685
 686         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 687
 688         g_array_append_vals(in_param1, &def_tx_Octets, sizeof(guint));
 689         g_array_append_vals(in_param2, &def_tx_Time, sizeof(guint));
 690
 691         result = _bt_send_request(BT_BLUEZ_SERVICE,
 692                 BT_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH,
 693                 in_param1, in_param2, in_param3, in_param4, &out_param);
 694
 695         if (result != BLUETOOTH_ERROR_NONE)
 696                 BT_ERR("Failed to Write the host suggested default data length values : %d", result);
 697
 698         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 699
 700         return result;
 701 }
 702
 703 BT_EXPORT_API int bluetooth_le_read_suggested_default_data_length(
 704         bluetooth_le_read_host_suggested_data_length_t *le_data_length)
 705 {
 706         BT_CHECK_ENABLED_ANY(return);
 707         BT_INIT_PARAMS();
 708
 709         int result;
 710         bluetooth_le_read_host_suggested_data_length_t *data_values = NULL;
 711         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 712
 713         result = _bt_send_request(BT_BLUEZ_SERVICE,
 714                 BT_LE_READ_HOST_SUGGESTED_DATA_LENGTH,
 715                 in_param1, in_param2, in_param3, in_param4, &out_param);
 716
 717         if (result == BLUETOOTH_ERROR_NONE) {
 718                 data_values = &g_array_index(out_param,
 719                         bluetooth_le_read_host_suggested_data_length_t, 0);
 720
 721                 le_data_length->def_tx_octets = data_values->def_tx_octets;
 722                 le_data_length->def_tx_time = data_values->def_tx_time;
 723         }
 724
 725         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 726
 727         return result;
 728 }
 729
 730 BT_EXPORT_API int bluetooth_le_set_data_length(bluetooth_device_address_t *address,
 731         const unsigned int max_tx_octets, const unsigned int max_tx_time)
 732 {
 733         BT_CHECK_ENABLED_ANY(return);
 734         BT_INIT_PARAMS();
 735
 736         int result;
 737
 738         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 739
 740         g_array_append_vals(in_param1, address, sizeof(bluetooth_device_address_t));
 741         g_array_append_vals(in_param2, &max_tx_octets, sizeof(guint));
 742         g_array_append_vals(in_param3, &max_tx_time, sizeof(guint));
 743
 744         result = _bt_send_request(BT_BLUEZ_SERVICE,
 745                 BT_LE_SET_DATA_LENGTH,
 746                 in_param1, in_param2, in_param3, in_param4, &out_param);
 747
 748         if (result != BLUETOOTH_ERROR_NONE)
 749                 BT_ERR("Failed to Set data length values : %d", result);
 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_is_le_2m_phy_supported(gboolean *is_supported)
 757 {
 758         int result;
 759
 760         BT_CHECK_PARAMETER(is_supported, return);
 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_IS_LE_2M_PHY_SUPPORTED,
 767                         in_param1, in_param2, in_param3, in_param4, &out_param);
 768
 769         if (result == BLUETOOTH_ERROR_NONE) {
 770                 *is_supported = g_array_index(out_param, int, 0);
 771         } else {
 772                 BT_ERR("Fail to send request");
 773         }
 774
 775         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 776
 777         BT_INFO("LE 2M PHY Support[%s]", *is_supported ? "TRUE" : "FALSE");
 778         return result;
 779 }
 780
 781 BT_EXPORT_API int bluetooth_is_le_coded_phy_supported(gboolean *is_supported)
 782 {
 783         int result;
 784
 785         BT_CHECK_PARAMETER(is_supported, return);
 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_IS_LE_CODED_PHY_SUPPORTED,
 792                         in_param1, in_param2, in_param3, in_param4, &out_param);
 793
 794         if (result == BLUETOOTH_ERROR_NONE) {
 795                 *is_supported = g_array_index(out_param, int, 0);
 796         } else {
 797                 BT_ERR("Fail to send request");
 798         }
 799
 800         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 801
 802         BT_INFO("LE CODED PHY Support[%s]", *is_supported ? "TRUE" : "FALSE");
 803         return result;
 804 }
 805
 806 BT_EXPORT_API int bluetooth_is_le_extended_advertising_supported(gboolean *is_supported)
 807 {
 808         int result;
 809
 810         BT_CHECK_PARAMETER(is_supported, return);
 811         BT_CHECK_ENABLED_ANY(return);
 812
 813         BT_INIT_PARAMS();
 814         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 815
 816         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_LE_EXTENDED_ADVERTISING_SUPPORTED,
 817                         in_param1, in_param2, in_param3, in_param4, &out_param);
 818
 819         if (result == BLUETOOTH_ERROR_NONE) {
 820                 *is_supported = g_array_index(out_param, int, 0);
 821         } else {
 822                 BT_ERR("Fail to send request");
 823         }
 824
 825         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 826
 827         BT_INFO("LE Extended Advertising Support[%s]", *is_supported ? "TRUE" : "FALSE");
 828         return result;
 829 }
 830
 831 BT_EXPORT_API int bluetooth_is_le_extended_scan_supported(gboolean *is_supported)
 832 {
 833         int result;
 834
 835         BT_CHECK_PARAMETER(is_supported, 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         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_LE_EXTENDED_SCAN_SUPPORTED,
 842                         in_param1, in_param2, in_param3, in_param4, &out_param);
 843
 844         if (result == BLUETOOTH_ERROR_NONE) {
 845                 *is_supported = g_array_index(out_param, int, 0);
 846         } else {
 847                 BT_ERR("Fail to send request");
 848         }
 849
 850         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 851
 852         BT_INFO("LE Extended Scan Support[%s]", *is_supported ? "TRUE" : "FALSE");
 853         return result;
 854 }
 855
 856 BT_EXPORT_API int bluetooth_le_get_maximum_advertising_data_length(gint *data_length)
 857 {
 858         int result;
 859
 860         BT_CHECK_PARAMETER(data_length, return);
 861         BT_CHECK_ENABLED_ANY(return);
 862
 863         BT_INIT_PARAMS();
 864         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 865
 866         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_LE_MAX_ADVERTISING_DATA_LEN,
 867                         in_param1, in_param2, in_param3, in_param4, &out_param);
 868
 869         if (result == BLUETOOTH_ERROR_NONE) {
 870                 *data_length = g_array_index(out_param, int, 0);
 871         } else {
 872                 BT_ERR("Fail to send request");
 873         }
 874
 875         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 876
 877         BT_INFO("LE Max Advertising Data Length [%d]", *data_length);
 878         return result;
 879 }